1.常见的内置函数：
查看内置函数print(dir(__builtins__))
常见函数：
len 求长度
min求最小值
max求最大值
sorted 排序
reversed反向
sum求和
type 对象类型
print输出打印
help 查看相关方法属性
range创建一个整数列表，一般用在 for 循环中
id查看对象内存
hash哈希
查看内置函数
li=dir(builtins)
li.index('abs')=>81
len(li[81:])
绝对值：abs(-3)=>-3
求和：sum([1,3]) =>4
返回浮点数x的四舍五入值：round(1.4) =>1，round(12.175,2)=>12.18
其他内置参数，请查看相关资料.
enumerate()内置函数，返回一个枚举的对象；
对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
enumerate(['a','b','c']) =>> <enumerate object at 0x031DF148>
list(enumerate(['a','b','c'])) =>> [(0, 'a'), (1, 'b'), (2, 'c')]
list(enumerate(['a','b','c'],2)) #2：就是从索引2开始
=>> [(2, 'a'), (3, 'b'), (4, 'c')]
无序的集合，字典 返回一个伪索引
list(enumerate((1,2,3,4))) #[(0, 1), (1, 2), (2, 3), (3, 4)]
list(enumerate({'a':1,'b':2})) #[(0, 'a'), (1, 'b')] 获取键key
如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：
lis = ['我','是','新手']
for i in range(len(lis)):
print(i,lis[i])
=>>
0 我
1 是
2 新手
上述方法有些累赘，利用enumerate()会更加直接和优美
lis2 = ['我','是','新手']
for index,value in enumerate(lis2):
print(index,value)
=>>
0 我
1 是
2 新手
filter 过滤器
filter(function, sequence)，filter()函数接收一个函数 f 和一个序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
li=[1,2,3,4]
def guolv(x):
return x%2==1
li2=filter(guolv,li)
list(li2) =>>[1, 3]
另外一种方法：
list(filter(lambda x:x%2==1,li)) =>[1, 3]
利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符，可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。
map 加工
map(function, sequence) ，map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
对sequence中的item依次执行function(item)，见执行结果组成一个List返回：
def f(x):
return x*x
list(map(f,[1,2,3,4])) =>>[1, 4, 9, 16]
zip 压缩，将对象一一对应
返回元组组成的迭代器，zip是Python中的一个内建函数，能够用来组合多个序列类型的数据。它会把传入的所有序列中下标相同的元素组成一个个元组，以最短的序列为基准。
实例1：
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
xyz=zip(x,y,z)
xyz
=>> <zip object at 0x04133968>
list(xyz)
=>> [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
实例2： 最终的长度以最短的序列长度为准
x=[1,2,3]
y=[4,5,6,7]
xy = zip(x,y)
xy
=>> <zip object at 0x041339B8>
list(xy)
=>> [(1, 4), (2, 5), (3, 6)]
实例3：如果只有一个序列压缩，那么同样会返回元组：
x = [1, 2, 3]
list(zip(x))
=>> [(1,), (2,), (3,)]
所有的序列类型都可以进行压缩，最终的长度以最短的序列长度为准，不过字典在压缩时只会保存的它的键：
a=[1,2,3]
b='abcde'
c={'one':1,'two':2}
z=zip(a,b,c)
z
=>> <zip object at 0x041498C8>
list(z)
=>> [(1, 'a', 'one'), (2, 'b', 'two')]
解压
如果需要对压缩过的对象进行解压，只需要在之前添加一个星号*：
z=zip(*zip('python'))
list(z)
=>> [('p', 'y', 't', 'h', 'o', 'n')]
通过zip来进行字典的键值对翻转
dict(spam = 1, egg = 2, bar =3)
=>> {'spam': 1, 'egg': 2, 'bar': 3}
dic = {'a':1,'b':2,'c':3}
list(zip(dic.values(),dic.keys()))
=>> [(1, 'a'), (2, 'b'), (3, 'c')]
dict(list(zip(dic.values(),dic.keys())))
=>> {1: 'a', 2: 'b', 3: 'c'}
变量的作用域
变量的作用域与其定义的方式有关：
局部变量：变量在函数内部定义，则变量的作用域在函数内部
全局变量：变量在函数外部定义的，则变量的作用域是全局
x =1 #全局
def test1():
y = 2 #局部
print(x) #能访问
test1()
def test2():
y=2
x+=1 #能访问不能修改
print(x)
test2()
=>>UnboundLocalError: local variable 'x' referenced before assignment
def test3():
y=2
global x #全局变量可以在函数内部访问，但是不能改变。如果要修改则用global来修饰
x+=1
print(x)
test3()
局部变量全局不能访问
def fun1():
g = 1
print(g)
print(g) =>>SyntaxError: unindent does not match any outer indentation level
def fun2():
global g #局部变量只能在局部进行访问和修改。如果在函数外部，想访问局部变量，也可以用 global，将局部变量声明为全局变量
g = 1
print(g)
print(g)
fun2() =>> 1
总结：global：用来在函数或其他局部作用域中，声明全局变量。 (作用于全局)
使用global情况：
1 全局变量可以在函数内部访问，但是不能改变。如果在函数内部想修改全局变量，可以用 global 来修饰变量。
2 局部变量只能在局部进行访问和修改。如果在函数外部，想访问局部变量，也可以用 global，将局部变量声明为全局变量。
内嵌函数
在函数内部定义函数，就是函数里面嵌套函数
nonlocal：用来在函数或其他作用域中，声明外层(非全局)变量。(作用于局部) 。
使用nonlocal的情况：
当里层局部，需要修改外层局部时，需要使用nonlocal。 (如嵌套函数)
闭包
闭包：一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。(但是B函数，一定要是嵌套在函数A里面) 。你在调用函数A的时候传递的参数就是自由变量。
总结：一个函数里面嵌套一个函数，调用外面这个函数，就返回里面嵌套的函数。
def fun2(a):
print(a)
def fun3(b):
print(a,b)
return fun3
g=fun2(1)
=>> 1
g(2)
=>>1 2
回调函数
递归函数
递归： 函数调用自己本身
递归的核心：
1.递归推导式
2.递归终止条件
作业
1.定义一个函数，输入一个序列(序列元素是同种类型)，判断序列是顺序还是逆序，顺序输出UP，逆序输出DOWN，否则输出None
def judge(seq):
seq = list(seq) #sorted函数返回新的列表list,所以在此处转换为列表，否则如果是其他序列类型，则不行，以便下面==判断
if sorted(seq) == seq:
print('UP,从小到大')
elif sorted(seq,reverse=True) == seq:
print('DOWN,从大到小')
else:
print('None 无规律')
注意：
sorted（内置函数，属于python） sort(属于列表)
li.sort()
sorted(li)
reversed(sequence) -> reverse iterator over values of the sequence
li = [1,99,66,33]
list(reversed(li))
写一个函数，对列表li = [9,8,3,2,6,4,5,7,1]，进行从小到大的排序。最后返回li。
方法1：
def fun(li):
li.sort()
return li
方法2：
def fun2(li):
return sorted(li)
li = [9,8,3,2,6,4,5,7,1]
fun(li)
print(li)
方法3：冒泡排序：
def fun3(li):
for i in range(len(li)-1):
for j in range(len(li)-i-1):
if li[j] > li[j+1]:
li[j],li[j+1]=li[j+1],li[j]一个列表，有4个由数字组成的长度为4的元组，对这四个元组，
按每个元组的第2个数字大小排序。
li =[(1,3,5,4),(5,2,3,6),(5,8,3,9),(8,1,3,9)]
li.sort(key=lambda x:x[1]) #key为函数，指定取待排序元素的哪一项进行排序
print(li)
