python程序设计笔记

前言

有关python程序设计的一些笔记。

略去了与大计基重复的前置部分。

2024.3.27开始创作，持续更新。

运算

优先级表

运算类型	符号	含义	优先级
括号运算	()	括号	0
幂运算	**	乘方	1
算数运算	*、/、//、%	乘、除、整除、取模	2
算数运算	+、-	加、减	3
位运算	>>、<<	右移、左移	4
位运算	&	二进制与	5
位运算	^	二进制异或	6
位运算	|	二进制或	7
比较运算	>、>=、==、<=、<、!=、in、not in、is、is not	大于、大于等于、等于、小于等于、小于、不等于、属于、不属于、对象相同、对象不同	8
逻辑运算	not	逻辑非	9
逻辑运算	and	逻辑与	10
逻辑运算	or	逻辑或	11

短路运算

出现在or与and运算中

进行 A or B运算时，若A为真，则不用考虑B。

同理，A and B运算时，若A为假，则不用考虑B。

即使后面的判断中存在报错，也不予考虑。

简化运算

A > B > C #表示 A > B and B > C
x in S == False #表示 x in S and S == False

数据结构

有序性与可变性

有序性是指数据结构元素索引间是否有逻辑关系。

可变性是指数据结构能否被改变。

是否有序	对象	是否可变
有序	字符串	不可变
有序	元组	不可变
有序	列表	可变
无序	集合	可变
无序	字典	可变

序列

序列介绍

包括字符串、列表、元组。

range()函数产生数字序列对象，for语句可遍历range，不需要用list()转换为列表。

序列索引

正向索引	1	2	...	n-2	n-1
逆向索引	-n+1	-n+2	...	-2	-1

序列操作

操作	含义	实例	结果	提醒
x in s	x是否是s的元素	1 in [1,2,3] [1,2] in [1,2,3]	True False	实例2中，[1,2]为一个元素，没有在原列表中
x not in s	x是否不是s的元素	1 not in [1,2,3]	False
s+t	连接序列s与t	[1]+[2,3]	[1,2,3]	range不支持
s*n/n*s	将s复制n次	[1,2,3]*2 2*[1,2,3]	[1,2,3,1,2,3] [1,2,3,1,2,3]	range不支持
s[i]	返回序列第i个元素	"123"[1]	"2"
s[i:j]	返回序列下标[i,j)的切片	"123"[0:2] "123"[1:] "123"[:2] "123"[-1:-3]	"12" "23" "12" ""	若步幅与起点终点反向，则会返回空字符串
s[i:j:k]	步幅为k的切片	"123"[0:3:2] "123"[-1:-3:-1]	"13" "32"
len(s)	s的元素个数（长度）	len("123")	3
min(s)	最小值	min([1,2,3])	1
max(s)	最大值	max([1,2,3])	3
sorted(s)	返回排序结果	sorted([2,3,1])	[1,2,3]	排序不改变原对象
s.index(x[,i[,j]])	从i到j第一次出现x的位置	[1,2,3].index(2,0,3) [1,2,3].index(4)	1 ValueError	若没有x会报错；始末位置可有可无
s.count(x)	s中x的个数	[1,1,4,5,1,4].count(1) "11111".count("11") [1].count(2)	3 2 0	找到一个之后，从当前末尾开始找下一个；始末位置可有可无
a,b=s	将s中元素依次赋值给前者	a,b=[1,2] a,*b=[1,2,3] a,*b,c=[1,2,3,4]	a=1,b=2 a=1,b=[2,3] a=1,b=[2,3],c=4	若元素数量不一致且没有用*，则报错

字符串

字符串介绍

用引号（'、"、或'''）括起来的一连串字符。

字符串操作

操作	含义	实例	结果	说明
s.title()	首字母大写	"a".title()	"A"
s.lower()	字母转小写	"ABC".lower()	"abc"
s.upper()	字母转大写	"abc".upper()	"ABC"
s.strip()	删除前后空格	"  a  ".strip()	"a"
s.lstrip()	删除左空格	"  a  ".lstrip()	"a  "
s.rstrip()	删除右空格	"  a  ".rstrip()	"  a"
s.find(t[,i[,j]])	在[i,j)中字符串t第一次出现的位置	"114514".find("1",2,5) "114514".find("0") "114514".find("14",0,2)	4 -1 -1	若无参数i或j，则默认从头到尾；若找不到，则返回-1；全部在范围内才算找到
s.replace(x,y)	把字符串中所有x换成y	"114514".replace("14","0")	"1050"
s.join(x)	将列表x用字符串s连接	"a".join(["1","2","3"])	"1a2a3"
s.split(c)	将字符串s根据字符c拆分成列表	"1a2a3".split("a") "aa".split("a") "1  2".split()	["1","2","3"] ["","",""] ["1","2"]	分隔字符相邻或者在收尾，会补上空串；若没有分隔符，则默认将连续的空格作为分隔符
s.count(x[,i[,j]])	在[i,j)中x的出现次数	"114514".count("14",0,5)	1	若无参数i或j，则默认从头到尾

列表

列表介绍

以一定顺序存储元素的可变容器。

列表创建

直接创建

a=[]
b=[1,2,3]
c=['a','b','c']

循环创建

a=[i in range(5)]
#a=[0, 1, 2, 3, 4]

b=[2*i+1 for i in range(5)]
#b=[1, 3, 5, 7, 9]

c=[[i+j for j in range(3)] for i in range(3)]
#c=[[0, 1, 2], 
#   [1, 2, 3], 
#   [2, 3, 4]]

列表操作

a=[1,1,4,5,1,4]

操作	含义	实例	结果	说明
a[i]=x	将第i个元素改为x	a[0]=0	[0,1,4,5,1,4]
a[i:j]=b	将[i,j)改为列表b	a[0:3]=[1,2,3]	[1,2,3,5,1,4]
a[i:j:k]=b	改变切片，步长为k	a[0:3:2]=[1,2]	[1,1,2,5,1,4]
del a[i:j]	将[i,j)删除	del a[2:4]	[1,1,1,4]
del a[i:j:k]	步长为k删除	del a[0:3:2]	[1,5,1,4]
a+=b/a.extend(b)	在末尾添加列表b	a+=[0,0] a.extend([0,0])	[1,1,4,5,1,4,0,0]	添加的东西必须是列表
a*=n	a复制n遍	a*=2	[1,1,4,5,1,4,1,1,4,5,1,4]
a.append(b)	在末尾添加元素b	a.append(0) a.append([0])	[1,1,4,5,1,4,0] [1,1,4,5,1,4,[0]]	b是什么，添加的就是什么
a.clear()	清空a	a.clear()	[]
a.count(x)	a中元素x的个数	a.count(1)	3
a.copy()	生成和a相同的新列表	a.copy()	[1,1,4,5,1,4]	新列表不是原来的对象
a.insert(i,x)	在i位置添加x	a.insert(0,0)	[0,1,1,4,5,1,4]
a.pop(i)	删除第i个元素并返回该元素	a.pop(0) a.pop()	a:[1,4,5,1,4],返回1 a:[1,1,4,5,1],返回4	若无参数，则删除末尾元素并返回该元素
a.remove(x)	删除第一个x	a.remove(1) a.remove(2)	[1,4,5,1,4] ValueError	若无x，则报错
a.reverse()	翻转列表	a.reverse()	[4,1,5,4,1,1]
a.sort()	对列表排序	a.sort()	[1,1,1,4,4,5]	改变原来的列表，地址不变；过程函数，返回的是NoneType

元组

元组介绍

元素不可改变的有序容器。

元组创建

tuple()创建

>>> a=tuple("abc")
>>> print(a)
('a', 'b', 'c')

>>> a=tuple([1,2,3])
>>> print(a)
(1, 2, 3)

()创建

>>> a=(1,2,3)
>>> print(a)
(1, 2, 3)

# 注：对于单个元素的元组，创建时要加逗号
>>> a=(1,)
>>> print(a)
(1,)

直接创建

>>> a=1,2,3
>>> print(a)
(1, 2, 3)

字典

字典介绍

一种无序可变容器，每一组元素包含“键”（key）与“值”（value）。

键需要具有唯一性，且必须是不可变类型，如字符串、数字。

值可以重复，类型没限制。

字典创建

{}创建

#字典 = {键1:值1,键2:值2,...,键n:值n}

dic1={1:"a",2:"b",3:"c"}

dic2={"a":1,"b":2,"c":3}

dict()创建

dic=dict(a=1,b=2)
#等价于 dic={"a":1,"b":2}

字典基本操作

字典访问

#字典名[键]，可以访问键对应的值
>>> dic={"a":1,"b":2}
>>> print(dic["a"])
1

字典修改

#字典名[键]=值，可以赋值或者修改原来键对应的值
>>> dic={"a":1,"b":2}
>>> dic["a"]=3
>>> dic["c"]=4
>>> print(dic)
{'a': 3, 'b': 2, 'c': 4}

字典其它操作

d=["a":1,"b":2,"c":3]

操作	含义	实例	结果	说明
len(d)	字典元素个数	len(d)	3
str(d)	以字符串形式输出字典	str(d)	"{'a': 1, 'b': 2, 'c': 3}"
d.clear()	清空字典	d.clear()	{}
d.copy()	生成和d相同的新字典	a.copy()	{'a': 1, 'b': 2, 'c': 3}	新字典不是原来的对象
x in d	判断字典里是否有键x	"a" in d	True
d.get(k,v)	返回键k对应的值，若字典中没有该键则返回v	d.get("a",0) d.get("d",0)	1 0
d.update(t)	将字典t更新到d里	d.update({"a":0,"d":4})	{'a': 0, 'b': 2, 'c': 3, 'd': 4}
d.pop(k[,x])	删除键k对应的值并返回，若无键k，返回x	d.pop("a") d.pop("d") d.pop("d",0)	1 KeyError 0	x非必填，但若字典中无k且未填x，则报错
d.popitem()	删除字典中最后一对键和值并以元组形式返回	d.popitem()	{'a': 0, 'b': 2} 输出('c', 3)

集合

集合介绍

无序不重复元素容器。

集合创建

{}创建

#集合名={元素1,元素2,...}
S={1,2,3}
T={"a","b","c"}
#注意，{}不能用来创建空集合，创建出的是字典

set()创建

# 集合名=set(序列)
S=set("abcd") #S={'d', 's', 'a', 'f'}
T=set((1,2,3,4)) #T={1,2,3,4}
U=set([1,2,3,4]) #U={1,2,3,4}

集合操作

s={1,2,3}

操作	含义	实例	结果	说明
s.add(x)	往集合中加入元素x	s.add(4)	{1,2,3,4}
s.update(a)	往集合s中加入序列a中的元素	s.update([4,5])	{1,2,3,4,5}	序列可以有多个，用逗号隔开
s.remove(x)	删掉集合中的元素x	s.remove(1) s.remove(0)	{2,3} KeyError	若集合中无x，则报错
s.discard(x)	删掉集合中的元素x	s.discard(1) s.discard(0)	{2,3} {2,3}	即使集合中无x，也不会报错
s.pop()	随机删除集合中的一个元素	s.pop()	{2,3}或{1,3}或{1,2}
len(s)	返回集合元素个数	len(s)	3
s.clear()	清空集合	s.clear()	{}
x in s	判断元素是否在集合内	1 in s 0 in s	True False
s.copy()	生成和s相同的新字典	s.copy()	{1,2,3}	新集合不是原来的对象
s.difference(t)	返回在s中且不在t中的元素构成的集合（差集）	s.difference({2,3,4})	{1}
s.difference_update(t)	返回在s中且不在t中的元素构成的集合（差集）并用结果更新s	s.difference({2,3,4})	s:{1}	函数无返回值
s.intersection(t)	返回s与t的交集	s.intersection({2,3,4})	{2,3}
s.intersection_update(t)	返回s与t的交集并用结果更新s	s.intersection _update({2,3,4})	s:{2,3}	函数无返回值
s.symmetric _difference(t)	返回s、t中不重复元素的集合	s.intersection _update({2,3,4})	{1,4}
s.symmetric_difference _update(t)	返回s、t中不重复元素的集合并用结果更新s	s.symmetric _difference _update({2,3,4})	s:{1,4}	函数无返回值
s.union(t)	返回s与t的并集	s.union({2,3,4})	{1,2,3,4}
s.isdisjoint(t)	判断结合中是否无相同元素	s.isdisjoint({0}) s.isdisjoint({1})	True False
s.issubset(t)	判断t是否是s的子集	s.issubset({1,2,3,4}) s.issubset({1})	False True
s.issuperset(t)	判断s是否是t的子集	s.issubset({1,2,3,4}) s.issubset({1})	True False

控制结构

顺序结构

按照顺序执行的一系列语句。

分支结构

if语句

用法

if 条件:
    条件为真时执行的语句

实例

if "0"<=c<="9":
    print("是数字")
# 若是数字，输出"是数字"

elif语句

用法

if 条件1:
    ...
elif 条件2:
    条件1不成立，条件2成立时执行的语句
elif 条件3:
    条件1,2不成立，条件3成立时执行的语句

实例

if x>=90:
    print("90-100")
elif x>=80:
    print("80-89")
elif x>=70:
    print("70-79")

else语句

用法

if 条件1:
    ...
elif 条件2:
    ...
...
elif 条件n:
    ...
else:
    条件1,2,...,n都不成立时执行的语句

实例

if x>=60:
    print("及格")
else:
    print("不及格")

循环结构

for语句

用法

for 变量名 in 序列:

for i in [1,2,3]:

for i in "123":

for i in lst:

for i in range(10):

while语句

用法

while 表达式:
    表达式为真执行的语句

continue

功能

跳过当前迭代。

实例

a=[i for i in range(10)]
b=[]
for i in a:
    if i%3==0: #若i为3的倍数则跳过当前迭代
        continue
    b+=[i]
print(b)
# 输出 [1, 2, 4, 5, 7, 8]

break

功能

退出循环。

实例

a=[i for i in range(10)]
b=[]
for i in range(10):
    if i%3==0: #若i为3的倍数则退出循环
        break
    b+=[i]
print(b)
#输出 []

break-else语句

功能

若正常结束循环，未触发break语句退出循环，则在循环之后执行。

实例

for i in list:
    if i%3==0:
        break
else:
    print("list中无3的倍数")

函数

函数定义

def <函数名>(<形参列表>):
    <函数体>
    [return <返回值列表>]

常用算法

排序

函数调用

sort

sorted

桶排序

选择排序

冒泡排序

插入排序

查找

顺序查找

二分查找

加密

异或加密

移位加密

常见报错

IndentationError

意义

缩进错误。

实例

 a=3 #前面多了个空格
IndentationError: unexpected indent

SyntaxError

意义

语法错误，解释器无法理解代码。

实例

 a=)
      ^
SyntaxError: unmatched ')'
#解释器没读懂这个没匹配完成的）

TypeError

意义

参数类型错误。

实例

range('a')
TypeError: 'str' object cannot be interpreted as an integer
#range里的参数不应该是字符串

ValueError

意义

错误的参数值。

实例

int('a')
ValueError: invalid literal for int() with base 10: 'a'

KeyError

意义

字典的键错误，引用了一个字典中不存在的键。

实例

a={}
a[1]
KeyError: 1

IndexError

意义

索引错误，访问了一个不存在的索引。

实例

a=[1]
a[1]
IndexError: list index out of range

NameError

意义

变量名错误，访问了未定义的变量名。

实例

print(a)
NameError: name 'a' is not defined

异常处理

try-except-else语句

用法

try:
    尝试运行的语句
except 报错1:
    如果try部分发生了报错1，要执行的语句
except 报错2:
    如果try部分发生了报错2，要执行的语句
else:
    其它情况，要执行的语句

实例

a=[0,1,2]
try:
    x=int(input()) #读入一个索引
    print(a[x]) #输出索引对应的值
except IndexError: #若输入3，跳转到此
    print("IndexError") #输出IndexError
except ValueError: #若输入字符'a'，跳转到此
    print("ValueError") #输出ValueError
else: #若以上情况未发生，跳转到此
    print("NoError") #输出NoError

a=[0,1,2]
try:
    x=int(input()) #读入一个索引
    print(a[x]) #输出索引对应的值
except: #如果出现了错误，跳转到此处
    print("Error")
else: #若以上错误没出现，跳转到此处
    print("NoError") #输出NoError

a=[0,1,2]
try:
    x=int(input()) #读入一个索引
    print(a[x]) #输出索引对应的值
except(IndexError,ValueError): #若发生这些报错，跳转到此处
    print("Error")
else: #若以上情况未发生，跳转到此
    print("NoError") #输出NoError

try-finally语句

用法

try:
    语句
finally:
    退出try时执行的语句

实例

a=[0,1,2]
try:
    x=int(input())
    print(a[x])
except:
    print("Error")
finally: #不管前面发生了什么，try完之后都要执行
    print("EndTry")

raise语句

用法

raise 基本报错类型

 实例

raise IndexError
#生成一个IndexError报错

assert语句

用法

assert 判断语句,结果为False时生成的报错信息

实例

x=-1
assert x>=0,"x<0"
#生成了一个"AssertionError: x<0"的报错

文件操作

疑难题解答

#1 ++

i=3
++i
# 此时i的值依然为3，python没有c中的++运算，此处理解为两个正号

i++
# 在python中会报错，要与c语言自加区分

#2  浮点数判断是否相等

#a,b为两个浮点数
if a==b:
#这是错误的判断浮点数是否相等的方法，易出现错误

if abs(a-b)<1e-9:
#这是正确的写法，二者差的绝对值小于精度阈值即为相等