函数：
格式：
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 + b
ret = func(10, 30)
print( ret * 3) # 90
# 不写return
def func():
pass
ret = func()
print(ret) # None
# 写了return但没有返回值
def fun():
print(1223)
return # 不管return有没有返回值，只要读到return就会让程序停止，后续代码不会执行，有点像循环里的break
print(234)
ret = fun()
print(ret) # 1223 None
1.如果函数里没有return，此时函数收到的是什么？ 默认收到的时None
2.如果写了return
1.只写了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")) # 二进制 10010
print(format(a, "08b")) # 需要一个由0补充的8位的二进制 00010010 只能补齐，不能切割
c = 12000
print(format(c, "08b")) # 10111011100000
print(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，全是空就是false
lst = ["张无忌", "张翠山", "张三丰","张大大"]
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 = 199
return c # 想要在函数外面访问到函数里面的东西，必须要return,必须！
c1 = func() # 此时调用的func是c的值
print(c1) # 199函数的嵌套
结论（*）：
1.函数可以作为返回值进行返回
2.函数可以作为参数进行相互传递
函数实际上就是一个变量名，都表示一个内存地址
def fun1():
pass
def fun2():
fun1() # 这个叫函数的调用，不叫嵌套
fun2()
def func1():
b = 20
def 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() # 123
bn = 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 # 创建一个局部变量，并没有改变全局变量中的a
func()
print(a) # 10 为什么还是10（按理说应该是20）？ 只写了a = 20不行
# 有了global a ，a的结果变成20 20
def func():
a = 10
def func2():
nonlocal a # 向外找一层，看有没有该变量，如果有就引入，如果没有，继续向外扩一层，直到全局（不包括）
a = 20
func2()
print(a)
func() # 10
# 20 （nonlocal a）