Using 'match...case' in Python 3.10

The "match...case" syntax is similar to the switch statement in other object-oriented languages ​​and is designed to make matching structures to cases easier.

Let's get started.

Syntax

The "match...case" syntax is as follows:

def greeting(message):
match message.split():
case ["hello"]:
print("this message says hello")
case ["hello", name]:
print("This message is a personal greeting to {name}")
case _:
print("The message didn’t match with anything")

Let's go through the syntax to see how it works work.

The function we created accepts a parameter named message. The match keyword accepts an object to compare the listed cases.

In our example, the match keyword receives a list of strings, which is the result of the message.split() operation. To illustrate further, suppose we call the function like this:

greeting("hello")

The function first splits this string into all spaces and forms a list. For the above input, the match operator will use the ["hello"] list. It then compares the list with each case. Our first case is:

case ["hello"]

Our input matches this exactly, so the code continues executing in this case.

Output:

this message says hello

What happens if we call the function like this: greeting("hello George")?

With this input, the matching operator will use the ["hello", "George"] list to compare all cases. The first case, case "hello", will not match because there are two elements in the comparison list, not one.

Structure matching

The matching operator matches the structure of the given expression, so our first case does not match due to the length of the case expression, even if the expression is compared to the list matches the first element in .

The second case is ["hello", name]. This is what happens when our input matches. If you don't provide Python with a literal value to match, it will bind any value in the comparison expression to the variable name in the case expression. So, in our example, name will be set to George. and this case matches (it has "hello" as first element, and there is also an element, which is bound to name), so the output is:

This message is a personal greeting to George

Now let's try to call the function like this :greeting("hello George Johnson").

The comparison expression becomes ["hello", "George", "Johnson"]. Now let's look at each case. The first case fails because there are 3 elements in the comparison expression, not 1. The second case fails in the same way; the second case expects to see a list of length 2 where the first element is "hello". The first element is actually "hello", but the comparison expression has 3 elements, so this case does not match.

The only remaining option is underscore case, which is the default case that matches everything. Think of it like the default case in a switch statement. If the comparison expression does not match anything else, it will always match the _ case.

Underscore as the last case No case in this case will be run as all cases will match the underline case. This is similar to the else keyword in if...else. _ case matches everything because Python recognizes _ as a valid variable name. So like when we match case ["hello", name], the comparison expression will be bound to _ name. In our particular case, the _ variable will hold the values ​​["hello", "George", "Johnson"].

So in our latest function call greeting("hello George Johnson"), the output will be:

The message didn’t match with anything

Advanced Usage

"match...case" syntax is a very powerful tool that can be used to compare many different expressions and values. If you compare lists like we did in the example above, more matching features are available.

In a case expression, you can use operators to put all remaining elements into variables. For example:

comparison_list = ["one", "two", "three"]
match comparison_list:
case [first]:
print("this is the first element: {first}")
case [first, *rest]:
print("This is the first: {first}, and this is the rest: {rest}")
case _:
print("Nothing was matched")

In this snippet, the second case will be matched and executed with the output being:

This is the first: one, and this is the rest: ["two", "three"]

It is also possible to combine case branches from two or more structures as follows Representation:

match comparisonList:
 case [first] | [first, "two", "seven"]:
 print("this is the first element: {first}")
 case [title, "hello"] | ["hello", title]:
 print("Welcome esteemed guest {title}")
 case [first, *rest]:
 print("This is the first: {first}, and this is the rest: {rest}")
 case _:
 print("Nothing was matched")

The first and second cases consist of several different expressions to which a comparison expression can be fit to run the case branch. This provides some flexibility in combining branches.

We will also introduce the "match...case" syntax for dictionaries. The match operator checks whether the comparison expression contains the attributes in the case expression. For example:

comparisonDictionary = {
 "John": "boy",
 "Jack": "boy",
 "Jill": "girl",
 "Taylor": "girl"
}
match comparisonDictionary:
 case {"John": "boy", "Taylor": "boy"}:
 print("John and Taylor are both boys")
 case {"John": "boy", "Taylor": "girl"}:
 print("Taylor is a girl and John is a boy")
 case _:
 print("Nothing matches")

Output:

Taylor is a girl and John is a boy

The match operator will check if the case attribute exists in the input dictionary and then check if the values ​​match.

In summary, the new "match...case" operator is a powerful tool that Python developers can take advantage of when creating branching cases. With it, you can reliably check the structure of any incoming variable and make sure you're not trying to access something that doesn't exist on the variable.

Important In dictionary matching, case will still match even if the input dictionary has more attributes than case specifies.

In summary, the new "match...case" operator is a powerful tool that Python developers can take advantage of when creating branching cases. With it, it is possible to reliably check the structure of any incoming variable and ensure that no attempts are made to access something that does not exist on the variable.

The above is the detailed content of Using 'match...case' in Python 3.10. For more information, please follow other related articles on the PHP Chinese website!