一、注释
注释: 就是对代码的解释，方便阅读，被注释的代码不执行
分类
- 单行注释
# 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 : 换行
\r\n : 换行
\t : 缩进(水平制表符)
\r : 将\r后面的字符串拉到了当前行的行首
"""
# 1.单引号的字符串
strvar = '生活不止眼前的苟且'
# 2.双引号的字符串
strvar = "还有诗和远方的田野"
### 转义字符
## a.可以将无意义的字符变得有意义
strvar = "还有诗和\n远方的田野"
## b.可以将有意义的字符变得无意义
strvar = "还有诗和\"远\"方的田野"
# 3.三引号的字符串 (可以支持跨行效果)
strvar = '''
生活就像"醉"酒
表面上说'不'要
身体却很诚实
'''
# 4.元字符串 r"字符串" 原型化输出字符串
strvar = "D:\nython32_python\tay02" # 会转义
strvar = r"D:\nython32_python\tay02" # 不会转义
# 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版本，其他版本略有不同）了解
- 小数据池只针对:
int str bool 空元祖() None关键字 这些数据有效
- 对于int而言
python 在内存中创建了 -5~256 范围的整数，提前驻留在内存的一块区域
如果是不同文件（模块）的两个变量，声明同一个值在 -5~256 范围里，则id()返回一致，让两个变量的值都指向一个值的地址，节省空间。 - 对于str来说
- 字符串的长度为0或者1，默认驻留小数据池
- 字符串的长度大于1，且只含有大小写字母，数字，下划线时，默认驻留小数据池
- 用*号得到的字符串，分两种情况
a. 乘数等于1时，无论什么字符串 *1， 都默认驻留小数据池
b. 乘数大于1时，乘数大于1，仅包含数字，字母，下划线时会被缓存，但字符串长度不能大于20
- 指定驻留
从 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)位运算符: & | ~ ^ << >>
| python运算符 | 注意点 |
|---|---|
| 算数运算符 | %取余 ， //地板除 ， ** 幂运算 |
| 比较运算符 | == 比较两个值是否相等 != 比较两个值是否不同 |
| 赋值运算符 | a += 1 => a = a+1 |
| 成员运算符 | in 或 not in 判断某个值是否包含在(或不在)一个容器类型数据当中 |
| 身份运算符 | is 和 is not 用来判断内存地址是否相同 |
| 逻辑运算符 | 优先级 () > not > and > or |
| 位运算符 | 优先级 (<<或 >> ) > & > ^ > | 5 << 1 结果：10 , 5 >> 1 结果：2 |
算数运算符
# ### (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
位运算符 : ( << >> ) > & > ^ > |
整体排序: 算位比身成逻
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符用来做收尾
"""
运算符的优先级
