往期回顾：
目录
一、公共运算符和函数
所谓的公共运算符及函数是指他们既可以操作列表，也可以操作字符串、元组、以及字典等。
1.公共运算符
+：连接 适用于字符串、列表、元组
* ：重复 适用于字符串、列表、元组
in：成员判断 适用于字符串、列表、元组、字典（仅判断键）
not in：非成员判断 与 in 相反。
[]：索引访问 适用于字符串、列表、元组、字典（用键索引）
[:]：切片 适用于字符串、列表、元组
举例：后面两种前一篇文章已经讲过了，这里举例前3种
"hello" + "world" # 'helloworld'
[1, 2] + [3, 4] # [1, 2, 3, 4]
(1, 2) + (3,) # (1, 2, 3)"ha" * 3 # 'hahaha'
[1, 2] * 2 # [1, 2, 1, 2]
(1, 2) * 2 # (1, 2, 1, 2)'a' in 'abc' # True
3 in [1, 2, 3] # True
2 in (1, 2, 3) # True
'age' in {'name': 'Tom', 'age': 20} # True2. 公共函数
len(obj)：返回长度或元素个数
type(obj)：返回对象的类型
isinstance(obj, type)：判断是否是某种类型
max(iterable) 和 min(iterable)：求最大/最小值
sorted(iterable)：排序并返回新列表
enumerate(iterable[ , 起始索引])：可以对数据进行拉链操作
举例：
len("abc") # 3
len([1, 2, 3]) # 3
len((1, 2)) # 2
len({'a': 1, 'b': 2}) # 2type("abc") # <class 'str'>
type([1, 2]) # <class 'list'>
isinstance("abc", str) # True
isinstance([1, 2], list) # Truemax([1, 2, 3]) # 3
min(('a', 'b')) # 'a'
max({'a': 1, 'b': 2}) # 'b'（按键排序）sorted("hello") # ['e', 'h', 'l', 'l', 'o']
sorted([3, 1, 2]) # [1, 2, 3]
sorted({'b': 1, 'a': 2}) # ['a', 'b']list1 = ['a', 'b', 'c']
for i in enumerate(list1):
print(i) # (0, 'a')(1, 'b')(2, 'c')二、推导式
所谓推导式就是为了简化python代码的
2.1列表推导式
# 获取一个列表，其中值为0到9
list1 = []
for i in range(10):
list1.append(i)
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 利用列表推导式
list2 = [i for i in range(10)]
print(list2) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 求0到9之间的偶数
list3 = [i for i in range(0,10,2)]
print(list3) # [0, 2, 4, 6, 8]
# 获取一个列表，值为[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list6 = [(i,j) for i in range(1,3) for j in range(3)]
print(list6) # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]2.1 集合推导式
集合推导式和列表推导式相同，就是中括号换成大括号
set1 = {(i,j) for i in range(1,3) for j in range(3)}
print(set1) # {(1, 2), (2, 1), (1, 1), (2, 0), (2, 2), (1, 0)}2.3 字典推导式
# 快速创建字典，key是1~5，value是key的二次方
dict1 = {i:i**2 for i in range(1,6)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 合并两个元素个数一致的列表
list1 = ['a','b','c']
list2 = [1,2,3]
dict2 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict2) # {'a': 1, 'b': 2, 'c': 3}三、函数
函数就是组织好的、可重复使用的、用来实现特定功能的代码块。是Python编程中非常重要的组成，极大的提高了代码的可读性、可维护性和可复用性。
3.1 函数定义
格式：
def 函数名(参数列表) -> 返回类型:
函数体,就是我们为了实现特定功能编写的代码
return 具体的返回值
def 表示定义函数, 固定格式
函数名 要符合命名规则和命名规范, 方便我们调用的
参数列表 调用这个函数需要传入什么值
函数体 为了实现特定功能编写的代码
return 主职: 结束方法, 兼职: 如果方法有返回值, 可以捎带着返回这些结果.->返回类型 定义函数返回值类型，可以省略不写
举例：
# 定义一个打印n次hello world的函数
def say_hello(n):
for i in range(n):
print('hello world')
say_hello(5)查看函数的说明文档，调用时光标移动到函数上使用ctrl＋q查看函数的说明文档
# 有参有返回值的函数
def sum_i(a,b):
"""
该函数用于计算两个整数的和
:param a:整数a
:param b:整数b
:return:返回a+b的值
"""
return a+b;
# 光标移动到括号中使用快捷键ctrl＋q
sum1 = sum_i(1,2)
print(sum1) # 3
注意上面这个函数函数定义时def sum_i(a,b)中a,b叫形参，函数调用时sum_i(1,2)中的1，2是实参，sum1接收函数调用后的返回值。
3.2 函数嵌套
函数的嵌套指的是在一个函数中调用另一个函数，一定注意不是函数嵌套定义。
举例：
# 对列表所有数据求和
def sum_l(list1:list):
sum = 0
for i in list1:
sum += i
return sum
# 对列表数据进行求平均值
def avg_l(list1:list):
sum = sum_l(list1)
avg = round(sum / len(list1),2) # 对结果保留两位小数，四舍五入
return avg
list1 = [1,2,3,4,5]
# 下面这种写法也是一种函数的嵌套调用
print(avg_l(list1)) # 3.0
注意：上面的例子中我们在定义函数时对参数的类型进行了限定， def sum_l(list1:list)：表示只接收list类型的值作为参数，传入其他类型会报错。
3.3 变量的作用域
变量的作用域就是指该变量在哪个范围有效，根据变量的作用域不同可分为全局变量和局部变量。不过不管是全局变量还是局部变量都必须遵守先定义再使用这一原则。
局部变量: 写到函数的内部或者函数的形参列表中的变量, 只在该函数内部有效.
全局变量: 定义在函数外边的变量叫全局变量, 或者 global修饰的变量 也叫全局变量. 全局变量在该.py文件内部都有效.
举例：
num = 100
# 1.定义函数 show()
def show():
global a,num
a,b = 10,20
print(f'show()函数中打印a，b ={a,b}') # show()函数中打印a，b =(10, 20)
num = 666
show()
print(f'show()函数外打印a ={a}') # show()函数外打印a =10
# 下面代码报错：name 'b' is not defined
# print(f'show()函数外打印b ={b}')
# 如果某个函数修改了全局变量中的值，那么出函数后该值也会改变
# 注意必须加global限定才能修改全局变量中的值
print(num) # 6663.4 函数参数类型
插一个知识点：函数返回多个值
Python中的函数如果返回多个值, 默认是把这个多个值放到一个元组中, 然后返回的。
# 定义函数，返回值: 加减乘除结果
def calc(a, b):
sum = a + b
sub = a - b
mul = a * b
div = a // b # //整除, /除法
return sum, sub, mul, div
# 调用函数，接收返回值
result = calc(10, 3)
print(result, type(result)) # (13, 7, 30, 3) <class 'tuple'>位置参数、关键字参数、缺省参数
# 位置参数 位置参数的个数以及顺序必须和形参的个数及顺序保持一致
def show1(name,age):
print(f"我是{name}，我今年{age}岁了")
# show1('小明',18)
show1(18,'小明')
# 关键字参数，注意该参数如果与位置参数同时出现必须放在其后面
def show2(name,age):
print(f"我是{name}，我今年{age}岁了")
show2(age=18,name='aaa')
# 缺省参数，就是给形参设置默认值
def show2(name,age,spec='打篮球'):
print(f"我是{name}，我今年{age}岁了，我擅长{spec}")
show2(age=18,name='aaa')
show2('aaa',spec='rap',age=18)运行结果：
# 我是18，我今年小明岁了
# 我是aaa，我今年18岁了
# 我是aaa，我今年18岁了，我擅长打篮球
# 我是aaa，我今年18岁了，我擅长rap不定长参数：不定长参数也叫可变参数, 即: 参数的个数是可变的。
一个 * （位置参数）表示接收单个值封装到元组中，两个 * （关键字参数）表示接收键值对封装到字典中
1. 如果位置参数, 一般用 *args表示
2. 如果是关键字参数, 一般用 **kwargs kw: keyword 关键字的意思
3. 可变参数用于形参, 表示可以接收任意个实参, 最少0个, 最多无数个4. *args是位置参数的, **kwargs是接收关键字参数, 不冲突, 所以在一个函数中, 可以共存
def sum1(*args):
print(args,type(args),len(args)) # (1, 2, 3) <class 'tuple'> 3
sum = 0
for i in args:
sum += i
return sum
print(sum1(1,2,3)) # 6
def info1(**kwargs):
print(kwargs,type(kwargs)) # {'name': 'abc', 'age': 18, 'hight': 100} <class 'dict'>
for i in kwargs:
print(i,end=' ') # name age hight
info1(name='abc',age=18,hight=100)3.5 匿名函数
匿名函数（Anonymous Function） 是指没有显式名称的函数。它通过关键字 lambda 来定义，因此也被称为 lambda 函数。
格式：lambda 参数列表: 表达式
# 1. 普通形式
def get_sum(a, b):
return a + b
print(get_sum(1, 2))
# 2.匿名函数
get_sum2 = lambda a, b: a + b
print(get_sum2(2, 3))匿名函数不是用来替代普通函数的，而是为了简化代码结构，尤其是在需要一个简单函数作为参数传递给其他函数时非常有用。
3.6 函数递归
递归值得是函数自己调用自己
递归必须有出口，否则容易造成死递归
# 计算5的阶乘
def factorial(n):
# 出口: 1! = 1
if n == 1:
return 1
else:
# 规律: n! = n * (n - 1)!
return n * factorial(n - 1)
print(factorial(5))四、拆包和组包
拆包: 把一个容器类型(例如: 列表, 元组, 字典), 变成多个 "单值"类型, 1 -> 多
组包: 把多个"单值"类型, 合并成一个整体(例如: 列表, 元组, 字典) 多 -> 1细节:
1. 拆包的时候, 变量格式要和容器中的元素个数一致
2. 对字典拆包, 获取的是所有的键
# 列表操作
list1 = [10, 20, 30, 'abc', True] # 组包
a, b, c, d, e = list1 # 拆包
print(a, b, c, d, e) # 10 20 30 abc True
# 元组操作
tuple1 = (10, 20, 'abc', True)
a1, b1, c1, d1 = tuple1
print(a1, b1, c1, d1) # 10 20 abc True
a1,b1 = b1,a1 # 利用组包和拆包交换两个变量值
# 字典操作
dict1 = {'name': 'aaa', 'age': 18}
k1, k2 = dict1 # 拆包只能拆到 键
print(k1, k2) # name age
# 优化写法
for k,v in dict1.items():
print(f'{k} = {v}') # name = aaa age = 18
# 集合操作（这里需要注意集合是无序的）
set1 = {10, 'abc', True}
a, b, c = set1
print(a, b, c) # True 10 abc
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
