python函数基础（2）-----内置函数、作用域、闭包、递归

python函数基础(2)

常见的内置函数:
查看内置函数：
print(dir(__builtins__))
常见函数
len 求长度
min 求最小值
max 求最大值
sorted  排序
reversed 反向
sum  求和

进制转换函数:
bin()  转换为二进制
oct()  转换为八进制
hex() 转换为十六进制
ord() 将字符转换成对应的ASCII码值
chr() 将ASCII码值转换成对应的字符
补充：
1.enumerate()   #返回一个可以枚举的对象
2.filter() #过滤器
3.map() #加工。对于参数iterable中的每个元素都应用fuction函数，并返回一个map对象
4.zip() #将对象逐一配对

变量的作用域与其定义的方式有关：
局部变量： 变量在函数内部定义，则变量的作用域在函数内部
全局变量：变量在函数外部定义的，则变量的作用域是全局

global：用来在函数或其他局部作用域中，声明全局变量。   (作用于全局)
nonlocal：用来在函数或其他作用域中，声明外层(非全局)变量。(作用于局部)

使用global情况：
全局变量可以在函数内部访问，但是不能改变
如果在函数内部想修改全局变量，可以用 global 来修饰变量

局部变量只能在局部进行访问和修改。
如果在函数外部，想访问局部变量，也可以用 global，将局部变量声明为全局变量

使用nonlocal的情况：
当里层局部，需要修改外层局部时，需要使用nonlocal。 (如嵌套函数)

总结：
global ：函数中，需要修改全局变量时，用global
nonlocal：当里层局部，需要修改外层局部时，需要使用nonlocal。
（局部调用局部，使用nonlocal）

内嵌函数： 在函数内部定义函数，就是函数里面嵌套函数

闭包：一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。(但是B函数，一定要是嵌套在函数A里面) 。你在调用函数A的时候传递的参数就是自由变量。

总结：一个函数里面嵌套一个函数，调用外面这个函数，就返回里面嵌套的函数。

递归： 函数调用自己本身
'''
例题：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。
问第4个人岁数，他说比第3个人大2岁。
问第三个人，又说比第2人大两岁。
问第2个人，说比第一个人大两岁。
最后问第一个人，他说是10岁。
请问第五个人多少岁？
'''
递归的核心：
1.递归推导式
2.递归终止条件

li = [1,2,3,4,5,6]
#查看内置函数：
print(dir(__builtins__))
##内置函数
print(len([1,2,3])) #求长度
print(min([1,2,3])) #求最小值
print(max([1,2,3])) #求最大值
print(sorted(li,key = int,reverse = True)) #排序
#reversed() 反转，逆序对象
print(sum([1,2,3],2))#从2开始加,即初始值为2
#进制转换函数:
print(bin(5))#转换为二进制
print(oct(16))#转换为八进制
print(hex(15))  #转化为16进制
print(ord('a'))#97 将字符转换成对应的ASCII码值
print(ord('A'))#65
print(chr(65))#'A'将ASCII码值转换成对应的字符

#补充
print(enumerate([1,2,3]))
print(list(enumerate([1,2,3])))#返回一个枚举对象（索引，值）索引可以自定义
print(dict(enumerate(['a','b','c'],2)))#{2: 'a', 3: 'b', 4: 'c'}

print(filter(None,[1,2,3]))#<filter object at 0x000001E052827FD0> #过滤器
print(list(filter(lambda x:x>1,[1,2,3])))
'''
给定一个过滤的函数当参数，过滤可迭代对象

'''
#加工。对于参数iterable中的每个元素都应用fuction函数，并返回一个map对象
print(list(map(lambda x:x+1,[1,2,3,4])))#[2, 3, 4, 5]
print(list(map(str,[1,2,3,4])))#['1', '2', '3', '4']

#配对
print(list(zip([1,2,3]))) #[(1,), (2,), (3,)]
print(list(zip([1,2,3],['a','b','c'])))#[(1, 'a'), (2, 'b'), (3, 'c')]
print(list(zip([1,2,3],['a','b','c'],(11,22,33))))

##函数内变量的作用域
x=1         #全局变量
def fun():
global y
y=2   #局部变量
global x
x+=1
print(x,y)
fun()
def fun1():
a=1
a+=1
print(a)
fun1()
##lianxi
a=10
def f1():
global a
a+=1
print(a)
f1()
def f2():
global a
a=1
print(a)
f2()
##nonlocal   当局部里层想修改局部外层时
def fun2():
q=1      #局部外层
print('局部外层',q)
def fun3():
w=22
nonlocal q
q+=1
print(q)
print('局部里层',w)
fun3()
fun2()
##闭包         嵌套函数
def fun4(a):
print(a)
def fun5(b):
print(a,b)
return fun5       #调用不执行
fun4(5)
fun4(5)(6)
##回调函数
def fun6():
print('第一个函数')
def fun7(a):    #把上一个函数体当成参数
a()
print('第二个函数')
fun7(fun6)
##递归   调用自己
def age(n):
if n==1:
return 18
else:
return age(n-1)+2
print('第五个人%d岁'%age(5))
#阶乘
# 5！=5*4*3*2*1
def jiec(n):
if n==1:
return 1
else:
return jiec(n-1)*n

print('5!:',jiec(5))

==============
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
3
1
3
[6, 5, 4, 3, 2, 1]
8
0b101
0o20
0xf
97
65
A
<enumerate object at 0x0000001B6AF236C0>
[(0, 1), (1, 2), (2, 3)]
{2: 'a', 3: 'b', 4: 'c'}
<filter object at 0x0000001B6AA61AC8>
[2, 3]
[2, 3, 4, 5]
['1', '2', '3', '4']
[(1,), (2,), (3,)]
[(1, 'a'), (2, 'b'), (3, 'c')]
[(1, 'a', 11), (2, 'b', 22), (3, 'c', 33)]
2 2
2
11
1
局部外层 1
2
局部里层 22
5
5
5 6
第一个函数
第二个函数
第五个人26岁
5!: 120

#1.定义一个函数，输入一个序列(序列元素是同种类型)，判断序列是顺序还是逆序，顺序输出UP，逆序输出DOWN，否则输出None
#解答：
print('#1.解答：')
li = [9,8,3,2,6,4,5,7,1]
li1 = [1,2,3,4,5,6]
li2 = [6,5,4,3,2,1]
li3 = 'z',5,4,'d',2,1
def judge(li):
try:
li = list(li)
if(sorted(li)==li):
print('顺序序列----->UP')
elif(sorted(li,reverse=True)==li):
print('逆序序列----->DOWN')
else:
print('None')
except Exception as e:
print('你输入为非序列，请输入一个序列')
judge(li)
judge(li1)
judge(li2)
judge(li3)
#2.写一个函数，对列表li = [9,8,3,2,6,4,5,7,1]，进行从小到大的排序。最后返回li
#解答：
#冒泡排序：
def bubbleSort(li):
lenght = len(li)
for i in range(0,lenght-1):
for j in range(0,lenght-i-1):
if li[j]>li[j+1]:
li[j],li[j+1] = li[j+1],li[j]
return li
#选择排序
def selectSort(li):
lenght = len(li)
for i in range(0,lenght-1):
for j in range(i+1,lenght-1):
if li[i]>li[j]:
li[i],li[j] = li[j],li[i]
return li
#插入排序
def insertSort(li):
lenght = len(li)
if lenght <2:
return li
for i in range(1,lenght):
tmp = li[i]
j = i-1
while j>=0 and tmp < li[j]:
li[j+1] = li[j]
j =j - 1
li[j+1] = tmp
return li
#快速排序
def quickSort(li):
lenght = len(li)
if lenght <2:
return li
min1 = []
max1 = []
mid = li.pop(0)
for i in li:
if i < mid:
min1.append(i)
else:
max1.append(i)
return quickSort(min1) + [mid] + quickSort(max1)
#..........
#函数调用：
print('#2.解答：')
print(bubbleSort(li))
print(selectSort(li))
print(insertSort(li))
print(quickSort(li))

=====
#1.解答：
None
顺序序列----->UP
逆序序列----->DOWN
你输入为非序列，请输入一个序列
#2.解答：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>