数据容器----python

拾萤

已于 2023-03-26 18:52:22 修改

阅读量230

点赞数

分类专栏： python 文章标签： numpy Powered by 金山文档

于 2023-03-23 22:43:44 首次发布

本文链接：https://blog.csdn.net/m0_56746629/article/details/129453552

版权

python 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

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

根据容器的特点：元素是否可以重复、是否可以修改、是否有序等分为以下五大类：

列表（list)

变量名=[元素1，元素2,....元素n]#元素可以为空
变量名=[[元素1，元素2...元素n],[元素1，元素2...元素n]....[元素1，元素2...元素n]]#嵌套列表

列表的下标的索引正反都可以取

s=[['name'],['num'],['hello'],]
print(s[0].index('name'),s[2],'\n')
print(s[1].index('num'),'\n')
print(s[-1][2])

注意：下标索引超出范围，或者查找的内容不在list会报错

列表的常用操作

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

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

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

在python中，将函数定义为class(类)的成员，那么函数称之为：方法

函数的使用

a=strlen('hello')

方法的使用

stu=Student()
n=stu.add(1,2)

列表的增删查改

查询元素下标

元素.index(索引)

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

列表[下标]=值

str.replace('旧','新')

插入元素

列表insert（下标，元素）#在指定位置插入指定元素

l1=[1,2,3,4,6]
l1.insert(4,5)
print(l1)

追加一个元素

列表.append(元素) 将指定的一个元素，追加到列表尾部

l1=[1,2,3,4,5,6]
l1.append(7)
print(l1)

追加一批元素

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

l1=[1,2,3,4,5,6]
l2=[7,8,9,10]
l1.extend(l2)
print(l1)

删除指定下标索引的元素

语法1：del 列表[下标]

语法2：列表.pop（下标）

#删除列表元素
mlist=['1','a','c']
print (mlist)
#del 列表名[下标]
del mlist[0]
print(mlist)
#列表名.pop(下标)
mlist.pop(0)
print(mlist)

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

列表.remove(元素)

删除的是第一个指定的元素，如果没有该元素会报错

#删除列表中的某个元素
m=['aaaa','abbbb','bccccc','abcd']
print(m)
m.remove('aaaa')#一个单引号里的是一个元素
print(m)
n=[1,1,2,2,3,4,1,5]
print(n)
n.remove(1)
print(n)

清空列表

n.clear()
print(n)

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

列表.count(元素)

n=[1,1,2,2,3,4,1,5]
print(n.count(1))

统计列表元素的数量

len(n)

n=[1,1,2,2,3,4,1,5]
# print(n.count(1))
print(len(n))

m='mylist'
print(len(m))

列表的综合案例运用

l=[21,25,21,23,22,20]
l.append(31)
print(l)
n=[29,33,30]
l.extend(n)
print(l)
l.remove(21)
print(l)
l.pop(8)
print(l)
m=l.index(31)
print(m)

列表的遍历--while循环

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

while循环遍历列表元素

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

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

n=[1,2,3,4,5,6,7,8,9,11]
i=0
while i<10:
    m=n[i]
    print(m)
    i+=1

列表的遍历--for循环

n=[1,2,3,4,5,6,7,8,9,11]
i=0
for i in range(1,11):
    m=n[i]
    print(m)
    i+=1

n=[1,2,3,4,5,6,7,8,9,11]
i=0
for i in n:
    print(i)

while循环可以自定义条件，并控制。可以通过条件做到无限循环，适合于任何想要循环的环境。

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

取出列表内的偶数

l=[1,4,6,4,3,8,9,11,15,14]
m=[]
for i in l:
    if i%2==0:
        m.append(i)
print(m)
n=[]
k=0
while k<len(l):
    if l[k] % 2 == 0:
        n.append(l[k])
    k+=1
print(n)

元组（tuple）

元组相当于一个只读的列表，一旦定义，不可修改。元组是用于封装数据，又不希望数据被篡改，元组非常合适。

元组定义：元组定义用小括号，且用逗号隔开各个数据，数据可以是不同的数据类型。同时，元组支持下标索引。

t1=()#空元组
print(type(t1),t1)
t2=(1,'mmm',True)#元组内数据类型可以不同
print(type(t2),t2)
l=[1,'1',True]#列表同理
print(type(l),l)
t3=tuple()
print(type(t3),t3)
t4=('mmm')
print(type(t4),t4)
t5=('mmm',)#','
print(type(t5),t5)

index、count、len、while、for的使用

n=(1,2,3,4,5,9)
print(n.index(3))
print(n.count)
print(len(n))
i=0
while i<len(n):
    print(n[i])
    i+=1
for j in n:
    print(j)

t1=('周',11,['football',"music"])
print(t1[1])
print(t1[0])
del t1[2][0]
print(t1)
t1[2].append('coding')
print(t1)

字符串（str）

支持下标索引

str1='i am a student'
#寻找下标索引
print(str1.index('a'))
print(str1.find('s'))
#字符替代
print(str1.replace('a','b'))
#统计某字符出现的次数
print(str1.count('d'))
#统计字符串长度
print(len(str1))

#split（）方法分割，不会修改原字符串，会生成新的列表
#str.split(str="", num=分割次数)
str2='hello i am your father'
n_str2=str2.split(' ')
print(n_str2,type(n_str2))
#strip（）方法【注】要注意的是该方法只能删除开头或结尾部分的字符，不能删除中间部分的字符
str3=' hello ! you are so fine '
print(str3)
n_str3=str3.strip()#不传入参数，去除首尾空格，也可以指定字符串
print(n_str3,'\n',type(n_str3))
n1_str3=str3.strip(" he ")#strip(需要移除的字符序列)
print(n1_str3)

练习

str1='you are a silly man'
print(str1.count('a'))
print(str1.replace(' ','|'))
n_str1=str1.split('|')
print(n_str1)

序列的常用操作---切片

序列：内容连续有序且支持下标索引的一类数据容器，例如列表、元组、字符串......

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

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

集合（set）

集合没有重复元素，且内部无序，不支持下标索引。

语法：{元素1，元素2...元素n}

随机取出集合的元素、增加元素、移除元素

结果

清空集合

结果

取出差集

结果

消除差集

在s1里面消除和s2里面相同的元素

两个集合合并

统计元素数量

循环

集合不能用while，可以用for

综合练习

字典（dict）

定义：字典名字={key:value,key:value,key:value...}

key和value可以为任意地数据类型，但是key不能为字典

空字典字典名字={}

定义重复key的字典

从字典中基于key获取value

字典也不支持下标索引，但是它可以通过key来取得对应的value

定义嵌套字典

dict1={'张三':{
    "语文":77,
    "数学":99,
    "英语":61},
    '里斯':{
    "语文":97,
    "数学":99,
    "英语":61},
    '王二':{
    "语文":87,
    "数学":63,
    "英语":71},
}
print(dict1)

从嵌套字典中获取数据

print(dict1['张三']['语文'])

新增元素

语法：字典[key]=value，结果是字典被修改，新增了元素

dict1['麻子']='1'

更新元素

语法：字典[key]=value,结果：字典被修改，元素被更新

注意：字典key不可以重复，所以对已存在的key执行上述操作，就是更新

dict1['张三']['总分']= {(77 + 99 + 61)}
print(dict1['张三'])

删除元素

dict1.pop('张三')
print(dict1)

清空元素

dict1.clear()
print(dict1)

获取全部的key

语法：字典.keys()

print(dict1.keys())

遍历字典

方法一：通过获取所有key来遍历

keys=dict1.keys()
for key in keys:
    print(f'字典的key为{key}')
    print(f'字典的value为{dict1[key]}')

方法二：直接循环

for key in dict1:
    print(f'字典的key为{key}')
    print(f'字典的value为{dict1[key]}')

字典由于不支持下标索引，故字典不可以使用while循环

统计字典元素数量

print(len(dict1))

综合测验

dict1={
    '小王':{
        '部门':'it',
        '工资':3000,
        '级别':1
    },
    '小周':{
        '部门':'sc',
        '工资':5000,
        '级别':2

    },
    '小林':{
        '部门':'sc',
        '工资':7000,
        '级别':3
    },
    '小张':{
        '部门':'it',
        '工资':4000,
        '级别':2},
    '小刘':{
        '部门':'sc',
        '工资':6000,
        '级别':2},
}
# print(dict1)
for key in dict1:
    if dict1[key]['级别']==1:
        dict1[key]['级别']=2
        dict1[key]['工资']+=1000
print(dict1)