一、字符串
定义：用来存储多个字符的, 也算是一种容器类型，不可被修改
(一)容器
容器概述
所谓的容器指的是就是能同时存储多个元素的容器, 且大多数容器都支持CURD(增删改查)的操作.
分类
- 字符串:
- 列表:
- 元组:
- 字典:
(二)字符串
字符串概述
它是用来存储多个字符的, 也算是一种容器类型, 在实际开发中非常常用
格式
方式1: 一对引号(单双引号均可).
name = '刘亦菲'
name = "刘亦菲"
方式2: 引号嵌套, 例如: 你搞一个字符串, 帮我存储 I'm Tom
s1 = "I'm Tom"
s2 = 'I\'m Tom'
方式3: 三对引号(单双引号均可), 可以保留格式.
例如: 你搞一个字符串, 帮我存储
I 老虎
You!
例如
# 方式1: 一对引号(单双引号均可).
name1 = '海鸥'
name2 = "薯条"
print(name1, name2)
print('-' * 13)
# 方式2: 引号嵌套, 例如: 你搞一个字符串, 帮我存储 I'm Tom
# s1 = 'I'm 海鸥' # 报错.
s1 = "I'm 海鸥"
s2 = 'I\'m 海鸥' # 转义符, 即: \开头的, 例如: \t, \n, \r, \', \"
print(s1, s2)
print('-' * 13)
# 方式3: 三对引号(单双引号均可), 可以保留格式.
s3 = """
I 老虎
You!
"""
print(s3)
(三)下标
概述
所谓的下标指的是字符串的元素的索引(也叫脚标, 编号, 下标, index), 索引从0开始.
格式
字符串变量[索引] 根据索引获取其对应的字符
例如
# 演示字符串的下标
name = 'hello cheems'
print(name[1]) # e
print(name[6]) # c
print(name[10]) # m
(四)切片
概述
所谓的字符串切片, 就是从字符串中截取一部分出来.
格式
字符串变量[起始索引:结束索引:步长] 起始和结束索引表示范围(包左不包右), 步长表示间隔.
例如
# 演示字符串的切片
'''
字符串内容: a b c d e f g
正索引: 0 1 2 3 4 5 6
负索引: -7 -6 -5 -4 -3 -2 -1
'''
s1 = 'abcdefg'
# 正索引演示.
print(s1[2:5]) # cde
print(s1[1:5:2]) # bd
print(s1[:3]) # abc, 没有写起始索引, 默认从0开始.
print(s1[4:]) # efg, 没有写结束索引, 默认到字符串最后.
print('-' * 13)
# 负索引演示
print(s1[-6:-2]) # bcde
print(s1[-6:-2:2]) # bd
print(s1[-6:-2:-2]) # 不报错, 但是没有数据, 因为获取元素(正向)的方向, 和步长的方向(逆向)不一致.
print(s1[-2:-7]) # 不报错, 但是没有数据, 如果不写步长, 默认步长是 1
print(s1[-2:-7:-1]) # fedcb
print('-' * 13)
# 最后两个, 必须记忆, 上述的内容, 最好记忆.
print(s1[:]) # abcdefg
print(s1[::-1]) # gfedcba, 相当于字符串内容反转, 这个是面试题.
(五)字符串查找之find()函数
格式
字符串相关函数之 find()
find(子串, 起始索引, 结束索引) 查找子串在指定字符串中第一次出现的位置, 并返回该索引, 找不到就返回-1
rfind(子串, 起始索引, 结束索引) 查找子串在指定字符串中最后一次出现的位置, 并返回该索引, 找不到就返回-1
细节
-
例如去: ‘hello and hello’ 里边找 ‘hello’ 第一次出现的位置, 则返回的是 'h’字符的索引, 即: 0
-
find()是找第一次出现的位置, rfind()是找最后一次出现的位置.
例如
# 需求: 演示find()的用法.
s1 = 'hello and python and java and scala and sql'
# 6 10 17 26 36
print(s1.find('and')) # 6, 如果没写, 默认从0索引开始查找, 直至字符串末尾.
print(s1.find('and', 9)) # 17, 9表示从索引为9的地方开始查找, 直至字符串末尾.
print(s1.find('and', 10, 17)) # -1, 从索引10开始, 到索引17结束, 包左不包右.
print(s1.find('and', 17, 19)) # -1, 从索引17开始, 到索引19结束, 包左不包右.
print(s1.find('and', 17, 20)) # 17, 从索引17开始, 到索引20结束, 包左不包右.
print('-' * 13)
print(len(s1)) # 获取s1的长度, 43
print(s1.rfind('and')) # 36
print(s1.rfind('and', 17, 30)) # 26
print(s1.rfind('and', 27, 35)) # -1
(六)字符串查找之index()函数
格式
字符串相关函数之 index()
index(子串, 起始索引, 结束索引) 查找子串在指定字符串中第一次出现的位置, 并返回该索引, 找不到就 报错.
rindex(子串, 起始索引, 结束索引) 查找子串在指定字符串中最后一次出现的位置, 并返回该索引, 找不到就 报错.
细节
find(), index(), rfind(), rindex()的功能都是相似的, 都是返回子串的索引.
区别在于, 如果找不到元素, find(), rfind()是返回-1, 而index()和rindex()是报错.
例如
# 需求: 演示index()的用法.
s1 = 'hello and python and java and scala and sql'
# 6 10 17 26 36
print(s1.index('and')) # 6, 如果没写, 默认从0索引开始查找, 直至字符串末尾.
print(s1.index('and', 9)) # 17, 9表示从索引为9的地方开始查找, 直至字符串末尾.
print(s1.index('and', 10, 17)) # -1, 从索引10开始, 到索引17结束, 包左不包右.
# print(s1.index('and', 17, 19)) # -1, 从索引17开始, 到索引19结束, 包左不包右.
print(s1.index('and', 17, 20)) # 17, 从索引17开始, 到索引20结束, 包左不包右.
print('-' * 13)
print(len(s1)) # 获取s1的长度, 43
print(s1.rindex('and')) # 36
print(s1.rindex('and', 17, 30)) # 26
# print(s1.rfind('and', 27, 35)) # -1
(七)字符串替换之replace()函数
格式
replace(旧串, 新串, 个数) 用新串替换旧串, 个数表示替换几个.
细节
-
容器类型按照内容是否可以修改, 主要分为: 可变类型 和 不可变类型.
-
字符串属于不可变类型, 所以上述的 replace()替换之后, 是返回一个新串, 并不是在原始字符串上修改.
例如
# 需求: 演示 replace()
s1 = "hello and python and java and scala and sql"
# 具体的替换的操作.
s2 = s1.replace('and', 'or') # 没写个数, 表示替换所有.
print(s2) # hello or python or java or scala or sql
s3 = s1.replace('and', '&', 2) # 2的意思是, 表示替换2个.
print(s3) # hello & python & java and scala and sql
# "hello and python and java and scala and sql"
print(s1) # 字符串属于不可变类型, 所以内容不会变化.
print('-' * 13)
# 需求: 找小串在大串中出现了多少次.
maxStr = "woaiheima, buguanheimahaishibaima, zhaodaogongzuojiushihaoma"
minStr = 'heima'
# 思路(公式): (大串的长度 - 新串的长度) / 小串的长度
# 新串 = 在大串中, 把所有的小串全部替换为空, 获取到的 字符串.
newStr = maxStr.replace(minStr, '') # 'woai, buguanhaishibaima, zhaodaogongzuojiushihaoma'
num = (len(maxStr) - len(newStr)) // len(minStr) # 2
print(f'小串在大串中出现了 {num} 次')
(八)字符串切割之split()函数
格式
split(子串, num) 根据子串, 切割原始字符串, num表示切几个, 最终结果是: num + 1个
例如
# 演示split()
s1 = 'hello and python and java and scala and sql'
s2 = s1.split('and')
print(s2)
print(type(s2)) # <class 'list'>
print('-' * 13)
# 遍历切割后的结果(列表)
for i in s2:
print(i)
# print(i.replace(' ', '')) # 切割后有空格, 我们把空格替换为空.
# 还是s1自身, 因为它是不可变类型.
# print(s1)
print('-' * 13)
# 切割指定个数
print(s1.split('and', 2)) # ['hello ', ' python ', ' java and scala and sql']
# 扩展, 字符串的join函数.
s2 = 'hello'
s3 = ','.join(s2)
print(s3) # h,e,l,l,o
# 需求: 把字符串转成列表, 字符串中每个元素都是列表的元素.
s4 = ','.join(s2).split(',')
print(s4)
print(type(s4))
(九)字符串常用函数
# 全小写
words = words.lower()
# 单词开头大写
words = words.title()
# 左边空格删掉
words = words.lstrip()
# 右边空格删掉
words = words.rstrip()
# 前后空格都删掉
words = words.strip()
二、列表
定义：所谓的列表也是一种容器类型, 可以存储多个元素, 可以是不同类型的元素, 也可以是同类型的元素,可以被修改.
(一)创建
格式
方式1: [值1, 值2, 值3...]
方式2: list(), 这种方式是在创建一个空列表.
细节
- 建议使用列表存储 同类型的多个元素.
- 和字符串一样, 列表中的元素也是有索引的, 也分为正向索引和逆向索引.
例如
# 1. 演示列表的定义.
list1 = [10, 20, 30, 'abc', True, 10.3]
list2 = list() # 看看就行了, 不推荐.
# 打印内容
print(list1, list2)
# 打印类型
print(type(list1), type(list2))
# 2. 演示列表的元素索引
print(list1[2]) # 30, 正向索引
print(list1[-4]) # 30, 逆向索引
(二)遍历
概述
所谓的列表遍历指的就是逐个获取列表中的元素, 并输出.
格式
方式1: for循环
方式2: while循环
例如
# 1. 定义列表, 记录元素.
list1 = [10, 20, 30, 'abc', 10.3, 50]
# 2. 遍历列表.
# 方式1: 最Low版.
print(list1[0])
print(list1[1])
print(list1[2])
print(list1[3])
print(list1[4])
print(list1[5])
print('-' * 13)
# 方式2: for循环
for i in list1:
print(i)
print('-' * 13)
# 方式3; while循环
i = 0
while i < len(list1):
print(list1[i])
i += 1 # 控制条件, 不写容易死循环
(三)列表的CURD之增
格式
append(要添加的元素) 将元素添加到列表的末尾, 一次只能添加1个元素.
extend(容器类型) 将元素添加到列表的末尾, 一次可以添加多个元素.
insert(索引, 元素) 在列表的指定位置(索引), 插入元素.
例如
# 1. 定义列表
list1 = [10, 20, 30]
# 2. 演示 append() 函数
# list1.append('abc')
# list1.append(True)
# list1.append(10.3)
# 3. 演示 extend() 函数
# list1.extend('abc') # 这里传入的类型是可迭代(可遍历)的类型.
# list1.extend(['a', 'b', 10.3, False])
# 4. 演示 insert() 函数
# list1.insert(1, 'abc') # [10, 'abc', 20, 30]
# list1.insert(10, 'abc') # 这个索引, 最大, 最小我们写谁都行.
#list1.insert(-30, 'abc') # 这个索引, 最大, 最小我们写谁都行.
# list1.insert(2, 'abc') # [10, 20, 'abc', 30]
list1.insert(-2, 'abc') # [10, 'abc', 20, 30]
# 5. 打印列表
print(list1)
(四)列表的CURD之查
格式
index(元素, 开始索引, 结束索引) 查找元素在列表中的位置, 不存在就: 报错.
count(元素) 统计元素在列表中的总次数.
元素 in 列表 判断列表中是否包含该元素, 包含:True, 不包含: False
元素 not in 列表 判断列表中是否不包含该元素, 不包含:True, 包含: False
例如
# 1. 定义列表
list1 = [10, 20, 30, 'abc', 30, False, 10.3, 30]
# 2. 演示index函数
print(list1.index(30)) # 2
# print(list1.index(50)) # 报错
# 3. 演示count(元素)
print(list1.count(30)) # 3
# 4. 演示 in 的用法.
print(30 in list1) # True
print(50 in list1) # False
# 5. 演示 not in 的用法, 有点像 双重否定表肯定
print(30 not in list1) # False
print(50 not in list1) # True
print('-' * 13)
(五)列表的CURD之删
格式
remove(元素) 根据元素(内容), 从列表中删除指定的元素, 只删除第一个匹配到的, 不存在就报错.
pop(索引) 根据索引, 从列表中删除指定的元素, 不存在就报错.
del 如果跟的是索引, 就删除该元素, 如果跟的是列表, 就删除该列表(内存中没有了)
clear 清空列表中所有的元素, 但是列表还在.
例如
# 1. 定义列表, 记录元素.
list1 = [1, 2, 3, 4, 5, 2]
# 2. 测试 remove() 函数
# list1.remove(20) # 报错
# list1.remove(2) # 删除元素2
# 3. 测试 pop() 函数
# list1.pop(3) # 删除索引为3的元素
# list1.pop(30) # 报错
# 4. 测试 del() 函数
# del list1[3]
# del list1[-3]
# del list1 # 不仅删除元素, 还把list1从内存中删除
# 5. 测试 clear() 函数
list1.clear()
# 6. 打印集合
print(list1)
(六)列表的CURD之改
格式
列表[索引] = 修改后的值 根据索引, 修改列表中对应元素的值, 索引不存在, 就 报错
sort() 排序的意思, 里边可以写参数, reverse=False(默认的, 升序), reverse=True(降序)
reverse() 反转元素.
例如
# 1. 定义列表, 记录元素.
list1 = [1, 2, 11, 5, 3]
# 2. 测试修改列表的元素值.
# list1[2] = 'abc'
# list1[20] = 'abc' # 报错
# 3. 测试对列表元素 反转.
# list1.reverse() # [3, 5, 11, 2, 1]
# 4. 测试对列表元素 排序.
# list1.sort() # 默认, 升序
# list1.sort(reverse=False) # 同上
list1.sort(reverse=True) # 降序, 即: 先升序排列, 然后反转.
# 降序排列分解动作.
# list1.sort() # 升序
# list1.reverse() # 反转
# 5. 打印列表
print(list1)
(七)列表嵌套
概述
所谓的列表嵌套指的就是 列表的每一个元素, 还是一个列表.
格式
list1 = [10, 20, 30] # 这个不是列表的嵌套
list1 = [[10, 20, 30], ['aa', 'bb', 'cc']]
例如
# 需求1: 演示列表的嵌套.
list1 = [[10, 20, 30], ['aa', 'bb', 'cc']]
# 获取30, 然后打印.
# print(list1[0][2])
# 获取'bb', 然后打印
# print(list1[1][1])
# 需求2: 列表嵌套情况下的遍历.
# for i in list1:
# # i 就是list1列表中的每个元素, 例如: [10, 20, 30], 因为是列表, 所以我们接着遍历.
# for j in i:
# print(j, end='\t')
# print() # 每打印1个列表, 我们就换行
三、元组
定义：它属于容器类型, 是不可变类型(即, 元素内容不能修改, 注意: 元素是列表的情况除外), 和列表类似, 它也是用来存储多个元素的
创建格式
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
# 空元组
t3 = tuple()
与列表区别
-
定义格式不同, 元组用(), 列表用[]
-
关于是否可以修改元素内容, 元组不可以, 列表可以.
例如
# 需求1: 元组的定义格式.
t1 = tuple()
t2 = (10, 20, 'abc', True)
t3 = (10,)
print(type(t1), type(t2), type(t3))
print('-' * 13)
# 需求2: 演示元组的内容不能修改.
t1 = (10, 20, 30)
print(t1[1]) # 20, 获取元素值.
# t1[1] = 200 # 报错
# 特殊情况, 元组的元素是列表, 列表内容可以修改.
t1 = (10, 20, ['a', 'b', 'c'])
t1[2][1] = 'bb' # 可以修改列表值.
# t1[2] = [11, 22] # 报错
print(t1)
print('-' * 13)
四、字典
定义：字典指的是dict, 它主要存储双列数据(键值对, 左边叫键, 右边叫值), 可以存储多个元素.
所以它也是容器类型, 且是可变的容器类型.
(一)创建
格式
dict1 = {}
dict2 = dict()
dict3 = {'name': '鸭梨', 'age': 24, 'address': '薯条码头'}
细节
字典的键的类型, 必须是唯一的
例如
dict1 = {'name': '海鸥', 10: 'abc', True: 200, 10.3: '你好', (10, 20): [11, 22, 33]}
print(dict1)
print(type(dict1))
print(len(dict1)) # 统计的是键值对的对数
(二)字典的CURD之增
格式
字典名[键] = 值 # 如果键存在, 就是用新值覆盖旧值, 并返回旧值, 如果键不存在, 则是新增.
细节
列表: [10, 20, 30]
元组: (10, 20, 30)
集: {10, 20, 30}
字典: {‘a’:10, ‘b’:20, ‘c’:30}
字典是容器类型, 且是可变的容器.
例如
# 1. 定义字典.
dict1 = {'name': '鸭梨', 'age': 24}
# 2. 给字典添加元素, 键不存在.
dict1['address'] = '薯条码头'
# 3. 给字典添加元素, 键存在.
dict1['age'] = 124
# 4. 打印字典.
print(dict1)
(三)字典的CURD之删
格式
pop() 根据键, 删除其对应的键值对
del 可以删除键值对, 也可以删除整个字典(内存中没有了)
clear() 清空字典, 即内容都没有了, 但是字典还在.
例如
# 1. 定义字典.
dict1 = {'name': '鸭梨', 'age': 24}
# 2. 演示 pop() 根据键, 删除其对应的键值对, 键存在就删除, 且返回值.
print(dict1.pop('name')) # 鸭梨
# print(dict1.pop('address')) # 键不存在, 就报错
# 3. 演示 clear()
dict1.clear()
# 4. 打印结果.
print(dict1)
(四)字典的CURD之改
格式
字典名[键] = 值 # 键存在就是修改, 键不存在就是 新增(添加)
例如
# 1. 定义字典.
dict1 = {'name': '鸭梨', 'age': 24}
# 2. 修改元素.
dict1['age'] = 66
# 3. 打印结果.
print(dict1)
(五)字典的CURD之查
格式
字典名[键] 根据键获取其对应的值, 键不存在就报错.
字典名.get(键) 根据键获取其对应的值, 键不存在就返回None
keys() 获取到所有的键.
values() 获取到所有的值
items() 获取到所有的键值对.
例如
# 1. 定义字典.
dict1 = {'name': '鸭梨', 'age': 24, 'address': '北京', 'wifes': ['冬瓜', '南瓜', '西瓜'], '丝瓜': '苦瓜', '苹果': '；苦瓜'}
# 2. 演示 根据键获取其对应的值.
print(dict1['name'])
# print(dict1['names']) 报错
print(dict1.get('name'))
print(dict1.get('names')) # 不报错, 返回None
print('-' * 13)
# 3. 字典中没有根据值获取键的操作, 因为值可以是重复的.
print(dict1['丝瓜']) # 苦瓜, 根据键获取值
print(dict1['苹果']) # 苦瓜, 根据键获取值, 因为值可以重复, 所以根据值获取键没有意义, 或者说压根不支持.
print('-' * 13)
# 4. 获取所有的键.
print(dict1.keys())
print(type(dict1.keys())) # dict_keys
print('-' * 13)
# 5. 获取所有的值.
print(dict1.values())
print(type(dict1.values())) # dict_values
print('-' * 13)
# 6. 获取所有键值对的集合.
print(dict1.items())
print(type(dict1.items())) # dict_items
(六)遍历
入门版本
- 直接遍历字典, 相当于遍历所有的键.
- 遍历所有的键.
- 遍历所有的值.
进阶版本
- 根据键获取其对应的值, 也叫: 根据丈夫找妻子.
- 根据键值对获取其对应的键和值, 也叫: 根据结婚证找丈夫和妻子.
例如
# 1. 定义字典.
dict1 = {'name': '鸭梨', 'age': 24, 'address': '薯条码头'}
# 版本1: 直接遍历字典, 相当于遍历所有的键.
for i in dict1:
print(i) # i 就是每一个键.
print('-' * 13)
# 版本2: 遍历所有的键.
for i in dict1.keys():
print(i) # i 就是每一个键.
print('-' * 13)
# 版本3: 遍历所有的值.
for i in dict1.values():
print(i) # i 就是每一个值.
print('-' * 13)
# 进阶版.
# 方式1: 根据键获取其对应的值, 也叫: 根据丈夫找妻子.
for key in dict1.keys(): # 掌握
# print(f'{key} = {dict1.get(key)}')
print(f'{key} = {dict1[key]}')
print('-' * 13)
# 方式2: 根据键值对获取其对应的键和值, 也叫: 根据结婚证找丈夫和妻子.
for item in dict1.items():
# item的格式: ('name', '段誉') 这个是 元组
print(f'{item[0]} = {item[1]}')
print('-' * 13)
# 方式2的优化版.
# 每一个item的格式: ('name', '段誉') 这个是 元组
for k,v in dict1.items(): # 掌握
print(f'{k} = {v}')
五、集
定义：集指的就是集合, 它的元素特点是: 唯一(去重), 无序(元素的存取顺序不一致, 而不是排序)
创建格式
常用的场景:对列表元素去重.
流程:列表 -> 集, 自动去重 -> 再添加到列表中.
例如
# 需求1:集的格式
set1 = set()
set2 = {10, 20, 30, 10, 30, 20, 55, 33}
print(type(set1), type(set2))
print(set2) # 元素特点: 去重, 无序, {33, 10, 20, 55, 30}
print('-' * 13)
# 需求2: 对以下列表中的数据进行去重操作.
list1 = [10, 20, 30, 20, 10, 'aa', True, 20]
# 把列表中的数据添加到集中, 它会自动去重.
set1 = set(list1)
# 清空列表元素.
list1.clear()
# 然后把去重后的数据, 重新添加到列表中.
list1 = list(set1)
# 打印结果.
print(list1)
扫一扫
3896
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
