python 07 字典 集合

字典

key：value　　键:值　　映射，哈希值，关系（数组）

x=['1','2']

y=['a','b']

>>print(y[x.index('1')])

a

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

x.index('1') 　　0　　

y[0]　　　　　a

>>x={'1':'a','2':'b'}

>>print(x['1'])

a

>>dict1={1:'one',2:'two'}

>>dict1[2]　　　　　　[]中是key，而不是索引值

创建 {"one":1,"two":2,"three":3}

>>> a = dict(one=1, two=2, three=3)

>>> b = {'one': 1, 'two': 2, 'three': 3}

>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))

>>> d = dict([('two', 2), ('one', 1), ('three', 3)])　　　#　((()))

>>> e = dict({'three': 3, 'one': 1, 'two': 2})

>>> a == b == c == d == e

True

>>dict()　　　　创建新字典

{}

>>dict(one=1, two=2, three=3)

{"one":1,"two":2,"three":3}

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表

>>>a = [1,2,3]

>>> b = [4,5,6]

>>> zipped = zip(a,b)

>>> zipped

<zip object at 0x103abc288>

>>> list(zipped)

[(1, 4), (2, 5), (3, 6)]

>>dict1={1:'one',2:'two'}

>>> a = dict(one=1, two=2)　　#后面数字
>>> a
{'one': 1, 'two': 2}
>>> a= dict(1=one, 2=two)
SyntaxError: keyword can't be an expression

>>> a= dict(o='one', t='two')　　#后面字符串，要加' '
>>> a
{'o': 'one', 't': 'two'}

dict() 　　字符串=字符串或数字，不可以数字=

工厂函数（类型）　　int() str() dict() list()

Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

dict.fromkeys(seq[, value])

seq -- 字典键值列表。

value -- 可选参数, 设置键序列（seq）的值。

seq = ('Google', 'Runoob', 'Taobao')　　　#元组，列表，都可换成字典。若后无参数，默认None

dict = dict.fromkeys(seq) print "新字典为 : %s" % str(dict)

dict = dict.fromkeys(seq, 10) print "新字典为 : %s" % str(dict)

新字典为 : {'Google': None, 'Taobao': None, 'Runoob': None}

新字典为 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}

>>dict.fromkeys((1,3),'hi')

{1:'hi',3:'hi'}

>>dict1=dict.fromkeys(range(3),'hi')

{0:'hi',1:'hi',2:'hi'}

>>for a in  dict1.keys():

　　print(a)

0

1

2

>>for a in dict1.values():

　　print(a)

hi

hi

hi

>>for a in dict1.items():

　　print(a)

(0,'hi')

(1,'hi')

(2,'hi')

>>print(dict1[2])　　　　key

hi

>>dict1.get(2)

hi

>>3 in dict1

false

>>dict1.get(3,'no')　　　　#修改

no

clear() 函数用于删除字典内所有元素。

dict1.clear()

dict1={}　　　　也可用于清空字典内元素

缺点

a={1,2}

b=a　　　　a，b指向这个字典

a={}　　　　a清空

b={1,2}　　　　b不变

a.clear()　　　　a，b都为空

a={1:'hi',2'hi',3'hi'}

c=a　　　　赋值

b=a.copy　　　　浅拷贝　　　　

id(a) == id(c)　　　　a变时c也变

id(a) != id (b)　　　　a 变时b不变

a.pop(2)　　　key

{1:'hi',3'hi'}

a.popitem()　　　　随机弹出一个

(1,'hi')　　

Python 字典 setdefault() 函数和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

dict.setdefault(key, default=None)

key -- 查找的键值。

default -- 键不存在时，设置的默认键值。

a={1:'hi',2'hi',3'hi'}

print(a.setdefault(1))

hi

a.setdefault(4,'hi')

{1:'hi',2'hi',3'hi',4'hi'}

update() 函数把字典dict2的键/值对更新到dict里。

b={4,'hello'}

a.update(b)

{1:'hi',2'hi',3'hi',4'hello'}

集合　　无序（非序列）无索引

>>type(num1={})

divt

>>type(num2={1,2,3})

set

>>num2={1,1,2,3,3}

>>num2

{1,2,3}

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

set1=set([1,2,2,3])

{1,2,3}

>>>x = set('runoob')

>>> y = set('google')

>>> x, y

(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))

{'r', 'b', 'o', 'u', 'n'},{'g', 'e', 'l', 'o'}

>>> x & y # 交集

set(['o'])

{'o'}

>>> x | y # 并集

set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])

{'g', 'l', 'r', 'e', 'b', 'o', 'u', 'n'}

>>> x - y # 差集

set(['r', 'b', 'u', 'n'])

{'b', 'u', 'r', 'n'}

去掉重复数

num1=[1,2,2,3]

remp=[]

for a in num1:

　　if a not remp:

　　　　temp.append(a)

创建一个空列表，若空列表中没有的数，放到空列表中（避免重复）（顺序不变）

num1=list(set(num1))　　变集合，去掉重复，再变回列表（从小至大排序）

num1={1,2,3}

>> 1 in num1　　　　判断集合内是否有元素

true

>>num1.add(4)　　添加元素4

{1,2,3,4}

>>num1.remove(1)　　删除元素1

{2,3,4}

不可变集合

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>>a = frozenset(range(10))　　　　frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> a

frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

>>> b = frozenset('runoob')　　　　frozenset(['b', 'r', 'u', 'o', 'n'])

>>> b

frozenset({'r', 'b', 'o', 'u', 'n'})　　　　# 创建不可变集合