一、注释

注释: 就是对代码的解释，方便阅读，被注释的代码不执行

分类

• 单行注释

# 1.单行注释   以#号开头 ，右边的所有东西都被当做说明文字 ，程序不进行编译运行。
print('hello world')

• 多行注释

# 2.多行注释   三个单引号 或 三个双引号
'''
这是第一行
这是第二行
'''

注意

嵌套使用时，如果外面使用三个单引号，里面使用三个双引号，反之亦然。

'''
print('hello world')
"""
print('hello world, 嵌套使用')
"""
'''

注释具有一定的排错性

先注释一部分代码，然后执行另外一部分，看看是否报错，逐层缩小报错范围，找到最终错误点。

二、变量

可以改变的量,实际具体指的是内存中的一块存储空间

变量的声明

# 1
a = 100
b = 101
print(a)
print(b)
​
# 2
a,b = 200,201
# print(值1,值2,值3, ..... ) 一行打印所有变量
print(a , b)
​
# 3
a = b = 300
print(a, b)

变量的命名

• 字母数字下划线, 首字符不能为数字
• 严格区分大小写,且不能使用关键字
• 变量命名有意义,且不能使用中文哦

# 严格区分大小写
# 关键字 : 系统预设的相关属性和函数或者特殊意义的变量;
# 引入 模块(文件)
import keyword
# 模块.属性 (文件.变量)
print(keyword.kwlist)
"""
[
'False', 'None', 'True', 'and', 'as', 'assert', 
'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 
'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 
'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while',
 'with', 'yield'
 ]
"""
# 系统预设的相关关键字不能被替换覆盖,不要使用该名字作为变量名;
"""
print = 100
print(1)   # 报错
"""

注意

• 起名字要见名知意
• 中文命名变量不会报错的,但是严禁使用

变量的交换

# 通用写法
tmp = a
a = b
b = tmp
print(a,b)
​
# python特有
a = 18
b = 19
a,b = b,a
print(a,b)

常量

永远不变的量(约定俗成:把每个字母都变成大写)

BIRTHDAY = "1010"
ID_CARD = 210205200010106688

三、数据类型分类

六大标准数据类型

Number         数字类型（int, float, bool, complex)
str            字符串类型
list           列表类型
tuple          元组类型
set            集合类型
dict           字典类型

Number 数字类型 分类：

int：         整数类型（正整数   0   负整数）
float：       浮点数类型（1普通小时  2科学计数法表示的小数  例如: a=3e-5  # 3e-05）
bool:         布尔值类型（真 True 和 假False）
complex       负数类型（声明复数的2中方法）（复数用作与科学计算中，表示高精度的数据，科学家会使用）

2个内置方法 type 和 id

# type 获取值得类型
intvar=100
res = type(intvar)
print(res)    # <class 'int'>

# id   获取值得地址
res = id(intvar)
print(res)    # 1926270160(用十进制表示的地址值)

# 二进制整型
intvar = 0b110
# 八进制整型
intvar = 0o127
# 十六进制
intvar = 0xff    # 进制不区分大小写 0xFF

# float 浮点型(小数)
# 表达方式1
floatvar = 3.6
print(floatvar  ,  type(floatvar))
# 表达方式2 科学计数法
floatvar = 5.7e5  # 小数点右移5    57000.0  10的5次幂
floatvar = 5.7e-2 # 小数点左移2    0.057    10的-2次幂
print(floatvar , type(floatvar))

# bool 布尔型 (True 真的, False 假的)
boolvar = True
boolvar = False
print(boolvar , type(boolvar))   # bool

# complex 复数类型
"""
3 + 4j
实数+虚数
实数: 3
虚数: 4j
j   : 如果有一个数他的平方等于-1,那么这个数就是j , 科学家人员用,表达一个高精度的类型
"""
# 表达方式1
complexvar = 3 + 4j
complexvar = -3j
print(complexvar , type(complexvar))

# 表达方法2 
"""
complex(实数,虚数) => 复数
"""
res = complex(3,4)
print(res , type(res))    # (3+4j) complex

自动类型转换

当2个不同类型的数据进行运算的时候，默认向更高精度转换
数据类型精度从低到高： bool int float complex

# bool + int
res = True + 100
print(res ,type(res)) # 1 + 100 => 101

# bool + float
res = True  + 344.565 # 1.0 + 344.565 => 345.565
print(res ,type(res)) 

# bool + complex
res = True + 7 - 90j  #  1 + 0j + 7 - 90j => 8 - 90j
print(res ,type(res)) 

# int + float
res = 5 + 7.88 # 5.0 + 7.88 => 12.88
print(res ,type(res)) 

# int + complex
res = 5 + 6 + 8j # 5 + 0j   6 + 8j => 11 + 8j
print(res ,type(res)) 

# float + complex 
res = 5.66 + 9.1 -90j # 5.66 + 0j + 9.1 -90j => 14.76-90j
print(res ,type(res)) 

# 小数的精度损耗 (小数后面一般有时截取15~18位,但是不完全,存在精度损耗)
"""不要用小数作比较,不准"""
print(0.1 + 0.2 == 0.3)  # 0.0999999999999999  False
print(5.1 + 5.9 == 11.0)
# True

强制类型转换

# 1. Number 类型的强制转换 (int float complex bool)
# int 强制把数据变成整型
"""int float bool 纯数字字符串"""
var1 = 13
var2 = 5.67
var3  = True
var4 = "123456"
var5 = "123abc"
var6 = 3+5j

res = int(var2)  	# 5
res = int(var3) 	# True  => 1
res = int(False)	# False => 0
res = int(var4)     # 123456
# res = int(var5) 	# ValueError
# res = int(var6) 	# TypeError
print(res , type(res))

# float 强制把数据变成小数
"""int float bool 纯数字字符串"""
res = float(var1)       # 13.0
res = float(var3) 		# True  => 1.0
res = float(False)		# False => 0.0
res = float(var4) 		# 123456.0 
print(res , type(res))

# complex 强制把数据变成复数
"""int float bool 纯数字字符串 complex"""
res = complex(var1)  # (13+0j) 添加0j 表达复数
res = complex(var2)  # (5.67+0j)
res = complex(var3)  # True => 1+0j
res = complex(False) # False => 0j
res = complex(var4)  # 123456+0j
print(res , type(res))

# bool 强制把数据变成布尔型
"""布尔型可以强转一切数据类型"""
#  布尔型为假的十种情况
""" 0 , 0.0 , False , 0j , '' ,  [] , () ,set(), {}, None """
res = bool(None)
print(res , type(res))

# 初始化变量时,不清楚用什么值,无脑写上None
"""None 代表空的,代表什么也没有,一般用于初始化变量"""
a =None
b =None

"""
默认转换成当前数据类型的一个值
int() float() complex() bool()
"""
res = bool() 
print(res , type(res))

容器类型分类：五个

str          "hello"
list         [1,2,3]
tuple        (6,7,8)
set          {"a", 1, 2}
dict         {"a": 1, "b": 2}

字符串类型 str

# 字符串类型 str
"""
用引号引起来的就是字符串,单引号,双引号,三引号

# 转义字符  + 字符
    (1) 可以将无意义的字符变得有意义
    (2) 可以将有意义的字符变得无意义
    
n   : 换行
rn : 换行
t   : 缩进(水平制表符)    
r   : 将r后面的字符串拉到了当前行的行首
"""
# 1.单引号的字符串
strvar = '生活不止眼前的苟且'

# 2.双引号的字符串
strvar = "还有诗和远方的田野"

### 转义字符
## a.可以将无意义的字符变得有意义
strvar = "还有诗和n远方的田野"
## b.可以将有意义的字符变得无意义
strvar = "还有诗和"远"方的田野"

# 3.三引号的字符串 (可以支持跨行效果)
strvar = '''
生活就像"醉"酒
表面上说'不'要
身体却很诚实
'''

# 4.元字符串 r"字符串" 原型化输出字符串
strvar = "D:nython32_pythontay02"    # 会转义
strvar = r"D:nython32_pythontay02"   # 不会转义 

# 5.字符串的格式化
"""
%d 整型占位符
%f 浮点型占位符
%s 字符串占位符
语法形式:
    "字符串" % (值1,值2)
"""
# %d 整型占位符
strvar = "王同学昨天买了%d风油精,洗澡"  %  (2)
print(strvar)

# %2d  占两位 (不够两位拿空格来补位) 原字符串具右
strvar = "王同学昨天买了%2d风油精,洗澡"  %  (2)
print(strvar)

# %-2d 占两位 (不够两位拿空格来补位) 原字符串具左
strvar = "王同学昨天买了%-2d风油精,洗澡"  %  (2)
print(strvar)

# %f 浮点型占位符
strvar = "赵同学一个月开%f工资" % (9.9)
print(strvar)

# %.2f 保留小数点后面两位小数 (存在四舍五入的情况,默认保留六位小数)
strvar = "赵同学一个月开%.2f工资" % (9.178)
print(strvar)

# %s 字符串占位符
strvar = "%s最喜欢在电影院尿尿" % ("赵同学")
print(strvar)

# 综合案例
strvar = "%s在水里%s被发现了,罚款%.2f元,并且做了%d俯卧撑." % ("孟同学","拉屎",500.129,50000)
print(strvar)

# 如果搞不清楚用什么占位符,可以无脑使用%s
strvar = "%s在水里%s被发现了,罚款%s元,并且做了%s俯卧撑." % ("孟同学 ","拉屎",500.129,50000)
print(strvar)

列表类型 list

特征: 可获取,可修改,有序

内置函数 len

len 获取容器类型数据中元素个数

# 1.定义普通列表
listvar = [98,6.9,True,12-90j,"hello"]
# 2.获取列表中的元素
## 正向索引   0  1   2     3      4
listvar =   [98,6.9,True,12-90j,"hello"]
## 逆向索引  -5  -4  -3     -2      -1

res = listvar[2]
# res = listvar[-3]
print(res)

## 常规获取最后一个元素
length = len(listvar)
res = listvar[length-1]
print(res)

# 简写
res = listvar[len(listvar)-1]
print(res)

# python逆向索引的特点,瞬间得到列表中最后一个元素
print(listvar[-1])

# 3.修改列表中的元素
listvar = [98,6.9,True,12-90j,"hello"]
listvar[3] = "大象"
print(listvar)

元组类型 tuple

特征: 可获取,不可修改,有序

# 1. 定义一个元组
tuplevar = ("梦好心","王伟","安晓东","孙坚")
print(tuplevar , type(tuplevar))

# 2. 获取元组中的元素
# 正向索引   0          1       2       3      
tuplevar = ("梦好心","王伟","安晓东","孙坚")
# 逆向索引    -4       -3      -2      -1

print(tuplevar[2])
print(tuplevar[-2])

# 修改元组中的元素 : 元组中的值不能修改
# tuplevar[0] = "萌不好心"  error

## 注意点
"""逗号才是区分是否是元组的标识符"""
tuplevar = (8.9,)
tuplevar = 8.1,  # 括号不写也可
print(tuplevar)
print(type(tuplevar))

# 定义空元组
tuplevar = ()
print(type(tuplevar))

字符串类型的索引取值

特征: 可获取,不可修改,有序

# ### 字符串类型
"""特征: 可获取,不可修改,有序"""
# 正向索引   0 1 2 3 4 5 6 7 8
strvar =    "看你,我就心跳加速"
# 逆向索引  -9-8-7-6-5-4-3-2-1

# 获取字符串中的元素
print(strvar[3])
print(strvar[-6])

# 不能修改字符串中的元素
# strvar[3] = "你" TypeError 

print("<===============>")
strvar = ""   # 单纯定义一个字符串类型
print(strvar, type(strvar))
strvar = "   " # 字符串中含有3个空格字符
print(strvar[0], type(strvar))

集合类型 set

特点: 无序,自动去重
支持运算： 交差并补

# 1.集合无序
setvar = {"巨石强森","史泰龙","施瓦辛格","hello"}
print(setvar , type(setvar))

# 获取集合中的元素 不可以
# setvar[0] error

# 修改集合中的元素 不可以
# setvar[2] = 111 error

# 2.集合自动去重
setvar = {"巨石强森","史泰龙","施瓦辛格","hello","史泰龙","史泰龙","史泰龙"}
print(setvar , type(setvar))

# 3.定义一个空集合
setvar = set()
print(setvar , type(setvar))

字典 dict

键值对存储的数据,表面上有序,本质上无序
dictvar = {键1:值1, 键2:值2 , … }
3.6版本之前,完全无序,
3.6版本之后,存储的时候,保留了字典定义的字面顺序,在获取内存中数据时
重新按照字面顺序做了排序,所以看起来有序,实际上存储时还是无序。

# 1.定义一个字典
dictvar = {"top":"the shy", "middle":"肉鸡"}
print(dictvar, type(dictvar))
# 2.获取字典中的值
res = dictvar["middle"]
print(res)
# 3.修改字典中的值
dictvar["top"] = "the xboy"
print(dictvar)
# 4.定义空字典
dictvar = {}
print(dictvar, type(dictvar))
# ### 3.set 和 dict 的注意点
"""
字典的键 和 集合的值 有数据类型上的要求:
(允许的类型范围)不可变的类型: Number(int float complex bool) str tuple
(不允许的类型)可变的类型    : list set dict

哈希算法的提出目的是让数据尽量均匀的在内存当中分配,以减少哈希碰撞,提升存储分配的效率;
哈希算法一定是无序的散列,所以集合 和 字典都是无序

字典的 键有要求,值没要求
字典的值可以任意换掉,但是键不可以.
"""
# 允许的类型范围
dictvar = {1:"abc",4.89:111,False:333,3+90j:666,"王文":"没毛病",(1,2,3,4,5,6):9999}
print(dictvar)  # 没报错
print(dictvar[(1,2,3,4,5,6)])
# dictvar = {[1,2,3]:123}  TypeError: unhashable type: 'list'

# 允许的类型范围
setvar = {1,"a",4.56,9+3j,False,(1,2,3)}
# setvar = {1,"a",4.56,9+3j,False,(1,2,3),{"a","b"}} error
print(setvar)

变量的缓存机制

意义： 无论是变量缓存机制还是小数据池的驻留机制，都是为了节省内存空间，提升代码效率

# ### 在同一文件中,变量的缓存机制 (仅仅针对python3.6版本负责)
# 1.对于整型而言，-5~正无穷范围内的相同值 id一致
var1 = 5
var2 = 5
var1 = -100
var2 = -100
print(id(var1) , id(var2) )


# 2.对于浮点数而言，非负数范围内的相同值 id一致
var1 = 4.67
var2 = 4.67
var1 = -4.67
var2 = -4.67
print(id(var1) , id(var2) )

# 3.布尔值而言,值相同情况下，id一致
var1 = True
var2 = True
print(id(var1) , id(var2) )

# 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
var1 = 4 +5j
var2 = 4 +5j
# 5j 情况下例外
var1 = 5j
var2 = 5j
var1 = -5j
var2 = -5j
print(id(var1) ,id(var2))   # 虚数地址值一样

# -->容器类型部分
# 5.字符串 和 空元组 相同的情况下，地址相同
var1 = "你"
var2 = "你"
var1 = ()
var2 = ()
print(id(var1) ,id(var2))
# 6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]
var1 = (1,2)
var2 = (1,2)
var1 = [1,2,3]
var2 = [1,2,3]
print(id(var1) ,id(var2))

不同文件（模块）里，部分数据驻留小数据池中（仅3.6版本，其他版本略有不同）了解

1. 小数据池只针对: int str bool 空元祖() None 关键字 这些数据有效

• 对于int而言
  python 在内存中创建了 -5~256 范围的整数，提前驻留在内存的一块区域
  如果是不同文件（模块）的两个变量，声明同一个值在 -5~256 范围里，则id()返回一致，让两个变量的值都指向一个值的地址，节省空间。
• 对于str来说
  1. 字符串的长度为0或者1，默认驻留小数据池
  2. 字符串的长度大于1，且只含有大小写字母，数字，下划线时，默认驻留小数据池
  3. 用*号得到的字符串，分两种情况
     a. 乘数等于1时，无论什么字符串 *1， 都默认驻留小数据池
     b. 乘数大于1时，乘数大于1，仅包含数字，字母，下划线时会被缓存，但字符串长度不能大于20

2. 指定驻留
   从 sys模块中 引入 intern 函数， 让 a, b两个变量指向同一个值

from sys import intern
a = intern("aaaa哈哈哈bbb***123" * 10)
b = intern("aaaa哈哈哈bbb***123" * 10)
print(a id b)
# 可以指定任意字符串加入到小数据池中，无论声明多少个变量，只要此值相等，就都指向同一个地址空间

容器类型的强制类型转换

内置方法 repr （元字符串）

不转义字符原型化输出字符串

strvar = "hello"
listvar = [1,2,3]
tunplevar = (4,5,6)
setvar = {"name", "age", "gender"}
dictvar = {"name": "hmm", "age": 18, "gender": False}
numvar = 90
boolvar = True

# str 强制转换成字符串
"""所有的数据类型都可以转换, 在当前的数据类型两边套上引号"""
res = str(listvar)
print(res ,type(res))    # [1, 2]
# repr 不转义字符原型化输出字符串
print(repr(res))    # '[1, 2]'

# list 强制转换成列表
"""
如果是字符串:把字符串中的每个元素单独拿出来,作为列表中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型的两边换上[]括号
"""
res = list(strvar)  # ['h', 'e', 'l', 'l', 'o']
res = list(tunplevar)    # [4, 5, 6]
res = list(setvar)  # ['gender', 'age', 'name']
# 字典: 只获取字典得键,忽略掉值
res = list(dictvar)  # ['name', 'age', 'gender']
# res = list(numvar) # TypeError 'int' object is not iterable 只能是容器间的互转
print(res ,type(res))

# tuple 强制转换成元组
"""
如果是字符串:把字符串中的每个元素单独拿出来,作为元组中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上()括号
"""
res = tuple(strvar)
res = tuple(tunplevar)
res = tuple(setvar)
res = tuple(dictvar)
print(res ,type(res))

# set 强制转换成集合，（自动去掉重复的值）
"""
如果是字符串:把字符串中的每个元素单独拿出来,作为集合中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上{}括号
"""
res = set(strvar)
res = set(tunplevar)
res = set(dictvar)
print(res ,type(res))
# 多滤掉列表中所有重复元素;
lst = [1,222,3,3,3,44,88,999,77,88,1]
res = set(lst)
print(res)
# 在把当前的集合转换成原来的列表
res2 = list(res)
print(res2)

"""
默认不加任何值,转换成该数据类型的空值
str() list()  tuple()  set()  dict()
"""
res = dict()
print(res, type(res))


# ### dict 字典类型的强制转换
"""
要求: 必须是等长的二级容器,并且里面的元素个数是2个;
# 等长的二级容器
# 外面是容器,里面的元素也是容器,且元素个数相同
lst = [(1,2,3),[4,5,6],{7,8,9}]
外层是列表,元组,集合 , 里层是列表或者元组的等长二级容器 => 字典;
"""

# 1.外层是列表,里层是列表或者元组
lst = [ ["a",1] , ("b",2) ]
dic = dict(lst)
print(dic , type(dic)) # {'a': 1, 'b': 2} <class 'dict'>

# 2.外层是元组,里层是列表或者元组
tup = ( ["a",1] , ("b",2) )
dic = dict(lst)
print(dic , type(dic))

# 3.外层是集合,里层是元组（里层不能是列表）
setvar = { ("a",1) , ("b",2) }
dic = dict(setvar)
print(dic , type(dic))

# 例外1:外层是列表/元组,里层放集合
"""可以实现,不推荐使用,因为达不到想要的目的,集合无序,不推荐使用"""
lst = [ ["a",1] , {"b","250"} ]
dic = dict(lst)
print(dic)

# 例外2:外层是列表/元组,里层放字符串
""" 字符串长度只能是2位,有极大的局限性,不推荐使用"""
lst = ["a1","b2"]
# lst = ["a11","b22"] ValueError 
# dic = dict(lst)
# print(dic)

类型判断

# ### 判断类型  isinstance
"""
# 使用方法一
isinstance(数据,类型)  
如果该数据是这个类型,返回True 反之,返回False
类型: int float complex bool str list tuple set dict

# 使用方法二
isinstance(  数据, (类型1,类型2,类型3...)   )
如果该数据在所对应的类型元组当中,返回True,反之,返回False
"""

# 使用方法一
n = 123
res = isinstance(n , int)
print(res)

n = [1,2,3]
res = isinstance(n , list)
res = isinstance(n , tuple)
print(res)

# 使用方法二
n = "1233"
res = isinstance(n , (list , tuple ,set , str)  )
print(res)


n = {"a":1}
res = isinstance(n , (list , tuple ,set , str)  )
print(res)

四、运算符

分类

(1)算数运算符:  + - * / // % **
(2)比较运算符:  > < >= <= == !=   
(3)赋值运算符:  = += -= *= /= //= %= **=
(4)成员运算符:  in 和 not in (针对于容器型数据)
(5)身份运算符:  is 和 is not (检测两个数据在内存当中是否是同一个值)  
(6)逻辑运算符:  and or not
(7)位运算符:    & | ~ ^ << >>

算数运算符

# ### (1)算数运算符:  + - * / // % **

# +
var1 = 7
var2 = 90
res = var1 + var2
print(res)

# -
var1 = 7
var2 = 90
res = var1 - var2
print(res)

# *
var1 = 7
var2 = 10
res = var1 * var2
print(res)

# / 结果永远为小数
var1 = 10
var2 = 5
res = var1 / var2
print(res , type(res))  # 2.0

# // 地板除
"""被除数 ➗ 除数 = 商"""
"""注意点:如果被除数或者除数是小数,那么得到正常结果之后,数值后面带上.0变成小数"""
var1 = 10.0
var2 = 3.0
# var2 = 3.0
res = var1 // var2
print(res)  # 都为整数时，结果为整数

# %  取余
var1 = 7
var2 = 4
res = var1 % var2   # 3
res = -7 % 4  # -3 + 4 = 1  （没带负数的余数为3，被除数为负数，则正常的余数改为负数，加上除数）
res = 7 % -4  # 3 + (-4) = -1
res = -7 % -4 # -3 (被除数和除数都是负的,正常结果加负号)
res = 81 % 7   # 4
res = 81 % -7  # -3
res = -81 % 7  # 3
res = -81 % -7 # -4
print(res)

# ** 幂运算
res = 2 ** 3
print(res)

比较运算符

# (2)比较运算符:  >   <   >=   <=   ==   !=   
"""比较运算符的结果要么是True , 要么是False 只有两个值"""
res = 10 > 5
res = 10 >= 10
# ==这个符号是在做比较,比较==两边的数值是否一样
res = 5 == 9
res = 5 != 9 
print(res)
赋值运算符
# ### (3)赋值运算符:  =   +=   -=   *=   /=   //=   %=   **=
# = 赋值运算符 将右侧的值赋值给左侧变量
a = 5 <= 3
print(a)

var1 = 10
var2 = 5
# += 
"""var1 = var1 + var2"""
# var1 += var2
# print(var1)

# -=
"""var1 = var1 - var2"""
# var1 -= var2
# print(var1)

# %=
"""var1 = var1 % var2"""
var1 %= var2
print(var1)

成员运算符 in

# (4)成员运算符:  in 和 not in (针对于容器型数据)
"""字符串判断时,必须是连续的片段"""
strvar = "今天天气要下雨,赶紧回家收衣服"

res = "今" in strvar
res = "天气" in strvar
res = "赶回" in strvar
print(res)

# 针对于列表,元组,集合
container = ["赵沈阳","赵万里","赵世超"]
container = ("赵沈阳","赵万里","赵世超")
container = {"赵沈阳","赵万里","赵世超"}
# res = "赵沈阳" in container
# res = "赵万里" not in container
res = "赵世超1223232" not in container
print(res)
 
# 针对于字典 (判断的是字典的键,不是值)
container = {"zsy":"赵沈阳","zwl":"赵万里","zsc":"赵世超"}
res = "赵沈阳" in container # False
res = "zsy" in container
print(res)

身份运算符

# (5)身份运算符 is 和 is not (检测两个数据在内存当中是否是同一个值)  

# 整型 -5~正无穷 
var1 = 100
var2 = 100
print(var1 is var2)   # True

# 浮点型 非负数
var1 = -9.1
var2 = -9.1
print(var1 is var2) # False

# bool 相同即可
var1 = True
var2 = True
print(var1 is var2) # True

# complex 在实数+虚数不相同 (只有虚数的情况下例外)
var1 = 6-8j
var2 = 6-8j
var1 = -10j
var2 = -10j
print(var1 is var2)

# 容器: 相同字符串 , 空元组相同即可  剩下的所有容器都不相同
container1 = ()
container2 = ()
print(container1 is not container2)

container1 = "你"
container2 = "你"
print(container1 is not container2)

container1 = [1,23,3]
container2 = [1,23,3]
print(container1 is not container2)

逻辑运算符

# (6)逻辑运算符:  and or not
# and 逻辑与   
"""全真则真,一假则假"""
res = True and True    # True
res = True and False   # False
res = False and True   # False
res = False and False  # False
print(res)

# or  逻辑或  
"""一真则真,全假则假"""
res = True or True    # True
res = False or True   # True
res = True or False   # True 
res = False or False  # False
print(res)

# not 逻辑非  
res = not True
res = not False
print(res)

# 逻辑短路
"""
无论后面的表达式是True 还是False 都已经无法改变最后的结果,那么直接短路,后面的代码不执行;
(1) True or print("程序执行了 ~ 1111")
(2) False and print("程序执行了 ~ 2222")

True or print("程序执行了 ~ 1111")
True or True => True
True or False => True
False and print("程序执行了 ~ 2222")
False and True  => False
False and False => False
"""

"""
计算规律:
    先脑补计算当前表达式的布尔值是True还是False
    如果出现了 True or 表达式  或者 False and 表达式的情况,直接返回前者,后面代码不执行
    如果没有出现短路效果,直接返回后者
"""

res = 5 and 6 # 6
"""
True and True =>True
True and False => False
"""
res = 5 or 6  # 5
res = 0 and 999
res = 0 or "abc"
print(res)

# 逻辑运算符的优先级
""" 优先级从高到低: () > not > and > or   """
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7
res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => False
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
"""
not (False or False) => True
res = 1<2 or 3>4 and 5<100 or 100<200 and not (700>800 or 1<-1)
res = True or False and True or True and True
res = True or False or True
res = True or True => True
"""
print(res)

位运算符

# ### (7)位运算符:    & |  ^ << >> ~

var1 = 19
var2 = 15

# & 按位与
res = var1 & var2
"""
000 ... 10011
000 ... 01111
000 ... 00011 => 3
"""
print(res)

# | 按位或
res = var1 | var2
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""
print(res)

# ^ 按位异或
"""两个值不相同=>True 反之返回False"""
res = var1 ^ var2
"""
000 ... 10011
000 ... 01111
000 ... 11100
"""
print(res)

# << 左移 (相当于乘法)
"""5乘以2的n次幂"""
res = 5 << 1 # 10
res = 5 << 2 # 20
res = 5 << 3 # 40
print(res)

"""
000 ... 101  => 5
000 .. 1010  => 10
000 ..10100  => 20
000 .101000  => 40
"""

# >> 右移 (相当于除法)
"""5地板除2的n次幂"""
res = 5 >> 1 # 2
res = 5 >> 2 # 1
res = 5 >> 3 # 0
"""
000 ... 101
000 ... 010 => 2
000 ... 001 => 1
000 ... 000 => 0
"""
print(res)


# ~ 按位非 (针对于补码进行操作,按位取反,包含每一位)
""" -(n+1) """
# res = ~22
res = ~19
print(res)
"""
原码:000 ... 10011
反码:000 ... 10011
补码:000 ... 10011

补码:   000 ... 10011
按位非: 111 ... 01100

给你补码->原码
补码:111 ... 01100
反码:100 ... 10011
原码:100 ... 10100 => -20
"""

res = ~-19
print(res)
"""
原码:100 ... 10011
反码:111 ... 01100
补码:111 ... 01101

补码:   111 ... 01101
按位非: 000 ... 10010

给你补码->原码 (因为是整数 ,原反补相同)
000 ... 10010 => 19
"""


"""
总结:
    个别运算符:
        运算符优先级最高的: **
        运算符优先级最低的: =
        ()可以提升优先级
        
    一元运算符 > 二元运算符 (优先级)
        一元运算符 : 同一时间,操作一个值 ~ - 
        二元运算符 : 同一时间,操作一个值 + - * / ....
        
    同一种类运算符:
        算数运算符 : 乘除 > 加减
        逻辑运算符 : () > not > and > or 
        位运算符   : ( << >> ) > & > ^ > |
    
    整体排序: 算位比身成逻
        算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
        赋值运算符用来做收尾
"""

运算符的优先级