Awesome! I'd love to work on language tooling. How did you get that job?

I guess I should also point out that libcst has "matchers" that do effectively what the match statement does and can be used pre-Python3.10.

Hello 👋. What does "static analysis" mean? Thanks.

@@pranavnyavanandi9710 it's the process of analyzing code by looking at its structure

@@pranavnyavanandi9710 to add to what Tushar is saying: static analysis is basically inferring facts about a program without running it, by looking at the source code or sometimes binary (analyzing the instructions) This is in contrast to dynamic analysis / run-time analysis, which looks at the characteristics of a program while it is being run. (Analyzing the behavior)

I am glad that Rust and Python both copied it

Scala too. Its awesome for functional programming.

I just wish python also had sum types. It would make things so much easier.

@Jamie Walkerdine functional tools? Python has the biggest repository of plugins, modules, etc. You can literally do anything with python, from making a full stack website to a neural network, pattern recognition, data science, ETL, etc. Perhaps you mean functional tools as in functional programming, in which case I dont understand your point at all since structural pattern matching is a feature (one of many) of functional programming.

@Jamie Walkerdine Pattern matching is very useful. In fact, it's pretty much the only way to differentiate between different variants of a sum type. Of course, python doesn't have sum types, so... it doesn't add super much. It does mean you can more easily deal with deeply nested structures, but let's be honest - that is pretty rare.

same here, only with prolog

Agrees in Scala

You should demand a refund on your tuition if they taught you OCaml.

@@waytospergtherebro whats wrong with ocaml

@@waytospergtherebro if you can understand ocaml, no normal language can break you

Great to hear!

That's true, like checking if (x == 1) and pulling the answer from the statement like true or false You can also use if (is_true:= (x == 1)) and use the new variable to check against other conditions Probably not the most readable code.

That's exactly what the walrus operator, introduces in 3.9 is meant for. (See the other comment)

Me: patiently waiting the next advanced video from YOUR channel

@@mCoding Lol new one coming tomorrow in fact. I've been taking time away from writing/shoot/animating to read about Reinforcement Learning.. and why it doesn't work well (yet) in production. Not rushing this one. Would like to make a series that's useful and not totally redundant with what's out there.

This is mutual respect for each other 👍🤝

You're very welcome!

Agreed. The terser syntax of switch statements is much easier to skim and read imo.

​​​​​@@calyodelphi124 100% that. It has the exact benefit of color coding. You know exactly what you're dealing with the moment you lay your eyes on one of those colors. I have no idea why people have been gaslighted into believing that switch is bad. It sounds very Apple-y "you don't need that feature" to me.

If you want to easily vhange compared variable, use some temporal variable.. patt = x if patt == case1: ... elif patt == case2: ... else: ...

I guess time will tell if people use it this way. I will be happy to change my mind if the community agrees it is a better switch. Apparently some of those integer-only optimizations might actually be on the way, that would be cool!

you can recurse your match statements however

Hello. I'm a novice programmer, I know basics of C and am decent in Python. That said, can you tell me what really is the core difference between a compiled vs. an interpreted language? Because, in a compiled language, the code directly gets converted into machine readable code - which is then executed by the processor **line by line**. In interpreted languages like python, the source code is first converted into something called "bytecode" at once - that is, _compiled_ into bytecode, after which, the bytecode is executed again *line by line*. There really seems to be not much difference. Except that, the conversion of code to bytecode in case of interpreted languages makes the code portable, since the 'Virtual Machine' as I have heard, then converts the bytecode to machine code specific to that machine. Is it that the bytecode is converted line by line into machine code and then immediately executed before moving on to the next line of bytecode, is that the difference? Thanks.

A big difference is that python bytecode is not executed directly by the processor. A Python source file is just a high level way of generating instructions for another program: the python interpreter. And a C source file is just a high level way of generating instructions for the CPU. If you create a C source file or change a C program's source code, you need to recompile it (that is, you need to (re)generate the binary): nobody is going to do that for you. On the other hand, when you create or change a Python file, you don't need to compile anything (in the traditional sense of the term) because the thing that "talks" to the CPU (this is, the python interpreter) has not changed at all. c source -> ... -> instructions for the CPU python source -> ... -> instructions for the Python interpreter -> ... -> instructions for the CPU I think this is the key to your doubt: the python interpreter DOES NOT convert bytecode into machine readable code. Instead, this bytecode contains instructions for the virtual machine. The virtual machine just follows those instructions, executes them (side note: a line of python code does not translate directly intro one instruction for the virtual machine, so there is no such thing as a *line by line* interpretation). Try to think an extremely simple example. A C program that enters a while-true loop and prompts the user for one of 2 characters: d or t. If the user enters "t", the program prints the time on screen. If the user enters "d" the program prints the date on screen. Now the next step is to introduce a small modification on your program in such a way that instead of waiting for the user to input anything, it has the ability to process files with strings of "d"s and "t"s. Your program has become a (rather useless...) interpreter for a new kind of (rather limited...) programming language. Eventually, you can make your C program a little bit more useful by having it accept things like "1000000 t" and not force the user to actually type a million times the letter "t" on a file. Of course, your program gains complexity, it has to parse the file and discover its structure. A nice performance boost: once your program figures out what to do with a line like "100 t" in a file, it would be nice to save it for future use if the input file does not change (think `__pycache__` and bytecode....). In some way, you start "compiling" these files into simpler strings of "d"s and "t"s. But do not forget: these "d"s and "t"s are far far far away from being instructions the CPU can understand. hope this helps! it's a difficult thing to discuss in a youtube comment thread :D

Thanks for catching this! I even checked the docs, but in the docs the parameter name is "default" and it is not mentioned that the arguments are positional only, oops!

Yeah, it's really annoying that many built-in functions take positional-only arguments, even when users might reasonably want to explicitly use a keyword. Someone should write a PEP.

It might make even more sense with Enum over strings if there is an a priori known finite number of cases

That's called polymorphism in OOP paradigm. Please use it, and do not use switch case of function references.

@@iMaxBlazer Is using a dictionary of functions instead of huge elif statement really such a bad practice? It always seemed more readable and much more editable to me.

hard same, I pretty much always do this when possible. python is multi-paradigm, the fact that functions are first-class objects and we can easily use elegant FP patterns like this is awesome.

This is what i have been using, and is match more readable and maintainable .

@@iMaxBlazer were we in a language that makes use of code locality (cache misses and branch prediction misses can be avoided on typical use cases), it could be a huge hit to performance, so only use it when you explicitly need it as part of a library if performance is a concern (just saying be aware of its potential pitfalls)

I'd be careful not to confuse functional languages with languages with algebraic data types. While there's a huge amount of overlap between the two, it's the presence of ADTs where having pattern matching shines. Languages like Erlang that lack ADTs use tagged tuples to similar effect, so the end result is the same.

Do type checkers support this now!? I've been waiting since it came out!

it would be interesting to compare the performance of the match and the if solutions, but hopefully that's going to improve

The point of this feature isn't performance, but readability and boilerplate elimination. Python 3.11 gives you a speed boost of ~40%, OTOH. So no, not Python in a nutshell. Python's speed is held back by its C API, and that's hard to fix without breaking stuff.

Does clang lib python bindings works in windows?

Good point! I actually considered whether to also compare against the early-return version that would be less indented, but I decided not to since it would require additional refactoring. In my opinion, the early return one is still less readable than the match, but let me know if you think otherwise!

I find the most benefit from a live lecture is being able to ask questions.

Thanks! Indeed, the pattern matching in haskell and a few other languages is listed as inspiration for the pep that introduced this feature to python.

Socratica has and excellent series of those: kzfaq.info/get/bejne/mL9moJmQrq-yaWg.html Enjoy!

you may want to start with some basic topics or applied-level topics first.. these are pretty non-essential

If I can pattern match on a type, I can tilt my head a little to the side (because Python's dynamically typed) and see type constructors for sum types. If Python were statically typed, the lack of algebraic types would be a real problem. Go, for instance, would suck so much less if it had sum types: imagine how much less clumsy its error handling alone would be...

Agreed. I would have liked a real life example of where on is better than the other

We can hope! I honestly don't see why not in some specific cases except that Python doesn't usually place much emphasis on changing things for performance reasons. Would love to be proven wrong in 3.11 or 3.12!

I'm not familiar with python ecosystem, but that sounds like syntax highlither/parser hasn't been updated yet. It's provided by Atom or one of its packages/addons for python support, not a part of python installation itself.

Yeah this sounds like an issue that would likely be fixed by updating atom or updating your python plugin for atom. It's possible the plugin doesn't support 3.10 yet, but its been a while since it was released so i would hope 3.10 is supported!

It's even better to match against enum cases

you can avoid re-creating the dict by assigning it as a member of the function directly after writing the function, so it still 'belongs' to the function def switch(x): return switch.dict.get(x, default)() switch.dict = { 0: do_0, 1: do_1, 2: do_2, 3: do_3, } also added a tail call return in case python ever optimises tail calls also now that it's a publicly accessible member of switch it could still be potentially extended by other parts of the code without having to replace the original function or mess with its dunders

You can use _ everywhere already. Really, this just plain old destructuring assignment.

It's up to the compiler to decide if it will use a jump table or not, in both Java and in C. If your cases are compile-time known nearly consecutive integers or enum values, it typically will turn into a jump table.

@@mCoding thanks for replying

In your opinion, should I change any of: talk slower, increase breaks between sentences, or repeat myself more?

@@mCoding If anything, add a small break when going to the next example/paragraph, it will help digest the information. But really, that's what the pause button is for. I find your videos challenging enough that I have to go back more than a few times as the topics are not always easy to grasp. Talking slower probably wouldn't help as you'd need to artificially achieve this, it's best to do what feels natural.

That's because most people are just craftsmen, amateurs who picked up their knowledge through playing around and so their videos are easy and reflect the shallowness of their knowledge. mCoding is obviously a university-educated individual who actually remembers everything he learned, and so has true, properly deep knowledge in CS and math. Therefore, you have to actually think about what he's saying a lot of the time, especially if you're not super familiar with it. There is nothing wrong with this, and nothing to fix. In my opinion, his videos have the best possible balance between rigor and accessibility, given the subject matter. You're just not used to rigor.

@@nollix Not sure "university educated" is all that awesome nowadays nor that it's what makes his content so intense.

@@incremental_failure Don't listen to the foxes about their sour grapes. You basically cannot learn these topics with proper rigor without education unless you're a super self-motivated prodigy.

The proposal lists C#, Elixir, Erlang, F#, Grace, Haskell, Mathematica, OCaml, Ruby, Rust, Scala, Swift, and Thorn as inspirations for the match in Python, so yes!

You can use it as a switch statement if you like, but it's going to be a tad more verbose. This is just trying to make the point that it does much more than that. In my case, it's going to make the code for a whole bunch of finite state machines in my codebase a lot simpler to deal with.

The cst and ast are both objects that help with working with program source code. Without them working with program source code is hard. Think about how hard it would be to find all the places x is assigned to in a string of python code. You could search through the string for 'x=' but then that would find "yx=2" as well, or even " 'x=2' " which is not an assignment but a string expression. If you have the cst or ast you wouldn't run into these problems. Both the cst and ast are tree representations of the source code. They are trees because of the nested nature of source code. Like you can have a number in a function call in an expression in a variable assignment. Ex: x = 3 * f(2) The cst and ast both make it easy to find the assignment to x. All you have to do is look through all the nodes and see if they are an assignment node and if so see if they are an assignment to the variable x. the ast for the above code would look kinda like assignment | expression | multiplication | \ number:3 function call:f | number: 2 The difference between the cst and ast is that the ast just cares about what was written while the cst also cares about how it was written. Things like the extra whitespace in "x= 2" would be ignored by the ast but included in the cst. This is why in the video he needed to use the cst, because what he was looking for was not just any tuple but a tuple written in a way signaling it was likely meant to be something different.

you may want to look at "meta-programming", I am learning too while the readability point is just compling with the zen of Python I guess

If you've ever used a code formatter like black or the one built into your IDE, this is exactly what your code formatter needs to do. You can also use it for refactoring, e.g. rename all instances of the name x in this function to y. Think code that modifies other code!

Great questions! I made a video about the intricacies of the match statement that I think would clear things up for you kzfaq.info/get/bejne/Y82WZ91kzJ2VfZs.html

I don't know python too well, but let's say you have Foo(a=0, b = 0) If you use `if something == Foo(a=7)` it means a = 7 AND b = 0 (default) if you use match for the same thing it means a = 7 and b is free to be whatever it wants

Yes you could, and I even show this in the video!

@@mCoding right but why was your if statement code so much more complicated, couldn't you have simply checked for equality in the same way that the match statement does?

​@@GuyMichaely Thing is that you don't have guarantee that Foo is Equatable or equality is what you describe, also you can't do dynamic matching with your approach. i.e what if you only carry for a = 0 and b could be whatever, smth like Foo(a=0, _). So if we had to implement this using if else, we first have to check that object type is Foo and if so check that a is 0 and if so consider it match. that's why latter code was complicated. while with pattern matching match object_under_question: case Foo(a=0):

You're clearly not the designated refactoring guy at your company!! Anyway yes I agree matching json responses is another big use case, though if you think about json as a serialization of a real class then it's actually quite a similar use case!

I would love to but I don't know rust!

@@mCoding Me either! But I've been making my way through Programming Rust 2nd Edition. Pretty dense but my work keep mentioned rust so I thought I should learn it.

kzfaq.info/get/bejne/ma2mmKyn3N23oWg.html

oh yeah right, bots provide comments in that format. The link I provided links to a video which explains why Python's += operator can act counterintuitively

@@delta3244 Thanks, didn't know about that. Also a quick shoutout to mcoding for not greedily using every opportunity to plug his own content (like this one or the hint saying the last video is not a prerequisite)!

TL/DW: can be either x=x+y or x.operator+=(y) first makes new object, second adjusts old one and you can't know which from the callsite

@skrt You are welcome. I guess it worked out in this case, but I didn't realize plugging my own content was a bad thing though! I would assume if you liked this video you would like my others too!

How would you describe "digital humanities" to a layperson such as myself who has never come across that term before? It sounds quite interesting. Not as a career choice but just out of general curiosity (this is coming from a guy who reads papers on Pubmed [a medical database] because I have random thoughts like "how does capsaicin [the oil in chilies that makes them spicy] work?"). By the way the way capsaicin works is it interacts with a "protein channel" (a big ole hole in nerves that regulates the intake of electrolytes [sodium, potassium, and calcium] by getting wider or narrower) called TRPV1 or "Transient Receptor Potential Vanilloid 1". Capsaicin causes the TRPV1 channel to open up wider, thereby increasing the flow of electrolytes into the nerves which in turn causes the nerves to fire off signals to the brain that makes you experience a warming/burning feeling! ...You didn't really need to know that last part but perhaps it was interesting! By the way I am not a medical expert just a computer nerd with a penchant for eating spicy peppers no matter the amount of water loss in sweating!

I have a whole video explaining. Search for python's sharpest corner!

You are certainly welcome to do that :). Just curious, is the reason because you feel that it expresses the intent clearer? Or some other reason?

@@mCoding yes, to me a switch-case conveys that you have a specific intent, which if-elif-elif-else doesn't immediately do. I usually use them for things such as factories where I might need to create instances differently for different options, or for parsing text-based commands. It's also much more readable to me.

Good point! I suppose the switch dict would only be useful if your inputs are not consecutive ints. I'd love to see the performance comparison!

No, it's there because it was an easy way to implement things back in the '70s and enabled some clever coding, but subsequent to that, it's been nothing but an albatross around the neck of most people using switch statements as you rarely want to pass through, it's a pain to explain to beginners, and a common source of bugs. Every code base that I've had to deal with that uses them ends up with comments like "/* pass through */" all over the place to indicate the pass through was intentional. Sure, that's anecdotal, but I wouldn't be surprised if it's common, and that would be a strong indicator that an explicit "passthrough" keyword would've been a better option than making it the default.

Pycharm

They can, and they did. I don't remember the name of the module that did it before python match case, but they used lists of lists to encode this behavior. It was a total mess to read.

Hahaha of course, use whatever YOU think is clearest. Don't ever let a video tell you otherwise.