02 函数

函数

"""
先定义后调用(函数名+括号)
函数名的命名规则跟变量名一样
函数在定义的时候只检测函数体语法,不执行函数体代码
函数名遇到括号会立即执行函数体代码
"""


# 定义: 
# 1.空函数
    def func(): 
        pass
# 2.无参函数
    def func(): 
        print('hello world')
# 3.有参函数
    def func(x, y, *args, **kwargs): 
        print('hello world')
        
        
def index(): 
    pass  # 第一种顶替方式(推荐使用pass)
    ...  # 第二种顶替方式

函数返回值 return

"""
函数内要想返回值给调用者,必须用关键字return,函数体遇到return直接结束整个函数的运行
所有的函数都有返回值,不写默认返回None
光写return或return None并不是为了考虑返回值,而是为了结束函数的运行
"""



def func(): 
    l = ['jason', 'egon', 'tank']
    while True: 
        for i in l: 
            if i == 'egon': 
                return  # 当i为egon时,直接结束函数运行
                print('abcdefg')  # 这一行代码永远都不会运行
            print(i)


            
# 不写return:  函数默认返回None

# 只写return:  返回None 

# 写return返回None:  跟只写return一样

# 写return返回一个值:  这个值可以是python任意数据类型

# 写return返回多个值:  将多个值以元组的形式返回给调用者

def func1(): 
    return 1, 2, 3, 4
print(func())  # (1, 2, 3, 4)

def func2(): 
    return 'a', 'b', 'c'  
print(func2())  # ('a', 'b', 'c')

def func3(): 
    return [1, 2], [1, 3], [2, 3]  
print(func3())  # ([1, 2], [1, 3], [2, 3]) 

def func4(): 
    return {'name':  'jason'}, {'age':  '18'}  
print(func4())  # ({'name':  'jason'}, {'age':  '18'})

# 写return返回多个值:  不想返回元组类型,可以加上你想返回的数据类型符号
def func5(): 
    return [[1, 2], [1, 3], [2, 3]]  
print(func5())  # [[1, 2], [1, 3], [2, 3]]

函数参数

"""
函数参数的两大类型: 
    形参: 在函数的定义阶段,括号内写的变量名,叫做该函数的形式参数,简称形参
    实参: 在函数的调用阶段,括号内实际传入的值,叫做实际参数,简称实参
    
形参与实参的关系: 
    形参就相当于变量名,而实参就相当于变量的值
    函数调用传参的过程,就是给形参赋值的过程
    
注意: 形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除,只在函数内部有效,函数外部无任何影响
    
函数的简易结构: 
    def 函数名(形参1,形参2...): 
        '''函数的注释,用来描述该函数的作用以及各个形参的类型和return返回值'''
        函数体代码1
        函数体代码2
        ...
        return 函数的返回值
"""


def func(x, y): 
    """
    该函数的作用
    : param x:  对形参x的解释
    : param y:  对形参y的解释
    : return:  对函数返回值的解释
    """
    print('hahaha')
    return 'heihei'

print(help(func))  # 查看函数注释

位置参数

"""
位置形参: 在函数定义阶段按照位置从左往右依次书写的变量名,位置形参在调用的时候,必须为其传值,有几个传几个
位置实参: 在函数的调用阶段
	位置传参: 直接按照位置传,一一对应
	关键字传参: 指名道姓的传

注意: 在函数的调用阶段,位置传参和关键字传参可以混合使用,但是必须保证
    1.位置传参必须在关键字传参的前面
    2.同一个形参不能被多次赋值
"""



# 比较两个数的大小,返回大的那个
def my_max(x,y):   # 位置形参
    print(x,y)
    if x > y: 
        return x
    else: 
        return y

# 位置传参
print(my_max(1,3))
print(my_max(1))  # 在调用函数时,少一个实参不行
print(my_max(1,2,3))  # 在调用函数时,多一个实参也不行

# 关键字传参
print(my_max(y=20,x=10))

# 位置传参和关键字传参混合使用
print(my_max(10,y=20))  

默认值参数

"""
默认值参数: 在函数的定义阶段,形参(变量名)就已经被赋值了
在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
在调用的时候如果给默认值形参传值,那么就使用你传的值
在定义阶段,默认值形参必须放在位置形参的后面

函数在定义阶段,内部所使用的变量都已经初始化完毕了,不会因为调用位置变化,而影响到内部的值(暂时可忽略)
函数无论在什么地方被调用,都会跑到函数定义阶段去执行代码,形参中用到的值都是往函数定义阶段代码之上找
"""



def my_max(x,y=100): 
    if x > y: 
        return x
    return y
print(my_max(200))  # y使用默认值参数
print(my_max(200,1000))  # y使用传的值



# 默认值参数问题
def info(username,hobby,l=[]): 
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','read')  # jason 的爱好是 ['read']
info('tank','study')  # tank 的爱好是 ['read', 'study']

# 解决方法1: 不使用默认的自己传参
info('jason','read',[])  # jason 的爱好是 ['read']
info('tank','study',[])  # tank 的爱好是 ['study']

# 解决方法2: 
def info(username,hobby,l=None): 
    if l == None: 
        l = []
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','read')  # jason 的爱好是 ['read']
info('tank','study')  # tank 的爱好是 ['study']

可变长参数

"""
用*和**来接收多余的(溢出的)位置参数和关键字参数
    *在形参中能够接受多余的位置参数,组织成一个元祖赋值给*后面的变量名
    **在形参中能够接受多余的关键字参数,组织成一个字典赋值给**后面的变量名
     
    *在实参中能够将、列表、元祖、集合打散成位置实参的形式传递给函数,*就看成是for循环取值
    **在实参中能够将字典打散成key=value的形式按照关键字参数传递给函数
"""



# 站在形参的角度,看 *
# 形参中的*会将多余的(溢出的)位置实参,统一用元组的形式处理,传递给*后面的形参名
# *在形参中只能接收多余的位置实参,不能接收关键字实参
def func(x,y,*z): 
    print(x,y,z)
func(1,2,3,4,5,6)  # 1 2 (3, 4, 5, 6)



# 站在实参的角度,看 *
# *只能将字符串、列表、元组、集合打散成位置实参一一传入,*的内部看成是for循环
def func(x,y,z): 
    print(x,y,z)
func(*[1,2,3])  # *会将列表打散成位置实参一一传入,等价于func(1,2,3)

def func(x,*z): 
    print(x,z)
func(1,*{1,2,3})  # 1 (1, 2, 3)



# 站在形参的角度,看 **
# **会接收所有多余的关键字参数,并将关键字参数转换成字典形式,字典的key为关键字的名字,字典的value为关键字的名字指向的值,将字典交给**后面的变量名
def func(x,y,**z): 
    print(x,y,z)
func(1,2,a=1,b=2,c=3)  # 1 2 {'a':  1, 'b':  2, 'c':  3}
func(x=1,y=2,a=1,b=2,c=3)  # 1 2 {'a':  1, 'b':  2, 'c':  3}



# 站在实参的角度,看 **
# **会将字典拆封成key=value的形式
def func(x,y,z): 
    print(x,y,z)
func(**{'x': 1,'y': 2,'z': 3})  # 等价于func(x=1,y=2,z=3)



# 需求: 你写的函数,调用者按照正确传参方式无论怎么传,你的函数都能够正常执行
def func1(*x,**y): 
    print(x,y)
func1(1,2,x=1,y=2,z=3)  # (1, 2) {'x':  1, 'y':  2, 'z':  3}



# python推荐形参中*和**通用写法
def func2(*args,**kwargs): 
    print(args,kwargs)

命名关键字参数

# 在函数定义阶段,写在*与**可变长参数之间的形参
# 在给命名关键字参数传值的时候,只能用关键字为其传值
# 在定义阶段,感觉好像是z是默认值参数放在了m这个位置参数的前面了,应该报错,其实z和m都是命名关键字参数,不是默认值参数和位置参数
def func(x,y=1,*args,z=3,m,**kwargs): 
    print(x,y)  # 1 2
    print(args)  # (1, 2, 3)
    print(z,m)  # 69 999
    print(kwargs)  #{'o':  666999, 'l':  999666}
func(1,2,1,2,3,z=69,m=999,o=666999,l=999666)

函数对象

# 函数是第一类对象: 函数名指向的值可以被当做参数传递



# 1.函数名可以被传递
def func(): 
    print('from func')
print(func)  # <function func at 0x0000028D0566F1F0>
f = func
print(f)  # <function func at 0x0000028D0566F1F0>



# 2.函数名可以被当做参数传递给其他函数
def func(): 
    print('from func')
def index(args): 
    print(args)
    args()
index(func)  # <function func at 0x000001C8B572E160>  from func



# 3.函数名可以被当做函数的返回值
def index(): 
    print('index')
def func(): 
    return index
res = func()
print(res)  # <function index at 0x0000021D260FE160>
res()  # index



# 4.函数名可以被当做容器类型的参数
def func(): 
    return 'func'
l = [1,2,func,func()]
print(l)  # [1, 2, <function func at 0x0000024DEBFEE160>, 'func']



# 示例: 循环打印项目功能提示信息,供用户选择,用户选择谁就执行谁
def register(): 
    print('register ...')
def login(): 
    print('login ...')
def transfer(): 
    print('transfer ...')

msg = """
1 注册
2 登陆
3 转账
"""

func_dict = {
    '1': register,
    '2': login,
    '3': transfer,
}

while True: 
    print(msg)
    choice = input('请输入你想执行的功能>>>: ').strip()
    if choice in func_dict: 
        func_dict.get(choice)()  # 函数名()
    else: 
        print('输入错误')

函数的嵌套调用

# 在函数内部调用其他函数,可以将复杂的逻辑简单化

def index(): 
    print('index')
def func(): 
    index()
func()  # index


def my_max(x,y): 
    if x > y: 
        return x
    return y
def my_max4(a,b,c,d): 
    res1 = my_max(a,b)
    res2 = my_max(res1,c)
    res3 = my_max(res2,d)
    return res3
print(my_max4(1,2,10,4))  # 10

函数的嵌套定义

def outer(): 
    x = 1
    print('outer')
    def inner(): 
        print('inner')
outer()  # outer
print(x)  # NameError:  name 'x' is not defined 外层不能访问函数体内部代码
print(inner)  # NameError:  name 'inner' is not defined



def outer(): 
    x = 1
    print('outer')
    def inner(): 
        print('inner')
    inner()
outer()  # outer  inner 函数体内部可以访问函数体内部代码



def outer(): 
    x = 1
    print('outer')
    def inner(): 
        print('inner')
    return inner
res = outer()  # outer
print(res)  # <function outer.<locals>.inner at 0x0000029F26891D30>
res()  # inner



# 示例: 写一个函数,该函数用户可以通过传参的不同控制函数执行不同的功能

def all_funx(type): 
    def register(): 
        print('register')
    def login(): 
        print('login')
    def shopping(): 
        print('shopping')

    if type == '1': 
        register()
    elif type == '2': 
        login()
    elif type == '3': 
        shopping()

all_funx('1')  

闭包函数

# 闭: 定义在函数内部的函数
# 包: 内部函数引用了外部函数作用域的名字
def outter(): 
    x = 111
    def inner(): 
        print(x)
    return inner
res = outter()  # res就是inner函数的内存地址
x = 222
res()  # 111
def func(): 
    x = 333
    res()
func()  # 111



# 给函数体传值的两种方式
# 第一种方式: 传参
def index(name): 
    print(name)

# 第二种方式: 闭包
def outter(x,y): 
    def my_max(): 
        if x > y: 
            return x
        return y
    return my_max
res1 = outter(1,40)  # res1就是my_max函数的内存地址
print(res1())  # 40



# 示例: 
import requests

# 传参
def my_get(url): 
    response = requests.get(url)
    if response.status_code == 200: 
        print(response.text)
my_get('https: //www.baidu.com')

# 闭包
def outter(url): 
    def my_get(): 
        response = requests.get(url)
        if response.status_code == 200: 
            print(response.text)
    return my_get
my_jd = outter('https: //www.jd.com')
my_jd()

装饰器

装饰器

"""
装饰器: 给被装饰对象添加新的功能的工具
开放封闭原则: 
    开放: 对扩展开放
    封闭: 对修改封闭
装饰器必须遵循的两个原则: 
    1.不改变被装饰对象源代码
    2.不改变被装饰对象调用方式
"""



# 示例: 统计index函数执行的时间

# 简单版
import time

def index(): 
    time.sleep(3)
    print('结束啦')

def outter(func):   # func为最原始的index函数的内存地址
    def get_time(): 
        start = time.time()
        func()  # func为最原始的index函数的内存地址,直接调用
        end = time.time()
        print('index run time: %s'%(end-start))
    return get_time

index = outter(index)  # outter(最原始的index函数内存地址),index指向get_time函数的内存地址
index()  # 结束啦  index run time: 3.0007338523864746


# 升级版
"""
函数参数的问题: 
    无参函数和有参函数都可以直接调用
    函数可以接收任意数量的参数
    能返回之前函数的返回值
"""
import time

def index(): 
    time.sleep(3)
    print('结束啦')
    return 'index'

def login(name): 
    time.sleep(1)
    print('%s is sb'%name)
    return 'login'

def outter(func):   
    def get_time(*args, **kwargs):   # args = ('egon',) kwargs = {}
        start = time.time()
        res = func(*args, **kwargs)  # 最原始的login函数的内存地址(),直接调用,login('egon')
        end = time.time()
        print('func run time: %s'%(end-start))
        return res
    return get_time

login = outter(login)
res = login('egon')  # egon is sb  func run time: 1.006035327911377
print(res)  # login

index = outter(index) 
res1 = index()  # 结束啦  func run time: 3.004805326461792
print(res1)  # index

装饰器语法糖

# 语法糖写时应该与被装饰对象紧挨着,两者之间不要有空行

import time

def outter(func):   
    def get_time(*args, **kwargs): 
        start = time.time()
        res = func(*args, **kwargs)  
        end = time.time()
        print('func run time: %s'%(end-start))
        return res
    return get_time

@outter  # index = outter(index),index = outter(最原始的index函数的内存地址),这个就是装饰器语法糖
def index(): 
    time.sleep(3)
    print('结束啦')
    return 'index'

@outter  # login = outter(login)
def login(name): 
    time.sleep(1)
    print('%s is sb'%name)
    return 'login'

@outter  # home = outter(home)
def home(*args,**kwargs): 
    time.sleep(1)
    return 'home'

index()
login('egon')
home()



# 示例: 认证装饰器,执行函数index之前判断用户登入状态,已登入则执行,未登入则需登入,用户名密码正确才能执行,修改用户登入状态,否则提示用户输入错误,结束程序

import time

user_dic = {'is_login': None}

def login_auth(func): 
    def inner(*args,**kwargs): 
        if user_dic['is_login']: 
            res = func(*args, **kwargs)
            return res
        else: 
            username = input('please input your username>>>: ').strip()
            password = input('please input your password>>>: ').strip()
            if username == 'jason' and password == '123': 
                user_dic['is_login'] = True
                res = func(*args,**kwargs)
                return res
            else: 
                print('username or password error')
    return inner

@login_auth
def index(name): 
    time.sleep(1)
    print('%s is dsb'%name)
    return 666

index('egon')

多层装饰器

# 双层装饰器
import time
user_dic = {'is_login': None}

def outter(func):   
    def get_time(*args, **kwargs): 
        start = time.time()
        res = func(*args, **kwargs)  
        end = time.time()
        print('func run time: %s'%(end-start))
        return res
    return get_time

def login_auth(func): 
    def inner(*args,**kwargs): 
        if user_dic['is_login']: 
            res = func(*args, **kwargs)
            return res
        else: 
            username = input('please input your username>>>: ').strip()
            password = input('please input your password>>>: ').strip()
            if username == 'jason' and password == '123': 
                user_dic['is_login'] = True
                res = func(*args,**kwargs)
                return res
            else: 
                print('username or password error')
    return inner

# 装饰器语法糖嵌套,装饰的时候从下往上执行
@login_auth  # index = login_auth(get_time),index = inner函数的内存地址
@outter  # get_time = outter(index),index是最原始的index
def index(): 
    time.sleep(1)
    print('from index')
    return 'index'

print(index())



#有参装饰器,三层装饰器
import time
user_dic = {'is_login': None}

def outter(func): 
    def get_time(*args, **kwargs): 
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print('func run time: %s'%(end-start))
        return res
    return get_time

def login_auth2(data_source,x,y): 
    # data_source = 'file'
    def login_auth(func): 
        # func = index
        def inner(*args,**kwargs): 
            if user_dic['is_login']: 
                res = func(*args, **kwargs)
                return res
            else: 
                if data_source == 'file': 
                    username = input('please input your username>>>: ').strip()
                    password = input('please input your password>>>: ').strip()
                    if username == 'jason' and password == '123': 
                        user_dic['is_login'] = True
                        res = func(*args,**kwargs)
                        return res
                    else: 
                        print('username or password error')
                elif data_source == 'MySQL': 
                    print('from MySQL')
                elif data_source == 'LDAP': 
                    print('from LDAP')
                else: 
                    print('暂无该数据来源')
        return inner
    return login_auth

@login_auth2('MySQL',1,2)  # @login_auth2('file',1,2) => @login_auth,并且带参 data_source='file'、x=1、y=2
@outter
def index(): 
    time.sleep(1)
    print('from index')
    return 'index'

index()

装饰器修复技术

"""
若没有用装饰器修复技术,则看被装饰器函数的内存地址、函数名和注释为装饰器内部函数的函数名和注释
装饰器修容技术可以解决: 
    用户查看被装饰函数的内存地址时就是被装饰函数的内存地址
    用户查看被装饰函数的函数名时就是被装饰函数的函数名
    用户查看被装饰函数的注释时就是被装饰函数的注释
"""

from functools import wraps
def outter(func): 
    @wraps(func)  # 装饰器修复技术
    def inner(*args,**kwargs): 
        """
        我是inner函数
        : param args: 
        : param kwargs: 
        : return: 
        """
        print('执行被装饰函数之前 你可以执行的操作')
        res = func(*args,**kwargs)
        print('执行被装饰函数之后 你可以执行的操作')
        return res
    return inner

@outter  # index = outter(最原始的index函数的内存地址)
def index(): 
    """
    我是index函数
    : return: 
    """
    pass

print(index)  # index函数的内存地址
print(help(index))  # index函数的注释
print(index.__name__)  # index函数的函数名,FUNC__name__: 查看函数名

装饰器模板

# 1.无参装饰器
from functools import wraps
def outter(func): 
    @wraps(func)
    def inner(*args,**kwargs):   # * **在形参中使用
        print('执行被装饰函数之前你可以做的操作')
        res = func(*args,**kwargs)  # * **在实参中使用
        print('执行被装饰函数之后你可以做到操作')
        return res
    return inner

@outter
def index(name,*args,**kwargs): 
    """index注释"""
    pass


# 2.有参装饰器(最复杂就三层)
def wrappers(data): 
    def outter(func): 
        def inner(*args,**kwargs): 
            if data == 'file': 
                print('执行被装饰函数之前你可以做的操作')
                res = func(*args,**kwargs)  # * **在实参中使用
                print('执行被装饰函数之后你可以做到操作')
                return res
        return inner
    return outter

@wrappers('file')
def index(name,*args,**kwargs): 
    """index注释"""
    pass

递归函数

"""
函数在调用阶段直接或间接的又调用自身
递归分为两个阶段: 
    1.回溯: 就是一次次重复的过程,这个重复的过程必须建立在每一次重复问题的复杂度下降,直到最终的结束条件
    2.递推: 一次次往回推导的过程
"""



# 函数递归深度限制
import sys
print(sys.getrecursionlimit())  # 1000 获取函数递归深度限制,不是很精确
sys.setrecursionlimit(1000)  # 设置函数递归深度限制

def func(n): 
    print('from func',n)
    func(n+1)
func(1)  # 函数递归深度限制,大概997、998



# 示例1: 
"""
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18

age(n) = age(n-1) + 2  # n > 1
age(1) = 18  # n = 1
"""
def age(n): 
    if n == 1:   # 必须要有结束条件
        return 18
    return age(n-1) + 2
print(age(5))  # 26



# 示例2: 将列表中的数字依次打印出来
l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,]]]]]]]]]]
def get_num(list): 
    for i in list: 
        if type(i) is int: 
            print(i)
        else: 
            get_num(i)
get_num(l)  



# 示例3: 二分法,容器类型里面的数字必须有大小顺序
l = [1,3,5,12,57,89,101,123,146,167,179,189,345]
num = 666

def get_num(list,target_num): 
    if not list: 
        print('列表不存在')
        return
    print(list)
    # 获取列表中间的索引
    middle_index = len(list) // 2
    # 比较target_num和middle_index大小
    if target_num > list[middle_index]: 
        # 切取列表右半部分
        num_right = list[middle_index + 1: ]
        # 再递归调用get_num函数
        get_num(num_right,target_num)
    elif target_num < list[middle_index]: 
        # 切取列表左半部分
        num_left = list[0: middle_index]
        # 再递归调用get_num函数
        get_num(num_left, target_num)
    else: 
        print('find it',target_num)

get_num(l,num)

匿名函数

"""
没有名字的函数,临时存在用完就没了

lambda x,y: x+y
    : 左边相当于函数的形参
    : 右边相当于函数的返回值

匿名函数通常不会单独使用,而是配合内置函数一起使用
"""

res = (lambda x,y: x+y)(1,2)
print(res)  # 3


# 给匿名函数命名
func = lambda x,y: x+y
print(func)  # <function <lambda> at 0x0000027ED663F160>
print(func(1,2))  # 3

常用的内置函数

# 1. max() min()
l = [1,2,3,4,5]
print(max(l))  # 5

d = {
    'egon': 30000,
    'jason': 88888,
    'nick': 3000,
    'tank': 1000
}

print(max(d))  # tank max内部是基于for循环的,字典里比的是索引的第一个字母在ASCII码中对应的大小
"""
ASCII码
A-Z  65-90
a-z  97-122
"""

def index(name): 
    return d[name]
print(max(d,key=index))  # jason max字典比较,如果传了key,则会把for循环拿到的key作为参数传给后面的index函数执行,最后比较的是函数执行的结果,返回的还是for循环的key
print(max(d,key=lambda name: d[name]))  # jason 使用匿名函数
print(min(d,key=lambda name: d[name]))  # tank min和max一样


# 2. map() 映射,基于for循环
l = [1,2,3,4,5]
print(list(map(lambda x: x+1,l)))  # [2, 3, 4, 5, 6]


# 3. zip() 拉链,基于for循环
l1 = [1,2,3,4]
l2 = ['jason','egon','tank']
l3 = ['a','b',]
print(list(zip(l1,l2)))  # [(1, 'jason'), (2, 'egon'), (3, 'tank')]
print(list(zip(l1,l2,l3)))  # [(1, 'jason', 'a'), (2, 'egon', 'b')]


# 4. filter() 过滤,基于for循环
l = [1,2,3,4,5]
print(list(filter(lambda x: x != 3,l)))  # [1, 2, 4, 5]


# 5. sorted() 对序列（列表、元组、字典、集合、字符串）进行排序
# 语法: list = sorted(iterable, key=None, reverse=False)  # iterable 表示指定的序列，key参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted()函数会返回一个排好序的列表
l1 = ['jason','egon','nick','tank']
l2 = [32,12,55,3,656,30]
print(sorted(l1))  # ['egon', 'jason', 'nick', 'tank'] 按首字母排序
print(sorted(l1,reverse=True))  # ['tank', 'nick', 'jason', 'egon'] reverse=True降序
print(sorted(l2))  # [3, 12, 30, 32, 55, 656]
print(sorted(l2,reverse=True))  # [656, 55, 32, 30, 12, 3]
#另外在调用sorted()函数时，还可传入一个key参数，它可以接受一个函数，该函数的功能是指定sorted()函数按照什么标准进行排序。例如：
chars=['http://c.biancheng.net',\
       'http://c.biancheng.net/python/',\
       'http://c.biancheng.net/shell/',\
       'http://c.biancheng.net/java/',\
       'http://c.biancheng.net/golang/']
print(sorted(chars,key=lambda x:len(x)))  # 自定义按照字符串长度排序


# 6. reduce() 将多个值变成一个值,变的过程依据你传入的函数
from functools import reduce
l = [1,2,3,4,5]
print(reduce(lambda x,y: x+y,l))  # 15 1+2->+3->+4->+5,第一次先获取两个元素相加,之后每次获取一个元素与上一次相加的结果再相加
print(reduce(lambda x,y: x+y,l,18))  # 33 18为初始值,18 >+1->+2->+3->+4->+5


# 7. abs() 求绝对值
print(abs(-11.11))  # 11.11


# 8. all() any() 
print(all([0,1,2]))  # False 传入可迭代对象,只要有一个值为False就返回False
print(any([0,1,2]))  # True 传入可迭代对象,只要有一个值为True就返回True


# 9. bool() 转化为布尔值
print(bool(1))  # True
print(bool(0))  # False


# 10. callable() 判断是否可调用
l = [1,2,3]
def index(): 
    pass
print(callable(l))  # False
print(callable(index))  # True


# 11. chr() ord()
print(chr(97))  # a 将数字转换成ascii码对应的字符
print(ord('a'))  # 97 将字符转换成ascii码对应的数字


# 12. dir() 获取当前对象所在的名称空间里的所有名字,返回的是列表
l = [1,2,3]
print(dir(l))


# 13. divmod() 分页器
print(divmod(101,10))  # (10, 1) 101除以10等于10余1


# 14. eval() exec()
# 识别字符串里的代码自动执行返回结果,eval不支持逻辑代码（赋值、for循环等）,只支持简单的代码；exec支持逻辑代码
s = """
print('hello baby~')
x = 1
y = 2
print(x + y)
"""
eval(s)
exec(s)


# 15. globals() locals()
# globals() 字典的形式访问全局变量
# locals() 字典的形式访问局部变量,返回的是当前局部变量的深拷贝,修改locals()中变量值对原变量没有影响
b = 5
def index(): 
    a = 1
    locals()['a'] = 2
    globals()['b'] = 6
    print(locals())  # {'a':  1}
    print(globals())  # {'b':  6,...}
index()    


# 16. help() 查看注释
def login(): 
    """
    登入
    : return: 
    """
print(help(login))


# 17. isinstance() 判断对象是否属于某一类型
print(isinstance(1,list))  # False


# 18. pow()
print(pow(2,3))  # 8 计算2的三次方


# 19. round()
print(round(3.5))  # 4 四舍五入取整数