Python入门笔记—第五章【元祖tuple，集合set，字典dict】

第五章：元祖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"])

结果：
None
1
100
然后报错

- fromkeys，使用制定的序列作为键，使所有键的键值都为一个值

a = {"one", "two", "three"}

#此处应注意fromkeys两个参数的类型
#必要要注意fromskeys调用的主体，dict
a = dict.fromkeys(a,"hhhhhhhh")
print(a)

结果：

{'two': 'hhhhhhhh', 'three': 'hhhhhhhh', 'one': 'hhhhhhhh'}