Python的数据类型3元组，集合和字典

首先要讲到的就是元组

元组其实拥有列表的一些特性，可以存储不同类型的值，但在某些方面元组又比不上列表

定义一个元组，你可以不用加‘ [ ] ’，你只需用逗号隔开即可

例如

In [1]: my_tuple = "susmote", 28, 123456789

In [2]: my_tuple[0]

Out[2]: 'susmote'

In [3]: my_tuple[1]

Out[3]: 28

In [4]: my_tuple

Out[4]: ('susmote', 28, 123456789)

元组也能被嵌套

In [5]: nested_t = my_tuple, (4, 3, 2, 1)

In [6]: nested_t

Out[6]: (('susmote', 28, 123456789), (4, 3, 2, 1))

In [7]: nested_t[0][0]

Out[7]: 'susmote'

在这里，元组和列表最大的不同就是元组是不可变的，不能通过直接赋值改变元组中的值

In [8]: my_tuple = "susmote", 28, 123456789

In [9]: my_tuple[0] = "ayesup"

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

TypeError Traceback (most recent call last)

<ipython-input-9-d99875c0ce61> in <module>()

----> 1 my_tuple[0] = "ayesup"

TypeError: 'tuple' object does not support item assignment

　　下面报了一个类型错误

但是，在元组里面可以包含列表，而列表有是可变的，所以说元组是包含可变对象

In [11]: my_tuple = ([1, 2, 3],[4, 5, 6])

In [12]: my_tuple[0][0] = 7

In [13]: my_tuple

Out[13]: ([7, 2, 3], [4, 5, 6])

　　在这里，要注意，括号是可以不用加上的，但为什么规范起见，还是尽量要把括号加上

元组是可以为空的，你只需要在赋值的时候加一个括号即可

In [16]: my_tuple = ()

In [17]: len(my_tuple)

Out[17]: 0

如果你想创建一个只有一个元素的元组，那么你只需要在最后加上一个逗号就可以了

In [18]: my_tuple = "susmote",

In [19]: my_tuple

Out[19]: ('susmote',)

In [20]: len(my_tuple)

Out[20]: 1

元组是一个包含多个值的列表集合，所以我们可以直接获取其中的值，并赋给一个变量

In [27]: my_tuple = "susmote",123456, 18

In [28]: my_tuple = "susmote", 18, 13488888888

In [29]: name, age, phone = my_tuple

In [30]: name

Out[30]: 'susmote'

In [31]: phone

Out[31]: 13488888888

接下来我们讲一下集合

集合相信大家应该不陌生，初中的时候应该是学过的，当然你如果说你没上个初中，那就另当别论了

由一个或多个确定的元素所构成的整体叫做集合。这是数学中的概念，在python中也可以这样简单的认为

声明一个要用到花括号" { } "，你要把值全部加到括号里面

首先集合的一个重要概念就是无序

例如，我们声明一个集合

In [32]: my_set = {'a', 'b', 'c', 'd'}

In [33]: print(my_set)

{'b', 'd', 'c', 'a'}

　　很清晰的看出他是无序的

同时你也可以通过判断语句" in "来获取某个元素是否存在与集合中,他返回一个布尔类型

In [36]: my_set = {'a', 'b', 'c', 'd'}

In [37]: 'a' in my_set

Out[37]: True

In [38]: 'e' in my_set

Out[38]: False

　　tips：Ture代表真，false代表假（相信大家都知道）

然后集合还有一个概念就是里面的元素只能是唯一的，如果有重复的，会自动移除

In [1]: my_set = {'a', 'b', 'b', 'c', 'c', 'd'}

In [2]: my_set

Out[2]: {'a', 'b', 'c', 'd'}

除了通过花括号赋值，我们还可以直接调用 set() 方法，生成一个集合

In [3]: my_set = set('abcdefgabcdefg')

In [4]: my_set

Out[4]: {'a', 'b', 'c', 'd', 'e', 'f', 'g'}

下面我们要讲到集合的一个重要的概念

集合的运算

“ - ” 差运算

In [5]: a = set('abcde')

In [6]: b = set('bdfgh')

In [7]: a - b

Out[7]: {'a', 'c', 'e'}

　　只保留a独有的元素，其他的如有与b相同的则移除

“ | ” 并运算

In [8]: a = set('abcde')

In [9]: b = set('bdfgh')

In [10]: a | b

Out[10]: {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}

　　包含a和b所有的元素，如果有重复的则只留一个

“ & ” 交运算，求交集

In [11]: a = set('abcde')

In [12]: b = set('bdfgh')

In [13]: a & b

Out[13]: {'b', 'd'}

　　只保留a集合和b集合中相同的元素

“ ^ ” 求交集的补集

In [16]: a = set('abcde')

In [17]: b = set('bdfgh')

In [18]: a ^ b

Out[18]: {'a', 'c', 'e', 'f', 'g', 'h'}

　　保留a和b都单独存在的元素，去除a与b相同的元素

关于集合我们主要需要了解的只有这些，至于运用，后续讲

在这我们再讲最后一种数据类型

字典（ Dictionaries）

在python中，字典是一个很常用的数据类型。在其他语言中，也有叫做关联数组的

字典不像列表，元组，存在自动有顺序的索引（index）

字典中的索引也就是必须手动建立的Key（键），每个键对应一个value（值）

而且键除了普通的数值类型之外，还可以用“String”类型

定义一个字典要用到“ { } ”,每个key后面加“ : ”（冒号）接value（值），再加一个值的话，用逗号隔开

例如，我们下面定义一个字典

In [23]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}

In [24]: my_dict

Out[24]: {'age': 18, 'name': 'susmote', 'tel': 1348888888}

下面我们通过key来获取值

In [20]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}

In [21]: my_dict["name"]

Out[21]: 'susmote'

In [22]: my_dict["tel"]

Out[22]: 1348888888

如果你觉得里面有个元素没用了，你可以通过 “del()”方法来删除

In [23]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}

In [24]: my_dict

Out[24]: {'age': 18, 'name': 'susmote', 'tel': 1348888888}

In [25]: del my_dict["tel"]

In [26]: my_dict

Out[26]: {'age': 18, 'name': 'susmote'}

你可以通过list()方法列出字典里所有的key，或者是所有的value

In [32]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}

In [33]: list(my_dict.keys())

Out[33]: ['name', 'age', 'tel']

In [34]: list(my_dict.values())

Out[34]: ['susmote', 18, 1348888888]

排序，通过sorted()方法按照key的首字母顺序进行排序

In [5]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}

In [6]: sorted(my_dict.keys())

Out[6]: ['age', 'name', 'tel']

前面讲到集合可以通过 “in” "not in"判断一个keys是否存在与集合中，当然字典也是可以的，同样也是返回一个布尔类型

In [41]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}

In [42]: 'name' in my_dict

Out[42]: True

In [43]: 'name'not in my_dict

Out[43]: False

使用dict() 生成字典

1 2	`In [44]:` `dict([('name',` `'susmote'), ('age',` `18), ('Tel',` `13488888888)])` `Out[44]: {'Tel':` `13488888888,` `'age':` `18,` `'name':` `'susmote'}`

　　也可以直接这样（字符串类型简单的时候）

1 2	`In [45]:` `dict(name` `=` `"susmote", age` `=` `18, tel` `=` `13488888888)` `Out[45]: {'age':` `18,` `'name':` `'susmote',` `'tel':` `13488888888}`

python的数据类型大概就是这些，有一些知识点，我会在后面学了控制循环语句之后在讲