第二章·数据类型与运算符
文章目录
数据类型
分类
基本数据类型
Number（数字类型）
- int整型
- float浮点型
- complex复数
boolean（布尔类型）
- true
- false
- String（字符串类型）
复合数据类型
序列类型
- List（列表）
- Tuple（元组）
映射类型
- Dictionary（字典）
Set（集合类型）
基本数据类型
整型( int)
整数
'整型'
a=5
b=2
c=1
print(a,b,c)
浮点型( float)
小数，浮点数，计算机表示一个小数时是有误差的
'浮点型'
a=1.3
b=1.4
c=10
d=3
print(a,b)
print(c/d)
'输出：
1.3 1.4
3.3333333333333335'
复数（complex）
用于表示包含实数和虚数的数字，一个复数由实数和虚数两部分组成
格式
a + bj
a是实部，b是虚部，j是虚数单位
x = 3 + 4j # 创建复数对象 x，实部为 3，虚部为 4
属性与方法
real属性：返回复数的实部。imag属性：返回复数的虚部。conjugate()方法：返回复数的共轭（改变虚部的符号）。例如，对于复数3 + 4j，其共轭是3 - 4j
字符串(str)
用单引号或双引号括起来的一串字符即字符串
表示方式
单行字符串＇＇或＂＂
多行字符串＇＇＇＇＇＇或＂＂＂＂＂＂
a='lyy'
b="ydl"
print(a,b)
字符串运算符
+表示多个字符串连接
*表示一个字符串的重复次数
a="hello"
b="world"
print(a+b)
print(a*2)
输出：helloworld
hellohello
[:]表示截取字符串中的一部分
语法格式
变量[头下标：尾下标]
a="hello world"
print(a[1:4])
输出：ell
字符串的常见操作
替换：replace()
str="我好呀"
old="我"
new="你"
print(str.replace(old,new,1))
'输出：你好呀
语法格式：str.replace(old,new,count)
old:表示原有字符串
new:表示新的字符串
count:表示设定替换的次数'
分割：split（）
"""str.split(sep='选择哪个字符分割',maxsplit=分割的次数)"""
srt="我叫xxx你家住ggg你喜欢ddd"
str01="123|45|67"
print(srt.split(sep='你',maxsplit=2))
print(str01.split(sep='|',maxsplit=2))
'''输出：
['我叫xxx', '家住ggg', '喜欢ddd']
['123', '45', '67']'''
去除两侧空格：strip()
srt=' 12345 '
print(srt.strip())
格式化输出
%s字符串占位
%d占位整数
%f占位小数
name=input("名字:")
age=int(input("年龄:"))
hobby=input("爱好:")
zhhi=input("住址：")
a="我叫%s，今年%d岁，我喜欢%s"%(name,age,hobby)
b="我叫{}，今年岁{}，我喜欢{}".format(name,age,hobby)
c=f"我叫{name},今年岁{age},我家住在{zhhi},我喜欢{hobby}"
print(a)
print(b)
print(c)
#三种方式输出想要输出的内容
'输出：
我叫xxx，今年xx岁，我喜欢xx
我叫xxx，今年岁xx，我喜欢xx
我叫xxx,今年岁xx,我家住在xx,我喜欢xx'
索引和切片
索引
srt="字符串的索引"
print(srt[2])
'输出：串'
切片
srt="字符串的索引"
print(srt[0:5:2])
'输出：
字串索
解释：属于左闭右开型，0为起始位置，5为结束位置，但不包含结束位置，2为每隔两个字符取一个字符的间隔'
大小写转换
#字符串大小写转换
#小转大upper()
s="hello world"
s1=s.upper()
print(s1)
#大转小lower()
s2=s1.lower()
print(s2)
#首字母大写capitalize()
s3=s.capitalize()
print(s3)
查找和判断
#字符串查找
#方式一
s4="hello world"
if "world" in s4:
print("有")
else:
print("没有")
#方式二
s5=s4.find("world")
print(s5)#结果为真，返回的是位置（索引），否则返回-1
#字符串判断
ss="world"
ss1="world"
ss2="wordd"
#方式一
if ss==ss2:
print("等于")
else:
print("不相等")
#方式二
if ss!=ss2:
print("不相等")
else:
print("相等")
代码块操作
#字符串的定义
name='hell world'
name1="hell world"
name2="""
hello world
"""
#查看是否为字符串类型
print(type(name))
print(type(name1))
print(type(name2))
#字符串拼接+
a="hello"
b="world"
print(a+b)
#字符串格式
# 占位符：%s(存放字符串),%d(存放整数),%f(存放小数)
a1="hello"
b1="world"
a2=3
b2=5
a3=4.6
b3=9.9
#格式化：”%占位符“%变量
print("%s早啊!我爱这个%s"%(a1,b1))#
print("我今年%d岁，我%d岁开始学习python了"%(b2,a2))#当有多个变量时，需要用括号括起来
print("我昨天还有%f元,今天只剩下%f元了"%(b3,a3))
#控制精度:.f/.d/.s
a5=388.1415
#把a4控制两个精度
print("%4d"%a5)#整数部分空格4位
print("5%d"%a5)#如果给的数字比数字本身还小，是不会生效的
print("%.3f"%a5)#小数部分取3位
#快速格式f"内容{变量}"
print(f"{a1}早啊！我爱这个{b1}")#特点：不限数据类型，也不做精度控制
bool布尔型:（条件判断）
取值范围:true(真)或false(假)
'布尔型'
print(100>30)
a=""
b=0
print(bool(a))
print(bool(b))
'输出：
True
false
false'
注意
在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。
数据类型的查看（type）和转换
查看数据类型
i=7
a="你好"
c='60'
d=6.66
e=type(8)
print(type(i))
print(type(a))
print(type(c))
print(type(d))
print(e)
#<class 'int'>
<class 'str'>
<class 'str'>
<class 'float'>
<class 'int'>
数据类型转换
想转换成谁，就用谁套起来
例子
str→int 即int(str)
b=input("请输入：")
a=input("请输入：")
#转换整型
c= int(a)
d= int(b)
print(c+d)
#input最后输出的结果一定为str型
代码块
#数据类型
"""
string:字符串类型
int：整型
float浮点型
"""
#python中变量是没有变量类型的，我们所说的变量数据类型，其实是变量对应的值的变量类型
#使用变量存储数据类型的信息，再查数据类型
a=8
a1=type(a)
b='l'
c="j"
d=6.999
f=True
f1=False
#查看数据类型：type()
print(type(a))
print(a1)
print(type(b))
print(type(c))
print(type(d))
print(type(f))
print(type(f1))
print(type(5))#直接查询5是什么数据类型
#数据类型的转换int(x),float(x),str(x)
print(int(9.8))#转换整型
print(float(4))#转换浮点型
print(str(66))#转换字符串
print(type(str(66)))#查看数据类型是否转换成str
复合数据类型
List列表
创建列表
语法
变量=[元素1,元素2,元素3,....]
a=[1,2,3,4,5,6]
b=[1,"f",0.3,"k",'l']#列表的元素类型不受限制
b=list((1,2,3,4))
b1=list((1,2,"h",5))
print(a)
print(b)
print(b)
print(b1)
列表嵌套
a1=[[1,2,3],["h","e","l,","l","o"]]
print(a1)
列表的访问
- 就是锁定某位置有什么内容
- 列表访问的是下标索引
下标索引
1.列表中每个元素的位置
2.列表的下标是从0开始的"“”a1=[1,2,3,4,5,6] print(a1[0])#1 print(a1[5])#6 #print(a1[7])#当需要访问的位置超过列表中元素数量时，变化报小标越界错 a3=[[1,2,3],["h","e","l,","l","o"]] """ 上面列表去掉元素后，可以看成是 a3=[[0],[1]] 下面输出解释： [1]表示索引中括号的位置，下标也是从0开始索引 [4]表示索引[1]内的元素下标为4的位置 """ print(a3[1][4])反向下标索引
注意：
1.元素的多少即是下标的多少，而不是从0开始
2.使用-号表示，-1表示最后一位，
也是从最后一位开始向前索引的a2=[1,2,3,4,5,6] print(a2[-1])#6 print(a2[-6])#1
列表常用操作（方法）
查询
查找列表中是否含有某元素
语法：
列表.index（元素）
a4=[1,2,"户",4,5,6,"zhangsan"] print(a4.index("zhangsan"))#如果存在所需元素，则会返回所需元素所在的位置下标 #print(a.index("李四"))#如果不存在所需元素，则会报错为：ValueError: '李四' is not in list
修改
语法
列表[下标]=值
a5=[1,2,"户",4,5,6,"zhangsan"] a5[2]="李四" print(a5)
插入
插入指定位置，插入指定元素
语法：列表.insert(下标,位置)a6=[1,2,"户",4,5,6,"zhangsan"] a6.insert(1,"王五") print(a6)插入列表尾添加内容，即为追加
语法列表.append（元素）
a7=[1,2,"户",4,5,6,"zhangsan"] a7.append("张三") print(a7) #将其他列表中的元素全部插入到列表中的尾部 # 语法： # 列表.extend(其他数据容器) a8=[1,2,"户",4,5,6,"zhangsan"] a9=[6,7,8] a8.extend(a9) print(a8)
删除
语法1：del 列表[小标]
语法2：列表.pop(下标)
语法3：列表.remove(要删除的指定元素)aa1=[1,2,"户",4,5,6,"zhangsan"] #del 列表[小标] del aa1 [6] print(aa1) #列表.pop(下标) aa1.pop(2) print(aa1) #列表.remove(要删除的指定元素) aab=[1,2,"户",4,5,6,"zhangsan"] aab.remove(4) print(aab)
获取列表长度
aab=[1,2,"户",4,5,6,"zhangsan"]
print(len(aab))
清空
aab1=[1,2,"户",4,5,6,"zhangsan"]
aa1.clear()
print(aa1)
遍历
概念
将列表中的每个元素依次输出while循环遍历
aab1=[1,2,"户",4,5,6,"zhangsan"] a=0 while a<len(aab1): k=aab1[a] print(k,end="")#end=""：输出不换行,若要遍历输出的元素是（元素与元素之间有逗号隔开）则可以end="," a+=1 print("")#换行的意思for循环遍历
for a in aab1: print(a,end=",")
代码块操作
#列表list #语法：变量=[元素1,元素2,元素3,....] #创建列表 a=[1,2,3,4,5,6] b=[1,"f",0.3,"k",'l']#列表的元素类型不受限制 b=list((1,2,3,4)) b1=list((1,2,"h",5)) print(a) print(b) print(b) print(b1) #嵌套列表 a1=[[1,2,3],["h","e","l,","l","o"]] print(a1) #列表的访问 #就是锁定某位置有什么内容 #列表访问的是下标索引 """下标索引: 1.列表中每个元素的位置 2.列表的下标是从0开始的""" a1=[1,2,3,4,5,6] print(a1[0])#1 print(a1[5])#6 #print(a1[7])#当需要访问的位置超过列表中元素数量时，变化报小标越界错 a3=[[1,2,3],["h","e","l,","l","o"]] """ 上面列表去掉元素后，可以看成是 a3=[[0],[1]] 下面输出解释： [1]表示索引中括号的位置，下标也是从0开始索引 [4]表示索引[1]内的元素下标为4的位置 """ print(a3[1][4]) #反向下标索引 """注意： 1.元素的多少即是下标的多少，而不是从0开始 2.使用-号表示，-1表示最后一位， 也是从最后一位开始向前索引的 """ a2=[1,2,3,4,5,6] print(a2[-1])#6 print(a2[-6])#1 #列表常用操作（方法） #查询 #查找列表中是否含有某元素 # 语法：列表.index（元素） a4=[1,2,"户",4,5,6,"zhangsan"] print(a4.index("zhangsan"))#如果存在所需元素，则会返回所需元素所在的位置下标 #print(a.index("李四"))#如果不存在所需元素，则会报错为：ValueError: '李四' is not in list #修改 #语法：列表[下标]=值 a5=[1,2,"户",4,5,6,"zhangsan"] a5[2]="李四" print(a5) #插入 #插入指定位置，插入指定元素 #语法：列表.insert(下标,位置) a6=[1,2,"户",4,5,6,"zhangsan"] a6.insert(1,"王五") print(a6) #插入列表尾添加内容，即为追加 #语法：列表.append（元素） a7=[1,2,"户",4,5,6,"zhangsan"] a7.append("张三") print(a7) #将其他列表中的元素全部插入到列表中的尾部 # 语法： # 列表.extend(其他数据容器) a8=[1,2,"户",4,5,6,"zhangsan"] a9=[6,7,8] a8.extend(a9) print(a8) #删除 """语法1：del 列表[小标] 语法2：列表.pop(下标) 语法3：列表.remove(要删除的指定元素)""" aa1=[1,2,"户",4,5,6,"zhangsan"] #del 列表[小标] del aa1 [6] print(aa1) #列表.pop(下标) aa1.pop(2) print(aa1) #列表.remove(要删除的指定元素) aab=[1,2,"户",4,5,6,"zhangsan"] aab.remove(4) print(aab) #获取列表长度 aab=[1,2,"户",4,5,6,"zhangsan"] print(len(aab)) #清空 aab1=[1,2,"户",4,5,6,"zhangsan"] aa1.clear() print(aa1) #列表的遍历 #概念：将列表中的每个元素依次输出 aab1=[1,2,"户",4,5,6,"zhangsan"] #while循环遍历 a=0 while a<len(aab1): k=aab1[a] print(k,end="")#end=""：输出不换行,若要遍历输出的元素是（元素与元素之间有逗号隔开）则可以end="," a+=1 print("")#换行的意思 #for循环遍历 for a in aab1: print(a,end=",")
Tuple元组
基本特性
元组的内容是不可改变的，即一旦创建了一个元组，就不能添加、删除或修改其中的元素。
创建元组
使用小括号()创建元组
my_tuple = (1, 2, 3, "hello")使用
tuple()函数创建元组my_tuple = tuple([1, 2, 3, "hello"]) # 从列表创建元组
元组的用途
- 用于存储一组相关的数据项。
- 作为字典中的键（因为元组的不可变性）。
- 作为函数返回的多个值的容器（多个返回值可以打包成元组）。
- 在需要不可变序列的情况下使用，例如表示时间戳或坐标点等。
元组和列表的区别
- 元组是不可变的，而列表是可变的。这意味着您可以在列表中增加、删除和修改元素，但无法对元组进行这样的操作。
- 元组的语法通常用于表示不变的数据集合，而列表主要用于表示有序的集合。
代码块操作
#创建元组 a=(1,"hello",True)#元组也可以存放任何数据类型 print(a) print(type(a))#<class 'tuple'> #定义单个元素的元组，必须后面添加一个逗号，否则不是元组类型 a1=("hello") a2=("hello",) print(type(a1))#<class 'str'> print(type(a2))#<class 'tuple'> #嵌套 a3=((3,2,4),(5,8,9,1)) print(a3) #获取下标内容 a4=a3[1][2] print(a4) #元组的操作 #查找.index()方法 a5=(1,"hello",True) b=a5.index("hello") print(b)#1 #统计 #统计某元素出现的次数 #.count()方法 a6=(1,"hello",True,2,1,3,1,4,7) b1=a6.count(1)#1这个元素在元组中出现多少次 print(b1)#4 #统计元组的长度 a7=len(a6) print(a7)#9 #遍历 #while循环遍历 a8=(1,"hello",True,2,1,3,1,4,7) b2=0 while b2<len(a8): print(a8[b2],end=".") b2+=1 print("") #for循环遍历 a8=(1,"hello",True,2,1,3,1,4,7) for b3 in a8: print(b3,end=",") print("") #元组与列表的嵌套使用 #元组的内容一旦创建不能改变，但嵌套的列表依然可以添加增删改的 s=(1,2,3,4,5,["上山","打","老虎"],["老虎"],"不在",["家"]) print(s)#(1, 2, 3, 4, 5, ['上山', '打', '老虎'], ['老虎'], '不在', ['家']) s[5][0]="下山" print(s,end="")#(1, 2, 3, 4, 5, ['下山', '打', '老虎'], ['老虎'], '不在', ['家'])
Set集合
集合的基本特性
- 无序性：集合中的元素没有特定的顺序。
- 元素的唯一性：集合中的每个元素都是唯一的，不会出现重复的元素。
- 可变性：集合是可以修改的，可以添加、删除元素。
创建集合
使用大括号{}创建集合
my_set = {1, 2, 3, "hello"}使用set()函数创建集合
my_set = set([1, 2, 3, "hello"])
代码块操作
#创建集合
a={1,3,6,89,6}#集合的元素不能重复，因此元素5只会被输出一次
#print(a[1])#报错'set' object is not subscriptable，集合是无序的，不支持下标索引
print(a)#{89, 1, 3, 6}；集合是无序的
#添加元素
#语法：集合.add(元素)
a.add("hello")
print(a)
a.add(3)#添加的3无效，因为集合的特性是集合中的每个元素都是唯一的，不能重复
print(a)
#移除
#语法：集合.remove(元素)
a1={1,3,6,89,6}
a1.remove(6)
print(a1)
#随机抽取元素
#语法：集合.pop()
a2={1,3,6,89,6}
b=a2.pop()
print(b)
#清空集合
#语法：集合.clear()
a2.clear()
#取两集合的差集
a3={1,3,6,89,6}
a4={1,2,5,89,6}
a5=a4.difference(a3)#表示：a4有a3没有的值，即{2, 5}a3没有
print(a5)#{2, 5}
#消除差集
#意思是删除两个集合中相同的元素
a6={1,3,6,89,6}
a7={1,2,5,89,6}
a6.difference_update(a7)
print(a6)#{3}
#两个集合合并
#语法：集合1.union(集合2)
a8={3,6,7,1,2}
a9={1,2,5,89}
aa=a8.union(a9)
print(aa)#集合具有唯一性；{1, 2, 3, 5, 6, 7, 89}
#集合的长度
aa1={1,2,3,4,1,2,3,4}
print(len(aa1))#4,集合是不可以重复的，当重复时会自动去重，因此去重后的长为4
#集合遍历
aa2={1,2,3,4,5}
for bb1 in aa2:
print(bb1,end="")
Dictionary字典
字典的特性
- 无序性：字典中的键值对是无序的，即键值对的存储和访问顺序不固定。
- 唯一键：字典中的键必须是唯一的，不能重复。每个键对应一个值，这意味着通过键可以快速地找到对应的值。
- 可变性：字典是可变的，可以动态地添加、删除和修改键值对。
创建字典
字典可以通过大括号
{}创建，其中键值对之间用冒号:分隔，不同的键值对之间用逗号,分隔。empty_dict = {} # 创建一个空字典 non_empty_dict = {"key1": "value1", "key2": "value2", "key3": 3} # 创建一个包含三个键值对的字典
代码块操作
#创建字典
a={"zhangsan":18,"lisi":16,"wangwu":20}
a1={}#空字典
a2=dict()#空字典
#a={"zhangsan":18,"lisi":16,"wangwu":20,"lisi":16}#字典唯一键，不重复
print(type(a))
print(type(a1))
print(type(a2))
#字典不能索引，只能通过key值去索引到对应的value值
a3={"zhangsan":18,"lisi":16,"wangwu":20}
a4=a3["lisi"]#通过lisi的key键去索引value值为16
print(a4)#16
#嵌套
a5={"zhaoliu":{
"age":19,
"calssname":20245
},
"qiqi":{
"age":19,
"calssname":20245
},
"zhangsan":{
"age":14,
"calssname":20245
}
}
print(a5,end="")
print("")
#获取字典信息
a6=a5["qiqi"]["age"]#通过对应的键得到对应的值
print(a6)#19
#常用操作
#新增/更新字典信息
#如果新增的键值信息，字典中没有，则新增一个键值信息；如果已经存在，那么会更新原有字典的键值信息
a7={"zhangsan":18,"lisi":16,"wangwu":20}
a7["zhangsan"]=99
print(a7)#由于已经有了zhangsan，因此为更新，即将18更新成99，即{'zhangsan': 99, 'lisi': 16, 'wangwu': 20}
a7["qianyu"]=77
print(a7)#没有qianyu，为新增，即添加“qianyu”:77到字典中为，{'zhangsan': 99, 'lisi': 16, 'wangwu': 20, 'qianyu': 77}
#删除
#语法：字典.pop[key]
a8={"zhangsan":18,"lisi":16,"wangwu":20}
a8.pop("wangwu")
print(a8)#{'zhangsan': 18, 'lisi': 16}
#清空clear
a9={"zhangsan":18,"lisi":16,"wangwu":20}
a9.clear()
print(a9)#{}
#获取全部key值
#作用：可以通过key值让字典遍历
#语法：字典.keys()
aa={"zhangsan":18,"lisi":16,"wangwu":20}
b=aa.keys()#需要定义一个变量名接收
print(b)#dict_keys(['zhangsan', 'lisi', 'wangwu'])
#遍历
"""方式一：
通过上面得到的键值遍历"""
ab={"zhangsan":18,"lisi":16,"wangwu":20}
for k in b:
print(ab[k],end="")#181620
print("")
"""方式二：
直接对字典进行遍历"""
for j in ab:
print(ab[j],end="")#181620
print("")
#统计字典元素数量len()
ab1={"zhangsan":18,"lisi":16,"wangwu":20}
l=len(ab1)
print(l)
#print(len(ab1))
列表，元组，集合区别
| 列表（List） | 元组（Tuple） | 集合（Set） | Dictionary字典 | |
|---|---|---|---|---|
| 有序：列表中的元素是有序的，即元素在列表中的位置是固定的 | 有序：元组中的元素也是有顺序的 | 无序：集合是无序的，不考虑元素的顺序 | 无序性：字典中的键值对是无序的，即键值对的存储和访问顺序不固定。 | |
| 可重复：列表中的元素可以重复出现 | 不可重复：元组中的元素是唯一的，不能重复 | 不可重复：集合中的元素是唯一的，不能重复出现相同的元素 | 唯一键：字典中的键必须是唯一的，不能重复。每个键对应一个值，这意味着通过键可以快速地找到对应的值。 | |
| 可修改：列表是可变的，可以添加、删除和修改元素 | 不可修改：一旦创建，元组是不可变的，不能修改其中的元素 | 可修改：集合是可变的，可以添加和删除元素。但在创建后，单个元素的顺序是不确定的 | 可变性：字典是可变的，可以动态地添加、删除和修改键值对 | |
表示方式：使用中括号 [] 创建 | 表示方式：使用小括号 () 创建 | **表示方式：**使用大括号 {} 创建，空集合除外 | **表达方式：**使用大括号 {} 创建，其中键值对之间用冒号分隔，不同的键值对之间用逗号分隔。 |
运算符与表达式
算术运算符
以a=10,b=21为例子：
| **+**加 | a+b=31 |
|---|---|
| -减 | a-b=-11 |
| *乘 | a*b=210 |
| /除 | b/a=2.1 |
| %取模 | b%a=1 |
| **幂 | a**b=10000000 |
| //取整除 | 9//2=4;9.0//2.0=4.0 |
比较（关系）运算符
| == | 等，真 |
|---|---|
| != | 不等，真 |
| > | 大于，真 |
| < | 小于，真 |
| >= | 大于或等于，真 |
| <= | 小于或等于，真 |
赋值运算符
| = |
|---|
| += |
| -= |
| *= |
| /= |
| %= |
| **= |
| //= |
逻辑运算符
| and与 | x and y；x,y只要有一个为假，即输出假；只有同时为真时，即输出y值 |
|---|---|
| or或 | x or y;一真一假即输出真的那个值;同时为真即输出x |
| not非 | 真即假，假即真 |
成员运算符
| in | 判断xxx是否在xxx中出现了 |
|---|---|
| not in | 判断xxx是否不在xxx中出现了 |
a=[2,3,4,5,6,7,8]
print(9 in a)
print(2 in a)
print(9 not in a)
print(2 not in a )
\#输出：
False
True
True
False
身份运算符
| is | 判断两个对象是否是同一个对象实例 |
|---|---|
| is not | 判断两个对象是否不是同一个对象实例 |
运算符优先级
优先级从高到低排序如下
- 括号
()- 指数运算符
**- 一元运算符
+-~（正号、负号、位取反）- 乘性运算符
*/%//（乘、除、模、整除）- 加性运算符
+-（加、减）- 移位运算符
<<>>- 位运算符
&|^~（位与、位或、位异或、位取反）- 比较运算符
<<=>>=!===- 身份运算符
isis not- 逻辑运算符
notandor- 条件运算符（三元运算符）
x if condition else y- 赋值运算符
=以及复合赋值运算符如+=,-=
代码块操作
#算术运算符+，-，*，/，//取整除，%取余，**求指数结果
print("1+1=",1+1)
print("2-1=",2+1)
print("1*1=",1*1)
print("2/2=",2/2)
print("8//3=",8//3)
print("10%3=",8%3)
print("2**3=",2**3)
#赋值运算符=,(+=，-=，*=，/=，%=，**=，//=(相当于用本身当前的值去做运算，最后返回一个新的值；本身的名不变，而容量已经发生改变))
a=1
a+=1 #a=a+1
a-=8 #a=a-1
print(a)#此时输出的a为-6
#比较运算符==,!=,>,<,>=,<=
a=5
b=8
c=0
print(a==b)#False
print(a!=c)#True
print(a<b)#True
print(a<=b)#True
#逻辑运算符and与,or或,not非
a=66
b=88
c=98
d=66
print((a==b)and(b<c))#False
print((a==d)or(a<b))#True
print(not d>c)#True
#成员运算符in,not in
a=[2,4,6,7,9]
print(2 in a)#True
print(9 in a)#True
print(3 in a)#False
print(6 not in a)#False
print(7 not in a)#False
---------------: |
| is not | 判断两个对象是否不是同一个对象实例 |
## 运算符优先级
**优先级从高到低排序如下**
> 1. 括号 `()`
> 2. 指数运算符 `**`
> 3. 一元运算符 `+` `-` `~`（正号、负号、位取反）
> 4. 乘性运算符 `*` `/` `%` `//`（乘、除、模、整除）
> 5. 加性运算符 `+` `-`（加、减）
> 6. 移位运算符 `<<` `>>`
> 7. 位运算符 `&` `|` `^` `~`（位与、位或、位异或、位取反）
> 8. 比较运算符 `<` `<=` `>` `>=` `!=` `==`
> 9. 身份运算符 `is` `is not`
> 10. 逻辑运算符 `not` `and` `or`
> 11. 条件运算符（三元运算符） `x if condition else y`
> 12. 赋值运算符 `=` 以及复合赋值运算符如 `+=`, `-=`
***
## 代码块操作
```python
#算术运算符+，-，*，/，//取整除，%取余，**求指数结果
print("1+1=",1+1)
print("2-1=",2+1)
print("1*1=",1*1)
print("2/2=",2/2)
print("8//3=",8//3)
print("10%3=",8%3)
print("2**3=",2**3)
#赋值运算符=,(+=，-=，*=，/=，%=，**=，//=(相当于用本身当前的值去做运算，最后返回一个新的值；本身的名不变，而容量已经发生改变))
a=1
a+=1 #a=a+1
a-=8 #a=a-1
print(a)#此时输出的a为-6
#比较运算符==,!=,>,<,>=,<=
a=5
b=8
c=0
print(a==b)#False
print(a!=c)#True
print(a<b)#True
print(a<=b)#True
#逻辑运算符and与,or或,not非
a=66
b=88
c=98
d=66
print((a==b)and(b<c))#False
print((a==d)or(a<b))#True
print(not d>c)#True
#成员运算符in,not in
a=[2,4,6,7,9]
print(2 in a)#True
print(9 in a)#True
print(3 in a)#False
print(6 not in a)#False
print(7 not in a)#False