文章目录
前言
流程：就是计算机执行代码的顺序流程控制：对计算机代码执行的顺序进行有效的管理，只有流程控制才能实现在开发当中的业务逻辑
一、流程控制
流程控制的分类：
- 顺序流程: 就是代码一种自上而下的执行结构，也是python默认的流程
- 选择流程/分支流程: 根据在某一步的判断，有选择的去执行相应的逻辑的一种结构
2.1 单分支
2.2 双分支
2.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('严重肥胖')
二、关键字学习
- end关键字
'''
end关键字：
end 是print函数中的关键字。
在while、for循环中，每次输出都是换行的。加入end，使用end=“”中的内容代替换行，分隔每次循环输出内容
'''
三、数据类型的操作
计算机是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。
在Python中，能够直接处理的数据类型有：数字、字符串、列表、元组、字典等。
-
序列：在python当中 序列就是一组按照顺序排列的值【数据集合】
在python中 存在三种内置的序列类型：字符串、列表、元组 -
序列优点：可以支持索引和切片的操作 -
序列特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端
1. 字符串(str)操作
字符串是有下标的，从0开始
如图所示
字符串方法举例
- 字符串创建
# 字符串操作
test = 'python'
print('test 变量的类型：', type(test))
- 字符串遍历
print('第一个字符:', test[0])
print('第一个字符:', test[1])
for item in test:
print(item, end=' ')
pass
print()
- 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：支持索引和切片来进行操作
列表操作
- 列表定义
# 列表定义
li = [] # 空列表
listA = [1, 2, 3, '你好']
- 列表长度、类型
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)操作
- 元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，元组也是通过下标进行访问
- 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
- 元组的内置方法count，统计元素在元组中出现的次数
- 元组的内置方法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方法，还可以设置默认值
注意点：
-
字典的键（key）不能重复，值（value）可以重复。
-
字典的键（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]))
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
