Python全棧之路系列之數字數據類型

上篇文章中咱們簡單的體驗了Python語言基本概念與語法，那麼在繼續深刻下去的過程當中，不妨先學習幾個常見的Python內置數據類型？這也是大部分Python教科書的學習目錄，由淺至深，慢慢深刻。

Python經常使用的幾種數據類型就是如下幾種，其實Python內部的數據類型仍是不少的，多歸多可是不多有咱們用到了，太多了也記不了，把經常使用的幾個玩熟練了就OK了。

那麼接下來咱們會學到那些內置的數據類型呢？

雖說咱們是在學習數據類型，但其實只是在學習每個類型所提供的API而已，你所須要的大部分功能，Python都已經幫咱們封裝好了，不須要擔憂任何效率的問題，當你熟悉了這些API以後，靈活的組合應用，由於這在開發的過程當中是必不可少的，那麼接下來就讓咱們開始漫長的數據類型API學習之旅吧。

全部的數據類型所具有的方法都存在相對應的類裏面，當建立一個類型的對象時，該對象所具有的功能都保存在相應的類中。

數字

在Python3中，整型、長整型、浮點數、負數、布爾值等均可以稱之爲數字類型。

建立數字類型類型的對象

int類型一般都是數字，建立數字類型的方式有兩種，且在建立的時候值兩邊不須要加雙引號或單引號。

第一種建立整型的方式

>>> number = 9
>>> type(number)
<class 'int'>

第二種建立整型的方式

>>> number = int(9)
>>> type(number)
<class 'int'>

以上兩種建立整型對象的方式均可以建立的，可是他們也是有本質上的區別，第一種方式實際上會轉換成第二種方式，而後第二種方式會把括號內的數據交給__init__這個構造方法，構造方法是int類的，而後構造方法會在內存中開闢一塊空間用來存放數據，但實際上咱們在用時候是沒有任何區別的。

構造方法每一個數據類型中都會有，這是Python內部所定義的，以下圖所示：

__init__

def __init__(self, x, base=10): # known special case of int.__init__

能夠從源碼中看到，__init__的方法有兩個參數，其中base=10是可選的參數，x是咱們對象的值，base=10其實就是說把咱們的值(默認二進制)以十進制的方式輸出出來，經過下面的實例能夠看到：

>>> var=int('0b100',base=2)
>>> var
4

經過int()能夠將一個數字的字符串變成一個整數，而且若是你指定了第二個參數，還能夠將值進制數轉換爲整數：

# 將數字字符串轉換爲整數，數字字符串經過進制轉換爲整數
>>> int('99'),int('100',8),int('40',16),int('10000000',2)
(99, 64, 64, 128)
# 講進制數轉換爲整數
>>> int('0x40',16),int('0b1000000',2)
(64, 64)

把二進制的數字4經過十進制輸出出來，4的二進制就是0b100，又有一個知識點就是在類的方法中，全部以__開頭，而且以__結尾的方法都是Python內部本身去調用的，咱們在寫代碼的過程當中是不須要去調用的，最簡單的例子就是__init__，經過上面的流程圖咱們就能夠很清楚的看到。

int內部優化機制

下圖中咱們能夠很清楚的看到int類型在建立對象時內存所分配空間的狀況

首先咱們知道當咱們建立第一個對象var1的時候會在內存中開闢一塊空間做爲存放var1對象的值用的，當咱們建立第二個對象var2的時候也會在內存中開闢一塊空間來做爲var2對象的值，那若是這樣說，那是否是說對象var1和var2的值內存是否會同時開闢兩塊呢？咱們經過下面的實例能夠獲得答案：

C:\Users\anshe>c:\Python35\python.exe
# 注意我是用的是Python3.5.1
Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2016, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
# 分別建立對象var1和var2
>>> var1=123
>>> var2=123
# 咱們能夠看到他們的內存地址都是指向的`1502084720`
>>> id(var1)
1502084720
>>> id(var2)
1502084720

經過上面的結果咱們能夠看到var1和var2的內存地址是相同的，就表明他們的值是使用的同一塊空間，那麼若是我把var2的值改成456呢？

>>> var2=456
>>> id(var1)
1502084720
>>> id(var2)
2452305956816

能夠看到var2的內存地址已經改變了（廢話），由於對象的值不同了，因此他纔不會改變，OK，咱們能夠獲得一個結論就是：當兩個或者多個對象的值都是同一個的時候，那麼這些對象都會使用同一個內存地址，這裏的值是是有範圍的，默認範圍是-5~257，獲得這個結論以後咱們繼續往下看。

這張圖咱們一樣建立了兩個對象，可是惟一不一樣的是我把第一個建立的對象的值做爲第二個對象的值，這裏他們確定使用的是同一個內存地址，可是若是我把第一個對象的值改動了呢？

>>> var1=123
>>> var2=var1
>>> id(var1)
1502084720
>>> id(var2)
1502084720
>>> var1=456
>>> id(var1)
2452305956816
>>> id(var2)
1502084720

請自行思考，這裏很少作解釋，而後下面咱們再來講說剛纔的話題，說在-5~257這個範圍內對象的值都會引用同一塊內存地址，咱們能夠經過下面的實驗來測試：

>>> var1=12345
>>> var2=12345
>>> id(var1)
2452305956816
>>> id(var2)
2452308384720

事實證實咱們的結論是徹底沒有問題的，注意我上面的實例都是在Python3.5上面執行的哦，var1和var2兩個對象的值一樣是12345，可是他們的內存地址就是不同，這就是Python在內部作的優化，他把-5~257這個範圍內咱們經常使用道德數字多對象可引用的，OK，到此結束這個話題。

數字類型的長度限制

數字類型在python2.7裏面是分整型和長整型這個區別的，也就是說若是你的數字大到必定的範圍，那麼python會把它轉換爲長整形，一個數字類型包含32位，能夠存儲從-2147483648到214483647的整數。

一個長整(long)型會佔用更多的空間，64位的能夠存儲-922372036854775808到922372036854775808的整數。

python3裏long型已經不存在了，而int型能夠存儲到任意大小的整型，甚至超過64爲。

Python內部對整數的處理分爲普通整數和長整數，普通整數長度爲機器位長，一般都是32位，超過這個範圍的整數就自動當長整數處理，而長整數的範圍幾乎徹底沒限制，以下：

• Python2.7.x

>>> var=123456
>>> var
123456
>>> var=10**20
>>> var
100000000000000000000L
>>> type(var)
# long就是長整型
<type 'long'>

• Python3.5.x

>>> var=123456789
>>> var
123456789
>>> var=10**20
>>> var
100000000000000000000
>>> type(var)
<class 'int'>

請自行補腦 - - 、

數字類型所具有的方法

bit_length

返回表示該數字時佔用的最少位數

>>> num=20
>>> num.bit_length()
5

conjugate

返回該複數的共軛複數，複數，好比0+2j,其中num.real,num.imag分別返回其實部和虛部，num.conjugate()，返回其共扼複數對象

>>> num =-20
>>> num.conjugate()
-20
>>> num=0+2j
>>> num.real
0.0
>>> num.imag
2.0
>>> num.conjugate()
-2j

imag

返回複數的虛數

>>> number = 10
>>> number.imag
0
>>> number = 3.1415926
>>> number.imag
0.0

內置的方法還有denominator、from_bytes、numerator、real、to_bytes，實在搞不懂這有什麼用，也不太理解，就不作介紹了，你能夠經過help(int.numerator)查看該方法的幫助信息等。

混合類型

所謂混合類型就是浮點數和整數進行運算，以下所示：

>>> 3.14159 + 10
13.14159

結果和咱們想象中的同樣，可是一個浮點數一個正整數它是怎麼進行相加的呢？其實很簡單，Python會把兩個值轉換爲其中最複雜的那個對象的類型，而後再對相同類型運算。

好比上面的例子中，會先把10轉換爲10.0而後再與3.14159相加。

數字類型的複雜度

整數比浮點數簡單、浮點數比複數簡單。

布爾類型(bool)

布爾類型其實就是數字0和1的變種而來，即真（True/0）或假（False/1），實際上就是內置的數字類型的子類而已。

# 若是0不是真，那麼就輸出'0 is False.'
>>> if not 0: print('0 is False.')
... 
0 is False.
# 若是1是真，那麼就輸出'1 is True.'
>>> if 1: print('1 is True.')
... 
1 is True.

你還可使用布爾值進行加減法，雖然歷來沒在任何代碼中見過這種形式：

>>> True + 1
# 1 + 1 = 2
2
>>> False + 1
# 0 + 1 = 1
1

集合(set)

集合的元素是不容許重複、不可變且無序的集合，集合就像是字典捨棄了值同樣，集合中的元素只可以出現一切且不能重複。

建立set集合

>>> s = set([11,22,33])
>>> s
{33, 11, 22}
>>> type(s)
<class 'set'>

第二種不經常使用建立set集合的方式

# 這種的建立方式，集合中的元素至關於字典中的key
>>> s = {11,22,33}
>>> type(s)
<class 'set'>
>>> s
{33, 11, 22}

把其它可迭代的數據類型轉換爲set集合

>>> li = ["a","b","c"]
>>> seting = set(li)
>>> seting
{'b', 'a', 'c'}
>>> type(seting)
<class 'set'>

集合一樣支持表達式操做符

# 首先建立兩個集合
>>> x = set('abcde')
>>> y = set('bdxyz')
>>> x
{'a', 'd', 'b', 'c', 'e'}
>>> y
{'y', 'd', 'b', 'x', 'z'}
# 使用in進行成員檢測
>>> 'a' in x
True
# 差集
>>> x - y
{'a', 'e', 'c'}
# 並集
>>> x | y
{'b', 'y', 'z', 'a', 'd', 'e', 'c', 'x'}
# 交集
>>> x & y
{'d', 'b'}
# 對稱差
>>> x ^ y
{'y', 'z', 'a', 'e', 'c', 'x'}
# 比較
>>> x > y, x < y
(False, False)

集合解析

>>> {x for x in 'abc'}
{'a', 'b', 'c'}
>>> {x+'b' for x in 'abc'}
{'bb', 'cb', 'ab'}

集合所提供的方法

add

往集合內添加元素

>>> se = { 11, 22, 33 }
>>> se
{33, 11, 22}
# 元素寫在小括號內
>>> se.add(44)
>>> se
{33, 11, 44, 22}

 
clear

清除集合內容

>>> se = { 11, 22, 33 }
>>> se
{33, 11, 22}
>>> se.clear()
>>> se
set()

 
copy淺拷貝

下文介紹
 
difference

尋找集合的元素var1中存在，var2中不存在的

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22 ,55 }
>>> var1.difference(var2)
{33, 11}
>>> var2.difference(var1)
{55}

 
difference_update

尋找集合的元素var1中存在，var2中不存在的元素，並把查找出來的元素從新複製給var1

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22 ,55 }
>>> var1.difference_update(var2)
>>> var1
{33, 11}

 
discard

移除指定元素，不存在不保錯

>>> var1 = { 11, 22, 33 }
>>> var1.discard(11)
>>> var1
{33, 22}
>>> var1.discard(1123123)
>>> var1
{33, 22}

remove

移除指定元素，不存在保錯

>>> var1 = { 11, 22, 33 }
>>> var1
{33, 11, 22}
>>> var1.remove(11)
>>> var1
{33, 22}
>>> var1.remove(asda)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'asda' is not defined

intersection

交集，查找元素中都存在的值

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 55, "一二" }
>>> var1.intersection(var2)
{22}

 
intersection_update

取交集並更更新到A中

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 55, "一二" }
>>> var1.intersection_update(var2)
>>> var1
{22}

 
isdisjoint

判斷有沒有交集，若是有返回False，不然返回True

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 44, 55 }
>>> var1.isdisjoint(var2)
False
>>> var2 = { 66, 44, 55 }
>>> var1.isdisjoint(var2)
True

 
issubset

是不是子序列,也就是說若是var2的全部元素都被var1所包含了，那麼var2就是var1的子序列

>>> var1 = {11,22,33,44}
>>> var2 = {11,22}
>>> var2.issubset(var1)
True

issuperset

是不是父序列

>>> var1 = { 11, 22, 33 }
>>> var2 = { 22, 44, 55 }
>>> var1.issuperset(var2)
True

pop

移除一個元素，並顯示移除的元素，移除時是無序的

>>> var1 = {11,22,33,44}
>>> var1.pop()
33
>>> var1
{11, 44, 22}

symmetric_difference

對稱交集，把var1存在且b不存在和var2存在且var1不存在的元素合在一塊兒

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1.symmetric_difference(var2)
{33, 44, 77, 55}

symmetric_difference_update

對稱交集，並更新到var1中

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1
{33, 11, 44, 22}
>>> var1.symmetric_difference_update(var2)
>>> var1
{33, 44, 77, 55}

union

並集，把兩個集合中的全部元素放在一塊兒，若是有重複的則只存放一個

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1.union(var2)
{33, 11, 44, 77, 22, 55}

update

更新，把一個集合中的元素更新到另外一個集合中

>>> var1 = { 11, 22, 33, 44 }
>>> var2 = { 11, 22, 77, 55 }
>>> var1.update(var2)
>>> var1
{33, 11, 44, 77, 22, 55}

---

原文連接

Python全棧之路系列文章