运算符们的介绍，以及结算顺序啥玩意的

本文详细介绍了Python中的算术、比较、赋值、逻辑运算符以及条件判断，包括取模、增量赋值、交叉赋值、链式赋值、解压赋值等，并探讨了可变与不可变类型的特性，如int、float、str的不可变性和list、dict的可变性。此外，还解释了成员和身份运算符的使用，以及条件判断的逻辑。

# 1.算术运算符加减乘除、取模、取余
# print(135 + 46)
# print(3 + 5.1)
# print(3 - 1)
# print(3 * 5)
# print(10 / 3) # 结果带小数
# print(10 // 3) # 只保留整数部分、取模
# print(10 % 3) # 取余数
# print(10 ** 3) # 取次数幂

# 2.比较运算符:> < == >= <= !=
# print(10>3)
# print(10==10)
#
# print(10>=3)
# print(10<=3)
# print(10!=3)

# 3.赋值运算符
# 3.1 =:变量的赋值
x=1
y=2

# 3.2 增量赋值：+=
# age = 18
# age = age + 1
# print(age)
#
# age += 1
# print(age)
#
# age *= 3
# age /= 3
# age %= 3
# age **= 3

# 3.3 链式赋值
# x = 10
# y = x
# z = y
# print(x, y, z)
# print(id(x), id(y), id(z))
#
# z = y = x = 10 # 链式赋值
# print(x, y, z)
# print(id(x), id(y), id(z))

# 3.4 交叉赋值
m = 10
n = 20

# m = n # m=n n=20 m=20
# n = m # n=m m=20 n=20
# print(m, n)

# temp = m
# m = n
# n = temp
# print(m, n)
#
# m, n = n, m # 交叉赋值
# print(m, n)

# 解压赋值
salaries = [111, 222, 333, 444, 555]
# 把五个月的工资取出来分别赋值给不同的变量名
# mon0 = salaries[0]
# mon1 = salaries[1]
# mon2 = salaries[2]
# mon3 = salaries[3]
# mon4 = salaries[4]
# print(mon0)
# print(mon1)
# print(mon2)
# print(mon3)
# print(mon4)
#
# mon0,mon1,mon2,mon3,mon4 = salaries
# print(mon0)
# print(mon1)
# print(mon2)
# print(mon3)
# print(mon4)

# mon0,mon1,mon2,mon3=salaries # 对应的变量名少一个不行
# mon0,mon1,mon2,mon3,mon4,mon5=salaries # 对应的变量名多一个也不行

# 引入*，可以帮助我们取两头的值，无法取中间的值
# 取前三个值
# x, y, z, *_ = salaries # *会将没有对应关系的值存成列表然后赋值给紧跟*其后的那个变量名,此处这个变量名为_
# print(x, y, z)
# print(_)
#
# x, y, z, *aaa = salaries
# print(aaa)
#
# 取后三个值
# *_, x, y, z = salaries
# print(x, y, z)
# print(_)
#
#
# x, *_, y, z = salaries
# print(x, y, z)

# *_1,x,y,*_2 = salaries

# # 拓展
# _, _, *x, _ = salaries
# print(x)

# 解压赋值应用于字典时，默认解压出来的是字典的key
dic={'a':1,'b':2,'c':3}

x,y,z = dic

print(x,y,z)

'''
5.算术运算符相关
每种方式用1个示例演示
取模运算
增量赋值
交叉赋值
链式赋值
解压赋值
'''

逻辑运算符

# 可变不可变类型

# 可变类型：值改变，id不变，证明原值是可以被改变的

# 不可变类型：值改变，id也改变了，证明是产生新的值，压根没有改变原值；证明原值是不可被修改的

# 2.验证
# 2.1 int是不可变类型
x=10
print(id(x))
x=11 # 产生新值
print(id(x))

# 2.2 float是不可变类型
x=3.1
print(id(x))
x=3.6 # 产生新值
print(id(x))

# 2.3 str是不可变类型
x='xiaoxiao'
print(id(x))
x='xiaomin' # 产生新值
print(id(x))

# 小结：int、float、str都被设计成了不可分割的整体，不能被改变

# 2.4 list是可变类型
l=['aaa','bbb','ccc']
print(id(l))
l[0]='AAA'
print(l)
print(id(l))

# 2.5 dict是可变类型
dic={'k1':111,'k2':222}
print(id(dic))
dic['k1']='一一一'
print(dic)
print(id(dic))

# 2.6 bool不可变
x=True
x=False

# 关于字典补充：
# 定义：{}内用逗号分隔开多个key:value,
# 其中value可以是任意类型
# 但是key必须是不可变类型

dic={
'k1':111,
'k2':3.1,
'k3':[333,555],
'k4':{'name':'xiaoxiao'}
}

dic={
111:111,
3.1415926:3.1,
'k3':[333,555]
}
print(dic[3.1415926])

# dic={[1,2]:111}
# dic={{'a',1}:111}

————————————分割线————————————

# 2.什么是条件？什么可以当作条件？为什么要用条件？
# 第一大类：显式布尔值
# 2.1 条件可以是：比较运算符
age=18
print(age>16) # 条件判断之后

# 2.2 条件可以是：True、False
# is_beautiful=True
# print(is_beautiful)

# 第二大类：隐式布尔值，所有的值都可以当成条件去用

# 1
# 'aaa'
# 3.14
# [1,23]
# ...

# 其中0、None、空（空字符串、空列表、空字典）=》代表的布尔值为False，其余都为True

# ' '
# ''

# if 条件:
# 代码

# 显式布尔值：True、False
# 隐式布尔值：所有数据类型，其中0、None、空为假

成员、身份运算符

# 1.not and or 的基本使用
# not:就是把紧跟其后的那个条件结果取反
# not与紧跟其后的那个条件是一个不可分割的整体
# print(16>13)
# print(not 16>13)
# print(not True)
# print(not False)
# print(not 10)
#
# print(not 0)
# print(not None)
# print(not '')

# and:逻辑与，and用来链接左右两个条件，两个条件同时为True，最终结果才为True
# 条件1 and 条件2
# print(True and 10>3)
# print(True and 10>3 and 10)
# print(True and 10)
# print(10 and True)
# x = True and 10>3 and 10 and 0
# x = bool(x)
# print(True and 10>3 and 10 and 0) # 条件全为真，结果才为True
# print(x)

# if True and 10>3 and 10 and 0:
# print('条件为真')

#
# print(0 and 10>3 and 5 and 0 and 1>3 and 6==6 and 'xiaoxiao') # 偷懒原则

# or:逻辑或，or用来链接左右两个条件，两个条件但凡有一个为True，最终结果就为True
# 两个条件都为False的情况下，最终结果才为False
# print(3>2 or 0)
#
# print(3>2 or 10 or 3 != 2 or 1>2 or True # 偷懒原则

# 2.优先级 not>and>or
# 如果单独就只是一串and链接，或者说单独只是一串or链接，按照从左到右的顺序依次运算即可
# 如果是混用，则需要考虑优先级

x = 3>4 and not 4>3 or 1==3 and 'x'=='x' or 3>3
x = bool(x)
print(x)

3>4 and not 4>3 or 1==3 and 'x'=='x' or 3>3
3>4 and (not 4>3) or 1==3 and 'x'=='x' or 3>3
3>4 and False or 1==3 and 'x'=='x' or 3>3
(3>4 and False) or (1==3 and 'x'=='x') or 3>3
False or False or 3>3
False or 3>3
False

(3>4 and (not 4>3)) or (1==3 and 'x'=='x') or 3>3

# 加括号
3>4 and not 4>3 or 1==3 and 'x'=='x' or 3>3

(3>4 and not 4>3) or (1==3 and 'x'=='x') or 3>3

res = (3>4 and not 4>3) or (1==3 and 'x'=='x') or 3>3
print(res)

---------------------------------------------------------------

# 1.成员运算符

print("xiaoxiao" in "hello xiaoxiao") # 判断一个字符串是否存在于一个大写字符串中
print("x" in "hello xiaoxiao")

print(111 in [111,222,33]) # 判断元素是否存在于列表
print(111 in ['111',222,33])

# 判断key是否存在于字典
print(111 in {"k1":111,"k2":456}) # False
print("k1" in {"k1":111,"k2":456}) # True

print('-'*20)
# not in
print("xiaoxiao" not in "hello xiaoxiao") # 推荐使用
print(not "xiaoxiao" in "hello xiaoxiao") # 逻辑同上，但语义不明确，不推荐

# 2.身份运算符: is
# is,判断的是id是否相等

print('-'*20)