טיש פון קאָנטענץ[באַהאַלטן][ווייַזן]
אין דעם לעקציע, מיר וועלן לערנען וועגן קלאסן, קאַנסטראַקטערז און ירושה אין פּיטהאָן.
די קאַנסעפּס זענען טאַקע וויכטיק אין אַ גרויס פּראָגראַם ווו פאַרשידענע טייפּס זענען דארף צו זיין דיפיינד.
קלאסן
קלאסן זענען יקערדיק אין פּראָגראַממינג און זיי זענען נישט ספּעציפיש צו פּיטהאָן. פילע אנדערע פּראָגראַממינג שפּראַכן שטיצן דעם געדאַנק פון קלאסן. מיר נוצן קלאסן צו דעפינירן נייַע דאַטן טייפּס.
ביז איצט, מיר האָבן געלערנט וועגן די יקערדיק דאַטן טייפּס אין פּיטהאָן ווי נומערן, סטרינגס און בולאַנז. דאָס זענען די יקערדיק אָדער פּשוט דאַטן טייפּס אין פּיטהאָן. מיר האָבן אויך געזען אַ פּאָר פון קאָמפּלעקס דאַטן טייפּס ווי רשימות און דיקשאַנעריז.
כאָטש די טייפּס זענען גאָר נוציק, זיי קענען נישט שטענדיק זיין געוויינט צו מאָדעל קאָמפּלעקס קאַנסעפּס. למשל, טראַכטן וועגן דעם געדאַנק פון אַ פונט אָדער אַ שאַפּינג וואָגן. א שאַפּינג וואָגן איז נישט אַ בוליאַן אָדער אַ רשימה. עס איז אַ אַנדערש סאָרט פון דאַטן. אַזוי מיר קענען נוצן קלאסן צו דעפינירן נייַע טייפּס צו מאָדעל פאַקטיש קאַנסעפּס.
איצט, לאָמיר דעפינירן אַ נייַע דאַטן טיפּ גערופן פונט. דער נייַע טיפּ וועט האָבן מעטהאָדס ווי מיר אָפּגעשטעלט פריער.
דאָס איז ווי איר וועט טאָן דאָס:
מיר אָנהייבן מיט דיפיינינג אַ קלאַס דורך ניצן די "קלאַס" קיווערד און גלייך דערנאָך מיר געבן אונדזער קלאַס אַ נאָמען.
class Point
איצט, קוק אין די נאַמינג קאַנווענשאַן איך האָבן געוויינט דאָ. איך'ווע קאַפּיטאַלייזד דעם ערשטער בריוו דאָ, דאָס איז וואָס מיר רופן אַ פּאַסקאַל נאַמינג קאַנווענשאַן. די קאַנווענשאַן איז אַנדערש פון די וואָס מיר נוצן פֿאַר נאַמינג אונדזער וועריאַבאַלז און פאַנגקשאַנז פֿאַר וואָס מיר שטענדיק נוצן נידעריק אותיות און באַזונדער קייפל ווערטער ניצן אַן אַנדערסקאָר. אבער ווען נאַמינג קלאסן, מיר טאָן ניט נוצן אַן אַנדערסקאָר צו באַזונדער קייפל ווערטער אַנשטאָט, מיר קאַפּיטאַלייז דער ערשטער בריוו פון יעדער וואָרט.
נאָך דיפיינינג אונדזער קלאַס, אַ צווייפּינטל איז געניצט וואָס מיטל אַז איצט אַ בלאָק איז דיפיינד.
class Point:
def move (self):
אין דעם בלאָק, מיר קענען דעפינירן אַלע די פאַנגקשאַנז אָדער מעטהאָדס וואָס געהערן צו פונקטן. פֿאַר בייַשפּיל, מיר קענען דעפינירן אַ פֿונקציע גערופֿן "מאַך" פֿאַר מאָווינג אַ פונט. באַמערקונג אַז ווי באַלד ווי מיר טיפּ אָפֿן קלאַמערן, PyCharm אויטאָמאַטיש מוסיף "זיך" דאָ. דאָס איז אַ ספּעציעל קיווערד און לאָזן מיר צוריקקומען צו דעם באַלד. לאָמיר דרוקן "מאַך" אויף די וואָקזאַל.
print("move")
לאָמיר דעפינירן אן אנדער אופֿן ווי "ציען" און דרוקן עס אויף די וואָקזאַל.
def draw(self):
print("draw")
מיר זענען פאַרטיק מיט די דעפֿיניציע פון אונדזער "פונט" קלאַס. מיט דעם נייַע טיפּ, מיר קענען מאַכן נייַע אַבדזשעקץ. א קלאַס פשוט דיפיינז די פּלאַן אָדער די מוסטער פֿאַר קריייטינג אַבדזשעקץ וואָס זענען די פאַקטיש ינסטאַנסיז באזירט אויף דעם פּלאַן. צו שאַפֿן אַ כייפעץ, מיר דרוקן די נאָמען פון אונדזער קלאַס און דעמאָלט רופן עס פּונקט ווי אַ פֿונקציע. דעם קריייץ אַ נייַ כייפעץ און דעמאָלט קערט עס. דערנאָך מיר קענען קראָם דעם כייפעץ אין אַ בייַטעוודיק. לאמיר דיר ווייזן:
דאָ מיר האָבן דיפיינד אַ "פּוינט 1" וואָס איז אַ דריי-דימענשאַנאַל פונט. איר קענען זען אַז, מיר קענען דרוקן יחיד קאָואָרדאַנאַץ אויף די וואָקזאַל.
מיר קענען נוצן די צוויי מעטהאָדס "ציען" און "מאַך" מיט דעם פונט.
אַזוי צו רעקאַפּ, מיר נוצן קלאסן צו דעפינירן נייַע טייפּס און די טייפּס קענען האָבן מעטהאָדס וואָס מיר דעפינירן אין דעם גוף פון די קלאַס. קלאסן קענען האָבן אַטריביוץ וואָס מיר קענען שטעלן ערגעץ אין אונדזער מגילה.
קאָנסטרוקטאָרס
ביז איצט, מיר האָבן געלערנט ווי צו שאַפֿן נייַע טייפּס מיט קלאסן. איצט עס איז אַ קליין פּראָבלעם מיט דעם ימפּלאַמענטיישאַן. מיר קענען מאַכן אַ פונט כייפעץ אָן אַ X אָדער י קאָואָרדאַנאַט ניצן קלאסן און דאָס איז נישט ידעאַל. לאמיך דיר ווייזן.
לאָמיר מאַכן אַ פונט און דרוקן עס איידער מיר שטעלן די X קאָואָרדאַנאַט. פליסנדיק אונדזער פּראָגראַם רעזולטאַט אין אַ אַטריביוט טעות ווי דעם:
עס מיטל אַז די פונט כייפעץ האט קיין אַטריביוט גערופן X. איצט דער פּראָבלעם איז אַז עס איז מעגלעך צו האָבן אַ פונט כייפעץ אָן X אָדער y קאָואָרדאַנאַץ. דאָס טוט נישט מאַכן זינען ווייַל ווען מיר רעדן וועגן אַ פונט, מיר דאַרפֿן צו וויסן ווו די פונט איז ליגן. צו סאָלווע דעם פּראָבלעם, מיר נוצן אַ קאַנסטראַקטער. א קאָנסטרוקטאָר איז אַ פֿונקציע וואָס ווערט גערופן אין דער צייט פון קריייטינג אַ כייפעץ.
דאָ איז ווי מיר נוצן אַ קאַנסטראַקטער. ערשטער, לאָזן אונדז פאָרן די רענטגענ און י קאָואָרדאַנאַץ וואַלועס אין די אויבן פּראָגראַם.
point = Point(10, 20)
print(point.x)
איצט, מיר דאַרפֿן צו לייגן אַ ספּעציעל אופֿן אין דעם קלאַס גערופן אַ קאַנסטראַקטער. זייַן סינטאַקס איז ווי דאָס:
def __init__(self, x, y):
init
איז קורץ פֿאַר יניטיאַליזעד, און דאָס איז די פֿונקציע אָדער דער אופֿן וואָס ווערט גערופן ווען אַ נייַע פונט כייפעץ איז באשאפן. די רענטגענ און י זענען מוסיף גלייך נאָך self
צו לייגן צוויי עקסטרע פּאַראַמעטערס.
נאָך דעם, מיר זאָל מאַפּע די X און y צו די דורכגעגאנגען וואַלועס הייסט 10 און 20
self.x = x
self.y = y
מיר נוצן די self
צו אָפּשיקן צו דעם קראַנט כייפעץ און דעמאָלט מיר שטעלן די X אַטריביוט צו די X אַרגומענט דורכגעגאנגען צו די פֿונקציע "X". אין דעם וועג, ניצן init
אופֿן, מיר קענען ינישאַלייז אונדזער אַבדזשעקץ. דעם אופֿן איז ריפערד צו ווי אַ קאַנסטראַקטער. לאָמיר לויפן אונדזער פּראָגראַם.
איצט מיר קענען טוישן די X און y קאָואָרדאַנאַץ שפּעטער. זאל ס דערהייַנטיקן x קאָואָרדאַנאַט:
point = Point(10, 20)
point.x = 11
print(point.x)
איצט, די X קאָואָרדאַנאַט איז דערהייַנטיקט צו ווערט 11.
געניטונג
דאָ ס אַ טשיקאַווע געניטונג פֿאַר איר.
איך ווילן איר צו דעפינירן אַ נייַע טיפּ גערופן אַ מענטש. די "מענטש" אַבדזשעקץ זאָל האָבן אַ "name
" אַטריביוט און אַ "talk()
”אופֿן.
עס איז אַ פּשוט אַרבעט און זאָל נישט נעמען מער ווי אַ פּאָר פון מינוט.
באַשייד
אָנהייבן מיט דיפיינינג די קלאַס "מענטש" ווי דאָס:
class Person:
self.name = name
מיר וועלן דעפינירן די קאַנסטראַקטער שפּעטער. איצט מיר קענען מאַכן די "מענטש" כייפעץ. זאל ס רופן עס יוחנן
john = Person("John Smith")
print(john.name)
john.talk()
איצט, גיין צו דער ערשטער חלק פון די קאָד און שאַפֿן אַ קאַנסטראַקטער.
def __init__(self, name):
די לעצט קאָד וועט קוקן ווי דאָס:
איר קענט אויך נוצן פאָרמאַטטעד סטרינגס און אנדערע קאַנסעפּס אין קאַנדזשאַנגקשאַן מיט קלאסן און קאַנסטראַקטערז.
יערושע
ירושה איז אן אנדער באַגריף פֿאַרבונדן מיט קלאסן וואָס לאָזן איר רייוז אַ קאָד.
באַטראַכטן דעם שטיק פון קאָד.
class Dog:
def walk(self):
print("walk")
מיר האָבן באשאפן אַ קלאַס "הונט" מיט אַ "גיין" אופֿן. אין דעם אופֿן, מיר נאָר דרוקן די גיין אָנזאָג אויף די וואָקזאַל. זאל ס זאָגן, אין אַ פאַקטיש פּראָגראַם, עס זענען 10 שורות פון קאָד אַנשטאָט פון בלויז איין שורה דאָ. אין דער צוקונפֿט, אויב אן אנדער קלאַס איז דארף צו האָבן די "גיין" אופֿן, מיר וועלן האָבן צו איבערחזרן אַלע דעם קאָד. דאָס איז נישט ידעאַל.
אין פּראָגראַממינג, מיר האָבן אַ פּרינציפּ גערופן DRY וואָס איז קורץ פֿאַר טאָן ניט איבערחזרן זיך. לאָמיר זאָגן אַמאָל אין דער צוקונפֿט, מיר אַנטדעקן אַ פּראָבלעם מיט אונדזער "גיין" אופֿן און אויב מיר האָבן ריפּיטיד אָדער דופּליקייטיד דעם אופֿן אין פילע אנדערע ערטער, מיר וועט האָבן צו קומען צוריק און פאַרריכטן דעם פּראָבלעם אין יעדער אָרט וואָס מיר האָבן דופּליקייטיד דעם. קאָד. אַזוי אַז ס וואָס אין פּראָגראַממינג מיר זאָל נישט דעפינירן עפּעס צוויי מאָל.
עס זענען פאַרשידענע אַפּראָוטשיז צו סגולע דעם פּראָבלעם אָבער דאָ מיר זענען געגאנגען צו לערנען די וואָס איז גרינגער פֿאַר ביגינערז און עס איז גערופן ירושה. אין דעם פאַל, מיר וועלן מאַכן אן אנדער קלאַס "מאַמאַל" און דעפינירן אונדזער "גיין" אַטריביוט אין דעם קלאַס.
class Mammal:
def walk(self):
print("walk")
נאָך דיפיינינג אונדזער "מאַמאַל" קלאַס, מיר קענען נוצן ירושה צו פאָרן די אַטריביוץ ווי דאָס:
ביידע הונט און קאַץ קלאסן ינכעראַטיד אַלע די קלאַס מעטהאָדס דיפיינד אין זייער פאָטער קלאַס. איצט, מיר קענען לייגן מעטהאָדס ספּעציפיש צו הינט ווי דאָס:
class Dog:
def bark(self):
print("bark")
נעם צוזאם!
דאָס איז געווען אַלע וועגן די קלאסן, קאַנסטראַקטערז און ריוזינג די קאָד אין קלאסן מיט ירושה קאַנסעפּס. איצט מיר זענען נירינג די סוף פון אונדזער סעריע. דורך דעם פונט, איר זאָל קענען צו פּראָדוצירן גוט, ליינעוודיק און קאַנסייס קאָודז אין פּיטהאָן.
מיר וועלן זען דעם באַגריף פון מאַדזשולז און פּאַקאַדזשאַז אין דער ווייַטער לעקציע.
לאָזן אַ ענטפֿערן