Python3 列表

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

獲取

>>> classmates[2]
'Tracy'

當索引超出了範圍時，Python會報一個IndexError錯誤，所以，要確保索引不要越界，記得最後一個元素的索引是len(classmates) - 1。

如果要取最後一個元素，除了計算索引位置外，還可以用-1做索引，直接獲取最後一個元素：

friends.append("zx")
friends.insert(0, "yyn")
friends.pop() // 刪除最後一個元素
friends.pop(1) // 刪除索引1對應的元素
friends[0] = "hh" // 直接對索引0賦值

list裡面的元素的數據類型也可以不同，比如：

>>> L = ['Apple', 123, True]

list元素也可以是另一個list，比如：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

tuple

另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字

>>> classmates = ('Michael', 'Bob', 'Tracy')

不可變的tuple有什麼意義？因為tuple不可變，所以代碼更安全。如果可能，能用tuple代替list就儘量用tuple。

tuple的陷阱：當你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來。

但是，要定義一個只有1個元素的tuple，如果你這麼定義：

>>> t = (1)
>>> t
1

所以，只有1個元素的tuple定義時必須加一個逗號,，來消除歧義：

>>> t = (1,)
>>> t
(1,)

Python在顯示只有1個元素的tuple時，也會加一個逗號,，以免你誤解成數學計算意義上的括弧。

最後來看一個“可變的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

這個tuple定義的時候有3個元素，分別是'a'，'b'和一個list

條件判斷

if判斷條件還可以簡寫，比如寫：

if x:
    print('True')
else:
　　 print('False');

只要x是非零數值、非空字元串、非空list等，就判斷為True

if <條件判斷1>:
    <執行1>
elif <條件判斷2>:
    <執行2>
elif <條件判斷3>:
    <執行3>
else:
    <執行4>

迴圈

Python的迴圈有兩種，一種是for...in迴圈，依次把list或tuple中的每個元素迭代出來，看例子：

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

>>> list(range(5))
[0, 1, 2, 3, 4]

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

dict

Python內置了字典：dict的支持，dict全稱dictionary，在其他語言中也稱為map，使用鍵-值（key-value）存儲，具有極快的查找速度。

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} >>> d['Michael'] 95

為什麼dict查找速度這麼快？因為dict的實現原理和查字典是一樣的。假設字典包含了1萬個漢字，我們要查某一個字，一個辦法是把字典從第一頁往後翻，直到找到我們想要的字為止，這種方法就是在list中查找元素的方法，list越大，查找越慢。

第二種方法是先在字典的索引表裡（比如部首表）查這個字對應的頁碼，然後直接翻到該頁，找到這個字。無論找哪個字，這種查找速度都非常快，不會隨著字典大小的增加而變慢。

dict就是第二種實現方式，給定一個名字，比如'Michael'，dict在內部就可以直接計算出Michael對應的存放成績的“頁碼”，也就是95這個數字存放的記憶體地址，直接取出來，所以速度非常快。

你可以猜到，這種key-value存儲方式，在放進去的時候，必鬚根據key算出value的存放位置，這樣，取的時候才能根據key直接拿到value。

把數據放入dict的方法，除了初始化時指定外，還可以通過key放入：

>>> d['Adam'] = 67
>>> d['Adam']
67

由於一個key只能對應一個value，所以，多次對一個key放入value，後面的值會把前面的值衝掉，如果key不存在，dict就會報錯：

>>> 'Thomas' in d
False

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

和list比較，dict有以下幾個特點：

1. 查找和插入的速度極快，不會隨著key的增加而增加；
2. 需要占用大量的記憶體，記憶體浪費多。

而list相反：

1. 查找和插入的時間隨著元素的增加而增加；
2. 占用空間小，浪費記憶體很少。

所以，dict是用空間來換取時間的一種方法。

dict可以用在需要高速查找的很多地方，在Python代碼中幾乎無處不在，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變對象。

set

set和dict類似，也是一組key的集合，但不存儲value。由於key不能重覆，所以，在set中，沒有重覆的key。

要創建一個set，需要提供一個list作為輸入集合：

>>> s = set([1, 2, 3])

>>> s.remove(4)

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

不可變對象

上面我們講了，str是不變對象，而list是可變對象。

對於可變對象，比如list，對list進行操作，list內部的內容是會變化的

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

而對於不可變對象，比如str，對str進行操作呢：

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc' # replace方法創建了一個新字元串'Abc'並返回
>>> a
'abc'