Python学习/复习日记

前言

为什么要写这个呢，原因是暑假从同学那借来了一本python教程书，然而借来的东西总是要还的，总不可能一个字没看又还回去了吧。。所以现在让我们试试一天速成python基础吧。

基础部分

变量与基础数据类型

Python 不需要像 c语言 那样写变量类型声明，直接赋值即可

#声明一个整型变量
a=123
#声明一个浮点型变量
b=1.23
#声明一个字符串
c="hello world"
c='hello world'
c='''使用三单引号
可以快速声明多行字符串
就像这样
'''
#python中的变量是可以重定义类型的，比如：
a=123
a="234"#a本来是整型，到这里重新赋值成了一个字符串
#顺带说明，python里#代表单行注释
#多行注释可以用三单引号'''括起来
c=r"使用r前缀（Raw Text）可以禁止所有的\转义，同样一个字符串，用r前缀写可以省不少事，比如："
c="http:\\\\img.hongyoubizhi.com\\picture\\pages\\original\\2023\\10\\25\\15\\115565344_p0.jpg"
c=r"http:\\img.hongyoubizhi.com\picture\pages\original\2023\10\25\15\115565344_p0.jpg"

变量名命名规则，这方面与c差不多，不允许短横线，不允许空格，不允许数字开头，不允许特殊字符，不允许关键字（存疑）

关于关键字，虽然语法上确实可以使用比如int，float之类的自带函数作为变量名，但是像import，for，while，as，with，del之类的是没法作为变量名使用的

int=123#虽然可以这样用，但是int的函数功能就被覆写了
print(int)
a=int(123.3)#会报错：'int' object is not callable
#解决方法是使用del删除一次int的定义，才能正常调用int
del int
a=int(123.3)

基础运算

整型与浮点型之间可以进行如下运算：

#整型与整型
1+1
2-1
2*2
5/2
5//2
5%2
5**2
4^92#异或
3|1234#并
2431&1213#与
#整型与浮点型
1+1.1
2-1.1
2*1.1
5/2.0
5**0.5
#浮点与浮点
1.2+2.5
2.4-1.2
2.3*3.5
1.4/3.4
1.3**0.5
#字符串与字符串
"123"+"456"
#字符串与整型
"123"*2
#值得注意的是，上述运算方式全可以用<运算符>=的方式实现变量自操作
#比如：
a=1
a+=1
a-=2
a*=3
a/=4
a//=5
a=9
a%=6
a**=2#没错，幂运算也能这样自操作
a^=6
a|=7
a&=10
s="123"
s+="122"
s*=2

类型转换

python中的类型转换与c差不多，但是只能以函数的方式转换：

#整型、浮点型转字符串
a=str(123)
a=str(1.23)
#字符串转整型
a=int("123")
#字符串转浮点
a=float("1.23")
#浮点型转整型（“向0”取整（去小数部分），正数时和floor()表现一样
a=int(1.23)#->1
a=int(-1.23)#->1

Hello world

print()函数：每次输出一个字符串后换行

print(123)
print(124.6789)
print("Hello world")

input()函数：接受用户一次输入（按用户的回车计，复制粘贴的回车也算一次，以字符串形式返回

a=input()#里面也可以写上字符串作为输入提示的信息
print(a)
b=input("请输入一个整数")
print(int(b)+123)

关于print还有更多参数可以使用，这里留到后面的函数章节来讲

字符串

字符串长度获取：len()

print(len("abcdef"))#->6

字符串下标引用：

下标从0开始，s[2]表示字符串下标为2的字符；下标可以为负数，s[-1]表示字符串倒数第1个字符

字符串切片：

基本形式：s[start:end]

左闭右开，返回一个从下标start到下标end（不包含end对应的字符）的子串

带步长的形式：s[start:end:step]

也是左闭右开，返回从下标start开始，每次取完一个字符后，当前下标加上step，一直取到刚好等于end为止（不包含end对应的字符），比如a[1:10:2]

为什么要用这么冗长的定义解释？因为步长也可以是负数，比如a[10:1:-1]

a="hello 2024"
#"hello 2024"
# 0123456789
#  1 3
print(a[1:3])#->'el'
#"hello 2024"
# 0123456789
#  e l   0  
print(a[1:9:2])#->'el 0'
#"hello 2024"
# 0123456789
#   llo 2024
print(a[9:1:-1])#->'4202 oll'
#需要注意的是，":"左右是可选的参数，也就是说，你可以使用a[:]表示a的一个拷贝
#也可以使用a[::-1]表示a的反转字符串
#a[3:]代表从下标3开始往后一直截取
#a[:5]代表截取到下标5的上一个下标为止

列表 (list或者叫数组)

列表的声明

#直接使用[]声明
a=[1,2,3]
print(a)
#使用list()构造
a=list()
print(a)
#使用*构造（关于这种构造要慎用，后面进阶篇会提到注意事项）
a=[0]*10
print(a)
#使用for构造
a=[i for i in range(0,10)]
print(a)
#列表内元素的类型不一定都相同，可以是整型，浮点型，字符串甚至是一个列表
a=[1,2,3.4,"5",[6,7]]
print(a)

列表的访问，插入与删除

#========直接在变量名后加"[下标]"即可访问列表的该下标的数
a=[2*i for i in range(0,10)]
a[2]=-2
print(a)
print(a[3])
#=======可以是负数下标
a=[1,2,3,4,5,6,7,8]
print(a[-1])#倒数第一个元素
print(a[-3])#倒数第三个元素

#===========使用append()一次添加一个元素
a=[2]
a.append(12)
a.append(22)
print(a)
#===========使用extend()一次添加多个元素
a=[1]
a.extend([1,2,3])
print(a)
a.extend([1])
a.extend([])#可以为空
print(a)
a.extend((1,2,3))#*或者是一个元组
a.extend({1,2,3})#*一个set集合
a.extend({1:2,3:4})#*一个字典
#理论上只要是带有iterable属性的变量，就可以丢到这个extend里
#至于iterable，留到后面进阶篇
print(a)
#============使用+运算符进行列表拼接
a=[3]
a=a+[4]
a+=[7]
a+=[1,2,3]
print(a)
#============使用insert()向指定下标处插入一个值
a=[0,1,2,3,4,5,6]
a.insert(2,99)
print(a)#->[0,1,99,2,3,4,5,6]

#===========使用del关键字进行删除
a=[0,1,2,3,4,5,6]
del a[4]
print(a)
#===========使用pop()按下标进行删除
a=[0,1,2,3,4,5,6,7,8,9]
a.pop()#删除列表尾元素
print(a)
print(a.pop())#pop()会返回所删除元素的值
a.pop(2)#指定下标删除
print(a)
#===========使用remove按值删除
a=[0,1,2,3,1,4,5,7]
a.remove(1)#删除第一个出现的1
print(a)

库

库的引用

#使用import关键字进行库的引用
import math
print(math.ceil(1.1))#上取整

#加上as关键字更换引用库函数时的名称
import math as m
print(m.floor(1.9))#下取整

#引用库时省略库名称的方法
import math as *
print(sin(6))

#只引用库里面的某个函数
from math import exp
print(exp(4))#取指数

#引用库时省略库名称的方法2
from math import *
print(pi)#圆周率

#引用多个库
import math,random
print(random.randint(1,100))#[1,100]中的一个随机数
#或者直接列
import math
import random
import sys
print(123)
sys.exit()#提前结束程序，后面的456不会被打印
print(456)

第三方库的安装

有时候上网复制的代码运行后会出现：

Traceback (most recent call last):
  File "E:\Desktop\Blank.py", line 1, in <module>
    import xxx
ModuleNotFoundError: No module named 'xxx'

这种报错一般是没有安装第三方库造成的，解决方法是用pip手动安装，安装分为在线安装和离线安装。

在线安装：在线win+r键打开cmd窗口，然后用pip install <目标模块名>即可

离线安装：去下载符合当前系统版本对应的离线包xxx，放到pip所在的文件夹，然后用pip install xxx即可（也可以不放到pip所在文件夹，直接pip install <完整路径>即可

安装完之后就可以直接import xxx导入了

逻辑控制流语句

和c很像，但是删了switch-case语句

python中的布尔值：True，False（注意，python对大小写敏感，这意味着你不能使用true，false作为替代品

比较操作符：

通过比较操作符可以比较两个变量，并返回一个布尔值

tips: 可以使用in和not in关键字来判断列表中是否有某元素

a=[1,2,3]
print(1 in a)
print(4 in a)
print(5 not in a)
print(2 not in a)

布尔值运算：

(a>1) and (a<10)#逻辑与 也可以用&
(a<1) or (a>10)#逻辑或 也可以用|
not (a>1)#逻辑取反
(a>1)^(b>1)#逻辑异或

if 判断语句：

python对代码缩进有严格要求，因为它就是靠着缩进来划分代码块（作用域）的，每个控制流语句都有自己负责的代码块（作用域）

#if <条件>:
#    <执行语句>
if a==b:
    print("a等于b")
#if <条件>:
#   <执行语句1>
#else:
#   <执行语句2>
if a>b:
    print("a大于b")
else:
    print("a小于等于b")
#if <条件1>:
#   <执行语句1>
#elif <条件2>:
#   <执行语句2>
#else:#这个else是可选的
#   <执行语句3>
if (a>10) and (a<100):
    print("a在10到100之间")
elif a>b:
    print("a大于b")
#当然也可以用下面的方式表示范围
#这在c中是无法达到预期目的的，但是python对此做了优化
if 10<a<100:
    print("a在10到100之间")

while 循环语句：

#while <条件>:
#   <执行语句>
a=10
while a>1:
    print(a)

for 循环语句

#for <变量名> in <范围>:
#   <执行语句>
#其中范围可以使用range(1,10)生成，表示，从1到10（左闭右开）
#range(n)表示从0到n（左闭右开）
#range(10,1,-1)表示从10到1
#range范围和字符串切片很像
for i in range(1,9):
    print(i)

#范围也可以是列表或元组
a=[1,2,3,6,8,4,8,3]
for i in a:
    print(i)
for j in (6,"we",6,1,9,6,2):
    print(j)

break与continue

#break是跳出for和while循环用的
#continue是提前结束当前for，while循环用的，将程序重新导向下一次循环开始的条件判断部分
a=123
while True:
    if a==0:
        break
    a+=1

for i in range(1,100):
    if i%2==0:
        continue
    print(i)

函数

函数的声明与调用：

#def <函数名>(<参数列表(选填)>):
#   <执行语句>
#...
#<函数名>(参数列表)#在某处调用
def myfunc():
    print("This is a instance for function call.")
    print("You can achieve almost anything with it.")
myfunc()
#传参
def myfunc(value):#python的变量可以是任何类型，所以不需要为形参声明类型
    print("You put a ",value," in!")
myfunc(123)
myfunc("cat")
#多个参数
def myfunc(a,b,c):
    print(c,b,a)
myfunc(1,2.3,"4")
#默认参数的设置
def myfunc(a,b=123):
    print(a,b)
myfunc("传参时传入了b的值，默认参数值123未被使用，b=","22")
myfunc("传参时默认参数值被使用,，b=")
#指定默认参数
def myfunc(a,b=123,c=345,d=567):
    print(a,b,c,d)
myfunc(33,c=99)#在调用时使用 <形参名>=<值> 即可指定更改默认参数

上面是无返回值函数，下面来介绍有返回值函数

#和无返回值函数差不多，只是多了一句return以返回一个值或多个值
def myfunc():
    return 123
a=myfunc()
print(a)
print(myfunc())
#可以返回多个值
def myfunc():
    return 1,2.2,"3"
a,b,c=myfunc()
print(c,b,a)
print(myfunc())
print(myfunc()[1])
#若试图使用变量接收无返回值函数的值，返回值为None
def myfunc():
    print(1+2)
a=myfunc()
print(a==None)

函数的作用域：

#在函数最外面（全局作用域）声明的变量统称为全局变量，这些变量可在任意位置调用
#在函数内部（局部作用域）声明的变量统一叫局部变量，这些变量只能在函数内部使用

a=234#全局变量
def f():
    b=123#局部变量

#变量的引用：父作用域无法用任何方式调用子作用域和其他同级作用域的变量
#但子作用域可以获得父作用域的变量，但无法修改
a=123
def g():
    print(a)#子作用域获得父作用域的变量
    b=12
g()
print()#父作用域无法调用子作用域的变量

def f():
    def g():
        a=123
    g()
    def h():
        print(a)#h与g同级，h获取不了g的变量a
    h()
f()
#在任意作用域中使用global关键字可将变量声明在全局作用域
def f():
    global a
    a=123
f()
print(a)

#一般来说，在不使用global的情况下，重名的变量在作用域中有着“就近原则”
x=123
def f():
    x=456
    print(x)#->456#x在作用域内重新声明，用作用域内的x
print(x)#->123

函数的递归

#直接在函数内部调用函数本身称为递归，注意设置终止条件，不要超过递归上限
a=[0]*11
def f(x):
    if(x==0 or x==1):#终止条件
        a[x]=1
        return 1
    a[x]=f(x-1)+f(x-2)#递归调用
    return f(x-1)+f(x-2)
f(10)
print(a)

一些默认函数的用法：

print(1,2,3,4,5,sep="-")#->1-2-3-4-5
print("text",end="")#->text（无换行）
print("123",file="tmp.txt")#将输出导向tmp.txt文件
print("456",flush=True)#每次print后清空缓存区（暂时不知道用处
int("123")#字符串/浮点转整型
float("1.2")#整型/字符串转浮点
str(123)#整型/浮点转字符串
bin(123)#->'0b1111011'#整型转二进制表示(返回字符串)
hex(123)#->'0x7b'#整型转十六进制表示
chr(67)#->'C'#Unicode编码转字符

异常处理

#使用try,except关键字可以处理各种异常,而不是直接结束程序
a=0
try:
    print(123/a)
except:
    print("something wrong")
print("go on")

#在except后面跟上错误类型即可对不同错误分类处理
import sys
print("除法计算器v0.0.1，按Ctrl+C退出")
while True:
    try:
        a=int(input("输入被除数："))
        print(a/int(input("输入除数：")))
    except ZeroDivisionError:#除0错误
        print("-+"[a>=0]+"inf")
    except ValueError:#值错误(如果用户输入含有非数字，那么int()那会报这个错)
        print("输入格式有误，请重试！")
        continue
    except KeyboardInterrupt:#键盘输入被干扰（用户在输入时按下Ctrl+C会发生这个错误）
        print("感谢你的使用！")
        sys.exit()

异常的获取：

每条错误信息的最后一行开头就是错误类型

Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    int("a")
ValueError: invalid literal for int() with base 10: 'a'

通过大量地尝试各种输入，记录所有错误信息的种类并写出处理方法，即可写出较为完善的程序

进阶篇

列表再引入

列表的其他操作

#len()函数获取列表长度
a=[1,2,3,4,5,123]
print(len(a))

#clear()用于清空列表
a=[1,2,3,4,5]
a.clear()
print(a)

#copy()返回列表的一个拷贝
#这个等下讲

#count()统计列表中的元素出现次数
a=[1,1,4,5,1,4]
print(a.count(1))

#index()返回列表中某元素第一次出现的下标
a=[1,2,3,4,5,6,2,3,4]
print(a.index(2))

#reverse()使列表反转
a=[1,2,3,4,5]
a.reverse()
print(a)

#sort()列表排序（升序）
a=[1,5,2,4,3]
a.sort()
print(a)
#用reverse使其降序
a=[1,5,2,4,3]
a.sort(reverse=True)
print(a)
#*传入一个函数使其按指定规则排序
def f(z):
    return z[1]
a=[[1,2],[9,1],[5,3]]
a.sort(key=f)#这里使用key=f将函数方法f传入，因此a列表在排序时会先将每个元素z映射为f(z)，再排序
print(a)
#*传入一个lambda函数使其按指定规则排序
a=[[1,2],[9,1],[5,3]]
a.sort(key=lambda x:(x[1],x[0]))#先按下标1排序，再按下标0排序
print(a)

#列表解包，多个变量用逗号连接，可一次性为这些变量赋值
#============你可能在用这种===========#
a=["alice","bob","candy"]
x=a[0]
y=a[1]
z=a[2]
#============但其实可以这样===========#
a=["alice","bob","candy"]
x,y,z=a

#通过enumerate()函数返回索引与元素
a=["alice","bob","candy"]
for index,person in enumerate(a):
    print("The "+str(index)+"th person is "+person)

#引入random库后，可使用choice()和shuffle对列表进行随机操作
import random
a=["alice","bob","candy"]
print(random.choice(a))#随机选取一个元素
random.shuffle(a)#打乱列表，随机排序

序列数据类型

按序列表示值的数据类型除了列表，还有字符串，range()生成的范围对象，元组。对列表进行的大多操作均可用在这些类型上，比如按索引取值，切片，for循环，len()函数取长度，用于in和not in

姑且先放这么多，剩下的下次接着更新