1、内置函数
（1） help 查看函数的帮助信息
help(print)
（2）数学运算
print(abs(-5));
print(max(12,6,-5,120,74))
print(pow(2,4))
（3）类型转换
print(int('123'))
print(float('12.5'))
print(str(123))
print(bool(5))
（4）判断数据类型
a = 'abc'
print(isinstance(a,int))#第二个参数可以是元组
2 自定义函数
def 函数名(参数):
缩进函数体
（1）默认参数
def my_pow(x,y=2)
if y == 0:
return 1;
res = x
for i in range(y - 1):
res *= x
return res
（2）、可变参数
def my_sum(x,*y):
#第二个参数为一个元组
print(x)
print(y)
my_sum(1,2,3,4,5)#1 (2,3,4,5)
def my_sum(*y,x):
#第二个参数为一个元组
print(x)
print(y)
my_sum(1,2,3,4,x=5) #(1,2,3,4) 5
def my_sum(*y,x):
#第二个参数为一个元组
print(x)
print(y)
nums = [6,7,8,9]
my_sum(*nums,x=5) #(1,2,3,4) 5
（3） 关键字参数
关键字参数，使用**，也表示参数个数是可变的，但传递的是带名称的参数
def f1(x,**y):
print(x)
print(y)#接收到的是一个dict
f1(3,a=5,b=9,c=18)
#对于关键字参数，可以直接传入一个dict，只需要在参数前添加**
def f1(x,**y):
print(x)
print(y)#接收到的是一个dict
user = {'id':1001,'name':'tom','age':18}
#调用时有两种写法
f1(4,id=user['id'],name=user['name'],age=user['age'])
f1(4,**user)
（4）命名关键字参数，限制关键字参数的名字，使用分割，号后面的参数标识命名关键字参数
def f2(x,*,name,age):
print(x)
print(name)
print(age)
f2(4,name='alice',age=20)
（5） 接收任意参数
def f3(*args,**kwargs):
print(args)
print(kwargs)
f3(1,43,'aaa',name='alice',age=20)
（6） 空函数
# 表示以后再实现
def empty():
pass
2 函数的返回值
（1）、多个返回值
#函数有且只能有一个返回值，如果返回多个，会被视作一个元组
def f4():
return 'tom'
def f5():
name = 'tom'
age = 20
sex = 'male'
return name,age,sex
a,b,c = f5()
print(a,b,c)
（2） 闭包
#内部函数使用了外部函数的参数或局部变量，成为闭包
def f6(x):
z = 6
def f7(y):
print(x*y)
return f3
fn = f6(3)
fn(5)
（3）递归函数：一个函数再内部调用自身，这个函数就是递归函数
def calc(x,y):
i = 1
res = x
while i < y:
res *= x
i += 1
return res
calc(x,3)
#递归写法
def calc(x,y):
if y == 0;
return 1
else:
return calc(x,y-1)
（4）变量作用域和命名空间
'''
变量作用域scope:指的是变量生效的区域
两种作用域：
1、全局作用域
函数以外的区域都是全局作用域
在全局作用域中定义的变量，都是全局变量
2、函数作用域，也成为局部作用域
函数内的区域
'''
a = 5 #全局变量
#python没有块级作用域
#如果希望在函数中修改全局变量，要使用global关键字来声明变量
def fn():
global a
a = 10
fn()
print('函数外部:a=',a)
'''
命名空间namespace:指的是变量存储的位置，每一个变量都要存储在指定的命名空间中，每个作用域都有一个对应的命名空间。
'''
- 操作scope
scope = locals()
print(scope)
print(type(scope))
#可以通过scope['name']的方式获取变量值，但不建议设置未声明变量的值（而且函数作用域中不可以通过作用域声明变量）
# 可以通过globals()在任意位置获取全局命名空间（在函数中也可以）
- 迭代
#迭代：也成为遍历，循环获取每一个元素
for i in ['tom','jack','alice']:
print(i,end=' ')
print()
for i in ('tom','jack','alice'):
print(i,end=' ')
print()
for k,v in {'name':'tom','age':18,'sex':'male'}.items():
print(k,v)
for i in 'hello':
print(i)
- 判断一个数据是否可迭代
import collections
print(isinstance('hello',collections.Iterable))
- 介绍两种数组的迭代方法
# 方式1：自己获取索引
names = ['tom','jack','alice']
for i in range(len(names)):
print(i,names[i])
#方式2:使用enumerate()函数，转换为索引-元素对
for k,v in enumerate(names):
print(k,v)
- 列表生成器
nums = list(range(0,100))
- 生成一个包含[1,100]之间所有3的倍数的list
#方式1
lst = []
for i in range(1,101):
if i%3 == 0:
lst.append(i)
#方式2
lst = [i for i in range(1,101) if i%3 == 0]
（5）迭代器和生成器
迭代器
nums = [1,2,3,4,5,6]
it = iter(nums)#调用iter()函数创建迭代器
next(it)#调用next()函数获取迭代器的下一个元素，它只能往前，不能往后
使用for in遍历迭代器
nums = [1, 2, 3, 4, 5, 6]
it = iter(nums) #调用iter()函数创建迭代器
for i in it:
print(i)
生成器
生成器并不会立即在内存中开辟空间存储数据，只有你调用next方法时才会生成这个数据
generator = (i for i in range(1,100))
print(next(generator))
在函数中使用yield关键字，该函数就变成一个生成器函数
def gen():
yield 13
yield 14
3、高阶函数
高阶函数： 一个函数接收另一个函数作为参数，这种函数称为高阶函数
（1）、自定义高阶函数
def fil(x):
return x > 5
def fn(fun, lst):
new_list = []
for i in lst:
if fun(i):
new_list.append(i)
return new_list
print(fn(fil, [2, 3, 5, 8, 9]))
（2）、内置高阶函数
- filter
def fil(x):
return x > 5
nums = [3, 6, 8, 9, 4]
print(list(filter(fil, nums)))
- map
def fil(x):
return x + 5
nums = [3, 6, 8, 9, 4]
print(list(map(fil, nums)))
- sorted
def fil(x):
return x + 5
nums = [3, -6, 8, -9, 4]
print(list(sorted(nums, key=abs)))
4 匿名函数
nums = [3, -6, 8, -9, 4]
print(list(map(lambda x: x*2, nums)))
#不建议将匿名函数赋值给变量
5 装饰器
在代码运行期间动态增加功能，称为装饰器
def log(fn):
def wrapper(*args, **kwargs):
print('开始执行%s()函数' % fn.__name__)
res = fn(*args, **kwargs)
print('%s()函数执行结束' % fn.__name__)
return res
return wrapper
@log
def con(num):
print(num)
return num
con(5)
