python資料類型：列表、元組、字典、集合

標籤：rate   img   集合   嵌套使用   name   move   嵌套   href   inpu   

列表

一、列表基礎 

前言：

數組：把一堆同類型的資料挨個放在一起

列表：把一堆任意類型的資料挨個放在一起（基於變數沒有類型，列表中的資料也沒有類型的）

文法：

list名=[value1,value2,value3,.....]

1、中括弧 ；2、資料間用逗號隔開;

特點：有序，資料可重複，資料類型可以不一致，可嵌套使用

樣本：

list=[1，‘22‘,"龍貓",3.14]    #各種資料類型

list=[1，‘22‘,"龍貓",3.14，[1，2，3]]  #列表嵌套列表

list1=[]       # 空列表

列表的基礎操作：

1、元素的擷取（索引、分區）

從左至右：0開始，從右至左邊：-1開始

# -*- coding:utf-8 -*-name=[1,‘a‘,‘json jk‘,3.5]msg=[11,3]print(name)       #輸出完整列表print(name[0])    #輸出資料行表第一元素print(name[-1])   #輸出資料行表最後一個元素print(name[0:2])  #輸出資料行表第一到第二個元素print(name+msg)   #串連列表print(msg*2)      #輸出資料行表2次

#輸出[1, ‘a‘, ‘json jk‘, 3.5]13.5[1, ‘a‘][1, ‘a‘, ‘json jk‘, 3.5, 11, 3][11, 3, 11, 3]

•  分區

list=[1,2,3,4,5,‘haha‘]print(list[2:4])print(list[2:])print(list[:-1])print(list[:])

#輸出
[3, 4]
[3, 4, 5]
[3, 4, 5, ‘haha‘]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, ‘haha‘]

print(list[::2]) #第三個代表步長print(list[::-1]) #步長為-1，直接反轉#輸出
[1, 3, 5][‘haha‘, 5, 4, 3, 2, 1]

 

二、列表的方法：

增（appned 、insert、extand)

• append() 追加 

list=[1,2,3,4]list.append(5)   #追加最後一個元素後面print(list)
#輸出
[1, 2, 3, 4, 5]

• insert （）插入

list1=[1,2,3]
list1.insert(2，7) #在第二個元素後面插入print(list)

#輸出[1, 2, 7, 5]

• extend（）擴充

 1 list1=[1,2]2 list2=[7,8]3 list1.extend(list2)4 list2.extend(list1)5 print(list1)6 print(list2)
#輸出  
[1, 2, 7, 8]  
[7, 8, 1, 2, 7, 8]

刪（remove、del、pop）

•  remove

    1、 指定需要刪除的內容，否則若刪除的元素不存在，程式會報錯

    2、不能指定元素的位置

>>>removelist=[1,2,3,4,5]list.remove(2)   #刪除指定內容的元素print (list) 

#輸出[1, 3, 4, 5]

• del

  指定刪除元素的索引位置(del是一個語句，不是list的方法)，刪除整列 del list

list=[1,2,77]del list[0]print (list)#輸出
[2, 77]

• pop

1、預設刪除最後一個

2、指定索引後，刪除具體位置元素

>>> poplist.pop()   #預設刪除最後一個元素 print(list)>>>list.pop(0)   #刪除第一元素print(list)#輸出[1, 3, 4][3, 4]

 改

list1=[1,4]list1[0]=2print(list1)#輸出[2, 4]

查（索引）

index() 通過元素值擷取下標值

list=[8,‘a‘,1]

print(list.index(‘a‘))

>> 1

通過下標值擷取元素

list=[8,‘a‘,1]print(list[0])>>8

清空（clear）

list=[8,‘a‘,10]print(list.clear())
#輸出
None

反轉（reverse）

排序（sort）

將使用者輸入的數從大到小排序，並輸出

x=int(input("請輸入x:"))
y=int(input("請輸入y:")) 
z=int(input("請輸入z:"))
list=[x,y,z] print(list)
list.sort() 
list.reverse()
for i in range(len(list)):    
    print(list[i])    
    i=i+1

# 輸出
請輸入x:3 
請輸入y:4 
請輸入z:1 

4
3
1

 

 三、列表常用操作符

• 比較操作符（>,<,==,!=）

list1=[133]list2=[214]print(list1>list2)#Falselist3=[123,456] #第一個元素開始比較，只要一個pk贏了，整個列表就贏了list4=[234,123]print(list1>list2)#False

• 算數運算操作符（+，*）

加號（+）代表串連，乘號（*）代表負責自身若干次

list1=[123,456]list2=[234]list3=list1+list2print(list3)#[123, 456, 234]

list1=[123,456]list2=[234]list4=list2*2print(list4)#[234, 234]

• 邏輯/關係運算 (not in、in)

>>>list1=[123,456] >>>123 in list1 True

 

元組

一、元組基礎

寫法：（小括弧、逗號）

tuple1=(1,2,3)

tuple1=1,2,3

tuple2=(1,)

標誌性符號的關鍵是逗號，不是小擴號，如下

>>>tuple1=(8)>>>print(type(tuple1))<class ‘int‘>

>>>tuple2=(8,)>>>print(type(tuple2))<class ‘tuple‘>

>>>c=1,2,3
>>>print(type(c))
<class ‘tuple‘>

元組元素的擷取（索引、切片）

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

 

二、元組的方法

元組不支援修改，所以列表中的 ：元素賦值，刪除元素，分區賦值，append，extend，insert，pop，remove，reverse，sort,進階排序任何妄圖修改元組的函數都不支援。

 

>>>tup = (1, 2, 3, 4, 5, 6)>>> tup[0] = 11  # 修改元組元素的操作是非法的Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: ‘tuple‘ object does not support item assignment>>>

1、count（）尋找某個元素出現的次數

x=(1,2,2)
print(x.count(2))
>> 2

2、index:找出某個元素的索引位置：

x=(1,2,2)

print(x.index(2))

=> 1

三、元組的常用操作符

 和列表一樣，支援算術操作（+、*），邏輯操作，成員關係操作(not in 、in）

乘法：

x=(1,2,3,4,5) 
x*3 
=>(1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)

成員關係：

x=(1,2,3,4,5) 

1 in x 
=> True 
6 in x 
=> False

 

四、BIF元組相關內建方法

1、tuple（）將可迭代對象轉換為元組

tuple(‘Hello‘)

=>(‘H‘,‘e‘,‘l‘,‘l‘,‘o‘)

2、min,max,len,sum:

x=(1,2,3,4,5) 

min(x)
=>1 

max(x)
=>5 

len(x) 
=>5

sum(x) 

=>15

 

五、Python之“可變”的tuple

前面我們看到了tuple一旦建立就不能修改。現在，我們來看一個“可變”的tuple：

>>> t = (‘a‘, ‘b‘, [‘A‘, ‘B‘])

注意到 t 有 3 個元素：‘a‘，‘b‘和一個list：[‘A‘, ‘B‘]。list作為一個整體是tuple的第3個元素。list對象可以通過 t[2] 拿到：

>>> L = t[2]

然後，我們把list的兩個元素改一改：

>>> L[0] = ‘X‘>>> L[1] = ‘Y‘

再看看tuple的內容：

>>> print t(‘a‘, ‘b‘, [‘X‘, ‘Y‘])

不是說tuple一旦定義後就不可變了嗎？怎麼現在又變了？

別急，我們先看看定義的時候tuple包含的3個元素：

當我們把list的元素‘A‘和‘B‘修改為‘X‘和‘Y‘後，tuple變為：

表面上看，tuple的元素確實變了，但其實變的不是 tuple 的元素，而是list的元素。

tuple一開始指向的list並沒有改成別的list，所以，tuple所謂的“不變”是說，tuple的每個元素，指向永遠不變。即指向‘a‘，就不能改成指向‘b‘，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的！

理解了“指向不變”後，要建立一個內容也不變的tuple怎麼做？那就必須保證tuple的每一個元素本身也不能變。

 

序列

python中有6種序列，常用的2種：列表、元組。列表和元組的區別：列表可以修改，元組不可以修改。

序列的通用操作

所有序列可以進行某些特定的操作，這些操作包含：

1、索引、分區、加、乘、成員資格（in 、not in）。

2、len（）、max（）、min（）

3、迭代

共同點：

1、都可以通過索引得到一個元素

2、從左至右0代表開始，從右至左-1代表開始

3、都可以通過切片/分區得到一個範圍內的元素的集合

4、都有很多共同的操作符（算術操作符+、*）（成員關係操作符in、not in）（比較操作符> <）

序列的內建方法【BIF】

1、list()

list()把一個可迭代對象轉換為列表

#字串轉換為列表
a="world"print (list(a))#元群組轉換為列表
c=(1,‘w‘,33)            
print(list(c))

#輸出
[‘w‘, ‘o‘, ‘r‘, ‘l‘, ‘d‘]
[1, ‘w‘, 33]

 2、tuple（）

tuple（）把一個可迭代的對象轉換為元組，和list（）一樣

3、str（）、int（）、float（）

str（）把對象轉換為字串

4、len（）

返回參數長度

5、max（）、min（）

返回序列或者參數集中最大/最小的值

確保序列或者參數集中的資料類型一致，否則會出錯

6、enumerate（）

作用：產生二元組構成的一個迭代對象，該二元組由迭代參數的索引號，以及對應的元素組成，如下：

a="we"for i in enumerate(a):    print(i)#輸出
(0, ‘w‘)(1, ‘e‘)

 

a="we"for i in enumerate(a):    print(i[1])
#輸出
w
e

 

字典dict

一、建立與訪問：

1、建立：2種方式

• 大括弧：

x={}      #空字典

x={‘a‘:1,‘b‘:2}

• dict函數：

x=dict（） #空字典

方法一：

x=dict（a=1，b=2）

>>{‘a‘: 1, ‘b‘: 2} 

方法二：

dict()函數的參數可以是一個序列，但不能多個，所以要打包成一個元組序列或者以列表

y=dict((("a",2),("b",2)))  print(y) >>{‘a‘: 1, ‘b‘: 2}

x=dict({"a":2,"3":4})print(x)>>{‘a‘: 1, ‘b‘: 2}

 

2、訪問：

1、序列是以連續的整數為索引，與此不同的是，字典以關鍵字為索引，關鍵字可以是任意不可變類型，通常用字串或數值。

2、訪問不存在的鍵會報錯

x={‘a‘:1,‘b‘:2} y=x[‘a‘]print(y)#輸出1

 

通過 key 訪問 dict 的value，只要 key 存在，dict就返回對應的value。如果key不存在，會直接報錯：KeyError。

要避免 KeyError 發生，有兩個辦法：一是先判斷一下 key 是否存在，用 in 操作符：if ‘Paul‘ in d:    print d[‘Paul‘]
如果 ‘Paul‘ 不存在，if語句判斷為False，自然不會執行 print d[‘Paul‘] ，從而避免了錯誤。二是使用dict本身提供的一個 get 方法，在Key不存在的時候，返回None：>>> print d.get(‘Bart‘)59>>> print d.get(‘Paul‘)None

3、字典特點：

1、無序 。儲存的key-value序對是沒有順序的！這和list不一樣

2、由於dict是按 key 尋找，所以，在一個dict中，key不能重複。

    鍵必須唯一，值可以取任何資料類型，但必須是不可以改變的（數字、字串、元組），不能使用列表

二、字典內建的方法

1、增

x={‘a‘:1,‘b‘:2}x["c"]=3print(x)#輸出{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

2、刪 pop() 、del() 、popitem()

pop 

x={‘a‘:1,‘b‘:2}print(x.pop("a"))#輸出1

popitem()隨機刪除一個

del（）

x={‘a‘:1,‘b‘:2}del x["a"]print (x)#輸出{‘b‘: 2}

3、改 

x={‘a‘:1,‘b‘:2}x["b"]=3print (x)#輸出{‘a‘: 1, ‘b‘: 3}

4、查

x={‘a‘:1,‘b‘:2}

（1）x[‘a‘]  不建議使用，若無該值會報錯

 (2) x.get(‘a‘)  若無該鍵，則返回none，不會報錯

5、keys（）、values（）、items（）：返回字典中的鍵、返回字典中的所有值、返回字典中的所有索引值對

6、update（）

合并2個字典，無交集的就新增，有交集（相同的鍵）就修改成更新的字典

x={‘a‘:1,‘b‘:2}y={‘a‘:3,‘c‘:4}x.update(y)print (x)#輸出
{‘a‘: 3, ‘b‘: 2, ‘c‘: 4}

7、迴圈遍曆

取鍵

x={‘a‘:1,‘b‘:2}
for i in x:    print (i)

#輸出

a

  b

取值

x={‘a‘:1,‘b‘:2}for i in x:    print (x[i])
#輸出
1
2

取索引值

x={‘a‘:1,‘b‘:2}for i in x:    print (i,x[i])
#輸出

a 1

b 2

 

集合
1、建立集合：

法一：把元素用{}括起來，如：
     num={1,"hello","你好"}
法二：set（）函數，如：

num=set([1,"hello","你好"])print(num)
>>>{1, ‘hello‘, ‘你好‘}

 

2、集合的特點
集合的作用，兩個字：唯一，如下：

num={1,2,2,3,3,4}print(num)>>>{1, 2, 3, 4}

集合無序，所以無法通過索引擷取值，否則報錯。

python資料類型：列表、元組、字典、集合