寫在前面

2019年最新python教程

如果你處於想學python或者正在學習python，那麼你的python教程應該不少了吧，但是是最新的嗎？說不定你學的可能是兩年前人家就學過的內容，在這小編分享一波2019最新的python全套教程最後小編為大家準備了6月份新出的python自學視頻教程，共計415集，免費分享給大家！2019Python自學教程全新升級為《Python+數據分析+機器學習》，九大階段能力逐級提升，打造技能更全面的全棧工程師。請大家轉發本文+關注並私信小編：“資料”即可免費領取哦！

第一部分 Python基礎語法

第一部分 Python基礎語法1. 認識Python1.1 Python 簡介Python 的創始人為吉多·範羅蘇姆（Guido van Rossum）。

Python 的設計目標：

• 一門簡單直觀的語言並與主要競爭者一樣強大
• 開源，以便任何人都可以為它做貢獻
• 代碼像純英語那樣容易理解
• 適用於短期開發的日常任務

Python 的設計哲學：

• 優雅、明確、簡單

Python 開發者的哲學是：

Python 是完全面向對象的語言，在 Python 中一切皆對象。

可擴展性：如果需要一段關鍵代碼運行得更快或者希望某些算法不公開，可以把這部分程序用 C 或 C++ 編寫，然後在 Python 程序中使用它們。

1.2. 第一個Python程序執行 Python 程序的三種方式：解釋器、交互式運行、IDE運行Python 是一個格式非常嚴格的程序設計語言。python 2.x 默認不支持中文。

• ASCII 字符只包含 256 個字符，不支持中文
• Python 2.x 的解釋器名稱是 python
• Python 3.x 的解釋器名稱是 python3

為了照顧現有的程序，官方提供了一個過渡版本 ——

Python 2.6。

提示：如果開發時，無法立即使用 Python 3.0（還有極少的第三方庫不支持 3.0 的語法），建議

• 先使用 Python 3.0 版本進行開發
• 然後使用 Python 2.6、Python 2.7 來執行，並且做一些兼容性的處理

IPython 是一個 python 的

交互式 shell，比默認的 python shell 好用得多，它支持 bash shell 命令，適合於學習/驗證 Python 語法或者局部代碼。集成開發環境（IDE，Integrated Development Environment）——

集成了開發軟件需要的所有工具，一般包括以下工具：

• 圖形用戶界面
• 代碼編輯器（支持 代碼補全／自動縮進）
• 編譯器／解釋器
• 調試器（斷點／單步執行）
• ……

PyCharm 是 Python 的一款非常優秀的集成開發環境

PyCharm運行工具欄1.3. PyCharm 的設置PyCharm 的

配置信息

是保存在

用戶家目錄下

的 .PyCharmxxxx.x 目錄下的，xxxx.x 表示當前使用的 PyCharm 的版本號1.3.1 恢復 PyCharm 的初始設置：

1. 關閉正在運行的 PyCharm
2. 在終端中執行以下終端命令，刪除 PyCharm 的配置信息目錄：

<code>$ rm -r ~/.PyCharm2016.3/<code>

1. 重新啟動 PyCharm

1.3.2 PyCharm 安裝和啟動步驟：

1. 執行以下終端命令，解壓縮下載後的安裝包

<code>$ tar -zxvf pycharm-professional-2017.1.3.tar.gz/<code>

1. 將解壓縮後的目錄移動到 /opt 目錄下，可以方便其他用戶使用

/opt 目錄用戶存放給主機額外安裝的軟件

<code>$ sudo mv pycharm-2017.1.3/ /opt//<code>

1. 切換工作目錄

<code>$ cd /opt/pycharm-2017.1.3/bin/<code>

1. 啟動 PyCharm

<code>$ ./pycharm.sh/<code>

1.3.3 設置啟動圖標

• 在專業版中，選擇菜單 Tools / Create Desktop Entry... 可以設置任務欄啟動圖標
• 注意：設置圖標時，需要勾選 Create the entry for all users
• 快捷方式文件
• /usr/share/applications/jetbrains-pycharm.desktop

在 ubuntu 中，應用程序啟動的快捷方式通常都保存在 /usr/share/applications 目錄下

1.3.4 卸載之前版本的 PyCharm要卸載 PyCharm 只需要做以下兩步工作：

1. 刪除解壓縮目錄

<code>$ sudo rm -r /opt/pycharm-2016.3.1//<code>

1. 刪除家目錄下用於保存配置信息的隱藏目錄

<code>$ rm -r ~/.PyCharm2016.3//<code>

如果不再使用 PyCharm 還需要將 /usr/share/applications/ 下的 jetbrains-pycharm.desktop 刪掉

1.4. 多文件項目的演練

• 開發 項目 就是開發一個 專門解決一個複雜業務功能的軟件
• 通常每 一個項目 就具有一個 獨立專屬的目錄，用於保存 所有和項目相關的文件
• 在 PyCharm 中，要想讓哪一個 Python 程序能夠執行，必須首先通過 鼠標右鍵的方式執行
  一下
• 對於初學者而言，在一個項目中設置多個程序可以執行，是非常方便的，可以方便對不同知識點的練習和測試
• 對於商業項目而言，通常在一個項目中，只有一個 可以直接執行的 Python 源程序

讓選中的程序可以執行2. 註釋

• 註釋的作用
• 使用用自己熟悉的語言，在程序中對某些代碼進行標註說明，增強程序的可讀性

2.1 單行註釋（行註釋）

• 以 # 開頭，# 右邊的所有東西都被當做說明文字，而不是真正要執行的程序，只起到輔助說明作用

<code>print("hello python") # 輸出 `hello python`/<code>

為了保證代碼的可讀性，# 後面建議先添加一個空格，然後再編寫相應的說明文字；為了保證代碼的可讀性，註釋和代碼之間 至少要有 兩個空格。

2.2 多行註釋（塊註釋）

• 要在 Python 程序中使用多行註釋，可以用 一對 連續的 三個 引號(單引號和雙引號都可以)

<code>"""
這是一個多行註釋
在多行註釋之間，可以寫很多很多的內容…… 

""" 
print("hello python")/<code>

提示：

1. 註釋不是越多越好，對於一目瞭然的代碼，不需要添加註釋
2. 對於 複雜的操作，應該在操作開始前寫上若干行註釋
3. 對於 不是一目瞭然的代碼，應在其行尾添加註釋（為了提高可讀性，註釋應該至少離開代碼 2 個空格）
4. 絕不要描述代碼，假設閱讀代碼的人比你更懂 Python，他只是不知道你的代碼要做什麼

2.3 代碼規範：

• Python 官方提供有一系列 PEP（Python Enhancement Proposals） 文檔，其中第 8 篇文檔專門針對 Python 的代碼格式 給出了建議，也就是俗稱的 PEP 8：
• 文檔地址：https://www.python.org/dev/peps/pep-0008/
• 谷歌有對應的中文文檔：http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/

3. 運算符3.1 算數運算符是完成基本的算術運算使用的符號，用來處理四則運算，而“+”和“*”還可以用來處理字符串。運算符 描述 實例 + 加 10 + 20 = 30 - 減 10 - 20 = -10 * 乘 10 * 20 = 200 / 除 10 / 20 = 0.5 // 取整除 返回除法的整數部分（商） 9 // 2 輸出結果 4 % 取餘數 返回除法的餘數 9 % 2 = 1 ** 冪 又稱次方、乘方，2 ** 3 = 8 3.2 比較（關係）運算符

• 運算符 描述 == 檢查兩個操作數的值是否 相等，如果是，則條件成立，返回 True != 檢查兩個操作數的值是否 不相等，如果是，則條件成立，返回 True > 檢查左操作數的值是否 大於 右操作數的值，如果是，則條件成立，返回 True < 檢查左操作數的值是否 小於 右操作數的值，如果是，則條件成立，返回 True >= 檢查左操作數的值是否 大於或等於 右操作數的值，如果是，則條件成立，返回 True <= 檢查左操作數的值是否 小於或等於 右操作數的值，如果是，則條件成立，返回 True Python 2.x 中判斷
  不等於 還可以使用 <> 運算符
• != 在 Python 2.x 中同樣可以用來判斷 不等於

3.3 賦值運算符

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

運算符 描述 實例 = 簡單的賦值運算符 c = a + b 將 a + b 的運算結果賦值為 c += 加法賦值運算符 c += a 等效於 c = c + a -= 減法賦值運算符 c -= a 等效於 c = c - a *= 乘法賦值運算符 c *= a 等效於 c = c * a /= 除法賦值運算符 c /= a 等效於 c = c / a //= 取整除賦值運算符 c //= a 等效於 c = c // a %= 取

模

(餘數)賦值運算符 c %= a 等效於 c = c % a **= 冪賦值運算符 c **= a 等效於 c = c ** a 3.4 身份運算符身份運算符比較兩個對象的內存位置。常用的有兩個身份運算符，如下所述：運算符 描述 示例 is 判斷兩個標識符是不是引用同一個對象 x is y，類似 id(x) == id(y) is not 判斷兩個標識符是不是引用不同對象 x is not y，類似 id(a) != id(b)

辨析

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

3.5 成員運算符Python成員運算符測試給定值是否為序列中的成員。 有兩個成員運算符，如下所述：運算符 描述 in 如果在指定的序列中找到一個變量的值，則返回true，否則返回false。 not in 如果在指定序列中找不到變量的值，則返回true，否則返回false。 3.6 邏輯運算符運算符 邏輯表達式 描述 and x and y 只有 x 和 y 的值都為 True，才會返回 True否則只要 x 或者 y 有一個值為 False，就返回 False or x or y 只要 x 或者 y 有一個值為 True，就返回 True只有 x 和 y 的值都為 False，才會返回 False not not x 如果 x 為 True，返回 False如果 x 為 False，返回 True 3.7 運算符優先級

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

運算符 描述 ** 冪 (最高優先級) * / % // 乘、除、取餘數、取整除 + - 加法、減法 <= < > >= 比較運算符 == != 等於運算符 = %= /= //= -= += *= **= 賦值運算符 is is not 身份運算符 in not in 成員運算符 not or and 邏輯運算符 程序執行原理

Python程序執行示意圖

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

Python 的解釋器有多大？

• 執行以下終端命令可以查看 Python 解釋器的大小

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

4. 變量4.1 變量定義

• 在 Python 中，每個變量 在使用前都必須賦值，變量 賦值以後 該變量 才會被創建
• 可以用 其他變量的計算結果
  來定義變量
• 變量名 只有在 第一次出現 才是 定義變量

<code>變量名 = 值/<code>

使用交互式方式，如果要查看變量內容，直接輸入變量名即可，不需要使用 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 函數可以查看一個變量的類型

<code>In [1]: type(name)/<code> 

不同類型變量之間的計算

1. 數字型變量 之間可以直接計算

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

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

從鍵盤獲取輸入信息：input

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

<code>字符串變量 = input("提示信息：")/<code>

類型轉換函數

<code> 函數 說明 int(x) 將 x 轉換為一個整數 float(x) 將 x 轉換到一個浮點數 str(x) 將對象x轉換為字符串表示形式 tuple(s) 將s轉換為元組 list(s) 將s轉換為列表 price = float(input("請輸入價格:"))/<code>

格式化輸出：print

• 如果希望輸出文字信息的同時，一起輸出數據，就需要使用到 格式化操作符
• % 被稱為 格式化操作符，專門用於處理字符串中的格式
• 包含 % 的字符串，被稱為
  格式化字符串
• % 和不同的 字符 連用，不同類型的數據 需要使用 不同的格式化字符
• 格式化字符 含義 %s 字符串 %d 有符號十進制整數，%06d 表示輸出的整數顯示位數，不足的地方使用 0 補全 %f 浮點數，%.2f 表示小數點後只顯示兩位 %% 輸出 % 語法格式如下：

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

4.3 變量的命名4.3.1 標識符和關鍵字

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

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

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

• 關鍵字 具有特殊的功能和含義
• 開發者 不允許定義和關鍵字相同的名字的標識符
• 通過以下命令可以查看 Python 中的關鍵字

<code>In [1]: import keyword
In [2]: print(keyword.kwlist)/<code>

4.3.2 變量的命名規則

命名規則 可以被視為一種

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

當然，還有駝峰命名法：小駝峰式命名法：第一個單詞以小寫字母開始，後續單詞的首字母大寫，例如：firstName、lastName。大駝峰式命名法，每一個單詞的首字母都採用大寫字母，例如：FirstName、LastName、CamelCase 。4.4 高級變量類型在 Python 中，所有

非數字型變量

都支持以下特點：1. 都是一個

序列

sequence，也可以理解為

容器2.

取值

[]3.

遍歷

for in4.

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

鏈接

+ 和

重複

*6.

切片4.4.1 列表（list）

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

索引 就是數據在 列表 中的位置編號，索引 又可以被稱為 下標注意：從列表中取值時，如果 超出索引範圍，程序會報錯

<code>name_list = ["zhangsan", "lisi", "wangwu"]/<code>

列表示意圖del 關鍵字

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

<code>In [1]: l = [1,2,3,4]
In [2]: del l[1]
In [3]: l[1]
Out[3]: 3/<code>

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

函數與方法

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

<code>函數名(參數)/<code>

函數需要死記硬背

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

<code>對象.方法名(參數)/<code>

在變量後面輸入 .，然後選擇針對這個變量要執行的操作，記憶起來比函數要簡單很多

循環遍歷

• 遍歷 就是 從頭到尾依次 從 列表 中獲取數據，在 循環體內部 針對 每一個元素
  ，執行相同的操作。
• 在 Python 中為了提高列表的遍歷效率，使用 for 就能夠實現迭代遍歷。

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

for-in循環流程圖

• 儘管 Python 的 列表 中可以 存儲不同類型的數據
• 但是在開發中，更多的應用場景是

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

4.4.2 元組（tuple）

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

<code>info_tuple = ("zhangsan", 18, 1.75)/<code>

創建空元組：

<code>info_tuple = ()/<code>

元組中

只包含一個元素

時，需要

在元素後面添加逗號：

<code>info_tuple = (50, )/<code>

元組示意圖

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

元組和列表之間的轉換

• 使用 list 函數可以把元組轉換成列表

<code>list(元組) /<code>

• 使用 tuple 函數可以把列表轉換成元組

<code>tuple(列表)/<code>

4.4.3 字典（dict）dict（字典） 是

除列表以外

Python 之中

最靈活

的數據類型。字典同樣可以用來

存儲多個數據，通常用於存儲

描述一個 物體 的相關信息

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

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

字典示意圖

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

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

提示：在實際開發中，由於字典中每一個鍵值對保存數據的類型是不同的，所以針對字典的循環遍歷需求並不是很多

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

card_list = [{"name": "張三","qq": "12345","phone": "110"},{"name": "李四","qq": "54321","phone": "10086"}]4.4.4 字符串（str）

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

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

<code>string = "Hello Python"
for c in string:
 print(c)/<code>

字符串示意圖

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

1) 判斷類型 - 9方法 說明 string.isspace() 如果 string 中只包含空格，則返回 True string.isalnum() 如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True string.isalpha() 如果 string 至少有一個字符並且所有字符都是字母則返回 True string.isdecimal() 如果 string 只包含數字則返回 True，全角數字 string.isdigit() 如果 string 只包含數字則返回 True，全角數字、⑴、\\\\\\\\\\\\\\虜 string.isnumeric() 如果 string 只包含數字則返回 True，全角數字，漢字數字 string.istitle() 如果 string 是標題化的(每個單詞的首字母大寫)則返回 True string.islower() 如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True string.isupper() 如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True 2) 查找和替換 - 7方法 說明 string.startswith(str) 檢查字符串是否是以 str 開頭，是則返回 True string.endswith(str) 檢查字符串是否是以 str 結束，是則返回 True string.find(str, start=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 start 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回 -1 string.rfind(str, start=0, end=len(string)) 類似於 find()，不過是從右邊開始查找 string.index(str, start=0, end=len(string)) 跟 find() 方法類似，不過如果 str 不在 string 會報錯 string.rindex(str, start=0, end=len(string)) 類似於 index()，不過是從右邊開始 string.replace(old_str, new_str, num=string.count(old)) 把 string 中的 old_str 替換成 new_str，如果 num 指定，則替換不超過 num 次 3) 大小寫轉換 - 5方法 說明 string.capitalize() 把字符串的第一個字符大寫 string.title() 把字符串的每個單詞首字母大寫 string.lower() 轉換 string 中所有大寫字符為小寫 string.upper() 轉換 string 中的小寫字母為大寫 string.swapcase() 翻轉 string 中的大小寫 4) 文本對齊 - 3方法 說明 string.ljust(width) 返回一個原字符串左對齊，並使用空格填充至長度 width 的新字符串 string.rjust(width) 返回一個原字符串右對齊，並使用空格填充至長度 width 的新字符串 string.center(width) 返回一個原字符串居中，並使用空格填充至長度 width 的新字符串 5) 去除空白字符 - 3方法 說明 string.lstrip() 截掉 string 左邊（開始）的空白字符 string.rstrip() 截掉 string 右邊（末尾）的空白字符 string.strip() 截掉 string 左右兩邊的空白字符 6) 拆分和連接 - 5方法 說明 string.partition(str) 把字符串 string 分成一個 3 元素的元組 (str前面, str, str後面) string.rpartition(str) 類似於 partition() 方法，不過是從右邊開始查找 string.split(str="", num) 以 str 為分隔符拆分 string，如果 num 有指定值，則僅分隔 num + 1 個子字符串，str 默認包含 '\\\\r', '\\\\t', '\\\\n' 和空格 string.splitlines() 按照行('\\\\r', '\\\\n', '\\\\r\\\\n')分隔，返回一個包含各行作為元素的列表 string.join(seq) 以 string 作為分隔符，將 seq 中所有的元素（的字符串表示）合併為一個新的字符串 字符串的切片

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

字符串索引示意圖

<code>字符串[開始索引:結束索引:步長]/<code>

注意：

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

1. 從頭開始，開始索引數字可以省略，冒號不能省略
2. 到末尾結束，結束索引數字可以省略，冒號不能省略
3. 步長默認為 1，如果連續切片，數字和冒號都可以省略

索引的順序和倒序

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

<code>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])/<code>

4.4.5 公共方法和變量的高級應用4.4.5.1 內置函數Python 包含了以下內置函數：函數 描述 備註 len(item) 計算容器中元素個數 del(item) 刪除變量 del 有兩種方式 max(item) 返回容器中元素最大值 如果是字典，只針對 key 比較 min(item) 返回容器中元素最小值 如果是字典，只針對 key 比較 cmp(item1, item2) 比較兩個值，-1 小於 / 0 相等 / 1 大於

Python 3.x 取消了 cmp 函數注意：字符串

比較符合以下規則： "0" < "A" < "a"。4.4.5.2 切片

• 描述 Python 表達式 結果 支持的數據類型 切片 "0123456789"[::-2] "97531" 字符串、列表、元組 切片 使用 索引值 來限定範圍，從一個大的 字符串 中 切出 小的 字符串
• 列表 和 元組 都是 有序 的集合，都能夠 通過索引值 獲取到對應的數據
• 字典 是一個 無序 的集合，是使用 鍵值對 保存數據

4.4.5.3 運算符運算符 Python 表達式 結果 描述 支持的數據類型 + [1, 2] + [3, 4] [1, 2, 3, 4] 合併 字符串、列表、元組 * ["Hi!"] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重複 字符串、列表、元組 in 3 in (1, 2, 3) True 元素是否存在 字符串、列表、元組、字典 not in 4 not in (1, 2, 3) True 元素是否不存在 字符串、列表、元組、字典 > >= == < <= (1, 2, 3) < (2, 2, 3) True 元素比較 字符串、列表、元組

注意

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

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

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

<code>for 變量 in 集合:

 循環體代碼
else:
 沒有通過 break 退出循環，循環結束後，會執行的代碼/<code>

應用場景：

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

4.4.5.5 變量的引用

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

在 Python 中：變量

和

數據

是分開存儲的，數據

保存在內存中的一個位置，變量

中保存著數據在內存中的地址，就叫做

引用，使用 id() 函數可以查看變量中保存數據所在的

內存地址。

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

• 變量 不再 對之前的數據引用
• 變量 改為 對新賦值的數據引用

在 Python 中，變量的名字類似於

便籤紙

貼在

數據

上：

• 定義一個整數變量 a，並且賦值為 1

代碼 圖示 a = 1

• 將變量 a 賦值為 2

代碼 圖示 a = 2

• 定義一個整數變量 b，並且將變量 a 的值賦值給 b

代碼 圖示 b = a

在 Python 中，函數的

實參/

都是是靠

引用

來傳遞來的

<code>def test(num):
 print("-" * 50)
 print("%d 在函數內的內存地址是 %x" % (num, id(num)))
 result = 100
 print("返回值 %d 在內存中的地址是 %x" % (result, id(result)))
 print("-" * 50)
 return result
a = 10
print("調用函數前 內存地址是 %x" % id(a))
r = test(a)
print("調用函數後 實參內存地址是 %x" % id(a))
print("調用函數後 返回值內存地址是 %x" % id(r))/<code>

結果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聲明該變量是全局變量。

<code>num = 10
def demo1():
 print("demo1" + "-" * 50)
 # global 關鍵字，告訴 Python 解釋器 num 是一個全局變量
 global num
 # 只是定義了一個局部變量，不會修改到全局變量，只是變量名相同而已
 num = 100
 print(num)
def demo2():
 print("demo2" + "-" * 50)
 print(num)
demo1()
demo2()
print("over")/<code>

注意：為了避免局部變量和全局變量出現混淆，在定義全局變量時，有些公司會有一些開發要求，例如：全局變量名前應該增加 g_ 或者 gl_ 的前綴。5. 判斷（分支）5.1 if 語句語法1、if 判斷語句基本語法：

<code>if 要判斷的條件: 

 條件成立時，要做的事情
 ……/<code>

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

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

2、如果需要在

不滿足條件的時候，做某些事情，該如何做呢？

<code>if 要判斷的條件:
 條件成立時，要做的事情
 ……
else:
 條件不成立時，要做的事情
 ……/<code>

• 在程序開發中，通常 在判斷條件時，會需要同時判斷多個條件，只有多個條件都滿足，才能夠執行後續代碼，這個時候需要使用到 邏輯運算符。
• Python 中的 邏輯運算符 包括：與 and／或 or／非 not 三種

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

3、如果希望

再增加一些條件，條件不同，需要執行的代碼也不同

時，就可以使用 elif ：

<code>if 條件1:
 條件1滿足執行的代碼
 ……
elif 條件2:
 條件2滿足時，執行的代碼
 ……
elif 條件3:
 條件3滿足時，執行的代碼 

 ……
else:
 以上條件都不滿足時，執行的代碼
 ……/<code>

注意

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

4、在開發中，使用 if 進行條件判斷，如果希望

在條件成立的執行語句中

再

增加條件判斷，就可以使用

if 的嵌套：

<code>if 條件 1:
 條件 1 滿足執行的代碼
 ……

 if 條件 1 基礎上的條件 2:
 條件 2 滿足時，執行的代碼
 …… 

 # 條件 2 不滿足的處理
 else:
 條件 2 不滿足時，執行的代碼

# 條件 1 不滿足的處理
else:
 條件1 不滿足時，執行的代碼
 ……/<code>

5.2 if語句的應用5.2.1 隨機數的處理

• 在 Python 中，要使用隨機數，首先需要導入 隨機數 的 模塊 —— “工具包”

<code>import random/<code>

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

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

5.2.2 石頭剪刀布

<code># 導入隨機工具包
# 注意：在導入工具包的時候，應該將導入的語句，放在文件的頂部
# 因為，這樣可以方便下方的代碼，在任何需要的時候，使用工具包中的工具
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("不服氣，我們決戰到天明！")/<code>

6. 循環6.1 程序執行的三大流程在程序開發中，一共有三種流程方式：

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

程序執行的三大流程6.2 while 循環基本使用while 語句基本語法：

<code>初始條件設置 —— 通常是重複執行的 計數器
while 條件(判斷 計數器 是否達到 目標次數):
 條件滿足時，做的事情1
 條件滿足時，做的事情2
 條件滿足時，做的事情3
 ...(省略)...

 處理條件(計數器 + 1)/<code>

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

計數器 +1 ：可以通過賦值運算符簡化代碼的編寫。常見的計數方法有兩種，可以分別稱為：

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

因此，大家在編寫程序時，應該儘量養成習慣：除非需求的特殊要求，否則 循環 的計數都從 0 開始6.3 break 和 continue

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

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

6.4 while 循環嵌套

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

<code>while 條件 1: 

 條件滿足時，做的事情1
 條件滿足時，做的事情2
 條件滿足時，做的事情3
 ...(省略)...

 while 條件 2:
 條件滿足時，做的事情1
 條件滿足時，做的事情2
 條件滿足時，做的事情3
 ...(省略)...

 處理條件 2

 處理條件 1/<code>

示例：

<code>"""
打印 9 行小星星：
*
**
***
****
*****
******
*******
********
*********
"""
# 定義起始行
row = 1
# 最大打印 9 行
while row <= 9:
 # 定義起始列
 col = 1
 # 最大打印 row 列
 while col <= row:
 # end = ""，表示輸出結束後，不換行
 # "\\\\t" 可以在控制檯輸出一個製表符，協助在輸出文本時對齊 

 print("%d * %d = %d" % (col, row, row * col), end="\\\\t")
 # 列數 + 1
 col += 1
 # 一行打印完成的換行
 print("")
 # 行數 + 1
 row += 1/<code>

字符串中的轉義字符

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

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

轉義字符 描述 \\\\\\\\ 反斜槓符號 \\\\' 單引號 \\\" 雙引號 \\\\n 換行 \\\\t 橫向製表符 \\\\r 回車 7. 函數7.1 函數的基本使用所謂函數，就是把

具有獨立功能的代碼塊

組織為一個小模塊，在需要的時候

調用。在開發程序時，使用函數可以提高編寫的效率以及代碼的

重用，函數的使用包含兩個步驟：1. 定義函數 ——

封裝

獨立的功能2. 調用函數 —— 享受

封裝

的成果

• 定義函數：

<code>def 函數名():
 函數封裝的代碼
 ……/<code>

• 函數調用：通過 函數名() 即可完成對函數的調用。

PyCharm 的調試工具：

• F8 Step Over 可以單步執行代碼，會把函數調用看作是一行代碼直接執行
• F7 Step Into 可以單步執行代碼，如果是函數，會進入函數內部
• 函數的文檔註釋
• 在開發中，如果希望給函數添加註釋，應該在 定義函數 的下方，使用
  連續的三對引號，在 連續的三對引號 之間編寫對函數的說明文字，在 函數調用 位置，使用快捷鍵 CTRL + Q 可以查看函數的說明信息。

注意：因為 函數體相對比較獨立，函數定義的上方，應該和其他代碼（包括註釋）保留 兩個空行

7.2 函數的參數7.2.1 形參和實參

• 在函數名的後面的小括號內部填寫 參數，多個參數之間使用逗號 , 分隔。
• 函數的參數，增加函數的 通用性，針對 相同的數據處理邏輯，能夠 適應更多的數據**：
• 形參：
  定義 函數時，小括號中的參數，是用來接收參數用的，在函數內部 作為變量使用。
• 實參：調用 函數時，小括號中的參數，是用來把數據傳遞到 函數內部 用的。

<code>def sum_2_num(num1, num2):
 result = num1 + num2

 print("%d + %d = %d" % (num1, num2, result))
sum_2_num(50, 20)/<code>

7.2.2 可變和不可變參數

問題 1：在函數內部，針對參數使用 賦值語句，會不會影響調用函數時傳遞的 實參變量？ —— 不會！

• 無論傳遞的參數是 可變 還是 不可變只要
  針對參數 使用 賦值語句，會在 函數內部修改 局部變量的引用，不會影響到 外部變量的引用

問題 2：如果傳遞的參數是 可變類型，在函數內部，使用 方法 修改了數據的內容，同樣會影響到外部的數據，例如列表變量調用 += 本質上是在執行列表變量的 extend 方法。

7.2.2 缺省參數定義函數時，可以給

某個參數

指定一個默認值

缺省參數，* 調用函數時，如果沒有傳入

缺省參數

的值，則在函數內部使用定義函數時指定的

參數默認值，將常見的值設置為參數的缺省值，從而

簡化函數的調用。例如：對列表排序的方法：

<code>gl_num_list = [6, 3, 9]
# 默認就是升序排序，因為這種應用需求更多 

gl_num_list.sort()
print(gl_num_list)
# 只有當需要降序排序時，才需要傳遞 `reverse` 參數
gl_num_list.sort(reverse=True)
print(gl_num_list)/<code>

• 在參數後使用賦值語句，可以指定參數的缺省值

<code>def print_info(name, gender=True):
 gender_text = "男生"
 if not gender:
 gender_text = "女生"
 print("%s 是 %s" % (name, gender_text))/<code>

提示

1. 缺省參數，需要使用 最常見的值 作為默認值！
2. 如果一個參數的值 不能確定，則不應該設置默認值，具體的數值在調用函數時，由外界傳遞！

注意

1. 必須保證帶有默認值的缺省參數在參數列表末尾
2. 在 調用函數時，如果有 多個參數，需要指定參數名，這樣解釋器才能夠知道參數的對應關係！

7.2.3 多值參數有時可能需要

一個函數

能夠處理的參數

個數

是不確定的，這個時候，就可以使用

多值參數。

• python 中有 兩種 多值參數：
• 參數名前增加 一個 * 可以接收 元組
• 參數名前增加 兩個 ** 可以接收 字典
• 一般在給多值參數命名時，習慣使用以下兩個名字
• *args —— 存放 元組 參數，前面有一個 *
• **kwargs —— 存放 字典 參數，前面有兩個 **

<code>def demo(num, *args, **kwargs):
 print(num)
 print(args)
 print(kwargs)
demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
print("-"*20)
demo(1,(2,3,4,5),{"name":"小明", "age":18, "gender":True})
print("-"*20)
demo(1,(2,3,4,5), name="小明", age=18, gender=True)/<code>

結果 元組和字典的拆包

• 在調用帶有多值參數的函數時，如果希望：
• 將一個 元組變量，直接傳遞給 args
• 將一個 字典變量，直接傳遞給 kwargs
• 就可以使用
  拆包，簡化參數的傳遞，拆包 的方式是：
• 在 元組變量前，增加 一個 *
• 在 字典變量前，增加 兩個 *

<code>def demo(*args, **kwargs):
 print(args)
 print(kwargs)
# 需要將一個元組變量/字典變量傳遞給函數對應的參數
gl_nums = (1, 2, 3)
gl_xiaoming = {"name": "小明", "age": 18}
# 會把 num_tuple 和 xiaoming 作為元組傳遞個 args
# demo(gl_nums, gl_xiaoming)
demo(*gl_nums, **gl_xiaoming)/<code>

7.3 函數的返回值

• 在函數中使用 return 關鍵字可以返回結果，調用函數一方，可以 使用變量 來 接收函數的返回結果。

注意：return 表示返回，後續的代碼都不會被執行

<code>def sum_2_num(num1, num2):
 """對兩個數字的求和"""
 return num1 + num2
# 調用函數，並使用 result 變量接收計算結果
result = sum_2_num(10, 20)
print("計算結果是 %d" % result)/<code>

函數參數和返回值

• 在 Python 中，可以 將一個元組 使用 賦值語句 同時賦值給 多個變量
• 注意：變量的數量需要和元組中的元素數量保持一致

<code># Python 專有，利用元組交換兩個變量的值
a, b = b, a/<code>

7.4 函數的嵌套調用

• 一個函數里面 又調用 了 另外一個函數，這就是 函數嵌套調用。

def test1():print("*" * 50)print("test 1")print("*" * 50)def test2():print("-" * 50)print("test 2")test1()print("-" * 50)test2()

提示：工作中針對需求的變化，應該冷靜思考，不要輕易修改之前已經完成的，能夠正常執行的函數

7.5 函數的遞歸

函數調用自身的 編程技巧 稱為遞歸

特點：一個函數內部調用自己代碼特點：

1. 函數內部的 代碼 是相同的，只是針對 參數 不同，處理的結果不同
2. 當 參數滿足一個條件 時，函數不再執行，通常被稱為遞歸的出口，否則 會出現死循環！

案例 —— 計算數字累加：需求：

1. 定義一個函數 sum_numbers
2. 能夠接收一個 num 的整數參數
3. 計算 1 + 2 + ... num 的結果

<code>def sum_numbers(num):
 if num == 1:
 return 1

 # 假設 sum_numbers 能夠完成 num - 1 的累加
 temp = sum_numbers(num - 1)
 # 函數內部的核心算法就是 兩個數字的相加
 return num + temp
print(sum_numbers(2))/<code>

7.6 在模塊中定義函數

模塊是 Python 程序架構的一個核心概念

模塊

就好比是

工具包，要想使用這個工具包中的工具，就需要

導入 import

這個模塊， 每一個以擴展名 py 結尾的 Python 源代碼文件都是一個

模塊，在模塊中定義的

全局變量

、

函數

都是模塊能夠提供給外界直接使用的工具。

• 可以 在一個 Python 文件 中 定義 變量 或者 函數
• 然後在 另外一個文件中 使用 import 導入這個模塊
• 導入之後，就可以使用 模塊名.變量 / 模塊名.函數 的方式，使用這個模塊中定義的變量或者函數

模塊可以讓 曾經編寫過的代碼 方便的被 複用！模塊名也是一個標識符，如果在給 Python 文件起名時，以數字開頭 是無法在 PyCharm 中通過導入這個模塊的。

Pyc 文件

C 是 compiled 編譯過 的意思。

• 瀏覽程序目錄會發現一個 __pycache__ 的目錄。
• 目錄下會有一個 hm_10_分隔線模塊.cpython-35.pyc 文件，cpython-35 表示 Python 解釋器的版本。
• 這個 pyc 文件是由 Python 解釋器將 模塊的源碼 轉換為 字節碼。

Python 這樣保存

字節碼

是作為一種啟動

速度的優化。

• 什麼是字節碼？
• Python 在解釋源程序時是分成兩個步驟的：

1. 首先處理源代碼，編譯 生成一個二進制 字節碼。
2. 再對 字節碼 進行處理，才會生成 CPU 能夠識別的 機器碼。

• 有了模塊的字節碼文件之後，下一次運行程序時，如果在 上次保存字節碼之後 沒有修改過源代碼，Python 將會加載 .pyc 文件並跳過編譯這個步驟。
• 當 Python 重編譯時，它會自動檢查源文件和字節碼文件的時間戳。
• 如果你又修改了源代碼，下次程序運行時，字節碼將自動重新創建。

8. 文件、異常、模塊和包8.1 文件8.1.1 文件的概念

• 計算機的 文件，就是存儲在某種 長期儲存設備
  上的一段 數據
• 長期存儲設備包括：硬盤、U 盤、移動硬盤、光盤...

文件的作用：將數據長期保存下來，在需要的時候使用文件的存儲方式：在計算機中，文件是以

二進制

的方式保存在磁盤上的文本文件：可以使用

查看，本質上還是二進制文件二進制文件：保存的內容 不是給人直接閱讀的，而是

提供給其他軟件使用的，例如：圖片文件、音頻文件、視頻文件等等，二進制文件不能使用

查看8.1.2 文件的基本操作

閱讀更多 在線學編程 的文章

關鍵字: 軟件 Guido 集成開發環境