'For' ලූප භාවිතා කරමින් ශබ්ද කෝෂ හරහා උපුටා දැක්වීම

පහත කේතය නිසා මම ටිකක් ව්‍යාකූල වී සිටිමි:

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:
    print key, 'corresponds to', d[key]

මට නොතේරෙන keyකොටස එයයි. ශබ්ද කෝෂයේ යතුර කියවීමට පමණක් අවශ්‍ය බව පයිතන් හඳුනා ගන්නේ කෙසේද? වන keyPython විශේෂ වචනය? නැතහොත් එය හුදෙක් විචල්‍යයක්ද?

key යනු විචල්‍ය නමකි.

for key in d:

යතුරු සහ අගයන්ට වඩා ශබ්ද කෝෂයේ යතුරු උඩින් ලූප් කරයි. යතුර සහ අගය යන දෙකම ඉක්මවා යාමට ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය:

පයිතන් 3.x සඳහා:

for key, value in d.items():

පයිතන් 2.x සඳහා:

for key, value in d.iteritems():

ඔබම පරීක්ෂා කර බැලීමට, වචනය වෙනස් keyකරන්න poop.

පයිතන් 3.x හි iteritems()සරලව ප්‍රතිස්ථාපනය items()කරන ලද අතර එය ආ ict ාව පිටුබලය දෙන කට්ටලයක් වැනි දර්ශනයක් ලබා දෙයි iteritems(). මෙය 2.7 ලෙසද ලබා ගත හැකිය viewitems().

මෙහෙයුම items()2 සහ 3 යන දෙකටම ක්‍රියා කරනු ඇත, නමුත් 2 දී එය ශබ්ද කෝෂයේ (key, value)යුගල ලැයිස්තුවක් නැවත ලබා දෙනු ඇත, එමඟින් items()ඇමතුමෙන් පසුව සිදුවන ආ ict ාවේ වෙනස්කම් පිළිබිඹු නොවේ . ඔබට 3.x හි 2.x හැසිරීම අවශ්‍ය නම්, ඔබට ඇමතිය හැකිය list(d.items()).

එය යතුර විශේෂ වචනයක් නොවේ, නමුත් ශබ්දකෝෂ මඟින් iterator ප්‍රොටෝකෝලය ක්‍රියාත්මක කරයි. ඔබට මෙය ඔබේ පන්තියේදී කළ හැකිය, උදා: පන්ති අනුකාරක ගොඩනගන්නේ කෙසේද යන්න සඳහා මෙම ප්‍රශ්නය බලන්න .

ශබ්ද කෝෂ සම්බන්ධයෙන් ගත් කල, එය සී මට්ටමින් ක්‍රියාත්මක වේ. විස්තර PEP 234 හි ඇත. විශේෂයෙන්, “ශබ්ද කෝෂ අනුකාරක” යන මාතෘකාව යටතේ:

• ශබ්ද කෝෂයේ tp_iter slot එකක් ක්‍රියාත්මක කරන අතර එය ශබ්දකෝෂයේ යතුරු හරහා නැවත ක්‍රියාත්මක වන කාර්යක්ෂම අනුකාරකයක් ලබා දෙයි. [...] මෙයින් අදහස් කරන්නේ අපට ලිවිය හැකි බවයි

  for k in dict: ...

  එය සමාන, නමුත් වඩා වේගවත්

  for k in dict.keys(): ...

  ශබ්ද කෝෂයේ වෙනස් කිරීම් සීමා කිරීම (ලූපය මගින් හෝ වෙනත් නූලකින්) උල්ලං are නය නොවන තාක් කල්.

• විවිධාකාර අනුකාරක පැහැදිලිව ලබා දෙන ශබ්ද කෝෂවලට ක්‍රම එකතු කරන්න:

  for key in dict.iterkeys(): ...
  
  for value in dict.itervalues(): ...
  
  for key, value in dict.iteritems(): ...

  මෙයින් අදහස් කරන්නේ for x in dictඑය කෙටිකාලීන for x in dict.iterkeys()බවයි.

පයිතන් 3 හි dict.iterkeys(), dict.itervalues()සහ dict.iteritems()තවදුරටත් සහාය නොදක්වයි. භාවිතා dict.keys(), dict.values()සහ dict.items()ඒ වෙනුවට.

dictඔබට මෙහි දැකිය හැකි පරිදි, කිසියම් අනුපිළිවෙලකට එහි යතුරු හරහා පුනරාවර්තනය කිරීම:

සංස්කරණය කරන්න: ( පයිතන් 3.6 හි මෙය තවදුරටත් සිදු නොවේ , නමුත් එය තවමත් හැසිරීම සහතික කර නොමැති බව සලකන්න )

>>> d = {'x': 1, 'y': 2, 'z': 3} 
>>> list(d)
['y', 'x', 'z']
>>> d.keys()
['y', 'x', 'z']

ඔබේ උදාහරණය සඳහා, එය භාවිතා කිරීම වඩා හොඳ අදහසකි dict.items():

>>> d.items()
[('y', 2), ('x', 1), ('z', 3)]

මෙය ඔබට ටුපල් ලැයිස්තුවක් ලබා දෙයි. ඔබ ඔවුන් කෙරෙහි මහත් පිටුවහලක් මේ වගේ, එක් එක් tuple බවට ලෙස සකස්කර ඇත kහා vස්වයංක්රීයව:

for k,v in d.items():
    print(k, 'corresponds to', v)

භාවිතා kසහ vවිචල්ය නම් ලෙස වැඩි ප්රහාරක විට dictකම්බියක් ශරීරය ඉතා පේලි කිහිපයක් පමණක් නම් ඉතා සුලභ වේ. වඩාත් සංකීර්ණ ලූප සඳහා වඩාත් විස්තරාත්මක නම් භාවිතා කිරීම හොඳ අදහසක් විය හැකිය:

for letter, number in d.items():
    print(letter, 'corresponds to', number)

ආකෘති නූල් භාවිතා කිරීමේ පුරුද්දට පිවිසීම හොඳ අදහසකි:

for letter, number in d.items():
    print('{0} corresponds to {1}'.format(letter, number))

key හුදෙක් විචල්යයකි.

සඳහා Python2.X :

d = {'x': 1, 'y': 2, 'z': 3} 
for my_var in d:
    print my_var, 'corresponds to', d[my_var]

... හෝ වඩා හොඳයි,

d = {'x': 1, 'y': 2, 'z': 3} 
for the_key, the_value in d.iteritems():
    print the_key, 'corresponds to', the_value

සඳහා Python3.X :

d = {'x': 1, 'y': 2, 'z': 3} 
for the_key, the_value in d.items():
    print(the_key, 'corresponds to', the_value)

for .. in ..-Syntax භාවිතයෙන් ඔබ ශබ්ද කෝෂ හරහා නැවත කියවන විට, එය සෑම විටම යතුරු හරහා නැවත ක්‍රියා කරයි (අගයන් භාවිතයෙන් ප්‍රවේශ විය හැක dictionary[key]).

යතුරු අගය යුගල හරහා නැවත සැකසීමට, පයිතන් 2 භාවිතයේදී for k,v in s.iteritems()සහ පයිතන් 3 හි for k,v in s.items().

මෙය ඉතා සුලභ ලූපි මෝඩයකි. inක්‍රියාකරුවෙකි. භාවිතා කිරීමට විට සඳහා for key in dictඑය විය යුතුය විට for key in dict.keys()බලන්න ඩේවිඩ් Goodger ගේ සෙන්දගශයෙහි Python ලිපිය (සංරක්ෂණය කරන ලද පිටපතක්) .

'For' ලූප භාවිතා කරමින් ශබ්ද කෝෂ හරහා උපුටා දැක්වීම

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:
    ...

ශබ්ද කෝෂයේ යතුර කියවීමට පමණක් අවශ්‍ය බව පයිතන් හඳුනා ගන්නේ කෙසේද? යතුර පයිතන්හි විශේෂ වචනයක්ද? නැතහොත් එය හුදෙක් විචල්‍යයක්ද?

එය forලූප පමණක් නොවේ . මෙහි ඇති වැදගත් වචනය වන්නේ “නැවත සැකසීම” යන්නයි.

ශබ්දකෝෂයක් යනු අගයන් සඳහා යතුරු සිතියම්ගත කිරීමකි:

d = {'x': 1, 'y': 2, 'z': 3} 

අපි එය නැවත නැවත කියවන ඕනෑම වේලාවක අපි යතුරු හරහා නැවත කියමු. විචල්ය නාමය keyවිස්තර කිරීමට පමණක් අදහස් කර ඇති අතර එය ඒ සඳහා බෙහෙවින් යෝග්‍ය වේ.

මෙය ලැයිස්තු අවබෝධයකින් සිදු වේ:

>>> [k for k in d]
['x', 'y', 'z']

එය සිදු වන්නේ අප ශබ්දකෝෂය ලැයිස්තු ගත කළ විට (හෝ වෙනත් එකතු කිරීමේ වර්ගයේ වස්තුවක්):

>>> list(d)
['x', 'y', 'z']

පයිතන් පුනරාවර්තනය වන ආකාරය, එය අවශ්‍ය වන සන්දර්භයකදී, එය __iter__වස්තුවේ ක්‍රමය (මෙම අවස්ථාවේදී ශබ්දකෝෂය) ලෙස හඳුන්වන්නේ එය නැවත ක්‍රියාකරවන්නෙකු ආපසු ලබා දීමයි (මේ අවස්ථාවේ දී, යතුරුපුවරු වස්තුවක්):

>>> d.__iter__()
<dict_keyiterator object at 0x7fb1747bee08>

අපි, ඒ වෙනුවට, අප මෙම විශේෂ ක්රම භාවිතා නොකළ යුතු, එය කැඳවීමට අදාළ builtin ක්රියාව භාවිත, iter:

>>> key_iterator = iter(d)
>>> key_iterator
<dict_keyiterator object at 0x7fb172fa9188>

අනුකාරකයන්ට __next__ක්‍රමයක් ඇත - නමුත් අපි එය බිල්ඩින් ශ්‍රිතය සමඟ අමතන්නෙමු next:

>>> next(key_iterator)
'x'
>>> next(key_iterator)
'y'
>>> next(key_iterator)
'z'
>>> next(key_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

පුනරාවර්තකය අවසන් වූ විට, එය මතු කරයි StopIteration. පයිතන් ලූපයකින් forහෝ ලැයිස්තු අවබෝධයකින් හෝ උත්පාදක ප්‍රකාශනයකින් හෝ වෙනත් ක්‍රියාකාරී සන්දර්භයකින් පිටවීමට දන්නා ආකාරය මෙයයි . අනුකාරකයක් මතු StopIterationකළ පසු එය සැමවිටම එය ඉහළ නංවනු ඇත - ඔබට නැවත නැවත කියවීමට අවශ්‍ය නම්, ඔබට නව එකක් අවශ්‍ය වේ.

>>> list(key_iterator)
[]
>>> new_key_iterator = iter(d)
>>> list(new_key_iterator)
['x', 'y', 'z']

අණපනත් වෙත ආපසු යාම

බොහෝ සන්දර්භයන් තුළ අණපනත් ක්‍රියාත්මක වන ආකාරය අපි දැක ඇත්තෙමු. අප දුටු දෙය නම්, අපි නියෝගයක් නැවත කියවන ඕනෑම වේලාවක අපට යතුරු ලැබෙනු ඇත. මුල් උදාහරණය වෙත ආපසු:

d = {'x': 1, 'y': 2, 'z': 3} 
for key in d:

අපි විචල්ය නාමය වෙනස් කළහොත්, අපට තවමත් යතුරු ලැබේ. ඒක උත්සාහ කරමු:

>>> for each_key in d:
...     print(each_key, '=>', d[each_key])
... 
x => 1
y => 2
z => 3

අපි වටිනාකම් කට වඩාත් කැපීපෙනේ කිරීමට අවශ්ය නම්, අපි භාවිතා කිරීමට අවශ්ය .valuesdicts ක්රමය, හෝ, දෙකම එකට සඳහා .items:

>>> list(d.values())
[1, 2, 3]
>>> list(d.items())
[('x', 1), ('y', 2), ('z', 3)]

ලබා දී ඇති උදාහරණයේ දී, මෙවැනි අයිතමයන් නැවත සැකසීම වඩා කාර්යක්ෂම වනු ඇත:

for a_key, corresponding_value in d.items():
    print(a_key, corresponding_value)

නමුත් ශාස්ත්‍රීය අරමුණු සඳහා, ප්‍රශ්නයේ උදාහරණය ඉතා හොඳයි.

යතුර, අගය යුගලය සහ මා සිටින තැන දැක්වෙන දර්ශකය ලබා ගැනීම සඳහා ආ ict ාව හරහා නැවත යෙදීමට මට භාවිතා කිරීමේ අවස්ථාවක් තිබේ. මම එය කරන්නේ මෙයයි:

d = {'x': 1, 'y': 2, 'z': 3} 
for i, (key, value) in enumerate(d.items()):
   print(i, key, value)

යතුර වටා ඇති වරහන්, අගය වැදගත් බව සලකන්න, වරහන් නොමැතිව ඔබට ValueError එකක් ලැබෙනු ඇත "ඉවත් කිරීමට ප්‍රමාණවත් අගයන් නොමැත".

ඔබට dicttypeGitHub හි CPython ක්‍රියාත්මක කිරීම පරීක්ෂා කළ හැකිය . ආ it ා පනත ක්‍රියාත්මක කරන ක්‍රමයේ අත්සන මෙයයි:

_PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey,
             PyObject **pvalue, Py_hash_t *phash)

CPython dictobject.c

යතුරු නැවත කියවීමට, එය මන්දගාමී නමුත් භාවිතා කිරීමට වඩා හොඳය my_dict.keys(). ඔබ මේ වගේ දෙයක් කිරීමට උත්සාහ කළේ නම්:

for key in my_dict:
    my_dict[key+"-1"] = my_dict[key]-1

වැඩසටහන ක්‍රියාත්මක වන විට ඔබ යතුරු වෙනස් කරන බැවින් එය ධාවන කාල දෝෂයක් ඇති කරයි. ඔබ කාලය අඩු කිරීම සඳහා නියත වශයෙන්ම සකසා ඇත්නම්, for key in my_dictමාර්ගය භාවිතා කරන්න , නමුත් ඔබට අනතුරු අඟවා ඇත;).

මෙමඟින් ප්‍රතිදානය අගය අනුව පිළිවෙලට පිළිවෙලට මුද්‍රණය කෙරේ.

d = {'x': 3, 'y': 1, 'z': 2}
def by_value(item):
    return item[1]

for key, value in sorted(d.items(), key=by_value):
    print(key, '->', value)

ප්‍රතිදානය:

පයිතන්හි යතුර දර්ශක මෙන් ය. දර්ශක වල, අප දන්නා පරිදි, 0 සිට ආරම්භ වේ. දර්ශක සහ යතුරු අතර ඇති එකම වෙනස වන්නේ දර්ශක කලින් ලියා තිබීමයි. නමුත් යතුරු ලියා ඇත්තේ ඔබ විසිනි. සරල වචන වලින් කිවහොත්, යතුරු ලැයිස්තුවක් සඳහා මෙන් ඒවායේ ගබඩා කර ඇති අගයන් වෙත යොමු වේ.

>>>l=[1,2,3,4]
>>>l[0]
1

නමුත් ශබ්ද කෝෂයේ:

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

යතුරු දර්ශක හා සමාන යැයි මා කීවේ මන්දැයි ඔබ තේරුම් ගත්තා යැයි සිතමි. ඔබට තවමත් සැකයක් ඇත්නම් මට දන්වන්න.