摘要：數(shù)字在中，整型長(zhǎng)整型浮點(diǎn)數(shù)負(fù)數(shù)布爾值等都可以稱之為數(shù)字類型。數(shù)字類型的復(fù)雜度整數(shù)比浮點(diǎn)數(shù)簡(jiǎn)單浮點(diǎn)數(shù)比復(fù)數(shù)簡(jiǎn)單。布爾類型布爾類型其實(shí)就是數(shù)字和的變種而來，即真或假，實(shí)際上就是內(nèi)置的數(shù)字類型的子類而已。

上篇文章中我們簡(jiǎn)單的體驗(yàn)了Python語(yǔ)言基本概念與語(yǔ)法，那么在繼續(xù)深入下去的過程中，不妨先學(xué)習(xí)幾個(gè)常見的Python內(nèi)置數(shù)據(jù)類型？這也是大部分Python教科書的學(xué)習(xí)目錄，由淺至深，慢慢深入。

Python常用的幾種數(shù)據(jù)類型就是以下幾種，其實(shí)Python內(nèi)部的數(shù)據(jù)類型還是很多的，多歸多但是很少有我們用到了，太多了也記不了，把常用的幾個(gè)玩熟練了就OK了。

那么接下來我們會(huì)學(xué)到那些內(nèi)置的數(shù)據(jù)類型呢？

雖然說我們是在學(xué)習(xí)數(shù)據(jù)類型，但其實(shí)只是在學(xué)習(xí)每一個(gè)類型所提供的API而已，你所需要的大部分功能，Python都已經(jīng)幫我們封裝好了，不需要擔(dān)心任何效率的問題，當(dāng)你熟悉了這些API之后，靈活的組合應(yīng)用，因?yàn)檫@在開發(fā)的過程中是必不可少的，那么接下來就讓我們開始漫長(zhǎng)的數(shù)據(jù)類型API學(xué)習(xí)之旅吧。

所有的數(shù)據(jù)類型所具備的方法都存在相對(duì)應(yīng)的類里面，當(dāng)創(chuàng)建一個(gè)類型的對(duì)象時(shí)，該對(duì)象所具備的功能都保存在相應(yīng)的類中。

在Python3中，整型、長(zhǎng)整型、浮點(diǎn)數(shù)、負(fù)數(shù)、布爾值等都可以稱之為數(shù)字類型。

創(chuàng)建數(shù)字類型類型的對(duì)象

int類型通常都是數(shù)字，創(chuàng)建數(shù)字類型的方式有兩種，且在創(chuàng)建的時(shí)候值兩邊不需要加雙引號(hào)或單引號(hào)。

第一種創(chuàng)建整型的方式

>>> number = 9
>>> type(number)

第二種創(chuàng)建整型的方式

>>> number = int(9)
>>> type(number)

以上兩種創(chuàng)建整型對(duì)象的方式都可以創(chuàng)建的，但是他們也是有本質(zhì)上的區(qū)別，第一種方式實(shí)際上會(huì)轉(zhuǎn)換成第二種方式，然后第二種方式會(huì)把括號(hào)內(nèi)的數(shù)據(jù)交給__init__這個(gè)構(gòu)造方法，構(gòu)造方法是int類的，然后構(gòu)造方法會(huì)在內(nèi)存中開辟一塊空間用來存放數(shù)據(jù)，但實(shí)際上我們?cè)谟脮r(shí)候是沒有任何區(qū)別的。

構(gòu)造方法每個(gè)數(shù)據(jù)類型中都會(huì)有，這是Python內(nèi)部所定義的，如下圖所示：

__init__

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

可以從源碼中看到，__init__的方法有兩個(gè)參數(shù)，其中base=10是可選的參數(shù)，x是我們對(duì)象的值，base=10其實(shí)就是說把我們的值(默認(rèn)二進(jìn)制)以十進(jìn)制的方式輸出出來，通過下面的實(shí)例可以看到：

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

通過int()可以將一個(gè)數(shù)字的字符串變成一個(gè)整數(shù)，并且如果你指定了第二個(gè)參數(shù)，還可以將值進(jìn)制數(shù)轉(zhuǎn)換為整數(shù)：

# 將數(shù)字字符串轉(zhuǎn)換為整數(shù)，數(shù)字字符串通過進(jìn)制轉(zhuǎn)換為整數(shù)
>>> int("99"),int("100",8),int("40",16),int("10000000",2)
(99, 64, 64, 128)
# 講進(jìn)制數(shù)轉(zhuǎn)換為整數(shù)
>>> int("0x40",16),int("0b1000000",2)
(64, 64)

把二進(jìn)制的數(shù)字4通過十進(jìn)制輸出出來，4的二進(jìn)制就是0b100，又有一個(gè)知識(shí)點(diǎn)就是在類的方法中，所有以__開頭，并且以__結(jié)尾的方法都是Python內(nèi)部自己去調(diào)用的，我們?cè)趯懘a的過程中是不需要去調(diào)用的，最簡(jiǎn)單的例子就是__init__，通過上面的流程圖我們就可以很清楚的看到。

下圖中我們可以很清楚的看到int類型在創(chuàng)建對(duì)象時(shí)內(nèi)存所分配空間的情況

首先我們知道當(dāng)我們創(chuàng)建第一個(gè)對(duì)象var1的時(shí)候會(huì)在內(nèi)存中開辟一塊空間作為存放var1對(duì)象的值用的，當(dāng)我們創(chuàng)建第二個(gè)對(duì)象var2的時(shí)候也會(huì)在內(nèi)存中開辟一塊空間來作為var2對(duì)象的值，那如果這樣說，那是不是說對(duì)象var1和var2的值內(nèi)存是否會(huì)同時(shí)開辟兩塊呢？我們通過下面的實(shí)例可以得到答案：

C:Usersanshe>c:Python35python.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.
# 分別創(chuàng)建對(duì)象var1和var2
>>> var1=123
>>> var2=123
# 我們可以看到他們的內(nèi)存地址都是指向的`1502084720`
>>> id(var1)
1502084720
>>> id(var2)
1502084720

通過上面的結(jié)果我們可以看到var1和var2的內(nèi)存地址是相同的，就代表他們的值是使用的同一塊空間，那么如果我把var2的值改為456呢？

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

可以看到var2的內(nèi)存地址已經(jīng)改變了（廢話），因?yàn)閷?duì)象的值不一樣了，所以他才不會(huì)改變，OK，我們可以得到一個(gè)結(jié)論就是：當(dāng)兩個(gè)或者多個(gè)對(duì)象的值都是同一個(gè)的時(shí)候，那么這些對(duì)象都會(huì)使用同一個(gè)內(nèi)存地址，這里的值是是有范圍的，默認(rèn)范圍是-5~257，得到這個(gè)結(jié)論之后我們繼續(xù)往下看。

這張圖我們同樣創(chuàng)建了兩個(gè)對(duì)象，但是唯一不同的是我把第一個(gè)創(chuàng)建的對(duì)象的值作為第二個(gè)對(duì)象的值，這里他們肯定使用的是同一個(gè)內(nèi)存地址，但是如果我把第一個(gè)對(duì)象的值改動(dòng)了呢？

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

請(qǐng)自行思考，這里不多做解釋，然后下面我們?cè)賮碚f說剛才的話題，說在-5~257這個(gè)范圍內(nèi)對(duì)象的值都會(huì)引用同一塊內(nèi)存地址，我們可以通過下面的實(shí)驗(yàn)來測(cè)試：

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

事實(shí)證明我們的結(jié)論是完全沒有問題的，注意我上面的實(shí)例都是在Python3.5上面執(zhí)行的哦，var1和var2兩個(gè)對(duì)象的值同樣是12345，但是他們的內(nèi)存地址就是不一樣，這就是Python在內(nèi)部做的優(yōu)化，他把-5~257這個(gè)范圍內(nèi)我們常用道德數(shù)字多對(duì)象可引用的，OK，到此結(jié)束這個(gè)話題。

數(shù)字類型在python2.7里面是分整型和長(zhǎng)整型這個(gè)區(qū)別的，也就是說如果你的數(shù)字大到一定的范圍，那么python會(huì)把它轉(zhuǎn)換為長(zhǎng)整形，一個(gè)數(shù)字類型包含32位，可以存儲(chǔ)從-2147483648到214483647的整數(shù)。

一個(gè)長(zhǎng)整(long)型會(huì)占用更多的空間，64位的可以存儲(chǔ)-922372036854775808到922372036854775808的整數(shù)。

python3里long型已經(jīng)不存在了，而int型可以存儲(chǔ)到任意大小的整型，甚至超過64為。

Python內(nèi)部對(duì)整數(shù)的處理分為普通整數(shù)和長(zhǎng)整數(shù)，普通整數(shù)長(zhǎng)度為機(jī)器位長(zhǎng)，通常都是32位，超過這個(gè)范圍的整數(shù)就自動(dòng)當(dāng)長(zhǎng)整數(shù)處理，而長(zhǎng)整數(shù)的范圍幾乎完全沒限制，如下：

Python2.7.x

>>> var=123456
>>> var
123456
>>> var=10**20
>>> var
100000000000000000000L
>>> type(var)
# long就是長(zhǎng)整型

Python3.5.x

>>> var=123456789
>>> var
123456789
>>> var=10**20
>>> var
100000000000000000000
>>> type(var)

請(qǐng)自行補(bǔ)腦 - - 、

bit_length

返回表示該數(shù)字時(shí)占用的最少位數(shù)

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

conjugate

返回該復(fù)數(shù)的共軛復(fù)數(shù)，復(fù)數(shù)，比如0+2j,其中num.real,num.imag分別返回其實(shí)部和虛部，num.conjugate()，返回其共扼復(fù)數(shù)對(duì)象

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

imag

返回復(fù)數(shù)的虛數(shù)

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

內(nèi)置的方法還有denominator、from_bytes、numerator、real、to_bytes，實(shí)在搞不懂這有什么用，也不太理解，就不做介紹了，你可以通過help(int.numerator)查看該方法的幫助信息等。

所謂混合類型就是浮點(diǎn)數(shù)和整數(shù)進(jìn)行運(yùn)算，如下所示：

>>> 3.14159 + 10
13.14159

結(jié)果和我們想象中的一樣，但是一個(gè)浮點(diǎn)數(shù)一個(gè)正整數(shù)它是怎么進(jìn)行相加的呢？其實(shí)很簡(jiǎn)單，Python會(huì)把兩個(gè)值轉(zhuǎn)換為其中最復(fù)雜的那個(gè)對(duì)象的類型，然后再對(duì)相同類型運(yùn)算。

比如上面的例子中，會(huì)先把10轉(zhuǎn)換為10.0然后再與3.14159相加。

數(shù)字類型的復(fù)雜度

整數(shù)比浮點(diǎn)數(shù)簡(jiǎn)單、浮點(diǎn)數(shù)比復(fù)數(shù)簡(jiǎn)單。

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

# 如果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.

你還可以使用布爾值進(jìn)行加減法，雖然從來沒在任何代碼中見過這種形式：

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

集合的元素是不允許重復(fù)、不可變且無(wú)序的集合，集合就像是字典舍棄了值一樣，集合中的元素只能夠出現(xiàn)一切且不能重復(fù)。

創(chuàng)建set集合

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

第二種不常用創(chuàng)建set集合的方式

# 這種的創(chuàng)建方式，集合中的元素相當(dāng)于字典中的key
>>> s = {11,22,33}
>>> type(s)

>>> s
{33, 11, 22}

把其它可迭代的數(shù)據(jù)類型轉(zhuǎn)換為set集合

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

集合同樣支持表達(dá)式操作符

# 首先創(chuàng)建兩個(gè)集合
>>> x = set("abcde")
>>> y = set("bdxyz")
>>> x
{"a", "d", "b", "c", "e"}
>>> y
{"y", "d", "b", "x", "z"}
# 使用in進(jìn)行成員檢測(cè)
>>> "a" in x
True
# 差集
>>> x - y
{"a", "e", "c"}
# 并集
>>> x | y
{"b", "y", "z", "a", "d", "e", "c", "x"}
# 交集
>>> x & y
{"d", "b"}
# 對(duì)稱差
>>> 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

往集合內(nèi)添加元素

>>> se = { 11, 22, 33 }
>>> se
{33, 11, 22}
# 元素寫在小括號(hào)內(nèi)
>>> se.add(44)
>>> se
{33, 11, 44, 22}

?
clear

清除集合內(nèi)容

>>> 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中不存在的元素，并把查找出來的元素重新復(fù)制給var1

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

?
discard

移除指定元素，不存在不保錯(cuò)

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

remove

移除指定元素，不存在保錯(cuò)

>>> var1 = { 11, 22, 33 }
>>> var1
{33, 11, 22}
>>> var1.remove(11)
>>> var1
{33, 22}
>>> var1.remove(asda)
Traceback (most recent call last):
  File "", line 1, in 
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

移除一個(gè)元素，并顯示移除的元素，移除時(shí)是無(wú)序的

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

symmetric_difference

對(duì)稱交集，把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

對(duì)稱交集，并更新到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

并集，把兩個(gè)集合中的所有元素放在一起，如果有重復(fù)的則只存放一個(gè)

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

update

更新，把一個(gè)集合中的元素更新到另一個(gè)集合中

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