Python学习

本文最后更新于:2021年9月6日 凌晨

🐍Python学习

✍️一、最基本的入坑

🖨️print函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
print('helloword')			#  print用于输出
print('你说:"hello,word!"') # 单引号,用于防止转义双引号
print("在这里'hello,word'") # 双引号,用于防止转义单引号
print('''hello
word #name
hello'word'
hello"word"
''') # 三引号,用于原格式输出(转义符除外),还能添加注释
print('hello', 'word') # ,即可使多内容在同一行进行输出并用空格分开
name = open('输出目录', 'a+')
print('输出内容', file=name)
name.close()
# 使内容以文件格式输出到指定位置
# a+:如果文件不存在就创建新文件,存在内容就在原文件后面追加

📑Python的注释

1
2
3
4
5
6
7
#  单#为单行注释
'''
此为多行注释符号或者是↓
'''
"""
此为多行注释的符号
"""

🩺Python的转义符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
###  print的用法和转义字符的意义与用法
print('hell\nword')
# \n:回车键,换行
print('hell\tword')
# \t:TAB制表键
print('hello\rword')
# \r:回车键,转义符后面将前面覆盖
print('hell\bword')
# \b回格键
print('hell\\word')
# 两个\\输出的是一个\
print(r'hell\nword')
# print(r'hell\nword\')
# '前面加上r即可使转义字符失效,注意:最后一个符号不能是反斜杠

📊了解文件大小单位换算

1
2
3
4
8bit=1byte(1B)
1024B=1KB
1024KB=1MB
1024MB=1TB

🪶变量的多次定义与使用

1
2
3
4
5
6
7
8
9
10
name = '学习'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)
name = '我爱'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)

🗞️常见的数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
n1 = 96
n2 = -76
n3 = 0
n4 = 0b10101111 # 二进制以0b开头
n5 = 0o176 # 八进制以0o开头
n6 = 0x1EAF # 十六进制以0x开头
print(n1, '十进制', type(n1))
print(n2, '十进制', type(n2))
print(n3, '十进制', type(n3))
print(n4, '二进制', type(n4))
print(n5, '八进制', type(n5))
print(n6, '十六进制', type(n6))
# 整数可以标识为二进制,八进制,十进制,十六进制
# 浮点数类型 float 例:3.1415926535
a = 3.14159
print(a, type(a))
a1 = 1.1
a2 = 2.2
print(a1 + a2) # 浮点类型数据计算会有误差,以下代码来解决
from decimal import Decimal

print(Decimal('1.1') + Decimal('2.2'))
# 布尔类型 bool true=1 false=0
f1 = True
f2 = False
print(f1, type(f1))
print(f2, type(f2))
print(f1 + 1) # 布尔类型的值可以转成整数计算
print(f2 + 1) # 布尔类型的值可以转成整数计算
# 字符串类型 str 例:人生苦短,我用Python
r1 = '人生苦短我用Python'
r2 = "人生苦短我用Python"
r3 = '''人生苦短
我用
Python'''
r4 = """人生苦短
我用
Python"""
print(r1, type(r1))
print(r2, type(r2))
print(r3, type(r3))
print(r4, type(r4))

💱数据类型转换

1
2
3
4
name = '张三'
age = '20'
print(type(name), type(age))
print('我叫', 'name', '今年', 'str(age)', '岁。')
  • srt()将其他类型转换为str类型
1
2
3
4
5
6
a = 10
b = 194.5
c = False
print(type(a), type(b), type(c))
print(str(a), str(b), str(c), )
print(type(str(a)), type(str(b)), type(str(c)))
  • int()将其他类型转换为int类型
1
2
3
4
5
6
7
8
9
10
11
s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1))) # 将str转成int类型,字符串为数字串
print(int(f1), type(int(f1))) # 将float转成int类型,截取整数部分
# print(int(s2),type(int(s2))) # 将str转成int类型,报错,因为字符串为小数串
print(int(ff), type(int(ff)))
# print(int(s3),type(int(s3))) # 将str转成int类型时,字符串必须为数字串(整数),非数字串是不允许转换
  • float()将其他类型转换为float类型
1
2
3
4
5
6
7
8
9
10
11
12
13
s1 = '128.98'
s2 = '76'
ff = True
s3 = 'hello'
i = 98
print(type(s1), type(s2), type(ff), type(s3), type(i))
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))
print(float(ff), type(float(ff)))
# print(float(s3),type(float(s3))) #字符串中的数据如果是非数字串,则不允许转换
print(float(i), type(float(i)))

#注意:如果print(int + str),不是两个不同类型的数字要用逗号连接,或者是用str(int)其他类型的转化成字符串再进行用加号连接输出

📥input输入函数

  • 不带数据类型转换
1
2
a1 = input('你想要什么礼物?')
print(a1, type(a1))
  • 带数据类型转换
1
2
3
4
a = int(input('请输入一个数:'))
b = int(input('请输入另一个数:'))
print(type(a), type(b))
print(a + b)

➗Python中的运算符

  • 计算运算符
1
2
3
4
5
6
7
print(1 + 1)    # 加法运算
print(1 - 1) # 减法运算
print(1 * 1) # 乘法运算
print(11 / 2) # 除法运算
print(11 // 2) # 整除运算
print(11 % 2) # 取余运算
print(2 ** 2) # 次方运算
  • 解包赋值
1
2
a, b, c = 10, 15, 65
print(a, c, b)
  • 交换赋值
1
2
3
print('交换之前', a, b)
a, b = b, a
print('交换之后', a, b)
  • 比较运算符
1
2
3
4
5
6
7
# 比较运算符的结果为bool类型
# ’=‘为赋值运算符 ’==‘为比较运算符
a, b = 10, 20
print(a > b)
print(a == b)
print(a <= b)
print(a != b) # '!'非的意思
  • is/is not 比较id用
1
2
3
4
5
6
7
8
9
10
a = 10
b = 10
print(a == b)
print(a is b)
print(a is not b)
list1 = [11, 22, 33, 44]
list2 = [11, 22, 33, 44]
print(id(list1), id(list2))
print(list1 is list2)
print(list1 is not list2)
  • bool运算
1
or’与‘有真即真  and’或‘有假即假  not’非‘与结果相反  in’在‘在不在
  • 位运算符
1
2
3
4
5
6
7
8
9
10
print(4 & 8)  # 按位计算,同时为1结果为1,其他情况为0
print(4 | 8) # 按位计算,同时为0结果为0,其他情况为1
print(4 >> 1)
# 按位计算,空位用零表示,移动1个位置相当于除以2
print(4 >> 2)
# 按位计算,空位用零表示,移动2个位置相当于除以4
print(4 << 1)
# 按位计算,空位用零表示,移动1个位置相当于乘以2
print(4 << 2)
# 按位计算,空位用零表示,移动2个位置相当于除以4
  • 运算符的优先级
1
2
3
4
5
1、算术运算符
2、位运算符
3、比较运算符
4、布尔运算符
5、赋值运算符

🎗️有关布尔运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
print('----以下对象的布尔值为False----')
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([])) # 空列表
print(bool(list())) # 空列表
print(bool(())) # 空元组
print(bool(tuple())) # 空元祖
print(bool({})) # 空字典
print(bool(dict())) # 空字典
print(bool(set())) # 空集合

print('----其他对象的布尔值均为True')
print(bool(18))
print(bool(True))
print(bool('helloworld'))

🔗二、基本的Python函数

➿range函数

1
2
3
4
5
6
7
8
9
10
11
12
print('range的用法与作用')
#作用:range用于生成一个整数序列
'''
方式1、只给一个参数
range(stop) 创建一个[0~stop)之间的整数序列 步长为1
方式2、只给两个参数
range(start,stop) 创建一个[start~stop)之间的整数序列 步长为1
方式3、只给三个参数
range(start,stop,step) 创建一个[start~stop)之间的整数序列 步长为step
'''
#list函数是列表的意思
#range可以用来折叠数列节省内存

🔂while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
print('while循环函数的用法')
'''
四步循环法
1、初始化变量
2、条件判断
3、条件执行体(循环体)
4、改变变量
总结:初始化的变量与条件判断的变量与改变的变量为同一个
'''

# 初始化变量
sum = 0
a = 0 # 用来存储累加和
# 条件判断
while a < 5:
# 条件执行体(循环体)
sum += a
# 改变变量
a += 1
print('和为', sum)

# 计算1~100偶数的和 while和if语句运用
sum = 0
a = 1
while a <= 100:
if a % 2 == 0: # not bool (a%2)
# 这一步就是判断语句的成立 与否,如果if条件成立就执行if下的语句,如果不成立跳出if语句继续执行while循环
sum += a
a += 1
print('1-100之间的偶数和', sum)

🔄️for-in循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
print('for in 函数的用法及理解')
# 这样写就是让字符串一个一个的赋值并输出 直到赋到没有值为止
for ace in 'Python':
print('ace')

# 这样写就是让生成的整数一个一个的赋值并输出 直到赋到没有值为止
for i in range(10):
print(i)

# 没有print了这样理解吧,就是range里面有多少个东西这个程序就能执行多少次
'''
for x in range(5)
'''
# for in函数和if函数共同来计算1~100之间的偶数和
sum = 0
for item in range(1, 101):
'''
这里就是如果item里面的数除以2能整除的数就在if语句里面成立
累加到sum里面 如果不能整除就跳出if继续执行for循环
'''
if item % 2 == 0:
sum += item
print('1~100之间的偶数和为: ', sum)

🕵️‍♀️案例:for in函数和if函数共同来计算100~999之间的”水鲜花数”

1
2
3
4
5
6
7
8
9
10
for num in range(100, 1000):
# 这个:333/10=33······3(取余数3)
ge = num % 10
# 这个:333/10=33(······3舍去) 33/10=3······3(取余数3)
shi = num // 10 % 10
# 这个:333/100=3(······33舍去)
bai = num // 100
if ge ** 3 + shi ** 3 + bai ** 3 == num:
print(num)
# 符合的就进入if语句里的输出,不符合的直接跳出if继续进入for循环

🚩break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 让程序提前终止本次运行,并不再进行循环
'''
for 循环次数 in range(10):
if 条件成立:
break
#条件成立了就可以跳出这个循环了,不成立就继续进行if成立以外的代码
else:
print('继续进行for in循环')
'''

# 提前结束while循环多余的循环次数
'''
a=0
while a<3:
if 条件成立:
break
#条件成立了就可以结束这个循环了,不成立就继续进行if成立条件以外的代码
else:
print('继续进行while循环')
a+=1
'''

♻️continue

1
2
3
4
5
6
# 让程序提前终止本次运行,并再次重新继续运行这次循环
'''
for item in range(1,51)
if (!代表否定)条件不成立的时候,就从新在这里跳出本次开始下次循环
continue
'''

🔄️嵌套循环

1
2
3
4
5
6
7
8
9
10
11
12
13
# 在while里面嵌套for,else循环
for i in range(1, 4):
for j in range(1, 5):
print('*', end='\t')
print()
# end='\t'就这在末尾换行输出
for i in range(1, 10):
# 这个是控制行数,range(1,10)中,1.2.3.4.5.6.7.8.9为有效数据就说明要循环9次
for j in range(1, i + 1):
# 这个是控制列数,例如当i=1时,这个就等于range(1,2),1为有效数据就说明要循环1次,所以第一行是1个式子就结束了
# 例如当i=2时,这个就等于range(1,3),1.2为有效数据就说明要循环2次,所以第一行是2个式子就结束了,以此类推
print(i, '*', j, '=', i * j, end='\t')
print()

📃Python的列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 可以有序存储多个数据类型不一样的数据
# 列表的创建方式
'''
形式1:使用中括号
lst=['数据1','数据2',1,2]
形式2:使用内置函数
lst=(list['数据1','数据2',1,2])
list[]这个是列表的内置函数
'''
# 数组的特点
'''
1、列表元素按顺序有序排列
2、索引映射唯一个数据
1)、索引单个元素
-4 -3 -2 -1 从右往左从-1开始排序
list['数据1','数据2',1,2]
0 1 2 3 从左往右从0开始排序
2)、查询元素索引用函数index()
print(列表名.index('数据')) 如果有相同的数据,就按第一个数据来算,如果没有这个元素就会报错
print(列表名.index('数据',范围1,范围2)) 说明在范围内查找某个元素,但是并不包括那个范围两端
print(lst[序号])
正向索引:0到N-1 逆向索引:-1到-N
3、列表可以存储重复数据
4、任意数据类型可以共存
5、根据需要动态分配和回收内存
'''

🔰列表的切片操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
print('排序为正且步长为正数')
lst = [1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9]
print(lst[::])
# print(lst[起始(默认0) 若指定则包括:结束 若指定则不包括:步长 默认是1])
print('排序为正且步长为负数')
print(lst[::-2])
# print(lst[起始(默认列表最后一个数据) 若指定则包括:结束(默认列表第一个数据) 若指定则不包括:-1])
print('排序为负且步长为正数')
print(lst[-7:-2:1])
# print(lst[起始(默认列表最后一个数据) 若指定则包括:结束(默认列表第一个数据) 若指定则不包括:步长 默认是1])
print('检查元素是否存在')
print(10 in lst) # 元素 in/not in 列表
print('遍历列表的元素')
for test in lst:
print(test)
print('添加元素')
lst.append(10) # lst.append(元素)·放到原列表的最后
lst2 = ['xi', 'huan']
lst.append(lst2)
# lst.append(其他列表)·把整个列表放到原列表的最后,但是这个列表在原列表中就占一个位置
lst.extend(lst2) # lst.extend(其他列表)·把列表里面的每一个元素放到原列表的最后
lst.insert(15, 'zeng') # lst.insert(位置·序号,要插入的元素)
print(lst)
lst3 = ['you', 'W0']
lst[-1:] = lst3 # 相当于一种替换,把这个位置上原有的元素替换掉
print(lst)
print('删除元素')
lst.remove(5) # lst.remove(元素) 有重复的只删除第一个
print(lst)
lst.pop() # lst.pop(位置·序号),默认是最后一个
print(lst)
new_lst = lst[12:17] # 切片操作,只留限定[)区间以内的元素,并且产生一个新列表
print('原列表', lst, 'ID:', id(lst))
print('新列表', new_lst, 'ID:', id(new_lst)) # 从这里就可以看出ID不一样
lst[12:17] = [] # 切片操作,只留限定[)区间以外的元素,不会产生新列表
print(lst)
print('修改元素')
lst[1] = 1 # 单值修改·lst[要替换的位置] = 要替换的元素
lst[2:5] = [4, 3, 2] # 多值修改·lst[要替换的位置] = [要替换的元素]
print(lst)
lst.clear() # 清除列表中所有元素
print(lst)
del lst # 直接删除列表
del new_lst
del lst2
del lst3

🎰列表的排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
lst = [2, 1, 40, 50, 62, 89, 25, 45, 16, 25, 86, 98]
# lst=[2,1,40,50,62,89,25,45,16,25,86,98,['ftp','bing']] 这个数据类型不一样排序会报错
print('排序前的列表', lst, 'ID:', id(lst))
lst.sort() # 将列表的元素进行升序排列
print('升序排列后的列表1', lst, 'ID:', id(lst)) # 从这里看出来对列表排序是在原列表的基础上进行操作,不会生成新列表
lst.sort(reverse=False) # 将列表的元素进行升序排列
print('升序排列后的列表2', lst, 'ID:', id(lst))
lst.sort(reverse=True) # 将列表的元素进行降序排列
print('降序排列后的列表', lst, 'ID:', id(lst)) # 从这里看出来对列表排序是在原列表的基础上进行操作,不会生成新列表
del lst
lst = [15, 16, 5, 2, 0, 4, 3, 5, 2, 50, 23, 64]
print('排序前的列表', lst, 'ID:', id(lst))
new_lst = sorted(lst) # 将列表的元素进行升序排列,并且会生成新列表
print('原列表', lst, 'ID:', id(lst))
print('升序排列后列表1', new_lst, 'ID:', id(new_lst))
new_lst2 = sorted(lst, reverse=True) # 将列表的元素进行降序排列,并且会生成新列表
print('降序排列后的列表', new_lst2, 'ID:', id(new_lst2))
new_lst3 = sorted(lst, reverse=False) # 将列表的元素进行升序排列,并且会生成新列表
print('升序排列后列表2', new_lst3, 'ID:', id(new_lst3))
# sort()不产生新列表排序,sorted()产生新列表的排序
del lst # 直接删除列表
del new_lst
del new_lst2
del new_lst3

📥生成列表

1
2
3
4
5
6
7
8
9
lst = [i for i in range(1, 15)]  # lst=[要生成的元素 for i in range(起始数,结束数+1)]
print('列表生成式生成的列表1', lst)
new_lst2 = [i + i for i in range(1, 15)]
print('列表生成式生成的列表2', new_lst2)
new_lst3 = [i * i for i in range(1, 15)]
print('列表生成式生成的列表3', new_lst3)
new_lst4 = [i + i * i for i in range(1, 15)]
print('列表生成式生成的列表4', new_lst4)
# lst=[要生成的元素(或者是生成这种元素的函数式) for i in range(起始数,结束数+1)]

📕Python的字典

1
2
3
4
5
6
7
8
9
10
# 可以无序存储多个数据类型不一样的数据
# 字典的创建方式
'''
形式1:使用{}
zidian={'元素1':值1,'元素2':值2} 元素跟值成对存在
形式2:使用内置函数dict()
dict(name='元素',值=x)
形式3:创建空字典
kong={}
'''

📑字典元素的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
print('字典元素的获取')
zidain = {'张三': 10, '李四': 12, '王五': 18, '老六': 28, '大一': 30}
print(zidain, 'ID:', id(zidain))
print(zidain['张三'])
# print(zidain['陈六']) # 这个会报错
print('2、使用get()方法')
print(zidain.get('张三'))
print(zidain.get('陈六'))
# 如果找的元素不存在直接用{}找会报错导致程序无法继续运行,所以就用get()函数
print(zidain.get('陈六', 981)) # 如果列表没有这个元素,就提供这个的默认值
print('key存在的判断')
print('张三' in zidain)
print('李四' not in zidain)
print('字典元素的删除')
del zidain['大一'] # 删除指定的键值对
print(zidain, 'ID:', id(zidain))
print(zidain, 'ID:', id(zidain))
print('字典元素的新增')
print('原字典', zidain, 'ID:', id(zidain))
zidain['陈六'] = 1 # 新增元素的操作
print('新增后的字典', zidain, 'ID:', id(zidain))
print('字典元素的修改')
print('原字典', zidain, 'ID:', id(zidain))
zidain['陈六'] = 210 # 修改元素的操作
print('修改后的字典', zidain, 'ID:', id(zidain))
# 获取所有的元素后组成列表
test = zidain.keys() # 在这里key就是单个元素
print(test)
print('数据类型:', type(test))
print(list(test)) # 将所有元素组成视图转成列表
# 获取所有的值后组成列表
values = zidain.values() # 在这里valuse就是单个值
print(values)
print('数据类型:', type(values))
print(list(values)) # 将所有的值组成视图转成列表
# 将元素跟值配对后组成列表
tao = zidain.items() # 在这里item就代表(元素,值)一套
print(tao)
print('数据类型:', type(tao))
print(list(tao)) # 这里的列表元素是由元组组成的,元素和值配对变成元组

🍳字典元素的遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
zidain = {'张三': 10, '李四': 12, '王五': 18, '老六': 28, '大一': 30}
for item in zidain: # 这里只代表元素
print('元素:', item, '元素所对应的值:(方法1)', zidain[item], '元素所对应的值:(方法2)', zidain.get(item))
# 字典的特点
zi = {'me': 'ta', 'me': 'you'}
print(zi) # 一对中的第一个元素不能重复,重复的话就用最后一个值来配对
dian = {'gtx': 'nvidia', 'rtx': 'nvidia'}
print(dian) # 一对中的第二个值可以重复
# 1、字典中的元素是无序的 2、字典中的一对中的第一个元素一定是不可变的
# 3、字典可以根据需要来进行动态来进行占用内存大小的改变 4、但是字典比较浪费内存,但是读取较快
zidain.clear() # 清空字典的元素
print(zidain)
del zidain # 删除字典

📥生成字典

1
2
3
4
5
6
7
8
9
xianka = ['3090Ti', '3070s', '2080ti', '1060MAX-Q','RtX']
jage = [12500, 8500, 6300, 2700,'ON']
mysql1 = {item: price for item, price in zip(xianka, jage)}
# 字典名 要生成的字典公式 for 每次循环抽出来的东西 in zip(打包好的东西)
# 这个应该固定的item:price 这个应该固定的item,price
print(mysql1)
mysql2 = {item.upper(): price for item, price in zip(xianka, jage)}
# 最终生成的两个一对的元组数量由压缩包里面元素最少的那个数量来决定
print(mysql2)

🔢Python的元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
print('可变序列:列表,字典')
lie = [11, 26, 52, 46]
print(id(lie))
lie.append(500)
print(id(lie))
print('不可变序列:字符串,元组')
zi = '英伟达'
print(zi, 'ID:', id(zi))
zi = zi + '显卡'
print(zi, 'ID:', id(zi)) # 这里字符串看起来能修改实际上不是,一旦修改以后ID变了,就不再是原来的那个字符串了
print('不可变序列是不能被修改的')
print('元组的创建方式')
# 形式一:用()来创建
yuanzu = ('rtx', 'on', 1660)
print(yuanzu, '数据类型:', type(yuanzu))
# 形式二:用内置函数tuple()来创建
yz = tuple(('intel', '英特尔', 'E7工作站'))
print(yz, '数据类型:', type(yz))
# 形式三:直接创建
yuanzu2 = '元组', '就是', 'tupe'
print(yuanzu2, '数据类型:', type(yuanzu2))
yuanzu4 = '测试1'
print(yuanzu4, '数据类型:', type(yuanzu4))
yuanzu5 = '测试2',
print(yuanzu5, '数据类型:', type(yuanzu5))
yuanzu6 = ('测试3')
print(yuanzu6, '数据类型:', type(yuanzu6))
yuanzu7 = ('测试4',)
print(yuanzu7, '数据类型:', type(yuanzu7))
print('有无括号都可以但是想要元组单个元素的话必须后面要有,')
# 形式四:创建空元组
kong = ()
kongyuanzu = tuple() # tuple代表元组
print(kong, '数据类型:', type(kong))
print(kongyuanzu, '数据类型:', type(kongyuanzu))
print('空值创建对比')
liebiao = [] # 空列表
kongliebiao = list() # list代表列表
print(liebiao, '数据类型:', type(liebiao))
print(kongliebiao, '数据类型:', type(kongliebiao))
zidian = {} # 空字典
kongzidian = dict() # dict代表字典
print(zidian, '数据类型:', type(zidian))
print(kongzidian, '数据类型:', type(kongzidian))
print('把元组设计成不可变的意义')
# 1、因为ID不会变,对元组进行多方面操作时不怕内存ID改变重要数据丢失导致的程序崩溃问题
# 2、不能对不可变序列里面的元素进行修改,但是可以修改不可变序列里面的可变序列里面的元素
testyuanzu = (10, [25, 68, 41], 75, 82)
print('原列表:', testyuanzu, 'ID:', id(testyuanzu))
testyuanzu[1].append(55) # 在修改元组里面列表里面的元素
print('原列表:', testyuanzu, 'ID:', id(testyuanzu))
del zidian
del yz
del yuanzu, kongliebiao,testyuanzu
del yuanzu2, yuanzu4, yuanzu5, yuanzu6, kongzidian # 能一次性删除很多,就用,隔开

🍳元组的遍历

1
2
3
4
5
6
7
# 方式一:使用索引获取元素
yaunzu = (60, 98, 55)
print(yaunzu[0], yaunzu[1], yaunzu[2])
# print(yaunzu[3]) # 这个超出索引的范围会报错
# 方式二:遍历元素
for test in yaunzu:
print(test)

🗂️Python的集合

1
相似版字典,就是只要字典中一对的里面第一个元素,另一个元素去掉的版本

📥集合的创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 形式一:使用{}
jihe = {12, 45, 78, 96, 36, 56, 78, 12}
print(jihe, '数据类型:', type(jihe))
# 因为字典中一对的里面第一个元素不能重复,所以在集合这里也是不能重复的,若有重复就取第一个值
# 形式二:使用内置函数set()
jh = set(range(5)) # 使用内置函数range()来生成元素
print(jh, '数据类型:', type(jh))
test1 = set((72, 64, 5, 8, 9, 24, 64)) # 输出的顺序跟定义的时候不一样的原因是因为这个是哈希函数计算的结果
print(test1, '数据类型:', type(test1))
test2 = set([1, 52, 10, 34, 25, 10]) # 集合的元素是无序的,且不会重复
print(test2, '数据类型:', type(test2))
test3 = set({15, 55, 32, 12, 15, 12})
print(test3, '数据类型:', type(test3))
test4 = set('nvidia')
print(test4, '数据类型:', type(test4))
test5 = set('英伟达显卡') # 无序
print(test5, '数据类型:', type(test5))
test6 = {} # 这个是创建字典的空列表
print(test6, '数据类型:', type(test6))
test7 = set() # 这个才是创建空结合
print(test7, '数据类型:', type(test7))

📑集合的相关操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
print('集合元素存在的判断')
print(10 in jihe)
print(45 not in jihe) # 就是不说实话!
print('集合元素新增操作')
print('原集合:', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.add(500)
# jihe.add(500,200) # 这个报错的,add只能添加一个函数
# jihe.add({500,200}) # 想多了,这个也不行
print('新增加后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.update({100, 200, 600, 400, 500}) # 添加多个元素就用update
print('再次新增加后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.update((1, 13, 10))
print('再次新增加后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.update([5, 0, 2]) # 几种括号都可以
print('再次新增加后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
print('集合元素的删除')
jihe.remove(0) # 只能删除列表中有的元素,删除没有的会报错,影响下面程序的运行
print('删除0后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.discard(96) # 这个删除没有的元素就不会报错
print('删除96后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.pop() # 随机删除一个任意元素,不能指定参数
print('删除一个任意数的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
jihe.clear() # 清空集合
print('clear以后的集合', jihe, '数据类型:', type(jihe), 'ID:', id(jihe))
del jihe, jh, test1, test2, test3, test4, test5, test6, test7 # 直接删除

🤼‍♂️集合之间的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
jh1 = {10, 20, 30, 40}
jh2 = {20, 10, 40, 30}
jh3 = {40, 50, 10, 88}
print(jh1 == jh2)
print(jh1 != jh3)
print('子集的判断')
jh4 = {30, 10}
print(jh1.issubset(jh4)) # False
print(jh4.issubset(jh1)) # True
# 这个判断顺序是前面指定后面的(前面的跟后面的比) //仅限个人理解,可有其他理解方式,记住顺序就可
print('超集的判断')
print(jh1.issuperset(jh4))
# 这个判断顺序是前面指定后面的(前面的跟后面的比) //仅限个人理解,可有其他理解方式,记住顺序就可
print('非交集的判断')
print(jh3.isdisjoint(jh1))
# 这个前后顺序都一样的,但是有交集的是Fales,没有交集的结果是True
print('集合的数学操作') # 这些数学操作不影响原集合
print('交集:', jh1.intersection(jh3)) # 就是两个集合相同的元素列举出来
print('交集:', jh1 & jh3) # &是求交集的符号&=intersection()
print('并集:', jh1.union(jh3)) # 就是两个集合全部的元素去重后列举出来
print('并集:', jh1 | jh3) # |是求交集的符号|=union()
print('差集:', jh1.difference(jh3)) # 差集就是第一个集合减去这两个集合共有的元素
print('差集:', jh1 - jh3) # -是求交集的符号-=difference()
print('差集:', jh1.symmetric_difference(jh3)) # 就是两个集合除去共有的元素列举出来
print('差集:', jh1 ^ jh3) # ^是求交集的符号^=symmetric_difference()

📥集合的生成式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
scjihe = {i for i in range(1, 15)}  # scjihe={要生成的元素 for i in range(起始数,结束数+1)}
print('集合生成式生成的集合1', scjihe)
scjihe2 = {i + i for i in range(1, 15)}
print('集合生成式生成的集合2', scjihe2)
scjihe3 = {i * i for i in range(1, 15)}
print('集合生成式生成的集合3', scjihe3)
scjihe4 = {i + i * i for i in range(1, 15)}
print('集合生成式生成的集合4', scjihe4)
# scjihe4={要生成的元素(或者是生成这种元素的函数式) for i in range(起始数,结束数+1)}
# 跟列表生成式比就是[]变成{}且生成的元素是错乱的
print('列表、字典、元组、集合总结')
print('数据结构', '是否可变', '是否重复', '是否有序', '定义符号')
print('列表(list)', '是', '是', '是', '[]')
print('元组(tuple)', '不是', '是', '是', '()')
print('字典(dict)', '是', '第一个不可以,第二个可以', '不是', '{key,value}')
print('集合(set)', '是', '是', '不是', '{}')

🍡Python的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
print('字符串的驻留机制')  # 就是在判断ID是否相同
a = 'RTX'
b = "RTX"
c = '''RTX'''
print(a, 'ID:', id(a))
print(b, 'ID:', id(b))
print(c, 'ID:', id(c))
print(a == b) # == 这个是来判断内容是否相同
print(a is b) # 这个是来判断ID是否相同
'''
字符串驻留机制:就是对字符串在内存中的占位的一个表现
如果一个不可变的字符串已经在内存中出现,那么再创建一个相同的字符串
内存中的数据是不变的,新创建的相同字符串还是会延用原来内存中已拥有的那个数据
从而达到节省内存空间的效果,内存其实就是电脑里面的运行内存
符合驻留机制的情况:
1:字符串的长度为0或1时 # 例如空字符串或者是里面只有一个元素的时候
2:符合标识符的字符串 # 含有字母、数字、下划线的字符串属于标识符的字符串
3:字符串只在编译的时候进行驻留,而非运行时
# 就是在写代码的时候定义几个相同的字符串那么它们就有可能符合驻留机制,
但是如果运行出来一个跟代码中的字符串相同的字符串那么就一定不会符合驻留机制
4:[-5~256]之间的整数数字
以上实验不要在pycharm里面进行,要在交互式窗口里面进行实验,pycharm有内存优化机制
优点:有多个相同的字符串只会占用一个内存地址来储存它们,从而节省内存空间,提高运行效率。
缺点:如果要进行字符串的修改或者是拼接的时候就是会影响性能的,先要进行字符串的生成内存或者是拷贝内存再进行操作计算等等
补救方法:使用str类型的join方法,这样的话是先进行计算再进行生成内存或者是拷贝内存,比原来直接+来连接字符串的效率要高
'''

🕵️‍♀️字符串的查询

1
2
3
4
5
6
7
8
9
10
rtx = 'nvidia,nvidia,NIdia'
print(rtx.index('dia'))
print(rtx.rindex('dia'))
print(rtx.find('dia'))
print(rtx.rfind('dia'))
# 就看内置函数前面有没有r,有r
# 的话就是查最后一次出现的位置,没有r的话就是查第一次出现的位置
# print(rtx.index('gtx'))
# print(rtx.rindex('gtx')) #抛异常
# index在查没有出现过的字符的时候会抛异常,所以尽量使用find函数,没有元素的话出现-1,但是不会抛异常

📑字符串的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
print('操作一、转换大小写')
print('原字符串:', rtx, 'ID:', id(rtx))
test1 = rtx.upper() # upper全转大写
print(test1, 'ID:', id(test1))
test2 = rtx.lower() # lower全转小写
print(test2, 'ID:', id(test2))
test3 = rtx.swapcase() # swapcase大写→小写;小写→大写
print(test3, 'ID:', id(test3))
test4 = rtx.capitalize() # capitalize只把第一个变成大写,其他的全部小写
print(test4, 'ID:', id(test4))
test5 = rtx.title() # title把每个单词的第一个变大写,其他的全部小写
print(test5, 'ID:', id(test5))
# ID不一样,说明更改大小写会产生新的字符串
print('操作二、内容对齐、填充')
chuan = 'nvidia,rtx:ON'
fu = '-2440'
print('原字符串:', chuan, 'ID:', id(chuan))
test6 = chuan.center(20, '&')
print(test6, 'ID:', id(test6))
test7 = chuan.center(20) # 将字符串中的字符放到中间,其他的用'&'来填充(默认为空格),到指定数量的字符
print(test7, 'ID:', id(test7))
test9 = chuan.center(5)
print(test9, 'ID:', id(test9))
test10 = chuan.ljust(20, '$') # l左对齐
print(test10, 'ID:', id(test10))
test11 = chuan.rjust(20, '¥') # r右对齐
print(test11, 'ID:', id(test11))
test12 = chuan.zfill(30) # 右对齐,其他位置只能用0来填充
print(test12, 'ID:', id(test12))
print('原字符串:', fu, 'ID:', id(fu))
test14 = fu.center(20, '&')
print(test14, 'ID:', id(test14))
test15 = fu.center(20)
print(test15, 'ID:', id(test15))
test16 = fu.rjust(20, '¥')
print(test16, 'ID:', id(test16))
test13 = fu.zfill(20) # 如果有符号则会把0填充到符号后面,其他的倒是不会
print(test13, 'ID:', id(test13))
# 以上都是,如果指定的数量小于实际字符串,那依然输出原来的字符串
del rtx, fu, chuan
print('操作三、字符串内容的拆分')
fu = 'nvidia rtx 3090 its on'
print('原字符串:', fu, 'ID:', id(fu))
test17 = fu.split() # 从左往右拆分成列表,默认是按空格来分隔每个字段
print(test17, 'ID:', id(test17))
test18 = fu.rsplit() # 从右往左拆分成列表
print(test18, 'ID:', id(test18))
chuan = 'nvidia*rtx*3090*its*on'
print('原字符串:', chuan, 'ID:', id(chuan))
test19 = chuan.rsplit(sep='*') # sep=''来设置指定的分隔符
print(test19, 'ID:', id(test19))
test20 = chuan.rsplit(sep='*', maxsplit=2) # maxsplit=来设置分隔几次
print(test20, 'ID:', id(test20))
test21 = chuan.split(sep='*', maxsplit=2)
print(test21, 'ID:', id(test21))
print('操作四、字符串内容的判断')
print('原字符串:', chuan, 'ID:', id(chuan))
print(chuan.isidentifier()) # isidentifier用来判断是否含有合法的字符串
# 仅有数字或者是字母或者是下划线的字符串称为合法字符串
z = 'null,\t,哈哈哈哈'
print('原字符串:', z, 'ID:', id(z))
print(z.isspace()) # isspace用来判断是否含有空字符
# 转义符称为空白字符
r = 'kalilinux哈哈哈'
print('原字符串:', r, 'ID:', id(r))
print(r.isalpha()) # isalpha用来判断是否全部都由字母组成
a = '124523120541哈哈哈'
print('原字符串:', a, 'ID:', id(a))
print(a.isdecimal()) # isdecimal用来判断是否全部都是由十进制的数字组成
b = '451482148212015哈哈'
print('原字符串:', b, 'ID:', id(b))
print(b.isnumeric()) # isnumeric用来判断是否都是由数字组成
c = 'sddvffergfe1526489625196哈哈哈'
print('原字符串:', c, 'ID:', id(c))
print(c.isalnum()) # isalnum用来判断是否都是由数字和字母组成
# 这里的汉字也可以当成字母来识别好像
del a, b, c
print('字符串的合并和替换')
a = '啊这,哈哈哈哈哈哈哈'
print(a.replace('哈', '6', 3)) # replace用来对字符串里面的元素进行替换
# ('被替换的字符','将要换成的新字符',被换的次数)
b = ['intel', 'i', '9', '-', '10970', 'k', 's']
# b=['intel','i',9,'-',10970,'k','s'] # 这个报错·要确保列表里面的元素都是一同个数据类型
print(''.join(b))
print('¥'.join('mynginx要暴富')) # 如果里面直接是字符串那么就按每个字符来进行分开
# ('进行连接的时候的分隔标识符,如果不需要就留空'.join(列表、元组等等再或者直接是字符串))
del a, b
print('字符串的比较')
a = 'apple'
b = 'app'
c = 'orange'
d='org'
print(a > b)
print(a > c)
print(ord('a'), ord('o'))
print(a>d)
# 比较原理,从前往后只要遇到一个不一样的字符就按这个不一样的字符的ord的值来进行大小判断,往后的字符串就无所谓了
# ==是比较字符串的元素的 is是来比较ID的 ID一样的话元素一定一样,元素一样的话ID不一定一样
del a,b,c,d
print('字符串的切片')
a='hello,yiyi'
print(a[6:], 'ID:', id(a[6:]))
print(a[0:5:1], 'ID:', id(a[0:5:1]))
print(a[::], 'ID:', id(a[::])) # [起始(默认0) 若指定则包括:结束 若指定则不包括:步长 默认是1]
print(a[-4::], 'ID:', id(a[-4::])) # 就跟切列表一样,会生成新的字符串或者是列表
b='my'
new=a[0:5:1]+b+a[6:]
print(new, 'ID:', id(new))

🧩格式化字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
fudianleixingshujv=3.1215926535
name='张三'
age=20
age2='20' # 一定要注意数据格式
# 第一种方式:%作为占位符
print('我叫%s,今年%d岁' % (name,age))
print('我叫%s,今年%s岁' % (name,age2))
#('1:%数据类型代号,2:%数据类型代号') % (数据1,数据2)
print('宽度测试:%20s' % (name)) # %跟数据类型之间的数,是来限定这个字符串固定的宽度的
print('宽度测试:%1s' % (name)) # %跟数据类型之间的数小了无所谓了,跟没用一样
print('格式化浮点类型数据:%.3f' % (fudianleixingshujv))
# %跟数据类型之间的.数,是来限定这个浮点类型数据小数点后面的位数
print('多个格式限定:%20.3f' % (fudianleixingshujv))
# 条件直接加一起完事
# 第二种方式:{}作为占位符
#print('我叫{0},今年{2}岁'.format(name,age)) # 报错
print('我叫{0},今年{1}岁'.format(name,age)) # {}里面的数字一定要按顺序
print('{}'.format(fudianleixingshujv)) # 就一个括号可以省略里面的数
print('{0}'.format(fudianleixingshujv)) # 多个括号就不能省略
print('{0:15.3}'.format(fudianleixingshujv))
# 括号数后加:限定条件--格式就跟小括号的一样了
# 第三种方式:直接代入法
print(f'我叫{name},今年{age}岁') # (f'1:{定义字符串名称},2:{定义字符串名称}')

💱字符串编码的转换

1
2
3
4
5
6
7
8
9
10
11
12
13
# 编码
ma='好好学习,天天向上'
gbk_ma=ma.encode(encoding='GBK') # GBK一个中文2个字节
utf_8_ma=ma.encode(encoding='UTF-8') # UTF-8一个中文3个字节
print(gbk_ma)
print(utf_8_ma)
# 解码
gbk_jiema=gbk_ma.decode(encoding='GBK')
# utf_8_jiema=utf_8_ma.decode(encoding='GBK')
# 这个报错的,用什么的格式编码就用什么的格式解码
utf_8_jiema=utf_8_ma.decode(encoding='UTF-8')
print(gbk_jiema)
print(utf_8_jiema)

💠定义Python中的f(x)

♻️创建与调用

1
2
3
4
5
6
7
8
9
10
def test(a, b):  # a,b称为形式参数,简称形参,形参是位置是在函数的定义处
c = a + b
return c


result = test(10, 20) # 10,20称为实际参数的值,简称实参,实参的位置是函数的调用处
print(result)

res = test(b=10, a=20) # =左侧的变量的名称为关键字参数
print(res)

👩🏿‍🤝‍👩🏼可变与不可变的参数区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def test1(nu1, nu2):
print('nu1=', nu1)
print('nu2=', nu2)
nu1 = 110
nu2.append(10) # .append追加函数
print('nu1=', nu1)
print('nu2=', nu2)
# return # 这个可有可无


n1 = 11
n2 = [22, 33, 44]
print('n1=', n1)
print('n2=', n2)
test1(n1, n2)
print('经过函数后的n1=', n1) # 这个值就没有变化,因为这个参数是不可变的
print('经过函数后的n2=', n2) # 这个值就被上面的函数给改变了,因为这个参数是可变的
'''
在函数调用的过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会影响实参的值
如果是可变对象,在函数体的的修改会影响到实参的值
'''
# 函数返回多个值时,结果为元组
print(bool(0)) # 0的bool值是False
print(bool(2)) # 非0的bool值是True

🔙关于函数的返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def test2(num):
ji = [] # 奇数
ou = [] # 偶数
for i in num:
if i % 2:
ji.append(i)
else:
ou.append(i)
return ji, ou


lst = [11, 12, 13, 14, 15, 16, 17, 34, 25, 657, 6455, 234, 3434532]
print(test2(lst))
'''
函数在调用时,是否需要返回值,视情况而定
(1)如果函数没有返回值【函数执行完毕之后,不需要给调用处提供数据】return可以省略不写
(2)函数的返回值,如果是1个,直接返回类型
(3)函数的返回值,如果是多个,返回的结果为元组
'''

🪶函数的调用与定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def test3():
print('hello')


# return
test3()


def test4():
return 'hellow'


res = test4() # 函数的调用处
print(res)


def test5():
return 'hello', 'world'


print(test5())
print('函数的参数定义')


def test6(a, b=10):
print(a, b)


test6(100)
test6(20, 30)
print('hello', end='\t') # \t与下面的输出在同一行
print('world')

🆕可变函数的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
print('个数可变的位置参数')


def test7(*args): # 带一个*,即是可变的位置参数
print(args)
print(args[0]) # 可指定位置输出


test7(10)
test7(10.20)
test7(30782, 241, 2432, 41)
# 结果是一个元组
print('个数可变的关键字形参')


def test7(**args): # 带一个*,即是可变的位置参数
print(args)


test7(a=10)
test7(a=10, b=20, c=20)


# 结果是一个字典
# 一个类型
# 例如:def test7(**args,**abc):
def test8(*avf, **abc):
pass


# def test9(**avf,*abc): # 这个是错误的写法
# 在一个函数的定义过程中,既有个数可变的关键字形参,也有个数可变的位置形参,要求,个数可变的位置形参放在个数可变的关键字形参之前

🔝函数的参数应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
def test9(a, b, c):  # a,b,c在函数的定义处,所以是形式参数
print('a=', a)
print('b=', b)
print('c=', c)


# 函数的调用
test9(10, 20, 30) # 函数调用时的参数传递,称为位置传参
lst = [1, 12, 13]
test9(*lst) # 在函数的调用时,将列表中的每个元素都转换为位置实参传入
print('-------------------------------------------')
test9(a=100, c=300, b=200) # 函数的调用,所以都是关键字实参
print('-------------------------------------------')
dic = {'a': 121, 'b': 123, 'c': 134}
test9(**dic) # 在函数调用时,将字典中的键值对都转换为关键字实参传入
print('-------------------------------------------')


def test10(a, b=10): # b是在函数的定义处,说以b是形参,而且进行了赋值,所以b称为默认值形参
print('a=', a)
print('b=', b)


def test11(*args): # 个数可变的位置形参
print(args)


def test12(**arge): # 个数可变的关键字形参
print(arge)


test11(13, 13, 24, 3456, 63426, 4532, 12)
test12(a=11, b=14, c=454, h=42)


def test13(a, b, c, d):
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)


test13(12331, 124, c=100, d=3232) # 前两个参数,采用的是位置实参传递,而c, d采用的是关键字实参传递


def test14(a, b, *, c, d): # 从*之后的参数,在函数调用时,只能采用关键字参数传递

print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)


pass

print('函数参数的顺序')


def test15(a, b, *, d, c, **dasda):
pass


def test16(*sdf, **fwffw):
pass


def test17(a, b, c=10, *dfsd, **fqqf):
pass


def test18(a, b):
c = a + b # c,就称为局部变量,因为c在是函数体内进行定义的变量, a, b为函数的形参,作用范围也是函数内部,相当于局部变量
print(c)


name = 'xxxx' # name的作用范围为函数内部和外部都可以使用-->称为全局变量
print(name)


def test19():
print(name)


test19() # 调用函数


def test20():
global rtx # #函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
rtx = 30
print(rtx)


test20()
print(rtx)

💹递归函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def test21(n):
if n == 1:
return 1
else:
return n * test21(n - 1)


print(test21(6))

print('斐波那契数列')


def test22(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return test22(n - 1) + test22(n - 2)


print(test22(6))

print('----------------')
for i in range(1, 7):
print(test22(i))

⚠️Python的BUG处理

❎try···except机构处理错误

1
2
3
4
5
6
7
8
9
10
11
12
try:
a=int(input('请输入第一个数'))
b=int(input('请输入第一个数'))
c=a/b
print('结果为:',c)
except ZeroDivisionError:
print('对不起,除数不允许为0')
except ValueError:
print('只能输入数字')
except BaseException as e:
print(e)
print('程序结束')

❎try···except···else机构处理错误

1
2
3
4
5
6
7
8
9
try:
a=int(input('请输入第一个数'))
b=int(input('请输入第一个数'))
c=a/b
except BaseException as e:
print('出错了:',e)
else:
print('计算结果为:',c)
print('程序结束')

❎try···except/else···finally机构处理错误

1
2
3
4
5
6
7
8
9
10
11
try:
a=int(input('请输入第一个数'))
b=int(input('请输入第一个数'))
c=a/b
except BaseException as e:
print('出错了:',e)
else:
print('计算结果为:',c)
finally: # 不管程序出不出现异常,都会被执行,能够释放try块中申请的资源
print('谢谢使用')
print('程序结束')

❎traceback模块处理错误

  • 打印异常信息,能写报错日志
1
2
3
4
5
6
import traceback
try:
print('-------------')
print(1/0)
except:
traceback.print_exc()

🥱剩下的还有呢,正在持续编写中,尽请期待!!

💔算了这几天先不更了,运气不太好,等我心理阴影过去先··· ···

写完博客当晚回宿舍的路上,差点踩到👁️🐍· · · · · · ,当我发现它的时候,它就在我两脚之前,呲呲叫了😱

最后,这个鬼东西逃到了这里··· ···

📣特别声明

此文章全部都是依靠自己的学习理解来写的原创文章,难免可能会出现有错误的地方,

如果大家以后阅读的时候发现有问题,那就麻烦到下方评论区来进行错误指出,使错误尽快做出改正,

在此,感谢大家的阅读与支持!🤝💦🎉

🍻支持一下

觉得我写的好的话可以支持一下我哦~持续关注我,会更新其他好玩且实用的项目。

👋如果我能帮助到你,那就请我喝杯🧋呗~👇👇👇


本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!