零基礎學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 運算子優先順序
- 以下表格的算數優先順序由高到最低順序排列：
- 作業系統會首先讓 CPU 把 Python 直譯器 的程式複製到 記憶體 中
- Python 直譯器 根據語法規則，從上向下 讓 CPU 翻譯 Python 程式中的程式碼
- 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)
<補>不同型別變數之間的計算
- 數字型變數 之間可以直接計算
- 在 Python 中，兩個數字型變數是可以直接進行 算數運算的
- 如果變數是 bool 型，在計算時
- True 對應的數字是 1
- False 對應的數字是 0
- 字串變數 之間使用 + 拼接字串
- 字串變數 可以和 整數 使用 * 重複拼接相同的字串
- 數字型變數 和 字串 之間 不能進行其他計算
<補>從鍵盤獲取輸入資訊：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 中的 識別符號 是 區分大小寫的
- 在定義變數時，為了保證程式碼格式，= 的左右應該各保留一個空格
- 在 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 的 列表 中可以 儲存不同型別的資料
- 但是在開發中，更多的應用場景是
- 列表 儲存相同型別的資料
- 通過 迭代遍歷，在迴圈體內部，針對列表中的每一項元素，執行相同的操作
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，如果連續切片，數字和冒號都可以省略
<補>索引的順序和倒序
- 在 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 只能使用不可變型別的資料
注意
- 可變型別的資料變化，是通過 方法 來實現的
- 如果給一個可變型別的變數，賦值了一個新的資料，引用會修改變數 不再 對之前的資料引用
- 變數 改為 對新賦值的資料引用
<補>雜湊 (hash)
- Python 中內建有一個名字叫做 hash(o) 的函式：接收一個 不可變型別 的資料作為 引數，返回 結果是一個 整數。
- 雜湊 是一種 演算法，其作用就是提取資料的 特徵碼（指紋），相同的內容 得到 相同的結果，不同的內容 得到 不同的結果。
- 在 Python 中，設定字典的 鍵值對 時，會首先對 key 進行 hash 已決定如何在記憶體中儲存字典的資料，以方便 後續 對字典的操作：增、刪、改、查：鍵值對的 key 必須是不可變型別資料，鍵值對的 value 可以是任意型別的資料。
4.4.5.7 區域性變數和全域性變數
- 區域性變數 是在 函式內部 定義的變數，只能在函式內部使用；函式執行結束後，函式內部的區域性變數，會被系統回收；不同的函式，可以定義相同的名字的區域性變數，但是 彼此之間 不會產生影響；區域性變數一般臨時 儲存 函式內部需要使用的資料。
- 全域性變數 是在 函式外部定義 的變數（沒有定義在某一個函式內），所有函式 內部 都可以使用這個變數。
提示：在其他的開發語言中，大多 不推薦使用全域性變數 —— 可變範圍太大，導致程式不好維護！
注意：函式執行時，需要處理變數時 會：
- 首先 查詢 函式內部 是否存在 指定名稱 的區域性變數，如果有，直接使用
- 如果沒有，查詢 函式外部 是否存在 指定名稱 的全域性變數，如果有，直接使用
- 如果還沒有，程式報錯！
注意：函式不能直接修改全域性變數的引用，如果要修改，必須要用global宣告該變數是全域性變數。
注意：為了避免區域性變數和全域性變量出現混淆，在定義全域性變數時，有些公司會有一些開發要求，例如：全域性變數名前應該增加 g_ 或者 gl_ 的字首。
5. 判斷（分支）
5.1 if 語句語法
1、if 判斷語句基本語法：
if 要判斷的條件: 條件成立時，要做的事情 ……
注意：程式碼的縮排為一個 tab 鍵，或者 4 個空格 —— 建議使用空格
- 在 Python 開發中，Tab 和空格不要混用！
2、如果需要在 不滿足條件的時候，做某些事情，該如何做呢？
if 要判斷的條件: 條件成立時，要做的事情 …… else: 條件不成立時，要做的事情 ……
- 在程式開發中，通常 在判斷條件時，會需要同時判斷多個條件，只有多個條件都滿足，才能夠執行後續程式碼，這個時候需要使用到 邏輯運算子。
- Python 中的 邏輯運算子 包括：與 and／或 or／非 not 三種
條件1 and 條件2 ：兩個條件同時滿足，返回 True 條件1 or 條件2：兩個條件只要有一個滿足，返回 True not 條件：非，不是
3、如果希望 再增加一些條件，條件不同，需要執行的程式碼也不同 時，就可以使用 elif ：
if 條件1: 條件1滿足執行的程式碼 …… elif 條件2: 條件2滿足時，執行的程式碼 …… elif 條件3: 條件3滿足時，執行的程式碼 …… else: 以上條件都不滿足時，執行的程式碼 ……
注意
- elif 和 else 都必須和 if 聯合使用，而不能單獨使用
- 可以將 if、elif 和 else 以及各自縮排的程式碼，看成一個 完整的程式碼塊
4、在開發中，使用 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
<補>字串中的轉義字元
- 在控制檯輸出一個 製表符，協助在輸出文字時 垂直方向 保持對齊
- 在控制檯輸出一個 換行符
製表符 的功能是在不使用表格的情況下在 垂直方向 按列對齊文字