키별로 사전을 정렬하려면 어떻게 해야 합니까?
키를 기준으로 사전을 정렬하려면 어떻게 해야 합니까?
입력 예:
{2:3, 1:89, 4:5, 3:0}
원하는 출력:
{1:89, 2:3, 3:0, 4:5}
참고: Python 3.7+의 경우 다음 답변을 참조하십시오.
Python 3.7 Python. 값)해도 (키, 값)에 할 수 dict질서를 유지할 수 있는 방법으로요
가장 쉬운 방법은 요소를 삽입한 순서를 기억하는 를 사용하는 것입니다.
In [1]: import collections
In [2]: d = {2:3, 1:89, 4:5, 3:0}
In [3]: od = collections.OrderedDict(sorted(d.items()))
In [4]: od
Out[4]: OrderedDict([(1, 89), (2, 3), (3, 0), (4, 5)])
은 마세요.od출력됩니다.예상대로 동작합니다.
In [11]: od[1]
Out[11]: 89
In [12]: od[3]
Out[12]: 0
In [13]: for k, v in od.iteritems(): print k, v
....:
1 89
2 3
3 0
4 5
파이썬 3
3 Python 3을 ..items().iteritems():
In [13]: for k, v in od.items(): print(k, v)
....:
1 89
2 3
3 0
4 5
사전 자체에는 정렬된 항목이 없습니다. 인쇄를 원하는 경우 다음과 같은 예를 들 수 있습니다.
Python 2.4 이상에서는:
mydict = {'carl':40,
'alan':2,
'bob':1,
'danny':3}
for key in sorted(mydict):
print "%s: %s" % (key, mydict[key])
다음과 같은 기능이 있습니다.
alan: 2
bob: 1
carl: 40
danny: 3
(피톤 2.4 미만:)
keylist = mydict.keys()
keylist.sort()
for key in keylist:
print "%s: %s" % (key, mydict[key])
출처 : http://www.saltycrane.com/blog/2007/09/how-to-sort-python-dictionary-by-keys/
CPython/PyPy 3.6 및 Python 3.7 이상의 경우 다음을 사용하여 쉽게 수행할 수 있습니다.
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> dict(sorted(d.items()))
{1: 89, 2: 3, 3: 0, 4: 5}
Python 라이브러리 설명서:
>>> from collections import OrderedDict
>>> # regular unsorted dictionary
>>> d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}
>>> # dictionary sorted by key -- OrderedDict(sorted(d.items()) also works
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
>>> # dictionary sorted by value
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
>>> # dictionary sorted by length of the key string
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])
정렬된 순서대로 키를 자동으로 유지하는 사전 구현을 제공하는 많은 Python 모듈이 있습니다.순수 Python 및 Fast-as-C 구현인 sorted containers 모듈을 고려합니다.또, 다른 일반적인 옵션과의 퍼포먼스 비교도 실시합니다.
반복하면서 키/값 쌍을 계속 추가 및 제거해야 하는 경우에는 순서가 지정된 dict를 사용하는 것이 적절하지 않습니다.
>>> from sortedcontainers import SortedDict
>>> d = {2:3, 1:89, 4:5, 3:0}
>>> s = SortedDict(d)
>>> s.items()
[(1, 89), (2, 3), (3, 0), (4, 5)]
SortedDict 유형은 기본 제공 dict 유형으로는 불가능한 인덱스 위치 조회 및 삭제를 지원합니다.
>>> s.iloc[-1]
4
>>> del s.iloc[2]
>>> s.keys()
SortedSet([1, 2, 4])
심플:
d = {2:3, 1:89, 4:5, 3:0}
sd = sorted(d.items())
for k,v in sd:
print k, v
출력:
1 89
2 3
3 0
4 5
Python 사전은 Python 3.6 이전에 정렬되지 않았습니다.Python 3.6의 CPython 구현에서는 사전이 삽입 순서를 유지합니다.Python 3.7부터는 언어 기능이 될 것입니다.
Python 3.6의 changelog(https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict):
이 새로운 구현의 순서 유지 측면은 구현의 세부 사항으로 간주되어 신뢰할 수 없습니다(이는 미래에 변경될 수 있지만 현재 및 미래의 모든 Pytho에 대해 순서 유지 시멘틱스를 의무화하는 언어 사양을 변경하기 전에 몇 가지 릴리스에서 이 새로운 dict 구현을 언어로 하는 것이 좋습니다).n 구현. 또한 Python 3.5와 같은 랜덤 반복 순서가 여전히 유효한 이전 버전의 언어와의 하위 호환성을 유지하는 데 도움이 됩니다.
Python 3.7 문서(https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries):
사전에서 목록(d)을 수행하면 사전에서 사용된 모든 키의 목록이 삽입 순서대로 반환됩니다(정렬하려면 정렬(d)을 사용하십시오).
따라서 이전 버전과 달리 Python 3.6/3.7 이후에 딕트를 정렬할 수 있습니다.내부 하위 딕트를 포함하여 중첩된 딕트를 정렬하려면 다음을 수행할 수 있습니다.
test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}
def dict_reorder(item):
return {k: dict_reoder(v) if isinstance(v, dict) else v for k, v in sorted(item.items())}
reordered_dict = dict_reorder(test_dict)
https://gist.github.com/ligyxy/f60f0374defc383aa098d44cfbd318eb
다른 사람들이 언급했듯이, 사전은 본질적으로 순서가 없다.다만, 사전이 순서대로 표시되었을 뿐이라면, 이 문제를 덮어쓸 수 있습니다.__str__를 사용하여 제공이 아닌 이 합니다.dict ㅇㅇ.
class SortedDisplayDict(dict):
def __str__(self):
return "{" + ", ".join("%r: %r" % (key, self[key]) for key in sorted(self)) + "}"
>>> d = SortedDisplayDict({2:3, 1:89, 4:5, 3:0})
>>> d
{1: 89, 2: 3, 3: 0, 4: 5}
저장되어 , 등,되는지, 키가 어떻게 표시되는지에 되지 않습니다print비단뱀
다른 방법을 찾았습니다.
import json
print json.dumps(d, sort_keys = True)
삭제:
1.합니다(@ 감사합니다 1. 중첩된 오브젝트는 정렬됩니다(@DanielF
가 없기 2. python 사전은 인쇄 str.2. python 이 가능합니다.
간단한 방법:
d = {2:3, 1:89, 4:5, 3:0}
s = {k : d[k] for k in sorted(d)}
s
Out[1]: {1: 89, 2: 3, 3: 0, 4: 5}
Python 3에서는.
>>> D1 = {2:3, 1:89, 4:5, 3:0}
>>> for key in sorted(D1):
print (key, D1[key])
주다
1 89
2 3
3 0
4 5
여기에는 이미 Python 사전을 정렬하는 인기 있는 방법들을 보여주는 많은 답변들이 있다.비표준적인 아이디어를 찾고 있는 구글에서 여기로 오는 사람들을 위해 몇 가지 덜 분명한 방법을 더 추가하려고 합니다.
딕셔너리: sample플 sample sample :d = {2: 'c', 1: 'b', 0: 'a', 3: 'd'}
사전 이해
# Converts to list, sorts, re-converts to dict
{k: v for k, v in sorted(list(d.items()))}
람다 사용
정렬이 항상 오름차순 또는 내림차순으로만 정렬되는 것은 아닙니다.보다 조건부 정렬을 위해서는 위의 방법을 라마와 조합하여 사용하십시오.
{k: v for k, v in sorted(d.items(), key=lambda v: ord(v[1]))}
기타 예
이 스레드는 이미 좋은 예시로 가득 차 있습니다.엣지 케이스나 기호에 대해서는, Python 의 사전 정렬에 관한 이 기사를 참조해 주세요.
질문에 따라 키별로 현재 사전을 정렬하여 새 사전을 만들 수 있습니다.
이것은 당신의 사전입니다.
d = {2:3, 1:89, 4:5, 3:0}
람다 함수를 사용하여 이 d를 정렬하여 새 사전 d1 만들기
d1 = dict(sorted(d.items(), key = lambda x:x[0]))
d1은 d의 키를 기준으로 정렬된 {1:89, 2:3, 3:0, 4:5}이어야 합니다.
간단한 .pprint예:
>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99}
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}
그러나 pprint를 사용하는 동안 정렬된 dict가 반환됩니다.
>>> import pprint
>>> pprint.pprint(x)
{'a': 10, 'az': 99, 'b': 30, 'cd': 20}
사전을 분류하는 쉬운 방법이 있다.
당신의 질문에 따르면,
해결책은 다음과 같습니다.
c={2:3, 1:89, 4:5, 3:0}
y=sorted(c.items())
print y
(여기서 c는 사전 이름입니다.)
이 프로그램은 다음과 같은 출력을 제공합니다.
[(1, 89), (2, 3), (3, 0), (4, 5)]
네가 원하던 대로.
또 다른 예는 다음과 같습니다.
d={"John":36,"Lucy":24,"Albert":32,"Peter":18,"Bill":41}
x=sorted(d.keys())
print x
출력을 제공합니다.['Albert', 'Bill', 'John', 'Lucy', 'Peter']
y=sorted(d.values())
print y
출력을 제공합니다.[18, 24, 32, 36, 41]
z=sorted(d.items())
print z
출력을 제공합니다.
[('Albert', 32), ('Bill', 41), ('John', 36), ('Lucy', 24), ('Peter', 18)]
키, 값, 아이템으로 변경함으로써 원하는 대로 인쇄할 수 있습니다.이게 도움이 됐으면 좋겠네요!
사전을 정렬하기 위해 찾은 간단한 방법은 정렬하려는 사전의 key:value 항목을 기준으로 새 사전을 만드는 것입니다.「」를 .dict = {} 항목을 해, 「」를 합니다.sorted()그런 다음 새 사전을 만듭니다.
다음은 사전 이해를 사용한 코드입니다.
sorted_dict = {k:v for k,v in sorted(dict.items())}
원하는 대로 정확하게 생성:
D1 = {2:3, 1:89, 4:5, 3:0}
sort_dic = {}
for i in sorted(D1):
sort_dic.update({i:D1[i]})
print sort_dic
{1: 89, 2: 3, 3: 0, 4: 5}
하지만 이것은 올바른 방법이 아닙니다. 왜냐하면 제가 최근에 배운 다른 사전에서 다른 행동을 보일 수 있기 때문입니다.그래서 팀 인은 내가 여기서 공유하고 있는 나의 질의에 대한 응답으로 완벽한 방법을 제안했습니다.
from collections import OrderedDict
sorted_dict = OrderedDict(sorted(D1.items(), key=lambda t: t[0]))
다음은 권장 솔루션의 성능입니다.
from collections import OrderedDict
from sortedcontainers import SortedDict
import json
keys = np.random.rand(100000)
vals = np.random.rand(100000)
d = dict(zip(keys, vals))
timeit SortedDict(d)
#45.8 ms ± 780 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
timeit sorted(d.items())
#91.9 ms ± 707 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
timeit OrderedDict(sorted(d.items(), key=lambda x: x[0]))
#93.7 ms ± 1.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
timeit dict(sorted(dic.items()))
#113 ms ± 824 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
timeit OrderedDict(sorted(dic.items()))
#122 ms ± 2.65 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
timeit json.dumps(d, sort_keys=True)
#259 ms ± 9.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
가장 쉬운 것은 키별로 dict를 정렬하고 정렬된 key:value 쌍을 새 dict에 저장하는 것이라고 생각합니다.
dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2}
dict2 = {} # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
if not key in dict2: # Depending on the goal, this line may not be neccessary
dict2[key] = dict1[key]
알기 쉽게 하기 위해:
dict1 = {'renault': 3, 'ford':4, 'volvo': 1, 'toyota': 2}
dict2 = {} # create an empty dict to store the sorted values
for key in sorted(dict1.keys()):
if not key in dict2: # Depending on the goal, this line may not be neccessary
value = dict1[key]
dict2[key] = value
한 줄짜리 구술이 떠올랐어요.
>> a = {2:3, 1:89, 4:5, 3:0}
>> c = {i:a[i] for i in sorted(a.keys())}
>> print(c)
{1: 89, 2: 3, 3: 0, 4: 5}
[Finished in 0.4s]
이것이 도움이 되기를 바랍니다.
Python dicts는 순서가 없습니다.일반적으로 이것은 문제가 되지 않습니다.왜냐하면 가장 일반적인 사용 사례는 조회를 하는 것이기 때문입니다.
할 수 있는 은 '만들다'를 입니다.collections.OrderedDict요소를 정렬된 순서대로 삽입합니다.
ordered_dict = collections.OrderedDict([(k, d[k]) for k in sorted(d.keys())])
위의 다른 제안과 같이 반복해야 하는 경우 정렬된 키를 반복하는 것이 가장 간단한 방법입니다.예-
키별로 정렬된 값 인쇄:
# create the dict
d = {k1:v1, k2:v2,...}
# iterate by keys in sorted order
for k in sorted(d.keys()):
value = d[k]
# do something with k, value like print
print k, value
키별로 정렬된 값 목록을 가져옵니다.
values = [d[k] for k in sorted(d.keys())]
이 함수는 키를 기준으로 사전을 재귀적으로 정렬합니다.즉, 사전의 값이 사전인 경우 해당 값도 키에 따라 정렬됩니다.CPython 3.6 이상에서 실행 중인 경우, 를 사용하기 위한 단순한 변경보다dict가 an an OrderedDict만들 수 있습니다.
from collections import OrderedDict
def sort_dict(d):
items = [[k, v] for k, v in sorted(d.items(), key=lambda x: x[0])]
for item in items:
if isinstance(item[1], dict):
item[1] = sort_dict(item[1])
return OrderedDict(items)
#return dict(items)
가장 간단한 해결책은 dict 키 목록이 정렬된 순서인 다음 dict를 반복하는 것입니다.예를들면
a1 = {'a':1, 'b':13, 'd':4, 'c':2, 'e':30}
a1_sorted_keys = sorted(a1, key=a1.get, reverse=True)
for r in a1_sorted_keys:
print r, a1[r]
출력은 다음과 같습니다(발주 예정).
e 30
b 13
d 4
c 2
a 1
질문의 공식화 방식에 대해서는 정답이 가장 많습니다.
그러나 컴퓨터 과학이 수십 년 동안 축적되어 온 것을 고려하면, 삽입 포인트에서 키를 기준으로 요소를 분류하는 정렬된 연관 컨테이너(정렬된 컨테이너)의 사용을 제안하는 답변은 실제로 여기(GrantJ 사용자로부터) 하나뿐이라는 것이 저의 완전한 놀라움으로 다가왔습니다.
이렇게 하면 콜마다 퍼포먼스에 큰 영향을 미치는 것을 피할 수고를 덜 수 있습니다.sort(...)(최소O(N*log(N)),어디에N요소의 수(이러한 경우, 이는 여기서의 모든 솔루션에 해당하며,sort(...)). 이러한 모든 솔루션에 대해sort(...)요소를 추가/제거하여 수정한 후 정렬된 상태로 콜렉션에 액세스해야 할 때마다 호출해야 합니다.
얘들아, 너 때문에 일이 복잡해지고 있어.정말 간단합니다.
from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)
출력은 다음과 같습니다.
{'A':2,'B':1,'C':3}
from operator import itemgetter
# if you would like to play with multiple dictionaries then here you go:
# Three dictionaries that are composed of first name and last name.
user = [
{'fname': 'Mo', 'lname': 'Mahjoub'},
{'fname': 'Abdo', 'lname': 'Al-hebashi'},
{'fname': 'Ali', 'lname': 'Muhammad'}
]
# This loop will sort by the first and the last names.
# notice that in a dictionary order doesn't matter. So it could put the first name first or the last name first.
for k in sorted (user, key=itemgetter ('fname', 'lname')):
print (k)
# This one will sort by the first name only.
for x in sorted (user, key=itemgetter ('fname')):
print (x)
dictionary = {1:[2],2:[],5:[4,5],4:[5],3:[1]}
temp=sorted(dictionary)
sorted_dict = dict([(k,dictionary[k]) for i,k in enumerate(temp)])
sorted_dict:
{1: [2], 2: [], 3: [1], 4: [5], 5: [4, 5]}
2.7의 두 가지 방법을 타이밍 비교한 결과, 두 가지 방법이 사실상 동일한 것으로 나타났습니다.
>>> setup_string = "a = sorted(dict({2:3, 1:89, 4:5, 3:0}).items())"
>>> timeit.timeit(stmt="[(k, val) for k, val in a]", setup=setup_string, number=10000)
0.003599141953657181
>>> setup_string = "from collections import OrderedDict\n"
>>> setup_string += "a = OrderedDict({1:89, 2:3, 3:0, 4:5})\n"
>>> setup_string += "b = a.items()"
>>> timeit.timeit(stmt="[(k, val) for k, val in b]", setup=setup_string, number=10000)
0.003581275490432745
「」를 사용합니다.pandas ,
데모:
>>> d={'B':1,'A':2,'C':3}
>>> df=pd.DataFrame(d,index=[0]).sort_index(axis=1)
A B C
0 2 1 3
>>> df.to_dict('int')[0]
{'A': 2, 'B': 1, 'C': 3}
>>>
참조:
l = dict.keys()
l2 = l
l2.append(0)
l3 = []
for repeater in range(0, len(l)):
smallnum = float("inf")
for listitem in l2:
if listitem < smallnum:
smallnum = listitem
l2.remove(smallnum)
l3.append(smallnum)
l3.remove(0)
l = l3
for listitem in l:
print(listitem)
언급URL : https://stackoverflow.com/questions/9001509/how-do-i-sort-a-dictionary-by-key
'programing' 카테고리의 다른 글
| IDEA 10.5 명령줄이 너무 깁니다. (0) | 2022.09.12 |
|---|---|
| 스태틱 범용 메서드를 호출 (0) | 2022.09.12 |
| MariaDB - 릴레이 로그 읽기 실패: 릴레이 로그 이벤트 항목을 구문 분석할 수 없습니다. (0) | 2022.09.12 |
| 다른 .py 파일에서 함수를 호출하려면 어떻게 해야 합니까? (0) | 2022.09.11 |
| SQL INSERT 문에 Python dict 사용 (0) | 2022.09.11 |