2. 程式人生 > >Python容器：列表、元組、字典、集合

Python容器：列表、元組、字典、集合

阿新 • • 發佈：2018-12-24

文章目錄

序言

  • 此文章針對有一定基礎的人，簡明扼要的介紹字串、列表、元組、字典、集合的概念和常用操作，以備複習鞏固之用。

  • 底層的基本資料型別：布林型，整形，浮點型以及字串型別。

  • 基本資料型別組合起來稱之為資料結構。

    • 資料結構：列表、元組、字典、集合。

序列

  • 序列：一系列元素以它們所處的位置為索引，以第一個到最後一個依次編號就組成一個序列。
  • 序列結構：字串、元組和列表都是序列結構，但是它們又有各自的特點。
    • 元組和列表與字串不同的是，元組和列表並不是求所含元素的種類相同，每個元素都可以是任何Python型別的物件。
    • 元組和列表不同的是，元組是不可變的，元組被賦值後，這些值就會被固定在元組中，不會被修改，而列表中的值還可以進行插入、刪除等操作。

字串（string）

  • 字串是我們首先要接觸到的Python序列型別，其本質為字元序列，Python字串不可改變，無法對原字串進行修改，但是可以將字串的一部分複製到新的字串中。

建立字串

  • 1.1 單引號
    • 雙引號
    • 三個單引號：建立多行字串
'example1'
"example2"
'''example3,
example4
continue'''
  • 1.2 使用str()轉換
str(123)
'123'
#注意用print輸出的差別,沒有引號
print(str(123))
123

字串的簡單操作

  • \轉義
    • \n
    • \t
    • ’
    • "
  • +拼接
#注意，one後面有個空格
使用 + 進行拼接
'one '+'two'
'one two'
直接寫在後面也可以拼接
'one ''two'
'one two'

  • *複製

  • []中括號提取

#注意，偏移量不能超過字串長度
vocabulary = 'transcendental'
vocabulary[0]
't'
vocabulary[-1]
'l'
  • [start : end : step]字串分片
#：引號不可省略，其他的都可以省略
#[:] 提取全部
#[:end] 開始到end - 1
#[start:end:step]定步長擷取
#負號的使用可以帶來許多有意思的操作，比如步長為-1，那麼將會反向輸出字串
#在這裡允許偏移量超過字串長度
vocabulary = 'transcendental'

相關操作函式

  • len()獲取字串函式
  • split()分割
  • join()合併
  • replace()替換字串
  • startswith()判斷字串開始字元是否為某個字串
  • find()查詢某個字元的開始的偏移量
  • rfind()查詢某個字元的最後的偏移量
  • count()統計某個字元出現的次數
  • title()所有單詞開頭字母變大寫
  • upper()所有字母大寫
  • lower()所有字母小寫
  • swapcase()大小寫轉換
  • split()分割
#split基於分隔符分割字串，分割成為列表
#逗號為分隔符，分割program_ex 
program_ex = 'hello,world'
program_ex.split('，')
['hello','world']
  • join()合併
#與split邏輯相反
#呼叫順序：首先指定粘合用的字串，然後指定需要粘合的列表
#string.join(list)
crypto_list = "'Yeti', 'Bigfoot', 'Loch Ness Monster'"
ctypto_string = ','.join(crypto_list)
print('Found and signing book deals:',ctypto_string)
Found and signing book deals:Yeti, Bigfoot, Loch Ness Monster
  • replace()替換字串
#引數 需要被替換的子串，用於替換的子串，需要替換次數
#將三個o替換成X
crypto_list = "'Yeti', 'Bigfoot', 'Loch Ness Monster'"
crypto_list_replace = crypto_list.replace('o','X',3)
print(crypto_list_replace)
['Yeti', 'BigfXXt', 'LXch Ness Monster']

列表（list）

建立列表

  • 1.1：中括號[ ]或者list( )建立列表
empty_list = []
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']

another_empty_list = list()
  • 1.2：使用list()轉換
#字串轉換
list('cat')
['c','a','a']

#元組轉換
a_tuple = ('ready','fire','aim')
list(a_tuple)
['ready','fire','aim']
  • 1.3 split分割，參見字串中的split()
  • 1.4(高階方式)：列表推式（一種從一個或者多個迭代器快速簡潔地建立資料結構的一種方法，將迴圈和條件判斷結合，避免語法冗長）
  • 表示式：
    • [expression for item in iterable]
    • [expression for item in iterable if condition]
number_list = [number for number in range(1,6)]
number_list
[1,2,3,4,5]
a_list = [number for number in range(1,6) if number % 2 == 1]
a_list
[1,3,5]
  • 迴圈巢狀
    • 建立一個元組，其中元組第一項由迴圈1控制，第二項由迴圈2控制。
    • [(iterable1,iterable2) for item in iterable1 for item in iterable2]
    • example:
列表推導模式
rows = range(1,4)
cols = range(1,3)
cells = [(row,col) for row in rows for col in cols]
	for cell in cells:
		print(cell)
(1 1)
(1 2)
(2 1)
(2 2)
(3 1)
(3 2)

普通模式
rows = range(1,4)
cols = range(1,3)
	for row in rows:
		for col in cols:
			print(row,col)
1 1
1 2
2 1
2 2
3 1
3 2

列表的簡單操作

  • 獲取列表元素
    • 通過偏移量（offse）獲取對應位置的元素
    • 表示式：list_number[offset]
#正偏移量
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly[0]
'Monday'
weekly[1]
'Tuesday'
#負偏移量，從尾數開始計數
weekly[-1]
'Friday'
  • 列表的巢狀：列表中可以包含各類元素，也可包含其它列表。
#列表3中的元素型別包含整形，字串，陣列
list1 = ['Wednesday','Friday']
list2 = [3,'apple',4,'TV']
list3 = [list1,'helloworld',list2,8,5]
#訪問列表3中第一元素
list3[0]
['Wednesday','Friday']
#通過列表3訪問列表2中第一個元素
list3[2][1]
3
  • 修改列表元素
    • 通過偏移量(offset)修改列表元素
#使用偏移量無法更改字串中的指定字元，因為字串本身不可變。
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly[1] = 'correct'
['Monday','Tuesday','correct','Thursday','Friday']
  • 指定範圍的列表切片
#獲取子序列
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly[0:2]
['Monday','Tuesday']
#設定步長:每兩個元素提取一個
weekly[::2]
['Monday','Wednesday','Friday']
#列表逆序，同樣使用負號可以產生很有意思的事情
weekly[::-1]
['Friday','Thursday','Tuesday','Wednesday','Monday']

列表函式

  • append()

  • extend()

  • insert()

  • del()

  • remove()

  • pop()

  • index()

  • in()

  • =賦值

  • copy()

  • append():列表後追加元素

# 插入Saturday
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.append('Saturday')
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
  • extend()或者+=：列表合併，將一個列表加入到另一箇中，成為一個列表。
# 合併列表
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekend =['Saturday','Sunday']
weekly.extend(weekend)
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

weekly += weekend
weelkly
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
  • insert()
# 插入Saturday
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.insert(5,'Saturday')
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
  • del()
# 刪除Friday，del為Python語句，而不是list方法，所以不能用  .  呼叫
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
del weekly[4]
weekly
['Monday','Tuesday','Wednesday','Thursday']
  • remove()
# 刪除Friday,remove是list方法
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.remove('Friday')
weekly
['Monday','Tuesday','Wednesday','Thursday']
  • pop()
# 獲取元素後刪除，且pop()的，預設只為-1，刪除尾元素，因此pop(0)=pop(-1),可以用pop(0)獲取並刪除首元素
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.pop()
'Friday'
weekly
['Monday','Tuesday','Wednesday','Thursday']
  • index()：插入特定值的元素位置
#返回指定值的位置資訊
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekly.index('Monday')
0
  • in()：判斷存在
# 判斷Sunday是否在weekly中
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
'Sunday' in weekly
False
  • count()：統計特定值的出現次數
weekly.count('Wednesday')
  • join()
    • 字串方法的擴充，參見字串方法中的join
  • sort()和sorted()
# sort對原列表進行排序，sorted對原列表生成副本後排序，原列表內容不變
marxes = ['Groucho','Chico','Harpo']
sorted_marxes = sorted(marxes)
sorted_marxes
['Chico','Groucho','Harpo']

marxes = ['Groucho','Chico','Harpo']
marxes.sort()
marxes
['Chico','Groucho','Harpo']
  • len()
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
a = len(weekly)
print(a)
5
  • in()
# 賦值後weekly = Weekly，改變其中一個，另一個隨之改變
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
Weekly = weekly
  • copy()
# copy()
# list()
#列表分片
#用以上方法產生的新列表和元列表沒有內在聯絡，即改變其中任何一個，其它的不受影響
a = [1,2,3]
b = copy(a)
c= list(a)
d = a[:]

a[0] = '100000000000'
b = [1,2,3]
c = [1,2,3]
d = [1,2,3]

元組（tuple）

  • 元組與序列類似，也是由任意元素組成的序列，但是元組一旦建立如同字串，不可改變。

元組的建立

  • 使用()建立空元組
#建立空元組
empty_tuple = ()
()
  • 使用逗號’,'建立元組
#建立一個元素的元組，最後','不可省略
one_marx = 'martrix',
( 'martrix',)

#建立多個元素的元組，最後的','可省略
another_martx =  'martrix','array'
 ('martrix','array')
  • 元組解包（元組賦值操作）
another_martx =  'martrix','array'
a,b = another_martx
a 
'martrix'
b
'array'
元組解包的經典操作，交換變數的值
one = 'martrix'
two =  'array'
two,one = one,two
one
'array'
two
'martrix'
  • tuple建立
weekly = ['Monday','Tuesday','Wednesday','Thursday','Friday']
tuple(weekly)
('Monday','Tuesday','Wednesday','Thursday','Friday')
  • 元組的不可更改由其獨特的優點，在以後的應用中可以用到，但是一般情況下多用列表和字典。

字典（dict）

  • 字典中的元素順序無關緊要，通過不同的鍵(key)進行訪問，字典是可以改變的，和現實的字典類似。
  • 字典在其它的語言中被稱為關係型陣列，雜湊表，雜湊圖等。

字典的建立

  • 使用大括號{key:value}建立
#空字典
empty_dic = {}
#鍵值對的字典
one_dict = {"day1":study
"day2":paly
"day3":sleep
}
empty_dic
{"day1":study
"day2":paly
"day3":sleep
}
  • 使用dict()建立
#將包含雙值的子序列的序列轉換成字典,第一值為鍵，第二個值為值
one_list = [[1,'a'],[2,'b']]
dict(one_list)
{1:'a',2:'b'}
#可以將雙值的，雙字元，元組，列表化成字典。
tos = ('ab','cd','ef')
dict(tos)
{'c':'d','a':'b','e':'f'}

字典的相關操作

  • [key]儲存，訪問，新增或者修改元素
#儲存一個元素
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
   }
 d2 = d['three']
 d2
 ['three':3]
#訪問一個元素,如果不存在會報錯
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
   }
   d['one']
   123
#新增一個元素，然後修改這個元素
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
   }
#新增元素'try':55
d['try'] = '55'
d
d = {
    'one':123,
    'two':2,
    'three':3,
    'test':2
    'try':55
   }
修改元素55為5
d['try'] = '5'

字典的函式

  • update()合併字典
  • del()刪除具有指定鍵的元素
  • clear()刪除所有元素，變成空字典
  • in()判斷是否存在
  • get()獲取鍵對應元素，[key]不同是，不會報錯
  • keys()獲取所有鍵
  • values()獲取所有值
  • item()獲取所有鍵值對
  • =賦值
  • copy()複製
    用法參見list

集合（set）

  • 集合和只剩下的鍵的字典類似，鍵與鍵之間不允許重複，類似數學中的集合，主要包括並、交等運算，且集合是無序的。

集合的建立

  • 用{}大括號將一系列用逗號隔開的值包裹起來。
  • 用set函式建立
  • 將其他型別轉換成集合
#空集合
empty_set = set()
empty_set
set()
#偶數集合
even_numbers = {0,2,4,6,8}
even_numbers
{0,2,4,6,8}
#轉換字串,不包含重複的鍵
set('letters')
｛‘l’，‘e’，‘t’,'r','s'｝
#轉換列表
set(['Dasher','Dancer','Prancer','Mason-Dixon'])
{'Dasher','Dancer','Prancer','Mason-Dixon'}
#轉換元祖
set(('Monday','Tuesday','Wednesday','Thursday','Friday'))
{'Monday','Tuesday','Wednesday','Thursday','Friday'}
#轉換字典，注意只保留鍵
set({'apple':'red','flower':'blue','tree':'green'})
{'apple','flower','tree'}

集合的相關函式

  • 用in測試值是否存在
for name,contents in drinks.items():
	if 'vodka' in contents:
		print(name)

screwdriver
martini
black russin
white russin
#選擇vodka，但是不要vermouth，且不是cream
for name,contents in drinks.items():
if 'vodka' in contents and not ('vermouth' in contents or 'cream' in contents):
	print(name)
screwdriver
black russin
  • intersection() 或者& 獲取交集
drinks = ｛
	'martini' : {'vodka','vermouth'}
	'black russin' : {'vodka','kahlua'}
	'white russin' : {'cream','kahlua','vodka'}
	'manhattan' : {'rye','vermouth','bitters'}
	'screwdriver' : {'orange juice','vodka'}
｝
for name,contents in drinks.items():
	if contents & {'vermouth','orange jucice'}
		print(name)
screwdriver
martini
manhattan

for name,contents in drinks.items():
	if 'vodka' in contents and not contents & {'vermouth','cream'}:
		print(name)
screwdriver
black russin

a和b的

相關推薦

Python基礎學習！容器，列表，元組，字典與集合！（1）

本文是容器 列表知識的筆記！ 元組&列表 元組：是不可變的，值被固定元組中就不可以再進行改變！ 列表：是可變的，意味著可以隨意插入或者刪除其中的元素 函式呼叫格式： 列表名.函式名(引數)#元素的話要帶著單引號！大多是這樣！ ‘,’.join(a)這個連線函式，用法

Python中的列表，元組，字典以及集合的概念

一、列表，元組，字典以及集合的對比圖表 列表，元組，字典以及集合的對比圖表 列表 list 元組 tuple 字典 dict 集合 set 可否修改 可變 不可變 可變 可變 可否重複 可以 可以

關於python語句與列表，元組，字典等集合的題

 a.upper()把所有字母都變成大寫 a.lower() 把所有字母都變成大寫  ([(x,a.count(x)) for x in set(a)  ]) Set(a)可以去重複count（）

Python中非數字型變數：列表，元組，字典，字串的總結

列表（儲存一組資料）：list，用[]定義，資料之間用“，”分隔 定義列表： 列表名字 = [“引數1”，“引數2”……] 取值和取索引： 列表名字[索引] 索引從0開始（從前到後） 從後到前取值時：索引最後一個是-1，依次-2…… 建立一個空列表，以列表的名字加“.”，按下tab鍵，會看到

Python中列表，元組，字典，集合的區別

參考文件https://blog.csdn.net/Yeoman92/article/details/56289287 理解Python中列表，元組，字典，集合的區別 列表，元組，字典，集合的區別是python面試中最常見的一個問題。這個問題雖然很基礎，但確實能反映出面試者的基礎水平。 1.列表（Lis

Python 列表，元組，字典，集合的特點

一 列表 列表是一組任意型別的值，按照一定的順序組合而成； 通過索引來標識元素，第一個索引為0；需要注意的是索引可以是負值； 列表中元素是任意型別的，包括列表型別； 可以進行合併，刪除，索引，切片等操作； 定義列表使用中括號； 二 元組 元組是

PYTHON 列表&元組&字典&集合

列表（list） 有序性，可儲存任意型別的值 通過偏移存取，支援索引來讀取元素，第一個索引為0 ，倒數第一個索引為-1 可變性 ，支援切片、合併、刪除等操作 可通過索引來向指定位置插入元素 可通過pop()方法刪除末尾元素，pop(索引位置)來刪除指定位置元素

python 列表，元組，字典，集合

列表： 序列是Python中最基本的資料結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。 Python有6個序列的內建型別，但最常見的是列表和元組。 序列都可以進行的操作包括索引，切片，加，乘，檢查成員。 此外，Python已經內建確

Python學習之路（２）——標準資料型別續——列表，元組，字典，集合

０．Python之禪 可以通過在python直譯器中輸入import this 檢視python應該注意的一些規範與原則，如下： １．列表 元素用方括號括起，元素之間用逗號隔開,如[1,2,3,4] 三大特點： （1）異構性 列表裡想裝啥就裝啥，即：他可以包含不同種類、

列表，元組，字典，集合 練習題

大寫 strip() 練習題 lex dex art per star 空格 練習題：（字符串name = ‘ aleX‘# 1) 移除 name 變量對應的值兩邊的空格,並輸出處理結果print(name.strip())# 2) 判斷 name 變量對應的值

遍歷列表，元組，字典，集合

src alt 分享 集合 -1 logs .com 列表 ima 遍歷列表，元組，字典，集合

字串，列表，元組，字典，集合，序列通用操作

　　序列的通用操作 　　Python包含6種內建的序列：列表，元組，字串，Unicode字串，buffer物件和xrang物件。 　　所有序列型別都可以進行某些特定的操作。這些操作包括但不限於：索引(indexing)，分片(slicing)，加(adding)，乘(multiplying)，以及成員資格

列表，元組，字典，集合的同異

一.前言 一直想寫寫這四種類型的相同點，與不同點在哪裡，以及在什麼情況下應該使用哪種型別。無奈水平不夠，怕寫出來不夠深刻，所以一直拖著。今天想了想還是寫出來吧，如果以後還有新的見解或者

Python容器：列表、元組、字典、集合

文章目錄 序言 序列 字串（string） 建立字串 字串的簡單操作 相關操作函式 列表（list） 建立列表 列表的簡單操作 列表函式

Python基礎：列表、元組和字典

Python中最為常用的資料容器有列表、元組和字典。是使用Python必須掌握的基礎。本文詳細介紹列表、元組和字典，以及字典的兩種（按照key排序和按照value排序）排序方法。 一、列表 1.建立 list1 = [1,2,3,4,5,6] list2 = ['a','b','c','

Python學習之路——Python基礎之基本資料型別(列表、元組和字典)

基本資料型別 數字 字串 列表 list 元組 tuple 字典 dict 布林值 bool 列表和元組 列表：有序，元素可以被修改元組： 書寫格式：元組的一級元素不可被修改，不能被增加或者刪除，一般寫元租的時候，推薦在最後加入',' 索引：v =

Python學習之路——Python基礎之基本數據類型(列表、元組和字典)

bre mark 有序 數據 str sca 索引 更新 蘋果 基本數據類型 數字 字符串 列表 list 元組 tuple 字典 dict 布爾值 bool 列表和元組 列表：有序，元素可以被修改元組： 書寫格式：元組的一級元素不可被修改，不能被增加或者刪除，一般寫

【python學習筆記】列表、元組和字典的迭代

在python中，列表和元組的迭代是通過for....in....來完成的； >>> a=[1,2,3,4,5,6,7] >>> for index in a: ... print(index) ... 1 2 3 4 5

Python-列表、元組和字典

Python三種內建的資料結構：列表、元組、字典 一、列表 List 表示方法：[ ] list=[1,2,3,4] list[0]=1 對列表內元素可進行增、刪、改、查等操作： list.append()    按順序最後增加元素（不限型別），如果是列表，則作為一個元素增

Python筆記——基本資料結構:列表、元組及字典

一、列表 一組有序專案的集合。可變的資料型別【可進行增刪改查】 列表是以方括號“[]”包圍的資料集合，不同成員以“,”分隔。 列表中可以包含任何資料型別，也可包含另一個列表 列表可通過序號訪問其中成員 常用列表操作： list.append()追加成員，成員資料 li