一、元组 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)

三、集合

数据形式

{数据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

字典的数据修改和添加