Python通用編程 - 第三章：數據類型

時間  2019-11-17
標籤 python 通用 編程 第三 數據 類型 欄目 Python 简体版
原文   原文鏈接

本文是Python通用編程系列教程，已所有更新完成，實現的目標是從零基礎開始到精通Python編程語言。本教程不是對Python的內容進行泛泛而談，而是精細化，深刻化的講解，共5個階段，25章內容。因此，須要有耐心的學習，才能真正有所收穫。雖不涉及任何框架的使用，可是會對操做系統和網絡通訊進行全局的講解，甚至會對一些開源模塊和服務器進行重寫。學完以後，你所收穫的不只僅是精通一門Python編程語言，並且具有快速學習其餘編程語言的能力，無障礙閱讀全部Python源碼的能力和對計算機與網絡的全面認識。對於零基礎的小白來講，是入門計算機領域並精通一門編程語言的絕佳教材。對於有必定Python基礎的童鞋，相信這套教程會讓你的水平更上一層樓。html

一 數字類型

1. 數字類型 int和float

在第一章用戶交互咱們給你們介紹了一下基本的數據類型，這一章主要是介紹不一樣數據類型的使用方法和深刻研究python

數字類型即變量的值，如age=18，18則是咱們保存的數據。
變量的是用來反映/保持狀態以及狀態變化的，毫無疑問針對不一樣的狀態就應該用不一樣類型的數據去標識
複製代碼

數字類型只能存一個值，是不可變類型（不可變類型能夠哈希，後面章節會講解哈希）git

#int整型
定義：age=10  # age=int(10)
用於標識：年齡，等級，身份證號，qq號，個數
#float浮點型
定義：salary=3.1 #salary=float(3.1)
用於標識：工資，身高，體重，
複製代碼

2. int類型經常使用的方法

# 經常使用操做+內置的方法
print(bin(3)) #十進制轉成二進制,0b11
print(oct(8)) #十進制轉成八進制,0o10
print(10) #10
print(hex(16)) #十進制轉成十六進制,0x10
複製代碼

在進行用戶交互程序的時候咱們經常使用 .isdigit()這個判斷用戶輸入是否是數字，來進行下一步操做，這樣就避免了程序出錯，可是須要注意的是用戶輸入的內容默認是字符串，判斷一個字符串是不是數字，咱們使用這個方法。編程

age = input(your age>>:)
if age.isdigit():
    age = int(age)
    age +=1 
print(age)
複製代碼

3. Python其餘數字類型（瞭解）

#int（整型）
在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647
在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807
#long（長整型）
跟C語言不一樣，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上因爲機器內存有限，咱們使用的長整數數值不可能無限大。
注意，自從Python2.2起，若是整數發生溢出，Python會自動將整數數據轉換爲長整數，因此現在在長整數數據後面不加字母L也不會致使嚴重後果了。
注意：在Python3裏再也不有long類型了，全都是int
>>> a= 2**64
>>> type(a)  #type()是查看數據類型的方法
<type 'long'>
>>> b = 2**60
>>> type(b)
<type 'int'>
#complex複數型
>>> x=1-2j
>>> x.imag
-2.0
>>> x.real
1.0
複製代碼

二 字符串類型

1. 字符串類型介紹

在python中，加了引號的字符就是字符串類型，用於標識：描述性的內容，如姓名，性別，國籍，種族，定義形式：api

name='Albert' # name=str('Albert') 
複製代碼

字符串格式化：服務器

name = input('請輸入名字>>:')
print('你好，%s' % name)
複製代碼

2. 單引號，雙引號和三引號的區別

#那單引號、雙引號、多引號有什麼區別呢？ 讓我大聲告訴你，單雙引號木有任何區別，只有下面這種狀況 你須要考慮單雙的配合
msg = "My name is Albert , I'm 18 years old!"
#多引號什麼做用呢？做用就是多行字符串必須用多引號
msg = 
''' 今天我想寫首小詩， 歌頌個人同桌， 你看他那烏黑的短髮， 好像一隻炸毛雞。 '''
print(msg)
# 三引號裏面寫多行內容
複製代碼

3. 字符串的拼接

#數字能夠進行加減乘除等運算，字符串呢？讓我大聲告訴你，也能？what ?是的，但只能進行"相加"和"相乘"運算。
>>> name='albert'
>>> age='18'
>>> name+age #相加其實就是簡單拼接
'albert18'
>>> name*5 
'albertalbertalbertalbertalbert'
#注意1：
字符串1+字符串3，並不會在字符串1的基礎上加字符串2，而是申請一個全新的內存空間存入字符串1和字符串3，至關字符串1與字符串3的空間被複制了一次，
#注意2：只能字符串加字符串，不能字符串加其餘類型
字符串拼接（只能在字符串之間進行，且只能相加或相乘）
複製代碼

字符串類型只能存一個值，是不可變類型，能夠哈希。網絡

4. 字符串類型經常使用的方法

(1) 按照索引取值

字符串是不可變類型，並不能改變字符串的值，取值時最多能夠有三個參數，分別是起始位置，結束爲止和步長，能夠正向取值，反向取值（起始位置大於結束位置或者沒有起始位置與結束位置，步長爲-1表示從最後一個開始，步長爲負數）數據結構

hobbies = "music basketball"
print(hobbies[0])
print(hobbies[1])
print(hobbies[5])
print(hobbies[0:5])
print(hobbies[:5])
print(hobbies[0:5:2])
print(hobbies[0:5:-2])
print(hobbies[11:5:-2])
print(hobbies[-1])
print(hobbies[-2])
複製代碼

(2) 長度運算

print(len('name'))
複製代碼

(3) 成員運算

print('a' in 'Albert')
# False
print('a' in not 'Albert')
# True
複製代碼

(4) 移除空白

print(' name'.lstrip())  # 移除左邊空白
print('name '.rstrip())  # 移除右邊空白
print(' name '.strip())  # 移除兩邊空白
複製代碼

(5) 切分

print('n a me'.split(','))
print('n,a me'.split(','))
print('n,/a /me'.split('/',1)) # 數字表示切割次數，默認所有切割
print('n,a /me'.split('/'))
print('a|b|c'.rsplit('|',1)) # 從右邊開始切割
複製代碼

(6) 組合

print('a'.join('1234'))
print('a'.join('bcde'))
tag = ' '
print(tag.join(['I', 'say', 'hello', 'world']))  # 可迭代對象必須都是字符串
複製代碼

(7) 替換

print('abc name id'.replace('a', 'card')) 
name = 'albert say :i have a dream,my name is albert'
# 注意此時name原來的值並無改變，而是產生了一個替換以後新的值
print(name.replace('albert', 'Albert', 1))   
複製代碼

(8) 字符串其餘操做

# find,rfind,index,rindex,count
name='albert say hello'
print(name.find('o',1,3))  # 顧頭不顧尾,找不到則返回-1不會報錯,找到了則顯示索引
# print(name.index('e',2,4)) # 同上,可是找不到會報錯
print(name.count('e',1,3))  # 顧頭不顧尾,若是不指定範圍則查找全部
# center,ljust,rjust,zfill
name='albert'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50))  # 用0填充

# expandtabs
name='albert\thello'
print(name)
print(name.expandtabs(1))

# captalize,swapcase,title
print(name.capitalize())  # 首字母大寫
print(name.swapcase())  # 大小寫翻轉
msg='albert say hi'
print(msg.title())  # 每一個單詞的首字母大寫

# is數字系列
# 在python3中
num1=b'4'  # bytes
num2=u'4'  # unicode,python3中無需加u就是unicode
num3='四'  # 中文數字
num4='Ⅳ' #羅馬數字

# isdigit:bytes,unicode
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

# isdecimal:uncicode
# bytes類型無isdecimal方法
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

# isnumberic:unicode,中文數字,羅馬數字
# bytes類型無isnumberic方法
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

# 三者不能判斷浮點數
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())

''' 總結: 最經常使用的是isdigit,能夠判斷bytes和unicode類型,這也是最多見的數字應用場景 若是要判斷中文數字或羅馬數字,則須要用到isnumeric '''

# is其餘
print('===>')
name='alb123ert'
print(name.isalnum())  # 字符串由字母或數字組成
print(name.isalpha())  # 字符串只由字母組成
print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())
複製代碼

三 列表

1. 列表類型基本介紹

在[]內用逗號分隔，能夠存放n個任意類型的值，用於標識：存儲多個值的狀況，好比一我的有多個愛好，定義格式示例：app

students=['albert','james','kd',] 
# 或者students=list(['albert','james','kd',]) 
複製代碼

列表能夠存儲多個值，是有序的，是可變類型，不能夠哈希。框架

2. 列表類型經常使用的方法

(1) 添加元素

append方法 在列表最後追加元素

l1 = ['a', 'b', 'c', 'd', ]
l1.append('e')
print(l1)
print(l1.append('e'))
# 在隊尾追加，沒有返回值

# ['a', 'b', 'c', 'd', 'e']
# None
複製代碼

insert方法 在列表中插入元素

l1 = ['a', 'b', 'c', 'd', ]
l1.insert(3,'x') # 3 指定插入索引3這個位置，就是「d」，這個位置，把‘d’ 頂到了後面
print(l1)

# insert能夠指定插入的位置

# ['a', 'b', 'c', 'x', 'd']
複製代碼

extend方法 在列表中同時插入多個元素，extend方法使用以及與append方法的區別 append是總體添加

l1 = [1, 2, 3, 4, 5, ]
l1.append([6, 7, 8, 9, ])
# l1.append(*[6, 7, 8, 9, ]) # 會報錯
print(l1)
l1.extend([6, 7, 8, 9])
print(l1)
複製代碼

只能接收一個參數，若是出現打散的狀況，仍是會被識別成多個參數，由於程序執行執行是從左到右，從上倒下執行的，當出現時這個列表已經被打散了，於是，會被程序識別成被傳入了多個參數。

extend是逐個添加

l1 = [1, 2, 3, 4, 5, ]
l1.extend([6, 7, 8, 9])
print(l1)
l1.extend('abc')
print(l1)
l1.extend('a')  # 也是可迭代對象
print(l1)
# l1.extend(1) # 報錯，不可迭代
print(l1)
複製代碼

extend在執行添加的時候，被傳入的參數必須是可迭代對象，這樣經過迭代就解決了同時傳入多個參數的問題，若是你還不知道可迭代對象，放心，你很快就會知道的。

(2) 刪除元素

pop刪除，有返回值，默認刪除列表中最後一個，指定刪除索引值

l1 = [1, 2, 3, 4, 5, 6, ]
print(l1.pop())  # 這個是有返回值的，由於這是一個可迭代類型和咱們前面的extend一類
print(l1)
print(l1.pop(2))  # 2指定是列表中的索引值
print(l1)
複製代碼

remove 刪除 沒有返回值，沒有默認值，指定被刪除的元素

l1 = [1, 2, 3, 4, 5, 6, ]
print(l1.remove(2))  # 注意這個2 是真的2，不是索引值
# print(l1.remove()) # 報錯
print(l1)
複製代碼

clear 刪除 保留列表名稱，清空裏面的值

l1 = ['a', 'b', 'c', 'd', 'e', 'b', 'c']
l1.clear()
print(l1)
複製代碼

del 刪除 通用刪除 可是通常不用

l1 = [1, 2, 3, 4, 5, 6, ]
del l1[2]  # 按索引
print(l1)
l1 = [1, 2, 3, 4, 5, 6, ]
del l1  # 在內存中刪除l1 至關於沒有定義l1
# print(l1) # 報錯
複製代碼

(3) 更改元素

注意與insert插入的不一樣，都是以原來的爲位置爲參照，insert是擠開，本質是添加，而這裏是替換

l1 = [1, 2, 3, ]
l1[2] = 4
print(l1)
複製代碼

(4) 查找元素

按照索引或者指定列表中的元素查找

l1 = ['a', 'b', 'c', 'd', 'e', 'b', 'c']
print(l1.index('a'))
print(l1.index('b',1,4))  # 兩個數字分別對應起始位置和結束位置
print(l1[0:5])  # 按照索引取值和字符串的用法相同
print(l1[:5])
print(l1[0:5:2])
print(l1[:-1])
print(l1[:-2])
print(l1[5:1:-2])
複製代碼

把列表分段查找

l1 = ['a', 'b', 'c', 'd', 'e', 'b', 'c']
a = int(len(l1)/2)
print(l1[:a])  # 從中間位置開始，列出前面全部的元素
print(l1[a:])  # 從中間位置開始，列出後面全部的元素
複製代碼

使用enumerate對列表枚舉

l1 = ['a', 'b', 'c', 'd', 'e']
for i, x in enumerate(l1, 100):  # 100指定枚舉開始的數字
    print(i, x)
複製代碼

(5) 統計長度

print(len([1,2,3,4,]))
複製代碼

(6) 統計元素個數

print(['a','b'].count('a'))
複製代碼

(7) 排序 reverse 反序排序

l1 = ['a', 1, 'b', 'c', 'd', 'e', 'b', 'c']
l1.reverse()
print(l1)
複製代碼

sort 按照ascii碼來進行排序

l1 = ['a', '1', 'b', 'c', 'd', 'e', 'b', 'A', 'Z', 'c']
l1.sort()
print(l1)
l1.sort(reverse=True)
print(l1)
複製代碼

(7) 複製列表

l1 = ['a', '1', 'b', 'c', 'd', 'e', 'b', 'A', 'Z', 'c']
print(l1.copy())
複製代碼

(8) Python中的賦值，淺拷貝與深拷貝區別 賦值 對於複製的操做，最簡單的就是賦值，指的是新建一個對象的引用，新建目標對象與原來的目標對象指向同一個內存地址，於是，始終保持一致。

list1 = [1, 2, 3, 4, 5, [6, 7, 8, ]]
list2 = list1
list1.append(9)
print(list1)
print(list2)
list1[5][0] = 10
print(list1)
print(list2)
list1[5] = 10
print(list1)
print(list2)
複製代碼

淺拷貝 淺拷貝顧名思義就是拷貝的比較淺，咱們能夠把賦值認爲是新建了一個對象的引用，把原來被對象內存空間的數據指向新的變量，這時同一塊內存空間指向兩個變量。淺拷貝與賦值不一樣，既然是拷貝，那麼就是要開闢一塊新的內存空間，複製的是原來被拷貝對象內多個元素對象的引用，有幾個元素對象就賦值幾個元素對象的引用。所以，被淺拷貝對象內的元素改變，會引發淺拷貝對象內元素的改變；被拷貝對象添加元素，拷貝對象再也不添加元素（由於沒有一個新的引用）；被拷貝對象刪除元素，拷貝對象也刪除元素（元素都已經刪了，雖然引用存在，可是並無什麼卵用）。

import copy


list1 = [1, 2, 3, 4, 5, [6, 7, 8, ]]
list2 = copy.copy(list1)
print(list1)
print(list2)

list1[5].append(9)
print(list1)
print(list2)

list1.append(6)
print(list1)
print(list2)

list1.pop()
print(list1)
print(list2)
複製代碼

深拷貝 深拷貝其實與淺拷貝有本質的區別，它不會複製任何的引用，對象內的全部元素，子元素，孫子元素，重孫元素，曾孫元素的數據都是由複製而來。它的實現原理就是遞歸，只要任意元素內仍然有子元素，就會複製子元素的數據放到新的內存地址。既然這樣，在使用深拷貝後，被拷貝對象的改變，不會引發拷貝對象的任何改變。

import copy


list1 = [1, 2, 3, 4, 5, [6, 7, 8, ]]
list2 = copy.deepcopy(list1)
print(list1)
print(list2)

list1[5].append(9)
print(list1)
print(list2)

list1.append(6)
print(list1)
print(list2)

list1.pop()
print(list1)
print(list2)
複製代碼

複製與深淺拷貝總結：

  • 賦值：新建一個原來對象內存地址的引用，不開闢新的內存空間；
  • 淺拷貝：新建多個原來對象內一級子元素內存地址的引用，開闢新的內存空間；
  • 深拷貝：複製原來對象內的全部N級子元素的數據，開闢新的內存空間。

四 元組

與列表類型相比，很是相似只不過[]換成()，做用：用於存儲多個值，對比列表來講，元組不可變（是能夠當作字典的key的），不可更改，主要是用來讀。

age=(11,22,33,44,55)
# 本質age=tuple((11,22,33,44,55))
複製代碼

元組能夠存儲多個值，是有序的，是不可變類型，能夠哈希。元組經常使用的方法，請參考列表經常使用方法，須要注意的是，元組只能取值，而不能改變元組的值

五 字典

1. 字典類型基本介紹

字典用於存放一我的的信息：姓名，性別，年齡，很明顯是多個值，既然是存多個值，咱們徹底能夠基於剛剛學習的列表去存放，以下：

# 既然如此，咱們咱們爲什麼還要用字典？
info=['albert','male',18]
# 定義列表的目的不僅僅是爲了存，還要考慮取值，若是我想取出這我的的年齡，能夠用
info[2]
# 但這是基於咱們已經知道在第3個位置存放的是年齡的前提下，咱們才知道索引2對應的是年齡，即：
# # name, sex, age
info=['albert','male',18]
""" 而這徹底只是一種假設，並無真正意義上規定第三個位置存放的是年齡， 因而咱們須要尋求一種，便可以存放多個任意類型的值，又能夠硬性規定值的映射關係的類型， 好比key=value，這就用到了字典 """
複製代碼

字典用於標識存儲多個值的狀況，每一個值都有惟一一個對應的key，能夠更爲方便高效地取值，字典的定義格式以下：

# 在{}內用逗號分隔，能夠存放多個key:value的值，key通常是字符串，value能夠是任意類型
info={'name':'albert','age':18,'sex':18} 
# info=dict({'name':'albert','age':18,'sex':18})
複製代碼

字典能夠存儲多個值，是無序的，是可變類型，不可哈希。

2. 字典類型經常使用的方法

(1) 增長元素

經過鍵值對的方式

l1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male'
}
l1['hobbies'] = "music"
print(l1)
複製代碼

用fromkeys構造一個字典

""" 第一個參數迭代循環的字典的key，第二個參數表示value， 能夠多個key循環對應這個value，也能夠只有一個key，也能夠沒有value """
a = l1.fromkeys(l1,'I am Albert') 
print(a)

b = dict.fromkeys('name')  # 必須有一個可迭代類型，做爲字典的key
print(b)

b = dict.fromkeys('e')  # 也能夠迭代
print(b)
# b = dict.fromkeys(1) #報錯 數字類型不可迭代

b = dict.fromkeys([1,2,3,])
print(b)
複製代碼

(2) 刪除元素

del 經過字典的key刪除

l1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male'
}

del l1['name']
print(l1)
複製代碼

pop 或者popitem刪除

l1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male'
}

res = l1.pop('name')  # 刪除指定key的value，並拿到一個返回值
print(res)
print(l1)

res2 = l1.popitem()  # 隨機返回並刪除字典中的一對鍵和值(通常刪除末尾對)。
# 若是字典已經爲空，卻調用了此方法，就報出KeyError異常。
print(res2)
print(l1)
複製代碼

(3) 更改元素

經過鍵值對的方式

l1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male','3':3,
}

l1['name'] = '馬一特'
print(l1)
複製代碼

經過setdefault 或者update操做，二者使用和區別以下： setdefault只添加不修改

d1 = {
    'name': 'albert',
    'age': 18,
}

d1.setdefault('name', 'Albert')
d1.setdefault('gender', 'male')
print(d1)
複製代碼

update既添加也修改

d1 = {
    'name': 'albert',
    'age': 18,
}

d1.update({'name': 'Albert', 'gender': 'male'})  # 注意傳參方式的不一樣
print(d1)
複製代碼

(4) 查找元素

經過鍵值對查找

l1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male'
}

a = l1['name']
print(a)
複製代碼

經過get方法查找

l1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male'
}

a = l1.get('hobbies')   # 找不到不報錯
print(a)
複製代碼

經過enumerate 枚舉

d1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male',
    '3':3,
}

for a in enumerate(d1):
    print(a)
複製代碼

經過.keys(),.values(),.items()等方法

d1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male',
    '3':3,
}

a = d1.keys()
print(a)
print(list(a)[0])

a = d1.values()
print(a)
print(list(a)[0])

a = d1.items()
print(a)
print(list(a)[0])
複製代碼

經過for循環遍歷

d1 = {
    'name': 'albert',
    'age': 18,
    'gender': 'male',
    '3':3,
}

for k,v in d1.items():
    print(k,v)
複製代碼

(5) 成員運算與長度運算

參考列表的運算方法，成員運算的依據是字典的key，而不是value，長度運算均可以做爲參考的依據

六 集合類型

花括號內，多個元素用逗號分割，用來存儲多個值，而且是無序的，那麼這多個值不能用來取值，可是咱們可使用它來進行去重和關係運算。

# 集合的元素遵循三個原則：
             1: 每一個元素必須是不可變類型(可做爲字典的key)
             2: 沒有重複的元素
             3: 無序
# 注意集合的目的是將不一樣的值存放到一塊兒，不一樣的集合間用來作關係運算，無需糾結於集合中單個值
複製代碼

集合類型能夠存多個值，是無序的，是可變類型，不能夠哈希。
關係運算練習

有以下兩個集合，piano是報名鋼琴課程的學員名字集合，violin是報名小提琴課程的學員名字集合
&emsp;&emsp;piano={'albert','孫悟空','周星馳','朱茵','林志玲'}
&emsp;&emsp;violin={'豬八戒','郭德綱','林憶蓮'，'周星馳'}
&emsp;&emsp;1. 求出即報名鋼琴又報名小提琴課程的學員名字集合
&emsp;&emsp;2. 求出全部報名的學生名字集合
&emsp;&emsp;3. 求出只報名鋼琴課程的學員名字
&emsp;&emsp;4. 求出沒有同時這兩門課程的學員名字集合
複製代碼

參考答案

# 求出即報名鋼琴又報名小提琴課程的學員名字集合
print(piano & violin)
# 求出全部報名的學生名字集合
print(piano | violin)
# 求出只報名鋼琴課程的學員名字
print(piano - violin)
# 求出沒有同時這兩門課程的學員名字集合
print(piano ^ violin)
複製代碼

七 布爾類型

計算機俗稱電腦，即咱們編寫程序讓計算機運行時，應該是讓計算機無限接近人腦，或者說人腦能幹什麼，計算機就應該能幹什麼，人腦的主要做用是數據運行與邏輯運算，此處的布爾類型就模擬人的邏輯運行，即判斷一個條件成立時，用True標識，不成立則用False標識。

#布爾值，一個True一個False
>>> a=3
>>> b=5
>>> a > b #不成立就是False,即假
False
>>> a < b #成立就是True, 即真
True
# 接下來就能夠根據條件結果來幹不一樣的事情了：
if a > b:
   print(a is bigger than b )
else:
   print(a is smaller than b )
# 上面是僞代碼，但意味着，計算機已經能夠像人腦同樣根據判斷結果不一樣，來執行不一樣的動做。
複製代碼

布爾類型的重點知識

#全部數據類型都自帶布爾值
1、None，0，空（空字符串，空列表，空字典等）三種狀況下布爾值爲False
2、其他均爲真
複製代碼

可變類型與不可變類型（重點）

# 1.可變類型：在id不變的狀況下，value能夠變，則稱爲可變類型，如列表，字典
# 2. 不可變類型：value一旦改變，id也改變，則稱爲不可變類型（id變，意味着建立了新的內存空間）
複製代碼

八 collections容器數據類型

1. namedtuple 命名元組

from collections import namedtuple
# 建立一個命名元組對象
point = namedtuple('p', ['x', 'y'])  # p表明名稱，"x"和"y"爲內容
p = point(1, 2)
print(p)
print(p.x)  # 1
print(p.y)  # 2
複製代碼

2. deque 超級列表

from collections import deque
# 相似列表(list)的容器，實現了在兩端快速添加(append)和彈出(pop)
d = deque('abcd')
for i in d:
    print(i)
print(d[0])
print(d[1])
d.append('e')  # 從右邊加入
print(d)
d.appendleft('x')  # 從左邊加入
print(d)
d.pop()  # 從右側彈出
print(d)
d.popleft()  # 從左側彈出
print(d)
deque(reversed(d))  # 反轉順序
print(d)
# d = list(d) # 轉化成list
# d = list(reversed(d))
# print(d)
d.extend('xyz')  # 從右側添加
print(d)
d.extendleft('nba')  # 從左側添加
print(d)
d.rotate(1)  # 把最右邊的元素挪到最左邊
print(d)
d.rotate(-1)  # 把最左邊的元素挪到最右邊
print(d)
d.clear()  # 清空
# d.pop() # 報錯
複製代碼

3. ChainMap 鏈映射

from collections import ChainMap
""" 一個 ChainMap 類是爲了將多個映射快速的連接到一塊兒，這樣它們就能夠做爲一個單元處理。 它一般比建立一個新字典和屢次調用 update() 要快不少。 這個類能夠用於模擬嵌套做用域，而且在模版化的時候比較有用。 """
# 鏈映射的用法
dict1 = {'name': 'Albert', 'age': 18}
dict2 = {'weight': 65, 'height': 180}
res = list(ChainMap(dict1, dict2))
print(res)
複製代碼

4. Counter 計數字典

from collections import Counter
# 計數
cnt = Counter()
for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
    cnt[word] += 1
print(cnt)
# Counter({'blue': 3, 'red': 2, 'green': 1})
# 數學運算
c = Counter(a=3, b=1)
d = Counter(a=1, b=2)
print(c + d)  # 相同的部分相加
# Counter({'a': 4, 'b': 3})
print(c - d)  # 相同的部分相減
# Counter({'a': 2})
print(c & d)  # 相同的部分取最小
# Counter({'a': 1, 'b': 1})
print(c | d)  # 相同的部分取最大
# Counter({'a': 3, 'b': 2})
複製代碼

Collections容器類型一共有9種，除了上面介紹的4種以外還有OrderedDict，defaultdict，UserDict，UserList，UserString，他們的用法不是徹底相同，可是使用起來並不複雜，更多Collections容器類型數據結構詳見官方文檔：Collections容器數據類型。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程