אין די וואַסט וועלט פון פּיטהאָן פּראָגראַממינג, עס איז אַ סכום פון פֿעיִקייטן וואָס אָפט גיין אַננאָוטיסט דורך ביגינערז, אָבער האָבן אַ באַטייטיק וויכטיקייט אין די יקאָוסיסטאַם פון דער שפּראַך.
מאַגיש מעטהאָדס זענען אַ סכום פון פאַר-מיטלעןdefiניטעס אין פּיטהאָן וואָס צושטעלן ספּעציעל סינטאַקטיק פֿעיִקייטן. זיי זענען לייכט דערקענט דורך זייער טאָפּל דאַשאַז אין די אָנהייב און סוף, ווי __init__, __call__, __len__ … עטק.
מאַגיש מעטהאָדס לאָזן מנהג אַבדזשעקץ צו ביכייווז ענלעך צו די געבויט-אין פּיטהאָן טייפּס.
אין דעם אַרטיקל, מיר וועלן פאָקוס אויף די שטאַרק דאַנדער פאַנגקשאַנז. מיר וועלן ויספאָרשן זייער ציל און דיסקוטירן זייער נוצן.
צי איר זענט אַ פּיטהאָן אָנהייבער אָדער אַ יקספּיריאַנסט פּראָגראַמיסט, דער אַרטיקל יימז צו צושטעלן אַ פולשטענדיק פארשטאנד פון דאַנדער פאַנגקשאַנז, מאכן דיין פּיטהאָן קאָדירונג דערפאַרונג מער עפעקטיוו און ענדזשויאַבאַל.
געדענקט, די מאַגיש פון Python ליגט ניט בלויז אין זיין פּאַשטעס און ווערסאַטילאַטי, אָבער אויך אין זיין שטאַרק פֿעיִקייטן ווי Dunder פאַנגקשאַנז.
טאָמער די מערסט יקערדיק דאַנדער פונקציע פון אַלע. דאָס איז דער מאַגיש אופֿן וואָס פּיטהאָן אויטאָמאַטיש רופט ווען מיר שאַפֿן (אָדער ווי דער נאָמען סאַגדזשעס, ינישאַלייז) אַ נייַע כייפעץ.__init__
קלאַס פּיצאַ:
דעף __יניט__ (זיך, גרייס, טאַפּינגז):
self.size = גרייס
self.topings = טאַפּינגז
# יעצט לאמיר מאכן א פיצע
my_pizza = פּיצאַ ('גרויס', ['פּעפּעראָני', 'מאַשרומז'])
print(my_pizza.size) # דאָס וועט דרוקן: גרויס
print(my_pizza.toppings) # דאָס וועט דרוקן: ['פּעפּעראָני', 'מאַשרומז']
אין דעם בייַשפּיל, אַ קלאַס גערופן פּיצאַ איז באשאפן. מיר שטעלן אונדזער __init__ פֿונקציע צו אַרייַננעמען פּאַראַמעטערס צו ספּעציפיצירן אין יניטיאַליזאַטיאָן צייט, און שטעלן זיי ווי פּראָפּערטיעס פֿאַר אונדזער מנהג כייפעץ.
דאָ, עס איז געניצט צו פאָרשטעלן דעם בייַשפּיל פון די קלאַס. אַזוי ווען מיר שרייַבן self.size = גרייס, מיר זאָגן, "היי, דעם פּיצע כייפעץ האט אַ אַטריביוט גרייס size, און איך ווילן עס צו זיין וועלכער גרייס איך צוגעשטעלט ווען איך באשאפן דעם כייפעץ".
דאָס איז די מאַגיש אופֿן פון Python וואָס אַלאַוז אונדז צו defiגעבן אַ באַשרייַבונג פֿאַר אונדזער מנהג נומער.
ווען איר דרוקן אַ כייפעץ אָדער גער עס צו אַ שטריקל ניצן str(), Python טשעק אויב איר האָבן defiאיך האב פארשטאנען א שיטה __str__ פֿאַר דעם כייפעץ ס קלאַס.
אויב אַזוי, נוצן דעם אופֿן צו בייַטן די כייפעץ צו אַ שטריקל.
מיר קענען פאַרברייטערן אונדזער פּיצאַ בייַשפּיל צו אַרייַננעמען אַ פֿונקציע __str__ ווי גייט:
קלאַס פּיצאַ: דעף __יניט__ (זיך, גרייס, טאַפּינגז): self.size = גרייס self.toppings = טאַפּינגז דעף __str__ (זיך): צוריקקומען f"א {self.size} פּיצע מיט {', '.join(self.toppings )}" my_pizza = פּיצאַ('גרויס', ['פּעפּעראָני', 'מאַשרומז']) print(my_pizza) # דאס וועט דרוקן: א גרויסע פּיצע מיט פעפעראָני, מאַשרומז
__repr__די __str__ פֿונקציע איז מער אַ ינפאָרמאַל וועג צו דיסקרייבינג די פּראָפּערטיעס פון אַ כייפעץ. אויף די אנדערע האַנט, __repr__ איז געניצט צו צושטעלן אַ מער פאָרמאַל, דיטיילד און אַנאַמביגיואַס באַשרייַבונג פון די מנהג כייפעץ.
אויב איר רופן repr() אויף אַ כייפעץ אָדער איר נאָר דרוקן די כייפעץ נאָמען אין די קאַנסאָול, Python וועט קוקן פֿאַר אַ אופֿן __repr__.
Se __str__ ס 'איז נישט defiניט, פּיטהאָן וועט נוצן __repr__ ווי אַ באַקאַפּ ווען טריינג צו דרוקן די כייפעץ אָדער גער עס צו אַ שטריקל. אַזוי עס איז אָפט אַ גוט געדאַנק defiענדיקן בייַ מינדסטער __repr__, אפילו אויב איר טאָן ניט defiקומט ארויס __str__.
דאָ ס ווי מיר קען defiענדיקן __repr__ פֿאַר אונדזער פּיצאַ בייַשפּיל:
קלאַס פּיצאַ:
דעף __יניט__ (זיך, גרייס, טאַפּינגז):
self.size = גרייס
self.topings = טאַפּינגז
דעף __repr__ (זיך):
צוריקקומען f"Pizza('{self.size}', {self.topings})"
my_pizza = פּיצאַ ('גרויס', ['פּעפּעראָני', 'מאַשרומז'])
print(repr(my_pizza)) # דאָס וועט דרוקן: פּיצאַ('גרויס', ['פּעפּעראָני', 'מאַשרומז'])
__repr__ גיט איר אַ שטריקל אַז איר קענען לויפן ווי אַ פּיטהאָן באַפֿעל צו ריקריייט די פּיצע כייפעץ, כוועראַז __str__ גיט איר אַ מער מענטש באַשרייַבונג. איך האָפֿן עס העלפּס איר קייַען די דאַנדער מעטהאָדס אַ ביסל בעסער!
אין Python, מיר אַלע וויסן אַז עס איז מעגלעך צו לייגן נומערן ניצן די אָפּעראַטאָר +, ווי 3 + 5.
אָבער וואָס אויב מיר ווילן צו לייגן ינסטאַנסיז פון עטלעכע מנהג כייפעץ?
די דאַנדער פֿונקציע __add__ עס אַלאַוז אונדז צו טאָן פּונקט אַז. עס גיט אונדז די פיייקייַט צו defiניט די נאַטור פון דער אָפּעראַטאָר + אויף אונדזער פערזענליכען זאכן.
אין דעם אינטערעס פון קאָנסיסטענסי, לאָזן ס יבערנעמען מיר וועלן צו defiענדיקן די נאַטור פון + אויף אונדזער פּיצאַ בייַשפּיל. זאל ס זאָגן אַז ווען מיר לייגן צוויי אָדער מער פּיצאַז צוזאַמען, עס וועט אויטאָמאַטיש פאַרבינדן אַלע זייער טאַפּינגז. דאָ ס וואָס עס קען קוקן ווי:
קלאַס פּיצאַ:
דעף __יניט__ (זיך, גרייס, טאַפּינגז):
self.size = גרייס
self.topings = טאַפּינגז
דעף __אַדד__ (זיך, אנדערע):
אויב נישט איז (אנדערע, פּיצאַ):
כאַפּן טיפּערראָר ("איר קענט בלויז לייגן אן אנדער פּיצאַ!")
ניו_טאָפּינגס = זיך.טאָפּינגס + אנדערע.טאַפּינגז
צוריקקומען פּיצאַ (זיך. גרייס, נייַ_טאַפּינגס)
# לאָמיר מאַכן צוויי פּיצעס
pizza1 = פּיצאַ('גרויס', ['פּעפּעראָני', 'מאַשרומז'])
pizza2 = פּיצאַ('גרויס', ['אָליוועס', 'אַנאַנאַס'])
# און יעצט לאמיר זיי " צוגעבן "
קאַמביינד_פּיצאַ = פּיצאַ1 + פּיצאַ2
print(combined_pizza.toppings) # דאָס וועט דרוקן: ['פּעפּעראָני', 'מאַשרומז', 'אָליוועס', 'אַנאַנאַס']
אזוי ווי דונדער __add__, מיר קענען אויך defiענדיקן אנדערע אַריטמעטיק פאַנגקשאַנז אַזאַ ווי __sub__ (דורך כיסער ניצן די אָפּעראַטאָר -) און __mul__ (פֿאַר קייפל ניצן די אָפּעראַטאָר *).
דעם דאַנדער אופֿן אַלאַוז אונדז צו defiענדיקן וואָס די פֿונקציע len() מוזן צוריקקומען פֿאַר אונדזער קאַסטאַמייזד זאכן.
פּיטהאָן ניצט len() צו באַקומען די לענג אָדער גרייס פון אַ דאַטן סטרוקטור אַזאַ ווי אַ רשימה אָדער שטריקל.
אין דעם קאָנטעקסט פון אונדזער בייַשפּיל, מיר קען זאָגן אַז די "לענג" פון אַ פּיצאַ איז די נומער פון טאַפּינגז עס האט. דאָ ס ווי מיר קענען ינסטרומענט עס:
קלאַס פּיצאַ:
דעף __יניט__ (זיך, גרייס, טאַפּינגז):
self.size = גרייס
self.topings = טאַפּינגז
דעף __len__ (זיך):
return len(self.topings)
# לאָמיר מאַכן אַ פּיצע
my_pizza = פּיצאַ ('גרויס', ['פּעפּעראָני', 'מאַשרומז', 'אָליוועס'])
print(len(my_pizza)) # דאָס וועט דרוקן: 3
אין די __len__ אופֿן, מיר נאָר צוריקקומען די לענג פון דער רשימה toppings. איצט, len(my_pizza) עס וועט זאָגן אונדז ווי פילע טאַפּינגז זענען אויף עס my_pizza.
דעם דאַנדער אופֿן אַלאַוז אַבדזשעקץ צו זיין יטעראַבאַל, ד"ה עס קענען זיין געוויינט אין אַ פֿאַר שלייף.
צו טאָן דאָס, מיר מוזן אויך defiענדיקן די פֿונקציע __next__, דאס איז געניצט פֿאַר defiניש די נאַטור וואָס זאָל צוריקקומען די ווייַטער ווערט אין די יטעראַטיאָן. עס זאָל אויך סיגנאַל די יטעראַבלע אויף דער געשעעניש אַז עס זענען ניט מער עלעמענטן אין די סיקוואַנס. מיר טיפּיקלי דערגרייכן דעם דורך פארווארפן אַ ויסנעם StopIteration.
פֿאַר אונדזער פּיצע בייַשפּיל, לאָזן ס זאָגן מיר ווילן צו יטערייט די טאַפּינגז. מיר קענען מאַכן אונדזער פּיצאַ קלאַס יטעראַבאַל defiנעדאָ אַ אופֿן __iter__:
קלאַס פּיצאַ:
דעף __יניט__ (זיך, גרייס, טאַפּינגז):
self.size = גרייס
self.topings = טאַפּינגז
דעף __iter__ (זיך):
self.n = 0
צוריקקומען זיך
דעף __ווייַטער __ (זיך):
if self.n <len(self.topings):
רעזולטאַט = self.topings[self.n]
self.n += 1
צוריקקומען רעזולטאַט
אַנדערש:
כאַפּן StopIteration
# לאָמיר מאַכן אַ פּיצע
my_pizza = פּיצאַ ('גרויס', ['פּעפּעראָני', 'מאַשרומז', 'אָליוועס'])
# און יעצט לאמיר איבער דעם איבערחזרן
פֿאַר טאַפּינג אין מיין_פּיצאַ:
דרוק (טאַפּינג)
אין דעם פאַל, די פֿאַר שלייף רופט __iter__, וואָס ינישאַלייזיז אַ טאָמבאַנק (self.n) און קערט די פּיצאַ כייפעץ זיך (self).
דערנאָך, די פֿאַר שלייף רופט __next__ צו באַקומען יעדער טאַפּינג אין קער.
ווען __next__ אומגעקערט אַלע געווירץ, StopIteration עס ווארפט ער אַן אויסנאַם און די פֿאַר שלייף איצט ווייסט אַז עס זענען ניט מער טאַפּינגז און אַזוי וועט אַבאָרט די יטעראַטיאָן פּראָצעס.
Ercole Palmeri
Coveware דורך Veeam וועט פאָרזעצן צו צושטעלן ענטפער באַדינונגס פֿאַר סייבער יקסטאָרשאַן אינצידענט. קאָוועוואַרע וועט פאָרשלאָגן פאָרענסיקס און רימעדייישאַן קייפּאַבילאַטיז ...
פּרידיקטיוו וישאַלט איז רעוואַלושאַנייזינג די ייל & גאַז סעקטאָר, מיט אַן ינאַווייטיוו און פּראָואַקטיוו צוגאַנג צו פאַבריק פאַרוואַלטונג.…
די UK CMA האט ארויס אַ ווארענונג וועגן ביג טעק ס נאַטור אין די קינסטלעך סייכל מאַרק. דאָרט…
די "קאַסע גרין" דעקרעט, פארמולירט דורך די אייראפעישע יוניאַן צו פאַרבעסערן די ענערגיע עפעקטיווקייַט פון בנינים, האט פארענדיקט זיין לעגיסלאַטיווע פּראָצעס מיט ...