යතුරකින් ශබ්ද කෝෂයක් වර්ග කරන්නේ කෙසේද?

සිට යාමට හොඳ ක්‍රමයක් {2:3, 1:89, 4:5, 3:0}වන්නේ {1:89, 2:3, 3:0, 4:5}කුමක්ද?
මම සමහර පෝස්ට් පරික්ෂා කළ නමුත් ඒවා සියල්ලම භාවිතා කරන්නේ "වර්ග කළ" ක්‍රියාකරු ය.

සම්මත පයිතන් ශබ්දකෝෂ අනුපිළිවෙලට නොමැත. ඔබ (යතුර, අගය) යුගල වර්ග කළද dict, ඇණවුම ආරක්ෂා වන අයුරින් ඒවා ගබඩා කිරීමට ඔබට නොහැකි වනු ඇත.

පහසුම ක්‍රමය නම් භාවිතා කිරීමයි OrderedDict, එමඟින් මූලද්‍රව්‍ය ඇතුළත් කර ඇති අනුපිළිවෙල සිහිපත් වේ:

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 භාවිතා කරන්නන් සඳහා, .items()ඒ වෙනුවට භාවිතා කළ යුත්තේ .iteritems():

In [13]: for k, v in od.items(): print(k, v)
   ....: 
1 89
2 3
3 0
4 5

ශබ්ද කෝෂවලම ඇණවුම් කරන ලද අයිතම නොමැත, ඔබට ඒවා යම් අනුපිළිවෙලකට මුද්‍රණය කිරීමට අවශ්‍ය නම්, උදාහරණ කිහිපයක් මෙන්න:

පයිතන් 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/

සිට Python හි collectionsපුස්තකාල ප්රලේඛන :

>>> 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)])

CPython / PyPy 3.6 සහ ඕනෑම පයිතන් 3.7 හෝ ඊට වැඩි නම් මෙය පහසුවෙන් කළ හැකිය:

>>> d = {2:3, 1:89, 4:5, 3:0}
>>> dict(sorted(d.items()))
{1: 89, 2: 3, 3: 0, 4: 5}

යතුරු වර්ග කළ අනුපිළිවෙලින් ස්වයංක්‍රීයව නඩත්තු කරන ශබ්ද කෝෂ ක්‍රියාත්මක කිරීම් සපයන පයිතන් මොඩියුල ගණනාවක් තිබේ. පිරිසිදු-පයිතන් සහ සී-සී වේගයෙන් ක්‍රියාත්මක කරන වර්ග කළ බහාලුම් මොඩියුලය සලකා බලන්න . එකිනෙකාට එරෙහිව මිණුම් සලකුණු කර ඇති වෙනත් ජනප්‍රිය විකල්ප සමඟ සැසඳීමේ කාර්ය සාධනයක් ද ඇත .

යතුරු / අගය යුගල නැවත එකතු කිරීමට සහ ඉවත් කිරීමට අවශ්‍ය නම් ඇණවුම් කරන ලද නියෝගයක් භාවිතා කිරීම ප්‍රමාණවත් නොවේ.

>>> 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 වර්ගය සුචිගත කරන ලද ස්ථාන සොයා බැලීමට සහ බිල්ට් ඩික්ට් වර්ගය සමඟ කළ නොහැකි මකාදැමීමට සහය දක්වයි.

>>> 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

අනෙක් අය සඳහන් කර ඇති පරිදි, ශබ්දකෝෂ සහජයෙන්ම අනුපිළිවෙලට නොමැත. කෙසේ වෙතත්, ගැටළුව හුදෙක් ඇණවුම් කරන ලද ශබ්දකෝෂයක් ප්‍රදර්ශනය කරන්නේ නම් , ඔබට මෙම __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. මෙය කැදැලි වස්තු ද වර්ග කරයි (ස්තූතියි an ඩැනියෙල් එෆ්).
2. පයිතන් ශබ්දකෝෂ අනුපිළිවෙලට සකස් කර ඇති බැවින් මෙය මුද්‍රණය කිරීම සඳහා සුදුසු වේ.

පයිතන් 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

පයිතන් 3.6 ට පෙර පයිතන් ශබ්දකෝෂය අනුපිළිවෙලට සකස් කර නොමැත. පයිතන් 3.6 CPython ක්‍රියාත්මක කිරීමේදී ශබ්දකෝෂය ඇතුළු කිරීමේ අනුපිළිවෙල තබා ගනී. පයිතන් 3.7 සිට මෙය භාෂා අංගයක් බවට පත්වනු ඇත.

පයිතන් 3.6 හි වෙනස් කිරීමේ දී ( https://docs.python.org/3.6/whatsnew/3.6.html#whatsnew36-compactdict ):

මෙම නව ක්‍රියාවට නැංවීමේ අංගය ක්‍රියාත්මක කිරීමේ විස්තරයක් ලෙස සලකනු ලබන අතර එය විශ්වාසය තැබිය යුතු නොවේ (මෙය අනාගතයේ දී වෙනස් විය හැකිය, නමුත් භාෂා පිරිවිතර වෙනස් කිරීමට පෙර නිකුත් කිරීම් කිහිපයක් සඳහා භාෂාවේ මෙම නව නියෝග ක්‍රියාත්මක කිරීම අපේක්ෂා කෙරේ. සියලුම වර්තමාන සහ අනාගත පයිතන් ක්‍රියාත්මක කිරීම් සඳහා ඇණවුම්-සංරක්ෂණ අර්ථ නිරූපණය කිරීම; මෙය අහඹු පුනරාවර්තන අනුපිළිවෙල තවමත් ක්‍රියාත්මක වන භාෂාවේ පැරණි අනුවාදයන් සමඟ පසුපසට-ගැළපුම ආරක්ෂා කර ගැනීමට උපකාරී වේ, උදා: පයිතන් 3.5).

පයිතන් 3.7 හි ලේඛනයේ ( https://docs.python.org/3.7/tutorial/datastructures.html#dictionary ):

ශබ්දකෝෂයක ලැයිස්තුව ()) සිදු කිරීම, ශබ්දකෝෂයේ භාවිතා කර ඇති සියලුම යතුරු ලැයිස්තුවක් ඇතුළත් කිරීමේ අනුපිළිවෙලට ලබා දෙයි (ඔබට එය වර්ග කිරීමට අවශ්‍ය නම්, ඒ වෙනුවට වර්ග කළ ()) භාවිතා කරන්න).

එබැවින් පෙර සංස්කරණ මෙන් නොව, ඔබට පයිතන් 3.6 / 3.7 ට පසුව නියෝගයක් වර්ග කළ හැකිය. ඇතුළත උප ආ ict ාව ඇතුළුව කැදැලි නියෝගයක් වර්ග කිරීමට ඔබට අවශ්‍ය නම්, ඔබට කළ හැක්කේ:

test_dict = {'a': 1, 'c': 3, 'b': {'b2': 2, 'b1': 1}}

def dict_reorder(item):
    return {k: sort_dict(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

යතුරු භාවිතයෙන් පයිතන් ආ ict ාව වර්ග කිරීම සඳහා සරලම විසඳුමක් මෙහිදී මට හමු විය pprint. උදා.

>>> x = {'a': 10, 'cd': 20, 'b': 30, 'az': 99} 
>>> print x
{'a': 10, 'b': 30, 'az': 99, 'cd': 20}

නමුත් මුද්‍රණය භාවිතා කරන විට එය වර්ග කළ නියෝගයක් ලබා දෙනු ඇත

>>> 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)]

එබැවින් එය යතුරු, අගයන් සහ අයිතම බවට වෙනස් කිරීමෙන් ඔබට අවශ්‍ය දේ මෙන් මුද්‍රණය කළ හැකිය. මෙය උපකාරී වේ යැයි සිතමු!

ඔබට අවශ්‍ය දේ හරියටම ජනනය කරනු ඇත:

 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]))

ඔබගේ ප්‍රශ්නයට අනුව වත්මන් ශබ්ද කෝෂය යතුරෙන් වර්ග කිරීමෙන් ඔබට නව ශබ්ද කෝෂයක් නිර්මාණය කළ හැකිය.

මෙය ඔබේ ශබ්දකෝෂයයි

d = {2:3, 1:89, 4:5, 3:0}

ලැම්බඩා ශ්‍රිතය භාවිතයෙන් මෙම d වර්ග කිරීමෙන් නව ශබ්ද කෝෂයක් සාදන්න

d1 = dict(sorted(d.items(), key = lambda x:x[0]))

d1 {1: 89, 2: 3, 3: 0, 4: 5 be විය යුතුය, d හි යතුරු මත පදනම්ව වර්ග කළ යුතුය.

මම හිතන්නේ පහසුම දෙය නම් විධානය යතුරෙන් වර්ග කර වර්ග කළ යතුර සුරැකීමයි: අගය යුගලය නව නියෝගයකින්.

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

පයිතන් නියෝග ඇණවුම් කර නැත. සාමාන්‍යයෙන්, මෙය ගැටළුවක් නොවන්නේ වඩාත් පොදු භාවිත අවස්ථාව වන්නේ සොයා බැලීමයි.

ඔබට අවශ්‍ය දේ කිරීමට ඇති සරලම ක්‍රමය වනුයේ 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වෙනුවට සරල වෙනසක් කිරීමට වඩා 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)

මෙය කිරීමට පහසු ක්‍රමයක්:

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} 

මම තනි රේඛා ඩික් වර්ග කිරීම සමඟ ඉදිරියට එනවා.

>> 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]

මෙය ප්‍රයෝජනවත් වේ යැයි සිතමි.

යාලුවනේ ඔයා දේවල් සංකීර්ණ කරනවා ... ඒක ඇත්තටම සරලයි

from pprint import pprint
Dict={'B':1,'A':2,'C':3}
pprint(Dict)

ප්‍රතිදානය:

{'A':2,'B':1,'C':3}

සරලම විසඳුම නම්, ඔබ විසින් ඩික්ට් යතුර ලැයිස්තුවක් ලබා ගත යුතු අතර එය පිළිවෙලට පිළිවෙලට තබා ඇති අතර පසුව ඩික්ට් හරහා නැවත කියන්න. උදාහරණයක් වශයෙන්

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

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 

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]}

නැතහොත් භාවිතා කරන්න 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}
>>> 

බලන්න:

මේ පිළිබඳ ලියකියවිලි

සම්පූර්ණ පැන්ඩා ලේඛනගත කිරීම

මගේ යෝජනාව මෙයයි, එමඟින් ඔබ අයිතම එකතු කරන විට ආ ict ාවක් වර්ග කිරීමට හෝ නියෝගයක් පිළිවෙලට තබා ගැනීමට ඉඩ සලසන අතර අනාගතයේදී අයිතම එකතු කිරීමට අවශ්‍ය වනු ඇත:

dictඔබ යන විට මුල සිටම ගොඩනඟන්න . ඔබගේ යතුරු ලැයිස්තුව සමඟ දෙවන දත්ත ව්‍යුහයක්, ලැයිස්තුවක් තබා ගන්න. ද්වීපාර්ශ්වික පැකේජයට ඇතුළත් කිරීමේ ශ්‍රිතයක් ඇති අතර එය වර්ග කළ ලැයිස්තුවකට ඇතුළු කිරීමට ඉඩ සලසයි, නැතහොත් ඔබේ ආ ict ාව මුළුමනින්ම ජනගහනය කිරීමෙන් පසුව ඔබේ ලැයිස්තුව වර්ග කරන්න. දැන්, ඔබ ඔබේ ආ ict ාව ගැන නැවත කියවන විට, ඒ වෙනුවට ඔබ එක් එක් යතුර පිළිවෙලට සකස් කර ගැනීම සඳහා ලැයිස්තුවට නැවත යොමු කරයි.

ප්‍රශ්නය සකස් කරන ආකාරය සඳහා, මෙහි ඇති බොහෝ පිළිතුරු එයට නිවැරදිව පිළිතුරු සපයයි.

කෙසේ වෙතත්, කරුණු ආකාරය සලකා යුතු ඇත්තටම acount දශක හා පරිගණක විද්යාව දශක වෙත ගෙන, සිදු කළ, එය මගේ මුළු suprise එන පමණක් ඇත්තටම පවතින බව එක් පිළිතුරක් මෙතන (සිට GrantJ හරිම associative බඳුන් (sortedcontainers) භාවිතය යෝජනා පරිශීලකයා) වන ඒවායේ ඇතුළත් කිරීමේ ස්ථානයේ යතුර මත පදනම්ව මූලද්‍රව්‍ය වර්ග කරයි.

එමඟින් සෑම ඇමතුමකටම දැවැන්ත කාර්යසාධන බලපෑමක් වළක්වනු ඇත sort(...)(අවම වශයෙන් O(N*log(N)), Nමූලද්‍රව්‍ය ගණනක් ඇති තැන (තර්කානුකූලව, මෙය භාවිතා කිරීමට යෝජනා කරන එවැනි සියලු විසඳුම් සඳහා මෙය අදාළ වේ sort(...)). එවැනි සියලු විසඳුම් සඳහා, sort(...)අවශ්‍ය වනු ඇති බව සැලකිල්ලට ගන්න. colletion අවශ්යතා හරිම ලෙස භාවිතා කිරීමට විට සෑම අවස්ථාවකදීම කැඳවනු පසු එය එකතු / අංග ඉවත් කිරීමෙන් වෙනස් කරන ලද්දේ ...

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)