Python的資料型別3元組，集合和字典
首先要講到的就是元組
元組其實擁有列表的一些特性，可以儲存不同型別的值，但在某些方面元組又比不上列表
定義一個元組，你可以不用加‘ [ ] ’，你只需用逗號隔開即可
例如
| 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 [
|