有一些補充

標準數據類型

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))

此外還可以用 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

注意：在 Python2 中是沒有布爾型的，它用數字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數字相加。

當你指定一個值時，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會把整型轉換成為浮點數。

數值類型實例

intfloatcomplex

100.03.14j

10015.2045.j

-786-21.99.322e-36j

08032.3e+18.876j

-0490-90.-.6545+0J

-0x260-32.54e1003e+26J

0x6970.2E-124.53e-7j

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

String(字符串)

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

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

變量[頭下標:尾下標]

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

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

實例

#!/usr/bin/python3

str = 'Runoob'

print (str) # 輸出字符串

print (str[0:-1]) # 輸出第一個到倒數第二個的所有字符

print (str[0]) # 輸出字符串第一個字符

print (str[2:5]) # 輸出從第三個開始到第五個的字符

print (str[2:]) # 輸出從第三個開始的后的所有字符

print (str * 2) # 輸出字符串兩次

print (str + "TEST") # 連接字符串

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

Runoob

Runoo

R

noo

noob

RunoobRunoob

RunoobTEST

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

>>> print('Ru\noob')

Ru

oob

>>> print(r'Ru\noob')

Ru\noob

>>>

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

注意，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, 'runoob', 70.2 ]

tinylist = [123, 'runoob']

print (list) # 輸出完整列表

print (list[0]) # 輸出列表第一個元素

print (list[1:3]) # 從第二個開始輸出到第三個元素

print (list[2:]) # 輸出從第三個元素開始的所有元素

print (tinylist * 2) # 輸出兩次列表

print (list + tinylist) # 連接列表

以上實例輸出結果：

['abcd', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

[123, 'runoob', 123, 'runoob']

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

與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 runoob'

rw = reverseWords(input)

print(rw)

輸出結果為：

runoob like I

Tuple(元組)

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

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

實例

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )

tinytuple = (123, 'runoob')

print (tuple) # 輸出完整元組

print (tuple[0]) # 輸出元組的第一個元素

print (tuple[1:3]) # 輸出從第二個元素開始到第三個元素

print (tuple[2:]) # 輸出從第三個元素開始的所有元素

print (tinytuple * 2) # 輸出兩次元組

print (tuple + tinytuple) # 連接元組

以上實例輸出結果：

('abcd', 786, 2.23, 'runoob', 70.2)

abcd

(786, 2.23)

(2.23, 'runoob', 70.2)

(123, 'runoob', 123, 'runoob')

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

元組與字符串類似，可以被索引且下標索引從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 "", line 1, in

TypeError: 'tuple' object does not support item assignment

>>>

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

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

tup1 = () # 空元組

tup2 = (20,) # 一個元素，需要在元素后添加逗號

string、list 和 tuple 都屬于 sequence(序列)。

注意：

1、與字符串一樣，元組的元素不能修改。

2、元組也可以被索引和切片，方法一樣。

3、注意構造包含 0 或 1 個元素的元組的特殊語法規則。

4、元組也可以使用+操作符進行拼接。

Set(集合)

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

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

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

創建格式：

parame = {value01,value02,...}

或者

set(value)

實例

#!/usr/bin/python3

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

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

# 成員測試

if 'Rose' in student :

print('Rose 在集合中')

else :

print('Rose 不在集合中')

# 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 中不同時存在的元素

以上實例輸出結果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}

Rose 在集合中

{'b', 'a', 'c', 'r', 'd'}

{'b', 'd', 'r'}

{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}

{'a', 'c'}

{'l', 'r', 'z', 'm', 'b', 'd'}

Dictionary(字典)

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

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

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

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

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

實例

#!/usr/bin/python3

dict = {}

dict['one'] = "1 - 菜鳥教程"

dict[2] = "2 - 菜鳥工具"

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

print (dict['one']) # 輸出鍵為 'one' 的值

print (dict[2]) # 輸出鍵為 2 的值

print (tinydict) # 輸出完整的字典

print (tinydict.keys()) # 輸出所有鍵

print (tinydict.values()) # 輸出所有值

以上實例輸出結果：

1 - 菜鳥教程

2 - 菜鳥工具

{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}

dict_keys(['name', 'code', 'site'])

dict_values(['runoob', 1, 'www.runoob.com'])

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

實例

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])

{'Taobao': 3, 'Runoob': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}

>>> dict(Runoob=1, Google=2, Taobao=3)

{'Runoob': 1, 'Google': 2, 'Taobao': 3}

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

注意：

1、字典是一種映射類型，它的元素是鍵值對。

2、字典的關鍵字必須為不可變類型，且不能重復。

3、創建空字典使用 { }。

Python數據類型轉換

有時候，我們需要對數據內置的類型進行轉換，數據類型的轉換，你只需要將數據類型作為函數名即可。

以下幾個內置的函數可以執行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。

int(x [,base])

將x轉換為一個整數

float(x)

將x轉換到一個浮點數

complex(real [,imag])

創建一個復數

str(x)

將對象 x 轉換為字符串

repr(x)

將對象 x 轉換為表達式字符串

eval(str)

用來計算在字符串中的有效Python表達式,并返回一個對象

tuple(s)

將序列 s 轉換為一個元組

list(s)

將序列 s 轉換為一個列表

set(s)

轉換為可變集合

dict(d)

創建一個字典。d 必須是一個 (key, value)元組序列。

frozenset(s)

轉換為不可變集合

chr(x)

將一個整數轉換為一個字符

ord(x)

將一個字符轉換為它的整數值

hex(x)

將一個整數轉換為一個十六進制字符串

oct(x)

將一個整數轉換為一個八進制字符串

總結

以上是生活随笔為你收集整理的python3 long类型_Python3 基本数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。