python基礎入門語法和變量類型（二）

列表

列表是 Python 中使用最頻繁的數據類型，它能夠完成大多數集合類的數據結構實現，能夠包含不一樣類型的元素，包括數字、字符串，甚至列表（也就是所謂的嵌套）。

和字符串同樣，能夠經過索引值或者切片(截取)進行訪問元素，索引也是從 0 開始，而若是是倒序，則是從 -1 開始。列表截取的示意圖以下所示：

 

另外，還能夠添加第三個參數做爲步長：

 

一樣，列表也有不少內置的方法，這裏介紹一些常見的方法：

• len(list)：返回列表的長度
• append(obj) / insert(index, obj) / extend(seq)：增長元素的幾個方法
• pop() / remove(obj) / del list[index] / clear()：刪除元素
• reverse() / reversed：反轉列表
• sort() / sorted(list)：對列表排序，注意前者會修改列表內容，後者返回一個新的列表對象，不改變原始列表
• index()：查找給定元素第一次出現的索引位置

初始化列表的代碼示例以下：

# 建立空列表，兩種方法

list1 = list()

list2 = []# 初始化帶有數據

list3 = [1, 2, 3]

list4 = ['a', 2, 'nb', [1, 3, 4]]

 

print('list1:', list1)

print('list2:', list2)

print('list3:', list3)

print('list4:', list4)

print('len(list4): ', len(list4))  

添加元素的代碼示例以下：

# 末尾添加元素

list1.append('abc')

print('list1:', list1)# 末尾添加另外一個列表，併合併爲一個列表

list1.extend(list3)

print('list1.extend(list3), list1:', list1)

list1.extend((1, 3))

print('list1.extend((1,3)), list1:', list1)# 經過 += 添加元素

list2 += [1, 2, 3]

print('list2:', list2)

list2 += list4

print('list2:', list2)# 在指定位置添加元素,原始位置元素右移一位

list3.insert(0, 'a')

print('list3:', list3)# 末尾位置添加，原來末尾元素依然保持在末尾

list3.insert(-1, 'b')

print('list3:', list3)  

刪除元素的代碼示例以下：

# del 刪除指定位置元素del list3[-1]

print('del list3[-1], list3:', list3)# pop 刪除元素

pop_el = list3.pop()

print('list3:', list3)

print('pop element:', pop_el)# pop 刪除指定位置元素

pop_el2 = list3.pop(0)

print('list3:', list3)

print('pop element:', pop_el2)# remove 根據值刪除元素

list3.remove(1)

print('list3:', list3)# clear 清空列表

list3.clear()

print('clear list3:', list3)  

查找元素和修改、訪問元素的代碼示例以下：

# index 根據數值查詢索引

ind = list1.index(3)

print('list1.index(3)，index=', ind)# 訪問列表第一個元素

print('list1[0]: ', list1[0])# 訪問列表最後一個元素

print('list1[-1]: ', list1[-1])# 訪問第一個到第三個元素

print('list1[:3]: ', list1[:3])# 訪問第一個到第三個元素,步長爲2

print('list1[:3:2]: ', list1[:3:2])# 複製列表

new_list = list1[:]

print('copy list1, new_list:', new_list)  

排序的代碼示例以下：

list5 = [3, 1, 4, 2, 5]

print('list5:', list5)# use sorted

list6 = sorted(list5)

print('list6=sorted(list5), list5={}, list6={}'.format(list5, list6))# use list.sort()

list5.sort()

print('list5.sort(), list5: ', list5)  

sorted() 都不會改變列表自己的順序，只是對列表臨時排序，並返回一個新的列表對象；

相反，列表自己的 sort() 會永久性改變列表自己的順序。

另外，若是列表元素不是單純的數值類型，如整數或者浮點數，而是字符串、列表、字典或者元組，那麼還能夠自定義排序規則，這也就是定義中最後兩行，例子以下：

# 列表元素也是列表

list8 = [[4, 3], [5, 2], [1, 1]]

list9 = sorted(list8)

print('list9 = sorted(list8), list9=', list9)# sorted by the second element

list10 = sorted(list8, key=lambda x: x[1])

print('list10 = sorted(list8, key=lambda x:x[1]), list10=', list10)

list11 = sorted(list8, key=lambda x: (x[1], x[0]))

print('list11 = sorted(list8, key=lambda x:(x[1],x[0])), list11=', list11)# 列表元素是字符串

list_str = ['abc', 'pat', 'cda', 'nba']

list_str_1 = sorted(list_str)

print('list_str_1 = sorted(list_str), list_str_1=', list_str_1)# 根據第二個元素排列

list_str_2 = sorted(list_str, key=lambda x: x[1])

print('list_str_2 = sorted(list_str, key=lambda x: x[1]), list_str_2=', list_str_2)# 先根據第三個元素，再根據第一個元素排列

list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0]))

print('list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])), list_str_3=', list_str_3)  

反轉列表的代碼示例以下：

# 反轉列表

list5.reverse()

print('list5.reverse(), list5: ', list5)

list7 = reversed(list5)

print('list7=reversed(list5), list5={}, list7={}'.format(list5, list7))#for val in list7:#    print(val)# 注意不能同時兩次

list7_val = [val for val in list7]

print('採用列表推導式, list7_val=', list7_val)

list8 = list5[::-1]

print('list5 = {}\nlist_reversed = list5[::-1], list_reversed = {}'.format(list5, list_reversed))  

reverse() 方法會永久改變列表自己，而 reversed() 不會改變列表對象，它返回的是一個迭代對象，如例子輸出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要獲取其排序後的結果，須要經過 for 循環，或者列表推導式，但須要注意，它僅僅在第一次遍歷時候返回數值。

以及，一個小小的技巧，利用切片實現反轉，即 <list> = <list>[::-1]。

元組

元組和列表比較類似，不一樣之處是元組不能修改，而後元組是寫在小括號 () 裏的。

元組也能夠包含不一樣的元素類型。簡單的代碼示例以下：

t1 = tuple()

t2 = ()

t3 = (1, 2, '2', [1, 2], 5)# 建立一個元素的元祖

t4 = (7, )

t5 = (2)

print('建立兩個空元組：t1={}, t2={}'.format(t1, t2))

print('包含不一樣元素類型的元組：t3={}'.format(t3))

print('包含一個元素的元祖: t4=(7, )={}, t5=(2)={}'.format(t4, t5))

print('type(t4)={}, type(t5)={}'.format(type(t4), type(t5)))

print('輸出元組的第一個元素：{}'.format(t3[0]))

print('輸出元組的第二個到第四個元素：{}'.format(t3[1:4]))

print('輸出元祖的最後一個元素: {}'.format(t3[-1]))

print('輸出元祖兩次: {}'.format(t3 * 2))

print('鏈接元祖: {}'.format(t3 + t4))  

元祖和字符串也是相似，索引從 0 開始，-1 是末尾開始的位置，能夠將字符串看做一種特殊的元組。

此外，從上述代碼示例能夠看到有個特殊的例子，建立一個元素的時候，必須在元素後面添加逗號，即以下所示:

tup1 = (2,) # 輸出爲 (2,)

tup2 = (2)  # 輸出是 2

print('type(tup1)={}'.format(type(tup1))) # 輸出是 <class 'tuple'>

print('type(tup2)={}'.format(type(tup2))) # 輸出是 <class 'int'>  

還能夠建立一個二維元組，代碼例子以下：

# 建立一個二維元組

tups = (1, 3, 4), ('1', 'abc')

print('二維元組: {}'.format(tups)) # 二維元組: ((1, 3, 4), ('1', 'abc'))  

而後對於函數的返回值，若是返回多個，實際上就是返回一個元組，代碼例子以下：

def print_tup():

    return 1, '2'

 

 

res = print_tup()

print('type(res)={}, res={}'.format(type(res), res)) # type(res)=<class 'tuple'>, res=(1, '2')  

元組不可修改，但若是元素可修改，那能夠修改該元素內容，代碼例子以下所示：

tup11 = (1, [1, 3], '2')

print('tup1={}'.format(tup11)) # tup1=(1, [1, 3], '2')

tup11[1].append('123')

print('修改tup11[1]後，tup11={}'.format(tup11)) # 修改tup11[1]後，tup11=(1, [1, 3, '123'], '2')  

由於元組不可修改，因此僅有如下兩個方法：

• count(): 計算某個元素出現的次數
• index(): 尋找某個元素第一次出現的索引位置

代碼例子：

# count()

print('tup11.count(1)={}'.format(tup11.count(1)))# index()

print('tup11.index(\'2\')={}'.format(tup11.index('2')))  

字典

字典也是 Python 中很是經常使用的數據類型，具備如下特色：

• 它是一種映射類型，用 {} 標識，是無序的 鍵(key): 值(value) 的集合；
• 鍵(key) 必須使用不可變類型；
• 同一個字典中，鍵必須是惟一的；

建立字典的代碼示例以下，總共有三種方法：

# {} 形式

dic1 = {'name': 'python', 'age': 20}# 內置方法 dict()

dic2 = dict(name='p', age=3)# 字典推導式

dic3 = {x: x**2 for x in {2, 4, 6}}

print('dic1={}'.format(dic1)) # dic1={'age': 20, 'name': 'python'}

print('dic2={}'.format(dic2)) # dic2={'age': 3, 'name': 'p'}

print('dic3={}'.format(dic3)) # dic3={2: 4, 4: 16, 6: 36}  

常見的三個內置方法，keys(), values(), items() 分別表示鍵、值、對，例子以下：

print('keys()方法，dic1.keys()={}'.format(dic1.keys()))print('values()方法, dic1.values()={}'.format(dic1.values()))print('items()方法, dic1.items()={}'.format(dic1.items()))  

其餘對字典的操做，包括增刪查改，以下所示：

# 修改和訪問

dic1['age'] = 33

dic1.setdefault('sex', 'male')

print('dic1={}'.format(dic1))# get() 訪問某個鍵

print('dic1.get(\'age\', 11)={}'.format(dic1.get('age', 11)))

print('訪問某個不存在的鍵，dic1.get(\'score\', 100)={}'.format(dic1.get('score', 100)))# 刪除del dic1['sex']

print('del dic1[\'sex\'], dic1={}'.format(dic1))

dic1.pop('age')

print('dic1.pop(\'age\'), dic1={}'.format(dic1))# 清空

dic1.clear()

print('dic1.clear(), dic1={}'.format(dic1))# 合併兩個字典

print('合併 dic2 和 dic3 前, dic2={}, dic3={}'.format(dic2, dic3))

dic2.update(dic3)

print('合併後，dic2={}'.format(dic2))

# 遍歷字典

dic4 = {'a': 1, 'b': 2}for key, val in dic4.items():

    print('{}: {}'.format(key, val))# 不須要採用 keys()for key in dic4:

    print('{}: {}'.format(key, dic4[key]))  

最後，由於字典的鍵必須是不可改變的數據類型，那麼如何快速判斷一個數據類型是否能夠更改呢？有如下兩種方法：

• id()：判斷變量更改先後的 id，若是同樣表示能夠更改，不同表示不可更改。
• hash()：若是不報錯，表示能夠被哈希，就表示不可更改；不然就是能夠更改。

首先看下 id() 方法，在一個整型變量上的使用結果：

i = 2

print('i id value=', id(i))

i += 3

print('i id value=', id(i))   

輸出結果，更改先後 id 是更改了，代表整型變量是不可更改的。

i id value= 1758265872

i id value= 1758265968  

而後在列表變量上進行一樣的操做：

l1 = [1, 3]

print('l1 id value=', id(l1))

l1.append(4)

print('l1 id value=', id(l1))  

輸出結果，id 並無改變，說明列表是能夠更改的。

l1 id value= 1610679318408

l1 id value= 1610679318408  

而後就是採用 hash() 的代碼例子：

# hash

s = 'abc'

print('s hash value: ', hash(s))

l2 = ['321', 1]

print('l2 hash value: ', hash(l2))   

輸出結果以下，對於字符串成功輸出哈希值，而列表則報錯 TypeError: unhashable type: 'list'，這也說明了字符串不可更改，而列表能夠更改。

s hash value:  1106005493183980421

TypeError: unhashable type: 'list'  

集合

集合是一個無序的不重複元素序列，採用大括號 {} 或者 set() 建立，但空集合必須使用 set() ，由於 {} 建立的是空字典。

建立的代碼示例以下：

# 建立集合

s1 = {'a', 'b', 'c'}

s2 = set()

s3 = set('abc')

print('s1={}'.format(s1)) # s1={'b', 'a', 'c'}

print('s2={}'.format(s2)) # s2=set()

print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}  

注意上述輸出的時候，每次運行順序均可能不一樣，這是集合的無序性的緣由。

利用集合能夠去除重複的元素，以下所示：

s4 = set('good')

print('s4={}'.format(s4)) # s4={'g', 'o', 'd'}  

集合也能夠進行增長和刪除元素的操做，代碼以下所示：

# 增長元素，add() 和 update()

s1.add('dd')

print('s1.add(\'dd\'), s1={}'.format(s1)) # s1.add('dd'), s1={'dd', 'b', 'a', 'c'}

s1.update('o')

print('添加一個元素，s1={}'.format(s1)) # 添加一個元素，s1={'dd', 'o', 'b', 'a', 'c'}

s1.update(['n', 1])

print('添加多個元素, s1={}'.format(s1)) # 添加多個元素, s1={1, 'o', 'n', 'a', 'dd', 'b', 'c'}

s1.update([12, 33], {'ab', 'cd'})

print('添加列表和集合, s1={}'.format(s1)) # 添加列表和集合, s1={1, 33, 'o', 'n', 'a', 12, 'ab', 'dd', 'cd', 'b', 'c'}

# 刪除元素, pop(), remove(), clear()

print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}

s3.pop()

print('隨機刪除元素, s3={}'.format(s3)) # 隨機刪除元素, s3={'a', 'c'}

s3.clear()

print('清空全部元素, s3={}'.format(s3)) # 清空全部元素, s3=set()

s1.remove('a')

print('刪除指定元素,s1={}'.format(s1)) # 刪除指定元素,s1={1, 33, 'o', 'n', 12, 'ab', 'dd', 'cd', 'b', 'c'}  

此外，還有專門的集合操做，包括求取兩個集合的並集、交集

# 判斷是否子集, issubset()

a = set('abc')

b = set('bc')

c = set('cd')

print('b是否a的子集:', b.issubset(a)) # b是否a的子集: True

print('c是否a的子集:', c.issubset(a)) # c是否a的子集: False

# 並集操做，union() 或者 |

print('a 和 c 的並集:', a.union(c)) # a 和 c 的並集: {'c', 'b', 'a', 'd'}

print('a 和 c 的並集:', a | c) # a 和 c 的並集: {'c', 'b', 'a', 'd'}

# 交集操做，intersection() 或者 &

print('a 和 c 的交集:', a.intersection(c)) # a 和 c 的交集: {'c'}

print('a 和 c 的交集:', a & c) # a 和 c 的交集: {'c'}

# 差集操做，difference() 或者 - ，即只存在一個集合的元素

print('只在a中的元素:', a.difference(c)) # 只在a中的元素:: {'b', 'a'}

print('只在a中的元素:', a - c) # 只在a中的元素:: {'b', 'a'}

# 對稱差集, symmetric_difference() 或者 ^, 求取只存在其中一個集合的全部元素

print('對稱差集:', a.symmetric_difference(c)) # 對稱差集: {'a', 'd', 'b'}

print('對稱差集:', a ^ c) # 對稱差集: {'a', 'd', 'b'}  

數據類型的轉換

有時候咱們須要對數據類型進行轉換，好比列表變成字符串等，這種轉換通常只須要將數據類型做爲函數名便可。下面列舉了這些轉換函數：

int(x, [,base])：將 x 轉換爲整數，base 表示進制，默認是十進制

float(x)：將 x 轉換爲一個浮點數

complex(x, [,imag])：建立一個複數, imag 表示虛部的數值，默認是0

str(x)：將對象 x 轉換爲字符串

repr(x)： 將對象 x 轉換爲表達式字符串

eval(str)： 用來計算在字符串中的有效 Python 表達式,並返回一個對象

tuple(s)： 將序列 s 轉換爲一個元組

list(s)： 將序列 s 轉換爲一個列表

set(s)：轉換爲可變集合

dict(d)： 建立一個字典。d 必須是一個序列 (key,value)元組

frozenset(s)： 轉換爲不可變集合

chr(x)：將一個整數轉換爲一個字符

ord(x)：將一個字符轉換爲它的整數值

hex(x)：將一個整數轉換爲一個十六進制字符串

oct(x)：將一個整數轉換爲一個八進制字符串