可变不可变类型和逻辑运算

1、基本运算符

1.1、算术运算符

'''
+、-、*、/（结果带小数）、//（地板除，只保留整数部分）、%（取余、取模）、**（次方）
'''
print(10 + 3.1)
print(10 ** 3) # 十的三次方

1.2、比较运算符

'''
>、>=、<、<=、==、!=
'''
# 用于条件判断、返回值是True或者False

1.3、赋值运算符

• ​ **变量的赋值: = **

1.3.1 增量赋值

'''
*=、/=、-=、%=、**=、//=
'''
age = 18
# age = age + 1
age += 1
print(age)

1.3.2 链式赋值

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

1.3.3 交叉赋值

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

1.3.4 解压赋值

salaries=[11,22,33,44,55]
# 把五个月的工资取出来分别赋值给不同的变量
'''
mon0=salaries[0]
mon1=salaries[1]
mon2=salaries[2]
mon3=salaries[3]
mon4=salaries[4]
'''
mon0, mon1, mon2, mon3, mon4 = salaries
print(mon0, mon1, mon2, mon3, mon4)

# *_ 指后续的值会被*存称一个列表赋值给_，
# _ 通常指被废弃掉的变量，做一个占位符而已，约定熟成 
# *_ 只能取两端的值，不能够取中间值,且*在解压赋值中只能出现一次
mon0, mon1, *_ = salaries # 只取前两个值
*_, mon0, mon1= salaries # 只取后两个值
mon0, *_, mon1= salaries # 只取开头第一个值跟最后一个值
print(mon0, mon1)

# 解压字典默认解压出来的是字典的key
x,y,z=dic={'name':'Umi','age':18,'sex':'male'}
print(x,y,z)

2、可变不可变类型

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

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

2.1、验证

2.1.1 int是不可变类型

x=10
print(id(x))
x=11 # 产生新值
print(id(x))

2.1.2 float是不可变类型

x=3.1
print(id(x))
x=3.2
print(id(x))

2.1.3 str是不可变类型

x="abc"
print(id(x))
x='gggg'
print(id(x))

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

2.1.4 list是可变类型

l=['aaa','bbb','ccc']
print(id(l))
l[0]='AAA'
print(l)
print(id(l))

2.1.5 dict是可变类型

x={'k1':111, 'k2':222}
print(id(x)) # 3199870035008
x['k1']=333
print(id(x)) # 3199870035008
'''
关于字典补充：
定义：{}内用逗号分隔多key:value，
  其中value可以是任意类型
  但是key必须是不可变类型
'''

2.1.6 布尔类型是不可变类型

dic={
    'k1':111,
    'k2':3.1,
    'k3':[333,],
    'k4':{'name':'egon'}
}
dic={
    2222:111,
    3.3:3.1,
    'k3':[333,],
    'k4':{'name':'egon'}
}
print(dic[3.3])
dic={[1,2,3]:33333333}
dic={{'a':1}:33333333}

3、条件

3.1、什么是条件？

​ 条件就是为了达成某种状况而所要具备的机制

3.2、什么可以当做条件？

3.2.1、第一大类：显式布尔值

比较运算符
age = 18
print(age > 16)  # 条件判断之后会得到一个布尔值True
布尔类型
is_beautiful=True
print(is_beautiful)

3.2.2、第二大类：隐式布尔值

​ 所有的值都可以当成条件去用

​ 其中0、None、空(空字符串、空列表、空字典)=》代表的布尔值为False，其余都为真

print(bool(0)) # False
print(bool(None)) # False
print(bool('')) # False
print(bool([])) # False
print(bool({})) # False

3.2.3、为何要要用条件？

​ 为了能够让计算机具备人的这种判断事物是否能够成立的机制

3、逻辑运算符

3.1、not、and、or的基本使用

3.1.1、 not

​ not：就是把紧跟其后的那个条件结果取反
​ ps:not与紧跟其后的那个条件是一个不可分割的整体

print(not 16 > 13)
print(not True)
print(not False)
print(not 10)
print(not 0)
print(not None)
print(not '')

3.1.2、and

​ and：逻辑与，and用来链接左右两个条件，两个条件同时为True，最终结果才为真

print(True and 10 > 3)

print(True and 10 > 3 and 10 and 0) # 条件全为真，最终结果才为True
print( 10 > 3 and 10 and 0 and 1 > 3 and 4 == 4 and 3 != 3)  # 偷懒原则

3.1.3、or

​ or：逻辑或，or用来链接左右两个条件，两个条件但凡有一个为True，最终结果就为True，两个条件都为False的情况下，最终结果才为False

print(3 > 2 or 0)
print(3 > 4 or False or 3 != 2 or 3 > 2 or True) # 偷懒原则

3.2、优先级not>and>or

如果单独就只是一串and链接，或者说单独就只是一串or链接，按照从左到右的顺讯依次运算即可（偷懒原则）
如果是混用，则需要考虑优先级了

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

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

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

4、成员运算与身份运算

​ 成员运算符:in/not in

​ 身份运算符:is 判断的是id是否相等

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

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

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

not in
print("egon" not in "hello egon") # 推荐使用
print(not "egon" in "hello egon") # 逻辑同上，但语义不明确，不推荐