python字典相乘_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()

{1, 2, 3, 4, 5}

{}

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)

结果：

dict_items([('one', 1), ('two', 2), ('three', 3)])dict_keys(['one', 'two', 'three'])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'}