Python流程控制
一、代码块
以冒号（:）作为开始,用缩进来划分相同的作用域,称之为代码块,代码块是一个整体,一个文件也可称代码块
# 代码块 : 以冒号作为开始,用缩进来划分作用域,这个整体是一个代码块
"""
作用域: 作用的范围
"""
if 5 == 6:
print(1)
print(2)
print(3)
if 5 == 5:
print(4)
print(5)
print(6)
# 注意点:
"""
在使用缩进的时候,
要么全都使用\t ,要么全都使用4个空格
不能混合在一起使用,不能表达同一个代码块 IndentationError
"""
if 5 == 5:
print(7)
print(8)
"""
# 其他语言的写法:(拓展了解如：Java)
if(5 == 5){
print(9)
print(10)
}
"""
二、流程控制
流程的定义:代码执行的过程。
流程控制的定义:对代码执行的过程进行把控。
三大结构:
2.1、 顺序结构 : 从上到下依次执行代码
2.2、分支结构 : 细分成四种
2.3、 循环结构 : while , for
2.2、分支结构 :
2.2.1、单项分支
2.2.2、双项分支
2.2.3、多项分支
2.2.4、巢状分支
用if关键字来实现分支结构，完整语法如下
if 条件1: # 如果条件1的结果为True，就依次执行：代码1、代码2，......
代码1
代码2
......
elif 条件2: # 如果条件2的结果为True，就依次执行：代码3、代码4，......
代码3
代码4
......
elif 条件3: # 如果条件3的结果为True，就依次执行：代码5、代码6，......
代码5
代码6
......
else: # 其它情况，就依次执行：代码7、代码8，......
代码7
代码8
......
# 注意：
# 1、python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行
# 2、条件可以是任意表达式，但执行结果必须为布尔类型
# 在if判断中所有的数据类型也都会自动转换成布尔类型
# 2.1、None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False
# 2.2、其余均为True
2.2.1、单项分支
# 单项分支
'''
语法1:
if 条件:
代码1
代码2
代码3
'''
name = "程序员在写代码"
if name == "程序员":
print("苦逼程序员")
2.2.2、双项分支
# 双项分支 (二选一)
"""
if 条件表达式 :
code1
code2
else:
code3
code4
如果条件表达式满足,返回True,执行if这个区间的代码块,也叫做真区间
如果条件表达式不满足,返回False,执行else这个区间的代码块,叫做假区间
"""
print("我叫你一声,你敢答应么?")
reply = "no"
if reply == "yes":
print("金角大王~")
else:
print("雄起~")
# 小练习
"""
登录网站:
账户admin , 密码是111
如果条件满足,打印登陆成功
如果条件不满足,打印登录失败
# input 等待用户输入字符串: [永远接受的数据是字符串]
name = input("请输入您的姓名:")
print(name)
"""
username = input("请输入您的账号:")
password = input("请输入您的密码:")
if username == "admin" and password == "111":
print("恭喜你,登陆成功~")
else:
print("抱歉,登录失败!")
2.2.3、多项分支
# 多项分支 (多选一) """ if 条件表达式1: code1 ... elif 条件表达式2: code2 ... elif 条件表达式3: code3 ... else: code4 ... 先判断条件表达式1是否满足,成立的话,执行对应code1这个代码块, 否则,向下执行 判断条件表达式2是否满足,成立的话,执行对应code2这个代码块, 否则,向下执行 判断条件表达式3是否满足,成立的话,执行对应code3这个代码块, 否则,向下执行 执行else 这个代码块 当所有条件表达式都不成立了,执行else这个代码块 elif + 条件表达式 可以写0个或者多个 else 不能接条件表达式 可以写0个或者1个 """ youqian = False youfang = False youche = False youyanzhi = False youtili = False 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("你是个好人6~")
2.2.4、巢状分支
# 巢状分支 (单项分支,双向分支,多项分支互相嵌套的写法,看起来像巢状)
youqian = True
youfang = False
youche = False
youyanzhi = False
youtili = False
if youqian == True:
if youfang == True:
if youche == True:
if youyanzhi == True:
if youtili == True:
print("恭喜你~ 我要嫁给你~")
else:
print("你去补一补,吃两个大腰子")
else:
print("你去韩国整整容,再来,我不喜欢油腻的大叔..")
else:
print("出门左拐,是二路汽车,投币只需要1元钱")
2.2.5、分支结构的注意事项示例
#出题 height
#女生找对象
# 男生在1米以下的 大朗~ 该吃药了!
# 男生在1米~1.5米之间 小强 你在哪里?
# 男生在1.5~1.7米之间 没有安全感~
# 男生 1.7~ 1.8米之间 帅哥 留个电话
# 男生 1.8~2米之间 帅哥 你建议多一个女朋友吗
"""
注意点: 表达的条件分支不要有交集,彼此独立;
"""
# Python支持的写法：1 < height <= 1.5: 而在其他语言中可修改为：1 < height and height <= 1.5:
height = float(input("请输入您的身高:"))
print(height , type(height))
""""""
if height <= 1:
print("大朗~ 该吃药了!")
elif 1 < height <= 1.5:
print("小强 你在哪里?")
elif 1.5 < height <= 1.7:
print("没有安全感~")
elif 1.7 < height < 1.8:
print("帅哥 留个电话")
elif 1.8 < height <= 2:
print("帅哥 你建议多一个女朋友吗")
else:
print("没有对应的选项")
2.3、 循环结构 :python中有while与for两种循环机制，其中while循环称之为条件循环。
循环：重复做一件事。
while循环：
while 条件:
代码1
代码2
代码3
while的运行步骤：
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、......，如果条件为False,则循环终止
# 循环结构--while
# while 条件表达式:
code ...
如果条件表达式成立,返回真True ,执行对应的代码块
如果条件表达式不成立,返回假False,不执行对应的代码块
(1) 初始化变量
(2) 写上判断的条件
(3) 写上自增或者自减的值,用来跳出循环;
"""
# 打印1 ~ 100
# (1) 初始化变量
i = 1
# (2) 写上判断的条件
while i <= 100:
# (4) 写上代码的循环逻辑
print(i)
# (3) 写上自增或者自减的值,用来跳出循环;
i+=1 # i = i + 1
"""
第一步初始化变量i
第一次循环
i = 1 判断i <= 100 条件成立,返回True,执行循环体
print(1)
i+=1 => 自增加1 => 2
第二次循环
i = 2 判断2 <= 100 条件成立,返回True,执行循环体
print(2)
i+=1 => 自增加1 => 3
第三次循环
i = 3 判断3 <= 100 条件成立,返回True,执行循环体
print(3)
i+=1 => 自增加1 => 4
以此类推...
... ...
当print(100)时,
i+=1 => 自增加1 => 101
回到循环判断,发现 101<= 100 条件不满足,返回False ,终止循环.
"""
# ### 死循环和致命的效率问题
"""
while True:
print("死循环") # CPU一直输出，是致命的
"""
"""
while True:
name = input("请输入你的名字：") # 这种属于不致命
print("死循环")
"""
# 总结：纯计算无IO的死循环会导致致命的效率问题。
"""
while 1的执行效率 高于 while True的效率（True会先转行成1后再运行所以效率低）
# ### 计算1~100的累加和
# 方法一
i = 1
total = 0
while i<=100:
total += i
i+=1
print(total)
"""
第一次循环
i = 1 i<=100 条件满足 => total += i => total = total + i = 0 + 1
i+=1 => i = 2
第二次循环
i = 2 i<=100 条件满足 => total += i => total = total + i = 0 + 1 + 2
i+=1 => i = 3
第三次循环
i = 3 i<=100 条件满足 => total += i => total = total + i = 0 + 1 + 2 + 3
i+=1 => i = 3
....
以此类推
当i = 100的时候 total = 0+1+2+3+4+ .... + 100
i+=1 => i = 101
101 <= 100 条件为假,不满足,不执行循环,循环终止了;
print(total) => 5050
"""
# 方法二
sign = True
total = 0
i = 1
while sign:
total += i
i+=1
# 加判断条件,用来终止循环
if i == 101:
sign = False
print(total)
# (1).打印一行十个小星星
help(print)
i = 0
while i<10:
print("*",end="")
i+=1
# 直接打印换行
print()
# (2).用字符串拼接的形式,打印变量得到一行十个小星星
i = 0
strvar = ""
while i<10:
# 写上自己的代码逻辑
strvar += "*"
i+=1
print(strvar)
"""
strvar += "*"
第一次
strvar = "" + "*" => "*"
第二次
strvar = "*" + "*" => "**"
第三次
strvar = "**" + "*" => "***"
...
依次类推
strvar = "**********"
"""
# (3).打印一行十个小星星 奇数个打印★ 偶数个打印☆
"""
任意数和n进行取余 , 余数的范围是多少? 0 ~ (n-1)
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
3 % 2 = 1
4 % 2 = 0
0101010 ....
0 % 5 = 0
1 % 5 = 1
2 % 5 = 2
3 % 5 = 3
4 % 5 = 4
5 % 5 = 0
6 % 5 = 1
01234 ...
任意数 % 98
"""
i = 0
while i < 10:
# 循环的逻辑
if i % 2 == 0:
print("★",end="")
else:
print("☆",end="")
i+=1
（1）用户认证程序：
用户认证程序的基本逻辑就是接收用户输入的用户名密码然后与程序中存放的用户名密码进行判断， 判断成功则登陆成功，判断失败则输出账号或密码错误。
# 使用if判断完成
username = "lsj"
password = '123'
input_name = input("请输入您的账号：")
input_pw = input("请输入您的密码：")
if username == input_name and password == input_pw:
print("登录成功！！")
else:
print("账号或者密码错误，登录失败！！！")
（2）通常认证失败的情况下，会要求用户重新输入用户名和密码进行验证，如果我们想给用户三次试错机会，我们使用while循环实现。
username = 'lsj'
password = 123
count = 0
while count < 3:
inp_name = input("请输入您的账号：")
inp_password = int(input("请输入您的账号："))
if inp_name == username and inp_password == password:
print("登录成功！！！")
else:
print("账号或者密码错误，登录失败！！！")
count += 1
# 但是上面的代码是有问题的，当用户前三次登录成功后，无法结束循环，那如何结束掉一个循环呢？这就需要用到break了！
（3）while+break的使用
username = 'lsj'
password = 123
# 记录循环此时
count = 0
while count < 3:
inp_name = input("请输入您的账号：")
inp_password = int(input("请输入您的账号："))
if inp_name == username and inp_password == password:
print("登录成功！！！")
break # 结束当前循环
else:
print("账号或者密码错误，登录失败！！！")
count += 1 # 看一下count += 1在这个地方的效果，这两个地方无区别
# count += 1 # 看一下count += 1在这个地方的效果，这两个地方无区别
使用break关键字，只要运行到break立刻跳出当前所嵌套的循环，如果嵌套多层while循环体，则每层都要使用break结束，则break之后的代码不会被执行。
# 嵌套循环中break终止循环，每层嵌套都要有一个break'
username = "lsj"
password = "123"
tag = True
while tag:
intput_name = input("请输入您的账号：")
intput_password = input("请输入您的密码：")
if intput_name == username and intput_password == password:
print("登录成功！！")
while True:
c = input("请输入执行命令：")
if c == 'q':
print("{x}".format(x = c))
break # 每一层都要有个break，结束当前循环
break # 跳出当前嵌套的循环（如果嵌套好几层的话）
else:
print("登录失败")
print("=====end:tag= False时之后的代码还会执行====")
（4）while循环嵌套+tag的使用，将循环条件tag由True改为False
针对嵌套多层的while循环，如果我们的目的很明确就是要在某一层直接退出所有层的循环。
其实有一个窍门，就让所有while循环的条件都用同一个变量，该变量的初始值为True，一旦在某一层将该变量的值改成False，则所有层的循环都结束。
# 要在某一层直接退出所有循环
username = 'lsj'
password = "123"
# 记录循环次数
# count = 0
tag = True
while tag:
inp_name = input("请输入您的账号：")
inp_password = input("请输入您的密码：")
if inp_password == password and inp_name == username:
print("登录成功！！")
while tag:
cmd = input("随意输入一条命令：")
if cmd == "q":
tag = False # tag变为False， 所有while循环的条件都变为False
break # 结束内部循环
print('run<%s>' % cmd)
break # 结束本层循环
else:
print("账号或者密码错误！！！")
# count += 1
# 方式一：False终止循环，可以执行之后的代码
username = "lsj"
password = "123"
tag = True
while tag:
tag = False # 时之后的代码还会执行
intput_name = input("请输入您的账号：")
intput_password = input("请输入您的密码：")
if intput_name == username and intput_password == password:
print("登录成功！！")
tag = False # 时之后的代码还会执行
else:
print("登录失败")
print("=====end:tag= False时之后的代码还会执行====")
（5）while+continue的使用
break代表结束本层循环，而continue则用于结束本次循环，直接进入下一次循环，所以continue之后的代码永远无法运行到
# 打印1到10之间，除了6以外的所有数字
number = 1
while number < 10: # 问什么此处是number<10 而不是<=10
number += 1
if number == 6:
continue #结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环
print(number)
（6）while+else的使用（break就是真的else结束循使用的）
在while循环的后面，我们可以跟else语句，当while 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束
# 输错三次跳出循环
username = "lsj"
password = "123"
tag = True
count = 0
while tag:
if count == 3:
print("输入超过三次退出循环")
break
intput_name = input("请输入您的账号：")
intput_password = input("请输入您的密码：")
if intput_name == username and intput_password == password:
print("登录成功！！")
while tag:
c = input("请输入执行命令：")
if c == "q":
tag = False
else:
print("{x}".format(x = c))
else:
print("登录失败")
count += 1
else:
print("tag = False跳出while循环，查看while循环后的else是有运行")
print("=====break和else关系====")
2.4、单项循环练习
# (4)用 一个循环 打印十行十列小星星
"""
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
★★★★★★★★★★
0 ~ 9 0 1 2 3 4 5 6 7 8 9
10~19 0 1 2 3 4 5 6 7 8 9
20~29 0 1 2 3 4 5 6 7 8 9
...
90~99 0 1 2 3 4 5 6 7 8 9
0123456789
**********
10 11 12 13 14 15 16 17 18 19
* * * * * * * * * *
20 21 22 23 24 25 26 27 28 29
* * * * * * * * * *
**********************************************************************
无论是9 ,19 ,29,39 .... 只要是和10取余,余数是9,就意味着是该打印换行了;
"""
i = 0
while i<100:
# 打印星星
print("*",end="")
# 打印换行
if i % 10 == 9:
print()
i+=1
print()
# (5)一个循环 打印十行十列隔列变色小星星(一个循环)★☆
"""
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
"""
i = 0
while i<100:
# 控制输出星星的种类
if i % 2 == 0:
print("★",end="")
else:
print("☆",end="")
# 控制打印换行
if i % 10 == 9:
print()
i+=1
# (6)一个循环 打印十行十列隔行变色小星星(一个循环)
"""
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
"""
"""
# 方法一：
i = 0
flg = True
while i < 100:
if flg:
print("★", end="")
else:
print("☆", end="")
if i % 10 == 9:
print()
if flg:
flg = False
else:
flg = True
i += 1
"""
"""
# 方法二：
i = 0
while i < 100:
# 打印星星
if (int(i/10)) % 2 == 0:
print("☆", end="")
else:
print("★", end="")
# 打印换行
if i % 10 == 9:
print()
i += 1
"""
"""
# 方法三：
i = 0
u = 0
while i < 100 :
if u%2 == 0:
print('★',end='')
else:
print('☆',end='')
if i % 10 == 9:
u+=1
print()
i += 1
"""
"""
任意数和n进行地板除,会出现n个相同的数
0 // 3 = 0
1 // 3 = 0
2 // 3 = 0
3 // 3 = 1
4 // 3 = 1
5 // 3 = 1
6 // 3 = 2
7 // 3 = 2
8 // 3 = 2
# 10个相同的0
0 // 10 = 0
1 // 10 = 0
2 // 10 = 0
...
9 // 10 = 0
# 10个相同的1
10 // 10 = 1
11 // 10 = 1
...
19 // 10 = 1
# 10个相同的2
20 // 10 = 2
21 // 10 = 2
..
29 // 10 = 2
# 10个相同的3
# 10个相同的4
# 10个相同的5
# 10个相同的6
# 10个相同的7
# 10个相同的8
...
# 10个相同的9
90 // 10 = 9
91 // 10 = 9
..
99 // 10 = 9
总结: 出现了10个相同的种类
0 ~ 9 0000000000 %2 => 0
10~19 1111111111 %2 => 1
20~29 2222222222 %2 => 0
30~39 3333333333 %2 => 1
40~49 4444444444 ...
50~59 5555555555
60~69 6666666666
70~79 7777777777
80~89 8888888888
90~99 9999999999
要的花色是黑白
在和 2 取余
"""
i = 0
while i<100:
# 负责打印星星
if i // 10 % 2 == 0:
print("★",end="")
else:
print("☆",end="")
# 负责打印换行
if i % 10 == 9:
print()
i+=1
2.5、双项循环
# (1)打印十行十列小星星 (用两个循环)
"""
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
"""
# 外层循环负责控制行数
j = 0
while j<10:
# 里层循环负责控制列数,打印一行十个小星星
i = 0
while i<10:
print("*",end="")
i+=1
# 负责打印换行
print()
j+=1
# (2)打印十行十列隔列换色小星星 (用两个循环)
print("<=====>")
i = 0
while i < 10:
# 里层循环负责打印星星
j = 0
while j<10:
if j % 2 == 0:
print("◇",end="")
else:
print("◆",end="")
j+=1
# 打印换星星
print()
i+=1
# (3)打印十行十列隔行换色小星星 (用两个循环)
"""
外层循环动一遍,里层循环动十遍
外层循环动的慢,里层循环动的快
"""
print("<=====>")
i = 0
while i < 10:
# 里层循环负责打印星星
j = 0
while j<10:
if i % 2 == 0:
print("◇",end="")
else:
print("◆",end="")
j+=1
# 打印换星星
print()
i+=1
循环的强化练习
# 循环的强化练习 # 99乘法表 # 方向一 i = 1 while i<=9: # 打印里面的表达式 j = 1 while j<=i: # "谁*谁=谁" print("%d*%d=%2d " % (i,j,i*j) , end="" ) j+=1 # 打印换行 print() i+=1
结果如下：
# 方向二
print("<========>")
i = 9
while i>=1:
# 打印里面的表达式
j = 1
while j<=i:
# "谁*谁=谁"
print("%d*%d=%2d " % (i,j,i*j) , end="" )
j+=1
# 打印换行
print()
i-=1
结果如下：
# 方向三
print("<=========>")
i = 1
while i<=9:
# 先循环空格
k = 9-i
while k>0:
# print(" "*7 ,end="")
print(" ",end="")
k-=1
# 在循环表达式
j = 1
while j<=i:
# "谁*谁=谁"
print("%d*%d=%2d " % (i,j,i*j) , end="" )
j+=1
# 在打印换行
print()
i+=1
结果如下：
# 方向四 print("<=========>") i = 9 while i>=1: # 先循环空格 k = 9-i while k>0: # print(" "*7 ,end="") print(" ",end="") k-=1 # 在循环表达式 j = 1 while j<=i: # "谁*谁=谁" print("%d*%d=%2d " % (i,j,i*j) , end="" ) j+=1 # 在打印换行 print() i-=1
结果如下:
# (5)100 ~ 999 找吉利数字 111 222 123 321 888 ... """ // 可以获取一个数的高位 % 可以获取一个数的低位 987 个位: 987 % 10 = 7 十位: 987 // 10 % 10 = 8 百位: 987 // 100 = 9 """ # 方法一 i = 100 while i<=999: # 写上自己的逻辑 gewei = i % 10 shiwei = i // 10 % 10 baiwei = i // 100 # 个位 = 十位 = 百位 if shiwei == gewei and shiwei == baiwei: print(i) # 123 345 789 if shiwei == gewei -1 and shiwei == baiwei + 1: print(i) # 987 765 if shiwei == gewei + 1 and shiwei == baiwei - 1: print(i) i+=1 # 方法二 print("<========>") i = 100 while i<=999: # 先把数字变成字符串 str_num = str(i) gewei = int(str_num[-1]) shiwei = int(str_num[1]) baiwei = int(str_num[0]) # print(baiwei,shiwei , gewei) # 个位 = 十位 = 百位 if shiwei == gewei and shiwei == baiwei: print(i) # 123 345 789 if shiwei == gewei -1 and shiwei == baiwei + 1: print(i) # 987 765 if shiwei == gewei + 1 and shiwei == baiwei - 1: print(i)
i+=1 # (6)百钱买百鸡:公鸡一个五块钱，母鸡一个三块钱，小鸡三个一块钱，现在要用一百块钱买一百只鸡，问公鸡、母鸡、小鸡各多少只 """ 穷举: 一个个试 x = (1,2) y = (3,4) z = (5,6) x+y+z = 10? 有几种情况 x = 1 y = 3 z = 5 1+3+5 = 9 不符合 x = 1 y = 3 z = 6 (第一种) 1+3+6 = 10 符合 x = 1 y = 4 z = 5 (第二种) 1+4+5 = 10 符合 x = 1 y = 4 z = 6 1+4+6 = 11 不符合 x = 2 y = 3 z = 5 (第三种) 2+3+5 = 10 符合 x = 2 y = 3 z = 6 2+3+6 = 11 不符合 x = 2 y = 4 z = 5 2+4+5 = 11 不符合 x = 2 y = 4 z = 6 2+4+6 = 12 不符合 公鸡 x 母鸡 y 小鸡 z x+y+z = 100 5 *x + 3 * y + 1/3 * z = 100 x 范围小于20 y 范围小于33 z 范围小于100 """ # 试用while循环操作 x = 0 while x <= 20: y = 0 while y <= 33: z = 0 while z<=100: if x+y+z == 100 and 5*x + 3*y +1/3*z == 100: print(x,y,z) z += 1 y+=1 x+=1
试用for循环实现
for i in range(1,20):
for j in range(1,33):
for k in range(3,98,3):
if i+j+k == 100 and 5*i + 3*j + k//3 == 100:
print("公鸡：",i,"母鸡：",j,"小鸡：",k)
三、关键字的使用
pass / break / continue
3.1、pass语句在 Python 中用于表示一个空的语句块，通常用于占位。
def some_function():
pass
some_function()
输出：
None
3.2、break 语句是用来 中断 循环语句的，即直接停止循环语句的执行，就算循环条件没有变为 False 或者序列没有迭代到最后一项。
需要重点关注的是，如果你 中断 了一个 for 循环或者一个 while 循环，任何相应循环的 else 语句块都不会被执行。
while True:
s = input('Enter something : ')
if s == 'quit':
break
print('Length of the string is', len(s))
3.3、continue 语句用来告诉 Python 跳过当前循环语句块中的其余部分，然后 继续 执行循环的下一个迭代。
while True:
s = input('Enter something : ')
if s == 'quit':
break
if len(s) < 3:
print('Too small')
continue
print('Input is of sufficient length')
四、字符串相关操作
(1)字符串的拼接
# (1)字符串的拼接 +
strvar = "刘先生" + "真棒"
# strvar = "feiernk" + 15 error
var1 = "刘先生"
var2 = "15岁了"
strvar = var1 + var2 # 刘先生岁了
# += strvar = strvar + ",非常聪明"
strvar += ",非常聪明"
print(strvar)
(2)字符串的重复
# (2)字符串的重复 *
strvar = "重要的事情说三遍" * 3
print(strvar)
(3)字符串跨行拼接
# (3)字符串跨行拼接 \
strvar = "isjdfalkdfjkdasfjlkdaflkdajsklfsdalkfjskaldfjkadfjlkaoiwuo2432" \
"2934234h213hkjhsdfjjdsfyysadf"
print(strvar)
(4)字符串的索引
# (4)字符串的索引
# 正向 0 1 2
strvar = "你好么"
# 逆向 -3 -2 -1
res = strvar[1]
res = strvar[-2]
print(res)
(5)字符串的切片（截取）
(5)字符串的切片:"""
语法 => 字符串[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到字符串的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
(5)[:]或[::] 截取所有字符串
"""
strvar = "有时候,你害怕的是趴在窗外的班主任给你写罚单"
# (1)[开始索引:] 从开始索引截取到字符串的最后
res = strvar[4:]
print(res)
# (2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
res = strvar[:7] # 0 1 2 3 4 5 6
print(res)
# (3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
res = strvar[14:17] # 14 15 16
print(res)
# (4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取字符
# 正向获取
res = strvar[::3] # 0 3 6 9 12 15 18 21 ....
# 逆向获取
res = strvar[::-1] # -1 -2 -3 -4 -5 -6 -7 ...
print(res)
# (5)[:]或[::] 截取所有字符串
res = strvar[:]
res = strvar[::]
print(res)
五、字符串的格式化format
(1)顺序传参
(2)索引传参
(3)关键字传参
(4)容器类型数据(列表或元祖)传参
(5)format的填充符号的使用( ^ > < )
(6)进制转换等特殊符号的使用( :d :f :s :, )
六、字符串相关函数
*capitalize 字符串首字母大写
*title 每个单词的首字母大写 (非字母隔开的单词)
*upper 将所有字母变成大写
*lower 将所有字母变成小写
*swapcase 大小写互换
*count 统计字符串中某个元素的数量
*find 查找某个字符串第一次出现的索引位置
*index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
*startswith 判断是否以某个字符或字符串为开头
*endswith 判断是否以某个字符或字符串结尾
*split 按某字符将字符串分割成列表(默认字符是空格)
*join 按某字符将列表拼接成字符串(容器类型都可)
*replace 替换字符串(可选择替换的次数)
isupper 判断字符串是否都是大写字母
islower 判断字符串是否都是小写字母
istitle 判断字符串是否每个单词都首字母大写
*isalnum 判断字符串是否是由数字、字母、汉字组成
isalpha 判断字符串是否由字母和文字组成
*isdigit 检测字符串数是数字组成 接受二进制字节流
*isdecimal 检测字符串是否以数字组成 必须是纯数字
isnumeric 检测字符串是否以数字组成 接受中文"四"
isspace 判断字符串是否由空白符组成
*len 计算容器类型长度
splitlines 按换行来进行切分(\n)
zfill 填充字符串(默认填充0,原字符串右对齐)
ljust 填充字符串,原字符居左 (默认填充空格)
rjust 填充字符串,原字符居右 (默认填充空格)
*center 填充字符串,原字符居中 (默认填充空格)
*strip 默认去掉首尾两边的空白符
rstrip 去掉右边某个字符
lstrip 去掉左边某个字符
maketrans translate 是一对
maketrans()
功能: 制作用于字符串替换的映射表
格式: 字符串.maketrans('查找字符','替换字符')两个字符必须长度相等
返回值: 字典
translate()
功能: 进行字符串替换操作
格式: 字符串.translate(maketrans返回的字典)
返回值: 替换之后的字符串
