Python3 基本數據類型

Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創建。

在 Python 中，變量就是變量，它沒有類型，我們所說的"類型"是變量所指的內存中對象的類型。

等號（=）用來給變量賦值。

等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。例如：

#!/usr/bin/python3

counter = 100          # 整型變量
miles   = 1000.0       # 浮點型變量
name    = "dyf"     # 字符串

print (counter)
print (miles)
print (name)

執行以上程序會輸出如下結果：

100 1000.0 dyf

多個變量賦值

Python允許你同時為多個變量賦值。例如：

a = b = c = 1

以上實例，創建一個整型對象，值為 1，從后向前賦值，三個變量被賦予相同的數值。

您也可以為多個對象指定多個變量。例如：

a, b, c = 1, 2, "dyf"

以上實例，兩個整型對象 1 和 2 的分配給變量 a 和 b，字符串對象 "dyf" 分配給變量 c。

標準數據類型

Python3 中有六個標準的數據類型：

Number（數字） String（字符串） List（列表） Tuple（元組） Set（集合） Dictionary（字典） Python3 的六個標準數據類型中：

不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）；可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。

Number（數字）

Python3 支持 int、float、bool、complex（復數）。

在Python 3里，只有一種整數類型 int，表示為長整型，沒有 python2 中的 Long。

像大多數語言一樣，數值類型的賦值和計算都是很直觀的。

內置的 type() 函數可以用來查詢變量所指的對象類型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外還可以用 isinstance 來判斷：

>>> a = 111
>>> isinstance(a, int)
True
>>>

isinstance 和 type 的區別在于：

type()不會認為子類是一種父類類型。

isinstance()會認為子類是一種父類類型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

注意：Python3 中，bool 是 int 的子類，True 和 False 可以和數字相加， True==1、False==0 會返回 True，但可以通過 is 來判斷類型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

在 Python2 中是沒有布爾型的，它用數字 0 表示 False，用 1 表示 True。

當你指定一個值時，Number 對象就會被創建：

var1 = 1 var2 = 10

您也可以使用del語句刪除一些對象引用。

del語句的語法是：

del var1[,var2[,var3[....,varN]]]

您可以通過使用del語句刪除單個或多個對象。例如：

del var del var_a, var_b

數值運算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 減法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一個浮點數
0.5
>>> 2 // 4 # 除法，得到一個整數
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

注意：

1、Python可以同時為多個變量賦值，如a, b = 1, 2。

2、一個變量可以通過賦值指向不同類型的對象。

3、數值的除法包含兩個運算符：/ 返回一個浮點數，// 返回一個整數。

4、在混合計算時，Python會把整型轉換成為浮點數。

數值類型實例

Python 還支持復數，復數由實數部分和虛數部分構成，可以用 a + bj，或者 complex(a,b) 表示， 復數的實部 a 和虛部 b 都是浮點型。

String（字符串）

Python中的字符串用單引號 ' 或雙引號 " 括起來，同時使用反斜杠 轉義特殊字符。

字符串的截取的語法格式如下：

變量[頭下標:尾下標]

索引值以 0 為開始值，-1 為從末尾的開始位置。

加號 + 是字符串的連接符， 星號 * 表示復制當前字符串，與之結合的數字為復制的次數。實例如下：

#!/usr/bin/python3

str = 'Caiyua'

print (str)          # 輸出字符串
print (str[0:-1])    # 輸出第一個到倒數第二個的所有字符
print (str[0])       # 輸出字符串第一個字符
print (str[2:5])     # 輸出從第三個開始到第五個的字符
print (str[2:])      # 輸出從第三個開始的后的所有字符
print (str * 2)      # 輸出字符串兩次，也可以寫成 print (2 * str)
print (str + "TEST") # 連接字符串

執行以上程序會輸出如下結果：

Caiyua
Caiyu
C
iyu
iyua
CaiyuaCaiyua
CaiyuaTEST

Python 使用反斜杠 轉義特殊字符，如果你不想讓反斜杠發生轉義，可以在字符串前面添加一個 r，表示原始字符串：

>>> print('Cu
ooa')
Cu
ooa
>>> print(r'Cu
ooa')
Cu
ooa
>>>

另外，反斜杠()可以作為續行符，表示下一行是上一行的延續。也可以使用 """...""" 或者 '''...''' 跨越多行。

注意，Python 沒有單獨的字符類型，一個字符就是長度為1的字符串。

>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

與 C 字符串不同的是，Python 字符串不能被改變。向一個索引位置賦值，比如 word[0] = 'm' 會導致錯誤。

注意：

1、反斜杠可以用來轉義，使用r可以讓反斜杠不發生轉義。 2、字符串可以用+運算符連接在一起，用*運算符重復。 3、Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。 4、Python中的字符串不能改變。

List（列表）

List（列表） 是 Python 中使用最頻繁的數據類型。

列表可以完成大多數集合類的數據結構實現。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。

列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。

和字符串一樣，列表同樣可以被索引和截取，列表被截取后返回一個包含所需元素的新列表。

列表截取的語法格式如下：

變量[頭下標:尾下標]

索引值以 0 為開始值，-1 為從末尾的開始位置。加號 + 是列表連接運算符，星號 * 是重復操作。如下實例：

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'caiyuan', 70.2 ]
tinylist = [123, 'caiyuan']

print (list)            # 輸出完整列表
print (list[0])         # 輸出列表第一個元素
print (list[1:3])       # 從第二個開始輸出到第三個元素
print (list[2:])        # 輸出從第三個元素開始的所有元素
print (tinylist * 2)    # 輸出兩次列表
print (list + tinylist) # 連接列表

以上實例輸出結果：

['abcd', 786, 2.23, 'caiyuan', 70.2]
abcd
[786, 2.23]
[2.23, 'caiyuan', 70.2]
[123, 'caiyuan', 123, 'caiyuan']
['abcd', 786, 2.23, 'caiyuan', 70.2, 123, 'caiyuan']

與Python字符串不一樣的是，列表中的元素是可以改變的：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 將對應的元素值設置為 []
>>> a
[9, 2, 6]

List 內置了有很多方法，例如 append()、pop() 等等，這在后面會講到。

注意：

1、List寫在方括號之間，元素用逗號隔開。 2、和字符串一樣，list可以被索引和切片。 3、List可以使用+操作符進行拼接。 4、List中的元素是可以改變的。

Python 列表截取可以接收第三個參數，參數作用是截取的步長，以下實例在索引 1 到索引 4 的位置并設置為步長為 2（間隔一個位置）來截取字符串：如果第三個參數為負數表示逆向讀取，以下實例用于翻轉字符串：

def reverseWords(input):
     
    # 通過空格將字符串分隔符，把各個單詞分隔為列表
    inputWords = input.split(" ")
 
    # 翻轉字符串
    # 假設列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一個元素 list[-1]=4 ( 與 list[3]=4 一樣)
    # inputWords[-1::-1] 有三個參數
    # 第一個參數 -1 表示最后一個元素
    # 第二個參數為空，表示移動到列表末尾
    # 第三個參數為步長，-1 表示逆向
    inputWords=inputWords[-1::-1]
 
    # 重新組合字符串
    output = ' '.join(inputWords)
     
    return output
 
if __name__ == "__main__":
    input = 'I like caiyua'
    rw = reverseWords(input)
    print(rw)

輸出結果為：

caiyua  like I

Tuple（元組）

元組（tuple）與列表類似，不同之處在于元組的元素不能修改。元組寫在小括號 () 里，元素之間用逗號隔開。

元組中的元素類型也可以不相同：

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'caiyuan', 70.2  )
tinytuple = (123, 'caiyuan')

print (tuple)             # 輸出完整元組
print (tuple[0])          # 輸出元組的第一個元素
print (tuple[1:3])        # 輸出從第二個元素開始到第三個元素
print (tuple[2:])         # 輸出從第三個元素開始的所有元素
print (tinytuple * 2)     # 輸出兩次元組
print (tuple + tinytuple) # 連接元組

以上實例輸出結果：

('abcd', 786, 2.23, 'caiyuan', 70.2)
abcd
(786, 2.23)
(2.23, 'caiyuan', 70.2)
(123, 'caiyuan', 123, 'caiyuan')
('abcd', 786, 2.23, 'caiyuan', 70.2, 123, 'caiyuan')

元組與字符串類似，可以被索引且下標索引從0開始，-1 為從末尾開始的位置。也可以進行截取（看上面，這里不再贅述）。

其實，可以把字符串看作一種特殊的元組。

>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元組元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：

tup1 = ()    # 空元組 t up2 = (20,) # 一個元素，需要在元素后添加逗號

string、list 和 tuple 都屬于 sequence（序列）。

注意：

1、與字符串一樣，元組的元素不能修改。 2、元組也可以被索引和切片，方法一樣。 3、注意構造包含 0 或 1 個元素的元組的特殊語法規則。 4、元組也可以使用+操作符進行拼接。

Set（集合）

集合（set）是由一個或數個形態各異的大小整體組成的，構成集合的事物或對象稱作元素或是成員。

基本功能是進行成員關系測試和刪除重復元素。

可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。

創建格式：

parame = {value01,value02,...} 或者 set(value)

#!/usr/bin/python3

sites = {'Google', 'Taobao', 'dyf', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 輸出集合，重復的元素被自動去掉

# 成員測試
if 'dyf' in sites :
    print('dyf在集合中')
else :
    print('dyf不在集合中')


# set可以進行集合運算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同時存在的元素

以上實例輸出結果：

{'Zhihu', 'Baidu', 'Taobao', 'dyf', 'Google', 'Facebook'}
dyf在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}

Dictionary（字典）

字典（dictionary）是Python中另一個非常有用的內置數據類型。

列表是有序的對象集合，字典是無序的對象集合。兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

字典是一種映射類型，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合。

鍵(key)必須使用不可變類型。

在同一個字典中，鍵(key)必須是唯一的。

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - python教程"
dict[2]     = "2 - php教程"

tinydict = {'name': 'dyf','code':1, 'site': 'www.dyf.com'}


print (dict['one'])       # 輸出鍵為 'one' 的值
print (dict[2])           # 輸出鍵為 2 的值
print (tinydict)          # 輸出完整的字典
print (tinydict.keys())   # 輸出所有鍵
print (tinydict.values()) # 輸出所有值

以上實例輸出結果：

1 - python教程
2 - php教程
{'name': 'dyf', 'code': 1, 'site': 'www.dyf.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['dyf', 1, 'www.dyf.com'])

構造函數 dict() 可以直接從鍵值對序列中構建字典如下：

>>> dict([('dyf', 1), ('Google', 2), ('Taobao', 3)])
{'dyf': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(dyf=1, Google=2, Taobao=3)
{'dyf': 1, 'Google': 2, 'Taobao': 3}

{x: x**2 for x in (2, 4, 6)} 該代碼使用的是字典推導式

另外，字典類型也有一些內置的函數，例如 clear()、keys()、values() 等。

注意：

1、字典是一種映射類型，它的元素是鍵值對。 2、字典的關鍵字必須為不可變類型，且不能重復。 3、創建空字典使用 { }。