本文主要是介绍运算符及流程控制、while循环、for遍历，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 运算符
• • 概念
  • 算数运算符 + - * / // % **
  • 比较运算符：< > <= >= == !=
  • 赋值运算符：= += -= *= /= //= %= **=
  • 成员运算符：in 和 not in （针对于容器型数据）
  • 身份运算符: is 和 is not
  • 逻辑运算符：and or not
  • • and 逻辑与：全真则真，一假则假
    • or 逻辑或：全假则假，一真则真
    • not 逻辑非：真变假，假变真
    • 逻辑短路
  • 位运算符: & | ~ ^ << >>
  • 运算符的总结
  • • 1.个别的特殊运算符：
    • 2 对于全体运算符来说：
    • 3.处于同一层级的运算符：
    • 4.运算符的优先级：
• 流程控制
• • 判断类型 isinstance
  • 代码块
  • 代码块的注意点：
  • 流程控制
  • • 单项分支：
    • 双项分支：
    • 多项分支：
    • 巢状分支：
• while循环
• 关键字使用 pass break continue
• • pass 过（占位）
  • break 终止当前循环
  • continue 跳过当前循环，从下一次循环开始
• for遍历
• • range对象
• while和for循环总结

运算符

概念

计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算，今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算

算数运算符 + - * / // % **

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()

这篇关于运算符及流程控制、while循环、for遍历的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！