函数
* 和 ** 分别在形参和实参中的用法
- 形参
- *参数：函数接收任意长度的非关键字参数，系统将这些参数用tuple元组组合起来表示
- **参数：函数接收任意长度的关键字参数，系统将这些参数用dict字典组合起来表示
- 混合使用：关键字必须在位置参数后面，否则报错
- 实参
- *参数：
- 实参中的 * 后面跟的是可迭代对象，获取的是可迭代对象的 key，此时形参为位置参数或可变参数都可以
- 除了list, str, tuple等，还可以用dict作为实参，获取的是dict中的key值
- ** 参数：实参中的 ** 后面跟的是可迭代映射，获取的是可迭代映射的 value。此时，当形参为位置参数时，获取的是可迭代映射的value，当形参为关键字参数时，获取的是dict
- *参数：
命名关键字参数（了解）
- 需要形参传实参的时候必须按照关键字
- 在形参 * args的后面
- 如果形参中还有** kwargs，那必须在它的前面
名称空间
- 定义：用来存放变量名与数据值之间绑定关系的地方
- 分类：
- 内置名称空间：python解释器运行就会立刻创建的空间（代码过程中可以直接使用的名字都在该空间中）
- 全局名称空间：py文件运行代码过程中产生的名字都会存入该空间（普通代码分支结构循环结构里的变量名、定义函数的函数名、定义类的类名）
- 存活周期：
- 内置名称空间：解释器运行（创建），解释器关闭（销毁）
- 全局名称空间：py文件运行（创建），py文件结束（销毁）
- 局部名称空间：函数体代码运行（创建），函数体代码结束（销毁）
名字查找顺序
-
当前在全局名称空间：全局名称空间 → 内置名称空间
-
当前在局部名称空间：局部名称空间 → 全局名称空间 → 内置名称空间
-
名字的查找顺序默认情况下不能颠倒只能是：局部名称空间 → 全局名称空间 → 内置名称空间
名称空间的作用域
- 内置名称空间/全局名称空间：在程序任意位置都可以使用(全局有效)
- 局部名称空间：在各自的局部空间可以使用(局部有效)
局部名称空间复杂情况
- 各自局部名称空间默认情况下不能彼此共享名字
def func1():
name = 'jason'
print(age)
def func2():
age = 18
print(name)
func1()
func2()
- 特殊情况
x = 1
def func1():
x = 2
def func2():
x = 3
def func3():
print(x) # 特例
# x = 4
func3()
func2()
func1()
- 函数在定义阶段其实名字的查找顺序就已经固定死了
name = 'jason'
def func():
print(name) # 报错
name = 'jasonNB'
func()
global与nonlocal关键字
- 正常情况下，局部名称空间里面出现新的名字会在局部名称空间中存储，但是有时候需要在局部名称空间中修改全局名称空间的名字
money = 999
def func():
money = 1000
print(money) # 1000
func()
print(money) # 999
def func():
global money # 声明 局部名称空间中的money操作的是全局的money
money = 1000
print(money) # 1000
func()
print(money) # 1000
- 局部修改全局名称空间中不可变类型的数据，需要使用关键字global声明，如果是可变类型，则无需关键字声明
l1 = [1, 2, 3, 4, 5]
s = '$jason$'
def func():
s = 'jason'
res = s.strip('$')
l1.append(113123)
l1.append(666)
func()
print(l1) # [1, 2, 3, 4, 5, 113123, 666]
def func():
global s
s = 'jason'
res = s.strip('$')
l1.append(113123)
l1.append(666)
func()
print(l1) # [1, 2, 3, 4, 5, 113123, 666]
- nonlocal 在内存局部名称空间修改外层局部名称空间中的不可变类型
def func1():
x = 1
l1 = [1,2]
def func2():
# nonlocal x
x = 999
l1.append(666)
func2()
print(x) # 1
print(l1) # [1, 2, 666]
func1()
def func1():
x = 1
l1 = [1,2]
def func2():
nonlocal x
x = 999
l1.append(666)
func2()
print(x) # 999
print(l1) # [1, 2, 666]
func1()
函数名的多种使用方式
-
函数名也可以被用来多次赋值(函数名与变量名使用一致)
-
函数名还可以当做函数的实参
-
函数名还可以当做函数的返回值
-
数名还可以当做容器类型里面的数据值
闭包函数
-
定义：在一个内部函数中，对外部作用域的变量进行引用，(并且一般外部函数的返回值为内部函数)，那么内部函数就被认为是闭包
-
特征：
- 定义在函数内部的函数
- 内部函数使用了外部函数
-
实际应用：
# 给函数体代码传值的方式一：通过形参传值
def func(xxx):
print(xxx)
# 给函数体代码传值的方式2：闭包函数
def index():
username = 'jason'
def func():
print(username)
return func
res = index('jason')
res()
装饰器
简介
- 概念：函数知识整合到一块的产物
- 本质：在不改变装饰对象原来的‘调用方式’和‘内部代码’的情况下给被装饰的对象添加功能
- 原则：对修改封闭，对扩展开放
装饰器固定模板
from functools import wraps
def outer(func_name):
@wraps(func_name) # 仅仅是为了让装饰器不容易被别人发现 做到真正的以假乱真
def inner(*args, **kwargs):
print('执行被装饰对象之前可以做的额外操作')
res = func_name(*args, **kwargs)
print('执行被装饰对象之后可以做的额外操作')
return res
return inner
装饰器语法糖
import time
from functools import wraps
def outer(func_name):
@wraps(func_name) # 仅仅是为了让装饰器不容易被别人发现 做到真正的以假乱真
def inner(*args, **kwargs):
print('执行被装饰对象之前可以做的额外操作')
res = func_name(*args, **kwargs)
print('执行被装饰对象之后可以做的额外操作')
return res
return inner
@outer # home = outer(真正的函数名home)
def home():
'''我是home函数 我要热死了!!!'''
time.sleep(1)
print('from home')
return 'home返回值'
home()
多层装饰器
- 语法糖功能：会自动将下面紧挨着的函数名当做参数传递给@符号后面的函数名（加括号调用）
- 多个语法糖装饰一个函数名：从下往上执行最后一个语法糖才会做重命名操作
def outter1(func1): # func1 = wrapper2函数名
print('加载了outter1')
def wrapper1(*args, **kwargs):
print('执行了wrapper1')
res1 = func1(*args, **kwargs)
return res1
return wrapper1
def outter2(func2): # func2 = wrapper3函数名
print('加载了outter2')
def wrapper2(*args, **kwargs):
print('执行了wrapper2')
res2 = func2(*args, **kwargs)
return res2
return wrapper2
def outter3(func3): # func3 = 真正的index函数名
print('加载了outter3')
def wrapper3(*args, **kwargs):
print('执行了wrapper3')
res3 = func3(*args, **kwargs)
return res3
return wrapper3
# 语法糖功能：会自动将下面紧挨着的函数名当做参数传递给@符号后面的函数名（加括号调用）
@outter1 # index = outter1(wapper2) index是wrapper1
@outter2 # wrapper2 = outter2(wrapper3)
@outter3 # wrapper3 = outter3(真正的index函数名)
def index():
print('from index')
index()
# 加载了outter3
# 加载了outter2
# 加载了outter1
# 执行了wrapper1
# 执行了wrapper2
# 执行了wrapper3
# from index
有参装饰器
- 有参装饰器：编写一个装饰器时，当这个装饰器内部需要外界传入额外的数据来控制代码的分支，就需要给原来的装饰器模板再套用一层，加语法糖时就直接添加额外的数据
def outer(condition,type_user): # 给装饰器传参数（有几个参数就传几个参数）
def login_auth(func_name): # 这里不能再填写其他形参
def inner(*args, **kwargs): # 这里不能再填写非被装饰对象所需的参数
username = input('username>>>:').strip()
password = input('password>>>:').strip()
# 应该根据用户的需求执行不同的代码
if type_user =='jason':print('VIP')
if condition == '列表':
print('使用列表作为数据来源 比对用户数据')
elif condition == '字典':
print('使用字典作为数据来源 比对用户数据')
elif condition == '文件':
print('使用文件作为数据来源 比对用户数据')
else:
print('目前只有上面几种方式')
return inner
return login_auth
@outer('文件','jason') # 函数名加括号 优先级最高
def index():
print('from index')
index()
递归函数
- 概念：在函数内部直接或间接调用自己的函数
- python中允许函数最大递归调用次数，官方给出的限制是1000，代码验证可能会有偏差（996 997 998...都有可能）
- 应用场景：
- 递推：层层往下寻找答案（每一次都是基于上一次进行下一次的执行）
- 回溯：遇到终止条件，则从最后往回返一级一级的把值返回来
- 特点：
- 必须要有一个明确的结束条件
- 一层比一层更简单
l1 = [1, [2, [3, [4, [5, [6, [7, [8, [9, [10,]]]]]]]]]]
def get_num(l1):
for i in l1: # for循环自带结束条件，不用手动加结束条件
if isinstance(i, int): # 判断i绑定的数据值是不是整型
print(i)
else:
get_num(i)
get_num(l1)
算法之二分法
算法
-
定义：解决问题的方法
-
算法永远都在精进，但是很少有最完美的算法
二分法
-
定义：二分法是所有算法里最简单的算法
-
前提：数据集必须有顺序(升序/降序)
-
原理：获取数据集中间的元素，比对大小
l1 = [11, 23, 32, 45, 65, 78, 90, 123, 432, 467, 567, 687, 765, 876, 999, 1131, 1232]
def get_num(l1, target_num):
# 添加递归函数的结束条件
if len(l1) == 0:
print('不好意思 找不到')
return
# 1.先获取数据集中间那个数
middle_index = len(l1) // 2
middle_value = l1[middle_index]
# 2.判断中间的数据值与目标数据值孰大孰小
if target_num > middle_value:
# 3.说明要查找的数在数据集右半边 如何截取右半边
right_l1 = l1[middle_index + 1:]
# 获取右半边中间那个数
# 与目标数据值对比
# 根据大小切割数据集
# 经过分析得知 应该使用递归函数
print(right_l1)
get_num(right_l1, target_num)
elif target_num < middle_value:
left_l1 = l1[:middle_index]
# 获取左半边中间那个数
# 与目标数据值对比
# 根据大小切割数据集
# 经过分析得知 应该使用递归函数
print(left_l1)
get_num(left_l1, target_num)
else:
print('找到了', target_num)
# get_num(l1, 999)
get_num(l1, 1000)
- 缺陷：
- 数据集必须是有序的
- 查找的数如果在开头或结尾而分发效率更低
三元表达式
- 语法结构：值1 if 条件 else 值2（注意：没有冒号）
- 如果if后面的条件成立，则使用if前面的值
- 如果if后面的条件不成立，则使用else后面的值
# 编写一个函数，比较两个数的大小，返回较大的数
# 一般编写
def max_num(a, b):
if a > b:
return a
else:
return b
res = max_num(1, 10)
print(res) # 10
# 三元表达式编写
def max_num(a, b):
return a if a > b else b
res = max_num(1, 10)
print(res) # 10
-
注意：
- 仅限于二选一的情况并且不建议嵌套使用
res = 123 if 10 > 5 else (222 if 0 else (666 if 1 == 2 else 666)) # 不建议嵌套使用- 在python中代码不是精简的越少越好，在精简的过程中还要保证代码的可读性
生成式
列表生成式
-
概念：列表生成式是python内置的一种创建列表的方法，通过在[]内部执行一行for循环语句，将for循环所遍历到的元素添加到列表中
-
语法结构：[表达式 for 变量 in 列表] 或 [表达式 for 变量 in 列表 if 条件]
-
注意：列表生成式中只能出现for和if
# 给列表中所有的数据值加上_NB的后缀
name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
# 1.定义一个新的列表
new_list = []
# 2.循环原列表中所有的数据值
for name in name_list:
# 3.拼接_NB后缀
new_name = name + '_NB'
# 4.追加到新列表中
new_list.append(new_name)
print(new_list)
new_list = [name + '_NB' for name in name_list]
print(new_list)
new_list = [name + '_NB' for name in name_list if name != 'jason']
print(new_list)
字典生成式
- 概念：通过在大括号{} 内执行一行for循环语句创建一个新的字典，大括号内的语句需要指定键值对的key与value，这两项值都是for循环语句中变量
- 语法结构：{key: values for 变量名 in 数据集} 或 {key: values for 变量名 in 数据集 if 条件}
new_dict = {i: 'jason' for i in range(10)}
print(new_dict) # {0: 'jason', 1: 'jason', 2: 'jason', 3: 'jason', 4: 'jason', 5: 'jason', 6: 'jason', 7: 'jason', 8: 'jason', 9: 'jason'}
new_dict = {i: 'jason' for i in range(10) if i == 6}
print(new_dict) # {6: 'jason'}
集合生成式
- 概念：python集合生成式与列表生成式几乎是一模一样的，只需要将[]替换为{} 即可，在{}内执行一个for循环语句，for循环所遍历的元素自动添加到集合之中
- 语法结构：{表达式 for 变量 in range()} 或 {表达式 for 变量 in range() if 条件}
new_set = {i for i in range(10)}
print(new_set) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
new_set = {i for i in range(10) if i == 6}
print(new_set) # {6}
注意：元组没有生成式，它是后面重点讲解的迭代器知识(生成器)
匿名函数
- 概念：匿名函数，也称为lambda函数，是没有定义名称的函数
- 语法结构：lambda 形参:返回值（lambda函数可以具有任意数量的参数，但只能有一个表达式，不用写return，返回值就是该表达式的结果。Lambda函数可在需要函数对象的任何地方使用）
- 注意：lambda 表达式创建的函数只能包含一条表达式
- 案例
(lambda x: x + 1)(123) # 直接调用
res = lambda x: x + 1 # 命名调用
print(res(123))
- 应用场景：通常都需要配合其他函数一起使用，用于减少代码
重要内置函数
max函数
- max()：最大值。如果值是字符串，则按字母顺序进行比较。如果值是字符串，则按字母顺序进行比较
# max函数与lambda函数（匿名函数）集合使用
dic = {
'jason': 100,
'aj': 123,
'Bason': 9999999,
'zero': 888
}
def index(k):
return dic.get(k)
# res = max(dic, key=lambda k: dic.get(k))
res = max(dic, key=index)
print(res) # Bason
min函数
- min()：最小值。如果值是字符串，则按字母顺序进行比较。如果值是字符串，则按字母顺序进行比较
# min函数与lambda函数（匿名函数）集合使用
dic = {
'jason': 100,
'aj': 123,
'Bason': 9999999,
'zero': 888
}
def index(k):
return dic.get(k)
# res = min(dic, key=lambda k: dic.get(k))
res = min(dic, key=index)
print(res) # jason
map函数
- map()：映射函数
# map函数与lambda函数（匿名函数）集合使用
l1 = [11, 22, 33, 44, 55, 66]
res = map(lambda x: x + 20, l1)
print(res) # <map object at 0x000001954B581100>
print(list(res)) # [31, 42, 53, 64, 75, 86]
filter函数
- 定义和用法：过滤器，用法和map类似
# filter函数与lambda函数（匿名函数）集合使用
l1 = ['jason', 'kevin', 'oscar', 'tony']
res = filter(lambda a: a != 'jason', l1)
print(res) # <filter object at 0x00000195F21E6C70>
print(list(res)) # ['kevin', 'oscar', 'tony']
reduce函数
- 定义和用法：会对参数序列中元素进行累积
# reduce函数与lambda函数（匿名函数）集合使用
l2 = [1, 2, 3]
from functools import reduce
res = reduce(lambda x, y: x + y, l2, 100)
res = reduce(lambda x, y: x + y, l2, 100)
print(res) # 106
zip函数
- 定义和用法：组合对象，将对象逐一配对
n1 = [1, 2, 3]
n2 = ['jason', 'kevin', 'oscar']
res = zip(n1, n2)
print(res) # <zip object at 0x000002A9E38C7F40>
print(list(res)) # [(1, 'jason'), (2, 'kevin'), (3, 'oscar')]
n1 = [1, 2, 3, 4]
n2 = [5, 6, 7, 8]
n3 = 'jack'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 'c'), (4, 8, 'k')]
n1 = [1, 2, 3, 4, 5, 6, 7]
n2 = [5, 6, 7, 8]
n3 = 'jason'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 's'), (4, 8, 'o')]
练习题
1.编写一个用户认证装饰器
基本要求
执行每个函数的时候必须先校验身份 eg: jason 123
拔高练习(有点难度)
执行被装饰的函数 只要有一次认证成功 那么后续的校验都通过
函数:register login transfer withdraw
提示:全局变量 记录当前用户是否认证
is_login = {'is_login': False, }
# 2.编写装饰器
def login_auth(func_name):
def inner(*args, **kwargs):
# 2.3判断全局字典is_login对应的值是否是True
if is_login.get('is_login'):
# 2.4直接执行被装饰函数即可
res = func_name(*args, **kwargs)
return res
# 2.1假设是第一次调用 肯定需要校验用户身份
username = input('username>>>:').strip()
password = input('password>>>:').strip()
if username == 'jason' and password == '123':
res = func_name(*args, **kwargs)
# 2.2保存用户登录的状态
is_login['is_login'] = True
return res
else:
print('权限不够 无法执行')
return inner
# 1.定义函数
@login_auth
def register():
print('注册功能')
@login_auth
def login():
print('登录功能')
@login_auth
def transfer():
print('转账功能')
@login_auth
def withdraw():
print('提现功能')
register()
login()
transfer()
withdraw()
2.尝试编写有参函数将多种用户验证方式整合到其中
直接获取用户数据比对
数据来源于列表
数据来源于文件
data_list = ['jason|123', 'kevin|321', 'oscar|222']
def login_auth(condition):
def outer(func_name):
def inner(*args, **kwargs):
username = input('username>>>:').strip()
password = input('password>>>:').strip()
if condition == 'absolute':
if username == 'jason' and password == '123':
res = func_name(*args, **kwargs)
return res
else:
print('你不是jason 不允许执行')
elif condition == 'list_type':
for user_data in data_list: # 'jason|123'
real_name, real_pwd = user_data.split('|')
if real_name == username and real_pwd == password:
res = func_name(*args, **kwargs)
return res
elif condition == 'file_type':
with open(r'userinfo.txt','r',encoding='utf8') as f:
for line in f:
real_name, real_pwd_n = line.split('|')
if real_name == username and password == real_pwd_n.strip('\n'):
res = func_name(*args, **kwargs)
return res
return inner
return outer
@login_auth('absolute')
def func1():
print('from func1')
return 1
@login_auth('list_type')
def func2():
print('from func2')
return 2
@login_auth('file_type')
def func3():
print('from func3')
return 3
func1()
func2()
func3()
3.尝试编写递归函数
推导指定某个人的正确年龄
eg: A B C D E 已知E是18 求A是多少
def get_age(n):
if n == 1:
return 18
return get_age(n-1) + 2
res = get_age(5)
print(res)
posted on
浙公网安备 33010602011771号