函数：
格式：
def 函数的名字():函数体例如：def playgame():print("I am playing!")函数调用：
playgame()调用的方法： 函数名()
函数的定义只是定义函数，调用了才会有结果
函数的参数
分类：1.形参：在函数定义的时候，需要准备一些变量来接收信息1.位置参数，按照位置一个一个声明变量2.默认值参数，在函数声明的时候给变量一个默认值，如果实参不传递信息，此时默认值生效，否则就不生效
def luru(name, age, gender="男"):print(name, age, gender)luru("张三", 18) # 张三 18 男
luru("李四", 18)
luru("王二麻子", 18)
luru("赵敏", 18, "女") # 赵敏 18 女
luru("周芷若", 18, "女")
luru("吴老二", 18)3.动态传参1. * 参数名（args） 表示接收所有的位置参数的动态传参，接收到的值被统一放在元组里2. ** 参数名（kwargs） 表示接收所有的关键字的动态传参，接收到的值统一放在字典里
def chi(*food): # * 表示位置参数的动态传参，*接收到的值会被统一放在一个元组里面print(food)chi('大米饭', "烧茄子", "紫菜蛋花汤") # ('大米饭', '烧茄子', '紫菜蛋花汤')
chi("大米饭") # ('大米饭',)# 关键字参数的动态接收
def chi(**food): # ** 表示接收关键字的动态传参，接收到的所有参数都会被处理成字典print(food)chi(zhu="小米饭", tang="胡辣汤", ) # {'zhu': '小米饭', 'tang': '胡辣汤'} 混合使用的顺序：位置参数 > *args > 默认值 > **kwargs上述参数可以随意搭配使用；位置参数 在 默认值参数之前2.实参：实际调用的时候传递信息1.位置参数，按照位置进行参数传递2.关键字参数，按照参数的名字进行传递参数
def chi(zhu, fu, tang, tian):print(zhu, fu, tang, tian)chi("大米饭", '西红柿炒鸡蛋', "紫菜蛋花汤", "哈根达斯") # 位置参数chi(zhu="小米饭", tang="胡辣汤", fu="西红柿炒鸡蛋", tian="老冰棍") # 关键字参数chi("小米饭","胡辣汤", tang="西红柿炒鸡蛋", tian="老冰棍") # 混合参数3.混合参数 (位置参数放前面，关键字参数放后面---> 否则报错)实参在执行的时候，必须保障形参有数据
open(xxxx,mode="xx",encoding="xxxx") # xxxx是文件名，这个就是混合参数* 在实参位置，是把列表打散成位置参数进行传递** 在实参位置，可以把字典自动转化成关键字参数进行传递
def func(*args):print(args)# list少量元素
func(stu_lst[0], stu_lst[1], stu_lst[2], stu_lst[3],) # ('流川枫', '樱木', '大老王', '隔壁二老王')# list 大量元素
func(*stu_lst) # * 在实参位置，是把列表打散成位置参数进行传递# ** 在实参位置，可以把字典自动转化成关键字参数进行传递
# ('流川枫', '樱木', '大老王', '隔壁二老王')
返回值
返回值：函数执行之后，会给调用方一个结果，这个结果就是返回值关于return： 函数只要执行到了return，函数就会立即停止并返回内容，函数内的return后续代码不会执行
def func(a, b):# print(a + b)return a + bret = func(10, 30)
print( ret * 3) # 90# 不写return
def func():passret = func()print(ret) # None# 写了return但没有返回值
def fun():print(1223)return # 不管return有没有返回值，只要读到return就会让程序停止，后续代码不会执行，有点像循环里的breakprint(234)ret = fun()
print(ret) # 1223 None1.如果函数里没有return，此时函数收到的是什么？ 默认收到的时None 2.如果写了return1.只写了return 后面不跟数据 （充当的break情况）2.return 值，此时表示函数有一个返回值，外界能收到一个数据 （用的最多）3.return 值1，值2，值3.... 此时函数有多个返回值，外界收到的是什么呢 外界收到的是元组，且该元组内存放所有返回值
内置函数（上）
内置函数： 直接拿来用的函数 例：print, input和数学运算相关数据类型： bool、 int、 float、 complex（复数）进制转换：bin（二进制）、oct（八进制）, int（十进制），hex（十六进制）数学运算：sum, min, max, pow(次方)
# 进制
a = 18
print(bin(a)) # 0b10010 二进制
print(oct(a)) # 0o22 八进制
print(hex(a)) # 0x12 十六进制b = 0b10011
print(int(b)) # 19 二进制转十进制# 数学运算
# pow
c = 10
d = 3
print(pow(c, d)) # 1000
print(c ** d) # 1000 表示的也是次方# max , min , sum
lst = [12, 32, 57, 789, 1000]
print(max(lst)) # 1000
print(min(lst)) # 12
print(sum(lst)) # 1890和数据结构相关列表和元组： list, tuple相关内置函数：slice(切片)字符串：str,format,bytes,ord(把文字转化成unicode编码中的码位), chr（把unicode编码的码位转化为文字）, repr相关内置函数：len, enumerate（能够直接拿到索引和元素）, all（当作and看）, any（当作or看）, zip, filter, map, sorted,
# 列表
s = {1, 3, 4}
lst = list("呵呵哒") # list 内部有个for循环
print(lst) # [1, 3, 4] ['呵', '呵', '哒']
# list的原理
for item in s:lst.append(item)
lst = list("呵呵哒")
print(lst) # ['呵', '呵', '哒']s = slice(1, 4, 3) # [1: 4:3] 从1切到4，每3个出来一个
print("呵呵呵呵呵呵"[s]) # 呵# format, ord, chr
# format 格式化
a = 18
print(format(a, "b")) # 二进制 10010print(format(a, "08b")) # 需要一个由0补充的8位的二进制 00010010 只能补齐，不能切割
c = 12000
print(format(c, "08b")) # 10111011100000print(format(a, "o")) # 八进制 22
print(format(a, "x")) # 十六进制 12# ord, chr
a = '中' # python的内存是unicode
print(ord(a)) # 20013 “中”在unicode中码位是20013
print(chr(20013)) # 中 给出编码位置，展示出文字# enumerate, all, any,
# all, any
print(all([12, "呵呵", "豆沙包"])) # 把all当作and来看 True
print(all([0, "呵呵", "豆沙包"])) # False，有一个空就是false
print(any([0, "呵呵", "豆沙包"])) # True 把any当作or来看
print(any([0, "", ""])) # False，全是空就是falselst = ["张无忌", "张翠山", "张三丰","张大大"]for item in enumerate(lst):print(item)
'''
(0, '张无忌')
(1, '张翠山')
(2, '张三丰')
(3, '张大大')
'''
for index,item in enumerate(lst):print(index,item)
# # 等价于下面
for i in range(len(lst)):print(i, lst[i])
'''
0 张无忌
1 张翠山
2 张三丰
3 张大大
'''
其他id (字符串的内存地址)help（） dir（） （告诉当前数据能执行的操作）print(dir(s))
python进阶
作用域
作用域：变量的访问权限全局变量：顶格写，全局作用域局部变量：内侧 ，局部作用域总结： 里面访问外面没问题，外面访问里面不能直接访问
def func():c = 199return c # 想要在函数外面访问到函数里面的东西，必须要return,必须！c1 = func() # 此时调用的func是c的值
print(c1) # 199函数的嵌套
结论（*）：1.函数可以作为返回值进行返回2.函数可以作为参数进行相互传递函数实际上就是一个变量名，都表示一个内存地址
def fun1():passdef fun2():fun1() # 这个叫函数的调用，不叫嵌套fun2()def func1():b = 20def func2(): # 函数的嵌套print(b)func2() # 20 局部的东西，一般都是在局部自己访问使用的# func1内部的func2函数访问了局部变量b，并且在调用func1()时输出了20。# 外部无法直接访问b和func2，因为它们是在func1内部定义的局部变量和函数。
func1() # 20 这算直接调用func1()
print(func1()) # None
# 输出 None 是因为函数 func1 没有明确地返回任何值。在 Python 中，如果函数没有显式使用 return 语句返回一个值，它将默认返回 None。
print(b) # 访问不了，外面没办法访问里面
print(func2) # 访问不了，外面没办法访问里面# 函数嵌套执行过程
def func1():print(123)def func2():print(234)def func3():print(345)print(1)func3()print(2)print(3)func2()print(4)func1()
"""
只有调用了才会执行
123
3
234
1
345
2
4"""def func():def inner():print(123)print(inner) # <function func.<locals>.inner at 0x000001C7CD54B520> 打印出来的是函数func的局部变量inner的地址return inner # 返回的是函数，如果返回inner()，返回的是None,把函数当成一个变量进行返回b1 = func() # b1是func的返回值，此时是b1内部的inner
print(b1) # <function func.<locals>.inner at 0x000001A8F892B520> 和inner一样
b1() # 123# 在外部调用局部变量
def an():print(123)an() # 123bn = an # 把an赋值给了bn
bn() # 123 此时的bn()就是an()# 函数就是一个变量！# 代理模式
def func(an):# print(an) # 传入func的变量，打印该变量本身an() # 传入func的函数，执行该函数
# 实参可以是函数
def target():print("我是target")c = 123
func(c) # 123 给func传变量c，调用func，输出123
func(target) # <function target at 0x000001FDC715B520> 给func（）传函数，调用func，返回的是传入函数的地址# 用的是 print(an)
func(target) # 我是target 说明实参可以是函数两个关键字global，nonlocal
global:在局部引入全局变量 nonlocal: 在局部，引入外层的局部变量
a = 10
def func():# 此时就想要在函数内部修改全局变量a，怎么办？global a # 把外面的全局变量引入到局部a = 20 # 创建一个局部变量，并没有改变全局变量中的afunc()
print(a) # 10 为什么还是10（按理说应该是20）？ 只写了a = 20不行# 有了global a ，a的结果变成20 20def func():a = 10def func2():nonlocal a # 向外找一层，看有没有该变量，如果有就引入，如果没有，继续向外扩一层，直到全局（不包括）a = 20func2()print(a)func() # 10# 20 （nonlocal a）闭包
闭包：本质：内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数1. 可以让一个变量常驻于内存2. 避免全局变量被修改
def func():a = 10 # 把成员变量变成局部变量，将其保护起来def inner():nonlocal aa += 1return areturn inner # 此时inner构成闭包函数ret = func() # inner ==> ret ==> 什么时候执行r1 = ret()
print(r1) # 11r2 = ret()
print(r2) # 12装饰器
函数回顾：
1. 函数可以作为参数进行传递 2. 函数可以作为返回值进行返回 3. 函数名称可以当成变量一样进行赋值
# 1.函数可以作为参数传递
def func():print("我是函数")def gggg(fn):fn()gggg(func) # 我是函数# 2.函数可以作为返回值进行返回
def func():def inner():print("123")return innerret = func()
ret() # 123# 3.函数名称可以当成变量一样进行赋值
def func1():print("我是函数1")def func2():print("我是函数2")
func1 = func2
func1() # 我是函数2装饰器： --> 要求记住最后的结论装饰器本质上是一个闭包作用：在不改变原有函数调用的情况下，给函数增加新功能直白：可以在函数前后添加新功能，但不改原代码应用： 在用户登录的地方，日志，通用装饰器写法：def wrapper(fn): wrapper: 装饰器，fn：目标函数def inner(* args, **kwargs):# 在目标函数执行之前ret = fn(* args, **kwargs) # 执行目标函数# 在目标函数执行之后return retreturn inner # 千万不能加小括号@wrapperdef target():passtarget() # ==> inner()一个函数可以被多个装饰器装饰@wrapper1@wrapper2def target():print('我是目标')target()作用顺序： wrapper1 wrapper2 target wrapper2 wrapper1
def wrapper1(fn): # fn: wrapper2.innerdef inner(*args, **kwargs):print("这里是wrapper1,进") # 1ret = fn(*args,**kwargs) # 调用 fn : wrapper2.innerprint("这里是wrapper1,出") # 4return retreturn innerdef wrapper2(fn): # fn ： targetdef inner(*args, **kwargs):print("这里是wrapper2,进") # 2ret = fn(*args,**kwargs) # targetprint("这里是wrapper2,出") # 4return retreturn inner@wrapper1 # target = wrapper1(wrapper2.inner) ==> target:wrapper1.inner
@wrapper2 # target = wrapper2(target) 此时的target是wrapper2的inner
def target():print('我是目标')target()wrapper1 wrapper2 target wrapper2 wrapper1
"""
这里是wrapper1,进
这里是wrapper2,进
我是目标
这里是wrapper2,出
这里是wrapper1,出
"""
：一个请求的执行流程（附Tomcat整体总结）)
.test(value)无效)
