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	迭代

 

七，列表操做函數

　　　　一、cmp(list1, list2)：比較兩個列表的元素 
　　　　二、len(list)：列表元素個數 
　　　　三、max(list)：返回列表元素最大值 
　　　　四、min(list)：返回列表元素最小值 
　　　　五、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-一、字典

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

13-二、元組

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

13-三、列表

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

13-四、字符串

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