1、總結

增、刪、改、查

list = [1,"xiaoming","atao","quangege",10,"a"]
# 列表增
list.append("10") # 列表尾部增加
list.insert(1,"xxxx") # 指定位置增加
print(list)
# 列表刪除
# list.remove("xiaoming") 指定字串刪除
# list.pop[1] 不指定預設行位
del list[1]
print(list)
# 修改
list[1] = "xiaoxuesheng"
print(list)
# 查詢列表某個欄位所屬位置
list.index("xiaoxuesheng")
print(list)

程式碼執行結果

python遍歷列表

list = [1,"xiaoming","atao","quangege",10,"a"]
for i in list:
    print(i)

print("\n")
# 每隔1位遍歷
for i in list[::2]:
    print(i)

程式碼執行效果:

2、python 列表操作方法詳解

轉自或參考：python 列表操作方法詳解 - 戰爭熱誠 - 部落格園
https://www.cnblogs.com/wj-1314/p/8433116.html

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

一，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]

六，列表指令碼操作符

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

七，列表操作函式

　　　　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型別

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。