名称空间作用域

名称空间的作用域

作用域
	名称空间所能够作用的范围
内置名称空间
	程序在任何阶段任何位置均可以使用(全局有效)
全局名称空间
	程序在任何阶段任何位置均可以使用(全局有效)
局部名称空间
	一般情况下只在各自的局部名称空间有效

global与nonlocal关键字使用

global  # 在局部名称空间内更改全局名称空间变量，使用关键字生命。在变量是不可变类型的情况下
nonlocal  # 在局部内部名称空间修改局部外部名称空间的值，使用关键字声明。在变量是不可变的情况下

函数对象(函数名)

函数名遇到括号就是被调用  # 重点记住
1.函数名做变量被变量名赋值，本质就是调用函数，运行函数体代码运行
	def index():
		print('from index')
	a = index
	print(a())
	from index
	None
2.函数名做函数的实参，被当成参数的实参后可以在函数体代码内部运行函数体代码
	def index():
		print('from index')
	def func(a):
		print(a)
		a()
		print('from func')
	func(index)
	<function index at 0x0000025C44691EA0>  # 打印的是函数体代码的内存地址
	from index  # 以实参的方式进入到func的函数体代码中后被执行
	from func  # index函数体代码运行结束回到func函数代码体，继续执行的打印
3.函数名做函数的返回值
	def index():
		print('from index')  # 2
	def func():
		print('from func')  # 1
		return index
	res = func()
	res()
	from func  
	from index
4.函数名做容器类型的元素
	def index():
		print('from index')  # 1
	l = [111, 222, 333, index()]  # 2
	print(l)
	from index
	[111, 222, 333, None]
								'''实例'''
def register():
    print('注册功能')
def login():
    print('登录功能')
def shopping():
    print('购物功能')
def transfer():
    print('转账功能')
def withdraw()
	print('提现功能')
def check_order():
    print('查看订单')
while True：
	func_dict = {'1':['用户注册'，register],
				'2':['用户登录'，login]
				'3':['用户购物'，shopping]
 				'4':['用户转账'，transfer]
 				'5':['用户提现'，withdraw]
				'6':['查看订单'，check_order]
				}
	for i in range(1,len(func_dict) + 1):
		print(i,func_dict(str(i))[0])
	choice = input('请输入编号,按0退出>>>:').strip()
	if choice == '0':
		print('再见！')
		breka
	while choice.isdigit and choice in func_dict:
		l1 = func_dict.get(choice)[1]()
	else:
		print('请输入正确编号')

函数的嵌套使用

嵌套使用：函数内部调用其他函数
def my_max(a, b):
	if a > b:
		return a
	return b

def many_max(x,y,z,m):
	res = my_max(x,y)
	res1 = my_max(res,z)
	res2 = my_max(res1,m)
	return res2
ret = many_max(1,2,3,4)
print(ret)7

函数的嵌套定义

定义 :函数体内部定义其他函数
	:将复杂的功能全部隐藏起来，暴露一个简单的借口
def all_func(type):
	def register():
		print('注册功能')
	def login():
		print('登录功能')
	def transfer():
		print('转账功能')
	def shopping():
		print('购物功能')
#最后调用  all_func(type)即可

闭包函数

闭:定义在函数内部的函数
包:内部函数使用了外部函数名称空间中的名字()
只有符合闭and包。才是'闭包函数'
def outer():
	x = 222
	def index():
		print('from index', x)
	return index
闭包函数也是另一种给参数传参的另一种方式
def outer(x,y):  # 调用之后传入参数
		# x = 2  # 这里可以不参加
		# y = 40  # 这里可以不添加
	def my_max():  # 函数体代码内部的函数
		if x > y:  # 内部函数进行判断，接受外层函数接受的参数
			return x  # 运行之后的返回值
		return y  # 返回值
		return my_max  # 返回值
res = outer(2,40)  # 传参虽然固定，但可以在任何地方print(res())
print(res())  # 调用
print(res())  # 调用

'''了解即可'''
import requests
url = 'https://www.baidu.com'
def outer(url):
	def get_content():
		# 爬取百度首页数据
		res = requests.get(url)
		if res.status_code == 200:
			with open(r'xxx.html','wb') as f:
				print('*'.center(30))
				f.write(res.content)
	return get_content

res = outer('https://www.baidu.com')
res()
res1 = outer('https://www.jd.com')
res1()

装饰器

1.装饰器:是由名称空间，函数对象，闭包函数组合的
	器:指的是工具
	装饰:给被装饰对象额外添加的功能

2.装饰器的原则
	开放封闭原则
		开放:对扩展开放
		封闭:对修改封闭
3.装饰器核心思想
	在不改变'装饰对象内部代码'和'原有调用方式'的基础上'添加新功能'
def index():
	print('from index')
index()

# 统计index函数的执行时间
import time
# print(time.time()) 
# 获取的结果叫时间戳(运行代码的那一刻距离1970-1-1所经历的秒数)
# time.sleep(3)  # 让程序原地等待3秒
def index():
	time.sleep(3)
	print('from index')
# 统计index函数的执行时间
# 在函数运行之前统计一次时间
start_time = time.time()
index()
# 在函数运行完毕之后再次统计
end_time = time.time()
# 计算差值
print(end_time - start_time)