python基礎數據結構：序列、映射、集合

參考資料：

創(chuàng)新互聯建站專注為客戶提供全方位的互聯網綜合服務，包含不限于成都做網站、網站建設、外貿營銷網站建設、紅古網絡推廣、微信小程序開發(fā)、紅古網絡營銷、紅古企業(yè)策劃、紅古品牌公關、搜索引擎seo、人物專訪、企業(yè)宣傳片、企業(yè)代運營等，從售前售中售后，我們都將竭誠為您服務，您的肯定，是我們最大的嘉獎；創(chuàng)新互聯建站為所有大學生創(chuàng)業(yè)者提供紅古建站搭建服務，24小時服務熱線：18980820575，官方網址：sd-ha.com

Python中常見的數據結構可以統(tǒng)稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。

一、序列（列表、元組和字符串）

序列中的每個元素都有自己的編號。Python中有6種內建的序列。其中列表和元組是最常見的類型。其他包括字符串、Unicode字符串、buffer對象和xrange對象。下面重點介紹下列表、元組和字符串。

1、列表

列表是可變的，這是它區(qū)別于字符串和元組的最重要的特點，一句話概括即：列表可以修改，而字符串和元組不能。

（1）、創(chuàng)建

通過下面的方式即可創(chuàng)建一個列表：

輸出：

['hello', 'world']

[1, 2, 3]

可以看到，這中創(chuàng)建方式非常類似于javascript中的數組。

（2）、list函數

通過list函數（其實list是一種類型而不是函數）對字符串創(chuàng)建列表非常有效：

輸出：

['h', 'e', 'l', 'l', 'o']

2、元組

元組與列表一樣，也是一種序列，唯一不同的是元組不能被修改（字符串其實也有這種特點）。

（1） 、創(chuàng)建

輸出：

(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)

從上面我們可以分析得出：

a、逗號分隔一些值，元組自動創(chuàng)建完成；

b、元組大部分時候是通過圓括號括起來的；

c、空元組可以用沒有包含內容的圓括號來表示；

d、只含一個值的元組，必須加個逗號（,）；

（2）、tuple函數

tuple函數和序列的list函數幾乎一樣：以一個序列（注意是序列）作為參數并把它轉換為元組。如果參數就算元組，那么該參數就會原樣返回：

輸出：

(1, 2, 3)

('j', 'e', 'f', 'f')

(1, 2, 3)

Traceback (most recent call last):

File "F:\Python\test.py", line 7, in

t4=tuple(123)

TypeError: 'int' object is not iterable

3、字符串

（1）創(chuàng)建

輸出：

Hello world

H

H

e

l

l

o

w

o

r

l

d

（2）、格式化

format（）：

print(‘{0} was {1} years old when he wrote this book’. format(name,age) )

print(‘{} was {} years old when he wrote this book’. format(name,age) )

print(‘{name} was {age} years old when he wrote this book’. format(name=’Lily’,age=’22’) )

#對于浮點數“0.333”保留小數點后三位

print(‘{0 : .3f}’.format(1.0/3) )

結果：0.333

#使用下劃線填充文本，并保持文字處于中間位置

#使用^定義‘_____hello_____’字符串長度為11

print(‘{0 : ^_11}’.format(‘hello’) )

結果：_____hello_____

% :

格式化操作符的右操作數可以是任何東西，如果是元組或者映射類型（如字典），那么字符串格式化將會有所不同。

輸出：

Hello,world

Hello,World

注意：如果需要轉換的元組作為轉換表達式的一部分存在，那么必須將它用圓括號括起來：

輸出：

Traceback (most recent call last):

File "F:\Python\test.py", line 2, in

str1='%s,%s' % 'Hello','world'

TypeError: not enough arguments for format string

如果需要輸出%這個特殊字符，毫無疑問，我們會想到轉義，但是Python中正確的處理方式如下：

輸出：100%

對數字進行格式化處理，通常需要控制輸出的寬度和精度：

輸出：

3.14

3.141593

3.14

字符串格式化還包含很多其他豐富的轉換類型，可參考官方文檔。

4、通用序列操作（方法）

從列表、元組以及字符串可以“抽象”出序列的一些公共通用方法（不是你想像中的CRUD），這些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及檢查某個元素是否屬于序列的成員。除此之外，還有計算序列長度、最大最小元素等內置函數。

（1）索引

輸出

H

2

345

索引從0（從左向右）開始，所有序列可通過這種方式進行索引。神奇的是，索引可以從最后一個位置（從右向左）開始，編號是-1：

輸出：

o

3

123

（2）分片

分片操作用來訪問一定范圍內的元素。分片通過冒號相隔的兩個索引來實現：

輸出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[1, 2, 3, 4]

[6, 7, 8, 9]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[7, 8]

[7, 8, 9]

不同的步長，有不同的輸出：

輸出：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0, 2, 4, 6, 8]

[0, 3, 6, 9]

[]

（3）序列相加

輸出：

Hello world

[1, 2, 3, 2, 3, 4]

Traceback (most recent call last):

File "F:\Python\test.py", line 7, in

print str1+num1

TypeError: cannot concatenate 'str' and 'list' objects

（4）乘法

輸出：

[None, None, None, None, None, None, None, None, None, None]

HelloHello

[1, 2, 1, 2]

Traceback (most recent call last):

File "F:\Python\test.py", line 5, in

print str1*num1

TypeError: can't multiply sequence by non-int of type 'list'

（5）成員資格

in運算符會用來檢查一個對象是否為某個序列（或者其他類型）的成員（即元素）：

輸出：

False

True

True

（6）長度、最大最小值

通過內建函數len、max和min可以返回序列中所包含元素的數量、最大和最小元素。

輸出：

5

o

H

5

123

1

二、映射（字典）

映射中的每個元素都有一個名字，如你所知，這個名字專業(yè)的名稱叫鍵。字典（也叫散列表）是Python中唯一內建的映射類型。

1、鍵類型

字典的鍵可以是數字、字符串或者是元組，鍵必須唯一。在Python中，數字、字符串和元組都被設計成不可變類型，而常見的列表以及集合（set）都是可變的，所以列表和集合不能作為字典的鍵。鍵可以為任何不可變類型，這正是Python中的字典最強大的地方。

輸出：

{1: 1}

Traceback (most recent call last):

File "F:\Python\test.py", line 6, in

d[list1]="Hello world."

TypeError: unhashable type: 'list'

2、自動添加

即使鍵在字典中并不存在，也可以為它分配一個值，這樣字典就會建立新的項。

3、成員資格

表達式item in d（d為字典）查找的是鍵（containskey），而不是值（containsvalue）。

三、集合

集合（Set）在Python 2.3引入，通常使用較新版Python可直接創(chuàng)建，如下所示：

strs=set(['jeff','wong','cnblogs'])

nums=set(range(10))

看上去，集合就是由序列（或者其他可迭代的對象）構建的。集合的幾個重要特點和方法如下：

1、副本是被忽略的

集合主要用于檢查成員資格，因此副本是被忽略的，如下示例所示,輸出的集合內容是一樣的。

輸出如下：

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

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

2、集合元素的順序是隨意的

這一點和字典非常像，可以簡單理解集合為沒有value的字典。

輸出如下：

set(['wong', 'cnblogs', 'jeff'])

3、集合常用方法

a、并集union

輸出：

set([1, 2, 3])

set([2, 3, 4])

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

union操作返回兩個集合的并集，不改變原有集合。使用按位與（OR）運算符“|”可以得到一樣的結果：

輸出和上面union操作一模一樣的結果。

其他常見操作包括（交集）,=,=,-,copy()等等，這里不再列舉。

輸出如下：

set([1, 2, 3])

set([2, 3, 4])

set([2, 3])

True

set([1, 2, 3])

False

b、add和remove

和序列添加和移除的方法非常類似，可參考官方文檔：

輸出：

set([1])

set([1, 2])

set([1])

set([1])

False

Traceback (most recent call last):

File "F:\Python\test.py", line 9, in

set1.remove(29) #移除不存在的項

KeyError: 29

4、frozenset

集合是可變的，所以不能用做字典的鍵。集合本身只能包含不可變值，所以也就不能包含其他集合：

輸出如下：

Traceback (most recent call last):

File "F:\Python\test.py", line 3, in

set1.add(set2)

TypeError: unhashable type: 'set'

可以使用frozenset類型用于代表不可變（可散列）的集合：

輸出：

set([1, frozenset([2])])

python有多少內置函數

Python內置函數有很多，為大家推薦5個神仙級的內置函數：

(1)Lambda函數

用于創(chuàng)建匿名函數，即沒有名稱的函數。它只是一個表達式，函數體比def簡單很多。當我們需要創(chuàng)建一個函數來執(zhí)行單個操作并且可以在一行中編寫時，就可以用到匿名函數了。

Lamdba的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

利用Lamdba函數，往往可以將代碼簡化許多。

(2)Map函數

會將一個函數映射到一個輸入列表的所有元素上，比如我們先創(chuàng)建了一個函數來返回一個大寫的輸入單詞，然后將此函數應有到列表colors中的所有元素。

我們還可以使用匿名函數lamdba來配合map函數，這樣可以更加精簡。

(3)Reduce函數

當需要對一個列表進行一些計算并返回結果時，reduce()是個非常有用的函數。舉個例子，當需要計算一個整數列表所有元素的乘積時，即可使用reduce函數實現。

它與函數的最大的區(qū)別就是，reduce()里的映射函數(function)接收兩個參數，而map接收一個參數。

(4)enumerate函數

用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在for循環(huán)當中。

它的兩個參數，一個是序列、迭代器或其他支持迭代對象;另一個是下標起始位置，默認情況從0開始，也可以自定義計數器的起始編號。

(5)Zip函數

用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表

當我們使用zip()函數時，如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同。

python join函數用法

python join函數用法如下：

join函數python就是把一個list中所有的串按照你定義的分隔符連接起來。join是string類型的一個函數，用調用他的字符串去連接參數里的列表，python里面萬物皆對象，調用join函數，將后面的列表里的值用逗號連接成新的字符串。str（i）foriinlist這是一個映射，就是把list中每個值都轉換成字符串。

函數含義

python中得thread的一些機制和C/C++不同：在C/C++中，主線程結束后，其子線程會默認被主線程kill掉。而在python中，主線程結束后，會默認等待子線程結束后，主線程才退出。

python對于thread的管理中有兩個函數：join和setDaemon。

join：如在一個線程B中調用threada。join（），則threada結束后，線程B才會接著threada。join（）往后運行。

setDaemon：主線程A啟動了子線程B，調用b。setDaemaon（True），則主線程結束時，會把子線程B也殺死，與C/C++中得默認效果是一樣的。

python字典操作函數

字典是一種通過名字或者關鍵字引用的得數據結構，其鍵可以是數字、字符串、元組，這種結構類型也稱之為映射。字典類型是Python中唯一內建的映射類型，基本的操作包括如下：

(1)len()：返回字典中鍵—值對的數量；

(2)d[k]:返回關鍵字對于的值；

(3)d[k]=v:將值關聯到鍵值k上；

(4)del d[k]:刪除鍵值為k的項；

(5)key in d:鍵值key是否在d中，是返回True，否則返回False。

(6)clear函數：清除字典中的所有項

(7)copy函數：返回一個具有相同鍵值的新字典；deepcopy()函數使用深復制，復制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題

(8)fromkeys函數：使用給定的鍵建立新的字典，鍵默認對應的值為None

(9)get函數：訪問字典成員

(10)has_key函數：檢查字典中是否含有給出的鍵

(11)items和iteritems函數:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

(13)pop函數：刪除字典中對應的鍵

(14)popitem函數：移出字典中的項

(15)setdefault函數：類似于get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值

(16)update函數：用一個字典更新另外一個字典

(17)?values和itervalues函數：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復的元素

一、字典的創(chuàng)建

1.1 直接創(chuàng)建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通過dict創(chuàng)建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的內容:'

printitems

printu'利用dict創(chuàng)建字典，輸出字典內容:'

d=dict(items)

printd

printu'查詢字典中的內容:'

printd['one']

printd['three']

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的內容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict創(chuàng)建字典，輸出字典內容:

{'four':4,'three':3,'two':2,'one':1}

查詢字典中的內容:

或者通過關鍵字創(chuàng)建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'輸出字典內容:'

printd

printu'查詢字典中的內容:'

printd['one']

printd['three']

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出字典內容:

{'three':3,'two':2,'one':1}

查詢字典中的內容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1?clear函數：清除字典中的所有項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

請看下面兩個例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關聯到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空后，字典dd里面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內容，clear是一個原地操作的方法，使得d中的內容全部被置空，這樣dd所指向的空間也被置空。

3.2?copy函數：返回一個具有相同鍵值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X復制到Y：'

y=x.copy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，觀察輸出：'

printy

printx

printu'刪除Y中的值，觀察輸出'

y['test'].remove('c')

printy

printx

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X復制到Y：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，觀察輸出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

刪除Y中的值，觀察輸出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在復制的副本中對值進行替換后，對原來的字典不產生影響，但是如果修改了副本，原始的字典也會被修改。deepcopy函數使用深復制，復制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'輸出：'

printy

printz

printu'修改后輸出：'

x['test'].append('e')

printy

printz

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后輸出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3?fromkeys函數：使用給定的鍵建立新的字典，鍵默認對應的值為None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默認的對應值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4?get函數：訪問字典成員

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注：get函數可以訪問字典中不存在的鍵，當該鍵不存在是返回None

3.5?has_key函數：檢查字典中是否含有給出的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6?items和iteritems函數:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7?keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

printx

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

3.8?pop函數：刪除字典中對應的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9?popitem函數：移出字典中的項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10?setdefault函數：類似于get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

運算結果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11?update函數：用一個字典更新另外一個字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12?values和itervalues函數：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

68 個 Python 內置函數詳解

內置函數就是Python給你提供的，拿來直接用的函數，比如print.，input等。

截止到python版本3.6.2 ，python一共提供了68個內置函數，具體如下

本文將這68個內置函數綜合整理為12大類，正在學習Python基礎的讀者一定不要錯過，建議收藏學習！

（1）列表和元組

（2）相關內置函數

（3）字符串

frozenset 創(chuàng)建一個凍結的集合，凍結的集合不能進行添加和刪除操作。

語法：sorted(Iterable, key=函數(排序規(guī)則), reverse=False)

語法：fiter(function. Iterable)

function: 用來篩選的函數. 在?lter中會自動的把iterable中的元素傳遞給function. 然后根據function返回的True或者False來判斷是否保留留此項數據 , Iterable: 可迭代對象

搜索公眾號頂級架構師后臺回復“面試”，送你一份驚喜禮包。

語法 : map(function, iterable)

可以對可迭代對象中的每一個元素進行映射. 分別去執(zhí)行 function

hash : 獲取到對象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時間 比較耗費內存

文章名稱：python影射函數 映射類型python
瀏覽路徑：http://sd-ha.com/article0/hjdgio.html

成都網站建設公司_創(chuàng)新互聯，為您提供品牌網站建設、虛擬主機、網站排名、App設計、網站營銷、外貿網站建設

廣告

聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯