您现在的位置是：首页 > Python

当前栏目

Python学习（七）

Python 对象学习迭代

2023-03-02 10:30:20 时间

> 学习笔记-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

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python学习（七）

相关文章