06 Python入门之基本运算符

167次阅读
没有评论

共计 2391 个字符,预计需要花费 6 分钟才能阅读完成。

一. 算数运算符

1. 加减乘除

print(10 + 3) 13
print(10 - 3) 7
print(10 * 3) 30
print(10 / 3) 3.333....(到达一定精度后停止)

2. 整除(地板除) //

  • 只保留整数部分,不是四舍五入,而是直接抛弃小数部分
print(10 / 3) 3.333333....
print(10//3) 3

3. 取余(取模) %

🍁"10" 除于 "3" 余 "1"
print(10%3)  #1

4. 多少次方 ^

🍁"10" 的 "3" 次方
print(10**3)   #1000

二. 比较运算

> 大于
< 小于
= 等于
!= 不等于
<= 小于等于
>= 大于等于
  • 一个等于号是赋值操作
  • 两个等于号才是等于

三. 赋值运算符

  • 像这样 : age = 18

1. 增量赋值

age += 10 等同于 age = age + 10
age -= 10 等同于 age = age - 10
age *= 10 等同于 age = age * 10
age /= 10 等同于 age = age / 10
age //= 10 等同于 age = age // 10
age %= 10 等同于 age = age % 10
age **= 10 等同于 age = age ** 10

2. 交叉赋值

a = 20
b = 10
🍁通过中间值将其值变换
zz = a   #zz = 20
a = b    #a = 10
b = zz   #b = 20

🍁通过等号赋值符号交叉
a, b = b, a 

3. 链式赋值

🍁一个变量值要同时绑定多个变量名
a = 10
b = a
c = b
d = c

🍁通过链式赋值
a = b = c = d = 10

4. 解压运算符

  • 直言是多个指定的数据类型都可以解压
  • 可用于字符串, 列表, 元组, 字典, 集合, 多用于列表, 元组
  • 如果用于字典, 则解压的结果是 key
  • 使用 *_ 来将剩余的值存成一个列表(单个 _ 表示该变量被废弃)
salary = [1.1, 2.2, 3.3, 4.4, 5.5,6.6,44]
🍁只想取前三个
m1,m2,m3,*_ = salary
print(m1,m2,m3)  #1.1,2.2,3.3
print(_)         #4.4,5.5,6.6,44

🍁取前面一个和后面两个
m1,*_,m7,m8 = salary
print(m1,m7,m8)  #1.1,6.6,44
print(_)         #2.2,3.3,4.4,5.5

🍁可以自由搭配

四. 逻辑运算符

1.not 逻辑非

  • 把紧跟其后的那个条件的布尔值取反
print(not 10 == 10) #False
print(not 10 < 0)   #True
print(not True)     #False
print(not False)    #True
print(not None)     #True
.........

2.and 逻辑与

  • and 用来连接左右两个条件,两个条件同时为 True,最终结果才为 True

  • 两个条件有一个为 False,结果一定为 False.

#       True     True
print(True and 10 > 3)

#       True     True    True  False
print(True and 10 > 3 and 10 and 0)  # 0

#       True     True    False(and 偷懒, 计算 0 就不计算了)
print(10 > 3 and 10 and 0 and 1 > 3 and 4 == 4 and 3 != 3)  # 0

3.or 逻辑或

  • or 用来连接左右两个条件,两个条件同时为 False,最终结果才为 False
  • 两个条件有一个为 True,结果一定为 True
#      True(or 偷懒,计算到 3 > 2 就不计算了)
print(3 > 2 or 0)   # True
#       True(or 偷懒,计算到 3 > 4 就不计算了)print(3 > 4 or False or 3 != 2 or 3 > 2 or True)    # True

4. 短路运算(偷懒原则)

  • 只要 and 左边的值为 Flaseand 右边的值将不会执行,返回结果就是 False(偷懒原则), 如果为True 则继续判断后面的条件
  • 只要 or 左边的值为 Trueor 右边的值将不会执行,返回结果就是 True(偷懒原则),如果为Flase 则继续判断后面的条件
print((1 > 2 and 2 < 3) or (4 and not 1 != 3) or (3 and []))  #[]
#            False                 False             []

5. 或, 与, 非的优先级

  • not > and > or
🍁 第一步计算:not 4 > 3,为 False
🍁 第二步计算:3 > 4 and Flase,为 False
🍁 第三步计算:1 == 3 and 'x' == 'x',为 Flase(偷懒原则)
🍁 第四步计算:这个时候只剩下 or 从左到右依次计算,Flase
res = 3 > 4 and not 4 > 3 or 1 == 3 and 'x' == 'x' or 3 > 3
print(res)  # False

五. 成员运算

适用于字符串时,判断子字符串是否在大字符串中

1.in

🍁判断子字符串是否在大字符串中
print("shawn" in "hello shawn") # True
print("sha" in "hello shawn")       # True
print("he sh" in "hello shawn")     # False

🍁判断 key 是否存在于字典中(注意:in 判断的条件是 key)print(111 in {"k1": 111, 'k2': 222})    # False
print("k1" in {"k1": 111, 'k2': 222})   # True

2.not in

🍁用法一:条件 1 not in 条件 2(推荐使用)print("shawn" not in "hello shawn")  # False

🍁用法二:not 条件 1 in 条件 2(先运算条件 1 in 条件 2 再取反)print(not "shawn" in "hello shawn")  # False

六. 身份运算

is : 判断左右两边的 id 是否相等

🍁两个不同的内存地址关联不同的变量名, 只是存的值一样
li1 = [111, 222, 333]
li2 = [111, 222, 333]
print(id(li1))     #2160395309640
print(id(li2))     #2160395310152
print(li1 is li2)  #False

🍁两个变量名关联同一个内存地址
x = 10
y = x
print(x)       #140725148348960
print(y)       #140725148348960 
print(x is y)  #True
正文完
 
shawn
版权声明:本站原创文章,由 shawn 2023-06-16发表,共计2391字。
转载说明:除特殊说明外本站文章皆由CC-4.0协议发布,转载请注明出处。
评论(没有评论)