推导式

列表推导式

  1. # 需求：创建一个0-10的列表
  3. print('===while循环创建===')
  4. list1 = []
  5. i = 0
  6. while i < 10:
  7.     list1.append(i)
  8.     i += 1  
  9. print(list1)
  11. print('\n===for循环创建===')
  12. list2 = []
  13. for j in range(10):
  14.     list2.append(j)  
  15. print(list2)
  17. print('\n===列表推导式创建===')
  18. list3 = [i for i in range(10)]            # 因为是列表推导式，返回的是一个列表数据，所以需要使用[ ],数据的读写从for循环开始，每次循环后所返回的结果值放在第一个i变量中.
  19. print(list3)
  1. # 创建0-10之间的偶数列表
  3. print('===for循环创建（带if判断）===')
  4. list1 = []
  5. for i in range(10):
  6.     if i%2 == 0:
  7.         list1.append(i)
  8. print(list1)
  10. print('\n===列表推导式创建(带步长)===')
  11. list2 = [i for i in range(0,10,2)]
  12. print(list2)
  14. print('\n===列表推导式创建（带if判断）===')
  15. list3 = [i for i in range(10) if i % 2 == 0]    # if i % 2 是一个布尔值，如：i = 4， 4 % 2 = 0 ==》 if 0 ==》 False，所以偶数就不会加入到列表中
  16. print(list3)
  1. # 多个for循环实现列表推导式（列表的嵌套）
  3. # 需求：创建一个列表，如[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]     
  4. # 分析：每个列表元素是一个元组，每个元组中的第一个元素有：1 2 -> range(1,3)  元组中第二个元素有：0 1 2 -> range(3) 
  5. print('\n===for循环创建===')
  6. list1 = []
  7. for i in range(1,3):
  8.     for j in range(3):
  9.         list1.append((i,j))         # 追加的需要是一个元组，所以要用()
  10. print(list1)
  12. print('\n===列表推导式创建===')
  13. list2 = [(i,j) for i in range(1,3) for j in range(3)]    
  14. print(list2)
  16. # 示例
  17. y_list = ['assss','dvv']
  18. list3 = [print(i) for y in y_list for i in y]       # 结果：a s s s s d v v
  1. # 带有if...else...的列表推导式
  3. # 对元素为字典的列表进行操作
  4. dict1 = {'name':'tom','salay':5000}
  5. dict2 = {'name':'lucy','salay':8000}
  6. dict3 = {'name':'jack','salay':4500}
  7. dict4 = {'name':'lily','salay':3000}
  9. list1 = [dict1,dict2,dict3,dict4]      # [{},{},{},{}]
  11. # 需求:如果薪资大于等于5000的加200, 低于等于5000的加500 (只有一个if-else)
  12. newlist = [i['salay']+200 if i['salay'] >=5000 else i['salay']+500 for i in list1]
  13. print(newlist)
  15. # 需求:如果薪资大于等于5000的加200, 低于等于5000并且大于3000的加500, 小于3000加800 (多层if-else)
  16. newlist1 = [j['salay']+200 if j['salay'] >=5000 else j['salay']+500 if 3000<j['salay']<5000 else j['salay']+800 for j in list1]
  17. print(newlist1)

集合推导式

  1. # 创建一个集合，数据为下方列表的2次方
  2. list1 = [2,2,4]
  4. set1 = {i**2 for i in list1}
  5. print(set1)                       # 注意：集合的结果是无序，不重复的

字典推导式

作用：快速合并列表为字典，提取字典中的目标数据

  1. # 需求1：创建一个字典，key是1~5之间的数字，value是这个数字的2次方
  2. dic1 = {i:i**2 for i in range(1,5)}
  3. print(dic1)                            # {1: 1, 2: 4, 3: 9, 4: 16}
  1. # 需求2：将两个列表快速的合并成一个字典
  2. list1 = ['name','age','gender']
  3. list2 = ['Tom',20,'男']
  5. list3 = ['name','age','gender','id']
  6. list4 = ['Tom',20,'男']
  8. # 当两个列表长度相同,len统计任何一个列表长度都可以.
  9. dic1 = {list1[i]:list2[i] for i in range(len(list1))}
  10. print(dic1)
  12. # 当两个列表长度不相同时，len统计列表长度最短的那一个.
  13. dic2 = {list3[i]:list4[i] for i in range(len(list4))}
  14. print(dic2)
  1. # 需求3：将字典中的key和value调换位置后存入到新的字典中
  2. d1 = {'A':100,'B':200,'C':300}  
  3. d2 = {}
  5. print('===使用for循环===')
  6. for k,v in d1.items():
  7.     d2[v] = k
  8. print(d2)
  10. print('\n===使用字典推导式===')
  11. d2 = {k:v for v,k in d1.items()}        # 字典中保存的k:v, 遍历的时候将k与v调换位置
  12. print(d2)
  1. # 需求4：提取字典中目标数据 (如下：提取字典中 value % 2 == 0 的字典数据)
  2. counts = {'A':11,'B':22,'C':33,'D':44,'E':55,'F':66}
  4. dic1 = {k:v for k,v in counts.items() if v % 2 == 0}
  5. print(dic1)                              # {'B': 22, 'D': 44, 'F': 66}

生成器

  • 通过列表推导式, 我们可以直接创建一个列表, 但是, 因受到内存容量的限制, 列表的容量也肯定是有限的;
  • 比如, 创建了一个包含100万个元素的列表, 这样不仅占用了很大的内存空间, 而且当我们只需要访问前面几个元素的时候, 后面大部分元素所占用的空间就白白浪费掉了;
  • 因此, 出现了一种机制, 可以一边循环一边推算出后面需要访问的元素, 这样就不必创建一个完整的列表, 从而也大大的节省了内存空间;
  • 这种机制称为: 生成器 (generator)

    通过列表推导式得到生成器

    ```python

    产生一个列表[0, 6, 12, 18, 24, 30…..]

使用列表推导式

list1 = [x*3 for x in range(10) if x%2 ==0 ] # 使用这种方式,就会将所有满足条件的元素全部放在列表中,占用了内存空间 print(list1)

得到生成式, 那么这个列表中可以控制产生多少个元素

list2 = (x*3 for x in range(20) if x%2 ==0) # —-> 就是将[]改成() print(type(list2))

print(list2.next()) # (方式1)通过调用next()得到元素, 调用一次产生一次元素 print(list2.next()) print(list2.next())

print(next(list2)) # (方式2)通过调用next(生成器对象), 调用一次产生一次元素 print(next(list2)) print(next(list2)) print(next(list2)) print(next(list2)) print(next(list2)) # 调用几次,就出现几次结果, 当元素个数超出了范围, 则会报’StopIteration’错误.

  2. ```python
  3. # 使用try来解决会报'StopIteration'错误的情况.
  4. list3 = (x*3 for x in range(20) if x%2 ==0) 
  6. while True:
  7.     try:
  8.         e = next(list3)
  9.         print(e)
  10.     except:
  11.         print('没有多余的元素了')
  12.         break

通过函数得到生成器

步骤

  • 定义一个函数, 函数中使用yield关键字;
  • 调用函数, 并使用一个对象来接收它, 该对象就是生成器;
  • 借助next( )方法或 next ( )方法获取元素; ```python def func(): s = 0 while True:
    1.   s += 1
    2.   yield s   # 这里相当于return s + 暂停 的功能 ,另外, 只要函数中出现了yield关键字, 说明函数就不是函数了, 变成生成器啦.

x = func() # 调用函数时, 使用一个对象来接收它, 该对象就是生成器; print(type(x))

list1 = [] for i in range(10): list1.append(next(x)) print(list1)

print(next(x))

print(next(x))

print(next(x))

print(next(x))

```