学习笔记：Python3 高级特性

仅为个人查阅使用，如有错误还请指正。

使用高级特性的原因就是为了代码能够简洁。代码越少，开发效率越高。

切片

列表和元组的切片操作完全相同。字符串也相差不多。

以列表为例

L = ["Harden", "Durant", "Jordan", "Curry", "O'Neal"]


print(L[0:3])             # 取前3个元素
# output:['Harden', 'Durant', 'Jordan']
print(L[:3])              # 第一个索引是0，还可以省略
# output:['Harden', 'Durant', 'Jordan']
print(L[1:3])             # 从索引1开始，取出2个元素出来
# output:['Durant', 'Jordan']
print(L[:])                   # L[:]实际上是复制，这种复制是浅拷贝。
# output:['Harden', 'Durant', 'Jordan', 'Curry', "O'Neal"]
print(L[::2])             # 第三个参数表示每N个取一个
# output:['Harden', 'Jordan', "O'Neal"]

# 倒序切片：记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

print(L[-2:])             # 取最后两个元素
# output:['Curry', "O'Neal"]
print(L[:-2])             # 删去最后两个元素
# output:['Harden', 'Durant', 'Jordan']
print(L[-3:-1])               # 从索引-3开始，取出两个元素
# output:['Jordan', 'Curry']
print(L[-4:-1:2])         # 从索引-4开始，每两个取一个，到索引-1前结束
# output:['Durant', 'Curry']

迭代

通过for循环来遍历字符串，列表，元组，字典等。遍历就相当于是迭代。

如果学过C语言或者Java语言都知道，迭代是通过下标来完成的。请看下面这个代码。
```
for (i=0; i<list.length; i++) {
    n = list[i];
}
```
而Python是通过for...in...来完成的。请看下面这个代码。
```
for i in range(1, 100):
    if i % 7 == 0:
        print(i)
```
很明显，Python的迭代是取出元素本身，而非元素的索引。

如果想要在迭代的时候获取索引，可以通过enumerate()函数来获取。
```
L = ["Harden", "Durant", "Jordan", "Curry", "O'Neal"]

for index, name in enumerate(L):
  print(index, "--", name)

# output:
0 -- Harden
1 -- Durant
2 -- Jordan
3 -- Curry
4 -- O'Neal
```
enumerate()函数本质是把L变成了

[(0, "Harden"), (1, "Durant"), (2, "Jordan"), (3, "Curry"), (4, "O'Neal")]

相当于是每个元素变成了元组。那也可以通过下标去访问。

注意：这个写法只是用来理解概念，推荐使用上面一种方法，因为方便简洁。
```
for i in enumerate(L):
  index = i[0]
  name = i[1]
  print(index, "--", name)
```
前面说了列表，元组，现在来说说一个比较特别的字典

注意：Python 3.6版本之前，字典是无序的，本环境是Python 3.6.5是有序的。
- 默认情况，字典遍历是内容是key
```
d = {"PF":"Jordan", "SF":"Durant", "C":"O'Neal", "SG":"Harden", "PG":"Curry"}

for key in d:
    print(key)

# output:
PF
SF
C
SG
PG    
```
- 如果需要遍历value，就使用d.values()。
  
  for value in d.values():
- 如果key，value都需要遍历，就使用d.items()
  
  for k, v in d.items()
如果判断一个对象是可迭代对象呢？需要通过collections模块的Iterable类型判断。

其实我觉得没有必要，把常用的记住就好了。稍微了解一下有这么一种方法就行。
```
from collections import Iterable

print(isinstance("a", Iterable))      # 字符串是
print(isinstance([a, b, c], Iterable))    # 列表是
print(isinstance(123, Iterable))      # 整数不是
```
列表生成式

就是用一行代码实现一个列表，而且这个列表是可以灵活多变的。
- 生成列表
  
  比如我们之前要生成一个列表，最傻瓜的办法就是自己创建一个。
  
  稍微好一点的就用list(range(1, 11))，然后生成1到10这10个数字。
  
  或者稍微多变一点，list(range(1, 10, 2))，然后生成1到10的奇数。
  
  如果要添加一些运算，可能需要for循环来辅助。但是循环太繁琐。
  
  这时我们可以使用Python特有的列表生成式来解决这个问题，而且是一行代码。
  - 比如要生成[1×1，2×2， 3×3，...，10×10]
    
    [x * x for x in range(1, 11)]
  - 比如要生成[1×2，3×4， 5×6， 7×8，...，99×100]
    
    [x * (x + 1) for x in range(1, 100, 2)]
- 条件过滤
  
  顾名思义就是，可以在列表生成式里面加if语句。
  
  比如，把列表中的所有字符串变成小写，非字符串元素进行过滤
```
L = [35, "Durant", "Jordan", "Curry", "O'Neal"]

print([name.lower() for name in L if isinstance(name, str)])
```
- 多层表达式
  
  利用多层循环，找出对称的3位数，例如，101，121，232，222。
  
  [x*100+y*10+z for x in range(1,10) for y in range(10) for z in range(10) if x == z]
生成器

前面提到了列表生成式，也明白列表容量会受到限制。占用太多的存储空间。

如果一个列表的元素可以通过某种算法推算出来，就可以节省很大空间，而这种机制就是生成器。

创建一个生成器，最简单的方法，就是用()来表示。例如
```
g = (x * x for x in range(10))

print(g)

# output:<generator object <genexpr> at 0x00000239CCD59C50>
# 可以看到这是一个生成器，怎么去获取呢？使用next()函数，一个一个打印出来。
print(next(g)) # output:0
print(next(g)) # output:1

# 需要注意的是：生成器保存的是算法。
# 上面的next()方法是有点傻的，如果没有元素了，还会调用异常。所以一般都是用for循环去遍历的。

for n in g:
    print(n, end=",")

# output:0,1,4,9,16,25,36,49,64,81,
```
前面说了，生成器是保存算法的，如果算法复杂，列表生成式的for循环无法实现，可以用函数来实现。

以斐波那契数列来说，它的规则是除了第一个和第二个数外，任意一个数都由前两个数相加所得。

1，1，2，3，5，8，13，21，34，55，...

很显然，用列表生成式写不出来，但是，用函数可以很方便的实现。
```
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'over'

print(fib(6))

# output:
1
1
2
3
5
8
over
```
如上所述，这个fib函数实现了这个算法规则，整体的逻辑也符合生成器。但他始终是个函数。

需要通过一个关键字yield，把函数变成生成器。这是另一种创建生成器的方法。

执行流程：第一次迭代，会执行到yield b，然后返回b的值，作为第一个迭代的返回值，那么第2次迭代，不会再去执行函数，而是从yield b的下一条语句继续执行，直到再次遇到 yield。依此类推。
```
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'over'

print(fib(6))
# <generator object fib at 0x000001494CE09A40>
for n in fib(6):
    print(n)
```
总结：生成器可以用[]或者yield，可迭代对象又多了一个（生成器）
迭代器

前面在讲生成器的时候，有一个next()函数。迭代器的定义就是通过它来的。

能够被next()函数调用，并不断返回下一个值的对象称为迭代器。

前面讲迭代的时候，讲到，如果要判断一个对象是否等着该对象，有一个isinstance()函数。

迭代器的数据类型名称是：Iterator，迭代器相当于是一个数据流。
```
from collections import Iterator


print(isinstance((x for x in range(10)), Iterator))       # 生成器是
print(isinstance([1,2,3], Iterator))                  # 列表不是
print(isinstance({"a":1, "b":2}, Iterator))               # 字典不是
print(isinstance('abc', Iterator))                        # 字符串不是
```
有些同学可能会问，列表，字典，字符串都是可迭代对象，为什么不是迭代器。

这是因为迭代器表示的是一个数据流。因为它可以被next()函数调用并不断返回下一个数据。

但是可以把可迭代对象变成迭代器，通过iter()函数。
```
L = [1,2,3,4,5]

a = iter(L)

print(next(a))
# output:1
print(next(a))
# output:2
print(next(a))
# output:3
```
总结：迭代器的两个基本方法 iter()， next()。

学习笔记：Python3 高级特性

猜你喜欢