Python学习（七）

今天药忘吃喽~ 2021-09-23 11:00 293阅读 0赞

> 学习笔记-Python
> 
> 学习地址：[https://www.liaoxuefeng.com/wiki/1016959663602400][https_www.liaoxuefeng.com_wiki_1016959663602400]
> 
> 健忘选手，做好笔记，温故而知新

*  切片
 *  迭代
 *  列表生成器
 *  生成器
 *  迭代器

**一：切片**

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

`L[0:3]`表示，从索引`0`开始取，直到索引`3`为止，但不包括索引`3`

如果第一个索引是`0`，还可以省略， L\[:3\]

**倒数取：**

**注：倒数取值别这样：L\[-1:0\]，这样拿到的是\[ \]**，而不是倒数第一个元素

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
    # 取倒数第一个元素
    print(L[-1])
    # 可以理解为-2，-1，0，0没有显示，['Bob', 'Jack']，倒数第一个元素的索引是-1
    print(L[-2:])

**间隔取：**

#创建了一个0-20的数列
    L = list(range(20))
    #前10个数，每两个取一个,[0, 2, 4, 6, 8]
    print(L[:10:2])
    #所有数，每两个取一个,[0, 2, 4, 6, 8]
    print(L[::5])
    
    #list，tuple，字符串都可以这样使用

**去掉首尾的空格：**

# def trim(str):
    #     # 拿第一个元素
    #     if str[0:1] ==" ":
    #         str = str[1:]
    #     # 拿最后一个元素
    #     if str[-1:] == " ":
    #         str = str[:-1]
    #     #这个的作用是去头去尾的空格后，还要继续判断新的头和尾是不是空格
    #     if str[:1] != " " and str[-1:] != " ":
    #         return str
    #     else:
    #         # 新的头和尾是空格，那就继续循环这样判断
    #         return trim(str)
    
    
    def trim(s):
        #拿第一个元素
        if s[:1]==' ':
            #继续递归（1-最后）
            return trim(s[1:])
        #拿最后一个元素
        elif s[-1:]==' ':
            #继续递归（1-倒数第二）
            return trim(s[:-1])
        else:
            return s

**二：迭代**

\# 迭代是通过for ... in来完成的

#dict类型也可以，但不是按照list方式存储的，迭代出来顺序可能不一样
    d = {'a': 1, 'b': 2, 'c': 3}
    for key in d:
        print(key)
    
    # 默认情况下，dict迭代的是key
    # 如果要迭代value，可以用for value in d.values()
    # 如果要同时迭代key和value，可以用for k, v in d.items()

#字符串也是可迭代对象
    for ch in 'ABC':

# 判断一个对象是可迭代对象
    # 不过这种方式在3.9用不了了好像
    from collections import Iterable
    print(isinstance([1,2,3], Iterable))

# 对list实现类似Java那样的下标循环
    # Python内置的enumerate函数可以把一个list变成索引-元素对
    for i, value in enumerate(['A', 'B', 'C']):
        print(i, value)

![20200114214146765.png][]

# for循环里，同时引用了两个变量
    for x, y in [(1, 1), (2, 4), (3, 9)]:
        print(x,y)

![20200114214316737.png][]

附加：

#对于list
    #一个空格
    a = [ ]
    print(len(a))
    # 两个空格
    b = [  ]
    print(len(b))
    # 空格在双引号里面
    c = [' ']
    print(len(c))
    d = ['',' ']
    print(len(d))

结果是0,0,1,2

# 使用迭代查找一个list中最小和最大值，并返回一个tuple
    def findMinAndMax(str):
        if len(str) == 0:
            return (None,None)
        elif len(str) == 1:
            return (str[0],str[0])
        else:
            max = str[0]
            min = str[0]
            for i in str:
                if max>i:
                    if min>i:
                        min = i
                else:
                    max = i
        return (min,max)

**三：列表生成器（List Comprehensions）**

# 创建list
    print(list(range(1, 10)))
    
    # 列表生成器
    # 偶数的平方
    print([x * x for x in range(1, 11) if x % 2 == 0])
    
    # 两层循环，生成全排列
    print([m + n for m in 'ABC' for n in 'XYZ'])
    
    # 多个变量
    # dict的items()可以同时迭代key和value
    d = {'x': 'A', 'y': 'B', 'z': 'C'}
    for k, v in d.items():
          print(k, '=', v)
    # 改下格式
    print([k + '=' + v for k, v in d.items()])
    
    
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    [4, 16, 36, 64, 100]
    ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
    x = A
    y = B
    z = C
    ['x=A', 'y=B', 'z=C']

在一个列表生成式中，`for`前面的`if ... else`是表达式，而`for`后面的`if`是过滤条件，不能带`else`

[x for x in range(1, 11) if x % 2 == 0]
    [x if x % 2 == 0 else -x for x in range(1, 11)]

# isinstance函数可以判断一个变量是不是字符串
    # 非字符串类型没有lower()方法
    L1 = ['World', 18, None]
    L2 = [s.lower() for s in L1 if isinstance(s, str)]

**四：生成器（generator）**

列表生成式可以直接创建一个列表，但如果只是访问前面一些元素，又浪费存储空间，可以使用generator。

列表生成式使用\[\]，生成器使用()，前者是list，后者是generator

# 创建生成器
    g = (x*x for x in range(5))
    # <generator object <genexpr> at 0x0000000002511DB0>
    print(g)

# generator保存的是算法，每次调用，得到下一个元素,若没有更多的元素，抛出StopIteration错误
    # 基本不使用
    print(next(g))
    
    # generator是可迭代对象
    # 一般使用该方法，而且不用关心StopIteration错误
    for i in g:
        print(i)

斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：  
1, 1, 2, 3, 5, 8, 13, 21, 34, ...

def fib(max):
        n, a, b = 0, 0, 1
        while n < max:
            # 一个函数定义中包含yield关键字,它是generator
            yield b
            # print(b)
            a, b = b, a + b
            n = n + 1
        return 'done'
    
    # 输出斐波那契数列的前3个数
    # fix(3)
    
    for n in fib(3):
        print(n)

其中a, b = b, a + b，相当于

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

这样写的好处是不用显示写出临时变量t，就能赋值。

使用了yield后，generator的函数在每次调用`next()`的时候执行，遇到`yield`语句返回，再次执行时从上次返回的`yield`语句处继续执行

区别：

# 普通函数调用返回结果
    r = abs(4)
    # 结果6
    print(4)
    # generator函数调用返回generator对象
    r = fib(3)
    # <generator object fib at 0x0000000002908200>
    print(r)

**五：迭代器**

直接作用于`for`循环的数据类型：

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

一类是`generator`，包括生成器和带`yield`的generator function

（1）这些可以直接作用于`for`循环的对象统称为可迭代对象：**`Iterable`**。

# 判断对象是否是Iterable对象
    from collections import Iterable
    # 结果是True
    rs = isinstance([], Iterable)

（2）而生成器不但作用于for循环，还能被next（）函数调用，这种被`next()`函数调用并不断返回下一个值的对象称为迭代器：**`Iterator`**

# 判断对象是否是Iterator对象
    from collections import Iterator
    # 结果是True
    rs = isinstance((x*x for x in range(2)), Iterator)

# 将list、dict、str等变成Iterator可以使用iter()函数
    # 结果是True
    rs = isinstance(iter('哈哈'), Iterator)

Python的`Iterator`对象表示的是一个数据流，它可以看成有序序列，但我们不知它的长度，只能通过`next()`函数实现按需计算下一个数据，它的计算是惰性的；Iterator可以表示无限大数据流，如全体自然数，而list不可能存储全体自然数。

（3）Python的`for`循环本质上就是通过不断调用`next()`函数实现的

for x in [1, 2, 3, 4, 5]:
        pass

等价于

# 首先获得Iterator对象
    it = iter([1, 2, 3, 4, 5])
    # 循环
    while True:
        try:
            # 获得下一个值
            x = next(it)
        except StopIteration:
            # 遇到StopIteration就退出循环
            break

[https_www.liaoxuefeng.com_wiki_1016959663602400]: https://www.liaoxuefeng.com/wiki/1016959663602400
[20200114214146765.png]: /images/20210923/72a542d0fa9e43d3934f3ae9e832f7a2.png
[20200114214316737.png]: /images/20210923/66599cd120554a218bbaffce122c3568.png