python 第十三章 内置函数二+重要函数+闭包

内置函数

# abs绝对值，返回的都是正数
print(abs(-11))
# 输出 11

# 列表元素转成绝对值，再以列表输出
print([abs(i)for i in [-1,-2,-3]])
# 输出[1, 2, 3]
lst = [-1,-2,-3]
print([abs(i) for i in lst])

# enumerate枚举，用于标序号
# enumerate("可迭代对象","序号的起始值")# 默认的起始值是0
# 例如将列表元素转成元组
print([i for i in enumerate([1,2,3,4],10)])
# 输出[(10, 1), (11, 2), (12, 3), (13, 4)]
lst = [1,2,3,4]
print([i for i in enumerate(lst,10)])

lst = [1,2,3,4]
new_lst = []
for i in enumerate(lst,10):
    new_lst.append(i)
print(new_lst)


# 求最大值，后跟可迭代对象
print(max(1,2,3,4,5))
print(max("1,2,3,4,5"))
print(max([1,2,3,4,5]))
# 输出5

# 求最小值
print(min(1,2,3,4,5))
print(min("1,2,3,4,5"))
print(min([1,2,3,4,5]))
# 输出1

# 求和
print(sum((1,2,3)))
print(sum([1,2,3]))
# 输出6
print(sum([1,2,3],5))
# 输出11

# 范围
g = range(0,10) # python3中是可迭代对象
g.__iter__()

range(0,10) # python2获取的是一个列表
#xrange(0,10) # 获取的是一个可迭代对象

#sep,end多个元素的连接符
# \t 是换行，\n 是空格
print(sep="",end="\n")
print(1,2,3,sep="")
print(1,end="\n")
print(2,end=" ")
print(3)
# 输出
# 1   2   3
# 1
# 2 3

print(12345,file=open("t1.txt","w",encoding="utf-8"))

# 求长度
lst = [1,2,3,5]
print(len(lst))
# 输出 4

# list转元素
print(list("alex"))
# 输出 ['a', 'l', 'e', 'x']

# 转元组
list()

# 查看当前函数的方法
list()# 是函数
print(dir(list))

# 将只有两个元素的元组转成字典
print(dict(((1,2),(2,3),(3,4))))
# 输出 {1: 2, 2: 3, 3: 4}
# 给字典赋值
print(dict(key=1,a="alex"))
# 输出{'key': 1, 'a': 'alex'}


# 强转
str()

# zip拉链，按照最少的进行合并按照索引拉

lst1 = [1,2,3,4,5]
lst2 = ['a',"b","c","d","f","e"]
print(list(zip(lst1,lst2)))
# 输出 [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'f')]

lst1 = [1,2,3,4,5]
lst2 = ['a',"b","c","d","f","e"]
print(dict(list(zip(lst1,lst2))))# 面试题
# 输出{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'f'}

lst1 = {"k":"a","k2":"b"}
lst2 = [1,2,3,4,5]
lst3 = []
list(zip(lst1,lst2))

重要函数

def func():
    print(123)
    return "您好"
func()
# 输出 123

def func(a,b):
    return a+b
print(func(1,2))
# 输出 3

# lambda 匿名函数--定义函数 函数名叫lambda
# x,y 形参
# :x+y 返回值，只能返回一个数据类型
f = lambda x,y:x+y
print(f(1,2))
# 输出 3
f = lambda x,y:(x,y)
print(f(1,2))
# 输出元组 (1,2)

# 一行定义一行调用
def func():
    return 1
print(func())
print((lambda x:x)(2))
# 输出 2

# 面试题
lst = [lambda i:i*i for i in range(10)]
print(lst[2](2))
# 结构
lst = []
for i in range(10):
    def func(i):
        return i*i
    lst.append(func)
print(lst[2](2))
# 输出9

# 10个函数地址
lst = [lambda i:i*i for i in range(10)]
print(lst[2](2))
# 输出4

# 冒号前没有形参不会报错
lst = [lambda :i*i for i in range(10)]
print(lst[2]())
# 输出 81


# list的底层是for
for i in range(10):
    pass
print(i)

lst = []
for i in range(10):
    def func():
        return i*i
    lst.append(func)
print(lst[2]())
# 输出81

# 一行函数
# 形参可以不写
# 返回值必须写，返回值只能返回一个数据类型
# 返回值可以写None
lst = list((lambda i:i*i for i in range(5)))
print(lst[1](4))
# 输出16

lst = [x for x in (lambda :i**i for i in range(5))]
print(lst[2]())
# 输出256

lst1 = []
def func():
    for i in range(5):
        def foo():
            return i**i
        yield foo

for x in func():
    lst1.append(x)
print(lst1[2]())
# 输出256

# 内置函数（重要）
print(format(13,">20")) # 右对齐
print(format(13,"<20")) # 左对齐
print(format(13,"^20")) # 居中


# 二进制十进制八进制十六进制
print(format(13,"08b")) # 2
print(format(13,"08d")) # 10
print(format(13,"080")) # 8
print(format(13,"08x")) #16

# 转成二进制
print(bin(13))
# 输出0b1101

# 过滤filter()
# func就是自己定义一个过滤条件,lst要迭代的对象
lst = [1,2,3,4,5,6]
def func(s):
    return s>3
print(list(filter(func,lst)))
# 输出 [4,5,6]

# 不加list拿到的是内存地址
lst = [1,2,3,4,5,6]
def func(s):
    return s>3
print(filter(func,lst))
# 输出 迭代器内存地址
#<filter object at 0x10087acc0>


# filter+lambda 组合最容易考到
lst = [1,2,3,4,5,6,7]
print(list(filter(lambda x:x % 2 == 1,lst)))
# 输出 [1,3,5,7]

# map() 对象映射
lst = [1,2,3,4,5,6,7]
print(list(map(lambda x:x*x,lst)))
# 对可迭代对象中每个元素进行加工
# 输出[1, 4, 9, 16, 25, 36, 49]

# reversed反转，反可变的数据类型
lst = [1,2,3,4,5,6,7]
lst.reverse()
print(lst)# 在源数据空间进行修改
# 输出[7, 6, 5, 4, 3, 2, 1]

lst1 = list(reversed(lst)) # 在重新开辟的空间进行修改
print(lst)
print(lst1)
# 输出
# [7, 6, 5, 4, 3, 2, 1]
# [1, 2, 3, 4, 5, 6, 7]
# 反转后内存地址不一样


# sorted 源数据不改变
lst = [1,112,64,55,]
print(sorted(lst)) # 升序
print(lst)


lst = [1,112,64,55,]
print(sorted(lst,reverse=True)) # 降序

dict(key=1,key1=2)
print(dict([(1,2),(2,3)]))
dic = {"key":1,"kye1":2,"key3":3}
print(sorted(dic,key=lambda  x:dic[x],reverse=True)) # key是指定排序规则

print(max([1,2,-3,4],key=abs))# key指定查找最大值的规则

#reduce 累计算
from functools import reduce
print(reduce(lambda x,y:x-y,[1,2,3,4]))

闭包

def func():
    a = 1
    def f1():
        def foo():
            print(a)
        return foo
    return f1
ret = func()
a = ret()
a()
# 相当于func()()()


# 1、在嵌套函数中，使用非全局变量且不是本层变量
# 2、闭包函数体不会消失
# 闭包的作用：
# 1、作用保证数据的纯洁度和干净度（安全性）
# 2、装饰器的本质
# 了解：
# 判断是否是闭包
print(ret.__closure__)
# 拿到闭包的ID
# 当前空间是否有变量：
print(ret.__code__.co_freevars)# 获取的是自由变量
print(ret.__code__.co_varnames)# 获取的是局部变量


# 1、在嵌套函数中，使用非全局变量且不是本层变量
avg_lst = []
def func(pirce):
    avg_lst.append(pirce)
    avg = sum(avg_lst) / len(avg_lst)
    return avg
print(func(150000))
print(func(160000))
print(func(170000))
print(func(150000))
avg_lst.append(18888888)
# 输出
# 150000.0
# 155000.0
# 160000.0
# 157500.0


def func(pirce):
    avg_lst = []
    avg_lst.append(pirce)
    avg = sum(avg_lst) / len(avg_lst)
    return avg
print(func(150000))
print(func(160000))
print(func(170000))
print(func(150000))
# 输出
# 150000.0
# 160000.0
# 170000.0
# 150000.0

def func():
    avg_lst = []  # 自由变量
    def foo(pirce):
        avg_lst.append(pirce)
        avg = sum(avg_lst) / len(avg_lst)
        return avg
    return foo
ret = func()
print(ret(150000))
print(ret(160000))
print(ret(170000))
print(ret(150000))
print(ret(180000))
print(ret.__closure__)
# (<cell at 0x0000018E93148588: list object at 0x0000018E931D9B08>,)
# 输出
# 150000.0
# 155000.0
# 160000.0
# 157500.0
# 162000.0
# (<cell at 0x102e599d8: list object at 0x102d7ef88>,)

今日总结

# 1、内置函数二
#     1.1匿名函数lambda
#         lambda 形参：返回值 - lambda x:x
#         形参可以不写，返回值必须写，返回值只能是一个数据类型
#         匿名函数的名字叫做 lambda
#     1.2 abs()
#     1.3 filter("函数","可迭代对象")写函数的时候可以指定过滤条件
#     1.4 map("函数","可迭代对象") 写函数的时候可以指定对元素的操作
#     1.5 zip("可迭代对象","可迭代对象") 返回的是一个内存地址
#     1.5 list(zip("可迭代对象","可迭代对象")) 返回的是[(1，2),(2,3)]
#     1.6 sorted("可迭代对象",key="函数名",reverse=True)key是指定排序的规则，默认是升序，写了re就是降序
#     1.7 reversed("可迭代对象") 对可迭代对象进行翻转(不改变源数据)
#     1.8 max("可迭代对象",key=abs) 找最大
#     1.9 mix("可迭代对象",key=abs) 找最小
#     1.10 sum("int,list,tuple,set") 求和
#     1.11 reduce("函数","可迭代对象") 指定累计算
#     1.12 enumerate()枚举
#     1.12 format()
#         08b - 2进制
#         08d - 10进制
#         080 - 8进制
#         08x - 16进制
#
# 高阶函数 可以指定key的是指定函数
#
#
# 2、闭包
# 闭包：嵌套函数内，使用非全局变量就是闭包
# 闭包作用：保证数据的安全性，装饰器使用
# def func():
#     a =1
#     def foo():
#         print(a)
#     return foo
# func()()
#