Python（文件操作、函数）

目录

一、字符编码

二、文件操作

1、基本操作流程

2、资源回收与with用法

3、控制读写操作的模式

4、控制读写内容的模式 

5、文件指针的移动

6、文件操作的其他方法

7、循环读取文件以及文件拷贝

8、文件修改的两种方式

四、函数

1、语法

2、形参与实参的具体使用

3、名称空间以及作用域

4、函数对象

5、函数嵌套

6、闭包函数（名称空间以及作用域+函数对象+函数嵌套）

五、装饰器

1、定义与模板

2、装饰器实现思路

3、@装饰器名字

4、有参装饰器

5、叠加多个装饰器（了解）

六、迭代器

七、生成器 

八、表达式

1、三元表达式

2、列表生成式

3、其它生成式 

九、递归函数

1、定义

2、递归的两个阶段

3、递归的应用

十、匿名函数

1、lambda

2、结合max、min、sorted、map、filter、reduce

十一、内置函数

---

一、字符编码

'''
ASCII表：
    1、只支持英文字符
    2、采用8位（8bit=1Bytes）二进制数对应一个英文字符

GBK表：
    1、支持英文字符、中文字符
    2、采用8位二进制数对应一个英文字符、采用16位二进制数对应一个中文字符

unicode：
    1、兼容万国字符，与ASCII表GBK表都有对应关系
    2、采用16位二进制数对应一个字符
utf-8:
    1个英文字符——>1Bytes
    1个中文字符——>3Bytes

结论：
1、内存中固定是unicode，我们可以改变的是存入硬盘的格式
                          内存          硬盘
        中文、英文       unicode         GBK
        日文、英文       unicode       Shift-JIS
        万国字符         unicode        utf-8
2、文本文件存取乱码的问题
    存乱了：存入硬盘的编码格式必须支持文本文件中的字符
    取乱了：以什么格式存入硬盘，就应该以什么格式读取硬盘
3、python解释器默认的读文件编码
    python3默认：utf-8
    python2默认：ASCII
    怎样修改默认的读文件编码：在文件首行添加# coding:utf-8
4、字符串
    python3中的str类型直接存成unicode格式
    python2中强制将str类型存成unicode格式：x=u"上"
'''

x="上"
res=x.encode("gbk")
print(res)
y=res.decode("gbk")
print(y)

二、文件操作

1、基本操作流程

# 1、打开文件
# f的值是一种变量，占用应用程序的内存空间
f=open(r"D:\s38\Day03\aaa.txt",mode="rt",encoding="utf-8")
print(f)

# 2、操作文件
# 用户/应用程序（文件句柄）—————>操作系统（文件）—————>计算机硬件（硬盘）
res=f.read()
print(res)

# 3、关闭文件
f.close()

2、资源回收与with用法

with open(r"D:\s38\Day03\aaa.txt",mode="rt",encoding="utf-8") as f1,\
        open(r"D:\s38\Day03\bbb.txt",mode="rt",encoding="utf-8") as f2:
    res1=f1.read()
    res2=f2.read()
    print(res1)
    print(res2)

3、控制读写操作的模式

# r只读模式
# 文件不存在时则报错
# 指针在开头
with open("a.txt",mode="rt",encoding="utf-8") as f:
    print(f.read())

# w只写模式
# 文件不存在时则创建，存在时则清空文件
# 指针在开头
with open("b.txt",mode="wt",encoding="utf-8") as f:
    f.write("bbb")

# a只追加写模式
# 文件不存在时则创建
# 指针在末尾
with open("c.txt",mode="at",encoding="utf-8") as f:
    f.write("ccc")

# r+、w+、a+可读可写模式
# 保留原先r、w、a本身的特性
with open("d.txt",mode="rt+",encoding="utf-8") as f:
    print(f.read())
    f.write("aaa")
with open("d.txt",mode="wt+",encoding="utf-8") as f:
    print(f.read())
    f.write("aaa")
with open("d.txt",mode="at+",encoding="utf-8") as f:
    print(f.read())
    f.write("aaa")

4、控制读写内容的模式 

# t模式：针对文本文件，自动进行编码操作读写都是以str为单位的
with open(r"a.txt",mode="rt",encoding="utf-8") as f:
    res=f.read()
    print(res,type(res))


# b模式：针对所有文件，不会进行编码操作读写都是以bytes为单位的
with open(r"a.jpg",mode="rb") as f:
    res=f.read()
    print(res,type(res))

with open(r"a.txt",mode="wb") as f:
    f.write("你好aaa".encode("gbk"))        # bytes("你好aaa",encoding="gbk")

5、文件指针的移动

'''
f.seek(n,模式)
n：移动的字节个数
模式0：指针在开头（可以用在t模式下）
模式1：指针在当前
模式2：指针在末尾
f.tell()         # 获取文件指针当前位置
'''

with open(r"a.txt",mode="rt",encoding="utf-8") as f:
    f.seek(3,0)
    print(f.tell())
    print(f.read())
with open(r"a.txt",mode="rb") as f:
    f.seek(1,0)
    f.seek(1,1)
    f.seek(-1,2)
    print(f.tell())
    print(f.read())

# 实现tail -f
import time
with open(r"message_log.txt",mode="rb") as f:
    f.seek(0,2)
    while True:
        res=f.readline()
        if len(res)==0:
            time.sleep(0.3)
        else:
            print(res)

6、文件操作的其他方法

with open(r"a.txt",mode="rt+",encoding="utf-8") as f:
    print(f.readline())
    print(f.readlines())        # ['nihao\n', '你好\n', 'aaa\n']
    
    f.seek(2,0)
    l=['nihao\n', '你好\n', 'aaa\n']
    f.writelines(l)
    
    f.flush()

7、循环读取文件以及文件拷贝

# 循环读取文件
with open(r"a.jpg",mode="rb") as f:
    # print(f.read())

    # for line in f:
    #     print(line)

    while True:
        res=f.read(1024)
        if len(res)==0:
            break
        print(res)


# 文件拷贝
src_file=input("请输入源文件的路径：")
dst_file=input("请输入目标文件的路径：")

with open(r"{}".format(src_file),mode="rb") as f1,\
    open(r"{}".format(dst_file),mode="wb") as f2:
    # res=f1.read()
    # f2.write(res)

    # for line in f1:
    #     f2.write(line)

    while True:
        res=f1.read(1024)
        if len(res)==0:
            break
        f2.write(res)

8、文件修改的两种方式

# 大前提：硬盘不能修改，内存可以修改

# 方式一：
with open(r"a.txt",mode="rt",encoding="utf-8") as f:
    res=f.read()
    res.replace("cang","yuan")
    print(res)
with open(r"a.txt",mode="wt",encoding="utf-8") as f:
    f.write(res)

# 方式二：
import os
with open(r"a.txt",mode="rt",encoding="utf-8") as f1,\
    open(r"b.txt",mode="wt",encoding="utf-8") as f2:
    for line in f1:
        f2.write(line.replace("yuan","cang"))
os.remove(r"a.txt")
os.rename(r"b.txt",r"a.txt")

四、函数

1、语法

'''
def 函数名(形参1,形参2,...):
    """文档描述"""
    函数体
    return 值

函数名(实参1,实参2,...)
'''


# 定义函数发生的事情
# 1、申请内存空间存储函数体代码
# 2、函数体的内存地址绑定函数名
# 3、只是检测函数体语法，不会执行函数体代码

# 函数的返回值：函数终止的标志
# 1、None：无return、return、return None
# 2、一个值：return 值
# 3、元组：return 值1,值2,...

# 形参与实参
# 1、在函数定义阶段的参数是形参，相当于变量名
# 2、在函数调用阶段的参数是实参，相当于变量值
# 3、在函数调用时绑定形参与实参，在调用结束后解除绑定关系

# 调用函数发生的事情
# 1、通过函数名找到函数体的内存地址
# 2、通过函数名加括号执行函数体代码

def func():
    print("哈哈哈")
func()

def fun(x,y):
    z=x+y
    # print(z)
    return z
res=fun(10,30)
print(res)

def func():
    pass

2、形参与实参的具体使用

# def func(x,y):              # 位置参数：必须被传值
#     pass
# def func(x=1,y=1):          # 默认参数：可以不被传值（在函数定义阶段被赋值的参数，且该参数不推荐使用可变类型）
#     pass
def func(x,y=1):              # 混合使用：位置参数必须在默认参数前
    print(x,y)

func(1,2)                     # 位置实参：按照从左到右的顺序传值
func(y=2,x=1)                 # 关键字实参：按照key=value传值
func(1,y=2)                   # 混合使用：位置实参必须在关键字实参前，且不能为同一形参重复传值

# 可变长参数
def func(x,y,*args):            # *用来接收溢出的位置实参，保存成元组格式，赋值给args
    print(x,y,args)
func(1,2,3,4,5,6)

def func(x,y,**kwargs):         # **用来接收溢出的关键字实参，保存成字典格式，赋值给kwargs
    print(x,y,kwargs)
func(1,y=2,a=1,b=2,c=3)

def func(x,y,z):
    print(x,y,z)
func(*[1,2,3])                  # 实参中带*，先用for循环将其拆解成位置实参

def func(x,y,*args):
    print(x,y,args)
func(1,2,*[1,2,3])

def func(x,y,z):
    print(x,y,z)
func(**{"x":1,"y":2,"z":3})     # 实参中带**，先将其拆解成关键字实参

def func(x,y,**args):
    print(x,y,args)
func(**{"x":1,"y":2,"z":3})

def func(*args,**kwargs):       # 混用*和**，*args必须在**kwargs之前
    print(args)
    print(kwargs)
func(1,2,3,x=1,y=2,z=3)


def index(x,y,z):
    print(x,y,z)
def wrapper(*args,**kwargs):    # args=(1,)   kwargs={"z":3,"y":2}
    index(*args,**kwargs)       # index(1,z=3,y=2)
wrapper(1,z=3,y=2)              # 给wrapper传参，遵循index的参数规则

# 命名关键字参数（了解）
def func(x,y,*args,a,b):        # 命名关键字参数：*后面的参数，必须按照key=value的形式为其传值
    print(x,y)
    print(args)
    print(a,b)
func(1,3,4,5,a=1,b=2)

# 组合使用（了解）
def func(x,y=22,*args,z,**kwargs):
    pass

3、名称空间以及作用域

#       栈区                                      堆区
# 内置名称空间（在python解释器启动时存活）
# 全局名称空间（在python文件执行时存活）
# 局部名称空间（在函数调用时存活，调用结束后且名字未被引用时销毁）

# 加载顺序：内置名称空间 > 全局名称空间 > 局部名称空间

input=333
def func():
    input=444
    print(input)        # 查找名字优先级：从当前所在的位置向上一层一层查找
func()                

x=1
def func():           
    print(x)            # 对于函数内的名字，以定义阶段为基准向上一层一层查找
def foo():
    x=222
    func()
foo()

input=111               
def f1():
    input=222
    def f2():           
        input=333
        print(input)    # 函数嵌套时对于名字的查找
    f2()
f1()

x=111
def func():
    print(x)
    x=222
func()

# global与nonlocal（了解）
x=111
def f1():
    x=222
    def f2():
        # global x      # 将全局名称空间中的x拿过来
        # nonlocal x    # 将该层局部名称空间的上一层局部名称空间中的x拿过来
        x=333
    f2()
f1()

4、函数对象

def register():
    print("注册")

def login():
    print("登录")

def check():
    print("查询")

def transfer():
    print("转账")


while True:
    print("""
    0 退出
    1 注册
    2 登录
    3 查询
    4 转账
    """)
    res=input("请输入编号：").strip()
    if not res.isdigit():
        print("请输入数字！")
        continue
    if res=="0":
        break

    if res=="1":
        register()
    elif res=="2":
        login()
    elif res=="3":
        check()
    elif res=="4":
        transfer()
    else:
        print("请输入提示信息中编号！")

def register():
    print("注册")

def login():
    print("登录")

def check():
    print("查询")

def transfer():
    print("转账")

dict_fun={
    "1":register,
    "2":login,
    "3":check,
    "4":transfer
}

while True:
    print("""
    0 退出
    1 注册
    2 登录
    3 查询
    4 转账
    """)
    res=input("请输入编号：").strip()
    if not res.isdigit():
        print("请输入数字！")
        continue
    if res=="0":
        break

    if res in dict_fun:
        dict_fun[res]()
    else:
        print("请输入已有编号！")

def register():
    print("注册")

def login():
    print("登录")

def check():
    print("查询")

def transfer():
    print("转账")

dict_fun={
    "0":("退出",None),
    "1":("注册",register),
    "2":("登录",login),
    "3":("查询",check),
    "4":("转账",transfer)
}

while True:
    for k in dict_fun:
        print(k,dict_fun[k][0])
    res=input("请输入编号：").strip()
    if not res.isdigit():
        print("请输入数字！")
        continue
    if res=="0":
        break

    if res in dict_fun:
        dict_fun[res][1]()
    else:
        print("请输入已有编号！")

5、函数嵌套

# 函数的嵌套调用：在调用一个函数的过程中再，调用其它函数
def max2(x,y):
    if x>=y:
        return x
    else:
        return y
def max4(a,b,c,d):
    res1=max2(a,b)
    res2=max2(res1,c)
    res3=max2(res2,d)
    return res3
res=max4(1,2,3,4)
print(res)

# 函数的嵌套定义：在定义一个函数的过程中，再定义其它函数
def f1():
    def f2():
        pass

6、闭包函数（名称空间以及作用域+函数对象+函数嵌套）

# 什么是闭包函数
# 闭：内嵌函数
# 包：对外层局部名称空间中变量的引用
def f1(x):
    def f2():
        print("f2",x)
    return f2

f=f1(10)
f()

五、装饰器

1、定义与模板

# 装饰器：在不修改被装饰对象源代码以及调用方式的前提下，为被装饰对象添加新功能
def outter(fun):
    def wrapper(*args,**kwargs):
        # 1.被装饰对象原有功能
        # 2.增加的新功能
        res=fun(*args, **kwargs)
        return res
    return wrapper

2、装饰器实现思路

# 为下面的函数增加一个功能，计时函数的运行时间
# import time
# def index(x,y):
#     time.sleep(3)
#     print("index {} {}".format(x,y))

# 方案一：
# import time
# def index(x,y):
#     start=time.time()
#     time.sleep(3)
#     print("index {} {}".format(x,y))
#     stop=time.time()
#     print(stop-start)
# index(11,22)
# 废弃：改动了源代码

# 方案二：
# import time
# def index(x,y):
#     time.sleep(3)
#     print("index {} {}".format(x,y))
#
# start=time.time()
# index(11,22)
# stop=time.time()
# print(stop-start)
#
# start=time.time()
# index(33,44)
# stop=time.time()
# print(stop-start)
# 废弃：当有多处时，代码冗余

# 方案三：
# import time
# def index(x,y):
#     time.sleep(3)
#     print("index {} {}".format(x,y))
#
# def wrapper():
#     start=time.time()
#     index(11,22)
#     stop=time.time()
#     print(stop-start)
#
# wrapper()

# 优化：写活被装饰对象的参数
# import time
# def index(x,y,z):
#     time.sleep(3)
#     print("index {} {} {}".format(x,y,z))
#
# def wrapper(*args,**kwargs):
#     start=time.time()
#     index(*args,**kwargs)
#     stop=time.time()
#     print(stop-start)
#
# wrapper(11,12,13)

# 优化:写活被装饰对象
# import time
# def index(x,y,z):
#     time.sleep(3)
#     print("index {} {} {}".format(x,y,z))
#
# def outter(func):
#     def wrapper(*args,**kwargs):
#         start=time.time()
#         func(*args,**kwargs)
#         stop=time.time()
#         print(stop-start)
#     return wrapper
#
# index=outter(index)
# index(1,2,3)

# 优化:将wrapper的返回值,与被装饰对象的返回值保持一致
# import time
# def index(x,y,z):
#     time.sleep(3)
#     print("index {} {} {}".format(x,y,z))
#     return 123
# res=index(1,2,3)
# print(res)
#
# def outter(func):
#     def wrapper(*args,**kwargs):
#         start=time.time()
#         res=func(*args,**kwargs)
#         stop=time.time()
#         print(stop-start)
#         return res
#     return wrapper
# index=outter(index)
#
# res=index(1,2,3)
# print(res)

3、@装饰器名字

import time
# 装饰器
def outter(func):
    def wrapper(*args,**kwargs):
        start=time.time()
        res=func(*args,**kwargs)
        stop=time.time()
        print(stop-start)
        return res
    return wrapper

# 在被装饰对象正上方的单独一行写@装饰器名字
@outter             # 等效为:index=outter(index)
def index(x,y,z):
    time.sleep(3)
    print("index {} {} {}".format(x,y,z))
    return 123

@outter             # 等效为:index=outter(home)
def home():
    pass

4、有参装饰器

# 有参装饰器
def outter(db_type):
    def deco(func):
        def wrapper(*args,**kwargs):
            # 加个认证功能
            username=input("your name——>> ").strip()
            pwd=input("your password——>> ").strip()
            if db_type=="file":
                # 从文件中取出username和pwd
                if username=="cang" and pwd=="123":
                    res=func(*args,**kwargs)
                    return res
                else:
                    print("认证失败")
            elif db_type=="mysql":
                # 从数据库中取出username和pwd
                if username=="cang" and pwd==123:
                    res=func(*args,**kwargs)
                    return res
                else:
                    print("认证失败")
            else:
                print("传入的认证方式错误")
        return wrapper
    return deco

@outter("file")
def index(x,y):
    print("index: {} {} ".format(x,y))
index(1,2)

@outter("mysql")
def withdraw(x,y):
    print("index: {} {} ".format(x,y))
withdraw(1,2)

# def deco(func):
#     def wrapper(*args,**kwargs):
#         res=func(*args,**kwargs)
#         return res
#     wrapper.__name__=func.__name__
#     wrapper.__doc__=func.__doc__
#     return wrapper

# wraps装饰器补充
from functools import wraps
def deco(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        res=func(*args,**kwargs)
        return res
    return wrapper

@deco
def index(x,y):
    """这是函数注解说明"""
    print("index: {} {}".format(x,y))
    return 123

print(index.__name__)
print(index.__doc__)

5、叠加多个装饰器（了解）

def deco1(func1):                       # func1=wrapper2
    def wrapper1(*args,**kwargs):
        print("执行deco1.wrapper下的代码")
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def deco2(func2):                       # func2=wrapper3
    def wrapper2(*args,**kwargs):
        print("执行deco2.wrapper2下的代码")
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def deco3(x):
    def outter(func3):                  # func3=index
        def wrapper3(*args,**kwargs):
            print("执行deco3.outter.wrapper下的代码")
            res3=func3(*args,**kwargs)
            return res3
        return wrapper3
    return outter

# 加载顺序自下而上
@deco1                  # index=wrapper1
@deco2                  # index=wrapper2
@deco3(111)             # index=wrapper3
def index(x,y):
    print("index: {} {}".format(x,y))

index(1,2)              # wrapper1(1,2)

六、迭代器

d={"a":1,"b":2,"c":3}                   # 字符串、列表、元组、字典、集合是可迭代对象，文件对象是迭代器对象

d_iterator=d.__iter__()                 # 调用可迭代对象的__iter__方法，将其转换成迭代器对象
while True:
    try:
        print(d_iterator.__next__())    # 调用迭代器对象的__next__方法，拿到一个返回值
    except StopIteration:
        break                           # 捕捉到异常（值取尽了拿不到返回值），结束循环

for k in d:
    print(k)

'''
优点：
1、为序列和非序列类型提供了一种统一的迭代取值方式。
2、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值。
            就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流。
            就其它容器类型如列表，需要把所有的元素都存放于内存中，可以存放值的个数是有限的。
缺点：
1、除非取尽，否则无法获取迭代器的长度。
2、迭代器产生的唯一目标就是重复执行next方法取到下一个值，直到取尽。否则会停留在某一位置，等待下一次调用next。
'''

七、生成器 

# 生成器：自定义迭代器
def func():
    print("第一次")
    yield 1
    print("第二次")
    yield 2
    print("第三次")
    yield 3
    print("第四次")
    
# 函数内存在yield关键字，调用函数时并不会执行函数体代码
# 会返回一个生成器对象，即为自定义的迭代器
g=func()   

# 调用生成器的next方法会触发函数体代码的运行，然后遇到yield停下来
# 将yield后的值当作本次调用的结果返回
res=g.__next__()
print(res)

print(next(g))
print(next(g))
print(next(g))      # 取不到返回值就抛出异常

# yield表达式
d=[]
def func(name):
    print("道哥{}蹲下!".format(name))
    while True:
        x=yield d
        print("道哥{}吃{}".format(name,x))
        d.append(x)



g=func("wei")           # 函数内存在yield关键字，调用函数时不会执行代码，返回一个生成器对象

res=g.send(None)        # 相当于next(g)，执行函数体代码碰到yield停下，返回yield后的值
print(res)

res=g.send("骨头")      # 将send的值传给yield，执行函数体代码碰到yield停下，返回yield后的值
print(res)

res=g.send("肉肉")
print(res)

g.close

八、表达式

1、三元表达式

# 三元表达式:
# 条件成立时要返回的值 if 条件 else 条件不成立时要返回的值
def func(x,y):
    if x>y:
        return x
    else:
        return y
res=func(1,2)
print(res)

x=1
y=2
res=x if x>y else y
print(res)

2、列表生成式

# 列表生成式：
# 条件成立时的值 for 变量名 in 可迭代对象 if 条件

# 将列表内后缀为"dsb"的字符串取出来
l=["a_dsb","b_dsb","c_dsb","d"]
new_l=[]
for name in l:
    if name.endswith("dsb"):
        new_l.append(name)
print(new_l)

# 将列表内后缀为"dsb"的字符串取出来
l=["a_dsb","b_dsb","c_dsb","d"]
new_l=[name for name in l if name.endswith("dsb")]
print(new_l)

# 将列表中的字符串小写替换成大写
l=["a_dsb","b_dsb","c_dsb","d"]
new_l=[name.upper() for name in l]
print(new_l)

# 将列表中的字符串去除"dsb"后缀
l=["a_dsb","b_dsb","c_dsb","d"]
new_l=[name.split("_")[0] for name in l]
print(new_l)

3、其它生成式 

# 字典生成式
keys=["k1","k2","k3"]
d={k:None for k in keys}
print(d)
items=[("k1",1),("k2",2),("k3",3)]
d={k:v for k,v in items if k!="k3"}
print(d)

# 集合生成式
keys=["k1","k2","k3"]
d={k for k in keys}
print(d)


# 生成器表达式
g=(i for i in range(3))
print(g,type(g))
print(next(g))
print(next(g))
print(next(g))
# 计算文件字符长度
with open(r"a.txt",mode="rt",encoding="utf-8") as f:
    res=0
    for line in f:
        res+=len(line)
    print(res)
# 用生成器表达式与sum()改写
with open(r"a.txt",mode="rt",encoding="utf-8") as f:
    l=(len(line) for line in f)
    res=sum(l)
    print(res)

九、递归函数

1、定义

# 1、直接或间接地调用自身
# 直接调用本身：
def f1():
    print("hhh")
    f1()
f1()
# 间接调用本身：
def f1():
    print("aaa")
    f2()
def f2():
    print("bbb")
    f1()
f1()

# 2、具有结束条件
def f(n):
    if n==10:
        return 
    print(n)
    n+=1
    f(n)
f(0)

2、递归的两个阶段

# 递推：一层一层调用下去
# 回归：当遇到终止条件，然后一层一层返回

def age(n):
    if n==1:
        return 18
    return age(n-1)+10
age(5)
# age(5)=age(4)+10
#        age(4)=age(3)+10
#               age(3)=age(2)+10
#                      age(2)=age(1)+10
#                             age(1)=18

3、递归的应用

# 将列表中的值打印出来
l=[1,2,[3,[4,5,[6,7,[8,9,[10]]]]]]
def f(list1):
    for x in list1:
        if type(x) is list:
            f(x)
        else:
            print(x)
f(l)



# 二分法
l=[-2,3,5,7,9,23,42,53,66,111]

def search(list1,m):
    print(list1)
    if len(list1)==0:
        print("找的值不存在")
        return
    mid_index=len(list1)//2
    mid_val=list1[mid_index]
    if m>mid_val:
        list1=list1[mid_index+1:]
        search(list1,m)
    elif m<mid_val:
        list1=list1[:mid_index]
        search(list1,m)
    else:
        print("找到了，索引为{}".format(mid_index))

search(l,-3)

十、匿名函数

1、lambda

'''
lambda 形参:函数体代码
'''

lambda x,y:x+y

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

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

2、结合max、min、sorted、map、filter、reduce

salaries={
    "aaa":3000,
    "bbb":7000,
    "ccc":10000,
    "ddd":2000
}
# ============================>>>max
max(salaries)
max(salaries,key=lambda k:salaries[k])          # 指定比较基准，返回最大的对象

# ============================>>>min
min(salaries)
min(salaries,key=lambda k:salaries[k])          # 指定比较基准，返回最小的对象

# ============================>>>sorted
sorted(salaries)
sorted(salaries,key=lambda k:salaries[k])       # 指定排序基准，返回排序好的列表

# 以下皆为了解
# map
l=["a","b","c"]
res=map(lambda name:name+"_dsb",l)              # 返回生成器对象
print(next(res))

# filter
l=["a_dsb","b_dsb","c"]
res=filter(lambda k:k.endswith("_dsb"),l)       # 返回生成器对象
print(next(res))

# reduce
from functools import reduce
reduce(lambda x,y:x+y,[1,2,3,4],10)             # 返回20
reduce(lambda x,y:x+y,["a","b","c"],"hello")    # 返回helloabc

十一、内置函数

time=__import__("time")             # 从文件中取出字符串，导入该字符串表示的模块
time.sleep(1)

class Foo:
    pass
obj=Foo()
print(isinstance(obj,Foo))
print(isinstance("aa",str))         # 类型判断推荐使用isinstance

res=eval("1+2")                     # 执行字符串中的表达式
print(res)
res=eval("{'k1':2}")
print(res,type(res))

for v in enumerate(["a","b","c"]):
    print(v)

class Foo:
    k1=1
obj=Foo()
print(dir(obj))                     # obj.那些属性

print(divmod(1000,33))              # (30, 10)

v1="hello"
v2=[111,222,33,444,555,666]
res=zip(v1,v2)
print(list(res))

abs
all
any
bin
oct
hex
int
str
list
tuple
dict
set
frozenset
bool
bytes
complex
callable
chr
ord
classmethod
staticmethod
setattr
getattr
delattr
hasattr
help
id
type
input
print
max
min
sum
object
issubclass
super
property
hash
iter
next
len
globals
locals        # 返回当前位置的全部局部变量
range
sorted
reversed
open
round         # 四舍五入
exec          # ...
filter        # 会根据提供的函数对指定的序列做过滤
map           # 会根据提供的函数对指定的序列做映射
pow           # 10 **2 % 3
repr          # 交互式环境自动打印
slice         # l[1:3:1]