Python中list（列表）、tuple（元組）、dict（字典）基本操做快速入門

最近看了一下Python的列表、字典以及元組等幾種數據類型，感受這幾種數據類型比較經常使用，順便總結了一下一些比較經常使用的用法。

1. 列表是Python中比較經常使用的數據類型，而且列表是能夠改變的，使用也很是簡單，具體操做以下：

1）如建立一個列表：

list1 = [1,2,3]
list2 = ['a','b','c']
list3 = [1,2,3,'a','b','abc']
list4 = [1,[2,3],['a','b',''c]]
#建立一個有序列表
list5 = range(10)
#建立一個二維列表
list6 = [[ 0 for col in range(10)] for row in range(10)]

2）訪問列表中的值

#!/usr/bin/env python
# -*-coding:UTF-8 -*-
list1 = [1,2,3,4,5,6]
#如取出list1列表中第二個元素的值：(注意：列表的下標是從0開始的)
print('list1列表的第二個元素的值爲：%d' % list1[1]) #若是想取出其它元素以此類推
#輸出列表中的因此元素的值
print('遍歷輸出list1全部元素的值：')
for i in list1:
    print(i)
#輸出列表中奇數項的值（即取出列表中第一、三、5...等項的值）
print('輸出list1中奇數項元素的值：')
for j in list1[::2]: #這裏使用了列表的切片以及步長
    print(j)
list2 = [1,2,[3,4,[6,7,8]]]
#取出列表list2中的值3的元素
print('取出列表list2%s中的值3的元素：' % list2)
print(list2[2][0])
'''
原理：首先看數值3在一個子列表中，而這個子列表屬於外層列表（父列表）的第三個元素，先取出含有數值3的子列表即：list2[2],因爲list2[2]仍然是一個列表，而數值3處於這個列表的第一個元素的位置，因此
咱們仍能夠按照列表的操做取出list2[2]這個子列表的第一個元素list2[2][0]，即取出了值爲3的元素。
'''
#取出列表list2中的值8的元素
print('取出列表list2%s中的值8的元素：' % list2)
print(list2[2][2][2]) #參照上邊以此類推
'''運行結果以下：
list1列表的第二項的值爲：2
遍歷輸出list1全部元素的值：
1
2
3
4
5
6
輸出list1中奇數項元素的值：
1
3
5
取出列表list2[1, 2, [3, 4, [6, 7, 8]]]中的值3的元素：
3
取出列表list2[1, 2, [3, 4, [6, 7, 8]]]中的值8的元素：
8
'''

3）增長或者修改列表的值

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
list3 = ['Python','Java','Php']
print('原列表list3爲：%s' % list3)
#給list3添加一個元素
list3.append('C#')
print('給list3添加一個元素C#：%s' % list3)
#修改列表list3的第一個值爲Python3
list3[0] = 'Python3'
print('修改列表list3的第一個元素的值爲Python3：%s' % list3)
'''運行結果以下：
原列表list3爲：['Python', 'Java', 'Php']
給list3添加一個元素C#：['Python', 'Java', 'Php', 'C#']
修改列表list3的第一個元素的值爲Python3：['Python3', 'Java', 'Php', 'C#']
'''

4）刪除列表中的元素

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
list4 = ['Python','Java','Php','Go']
print('原列表爲：%s' % list4)
#刪除值爲Php的元素
del list4[2]
print('刪除值爲Php的元素：%s' % list4)
#刪除值爲Go的元素
list4.pop()
print('刪除值爲Go的元素：%s' % list4)
'''運行結果以下:
原列表爲：['Python', 'Java', 'Php', 'Go']
刪除值爲Php的元素：['Python', 'Java', 'Go']
刪除值爲Go的元素：['Python', 'Java']
'''

5）列表的一些其它基本操做

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
list1 = [1,2,3,4,5]
list2 = ['Python','Java','Php','Go']
print('列表list1爲：%s' % list1)
print('列表list2爲：%s' % list2)
#得到列表list1的長度
l = len(list1)
print('列表list1的長度爲：%d' % l)
#合併list1和list2成爲一個新的列表list3
list3 = list1 + list2
print('合併list1和list2成爲一個新的列表：%s' % list3)
#建立一個指定長度且元素值相同的列表list4
list4 = ['Python'] * 4
print('建立一個指定長度且元素值相同的列表：%s' % list4)
#判斷元素3是否存在於列表list1中
f = 3 in list1
print('判斷元素3是否存在於列表list1中：%s' % f)
#截取列表list2中第二個元素之後的值
list5 = list2[1:]
print('截取列表list2中第二個元素之後的列表元素：%s' % list5)
#獲取列表list1中的元素的最大值
max_value = max(list1)
print('列表list1中元素的最大值爲：%d' % max_value)
#獲取列表list1中元素的最小值
min_value = min(list1)
print('列表list1中元素的最小值爲：%d' % min_value)
#將元組轉化成列表
a = (1,2,3)
list6 = list(a)
print('元組(1,2,3)轉化成的列表爲：%s' % list6)
#將字符串轉化成列表
s = 'abc'
list7 = list(s)
print("字符串'abc'轉化成的列表爲：%s" % list7)
#列表轉化成字符串：
list8 = "".join(list7)
print("列表['a','b','c']轉化成的字符串爲：%s" % list8)
#應用場景如:作一個加法運算的拼接
# expr = "+".join([1,2,3])
#結果爲：1+2+3
'''運行結果以下：
列表list1爲：[1, 2, 3, 4, 5]
列表list2爲：['Python', 'Java', 'Php', 'Go']
列表list1的長度爲：5
合併list1和list2成爲一個新的列表：[1, 2, 3, 4, 5, 'Python', 'Java', 'Php', 'Go']
建立一個指定長度且元素值相同的列表：['Python', 'Python', 'Python', 'Python']
判斷元素3是否存在於列表list1中：True
截取列表list2中第二個元素之後的列表元素：['Java', 'Php', 'Go']
列表list1中元素的最大值爲：5
列表list1中元素的最小值爲：1
元組(1,2,3)轉化成的列表爲：[1, 2, 3]
字符串'abc'轉化成的列表爲：['a', 'b', 'c']
列表['a','b','c']轉化成的字符串爲：abc
'''

6）Python列表包含的方法示例

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
#注意如下的列表操做都是對原列表進行操做
list = [3,2,4,1,5]
print('原列表list爲：%s' % list)
#在列表尾部添加新元素
list.append(6)
print('在列表尾部添加新元素6：%s' % list)
#在list列表的第2個位置插入一個新元素3
list.insert(1,3)     #注意列表的下標是從0開始
print('在list列表的第2個位置插入一個新元素3：%s' % list)
#在列表尾部追加另外一個列表的值
list1 = [1,2,3]
list.extend(list1)
print('在列表尾部追加另外一個列表%s的值：%s' % (list1,list))
#統計列表list中值爲3的元素出現的次數
count = list.count(3)
print('統計列表list中值爲3的元素出現的次數：%d' % count)
#找出列表list中第一個值3的元素的索引
index = list.index(3)
print('找出列表list中第一個值3的元素的索引：%d' % index)
#移除列表中第2個元素 #####注意：默認狀況下list.pop()是移除列表的最後一個元素
list.pop(1)           #注意list下標是從0開始
print('移除列表中第4個元素：%s' % list)
#移除列表中第一個值爲3的元素
list.remove(3)
print('移除列表中第一個值爲3的元素：%s' % list)
#對list列表進行排序
list.sort() #默認是按照ASSCII來排序的
print('對list列表進行排序：%s' % list)
#反轉列表中的元素
list.reverse()
print('反轉列表中的元素：%s' % list)
#反轉列表中的元素
list.reverse()
print('反轉後的列表爲：%s' % list)
'''運行結果以下所示：
原列表list爲：[3, 2, 4, 1, 5]
在列表尾部添加新元素6：[3, 2, 4, 1, 5, 6]
在list列表的第2個位置插入一個新元素3：[3, 3, 2, 4, 1, 5, 6]
在列表尾部追加另外一個列表[1, 2, 3]的值：[3, 3, 2, 4, 1, 5, 6, 1, 2, 3]
統計列表list中值爲3的元素出現的次數：3
找出列表list中第一個值3的元素的索引：0
移除列表中第4個元素：[3, 2, 4, 1, 5, 6, 1, 2, 3]
移除列表中第一個值爲3的元素：[2, 4, 1, 5, 6, 1, 2, 3]
對list列表進行排序：[1, 1, 2, 2, 3, 4, 5, 6]
反轉列表中的元素：[6, 5, 4, 3, 2, 2, 1, 1]
'''

7）list列表的深淺拷貝比較及原理講解

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
#list列表淺拷貝示例
import  copy
list1 = [1,2,3,[4,5,6]]
list2 = list1.copy()
print('list1的值爲：%s' % list1)
print('list2的值爲：%s' % list2)
'''運行結果爲
list1的值爲：[1, 2, 3, [4, 5, 6]]
list2的值爲：[1, 2, 3, [4, 5, 6]]
'''
#修改list2中的值
list2[0] = 3
print('list1的值爲：%s' % list1)
print('list2的值爲：%s' % list2)
'''運行結果爲：
list1的值爲：[1, 2, 3, [4, 5, 6]]
list2的值爲：[3, 2, 3, [4, 5, 6]]
咱們將list1拷貝了一份給list2，當修改list2的第一個元素值爲3的時候，list1的值並無發生改變，
這個很好理解，那麼請繼續往下邊看
'''
#繼續修改list2的值，此次修改list2子列表的值
list2[3][0] = 5
print('list1的值爲：%s' % list1)
print('list2的值爲：%s' % list2)
'''
list1的值爲：[1, 2, 3, [5, 5, 6]]
list2的值爲：[3, 2, 3, [5, 5, 6]]
 經過此次修改，咱們會驚訝的發現，咱們此次將list2的子列表的第一個元素修改成5，爲何list1的子列表中的第一個元素的值也跟着發生變化了呢？
 緣由：淺拷貝只複製（拷貝）列表的第一層，還拿上邊的爲例來講，第一次當修改list2的第一個元素時，因爲列表list1的第一個元素是一個真實的值，因此list2在拷貝的時候直接把這個值拷貝了過來，因此list2在修改這個值時，不會影響list1的值；而在list2第二次修改的時候，修改的是子列表中的值，而在list1中第四個位置存儲的並非子列表的值，而是子列表的一個引用地址，因爲淺拷貝只拷貝（複製）了一層，因此list2在拷貝的時候，是把list1中子列表的引用地址拷貝了過來，這時list1和list2中的第四個元素存放一個相同的引用地址，都指向了同一個子列表，因此當修改list1或者list2中任意一箇中的子列表的值時，另外一個列表的子列表的值也會跟着變化。
 注意：
 淺拷貝的幾種方式
 p1 = copy.copy(list1)
 p2 = list1[:] 
 p3 = list(list1)
 以上這幾種方式都屬於淺拷貝，使用的時候須要注意一點，否則會有坑。。。
'''
'''
深拷貝的實現方式以下：
list4 = copy.deepcopy(list1)
深拷貝其實就是徹底把列表徹底拷貝了一遍，修改任意一個，都不會影響另外一個列表
'''

2.元組（tuple）與列表很相似，最大的不一樣點在於元組的元素不能修改

1）建立元組

#建立一個空的元組
tup1 = ()
#建立只包含一個元素的元組
tup2 = ('a',)  #注意須要在元素後邊添加逗號
#建立一個包含多個元素的元組
tup3 = (1,2,3,'Java','Python','Php')

2）元組的基本操做

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
tup1 = (1,2,3)
tup2 = ('Python','Java','Php','C#')
#訪問元組tup2中的第一個元素
s = tup2[0]
print('訪問元組tup2中的第一個元素：%s' % s)
#遍歷輸出元組tup2中的全部元素：
print('遍歷輸出元組tup2中的全部元素：')
for i in tup2:
    print(i)
#合併tup1和tup2爲一個新的元組（即鏈接兩個元組）
tup3 = tup1 + tup2   #注意：這裏並無對元組作任何修改，而是將兩個元組合併成了一個新的元組，老的元組並無被修改。
print('合併tup1和tup2的新元組爲：' , tup3)
#刪除元組 因爲元組不能修改的特性，因此元組內的元素不容許刪除，可是咱們可使用del來刪除整個元組
del tup3
#若是將整個元組刪除就不能在訪問該元組，不然會出現not defined的異常錯誤
#計算元組tup2的長度：
l = len(tup2)
print('計算元組tup2的長度爲：%d' % l)
#判斷元素3在元組tup1是否存在：
b = 3 in tup1
print('判斷元素3在元組tup1是否存在：%s' % b)
#取出元組tup1中的最大值：
max = max(tup1)
print('元組tup1中的最大值：%d' % max)
#取出元組tup1中的最小值：
min = min(tup1)
print('元組tup1中的最小值：%d' % min)
#將列表轉換爲元組
list1 = ['a','b','c']
tup4 = tuple(list1)
print('列表list1%s轉換爲元組：%s' % (list1, tup4))
#以上爲列表的一些基本操做，主要元組是不能夠修改，例如：tup1[1] = 10這樣的操做是不合法的。
'''運行結果以下：
訪問元組tup2中的第一個元素：Python
遍歷輸出元組tup2中的全部元素：
Python
Java
Php
C#
合併tup1和tup2的新元組爲： (1, 2, 3, 'Python', 'Java', 'Php', 'C#')
計算元組tup2的長度爲：4
判斷元素3在元組tup1是否存在：True
元組tup1中的最大值：3
元組tup1中的最小值：1
列表list1['a', 'b', 'c']轉換爲元組：('a', 'b', 'c')
'''

3.Python字典（dict）使用了key-value存儲和其它語言中的map相似，格式要求爲d = {key1:value1, key2: value2}，且能夠存儲任意類型的對象，可是字典的key是不可變類型，而value能夠改變，而且只容許

同一個key出現一次（若是同一個key被賦值兩次，則後一次會覆蓋前一次的value）。

1）字典的通常定義形式以下：（注意字典dict的格式）

d1 = {'a':1, 'b':2, 'c':3}
d2 = {'北京':['昌平','朝陽','大興','東城'],'上海':['虹口','嘉定','浦東','松江']}

2）訪問字典中的值

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
d1 = {'name':'zhangsan','age':21,'addr':'beijing'}
#輸出字典d1中age的值
a = d1['age']   #或者 a2 = d1.get('age')
print('輸出字典d1中age的值：%d' % a)
#便利輸出字典中的key和value
print('將字典轉化成列表的形式遍歷輸出：')
print('d1.items()的結果爲：', d1.items())  #items()將字典裏邊的鍵/值轉化成了元組，將字典整個轉換成包含元組的列表
for key,value in d1.items():
    print(key,value)
print('直接遍歷輸出字典中的值：')
for i in d1:
    print(i,d1[i])
'''運行結果以下：
輸出字典d1中age的值：21
將字典轉化成列表的形式遍歷輸出：
d1.items()的結果爲： dict_items([('name', 'zhangsan'), ('age', 21), ('addr', 'beijing')])
name zhangsan
age 21
addr beijing
直接遍歷輸出字典中的值：
name zhangsan
age 21
addr beijing
'''

3）字典的一些其它基本操做，如修改、添加、刪除

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
d1 = {'name':'zhangsan','age':21,'addr':'beijing'}
#爲字典添加一個新的鍵值對'gender':'male'：
d1['gender'] = 'male'
print("爲字典添加一個新的鍵值對'gender':'male'後：",d1)
#修改d1中age的值爲22：
d1['age'] = 22
print('修改d1中age的值爲22：',d1)
#刪除d1中的addr
del d1['addr']
print('刪除d1中的addr：',d1)
'''
d1.clear() #可以清空字典
del d1  #是刪除字典
'''
#將兩個列表合成一個字典
list1 = ['a','b','c','d']
list2 = [1,2,3,4]
d2 = dict(zip(list1,list2))
print('將兩個列表合成一個字典：',d2)
'''運行結果以下：
爲字典添加一個新的鍵值對'gender':'male'： {'name': 'zhangsan', 'age': 21, 'addr': 'beijing', 'gender': 'male'}
修改d1中age的值爲22： {'name': 'zhangsan', 'age': 22, 'addr': 'beijing', 'gender': 'male'}
刪除d1中的addr： {'name': 'zhangsan', 'age': 22, 'gender': 'male'}
將兩個列表合成一個字典： {'a': 1, 'b': 2, 'c': 3, 'd': 4}
'''

4）字典的內置方法的簡單示例：

#!/usr/bin/env python
#-*- coding:UTF-8 -*-
d1 = {'name':'zhangsan','age':21,'addr':'beijing'}
#獲取字典d1的全部鍵(key)：
keys = d1.keys()       #以列表形式返回全部鍵的值
print('獲取字典d1的全部鍵(key)：', keys)
#獲取字典d1的全部值(value)：
values = d1.values()   #以列表形式返回全部value的值
print('獲取字典d1的全部值(values)：', values)
#對字典進行一次淺拷貝
d2 = d1.copy()      #返回字典的一個淺拷貝
print('原字典：',d1)
print('拷貝的字典：',d2)
#取出字典d1中鍵爲addr的值
addr = d1.get('addr')   #返回指定鍵的值，若是之不存在，則能夠返會指定的默認值
print('取出字典d1中鍵爲addr的值：%s' % addr)
#取出字典d1中鍵爲gender的值，若是不存在就添加
g = d1.setdefault('gender','male')   #若是字典中不存在該鍵，將會把該鍵以及指定的默認值添加進字典
print('取出字典d1中鍵爲gender的值，若是不存在就添加：',d1)
#把另外一個字典中的鍵值對跟新到字典d1中：
d3 = {'hobby':'meizi'}
d1.update(d3)       #把另個字典的鍵/值更新到d1中
print("把另外一個字典d3{'hobby':'meizi'}中的鍵值對跟新到字典d1中：", d1)
#刪除字典中鍵age所對應的值，並將value返回
v = d1.pop('age')    #刪除字典中指定的鍵以及對應的值，而且返回鍵的值
print('刪除字典中鍵age所對應的值，並將value返回：', v)
print('此時字典d1包含的項有：', d1)
#隨機刪除字典d1中的一對鍵值，並返回改鍵值對：
kv = d1.popitem()     #隨機刪除字典中的一對鍵值並將結果返回
print('隨機刪除字典d1中的一對鍵值，並返回改鍵值對：', kv)
print('此時字典d1包含的項有：', d1)
#刪除字典d1內的全部元素
d1.clear()
print('刪除字典d1內的全部元素：', d1)
#建立一個新字典
d4={}.fromkeys(('a','b'),1)   #建立一個新字典，以seq中的元素爲鍵，以val爲字典的鍵對應的初始值
print('建立一個新字典d4：', d4)
'''運行結果以下：
獲取字典d1的全部鍵(key)： dict_keys(['name', 'age', 'addr'])
獲取字典d1的全部值(values)： dict_values(['zhangsan', 21, 'beijing'])
原字典： {'name': 'zhangsan', 'age': 21, 'addr': 'beijing'}
拷貝的字典： {'name': 'zhangsan', 'age': 21, 'addr': 'beijing'}
取出字典d1中鍵爲addr的值：beijing
取出字典d1中鍵爲gender的值，若是不存在就添加： {'name': 'zhangsan', 'age': 21, 'addr': 'beijing', 'gender': 'male'}
把另外一個字典d3{'hobby':'meizi'}中的鍵值對跟新到字典d1中： {'name': 'zhangsan', 'age': 21, 'addr': 'beijing', 'gender': 'male', 'hobby': 'meizi'}
刪除字典中鍵age所對應的值，並將value返回： 21
此時字典d1包含的項有： {'name': 'zhangsan', 'addr': 'beijing', 'gender': 'male', 'hobby': 'meizi'}
隨機刪除字典d1中的一對鍵值，並返回改鍵值對： ('hobby', 'meizi')
此時字典d1包含的項有： {'name': 'zhangsan', 'addr': 'beijing', 'gender': 'male'}
刪除字典d1內的全部元素： {}
建立一個新字典d4： {'a': 1, 'b': 1}
'''