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

Python Switch Case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ: рд╢реБрд░реБрдЖрддреА рдХреЗ рд▓рд┐рдП рдорд╛рд░реНрдЧрджрд░реНрд╢рд┐рдХрд╛

Python рдХреЗ match-case рдХрд╛ рдЕрдиреНрд╡реЗрд╖рдг рдХрд░реЗрдВ: рдЗрд╕рдХреЗ рд╕рд┐рдВрдЯреИрдХреНрд╕, рдбреЗрдЯрд╛ рд╕рд╛рдЗрдВрд╕, ML рдореЗрдВ рдЕрдиреБрдкреНрд░рдпреЛрдЧ, рдФрд░ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рдХреЗ рд╕рд╛рде рддреБрд▓рдирд╛рддреНрдордХ рд╡рд┐рд╢реНрд▓реЗрд╖рдгред
┬╖ 5 рдорд┐ре░ рдкрдврд╝реЗрдВ

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

Python 3.10 рдореЗрдВ рдкреЗрд╢ рдХрд┐рдП рдЧрдП Python рдХреЗ match-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдХрд╛ рдЕрдиреНрд╡реЗрд╖рдг рдХрд░реЗрдВ рдФрд░ рдЬрд╛рдиреЗрдВ рдХрд┐ рд╕реНрдЯреНрд░рдХреНрдЪрд░рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХреИрд╕реЗ Python рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдореЗрдВ рдПрдХ рдирдпрд╛ рд╕реНрддрд░ рдХреА рдЧрд░рд┐рдорд╛ рдФрд░ рд╢рдХреНрддрд┐ рд▓рд╛рддреА рд╣реИред рд╣рдо рдЗрд╕рдХреЗ рд╕рд┐рдВрдЯреИрдХреНрд╕, рдбреЗрдЯрд╛ рд╕рд╛рдЗрдВрд╕ рдФрд░ рдорд╢реАрди рд▓рд░реНрдирд┐рдВрдЧ рдореЗрдВ рдЕрдиреБрдкреНрд░рдпреЛрдЧреЛрдВ, рдФрд░ рдЕрдиреНрдп рднрд╛рд╖рд╛рдУрдВ рдХреЗ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рд╕реЗ рдЗрд╕рдХреА рддреБрд▓рдирд╛ рдкрд░ рдЪрд░реНрдЪрд╛ рдХрд░реЗрдВрдЧреЗред рдпрджрд┐ рдЖрдк Python рдореЗрдВ рдирдП рд╣реИрдВ, рддреЛ рд╣рдорд╛рд░рд╛ Python рдЪреАрдЯ рд╢реАрдЯ рдлреЙрд░ рдмрд┐рдЧрд┐рдирд░реНрд╕ рдЕрд╡рд╢реНрдп рджреЗрдЦреЗрдВред┬а

рдкрд╛рд░рдВрдкрд░рд┐рдХ Switch Case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рдХреЛ рд╕рдордЭрдирд╛

Python 3.10 рд╕реЗ рдкрд╣рд▓реЗ, Python рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЛ switch case рдЬреИрд╕реА рдХрд╛рд░реНрдпрдХреНрд╖рдорддрд╛ рдкрд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдХрдИ if-elif-else рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рдпрд╛ рдбрд┐рдХреНрд╢рдирд░реАрдЬрд╝ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ рдкрдбрд╝рддрд╛ рдерд╛ред рдпрд╣рд╛рдБ if-elif-else рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реБрдП рдПрдХ рдмреБрдирд┐рдпрд╛рджреА рдЙрджрд╛рд╣рд░рдг рд╣реИ:

day = "Saturday"

if day == "Saturday" or day == "Sunday":
    print(f"{day} is a weekend.")
elif day in ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]:
    print(f"{day} is a weekday.")
else:
    print("That's not a valid day of the week.")

# Saturday is a weekend.

Python 3.10 рдореЗрдВ Match рдФрд░ Case рдХрд╛ рдкрд░рд┐рдЪрдп

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

рд╕реНрдЯреНрд░рдХреНрдЪрд░рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХреНрдпрд╛ рд╣реИ?

PEP 634 рдореЗрдВ рдкреЗрд╢ рдХреА рдЧрдИ рд╕реНрдЯреНрд░рдХреНрдЪрд░рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ, рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдХреА рдЖрдХреГрддрд┐ рдФрд░ рд╕рд╛рдордЧреНрд░реА рдХреЗ рдЖрдзрд╛рд░ рдкрд░ рдЙрдиреНрд╣реЗрдВ рдореИрдЪ рдФрд░ рдбреАрд╕реНрдЯреНрд░рдХреНрдЪрд░ рдХрд░рдиреЗ рдХрд╛ рддрд░реАрдХрд╛ рд╣реИред рдпрд╣ рдкрд╛рд░рдВрдкрд░рд┐рдХ рд╡реИрд▓реНрдпреВ рдореИрдЪрд┐рдВрдЧ рд╕реЗ рдЕрдзрд┐рдХ рд▓рдЪреАрд▓реА рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдбреЗрд╡рд▓рдкрд░реНрд╕ рд╕реАрдХреНрд╡реЗрдВрд╕реЗрдЬрд╝, рдореИрдкрд┐рдВрдЧреНрд╕, рдФрд░ рдХрд╕реНрдЯрдо рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

Match-Case рдХрд╛ рдмреЗрд╕рд┐рдХ рд╕рд┐рдВрдЯреИрдХреНрд╕

рдпрд╣рд╛рдБ match-case рдХрд╛ рдПрдХ рд╕рд░рд▓ рдЙрджрд╛рд╣рд░рдг рд╣реИред рдЪрд▓рд┐рдП рд╕рдкреНрддрд╛рд╣ рдХреЗ рджрд┐рдиреЛрдВ рдХреЛ рд╡реАрдХреЗрдВрдб рдФрд░ рд╡реАрдХрдбреЗ рдореЗрдВ рд╡рд░реНрдЧреАрдХреГрдд рдХрд░рддреЗ рд╣реИрдВ:

day = "Monday"

# Match the day to predefined patterns
match day:
    case "Saturday" | "Sunday":
        print(f"{day} is a weekend.")  # Match weekends
    case "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday":
        print(f"{day} is a weekday.")  # Match weekdays
    case _:
        print("That's not a valid day of the week.")  # Default case

# Monday is a weekday.

рдЙрджрд╛рд╣рд░рдг рдореЗрдВ рдкреНрд░рдореБрдЦ рдЕрд╡рдзрд╛рд░рдгрд╛рдПрдБ:

  1. case рдХреЗ рд╕рд╛рде рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ:

    • case "Saturday" | "Sunday": рд╕реВрдЪреАрдмрджреНрдз рдХрд┐рд╕реА рднреА рдкреИрдЯрд░реНрди рд╕реЗ рдореЗрд▓ рдЦрд╛рддрд╛ рд╣реИред | рдкреНрд░рддреАрдХ OR рдСрдкрд░реЗрдЯрд░ рдЬреИрд╕рд╛ рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд░рддрд╛ рд╣реИред

    • case _: рдЕрдорд╛рдиреНрдп рдЗрдирдкреБрдЯ рдХреЛ рд╕рдВрднрд╛рд▓рдиреЗ рдХреЗ рд▓рд┐рдП рдХреИрдЪ-рдСрд▓ (рдбрд┐рдлреЙрд▓реНрдЯ) рдХреЗрд╕ред

  2. break рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рдирд╣реАрдВ: рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рдХреЗ рд╡рд┐рдкрд░реАрдд, Python рдкрд╣рд▓реЗ рд╕рдлрд▓ рдореИрдЪ рдХреЗ рдмрд╛рдж match рдмреНрд▓реЙрдХ рд╕реЗ рдмрд╛рд╣рд░ рдирд┐рдХрд▓ рдЬрд╛рддрд╛ рд╣реИред

match-case рдмрдирд╛рдо if-elif-else рдХреА рддреБрд▓рдирд╛

рдиреАрдЪреЗ рджреА рдЧрдИ рддрд╛рд▓рд┐рдХрд╛ рдореЗрдВ, рдЖрдк рджреЗрдЦ рд╕рдХрддреЗ рд╣реИрдВ рдХрд┐ рджреЛрдиреЛрдВ рддрдХрдиреАрдХреЗрдВ рдХреИрд╕реЗ рддреБрд▓рдирд╛ рдХрд░рддреА рд╣реИрдВ:┬а

рд╡рд┐рд╢реЗрд╖рддрд╛if-elif-elsematch-case
рдХрдм рдкреЗрд╢ рд╣реБрдЖрдкреНрд░рд╛рд░рдВрднрд┐рдХ Python рд╕рдВрд╕реНрдХрд░рдгреЛрдВ рд╕реЗ рдЙрдкрд▓рдмреНрдзPython 3.10 рдореЗрдВ рдкреЗрд╢
рд╕рд┐рдВрдЯреИрдХреНрд╕if, elif рдФрд░ else рдХреАрд╡рд░реНрдб рдХрд╛ рдЙрдкрдпреЛрдЧmatch рдФрд░ case рдХреАрд╡рд░реНрдб рдХрд╛ рдЙрдкрдпреЛрдЧ
рдкрдардиреАрдпрддрд╛рдХрдИ рд╢рд░реНрддреЛрдВ рдХреЗ рд╕рд╛рде рд╡рд┐рд╕реНрддреГрдд рд╣реЛ рд╕рдХрддрд╛ рд╣реИрдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрдиреНрд╕ рдХреЗ рд╕рд╛рде рдЕрдзрд┐рдХ рд╕рдВрдХреНрд╖рд┐рдкреНрдд рдФрд░ рдкрдардиреАрдп
рдбрд┐рдлреЙрд▓реНрдЯ рдХреЗрд╕рдбрд┐рдлреЙрд▓реНрдЯ рдкрд░рд┐рджреГрд╢реНрдп рдХреЗ рд▓рд┐рдП else рдХрд╛ рдЙрдкрдпреЛрдЧрдбрд┐рдлреЙрд▓реНрдЯ рдХреЗрд╕ рдХреЗ рд▓рд┐рдП рд╡рд╛рдЗрд▓реНрдбрдХрд╛рд░реНрдб рдХреЗ рд░реВрдк рдореЗрдВ _ рдХрд╛ рдЙрдкрдпреЛрдЧ
рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧрд╕рд░рд▓ рдХрдВрдбреАрд╢рди рдЪреЗрдХ рддрдХ рд╕реАрдорд┐рддрдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХрд╛ рд╕рдорд░реНрдерди (рдЬреИрд╕реЗ, рд╕реАрдХреНрд╡реЗрдВрд╕реЗрдЬрд╝)
рдкреНрд░рджрд░реНрд╢рдирд╕рд░рд▓ рд╢рд░реНрддреЛрдВ рдХреЗ рд▓рд┐рдП рд╕рд╛рдорд╛рдиреНрдпрддрдГ рдХреБрд╢рд▓рдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрдиреНрд╕ рдореЗрдВ рд╕рдВрднрд╛рд╡рд┐рдд рд░реВрдк рд╕реЗ рдЕрдзрд┐рдХ рдХрд╛рд░рдЧрд░
рд╕реНрдХреЛрдкрд╣рд░ рдмреНрд▓реЙрдХ рдХреЗ рд▓рд┐рдП рдЗрдВрдбреЗрдВрдЯреЗрд╢рди рд╕реЗ рд╕реНрдкрд╖реНрдЯ рд╕реНрдХреЛрдк рдЪрд╛рд╣рд┐рдПрд╕реНрдХреЛрдк рд╕реНрд╡рд╛рднрд╛рд╡рд┐рдХ рд░реВрдк рд╕реЗ case рдмреНрд▓реЙрдХреНрд╕ рдХреЗ рдЕрдВрддрд░реНрдЧрдд рдкрд░рд┐рднрд╛рд╖рд┐рдд
рдЙрдкрдпреЛрдЧ рдХреЗ рдорд╛рдорд▓реЛрдВрд╕рд░рд▓ рдирд┐рд░реНрдгрдп-рд▓реЗрдиреЗ рд╡рд╛рд▓реЗ рдХрд╛рд░реНрдпреЛрдВ рдХреЗ рд▓рд┐рдП рдЙрдкрдпреБрдХреНрддрдЬрдЯрд┐рд▓ рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░ рдХреЗ рдбреАрдХрдВрд╕реНрдЯреНрд░рдХреНрд╢рди рдХреЗ рд▓рд┐рдП рдЖрджрд░реНрд╢
рд▓рдЪреАрд▓рд╛рдкрдирд╕реНрдХреЗрд▓рд░ рддреБрд▓рдирд╛ рддрдХ рд╕реАрдорд┐рддрдЬрдЯрд┐рд▓ рдбреЗрдЯрд╛ рдкреНрд░рдХрд╛рд░реЛрдВ рдФрд░ рд╕реНрдЯреНрд░рдХреНрдЪрд░реНрд╕ рдХрд╛ рдорд┐рд▓рд╛рди рдХрд░ рд╕рдХрддрд╛ рд╣реИ
рд╕реНрд╡рдЪрд╛рд▓рд┐рдд рдмреНрд░реЗрдХрдХреБрдЫ рднрд╛рд╖рд╛рдУрдВ рдореЗрдВ рд╕реНрдкрд╖реНрдЯ break рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛рдХреЗрд╕ рдореИрдЪ рд╣реЛрддреЗ рд╣реА рд╕реНрд╡рддрдГ рдмрд╛рд╣рд░ рдирд┐рдХрд▓ рдЬрд╛рддрд╛ рд╣реИ

Python рдореЗрдВ Match рдФрд░ Case рдХреЗ рдЙрдиреНрдирдд рдЙрдкрдпреЛрдЧ

рдбреЗрдЯрд╛ рд╕рд╛рдЗрдВрд╕ рдЕрдиреБрдкреНрд░рдпреЛрдЧ

рдбреЗрдЯрд╛ рд╕рд╛рдЗрдВрд╕ рдореЗрдВ рдбреЗрдЯрд╛ рдкреНрд░реАрдкреНрд░реЛрд╕реЗрд╕рд┐рдВрдЧ рдХрд╛рд░реНрдпреЛрдВ рдХреЗ рд▓рд┐рдП Python рдХрд╛ match-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдмрд╣реБрдд рдЙрдкрдпреЛрдЧреА рд╣реЛ рд╕рдХрддрд╛ рд╣реИред рдкреНрд░реАрдкреНрд░реЛрд╕реЗрд╕рд┐рдВрдЧ рдореЗрдВ рдЕрдХреНрд╕рд░ рд╡рд┐рд╢рд┐рд╖реНрдЯ рдорд╛рдирджрдВрдбреЛрдВ рдХреЗ рдЖрдзрд╛рд░ рдкрд░ рдбреЗрдЯрд╛ рдХреЛ рд╡рд┐рднрд┐рдиреНрди рд╕рдореВрд╣реЛрдВ рдореЗрдВ рд╡рд░реНрдЧреАрдХреГрдд рдХрд░рдирд╛ рд╢рд╛рдорд┐рд▓ рд╣реЛрддрд╛ рд╣реИред

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

animal = "Eagle"
match animal:
    case "Eagle" | "Parrot":
        print("Bird")
    case "Lion" | "Tiger":
        print("Mammal")
    case "Python" | "Crocodile":
        print("Reptile")
    case _:
        print("Unknown Class")

# Bird

рдпрд╣ рддрд░реАрдХрд╛ рдЬрдЯрд┐рд▓ if-else рд▓реЙрдЬрд┐рдХ рдХреЛ рд╕рд░рд▓ рдмрдирд╛рддрд╛ рд╣реИ рдФрд░ рд╡рд┐рд╢реЗрд╖рдХрд░ рдХрдИ рд╢реНрд░реЗрдгрд┐рдпреЛрдВ рд╡рд╛рд▓реЗ рдмрдбрд╝реЗ рдбреЗрдЯрд╛рд╕реЗрдЯреНрд╕ рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░рддреЗ рд╕рдордп рдХреЛрдб рдХреЛ рдЕрдзрд┐рдХ рдкрдардиреАрдп рдФрд░ рдореЗрдВрдЯреЗрди рдХрд░рдиреЗ рдпреЛрдЧреНрдп рдмрдирд╛рддрд╛ рд╣реИред

рд╡реЗрдм рдбреЗрд╡рд▓рдкрдореЗрдВрдЯ

Django рдпрд╛ Flask рдЬреИрд╕реЗ рд╡реЗрдм рдлреНрд░реЗрдорд╡рд░реНрдХреНрд╕ рдореЗрдВ, рдЖрдк match-case рдХрд╛ рдЙрдкрдпреЛрдЧ HTTP рд░рд┐рдХреНрд╡реЗрд╕реНрдЯреНрд╕ рдХреЛ рд░реВрдЯ рдХрд░рдиреЗ рдпрд╛ рд╡рд┐рд╢рд┐рд╖реНрдЯ рдПрд░рд░ рдХреЛрдбреНрд╕ рдХреЛ рд╕рдВрднрд╛рд▓рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред рд╣рдорд╛рд░реЗ рдСрдирд▓рд╛рдЗрди рдХреЛрд░реНрд╕ рдХреЗ рд╕рд╛рде Python for Developers рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдФрд░ рдЬрд╛рдиреЗрдВред┬а

рдЙрджрд╛рд╣рд░рдг: HTTP рдореЗрдердбреНрд╕ рдХреЛ рд░реВрдЯ рдХрд░рдирд╛

# Example: Handling HTTP methods in a Flask-like application
method = "POST"

match method:
    case "GET":
        print("Fetching resource...")
    case "POST":
        print("Creating resource...")
    case "PUT":
        print("Updating resource...")
    case "DELETE":
        print("Deleting resource...")
    case _:
        print("Unsupported HTTP method.")

# Creating resource...

рд╡реНрдпрд╛рдЦреНрдпрд╛:

  • method рд╡реЗрд░рд┐рдПрдмрд▓ HTTP рд░рд┐рдХреНрд╡реЗрд╕реНрдЯ рдХреЗ рдкреНрд░рдХрд╛рд░ рдХрд╛ рдкреНрд░рддрд┐рдирд┐рдзрд┐рддреНрд╡ рдХрд░рддрд╛ рд╣реИред
  • рд╣рд░ case рд╕рдВрднрд╛рд╡рд┐рдд HTTP рдореЗрдердб рд╕реЗ рдореЗрд▓ рдЦрд╛рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рдЕрдиреНрдпрдерд╛ рдХрдИ if-elif рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╕рд░рд▓ рд╣реЛ рдЬрд╛рддреА рд╣реИред

API рд╣реИрдВрдбрд▓рд┐рдВрдЧ

API рдкреНрд░рддрд┐рдХреНрд░рд┐рдпрд╛рдУрдВ рдХреЛ рдкреНрд░реЛрд╕реЗрд╕ рдХрд░рддреЗ рд╕рдордп, match-case рдХрд╛ рдЙрдкрдпреЛрдЧ рд╡рд┐рднрд┐рдиреНрди рд╕реНрдЯреЗрдЯрд╕ рдХреЛрдбреНрд╕ рдХреЛ рд╕рдВрднрд╛рд▓рдиреЗ рдпрд╛ JSON рдкреНрд░рддрд┐рдХреНрд░рд┐рдпрд╛рдУрдВ рдХреЛ рд╡рд░реНрдЧреАрдХреГрдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИред

рдЙрджрд╛рд╣рд░рдг: рд╕реНрдЯреЗрдЯрд╕ рдХреЛрдбреНрд╕ рдХреЛ рд╕рдВрднрд╛рд▓рдирд╛

# Example: API response status code handling
status_code = 200

match status_code:
    case 200:
        print("Request succeeded.")
    case 404:
        print("Resource not found.")
    case 500:
        print("Server error. Please try again later.")
    case _:
        print("Unknown status code.")

# Request succeeded.

рдпрд╣ рддрд░реАрдХрд╛ API рдХреЗ рдкрд░рд┐рдгрд╛рдореЛрдВ рдХреА рд╡реНрдпрд╛рдЦреНрдпрд╛ рдФрд░ рдЙрди рдкрд░ рдкреНрд░рддрд┐рдХреНрд░рд┐рдпрд╛ рджреЗрдирд╛ рдЖрд╕рд╛рди рдмрдирд╛рддрд╛ рд╣реИред

рд╕рд░рд▓ рдмрдирд╛рдо рдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ

Python рдХрд╛ match-case рдХреЗрд╡рд▓ рд╕реНрдерд┐рд░ рдорд╛рдиреЛрдВ рдХреЗ рдорд┐рд▓рд╛рди рддрдХ рд╕реАрдорд┐рдд рдирд╣реАрдВ рд╣реИ; рдпрд╣ рдЕрдзрд┐рдХ рдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрдиреНрд╕ рдХреЛ рднреА рд╕рдВрднрд╛рд▓ рд╕рдХрддрд╛ рд╣реИред рдпрд╣рд╛рдБ рднреЗрдж рджреЗрдЦреЗрдВ:

рд╕рд░рд▓ рдХреЙрдиреНрд╕реНрдЯреЗрдВрдЯ рдореИрдЪрд┐рдВрдЧ

рд╕реНрдЯреНрд░рд┐рдВрдЧреНрд╕ рдпрд╛ рдЗрдиреНрдЯреАрдЬрд░реНрд╕ рдЬреИрд╕реЗ рд╕рд╛рдзрд╛рд░рдг рдорд┐рд▓рд╛рди, рдКрдкрд░ рджрд┐рдП рдЧрдП рдЙрджрд╛рд╣рд░рдгреЛрдВ рдХреА рддрд░рд╣, рд╕рд╛рдлрд╝-рд╕реБрдерд░реА рдФрд░ рдкрдардиреАрдп рд▓реЙрдЬрд┐рдХ рдХреЗ рд▓рд┐рдП рдмреЗрд╣рддрд░реАрди рд╣реИрдВред

рдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ

рд╕реНрдЯреНрд░рдХреНрдЪрд░реНрдб рдбреЗрдЯрд╛ (рдЬреИрд╕реЗ рдбрд┐рдХреНрд╢рдирд░реАрдЬрд╝, рд╕реАрдХреНрд╡реЗрдВрд╕реЗрдЬрд╝) рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░рддреЗ рд╕рдордп, match-case рдбреЗрдЯрд╛ рдирд┐рдХрд╛рд▓рдиреЗ рдФрд░ рдЙрд╕реЗ рдХреБрд╢рд▓рддрд╛ рд╕реЗ рд╕рдВрд╕рд╛рдзрд┐рдд рдХрд░рдиреЗ рдореЗрдВ рд╕рдХреНрд╖рдо рд╣реИред

рдЙрджрд╛рд╣рд░рдг: рдбреЗрдЯрд╛ рд╕реНрдЯреНрд░рдХреНрдЪрд░реНрд╕ рдХрд╛ рдорд┐рд▓рд╛рди

# Example: Categorizing configurations
config = {"type": "database", "name": "PostgreSQL", "version": 13}

match config:
    case {"type": "database", "name": name, "version": version}:
        print(f"Database: {name} (Version {version})")
    case {"type": "cache", "name": name}:
        print(f"Cache system: {name}")
    case _:
        print("Unknown configuration.")

# Database: PostgreSQL (Version 13)

рд╡реНрдпрд╛рдЦреНрдпрд╛:

  • рдкрд╣рд▓рд╛ case рдбрд┐рдХреНрд╢рдирд░реА рд╕реЗ name рдФрд░ version рдирд┐рдХрд╛рд▓рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рд╕реНрдЯреНрд░рдХреНрдЪрд░реНрдб рдбреЗрдЯрд╛ рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░рдирд╛ рдЖрд╕рд╛рди рд╣реЛрддрд╛ рд╣реИред

  • рдпрд╣ Python рдХреА рд╕реНрдЯреНрд░рдХреНрдЪрд░рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХреА рд╡рд╛рд╕реНрддрд╡рд┐рдХ рд╢рдХреНрддрд┐ рдХреЛ рджрд┐рдЦрд╛рддрд╛ рд╣реИ, рдЬреЛ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рдЗрдореНрдкреНрд▓реАрдореЗрдВрдЯреЗрд╢рдиреНрд╕ рд╕реЗ рдХрд╣реАрдВ рдЖрдЧреЗ рдЬрд╛рддреА рд╣реИред

рдпрд╣рд╛рдБ рдХреЗрд╡рд▓ рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХ рдЬреЛрдбрд╝ рдХреЗ рд╕рд╛рде рд╕рдВрдХреНрд╖рд┐рдкреНрдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рдЕрдиреБрднрд╛рдЧ рд╣реИ:

рдмреЗрд╕рд┐рдХ Switch-Case рд╕реЗ рдЖрдЧреЗ

рдмреЗрд╕рд┐рдХ рд╡реИрд▓реНрдпреВ рдореИрдЪрд┐рдВрдЧ рд╕реЗ рдЖрдЧреЗ, Python рдХрд╛ match-case рдХреБрдЫ рдРрд╕реА рд╡рд┐рд╢реЗрд╖рддрд╛рдПрдБ рд╢рд╛рдорд┐рд▓ рдХрд░рддрд╛ рд╣реИ рдЬреЛ рдЗрд╕реЗ рдЕрдиреНрдп рднрд╛рд╖рд╛рдУрдВ рдХреЗ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рд╕реЗ рдЕрд▓рдЧ рдмрдирд╛рддреА рд╣реИрдВред

рдЧрд╛рд░реНрдб рдХреНрд▓реЙрдЬрд╝

рдЧрд╛рд░реНрдб рдПрдХ if рд╢рд░реНрдд рд╣реЛрддреА рд╣реИ рдЬрд┐рд╕реЗ рдХрд┐рд╕реА case рд╕реЗ рдЬреЛрдбрд╝рд╛ рдЬрд╛рддрд╛ рд╣реИ, рдФрд░ рдХреЗрд╕ рдХреЗ рдореИрдЪ рд╣реЛрдиреЗ рдХреЗ рд▓рд┐рдП рдЙрд╕рдХрд╛ рд╕рдЪ рд╣реЛрдирд╛ рдЖрд╡рд╢реНрдпрдХ рд╣реИред рдЗрд╕рд╕реЗ рдЖрдк рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХреЛ рдЕрддрд┐рд░рд┐рдХреНрдд рд▓реЙрдЬрд┐рдХ рдХреЗ рд╕рд╛рде рдЬреЛрдбрд╝ рд╕рдХрддреЗ рд╣реИрдВ тАФ рдЬреЛ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рдирд╣реАрдВ рдХрд░ рд╕рдХрддреЗ:

match point:
    case (x, y) if x == y:
        print(f"Point is on the diagonal at {x}")
    case (x, y) if x > 0 and y > 0:
        print(f"Point {point} is in the first quadrant")
    case (x, y):
        print(f"Point {point} is somewhere else")

# Point (3, 7) is in the first quadrant
┬а

рдЬрдм рдХреЗрд╡рд▓ рдкреИрдЯрд░реНрди рд╕реЗ рдорд╛рдорд▓реЛрдВ рдХреЗ рдмреАрдЪ рдЕрдВрддрд░ рдХрд░рдирд╛ рдкрд░реНрдпрд╛рдкреНрдд рд╡рд┐рд╢рд┐рд╖реНрдЯ рди рд╣реЛ, рддрдм рдЧрд╛рд░реНрдб рдЙрдкрдпреЛрдЧреА рд╣реЛрддреЗ рд╣реИрдВред

switch-case рд╕реЗ рдЖрдЧреЗ: рдбреАрд╕реНрдЯреНрд░рдХреНрдЪрд░рд┐рдВрдЧ рдкреИрдЯрд░реНрдиреНрд╕

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

рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдХрд┐рд╕реА рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдХрд╛ рдорд┐рд▓рд╛рди:

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

point = Point(0, 5)

match point:
    case Point(x=0, y=0):
        print("Origin")
    case Point(x=0, y=y):
        print(f"On the Y-axis at {y}")
    case Point():
        print("Somewhere else on the plane")

# On the Y-axis at 5

рдпрджрд┐ рдЖрдк рдЗрди рдЙрдиреНрдирдд рдкреИрдЯрд░реНрдиреНрд╕ рдХреЛ рдЧрд╣рд░рд╛рдИ рд╕реЗ рдЦреЛрдЬрдирд╛ рдЪрд╛рд╣рддреЗ рд╣реИрдВ, рддреЛ PEP 636 рджреЗрдЦреЗрдВ, рдЬреЛ рд╕реНрдЯреНрд░рдХреНрдЪрд░рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдкрд░ рдЖрдзрд┐рдХрд╛рд░рд┐рдХ рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рд╣реИред

Python Switch Case: рдЖрдо рдЧрд▓рддрд┐рдпрд╛рдБ рдФрд░ рд╕рд░реНрд╡реЛрддреНрддрдо рдкреНрд░рдерд╛рдПрдБ

рдбрд┐рдмрдЧрд┐рдВрдЧ рд╕реБрдЭрд╛рд╡

Python рдореЗрдВ match-case рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╕рдордп рдПрдХ рдЖрдо рдЧрд▓рддреА рдбрд┐рдлреЙрд▓реНрдЯ рдХреЗрд╕ рдХреЗ рд▓рд┐рдП рдЕрдВрдбрд░рд╕реНрдХреЛрд░ (_) рд╢рд╛рдорд┐рд▓ рдХрд░рдирд╛ рднреВрд▓ рдЬрд╛рдирд╛ рд╣реИ, рдЬреЛ рдкрд╛рд░рдВрдкрд░рд┐рдХ if-else рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рдореЗрдВ 'else' рдХреЗ рд╕рдорд╛рди рд╣реИред рдпрджрд┐ рдХреЛрдИ рд╡рд┐рд╢рд┐рд╖реНрдЯ рдХреЗрд╕ рдореЗрд▓ рдирд╣реАрдВ рдЦрд╛рддрд╛, рддреЛ рдпрд╣ рдЕрдкреНрд░рддреНрдпрд╛рд╢рд┐рдд рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд╛ рдХрд╛рд░рдг рдмрди рд╕рдХрддрд╛ рд╣реИред рд╣рдореЗрд╢рд╛ рдЕрдкреНрд░рддреНрдпрд╛рд╢рд┐рдд рдпрд╛ рд╡рд┐рд╡рд┐рдз рдорд╛рдиреЛрдВ рдХреЛ рд╕рдВрднрд╛рд▓рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдбрд┐рдлреЙрд▓реНрдЯ рдХреЗрд╕ рд╢рд╛рдорд┐рд▓ рдХрд░реЗрдВред

рдкреНрд░рджрд░реНрд╢рди рд╕рдВрдмрдВрдзреА рд╡рд┐рдЪрд╛рд░

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

Python Match-Case рдмрдирд╛рдо рдкрд╛рд░рдВрдкрд░рд┐рдХ Switch-Case

рддреБрд▓рдирд╛рддреНрдордХ рд╡рд┐рд╢реНрд▓реЗрд╖рдг

Python рдХрд╛ match-case, Java рдпрд╛ C++ рдЬреИрд╕реА рднрд╛рд╖рд╛рдУрдВ рдореЗрдВ рдкрд╛рдП рдЬрд╛рдиреЗ рд╡рд╛рд▓реЗ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рд╕реЗ рдХрд╛рдлреА рднрд┐рдиреНрди рд╣реИред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, Java рдореЗрдВ switch рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдХреЗрд╡рд▓ рд╕реНрдХреЗрд▓рд░ рдорд╛рдиреЛрдВ (рдЬреИрд╕реЗ рдЗрдиреНрдЯреАрдЬрд░реНрд╕ рдФрд░ enum рдкреНрд░рдХрд╛рд░) рдХреЗ рдорд┐рд▓рд╛рди рддрдХ рд╕реАрдорд┐рдд рд╣реИ, рдЬрдмрдХрд┐ Python рдХрд╛ match-case рдХрд╣реАрдВ рдЕрдзрд┐рдХ рд▓рдЪреАрд▓реА рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИ, рдЬрд┐рд╕рд╕реЗ рд╕реАрдХреНрд╡реЗрдВрд╕реЗрдЬрд╝ рдФрд░ рдХреНрд▓рд╛рд╕ рдЗрдВрд╕реНрдЯреЗрдВрд╕ рдЬреИрд╕реЗ рдЬрдЯрд┐рд▓ рдбреЗрдЯрд╛ рдкреНрд░рдХрд╛рд░реЛрдВ рдХрд╛ рдорд┐рд▓рд╛рди рд╕рдВрднрд╡ рд╣реЛрддрд╛ рд╣реИред рдЗрд╕рд╕реЗ Python рдХрд╛ рдЗрдореНрдкреНрд▓реАрдореЗрдВрдЯреЗрд╢рди рдЕрдзрд┐рдХ рд╢рдХреНрддрд┐рд╢рд╛рд▓реА рдмрди рдЬрд╛рддрд╛ рд╣реИ, рд▓реЗрдХрд┐рди рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдЕрд╡рдзрд╛рд░рдгрд╛рдУрдВ рдХреА рдЧрд╣рд░реА рд╕рдордЭ рднреА рдЖрд╡рд╢реНрдпрдХ рд╣реЛрддреА рд╣реИред

рдЯреНрд░рд╛рдВрдЬрд╝рд┐рд╢рдирд┐рдВрдЧ рдЧрд╛рдЗрдб

C++ рдпрд╛ Java рдЬреИрд╕реА рднрд╛рд╖рд╛рдУрдВ рдореЗрдВ рдкрд╛рд░рдВрдкрд░рд┐рдХ switch-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕ рд╕реЗ рдкрд░рд┐рдЪрд┐рдд рдкреНрд░реЛрдЧреНрд░рд╛рдорд░реНрд╕ рдХреЗ рд▓рд┐рдП, Python рдХреЗ match-case рдкрд░ рдЖрдирд╛, рд╕рд░рд▓ рд╡реИрд▓реНрдпреВ рдореИрдЪрд┐рдВрдЧ рд╕реЗ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХреА рдУрд░ рд╕реЛрдЪ рдореЗрдВ рдмрджрд▓рд╛рд╡ рдХреА рдорд╛рдБрдЧ рдХрд░рддрд╛ рд╣реИред

рдпрд╣ рд╕рдордЭрдирд╛ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИ рдХрд┐ Python рдХрд╛ match-case рдХреЗрд╡рд▓ switch-case рдирд╣реАрдВ рд╣реИ; рдпрд╣ рдбреЗрдЯрд╛ рдкреНрд░рдХрд╛рд░реЛрдВ рдХреЛ рдбреАрдХрдВрд╕реНрдЯреНрд░рдХреНрдЯ рдХрд░рдиреЗ рдФрд░ рдЬрдЯрд┐рд▓ рд╕реНрдЯреНрд░рдХреНрдЪрд░реНрд╕ рд╕реЗ рдЬрд╛рдирдХрд╛рд░реА рдирд┐рдХрд╛рд▓рдиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдмрд╣реБрдореБрдЦреА рдЙрдкрдХрд░рдг рд╣реИред рд╡рд┐рднрд┐рдиреНрди рдбреЗрдЯрд╛ рдкреНрд░рдХрд╛рд░реЛрдВ рдФрд░ рдкреИрдЯрд░реНрдиреНрд╕ рдХреЗ рд╕рд╛рде рдЕрднреНрдпрд╛рд╕ рдХрд░рдирд╛ рдЗрд╕рдХреЗ рдЙрдкрдпреЛрдЧ рдореЗрдВ рдорд╣рд╛рд░рдд рд╣рд╛рд╕рд┐рд▓ рдХрд░рдиреЗ рдХреА рдХреБрдВрдЬреА рд╣реИред

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

Python рдХреЗ match рдФрд░ case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯреНрд╕, рд╕рдВрд╕реНрдХрд░рдг 3.10 рдореЗрдВ рдкреЗрд╢ рдХрд┐рдП рдЧрдП, рдЖрдзреБрдирд┐рдХ Python рдХреА рдПрдХ рд╕реНрдерд╛рдкрд┐рдд рд╡рд┐рд╢реЗрд╖рддрд╛ рдмрди рдЪреБрдХреЗ рд╣реИрдВред рддрдм рд╕реЗ, рд╕реНрдЯреНрд░рдХреНрдЪрд░рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдкрд░рд┐рдкрдХреНрд╡ рд╣реЛрдХрд░ рдПрдХ рд╡рд┐рд╢реНрд╡рд╕рдиреАрдп рдЙрдкрдХрд░рдг рдмрди рдЧрдпрд╛ рд╣реИ, рдЬреЛ рднрд╛рд╖рд╛ рдХреЗ рд╣рд░ рд╕рдХреНрд░рд┐рдп рд░реВрдк рд╕реЗ рд╕рдорд░реНрдерд┐рдд рд╕рдВрд╕реНрдХрд░рдг рдореЗрдВ рдЙрдкрд▓рдмреНрдз рд╣реИ тАФ рдирд╡реАрдирддрдо рд╕реНрдерд┐рд░ рд░рд┐рд▓реАрдЬрд╝ Python 3.14.4 (рдЕрдкреНрд░реИрд▓ 2026), рд╕рд╛рде рд╣реА 3.13 рдФрд░ 3.12 рд╕рд╣рд┐рддред

рдЖрдк рд╣рдорд╛рд░реЗ рдкреВрд░реНрдг рдЯреНрдпреВрдЯреЛрд░рд┐рдпрд▓ рдореЗрдВ Python Functions рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдФрд░ рдкрдврд╝ рд╕рдХрддреЗ рд╣реИрдВ рдФрд░ рд╣рдорд╛рд░реЗ Intermediate Python┬ардХреЛрд░реНрд╕ рдореЗрдВ рдЗрд╕ рдФрд░ рдЕрдиреНрдп рдЕрд╡рдзрд╛рд░рдгрд╛рдУрдВ рдХрд╛ рдЕрдиреНрд╡реЗрд╖рдг рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

Matt Crabtree

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

Matt Crabtree

рдПрдЖрдИ рдФрд░ рдПрдбрдЯреЗрдХ рдХреНрд╖реЗрддреНрд░ рдореЗрдВ рд╕реАрдирд┐рдпрд░ рд╕рдВрдкрд╛рджрдХред рдбреЗрдЯрд╛ рдФрд░ рдПрдЖрдИ рд░реБрдЭрд╛рдиреЛрдВ рдХреА рдкрдбрд╝рддрд╛рд▓ рдХреЗ рд▓рд┐рдП рдкреНрд░рддрд┐рдмрджреНрдзред┬а┬а

Python Switch Case FAQs

рдпрджрд┐ рдПрдХ match-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдореЗрдВ рджреЛ рдХреЗрд╕ рдПрдХ рд╣реА рдЗрдирдкреБрдЯ рд╕реЗ рдореЗрд▓ рдЦрд╛рддреЗ рд╣реИрдВ рддреЛ рдХреНрдпрд╛ рд╣реЛрддрд╛ рд╣реИ?

Python рдЗрди рдорд╛рдорд▓реЛрдВ рдХрд╛ рдореВрд▓реНрдпрд╛рдВрдХрди рдЙрдирдХреЗ рдХреНрд░рдо рдореЗрдВ рдХрд░рддрд╛ рд╣реИ рдЬрд┐рд╕ рдХреНрд░рдо рдореЗрдВ рд╡реЗ рд▓рд┐рдЦреЗ рдЧрдП рд╣реИрдВред рдкрд╣рд▓рд╛ рдореЗрд▓ рдЦрд╛рддрд╛ рдХреЗрд╕ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рд╣реЛрддрд╛ рд╣реИ рдФрд░ match рдмреНрд▓реЙрдХ рддреБрд░рдВрдд рд╕рдорд╛рдкреНрдд рд╣реЛ рдЬрд╛рддрд╛ рд╣реИред

рдХреНрдпрд╛ match-case рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд╕реНрдЯрдо рдХреНрд▓рд╛рд╕реЗрд╕ рдпрд╛ рдСрдмреНрдЬреЗрдХреНрдЯреНрд╕ рдХреЗ рд╕рд╛рде рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ?

рд╣рд╛рдБ, match-case рдХрд╕реНрдЯрдо рдХреНрд▓рд╛рд╕реЗрд╕ рдХреЗ рд╕рд╛рде рдХрд╛рдо рдХрд░ рд╕рдХрддрд╛ рд╣реИред рдЖрдк рдРрдЯреНрд░рд┐рдмреНрдпреВрдЯреНрд╕ рд╕реЗ рдореЗрд▓ рдЦрд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдкреИрдЯрд░реНрди рдкрд░рд┐рднрд╛рд╖рд┐рдд рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдпрд╛ рдЕрддрд┐рд░рд┐рдХреНрдд рд▓реЙрдЬрд┐рдХ рд▓рд╛рдЧреВ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЧрд╛рд░реНрдбреНрд╕ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

рдХреНрдпрд╛ match-case, if-elif-else рд╕реЗ рддреЗрдЬ рд╣реИ?

рдкреНрд░рджрд░реНрд╢рди рдХрд╛ рдЕрдВрддрд░ рд╢рд░реНрддреЛрдВ рдХреА рдЬрдЯрд┐рд▓рддрд╛ рдкрд░ рдирд┐рд░реНрднрд░ рдХрд░рддрд╛ рд╣реИред рд╕рд░рд▓ рд╡реИрд▓реНрдпреВ рдЪреЗрдХреНрд╕ рдХреЗ рд▓рд┐рдП, рджреЛрдиреЛрдВ рдХрд╛ рдкреНрд░рджрд░реНрд╢рди рд▓рдЧрднрдЧ рд╕рдорд╛рди рд╣реЛрддрд╛ рд╣реИред рд╣рд╛рд▓рд╛рдБрдХрд┐, рдЬрдЯрд┐рд▓ рдкреИрдЯрд░реНрди рдореИрдЪрд┐рдВрдЧ рдХреЗ рд▓рд┐рдП match-case рдЕрдзрд┐рдХ рдХреБрд╢рд▓ рдФрд░ рдЕрдзрд┐рдХ рдкрдардиреАрдп рд╣реЛ рд╕рдХрддрд╛ рд╣реИред

match-case рд╕реНрдЯреЗрдЯрдореЗрдВрдЯ рдореЗрдВ рдЧрд╛рд░реНрдб рдХреНрдпрд╛ рд╣реИ?

рдЧрд╛рд░реНрдб рд╡рд╣ рд╢рд░реНрдд рд╣реИ рдЬреЛ case рдХреЗ рдмрд╛рдж рдирд┐рд░реНрджрд┐рд╖реНрдЯ рдХреА рдЬрд╛рддреА рд╣реИ рдФрд░ рдпрд╣ рдирд┐рд░реНрдзрд╛рд░рд┐рдд рдХрд░рддреА рд╣реИ рдХрд┐ рдХреЛрдИ рдХреЗрд╕ рдХрдм рдореЗрд▓ рдЦрд╛рдирд╛ рдЪрд╛рд╣рд┐рдПред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП:

match value:
    case x if x > 10:
        print("Value is greater than 10.")
рдХреНрдпрд╛ рдЖрдк 3.10 рд╕реЗ рдкрд╣рд▓реЗ рдХреЗ Python рд╕рдВрд╕реНрдХрд░рдгреЛрдВ рдореЗрдВ match-case рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ?

рдирд╣реАрдВ, match-case рдХреЗрд╡рд▓ Python 3.10 рдФрд░ рдЙрд╕рдХреЗ рдмрд╛рдж рдХреЗ рд╕рдВрд╕реНрдХрд░рдгреЛрдВ рдореЗрдВ рдЙрдкрд▓рдмреНрдз рд╣реИред рдкрд╣рд▓реЗ рдХреЗ рд╕рдВрд╕реНрдХрд░рдгреЛрдВ рдХреЗ рд▓рд┐рдП, рдЖрдк рд╕рдорд╛рди рдХрд╛рд░реНрдпрдХреНрд╖рдорддрд╛ рдкреНрд░рд╛рдкреНрдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП if-elif-else рдпрд╛ рдбрд┐рдХреНрд╢рдирд░реА рдореИрдкрд┐рдВрдЧ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред

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