元组

概念

元组:由一系列变量组成的不可变序列容器

序列：支持索引和切片

不可变：1.没有增删改的方法
            2.所有的操作都不会直接作用于原数据

定义

<span style="font-size: 16px;" data-mce-style="font-size: 16px;">元组        tuple        ()

#1.定义多个数据的元组
tuple1 = (1,2.9,"3",[1,2,3],5)
tuple2 = 1,2.9,"3",[1,2,3],5
print(tup;e2) #(1,2.9,"3",[1,2,3],5)
print(type(tuple2)) #class tuple

#2.定义单个数据的元组---&gt;单个数据后需要加逗号
#如果不加逗号,当前变量与元素的类型一致
tuple3 = （"2.3",）
print(tuple3) #("2.3")s索引<br></span>

 索引

1 tuple1 = (1,2.9,"3",[1,2,3],5)
2 #索引
3 #元组[索引]
4 #从左往右，从0开始，从右往左，从-1开始
5 print(tuple1[3]) #[1,2,3]
6 print(tuple1[-3]) #"3"

 切片

tuple1 = (1,2.9,"3",[1,2,3],5)

#切片
#元组[开始下标:结束下标:步长]
#1.取头不取尾
#2.步长不写默认为1，步长可以是正负数
#3.下标可以正负数混搭
#4.[:m] 从开头取到下标为m的前一位
#5.[n:] 从下标为n的位置取到最后
#6.[:] [::] 取整个元组
#7.[::-1] 反转
print(tuple1[1:4])
print(tuple1[-4:-1])
print(tuple1[1:-1])
print(tuple1[-4:4])
print(tuple1[:3])
print(tuple1[3:])
print(tuple1[:])
print(tuple1[::])
print(tuple1[::-1])

查询方法

index（）：统计元素在元组中第一次出现的位置的下标：如果元素不存在则报错
count（）：统计元素在元组中出现的次数：如果元素不存在则返回0

补充方法

tuple = ("hello",26,37,8,54,12,"hello",8,9)

#补充方法：

#len（）
#语法：len（数据）
#作用：统计数据的长度：统计数据中元素的个数（集合具有唯一性）
print（len（tuple））

#in
#语法：元素 in 集合
#作用：判断元素是否在集合中存在，如果存在则返回True，否则返回False
print（540 in tuple）# False

#not in 
#语法：元素 not in 集合
#作用：判断元素是否不在集合中存在，如果不存在则返回True，否则返回False
print（540 not in tuple） #True

#+
#元组 + 元组
tuple1 = (4,5,6)
print(tuple+tuple1)

#*
#元组 * 数字
print(tuple1*3)

循环遍历元组

#循环遍历元组

tuple = （”玛卡巴卡“，”唔西迪西“）

#for 循环
#for 临时变量 in 循环遍历：
#      代码块

for i in tuple：
    print（i）

#while循环--->索引的范围： 0~len（）-1
#初始值
#while 循环条件：
#    代码块
#    步长

num = 0
while num<= len(tuple)-1:
    #通过索引取值    元组[索引]
    print（tuple[num]）
    num += 1

集合

概念 

由一系列不可变不重复的数据组成的可变容器

集合中只能存放不可变的数据类型的数据：整型、浮点型、字符串、元组

唯一性：集合中的元素具有唯一性，集合中的数据会自动被去重

无序性：集合中的元素具有无序性，不支持索引切片操作

可变：1.有增删方法
         2.所有的操作会直接作用于原数据


集合为什么没有修改方法？
        修改的思路：通过索引找到要修改的数据，重新赋值
        
        集合具有无序性：无法定位到要修改的数据的位置，集合没有修改的方法

定义

集合        set         {}


#1.定义有数据的集合
set1 = {1，2.6，”3“，（1，2，3），6，6，1，”3“}
print（set1）
print（type（set1））


#2.定义空集合--->构造法        本质是数据类型转换    set（）
str1 = ”“
list = []
tuple1 = （）
set1 = set（）
print（set1）

增加数据的方法

#集合增加数据的方法

set1 = {1，2，3}

#add（）
#语法：集合.add（不可变数据）
#作用：将数据作为一个整体添加到集合中
set1.add（10）
set1.add（5.6）
set1.add（”hello“）
set1.add（（1，2，3））
print（set1）

#update（）
#语法：集合.update（可迭代对象）
#作用：将可迭代对象中的元素进行拆分，添加到集合中；要求可迭代对象中的元素必须是不可变数据
set1.update（”hello“）
print（set1）

删除数据的方法

# 集合删除数据的方法

set1 = {"hello",26,37,87,54,12,70,8,9}

# pop
# 语法：集合.pop()
# 作用：随机删除集合中的一个元素
set1.pop()
print(set1)

# remove
# 语法：集合.remove(元素)
# 作用：从集合中删除指定元素；如果元素不存在则报错
set1.remove(700)
print(set1)

#discard
#语法：集合.discard（元素）
#作用：从集合中删除指定元素：如果元素不存在不报错也不做任何删除操作
set.discard（870）
print（set1）

# clear
# 语法：集合.clear()
# 作用：清空集合，集合仍然存在
set1.clear()
print(set1)

# del
# 语法：del 集合
# 作用：删除整个集合，集合不存在；
del set1
print(set1)

补充方法

set1 = {"hello",26,37,8,54,12,"hello",8,9}

# 补充方法：

# len()
# 语法：len(数据)
# 作用：统计数据的长度；统计数据中元素的个数(集合具有唯一性)
print(len(set1))

# in
# 语法：元素 in 集合
# 作用：判断元素是否在集合中存在，如果存在则返回True，否则返回False
print(540 in set1)

# not in
# 语法：元素 not in 集合
# 作用：判断元素是否不在集合中存在，如果不存在则返回True，否则返回False
print(540 not in set1)

 交集和并集

set1 = {1，2，3，4，5}
set2 = {4，5，6，7，8}

#交集    &    交叉重合的部分数据
print（set1&set2）#（4，5）

#并集    |    将多个集合中的数据合并到一起（集合具有唯一性）
print（set1|set2）#（1，2，3，4，5，6，7，8）

字典

概念 

由一系列键值对组成的可变映射容器


键值对：
可变：1.有增删改方法   
         2.所有的操作会直接作用于原数据

映射：键与值一一对应的关系

定义

字典        dict        {}


#定义字典

#1.直接定义字典
#语法：{键：值，键：值}--->键与值之间使用冒号隔开：键值对与键值对之间用逗号隔开
#键-key：name、age、height、address        键不重复且不可变：不可变的数据类型：整型、浮点型、字符串、元组；
#值-value：张三、18、189、北京某桥东下        值支持所有的数据类型
#键值对-item：”name“：”张三“
dict1 = {”name“：”张三“，”age“：18，”height“：18.9，（”address“）：[”北京“]}
print（dict1）
print（type（dict1））


#2.构造法--->本质通过数据类型转换        dict（键=值，键=值）
dict2 = dict（name=”李四"，gender=“女”，age=16）
print（dict2）
print（type（dict2））

增加和修改方法

dict1 = {”name“：“张三”，“age”：18}

#规则：有则修改，无则增加

#增加方法 修改方法
#语法：字典名[键] = 值
dict["phone"] = 110

删除方法

#删除方法


#1.clear（）
#语法：字典名.clear（）
#作用：清空字典，字典仍然存在
dict1.clear（）
print（dict1）


#2.del
#语法：del 字典名            del 字典名[键]
#作用：删除字典，字典不存在；删除指定键对应的键值对
del dict1[”name“]
print(dict1)

查询方法

dict1 = {”name“：”张三“，”age“：18}

#查询--->只能通过键找值，不能值找键

#1.直接查询
#语法：字典名[键]
#作用：通过键找值，如果键不存在则报错
print（dict1["age"]）


#2.get()
#语法：字典名.get(键,默认值)
#作用：通过键找值，如果键不存在则返回None；可以给不存在的键设置默认值
print（dict1.get（”age“，110））

字典常用方法⭐

#字典常用方法

dict1 = {“name”：“张三”，“age”：18}


#keys（）
#语法：字典名.keys（）
#作用：以列表的形式获取字典中所有的值
print（dict1.keys）

#values（）
#语法：字典名.values（）
#作用：以列表的形式获取字典中所有的值
print（dict1.values（））

#items（）
#语法：字典名.items（）
#作用：以列表的形式返回所有的键值对；键与对应的值存放在一个元组中，多个元组存放在列表中
print（dict1.items（））

循环遍历字典

#循环遍历字典

dict1 = {“name”：“张三”，“age“：18}


#循环遍历获取字典中所有的键-->同时可以获取值
for i in dict1.keys（）：
    print（i，dict1[i]）

#循环遍历获取字典中所有的值
for i in dict1.values（）:
    print（i）

#循环遍历获取字典中的键值对
#[("name","张三")("age",18)]
#使用一个临时变量接收结果    i就是元组（键，值）
for i in dict1.items():
    print(i)

#使用两个临死变量接收结果        i接收所有的键，j接收所有的值
for i,j in dict1.items（）：
    print（j）