目录
一.命名空间和访问命名空间中的内容：
1.命名空间：
局部命名空间：记录的是参数以及在函数体中声名的变量。
全局命名空间：记录的是整个py文件中的变量和函数。
内置命名空间：任何模任何模块均可访问它，它存放着内置的函数和异常
注意：函数名本质就是内存地址（id）来调用方法
2.访问命名空间的内容：
使用locals()内置函数查看局部命名空间的内容
使用globals()内置函数来查看全局命名空间的内容
注意：如果locals()没有放在函数体中，而是放在全局命名空间中，作用和globals()一样。
c = 30
def func():
a = 10
b = 20
print(locals()) # 访问局部命名空间
func()
print(globals()) # 访问全局命名空间
print(locals()) # 放在函数体外和globs()作用一样。
输出结果：
二.命名空间的加载和查找顺序 ：
1.加载顺序：
内置命名空间(程序运行前加载)----->全局命名空间(程序运行中：从上到下加载)----->局部命名空间(程序运行中：调用时才加载)当函数返回结果 或 抛出异常时，被删除。每一个递归调用的函数都拥有自己的命名空间。
2.查找顺序：
当使用某个变量的时候，先从局部命名空间中找，如果能找到则停止搜索，如果找不到在去全局命名空间中查找，如果找到则停止搜索，如果找不到则到内置名称空间中查找，如果找不到则报错。
注意：自己的变量名不要和内置的变量名相同，否则无法使用内置函数的功能
例如：
输出结果：
报错
三.作用域：
1.定义：变量的可用范围。
2.根据变量位置不同可分为4类：
局部作用域----->函数体中声明的变量。
嵌套作用域----->嵌套函数中外城函数体声明的变量
全局作用域----->py文件中声明的变量
内置作用域----->python提供的变量（函数）
a = 20 # 声明了全局作用域，一次可以在全局使用
def func():
b = 10 # 声明了局部作用域，只能在局部使用
print(b)
print(a)
func()
print(a)
# print(b) 报错，因为b变量出了自己作用域的范围。
输出结果：10
20
20
输出结果：10
20
30
四.global和nonlocal关键字：
1.global:
global关键字可以将局部变量变成一个全局变量。
a = 10
print(id(a))
def func():
global a # 变成全局变量
print(a)
print(id(a))
a = 20 # 修改全局变量的值
print(a)
print(id(a))
func()
print(a)
输出结果：
2.nonlocals:
nonlocal关键字可以修改外层(非全局)变量。
def outter():
name = 'zs'
def inner():
nonlocal name # 和outter中的那么是同一个变量
name = '赵四'
print(name)
print(id(name))
inner()
print(name)
print(id(name))
outter()输出结果：
五.递归函数：
1.定义：如果一个函数在内部调用自身本身，这个函数就是递归函数。
在使用递归时，需要注意以下几点：
l(1).自己调用自己。
l(2).必须有一个明确的递归结束条件，称为递归出口。
2.练习：
# 让控制台输出3，2，1：
输出结果：3
2
1
# 计算1到10的乘阶：例如 1*2*3*4*5...*10。
def digui(n):
if n == 1: # 判断条件，递归的出口。
return 1
ret = digui(n - 1) # 自己调用自己
return n * ret
num = digui(10)
print(num)
输出结果：3628800
# 查找数字：通过程序查找输入的number值。
提示：二分查找法：
def search_num(number, start, end):
if number == start:
return start
else:
middle = (start + end) // 2 # 获取中间值
if middle >= number:
return search_num(number, start, middle)
else:
return search_num(number, middle, end)
ret = search_num(4, 2, 8)
print(ret)
六.内置函数:
abs() 函数 max() 函数、map() 函数、filter() 函数，zip() 函数
1.abs()函数：求数字的绝对值
a = -10
print(abs(a))
输出结果：10
2.max():
max(iterable, key, default) 求迭代器的最大值，
其中iterable 为迭代器，max会for i in … 遍历一遍这个迭代器，
然后将迭代器的每一个返回值当做参数传给key=func 中的func(一般用lambda表达式定义) ，然后将func的执行结果传给key，然后以key为标准进行大小的判断。
练习：
# 根据name和price 返回最大的信息
lst = [{'name': 'egon', 'price': 100},
{'name': 'rdw', 'price': 666},
{'name': 'zat', 'price': 1}]
lst = [
{'name': 'egon', 'price': 100},
{'name': 'rdw', 'price': 666},
{'name': 'zat', 'price': 1}]
# name返回的最大值
def max_name(dic):
return dic['name'] # 返回字典对应的值
ret = max(lst,key=max_name) # 指定比较内容
print(ret)
# price 返回的最大值：
def max_price(dic):
return dic['price']
ret = max(lst,key=max_price)
print(ret)输出结果：{'name': 'zat', 'price': 1}
{'name': 'rdw', 'price': 666}
3.map():
有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容。
函数会依次作用在可迭代内容的每一个元素上进行计算，然后返回一个新的可迭代内容。
练习：求lst = [1,2,3]中每一个元素平方的值
lst = [1, 2, 3]
def square(num):
num1 = num * num
return num1
ret = map(square, lst) # 迭代器
for i in ret: # 迭代器需要for循环遍历取值
print(i)
4.filter():
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
练习：
过滤出列表所有的奇数：
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def ood_num(num):
if num % 2 == 1: # 判断是否是奇数
return num
ret = filter(ood_num, lst)
print(list(ret)) # 将迭代器强制转化成列表
输出结果：[ 1,3,5,7,9 ]
5.zip()
zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,
然后返回一个可迭代的zip对象.这个可迭代对象可以使用循环的方式列出其元素
若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相同。
a = [1, 2, 3]
b = ['a', 'b', 'c']
ret = zip(a, b)
for i in ret:
print(i)
----------------------------------------------------------------------------------
tu1 = (('a'), ('b'))
tu2 = (('c'), ('d'), ('e'))
ret = zip(tu1, tu2)
for i in ret:
print(i)
输出结果：
(1, 'a')
(2, 'b')
(3, 'c')
('a', 'c')
('b', 'd')