python_learn 七_组合数据类型

组合数据类型有：列表、元组、字典、集合
这些都是python序列，还有一个python序列是字符串

image.png

基本操作：

>>> a = [1, 2, 'sdf', [1, 2]]   #定义一个列表，里面的元素可以是任何类型
>>> a
[1, 2, 'sdf', [1, 2]]
>>> a[1]                        #对该列标进行索引，索引号从0开始
2
>>> a[2] = 7                    #对该列表的某个元素进行修改，修改完后重新打印
>>> a
[1, 2, 7, [1, 2]]

除了上述利用a = [ ]来定义列表，还可以用list函数来定义：list（）函数把可迭代对象转换为列表类型

>>> a = 'hello'
>>> b = list(a)
>>> b
['h', 'e', 'l', 'l', 'o']

附加：python中的列表类似于c语言中的数组，但是列表不需要预定义大小，数组则需要预定义大小。

列表的的索引：
类似于前面说过的，正向索引从0开始，反向索引从-1开始。
列表的操作方法：

（1）append（），insert（），extend（）
这3个方法均可用于向列表中添加元素，而且都属于原地操作，不影响列表对象在内存中的起始地址。

>>> a = [1, 3, 4, 'sdc']
>>> id(a)
1778034251912     #这串数字表示这个元组在内存的这个位置
>>> a.append("cks")
>>> a
[1, 3, 4, 'sdc', 'cks']
>>> id(a)
1778034251912     #这就表明append是原地修改，即不改变内存的地址
>>> a.insert(1,'python')   #在1的位置插入一个字符串python
>>> a
[1, 'python', 3, 4, 'sdc', 'cks']
>>> id(a)
1778034251912    #这就表明insert是原地修改，即不改变内存的地址
>>> c = ["wc", 2, 3]
>>> c.extend(a)
>>> c
['wc', 2, 3, 1, 'python', 3, 4, 'sdc', 'cks', 'wc', 2, 3]
>>> a.extend(c)
>>> a
[1, 'python', 3, 4, 'sdc', 'cks', 'wc', 2, 3, 'wc', 2, 3, 1, 'python', 3, 4, 'sdc', 'cks', 'wc', 2, 3]
>>> id(a)
1778034251912

（2）pop（）、remove（）、clear（）
这3个方法均可用于删除列表中的元素，而且也都属于原地操作，不影响列表对象在内存中的地址。另外del语句删除列表中的指定元素。

>>> a = [1, 3, 'scd', 4]
>>> a
[1, 3, 'scd', 4]
>>> id(a)
2503374902856
>>> a.pop()   #如果括号里面什么也不写，默认是最后一个元素
4
>>> a
[1, 3, 'scd']
>>> id(a)
2503374902856  #原地修改，地址不变
>>> a.pop(0)
1
>>> a
[3, 'scd']
>>> id(a)
2503374902856

>>> a.remove(3)   #这个3 不是索引号3 ，而是这个列表中的元素，remove是根据元素删元素，并返回删掉之后的列表。
>>> a
['scd']

>>> a = [1, 23, 'ece', 4, 6]
>>> del a[2]
>>> a
[1, 23, 4, 6]
>>> a.clear()
>>> a
[]

（3）count（），index（）
count（）用于返回列表中指定元素出现的次数，index（）用于返回指定元素在列表中首次出现的位置，如果该元素不在列表中则抛出异常。

>>> a = [1,2,3,4,5,6,4,3,1,2,7,8]
>>> a.count(4)
2
>>> a.index(4)
3

（4）sort（）、reverse（）
sort（）方法按照指定的规则对所有元素排序，默认升序；reverse（）将所有列表元素逆序或反转。

>>> a = [1,2,3,4,5,6,4,3,1,2,7,8]
>>> a.sort()
>>> a
[1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 7, 8]
>>> a.sort(reverse=True)
>>> a
[8, 7, 6, 5, 4, 4, 3, 3, 2, 2, 1, 1]

>>> a = [2,4,6,7]
>>> a.reverse()
>>> a
[7, 6, 4, 2]

sort（）和reverse（）方法分别对列表进行原地排序和逆序，没有返回值。

>>> a = [2,5,4,3]
>>> p = a.reverse()
>>> print(p)
None      #这就是没有返回值

（5）copy

>>> a = [1,2,3,4]
>>> b = a.copy()
>>> b
[1, 2, 3, 4]
>>> id(a)
2503377870344
>>> id(b)
2503378133640  #使用copy函数地址会变
#若利用赋值的方法，地址是不会变的，而且c变 a也变，但是copy就不一样了，b变a不变
>>> c = a
>>> c
[1, 2, 3, 4]
>>> id(c)
2503377870344
>>> c[1] = 9
>>> c
[1, 9, 3, 4]
>>> a
[1, 9, 3, 4]
>>> b[2] = 8
>>> b
[1, 2, 8, 4]
>>> a
[1, 9, 3, 4]

列表支持的运算符:
①加号

>>> a = [1,2,3]
>>> id(a)
2503378134088
>>> a = a + [4]
>>> a
[1, 2, 3, 4]
>>> id(a)
2503377907848
>>> a += [5]
>>> a
[1, 2, 3, 4, 5]
>>> id(a)
2503377907848
# a = a + [4]和a += [5]实现的功能一样，但是地址不一样

②乘法：类似于加法

>>> a = [1,2]
>>> id(a)
2503377515528
>>> a = a * 2
>>> a
[1, 2, 1, 2]
>>> id(a)
2503378133640
>>> a *= 2
>>> a
[1, 2, 1, 2, 1, 2, 1, 2]
>>> id(a)
2503378133640

2、元组
①所有元素放在圆括号（）内；
②如果元组中只有一个元素，必须在最后增加一个逗号；
③使用tuple创建空元组；
④支持双向索引；
⑤元组是不可变的。

>>> x = (1,2,3)
>>> x
(1, 2, 3)
>>> x[1]
2
>>> x[-1]
3
>>> type(x)
<class 'tuple'>
>>> b = (2,)
>>> type(b)
<class 'tuple'>
>>> c = (2)
>>> type(c)
<class 'int'>

#元组是不可变的
>>> a = (1,2,3,4,5)
>>> a[0]=5
Traceback (most recent call last):
  File "<pyshell#90>", line 1, in <module>
    a[0]=5
TypeError: 'tuple' object does not support item assignment

3、字典
①dict（）生成一个空字典
②键和值通过冒号连接组成的集合
{<键1>：<值1>，<键2>：<值2>，...<键n>：<值n>}
③字典内的键值对没有顺序且不能重复
④元素类型可以不同
⑤用花括号{}表示
⑥字典中是以键值对存储的，因此键就是值的索引
⑦字典是可变的，可以存储任意类型

空字典生成的两种方式
>>> d = dict()
>>> d
{}
>>> e = {}
>>> e
{}

字典元素的访问
字典中的每个元素表示一种映射或对应关系，根据提供的"键"作为下标可以访问对应的“值"，如果改"键"不存在，则抛出异常。

>>> d = {"name": "jack", "age":18, "sex": "男"}
>>> d
{'name': 'jack', 'age': 18, 'sex': '男'}
#读取里面的东西
>>> d[0]            #字典是无序序列，所以利用索引没有用
Traceback (most recent call last):
  File "<pyshell#104>", line 1, in <module>
    d[0]
KeyError: 0
>>> d['name']
'jack'
#改里面的东西
>>> d['name'] = 'sam'
>>> d
{'name': 'sam', 'age': 18, 'sex': '男'}

字典的操作方法
d.keys（）：返回字典中所有的键信息
d.values（）：返回字典中所有的值信息
d.items（）：返回字典中所有的键值对（键值对以元组类型表示）
d.get（key，default:）键存在则返回相应值，不存在则返回默认值default
d.clear（）：删除所有键值对，清空字典
d.popitem（）：随机从字典取出一个键值对，以元组形式返回，同时将该键值对从字典中删除
d.pop（key，default）：键存在则返回相应值，同时删除键值对，否则返回默认值default

（1）get（key，default）
返回指定"键”对应的“值"，并且允许该键不存在时返回特定的"值"。第二个元素可以省略，省略时则默认为空。

>>> d = {"name": "jack", "age":18, "sex": "man"}
>>> d.get('name')
'jack'
>>> d.get('name1',30)  #键值不存在，则返回自己设定的值30
30
>>> d.get('nam')         #键值不存在，自己也没有设定返回的值，则返回空格
>>> 

(2) d. items()
返回字典中所有键值对信息，返回结果是Python的一种内部数据类型dict_items。
如果希望更好地使用返回结果，可以转换为列表类型，键值对以元组类型表示。

>>> d = {"name": "jack", "age":18, "sex": "man"}
>>> d.items()
dict_items([('name', 'jack'), ('age', 18), ('sex', 'man')])

（3）d.values（）
返回字典中所有值的信息，返回结果是Python的一种内部数据类型dict_values.
如果希望更好地使用返回结果，可以转换为列表类型。

>>> d = {"name": "jack", "age":18, "sex": "man"}
>>> d.values()
dict_values(['jack', 18, 'man'])
>>> list(d.values())
['jack', 18, 'man']
>>> c = list(d.values())
>>> c
['jack', 18, 'man']  
>>> c[1]           #转换成列表就可以使用索引的方式找到了
18

（4）d.keys（）
返回键的信息，其他同（3）
（5）d.clear（）
删除字典中所有键值对，如果想要删除字典中的某一个元素，可以使用del命令。

>>> d = {"name": "jack", "age":18, "sex": "man"}
>>> d.clear()
>>> d
{}

>>> d = {"name": "jack", "age":18, "sex": "man"}
>>> del d['sex']
>>> d
{'name': 'jack', 'age': 18}

4、集合
①集合中的元素不可重复；
②元素类型只能是不可变类型；
③集合元素没有顺序，不能比较，不能排序；
④用花括号{}表示，没有索引和位置的概念；
⑤可使用set（）创建。

集合运算

上述类比韦恩图。

>>> a = {1,2,3,4,5,6}
>>> b = {5,6,7,8,9,10}
>>> a - b
{1, 2, 3, 4}
>>> a & b
{5, 6}
>>> a ^ b
{1, 2, 3, 4, 7, 8, 9, 10}
>>> a | b
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

集合操作方法
add（x）：若x不在集合中，则把x增加到该集合中；
remove（x）：若x在，则从该集合移除，不在则产生KeyError异常；
clear（）：移除集合中所有元素；
update（）：返回集合元素个数；
pop（）：随机删除并返回集合中的一个元素；
x in s:x是集合的元素，返回True，不是返回False；
x not in s:x不是集合的元素，返回True，是，返回False；
discard（）：从集合中删除一个特定的元素。

>>> a = {1,2,3}
>>> a.add(4)
>>> a
{1, 2, 3, 4}

>>> a = {1,2,3,4}
>>> a.update({3,4,5,6})
>>> a
{1, 2, 3, 4, 5, 6}

这样就可以利用集合的这一个特性去除列表中重复的元素

（2）discard()，clear()，remove()，popl()
discard（）方法从集合中删除一个特定的元素，如果元素不在集合中则忽略此操作，clear（）方法清空集合，remove（）方法删除集合中的元素，指定元素不存在则抛出异常，pop（）方法随机删除集合中的元素。

>>> a = {1, 2, 3, 4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.pop()
2
>>> a.clear()
>>> a
set()   #空集合