01_列表生成式
需求1：
1.接收变量k,a,b
s = '51 5000 10000'
# 一般方法
li1 = []
for item in s.split():
li1.append(int(item))
k,a,b = li1
print(li1)
print(k,a,b)
# 列表生成式
li2=[int(item) for item in s.split()] ## 生成式返回给变量li的是一个生成器,通过[]将其转换成列表
k,a,b = li2 ##需要数据时才从生成器中调用数据，占用内存
print(li2)
print(k,a,b)
需求2：生成一个列表，列表元素分别为[1**1,2**2,3**3,4**4...n*n]
li = []
# 一般方法
for i in range(1,8):
li.append(i**i)
print(li)
# 列表生成式
li1 = [i**i for i in range(1,8)]
print(li1)
for i in li1:
print(i)
[experssion for item in 序列 if 判断语句] ##在for循环中，若if条件成立，则experssion输出成一个列表数据类型
# 当需要输出两个条件的数据时
[experssion1 if 判断语句 else experssion2 for item in 序列]
# 找出1~8中的偶数的平方
li = [i ** 2 for i in range(1, 8) if i % 2 == 0]
print(li)
# 找出1～10之间的所有的偶数
print([i for i in range(1, 11) if i % 2 == 0])
找出1～1000之间的所有质数
def isPrime(num):
for i in range(2,num):
if num%i==0:
return False
else:
return True
print([i for i in range(1,1001) if isPrime(i)])
# s1='ABC' s2='123'(for嵌套循环)
# 生成'A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3'
print([i + j for i in 'ABC' for j in '123'])
02_列表生成式变形之for循环嵌套
需求：将3x3的矩阵转换成一堆数组
[
[1,2,3],
[4,5,6],
[7,8,9]
]
[1,2,3,4,5,6,7,8,9]
代码：
# 一般方法
li = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
resLi = []
for item1 in li: # [1,2,3] [4,5,6] [7,8,9]
for item2 in item1:
if item2 % 2 == 0:
resLi.append(item2)
print(resLi)
# 列表生成式
li=[
[1,2,3],
[4,5,6],
[7,8,9]
]
print([j for i in li for j in i])
# python内置模块chain
li=[
[1,2,3],
[4,5,6],
[7,8,9]
]
from itertools import chain ##导入chain模块
print(list(chain(*li))) ##chain(*li)解包列表内的数据成一个对象，list将对象调用成列表
03_列表生成式案例
将列表中所有内容都变成小写
li = ['dasdaFSDFSFDSF','dadDSADSAsdaDASsadas']
print([i.lower() for i in li])
找出/var/log目录中，所有以.py结尾的文件名或者目录名
import os ##导入操作系统模块
print(os.listdir('C:'))
print([filename for filename in os.listdir('C:') if filename.endswith('.py')])
04_列表生成式练习
1. 找出1～10之间所有偶数， 并且返回一个列表，（包含以这个偶数为半径的圆的面积）
# 方法一:
import math ##导入数学模块
li = []
for r in range(2, 11, 2):
square = math.pi * r * r
li.append(square)
print(li)
# 方法二：
print([math.pi * r * r for r in range(2, 11, 2)])
# 方法三：
def square(r):
"""求以r为半径的圆"""
res = math.pi *r*r
return res
print([square(r) for r in range(2,11,2)])
2. 找出1～100之间所有的质数.
"""
判断num是否为质数，如果是质数，返回True，否则返回False
什么是质数？
只能被1和本身整除的数，就是质数
方法：
依次判断num能被(2,num)整除
如果能被其中其中一个数整除，不是质数
当循环结束，都没有发现能被整除的数，那么就是质数
"""
def isPrime(num):
for i in range(2,num):
if num%i==0:
return False
else:
return True
print([i for i in range(1,101) if isPrime(i)])
05_列表生成式之腾讯笔试题
- 题目描述:
给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输
入值小于1000。
如，输入为10, 程序应该输出结果为2。（共有两对质数的和为10,分别为(5,5),(3,7)）
# [2,3,5,7]
- 输入描述:
输入包括一个整数n,(3 ≤ n < 1000)
- 输出描述:
输出对数
- 示例1 :
输入:
10
输出:
2
## 代码：
import math
def is_prime(n):
for i in range(2,int(math.sqrt(n))+1):
if n%i==0:
return False
return True
num=int(input('输入:'))
List=list(filter(is_prime,range(1,num)))
count=0
for i in range(len(List)):
for j in range(i,len(List)):
if List[i]+List[j]==num:
count+=1
break
print('输出:',count)
06_字典生成式
需求1：假设有20个学生，学生分数在60～100之间，筛选出成绩在90分以上的学生
代码：
import random
stuInfo={}
for i in range(20): ##随机生成20个学生的名字，成绩的字典
name = 'westos' + str(i)
score = random.randint(60,100)
stuInfo[name] = score
print(stuInfo)
# 用字典定义20个学生名字，成绩
# stuInfo = {'westos'+ str(i):random.randint(60,100) for
i in range(20)}
highscore = {}
for name,score in stuInfo.items(): ###判成绩大于90的学生名字，成绩
if score > 90:
highscore[name] = score
print(highscore)
# 用字典生成式
# print({name:score for name,score in stuInfo.items() if score > 90})
需求2:将所有的key值变为大写
d = dict(a=1,b=2)
new_d = {}
for i in d:
new_d[i.upper()] = d[i]
print('key转化为大写的字典:',new_d)
print({k.upper():v for k,v in d.items()})
需求3：大小写key值合并，统一以小写输出
d = dict(a=2, b=1, c=2, B=9, A=10)
# 用字典生成式
print({k.lower(): d.get(k.lower(), 0) + d.get(k.upper(), 0) for k in d})
# 一般方法
for k, v in d.items():
low_k = k.lower()
if low_k not in new_d:
new_d[low_k] = v
else:
new_d[low_k] += v
print(new_d)
07_集合生成式
# 与列表生成式类似
print({i ** 2 for i in {1, 2, 3}})
print({i ** 2 for i in {1, 2, 3, 9, 12} if i % 3 == 0})
08_生成器
1.创建生成器的第一重方式
In [7]: nums = (x*2 for x in range(10))
In [8]: nums
Out[8]: at 0x7fb2a6137fc0>
In [9]: for num in nums:
...: print(num)
...:
0
2
4
6
8
10
12
14
16
18
2.创建生成器的方法2(定义一个函数，让这个函数变成生成器)
"""
如果在调用函数的时候，发现这个函数中有yeild
那么此时，也就不是调用函数了，而是创建了一个生成器对象
"""
def creat_num(all_num):
print('~~~~~~~~~~~1~~~~~~~~~~~~~~~~~')
a,b=0,1
current_num = 0
while current_num < all_num:
print('~~~~~~~~~2~~~~~~~~~~~~~~~~~')
yield a # 相当于暂停了程序
#print(a)
print('~~~~~~~~~~~~~~3~~~~~~~~~~~~')
a,b = b,b+a
current_num += 1
print('~~~~~~~~~~~4~~~~~~~~~~~~~~~~')
obj = creat_num(5) ##调用函数，但没有执行函数，只是产生一个生成器
res=next(obj) ##执行函数到yield a，返回一个a的值后暂停
print(res) ##打印出返回的a的值
obj = creat_num(3)
ret = next(obj)
print(ret)
ret1 = next(obj)
print(ret1)
ret2 = next(obj)
print(ret2)
ret3 = next(obj)
print(ret3)
## 此时.我们发现程序会报错(告诉我们,生成器里面没有东西了)
# 在超过调用次数时，为了防止程序报错
while True:
try:
ret = next(obj)
print('obj:',ret)
except Exception as red:
print(red.value)
break
##超出调用次数时，返回None
# 两个生成器对象之前并没有任何关系
obj = creat_num(5)
print(obj)
ret = next(obj)
print(ret)
ret1 = next(obj)
print(ret1)
obj2 = creat_num(100)
print(obj2)
ret4 = next(obj2)
print(ret4)
09_生成器_send
"""
使用send唤醒程序
使用send()函数来唤醒程序执行,使用send()函数的好处是
可以在唤醒的同时向断点中传入一个附加的数据
"""
def create_num(all_num):
a,b = 0,1
current_num = 0
while current_num < all_num:
ret = yield a
print('>>>>>>>>ret>>>>>>>',ret)
a,b = b,a+b
current_num += 1
obj = create_num(100)
red = obj.send(None) ##调用函数到ret = yield a，并将a的值返回给red，同时将None赋值给ret
print(red)
red1 = obj.send('hello')
print(red1)
"""
next和send得到的都是yield后面的值
不同的是send传递值而next不传递值
注意:
不能把send放在第一个,因为send只能将值传给上一个yield所在位置
第一次执行程序是从开始执行
并没有值来接收send
如果你非要把send放在第一个,那么传递的值应该是None
"""
obj = create_num(100)
red1 = obj.send('hello')
print(red1)
生成器的应用
生成器的应用，实现多任务
import time
def task_1():
while True:
print('-----1-------')
time.sleep(0.1)
yield
def task_2():
while True:
print('-------2---------')
time.sleep(0.1)
yield
def main():
t1 = task_1()
t2 = task_2()
"""
类似于两个while True一起执行
先让t1运行一会，当t1遇到yield的时候，再返回到18行
然后执行t2,当它遇到yield的时候，再次切换到t1中
这样t1/t2/t1/t2的交替运行，最终实现了多任务---->协程
"""
while True:
next(t1)
next(t2)
main()
"""
并行(真的)：有两个任务，两个cpu，一个任务占一个cpu
并发(假的):有四个任务，两个cpu，四个任务交替占有cpu执行
"""
yield实现单线程并发
import time
def consumer(name):
print('%s 准备学习了～' %(name))
while True:
lesson = yield
print('开始[%s]了,[%s]老师来讲课了～' %(lesson,name))
def producer(name):
c1 = consumer('A')
c2 = consumer('B')
c1.__next__() ##先调用c1使后面的send能够传值
c2.__next__() ##先调用c2使后面的send能够传值
print('同学们开始上课了～')
for i in range(10):
time.sleep(1)
print('到了两个同学')
c1.send(i)
c2.send(i)
producer('westos')
"""
利用了关键字yield一次性返回一个结果，阻塞，重新开始
send 唤醒
"""
第三方函数库-greenlet
# 安装greenlet
# 在root用户下操作
/usr/local/python3/bin/pip3 install greenlet
"""
使用greenlet完成多任务
为了更好的使用协程来完成多任务，python中的greeblet模块
对其进行的封装
"""
from greenlet import greenlet
import time
def test1():
while True:
print('---A----')
gr2.switch()
time.sleep(0.5)
def test2():
while True:
print('----B----')
gr1.switch()
time.sleep(0.5)
"""
greenlet这个类对yield进行的封装
"""
gr1= greenlet(test1)
gr2 = greenlet(test2)
# 相当于开关，开启后两个函数之间能够相互切换执行
gr1.switch()
