一文带你搞懂Python中的数据容器

目录

一、数据容器：list(列表)

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

以>列表内每一个元素之间用, 逗号隔开

定义语法：

[元素1, 元素2, 元素3, ......]

例：

list = ['iii', 666, '你好']

1.1>

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增或者递减

语法：列表[下标]，即可取出

1.2>

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

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

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

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

语法：列表[下标] = 值

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

插入元素：

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

追加元素:

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

追加元素方式2：

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

删除元素：

语法1：del 列表[下标]语法2：列表.pop(下标)

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

语法：列表.remove(元素)

清空列表内容:

语法：列表.clear()

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

语法：列表.count(元素)

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

统计列表内，有多少元素

语法：len(列表)

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

list = [21, 25, 21, 23, 22, 20]

list.append(31)
list.extend([29, 33, 30])
listone = list.pop()
idx = list.index(31)
print(idx)

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

1.3>

可以容纳多个元素（上限为2**63-1、9223372036854775807个）可以容纳不同类型的元素（混装）数据是有序存储的（有下标序号）允许重复数据存在可以修改（增加或删除元素等）

1.4>

1.4.1 列表的遍历 - while循环

def while_list():
    list = [11, 12, 13]
    index = 0
    while index < len(list):
        el = list[index]
        print(f'元素：{el}')

        index += 1

while_list()

1.4.2 列表的遍历 - for循环

def for_list():
    list = [1, 2, 3, 4, 5]
    for v in list:
        print(f'元素：{v}')

for_list()

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

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
index = 0
new_list = []
while index < len(list):
    if list[index] % 2 == 0:
        new_list.append(list[index])

    index += 1

for val in list:
    if val % 2 == 0:
        new_list.append(val)

print(new_list)

二、数据容器：tuple(元组)

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

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

元组由于不可修改的特性，所以其操作方法非常少。

元组也可以被遍历，同列表一样。

可以使用while循环和for循环遍历它

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

t1 = (1, 11)
print(f'{t1}, type:{type(t1)}')
num = t1.index(11)

元组的特点:

可以容纳多个数据可以容纳不同类型的数据（混装）数据是有序存储的（下标索引）允许重复数据存在不可以修改（增加或删除元素等）支持for循环

三、数据容器：str(字符串)

3.1>

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

从前向后，下标从0开始从后向前，下标从-1开始

同元组一样，字符串是一个：无法修改的数据容器。

所以：

修改指定下标的字符 （如：字符串[0] = “a”）移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）追加字符等 （如：字符串.append()）均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

3.2>

操作	说明
字符串[下标]	根据下标索引取出特定位置字符
字符串.index(字符串）	查找给定字符的第一个匹配项的下标
字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
字符串.split(字符串)	按照给定字符串，对字符串进行分隔 <br/>不会修改原字符串，而是得到一个新的列表
字符串.strip()<br/> 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
字符串.count(字符串)	统计字符串内某字符串的出现次数
len(字符串)	统计字符串的字符个数

3.3>

同列表、元组一样，字符串也支持while循环和for循环进行遍历

str = '小小叮当'
index = 0
while index < len(str):
    print(str[index])
    index += 1


for v in str:
    print(v)

3.4>

作为数据容器，字符串有如下特点：

只可以存储字符串长度任意（取决于内存大小）支持下标索引允许重复字符串存在不可以修改（增加或删除元素等）支持for循环

四、数据容器（序列）的切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列

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

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

步长1表示，一个个取元素步长2表示，每次跳过1个元素取步长N表示，每次跳过N-1个元素取步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

my_list = [1, 2, 3, 4, 5]
print(my_list[1:4:2])

my_tuple = (0, 1, 2, 3, 4, 5, 6)
print(my_tuple[0:6:2])
str = 'ay，呀当叮小来，nohtyP学'
new_str = str[::-1]
# print(new_str)
list = new_str.split('，')
print(list[1].replace('来', ''))

五、数据容器：set(集合)

集合的定义：

#>{元素,元素, ..., 元素}
# 定义集合变量
变量名称 = {元素, 元素, ..., 元素}
# 定义空集合 
变量名称 = set()

操作	说明
集合.add(元素)	集合内添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素
集合.clear()	将集合清空
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素<br/> 原有的2个集合内容不变
len(集合)	得到一个整数，记录了集合的元素数量

集合的特点：

可以容纳多个数据可以容纳不同类型的数据（混装）数据是无序存储的（不支持下标索引）不允许重复数据存在可以修改（增加或删除元素等）支持for循环

例：

my_list = ['111', '222', '333', '111', '333', 'itit', 'hehe', 'itit']
new_set = set()

for val in my_list:
    new_set.add(val)

print(new_set)

六、数据容器：dict(字典、映射)

字典的定义：同样使用{}，不过存储的元素是一个个的：键值对

注意：

使用{}存储原始，每一个元素是一个键值对每一个键值对包含Key和Value（用冒号分隔）键值对之间使用逗号分隔Key和Value可以是任意类型的数据（key不可为字典）Key不可重复，重复会对原有数据覆盖

提示：

键值对的Key和Value可以是任意类型（Key不可为字典）字典内Key不允许重复，重复添加等同于覆盖原有数据字典不可用下标索引，而是通过Key检索Value

dic = {
    '王': {
        '部门': '科技部',
        '工资': 3000,
        '级别': 1
    },
    '周': {
        '部门': '市场部',
        '工资': 5000,
        '级别': 2
    },
    '林': {
        '部门': '市场部',
        '工资': 7000,
        '级别': 3
    },
    '张': {
        '部门': '科技部',
        '工资': 4000,
        '级别': 1
    },
}

for key in dic:
    if dic[key]['级别'] == 1:
        dic[key]['级别'] += 1
        dic[key]['工资'] += 1000

print(dic)

到此这篇关于一文带你搞懂Python中的数据容器的文章就介绍到这了,更多相关Python数据容器内容请搜索易采站长站以前的文章或继续浏览下面的相关文章希望大家以后多多支持易采站长站！