Avaren Lab

Python_高级特性

11分钟阅读

一、切片

切片是 Python 中非常强大且常用的功能，它允许您从序列类型（如列表、元组、字符串等）中提取子序列。

基本语法：sequence[start:stop:step]

  • start：起始索引（包含，从0开始索引的话可以省略）
  • stop：结束索引（不包含，如果直接到尾部可以省略）
  • step：步长（可选，默认为1）

例如：

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
print(L[0:3])
# ['Michael', 'Sarah', 'Tracy']

也可以进行负数索引：

print(L[-2:])
#['Bob', 'Jack']

控制步长：

L = list(range(100))
print(L)
# [0, 1, 2, 3, ..., 99]
print(L[::5])
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

操作字符串：

print('ABCDEFG'[:3])
# 'ABC'
print('ABCDEFG'[::2])
# 'ACEG'

反转字符串：特殊地，当步长为负数的时候表示从末尾开始往前遍历

print('ABCDEFG'[::-1])  
# GFEDCBA

二、迭代

​ 在Python中，迭代是通过for ... in来完成的，而很多语言比如C语言，迭代list是通过下标完成的，比如C等语言；Python的for循环抽象程度是要更高的，因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

​ 对于Python来说，不管有没有下标，只要是可迭代对象，一律都可以进行迭代。

  • 以 Dictionary为例
d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
	 print(key)
        
###
a
c
b
###

​ 因为dict的存储不是按照list的方式顺序排列的，所以迭代出来的结果可能顺序不一样。默认情况下，dict迭代的是key，如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

  • 判断是否可迭代

通过collections.abc模块的Iterable类型判断：

from collections.abc import Iterable
print(isinstance('abc', Iterable)) # True
print(isinstance([1,2,3], Iterable)) # True
print(isinstance(123, Iterable)) # False

Extra：

如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

for i, value in enumerate(['A', 'B', 'C']):
     print(i, value)
 
#0 A
#1 B
#2 C

上面的for循环里，同时迭代了两个变量，在Python里是很常见的，比如下面的代码：

 for x, y in [(1, 1), (2, 4), (3, 9)]:
     print(x, y)
 
#1 1
#2 4
#3 9

三、列表生成式(List Comprehension)

​ 写列表生成式的时候，把要生成的元素放在最前面，后面跟for循环，就可以把list创建出来，方便快速生成一些特殊的list。

​ 例：如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？除了正常循环生成以外，就是用列表生成式。

# 循环
L = []
for x in range(1, 11):
    L.append(x * x)
 
print(L)
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 
 
# 列表生成式
l = [x * x for x in range(1, 11)]
print(l)

​ 除了正常这样的列表生成式之外，还可以加上if...else语句进行一个筛选或者计算。

  • 在for之前：if...else是一个表达式【不能少else】
print([x if x % 2 == 0 else -x for x in range(1, 11)])
#[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
  • 在for之后：if...else是一个筛选条件【不能加else】
priny([x for x in range(1, 11) if x % 2 == 0])
# [2, 4, 6, 8, 10]

四、生成器

​ 通过列表生成器我们可以快速创建一个列表。但是受到内存限制，我们创建的列表容量是有限的。所以，当要创建一个大容量的列表，但是仅仅需要访问前面几个元素，那后面的大多数空间都浪费了；这个时候就需要让列表元素可以按照某种算法推算出来，这样就不需要创建完整的list，从而节省空间。这种边循环边计算的机制，称为生成器：generator。

  • 方法一：要创建一个generator，有很多种方法。第一种方法很简单，==只要把一个列表生成式的[]改成()==，就创建了一个generator；
L = [x * x for x in range(10)]
print(L)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
g = (x * x for x in range(10))
print(g)
#<generator object <genexpr> at 0x1022ef630>

​ 如果需要一个个打印出来生成器的元素，可以用next()函数，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

​ 大部分时候，我们都是用for循环，基本上不会调用next()因为generator也是可迭代对象。

  • 方法二：函数实现；如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。即：如果一个函数==定义中包含yield关键字==，那么这个函数就是一个generator函数。
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

Tip：代码中的a, b = b, a + b语句比较特殊，是Python的一种特殊赋值方式，多重赋值语句，相当于下列操作：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

​ 执行流程：generator和普通函数执行流程是不一样的。普通函数就是顺序执行，遇到return语句或者最后一行函数语句就返回；而generator函数在每次调用next()的时候执行，遇到yield语句返回，再次执行的时候从上次返回的yield语句处继续执行。

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
 
o = odd()
next(o)
#step 1
#1
next(o)
#step 2
#3
next(o)
#step 3
#5
next(o)
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#StopIteration

Tips：调用generator函数会创建一个generator对象，多次调用generator函数会创建多个相互独立的generator。所以需要避免每次直接调用generator函数，而是调用一次函数后，每次调用创建出来的generator对象。

#错误示范，这样每次都只会执行第一步
next(odd())
step 1
1
 
#正确写法，调用创建出来的对象
g = odd()
next(g)
#step 1
#1

​ 回到fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

g = fib(6)
while True:
     try:
         x = next(g)
         print('g:', x)
     except StopIteration as e:
         print('Generator return value:', e.value)
         break
###
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
###

至于如何捕获异常详见

五、迭代器

​ 我们已经知道，可以作用于for循环的数据类型有以下几种：

​ 一类是集合数据类型，如list、tuple、dict、set、str等；

​ 一类是generator，包括生成器和带yield的函数

​ 这些可以直接作用于for循环的对象统称为可迭代对象：Iterable，我们可以使用函数isinstance()判断一个对象是否是可迭代对象。

​ 其中生成器不但可以作用域for循环，还可以被next()函数不断调用返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

​ 需要注意的是：迭代器一定是可迭代对象，但是可迭代对象不一定是迭代器。生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。 ​ 原因是：Python中的Iterator对象表示的是一个数据流，它可以被next()函数调用并不断返回下一个数据，直到抛出StopIteration错误，它甚至可以表示一个无限大的数据流，例如全体自然数。所以迭代器的计算是惰性的，只有在需要的时候才会计算下一个数据。我们可以看成是一个有序序列，但是我们不知道序列的长度，只有通过不同的计算下一个数据。

​ 凡是可作用于for循环的对象都是Iterable类型

​ 凡是可作用于next()函数的对象都是Iterator对象

关系图谱