Java教程

运算符及流程控制、while循环、for遍历

本文主要是介绍运算符及流程控制、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遍历的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!