python3高级特性

高级特性

代码越少、开发效率越高

切片

• 作用 
  取list或tuple的部分元素

• 语句

  1. 定义

     1.>>> L = list(range(100))
     2.>>> L
     3.[0, 1, 2, 3, ..., 99]
     

  2. 取前十个数

     1.>>>L[:10]
     2.[0,1,2,3,4,5,6,7,8,9]
     

  3. 取后十个数

     1.>>> L[-10:]
     2.[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
     

  4. 取中间十个数

     1.>>> L[10:20]
     2.[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
     

  5. 前十个数，每两个取一个

     1.>>> L[:10:2]
     2.[0, 2, 4, 6, 8]
     

  6. 所有数，每五个取一个

     1.>>> L[::5]
     2.[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
     

  7. 复制

     1.>>> L[:]
     2.[0, 1, 2, 3, ..., 99]
     

• 注意 
  
  1. list切片操作后，结果仍是list
  2. tuple切片操作后，结果仍是tuple
  3. 字符串也可以用切片操作，结果仍是字符串

迭代

• 作用 
  用for...in循环来遍历这个list或tuple

• 语句

  1. 循环迭代list或tuple

     1.>>>w=[1,2,3]
     2.>>>for i in w:
     3....     print(key)
     4....
     5.1
     6.2
     7.3
     

  2. 循环迭代dict,迭代顺序可能不一样

     1.>>> d = {'a': 1, 'b': 2, 'c': 3}
     2.>>> for key in d:
     3....     print(key)
     4....
     5.a
     6.c
     7.b
     

     默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

  3. 循环迭代字符串 
     

     1.>>> for ch in 'ABC':
     2....     print(ch)
     3....
     4.A
     5.B
     6.C
     

• 注意

  1. 判断一个对象是否可迭代 
     方法是通过collections模块的Iterable类型判断

     1.>>> from collections import Iterable
     2.>>> isinstance('abc', Iterable) # str是否可迭代
     3.True
     4.>>> isinstance([1,2,3], Iterable) # list是否可迭代
     5.True
     6.>>> isinstance(123, Iterable) # 整数是否可迭代
     7.False
     

  2. 用for循环同时迭代索引和元素本身

     1.>>> for i, value in enumerate(['A', 'B', 'C']):
     2....     print(i, value)
     3....
     4.0 A
     5.1 B
     6.2 C
     

  3. 同时迭代两个数

     1.>>> for s in[(1,1),(2,3),(3,4)]:
     2....     print(s)
     3....
     4.(1, 1)
     5.(2, 3)
     6.(3, 4)
     7.>>> for x,y in[(1,1),(2,3),(3,4)]:
     8....     print(x,y)
     9....
     10.1 1
     11.2 3
     12.3 4
     

列表生成式

• 作用 
  简单却强大的可以用来创建list的生成式。

• 语句

  1. 如果要生成[1x1, 2x2, 3x3, …, 10x10]怎么做

     1.>>> [x * x for x in range(1, 11)]
     2.[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
     

  2. 用for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方

     1.>>> [x * x for x in range(1, 11) if x % 2 == 0]
     2.[4, 16, 36, 64, 100]
     

  3. 使用两层循环，可以生成全排列

     1.>>> [m + n for m in 'ABC' for n in 'XYZ']
     2.['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
     

  4. 列表生成式也可以使用两个变量来生成list

     1.>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
     2.>>> [k + '=' + v for k, v in d.items()]
     3.['y=B', 'x=A', 'z=C']
     

• 注意

  • 用isinstance()函数可以判断一个变量是不是字符串 
    

    1.>>> x = 'abc'
    2.>>> y = 123
    3.>>> isinstance(x, str)
    4.True
    5.>>> isinstance(y, str)
    6.False
    

生成器

• 作用 
  如果列表元素过多，会占用大量内存。但是如果列表元素可以按照某种算法推算出来，那么就不用创建完整的list，在python中可以通过一种一边循环一边计算的：generator的生成器机制。

• 语句

  1. 把列表生成器的[]改成()

     1.>>> g = (x * x for x in range(10))
     2.>>> for n in g:
     3....     print(n)
     4.... 
     5.0
     6.1
     7.4
     8.9
     9.16
     10.25
     11.36
     12.49
     13.64
     14.81
     

  2. 使用yield这个关键字

     • 一般的斐波那契数列写法

       1.def fib(max):
       2.n, a, b = 0, 0, 1
       3.while n < max:
       4.    print(b)
       5.    a, b = b, a + b
       6.    n = n + 1
       7.return 'done'
       

     • 使用生成器的写法

       1.def fib(max):
       2.    n, a, b = 0, 0, 1
       3.    while n < max:
       4.          yield b
       5.          a, b = b, a + b
       6.          n = n + 1
       7.    return 'done'
       

       1.>>> for n in fib(6):
       2....     print(n)
       3....
       4.1
       5.1
       6.2
       7.3
       8.5
       9.8
       

• 注意

  • 创建了generator后，调用next(),可能会出现StopIteration的错误，所以都是通过for循环来迭代它。
  • 在generator的函数中，每次调用next()的时候，遇到yield语句就返回，所以最后发现拿不到return语句的返回值，要拿到就得捕获StopIteration错误。 
    

    1.>>> g = fib(6)
    2.>>> while True:
    3....     try:
    4....         x = next(g)
    5....         print('g:', x)
    6....     except StopIteration as e:
    7....         print('Generator return value:', e.value)
    8....         break
    9....
    10.g: 1
    11.g: 1
    12.g: 2
    13.g: 3
    14.g: 5
    15.g: 8
    16.Generator return value: done
    

迭代器

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

• 语句

  1. 使用isinstance()判断一个对象是否是Iterator对象

     1.>>> from collections import Iterator
     2.>>> isinstance((x for x in range(10)), Iterator)
     3.True
     4.>>> isinstance([], Iterator)
     5.False
     6.>>> isinstance({}, Iterator)
     7.False
     8.>>> isinstance('abc', Iterator)
     9.False
     

  2. 把list、dict、str等Iterable变成Iterator可以使用iter()函数

     1.>>> isinstance(iter([]), Iterator)
     2.True
     3.>>> isinstance(iter('abc'), Iterator)
     4.True
     

• 注意 
  为什么list、dict、str等数据类型不是Iterator?

  这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。