рдореБрдЦреНрдп рд╕рд╛рдордЧреНрд░реА рдкрд░ рдЬрд╛рдПрдБ

Python рдореЗрдВ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рдХреИрд╕реЗ рд▓рд┐рдЦреЗрдВ

рдЙрдиреНрдирдд рддрдХрдиреАрдХреЛрдВ рдХреЗ рд╕рд╛рде Python рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдЬрд╛рдиреЗрдВ рдФрд░ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рдХреЛрдб рдХрд░реЗрдВред рдмреЗрд╣рддрд░ рдкреНрд░рджрд░реНрд╢рди рдХреЗ рд▓рд┐рдП рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЕрднреНрдпрд╛рд╕ рджреЗрдЦреЗрдВред
┬╖ 10 рдорд┐ре░ рдкрдврд╝реЗрдВ

AI рдХреЗ рд╕рд╛рде рдЦреЛрдЬреЗрдВ

Python рдореЗрдВ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдирд╛ рдРрд╕реА рдордЬрд╝рдмреВрдд рдПрдкреНрд▓рд┐рдХреЗрд╢рди рд╡рд┐рдХрд╕рд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рд╣реИ рдЬреЛ рд╡рд┐рднрд┐рдиреНрди рд╕рд┐рд╕реНрдЯрдо рдмрд╛рдзрд╛рдУрдВ рдореЗрдВ рднреА рдЕрдЪреНрдЫрд╛ рдкреНрд░рджрд░реНрд╢рди рдХрд░реЗрдВред рдХреБрд╢рд▓ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рд░рдирдЯрд╛рдЗрдо рдХреЛ рддреЗрдЬрд╝ рдХрд░рддрд╛ рд╣реИ рдФрд░ рдХрдо рд╕рдВрд╕рд╛рдзрди рдЦрдкрдд рдХреЗ рд╕рд╛рде рд╕реНрдХреЗрд▓реЗрдмрд┐рд▓рд┐рдЯреА рдмрдврд╝рд╛рддрд╛ рд╣реИ, рдЬреЛ рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ рд╕реАрдорд┐рдд рдореЗрдореЛрд░реА рд╡рд╛рд▓реЗ рд╡рд╛рддрд╛рд╡рд░рдг рдореЗрдВ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реЛрддрд╛ рд╣реИред

рдЗрд╕ рд▓реЗрдЦ рдореЗрдВ, рдореИрдВ рдЖрдкрдХреЛ Python рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдХреА рдмреБрдирд┐рдпрд╛рджреА рдмрд╛рддреЗрдВ рдмрддрд╛рдКрдВрдЧрд╛ рдФрд░ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдиреЗ рдХреА рдЕрд▓рдЧ-рдЕрд▓рдЧ рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рддрдХрдиреАрдХреЗрдВ рдкреНрд░рд╕реНрддреБрдд рдХрд░реВрдВрдЧрд╛ред рдЪрд╛рд╣реЗ рдЖрдк рдЬрдЯрд┐рд▓ рд╕рд┐рд╕реНрдЯрдо рдмрдирд╛ рд░рд╣реЗ рд╣реЛрдВ рдпрд╛ рд╕рд╛рдзрд╛рд░рдг рд╕реНрдХреНрд░рд┐рдкреНрдЯ, рдпреЗ рдЬрд╛рдирдХрд╛рд░рд┐рдпрд╛рдБ рдЖрдкрдХреЛ рдФрд░ рдЕрдзрд┐рдХ рд╕рд╛рдлрд╝-рд╕реБрдерд░рд╛ рдФрд░ рдХреБрд╢рд▓ Python рдХреЛрдб рд▓рд┐рдЦрдиреЗ рдореЗрдВ рдорджрдж рдХрд░реЗрдВрдЧреАред

Python рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдХреА рдмреБрдирд┐рдпрд╛рджреА рдмрд╛рддреЗрдВ

Python рдХрд╛ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рд╕рд┐рд╕реНрдЯрдо рдкрд░рд┐рд╖реНрдХреГрдд рд╣реИ рдФрд░ рдореЗрдореЛрд░реА рдСрдкрд░реЗрд╢рдиреЛрдВ рдХреА рдЬрдЯрд┐рд▓рддрд╛ рдХреЛ рд╕рдВрднрд╛рд▓рдХрд░ рд╡рд┐рдХрд╛рд╕ рдХреЛ рд╕рд░рд▓ рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдбрд┐рдЬрд╝рд╛рдЗрди рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред рдпрд╣ рд╕рд┐рд╕реНрдЯрдо рдЗрд╕ рдмрд╛рдд рдХреЛ рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рд╣реИ рдХрд┐ Python рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдХреБрд╢рд▓рддрд╛ рд╕реЗ рдЪрд▓реЗрдВред

Python рдореЗрдореЛрд░реА рдХреЛ рдХреИрд╕реЗ рдореИрдиреЗрдЬ рдХрд░рддрд╛ рд╣реИ

Python рдХреЗ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдХреЗ рдХреЗрдВрджреНрд░ рдореЗрдВ рдкреНрд░рд╛рдЗрд╡реЗрдЯ рд╣реАрдк рд╣реЛрддрд╛ рд╣реИред рдпрд╣реАрдВ рдкрд░ рд╕рднреА Python рдСрдмреНрдЬреЗрдХреНрдЯ рдФрд░ рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рд╕рдВрдЧреНрд░рд╣реАрдд рд╣реЛрддреЗ рд╣реИрдВред рдкреНрд░реЛрдЧреНрд░рд╛рдорд░ рд╕реАрдзреЗ рдЗрд╕ рдкреНрд░рд╛рдЗрд╡реЗрдЯ рд╣реАрдк рддрдХ рдкрд╣реБрдБрдЪ рдирд╣реАрдВ рд╕рдХрддреЗ; рд╡реЗ Python рдХреЗ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рд╕рд┐рд╕реНрдЯрдо рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЗ рд╕рд╛рде рдЗрдВрдЯрд░реИрдХреНрдЯ рдХрд░рддреЗ рд╣реИрдВред

рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рд╕рд┐рд╕реНрдЯрдо рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИ:

  • рдореЗрдореЛрд░реА рдЕрд▓реЛрдХреЗрдЯрд░: Python рдПрдХ рдЗрди-рдмрд┐рд▓реНрдЯ рдореЗрдореЛрд░реА рдЕрд▓реЛрдХреЗрдЯрд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИ рдЬреЛ рдореЗрдореЛрд░реА рдмреНрд▓реЙрдХреЛрдВ рдХреЗ рдЖрд╡рдВрдЯрди рдФрд░ рдбреАрд▓реЛрдХреЗрд╢рди рдХреЛ рдкреНрд░рдмрдВрдзрд┐рдд рдХрд░рддрд╛ рд╣реИред рдпрд╣ рдЕрд▓реЛрдХреЗрдЯрд░ рдЫреЛрдЯреЗ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЗ рд▓рд┐рдП тАЬрдлреНрд░реА рд▓рд┐рд╕реНрдЯреНрд╕тАЭ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝ рдХрд░рддрд╛ рд╣реИ, рдЬреЛ рдкрд╣рд▓реЗ рд╕реЗ рдЖрд╡рдВрдЯрд┐рдд рдореЗрдореЛрд░реА рдмреНрд▓реЙрдХреЛрдВ рдХреЛ рдкреБрди: рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рднрд╡рд┐рд╖реНрдп рдХреЗ рдЖрд╡рдВрдЯрдиреЛрдВ рдХреЛ рддреЗрдЬрд╝ рдХрд░рддрд╛ рд╣реИред рдЕрдзрд┐рдХ рдЬрдЯрд┐рд▓ рдСрдмреНрдЬреЗрдХреНрдЯ, рдЬреИрд╕реЗ рд▓рд┐рд╕реНрдЯ рдФрд░ рдбрд┐рдХреНрд╢рдирд░реА, рдХреЗ рд▓рд┐рдП Python рдЙрдирдХреЗ рдЖрдХрд╛рд░ рдХреЗ рдмрджрд▓рд╛рд╡реЛрдВ рдХреЛ рд╕рдВрднрд╛рд▓рдиреЗ рд╣реЗрддреБ рдбрд╛рдпрдиреЗрдорд┐рдХ рдореЗрдореЛрд░реА рдЕрд▓реЛрдХреЗрд╢рди рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИред
  • рдореЗрдореЛрд░реА рдкреВрд▓: Python рдУрд╡рд░рд╣реЗрдб рдФрд░ рдлреНрд░реИрдЧреНрдореЗрдВрдЯреЗрд╢рди рдХреЛ рдХрдо рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдСрдмреНрдЬреЗрдХреНрдЯ рдЖрдХрд╛рд░ рдХреЗ рдЕрдиреБрд╕рд╛рд░ рдореЗрдореЛрд░реА рдХреЛ рдкреВрд▓реНрд╕ рдореЗрдВ рд╡реНрдпрд╡рд╕реНрдерд┐рдд рдХрд░рддрд╛ рд╣реИред рдЗрд╕рд╕реЗ рд╕рдорд╛рди рдЖрдХрд╛рд░ рдХреЗ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рд╕рдореВрд╣рд┐рдд рдХрд░ рдореЗрдореЛрд░реА рдХрд╛ рдЕрдзрд┐рдХ рдХреБрд╢рд▓ рдкреНрд░рдмрдВрдзрди рд╣реЛрддрд╛ рд╣реИред

рдореЗрдореЛрд░реА рдбреАрд▓реЛрдХреЗрд╢рди рдФрд░ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрд╢рди

Python рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрд╢рди рдХреЗ рд▓рд┐рдП рджреНрд╡рд┐-рдЖрдпрд╛рдореА рджреГрд╖реНрдЯрд┐рдХреЛрдг рдЕрдкрдирд╛рддрд╛ рд╣реИ:

  • рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛рдЙрдВрдЯрд┐рдВрдЧ: рдпрд╣ рдкреНрд░рд╛рдердорд┐рдХ рд╡рд┐рдзрд┐ рд╣реИ рдЬрд┐рд╕рдореЗрдВ Python рдкреНрд░рддреНрдпреЗрдХ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЗ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХреЛ рдЯреНрд░реИрдХ рдХрд░рддрд╛ рд╣реИред рдЬрдм рдХрд┐рд╕реА рдСрдмреНрдЬреЗрдХреНрдЯ рдХрд╛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛рдЙрдВрдЯ рд╢реВрдиреНрдп рдкрд░ рдЖ рдЬрд╛рддрд╛ рд╣реИ, рдпрд╛рдиреА рдЙрд╕ рдкрд░ рдХреЛрдИ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдирд╣реАрдВ рд░рд╣рддрд╛, рддреЛ рдореЗрдореЛрд░реА рдЕрд▓реЛрдХреЗрдЯрд░ рдЙрд╕рдХреА рдореЗрдореЛрд░реА рддреБрд░рдВрдд рдореБрдХреНрдд рдХрд░ рджреЗрддрд╛ рд╣реИред
  • рд╕рд╛рдЗрдХреНрд▓рд┐рдХ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░: рдкрд░рд╕реНрдкрд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ (рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕) рдХреЛ рд╕рдВрднрд╛рд▓рдиреЗ рдХреЗ рд▓рд┐рдП Python рдореЗрдВ рдПрдХ рд╕рд╛рдЗрдХреНрд▓рд┐рдХ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рд╢рд╛рдорд┐рд▓ рд╣реИ, рдЬрд┐рд╕реЗ рдХреЗрд╡рд▓ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛рдЙрдВрдЯрд┐рдВрдЧ рд╕реЗ рд╕рдВрднрд╛рд▓рд╛ рдирд╣реАрдВ рдЬрд╛ рд╕рдХрддрд╛ред рдпрд╣ рдХрд▓реЗрдХреНрдЯрд░ рд╕рдордп-рд╕рдордп рдкрд░ рдРрд╕реЗ рдСрдмреНрдЬреЗрдХреНрдЯ рд╕рдореВрд╣реЛрдВ рдХреА рдкрд╣рдЪрд╛рди рдХрд░ рдЙрдиреНрд╣реЗрдВ рд╕рд╛рдл рдХрд░рддрд╛ рд╣реИ рдЬреЛ рдПрдХ-рджреВрд╕рд░реЗ рдХреЛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд░рддреЗ рд╣реИрдВ рд▓реЗрдХрд┐рди рдкреНрд░реЛрдЧреНрд░рд╛рдо рдореЗрдВ рдЕрдиреНрдпрддреНрд░ рдЙрдкрдпреЛрдЧ рдореЗрдВ рдирд╣реАрдВ рд╣реИрдВред

рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХрд╛ рдкреНрд░реЛрдлрд╛рдЗрд▓рд┐рдВрдЧ рдФрд░ рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝реЗрд╢рди

рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХреЛ рд╕рдордЭрдирд╛ рдФрд░ рдЙрд╕рдХрд╛ рдЕрдиреБрдХреВрд▓рди рдХрд░рдирд╛ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдкреНрд░рджрд░реНрд╢рди рдмрдирд╛рдП рд░рдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдЕрддреНрдпрдВрдд рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИред┬а

Python рдореЗрдореЛрд░реА рдкреНрд░реЛрдлрд╛рдЗрд▓рд┐рдВрдЧ рдХреЗ рдХрдИ рдЯреВрд▓ рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИ, рдЬреЛ рдорд╛рдирдХ рдбреАрдмрдЧрд┐рдВрдЧ рд╕реЗ рдЖрдЧреЗ рдХреА рдЕрдВрддрд░реНрджреГрд╖реНрдЯрд┐ рджреЗрддреЗ рд╣реИрдВ рдФрд░ рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЛ рдореЗрдореЛрд░реА рдЕрдХреНрд╖рдорддрд╛рдУрдВ рдХреА рдкрд╣рдЪрд╛рди рд╡ рд╕рдорд╛рдзрд╛рди рдореЗрдВ рдорджрдж рдХрд░рддреЗ рд╣реИрдВ:

  • pympler: рдПрдХ рд╡реНрдпрд╛рдкрдХ рдЯреВрд▓ рдЬреЛ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХреЛ рдЯреНрд░реИрдХ рдХрд░рддрд╛ рд╣реИ рдФрд░ рдСрдмреНрдЬреЗрдХреНрдЯ рд╕реНрдкреЗрд╕ рдХрд╛ рд╡рд┐рд╢реНрд▓реЗрд╖рдг рдХрд░рддрд╛ рд╣реИ, рд╡рд┐рд╕реНрддреГрдд рдореЗрдореЛрд░реА рдЬрд╛рдБрдЪ рдХреЗ рд▓рд┐рдП рдЙрдкрдпреБрдХреНрддред
  • memory_profiler: рд▓рд╛рдЗрди-рджрд░-рд▓рд╛рдЗрди рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХрд╛ рд╡рд┐рд╢реНрд▓реЗрд╖рдг рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдбреЗрд╡рд▓рдкрд░реНрд╕ рдЙрди рд╕рдЯреАрдХ рд▓рд╛рдЗрдиреЛрдВ рдХреА рдкрд╣рдЪрд╛рди рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдЬрд╣рд╛рдБ рдореЗрдореЛрд░реА рдЦрдкрдд рдЕрдзрд┐рдХ рд╣реИред
  • tracemalloc: Python рд╕реНрдЯреИрдВрдбрд░реНрдб рд▓рд╛рдЗрдмреНрд░реЗрд░реА рдореЗрдВ рдПрдХреАрдХреГрдд, tracemalloc рдореЗрдореЛрд░реА рдЕрд▓реЛрдХреЗрд╢рди рдХреЛ рдЯреНрд░реИрдХ рдХрд░рдиреЗ рдФрд░ рд▓реАрдХреНрд╕ рдХрд╛ рдкрддрд╛ рд▓рдЧрд╛рдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддрд╛ рд╣реИ, рддрдерд╛ рдЕрд▓реЛрдХреЗрд╢рди рдЯреНрд░реЗрдВрдбреНрд╕ рдкрд░ рдЕрдВрддрд░реНрджреГрд╖реНрдЯрд┐ рджреЗрддрд╛ рд╣реИред

рд╣рдо рдЗрд╕ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рдореЗрдВ pympler рд▓рд╛рдЗрдмреНрд░реЗрд░реА рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВрдЧреЗ, рдФрд░ рдЖрдк рдЗрд╕реЗ рдЯрд░реНрдорд┐рдирд▓ рдкрд░ pip рдкреИрдХреЗрдЬ рдореИрдиреЗрдЬрд░ рд╕реЗ рдЗрдВрд╕реНрдЯреЙрд▓ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

pip install pympler

рдореЗрдореЛрд░реА рдкреНрд░реЛрдлрд╛рдЗрд▓рд┐рдВрдЧ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдФрд░ рдкрдврд╝реЗрдВ рд╣рдорд╛рд░реЗ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓тАКтАФтАКPython рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░реЛрдлрд╛рдЗрд▓рд┐рдВрдЧ рдХрд╛ рдкрд░рд┐рдЪрдпред┬а

Python рдореЗрдВ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдиреЗ рдХреА рддрдХрдиреАрдХреЗрдВ

рдЕрдм рдЬрдм рд╣рдордиреЗ Python рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдХреА рдмреБрдирд┐рдпрд╛рдж рд╕рдордЭ рд▓реА рд╣реИ, рддреЛ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдиреЗ рдХреА рдХреБрдЫ рдЙрдиреНрдирдд рддрдХрдиреАрдХреЛрдВ рдкрд░ рдирдЬрд╝рд░ рдбрд╛рд▓рддреЗ рд╣реИрдВред

1. __slots__ рдХреЗ рд╕рд╛рде рдХреНрд▓рд╛рд╕ рд╕рдВрд░рдЪрдирд╛ рдХрд╛ рдЕрдиреБрдХреВрд▓рди

Python рдореЗрдВ, рдкреНрд░рддреНрдпреЗрдХ рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдореЗрдВ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рд░рдЦрдиреЗ рдХреЗ рд▓рд┐рдП __dict__ рдирд╛рдордХ рдПрдХ рдбрд┐рдХреНрд╢рдирд░реА рд╣реЛрддреА рд╣реИред рдпрджреНрдпрдкрд┐ рдпрд╣ рдирдП рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдХреЗ рдбрд╛рдпрдиреЗрдорд┐рдХ рдЕрд╕рд╛рдЗрдирдореЗрдВрдЯ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддреА рд╣реИ, рдкрд░рдВрддреБ рдмрд╣реБрдд рд╕рд╛рд░реЗ рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдмрдирд╛рдиреЗ рдкрд░ рдпрд╣ рдЙрд▓реНрд▓реЗрдЦрдиреАрдп рдореЗрдореЛрд░реА рдУрд╡рд░рд╣реЗрдб рдХрд╛ рдХрд╛рд░рдг рдмрди рд╕рдХрддреА рд╣реИред __slots__ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдХрд░рдХреЗ, рдЖрдк Python рдХреЛ рдПрдХ рдирд┐рд╢реНрдЪрд┐рдд рд╕реЗрдЯ рдХреЗ рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯреНрд╕ рдХреЗ рд▓рд┐рдП рдЬрдЧрд╣ рдЖрд╡рдВрдЯрд┐рдд рдХрд░рдиреЗ рдХреЛ рдХрд╣рддреЗ рд╣реИрдВ, рдЬрд┐рд╕рд╕реЗ рдбрд╛рдпрдиреЗрдорд┐рдХ рдбрд┐рдХреНрд╢рдирд░реА рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╕рдорд╛рдкреНрдд рд╣реЛ рдЬрд╛рддреА рд╣реИред

__slots__ рдХреЗ рджреЛ рдореБрдЦреНрдп рдлрд╛рдпрджреЗ рд╣реИрдВ:

  • рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдореЗрдВ рдХрдореА: рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдбрд┐рдХреНрд╢рдирд░реА рди рд╣реЛрдиреЗ рдкрд░ рдкреНрд░рддреНрдпреЗрдХ рдСрдмреНрдЬреЗрдХреНрдЯ рдХрдо рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИред рдЬрдм рд▓рд╛рдЦреЛрдВ рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХреА рдЬрд╝рд░реВрд░рдд рд╣реЛ, рддреЛ рдкреНрд░рддрд┐ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╣реЛрдиреЗ рд╡рд╛рд▓реА рдпрд╣ рдмрдЪрдд рдЧреБрдгрд╛ рд╣реЛрдХрд░ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реЛ рдЬрд╛рддреА рд╣реИред
  • рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯ рдПрдХреНрд╕реЗрд╕ рдХреА рдЧрддрд┐ рдореЗрдВ рд╡реГрджреНрдзрд┐: __slots__ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯреНрд╕ рддрдХ рдкрд╣реБрдБрдЪрдирд╛ рдбрд┐рдХреНрд╢рдирд░реА рдХреЗ рдореБрдХрд╛рдмрд▓реЗ рддреЗрдЬрд╝ рд╣реЛрддрд╛ рд╣реИ, рдХреНрдпреЛрдВрдХрд┐ рдпрд╣ рд╕реАрдзреЗ рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯ рд▓реБрдХрдЕрдк рдХрд░рддрд╛ рд╣реИ рдФрд░ рдбрд┐рдХреНрд╢рдирд░реА рдПрдХреНрд╕реЗрд╕ рдореЗрдВ рд╢рд╛рдорд┐рд▓ рд╣реИрд╢-рдЯреЗрдмрд▓ рдСрдкрд░реЗрд╢рди рдХреЛ рд╕реНрдХрд┐рдк рдХрд░ рджреЗрддрд╛ рд╣реИред

рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЙрджрд╛рд╣рд░рдг: рджреНрд╡рд┐-рдЖрдпрд╛рдореА рд╕реНрдкреЗрд╕ рдореЗрдВ рдмрд┐рдВрджреБ

рдПрдХ рд╕рд╛рдзрд╛рд░рдг рдХреНрд▓рд╛рд╕ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВ рдЬреЛ рджреНрд╡рд┐-рдЖрдпрд╛рдореА рд╕реНрдкреЗрд╕ рдореЗрдВ рдПрдХ рдмрд┐рдВрджреБ рдХрд╛ рдкреНрд░рддрд┐рдирд┐рдзрд┐рддреНрд╡ рдХрд░рддреА рд╣реИ:

class PointWithoutSlots:
   def __init__(self, x, y):
       self.x = x
       self.y = y

class PointWithSlots:
   __slots__ = ('x', 'y')
   def __init__(self, x, y):
       self.x = x
       self.y = y

PointWithoutSlots рдХреНрд▓рд╛рд╕ рдореЗрдВ, рдкреНрд░рддреНрдпреЗрдХ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдореЗрдВ __dict__ рд╣реЛрддрд╛ рд╣реИ рдЬрд┐рд╕рдореЗрдВ x рдФрд░ y рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯреНрд╕ рд╕реНрдЯреЛрд░ рд╣реЛрддреЗ рд╣реИрдВ, рдЬрдмрдХрд┐ PointWithSlots рдХреНрд▓рд╛рд╕ рдореЗрдВ рдРрд╕рд╛ рдирд╣реАрдВ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдкреНрд░рддрд┐ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХрдо рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рд╣реЛрддреА рд╣реИред

рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдореЗрдВ рдЕрдВрддрд░ рджрд┐рдЦрд╛рдиреЗ рдХреЗ рд▓рд┐рдП, рдЖрдЗрдП рд╣рдЬрд╝рд╛рд░ рдкреЙрдЗрдВрдЯ рдмрдирд╛рддреЗ рд╣реИрдВ рдФрд░ pympler рдкреИрдХреЗрдЬ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдХреБрд▓ рдореЗрдореЛрд░реА рдорд╛рдкрддреЗ рд╣реИрдВ:

from pympler import asizeof

points_without_slots = [PointWithoutSlots(i, i) for i in range(1000)]
points_with_slots = [PointWithSlots(i, i) for i in range(1000)]

print("Total memory (without __slots__):", asizeof.asizeof(points_without_slots))
print("Total memory (with __slots__):", asizeof.asizeof(points_with_slots))

рдЬреЛ рдЖрдЙрдЯрдкреБрдЯ рд╣рдореЗрдВ рджрд┐рдЦрд╛рдИ рджреЗрддрд╛ рд╣реИ:

Memory comparison with and without slots

рд╕реНрд▓реЙрдЯреНрд╕ рдХреЗ рд╕рд╛рде рдФрд░ рдмрд┐рдирд╛ рдореЗрдореЛрд░реА рддреБрд▓рдирд╛

рдЖрдо рддреМрд░ рдкрд░ рдЖрдЙрдЯрдкреБрдЯ рджрд┐рдЦрд╛рддрд╛ рд╣реИ рдХрд┐ PointWithSlots рдХреЗ рдЗрдВрд╕реНрдЯреЗрдВрд╕, PointWithoutSlots рдХреА рддреБрд▓рдирд╛ рдореЗрдВ рдХрдо рдореЗрдореЛрд░реА рд▓реЗрддреЗ рд╣реИрдВ, рдЬреЛ рдкреНрд░рддрд┐-рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдореЗрдореЛрд░реА рдУрд╡рд░рд╣реЗрдб рдХреЛ рдШрдЯрд╛рдиреЗ рдореЗрдВ __slots__ рдХреА рдкреНрд░рднрд╛рд╡рд╢реАрд▓рддрд╛ рджрд░реНрд╢рд╛рддрд╛ рд╣реИред

__slots__ рдЙрдкрдпреЛрдЧ рдХреА рд╕реАрдорд╛рдПрдБ

рд╣рд╛рд▓рд╛рдБрдХрд┐ __slots__ рдореЗрдореЛрд░реА рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝реЗрд╢рди рдХреЗ рд▓рд┐рдП рдЙрдкрдпреЛрдЧреА рд╣реИрдВ, рдЗрдирдХреЗ рд╕рд╛рде рдХреБрдЫ рд╕реАрдорд╛рдПрдБ рдЖрддреА рд╣реИрдВ:

  • рдЕрдирдореНрдпрддрд╛: рдПрдХ рдмрд╛рд░ __slots__ рдкрд░рд┐рднрд╛рд╖рд┐рдд рд╣реЛрдиреЗ рдХреЗ рдмрд╛рдж, рдЖрдк рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдореЗрдВ рдирдП рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯреНрд╕ рдбрд╛рдпрдиреЗрдорд┐рдХ рд░реВрдк рд╕реЗ рдирд╣реАрдВ рдЬреЛрдбрд╝ рд╕рдХрддреЗред
  • рдЗрдирд╣реЗрд░рд┐рдЯреЗрдВрд╕ рдХреА рдЬрдЯрд┐рд▓рддрд╛рдПрдБ: рдпрджрд┐ рдХрд┐рд╕реА рдХреНрд▓рд╛рд╕ рдореЗрдВ __slots__ рд╣реИрдВ рдФрд░ рд╡рд╣ рдЗрдирд╣реЗрд░рд┐рдЯ рд╣реЛрддреА рд╣реИ, рддреЛ рд╕рдмрдХреНрд▓рд╛рд╕ рдХреЛ рднреА рдореЗрдореЛрд░реА рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝реЗрд╢рди рдХрд╛ рд▓рд╛рдн рдмрдирд╛рдП рд░рдЦрдиреЗ рдХреЗ рд▓рд┐рдП __slots__ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдХрд░рдиреЗ рд╣реЛрдВрдЧреЗ, рдЬреЛ рдХреНрд▓рд╛рд╕ рдбрд┐рдЬрд╝рд╛рдЗрди рдХреЛ рдЬрдЯрд┐рд▓ рдмрдирд╛ рд╕рдХрддрд╛ рд╣реИред┬а

рдЗрди рд╕реАрдорд╛рдУрдВ рдХреЗ рдмрд╛рд╡рдЬреВрдж, __slots__ рдХрд╛ рдЙрдкрдпреЛрдЧ рдЙрди рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЗ рд▓рд┐рдП рдПрдХ рд╢рдХреНрддрд┐рд╢рд╛рд▓реА рдЯреВрд▓ рд╣реИ рдЬреЛ Python рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХрд╛ рдЕрдиреБрдХреВрд▓рди рдХрд░рдирд╛ рдЪрд╛рд╣рддреЗ рд╣реИрдВтАФрд╡рд┐рд╢реЗрд╖рдХрд░ рд╕рдЦреНрдд рдореЗрдореЛрд░реА рдмрд╛рдзрд╛рдУрдВ рд╡рд╛рд▓реЗ рд╡рд╛рддрд╛рд╡рд░рдг рдореЗрдВ рдпрд╛ рдЬрд╣рд╛рдБ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХреА рд╕рдВрдЦреНрдпрд╛ рдмрд╣реБрдд рдЕрдзрд┐рдХ рд╣реЛред

2. рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди рд▓рд╛рдЧреВ рдХрд░рдирд╛

рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди рдРрд╕реЗ рдЖрд░реНрдХрд┐рдЯреЗрдХреНрдЪрд░рд▓ рд╕рдорд╛рдзрд╛рди рд╣реИрдВ рдЬреЛ Python рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдФрд░ рдкреНрд░рдмрдВрдзрди рдХреЛ рдЕрдиреБрдХреВрд▓рд┐рдд рдХрд░рдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддреЗ рд╣реИрдВред┬а

рдХреНрд▓рд╛рд╕ рдбрд┐рдЬрд╝рд╛рдЗрди рдореЗрдВ рдореЗрдореЛрд░реА рджрдХреНрд╖рддрд╛ рдХреЗ рд▓рд┐рдП рджреЛ рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ рдкреНрд░рднрд╛рд╡реА рдкреИрдЯрд░реНрди рд╣реИрдВ: рдлреНрд▓рд╛рдЗрд╡реЗрдЯ рдФрд░ рд╕рд┐рдВрдЧрд▓рдЯрдиред рдЬрдм рдЗрдиреНрд╣реЗрдВ рдЙрди рдкрд░рд┐рджреГрд╢реНрдпреЛрдВ рдореЗрдВ рд╕рд╣реА рдврдВрдЧ рд╕реЗ рд▓рд╛рдЧреВ рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ рдЬрд┐рдирдореЗрдВ рдмрдбрд╝реА рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдпрд╛ рд╕рд╛рдЭрд╛ рдбреЗрдЯрд╛ рд╢рд╛рдорд┐рд▓ рд╣реЛрддреЗ рд╣реИрдВ, рддреЛ рдпреЗ рдкреИрдЯрд░реНрди рдореЗрдореЛрд░реА рдЦрдкрдд рдХреЛ рдХрд╛рдлреА рд╣рдж рддрдХ рдШрдЯрд╛ рд╕рдХрддреЗ рд╣реИрдВред

рдлреНрд▓рд╛рдЗрд╡реЗрдЯ рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди

рдлреНрд▓рд╛рдЗрд╡реЗрдЯ рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди рдореЗрдВ рдкреНрд░рддреНрдпреЗрдХ рдСрдмреНрдЬреЗрдХреНрдЯ рдореЗрдВ рд╕рднреА рдбреЗрдЯрд╛ рд░рдЦрдиреЗ рдХреЗ рдмрдЬрд╛рдп рдХрдИ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЗ рдмреАрдЪ рд╕реНрдЯреЗрдЯ рдХреЗ рд╕рд╛рдорд╛рдиреНрдп рд╣рд┐рд╕реНрд╕реЛрдВ рдХреЛ рд╕рд╛рдЭрд╛ рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдХреБрд▓ рдореЗрдореЛрд░реА рдлрд╝реБрдЯрдкреНрд░рд┐рдВрдЯ рдореЗрдВ рдЙрд▓реНрд▓реЗрдЦрдиреАрдп рдХрдореА рдЖрддреА рд╣реИред

рдПрдХ рдбреНрд░реЙрдЗрдВрдЧ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдЧреНрд░рд╛рдлрд┐рдХрд▓ рд╕рд░реНрдХрд┐рд▓ рджрд░реНрд╢рд╛рдиреЗ рд╡рд╛рд▓реА рдХреНрд▓рд╛рд╕ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВ, рдЬрд╣рд╛рдБ рдкреНрд░рддреНрдпреЗрдХ рд╕рд░реНрдХрд┐рд▓ рдХрд╛ рд░рдВрдЧ, рддреНрд░рд┐рдЬреНрдпрд╛ рдФрд░ рдХреЙрд░реНрдбрд┐рдиреЗрдЯреНрд╕ рд╣реЛрддреЗ рд╣реИрдВред рдлреНрд▓рд╛рдЗрд╡реЗрдЯ рдкреИрдЯрд░реНрди рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реБрдП, рд░рдВрдЧ рдФрд░ рддреНрд░рд┐рдЬреНрдпрд╛, рдЬреЛ рдХрдИ рд╕рд░реНрдХрд┐рд▓ рдореЗрдВ рд╕рд╛рдорд╛рдиреНрдп рд╣реЛ рд╕рдХрддреЗ рд╣реИрдВ, рд╕рд╛рдЭрд╛ рдСрдмреНрдЬреЗрдХреНрдЯ рдореЗрдВ рд╕рдВрдЧреНрд░рд╣реАрдд рдХрд┐рдП рдЬрд╛ рд╕рдХрддреЗ рд╣реИрдВ:

class Circle:
   # Flyweight object
   def __init__(self, color):
       self.color = color
   def draw(self, radius, x, y):
       print(f"Drawing a {self.color} circle with radius {radius} at ({x},{y})")

class CircleFactory:
   # Factory to manage Flyweight objects
   _circles = {}
   @classmethod
   def get_circle(cls, color):
       if not cls._circles.get(color):
           cls._circles[color] = Circle(color)
       return cls._circles[color]

рдЗрд╕ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рдХрдИ рд╕рд░реНрдХрд┐рд▓ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд░рдВрдЧ рдХреЗ рдЖрдзрд╛рд░ рдкрд░ CircleFactory рдХреЗ Circle рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рд╕рд╛рдЭрд╛ рдХрд░рддреЗ рд╣реИрдВ, рдЬрд┐рд╕рд╕реЗ рд░рдВрдЧ рдбреЗрдЯрд╛ рдПрдХ рдмрд╛рд░ рд╣реА рд╕рдВрдЧреНрд░рд╣реАрдд рд╣реЛрдХрд░ рдореЗрдореЛрд░реА рдХрд╛ рдЕрдзрд┐рдХ рдХреБрд╢рд▓ рдЙрдкрдпреЛрдЧ рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рд╣реЛрддрд╛ рд╣реИред

рдЖрдЗрдП рдЗрд╕ рдХреНрд▓рд╛рд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдмрдирд╛рддреЗ рд╣реИрдВ рдФрд░ рд╕рдордЭрддреЗ рд╣реИрдВ рдХрд┐ рдореЗрдореЛрд░реА рдХреИрд╕реЗ рдмрдЪрддреА рд╣реИред

import sys

factory = CircleFactory()
circle1 = factory.get_circle("Red")
circle2 = factory.get_circle("Red")
circle3 = factory.get_circle("Blue")

print("Memory address of circle1:", id(circle1))
print("Memory address of circle2:", id(circle2))
print("Memory address of circle3:", id(circle3))
print ("-----------------------------")
print("Memory used by circle1:", sys.getsizeof(circle1))
print("Memory used by circle2:", sys.getsizeof(circle2))
print("Memory used by circle3:", sys.getsizeof(circle3))

рдЬреЛ рдЖрдЙрдЯрдкреБрдЯ рд╣рдореЗрдВ рджрд┐рдЦрд╛рдИ рджреЗрддрд╛ рд╣реИ:

Memory usage for flyweight design pattern

рдлреНрд▓рд╛рдЗрд╡реЗрдЯ рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди рдХреЗ рд▓рд┐рдП рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ

рд╣рдо рджреЗрдЦрддреЗ рд╣реИрдВ рдХрд┐ circle1 рдФрд░ circle2 рдХрд╛ рдореЗрдореЛрд░реА рдкрддрд╛ рд╕рдорд╛рди рд╣реИ, рдпрд╛рдиреА рд╡реЗ рд╡рд╛рд╕реНрддрд╡ рдореЗрдВ рд╡рд╣реА рдПрдХ рдСрдмреНрдЬреЗрдХреНрдЯ рд╣реИрдВ (рд░рдВрдЧ тАЬRedтАЭ рдХреЗ рд▓рд┐рдП рдПрдХ рд╣реА рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╕рд╛рдЭрд╛ рдХрд░рддреЗ рд╣реБрдП)ред circle3 рдХрд╛ рдореЗрдореЛрд░реА рдкрддрд╛ рдЕрд▓рдЧ рд╣реИ рдХреНрдпреЛрдВрдХрд┐ рдпрд╣ рдЕрд▓рдЧ рд░рдВрдЧ (тАЬBlueтАЭ) рд╡рд╛рд▓реЗ рд╕рд░реНрдХрд┐рд▓ рдХрд╛ рдкреНрд░рддрд┐рдирд┐рдзрд┐рддреНрд╡ рдХрд░рддрд╛ рд╣реИред

circle1 рдФрд░ circle2 рдХрд╛ рдПрдХ рд╣реА рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╣реЛрдирд╛ рджрд░реНрд╢рд╛рддрд╛ рд╣реИ рдХрд┐ CircleFactory рдиреЗ рдЗрди рджреЛрдиреЛрдВ рдХреЗ рдмреАрдЪ Circle рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХреЛ рд╕рдлрд▓рддрд╛рдкреВрд░реНрд╡рдХ рд╕рд╛рдЭрд╛ рдХрд┐рдпрд╛ред рдпрд╣реА рд╡рд╣ рдЬрдЧрд╣ рд╣реИ рдЬрд╣рд╛рдБ рдореЗрдореЛрд░реА рджрдХреНрд╖рддрд╛ рдЖрддреА рд╣реИ: рдпрджрд┐ рдЖрдкрдХреЗ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдлреНрд▓рд╛рдЗрд╡реЗрдЯ рдкреИрдЯрд░реНрди рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реБрдП рд╣рдЬрд╝рд╛рд░ рд▓рд╛рд▓ рд╕рд░реНрдХрд┐рд▓ рд╣реЛрдВ, рддреЛ рд╡реЗ рд╕рднреА рд░рдВрдЧ рдХреЗ рд▓рд┐рдП рдПрдХ рд╣реА Circle рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╕рд╛рдЭрд╛ рдХрд░реЗрдВрдЧреЗ, рдмрдЬрд╛рдп рдЗрд╕рдХреЗ рдХрд┐ рдкреНрд░рддреНрдпреЗрдХ рдХреЗ рдкрд╛рд╕ рдЕрдкрдирд╛ рдЕрд▓рдЧ Circle рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╣реЛтАФрдЗрд╕ рдкреНрд░рдХрд╛рд░ рдореЗрдореЛрд░реА рдореЗрдВ рдЙрд▓реНрд▓реЗрдЦрдиреАрдп рдмрдЪрдд рд╣реЛрдЧреАред

рд╕рд┐рдВрдЧрд▓рдЯрди рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди

рд╕рд┐рдВрдЧрд▓рдЯрди рдкреИрдЯрд░реНрди рдпрд╣ рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдХрд┐рд╕реА рдХреНрд▓рд╛рд╕ рдХрд╛ рдХреЗрд╡рд▓ рдПрдХ рд╣реА рдЗрдВрд╕реНрдЯреЗрдВрд╕ рд╣реЛ рдФрд░ рдЙрд╕реА рддрдХ рд╡реИрд╢реНрд╡рд┐рдХ рдкрд╣реБрдБрдЪ рдЙрдкрд▓рдмреНрдз рд╣реЛред рдпрд╣ рдкреИрдЯрд░реНрди рдХреЙрдиреНрдлрд╝рд┐рдЧрд░реЗрд╢рди рдпрд╛ рдПрдкреНрд▓рд┐рдХреЗрд╢рди-рд╡реНрдпрд╛рдкреА рд╕рд╛рдЭрд╛ рд╕рдВрд╕рд╛рдзрдиреЛрдВ рдХреЛ рдореИрдиреЗрдЬ рдХрд░рдиреЗ рдореЗрдВ рдЙрдкрдпреЛрдЧреА рд╣реИ, рдХреНрдпреЛрдВрдХрд┐ рдпрд╣ рд╕рд╛рдЭрд╛ рд╕рдВрд╕рд╛рдзрди рдпрд╛ рдХреЙрдиреНрдлрд╝рд┐рдЧрд░реЗрд╢рди рдбреЗрдЯрд╛ рдХреА рдХрдИ рдЬрдЧрд╣реЛрдВ рдкрд░ рдирдХрд▓ рд╕реЗ рдмрдЪрдХрд░ рдореЗрдореЛрд░реА рдУрд╡рд░рд╣реЗрдб рдШрдЯрд╛рддрд╛ рд╣реИред

рдЗрд╕ Database рдХреНрд▓рд╛рд╕ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВ:

class Database:
   _instance = None
   def __new__(cls):
       if cls._instance is None:
           cls._instance = super(Database, cls).__new__(cls)
           # Initialize any attributes of the instance here
       return cls._instance
   def connect(self):
       # method to simulate database connection
       return "Connection established"

рдЗрд╕ рдЗрдореНрдкреНрд▓реАрдореЗрдВрдЯреЗрд╢рди рдореЗрдВ, Database рдпрд╣ рд╕реБрдирд┐рд╢реНрдЪрд┐рдд рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдЪрд╛рд╣реЗ рдЗрд╕реЗ рдХрд┐рддрдиреА рднреА рдмрд╛рд░ рдЗрдВрд╕реНрдЯреИрдВрд╢рд┐рдПрдЯ рдХрд┐рдпрд╛ рдЬрд╛рдП, рдХреЗрд╡рд▓ рдПрдХ рд╣реА рд╕рд╛рдЭрд╛ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рд╣реЛтАФрдЗрд╕ рдкреНрд░рдХрд╛рд░ рдПрдХ рдЬреИрд╕реЗ рдХрдИ рдСрдмреНрдЬреЗрдХреНрдЯ рдмрдирдиреЗ рд╕реЗ рдмрдЪрдХрд░ рдореЗрдореЛрд░реА рдХреА рдмрдЪрдд рд╣реЛрддреА рд╣реИред

рдЗрд╕реЗ рд╣рдо рдирд┐рдореНрди рдХреЛрдб рд╕реЗ рдЬрд╛рдБрдЪ рд╕рдХрддреЗ рд╣реИрдВ:

db1 = Database()
print(db1.connect())
db2 = Database()
print(db1 is db2) 

рдЖрдЙрдЯрдкреБрдЯ рдЗрд╕ рдкреНрд░рдХрд╛рд░ рд╣реИ:

Instance creation for singleton design pattern

рд╕рд┐рдВрдЧрд▓рдЯрди рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди рдХреЗ рд▓рд┐рдП рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдирд┐рд░реНрдорд╛рдг

тАЬTrueтАЭ рдХрд╛ рдЖрдЙрдЯрдкреБрдЯ рджрд░реНрд╢рд╛рддрд╛ рд╣реИ рдХрд┐ db1 рдФрд░ db2 рд╡реЗрд░рд┐рдПрдмрд▓ рдПрдХ рд╣реА рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХреЛ рд╕рдВрджрд░реНрднрд┐рдд рдХрд░рддреЗ рд╣реИрдВред

рдпреЗ рдкреИрдЯрд░реНрди рджрд┐рдЦрд╛рддреЗ рд╣реИрдВ рдХрд┐ рд╕реЛрдЪ-рд╕рдордЭрдХрд░ рдХрд┐рдпрд╛ рдЧрдпрд╛ рдбрд┐рдЬрд╝рд╛рдЗрди рдореЗрдореЛрд░реА рджрдХреНрд╖рддрд╛ рдХреЛ рдХрд┐рддрдирд╛ рдмрдврд╝рд╛ рд╕рдХрддрд╛ рд╣реИред рдЙрдкрдпреБрдХреНрдд рдбрд┐рдЬрд╝рд╛рдЗрди рдкреИрдЯрд░реНрди рдЪреБрдирдХрд░ рдФрд░ рдЙрдиреНрд╣реЗрдВ рд▓рд╛рдЧреВ рдХрд░рдХреЗ, рдбреЗрд╡рд▓рдкрд░реНрд╕ рдЕрдкрдиреЗ Python рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдХреЛ рдЕрдзрд┐рдХ рд╣рд▓реНрдХрд╛ рдФрд░ рдкреНрд░рджрд░реНрд╢рдирдХрд╛рд░реА рдмрдирд╛ рд╕рдХрддреЗ рд╣реИрдВред

3. рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рдореЗрдВ рдмрд┐рд▓реНрдЯ-рдЗрди рдбреЗрдЯрд╛ рдЯрд╛рдЗрдкреНрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ

рдЙрдкрдпреБрдХреНрдд Python рдХреЗ рдмрд┐рд▓реНрдЯ-рдЗрди рдбреЗрдЯрд╛ рдЯрд╛рдЗрдк рдЪреБрдирдирд╛ рдореЗрдореЛрд░реА рджрдХреНрд╖рддрд╛ рдкрд░ рдХрд╛рдлрд╝реА рдЕрд╕рд░ рдбрд╛рд▓ рд╕рдХрддрд╛ рд╣реИред рдмрд┐рд▓реНрдЯ-рдЗрди рдЯрд╛рдЗрдкреНрд╕ рдХреЛ Python рдЗрдВрдЯрд░рдкреНрд░реЗрдЯрд░ рдХреЗ рдЖрдВрддрд░рд┐рдХ рдЗрдореНрдкреНрд▓реАрдореЗрдВрдЯреЗрд╢рди рдХреЗ рдХрд╛рд░рдг рдкреНрд░рджрд░реНрд╢рди рдФрд░ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХреЗ рд▓рд┐рдП рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝ рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред┬а

рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдЕрдкрдиреА рдЦрд╛рд╕ рд╡рд┐рд╢реЗрд╖рддрд╛рдУрдВ рдХреЗ рдХрд╛рд░рдг рдХреБрдЫ рдЙрдкрдпреЛрдЧ-рдкреНрд░рд╕рдВрдЧреЛрдВ рдореЗрдВ рдЯреНрдпреВрдкрд▓ рдФрд░ рд╕реЗрдЯ, рд▓рд┐рд╕реНрдЯ рдФрд░ рдбрд┐рдХреНрд╢рдирд░реА рдХреА рддреБрд▓рдирд╛ рдореЗрдВ рдЕрдзрд┐рдХ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рд╡рд┐рдХрд▓реНрдк рд╣реЛ рд╕рдХрддреЗ рд╣реИрдВред

рдЯреНрдпреВрдкрд▓ рд╕рд╛рдорд╛рдиреНрдпрддрдГ рд▓рд┐рд╕реНрдЯ рд╕реЗ рдХрдо рдореЗрдореЛрд░реА рд▓реЗрддреЗ рд╣реИрдВ рдХреНрдпреЛрдВрдХрд┐ рдЙрдирдХрд╛ рдЖрдХрд╛рд░ рддрдп рд╣реЛрддрд╛ рд╣реИ рдФрд░ рдмрдирдиреЗ рдХреЗ рдмрд╛рдж рдЙрдиреНрд╣реЗрдВ рдмрджрд▓рд╛ рдирд╣реАрдВ рдЬрд╛ рд╕рдХрддрд╛ред рдЗрд╕рд╕реЗ Python рдХреЗ рдЖрдВрддрд░рд┐рдХ рддрдВрддреНрд░ рдЙрдирдХреЗ рд╕реНрдЯреЛрд░реЗрдЬ рдХреЛ рдмреЗрд╣рддрд░ рдврдВрдЧ рд╕реЗ рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝ рдХрд░ рдкрд╛рддреЗ рд╣реИрдВред рдРрд╕реА рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рдХреЗ рд▓рд┐рдП рдЬреЛ рдирд┐рд░реНрдорд╛рдг рдХреЗ рдмрд╛рдж рдбреЗрдЯрд╛ рдореЗрдВ рдмрджрд▓рд╛рд╡ рдирд╣реАрдВ рдХрд░рддреАрдВ, рдЯреНрдпреВрдкрд▓ рдЙрддреНрддрдо рд╡рд┐рдХрд▓реНрдк рд╣реИрдВред

рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЙрджрд╛рд╣рд░рдг: рдкреЙрд▓рд┐рдЧреЙрди рдХреНрд▓рд╛рд╕реЗрдЬрд╝

рджреЛ рд╕рд╛рдзрд╛рд░рдг рдкреЙрд▓рд┐рдЧреЙрди рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВ рдЬреЛ рдХреНрд░рдорд╢рдГ рдЯреНрдпреВрдкрд▓ рдФрд░ рд▓рд┐рд╕реНрдЯ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рдорд╛рди рд╕рдВрдЧреНрд░рд╣реАрдд рдХрд░рддреА рд╣реИрдВ:

class PolygonWithTuple:
   def __init__(self, points):
       self.points = tuple(points)  # Storing points as a tuple
   def display_points(self):
       return self.points

class PolygonWithList:
   def __init__(self, points):
       self.points = list(points)  # Storing points as a list
   def display_points(self):
       return self.points

рд╣рдо рджреЛрдиреЛрдВ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рдХреЗ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдмрдирд╛рдХрд░ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХреА рддреБрд▓рдирд╛ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

from pympler import asizeof

points = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Creating instances of each class
polygon_tuple = PolygonWithTuple(points)
polygon_list = PolygonWithList(points)

# Memory usage comparison using pympler
print("Total memory used by Polygon with Tuple:", asizeof.asizeof(polygon_tuple))
print("Total memory used by Polygon with List:", asizeof.asizeof(polygon_list))

рд╣рдореЗрдВ рдЬреЛ рдЖрдЙрдЯрдкреБрдЯ рдорд┐рд▓рддрд╛ рд╣реИ:

Memory comparison for tuples and lists

рдЯреНрдпреВрдкрд▓ рдФрд░ рд▓рд┐рд╕реНрдЯ рдХреЗ рд▓рд┐рдП рдореЗрдореЛрд░реА рддреБрд▓рдирд╛

рдпрд╣ рдЖрдЙрдЯрдкреБрдЯ рджрд┐рдЦрд╛рддрд╛ рд╣реИ рдХрд┐ рдЯреНрдпреВрдкрд▓ рдЖрдорддреМрд░ рдкрд░ рд▓рд┐рд╕реНрдЯ рд╕реЗ рдХрдо рдореЗрдореЛрд░реА рд▓реЗрддреЗ рд╣реИрдВ, рдЬрд┐рд╕рд╕реЗ рд╕реНрдерд┐рд░, рдЕрдкрд░рд┐рд╡рд░реНрддрдиреАрдп рдбреЗрдЯрд╛ рдЬреИрд╕реЗ рдЬреНрдпрд╛рдорд┐рддреАрдп рдХреЙрд░реНрдбрд┐рдиреЗрдЯреНрд╕ рдХреЛ рд╕рдВрдЧреНрд░рд╣реАрдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП PolygonWithTuple рдХреНрд▓рд╛рд╕ рдЕрдзрд┐рдХ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рд╕рд┐рджреНрдз рд╣реЛрддреА рд╣реИред

4. рд▓реЗрдЬрд╝реА рдЗрд╡реИрд▓реНрдпреВрдПрд╢рди рдХреЗ рд▓рд┐рдП рдЬреЗрдирд░реЗрдЯрд░ рдХрд╛ рд▓рд╛рдн рдЙрдард╛рдирд╛

Python рдореЗрдВ рдЬреЗрдирд░реЗрдЯрд░ рдмрдбрд╝реЗ рдбреЗрдЯрд╛рд╕реЗрдЯ рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░рддреЗ рд╕рдордп рдореЗрдореЛрд░реА рдХреЛ рдкреНрд░рднрд╛рд╡реА рдврдВрдЧ рд╕реЗ рдореИрдиреЗрдЬ рдХрд░рдиреЗ рдХрд╛ рдПрдХ рд╢рдХреНрддрд┐рд╢рд╛рд▓реА рдЯреВрд▓ рд╣реИрдВред

рдЬреЗрдирд░реЗрдЯрд░ рдбреЗрдЯрд╛ рдХреЛ рдПрдХ рд╕рдордп рдореЗрдВ рдПрдХ рдЖрдЗрдЯрдо рдХреЗ рд░реВрдк рдореЗрдВ рдкреНрд░реЛрд╕реЗрд╕ рдХрд░рдиреЗ рджреЗрддреЗ рд╣реИрдВ, рдЬрд┐рд╕рд╕реЗ рдХрд┐рд╕реА рднреА рдХреНрд╖рдг рдХреЗрд╡рд▓ рдЖрд╡рд╢реНрдпрдХ рдбреЗрдЯрд╛ рд╣реА рдореЗрдореЛрд░реА рдореЗрдВ рд▓реЛрдб рд╣реЛрддрд╛ рд╣реИред рд▓реЗрдЬрд╝реА рдЗрд╡реИрд▓реНрдпреВрдПрд╢рди рдХреА рдпрд╣ рд╡рд┐рдзрд┐ рдЙрди рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рд▓рд╛рднрджрд╛рдпрдХ рд╣реИ рдЬрд╣рд╛рдБ рдмрдбрд╝реЗ рдкреИрдорд╛рдиреЗ рдкрд░ рдбреЗрдЯрд╛ рд╕рдВрднрд╛рд▓рд╛ рдЬрд╛рддрд╛ рд╣реИ, рдкрд░рдВрддреБ рдПрдХ рд╕рдордп рдореЗрдВ рдХреЗрд╡рд▓ рдереЛрдбрд╝рд╛-рд╕рд╛ рдбреЗрдЯрд╛ рд╣реА рдкреНрд░реЛрд╕реЗрд╕ рдХрд░рдирд╛ рд╣реЛрддрд╛ рд╣реИтАФрдЗрд╕ рдкреНрд░рдХрд╛рд░ рдХреБрд▓ рдореЗрдореЛрд░реА рдлрд╝реБрдЯрдкреНрд░рд┐рдВрдЯ рдШрдЯрддрд╛ рд╣реИред

рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЙрджрд╛рд╣рд░рдг: рдмрдбрд╝реЗ рдбреЗрдЯрд╛рд╕реЗрдЯ рдкреНрд░реЛрд╕реЗрд╕ рдХрд░рдирд╛

рдРрд╕реА рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВ рдЬрд┐рд╕реЗ рдЙрдкрдпреЛрдЧрдХрд░реНрддрд╛ рд░рд┐рдХреЙрд░реНрдбреНрд╕ рдХреЗ рдмрдбрд╝реЗ рдбреЗрдЯрд╛рд╕реЗрдЯ рдХреЛ рдкреНрд░реЛрд╕реЗрд╕ рдХрд░рдирд╛ рд╣реИ, рдЬреИрд╕реЗ рдЙрдкрдпреЛрдЧрдХрд░реНрддрд╛рдУрдВ рдХреА рдФрд╕рдд рдЖрдпреБ рдирд┐рдХрд╛рд▓рдирд╛ред рд╕рднреА рд░рд┐рдХреЙрд░реНрдбреНрд╕ рдХреЛ рд▓рд┐рд╕реНрдЯ рдореЗрдВ рд▓реЛрдб рдХрд░рдиреЗ (рдЬреЛ рдХрд╛рдлреА рдореЗрдореЛрд░реА рд▓реЗ рд╕рдХрддрд╛ рд╣реИ) рдХреЗ рдмрдЬрд╛рдп, рдЬреЗрдирд░реЗрдЯрд░ рдПрдХ рд╕рдордп рдореЗрдВ рдПрдХ рд░рд┐рдХреЙрд░реНрдб рдкреНрд░реЛрд╕реЗрд╕ рдХрд░ рд╕рдХрддрд╛ рд╣реИред

def process_records(file_name):
   """Generator that yields user ages from a file one at a time."""
   with open(file_name, 'r') as file:
       for line in file:
           user_data = line.strip().split(',')
           yield int(user_data[1]) 

def average_age(file_name):
   """Calculate the average age from user records."""
   total_age = 0
   count = 0
   for age in process_records(file_name):
       total_age += age
       count += 1
   return total_age / count if count else 0

print("Average Age:", average_age('user_data.csv'))

рдЗрд╕ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, process_records() рдЬреЗрдирд░реЗрдЯрд░ рдлрд╝рдВрдХреНрд╢рди рдлрд╝рд╛рдЗрд▓ рдХреЛ рдПрдХ-рдПрдХ рд▓рд╛рдЗрди рдХрд░рдХреЗ рдкрдврд╝рддрд╛ рд╣реИ, рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХ рдбреЗрдЯрд╛ рдХреЛ рдкреВрд░реНрдгрд╛рдВрдХ рдореЗрдВ рдмрджрд▓рддрд╛ рд╣реИ рдФрд░ рдЙрд╕реЗ рдпреАрд▓реНрдб рдХрд░рддрд╛ рд╣реИред рдЗрд╕рдХрд╛ рдЕрд░реНрде рд╣реИ рдХрд┐ рдХрд┐рд╕реА рднреА рд╕рдордп рдореЗрдореЛрд░реА рдореЗрдВ рдХреЗрд╡рд▓ рдПрдХ рд▓рд╛рдЗрди рдХрд╛ рдбреЗрдЯрд╛ рд░рд╣рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдиреНрдпреВрдирддрдо рд╣реЛрддрд╛ рд╣реИред average_age() рдлрд╝рдВрдХреНрд╢рди рдЬреЗрдирд░реЗрдЯрд░ рдХреЛ рдХрдВрдЬрд╝реНрдпреВрдо рдХрд░рддрд╛ рд╣реИ рдФрд░ рдмрд┐рдирд╛ рдкреВрд░реЗ рдбреЗрдЯрд╛рд╕реЗрдЯ рдХреЛ рдПрдХ рд╕рд╛рде рдореЗрдореЛрд░реА рдореЗрдВ рд░рдЦреЗ, рдХреБрд▓ рдЖрдпреБ рдФрд░ рдХрд╛рдЙрдВрдЯ рдЬреЛрдбрд╝рддрд╛ рдЬрд╛рддрд╛ рд╣реИред

рдЗрд╕ рддрд░рд╣, рд▓реЗрдЬрд╝реА рдЗрд╡реИрд▓реНрдпреВрдПрд╢рди рджреГрд╖реНрдЯрд┐рдХреЛрдг рдЕрдкрдирд╛рдХрд░ рд╣рдо рдореЗрдореЛрд░реА рдмрдЪрд╛ рд╕рдХрддреЗ рд╣реИрдВ рдФрд░ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдХреА рдкреНрд░рддрд┐рд╕рд╛рдж-рдХреНрд╖рдорддрд╛ рд╡ рд╕реНрдХреЗрд▓реЗрдмрд┐рд▓рд┐рдЯреА рдмрдврд╝рд╛ рд╕рдХрддреЗ рд╣реИрдВред

5. рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╕реЗ рдмрдЪрдирд╛

рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рддрдм рд╣реЛрддреЗ рд╣реИрдВ рдЬрдм рджреЛ рдпрд╛ рдЕрдзрд┐рдХ рдСрдмреНрдЬреЗрдХреНрдЯ рдПрдХ-рджреВрд╕рд░реЗ рдХреЛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд░рддреЗ рд╣реИрдВред рдпрд╣ рд╕реВрдЪрд┐рдпреЛрдВ, рдбрд┐рдХреНрд╢рдирд░реА рдпрд╛ рдФрд░ рдЕрдзрд┐рдХ рдЬрдЯрд┐рд▓ рдХреНрд▓рд╛рд╕ рдкрд░рд┐рднрд╛рд╖рд╛рдУрдВ рдЬреИрд╕реЗ рдврд╛рдБрдЪреЛрдВ рдореЗрдВ рд╕реВрдХреНрд╖реНрдо рд░реВрдк рд╕реЗ рд╣реЛ рд╕рдХрддрд╛ рд╣реИ, рдЬрд╣рд╛рдБ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдПрдХ-рджреВрд╕рд░реЗ рдХреЗ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд░рдЦрддреЗ рд╣реИрдВ рдФрд░ рдПрдХ рд▓реВрдк рдмрди рдЬрд╛рддрд╛ рд╣реИред

рдЬреИрд╕рд╛ рдХрд┐ рд╣рдордиреЗ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдХреА рдмреБрдирд┐рдпрд╛рджреА рдмрд╛рддреЛрдВ рдореЗрдВ рджреЗрдЦрд╛, Python рдореЗрдВ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛ рдкрддрд╛ рд▓рдЧрд╛рдиреЗ рдФрд░ рдЙрдиреНрд╣реЗрдВ рд╕рд╛рдлрд╝ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдЕрддрд┐рд░рд┐рдХреНрдд рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рд╣реИред рдлрд┐рд░ рднреА, рдЗрд╕ рддрдВрддреНрд░ рдкрд░ рдирд┐рд░реНрднрд░ рд░рд╣рдирд╛ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдФрд░ рджрдХреНрд╖рддрд╛ рдкрд░ рдкреНрд░рддрд┐рдХреВрд▓ рдкреНрд░рднрд╛рд╡ рдбрд╛рд▓ рд╕рдХрддрд╛ рд╣реИ:

  • рд╕рдлрд╛рдИ рдореЗрдВ рджреЗрд░реА: рд╕рд╛рдЗрдХреНрд▓рд┐рдХ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рдирд┐рд░рдВрддрд░ рдирд╣реАрдВ, рдмрд▓реНрдХрд┐ рд╕рдордп-рд╕рдордп рдкрд░ рдЪрд▓рддрд╛ рд╣реИред рдЗрд╕рдХрд╛ рдорддрд▓рдм рд╣реИ рдХрд┐ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдореЗрдВ рд╢рд╛рдорд┐рд▓ рдСрдмреНрдЬреЗрдХреНрдЯреНрд╕, рдЙрдирдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рди рд░рд╣рдиреЗ рдкрд░ рднреА, рддреБрд░рдВрдд рд░рд┐рдХреНрд▓реЗрдо рдирд╣реАрдВ рдХрд┐рдП рдЬрд╛ рд╕рдХрддреЗ рдФрд░ рдЕрдирд╛рд╡рд╢реНрдпрдХ рдореЗрдореЛрд░реА рдШреЗрд░рддреЗ рд░рд╣рддреЗ рд╣реИрдВред
  • рдкреНрд░рджрд░реНрд╢рди рдУрд╡рд░рд╣реЗрдб: рд╕рд╛рдЗрдХреНрд▓рд┐рдХ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рдХреЛ рд╕рдордп-рд╕рдордп рдкрд░ рдЬрд╛рдБрдЪ рдФрд░ рд╕рдлрд╛рдИ рдХреЗ рд▓рд┐рдП рдЕрддрд┐рд░рд┐рдХреНрдд рд╕рдВрд╕рд╛рдзрдиреЛрдВ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИ, рдЬреЛ рдкреНрд░рджрд░реНрд╢рди рдХреЛ рдкреНрд░рднрд╛рд╡рд┐рдд рдХрд░ рд╕рдХрддрд╛ рд╣реИред

рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЙрджрд╛рд╣рд░рдг: рдПрдХ рдЯреНрд░реА рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░

рдПрдХ рд╕рд╛рдорд╛рдиреНрдп рдЙрдкрдпреЛрдЧ-рдорд╛рдорд▓реЗ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВтАФрдЯреНрд░реА рдЬреИрд╕реЗ рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдореЗрдВтАФрдЬрд╣рд╛рдБ рдкреНрд░рддреНрдпреЗрдХ рдиреЛрдб рдЕрдкрдиреЗ рдмрдЪреНрдЪреЛрдВ рдХрд╛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд░рдЦ рд╕рдХрддрд╛ рд╣реИ рдФрд░ рд╡реИрдХрд▓реНрдкрд┐рдХ рд░реВрдк рд╕реЗ рдЕрдкрдиреЗ рдкреИрд░реЗрдВрдЯ рдХрд╛ рднреАред рдпрд╣ рдкреИрд░реЗрдВрдЯ-рдЪрд╛рдЗрд▓реНрдб рд▓рд┐рдВрдХрд┐рдВрдЧ рдЖрд╕рд╛рдиреА рд╕реЗ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдмрдирд╛ рд╕рдХрддреА рд╣реИред

class TreeNode:
   def __init__(self, value, parent=None):
       self.value = value
       self.parent = parent
       self.children = []
   def add_child(self, child):
       child.parent = self  # Set parent reference
       self.children.append(child)

root = TreeNode("root")
child = TreeNode("child1", root)
root.add_child(child)

рдЗрд╕ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, root рдЕрдкрдиреЗ children рд▓рд┐рд╕реНрдЯ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ child рдХреЛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд░рддрд╛ рд╣реИ, рдФрд░ child рдЕрдкрдиреЗ parent рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ root рдХреЛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд░рддрд╛ рд╣реИред рдпрд╣ рд╕реЗрдЯрдЕрдк рдмрд┐рдирд╛ рдХрд┐рд╕реА рдФрд░ рд╣рд╕реНрддрдХреНрд╖реЗрдк рдХреЗ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдмрдирд╛ рд╕рдХрддрд╛ рд╣реИред

рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╕реЗ рдмрдЪрдиреЗ рдХреЗ рд▓рд┐рдП рд╡реАрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ

рд╡реАрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕, рдкреВрд░реЗ рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдХреЛ рдлрд┐рд░ рд╕реЗ рдбрд┐рдЬрд╝рд╛рдЗрди рдХрд┐рдП рдмрд┐рдирд╛ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХреЛ рддреЛрдбрд╝рдиреЗ рдпрд╛ рд░реЛрдХрдиреЗ рдХрд╛ рдПрдХ рдкреНрд░рднрд╛рд╡реА рддрд░реАрдХрд╛ рд╣реИрдВред┬а

Python рдХрд╛ weakref рдореЙрдбреНрдпреВрд▓ рдХрд┐рд╕реА рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЗ рд▓рд┐рдП рдРрд╕рд╛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдмрдирд╛рдиреЗ рджреЗрддрд╛ рд╣реИ рдЬреЛ рдЙрд╕рдХреЗ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛рдЙрдВрдЯ рдХреЛ рдирд╣реАрдВ рдмрдврд╝рд╛рддрд╛ред рдпрд╣ рд╡реАрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд┐рдП рдЧрдП рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯ рд╣реЛрдиреЗ рд╕реЗ рдирд╣реАрдВ рд░реЛрдХрддрд╛, рдЬрд┐рд╕рд╕реЗ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╕реЗ рдЬреБрдбрд╝реЗ рдореЗрдореЛрд░реА рд▓реАрдХ рд░реЛрдХреЗ рдЬрд╛ рд╕рдХрддреЗ рд╣реИрдВред

рдкрд┐рдЫрд▓реА рдХреНрд▓рд╛рд╕ рдХреЛ рд╡реАрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдЗрд╕реНрддреЗрдорд╛рд▓ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рд╣рдо рдЗрд╕ рдкреНрд░рдХрд╛рд░ рд╕рдВрд╢реЛрдзрд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

import weakref

class TreeNode:
   def __init__(self, value, parent=None):
       self.value = value
       self.parent = weakref.ref(parent) if parent else None
       self.children = []
   def add_child(self, child):
       child.parent = weakref.ref(self)
       self.children.append(child)
root = TreeNode("root")
child = TreeNode("child1", root)
root.add_child(child)

рдЗрд╕ рдХреНрд▓рд╛рд╕ рдореЗрдВ, parent рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯ рдЕрдм рдкреИрд░реЗрдВрдЯ рдиреЛрдб рдХрд╛ рд╡реАрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╣реИред рдЗрд╕рдХрд╛ рдорддрд▓рдм рд╣реИ рдХрд┐ рдпрджрд┐ рдкреИрд░реЗрдВрдЯ рдХреЗ рд▓рд┐рдП рдЕрдиреНрдп рдХреЛрдИ рд╕реНрдЯреНрд░реЙрдиреНрдЧ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдирд╣реАрдВ рд╣реИ, рддреЛ рдЪрд╛рдЗрд▓реНрдб рдиреЛрдб рдореМрдЬреВрдж рд░рд╣рддреЗ рд╣реБрдП рднреА рдкреИрд░реЗрдВрдЯ рдиреЛрдб рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯ рд╣реЛ рд╕рдХрддрд╛ рд╣реИред┬а

рдпрд╣ рддрд░реАрдХрд╛ рдРрд╕реЗ рдврд╛рдБрдЪреЛрдВ рдореЗрдВ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╕реЗ рд╕рд╛рдорд╛рдиреНрдпрддрдГ рдЬреБрдбрд╝реЗ рдореЗрдореЛрд░реА рд▓реАрдХ рдореБрджреНрджреЛрдВ рдХреЛ рдХреБрд╢рд▓рддрд╛ рд╕реЗ рд░реЛрдХрддрд╛ рд╣реИред

рдирд┐рд╖реНрдХрд░реНрд╖

рдЗрд╕ рд▓реЗрдЦ рдореЗрдВ Python рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдХреА рдмреБрдирд┐рдпрд╛рджреА рдмрд╛рддреЗрдВ рдмрддрд╛рдИ рдЧрдИрдВ рдФрд░ рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЙрджрд╛рд╣рд░рдгреЛрдВ рд╡ рдореЗрдореЛрд░реА рддреБрд▓рдирд╛ рдХреЗ рд╕рд╛рде рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдиреЗ рдХреА рдкрд╛рдБрдЪ рдЙрдиреНрдирдд рддрдХрдиреАрдХреЗрдВ рдкреНрд░рд╕реНрддреБрдд рдХреА рдЧрдИрдВред рд╣рдореЗрдВ рдЙрдореНрдореАрдж рд╣реИ рдХрд┐ рдЖрдк рдЗрди рддрдХрдиреАрдХреЛрдВ рдФрд░ рд╕рд░реНрд╡реЛрддреНрддрдо рдкреНрд░рдерд╛рдУрдВ рдХреЛ рдЕрдкрдиреЗ рдкреНрд░реЛрдЬреЗрдХреНрдЯреНрд╕ рдореЗрдВ рдЕрдкрдирд╛рдХрд░ рд╕реНрдХреЗрд▓реЗрдмрд▓ рдФрд░ рдХреБрд╢рд▓ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдмрдирд╛рдПрдБрдЧреЗред┬а

рд╣рдо рдЖрдкрдХреЛ рд╣рдорд╛рд░рд╛ Python рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдЯреНрд░реИрдХ рджреЗрдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдкреНрд░реЛрддреНрд╕рд╛рд╣рд┐рдд рдХрд░рддреЗ рд╣реИрдВ, рдЬрд┐рд╕рдореЗрдВ рд╕реЙрдлрд╝реНрдЯрд╡реЗрдпрд░ рдЗрдВрдЬреАрдирд┐рдпрд░рд┐рдВрдЧ рд╕рд┐рджреНрдзрд╛рдВрдд рдФрд░ рдСрдмреНрдЬреЗрдХреНрдЯ-рдУрд░рд┐рдПрдВрдЯреЗрдб рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рд╢рд╛рдорд┐рд▓ рд╣реИрдВ, рддрдерд╛ рдХреБрд╢рд▓ Python рдХреЛрдб рд▓рд┐рдЦрдирд╛ рднреА рдХрд╡рд░ рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред

Arunn Thevapalan

рд▓реЗрдЦрдХ

Arunn Thevapalan

рдПрдХ рд╡рд░рд┐рд╖реНрда рдбреЗрдЯрд╛ рд╡реИрдЬреНрдЮрд╛рдирд┐рдХ рдХреЗ рд░реВрдк рдореЗрдВ, рдореИрдВ рдмрдбрд╝реЗ рдкреИрдорд╛рдиреЗ рдкрд░ рдорд╢реАрдитАСрд▓рд░реНрдирд┐рдВрдЧ рд╕рдорд╛рдзрд╛рди рдбрд┐рдЬрд╝рд╛рдЗрди, рд╡рд┐рдХрд╕рд┐рдд рдФрд░ рдкрд░рд┐рдирд┐рдпреЛрдЬрд┐рдд рдХрд░рддрд╛/рдХрд░рддреА рд╣реВрдБ рддрд╛рдХрд┐ рд╡реНрдпрд╡рд╕рд╛рдп рдмреЗрд╣рддрд░ рдбреЗрдЯрд╛тАСрдЖрдзрд╛рд░рд┐рдд рдирд┐рд░реНрдгрдп рд▓реЗ рд╕рдХреЗрдВред рдбреЗрдЯрд╛ рд╕рд╛рдЗрдВрд╕ рд▓реЗрдЦрдХ рдХреЗ рд░реВрдк рдореЗрдВ, рдореИрдВ рдЕрдкрдиреЗ рд╕реАрдЦ, рдХрд░рд┐рдпрд░ рд╕рд▓рд╛рд╣, рдФрд░ рдЧрд╣рди рд╡реНрдпрд╛рд╡рд╣рд╛рд░рд┐рдХ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рд╕рд╛рдЭрд╛ рдХрд░рддрд╛/рдХрд░рддреА рд╣реВрдБред

FAQs

__slots__ рдХреНрдпрд╛ рд╣реИрдВ, рдФрд░ рд╡реЗ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ Python рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдиреЗ рдореЗрдВ рдХреИрд╕реЗ рдорджрдж рдХрд░рддреЗ рд╣реИрдВ?

__slots__ Python рдореЗрдВ рдПрдХ рддрдВрддреНрд░ рд╣реИ рдЬреЛ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдПрдЯреНрд░рд┐рдмреНрдпреВрдЯреНрд╕ рдХреА рд╕реНрдкрд╖реНрдЯ рдШреЛрд╖рдгрд╛ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИ рдФрд░ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдбрд┐рдХреНрд╢рдирд░реА рдХреЗ рдирд┐рд░реНрдорд╛рдг рдХреЛ рд░реЛрдХрддрд╛ рд╣реИред рдХрд┐рд╕реА рдХреНрд▓рд╛рд╕ рдореЗрдВ __slots__ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдХрд░рдиреЗ рдкрд░, Python рд╕рд╛рдорд╛рдиреНрдп рдкреНрд░рддрд┐-рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдбрд┐рдХреНрд╢рдирд░реА рдХреА рддреБрд▓рдирд╛ рдореЗрдВ рдХрд╣реАрдВ рдЕрдзрд┐рдХ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рдбреЗрдЯрд╛ рд╕рдВрд░рдЪрдирд╛ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИред рдЗрд╕рд╕реЗ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдШрдЯрддрд╛ рд╣реИ, рдЦрд╛рд╕рдХрд░ рдЙрди рдкреНрд░реЛрдЧреНрд░рд╛рдореЛрдВ рдореЗрдВ рдЬрд╣рд╛рдБ рдмрд╣реБрдд рд╕реЗ рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдмрдирд╛рдП рдЬрд╛рддреЗ рд╣реИрдВред

рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХреЛ рдХреИрд╕реЗ рдкреНрд░рднрд╛рд╡рд┐рдд рдХрд░рддреЗ рд╣реИрдВ, рдФрд░ рдЙрдирд╕реЗ рдХреИрд╕реЗ рдмрдЪрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ?

рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рддрдм рд╣реЛрддреЗ рд╣реИрдВ рдЬрдм рджреЛ рдпрд╛ рдЕрдзрд┐рдХ рдСрдмреНрдЬреЗрдХреНрдЯ рдПрдХ-рджреВрд╕рд░реЗ рдХреЛ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд░рддреЗ рд╣реИрдВ рдФрд░ рдПрдХ рд▓реВрдк рдмрдирддрд╛ рд╣реИ, рдЬреЛ Python рдХреЗ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рдХреЛ рдЙрдирдХреА рдореЗрдореЛрд░реА рд╡рд╛рдкрд╕ рд▓реЗрдиреЗ рд╕реЗ рд░реЛрдХ рд╕рдХрддрд╛ рд╣реИред рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╕реЗ рдмрдЪрдиреЗ рдХреЗ рд▓рд┐рдП рдЖрдк weakref рдореЙрдбреНрдпреВрд▓ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рд╡реАрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВ, рдЕрдкрдиреЗ рдбрд┐рдЬрд╝рд╛рдЗрди рдХреЛ рд░рд┐рдлрд╝реИрдХреНрдЯрд░ рдХрд░ рдЕрдирд╛рд╡рд╢реНрдпрдХ рд░реЗрдлрд╝рд░реЗрдВрд╕ рд╣рдЯрд╛рдПрдБ, рдпрд╛ рдЖрд╡рд╢реНрдпрдХрддрд╛ рди рд░рд╣рдиреЗ рдкрд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХреЛ None рдкрд░ рд╕реЗрдЯ рдХрд░рдХреЗ рдЪрдХреНрд░ рдХреЛ рдореИрдиреНрдпреБрдЕрд▓ рд░реВрдк рд╕реЗ рддреЛрдбрд╝реЗрдВред

Python рдореЗрдВ рдореЗрдореЛрд░реА рдкреНрд░рдмрдВрдзрди рдореЗрдВ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рдХреА рдХреНрдпрд╛ рднреВрдорд┐рдХрд╛ рд╣реИ?

Python рдореЗрдВ рдЧрд╛рд░рдмреЗрдЬ рдХрд▓реЗрдХреНрдЯрд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛рдЙрдВрдЯрд┐рдВрдЧ рд╕рд┐рд╕реНрдЯрдо рдХрд╛ рдкреВрд░рдХ рд╣реИ, рдЬреЛ рд╕рд░реНрдХреБрд▓рд░ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛ рдкрддрд╛ рд▓рдЧрд╛рдХрд░ рдЙрдиреНрд╣реЗрдВ рдбрд┐рд╕реНрдкреЛрдЬрд╝ рдХрд░рддрд╛ рд╣реИред рдпрд╣ рд╕рдордп-рд╕рдордп рдкрд░ рдРрд╕реЗ рдСрдмреНрдЬреЗрдХреНрдЯ рд╕рдореВрд╣реЛрдВ рдХреЛ рд╕реНрдХреИрди рдХрд░рддрд╛ рд╣реИ рдЬреЛ рдХреЗрд╡рд▓ рдПрдХ-рджреВрд╕рд░реЗ рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рд╣реА рд╕реБрд▓рдн рд╣реИрдВ рдФрд░ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдХрд╣реАрдВ рдФрд░ рдЙрдкрдпреЛрдЧ рдирд╣реАрдВ рд╣реЛ рд░рд╣реЗ, рддрд╛рдХрд┐ рдЙрд╕ рдореЗрдореЛрд░реА рдХреЛ рдореБрдХреНрдд рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХреЗ рдЬрд┐рд╕реЗ рдХреЗрд╡рд▓ рд░реЗрдлрд╝рд░реЗрдВрд╕ рдХрд╛рдЙрдВрдЯрд┐рдВрдЧ рд╕реЗ рд░рд┐рдХреНрд▓реЗрдо рдирд╣реАрдВ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ред

рдореЗрдореЛрд░реА рджрдХреНрд╖рддрд╛ рдХреЗ рд▓рд┐рдП рдмрд┐рд▓реНрдЯ-рдЗрди рдбреЗрдЯрд╛ рдЯрд╛рдЗрдк рдФрд░ рд╕рдВрд░рдЪрдирд╛рдУрдВ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХреНрдпреЛрдВ рдЖрд╡рд╢реНрдпрдХ рд╣реИ?

Python рдХреЗ рдмрд┐рд▓реНрдЯ-рдЗрди рдбреЗрдЯрд╛ рдЯрд╛рдЗрдк рдФрд░ рд╕рдВрд░рдЪрдирд╛рдПрдБ рдкреНрд░рджрд░реНрд╢рди рдФрд░ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХреЗ рд▓рд┐рдП рдЕрддреНрдпрдзрд┐рдХ рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝реНрдб рд╣реИрдВред рдЗрди рдмрд┐рд▓реНрдЯ-рдЗрдиреНрд╕, рдЬреИрд╕реЗ рдЕрдкрд░рд┐рд╡рд░реНрддрдиреАрдп рдбреЗрдЯрд╛ рдХреЗ рд▓рд┐рдП рд▓рд┐рд╕реНрдЯ рдХреА рдмрдЬрд╛рдп рдЯреНрдпреВрдкрд▓ рдпрд╛ рдпреВрдирд┐рдХ рдХрд▓реЗрдХреНрд╢рди рдХреЗ рд▓рд┐рдП рд╕реЗрдЯ рдХрд╛ рдЙрдкрдпреЛрдЧ, рдХрд╕реНрдЯрдо рдпрд╛ рдХрдо рдЙрдкрдпреБрдХреНрдд рдбреЗрдЯрд╛ рд╕рдВрд░рдЪрдирд╛рдУрдВ рдХреА рддреБрд▓рдирд╛ рдореЗрдВ рдореЗрдореЛрд░реА рдУрд╡рд░рд╣реЗрдб рдХреЛ рдЙрд▓реНрд▓реЗрдЦрдиреАрдп рд░реВрдк рд╕реЗ рдШрдЯрд╛ рд╕рдХрддрд╛ рд╣реИред

рдореЗрдореЛрд░реА рдкреНрд░реЛрдлрд╛рдЗрд▓рд┐рдВрдЧ рдЯреВрд▓ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ Python рдХреНрд▓рд╛рд╕реЗрдЬрд╝ рд▓рд┐рдЦрдиреЗ рдореЗрдВ рдХреИрд╕реЗ рдорджрдж рдХрд░рддреЗ рд╣реИрдВ?

memory_profiler, pympler, рдФрд░ tracemalloc рдЬреИрд╕реЗ рдореЗрдореЛрд░реА рдкреНрд░реЛрдлрд╛рдЗрд▓рд┐рдВрдЧ рдЯреВрд▓ рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЛ рдпрд╣ рд╕рдордЭрдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддреЗ рд╣реИрдВ рдХрд┐ рдЙрдирдХреА рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдореЗрдВ рдореЗрдореЛрд░реА рдХреИрд╕реЗ рдЙрдкрдпреЛрдЧ рд╣реЛ рд░рд╣реА рд╣реИред рдпреЗ рдЯреВрд▓ рдореЗрдореЛрд░реА рд▓реАрдХреНрд╕, рдЕрдХреНрд╖рдо рдбреЗрдЯрд╛ рд╕рдВрд░рдЪрдирд╛рдПрдБ, рдпрд╛ рдЕрддреНрдпрдзрд┐рдХ рдореЗрдореЛрд░реА рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рд╡рд╛рд▓реА рдХреЛрдб рдХреА рд╡рд┐рд╢рд┐рд╖реНрдЯ рдкрдВрдХреНрддрд┐рдпреЛрдВ рдХреА рдкрд╣рдЪрд╛рди рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ, рдЬрд┐рд╕рд╕реЗ рдбреЗрд╡рд▓рдкрд░реНрд╕ рдпрд╣ рдирд┐рд░реНрдгрдп рд▓реЗ рд╕рдХреЗрдВ рдХрд┐ рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝реЗрд╢рди рдХрд╣рд╛рдБ рдЖрд╡рд╢реНрдпрдХ рд╣реИред

рд╡рд┐рд╖рдп