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

рдЙрджрд╛рд╣рд░рдгреЛрдВ рдХреЗ рд╕рд╛рде рдмреЗрд╣рддрд░ рдХреЛрдб рдХреЗ рд▓рд┐рдП 30 рд╢рд╛рдирджрд╛рд░ Python рдЯреНрд░рд┐рдХреНрд╕

рд╣рдордиреЗ 30 рд╢рд╛рдирджрд╛рд░ Python рдЯреНрд░рд┐рдХреНрд╕ рдЪреБрдиреА рд╣реИрдВ рдЬрд┐рдиреНрд╣реЗрдВ рдЖрдк рдЕрдкрдиреЗ рдХреЛрдб рдореЗрдВ рд╕реБрдзрд╛рд░ рдФрд░ рдЕрдкрдиреА Python рдХреМрд╢рд▓ рд╡рд┐рдХрд╕рд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред
┬╖ 15 рдорд┐ре░ рдкрдврд╝реЗрдВ

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

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

рдпрджрд┐ рдЖрдкрдХреА Python рдХреМрд╢рд▓ рдЕрднреА рдорд╛рдирдХ рдкрд░ рдирд╣реАрдВ рд╣реИрдВ, рддреЛ рдЖрдк рд╣рдорд╛рд░реЗ Python Programming рд╕реНрдХрд┐рд▓ рдЯреНрд░реИрдХ рд╕реЗ рдЙрдиреНрд╣реЗрдВ рдирд┐рдЦрд╛рд░ рд╕рдХрддреЗ рд╣реИрдВред

рд╕реАрдХреНрд╡реЗрдВрд╕ рдФрд░ рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдЯреНрд░рд┐рдХреНрд╕

#1 Slicing

Slicing Python рдореЗрдВ рдПрдХ рдлрд╝реАрдЪрд░ рд╣реИ рдЬреЛ рдЗрдВрдбреЗрдХреНрд╕рд┐рдВрдЧ рдкрд░ рдирд┐рд░реНрднрд░ рдХрд░рддрд╛ рд╣реИ рдФрд░ рдЙрдкрдпреЛрдЧрдХрд░реНрддрд╛рдУрдВ рдХреЛ рдХрд┐рд╕реА рд╕реАрдХреНрд╡реЗрдВрд╕ рдХрд╛ рдПрдХ рдЙрдкрд╕рдореБрдЪреНрдЪрдп рдПрдХреНрд╕реЗрд╕ рдХрд░рдиреЗ рджреЗрддрд╛ рд╣реИред рдЗрдВрдбреЗрдХреНрд╕ рдХрд┐рд╕реА рд╕реАрдХреНрд╡реЗрдВрд╕ рдореЗрдВ рддрддреНрд╡ рдХреА рд╕реНрдерд┐рддрд┐ рд╣реЛрддрд╛ рд╣реИред рдЕрдЧрд░ рд╕реАрдХреНрд╡реЗрдВрд╕ рдЯрд╛рдЗрдк mutable рд╣реИ, рддреЛ рдЖрдк slicing рдХрд╛ рдЙрдкрдпреЛрдЧ рдбреЗрдЯрд╛ рдирд┐рдХрд╛рд▓рдиреЗ рдФрд░ рд╕рдВрд╢реЛрдзрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред┬а

рдиреЛрдЯ: рд╣рдо immutable рд╕реАрдХреНрд╡реЗрдВрд╕ рдкрд░ рднреА slicing рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ, рд▓реЗрдХрд┐рди slice рдХреЛ рд╕рдВрд╢реЛрдзрд┐рдд рдХрд░рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХрд░рдиреЗ рдкрд░ TypeError рдЙрдареЗрдЧрд╛ред┬а

Slices рдХрд╛ рдлрд╝реЙрд░реНрдореЗрдЯ рд╣реИ: sequence[start:stop:step]ред рдпрджрд┐ start, stop рдФрд░ step рдкреИрд░рд╛рдореАрдЯрд░ рдореЗрдВ рдорд╛рди рдирд┐рд░реНрдзрд╛рд░рд┐рдд рдирд╣реАрдВ рдХрд┐рдП рдЧрдП рд╣реИрдВ, рддреЛ рдбрд┐рдлрд╝реЙрд▓реНрдЯреНрд╕ рд▓рд╛рдЧреВ рд╣реЛрдВрдЧреЗред рдбрд┐рдлрд╝реЙрд▓реНрдЯреНрд╕ рд╣реИрдВ:┬а

  • "start" рдХрд╛ рдбрд┐рдлрд╝реЙрд▓реНрдЯ 0┬ард╣реИ
  • "stop" рдХрд╛ рдбрд┐рдлрд╝реЙрд▓реНрдЯ рд╕реАрдХреНрд╡реЗрдВрд╕ рдХреА рд▓рдВрдмрд╛рдИ рд╣реИ
  • "step" рдХрд╛ рдбрд┐рдлрд╝реЙрд▓реНрдЯ 1 рд╣реИ, рдпрджрд┐ рдирд┐рд░реНрджрд┐рд╖реНрдЯ рди рд╣реЛред┬а

рдЬрдм рдЖрдк sequence[start:stop] рджреЗрддреЗ рд╣реИрдВ, рддреЛ рд▓реМрдЯреЗ рд╣реБрдП рддрддреНрд╡ starting рдЗрдВрдбреЗрдХреНрд╕ рд╕реЗ рд▓реЗрдХрд░ stopтАК-тАК1 рддрдХ рд╣реЛрдВрдЧреЗ (stop рдЗрдВрдбреЗрдХреНрд╕ рд╢рд╛рдорд┐рд▓ рдирд╣реАрдВ рд╣реЛрддрд╛)ред┬а

рд╣рдо negative indices рднреА рдкрд╛рд╕ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ, рдЬрд┐рдиреНрд╣реЗрдВ рд╕реАрдХреНрд╡реЗрдВрд╕ рдХреЛ рд░рд┐рд╡рд░реНрд╕ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЗрд╕реНрддреЗрдорд╛рд▓ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, 4 рддрддреНрд╡реЛрдВ рдХреА рд╕реВрдЪреА рдореЗрдВ, 0рд╡рд╛рдВ рдЗрдВрдбреЗрдХреНрд╕ -4 рдЗрдВрдбреЗрдХреНрд╕ рднреА рд╣реИ, рдФрд░ рдЖрдЦрд┐рд░реА рдЗрдВрдбреЗрдХреНрд╕ -1 рднреА рд╣реИред рдКрдкрд░ рджрд┐рдП рдЧрдП рдХреЛрдб рдореЗрдВ, рдЗрд╕ рдмрд╛рдд рдХрд╛ рдЙрдкрдпреЛрдЧ рд╕реАрдХреНрд╡реЗрдВрд╕ рдХреЗ step рдкреИрд░рд╛рдореАрдЯрд░ рдореЗрдВ рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред рдирддреАрдЬрддрди, рд╕реНрдЯреНрд░рд┐рдВрдЧ рдХреЛ рдЙрд▓реНрдЯрд╛ рдкреНрд░рд┐рдВрдЯ рдХрд┐рдпрд╛ рдЧрдпрд╛, рд╕реАрдХреНрд╡реЗрдВрд╕ рдХреЗ рдЕрдВрдд рд╕реЗ рд▓реЗрдХрд░ рдЗрдВрдбреЗрдХреНрд╕ 0 рддрдХред┬а┬а┬а

#2 рдЗрди-рдкреНрд▓реЗрд╕ рд╕реНрд╡реИрдк / рдПрдХрд╕рд╛рде рдЕрд╕рд╛рдЗрдирдореЗрдВрдЯ

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

рдпрджрд┐ рдЖрдкрдХреА рдкрд╣рд▓реА рдзрд╛рд░рдгрд╛ рдпрд╣ рдереА рдХрд┐ b рдХрд╛ рдорд╛рди 7 рд╣реЛрдЧрд╛ рди рдХрд┐ 12, рддреЛ рдЖрдк рдЗрди-рдкреНрд▓реЗрд╕ swapping рдХреЗ рдЬрд╛рд▓ рдореЗрдВ рдлрдБрд╕ рдЧрдПред┬а

Python рдореЗрдВ, рд╣рдо рдСрдЯреЛрдореИрдЯрд┐рдХ рдЕрдирдкреИрдХрд┐рдВрдЧ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдПрдХ рд╣реА рдЕрд╕рд╛рдЗрдирдореЗрдВрдЯ рдореЗрдВ рдХрд┐рд╕реА iterable рдХреЛ рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдореЗрдВ рдЕрдирдкреИрдХ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП:┬а

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

рд╣рдо рдХрдИ рдорд╛рдиреЛрдВ рдХреЛ * рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдПрдХ рд╣реА рд╡реЗрд░рд┐рдПрдмрд▓ рдореЗрдВ рдЗрдХрдЯреНрдард╛ рднреА рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ тАУ рдЗрд╕ Python рдЯреНрд░рд┐рдХ рдХреЛ packing рдХрд╣рддреЗ рд╣реИрдВред рдиреАрдЪреЗ packing рдХрд╛ рдПрдХ рдЙрджрд╛рд╣рд░рдг рд╣реИред┬а┬а

рдСрдЯреЛрдореИрдЯрд┐рдХ packing рдФрд░ unpacking рдХреЛ рдорд┐рд▓рд╛рдХрд░ рдПрдХ рддрдХрдиреАрдХ рдмрдирддреА рд╣реИ рдЬрд┐рд╕реЗ simultaneous assignment рдХрд╣рддреЗ рд╣реИрдВред рд╣рдо рдПрдХрд╕рд╛рде рдЕрд╕рд╛рдЗрдирдореЗрдВрдЯ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрдИ рдорд╛рдиреЛрдВ рдХреЛ рдХрдИ рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдореЗрдВ рдЕрд╕рд╛рдЗрди рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

#3 рд▓рд┐рд╕реНрдЯ рдмрдирд╛рдо рдЯреНрдпреВрдкрд▓┬а

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

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

рд╕рдмрд╕реЗ рдкрд╣рд▓реЗ, рд▓рд┐рд╕реНрдЯ mutable рд╣реЛрддреА рд╣реИрдВ, рдпрд╛рдиреА рд╣рдо рдЙрдиреНрд╣реЗрдВ рдЕрдкрдиреА рдЗрдЪреНрдЫрд╛ рд╕реЗ рдмрджрд▓ рд╕рдХрддреЗ рд╣реИрдВ:┬а

рджреВрд╕рд░реА рдУрд░, рдЯреНрдпреВрдкрд▓ immutable рд╣реЛрддреА рд╣реИрдВ, рдпрд╛рдиреА рдЙрдиреНрд╣реЗрдВ рдмрджрд▓рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХрд░рдиреЗ рдкрд░ TypeError рдЙрдареЗрдЧрд╛ред┬а

рдЗрд╕реА рд╡рдЬрд╣ рд╕реЗ, рдЯреНрдпреВрдкрд▓ рдЕрдзрд┐рдХ рдореЗрдореЛрд░реА-рдХреБрд╢рд▓ рд╣реЛрддреА рд╣реИрдВ рдХреНрдпреЛрдВрдХрд┐ Python рдбреЗрдЯрд╛ рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рд╕рд╣реА рдореЗрдореЛрд░реА рдмреНрд▓реЙрдХ рдЕрд▓реЙрдЯ рдХрд░ рд╕рдХрддрд╛ рд╣реИред рдЗрд╕рдХреЗ рд╡рд┐рдкрд░реАрдд, рд▓рд┐рд╕реНрдЯ рдореЗрдВ рдЕрддрд┐рд░рд┐рдХреНрдд рдореЗрдореЛрд░реА рдЕрд▓реЙрдЯ рдХрд░рдиреА рдкрдбрд╝рддреА рд╣реИ рддрд╛рдХрд┐ рднрд╡рд┐рд╖реНрдп рдореЗрдВ рдЙрд╕реЗ рдмрдврд╝рд╛рдпрд╛ рдЬрд╛ рд╕рдХреЗ тАУ рдЗрд╕реЗ dynamic memory allocation рдХрд╣рддреЗ рд╣реИрдВред┬а

рд╕рдВрдХреНрд╖реЗрдк рдореЗрдВ; рдЬрд┐рди рдкрд░рд┐рд╕реНрдерд┐рддрд┐рдпреЛрдВ рдореЗрдВ рдЖрдк рдирд╣реАрдВ рдЪрд╛рд╣рддреЗ рдХрд┐ рдбреЗрдЯрд╛ рдмрджрд▓реЗ, рдореЗрдореЛрд░реА рдХрд╛рд░рдгреЛрдВ рд╕реЗ рд▓рд┐рд╕реНрдЯ рдХреА рдЕрдкреЗрдХреНрд╖рд╛ рдЯреНрдпреВрдкрд▓ рдХреЛ рдкреНрд░рд╛рдердорд┐рдХрддрд╛ рджреЗрдиреА рдЪрд╛рд╣рд┐рдПред рдЯреНрдпреВрдкрд▓ рд▓рд┐рд╕реНрдЯ рд╕реЗ рддреЗрдЬ рднреА рд╣реЛрддреА рд╣реИрдВред┬а

рдЗрд╕ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рдореЗрдВ Python рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдЕрдзрд┐рдХ рдЬрд╛рдиреЗрдВред┬а

#4 Generators

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

рд▓рд┐рд╕реНрдЯ рдХреЙрдореНрдкреНрд░рд┐рд╣реЗрдВрд╢рди рдХрд┐рд╕реА рдЕрдиреНрдп iterable рд╕реЗ рд▓рд┐рд╕реНрдЯ рдмрдирд╛рдиреЗ рдХрд╛ pythonic рддрд░реАрдХрд╛ рд╣реИ тАУ рдпрд╣ for рд▓реВрдк рд╕реЗ рдХрд╣реАрдВ рддреЗрдЬрд╝ рд╣реИред рд▓реЗрдХрд┐рди рдХреНрдпрд╛ рд╣реЛрдЧрд╛ рдпрджрд┐ рдЖрдк рдЧрд▓рддреА рд╕реЗ рдмреНрд░реИрдХреЗрдЯреНрд╕ [] рд╕реЗ рдмрджрд▓рдХрд░ () рдХрд░ рджреЗрдВ? рдЖрдкрдХреЛ рдПрдХ generator рдСрдмреНрдЬреЗрдХреНрдЯ рдорд┐рд▓реЗрдЧрд╛ред

Python рдореЗрдВ, рд▓рд┐рд╕реНрдЯ рдХреЙрдореНрдкреНрд░рд┐рд╣реЗрдВрд╢рди рдЬреИрд╕реА рд▓реЙрдЬрд┐рдХ рдХреЛ рдЧреЛрд▓ рдмреНрд░реИрдХреЗрдЯреНрд╕ рдореЗрдВ рд▓рд┐рдЦрдиреЗ рд╕реЗ generator рдСрдмреНрдЬреЗрдХреНрдЯ рдмрдирддрд╛ рд╣реИред рдЬреЗрдирд░реЗрдЯрд░ рдПрдХ рд╡рд┐рд╢реЗрд╖ рддрд░рд╣ рдХреЗ iterable рд╣реЛрддреЗ рд╣реИрдВред рд▓рд┐рд╕реНрдЯ рдХреЗ рд╡рд┐рдкрд░реАрдд, рд╡реЗ рдЕрдкрдиреЗ рдЖрдЗрдЯрдо рд╕реНрдЯреЛрд░ рдирд╣реАрдВ рдХрд░рддреЗред рдЗрд╕рдХреЗ рдмрдЬрд╛рдп, рд╡реЗ рдкреНрд░рддреНрдпреЗрдХ рддрддреНрд╡ рдХреЛ рдХреНрд░рдо рдореЗрдВ рдЙрддреНрдкрдиреНрди рдХрд░рдиреЗ рдХреЗ рдирд┐рд░реНрджреЗрд╢ рдФрд░ iteration рдХреА рд╡рд░реНрддрдорд╛рди рдЕрд╡рд╕реНрдерд╛ рд╕реНрдЯреЛрд░ рдХрд░рддреЗ рд╣реИрдВред

рд╣рд░ рддрддреНрд╡ рдХреЗрд╡рд▓ рдЕрдиреБрд░реЛрдз рдкрд░ рдЙрддреНрдкрдиреНрди рд╣реЛрддрд╛ рд╣реИ, рдЬрд┐рд╕реЗ lazy evaluation рдХрд╣рддреЗ рд╣реИрдВред рдЬреЗрдирд░реЗрдЯрд░ рдХрд╛ рдореБрдЦреНрдп рд▓рд╛рдн рдпрд╣ рд╣реИ рдХрд┐ рдпрд╣ рдХрдо рдореЗрдореЛрд░реА рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИ рдХреНрдпреЛрдВрдХрд┐ рдкреВрд░реА рд╕реАрдХреНрд╡реЗрдВрд╕ рдПрдХ рд╕рд╛рде рдирд╣реАрдВ рдмрдирддреАред┬а

#5 Aliasing┬а

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python рдПрдХ рдСрдмреНрдЬреЗрдХреНрдЯ-рдУрд░рд┐рдПрдВрдЯреЗрдб рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рднрд╛рд╖рд╛ рд╣реИ тАУ рд╕рдм рдХреБрдЫ рдСрдмреНрдЬреЗрдХреНрдЯ рд╣реИред рдЗрд╕рд▓рд┐рдП, рдХрд┐рд╕реА рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рдХрд┐рд╕реА рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ (identifier) рдХреЛ рдЕрд╕рд╛рдЗрди рдХрд░рдирд╛ рдЙрд╕ рдСрдмреНрдЬреЗрдХреНрдЯ рдХрд╛ рд░реЗрдлрд░реЗрдВрд╕ рдмрдирд╛рдирд╛ рд╣реИред┬а

рдЬрдм рд╣рдо рдПрдХ рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдХреЛ рджреВрд╕рд░реЗ рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдХреЛ рдЕрд╕рд╛рдЗрди рдХрд░рддреЗ рд╣реИрдВ, рддреЛ рджреЛрдиреЛрдВ рдПрдХ рд╣реА рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рд░реЗрдлрд░ рдХрд░рддреЗ рд╣реИрдВред рдЗрд╕реЗ aliasing рдХрд╣рддреЗ рд╣реИрдВред рдПрдХ рдПрд▓рд┐рдпрд╕ рдореЗрдВ рдХрд┐рдП рдЧрдП рдкрд░рд┐рд╡рд░реНрддрди рджреВрд╕рд░реЗ рдХреЛ рдкреНрд░рднрд╛рд╡рд┐рдд рдХрд░реЗрдВрдЧреЗред рдХрднреА-рдХрднреА рдпрд╣ рд╡реНрдпрд╡рд╣рд╛рд░ рд╡рд╛рдВрдЫрд┐рдд рд╣реЛрддрд╛ рд╣реИ, рд▓реЗрдХрд┐рди рдЕрдХреНрд╕рд░ рдпрд╣ рд╣рдореЗрдВ рдЪреМрдВрдХрд╛ рджреЗрддрд╛ рд╣реИред┬а

рдЗрд╕рд╕реЗ рдмрдЪрдиреЗ рдХрд╛ рдПрдХ рддрд░реАрдХрд╛ рдпрд╣ рд╣реИ рдХрд┐ mutable рдСрдмреНрдЬреЗрдХреНрдЯреНрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╕рдордп aliasing рд╕реЗ рдмрдЪреЗрдВред рдПрдХ рдФрд░ рд╕рдорд╛рдзрд╛рди рдпрд╣ рд╣реЛ рд╕рдХрддрд╛ рд╣реИ рдХрд┐ рд░реЗрдлрд░реЗрдВрд╕ рдХреЗ рдмрдЬрд╛рдп рдореВрд▓ рдСрдмреНрдЬреЗрдХреНрдЯ рдХрд╛ рдХреНрд▓реЛрди рдмрдирд╛рдпрд╛ рдЬрд╛рдПред┬а

рдХреНрд▓реЛрди рдмрдирд╛рдиреЗ рдХрд╛ рд╕рдмрд╕реЗ рд╕рд░рд▓ рддрд░реАрдХрд╛ slicing рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ рд╣реИ:┬а

b = a[:] 

рдпрд╣ b рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдореЗрдВ рдПрдХ рдирдП рд▓рд┐рд╕реНрдЯ рдСрдмреНрдЬреЗрдХреНрдЯ рдХрд╛ рд░реЗрдлрд░реЗрдВрд╕ рдмрдирд╛рдПрдЧрд╛ред┬а

рдЖрдк рдХрдИ рдЕрдиреНрдп рд╕рдорд╛рдзрд╛рди рднреА рдЕрдкрдирд╛ рд╕рдХрддреЗ рд╣реИрдВ, рдЬреИрд╕реЗ рдЕрд╕рд╛рдЗрди рдХрд░рддреЗ рд╕рдордп list(a) рдХреЙрд▓ рдХрд░рдирд╛ рдпрд╛ copy() рдореЗрдердб рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ред┬а

#6 тАШnotтАЩ рдСрдкрд░реЗрдЯрд░

рдЕрдЧрд▓реА Python рдЯрд┐рдк рд╣реИ not рдСрдкрд░реЗрдЯрд░ рд╕реЗ рдЕрдкрдиреА рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдХреЗ рдЦрд╛рд▓реА рд╣реЛрдиреЗ рдХреА рдЬрд╛рдБрдЪ рдХрд░рдиреЗ рдХрд╛ рд╕рдмрд╕реЗ рдЖрд╕рд╛рди рддрд░реАрдХрд╛ред Python рдХрд╛ рдмрд┐рд▓реНрдЯ-рдЗрди not рдПрдХ рд▓реЙрдЬрд┐рдХрд▓ рдСрдкрд░реЗрдЯрд░ рд╣реИ рдЬреЛ рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐ рд╕рдЪ рди рд╣реЛрдиреЗ рдкрд░ True рд▓реМрдЯрд╛рддрд╛ рд╣реИ, рдЕрдиреНрдпрдерд╛ False тАУ рдпрд╣ рдмреВрд▓рд┐рдпрди рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐рдпреЛрдВ рдФрд░ рдСрдмреНрдЬреЗрдХреНрдЯреНрд╕ рдХреЗ truth value рдХреЛ рдЙрд▓рдЯ рджреЗрддрд╛ рд╣реИред┬а┬а

рдПрдХ рдФрд░ рддрд░реАрдХрд╛ рдЬрд┐рд╕рд╕реЗ рдЖрдк рдЗрд╕реЗ рджреЗрдЦ рд╕рдХрддреЗ рд╣реИрдВ, рд╡рд╣ рд╣реИ if рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдореЗрдВ:┬а

if not a:
    # do something... 

рдЬрдм a True рд╣реЛрддрд╛ рд╣реИ, рддрдм not рдСрдкрд░реЗрдЯрд░ False рд▓реМрдЯрд╛рдПрдЧрд╛, рдФрд░ рдЗрд╕рдХреЗ рдЙрд▓рдЯ рднреА рд╕рд╣реА рд╣реИред┬а

рдпрд╣ рд╢реБрд░реБрдЖрдд рдореЗрдВ рдЙрд▓рдЭрд╛ рд╕рдХрддрд╛ рд╣реИ, рддреЛ рдЗрд╕реЗ рдЖрдЬрд╝рдорд╛рдПрдБред

рд╕реНрдЯреНрд░рд┐рдВрдЧ рдФрд░ рдЖрдЙрдЯрдкреБрдЯ рдЯреНрд░рд┐рдХреНрд╕

#7 F-strings

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

рдХрднреА-рдХрднреА рд╣рдореЗрдВ рдХрд┐рд╕реА рд╕реНрдЯреНрд░рд┐рдВрдЧ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рдлрд╝реЙрд░реНрдореЗрдЯ рдХрд░рдирд╛ рдкрдбрд╝рддрд╛ рд╣реИ; Python 3.6 рдиреЗ рдЗрд╕ рдкреНрд░рдХреНрд░рд┐рдпрд╛ рдХреЛ рд╕рд░рд▓ рдмрдирд╛рдиреЗ рдХреЗ рд▓рд┐рдП f-strings рдирд╛рдордХ рдПрдХ рд╢рд╛рдирджрд╛рд░ рдлреАрдЪрд░ рдкреЗрд╢ рдХрд┐рдпрд╛ред рдирдП рддрд░реАрдХреЗ рдХреЛ рдмреЗрд╣рддрд░ рд╕рдордЭрдиреЗ рдХреЗ рд▓рд┐рдП рдпрд╣ рдЬрд╛рдирдирд╛ рдорджрджрдЧрд╛рд░ рд╣реИ рдХрд┐ рдирдП рд░рд┐рд▓реАрдЬрд╝ рд╕реЗ рдкрд╣рд▓реЗ рд╕реНрдЯреНрд░рд┐рдВрдЧреНрд╕ рдХреИрд╕реЗ рдлрд╝реЙрд░реНрдореЗрдЯ рдХреА рдЬрд╛рддреА рдереАрдВред┬а

рдкрд╣рд▓реЗ рд╕реНрдЯреНрд░рд┐рдВрдЧреНрд╕ рдЗрд╕ рддрд░рд╣ рдлрд╝реЙрд░реНрдореЗрдЯ рд╣реЛрддреА рдереАрдВ:┬а

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

рдореВрд▓рддрдГ, рдирдпрд╛ рдлрд╝реЙрд░реНрдореЗрдЯрд┐рдВрдЧ рддрд░реАрдХрд╛ рддреЗрдЬрд╝, рдЕрдзрд┐рдХ рдкрдардиреАрдп, рдЕрдзрд┐рдХ рд╕рдВрдХреНрд╖рд┐рдкреНрдд рдФрд░ рдЧрд▓рддреА рдХреА рдЧреБрдВрдЬрд╛рдЗрд╢ рдХрдо рдХрд░рдиреЗ рд╡рд╛рд▓рд╛ рд╣реИред

f-strings рдХрд╛ рдПрдХ рдФрд░ рдЙрдкрдпреЛрдЧ рдХрд┐рд╕реА рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдХрд╛ рдирд╛рдо рдЙрд╕рдХреЗ рдорд╛рди рдХреЗ рд╕рд╛рде рдкреНрд░рд┐рдВрдЯ рдХрд░рдирд╛ рд╣реИред рдпрд╣ Python 3.8 рдореЗрдВ рдкреЗрд╢ рдХрд┐рдпрд╛ рдЧрдпрд╛ рдерд╛ред

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

рдФрд░ рдЬрд╛рдирдиреЗ рдХреЗ рд▓рд┐рдП рдпрд╣ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рджреЗрдЦреЗрдВ: Python рдореЗрдВ F-string рдлрд╝реЙрд░реНрдореЗрдЯрд┐рдВрдЧред┬а

#8 print() рдлрд╝рдВрдХреНрд╢рди рдХрд╛ тАШendтАЩ рдкреИрд░рд╛рдореАрдЯрд░

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

рдЕрдХреНрд╕рд░ рд╣рдо print рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдХреЛ рдЙрд╕рдХреЗ рдХрд┐рд╕реА рд╡реИрдХрд▓реНрдкрд┐рдХ рдкреИрд░рд╛рдореАрдЯрд░ рдХреЗ рдмрд┐рдирд╛ рд╣реА рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВред рдкрд░рд┐рдгрд╛рдорд╕реНрд╡рд░реВрдк, рдХрдИ Pythonistas рдЗрд╕ рдмрд╛рдд рд╕реЗ рдЕрдирдЬрд╛рди рд░рд╣рддреЗ рд╣реИрдВ рдХрд┐ рдЖрдк рдЖрдЙрдЯрдкреБрдЯ рдХреЛ рдХреБрдЫ рд╣рдж рддрдХ рдирд┐рдпрдВрддреНрд░рд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

рдПрдХ рд╡реИрдХрд▓реНрдкрд┐рдХ рдкреИрд░рд╛рдореАрдЯрд░ рдЬрд┐рд╕реЗ рд╣рдо рдмрджрд▓ рд╕рдХрддреЗ рд╣реИрдВ рд╡рд╣ рд╣реИ endред end рдкреИрд░рд╛рдореАрдЯрд░ рдпрд╣ рдирд┐рд░реНрджрд┐рд╖реНрдЯ рдХрд░рддрд╛ рд╣реИ рдХрд┐ print рдХреЙрд▓ рдХреЗ рдЕрдВрдд рдореЗрдВ рдХреНрдпрд╛ рджрд┐рдЦрд╛рдпрд╛ рдЬрд╛рдирд╛ рдЪрд╛рд╣рд┐рдПред┬а

end рдХрд╛ рдбрд┐рдлрд╝реЙрд▓реНрдЯ "\n" рд╣реИ, рдЬреЛ Python рдХреЛ рдирдИ рдкрдВрдХреНрддрд┐ рд╢реБрд░реВ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд╣рддрд╛ рд╣реИред рдКрдкрд░ рдХреЗ рдХреЛрдб рдореЗрдВ, рд╣рдордиреЗ рдЗрд╕реЗ рд╕реНрдкреЗрд╕ рдореЗрдВ рдмрджрд▓рд╛ред рдЗрд╕рд▓рд┐рдП, рдЖрдЙрдЯрдкреБрдЯ рдореЗрдВ рд╣рдорд╛рд░реА рд▓рд┐рд╕реНрдЯ рдХреЗ рд╕рд╛рд░реЗ рддрддреНрд╡ рдПрдХ рд╣реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдкреНрд░рд┐рдВрдЯ рд╣реБрдПред

#9 рдЯреНрдпреВрдкрд▓ рдореЗрдВ рдЬреЛрдбрд╝рдирд╛

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

рд╣рдо рдкрд╣рд▓реЗ рд╣реА рдЬрд╛рдирддреЗ рд╣реИрдВ рдХрд┐ рдЯреНрдпреВрдкрд▓ immutable рд╣реИрдВ тАУ рджреЗрдЦреЗрдВ Python рдЯреНрд░рд┐рдХ #3 рд▓рд┐рд╕реНрдЯ рдмрдирд╛рдо рдЯреНрдпреВрдкрд▓ред рдЯреНрдпреВрдкрд▓ рдХреА рд╕реНрдЯреЗрдЯ рдмрджрд▓рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХрд░рдиреЗ рдкрд░ TypeError рдлреЗрдВрдХрд╛ рдЬрд╛рдПрдЧрд╛ред рд▓реЗрдХрд┐рди, рдпрджрд┐ рдЖрдк рдЯреНрдпреВрдкрд▓ рдСрдмреНрдЬреЗрдХреНрдЯ рдХреЛ рдПрдХ рдРрд╕реА рдирд╛рдореЛрдВ рдХреА рд╕реАрдХреНрд╡реЗрдВрд╕ рдорд╛рдиреЗрдВ рдЬрд┐рдирдХреА рдмрд╛рдЗрдВрдбрд┐рдВрдЧреНрд╕ рдСрдмреНрдЬреЗрдХреНрдЯреНрд╕ рд╕реЗ рд╣реИрдВ рдЬрд┐рдиреНрд╣реЗрдВ рдмрджрд▓рд╛ рдирд╣реАрдВ рдЬрд╛ рд╕рдХрддрд╛, рддреЛ рдмрд╛рдд рдЕрд▓рдЧ рджрд┐рдЦреЗрдЧреАред

рд╣рдорд╛рд░реЗ рдЯреНрдпреВрдкрд▓ рдХреЗ рдкрд╣рд▓реЗ рджреЛ рддрддреНрд╡ integers рд╣реИрдВ тАУ рд╡реЗ immutable рд╣реИрдВред рдЖрдЦрд┐рд░реА рддрддреНрд╡ рдПрдХ рд▓рд┐рд╕реНрдЯ рд╣реИ, рдЬреЛ Python рдореЗрдВ mutable рдСрдмреНрдЬреЗрдХреНрдЯ рд╣реИред

рдпрджрд┐ рд╣рдо рдЕрдкрдиреА рд▓рд┐рд╕реНрдЯ рдХреЛ рдЯреНрдпреВрдкрд▓ рдХреЗ рднреАрддрд░ рдПрдХ рдФрд░ рдирд╛рдо рднрд░ рдорд╛рдиреЗрдВ рдЬрд┐рд╕рдХреА рдмрд╛рдЗрдВрдбрд┐рдВрдЧ рдХрд┐рд╕реА рдСрдмреНрдЬреЗрдХреНрдЯ рд╕реЗ рд╣реИ рдФрд░ рд╡рд╣ рдмрд╛рдЗрдВрдбрд┐рдВрдЧ рдмрджрд▓реА рдирд╣реАрдВ рдЬрд╛ рд╕рдХрддреА, рддреЛ рд╣рдореЗрдВ рдПрд╣рд╕рд╛рд╕ рд╣реЛрдЧрд╛ рдХрд┐ рд▓рд┐рд╕реНрдЯ рдХреЛ рдЯреНрдпреВрдкрд▓ рдХреЗ рдЕрдВрджрд░ рд╕реЗ рднреА рдмрджрд▓рд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

рдХреНрдпрд╛ рд╣рдо рдЗрд╕реЗ рд╡реНрдпрд╡рд╣рд╛рд░ рдореЗрдВ рдХрд░рдиреЗ рдХреА рд╕рд▓рд╛рд╣ рджреЗрдВрдЧреЗ? рд╢рд╛рдпрдж рдирд╣реАрдВ, рд▓реЗрдХрд┐рди рдпрд╣ рдЬрд╛рдирдиреЗ рдпреЛрдЧреНрдп рдмрд╛рдд рд╣реИ!

#10 рдбрд┐рдХреНрд╢рдирд░реАрдЬрд╝ рдХреЛ рдорд░реНрдЬ рдХрд░рдирд╛

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

Python 3.9 рдФрд░ рдЙрд╕рд╕реЗ рдКрдкрд░ рдореЗрдВ, | (рдмрд┐рдЯрд╡рд╛рдЗрдЬрд╝ OR) рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдбрд┐рдХреНрд╢рдирд░реАрдЬрд╝ рдХреЛ рдорд░реНрдЬ рдХрд░рдирд╛ рд╕рдВрднрд╡ рд╣реИред рдЗрд╕ рд╡рд┐рд╢реЗрд╖ Python рдЯреНрд░рд┐рдХ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдФрд░ рдХрд╣рдиреЗ рдХреЛ рдЬрд╝реНрдпрд╛рджрд╛ рдирд╣реАрдВ рд╣реИ рд╕рд┐рд╡рд╛рдп рдЗрд╕рдХреЗ рдХрд┐ рдпрд╣ рдЕрдзрд┐рдХ рдкрдардиреАрдп рд╕рдорд╛рдзрд╛рди рд╣реИ!┬а

рдХреЛрдб рд╕реНрдЯрд╛рдЗрд▓ рдФрд░ рд╕рд┐рдВрдЯреИрдХреНрд╕ рдЯреНрд░рд┐рдХреНрд╕

#11 рдЯрд░реНрдирд░реА рдСрдкрд░реЗрдЯрд░ / рдХрдВрдбреАрд╢рдирд▓ рдПрдХреНрд╕рдкреНрд░реЗрд╢рдВрд╕┬а

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

рдКрдкрд░ рдХреЗ рдХреЛрдб рдореЗрдВ рдЖрдкрдиреЗ рдЯрд░реНрдирд░реА рдСрдкрд░реЗрдЯрд░ рджреЗрдЦрд╛ тАУ рдЗрд╕реЗ рдХрдВрдбреАрд╢рдирд▓ рдПрдХреНрд╕рдкреНрд░реЗрд╢рди рднреА рдХрд╣рд╛ рдЬрд╛рддрд╛ рд╣реИред рд╣рдо рдЯрд░реНрдирд░реА рдСрдкрд░реЗрдЯрд░реНрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рдЗрд╕ рдЖрдзрд╛рд░ рдкрд░ рдорд╛рди рдирд┐рд░реНрдзрд╛рд░рд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд░рддреЗ рд╣реИрдВ рдХрд┐ рдХреЛрдИ рд╢рд░реНрдд True рд╣реИ рдпрд╛ Falseред

рд╣рдо рдЕрдкрдирд╛ рдХреЛрдб рдЗрд╕ рддрд░рд╣ рднреА рд▓рд┐рдЦ рд╕рдХрддреЗ рдереЗ:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

рднрд▓реЗ рд╣реА рджреЛрдиреЛрдВ рдХреЛрдб рд╕рдорд╛рди рдЖрдЙрдЯрдкреБрдЯ рджреЗрдВ, рдзреНрдпрд╛рди рджреЗрдВ рдХрд┐ рдЯрд░реНрдирд░реА рдХрдВрдбреАрд╢рдирд▓ рд╣рдореЗрдВ рдХрд╣реАрдВ рдЫреЛрдЯрд╛ рдФрд░ рд╕рд╛рдлрд╝ рдХреЛрдб рд▓рд┐рдЦрдиреЗ рджреЗрддрд╛ рд╣реИред рдпрд╣реА рд╡рд╣ тАШPythonicтАЩ рддрд░реАрдХрд╛ рд╣реИ рдЬрд┐рд╕реЗ Pythonistas рдкрд╕рдВрдж рдХрд░рддреЗ рд╣реИрдВред┬а

#12 рд▓рд┐рд╕реНрдЯ рд╕реЗ рдбреБрдкреНрд▓реАрдХреЗрдЯ рд╣рдЯрд╛рдирд╛

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

рд▓рд┐рд╕реНрдЯ рд╕реЗ рдбреБрдкреНрд▓реАрдХреЗрдЯ рддрддреНрд╡ рд╣рдЯрд╛рдиреЗ рдХрд╛ рд╕рдмрд╕реЗ рд╕рд░рд▓ рддрд░реАрдХрд╛ рдпрд╣ рд╣реИ рдХрд┐ рд▓рд┐рд╕реНрдЯ рдХреЛ set рдореЗрдВ рдмрджрд▓ рджреЗрдВ (рдФрд░ рдЪрд╛рд╣реЗрдВ рддреЛ рдлрд┐рд░ рд╡рд╛рдкрд╕ рд▓рд┐рд╕реНрдЯ рдореЗрдВ)ред

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

рд▓рд┐рд╕реНрдЯ ordered, zero-based indexed рдФрд░ mutable рд╣реЛрддреА рд╣реИрдВред рд╕реЗрдЯ unordered рдФрд░ unindexed рд╣реЛрддреЗ рд╣реИрдВред рд╕реЗрдЯ рдХреЗ рддрддреНрд╡ immutable рдЯрд╛рдЗрдк рдХреЗ рд╣реЛрдиреЗ рдЪрд╛рд╣рд┐рдП, рднрд▓реЗ рд╣реА рд╕реЗрдЯ рд╕реНрд╡рдпрдВ mutable рд╣реЛ тАУ рдХрд┐рд╕реА рдЗрдВрдбреЗрдХреНрд╕ рд╕реЗ рддрддреНрд╡ рдирд┐рдХрд╛рд▓рдиреЗ рдпрд╛ рддрддреНрд╡ рдХреЛ рд╕рдВрд╢реЛрдзрд┐рдд рдХрд░рдиреЗ рдХреА рдХреЛрд╢рд┐рд╢ рдХрд░рдиреЗ рдкрд░ рддреНрд░реБрдЯрд┐ рд╣реЛрдЧреАред

рд╕реЗрдЯ рдФрд░ рд▓рд┐рд╕реНрдЯ рдХреЗ рдмреАрдЪ рдПрдХ рдФрд░ рдорд╣рддреНрд╡рдкреВрд░реНрдг рдЕрдВрддрд░ рдпрд╣ рд╣реИ рдХрд┐ рд╕реЗрдЯ рдореЗрдВ рдбреБрдкреНрд▓реАрдХреЗрдЯ рдирд╣реАрдВ рд╣реЛ рд╕рдХрддреЗред рдпрд╣реА рдмрд╛рдд рд╣рдореЗрдВ рд▓рд┐рд╕реНрдЯ рдХреЗ рдбреБрдкреНрд▓реАрдХреЗрдЯ рддрддреНрд╡ рд╣рдЯрд╛рдиреЗ рдореЗрдВ рдорджрдж рдХрд░рддреА рд╣реИред

#13 рд╕реНрд╡рддрдВрддреНрд░ рдЕрдВрдбрд░рд╕реНрдХреЛрд░┬а

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

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

рдбреЙрдХреНрдпреВрдореЗрдВрдЯреЗрд╢рди рдХреЗ рдЕрдиреБрд╕рд╛рд░, "рдЗрдВрдЯрд░реИрдХреНрдЯрд┐рд╡ рдЗрдВрдЯрд░рдкреНрд░реЗрдЯрд░ рдЖрдЦрд╝рд┐рд░реА рдореВрд▓реНрдпрд╛рдВрдХрди рдХрд╛ рдкрд░рд┐рдгрд╛рдо _ рд╡реЗрд░рд┐рдПрдмрд▓ рдореЗрдВ рдЙрдкрд▓рдмреНрдз рдХрд░рд╛рддрд╛ рд╣реИред (рдпрд╣ builtins рдореЙрдбреНрдпреВрд▓ рдореЗрдВ рд╕реНрдЯреЛрд░ рд╣реЛрддрд╛ рд╣реИ, print рдЬреИрд╕реА рдмрд┐рд▓реНрдЯ-рдЗрди рдлрд╝рдВрдХреНрд╢рдВрд╕ рдХреЗ рд╕рд╛рде)ред"

рдЪреВрдБрдХрд┐ рд╣рдордиреЗ рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рдХреЛ рдХрд┐рд╕реА рдСрдмреНрдЬреЗрдХреНрдЯ рд╕реЗ рдЕрд╕рд╛рдЗрди рдирд╣реАрдВ рдХрд┐рдпрд╛ рдерд╛, рд╣рдореЗрдВ рддреНрд░реБрдЯрд┐ рдорд┐рд▓реАред рд▓реЗрдХрд┐рди 1 + 2 рдХрд╛ рдЖрдЙрдЯрдкреБрдЯ рдирд┐рдХрд╛рд▓рдиреЗ рдкрд░ рдЗрдВрдЯрд░реИрдХреНрдЯрд┐рд╡ рдЗрдВрдЯрд░рдкреНрд░реЗрдЯрд░ рдиреЗ рдкрд░рд┐рдгрд╛рдо рдХреЛ рд╣рдорд╛рд░реЗ рд▓рд┐рдП _ рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдореЗрдВ рд╕реНрдЯреЛрд░ рдХрд░ рджрд┐рдпрд╛ред┬а

#14 рдорд╛рдиреЛрдВ рдХреЛ рдЕрдирджреЗрдЦрд╛ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЕрдВрдбрд░рд╕реНрдХреЛрд░

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Python рдЯрд┐рдк #13 рдореЗрдВ рд╣рдордиреЗ рджреЗрдЦрд╛ рдХрд┐ рдЗрдВрдЯрд░реИрдХреНрдЯрд┐рд╡ рдЗрдВрдЯрд░рдкреНрд░реЗрдЯрд░ рдЖрдЦрд╝рд┐рд░реА рдореВрд▓реНрдпрд╛рдВрдХрди рдХрд╛ рдкрд░рд┐рдгрд╛рдо рдЕрдВрдбрд░рд╕реНрдХреЛрд░ (_) рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдореЗрдВ рдЙрдкрд▓рдмреНрдз рдХрд░рд╛рддрд╛ рд╣реИ, рд▓реЗрдХрд┐рди рдЗрд╕рдХрд╛ рдЙрдкрдпреЛрдЧ рдпрд╣реАрдВ рддрдХ рд╕реАрдорд┐рдд рдирд╣реАрдВ рд╣реИред

рд╣рдо рдЗрд╕реЗ рдЙрди рдСрдмреНрдЬреЗрдХреНрдЯреНрд╕ рдХреЗ рд▓рд┐рдП рднреА рдЗрд╕реНрддреЗрдорд╛рд▓ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдЬрд┐рдирдХреА рд╣рдореЗрдВ рдкрд░рд╡рд╛рд╣ рдирд╣реАрдВ рд╣реИ рдпрд╛ рдЬрд┐рдиреНрд╣реЗрдВ рд╣рдо рдкреНрд░реЛрдЧреНрд░рд╛рдо рдореЗрдВ рдЖрдЧреЗ рдЙрдкрдпреЛрдЧ рдирд╣реАрдВ рдХрд░реЗрдВрдЧреЗред рдпрд╣ рдЗрд╕рд▓рд┐рдП рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИ рдХреНрдпреЛрдВрдХрд┐ рдХрд┐рд╕реА рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдХреЗ рдмрдЬрд╛рдп рдЕрдВрдбрд░рд╕реНрдХреЛрд░ (_) рдХрд╛ рдЙрдкрдпреЛрдЧ рди рдХрд░рдиреЗ рдкрд░ рдкреНрд░реЛрдЧреНрд░рд╛рдо рдХреА рд▓рд┐рдВрдЯрд┐рдВрдЧ рдХрд░рддреЗ рд╕рдордп F841 рддреНрд░реБрдЯрд┐ рдорд┐рд▓реЗрдЧреАред F841 рддреНрд░реБрдЯрд┐ рдпрд╣ рдмрддрд╛рддреА рд╣реИ рдХрд┐ рдХрд┐рд╕реА рд╕реНрдерд╛рдиреАрдп рд╡реЗрд░рд┐рдПрдмрд▓ рдХрд╛ рдирд╛рдо рдЕрд╕рд╛рдЗрди рдХрд┐рдпрд╛ рдЧрдпрд╛ рдерд╛ рд▓реЗрдХрд┐рди рдкреНрд░реЛрдЧреНрд░рд╛рдо рдореЗрдВ рдЙрдкрдпреЛрдЧ рдирд╣реАрдВ рд╣реБрдЖ, рдЬреЛ рдЦрд░рд╛рдм рдкреНрд░реИрдХреНрдЯрд┐рд╕ рд╣реИред

#15 Trailing underscores

рдкрд┐рдЫрд▓реА рджреЛ рдЯреНрд░рд┐рдХреНрд╕ рд╕реЗ рдЖрдЧреЗ рдмрдврд╝рддреЗ рд╣реБрдП, Python рдореЗрдВ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ (_) рдХрд╛ рдПрдХ рдФрд░ рдЙрджреНрджреЗрд╢реНрдп Python рдХреАрд╡рд░реНрдбреНрд╕ рдХреЗ рд╕рд╛рде рд╕рдВрдШрд░реНрд╖ рд╕реЗ рдмрдЪрдирд╛ рд╣реИред┬а

PEP 8 рдмрддрд╛рддрд╛ рд╣реИ рдХрд┐ trailing underscore (_) "рдкрд░рдВрдкрд░рд╛ рд╕реЗ Python рдХреАрд╡рд░реНрдбреНрд╕ рдХреЗ рд╕рд╛рде рд╕рдВрдШрд░реНрд╖ рд╕реЗ рдмрдЪрдиреЗ рдХреЗ рд▓рд┐рдП рдЙрдкрдпреЛрдЧ рдХрд┐рдпрд╛ рдЬрд╛рдирд╛ рдЪрд╛рд╣рд┐рдПред" рдпрд╣ рдпрд╣ рднреА рдХрд╣рддрд╛ рд╣реИ рдХрд┐ "рдЖрдо рддреМрд░ рдкрд░ рдХрд┐рд╕реА рдПрдХрд▓ trailing underscore рдХреЛ рдЬреЛрдбрд╝рдирд╛ рдХрд┐рд╕реА рд╕рдВрдХреНрд╖реЗрдк рдпрд╛ рдЧрд▓рдд рд╡рд░реНрддрдиреА рдХрд░рдиреЗ рд╕реЗ рдмреЗрд╣рддрд░ рд╣реИред рдЕрддрдГ list_ lst рд╕реЗ рдмреЗрд╣рддрд░ рд╣реИред"

#16 Leading underscores

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

рдЖрдк рдЕрдХреНрд╕рд░ рджреЗрдЦреЗрдВрдЧреЗ рдХрд┐ рдЕрдиреБрднрд╡реА Python рдкреНрд░реЛрдЧреНрд░рд╛рдорд░ рдХрд┐рд╕реА рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдпрд╛ рдореЗрдердб рдирд╛рдо рдХреЗ рдЖрдЧреЗ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рд▓рдЧрд╛рддреЗ рд╣реИрдВ тАУ рдФрд░ рдЗрд╕рдХреЗ рдкреАрдЫреЗ рдХрд╛рд░рдг рд╣реИред

рдХрд┐рд╕реА рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдпрд╛ рдореЗрдердб рдХреЗ рдЖрдЧреЗ рд▓рдЧрд╛ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рдПрдХ рдЫрд┐рдкрд╛ рдЕрд░реНрде рд▓рд┐рдП рд╣реЛрддрд╛ рд╣реИ: рдпрд╣ рд╡реЗрд░рд┐рдПрдмрд▓ рдпрд╛ рдореЗрдердб рдХреЗрд╡рд▓ рдЖрдВрддрд░рд┐рдХ рдЙрдкрдпреЛрдЧ рдХреЗ рд▓рд┐рдП рд╣реИред рдореВрд▓рддрдГ, рдпрд╣ рдЕрдиреНрдп рдкреНрд░реЛрдЧреНрд░рд╛рдорд░реНрд╕ рдХреЗ рд▓рд┐рдП рдПрдХ рдбрд┐рд╕реНрдХреНрд▓реЗрдорд░ рд╣реИ рдЬрд┐рд╕реЗ PEP 8 рдореЗрдВ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ рд▓реЗрдХрд┐рди Python рджреНрд╡рд╛рд░рд╛ рдкреНрд░рд╡рд░реНрддрд┐рдд рдирд╣реАрдВ рд╣реИред рдЗрд╕рд▓рд┐рдП, leading underscores рдПрдХ рдХрдордЬреЛрд░ рд╕рдВрдХреЗрддрдХ рд╣реИрдВред

Java рдХреЗ рд╡рд┐рдкрд░реАрдд, Python рдореЗрдВ private рдФрд░ public рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдХреЗ рдмреАрдЪ рд╕рдЦреНрдд рднреЗрдж рдирд╣реАрдВ рд╣реИред рджреВрд╕рд░реЗ рд╢рдмреНрджреЛрдВ рдореЗрдВ, рдЗрд╕рдХрд╛ рдЕрд░реНрде рдХреЗрд╡рд▓ рдЗрд╕рд▓рд┐рдП рд╣реИ рдХреНрдпреЛрдВрдХрд┐ Python рд╕рдореБрджрд╛рдп рдиреЗ рдЗрд╕реЗ рдЕрд░реНрде рджреЗрдиреЗ рдкрд░ рд╕рд╣рдорддрд┐ рдмрдирд╛рдИ рд╣реИред рдЗрдирдХрд╛ рд╢рд╛рдорд┐рд▓ рд╣реЛрдирд╛ рдЖрдкрдХреЗ рдкреНрд░реЛрдЧреНрд░рд╛рдореНрд╕ рдХреЗ рд╡реНрдпрд╡рд╣рд╛рд░ рдХреЛ рдкреНрд░рднрд╛рд╡рд┐рдд рдирд╣реАрдВ рдХрд░рддрд╛ред

#17 рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рд╡рд┐рдЬреБрдЕрд▓

рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рдкрд░ рдЖрдЦрд╝рд┐рд░реА рдЯрд┐рдк; рдЕрдм рддрдХ рд╣рдордиреЗ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рдХреЗ рддреАрди рдЕрд▓рдЧ-рдЕрд▓рдЧ рдЙрдкрдпреЛрдЧ рджреЗрдЦреЗ рд╣реИрдВ, рд▓реЗрдХрд┐рди рдФрд░ рдЬрд╛рдирдиреЗ рдХреЗ рд▓рд┐рдП рд╣рдорд╛рд░рд╛ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рджреЗрдЦреЗрдВ: Python рдореЗрдВ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ (_) рдХреА рднреВрдорд┐рдХрд╛ред┬а

рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рдХрд╛ рдПрдХ рдФрд░ рдЙрдкрдпреЛрдЧ рд╕рдВрдЦреНрдпрд╛рддреНрдордХ рд▓рд┐рдЯрд░рд▓реНрд╕ (integral, floating-point рдФрд░ complex) рдореЗрдВ рдЕрдВрдХреЛрдВ рдХреЗ рд╕рдореВрд╣реЛрдВ рдХреЛ рдЕрд▓рдЧ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рд╡рд┐рдЬреБрдЕрд▓ рд╕реЗрдкрд░реЗрдЯрд░ рдХреЗ рд░реВрдк рдореЗрдВ рд╣реИ тАУ рдпрд╣ Python 3.6 рдореЗрдВ рдкреЗрд╢ рдХрд┐рдпрд╛ рдЧрдпрд╛ рдерд╛ред┬а

рд╡рд┐рдЪрд╛рд░ рдпрд╣ рдерд╛ рдХрд┐ рд▓рдВрдмреЗ рд▓рд┐рдЯрд░рд▓реНрд╕ рдХреА рдкрдардиреАрдпрддрд╛ рдмрдврд╝реЗ, рдпрд╛ рдРрд╕реЗ рд▓рд┐рдЯрд░рд▓реНрд╕ рдЬрд┐рдирдХреЗ рдорд╛рди рдХреЛ рднрд╛рдЧреЛрдВ рдореЗрдВ рд╕реНрдкрд╖реНрдЯ рд░реВрдк рд╕реЗ рдЕрд▓рдЧ рджрд┐рдЦрдирд╛ рдЪрд╛рд╣рд┐рдП тАУ рдЗрд╕рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдЕрдзрд┐рдХ PEP 515 рдореЗрдВ рдкрдврд╝ рд╕рдХрддреЗ рд╣реИрдВред

рдХреЛрдб рд╕реНрдЯрд╛рдЗрд▓ рдФрд░ рд╕рд┐рдВрдЯреИрдХреНрд╕ рдЯреНрд░рд┐рдХреНрд╕

#18 __name__ == тАЬ__main__тАЭ┬а

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

рдХрд╛рдлреА рд╕рдВрднрд╛рд╡рдирд╛ рд╣реИ рдХрд┐ рдЖрдкрдиреЗ рдпрд╣ рд╕рд┐рдВрдЯреИрдХреНрд╕ рдХрдИ Python рдкреНрд░реЛрдЧреНрд░рд╛рдореНрд╕ рдореЗрдВ рджреЗрдЦрд╛ рд╣реЛрдЧрд╛; Python рдПрдХ рд╡рд┐рд╢реЗрд╖ рдирд╛рдо "__main__" рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИ рдФрд░ рдпрджрд┐ рдЪрд▓ рд░рд╣реА Python рдлрд╝рд╛рдЗрд▓ рдореБрдЦреНрдп рдкреНрд░реЛрдЧреНрд░рд╛рдо рд╣реИ, рддреЛ рдЗрд╕реЗ __name__ рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдХреЛ рд╕реЗрдЯ рдХрд░рддрд╛ рд╣реИред

рдпрджрд┐ рд╣рдо рд╕реНрдХреНрд░реАрдирд╢реЙрдЯ рдореЗрдВ рджрд┐рдЦрд╛рдП рдореЙрдбреНрдпреВрд▓ рдХреЛ рдХрд┐рд╕реА рдЕрдиреНрдп рдореЙрдбреНрдпреВрд▓ (Python рдлрд╝рд╛рдЗрд▓) рдореЗрдВ рдЗрдореНрдкреЛрд░реНрдЯ рдХрд░реЗрдВ рдФрд░ рд╡рд╣ рдлрд╝рд╛рдЗрд▓ рдЪрд▓рд╛рдПрдБ, рддреЛ рд╣рдорд╛рд░реЗ рдХреЛрдб рдореЗрдВ рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐ рдХрд╛ рд╕рддреНрдп False рд╣реЛрдЧрд╛ред рдРрд╕рд╛ рдЗрд╕рд▓рд┐рдП рдХреНрдпреЛрдВрдХрд┐ рдЬрдм рд╣рдо рдХрд┐рд╕реА рдЕрдиреНрдп рдореЙрдбреНрдпреВрд▓ рд╕реЗ рдЗрдореНрдкреЛрд░реНрдЯ рдХрд░рддреЗ рд╣реИрдВ, рддреЛ __name__ рдкрд╣рдЪрд╛рдирдХрд░реНрддрд╛ рдЙрд╕ рдореЙрдбреНрдпреВрд▓ (Python рдлрд╝рд╛рдЗрд▓) рдХреЗ рдирд╛рдо рдкрд░ рд╕реЗрдЯ рд╣реЛрддрд╛ рд╣реИред┬а

#19 тАШsetdefaultтАЩ рдореЗрдердб┬а

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

рдЖрдк рдбрд┐рдХреНрд╢рдирд░реА рдореЗрдВ рдХрдИ рдХреБрдВрдЬрд┐рдпреЛрдВ рдХреЗ рд▓рд┐рдП рдорд╛рди рд╕реЗрдЯ рдХрд░рдирд╛ рдЪрд╛рд╣ рд╕рдХрддреЗ рд╣реИрдВред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдЬрдм рдЖрдк рдХрд┐рд╕реА рдХреЙрд░реНрдкрд╕ рдореЗрдВ рд╢рдмреНрджреЛрдВ рдХреА рдЧрдгрдирд╛ рдЯреНрд░реИрдХ рдХрд░ рд░рд╣реЗ рд╣реЛрдВред рдЗрд╕реЗ рдХрд░рдиреЗ рдХрд╛ рд╕рд╛рдорд╛рдиреНрдп рддрд░реАрдХрд╛ рдпрд╣ рд╣реИ:┬а

  1. рдЬрд╛рдБрдЪреЗрдВ рдХрд┐ рдХреБрдВрдЬреА рдбрд┐рдХреНрд╢рдирд░реА рдореЗрдВ рдореМрдЬреВрдж рд╣реИ рдпрд╛ рдирд╣реАрдВ
  2. рдпрджрд┐ рд╣реИ, рддреЛ рдорд╛рди рдореЗрдВ 1 рдЬреЛрдбрд╝ рджреЗрдВред
  3. рдпрджрд┐ рдирд╣реАрдВ рд╣реИ, рддреЛ рдЙрд╕реЗ рдЬреЛрдбрд╝реЗрдВ рдФрд░ рдорд╛рди 1 рд╕реЗрдЯ рдХрд░реЗрдВред

рдХреЛрдб рдореЗрдВ рдпрд╣ рдЗрд╕ рддрд░рд╣ рджрд┐рдЦрддрд╛ рд╣реИ:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

рдЗрд╕реЗ рдХрд░рдиреЗ рдХрд╛ рдЕрдзрд┐рдХ рд╕рдВрдХреНрд╖рд┐рдкреНрдд рддрд░реАрдХрд╛ рдЖрдкрдХреА рдбрд┐рдХреНрд╢рдирд░реА рдкрд░ setdefault() рдореЗрдердб рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ рд╣реИред

рдореЗрдердб рдХреЛ рджрд┐рдпрд╛ рдЧрдпрд╛ рдкрд╣рд▓рд╛ рдЖрд░реНрдЧреНрдпреБрдореЗрдВрдЯ рд╡рд╣ рдХреБрдВрдЬреА рд╣реИ рдЬрд┐рд╕рдХреА рд╣рдо рдЬрд╛рдБрдЪ рдХрд░рдирд╛ рдЪрд╛рд╣рддреЗ рд╣реИрдВред рджреВрд╕рд░рд╛ рдЖрд░реНрдЧреНрдпреБрдореЗрдВрдЯ рд╡рд╣ рдорд╛рди рд╣реИ рдЬреЛ рддрдм рд╕реЗрдЯ рдХрд┐рдпрд╛ рдЬрд╛рдПрдЧрд╛ рдЬрдм рдХреБрдВрдЬреА рдбрд┐рдХреНрд╢рдирд░реА рдореЗрдВ рдкрд╣рд▓реЗ рд╕реЗ рдореМрдЬреВрдж рди рд╣реЛ тАУ рдпрджрд┐ рдХреБрдВрдЬреА рдореМрдЬреВрдж рд╣реИ, рддреЛ рдореЗрдердб рдХреБрдВрдЬреА рдХрд╛ рдорд╛рди рд▓реМрдЯрд╛рддрд╛ рд╣реИ, рдЕрддрдГ рдЙрд╕реЗ рдмрджрд▓рд╛ рдирд╣реАрдВ рдЬрд╛рдПрдЧрд╛ред

рдкреНрд░реЛрдЧреНрд░рд╛рдо рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдЯреНрд░рд┐рдХреНрд╕

#20 Regex рдорд┐рд▓рд╛рди

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

рд░реЗрдЧреБрд▓рд░ рдПрдХреНрд╕рдкреНрд░реЗрд╢рдВрд╕ рдЖрдкрдХреЛ рдЦреЛрдЬрдиреЗ рдХреЗ рд▓рд┐рдП рдЯреЗрдХреНрд╕реНрдЯ рдХрд╛ рдкреИрдЯрд░реНрди рдирд┐рд░реНрджрд┐рд╖реНрдЯ рдХрд░рдиреЗ рджреЗрддреА рд╣реИрдВ; рдЕрдзрд┐рдХрд╛рдВрд╢ рд▓реЛрдЧ рдЬрд╛рдирддреЗ рд╣реИрдВ рдХрд┐ рд╣рдо CTRL + F (Windows) рд╕реЗ рдЪреАрдЬреЗрдВ рдЦреЛрдЬ рд╕рдХрддреЗ рд╣реИрдВ, рд▓реЗрдХрд┐рди рдпрджрд┐ рдЖрдкрдХреЛ рдареАрдХ-рдареАрдХ рдкрддрд╛ рдирд╣реАрдВ рдХрд┐ рдХреНрдпрд╛ рдЦреЛрдЬ рд░рд╣реЗ рд╣реИрдВ, рддреЛ рдЖрдк рдХреИрд╕реЗ рдЦреЛрдЬреЗрдВрдЧреЗ? рдЬрд╡рд╛рдм рд╣реИ рдкреИрдЯрд░реНрди рдЦреЛрдЬрдирд╛ред┬а┬а

рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдпреВрдХреЗ рдирдВрдмрд░ рдПрдХ рд╕рдорд╛рди рдкреИрдЯрд░реНрди рдХрд╛ рдкрд╛рд▓рди рдХрд░рддреЗ рд╣реИрдВ: рд╡реЗ рд╢реБрд░реБрдЖрдд рдореЗрдВ рд╢реВрдиреНрдп рдФрд░ рдлрд┐рд░ рджрд╕ рдЕрдВрдХ рд░рдЦрддреЗ рд╣реИрдВ, рдпрд╛ рд╢реВрдиреНрдп рдХреА рдЬрдЧрд╣ +44 рдФрд░ рдлрд┐рд░ рджрд╕ рдЕрдВрдХ тАУ рджреВрд╕рд░реА рд╕реНрдерд┐рддрд┐ рдЕрдВрддрд░рд░рд╛рд╖реНрдЯреНрд░реАрдп рдлрд╝реЙрд░реНрдореЗрдЯ рджрд░реНрд╢рд╛рддреА рд╣реИред┬а

рд░реЗрдЧреБрд▓рд░ рдПрдХреНрд╕рдкреНрд░реЗрд╢рдВрд╕ рдмрдбрд╝рд╛ рд╕рдордп рдмрдЪрд╛рддреА рд╣реИрдВред рдпрджрд┐ рд╣рдо regex рдХреЗ рдмрдЬрд╛рдп рдЕрдкрдиреА рдЫрд╡рд┐ рдореЗрдВ рджрд┐рдЦреЗ рдорд╛рдорд▓реЛрдВ рдХреЛ рдкрдХрдбрд╝рдиреЗ рдХреЗ рд▓рд┐рдП рдирд┐рдпрдо рдХреЛрдб рдХрд░реЗрдВ, рддреЛ 10+ рдкрдВрдХреНрддрд┐рдпрд╛рдБ рд▓рдЧ рд╕рдХрддреА рд╣реИрдВред┬а

рднрд▓реЗ рд╣реА рдЖрдк рдХреЛрдб рди рд▓рд┐рдЦрддреЗ рд╣реЛрдВ, рд░реЗрдЧреБрд▓рд░ рдПрдХреНрд╕рдкреНрд░реЗрд╢рдВрд╕ рдХреИрд╕реЗ рдХрд╛рдо рдХрд░рддреА рд╣реИрдВ рдпрд╣ рдЬрд╛рдирдирд╛ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИред рдЕрдзрд┐рдХрд╛рдВрд╢ рдЖрдзреБрдирд┐рдХ рдЯреЗрдХреНрд╕реНрдЯ рдПрдбрд┐рдЯрд░реНрд╕ рдФрд░ рд╡рд░реНрдб рдкреНрд░реЛрд╕реЗрд╕рд░ find and replace рдлреАрдЪрд░реНрд╕ рдореЗрдВ regex рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддреЗ рд╣реИрдВред

#21 Regex pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

рд░реЗрдЧреБрд▓рд░ рдПрдХреНрд╕рдкреНрд░реЗрд╢рдВрд╕ рдореЗрдВ pipe (|) рдирд╛рдордХ рдПрдХ рд╡рд┐рд╢реЗрд╖ рдХреИрд░реЗрдХреНрдЯрд░ рд╣реЛрддрд╛ рд╣реИ рдЬреЛ рдЖрдкрдХреЛ рдХрдИ рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐рдпреЛрдВ рдореЗрдВ рд╕реЗ рдХрд┐рд╕реА рдПрдХ рд╕реЗ рдорд┐рд▓рд╛рди рдХрд░рдиреЗ рджреЗрддрд╛ рд╣реИ, рдФрд░ рдЗрд╕реЗ рдХрд╣реАрдВ рднреА рдЙрдкрдпреЛрдЧ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред рдЬрдм рдЖрдкрдХреЗ рдкрд╛рд╕ рдХрдИ рд╕рдорд╛рди рдкреИрдЯрд░реНрди рд╣реЛрдВ, рдпрд╣ рдмрд╣реБрдд рдХрд╛рдо рдЖрддрд╛ рд╣реИред

рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, 'Superman', 'Superwoman' рдФрд░ 'Superhuman' рд╕рднреА рдХрд╛ рд╡рд╣реА рдкреНрд░реАрдлрд╝рд┐рдХреНрд╕ рд╣реИред рдЗрд╕рд▓рд┐рдП, рдЖрдк pipe рдХрд╛ рд▓рд╛рдн рдЙрдард╛рдХрд░ рдкреИрдЯрд░реНрди рдХреЗ рджреЛрд╣рд░рд╛рдП рдЬрд╛рдиреЗ рд╡рд╛рд▓реЗ рд╣рд┐рд╕реНрд╕реЗ рдХреЛ рдмрдирд╛рдП рд░рдЦ рд╕рдХрддреЗ рд╣реИрдВ рдФрд░ рдЬрд┐рди рднрд╛рдЧреЛрдВ рдХреЛ рдЕрд▓рдЧ рдЪрд╛рд╣рд┐рдП рдЙрдиреНрд╣реЗрдВ рдмрджрд▓ рд╕рдХрддреЗ рд╣реИрдВред рдПрдХ рдмрд╛рд░ рдлрд┐рд░, рдЖрдкрдХрд╛ рдХрд╝реАрдорддреА рд╕рдордп рдмрдЪрддрд╛ рд╣реИред

рдзреНрдпрд╛рди рджреЗрдВ: рдпрджрд┐ рдЬрд┐рди рд╕рднреА рдЕрднрд┐рд╡реНрдпрдХреНрддрд┐рдпреЛрдВ рдХрд╛ рдЖрдк рдорд┐рд▓рд╛рди рдХрд░рдирд╛ рдЪрд╛рд╣рддреЗ рд╣реИрдВ рд╡реЗ рдПрдХ рд╣реА рдЯреЗрдХреНрд╕реНрдЯ рдореЗрдВ рдореМрдЬреВрдж рд╣реИрдВ, рддреЛ рдорд┐рд▓рд╛рди рдХреЗ рд▓рд┐рдП рдЯреЗрдХреНрд╕реНрдЯ рдХреА рдкрд╣рд▓реА рдЖрд╡реГрддреНрддрд┐ рд▓реМрдЯреЗрдЧреА тАУ рдЬреИрд╕реЗ, "An example text containing Superwoman, Superman, Superhuman," рдХрд╛ рдкрд░рд┐рдгрд╛рдо Superwoman рд╣реЛрдЧрд╛ред

#22 print() рдлрд╝рдВрдХреНрд╢рди рдХрд╛ тАШsepтАЩ рдкреИрд░рд╛рдореАрдЯрд░

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

print() рдлрд╝рдВрдХреНрд╢рди рдХреА рдкреВрд░реА рдХреНрд╖рдорддрд╛рдУрдВ рд╕реЗ рдЕрдирдЬрд╛рди Python рдкреНрд░реЛрдЧреНрд░рд╛рдорд░реНрд╕ рдХреА рд╕рдВрдЦреНрдпрд╛ рдЪреМрдВрдХрд╛рдиреЗ рд╡рд╛рд▓реА рд╣реИ; рдпрджрд┐ тАЬHello WorldтАЭ рдЖрдкрдХрд╛ рдкрд╣рд▓рд╛ рдкреНрд░реЛрдЧреНрд░рд╛рдо рдерд╛, рддреЛ print() рд╢рд╛рдпрдж Python рд╕реАрдЦрддреЗ рд╕рдордп рдЖрдкрдХреЗ рдкрд╣рд▓реЗ рдмрд┐рд▓реНрдЯ-рдЗрди рдлрд╝рдВрдХреНрд╢рдВрд╕ рдореЗрдВ рд╕реЗ рдПрдХ рд░рд╣рд╛ рд╣реЛрдЧрд╛ред рд╣рдо рд╕реНрдХреНрд░реАрди рдкрд░ рдлрд╝реЙрд░реНрдореЗрдЯреЗрдб рд╕рдВрджреЗрд╢ рджрд┐рдЦрд╛рдиреЗ рдХреЗ рд▓рд┐рдП print() рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВ, рд▓реЗрдХрд┐рди print() рдореЗрдВ рдЗрд╕рд╕реЗ рдХрд╣реАрдВ рдЬрд╝реНрдпрд╛рджрд╛ рд╣реИред┬а

рдКрдкрд░ рдХреЗ рдХреЛрдб рдореЗрдВ, рд╣рдордиреЗ рдЕрдкрдирд╛ рдлрд╝реЙрд░реНрдореЗрдЯреЗрдб рд╕рдВрджреЗрд╢ рджрд┐рдЦрд╛рдиреЗ рдХреЗ рдЕрд▓рдЧ-рдЕрд▓рдЧ рддрд░реАрдХреЗ рджрд┐рдЦрд╛рдП рд╣реИрдВред sep рдкреИрд░рд╛рдореАрдЯрд░ print() рдлрд╝рдВрдХреНрд╢рди рдХрд╛ рдПрдХ рд╡реИрдХрд▓реНрдкрд┐рдХ рдЖрд░реНрдЧреНрдпреБрдореЗрдВрдЯ рд╣реИ рдЬреЛ рдпрд╣ рдирд┐рд░реНрдзрд╛рд░рд┐рдд рдХрд░рдиреЗ рджреЗрддрд╛ рд╣реИ рдХрд┐ рдпрджрд┐ рд╣рдо рдПрдХ рд╕реЗ рдЕрдзрд┐рдХ рдСрдмреНрдЬреЗрдХреНрдЯ рд╢рд╛рдорд┐рд▓ рдХрд░реЗрдВ рддреЛ рдЙрдиреНрд╣реЗрдВ рдХреИрд╕реЗ рдЕрд▓рдЧ рдХрд┐рдпрд╛ рдЬрд╛рдПред┬а

рдбрд┐рдлрд╝реЙрд▓реНрдЯ рд░реВрдк рд╕реЗ рд╡реЗ рд╕реНрдкреЗрд╕ рд╕реЗ рдЕрд▓рдЧ рд╣реЛрддреЗ рд╣реИрдВ, рд▓реЗрдХрд┐рди рд╣рдордиреЗ рдЕрдкрдиреА print рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рдореЗрдВ рдпрд╣ рдмрджрд▓ рджрд┐рдпрд╛ рд╣реИ тАУ рдПрдХ рдореЗрдВ sep рдХреЛ "" рд╕реЗрдЯ рдХрд┐рдпрд╛ рд╣реИ рдФрд░ рджреВрд╕рд░реЗ рдореЗрдВ sep рдХреЛ "."ред

#23 Lambda рдлрд╝рдВрдХреНрд╢рдВрд╕┬а

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Lambda рдлрд╝рдВрдХреНрд╢рдВрд╕ рдЖрдкрдХреЛ Python рд╕реЗ рдЬреБрдбрд╝реЗ рдЕрдзрд┐рдХ рдЗрдВрдЯрд░рдореАрдбрд┐рдПрдЯ-рдПрдбрд╡рд╛рдВрд╕реНрдб рдХрд╛рдореЛрдВ рддрдХ рд▓реЗ рдЬрд╛рддреА рд╣реИрдВ тАУ рдЗрд╕ рдХреЛрд░реНрд╕ рд╕реЗ Intermediate Python рд╕реАрдЦреЗрдВред рдкрд╣рд▓реА рдирдЬрд╝рд░ рдореЗрдВ рд╡реЗ рдЬрдЯрд┐рд▓ рджрд┐рдЦрддреА рд╣реИрдВ, рд▓реЗрдХрд┐рди рджрд░рдЕрд╕рд▓ рдХрд╛рдлреА рд╕рд░рд▓ рд╣реИрдВред

рд╣рдорд╛рд░реЗ рдЙрджрд╛рд╣рд░рдг рдХреЛрдб рдореЗрдВ, рд╣рдордиреЗ рдХреЗрд╡рд▓ рдПрдХ рдЖрд░реНрдЧреНрдпреБрдореЗрдВрдЯ рдЙрдкрдпреЛрдЧ рдХрд┐рдпрд╛, рд▓реЗрдХрд┐рди рдЪрд╛рд╣реЗрдВ рддреЛ рдХрдИ рднреА рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

рдореВрд▓ рд░реВрдк рд╕реЗ, lambda рдХреАрд╡рд░реНрдб рд╣рдореЗрдВ рдПрдХ рдкрдВрдХреНрддрд┐ рдореЗрдВ рдЫреЛрдЯреЗ, рд╕реАрдорд┐рдд, рдЕрдирд╛рдо рдлрд╝рдВрдХреНрд╢рди рдмрдирд╛рдиреЗ рджреЗрддрд╛ рд╣реИред рд╡реЗ def рдХреАрд╡рд░реНрдб рд╕реЗ рдШреЛрд╖рд┐рдд рд╕рд╛рдорд╛рдиреНрдп рдлрд╝рдВрдХреНрд╢рди рдХреА рддрд░рд╣ рд╣реА рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд░рддреЗ рд╣реИрдВ, рд╕рд┐рд╡рд╛рдп рдЗрд╕рдХреЗ рдХрд┐ рдЗрди рдлрд╝рдВрдХреНрд╢рдВрд╕ рдХрд╛ рдирд╛рдо рдирд╣реАрдВ рд╣реЛрддрд╛ред

#24 тАШswapcaseтАЩ рдореЗрдердб

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

swapcase() рдореЗрдердб рдХреЛ рд╕реНрдЯреНрд░рд┐рдВрдЧ рдСрдмреНрдЬреЗрдХреНрдЯ рдкрд░ рд▓рд╛рдЧреВ рдХрд░ рд╣рдо рдПрдХ рд╣реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдЕрдкрд░рдХреЗрд╕ рдЕрдХреНрд╖рд░реЛрдВ рдХреЛ рд▓реЛрдЕрд░рдХреЗрд╕ рдФрд░ рд▓реЛрдЕрд░рдХреЗрд╕ рдЕрдХреНрд╖рд░реЛрдВ рдХреЛ рдЕрдкрд░рдХреЗрд╕ рдореЗрдВ рдмрджрд▓ рд╕рдХрддреЗ рд╣реИрдВред swapcase() рдХреЗ рдмрд╣реБрдд рдЕрдзрд┐рдХ рдЙрдкрдпреЛрдЧ рдХреЗ рдорд╛рдорд▓реЗ рдирд╣реАрдВ рд╣реИрдВ, рд▓реЗрдХрд┐рди рдпрд╣ рдЬрд╛рдирдирд╛ рдЕрдЪреНрдЫрд╛ рд╣реИред

#25 тАШisalnumтАЩ рдореЗрдердб

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

рдорд╛рди рд▓реЗрдВ рд╣рдо рдПрдХ рдкреНрд░реЛрдЧреНрд░рд╛рдо рдмрдирд╛ рд░рд╣реЗ рд╣реИрдВ рдЬрд┐рд╕рдореЗрдВ рдЙрдкрдпреЛрдЧрдХрд░реНрддрд╛рдУрдВ рдХреЛ рдкрд╛рд╕рд╡рд░реНрдб рдЗрдирдкреБрдЯ рдХрд░рдирд╛ рд╣реИ, рд▓реЗрдХрд┐рди рдЙрд╕рдореЗрдВ рдЕрдВрдХреЛрдВ рдФрд░ рдЕрдХреНрд╖рд░реЛрдВ рдХрд╛ рд╕рдВрдпреЛрдЬрди рд╣реЛрдирд╛ рдЪрд╛рд╣рд┐рдПред рд╣рдо рдЗрд╕реЗ рдПрдХ рд╣реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рд╕реНрдЯреНрд░рд┐рдВрдЧ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдкрд░ isalnum() рдХреЙрд▓ рдХрд░рдХреЗ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

рдпрд╣ рдореЗрдердб рдЬрд╛рдБрдЪрддрд╛ рд╣реИ рдХрд┐ рд╕рднреА рдХреИрд░реЗрдХреНрдЯрд░реНрд╕ рдЕрд▓реНрдлрд╛рдмреЗрдЯ (A-Za-z) рдФрд░ рдиреНрдпреВрдореЗрд░рд┐рдХ (0-9) рдХреЗ рд╣рд┐рд╕реНрд╕реЗ рд╣реИрдВ рдпрд╛ рдирд╣реАрдВред рдХреЛрдИ рд╕реНрдкреЗрд╕ рдпрд╛ рдкреНрд░рддреАрдХ (!#%$&? рдЖрджрд┐) False рд▓реМрдЯрд╛рдПрдЧрд╛ред

#26 Exception рд╣реИрдВрдбрд▓рд┐рдВрдЧ

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Python рдкреНрд░реЛрдЧреНрд░рд╛рдо рдХрд┐рд╕реА рддреНрд░реБрдЯрд┐ рдХрд╛ рд╕рд╛рдордирд╛ рдХрд░рдиреЗ рдкрд░ рд╕рдорд╛рдкреНрдд рд╣реЛ рдЬрд╛рддреЗ рд╣реИрдВред

рдХрднреА-рдХрднреА, рд╣рдо рдпрд╣ рд╡реНрдпрд╡рд╣рд╛рд░ рдирд╣реАрдВ рдЪрд╛рд╣рддреЗ, рдЬреИрд╕реЗ рдЬрдм рд╣рдорд╛рд░рд╛ рдХреЛрдб рдХрд┐рд╕реА рдПрдВрдб-рдпреВрдЬрд╝рд░ рдХреЗ рд╕рд╛рде рдЗрдВрдЯрд░реИрдХреНрдЯ рдХрд░ рд░рд╣рд╛ рд╣реЛред рдРрд╕реА рд╕реНрдерд┐рддрд┐ рдореЗрдВ рд╣рдорд╛рд░рд╛ рдХреЛрдб рд╕рдордп рд╕реЗ рдкрд╣рд▓реЗ рд╕рдорд╛рдкреНрдд рд╣реЛ рдЬрд╛рдП рддреЛ рдпрд╣ рдХрд┐рддрдирд╛ рдмреБрд░рд╛ рд╣реЛрдЧрд╛?

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

рд▓реЗрдХрд┐рди рдпрд╣ рддрднреА рд╕рд╣реА рд╣реИ рдЬрдм рд╕рдорд╕реНрдпрд╛ рд╣реЛрдиреЗ рдХреЗ рдмрд╛рдж рдЙрд╕рд╕реЗ рдирд┐рдкрдЯрдиреЗ рдХрд╛ рдХреЛрдИ рддрдВрддреНрд░ рдореМрдЬреВрдж рд╣реЛред

#27 рд▓рд┐рд╕реНрдЯреНрд╕ рдореЗрдВ рдЕрдВрддрд░ рдкрд╣рдЪрд╛рдирдирд╛

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

рдпрд╣рд╛рдБ Python рдореЗрдВ рджреЛ рд▓рд┐рд╕реНрдЯреНрд╕ рдХреЗ рдмреАрдЪ рдХрд╛ рдЕрдВрддрд░ рддреБрд▓рдирд╛ рдХрд░рдиреЗ рдХреЗ рддреАрди рдЕрд▓рдЧ-рдЕрд▓рдЧ рддрд░реАрдХреЗ рд╣реИрдВред┬а

рдиреЛрдЯ: рдЬрдм рддрдХ рдЖрдкрдХреЛ рдкрдХреНрдХрд╛ рди рдкрддрд╛ рд╣реЛ рдХрд┐ list_1, list_2 рдХрд╛ рд╕рдмрд╕реЗрдЯ рд╣реИ, рддрдм рддрдХ рд╕рдорд╛рдзрд╛рди 1 рдмрд╛рдХреА рджреЛ рд╕рдорд╛рдзрд╛рдиреЛрдВ рдЬреИрд╕рд╛ рдирд╣реАрдВ рд╣реИред

#28 Args рдФрд░ kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

рд╣рдо *args рдФрд░ **kwargs рдХрд╛ рдЙрдкрдпреЛрдЧ рдлрд╝рдВрдХреНрд╢рди рдХреЗ рдкреИрд░рд╛рдореАрдЯрд░реНрд╕ рдХреЗ рд░реВрдк рдореЗрдВ рддрдм рдХрд░рддреЗ рд╣реИрдВ рдЬрдм рд╣рдореЗрдВ рдирд╣реАрдВ рдкрддрд╛ рд╣реЛрддрд╛ рдХрд┐ рд╣рдорд╛рд░рд╛ рдлрд╝рдВрдХреНрд╢рди рдХрд┐рддрдиреЗ рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдХреА рдЕрдкреЗрдХреНрд╖рд╛ рдХрд░реЗред┬а

*args рдкреИрд░рд╛рдореАрдЯрд░ рд╣рдореЗрдВ non-keyworded (рдЕрд░реНрдерд╛рдд рдЬрд┐рди рдкреИрд░рд╛рдореАрдЯрд░реНрд╕ рдХреЗ рд╕рд╛рде рдирд╛рдо рдЖрд╡рд╢реНрдпрдХ рдирд╣реАрдВ) рдХреА рд╕реНрдерд┐рддрд┐ рдореЗрдВ рдХрд┐рд╕реА рдлрд╝рдВрдХреНрд╢рди рдХреЛ рдкрд░рд┐рд╡рд░реНрддрдиреАрдп рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рдкреИрд░рд╛рдореАрдЯрд░реНрд╕ рдкрд╛рд╕ рдХрд░рдиреЗ рджреЗрддрд╛ рд╣реИред рджреВрд╕рд░реА рдУрд░, **kwargs рдкреИрд░рд╛рдореАрдЯрд░ рд╣рдореЗрдВ рдХрд┐рд╕реА рдлрд╝рдВрдХреНрд╢рди рдХреЛ рдордирдорд╛рдиреА рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ keyworded рдкреИрд░рд╛рдореАрдЯрд░реНрд╕ рдкрд╛рд╕ рдХрд░рдиреЗ рджреЗрддрд╛ рд╣реИред

рд╡рд╛рд╕реНрддрд╡ рдореЗрдВ, *args рдФрд░ **kwargs рд╢рдмреНрдж рдЕрдкрдиреЗ-рдЖрдк рдореЗрдВ рдЬрд╛рджреБрдИ рдирд╣реАрдВ рд╣реИрдВ: рдЬрд╛рджреВ рддреЛ рд╕реНрдЯрд╛рд░ (*) рдореЗрдВ рд╣реИред рдЗрд╕рдХрд╛ рдорддрд▓рдм рдпрд╣ рд╣реИ рдХрд┐ рд╣рдо рд╕реНрдЯрд╛рд░ рдХреЗ рдмрд╛рдж рдХреЛрдИ рднреА рд╢рдмреНрдж рдЗрд╕реНрддреЗрдорд╛рд▓ рдХрд░ рд╕рдХрддреЗ рдереЗ, рд▓реЗрдХрд┐рди args рдФрд░ kwargs рдХрд╛ рдЙрдкрдпреЛрдЧ рдЖрдо рдкреНрд░рдЪрд▓рди рд╣реИ рдФрд░ Python рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЗ рдмреАрдЪ рдорд╛рдиреНрдп рд╣реИред┬а

#29 Ellipsis

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis рдПрдХ Python рдСрдмреНрдЬреЗрдХреНрдЯ рд╣реИ рдЬрд┐рд╕реЗ рддреАрди рдмрд┐рдВрджреБ (...) рджреЗрдХрд░ рдпрд╛ рдСрдмреНрдЬреЗрдХреНрдЯ (Ellipsis) рдХреЛ рд╕реНрд╡рдпрдВ рдХреЙрд▓ рдХрд░рдХреЗ рдмреБрд▓рд╛рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

рдЗрд╕рдХрд╛ рд╕рдмрд╕реЗ рдЙрд▓реНрд▓реЗрдЦрдиреАрдп рдЙрдкрдпреЛрдЧ NumPy рдореЗрдВ рдмрд╣реБ-рдЖрдпрд╛рдореА рдРрд░реЗ рдПрдХреНрд╕реЗрд╕ рдФрд░ slicing рдХреЗ рд▓рд┐рдП рд╣реЛрддрд╛ рд╣реИ, рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

рд▓реЗрдХрд┐рди Ellipsis рдХрд╛ рдПрдХ рдФрд░ рдЙрдкрдпреЛрдЧ рдЕрдирдЗрдореНрдкреНрд▓реАрдореЗрдВрдЯреЗрдб рдлрд╝рдВрдХреНрд╢рди рдореЗрдВ placeholder рдХреЗ рд░реВрдк рдореЗрдВ рд╣реИред┬а

рдЗрд╕рдХрд╛ рдЕрд░реНрде рд╣реИ рдХрд┐ рдЖрдк Ellipsis, ..., рдпрд╛ pass рдореЗрдВ рд╕реЗ рдХреБрдЫ рднреА рджреЗ рд╕рдХрддреЗ рд╣реИрдВ, рдФрд░ рддреАрдиреЛрдВ рдорд╛рдиреНрдп рд╣реЛрдВрдЧреЗред

#30 рд▓рд┐рд╕реНрдЯ рдХреЙрдореНрдкреНрд░рд┐рд╣реЗрдВрд╢рди

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

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

рдЙрд╕реА рд▓рдХреНрд╖реНрдп рдХреЛ рд╣рд╛рд╕рд┐рд▓ рдХрд░рдиреЗ рдХреЗ рдЕрдиреНрдп рддрд░реАрдХреЗ рднреА рд╣реИрдВ; рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рд╣рдо рдЗрд╕ рддрд░рд╣ lambda рдлрд╝рдВрдХреНрд╢рди рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рдереЗ:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

рд▓реЗрдХрд┐рди рдХрдИ Pythonistas рддрд░реНрдХ рджреЗрдВрдЧреЗ рдХрд┐ рдпрд╣ рд╕рдорд╛рдзрд╛рди рд▓рд┐рд╕реНрдЯ рдХреЙрдореНрдкреНрд░рд┐рд╣реЗрдВрд╢рди рдХреА рддреБрд▓рдирд╛ рдореЗрдВ рдХрдо рдкрдардиреАрдп рд╣реИред

FAQs

рд╢реБрд░реБрдЖрддреА рд▓реЛрдЧреЛрдВ рдХреЗ рд▓рд┐рдП рд╕рдмрд╕реЗ рдЙрдкрдпреЛрдЧреА Python рдЯреНрд░рд┐рдХ рдХреНрдпрд╛ рд╣реИ?

рд╢реБрд░реБрдЖрддреА рд▓реЛрдЧреЛрдВ рдХреЗ рд▓рд┐рдП f-strings рд╢рд╛рдпрдж рд╕рдмрд╕реЗ рддреБрд░рдВрдд рдЙрдкрдпреЛрдЧреА рд╣реИрдВред рдпреЗ .format() рдЬреИрд╕реЗ рдкреБрд░рд╛рдиреЗ рддрд░реАрдХреЛрдВ рдХреА рддреБрд▓рдирд╛ рдореЗрдВ рд╕реНрдЯреНрд░рд┐рдВрдЧ рдлрд╝реЙрд░реНрдореЗрдЯрд┐рдВрдЧ рдХреЛ рддреЗрдЬрд╝, рдЕрдзрд┐рдХ рдкрдардиреАрдп рдФрд░ рдХрдо рддреНрд░реБрдЯрд┐рдкреНрд░рд╡рдг рдмрдирд╛рддреА рд╣реИрдВред

Python рдореЗрдВ рджреЛ рд╡реЗрд░рд┐рдПрдмрд▓реНрд╕ рдХреЛ рд╕рдмрд╕реЗ рдЬрд▓реНрджреА рдХреИрд╕реЗ рд╕реНрд╡реИрдк рдХрд░реЗрдВ?

рд╕рдордХрд╛рд▓рд┐рдХ рдЕрд╕рд╛рдЗрдирдореЗрдВрдЯ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВ: a, b = b, aред рдХрд┐рд╕реА рдЕрд╕реНрдерд╛рдпреА рд╡реЗрд░рд┐рдПрдмрд▓ рдХреА рдЬрд╝рд░реВрд░рдд рдирд╣реАрдВ тАФ Python рдЕрд╕рд╛рдЗрди рдХрд░рдиреЗ рд╕реЗ рдкрд╣рд▓реЗ рджрд╛рдпреАрдВ рдУрд░ рдХреЛ рдкреВрд░реА рддрд░рд╣ рдореВрд▓реНрдпрд╛рдВрдХрд┐рдд рдХрд░рддрд╛ рд╣реИред

рдореИрдВ рдПрдХ рд▓рд╛рдЗрди рдореЗрдВ рджреЛ рдбрд┐рдХреНрд╢рдирд░реАрдЬрд╝ рдХреЛ рдХреИрд╕реЗ рдорд░реНрдЬ рдХрд░реВрдБ?

Python 3.9+ рдореЗрдВ | рдСрдкрд░реЗрдЯрд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВ: merged = dict_a | dict_bред рдкреБрд░рд╛рдиреЗ рд╡рд░реНрдЬрд╝рди рдХреЗ рд▓рд┐рдП {**dict_a, **dict_b} рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВред

*args рдФрд░ **kwargs рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?

*args рдЕрддрд┐рд░рд┐рдХреНрдд positional рдЖрд░реНрдЧреНрдпреБрдореЗрдВрдЯреНрд╕ рдХреЛ tuple рдореЗрдВ рдЗрдХрдЯреНрдард╛ рдХрд░рддрд╛ рд╣реИред **kwargs рдЕрддрд┐рд░рд┐рдХреНрдд keyword рдЖрд░реНрдЧреНрдпреБрдореЗрдВрдЯреНрд╕ рдХреЛ dictionary рдореЗрдВ рдЗрдХрдЯреНрдард╛ рдХрд░рддрд╛ рд╣реИред рдЬрд╛рджреВ рд╢рдмреНрджреЛрдВ рдореЗрдВ рдирд╣реАрдВ, рдмрд▓реНрдХрд┐ * рдФрд░ ** рдСрдкрд░реЗрдЯрд░реНрд╕ рдореЗрдВ рд╣реИ тАФ рдЖрдк рдЗрдирдХреЗ рдирд╛рдо рдХреБрдЫ рднреА рд░рдЦ рд╕рдХрддреЗ рд╣реИрдВред

Python рдореЗрдВ рдЬрд╛рдБрдЪреЗрдВ рдХрд┐ рд▓рд┐рд╕реНрдЯ рдЦрд╛рд▓реА рд╣реИ рдпрд╛ рдирд╣реАрдВ, рдХреИрд╕реЗ рдХрд░реЗрдВ?

not рдСрдкрд░реЗрдЯрд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░реЗрдВ: if not my_list:ред рдпрд╣ len(my_list) == 0 рдЬрд╛рдБрдЪрдиреЗ рд╕реЗ рдЕрдзрд┐рдХ Pythonic рд╣реИред

рд▓рд┐рд╕реНрдЯ рдХреЙрдореНрдкреНрд░рд┐рд╣реЗрдВрд╢рди рдФрд░ рдЬреЗрдирд░реЗрдЯрд░ рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?

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

рдореБрдЭреЗ рдЯрд░реНрдирд░реА рдСрдкрд░реЗрдЯрд░ рдХрдм рдЗрд╕реНрддреЗрдорд╛рд▓ рдХрд░рдирд╛ рдЪрд╛рд╣рд┐рдП?

рдЗрд╕реЗ рд╕рд╛рдзрд╛рд░рдг рдПрдХ-рдкрдВрдХреНрддрд┐ рд╡рд╛рд▓реЗ рдХрдВрдбреАрд╢рдирд▓реНрд╕ рдХреЗ рд▓рд┐рдП рдЗрд╕реНрддреЗрдорд╛рд▓ рдХрд░реЗрдВ, рдЬрд╣рд╛рдБ рджреЛрдиреЛрдВ рдкрд░рд┐рдгрд╛рдо рдЫреЛрдЯреЗ рдФрд░ рд╕реНрдкрд╖реНрдЯ рд╣реЛрдВ: name = "John" if condition else "Doe"ред рдЗрд╕рд╕реЗ рдЬрд╝реНрдпрд╛рджрд╛ рдЬрдЯрд┐рд▓ рдорд╛рдорд▓реЛрдВ рдореЗрдВ рд╕рд╛рдорд╛рдиреНрдп if/else рдмреНрд▓реЙрдХ рдЕрдзрд┐рдХ рдкрдардиреАрдп рд╣реЛрддрд╛ рд╣реИред

рд▓рд┐рд╕реНрдЯ рд╕реЗ рдбреБрдкреНрд▓реАрдХреЗрдЯ рд╣рдЯрд╛рдиреЗ рдХрд╛ рд╕рдмрд╕реЗ рдЖрд╕рд╛рди рддрд░реАрдХрд╛ рдХреНрдпрд╛ рд╣реИ?

рдЗрд╕реЗ set() рдореЗрдВ рд▓рдкреЗрдЯреЗрдВ рдФрд░ рд╡рд╛рдкрд╕ рдХрдиреНрд╡рд░реНрдЯ рдХрд░реЗрдВ: list(set(my_list))ред рдзреНрдпрд╛рди рд░рд╣реЗ рдХрд┐ рд╕реЗрдЯ unordered рд╣реЛрддреЗ рд╣реИрдВ, рдЗрд╕рд▓рд┐рдП рдореВрд▓ рдХреНрд░рдо рд╕реБрд░рдХреНрд╖рд┐рдд рдирд╣реАрдВ рд░рд╣реЗрдЧрд╛ред

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