一、Python快速入门 上
1.1 python基础知识
01 python介绍
python是一种面向对象、解释型、多用途设计语言，具有很丰富和强大的库，语法简介，强制用空格作为语法缩进，能够完成快速项目开发，相比传统语言开发效率高数倍。
**应用领域：**系统运维、网站开发、科学计算、爬虫、人工智能等
web框架：
- Django（最流行）
- Flask（轻量级）
- Tornado（异步框架）
为什么选择python？
- 语法简洁，易于学习
- 广泛的标准库，适合快速开发
- 跨平台，基本所有操作系统都能运行
- 是DevOps开发领域应用最广泛的语言
学习python编程：
-
python官方文档：https://www.python.org/doc
-
pycharm：强大的python集成开发环境
-
pip：python模块安装工具
02 python安装
Linux系统安装Python：
| 软件 | 版本 |
|---|---|
| CentOS | 7.9.2009 |
| Python | 3.11.2 |
# 下载Python-3.11.2
[root@python-server opt]# cd /opt/
[root@python-server opt]# wget https://www.python.org/ftp/python/3.11.2/Python-3.11.2.tgz
# 解压安装包
[root@python-server opt]# tar xf Python-3.11.2.tgz
[root@python-server opt]# ls
Python-3.11.2
# 安装依赖包
[root@python-server opt]# yum install zlib-devel -y
# 编译安装python
[root@python-server opt]# cd Python-3.11.2/
[root@python-server Python-3.11.2]# ./configure
[root@python-server Python-3.11.2]# make && make install
# 输入python3.11，已经安装成功
[root@python-server Python-3.11.2]# python3.11
# 使用python3命令也可以
Python 3.11.2 (main, Mar 15 2023, 09:36:43) [GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
# 查看python3.11安装在什么地方
[root@python-server Python-3.11.2]# which python3.11
/usr/local/bin/python3.11
Windows系统安装Python：
| 软件 | 版本 |
|---|---|
| Windows | 10 |
| Python | 3.11.2 |
下载地址：https://www.python.org/ftp/python/3.11.2/python-3.11.2-amd64.exe
1）双击安装程序开始安装
2）测试，打开cmd窗口，输入python
03 python解释器
Windows系统进入解释器：
win+r，cmd打开命令行模式，输入python，进入python解释器
Linux系统进入解释器：
命令行直接输入python3进入解释器
04 运行第一个程序
Windows系统：
print("hello world!")
D:\Python311\python.exe D:/pycode/练习/hello.py
hello world!
Linux系统：
[root@python-server scripts]# vim hello.py
#!/usr/local/bin/python3
print("hello world!")
[root@python-server scripts]# chmod +x hello.py
[root@python-server scripts]# ls
hello.py
[root@python-server scripts]# ./hello.py
hello world!
05 基本数据类型
- 整数（int）例如 10
- 浮点数（float）例如 5.7
- 字符串（str）例如 "hello world"
- 布尔值（bool）例如 True False
说明：使用type()查看数据类型
06 算数运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| + | 加法 | 5+5 结果 10 |
| - | 减法 | 10-7 结果 3 |
| * | 乘法 | 3*6 结果 18 |
| / | 除法 | 12/4 结果 3 |
| // | 整除 | 9//4 结果 2 |
| % | 取余 | 6%6 结果 0 |
| ** | 幂 | 2**3=2 * 2*2 结果 8 |
| () | 小括号 | 小括号用来提高优先级，(3+5)*2先算小括号里的 结果 16 |
07 变量
**变量：**变成语言中能存储结果或能表示值的抽象概念
**用途：**给一段数据赋予一个剪短，易于记忆的名字，方便使用
变量赋值：
变量名 = 变量值
例如：name = "axing"
多重赋值：
name1,name2 = "axing","awai"
变量引用：
print(变量名)
格式化字符串：
| 操作符号 | 描述 |
|---|---|
| %s | 字符串 |
| %d | 整数 |
| %f | 浮点数，可指定小数点后的精度 |
print("hello %s" %name)
保留2位小数点
calc = 48/16
print("计算结果：%.2f" %calc)
# 计算结果：2.82
08 赋值操作符
| 操作符 | 描述 | 示例 |
|---|---|---|
| = | 赋值，将=左侧的结果赋值给=右侧的变量 | a = 8 |
| += | 加法赋值 | b += 10等价于b = b + 10 |
| -= | 减法赋值 | |
| *= | 乘法赋值 | |
| /= | 除法赋值 | b /= 3 等价于 b = b / 3 |
| //= | 整除赋值 | |
| %= | 取余赋值 | |
| **= | 幂赋值 |
09 转义字符
| 转义字符 | 说明 |
|---|---|
| \n | 换行符，将光标位置移动到下一行 |
| \r | 回车符，将光标位置移动到本行开头 |
| \t | 水平制表符，即 tab键，相当于4个空格 |
| \b | 退格（Backspace），将光标位置移到前一列 |
| \\ | 反斜线 |
| \' | 单引号 |
| \" | 双引号 |
| \ | 在字符串行尾的续行符，一行未完，转到下一行继续写 |
10 获取用户输入
input()内建函数：用于与用户交互，接收一个参数，即要向用户显示的提示或者说明，让用户知道该怎么做。
示例：
name = input("请输入你的名字：")
print(name)
11 注释
# 单行注释
'''
三个单引号，多行注释
'''
"""
三个双引号，多行注释
"""
12 综合案例：实现简单的计算器
print("请选择运算方式：")
print("""
1、加法
2、减法
3、乘法
4、除法
""")
num = int(input("请输入编号："))
num1 = int(input("请输入第一个数字："))
num2 = int(input("请输入第二个数字："))
if num == 1:
print(num1 + num2)
elif num == 2:
print(num1 - num2)
elif num == 3:
print(num1 * num2)
elif num == 4:
print(num1 / num2)
else:
print("请输入正确的数字！")
1.2 python字符串
01 字符串格式化输出
name = "阿星"
age = 19
# 方式一
print("名字是：%s,年龄是：%d" % (name, age))
# 方式二
print(f"名字是：{name},年龄是：{age}")
# 方式三，python2和python3都支持，兼容性好
print("名字是：{},年龄是：{}".format(name, age))
02 字符串拼接
使用加号 + 可以对多个字符串进行拼接
示例：
str1 = "hello"
str2 = "world"
print(str1 + str2)
其它方式：
- 格式化输出
- 逗号
- join()内建函数，将序列中的元素拼成一个字符串
03 获取字符串长度
内建函数len()：获取字符串长度
# 语法格式
len(string)
# 获取字符串长度
str1 = "hello world"
print(len(str1))
# 结果：11
04 字符串切片
切片：截取字符串中的某部分内容
语法格式：
string[strart:end:step]
string：要切片的字符串
start：要切片的第一个索引（包括该字符），默认为0
end：要切片的最后一个字符索引（不包该字符）
step：步长，如果不指默认为1
示例：
# 获取字符串长度
str1 = "hello world"
# 截取第6个字符
print(str1[6])
# 截取0~2个字符
print(str1[0:3])
# 截取到第四个字符
print(str1[:4])
# 隔两个取一个字符
print(str1[:9:2])
# 结果
w
hel
hell
hlowr
05 字符串处理方法
str1 = " hELlo wOld! "
print("首字母大写：{}".format(str1.capitalize()))
print("字符l出现的次数：{}".format(str1.count('l')))
print("感叹号是否结尾：{}".format(str1.endswith('!')))
print("w字符是否是开头：{}".format(str1.startswith('w')))
print("w字符的索引位置：{}".format(str1.find('w'))) # str1.index('w')
print("格式化字符串hELlo{0}wOld!".format(','))
print("字符串是否都为小写：{}".format(str1.islower()))
print("字符串是否都为大写：{}".format(str1.isupper()))
print("所有字符转化为小写:{}".format(str1.lower()))
print("所有字符转化为大写：{}".format(str1.upper()))
print("感叹号替换为句号：{}".format(str1.replace('!', '.')))
print("以空格符切割字符串,生成列表:{}".format(str1.split(' ')))
print("切分为一个列表：{}".format(str1.splitlines()))
print("去除字符串两边空格：{}".format(str1.strip()))
print("字符串大小写互换：{}".format(str1.swapcase()))
# 结果
首字母大写： hello wold!
字符l出现的次数：2
感叹号是否结尾：False
w字符是否是开头：False
w字符的索引位置：9
格式化字符串hELlo,wOld!
字符串是否都为小写：False
字符串是否都为大写：False
所有字符转化为小写: hello wold!
所有字符转化为大写： HELLO WOLD!
感叹号替换为句号： hELlo wOld.
以空格符切割字符串,生成列表:['', '', '', 'hELlo', 'wOld!', '', '', '']
切分为一个列表：[' hELlo wOld! ']
去除字符串两边空格：hELlo wOld!
字符串大小写互换： HelLO WoLD!
1.3 python数据类型
01 列表 list
是一个序列的数据结构
什么是序列？
是指它的成员都是有序排列的，并且可以通过索引访问一个或多个成员
语法格式：
名称=["元素1","元素2","元素3","元素4"]
| 类型 | 方法 | 用途 |
|---|---|---|
| 查 | index("元素") | 查看元素索引位置 |
| count("元素") | 统计元素出现的次数 | |
| reverse("元素") | 倒序排序元素 | |
| sort("元素") | 进程排序 | |
| 增 | append("元素") | 追加一个元素 |
| insert(index,"元素") | 在指定索引位置插入一个元素 | |
| 改 | computer["index"]="元素" | 修改指定索引的值 |
| 删 | remove("元素") | 删除指定元素 |
| pop(index=-1) | 通过索引删除元素并返回索引 |
1）常用方法
示例：
# 定义列表computer
# 定义一个列表computer
computer = ["主机", "显示器", "鼠标", "键盘", "键盘", "键盘", "显示器", "显示器"]
# 查看元素索引位置
print("显示器的索引位置是：{}".format(computer.index("显示器")))
# 统计元素出现的次数
print("键盘出现的次数是：{}".format(computer.count("键盘")))
# 查看列表中有多少个元素
print(len(computer))
# 倒序排序元素
computer.reverse()
print(computer)
# 排序列表
computer.sort()
print(computer)
# 列表中添加一个元素
computer.append("主板")
print(computer)
# 在指定索引处添加一个元素
computer.insert(1, "显卡")
print(computer)
# 修改指定索引的元素
computer[2] = "声卡"
print(computer)
# 删除指定元素
computer.remove("键盘")
print(computer)
# 删除一个元素,可以有返回值，默认删除最后一个
dc = computer.pop()
print(dc)
# 指定索引删除
computer.pop(2)
print(computer)
2）列表切片
语法格式：
list[start:end:step]
示例：
# 定义一个列表computer
computer = ["主机", "显示器", "鼠标", "键盘", "键盘", "键盘", "显示器", "显示器"]
# 截取第一个元素
print(computer[0])
# 截取第一个到第5个元素
print(computer[0:5])
# 或者写成，从0开始，
print(computer[:5])
# 截取第一个到倒数第二个元素
print(computer[0:-1])
# 截取最后一个元素
print(computer[-1])
3）初始化、清空列表
# 重新初始化列表
computer=[]
# 删除列表
del computer
02 元组 tuple
与列表类似，也是一个序列数据结构。主要区别在于元组中的元素不能修改。
语法格式：
名称=("元素1","元素2","元素n")
元组特点：
1、不支持添加元素
2、不支持删除元素
3、不支持修改元素（如果元素里有列表可以修改）
4、支持查询元素
元组也支持切片，与列表方法一样
1）常用方法：
| 类型 | 方法 | 用途 |
|---|---|---|
| 查 | index("元素") | 查看元素索引位置 |
| count("元素") | 统计元素出现的次数 |
2）示例：
# 定义一个元组，装元素的是小括号()
tup=("显示器","显卡","键盘")
# 查看元素索引位置
print("键盘的索引位置是：{}".format(tup.index("键盘")))
# 统计元素出现的次数
print("显卡出现的次数是：{}".format(tup.count("显卡")))
03 字典 dict
字典的创建使用大括号{}的形式，字典中的每一个元素都是一对，每队包括key和value两部分，中间以冒号隔开
注意：key
（1）key的类型只能是常量类型
（2）key的值不能重复，唯一
语法格式：
dc = {"key1":"value1","key2":"value2","keyn":"valuen"}
1）常用方法
# 通过key值来访问value值
a = dict([(1, 'one'), (2, 'two'), (3, 'three')])
print(a[2])
# 比较运算符 == !=
a = dict([(1, 'one'), (2, 'two'), (3, 'three')])
b = dict([(1, 'one'), (2, 'two'), (3, 'three')])
print(a == b) # True
print(a != b) # False
# 清空字典
a = dict([(1, 'one'), (2, 'two'), (3, 'three')])
a.clear()
print(a)
# 删除字典的某一项
# pop()
ddc = a.pop(1)
print(ddc)
print(a)
# 结果
# 删除项返回值：one
# {2: 'two', 3: 'three'}
# 删除最后一项，返回剩下的键值对
a.popitem()
print(a)
2）示例：
# 定义一个空字典
# 方式一
dc1 = {}
print(type(dc1))
# 方式二
dc2 = dict()
print(type(dc2))
# 创建字典
# 通过一个映射类型的组对生成字典
ls = {1: "awai", 2: "axing", 3: "aliang"}
print(type(ls))
# 通过序列容器生成队列（序列容器的元素必须为两个元素的列表或者元组）
a = dict([(1, 'one'), (2, 'two'), (3, 'three')])
print(a)
# 通过输入方法传参（参数格式为name=value）创建字典
b = dict(one=1, tow=2, three=3, four=4)
print(b)
04 集合 set
分可变集合、不可变集合两种类型
无序并唯一地存放容器元素类型，元素不可重复
语法格式：
#创建一个空集合
a=set()
# frozenset 创建不可变集合
b = frozenset()
1）常用方法
| 方法 | 函数 | 说明 |
|---|---|---|
| 并 | union() 或者 | 运算符 | 将两个集合的元素合并在一起 |
| 交 | intersection() 或者 & 运算 | 求两个集合都有的公有元素 |
| 差 | difference() 或者 & 运算 | 求一个集合比另一个集合多、或者少的元素 |
| 补 | symmetric_difference() 或者 ^ 运算 | 求两个集合中部位交集的元素 |
| 判断子集 | issubset() 或者 <= 运算 | 判断一个集合是否是另一个集合的子集 |
2）示例
# 创建两个集合a和b
a = set([1, 2, 3, 4, 5, 6])
b = set([4, 5, 6, 7, 8, 9])
# 交集
c = a.union(b)
print(c)
# 并集
bing = a.intersection(b)
print(bing)
# 差集
cha = a.difference(b)
print(cha)
# 补集
bu = a.symmetric_difference(b)
print(bu)
# 判断子集
zj = a.issubset(b)
print(zj)
05 常见数据类型转换
| 函数 | 描述 |
|---|---|
| int(x[,base]) | 将x转换为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| str(x) | 将x转换为字符串 |
| tuple(seq) | 将序列seq转换为一个元组 |
| list(seq) | 将列表seq转换为一个列表 |
1.4 python操作符
01 比较操作符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 |
| <> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (a <> b) 返回 True。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。 | (a < b) 返回 True。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
02 逻辑操作符
| 逻辑运算符 | 含义 | 基本格式 | 说明 |
|---|---|---|---|
| and | 逻辑与运算，等价于数学中的“且” | a and b | 当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。 |
| or | 逻辑或运算，等价于数学中的“或” | a or b | 当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。 |
| not | 逻辑非运算，等价于数学中的“非” | not a | 如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。 |
03 成员操作符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
04 身份操作符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
1.5 python流程控制
01 条件判断
语法格式：
# 单判断
if <表达式>:
<代码块>
#
if <表达式>:
<代码块>
else:
<代码块>
# 多重判断
if <表达式>:
<代码块>
elif <表达式>:
<<代码块>>
elif <表达式>:
<<代码块>>
elif <表达式>:
<<代码块>>
else:
<<代码块>>
示例 - 01：单分支判断是否成年
"""
1、输入一个年龄，判断是否大于18岁，大于结果成年，小于未成年
"""
age = int(input("请输入你的年龄："))
if age > 18:
print("已经成年")
else:
print("还未成年")
示例 - 02：多分支，根据年龄划分人群类型
"""
1、输入一个年龄
小于7岁属于儿童
大于等于7岁到17岁属于少年
大于等于18到40岁属于青年
大于等于41到48岁属于壮年
大于48岁属于老年
"""
age = int(input("请输入你的年龄："))
if age < 7:
print("儿童")
elif 7 <= age < 17:
print("少年")
elif 18 <= age < 40:
print("青年")
elif 41 <= age < 48:
print("壮年")
else:
print("老年")
02 循环语句
作用：将一段代码重复执行多次
循环中两个常用语句
1） for循环
一般用于遍历数据类型的元素进程处理，例如，字符串、列表
语法格式：
for <变量> in <序列>:
<代码块>
示例 - 01：遍历字符串
# 遍历字符串
s="123helloworl!"
for i in s:
print(i)
示例 - 02：遍历列表
# 遍历列表
list1 = ["1","awai",'kaixin','中国']
for i in list1:
print(i)
示例 - 03：遍历字典
# 遍历字典
computer = {'显示器': 5000, '主板': 490, '键盘': 90, '鼠标': 45}
for i in computer.items():
print("{}的价格是：{}".format(i[0], i[1]))
示例 - 04：嵌套循环
# 嵌套循环
s1 = "123456"
s2 = "456789"
for i in s1:
for j in s2:
if i == j:
print(i)
range()内建函数：
动态生成数字序列，例如：range(10)，结果：[0, 1,2,3,4,5,6,7,8,9]
for i in range(5):
print(i)
# 结果：
0
1
2
3
4
2） while循环
在某条件下循环执行一段代码，即重复相同的任务
语法格式：
while <表达式>:
<代码块>
示例 - 01：当满足条件时停止循环
# while循环，当满足条件时停止循环
count = 0
while count < 5:
print(count)
count += 1
示例 - 02：死循环
count = 0
while True:
print(count)
count += 1
3）continue与break语句
continue
当满足条件时，跳出本次循环
示例 - 01：
# continue 示例
for i in range(1, 6):
if i == 3:
continue
else:
print(i, end='')
# 结果：1245
break
当满足条件时，跳出所有循环，结束程序
示例 - 01：
# break示例
for i in range(1, 6):
if i == 3:
break
else:
print(i, end='')
# 结果：12
综合案例：用户登陆，输入错误三次就退出程序
# 计数count
count = 0
name = "axing"
pwd = int(123456)
while True:
if count < 3:
in_name = input("请输入你的名字：").strip()
in_pwd = int(input("请输入你的密码："))
if in_name == name and in_pwd == pwd:
print("账号和密码输入正确，登陆成功！")
break
elif in_name != name or in_pwd != pwd:
print("账号和密码错误，请重新输入!!!")
count += 1
else:
print("输入错误次数已经超过{}次".format(count))
break
4） pass语句
相当于占位符
for i in range(5):
pass
1.6 python文件操作
要想读取文件（如：txt、csv等），第一步要用open()内建函数打开文件，它会返回一个对象，这个对象拥有read()、write()、close()等方法
01 open()函数
语法格式：
open(file,mode='r',encoding=None)
'''
file：打开文件的路径
mode（可选）：打开文件的模式，如只读、追加、写入等
r：只读
w：只写
a：在原有内容的基础上追加内容
w+：读写
如果需要以字节（二进制）形式读取文件，需要在mode值追加 b 即可，例如：wb
'''
1）常用方法：
| 方法 | 描述 |
|---|---|
| f.read([size]) | 读取size字节，当未指定或给赋值时，读取剩余所有的字节，作为字符串返回 |
| f.readline([size]) | 从文件中读取下一行，作为字符串返回，如果指定size则返回size字节 |
| f.readlines([size]) | 读取size字节，当为指定或给赋值时，读取剩余所有的字节，作为列表返回 |
| f.write(str) | 写字符串到文件 |
| f.flush | 刷新缓冲区到磁盘 |
| f.seek(offset[,whence=0]) | 在文件中移动指针，从whence(0代表起始位置，默认。1代表当前位置。<br />2代表文件末尾)，偏移offset个字节 |
| f.tell | 当前文件中的位置（指针） |
| f.close | 关闭文件 |
02 文件对象操作
示例 - 01：遍历打印每一行
f = open("yr.txt")
for line in f:
# strip('\n')去掉换行符
print(line.strip('\n'))
"""
结果：
lss_55444cb3
lss_55444cb3
lss_55444cb3
lss_55444cb3
"""
03 whith语句
不管在处理文件过程中是否发生异常，都能保证with语句执行完毕后已经关闭了打开的文件句柄
示例 - 01
with open("yr.txt",encoding="utf8") as f:
data = f.read()
print(data)
1.7 python函数
01 函数的定义与调用
**函数：**是指一段可以直接被另一段程序或代码引用的程序或代码
在编写代码时，经常将一些常用的功能模块编写成函数，放在函数库中供公共使用，可以减少重复编写程序段和简化代码结构
语法格式：
def 函数名(参数1,参数2,参数n)
<代码块>
return<表达式>
示例 - 01：
def hello():
print('hello world!')
# 调用函数
hello()
02 函数参数
接收参数：
示例 - 02：求和
# 求和函数
def sum(a, b):
return a + b
a = sum(3, 7)
print(a)
# 结果：10
参数默认值：
预先给参数定义默认值，如果调用函数时没有指定该值，则用默认值。
def sum(a, b=5):
return a + b
a = sum(7)
print(a)
# 结果：12
接收任意数量参数：
*name 接收任意多个参数，并放到一个元组中
**name 接收一个键值，并存储为字典
示例 - 01：传入多个参数，计算总和
# 传入多个参数，计算总和
def func(*seq):
x = 0
for n in seq:
x += n
return x
print(func(1, 2, 3, 4, 5, 6))
# 结果：21
示例 - 02：传入多个键值
# 传入多个键值
def func(**computer):
for k, v in computer.items():
print("名称:{},价格:{}".format(k, v))
func(主机=5000, 显示器=300, 键盘=68, 鼠标=39)
'''
结果：
名称:主机,价格:5000
名称:显示器,价格:300
名称:键盘,价格:68
名称:鼠标,价格:39
'''
示例 - 03：接收任意数量参数
# 接收任意数量参数
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1, 2, 3, a=4, b=13, c=19, d=[9, 8, 7])
'''
结果：
(1, 2, 3)
{'a': 4, 'b': 13, 'c': 19, 'd': [9, 8, 7]}
'''
03 匿名函数（Lambda）
没有名字的函数，使用lambda关键字定义，一般仅用于单个表达式。
示例 - 01：求和函数
# lambda函数求和
sum = lambda a, b: a + b
print(sum(4, 8))
# 等价于
def func(a,b):
return a + b
示例 - 02：判断
# lambda判断奇数偶数
a = lambda x: "偶数" if x % 2 == 0 else "奇数"
print(a(7))
# 结果：奇数
04 作用域
限制一个变量或一段代码可用范围，好处是可以提高程序逻辑的局部性，减少名字冲突。
优先级：变量从代码块里面往外开始查找
外 内
Built-in(内置) -> Global(全局) -> Enclosed(嵌套) -> Local(局部)
Local（局部作用域）：在函数中定义的变量。def关键字定义的语句块
Enclosed（嵌套作用域）：一般出现在函数中嵌套一个函数时，在外部函数中的作用域称为嵌套作用域（闭包常见）
Global（全局作用域）：文件顶层定义的变量
Built-in（内置作用域）：系统内解释器定义的变量，例如：关键字
05 闭包
就是一个定义在函数内部的函数，闭包使得变量即脱离了该函数的作用域范围也依然能被访问到。
嵌套函数也是闭包的一种形式（将内部嵌套定义的函数作为返回值）
闭包满足三个条件：
- 两层以上嵌套关系
- 内部函数调用外部函数定义的变量
- 外部函数返回内部函数体对象（函数名不加括号），而不是函数体结果（函数名后跟小括号）
示例 - 01
def outer():
x = 1
def inner():
# 内部函数调用外部函数的变量
print(x)
# return inner() 返回函数结果
return inner # 返回函数体
# 外部函数引用了内部函数的返回值
f = outer()
f() # 相当于outer()()，代表执行内部函数
# 结果：1
06 函数装饰器
装饰器本质上是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象
应用场景：
- 记录日志
- 性能测试
- 权限校验
示例 - 01：无参数装饰器
def hello():
print("我是原函数")
def dt(func):
def f():
print("原函数开始执行...")
func()
print("原函数结束执行...")
return f # 返回函数体
dec = dt(hello) # 装饰器传入函数
dec() # 调用内部函数
python提供一个简洁引用装饰器的方法：语法糖 "@"
示例 - 02：使用@装饰器
# 使用@装饰器
def dtcorator(func):
def f():
print("原函数开始执行...")
func()
print("原函数结束执行...")
return f # 返回函数体
# 函数体需要放在装饰器的上面，要不调用不到
@dtcorator
def hello():
print("我是原函数！")
hello()
示例 - 03：带参数装饰器
# 带参数装饰器
def decorator(func):
def f(msg):
print("原函数开始执行了...")
func(msg)
print("原函数结束执行了...")
return f
@decorator
def hello(msg):
print(msg)
hello("我是原函数！")
1.8 python常用内建函数
| 内建函数 | 功能描述 |
|---|---|
| map() | 根据提供的函数处理序列中的元素，处理完后返回一个迭代器对象 |
| filter() | 用于过滤序列，过滤掉不符合条件的元素，处理完后返回一个迭代器对象 |
| sorted | 对所有可迭代对象进行排序操作 |
| reversed() | 返回一个反向的可迭代对象 |
| join() | 将序列中的元素以指定的字符连接，生成一个新的字符串 |
| min() | 返回可迭代对象中的最小元素 |
| max() | 返回可迭代对象中的最大元素 |
| sum() | 对可迭代对象求和 |
| zip() | 对多个可迭代对象创建一个聚合，返回一个元组的迭代器 |
| locals() | 字典格式返回当前范围的局部变量 |
| globals() | 字典格式返回当前范围的全局变量 |
01 高阶函数
高阶函数至少满足两个任意一个条件
①能接收一个或多个函数作为输入
②输出一个函数
1）map()
语法格式：
# iterable 可迭代
map(func,iterable,...)
示例 - 01 map()函数演示
num = range(1, 11)
def handle(n):
return n * 2
result = map(handle, num)
print(list(result))
# 使用匿名函数
num = range(1, 11)
result = map(lambda n: n * 2, num)
print(list(result))
2）filter()
语法格式：
filter(function,interable)
示例 - 01 filter()函数
num = range(1, 11)
def handle(n):
if n % 2 == 0:
return n
result = filter(handle, num)
print(list(result))
# 使用匿名函数
num = range(1, 11)
result = filter(lambda n: n % 2 == 0, num)
print(list(result))
02 排序函数
1）sorted()
对所有可迭代对象进行排序操作
语法格式：
sorted(iterable,*,key=None,reverse=False)
# key：指定带有单个参数的函数，用于从interable的每个元素取出比较的键，默认为None（直接比较元素）
# reverse：排序规则，True 降序，False 升序（默认）
示例 - 01 对列表排序
n = [2, 4, 12, 1, 6, 11]
s = ["c", "d", "a", "b"]
print(sorted(n))
print(sorted(s, reverse=True))
'''
结果：
[1, 2, 4, 6, 11, 12]
['d', 'c', 'b', 'a']
'''
示例 - 02 对字典中的值排序
dict = {'a': 86, 'c': 45, 'b': 23}
result = sorted(dict.items(), key=lambda x: x[1])
print(result)
'''
结果：
[('b', 23), ('c', 45), ('a', 86)]
'''
2）reversed()
返回一个反转的迭代器
语法格式：
reversed(seq)
示例 - 01 列表反向
n = [1, 2, 3, 4, 5]
print(list(reversed(n)))
'''
结果：
[5, 4, 3, 2, 1]
'''
03 拼接字符串
1）join()
将序列中的元素以指定的字符连接，生成一个新的字符串
语法格式：
# str 连接符
str.join(sequence)
示例 - 01 拼接字符串
str = "+"
s = "helloworld!"
print(str.join(s))
'''
结果：
h+e+l+l+o+w+o+r+l+d+!
'''
示例 - 02 拼接序列
str = "+"
list01 = ["主机", "显示器", "键盘", "鼠标"]
print(str.join(list01))
'''
结果：
主机+显示器+键盘+鼠标
'''
04 最小值、最大值、求和函数
s = [1, 2, 3, 12, 6, 10]
# 最小值min()
print(min(s))
# 最大值max()
print(max(s))
# 求和sum()
print(sum(s))
05 多个可迭代对象聚合
1）zip
对多个可迭代对象创建一个聚合，返回一个元组的迭代器
语法格式：
zip(x,y)
示例 - 01
x = [1, 2, 3]
y = [4, 5, 6]
zip_demo = zip(x, y)
print(list(zip_demo))
06 获取当前所有变量
- globals()：字典格式返回当前范围的全局变量
- locals()：字典格式返回当前范围的局部变量
示例 - 01
a = 1
c = 3
def func():
b = 2
d = 4
print("局部变量为：{}".format(locals()))
print("全局变量为{}".format(globals()))
func()
'''
结果：
全局变量为：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001A6D87A4E50>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\pycode\\练习\\f_str1.py', '__cached__': None, 'a': 1, 'c': 3, 'func': <function func at 0x000001A6D87504A0>}
局部变量为：{'b': 2, 'd': 4}
'''