字典及集合基础知识

字典

1.引入

1.当列表的元素顺序打乱，在不知道指定元素序列时，更改对应元素信息相对麻烦

2.当列表多层嵌套时，想要遍历所有数据，同样相对麻烦

2.格式

由若干组键(key)值(value)对组成，用’’{ }’'包裹的数据，键(key)不能重复(重复时后面的key会覆盖前面的)，值(value)可以重复。值(value)可以取任意数据类型，键(key)必须为不可变数据类型即键必须可哈希(不可变)。

dic={key1:value1,key2:value2...,keyb:veluen}
info = {'id':2111,'name':'bob','age':13}

• 字典是列表以外Python中使用最灵活的内置数据类型
• 字典是一种可变类型
• 字典与列表的区别
  • 列表有序，字典无序
  • 列表通过索引访问元素，字典通过键(key)访问元素
• 特点
  • key:value,键值对之间必须以冒号连接
  • key:value,组成字典的一个元素
  • 键值对之间以’’,’'隔开

3.创建

#####空字典#####
dic={}
print(type(dic))
<class 'dict'>。。
#####多元素字典#####
info = {'id':2111,'name':'bob','age':13}
print(len(info))
print (info['name'])
3
bob
#####强转#####
dic=dict(id=2011,name='black',age=16)
print(dic)
{'id': 2011, 'name': 'black', 'age': 16}
dic=dict(id=2011,name='black',age=16)
print(dic)
zip()
key =('id','name','age')
value=(2019111,'tom',18)
tp=zip(key,value)
print(tp,type(tp))
print(dict(tp),(type(dict(tp))))

<zip object at 0x03A02030> <class 'zip'>
{'id': 2019111, 'name': 'tom', 'age': 18} <class 'dict'>
#####通过fromkeys#####
dict.fromkeys(seq(键值),value(默认值None))
b=dict.fromkeys('hapy','1234')
a=dict.fromkeys([1,2,3],'a')
print(b)
print(a)

{'h': '1234', 'a': '1234', 'p': '1234', 'y': '1234'}
{1: 'a', 2: 'a', 3: 'a'}

注: dict 强转时，转入的参数必须是单元素，所以要用列表元组嵌套

4.常见操作

增

• 直接添加键值对(dic[key]=value)

  通过使用 变量名[‘键’]=‘值’

  • 如果key不存在，添加键值对
  • key存在，则更新值

dic={}
print(dic)
dic['id']=2011659
dic['name']='Tom'
dic['age']=10
print(dic)
 
{}
{'id': 2011659, 'name': 'Tom', 'age': 10}

• dict1.update(dict2)

  把字典dict2中的键值对(key:value)更新到dict1中

  • 如果两个字典的键完全不同，则将dict2的键值对全部添加到dict1中
  • 如果存在相同的键，则更新到dict1中

dict1={'name':'tom','age':145,'id':3167888}
dict2={'age':28,'job':'IT'}
print(dict1,dict2)
dict1.update(dict2)
print(dict1)
结果
{'name': 'tom', 'age': 145, 'id': 3167888} {'age': 28, 'job': 'IT'}
{'name': 'tom', 'age': 28, 'id': 3167888, 'job': 'IT'}

删

• dict1.pop,格式：dict1.pop(key)

  • 如果key存在,删除并返回对应dict1[key] (value值)

  • 如果key不存在,如果给定默认值则返回默认值,否则报错

dict1={'id':123456,'name':'bob','job':'IT','age':16}
print(dict1.pop('id'),'\n',dict1,sep='')
print(dict1.pop('from','china'),'\n'，dict1,sep='')
结果
123456 
{'name': 'bob', 'job': 'IT', 'age': 16}
china 
{'name': 'bob', 'job': 'IT', 'age': 16}

• popitem():随机删除一个键值对,返回该键值对的元组(由于字典自身无序,故删除当前字典最后一个键值对)

dict1={'id':123456,'name':'bob','job':'IT','age':16}
print(dict1.popitem())
print(dict1)
结果
('age', 16)
{'id': 123456, 'name': 'bob', 'job': 'IT'}

• clear()清空字典、del 删除整个字典 del dict[key]删除对应键的键值对

改

• 通过key值,修改对应的value值. dict[key]=value(键不存在时即添加该键值对)
• dict.setdefault()
  • 键存在，不改动,返回该键原本对应的值
  • 键不存在,添加该键值对返回对应值

f=lambda x:print(x)
dic={'a':1,'b':2}
f(dic.setdefault('a',333))
f(dic.setdefault('c',3))
结果
1
3

查

• 字典值的访问

  • 直接输入键访问对应的值(value),当键不存在会报错

  • dict.get()

    dict.get(key),同样时通过key值访问对应的value值,当key值不存在时不会报错

• 遍历

  • dict.keys()

    返回所有的键(key)

  • dict.values()

    返回所有的值(value)

  • dict.items()

    返回所有的键值对

    dic={'a':1,'b':2,'c':3,'d':4,'e':5}
    for key in dic.keys():
        print(key,end=' ')
    print()
    for value in dic.values():
        print(value,end=' ')
    print()
    for item in dic.items():
        print(item,end=' ')
    print()
    for key,value in dic.items():
        print(key,value)
    结果
    a b c d e 
    1 2 3 4 5 
    ('a', 1) ('b', 2) ('c', 3) ('d', 4) ('e', 5) 
    a 1
    b 2
    c 3
    d 4
    e 5

集合

1.特点

无序、元素不可重复、内部元素可哈希(不可改变,故诸如列表等不能成为集合的元素),集合本身是不可哈希的(可改变),用{}包裹的数据集

2.用途

• 去重(列表=>集合，自动去重)
• 关系测试(子集、并集等)

3.集合的创建

• 空集合 s=set() ##{}表示空字典

• 多元素的集合创建

• 强转 #将字典转化成集合是只取其键,字符串、元组、列表转化成集合时会去重

  s=set()
  print(s,type(s))
  st={1,2,3,2,'a'}
  li=[1,1,1,12,3,4,5,6]
  print(type(st),st)
  print(set(li))
  结果
  set() <class 'set'>
  <class 'set'> {1, 2, 3, 'a'}
  {1, 3, 4, 5, 6, 12}

4.基本操作

改、查

由于其无序和元素可哈希，故无法改、查 #注:可以遍历集合、判断某元素是否存在于集合

增

• set.add() 将元素添加进集合
• set1.upate(set2)将另一个集合(set2)导入该集合(set1)

删

• set.pop(),删除排序最小的一个元素,返回该元素
• set.discard(),删除指定元素,元素不存在不会报错
• set.remove(),删除指定元素，元素不存在会报错
• del set,set.clear(),清空集合,和将整个集合删除

遍历

元素遍历、枚举(enumerate)遍历

st={1,2,3}
for i in st:
    print(i)
for i in enumerate(st):
    print(i)
结果
1
2
3
(0, 1)
(1, 2)
(2, 3)

基本运算

• 子集

  a={1,2,3}
  b={1,2}
  print(b.issubset(a))
  print(b<a)
  结果
  True
  True

• 交集(∩) intersection() a&b

a={1,2,3}
b={4,5,3}
print(a.intersection(b))
{3}

• 并集(∪) union() a|b

a={1,2,3}
b={4,5,3}
print(a.union(b))
{1, 2, 3, 4, 5}

• 差集 set.diffence() a-b

  a={1,2,3}
  b={4,5,3}
  print(a.difference(b))
  print(a-b)
  {1, 2}
  {1, 2}

补充

根据 id 找对应元素

import ctypes
t = 变量值
t1 = ctypes.cast(id(t), ctypes.py_object).value
######变量为列表时#####
import ctypes
t=[1,2,3,4]
print(id(t),id([1,2,3,4]))
t1 = ctypes.cast(id(t), ctypes.py_object).value
print(t,t1)
print(id(t),id([1,2,3,4]),id(t1))
结果
3388200 46765880
[1, 2, 3, 4] [1, 2, 3, 4]
3388200 17967224 3388200
列表可变,且不会内存缓存
#####变量为字符串时#####
import ctypes
t='1234aaa'
print(id(t),id('1234aaa'))
t1 = ctypes.cast(id(t), ctypes.py_object).value
print(t,t1)
print(id(t),id('1234aaa'),id(t1))
结果
16780448 16780448
1234aaa 1234aaa
16780448 16780448 16780448
字符串不可变,能进行内存缓存

map函数

• 描述

  map(function, iterable, …)会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

• 参数

  • function – 函数

  • iterable – 一个或多个序列

• 返回值

  • Python 2.x 返回列表。
  • Python 3.x 返回迭代器。

>>> a=[1,2,3,4,5]
>>> list(map(str,a))
['1', '2', '3', '4', '5']
>>> list(map(lambda x:x*x,a)) ###lambda为匿名函数返回x的平方
[1, 4, 9, 16, 25]

getpass 函数

• 不显示明文(在密码输入时,更加安全).

  import getpass
  id=input('请输入id:')
  password=getpass.getpass(input('请输入密码:'))

快速生成一个字母、数字的列表(或其他类型)

import string
alpha=list(string.ascii_letters)
nums=list(string.digits)
print(alpha)
print(nums)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

string 中的ascii_uppercase 、ascii_letters分别代表所有大写字母和小写字母