1.函数的基本操作
函数：表示的生活中的一种行为
行为操作：操作过程中可能需要消耗资源，可能需要汇报结果
行为：每个人都具备一种行为，但是行为只有在调用的时候才会执行
吃早餐[每个人都具备的行为，不是每时每刻都执行]：早上调用的时候才会执行
函数的定义
def 函数名称(参数列表): 参数列表：表示可以接受0~n个参数
函数中要执行的代码
[return 返回结果] 可以有返回结果/没有返回结果
声明 定义 函数：并不会执行函数中的代码
声明定义函数的意义：让我们的代码中具备了一个功能！
函数的意义：提前在项目中准备好需要的各种功能，方便在使用的时候直接执行，而不是从头开发
def eat():
print("模拟执行函数中的代码...")
print("函数中的代码在执行")
print("函数中的代码在执行")
print("函数中的代码在执行")
print("函数中的代码在执行")
# 执行函数：调用执行：通过函数的名称，直接执行函数中的代码
eat()
函数的命名规范：
和变量的命名规范一致
见名知意：
基本要做到的是~单词全拼，不要担心函数/变量名称太长
命名规则：
字母、数字、下划线组成，数字不能开头
项目规范：
《下划线分隔命名法》、驼峰命名法
2.函数的参数：
参数：其实就是一种变量
是一种特殊的变量：专门给函数接受数据使用的
生活场景：函数->行为
参数->行为需要的资源
案例：
代码：函数-> 展示用户信息(用户)
生活：创业-> 需要什么数据(钱)
def show_info(name): # name变量：名义上函数执行需要一个数据name：形式参数：形参
'''
展示用户信息
:return:
'''
print("用户姓名：%s" % name)
# 调用执行了函数：但是没有提供数据
show_info("李易峰")# 调用执行函数，传递了一个具体的实际的数据：实际参数：实参
# 多个参数的操作
def show_msg(name, msg):
# 留言的函数
print("%s给您留言了：%s" % (name, msg))
show_msg('tom', '我在未来等你...')
3.函数的返回值
程序
函数：返回值：返回的(运算)结果
返回值操作：return关键字
函数中的代码在执行时，如果一旦执行了return所在的代码，函数直接结束！
生活：
行为：汇报结果：生活中一个任务的最终信息
def check_phone():
# 检查手机
print("检查过程.....")
name = "宋艳华"
# 返回结果
return name
# 带有返回值的函数，调用的时候~我们需要自己定义一个变量存储返回结果！
check_phone()# 如果不接收函数的返回结果：结果会直接丢失
n = check_phone()
print("下午节目表演人：%s" % n)
# 规则：如果执行完有返回值的函数
# 1. 函数之后的代码中不需要这个返回结果进行运算：可以选择不接受返回值！
# 2. 函数之后的代码中需要这个数据，必须接受返回结果！
# 疑问：如果你不需要函数的返回值参与运算，你还给函数定义返回值干什么？
# 答案：函数不是你一个人在调用！
# 扩展：因为python中的变量可以交叉赋值：a, b = 值1, 值2
# 所以：函数中的返回值~可以返回多个数据；按照顺序进行接受
# python特有的！
def rest():
print("课件休息十分钟")
t = "十分钟"
c = "喝水"
return t, c
x, y = rest() # x, y = t, c
print("休息时间：%s, %s" % (x, y))
4.全局变量
变量：临时存储数据的容器：工具！
生活：私有的工具；公有的工具；
变量：
- 所有人都可以使用的：全局变量
- 只有当前函数可以使用的变量：局部变量
声明了一个全局变量
声明在函数外部的变量：全局变量
从声明的地方开始~当前文件中所有位置都能使用这个变量
jobs = "爬虫开发工程师"
def eat():
food = "大烩菜"
print("局部变量：", food)
print("全局变量：", jobs)
# 执行函数中的代码
eat()
# 打印数据
print("全局变量：", jobs)
print("局部变量：", food）
# unresolved reference 'food'不能解析(解释)引用的这个变量：food
# NameError: name 'food' is not defined 变量food没有定义！
#########################################
# 变量：全局变量 & 局部变量
# 全局变量：声明在函数外部，当前文件中~从声明开始的所有地方都可以访问的变量
# 局部变量：声明在函数内部，只有当前函数中可以访问的变量；出了函数~谁都解析不了
#########################################
5.如何使用全局变量
如果函数中要使用全局变量：应该怎么做？
如果函数中只是查询使用全局变量的值：直接使用
如果函数中要修改全局变量的值：global 变量名称
函数中 global的意义：
1. global 变量名称：表示在函数中要使用指定名称的全局变量
2. global 变量名称：表示在函数中声明一个全局变量
name = "jerry"
print("函数外部查询变量：", name)
def test():
global name # 声明在函数中要使用全局变量 name
global msg # 在函数中声明定义了一个全局变量 msg
print("函数内部查询变量：", name) # jerry
print("函数内部操作变量")
age = 18
print("函数中的局部变量：", age)
name = "tom"
msg = "hello 函数中的全局变量"
# UnboundLocalError: local variable 'name' referenced before assignment
# 一个没有绑定的局部变量错误：一个局部变量name必须先声明再修改！
# 函数中如果定义了和全局变量名称一直的变量~默认函数中的变量是重名的局部变量
test()
print("这里再次打印全局变量：", name) # tom
print(msg)
6.全局变量 局部变量 重名
# 声明了一个全局变量
name = "jerry"
def test():
#print(name) # 这里是出错的位置：
'''
原因：在函数中给变量name进行了赋值，但是没有使用global关键字引入全局变量
所以name变成了函数中的局部变量
变量必须先声明定义，再使用变量的数据；第10行代码未声明先使用所以出现了错误！
:return:
'''
name = "tom" # 如果在函数中，给一个和全局变量相同名称的变量赋值：这个变量就会立刻被解释成局部变量
print(name) # 如果[全局变量|局部变量]重名；函数中优先操作局部变量；不会影响全局变量的数据
print("全局变量：", name)
test()
print("全局变量：", name)
# # #
# 重要：在项目开发过程中，除了公共数据
# 其他的变量，尽量使用局部变量，避免使用全局变量
7.函数操作
'''
函数中的参数处理：
参数的操作在python中被强化了
参数的功能非常强大
'''
# 1 位置参数
def test1(p1, p2, p3):
print(p1, p2, p3)
# 调用执行时，传递的实际参数按照位置顺序给形式参数进行赋值
test1(10, 20, 30)
# 2 默认值参数：定义函数的参数时，可以给参数赋值
# 如果函数参数中出现了默认值参数~一般默认值参数放在普通参数的后面
def test2(n1, n2, opra="+"):
#def test(n1, opra="+", n2):
print("计算n1:[%s]和n2[%s]进行opra[%s]运算" % (n1, n2, opra))
# 默认值参数~如果实际参数传递了实际数据，就使用传递的数据；
# 如果默认值参数~没有传递实参，直接使用默认数据进行运算
test2(10, 20)
test2(10, 20, "/")
# 3. 实参关键字参数[可选]：主要目的是为了提高代码的可读性
def test3(p1, p2, p3):
print(p1, p2, p3)
# 实参关键字参数，调用时可以根据参数名称进行赋值[打破位置参数要求的顺序]
test3(10, 20, 30)# 按照默认的位置顺序赋值
test3(p2=20, p1=10, p3=30)# 按照形参名称赋值[可以打乱位置顺序]
# 4. 实参强制关键字参数：提高代码的可读性
def test4(*, p1, p2, p3):
print(p1, p2, p3)
# 实参传递数据时，形式参数中符号* 后面的所有参数~都要使用k=v的关键字参数方式传递数据
test4(p1=10, p2=20, p3=30)
8.可变参数操作
'''
# 函数参数操作进阶：
1. 可变参数
2. 关键字参数
3. 函数类型描述符
'''
# 1. 可变参数：函数在执行过程中，可以接受0~N个参数
def test(*args): # args: arguments 参数
print("可变参数，在普通参数前面添加一个符号*")
print("test()函数就可以接受0~n个参数进行操作")
print(args)
for x in args:
print(x)
print("**********************")
test()
test("hello")
test("hello", "jerry")
test(1, 3, 5)
test(1, 1, 2, 3, 5, 8, 13, 21)
# 2. 可变关键字参数
def test2(**kwargs): # keyword arguments=>kwargs
print("可变关键字参数，就是在普通参数的前面添加符号**")
print("可变关键字参数，可以接受多个k=v的参数数据")
print("并且可以接受0~n个k=v的数据")
print("并且将数据包含在字典中")
print(kwargs, kwargs.get('name'))
test2(name="tom")
test2(name="shuke", age=62)
test2(name="jerry", age=18, gender="男")
# 3. 函数的参数：万能形参
def test3(*args, **kwargs):
print(args, kwargs)
# 号称可以接受任何参数：满足规范的情况下
test3()
test3("hello")
test3("hello", name="jerry")
test3("hello", "world", name="tom")
test3(name="tom")
#test3(name="tom", "hello")
9.解包
'''
解包：讲组合数据类型拆分
'''
def test(p1, p2):
print(p1, p2)
# 正常调用
test(10, 20)
# 非正常调用：列表解包
nums = [10, 20]
# 列表参数前面添加一个*符号，表示将列表拆分成一个一个独立的数据传递
test(*nums) # test(*nums) -> test(10, 20)
# 非正常调用：字典解包
nums2 = {"p1": 100, "p2": 200}
test(**nums2) # test(**nums2)-> test(p1=100, p2=200)
10.函数的相互调用
'''
函数表示的是一种行为
在一个行为执行过程中，可能调用另一个行为去执行
看电影(行为) 吃零食[行为]
一个行为中，可以执行另一个行为的
代码
一个函数中，可以调用执行另一个函数的
'''
# 1。 两个行为是互相独立
# def movie():
# print("看电影")
#
#
# def eat():
# print("吃零食")
#
#
# # 两个函数单独执行
# movie()
# eat()
# 2. 函数中调用执行另一个函数
# def movie():
# print("看电影")
# eat()
#
#
# def eat():
# print("吃零食")
#
#
# movie()
# 3. 函数中调用执行自己:函数自己调用自己：递归调用
def login():
name = input("请输入账号：")
if name == "admin":
print("账号输入正确")
return name
login()
login()
