提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
运算符
概念
计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算，今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算
算数运算符 + - * / // % **
var1 = 6
var2 = 4
# + 加法
res = var1 + var2
print(res)
# ‐ 减法
res = var1 ‐ var2
print(res)
# * 乘法
res = var1 * var2
print(res)
# / 除法(结果为小数)
res = var1 / var2
print(res)
# // 地板除(返回整数)
res = var1 // var2
print(res)
# % 取余
res = 11 % 4
res = ‐11 % 4 # ‐3 + 4 = 1
res = 11 % ‐4 # 3 + (‐4) = ‐1
res = ‐11 % ‐4 # ‐3 (如果被除数和除数都是负数，在正常的结果前面加上 负号即可)
print(res)
res = ‐17 % 7 # ‐3 + 7 = 4
res = 17 % ‐7 # 3 + (‐7) = ‐4
res = ‐17 % ‐7 # ‐3
print(res)
# ** 幂运算
res = 3 ** 2
res = 3 ** 4
print(res)
注意点：
1./ 除法，结果为小数
2.// 地板除，返回整数
3.// 如果被除数或者除数是一个小数,结果加上.0
比较运算符：< > <= >= == !=
注意点：
1.只会产生两种结果：True和False
2.>=,<= 两个值相等，返回值也为True
var1 = 100
var2=100
res = var1 > var2
res = var1 < var2
res = var1 <= var2
res = var1 >= var2
print(res)
#注意点
res = var1 == var2
print(res )
res = var1 != var2
print(res)
赋值运算符：= += -= *= /= //= %= **=
注意点：
1.= 是赋值，从右向左,将右侧的值赋值给左侧变量
2.a+=b---->a=a+b
从右向左，将右侧的值赋值给左侧变量。 例如，var = 9 的意思是将9赋值给变量var，并非var等于9。
var1 = 9
var2 = 2
# +=
'''var1 = var1 + var2 '''
var1 += var2
print(var1)
# -=
'''var1 = var1 - var2'''
var1 -= var2
print(var1)
#*=
'''var1 = var1 * var2 '''
var1 *= var2
print(var1)
# /=
'''var1=var1/var2'''
var1 /= var2
print(var1)
# //=
'''var1 = var1 // var2'''
var1 / /= var2
print(var1)
# %=
'''var1 = var % var2'''
var1 %= var2
print(var1)
# **=
'''var1 = var1 ** var2'''
var1 **= var2
print(var1)
成员运算符：in 和 not in （针对于容器型数据）
注意点：
1.字符串必须是一个连续的片段
2.列表元组字典正常判断即可
3.在字典中，in和not in在字典中只判断键，不判断值
strvar=‘听说白雪公主在逃跑，小红帽在担心大灰狼'
res='雪' in strvar
res='文' in strvar
res='白雪公主' in strvar
s res='白小灰狼' in strvar#字符串必须是个连续的片段，否则即使每个字符都在字符串中也是False
res=',' in strvar
print(res)
#list tuple set
lst=['白雪公主'，'小红帽'，‘大灰狼'，‘匹诺曹']
res='白雪公主'in lst
print(res)
tup=('白雪公主'，'小红帽'，'大灰狼'，‘匹诺曹')
res='福兹福'not intup
print(res)
setvar = {'金角大王','银角大王','老男孩'}
res = '老男孩' in setvar
print(res)
# dict
'in和not in在字典中只判断键，不判断值'''
dic = {'bxgz': '白雪公主'，'xhm': '小红帽'，'dhl': '大灰狼'}
res = '白雪公主' in dic
res = 'bxgz' in dic
res = 'dhl' not in dic
print(res)
身份运算符: is 和 is not
注意点：
1.身份运算符的作用是检测两个数据在内存当中是否是同一个值
2.判断是否同一个值请看上篇文章：判断id是否相同的部分。
var1 = 4-90j
var2 = 4-90j
res = var1 is not var2
print(res)
var1 = (1, 2, 3)
var2 = (1, 2, 3)
res = var1 is var2
print(res)
逻辑运算符：and or not
注意点：
1.逻辑与:全真则真，一假则假
2.逻辑或:全假则假，一真则真
3.逻辑非：真变假，假变真
4.逻辑短路： 如果出现了短路效果,后面的代码不执行
短路条件：
(1) True or 表达式
(2) False and 表达式
5.逻辑运算符的优先级：() > not > and > or
and 逻辑与：全真则真，一假则假
res = True and True
res = True and False
res = False and True
res = False and False
print(res)
or 逻辑或：全假则假，一真则真
res = True and True
res = True and False
res = False and True
res = False and False
print(res )
not 逻辑非：真变假，假变真
res = not False
res = not True
print(res)
逻辑短路
逻辑短路：如果出现了短路效果，后面的代码不执行 逻辑短路的两种形式：
(1) True or 表达式；
(2) False and 表达式。
上述的两种情况，虽然后面的表达式不执行，但是表达式中如果有语法 错误，还是会报错的
True or print('我们都是小怪兽呀')
# True or True => True
# True or False => True
False and print('凡王之血，必以剑终')
# False and True => False
# False and False => Fal se
注意：只有and或者or出现一次的情况下才考虑逻辑短路，否则运算符 的优先级会影响短路的效果。
print(False and 7 or 8) # 由于运算符优先级的缘故，并不会出现短路的效果，结果是8，而不是False
位运算符: & | ~ ^ << >>
1.按位与 &
2按位或 |
3.按位异或 ^ (两个值不一样,返回真,否则返回假)
4.<< 左移 ：左移相当于做乘法 : a * 2的n次幂 >> 右移 ：右移相当于做除法 : a // 2的n次幂
5.~ 按位非 (针对于补码进行操作,按位取反,包括符号位)
var1 = 19
var2 = 15
print(var1 & var2)
'''
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 01111
0000 ... 01111
0000... 00011 => 3
'''
#按位或|
var1 = 19
var2 = 15
print(var1| var2)
'''
19的二进制
0000 ... 10011
15的二进制
0000 ... 01111
0000 ... 01111
0000 ... 01111
0000 ... 11111 => 31
'''
#按位或异^两个值不一样，返回真，否则返回假
'''
1 0=>1
0 1=>1
0 0=>0
1 1=>0
'''
var1 = 19
var2 = 15
print(var1 ^ var2)
'''
19的二进制
0000. ..10011
15的二进制
0000 ... 01111
0000 ... 01111
0000 ... 11100 => 28
'''
# << 左移
...左移相当于做乘法: 5 * 2的n次幂'..
res=5<<1
res=5<<2
res= 5<<3
print(res)
'''
0000..101
0000 .. 1010移动一位
0000 .. 10100移动两位
'''
#>>右移
'''右移相当于做除法: 5112的n次幕'''
res=5>> 1
res=5>>2
res=5>>3
print(res)
'''
68 0000 ... 101
69 0000 ... 010移动1位
70 0000 ... 001移动2位
71 0000 ... 000移动3位
'''
# ~ 按位非(针对于补码进行操作，按位取反，包括符号位)
'''公式：‐(n+1)'''
var1 = ~19
print(var1)
'''
~ 按位非每一位都取反，包括符号位，求反码是每一位除了符号位
原码：
0000 ... 10011
反码：
0000 ... 10011
补码：0000 ... 10011
补码： 0000 ... 10011
按位非： 1111 ... 01100
给你补码求原码：
补码：1111 ... 01100
反码：1000 ... 10011
原码：1000 ... 10100 => ‐20
'''
var1 = ~(‐19)
print(var1)
'''
原码：1000 ... 10011
反码：1111 ... 01100
补码：1111 ... 01101
补码： 1111 ... 01101
按位非：0000 ... 10010
补码：0000 ... 10010
原码：0000 ... 10010 => 18 108
'''
运算符的总结
1.个别的特殊运算符：
优先级最高：** (幂运算符)
优先级最低：= (赋值运算符)
2 对于全体运算符来说：
一元运算符 > 二元运算符
一元运算符：同一时间，只操作一个值 二元运算符：同一时间，操作两个值
3.处于同一层级的运算符：
逻辑：() > not > and > or
算数：乘除 > 加减
位运算符：(<< >>) > & > ^ > |
4.运算符的优先级：
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 >逻辑运算符 > 赋值运算符
流程控制
判断类型 isinstance
语法：
用法一：
isinstance(要判断的值，要判断的类型)返回True或者False
用法二：
isinstance(要判断的值，（可能的类型1，可能的类型2，可能的类型3...）)如果有一个类型满足，返回的类型是True否则返回False
适用的数据类型：
int float bool complex str list tuple set dict
用法一：
res = isinstance(5,int)
print(res)
# 结果为True
res = isinstance("11223344",str)
print(res)
# 结果为True
res = isinstance([1,2,3],tuple)
print(res)
# 结果为False
用法二：
res = isinstance(16, (str,list,tuple) )
print(res)
# 结果为False
代码块
代码块：以冒号作为开始，用缩进来划分作用域
作用域：作用的区域，作用的范围
# 判断条件为True，代码执行
if 10 == 10:
print(1)
print(2)
print(3)
print(4)
# 判断条件为False，代码执行
if 10 == 11:
print(11)
print(22)
print(33)
print(44)
代码块的注意点：
要么全都是一个Tab缩进，要么全部都是4个空格，不能混合使用
if 10 == 10:
print(100)
# print（200）前有一个2个空格和一个tab所以代码报错
print(200)
流程控制
流程：代码执行的过程
控制：对代码执行过程的一种把控
三大结构：
1.顺序结构：默认代码依次从上到下执行
2.分支结构：4种
（1）单项分支
（2）双项分支
（3）多项分支
（4）巢状分支
3.循环结构：for 和 while
<==========================================================>
单项分支：
if 条件表达式：
code1
code2
当条件表达式成立，返回True，执行对应的代码块，反之不执行
# 定义变量"女生"
liucaixia = "女生"
# 判断条件，判断liucaixia是否是女生，True执行，False不执行
if liucaixia == "女生":
# 执行打印
print("给他买一些好吃的")
print("给他买一些好玩的")
print("陪她出去逛街")
print("陪她买化妆品")
双项分支：
if 条件表达式：
code1
code2
else：
code3
code4
如果条件表达式成立，执行if对应的代码块
如果条件表达式不成立，则执行else对应的代码块
if 代码块也叫做真区间
else 代码块也叫做假区间
# 定义变量"抠脚老汉"
liucaixia = "抠脚老汉"
# 判断liucaixia是否是"抠脚老汉",结果为False，不执行if语句，
执行else语句
if liucaixia == "女生":
print("加他微信")
print("加他手机")
print("收集他的兴趣爱好")
print("以后多联系")
else:
print("给你一榔头~")
youqian = True
# 双项分支
if youqian == True:
print("上午刚认识,下午就结婚")
else:
print("你是个好人")
# input 等待用户输入字符串,接受的数据是字符串
"""
name = input("先森,你妈贵姓?~")
print(name , type(name))
"""
多项分支：
语法：
if 条件表达式1：
code1
code2
elif 条件表达式2：
code1
code2
elif 条件表达式3：
code1
code2
else:
code…
如果条件表达式1成立，返回True，执行对应的代码块，反之则向下执行
如果条件表达式2成立，返回True，执行对应的代码块，反之则向下执行
如果条件表达式3成立，返回True，执行对应的代码块，反之则向下执行
直到最后，任何条件都不满足，执行else这个分支的代码块。
elif 可以出现0次或者多次
else 可以出现0次或者1次
# 定义变量都为假
youqian = False
youfang = False
youche = False
youyanzhi = False
youtili = False
# 判断变量是否为真，不为真，则直接执行else
if youqian == True:
print("我就嫁给你1")
elif youfang == True:
print("我就嫁给你2")
elif youche == True:
print("我就嫁给你3")
elif youyanzhi == True:
print("我就嫁给你4")
elif youtili == True:
print("我就嫁给你5")
else:
print("你是个好人")
# 定义变量
youqian = True
youfang = False
youche = False
youyanzhi = False
youtili = False
# 判断变量是否为真，第一个变量为真，则直接执行第一个if语句
if youqian == True:
print("我就嫁给你1")
elif youfang == True:
print("我就嫁给你2")
elif youche == True:
print("我就嫁给你3")
elif youyanzhi == True:
print("我就嫁给你4")
elif youtili == True:
print("我就嫁给你5")
else:
print("你是个好人")
# 定义变量
youqian = False
youfang = True
youche = False
youyanzhi = False
youtili = False
# 判断变量是否为真，第二个变量为真，则直接执行第二个if语句
if youqian == True:
print("我就嫁给你1")
elif youfang == True:
print("我就嫁给你2")
elif youche == True:
print("我就嫁给你3")
elif youyanzhi == True:
print("我就嫁给你4")
elif youtili == True:
print("我就嫁给你5")
else:
print("你是个好人")
# 定义变量
youqian = True
youfang = True
youche = True
youyanzhi = True
youtili = True
# 判断变量都为真，只执行第一个if语句
if youqian == True:
print("我就嫁给你1")
elif youfang == True:
print("我就嫁给你2")
elif youche == True:
print("我就嫁给你3")
elif youyanzhi == True:
print("我就嫁给你4")
elif youtili == True:
print("我就嫁给你5")
else:
print("你是个好人")
巢状分支：
单项分支，双项分支，多项分支的相互嵌套
youqian = False
youfang = False
youche = False
youyanzhi = False
youtili = False
# 判断第一个if为假，往后的判断条件都不执行，直接执行else
if youqian == True:
if youfang == True:
if youche == True:
if youyanzhi == True:
if youtili == True:
print("老娘今天死活要嫁给你,等着接盘吧,兄弟")
else:
print("恭喜你~ 成为我的1号备胎")
else:
print("你可以上韩国整整容,整成金城武再来.")
else:
print("出门左拐,乘2路汽车,2站之后下是你家,不送了,老弟.")
while循环
循环结构：while 循环
特点：减少冗余的代码，提升代码的效率
语法：
while 条件表达式：
code1…
code2…
1.初始化一个变量
2.写上循环的判断条件
3.自增自减的变量值
打印1 ~ 100
# 打印1 ~ 100
i = 1
while i <= 100:
# 在这个位置写要执行的逻辑
print(i)
i += 1 # i = i + 1
代码解析：
初始化一个变量i
第一次循环
i = 1 , i<=100 成立返回True,执行循环
print(1)
i += 1 => 2
第二次循环
i = 2 , i<=100 成立返回True,执行循环
print(2)
i += 1 => 3
第三次循环
i = 3 , i<=100 成立返回True,执行循环
print(3)
i += 1 => 4
....
什么时候结束?
当i = 101时候, 判断i <= 100 不成立返回False ,不执行循环
循环结束...
计算1~100的累加和
方法一：
# 打印1 ~ 100
i = 1
while i <= 100:
# 在这个位置写要执行的逻辑
print(i)
i += 1 # i = i + 1
代码解析
第一次循环
i = 1 i<=100 成立执行循环
total += i => total = total + i => 0 + 1
i+=1 => 2
第二次循环
i = 2 i<=100 成立执行循环
total += i => total = total + i => 0 + 1 + 2
i+=1 => 3
第三次循环
i = 3 i<=100 成立执行循环
total += i => total = total + i => 0 + 1 + 2 + 3
i+=1 => 4
....
依次循环
什么时候结束?
i = 100
total = 0 + 1 + 2 + 3 + 4 + ...+ 100 = 5050
当i = 101 不满足循环的条件 , 直接跳出,循环结束..
到此打印 5050 ;
方法二：
# 方法二.
total = 0
i = 1
sign = True
while sign:
total += i # total = total + i
i+=1
# 手动加上终止循环的条件
if i == 101 :
sign = False
print(total)
关键字使用 pass break continue
pass 过（占位）
# 条件为真，执行while代码
while True:
# pass占位不执行下面代码，返回while继续执行，所以是死循环
pass
if 10 == 10:
print(123)
# if条件为真，打印123，执行下一行代码
if 10 == 10:
print(123)
# while为真执行
while True:
# pass占位不执行，所以只打印123后死循环
pass
break 终止当前循环
# 打印1~10 遇到5就终止循环
# 定义变量i从1开始
i = 1
# 循环i，并且让i<=10成立为True，执行下面代码
while i <= 10:
# 判断i是否等于5
if i == 5:
# 当i等于5时 终止当前循环
break
# 打印i的结果
print(i)
# i+1=i 循环
i += 1
# 输出结果：1 2 3 4
# break 终止的是当前循环
# 定义变量i
i = 1
# i<=3，控制外层循环，当i=3时终止循环
while i <= 3:
# 定义变量j
j = 1
# j<=3,控制内层循环
while j <= 3:
# 判断j是否等于2
if j == 2:
# 当j等于2时终止当前循环
break
# 打印i和j的值
print(i, j)
# 内层循环j+1=j
j += 1
# 外层循环i+1=i
i += 1
# 输出结果：1外层 1内层
# 2外层 1内层
# 3外层 1内层
continue 跳过当前循环，从下一次循环开始
# 打印1~10 跳过5
i = 1
while i <= 10:
# 当i不等于5时，会执行外层的i+=1，i等于5时才会执行内层的i+=1
if i == 5:
# 需手动自增加1. 当执行continue时,后面的代码不执行,
# 跳到while循环的条件判断处,会造成死循环
i += 1
continue
print(i)
i += 1
# 打印1~ 100 所有不含有4的数字
i = 1
while i <= 100:
# i地板除10取高位值，判断高位值是否等于4
# or(或者)
# i取余10取个位值，判断个位值是否等于4
if i // 10 == 4 or i % 10 == 4:
i += 1
# 当i等于4或i有含有4的值不执行下面代码，直接返回while
continue
print(i)
i += 1
for遍历
功能：遍历、循环、迭代
# while循环取出列表中的元素
lst = ["刘鑫", "刘子豪", "刘子涛", "晏国彰"]
# i等于lst列表的索引
i = 0
# len计算lst列表的长度，然后循环i
while i < len(lst):
print(lst[i])
i += 1
# 输出结果：刘鑫 刘子豪 刘子涛 晏国彰
# for 直接遍历出lst列表中的每个元素
for i in lst:
print(i)
# 输出结果：刘鑫 刘子豪 刘子涛 晏国彰
for主要用于遍历数据而提出，while在遍历数据时，有局限性
for语法：
for 变量 in 可迭代对象：
code1
code2
可迭代对象（容器类型数据，range对象，迭代器）
# 遍历字符串
container = "雷霆嘎巴,ZBC,无情哈拉少"
# 输出结果：雷/n霆/n嘎/n巴/n,/nZ/nB/nC/n,/n无/n情/n哈/n拉/n少
# 遍历列表
container = ["刘鑫", "刘子豪", "刘子涛", "晏国彰"]
# 输出结果：刘鑫/n刘子豪/n刘子涛/n晏国彰
# 遍历元组
container = (1, 2, 3, 45)
# 输出结果：1/n2/n3/n45
# 遍历集合
container = {"白星","高峰峰","孙志和","刘鹏","牧树人"}
# 输出结果：高峰峰/n白星/n牧树人/n刘鹏/n孙志和
# 遍历字典 (遍历字典时,只遍历键)
container = {"ww":"伟大的人,风流倜傥","msr":"树人,伟大的人","mh":"猥琐的老男人"}
# 输出结果：ww/n msr/n mh
for i in container:
print(i)
遍历不等长的二级容器
# 遍历不等长的二级容器
container = [["刘聪", "毛洪磊", "余锐", "张家豪"], ("崔文君", "张捷")]
# 先遍历第一级的元素赋值给i
for i in container:
# 在遍历第二级容器中每个元素赋值给j
for j in i:
print(j)
# 输出结果：
# 刘聪
# 毛洪磊
# 余锐
# 张家豪
# 崔文君
# 张捷
# 变量的解包
# a, b = 1, 2
# a, b = [3, 4]
a, b = {"a": 5, "b": 6}
print(a, b)
# 输出结果：
# 1 2
# 3 4
# a b
遍历等长的二级容器
# 遍历等长的二级容器
container = [("王健林", "王思聪", "王美丽"), ("马云", "马化腾", "马生平"), ("王宝强", "马蓉", "宋小宝")]
# 遍历container赋值给a，b，c
for a, b, c in container:
print(a, b, c)
# 输出结果：
# 王健林 王思聪 王美丽
# 马云 马化腾 马生平
# 王宝强 马蓉 宋小宝
range对象
语法：
range（开始值，结束值，步长）
结束值本身取不到，取到结束值之前的那个数
# 遍历0到9的元素，10本身取不到
for i in range(10):
print(i)
# 遍历3到10
for i in range(3, 11):
print(i)
# 遍历1到10的元素，每隔三个取一次值，结束值10本身取不到
for i in range(1, 10, 3):
print(i) # 1,4,7
# 倒序打印10 ~ 1
for i in range(10,0,-1):
print(i)
# 10 9 8 7 6 .... 1
while和for循环总结
while：适合较为复杂的逻辑
for： 适合数据遍历
while和for部分代码可以互相转换
区别写法1：
i = 1
while i<=10:
if i == 5:
i+=1
continue
print(i)
i+=1
for i in range(1,11):
if i == 5:
continue
print(i)
区别写法2
i = 1
while i <= 9:
j = 1
while j<=i:
print("%d*%d=%2d " % (i,j,i*j),end="")
j+=1
print()
i+=1
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%2d " % (i,j,i*j),end="")
print()