1.列表知識彙總

序列：基本的資料結構，序列中的每個元素都有編號（索引），第一個元素的索引是0，第二個元素的索引是1，依次類推
為什麼從0計數：從0開始指出相對於序列開頭的偏移量。同時可以繞到序列末尾，用負索引表示序列末尾元素的位置
eg1

# 列表中的元素可以不是同一種型別
edward = ["grid",1.0]
edward2 = ["bird",2]
print(edward)
print(edward2)
# 列表可以包含其他的列表
edward3 = [edward,edward2]
print(edward3)

['grid', 1.0]
['bird', 2]
[['grid', 1.0], ['bird', 2]]

列表操作

索引

#字串就是由字元組成的序列
greet = "Hello"
print("第一個元素："+greet[0])
#使用內建函式計算列表的長度，最後一個元素的索引是長度減一
print("最後一個元素："+greet[len(greet)-1])
#最後一個元素的下標是-1，往前數是-2，-3...
print("倒數第二個元素："+greet[-2])
#字串以及其他的序列字面量，可以直接對其使用索引
print("第二個元素："+"Hello"[1])
#如果函式返回一個序列，則函式也可以直接使用索引
four = input("please input a string : ")[3]
print("輸入的字串的第四個元素是：%s" %four)

第一個元素：H
最後一個元素：o
倒數第二個元素：l
第二個元素：e
please input a string : world
輸入的字串的第四個元素是：l

切片

使用切片來訪問特定範圍內的元素。可以使用兩個索引，並用冒號 ： 進行分隔。包含第一個索引指定的元素，不包含最後一個索引指定的元素

numbers = [1,2,3,4,5,6,7,8,9,10]
print(numbers[0:3])
#第二個索引超過實際的索引值，仍能正常列印
print(numbers[0:20])
print(numbers[-3:9])
#第一個索引的元素位置必須比第二索引的元素位置要小，否則列印空序列
print(numbers[-3:1])
#省略第一個索引，切片始於序列開頭
print(numbers[:-3])
#省略第2個索引，切片結束與序列結尾，且包含最後一個元素
print(numbers[-3:])
#省略第一個，第二個索引，表示整個序列
print(numbers[:])

[1, 2, 3]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[8, 9]
[]
[1, 2, 3, 4, 5, 6, 7]
[8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

切片之步長

#全部的奇數，步長是2
print(numbers[0:10:2])
#全部的偶數，步長是2
print(numbers[1:10:2])
#步長為負，表示從右邊向左邊提取元素，且第一個索引必須大於第二個索引
print(numbers[10:0:-2])
#第六個元素到序列開始，然後反向提取
print(numbers[5::-2])
#從序列結尾到第六個元素（不包含），反向提取
print(numbers[:5:-2])

[1, 3, 5, 7, 9]
[2, 4, 6, 8, 10]
[10, 8, 6, 4, 2]
[6, 4, 2]
[10, 8]

序列相加

#用加運算子連線列表
list1 = ["h","e","l"]
list2 = ["l","o"]
list3 = list1 + list2
print(list3)
#不能拼接不同型別的序列
# TypeError: can only concatenate list (not "str") to list
str = "world"
list4 = list3 + str
print(list4)

序列乘法

#序列與數相乘表示重複這個序列來建立一個新的序列
pythons = "python " * 5
print(pythons)

world = ["bye","bye"]
byes = world * 2
print(byes)

空列表 [ ]
使用None 初始化列表

emptyList = []
noneList = [None] * 8
print("emptyList len = %s" %(len(emptyList))) #0
print("noneList len = %s" %(len(noneList)))  #8

成員包含

in 或 not in

father = "father"
print("fa" in father) #True
print("wa" in father) #False
print("wa" not in father)#True
fathers = ["foo","sd"]
print("foo" in fathers)#True
print("wan" in fathers)#False
print("han" not in fathers)#True

序列成員包含

database = [["li",123],["zhao",234],["qian",456]]
userName = input("please input your name : ")
password = input("please input your password : ")
#實際上database 中的123 是數值型別，所以要進行型別轉化
password = int(password)
if [userName,password] in database :
    print("login success!")
else:
    print("login failure!")

please input your name : li
please input your password : 123
login success!

列表常用函式

函式list

#使用list 函式將字串轉為序列
str1 = "hello"
strToList = list(str1)
print(strToList)

#將序列轉為字串
list1 = ["w","o","r","l","d"]
listToStr = ','.join(list1)
listToStr2 = '！'.join(list1)
print("使用逗號隔開 ： "+listToStr)
print("使用歎號隔開 ： "+listToStr2)

['h', 'e', 'l', 'l', 'o']
使用逗號隔開 ： w,o,r,l,d
使用歎號隔開 ： w！o！r！l！d

給元素賦值

old = ["x","y","z"]
#使用空列表清空
old = []
old = "s"
#old = "s"後，old已經成為字串型別，而字串型別為不可變型別，所以old[0] = "w"報錯
# old[0] = "w"
old = ["a","b","c"]
#修改第一個元素的值
old[0] = "d"
#['d', 'b', 'c']
print(old)

刪除元素
刪除單個元素和範圍刪除

old = ["a","b","d","f"]
#刪除一個元素
del old[1]
#刪除切片（範圍）元素
print(old) #['a', 'd', 'f']
del old[-1:]
print(old) #['a', 'd']

切片賦值
eg1

hi = list("hi")
hi[1:] = "ello"
print("".join(hi)) #hello

eg2 插入新元素

old = ["a","b","d","f"]
#在第三個位置插入c
old[2:2] = "c"
print(old)#['a', 'b', 'c', 'd', 'f']

列表常用方法

1. append
   就地修改原列表

#將一個物件附加到列表末尾
#在列表末尾加一個字串
list1 = ["hello"]
list1.append("world")
print(list1)
#在列表末尾加一個列表
list1.append(["ha","hei"])
print(list1)
#在列表末尾加個元組
list1.append(("bye","bye"))
print(list1)
#在列表末尾加個數值
list11 = list1.append(3.14)
print(list1)
#看下apped返回的結果是什麼？None
print(list11)

['hello', 'world']
['hello', 'world', ['ha', 'hei']]
['hello', 'world', ['ha', 'hei'], ('bye', 'bye')]
['hello', 'world', ['ha', 'hei'], ('bye', 'bye'), 3.14]
None

2. clear
   就地清空原列表

list1 = ['hello', 'world']
listClear1 = list1.clear()
print(listClear1)
print(list1)

None
[]

3. copy
   複製列表，會產生一個新的列表

#list3與list2關聯，修改list3也會修改list2
list2 = ['hello', 'world']
list3 = list2
list3.append("how")
print(list2)
#list4 是list2的副本，修改list4之後不會修改list2
list4 = list2.copy()
list4.append("here")
print(list2)
print(list4)

['hello', 'world', 'how']
['hello', 'world', 'how']
['hello', 'world', 'how', 'here']

4. count
   計算指定元素在列表中出現的次數

list5 = [1,2,3,1,1,1,2]
myC = list5.count(1)
#myC的型別是Int,與字串連線時需要轉化為字串
print("1 在 list5 中出現的次數是：" + str(myC))

1 在 list5 中出現的次數是：4

5. extend
   就地修改原列表，將多個值附加在列表末尾

list5 = [1,2,3,1,1,1,2]
list6 = list5.extend(["he","hea"])
print(list6)#None
print(list5)#[1, 2, 3, 1, 1, 1, 2, 'he', 'hea']

6. index
   查詢指定元素在序列中第一次的位置，如果沒有找到會報錯，所以最好先使用in 判斷下要查內容是否在序列中是否存在，再求第一次出現時的索引

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
if "he" in list7 :
    heIndex = list7.index("he")
    #通過下標獲取列表中的元素
    heStr = list7[heIndex]
    print("在 list7 索引 %d 對應的元素是 ： %s" %(heIndex,heStr))
else:
    print("he 在 list7中找不到")

在 list7 索引 7 對應的元素是 ： he

可以在指定的範圍中搜尋index(object,start,end) 搜尋範圍包括start 不包括end

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
#he 的下標是7，所以在3-8中可以找到
print("範圍查詢 %d"  %list7.index("he",3,8))
#由於結束位置是7，實際搜尋的是從3-6，不會包含結束的索引位置，所以報錯ValueError: 'he' is not in list
print("範圍查詢 %d" %list7.index("he",3,7))

7. insert
   指定在列表某個位置插入物件，就地修改

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
result1 = list7.insert(3,["bao","zha"])
print(list7) #[1, 2, 3, ['bao', 'zha'], 1, 1, 1, 2, 'he', 'hea']
print(result1) #None

8. pop
   pop()從列表中刪除最後一個元素，並將其返回
   pop(x) 從列表中刪除索引x的元素，並將其返回

list7 = [1, 2, 3, 1, 1, 1, 2, 'he', 'hea']
#出棧列表第三個元素
popResult1 = list7.pop(2)
print(popResult1)
print(list7)
#出棧列表最後一個元素
popResult2 = list7.pop()
print(popResult2)
print(list7)
#還可以支援負數，最後一個元素是-1，倒數第二個是-2，依次類推
list8 = ['h','e','l','j','w']
print(list8.pop(-2))

3
[1, 2, 1, 1, 1, 2, 'he', 'hea']
hea
[1, 2, 1, 1, 1, 2, 'he']
j 

9. remove
   就地刪除，無返回值。刪除列表中的指定元素，如果列表中不存在該指定元素，報錯，所以也先用in檢視下包含關係再做刪除

list8 = "hello"
list9 = list(list8)
removeRes = list9.remove('e')
print(list8) #hello
print(removeRes)#None
print(list9) #['h', 'l', 'l', 'o']

10. reverse
    就地反轉，不返回值。

list10 = ["a","b","c","d"]
reverseRes = list10.reverse()
print(reverseRes) #None
print(list10)  #['d', 'c', 'b', 'a']

11. sort
    就地排序，且不返回任何值。

list11 = ['a','b','h','c']
sortRes = list11.sort()
print(list11) #['a', 'b', 'c', 'h']
print(sortRes) #None

12. sorted
    不修改原序列，而是返回一個排序後的序列

list12 = ['a','b','h','c']
#sorted()是python的內建函式，不是是list的函式所以直接使用，將列表作為sorted的引數
list13 = sorted(list12)
print(list12) #['a', 'b', 'h', 'c']
print(list13) #['a', 'b', 'c', 'h']