第五章：元祖tuple，集合set，字典dict
1.元祖—tuple（ ）
有序
可以访问，但是不能修改（指内容不可修改）
元祖数据可以是任意类型，如（1,2,"abc",'a',[1,2,3]）
列表list能用的操作，除了修改，元祖都能用，即索引，分片，相加，相乘等都能通用
1.1 常用操作
- 索引（和List相同）
a = (1,2,3,4,5)
print(a[4])
print(a[12]) #索引不可以超标
结果：5
报错
问题：为什么不能用 a = (i for i in range(1,5)),这个形式创建元祖？
- 切片
a = (1,2,3,4,5)
print(a[0:3])
print(a[0:100]) #切片可以超标
结果：
(1, 2, 3)
(1, 2, 3, 4, 5)
- 相加、相乘
a = (1,2,3,4,5)
b = (1,2,3)
c = a + b
d = a * 3
print(c)
print(d)
结果：
(1, 2, 3, 4, 5, 1, 2, 3)
(1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
- 遍历（单层）
a = (1,2,"aabbcc","ncu","dddaa")
for i in a:
print(i)
结果：
1
2
aabbcc
ncu
dddaa
- 遍历（双层）
a = ((1,2,3),("aa","bb","cc"),("dd",4,"ee"))
for i in a:
print(i)
for k,v,j in a:
print(k,v,j)
结果：
(1, 2, 3)
('aa', 'bb', 'cc')
('dd', 4, 'ee')
1 2 3
aa bb cc
dd 4 ee
1.2 常用函数
len、max、min 用法与列表list一致
count、index
a = (1,3,5,6,33,55,66,3,3)
print(a.count(3))
print(a.index(3)) #如果要索引的是多个值，则返回第一个值
- 其余列表list能用的函数，元祖tuple基本上都能通用
结果：
3
1
1.3 元祖没有内涵操作
即 a = (i for i in range(1,10))
会报错
1.4 附—两个变量交换
- C、JAVA、C++等语言的写法和Python写法的区别
a = 1
b = 3
#####C/C++/JAVA写法：
t = a
a = b
b = t
Python的写法：
a,b = b,a
2.集合—set{ }
和高中集合概念一致，即无序，值唯一
因为集合无序，值唯一，因此无法使用索引，分片，count等函数
2.1 集合的定义
- 两种方法
#第一种
a = set()
print(a)
print(type(a))
#第二种,其中大括号内一定要有值，否则定义的会是一个dict
a = {1,2,3,4,5,}
print(a)
print(type(a))
#大括号内没有值的情况
a = {}
print(a)
print(type(a))
结果：
set()
<class 'set'>
{1, 2, 3, 4, 5}
<class 'set'>
{}
<class 'dict'>
2.2 集合的特征
无序，即无法使用索引、分片、count等函数
唯一，可以利用该特征来排除重复值
a = {1,2,3,4,1,1,1,1,1}
print(a)
结果：
{1, 2, 3, 4}
- 集合内的数据只能放置可哈希的数据，如int、str、list、tuple、冰冻集合等
2.3 集合的遍历以及内涵
- 集合的遍历和内涵操作与列表list一致
a = {1,2,3,4,5,66,66,66,77,7,8,6,9,10}
print(a)
for i in a:
print(i,end = " ")
print(" ")
b = {i for i in a if i % 2 == 0}
print(b,end = " ")
结果：
{1, 2, 3, 4, 5, 66, 7, 8, 6, 9, 10, 77}
1 2 3 4 5 66 7 8 6 9 10 77
{2, 66, 4, 6, 8, 10}
2.4 关于集合的函数
len,max,min与列表list一直，不再重复
add,clear
#add,在集合内添加元素
a = {1,2,3}
print(id(a))
a.add(123)
print(id(a))
print(a)
#clrar，清空元素
a = {1,2,3}
print(id(a))
a.clear()
print(id(a))
print(a)
结果：#表明函数add和函数clear为原地操作
140431563811976
140431563811976
{123, 1, 2, 3}
140431563812648
140431563812648
set()
- pop,remove,discard
# pop，在列表list中是删除队尾的元素，一般伴随赋值操作，
# pop，在集合set中是随机删除一个元素
a = {1,2,3,4}
print(id(a))
a.pop()
print(a)
print(id(a))
结果：
140431563811976
{2, 3, 4}
140431563811976
在实际测试中，执行多次，但是函数pop删除元素并不随机，只是删除了元素1，是因为pop本身就不是随机删除还是因为丘比特笔记本的原因？有待深究
函数pop为原地操作
#remove,删除集合中特定的值，如果该值不存在于集合中则报错,原地操作
a = {1,2,3,44,55}
print(id(a))
a.remove(44)
print(id(a))
print(a)
#discard，删除集合中特定的值，与remove不同的是，如果该值不存在与集合中不会报错，原地操作
b = {11,22,33,44,55}
print(id(b))
b.discard(44)
print(id(b))
print(b)
b.discard(66)
print(id(b))
print(b)
结果：
140431702354856
140431702354856
{1, 2, 3, 55}
140431554061704
140431554061704
{33, 11, 22, 55}
140431554061704
{33, 11, 22, 55}
思考：为啥ｒｅｍｏｖｅ不存在的值会报ｋｅｙｅｒｒｏｒ？
- copy，与列表list操作一致，并且为浅拷贝，此处不重复
3 字典dict
没有顺序的组合数据，数据以键值对呈现
创建字典有很多种方法，一般情况下挑一种自己经常用的（第二种带冒号的），其余的自己能够认识就行
3.1 字典的创建方法
有以下几种常用的方法：
创建空字典
#创建空字典1
a = {}
print(a)
#创建空字典2
a = dict()
print(a)
结果：
{}
{}
- 创建有值的字典，一般情况下都用这种方法创建字典，简介
a = {"one":1,"two":2,"three":3}
print(a)
结果：
{'one': 1, 'two': 2, 'three': 3}
- 用dict创建有值字典1
a = dict({"one":1,"two":2,"three":3})
print(a)
结果：
{'one': 1, 'two': 2, 'three': 3}
- 用dict创建有值字典2,利用关键字参数
a = dict(one=1,two=2,three=3)
print(a)
结果：
{'one': 1, 'two': 2, 'three': 3}
- 用dict创建有值字典3
a = dict([(one,1),(two,2),(three,3)])
print(a)
结果：
{'one': 1, 'two': 2, 'three': 3}
3.2 字典特征
字典是无序的，因此没有分片和索引操作
-
字典中的数据没有都由键值对组成，即kv
key：必须是可哈希的值，如int,string,float,tuplle,但是list,set,dict不行
value:可以是任何值
3.3 字典常用操作
- 成员访问
#成员访问，括号内存放的是键值,访问的时候双引号""不能少
a = {"one":1,"two":2,"three":3}
print(a["one"])
#赋值操作
a["one"] = "enis"
print(a)
#删除成员，双引号不能少
del a["one"]
print(a)
结果：
1
{'one': 'enis', 'two': 2, 'three': 3}
{'two': 2, 'three': 3}
- 成员检测
#成员检测
a = {"one":1,"two":2,"three":3}
if "two" in a :
print("key")
if "2" in a:
print("value")
if ("two",2) in a:
print("kv")
结果：（说明成员检测时检测的是键值）
key
字典遍历，Python2和Python3不同，代码不通用，此处只讲Python3
按键值key遍历
#遍历
a = {"one":1,"two":2,"three":3}
for k in a:
print(k,d[k])
结果：
one 1
two 2
three 3
#上述代码可以改成以下形式
a = {"one":1,"two":2,"three":3}
for k in a.keys():
print(k,d[k])
结果：
one 1
two 2
three 3
- 只访问字典的值
a = {"one":1,"two":2,"three":3}
for v in a.values():
print(v)
结果：
1
2
3
- 注意以下特殊用法
a = {"one":1,"two":2,"three":3}
for k,v in a.items():
print(k,"———",v)
结果：
one ——— 1
two ——— 2
three ——— 3
3.4 字典生成式（字典内涵）
#
a = {"one":1,"two":2,"three":3}
aa = {k:v for k,v in a.items()}
print(aa)
#加限制条件的字典生成式
aaa = {k:v for k,v in a.items() if v % 2 == 0}
print(aaa)
结果：
{'one': 1, 'two': 2, 'three': 3}{'two': 2}
3.5 字典相关函数
len,max,min,clear等通用函数不再概述
str(字典)，返回字典的字符串格式
a = {"one":1,"two":2,"three":3}
print(str(a))
结果：
{'one': 1, 'two': 2, 'three': 3}
- items,keys,values
a = {"one":1,"two":2,"three":3}
# 返回字典键值对组成的元祖形式
i = a.items()
print(type(i))
print(i)
#返回字典键组成的一个结构
k = a.keys()
print(type(k))
print(k)
#返回字典值组成的一个结构
v = a.values()
print(type(v))
print(v)
结果：
<class 'dict_items'>dict_items([('one', 1), ('two', 2), ('three', 3)])<class 'dict_keys'>dict_keys(['one', 'two', 'three'])<class 'dict_values'>dict_values([1, 2, 3])
- get,根据制定键值返回相应的值，好处是可以设置默认值
a = {"one": 1, "two": 2, "three": 3}
#此处get默认值是None
print(d.get("one333"))
print(d.get("one"))
#此处将键one333的值设置成100
print(d.get("one333",100))
#此处并没有在字典a中增加one333这个键值对，因而会报错，仔细体会该条代码与上面代码的区别
print(d["one333"])
结果：None1100然后报错
- fromkeys，使用制定的序列作为键，使所有键的键值都为一个值
a = {"one", "two", "three"}
#此处应注意fromkeys两个参数的类型
#必要要注意fromskeys调用的主体，dict
a = dict.fromkeys(a,"hhhhhhhh")
print(a)
[图片上传中...(image-ece40-1538114686487-0)]
结果：
{'two': 'hhhhhhhh', 'three': 'hhhhhhhh', 'one': 'hhhhhhhh'}
