python運算符與表達式的用法?在了解了不同類型的變量之後，我們現在該用這些變量做點什麼了，接下來我們就來聊聊關于python運算符與表達式的用法?以下内容大家不妨參考一二希望能幫到您!

python運算符與表達式的用法

在了解了不同類型的變量之後，我們現在該用這些變量做點什麼了。

今天，我們将了解如何在變量上執行計算。你最終将會掌握如何使用變量和操作符來創建複雜的表達式。

Python 中，運算符（operators）是一些特殊的符号，用來指明可以執行某種計算。

那些被運算符操作的值叫做操作數（operands）。

>>> a = 10 >>> b = 20 >>> a b 30

這個簡單的例子中，運算符 将 a 和 b 兩個操作數相加。

操作數既可以是字面常量，也可以是指向對象的變量。

>>> a b -5 25

像 a b - 5 這樣由運算符和操作數組成的序列稱為表達式。

Python 提供了衆多的運算符來将各種對象組成表達式。

我們按照運算類型分别介紹一下這些運算符。

【算術運算符】

顧名思義，算術運算符是用來做算術運算的。

下表列舉了 Python 支持的算術運算符。

看一些例子：

>>> a = 4 >>> b = 3 >>> a 4 >>> -b -3 >>> a b 7 >>> a-b 1 >>> a*b 12 >>> a/b 1.3333333333333333 >>> a%b 1 >>> a ** b 64 >>> a // b 1

除法（/）運算的結果始終為 float 類型，即使可以整除。

>>> 10 /5 2.0 >>> type(10 / 5) <class 'float'>

對于地闆除（floor division），若結果為正，小數部分被舍棄；若結果為負，結果被約等為和其值最接近的不大于該值的整數。你可以這樣統一理解，地闆除的結果就是取數軸上結果點左側最靠近它的那個整數。

>>> 10 / 4 2.5 >>> 10 // 4 2 >>> >>> 10 / -4 -2.5 >>> 10 // -4 -3 >>> >>> -10 / -4 2.5 >>> -10 // -4 2

【比較運算符】

比較運算符用于比較兩個對象的“大小”。不同對象有其自定義的“大小”語義。

下表列舉了 Python 支持的比較運算符。

看一些例子：

>>> a = 10 >>> b = 20 >>> a == b False >>> a != b True >>> a <= b True >>> a >= b False >>> >>> b = 20 >>> a == b False

比較運算符通常用于 Boolean 上下文中，比如條件和循環語句，以改變程序的控制流程。

這裡需要注意一下浮點數的等值比較。

我們在 Python 變量中介紹過，存儲在 float 對象中的數值可能并非你所想的那麼精确。因此，直接比較兩個浮點數是否相等，通常是不可取的操作。

>>> x = 1.1 2.2 >>>x==3.3 False >>> x 3.3000000000000003

正确的做法是：比較兩個浮點數是否足夠接近彼此，它們的“距離”在可接受的誤差範圍内即認為兩者相等。

>>> distance = 0.00001 >>> x = 1.1 2.2 >>> abs(x - 3.3) < distance True

【邏輯運算符】

邏輯運算符包括：not、or 和 and。這三者可連接和修改 Boolean 上下文中的表達式，從而表達更複雜的條件語義。

1，包含 Boolean 類型操作數的邏輯表達式

我們知道，Python 中有些對象和表達式的值可以是 True 或 False，這時候，這些對象和表達式實際上就是 Boolean 類型。

>>> x = 5 >>> x < 10 True >>> type(x < 10) <class 'bool'> >>> >>> t = x > 10 >>> t False >>> type(t) <class 'bool'> >>> >>> callable(x) False >>> type(callable(x)) <class 'bool'> >>> >>> t = callable(len) >>> t True >>> type(t) <class 'bool'>

在上邊這些例子中，x<10、callable(x)、t 都是 Boolean 類型的對象或表達式。

當表達式中含有這些 Boolean 類型的操作數時，計算表達式的值很簡單。

可根據下表來計算：

看一些例子：

>>> x = 5 >>> x < 10 True >>> not x < 10 False >>> callable(x) False >>> not callable(x) True >>> >>> x < 10 or callable(x) True >>> x < 0 or callable(x) False >>> >>> x < 10 and callable(x) False >>> x < 10 and callable(len) True

2，非 Boolean 類型的值在 Boolean 上下文中的求值

Python 中還有很多對象和表達式的值并不等于 True 或 False，即它們非 Boolean 類型。

盡管如此，在需要進行 Boolean 計算的環境中，這些對象或表達式也可以被适當處理，從而被視為“真值（truthy）”或“假值（falsy）”。

那麼，到底何為真？何為假？嗯，這可以上升為一個較難回答的哲學問題。

但在 Python 中，真與假卻是良好定義的。

在 Boolean 上下文中，以下這些情況均視作假：

• Boolean 類型值：False
• 任何在數字上等于0的值：0、0.0、0.0 0.0j
• 空字符串：''
• 任何空的内置組合數據類型
• 關鍵字 None 表示的值

其他 Python 内置的對象可判為真。

我們可以使用 bool() 函數來判斷一個對象或表達式是否為真。若參數為真值，bool() 返回 True，否則返回 False。

數字數值的 Boolean 判定方法：

值為 0 的數字為 False，非 0 值為 True。

>>> print(bool(0), bool(0.0), bool(0.0 0.0j)) False False False >>> print(bool(-3), bool(3.14159), bool(1.0 1j)) True True True

字符串的 Boolean 判定方法：

空字符串為 False，非空字符串為 True。

>>> print(bool(''), bool(""), bool("""""")) False False False >>> print(bool('foo'), bool(" "), bool(''' ''')) True True True

内置組合類型對象的 Boolean 判定方法：

Python 内置的組合數據類型包括：list、tuple、dict 和 set。它們是可以包含其他對象的“容器”。

當這些容器不含任何其他對象時，這些容器就是空的。若容器為空，容器對象就視作假；容器非空，容器對象就視作真。

>>> type([]) <class 'list'> >>> bool([]) False >>> type([1, 2, 3]) <class 'list'> >>> bool([1, 2, 3]) True

關鍵字 None 永遠為假。

>>> bool(None) False

3，包含非 Boolean 類型操作數的邏輯表達式

非 Boolean 類型的值也可用在邏輯表達式中，通過 not、or 和 and 來修改或組合。表達式的計算結果依賴于這些非 Boolean 操作數的真假。

注意：這裡，表達式的結果不一定是 Boolean 值！

not 作用于非 Boolean 操作數：

例如：

>>> x = 3 >>> bool(x) True >>> not x False >>> >>> x = 0.0 >>> bool(x) False >>> not x True

or 作用于非 Boolean 操作數：

例如：

>>> x = 3 >>> y = 4 >>> x or y 3 >>> x = 0.0 >>> y = 4.4 >>> x or y 4.4

and 作用于非 Boolean操作數：

例如：

>>> x = 3 >>> y = 4 >>> x and y 4 >>> x = 0.0 >>> y = 4.4 >>> x and y 0.0

4，複合表達式與短路求值

我們在上文列舉的例子都是使用了一個運算符和至多兩個操作數：

x or y xand y

實際上，多個運算符和操作數也可以連在一起使用，形成複合邏輯表達式。

複合 or 表達式形式如下：

x1orx2orx3or...xn

當 xi 中任一操作數為True 時，表達式為 True。

在處理這類包含多個邏輯運算符的表達式時，Python 采用“短路求值”法來計算表達式的值。解釋器會從左向右逐一計算每個操作數 xi 的值。一旦遇到一個 xi 的值為 True，整個表達式就被認為是 True，此時，解釋器不再繼續向右計算，表達式的值就是最後那個已計算的 xi 操作數的值。

請注意體會“表達式的真假值”和“表達式的值”的區别，我們有時候會混用這兩個概念。

為便于理解“短路求值”，我們可以設計一個簡單的函數 f()，該函數的功能為：

• f() 接受一個單一的值作為參數
• f() 将參數輸出到控制台
• f() 将參數作為返回值返回

這是幾個調用 f() 的例子：

>>> f(0) -> f(0) = 0 0 >>> >>> f(False) -> f(False) = False False >>> >>> f(1.5) -> f(1.5) = 1.5 1.5

我們可以向 f() 傳遞具有真值或假值的參數，以使得 f(arg) 的值也為真或假。并且，通過控制台的輸出，我們能看到複合邏輯表達式中某一部分是否被調用了。

來看下邊這個複合邏輯表達式：

>>> f(0) or f(False) or f(1) or f(2) or f(3) -> f(0) = 0 -> f(False) = False -> f(1) = 1 1

按照上邊的介紹，f(0)、f(False) 依次被調用，直到 f(1) 為 True 時，表達式已能被判定為 True，計算到此結束，表達式的值就是 f(1) 的值。f(2) 和 f(3) 不會被執行到。

複合 and 表達式形式如下：

x1andx2andx3and ... xn

所有 xi 均為 True，表達式才為 True。

短路求值對複合 and 表達式的處理邏輯為：從左到右依次計算每個操作數的真假值，一旦遇到一個 xi 的值為 False，整個表達式就被判定為 False，計算結束，表達式的值就是最後那個已計算的 xi 操作數的值。

仍使用 f() 函數來看兩個例子：

>>> f(1) and f(False) and f(2) and f(3) -> f(1) = 1 -> f(False) = False False >>> >>> f(1) and f(0.0) and f(2) and f(3) -> f(1) = 1 -> f(0.0) = 0.0 0.0

這兩個表達式的計算過程都停止在第一個為假值的操作數上：f(False)、f(0.0)，表達式的值分别為 False 和 0.0。後邊的 f(2) 和 f(3) 沒有被調用。

如果所有的操作數都是真值，那麼它們都會被計算，最後一個操作數的值就是表達式的值。

>>> f(1) and f(2.2) and f('bar') -> f(1) = 1 -> f(2.2) = 2.2 -> f(bar) = bar 'bar'

短路求值在實際應用中有一些慣用場景：

• 避免出現異常假設有兩個變量：a 和 b。我們想要判斷 (b / a) 是否大于 0.>>> a = 3>>> b = 1>>> (b / a) > 0True這裡，需要注意 a 的值不能為 0，否則會導緻異常：>>> a = 0>>> b = 1>>> (b / a) > 0Traceback (most recent call last): File "<stdin>", line 1, in <module>ZeroDivisionError: division by zero我們可借助短路求值避免這種異常：>>> a = 0>>> b = 1>>> a != 0 and (b / a) > 0Falsea 為 0 時，a != 0 為假值，and 表達式求值結束，右邊的除法運算不會執行到。對于這個問題，我們還可以寫出更簡單的表達式：>>> a = 0>>> b = 1>>> a and (b / a) > 00作為數字，a 為 0 時，其就是一個假值，and 表達式也會結束求值過程。
• 選擇默認值為變量賦值時，若遇到 0 或 空值，可借助短路求值為變量賦一個默認值。比如，我們想使用字符串 s2 為字符串 s1 賦值，如果 s2 為空字符串，我們可以為 s1 指定一個默認值。>>> s2 = "World">>> s1 = s2 or 'Hello'>>> s1'World'>>>>>> s2 = ''>>> s1 = s2 or 'Hello'>>> s1'Hello'

5，鍊式比較

在 Python 中，多個比較運算符可以串聯起來使用。

比如，下邊這兩個表達式基本相同：

>>>x<y<=z >>>x<yandy<=z

它們有一點區别：y 的計算次數不同。x < y <= z 中，y 隻計算一次；x < y and y <= z 中，y 會被計算兩次。

如果 y 隻是一個靜态值，比如 1，這種差别微乎其微。但假如 y 是一個複雜的表達式，少一次計算可能會帶來可觀的效率上的提升。例如：

x < f() <= zx < f() and f() <= z

更一般的情況，如果 op1、op2、op...、opn 是比較運算符，那麼下邊的表達式具有相同的 Boolean 值：

x1op1x2op2x3...opn xn x1op1x2andx2op2x3andx3 ... opn xn

同樣，前者中的 xi 隻計算一次，而後者中的非首尾的 xi 會計算兩次，除非計算提前結束。

【位操作運算符】

位操作運算符将操作數視為二進制序列，對操作數進行逐位運算。

下表列舉了 Python 支持的位操作運算符。

看一些例子：

>>> '0b{:04b}'.format(0b1100 & 0b1010) '0b1000' >>> '0b{:04b}'.format(0b1100 | 0b1010) '0b1110' >>> '0b{:04b}'.format(0b1100 ^ 0b1010) '0b0110' >>> '0b{:04b}'.format(0b1100 >> 2) '0b0011' >>> '0b{:04b}'.format(0b0011 << 2) '0b1100'

這裡，以二進制的形式來表示操作數和運算結果，可以清晰地看出位運算的執行邏輯。

【ID 運算符】

id 運算符用于判斷兩個操作數是否擁有相同 id，也即是否指向同一對象。

這和“相等”不是同一個概念，相等表示兩個操作數的值相等，而它們不一定指向同一個對象。

Python 提供 is 和 is not 兩個 id 運算符。

看一些例子：

>>> a = 798 >>> b = 798 >>> a == b #相等 True >>> a is b #id 不同 False >>> >>> a = 798 >>> b = a >>>aisb#a、b指向同一對象，id 相同 True

可結合 《一文理解 Python 中的變量》來理解。

【運算符的優先級】

我們都知道算術中的混合運算可以包含多種運算符，這些運算符可改變運算順序。

>>> 20 4 * 10 60

在這個例子中，同時存在 和 * 兩種運算符，按照算術規則，先算乘法後算加法，乘法優先級高于加法。

Python 中的每個運算符也都有一定的優先級。優先級高的運算符先被執行，優先級相同的運算符按照從左向右的順序執行。

我們目前已使用了多種運算符，按優先級從低到高列表如下：

看一些例子：

>>> 2 * 3 ** 4 * 5 810

括号可以改變運算符的優先級，并且有助于理解運算的先後順序。

>>> 20 4 * 10 60 >>> (20 4) * 10 240 >>> 2 * 3 ** 4 * 5 810 >>> 2 * 3 ** (4 * 5) 6973568802

【擴展的賦值運算符】

賦值（=）運算符用于為變量賦值。既可以為變量賦靜态值，也可以為其賦予一個包含其他變量的表達式，并且表達式中還可以包含變量自身。

>>> a = 10 >>> b = 20 >>> c = a * 5 b >>> c 70 >>> a = a 5 >>> a 15 >>> b = b * 3 >>> b 60

對于 a=a 5、b=b*3 這種賦值形式，其含義是在變量自身基礎上再進行賦值操作。其前提是，變量必須已經被賦予了初值，否則導緻錯誤。

>>> i = i / 12 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'i' is not defined

Python 為上邊這種賦值方式提供了一個簡寫形式：

x <op>= y

這種簡寫等同于：

x = x <op> y

支持這種擴展賦值方式的運算符包括：

、=、*、/、%、//、**、&、|、^、>>、<<

看一些例子：

>>> a = 5 >>> a = 2 >>> a 7 >>> b = 16 >>> b /= 4 >>> b 4.0

【結語】

本文詳細介紹了 Python 提供的各種運算符，以及如何這些運算符來生成表達式。

特别指出了浮點比較運算、短路求值等細節性問題，相信會對你理解和使用運算符和表達式提供幫助。

我們接下來會學一個非常重要的數據類型：字符串。

更多精彩资讯请关注tft每日頭條，我们将持续为您更新最新资讯!