一、切片

在list、tuple、字符串中获取其中某个或某些元素时，可以使用循环获取，但python提供了一种更加简洁的方式—-切片

  1. 使用切片的形式
  1. list = [1, 2, 3, 45, 6]
  2. # 认识切片
  3. # 形式list[x:y:z]  x为开始索引， y为结束索引（不会取到结束索引的元素）， z为跨度（即隔z个元素后才切割取值）
  4. print(list[0:len(list):1])
  1. 使用
  1. # 取偶数索引的元素
  2. print(list[1::2])
  4. # 正向取前三个（索引值为0，1，2.....n）, 可以省略跨度，默认值为1
  5. print(list[:3])
  7. # 逆向切片(从后往前-1,-2,-3.....-n) ；取前三个
  8. print(list[:-2])
  10. # 只写[:]就可以原样复制一个list：
  11. print(list[:])
  1. 例子：
  1. # 利用切片操作，实现一个trim()函数，去除字符串首尾的空格，注意不要调用str的strip()方法：
  4. def trim(s):
  5.     if s[:1] != " " and s[-1:] != " ":  # 如果首尾都没有空格，则返回字符串
  6.         return s
  7.     elif s[:1] == " ":  # 如果前面有则把空格去掉，再递归检查
  8.         return trim(s[1:])
  9.     # elif s[-1:] == " ":
  10.     else:  # 如果尾部有则把空格去掉，再递归检查
  11.         return trim(s[:-1])
  14. # 测试:
  15. if trim('hello  ') != 'hello':
  16.     print('测试失败!')
  17. elif trim('  hello') != 'hello':
  18.     print('测试失败!')
  19. elif trim('  hello  ') != 'hello':
  20.     print('测试失败!')
  21. elif trim('  hello  world  ') != 'hello  world':
  22.     print('测试失败!')
  23. elif trim('') != '':
  24.     print('测试失败!')
  25. elif trim('    ') != '':
  26.     print('测试失败!')
  27. else:
  28.     print('测试成功!')

二、迭代

  1. 迭代的形式
  1. # list的迭代, 打印元素
  2. list_ = [1, 2, 3, 4, 5]
  3. for i in list_:
  4.     print(i)
  6. # 字典迭代
  7. dict_ = {'name': 'a1', 'age': 10, 'weight': 55}
  8. # 字典默认迭代键
  9. for key in dict_:
  10.     print(key)
  12. # 迭代字典的值
  13. for value in dict_.values():
  14.     print(value)
  16. # 键值一起迭代
  17. for key, value in dict_.items():
  18.     print("key=" + key + " value=" + str(value))
  20. # 元组的迭代
  21. tuple_ = (1, 2, 'v')
  22. for t in tuple_:
  23.     print(t)
  25. # 字符串
  26. str_ = "ABCD"
  27. for s in str_:
  28.     print(s)
  1. 判断可迭代的对象
  1. # 通过collections模块的Iterable类型判断一个对象是可迭代对象;
  2. from collections import Iterable
  4. if (isinstance("abc", Iterable)):
  5.     print("str 可迭代")
  6. if (isinstance([1, 2, 3], Iterable)):
  7.     print("list 可迭代")
  8. if (isinstance({'name': 'a1', 'age': 10, 'weight': 55}, Iterable)):
  9.     print("dict 可迭代")
  10. if (isinstance(('a', 'b', 'c'), Iterable)):
  11.     print("tuple 可迭代")
  12. if (isinstance(123, Iterable)):
  13.     print("int 可迭代")
  15. # 结果
  16. str 可迭代
  17. list 可迭代
  18. dict 可迭代
  19. tuple 可迭代
  1. 使用Python内置的enumerate函数实现下标迭代方式
  1. for i, value in enumerate(['A', 'B', 'C']):
  2.     print(i, value)
  3. # 结果
  4. 0 A
  5. 1 B
  6. 2 C

三、列表生成式

  1. 形式
  1. # 生成1-9的列表
  2. list_ = [x for x in list(range(1, 10))]
  3. print(list_)
  1. 特性
  2. # for前的x为得出的结果, 可以进行操作
  3. # 结果的平方
  4. list_2 = [x * x for x in list(range(1, 10))]
  5. print(list_2)
  7. # for循环后可添加条件
  8. # 1-9列表中，筛选出偶数
  9. list_3 = [x for x in list(range(1, 10)) if (x % 2 == 0)]
  10. print(list_3)
  12. # 也可以有多层for循环
  13. # 两层for循环实现打印乘法口诀表
  14. list_4 = [str(n) + " * " + str(m) + "=" + str(n * m) for n in list(range(1, 10)) for m in list(range(1, 10))]
  15. print(list_4)

四、生成器

  1. 创建方式
  1. # 1. 只要把一个列表生成式的[]改成()， 就创建了一个generator：
  2. g = (x * x for x in range(10))
  3. print(type(g))
  4. '''
  5. g类型为 <class 'generator'>
  6. '''
  9. # 2. 使用函数方式创建generator
  10. def odd():
  11.     print('step 1')
  12.     yield 1
  13.     print('step 2')
  14.     yield (3)
  15.     print('step 3')
  16.     yield (5)
  1. 打印出generator的每一个元素—-使用next()函数或迭代
  1. g = (x for x in range(10))
  2. # 使用next()
  3. print("使用next()")
  4. print(next(g))
  6. # 迭代
  7. print("使用迭代")
  8. for n in g:
  9.     print(n)
  1. 注意：
  • generator的执行顺序：

函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

  • 用while循环调用generator时，发现拿不到generator的return语句的返回值。(没搞明白)
  1. # 如果想要在while循环调用generator时，拿到返回值，
  2. # 必须捕获StopIteration错误，
  3. # 返回值包含在StopIteration的value
  4. g = (x for x in range(10))
  5. while True:
  6.     try:
  7.         x = next(g)
  8.         print('g:', x)
  9.     except StopIteration as e:
  10.         print('Generator return value:', e.value)
  11.         break

五、迭代器

  1. 什么是迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

  1. 判断对象是否是迭代器
  1. # 使用函数 isinstance
  2. from collections import Iterator
  4. if (isinstance([], Iterator)):
  5.     print("list is Iterator without iter()")
  1. 转换为可迭代的对象，使用含函数iter()
  1. if (isinstance(iter([]), Iterator)):
  2.     print("list is Iterator with iter()")
  1. 小结：
  • 凡是可作用于for循环的对象都是Iterable类型；
  • 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
  • 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。