python 列表推导式函数_Python进阶(四)----生成器、列表推导式、生成器推导式、匿名函数和内置函数...

Python进阶(四)----生成器、列表推导式、生成器推导式、匿名函数和内置函数

一丶生成器

本质:

​ 就是迭代器

生成器产生的方式:

​ 1.生成器函数 👇

​ 2.生成器表达式 👇

​ 3.python内置函数或者模块提供(其实1,3两种本质上差不多，都是通过函数的形式生成，只不过1是自己写的生成器函数，3是python提供的生成器函数 如: map() filter() zip()等等)

生成器与迭代器的区别:

​ 生成器是我们自己用python代码构建的.迭代器可以使用iter() , __ iter __()进行取值

​

二丶生成器函数

####只要函数中出现了yiled ,那么就是一个生成器函数.(生成器)

## 一个next 对应一个yield

def func():#当出现了yiled就是不再是函数了就是生成器函数

print(111)

print(111)

print(111)

print(111)

yield 2 # yield的作用是,yield后面的值 给了next取值

yield 3

yield 4

yield 5

ret=func() # 生成器对象 赋给变量ret

print(ret) # 生成器对象地址

print(ret.__next__())# ret执行__next__()方法 取值 2

print(ret.__next__())# ret执行__next__()方法 取值 3

print(next(ret))# ret执行__next__()方法 取值 4 next()方法的本质还是__next__()

print(next(ret))# ret执行__next__()方法 取值 5

print(next(ret)) # 当 生成器对象中没有值可以取的时候就会报错---> StopIteration

三丶yiled与return的区别

return:

​ 结束函数,给函数的执行者返回值,多个值通过元组返回,

yiled:

​ 不结束函数 ,(暂停函数) . 对应着给next返回值 , 多个值通过元组返回

# return

def func():

return 1,2,3,4

print(func())

# yield

def func():

yield 1,2,3,4 # yield后面跟一个列表就返回一个列表,返回多个值就是返回一个元组

print(func().__next__())

四丶send(了解)

# next只能获取yield生成的值，但是不能传递值。

def gen(name):

print(f'{name} ready to eat')

while 1:

food = yield

print(f'{name} start to eat {food}')

​

dog = gen('alex')

next(dog)

next(dog)

next(dog)

​

​

# 而使用send这个方法是可以的。

def gen(name):

print(f'{name} ready to eat')

while 1:

food = yield 222

print(f'{name} start to eat {food}')

​

dog = gen('alex')

next(dog) # 第一次必须用next让指针停留在第一个yield后面

# 与next一样，可以获取到yield的值

ret = dog.send('骨头')

print(ret)

​

​

def gen(name):

print(f'{name} ready to eat')

while 1:

food = yield

print(f'{name} start to eat {food}')

​

dog = gen('alex')

next(dog)

# 还可以给上一个yield发送值

dog.send('骨头')

dog.send('狗粮')

dog.send('香肠')

############# 此处, 先看看, 之后会补充含义

#send和next()区别:

# 相同点：

# send 和 next()都可以让生成器对应的yield向下执行一次。

# 都可以获取到yield生成的值。

# 不同点：

# 第一次获取yield值只能用next不能用send(可以用send(None))。

# send可以给上一个yield置传递值。

五丶生成器的应用

##生成器应用 ,现在你需要一个服装工厂给你加工2000件衣服,

###可迭代对象

#老板很实在,一下给你准备好了2000件衣服

def func()

li=[]

for i in range(1,2001):

li.append(f'{i}件衣服')

return li

print(func()) # 老板的工厂中一半的场地都用来堆积2000衣服

# 总结, 加工2000个衣服, 假如说加工一件1秒, 你现在需要2000秒才能加工完成. 而且加工完的衣服必须有地方放置. 耗时耗空间. 但是比较很直观,2000个衣服就在工厂里囤放. 换到程序角度来说: 你需要2000条数据,你的内存中就存放了2000个数据. 不管你用多少,这2000条数据就会在内存是实实在在的占2000个位置. so 占内存大.

###生成器

#加工厂老板,给你准备好了加工衣服的传送带, 夸张一些加工一件衣服1秒.

def func(): #生成器函数, 相当于创建一个加工流水线

for i in range(1,2001):

yield print(f'{i}件衣服') #yield返回数据, 相当于把加工的衣服给来拿衣服的你

gen_obj = func() #把生成器给了一个变量, 确保每次来加工时,都是这个流水线(预定)

###需求: 现在你需要200件衣服,老板立马给你制作了200件衣服 ,剩下的1800件还在待加工的状态.

for i in range(200): # 你拿了200件 ,执行了200次拿的动作

gen_obj.__next__() # 在当前的这个流水线(当前的这个生成器),每次拿一件(每次取一个数据)

###需求: 现在你需要400件衣服,老板立马从剩余的1800件衣服中又制作了400件衣服给你,现在这个流水线还剩1200

for l in range(400): # 老板从你预定的流水线继续加工400件

next(gen_obj) # 还是在当前的这个流水线(当前的这个生成器),每次拿一件(每次取一个数据)

# 总结, 你预定了2000件衣服, 老板没有给你一起直接加工出来,每当你来拿衣服的时候你需要多少个,老板给你咔咔咔把你需要多少个衣服加工出来. 优势:1.对于老板的工厂来说,不占地方, (对于程序来说,不占内存,需要多少条,就生成多少条,内存中就占这么多,并且一点数据取出来(next)就销毁.) 2.对加衣服的你也没有影响.(不影响本身程序的调用)

##创建200个生成器函数 --->相当于创建了200流水线

for i in range(200): # 生成200个生成器函数

print(func().__next__(),type(func())) # 所以每次打印的都是 1

六丶yiled与yiled from

##yield

def func():

li=[1,2,3,4]

yield li # yield 返回一个值 , 若是yield后跟多个值,就以元组的形式返回

ret =func()

print(next(ret)) # 返回一个列表的值(只能得到一个值,next只接一次,不管你是元组 或 列表都是一个值返回)

print(next(ret)) # 报错 StopIteration

##yield from 可以把 后面的可迭代的对象进行拆分,依次给next取值.

def func():

li=[1,2,3,4]

yield from li # yield from 把可迭代对象拆分, 简化for循环,

'''

#表面现象

yield 1

yield 2

yield 3

yield 4

'''

ret =func()

print(next(ret)) # 1

print(next(ret)) # 2

print(next(ret)) # 3

print(next(ret)) # 4

#### yield 与yield from 对比 ####

# yield : 对应next ,给next 返回值

# yield from 将一个可迭代对象的每一个元素返回给next

# yield from 节省代码 ,提升效率

七丶列表推导式,生成器表达式(字典的推导式,集合推导式)

列表推导式:

​ 一行代码构建一个有规律比较复杂的列表。(👇看代码.不废话)

####两种构建方式：

# 1.循环模式： [变量(加工后的变量) for 变量 in iterable]

# 2.筛选模式： [变量(加工后的变量) for 变量 in iterable if 条件]

######循环模式

##需求:循环 100以内的所有的值

#平常做法

li=[]

for i in range(1,101):

li.append(i)

print(li)

#列表推导式

print([i for i in range(1,101)])

######筛选模式 复杂程度不能超过3级

##案例1:三十以内可以被2整除的数。

print([i for i in range(1,31) if i%2==0])

#案例2: 找到嵌套列表中名字含有两个‘e’的所有名字(有难度)

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],

['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

##普通做法

li=[]

for el in names:

for el2 in el:

if el2.count('e')>=2:

li.append(el2)

print(li)

##列表推导式

print([name for el in names for name in el if name.count('e')>=2])

####列表推导式的优缺点

#优点:简单 快捷

#缺点:可读性不高,不好拍错

# 慎用,不用入迷

​

生成器表达式:

​ 一行代码构建一个生成器。(👇看代码.不废话)

####两种构建方式：

# 1.循环模式： (变量(加工后的变量) for 变量 in iterable)

# 2.筛选模式： (变量(加工后的变量) for 变量 in iterable if 条件)

####循环模式

obj=(i for i in range(10))

print(obj) # at 0x000001972E9CEF68>

#如何触发生成器(迭代器 )取值?

# 1. next() , __next__() 逐个取值

# 2 . for 循环 遍历取值 哪个简单不用多说了吧

# 3 . list

for i in obj:

print(i)

####筛选模式

obj=(i for i in range(10) if x%2==0)

print(obj) # at 0x000001999105FF68>

字典的推导式: (创建模式同上👆,一行解决)

####两种构建方式：

# 1.循环模式： {变量(加工后的变量) for 变量 in iterable}

# 2.筛选模式： {变量(加工后的变量) for 变量 in iterable if 条件}

li= ['小潘', '第三部','金馆长', '宋老板']

#普通创建字典

dic={}

for k,i in enumerate(li):

dic[k]=i

print(dic)

#字典推导式

print({k:i for k,i in enumerate(li)})

集合推导式:(创建模式同上👆,一行解决)

####两种构建方式：

# 1.循环模式： {变量(加工后的变量) for 变量 in iterable}

# 2.筛选模式： {变量(加工后的变量) for 变量 in iterable if 条件}

#集合推导式

print({i for i in range(101)})

八丶内置函数

什么是内置函数:

​ 由python解释器提供的一些特别的方法,目的提高开发效率

内置函数的数量:

​ 目前:内置函数 68种

👇看代码吧:

# -*- coding: utf-8 -*-

# Author : Ds

#eval() 剥去字符串外衣 执行代码

s1='1+3'

ret=eval(s1) #去除两端字符,数字相加得到结果

print(ret)

#exce() 也是执行代码流,

s3='''

for i in range(10):

print(i)

'''

exec(s3) # 执行for循环

##建议👉: 不要不轻易使用这个两个内置函数. 都是会将代码执行,

#假如给了一个字符串的病毒,使用这两个方法任意执行.你的电脑都会中毒

#hash() 得到一个哈希值

print(hash(123)) # 数字的哈希值还是数字

print(hash('abc'))

print(hash('abcdkjahfduai'))

#help()查看方法,

print(help(str.upper()))

#callable() 判断是不是一个可调用的对象

# 如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

def abc():

pass

a=123

b='123'

print(callable(abc),dir(abc)) # '__call__'

print(callable(a))

print(callable(b))

#bin() oct() hex()

print(bin(100)) # 将十进制转化成二进制。 逢2进一

print(oct(10)) # 将十进制转化成八进制字符串并返回。 逢8进一

print(hex(17)) # 将十进制转化成十六进制字符串并返回。 逢16进一

# 二进制

# 只有 0 1 两个数字, 逢2进一

#八进制

# 0 - 7 , 逢8进一

#十六进制

#0 - 9 , a-f表示 10 -15 逢16进一

#divmod() 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b) 分页用到

print(divmod(10, 3))

#round()保留小数位 四舍五入

print(round(3.123))

# pow() x**y x的y次幂

print(pow(2,3))

#ord() 输入字符寻找其在unicode的位置。

print(ord('a'))

print(ord('中'))

# chr() 输入位置数字找出其对应的字符

print(chr(98)) #

print(chr(20104)) # 予

#repr() 原形毕露 保留字符串格式

print('不打广告')

print(repr('不打广告'))

msg = '我叫%r' %('不打广告')

print(msg)

#all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE

#any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，

# 0,'',[],{},set(),(),None 都是False

l1 = [1, 'fgdsa', [], {1: 2}]

l2 = [0, '', [], {}]

print(all(l1)) # 判断可迭代对象元素全部都为True，返回True

print(any(l2)) # 判断可迭代对象元素只要有一个True返回True

九丶匿名函数

定义:

​ 没有名字的函数 ,lambda表达式 ,匿名函数只能构建简单的函数 ,

#普通模式, 定义函数

def func(a,b):

return a+b

#匿名函数构建

#格式---> lambda关键字 传参 : 返回值

func2=lambda x,y:x+y

print(func2(1,2))

# 写匿名函数：接收一个可切片的数据，返回索引为 0与2的对应的元素(元组形式)。

#匿名函数最常用的就是与内置函数结合使用

#1.

func3=lambda argv : tuple(argv[0:3:2])

print(func3([1,2,3,4]))

#2.

func3=lambda x : (x[0],x[2])

print(func3('你好啊的'))

#3.

func4=lambda x,y : x if x>y else y

print(func4(1,2))

#4.

func4=lambda *args : max(args)

print(func4(1,2,3,4,5))