Python学习四：流程控制语句（if-else、while、for），高级数据类型（字符串、列表、元组、字典）的操作

前言

• 流程：就是计算机执行代码的顺序
• 流程控制：对计算机代码执行的顺序进行有效的管理，只有流程控制才能实现在开发当中的业务逻辑

一、流程控制

• 流程控制的分类：

1. 顺序流程: 就是代码一种自上而下的执行结构，也是python默认的流程
2. 选择流程/分支流程: 根据在某一步的判断，有选择的去执行相应的逻辑的一种结构
   2.1 单分支
   2.2 双分支
   2.3 多分支
3. 循环流程：在满足一定的条件下，一直重复的去执行某段代码的逻辑【事情】
   while使用：适用于对未知的循环次数 用于判断
   for使用：适用于已知的循环次数【可迭代对象遍历】

1. 单分支 if 分支

• 单分支if 分支比较简单，只有一次判断，

if 条件表达式:
     一条条的python代码
     一条条的python代码
     一条条的python代码

• 直接上代码测试

# 单分支
# if  条件表达式: 比较运算符 逻辑运算符 /复合的条件表达式
#     代码指令
#     .......
score = 60
if score <= 60:  # 满足条件就会输出打印的提示
    print("成绩不是太理想,要继续加油哦")
    pass  # 空语句

print("语句运行结束")

'''
关键字pass属于占位关键字，一般是在开发中先用它占据函数体确定整个模块的基本框架，之后再删去pass填充函数体。
pass的合理使用可以方便我们组织编程。
当程序运行到pass时不会执行任何操作，解释器会把pass当做一条咸鱼而不去理会。
'''

2. 双分支 if-else 分支

• if-else 分支
  Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。
  

if 有卖西瓜的：
    买两个西瓜
else:
    买四个包子

• if-else 嵌套
  
• 代码测试

'''
双分支
if  条件表达式: 比较运算符 逻辑运算符 /复合的条件表达式
    代码指令
 else:
    代码指令
必定会执行其中一个分支
'''

score = 60
if score > 60:  # True
    print("你的成绩及格了...")
    pass
else:  # false时候才会执行
    print('成绩不合格，请继续努力')
    pass

3. 多分支 if-elif-else 分支

• if-elif-else 分支语法

if 条件表达式：
    python语句
elif 条件表达式：
    python语句
elif 条件表达式：
    python语句
else： 
    python语句

• 直接上代码测试

'''
多分支的选择【多个条件】
 if  条件表达式: 比较运算符 逻辑运算符 /复合的条件表达式
    代码指令
 elif 条件表达式:
    代码指令
 ......
    else:

特征:
1.只要满足其中一个分支，就会退出本层if语句结构【必定会执行其中一个分支】
2.至少有2中情况可以选择
elif 后面必须的写上条件和语句
else 是选配，根据实际的情况来填写
'''

score = int(input('请输入您的成绩：'))
print(type(score))
if score > 90:
    print('您的成绩是A等级')
    pass
elif score >= 80:
    print('您的成绩是B等级')
    pass
elif score >= 70:
    print('您的成绩是C等级')
    pass
elif score >= 60:
    print('您的成绩是D等级')
    pass
else:
    print('您的成绩不合格')

print('程序结束了。。。')

4. 案例:if-else嵌套

# if-else 的嵌套使用

# 一个场景需要分阶段或者层次，做出不同的处理
# 要执行内部的 if 语句 一定要外部的 if 语句满足条件才可以
score = int(input('请输入您的学分：'))

if score > 10:
    grade = int(input('请输入您的成绩：'))
    if grade >= 80:
        print('您可以升班了，恭喜您！！')
        pass
    else:
        print('很遗憾，您的成绩不达标！！')
        pass
    pass
else:
    print('您的表现有点差，学分成绩不达标。无法升班！！')
    pass

5. 循环流程-while循环

• python语法

while 条件表达式:
    代码指令

'''
语法特点
1.有初始值
2.条件表达式
3.变量【循环体内计数变量】的自增自减, 否则会造成死循环
使用条件：循环的次数不确定，是依靠循环条件来 结束
目的: 为了将相似或者相同的代码操作变得更加简洁，使得代码可以重复利用
'''
'''
end关键字：
end 是print函数中的关键字。
在while、for循环中，每次输出都是换行的。加入end，使用end=''中的内容代替换行，分隔每次循环输出内容
'''

• 案例一：输出1-100之间的数据

index = 1
while index <= 100:
    print(index)
    index += 1

• 案例二：打印九九乘法表 循环的嵌套

# 打印正三角
row = 1
while row <= 9:
    col = 1
    while col <= row:
        print('%d*%d=%d' % (row, col, row * col), end=' ')
        col += 1
        pass
    print()
    row += 1
    pass
# 打印倒三角
row = 9
while row >= 1:
    col = 1
    while col <= row:
        print('%d*%d=%d' % (row, col, row * col), end=' ')
        col += 1
        pass
    print()
    row -= 1
    pass

• 案例三：打印直角三角形

# 正三角
row = 1
while row <= 7:
    col = 1
    while col <= row:
        print('*', end=' ')
        col += 1
        pass
    print()
    row += 1
    pass

# 倒三角
row = 7
while row >= 1:
    col = 1
    while col <= row:
        print('*', end=' ')
        col += 1
        pass
    print()
    row -= 1

• 案例四：打印等腰三角形

# 第一行1个 第二行3个 第三行5个 第四行7个
row = 1
while row <= 5:
    col = 1
    while col <= 5 - row:  # 控制打印左边空格的数量
        print(' ', end=' ')
        col += 1
        pass
    k = 1
    while k <= 2 * row - 1:  # 控制打印 * 号
        print('*', end=' ')
        k += 1
        pass
    print()
    row += 1

6. 循环流程-for循环

下面的案例不在截图，直接运行即可

• python 语法

'''
for循环
语法特点: 遍历操作，依次的取集合容器中的每个值
for 临时变量 in 容器:
    执行代码块
'''
print('--------------for循环： 打印字符串------------------')
tags = '我是一个中国人'  # 字符串类型本身就是一个字符类型的集合
for item in tags:
    print(item, end=' ')
    pass

• 案例一：for循环： range函数，计算1到100的加和

print('--------------for循环： range函数，计算1到100的加和------------------')
'''
range 此函数可以生成一个数据集合列表
range(起始:结束:步长)  步长不能为0
'''
print(type(range(1, 100)))
sum = 0
for data in range(1, 101):  # 左边包含  右边不包含
    sum += data  # 求累加和
    print(data, end=' ')
    pass
print()
print('1+...+100=', sum)

• 案例二：for循环： 嵌套if-else

print('--------------for循环： 嵌套if-else------------------')
for data in range(50, 201):
    if data % 2 == 0:
        print("%d是偶数" % data)
        pass
    else:
        print("%d是奇数" % data)
pass

• 案例三：for循环： break的使用

'''
break和continue
break 代表中断结束，满足条件直接的结束本层循环
continue:结束本次循环，继续的进行下次循环（当continue的条件满足的时候，本次循环剩下的语句将不在执行
后面的循环继续）
这两个关键字只能用在循环中使用（while、loop）
'''
print('--------------for循环： break的使用------------------')
sum = 0
for item in range(1, 51):
    if sum > 100:
        print('循环执行到%d就退出来了' % item)
        break  # 退出循环体
        pass
    sum += item
    pass
print("sum=%d" % sum)

• 案例四：for循环： continue的使用

print('--------------for循环： continue的使用------------------')
for item in range(1, 100):  # 求出来奇数
    if item % 2 == 0:
        continue
        print('在continue的额后面会不会执行呢')  # 这句话不会执行
        pass
    print(item)
    pass

• 案例五：for循环： 练习 break 和 continue

print('--------------for循环： 练习 break 和 continue------------------')
for item in 'i love python':
    if item == 'e':
        break  # 彻底终端循环，
        # continue
    print(item, end=' ')

# break 打印出 i   l o v
# continue 打印出 i   l o v   p y t h o n

print()
print('--------------while循环： 练习 break 和 continue------------------')
index = 1
while index <= 100:
    index += 1
    if index > 20:
        break
        pass
    print(index)

• 案例六：for循环： 练习 break 和 continue

print('--------------for循环案例： 打印九九乘法表------------------')
# 案例1 打印九九乘法表  循环的嵌套
for i in range(1, 10):
    for j in range(1, i + 1):
        print('%d*%d=%d' % (i, j, i * j), end=' ')
        pass
    print()
    pass

• 案例七：for循环案例： for—else使用

print('--------------for循环案例： for---else使用------------------')
# for---else 使用
for item in range(1, 11):
    print(item, end=' ')
    pass
else:
    print('就是上面循环当中，只要是出现了break 那么else 的代码将不再执行')

• 案例八：for-else 使用，密码用户三次机会登录

'''
for-else 使用，密码用户三次机会登录
'''
account = 'wyw'
pwd = '123'
for i in range(3):
    zh = input('请输入账号')
    pd = input('请输入密码')
    if account == zh and pwd == pd:
        print('登录成功！！')
        break
    pass
else:
    print('您的账号已经被系统锁定。。。')

• 案例九：while循环案例： while—else使用

print('--------------while循环案例： while---else使用------------------')
index = 1
while index <= 10:
    print(index)
    if index == 6:
        break
        pass
    index += 1
    pass
else:
    print('else 执行了么') # 不会打印这句

7. homework

• 作业一：

'''
猜年龄小游戏，有三点需求
1.允许用户最多尝试3次
2.每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y， 就继续让其猜3次，以此往复，如果回答N或n，就退出程序
3.如何猜对了，就直接退出
目的：演练 while 和 if 的使用，综合运用
'''
print('------------------作业一：------------------')
times = 0
while times <= 3:
    ageInput = int(input('请输入您猜测的年龄：'))
    age = 25
    if ageInput == age:
        print('恭喜您，猜对了')
        break
        pass
    elif ageInput > 25:
        print('猜大了')
        pass
    else:
        print('猜小了')
    times += 1
    if times == 3:
        choose = input('想继续猜吗？ Y/N？')
        if choose == 'Y' or choose == 'y':
            times = 0
            pass
        elif choose == 'N' or choose == 'n':
            times = 4
            pass
        else:
            print('请不要乱输入')
            pass
        pass

• 作业二：

print('------------------作业二：------------------')
'''
小王身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小王计算他的BMI指数，并根据BMI指数：
低于18.5   过轻
18.5-25： 正常
25-28：    过重
28-32：    肥胖
高于32：  严重肥胖
用if-elif判断并打印结果
'''

weight = 80.5
high = 1.75
bmi = weight / (high * high)
print('BMI的数据是%d'%(bmi))
if bmi < 18.5:
    print('过轻')
    pass
elif bmi >= 18.5 and bmi < 25:
    print('正常')
    pass
elif bmi >= 25 and bmi < 28:
    print('过重')
    pass
elif bmi >= 28 and bmi < 32:
    print('肥胖')
    pass
elif bmi >= 32:
    print('严重肥胖')

二、关键字学习

1. end关键字

'''
end关键字：
end 是print函数中的关键字。
在while、for循环中，每次输出都是换行的。加入end，使用end=“”中的内容代替换行，分隔每次循环输出内容
'''

三、数据类型的操作

计算机是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。

在Python中，能够直接处理的数据类型有：数字、字符串、列表、元组、字典等。

1. 序列 ：在python当中 序列就是一组按照顺序排列的值【数据集合】
   在python中 存在三种内置的序列类型：字符串、列表、元组

2. 序列优点：可以支持索引和切片的操作

3. 序列特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端

1. 字符串(str)操作

字符串是有下标的，从0开始
如图所示

字符串方法举例

1. 字符串创建

# 字符串操作
test = 'python'
print('test 变量的类型：', type(test))

1. 字符串遍历

print('第一个字符:', test[0])
print('第一个字符:', test[1])

for item in test:
    print(item, end=' ')
    pass
print()

1. capitalize()首字母转换大写

print('------------------1、capitalize()首字母转换大写-----------------------')
name = 'peter'
print('首字母转换大写 %s' % name.capitalize())

4. strip()去掉两边的空格

print('------------------2、strip()去掉两边的空格-----------------------')
a = '    hel lo    '
print('去掉两边的空格: %s' % (a.strip()))

5. lstrip()去掉左边的空格

print('------------------3、lstrip()去掉左边的空格-----------------------')
b = '    hel lo    '
print('去掉左边的空格: %s' % (b.lstrip()))

6. rstrip()去掉右边的空格

print('------------------4、rstrip()去掉右边的空格-----------------------')
c = '    hel lo    '
print('去掉右边的空格: %s' % (c.rstrip()))

7. a 复制到 d

print('------------------5、a 复制到 d-----------------------')
d = a
print('a 复制到 d: %s' % (d))

8. id(a)查看内存地址

print('------------------6、id(a)查看内存地址-----------------------')
print('a 的内存地址:%d' % id(a))  # id（a）  id()函数，是查看地址的
print('d 的内存地址:%d' % id(d))

9. find()查找子字符串是否存在

print('------------------7、find()查找子字符串是否存在-----------------------')
dataStr = 'I Love Python'
print('find()查找子字符串是否存在：%d' % (dataStr.find('Py')))  # find() 函数返回的是该字符串在整体字符串的第一个下标,找不到返回 -1

10. index()查找子字符串是否存在

print('------------------8、index()查找子字符串是否存在-----------------------')
print('index()查找子字符串是否存在：%d' % (dataStr.index('o')))  # index() 函数 检测字符串中是否包含子字符串，返回的是下标值，找不到返回报错

11. startswith()、endswith()判断字符串是否以某个字符串为开头或者结尾

print('------------------9、startswith()、endswith()判断字符串是否以某个字符串为开头或者结尾-----------------------')
print('判断字符串是否以某个字符串为开头：%s' % dataStr.startswith('I'))
print('判断字符串是否以某个字符串为结尾：%s' % dataStr.endswith('on'))

12. 将字符串转化为小写或者大写

print('------------------11、将字符串转化为小写或者大写-----------------------')
print('将字符串转化为小写：%s' % dataStr.lower())
print('将字符串转化为大写：%s' % dataStr.upper())

13. 切片方法 slice [start: end:step]

print('------------------12、切片方法 slice [start: end:step]-----------------------')
strMsg = 'hello world'
# slice [start: end:step] 左闭右开， start<=value<end 范围
print('完整数据：%s' % strMsg)
print('字符串第一个字符：%s' % strMsg[0])
print(strMsg[2:5])  # 2-5下标之间的数据
print(strMsg[2:])  # 第三个字符到最后
print(strMsg[0:3])  # 1-3 strMsg[0:3]=strMsg[:3]
print(strMsg[:3])  # 1-3
print(strMsg[::-1]) # 倒叙输出 负号表示方向 从右边往左去遍历

还有一些没有测试，但是常用的

2. 列表(list)操作

list列表:python当中非常重要的数据结构，是一种有序的数据集合
特点：
1：支持增删改查
2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
3:用[] 来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据
4：支持索引和切片来进行操作

列表操作

1. 列表定义

# 列表定义
li = []  # 空列表
listA = [1, 2, 3, '你好']

1. 列表长度、类型

print('------------------1、列表长度、类型-----------------------')
# 打印列表类型 和 长度
print(type(listA))
print(len(listA))  # len函数可以获取到列表对象中的数据个数
strA = '我喜欢python'
print(len(strA))

3. 列表 遍历：通过下标和切片取值

print('------------------2、列表 遍历：通过下标和切片取值-----------------------')
listB = ['abcd', 785, 12.23, 'qiuzhi', True]
print(listB)  # 输出完整的列表
print(listB[0])  # 输出第一个元素
print(listB[1:3])  # 从第二个开始到第三个元素
print(listB[2:])  # 从第三个元素开始到最后所有的元素
print(listB[::-1])  # 负数从右像左开始输出
print('遍历', listB)
print(listB * 3)  # 输出多次列表中的数据【复制】

4. 列表 增加

print('------------------3、列表 增加-----------------------')
print('追加之前', listB)
listB.append(['fff', 'ddd'])  # 追加操作， 插入的是一个
listB.append(8888)
print('追加之后', listB)

listB.insert(1, '这是我刚插入的数据')  # 插入操作 需要执行一个位置插入
print(listB)

5. 列表 强转

print('------------------4、列表 强转-----------------------')
rsData = list(range(10))  # 强制转换为list对象
print(type(rsData))
print(rsData)

6. 列表 批量添加

print('------------------5、列表 批量添加-----------------------')
listB.extend(rsData)  # 拓展  等于批量添加
listB.extend([11, 22, 33, 44])
print(listB)

7. 列表 修改

print('------------------6、列表 修改-----------------------')
print('修改之前：', listB)
listB[0] = 333.6
print('修改之后：', listB)

8. 列表 删除,两种删除方式：关键字、函数

print('------------------7、列表 删除,两种删除方式：关键字、函数-----------------------')
listC = list(range(10, 50))
print('删除之前%s' % listC)
del listC[0]  # 删除列表中第一个元素
del listC[1:3]  # 批量删除多项数据 slice
print('删除之后%s' % listC)

listC.remove(20)  # 移除指定的元素  参数是具体的数据值
print('删除指定的数据20%s' % listC)

listC.pop(1)  # 移除制定的项  参数是索引值
print('删除指定的数据下标%s' % listC)

9. 列表 查找

print('------------------8、列表 查找-----------------------')
print(listC.index(11))  # 返回的是一个索引下标
print(listC.index(25, 5, 16))  # 查找 25 ，从下标为5开始查找 步长为16的范围 。返回的是一个索引下标,

10. 统计元素出现的次数

print('------------------9、统计元素出现的次数-----------------------')
print(listC.count(22))

其他常用的列表方法

3. 元组(tuple)操作

1. 元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，元组也是通过下标进行访问
2. 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
3. 元组的内置方法count，统计元素在元组中出现的次数
4. 元组的内置方法index 查找指定元素在元组中的下标索引

# 元组操作 不能进行修改、增加、删除   只能进行查找（一般是使用切片）
'''
元组：是一种不可变的序列，在创建之后不能做任何的修改
1：不可变
2：用（）创建元组类型，数据项用逗号来分割
3：可以是任何的类型
4：当元组中只有一个元素时，要加上逗号，不然后解释器会当做其他类型来处理
5：同样可是支持切片操作
'''
print('--------------------1、元组 创建（注意：当元组中只有一个元素时）-----------------------')
tupleA = ()
print(type(tupleA))
tupleA = ('abcd')
print(type(tupleA))
tupleA = ('abcd',)  # 当元组中只有一个元素时，要加上逗号，不然后解释器会当做其他类型来处理
print(type(tupleA))
tupleA = ('abcd', 89, 9.12, 'peter', [11, 22, 33])
print(type(tupleA))

print('--------------------2、元组 遍历-----------------------')
print('for 循环遍历:', end='')
for item in tupleA:
    print(item, end=' ')
    pass

print()
print('切片截取:', tupleA[2:4])
print('逆序打印：', tupleA[::-1])

print('反转字符串 每隔 1 个取一次：', tupleA[::-2])  # 表示反转字符串 每隔1 个取一次
print('反转字符串 每隔 2 个取一次：', tupleA[::-3])  # 表示反转字符串 每隔 2 个取一次

print('倒着取下标 为-2 到 -1 区间的：', tupleA[-2:-1:])  # 倒着取下标 为-2 到 -1 区间的  左不包含，右包含
print('倒着取下标 为-4 到 -2 区间的：', tupleA[-4:-2:])  # 倒着取下标 为-2 到 -1 区间的

print('---------------------3、元组不可修改，但可修改里面的列表------------------------')
# tupleA[0]='PythonHello'  #错误的
print(type(tupleA[4]))  # <class 'list'>
tupleA[4][0] = 285202  # 可以对元组中的列表类型的数据进行修改
print(tupleA)

print('---------------------4、元组和range方法------------------------')
tupleC = tuple(range(10))
print(tupleC)

print('---------------------统计元素出现的次数------------------------')
print(tupleC.count(4))  # 可以统计元素出现的次数

4. 字典(dict)操作

• 字典是Python的中重要的一种数据类型，可以存储任意对像。
  字典是以键值对的形式创建的{‘key’:‘value’}利用大括号包裹着。

• 字典中找某个元素时，是根据键、值字典的每个元素由2部分组成，键:值

• 访问值的安全方式get方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

注意点：

1. 字典的键（key）不能重复，值（value）可以重复。

2. 字典的键（key）只能是不可变类型，如数字，字符串，元组。

# 字典操作
'''
字典：也是python中重要的数据类型，字典是有 键值对 组成的集合，通常使用 键来访问数据，效率非常高，和list一样 支持对数据的添加、修改、删除
特点：
1：不是序列类型 没有下标的概念，是一个无序的 键值集合，是内置的高级数据类型
2：用{} 来表示字典对象，每个键值对用逗号分隔
3：键 必须是不可变的类型【元组、字符串】 值可以是任意的类型
4: 每个键必定是惟一的，如果存在重复的键，后者会覆盖前者
'''

print('---------------------1、字典创建------------------------')
dictA = {}  # 空字典
dictA = {'pro': '艺术', 'school': '山东中医药大学'}
dictA['name'] = '李易峰'  # key:value
dictA['age'] = 30
dictA['pos'] = '歌手'

# 结束添加
print('遍历：', dictA)
print('dictA类型：', type(dictA))
print('字典长度：', len(dictA))

print('---------------------2、字典修改:两种方式------------------------')

dictA['name'] = '谢霆锋'
dictA['school'] = '香港大学'
print('修改方式一修改之后：', dictA)

dictA.update({'age': 99})
dictA.update({'height': 99})  # 可以 更新 和 添加
print('修改方式二修改之后：', dictA)

print('---------------------3、字典获取------------------------')
# 获取所有的 键
print('获取所有的 键:', dictA.keys())
# 获取所有的 值
print('获取所有的 值:', dictA.values())
# 获取所有的 键和值
print('获取所有的 键和值:', dictA.items())

for key, value in dictA.items():
    print('%s == %s' % (key, value))
    pass

print('---------------------4、字典 删除:关键字 和 pop() 方法------------------------')
print('删除之前：', dictA)
del dictA['name']
dictA.pop('age')
print('删除之后：', dictA)

print('---------------------5、字典  排序（进阶）------------------------')
# 如何排序， 按照 key 排序
print('按照 key 排序', sorted(dictA.items(), key=lambda item: item[0]))
# 按照 value 排序
#print('按照 value 排序', sorted(dictA.items(), key=lambda item: item[1]))