Python基础-容器数据

标签：容器 下标 Python data 列表 book print 数据

一、容器类型介绍

容器就是存放数据的

python 中的容器数据有多种形式，每种形式有自己的存储格式, 数据存储特性不一样

字符串 str 就是容器 存放一个一个字母 格式 : 单引号 '数据' ，双引号 "数据" ,三个引号 """ 数据 """

列表 list 格式: [数据1，数据2，数据3.....]

元祖 tuple 格式: (数据1，数据2，数据3，)

集合 set 格式: {数据1，数据2，数据3，}

字典 dict 格式: {key1:value1,key2:value....}

数据存储的特性

• 有序和无序

  • 有序： 字符串，列表，元祖，字典

  • 无序： 集合

• 数据重复性

  • 允许数据重复 字符串，列表，元祖,字典的value部分可以重复

  • 不允许重复 集合，字典的key值

• 数据是否允许修改

  • 允许修改 列表，字典value数据可以修改，

  • 不允许修改 字符串 ，元祖

常用的字符串，列表和字典

二、字符串

字符串就是有一个一个字母构成，使用引号包裹数据

data_str1 = '数据'
data_str2 = "数据"
data_str3 = '''数据'''

2-1 下标取值

在有序的容器中，会对数据的顺序进行编号，该编号就称为数据下标。可以通过下标取出对应位置中的数据

下标编号是从0开始

数据:i t c a s t

下标:0 1 2 3 4 5

字符串的下标取值

一次取出一个下标对应的数据

# 有序容器的下标取值
data_str = 'itcast'
​
# 下标取一个值
print(data_str[2])
切片

指定下标范围进行取值

[起始下标:结束下标] 下标的范围是左闭右开的，结束下标的值取不到

# 有序容器的下标取值
data_str = 'itcast'
​
# 下标取一个值
print(data_str[2])
​
# 下标取多个值 使用切片  [起始下标:结束下标]  取值范围也是左闭右开 结束下标的数据无法取到
print(data_str[1:4])
​
​
​
间隔步长取值

# 有序容器的下标取值
data_str = 'itcast'
​
# 下标取一个值
print(data_str[2])
​
# 下标取多个值 使用切片  [起始下标:结束下标]  取值范围也是左闭右开 结束下标的数据无法取到
print(data_str[1:4])
​
# 间隔取多个值  使用切片  [起始下标:结束下标:步长]
print(data_str[1:6:2]) # 起始从1开始  下一个值是 1+2=3   1+2+2=5

 

下标的其他操作

# 单个取值时超过下标值或报错
print(data_str[6])

# 切片进行多个数据取值超出下标，不会报错，将后面的数据全部取出
print(data_str[1:1000])
# 取值的下标可以是负数
print(data_str[-4:-2])

 

# 如果需要改变起始位置从右边开始，则需要将步长设置为-1
# 可以实现字符串的反转
print(data_str[-1:-7:-1])
# 需要获取所有的的字符可以省略起始和结束下标
print(data_str[::-1])

2-2 for循环取值

依次从字符串中取出每一个字母，该过程叫做数据遍历

# 遍历字符串数据
data = 'itcast'
for i in data:
    print(i)

2-3 函数方法

find 找字符在字符串中位置，返回对应的首字母的下标，数据不存在返回-1

# 字符串的函数操作方法
# 查找字符在字符串中的下标位置
data = 'itcast'
# num接收查找到的下标 如果存在返回对应位置下标，不存在返回-1
num = data.find('w')
print(num)
index 找字符在字符串中位置，返回对应的首字母的下标，数据不存在报错

num2 = data.index('w')
print(num2)
split 字符串的切割

切割后的数据会放入列表中返回

data_str = 'python,hadoop,spark,flink'
# split的切割字符串
res =  data_str.split(',')
print(res)
replace 字符串的替换，替换字符串中的数据

除了可以替换数据，还可以清洗数据

data_str2 = '2024-10-11'
# 字符串替换
res2 = data_str2.replace('-','/')
print(res2)
​
​
data_str3 = '机器哦@我觉得#千库网'
# 通过replace的替换去除特殊字符
res3 = data_str3.replace('@','').replace('#','')
print(res3)

三、列表

3-1 列表定义

语法格式

[数据1,数据2.....]

# 列表的定义及取值
# 在列表中可以定义指定多个数据内容，尽量保证数据类型一致
data_list = [1, 20, 33, 15, 18, 21]
data_list2 = ['spark', 'hadoop', 'flink', 'python']
data_list3 = [1, '张三', 20]

3-2 列表取值

可以通过下标和切片取值

for循环遍历取值

# 列表的定义及取值
# 在列表中可以定义指定多个数据内容，尽量保证数据类型一致
data_list = [1, 20, 33, 15, 18, 21]
data_list2 = ['spark', 'hadoop', 'flink', 'python']
data_list3 = [1, '张三', 20]
​
# 列表也是有序容器，所以支持下标取值
# 单个取值
print(data_list[1])
print(data_list2[2])
​
# 切片取多个值
print(data_list[1:5])
​
# 步长间隔取值
print(data_list[1:5:2])
​
# 循环遍历取值
for i in data_list3:
    print(i)
​
​
# 列表嵌套列表
data_list4 =[[1,2,3],['a','b','c']]
​
print(data_list4[1][0])

3-3 列表的增删改查方法

增加

• append

  • 常用来增加一个元素数据

• extend

  • 将另一个列表的数据合并当前列表

• insert

  • 指定下标位置增加数据

# 添加列表数据
data_book = []  # 定义一个空列表
# append添加数据，将数据添加到列表末尾
data_book.append('昆仑')
data_book.append('沧海')
data_book.append('五大贼王')
# 查看原始数据
print(data_book)
# insert 可以指定下标位置添加
data_book.insert(1, '青盲')
# 查看数据
print(data_book)
​
# extend将一个列表数据合并另一个列表中
data_book_new = ['大魔术师', '冒死记录']
data_book.extend(data_book_new)
print(data_book)
​
# 使用运算符 + 将列表合并
data_book_new2 = ['死亡通知单', '暗黑者', '摄魂谷', '凶画']
res = data_book + data_book_new2
print(res)
​

删除

• del 数据[下标] 删除指定下标的数据

• remove 删除列中指定的数据

• pop() 弹出列表中的数据，数据弹出后会从列表中删除

  • 默认从最后一个数据弹出

• clear() 清除所有列表中的数据，变成空列表

# 删除列表中的数据
data_book = ['诛仙','斗破苍穹','盗墓笔记','年少荒唐','极品家丁','坏蛋是怎么练成的']
​
# 通过指定下标删除
del data_book[3]
print(data_book)
# 指定数据删除
data_book.remove('极品家丁')
print(data_book)
# 弹出数据删除  将末尾数据弹出 可以定义接收变量，接收弹出的数据
res = data_book.pop()
print(data_book)
# 清空列表数据
data_book.clear()
print(data_book)

修改

• 指定下标对应的数据进行修改

  • 列表[下标] = 修改的值

• 列表数据的反转 修改顺序

• 排序

# 修改列表数据
data_book = ['紫川', '三重门', '从你的全世界路过', '梦里花落知多少']
​
# 通过下标修改数据
data_book[1] = '善恶的彼岸'
print(data_book)
​
# 列表反转
data_book.reverse()
print(data_book)
​
# 列表排序
data_list = [1,7,2,4,3]
data_list.sort(reverse=False)
print(data_list)
data_list.sort(reverse=True)
print(data_list)

查询

• index 查询数据在列表中的下标位置

• count 查询数据出现的次数

• in 查找数据是否在列表中

  • not in 不在列表中

• len 获取列表的元素个数

# 查询列表数据
data_book = ['道德的谱系','反基督','瞧,这个人','飞鸟集']
​
# index查询数据
num = data_book.index('反基督')
print(num)
# num = data_book.index('aa')
# print(num)
​
# count  统计数据出现次数
num2 = data_book.count('飞鸟集')
print(num2)
​
# 查询元素个数
num3 = len(data_book)
print(num3)
​
# 判断元素是否在列表中
if '道德的谱系' in data_book:
    print('数据在列表中')
    
# not in 是判断不在列表中

四、元组 tuple

数据形式

(数据1,数据2，数据3.....)

元组数据是不可修改，数据是有序的，支持下标获取数据

无法增加,修改，删除数据,只能进行数据查询

4-1 元组定义

# 元组定义
data_tuple1 = (1,2,3,4)
data_tuple2 = (1.2,2.34,3.15,4.26)
data_tuple3 = ('a','b','c','d')
data_tuple4 = (['asd','2213'],[123,3342])
data_tuple5 = ((12,345,74,21),('ndkla','123'))
print(data_tuple1)
print(data_tuple2)
print(data_tuple3)
print(data_tuple4)
print(data_tuple5)
​
# 元组只有一个元素数据时，需要加逗号
data_tuple6 = (10)
print(type(data_tuple6))
data_tuple7 = ('张三',)
print(type(data_tuple7))

4-2 元组数据取值

通过下标取值，或for循环遍历取值

元组数据不可修改，所以没有添加，删除，修改的方法

# 元组定义
data_tuple1 = (1,2,3,4)
data_tuple2 = (1.2,2.34,3.15,4.26)
data_tuple3 = ('a','b','c','d')
data_tuple4 = (['asd','2213'],[123,3342])
data_tuple5 = ((12,345,74,21),('ndkla','123'))
print(data_tuple1)
print(data_tuple2)
print(data_tuple3)
print(data_tuple4)
print(data_tuple5)
​
# 元组只有一个元素数据时，需要加逗号
data_tuple6 = (10)
print(type(data_tuple6))
data_tuple7 = ('张三',)
print(type(data_tuple7))
​
# 元组是有序数据，支持下标
print(data_tuple3[2])
print(data_tuple3[1:4])
​
# 容器都支持for循环取值
for i in data_tuple5:
    print(i)

4-3 元组数据查找

# 查找数据
i = data_tuple_str.index('python')
print(i)
​
# 查找出现的次数
num = data_tuple_str.count('a')
print(num)
​
​
# 计算元素个数
print(len(data_tuple_str))

元组的特性和字符串特性一样

但是元组能存储的数据类型比字符串多

五、字典 dict

字典数据格式

{k1:v1,k2:v2,k3:v3}

字典的本质就是给下标命名一个名字

user = [1,'张三',20,'男','篮球','1371111111','北京','[email protected]']

5-1 字典定义

# 字典定义
data_dict1 = {1:'hadoop',2:'python',3:'spark',4:'hadoop'}
data_dict2 = {'a':'hadoop','b':'python','c':'spark','d':'hadoop'}
print(data_dict1)
print(data_dict2)
# 字典中不要重复定义key值，保证key值唯一
data_dict3 = {'a':'hadoop','b':'python','c':'spark','a':'flink'}
print(data_dict3)
​
# 使用key的下标值进行value部分取值
print(data_dict1[2])
print(data_dict2['d'])
​
# 字典下标不支持切片操作
# print(data_dict1[1:4])

5-2 字典取值

字典的内容包含两部分 key 和 value

在字典取值时可以分别取出两部分的数据

• 取value部分的数据

  • 方式1 通过key取value 一次只能取一个value值

    • data[key]

    • data.get(key)

  • 方式二 获取所有的value值

    • data.values()

# 取字典的value值
data_dict2 = {'a':'hadoop','b':'python','c':'spark','d':'hadoop'}
​
# 通过key取value
# 使用[] 取值，如果key不存在会报错
res = data_dict2['a']
print(res)
# get取值时  key不存在会返回一个None值
res2 = data_dict2.get('z')
print(res2)
​
# 将字典中value值全部取出
res3 = data_dict2.values()
print(res3)

• 取key值部分

  • 获取所有key值

  • data.keys()

# 获取字典中的所有key值
res4 = data_dict2.keys()
print(res4)

5-3 字典的增加和修改数据

字典数据的增加和修改语法一样,针对va部分的数据进行增加和修改

data[key]=value 将key对应的value修改或增加新的值

key值不存在则是增加数据，key存在则是修改数据

# 增加或修改字典数据
data_dict = {'id':1,'name':'张三','age':20,'gender':'男'}
print(data_dict)
# key值存在，修改对应的value数据
data_dict['age'] = 22
print(data_dict)
​
# key不存在，则增加薪数据
data_dict['hobby'] = '篮球'
print(data_dict)

5-4 字典删除

del data[key]

# 删除字段数据
# 通过key确定删除的数据
data_dict = {'id':1,'name':'张三','age':20,'gender':'男'}
print(data_dict)
del data_dict['name']
print(data_dict)
​
# 清空数据
data_dict.clear()
print(data_dict)

5-5 for循环遍历

• 格式

  • 字典for循环需要配合items方法

for 变量1,变量2 in data_dict.items():
    变量1接收key值部分
    变量2接受value部分
# 字典的for循环遍历
data_dict = {'id':1,'name':'张三','age':20,'gender':'男'}
​
for k,v in data_dict.items():
    print(k,v)

小结

一个用户数据如何存储？

姓名：张三 年龄:20 体重(kg):60 性别：男

在单个数据存储时，建议使用字典，字典的key可以用来描述数据是什么

['张三',20,60,'男'] ('张三',20,60,'男')

{'name':'张三'，'age':20,'weight':60,'gender':'男'}

---

多个用户数据如何存储？

姓名：李四 年龄:50 体重(kg):50 性别：男

{'name':'李四'，'age':50,'weight':50,'gender':'男'}

---

({'name':'张三'，'age':20,'weight':60,'gender':'男'},{'name':'张三'，'age':20,'weight':60,'gender':'男'})

user_list = [{'name':'张三'，'age':20,'weight':60,'gender':'男'},{'name':'张三'，'age':20,'weight':60,'gender':'男'}]

user_list.insert(0，{})

user_list.append{{}}

元组不能添加新数据，列表可以添加的新的数据

实际开发中就使用字典和列表组合完成多个数据存储

[{第一条数据},{第二条数据},{第三条数据}.....]

# 字典和列表数据组合完成多条数据存储
user1 = {'name':'张三','age':20,'gender':'男'}
user2 = {'name':'李四','age':22,'gender':'男'}
user3 = {'name':'王五','age':21,'gender':'男'}
​
# 将多个用户数据保存在列表中
data_list = []
data_list.append(user1)
data_list.append(user2)
data_list.append(user3)
print(data_list)
​
# 对每个用户数据进行处理 增加一个体重信息
for user in data_list:
    print(user)
    # 用户增加数据
    if user['name'] == '张三':
        user['weight'] = 55
    elif user['name'] == '李四':
        user['weight'] = 60
    else:
        user['weight'] = 100
​
print(data_list)

六、集合

数据形式

{数据1，数据2，数据3}

不重复的无序数据

集合的主要场景是去重

6-1 集合的定义

# 集合的定义
data_set1 = {1,22,13,4}
data_set2 = {1.1,2.35,3.16,4.28}
data_set3 = {'a','b','c','s','a','a'}
# data_set4 = {['a','b'],['c','s']}
# data_set5 = {{'id':1,'name':'张三'},{'id':2,'name':'李四'}}
data_set6 = {(1,2,3),('a','b')}
# data_set7 = {{1,2,3},{'a','b','c'}}
print(data_set1)
print(data_set2)
print(data_set3)
# print(data_set4)
# print(data_set5)
print(data_set6)
# print(data_set7)

有序的数据可以通过下标和for循环取值

list[0]

str[0]

tuple[0]

dict[key]

无序数据只能通过for循环取值

# 集合取值
data_set_str = {'hadoop', 'hive', 'oozie', 'spark', 'python', 'hive'}
for i in data_set_str:
    print(i)

6-2 集合增删改

• 增加数据

  • add

• 删除

  • remove

  • clear

• 修改

  • update

  • 用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

# 增加的数据
data_set.add('hive')
print(data_set)
# 删除数据
data_set.remove('hadoop')
print(data_set)
# 更新数据
data_set.update(['flink222'])
print(data_set)

集合类型的数据主要作用时去重

将数据转为set集合后最将重复数据去除

标签：容器,下标,Python,data,列表,book,print,数据
From： https://blog.csdn.net/weixin_65434097/article/details/139225470