【三】数据结构：list，tuple，string，sequence

Python初学者8号

前言

什么是数据结构？就是将基本的数据类型的对象按照某种逻辑进行封装的一种对象。目前学习的这些基本数据类型有：整型，浮点型，字符串，列表，元组，字典，函数，类等，比如下面（list也适用）

1. c=(1,1.555,'ctmd',f,Lei,[1,2,3],('x','y'))

复制代码

不同的数据结构之间有不同的特点，这些特点是为了其他的应用开发的吧。比如之前谈到的n维向量的最好使用tuple来表示，因为list的话可能会不小心修改了其中的元素导致出现问题

3.1 list

3.1.1 定义
列表是一种比较松散的数据结构；其特点为：
A. 元素对应着正向（左端点0,1,2,3....）和逆向（右端点开始-1，-2，-3，-4...）的index
B. 元素可以修改编辑，列表本体可以修改编辑
C.可以迭代

3.1.2 创建
直接使用[]就可以，或者list(iterable argument)2021年8月10日16:19:04 但是这不行哦

1. list(1, 2, 3, 4, 5)

复制代码

3.1.3 访问
        应该指出的是，list对象是按照index来将元素“绑定”在一起组成一种比较松散的邦联，访问的方式主要是要根据index来索引的。
（1）单个访问
直接list(index)就可以。主要联系到前面的index的正序和逆序，一个是从0开始的异世界，一个是从-1开始，这个负号其实就是表示顺序，这点很重要。

（2）抱团访问
访问连在一起（滑稽：单连通域）的时候，使用特色的切片方法。需要主要的是切片list[start_index:end_index:step]的用法中，首先是判定step的正负决定方向；然后再再看索引，start_index和end_index有具体值（不论正负）都是“先闭后开”的区间，而在缺省状态下是左端点-右端点（step为正）和右端点-左端点（step为负），并且此时终点不是“开”的。
与此同时，在start_index 和end_index之间构成了一个方向，这个方向当和step决定的方向是相反的时候切片失效，会得出一个空的列表！！

比较经典的是：（1）全部复制 （浅复制，不是一个id）lsit[:] （2）直接颠倒list[::-1]（3）偶数下标list[::2]和奇数下标list[1::2]
所以，总结就是：注意左闭右开（端点仍然闭）；整体复制是浅复制；注意step和区间的方向

参考文献：https://www.jianshu.com/p/15715d6f4dad
3.1.3 编辑——修改&新增&删除
（1）修改
对于个体元素来说实际就是赋值，赋值的方法就是访问的方法，也就是说访问出元素之后可以修改，这就是list对应在A的特性，tuple不行，并且这种赋值将会直接改变对应中的元素，不论是单个访问还是抱团访问（整体复制list[:]是例外）
同时也可以整体进行赋值——切片。
这两种方法都会直接改变list，让他不再是以前的哪个list，哈哈

（2）新增
考虑到将一排书架上的书进行增加成员的操作，自然而然地有直接在书列的末尾新增一本书或者是i一堆书（append），或者是在某个位置插入进去insert以及将某一列直接当做其扩展（extend）
append：单个元素插入到整体末尾，参数只有一个，是实例对象类型——排队
insert：插入到index的位置，以前这个位置成员直接后移一个位置（像是希尔伯特旅馆一样）。当然index可以是负数，也就是逆向找到这个元素挤进去）——插队
extend：就像是小部队归队一样，这个很好用——归队

（3）删除
访问是根据index（必不可能是通过元素访问啊），添加是增加元素啊（必不可能是index增加啊），所以删除的话就很好说了——知道人和知道id，所以就有两种方法删除
remove()，根据元素识别——是要人在就直接杀了，找人
pop()，根据index识别——直捣黄龙式。当然index可以为负数啊，找地址
最后就是del语句了，这个是通用的东西，有点像是remove了

3.1.4 运算
为了一些方便，可以对list进行一些运算。其实，按道理增加删除修改应该也是算一种运算的。
（1）线性运算
数乘：直接l乘以个整数就是将其扩展，自己的复制
加法：注意没有减法！！（想也知道不可以有也没有必要有）
in 和not in

3.1.4 其他方法
比较关注的是：
（1）元素出现次数使用count，参数为你要问的元素
（2）排序sort，默认是从大到小，当然元素要可以比较啊：纯整型，浮点型和字符串（字符串是根据前面位置的字母顺序不是ascii顺序）
（3）颠倒顺序reverse：顾名思义，后队变前队
还有其他的用到再说

Python初学者8号

3.2 元组
3.2.1 定义
元组也是和list类似的数据结构，只是用法有些区别，大概是基于数据的处理而设计出的另一种相似但是有所功能性区别的
特点：
A.一样的，index 索引，不再赘述
B.元素不可变，自身也不可变，就是固定班子
C.可以迭代

3.2.2  创建
小括号（）就是其特点。其实，逗号才是其特点，这点在a,b,c,=1,2,3这种操作中就是很好的体现，没有逗号也可以的，但是它是个很明显的identifier
当然也可以使用tuple（iterable）来创建了，都一样的，不过iterable要理解正确，否则出现下面的例子

1. >>> t=(50,)
   
2. >>> t
   
3. (50,)
   
4. >>> t=(50)
   
5. >>> t
   
6. 50

复制代码

3.2.3 访问
一样的，还是单个访问和抱团访问，with the usage of index。一样的index可以是负数


3.2.4  编辑
不可修改！
不可增添!
不可删除！
想要修改元组只能“借人”组建新人咯，就像乐队一样，老乐队不加人了，新乐队可以叫人来帮忙
3.2.5  运算
很有意思的是，这个线性运算居然支持！！
可以数乘来放大自己，也可以拼盘

3.2.6 方法
用的时候 再说吧

这个网站写很全面https://www.jb51.net/article/212330.htm

                               
登录/注册后可看大图

3.2.7有意思的实例
（1）类型转换

1. >>> tup = (1, 2, 3)
   
2. >>> bTup = bool(tup)
   
3. >>> bTup
   
4. True
   
5. >>> strTup = str(tup)
   
6. >>> strTup
   
7. '(1, 2, 3)'
   
8. >>> liTup = list(tup)
   
9. >>> liTup
   
10. [1, 2, 3]
    
11. >>> setTup = set(tup)
    
12. >>> setTup
    
13. {1, 2, 3}
    
14. >>> len(strTup)
    
15. 9
    
16. >>> for i in strTup:
    
17.         print(i)
    
18. 
    
19.         
    
20. (
    
21. 1
    
22. ,
    
23. 
    
24. 2
    
25. ,
    
26. 
    
27. 3
    
28. )
    
29. >>> len(setTup)
    
30. 3
    
31. >>> len(liTup)
    
32. 3
    

复制代码

说明字符串就是顾名思义，哈哈哈

这个牛逼

1. tup = (("k1", "v1"), ("k2", "v2"), ("k3", "v3"))
   
2. dictTuple = dict(tup)
   
3. 
   
4. print("值:%r,类型：%r" % (dictTuple, type(dictTuple)))
   
5. 
   
6. # 值:{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'},类型：<class 'dict'>

复制代码

hornwong

Python初学者8号

3.2.1  关于tuple不可变性的讨论
https://fishc.com.cn/forum.php?m ... p;extra=#pid5482491我的这个提问是我的问题。
总结就是，不变针对的是tuple的元素，而对于tuple元素的子元素（如list的元素）就不适用，也即为——我的封臣的封臣不是我的封臣
“逃兵”大哥的搬家【桌子、椅子、柜子】就很形象啊，柜子一定要搬走，但是柜子里面的东西随便

Python初学者8号

hornwong 发表于 2021-7-24 19:09

Python初学者8号

3.3 字符串
字符串这种东西，是语言里面很重要的一类的数据，毕竟文本还是比数据对于大多数人来说更加常用，所以相应的方法多一些，而且由于很多显示出来的东西也是文本（比如空格和回车），所以字符串稍微有点特殊。
注意：空格，回车，tab出来的缩进，这都是一种符号，只不过是不明显而已
3.3.1 定义
字符串，可以认为是一种特殊的元组，哈哈哈，毕竟其不可变性也在那里。但是其连接之间不想list和tuple之间有逗号，是连续读取的，就算是逗号也视为一种字符。
特点：
A.index索引，老规矩
B.不可变性
C.可迭代性
D.元素之间没有间隔标识符

3.2.2 创建
方法简单：str()函数和引号（一对单引号，双引号，三引号之间）
注意，str（）方法的参数可以放很多对象，哈哈

1. >>> t=[1,2,"3",("aaa",'bbb')]
   
2. >>> s=str(t)
   
3. >>> s
   
4. "[1, 2, '3', ('aaa', 'bbb')]"
   
5. >>> len(s)
   
6. 27
   
7. >>> s1=str(len)
   
8. >>> s1
   
9. '<built-in function len>'

复制代码

3.2.3 访问
还是单个访问和抱团访问，index和切片，和list，tuple的一样，不再赘述

1. >>> s
   
2. "[1, 2, '3', ('aaa', 'bbb')]"
   
3. >>> s[3:6]
   
4. ' 2,'

复制代码

3.2.4 编辑
和元祖一样，不可赋值，不可增加，不可删除
增加的话，有些别的方法，在这里只是统一一下和list相同的规律模板

1. >>> s.append(1)
   
2. Traceback (most recent call last):
   
3.   File "<pyshell#13>", line 1, in <module>
   
4.     s.append(1)
   
5. AttributeError: 'str' object has no attribute 'append'
   
6. >>> s+'WNDMD'
   
7. "[1, 2, '3', ('aaa', 'bbb')]WNDMD"
   
8. >>> del s[0]
   
9. Traceback (most recent call last):
   
10.   File "<pyshell#15>", line 1, in <module>
    
11.     del s[0]
    
12. TypeError: 'str' object doesn't support item deletion
    
13. >>> s[1]='s'
    
14. Traceback (most recent call last):
    
15.   File "<pyshell#16>", line 1, in <module>
    
16.     s[1]='s'
    
17. TypeError: 'str' object does not support item assignment

复制代码

3.2.5 运算
可以的，+和*都可以

1. >>> s+'WNDMD'
   
2. "[1, 2, '3', ('aaa', 'bbb')]WNDMD"
   
3. >>> s*2
   
4. "[1, 2, '3', ('aaa', 'bbb')][1, 2, '3', ('aaa', 'bbb')]"

复制代码

3.2.6 方法
说过了，字符串作为文本来说，当然具有很特殊的功能，所以需要提到一些比较重要的用法
（1）格式化字符串
A.方法.format()
它是一种字符串的内置方法，可以理解为“完形填空”

1. >>> '{1}'是'{2}'.format(我,你爹)
   
2. SyntaxError: invalid syntax
   
3. >>> '{1}是{2}'.format(我,你爹)
   
4. Traceback (most recent call last):
   
5.   File "<pyshell#20>", line 1, in <module>
   
6.     '{1}是{2}'.format(我,你爹)
   
7. NameError: name '我' is not defined
   
8. >>> '{1}是{2}'.format('我','你爹')
   
9. Traceback (most recent call last):
   
10.   File "<pyshell#21>", line 1, in <module>
    
11.     '{1}是{2}'.format('我','你爹')
    
12. IndexError: Replacement index 2 out of range for positional args tuple
    
13. >>> '{0}是{2}'.format('我','你爹')
    
14. Traceback (most recent call last):
    
15.   File "<pyshell#22>", line 1, in <module>
    
16.     '{0}是{2}'.format('我','你爹')
    
17. IndexError: Replacement index 2 out of range for positional args tuple
    
18. >>> '{0}是{1}{2}'.format('我','你爹')
    
19. Traceback (most recent call last):
    
20.   File "<pyshell#23>", line 1, in <module>
    
21.     '{0}是{1}{2}'.format('我','你爹')
    
22. IndexError: Replacement index 2 out of range for positional args tuple
    
23. >>> '{0}是{1}'.format('我','你爹')
    
24. '我是你爹'

复制代码

所以，根据index的方法注意事项就是：形式上是在字符串上完形填空，方法上是index根据format后面的参数对象来，但是必须和其中的参数对线的index对应——这是显而易见的
还有就是标签的方法：

1. >>> '{a}是{b}'.format(a='我',b='你爹')
   
2. '我是你爹'

复制代码

这个有点像字典那味儿了，我愿称之为广义index方法。
还有，虽然可以混着用（位置参数在关键字参数之前），但是我不想搞混淆。

以及需要强调的是，科学计算中的显示（当然后面%用的多吧）

1. >>> '{0}: {1}'.format('圆周率(circumference)','3.1415926')
   
2. '圆周率(circumference): 3.1415926'
   
3. >>> '{0}: {1:2f}'.format('圆周率(circumference)','3.1415926')
   
4. Traceback (most recent call last):
   
5.   File "<pyshell#28>", line 1, in <module>
   
6.     '{0}: {1:2f}'.format('圆周率(circumference)','3.1415926')
   
7. ValueError: Unknown format code 'f' for object of type 'str'
   
8. >>> '{0}: {1:.2f}'.format('圆周率(circumference)','3.1415926')
   
9. Traceback (most recent call last):
   
10.   File "<pyshell#29>", line 1, in <module>
    
11.     '{0}: {1:.2f}'.format('圆周率(circumference)','3.1415926')
    
12. ValueError: Unknown format code 'f' for object of type 'str'
    
13. >>> '{0}: {1:.2f}'.format('圆周率(circumference)',3.1415926)
    
14. '圆周率(circumference): 3.14'

复制代码

注意别搞错了哦，：是表示后续开始进行操作了开始标识符，. 表示的浮点，2f表示的两位小数。这个.2f只能对浮点数用
2021年9月25日10:47:30 在做二级的时候发现了一些补充的说明
format的参数具有： 填充    对齐     宽度      ，     .精度      类型   这六种，我们目前会用：.2f这样的表示两位“宽度”和精度。填充对齐宽度则是二级考点，比如这个:=>25,就是等号填充，居右，宽度为25，并且使用逗号显示数字类型

B.格式化操作符%
这是我们在C中就见过的老朋友了，网络上和小甲鱼的书中的这部分东西太多了，其实乍一看会给我一种茫然无措的感觉。但是其实这些用法是相通的，所以选几个有实际应用价值的来说
操作方法其实和上面的一样，也是完形填空的方法,注意类似上面的format的这个连接也用% 代替，而{}则是用%字符代替————'%字符'%(arg)
（1）数字——》ASCII字符        %C

1. >>> '%c%c%c%c%c'%(70,105,115,104,67)
   
2. 'FishC'

复制代码

数字——》ASCII字符
当然可以用这个chr函数实现，参数是数字啊

1. >>> chr(70)
   
2. 'F'

复制代码

ASCII字符——》数字
反过来，转换可以用这个ord函数，变量是ASCII字符

1. >>> ord('F')
   
2. 70

复制代码

（2）小数——》整数      %d（decimal）

1. >>> '%d%d'%(1.55,2.11)
   
2. '12'

复制代码

（3）十进制整数——》八和十六进制        o（octonary）,   x（hexadecimal）
注意是整数才可以转化，缺点是不可以变成其他进制的小数。

1. >>> '%x%o'%(1.55,2.11)
   
2. Traceback (most recent call last):
   
3.   File "<pyshell#43>", line 1, in <module>
   
4.     '%x%o'%(1.55,2.11)
   
5. TypeError: %x format: an integer is required, not float

复制代码

（4）小数点后精度
这个用法和上面提到的那个是一样的，也是. 数字 f的结构

1. >>> '%.3f'%(1.554241)
   
2. '1.554

复制代码

（5）整数/浮点数——》科学计数法    e/E

1. >>> '%.3e'%(1.554241)
   
2. '1.554e+00'
   
3. >>> '%.3e'%(15542.41)
   
4. '1.554e+04'
   
5. >>> '%.3e'%(0.00001554241)
   
6. '1.554e-05'

复制代码

要注意的是，也可以使用类似.2f的方法获取保留小数位，诶嘿嘿
2021年8月10日11:25:43还有一个要补充的句式%s

1. >>> '%s'%(123)
   
2. '123'
   
3. >>> '%s'%('111')
   
4. '111'
   
5. >>> '%s'%(print())
   
6. 
   
7. 'None'

复制代码

这个有点像是temp=input（‘输入：’）的东西一样，注意其语句是先执行括号中的东西，然后将括号的东西变成字符，如果是函数这类的话就将其返回值——比如print（‘sssss’）的返回值是NOne哦！！

这个挺好玩的

3.2.7 一些小技巧（1）得到一个逆序的字符串——切片方法

1. >>> a = 'hello world'
   
2. >>> a[::-1]
   
3. 'dlrow olleh'

复制代码

Python初学者8号

	list	tuple	string
形式	[]	(,,,,)	""    ''''''   ''
特点	1.元素可变 2.index索引 3.可迭代1	1.元素不可变 2.index索引 3.可迭代	1.元素不可变 2.index索引 3.可迭代
特征	松散的对象序列，元素可变	固定的对象序列，元素不可变	文本处理
访问	单个访问/报团访问——index及切片
编辑	赋值，增加，删除	不可赋值，可增加（线性运算），不可删除	不可赋值，可增加（线性运算和joint），不可删除
线性运算	√	√	√
主要方法	append,extend,insert;remove ,pop,del;reverse,sort		jonit连接，format方法和%操作符；index查询

注意，上面这些有的方法呢，在tupel和string中很少用，为啥？list本身具有的可变性导致了这个差异。
而正是这个差异，可以很明显的看到，包括，append extend reverse sort这些方法都是对list本身进行修改——id不变

Python初学者8号

3.4 序列

以上的数据结构我其实还搞混淆了，因为我居然把集合字典与这些放一起了，这个有点区别的吧，好像是二元的数据结构。我现在挖个坑，然后有机会看看数据结构中怎么讲这个集合字典的数据结构的。

大概就是总结一下这些数据结构的要点



1.创建
其实要说这些结构还是很简洁的，直接用几个符号就可以表示，包括后面集合。
所以创建都是通过符号就可以，当然还有函数——list（），tupel（）和str（）函数

2021年8月9日09:52:53需要提一句的是，一个高级用法——列表表达式。这个用法比较高级，因此在某些地方可以起到简洁的效果，并且有时候还可以兼具可读性强的作用。

一般的结构是[i for i in range(10)]这样的：一元/多元元素表达式    for  元素表达式 in 可迭代对象 限制条件

或者更简洁的来说就是：元素表达式  循环结构

其实应该这么理解：这个语法出现的目的是很显然的——简洁性和可读性。从for的结构本身来理解，这个结构本身就是一个可迭代结构，而for中本来也就包含可迭代。因此用for来作为一种快速得到sequence的想法自然而然就有了

这个回答写的很好很全面，还有这个

当然，鉴于我今年冬天的时候学过可是现在我明显差点记不住了，说明知识不牢固，现在给定一下需求
（1）一般的表达式 如

1. [i for i in range(10)]

复制代码

（2）可迭代对象表达式  

1. list_c = [7 * c for c in "python"]

复制代码

（3）带条件的表达式

1. list_d = [d for d in range(6) if d % 2 != 0]

复制代码

（4）多个for循环的表达式

1. list_e = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]

复制代码

注意，对于多个for循环可以看成是矩阵哦
*（5）嵌套的

1. list_g = [[x for x in range(g - 3, g)] for g in range(22) if g % 3 == 0 and g != 0]

复制代码

我的需求，主要就是（1）（2）（3）了，其他的次之


2.访问
都是使用index和切片——这点直接体现了序列这个性质。的

其实我认为和字典以及集合来说，这个索引就有很大的区别了吧，就像数学中的数列和离散函数一样，一个是数字对应一个是自变量对应的

3.编辑
到底能不能改变本身的元素这一点还是很有区别的。

个人理解是，列表就像是套丛书，科幻类的随便放，无所谓，有新人了老人的书也可以 撤掉；

而到了这个元组就像是成套的书一样，比如二十四史，可以加新的，但是已经有的不能动了

字符串是用于处理文本的，和tupel对比的话其实很像，但是呢，两个区别就是形式上没有逗号和功能主要用于文字处理的区别了，可以认为是tupel的兄弟了

4.方法
第一个很相似的线性运算+和*很有意思，使得他们的相似度很高

具有这些内建方法BIF，这些是py自带的函数，就像print函数一样。
（1）max和min，用于序列元素同类的时候选出最大值，字符亦可以
（2）len 度量个数
（3） sum，求和，只能用于数字（整型和浮点型）的序列
（4）sorted 直接创建一个新的排序之后的序列，返回值是新的

1. >>> l = [1,5,6,9,3,7,8]
   
2. >>> sorted(l)
   
3. [1, 3, 5, 6, 7, 8, 9]
   
4. >>> l
   
5. [1, 5, 6, 9, 3, 7, 8]
   
6. >>> id(sorted(l))==id(l)
   
7. False

复制代码

千万注意，参数是序列，返回值是列表哦

1. >>> t
   
2. (1, 5, 6, 9, 3, 7, 8)
   
3. >>> sorted(t)
   
4. [1, 3, 5, 6, 7, 8, 9]
   
5. >>> s=str(t)
   
6. >>> s
   
7. '(1, 5, 6, 9, 3, 7, 8)'
   
8. >>> sorted(s)
   
9. [' ', ' ', ' ', ' ', ' ', ' ', '(', ')', ',', ',', ',', ',', ',', ',', '1', '3', '5', '6', '7', '8', '9']

复制代码

（5）reversed 参数 序列，返回一个迭代器

1. >>> t
   
2. (1, 5, 6, 9, 3, 7, 8)
   
3. >>> s
   
4. '(1, 5, 6, 9, 3, 7, 8)'
   
5. >>> l
   
6. [1, 5, 6, 9, 3, 7, 8]
   
7. >>> reversed(t)
   
8. <reversed object at 0x0000020E4358C280>
   
9. >>> reversed(s)
   
10. <reversed object at 0x0000020E4358C160>
    
11. >>> reversed(l)
    
12. <list_reverseiterator object at 0x0000020E4358C250>
    
13. >>> type(reversed(t))==type(reversed(s))
    
14. True

复制代码

（6）enumerate
单词的中文意思是列举枚举
产生的是一系列的tuple组成的迭代对象

1. >>> str1="abcd"
   
2. >>> for i in enumerate(str1):
   
3.         print(i,type(i))
   
4. 
   
5. 
   
6. (0, 'a') <class 'tuple'>
   
7. (1, 'b') <class 'tuple'>
   
8. (2, 'c') <class 'tuple'>
   
9. (3, 'd') <class 'tuple'>

复制代码

（7）zip
现在发现zip这个名字很形象啊，因为zip就是拉链啊——将两排东西对应上就是zip的作用

参数是两个序列，当然个数要对上啊，然后缝合起来，每个元素是二院的tuple，这个和enumerate很像

1. >>> z1 = ['传','统','美','德']
   
2. >>> z2 = ('儒','雅','随','和')
   
3. >>> for i in zip(z1,z2):
   
4.         print(i,type(i))
   
5. 
   
6.         
   
7. ('传', '儒') <class 'tuple'>
   
8. ('统', '雅') <class 'tuple'>
   
9. ('美', '随') <class 'tuple'>
   
10. ('德', '和') <class 'tuple'>
    
11. 
    
12. >>>z1 = ['传','统','美','德']
    
13. >>> z2 = ('儒','雅','随','和','nmsl')
    
14. >>> z3=('儒','雅','随')
    
15. >>> for i in zip(z1,z2):
    
16.         print(i,type(i))
    
17. 
    
18.         
    
19. ('传', '儒') <class 'tuple'>
    
20. ('统', '雅') <class 'tuple'>
    
21. ('美', '随') <class 'tuple'>
    
22. ('德', '和') <class 'tuple'>
    
23. >>> for i in zip(z1,z3):
    
24.         print(i,type(i))
    
25. 
    
26.         
    
27. ('传', '儒') <class 'tuple'>
    
28. ('统', '雅') <class 'tuple'>
    
29. ('美', '随') <class 'tuple'>
    

复制代码

给出这几个不熟悉的help文档：

1. <font color="#ff0000">>>> help(enumerate)</font>
   
2. Help on class enumerate in module builtins:
   
3. 
   
4. class enumerate(object)
   
5. |  enumerate(iterable, start=0)
   
6. |  
   
7. |  Return an enumerate object.
   
8. |  
   
9. |    iterable
   
10. |      an object supporting iteration
    
11. |  
    
12. |  The enumerate object yields pairs containing a count (from start, which
    
13. |  defaults to zero) and a value yielded by the iterable argument.
    
14. |  
    
15. |  enumerate is useful for obtaining an indexed list:
    
16. |      (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
    
17. |  
    
18. |  Methods defined here:
    
19. |  
    
20. |  __getattribute__(self, name, /)
    
21. |      Return getattr(self, name).
    
22. |  
    
23. |  __iter__(self, /)
    
24. |      Implement iter(self).
    
25. |  
    
26. |  __next__(self, /)
    
27. |      Implement next(self).
    
28. |  
    
29. |  __reduce__(...)
    
30. |      Return state information for pickling.
    
31. |  
    
32. |  ----------------------------------------------------------------------
    
33. |  Static methods defined here:
    
34. |  
    
35. |  __new__(*args, **kwargs) from builtins.type
    
36. |      Create and return a new object.  See help(type) for accurate signature.
    
37. 
    
38. <font color="#ff0000">>>> help(reversed)</font>
    
39. Help on class reversed in module builtins:
    
40. 
    
41. class reversed(object)
    
42. |  reversed(sequence, /)
    
43. |  
    
44. |  Return a reverse iterator over the values of the given sequence.
    
45. |  
    
46. |  Methods defined here:
    
47. |  
    
48. |  __getattribute__(self, name, /)
    
49. |      Return getattr(self, name).
    
50. |  
    
51. |  __iter__(self, /)
    
52. |      Implement iter(self).
    
53. |  
    
54. |  __length_hint__(...)
    
55. |      Private method returning an estimate of len(list(it)).
    
56. |  
    
57. |  __next__(self, /)
    
58. |      Implement next(self).
    
59. |  
    
60. |  __reduce__(...)
    
61. |      Return state information for pickling.
    
62. |  
    
63. |  __setstate__(...)
    
64. |      Set state information for unpickling.
    
65. |  
    
66. |  ----------------------------------------------------------------------
    
67. |  Static methods defined here:
    
68. |  
    
69. |  __new__(*args, **kwargs) from builtins.type
    
70. |      Create and return a new object.  See help(type) for accurate signature.
    
71. 
    
72. <font color="#ff0000">>>> help(sorted)</font>
    
73. Help on built-in function sorted in module builtins:
    
74. 
    
75. sorted(iterable, /, *, key=None, reverse=False)
    
76.     Return a new list containing all items from the iterable in ascending order.
    
77.    
    
78.     A custom key function can be supplied to customize the sort order, and the
    
79.     reverse flag can be set to request the result in descending order.
    
80. 
    
81. <font color="#ff0000">>>> help(zip)</font>
    
82. Help on class zip in module builtins:
    
83. 
    
84. class zip(object)
    
85. |  zip(*iterables) --> zip object
    
86. |  
    
87. |  Return a zip object whose .__next__() method returns a tuple where
    
88. |  the i-th element comes from the i-th iterable argument.  The .__next__()
    
89. |  method continues until the shortest iterable in the argument sequence
    
90. |  is exhausted and then it raises StopIteration.
    
91. |  
    
92. |  Methods defined here:
    
93. |  
    
94. |  __getattribute__(self, name, /)
    
95. |      Return getattr(self, name).
    
96. |  
    
97. |  __iter__(self, /)
    
98. |      Implement iter(self).
    
99. |  
    
100. |  __next__(self, /)
     
101. |      Implement next(self).
     
102. |  
     
103. |  __reduce__(...)
     
104. |      Return state information for pickling.
     
105. |  
     
106. |  ----------------------------------------------------------------------
     
107. |  Static methods defined here:
     
108. |  
     
109. |  __new__(*args, **kwargs) from builtins.type
     
110. |      Create and return a new object.  See help(type) for accurate signature.
     
111. 
     

复制代码

Python初学者8号

	作用	输入参数	输出结果	备注
sorted	排序	sequence	列表	处理序列顺序
reversed	翻转顺序	sequence	列表	处理序列顺序
enumerate	打index标签的二元组	iterables	二元元组sequence	特殊的zip，自变量是数字
zip	拉链	两个iterables	一一映射	建立字典的准备工作？？

Python初学者8号

关于复制的问题看看这个回答https://zhuanlan.zhihu.com/p/118663392

1. [code]# python 内建模块copy
   
2. import copy
   
3. 
   
4. L1 = [1, 2, [3]]
   
5. L2 = L1
   
6. L3 = L1[:]
   
7. L4 = list(L1)
   
8. L5 = copy.copy(L1)
   
9. L6 = copy.deepcopy(L1)
   
10. 
    
11. if __name__ == '__main__':
    
12.     print('L1 = [1, 2, [3]],L1 id is :{}'.format(id(L1)))   
    
13.     print('L2 = L1,L2 id is :{}'.format(id(L1)))
    
14.     print('L3 = L1[:],L3 id is :{}'.format(id(L3)))
    
15.     print('L4 = list(L1),L4 id is :{}'.format(id(L4)))
    
16.     print('L5 = copy.copy(L1),L5 id is :{}'.format(id(L5)))
    
17.     print('L6 = copy.deepcopy(L1),L6 id is :{}'.format(id(L6)),end='\n\n')
    
18.    
    
19.     print('L1[2] id is :{}'.format(id(L1[2])))
    
20.     print('L2[2] id is :{}'.format(id(L1[2])))
    
21.     print('L3[2] id is :{}'.format(id(L3[2])))
    
22.     print('L4[2] id is :{}'.format(id(L4[2])))
    
23.     print('L5[2] id is :{}'.format(id(L5[2])))
    
24.     print('L6[2] id is :{}'.format(id(L6[2])))

复制代码

[/code]
输出结果是
L1 = [1, 2, [3]],L1 id is :1958940450176
L2 = L1,L2 id is :1958940450176
L3 = L1[:],L3 id is :1958940448576
L4 = list(L1),L4 id is :1958940450688
L5 = copy.copy(L1),L5 id is :1958940447168
L6 = copy.deepcopy(L1),L6 id is :1958940448512

L1[2] id is :1958940448064
L2[2] id is :1958940448064
L3[2] id is :1958940448064
L4[2] id is :1958940448064
L5[2] id is :1958940448064
L6[2] id is :1958940491840

Python初学者8号

2021年9月20日20:30:32 两个问题补充
一个是格式化字符串的居中/居左/居右的命令

1. >>> print("{:*^13}".format('love'))
   
2. ****love*****
   
3. >>> print("{:*<13}".format('love'))
   
4. love*********
   
5. >>> print("{:*>13}".format('love'))
   
6. *********love

复制代码

一个是，列表字符串元素的引号问题

1. ls = ["alex","brad","cundal"]
   
2. def func(a):
   
3.     ls.append(a)
   
4. func("pink")
   
5. print(ls)

复制代码

可以看出，其实只能是单引号的