算術運算符

python支持的算數運算符與數學上計算的符號使用是一致的(x = 5 , y = 2)：

算術運算符

描述

示例

+

兩個對象相加

x + y = 7

-

兩個對象相減

x - y = 3

*

兩個對象相乘

x * y = 10

/

除，返回值保留整數和小數部分

x / y = 2.5

//

整除，只保留整數部分

x // y = 2

%

取余數

x % y = 1

**

一個數的n次方

x ** y = 25

x = 5

y = 2

print(f"x + y = {x + y}")

print(f"x - y = {x - y}")

print(f"x * y = {x * y}")

print(f"x / y = {x / y}")

print(f"x // y = {x // y}")

print(f"x % y = {x % y}")

print(f"x ** y = {x ** y}")

# x + y = 7

# x - y = 3

# x * y = 10

# x / y = 2.5

# x // y = 2

# x % y = 1

# x ** y = 25

比較運算符

比較運算用來對兩個值進行比較，返回的是布爾值(x = 5，y = 2)：

比較運算符

描述

示例

==

相等

x ==y // False

!=

不相等

x !=y // True

>

大于

x > y // True

>=

大于等于

x >= y // True

<

小于

x < y // False

<=

小于等于

x <= y // False

x = 5

y = 2

print(f"x == y = {x == y}")

print(f"x != y = {x != y}")

print(f"x > y = {x > y}")

print(f"x >= y = {x >= y}")

print(f"x < y = {x < y}")

print(f"x <= y = {x <= y}")

# x == y = False

# x != y = True

# x > y = True

# x >= y = True

# x < y = False

# x <= y = False

賦值運算符

python語法中除了有=號這種簡單的賦值運算外，還支持增量賦值、鏈式賦值、交叉賦值、解壓賦值，這些賦值運算符存在的意義都是為了讓我們的代碼看起來更加精簡。

增量賦值

賦值運算符

描述

示例

+=

加法賦值運算符

x += 1 相當于 x = x + 1

-=

減法賦值運算符

x -= 1 相當于 x = x - 1

*=

乘法賦值運算符

x *= 1 相當于 x = x * 1

/=

除法賦值運算符

x /= 1 相當于 x = x / 1

//=

整除賦值運算符

x //= 1 相當于 x = x // 1

%=

取余賦值運算符

x %= 1 相當于 x = x % 1

**=

冪賦值運算符

x **= 1 相當于 x = x ** 1

x = 5

x += 2

print(f"x += 2 = {x}") # 7

x = 5

x -= 2

print(f"x -= 2 = {x}") # 3

x = 5

x *= 2

print(f"x *= 2 = {x}") # 10

x = 5

x /= 2

print(f"x /= 2 = {x}") # 2.5

x = 5

x //= 2

print(f"x //= y = {x}") # 2

x = 5

x %= 2

print(f"x %= y = {x}") # 1

x = 5

x **= 2

print(f"x **= y = {x}") # 25

鏈式賦值

如果我們想把同一個值同時賦值給多個變量名可以這么做：

z = 10

y = z

x = y

print(x, y, z) # 10 10 10

鏈式賦值指的是可以用一行代碼搞定這件事：

x = y = z = 10

print(x, y, z) # 10 10 10

交叉賦值

如果我們想交換兩個變量的值可以這么做：

x = 10

y = 20

print(f"x = {x}, y = {y}")

# x = 10, y = 20

temp = x

x = y

y = temp

print(f"x = {x}, y = {y}") # x = 20, y = 10

交叉賦值指的是一行代碼可以搞定這件事：

x = 10

y = 20

print(f"x = {x}, y = {y}") # x = 10, y = 20

x, y = y, x

print(f"x = {x}, y = {y}") # x = 20, y = 10

解壓賦值

如果我們想把列表中的多個值取出來依次賦值給多個變量名可以這么做：

numbers = [1, 2, 3]

a = numbers[0]

b = numbers[1]

c = numbers[2]

print(a, b, c) # 1 2 3

解壓賦值指的是一行代碼可以搞定這件事：

numbers = [1, 2, 3]

a, b, c = numbers

print(a, b, c) # 1 2 3

解壓賦值時等號左邊的變量名個數必須與右面包含值的個數相同，否則會報錯：

numbers = [1, 2, 3]

# 變量個數少了

a, b = numbers

# Traceback (most recent call last):

# File "/Users/fqyy/Downloads/Code/Learn/Python/demo.py", line 3, in # a, b = numbers

# ValueError: too many values to unpack (expected 2)

# 變量個數多了

a, b, c, d = numbers

# Traceback (most recent call last):

# File "/Users/fqyy/Downloads/Code/Learn/Python/demo.py", line 11, in

# a, b, c, d = numbers

# ValueError: not enough values to unpack (expected 4, got 3)

如果我們只想取頭尾的幾個值可以用 *變量名 進行匹配，此時Python會將沒有對應關系的值存成列表然后賦值給緊跟其后的變量名：

numbers = [1, 2, 3, 4, 5, 6]

# 取前面兩個

a, b, *_ = numbers print(a, b) # 1 2

# 取后面兩個

*_, a, b = numbers print(a, b) # 5 6

注意： 這里的 _ 是變量名，一般自己定義變量的時候不要使用下劃線( _ )開頭和結尾，或者直接使用下劃線( _ )，從Python的規范上來說它們都有特殊的用處，所有自己定義的變量不要去用。比如這里直接使用下劃線( _ )接受數據表示該變量一般不會使用，僅僅做為占位符。

除了列表外，字符串、字典、元組、集合類型都支持解壓賦值：

# 列表

l = [1, 2, 3]

a, b, c = l

print(a, b, c) # 1 2 3

# 元祖

t = (4, 5, 6)

a, b, c = t

print(a, b, c) # 4 5 6

# 集合

s = {7, 8, 9}

a, b, c = s

print(a, b, c) # 8 9 7

# 字符串

a, b, c = "abc"

print(a, b, c) # a b c

# 字典 獲取的是key值

a, b, c = {"name": "Tom", "age": 18, "gender": "男"}

print(a, b, c) # name age gender

邏輯運算符

邏輯運算符

描述

and

邏輯與，只有當兩個對象都是True的時候返回True， 否則返回False

or

邏輯或，只有當兩個對象都是False的時候返回False，否則返回True

not

取反

邏輯運算符用于連接多個條件進行關聯判斷，會返回布爾值：

# 邏輯與

print(1 and 2) # 2

print(1 and 0) # 0

print(0 and 0) # 0

# 邏輯或

print(1 or 2) # 1

print(1 or 0) # 1

print(0 or 0) # 0

# 邏輯非

print(not 1) # False

print(not 0) # True

可以用and連接多個條件，會按照從左到右的順序依次判斷，一旦某一個條件為False，則無需再往右判斷，可以立即判定最終結果就為False；只有在所有條件的結果都為True的情況下，最終結果才為True：

# 多個and

# 有一個是False就為False

print(1 and 0 and 2) # 0

# 全部是True的時候才是True

print(1 and 2 and 3) # 3

同樣也可以用or連接多個條件，此時會按照從左到右的順序依次判斷，一旦某一個條件為True，則無需再往右判斷，可以立即判定最終結果就為True；只有在所有條件的結果都為False的情況下，最終結果才為False：

# 多個or

# 有一個是True就是True

print(1 or 0 or 2) # 1

# 全部是False的時候才是False

print(0 or 0 or 0) # 0

注意： 三者的優先級關系 not > and > or ，同一優先級默認從左往右計算。最好使用括號來區別優先級，其實意義與上面的一樣。

邏輯運算的結果一旦可以確定，那么就以當前處計算到的值作為最終結果返回，這種現象叫做 短路運算：

# 因為or只要有一個為True就是True，因此當獲取到1后不會在執行后面的

print(1 or 0 or 2) # 1

# 因為or只要有一個為False就是False，因此當獲取到0后不會在執行后面的

print(0 and 1 and 2) # 0

成員運算符

成員運算符

描述

in

某個對象是否包含另一個對象，字符串、列表、元祖、集合和字典都支持

not in

某個對象是否不包含另一個對象

# 字符串

print('a' in 'Hello') # False

print('a' not in 'Hello') # Ture

# 字典 默認判斷是的key

print('a' in {"name": "age"}) # False

print('a' not in {"name": "age"}) # True

# 集合

print('a' in {'a', 'b'}) # True

print('a' not in {'a', 'b'}) # False

# 列表

print('a' in ['a', 'b']) # True

print('a' not in ['a', 'b']) # False

# 元祖

print('a' in ('a', 'b')) # True

print('a' not in ('a', 'b')) # False

注意： 雖然兩種判斷可以達到相同的效果，但推薦使用not in，因為它的語義更加明確。

身份運算符

身份運算符

描述

is

某個對象是否包含另一個對象，字符串、列表、元祖、集合和字典都支持

is not

某個對象是否不包含另一個對象

x = "Hello World"

y = "Hello World"

z = x

print(x is y) # False

print(x is not y) # True

print(x is z) # True

print(x is not z) # False