第034讲：序列（中）

小古比鱼

本节主要探讨了与序列相关的一部分函数，包括序列之间相互转换的函数（list()、tuple()、str()）、求最值函数（min()、max()）、求和函数（len()、sum()）、排序函数（sorted()、reversed()），共计9个内置函数！其中，求最值函数有两种函数原型，既可以传入可迭代对象，也可以传入多个参数；可迭代对象为空时会抛出ValueError异常，可通过设置default参数来“缓和氛围”。len()函数的参数有最大可承受范围，超出就会报错（OverflowError）。排序函数返回的是一个全新的序列，并不会作用于序列本身，这与列表的内置方法原地排序有所不同。sorted()函数和列表的sort()方法可以通过设置key参数来指定排序标准，即干预排序的算法，灵活而又巧妙！与sorted()函数返回列表不同，reversed()函数返回的是一个参数的反向迭代器（一串奇奇怪怪的英文），其也属于可迭代对象，可利用上述转换函数转换为序列，这样就一目了然啦！

wangtuan

1. >>> list("FishC")
   
2. ['F', 'i', 's', 'h', 'C']
   
3. >>> list(1,2,3,4,5)
   
4. Traceback (most recent call last):
   
5.   File "<pyshell#1>", line 1, in <module>
   
6.     list(1,2,3,4,5)
   
7. TypeError: list expected at most 1 argument, got 5
   
8. >>> list((1,2,3,4,5))
   
9. [1, 2, 3, 4, 5]
   
10. >>> tuple("FishC")
    
11. ('F', 'i', 's', 'h', 'C')
    
12. >>> tuple([1,2,3,4,5])
    
13. (1, 2, 3, 4, 5)
    
14. >>> str([1,2,3,4,5])
    
15. '[1, 2, 3, 4, 5]'
    
16. >>> str((1,2,3,4,5))
    
17. '(1, 2, 3, 4, 5)'
    
18. >>> [" list()可将字符串、元组转变为列表,  tuple()可将列表，字符串转变为元组,  str()可将列表、元组转变为字符串"]
    
19. [' list()可将字符串、元组转变为列表,  tuple()可将列表，字符串转变为元组,  str()可将列表、元组转变为字符串']
    
20. >>> s = [1,1,2,3,5]
    
21. >>> min(s)
    
22. 1
    
23. >>> max(s)
    
24. 5
    
25. >>> t = "FishC"
    
26. >>> min(t)
    
27. 'C'
    
28. >>> max(t)
    
29. 's'
    
30. >>> ["min(),max()分别可以求得序列中的最小值和最大值，如果是字符串，那么求得的是编码最小和最大的值，编码顺序即为26个字母顺序，并且大写字母编码在小写字母编码之前"]
    
31. ['min(),max()分别可以求得序列中的最小值和最大值，如果是字符串，那么求得的是编码最小和最大的值，编码顺序即为26个字母顺序，并且大写字母编码在小写字母编码之前']
    
32. >>> s = []
    
33. >>> min(s)
    
34. Traceback (most recent call last):
    
35.   File "<pyshell#16>", line 1, in <module>
    
36.     min(s)
    
37. ValueError: min() arg is an empty sequence
    
38. >>> min(s,default = "屁，啥都没有，怎么找到最小")
    
39. '屁，啥都没有，怎么找到最小'
    
40. >>> ["当可迭代对象为空时，此时直接求 min 、max 会出现报错，此时设置一个 default,即默认值，可以缓解气氛"]
    
41. ['当可迭代对象为空时，此时直接求 min 、max 会出现报错，此时设置一个 default,即默认值，可以缓解气氛']
    
42. >>>
    
43. >>> min(1,2,3,0,6)
    
44. 0
    
45. >>> max(1,2,3,0,6)
    
46. 6
    
47. >>> len(range(2 ** 100))
    
48. Traceback (most recent call last):
    
49.   File "<pyshell#22>", line 1, in <module>
    
50.     len(range(2 ** 100))
    
51. OverflowError: Python int too large to convert to C ssize_t
    
52. >>> ["len() 函数求长度，其有极限值"]
    
53. ['len() 函数求长度，其有极限值']
    
54. >>> s = [1,0,0,8]
    
55. >>> sum(s)
    
56. 9
    
57. >>> sum(s,start = 100)
    
58. 109
    
59. >>> s = [1,2,3,0,6]
    
60. >>> sorted(s)
    
61. [0, 1, 2, 3, 6]
    
62. >>> ["sorted() 函数返回的是一个全新的列表，而原来的列表不会受影响"]
    
63. ['sorted() 函数返回的是一个全新的列表，而原来的列表不会受影响']
    
64. >>> s
    
65. [1, 2, 3, 0, 6]
    
66. >>> s.sort()
    
67. >>> s
    
68. [0, 1, 2, 3, 6]
    
69. >>> ["如果使用 s.sort() 方法，s 本身就会被改变，切记！！！"]
    
70. ['如果使用 s.sort() 方法，s 本身就会被改变，切记！！！']
    
71. >>> sorted(s,reverse = True)
    
72. [6, 3, 2, 1, 0]
    
73. >>> t = ["FishC","Apple","Book","Banana","Pen"]
    
74. >>> sort(t)
    
75. Traceback (most recent call last):
    
76.   File "<pyshell#36>", line 1, in <module>
    
77.     sort(t)
    
78. NameError: name 'sort' is not defined
    
79. >>> sorted(t)
    
80. ['Apple', 'Banana', 'Book', 'FishC', 'Pen']
    
81. >>> sorted(t, key = len)
    
82. ['Pen', 'Book', 'FishC', 'Apple', 'Banana']
    
83. >>> t.sort(key = len )
    
84. >>> t
    
85. ['Pen', 'Book', 'FishC', 'Apple', 'Banana']
    
86. >>> ["使用 sorted() 对字符串进行排序时，先以每一字符串的首字母编码进行排序，如果首字母一样，再依次按照下一位字符串进行排序；                                     而 sorted(t,key = len) 中的 key 实际上是一个干预函数，他让排序方式按照字符串的长度来决定，对于列表中的字符串排序，我们可以使用 t.sort(key = len )来达到相同的结果"]
    
87. ['使用 sorted() 对字符串进行排序时，先以每一字符串的首字母编码进行排序，如果首字母一样，再依次按照下一位字符串进行排序；                                     而 sorted(t,key = len) 中的 key 实际上是一个干预函数，他让排序方式按照字符串的长度来决定，对于列表中的字符串排序，我们可以使用 t.sort(key = len )来达到相同的结果']
    
88. >>> sorted("FishC")
    
89. ['C', 'F', 'h', 'i', 's']
    
90. >>> sorted((1,0,0,8,6))
    
91. [0, 0, 1, 6, 8]
    
92. >>> ["sorted() 排序字符串、元组得到的是列表"]
    
93. ['sorted() 排序字符串、元组得到的是列表']
    
94. >>> s = [1,2,5,8,0]
    
95. >>> reversed(s)
    
96. <list_reverseiterator object at 0x00000257D3BC3A60>
    
97. >>> list(reversed(s))
    
98. [0, 8, 5, 2, 1]
    
99. >>> s.reverse()
    
100. >>> ["reversed() 函数生成的是一个 迭代器， 即也是一个可迭代对象，它可以对 列表、字符串、元组进行逆向排序"]
     
101. ['reversed() 函数生成的是一个 迭代器， 即也是一个可迭代对象，它可以对 列表、字符串、元组进行逆向排序']
     
102. >>> list(reversed("FishC"))
     
103. ['C', 'h', 's', 'i', 'F']
     
104. >>> lies(reversed((1,2,3,4,5)))
     
105. Traceback (most recent call last):
     
106.   File "<pyshell#51>", line 1, in <module>
     
107.     lies(reversed((1,2,3,4,5)))
     
108. NameError: name 'lies' is not defined
     
109. >>> list(reversed((1,0,0,8,6)))
     
110. [6, 8, 0, 0, 1]
     
111. >>> list(reversed(range(0,10)))
     
112. [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
     
113. >>>

复制代码

leizhenzi23

为什么sorted(t, key=len) 中  FishC 会排 在 Apple的前边呢，因为 FishC长度更长么

Er3nYeager

打卡

码农心

生活好难编程好难

降龙木

动动手：0
l=[1, 8, 7, 3, 6, 5, 4, 2]
a=[]
b=[]
l.sort()
for i in l:
    if  i %2==1:
        a.append(i)
    else:
        b.append(i)
print(a+b)

剪刀布稀里糊涂

leizhenzi23 发表于 2022-3-30 17:37
为什么sorted(t, key=len) 中  FishC 会排 在 Apple的前边呢，因为 FishC长度更长么

楼主知道为什么了吗？  

ctx111

list('ctx')
['c', 't', 'x']
list((1,2,3))
[1, 2, 3]
tuple('ctx')
('c', 't', 'x')
tuple((1,2,3))
(1, 2, 3)
tuple([1,2,3])
(1, 2, 3)
str([1,2])
'[1, 2]'
str((1,3))
'(1, 3)'
s=[1,1,2,3,5]
min(s)
1
t='ctx'
max(t)
'x'
t='Cc'
max(t)
'c'
s=[]
max(s)
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    max(s)
ValueError: max() arg is an empty sequence
min(s,'sdfds')
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    min(s,'sdfds')
TypeError: '<' not supported between instances of 'str' and 'list'
min(s,default='sdfds')
'sdfds'
len(range(2**333))
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    len(range(2**333))
OverflowError: Python int too large to convert to C ssize_t
s=[1,2,5]
sum(s)
8
sum(s,start=13)
21
s=[1,3,2,8,4]
sorted(s)
[1, 2, 3, 4, 8]
s
[1, 3, 2, 8, 4]
s.sort()
s
[1, 2, 3, 4, 8]
s=[1,5,2,8,4]
sorted(s,reverse=True)
[8, 5, 4, 2, 1]
s=[1,5,2,8,4]
sorted(s,reverse=False)
[1, 2, 4, 5, 8]
a=['ads','fgh','ervx','Ervx','ERvx']
sorted(a)
['ERvx', 'Ervx', 'ads', 'ervx', 'fgh']
sorted(a,len(s))
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    sorted(a,len(s))
TypeError: sorted expected 1 argument, got 2
sorted(a,key=len)
['ads', 'fgh', 'ervx', 'Ervx', 'ERvx']
sorted('Ctx')
['C', 't', 'x']
sorted('zqy')
['q', 'y', 'z']
sorted(1,0,0,8,6)
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    sorted(1,0,0,8,6)
TypeError: sorted expected 1 argument, got 5
sorted((1,0,0,8,6))
[0, 0, 1, 6, 8]
s=[1,3,7,8,5]
reversed(s)
<list_reverseiterator object at 0x103861720>
list(reversed(s))
[5, 8, 7, 3, 1]
s.reverse()
s
[5, 8, 7, 3, 1]
list(reversed("FishC"))
['C', 'h', 's', 'i', 'F']
tuple(reversed("FishC"))
('C', 'h', 's', 'i', 'F')
list(reversed((1, 2, 5, 9, 3)))
[3, 9, 5, 2, 1]
tuple(reversed((1, 2, 5, 9, 3)))
(3, 9, 5, 2, 1)
list(reversed(range(0, 10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
tuple(reversed(range(0, 10)))
(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

dami27

0.
s = [1, 8, 7, 3, 6, 5, 4, 2]

a = sorted(s)
res = []

for i in a:
    if i % 2 == 1:
        res.append(i)

for j in a:
    if j % 2 == 0:
        res.append(j)

print(res)

1.
s = input("请输入英文：")
a = list(reversed(s.split()))
print(" ".join(a))

goblinTech

leizhenzi23 发表于 2022-3-30 17:37
为什么sorted(t, key=len) 中  FishC 会排 在 Apple的前边呢，因为 FishC长度更长么

t1=["FishC","Apple","Book","Banana","Pen"]
sorted(t,key=len)
['Pen', 'Book', 'FishC', 'Apple', 'Banana']

t2=["Apple","Book","Banana","Pen","FishC"]
sorted(t,key=len)
['Pen', 'Book', 'Apple', 'FishC', 'Banana']

你对比一下就知道答案了，很简单

炎凉来寻

学习打卡

阿伟同学

leizhenzi23 发表于 2022-3-30 17:37
为什么sorted(t, key=len) 中  FishC 会排 在 Apple的前边呢，因为 FishC长度更长么

这两个是一样长的，但他是稳定。
<sorted() 函数的排序结果是稳定的。
假定在待排序的序列中，存在多个相同的元素，经过排序之后，这些元素的相对次序保持不变，则称这种排序算法是稳定的；否则称为不稳定的。>
所以在key = len时，两个字符串一样长的话，会保持原来的相对次序。

chenjinchao

好难了

墨墨在努力吖

len(range(2**63-1))
Traceback (most recent call last):
  File "<pyshell#90>", line 1, in <module>
    len(range(2**63-1))
OverflowError: Python int too large to convert to C ssize_t

我的电脑是64位，但是它报错了，这是为啥一，我还试了2的六十二次方、2的四十、2的三十二等等，都报错。查看了电脑，显示的是64位，是不是因为使用的Python版本的问题，我用的是3.7.3

但是输入2的三十一次方减1，就是对的。
>>> len(range(2**31-1))
2147483647

我的电脑显示的系统类型是64 位操作系统, 基于 x64 的处理器。

遇到的第二个问题是
s = [1,0,0,8,6]
>>> sum(s)
15
>>> sum(s,start=100)
Traceback (most recent call last):
  File "<pyshell#101>", line 1, in <module>
    sum(s,start=100)
TypeError: sum() takes no keyword arguments

它的结果不是115，结果报错了。想知道是什么原因然后怎么解决？

好像解决了：
>>> i = [3,2,0]
>>> sum(i,5)
10
后面不写start，直接写要加多少等等。


滴滴滴~打卡

migu_sm1

s = [1,3,5,6]
sum(s)
15
sum(s,start=100)
115
sum(s,100)
115
我的都可以.

jgz1818

非常感谢大家的支持

andyleesh

打卡打卡

yanfeigao2005

我的3.7.4版本不识别sum（s,start=10）中的start=10

xiaoxiangx