一、内置函数如何使用
help()一下：
如想看min()咋用？在shell中：help(min)
二、部分内置函数
（一）.排序：sorted()
li = [(1, 2, 3, 4), (7, 8, 1, 4), (3, 4, 6, 2), (6, 5, 9, 2)]
print(sorted(li, key=lambda a: a[1]))
# lambda a: a[1] 以元组的第二个值作为排序依据。
# 运行结果：[(1, 2, 3, 4), (3, 4, 6, 2), (6, 5, 9, 2), (7, 8, 1, 4)]
sorted()是python3的内置函数，返回一个新列表，不改变原来的数据，如要改变需赋值。
sort()是列表的函数：list.sort()，没有返回值，直接在原数据上进行修改。
（二）.枚举：enumerate()
enumerate 是个迭代器。
如要查看枚举中的内容，可用 list(enumerate[1,2,3]) 来查看。
print(list(enumerate([1, 2, 3])))
# 运行结果：[(0, 1), (1, 2), (2, 3)] # 可指定索引的开始值：
print(list(enumerate([1, 2, 3], 2)))
# 运行结果：[(2, 1), (3, 2), (4, 3)] # 转换为一个字典：（这里同样指定了索引的开始值）
print(dict(enumerate([1, 2, 3], 2)))
# 运行结果：{2: 1, 3: 2, 4: 3}
（三）.过滤器：filter(function or None,iterable)
字面意思理解一下，过滤、过滤，就是过滤掉自己不想要的那部分内容。
第一个参数需要放一个函数体，或者写"None"，因为是必备参数。
# 提取一个列表中，出大于2的元素
print(list(filter(lambda x: x > 2, [1, 2, 3, 4, 5])))
# 运行结果：[3, 4, 5]
把符合条件的都提取出来。但是，iterable对象中，如果有：空序列、False、0，也会被去除。
（四）.配对：zip(iterable1,iterable2,...)
# iterable 中的值 一一匹对 1 vs 1
print(list(zip([1, 2, 3], ["a", "b", "c"], [10, 20, 30])))
# 运行结果：[(1, 'a', 10), (2, 'b', 20), (3, 'c', 30)]
# 既然是一一对应，那么少了其中任何一个都不会再去匹对了 # 少了第二个 iterable 中的 "b"
print(list(zip([1, 2, 3], ["a", "c"], [10, 20, 30])))
# 运行结果：[(1, 'a', 10), (2, 'c', 20)] # 少了第一个 iterable 中的 2 和 第三个 iterable 中的 10
print(list(zip([1, 3], ["a", "b", "c"], [20, 30])))
# 运行结果：[(1, 'a', 20), (3, 'b', 30)]
# 同时遍历两个或更多的序列，可以使用 zip() 组合
questions = ["what's your name", "how old", "favorite color"]
answers = ["quanquan616", 30, "blue"]
for i, j in zip(questions, answers):
print("{}? {}".format(i, j)) """
运行结果：
what's your name? quanquan616
how old? 30
favorite color? blue
"""
(五).加工：map(func,*iterable)
func是指定一个函数体，指定以什么方式去加工。
*iterable "*"是什么？前面的内容有提到过，解包了。
print(list(map(str, [1, 2, 3])))
# 远行结果：['1', '2', '3']
此例中，str是指定了加工的方式。
list()是用来查看map()对象中的元素，tuple也可以。
三、作用域（全局、局部变量）
全局变量定义在函数体外，可以访问，但不可以修改。
（一）.global 用途：
(1)、如果要修改函数体外定义的全局变量，需要在对应变量名前加"global"关键字来修饰。（类似授权的概念）
(2)、函数体中的局部变量，如果要在函数体外访问到它，也需要在前加"global"
# --- global 第一种用法 --- #
n = 1 # 这里是全局变量
def fun():
n += 1
print(n)
fun()
# 运行直接报错！
# UnboundLocalError: local variable 'n' referenced before assignment
# 大意：n 是局部变量，未定义，无法使用
# 需要在 n 前加上 global n = 1
def fun():
global n
# 不能写成：global n += 1 会报语法错误！
n += 1
print(n)
fun() # 还有一种情况：
n = 1 # 这里是全局变量
def fun(a, b):
n = a + b # n 在这里是局部变量
print(n)
fun(10, 20)
print(n) # 运行结果：30 1
# --- global 第二种用法 --- #
def fun():
n = 616
fun()
print(n) # NameError: name 'n' is not defined // 语法错误 n 没有定义
# 在外要想访问函数体里的局部变量 n 就需要在前面加 global def fun():
# 如果 n 在 global 语句前定义，就会报错！
# SyntaxError: name 'n' is assigned to before global declaration
# 语法错误：n 在global声明前就分配了
global n
n = 616
fun()
print(n)
（二）.nonlocal：当里层局部，需要修改局部外层时，用 nonlocal 修饰。在嵌套函数中会用到。
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
# 不声明依旧是这个报错：UnboundLocalError: local variable 'num' referenced before assignment
num = 100
print(num)
inner() # 不调用是不会执行的 // 必须写在这里，不然未定义报错，因为函数必须先声明后使用
print(num)
outer() # 运行结果：100 100
（三）.总结
(1).外部不能访问函数内部的变量。
(2).函数内部能够访问函数外部的变量。
(3).函数里部不能修改函数外部的变量。
（四）.作用域链
从内向外，依次去寻找变量。
在函数定义的时候，作用域链其实就已经形成了。
四、回调函数
def test1():
print("") def fun2(a):
a()
print("") # 后面调用前面
fun2(test1) # 把函数体当作参数传过去
五、闭包
首先，闭包需要是嵌套函数。调用外层，返回里层的函数体。（外层函数返回里层函数）
通俗地讲：闭包是函数里面嵌套函数，外层函数返回里层函数，这种情况称之为闭包。
闭包能够维持住这个变量。JS中能体会到它的用途，但是JS和python的闭包是同一回的事儿。
简单来说，闭包有这么两个作用：
(1).构造局部的全局变量。
(2).在没有类的情况下，封装变量。
def fun1():
a = 1
print(a) def fun2(): # 封闭在函数里面
b = 2
print(b) return fun2 # 加了括号()是调用。不加括号"()"，返回函数体 print(fun1()) """
运行结果：
1
<function fun1.<locals>.fun2 at 0x0067D6F0>
"""
补充内容：闭包+回调函数+语法糖=装饰器
五、递归
递归的特点：
(1).自己调用自己。
(2).必须要有一个出口！
# 示例：5的阶乘
# 5! = 5*4*3*2*1
def jiec(n):
if n == 1:
return 1
# 如果把1写成0，结果就是0了。因为最后一个数乘以了0
else:
return jiec(n - 1) * n
print(jiec(5))
六、补充内容
可变的数据类型，可以在函数里面，直接进行修改：
li = [1, 2, 3]
tu = ("a", "b", "c") def test(li, tu):
# 元组不可变，所以tu不能直接修改
# 而li就可以在函数中直接修改
li.append("python") test(li, tu) print(li) # 原来的li被修改了
print(tu) """
远行结果：
[1, 2, 3, 'python']
('a', 'b', 'c')
"""
好处：在函数中修改了，无需重新赋值，就会改变。
坏处：当不想改变原数据时，显得略坑。需要提前copy()一份。
可变的对象都有copy()这个方法。
小练习：
(1).定义一个函数，输入一个序列(序列元素是同种类型)，判断序列是顺序还是逆序，顺序输出"UP"，逆序输出"DOWN"，乱序否则输出"None"
import re def is_up_down_none(list_value):
up = sorted(list_value) # 顺序排序
down = sorted(list_value, reverse=True) # 倒序排序
if list_value == up: # 原列表与up比较
print("顺序的，UP") # 一样的话肯定是顺序的
elif list_value == down: # 原列表与down比较
print("倒序的，DOWN") # 一样的话肯定是倒序的
else:
print("乱序的，None") while 1:
strings = input("请输入内容：")
list_value = list(re.findall("[a-zA-Z0-9]", strings)) # 用正则提取出每个元素，因为比较的是列表
is_up_down_none(list_value)
(2).写一个函数，对列表li = [9,8,3,2,6,4,5,7,1]，进行从小到大的排序。最后返回li
# 使用内置函数：sorted()
def sorting(li1):
return sorted(li1)
li1 = [9, 8, 3, 2, 6, 4, 5, 7, 1]
g = sorting(li1)
print(g)
# 使用冒泡排序法（我个人还是比较好理解这个方法）
def bubbling(li1):
for i in range(len(li1)): # list的下标是从0开始的，range()左闭右开，取不到最后一个数值，刚好不会造成列表index溢出
for j in range(i): # 只需比较8次就可以了，因为最后一次肯定是最小值在前面了
if li1[i] < li1[j]:
li1[i], li1[j] = li1[j], li1[i]
print(li1)
li1 = [9, 8, 3, 2, 6, 4, 5, 7, 1]
bubbling(li1)