python 基礎資料類型 之 列表

標籤：sha   排列   eve   strong   append   key   split()   博文   ISE   

列表：定義 和特性

列表定義和建立：

　　定義：[,]內以逗號分隔，按照索引，存放各種資料類型，一般沒有限制，每個位置代表一個元素

　　

range_create = list(range(0, 10))
print(range_create)
>>:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

str = ‘yanxiatingyu‘
str_create = list(str)
print(str_create)
>>:[‘y‘, ‘a‘, ‘n‘, ‘x‘, ‘i‘, ‘a‘, ‘t‘, ‘i‘, ‘n‘, ‘g‘, ‘y‘, ‘u‘]

iter_create=[lis for lis in range(0,10)]
print(iter_create)
>>:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

特性：
1.可以存放多個值
2.按照從左至右的順序定義列表元素，下標從0開始順序訪問，有序
3.可修改指定索引位置對應的值，可變

#取值
#索引 取值 基本上和string 操作差不多
name=‘yanxiatingyu‘
name_list=list(name)
print(name_list[0])
>>:y

print(name_list[：])#不設限

print(name_list[：：2])#正向步長

print(name_list[::-1])#取反

#追加
name_list.append(‘new_element‘)


#在指定位置添加元素，如果指定的下標不存在，那麼就是在末尾添加
#插入
name_list.insert()

name_list=(‘yan xia ting yu‘).split()
print(name_list)
name_list.insert(3,‘hello insert‘)
print(name_list)
[‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘]
[‘yan‘, ‘xia‘, ‘ting‘, ‘hello insert‘, ‘yu‘]

#刪除 
方式一
　　name_list.remove(‘new_element‘)

方式二
name_list.append(‘new_element‘)
del name_list[name_list.index(‘new_element‘)]
print(name_list)

list.pop() 刪最後一個元素

list.pop(n)指定下標，刪除指定的元素，如果刪除一個不存在的元素會報錯

list.remove(xx) 刪除list 裡面的一個元素，有多個相同的元素，刪除第一個 

print(list.pop()) 有傳回值

print(list.remove()) 無傳回值

del  list[n] 刪除指定下標對應的元素 

del list 刪除整個列表， list刪除後無法訪問

 

 

list.reverse()將列表反轉

list.sort()排序，預設升序

list.sort(reverse=True) 降序排列

註：list 中有字串，數字時不能排序，排序針對同類型

六，列表操作的函數

1、len(list)：列表元素個數 
2、max(list)：返回列表元素最大值 
3、min(list)：返回列表元素最小值 
4、list(seq)：將元群組轉換為列表

5、enumerate 用法（列印元素對應的下標）

同時取下標，元素

長度
print(len(name_list))


【in 與 not in 操作符】包含 與 不內含項目關聯性

if ‘new_element‘ in name_list:
　　print(‘存在此元素‘)
if ‘new_element‘ not in name_list:
　　print(‘不存在此元素‘)

【count 統計字元在list出現的次數】
print(name_list.count(‘統計‘))

【尋找值，並且返回索引】
name_list.index(‘a‘)#假如存在則返回元素第一次出現處的索引，不存在報錯：ValueError:element is not in list

name_list.index(‘a‘,0,5)#返回element 在指定切片內第一次出現的位置

三，查看列表中的值

print(list)    遍曆列表

等價於    for i in list:

                      print i

print(list[n])  使用下標索引來訪問列表中的值，同樣你也可以使用方括弧的形式截取字元

print(list.count(xx)) 查看某個元素在這個列表裡的個數，如果改元素不存在，那麼返回0

print(list.index(xx))找到這個元素的小標，如果有多個，返回第一個，如果找一個不存在的元素會報錯

【list 與 可迭代迴圈】
for i,item in enumerate(name_list):#可迭代迴圈
　　print(‘name_list[%s]:%s‘%(i,item))


#列表與字串
name=‘yan xia ting yu‘
name_list=name.split(‘ ‘)
print(name_list)
>>:[‘yan‘,‘xia‘,‘ting‘,‘yu‘]

print(‘ ‘.join(name_list))
>>:yan xia ting yu

#列表 進階操作 以及 效率問題
name_list = (‘yan xia ting yu‘).split(‘ ‘)
list_zhang = ‘zhang huan huan‘.split(‘ ‘)
name_list += list_zhang
#說明：用 + 號串連符此效率較低，
# 先建立新列表，並將所有對象複製過去，
# 而用extend將元素附加到現有列表
# (尤其是在構建一個大列表時)就會好很多
name_list.extend(list_zhang)
print(name_list)





#排序
#用sort方法可以實現就地排序(無需建立新對象，字串按首字母進行排序)
name=‘yanxiatingyu‘
name_list=list(name)
print(name_list)
name_list.sort()
print(name_list)
#[‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘, ‘zhang‘, ‘huan‘, ‘huan‘, ‘zhang‘, ‘huan‘, ‘huan‘]
#[‘y‘, ‘a‘, ‘n‘, ‘x‘, ‘i‘, ‘a‘, ‘t‘, ‘i‘, ‘n‘, ‘g‘, ‘y‘, ‘u‘]
#[‘a‘, ‘a‘, ‘g‘, ‘i‘, ‘i‘, ‘n‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘, ‘y‘]
#sort有幾個很好用的選項，一個是次要排序鍵，
# 即一個能夠產生可用於排序的值的函數。如可以通過長度對一組字串進行排序
#使用sort 排序 不會返回新列表

name_list=list(‘yanxiatingyu‘)
name_list.sort(key=len)#
print(name_list)
>>:[‘y‘, ‘a‘, ‘n‘, ‘x‘, ‘i‘, ‘a‘, ‘t‘, ‘i‘, ‘n‘, ‘g‘, ‘y‘, ‘u‘]
#是否進行降序排列：
# 下面例子是根據首字母進行排序操作

name_list.sort(key= lambda  x:x[0],reverse=True)
print(name_list)）

>>:[‘y‘, ‘y‘, ‘x‘, ‘u‘, ‘t‘, ‘n‘, ‘n‘, ‘i‘, ‘i‘, ‘g‘, ‘a‘, ‘a‘]

二分搜尋及維護有序列表（bisect）

       內建的bisect模組實現了二分尋找以及對有序列表的插入操作。bisect.bisect可以找出新元素應該被插入到哪個位置以保持元列表的有序性，bisect.insort則將新元素插入到那個正確的位置上。

  注意：bisect模組的函數不會判斷原列表是否有序，因為這樣做開銷太大；因此將他們用作無序列表時雖然不會出錯，但可能會導致不正確的結果。基於此，建議在使用bisect模組的函數前，先對原列表執行排序的操作。

#79685168 　　　　#原文：管理list操作
#https://www.cnblogs.com/yanxiatingyu/p/9277019.html　　　　　　　　　　#關於bisect 模組
#https://www.cnblogs.com/skydesign/archive/2011/09/02/2163592.html　　#關於bisect模組

切片（索引運算子[]及start：stop）

       可以對序列類型（數組、列表、元組等）進行切片操作，start索引處元素被包括在切片的結果中，stop索引處的元素未被包括在結果中，元素數量為 stop-start。start或stop都是可以省略的，此時他們分別預設為序列的起始處和結尾處。

 

切片操作：可以參考我的博文，striing 這塊

列表內建的序列函數 enumerate

enumerate函數可以逐個返回序列的(key，value)組合，你可以根據這個得到自己想要的容器類型
如下：

name = ‘yanxiatingyu‘
name_list = list(name)
name_dict= dict((key + 1, value) for key, value in enumerate(name_list))
print(type(name_dict), name_dict)
>>:<class ‘dict‘> {1: ‘y‘, 2: ‘a‘, 3: ‘n‘, 4: ‘x‘, 5: ‘i‘, 6: ‘a‘, 7: ‘t‘, 8: ‘i‘, 9: ‘n‘, 10: ‘g‘, 11: ‘y‘, 12: ‘u‘}

六，列表操作的函數

1、len(list)：列表元素個數 
2、max(list)：返回列表元素最大值 
3、min(list)：返回列表元素最小值 
4、list(seq)：將元群組轉換為列表

5、enumerate 用法（列印元素對應的下標）

同時取下標，元素

#sorted()排序是返回一個新的list
#sort()是就地排序
print(sorted(name_list))
[‘a‘, ‘a‘, ‘g‘, ‘i‘, ‘i‘, ‘n‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘, ‘y‘]

#sorted 和set 配合使用，得到一個有序，元素不重複的    list

print(sorted(‘yan xia ting yu‘))
print(sorted(set(‘yan xia ting yu‘)))
# [‘ ‘, ‘ ‘, ‘ ‘, ‘a‘, ‘a‘, ‘g‘, ‘i‘, ‘i‘, ‘n‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘, ‘y‘]
# [‘ ‘, ‘a‘, ‘g‘, ‘i‘, ‘n‘, ‘t‘, ‘u‘, ‘x‘, ‘y‘]
print(set(‘yan xia ting yu‘))
print(set(sorted(‘yan xia ting yu‘))) #字典是無序的，所以下列內容也是無序的，不信可以試一試多運行幾遍
# {‘i‘, ‘a‘, ‘x‘, ‘g‘, ‘ ‘, ‘n‘, ‘y‘, ‘t‘, ‘u‘}
# {‘i‘, ‘a‘, ‘g‘, ‘x‘, ‘ ‘, ‘n‘, ‘u‘, ‘t‘, ‘y‘}

zip用於將多個序列（列表、元組等）中的元素“配對”，從而產生一個新的元組列表；zip可以接受任意數量的序列，最終得到的元組數量由最短的序列決定；zip最常見的用法是同時迭代多個序列，還可以結合enumerate一起使用，如下：

 

name = ‘yan xia ting yu‘
name_list =name.split()
print(name_list)
girl=‘girl1 girl2 girl3 girl4‘
girl_list=girl.split()
print(girl_list)
iter_zip=zip(girl_list,name_list)
print(type(iter_zip))
print(‘iter_zip‘)
for v,k in iter_zip:
    print(v,k)

print(‘enumerate(iter_zip)‘)
for i,v in enumerate(iter_zip):#這裡無法輸出？
    print(‘%s %s ‘%(i+1,v))

print(‘enumerate(zip(girl_list,name_list))‘)
for i,(v,k) in enumerate(zip(girl_list,name_list)):
    print(‘%s %s %s‘%(i+1,v,k))

# [‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘]
# [‘girl1‘, ‘girl2‘, ‘girl3‘, ‘girl4‘]
# <class ‘zip‘>
# iter_zip
# girl1 yan
# girl2 xia
# girl3 ting
# girl4 yu
# enumerate(iter_zip)
# enumerate(zip(girl_list,name_list))
# 1 girl1 yan
# 2 girl2 xia
# 3 girl3 ting
# 4 girl4 yu

 對於“已壓縮的”（zipped）序列，zip還有一個很巧妙的用法，即對該序列進行解壓（unzip，用*表示）
。其實就是             【將一組行轉換為一組列】
如下：

teacher=[(‘egon‘,18),(‘lqz‘,16),(‘wxx‘,20)]
name,age=zip(*teacher)
print(type(name),name)
# <class ‘tuple‘> (‘egon‘, ‘lqz‘, ‘wxx‘)
print(type(age),age)
# <class ‘tuple‘> (18, 16, 20)


teacher=[(‘egon‘,18),(‘lqz‘,16)]
name1,name2=zip(teacher)
print(type(name1),name1)
# <class ‘tuple‘> ((‘egon‘, 18),)
print(type(name2),name2)
# <class ‘tuple‘> ((‘lqz‘, 16),)
name_list=(‘yan xia ting yu‘).split()
print(name_list)
[‘yan‘, ‘xia‘, ‘ting‘, ‘yu‘]

【資料解壓】
x,y,z,_=name_list
print(_)
x,y,*_=name_list
print(x)
print(*_)

#yu
#yan
#ting yu

#逆向排序 reversed()    函數是返回序列seq的反向訪問的迭代子。參數可以是列表，元組，字串，不改變原對象。

print([x for x in reversed([1,2,5,4,-1])])

>>:[-1, 4, 5, 2, 1]

head　first Python 總結：

1，列表是一個有序的對象集合
2，一個對象在另外一個對象中嗎？用 in 來檢查

3，從列表中刪除對象 remove
remove:取一個對象值作為唯一參數。remove方法會從列表中刪除指定資料值的第一次出現。

如果在列表中找到了這個資料值，就會從列表中刪除包含這個值的對象（同時列表的大小減一）。如果在列表中沒有找到這個資料值，會報錯。

4，從列表中彈出對象 pop
pop:取一個可選的索引值（indexof）作為參數。pop方法根據對象的索引值從現有列表刪除和返回一個對象。

如果調用pop時沒有指定索引值，將刪除和返回列表中的最後一個對象。如果指定了一個索引值，則會刪除和返回那個位置上的對象。

如果列表為空白或者調用pop時指定了一個不存在的索引值，會報錯。

5，用對象擴充列表 extend 
extend:取一個對象列表作為唯一參數。extend方法接收第二個列表，將其中的各個對象增加到現有列表。如果要將兩個列表合并為一個列表，這個方法就非常有用。

6，在列表中插入一個對象 insert/append
insert:取一個索引值和一個對象作為參數。insert 方法將一個對象插入到現有列表中指定索引值的前面。

這樣就可以將對象插入到現有列表的開頭，或者插入到列表中的任何位置。要把對象插入到列表末尾，用append 。用法 num.insert(2,"abc")

7，如何複製一個資料結構？不要使用賦值操作符複製列表；應當使用copy方法。
賦值操作都指向同一個資料，如果修改一個列表，另一個也會改變；如果想讓另一個變數引用一個現有列表，可以使用賦值操作（=）
copy:list2 = list1.copy() ；如果想建立現有列表中對象的副本，用他們初始化一個新列表，就一定要使用copy 方法

8，列表切片的使用【start:stop:step】不包含stop 索引值
step 為正數時，從右至左；step 為負數時，從左至右

python 基礎資料類型 之 列表