函数的返回值
现在有一个需求，比较两个人的月薪，然后想获取月薪较大人的年薪。
如果需要在程序中拿到函数的处理结果做进一步的处理，则需要函数必须要有返回值。
需要注意的是：
- return是一个函数结束的标志，函数内可以有多个return，只要执行到return，函数就会执行。
- return的返回值可以返回任意数据类型
- return的返回值无个数限制，即可以使用逗号隔开返回多个值
- 0个：返回None
- 1个：返回值是该值本身
- 多个：返回值是元组
#返回单个值
def max_self(salary_x, salary_y):
if salary_x > salary_y:
return salary_x
else:
return salary_y
max_salary = max_self(20000, 30000)
print(max_salary*12)
##360000
#返回多个值
def fun():
name = 'nick'
age = 19
hobby_list = ['read', 'run']
return name, age, hobby_list
name, age, hobby_list = func()#解压缩
print(f"name,age,hobby_list: {name, age, hobby_list}")
##name,age,hobby_list:{'nick', 19, ['read', 'run']}
函数的调用
#函数调用的三种方式
def max_self(x, y):
if x>y:
return x
else:
return y
# 1.
max_self(1, 2)
# 2.
res = max_self(1, 2)*12
# 3.
max_self(max_self(20000, 30000),40000)
函数的参数
#形参,本质是变量名
def func(x, y):
print(x)
print(y)
##位置形参
def func(x, y):
print(x)
print(y)
##默认形参
def fun(x, y=10):
print(x)
print(y)
func(2)
'''
注意：
1.位置形参必须放在默认形参的左边
2.默认形参的值只在定义阶段赋值一次，也就是说默认参数的值在函数定义阶段就已经固定了
'''
#实参，本质是变量的值
func(1, 2)
#位置实参，函数调用阶段，按照从左到右的顺序依次定义的实参。
func(1, 2)
#关键值实参,调用函数时，按照key=value的形式指定的参数传值
func(y=2, x=1)
'''
注意：
1.可以混用位置实参和关键字实参，但是位置实参必须在关键字实参的左边
2.可以混用位置实参和关键字实参，但不能对同一个形参重复赋值
func(x, y=2)
func(y=2, x) # SyntaxError：positional argument follows keyword argument
func(x, x=1) # NameError: name 'x' is not defined
'''
'''
可变长参数
#可变长参数之*
## 形参(会把溢出的位置实参全部接收，然后存成元组形式，然后把元组赋值给*后的参数)
def sun_self(*args)：
res = 0
for num in args:
res += args:
return res
res = sun_self(1, 2, 3, 4)
print(res)
### 10
## 实参(会把*后参数的值循环取出，打散成位置实参，遇到了就想到去打散)
def func(x, y, z, *args):
print(x, y, z, args)
func(1, *(1, 2), 3, 4):
### 1 1 2 (3, 4)
#可变长参数之**
## 形参(**会把溢出的关键字实参全部接收，存储成字典的形似，然后把字典赋值给*后的参数)
def func(**kwargs):
print(kwargs)
func(a=5)
### {'a', 5}
## 实参(**会将**后的参数的值循环取出，打散成关键字实参，遇到了就想到去打散)
def func(x, y, z, **kwargs):
print(x, y, z, kwargs)
func(1, 3, 4, **{'a': 1, 'b': 2})
### 1 3 4 {'a': 1, 'b': 2}
函数对象
'''
函数是第一类对象，即函数可以被当作数据处理
'''
def func():
print('from func')
print(func)
###<function func at 0x10af72f28>
#函数对象的四大功能
##1.引用
x = 'hello nick'
y = x
f = func
print(f)
###<function func at 0x10af72f28>
##2.当做参数传给一个函数
len(x)
def foo(m):
m()
foo(func)
### from func
##3.可以当做函数的返回值
def foo(x):
return x
res = foo(func)
print(res)
res()
###<function func at 0x10af72f28>
###from func
##4.可以当做容器类的元素
i = [x]
function_list = [func]
function_list[0]()
###from func
名称空间和作用域
"""
1.内置名称空间
存放Python解释器自带的名字，如int、float、len
在解释器启动时生效，在解释器关闭时失效
"""
'''
2.局部名称空间
用于存放函数调用期间函数体产生的名字,如f2
在文件执行时函数调用期间时生效，在函数执行结束后失效
'''
def f1():
def f2():
print('from f2')
f2()
f1()
'''
2.全局名称空间
除了内置和局部的名字之外，其余都存放在全局名称空间，如x, func, 1, z
'''
x = 1
def func():
pass
l = [1, 2]
if 3 > 2:
if 4 > 3:
z = 3
#加载顺序
##内置---》全局---》局部
#查找顺序
##当前位置--->局部---》全局---》内置
x = 1
def func():
print(x)
x = 10
func()
#10
##作用域
###全局作用域
x = 1
def bar():
print(x)
bar() #1
###局部作用域
def f1():
def f2():
def f3():
print(x)
x = 2
f3()
f2()
f1() #2
'''
作用域注意点
x = 1
def f1(): #定义阶段 x = 1
print(x)
def f2():
x = 2
f1()
f2() #1
'''
#作用域的应用
def f1():
def inner():
print('from inner')
return inner
f = f1() #把局部定义的函数放在全局之中
def bar():
f()
bar()
# from inner
## global关键字
x = 1
def f1():
x = 2
def f2():
# global x # 修改全局
x = 3
f2()
f1()
print(x) # 1
x = 1
def f1():
x = 2
def f2():
global x
x = 3
f2()
f1()
print(x)n # 3(global把x声明为全局变量之后，x指向3这个变量值，所以打印的是3)
##nonlocal
x = 1
def f1():
x = 2
def f2():
x = 3
f2()
print(x)
f1() # 2
x = 1
def f1():
x = 2
def f2():
nolocal x #针对嵌套函数局部之间的修改
x = 3
f2()
print(x)
f1() # 3
'''
注意点：
1.在局部想要修改全局的可变类型，不需要任何声明，可以直接修改。
2.在局部如果想要修改全局的不可变类型，需要借助global声明，声明为全局的变量，即可直接修改
'''
lis = []
def f1():
lis.append(1)
print(f"调用函数前：{lis}")
f1()
print(f"调用函数后：{lis}")
'''
调用函数前：[]
调用函数后：[1]
'''
闭包函数和装饰器
#闭包函数
def outter(x):
x = 1
def inner():
print(x)
return inner
f = outter(1)
f()
f()
f()
# 1
# 1
# 1
#闭包函数的应用
import requests
def outter(url):
def get():
response = requests.get(url)
print(response.text)
return get
baidu_spider = outter('https://www.baidu.com')
baidu_spider() #直接爬取百度网页
#装饰器
# 直接在模板里面加入登录功能
def deco(func):
def wrapper(*args, **kwargs):
#登录功能
inp_username = input('请输入用户名：')
inp_password = input("请输入密码：")
if inp_username == 'nick' and inp_password == '123':
print("登录成功")
else:
print("登录失败")
res = func(*args, **kwargs)
return res
return wrapper
@deco
def shopping():
print("欢迎来到购物模块")
shopping()
'''
#装饰器模板
def deco(func):
def wrapper(*args, **kwargs):
res = func(*args, **kwargs)
return res
return wrapper
'''
迭代器
#可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象。
'''
特点：
1.内置有__iter__方法的都叫可迭代的对象
'''
'''
迭代器对象：执行可迭代对象的__iter__方法，拿到的返回值就是迭代器对象。
特点：
内置__next__方法，执行该方法会拿到迭代器对象中的一个值
内置有__iter__方法，执行该方法会拿到迭代器本身
文件本身就是迭代器对象。
缺点：
取值麻烦，只能一个一个取，并且只能往后取，值取了就没了
无法使用len()方法获取长度
'''
#for循环：称为迭代器循环，in后必须是可迭代对象
'''
因为迭代器使用__iter__后还是迭代器本身，因此for循环不用考虑in后的对象是可迭代对象还是迭代器对象。
由于对可迭代对象使用__iter__方法后变成一个迭代器对象，这个迭代器对象只是占用了一小块内存空间，他只有使用__next__后才会吐出一个一个值。如lis = [1,2,3,4,5,...]相当于一个一个鸡蛋，而lis = [1,2,3,4,5,...].__iter__相当于一只老母鸡，如果你需要蛋，只需要__next__即可
'''