Python數據結構與算法

時間 2020-05-26

原文原文鏈接

Python數據結構與算法--數據類型

從數據類型開始

Python支持面向對象的編程範式，這意味着Python把數據當作解決問題的關鍵. 在Python中,相似其餘的面向對象的編程語言, 咱們定義一個類，用來描述數據是什麼 (狀態) 和數據能作些什麼 (行爲). 類和抽象數據類型類似，由於一個類的用戶只看數據項的狀態和行爲. 數據項在面向對象編程中被稱爲對象. 對象是類的實例.html

本文地址：http://www.cnblogs.com/archimedes/p/python-datastruct-algorithm-basedatatypes.html，轉載請註明源地址。python

內置的原子數據類型

咱們從原子數據類型開始咱們的回顧. Python有兩種主要的內建數據類：int和float. 標準的算術操做：+, -, *, /, and ** (冪運算), 可使用括號改變運算優先級.其餘很是有用的操做符爲取餘運算%, 和整數除法運算//. 注意：當兩個整數相除的時候，結果是一個浮點型數. 整數除法操做返回截斷小數以後的整數部分.算法

>>> print 2+3*4
14
>>> print (2+3)*4
20
>>> print 2**10
1024
>>> print 6/3
2
>>> print 7/3
2
>>> print 7//3
2
>>> print 7%3
1
>>> print 3/6
0
>>> print 3//6
0
>>> print 3%6
3
>>> print 2**100
1267650600228229401496703205376

boolean類型,由Python的 bool 類提供實現,在表示真值的時候很是有用. 對於一個boolean對象而言，只有兩個值：True and False，標準的boolean類型操做： and, or, 和not.shell

>>> True
True >>> False
False >>> False or True
True >>> not (False or True)
False >>> True and True
True

Boolean數據對象也被用於表示比較運算符的結果，好比：相等 (==) 和大於 (>). 另外, 關係運算符和邏輯運算符能夠組合在一塊兒來解決複雜的邏輯問題. 表1 展現了邏輯關係操做，後面還展現了相關的例子.編程

表1 : 邏輯與關係操做
操做名	操做符	說明
小於		小於操做符
大於		大於操做符
小於等於		小於等於操做符
大於等於		大於等於操做符
等於		等於操做符
不等於		不等於操做符
邏輯與		兩個同時爲True時候才爲True
邏輯或		兩個中至少有一個爲True，結果爲True
邏輯非		否認, False 變爲True, True 變爲False

示例代碼：數據結構

>>> print(5==10)
False >>> print(10 > 5)
True >>> print((5 >= 1) and (5 <= 10))
True

標識符以名字的形式被用於程序語言. 在Python中, 標識符以字母或一條下劃線開始，大小寫敏感且能夠是任意長度.記住常用變量來表達你的意思，使得你的代碼更加簡單的被閱讀和理解.一個 Python 變量被建立一旦被賦予左值. 賦值語句提供了一種聯繫變量和值的方法. 變量保持一個指向數據區域的引用，並非數據自己. 看下面的代碼:app

>>> theSum = 0
>>> theSum
0 >>> theSum += 1
>>> theSum
1
>>> theSum = True
>>> theSum
True

內建集合數據類型

做爲數據類型和布爾類型的補充, Python還有一些內建的集合類型. Lists, strings, 和 tuples（元組）都是有序集合，很是相似普通的結構可是有些特殊的不一樣點，因此必須理解它們這樣才能正確地使用它們. Sets 和 dictionaries 是無序集合.編程語言

list 是一個空的或多個指向Python數據對象類型的引用. Lists 一般寫爲用方括號包含的一些用逗號分隔的值. 空表表示爲 [ ]. Lists內部的元素能夠是不一樣的數據對象, 下面的例子展現了一個list中不一樣的數據類型.函數

>>> [1,3,True,6.5]
[1, 3, True, 6.5] >>> myList = [1,3,True,6.5]
>>> myList
[1, 3, True, 6.5]

當給list賦值的時候, list被返回. 可是, 想在 list上做操, 就須要將其賦值給一個對象.post

lists 被認爲是連續的序列, 它們支持一些可用於其餘序列的通用操做. 表2 展現了這些操做，接着給出一些例子來進一步說明它們的應用.

表 2: Python中序列的通用操做
操做名	操做符	解釋
索引	[ ]	訪問 sequence中的元素
鏈接	+	合併sequences
重複	*	連續重複次數
成員	in	判斷元素是否在quence中
長度	len	計算sequence的長度
分片	[ : ]	給sequence分片

注意到lists (序列)的索引從0開始. 取片操做, myList[1:3], 返回list的數據項，起始於1結束但不包含3.有時, 你想初始化一個list. 可使用重複來快速的完成. 例如,

>>> myList = [0]*6
>>> myList
[0, 0, 0, 0, 0, 0]

經過下面的例子很容易理解:

>>> myList = [1,2,3,4]
>>> A=[myList]*3
>>> print(A)
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]] >>> myList[2]=45
>>> print(A)
[[1, 2, 45, 4], [1, 2, 45, 4], [1, 2, 45, 4]]

Lists 提供大量用於構建數據結構的方法.表3 提供概要. 接着是一些例子.

表 3: Python中list提供的方法
方法名	應用	說明
`append`	`alist.append(item)`	在list的結尾添加一個項
`insert`	`alist.insert(i,item)`	在list的第i個位置插入一個項
`pop`	`alist.pop()`	移除並返回list中的最後一個元素
`pop`	`alist.pop(i)`	移除並返回list中的第i個位置的元素
`sort`	`alist.sort()`	排序修改list
`reverse`	`alist.reverse()`	將list倒序操做
`del`	`del alist[i]`	刪除第i個位置的元素
`index`	`alist.index(item)`	返回第一次出現 `item 的索引`
`count`	`alist.count(item)`	返回出現 `item` 的次數
`remove`	`alist.remove(item)`	刪除第一次出現的 `item`

list中的方法示例代碼：

>>> myList = [1024, 3, True, 6.5]
>>> myList.append(False)
>>> print(myList)
[1024, 3, True, 6.5, False] >>> myList.insert(2, 4.5)
>>> print(myList)
[1024, 3, 4.5, True, 6.5, False] >>> print(myList.pop())
False >>> print(myList)
[1024, 3, 4.5, True, 6.5] >>> print(myList.pop(1))
3
>>> print(myList)
[1024, 4.5, True, 6.5] >>> myList.pop(2)
True >>> print(myList)
[1024, 4.5, 6.5] >>> myList.sort()
>>> print(myList)
[4.5, 6.5, 1024] >>> myList.reverse()
>>> print(myList)
[1024, 6.5, 4.5] >>> print(myList.count(6.5))
1
>>> print(myList.index(4.5))
2
>>> myList.remove(6.5)
>>> print(myList)
[1024, 4.5] >>> del myList[0]
>>> print(myList)
[4.5]

即便像整型這樣的對象也能夠調用方法以下：

>>> (54).__add__(21)
75

上面的代碼中咱們使整型對象 54 執行 add 方法(稱爲 __add__ ) 而且傳遞 21 做爲被加數. 結果是它們的和, 75. 固然, 咱們一般寫做 54+21. 在後面還將詳細介紹這個方法.

一個Python常常用來鏈接lists的常見函數： range 函數.range 產生了一個範圍內的對象. 經過使用 list 函數, 能夠看到list中指定範圍內的值，以下面的代碼所示：

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(5,10)
[5, 6, 7, 8, 9] >>> list(range(5,10))
[5, 6, 7, 8, 9] >>> list(range(5,10,2))
[5, 7, 9] >>> list(range(10,1,-1))
[10, 9, 8, 7, 6, 5, 4, 3, 2]

Strings 包含0個或多個數字或其餘的字符的連續的順序集合. 咱們稱這些爲字母, 數字和其餘的符號字符.

>>> "David"
'David'
>>> myName = "David"
>>> myName[3]
'i'
>>> myName * 2
'DavidDavid'
>>> len(myName)
5

既然strings是序列, all of the 上面提到的序列的全部操做均可以使用. 然而, strings 還有一些自身的方法, 如表 4所示. 例如,

>>> myName
'David'
>>> myName.upper()
'DAVID'
>>> myName.center(10)
' David '
>>> myName.find('v')
2
>>> myName.split('v')
['Da', 'id']

表 4: Python中Strings 提供的方法
方法名	應用	說明
`center`	`astring.center(w)`	返回一個以 `w` 爲寬度的居中字符串
`count`	`astring.count(item)`	返回字符串中包含 `item` 的個數
`ljust`	`astring.ljust(w)`	返回一個以 `w` 爲寬度的左對齊字符串
`lower`	`astring.lower()`	返回string的小寫形式
`rjust`	`astring.rjust(w)`	返回一個以 `w` 爲寬度的右對齊字符串
`find`	`astring.find(item)`	返回第一次出現 `item` 的索引
`split`	`astring.split(schar)`	將string以 `schar`爲分隔符劃分爲子串

lists 和 strings的主要區別是 lists 能夠修改可是 strings 不能修改. 例如, 你能夠經過索引和賦值改變項的值. 對於string不能發生改變.

>>> myList = [1,3,True,6.5]
>>> myList[0] = 2 ** 10
>>> myList
[1024, 3, True, 6.5] >>> myName = 'David'
>>> myName[0] = 'X'
Traceback (most recent call last):
  File "<pyshell#81>", line 1, in <module>
    myName[0] = 'X'
TypeError: 'str' object does not support item assignment

Tuples（元組）很是相似於lists，由於它們的元素均可以是不一樣類型的.不一樣的是tuple是不能夠變的, 就像 string. Tuples是一組用圓括號包圍的用逗號分隔的值. 做爲序列，你可使用上面介紹的全部方法. 例如：

>>> myTuple = (2, True, 4.32)
>>> myTuple
(2, True, 4.32) >>> len(myTuple)
3
>>> myTuple[0]
2
>>> myTuple * 3 (2, True, 4.32, 2, True, 4.32, 2, True, 4.32) >>> myTuple[0:2]
(2, True)

然而，假如你試圖修改元組中的元素，就會出錯，以下所示.

>>> myTuple[1] = false
Traceback (most recent call last): File "<pyshell#92>", line 1, in <module>
    myTuple[1] = false
NameError: name 'false' is not defined

set 是一個包含0個或多個不可變Python對象的無序集合. 空set 表示爲 set(). Sets 的元素類型多樣.

>>> {3,6,"cat",4.3,False}
set([False, 3, 4.3, 6, 'cat'])
>>> mySet = {3,6,"cat",4.3,False}
>>> mySet
set([False, 3, 4.3, 6, 'cat'])

表 5: Python中的Set操做
操做名	操做	說明
成員	in	判斷成員
長度	len	返回set中的元素個數
`\|`	`aset \| otherset`	返回一個新的set，做爲並集
`&`	`aset & otherset`	返回一個新的set，做爲交集
`-`	`aset - otherset`	返回一個新的set，做爲差集
`<=`	`aset <= otherset`	判斷第一個集合是否爲第二個集合的子集

>>> {3,6,"cat",4.3,False}
set([False, 3, 4.3, 6, 'cat']) >>> mySet = {3,6,"cat",4.3,False}
>>> mySet
set([False, 3, 4.3, 6, 'cat']) >>> 
>>> mySet = {3,6,"cat",4.3,False}
>>> len(mySet)
5
>>> False in mySet
True >>> "dog" in mySet
False >>> yourSet = {3,1,"cat",4.7,False}
>>> mySet | yourSet
set([False, 1, 3, 6, 4.3, 'cat', 4.7]) >>> mySet & yourSet
set([False, 3, 'cat']) >>> mySet - yourSet
set([4.3, 6]) >>> mySet <= yourSet
False

Sets 提供的方法相似於數學中的集合. 表 6 提供了概要. 例子以下所示：

表 6: Python中Sets提供的方法
方法名	應用	說明
`union`	`aset.union(otherset)`	返回一個新的set，元素由兩個set的並集組成
`intersection`	`aset.intersection(otherset)`	返回一個新的set ，元素由兩個set的交集組成
`difference`	`aset.difference(otherset)`	返回一個新的set，元素由兩個set的差組成
`issubset`	`aset.issubset(otherset)`	判斷第一個set中的全部元素是否是在第二個set中
`add`	`aset.add(item)`	向set中添加元素
`remove`	`aset.remove(item)`	從set中刪除元素
`pop`	`aset.pop()`	從set中刪除任意元素
`clear`	`aset.clear()`	將set中全部元素刪除

>>> mySet = {False, 4.5, 3, 6, 'cat'}
>>> yourSet = {99, 3, 100}
>>> mySet.union(yourSet)
set([4.5, False, 3, 100, 6, 'cat', 99]) >>> mySet | yourSet
set([4.5, False, 3, 100, 6, 'cat', 99]) >>> mySet.intersection(yourSet)
set([3]) >>> mySet & yourSet
set([3]) >>> mySet.difference(yourSet)
set([4.5, False, 6, 'cat']) >>> mySet - yourSet
set([4.5, False, 6, 'cat']) >>> {3, 100}.issubset(yourSet)
True >>> {3, 100}<=yourSet
True >>> mySet.add("house")
>>> mySet
set([4.5, False, 3, 6, 'house', 'cat']) >>> mySet.remove(4.5)
>>> mySet
set([False, 3, 6, 'house', 'cat']) >>> mySet.pop()
False >>> mySet
set([3, 6, 'house', 'cat']) >>> mySet.clear()
>>> mySet
set([])

Dictionaries（字典）既有方法又有操做. 表7 和表 8 描述了它們.

表 7: Python中Dictionaries 提供的操做
操做符	應用	說明
`[]`	`myDict[k]`	返回鍵爲 `k` 的值，不然發生錯誤
`in`	`key in adict`	當key在字典中的時候返回 `True` 不然返回 `False`
`del`	del `adict[key]`	刪除全部的 dictionary 元素

>>> phoneext = {'david':1410, 'brad':1137}
>>> phoneext
{'brad': 1137, 'david': 1410} >>> phoneext.keys()
['brad', 'david'] >>> phoneext.values()
[1137, 1410] >>> phoneext.items()
[('brad', 1137), ('david', 1410)] >>> phoneext.get("kent")

表 8: Python中Dictionaries 提供的方法
方法名	應用	說明
`keys`	`adict.keys()`	返回dictionary中的key
`values`	`adict.values()`	返回dictionary中的值
`items`	`adict.items()`	返回字典中的全部鍵-值對
`get`	`adict.get(k)`	返回 `k` 對應的值,不然返回 `None`
`get`	`adict.get(k,alt)`	返回 `k` 對應的值,不然返回 `alt`