一、元组 tuple
数据形式
(数据1,数据2，数据3.....)
元组数据是不可修改，数据是有序的，支持下标获取数据
无法增加,修改，删除数据,只能进行数据查询
1-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))
1-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)
1-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','北京','23123@qq.com']
2-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])
2-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)
2-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)
2-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)
2-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}
不重复的无序数据
集合的主要场景是去重
3-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)
3-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集合后最将重复数据去除
四、公共方法
4-1 容器类型之间的转化
str(数据) 将数据转为字符串
list(数据) 将数据转为列表
set(数据)将数据转为集合tuple(数据) 将数据转为元组
# 容器类型之间的转化
data_str = 'itcast'
data_list = ['hadoop','hive','spark','python','list','python']
data_tupe = ('hadoop','hive','spark','python','tuple','hadoop')
data_set = {'hadoop','hive','spark','python','set'}
# 字符串
print(list(data_str))
print(tuple(data_str))
print(set(data_str))
# 元组操作
print(str(data_tupe))
print(list(data_tupe))
print(set(data_tupe))
# 列表
print(str(data_list))
print(tuple(data_list))
print(set(data_list))
4-2 运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
+ | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典,集合 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典，集合 |
# + *
data_str1 = 'itcast'
data_str2 = 'python'
data_list1 = ['a', 'b']
data_list2 = ['c', 'd']
data_tuple1 = ('w', 'q')
data_tuple2 = ('e', 'f')
data_set1 = {1, 2, 3}
data_set2 = {4, 5, 6}
data_dict1 = {'id': 1, 'name': '张三'}
data_dict2 = {'id': 2, 'name': '李四'}
# + 运算符
data_str1_str2 = data_str1 + data_str2 # 字符串+ 是拼接字符串
print(data_str1_str2)
data_list1_list2 = data_list1 + data_list2 # 列表+ 合并列表数据
print(data_list1_list2)
data_tuple1_tuple2 = data_tuple1 + data_tuple2 # 元组+ 合并元组数据
print(data_tuple1_tuple2)
# 集合数据不支持 + 运算
# data_set1_set2 = data_set1+data_set2
# print(data_set1_set2)
# 字典不支持+运算
# * 运算符 数据 * 数值
data_str1_new = data_str1 * 3
print(data_str1_new)
data_list1_new = data_list1 * 3
print(data_list1_new)
data_tuple1_new = data_tuple1 * 3
print(data_tuple1_new)
# 集合和字典不支持 * 运算符
# data_set1_new = data_set1 * 3
# print(data_set1_new)
# 判断元素是否在容器内
if 'i' in data_str1:
print('在字符串中')
else:
print('不在字符串中')
if 'a' in data_list1:
print('在列表中')
else:
print('不在列表中')
if 'a' in data_set1:
print('在集合中')
else:
print('不在集合中')
# 判断key是否在字典中
if 'id' in data_dict1:
print('key在列表中')
else:
print('key不在列表中')
4-3 通用函数
| 编号 | 函数 | 描述 | 支持的容器类型 |
|---|---|---|---|
| 1 | len() | 计算容器中元素个数 | 字符串、列表、元组、字典，集合 |
| 2 | del | 删除 | 列表和字典 |
| 3 | max() | 返回容器中元素最大值 | 列表、元组、字典.values()，集合 |
| 4 | min() | 返回容器中元素最小值 | 列表、元组、字典，集合 |
| 5 | sum() | 求和 | 列表、元组、字典，集合 |
| 6 | count() | 统计元素在容器内出现的次数 | 字符串、列表、元组、 |
| 7 | enumerate() | 给容器显式增加下标值，主要是在for循环场景中 | 字符串、列表、元组、字典，集合 |
# 容器通用函数
data_str = 'itcast'
data_list = ['hadoop','spark','python','list','python']
data_tuple = ('hadoop','hive','spark','python','tuple','hadoop')
data_set = {'hadoop','hive','spark','python','set','presto','doris'}
data_dict = {'id':1,'name':'张三'}
# len 计算容器元素的个数
print(len(data_str))
print(len(data_list))
print(len(data_tuple))
print(len(data_set))
print(len(data_dict))
# count 统计元素在容器内出现的次数
print('--------count--------------')
num = data_str.count('t')
print(num)
num2 = data_list.count('hadoop')
print(num2)
num3 = data_tuple.count('hadoop')
print(num3)
# 集合和字典不支持count方法
# num4 = data_set.count('hadoop')
# print(num4)
# 统计字典中value值出现次数
value_data = data_dict.values()
print(list(value_data).count('张三'))
# max min sum 处理数值数据
print('---------max----------')
data_list2 = [1,22,15,3]
data_tuple2 = (15,10,33,6)
data_set2 = {28,9,15,12}
data_dict2 = {'id':1,'age':20}
print(max(data_list2))
print(max(data_tuple2))
print(max(data_set2))
print(max(data_dict2.values()))
print('------min-----')
print(min(data_list2))
print(min(data_tuple2))
print(min(data_set2))
print(min(data_dict2.values()))
print('-----sum-----------')
print(sum(data_list2))
print(sum(data_tuple2))
print(sum(data_set2))
print(sum(data_dict2.values()))
print('--------平均数----------')
print(sum(data_list2)/len(data_list2))
# 元素数据的删除
print('--------------del------')
# del data_str[0]
# print(data_str)
print(data_list)
del data_list[0]
print(data_list)
# print(data_tuple)
# del data_tuple[0]
# print(data_tuple)
print(data_dict)
del data_dict['id']
print(data_dict)
# enumerate枚举方法的使用
# 容器可以通过for循环遍历数据
data_str = 'pyhton'
for i in data_str:
# 在遍历数据时，只会获取到每个元素数据，无法获取对应的下标值
print(i)
# 使用枚举方法获取对应数据的下标值
for i in enumerate(data_str):
print(i)
data_list = ['hadoop','spark','hive','python','java']
for i in enumerate(data_list):
print(i)
data_tuple = ('flink','presto','kafka','doris','hdfs')
for i in enumerate(data_tuple):
print(i)
data_set = {'es','ds','yarn','mr','hdfs'}
for i in enumerate(data_set):
print(i)
print(type(i))
data_dict = {'id':1,'name':'张三'}
for i in enumerate(data_dict):
print(i)
五、推导式
使用一行代码生成对应容器数据
列表推导式
字典推导式
-
生成一个1-100列表数据
-
[1,2,3,4,5,6,7,8,9,10,.......]
-
# 列表推导式
# 生成1--100的列表数据
data_list =[]
for i in range(1,101):
data_list.append(i)
print(data_list)
# 列表推导式 使用一行代码实现列表生成
# [添加的值 值处理的逻辑]
print([i for i in range(1,101)])
-
字典推导式
-
将符合kv数据结构改成字典类型
-
{k:v}
-
-
data_str = 'id=1;name=张三;age=20;gender=男'
# {'id':1,'name':'张三','age':20,'gender':'男'}
# 1-现将kv结构的数据进行拆分一个个单独元素 id=1 name=张三
data_split = data_str.split(';')
# 2-将kv数据进一步拆分得到key值和value值
data_dict = {}
for data in data_split:
key = data.split('=')[0]
value = data.split('=')[1]
# 3-将数据添加到字典
data_dict[key] = value
print(data_dict)
# 字典推导式 使用一行代码
# {k:v kv数据的处理逻辑}
print({data.split('=')[0]:data.split('=')[1] for data in data_str.split(';')})
容器数据中使用最多的容器是 字符串，列表，字典
字段的split和replace
字典的数据修改和添加
扫一扫
311
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
