4. Python的序列

深碍√TFBOYSˉ_ 2021-10-23 23:52 222阅读 0赞

字符串str、列表list、元组tuple都是序列。序列有序的，且具有类似的基本操作。

字符串str、元组tuple是不可变类型，而列表list是可变类型。

--------------------

### 列表list ###

列表通过`[]`定义，`[]`中是单个的元素，当`[]`中只含None元素时称为空列表。列表中的元素是可以任意改变的。

>>> type([1, 2, 3, 4, 5])
    <class 'list'>
    
    >>> type([])
    <class 'list'>

对于一个列表，其内部元素的类型并不是固定的单一类型，可以是任意的类型。

>>> type(["hello world", 1, False])
    <class 'list'>

列表内部的元素还可以是列表、元组、集合及字典。列表中元素为列表的列表称为嵌套列表。

>>> type([[1, "two", 'three'], ('zhang', 25, 'liu'), { 30, 'wang', 'male'}, { 'Bob': 85, 'Jack': 63, 'Ailce': 96}])
    <class 'list'>

#### 列表的基本操作 ####

*  访问列表元素：

>>> Jiaoyue = ["新月打击", "苍白之瀑", "月之降临", "月神冲刺"]
    
    >>> Jiaoyue[0]
    '新月打击'
    
    >>> Jiaoyue[3]
    '月神冲刺'

单个数字序号取到的是字符串，而不是列表。

*  切片：

>>> Jiaoyue[0:2]
    ['新月打击', '苍白之瀑']
    
    >>> Jiaoyue[-1]
    '月神冲刺'
    
    >>> Jiaoyue[-1:]
    ['月神冲刺']
    
    >>> Jiaoyue[0:3:2]
    ['新月打击', '月之降临']
    
    >>> Jiaoyue[:]
    ['新月打击', '苍白之瀑', '月之降临', '月神冲刺']

通过对列表进行切片得到的仍然是列表，而不是字符串。切片时第三个参数是步长，不指定默认为1。`[:]`表示进行复制，不影响原列表。

*  相加：

>>> DF = ["闪现", "点燃", "月神冲刺"]
    
    >>> Jiaoyue + DF
    ['新月打击', '苍白之瀑', '月之降临', '月神冲刺', '闪现', '点燃', '月神冲刺']
    
    >>> Jiaoyue - DF
    Traceback (most recent call last):
      File "<pyshell#20>", line 1, in <module>
        Jiaoyue - DF
    TypeError: unsupported operand type(s) for -: 'list' and 'list'

两个列表相加得到的仍然是列表，且相同元素不会被去除。列表不支持减法操作。

*  相乘：

>>> Jiaoyue * DF
    Traceback (most recent call last):
      File "<pyshell#13>", line 1, in <module>
        Jiaoyue * DF
    TypeError: can't multiply sequence by non-int of type 'list'
    
    >>> DF * 3
    ['闪现', '点燃', '月神冲刺', '闪现', '点燃', '月神冲刺', '闪现', '点燃', '月神冲刺']

与字符串类似，列表之间不能相乘，列表只能与数字相乘，得到的仍然是列表，列表元素会重复对应数字的次数。

--------------------

### 元组tuple ###

元组通过`()`定义，`()`中是单个的元素，当`()`中只含None元素时称为空元组。与列表不同，元组中的元素是不可改变的，元组可看作不可变的列表。

>>> type((1, 2, 3, 4, 5))
    <class 'tuple'>
    
    >>> type(())
    <class 'tuple'>

对于一个元组，其内部元素的类型并不是固定的单一类型，可以是任意的类型。

>>> type((1, 'aaa', True))
    <class 'tuple'>

元组内部的元素还可以是列表、元组、集合及字典。元组中元素为元组的元组称为嵌套元组。

>>> type(([1, "two", 'three'], ('zhang', 25, 'liu'), { 30, 'wang', 'male'}, { 'Bob': 85, 'Jack': 63, 'Ailce': 96}))
    <class 'tuple'>

对于只含单个元素的元组，定义元组时需要注意一个小问题。

>>> t1 = (1)
    
    >>> type(t1)
    <class 'int'>
    
    >>> t1
    1
    
    >>> type(('hello'))
    <class 'str'>

>>> t2 = (1,)
    
    >>> type(t2)
    <class 'tuple'>
    
    >>> t2
    (1,)

只含单个元素的元组在定义时不要忘记添加`,`，否则不会作为tuple类型。列表不存在这个问题。

这是因为Python也使用`()`作为数学运算的优先级符号，这与元组的定义产生了冲突，所以Python规定只含单个元素的元组在定义时需要加上`,`。

#### 元组的基本操作 ####

*  访问元组元素：

>>> T = ('Zhangsan', 18, "male", 67)
    
    >>> T[1]
    18
    
    >>> T[-2]
    'male'

单个数字序号取到的是字符串，而不是元组。

*  切片：

>>> T[0:2]
    ('Zhangsan', 18)
    
    >>> T[-2:]
    ('male', 67)
    
    >>> T[0:3:3]
    ('Zhangsan',)
    
    >>> T[:]
    ('Zhangsan', 18, 'male', 67)

通过对元组进行切片得到的仍然是元组，而不是字符串。切片时第三个参数是步长，不指定默认为1。`[:]`表示进行复制，不影响原元组。

*  相加：

>>> t = (17, 18, 19)
    
    >>> T + t
    ('Zhangsan', 18, 'male', 67, 17, 18, 19)
    
    >>> T - t
    Traceback (most recent call last):
      File "<pyshell#21>", line 1, in <module>
        T - t
    TypeError: unsupported operand type(s) for -: 'tuple' and 'tuple'

两个元组相加得到的仍然是元组，且相同元素不会被去除。元组不支持减法操作。

*  相乘：

>>> T * t
    Traceback (most recent call last):
      File "<pyshell#22>", line 1, in <module>
        T * t
    TypeError: can't multiply sequence by non-int of type 'tuple'
    
    >>> t * 3
    (17, 18, 19, 17, 18, 19, 17, 18, 19)

与列表类似，元组之间不能相乘，元组只能与数字相乘，得到的仍然是元组，元组元素会重复对应数字的次数。

--------------------

### 序列的共有操作 ###

字符串、列表、元组都是序列，序列是有序的，通过上面我们可以看到序列的一些操作。接下来继续谈谈序列的共有操作。

*  成员运算符`in`和`not in`：

用于判断一个元素是否在序列中。

>>> 3 in [1, 2, 3, 4, 5]
    True
    
    >>> 3 not in (6, 7, 8, 9, 10)
    True
    
    >>> 'hello' not in 'hello world'
    False

*  `len()`方法：

求序列长度。

>>> len('hello world')
    11
    
    >>> len(['新月打击', '苍白之瀑', '月之降临', '月神冲刺', 1, 2, 3, 4, 5])
    9
    
    >>> len(('Zhangsan', 18, "male", 67))
    4

*  `max()`和`min()`方法：

求序列最大值及最小值。

>>> max('hello world')
    'w'
    
    >>> max(['新月打击', '苍白之瀑', '月之降临', '月神冲刺'])
    '苍白之瀑'
    
    >>> max(('Zhangsan', 18, "male", 67))
    Traceback (most recent call last):
      File "<pyshell#9>", line 1, in <module>
        max(('Zhangsan', 18, "male", 67))
    TypeError: '>' not supported between instances of 'int' and 'str'

>>> min('hello world')
    ' '
    
    >>> min('helloworld')
    'd'
    
    >>> min(['新月打击', '苍白之瀑', '月之降临', '月神冲刺'])
    '新月打击'
    
    >>> min(('Zhangsan', 18, "male", 67))
    Traceback (most recent call last):
      File "<pyshell#12>", line 1, in <module>
        min(('Zhangsan', 18, "male", 67))
    TypeError: '<' not supported between instances of 'int' and 'str'

可以看到，`max()`及`min()`不能对不同的元素类型进行比较，元素类型相同时可比较取得最大值及最小值。

--------------------

### 集合set ###

不同于上面所讲的列表和元祖，它们都是序列。而集合是无序的，集合不是序列。

集合通过`{}`定义，`{}`中是单个的元素。集合中的元素是可改变的。

>>> type({ 1, 2, 3, 4, 5})
    <class 'set'>

对于一个集合，其内部元素的类型并不是固定的单一类型，可以是任意类型。

>>> type({ 'abc', 222, False})
    <class 'set'>

集合内部的元素还可以是元组，但不能是列表、集合及字典。

>>> type({ ('hello', 22)})
    <class 'set'>
    
    >>> type({ ['hello', 22]})
    Traceback (most recent call last):
      File "<pyshell#8>", line 1, in <module>
        type({ ['hello', 22]})
    TypeError: unhashable type: 'list'
    
    >>> type({ { 'hello', 22}})
    Traceback (most recent call last):
      File "<pyshell#10>", line 1, in <module>
        type({ { 'hello', 22}})
    TypeError: unhashable type: 'set'
    
    >>> type({ { 'hello':22, 'world': 23}})
    Traceback (most recent call last):
      File "<pyshell#9>", line 1, in <module>
        type({ { 'hello':22, 'world': 23}})
    TypeError: unhashable type: 'dict'

集合不支持通过序号访问其内部元素，当然也就无法切片。

>>> S = { 'hello', 22, 'Bob', 'Student'}
    
    >>> S[2]
    Traceback (most recent call last):
      File "<pyshell#13>", line 1, in <module>
        S[2]
    TypeError: 'set' object is not subscriptable
    
    >>> S[0:2]
    Traceback (most recent call last):
      File "<pyshell#14>", line 1, in <module>
        S[0:2]
    TypeError: 'set' object is not subscriptable

集合中元素不重复，集合中不会存在相同的元素。

>>> S1 = { 1, 2, 3, 4, 1, 2, 3 ,4}
    
    >>> S1
    { 1, 2, 3, 4}

集合支持前面所讲的`len()`、`max()`、`min()`等方法，也支持`in`及`not in`这样的成员判断符。

>>> len(S1)
    4
    
    >>> max(S1)
    4
    
    >>> min(S1)
    1
    
    >>> 3 in S1
    True
    
    >>> 1 not in S1
    False

还有个小问题，如何定义一个空的集合？

>>> type({ })
    <class 'dict'>
    
    >>> type(set())
    <class 'set'>
    
    >>> len(set())
    0

当`{}`中只含None元素时，Python默认识别为字典dict类型。不过与列表、元组及字典类似，可以通过`set()`方法来定义一个空的集合。

#### 集合的特殊操作 ####

*  求两集合差集`-`：

>>> { 1, 2, 3, 4, 5, 6} - { 3, 4}
    { 1, 2, 5, 6}

*  求两集合交集`&`：

>>> { 1, 2, 3, 4, 5, 6} & { 3, 4}
    { 3, 4}

*  求两集合并集`|`：

>>> { 1, 2, 3, 4, 5, 6} | { 3, 4, 7}
    { 1, 2, 3, 4, 5, 6, 7}

--------------------

### 字典dict ###

与集合一样，字典也不是序列，它是无序的。

字典也是通过`{}`定义，只不过`{}`中的元素是键-值对（k-v）。字典中元素的key是不可变的，而value是可以改变的。

为什么叫字典，因为它是根据其内部元素的key来查找对应的value。

>>> type({ 'name': 'Bob', 'age': 16, 'gender': 'male'})
    <class 'dict'>

对于一个字典，其内部元素的类型并不是固定的单一类型，key可以是任意不可变类型，而value不可以是bool类型。

>>> type({ 0: Flase, True: 'True', 'age': 16})
    Traceback (most recent call last):
      File "<pyshell#1>", line 1, in <module>
        type({ 0: Flase, True: 'True', 'age': 16})
    NameError: name 'Flase' is not defined
    
    >>> type({ 0: 'Flase', True: 'True', 'age': 16})
    <class 'dict'>

和集合一样，字典内部元素的key可以是元组，但不能是列表、集合及字典，而value可以是列表、元组、集合及字典。

>>> type({ ['hello', 22]: 'Bob'})
    Traceback (most recent call last):
      File "<pyshell#6>", line 1, in <module>
        type({ ['hello', 22]: 'Bob'})
    TypeError: unhashable type: 'list'
    
    >>> type({ 'Bob': ['hello', 22]})
    <class 'dict'>
    
    >>> type({ ('hello', 22): 'Bob'})
    <class 'dict'>
    
    >>> type({ 'Bob': ('hello', 22)})
    <class 'dict'>
    
    >>> type({ { 'hello', 22}: 'Bob'})
    Traceback (most recent call last):
      File "<pyshell#9>", line 1, in <module>
        type({ { 'hello', 22}: 'Bob'})
    TypeError: unhashable type: 'set'
    
    >>> type({ 'Bob': { 'hello', 22}})
    <class 'dict'>
    
    >>> type({ { 'hello': 22}: 'Bob'})
    Traceback (most recent call last):
      File "<pyshell#11>", line 1, in <module>
        type({ { 'hello': 22}: 'Bob'})
    TypeError: unhashable type: 'dict'
    
    >>> type({ 'Bob': { 'hello': 22}})
    <class 'dict'>

集合不支持通过序号访问其内部元素，当然也就无法切片。

>>> { 'name': 'Bob', 'age': 16, 'gender': 'male', 'job': 'student'}[2]
    Traceback (most recent call last):
      File "<pyshell#15>", line 1, in <module>
        { 'name': 'Bob', 'age': 16, 'gender': 'male', 'job': 'student'}[2]
    KeyError: 2
    
    >>> { 'name': 'Bob', 'age': 16, 'gender': 'male', 'job': 'student'}[0:3]
    Traceback (most recent call last):
      File "<pyshell#17>", line 1, in <module>
        { 'name': 'Bob', 'age': 16, 'gender': 'male', 'job': 'student'}[0:3]
    TypeError: unhashable type: 'slice'

字典中元素不重复，且key值不允许相同，value值无限制。

>>> { 'name': 'Bob', 'age': 16, 'gender': 'male', 'job': 'student', 'name': 'Jack', 'age': 16}
    { 'name': 'Jack', 'age': 16, 'gender': 'male', 'job': 'student'}

字典也支持前面所讲的`len()`、`max()`、`min()`等方法，也支持`in`及`not in`这样的成员判断符。

>>> len({ 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'})
    4
    
    >>> max({ 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'})
    'W'
    
    >>> min({ 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'})
    'E'
    
    >>> 'W' in { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
    True
    
    >>> '苍白之瀑'  not in { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
    True

#### 字典的特殊操作 ####

*  访问字典元素：

>>> { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['Q']
    '新月打击'
    
    >>> { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['R']
    '月神冲刺'
    
    >>> { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['E', 'R']
    Traceback (most recent call last):
      File "<pyshell#24>", line 1, in <module>
        { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['E', 'R']
    KeyError: ('E', 'R')
    
    >>> { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['E']['Q']
    Traceback (most recent call last):
      File "<pyshell#25>", line 1, in <module>
        { 'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['E']['Q']
    TypeError: string indices must be integers

--------------------