零、python前言

（一）解釋器

計算機不能直接理解任何除機器語言以外的語言，必須要把程序語言翻譯成機器語言，計算機才能執(zhí)行程序。

編譯器：將其他語言翻譯成機器語言的工具

編譯器翻譯的方式：編譯，解釋。

兩種方式的區(qū)別在于翻譯時間點的不同。當編譯器以解釋方式運行的時候，也稱之為解釋器

• 編譯型語言：程序執(zhí)行之前需要有一個專門的編譯過程，把程序編譯成為機器語言的文件，運行時不需要重新翻譯，直接使用編譯的結果就行了。程序執(zhí)行效率高，依賴編譯器，跨平臺性差些。
• 解釋型語言：解釋型語言編寫的程序不進行預先編譯，以文本方式存儲程序代碼，會將代碼一句一句直接運行。在發(fā)布程序時，看起來省了道編譯工序，但是在運行程序的時候，必須先解釋再運行

編譯型語言和解釋型語言對比

• 速度： 編譯比解釋型快
• 跨平臺性： 解釋比編譯跨好

（二）Python 特點

• 完全面向對象的語言
  • 函數、模塊、數字、字符串都是對象，Python 中一切皆對象
  • 完全支持繼承、重載、多重繼承
  • 支持重載運算符，也支持泛型設計
• 擁有一個強大的標準庫
  • Python 標準庫提供了 系統(tǒng)管理、網絡通信、文本處理、數據庫接口、圖形系統(tǒng)、XML 處理 等額外的功能
• 有大量的第三方模塊
  • 使用方式與標準庫類似。它們的功能覆蓋 科學計算、人工智能、機器學習、Web 開發(fā)、數據庫接口、圖形系統(tǒng) 多個領域

（三）面向對象的思維方式

• 面向對象 是一種 思維方式，也是一門 程序設計技術
• 要解決一個問題前，首先考慮 由誰 來做，怎么做事情是 誰 的職責，最后把事情做好就行！
  • 對象 就是 誰
• 要解決復雜的問題，就可以找多個不同的對象，各司其職，共同實現，最終完成需求
• 先找一個可以完成功能的對象，并且使用對象所提供的能力來解決問題

（四）Python 的優(yōu)缺點

（1）優(yōu)點

• 簡單、易學
• 免費、開源
• 面向對象
• 豐富的庫
• 可擴展性
  • 如果需要一段關鍵代碼運行得更快或者希望某些算法不公開，可以把這部分程序用 C 或 C++ 編寫，然后在 Python 程序中使用它們

（2）缺點

• 運行速度差一點
• 國內市場較小
• 中文資料匱乏

（五）執(zhí)行 Python 程序的三種方式

• 解釋器 —— python / python3
• 交互式 —— ipython
• 集成開發(fā)環(huán)境 —— PyCharm

注：

可以使用任意文本編輯軟件做 Python 的開發(fā)

文件擴展名 通常都是 .py

（1）單詞列表

* error 錯誤 * name 名字 * defined 已經定義 * syntax 語法 * invalid 無效 * Indentation 索引 * unexpected 意外的，不期望的 * character 字符 * line 行 * encoding 編碼 * declared 聲明 * details 細節(jié)，詳細信息 * ASCII 一種字符編碼

（2）python的運行方式

Python 的解釋器

# 使用 python 2.x 解釋器 $ python xxx.py# 使用 python 3.x 解釋器 $ python3 xxx.py

（3）交互式運行 Python 程序

• 直接在終端中運行解釋器，而不輸入要執(zhí)行的文件名
• 在 Python 的 Shell 中直接輸入 Python 的代碼，會立即看到程序執(zhí)行結果

1) 交互式運行 Python 的優(yōu)缺點

優(yōu)點

• 適合于學習/驗證 Python 語法或者局部代碼

缺點

• 代碼不能保存
• 不適合運行太大的程序

2) 退出 官方的解釋器

1> 直接輸入 exit()

>>> exit()

2> 使用熱鍵退出

按熱鍵 ctrl + d 可以退出解釋器

一、變量

程序就是用來處理數據的，而變量就是用來存儲數據的

（零）變量類型

• Python 中數據類型可以分為 數字型 和 非數字型

• 數字型

  • 整型 (int)
  • 浮點型（float）
  • 布爾型（bool）
    • 真 True 非 0 數 —— 非零即真
    • 假 False 0
  • 復數型 (complex)
    • 主要用于科學計算，例如：平面場問題、波動問題、電感電容等問題

• 非數字型

  • 字符串
  • 列表
  • 元組
  • 字典

• 在 Python 中，所有 非數字型變量 都支持以下特點：

• 都是一個 序列 sequence，也可以理解為 容器
• 取值 []
• 遍歷 for in
• 計算長度、最大/最小值、比較、刪除
• 鏈接 + 和 重復 *
• 切片

（一）變量定義

• 每個變量 在使用前都必須賦值，變量 賦值以后 該變量 才會被創(chuàng)建

變量名 = 值

變量：先定義，后使用

（二）變量的類型

• 在內存中創(chuàng)建一個變量，會包括：
• 變量的名稱
• 變量保存的數據
• 變量存儲數據的類型
• 變量的地址（標示）

（1）變量的類型

• 在 Python 中定義變量是 不需要指定類型
• 數據類型可分為 數字型 和 非數字型
• 數字型
  • 整型 (int)
  • 浮點型（float）
  • 布爾型（bool）
    • 真 True 非 0 數 —— 非零即真
    • 假 False 0
  • 復數型 (complex)
    • 主要用于科學計算
• 非數字型
  • 字符串
  • 列表
  • 元組
  • 字典

（2）不同類型變量之間的計算

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

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

字符串變量 之間使用 + 拼接字符串

字符串變量 可以和 整數 使用 * 重復拼接相同的字符串

數字型變量 和 字符串 之間 不能進行其他計算

（3）變量的輸入

• 所謂 輸入，就是 用代碼 獲取 用戶通過 鍵盤 輸入的信息
• 在 Python 中，使用 input 函數

input 函數實現鍵盤輸入

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

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

（4）變量的格式化輸出

格式化操作符

• % 被稱為 格式化操作符，專門用于處理字符串中的格式
  • 包含 % 的字符串，被稱為 格式化字符串
  • % 和不同的 字符 連用，不同類型的數據 需要使用 不同的格式化字符

格式化字符含義

%s	字符串
%d	有符號十進制整數，%06d 表示輸出的整數顯示位數，不足的地方使用 0 補全
%f	浮點數，%.2f 表示小數點后只顯示兩位
%%	輸出 %

• 語法格式如下：

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

（二）標識符和關鍵字

（1）標識符

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

名字 要 見名知義

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

（2）關鍵字

• 關鍵字 就是在 Python 內部已經使用的標識符
• 關鍵字 具有特殊的功能和含義
• 不允許定義和關鍵字相同的名字的標示符

（三）變量的命名規(guī)則

注意 Python 中的 標識符 是 區(qū)分大小寫的

在定義變量時，為了保證代碼格式，= 的左右應該各保留一個空格

在 Python 中，如果 變量名 需要由 二個 或 多個單詞 組成時，可以按照以下方式命名

• 每個單詞都使用小寫字母

• 小駝峰式命名法
  • 第一個單詞以小寫字母開始，后續(xù)單詞的首字母大寫
• 大駝峰式命名法
  • 每一個單詞的首字母都采用大寫字母

（四）變量進階

（1）變量的引用

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

1）引用的概念

在 Python 中 ：

• 變量 和 數據 是分開存儲的
• 數據 保存在內存中的一個位置
• 變量 中保存著數據在內存中的地址
• 變量 中 記錄數據的地址，即 引用
• 使用 id() 函數查看變量中保存數據所在的 內存地址

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

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

2）函數的參數和返回值的傳遞

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

（2）可變和不可變類型

• 不可變類型，內存中的數據不允許被修改：

  • 數字類型 int, bool, float, complex, long(2.x)
  • 字符串 str
  • 元組 tuple

• 可變類型，內存中的數據可以被修改：

  • 列表 list
  • 字典 dict

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

注意

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

若給一個可變類型的變量，賦值了一個新的數據，引用會修改

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

（3）哈希 (hash)

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

（4）局部變量和全局變量

• 局部變量 是在 函數內部 定義的變量，只能在函數內部使用
• 全局變量 是在 函數外部定義 的變量（沒有定義在某一個函數內），所有函數 內部 都可以使用這個變量

1）局部變量

• 局部變量 是在 函數內部 定義的變量，只能在函數內部使用
• 函數執(zhí)行結束后，局部變量，會被系統(tǒng)回收
• 不同的函數，可以定義相同的名字的局部變量，但是 彼此之間 不會產生影響

2）局部變量的作用

• 在函數內部使用，臨時 保存 函數內部需要使用的數據

3）局部變量的生命周期

• 所謂 生命周期 就是變量從 被創(chuàng)建 到 被系統(tǒng)回收 的過程
• 局部變量 在 函數執(zhí)行時 才會被創(chuàng)建
• 函數執(zhí)行結束后 局部變量 被系統(tǒng)回收
• 局部變量在生命周期 內，可以用來存儲 函數內部臨時使用到的數據

4）全局變量

• 全局變量 是在 函數外部定義 的變量，所有函數內部都可以使用這個變量

注意：函數執(zhí)行時，需要處理變量時 會：

首先 查找 函數內部 是否存在 指定名稱 的局部變量，如果有，直接使用

若沒有，查找 函數外部 是否存在 指定名稱 的全局變量，如果有，直接使用

若還沒有，程序報錯！

5) 函數不能直接修改 全局變量的引用

• 全局變量 是在 函數外部定義 的變量（沒有定義在某一個函數內），所有函數 內部 都可以使用這個變量

• 在函數內部，可以 通過全局變量的引用獲取對應的數據

• 但是，不允許直接修改全局變量的引用 —— 使用賦值語句修改全局變量的值

注：只是在函數內部定義了一個局部變量而已，只是變量名相同 —— 在函數內部不能直接修改全局變量的值

6) 在函數內部修改全局變量的值

• 若在函數中需要修改全局變量，需要使用 global 進行聲明

3) 全局變量定義的位置

• 將全局變量定義在其他函數的上方

二、運算符

（一）算數運算符

• 是完成基本的算術運算使用的符號，用來處理四則運算

運算符描述

+	加
-	減
*	乘
/	除
//	取整除(返回除法的整數部分（商）)
%	取余數(返回除法的余數)
**	冪

• 在 Python 中 * 還可以用于字符串，結果是字符串重復指定次數的結果

優(yōu)先級

• 先乘除后加減

• 同級運算符是 從左至右 計算

• 可以使用 () 調整計算的優(yōu)先級

• 算數優(yōu)先級由高到最低順序排列

運算符描述

**	冪 (最高優(yōu)先級)
* / % //	乘、除、取余數、取整除
+ -	加法、減法

（二）比較（關系）運算符

運算符描述

==	檢查兩個操作數的值是否 相等，如果是，則條件成立，返回 True
!=	檢查兩個操作數的值是否 不相等，如果是，則條件成立，返回 True
>	檢查左操作數的值是否 大于 右操作數的值，如果是，則條件成立，返回 True
<	檢查左操作數的值是否 小于 右操作數的值，如果是，則條件成立，返回 True
>=	檢查左操作數的值是否 大于或等于 右操作數的值，如果是，則條件成立，返回 True
<=	檢查左操作數的值是否 小于或等于 右操作數的值，如果是，則條件成立，返回 True

Python 2.x 中判斷 不等于 還可以使用 <> 運算符

!= 在 Python 2.x 中同樣可以用來判斷 不等于

（三）邏輯運算符

運算符邏輯表達式描述

and	x and y	同True返True，否則返False
or	x or y	一True返True，同False返False
not	not x	為True返 False，為 False返 True

（四）賦值運算符

• 注：賦值運算符中間不能使用空格

運算符描述

=	簡單的賦值運算符
+=	加法賦值運算符
-=	減法賦值運算符
*=	乘法賦值運算符
/=	除法賦值運算符
//=	取整除賦值運算符
%=	取 模 (余數)賦值運算符
**=	冪賦值運算符

（五）運算符的優(yōu)先級

• 表格算數優(yōu)先級由高到最低順序排列

運算符描述

**	冪 (最高優(yōu)先級)
* / % //	乘、除、取余數、取整除
+ -	加法、減法
<= < > >=	比較運算符
== !=	等于運算符
= %= /= //= -= += *= **=	賦值運算符
not or and	邏輯運算符

三、字符串

（一）字符串的定義

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

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

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

（二）字符串的常用操作

（1）判斷類型

方法說明

string.isspace()	若string 中只包含空格，則返回 True
string.isalnum()	若string 至少有一個字符并且所有字符都是字母或數字則返回 True
string.isalpha()	若string 至少有一個字符并且所有字符都是字母則返回 True
string.isdecimal()	若string 只包含數字則返回 True，全角數字
string.isdigit()	若string 只包含數字則返回 True，全角數字、⑴、\u00b2
string.isnumeric()	若string 只包含數字則返回 True，全角數字，漢字數字
string.istitle()	若string 是標題化的(每個單詞的首字母大寫)則返回 True
string.islower()	若string 中包含至少一個區(qū)分大小寫的字符，并且所有這些(區(qū)分大小寫的)字符都是小寫，則返回 True
string.isupper()	若string 中包含至少一個區(qū)分大小寫的字符，并且所有這些(區(qū)分大小寫的)字符都是大寫，則返回 True

（2）查找和替換

方法說明

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）大小寫轉換

方法說明

string.capitalize()	把字符串的第一個字符大寫
string.title()	把字符串的每個單詞首字母大寫
string.lower()	轉換 string 中所有大寫字符為小寫
string.upper()	轉換 string 中的小寫字母為大寫
string.swapcase()	翻轉 string 中的大小寫

（4）文本對齊

方法說明

string.ljust(width)	返回一個原字符串左對齊，并使用空格填充至長度 width 的新字符串
string.rjust(width)	返回一個原字符串右對齊，并使用空格填充至長度 width 的新字符串
string.center(width)	返回一個原字符串居中，并使用空格填充至長度 width 的新字符串

（5）去除空白字符

方法說明

string.lstrip()	截掉 string 左邊（開始）的空白字符
string.rstrip()	截掉 string 右邊（末尾）的空白字符
string.strip()	截掉 string 左右兩邊的空白字符

（6）拆分和連接

方法說明

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 中所有的元素（的字符串表示）合并為一個新的字符串

（7）字符串的切片

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

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

注意：

指定的區(qū)間屬于 左閉右開 型 [開始索引, 結束索引) => 開始索引 >= 范圍 < 結束索引

• 從 起始 位開始，到 結束位的前一位 結束（不包含結束位本身)

從頭開始，開始索引 數字可以省略，冒號不能省略

到末尾結束，結束索引 數字可以省略，冒號不能省略

步長默認為 1，如果連續(xù)切片，數字和冒號都可以省略

（8）索引的順序和倒序

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

四、列表

（一）列表的定義

• List（列表） 是 Python 中使用 最頻繁 的數據類型，在其他語言中通常叫做 數組
• 專門用于存儲 一串 信息
• 列表用 [] 定義，數據 之間使用 , 分隔
• 列表的 索引 從 0 開始
  • 索引 就是數據在 列表 中的位置編號，索引 又可以被稱為 下標

注意：從列表中取值時，如果 超出索引范圍，程序會報錯

（二）列表常用操作

• 定義一個 列表，例如：name_list = []

分類關鍵字 / 函數 / 方法說明

增加	列表.insert(索引, 數據)	在指定位置插入數據
	列表.append(數據)	在末尾追加數據
	列表.extend(列表2)	將列表2 的數據追加到列表
修改	列表[索引] = 數據	修改指定索引的數據
刪除	del 列表[索引]	刪除指定索引的數據
	列表.remove[數據]	刪除第一個出現的指定數據
	列表.pop	刪除末尾數據
	列表.pop(索引)	刪除指定索引數據
	列表.clear	清空列表
統(tǒng)計	len(列表)	列表長度
	列表.count(數據)	數據在列表中出現的次數
排序	列表.sort()	升序排序
	列表.sort(reverse=True)	降序排序
	列表.reverse()	逆序、反轉

（三）關鍵字（科普）

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

del name_list[1]

（四）循環(huán)遍歷

• 遍歷 就是 從頭到尾 依次 從 列表 中獲取數據

  • 在 循環(huán)體內部 針對 每一個元素，執(zhí)行相同的操作

• 在 Python 中為了提高列表的遍歷效率，專門提供的 迭代 iteration 遍歷

• 使用 for 就能夠實現迭代遍歷

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

五、元組

（一）元組的定義

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

元組中 只包含一個元素 時，需要 在元素后面添加逗號

info_tuple = (50, )

（二）元組常用操作

• 定義一個 元組，eg：info = ()

（1）循環(huán)遍歷

• 取值 就是從 元組 中獲取存儲在指定位置的數據
• 遍歷 就是 從頭到尾 依次 從 元組 中獲取數據

# for 循環(huán)內部使用的變量 in 元組

• 在 Python 中，可以使用 for 循環(huán)遍歷所有非數字型類型的變量：列表、元組、字典 以及 字符串

（2）應用場景

• 盡管可以使用 for in 遍歷 元組
• 在開發(fā)中應用場景是：
  • 函數的 參數 和 返回值，一個函數可以接收 任意多個參數，或者 一次返回多個數據
    • 有關 函數的參數 和 返回值，在后續(xù) 函數高級 給大家介紹
  • 格式字符串，格式化字符串后面的 () 本質上就是一個元組
  • 讓列表不可以被修改，以保護數據安全

info = ("zhangsan", 18)print("%s 的年齡是 %d" % info)

（三）元組和列表之間的轉換

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

list(元組)

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

tuple(列表)

六、字典

（一）字典的定義

• dictionary（字典） 是 除列表以外 Python 之中 最靈活 的數據類型
• 字典同樣可以用來 存儲多個數據
  • 通常用于存儲 描述一個 物體 的相關信息
• 和列表的區(qū)別
  • 列表 是 有序 的對象集合
  • 字典 是 無序 的對象集合
• 字典用 {} 定義
• 字典使用 鍵值對 存儲數據，鍵值對之間使用 , 分隔
  • 鍵 key 是索引
  • 值 value 是數據
  • 鍵 和 值 之間使用 : 分隔
  • 鍵必須是唯一的
  • 值 可以取任何數據類型，但 鍵 只能使用 字符串、數字或 元組

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

（二）字典常用操作

• 定義一個 字典

zidian = {}

• 常用操作在上圖

（三）循環(huán)遍歷

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

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

七、判斷語句（if）

（一）基本語法

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

注：if 語句以及縮進部分是一個 完整的代碼塊

（二）else 處理條件不滿足的情況

格式如下：

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

注：if 和 else 語句以及各自的縮進部分共同是一個 完整的代碼塊

（三）邏輯運算

• 通常 在判斷條件時，會需要同時判斷多個條件
• 只有多個條件都滿足，才能夠執(zhí)行后續(xù)代碼
• 邏輯運算符 可以把 多個條件 按照 邏輯 進行 連接，變成 更復雜的條件
• Python 中的 邏輯運算符 包括：與 and／或 or／非 not 三種

（1） and

條件1 and 條件2

• 與／并且
• 兩個條件同時滿足，返回 True
• 只要有一個不滿足，就返回 `False``

（2） or

條件1 or 條件2

• 或／或者
• 兩個條件只要有一個滿足，返回 True
• 兩個條件都不滿足，返回 False

（3） not

not 條件

• 非／不是

（四）if語句進階

（1）elif

• 語法格式如下：

if 條件1:條件1滿足執(zhí)行的代碼…… elif 條件2:條件2滿足時，執(zhí)行的代碼…… elif 條件3:條件3滿足時，執(zhí)行的代碼…… else:以上條件都不滿足時，執(zhí)行的代碼……

• 對比邏輯運算符的代碼

if 條件1 and 條件2:條件1滿足 并且 條件2滿足 執(zhí)行的代碼……

注:

elif 和 else 都必須和 if 聯合使用，而不能單獨使用

可以將 if、elif 和 else 以及各自縮進的代碼，看成一個 完整的代碼塊

（2）if 嵌套

• 語法格式如下：

if 條件 1:條件 1 滿足執(zhí)行的代碼……if 條件 1 基礎上的條件 2:條件 2 滿足時，執(zhí)行的代碼…… # 條件 2 不滿足的處理else:條件 2 不滿足時，執(zhí)行的代碼# 條件 1 不滿足的處理 else:條件1 不滿足時，執(zhí)行的代碼……

（3）隨機數的處理

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

import random #引入隨機數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) # 錯誤，下限必須小于上限

八、while循環(huán)

（一）while循環(huán)

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

注意：

• while 語句以及縮進部分是一個 完整的代碼塊

注意：循環(huán)結束后，之前定義的計數器條件的數值是依舊存在的

（二）for循環(huán)

• 語法：

for 變量 in 集合:循環(huán)體代碼 else:沒有通過 break 退出循環(huán)，循環(huán)結束后，會執(zhí)行的代碼

應用場景

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

（三）Python 中的計數方法

常見的計數方法有兩種：

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

因此除非需求的特殊要求，否則 循環(huán) 的計數都從 0 開始

（四）循環(huán)計算

在程序開發(fā)中，通常會遇到 利用循環(huán) 重復計算 的需求

遇到這種需求，可以：

在 while 上方定義一個變量，用于 存放最終計算結果

在循環(huán)體內部，每次循環(huán)都用 最新的計算結果，更新 之前定義的變量

（五）break 和 continue

break 和 continue 是專門在循環(huán)中使用的關鍵字

• break 某一條件滿足時，退出循環(huán)，不再執(zhí)行后續(xù)重復的代碼
• continue 某一條件滿足時，不執(zhí)行后續(xù)重復的代碼（容易出現死循環(huán)）

break 和 continue 只針對 當前所在循環(huán) 有效

循環(huán)也可以嵌套

九、函數

（一）函數基礎

• 函數：將 具有獨立功能的代碼塊 封裝為一個小模塊，在需要時 調用
• 函數的使用包含兩個步驟（先封裝、后使用）：
• 定義函數 —— 封裝 獨立的功能
• 調用函數 —— 享受 封裝 的成果
• 函數的作用 ：提高編寫的效率以及代碼的 重復使用

（二）函數基本使用

（1）函數的定義

定義函數格式：

def 函數名():函數封裝的代碼……

def 是英文 define 的縮寫

函數名稱 應該能夠表達 函數封裝代碼 的功能，便于后續(xù)調用

函數名稱 的命名應該 符合 標識符的命名規(guī)則

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

（2）函數調用

調用函數很簡單的，通過 函數名() 即可完成對函數的調用

• 定義完成之后，若不主動調用函數，則函數是不會主動執(zhí)行的

（三）函數的參數

（1）參數的使用

• 在函數名的后面的小括號內部填寫 參數
• 多個參數之間使用 , 分隔

（2）參數的作用

• 函數的參數，增加函數的 通用性，針對 相同的數據處理邏輯，能夠 適應更多的數據
• 在函數 內部，把參數當做 變量 使用，進行需要的數據處理
• 函數調用時，按照函數定義的參數順序，把 希望在函數內部處理的數據，通過參數 傳遞

（3）形參和實參

• 形參：定義 函數時，小括號中的參數，用于接收參數，在函數內部 作為變量使用
• 實參：調用 函數時，小括號中的參數，將數據傳遞到 函數內部

（四）函數的返回值

• 返回值 是函數 完成工作后，返回 給調用者的 結果
• 在函數中使用 return 關鍵字可以返回結果
• 調用函數一方，可以 使用變量 來 接收 函數的返回結果

注意：return 表示返回，后續(xù)的代碼都不會被執(zhí)行

return 的作用：

返回一個對象

阻斷代碼執(zhí)行

（五）使用模塊中的函數

• 模塊 就好比是 工具包，要想使用這個工具包中的工具，就需要 導入 import 這個模塊

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

• 在模塊中定義的 全局變量 、 函數 都是模塊能夠提供給外界直接使用的工具

• 可以 在一個 Python 文件 中 定義 變量 或者 函數

• 然后在 另外一個文件中 使用 import 導入這個模塊

• 導入之后，就可以使用 模塊名.變量 / 模塊名.函數 的方式，使用這個模塊中定義的變量或者函數

• 模塊名也是一個標識符
  • 標示符可以由 字母、下劃線 和 數字 組成
  • 不能以數字開頭
  • 不能與關鍵字重名

（六）函數進階

（1）函數參數和返回值的作用

如果函數 內部處理的數據不確定，就可以將外界的數據以參數傳遞到函數內部

如果希望一個函數 執(zhí)行完成后，向外界匯報執(zhí)行結果，就可以增加函數的返回值

1、無參數，無返回值

此類函數，不接收參數，也沒有返回值，應用場景如下：

只是單純地做一件事情，例如 顯示菜單

在函數內部 針對全局變量進行操作，例如：新建名片，最終結果 記錄在全局變量 中

注：

• 如果全局變量的數據類型是一個 可變類型，在函數內部可以使用 方法 修改全局變量的內容 —— 變量的引用不會改變
• 在函數內部，使用賦值語句 才會 修改變量的引用

2、無參數，有返回值

此類函數，不接收參數，但是有返回值，應用場景如下：

• 采集數據，例如 溫度計，返回結果就是當前的溫度，而不需要傳遞任何的參數

3、有參數，無返回值

此類函數，接收參數，沒有返回值，應用場景如下：

• 函數內部的代碼保持不變，針對 不同的參數 處理 不同的數據

4、有參數，有返回值

此類函數，接收參數，同時有返回值，應用場景如下：

• 函數內部的代碼保持不變，針對 不同的參數 處理 不同的數據，并且 返回期望的處理結果

（2）函數的返回值 進階

• 在程序開發(fā)中，有時候，會希望 一個函數執(zhí)行結束后，告訴調用者一個結果，以便調用者針對具體的結果做后續(xù)的處理
• 返回值 是函數 完成工作后，最后 給調用者的 一個結果
• 在函數中使用 return 關鍵字可以返回結果
• 調用函數一方，可以 使用變量 來 接收 函數的返回結果

提示：如果一個函數返回的是元組，括號可以省略

技巧

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

result = temp, wetness = measure()

（七）函數的參數 進階

（1）不可變和可變的參數

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

1、缺省參數

• 定義函數時，給 某個參數 指定一個默認值，具有默認值的參數就叫做 缺省參數
• 調用函數時，如果沒有傳入 缺省參數 的值，則在函數內部使用定義函數時指定的 參數默認值
• 函數的缺省參數，將常見的值設置為參數的缺省值，從而 簡化函數的調用

2、指定函數的缺省參數

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

提示

缺省參數，需要使用 最常見的值 作為默認值！

如果一個參數的值 不能確定，則不應該設置默認值，具體的數值在調用函數時，由外界傳遞！

3、缺省參數的注意事項

1) 缺省參數的定義位置

• 必須保證 帶有默認值的缺省參數 在參數列表末尾

2) 調用帶有多個缺省參數的函數

• 在 調用函數時，如果有 多個缺省參數，需要指定參數名，這樣解釋器才能夠知道參數的對應關系！

（2）多值參數

1、定義支持多值參數的函數

• 有時可能需要 一個函數 能夠處理的參數 個數 是不確定的，這個時候，就可以使用 多值參數
• python 中有 兩種 多值參數：
  • 參數名前增加 一個 * 可以接收 元組 如：*args
  • 參數名前增加 兩個 * 可以接收 字典 如：**kwargs

2、元組和字典的拆包

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

（八）函數的遞歸

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

遞歸函數的特點

• 一個函數 內部 調用自己

代碼特點

函數內部的 代碼 是相同的，只是針對 參數 不同，處理的結果不同

當 參數滿足一個條件 時，函數不再執(zhí)行

• 非常重要，通常被稱為遞歸的出口，否則 會出現死循環(huán)！

九、其他

（一）print函數

• 在默認情況下，print 函數輸出內容之后，會自動在內容末尾增加換行

• 如果不希望末尾增加換行，可以在 print 函數輸出內容的后面增加 , end=""

• 其中 "" 中間可以指定 print 函數輸出內容之后，繼續(xù)希望顯示的內容

• 語法格式如下：

# 向控制臺輸出內容結束之后，不會換行 print("*", end="")# 單純的換行 print("")

end="" 表示向控制臺輸出內容結束之后，不會換行

假設 Python 沒有提供 字符串的 * 操作 拼接字符串

字符串中的轉義字符

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

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

轉義字符描述

\\	反斜杠符號
\’	單引號
\"	雙引號
\n	換行
\t	橫向制表符
\r	回車

（二）注釋

• 單行注釋（行注釋）：使用#
• 多行注釋（塊注釋）：使用"" … “”

（三）公共方法

（1）Python 內置函數

Python 包含了以下內置函數：

函數描述備注

len(item)	計算容器中元素個數
del(item)	刪除變量	del 有兩種方式
max(item)	返回容器中元素最大值	如果是字典，只針對 key 比較
min(item)	返回容器中元素最小值	如果是字典，只針對 key 比較
cmp(item1, item2)	比較兩個值，-1 小于/0 相等/1 大于	Python 3.x 取消了 cmp 函數

注意

• 字符串 比較符合以下規(guī)則： “0” < “A” < “a”

（2）切片

描述Python 表達式結果支持的數據類型

切片	“0123456789”[::-2]	“97531”	字符串、列表、元組

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

（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）成員運算符

成員運算符用于 測試 序列中是否包含指定的 成員

運算符描述實例

in	如果在指定的序列中找到值返回 True，否則返回 False	3 in (1, 2, 3) 返回 True
not in	如果在指定的序列中沒有找到值返回 True，否則返回 False	3 not in (1, 2, 3) 返回 False

注意：在對 字典 操作時，判斷的是 字典的鍵

總結

以上是生活随笔為你收集整理的Python基础笔记（全）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。