数据容器分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

list

#字面量

[元素1，元素2，元素3，……]

#定义变量

变量名称 = [元素1，元素2，元素3，……]

#定义空列表

变量名称 = []

变量名称 = list()

列表的方法

插入元素，删除元素，清空列表，修改元素，统计元素个数等

在python中，如果将函数定义为class的成员，那么函数会称之为：方法

1.查询功能

语法：列表.index(元素)

统计列表内，有多少元素

语法：len(列表)

2.修改功能

语法：列表[下标] = 值

3.修改功能

插入元素

语法：列表.insert(下标，元素)

追加元素

语法1：列表.append(元素)，将指定元素，追加到列表的尾部

语法2：列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表尾部

删除元素

语法1：del列表[下标]

语法2：列表.pop(下标)

删除某元素在列表中的第一个匹配项

语法：列表.remove(元素)

清空列表内容

语法：列表.clear()

统计某元素在列表内的数量

语法：列表.count(元素)

练习案例：常用功能练习

有一个列表，内容是：[21,25,21,23,22,20]，记录的是一批学生的年龄

请通过列表的功能（方法），对其进行

1.定义这个列表，并用变量接收它

2.追加一个数字31，到列表的尾部

3.追加一个新列表[29,33,30]，到列表的尾部

4.取出第一个元素（应是：21）

5.取出最后一个元素（应是：31）

6.查找元素31，在列表中的下标位置

list = [21,25,21,23,22,20]
list.append(31)
list.extend([29,33,30])
print(f"从列表中取出来第一个元素，应该是21，实际上是：{list[0]}")
print(f"从列表中取出来最后一个元素，应该是30，实际上是：{list[-1]}")
print(f"元素31在列表中的下标位置是：{list.index(31)}")
print(f"最后列表的内容是：{list}")

运行：

练习案例：取出列表内的偶数

定义一个列表，内容是：[1,2,3,4,5,6,7,8,9,10]

1.遍历列表，取出列表内的偶数，并存入一个新的列表对象中

2.使用while循环和for循环各操作一次

提示：

1.通过if判断来确认偶数

2.通过列表的append方法，来增加元素

#定义列表，用list接收它
list = [1,2,3,4,5,6,7,8,9,10]
#定义一个空列表，用于接收偶数列表
my_list=[]
my_list2=[]
n = 0

#用for循环列表
for element in list:
    if element % 2 == 0:
        my_list.append(element)

print(f"通过for循环,从列表:{list}中取出偶数,组成新的列表{my_list}")

#用while循环列表
while n < len(list):
    element = list[n]
    if element % 2 == 0:
        my_list2.append(element)
    n += 1

print(f"通过while循环,从列表:{list}中取出偶数,组成新的列表{my_list2}")

运行：

元组

#定义元组字面量

（元素，元素，……元素）

#定义元组变量

变量名称=（元素，元素，……元素）

#定义空元组

变量名称=（）

变量名称=tuple（）

练习案例：元组的基本操作

定义一个元组，内容是：（‘小兰花’，11，[‘footba’，‘music’]），记录的是一个学生的信息（姓名、年龄、爱好）

请通过元组的功能（方法），对其进行

1.查询其年龄所在的下标位置

2.查询学生的姓名

3.删除学生爱好中的football

4.增加爱好：coding到爱好list内

#定义一个元组记录学生的信息
tuple = ('小兰花',11,['football','music'])
#查询年龄所在的下标位置
print(f"年龄所在的下标位置是：{tuple.index(11)}")
#查询学生的姓名
name = tuple[0]
print(f"姓名为：{name}")
#删除爱好中的football
del tuple[2][0]
#增加爱好：coding到爱好list内
tuple[2].append('coding')
print(f"现在的元组是：{tuple}")

运行：

字符串

查找特点字符串的下标索引值

语法：字符串.index（字符串）

字符串的替换

语法：字符串.replace（字符串1，字符串2）

功能：将字符串内的全部字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串哦

字符串的分割

语法：字符串.split（分隔符字符串）

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

字符串的规整操作（去前后空格）

语法：字符串.strip()

字符串的规整操作（去前后指定字符串）

语法：字符串.strip(字符串)

统计字符串内某字符串的出现次数

语法：字符串.count(字符串)

统计字符串的字符个数

语法：len(字符串)

练习案例：分割字符串

给定一个字符串：“nitty is a nauty boy"

1.统计字符串内有多少个“ty“字符

2.将字符串内的空格，全部替换为字符：“|”

3.并按照“|”进行字符串分割，得到列表

提示：

count replace split

#定义字符串
my_str = "nitty is a nauty boy"
#统计字符串内有多少个“ty“字符
count = my_str.count("ty")
print(f"字符串nitty is a nauty boy中有：{count}个ty字符")
#将字符串内的空格，全部替换为字符：“|”
new_str = my_str.replace(" ","|")
print(f"字符串nitty is a nauty boy被替换空格后，结果：{new_str}")
#并按照“|”进行字符串分割，得到列表
list = new_str.split("|")
print(f"字符串{new_str}按照|分割后，得到：{list}")

运行：

序列

序列是指内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可以视为序列。

序列的常用操作-切片

切片：从一个序列中，取出一个子序列

语法：序列[起始下标：结束下标：步长]

练习案例：序列的切片实践

有字符串：“步进日日，起一烟如霞暮兮念和，nohtpy学”

使用已学的任何方式，得到“念兮暮霞如烟”

参考：

1.倒序字符串，切片取出 或 切片取出，然后倒序

2.split分隔“，”replace替换“和”“一起”为空，倒序字符串

#定义字符串
a_str = "步进日日,起一烟如霞暮兮念和,nohtpy学"

#方法1 倒序字符串，切片取出
def method1():
    print("方法1")
    my_str = a_str[::-1]
    print(f"倒序后的字符串：{my_str}")
    index = my_str.index("念")
    index2 = my_str.index("烟")
    str = my_str[index:index2+1:]
    print(f"切片取出的字符串：{str}")

#方法2 切片取出，然后倒序字符串
def method2():
    print("方法2")
    index2 = a_str.index("烟")
    index = a_str.index("念")
    my_str = a_str[index2:index+1:]
    print(f"切片取出的字符串：{my_str}")
    str = my_str[::-1]
    print(f"倒序后的字符串：{str}")

#方法3 split分隔“，”replace替换“和”“一起”为空，倒序字符串
def method3():
    print("方法3")
    str = a_str.split(",")[1][::-1].replace("和"," ").replace("一起"," ").replace(" ","")
    print(f"方法3得到的结果：{str}")

method1()
method2()
method3()

运行：

我是为了更清楚每一步的变化，把过程中的也print出来了，实际上可以更简化，一句话解决。

今天先到这了，数据容器中的集合和字典明天继续更新~