python 元组、集合与字典

列表、元组、字符串属于序列，字典属于映射，集合不属于2者其中之一。
在序列中，每个元素都有编号。

1、元组（tuple）

与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容。

# 效率比列表效率高
# 1、创建
# 元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔，如下所示
# 2 、删除
# 元组中的元素不能被删除，我们只能删除整个元组,重新分配一个新的元组
# del Keyword
# 注意del是python关键字，就像def、and、or一样。它不是字典、列表的方法，但是可以用来删除字典、列表的元素

t1 = ()
print(t1)
t2 = (1, 3, 5)
print(t2)
# list->tuple
t3 = tuple([x for x in range(4) if x % 2 == 0])
print(t3)
t4 = tuple("abc")
print(t4)
t5 =("abc","def","ghi")
print(t5)
del t5
print(t5)

# 输出：
# ()
# (1, 3, 5)
# (0, 2)
# ('a', 'b', 'c')
# ('abc', 'def', 'ghi')
# NameError: name 't5' is not defined

# 推导
s={i:"{} squared is {}".format(i,i**2) for i in range(10)}
print(s[0])  # 0 squared is 0

还有一些序列的函数，len(),min(),max()

2、集合

可以存储不同类型元素，除了列表外都是哈希的

# 2、集合
# 只存储 key，集合的元素是不重复，不是按任何的特定顺序放置
# 集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数，以创建集合 s 为例
s1 = set()
print(s1)

s2={1,3,4}
print(s2)

# tuple->set
s3=set((1,3,5))
print(s3)

# list->set
s4=set([x for x in range(5)])
print(s4)

# 字符串的字符成为元素
s5=set("abac")
print(s5)

# set()
# {1, 3, 4}
# {1, 3, 5}
# {0, 1, 2, 3, 4}
# {'b', 'c', 'a'}

2.1、操作和访问集合

in 或not in 判断是否元素在集合

s1 = {2,3,5}

# 添加元素可以使用 add ，如果元素已经存在，则不进行操作
s1.add(6)
print(s1)

print(max(s1))

print(5 in s1)

s1.remove(2)
print(s1)
s1.remove(0)  # 如果移除不存在的元素，则会报错，抛异常
print(s1)


# 结果：
# {2, 3, 5, 6}
# Traceback (most recent call last):
# 6
# File "F:/PycharmWorkPlace/Try/excercise.py", line 13, in <module>
# True
# {3, 5, 6}
# s1.remove(0)  # 如果移除不存在的元素，则会报错，抛异常
# KeyError: 0

# 使用update(s)添加元素
s1=set("abc")
s1.update("d")
print(s1)

# 使用clear方法，清空
s1.clear()
print(s1)

2.2、子集和超集

s1 = {1, 2, 3}
s2 = {1, 3, 4, 5, 2, 6}
print(s1.issubset(s2))   # 判断s1是不是s2的子集
print(s1.issuperset(s2))
# True
# False

2.3、判断元素是否完全相同

s1 = {1, 2, 3}
s2 = {1, 3, 2}
print(s1 == s2)  # True
print(s1 != s2)

2.4 操作符含义

s1是s2的真子集=》s1<s2
s1是s2的子集=》s1<=s2
s1是s2的真超集=》s1>s2

2.5、集合运算

并集 交集 差集 异或

# 并集 union 或 |
s1 = {1, 2, 3}
s2 = {3, 4, 5}
s = s1.union(s2)
print(s)
S = s1 | s2
print(S)
# 输出
# {1, 2, 3, 4, 5}
# {1, 2, 3, 4, 5}

# =====================
# 交集 intersection 或&
s1 = {3, 2, 4}
s2 = {2, 3, 9, 10}
s = s1.intersection(s2)
print(s)
S = s2 & s1
print(S)
# 输出
# {2, 3}
# {2, 3}

# =====================
# 差集 set1中有，set2无 difference() 或 s1-s2
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s = s1.difference(s2)
print(s)
S = s1 - s2
print(S)
# 输出
# {1}
# {1}
# =====================
# 异或 symmertric_difference 或 ^
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s = s1.symmetric_difference(s2)
print(s)
S = s1 ^ s2
print(S)
# 输出
# {1, 4}
# {1, 4}

2.6、总结集合与列表性能

对于in、not in 、remove，集合效率较高
集合不支持下标运算符

查找、删除元素，集合快

import random
import time

NUMBER_OF_ELEMNTS = 10000

# create a list
lst =list(range(NUMBER_OF_ELEMNTS))
random.shuffle(lst)
# create a set
s = set(lst)

# test if in list
startTime = time.time()
for i in range(NUMBER_OF_ELEMNTS):
    i in lst
endTime = time.time()
print("Test time of find element in list :", int((endTime - startTime) * 1000))

# test if in set
startTime = time.time()
for i in range(NUMBER_OF_ELEMNTS):
    i in s
endTime = time.time()
print("Test time of find element in set :", int((endTime - startTime) * 1000))

# test time delete list
startTime = time.time()
for i in range(NUMBER_OF_ELEMNTS):
    lst.remove(i)
endTime = time.time()
print("Test time of delete element in list :", int((endTime - startTime) * 1000))

# test time delete set
startTime = time.time()
for i in range(NUMBER_OF_ELEMNTS):
    s.remove(i)
endTime = time.time()
print("Test time of delete element in set :", int((endTime - startTime) * 1000))

# 单位：毫秒 测试结果：
# Test time of find element in list : 735
# Test time of find element in set : 0
# Test time of delete element in list : 373
# Test time of delete element in set : 0

3、字典

3.1、创建：

# dict 拥有良好的查询速度，dict 中的值可以是任意 Python 对象，多次对一个 key 赋 value，后面的 value 会把前面的 value 覆盖。
# 字典的内容在花括号 {} 内，键-值（key-value）之间用冒号 : 分隔，键值对之间用逗号 , 分隔，比如创建字典 d，如下所示：
# 1.创建字典

# 表示格式 d = {'name': '小明', 'age': '18'}

# 使用 dict 函数
# 方式一
l = [('name', '小明'), ('age', 18)]
d = dict(l)
print(d)

# 方式二
d = dict(name='小明', age='18')
print(d)

# 空字典
d = dict()
d = {}
print(d)    # {}

3.2、访问、添加、修改

# 字典中的值通过 key 进行访问
d = {'name': '小明', 'age': '18'}
print(d["name"])
print(d.get("age"))

# 添加操作
d["address"] = "中国"  # 如果有这个Key，则newValue取代oldValue
print(d)  # {'name': '小明', 'age': '18', 'address': '中国'}

# 修改操作
d["name"] = "朱小明"
print(d)

# 删除操作 del
del d["age"]
print(d)

# 清空操作
d.clear()
print(d)

# update() 添加字典
people = {'Alice': {'phone': '1234', 'addr': '中国'},
          'Beth': {'phone': '2344', 'addr': '巴西'}}
labels = {'phone': 'phone number', 'addr': "address"}
people.update(labels)
print(people)
#{'Alice': {'phone': '1234', 'addr': '中国'}, 'Beth': {'phone': '2344', 'addr': '巴西'}, 'phone': 'phone number', 'addr': 'address'}

3.3、遍历

students = {"1801": "孙悟空", "1802": "猪八戒", "1803": "唐僧", "1804": "沙和尚"}
for key in students:
    print(key, ":", students[key])

字典可以使用== ，！=来判断是否元素相同
也可以用 in ,not in 判断是否存在
不可以用<,>,<=,>=等进行比较，因为条目没有顺序

students = {"1801": "孙悟空", "1802": "猪八戒", "1803": "唐僧", "1804": "沙和尚"}
print(students.keys()) #dict_keys(['1801', '1802', '1803', '1804'])

3.4、dict 的其他函数

# keys():tuple 返回的是序列，用tuple表示
# values():tuple 返回一个由字典中的值组成的字典视图，可能重复
# items():tuple
# clear():None
# get(key):value
# get(key) 访问不存在的key时，不会报错，返回None
# get(key,defaultValue) 查询不到回复defaultValue
# setdefault()如果查询不到，就添加指定的键-值对
# pop(key):value
# popitem():tuple 方法随机返回并删除字典中的最后一对键和值。
# 如果字典已经为空，却调用了此方法，就报出KeyError异常。
students = {"1801": "孙悟空", "1802": "猪八戒", "1803": "唐僧", "1804": "沙和尚"}
print(tuple(students.keys()))
print(tuple(students.values()))
print(tuple(students.items()))
print(students.get("1804"))
students.pop("1801")
print(students)
students.popitem()
print(students)

d={}
print(d.setdefault("name","value"))     # value
print(d)    # {'name': 'value'}

d={}
print(d.get('name'))    # None
print(d.get('name','It is not available'))#It is not

boys=['aman','banc','cadf']
girls=['cafe','abe','baw']
letterGirls={}
for girl in girls:
    letterGirls.setdefault(girl[0],[]).append(girl)
    # 创建一个以girl首字母为key，值为girl的元组
team=[b+'+'+ g for b in boys for g in letterGirls[b[0]]  ]
print(team)

3.5、复制

# 1、copy 浅复制  deepcopy 深复制
from copy import deepcopy
x={"username":"a","machine":['1','2','3']}
y=x.copy()
z=deepcopy(x)
x['machine'].remove('2')
print(y)    # {'username': 'a', 'machine': ['1', '3']}
print(z)    # {'username': 'a', 'machine': ['1', '2', '3']}

# 2、fromkeys 创建空字典
x=dict.fromkeys(['name','key'])
y=dict.fromkeys(['name','key'],'(unknown)')
print(x)        # {'name': None, 'key': None}
print(y)        # {'name': '(unknown)', 'key': '(unknown)'}

3.6、字典格式化：

​​参考资料链接​​

student = {'name': '小明', 'class': '20190301', 'score': 597.5}
s1 = '{st[class]}班{st[name]}总分：{st[score]}'.format(st=student)
print(s1)  # 20190301班小明总分：597.5

student = {'name': '小明', 'class': '20190301', 'score': 597.5}
print('{classno} 班 {name} 同学,小名：{name}，总分:{score}'.format(classno=student['class'], name=student['name'],score=student['score']))
# 20190301 班 小明 同学,小名：小明，总分:597.5


# 1、    调用方法从format改成了format_map；
# 2、    格式化字符串从“变量[键]”值方式变成了“键”方式；
# 3、    format_map的参数不需传入“关键字=真实值”，而是直接传入真实的字典值。
student = {'name': '小明', 'class': '20190301', 'score': 597.5}
s1 = '{class}班{name}总分：{score}'.format_map(student)
print(s1)
# 20190301班小明总分：597.5

4、实例：

4.1、用字典存储，用列表排序

# 实例：统计文件中单词出现次数，字典有的出现+1，没有的添加字典+1，出现次数，由高到低显示
# 用字典存储，用列表排序
def main():
    readFromText()


def readFromText():
    filename = input("Enter a filename").strip()  # C:\Users\Lenovo\Desktop\1.txt
    infile = open(filename, "r")
    wordCounts = {}
    for line in infile:
        processCount(line.lower(), wordCounts)

    # 排序
    lst = list(wordCounts.items())
    newLst = [[x, y] for (y, x) in lst]  # 2维的列表

    newLst.sort()

    for i in range(len(newLst) - 1, len(newLst) - 11, -1):
        print(newLst[i][1], "--", newLst[i][0])

    infile.close()


# count words
def processCount(line, wordCounts):
    line = replacePunctuation(line)
    words = line.split()  # 列表
    for word in words:
        if word in wordCounts:
            wordCounts[word] += 1
        else:
            wordCounts[word] = 1


# replace punctuation in the line with space
def replacePunctuation(line):
    for ch in line:
        if ch in "~!@#$%^&*()_+{}[]|\"';:?/>.<,":
            line = line.replace(ch, " ")
    return line


main()

4.2实例：简单的数据库

# 字典简单数据库
people = {'Alice': {'phone': '1234', 'addr': '中国'},
          'Beth': {'phone': '2344', 'addr': '巴西'}}
label = {'phone': 'phone number', 'addr': "address"}
name = input("Enter a name")
if name in people:
    request = input("phone number (p) or address(a)")
    if request == 'p':
        key = 'phone'
    else:
        key = 'addr'
        print("{}'s {} is {}".format(name, label[key], people[name][key]))

4.3 改进的简单数据库

# 字典简单数据库
people = {'Alice': {'phone': '1234', 'addr': '中国'},
          'Beth': {'phone': '2344', 'addr': '巴西'}}
labels = {'phone': 'phone number', 'addr': "address"}
name = input("Enter a name")
request = input("phone number (p) or address(a)")
key=request
if request == 'p':
    key = 'phone'
if request=='a':
    key = 'addr'

person=people.get(name,{})
label=labels.get(key,key)
result=person.get(key,"is not available")
print("{}'s {} is {}".format(name,label,result))

5、reverse()和reversed()

• reverse()：–该方法是对原来list内存的修改
  是python中列表的一个内置方法（也就是说，在字典，字符串或者元组中，是没有这个内置方法的），用于列表中数据的反转；
• reversed()：–python内建函数，返回一个新的对象
  作用：反向迭代序列
  而reversed()是python自带的一个方法
  translate it :
  reverse（sequence） - >反转迭代器的序列值
  返回反向迭代器
  也就是说，在经过reversed()的作用之后，返回的是一个把序列值经过反转之后的迭代器，所以，需要通过遍历，或者List,或者next()等方法，获取作用后的值

a=[1,3,5,7]
print(list(reversed(a)))
print(a)

b=(1,2,3,4)
print(tuple(reversed(b)))
print(b)

d=[1,2,4,5]
print(d[::-1])
print(d)

6、sorted(key,reverse)

–作用于任何序列，总是返回一个有序序列

a=[1,10,9,7]
print(list(sorted(a)))
print(a)

b=(1,8,5,4)
print(tuple(sorted(b)))
print(b)

sorted()中的key可以是str.lower

# 元组排序可通过list函数将元组转换成列表，采用列表排序方法
# 1、最简单的排序，sort()对列表直接排序，返回None
a=[2,1,4]
a.sort()
print(a)
# b=a.sort() b=None

# 2、y关联到x的副本,y排序后,x不变化--y=x.copy()
a=[2,1,3]
b=a.copy()
b.sort()
print(a)
print(b)

# 3、获取排序后的副本  sorted(x)--sorted()的reverse参数接受False 或者True 表示是否逆序
a=[1,3,2]
b=sorted(a)
print(a)
print(b)


# 4、sort()不能对dict字典进行排序--sorted()
# 4.1对dict排序默认会按照dict的key值进行排序，最后返回的结果是一个对key值排序好的list
a={"1":"a","3":"b","0":"c"}
b=sorted(a)
print(a)    # {'1': 'a', '3': 'b', '0': 'c'}
print(b)    # ['0', '1', '3']

# 4.2、对dict的value值排序
a={"1":"a","3":"z","0":"d"}
b=sorted(a,key=lambda x : a[x])
print(b)        # ['1', '0', '3']

# 5、对多层列表排序
list=[('b',6),('a',1),('c',3),('d',4)]
list.sort(key=lambda x:x[1])
print(list)     # [('a', 1), ('c', 3), ('d', 4), ('b', 6)]


# 5.1 对列表的第二个元素排序后，再对第一个元素排序
list=[('b',1),('a',1),('c',3),('d',4)]
list.sort(key=lambda x:(x[1],x[0]))
print(list)     # [('a', 1), ('b', 1), ('c', 3), ('d', 4)]


# 6 key=str.lower指 把字符串按小写格式排序
b=sorted("aBc",key=str.lower)
print(b) #['A', 'B', 'C']