Python의 dict 사전 구조 작업 방법

이 글에서는 Python의 dict 사전 구조의 연산 방법을 주로 소개합니다. 사전의 연산은 Python 입문 학습을 위한 기본 지식입니다.

1. 방법

1. 새 사전 만들기

1) 빈 사전 만들기

>>> dict1={} 
>>> dict2=dict() 
>>> dict1,dict2 
({}, {})

2) 새 값 생성 시 값 초기화

>>> dict1={1:'a',2:'b',3:'c'} 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'}

3) 튜플 사용

>>> dict1=dict([(1,'a'),(2,'b'),(3,'c')]) 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'}

2. 획득 방법

1) get(key) 사전에서 키에 해당하는 값을 가져옵니다. 및 반환 값

>>> dict1={1:'a',2:'b',3:'c'} 
>>> dict1.get(1) 
'a'

사전에 없으면 NoneType

>>> type(dict1.get(4)) 
<type &#39;NoneType&#39;>

필요한 키 값이 존재하지 않는 경우 다른 값을 지정하여 반환

>>> dict1.get(4,'not found') 
'not found'

2), 키() 사전에 있는 모든 키 값을 가져오고 목록을 반환합니다

>>> dict1.keys() 
[1, 2, 3]

3), 값()은 해당 키() 메소드와 반환된 사전 모든 값 목록

>>> dict1.values() 
['a', 'b', 'c']

4), items()는 (key, value)

>>> dict1.items() 
[(1, 'a'), (2, 'b'), (3, 'c')]

5), iterkeys(), itervalues(), iteritems()도 각각 모든 키, 값, (키, 값) 프리미티브를 얻습니다. 그러나 더 이상 목록을 반환하지 않고 반복자

>>> for key in dict1.iterkeys(): 
 print key 
1 
2 
3

3. 사전 값 설정 방법

1) 직접 방식은

>>> dict1[4]='d' 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

그런데 이 방식은 제가 원하는 키값이 add가 이미 사전에 있으면 원본을 덮어쓰게 됩니다. value

>>> dict1[4]='e' 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'e'}

2), setdefault(key, value) 이 방법의 장점 삽입된 키가 사전에 없으면 이를 사전에 삽입하고 값을 반환하고, 그렇지 않으면 사전에 있으면 기존 값을 반환하고

을 덮어쓰지 않는다는 것입니다.

>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'e'} 
>>> dict1.setdefault(5,'f') 
'f' 
>>> dict1.setdefault(5,'g') 
'f' 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c', 4: 'e', 5: 'f'}

4. 사전 삭제

1) pop(key) 지정된 키의 항목을 삭제하고 삭제된 항목의 값을 성공적으로 반환합니다. 존재하지 않으면 예외가 발생하므로 이 방법을 사용할 때는 키가 존재하는지 판단하거나 이 예외를 잡아야 합니다

>>> def pop_key(d,key): 
 try: 
 d.pop(key) 
 print "sucess" 
 except: 
 print "key is not in dict" 
>>> dict1 
{1: 'a', 2: 'b'} 
>>> pop_key(dict1,3) 
key is not in dict

또는

>>> def sub_dict2(d,key): 
 if d.has_key(key): 
 d.pop(key) 
 print "sucess" 
 else:print "key is not in dict" 
 
>>> pop_key(dict1,3) 
key is not in dict

여기서 has_key(key)는 해당 키가 사전에 있는지 확인하는 것입니다. 대신 d에 키를 사용할 수도 있습니다

2) popitem()은 A(키, 값) 튜플을 삭제한다는 점을 제외하면 pop()과 유사합니다.

위 방법을 사용하면 다음과 같은 작업을 수행할 수 있습니다. 고급 사용법을 사용합니다

A. 2개의 목록을 통해 사전을 생성합니다. 첫 번째 목록은 모두 키이고 두 번째 목록은 모든 값입니다

>>> list1=[1,2,3] 
>>> list2=['a','b','c'] 
>>> dict1=dict(zip(list1,list2)) 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'}

B. 사전의 자식 찾기

>>> dict1 
{1: 'a', 2: 'b', 3: 'c'} 
>>> dict1=dict([(1,'a'),(2,'b'),(3,'c')]) 
>>> dict1 
{1: 'a', 2: 'b', 3: 'c'} 
>>> subkeys=[1,3] 
>>> def sub_dict(d,subkeys): 
 return dict([(k,d.get(k)) for k in subkeys if k in d]) 
 
>>> print sub_dict(dict1,subkeys) 
{1: 'a', 3: 'c'}

C. , 키는 새 사전의 값이 되고 값은 새 사전의 키가 됩니다. (값에 Repeat가 있는 경우 역방향 사전은 하나만 유지됩니다.

>>> def invert_dict(d): 
 return dict([(k,v) for v,k in d.iteritems()]) 
 
>>> print invert_dict(dict1) 
{'a': 1, 'c': 3, 'b': 2} 
>>>

5. 기타 기본 방법

1 ) has_key(key) 키가 사전에 있는지 확인

2) copy()는 a를 반환합니다. 사전 사본 (사본은 얕은 사본입니다)

>>> d2={1:[1],2:[2],3:[3]} 
>>> d3=d2.copy() 
>>> d3[1].append(4) 
>>> d2[1] 
[1, 4]

전체 복사를 하려면 copy.deepcopy(a)를 사용해야 합니다

>>> d2={1:[1],2:[2],3:[3]} 
>>> import copy 
>>> d3=copy.deepcopy(d2) 
>>> d3[1].append(4) 
>>> print d2[1] , d3[1] 
[1] [1, 4]

3) clear() dict 지우기

4) update(d)는 하나의 사전을 사용하여 다른 사전을 업데이트합니다. 이는 병합과 다소 유사합니다. 두 개의 사전

>>> dict1={1: 'a', 2: 'b', 3: 'c'} 
>>> dict2={1:'x',4:'y'} 
>>> dict1.update(dict2) 
>>> dict1 
{1: 'x', 2: 'b', 3: 'c', 4: 'y'} 
>>>

2.

사전

1. dict

>>> d 
{'a': 'aa', 'c': 'cc', 'b': 'bb'} 
>>> for i in d: 
 print i,d[i] 
 
a aa 
c cc 
b bb

2. items() 사용

>>> for i,v in d.items(): 
 print i,v 
 
a aa 
c cc 
b bb

물론 이렇게 할 수도 있습니다

>>> for (i,v) in d.items(): 
 print i,v 
 
a aa 
c cc 
b bb

이 두 가지 방법(괄호 포함 및 제외)의 효율성은 사전 크기가 200 이하일 때 괄호가 더 빠르며, 200 이상이면 괄호가 없을 때 속도가 조금 더 빠르다고 하는데 구체적으로 테스트하지는 않았습니다. .

3.iteritems()
(더 좋은 방법인 것 같아요)

>>> for k,v in d.iteritems(): 
 print k,v 
 
a aa 
c cc 
b bb

그 외도 있어요 순회 방법은 이 3개면 충분하다고 생각합니다

3. 약간의 고급 사용법

1. >

일반적으로 사전은 일대일 매핑이 이루어지지만 책과 같이 일대다 매핑이 ​​필요한 경우 일부 단어가 나타나는 페이지 수를 세어야 합니다. 그런 다음 list를 dict의 값으로 사용할 수 있습니다. 이는 setdefault() 메서드

>>> d={'hello':[1,4,9],"good":[1,3,6]} 
>>> d 
{'good': [1, 3, 6], 'hello': [1, 4, 9]} 
>>> d.setdefault('good',[]).append(7) 
>>> d 
{'good': [1, 3, 6, 7], 'hello': [1, 4, 9]} 
>>> d.setdefault('bad',[]).append(2) 
>>> d 
{'bad': [2], 'good': [1, 3, 6, 7], 'hello': [1, 4, 9]} 
>>>

를 사용하여 수행할 수 있습니다.

当然，如果写成一个函数话，就可以更方便的使用，
我们也可以利用set来代替list

>>> def addFunc(d,word,pag): 
 d.setdefault(word,set()).add(pag) 
>>> d={'hello':set([1,4,9]),"good":set([1,3,6])} 
>>> addFunc(d,'hello',8) 
>>> d 
{'good': set([1, 3, 6]), 'hello': set([8, 1, 4, 9])} 
>>> addFunc(d,'bad',8) 
>>> d 
{'bad': set([8]), 'good': set([1, 3, 6]), 'hello': set([8, 1, 4, 9])}

2、利用字典完成简单工厂模式
字典的value不单单只是一些常见的字符串，数值，还可以是类和方法，比如我们就可以这样来实现简单工厂模式

>>> class cat(object): 
 def __init__(self): 
 print 'cat init' 
>>> class dog(object): 
 def __init__(self): 
 print 'dag init' 
>>> d={'cat':cat,'dog':dog} 
>>> def factoryFunc(d,name): 
 if name in d: 
 return d[name]() 
 else: 
 raise Exception("error") 
>>> cat=factoryFunc(d,'cat') 
cat init

另外一个例子，利用变量来控制执行的函数

>>> def deal_cat(): 
 print 'cat run!!' 
 
>>> def deal_dog(): 
 print 'dag run!!' 
 
>>> d={'cat':deal_cat ,'dog':deal_dog } 
>>> animal='cat' 
>>> d[animal]() 
cat run!!

更多Python的dict字典结构操作方法相关文章请关注PHP中文网！