目录
循环
for循环
for 循环 也可以让指定的代码重复执行（循环）for 循环 可以遍历容器中的数据遍历：从容器中把数据⼀个⼀个取出容器：可以简单理解为盒子，盒子中可以存放很多的数据（ 字符串 str ， 列表 list ， 元组 tuple ， 字典 dict ）for 循环 也可以称为 for 遍历
-
基本的 for 循环语法
for 变量名 in 容器：
重复执行的代码
- for 和 in 都是关键字
- 容器中有多少个数据，循环会执行多少次（0 个数据，执行0 次，...）
- 每次循环，会将容器中数据取出⼀个保存到 in 关键字前边的变量中
-
for 做指定次数的循环
for 变量 in range ( n )：重复执⾏的代码
- range() 是 Python 中的函数，作用使用可以生成 [0, n) 之间的整数，不包含 n 的，⼀个有 n 个数字，所以这个循环循环 n 次
- 想让 for 循环循环多少次，n 就写几
- 变量的值 也是每次循环从 [0, n) 取出⼀个值，第⼀次取得是 0，最后⼀次取得是 n-1
-
range()变形
# 需求：使用 for 循环获取 5 到 10 之间的数字for 变量 in range ( a , b ):重复的代码# range(a, b) 作用是生成 [a, b) 之间的整数数字, 不包含 bfor i in range(5): # [0 1 2 3 4 ]
print ( i )print ( '-' * 30 )# 需求：使用 for 循环获取 5 到 10(包含) 之间的数字for m in range ( 5 , 11 ):print ( m )
break 和 continue
break 和 continue 是 Python 中的两个关键字 ， 只能在循环中使用
break
：
终止循环，即代码执行遇到 break，循环不再执行，立即结束
continue
：
跳过本次循环，即代码执行遇到 continue，本次循环剩下的代码不再执行，继续下⼀次循环
# 1. 获取你输⼊的字符串
result = input('请输⼊⼀个字符串:')
# 2. 遍历打印这个字符串
for i in result:
# 3. 在遍历的时候,如果这个字符是 e, 不打印(即后续的代码不执⾏)
if i == 'e':
continue # 本次循环后续的代码不执⾏,执⾏下⼀次循环
print(i)
print('-' * 30)
for i in result:
# 3. 在遍历的时候,如果这个字符是 e, 不打印(即后续的代码不执⾏)
# 如果这个字符不是 e, 打印
if i != 'e':
print(i)容器
字符串
字符串是容器 ， 因为字符串中可以包含多个字符
定义
定义： 使用引号（单引号，双引号，三引号）引起来的内容就是字符串
# 1. 使⽤单引号定义
my_str1 = 'hello'
print(my_str1, type(my_str1))
# 2, 使⽤双引号定义
my_str2 = "hello"
print(my_str2, type(my_str2))
# 3. 使⽤三引号定义
my_str3 = """hello"""
print(my_str3, type(my_str3))
my_str4 = '''hello'''
print(my_str4, type(my_str4))
# 4. 字符串本身包含引号 I'm ⼩明
# 4.1 字符串本身包含单引号, 则在定义的时候不能使⽤单引号
# 4.2 字符串本身包含双引号, 则在定义的时候不能使⽤双引号
my_str5 = "I'm ⼩明"
print(my_str5)
# 5. 字符串本身包含单引号,在定义的时候,我就是想使⽤单引号
# 5.1 使⽤ \ 转义字符,将字符串本身的引号进⾏转义 \' -->' \" --> "
my_str6 = 'I\'m ⼩明'
print(my_str6)
# 5.2 字符串 I\'m ⼩明 \\ --> \
my_str7 = 'I\\\'m ⼩明'
print(my_str7)
# 5.3 字字符串前边加上 r"" 原⽣字符串, 字符串中 的\不会作为转义字符, ⽂件操作会⽤⼀下
my_str8 = r'I\'m ⼩明'
print(my_str8)
my_str9 = r'I\\\'m ⼩明'
print(my_str9)下标
- 下标(索引): 就是指字符在字符串中的位置编号，这个编号就是下标
这个编号⼀般来说都是从左到右进行编号的，从 0 开始的
（Python 中支持负数下标，从右到左进行编号的，从-1 开始）
- 下标作用：可以使用下标获取字符串中某个位置的字符
- 语法: 字符串[下标] # 获取指定位置的字符
str1 = 'abcdefg'
# 1. 打印字符串中最开始位置的字符
print(str1[0]) # a
# 2. 打印最后⼀个位置的数据
print(str1[-1]) # g
# 3. 打印倒数第⼆个位置的字符
print(str1[-2]) # f
# 打印下标为 2 的数据
print(str1[2]) # c
# 获取字符串中字符的个数(获取字符串的⻓度)
# len(字符串) # length(⻓度)
num = len(str1)
print(num)
# ⻓度-1 的下标位置是最后⼀个字符
print(str1[num-1]) # g 最后⼀个字符,倒数第⼀个
print(str1[len(str1)-1]) # g 最后⼀个字符,倒数第⼀个切片
- 切片：可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）
- 语法：字符串[start:end:step]
- start 是开始位置的下标，end 是结束位置的下标（注意，不能取到这个位置的字符）step 步长，等差数列的差值，所取的相邻字符下标之间的差值，默认是 1，可以不写
- 例: [1:5:1] # 1 2 3 4
- [1:5:2] # 1 3
- [1:5:3] # 1 4
- [1:5:4] # 1
# 切⽚会得到⼀个字符串, 即可以获取字符串中的多个字符
str1 = 'abcdefg'
# 1. 获取 abc 字符
print(str1[0:3:1]) # abc
# 1.1 如果步⻓是 1 可以不写, 最后⼀个冒号也不写
print(str1[0:3]) # abc
# 1.2 如果开始位置为 0 ,可以不写, 但是冒号必须有
print(str1[:3]) # abc
# 2. 获取 efg 字符
print(str1[4:7]) # efg
print(str1[-3:7]) # efg
# 2.1 如果最后⼀个字符也要取, 可以不写, 但是冒号必须有
print(str1[4:]) # efg
# 2.2 如果开始和结束都不写, 获取全部内容, 但是冒号必须有
print(str1[:]) # abcdefg
# 3. 获取 aceg # 0 2 4 6, 所以步⻓为 2
print(str1[0:7:2]) # aceg
print(str1[::2]) # aceg
# 4. 特殊应⽤, 步⻓为负数, 开始和结束不写,意思全变, ⼀般不⽤管,只有⼀种使⽤场景
# 反转(逆置) 字符串 字符串[::-1]
print(str1[::-1]) # gfedcba字符串的查找方法 find
- 字符串 .find(sub_str, start, end)
- 作用：在字符串中查找是否存在 sub_str 这样的字符串
- sub_str：要查找的小的字符串
- start：开始位置，从哪个下标位置开始查找，⼀般不写，默认是 0
- end：结束位置，查找到哪个下标结束，⼀般不写，默认是len
- len()
- 返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）：
- 如果在字符串中找到了 sub_str ，返回 sub_str第⼀次出现的正数下标（sub_str 中第⼀个字符在⼤字符串中的下标）
- 如果没有找到，返回 -1
- 返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）：
str1 = "and itcast and itheima and Python"
# 在字符串中查找 and
num = str1.find('and')
print(num) # 0
# 在字符串中查找 第⼆个 and 出现的下标, 从第⼀次出现的后⼀位开始找
num1 = str1.find('and', num+1)
print(num1) # 11
# 在字符串中查找 第三个 and 出现的下标, 从第⼆次出现的后⼀位开始找
num2 = str1.find('and', num1+1)
print(num2) # 23
# 在字符串中查找 第四个 and 出现的下标, 从第三次出现的后⼀位开始找
num3 = str1.find('and', num2+1)
print(num3) # -1字符串的替换方法 replace
- 字符串 .replace(old_str, new_str, count) # 将字符串中
- old_str 替换为 new_str
- old_str：被替换的内容
- new_str：替换为的内容
- count：替换的次数，⼀般不写，默认是全部替换
- old_str 替换为 new_str
- 返回: 替换之后的完整的字符串，注意：原来的字符串没有发生改变
str1 = 'good good study'
# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1) # str1: good good study
print('str2:', str2) # str2: Good Good study
# 2. 将 str1 中第⼀个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3) # str3: GOOD good study
# 3. 将 str1 中第⼆个 good 改为 GOOD
# 3.1 先将全部的 good --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第⼀个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4) # str4: good GOOD study字符串的拆分 split
- 字符串 .split(sep, maxsplit) # 将字符串按照 sep 进行分割(拆分)
- sep：字符串按照什么进行拆分，默认是空白字符(空格，换行\n，tab键\t)
- max_split：分割次数，⼀般不写，全部分割
- 返回：将⼀个字符串拆分为多个，存到列表中
- 注意：如果 sep 不写，想要指定分割次数则需要按照如下方式使用
- 字符串 .split(maxsplit=n) # n 是次数
str1 = "hello world and itcast and itheima and Python"
# 1. 将 str1 按照 and 字符进⾏拆分
result1 = str1.split('and')
print(result1) # ['hello world ', ' itcast ', 'itheima ', ' Python']
# 2, 将 str1 按照 and 字符进⾏拆分, 拆分⼀次
result2 = str1.split('and', 1)
print(result2) # ['hello world ', ' itcast and itheima and Python']
# 3. 按照空⽩字符进⾏切割
result3 = str1.split()
print(result3) # ['hello', 'world', 'and','itcast', 'and', 'itheima', 'and', 'Python']
# 4. 按照空⽩字符进⾏切割, 拆分⼀次
result4 = str1.split(maxsplit=1)
print(result4)
字符串的链接 join
- 字符串 .join(列表) # 括号中的内容主要是列表，可以是其他容器
- # 作⽤：将字符串插入到列表中每相邻的两个数据之间，组成⼀个新的字符串
- 列表中的数据使⽤使用逗号隔开的
- 注意点：列表中的数据必须都是字符串，否则会报错
list1 = ['good', 'good', 'study']
# 1. 将 列表中的字符串使⽤空格连起来
str1 = ' '.join(list1)
print(str1) # good good study
# 2. 将 列表中的字符串使⽤ and 连起来
str2 = ' and '.join(list1)
print(str2) # good and good and study列表
列表 list ， 是使⽤最多的⼀种容器 ( 数据类型 )列表中可以存储多个数据，每个数据之间使⽤逗号隔开列表中可以存放任意类型的数据
列表支持下标和切片，长度
列表支持下标和切片操作，使⽤方法和字符串中的使用方法⼀致区别 ： 列表的切片得到的是列表
list1 = ['⼩明', 18, 1.71, True]
# 获取第⼀个数据,名字
print(list1[0])
# 获取最后⼀个数据
print(list1[-1])
# 第⼀第⼆个数据
print(list1[0:2]) # ['⼩明', 18]
# 列表⻚⽀持 len() 求⻓度的, 求数据元素个数
print(len(list1)) # 4查找 - 查找列表中数据下标的方法
- 在字符串中使用的 find 方法查找下标的，不存在返回的是 -1
- 在列表中没有 find 方法，想要查找数据的下标，使用的 index() 方法
- 列表 .index(数据, start, end) 使用和 find 方法⼀样，同时在字符串中也有 index 方法
- 区别：返回，index() 方法，找到返回第⼀次出现的下标，没有找到代码直接报错
查找 - 判断是否存在
- 判断容器中某个数据是否存在可以使⽤ in 关键字
- 数据 in 容器 # 如果存在返回 True，如果不存在，返回 False
查找 - 统计出现的次数
- 统计出现的次数，使⽤的是 count() ⽅法
- 列表 .count(数据) # 返回 数据出现的次数
my_list = [1, 3, 5, 7, 2, 3]
# 找 数据 3 出现的下标
num = my_list.index(3)
print(num) # 1
# 找 数据 4 出现的下标
# num1 = my_list.index(4) # 代码会报错
if 4 in my_list:
num1 = my_list.index(4)
print(num1)
else:
print('不存在数据 4')
# my_list.count(4) 统计 数据 4 出现的次数
if my_list.count(4) > 0:
num1 = my_list.index(4)
print(num1)
else:
print('不存在数据 4')添加数据的方法
- 尾部添加（最常用）
列表.append(数据) # 将数据添加到列表的尾部返回：返回的 None(关键字,空)，⼀般就不再使用 变量 来 保存返回的内容想要查看添加后的列表，需要打印的是列表
- 指定下标位置添加
列表.insert(下标, 数据) # 在指定的下标位置添加数据，如果指定的下标位置本来有数据，原数据会后移返回：返回的 None(关键字,空)，⼀般就不再使用 变量 来 保存返回的内容想要查看添加后的列表，需要打印的是列表
- 列表合并
列表1.extend(列表2) # 将列表 2 中的所有数据逐个添加的列表1 的尾部返回：返回的 None(关键字,空)，⼀般就不再使用 变量 来 保存返回的内容想要查看添加后的列表，需要打印的是列表
my_list = []
print(my_list) # []
# 1. 想列表中添加数据 郭德纲
my_list.append('郭德纲')
print(my_list) # ['郭德纲']
# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list) # ['郭德纲', '郭麒麟']
# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list) # ['郭德纲', '岳岳', '郭麒麟']
# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟']
# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟','孙越', '烧饼']
# 将 list1 作为⼀个整体添加到 my_list
my_list.append(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟','孙越', '烧饼', ['孙越', '烧饼']]
2402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
