එයට අනුබල දෙන භාෂාවලින් බහුවිධ අගයන් ආපසු ලබා දීමට කැනොනිකල් ක්‍රමය බොහෝ විට හීලෑ වේ.

විකල්පය: ටුපල් එකක් භාවිතා කිරීම

මෙම සුළු උදාහරණය සලකා බලන්න:

def f(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return (y0, y1, y2)

කෙසේ වෙතත්, ආපසු ලබා දුන් අගයන් ගණන වැඩි වන විට මෙය ඉක්මනින් ගැටළු සහගත වේ. ඔබට අගයන් හතරක් හෝ පහක් ආපසු ලබා දීමට අවශ්‍ය නම් කුමක් කළ යුතුද? අනිවාර්යෙන්ම, ඔබට ඒවා දිගින් දිගටම හසුකර ගත හැකිය, නමුත් කුමන වටිනාකම කොතැනද යන්න අමතක කිරීම පහසුය. ඔබට ඒවා ලැබීමට අවශ්‍ය ඕනෑම තැනක ඒවා ඉවත් කිරීම තරමක් කැතයි.

විකල්පය: ශබ්ද කෝෂයක් භාවිතා කිරීම

මීළඟ තාර්කික පියවර වන්නේ යම් ආකාරයක 'වාර්තා අංකනයක්' හඳුන්වා දීමයි. පයිතන්හි, මෙය කළ හැකි පැහැදිලි ක්‍රමය වන්නේ a dict.

පහත සඳහන් කරුණු සලකා බලන්න:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0': y0, 'y1': y1 ,'y2': y2}

(පැහැදිලිව කිවහොත්, y0, y1 සහ y2 යන්නෙන් අදහස් කරන්නේ වියුක්ත හඳුනාගැනීම් ලෙසය. පෙන්වා දුන් පරිදි, ප්‍රායෝගිකව ඔබ අර්ථවත් හඳුනාගැනීම් භාවිතා කරනු ඇත.)

දැන්, අපට ආපසු ලබා දුන් වස්තුවෙහි නිශ්චිත සාමාජිකයෙකු ප්‍රක්ෂේපණය කළ හැකි යාන්ත්‍රණයක් තිබේ. උදාහරණයක් වශයෙන්,

result['y0']

විකල්පය: පන්තියක් භාවිතා කිරීම

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

class ReturnValue:
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return ReturnValue(y0, y1, y2)

Python වූ අතර එය පසුගිය දෙකක් ජලනල අනුව සමහර විට ඉතා සමාන වේ - සියලු පසු { y0, y1, y2 }පමණක් අභ්යන්තර ඇති ඇතුළත් කිරීම් වීම අවසන් __dict__කිරීම ReturnValue.

කුඩා වස්තූන් සඳහා වුවද, පයිතන් විසින් සපයන ලද තවත් එක් අංගයක් __slots__ඇත. පංතිය මෙසේ ප්‍රකාශ කළ හැකිය:

class ReturnValue(object):
  __slots__ = ["y0", "y1", "y2"]
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

සිට Python විමර්ශන අත්පොත :

මෙම __slots__ප්රකාශය උදාහරණයක් විචල්යයන් සහ සංචිත එක් එක් විචල්ය සඳහා අගය පැවැත්වීමට එක් එක් අවස්ථාවේ දී ප්රමාණවත් තරම් ඉඩ අනුක්රමයක් ගනී. __dict__එක් එක් අවස්ථාව සඳහා නිර්මාණය කර නොමැති නිසා අවකාශය සුරකිනු ලැබේ.

විකල්පය: ඩේටාක්ලාස් භාවිතා කිරීම (පයිතන් 3.7+)

පයිතන් 3.7 හි නව දත්ත කට්ටල භාවිතා කරමින්, ස්වයංක්‍රීයව එකතු කරන ලද විශේෂ ක්‍රම, ටයිප් කිරීම සහ වෙනත් ප්‍රයෝජනවත් මෙවලම් සහිත පන්තියක් ආපසු එවන්න:

@dataclass
class Returnvalue:
    y0: int
    y1: float
    y3: int

def total_cost(x):
    y0 = x + 1
    y1 = x * 3
    y2 = y0 ** y3
    return ReturnValue(y0, y1, y2)

විකල්පය: ලැයිස්තුවක් භාවිතා කිරීම

මා නොසලකා හැරිය තවත් යෝජනාවක් බිල් ද කටුස්සාගෙන් ය:

def h(x):
  result = [x + 1]
  result.append(x * 3)
  result.append(y0 ** y3)
  return result

මෙය මගේ අවම ප්‍රියතම ක්‍රමයයි. හැස්කෙල්ට නිරාවරණය වීමෙන් මා කැළැල් වී ඇතැයි සිතමි, නමුත් මිශ්‍ර ආකාරයේ ලැයිස්තු පිළිබඳ අදහස සෑම විටම මට අපහසුතාවයක් දැනුනි. මෙම විශේෂිත උදාහරණයේ දී ලැයිස්තුව-මිශ්‍ර නොවන වර්ගයකි, නමුත් එය සිතිය හැකි ය.

මේ ආකාරයෙන් භාවිතා කරන ලැයිස්තුවක් මට කිව හැකි තාක් දුරට ටුපල් සම්බන්ධයෙන් කිසිවක් ලබා ගන්නේ නැත. පයිතන් හි ලැයිස්තු සහ ටුපල් අතර ඇති එකම සැබෑ වෙනස නම් ලැයිස්තු විකෘති වන අතර ටුපල් නැත.

ක්‍රියාකාරී ක්‍රමලේඛනයේ සම්මුතීන් මම පෞද්ගලිකව ගෙනයාමට නැඹුරු වෙමි: එකම වර්ගයේ ඕනෑම මූලද්‍රව්‍ය ගණනක් සඳහා ලැයිස්තු භාවිතා කරන්න, සහ කලින් තීරණය කළ වර්ගවල මූලද්‍රව්‍ය ගණනක් සඳහා ටුපල් භාවිතා කරන්න.

ප්‍රශ්නය

දීර් pre පෙරවදනෙන් පසු නොවැළැක්විය හැකි ප්‍රශ්නය පැමිණේ. වඩාත්ම සුදුසු ක්‍රමය කුමක්ද?

මේ සඳහා 2.6 දී නම් කරන ලද ටුපල් එකතු කරන ලදී. ඒ හා සමාන බිල්ඩින් උදාහරණයක් සඳහා os.stat ද බලන්න .

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, y=2)
>>> p.x, p.y
1 2
>>> p[0], p[1]
1 2

පයිතන් 3 හි මෑත සංස්කරණ වලදී (3.6+, මම හිතන්නේ), නව typingපුස්තකාලයට NamedTupleනම් කරන ලද ටුපල් නිර්මාණය කිරීමට පහසු සහ වඩා බලවත් කිරීමට පන්තිය ලැබුණි . සිට උරුම කර ගැනීම typing.NamedTupleමඟින් ලේඛ ලේඛන, පෙරනිමි අගයන් සහ විවරණ වර්ග භාවිතා කිරීමට ඔබට ඉඩ සලසයි.

උදාහරණය (ලියකියවිලි වලින්):

class Employee(NamedTuple):  # inherit from typing.NamedTuple
    name: str
    id: int = 3  # default value

employee = Employee('Guido')
assert employee.id == 3

කුඩා ව්‍යාපෘති සඳහා ටුපල් සමඟ වැඩ කිරීම පහසු බව මට පෙනේ. එය කළමනාකරණය කිරීමට අපහසු වූ විට (සහ ඊට පෙර නොවේ) මම දේවල් තාර්කික ව්‍යුහයන් ලෙස කාණ්ඩ කිරීමට පටන් ගනිමි, කෙසේ වෙතත් ඔබ යෝජනා කරන ශබ්දකෝෂ සහ ReturnValueවස්තූන් භාවිතා කිරීම වැරදියි (හෝ ඉතා සරල).

යතුරු ශබ්දකෝෂ නැවත "y0", "y1", "y2", ආදිය tuples වාසියක් ලබා නැත. නැවත හැරී ReturnValueගුණ ඇති උදාහරණයක් .y0, .y1, .y2ආදිය, එක්කෝ tuples වාසියක් ලබා නැත. ඔබට ඕනෑම තැනකට යාමට අවශ්‍ය නම් ඔබට නම් තැබීම ආරම්භ කළ යුතු අතර, කෙසේ හෝ ඔබට එය භාවිතා කළ හැකිය:

def get_image_data(filename):
    [snip]
    return size, (format, version, compression), (width,height)

size, type, dimensions = get_image_data(x)

IMHO, ටුපල් වලින් ඔබ්බට ඇති එකම හොඳ තාක්‍ෂණය වන්නේ ඔබ ලබා ගන්නා re.match()හෝ වැනි නියම ක්‍රම සහ ගුණාංග සහිත සැබෑ වස්තූන් ආපසු ලබා දීමයි open(file).

බොහෝ පිළිතුරු මඟින් ඔබට ශබ්දකෝෂයක් හෝ ලැයිස්තුවක් වැනි කිසියම් එකතුවක් ආපසු ලබා දිය යුතු යැයි යෝජනා කරයි. ඔබට අමතර වාක්‍ය ඛණ්ඩය අතහැර කොමා වලින් වෙන් කර ඇති ප්‍රතිලාභ අගයන් ලිවිය හැකිය. සටහන: මෙය තාක්‍ෂණිකව ටුපල් එකක් ලබා දෙයි.

def f():
    return True, False
x, y = f()
print(x)
print(y)

ලබා දෙයි:

True
False

මම ශබ්ද කෝෂයට ඡන්දය දෙමි.

මම විචල්‍ය 2-3 ට වඩා වැඩි යමක් ලබා දෙන ශ්‍රිතයක් කළහොත් මම ඒවා ශබ්දකෝෂයක නැමෙනු ඇත. එසේ නොමැතිනම් මා නැවත පැමිණෙන දේවල පිළිවෙල හා අන්තර්ගතය අමතක කිරීමට මම නැඹුරු වෙමි.

එසේම, 'විශේෂ' ව්‍යුහයක් හඳුන්වා දීමෙන් ඔබේ කේතය අනුගමනය කිරීම වඩාත් අපහසු වේ. (වෙනත් අයෙකුට එය කුමක්දැයි සොයා ගැනීමට කේතය හරහා සෙවීමට සිදුවේ)

ටයිප් සෙවීම ගැන ඔබ සැලකිලිමත් වන්නේ නම්, විස්තරාත්මක ශබ්ද කෝෂ යතුරු භාවිතා කරන්න, උදාහරණයක් ලෙස, 'x- අගයන් ලැයිස්තුව'.

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

තවත් විකල්පයක් වනුයේ ජනක යන්ත්‍ර භාවිතා කිරීමයි:

>>> def f(x):
        y0 = x + 1
        yield y0
        yield x * 3
        yield y0 ** 4


>>> a, b, c = f(5)
>>> a
6
>>> b
15
>>> c
1296

IMHO ටුපල් සාමාන්‍යයෙන් හොඳම ඒවා වුවද, ආපසු ලබා දෙන අගයන් පන්තියක සංයුක්ත කිරීම සඳහා අපේක්ෂකයින් වේ.

ටුපල් "ස්වාභාවික" යැයි හැඟෙන සෑම අවස්ථාවකම මම ටුපල් භාවිතා කිරීමට කැමැත්තෙමි; ඛණ්ඩාංක යනු සාමාන්‍ය උදාහරණයකි, එහිදී වෙනම වස්තූන්ට තනිවම නැගී සිටිය හැකිය, උදා: එක් අක්ෂයකින් පමණක් පරිමාණ ගණනය කිරීම් සිදු වන අතර අනුපිළිවෙල වැදගත් වේ. සටහන: කණ්ඩායමේ අර්ථයට අහිතකර බලපෑමක් නොමැතිව මට අයිතම වර්ග කිරීමට හෝ මාරු කිරීමට හැකි නම්, මම බොහෝ විට ටුපල් භාවිතා නොකළ යුතුය.

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

කාණ්ඩගත වස්තූන් තුළ සමූහය තුළ ආවේනික අර්ථයක් ඇති විට හෝ තමන්ගේම ක්‍රමවේදයන් සහිත අංග සම්පූර්ණ වස්තුවක් අවශ්‍ය වන ඉතිරි අවස්ථා සඳහා මම පන්තියක් භාවිතා කරමි.

මම කැමතියි:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

අනෙක් සියල්ලම එකම දේ කිරීමට අමතර කේතයක් බව පෙනේ.

>>> def func():
...    return [1,2,3]
...
>>> a,b,c = func()
>>> a
1
>>> b
2
>>> c
3

පොදුවේ ගත් කල, “විශේෂිත ව්‍යුහය” යනු ඇත්ත වශයෙන්ම වස්තුවක සංවේදී ක්‍රමවේදයක් වන අතර එහි ක්‍රමවේදයන් ඇත.

class Some3SpaceThing(object):
  def __init__(self,x):
    self.g(x)
  def g(self,x):
    self.y0 = x + 1
    self.y1 = x * 3
    self.y2 = y0 ** y3

r = Some3SpaceThing( x )
r.y0
r.y1
r.y2

හැකි සෑම තැනකම නිර්නාමික ව්‍යුහයන් සඳහා නම් සොයා ගැනීමට මම කැමතියි. අර්ථවත් නම් මගින් දේවල් වඩාත් පැහැදිලි වේ.

කුඩා දත්ත ව්‍යුහයන් සඳහා ("දේවල්") විධිමත්භාවය සහ පහසුව අතර සුමට වෙළඳාමක් පයිතන්ගේ ටුපල්, ඩික්ට්ස් සහ වස්තූන් ක්‍රමලේඛකයාට ලබා දෙයි. මට නම්, යම් දෙයක් නිරූපණය කරන්නේ කෙසේද යන්න තෝරා ගැනීම ප්‍රධාන වශයෙන් නියම කරනුයේ මම ව්‍යුහය භාවිතා කරන්නේ කෙසේද යන්න මතය. C ++ හි, ඔබට නීත්‍යානුකූලව ක්‍රමවේදයන් a මත තැබිය හැකි වුවද, structදත්ත පමණක් අයිතම classසඳහා සහ ක්‍රම සහිත වස්තු සඳහා භාවිතා කිරීම පොදු සම්මුතියකි struct; මගේ පුරුද්දක් සමග, Python සමාන වේ dictහා tupleවෙනුවට struct.

ඛණ්ඩාංක කට්ටල සඳහා, මම tupleලක්ෂ්‍යයක් classහෝ ලක්ෂ්‍යයක් වෙනුවට භාවිතා කරමි dict(තවද ඔබට tupleශබ්ද කෝෂ යතුරක් ලෙස භාවිතා කළ හැකි බව සලකන්න , එබැවින් dictවිශාල විරල බහුමාන අරා සාදන්න).

මම දේවල් ලැයිස්තුවක් හරහා නැවත කියවීමට යන්නේ නම්, මම නැවත නැවත ක්‍රියා විරහිත කිරීමට කැමතියි tuple:

for score,id,name in scoreAllTheThings():
    if score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(score,id,name)

... වස්තු අනුවාදය කියවීමට වඩා අවුල් සහගත බැවින්:

for entry in scoreAllTheThings():
    if entry.score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry.score,entry.id,entry.name)

... ඉඩ දෙන්න dict.

for entry in scoreAllTheThings():
    if entry['score'] > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry['score'],entry['id'],entry['name'])

එය බහුලව භාවිතා වන අතර, කේතයේ ස්ථාන කිහිපයකම ඒ හා සමාන සුළු නොවන මෙහෙයුම් සිදු කරන බව ඔබට පෙනේ නම්, සාමාන්‍යයෙන් එය සුදුසු ක්‍රම සහිත පන්ති වස්තුවක් බවට පත් කිරීම වටී.

අවසාන වශයෙන්, මම පයිතන් නොවන පද්ධති සංරචක සමඟ දත්ත හුවමාරු කර ගැනීමට යන්නේ නම්, මම බොහෝ විට ඒවා dictJSON අනුක්‍රමිකකරණයට වඩාත් සුදුසු බැවින් ඒවා තබා ගන්නෙමි .

නම් කරන ලද බහාලුම් පන්තියක් සඳහා එස්. ලොට්ගේ යෝජනාවට +1.

පයිතන් 2.6 සහ ඊට වැඩි නම් සඳහා නම් කරන ලද ටුපල් එකක් මෙම බහාලුම් පන්ති පහසුවෙන් නිර්මාණය කිරීමට ප්‍රයෝජනවත් ක්‍රමයක් සපයන අතර ප්‍රති results ල "සැහැල්ලු වන අතර සාමාන්‍ය ටුපල් වලට වඩා වැඩි මතකයක් අවශ්‍ය නොවේ".

පයිතන් වැනි භාෂාවල, මම සාමාන්‍යයෙන් ශබ්ද කෝෂයක් භාවිතා කරන්නේ එයට නව පංතියක් නිර්මාණය කිරීමට වඩා අඩු පිරිවැයක් දැරීමට සිදුවන බැවිනි.

කෙසේ වෙතත්, මම නිරන්තරයෙන් එකම විචල්‍යයන් සමූහයක් නැවත ලබා දෙන බව මට පෙනී ගියහොත්, එයට බොහෝ විට නව පන්තියක් ඇතුළත් වනු ඇත.

ශ්‍රිතයකින් අගයන් සම්මත කර ආපසු ලබා දීමට මම නියෝගයක් භාවිතා කරමි:

අර්ථ දක්වා ඇති පරිදි විචල්ය ආකෘති පත්රය භාවිතා කරන්න ආකෘති පත්රය .

form = {
    'level': 0,
    'points': 0,
    'game': {
        'name': ''
    }
}


def test(form):
    form['game']['name'] = 'My game!'
    form['level'] = 2

    return form

>>> print(test(form))
{u'game': {u'name': u'My game!'}, u'points': 0, u'level': 2}

මෙය මට සහ සැකසුම් ඒකකයට වඩාත්ම කාර්යක්ෂම ක්‍රමයයි.

ඔබට එක් දර්ශකයක් පමණක් පසු කර එක් දර්ශකයක් පමණක් ආපසු යා යුතුය.

ඔබ ඔබේ කේතයේ වෙනසක් සිදු කරන සෑම විටම කාර්යයන් (ඒවා දහස් ගණනක්) වෙනස් කිරීමට ඔබට අවශ්‍ය නැත.

"හොඳම" යනු අර්ධ වශයෙන් ආත්මීය තීරණයක්. වෙනස් කළ නොහැකි දෙයක් පිළිගත හැකි පොදු අවස්ථාවකදී කුඩා ප්‍රතිලාභ කට්ටල සඳහා ටුපල් භාවිතා කරන්න. විකෘතිතාව අවශ්‍ය නොවන විට ලැයිස්තුවක් සඳහා ටුපල් එකක් වඩාත් සුදුසුය.

වඩාත් සංකීර්ණ ප්‍රතිලාභ අගයන් සඳහා, හෝ විධිමත් බව වටිනා අවස්ථාවක (එනම් ඉහළ අගය කේතය) නම් කරන ලද ටුපල් එකක් වඩා හොඳය. වඩාත්ම සංකීර්ණ අවස්ථාව සඳහා වස්තුවක් සාමාන්‍යයෙන් හොඳම වේ. කෙසේ වෙතත්, එය ඇත්ත වශයෙන්ම වැදගත් වන තත්වයයි. ශ්‍රිතය අවසානයේ ඔබට ස්වභාවිකවම ඇති නිසා වස්තුවක් ආපසු ලබා දීම අර්ථවත් නම් (උදා: කර්මාන්තශාලා රටාව) ඉන්පසු වස්තුව ආපසු ලබා දෙන්න.

Wise ානවන්තයා පැවසූ පරිදි:

නොමේරූ ප්‍රශස්තිකරණය යනු ක්‍රමලේඛනයේ සියලු නපුරේ (හෝ අවම වශයෙන් බොහෝ දුරට) මුල වේ.