本文介绍: def 函数名称() ：代码块tab() //直接调用函数名import function # 导入整个函数文件function.tab() # 调用: 函数文件.函数案例：1、将九九乘法表封装成函数row = 1col = 1col += 1print(”)row += 1# 使用函数名称调用函数tab()1 * 1 = 12、调用func文件中的 tab函数tab()list(列表)，是python中使用最频繁的数据类型，其他语言中通常叫数组;
文章目录
一、变量及基本概念
1、变量
# 1、定义变量
user = "root"
password = "123.com"
# 2、打印变量
print(user)
print(password)
注意：print函数()括号内 存在双引号或单引号那就是字符串，并非变量。
price = 8.5
weight = 7.5
money = price * weight
print("共%d元" %money)
price = 8.5
weight = 7.5
money = price * weight - 5
print("共%d元" %money)
2、变量类型
| 变量类型 | 解释 |
|---|---|
| srt | 字符串 |
| int | 整数 |
| long | 长整数(仅在python2中存在) |
| bool | 布尔(真假) |
| float | 浮点数 |
| tuple | 元组 |
| list | 列表 |
3、变量格式化输出
| 格式化字符 | 含义 |
|---|---|
| %s | 字符串 |
| %d | 有符号十进制整数，%06d表示输出整数为6位，不足6为则使用0代替 |
| %f | 浮点数，%.2f表示显示小数点后2位 |
| %% | 显示% |
案例：
1、字符串
name = "张三"
print('%s' %(name))
我的名字叫zhangsan
2、整数
studentId = 5
print("我的学号是 %06d" %studentId)
我的学号是 000005
3、浮点数
height = 1.8
print("我的身高是 %.2f" %height)
我的身高是 1.80
4、输出%号
memory = 25
print("当前内存使用率是 %.2f%%" %memory)
当前内存使用率是 25.00%
price = 9
weight = 5
money = price * weight
print('苹果价格 %.2f/斤, 购买了 %.2f斤，需要支付 %.2f元' % (price, weight, money))
输出结果如下：
苹果价格 9.00/斤, 购买了 5.00斤，需要支付 45.00元
4、type()函数
variable_str = "zhangsan"
variable_int = 1790
variable_bool = True
variable_float = 17.90
print(type(variable_str))
print(type(variable_int))
print(type(variable_bool))
print(type(variable_float))
输出结果如下：
<class 'str'>
<class 'int'>
<class 'bool'>
<class 'float'>
5、input()函数
user = input('账号:')
passwd = input('密码:')
print('账号为:%s 密码为:%s' %(user, passwd))
输出结果如下：
账号:root
密码:123
账号为:root 密码为:123
6、类型转换函数
| 函数 | 解释 |
|---|---|
| int(x) | 将x转换为整数 |
| float(x) | 将x转换为浮点数 |
price = float(input("请输入苹果单价:"))
weight =float(input("请输入苹果重量:"))
money = price * weight
print('苹果价格 %.2f/斤，购买了 %.2f斤，需要支付 %.2f元' % (price, weight, money))
输出结果如下：
请输入苹果单价:10
请输入苹果重量:50
苹果价格 10.00/斤，购买了 50.00斤，需要支付 500.00元
7、注释
# 这是一个注释
print('test1')
或者
print('test1') # 这是一个注释
"""
这是一段注释
"""
3、TODO注释
# TODO(作者/邮箱) XXXXXXX
二、Python运算/字符
1、算数运算
| 运算符 | 描述 | 案例 |
|---|---|---|
| + | 加 | 10 + 10 = 20 |
| – | 减 | 20 – 10 = 10 |
| * | 乘 | 50 * 50 = 2500 |
| / | 除 | 10 / 3 = 3.3333 |
| // | 取整除 | 10 // 3 = 3 |
| % | 取余数 | 10 % 3 = 1 |
| ** | 幂 | 2 ** 3 = 8/ |
在python中*运算还可以用于字符串拼接，计算结果就是字符串重复指定次数的结果；
test = "-" * 50
print(test)
优先级：
| 运算符 | 描述 |
|---|---|
| ** | 幂（优先级最高） |
| * / % // | 乘、除、取余数、取整数 |
| + – | 加、减 |
2、比较运算
| 运算符 | 描述 |
|---|---|
| == | 判断A、B是否相等 |
| != | 判断A、B是否不相等 |
| > | 判断A是否大于B |
| < | 判断A是否小于B |
| >= | 判断A是否大于等于B |
| <= | 判断A是否小于等于B |
3、逻辑运算
| 运算符 | 描述 |
|---|---|
| and | 逻辑与 |
| or | 逻辑或 |
| not | 逻辑非 |
# 逻辑与： 真真为真 真假为假 假假为假
# 逻辑或： 真真为真 真假为真 假假为假
# 逻辑非： 真的是假的 假的是真的
4、赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值运算符 | c = a + b |
| += | 加法运算符 | i += c 等价于 i = i + c |
| -= | 减法运算符 | i -= c 等价于 i = i – c |
| /= | 除法运算符 | c /=a 等价于 c = c / a |
| //= | 取整数运算符 | c //= b 等价于 c = c // b |
| %= | 取余运算符 | c %= a 等价于 c = c % a |
| **= | 幂运算符 | c **= b 等价于 c = c ** b |
5、转义字符
| 符号 | 描述 |
|---|---|
| 转义字符 | |
| n | 换行符 |
| t | 制表符 TAB键 |
| r | 回车 |
案例：
1、转义字符
print(""hello"")
输出结果如下：
"hello"
2、换行符 n
print("hellonhello")
输出结果如下：
hello
hello
3、制表符 t
print("hellothello")
hello hello
输出结果如下：
print("hellothello")
hello hello
4、回车 r
print("hellorworld")
输出结果如下：
world
6、成员运算符
| 运算符 | 描述 |
|---|---|
| in | 判断元素是否存在 返回值是布尔值 |
| not in | 判断元素是不否存在 返回值是布尔值 |
案例：
1、成员运算符 in
listName = ["zhangs", "lisi", "wangwu"]
print("zhangs" in listName)
输出结果如下：
True
listName = ["zhangs", "lisi", "wangwu"]
print("zhangs" not in listName)
输出结果如下：
False
三、判断/循环语句
1、if判断语句
if 条件1:
代码块1....
elif 条件2:
代码块2....
else:
代码块.....
案例：
age = int(input('你今年多大了?:'))
if age >= 18:
print('已满18岁,没有防沉迷啦！')
else:
print('未满18岁,有限制哦！')
输出结果如下：
你今年多大了?:18
已满18岁,没有防沉迷啦！
num = int(input('0-150之间请选择一个整数:'))
if num <= 0:
print('小于等于0')
elif 0 < num <= 100:
print('大于0且小于等于100')
elif 100 < num <= 150:
print('大于100且小于等于150')
else:
print('无效数字 请0-150选择')
输出结果如下：
0-150之间请选择一个整数:100
大于0且小于等于100
day = input('今天是什么日子:')
if day == '情人节':
print('今天是情人节,不会又是你自己吧？')
elif day == '劳动节':
print('今天是劳动节,赖床上还没起?')
elif day == '国庆节':
print('今天是国庆节,天安门看升国旗')
else:
print('每天都是值得期待的日子呀！')
输出结果如下：
今天是什么日子:情人节
今天是情人节,不会又是你自己吧？
# 疫情可以回家过年吗？
city = input('请输入现在所在城市:')
if not city == '天津' or city == '武汉':
print('%s 不属于高风险区,可以进行购票' % city)
ticket = input('是否购买去往 %s 的票:' % city)
if ticket == '是':
print('购票成功,可以回家啦')
else:
print('购票失败')
else:
print('%s 是高风险区,禁止购票' % city)
输出结果如下：
请输入现在所在城市:北京
北京 不属于高风险区,可以进行购票
是否购买去往 北京 的票:是
购票成功,可以回家啦
import random
computer = random.randint(1, 3)
player = int(input('请输入你要出的拳 石头(1)/剪刀(2)/布(3):'))
print('我出的是%d 电脑出的是%d' % (player, computer))
if ((player == 1 and computer == 2)
or (player == 2 and computer == 3)
or (player == 3 and computer == 1 )):
print('我赢了 不服不行呀')
elif player == computer:
print('平局 真是心有灵犀呀')
else:
print('我不服 大战三百回合')
输出结果如下：
请输入你要出的拳 石头(1)/剪刀(2)/布(3):1
我出的是1 电脑出的是3
我不服 大战三百回合
score = int(input("请输入一个整数:"))
if score >= 60:
if score >= 80:
if score == 100:
print("满分真棒！")
else:
print("优秀！")
else:
print('及格')
else:
print('继续加油')
输出结果如下：
请输入一个整数:100
满分真棒！
2、while循环语句
while 条件 (计数器 是否达到目的): # 条件成立执代码块
代执行码块
处理条件(计数器 +1)
案例：
i = 0
while i < 5:
print('I love china')
i += 1
输出结果如下：
I love china
I love china
I love china
I love china
I love china
思路：
num = 0
result = 0
while num <= 100:
result += num
num += 1
print(result)
输出结果如下：
5050
num = 0
result = 0
while num <= 100:
if num % 2 == 0:
result += num
num += 1
print(result)
输出结果如下：
2500
num = 0
result = 0
while num <= 100:
if not num % 2 == 0:
result += num
num += 1
print(result)
输出结果如下：
2500
5、输出久久乘法表
num1 = 1
while num1 <= 9:
num2 = 1
while num2 <= num1:
print(f"{num1} * {num2} = {num1 * num2}", end='t')
num2 += 1
print('')
num1 += 1
或者：for循环 乘法表
for i in range(1,10):
j = 1
for j in range(1,i+1):
print("%d * %d = %d" %(i,j,(i*j)),end='t')
j += 1
print('')
i += 1
输出结果如下：
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
3、for循环语句
基本语法：
for 变量 in 集合:
循环体代码
else:
没有通过break 退出循环，循环结束后，会执行的代码
举例：
lisi_name = ["雅典娜", "张良", "夏侯惇", "百里玄策", "盾山"]
for i in lisi_name:
print(i)
输出结果如下：
雅典娜
张良
夏侯惇
百里玄策
盾山
for i in "我爱中国":
print(i)
输出结果如下：
我
爱
中
国
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print('当前水果 : %s' % fruits[index])
print("Good bye!")
输出结果如下：
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!
students_list = [
{"name": "张三",
"age": 20,
"height": 1.70,
"weight": 75.0},
{"name": "李四",
"age": 22,
"height": 1.86,
"weight": 99.0}
]
find_name = input('请输入您要查询的名字:')
for i in students_list:
if i["name"] == find_name:
print("找到了 %s 信息如下: %s" % (find_name, i))
break
else:
print('没有找到 %s' % find_name)
输出结果如下：
请输入您要查询的名字:张三001
没有找到 张三001
4、for和while循环区别
for 循环：用于遍历一个可迭代对象（如列表、元组、字典、字符串等）中的元素。
while 循环：用于根据条件判断来重复执行代码块，当条件为真时，循环会一直执行下去。
主要区别：
- for 循环适合在已知循环次数或者需要遍历集合内元素的情况下使用，而 while 循环适合在未知循环次数或者需要根据条件来确定是否继续循环的情况下使用。
- for 循环通常比较适合处理已知范围的循环，而 while 循环更适合处理未知范围的循环。
- for 循环的控制结构相对简单，而 while 循环的控制结构较灵活，可以实现更复杂的循环逻辑。
5、break和continue
案例：
1、break
i = 0
while i <= 10:
if i == 5:
break
print(i)
i += 1
print('over')
输出结果如下：
0
1
2
3
4
over
i = 0
while i <= 10:
if i == 5:
i += 1
continue
print(i)
i += 1
print('over')
输出结果如下：
0
1
2
3
4
6
7
8
9
10
over
四、函数
1、函数定义式及调用
基本语法：
def 函数名称()：
代码块
from function import tab
tab() //直接调用函数名
或者：
import function # 导入整个函数文件
function.tab() # 调用: 函数文件.函数
案例：
def tab ():
row = 1
while row <= 9:
col = 1
while col <= row:
print('%d * %d = %d ' % (col, row, col * row), end='t')
col += 1
print('')
row += 1
# 使用函数名称调用函数
tab()
输出结果如下：
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
2、调用 func文件中的 tab函数
from func import tab
tab()
或者：
import func
func.tab()
2、函数注释
- 在函数名称下面使用三个引号进行注释：
def tab():
"""
这里填写注释噢
"""
row = 1
while row <= 9:
col = 1
while col <= row:
print("%d * %d = %d" %(col, row, col * row), end='t')
col += 1
print('')
row += 1
3、函数参数
def sum(num1, num2):
"""对两个变量的求和"""
print('%d + %d = %d' % (num1, num2, num1 + num2))
sum(100, 200)
4、函数返回值
def sum(num1, num2):
"""对两个变量相加结果"""
result = num1 + num2
# 使用return返回值 告诉调用一方计算结果
# return下方同缩进代码不会被执行
return result
# 使用变量 接受函数执行返回值
sum_result = sum(10, 20)
print('计算结果：%d' % sum_result)
输出结果如下：
计算结果：30
def sum():
print("没有返回值的函数!!!")
return
result = sum()
print(result)
输出结果如下：
没有返回值的函数!!!
None
5、函数嵌套
嵌套函数就是一个函数里面嵌套着另一个函数，执行过程是从上往下的
案例：
def func1(char, num):
print(char * num)
func1('*', 50)
def func1(char, num):
print(char * num)
def func2(char, num):
i = 0
while i < 5:
func1(char, num)
i += 1
func2('*', 50)
输出结果如下：
**************************************************
**************************************************
**************************************************
**************************************************
**************************************************
6、局部变量和全局变量
局部变量：
全局变量：
g_variable = 100
def num1():
g_variable = 200
# 在函数中定义局部变量g_variable和全局变量名称相同 但不会影响全局变量的值;
print('输出全局变量内容 %d' % g_variable)
def num2():
print('输出全局变量内容 %d' % g_variable)
num1()
num2()
输出结果如下：
输出全局变量内容 200
输出全局变量内容 100
但可以使用global将修改全局变量
g_variable = 100
def num1():
global g_variable
# 使用 global 关键字将可以修改全局变量；
g_variable = 200
print('输出全局变量内容 %d' % g_variable)
def num2():
print('输出全局变量内容 %d' % g_variable)
num1()
num2()
# 输入结果
输出全局变量内容 200
输出全局变量内容 200
输出结果如下：
输出全局变量内容 200
输出全局变量内容 200
五、列表
1、列表定义及引用
案例：定义列表及引用
userList = ["zhangs", "lisi", "wangwu"]
print(userList[0])
输出结果如下：
zhangs
2、列表操作
| 操作 | 格式 | 说明 |
|---|---|---|
| 查看 | 列表.index(数据, num) | 查看指定数据索引位置 ，有重复num指定第几个数据 |
| 增加 | 列表.insert(索引, 数据) | 在指定位置插入数据 |
| 列表.append(数据) | 在末行追加 | |
| 列表.extend(列表2) | 将 列表2的数据追加到列表1 | |
| 修改 | 列表[索引] = 数据 | 修改指定索引数据 |
| 删除 | del 列表[索引] | 删除指定索引数据 |
| 列表.remove[数据] | 删除指定数据(第一个出现的) | |
| 列表.pop | 删除末尾数据 | |
| 列表.pop(索引) | 删除指定索引数据 | |
| 列表.clear | 清空列表 | |
| 统计 | len(列表) | 统计列表长度 |
| 列表.count(数据) | 统计数据出现此时 | |
| 排序 | 列表.sort() | 升序 |
| 列表.sort(reverse) | 降序 | |
| 列表.reverse() | 逆序 |
案例：
1、查看
# 查看第二个 "李四" 的索引
name_list = ["张三", "李四", "王五", "李四"]
print(name_list.index("李四", 2))
输出结果如下：
3
2、增加
# insert 指定索引位置插入数据(insert一次只能插入一个值)
name_lisi = ["zhangsan", "lisi", "wangwu"]
name_lisi.insert(3, "maliu")
print(name_lisi)
# append 末尾追加数据(append一次只能插入一个值)
name_lisi = ["zhangsan", "lisi", "wangwu"]
name_lisi.append("maliu")
print(name_lisi)
# extend 列表1和列表2合并数据
name_lisi1 = ["zhangsan", "lisi", "wangwu"]
name_list2 = ["张三", "李四", "王五"]
name_lisi1.extend(name_list2)
print(name_lisi1)
输出结果如下：
['zhangsan', 'lisi', 'wangwu', 'maliu']
['zhangsan', 'lisi', 'wangwu', 'maliu']
['zhangsan', 'lisi', 'wangwu', '张三', '李四', '王五']
3、修改
name_list = ["张三", "李四", "王五"]
name_list[0] = "zhangsan"
print(name_list)
输出结果如下：
['zhangsan', '李四', '王五']
4、删除
# del 删除指定索引数据
name_list = ["张三", "李四", "王五"]
del name_list[0]
print(name_list)
# remove 删除指定数据
name_list = ["张三", "李四", "王五", "李四"]
name_list.remove("李四")
print(name_list)
# pop 删除末尾数据
name_list = ["张三", "李四", "王五", "李四"]
name_list.pop()
print(name_list)
# pop 删除指定索引数据
name_list = ["张三", "李四", "王五", "李四"]
name_list.pop(2)
print(name_list)
# clear 清空列表
name_list = ["张三", "李四", "王五", "李四"]
name_list.clear()
print(name_list)
输出结果如下：
['李四', '王五']
['张三', '王五', '李四']
['张三', '李四', '王五']
['张三', '李四', '李四']
[]
5、统计
# len() 统计列表长度
name_list = ["张三", "李四", "王五", "李四"]
print(len(name_list))
# 统计指定数据在列表中出现的次数
name_list = ["张三", "李四", "王五", "李四"]
print(name_list.count("李四"))
6、排序
# 升序 soft
# 字母A排最前 Z排最后
# 数字1排最前 数字越大排越后
list_name = ["C", "B", "A", "D"]
list_num = [2, 4, 3, 1]
list_num.sort()
list_name.sort()
print(list_name)
print(list_num)
# 降序 sort(reverse)
list_name = ["C", "B", "A", "D"]
list_num = [2, 4, 3, 1]
list_num.sort(reverse=True)
list_name.sort(reverse=True)
print(list_name)
print(list_num)
# 逆序 reverse
list_name = ["C", "B", "A", "D"]
list_num = [2, 4, 3, 1]
list_num.reverse()
list_name.reverse()
print(list_name)
print(list_num)
输出结果如下：
['A', 'B', 'C', 'D']
[1, 2, 3, 4]
['D', 'C', 'B', 'A']
[4, 3, 2, 1]
['D', 'A', 'B', 'C']
[1, 3, 4, 2]
3、循环遍历
list_name = ["张三", "李四", "王五", "马六"]
for i in list_name:
print("我的名字叫 %s " %i)
输出结果如下：
我的名字叫 张三
我的名字叫 李四
我的名字叫 王五
我的名字叫 马六
六、元组
1、元组定义及引用
# 定义元组
info_tuple = ('小明', 18, 1.75)
print(type(info_tuple))
# 引用元组
info_tuple = ('小明', 18, 1.75)
print(info_tuple[0])
# 定义空元组
info_tuple = ()
print(type(info_tuple))
# 定义只有一个元素的元组
info_tuple = ('zhangsan',)
print(info_tuple[0])
输出结果如下：
<class 'tuple'>
小明
<class 'tuple'>
zhangsan
2、元组操作
# 通过元素名称取索引
info_name = ('zhangsan', 'lisi', 'zhangsan', 'wangwu')
print(info_name.index('zhangsan'))
# 统计某个元素出现次数
info_name = ('zhangsan', 'lisi', 'zhangsan', 'wangwu')
print(info_name.count('zhangsan'))
# 统计元组中元素个数
info_name = ('zhangsan', 'lisi', 'zhangsan', 'wangwu')
print(len(info_name))
输出结果如下：
0
2
4
3、元组列表之间切换
| 函数 | 解释 |
|---|---|
| tuple() | 将列表复制为元组 |
| list() | 将元组复制为列表 |
# 列表切换元组
list_name = ["孙悟空", "猪八戒", "机器吧"]
list_name2 = tuple(list_name)
print(type(list_name))
print(type(list_name2))
# 元组切换列表
tuple_xiaoming = ("小明", 19, 1.75)
tuple_xiaoming2 = list(tuple_xiaoming)
print(type(tuple_xiaoming))
print(type(tuple_xiaoming2))
输出结果如下：
<class 'list'>
<class 'tuple'>
<class 'tuple'>
<class 'list'>
七、字典
- 列表存放有序集合，字典(dictionary)存放无序集合；
- 字典使用 { }定义；
- 字典格采用键值对格式存储数据 即一个键 对应一个值 ；
- **键 **必须是唯一的，值 可以是任何数据类型，但键只能使用 字符串、数字、元组；
1、字典定义及引用
xiaoming = {"name": "小明",
"age": 20,
"height": 1.75}
print(xiaoming)
输出结果如下：
{'name': '小明', 'age': 20, 'height': 1.75}
2、字典操作
| 操作 | 格式 | 说明 |
|---|---|---|
| 修改、添加 | 字典[key] = value | key存在则修改对应内容，不存在则添加内容 |
| 添加key添加 | 字典.setdefault(key，value) | key存在不做操作，不存在则添加key |
| 查看 | 字典.keys() | 打印所有key |
| 字典.values() | 打印所有value | |
| 字典.items() | 打印所有键值对 | |
| 删除 | del 字典[“key”] | 删除指定key |
| 字典.pop(‘key’) | 删除指定key | |
| 字典.popitem() | 随机删除一个key | |
| 字典.clear() | 清空字典 | |
| 合并 | 字典.update(字典2) | 合并字典 |
案例：
1、增删改操作
xiaoming = {"name": "小明",
"age": 20,
"height": 1.75,
"weight": 120}
# 增加、修改
xiaoming["Size"] = 100
xiaoming["name"] = "小小明"
print(xiaoming)
# 删除
xiaoming.pop("name")
输出结果如下：
{'name': '小小明', 'age': 20, 'height': 1.75, 'weight': 120, 'Size': 100}
{'age': 20, 'height': 1.75, 'weight': 120, 'Size': 100}
2、合并字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
dict1.update(dict2)
print(dict1)
输出结果如下：
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
3、其他操作
xiaoming = {"name": "小明",
"age": 20,
"height": 1.75,
"weight": 120}
# 统计键值数量
print(len(xiaoming))
# 清空字典
xiaoming.clear()
print(xiaoming)
输出结果如下：
4
{}
3、循环遍历
此处的 i 变量 相当于 key(键)
xiaoming = {"name": "小明", "age": 20}
for i in xiaoming:
print("%s : %s" % (i, xiaoming[i]))
输出结果如下：
name : 小明
age : 20
4、列表嵌套字典
class_name = [
{"姓名": "小明", "年龄": 20, "身高": 175},
{"姓名": "小红", "年龄": 18, "身高": 165},
{"姓名": "小刚", "年龄": 21, "身高": 185}
]
for i in class_name:
print(i)
输出结果如下：
{'姓名': '小明', '年龄': 20, '身高': 175}
{'姓名': '小红', '年龄': 18, '身高': 165}
{'姓名': '小刚', '年龄': 21, '身高': 185}
八、字符串
hello_str = "hello hello"
# 1、统计字符串长度
print(len(hello_str))
# 2、统计某个子字符出现次数
print(hello_str.count('llo'))
# 3、查看索引位置
print(hello_str.index('llo'))
1、字符串判断类型
| 方法 | 说明 |
|---|---|
| string.isspace() | 判断是否为空 包含制表符 |
| string.isalnum() | 判断是否不为空(只包含数字和字母) |
| string.isalpha() | 判断是否不为空(只包含字母) |
| string.isdigit() | 判断是否只包含数字 包含阿拉伯数字、(1)、u00b2 |
| string.isdecimal() | 判断是否只包含数字 包含阿拉伯数字 |
| string.isnumeric() | 判断是否只包含数字 包含阿拉伯数字、汉字数字 |
| string.istitle() | 判断是否 每个单词的首字母大写 |
案例：
# 判断 Name_id值 是否只包含 数字
Name_id = '121201920128230989385'
print(Name_id.isdigit())
# 判断每个单词首字母是否大写
Name_id = 'Name Zhang San'
print(Name_id.istitle())
输出结果如下：
True
True
2、字符串查找替换
| 方法 | 说明 |
|---|---|
| string.startswith(‘str’) | 判断字符串是否以str开头 |
| string.endswith(‘str’) | 判断字符串是否以str结尾 |
| string.find(‘str’) | 查看字符串中str索引位置编号 若不存在则返回-1 |
| string.index(‘str’) | 查看字符串中str索引位置编号 若不存在则报错 |
| string.replace(‘old_str, ‘new_str’) | 替换old_str字符为new_str |
案例：
str = 'Name'
# 查看 'm' 所在索引位置
print(str.find('m'))
print(str.index('m'))
# 将 'Name' 替换为 'name'
print(str.replace('Name', 'name'))
输出结果如下：
2
2
name
3、字符串大小写转换
| 方法 | 说明 |
|---|---|
| string.capitalize() | 将第一个字符大写 |
| string.title() | 将字符串中每个首字母大写 |
| string.lower() | 将字符串中 所有大写 转换为 小写 |
| string.upper() | 将字符串中 所有小写 转换为 大写 |
| string.swapcase() | 将字符串中 所有大小写字符 进行转换 |
案例：
str = 'L love your'
print(str.lower()) # 转小写
print(str.upper()) # 转大写
print(str.swapcase()) # 相互转化
输出结果如下：
l love your
L LOVE YOUR
l LOVE YOUR
4、字符串文本对齐
| 方法 | 说明 |
|---|---|
| string.center(宽度) | 居中对齐 |
| string.rjust(宽度) | 右对齐 |
| string.ljust(宽度) | 左对齐 |
举例：
poem = ["登鹳雀楼",
"王之涣",
"白日依山尽",
"黄河入海流",
"欲穷千里目",
"更上一层楼"]
# 居中对齐
for i in poem:
print("|%s|" % i.center(10, " "))
print('=' * 50)
# 右对齐
for i in poem:
print("|%s|" % i.rjust(10))
print('=' * 50)
# 左对齐
for i in poem:
print("|%s|" % i.ljust(10))
print('=' * 50)
输出结果如下：
| 登鹳雀楼 |
| 王之涣 |
| 白日依山尽 |
| 黄河入海流 |
| 欲穷千里目 |
| 更上一层楼 |
==================================================
| 登鹳雀楼|
| 王之涣|
| 白日依山尽|
| 黄河入海流|
| 欲穷千里目|
| 更上一层楼|
==================================================
|登鹳雀楼 |
|王之涣 |
|白日依山尽 |
|黄河入海流 |
|欲穷千里目 |
|更上一层楼 |
==================================================
5、 字符串去除空白字符
| 方法 | 说明 |
|---|---|
| string.strip() | 去除空白字符 |
| string.rstrip() | 去除右边空白字符 |
| string.lstrip() | 去除左边空白字符 |
举例：
Name = ' zhangsan '
print(Name.strip())
输出结果如下：
zhangsan
6、字符串拆分和连接
| 方法 | 说明 |
|---|---|
| string.split(separator, maxsplit) | 字符串切割，存到数组中 |
| separator.join(iterable) | 字符串拼接 |
split()方法的基本语法：
string.split(separator, maxsplit)
案例：
sentence = "Hello, world! How are you today?"
words = sentence.split()
print(words)
输出结果如下：
['Hello,', 'world!', 'How', 'are', 'you', 'today?']
sentence = "Hello, world,How,are you today?"
words = sentence.split(",",2)
print(words)
输出结果如下：
['Hello', ' world', 'How,are you today?']
join()方法的基本语法：
separator.join(iterable)
案例：
1、使用|符号连接字符串
words = ['Hello,', 'world!', 'How', 'are', 'you', 'today?']
sentence = '|'.join(words)
print(sentence)
输出结果如下：
Hello,|world!|How|are|you|today?
words = ['Hello,', 'world!', 'How', 'are', 'you', 'today?']
sentence = ' '.join(words)
print(sentence)
输出结果如下：
Hello, world! How are you today?
7、字符串的切片
切片基本语法：
字符串[开始索引:结束索引:步长]
案例：
num_str = "012345679"
# 截取从 2-5 位置 的字符串
print(num_str[2:6])
# 截取从 2-末尾 的字符串
print(num_str[2:])
# 截取从 开始-5位置 的字符串
print(num_str[:6])
# 截取从 索引1开始 每隔一个取一个
print(num_str[1::2])
# 截取字符串末尾两个
print(num_str[-2::])
# 字符串的逆序
print(num_str[::-1])
输出结果如下：
2345
2345679
012345
1357
79
976543210
九、公共方法
1、内置函数
| 函数 | 描述 | 备注 |
|---|---|---|
| len() | 计算容器中元素个数 | |
| del() | 删除变量 | |
| max() | 返回容器最大值 | 字典只针对key作比较 |
| min() | 返回容器最小值 | 字典只针对key作比较 |
案例：
name_list = ["zhangsan", "lisi", "wangwu", "maliu"]
name_key = "zhangsan"
# 统计个数
print(len(name_list))
print(len(name_key))
# 最大值 & 最小值
print(max(name_key))
print(min(name_key))
# 删除变量
del(name_key)
输出结果如下：
4
8
z
a
2、切片
| 描述 | Python表达式 | 结果 | 支持的数据类型 |
|---|---|---|---|
| 切片 | “0123456”[::-2] | 6420 | 字符串、列表、元组 |
- 切片 使用 索引 值来限定范围，从一个大的字符串中切出 小的字符串
- 列表 和 元组 都是有序集合，都能够通过索引获取到对应的数据
- 字典 是一个 无序集合 ，使用键值对保存数据，没有索引的概念 所以不支持切片
3、常用运算符
| 运算符 | Python表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1,2] + [3,4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| * | “Hi” * 3 | HiHiHi | 重复 | 字符串、列表、元组 |
| in | “a” in [“a”, “b”, “c”, “d”] | True | 元素是否包含 | 字符串、列表、元组、字 |
| not in | “a” in [“a”, “b”, “c”, “d”] | False | 元素是否不包含 | 字符串、列表、元组、字典 |
| 注意： |
十、客户管理系统(综合案例)
1、程序需求解释
2、程序实现代码
import customer_function
while True:
customer_function.showMenu()
userSelect = input("请输入选择您的指令:")
if userSelect == "1":
customer_function.newCustomer()
elif userSelect == "2":
customer_function.viewCustomer()
elif userSelect == "3":
customer_function.sourceCustomer()
elif userSelect == "0":
print("退出系统.....")
break
else:
print("选择操作无效！请重新再次选择")
customerList = [{"Name": "111",
"Gender": "111",
"Phone": "111",
"Wechat": "111",
"QQ": "111"}]
# customerList = []
def showMenu():
print("*" * 50)
print("欢迎使用【客户管理系统V0.1版本】")
print("*" * 50)
print("")
print("1. 添加客户信息")
print("2. 查看所有客户信息")
print("3. 查询客户信息")
print("")
print("0. 退出系统")
print("*" * 50)
def newCustomer():
print('*' * 50)
print("功能: 添加客户信息")
customerName = input("请输入客户姓名:")
customerGender = input("请输入客户性别:")
customerPhone = input("请输入客户电话:")
customerWechat = input("请输入客户微信:")
customerQQ = input("请输入客户QQ:")
customerList.append({"Name": customerName,
"Gender": customerGender,
"Phone": customerPhone,
"Wechat": customerWechat,
"QQ": customerQQ})
print('')
print("添加【%s】客户信息成功!!!!" %(customerName))
def viewCustomer():
if len(customerList) == 0:
print("当前没有任何客户信息:")
return
print("*" * 50)
print("功能: 查看所有客户信息")
for name in ["姓名" ,"性别" ,"电话" ,"微信" ,"QQ"]:
print(name, end='ttt')
print('')
print('=' * 50)
for i in customerList:
print("%sttt%sttt%sttt%sttt%s"
%(i["Name"] ,i["Gender"],i["Phone"],i["Wechat"],i["QQ"]))
while True:
viewCustomerUserSelect = input("0. 退出查看:")
if viewCustomerUserSelect == "0":
break
else:
print("选择操作无效！请重新再次选择")
def sourceCustomer():
print("*" * 50)
print("功能: 查询客户信息")
sourceCustomerUserSelect = input("请输入要查询的客户名称:")
for index in customerList:
if index["Name"] == sourceCustomerUserSelect:
for name in ["姓名", "性别", "电话", "微信", "QQ"]:
print(name, end='ttt')
print('')
print('=' * 50)
print("%sttt%sttt%sttt%sttt%sn"
% (index["Name"], index["Gender"], index["Phone"], index["Wechat"], index["QQ"]))
while True:
sourceCustomerUserMenu = input("1. 修改客户t2. 删除客户t0. 返回上级:")
if sourceCustomerUserMenu in ["1" ,"2" ,"0"]:
if sourceCustomerUserMenu == "1":
updateCustomer(index)
break
elif sourceCustomerUserMenu == "2":
removeCustomer(index)
break
elif sourceCustomerUserMenu == "0":
break
else:
print("选择操作无效！请重新再次选择！！！")
else:
print("没有查询到【%s】客户信息,请重新选择!!!" %sourceCustomerUserSelect)
def updateCustomer(CustomerName):
CustomerName["Name"] = nullDispose(CustomerName["Name"],"请输入修改姓名[回车不修改]:")
CustomerName["Gender"] = nullDispose(CustomerName["Gender"], "请输入修改性别[回车不修改]:")
CustomerName["Phone"] = nullDispose(CustomerName["Phone"], "请输入修改电话[回车不修改]:")
CustomerName["Wechat"] = nullDispose(CustomerName["Wechat"], "请输入修改微信[回车不修改]:")
CustomerName["QQ"] = nullDispose(CustomerName["QQ"], "请输入修改QQ[回车不修改]:")
print("修改成功!!!!")
def removeCustomer(CustomerName):
customerList.remove(CustomerName)
print("【%s】删除成功!!" %(CustomerName["Name"]))
def nullDispose(disposeName,info):
result = input(info)
if len(result) > 0:
return result # 输入
else:
return disposeName # 未输入
3、程序测试结果
**************************************************
欢迎使用【客户管理系统V0.1版本】
**************************************************
1. 添加客户信息
2. 查看所有客户信息
3. 查询客户信息
0. 退出系统
**************************************************
请输入选择您的指令:
2、添加客户信息
**************************************************
请输入选择您的指令:1
**************************************************
功能: 添加客户信息
请输入客户姓名:112
请输入客户性别:112
请输入客户电话:112
请输入客户微信:112
请输入客户QQ:112
添加【112】客户信息成功!!!!
3、查看所有客户信息
**************************************************
请输入选择您的指令:2
**************************************************
功能: 查看所有客户信息
姓名 性别 电话 微信 QQ
==================================================
111 111 111 111 111
112 112 112 112 112
0. 退出查看:
4、修改客户信息
**************************************************
请输入选择您的指令:3
**************************************************
功能: 查询客户信息
请输入要查询的客户名称:111
姓名 性别 电话 微信 QQ
==================================================
111 111 111 111 111
1. 修改客户 2. 删除客户 0. 返回上级:1
请输入修改姓名[回车不修改]:222
请输入修改性别[回车不修改]:
请输入修改电话[回车不修改]:
请输入修改微信[回车不修改]:
请输入修改QQ[回车不修改]:
修改成功!!!!
5、删除客户
**************************************************
请输入选择您的指令:3
**************************************************
功能: 查询客户信息
请输入要查询的客户名称:222
姓名 性别 电话 微信 QQ
==================================================
222 111 111 111 111
1. 修改客户 2. 删除客户 0. 返回上级:2
【222】删除成功!!
十一、函数进阶
1、函数多返回值
如果一个函数有多个返回值，需要定义多个变量来接受函数的返回值。
案例：
def t1_func():
return 1, 2, 3
a, b, c = t1_func() #定义多个变量接受函数的返回值
print(a, b, c)
输出结果如下：
1 2 3
2、缺省参数
举例： 定义形参gender缺省参数值为True
def print_info(name, gender=True):
"""
在定义函数时 形参变量使用 赋值变量 赋予默认值
"""
gender_txet = '男生'
if not gender:
gender_txet = '女生'
print('%s 是 %s' %(name, gender_txet))
# 定义缺省参数后 调用函数时如果 不指定参数 默认值为True
print_info('小明')
输出结果如下：
小明 是 男生
缺省参数注意事项：
函数定义时 带有缺省参数的形参 应该放到最后 如下是错误的定义：
# 错误定义
def test(name, age=16, height):
多个缺省参数的的调用:
def test(name, gender='男', age=26):
print('%s %s %d' % (name, gender, age))
# 只想要修改age的默认值为36 其他保持默认；
# 可以在调用函数时 使用age=36 这种方法实现效果；
test('小明', age=36)
3、关键字传参
函数调用通过“键=值”形式传递参数，同时也清除了参数的顺序需求。
def t1_func(name ,age):
print(f"名字: {name}, 年龄: {age}")
t1_func(age="16", name="zhangsan") # 不用考虑参数顺序
输出结果如下：
名字: zhangsan, 年龄: 16
4、多值传参
有时可能需要 一个函数 能够处理的参数 个数 是不确定的 这个需求情况下 就可以使用多值参数；
def test(num, *args, **wkargs):
print(num)
print(args)
print(wkargs)
test(1, 2, 3, 4, 5, name='小明', age='20')
输出结果如下：
1
(2, 3, 4, 5)
{'name': '小明', 'age': '20'}
案例：将传递的所有数字累加
需求如下：
def sum_numbers(*args):
num = 0
print(args)
for i in args:
num += i
return num
result = sum_numbers(1, 2, 3)
print(result)
输出结果如下：
(1, 2, 3)
6
5、元组和字典的拆包
-
在调用带有多值参数的函数时，如果希望
-
- 在 元组变量前 增加
一个 * - 在 字典变量前 增加
二个*
- 在 元组变量前 增加
举例：
def demo(*args, **kwargs):
print(args)
print(kwargs)
# 需要将一个元组变量/字典变量传递给函数对应的参数
gl_nums = (1, 2, 3)
gl_xiaoming = {'name': 'xiaoming', 'age': '22'}
# 错误案例
# demo(gl_nums,gl_xiaoming)
# 真确案例 相当于 demo(1, 2, 3, name='xiaoming', age='16') 简化代码量
demo(*gl_nums,**gl_xiaoming)
输出结果如下：
(1, 2, 3)
{'name': 'xiaoming', 'age': '22'}
6、函数的递归
案例：
def sum_number(num):
print(num)
# 递归出口 当参数满足某个条件时 不在执行函数
if num == 1:
return
# 调用自己
sum_number(num - 1)
sum_number(3)
输出结果如下：
3
2
1
2、计算1+1+2…+100的和
def sum_numbers(num):
if num == 1:
return 1
temp = sum_numbers(num -1)
return num + temp
result = sum_numbers(100)
print(result)
输出结果如下：
5050
7、函数作为参数传递
将函数作为参数传入到另一个函数中
- test_func需要一个函数作为参数传入，这个函数需要接受两个数字进行计算，计算逻辑由这个被传入函数决定。
- compute函数接受两个数字进行计算，compute函数作为参数传递给test_func()函数使用。
- 最终，在test_func函数内部，由传入compute函数，完成了数字计算操作。
- 所以这是一种，计算逻辑的传递，而非数据的传递。
def test_func(compute):
result = compute(1, 2)
print(result)
def compute(x, y):
return x + y
test_func(compute)
输出结果如下：
3
如上代码那样，不仅仅是相加、相减、相除等，任何逻辑都可以自行定义，并作为函数传入。
8、lambda匿名函数
基本语法如下：
lambda 传入参数: 函数体(一行代码)
案例：
test = lambda x, y: x + y
print(test(2,5))
输出结果如下：
7
十二、文件操作
| 类型 | 语法 | 解释 |
|---|---|---|
| 打开文件 | 文件对象 = open(name, mode, encoding) | 打开文件，获取文件对象 |
| 读取文件 | 文件对象.read(num) | 读取指定字节内容，不指定num读取所有 |
| 文件对象.readlines() | 读取所有内容，返回一个列表 | |
| 文件对象.readline() | 读取一行内容，常配合for循环遍历文件内容 | |
| 关闭文件 | 文件对象.close() | 关闭文件对象 |
| with open() as f: | 通过with open语法打开文件，结束后可以自动关闭文件对象 | |
| 写入文件 | 文件对象.write(“内容”) | 内容写入到内存中，如果文件存在则情况内容，添加写入内容 |
| 写入文件、刷新文件 | 文件对象.flush() | 将内存内容写入到磁盘中 |
| 追加内容 | 定义文件对象时mode模式指定’a’即可 | 模式指定’a’即追加内容，其他操作和写入文件一致 |
1、打开文件
open(name, mode, encoding)
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件，默认模式 |
| w | 以写入方式打开文件，文件不存在，则自动创建 |
| a | 打开一个文件用于追加，如果文件存在直接追加，如果文件不存在，则创建新的文件 |
示例代码：
fw = open("test.txt", 'w', encoding='utf-8')
2、读取文件
示例代码：
fw = open('测试.txt', 'r', encoding='UTF-8')
print(fw.read(10)) # 只读取10字节内容
print(fw.read()) # 读取所有内容(会接着上面内容继续往下读取内容)
示例代码：
fw = open('测试.txt', 'r', encoding='UTF-8')
result = fw.readlines()
print(type(result))
输出结果如下：
<class 'list'>
示例代码：
fw = open('测试.txt', 'r', encoding='UTF-8')
print(f"第一行内容：{fw.readline()}")
print(f"第二行内容：{fw.readline()}")
使用for循环遍历文件内容：
fw = open('测试.txt', 'r', encoding='UTF-8')
for line in fw:
print(line)
示例代码：
with open('测试.txt', 'r', encoding='UTF-8') as f:
print(f.read())
3、写入文件
1、wirte()：内容写入到内存中，如果文件存在则情况内容，添加写入内容
示例代码：
fw = open("测试.txt", 'w', encoding='UTF-8')
fr = open("测试.txt", 'r', encoding='UTF-8')
fw.write('Qin Ziteng is a handsome boy')
print(fr.read())
问：为什么没有任何返回内容？
答：因为只写入到了内存，没有从内存写入到磁盘中，所以没有输出任何内容，但是程序退出后会也会写入到磁盘中。
示例代码：
fw = open("测试.txt", 'w', encoding='UTF-8')
fr = open("测试.txt", 'r', encoding='UTF-8')
fw.write('Qin Ziteng is a handsome boy')
fw.flush()
print(fr.read())
输出结果如下：
Qin Ziteng is a handsome boy
4、追加文件
示例代码：
fw = open("测试.txt", 'w', encoding='UTF-8') # 定义写入对象
fr = open("测试.txt", 'r', encoding='UTF-8') # 定义只读对象
fa = open("测试.txt", 'a', encoding='UTF-8') # 定义追加对象
fw.write('Qin Ziteng is a handsome boyn') # 写入一句话
fa.write('Qin Ziteng is a handsome boy ....') # 追加一句话(不会清空文件原内容)
fw.flush()
fa.flush()
print(fr.read())
输出结果如下：
Qin Ziteng is a handsome boy
Qin Ziteng is a handsome boy ....
5、文件综合案例
周杰轮,2022-01-01,100000,消费,正式
周杰轮,2022-01-02,300000,收入,正式
周杰轮,2022-01-03,100000,消费,测试
林俊节,2022-01-01,300000,收入,正式
林俊节,2022-01-02,100000,消费,测试
林俊节,2022-01-03,100000,消费,正式
林俊节,2022-01-04,100000,消费,测试
林俊节,2022-01-05,500000,收入,正式
张学油,2022-01-01,100000,消费,正式
张学油,2022-01-02,500000,收入,正式
张学油,2022-01-03,900000,收入,测试
王力鸿,2022-01-01,500000,消费,正式
王力鸿,2022-01-02,300000,消费,测试
王力鸿,2022-01-03,950000,收入,正式
刘德滑,2022-01-01,300000,消费,测试
刘德滑,2022-01-02,100000,消费,正式
刘德滑,2022-01-03,300000,消费,正式
实现代码如下：
fr = open("buil.txt", 'r' ,encoding='UTF-8')
fw = open("buil.txt.bak", 'w' ,encoding='UTF-8')
for line in fr:
line = line.strip() # 去除空格
lines = line.split(',') # 切割 得到数组
if lines[4] == "正式":
fw.write(f'{line}n')
else:
continue
fr.close()
fw.close()
十三、异常处理
当检测到一个错误时，Python解释器就无法继续执行了，反而出现一些错误的提示，这就是所谓的 “异常”，也就是我们说的常说的BUG。
1、异常的捕获
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
基本语法：
try:
可能发生错误的代码段
except:
如果出现异常执行的代码
案例：
try:
fr = open('centos.txt', 'r', encoding='UTF-8')
except:
print('打开centos.txt文件失败')
输出结果如下：
打开centos.txt文件失败
捕获所有异常第二种写法，使用Exception 表示所有异常：
try:
fr = open('centos.txt', 'r', encoding='UTF-8')
except Exception as e:
print(f'ERROR: {e}')
print('捕获到异常了')
输出结果如下：
ERROR: [Errno 2] No such file or directory: 'centos.txt'
捕获到异常了
try:
print(name)
except NameError as e: # 只捕获NameError异常
print(f"ERROR: {e}")
name = "zhangsan" # 捕获到变量未定义,在except里面定义变量
print(name)
输出结果如下：
ERROR: name 'name' is not defined
zhangsan
3、捕获多个异常，捕获NameError 和 FileNotFoundError 异常
try:
print(name)
except (Exception, FileNotFoundError) as e:
print(f'ERROR: {e}')
输出结果如下：
ERROR: name 'name' is not defined
2、try…else 和 finally结构
try:
可能发生错误的代码段
except:
如果出现异常执行的代码
else:
如果没有出现异常执行的代码
finally结果基本语法：
try:
可能发生错误的代码段
except:
如果出现异常执行的代码
else:
如果没有出现异常执行的代码
finally:
无论有没有出现异常都要执行的代码
示例代码：
try:
fr = open('centos2.txt', 'r', encoding='UTF-8')
except Exception as e: # 出现异常执行
print(f'ERROR: {e}')
fr = open('cento2.txt', 'w', encoding='UTF-8')
else: # 没有出现异常执行
print('没有出现异常')
finally:
fr.close() # 无论有没有异常,都要执行关闭文件操作
输出结果如下：
ERROR: [Errno 2] No such file or directory: 'centos2.txt'
3、异常的传递性
异常时具有传递的，示例代码如下：
def func1():
print('func1函数开始....')
num = 1 / 0 # 肯定报异常
print('func01函数结束.....')
def func2():
print('func2函数开始.....')
func1()
print('func2函数结束.....')
def main():
try:
func2()
except Exception as e:
print(f'捕获到异常:{e}')
main()
当函数func1中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func2，当func2函数也没有捕获到这个异常的时候，main函数会捕捉到这个异常，这就是异常的传递性。
十四、模块
1、导入模块
模块的作用：模块就是一个python文件，里面有类、函数、变量，我们可以拿过来用(导入模块去使用)
基本语法：
[from 模块名] import [模块|类|变量|函数|*] [as 别名]
示例代码：
import time
time.sleep(100) # 使用
from time import sleep
sleep(100) # 使用
3、导入time模块所有功能
from time import *
sleep(100) # 使用
from time import sleep as t1
t1(100) # 使用
2、自定义模块
自定义模块就是自己创建一个py文件，py文件中写一些自定义的功能，然后通过import导入到其他py中使用这些自定义功能。
如上图所示：在funcs.py文件中自定义了t1_func函数，而在test.py文件中导入了这个函数并使用了。
3、__main__变量
__main__是一个特殊的变量，用于指示当前模块是否正在被直接执行。当一个Python文件被直接执行时，其__name__变量会被设置为"__main__"，这样我们可以通过检查__name__来确定代码是被导入还是直接执行的。
示例代码：
def t1_func(num1, num2):
sum = num1 + num2
print(sum)
return sum
if __name__ == "__main__": # 表示判断一下是否是其他文件调用，如果是则不执行if下面的代码
t1_func(100,100)
4、__all__变量
__all__是一个特殊的变量，用于指定一个模块中哪些成员可以被导入。但仅限于使用from module import *语句
示例代码：
__all__ = ['t1_func'] # 表示使用import * 导入所有模块时只能t1_func函数
def t1_func(num1, num2):
sum = num1 + num2
print(sum)
return sum
def t2_func(num1, num2):
sum = num1 - num2
print(sum)
return sum
十五、包
1、包概念及创建包
问：什么是包？
答：包就是一个文件夹，里面可以存放多个Python模块(py文件)，通过包，在逻辑上将一批模块归为一类，方便使用。
在包的文件夹中包含了一个__init__.py 文件，通过这文件来表示此文件夹是一个python包，而非普通的文件夹。
文件 > 新建 > Python软件包 创建完成后该目录中会存在__init__.py 文件。
可以在此文件中定义 __all__ 变量，在控制那些模块可以被导入，仅限于from Package import *方式。
__all__ = ['func_1', 'func_2']
2、导入包
示例代码如下：
1、导入Package包func_1模块
import Package.func_1
Package.func_1.t1_func() # 使用
from Package import func_1
func_1.t1_func() # 使用
3、导入Package包中func_1模块中的t1_func功能
from Package.func_1 import t1_func
t1_func() # 使用
from Package import *
func_1.t1_func() # 使用
3、安装第三方包
示例代码：
pip install requests
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple requests
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple elasticsearch --timeout 1800
pip list
原文地址:https://blog.csdn.net/weixin_45310323/article/details/134762445
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.7code.cn/show_38702.html
如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！
声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。
