python笔记6-第六章 数据容器（上）

一、数据容器入门

1.数据容器概念

        一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

2.分类：

根据特点不同，如：

        是否支持重复元素

        是否可以修改

        是否有序，等

分为5类，分别是：

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

二、数据容器：list（列表）

（1）列表的定义

a.基本语法：

# 字面量

[元素1，元素2，元素3，元素4，...]

# 定义变量

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

#定义空列表

变量名称 = []

变量名称 = list()

列表中的每一个数据，称之为元素

        以[]作为标识

        列表内每一个元素之间用，逗号隔开

b.列表的定义方式：

案例演示：使用[]的方式定义列表

name_list = ['itheima','itcast','python']
print(name_list)
print(type(name_list))

['itheima','itcast','python'] 

<class 'list'>

my_list = ['itheima',666,True]
print(my_list)
print(type(my_list))

['itheima',666,True] 

<class 'list'>

#嵌套列表定义
my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

 [[1,2,3],[4,5,6]]

<class 'list'>

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。

（2）列表的下标索引

嵌套列表的元素

（3）列表的查询功能（方法）

        回忆：函数是一个封装的代码单元，可以提供特定功能。

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

#函数
def add(x, y):
return x + y

#方法
class Student:
    def add(self, x, y):
        return x + y

 方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：

函数的使用：num = add(1, 2)

方法的使用：Student = Student()

                      num = student.add(1,2)

（4）列表的修改功能（方法）

a.修改特定位置（索引）的元素值：

        语法：列表[下标] = 值

        可以使用如上语法，直接对指定下标（正向、反向均可）的值进行：重新赋值（修改）

# 正向下标
my_list = [1, 2, 3]
my_list[0] = 5
print(my_list)    #结果：[5, 2, 3]

# 反向下标
my_list = [1, 2, 3]
my_list[-3] = 5
print(my_list)    # 结果：[5, 2, 3]

b.插入元素：

        语法：列表insert（下标，元素），在指定的下标位置，插入指定的元素

my_list = [1, 2, 3]
my_list.insert(1,"itheima")
print(my_list)    #结果：[1,"itheima", 3, 4]

c.追加元素：

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

my_list = [1, 2, 3]
my_list.append(4)
print(my_list) #结果：[1, 2, 3, 4]

my_list = [1, 2, 3]
my_list.append([4, 5, 6])
print(my_list)    #结果：[1, 2, 3, [4, 5, 6]]

       方式2：在列表尾部，追加一批元素

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

my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)    #结果：[1，2，3，4，5，6]

d.删除元素：

        语法1：del列表[下标]

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

my_list = [1, 2, 3]

# 方式1 删除对应下标的方式
del my_list[0]
print(my_list)    # 结果：[2，3]
# 方式2 取出对应下标的方式删除
my_list.pop(0)
print(my_list)    # 结果：[2，3]

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

        语法:列表.remove(元素)

my_list = [1, 2, 3, 2, 3]
my_list.remove(2)
print(my_list)    # 结果：[1，3，2，3]

 f.清空列表内容

        语法：列表.clear()

my_list = [1, 2, 3]
my_list.clear()
print(my_list)    # 结果：[]

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

        语法：列表count(元素)

my_list = [1, 1, 1, 2, 3]
print(my_list.count(1))    # 结果：3

 （5）列表的查询功能（方法）

        统计列表内，有多少元素

        语法：len(列表)

        可以得到一个int数字，表示列表内的元素数量 

my_list = [1, 2, 3, 4, 5]
print(len(my_list))    # 结果5

 

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标，元素)	在指定下标处，插入指定的元素
4	del列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError
10	len(列表)	统计容器内有多少元素

        通过上述对列表的学习，可以总结出列表有如下特点：

        a.可以容纳多个元素（上限为2**63-1、922337206854775807个）

        b.可以容纳不同类型的元素（混装）

        c.数据是有序存储的（有下标序号）

        d.允许重复数据存在

        e. 可以修改（增加或删除元素等）

三、list（列表）的遍历

1.列表的遍历-while循环

        既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

如何遍历列表的元素呢？

        可以使用前面学过的while循环

如何在循环中取出列表的元素呢？

        使用列表[下标]的方式取出

循环条件如何控制？

        定义一个变量表示下标，从0开始

        循环条件为 下标值<列表的元素数量

index = 0
while index < len(列表)：
    元素 = 列表[index]
    对元素进行处理
    index += 1

 2.列表的遍历-for循环

        除了while循环外，python中还有另外一个循环形式：for循环。对比while，for循环更加适合对列表等数据容器进行遍历。

语法：

 for 临时遍历 in 数据容器：

        对临时变量进行处理

        表示，从容器内，依次取出元素并编辑到临时变量上。在每一次的循环中，我们可以对临时变量（元素）进行处理。

3.while循环和for循环的对比

        while循环和for循环，都是循环语句，但细节不同：

a.在循环控制上：

        while循环可以自定循环条件，并自行控制

        for循环不可以自定循环条件，只可以一个个从容器内取出数据

b.在无限循环上：

        while循环可以通过调节控制做到无限循环

        for循环理论上不可以，因为被遍历的容器不是无限的

c.在使用场景上：

        while循环适用于任何想要循环的场景

        for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

总结： 

（1）什么是遍历？

        将容器内的元素依次取出，并处理，称之为遍历操作

（2）如何遍历列表的元素？

        可以使用while或for循环

（3）for循环的语法：

for 临时变量 in 数据容器：

        对临时变量进行处理

（4）for循环和while对比

        a.for循环更简单，while更灵活

        b.for用于从容器内依次取出元素并处理，while用于任何需要循环的场景 

四、数据容器：tuple（元组）

为什么需要元组？

        思考：列表是可以修改的，如果想传递的信息，不被篡改，列表就不合适了。

元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：

        元组一旦定义完成，就不可修改

1.定义元组 

 (1)元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

# 定义元组字面量
（元素，元素，......，元素）
# 定义元组变量
变量名称 = （元素，元素，......，元素）
# 定义空元组
变量名称 = ()        # 方式1
变量名称 = tuple     # 方式2

(2)注意事项

# 定义3个元素的元组
t1 = (1,'Hello',True)

# 定义1个元素的元组
t2 = ('Hello',)    # 注意，必须带有逗号，否则不是元组类型

 注意：元组只有一个数据，这个数据后面要添加逗号

(3)元组的嵌套：

# 定义一个嵌套元组
t1 = ((1, 2, 3),(4, 5, 5))
print(t1[0][0])    # 结果：1

2.元组的相关操作 

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

# 根据下标（索引）取出数据
t1 = (1, 2, 'hello')
print(t1[2])    # 结果：'hello'

# 根据index（），查找特定元素的第一个匹配项
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello'))    # 结果：2

# 统计某个数据在元组内出现的次数
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.count('hello'))    # 结果：2

# 统计元组内的元素个数
t1 = (1, 2, 3)
print(len(t1))    # 结果：3

（1）不可以修改元组的内容，否则会直接报错

# 尝试修改元组内容
t1 = (1, 2, 3)
t1[0] = 5

（2） 可以修改元组内的list的内容（修改元素、增加、删除、反转等）

# 尝试修改元组的内容
t1 = (1, 2, ['itheima', 'itcast'])
t1[2][1] = 'best'
print(t1)    # 结果：（1，2，['itheima', 'best']）

总结：

        经过上述对元组的学习，可以总结出列表有如下特点：

a.可以容纳多个数据

b.可以容纳不同类型的数据（混装）

c.数据是有序存储的（下标索引）

d.允许重复数据存在

e.不可以修改（增加或删除元素等）

f.支持for循环

         多数特性和list一致，不同点在于不可修改的特性。