零基礎學python，看完這篇文章，你的python基礎就差很少了！乾貨【2】

3. 運算符

3.1 算數運算符

是完成基本的算術運算使用的符號，用來處理四則運算，而「+」和「*」還能夠用來處理字符串。

 

3.2 比較（關係）運算符

 

• Python 2.x 中判斷 不等於 還可使用 <> 運算符
• != 在 Python 2.x 中一樣能夠用來判斷 不等於

3.3 賦值運算符

• 在 Python 中，使用 = 能夠給變量賦值。在算術運算時，爲了簡化代碼的編寫，Python 還提供了一系列的 與 算術運算符 對應的 賦值運算符，注意：賦值運算符中間不能使用空格。

 

3.4 身份運算符

身份運算符比較兩個對象的內存位置。經常使用的有兩個身份運算符，以下所述：

 

辨析

• is 用於判斷 兩個變量引用的對象是否爲同一個
• == 用於判斷 引用變量的值 是否相等

3.5 成員運算符

Python成員運算符測試給定值是否爲序列中的成員。 有兩個成員運算符，以下所述：

 

3.6 邏輯運算符

 

3.7 運算符優先級

• 如下表格的算數優先級由高到最低順序排列：

 

 

1. 操做系統會首先讓 CPU 把 Python 解釋器 的程序複製到 內存 中
2. Python 解釋器 根據語法規則，從上向下 讓 CPU 翻譯 Python 程序中的代碼
3. CPU 負責執行翻譯完成的代碼

Python 的解釋器有多大？

• 執行如下終端命令能夠查看 Python 解釋器的大小

# 1. 確認解釋器所在位置
$ which python
# 2. 查看 python 文件大小(只是一個軟連接)
$ ls -lh /usr/bin/python
# 3. 查看具體文件大小
$ ls -lh /usr/bin/python2.7

4. 變量

4.1 變量定義

• 在 Python 中，每一個變量 在使用前都必須賦值，變量 賦值之後 該變量 纔會被建立
• 能夠用 其餘變量的計算結果 來定義變量
• 變量名 只有在 第一次出現 纔是 定義變量

變量名 = 值

使用交互式方式，若是要查看變量內容，直接輸入變量名便可，不須要使用 print 函數

使用解釋器執行，若是要輸出變量的內容，必需要要使用 print 函數

4.2 變量的類型

• 在 Python 中定義變量是 不須要指定類型（在其餘不少高級語言中都須要），Python 能夠根據 = 等號右側的值，自動推導出變量中存儲數據的類型
• 數據類型能夠分爲 數字型 和 非數字型數字型
• 整型 (int)：Python3中的全部整數都表示爲長整數。 所以，長整數沒有單獨的數字類型。
• 浮點型（float）
• 布爾型（bool） ：真 True 非 0 數 —— 非零即真，假 False 0。
• 複數型 (complex)：複數是由x + yj表示的有序對的實數浮點數組成，其中x和y是實數，j是虛數單位。
• 非數字型：有些運算符還支持這些數據類型，詳見4.4.5.3 運算符。
• 字符串（str）：加號(+)是字符串鏈接運算符，星號(*)是重複運算符。
• 列表（list）
• 元組（tuple）
• 字典（dict）

提示：在 Python 2.x 中，整數 根據保存數值的長度還分爲：

• int（整數）
• long（長整數）
• 使用 type 函數能夠查看一個變量的類型

In [1]: type(name)

<補>不一樣類型變量之間的計算

1. 數字型變量 之間能夠直接計算

• 在 Python 中，兩個數字型變量是能夠直接進行 算數運算的
• 若是變量是 bool 型，在計算時
• True 對應的數字是 1
• False 對應的數字是 0

1. 字符串變量 之間使用 + 拼接字符串
2. 字符串變量 能夠和 整數 使用 * 重複拼接相同的字符串
3. 數字型變量 和 字符串 之間 不能進行其餘計算

<補>從鍵盤獲取輸入信息：input

• 在 Python 中可使用 input 函數從鍵盤等待用戶的輸入
• 用戶輸入的 任何內容 Python 都認爲是一個 字符串

字符串變量 = input("提示信息：")

<補>類型轉換函數

 

price = float(input("請輸入價格:"))

<補>格式化輸出：print

• 若是但願輸出文字信息的同時，一塊兒輸出 數據，就須要使用到 格式化操做符
• % 被稱爲 格式化操做符，專門用於處理字符串中的格式
• 包含 % 的字符串，被稱爲 格式化字符串
• % 和不一樣的 字符 連用，不一樣類型的數據 須要使用 不一樣的格式化字符

 

• 語法格式以下：

print("格式化字符串" % 變量1)
print("格式化字符串" % (變量1, 變量2...))

4.3 變量的命名

4.3.1 標識符和關鍵字

標示符就是程序員定義的 變量名、函數名

• 標示符能夠由 字母、下劃線 和 數字 組成
• 不能以數字開頭
• 不能與關鍵字重名

關鍵字 就是在 Python 內部已經使用的標識符

• 關鍵字 具備特殊的功能和含義
• 開發者 不容許定義和關鍵字相同的名字的標識符
• 經過如下命令能夠查看 Python 中的關鍵字

In [1]: import keyword
In [2]: print(keyword.kwlist)

4.3.2 變量的命名規則

命名規則 能夠被視爲一種 慣例，並沒有絕對與強制

目的是爲了 增長代碼的識別和可讀性

注意 Python 中的 標識符 是 區分大小寫的

1. 在定義變量時，爲了保證代碼格式，= 的左右應該各保留一個空格
2. 在 Python 中，若是 變量名 須要由 二個 或 多個單詞 組成時，能夠按照如下方式命名：每一個單詞都使用小寫字母，單詞與單詞之間使用 _下劃線 鏈接，例如：first_name、last_name、qq_number、qq_password。

固然，還有駝峯命名法：

小駝峯式命名法：第一個單詞以小寫字母開始，後續單詞的首字母大寫，例如：firstName、lastName。

大駝峯式命名法，每個單詞的首字母都採用大寫字母，例如：FirstName、LastName、CamelCase 。

4.4 高級變量類型

在 Python 中，全部 非數字型變量 都支持如下特色：

1. 都是一個 序列 sequence，也能夠理解爲 容器

2. 取值 []

3. 遍歷 for in

4. 計算長度len、最大/最小值max/min、比較、刪除del

5. 連接 + 和 重複 *

6. 切片

4.4.1 列表（list）

• List（列表） 是 Python 中使用 最頻繁 的數據類型，在其餘語言中一般叫作 數組，專門用於存儲 一串 信息，列表用 [] 定義，數據 之間使用 , 分隔，列表的 索引 從 0 開始。

索引 就是數據在 列表 中的位置編號，索引 又能夠被稱爲 下標

注意：從列表中取值時，若是 超出索引範圍，程序會報錯

name_list = ["zhangsan", "lisi", "wangwu"]

 

<補>del 關鍵字

• 使用 del 關鍵字(delete) 一樣能夠刪除列表中元素
• del 關鍵字本質上是用來 將一個變量從內存中刪除的
• 若是使用 del 關鍵字將變量從內存中刪除，後續的代碼就不能再使用這個變量了

In [1]: l = [1,2,3,4]
In [2]: del l[1]
In [3]: l[1]
Out[3]: 3

在平常開發中，要從列表刪除數據，建議 使用列表提供的方法

<補>函數與方法

• 函數 封裝了獨立功能，能夠直接調用

函數名(參數)

函數須要死記硬背

• 方法 和函數相似，一樣是封裝了獨立的功能
• 方法 須要經過 對象 來調用，表示針對這個 對象 要作的操做

對象.方法名(參數)

在變量後面輸入 .，而後選擇針對這個變量要執行的操做，記憶起來比函數要簡單不少

<補>循環遍歷

• 遍歷 就是 從頭至尾 依次 從 列表 中獲取數據，在 循環體內部 針對 每個元素，執行相同的操做。
• 在 Python 中爲了提升列表的遍歷效率，使用 for 就可以實現迭代遍歷。

# for 循環內部使用的變量 in 列表
for name in name_list:
 循環內部針對列表元素進行操做
 print(name)

 

for-in循環流程圖

• 儘管 Python 的 列表 中能夠 存儲不一樣類型的數據
• 可是在開發中，更多的應用場景是

1. 列表 存儲相同類型的數據
2. 經過 迭代遍歷，在循環體內部，針對列表中的每一項元素，執行相同的操做

4.4.2 元組（tuple）

• Tuple（元組）與列表相似，不一樣之處在於元組的 元素不能修改元組 表示多個元素組成的序列
• 元組 在 Python 開發中，有特定的應用場景
• 用於存儲 一串 信息，數據 之間使用 , 分隔
• 元組用 () 定義，元組的 索引 從 0 開始，索引 就是數據在 元組 中的位置編號。

info_tuple = ("zhangsan", 18, 1.75)

建立空元組：

info_tuple = ()

元組中 只包含一個元素 時，須要 在元素後面添加逗號：

info_tuple = (50, )

 

元組示意圖

• 在 Python 中，可使用 for 循環遍歷全部非數字型類型的變量：列表、元組、字典以及 字符串
• 提示：在實際開發中，除非 可以確認元組中的數據類型，不然針對元組的循環遍歷需求並非不少
• 在開發中，更多的應用場景是：
• 函數的 參數 和 返回值，一個函數能夠接收 任意多個參數，或者 一次返回多個數據
• 格式字符串，格式化字符串後面的 () 本質上就是一個元組
• 讓列表不能夠被修改，以保護數據安全

<補>元組和列表之間的轉換

• 使用 list 函數能夠把元組轉換成列表

list(元組)

• 使用 tuple 函數能夠把列表轉換成元組

tuple(列表)

4.4.3 字典（dict）

dict（字典） 是 除列表之外 Python 之中 最靈活 的數據類型。

字典一樣能夠用來 存儲多個數據，一般用於存儲 描述一個 物體 的相關信息

• 和列表的區別：
• 列表 是 有序 的對象集合
• 字典 是 無序 的對象集合
• 字典用 {} 定義。
• 字典使用 鍵值對 存儲數據，鍵值對之間使用逗號 , 分隔：
• 鍵 key 是索引
• 值 value 是數據
• 鍵 和 值 之間使用冒號 : 分隔
• 鍵必須是惟一的
• 值 能夠取任何數據類型，但 鍵 只能使用 字符串、數字或 元組

xiaoming = {"name": "小明",
 "age": 18,
 "gender": True,
 "height": 1.75}

 

• 字典的遍歷 就是 依次 從 字典 中獲取全部鍵值對：

# for 循環內部使用的 `key 的變量` in 字典
for k in xiaoming:
 print("%s: %s" % (k, xiaoming[k]))

提示：在實際開發中，因爲字典中每個鍵值對保存數據的類型是不一樣的，因此針對字典的循環遍歷需求並非不少

• 儘管可使用 for in 遍歷 字典
• 可是在開發中，更多的應用場景是：
• 使用 多個鍵值對，存儲 描述一個 物體 的相關信息 —— 描述更復雜的數據信息
• 將 多個字典 放在 一個列表 中，再進行遍歷，在循環體內部針對每個字典進行 相同的處理

card_list = [{"name": "張三",

"qq": "12345",

"phone": "110"},

{"name": "李四",

"qq": "54321",

"phone": "10086"}

]

4.4.4 字符串（str）

• 字符串 就是 一串字符，是編程語言中表示文本的數據類型
• 在 Python 中可使用 一對雙引號 " 或者 一對單引號 ' 定義一個字符串
• 雖然可使用 " 或者 ' 作字符串的轉義，可是在實際開發中：
• 若是字符串內部須要使用 "，可使用 ' 定義字符串
• 若是字符串內部須要使用 '，可使用 " 定義字符串
• 可使用 索引 獲取一個字符串中 指定位置的字符，索引計數從 0 開始
• 也可使用 for 循環遍歷 字符串中每個字符

大多數編程語言都是用 " 來定義字符串

string = "Hello Python"
for c in string:
 print(c)

 

提示：在 python 中對字符串操做，內置提供的方法足夠多，使得在開發時，可以針對字符串進行更加靈活的操做！應對更多的開發需求！

1) 判斷類型 - 9

 

2) 查找和替換 - 7

 

3) 大小寫轉換 - 5

 

4) 文本對齊 - 3

 

5) 去除空白字符 - 3

 

6) 拆分和鏈接 - 5

 

<補>字符串的切片

• 切片 方法適用於 字符串、列表、元組切片 使用 索引值 來限定範圍，從一個大的 字符串 中 切出 小的 字符串
• 列表 和 元組 都是 有序 的集合，都可以 經過索引值 獲取到對應的數據
• 字典 是一個 無序 的集合，是使用 鍵值對 保存數據

 

字符串[開始索引:結束索引:步長]

注意：

• 指定的區間屬於 左閉右開 型 [開始索引, 結束索引) => 開始索引 <= 範圍 < 結束索引從 起始 位開始，到 結束位的前一位 結束（不包含結束位自己)

1. 從頭開始，開始索引 數字能夠省略，冒號不能省略
2. 到末尾結束，結束索引 數字能夠省略，冒號不能省略
3. 步長默認爲 1，若是連續切片，數字和冒號均可以省略

<補>索引的順序和倒序

• 在 Python 中不只支持 順序索引，同時還支持 倒序索引
• 所謂倒序索引就是 從右向左 計算索引：最右邊的索引值是 -1，依次遞減。

num_str = "0123456789"
# 1. 截取從 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取從 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取從 `開始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 從開始位置，每隔一個字符截取字符串
print(num_str[::2])
# 6. 從索引 1 開始，每隔一個取一個
print(num_str[1::2])
# 倒序切片
# -1 表示倒數第一個字符
print(num_str[-1])
# 7. 截取從 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾兩個字符
print(num_str[-2:])
# 9. 字符串的逆序（面試題）
print(num_str[::-1])

4.4.5 公共方法和變量的高級應用

4.4.5.1 內置函數

Python 包含了如下內置函數：

 

注意：字符串 比較符合如下規則： "0" < "A" < "a"。

4.4.5.2 切片

 

• 切片 使用 索引值 來限定範圍，從一個大的 字符串 中 切出 小的 字符串
• 列表 和 元組 都是 有序 的集合，都可以 經過索引值 獲取到對應的數據
• 字典 是一個 無序 的集合，是使用 鍵值對 保存數據

4.4.5.3 運算符

 

注意

• in 在對 字典 操做時，判斷的是 字典的鍵
• in 和 not in 被稱爲 成員運算符

4.4.5.4 內置函數完整的 for 循環語法

• 在 Python 中完整的 for 循環 的語法以下：

for 變量 in 集合:
 
 循環體代碼
else:
 沒有經過 break 退出循環，循環結束後，會執行的代碼

應用場景：

• 在 迭代遍歷 嵌套的數據類型時，例如 一個列表包含了多個字典
• 需求：要判斷 某一個字典中 是否存在 指定的 值
• 若是 存在，提示而且退出循環
• 若是 不存在，在 循環總體結束 後，但願 獲得一個統一的提示

4.4.5.5 變量的引用

• 變量 和 數據 都是保存在 內存 中的
• 在 Python 中 函數 的 參數傳遞 以及 返回值 都是靠 引用 傳遞的

在 Python 中：變量 和 數據 是分開存儲的，數據 保存在內存中的一個位置，變量 中保存着數據在內存中的地址，就叫作 引用，使用 id() 函數能夠查看變量中保存數據所在的 內存地址。

注意：若是變量已經被定義，當給一個變量賦值的時候，本質上是 修改了數據的引用

• 變量 再也不 對以前的數據引用
• 變量 改成 對新賦值的數據引用

在 Python 中，變量的名字相似於 便籤紙 貼在 數據 上：

• 定義一個整數變量 a，而且賦值爲 1

在 Python 中，函數的 實參/返回值 都是是靠 引用 來傳遞來的

結果

結果

4.4.5.6 可變和不可變類型

• 不可變類型，內存中的數據不容許被修改：
• 數字類型 int, bool, float, complex, long(2.x)
• 字符串 str
• 元組 tuple
• 可變類型，內存中的數據能夠被修改：
• 列表 list
• 字典 dict

注意：字典的 key 只能使用不可變類型的數據

注意

1. 可變類型的數據變化，是經過 方法 來實現的

• 若是給一個可變類型的變量，賦值了一個新的數據，引用會修改變量 再也不 對以前的數據引用
• 變量 改成 對新賦值的數據引用

<補>哈希 (hash)

• Python 中內置有一個名字叫作 hash(o) 的函數：接收一個 不可變類型 的數據做爲 參數，返回 結果是一個 整數。
• 哈希 是一種 算法，其做用就是提取數據的 特徵碼（指紋），相同的內容 獲得 相同的結果，不一樣的內容 獲得 不一樣的結果。
• 在 Python 中，設置字典的 鍵值對 時，會首先對 key 進行 hash 已決定如何在內存中保存字典的數據，以方便 後續 對字典的操做：增、刪、改、查：鍵值對的 key 必須是不可變類型數據，鍵值對的 value 能夠是任意類型的數據。

4.4.5.7 局部變量和全局變量

• 局部變量 是在 函數內部 定義的變量，只能在函數內部使用；函數執行結束後，函數內部的局部變量，會被系統回收；不一樣的函數，能夠定義相同的名字的局部變量，可是 彼此之間 不會產生影響；局部變量通常臨時 保存 函數內部須要使用的數據。
• 全局變量 是在 函數外部定義 的變量（沒有定義在某一個函數內），全部函數 內部 均可以使用這個變量。

提示：在其餘的開發語言中，大多 不推薦使用全局變量 —— 可變範圍太大，致使程序很差維護！

注意：函數執行時，須要處理變量時 會：

1. 首先 查找 函數內部 是否存在 指定名稱 的局部變量，若是有，直接使用
2. 若是沒有，查找 函數外部 是否存在 指定名稱 的全局變量，若是有，直接使用
3. 若是尚未，程序報錯！

注意：函數不能直接修改全局變量的引用，若是要修改，必需要用global聲明該變量是全局變量。

 

注意：爲了不局部變量和全局變量出現混淆，在定義全局變量時，有些公司會有一些開發要求，例如：全局變量名前應該增長 g_ 或者 gl_ 的前綴。

5. 判斷（分支）

5.1 if 語句語法

一、if 判斷語句基本語法：

if 要判斷的條件:
 條件成立時，要作的事情
 ……

注意：代碼的縮進爲一個 tab 鍵，或者 4 個空格 —— 建議使用空格

• 在 Python 開發中，Tab 和空格不要混用！

二、若是須要在 不知足條件的時候，作某些事情，該如何作呢？

if 要判斷的條件:
 條件成立時，要作的事情
 ……
else:
 條件不成立時，要作的事情
 ……

• 在程序開發中，一般 在判斷條件時，會須要同時判斷多個條件，只有多個條件都知足，纔可以執行後續代碼，這個時候須要使用到 邏輯運算符。
• Python 中的 邏輯運算符 包括：與 and／或 or／非 not 三種

條件1 and 條件2 ：兩個條件同時知足，返回 True
條件1 or 條件2：兩個條件只要有一個知足，返回 True
not 條件：非，不是

三、若是但願 再增長一些條件，條件不一樣，須要執行的代碼也不一樣 時，就可使用 elif ：

if 條件1:
 條件1知足執行的代碼
 ……
elif 條件2:
 條件2知足時，執行的代碼
 ……
elif 條件3:
 條件3知足時，執行的代碼
 ……
else:
 以上條件都不知足時，執行的代碼
 ……

注意

• elif 和 else 都必須和 if 聯合使用，而不能單獨使用
• 能夠將 if、elif 和 else 以及各自縮進的代碼，當作一個 完整的代碼塊

四、在開發中，使用 if 進行條件判斷，若是但願 在條件成立的執行語句中 再 增長條件判斷，就可使用 if 的嵌套：

if 條件 1:
 條件 1 知足執行的代碼
 ……
 
 if 條件 1 基礎上的條件 2:
 條件 2 知足時，執行的代碼
 …… 
 
 # 條件 2 不知足的處理
 else:
 條件 2 不知足時，執行的代碼
 
# 條件 1 不知足的處理
else:
 條件1 不知足時，執行的代碼
 ……

5.2 if語句的應用

5.2.1 隨機數的處理

• 在 Python 中，要使用隨機數，首先須要導入 隨機數 的 模塊 —— 「工具包」

import random

• 導入模塊後，能夠直接在 模塊名稱 後面敲一個 . 而後按 Tab 鍵，會提示該模塊中包含的全部函數
• random.randint(a, b) ，返回 [a, b] 之間的整數，包含 a 和 b
• 例如：

random.randint(12, 20) # 生成的隨機數n: 12 <= n <= 20 
random.randint(20, 20) # 結果永遠是 20 
random.randint(20, 10) # 該語句是錯誤的，下限必須小於上限

5.2.2 石頭剪刀布

# 導入隨機工具包
# 注意：在導入工具包的時候，應該將導入的語句，放在文件的頂部
# 由於，這樣能夠方便下方的代碼，在任何須要的時候，使用工具包中的工具
import random
# 從控制檯輸入要出的拳 —— 石頭（1）／剪刀（2）／布（3）
player = int(input("請輸入您要出的拳 石頭（1）／剪刀（2）／布（3）："))
# 電腦 隨機 出拳 —— 先假定電腦只會出石頭，完成總體代碼功能
computer = random.randint(1, 3)
print("玩家選擇的拳頭是 %d - 電腦出的拳是 %d" % (player, computer))
# 比較勝負
# 1 石頭 勝 剪刀
# 2 剪刀 勝 布
# 3 布 勝 石頭
# if (()
# or ()
# or ()):
if ((player == 1 and computer == 2)
 or (player == 2 and computer == 3)
 or (player == 3 and computer == 1)):
 print("歐耶，電腦弱爆了！")
# 平局
elif player == computer:
 print("真是心有靈犀啊，再來一盤")
# 其餘的狀況就是電腦獲勝
else:
 print("不服氣，咱們決戰到天明！")

我剛整理了一套2018最新的0基礎入門和進階教程，無私分享，加Python學習qun ：227-435-450便可獲取，內附：開發工具和安裝包，以及系統學習路線圖

6. 循環

6.1 程序執行的三大流程

在程序開發中，一共有三種流程方式：

• 順序 —— 從上向下，順序執行代碼
• 分支 —— 根據條件判斷，決定執行代碼的 分支
• 循環 —— 讓 特定代碼 重複 執行

程序執行的三大流程

6.2 while 循環基本使用

while 語句基本語法：

初始條件設置 —— 一般是重複執行的 計數器
while 條件(判斷 計數器 是否達到 目標次數):
 條件知足時，作的事情1
 條件知足時，作的事情2
 條件知足時，作的事情3
 ...(省略)...
 
 處理條件(計數器 + 1)

因爲程序員的緣由，忘記 在循環內部 修改循環的判斷條件，致使循環持續執行，程序將陷入死循環而沒法終止！

計數器 +1 ：能夠經過賦值運算符簡化代碼的編寫。

常見的計數方法有兩種，能夠分別稱爲：

• 天然計數法（從 1 開始）—— 更符合人類的習慣
• 程序計數法（從 0 開始）—— 幾乎全部的程序語言都選擇從 0 開始計數

所以，你們在編寫程序時，應該儘可能養成習慣：除非需求的特殊要求，不然 循環 的計數都從 0 開始

6.3 break 和 continue

break 和 continue 是專門在循環中使用的關鍵字

• break ：某一條件知足時，退出循環，再也不執行後續的代碼
• continue ：某一條件知足時，不執行後續的代碼直接進入下一次循環
• break 和 continue 只針對 當前所在循環 有效

6.4 while 循環嵌套

• while 嵌套就是：while 裏面還有 while，每一次循環中還要作完一個循環。

while 條件 1:
 條件知足時，作的事情1
 條件知足時，作的事情2
 條件知足時，作的事情3
 ...(省略)...
 
 while 條件 2:
 條件知足時，作的事情1
 條件知足時，作的事情2
 條件知足時，作的事情3
 ...(省略)...
 
 處理條件 2
 
 處理條件 1

示例：

"""
打印 9 行小星星：
*
**
***
****
*****
******
*******
********
*********
"""
# 定義起始行
row = 1
# 最大打印 9 行
while row <= 9:
 # 定義起始列
 col = 1
 # 最大打印 row 列
 while col <= row:
 # end = ""，表示輸出結束後，不換行
 # "	" 能夠在控制檯輸出一個製表符，協助在輸出文本時對齊
 print("%d * %d = %d" % (col, row, row * col), end="	")
 # 列數 + 1
 col += 1
 # 一行打印完成的換行
 print("")
 # 行數 + 1
 row += 1

<補>字符串中的轉義字符

• 在控制檯輸出一個 製表符，協助在輸出文本時 垂直方向 保持對齊
• 在控制檯輸出一個 換行符

製表符 的功能是在不使用表格的狀況下在 垂直方向 按列對齊文本