python~容器

1.字符串str

1.1 定义

字符串就是用引号（单引号，双引号，三引号）引起来的内容

# 单引号
str1 = 'hello'
# 双引号定义
str2 = "hello"
# 三引号 定义
str3 = """hello"""
str4 = '''hello'''

如果字符串本身包含单引号,定义的时候不能使用 单引号
如果字符串本身包含双引号,定义的时候不能使用 双引号
如果字符串里面有单引号或者双引号，就用转义符“\”

使用转义字符“ \ ”：
如果字符串里面含有 \ ,那就前面加\
如果字符串前面加r,字符串中的\就不代表转义，就是一个简单的字符串

str5 = 'I\'m tao' 
print(str5) # I'm tao
str6 = 'I\\\'m tao'
print(str6) # I\'m tao
str7 = r'I\'m tao'
print(str7) # I\'m tao

1.2 下标（索引）

1. 下标（索引），是数据在容器（字符串，列表，元祖 ）中的位置/编号（字典中没有下标）
2. 一般使用正数下标，从0开始
3. 通过下标可以获取具体位置，语法：容器[下标]
4. 支持负数下标，-1表示最后一个位置的数据

str1 = 'abcdefg'
# 输出字符串中的 a 
print(str1[0])
print(str1[-7])
# 输出字符串中最后一个字符(-1)
print(str1[-1])
# 输出下标为3的位置的字符
print(str1[3])

1.3 切片操作

1. 使用切片操作, 可以一次性获取容器中的多个数据
2. 语法 容器[start : end : step]
   start 表示开始位置的下标
   end 表示结束位置的下标，end 所对应的下标位置的数据取不到
   step 步长，表示的意思就是相邻两个坐标的差值

str1 = "abcdefg"

#打印字符串中的abc字符
print(str1[0:3:1])
#差值step如果为1，或者start位置为0，或者取到最后一个字符end,都可以省略不写，但是冒号不能不写
print(str1[:3:])
print(str1[:3:2])
print(str1[::3])

#练习：打印cf
print(str1[2:6:3])

#特殊：步长为-1，逆序字符串
print(str1[::-1])

1.4 字符串几种常用方法

1. 查找方法find():

语法：字符串.find(str)

如果找到了，返回第一次出现的下标，如果没找到，则返回-1

str1 = '春夏秋冬'
#str2 = '秋'
str2 = "天"
result = str1.find(str2)
if result == -1:
    print(f"{str2}不存在")
    #f就是format,表示格式化字符串，可以在字符串中直接嵌入变量或表达式，要用{}括起来
    #还可以这样写：
    print("{}不存在".format(str2))
    print("%s不存在"%str2)
else:
    print(f"{str2}存在,下标位置为:",result)

2. 字符串的替换replace():

语法：字符串.replace(old, new, count)

old:被替换的字符串
new:替换后的字符串
count:替换的次数，不写就是全部替换，替换后原字符串不变
返回: 会返回一个替换后的完整的字符串

str1 = 'good good good'
#将good换成GOOD
str2 = str1.replace('good','GOOD')
print("原来的：",str1)
print("替换后：",str2)

#只替换第一个good
str3 = str1.replace("good","GOOD",1)
print("只替换一个good：",str3)

#第一个good不替换
str4 = str1.replace("good","GOOD").replace('GOOD','good',1)
print("只替换一个good：",str4)

3. 字符串拆分 split():

语法：字符串.split(sep)

将字符串按照指定的字符串sep分隔
拆分后返回列表，列表中每个数据就是分隔后的字符串
按照sep分隔，不写的话默认按照空白字符分隔

str1 = 'hello word python\tand java and\ngo'

#按空白字符分隔
list1 = str1.split()
print(list1) # ['hello', 'word', 'python', 'and', 'java', 'and', 'go']

#按空格分隔
list2 = str1.split(" ")
print(list2) # ['hello', 'word', 'python\tand', 'java', 'and\ngo']

#按照and分隔
list3 = str1.split("and")
print(list3) # ['hello word python\t', ' java ', '\ngo']

4. 字符串的连接 join()

语法：字符串.join(容器)

容器一般是列表
列表中的数据必须是字符串才行
用字符串将列表中各数据连接起来

list1 = ['hello', 'word', 'python', 'and', 'java', 'and', 'go']
#将列表中的数据用空格连接成新的字符串
str1 = " ".join(list1)
print(str1) # hello word python and java and go

2.列表list

2.1 定义

list:使用 [ ]，可以存放任意类型的多个数据，数据之间用逗号隔开
定义有两种方法，类的实例化或者直接用 [ ]

#方式1：类的实例化

#1、定义空列表：变量 = list()
list1 = list()
print(type(list1),list) # <class 'list'> <class 'list'>

#2、定义非空列表（类型转换）：list(可迭代类型），可迭代类型：能够使用for循环，例如容器
#将容器中的每个数据都作为列表中一个数据进行保存
list2 = list('abcd')
print(list2)  #['a', 'b', 'c', 'd']

# 方式2：直接用[]
list3 = []
print(list3) # []
list4 = [1,2,'python',True]
print(list4)

2.2 列表支持下标和切片

# 获取列表中的数据（索引）
print(list4[0])#获取列表中第一个数据
print(list4[-1])#获取列表中最后一个数据
print(list4[1:3])#获取中间两个数据
# 列表的切片还是列表，如果下标不存在会报错

2.3 列表的几种常用方法

1.列表查询：

index() 这个方法的作用和字符串中的 find() 的作用是一样
列表中是没有 find() 方法的, 只有 index() 方法
字符串中 同时存在 find() 和 index() 方法

使用 index()
1, 找到 返回下标
2, 没有找到, 直接报错

使用 count() 方法 统计次数

list1 = ['hi',1,2,3,2,4]
print(list1.index(2)) # 2
# print(list1.index(20))

#统计2出现的次数
print(list1.count(2)) # 2
print(list1.count(20))#找不到不报错，返回0

2.添加数据 append():

语法：列表.append(数据）

数据添加到列表末尾，返回值为None，
所以添加数据后不会生成新的列表，是直接修改原列表的

list1 = []
print(list1)
list1.append("张三")
list1.append("李四")
print(list1) # ['张三', '李四']
list1.append("王五")
print(list1) # ['张三', '李四', '王五']

3.删除数据pop()

语法：列表.pop(index)

是根据下标删除数据，不写下标时默认删除最后一个数据
返回值为删除的数据

list1 = ['张三', '李四', '王五']
list1.pop()
print(list1) # ['张三', '李四']
name = list1.pop(1)
print(name) # 李四

4.列表修改数据：

语法：列表 [ 下标 ] = 新数据

直接索引下标修改就行,直接修改原列表

list1 = [1,3,3,4,5]
list1[1] = 2
print(list1) # [1,2,3,4,5]
list1[-1] = 20
print(list1) # [1,2,3,4,20]

5.列表的翻转：

列表反转两种方法：

1. 列表[::-1] 得到一个新的列表, 原列表不会改动
2. 列表.reverse() 直接修改原列表的数据

#方法一：切片操作
list2 = list1[::-1]
print('原列表:',list1)
print('修改后的列表：',list2)

#方法二：reverse()
list1.reverse()
print(list1)

6.列表的排序：

前提: 列表中的数据要一样
列表.sort() # 升序, 从小到大, 直接在原列表中进行排序
列表.sort(reverse=True) # 降序, 从大到下, 直接在原列表中进行排序

list1 = [6,3,5,8,3,5,2,1]
#升序
list1.sort()
print(list1)
#降序
list1.sort(reverse=True)
print(list1)

7.列表的嵌套：
列表的嵌套 就是指 列表中数据都是列表.

score_list = [["语文",90,"优秀"],["数学",70,"良好"],["英语",65,"及格"]]
#语文
print(score_list[0][0]) # 语文
print(score_list[0][1]) # 90

#添加数据
score_list[0].append("小小")
print(score_list) # [['语文', 90, '优秀', '小小'], ['数学', 70, '良好'], ['英语', 65, '及格']]
#删除
score_list[0].pop()
print(score_list)[['语文', 90, '优秀'], ['数学', 70, '良好'], ['英语', 65, '及格']]

#打印有哪些科目
for subject in score_list:#遍历score_list列表中嵌套的所有列表赋给subject
    print(subject[0])

3.元组tuple

3.1 定义

1. 元组 tuple, 使用的 ()
2. 元组和列表非常相似, 都可以存储多个数据, 都可以存储任意类型的数据
3. 区别就是元组中的数据不能修改,列表中可以修改
4. 因为元组中的数据不能修改,所以只能查询方法, 如 index, count ,支持下标和切片
5. 元组,主要用于传参和返回值

两种定义方式：

#1、类实例化方式
#定义空元组
tuple1 =tuple()
print(type(tuple1),tuple1) # <class 'tuple'> ()
# 类型转换：将列表（可迭代类型）转换成元组
tuple2 = tuple([1,2,3,4])
print(tuple2) # (1, 2, 3, 4)

#2、直接用（）定义
#定义空元组
tuple3 = ()
# 非空元组
tuple4 = (1,'python',3,True)
print(tuple4) # (1, 'python', 3, True)
print(tuple4[1])  #查询元组中第二个数据

tuple5 = ("python",)  #要是想在元组中只放一个数据，那这个数据后面必须有一个逗号
print(tuple5) # ('python',)

3.2 元组的应用

使用元组交换两个数据很方便，定义元组时小括号可以省略
用到两个知识点：组包（pack)和拆包（unpack)

a = 10
b = 20
#c = b,a  #组包
#print(c)
#b,a = c  #拆包
#print(a,b)  #此时数据已经被交换了
#上面的是推导过程
a,b =b,a  #交换数据
print(a,b)
#练习
x,y,z = 'abc'
print(x,y,z)
print(z)

4.字典dict()

4.1 定义

字典dict，用 { } ，由键值对组成：key : value
一个键值对是一组数据，多个键值对之间使用逗号隔开
键不能重复，主要是字符串类型，数字也可以，字典中没有下标

#字典的定义：
#1、类的实例化
dict1 = dict()
print(type(dict1),dict1) # <class 'dict'> {}

#2、用{}定义
#空字典
dict2 = {}
print(dict2)

#非空字典
dict3 = {"name":"小小","age":21,"height":1.78}
print(dict3) # {'name': '小小', 'age': 21, 'height': 1.78}

4.2 字典的几种常用方法

查询，增加，修改，删除：

#字典中没有下标，但是有键
dict3 = {"name":"小小","age":21,"height":1.78}
print(dict3) # {'name': '小小', 'age': 21, 'height': 1.78}

#增加和修改，看键存不存在，存在就修改，不存在就添加
dict3["age"] = 22   #修改
print(dict3) # {'name': '小小', 'age': 22, 'height': 1.78}
dict3["weight"] = 75   #添加
print(dict3) # {'name': '小小', 'age': 22, 'height': 1.78, 'weight': 75}

#删除（pop）：根据键删除键值对
dict3.pop("weight")
print(dict3) # {'name': '小小', 'age': 22, 'height': 1.78}

#查询（get）：根据字典的键，获取对应的值
#方法一：缺点是找不到键会报错
print(dict3["name"]) # 小小
# print(dict3["sex"])

#方法二：如果没有对应的键会返回None
print(dict3.get("name")) # 小小

4.3 字典的遍历

1. 遍历字典的键
2. 遍历字典的值
3. 遍历字典的键和值

dict3 = {"name":"小小","age":21,"height":1.78}
print(dict3)
#遍历：
#遍历字典的键：
for k in dict3:
    print(k)

print('*'*30)
for k in dict3.keys():
    print(k)

print('*'*30)
#遍历字典的值：（使用较多）
for v in dict3.values():
    print(v)

print('*'*30)
#遍历字典的键和值
for k,v in dict3.items():
    print(k,v)

5.集合set

集合 set, {数据, 数据, …}

1, 集合中的数据是不能重复的, 即没有重复数据
2, 应⽤, 对列表进⾏去重操作就是类型转换 , 可以将列表转换为集合, 然后再将集合转换为列表

#去重方法一：用集合进行类型转换
list1 = [1,2,1,3]
set1 = set(list1)
print(set1) # {1, 2, 3}
list1 =list(set1)
print(list1) # [1, 2, 3]
# list1 = list(set(list1))  #更简单
# print(list1)

#去重方法二：遍历
# list3 = []
# for v in list1:
#     if v in list3:
#         pass
#     else:
#         list3.append(v)
# print(list3)

#优化：
list3 = []
for v in list1:
    if v not in list3:
        list3.append(v)
print(list3) # [1, 2, 3]