Python中的數(shù)據(jù)類型

1、數(shù)據(jù)類型（Number、String、list、typle、set、dictionary）

Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創(chuàng)建。在 Python 中，變量就是變量，它沒有類型，我們所說的"類型"是變量所指的內存中對象的類型，一個變量可以通過賦值指向不同類型的對象

#!/usr/bin/python3

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

a = b = c = 1        # 同時為多個變量賦值

a, b, c = 1, 2, "runoob"  # 分別同時為多個變量指定值。兩個整型對象 1 和 2 的分配給變量 a 和 b，字符串對象 "runoob" 分配給變量 c

Python3 中有六個標準的數(shù)據(jù)類型：

Number（數(shù)字）
String（字符串）
List（列表）
Tuple（元組）
Set（集合）
Dictionary（字典）

Python3 的六個標準數(shù)據(jù)類型中：

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

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

內置的 type() 和 isinstance() 函數(shù)可以用來查詢變量所指的對象類型：

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

a = 111
isinstance(a, int)  # True

isinstance 和 type 的區(qū)別在于：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

2、數(shù)字類型（Number）

數(shù)字類型是不允許改變的。python中數(shù)字有四種類型：整數(shù)、布爾型、浮點數(shù)和復數(shù)。

int (整數(shù)), 如 1, 只有一種整數(shù)類型 int，表示為長整型，沒有 python2 中的 Long。
Python允許在數(shù)字中間以_分隔，因此，寫成10_000_000_000和10000000000是完全一樣的。十六進制數(shù)也可以寫成0xa1b2_c3d4。

Python的整數(shù)和浮點數(shù)都沒有大小限制。
bool (布爾), 如 True。（在 Python2 中是沒有布爾型的，它用數(shù)字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數(shù)字相加）
float (浮點數(shù)), 如 1.23、3E-2
complex (復數(shù)), 如 1 + 2j、 1.1 + 2.2j

2.1、布爾值（true、false）

Python中的布爾值可以用and、or和not運算。

>>> True and True
True
>>> True or False
True
>>> not True
False

2.2、數(shù)字類型轉換方法（int()、float()、complex()）

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

int(x) 將x轉換為一個整數(shù)。
float(x) 將x轉換到一個浮點數(shù)。
complex(x) 將x轉換到一個復數(shù)，實數(shù)部分為 x，虛數(shù)部分為 0。
complex(x, y) 將 x 和 y 轉換到一個復數(shù)，實數(shù)部分為 x，虛數(shù)部分為 y。x 和 y 是數(shù)字表達式。

3、字符串（string）

python中的字符串有以下特點：

python中單引號和雙引號使用完全相同。
使用三引號('''或""")可以指定一個多行字符串。
轉義符 '\'。轉義字符\可以用來轉義，比如\n表示換行，\t表示制表符，字符\本身也要轉義，所以\\表示的字符就是\。使用r可以讓反斜杠不發(fā)生轉義。。如 r"this is a line with \n" 則\n會顯示，并不是換行。
按字面意義級聯(lián)字符串，如"this " "is " "string"會被自動轉換為this is string。
字符串可以用 + 運算符連接在一起，用 * 運算符重復。
Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
Python中的字符串不能改變。向一個索引位置賦值，比如word[0] = 'm'會導致錯誤。
Python 沒有單獨的字符類型，一個字符就是長度為 1 的字符串。
字符串的截取的語法格式如下：變量[頭下標:尾下標:步長]

單行及多行字符串：

word = '字符串'
sentence = "這是一個句子。"
paragraph = """這是一個段落，
可以由多行組成"""           #多行字符串'''...'''還可以在前面加上r使用，將認為里面的字符串默認不轉義：

字符串截取及轉義：

#!/usr/bin/python3
 
str='Runoob'
 
print(str)                 # 輸出字符串 Runoob
print(str[0:-1])           # 輸出第一個到倒數(shù)第二個的所有字符 Runoo
print(str[0])              # 輸出字符串第一個字符 R
print(str[2:5])            # 輸出從第三個開始到第五個的字符 noo
print(str[2:])             # 輸出從第三個開始后的所有字符 noob
print(str[1:5:2])          # 輸出從第二個開始到第五個且每隔兩個的字符 uo
print(str * 2)             # 輸出字符串兩次 RunoobRunoob
print(str + '你好')         # 連接字符串 Runoob你好
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n轉義特殊字符 
                               #  hello
                               # runoob
print(r'hello\nrunoob')     # 在字符串前面添加一個 r，表示原始字符 串，不會發(fā)生轉義 hello\nrunoob

len()方法可以得到字符串的長度：

>>> len('ABC')
3
>>> len('中文')
2

在Python2中，普通字符串是以8位ASCII碼進行存儲的，而Unicode字符串則存儲為16位unicode字符串，這樣能夠表示更多的字符集。使用的語法是在字符串前面加上前綴 u。在Python3中，所有的字符串都是Unicode字符串。

3.1、字符串中的占位符（%）

在字符串中，我們可以用 % 占位符來代替變量輸出格式化字符：

print ("我叫 %s 今年 %d 歲!" % ('小明', 10))   # 我叫 小明 今年 10 歲!

'Hello, %s' % 'world'  # 只有一個占位符后面的變量可以省略括號  Hello, world

%運算符就是用來格式化字符串的。在字符串內部，%s表示用字符串替換，%d表示用整數(shù)替換，有幾個%?占位符，后面就跟幾個變量或者值，順序要對應好。如果只有一個%?，括號可以省略。

其中，格式化整數(shù)和浮點數(shù)還可以指定是否補0和整數(shù)與小數(shù)的位數(shù)：

print('%2d-%02d' % (3, 1))   # 3-01 注意：3前面有1個空格
print('%.2f' % 3.1415926)    #3.14

如果不確定應該用什么，可以直接用%s，它會把任何數(shù)據(jù)類型轉換為字符串：

>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'

另外，可以用%%來表示一個%：

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'

3.2、format()、f-string輸出格式化字符串

還可以使用字符串的format()方法來輸出格式化的字符串，它會用傳入的參數(shù)依次替換字符串內的占位符{0}、{1}、、

'Hello, {0}, 成績提升了 {1:.1f}%'.format('小明', 17.125)   #'Hello, 小明, 成績提升了 17.1%'

另外，還可以使用以f開頭的字符串，稱之為f-string。f-string 是 python3.6 之后版本添加的，稱之為字面量格式化字符串，是新的格式化字符串的語法。它和普通字符串不同之處在于，字符串如果包含{xxx}，就會以對應的變量替換。

f-string 格式化字符串以 f 開頭，后面跟著字符串，字符串中的表達式用大括號 {} 包起來，它會將變量或表達式計算后的值替換進去，實例如下：

r = 2.5
s = 3.14 * r ** 2
print(f' {r} and number {s:.2f}')  # 2.5 and number 19.62

上述代碼中，{r}被變量r的值替換，{s:.2f}被變量s的值替換，并且:后面的.2f指定了格式化參數(shù)（即保留兩位小數(shù)），因此，{s:.2f}的替換結果是19.62。

4、list 列表（類似可變長數(shù)組）

Python 內置的一種數(shù)據(jù)類型是列表 list，列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。

list是一種有序的集合，可以隨時添加和刪除其中的元素。列表中元素的類型可以不相同，它支持數(shù)字，字符串甚至可以包含列表（所謂嵌套），因此 list 可以是一個二維數(shù)組，類似的還有三維、四維……數(shù)組。。

a = ['Michael', 'Bob', 'Tracy']
L = ['Apple', 123, True]
s = ['python', 'java', ['asp', 'php'], 'scheme']

用len()函數(shù)可以獲得list元素的個數(shù)，如果一個list中一個元素也沒有，就是一個空的list，它的長度為0：

len(classmates)  #3
L = []
print(len(L))    #0

可以用 + 號和 * 號對列表進行操作，加號 + 是列表連接運算符，星號 * 是重復操作。如下實例：

#!/usr/bin/python3

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

print (tinylist * 2)    # 輸出兩次列表 [123, 'runoob', 123, 'runoob']
print (list + tinylist) # 連接列表 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

4.1、截取list中的元素（listObj[頭下標:尾下標]）

和字符串一樣，列表同樣可以被索引和截取。列表截取的語法格式：變量[頭下標:尾下標]，不包含尾下標的元素。索引值以 0 為開始值，-1 為從末尾的開始位置。列表被截取后返回一個包含截取元素的新列表。

實例：

#!/usr/bin/python3

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

print (list)            # 輸出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2]
print (list[0])         # 輸出列表第一個元素 abcd 
print (list[1:3])       # 從第二個開始輸出到第三個元素 [786, 2.23]
print (list[2:])        # 輸出從第三個元素開始的所有元素 [2.23, 'runoob', 70.2]

當索引超出了范圍時，Python會報一個IndexError錯誤，所以，要確保索引不要越界，記得最后一個元素的索引是len(classmates) - 1。

與Python字符串不一樣的是，列表中的元素是可以改變的。要把某個元素替換成別的元素，可以直接賦值給對應的索引位置：

a = [1, 2, 3, 4, 5, 6]
a[0] = 9  #修改list
a[2:5] = [13, 14, 15]
print(a)  #[9, 2, 13, 14, 15, 6]

a[2:5] = []   # 將對應的元素值設置為 []
print(a)  #[9, 2, 6]

4.2、給list添加元素（append()、insert()）

list是一個可變的有序表，所以，可以往list中追加元素到末尾：

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引號為1的位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

4.3、刪除list中的元素（pop()、remove）

要刪除list末尾的元素，用pop()方法，pop() 方法返回被移除的元素。

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要刪除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

list.remove(obj) remove() 函數(shù)用于移除列表中某個值的第一個匹配項：

#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao']
list1.remove('Taobao')
print ("列表現(xiàn)在為 : ", list1)   #['Google', 'Runoob']

5、tuple元組（不可變的list）

另一種有序列表叫元組：tuple。元組（tuple）與列表類似，不同之處在于元組的元素不能修改，tuple一旦初始化就不能修改。當你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來。

元組寫在小括號 () 里，元素之間用逗號隔開。元組與字符串類似，可以被索引且下標索引從0開始，-1 為從末尾開始的位置。也可以進行截取，同時也可以使用 + 號和 * 符號。我們可以把字符串看作一種特殊的元組。

示例：

#!/usr/bin/python3

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

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

tuple 中的元素不能修改，它也沒有append()、insert()這樣的方法。但如果tuple中的元素含有一些引用類型的值，比如 list ，那該 list 是可變的，但此時 tuple 并不違背定義后不可變的原則，因為只是 tuple 中的 list 發(fā)生了改變，但 tuple 指向 list 仍未發(fā)生改變。但不允許指向的 list 被替換成另一個 list。

元素中的元素不能修改，但是整個元組可以重新被賦值。所謂元組的不可變指的是元組所指向的內存中的內容不可變。重新賦值的元組就綁定到新的對象了，不是修改了原來的對象，所以是可以的。

tup = ('r', 'u', 'n', 'o', 'o', 'b')
# tup[0] = 'g'     # 修改元組中的元素將直接報錯

tup = (1, 2, 3)    #支持重新給元組賦值

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

tup1 = ()    # 空元組
tup2 = (20,) # 構造一個元素的元組，需要在元素后添加逗號

要定義一個只有1個元素的 tuple 不能直接寫 tup2 = (20)，此時定義的不是 tuple，而是將 20 賦值給了 tup2 這個變量。這是因為括號()既可以表示tuple，又可以表示數(shù)學公式中的小括號，這就產生了歧義，因此，Python規(guī)定，這種情況下，按小括號進行計算，計算結果自然是1。所以，只有1個元素的tuple定義時必須加一個逗號，來消除歧義

6、set集合（類似不可重復數(shù)組）

集合（set）是由一個或數(shù)個形態(tài)各異的大小整體組成的，構成集合的事物或對象稱作元素或是成員。在set中，沒有重復的值，重復元素在set中自動被過濾。set 不是有序的，打印出的順序并不能代表它里面元素的排序。set 可以看成數(shù)學意義上的無序和無重復元素的集合。集合之間還可以進行集合運算（差集 -、并集 |、交集 &、^）。

6.1、創(chuàng)建集合

可以使用大括號 { } 或者 set() 函數(shù)創(chuàng)建集合，使用 set() 函數(shù)時，括號里面需提供一個 list 作為輸入?yún)?shù)：

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

實例：

#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', 'Google'}  # 集合中的重復元素會被自動去掉，程序不會報錯  

print(sites)   #輸出集合 {'Runoob', 'Google', 'Taobao'}

#判斷元素是否存在于集合當中
if 'Runoob' in sites :
    print('Runoob 在集合中')  #輸出 在集合中
else :
    print('Runoob 不在集合中')


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

print(a)         # {'b', 'c', 'a', 'r', 'd'}
print(a - b)     # a 和 b 的差集 {'r', 'b', 'd'}
print(a | b)     # a 和 b 的并集 {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
print(a & b)     # a 和 b 的交集 {'c', 'a'}
print(a ^ b)     # a 和 b 中不同時存在的元素 {'z', 'b', 'm', 'r', 'l', 'd'}

set() 函數(shù)為 Python 的內置函數(shù)，其功能是將字符串、列表、元組、range 對象等可迭代對象轉換成集合。該函數(shù)的語法格式如下所示，其中，iteration 就表示字符串、列表、元組、range 對象等數(shù)據(jù)。

setname = set(iteration)

代碼示例：

set1 = set("c.biancheng.net")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
 
print("set1:",set1)  # set1: {'a', 'g', 'b', 'c', 'n', 'h', '.', 't', 'i', 'e'}
print("set2:",set2)  # set2: {1, 2, 3, 4, 5}
print("set3:",set3)  # set3: {1, 2, 3, 4, 5}

注意：創(chuàng)建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創(chuàng)建一個空字典。

集合的原理和字典一樣，所以，同樣不可以放入可變對象，因為無法判斷兩個可變對象是否相等，也就無法保證set內部“不會有重復元素”。比如把 list 放入set 程序將會報錯。

6.2、添加元素（add）

通過add(key)方法可以添加元素到set中，重復添加不會報錯，但不會有效果：

thisset = set(("Google", "Runoob"))  
thisset.add("Facebook")  #{'Google', 'Facebook', 'Runoob'}

6.3、刪除元素（remove、discard）

通過remove(key)方法可以刪除元素，但是元素如果不存在，該方法會報錯。

thisset = set(("Google", "Runoob", "Taobao"))

thisset.remove("Taobao")  #{'Google', 'Runoob'}
thisset.remove("Facebook")   # 不存在會發(fā)生錯誤

此外還有一個方法也是移除集合中的元素，且如果元素不存在，不會發(fā)生錯誤：s.discard( x )

thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook")  # 不存在不會發(fā)生錯誤

7、Dictionary字典（類似對象）

Python內置了字典：dict的支持，dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存儲，具有極快的查找速度。

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

在同一個字典中，鍵(key)必須是唯一的，并且必須是不可變的，所以可以用數(shù)字，字符串或元組充當，而用列表就不行。

不可變對象是常量，該對象的內容是不會發(fā)生改變的。對于不變對象來說，調用對象自身的任意方法，也不會改變該對象自身的內容。相反，這些方法會創(chuàng)建新的對象并返回，這樣，就保證了不可變對象本身永遠是不可變的。

創(chuàng)建及使用 dict 代碼示例：

#!/usr/bin/python3

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

dict = {}
dict['one'] = "菜鳥教程"
dict[2]     = "菜鳥工具"

print (dict['one'])       # 輸出鍵為 'one' 的值   菜鳥教程
print (dict[2])           # 輸出鍵為 2 的值  菜鳥工具
print (tinydict)          # 輸出完整的字典  {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print (tinydict.keys())   # 輸出所有鍵  dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 輸出所有值  dict_values(['runoob', 1, 'www.runoob.com'])

創(chuàng)建空字典使用 { }。

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

dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])  #{'Runoob': 1, 'Google': 2, 'Taobao': 3}

dict(Runoob=1, Google=2, Taobao=3)  #{'Runoob': 1, 'Google': 2, 'Taobao': 3}

{x: x**2 for x in (2, 4, 6)}  #{2: 4, 4: 16, 6: 36}

通過dict提供的get()方法可以返回指定鍵的值，如果該字典中不存在該鍵，則返回可以返回None，或者第二個參數(shù)指定的value：

d.get('Thomas')  #none
d.get('Thomas', -1)  #-1

可以通過in來判斷key是否存在于字典中：

'Thomas' in d  # False

要刪除一個key，用pop(key)方法，對應的value也會從dict中刪除，該方法返回被刪除的值：

d = {'name': 'wen', age: 11}
d.pop('name')  #wen

posted @ 2021-01-12 23:57 wenxuehai 閱讀(883) 評論(0) 收藏舉報

刷新頁面返回頂部

提升自己，才有選擇的能力和勇氣