1，字符串：

name="ada lovelace"

• 首字母大写 name.title()
• 全部转化为大写 name.upper()
• 全部转化为小写 name.lower()
• 合并字符串 "hello" name

name=" ada lovelace "

• 删除结尾空白：name.rstrip()
• 删除开头空白：name.lstrip()
• 删除开头和结尾的空白：name.strip()

str():

age=23

• message="happy" age "rd birthday!" #有错误
• message="happy" str(age) "rd birthday!" #正确形式

2.列表

color=['red','yellow','blue',black]

• 访问列表元素：color[0] #下标从 0不是从1开始
• 修改列表中的元素：color[1]="green"
• 在列表中添加元素：color.append("white")
• 将元素插入列表：color.insert("orange")
• 删除列表中的元素：del color[0]
• color.pop() ##删除最后尾列表中的元素
• color.pop(1) ##删除指定位置的元素
• color.remove("red")

列表排序：

• 使用sort()永久排序列表的方法:color.sort(recerse=True)
• 使用sorted()临时排序列表的方法:
• print(color)
• print(sorted(color))
• print(color)
• 倒序打印列表：print(color.reverse())
• 确定列表长度：len(color)
• 整个列表循环：
• for c in color:
• print(c)

数值列表

• range()函数
• for value in rang(1,4): #从1开始到4结束
• print(value)
• 创建数值列表：
• number=list(range(1,11,2))
• 统计数值列表中的最大值：max(number)
• 统计数值列表中的最小值：min(number)
• 统计数值列表中的值和：sum(number)
• 数值列表的demo:
• squares=[value**2 for value in range(1,11)]
• print(squares)

使用列表的一部分-切片

• print(color[0:3]) #从索引位置0到索引位置3结束
• print(color[-3:]) #从索引位置倒数第三到最后
• 遍历切片：
• for c in color[:3]:
• print(c)

复制列表：

• color1=color此时此刻color和color12个列表不是同一个列表，但列表中的元素是相同的
• color1=color#此时color和color两个是同一列表

3 元组：

• 元组和列表的区别在于，列表可以改变列表元素，而元组不能
• 外观上的区别是元组用小括号标记，列表用中括号标记

定义元组：

dimensions=(200,50)

print(dimensions[0])

遍历元组的所有值：

for dimension in dimensions：

print(dimension)

修改元组变量：

dimensions=(200,50)

for dimension in dimensions：

print(dimension)

dimensions=(200,55)

for dimension in dimensions：

print(dimension)

4.字典

• 字典是一系列键值对：alient_0={"color":"red","points"："5"}
• 访问字典中的值：alient_0["color"]
• 添加键值对：alient_0["x_posisiotn"]=25
• 修改字典中的值：alient_0["color"]="yellow"
• 删除键值对：del alient_0["color"]
• 由类似对象组成的字典：
• alient_0={
• "color":"red",
• "points"："5"
• }
• 遍历字典中的所有键值对：for key,value in alient_0.items():
• 遍历字典中的所有键：for name in alient_0.keys(): 或 for name in alient_0:
• 按顺搜遍历字典中的所有键：for name in sorted(alient_0.keys()):
• 使用遍历字典中的所有值set集合来来去重:for name in set(alient_0.vlaues()):

可嵌套使用字典和字典、字典和列表、列表和列表。

5函数

• 当列表作为函数的参数时，为了不改变列表的值，传输的参数可以作为列表的副本：function_name(list_name[:])
• 传递任意数量的参数：def make_pizza(*toppings)
• 结合使用位置实参和任意数量实参：def make_pizza(size,*toppings)
• 使用任意数量的关键字实参：def make_pizza(first,last,*toppings)

函数和模块：模块被称为扩展.py函数位于模块中

• 导入整个模块：import pizza
• pizza.make_pizza(12,"apple")
• 倒入特定函数：from pizza import make_pizza
• 使用as指定函数的别名：from module_name import function_namr as fn
• 使用as指定模块的别名：import module_name as mn
• 导入模块中的所有函数：from pizza import *

6类

__init__()类似于java形参中的结构方法self必须放在其他形参的前面。为什么必须在方法定义中包含形参？self呢？ 因为Python调用这个__init__()方法来创建Dog实例时， 将自动传入实参self。 各类相关方法的调用自动传递实参self， 它是指向实例本身的引用， 让例子访问类中的属性和方法。 我们创建Dog实例时，Python将调用Dog类的方法__init__()。 我们将通过实际参与Dog()名称和年龄的传递；self它会自动传递，所以我们不需要传递它。 每当我们按Dog类创建实例时， 只需要最后两个形参（name和age） 提供值。

之前总结的直接搬了过来，嘻嘻嘻

Python list列表 定义格式 a=[1,2,'X'] 修改 a[1]=3 添加 append()

元素将直接插入后面 如果元素是地址(如列表)，将直接添加地址而不拆分

extend()

元素将直接插入后面 如果元素是地址（如列表），将逐个拆分并添加地址中的元素

a3=[1,2] a4=[1,3] a4.extend(a3) print(a4)#[1, 3, 1, 2] a5=[1,5] a4.append(a5) print(a4)#[1, 3, 1, 2, [1, 5]] 但是 如果内部元素中仍有地址，则不会拆分

a2=[1,2] a3=[1,a2] a4=[1,3] a4.extend(a3) a4.extend(a3) print(a4)#[1, 3, 1, [1, 2]] 删除 pop()

输入角标 删除指定角标处元素

不输入删除最后一个

1=[1,2,1,3,1,3] a1.pop(0) print(a1)#[2, 1, 3, 1, 3] a1.pop() print(a1)#[2, 1, 3, 1] remove()

删除指定元素 如有多个删除第一个

a2=[1,2,1,3,1,3] a2.remove(1) print(a2)[2, 1, 3, 1, 3] 切块 arr[X:Y]获取列表中从x到y(有x无y)中的元素

a1[1:3] 获取地址 id(a1) 复制 直接使用等于获取的是地址

修改列表时原列表也会发生改变

用copy方法获取的是新的指针方向

但是如果列表内嵌套了列表

修改 嵌套内的列表时 原列表也会发生改变

属于浅copy

a3=[1,2] a4=[1,a3] print(a4)#[1, [1, 2]] a5=a4.copy() a5[1].append(5) print(a4)#[1, [1, 2, 5]] 使用 deepcopy()方法可进行深copy

即使修改列表内的列表值原列表也不会发生改变

需要导包（from copy import deepcopy）

from copy import deepcopy a6 = deepcopy(a4) a6[1].append(3) print(a6)#[1, [1, 2, 5, 3]] print(a4)#[1, [1, 2, 5]] 遍历 简单列表 例如

list1=[“a”,“b”,“c”,“d”]

for i in list1: print(i)

列表中元素为元组时： 例如

list2=[(“a”,1),(“b”,2),(“c”,3),(“d”,4)]

for x,y in list2: print(x,y) 输出为：

a 1

b 2

c 3

d 4

列表中元素为集合时： 例如：

list3=[{“a”,1},{“b”,2},{“c”,3},{“d”,4}]

for x,y in list3: print(x,y) 输出为：

1 a

2 b

3 c

4 d

注意：集合中的元素是无序的，所以打印出来也是随机排列的。

列表中的元素为字典时： 例如：

list4=[{“a”:1},{“b”:2},{“c”:3},{“d”:4}]

for x in list4: print(x)

输出结果为：

{“a”:1}

{“b”:2}

{“c”:3}

{“d”:4}

方法 population 随机数

random.sample(population, k)

population：列表 k：随机返回的个数 reverse()内元素倒置 a1 = [1, 2, 1, 3, 1, 3] a1.reverse() print(a1)#[3, 1, 3, 1, 2, 1]

sort 排序 如果元素为数字按数字大小排序

a1 = [1, 2, 1, 3, 1, 3] a1.sort()#默认等同a1.sort(reverse=False) print(a1)#[1, 1, 1, 2, 3, 3] a1 = [1, 2, 1, 3, 1, 3] a1.sort(reverse=Ture) print(a1)#[3, 3, 2, 1, 1, 1]

如果元素为字符按字符第一个大小排序顺延

a1 = ['SDS','AC','AAD','ASDASD','SDS'] a1.sort() print(a1)#['AAD', 'AC', 'ASDASD', 'SDS', 'SDS']

不可数字字符混用

有更加具体的排序请自行搜索 以上只是一部分

count 计数 获取指定字符出现的次数

index 角标索引 获取指定字符第一次出现的位置

index(x,y,z)

获取指定字符x 从y到z区域中第一次出现的位置

a=(1,2,1,1,1) print(a.count(1))#4 print(a.index(2))#1 print(a.index(1,0,3))#0

字典 定义 用大括号包住

key 对应 元素

a1={1:2, 3:4} print(a1)

获取

print(a1[1])#{1:2,3:4}

方法 删除相关 pop() 若无参数则报错

若有会返回对应值

popitem() 删除最后一个元素并返回元素（元组）

a={ 1:2, 2:5 } a.pop(1) print(a)#{2: 5}

a={ 1:2, 2:5 } print(a.popitem())#(2, 5)

clear() 删除 删除全部

a={ 1:2, 2:5 } a.clear() print(a)#{}

获取相关 keys()获取钥匙 valus()获取值 get() 获取对应值 通过键获取值 可以防止报错

.get(X,若无返回的值默认none)

a={ 1:2, 2:5 } print(a.keys())#dict_keys([1, 2]) print(a.values())#dict_values([2, 5]) print(a.get(3))#None

items()获取 获取字典中所有元素 以元组返回

list() 可以将类似的转换为list

setdefault()获取传入 获取对应值若有则获取若无则传入传入默认为None

setdefault(key,valus)

a={ 1:2, 2:5 } print(a.setdefault(3))#None print(a)#{1: 2, 2: 5, 3: None'}

添加相关 update() 将元素添加入字典

或将其他字典里的元素添加进入

a={ 1:2, 2:5 } b={} b.update(a) b.update([(5,6),(9,7)]) print(b)#{1: 2, 2: 5, 5: 6, 9: 7} b[8]=7 print(b)#{1: 2, 2: 5, 5: 6, 9: 7, 8: 7}

10 b[key]=valus

可以直接添加

集合 定义 无序不重复

b={1,2,3,4,2} print(b)#{1, 2, 3, 4}

因为无序直接获取会报错

print(b[0])#TypeError: 'set' object is not subscriptable

定义空集合方法

a=set()#空集合 print(a,type(a))#set() <class 'set'>

直接为空是字典

c={} print(c,type(c))#{} <class 'dict'>

方法 传入相关 add()

b={1,2,3,4,2} d=(1,2) e={5:6} f=[7,8] b.add(d)# print(b)#{1, 2, (1, 2), 3, 4} #传入字典和列表时候会报错

删除相关 clear() 删除 删除全部

discard()

删除一个

fruits = {"apple", "banana", "cherry"}

fruits.discard("banana")

print(fruits)#{'cherry', 'apple'}

获取相关 update()并集合 实例 把集合 y 中的项目插入集合 x：

x = {"apple", "banana", "cherry"} y = {fruits = {"apple", "banana", "cherry"} x.update(y) print(x)#{'banana', 'google', 'microsoft', 'cherry', 'apple'}

intersection()返回交集 x = {"apple", "banana", "cherry"} y = {"google", "microsoft", "apple"}

z = x.intersection(y)

print(z)#{'apple'}

issubest() 如果集合 y 中存在集合 x 中的所有项目，则返回 True：

x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"}

z = x.issubset(y)

print(z)#True

基本运用 字符串去重

S = 'lsdljfjaldfaowioueroiuwoe' A = set(S) print(A)#{'d', 'j', 'l', 'w', 'a', 'i', 'e', 'r', 'f', 'o', 'u', 's'} B = list(A) print(''.join(A))#djlwaierfous B.sort(key=S.index) print(B)#['l', 's', 'd', 'j', 'f', 'a', 'o', 'w', 'i', 'u', 'e', 'r'] print(''.join(B))#lsdjfaowiuer

运算符 Python 在以下组中划分运算符：

算术运算符 赋值运算符 比较运算符 逻辑运算符 身份运算符 成员运算符 位运算符 Python 算术运算符 算术运算符与数值一起使用来执行常见的数学运算：

运算符 名称 实例

• 加 add x + y

• 减 sub x - y

• 乘 mul x * y / 除 floordiv x / y % 取模 mod x % y ** 幂 pow x ** y // 地板除（取整除）div x // y Python 赋值运算符 赋值运算符用于为变量赋值：

运算符 实例 等同于 = x = 5 x = 5 += x += 3 x = x + 3 -= x -= 3 x = x - 3 *= x *= 3 x = x * 3 /= x /= 3 x = x / 3 %= x %= 3 x = x % 3 //= x //= 3 x = x // 3 = x = 3 x = x ** 3 &= x &= 3 x = x & 3 Python 比较运算符 比较运算符用于比较两个值：

运算符 名称 实例 == 等于 eq x == y != 不等于 ne x != y

    大于gt    x > y
<   小于lt    x < y
=   大于或等于ge x >= y
<=  小于或等于le x <= y
Python 逻辑运算符
逻辑运算符用于组合条件语句：

运算符 描述 实例 and 如果两个语句都为真，则返回 True。 x > 3 and x < 10 or 如果其中一个语句为真，则返回 True。 x > 3 or x < 4 not 反转结果，如果结果为 true，则返回 False not(x > 3 and x < 10) Python 身份运算符 身份运算符用于比较对象，不是比较它们是否相等，但如果它们实际上是同一个对象，则具有相同的内存位置：

运算符 描述 实例 is 如果两个变量是同一个对象，则返回 true。 x is y is not 如果两个变量不是同一个对象，则返回 true。 x is not y Python 成员运算符 成员资格运算符用于测试序列是否在对象中出现：

运算符 描述 实例 in 如果对象中存在具有指定值的序列，则返回 True。 x in y not in 如果对象中不存在具有指定值的序列，则返回 True。 x not in y Python 位运算符 位运算符用于比较（二进制）数字：

运算符 描述 实例 & AND 如果两个位均为 1，则将每个位设为 1。 | OR 如果两位中的一位为 1，则将每个位设为 1。 ^ XOR 如果两个位中只有一位为 1，则将每个位设为 1。 ~ NOT 反转所有位。 << Zero fill left shift 通过从右侧推入零来向左移动，推掉最左边的位。

    Signed right shift  通过从左侧推入最左边的位的副本向右移动，推掉最右边的位。
数据
Python为我们提供了强大的内置函数和格式化数字的方法去实现进制转换的功能，下面一一介绍。
先将所有的函数罗列出来，如下：

↓ 2进制 8进制 10进制 16进制 2进制 - bin(int(n,8)) bin(int(n,10)) bin(int(n,16)) 8进制 oct(int(n,2)) - oct(int(n,10)) oct(int(n,16)) 10进制 int(n,2) int(n,8) - int(n,16) 16进制 hex(int(n,2) hex(int(n,8) hex(int(n,10)) -

2进制 2进制转换成其他进制：

2进制转换成8进制：oct(int(n,2)) n=input() print(oct(int(n,2)))

输入: 1010 输出: 0o12

2进制转换成10进制：int(n,2) n=input() print(int(n,2))

输入：1010 输出：10

2进制转换成16进制：hex(int(n,2)) n=input() print(hex(int(n,2)))

输入：1010 输出：0xa

8进制 8进制转换成其他进制：

8进制转换成2进制：bin(int(n,8)) n=input() print(bin(int(n,8)))

输入：1010 输出：0b1000001000

8进制转换成10进制：int(n,8) n=input() print(int(n,8))

输入：1010 输出：520

8进制转换成16进制：hex(int(n,16)) n=input() print(hex(int(n,8)))

输入：1010 输出：0x208

10进制 10进制转换成其他进制： 说明：10进制转换可以直接采取上述表格中的形式，读入字符串，先转换为10进制的数，再用函数进行操作转换成其他进制。 但同时可以这样操作，读入的时候直接进行强制类型转换操作，转为int类型(python中的int类型的数据就是10进制)

10进制转换成2进制：bin(n) n=int(input()) print(bin(n))

输入：10 输出：0b1010

10进制转换成8进制：oct(n) n=int(input()) print(oct(n))

输入：10 输出：0o12

10进制转换成16进制：hex(n) n=int(input()) print(hex(n))

输入：10 输出：0xa

16进制 16进制转换成其他进制：

16进制转换成2进制：bin(int(n,16)) n=input() print(bin(int(n,16)))

输入：a 输出：0b1010

16进制转换成8进制：oct(int(n,16)) n=input() print(oct(int(n,16)))

输入：a 输出：0o12

16进制转换成10进制：int(n,16) n=input() print((int(n,16)))

输入：a 输出：10

去头缀 注意：我们可以发现，除了转换成10进制的数，其他的进制转换结果都带有前缀，2进制是0b，8进制是0o，16进制是0x。但是我们在绝大部分使用进制转换后的数据时，是不需要它的前缀的。所以笔者这里介绍两种方法，去掉它的前缀。

方法一：使用字符串切片操作 原理：就是将进制转换后得到的结果对其进行字符串切片操作，将得到的结果从第三个字符开始取结果即可，这样我们可以得到不带前缀的结果

举例：

//10进制转换成2进制 n=int(input()) print(bin(n)[2:])//切片操作

输入：10 输出：1010

//10进制转换成8进制 n=int(input()) print(oct(n)[2:])//切片操作

输入：10 输出：12

//10进制转换成16进制 n=int(input()) print(hex(n)[2:])//切片操作

输入：10 输出：a

笔者这里以10进制转换其他进制进行了举例，其他的情况类比即可。

方法二：使用format函数进行格式化数字操作 说明：首先，笔者在前面说过，不同类型的进制转换的原理时先转换为十进制，然后再用相关的函数进行禁止转换操作，而format函数里面有格式化数字的方法可以直接实现进制转换的功能，下面一一介绍：

其他类型转换为2进制： 操作：在format函数的槽中添加一个b 即可实现其他类型对2进制的转换，下面举例说明

n=input() print("{:b}".format(int(n,8))) //先将8进制的数转换为10进制， //然后在format的槽中添加一个b，等价于实现了bin函数的功能 //但是此结果是不带有0b前缀的

输入：1010 输出：1000001000

其他类型转换为8进制：

操作：在format函数的槽中添加一个o 即可实现其他类型对8进制的转换，下面举例说明

n=input() print("{😮}".format(int(n,16))) //先将一个16进制数转换为10进制 //然后利用format函数格式化数字方法转换即可

输入：a 输出：12

其他类型转换为16进制： 操作：在format函数的槽中添加一个x 即可实现其他类型对2进制的转换，下面举例说明

n=input() print("{:x}".format(int(n,8))) //先将一个8进制的数转换为16进制 //然后原理同上

输入：1010 输出：208

注意：由于转换成10进制本来就是不带前缀的，无需用format格式化数字方法控制

方法 python格式化输出内容 以下是 print() 方法的语法:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数 objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。 sep – 用来间隔多个对象，默认值是一个空格。 end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。 file – 要写入的文件对象。 flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。 range range(X,Y,Z)

X到Y 隔z个

for i in range(9,0,-1): print(i) 9 8 7 6 5 4 3 2 1

错误与异常 错误 是不可运行的 在运行之前就会报错 通常是语法错误

编译失败 不可被处理

异常 可以运行到异常地点 之后报错

可以被处理

例1 被除数为0

1/0 #ZeroDivisionError: division by zero

语法 try 获取异常0

try: 要执行语句 except 异常类型 as 给异常改名: 处理异常的语句 else: 没有遇到异常执行语句 finally: 无论如何都执行的语句

excent 处理任意异常

as 给异常改名

finally 结束输出

try: 1/0 except: print('分母不能为0')

Exception 处理

try: print(111) 1/0 except Exception: print('分母不能为0')

常见异常 列表超出索引 元组不可改变 字典 key不存在 文件 说明 oprn:打开 open(file,encoding=“编码格式”,) 以什么演的形式打开 读或写 read ,write r 以读的方式 默认的 w 以写的方式打开 x 创建一个新文件,并以写的方式打开 a 以追加的方式去写 b 二进制方式 t 文本方式 默认的

/ +以读或者写打开一个磁盘

file(): 文件，路径+文件名 mode(): 模式 buffering: 保存 encoding(*) 编码 如 UTF-8 errors: 错误处理方式 newline 新行 closefd 关闭文件描述符

语法 fi=open("file.txt",encoding="UTF-8") da=fi.read() print(da) fi.close()

注意

fi=open("file.txt",encoding="UTF-8") da=fi.read() da1=fi.read() print(da)#你好啊 print(da1)# 空 因为已经读到了文章末尾 fi.close()

写入 write

writelines

多行输入

f2.writelines("\n".join(["1","2"])) 1 w 会直接删除 并写入

fa=open("file.txt","w",encoding="UTF-8") fa2=fa.write("111111") print(fa2) fa.close()

a 会追加 并写入

fa=open("file.txt","a",encoding="UTF-8") fa2=fa.write("2222") print(fa2) fa.close()

/ + 加号不可以单独使用

复制 f1=open("1.png","rb") F1=f1.read() f2=open("6.png","wb") f2.write(F1) f2.close() f1.close()

或者

f1=open("1.png","rb") F1=f1.read() with open("5.png","wb") as f2: f2.write(F1) f2.close() f1.close()

read 读取 read 读取全部

read(n) /*读取n个字节

readline() //读取一行

readlines()//读取所有行

readlines(n) 根据字节读取整行 且第二次读取从下一行开始

#如 第一行有6个 字节第二行有8个 字节 #n=8则读取了两行 小于等于6+1则只有第一行 f1=open("file.txt","rb") F1=f1.readlines(8) print(F1)#[b'222210\r\n', b'22221022\r\n'] f1.close()

模块 导入全部 间接用

import python2 print(python2.a)

导入局部 可以直接用

from python2 import a print(a)

导入*

from python2 import *

获取除了下划线开头的所有属性

主运行 _ name_ (无空格)

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用_ _name__属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3

Filename: using_name.py

if name == 'main': print('程序自身在运行') else: print('我来自另一模块')

os 语法 使用 os

import os

输入输出 输入 语法 xxx=input("XXXXX")

读取到一定是字符串，如果想使用实际数据类型，需要做类型转换

int(), float(), tuple(), list()

输出 语法 print("XXXX","SSSS")#屏幕输出 print("XXXX","file.txt")#文件内输出

格式化输出 旧版 占位符号

%d:digit 整形

%f:float 浮点型

%s: string 字符串

date=1 date1=1.1 date2="11" print("date is %d,date2 is %.1f,date2 is %s"%(date,date1,date2)) #date is 1,date2 is 1.1,date2 is 11

固定输出占位

%4d 右对齐 占4位

%-4d 左对齐 占4位

%8.4f 右对齐 占8位 有效数字小数后4位

%+10d 右对齐 占10位输出带加号

新版 date=1 date1=1.1 date2="11" print(f"date is {date},date2 is {date1},date2 is {date2}") #date is 1,date2 is 1.1,date2 is 11

{date:4} 占4位右对齐 默认等同{date:>4}

{date:<4} 占4位左对齐

{date:^4} 占4位中间对齐

{date:*^4}占4位中间对齐 空白用 * 号填充 此处星号可变为单字符

{date:x^4}占4位中间对齐 空白用 x 填充

date = ["张三", 20, "西安的"] print("姓名：{a},年龄：{b},家庭地址:{c}".format(a=date[1],b=date[1],c=date[2]))#姓名：20,年龄：西安的,家庭地址:张三

注 此处date 为变量名 可灵活改变

字符串 方法 切块 a. 使用切片倒序输出 b. 使用切片取出偶数的数字 c. 使用切片取出奇数的数字 d. 取出后5位字符

s = "123456789" print(s[::-1])#987654321 print(s[::2])#13579 print(s[1::2])#2468 print(s[-5:])#56789

x::y

从x开始 每隔y个获取 x默认为0 y默认为1

lower 字符串小写

str="aBcD" print(str.lower())#abcd

upper 字符串大写

str="aBcD" print(str.upper())#ABCD

capitalize 首字母大写

str="aBcD" print(str.capitalize())#Abcd

对齐方式 str="aBcD" print(str.center(10,""))#占位居中对齐填充**aBcD* print(str.ljust(10,""))#占位左对齐填充aBcD* print(str.rjust(10,""))#占位右对齐填充***aBcD

count 字符串中某字符个数

str="aBcD" print(str.count("a"))#1

字符串中从第二个字符以后某字符个数

str="aBcD" print(str.count("a",2))#0 print(str.count("c",2))#1

len 获取字符创的长度

str="aBcD" print(len(str))#4

字符串下标 获取字符串下标为1的字符

str="aBcD" print(str[1])#B

endswith 字符串是否以什么什么结尾的

str="aBcD" print(str.endswith("D"))#True

rstrip 去除末尾的字符或者特定符号

str="aBcD" print(str.rstrip("cD"))#aB

replace 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

str="zzsaixuexi" print(str.replace('z','a',1))#azsaixuexi

format date = ["王五五五五五五五五", 280, "山西的老百姓"] print("{},{},{}".format(date[0],date[1],date[2])) #传入参数格式化输出 print("{1},{0},{2}".format(date[0],date[1],date[2])) #按照下标顺序输入

结果

王五五五五五五五五,280,山西的老百姓 280,王五五五五五五五五,山西的老百姓

replace(self, old, new, count=-1, /) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

str="zzsaixuexi" print(str.replace('z','a',1))#azsaixuexi

join(self, iterable, /) join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

srg=["ZZS","AI","XUEXI"] str = "-"; print(str.join(srg))

isdigit 如果字符串只包含数字则返回 True 否则返回 False。

str="zzsaixuexi" print(str.isdigit())#False

isalpha 如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。

str="zzsaixuexi" print(str.isalpha())#True

isalnum 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

str="zzsaixuexi" print(str.isalnum())#True

strip 返回移除字符串头尾指定的字符生成的新字符串。

str = "00000003210ZZSAXX01230000000"; print(str.strip('0')) # 去除首尾字符 0 #3210ZZSAXX0123 str2 = " ZZSAIXX " # 去除首尾空格 print(str2.strip()) #ZZSAIXX

split 参数 str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。 num – 分割次数。默认为 -1, 即分隔所有。 返回值 返回分割后的字符串列表。

str = "Line1-abcdef \nLine2-abc \nLine4-abcd" print(str) print(str.split( )) # 以空格为分隔符，包含 \n print(str.split(' ', 1 ))# 以空格为分隔符，分隔成两个

結果

Line1-abcdef Line2-abc Line4-abcd ['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] ['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

splitlines 参数 keepends – 在输出结果里是否保留换行符(’\r’, ‘\r\n’, \n’)，默认为 False，不包含换行符，如果为 True，则保留换行符。 返回值 返回一个包含各行作为元素的列表。

print(str2.strip()) str1 = 'ab c\nde fg\nkl' print(str1) print(str1.splitlines()) print(str1.splitlines(True))

结果

ab c de fg kl ['ab c', 'de fg', 'kl'] ['ab c\n', 'de fg\n', 'kl']

函数 语法 定义 无返回值

def print_123():#定义函数 print("123") print_123()#调用函数 输出123

一个返回值

def jiachen(A): return A+1,A+2 print(jiachen(1),type(jiachen(1)))#2 <class 'int'> date,date1=jiachen(1) print(date,date1)#2 3

多个返回值

返回时候用逗号隔开

def jiachen1(A): return A+1 print(jiachen1(1),type(jiachen1(1)))#(2, 3) <class 'tuple'>

形参 定义函数时候用到的定义参数

实参 真正运行时候用到的参数

def zzs(arg,arg1=1): print(arg,arg1) zzs(1)#11 zzs(1,2)#11

有默认值的调用时候可以只输入没默认值的

如果输入默认值的默认值会更换

默认值参数需要放后面

因为数要根据位置去匹配

也可以通过调用时候输入来确定

def zzs(arg,arg1=1,arg2=1): print(arg,arg1,arg2) zzs(arg1=2,arg=1,arg2=5)

会按照输入参数来确定输入

特殊参数 *args 一个或者多个参数 aegs 名字可以改 重点是星号

def zzs(arg,args): print(arg,args )#1 2 3 4 5 print(args,type(args))#(2, 3, 4, 5) <class 'tuple'> # print(type(*args)) 会报错 因为他是多个数 zzs(1,2,3,4,5)

**kwargs 一个或者多个关键字参数

一言概之，*主要使用在函数参数中，在定义函数中添加是为了在调用该函数时直接将多个参数转换成一个元组，而在调用函数时参数添加，是为了将列表/元组转化成多个参数。

也主要使用在函数参数中，在定义函数中添加是为了在调用该函数时可以添加任意个键值对转出一个字典，而在调用函数时在列表中添加，是为了将字典转化成多个参数。

如例子：

def func1(a): print(a) def func2(**b): print(b) func1(1,2,3,4,5) #这样可以将多个参数变成一个元组 func2(name='mr',age='22') #这样可以将多个键值对变成一个字典 def f1(a,b,c): print(a) def f2(name,age,sex): print(name) l = [1,2,3] d = {"name":'mr',"age":22,"sex":'boy'} f1(l) #将列表、元组变成多个参数f2(**d) #将字典转成赋值参数，name='mr',age=22,sex='boy'`

func1(*l) #先将参数转成多个参数，在函数参数中又转成元组func2(**d) #先将参数转成多个键值对，在函数参数中又转成字典

结果：

(1, 2, 3, 4, 5) {'age': '22', 'name': 'mr'} 1 mr (1, 2, 3) {'age': 22, 'sex': 'boy', 'name': 'mr'}

/ 作用 在它之前的参数只能以位置参数形式传入

def hunhe(X1,Y1,/,X=None,Y=None): return X1,Y1,X,Y print(hunhe(X1=1,Y1=2,X=3,Y=2)) #报错因为x1y1不是以位置参数传入的

* 作用 在它之后的参数只能以关键字参数形式传入

def hunhe(*,X1,Y1,X=None,Y=None): return X1,Y1,X,Y print(hunhe(X1=1,Y1=2,X=3,Y=2))#（1,2,3,4） print(hunhe(1,2,3,4))#报错

调用 def print_123(): print("123") print_123()#调用函数 输出123 PPPP=print_123 #获取函数 PPPP()#调用函数 输出123

嵌套函数 定义 def outer(): def inner(): print("inner") print("outer") return inner() outer() #outer #inner

递归 定义 函数自身调用自身

应用 累加

def num(N): if N==1: return 1 else: return num(N-1)+N print(num(100))#5050 时间函数 类 定义 语法格式 class 类名:

注意 类名 尽量使用驼峰命名 单词首字符大写

class Person: name="张三" age=18 gender="男" def test(): print("this is test") pass

初始化变量定义 定义在 初始化类 _ init_ 中

注 外部的是类变量 如果一个修改了 就全修改了需要实例化

class Person: def init(self,name,age,gender): self.name=name self.agr=age self.gender=gender def print(self): return self.name,self.agr,self.gender student1=Person("li",18,"男") student2=Person("si",18,"nv") print(student1.print())#('li', 18, '男') print(student2.print())#('si', 18, 'nv')

类变量实例化 实例化前

class delivery: location="beixin" def init(self, id, from1, to, type): self.id=id self.from1 = from1 self.to=to self.type = type pass kuaiid1=delivery kuaiid2=delivery kuaiid1.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#2

实例化后

class delivery: location="beixin" def init(self, id, from1, to, type): self.id=id self.from1 = from1 self.to=to self.type = type kuaiid1=delivery(1,1,1,1)#实例化 kuaiid2=delivery kuaiid1.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#beixin

若实例化后 无对象类变量继续修改实例化类变量类变量不会改变

但是修改其他的类变量 实例化类变量类变量也会改变

kuaiid1=delivery(1,1,1,1) kuaiid2=delivery kuaiid1.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#beixin

修改未实例化的类变量

kuaiid1=delivery(1,1,1,1) kuaiid2=delivery kuaiid2.location=2 print(kuaiid1.location)#2 print(kuaiid2.location)#2

继承 父类默认为object

class delivery(object): pass

suber() 寻找父类方法

suber(A，c)

从A类之后开始寻找

具体百度

_和 _ _ 在类中实现私有和不被继承

_name 即外部人直接调用时候 用 . . 不出来

但是如果全拼的时候还是可以找到的

_ _funt()

双下划线方法 被调用时候 会被改名为类名加_ _funt()

达到不被调用效果 但是全拼还是可以调用的

注：python中没有私有的概念：这是约定的东西 是希望可以遵守

区快概念 date=1 def txt(): date=2 print(date)#2 print(date)#1 txt() print(date)#1

装饰器 @ 叫语法糖

def decorate(text): def innter(): print("内部1") text() print("内部2") return innter @decorate def fund(): print("东西")

fund()

下面更无敌 上面的不可传参数

def decorate(text): def innter(args,**kwargs): print("内部1") text(args,**kwargs) print("内部2") return innter @decorate def fund(i): print(f"东西{i}")

fund(1)

推导式 列表推导式 定义一次存储 存储1到10的平方

原方法

list=[] for i in range(1,11): list.append(i**2) print(list)

推导式方法

list=[i**2 for i in range(1,11)] print(list)

结果相同都为

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

循环二次输出 将两个列表所有组合方式输出

原方法

color=['red','blue','black'] size=['S','m','L'] for i in color: for j in size: print(i,j,end=" ")

结果

red S red m red L blue S blue m blue L black S black m black L

推导式

color=['red','blue','black'] size=['S','m','L']

list=[(i,j) for i in color for j in size] print(list)

结果

[('red', 'S'), ('red', 'm'), ('red', 'L'), ('blue', 'S'), ('blue', 'm'), ('blue', 'L'), ('black', 'S'), ('black', 'm'), ('black', 'L')]

判断输出 输出10以内奇数

原方法

list=[] for i in range(1,11): if i%2!=0: list.append(i) print(list)

推导式

list=[i for i in range(1,11) if i%2!=0] print(list)

结果都为

[1, 3, 5, 7, 9]

10以内平方大于10的数

list1=[i for i in range(1,11) if i*i>10] print(list1)#[4, 5, 6, 7, 8, 9, 10]

特殊判断 获取10以内数 且偶数变为0

list=[i if i%2 else 0 for i in range(1,11) ] print(list)

结果

[1, 0, 3, 0, 5, 0, 7, 0, 9, 0]

字典推导式 基本一元素推导式 获取10以内 key对应的 valus为key’平平方

data={i:i*i for i in range(1,11)} print(data)

结果

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

正则表达式 定义 导入包 re

import re str="abc" str2="abc" bool=re.fullmatch(str,str2)#是否相同 str3="abcssabcabcabcabcabcabcabc" bool2=re.findall(str,str3)##返回所有的str #['abc', 'abc', 'abc', 'abc', 'abc', 'abc', 'abc', 'abc'] str4=".a..."#匹配字符 str5="sasaa" print(re.match(str4,str5))