06.09 Python 變量

Python 通過變量引用內存中的值，變量的值佔用多少空間是由變量類型決定。聲明變量不需要顯示指定變量的類型，解釋器會自動根據值來判斷。變量的名稱必須符合標識符的定義。

標識符

標識符是由字母、數字和下劃線構成。

標識符不能以數字開頭。

標識符是區分大小寫的。

下劃線開頭的標識符有特殊的意義，例如 _foo 代表不能直接訪問的類屬性。雙下劃線 __foo 代表類的私有成員。雙下劃線開頭和結尾的例如 __foo__ 代表類裡的特殊方法。

標識符不能是保留字。

保留字

保留字在 Python 程序中有特殊意義。不能用於定義變量名。這些保留字是：

and,exec,not,assert,finally or,break,for,pass,class,from,print,continue,global,raise,def,if,return,del,import,try,elif,in,while,else,is,with,except,lambda,yield

下面的例子聲明瞭不同類型的變量，你可以任意賦值並打印他們

x = 3 # 數字類型
f = 3.1415926 # 浮點數類型 floating point number
name = 'alex' # 字符串類型 string

a = 1, 2, 3, 4, 5 # 元組
b = ['hello', 'world', '!'] # 列表
d = dict(name='alex', age=18) # 字典

Python有5個標準的數據類型。

1. 數字類型 Numbers
2. 字符串類型 String
3. 列表 Lists
4. 元組 Tuple
5. 字典 Dictionary

當你聲明一個變量的時候，是不需要指定變量類型的，可以直接給變量賦與任何類型的值。

數字類型 Numbers

Python 支持很多數字類型

1. 整數 Numeric
2. 浮點數 Float
3. 複數 Complex

>>> a = 1 # 整數
>>> print(a)
1
>>> b = 3.14 # 浮點數
>>> print(b)
3.14
>>> c = 2 + 3j # 複數
>>> print(c)
(2+3j)
>>> complex(2, 3) # 複數
(2+3j)

a+bj 和 complex(a, b) 等效。

字符串

字符串類型是一個不可變的字符序列，由 str 對象表示。

字符串字面量有幾種不同的定義形式

• 單引號：'foo'
• 雙引號："foo"
• 三個引號： '''foo''' 或者 """foo"""

三個引號的形式可以定義多行，換行符也算字符串的字符。

>>> a = """
... aaa
... bbb
... """
>>> a
'\\naaa\\nbbb\\n' 

>>> print(a)

aaa
bbb

>>> 

字符串相當於表達式，可以使用空格連續寫多個字符串，相當於定義一個。例如 ('foo ' 'bar') 相當於 'foo bar'。

如果字符串裡包含雙引號，單引號，需要使用 \\ 轉義。

>>> a = 'hello \\"world\\"'
>>> print(a)
hello "world"
>>> a = 'hello \\'world\\''
>>> print(a)
hello 'world'

可以轉義單引號，雙引號。以上輸出並沒有 \\。 若你想輸出 \\，需要寫兩個連續的 \\。例如：

a = '\\\\'
print(a) # 輸出 "\\"

或者加前綴 r，取消轉義。

>>> a = r'hello \\'world\\''
>>> print(a)
hello \\'world\\'

字符串可以使用 + ，連接多個字符串，返回一個新的字符串。

>>> a = 'hello'
>>> b = ' world' 

>>> a+b
'hello world'

列表

列表是可修改的序列類型。所以列表不可以作為字典的鍵。

>>> a = [1]
>>> hash(a)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
/<module>/<stdin>

如果調用 hash() 函數拋出異常 TypeError。

列表的操作：

• 賦值操作: s[i] = x
• 賦值操作: s[i:j] = t
• 刪除操作：del s[i:j] 相當於 s[i:j] = []
• 賦值操作：s[i:j:k] = t
• 刪除操作：del s[i:j:k]
• 添加元素到末尾：s.append(x)
• 刪除整個列表的元素：s.clear()
• 淺複製：s.copy() 相當於 s[:]
• 擴展列表：s.extend(t) 或者 s += t
• 複製內容n次：s*= n
• 在位置i,插入元素：s.insert(i, x)
• 彈出：s.pop([i]) 彈出位置i的元素，並返回，i是可選的，默認彈出列表末尾的元素
• 刪除：s.remove(x) 刪除元素 x，如果沒有找到元素，拋出 ValueError 異常
• 倒序：s.reverse()

舉例：

>>> s
[1, 3]
>>> s.extend([4])
>>> s
[1, 3, 4]
>>> s += [6,7]
>>> s
[1, 3, 4, 6, 7]
>>> s *= 2
>>> s
[1, 3, 4, 6, 7, 1, 3, 4, 6, 7]
>>> s.insert(3, 10)
>>> s
[1, 3, 4, 10, 6, 7, 1, 3, 4, 6, 7]
>>> s.pop()
7
>>> s
[1, 3, 4, 10, 6, 7, 1, 3, 4, 6]
>>> s.pop(3)
10
>>> s
[1, 3, 4, 6, 7, 1, 3, 4, 6]
>>> s.remove(1)
>>> s
[3, 4, 6, 7, 1, 3, 4, 6]
>>> s.reverse()
>>> s
[6, 4, 3, 1, 7, 6, 4, 3]
>>> s.remove(100)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
/<module>/<stdin>

s.remove(e) 只會刪除一個元素。

元組

元組是不可變的序列類型。由於它的不可變，可作為字典的鍵。

>>> t = 1,
>>> hash(t)
3430019387558

列表調用 hash() 函數會拋出 TypeError 異常，元組沒有問題，返回的是一個整數。

元組的構造方式

• 使用一對小括號生成一個空的元組 ()
• 逗號加在一個字符末尾，聲明一個元素的元組 2, 或者 (2,)
• 逗號分隔的元素 1,2,3 或者 (1,2,3)
• 利用 tuple() 函數，tuple() 或者 tuple(iterable)

>>> t = tuple()
>>> print(t)
()
>>> t = 1,
>>> print(t)
(1,)
>>> t[0]
1
>>> t[1]
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> t2 = (1,2,3)
>>> print(t2)
(1, 2, 3)
>>> t3 = tuple([1,2,3,4])
>>> print(t3)
(1, 2, 3, 4) 

>>> t4 = tuple(range(10))
>>> print(t4)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> print(t4[3])
3
>>> print(t4[3:8])
(3, 4, 5, 6, 7)
/<module>/<stdin>

列表和元組訪問如果下標越界，會拋出 IndexError 異常，例如元組越界會拋出 IndexError: tuple index out of range。

字典

Python中的字典是一個可映射的對象，映射是指一個可哈希化（hashable）的鍵值對應一個對象。字典是一個可變對象。

例如 {'name': 'alex', 'age': 18} ，聲明瞭一個字典，對應兩個映射對象，鍵姓名 name 對應一個字符串值alex，鍵年齡 age 對應一個整數 18。鍵 name 和 age 都是字符串，由於字符串是不可變的，可以哈希化，所以能夠作為鍵值。字典的值不必是哈希化的，所以列表可以作為值。

• {'one': 1}
• dict(**kwarg)
• dict(mapping, **kwarg)
• dict(iterable, **kwarg)

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> a
{'one': 1, 'two': 2, 'three': 3}
>>> b
{'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1,2,3]))
>>> c
{'one': 1, 'two': 2, 'three': 3}
>>> d = dict([('one', 1), ('two', 2), ('three', 3)])
>>> d
{'one': 1, 'two': 2, 'three': 3}

字典的操作：

• 返回字典長度 len(d)
• 返回鍵值 d[key]，如果鍵不存在，拋出 KeyError
• 設置或更新鍵值 d[key] = value
• 從字典中刪除鍵 del d[key]，如果鍵不存在，拋出 KeyError
• key in d 判斷一個鍵是否存在
• iter(d) 返回一個包含字典中所有鍵的迭代器
• d.clear() 清空字典
• classmethod fromkeys(seq, [value]) 從一個序列seq生成一個字典，value值是可選的，不傳默認是 None，這是一個類方法。
• d.get(key[, default]) 獲取鍵key的值。key不存在，則返回第二個參數default的值，如果第二個參數沒有傳，返回 None 類型。
• d.items() 返回鍵值對的一個視圖對象，可以用for遍歷，鍵值對是元組形式。
• d.keys() 返回鍵的一個視圖對象，可以用for遍歷
• d.pop(key[, default]) 彈出鍵key的值，沒有則返回default值
• d.popitem() 彈出一個鍵值元組
• d.setdefault(key[, default])
  如果鍵key存在，返回值，不存在則設置字典key=default，返回default
• d.update(other) 從other更新字典，如果other中的鍵已經存在了，則覆蓋原來的值。
• d.values() 返回所有值的視圖對象，可以用for遍歷

>>> d = {}
>>> d['one'] = 1
>>> d['two'] = 2
>>> d
{'one': 1, 'two': 2}
>>> del d['not_exists']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'not_exists'
>>> del d['one']
>>> d
{'two': 2}
>>> d.clear()
>>> d
{}
>>> len(d)
0
>>> d = dict.fromkeys('abc', 2)
>>> d
{'a': 2, 'c': 2, 'b': 2}
>>> d.get('a', 100)
2
>>> d.get('f', 100)
100
>>> d
{'a': 2, 'c': 2, 'b': 2}
>>> for i in d.items(): print(i)
... 
('a', 2)
('c', 2)
('b', 2)
>>> for i in d.keys(): print(i)
...  

a
c
b
>>> d['c'] = 5
>>> for i in d.values(): print(i)
... 
2
5
2
>>> d.pop('f')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'f'
>>> d.pop('f', 99)
99
>>> d
{'a': 2, 'c': 5, 'b': 2}
>>> d.popitem()
('a', 2)
>>> d
{'c': 5, 'b': 2}
>>> d.setdefault('c', 99)
5
>>> d
{'c': 5, 'b': 2}
>>> d.setdefault('e', 99)
99
>>> d
{'e': 99, 'c': 5, 'b': 2}
>>> d.update({'d': 8})
>>> d
{'e': 99, 'c': 5, 'b': 2, 'd': 8}
/<module>/<stdin>/<module>/<stdin>