中信建投 & 課程

昵稱6262245 2020-03-17

展開全文

## 什么是Python？

Python是一種計算機(jī)程序設(shè)計語言。你可能已經(jīng)聽說過很多種流行的編程語言，比如非常難學(xué)的C語言，非常流行的Java語言，適合初學(xué)者的Basic語言，適合網(wǎng)頁編程的JavaScript語言等等。

那Python是一種什么語言？

首先，我們普及一下編程語言的基礎(chǔ)知識。用任何編程語言來開發(fā)程序，都是為了讓計算機(jī)干活，比如下載一個MP3，編寫一個文檔等等，而計算機(jī)干活的CPU只認(rèn)識機(jī)器指令，所以，盡管不同的編程語言差異極大，最后都得“翻譯”成CPU可以執(zhí)行的機(jī)器指令。而不同的編程語言，干同一個活，編寫的代碼量，差距也很大。

比如，完成同一個任務(wù)，C語言要寫1000行代碼，Java只需要寫100行，而Python可能只要20行。

所以Python是一種相當(dāng)高級的語言。

你也許會問，代碼少還不好？代碼少的代價是運(yùn)行速度慢，C程序運(yùn)行1秒鐘，Java程序可能需要2秒，而Python程序可能就需要10秒。

那是不是越低級的程序越難學(xué)，越高級的程序越簡單？表面上來說，是的，但是，在非常高的抽象計算中，高級的Python程序設(shè)計也是非常難學(xué)的，所以，高級程序語言不等于簡單。

但是，對于初學(xué)者和完成普通任務(wù)，Python語言是非常簡單易用的。連Google都在大規(guī)模使用Python，你就不用擔(dān)心學(xué)了會沒用。

用Python可以做什么？可以做日常任務(wù)，比如自動備份你的MP3；可以做網(wǎng)站，很多著名的網(wǎng)站包括YouTube就是Python寫的；可以做網(wǎng)絡(luò)游戲的后臺，很多在線游戲的后臺都是Python開發(fā)的?？傊褪悄芨珊芏嗪芏嗍吕?。

Python當(dāng)然也有不能干的事情，比如寫操作系統(tǒng)，這個只能用C語言寫；寫手機(jī)應(yīng)用，只能用Swift/Objective-C（針對iPhone）和Java（針對Android）；寫3D游戲，最好用C或C++。

本篇教程將講述Python基礎(chǔ)的<font color=red>數(shù)據(jù)類型</font>

什么是Python？?

Python是一種計算機(jī)程序設(shè)計語言。你可能已經(jīng)聽說過很多種流行的編程語言，比如非常難學(xué)的C語言，非常流行的Java語言，適合初學(xué)者的Basic語言，適合網(wǎng)頁編程的JavaScript語言等等。

那Python是一種什么語言？

首先，我們普及一下編程語言的基礎(chǔ)知識。用任何編程語言來開發(fā)程序，都是為了讓計算機(jī)干活，比如下載一個MP3，編寫一個文檔等等，而計算機(jī)干活的CPU只認(rèn)識機(jī)器指令，所以，盡管不同的編程語言差異極大，最后都得“翻譯”成CPU可以執(zhí)行的機(jī)器指令。而不同的編程語言，干同一個活，編寫的代碼量，差距也很大。

比如，完成同一個任務(wù)，C語言要寫1000行代碼，Java只需要寫100行，而Python可能只要20行。

所以Python是一種相當(dāng)高級的語言。

你也許會問，代碼少還不好？代碼少的代價是運(yùn)行速度慢，C程序運(yùn)行1秒鐘，Java程序可能需要2秒，而Python程序可能就需要10秒。

那是不是越低級的程序越難學(xué)，越高級的程序越簡單？表面上來說，是的，但是，在非常高的抽象計算中，高級的Python程序設(shè)計也是非常難學(xué)的，所以，高級程序語言不等于簡單。

但是，對于初學(xué)者和完成普通任務(wù)，Python語言是非常簡單易用的。連Google都在大規(guī)模使用Python，你就不用擔(dān)心學(xué)了會沒用。

用Python可以做什么？可以做日常任務(wù)，比如自動備份你的MP3；可以做網(wǎng)站，很多著名的網(wǎng)站包括YouTube就是Python寫的；可以做網(wǎng)絡(luò)游戲的后臺，很多在線游戲的后臺都是Python開發(fā)的?？傊褪悄芨珊芏嗪芏嗍吕?。

Python當(dāng)然也有不能干的事情，比如寫操作系統(tǒng)，這個只能用C語言寫；寫手機(jī)應(yīng)用，只能用Swift/Objective-C（針對iPhone）和Java（針對Android）；寫3D游戲，最好用C或C++。

本篇教程將講述Python基礎(chǔ)的數(shù)據(jù)類型

# 基本的數(shù)據(jù)類型

在Python中，能夠直接處理的數(shù)據(jù)類型有以下幾種：

## 整數(shù)

Python可以處理任意大小的整數(shù)，包括負(fù)整數(shù)，寫程序的時候表述與數(shù)學(xué)上的方法一樣，例如：<font color=#0099ff>99</font>，<font color=#0099ff>-3</font>，<font color=#0099ff>6666</font> 等等。

## 浮點(diǎn)數(shù)

浮點(diǎn)數(shù)也可以稱為小數(shù)。叫做浮點(diǎn)數(shù)是因?yàn)榘凑湛茖W(xué)記數(shù)法表示時，一個浮點(diǎn)數(shù)的小數(shù)點(diǎn)位置是可變的。比如，<font color=#0099ff>1.11x10<sup>6</sup></font>和<font color=#0099ff>11.1x10<sup>5</sup></font>是完全相等的。對于很大或很小的浮點(diǎn)數(shù)，必須用科學(xué)計數(shù)法表示，把10用e替代，<font color=#0099ff>1.11x10<sup>6</sup></font>就是<font color=#0099ff>1.11e6</font>，或者<font color=#0099ff>11.1e5</font>，<font color=#0099ff>0.0000011</font>可以寫成<font color=#0099ff>1.1e-6</font>。負(fù)數(shù)的話直接在前面加負(fù)號即可，例如：<font color=#0099ff>-1.1e-6</font>。

**需要注意的一點(diǎn)是，整數(shù)和浮點(diǎn)數(shù)在計算機(jī)內(nèi)部存儲的方式是不同的，<font color=red>整數(shù)</font>之間的運(yùn)算永遠(yuǎn)是精確的，而<font color=red>浮點(diǎn)數(shù)</font>運(yùn)算則可能會有四舍五入的誤差。**

## 字符串

字符串是以單引號<font color=#0099ff> ' </font>或雙引號<font color=#0099ff> " </font>括起來的任意文本<font color=#0099ff>' '</font>或<font color=#0099ff>" "</font>只是一種表示方式，不是字符串的一部分，所以字符串<font color=#0099ff>'rice'</font>只有<font color=#0099ff>r</font>，<font color=#0099ff>i</font>，<font color=#0099ff>c</font>，<font color=#0099ff>e</font>這4個字符。如果要把<font color=#0099ff>'</font>本身也包括進(jìn)字符里，那就可以用<font color=#0099ff>" "</font>括起來。如果字符串內(nèi)部既包含<font color=#0099ff> ' </font>又包含<font color=#0099ff> " </font>怎么辦呢？我們可以用轉(zhuǎn)義字符<font color=#0099ff> \ </font>來標(biāo)識，例如：<font color=#0099ff>'I\'m \"OK\"!'</font>表示的內(nèi)容為：<font color=#0099ff>I'm "OK"!</font>

轉(zhuǎn)義字符<font color=#0099ff>\</font>可以轉(zhuǎn)義很多字符，比如<font color=#0099ff>\n</font>表示換行，<font color=#0099ff>\t</font>表示制表符，字符\本身也要轉(zhuǎn)義，所以<font color=#0099ff>\\</font>表示的字符就是<font color=#0099ff>\</font>，用print()打印字符串看看結(jié)果如何：

基本的數(shù)據(jù)類型?

在Python中，能夠直接處理的數(shù)據(jù)類型有以下幾種：

整數(shù)?

Python可以處理任意大小的整數(shù)，包括負(fù)整數(shù)，寫程序的時候表述與數(shù)學(xué)上的方法一樣，例如：99，-3，6666 等等。

浮點(diǎn)數(shù)?

浮點(diǎn)數(shù)也可以稱為小數(shù)。叫做浮點(diǎn)數(shù)是因?yàn)榘凑湛茖W(xué)記數(shù)法表示時，一個浮點(diǎn)數(shù)的小數(shù)點(diǎn)位置是可變的。比如，1.11x10⁶和11.1x10⁵是完全相等的。對于很大或很小的浮點(diǎn)數(shù)，必須用科學(xué)計數(shù)法表示，把10用e替代，1.11x10⁶就是1.11e6，或者11.1e5，0.0000011可以寫成1.1e-6。負(fù)數(shù)的話直接在前面加負(fù)號即可，例如：-1.1e-6。

需要注意的一點(diǎn)是，整數(shù)和浮點(diǎn)數(shù)在計算機(jī)內(nèi)部存儲的方式是不同的，整數(shù)之間的運(yùn)算永遠(yuǎn)是精確的，而浮點(diǎn)數(shù)運(yùn)算則可能會有四舍五入的誤差。

字符串?

字符串是以單引號 ' 或雙引號 " 括起來的任意文本' '或" "只是一種表示方式，不是字符串的一部分，所以字符串'rice'只有r，i，c，e這4個字符。如果要把'本身也包括進(jìn)字符里，那就可以用" "括起來。如果字符串內(nèi)部既包含 ' 又包含 " 怎么辦呢？我們可以用轉(zhuǎn)義字符 \ 來標(biāo)識，例如：'I\'m \"OK\"!'表示的內(nèi)容為：I'm "OK"!

轉(zhuǎn)義字符\可以轉(zhuǎn)義很多字符，比如\n表示換行，\t表示制表符，字符\本身也要轉(zhuǎn)義，所以\表示的字符就是\，用print()打印字符串看看結(jié)果如何：

In [1]:

print('I\'m \"OK\"!')

I'm "OK"!

In [2]:

print('CHINA SECURITIES is\ngreat')

CHINA SECURITIES is
great

In [3]:

print('\\\t\\')

## 布爾值

布爾值和布爾代數(shù)的表示完全一致，一個布爾值只有<font color=#0099ff>True</font>、<font color=#0099ff>False</font>兩種值。Python中，既可以直接用<font color=#0099ff>True</font>、<font color=#0099ff>False</font>表示（<font color=red>一定要大寫</font>），也可以通過布爾運(yùn)算計算出來：

布爾值?

布爾值和布爾代數(shù)的表示完全一致，一個布爾值只有True、False兩種值。Python中，既可以直接用True、False表示（一定要大寫），也可以通過布爾運(yùn)算計算出來：

In [4]:

True

Out[4]:

True

In [5]:

False

Out[5]:

False

In [6]:

1>0

Out[6]:

True

布爾值可以用<font color=#0099ff>and</font>、<font color=#0099ff>or</font>和<font color=#0099ff>not</font>即與、或和非進(jìn)行運(yùn)算。

布爾值可以用and、or和not即與、或和非進(jìn)行運(yùn)算。

In [7]:

True and False

Out[7]:

False

In [8]:

1 > 2 or 3 < 10

Out[8]:

True

In [9]:

not 3 < 10

Out[9]:

False

## 列表

Python內(nèi)嵌的數(shù)據(jù)類型主要包括以下兩類：

### 有序：

List（列表），是有序集合，沒有固定大小，可以通過對偏移量以及其他方法修改列表大小。列表的基本形式如：[1,2,3,4]

Tuple（元組），是有序集合，是不可變的，可以進(jìn)行組合和復(fù)制運(yùn)算后會生成一個新的元組。元組的基本形式比如：(1,3,6,10)

String（字符串），也是有序集合，字符串的基本形式比如：’hello’，這里不進(jìn)行具體介紹。

### 無序：

Set（集合），是一個無序不重復(fù)元素的集。基本功能包括關(guān)系運(yùn)算和消除重復(fù)元素。集合的基本形式如：set('abracadabra')

Dictionary（字典）是無序的鍵：值對 (key:value 對)集合，鍵必須是互不相同的(在同一個字典之內(nèi))。字典的基本形式如：{'jack': 4098, 'sape': 4139}

首先對列表進(jìn)行介紹。

List（列表） 是 Python 中最通用的序列。列表是一個任意類型對象位置的相關(guān)有序集合，它沒有固定大小。不像字符串，其大小是可以變的，通過對偏移量進(jìn)行賦值以及其他各種列表的方法進(jìn)行調(diào)用，可以修改列表大小。

### 索引是從0開始而非1開始?。?/span>

列表中值的分割用變量[頭下標(biāo):尾下標(biāo)]，就可以截取相應(yīng)的列表，從左到右索引默認(rèn)“0”開始的，從右到左索引默認(rèn)-1開始，下標(biāo)可以為空表示取到頭或尾?？梢詫α斜磉M(jìn)行索引、切片等操作，看下面例子。

列表?

Python內(nèi)嵌的數(shù)據(jù)類型主要包括以下兩類：

有序：?

List（列表），是有序集合，沒有固定大小，可以通過對偏移量以及其他方法修改列表大小。列表的基本形式如：[1,2,3,4]

Tuple（元組），是有序集合，是不可變的，可以進(jìn)行組合和復(fù)制運(yùn)算后會生成一個新的元組。元組的基本形式比如：(1,3,6,10)

String（字符串），也是有序集合，字符串的基本形式比如：’hello’，這里不進(jìn)行具體介紹。

無序：?

Set（集合），是一個無序不重復(fù)元素的集?；竟δ馨P(guān)系運(yùn)算和消除重復(fù)元素。集合的基本形式如：set('abracadabra')

Dictionary（字典）是無序的鍵：值對 (key:value 對)集合，鍵必須是互不相同的(在同一個字典之內(nèi))。字典的基本形式如：{'jack': 4098, 'sape': 4139} 首先對列表進(jìn)行介紹。

List（列表）是 Python 中最通用的序列。列表是一個任意類型對象位置的相關(guān)有序集合，它沒有固定大小。不像字符串，其大小是可以變的，通過對偏移量進(jìn)行賦值以及其他各種列表的方法進(jìn)行調(diào)用，可以修改列表大小。

索引是從0開始而非1開始！！?

列表中值的分割用變量[頭下標(biāo):尾下標(biāo)]，就可以截取相應(yīng)的列表，從左到右索引默認(rèn)“0”開始的，從右到左索引默認(rèn)-1開始，下標(biāo)可以為空表示取到頭或尾。可以對列表進(jìn)行索引、切片等操作，看下面例子。

列出一周5個工作日可以使用list：

列出一周5個工作日可以使用list：

In [10]:

week = ['Monday','Tuesday','Wednesday','Thursday','Friday']

week

Out[10]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

week是一個list，可以用len()獲取其元素個數(shù)：

week是一個list，可以用len()獲取其元素個數(shù)：

In [11]:

len(week)

Out[11]:

可以使用索引來訪問list中的每一個位置上的元素，不過一定要記住<font color=red>**索引是從0開始的??！**</font>

可以使用索引來訪問list中的每一個位置上的元素，不過一定要記住索引是從0開始的?。?/strong>

In [12]:

week[0]

Out[12]:

'Monday'

In [13]:

week[3]

Out[13]:

'Thursday'

In [14]:

week[5]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-14-aab97e4d2f9f> in <module>()
----> 1 week[5]

IndexError: list index out of range

當(dāng)索引超出了范圍時，Python會報一個<font color=#0099ff>IndexError</font>錯誤。由于索引是從<font color=#0099ff>0</font>開始的，最后一個元素的索引是<font color=#0099ff>列表長度 - 1</font>。

python支持從列表最后取元素，如果要取最后一個元素，可以用<font color=#0099ff>-1</font>做索引，直接獲取最后一個元素：

當(dāng)索引超出了范圍時，Python會報一個IndexError錯誤。由于索引是從0開始的，最后一個元素的索引是列表長度 - 1。

python支持從列表最后取元素，如果要取最后一個元素，可以用-1做索引，直接獲取最后一個元素：

In [15]:

week[-1]

Out[15]:

'Friday'

In [16]:

week[-4]

Out[16]:

'Tuesday'

由于list是一個可變的有序表，所以我們可以往list中追加元素到末尾：

由于list是一個可變的有序表，所以我們可以往list中追加元素到末尾：

In [17]:

week.append('Saturday')

week

Out[17]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

還可以吧元素插入到指定的位置，比如索引號為<font color=#0099ff>6</font>的位置：

還可以吧元素插入到指定的位置，比如索引號為6的位置：

In [18]:

week.insert(6,'Sunday')

week

Out[18]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

刪除list末尾的元素，使用<font color=#0099ff>pop()</font>方法：

刪除list末尾的元素，使用pop()方法：

In [19]:

week.pop()

week

Out[19]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

刪除list中指定位置的元素，使用<font color=#0099ff>pop(i)</font>方法，<font color=#0099ff>i</font>是對應(yīng)的索引位置：

刪除list中指定位置的元素，使用pop(i)方法，i是對應(yīng)的索引位置：

In [20]:

week.pop(1)

week

Out[20]:

['Monday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

把某個元素替換成別的元素，可以直接賦值給對應(yīng)的索引位置：

把某個元素替換成別的元素，可以直接賦值給對應(yīng)的索引位置：

In [21]:

week[0] = 'Tuesday'

week

Out[21]:

['Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

### Python 的列表數(shù)據(jù)類型包含更多的方法。

<font color=#0099ff>list.append(x)</font> 把一個元素添加到列表的結(jié)尾。

<font color=#0099ff>list.extend(L)</font> 將一個給定列表中的所有元素都添加到另一個列表中。

<font color=#0099ff>list.insert(i, x)</font> 在指定位置插入一個元素。第一個參數(shù)是準(zhǔn)備插入到其前面的那個元素的索引，例如 a.insert(0, x) 會插入到整個列表之前，而 a.insert(len(a), x) 相當(dāng)于 a.append(x)。

<font color=#0099ff>list.remove(x)</font> 刪除列表中值為 x 的第一個元素。如果沒有這樣的元素，就會返回一個錯誤。

<font color=#0099ff>list.pop([i])</font> 從列表的指定位置刪除元素，并將其返回。如果沒有指定索引，a.pop() 返回最后一個元素。元素隨即從鏈表中被刪除。(方法中 i 兩邊的方括號表示這個參數(shù)是可選的，而不是要求你輸入一對方括號，這個經(jīng)常會在 Python 庫參考手冊中遇到這樣的標(biāo)記。)

<font color=#0099ff>list.index(x)</font> 返回列表中第一個值為 x 的元素的索引。如果沒有匹配的元素就會返回一個錯誤。

<font color=#0099ff>list.count(x)</font> 返回 x 在鏈表中出現(xiàn)的次數(shù)。

<font color=#0099ff>list.sort(cmp=None, key=None, reverse=False)</font> 對列表中的元素進(jìn)行排序（參數(shù)可以用來自定義排序方法，參考 sorted() 的更詳細(xì)的解釋）。

<font color=#0099ff>list.reverse()</font> 就地倒排鏈表中的元素

<font color=#0099ff>del list[i] </font>有個方法可以從列表中按給定的索引而不是值來刪除一個子項(xiàng)：del 語句。它不同于有返回值的 pop() 方法。語句 del 還可以從列表中刪除切片或清空整個列表(我們以前介紹過一個方法是將空列表賦值給列表的切片)。

Python 的列表數(shù)據(jù)類型包含更多的方法。?

list.append(x) 把一個元素添加到列表的結(jié)尾。

list.extend(L) 將一個給定列表中的所有元素都添加到另一個列表中。

list.insert(i, x) 在指定位置插入一個元素。第一個參數(shù)是準(zhǔn)備插入到其前面的那個元素的索引，例如 a.insert(0, x) 會插入到整個列表之前，而 a.insert(len(a), x) 相當(dāng)于 a.append(x)。

list.remove(x) 刪除列表中值為 x 的第一個元素。如果沒有這樣的元素，就會返回一個錯誤。

list.pop([i]) 從列表的指定位置刪除元素，并將其返回。如果沒有指定索引，a.pop() 返回最后一個元素。元素隨即從鏈表中被刪除。(方法中 i 兩邊的方括號表示這個參數(shù)是可選的，而不是要求你輸入一對方括號，這個經(jīng)常會在 Python 庫參考手冊中遇到這樣的標(biāo)記。)

list.index(x) 返回列表中第一個值為 x 的元素的索引。如果沒有匹配的元素就會返回一個錯誤。

list.count(x) 返回 x 在鏈表中出現(xiàn)的次數(shù)。

list.sort(cmp=None, key=None, reverse=False) 對列表中的元素進(jìn)行排序（參數(shù)可以用來自定義排序方法，參考 sorted() 的更詳細(xì)的解釋）。

list.reverse() 就地倒排鏈表中的元素

del list[i] 有個方法可以從列表中按給定的索引而不是值來刪除一個子項(xiàng)：del 語句。它不同于有返回值的 pop() 方法。語句 del 還可以從列表中刪除切片或清空整個列表(我們以前介紹過一個方法是將空列表賦值給列表的切片)。

## 字典（dictionary）

字典在某些語言中可能稱為 聯(lián)合內(nèi)存 (associative memories) 或 聯(lián)合數(shù)組 (associative arrays)。序列是以連續(xù)的整數(shù)為索引，與此不同的是，字典以"關(guān)鍵字"為索引，關(guān)鍵字可以是任意不可變類型，通常用字符串或數(shù)值。如果元組中只包含字符串和數(shù)字，它可以作為關(guān)鍵字，如果它直接或間接地包含了可變對象，就不能當(dāng)做關(guān)鍵字。不能用列表做關(guān)鍵字，因?yàn)榱斜砜梢杂盟饕⑶懈罨蛘?append() 和 extend() 等方法改變。

字典是無序的鍵：值對 (key:value 對)集合，鍵必須是互不相同的(在同一個字典之內(nèi))。使用大括號創(chuàng)建一個空的字典：{}。初始化列表時，在大括號內(nèi)放置一組逗號分隔的鍵：值對，這也是字典輸出的方式。

字典的主要操作是依據(jù)鍵來存儲和取值。也可以用 del 來刪除鍵：值對(key:value)，從一個不存在的鍵中取值會導(dǎo)致錯誤。

字典（dictionary）?

字典在某些語言中可能稱為聯(lián)合內(nèi)存 (associative memories) 或聯(lián)合數(shù)組 (associative arrays)。序列是以連續(xù)的整數(shù)為索引，與此不同的是，字典以"關(guān)鍵字"為索引，關(guān)鍵字可以是任意不可變類型，通常用字符串或數(shù)值。如果元組中只包含字符串和數(shù)字，它可以作為關(guān)鍵字，如果它直接或間接地包含了可變對象，就不能當(dāng)做關(guān)鍵字。不能用列表做關(guān)鍵字，因?yàn)榱斜砜梢杂盟饕?、切割或?append() 和 extend() 等方法改變。

字典是無序的鍵：值對 (key:value 對)集合，鍵必須是互不相同的(在同一個字典之內(nèi))。使用大括號創(chuàng)建一個空的字典：{}。初始化列表時，在大括號內(nèi)放置一組逗號分隔的鍵：值對，這也是字典輸出的方式。

字典的主要操作是依據(jù)鍵來存儲和取值。也可以用 del 來刪除鍵：值對(key:value)，從一個不存在的鍵中取值會導(dǎo)致錯誤。

In [22]:

d = {'rice':35, 'wheat':101, 'corn':67}

print(d)

print(d['rice'])

{'corn': 67, 'wheat': 101, 'rice': 35}
35

把數(shù)據(jù)放入dict還可以直接通過key放入：

把數(shù)據(jù)放入dict還可以直接通過key放入：

In [23]:

d['egg'] = 33

Out[23]:

{'corn': 67, 'egg': 33, 'rice': 35, 'wheat': 101}

一個key只能對應(yīng)一個value，多次對一個key放入value，后面的值會把前面的值沖掉：

一個key只能對應(yīng)一個value，多次對一個key放入value，后面的值會把前面的值沖掉：

In [24]:

d['corn'] = 88

Out[24]:

{'corn': 88, 'egg': 33, 'rice': 35, 'wheat': 101}

如果key不存在，dict就會報錯。要避免key不存在的錯誤，有兩種辦法，一是通過<font color=#0099ff> in </font>判斷key是否存在，二是通過dict提供的<font color=#0099ff> get </font>方法，如果key不存在，可以返回None（返回None的時候Python的交互式命令行不顯示結(jié)果），或者自己指定的value：

如果key不存在，dict就會報錯。要避免key不存在的錯誤，有兩種辦法，一是通過 in 判斷key是否存在，二是通過dict提供的 get 方法，如果key不存在，可以返回None（返回None的時候Python的交互式命令行不顯示結(jié)果），或者自己指定的value：

In [25]:

d['meat']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-25-d3e7ffd8023e> in <module>()
----> 1 d['meat']

KeyError: 'meat'

In [26]:

'meat' in d

Out[26]:

False

In [27]:

d.get('meat')

In [28]:

d.get('meat',45)

Out[28]:

刪除一個key，使用<font color=#0099ff>pop(key)</font>方法，對應(yīng)的value也會從dict中刪除：

刪除一個key，使用pop(key)方法，對應(yīng)的value也會從dict中刪除：

In [29]:

d.pop('rice')

Out[29]:

{'corn': 88, 'egg': 33, 'wheat': 101}

有下面幾點(diǎn)需要注意：

1. dict內(nèi)部存放的順序和key放入的順序是沒有關(guān)系的

2. dict查找和插入的速度極快，不會隨著key的增加而增加，但是需要占用大量的內(nèi)存，內(nèi)存浪費(fèi)多

3. dict的key必須是<font color=red>**不可變對象**</font>。字符串、整數(shù)等都是不可變的，可以放心地作為key，而list是可變的，就不能作為key：

有下面幾點(diǎn)需要注意：

dict內(nèi)部存放的順序和key放入的順序是沒有關(guān)系的

dict查找和插入的速度極快，不會隨著key的增加而增加，但是需要占用大量的內(nèi)存，內(nèi)存浪費(fèi)多

dict的key必須是不可變對象。字符串、整數(shù)等都是不可變的，可以放心地作為key，而list是可變的，就不能作為key：

In [30]:

k = [3,4,5]

d[k] = 6

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-30-725fccd6cc45> in <module>()
      1 k = [3,4,5]
----> 2 d[k] = 6

TypeError: unhashable type: 'list'

### **常見字典操作方法**

<font color=#0099ff>D.clear()</font> 刪除字典內(nèi)所有元素

<font color=#0099ff>D.copy()</font> 返回一個字典的復(fù)制

<font color=#0099ff>D.fromkeys(seq,val)</font> 創(chuàng)建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應(yīng)的初始值

<font color=#0099ff>D.get(key, default=None)</font> 返回指定鍵的值，如果值不在字典中返回default值

<font color=#0099ff>D.has_key(key)</font> 如果鍵在字典dict里返回true，否則返回false

<font color=#0099ff>D.items()</font> 以列表返回可遍歷的(鍵, 值) 元組數(shù)組

<font color=#0099ff>D.keys()</font> 以列表返回一個字典所有的D.keys()以列表返回一個字典所有的鍵

<font color=#0099ff>D.setdefault(key, default=None) </font> 和get()類似, 但如果鍵不存在于字典中，將會添加鍵并將值設(shè)為default

<font color=#0099ff>D.update(dict2) </font> 把字典dict2的鍵/值對更新到dict里

<font color=#0099ff>D.values() </font> 以列表返回字典中的所有值

<font color=#0099ff>D.pop(key) </font> 刪除一個鍵并返回它的值，類似于列表的pop,只不過刪除的是一個鍵不是一個可選的位置

<font color=#0099ff>del D[key] </font> 刪除鍵

<font color=#0099ff>D[key] </font> = 42新增或修改鍵

### 字典用法注意事項(xiàng)：

1. 序列運(yùn)算無效，字典元素間是沒有順序的概念

2. 對新索引賦值會添加項(xiàng)

3. 鍵不一定總是字符串

常見字典操作方法?

D.clear() 刪除字典內(nèi)所有元素

D.copy() 返回一個字典的復(fù)制

D.fromkeys(seq,val) 創(chuàng)建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應(yīng)的初始值

D.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值

D.has_key(key) 如果鍵在字典dict里返回true，否則返回false

D.items() 以列表返回可遍歷的(鍵, 值) 元組數(shù)組

D.keys() 以列表返回一個字典所有的D.keys()以列表返回一個字典所有的鍵

D.setdefault(key, default=None) 和get()類似, 但如果鍵不存在于字典中，將會添加鍵并將值設(shè)為default

D.update(dict2) 把字典dict2的鍵/值對更新到dict里

D.values() 以列表返回字典中的所有值

D.pop(key) 刪除一個鍵并返回它的值，類似于列表的pop,只不過刪除的是一個鍵不是一個可選的位置

del D[key] 刪除鍵

D[key] = 42新增或修改鍵

字典用法注意事項(xiàng)：?

序列運(yùn)算無效，字典元素間是沒有順序的概念

對新索引賦值會添加項(xiàng)

鍵不一定總是字符串

### 多種構(gòu)造字典方式

<font color=#0099ff>dict()</font> 構(gòu)造函數(shù)可以直接從 key-value 對中創(chuàng)建字典

多種構(gòu)造字典方式?

dict() 構(gòu)造函數(shù)可以直接從 key-value 對中創(chuàng)建字典

In [31]:

dict([('john', 4139), ('mike', 4127), ('lucy', 4098)])

Out[31]:

{'john': 4139, 'lucy': 4098, 'mike': 4127}

In [32]:

dict.fromkeys(['a','b'],0) #創(chuàng)建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應(yīng)的初始值

Out[32]:

{'a': 0, 'b': 0}

In [33]:

dict(zip(['a','b','c'],[1,2,3]))

Out[33]:

{'a': 1, 'b': 2, 'c': 3}

In [34]:

{k:v for (k,v) in zip(['a','b','c'],[1,2,3])}

Out[34]:

{'a': 1, 'b': 2, 'c': 3}

此外，字典推導(dǎo)式可以從任意的鍵值表達(dá)式中創(chuàng)建字典:

此外，字典推導(dǎo)式可以從任意的鍵值表達(dá)式中創(chuàng)建字典:

In [35]:

{x: x**2 for x in (2, 4, 6)}

Out[35]:

{2: 4, 4: 16, 6: 36}

如果關(guān)鍵字都是簡單的字符串，有時通過關(guān)鍵字參數(shù)指定 key-value 對更為方便:

如果關(guān)鍵字都是簡單的字符串，有時通過關(guān)鍵字參數(shù)指定 key-value 對更為方便:

In [36]:

D = dict(a=1,b=2,c=3)

Out[36]:

{'a': 1, 'b': 2, 'c': 3}

In [37]:

{c:c*4 for c in 'Zhongxinjiantou'}#默認(rèn)是集合

Out[37]:

{'Z': 'ZZZZ',
 'a': 'aaaa',
 'g': 'gggg',
 'h': 'hhhh',
 'i': 'iiii',
 'j': 'jjjj',
 'n': 'nnnn',
 'o': 'oooo',
 't': 'tttt',
 'u': 'uuuu',
 'x': 'xxxx'}

In [38]:

{c:c*4 for c in ['Zhongxinjiantou']}

Out[38]:

{'Zhongxinjiantou': 'ZhongxinjiantouZhongxinjiantouZhongxinjiantouZhongxinjiantou'}

In [39]:

{c.lower():c*4+'!' for c in 'Zhongxinjiantou'}

Out[39]:

{'a': 'aaaa!',
 'g': 'gggg!',
 'h': 'hhhh!',
 'i': 'iiii!',
 'j': 'jjjj!',
 'n': 'nnnn!',
 'o': 'oooo!',
 't': 'tttt!',
 'u': 'uuuu!',
 'x': 'xxxx!',
 'z': 'ZZZZ!'}

## 元組（tuple）

元組（tuple）?

tuple是另一種有序的數(shù)據(jù)類型，與list比較類似。主要不同的一點(diǎn)是tuple被創(chuàng)建后就不能對其進(jìn)行修改。所以，tuple與list不同，沒有append(),pop(),insert()這些方法可以使用。獲取元素的方法和list是一樣的，可以通過索引來訪問（也是從0開始的），只不過不能賦值成為其他的元素。

因?yàn)閠uple不可變，所以代碼更安全。如果可以的話，我們盡量使用tuple代替list。

### 創(chuàng)造元組

定義一個空的tuple，使用<font color=#0099ff> () </font>：

tuple是另一種有序的數(shù)據(jù)類型，與list比較類似。主要不同的一點(diǎn)是tuple被創(chuàng)建后就不能對其進(jìn)行修改。所以，tuple與list不同，沒有append(),pop(),insert()這些方法可以使用。獲取元素的方法和list是一樣的，可以通過索引來訪問（也是從0開始的），只不過不能賦值成為其他的元素。

因?yàn)閠uple不可變，所以代碼更安全。如果可以的話，我們盡量使用tuple代替list。

創(chuàng)造元組?

定義一個空的tuple，使用 () ：

In [40]:

t = ()

Out[40]:

()

只有1個元素的元組在進(jìn)行定義的時候，需要加一個逗號<font color=#0099ff> **,** </font>來消除歧義，否則定義的就不是一個元組而是元素本身：

只有1個元素的元組在進(jìn)行定義的時候，需要加一個逗號 , 來消除歧義，否則定義的就不是一個元組而是元素本身：

In [41]:

t = (3)

Out[41]:

In [42]:

t = (3,)

Out[42]:

(3,)

### 元組的連接

如前面所說，元組是不可改的，但是可以連接

可以使用<font color=#0099ff> + </font>對元組進(jìn)行連接，例如：

元組的連接?

如前面所說，元組是不可改的，但是可以連接

可以使用 + 對元組進(jìn)行連接，例如：

In [43]:

t1 = (2,3,5)

t2 = ('Zhongxinjiantou','python')

t3 = t1 + t2

t3

Out[43]:

(2, 3, 5, 'Zhongxinjiantou', 'python')

### 元組的刪除

元組中的元素不能被刪除，但是我們可以使用<font color=#0099ff> del </font>刪除整個元組，刪除后可以重新定義：

元組的刪除?

元組中的元素不能被刪除，但是我們可以使用 del 刪除整個元組，刪除后可以重新定義：

In [44]:

t4 = ('a',2,'b')

t4

Out[44]:

('a', 2, 'b')

In [45]:

del t4

t4

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-45-00422465996d> in <module>()
      1 del t4
----> 2 t4

NameError: name 't4' is not defined

事實(shí)上，上面所說的元素不變是指每個元素的指向永遠(yuǎn)不變。即指向<font color=#0099ff>1</font>，就不能改成指向<font color=#0099ff>2</font>，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的，例如：

事實(shí)上，上面所說的元素不變是指每個元素的指向永遠(yuǎn)不變。即指向1，就不能改成指向2，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的，例如：

In [46]:

tup = (1,2,[3,4,5])

tup

Out[46]:

(1, 2, [3, 4, 5])

In [47]:

tup[2][0] = 7

tup[2][1] = 11

tup

Out[47]:

(1, 2, [7, 11, 5])

### Python 的元組數(shù)據(jù)類型包含更多的方法。

<font color=#0099ff>tup.index(x, [start, [stop]]))</font> 返回元組中start到stop索引中第一個值為 x 的元素在整個列表中的索引。如果沒有匹配的元素就會返回一個錯誤。

<font color=#0099ff>tup.count(x)</font> 返回 x 在元組中出現(xiàn)的次數(shù)。

<font color=#0099ff>cmp(tuple1, tuple2)</font> 比較元組中兩個元素。

<font color=#0099ff>len(tuple)</font> 計算元組元素個數(shù)。

<font color=#0099ff>max(tuple)</font> 返回元組中元素最大值。

<font color=#0099ff>min(tuple)</font> 返回元組中元素最小值。

<font color=#0099ff>tuple(seq)</font> 將列表轉(zhuǎn)換為元組。

<font color=red>元組不提供字符串、列表和字典中的方法。</font> 如果相對元組排序，通常先得將它轉(zhuǎn)換為列表并使其成為一個可變對象，才能獲得使用排序方法，或使用sorted內(nèi)置方法。

Python 的元組數(shù)據(jù)類型包含更多的方法。?

tup.index(x, [start, [stop]])) 返回元組中start到stop索引中第一個值為 x 的元素在整個列表中的索引。如果沒有匹配的元素就會返回一個錯誤。

tup.count(x) 返回 x 在元組中出現(xiàn)的次數(shù)。

cmp(tuple1, tuple2) 比較元組中兩個元素。

len(tuple) 計算元組元素個數(shù)。

max(tuple) 返回元組中元素最大值。

min(tuple) 返回元組中元素最小值。

tuple(seq) 將列表轉(zhuǎn)換為元組。

元組不提供字符串、列表和字典中的方法。如果相對元組排序，通常先得將它轉(zhuǎn)換為列表并使其成為一個可變對象，才能獲得使用排序方法，或使用sorted內(nèi)置方法。

## 集合（set）

與dict類似，set也是一組key的集合，但不存儲value。由于key不能重復(fù)，所以，在set中，沒有重復(fù)的key。創(chuàng)建一個set，需要提供一個list作為輸入集合：

集合（set）?

與dict類似，set也是一組key的集合，但不存儲value。由于key不能重復(fù)，所以，在set中，沒有重復(fù)的key。創(chuàng)建一個set，需要提供一個list作為輸入集合：

In [48]:

s = set([3,4,5])

Out[48]:

{3, 4, 5}

重復(fù)元素在set中會被自動被過濾，通過<font color=#0099ff>add(key)</font>方法往set中添加元素，重復(fù)添加不會有效果，通過<font color=#0099ff>remove(key)</font>方法可以刪除元素,例如：

重復(fù)元素在set中會被自動被過濾，通過add(key)方法往set中添加元素，重復(fù)添加不會有效果，通過remove(key)方法可以刪除元素,例如：

In [49]:

s = set([3,3,4,4,5,5,6,6,7])

Out[49]:

{3, 4, 5, 6, 7}

In [50]:

s.add(1)

Out[50]:

{1, 3, 4, 5, 6, 7}

In [51]:

s.add(1)

Out[51]:

{1, 3, 4, 5, 6, 7}

In [52]:

s.remove(5)

Out[52]:

{1, 3, 4, 6, 7}

由于set是無序和無重復(fù)元素的集合，所以兩個set可以做數(shù)學(xué)意義上的交并集等操作：

由于set是無序和無重復(fù)元素的集合，所以兩個set可以做數(shù)學(xué)意義上的交并集等操作：

In [53]:

s1 = set([3,4,5,6])

s2 = set([5,6,7,8,9])

s1 & s2

Out[53]:

{5, 6}

In [54]:

s1 | s2

Out[54]:

{3, 4, 5, 6, 7, 8, 9}

與dict一樣，set同樣不可以放入可變對象，因?yàn)闊o法判斷兩個可變對象是否相等，也就無法保證set內(nèi)部不會有重復(fù)元素。所以把list放入set，會報錯。

與dict一樣，set同樣不可以放入可變對象，因?yàn)闊o法判斷兩個可變對象是否相等，也就無法保證set內(nèi)部不會有重復(fù)元素。所以把list放入set，會報錯。

In [55]:

s = set([1,2,[1,2]])

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-55-806dee2b7dcf> in <module>()
----> 1 s = set([1,2,[1,2]])

TypeError: unhashable type: 'list'

## 總結(jié)

總體而言，幾種基礎(chǔ)數(shù)據(jù)類型有相似之處，可根據(jù)實(shí)際應(yīng)用場景來選擇。

總結(jié)?

總體而言，幾種基礎(chǔ)數(shù)據(jù)類型有相似之處，可根據(jù)實(shí)際應(yīng)用場景來選擇。

本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布，不代表本站觀點(diǎn)。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息，謹(jǐn)防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點(diǎn)擊一鍵舉報。

轉(zhuǎn)藏 分享

QQ空間 QQ好友新浪微博微信

獻(xiàn)花（0） +1

來自：昵稱6262245 > 《python》

舉報/認(rèn)領(lǐng)