首先要讲到的就是元组
元组其实拥有列表的一些特性，可以存储不同类型的值，但在某些方面元组又比不上列表
定义一个元组，你可以不用加‘ [ ] ’，你只需用逗号隔开即可
例如
|
1
2
3
4
5
6
7
8
9
10
|
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
)
|
元组也能被嵌套
|
1
2
3
4
5
6
7
|
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'
|
在这里，元组和列表最大的不同就是元组是不可变的，不能通过直接赋值改变元组中的值
|
1
2
3
4
5
6
7
8
9
|
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
|
下面报了一个类型错误
但是，在元组里面可以包含列表，而列表有是可变的，所以说元组是包含可变对象
|
1
2
3
4
5
6
|
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
])
|
在这里，要注意，括号是可以不用加上的，但为什么规范起见，还是尽量要把括号加上
元组是可以为空的，你只需要在赋值的时候加一个括号即可
|
1
2
3
4
|
In [
16
]: my_tuple
=
()
In [
17
]:
len
(my_tuple)
Out[
17
]:
0
|
如果你想创建一个只有一个元素的元组，那么你只需要在最后加上一个逗号就可以了
|
1
2
3
4
5
6
7
|
In [
18
]: my_tuple
=
"susmote"
,
In [
19
]: my_tuple
Out[
19
]: (
'susmote'
,)
In [
20
]:
len
(my_tuple)
Out[
20
]:
1
|
元组是一个包含多个值的列表集合，所以我们可以直接获取其中的值，并赋给一个变量
|
1
2
3
4
5
6
7
8
9
10
11
|
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中也可以这样简单的认为
声明一个要用到花括号" { } "，你要把值全部加到括号里面
首先集合的一个重要概念就是无序
例如，我们声明一个集合
|
1
2
3
4
|
In [
32
]: my_set
=
{
'a'
,
'b'
,
'c'
,
'd'
}
In [
33
]:
print
(my_set)
{
'b'
,
'd'
,
'c'
,
'a'
}
|
很清晰的看出他是无序的
同时你也可以通过判断语句" in "来获取某个元素是否存在与集合中,他返回一个布尔类型
|
1
2
3
4
5
6
7
|
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代表假（相信大家都知道）
然后集合还有一个概念就是里面的元素只能是唯一的，如果有重复的，会自动移除
|
1
2
3
4
|
In [
1
]: my_set
=
{
'a'
,
'b'
,
'b'
,
'c'
,
'c'
,
'd'
}
In [
2
]: my_set
Out[
2
]: {
'a'
,
'b'
,
'c'
,
'd'
}
|
除了通过花括号赋值，我们还可以直接调用 set() 方法，生成一个集合
|
1
2
3
4
|
In [
3
]: my_set
=
set
(
'abcdefgabcdefg'
)
In [
4
]: my_set
Out[
4
]: {
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
,
'g'
}
|
下面我们要讲到集合的一个重要的概念
集合的运算
“ - ” 差运算
|
1
2
3
4
5
6
|
In [
5
]: a
=
set
(
'abcde'
)
In [
6
]: b
=
set
(
'bdfgh'
)
In [
7
]: a
-
b
Out[
7
]: {
'a'
,
'c'
,
'e'
}
|
只保留a独有的元素，其他的如有与b相同的则移除
“ | ” 并运算
|
1
2
3
4
5
6
|
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所有的元素，如果有重复的则只留一个
“ & ” 交运算，求交集
|
1
2
3
4
5
6
|
In [
11
]: a
=
set
(
'abcde'
)
In [
12
]: b
=
set
(
'bdfgh'
)
In [
13
]: a & b
Out[
13
]: {
'b'
,
'd'
}
|
只保留a集合和b集合中相同的元素
“ ^ ” 求交集的补集
|
1
2
3
4
5
6
|
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（值），再加一个值的话，用逗号隔开
例如，我们下面定义一个字典
|
1
2
3
4
|
In [
23
]: my_dict
=
{
'name'
:
"susmote"
,
'age'
:
18
,
'tel'
:
1348888888
}
In [
24
]: my_dict
Out[
24
]: {
'age'
:
18
,
'name'
:
'susmote'
,
'tel'
:
1348888888
}
|
下面我们通过key来获取值
|
1
2
3
4
5
6
7
|
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()”方法来删除
|
1
2
3
4
5
6
7
8
9
|
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
|
1
2
3
4
5
6
7
|
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的首字母顺序进行排序
|
1
2
3
4
|
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是否存在与集合中，当然字典也是可以的，同样也是返回一个布尔类型
|
1
2
3
4
5
6
7
|
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
}
|