ටුපල් ලෙස නම් කර ඇත්තේ කුමක්ද?
නම් කරන ලද ටුපල් යනු ටුපල් ය.
එය කළ හැකි සෑම දෙයක්ම කරයි.
නමුත් එය හුදු ටුපල් එකකට වඩා වැඩි ය.
එය නම් කරන ලද ක්ෂේත්‍ර සහ ස්ථාවර දිගක් සහිතව ඔබේ පිරිවිතරයට ක්‍රමලේඛගතව නිර්මාණය කරන ලද ටුපල් එකක විශේෂිත උප පංතියකි.
නිදසුනක් ලෙස, මෙය ටුපල් උප පංතියක් නිර්මාණය කරන අතර, ස්ථාවර දිග හැරුණු විට (මේ අවස්ථාවේ දී, තුනක්), එය කැඩී යාමකින් තොරව ටුපල් එකක් භාවිතා කරන සෑම තැනකම භාවිතා කළ හැකිය. මෙය ලිස්කොව් ආදේශකතාව ලෙස හැඳින්වේ.
පයිතන් 3.6 හි අළුත් , අපට නම් කළtyping.NamedTupleටුපල් එකක් සෑදීමටපන්ති අර්ථ දැක්වීමක් භාවිතා කළ හැකිය:
from typing import NamedTuple
class ANamedTuple(NamedTuple):
"""a docstring"""
foo: int
bar: str
baz: list
ඉහත සඳහන් කර ඇති ආකාරයට පහත දැක්වෙන ආකාරයට සමාන වේ. පහත දැක්වෙන්නේ පයිතන් 2+ හි ය:
>>> from collections import namedtuple
>>> class_name = 'ANamedTuple'
>>> fields = 'foo bar baz'
>>> ANamedTuple = namedtuple(class_name, fields)
මෙය ක්ෂණිකව තහවුරු කරයි:
>>> ant = ANamedTuple(1, 'bar', [])
අපට එය පරීක්ෂා කර එහි ගුණාංග භාවිතා කළ හැකිය:
>>> ant
ANamedTuple(foo=1, bar='bar', baz=[])
>>> ant.foo
1
>>> ant.bar
'bar'
>>> ant.baz.append('anything')
>>> ant.baz
['anything']
ගැඹුරු පැහැදිලි කිරීම
නම් කරන ලද ටුපල් තේරුම් ගැනීමට, ඔබ මුලින්ම දැනගත යුත්තේ ටුපල් යනු කුමක්ද යන්නයි. ටුපල් යනු අත්‍යවශ්‍යයෙන්ම වෙනස් කළ නොහැකි (මතකයේ ස්ථානය වෙනස් කළ නොහැක) ලැයිස්තුවකි.
මෙන්න ඔබ සාමාන්‍ය ටුපල් එකක් භාවිතා කරන්නේ කෙසේද:
>>> student_tuple = 'Lisa', 'Simpson', 'A'
>>> student_tuple
('Lisa', 'Simpson', 'A')
>>> student_tuple[0]
'Lisa'
>>> student_tuple[1]
'Simpson'
>>> student_tuple[2]
'A'
නැවත සකස් කළ නොහැකි ඇසුරුමකින් ඔබට ටුපල් එකක් පුළුල් කළ හැකිය:
>>> first, last, grade = student_tuple
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'
නම් කරන ලද ටුපල් යනු හුදෙක් දර්ශකය වෙනුවට ඒවායේ මූලද්‍රව්‍යයන් නමට ප්‍රවේශ වීමට ඉඩ සලසන ටුපල් ය!
ඔබ මේ ආකාරයට නම් කළ ටුපල් එකක් සාදන්න:
>>> from collections import namedtuple
>>> Student = namedtuple('Student', ['first', 'last', 'grade'])
ඔබට අවකාශයකින් වෙන් කරන ලද නම් සහිත තනි නූලක් භාවිතා කළ හැකිය, ඒපීඅයි තරමක් කියවිය හැකි භාවිතය:
>>> Student = namedtuple('Student', 'first last grade')
ඒවා භාවිතා කරන්නේ කෙසේද?
ටුපල්වරුන්ට කළ හැකි සෑම දෙයක්ම ඔබට කළ හැකිය (ඉහත බලන්න) මෙන්ම පහත සඳහන් දේ කරන්න:
>>> named_student_tuple = Student('Lisa', 'Simpson', 'A')
>>> named_student_tuple.first
'Lisa'
>>> named_student_tuple.last
'Simpson'
>>> named_student_tuple.grade
'A'
>>> named_student_tuple._asdict()
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> vars(named_student_tuple)
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> new_named_student_tuple = named_student_tuple._replace(first='Bart', grade='C')
>>> new_named_student_tuple
Student(first='Bart', last='Simpson', grade='C')
විචාරකයෙක් ඇසුවේ:
විශාල ස්ක්‍රිප්ට් එකක හෝ වැඩසටහනක, සාමාන්‍යයෙන් නම් කරන ලද ටුපල් එකක් අර්ථ දක්වන්නේ කොතැනින්ද?
ඔබ නිර්මාණය කරන namedtupleවර්ග මූලික වශයෙන් ඔබට පහසු කෙටිමං සමඟ නිර්මාණය කළ හැකි පන්ති වේ. පංති වගේ සලකන්න. මොඩියුල මට්ටමින් ඒවා නිර්වචනය කරන්න, එවිට අච්චාරු සහ වෙනත් පරිශීලකයින්ට ඒවා සොයාගත හැකිය.
ගෝලීය මොඩියුල මට්ටමින් වැඩ කරන උදාහරණය:
>>> from collections import namedtuple
>>> NT = namedtuple('NT', 'foo bar')
>>> nt = NT('foo', 'bar')
>>> import pickle
>>> pickle.loads(pickle.dumps(nt))
NT(foo='foo', bar='bar')
අර්ථ දැක්වීම බැලීමට අපොහොසත් වීම මෙයින් පෙන්නුම් කෙරේ:
>>> def foo():
... LocalNT = namedtuple('LocalNT', 'foo bar')
... return LocalNT('foo', 'bar')
...
>>> pickle.loads(pickle.dumps(foo()))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
_pickle.PicklingError: Can't pickle <class '__main__.LocalNT'>: attribute lookup LocalNT on __main__ failed
සාමාන්‍ය ටුපල් වෙනුවට නම් කළ ටුපල් භාවිතා කළ යුත්තේ ඇයි / කවදාද?
ඔබේ කේතය වැඩි දියුණු කළ විට ඒවා භාවිතා කරන්න.
වෙනස් නොවන දත්ත ලක්ෂණ සහ ක්‍රියාකාරීත්වයක් නොමැති වස්තුවක් ඔබ භාවිතා කරන්නේ නම් ඔබට වස්තුවක් වෙනුවට ඒවා භාවිතා කළ හැකිය.
ක්‍රියාකාරීත්වය එක් කිරීම සඳහා ඔබට ඒවා උපවර්ග කළ හැකිය , උදාහරණයක් ලෙස :
class Point(namedtuple('Point', 'x y')):
"""adding functionality to a named tuple"""
__slots__ = ()
@property
def hypot(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
def __str__(self):
return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)
නම් කරන ලද ටුපල් වෙනුවට සාමාන්‍ය ටුපල් භාවිතා කළ යුත්තේ ඇයි / කවදාද?
බොහෝ විට නම් කරන ලද ටුපල් භාවිතා කිරීමෙන් ටුපල් වෙත මාරුවීම ප්‍රතිගාමී විය හැකිය. ටියුප් එක භාවිතා කරන විට කියවිය හැකි වැඩි දියුණු කිරීම සඳහා අමතර කේතයකින් ලැබෙන පිරිවැය වටී ද යන්න පිළිබඳව පෙර සැලසුම් තීරණ ගැනීමේ මධ්‍යස්ථාන කේන්ද්‍රගත වේ.
ටුපල් එදිරිව ටුපල් භාවිතා කරන අමතර මතකයක් නොමැත.
කිසියම් ආකාරයක “නම් කරන ලද ලැයිස්තුවක්” (නම් කරන ලද ටුපල් හි විකෘති අනුවාදය) තිබේද?
ඔබ සොයන්නේ ස්ථිතික ප්‍රමාණයේ ලැයිස්තුවක සියලුම ක්‍රියාකාරීත්වයන් ක්‍රියාත්මක කරන ස්ලට් කළ වස්තුවක් හෝ නම් කරන ලද ටුපල් එකක් මෙන් ක්‍රියා කරන උප පංති ලැයිස්තුවකි (එමඟින් ලැයිස්තුව ප්‍රමාණයෙන් වෙනස් වීම කෙසේ හෝ අවහිර කරයි.)
දැන් පුළුල් වී ඇති අතර සමහර විට ලිස්කොව් ආදේශ කළ හැකි පළමු උදාහරණය:
from collections import Sequence
class MutableTuple(Sequence):
"""Abstract Base Class for objects that work like mutable
namedtuples. Subclass and define your named fields with
__slots__ and away you go.
"""
__slots__ = ()
def __init__(self, *args):
for slot, arg in zip(self.__slots__, args):
setattr(self, slot, arg)
def __repr__(self):
return type(self).__name__ + repr(tuple(self))
# more direct __iter__ than Sequence's
def __iter__(self):
for name in self.__slots__:
yield getattr(self, name)
# Sequence requires __getitem__ & __len__:
def __getitem__(self, index):
return getattr(self, self.__slots__[index])
def __len__(self):
return len(self.__slots__)
භාවිතා කිරීමට, උප පංතිය සහ අර්ථ දැක්වීම __slots__:
class Student(MutableTuple):
__slots__ = 'first', 'last', 'grade' # customize
>>> student = Student('Lisa', 'Simpson', 'A')
>>> student
Student('Lisa', 'Simpson', 'A')
>>> first, last, grade = student
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'
>>> student[0]
'Lisa'
>>> student[2]
'A'
>>> len(student)
3
>>> 'Lisa' in student
True
>>> 'Bart' in student
False
>>> student.first = 'Bart'
>>> for i in student: print(i)
...
Bart
Simpson
A