* for循环详解
* 遍历字符串
* 求数字和
* 嵌套-99乘法表
* 控制跳转语句
* continue: 结束本次循环, 进行下次循环的.
* break: 终止循环.
* 综合案例: 猜数字游戏
* 容器类型之字符串详解
* 概述
* 下标
* 切片(重点)
* 常用函数
* find()
* index()
* replace()
* split()
---
1.前言
* 对你说的话, 如果你练习代码没有思路, 可以尝试下如下的方式
1. 先把我的代码备份了.
2. 把我的注释全部删掉, 只留代码.
3. 给我的代码写注释, 注释能写明白, 说明代码你看懂了.
4. 把我的代码删掉, 只留你写的注释, 这个就是思路.
5. 如果某段代码写不出来, 说明这个格式不熟, 记录一下, 一会着重练习.
6. 重复上述步骤, 直至: 删除注释和代码, 只留需求, 完成 注释和代码的编写.
2.for循环入门
"""
for循环介绍:
概述:
它属于 循环结构的一种, 主要用于 循环次数固定的 哪些循环.
例如: 遍历字符串, 列表...
格式:
for 临时变量 in 容器类型-例如字符串,列表等 :
循环体
细节:
1. 临时变量就是 从容器类型中获取到的每一个值, 用临时变量来记录.
2. for循环的临时变量, 只能在for循环内部使用, 除了for循环就不能用了.
这个是变量的: 作用域, 即: 变量在哪里能用, 在哪里不能用.
"""
# 需求1: for循环 遍历字符串.
s = 'heima'
for i in s:
# i 就是 字符串s中的每个字符, 例如: 'h', 'e', 'i', 'm', 'a'
print(i)
print('-' * 28)
# 需求2: for循环 遍历字符串, 判断是否有指定字符, 如果有, 就打印: 黑马AI28期
for i in s:
# i 就是字符串s中的每个字符, 例如: 'h', 'e', 'i'...
print(i)
# 判断当前字符串是否是 'i', 如果是, 就输出 黑马AI28期
if i == 'i':
# 走这里, 说明存在字符i
print('黑马AI28期')
print('-' * 28)
# 需求3: for循环, 打印 1 ~ 5之间的数字.
# 扩展: range(起始值, 结束值, 步长) 生成指定范围内的数字(包左不包右, 前闭后开), 默认的起始值: 0, 默认的步长是: 1
# for i in range(5): # 相当于你写了: range(0, 5, 1), 即: (0, 1, 2, 3, 4)
# for i in range(2, 5): # 相当于你写了: range(2, 5, 1), 即: (2, 3, 4)
# for i in range(1, 7, 2): # 从1开始, 到7结束, 间隔2. 即: (1, 3, 5)
for i in range(1, 6):
print(i)
print('-' * 28)
# 需求4: for循环, 统计 1 ~ 100之间的 奇数和.
# 1. 循环外定义求和变量 sum
sum = 0
# 2. for循环, 获取到所有合法的(要的) 数字.
for i in range(1, 101, 2):
# 3. 循环内, 完成具体的累加动作.
sum += i
# 4. 循环外, 打印求和结果.
print(f'求和结果为: {sum}')
3.for循环-99乘法表
# 需求: 通过for循环打印 99乘法表.
"""
如果你不熟, 还是效仿昨天的思路:
step1: 打印9行9列的 矩形.
step2: 将上述的图形改为 正三角形.
step3: 用 1 * 3 = 3 来替换上述的 *
step4: 用 i 和 j 进行填充即可.
"""
for i in range(1, 10): # 外循环控制 行数, 例如: i = 3
for j in range(1, i + 1): # 内循环控制 列数, 此时: j = 1, 2, 3
print(f'{j} * {i} = {i * j}', end='\t')
# 走到这里, 说明一行打印完毕, 记得换行.
print()
4.控制跳转语句-break-continue
"""
控制跳转语句详解:
概述:
控制跳转语句指的是 break 和 continue这两个关键字, 他们可以控制循环的执行.
作用:
continue: 结束本次循环, 进行下次循环的.
break: 终止循环, 即: 循环不再继续执行了.
"""
# 需求: 观察如下的代码, 再其中填充指定内容, 使其能够完成 打印2次, 7次, 13次 'Hello World'
for i in range(1, 11): # i的值: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
if i % 3 == 0:
# 这里加内容
# break # 看到break, 循环结束, 即: 打印的有 1, 2
# continue # 看到continue, 就结束本次循环, 立即开启下次循环, 即: 不打印的值有: 3, 6, 9
print(f'hello world! {i}')
print(f'hello world! {i}')
print('至此, for循环就执行结束了!')
5.报数字游戏
"""
案例: 报数字游戏.
规则:
1. 键盘录入玩游戏的人数.
2. 每个学生依次报数, 遇到尾数为7 或者 7的倍数时, 就跳过.
3. 统计报数的学生一共有多少人.
大白话翻译:
统计指定区间内, 尾数不为7 或者 不是7倍数的数字 共有多少个.
参考答案:
50个学生, 报数的同学为: 39人.
"""
# 1. 键盘录入参与游戏的 学生总人数.
num = int(input('请录入参与游戏的总人数: '))
# 2. 定义统计变量, 记录 合法数字的 总人数.
count = 0
# 3. 通过for循环, 获取到每个人, 例如: 1 ~ 50的每个人.
for i in range(1, num + 1):
# i 就是 1 ~ num + 1 之间的每个数值, 例如: 1, 2, 3, 4, 5, 6, 7......
# 4. 具体的报数环节, 如果尾数是7 或者 7的倍数, 就跳过.
if i % 10 == 7 or i % 7 == 0:
continue
# 5. 走到这里, 肯定是合法数值, 计数器 + 1即可.
count += 1
# 6. 循环结束后, 所有报数的总人数已经被变量记录了, 打印即可.
print(f'参与游戏总人数为 {num} 人, 报数的总人数为 {count} 人')
6.猜数字游戏
"""
需求:
1. 随机生成1个 1 ~ 100之间的随机数, 让用户来猜.
2. 如果用户猜大了, 就提示: 您猜大了. 接着让用户来猜.
3. 如果用户猜小了, 就提示: 您猜小了. 接着让用户来猜.
4. 如果用户猜对了, 就提示: 恭喜您, 猜对了. 并结束程序.
涉及到的知识点:
输入 input(),
类型转换: int(), eval()
循环: 循环次数不固定, 所以推荐用 while循环.
if判断
控制跳转: break
"""
# 0. 导包.
import random
# 1. 随机生成1个 1 ~ 100之间的随机数, 让用户来猜.
guess_num = random.randint(1, 100) # 包左包右
# 2. 因为不知道用户多少次能猜对, 所以用 while循环, 让用户一直猜.
while True:
# 3. 提示用户录入他/她要猜的数字, 并接收.
input_num = int(input('请录入您要猜的数字: '))
# 4. 比较两个数字(用户录入的, 随机生成的), 进行响应的提示即可.
if input_num > guess_num:
print('哎呀, 您猜大了!')
elif input_num < guess_num:
print('哎呀, 您猜小了!')
else:
print('恭喜您, 猜对了!')
# 5. 核心细节: 用户猜对了, 一定要break, 结束循环.
break
7.扩展-循环+else语法
"""
循环 + else语法:
概述:
else语句除了可以和 if语句结合使用外, 还可以和 循环一起使用.
格式:
while 或者 for循环:
循环体
else:
语句体
执行特点:
1. 只要循环是正常退出的, 就一定会执行 else中的内容.
2. 循环正常退出 指的是 非break的方式跳出.
3. 大白话: 只要循环不是break方式跳出的, 就会走else的内容, 否则不执行else的内容.
"""
# 需求1: 演示 for + else语句.
for i in range(1, 11): # i的值: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
if i % 3 == 0:
# continue # 结束本次循环, 进行下次循环的.
break
print(f'hello world! {i}')
else:
print('我是else, 看看我执行了吗?')
8.扩展-打印质数
"""
需求:
打印 1 ~ 100之间所有的质数, 按照 3个一行的方式进行输出.
质数解释:
1. 只能被1 和 自身整除的数字, 就称之为 质数, 质数 也叫 素数.
2. 最小的质数是 2
分析思路, 例如: 判断 10 是否是质数
1. 获取到 2 ~ 5(10的一半) 的值.
2. 和 10进行取余操作, 但凡有一组能整除, 说明10不是质数.
3. 无需判断后续的操作了, 直接判断 下个数字.
例如: 10 % 2 = 0, 说明10不是质数, 没必要接着判断 10 % 3 而是直接判断 11(下个数字)是否是质数即可.
"""
# 场景1: 分解版写法.
# 1. 定义计数器 count, 表示 质数的个数.
count = 0
# 2. 获取到 1 ~ 100之间 所有的整数.
for i in range(2, 101): # i 表示 要判断是否为 质数的数字, 例如: 10 13
# 3. 获取到 2 ~ i的一半之间, 所有的整数, 一会儿和i进行取余操作.
for j in range(2, i // 2 + 1): # j 表示 要进行取余操作的数字, 例如: 2,3,4,5 2,3,4,5,6
# 4. 具体的判断动作, 看其是否是质数.
if i % j == 0: # 10 % 2, 10 % 3, 10 % 4, 10 % 5 13 % 2, 13 % 3...
# 5. 走到这里, 说明 i 不是质数, 没必要继续判断i了, 直接判断 i + 1即可.
break
else:
# 6. 走到这里, 说明 不是break方式结束的, 说明 i 是质数.
count += 1 # 计数器 + 1
if count % 3 == 0:
print(i, end='\n')
else:
print(i, end='\t')
print()
print('-' * 28)
# 场景2: 合并版写法.
# 1. 定义计数器 count, 表示 质数的个数.
count = 0
# 2. 获取到 1 ~ 100之间 所有的整数.
for i in range(2, 101): # i 表示 要判断是否为 质数的数字, 例如: 10 13
# 3. 获取到 2 ~ i的一半之间, 所有的整数, 一会儿和i进行取余操作.
for j in range(2, i // 2 + 1): # j 表示 要进行取余操作的数字, 例如: 2,3,4,5 2,3,4,5,6
# 4. 具体的判断动作, 看其是否是质数.
if i % j == 0: # 10 % 2, 10 % 3, 10 % 4, 10 % 5 13 % 2, 13 % 3...
# 5. 走到这里, 说明 i 不是质数, 没必要继续判断i了, 直接判断 i + 1即可.
break
else:
# 6. 走到这里, 说明 不是break方式结束的, 说明 i 是质数.
count += 1 # 计数器 + 1
print(i, end='\n' if count % 3 == 0 else '\t')
print()
print('-' * 28)
# 场景3: 算法(公式)实现.
# 规律: 2 ~ 100之间的质数, 只要是 2, 3, 5, 7 或者 不能被其中所有的整数 整除, 该数字就是: 数值.
count = 0
for i in range(2, 101):
# 条件1: 是2, 3, 5, 7 或者 条件2: 不能被2,3,5,7 任意1个数字整除.
if i in (2, 3, 5, 7) or (i % 2 != 0 and i % 3 != 0 and i % 5 != 0 and i % 7 != 0):
count += 1
print(i, end = '\n' if count % 3 == 0 else '\t')
9.字符串入门
"""
容器类型介绍:
背景:
之前我们学的变量只能存储简单的, 单一的数据, 如果要同时存储多个值, 变量就实现不了了. 此时就需要用 容器类型 来实现.
例如:
存储咱们所有人的姓名, 年龄...
分类:
字符串:
列表:
字典:
元组:
集合:
字符串:
概述:
它属于容器类型的一种, 属于 不可变类型. 它由多个字符组成.
例如:
'abc', 'hello world', '张三'...
定义格式:
方式1: 一对引号, 单双引号均可.
方式2: 三引号, 可以保留字符串的格式.
下标:
...
切片:
...
常用函数:
...
案例:
...
"""
# 1. 通过 一对引号的方式 定义字符串, 单双引号均可.
s1 = '张三'
s2 = "李四"
print(s1, s2) # 同时输出多个值.
print(type(s1), type(s2))
# 2. 通过 三引号 的方式定义字符串.
s3 = """
select
[distinct] 列1, 列2...
from
表名
where
组前筛选
group by
分组字段
having
组后筛选
order by
排序字段 [asc | desc]
limit
起始索引, 数据条数;
"""
print(s3)
print(type(s3))
print('-' * 28)
# 3. 字符串特殊格式, 定义字符串变量, 记录: I'm Tom!
s4 = "I'm Tom!"
s5 = 'I\'m Tom!'
print(s4, s5)
print(type(s4), type(s5))
print('-' * 28)
# 4. 字符串遍历(也叫迭代, 即: 逐个获取 容器类型中 每个元素的动作)
for i in s5:
print(i) # i就是字符串s5中的 每个字符, 例如: 'I', 'm'...
10.字符串-索引详解
```python
"""
字符串索引详解:
概述:
Python中, 为了更好, 更方便的从字符串中获取到指定的内容, 给字符串的每个元素 提供的有索引.
索引也叫: 下标, 角标, 编号等...
细节:
1. Python中, 字符串的索引 有正向索引 和 逆向索引之分.
2. 正向索引: 从左往右(从前往后)编号, 且 编号从 0 开始.
3. 逆向索引: 从右往左(从后往前)编号, 且 编号从 -1 开始.
4. 例如:
字符串: i t h e i m a
正向索引: 0 1 2 3 4 5 6 ->
逆向索引: -7 -6 -5 -4 -3 -2 -1 <-
5. 可以通过 字符串变量名[索引] 的形式, 从字符串中 获取到 指定的内容.
"""
# 1. 定义字符串.
s1 = 'itheima'
# 2. 从字符串中获取指定内容, 并打印.
print(s1[2]) # 'h'
print(s1[-5]) # 'h'
print(s1[5]) # 'm'
print(s1[-2]) # 'm'
print(s1[3]) # 'e'
print(s1[-2]) # 'm'
11.字符串-切片
```python
"""
字符串切片介绍:
概述:
从字符串中 截取出 指定的内容 就称之为: 字符串切片.
格式:
字符串变量名[起始索引:结束索引:步长] 包左不包右.
细节:
1. 正向索引是从前往后(从左往右), 从 0 开始.
2. 逆向索引是从后往前(从右往左), 从 -1 开始.
3. 如果不写起始索引, 默认从: 0开始,
如果不写结束默认, 默认到字符串末尾.
如果不写步长, 默认是: 1
4. 如果 索引 和 步长的方向相反, 获取不到数据.
5. 特殊写法, 字符串[::-1] 表示反转字符串, 这个是面试题.
例如:
字符串: a b c d e f g h
正向索引: 0 1 2 3 4 5 6 7
逆向索引: -8 -7 -6 -5 -4 -3 -2 -1
"""
# 1. 定义变量s1, 记录字符串内容.
s1 = 'abcdefgh'
# 2. 演示字符串的切片.
print(s1[1:3]) # bc 不写步长, 默认是: 1
print(s1[:5]) # abcde 不写起始索引, 默认是: 0
print(s1[3:]) # defgh 不写结束索引, 默认到: 字符串最后
print(s1[1:5:2]) # bd 起始索引是1, 结束索引是5, 步长是2, 包左不包右.
print('-' * 28)
print(s1[-6:-2]) # cdef, 不写步长, 默认是: 1
print(s1[-6:-2:1]) # 效果同上.
print(s1[-6:-2:-1]) # 不报错, 但是啥都没有. 因为查找的顺序是 -6到-2 从前往后(->), 而步长是-1, 顺序是 从后往前(<-) 查找和步长顺序相反, 无数据.
print(s1[-1:-5:-1]) # hgfe
print(s1[:-3]) # abcde
print(s1[-5:]) # defgh
print(s1[2:-3]) # cde
print(s1[-2:1]) # 不报错, 但是啥都没有. 查找方向 和 方向顺序不一致.
print(s1[-2:1:-1]) # gfedc
# 面试题
print(s1[:]) # abcdefgh, 即: 字符串本身.
print(s1[::-1]) # hgfedcba, 即: 反转字符串
print(s1[::-3]) # heb
12.字符串函数-index-find
"""
字符串常用函数介绍:
概述:
你可以简单的把函数先理解为就是 别人写好的"工具", 我们直接调用就可以了, 传入 参数(原材料), 经过函数加工, 可以获取指定的 结果(返回值).
常用函数:
字符串变量名.find(子串, 起始索引, 结束索引)
找子串在字符串中 第1次 出现的位置, 如果写开始和结束索引(包左不包右), 就在指定区间查找, 找不到就返回 -1
字符串变量名.index(子串, 起始索引, 结束索引)
效果同上, 只不过是, 找不到就 报错.
字符串变量名.rfind(子串, 起始索引, 结束索引)
效果类似于 find(), 只不过是找 子串在字符串中 最后1次出现的位置, 找不到就返回 -1.
字符串变量名.rindex(子串, 起始索引, 结束索引)
类似于 rfind(), 找不到就 报错.
例如:
字符串: hello and python and java and sql and scala
索引: 0 6 17 26 34
"""
# 1. 定义字符串.
s1 = "hello and python and java and sql and scala"
# 2. 演示上述的函数.
print(s1.find('and')) # 6, 因为字符串由多个字符组成, 默认会返回 字符串第1个字符的 索引.
print(s1.find('and', 7, 30)) # 17
print(s1.find('and', 7, 19)) # -1, 包左不包右, 取不到索引19
print('-' * 28)
print(s1.index('and')) # 6, 因为字符串由多个字符组成, 默认会返回 字符串第1个字符的 索引.
print(s1.index('and', 7, 30)) # 17
# print(s1.index('and', 7, 19)) # 报错
print('-' * 28)
# 演示 rfind() 和 rindex(), 效果都一样, 区别就是 找不到的时候报不报错.
print(s1.rfind('and')) # 34
print(s1.rfind('and', 10, 30)) # 26
print(s1.rfind('and', 10, 19)) # -1
print('-' * 28)
print(s1.rindex('and')) # 34
print(s1.rindex('and', 10, 30)) # 26
# print(s1.rindex('and', 10, 19)) # 找不到, 就报错
13.字符串函数-replace-split
"""
字符串常用函数介绍:
概述:
你可以简单的把函数先理解为就是 别人写好的"工具", 我们直接调用就可以了, 传入 参数(原材料), 经过函数加工, 可以获取指定的 结果(返回值).
常用函数:
字符串变量名.replace(旧子串, 新子串, 替换次数) 用新串 来 替换 旧串, 可以设置替换几个(不写, 默认就替换所有) 返回新串.
字符串变量名.split(切割符, 切割个数) 按照切割符切割字符串, 切割个数表示切几个. 返回: 列表.
"""
# 1. 定义字符串变量s1, 记录要操作的数据.
s1 = 'hello and python and sql and linux'
# 2. 演示 replace()函数.
s2 = s1.replace('and', 'or') # 不写个数, 替换所有
s3 = s1.replace('and', 'or', 2) # 写了个数, 写几个替换几个.
# 3. 打印结果:
print(f's1: {s1}') # s1是不可变类型, 内容不变.
print(f's2: {s2}')
print(f's3: {s3}')
print('-' * 28)
# 4. 演示 split()函数.
list1 = s1.split('and')
print(type(list1)) # <class 'list'> 列表, 也是容器类型的一种.
print(list1) # ['hello ', ' python ', ' sql ', ' linux']
list2 = s1.split('and', 2)
print(type(list2)) # <class 'list'> 列表, 也是容器类型的一种.
print(list2) # ['hello ', ' python ', ' sql and linux']
print('-' * 28)
# 扩展: len()函数, 获取字符串的长度的, 即: 字符串有几个字符.
print(len(s1)) # 34
print('-' * 28)
# 分隔符.join(字符串) 用分隔符隔开 字符串中的每个字符.
s4 = 'hello'
s5 = ','.join(s4)
print(s5) # h,e,l,l,o
# 需求: 把 'hello' => ['h', 'e', 'l', 'l', 'o']
list3 = ','.join(s4).split(',')
print(list3) # ['h', 'e', 'l', 'l', 'o']
14.字符串案例
# 案例1: 输入1个字符串, 打印所有偶数位上的字符. 例如: 下标是 0, 2, 4, 6, 8, 10...
# # 1. 键盘录入1个字符串, 并接收.
# s1 = input('请录入您要操作的字符串: ') # 假设: abcde
#
# # 2. for循环方式, 获取到 字符串中所有 偶数索引.
# for i in range(0, len(s1), 2):
# # 3. 根据上述获取到的索引, 打印其对应的元素即可.
# print(s1[i])
#
# print("-" * 28)
# 案例2: 给定一个文件名，判断其尾部是否以".png"结尾
# 1. 定义变量, 记录: 文件名
file_name = 'abc.123.txt.png'
# 方式1: 切片思路实现, 即: 只切割出最后的4个字符, 比较是否是: .png
# 2. 获取文件名 最后的 4个字符.
end_name = file_name[-4:]
# 3. 判断, 并提示.
if end_name == '.png' and len(file_name) > 4:
print('文件名 是 以.png结尾的')
else:
print('文件名 不是 以.png结尾的')
# 方式2: 索引方式实现, 即: 通过rfind()找到 最后1个 .的索引, 然后做操作.
576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
