一文拿捏Python基本數(shù)據(jù)類型“列表、數(shù)組和字典”

引言

Python中的 列表(英文叫l(wèi)ist) 、 元組(英文叫tuple)和字典（dictionary） 也是 序列 特性的，它們也是非常常用的數(shù)據(jù)類型。

1、列表（List）

01、概述

列表（List）對象 經(jīng)常被用來 存儲 數(shù)據(jù)對象。我們可以把列表想象為 一連串的儲物格，就像下面這樣：

其中每個儲物格里面都可以存儲 任何類型 的對象

注意：是任何類型的對象， 整數(shù)、小數(shù)、字符串、函數(shù)、等等 都可以。 也可以存儲另一個列表對象。

Python代碼中，我們可以這樣定義一個空的列表，賦值給一個變量:

nameList = []
# 方括號用來表示一個列表

如果定義列表的時候，里面就存放了一些數(shù)據(jù)對象，只需要填寫到方括號里面就可以了。每個對象之間用逗號隔開。比如:

a = [1, 2, 3.14, 'hello']
# 這個列表里面就包含了多種類型的對象: 整數(shù)、小數(shù) 、 字符串。
# 列表里面的每個對象，就稱之為列表的一個元素。

列表中還可以包含另一個列表作為元素，如下

a = [1, 2, 3.14, 'hello', [7,8,9] ]
# 最后一個元素就是另外的一個列表對象 [7,8,9]

02、列表的sequence操作

雷彪具有序列化的特性，所以也支持sequence操作。舉例如下：

可以用元素索引的方式取出里面的元素; 也可以用切片操作 截取一部分內(nèi)容生成新的列表。
列表的 索引和切片操作和 字符串是 類似的。

比如上面的列表，其索引如下所示

列表每個元素的索引是從0開始的，支持正數(shù)索引，也支持負數(shù)索引

a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0]    # 就是 1
a[1]    # 就是 2
a[4]    # 就是 [7,8,9]
a[-1]   # 也是 [7,8,9]
a[-4]   # 也是 2
a[-1][0]  # a[-1] 是[7,8,9],  a[-1][0] 就是 [7,8,9] 里面的第一個元素，就是 7

列表的切片也和字符串類似，想象用刀去切取其中的一部分，該在哪里下刀，就使用哪里的索引

a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0:3]      # 結(jié)果是   [1, 2, 3.14]
a[:3]       # 結(jié)果也是 [1, 2, 3.14]
a[3:5]      # 結(jié)果是   ['hello', [7,8,9] ]
a[3:]       # 結(jié)果也是 ['hello', [7,8,9] ]

a[-1][:2]   # 結(jié)果是   [7,8]  采用二維數(shù)組，即訪問列表中的列表

print(a)      
# 結(jié)果還是 [1, 2, 3.14, 'hello', [7,8,9] ] 
# 上面對a的切片操作是產(chǎn)生新的對象，并不會改變a指向的對象

03、修改列表的內(nèi)容

和我們前面學(xué)過的其它數(shù)據(jù)類型不同，列表對象有個特點，它的內(nèi)容是可以變化的，比如：

a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)

a[0] = '你好'
print(a)

執(zhí)行上面的代碼，可以發(fā)現(xiàn)，最后列表變量 a 的內(nèi)容變成了:

[‘你好’, 2, 3.14, ‘hello’, [7, 8, 9]]

①列表的元素也可以填寫變量，比如:

var = [7, 8, '你好']
a = [1, 2, 3.14, 'hello', var]
print(a)

結(jié)果a的值是

[1, 2, 3.14, 'hello', [7, 8, '你好']]

②列表的元素還可以填寫表達式，解釋器會自動計算結(jié)果，放入列表中，比如：

var = 100
a = [1, 2, var*3 + 20, 'hello', [7, 8, '你好']]
print(a)

結(jié)果a的值是

[1, 2, 320, 'hello', [7, 8, '你好']]

③如果想部分修改列表中的數(shù)據(jù)，該如何修改呢？

# 原始數(shù)據(jù)
list1 = [0, 1, 2, 3, 4, 5]

# 修改方法
list1[1:4] = ['a','b','c']

結(jié)果列表的值為

list1 = [0, ‘a(chǎn)’, ‘b’, ‘c’, 4, 5]

這種寫法稱之為 切片賦值

④列表合并，列表中要添加另外一個列表的內(nèi)容很簡單，用+就可

>>> a = [1,2,3]
>>> a += [4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]

2、元組（Tuple）

01、概述

元組（Tuple）也是一種sequence特性的類型， 它和列表非常相似，也可以存放任何類型的數(shù)據(jù)對象，除了一點： 元組的內(nèi)容是 不能改變 的

Python代碼中，我們可以這樣定義一個空的元組，賦值給一個變量

nameList = ()
# 圓括號用來表示一個元組。

如果定義元組的時候，里面就存放了一些數(shù)據(jù)對象，只需要填寫到括號里面就可以了。每個對象之間用逗號隔開。比如:

a = (1, 2, 3.14, 'hello')

# 這個元組里面就包含了多種類型的對象: 整數(shù)、小數(shù) 、 字符串。
# 元組里面的每個對象，就稱之為元組的一個元素。

甚至還可以包含另一個列表或者元組作為元素，如下:

a = (1, 2, 3.14, 'hello', [7,8,9] )

02、元組的sequence操作

元組也是有sequnce特性的。當(dāng)然也支持序列化操作。

就是支持用元素索引的方式取出里面的元素; 也支持用切片操作 截取一部分內(nèi)容作子列表。

元組的 索引和切片操作和 列表、字符串是 類似的。比如：

a = (1, 2, 3.14, 'hello', [7,8,9])
a[0]    # 就是 1
a[1]    # 就是 2
a[4]    # 就是 [7,8,9]
a[-1]   # 也是 [7,8,9]
a[-4]   # 也是 2
a[-1][0]  # a[-1] 是[7,8,9],  a[-1][0] 就是 [7,8,9] 里面的第一個元素，就是 7

元組的切片也和字符串類似，想象用刀去切取其中的一部分，該在哪里下刀，就使用哪里的索引

a = (1, 2, 3.14, 'hello', [7,8,9])
a[0:3]      # 結(jié)果是   (1, 2, 3.14)
a[:3]       # 結(jié)果也是 (1, 2, 3.14)
a[3:5]      # 結(jié)果是   ('hello', [7,8,9])
a[3:]       # 結(jié)果也是 ('hello', [7,8,9])

a[-1][:2]   # 結(jié)果是   [7,8]   為什么？

03、元組內(nèi)容不可變

和列表不同，元組對象的內(nèi)容是不可以變化的，比如：

a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] = '你好'

執(zhí)行上面的代碼，解釋器會報如下錯誤:

Traceback (most recent call last):

File “”, line 1, in

TypeError: ‘tuple’ object does not support item assignment

這個錯誤是一個類型錯誤，提示了元組對象不支持項目賦值。

在Python中，元組是一種不可變的數(shù)據(jù)類型。這意味著一旦創(chuàng)建了一個元組，就不能修改其中的元素。在這個錯誤中，你試圖對一個元組進行項目賦值操作，但是元組是不可變的，因此導(dǎo)致了類型錯誤。

要解決這個問題，你可以考慮使用列表（list）而不是元組，因為列表是可變的?；蛘?，你可以重新設(shè)計你的代碼，以不需要修改元組中的元素為前提。

04、多個變量同時賦值

我們可以像下面這樣把 列表 或者 元組 中的元素直接賦值給變量

x,y = (1,2)   # x 的值為 1， y 的值為 2
print(x,y)   

name, age = ['李逵', 33] # name 的值為 '李逵'， age 的值為 33
print(name,age)

注意:這樣賦值，變量的個數(shù)一定要和 列表/元組 中元素的個數(shù)相等。

05、函數(shù)返回列表或者元組

函數(shù)的返回值可以是一個列表或者 元組對象:

def func1():
    age = input('請輸入年齡')
    gender = input('請輸入性別')
    return  [age,gender]

如果有多個數(shù)據(jù)對象需要在函數(shù)里面返回的時候，就可以放到列表中。

當(dāng)然也可以放到元組中返回，例如：

def func1():
    age = input('請輸入年齡')
    gender = input('請輸入性別')
    return  age,gender
# 因為元組的括號是可以省略的

3、字典（Dictionary）

01、概述

字典，是Python開發(fā)中非常重要的一種數(shù)據(jù)類型。字典 提供了一種特別的結(jié)構(gòu)， 就是 存放 鍵值對 數(shù)據(jù)。這種結(jié)構(gòu)使得字典，特別像 一張 表

什么是鍵值對？

一個會員管理系統(tǒng)里面會存儲用戶信息，系統(tǒng) 經(jīng)常需要 查詢某個會員用戶的信息，比如 某個用戶的等級、積分等。那么根據(jù)什么去查找該用戶的信息呢？ 根據(jù) 唯一標志 該用戶的屬性，比如 用戶登錄名 或者 用戶分配的ID號 等。

• 根據(jù) 登錄名1 就查到 用戶1 的信息
• 根據(jù) 登錄名2 就查到 用戶2 的信息

這樣就形成了如下 的一種 從 登錄名 到 用戶信息數(shù)據(jù) 的映射關(guān)系

? 上圖中，登錄名1就是鍵（英文叫Key）， 用戶1 就是值（英文叫Value）；每個對應(yīng)的帳號 和 會員數(shù)據(jù) 就形成了一個鍵值對。要存儲像這樣 一對一 的映射關(guān)系的數(shù)據(jù)結(jié)構(gòu)，就像一張表一樣，在Python中就可以使用字典這種數(shù)據(jù)類型。

02、字典的定義

字典對象定義用花括號 {} , 字典里面的 每個元素之間用 逗號 隔開。

每個元素都是一個鍵值對，鍵和值之間用 冒號 隔開。

上面例子中，如果每個帳號的信息比較簡單，比如只有等級信息，就定義成如下形式：

members = {
    'account1'  : 13 ,
    'account2'  : 12 
}

上面的字典對象 鍵就是帳號，值就是一個數(shù)字對象，表示等級的數(shù)字。

注意:

• 字典元素的 鍵 必須是 可進行哈希值計算 的對象， 通常是 數(shù)字 或者 字符串。
• 字典元素的 值 可以是任何類型的對象，包括數(shù)字、字符串、列表、元組、字典、自定義類型 等等均可。

什么是哈希值計算？

哈希值計算是指將任意長度的數(shù)據(jù)通過哈希算法轉(zhuǎn)換成固定長度的連續(xù)字符序列的過程。哈希值是根據(jù)輸入數(shù)據(jù)計算得出的唯一標識，具有以下特點：

1. 哈希值是固定長度的：哈希算法將不同長度的輸入數(shù)據(jù)轉(zhuǎn)換為固定長度的輸出結(jié)果，常見的哈希算法輸出的哈希值長度為128位、256位或512位。
2. 哈希值是唯一的：對于不同的輸入數(shù)據(jù)，哈希算法應(yīng)該保證計算得出的哈希值是唯一的，即不同的輸入數(shù)據(jù)不會計算得到相同的哈希值。
3. 哈希值是不可逆的：從哈希值無法推導(dǎo)出原始輸入數(shù)據(jù)，即無法通過哈希值還原出原始數(shù)據(jù)。這是哈希算法的一個重要特性，保證了輸入數(shù)據(jù)的安全性。
4. 哈希值的變化范圍很大：即使輸入數(shù)據(jù)有微小的變化，哈希值也應(yīng)該發(fā)生較大的變化。這是為了保證數(shù)據(jù)的完整性，即對于原始數(shù)據(jù)的任何改動，都會導(dǎo)致哈希值的明顯變化。

哈希值計算在密碼學(xué)、數(shù)據(jù)完整性校驗、數(shù)據(jù)快速查找等領(lǐng)域有廣泛應(yīng)用。常用的哈希算法有MD5、SHA-1、SHA-256等。

上述例中，用戶賬號信息，如果復(fù)雜一些，包括 等級、點卡數(shù)，可以是這樣的：

members = {
    'account1'  : {'account':'account1', 'level': 13, 'point':3000} ,
    'account2'  : {'account':'account2', 'level': 12, 'point':36000} 
}

上面的字典對象 鍵就是帳號，值也是一個字典對象。 這個值字典對象中又 包含了 帳號、等級、積分信息。

字典對象的一個特點就是 ： 根據(jù) 鍵 去查找 值 非常的方便高效，

比如 members['account1'] 就可以得到 鍵為 ‘a(chǎn)ccount1’ 的 元素的值

members = {
    'account1'  : 13 ,
    'account2'  : 12 
}
print(members['account1'])

# 輸出結(jié)果為13

• 字典對象可以存儲非常多的元素。理論上 只要內(nèi)存夠大，字典的元素的數(shù)量是沒有限制的。

• 字典對象 存儲元素有特別的優(yōu)化， 根據(jù) 鍵 查找值的效率非常高，速度非?？?/strong>，特別適合查找數(shù)據(jù)這樣的操作。

members = {
    'account1'  : 13 ,
    'account1'  : 12 
}
print(members)

# 首先定義一個空字典
members = {}

# 要在字典對象中添加元素非常簡單，像這樣
members['account1'] = 13

# members的內(nèi)容就變成了如下：
{
    'account1'  : 13 
}

# 像這樣的賦值語句
var[key] = something
# 括號里面的key：
	# 如果在字典中不存在，就是添加元素的的操作，
    # 如果已經(jīng)存在，就是重新賦值操作。 因為字典不允許有相同的key

members = {
    'account1'  : 13 ,
    'account2'  : 12 
}

val = members.pop('account1')
print(members)
print(val)

members = {
    'account2'  : 12 
}

del members['account1']

a in var  
	# 檢查 a 是否在var 中存在，存在返回True，否則返回False
	
a not in var   
	# 檢查 a 是否不在var 中，存在返回 False，否則返回 True

members = {
    'account1'  : 13 ,
    'account2'  : 12 
}

if 'account1' in members:
    print('account1 在字典中存在')

if 'account88' not in members:
    print('account88 不在字典中')

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

for account,level in members.items():
    print (f'account:{account}, level:{level}')

[('account1', 13), ('account2', 12), ('account3', 15)]

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members.clear()

print(members)

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members = {}

print(members)

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members.clear()

print(members)

members = {
    'account1'  : 13 ,
    'account2'  : 12 ,
    'account3'  : 15 ,
}

members = {}

print(members)