python笔记-数据序列(容器)

1、序列

• 在python中，有这样一些类型，他们的成员是有序排列的，并且可以通过下标访问成员，称之为序列
  -列表、range、元组和字符串都是序列

• 序列的通用操作
  

• 序列通用操作
  

- 索引(tuple[i])
- 切片(tuple[::])
- 元素个数计算(len(tuple))
- 求元素最大值(max(tuple))
- 求元素最小值（min(tuple)）
- 删除序列（del tuple）
**- 序列相加（+） **
- 序列相乘（*）

2、列表

• 作用 存储多个数据可以采用列表，专门用于存储一串信息
• List（列表）是python中使用最频繁的数据类型，在其他语言中通常叫做数组
• 列表用[]定义，数据之间使用,逗号分隔
• 列表的索引从0 开始
• 索引就是数据在列表中的位置编号，索引又可以被称为下标
• 注意：从列表中取值时，如果超出索引范围，程序会报错
• 基本语法
  列表名 = [元素1，元素2，元素3.....]
• 2.1列表的定义

点击查看代码

#1.类实例化的方法（不常用）
#1.1 定义空列表（没有任何数据）
#变量 = list()
list1 = list()
print(list1,type(list1))  #[] <class 'list'>

#1.2 类型转换 list(容器) 将其他容器转换为列表
#转换字符串会将字符串中的每个字符作为一个数据存入列表中
list2 = list('hello')
print(list2,type(list2)) #['h', 'e', 'l', 'l', 'o'] <class 'list'>

#2.直接使用[] 进行定义（常用）
#2.1 定义空列表
my_list = []
print(my_list)

#2.2 定义非空列表
my_list1 = [1,'小明',3.1415926,False]
print(my_list1,type(my_list1))  #[1, '小明', 3.1415926, False] <class 'list'>

• 列表的遍历-打印列表的每个元素

点击查看代码

list1 = list('123456789abcdeftghkflfjdlfj')
for i in list1:
    print(i,end='-')
print()

• 2.2 列表支持下标和切片
  -使用方法和字符串方法一致
  -区别：列表的切片得到的是列表，字符串的切片得到的是字符串

点击查看代码

list1 = ['小明',18,1.71,True]

#获取第一个数据，名字
print(list1[0]) #小明

#获取最后一个数据
print(list1[-1]) #True

#获取第一和第二个数据
print(list1[0:2]) #['小明', 18]

#列表也支持len() 求长度的，求数据元素个数
print(len(list1)) #4

• 2.3 查找-查找列表中数据下标得方法

• 在字符串中使用的find方法查找下标得，不存在返回的是 -1；

• 在列表中没有find 方法，想要查找数据的下标，使用index()方法

• 列表.index(数据，start，end) 使用和find方法一样，同时在字符串中也有index方法

• 区别：返回，index()方法，找到返回第一次出现的下标，没有返回代码直接报错

• 2.4 查找-判断是否存在

• 判断容器中某个数据是否存在可以使用 in 关键字

• 数据 in 容器 #如果存在返回True，如果不存在，返回False

• 2.5 查找-统计出现的次数

• 统计出现的次数，使用的是 count()方法

• 列表.count(数据) #返回 数据出现的次数

点击查看代码

my_list = [1,3,5,4,3,6,3,8,4,10]

#查找数据 3 出现的下标
print(my_list.index(3)) #1

#查找7 出现的下标
# print(my_list.index(7)) #代码会报错
if 7 in my_list:
    print(my_list.index(7))
else:
    print(f'7不在列表中！')

# my_list.count(7) 统计 数据 7 出现的次数
if my_list.count(7) > 0:
    print(my_list.index(7))
else:
    print(f'7不在列表中！')

• 2.6 添加数据的方法
• 尾部添加(最常用)
  列表.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中逐个元素添加到my_list中
my_list.extend(list1)
print(my_list) #['岳云鹏', '于谦', '郭德纲', '郭麒麟', '孙越', '烧饼', '贾玲']

#6.将list1作为一个整体添加到my_list
my_list.append(list1)
print(my_list) #['岳云鹏', '于谦', '郭德纲', '郭麒麟', '孙越', '烧饼', '贾玲', ['孙越', '烧饼', '贾玲']]

• 2.7 列表的遍历
  -通过内置函数enumerate打印列表的索引和对应的值

点击查看代码

list1 = list('123456789abcdeftghkflfjdlfj')
for i,j in enumerate(list1):
    print(i,j)

-通过range打印列表的索引和对应的值

点击查看代码

list1 = list('123456789abcdeftghkflfjdlfj')
for i in range(len(list1)):
    print(i,':',list1[i])

• 2.8 列表修改操作
• 想要修改列表中的指定下标位置的数据，使用的语法是：列表[下标] = 数据
• 字符串中字符不能使用下标修改

点击查看代码

#定义列表
my_list = [1,3,5,7,9]
#1. 想要将下标为1 的数据修改为22
my_list[1] = 22
print(my_list)
#修改最后一个位置的数据，改为hello
my_list[-1] = 'hello'
print(my_list)
#2.如果指定的下标不存在，会报错
#my_list[10] = 10  #代码会报错

• 2.9 列表的删除操作
• 在列表中删除中间某个数据，那么后面的数据会向前移动
• 根据下标删除：列表.pop(下标) #删除指定下标位置的数据
  1.下标不写，默认删除最后一个数据（常用）
  2.书写存在的下标，删除对应下标位置的数据
  3.返回：返回的是删除的数据
• 列表.remove(数据值) #根据数据值删除
  1.返回：None
  2、如果删除的数据不存在，会报错
• 清空数据：列表.clear() #清空列表

点击查看代码

#定义一个列表
my_list = [1,2,3,4,5,6,7,8,9,10]
#1.删除最后一个位置的数据
num = my_list.pop()
print(f'删除的数据为：{num}') #删除的数据为：10
print(my_list)  #[1, 2, 3, 4, 5, 6, 7, 8, 9]
#2.删除下标为1的数据
my_list.pop(1)
print(my_list)  #[1, 3, 4, 5, 6, 7, 8, 9]
#3.删除数据为7的数据
my_list.remove(7)  #如果列表中有多个7，只能删除第一个7
print(my_list) #[1, 3, 4, 5, 6, 8, 9]
#my_list.remove(7)  #会报错

#清空列表
my_list.clear()
print(my_list)

• 2.10 列表的反转(倒置)
• 字符串的反转倒置：字符串[::-1]
• 列表的 反转和倒置
  1.列表[::-1] #使用切片的方法，会得到一个新列表，原列表不会发生改变
  2.列表.reverse() #直接修改原列表，返回的是None

点击查看代码

my_list = [1,2,3,4,5,6,7,8,9,10]

#使用切片的方法进行列表的反转
new_list = my_list[::-1]
print(f'my_list:{my_list}')   #my_list:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(f'new_list:{new_list}') #new_list:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

#使用revese方法进行列表反转,直接修改原列表
my_list.reverse()
print(f'my_list:{my_list}') #my_list:[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

• 2.11 列表的复制
  使用场景：有一个列表，需要修改操作列表中的数据，修改之后需要和原数据进行对比，即原数据不能改
  1.使用切片 变量 = 列表[:]
  2.使用copy方法 变量 = 列表.copy()

点击查看代码

my_list = [1,2,3,4,5]

my_list1 = my_list[:]
print(f'my_list : {my_list}')       #my_list: [1, 2, 3, 4, 5]
print(f'my_list1: {my_list1}')      #my_list1: [1, 2, 3, 4, 5]
my_list1[1] = 22
print(f'my_list : {my_list}')      #my_list : [1, 2, 3, 4, 5]
print(f'my_list1: {my_list1}')     #my_list1: [1, 22, 3, 4, 5]
print('-' * 30)
my_list2 = my_list.copy()
print(f'my_list : {my_list}')     #my_list : [1, 2, 3, 4, 5]
print(f'my_list2: {my_list2}')    #my_list2: [1, 2, 3, 4, 5]
my_list2[1] = 33
print(f'my_list : {my_list}')   #my_list : [1, 2, 3, 4, 5]
print(f'my_list2: {my_list2}')  #my_list2: [1, 33, 3, 4, 5]

• 2.12 列表的排序
• 列表的排序，一般来说都是对数字进行排序的
• 列表.sort() #按照升序排序，从小到大排序
• 列表.sort(reverse=True) #降序排序，从大到小

点击查看代码

my_list = [1,3,5,7,9,0,8,6,4,2,10]
#升序排序
my_list.sort()
print(f'my_list: {my_list}')
#降序排序
my_list.sort(reverse=True)
print(f'my_list: {my_list}')

• 2.13 列表的嵌套
• 列表嵌套，列表中的内容还是列表
• 使用下标来确定获取的是什么类型的数据，然后确定可以继续进行什么类型的操作

点击查看代码

person_info = [['张三','18','功能测试'],['李四','20','自动化测试']]

print(f'person_info长度: {len(person_info)}')  #person_info长度: 2
print(person_info[0])   #['张三', '18', '功能测试']
print(person_info[0][0])  #'张三'
print(person_info[0][0][0]) #张

#张三的年龄18改为19
person_info[0][1] = '19'
print(person_info) #[['张三', '19', '功能测试'], ['李四', '20', '自动化测试']]

#给 李四 所在的列表添加一个性别 信息
person_info[1].append('男')
print(person_info)   #[['张三', '19', '功能测试'], ['李四', '20', '自动化测试', '男']]
person_info[1].insert(1,'男')
print(person_info)  #[['张三', '19', '功能测试'], ['李四', '男', '20', '自动化测试', '男']]

#将张三的年龄信息删除
#person_info[0].pop(1)
person_info[0].remove('19')
print(person_info) #[['张三', '功能测试'], ['李四', '男', '20', '自动化测试', '男']]

• 2.14 列表的常用方法
  变量.方法名()

点击查看代码

#列表的常用方法  变量.方法名()
list2 = [1,2,3,4,5,6,True,False,'hello','word','kate']
#append() 列表增加元素
list2.append('666')
print(list2)
#extend() 列表后面增加一个列表
list2.extend([11,22,33,44,55,11,1])
print(list2)
#insert() 插入元素,第一个参数是索引号，第二个参数是插入的元素值
list2.insert(2,'jake')
print(list2)
#pop() 通过索引删除某个元素
list2.pop(3)
print(list2)
#remove() 通过元素(值)删除,从头开始找，找到第一个删除就结束了
list2.remove(1)
print(list2)
#clear() 清空列表
# list2.clear()
# print(list2)
#reverse() 反转
list2.reverse()
print(list2)

• 2.15 列表去重
  1.方法1：遍历原列表中的数据，是否在新列表中存在，如存在，跳过，如不存在，放入新列表

点击查看代码

my_list1 = [1,2,3,3,2,1,4,5,612,43,45,6,64,77,88,1]
new_list1 = []
for i in my_list1:
    if i not in new_list1:
        new_list1.append(i)
print(new_list1)

2.方法2：在python中有一个数据类型(容器)，成为集合（set）
特点：集合中不能有重复的数据，如果有自动去重，可以使用该特点对列表去重
1）使用set()类型转换将列表转换为集合类型
2）在使用list()类型转换将集合转换为列表
缺点：不能保证数据在原列表中出现的顺序

点击查看代码

list1 = [1,2,3,4,3,2,1,12,3,4,3,2,1]
set(list1)
{1, 2, 3, 4, 12}
list(set(list1))
[1, 2, 3, 4, 12]

**3、元组** - Tuple（元组）与列表非常相似 1.元组中可以存放任意类型的数据 2.元组中可以存放任意多个数据 - 区别 1.元组中的数据内容不能改变，列表中的可以改变 2.元组使用(),列表使用[] - 应用 主要在函数的传参或返回值中使用，保证数据不会被修改

• 3.1 元组的定义
  1.使用类实例化方式
  2.直接使用()方式

点击查看代码

#1.使用类实例化方式定义
#1.1 定义空元组(不会使用的)
my_tuple1 = tuple()
print(f'{type(my_tuple1)} ,{my_tuple1}') #<class 'tuple'> ,()
#1.2 类型转换
#可以将列表转换为元组，只需要将[] 变为()
my_tuple2 = tuple([1,2,3,4])
print(f'{type(my_tuple2)} ,{my_tuple2}') #<class 'tuple'> ,(1, 2, 3, 4)
#转换字符串，和列表中一样，只是将列表的[]变为()
my_tuple3 = tuple('hello')
print(f'{type(my_tuple3)} ,{my_tuple3}')  #<class 'tuple'> ,('h', 'e', 'l', 'l', 'o')

#2.直接使用()定义
my_tuple4 = (1,'小王',3.1415926,False)
print(f'{type(my_tuple4)} ,{my_tuple4}')   #<class 'tuple'> ,(1, '小王', 3.1415926, False)

#3. 特殊点，定义只有一个数据的元组时，数据后补必须有一个逗号
my_tuple5 = ('王五',)
print(f'{type(my_tuple5)} ,{my_tuple5}') #<class 'tuple'> ,('王五',)

• 3.2 元组常用方法
  由于元组中的数据不能修改，所以只有查看方法
  1.在元组中也可以使用 下标和切片获取数据
  2.在元组中存在index方法
  3.在元组中存在count方法
  4.在元组中可以使用in 操作
  以上方法的使用 和列表中是一样的

点击查看代码

tuple1 = (1,2,3,4,5,6,'hello',False,'a','c','d')
#count()查找元组中元素的个数
print(tuple1)
a1 = tuple1.count('hello')
print(a1)  #6 
#index() 查找元素的索引
a2 = tuple1.index(4)
print(a2)   #5
#获取元组下标为1的数据
print(tuple1[1])  # 2

• 3.3 元组的遍历
• 只打印元组中各个元素的值
  tuple1 = (1,2,3,4,5,6,'hello',False,'a','c','d')
  print('-' * 30)
  for i in tuple1:
  print(i)
• 通过枚举函数enumerate实现打印索引和值
  for index,value in enumerate(tuple1):
  print(index,value)
• 通过for i in range()方式实现元组中的元素和索引的打印
  for i in range(len(tuple1)):
  print(i,tuple1[i])

4、range系统内置函数

• range(start,end,[step=1]),生成一个等差序列[start,end),包左不包右
• 注意序列属于不可变序列，不支持元素修改，不支持+和*操作
• range 一般用于for-in循环编列
• start 表示列表起始值，包含，默认是0
• stop 表示列表结束值，但是不包含
• step 步长，默认为1

5、字符串

• 5.1 常见的字符串定义

点击查看代码

#1.使用单引号定义
my_str1 = 'hello world1'
print(my_str1,type(my_str1))
#2.使用双引号定义
my_str2 = "hello world2"
print(my_str2,type(my_str2))
#3.使用三引号定义
my_str3 = """hello 
world3"""
print(my_str3,type(my_str3))
my_str4 = '''hello world4'''
print(my_str4,type(my_str4))

#4.字符串本身包含引号，I'm xiao ming
#4.1 字符串本身包含单引号，则在定义时不能用单引号
#4.2 字符串本身包含双引号，则在定义时不能用双引号
my_str5 = "I'm 小明"
print(my_str5,type(my_str5))

#5.字符串本身包含单引号，定义的时候，依然想使用单引号
#5.1 使用\ 转义字符，将字符串本身的引号进行转移 \' ---> '  \" --->"
my_str6 = 'I\'m 韩梅梅'
print(my_str6,type(my_str6))
# 5.2 字符串 'I\'m 李磊' 
my_str7 = 'I\\\'m 李磊'
print(my_str7,type(my_str7))
#5.3 字符串前边加上  r"" 原生字符串，字符串中的\不会作为转移字符,获取文件操作中会使用
my_str8 = r'I\'m 韩梅梅'
print(my_str8,type(my_str8))

• 5.2 字符串的下标常用操作

点击查看代码

str1 = "abcdefghijklmn"

#1.打印字符串中最开始位置的字符
print(f'最开始位置的字符:{str1[0]}')

#2.打印最后一个位置的字符
print(f'最后一个位置的字符：{str1[-1]}')

#3.打印倒数第二个位置的字符
print(f'倒数第二个位置的字符：{str1[-2]}')

#4.打印下标为2的字符
print(f'下标为2的字符：{str1[2]}')

#补充：获取字符串中字符个数（获取字符串的长度）
print(f'字符串的长度是:{len(str1)}')
print(f'最后一个位置的字母：{str1[len(str1)-1]}')   #字符串的长度-1，是最后一个字符

• 5.3 字符串切片常用操作

点击查看代码

str1 = 'abcdefghijklmn'

#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:15]) # lmn
# 2.1 如果最后一个字符也要取的话，可以不写
print(str1[-3:])  # lmn
# 2.2 如果开始和结束都不写，获取全部内容，但冒号必须有
print(str1[:])  #abcdefghijklmn

# 3.获取acegikm # 0 2 4 6 8 10 12
print(str1[::2])

# 4.特殊应用，步长为负数，开始和结束不写，意义全变
# 反转（逆置）字符串
print(str1[::-1])

• 5.4 字符串的查找方法 find
• 字符串.find(sub_str,start,end)通过元素进行索引查找，通过可选参数有查找元素的范围(起止索引号),查找不到返回-1
• 在大字符串中查找是否存在小的sub_str 这样的字符串
• sub_str：要查找的字符串
• start 开始位置，从哪个下标位置开始查找，一般不写，默认是0
• end 结束位置，查找到哪个下标结束，一般不写默认是len(字符串)
• 返回（代码执行之后会得到什么，如果有返回，就可以使用变量保存）
• 1.如果在字符串中找到 sub_str ,返回sub_str 第一次出现的正数下标（sub_str中第一个字符在大字符串中的下标）
• 2.如果没有找到，返回-1

点击查看代码

str1 = "and itcast and itheima and Python"

# 在字符串中查找 and
num = str1.find("and")
print(num)

# 在字符串中查找 第二个 and 出现的下标,从第一次出现的后一个开始找
num1 = str1.find("and",num+1)
print(num1)

# 在字符串中查找 第三个 and 出现的下标,从第二次出现的后一个开始找
num2 = str1.find("and",num1+1)
print(num2)

# 在字符串中查找 第四个 and 出现的下标,从第三次出现的后一个开始找
num3 = str1.find("and",num2+1)
# 如果是-1 说明没有and字符了
if num3 == -1:
    print('字符串str1中已经没有and字符了')
else:
    print(num3)

• 5.5 字符串的替换方法 replace
  -1.字符串.replace(old_str,new_str,count) #将字符串中old_str替换为new_str
  -2.old_str：被替换的内容
  -3.new_str:替换为的内容
  -4.count:替换的次数，一般不写，默认全部替换
  -5.返回：替换之后的完整字符串，注意：原来的字符串没有发生改变

点击查看代码

str1 = "good good study day day up"

#1.将str1中所有的g 改为大写的G
str2 = str1.replace("g","G")
print(f"str1:{str1} \nstr2:{str2}")  
#str1:good good study day day up 
#str2:Good Good study day day up

#2.将str1 中第一个good 改为 GOOD
str3 = str1.replace("good","GOOD",1)
print(f"str3:{str3}")
#str3:GOOD good study day day up

#3.将str2中第二个good 改为 GOOD
#3.1 先将全部的good --> GOOD
#3.2 再将第一个GOOD --> good
str4 = str1.replace("good","GOOD").replace("GOOD","good",1)
print(f"str4:{str4}")
#str4:good GOOD study day day up

• 5.6 字符串拆分 split
• 字符串.split(sep,maxsplit) #将字符串按照sep进行分割（拆分）
• sep，字符串按照什么进行拆分，默认是空白字符（空格，换行\n tab键\t）
• maxsplit,分割次数，一般不写，全部分割
• 返回：将一个字符串拆分为多个字符串，存到列表中
• 注意：如果sep不写，想要指定分割次数，则需要按照如下方式使用
• 例如：字符串.split(maxsplit=n) #n是次数

点击查看代码

str1 = "hello world and itcast and itheima and Python and ITTest"

#1.将str1按照and字符进行拆分
result1 = str1.split("and")
print(result1) #['hello world ', ' itcast ', ' itheima ', ' Python ', ' ITTest']

#2.将str1 按照and字符进行拆分，拆分一次
result2 = str1.split("and",1)
print(result2) #['hello world ', ' itcast and itheima and Python and ITTest']

#3.按照空白字符进行切割
result3 = str1.split()
print(result3)  #['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python', 'and', 'ITTest']

#4.按照空白字符进行切割，拆分1次
result4 = str1.split(maxsplit=1)
print(result4) #['hello', 'world and itcast and itheima and Python and ITTest']

• 5.7 字符串的连接 join
  -字符串1.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

• 5.8 字符串序列的通用操作

点击查看代码

print(str1+'jake')  #字符串加法
print(str1 * 2)  #字符串的乘法
print('字符串的长度%d' %(len(str1))) #字符串的长度
print(max(str1),min(str1))
#del str1
#print(str1)
print('s' in str1)
print('abcdt' > 'abcdef')

• 5.9 字符串的元素打印

点击查看代码

#打印字符串的值
for i in str1:
    print(i)
#打印字符串的索引和值，通过enumerate函数
for index,value in enumerate(str1):
    print(index,value)
#打印字符串的索引和值，通过range实现
for i in range (len(str1)):
    print(i,str1[i])

• 5.10 字符串类型转换

点击查看代码

print(str(1234),type(str(1234)))  #int->str
print(str([1,2,3,4]),type(str([1,2,3,4]))) #list->str
print(str((1,)),type(str((1,)))) #tuple->str

• 5.11 字符串的常用方法
  • 字符串名.方法名(可选参数1,可选参数2)

点击查看代码

str2 = '123456789'
str3 = '   heello wordleddd    '
s = "Hello, World! Welcome to Python World!"
#islower判断字符串是否全是小写
print(s.islower())
#isupper判断字符串是否全是大写
print(s.isupper())
#isdigit判断字符串是否全为数字
print(s.isdigit())
#isdigit判断字符串是否全为字母
print(str2.isalnum())
# index通过元素进行索引查找，如果没有则报错
print(s.index('w'))
# rindex() - 从右侧开始查找
print(s.rindex("World"))        # 27

print(s.find("World"))          # 7
print(s.find("Java"))           # -1
print(s.find("World", 10, 30))  # 从索引10开始到30查找: 27
# rfind() - 从右侧开始查找
print(s.rfind("World"))         # 27
#count统计子串出现的个数
print(s.count("World"))         # 2
print(s.count("o"))             # 4
print(s.count("o", 0, 10))      # 在索引0-10范围内查找: 1
#strip去除字符串前后的空格
print(str3)
print(str3.strip())
#split分割字符串，可以以指定的字符串进行分割,分割后生成的数据是列表
print(str3.split(' '))
print(str3.strip().split(' '))
#join将前面的字符串在后面每个元素中进行后面进行追加
print('#$%^'.join(['11','22','33','44']))
#将字符串全部转成小写
print(str1.lower())
#将字符串全部转成大写
print(str1.upper())
# startswith() - 检查是否以指定子串开头
filename = "document.pdf"
print(filename.startswith("doc"))      # True
print(filename.startswith("doc", 0, 3)) # True (指定范围)
#endswith() - 检查是否以指定子串结尾
print(filename.endswith(".pdf"))       # True
print(filename.endswith((".pdf", ".txt", ".docx")))  # 检查多个后缀: True

6、字典

• 6.1 dictionary(字典):是除列表以外python之中，最灵活的数据类型
  1.字典同样可以用来存储多个数据
  2.通常用于存储 描述一个物体的相关信息
  3.字典使用 键值对 存储数据，键值对之间使用，分割
  3.1 字典中的键key是索引，值value是数据
  3.2 字典中的键和值之间使用：分割
  3.3 一个字典中的键必须是唯一的
  3.4 字典中的值可以取任何数据类型，但键只能使用字符串、数字或元组
  4.与列表的区别
  4.1列表是有序的对象集合
  4.2字典是无序的对象集合
  4.3字典使用{}定义，列表使用[]定义，元组使用()定义

点击查看代码

#1.使用类实例化方法创建字典
my_dict = dict()
print(f'{type(my_dict)},{my_dict}') #<class 'dict'>,{}

#dict() 不能转列表和元组，字符串
#2.直接使用{}定义
#2.1 空字典
my_dict1 = {}
print(f'{type(my_dict1)},{my_dict1}') #<class 'dict'>,{}

# 2.2 非空字典，小明('name') 18('age')1.71('height')True(is_men) 抽烟 喝酒 烫头（'Like'）
my_dict2 = {'name':'小明','age':18,'height':1.71,'is_men':True,'Like':['抽烟','喝酒','烫头']}
print(my_dict2) #{'name': '小明', 'age': 18, 'height': 1.71, 'is_men': True, 'Like': ['抽烟', '喝酒', '烫头']}

• 6.2 字典的遍历
• 对字典的键进行遍历
  for 变量 in 字典：
  print(变量) #变量就是子带你的key，键
  for 变量 in 字典.keys(): 字典.keys() 可以获取字典中所有的键
  print(变量)
• 对字典的值进行遍历
  for 变量 in 字典.values(): 字典.values() 可以获取字典中所有的值
  print(变量)
• 对字典的键值对进行遍历
  for 变量1，变量2 in 字典.items(): 字典.items() 可以获取字典中所有的键值对
  print(变量1，变量2)

点击查看代码

d1 = {
    'name':'jake',
    'age':18,
    'gender':'Man',
    'phone':13152161817,
    'name':'jack', #键重复的情况下，后面的键值会覆盖前面的键值
}
#1.遍历字典的key值
for k in d1.keys():
    print(k)
for k in d1:
    print(k)
print('*' * 30)
#2.遍历字典的value值
for v in d1.values():
    print(v)
#3.传统for循环方法下遍历字典的key和value值
for i in  d1:
    print(i,d1[i])
print('*' * 30)
#4.遍历字典的key和value值
for k,v in d1.items():
    print(k,v)
print('*' * 30)

• 6.3 字典的增加和修改操作
  语法：字典[键] = 数据值
  1.如果 键 已经存在，就是修改数据操作
  2.如果 键 不存在，就是添加数据操作

点击查看代码

#1.定义一个字典
#小明 18 爱好
my_dict ={
    'name':'小明',
    'age':18,
    'like':['抽烟','喝酒','烫头']
}

#1.添加一个性别信息
my_dict['sex'] = '男'
print(my_dict) #{'name': '小明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

#2.修改年龄为 19
my_dict['age'] = 19
print(my_dict) #{'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}

#3.添加一个爱好：学习
my_dict['like'].append('学习')
print(my_dict) #{'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

• 6.4 字典的删除
  1.删除指定键值对 del 字典[键] 或字典.pop(键) #pop中的键必须写
  2.清空字典 字典.clear()

点击查看代码

my_dict={'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

#1.删除性别信息
del my_dict['sex']
print(my_dict) #{'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习']}
#字典.pop('键')
my_dict.pop('age')
print(my_dict) #{'name': '小明', 'like': ['抽烟', '喝酒', '烫头', '学习']}

#删除抽烟的爱好
my_dict['like'].remove('抽烟')
my_dict['like'].pop(0)
print(my_dict)  #{'name': '小明', 'like': ['喝酒', '烫头', '学习']}

#清空操作
my_dict.clear()
print(my_dict) #{}

• 6.5 查询-根据键获取对应的值
• 1.字典中没有下标，想要获取数据值，要使用key(键)来获取
• 2.使用 字典[键] 方法获取
  1）如果键存在，返回键对应的数据值
  2）如果键不存在，会报错
• 3.使用 字典.get(键)
  字典.get(键，数据值)，一般情况下数据值不下，默认是None
  返回：
  1）如果键存在，返回对应的数据值
  2）如果键不存在，返回的是None

点击查看代码

my_dict={'name': '小明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

#1.获取 名字
print(my_dict['name'])  #小明
print(my_dict.get('name')) #小明
print(my_dict.get('age','zzz'))  #19

#2.获取 height 性别
#print(my_dict['height'])  #代码会报错，原因 height不存在

print(my_dict.get('height')) #None
print(my_dict.get('height','保密'))  #保密

#3. 获取 第二个爱好
print(my_dict['like'][1])  #喝酒

• 6.6 字典的常用方法

点击查看代码

d1 = {
    'name':'jake',
    'age':18,
    'gender':'Man',
    'phone':13152161817,
    'name':'jack', #键重复的情况下，后面的键值会覆盖前面的键值
}
d1.items()  #遍历字典的key和value
d1.keys() #遍历字典的key
d1.values() #遍历字典的value
print('*' * 30)
print('原始的d1字典信息',d1)
d1.update({'height':185})   #更新字典中键值对内容
print('update后的字典信息',d1)
d1.pop('name') #删除字典中某个键值对
d1.popitem()  #从后面队尾删除一个键值对
print('popitem后的字典',d1)
a = d1.copy()  #复制字典
print('copy的字典',a)
print(d1.get('age')) #get或者字典中某个key的值
d1.clear()
print('clear后的字典信息',d1)

7、集合

• 7.1 集合定义
  1.不允许有重复的元素，如存在重复则自动过滤，可进行交集、并集运算
  2.是一种无序且不重复元素的数据结构
  3.与dict类似，是一组key的集合（不存储value）
• 7.2 集合的基础操作

点击查看代码

#成员运算符in
print(1 in s)
#长度计算len()
print(len(s))
print(max({1,2,3,4,5}))
print(min({1,2,3,4,5}))
# del s
# print(s)
print('-' * 40)
s = {'a','b','c','d',1,2,3,4,5,6,11,22,33,44,55,66,77}
#集合的变量
for i in s:
    print(i)

• 7.3 集合的常用方法

点击查看代码

#集合的追加，在原有的集合基础上追加一个集合
s.update({'helo','world',1,2,3})
print(s)
#集合中移除一个元素
s.remove('helo')
print(s)
#集合中增加一个元素
s.add('hello')
s.add('hello')
print(s)
#复制一个相同的集合
s1 = s.copy()
print(s1)
#从最左侧开始删除一个集合元素
s.pop()
print(s)
#清空集合
# s.clear()
# print(s)
#交集、并集
s2 = {1,2,3,'a','b','e','f',99,100}
#计算s和s2的交集
print(s & s2)
#计算s和s2的并集
print(s | s2)

-集合示例，分数列表数据去重，并计算每个分数段的学生人数

点击查看代码

#列表去重
score = [95,90,85,80,95,90,75,92,94,95,100,75,85,90,95,70,100,60,55,89,98,99]
s = set(score)
print(s)
d1 = {}
#统计各个分数的学生数量
for i in s:
    t = score.count(i)
    d1[i] = t
for k,v in d1.items():
    print('得分为%d的学生人数为:%d'%(k,v))

8、不可变类型

• 数字（例如int、float、complex）
• 字符串（例如str）
• 元组 （例如tuple）
• 布尔类型 （例如 bool）
  9、可变类型
• 列表 （例如 list）
• 字典 （例如 dict）
• 集合 （例如 set）
  10、容器总结
• 1.字符串，列表，元组 支持加法运算
  str1 = 'hello' + 'world' # 'hello world'
  list1 = [1,2,3] + [4,5,6] # [1,2,3,4,5,6]
  tuple1 = (1,2,3) + (4,5,6) # (1,2,3,4,5,6)
• 2. 字符串 列表 元组 支持 乘上一个数字
     'hello ' * 3 # 'hello hello hello'
     [1,2] * 3 # [1,2,1,2,1,2]
     (1,2) *3 # (1,2,1,2,1,2)
• 3.len()在 容器中都可以使用
• 4.in 关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在