Python：函数、内置函数、嵌套函数、高阶函数、装饰器
函数（又叫方法）：
将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。
定义函数：
def my_open(): #定义一个my_open的函数，要带冒号
函数即变量：意思就是说，只是一个函数名的话，它就是一个普通变量，这个变量里面存的是这个函数里面的代码而已
调用函数：
My_open() #函数名加括号即调用此函数，函数不调用就不会执行
函数参数：
1.函数必填参数：
def read_users(file_name,age): #定义函数时，括号里是形参（即变量）；多个参数用逗号隔开，这种又叫必填参数或位置参数
read_users(‘a.txt’,20) #调用函数时，括号里是实参，是实际的参数；多个参数用逗号隔开
2.函数默认值参数：
def read_users(name,sex=’nan’): #sex是默认值参数
read_users(‘hn’) #调用时如果不填sex对应的实参，就默认是‘nan’
read_users(‘hn’,’nv’) #调用时如果填sex对应的实参，就取实参的值
3.函数可变参数：
def post(*args): #也叫参数组（习惯性写args，也可以写其他变量），数量不固定，不是必填的，接收的是一个元组，它把调用函数时传进去的参数放到一个元组里
4.函数关键字参数：
也不是必填参数，可以为空
def kw(**kwargs) #两个星号，接收的是一个字典
kw(name=’hn’,age=20) #调用时实参要写关键字，括号里可以直接填字典变量，但要加上**，比如(dic={‘ name’=’hn’,’age’=20}) kw(**dic)
*args、**kwargs举例：
def a(name,age=18,*args,**kwargs):
pass
a('hn',20,'hehe','haha') #'hn'对应name ,20对应age ,'hehe'和'haha'对应的是*args
a(name='hn',age=18,addr='beijing',country='china') #addr='beijing',country='china'对应的参数就是**kwargs
5.参数的顺序：
按照必填参数、默认值参数、可变参数、关键字参数的顺序接收参数，否则会报错，例:def other(name,country=’china’,*args,**kwargs)
6.调用函数时使用关键字参数：
如果定义函数时，必填参数太多，在调用函数时，可以用key=value形式传实参，这种实参可以无序。例：定义函数：def write(filename,model,user,os): 调用：write(‘a.txt’,user=’hn’,os=’windows’,model=’hhh’) #调用函数传实参时，必填参数必须在关键字参数前面
函数返回值：
用return a #函数碰到return立即结束函数；调用完函数之后会返回一个结果
没有返回值的函数，默认返回None
PS：如果函数里有while循环：碰到return，循环和函数都结束
返回多个值：
return a,b,c #用逗号隔开，返回的多个值会放到元组里
一个小程序：校验输入的字符串是否为小数
def check_float(num):
num=str(num)
if num.count('.')==1: #小数的小数点只有一个
left_num=num.split('.')[0]
right_num=num.split('.')[1]
if left_num.isdigit() and right_num.isdigit(): #小数点左右两边都是整数
return '正小数'
elif left_num[0]=='-' and left_num[1:].isdigit() and right_num.isdigit(): #负小数只有一个负号，小数点两边两个整数
return '负小数'
return '不是小数'
局部变量、全局变量、常量：
给变量命名：1用下划线read_ffilename 2驼峰readFileName
局部变量：在函数里面定义的变量叫局部变量，只能在函数里面用
全局变量：在函数外定义的变量，是全局变量，在函数内也能使用
在函数里改全局变量：
（int、string类型）：用global声明
用global声明一下，即global a a=100这样全局变量a的值就变了，如果不用global声明，a只是在函数内部被定义、被改变，出了函数，a的值还是函数体之前的值
List、dic 类型，文件句柄：就不用global声明，在函数里改变值，出了函数值也变化了。如果用global声明，会报错。
函数递归调用：
即一个函数自己调用自己，最多递归调用999次。必须有一个明确的结束条件，效率不高，少用递归。用递归的话，要用return，作为结束条件（函数碰到return就结束）
高阶函数：
如果一个函数的入参是一个函数名的话，这个函数就是高阶函数
例：def add(ax,y,z)
res=z(x)+z(y)
return res
add(‘98’,’100’,int)
函数嵌套：
函数里可以嵌套定义另一个函数
函数嵌套里的作用域，是就近原则，从里往外找，如果自己函数里有，就用自己的，如果自己函数没有，就在上一级函数里找值，如果都没有，去全局变量找，例如：
name = 'python'
def warpper():
name='吴冰'
def deco():
name ='陈冬瓜'
print('我在里面%s'%name)#此处name是陈冬瓜
def hhh():
name = '张莹'
print('xxx%s'%name)
#此处name是张莹
hhh()
deco()
print('外面的name是%s'%name) #此处name是吴冰
warpper()
例子输出结果：
我在里面陈冬瓜
xxx张莹
外面的name是吴冰
Python内置函数：
print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真
print(any([0,1,2,3,4]))#判断可迭代的对象里面的值是否有一个为真
print(bin(10))#十进制转二进制
print(bool('s'))#把一个对象转换成布尔类型
print(callable('aa'))#判断传入的对象是否可调用
print(chr(10))#打印数字对应的ascii
print(ord('b'))#打印字符串对应的ascii码
print(dict(a=1,b=2))#转换字典
print(dir(1))#打印传入对象的可调用方法
print(eval('[]'))#执行python代码，只能执行简单的，定义数据类型和运算
print(exec('def a():pass'))#执行python代码
filter(func,[1,2,3,4])#func是某一个函数，[1 2 3 4]是可迭代对象；根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true保存
map(func,[1,2,3,4])#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的所有结果。注意与filter的区别，fileter是只返回为true的元素，map是都返回。
print(globals())#返回程序内所有的变量，返回的是一个字典，函数里面的局部变量不会返回
print(locals())#返回局部变量
print(hex(111))#数字转成16进制
print(max(111,12))#取最大值
print(oct(111))#把数字转换成8进制
print(round(11.11,2))#取几位小数，会四舍五入
print(sorted([2,31,34,6,1,23,4]))#排序
dic={1:2,3:4,5:6,7:8}
print(sorted(dic.items())) #按照字典的key排序
print(sorted(dic.items(),key=lambda x:x[1])) #按照字典的value排序
isinstance (a,b) 判断两个类型是否相同；b参数只能是int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple这些基本类型
例子：
arg=123
isinstance(arg, int) #输出True
isinstance(arg, str) #输出False
isinstance(arg, string) #报错
装饰器：
即一个嵌套加高阶的函数
作用：在不改变原有函数的调用方式、入参的情况下，给函数添加新功能
例一：
import time
