python 学习笔记

楚憷

于 2023-10-19 16:29:17 发布

阅读量588

点赞数

文章标签：学习笔记

本文链接：https://blog.csdn.net/Serien912/article/details/132210603

版权

一变量

1 创建变量

Python 的变量无需声明，只需要一次赋值，该变量就能够被成功创建：

x = 3

2 访问变量

当一个变量被创建之后，使用变量名就可以直接访问该变量了：..

>>>print(x)

3 变量名

字母，数字，下划线组成，数字不能开头，区分大小写，Python3支持中文字符作为变量

4 字符串

Single quotes 是使用一对单引号将文本包含起来：
>>> print('I love China')
I love China

Double quotes 就是使用一对双引号将文本包含起来：

>>> print("I love FishC")
I love FishC

混合使用 Single quotes 和 Double quotes 的技巧：

>>> print("Let's go!")
Let's go!
>>> print('"Life is short, you need Python."')
"Life is short, you need Python."

5 转义字符

6 思维导图

7 原始字符串

使用原始字符串，可以避免反斜杠（\）被当作转义字符解析：

>>> 未使用原始字符串
>>> print("D:\three\two\one\now")
D:        hree        wo\one
ow
>>> # 使用原始字符串
>>> print(r"D:\three\two\one\now")
D:\three\two\one\now

8. 字符串（Triple quotes）

通常，使用三引号字符串来引用多行文本：

>>> song = """
一片萤火 整个星河
流行也为你落下来了
在想什么 在想什么
你望着那朵
"""

9.字符串加法和乘法

字符串相加我们叫做拼接，就是将字符串组合成一个长的新的字符串：

>>> '520' + '1314'
'5201314'

>>>print("我爱你\n" * 1108)

10.思维导图

二运算符

1 赋值运算符。

一个等于号 =

2.将字符串转换为整数

使用int()函数将指定的值转换为整数，但要注意，并不是所有的字符串都能够转换为整数，比如 int("FishC") 你让人怎么转？

3.比较运算符

比较运算符会将其左边和右边两个操作数进行比较，如果结果成立，则返回 True，否则返回 False。

4.思维导图

三数据类型

1.整数

Python 的整数长度是不受限制的，也就是说它是有无限大的精度。

所以，你可以随时随地的进行大数运算：

>>> 1112234579121621 / 11235813213455
98.99012719343793

2.浮点数

>>> 0.1 + 0.2
0.30000000000000004

由于浮点数并不是 100% 精确的，所以我们拿浮点数来做比较就要特别小心了：

>>> 0.3 == 0.1 + 0.2
False

3.精确计算浮点数

这里我们需要借助到一个叫做 decimal 的模块

>>> import decimal
>>> a = decimal.Decimal('0.1')
>>> b = decimal.Decimal('0.2')
>>> print(a + b)
0.3

5. E记法

E 记法也就是平时我们所说的科学计数法，用于表示一些比较极端的数。

>>> x = 0.00005
>>> x
5e-05

6.复数

包含一个实部和一个虚部

>>> x = 0.00005
>>> x
5e-05

它们都是以浮点数的形式存放的，如果将一个复数赋值给一个变量 x，则可以通过 x.real 访问该复数的实部，x.imag 访问其虚部：

>>> x = 1 + 2j
>>> x.real
1.0
>>> x.imag
2.0

7.本节思维导图

8.数学运算

9.四则运算

>>> 1 + 2
3
>>> 1 - 2
-1
>>> 1 * 2
2
>>> 1 / 2
0.5

10.地板除

双斜杠（//）表示一种特殊的除法 —— 地板除。

地板除原理是取比目标结果小的最大整数：

>>> 3 // 2
1
>>> -3 // 2
-2

11.取余

>>> 3 % 2
1
>>> 6 % 2
0

12. divmod() 函数

Python 有个内置函数叫 divmod()，它的作用就是同时求出两参数地板除的结果和余数：
>>> divmod(3, 2)
(1, 1)
>>> divmod(-3, 2)
(-2, 1)

13.abs()函数

返回指定函数的绝对值

>>> x = -520
>>> abs(x)
520
>>> y = -3.14
>>> abs(y)
3.14

如果传入的是一个复数，abs() 函数返回的结果就是复数的模：

>>> z = 1 + 2j
>>> abs(z)
2.23606797749979

14.int()，float() 和 complex() 函数

int() 函数是将指定的值转换成整数，比如我们传入一个字符串 '520'，那么得到结果就是一个整数 520：

>>> int('520')
520

不过如果参数是一个浮点数，那么就要注意了，因为它得到的将是一个截掉小数的整数：

>>> int(3.14)
3
>>> int(9.99)
9

注意：它是直接截取整数部分，扔掉小数部分，而不是四舍五入。
同样的道理，float() 和 complex() 函数是将指定的值转换成浮点数和复数

15.pow() 函数和幂运算符（**）

>>> pow(2, 3)
8
>>> 2 ** 3
8
>>> pow(2, -3)
0.125
>>> 2 ** -3
0.125

不过，pow() 函数还留有一手，它支持第 3 个参数。

如果传入第 3 个参数，那么会将幂运算的结果和第 3 个参数进行取余数运算：

>>> pow(2, 3, 5)
3

相当于：

>>> 2 ** 3 % 5
3

16.本节思维导图

四布尔类型

1. 布尔类型

布尔类型的值只有两个：True 或者 False，也就是 “真” 或者 “假”。
2. bool() 函数

使用 bool() 函数可以直接给出 True 或者 False 的结果：

>>> bool(250)
True
>>> bool("假")
True
>>> bool("False")
True

3. 真真假假

结果是 True 的情况非常多，但 False 却是屈指可数，下面这些几乎就是结果为 False 的所有情况：

定义为 False 的对象：None 和 False
值为 0 的数字类型：0, 0.0, 0j, Decimal(0), Fraction(0, 1)
空的序列和集合：'', (), [], {}, set(), range(0)
bool('0')
True
bool(0)
False

4. 逻辑运算符

Python 总共有三个逻辑运算符：and、or 和 not。

对于 and 和 or 运算符，它的计算结果不一定是 True 或者 False。

这要看它的操作数是什么了，如果你给到操作数的是两个数值，那么它的运算结果也是数值：

>>> 3 and 4
4
>>> 4 or 5
4

如果你给到操作数的是两个字符串，那么它的结果也是字符串：

>>> "FishC" and "LOVE"
'LOVE'

5. 本节思维导图

6.短路逻辑

and 和 or 这两个运算符都是遵从短路逻辑的。

短路逻辑的核心思想就是：从左往右，只有当第一个操作数的值无法确定逻辑运算的结果时，才对第二个操作数进行求值。

7.运算符优先级

这个表格从低到高列出了 Python 的运算符优先级：

8.本节思维导图

五.了不起的分支和循环

if 五种用法

1.

if condition:

statement(s)

2

if condition:

statement(s)

else:

statements(s)

3

if condition1:

statement(s)

elif condition2:

statements(s)

elif condition3:

statements(s)

4

if condition1:

statement(s)

elif condition2:

statements(s)

elif condition3:

statements(s)

else:

statements(s)

5.转换

a = 6
b = 4
small = a if a < b else b
print(small)
4

6.分支结构的嵌套

age = 18
isMale = True

if age < 18:
print("抱歉，19岁以下的禁止访问")
else:
if isMale:
print("任君挑选")
else:
print("baoqian")

循环结构

1.while循环

while condition:

ststement(s)

love = "yes"
while love == "yes":
love = input("今天你还爱我吗？")

今天你还爱我吗？yes
今天你还爱我吗？no

死循环

2.break语句

跳出一层循环体

while True:
answer = input("主人可以退出循环吗")
if answer == "可以！":
break
print("好累")

主人可以退出循环吗弄
好累
主人可以退出循环吗可以！

3.continue

跳出本轮循环

i= 0
while i < 10:
i += 1
if i % 2 == 0:
continue
print(i)

1
3
5
7
9

4. while else

当循环条件不再为真，else语句被执行

i =1
while i <5:
print("循环内，i的值是",i)
if i == 2:
break #直接跳出循环，没有执行else
i += 1
else:
print("循环外，i的值是",i)

循环内，i的值是 1
循环内，i的值是 2

5.循环结构的嵌套

例如9x9乘法表

i =1
while i <= 9:
j=1
while j<=i:
print(j,"*",i,"=",j * i,end=" ")#最后一个end空格作用是行之间添加空格
j+=1
print()#换行
i +=1

1 * 1 = 1
1 * 2 = 2 2 * 2 = 4

6.for循环

for 变量 in 可迭代对象：

statement(s)

for n in range(2,10):
for x in range(2,n):
if n % x == 0:
print(n,"=",x,"*",n//x)
break
else:
print(n,"是一个素数")

7.range函数

1.range(a). 0到a-1

2.range(a,b). 左闭右开

3.range(a,b,step). step 跨越多少

>>>for i in range(1,10,2):
>>> print(i)

1
3
5
7
9

六列表

[1, 2, 3, 4, 5, '12345上山打老虎']
hyme = [1,2,3,4,5,"12345上山打老虎"]
print(hyme)
[1, 2, 3, 4, 5, '12345上山打老虎']

1.序列

for each in hyme:
print(each）
1
2
3
4
5
12345上山打老虎

2.下标索引

hyme[0]
1

3.列表切片

hyme[0:3]
[1, 2, 3]
hyme[3:6]
[4, 5, '12345上山打老虎']
hyme[:3]
[1, 2, 3]
hyme[:]
[1, 2, 3, 4, 5, '12345上山打老虎']
hyme[0:6:2]
[1, 3, 5]
hyme[::]
[1, 2, 3, 4, 5, '12345上山打老虎']
hyme[::-2]
['12345上山打老虎', 4, 2]

倒序输出

hyme[::-1]
['12345上山打老虎', 5, 4, 3, 2, 1]

4.列表的诸多方法

4.1增

（1）append 在结尾添加

heros = ["gangtie","lvjuren"]
heros.append("heihuafu")

（2）extend

heros.extend(["yingyan","fhios"])
heros
['gangtie', 'lvjuren', 'heihuafu', 'yingyan', 'fhios']

(3)len

s = [1,2,3,4,5]
s[len(s):] = [6]
s
[1, 2, 3, 4, 5, 6]
s[len(s):] = [7,8,9]

s
[1, 2, 3, 4, 5, 6, 7, 8, 9]

(4)insert

s = [1,3,4,5]
s
[1, 3, 4, 5]
s.insert(0,0)#为0插入序号为0
s
[0, 1, 3, 4, 5]
s.insert(len(s),6)#如果用len相当于append在末尾
s
[0, 1, 3, 4, 5, 6]

4.2 删

（1）将指定的元素删除remove

如果元素有多个，只删除第一个

（2） pop 删除列表中的序列号

heros
['lvjuren', 'heihuafu', 'yingyan', 'fhios']
heros.pop(2)
'yingyan'
heros
['lvjuren', 'heihuafu', 'fhios']

4.3 改

(1)列表是可改变的，字符串是不可改变的

heros = ["蜘蛛侠","绿巨人","黑寡妇","鹰眼","灭霸","雷神"]
heros[4]="钢铁侠"
heros
['蜘蛛侠', '绿巨人', '黑寡妇', '鹰眼', '钢铁侠', '雷神']

(2)如果有多个连续的字符串改变

heros[3:] = ["武松","林冲","李逵"]

heros

['蜘蛛侠', '绿巨人', '黑寡妇', '武松', '林冲', '李逵']

(3)sort方法从小到大排序 reverse方法倒转

nums = [3,1,9,6,8,6,5,3]
nums.sort()
>>>nums
[1, 3, 3, 5, 6, 6, 8, 9]
nums.reverse()
>>>nums
[9, 8, 6, 6, 5, 3, 3, 1]

等价于

nums.sort(reverse=True)

nums

[9, 8, 6, 6, 5, 3, 3, 1]

sorted(iterable) 方法用于对可迭代对象（如字符串、列表等）中的元素进行排序，并返回一个新的有序列表，不改变原始对象。它可以用于对字符串的字符进行排序，也可以用于对数字列表进行排序。

unsorted_list = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(unsorted_list)
print(sorted_list) # 输出: [1, 1, 2, 3, 4, 5, 6, 9]

unsorted_string = "gabdefc"
sorted_string = ''.join(sorted(unsorted_string))
print(sorted_string) # 输出: "abcdefg"

(4)replace方法

见字符串

4.4删

(1)查找某个元素的次数。count方法

nums.count(3)

（2）查找某个元素的索引值 index方法

nums.index(3)

nums.index(6,1,6)#(num,start,end)

3

当不知道某个元素的索引值并且想把他替换成别的元素时

heros[heros.index("绿巨人")]="神奇女侠"

count如果前面是字符串的话，里面也要用字符串

x = binary.count('1')

(3)复制copy

nums_copy1 = nums.copy()

nums_copy1

[3, 1, 9, 6, 8, 6, 5, 3]
nums_copy2 = nums[:]#等价于

nums_copy2

[3, 1, 9, 6, 8, 6, 5, 3]

4.5 列表的加法和乘法

(1)加法就是直接拼接

s = [1,2,3]

t = [4,5,6]

s+t

[1, 2, 3, 4, 5, 6]

(2)乘法就是列表中的元素重复多少次

s*3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

(3)嵌套列表

matrix = [[1,2,3],[4,5,6],[7,8,9]]
matrix = [[1,2,3],
[4,5,6],
[7,8,9]]

(4)访问嵌套列表

for i in matrix:
for each in i:
print(each,end = " ")
print()

matrix[0]

[1, 2, 3]
mtrix[0][0]

1

(6)is用法

x = "FinshC"

y ="FinshC"

B = [[0]*3]*3

B

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

B[1][1]=1

B

[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

x is y

True
x = [1,2,3]

y =[1,2,3]

x is y

False
#字符串是不可变的，列表是可变的

A[0] is A[1]

False
#说明不是同一个对象，指向不同的地址

B[0] is B[1]

True

(7)变量不是盒子

(1)当赋值语句发生时，python是把一个变量的引用复制给另一个

x = [1,2,3]
y = x
x[1]=1
x
[1, 1, 3]
y
[1, 1, 3]

如果想用到两个独立的列表还需要用到拷贝，

(2)浅拷贝. 直接用copy

nums_copy1 = nums.copy()

nums_copy1

[3, 1, 9, 6, 8, 6, 5, 3]
nums_copy2 = nums[:]#等价于

nums_copy2

[3, 1, 9, 6, 8, 6, 5, 3]

import copy
x = [[1,2,3],[4,5,6],[7,8,9]]

y = copy.copy(x)
x[1][1] =0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]

(3)深拷贝. deepcopy

首先引入copy模块

import copy

x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.deepcopy(x)

x[1][1] = 0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

(8)列表推导式

(1)将列表内的元素都变为2倍

oho
[2, 4, 6, 8, 10]
oho = [1,2,3,4,5]
oho = [i * 2 for i in oho]
oho
[2, 4, 6, 8, 10]

(2)#基本语法
expression for target in iterable

x

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i +1 for i in range(10)]

x

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y =[c *2 for c in "wangyuan"]

y

['ww', 'aa', 'nn', 'gg', 'yy', 'uu', 'aa', 'nn']
#ord()函数将单个字符串转变为编码

code = [ord(c) for c in "Finshc"]

code

[70, 105, 110, 115, 104, 99]

(3)利用列表推导式实现嵌套列表

s = [[0]*3 for i in range(3)]

s

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
s [1][1] =1

s

[[0, 0, 0], [0, 1, 0], [0, 0, 0]]

(4)列表推导式还可以添加用于筛选的if 分句

expression for target in iterable if condition

words = ["Great","FinshC","Brilliant","Excellent","Finistic"]

selsct = [i for i in words if i[0]== "F"]

selsct

['FinshC', 'Finistic']

(6)嵌套的列表推导式对应嵌套的循环

expression for target1 in iterable1

for target2 in iterable2

for targetN in interableN]

(7)将二维列表降为一维列表

#外层循环放在前面，内层循环放在后面

[x + y for x in "findhc" for y in"FINSHC"]

['fF', 'fI', 'fN', 'fS', 'fH', 'fC', 'iF', 'iI', 'iN', 'iS', 'iH', 'iC', 'nF', 'nI', 'nN', 'nS', 'nH', 'nC', 'dF', 'dI', 'dN', 'dS', 'dH', 'dC', 'hF', 'hI', 'hN', 'hS', 'hH', 'hC', 'cF', 'cI', 'cN', 'cS', 'cH', 'cC']

_ =[] #不知道变量起什么名字可以用下划线。单独的下划线是匿名变量列表初始化

for x in "finshc":
for y in "FINSHC":
_.append(x+y)

_

['fF', 'fI', 'fN', 'fS', 'fH', 'fC', 'iF', 'iI', 'iN', 'iS', 'iH', 'iC', 'nF', 'nI', 'nN', 'nS', 'nH', 'nC', 'sF', 'sI', 'sN', 'sS', 'sH', 'sC', 'hF', 'hI', 'hN', 'hS', 'hH', 'hC', 'cF', 'cI', 'cN', 'cS', 'cH', 'cC']

(8)列表推导的终极语法

expression for target1 in iterable1 if condition1

for target2 in iterable2 if condition2

for targetN in iterableN if conditionN

[[x,y] for x in range(10) if x %2 == 0 for y in range(10) if y % 3==0]

[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

#等价于

for x in range (10):
if x % 2==0:
for y in range(10):
if y % 3==0:
_.append([x,y])


_

[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

Keep It simple and stupid

七.元组 tuple

即可以像列表一样同时容纳多种对象，同时也拥有字符串不可变的特性

和列表的差别：元组用的圆括号，还可以省略，列表用的方括号

(1)元组切片

即将里面的元素单独导出来

rhyme = 1,2,3,4,5,"上山大老虎"

rhyme[1]

2

rhyme[:3]

(1, 2, 3)
rhyme[:5:2]

(1, 3, 5)
rhyme[::-1]

('上山大老虎', 5, 4, 3, 2, 1)

(2)元组只有查，只有count和index方法

nums = (3,1,9,6,8,3,5,3)

nums.count(3)

3

s = 1,2,3
t = 4,5,6
拼接
s +t
(1, 2, 3, 4, 5, 6)
s *2
(1, 2, 3, 1, 2, 3)

嵌套
w = s,t

w
((1, 2, 3), (4, 5, 6))
#迭代
for each in s:
print(each)


1
2
3
for i in w:
for each in i:
print(each)


1
2
3
4
5
6

(5)打包：生成一个元组

t = 123,"Finshc",3.14

(5)解包：把他们一次性的赋值给三个变量的行为

x,y,z=t
x
123
y
'Finshc'
z
3.14

a,b,c="ROy"
>>>a
'R'
>>>b
'O'
>>>c
'y'
>>>a,b,*c ="ROYWANG"
>>>a
'R'
>>>b
'O'
>>>c
['Y', 'W', 'A', 'N', 'G']

(6)元组里面的列表指向的东西可以被修改

t= [4,5,6]
w = (s,t)
w
([1, 2, 3], [4, 5, 6])
w[0][0] =0
w
([0, 2, 3], [4, 5, 6])

八字符串

字符串就是像元组一样不可变的序列

（1）判断是不是回文数

x = "12321"

"是回文数" if x == x[::-1] else "不是回文数"

'是回文数'

1.大小写字母换来换去方法

capitalize() 首字母大写，其他字母小写按照规则生成一个新的字符串

casefold() 所有字母都小写的新的字符串，可以处理其他字符

title() 每个单词的首字母大写，其他小写

swapcase() 大小写反转

upper() 所有的字母大写

lower() 所有的字母小写，只能处理英语

x.casefold()

'study to learn music,roy'
x.title()

'Study To Learn Music,Roy'
x.swapcase()

'sTUDY TO LEARN MUSIC,roy'
x.upper()

'STUDY TO LEARN MUSIC,ROY'
x.lower()

'study to learn music,roy'

2.左中右对齐

center(width,fillchar='') fillchar默认是空格

ljust(width,fillchar='') 左对齐

rjust(width,fillchar='') 右对齐

zfill(width) 用0去填充左边

y ="有内鬼，停止交易"

y.center(5)

'有内鬼，停止交易'
y.center(15)

' 有内鬼，停止交易 '
y.center(15,"*")

'****有内鬼，停止交易***'
y.ljust(15)

'有内鬼，停止交易 '
y.rjust(15)

' 有内鬼，停止交易'
y.zfill(15)

'0000000有内鬼，停止交易'
"-678".zfill(7)

'-000678'

3.查找功能

count(sub[,start,[,end]]) 用于查找sub参数指向的子字符串在字符串中出现的次数 end右区间取不到

find(sub[,start[,end]）用于查找sub参数指向的子字符串在字符串的索引下标，方括号表示可要可不要的内容 end右区间取不到

rfind(sub[,start[,end]])

index(sub[,start[,end]]) 是一个字符串方法，用于查找子字符串在原始字符串中的索引位置

rindex(sub[,start[,end]])

index()：如果找到子字符串，返回它在原始字符串中的索引位置；如果找不到，会引发 ValueError 异常。
find()：如果找到子字符串，返回它在原始字符串中的索引位置；如果找不到，返回 -1。

4.替换

（1）expandtabs([tabsize = 8])

是字符串方法之一，用于将字符串中的制表符（\t）(tab键）替换为空格，以便实现文本的对齐和格式化。它的语法如下：

string.expandtabs(tabsize=8)

code = """
\tprint("j")
    print("o")"""
              
new_code = code.expandtabs(4)#把制表符变成4个空格
              
print(new_code)
              

    print("j")
    print("o")
new_code = code.expandtabs(8)
              
print(new_code)
              

        print("j")
    print("o")
new_code = code.expandtabs()#默认是8个空格
              
print(new_code)
              

        print("j")
    print("o")

（2）replace(old,new,count=-1)

用于将字符串中的指定子字符串（旧子字符串）替换为新的子字符串。

string.replace(old, new, count=-1)

str.maketrans(x, y, z) 函数用于创建翻译表，它的参数如下：

string 是要进行操作的原始字符串。
old 是要被替换的旧子字符串。
new 是新的子字符串，用于替换旧子字符串。
count 是可选参数，表示替换的最大次数。默认值为 -1，表示替换所有匹配的子字符串。

text = "Hello, world! Hello, universe! Hello, galaxy!"

# 将所有的 "Hello" 替换为 "Hi"
new_text = text.replace("Hello", "Hi")
print(new_text)

# 将最多两次的 "Hello" 替换为 "Hi"
limited_replacement = text.replace("Hello", "Hi", 2)
print(limited_replacement)

Hi, world! Hi, universe! Hi, galaxy!
Hi, world! Hi, universe! Hello, galaxy!

(3)translate(table)

用于执行字符串的字符级别转换或删除操作。它需要一个翻译表（translation table）作为参数，这个表指定了字符的映射关系或要删除的字符
string.translate(table)
string 是要进行操作的原始字符串。
table 是一个翻译表，可以通过 str.maketrans() 函数创建。
x：一个字符串，包含要映射的字符
- y：另一个字符串，包含与 x 对应的映射字符。
- z：一个字符串，表示要删除的字符。
- 翻译表被传递给 translate() 方法，该方法使用表中定义的映射关系将字符串中的字符进行转换或删除操作。
- 示例
- ```
x = "I hate python"
              
table = str.maketrans("abcdef","123456")
              
new_x = x.translate(table)
              
print(new_x)
              
I h1t5 python

table = str.maketrans("abcdef","123456","I")
              
new_x = x.translate(table)
              
print(new_x)
              
 h1t5 python
```
  5.判断
- 在 Python 中，有许多字符串方法可用于判断字符串的不同特性。以下是一些常见的字符串判断方法，以及每个方法的范围和区别：
  
  1. **`isalnum()`**：
  - 范围：判断字符串是否只包含字母和数字字符。
  - 区别：不包括标点符号、空格等非字母数字字符。
  
  2. **`isalpha()`**：
  - 范围：判断字符串是否只包含字母字符。
  - 区别：不包括数字、标点符号、空格等非字母字符。
  
  3. **`isdigit()`**：
  - 范围：判断字符串是否只包含数字字符。
  - 区别：不包括字母、标点符号、空格等非数字字符。
  
  4. **`isnumeric()`**：
  - 范围：判断字符串是否只包含数字字符，包括其他数字字符（如汉字数字）。
  - 区别：比 `isdigit()` 更广泛，包括各种语言的数字字符。
  
  5. **`islower()`**：
  - 范围：判断字符串是否全部由小写字母组成。
  
  6. **`isupper()`**：
  - 范围：判断字符串是否全部由大写字母组成。
  
  7. **`istitle()`**：
  - 范围：判断字符串中的单词是否符合标题格式，每个单词的首字母大写。
  
  8. **`isspace()`**：
  - 范围：判断字符串是否只包含空白字符（空格、制表符、换行等）。
  
  9. **`startswith(prefix)`**：
  - 范围：判断字符串是否以指定的前缀开头。
  
  10. **`endswith(suffix)`**：
  - 范围：判断字符串是否以指定的后缀结尾。
  
  11. **`isdecimal()`**：
  - 范围：判断字符串是否只包含十进制数字字符。
- ```
text1 = "Hello123"
text2 = "Python"
text3 = "   "
text4 = "Title Case"

print(text1.isalnum())   # True (包含字母和数字)
print(text2.isalpha())   # True (只包含字母)
print(text1.isdigit())   # False (包含字母)
print(text2.islower())   # False (包含大写字母)
print(text3.isspace())   # True (只包含空白字符)
print(text2.startswith("Py"))  # True (以 "Py" 开头)
print(text2.endswith("on"))    # True (以 "on" 结尾)
print(text4.istitle())  # True (每个单词首字母大写)
```
  12. **`isascii()`**：
  - 范围：判断字符串是否只包含 ASCII 字符。SCII 字符是在 ASCII 编码范围内（0-127）的字符，包括字母、数字、标点符号等。
- ```
text1 = "Hello, world!"
text2 = "你好，世界！"

print(text1.isascii())  # True
print(text2.isascii())  # False
```
  13. **`isprintable()`**：可打印字符是指在屏幕上显示出来并占据宽度的字符，包括字母、数字、标点符号等。
  - 范围：判断字符串是否只包含可打印字符。转义字符不可打印
- ```
text3 = "Hello, world!"
text4 = "Hello\nworld!"

print(text3.isprintable())  # True
print(text4.isprintable())  # False
```
  14. **`isidentifier()`**：
  - 范围：判断字符串是否是合法的 Python 标识符（identifier）。
- ```
text5 = "variable_name"
text6 = "123identifier"

print(text5.isidentifier())  # True
print(text6.isidentifier())  # False
```
  15.可以引入keyword模块中的iskeyword函数来判断字符是不是特定的关键字

import keyword
keyword.iskeyword("if")
True
keyword.iskeyword("po")
False

6.截取

strip(chars = None)该方法返回一个去除了前导和尾随字符的字符串副本。如果提供了 chars 参数，它指定要从字符串的开头和结尾删除的字符集。如果未提供 chars 参数或设置为 None，则默认会删除空白字符（空格、制表符和换行符）。
lstrip(chars = None) 该方法返回一个去除了前导字符的字符串副本。
rstrip(chars = None).去除尾随字符的字符串
removeprefix(prefix)返回一个从开头删除了指定前缀的字符串副本。如果字符串以给定的 prefix 开头，它会被删除；否则，字符串将保持不变。
removesuffix(suffix)返回一个从结尾删除了指定后缀的字符串副本。
text = " 你好，世界！ "

# 使用 strip()
stripped_text = text.strip()
print(stripped_text) # 输出: "你好，世界！"

# 使用 lstrip() 和 rstrip()
left_stripped = text.lstrip()
right_stripped = text.rstrip()
print(left_stripped) # 输出: "你好，世界！ "
print(right_stripped) # 输出: " 你好，世界！"

# 使用 removeprefix() 和 removesuffix()
prefixed_text = "abc_你好"
suffixed_text = "世界_xyz"
removed_prefix = prefixed_text.removeprefix("abc_")
removed_suffix = suffixed_text.removesuffix("_xyz")
print(removed_prefix) # 输出: "你好"
print(removed_suffix) # 输出: "世界"
7.拆分和拼接
(1)partition(sep)
该方法将字符串分成三个部分，分别是分隔符 sep 左边的部分、分隔符本身以及分隔符右边的部分。如果字符串中包含多个相同的分隔符，该方法将使用第一个分隔符进行分割。返回一个包含三个元素的元组：左边部分、分隔符本身和右边部分。
(2)rpartition(sep)
类似于 partition() 方法，但它从字符串的右侧开始查找分隔符，然后将字符串分成三个部分，分别是分隔符左边的部分、分隔符本身以及分隔符右边的部分。如果字符串中包含多个相同的分隔符，该方法将使用最后一个分隔符进行分割。同样返回一个包含三个元素的元组
text = "apple:banana:cherry"

# 使用 partition()
left, sep, right = text.partition(":")
print(left) # 输出: "apple"
print(sep) # 输出: ":"
print(right) # 输出: "banana:cherry"

# 使用 rpartition()
left, sep, right = text.rpartition(":")
print(left) # 输出: "apple:banana"
print(sep) # 输出: ":"
print(right) # 输出: "cherry"

(3)split(sep=None, maxsplit=-1)：
这个方法通过指定的分隔符 sep 将字符串分割成多个子字符串，并返回一个包含这些子字符串的列表。如果未提供 sep 参数，方法默认使用空白字符（空格、制表符、换行符等）作为分隔符。可选的 maxsplit 参数可以用于指定最大分割次数。如果 maxsplit 为正数，将最多分割出 maxsplit+1 个子字符串；如果为负数或未指定，将尽可能多地分割。
(4)splitlines(keepends=False)：
这个方法根据换行符 \n（或 \r\n）将字符串拆分成多行，并返回一个包含这些行的列表。可选的 keepends 参数用于控制是否保留行的换行符。如果 keepends 为 True，则换行符会被保留在行的末尾。
text = "apple,banana,cherry,orange"

fruits = text.split(",")
fruits
['apple', 'banana', 'cherry', 'orange']
multitline_text = "Line 1\nLine 2\nLine 3"
lines = multitline_text.splitlines()
lines
['Line 1', 'Line 2', 'Line 3']

`(5)join方法`

join() 方法是用于连接字符串序列（例如列表或元组）中的各个元素，将它们合并成一个单独的字符串。这个方法接受一个可迭代对象作为参数，并将其中的元素用指定的字符串连接起来。返回的结果是一个新的字符串。

".".join(["www","ilove","com"])
'www.ilove.com'
"^".join(["www","iloce","com"])
'www^iloce^com'

8.格式化字符串format

`(1)format()`

是一种用于格式化字符串的方法。它允许您将变量、表达式和其他值插入到字符串中，从而创建具有特定格式的字符串。

formatted_string = "format_string".format(arguments)

{}：作为默认占位符，将被 format() 中的参数替换。
{0}、{1}、{2} 等：使用索引来指定要替换的参数的位置。
{key}：使用关键字参数的名称来指定要替换的值。

"{}看到{}很激动".format("me","roy")
'me看到roy很激动'
"{1}看到{0}很激动".format("me","roy")
'roy看到me很激动'
"{1}看到{1}很激动".format("me","roy")
'roy看到roy很激动'
"我叫{name},I love {fav}.".format(name = "roy",fav = "singing")
'我叫roy,I love singing.'
"{},{},{}".format(1,"{}",2)
'1,{},2'
"{},{{}},{}".format(1,2)
'1,{},2'

(2)"align"（对齐）

通常用于描述字符串在输出或格式化文本中对齐的操作。在字符串的格式说明符中，使用 <、>、^ 来分别表示左对齐、右对齐和居中对齐。然后通过 : 后面的数字来指定字段的宽度。字符串会根据指定的对齐方式在这个宽度内进行排列。
. **填充字符**：可以在对齐格式中使用填充字符来填充字段。例如，`{:*^10}` 表示居中对齐，使用 `*` 填充，宽度为 10。

"{:<10}".format(  456  )
'456       '
"{:>10}".format(  456  )
'       456'
"{:^10}".format(  456  )
'   456    '
"{1:>10}{0:<10}".format(520,250)
'       250520       '
"{right:>10}{left:<10}".format(right=520,left=250)
'       520250       '
"{:010}".format(520)
'0000000520'
"{:%>10}".format(520)
'%%%%%%%520'
"{:0=10}".format(520)
'0000000520'
"{:0=10}".format(-520)
'-000000520'

(3)'+''-'空格

'+' 正数在前面添加正号（+），负数在前面添加（-）
‘-’ 只有负数在前面添加
空格正数在前面添加一个空格，负数在前面添加负号（-）
"{:+} {:-}".format(8,-9)
'+8 -9'
（4） **数字格式化**：
在占位符中可以使用 `:.n` 来指定小数点后的位数，也可以使用其他数字格式选项，如 `{:.2f}` 表示保留两位小数的浮点数。
"{:.2f}".format(2.4568)
'2.46'

（5） **千位分隔符**：
通过在数字格式中使用 `,` 可以实现千位分隔符，例如 `{:,}`。
"{:,}".format(1234)
'1,234'

（6） **进制转换**：
可以使用 `{:x}`、`{:o}`、`{:b}` 等格式来进行十六进制、八进制和二进制的转换。'c'参数以Unicode字符形式，‘d'十进制
"{:x}".format(24)
'18'
"{:b}".format(2)
'10'
"{:o}".format(2)
'2'
"{:o}".format(9)
'11'
"{:#o}".format(9)
'0o11'
"{:#x}".format(24)
'0x18'
"{:f}".format(3.1415926)
'3.141593'
#默认是6个精度
"{:g}".format(123456789)
'1.23457e+08'
"{:g}".format(12345.6789)
'12345.7'
"{:%}".format(0.98)
'98.000000%'
"{:.2%}".format(0.98)
'98.00%'
"{:.{prec}f}".format(3.1415,prec =3)
'3.142'

"{:{fill}{align}{width}{prec}{ty}}".format(3.1415,fill = '+',align ='^',width = 10,prec = 3,ty = 'g')
'++++++++++++++++++++++++++++++++++++++++++++++++3.1415+++++++++++++++++++++++++++++++++++++++++++++++++'

（7）. 日期和时间格式化：

可以使用 `{:%Y-%m-%d}` 等格式将日期和时间格式化为特定的字符串。
（8）. **字典和列表访问**：
通过在占位符中使用索引或键，可以访问列表和字典中的元素。

（9）. **f-strings（格式化字符串字面值）**：
从 Python 3.6 开始引入的 f-strings 是一种更简洁和易读的字符串格式化方式，可以直接在字符串前加上 `f`，或者'F'然后在字符串中使用 `{}` 插入变量或表达式。

f"1+1 = {2}"
'1+1 = 2'
f"{520:010}"
'0000000520'
f"{123445:,}"
'123,445'
f"{235.34:2f}"
'235.340000'
f"{235.3467:.2f}"
'235.35'

九序列
列表元组和字符串

1. 加法和乘法

2.增量赋值

列表的唯一标识是不会改变的。 id函数就是返回唯一标

3.is is not

is 用于比较两个对象是否是同一个对象，即它们在内存中的地址是否相同。
is not 则是 is 的相反，用于判断两个对象是否不是同一个对象。

x = [1, 2, 3]
y = x

print(x is y)       # True，因为 x 和 y 引用同一个对象
print(x is not y)   # False，因为 x 和 y 引用同一个对象

4 in not in

in 用于检查一个值是否存在于一个序列（如列表、元组、字符串等）中。
not in 则是 in 的相反，用于检查一个值是否不存在于一个序列中。

my_list = [1, 2, 3, 4, 5]

print(3 in my_list)     # True，因为 3 存在于 my_list 中
print(6 not in my_list) # True，因为 6 不存在于 my_list 中

（1）补充python驻留机制

在Python中，**驻留机制（Interning Mechanism）**是一种优化策略，用于缓存并重用一些简单、不可变的对象，以提高内存使用效率和比较操作的性能。Python中的一些对象会被缓存起来，使得多个变量引用同一个对象，从而节省内存空间。

驻留机制的工作方式如下：

1.1. 整数对象的驻留：
** 在Python中，一些范围内的整数会被预先创建并缓存起来。通常，范围是-5到256。这意味着，当你创建一个位于这个范围内的整数对象时，多个变量引用的都是同一个对象。

1.2. 字符串对象的驻留：
** Python还会对某些字符串进行驻留，例如空字符串 `""` 和单个字符字符串（如 `"a"`）。这样，多个变量引用相同内容的字符串时，它们也会引用同一个对象。

1.3. 其他对象的驻留：
** 一些其他不可变的对象，如小的字符（如 '\n'，'\t'）也可能被驻留。

驻留机制的目标是减少内存占用，以及在比较操作（例如 `is` 运算符）时提供更高的性能。但需要注意的是，这种优化策略通常只适用于简单的、不可变的对象。对于较复杂的对象、动态生成的对象，以及可变对象（如列表、字典），驻留机制可能不适用。

示例：
```python
a = 10
b = 10
print(a is b) # True，因为整数10在范围内被驻留

x = "hello"
y = "hello"
print(x is y) # True，因为相同内容的字符串被驻留

s1 = "hello world"
s2 = "hello world"
print(s1 is s2) # False，这种字符串通常不被驻留

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 is list2) # False，可变对象通常不被驻留
```

尽管驻留机制可以提高一些操作的性能，但在实际编程中，通常不应该依赖于对象的驻留状态，而是应该使用适当的比较操作来判断对象的相等性。使用 `==` 来比较值是否相等，使用 `is` 来比较对象是否为同一个对象。

5 del

在Python中，`del` 是一个用于删除对象的关键字。它可以用于删除变量、元素、属性等不需要的对象，以释放内存或者改变程序状态。以下是 `del` 关键字的一些常见用法：

(1) 删除变量：
** 使用 `del` 可以删除一个变量，释放其引用的对象并且从命名空间中移除变量名。

```python
x = 10
del x # 删除变量 x
```

(2). 删除列表中的元素：
** 使用 `del` 可以删除列表中的指定索引位置的元素。

```python
my_list = [1, 2, 3, 4, 5]
del my_list[2] # 删除索引为2的元素，my_list变为 [1, 2, 4, 5]
```

(3). 删除字典中的键值对：
** 使用 `del` 可以删除字典中指定的键值对。

```python
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b'] # 删除键为 'b' 的键值对，my_dict变为 {'a': 1, 'c': 3}
```

(4). 删除属性：
** 使用 `del` 可以删除对象的属性。

```python
class MyClass:
def __init__(self):
self.x = 10

obj = MyClass()
del obj.x # 删除 obj 的属性 x
```

(5). 删除切片范围内的元素：
** 使用 `del` 可以删除列表或其他可变序列的切片范围内的元素。

```python
my_list = [1, 2, 3, 4, 5]
del my_list[1:3] # 删除索引1到2的元素，my_list变为 [1, 4, 5]
```

请注意，使用 `del` 删除对象不一定会立即释放对象占用的内存，Python会在适当的时机自动回收不再使用的内存。此外，`del` 仅会删除变量引用或对象的一部分，它不会影响其他引用同一对象的变量。在使用 `del` 时要小心，确保不会引起意外的副作用。

6.序列中的函数

（1）列表，元组和字符串的相互转换

1.1list()

函数用于创建一个新的列表，可以将其他可迭代对象（如字符串、元组、集合等）转换为列表。如果没有提供参数，将返回一个空列表。

empyt_list = list()# 创建一个空列表
numbers =(1,2,30)
list(numbers)# 将元组转换为列表
[1, 2, 30]
string_list = list("hello")# 将字符串转换为列表，每个字符成为列表中的一个元素
string_list
['h', 'e', 'l', 'l', 'o']

1.2 tuple()

函数用于创建一个新的元组，可以将其他可迭代对象转换为元组。如果没有提供参数，将返回一个空元组。

empty_typle = tuple()
numbers_list = [1,2,3]
numbers_tuple = tuple(numbers_list)
numbers_tuple
(1, 2, 3)  # 将列表转换为元组

1.3str()

函数用于创建一个新的字符串，可以将对象转换为字符串。如果没有提供参数，将返回一个空字符串。

empty_string = str()
number =42
number_string = str(number)
number_string
'42' # 将数字转换为字符串

要注意，这些函数仅用于创建新的序列，而不会修改原始对象。

(2)min()

函数用于找出序列中的最小值。它可以用于数字序列、字符串序列等。对于字符串序列，它会找到字母表中的最小字符。

numbers = [5, 2, 8, 1, 9]
min_number = min(numbers)  # 找出最小值，即1

words = ["apple", "banana", "cherry"]
min_word = min(words)  # 找出最小字符串，即"apple"

(3)max()

函数用于找出序列中的最大值。与 min() 类似，它可以用于数字序列、字符串序列等。

numbers = [5, 2, 8, 1, 9]
max_number = max(numbers)  # 找出最大值，即9

words = ["apple", "banana", "cherry"]
max_word = max(words)  # 找出最大字符串，即"cherry"

(4)len()

函数用于获取序列的长度，即序列中元素的数量。

numbers = [5, 2, 8, 1, 9]
length = len(numbers)  # 获取序列的长度，即5

text = "Hello, world!"
text_length = len(text)  # 获取字符串的长度，即13

(5)sum()

函数用于计算数字序列的和。

numbers = [5, 2, 8, 1, 9]
total = sum(numbers)  # 计算序列的和，即25

(6)sorted()

函数用于对可迭代对象（如列表、元组、字符串等）进行排序，并返回一个新的已排序的列表

numbers = [5, 2, 8, 1, 9]
sorted_numbers = sorted(numbers)
sorted_numbers
[1, 2, 5, 8, 9]
text = "python"
sorted_text = sorted(text)
sorted_text
['h', 'n', 'o', 'p', 't', 'y']

(7)reversed()

函数用于返回一个反向迭代器，可以用于反转序列中的元素。需要注意的是，reversed() 返回的是迭代器，需要将其转换为列表或其他序列类型来查看反转后的内容。
```
numbers = [5, 2, 8, 1, 9]
reversed_numbers = reversed(numbers)
reversed_list = list(reversed_numbers)  # 反转数字列表，得到 [9, 1, 8, 2, 5]
```

(8)all()

函数用于判断可迭代对象中的所有元素是否都为真（即不为零、空、False 等）。如果所有元素都为真，则返回 True，否则返回 False。
```
values = [True, True, False, True]
result = all(values)  # 返回 False，因为有一个元素为 False
```

(9)any()

函数用于判断可迭代对象中的任意一个元素是否为真。如果至少有一个元素为真，则返回 True，否则返回 False。
```
values = [False, False, True, False]
result = any(values)  # 返回 True，因为有一个元素为 True
```

(10)enumerate()

函数用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，返回一个包含索引和元素的元组。通常在循环中同时迭代索引和元素时使用。
```
words = ["apple", "banana", "cherry"]
for index,word in enumerate(words):
    print(index,word)

    
0 apple
1 banana
2 cherry
```

（11）zip()

数用于将多个可迭代对象逐个配对组合，返回一个包含元组的迭代器。它可以用于同时迭代多个序列。

numbers = [1, 2, 3]
letters = ["a", "b", "c"]
zipped = zip(numbers, letters)
for num, letter in zipped:
     print(num, letter)

     
1 a
2 b
3 c

（12）map()

函数用于对可迭代对象中的每个元素应用一个函数，返回一个迭代器。它可以将一个函数应用到序列的每个元素上。

mapped = map(ord,"FINSH")
for each in mapped:
    print(each)

    
70
73
78
83
72
list(mapped)
[]

（13）filter()

函数用于根据指定的条件过滤可迭代对象中的元素，返回一个迭代器。它可以用于过滤出符合条件的元素。
```
def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(is_even, numbers)  # 过滤出偶数
```
迭代器/可迭代对象
一个迭代器肯定是一个可迭代对象，可迭代对象可以重复使用而迭代器则是一次性的
列表，字符串，元组都是可迭代对象

（17）iter()

iter() 是一个内置函数，用于创建一个迭代器对象，使得可以对可迭代对象（如列表、字符串、字典等）进行迭代操作。迭代器是一种可以逐个访问元素的对象，可以使用 next() 函数来获取下一个元素。

iter() 函数接受一个参数，该参数可以是一个可迭代对象，也可以是一个带有 __next__() 方法的对象（即自定义迭代器）。调用 iter() 函数会返回一个迭代器对象。

numbers = [1, 2, 3, 4, 5]
iter_numbers = iter(numbers)  # 创建一个迭代器对象

print(next(iter_numbers))  # 输出 1
print(next(iter_numbers))  # 输出 2
print(next(iter_numbers))  # 输出 3

在循环中，Python 会自动使用 iter() 函数将可迭代对象转换为迭代器，从而实现循环遍历

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

十.字典

唯一具有映射关系，典（Dictionary）是一种无序的数据结构，用于存储键-值对（Key-Value pairs）的集合。它可以用来存储和管理数据，其中每个键都唯一且与一个值相关联。

1.创建字典

（1）字面值（Literal）创建：

使用花括号 `{}` 来创建一个字典，其中包含键值对。例如：

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

(2.)dict() 构造函数创建：

使用 `dict()` 构造函数来创建字典，可以传入键值对作为参数。例如：

my_dict = dict(name='Bob', age=25, city='Los Angeles')

(3.) 列表推导式创建

可以使用列表推导式来创建字典。例如，从两个列表创建字典：

keys = ['name', 'age', 'city']
values = ['Eve', 28, 'Chicago']
my_dict = {keys[i]: values[i] for i in range(len(keys))}
```

(4). zip() 函数创建

使用 `zip()` 函数将两个可迭代对象（通常是两个列表）打包成一个元组序列，然后通过 `dict()` 构造函数将其转换为字典。例如：
keys = ['name', 'age', 'city']
values = ['Grace', 33, 'San Francisco']
my_dict = dict(zip(keys, values))

(5). 字典推导式创建

类似于列表推导式，可以使用字典推导式来创建字典。例如，从一个列表创建字典：

data = [('name', 'John'), ('age', 22), ('city', 'Seattle')]
my_dict = {key: value for key, value in data}

(6) 使用 fromkeys() 方法

使用 `dict.fromkeys()` 方法创建一个字典，其中的键来自一个可迭代对象，值都设置为相同的默认值（默认为 `None`）。例如：

keys = ['name', 'age', 'city']
default_value = 'Unknown'
my_dict = dict.fromkeys(keys, default_value)

2.访问字典

print(my_dict['name']) # 输出：Alice

Python字典常用的内置方法，它们用于获取字典中的键、值和键值对。

2.1. `.keys()` 方法：

这个方法用于获取字典中所有的键，返回一个包含所有键的可迭代对象（通常是一个列表）。例如：
```python
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
keys = my_dict.keys()
print(keys) # 输出：dict_keys(['name', 'age', 'city'])
```

2.2. `.values()` 方法：

这个方法用于获取字典中所有的值，返回一个包含所有值的可迭代对象（通常是一个列表）。例如：
```python
values = my_dict.values()
print(values) # 输出：dict_values(['Alice', 30, 'New York'])
```

2.3. `.items()` 方法：

这个方法用于获取字典中所有的键值对，返回一个包含所有键值对的可迭代对象（通常是一个列表，每个元素是一个包含键和值的元组）。例如：
```python
items = my_dict.items()
print(items) # 输出：dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])
```

3.增

3.1.使用赋值运算符 `=`

可以添加新的键值对或修改已有的键值对。

my_dict = {'name': 'Alice', 'age': 30}
my_dict['city'] = 'New York' # 添加新键值对
my_dict['age'] = 31 # 修改已有键的值
```

3.2. setdefault() 方法：

添加键值对，如果键不存在，则插入指定的键值对。
```python
my_dict = {'name': 'Bob'}
my_dict.setdefault('age', 25) # 添加键值对 age: 25
```

4.删除操作：

4.1. del 语句：

使用 `del` 语句可以删除指定的键值对。
```python
my_dict = {'name': 'Alice', 'age': 30}
del my_dict['age'] # 删除键为 'age' 的键值对
```

42. pop() 方法：

根据键删除对应的键值对，并返回值。可以提供默认值，用于键不存在时返回。
```python
my_dict = {'name': 'Alice', 'age': 30}
deleted_age = my_dict.pop('age') # 删除键为 'age' 的键值对，并返回 30
```

4.3. popitem() 方法：

随机删除并返回一个键值对。3.7以后是删除最后一个
```python
my_dict = {'name': 'Alice', 'age': 30}
removed_item = my_dict.popitem() # 随机删除并返回一个键值对，如 ('age', 30)
```

4.4 clear

用于清空所有键值对的方法。调用这个方法会将字典中的所有内容删除，使其变为空字典

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
print("Before clear:", my_dict)

my_dict.clear() # 清空字典中的所有键值对

print("After clear:", my_dict) # 输出：{}

5.修改操作：

5.1. 直接赋值：

通过键访问相应的值，并进行修改。
```python
my_dict = {'name': 'Alice', 'age': 30}
my_dict['name'] = 'Alicia' # 修改键 'name' 的值为 'Alicia'
```

5.2 update

用于将另一个字典的键值对更新到当前字典中，或者用其他可迭代对象中的键值对来更新当前字典。如果存在相同的键，会用新值更新旧值。

my_dict = {'name': 'Alice', 'age': 30}
new_data = {'age': 31, 'city': 'New York'}

my_dict.update(new_data)

print(my_dict)
# 输出：{'name': 'Alice', 'age': 31, 'city': 'New York'}

5.3 copy

用于创建一个字典的浅拷贝副本，该副本包含原字典中相同的键值对。修改副本不会影响原字典，反之亦然。

original_dict = {'name': 'Alice', 'age': 30}
copied_dict = original_dict.copy()

copied_dict['age'] = 31 # 修改副本的值，不会影响原字典

print(original_dict)
# 输出：{'name': 'Alice', 'age': 30}

print(copied_dict)
# 输出：{'name': 'Alice', 'age': 31}

6查询操作：

6.1. 使用键访问值：

通过键访问字典中的值。
```python
my_dict = {'name': 'Alice', 'age': 30}
name_value = my_dict['name'] # 获取键 'name' 对应的值
```

6.2. get() 方法：

通过键获取对应的值，可以提供默认值，用于键不存在时返回。
```python
my_dict = {'name': 'Alice', 'age': 30}
name_value = my_dict.get('name', 'Unknown') # 获取键 'name' 对应的值，不存在时返回 'Unknown'
```

6.3. in 关键字：

使用 `in` 关键字检查键是否存在于字典中。
```python
my_dict = {'name': 'Alice', 'age': 30}
if 'name' in my_dict:
print("Name exists in the dictionary")
```

7.字典长度len

length = len(my_dict)

8.嵌套字典

指在一个字典中包含另一个或多个字典作为值的情况。嵌套字典可以帮助您组织更复杂的数据结构，以便于存储和访问层次化的信息

# 一个简单的嵌套字典示例
student_records = {
    'Alice': {'age': 20, 'grade': 'A'},
    'Bob': {'age': 22, 'grade': 'B'},
    'Eve': {'age': 21, 'grade': 'A'}
}

# 访问嵌套字典中的值
alice_age = student_records['Alice']['age']  # 获取 Alice 的年龄，输出：20
bob_grade = student_records['Bob']['grade']  # 获取 Bob 的成绩，输出：B

# 添加新的嵌套字典
student_records['Charlie'] = {'age': 23, 'grade': 'C'}

# 遍历嵌套字典
for name, info in student_records.items():
    print(name)
    print('  Age:', info['age'])
    print('  Grade:', info['grade'])

# 输出：
# Alice
#   Age: 20
#   Grade: A
# Bob
#   Age: 22
#   Grade: B
# Eve
#   Age: 21
#   Grade: A
# Charlie
#   Age: 23
#   Grade: C

9.不可变性：

字典中的键是不可变的，可以是字符串、数字、元组等不可变类型，但不能是列表等可变类型。十一.集合见菜鸟教程

十二.函数

函数只有在定义和调用的时候才会用到小括号，返回值时不用

1.闭包函数

闭包是一种编程概念，它允许函数捕获并记住其定义时周围的变量。换句话说，一个闭包函数可以访问它所在作用域中的变量，即使这个作用域已经结束了。

（1）利用嵌套函数的外层作用域具有记忆功能这个特性和将内层函数作为返回值给返回

在 Python 中，闭包是通过在一个函数内部定义另一个函数，并且内部函数可以访问外部函数的局部变量来实现的。下面是一个闭包函数的示例：

```python
def outer_function(x):
def inner_function(y):
return x + y
return inner_function

# 创建闭包函数
closure = outer_function(10)

# 调用闭包函数
result = closure(5) # 这里的 x 是 10，y 是 5
print(result) # 输出 15
```

在这个示例中，`outer_function` 是一个外部函数，它接受一个参数 `x`。在 `outer_function` 内部，我们定义了一个名为 `inner_function` 的内部函数，它接受参数 `y`。内部函数可以访问外部函数的 `x`，尽管外部函数已经执行完毕。

通过调用 `outer_function(10)`，我们创建了一个闭包函数 `closure`，它捕获了外部函数的 `x` 值为 10。然后，我们可以通过调用 `closure(5)` 来调用闭包函数，它会将外部函数的 `x`（即 10）与传入的 `y`（即 5）相加，得到结果 15。

闭包在许多情况下都很有用，特别是在需要保持状态或在函数之间共享数据时。

（2）你提供的代码片段是一个嵌套函数的示例，目的是创建一个用于计算指定幂次方的函数。代码中的 `power` 函数返回了一个名为 `exp_of` 的内部函数，它接受一个参数 `base` 并返回 `base` 的 `exp` 次幂。

```python
def power(exp):
def exp_of(base):
return base ** exp
return exp_of

# 创建一个计算平方的函数
square = power(2)
print(square(4)) # 输出 16，因为 4 的平方是 16

# 创建一个计算立方的函数
cube = power(3)
print(cube(3)) # 输出 27，因为 3 的立方是 27
```

在这个例子中，`power` 函数返回了一个嵌套的 `exp_of` 函数，然后我们通过调用 `power` 函数并传入指数来创建一个新的函数（例如 `square` 和 `cube`），并使用这些新函数来计算平方和立方。

（3）将函数作为参数传递给另一个函数

例子：

import time
def time_master(func):
print("开始运行程序")
start = time.time()
func()
stop = time.time()
print("结束程序运行")
print(f"一共耗费了{(stop-start):.2f}秒")

def myfunc():
time.sleep(2)
print("Hello finshc")

>>>time_master(myfunc)
开始运行程序
Hello finshc
结束程序运行
一共耗费了2.07秒

2.装饰器

（1）定义：

它允许你在不修改原始函数代码的情况下，动态地扩展或修改函数的行为。装饰器本质上是一个函数，它接受另一个函数作为参数，并返回一个新的函数。

(2)装饰器的语法使用@符号紧跟着装饰器函数的名称，放在要被装饰的函数之前。下面是一个简单的示例，说明如何定义和使用装饰器：

# 定义一个装饰器函数
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()  # 调用原始函数
        print("Something is happening after the function is called.")
    return wrapper

# 应用装饰器
@my_decorator
def say_hello():
    print("Hello!")

# 调用被装饰的函数
say_hello()



>>>Something is happening before the function is called.
Hello!
Something is happening after the function is called.

在这个示例中，my_decorator 是一个装饰器函数，它接受一个函数 func 作为参数，然后返回一个新的函数 wrapper。wrapper 函数在调用原始函数之前和之后，添加了额外的输出。

通过在 say_hello 函数定义之前使用 @my_decorator，我们将 say_hello 函数应用了装饰器。当我们调用 say_hello 函数时，实际上是调用了被装饰后的 wrapper 函数。

上述代码等同于

# 定义一个装饰器函数
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()  # 调用原始函数
        print("Something is happening after the function is called.")
    return wrapper


def say_hello():
    print("Hello!")

say_hello = my_decorator(say_hello)
say_hello()



>>>Something is happening before the function is called.
Hello!
Something is happening after the function is called.

（3）多个装饰器

3.1当一个函数被多个装饰器装饰时，装饰器的调用顺序是从上到下的，即从最近函数定义处的装饰器开始，一直到最外层的装饰器。这意味着最内层的装饰器将首先被调用，然后是外层的装饰器，以此类推，直到达到原始函数本身。

3.2

def decorator_a(func):
    def wrapper():
        print("Decorator A: Something before function A is called.")
        func()
        print("Decorator A: Something after function A is called.")
    return wrapper

def decorator_b(func):
    def wrapper():
        print("Decorator B: Something before function B is called.")
        func()
        print("Decorator B: Something after function B is called.")
    return wrapper

@decorator_b
@decorator_a
def my_function():
    print("Inside the original function.")

my_function()


============== RESTART: /Users/chuwenjing/Documents/time_master.py =============
Decorator B: Something before function B is called.
Decorator A: Something before function A is called.
Inside the original function.
Decorator A: Something after function A is called.
Decorator B: Something after function B is called.

在这个示例中，@decorator_a 和 @decorator_b 是两个装饰器。my_function 函数应用了这两个装饰器，首先是 @decorator_b，然后是 @decorator_a。

当调用 my_function() 时，装饰器的调用顺序是先 decorator_b，然后是 decorator_a，然后才是原始函数本身。输出将会按照这个顺序进行。这个顺序是由于装饰器在函数定义时从上到下依次应用的特性所决定的。

例子：

def add(func):
    def inner():
        x = func()
        return x + 1
    return inner
def cube(func):
    def inner():
        x = func()
        return x * x * x
    return inner
def square (func):
    def inner():
        x = func()
        return x * x
    return inner
@add
@cube
@square
def test():
    return 2

print(test())
>>65

(4)如何给装饰器传递参数

要给装饰器传递参数，你需要创建一个额外的函数，这个函数接受装饰器参数，并返回一个装饰器函数。这个额外的函数相当于一个工厂，用于生成具有特定参数的装饰器。

以下是一个示例，演示如何给装饰器传递参数：

```python
def my_decorator(param):
def decorator(func):
def wrapper(*args, **kwargs):
print(f"Decorator: Received parameter {param}")
result = func(*args, **kwargs)
print("Decorator: Function execution finished")
return result
return wrapper
return decorator

@my_decorator("example_param")
def my_function():
print("Inside the original function.")

my_function()
```

============== RESTART: /Users/chuwenjing/Documents/time_master.py =============
Decorator: Received parameter example_param
Inside the original function.
Decorator: Function execution finished

在这个示例中，`my_decorator` 函数是一个接受参数的工厂函数，返回一个装饰器函数 `decorator`。装饰器函数 `decorator` 在调用被装饰的函数前后输出信息。

当应用装饰器时，你可以在 `@my_decorator(...)` 中传递参数，这个参数将被传递到 `my_decorator` 工厂函数中。在 `wrapper` 函数内部，你可以使用传递的参数进行特定操作。

运行这段代码后，你会看到输出中包含有关参数和函数执行的信息。

总结来说，给装饰器传递参数需要使用两层嵌套的函数结构，第一层是参数接收的工厂函数，第二层是装饰器函数本身。这样可以实现装饰器的参数化。

3.lambda表达式--函数

Lambda表达式是Python中的一种匿名函数表示方式。它允许你在一行代码中定义简单的函数，而无需使用`def`关键字来定义命名函数。Lambda表达式通常用于传递简短的功能块给其他函数，如`map`、`filter`和`sorted`等。

Lambda表达式的基本语法如下：

```python
lambda arguments: expression
```

其中，`arguments`是函数的参数，可以是零个或多个参数，用逗号分隔。`expression`是一个表达式，表示函数的返回值。

以下是一些使用Lambda表达式的示例：

1. 加法函数：

```python
add = lambda x, y: x + y
result = add(3, 5) # 结果为 8
```

2. 平方函数：

```python
square = lambda x: x ** 2
result = square(4) # 结果为 16
```

3. 使用Lambda与`map`函数：

```python
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
# 结果为 [1, 4, 9, 16, 25]
```

4. 使用Lambda与`filter`函数：

```pytho
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
# 结果为 [2, 4, 6, 8, 10]
```

Lambda表达式的优势在于它们可以轻松地定义简单的函数，但是对于较复杂的逻辑，仍然推荐使用命名函数。Lambda表达式不适合于所有情况，但在某些情况下，它们可以使代码更加简洁和易读。

回顾：

map() 是 Python 中的一个内置函数，用于将一个函数应用于一个或多个可迭代对象（例如列表、元组等）的每个元素，并返回一个包含结果的迭代器。

map(function, iterable)
function 是要应用于每个元素的函数，而 iterable 是一个或多个可迭代对象，比如列表或元组。map() 函数将会返回一个迭代器，其中包含了将 function 应用于 iterable 中每个元素所得到的结果。

filter() 是 Python 中的另一个内置函数，它用于筛选一个可迭代对象中满足特定条件的元素，并返回一个包含符合条件的元素的迭代器。

filter(function, iterable)

其中，function 是用于判断每个元素是否满足条件的函数，而 iterable 是要筛选的可迭代对象，比如列表或元组。filter() 函数将返回一个迭代器，其中包含满足条件的元

4.生成器--函数

有没有办法让函数在退出之后还能保留状态呢

闭包或者全局变量都不太好

还可以用生成器

生成器对象不可以使用索引

生成器（Generators）是一种特殊类型的函数，它们在需要的时候产生（yield）一个值，而不是一次性计算并返回所有的值。这使得生成器非常适合处理大量的数据或者无限序列，因为它们不需要将所有的数据存储在内存中。

生成器的函数定义和普通函数类似，但使用了 `yield` 关键字来产生值。每次调用生成器函数时，它会从上次 `yield` 的地方恢复执行，并在下次 `yield` 处暂停。以下是一个生成器函数的示例：

```python
def countdown(n):
while n > 0:
yield n
n -= 1

# 创建生成器对象
counter = countdown(5)

# 使用生成器产生值
for num in counter:
print(num)
```

在这个示例中，`countdown` 函数是一个生成器函数，它产生从 `n` 倒数到 1 的序列。每次调用 `yield`，生成器函数会暂停并返回当前的值。通过使用 `for` 循环来迭代生成器，我们可以逐个获取生成器产生的值。

生成器表达式

(i ** 2 for i in range(10))
<generator object <genexpr> at 0x102f47100>
t = (i **2 for i in range(10))
next(t)
0
next(t)
1
next(t)
4
next(t)
9
for i in t:
    print(i)

    
16
25
36
49
64
81

5.递归--函数

过程向结果条件推进

（1）阶乘

def factRecur(n):
if n == 1:
return 1
else:
return n * factRecur(n-1)

（2）菲比纳妾数列

def fab(n):
if n <= 0:
return 0
elif n == 1:
return 1
else:
return fab(n-1) + fab(n-2)

（3）汉诺塔--函数

def hanoi(n,x,y,z)
    if n == 1:
        print(x,'-->',z)#如果只有一层，直接将金片从x鱼冻到z
    else:
        hanoi(n-1,x,z,y)#将x上n-1个移动到y
        print(x,'-->',z)
        hanoi(n-1,y,x,z)#将y上n-1个移动到z

n = int(input('请输入汉诺塔层数：')
hanoi(n,'A','B',"C')

6.函数文档

>>>help(print)

自己写的函数编写说明

def exchange(dollar,rate=6.32):
"""
gone能：汇率转化，美元-》人民币
参数：
-dollar 美元数量
-rate 汇率默认值
"""
return dollar * rate

exchange(20)
126.4

help(exchange)
Help on function exchange in module __main__:

exchange(dollar, rate=6.32)
gone能：汇率转化，美元-》人民币
参数：
-dollar 美元数量
-rate 汇率默认值

def times(s:str,n:int) ->str:
return s *n

times("finc",5)
'fincfincfincfincfinc'
#字符注释

7.内省

内省（Introspection）是指在程序运行时检查对象的能力，以获取有关对象自身的信息，如对象的类型、属性、方法等。在Python中，你可以使用一些内置的函数和特殊的属性来进行内省操作。

以下是一些常用的内省工具和技术：

1. **`type()` 函数：**
`type(obj)` 函数用于获取对象的类型。例如：`type(5)` 将返回 `<class 'int'>`。

2. **`dir()` 函数：**
`dir(obj)` 函数返回一个包含对象所有属性和方法名称的列表。例如：`dir([])` 将返回一个列表，其中包含了列表的所有属性和方法。

3. **`hasattr()` 函数：**
`hasattr(obj, attr)` 函数用于检查对象是否具有指定的属性或方法。例如：`hasattr(list, 'append')` 将返回 `True`，因为列表对象具有 `append` 方法。

4. **`getattr()` 函数：**
`getattr(obj, attr)` 函数用于获取对象的指定属性或方法。例如：`getattr(list, 'append')` 将返回列表的 `append` 方法。

5. **`callable()` 函数：**
`callable(obj)` 函数用于检查对象是否可调用（即是否是一个函数、方法或其他可调用的对象）。例如：`callable(print)` 将返回 `True`。

6. **特殊方法和属性：**
Python中的许多对象都有一些特殊的方法和属性，用于提供对象自身的信息。例如 `__class__` 属性返回对象的类，`__doc__` 属性返回文档字符串。

7. **帮助函数：**
在交互式环境中，你可以使用 `help(obj)` 来获取对象的帮助信息，包括对象的方法、属性以及相关文档。

内省是一种强大的工具，它使你能够在运行时动态地了解对象的特性和行为，从而更好地编写和调试代码。

8.高阶函数

高阶函数（Higher-order Functions）是指可以接受一个或多个函数作为参数，并/或返回一个函数的函数。在Python中，函数被视为一等公民，这意味着它们可以像其他数据类型一样被传递和操作。高阶函数是利用这种特性构建更抽象、通用的功能的重要工具。

以下是一些关于高阶函数的概念和示例：

1. **接受函数作为参数：**
高阶函数可以接受其他函数作为参数，以便在内部使用或处理这些函数。这种能力允许你将特定的功能从高阶函数中分离出来，使其更加通用和灵活。

```python
def apply_function(func, x):
return func(x)

def double(x):
return x * 2

result = apply_function(double, 5) # 结果为 10
```

2. **返回函数：**
高阶函数可以返回一个函数，这允许你在函数内部动态生成并返回其他函数，从而实现更具体和复杂的功能。

```python
def make_multiplier(factor):
def multiplier(x):
return x * factor
return multiplier

double = make_multiplier(2)
result = double(3) # 结果为 6
```

3. **使用内置高阶函数：**
Python的内置函数如 `map()`、`filter()`、`sorted()` 等都是高阶函数的示例。它们接受函数作为参数，用于处理、筛选或排序数据。

```python
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers) # [1, 4, 9, 16, 25]
even = filter(lambda x: x % 2 == 0, numbers) # [2, 4]
```

十三.永久存储

1.文件操作

open(方法）

Python open() 方法用于打开一个文件，并返回文件对象。

在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 参数有：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（Python 3 不支持）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 。

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号	方法及描述
1	file.close() 关闭文件。关闭后文件不能再进行读写操作。
2	file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next() Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。
6	file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size]) 读取整行，包括 "\n" 字符。
8	file.readlines([sizeint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence]) 移动文件读取指针到指定位置
10	file.tell() 返回文件当前位置。
11	file.truncate([size]) 从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12	file.write(str) 将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

f = open("FinshC.txt","w")
f.write("I love you")
10
f.writelines(["I lvove python.\n","I hate working."])
f.close()
f.readable()
False
f = open("FinshC.txt","r+")
f.readable()
True
f.read()
''
f.tell()
41
f.seek(0)
0
f.readline()
'I love youI lvove python.\n'
f.read()
'I hate working.'
f.write("i kkk")
5
f.flush()
f.truncate(29)
29
f.close()
f = open("FinshC.txt","w")

2.路径处理

os.文件/目录方法（菜鸟）

3.with 上下文管理器

with open('./test_runoob.txt', 'w') as file:
file.write('hello world !')

使用 with 关键字系统会自动调用 f.close() 方法， with 的作用等效于 try/finally 语句是一样的。

我们可以在执行 with 关键字后检验文件是否关闭：

>>> with open('./test_runoob.txt') as f:
... read_data = f.read()

>>> # 查看文件是否关闭
>>> f.closed
True

5.pickle

用于序列化（将对象转换为字节流）和反序列化（从字节流中重新创建对象）Python对象。它允许你将复杂的Python数据结构（如字典、列表、自定义类实例等）保存到文件或从文件中加载，以便在不同的运行时之间传递数据或持久化存储数据。永久存储Python对象的问题

dump,load

`dump` 是 `pickle` 模块中的一个函数，用于将 Python 对象序列化并保存到文件中。

具体来说，`pickle.dump(obj, file)` 函数将给定的 Python 对象 `obj` 序列化并将序列化的数据写入一个已打开的文件对象 `file`。这样，你可以将对象保存在磁盘上，以后可以通过读取文件并使用 `pickle.load()` 函数重新加载对象。

以下是一个示例，演示了如何使用 `pickle.dump()` 函数将一个字典对象保存到文件中：

```python
import pickle

data = {"name": "Alice", "age": 30, "city": "Wonderland"}

with open("data.pkl", "wb") as file:
pickle.dump(data, file)
```

在此示例中，我们将一个名为 `data` 的字典对象保存到名为 `data.pkl` 的文件中。要注意的是，我们在打开文件时使用了 `"wb"` 模式，其中 `"wb"` 表示以二进制写入模式打开文件。这是因为 `pickle` 库将数据序列化为字节流。

如果要从文件中加载数据，可以使用 `pickle.load()` 函数。以下是加载以前保存的数据的示例：

```python
import pickle

with open("data.pkl", "rb") as file:
loaded_data = pickle.load(file)

print(loaded_data)
```

这将从 `data.pkl` 文件中加载数据并将其存储在 `loaded_data` 变量中，然后打印出加载的数据（在这个例子中就是字典对象）。

模块和打包

代码的打包手段

导入模块

import 模块名称

#!/usr/bin/python3
# Filename: support.py

def print_func( par ):
print ("Hello : ", par)
return

# 导入模块
import support

# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

调用格式L：模块名称.函数名称（参数)

from 模块名称 import 对象名称

import 模块名称 as 关联名称

使用as关键字来指定一个关联的名称。这在以下情况下很有用：

import math as m  # 导入math模块并将其别名为m
print(m.sqrt(16))  # 使用别名访问模块中的函数

import numpy as np  # 导入numpy模块并将其别名为np
array = np.array([1, 2, 3, 4, 5])  # 使用别名创建numpy数组

十四.异常

1.语法错误

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 : 。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

内置异常

2.处理异常

(1)try - expect

try:
1 /0
except:
print("出错了")

出错了

使用as

try:
1 / 0
except ZeroDivisionError as e:
print(e)
division by zero

使用元组的方式

try:
1 / 0
520 + "kjh"
except (ZeroDivisionError,ValueError,TypeError):
pass

遇到第一个异常就抛出

try:
1 / 0
520 + "kjh"
except ZeroDivisionError:
print("除数不能为0")
except ValueError:
print("值不正确")
except TypeError:
print("类型不正确")

除数不能为0

(2)try - except-else

try:
1 /1
except:
print("出错了")
else:
print("没出错")

1.0
没出错

(3) try - except-finally

try:
1 /1
except:
print("出错了")
else:
print("没出错")
finally:
print("出没出错都会吱一声")

1.0
没出错
出没出错都会吱一声

try:
f = open("FinshC.txt","w")
f.write("I love you.")
except:
print("出错了")
finally:
f.close()

11

3.异常的嵌套

try:
try:
520 + "FinshC"
except:
print("内部异常")
1/0

except:
print("外部异常")
finally:
print("收尾工作")

内部异常
外部异常
收尾工作

raise语句

在 Python 中，raise 语句用于手动引发异常。你可以使用它来在代码中显式地触发特定类型的异常。语法是 raise ExceptionType("Error message")，其中 ExceptionType 是异常类型，而 "Error message" 是可选的错误消息。

raise ValueError("值不正确")
Traceback (most recent call last):
File "<pyshell#58>", line 1, in <module>
raise ValueError("值不正确")
ValueError: 值不正确
raise FinshCError("小甲鱼说你不行就不行")
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <module>
raise FinshCError("小甲鱼说你不行就不行")
NameError: name 'FinshCError' is not defined

assert语句

assert 语句用于在条件为假时引发 AssertionError 异常。它用于检查代码中的假设是否为真。如果断言失败，则表示代码存在问题，应该进行调试。语法是 assert condition, "Error message"。

assert s == "FinshC"
assert s != "FinshC"
Traceback (most recent call last):
File "<pyshell#68>", line 1, in <module>
assert s != "FinshC"
AssertionError

利用异常实现goto

在 Python 中，通常不鼓励使用异常来实现类似 goto 的操作，因为异常是用于处理错误和异常情况的。这样的设计可以使代码更易于理解和维护。Python 也没有直接的 goto 语句。

如果你需要在某些情况下跳转到代码的特定部分，可以使用循环、条件语句和函数来达到类似的效果，以保持代码的可读性。

try:
while True:
while True:
for i in range(10):
if i > 3:
raise
print(i)
print("被跳过")
print("被跳过")
except:
print("到这来了")

0
1
2
3
到这来了

十五.类与对象

1.对象= 属性➕方法

变量函数

例子：

class Employee:
    empCount = 0
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
        Employee.emCount += 1
    def displayCount(self):
        print ("Total Employee %d" % Employee.empCount)
    def displayEmployee(self):
        print("name:",self.name,",Salary:",self.salary)

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:
def prt(self):
print(self)
print(self.__class__)

t = Test()
t.prt()

<__main__.Test instance at 0x10d066878>
__main__.Test

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.__class__则指向类。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

2.继承

class A:
    x = 520
    def hello(self):
        print("你好")
class B(A):
    x = 880
    def hello(self):
        print("kj")

        
b = B()
b.x
880
b.hello()
kj
#实现了覆盖


#多重继承
class B
SyntaxError: incomplete input
class B:
    x =880
    y =890
    def hello(self):
        print(khp)
class C(A,B):
    pass

c = C()
c.x
520
c.hello()
你好
#访问顺序，从左到右
c.y
890


#组合
class Turtle:
    def say(self):
        print("不积跬步，无以至千里")

        
class cat:
    def say(self):
        print("喵喵")

        
class dog:
    def say(self):
        print("汪汪")

        
class Garden:
    t = Turtle()
    c = cat()
    d = dog()
    def say(self):
        self.t.say()
        self.c.say()
        self.d.say()

        
g = Garden()
g.say()
不积跬步，无以至千里
喵喵
汪汪

3.构造函数，重写，钻石继承

个性化定制对象

构造函数 __init__（）

class C:
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def add(self):
        return self.x + self.y
    def mul(self):
        return self.x * self.y

    
c = C(2,3)
c.add()
5
c.mul()
6
c.__dict__
{'x': 2, 'y': 3}

子类对父类的重写

钻石继承

class A:
    def __init__(self):
        print("哈喽，我是A")

        
class B1(A):
    def __init__(self):
        A.__init__(self)
        print("哈喽我是B1")

        
class B2(A):
    def __init__(self):
        A.__init__(self)
        print("哈喽我是B2")

        
class C(B1,B2):
    def __init__(self):
        B1.__init__(self)
        B2.__init__(self)
        print("哈喽我是C")

        
c = C()
哈喽，我是A
哈喽我是B1
哈喽，我是A
哈喽我是B2
哈喽我是C

使用super可以改变这种重复情况

class A:
    def __init__(self):
        print("哈喽，我是A")

        
class B1(A):
    def __init__(self):
        super().__init__()
        print("哈喽我是B1")

        
class B2(A):
    def __init__(self):
        super().__init__()
        print("哈喽我是B2")

        
class C(B1,B2):
    def __init__(self):
        super().__init__()
        print("哈喽，我是C")

        
c = C()
哈喽，我是A
哈喽我是B2
哈喽我是B1
哈喽，我是C

MRO顺序 method resolution order方法解析顺序

4.Mix-in

class Animal:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say(self):
        print(f"我叫{self.name},今年{self.age}岁。")

        
class FlyMixin:
    def fly(self):
        print("哦好，我还会飞")
        

class Pig(FlyMixin,Animal):
    def special(self):
        print("我的技能是工大百次啊")

p = Pig("大肠",5)
p.say()
p.special()
p.fly()

我叫大肠,今年5岁。
我的技能是工大百次啊
哦好，我还会飞

多态和鸭子

见机行事的多态

类继承的多态。即重写

python中允许在子类中定义和父类同名的方法

class Shape:
    def __init__(self,name):
        self.name = name
    def area(self):
        pass

    
class Square(Shape):
    def __init__(self,length):
        super().__init__("正方形")
        self.length = length
    def area(self):
        return self.length * self.length

    
class Circle(Shape):
    def __init__(self,radius):
        super().__init__("圆形")
        self.raduis = radius
    def area(self):
        return 3.14 * self.radius * self.radius

    
class Triangle(Shape):
    def __init__(self,base,height):
        super().__init__("三角形")
        self.base = base
        self.height = height
    def area(self):
        return self.base * self.height /2

    
s Square(2)
SyntaxError: invalid syntax
s = Square(5)
c = Circle(6)
t = Triangle(3,4)
s.name
'正方形'
c.name
'圆形'
t.name
'三角形'
s.area()
25
t.area()





class Cat:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def intro(self):
        print(f"我是一只烧掉猫咪，我叫{self.name}，今年{self.age}岁")
    def say(self):
        print("mua~")

        
class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def intro(self):
        print(f"我是一只烧掉小狗，我叫{self.name}，今年{self.age}岁")
    def say(self):
        print("youho~")

        
class Pig:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def intro(self):
        print(f"我是一只烧掉猪猪，我叫{self.name}，今年{self.age}岁")
    def say(self):
        print("oioi~")

        
#实例化对象
        
c = Cat("web",4)
d = Dog("奶茶",2)
p = Pig("佩奇",5)
def anmoal(x):
    x.intro()
    x.say()
anmoal(c)
我是一只烧掉猫咪，我叫web，今年4岁
mua~
anmoal(p)
我是一只烧掉猪猪，我叫佩奇，今年5岁
oioi~
anmoal(d)
我是一只烧掉小狗，我叫奶茶，今年2岁
youho~

私有变量

通过某种手段，使得对象中的属性或方法无法被外部所访问

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

class C:
    def __init__(self,x):
        self.__x = x
    def set_x(self,x):
        self.__x = x
    def get_x(self):
        print(self.__x)
c = C(250)
c.get_x()
250