Every video you drop is so hugely important. Youre single handedly saving my in-production code from ignorance

Wow. On other channels this video would just have been the display of the syntax and some code examples. But as always, you share valuable knowledge in the form of use cases, benchmarking, 'tricks' to remember the syntax, etc. I yearn to one day be as good of an educator as you. Thanks for the video!

What I love about these videos is that each highlights one specific topic that you rarely see anywhere else, yet all of them have real world applications. Thank you James

That explanation was CLEAN! And the speed test was the icing on the cake! Thank you so much

One use-case I've heard for positional-only args is that it allows you to have a truly-general kwargs parameter. Like, say you had a function that lets you modify some sort of general-purpose configuration settings, and it needs to take two things as input: a section to put the settings in, and some key-value pairs for what settings to change. The definition could look like: def modify_config(section, **changes): ... and you'd then call this like: modify_config("subscriptions", mCoding=True) But what if you wanted to have a setting that is literally called "section"? You can't call: modify_coding("a thing", section="left") because it will treat the "section=" parameter as being the first arg to the function, not a part of the kwargs, and you'll get an error that you're providing two values for the same argument. So our function isn't completely general-purpose, we can't use it to change a setting that's called "section". However, what if we change that parameter to be positional-only? def modify_config(section, /, **changes): ... modify_config("a thing", section="left") Now, the call works properly, exactly as we'd expect it, and the section="left" parameter ends up in the kwargs.

Another engaging and informative video with a pleasantly narrow scope 🤠

When the positional only stuff came out, I also remember hearing that there were some reasons related to the C foreign function interface. Most other languages don’t have kwargs, and this (supposedly) helped maintain symmetry when you were defining wrappers for C functions

I recommend your videos all the time. The depth on a narrow topic is exactly the type of video I've been after lately. You dont just explain what it does and some examples, you show exactly how something works and you somehow do it concisely.

This is the most clear and concise explanation and how-to tutorial on python arguments I have seen. Excellent job. Bravo!

one of the best explanation (about args and kwargs) i've ever heard

Great video. I recently came across your videos and have been gobbling them up and passing them along to my coworkers. Thank you so much for doing this and I really appreciate the nicely digestible length of your videos yum yum.

I learned an additional thing from this, as I didn't know about the {var_name=} feature of f-strings, so thank you for that as well!

You always provide a new (deeper) perspective on seemingly simple concepts. Im glad I found your channel, you have the best content Ive seen on YT.

This has been in python since 3.0 and I never knew what it meant (have not seen it in many codebases with the exception of boto3 stubs) thanks for this!

Thank you so much. I've been wondering about the slash in function parameters for so long

Damn, man these videos are what I wanted, one the edge python cases/implementation or advanced video.

Had never known about this syntax, but I can think of some good usecases allready! Your video's are really the best for learning these obscure but very often usefull features you don't see in beginners courses.

Congrats on the 100k

I always learn something new from your videos, thank you!

I learned something new today. Thanks for making this video!

wow, just started learning about this. You're amazing, James.

Banging video. Learnt something new, seems advanced but simple to understand and use. Love it

Note that int.__pow__ (and maybe other number types) has "mod" parameter especially for cases "(x ** y) % mod"

Amazing video. I've actually never seen this feature used before but I feel like it should be best practice, especially when writing APIs

I learned this from the book “90 Specific Ways to Write Better Python”. It’s such a great book that I would recommend to anyone looking to become a more professional Python developer

Times I refactor my code before finding your channel = once, times I refactor my code after finding your channel = once a day

Such a useful video I wondered how to do this exact case yesterday by chance!!

Star is like star-args but without the args 🤣 mCoding is like m but with Coding 😄 Your content is so advanced, I love it! 👌

Amazing stuff as always my good man

Your channel booted up my python skills x10 🥂

This is EXACTLY what I need today!

Loved the "yum"! Also, James, where is your face? It was so nice to see you narrating the video :) Great work. Really appreciate your efforts.

This was super informative. I understand a little better how to use *args and **kwargs which I know wasn't the point of this video. But still, this was very useful. Thank you!

Very interesting insights Thank you for that video!

5:05 best part! 0:40 jfyi for the completionist foo(2, a=1, c=3) is a TypeError foo() got multiple values for argument 'a'

Awesome video! I like the def foo(*, arg_1, arg_2, arg_3=default_3, ...): pattern to force users to explicitly pass in keyword names. This is useful for methods that have a lot of inputs to a) force users to look up the signature so they see everything that they need to pass and are able to pass in and b) ensure no parameter mix ups occur. This approach also makes code a bit more explicit which can be helpful. Of course it's more verbose which could be seen as a downside. It would be nice to see examples where you include default arguments as well. When I first learned about these I was confused by the fact that there was a difference between keyword only args and optional args (before I erroneously thought they were one and the same). I also think there's a confusing case of: Can I have position-only args with and without defaults while also having keyword-only args with and without defaults? I don't really need to see examples where there are explicitly positional or keyword args because I feel like those cases are just confusing, and like you helpfully pointed out, not really useful. I do have to say that I've hesitated to put these patterns in much of my code though, because I believe it's python 3.9+ and at the time I learned it I was still working with lower versions of python. I also hesitate to put it in because I think most people don't know what it means and it would surprise them.

Wonderful! Great as always

So good. Never heard about it the pure * before and directly implemented it in my code

great explanation! thanks!!

My takeaway: star yum star star yum yum slash NO NAME FOR YOU Great vid !

I never knew about plain *, it makes total sense.

Oh that looks great! I have to use it in the library I'm writing

I worked with a (proprietary) PHP framework which had an approach of making as few args as possible mandatory, and as many parameters of an operation args with sensible defaults. The "keyword arguments" was the way it was implemented - you'd often have a function with 15 args, one required, the rest - as needed. It was very friendly in use that way - bare minimum to get it to work, easy to change whatever you want changed.

I somehow have never see this syntax. I've seen mentions of this while manipulating python ASTs but I didn't know what they really meant lol

superb explanation

Very helpful !😀

This is GOLD!

Great and interesting video

Great videos! ✌ Could you do an in-depth video on asyncio? By in-depth I mean how it works under the hood; Particularly how it compares to & differs from multithreading, how does python know when to "wait for this to finish and run some other code in the meantime" and what happens under the hood when the results are ready and how it relates to OS scheduling and sleep queue. So basically, content that you find on this channel that it's harder to find elsewhere.

The benchmark at the end was the icing on the cake. Is there a performance change? Not enough to bother, but at least we know that

Great content once more!

Awesome! Props to you.

Amazing!

thanks for the video

OMG, I had to have a “dummy” parameter as the first argument because I couldn’t find a simple way to force all parameters to be named. Never found this syntax of just star-comma offered as a solution. It’s quite logical to remember that it’s like “*args” without the argument name. As if it just doesn’t give anywhere for the positional args to go.

4:00 this is also why most projects should probably use mypy and type annotations :)

I love your videos ❤️

Thanks James, great video. In what python version of python was this added?

I've defined keyword-only parameters before, but I honestly had no idea positional-only existed. Doubt I'll find much use for it, but good to know.

This I find helpful when there're a lot of boolean args, which if passed without keywords, would make its invocation harder to understand -- e.g. `process_two_numbers(3, 5, True, True, False, None, True)` -- no idea what's happening here without forced kwargs :)

U can memorize /* which start multiline comment in if I remember correct. You are welcome! : )

Until now I haven't used this feature a lot because I don't want to put restrictions on the users of my code. However, I make most boolean arguments keyword-only, because when passed as a literal it's usually not clear from reading the code what the argument is supposed to mean.

Is power mod slow because you could also implement binary exponentiation together with taking the mod on the output on each iteration?

I love it. I want to feed the YT algorithm so I make this comment.

Never seen this before. So cool. I wonder why positional only is faster than keyword. Thought it would be backwards

The best part of this is f"{x=}" I didnt know you could do that

thanks for the good content

great vid as always btw discord gang 🤙🤙

How did you run into all this information? I consider myself to be a reasonably experienced Python dev and I swear, 75% of your videos I come away learning something that I can actually use in my day-to-day work in a way that makes my output unquestionably better. What can I do to rapidly pick up info like this?

Yeah boi!

"We don't need x." I feel attacked lmao Jokes aside, this has been an awesome watch with some immediate gains in my codebases 🥰

4:58. If you want to swallow up keyword args you can just use **kwargs. This isn't exactly a parallel to / but is the equivalent kwargs version of *args

I’ve actually used this before without really knowing what it was doing while making a discord bot

7:22 Your note about slow function, what would be faster equivalent?

I always wanted to know whataheck that * meant on the others code... dam.. thank you.. that was greatly useful!

I think I finally remember the syntax... the / * is really hard to remember

My usual examples for why you would want keyword/positional-only arguments are: Keyword Only: consider n_sorted(data, true) -- what does the 'true' set there? ascending/descending? nulls first/last? Maybe something else? What if you would find n_sorted(data, false, true) -- which true and false is which? is the first false only there to keep the second argument as default to reach the third positional argument? n_sorted(data, nulls_last=True) is unambiguous about that. Positional only: Reason to enforce positional order could be if the ability to change the order would only exist to mess with the person reading the code. Similar to your example, divide(y=2, x=3) or Fraction(denominator=2, numerator=3) would seem to be only there to obfuscate that this is 3/2 and not 2/3

7:43 I actually recently used that in my project lol

Saw this some weeks ago in a colleagues Code.

I've always wondered what **kwargs means but never bothered to look up. Thanks!

This is not related to the video but since there are probably many python expert here I'll ask my question. Can I have some tips/good practices about how to create and organize a python package. Also what should be favored, relative or absolute imports? I prefer absolute because theye are easy to copy paste between files.

Pretty interesting

I never knew about the '/' and '*' in the function parameter list - they are awesome. Also, I realised that I can cheat the "slap the like button an odd number of times" system by hitting it twice, but also clicking dislike once in between. Under the cost of the emotional baring of having your video disliked for a moment this still results in a like ;)

you love to see it

You should be able to put the star next to the slash if you don't need the middle

How does this work w partial application?

4:35 Buying 10,000 items of $4,500 each, costs as much as buying 4,500 items of $10,000 each. Unless you're the seller :)

I have rhe impression you are probably resonably decent at writing python code :-)

What is the "good practice" way of implementing keyword arguments with default values?

I now very much want to know how to make a Python3-Thinter-to-HTML5 app far as it can get... because I very much struggle many thousands of times more with every other programming language despite the 6 years I tried. Granted... p5js has recently got my attention, but... it still looks a bit overly complicated to re-edit which I accomplished very much the same graphics which is too slow and doesn't transfer to Android via fully* the SD card. Unfortunately... I can't even find an entire side-by-side syntax comparison.

`mCoding` seems like A/M`tion; similar to `Playwright`.

yum

6:24 How about “truthvalue” or “flag”. Or even “colbert”.

This isn't really important but.. 10,000x4500 and 4500x10,000 are the same since multiplication is commutative. Awesome video as always though!

Wouldn’t it make sense from an enterprise standpoint that all arguments are passed as keywords? Otherwise the reader has to reference the functions implementation or comments if it has them to understand what the parameters mean.

Il y a grep sur Windows?

damn I envy people who can work with python. I work on an ancient mutated php codebase. I recently found some functions with a messy signsture and a bunch of option paramters. That kind of stuff is just bad code in php. In python that might work If I used the method to force those arguments to be keyword only. (in other places the codebase expects (what php calls) an "array" with keyword=>value pairs wich basically simulates keyword only args. fun times.

Being a dart developer where the convention is to use keyword arguments over positional ones, I wish more languages used that convention too! Makes reading others code a LOT easier when you don't have to learn the order of arguments in a function. Dart has extra features to make keyword args easier to use too (such as automatically filling backed fields) but definitely a feature you should use in other languages too!!

Discord gang