python 列表操作方法詳解

　　列表是Python中最基本的數據結構，列表是最常用的Python數據類型，列表是一個數據的集合，集合內可以放任何數據類型，可對集合方便的增刪改查操作。Python已經內置確定序列的長度以及確定最大和最小的元素的方法

序號	函數	描述
1	list.append(self,p_object)	給列表后面追加新的對象
2	list.clear(self)	清空列表中的元素
3	list.copy(self)	淺復制列表
4	list.count(self,value)	統計某個元素在列表中出現的次數
5	list.extend(self,iterable)	在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）
6	list.index(self, value, start=None, stop=None)	從列表中找出某個值第一個匹配項的索引位置
7	list.insert(self,index,start=None,stop=None)	將對象插入列表
8	list.pop(self,index=None)	移除列表中的一個元素（默認最后一個），並返回該元素的值
9	list.remove(self,value)	移除列表中某個值的第一個匹配項，從左找到第一個指定元素
10	list.reverse(self,value)	反向列表中的元素
11	list.sort(self,key=None,reverse=False)	對原列表進行排序

 

一，List list()方法

　　list()方法將元組轉換為列表

　　注意：元祖與列表是非常相似的，區別在於元組的元素值不能修改，元祖是放在括號中，列表是放在方括號里面的。

a_tuple = ('123','abc',123)
a_list = list(a_tuple)
print(a_tuple)
print(a_list)
結果：
('123', 'abc', 123)
['123', 'abc', 123]

二，創建一個列表

　　只要把逗號分隔的不同的數據項使用方括號括起來即可。如下：

a_list = [1,2,3,4,5,6]
b_list = ['a','b','c','d']
c_list = ['a','b','c',1,2,3,4]

三，訪問列表中的值

　　與字符串的索引一樣，列表索引從0開始。列表可以進行截取、組合等。使用下標索引來訪問列表中的值，同樣你也可以使用方括號的形式截取字符，如下所示：

a_list = [1,2,3,4,5,6]
b_list = ['a','b','c','d']
c_list = ['a','b','c',1,2,3,4]
print(a_list[0])
print(b_list[1:3])
print(c_list[:])
結果：
1
['b', 'c']
['a', 'b', 'c', 1, 2, 3, 4]

四，更新列表

　　可以對列表的數據項進行修改或更新，你也可以使用append()方法來添加列表項，如下所示：

a_list = [1,2,3,4,5,6]
b_list = ['a','b','c','d']
c_list = ['a','b','c',1,2,3,4]
a_list[0] = 123
print(a_list)
b_list.append("efg")
print(b_list)
結果：
[123, 2, 3, 4, 5, 6]
['a', 'b', 'c', 'd', 'efg']

五，刪除列表元素

　　1，可以使用 del 語句來刪除列表的的元素，

　　2，可以使用pop（）移除某元素並返回該元素，

　　3，使用remove（）刪除從左找到的第一個指定元素，如下實例：

a_list = [1,2,3,4,5,6]
b_list = ['a','b','c','d']
c_list = ['a','b','c',1,2,3,4，1]
del a_list[2]
print(a_list)
b = b_list.pop()
print(b)
c = c_list.pop(2)  #也可以刪除指定元素，並返回
print(c)
d = c_list.remove(1)
print(c_list)
結果：
[1, 2, 4, 5, 6]
d
c
['a','b','c',2,3,4，1]

　　

 

六，列表腳本操作符

　　列表對 + 和 * 的操作符與字符串相似。+ 號用於組合列表，* 號用於重復列表。

Python 表達式	結果	描述
len([1, 2, 3])	3	長度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	組合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重復
3 in [1, 2, 3]	True	元素是否存在於列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

 

七，列表操作函數

　　　　1、cmp(list1, list2)：比較兩個列表的元素 
　　　　2、len(list)：列表元素個數 
　　　　3、max(list)：返回列表元素最大值 
　　　　4、min(list)：返回列表元素最小值 
　　　　5、list(seq)：將元組轉換為列表

八，列表排序

　　注意排序優先級：數字>大寫字母>小寫字母>符號>中文

　　1，永久性排序：sort()

　　2，臨時性排序：sorted()

　　3，反轉排序：reverse()

l1 = ["排序","?","123","w","W"]
l2 = ['1','2','3']
a = l1.sort()      #永久性排序，就是這個列表就變了
print(l1)
b =sorted(l2)    #臨時性排序，就是可以賦值某個變量
print(b)
c = l1.reverse()
print(l1)
結果：
['123', '?', 'W', 'w', '排序']
['1', '2', '3']
['排序', 'w', 'W', '?', '123']

九，遍歷列表

　　除了一般的遍歷，還可以遍歷切片列表

list=['1','2','3']
for value in list:#末尾加上冒號
    print(value)#每次循環都把list列表中的值賦給value,賦值從索引號0開始#循環的語句需要縮進

結果：
1
2
3


list=['1','2','3','4','5','6','7']
for value in list[3:]:#遍歷索引3之后的數值
    print(value)

結果：
4
5
6
7

十，創建數值列表

　　1，使用range()函數生成一系列數值

　　2，遍歷range()函數生成的數值

value=list(range(0,6))#range()生成0~6的數值,list()函數把數值轉換成列表
print(value)
結果：
[0, 1, 2, 3, 4, 5]

for value in range(0,6):#range(0,6)順序生成從0到5的數值
    print(value)
結果：
0
1
2
3
4
5

>>> range(1,5)#代表從1到5(不包含5)----------------[1, 2, 3, 4]
>>> range(1,5,2) #代表從1到5，每次加2(不包含5)-----[1, 3]
>>> range(5) #代表從0到5(不包含5)-----------------[0, 1, 2, 3, 4]

　　

十一，復制列表

　　1，復制整個列表

　　2，復制切片列表

list=['1','2','3','4','5']
list_2=list[:]#從起始索引到末尾索引
print(list_2)
結果：
['1', '2', '3', '4', '5']

list=['1','2','3','4','5']
list_2=list[:]#從起始索引到索引3
print(list_2)#輸出['1','2','3']
結果：
['1', '2', '3', '4', '5']

十二，列表切片

切片操作（slice）可以從一個字符串中獲取子字符串（字符串的一部分）。我們使用一對方括號、起始偏移量start、終止偏移量end 以及可選的步長step 來定義一個分片。

 

格式： [start:end:step]

• • [:] 提取從開頭（默認位置0）到結尾（默認位置-1）的整個字符串
• • [start:] 從start 提取到結尾
• • [:end] 從開頭提取到end - 1
• • [start:end] 從start 提取到end - 1
• • [start:end:step] 從start 提取到end - 1，每step 個字符提取一個
• • 左側第一個字符的位置/偏移量為0，右側最后一個字符的位置/偏移量為-1

list = [1, 2, 3, 4, 5, 6, 7]
>>> list[0:] #列出索引0以后的---------[1, 2, 3, 4, 5, 6, 7]
>>> list[1:] #列出索引1以后的---------[2, 3, 4, 5, 6, 7]
>>> list[:-1] #列出索引-1之前的-------[1, 2, 3, 4, 5, 6]
>>> list[1:3] #列出索引1到3之間的-----[2]


#形成reverse函數的效果:
>>> list[::-1]#[7, 6, 5, 4, 3, 2, 1]
>>> list[::-2]#[7, 5, 3, 1]


>>> range(1,5)#代表從1到5(不包含5)----------------[1, 2, 3, 4]
>>> range(1,5,2) #代表從1到5，每次加2(不包含5)-----[1, 3]
>>> range(5) #代表從0到5(不包含5)-----------------[0, 1, 2, 3, 4]

十三，tuple,dict,list之間的轉換

　　直接聲明的list和tuple無法通過dict()轉換成dict類型

　　直接聲明的dict可以通過tuple()和list()分別轉換成tuple和list類型（結果只包含了keys），可是此時卻能通過dict()反轉回原來的dict類型

13-1、字典

dict = {'name': 'Zara', 'age': 7}
#字典轉為字符串
str(dict)
#字典可以轉為元組
tuple(dict)
#字典可以轉為元組
tuple(dict.values())
#字典轉為列表
list(dict)
#字典轉為列表
dict.values

13-2、元組

tup=(1, 2, 3, 4, 5,6,7,8)
#元組轉為字符串
tup.__str__()
#元組轉為列表
list(tup)
#元組不可以轉為字典

13-3、列表

nums=[1, 3, 5, 7, 9, 11, 13];
#列表轉為字符串
str(nums)
#列表轉為元組
tuple(nums)
#列表不可以轉為字典

13-4、字符串

str="(1,2,3)"
#字符串轉為元組
tuple(eval(str))
#字符串轉為列表
list(eval("(1,2,3)"))
#字符串轉為字典
str1="{'name':'ljq', 'age':24}"
eval(str1)

十四，列表的練習

寫代碼，要求實現下面每一個功能

　　li=['alex','eric','rain']

　　1，計算列表長度並輸出

　　2，列表中追加元素“servn"，並輸出添加后的列表

　　3，請在列表的第一個位置插入元素‘tony’，並輸出添加后的列表

　　4，請修改列表位置元素‘kelly’，並輸出修改后的列表

　　5，請在列表刪除元素‘eric’，並輸出刪除后的列表

　　6，請刪除列表中的第2個元素，並輸出刪除后的元素的值和刪除元素后的列表

　　7，請刪除列表中的第三個元素，並輸出刪除后的列表

　　8，請刪除列表的第2到4個元素，並輸出刪除元素后的列表

　　9，請用for len range輸出列表的索引

　　10，請使用enumrate輸出列表元素和序號

　　11，請使用for循環輸出列表中的所有元素

 

# li = ['alex','eric','rain']
# 1,計算列表長度並輸出
# print(len(li))
# 列表中追加元素“seven”，並輸出添加后的列表
# li.append('seven')
# print(li)
# 請在列表的第1個位置插入元素“Tony”，並輸出添加后的列表
# li.insert(1,'tony')
# print(li)
#請修改列表第2個位置的元素為“Kelly”，並輸出修改后的列表
# li[1] ='kelly'
# print(li)
# 請刪除列表中的元素“eric”，並輸出修改后的列表
# a =li.pop(2)
# print(li)
# li.remove('eric')
# print(li)
# 請刪除列表中的第2個元素，並輸出刪除元素后的列表
# b =li.pop(1)
# print(b)
# print(li)
# 請刪除列表中的第2至4個元素，並輸出刪除元素后的列表
# c = li[2:4]
# d = set(li)-set(c)
# # print(list(d))
# del li[1:4]
# print(li)
# 請將列表所有的元素反轉，並輸出反轉后的列表
# e = li.reverse()
# print(li)
# 請使用for、len、range輸出列表的索引
# for i in range(len(li)):
#     print(i)
# 請使用enumrate輸出列表元素和序號（序號從100開始）
# for index in enumerate(li):
#     print(index)
# for index,i in enumerate(li,100):
#     print(index,i)
# for i in li:
#     print(i)

十五，寫代碼，有如下元組，請按照功能要求實現每一個功能

　　tu = ('alex','eric,'rain')

　　1，計算元組的長度並輸出

　　2，獲取元祖的第二個元素，並輸出

　　3，獲取元祖的第1-2個元素，並輸出

　　4，請用for輸出元祖的元素

　　5，請使用for,len,range輸出元組的索引

　　6，請使用enumerate輸出元組元素和序號，（從10開始）

tu = ('alex','eric','rain')
# 　　1，計算元組的長度並輸出
print(len(tu))
# 　　2，獲取元祖的第二個元素，並輸出
print(tu[1])
# 　　3，獲取元祖的第1-2個元素，並輸出
print(tu[0:2])
# 　　4，請用for輸出元祖的元素
for i in tu:
    print(i)
# 　　5，請使用for,len,range輸出元組的索引
for i in range(len(tu)):
    print(i)
# 　　6，請使用enumerate輸出元組元素和序號，（從10開始）
for index,i in enumerate(tu,10):
    print(index,i)

　　

十六，list中的append和extend的區別

• list.append(object) 向列表中添加一個對象object
• list.extend(sequence) 把一個序列seq的內容添加到列表中

 舉例如下：

使用append的時候，是將new_media看作一個對象，整體打包添加到music_media對象中。

music_media = ['compact disc', '8-track tape', 'long playing record']
new_media = ['DVD Audio disc', 'Super Audio CD']
music_media.append(new_media)
print music_media
>>>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]

　　

使用extend的時候，是將new_media看作一個序列，將這個序列和music_media序列合並，並放在其后面。

music_media = ['compact disc', '8-track tape', 'long playing record']
new_media = ['DVD Audio disc', 'Super Audio CD']
music_media.extend(new_media)
print music_media
>>>['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']

　　

17 Python 統計列表中的重復項出現的次數的方法

　　對一個列表，比如[1,2,2,2,2,3,3,3,4,4,4,4]，現在我們需要統計這個列表里的重復項，並且重復了幾次也要統計出來。

　　方法1：

mylist = [1,2,2,2,2,3,3,3,4,4,4,4]
#myset是另外一個列表，里面的內容是mylist里面的無重復項
myset = set(mylist)  

for item in myset:
   res = mylist.count(item) 
   print("the %d has found %d" %(item,mylist.count(item)))

　　方法2：

List=[1,2,2,2,2,3,3,3,4,4,4,4]
a = {}
for i in List:
  if List.count(i)>1:
    a[i] = List.count(i)
print (a)

　　利用字典的特性來實現。

　　方法3：

>>> from collections import Counter
>>> Counter([1,2,2,2,2,3,3,3,4,4,4,4])
Counter({1: 5, 2: 3, 3: 2})

　　方法4：

l=[1,4,2,4,2,2,5,2,6,3,3,6,3,6,6,3,3,3,7,8,9,8,7,0,7,1,2,4,7,8,9]
 
count_times = []
for i in l :
  count_times.append(l.count(i))
 
m = max(count_times)
n = l.index(m)
 
print (l[n])

　　其實現原理就是把列表中的每一個數出現的次數在其對應的位置記錄下來，然后用max求出出現次數最多的位置。只用這段代碼的話，有一個缺點，如果有多個結果，最后的現實的結果只是出現在最左邊的那一個，不過解決方法也很簡單。

十八 sort與sorted函數排序的區別

　　Python list內置sort() 方法用來排序，也可以使用Python內置的全局sorted() 方法對可迭代的序列排序生成新的序列。

sort()函數

　　首先看一個例子：

lis1 = [3,5,6,8,9]
lis1.sort()
print(lis1)

　　使用sort()方法對list排序會修改list本身,不會返回新list，通常此方法不如sorted()方便，但是如果你不需要保留原來的list，此方法將更有效sort()。sort()方法不能對字典dict進行排序。

sorted() 函數

 　　再看一個例子：

lis1 = [3,5,6,8,9,1]
res = sorted(lis1)
print(lis1)
print(res)
# [3, 5, 6, 8, 9, 1]
# [1, 3, 5, 6, 8, 9]

　　sorted()不會改變原來的list，而是會返回一個新的已經排序好的list。

 

 

集合操作方法詳解，請看下面博客：http://www.cnblogs.com/wj-1314/p/8423273.html

字典操作方法詳解，請看下面博客：http://www.cnblogs.com/wj-1314/p/8421724.html

字符串操作方法詳解，請看下面博客：http://www.cnblogs.com/wj-1314/p/8419009.html