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)