• 基礎
• 基本資料型別
  • 賦值
  • 總覽
  • 查詢變數型別
• 字串
  • 常用的字串函式
• list：列表
  • 將列表當做堆疊使用
  • 將列表當作佇列使用
• tuple：元組
• set：集合
  • 集合常用方法
• dict dictionary 字典
• 變數型別轉換
• 條件語句
• 迴圈語句
• 運算子
  • Python算術運算子
  • Python比較運算子
  • Python賦值運算子
  • Python位運算子：& | ^ ~ << >>
  • Python邏輯運算子：and、or、not
  • Python成員運算子
  • Python身份運算子
• 變數作用域

學習資料參考：菜鳥教程，廖雪峰

基礎

1. #!/usr/bin/python 檔案頂部指定直譯器的路徑。可以讓檔案直接在Unix/Linux/Mac上執行。

• 這種指定指的是使用 ./main.py 直接執行時。
• 而使用 python ./main.py 該行程式碼會被忽略。

2. 預設以 utf-8 編碼。自定義編碼如下：

# -*- coding: cp-1252 -*-

3. 識別符號：
   字母或下劃線 _ 開頭；整個由字母、數字和下劃線組成

• python 3 以後可以使用非 ASCII 字元，即中文等作為變數名。
• 大小寫敏感

4. 註釋

# 單行註釋

"""
多行註釋1
"""

'''
多行註釋2
'''

• 使用三引號也可以包裹多行字串

5. 多行語句：

>>> print('''line1
... line2
... line3''')
 

line1
line2
line3

以上是命令列模式中，儲存檔案中的直接換行，不需要三個句號連線。

total = item_one + \
        item_two + \
        item_three
# 而有括號[]、()、{}的可不用反斜槓
total =  ['item_one',  'item_two',  'item_three',  'item_four',  'item_five']
print("first",
	"too long") # 這裡貌似沒有縮排要求

6. 在一行中使用多條語句，使用 ; 分隔。
7. 程式碼塊使用縮排表示，不要求縮排數量，但是要求同一程式碼塊必須有相同的縮排。
8. 函式之間、類之間使用空行間隔，比較具有可讀性。非強制，但很推薦。
9. print() 中使用逗號分隔多個引數，會使前後兩個字元中間自動新增空格。

• 它預設結尾換行，不換行：print("結尾不換行", end="")
• 就是將結尾刪除掉了，這裡還可以將結尾換成任意字元
• 注意： + 連線只能列印字串型別，如果接上數字就會報錯

first = 1
print("報錯,無法列印" + first)
# TypeError: can only concatenate str (not "int") to str

11. 布林值：True，False（注意大小寫，值為1、0，可以進行運算）
12. java 中的 &&，||，! 變成：and or not
13. null 變成 None
14. Python 是動態語言，型別不固定，定義變數前不需要宣告型別

a = 'ABC'
b = a
a = 'XYZ'
print(b)

結果：

ABC

15. Python 中沒有常量這一說法，都是可以被改變的。但也可以使用大寫名稱來表示是一個不應該被修改的量（我們思想上預設為常量~）
16. 與 java 不同，Python 中，兩個整數使用 / 進行除法運算，結果是浮點數，帶小數點。
    而 //，稱地板除，則與 java 中的 / 相似。整數相除只能得到整數結果。
17. Python 的整數浮點數沒有限制大小，但是太大了會表示為 inf（無限大）
18. Python 中沒有自增，裡面的數字型別是不可變資料。

基本資料型別

賦值

1. 為多個變數賦相同值：

a = b = c =  1

• 建立一個整型物件，值為 1，從後向前賦值，三個變數被賦予相同的數值。

2. 多個變數，各自賦值：（先計算右邊，再賦值給左邊，適合條件可以少寫一個變數）

a, b, c =  1,  2,  "runoob"

• 兩個整型物件 1 和 2 的分配給變數 a 和 b，字串物件 "runoob" 分配給變數 c。

3. del：解除變數的引用

del var1[,var2[,var3[....,varN]]]

總覽

Python 3 中有六個標準的資料型別：

• Number（數字）：不可改
• String（字串）：不可改
• List（列表）：有序可重複
• Tuple（元組）：有序可重複，不可改
• Set（集合）：無序不可重複
• Dictionary（字典）：無序不可重複，相當於 Map，{"熱":"流汗"}

Python 3 的六個標準資料型別中：

• 不可變資料（3 個）：Number（數字）、String（字串）、Tuple（元組）；

• 可變資料（3 個）：List（列表）、Dictionary（字典）、Set（集合）。

• 對於可變物件，物件的操作不會重建物件，而對於不可變物件，每一次操作就重建新的物件：

def listChanged(a): # 列表
    a[0] = 2

a = [1]
listChanged(a)
print(a)

def numberChanged(a): # 字串結果相同，記憶體地址不一樣說明重新建立了物件
    a = 2

a = 1
numberChanged(a)
print(a)

[2]
1

• 經過進一步測試，列表、元組在函式內外，他們的記憶體地址都是一致，說明是傳遞了記憶體地址；（除元組外都是可變型別）
  而數字、字串等函式內外記憶體地址不一樣，說明重新建立了物件。（不可變型別）
• 利用：因此可以利用不可變型別的引數來避免資料被某函式所改變。

查詢變數型別

• type() 函式可以用來查詢變數所指的物件型別。不會顯示為父類型別。
• isinstance(a, int)：判斷 a 是不是 int 型別。

• 因此可以使用 type() 精準判斷型別。

type(123)==int

• isinstance() 會認為子類是一種父類型別。

字串

1. python 中與 java 不同，沒有字元，只有字串，且字串也是不可改變的。
2. + 與 *：

print("this " "is " "string") # 正常執行

this is string

print("this "  *  2  + "is")

this this is

• 用 + 運算子連線字串，用 * 運算子重複。

3. ord('字元')：獲取字元的整數表示。
4. chr(25591)：獲取數值的字元表示。
5. 將字元儲存到檔案時，需要轉為位元組，pyhton 中用 b'A' 表示位元組，字元使用 encode() 可以獲得相應的位元組。

'ABC'.encode('ascii') -> b'ABC'
'中文'.encode('utf-8') -> b'\xe4\xb8\xad\xe6\x96\x87'

• 注：中文無法使用 ascii 編碼的（ascii 無法編碼中文）。

6. 反過來使用 decode('utf-8') 解碼位元組流。

• 如果包含無法解碼的會報錯，使用 ignore 忽略：

b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')

7. 獲取字串長度：

len('計算我的字元長度')

• 如果是位元組，則會計算位元組數：

len(b'ABC')
# 得到3
len(b'\xe4\xb8\xad\xe6\x96\x87')
# 得到6
len('中文'.encode('utf-8'))
# 得到6

• 可見，一個英文通常佔一個位元組，一箇中文佔三個位元組。

8. 與 String.format() 相似，py 中是 %

'Hello, %s' % 'world'
# 得到 'Hello, world'
'Hi, %s, you have $%d.' % ('Michael', 1000000)
# 得到 'Hi, Michael, you have $1000000.'

• 有多個引數時，使用小括號
• %d：整數
  %f： 浮點數
  %s：字串
  %x：十六進位制整數
• 格式化整數和浮點數還可以指定是否補0和整數與小數的位數。
• %% 表示 % 字元。
• 也可以將 % 換成 .format()，它是替換原文字中的 {1}，{2} 等。

9. r'\n不是換行'：r 指 raw，即 raw string，自動轉義字串，使得裡面的斜槓不具轉義功能。這裡使得 \n 就是普通“反斜槓n”字元。
10. f-string 格式化字串：

str = f'其他字元{content:format}'

• {} 裡 content 可以為變數、表示式也可以為函式，裡面不能使用反斜槓轉義，因為它是相當於一小段程式碼嘛。
• {} 新增冒號 :，為前面的最後計算得到的字元進行格式化。

有關於格式化寫法：Python格式化字串f-string概覽_sunxb10的部落格-CSDN部落格

對齊相關格式描述符

數字符號相關格式描述符

注：僅適用於數值型別。

數字顯示方式相關格式描述符

寬度與精度相關格式描述符

示例：

t = "天氣不錯"
s = 2.456
print(f'你說：{t}，你有{s:.2f}塊錢')

• {t}：替換為變數 t 的值
• {s:.2f}：替換為 s 的值，並且保留兩位小數

你說：天氣不錯，你有2.46塊錢

常用的字串函式

• string.capitalize()：首字母大寫。
• str.strip([chars])：去除首尾指定字元，預設空格或換行符。lstrip()、rstrip() ：僅去除左右邊的。
• string.decode(encoding='UTF-8', errors='strict')：解碼字串，errors 是選擇出錯後的處理方式。
  string.encode(encoding='UTF-8', errors='strict')：編碼字串。
• string.endswith(obj, beg=0, end=len(string))：是否以指定字串結尾，範圍可選。
• string.count(str, beg=0, end=len(string))：返回 str 出現的次數，範圍可選。
• string.find(str, beg=0, end=len(string))：返回 str 出現的索引位置，不存在返回 -1，範圍可選。
• string.index(str, beg=0, end=len(string))：與 find() 類似，但是不存在會丟擲異常。
• string.isalnum()、string.isalpha()、string.isdecimal()、string.isdigit()、string.islower()、string.isnumeric()、string.isspace()、string.istitle()、string.isupper()：判斷字串的組成。
• string.join(seq)：以指定字元將序列拼接成字串。
  • 元組、列表、字典、字串，字典連線鍵。
• string.split(str="", num=string.count(str))：以指定字元拆成列表。可選指定次數。
• string.partition(str)：以 str 為界，拆分成三段，返回三元素的元組。不存在則只有一個元素，為整個字串本身。
• string.replace(str1, str2, num=string.count(str1))：將 str1 換成 str2，可選指定替換次數。
• string.translate(str, del="")：按照翻譯表替換裡面的字元。

from  string  import  maketrans  # 引用 maketrans 函式。
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!";
print str.translate(trantab); # th3s 3s str3ng 2x1mpl2....w4w!!!

list：列表

L = ['Apple', 123, True]

1. 有序可重複，相當於 java 的陣列
2. 可以用 L[-1] 獲取末尾的元素，-2 倒二，-3 倒三
3. 與字串有很多相同操作，擷取、* 複製、+ 連線。
4. 通過 if 'Apple' in L 來看是否存在該元素。
5. L.append('末尾新增元素')。
6. L.insert(1, '插入')：原來的元素和原來元素後面的元素一起後移一位。
7. L.pop()：刪除末尾元素，(i)：指定位置。
8. 與 java 規定不同，python 列表中的元素可以型別不同。
9. 多維列表：列表裡可以還有列表，且因型別可不同，還可以有普通的元素和列表在一起。
10. 和字串一樣，可以使用運算子 + 和 *，突顯 Python 的便利性。 （+ 有順序）。
11. del a[0] 根據索引刪除一個值。

將列表當做堆疊使用

先進後出（後進先出）：使用 list.append()、list.pop()。

將列表當作佇列使用

先進先出（後進後出）：使用 list.append()、list.leftpop()。
但是這樣效率不高，每次 list.leftpop()，列表剩餘全部元素就會移動一下。

tuple：元組

t = (1, 2)
t = 1, 2

1. 也是有序可重複的，但是無法被修改，沒有 insert 等方法。
2. 注意：t = (1) 表示的是 t = 1，不是元組，小括號這裡是計算符號。

• 使用 t = (1, ) 消除歧義。
• 使用 t = () 建立空元組。

3. 注意：無法被修改指的是，元組裡儲存各個元素的記憶體地址不變，如果裡面有一個列表，那麼這個列表的內容是可以更改的。

set：集合

結構與 list 相似，但是是無序的不可重複的，底層與 dict 相似，都是要計算 key 獲取位置。但是 set 不是鍵值對，跟 list 一樣只儲存一個值。

• 無序，不可重複的一種列表

s = set([1, 2, 2, 3])
s = {1, 2, 3}

{1, 2, 3}

1. 建立，是將 list 轉為 set，重複元素會被自動過濾
   • 建立空集合：set([])
   • {} 是建立空字典
2. add()，remove()
3. 集合的運算

print(a - b)  # a 和 b 的差集
print(a | b)  # a 和 b 的並集
print(a & b)  # a 和 b 的交集
print(a ^ b)  # a 和 b 中不同時存在的元素

ps：集合與數學中的集合相似，。。。已經有點忘了高中的知識了。【互異性，無序性】

互異性，無序性：數學集合_百度百科

集合常用方法

新增元素

setx.add(string|tuple|bool|number):void # 新增元素
setx.update(y [,z...]):void  # 新增元素，型別需為有子元素的 list|tuple|dict
setx.clear():void # 清空集合
setx.copy():set  # 深拷貝（指向新的記憶體地址）

刪除元素

setx.remove(y):void|KeyError  # 如刪除不存在的元素，有報錯
setx.discard(y):void # 刪除集合中指定的元素，不會報錯
setx.pop():mixed # 隨機刪除集合元素，並返回被刪除的元素

右全包含布林真：判斷 setx 集合的所有元素是否都包含在 sety 集合中

setx.issubset(sety):bool
>>> x =  {"a",  "b",  "c"}  
>>> y =  {"f",  "e",  "d",  "c",  "b",  "a"}
>>> x.issubset(y)  True

左全包含布林真: 判斷 sety 集合的所有元素是否都包含在原始 setx 的集合中

setx.issuperset(sety):bool  >>> x =  {"a",  "b",  "c"}  >>> y =  {"f",  "e",  "d",  "c",  "b",  "a"}  >>> y.issuperset(x)  True

右半包含布林取反：判斷集合 sety 中是否有集合 setx 的任一元素（包含返回 False，不包含返回 True）

setx.isdisjoint(sety):bool

合併集合（並集）：（注意：集合元素的去重、唯一性）

setx.union(sety [, setz...]):set
>>> x =  {"a",  "b",  "c"}
>>> y =  {"f",  "d",  "a"}
>>> z =  {"c",  "d",  "e"}
>>> x.union(y, z)
{'c',  'd',  'f',  'e',  'b',  'a'}

左包含差集: 返回集合的差集，即返回的集合元素包含在第一個集合 x 中，但不包含在第二個集合 y(方法的引數)中

setx.difference(sety):set

左引用刪除交集（無返回值，即直接修改原記憶體指向）

setx.difference_update(sety):void

>>> x,y
({'banana',  'cshit',  'vipkwd.com',  'alipay'},  {'google',  'runoob',  'facebook',  'alipay'})
>>> type(x.difference_update(y))
<class  'NoneType'>
>>> x,y
({'banana',  'cshit',  'vipkwd.com'},  {'google',  'runoob',  'facebook',  'alipay'})

左右差集：返回兩個集合中不重複的元素集合，即會移除兩個集合中都存在的元素

setx.symmetric_difference(sety):set

左引用刪除交集且引用追加右差集（引用操作，無返回值）

setx.symmetric_difference_update(sett):void

左右交集：返回兩個或更多集合中都包含的元素，即交集

setx.intersection(sety[, seyz....]):set

左引用交集

setx.intersection_update(sety):void

輔助理解：所有提到 “引用” 倆字的都是函式內部直接操作記憶體指向，故無返回值。

dict dictionary 字典

相當於 java 中的 map。

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d['Michael'])

95

d = dict(Runoob=1, Google=2, Taobao=3) # 只能這種形式，直接變數不行
print(d)

d = dict([('Runoob',  1),  ('Google',  2),  ('Taobao',  3)])
print(d)

{'Runoob': 1, 'Google': 2, 'Taobao': 3}

1. 與 HashMap 相似，是通過 key 計算儲存位置的，所以儲存讀取速度比較快。但是佔用記憶體大。

• key 是不可變的（需要它的 hash 值，而變數內容不同則 hash 應不同），因此 list 不能作為 key。
• 因為是計算 key確定儲存位置的，所以 key 是唯一的，想“新增”也都會變成“修改”。

2. 通過 if 'Thomas' in d 來看是否存在該 key。
3. 不存在的情況：d.get('Anny') 返回 'None'；
   • d.get('Anny', -1) 返回自己給的預設值 -1。
4. pop('Bob')：刪除指定 key 和和該 key 下的 value。
5. 有關迭代，見另一筆記

變數型別轉換

條件語句

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

1. 使用縮排區分程式碼塊
2. 冒號不可忘：elif :
3. 簡寫：

if x:
    print('True')

只要 x 是非零數值、非空字串、非空 list 等，就判斷為 True，否則為 False。
4. 使用 int('4') 將字串轉為數值

迴圈語句

1. java 中的增強 for 迴圈，: 變成 in

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

Michael
Bob
Tracy

list(range(5))

[0, 1, 2, 3, 4]

• range(5)：生成 0-4 的整數
• list()：轉化為列表

3. while 迴圈，相似。

• break 打斷，continue 跳到下一個迴圈。

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

運算子

Python算術運算子

**：次方，幾次冪。2**3 值為 8。
//：取整除。向下取接近商的整數。9//2 得 4。

Python比較運算子

Python賦值運算子

海象運算子：在這個示例中，賦值表示式可以避免呼叫 len() 兩次:

if  (n := len(a))  >  10:
    print(f"List is too long ({n} elements, expected <= 10)")

• 省略我們中間賦值的步驟

while (block := f.read(256)) != '':
    process(block)

把運算子後面的表示式賦值給變數，然後將這個變數拿來使用，作為判斷的條件。

Python位運算子：& | ^ ~ << >>

Python邏輯運算子：and、or、not

Python成員運算子

in：如果在指定的序列中找到值返回 True，否則返回 False。（字串，列表，元組）
not in

Python身份運算子

is：判斷兩個識別符號是不是引用自一個物件。（類似 id(x) == id(y)）
is not

變數作用域

TODO
UnboundLocalError: local variable 'count' referenced before assignment