Python学习笔记--数据容器_python的数据容器综合练习及讲解

文章末尾进行了详细的扩展

（一） 数据容器入门

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

2.. 种类：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）

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

1. 定义

（1） 基本语法：

# 字面量

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

# 定义变量

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

# 定义空列表

变量名称 = []

变量名称 = list（）

（2） 元素：列表中的每个数据

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

2. 列表的下标索引

（1） 类型：正向：从前向后，从0开始，依次递增

                        反向：从后向前，从-1开始，依次递减

（2） 使用：

列表[下标]

 下标超出范围，则无法取出元素，并且会报错

3. 列表的常用操作（方法）

* 函数：封装的代码单元，可提供特定功能。

  如将函数定义为class（类）的成员，则称函数为方法。

4. 列表的特点

• 可容纳多个元素
• 可容纳不同类型的元素
• 数据是有序存储的
• 允许重复数据存在
• 可进行增删查改.

age = [21, 25, 21, 23, 22, 20]
 
age.append(31)
print(age)
 
age.extend([29, 33, 30])
print(age)
 
x = age[0]
y = age[-1]
 
print(x, y)
 
a = age.index(31)
print(a)

练习2：

#
a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x'))#统计此元素在列表中出现的次数
#
a.insert(2, -1)#在指定下标处，插入指定的元素
a.append(333)#向列表中追加一个元素
print(a)
#
a.index(333)#返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
print(a.index(333))
#
a.remove(333)#从前向后，删除此元素的第一个匹配项
print(a)
#
a.reverse()	#倒排列表中的元素。
print(a)
#
a.sort()#对列表中的元素进行排序。
print(a)

（三） list（列表）的遍历

遍历：将容器内的元素依次取出，并处理

1.  使用while遍历

     可以指定循环条件，自行控制
     可以通过条件控制做到无限循环
     适用于任何想要循环的场景

2. 使用for遍历

     不可以指定循环条件，只可以一个个从容器内取出数据
     理论上不可以无限循环，因为被遍历的容器容量不是无限的
     适用于遍历数据容器的场景或简单的固定次数循环场景
练习：

L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l1 = list()
l2 = list()
i = 0
 
# 取出偶数
while i < len(L):
    if L[i] % 2 == 0:
        l1 . append(L[i])
        i = i + 1
    else:
        i = i + 1
print(f"通过while循环，从列表：{L}，中取出偶数，组成新列表{l1}")
 
 
for j in L:
    if j % 2 == 0:
        l2 . append(j)
print(f"通过for循环，从列表：{L}，中取出偶数，组成新列表{l2}")

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

* 元组一旦定义，不可进行修改

1. 元组的定义

（1） 基本语法：

# 字面量

（元素1 ，元素2 ，元素3，……）

# 定义变量

变量名称 =（元素1 ，元素2 ，元素3，……）

# 定义空列表

变量名称 = （）

变量名称 =tuple（）

 元组即使只含有一个数据，这个数据后也要添加，也可进行嵌套

2. 元组的操作（方法） 
 

！ 不可修改元组内容，否则直接报错

！ 可修改元组内list的内容

！ 不可以替换元组内list为其他list或其他类型

3. 元组的特点

• 可容纳多个元素
• 可容纳不同类型的元素
• 数据是有序存储的
• 允许重复数据存在
• 可进行增删查改
• 可进行循环
• 不可修改

练习：

T = ('周杰伦', 11, ['football', 'music'])
 
a = T.index(11)
n = T[0]
print(a,n)
 
del T[2][0]
T[2].append('coding')
 
print(T)

（五） 数据容器：str（字符串）

1. 字符串

字符的容器，一个字符串可以存放任意数量的字符。

2. 字符串的下标（索引）

从前向后，下标从0开始
从后向前，下标从-1开始
！ 字符串是一个无法修改的数据容器

！ 如果要修改，则会得到一个新的字符串，旧的字符串是无法修改的

3. 字符串的常用操作

4. 字符串的特点

• 只可以存储字符串
• 长度任意
• 支持下标索引
• 允许重复的字符串出现
• 不可以修改
• 支持循环

练习：

S = "itheima itcast boxuegu"
 
n = S.count("it")
print(f"字符串{S}中有{n}个it字符")
 
S1 = S.replace(" ", "|")
print(f"字符串{S}，被替换空格后，结果{S1}")
 
L = S1.split("|")
print(f"字符串{S}，按照“|”分割后，得到{L}")

（七） 数据容器：set（集合）

1. 集合的基本语法

# 定义集合字面量

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

# 定义集合变量

变量名称 = {元素，元素，……，元素}

# 定义空集合

变量名称 = set（）

！ 去重且无序，无法保证顺序与创建的时候一致

！ 不支持：下标索引访问，因此不支持while循环

补充：

定义：

列表[]         可修改、支持重复元素且有序

元组（）    不可修改、支持重复元素且有序

字符串“”     不可修改、支持重复元素且有序

集合{}         可修改、不支持重复元素、无序

2. 集合的常用功能
 

3. 集合的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标存储）
• 不允许重复数据存在
• 可以修改
• 支持for循环，不支持while循环

练习：

my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
 
S = set()
for i in my_list:
    S.add(i)
 
print(f"有列表：{my_list}")
print(f"存入集合后结果：{S}")

（八） 数据容器：dict（字典、映射）

1. 字典的基本语法

# 定义字典字面量

{key：value，key：value，……，key：value}

# 定义字面变量

my_dict = {key：value，key：value，……，key：value}

# 定义空字典

my_dict = {}

my_dict = dict{}

！ 每个元素均为键值对，key和value可以为任意类型数据（key不可为字典）

！ key不可重复，重复会对原有数据覆盖

！ 不可以使用下标索引，但可通过key值取得对应的value，不可使用while循环

！ 字典可嵌套

2. 字典的常用操作
 

3. 字典的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 不支持下标索引
• 可以修改
• 支持for循环，不支持while循环

练习：

D = {
    "王力鸿":{"部门":"科技部","工资":3000,"级别":1},
    "周婕纶":{"部门":"市场部","工资":5000,"级别":2},
    "凌俊杰":{"部门":"市场部","工资":7000,"级别":3},
    "张雪有":{"部门":"科技部","工资":4000,"级别":1},
    "牛德华":{"部门":"市场部","工资":6000,"级别":2}
}
keys = D.keys()
 
print(D)
 
for key in keys:
    if D[key]["级别"] == 1:
        D[key]["工资"] = D[key]["工资"] + 1000
 
print(D)

 扩展：数据容器的对比总结

（九） 数据容器的通用操作

（十）综合案例

练习题1：

# 幸运数字6：
# 1. 输入任意数字，如数字8，生成nums列表，元素值为1-8，
#  2. 从中选取幸运数字（能被6整除）移动到新列表lucky
# 3. 打印nums和lucky
 
n = int(input("请输入您所想的数字："))
i = 1
j = 0
nums = list()
lucky = list()
print(n)
 
while i <= n:
    nums.append(i)
    i = i + 1
 
print(f"nums列表为：{nums}")
 
for j in nums:
    if j % 6 == 0:
        lucky.append(j)
    j = j + 1
 
print(f"lucky列表为：{lucky}")

结果1：

结果2： 

 练习题2：

# 列表嵌套：
# 3个教室[[],[],[]]
# 8名讲师['A','B','C','D','E','F','G','H']
# 随机分配
import random
 
classroom = [[],[],[]]
teacher = ['A','B','C','D','E','F','G','H']
 
j = random.randint(0,2)
 
for i in teacher:
    classroom[j].append(i)
    j = random.randint(0,2)
 
print(f"分配后为：{classroom}")

一、基础知识

可变序列：目前包括字典、列表

不可变序列：目前包括整数，字符串

区别在于可变序列可以进行增、删、查、改操作，而不可变序列不可以进行

二、 字典的组成及原理

字典是由键值对组成的，字典是无序的排列方式，他不是根据你输入键的前后顺序来存储他，而是根据键的哈希值来存储

也是由于这个原因，字典的键必须是一个不可变序列，而且键不可以重复

语法格式如此：字典名={键：值，键：值，…}

字典的实现原理：

他是先由哈希函数计算键从而得到不同键的索引,然后根据键的索引排序键，键中保存的是值的地址，从而达到引用键而找到值的效果

字典特点：

1.字典中键值对是一一对应的，其中，键是不可以重复的，而值是可以重复的

2.字典中的键值对是无序的

3.字典是一种用空间换时间的数据结构

4.字典的键必须是不可变对象

三、字典的创建方式

字典的创建方式总共有两种：

1.通过{}创建字典

score={'tom':85,'jack':92,'sam':'pass'}
print(score)                        #输出{'tom': 85, 'jack': 92, 'sam': 'pass'}
 
print(type(score))                  #输出<class 'dict'>

2.通过内置函数dict()创建字典

在()里面写入键值对，与{}不同的是，这种创建方式为键=值，而不是键：值，这点需要注意

student=dict(tom=85,jack=92,sam='pass')
print(student)                      #输出{'tom': 85, 'jack': 92, 'sam': 'pass'}
print(type(student))

3.创建一个空列表

empty={}                            #输出{}
print(empty)
 
empty1=dict()
print(empty1)

四、字典元素的获取

字典元素的获取有两种方法：

1.使用[]获取，[]里面是键值

print(score['tom'])             #输出58
 
#print(score['alice'])               #如果查找不到，就会报错：KeyError: 'alice'

2.使用get()方法获取

score={'tom':58,'linda':62,'jack':98}
print(score.get('tom'))             #输出58
 
print(score.get('alice'))           #如果查找不到就会输出：None，这个none是可以代替的，在键后面加入替代的值，找不到就会输出替代的值
 
print(score.get('alice',56))        #输出56，如果查找不到就会默认输出键后面的值

五、字典元素的增删改操作

5.1字典元素的修改

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
 
print(dict)             #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}
 
dict['tom']=100
 
print(dict)             #输出{'tom': 100, 'jack': 59, 'marry': 53, '刘桂香': 77}

5.2 字典元素的删除：

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
 
print(dict)             #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}
 
del dict['tom']             #删除会删除整个键值对
 
print(dict)             #输出{'jack': 59, 'marry': 53, '刘桂香': 77}

5.3 字典元素的增加

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
 
print(dict)
 
dict['alice']=5666
 
print(dict)                 #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77, 'alice': 5666}

5.4 字典元素的清空

dict={'tom':56,'jack':59,'marry':53,'刘桂香':77}
 
print(dict)                 #输出{'tom': 56, 'jack': 59, 'marry': 53, '刘桂香': 77}
 
dict.clear()
 
print(dict)                 #输出{}

六、获取字典视图

实际上就是获取字典里面所有的键，所有的值，以及所有的键值对

这三种东西的获取方法各有不同，虽然方法各不一样，但是操作原理，用法都是一样的

6.1 获取所有的键

keys()函数

score={'tom':58,'linda':62,'jack':98}
 
a=score.keys()
print(a)            #输出dict_keys(['tom', 'linda', 'jack'])
#可以将输出的键进行列表化，获得键的列表
 
print(list(a))      #输出['tom', 'linda', 'jack']

6.2 获取所有的值

values()函数

score={'tom':58,'linda':62,'jack':98}
b=score.values()
print(b)                # 输出dict_values([58, 62, 98])
print(list(b))          #输出[58, 62, 98]

6.3 获取所有的键值对

items()函数

score={'tom':58,'linda':62,'jack':98}
 
print(score.items())        #输出dict_items([('tom', 58), ('linda', 62), ('jack', 98)])
print(list(score.items()))          #输出[('tom', 58), ('linda', 62), ('jack', 98)]

七、字典元素的遍历

使用for in循环进行遍历

score={'tom':58,'linda':62,'jack':98}
 
for i in score:             #这里的i表示的是键，如果要获取字典的值，就需要使用[]获取或者get函数获取
    print(i,score[i],score.get(i))

八、字典生成式

实际上和列表生成式差不太多，多使用了一个内置函数zip，而且由于字典是由键值对组成的，所以需要两个可迭代对象

zip函数组成字典生成式里面，如果键的个数和值得个数不相同时，以小的为准

items=['books','fruits','papers']
 
prices=[98,56,233]
 
a={i:j for i,j in zip(items,prices)}
print(a)
 
prices1=[978,5,5,6451,1]            #当键和值的个数不一样的时候，以短的为准
 
b={m:n for m,n in zip(items,prices1)}
print(b)

九、元组

9.1 什么是元组？

9.2 元组的创建 

9.3 如果元组中只有一个元素，逗号不能省 

t1=('python','world',23)
print(t1)
print(id(t1))
print(type(t1))
# ('python', 'world', 23)
# 1882095097664
# <class 'tuple'>
t2=tuple(('python','world',25))
print(t2)
print(id(t2))
print(type(t2))
# ('python', 'world', 25)
# 1882095097856
# <class 'tuple'>
t3='python','world',23
print(t3)
print(id(t3))
print(type(t3))
# ('python', 'world', 23)
# 1882095097664
# <class 'tuple'>
t=('python',)
print(t)
print(type(t))
# ('python',)
# <class 'tuple'>
t=('python')
print(t)
print(type(t))
# python
# <class 'str'>
 
#空元组创建方式
t=()
t1=tuple()

9.4 为什么元组是不可变序列

t=(10,[20,30],9)
print(t)
# t[1]=100 TypeError: 'tuple' object does not support item assignment
t[1].append(100)
print(t)
 
# (10, [20, 30], 9)
# (10, [20, 30, 100], 9)

 9.5 元组的遍历

t=tuple(('python','world',25))
#使用索引获取元组,容易越界
print(t[0])
print(t[1])
print(t[2])
#遍历元组获取元组，不需要知道元祖个数
for item in t:
    print(item)

十、集合

什么是集合

 集合的创建

 集合中元素不允许重复；集合中元素无序

s={23,25,43,32,23,123,43,34,23}
print(s)
print(type(s))
# {32, 34, 23, 123, 25, 43}
# <class 'set'>
s=set(range(6))
print(s,type(s))
# {0, 1, 2, 3, 4, 5} <class 'set'>
print(set([3,4,5,6,5]))
# {3, 4, 5, 6}列表转集合
print(set((3,4,5,3,2,34,3,32,2)))
# {32, 34, 2, 3, 4, 5}元组转集合，集合中元素无序
print(set('PYTHON'))
# {'Y', 'H', 'P', 'O', 'N', 'T'} 字符串序列转集合
print(set({1,2,3,4,2,3,4,5,124}))
{1, 2, 3, 4, 5, 124}
 
#不能用花括号定义空集合
print(type({}),{})
print(type(set()),set())
# <class 'dict'> {}
# <class 'set'> set()

集合的相关操作

s={10,20,30,40,50}
 
print(10 in s)
print(100 in s)
 
s.add(100)
print(s)
s.update({200,400,300})
print(s)
s.update([500,600])
print(s)
s.update((700,800))
print(s)
# {50, 20, 100, 40, 10, 30}
# {100, 40, 200, 10, 300, 400, 50, 20, 30}
# {100, 40, 200, 10, 300, 400, 50, 20, 500, 600, 30}
# {800, 100, 40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
s.remove(100)
print(s)
# s.remove(900) KeyError: 900
s.discard(900)
print(s)
s.pop()
print(s)
# s.pop(400) TypeError: set.pop() takes no arguments (1 given) 函数pop()
# {800, 40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
# {800, 40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
# {40, 200, 10, 300, 400, 50, 20, 500, 600, 700, 30}
s.clear()
print(s)
# set()

 集合间的关系

s={10,20,30,40}
s1={20,10,40,30}
print(s1==s)
#True
 
s2={10,30}
s3={30,50}
print(s2.issubset(s))
print(s3.issubset(s))
# True
# False
print(s.issuperset(s2))
print(s.issuperset(s3))
# True
# False
 
s4={60,70,80}
print(s.isdisjoint(s1))
print(s.isdisjoint(s2))
print(s.isdisjoint(s4))
# False
# False
# True

 集合的数据操作

#交集:intersection()  或  &
s1={10,20,30}
s2={23,30,20}
print(s1.intersection(s2))
print(s1 & s2)
# {20, 30}
# {20, 30}
 
#并集:union()   或  |
print(s1.union(s2))
print(s1 | s2)
# {20, 23, 10, 30}
# {20, 23, 10, 30}
 
#差集：difference()   或  -
s1={10,20,30,40}
s2={20,30,50}
print(s1.difference(s2))
print(s1-s2)
# {40, 10}
# {40, 10}
 
#对称差集：symmetric_difference()   或   ^
s1={10,20,30,40}
s2={20,30,50}
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
# {40, 10, 50}
# {40, 10, 50}

集合生成式 

#列表生成式
lst=[i*i for i in range(6)]
print(lst,type(lst))
#集合生成式
s={i for i in range(6)}
print(s,type(s))
# [0, 1, 4, 9, 16, 25] <class 'list'>
# {0, 1, 2, 3, 4, 5} <class 'set'>

列表、字典、元组、集合总结