5 Uncommon Python Features I Love
2024 ж. 13 Мам.
117 492 Рет қаралды
Here are 5 great & uncommon Python features that you can use in your Python projects.
▶ Become job-ready with Python:
www.indently.io
▶ Follow me on Instagram:
/ indentlyreels
Here are 5 great & uncommon Python features that you can use in your Python projects.
▶ Become job-ready with Python:
www.indently.io
▶ Follow me on Instagram:
/ indentlyreels
The "pipeline" on sets is not a pipeline, but the OR operator (returning a set containing all elements which are in either A or B).
Isnt the character called "pipe"? Or am i wrong?
It's called pipe but is seen as OR in programming languages like how ^ is exponent but is seen as XOR
It’s actually the set-union operator in this context. It is spelled the same as the bitwise-or operator, but it’s not the same thing because it applies to the set type, not a binary number.
@@meowsqueak it actually can be considered as logical operator, because sets are mathematically identical to predicates which forms these sets. So a set operation on sets is actually a logical operation on their predicates.
@@christophertaylor5003I was trying to say that the set-union operator (or logical OR operator if you like) is not the same as the *bitwise* OR operator, which is usually spelled "|" ("pipeline", "pipe").
the custom __format__ can be useful when you have sort of vector class and want to print its value with standard spec. like with f"{vec:.1f}" you get "(1.5, 3.0, 4.7)" and with f"{vec:.2f}" you get "(1.50, 3.01, 4.68)"
Ohh this makes sense
00:13 Using slice object 02:03 Set operators 03:51 Custom object string format 07:52 Walrus operator := 11:51 Currying
I've seen dozens of "python tips" videos like this and learned almost nothing. They went from giving tips everybody knows to outright horrendously bad code. This one is the first where I actually learned something (that you can pass functions as first class objects) and every tip was actually relatively unknown, but still useful and presented in well written code. Compliment!
I would use partial for simple currying, but function returning functions for more complex or customised currying.
4:49 Please be warned that "match" was only introduced in Python 3.10 which is relatively recent On another note, I personally use this for only one purpose, which is to allow debug prints, it looks like this: print(f"{my_class:d1}") d1 is basically "debug-1" which essentially means "print this object with little information". The implementation looks something like this: class Example: def __init__(self, field1: str, field2: str, field3: str, field4: str) -> None: self.field1: str = field1 self.field2: str = field2 self.field3: str = field3 self.field4: str = field4 def __format__(self, __format_spec: str) -> str: if __format_spec.startswith("d"): level = int(__format_spec[1:]) fields = ["field1"] if level > 1: fields.append("field2") if level > 2: fields.append("field3") if level > 3: fields.append("field4") fields_dict = { field_name: self.__dict__[field_name] for field_name in fields } return f"{self.__class__.__name__} {fields_dict}" The actual implementation I use is a bit different, to give better error messages, and to override __str__ to use this (so you can do print(example) directly) but you get the idea...
Neat idea!
im just self-taught with python making programs for the last 4 years, but you just showed me (and i had no idea), that you could do self.__dict__ to get the defined variables from the __init__ of a class.... or the self.__class__.__name__... im assuming there must be one for getting the functions names of a class as well
@@resresres1 __dict__ gives you all fields of any object, and Python classes are also objects (I'm not talking about the instances of a class, but the class itself) If you use __dict__ on an *instance*, you get its fields, if you use it on the *class*, you get all static data, meaning methods, but also class constants. Python makes no distinction between functions and variables, they're all entries in the dictionary of the class, you can even define your own function as if it was a variable (obviously don't do that, it's unreadable and your IDE will probably loose its marbles). So this: class Example: EXAMPLE_CONST = "CONST VALUE" function_as_var = lambda self: self.some_func() def __init__(self) -> None: self.some_var = "value" def some_func(self): print("I've been called!") def print_self_dict(self): print(f"Static dict {self.__class__.__dict__} ") # Same as Example.__dict__ print(f"Object dict {self.__dict__}") # Same as Example().__dict__, assuming same instance example = Example() example.print_self_dict() example.function_as_var() prints out this: Static dict { '__module__': '__main__', '__doc__': "I'm a doc string and Python recognizes me at runtime!", 'EXAMPLE_CONST': 'CONST VALUE', '__init__': , 'some_func': , 'print_self_dict': , '__dict__': , '__weakref__': } Object dict {'some_var': 'value'} I've been called!
specifically for debugging mode, a dunder method ___repr___ was provided, which is called in f-strings as follows: f"{object!r}"
This is your best video yet IMHO. I didn't know 100% of any of the topics you covered, and while I knew about all of the set operations, I'd no idea you could do the same thing with operators... very cool. Great job! Keep it up!
The final example, the return type should be Callable[[float],float], to be more specific. I'm not sure if the ide will infer the contents of [...] there, but if it doesn't then you either should specify that, or not specify a return type.
I went for that approach originally, but it wasn't ideal for the explanation in the tutorial, and since this video wasn't about type annotations, I excluded that bit. Please continue with annotating your types appropriately regardless of what I show in the video :)
@@Indentlythought I should point it out as no one else did.
While your full annotation is indeed more specific, just specifying Callable will still be better than not annotating at all. Your type checker will validate against whatever annotation you provide, to whatever level of specificity.
@@keoghanwhimsically2268 Most if not all static type checker can infer the typing from the return statement. The return type annotation is mostly only useful for self documenting code and to enforce a return type. So Callable by itself is too vague (in my opinion) to do either of the job, thus allowing the inference to take over is more desirable (at least for me) than only partially typing a callable. In the example the return type is just Callable, this'll mean the type checker will allow you to give any number of arguments and any type of argument to the returned function, which can cause a runtime error. If the return type wasn't annotated then the type checker will accurately infer the type from the return statement, thus it'll appropriately throw error and a runtime error could be avoided. Inference also works at assignment and if you have a default value for an argument you can allow the argument's type to be inferred. I personally use inferred typing for assignment and return types,but for production code, I'll recomend typing everything, so that the code can be understood at first glance. Hope this helps.
@@keoghanwhimsically2268 Most if not all type checker have a system called inference. This allows you to not specify type for something and still have it typed. In case of return types the compiler can look at the return statement check the type of variable/variables being returned and infer the return type of the function to be the type/union of the types of the variable/variables being returned, as long as the return type of the function is not specified. If the return type of a function is specified, the type checker checks the type of the returned variable against the return type. Now in my opinion type checking is done for two purpose, documentation and type checking. In the given example the type Callable is too vague, to work for either documentation or type checking. So if the return type wasn't annotated, the type checker could infer the type properly thus potentially avoiding a runtime error. You can have inference take over at, variable assignment/initialisation, argument with default value and return type of a function. I most often use inference at assignment and return types in my personal projects, but for a group project or an oficial project annotating everything is desirable as it allows others to understand the code at a glance. Hope this makes sense and is useful, if you have other query please ask away.
Great video! Btw love HAIRY Potter 😂
HARRY ❌ HAIRY ✅...🗿🗿🗿
Hairy Potter and the Barber of Azkaban
By the way, Snape's name in the Italian translation is Piton, so seeing "Daily Python" just below was additionally funny for me.
1. when doing a[], you can extract as a variable of type "slice". for example a[slice(None,None,1)] is the same as a[::-1] 2. bit operations & | work with sets too 3. f-strings can be formated, __format__ can be implemented on types 4. You can use the walrus operator (a:=b) for its intended purpose, which is using it in if statements 4. curry is possible in python
Great video! The slice trick will be helpful, and I didn't know about that use of the walrus operator you showed inside the dictionary. The walrus operator can also be handy inside of comprehensions if you need to compute something with each element in an iterable, and you want to keep the computational results rather than the original items.
I've been using Python for almost 5 years now and im still learning something new everyday from your channel! I love your explanation style ❤
Same here!
Python ist very complex, more so than Rust apparently
I'm a python developer since about 2012, and EVERYTHING here was new and useful to me!
@@climatechangedoesntbargain9140 you must be out of your mind
This was amazingly well explained and useful! Thank you!
Great explanation of the walrus operator. I've struggled to understand it for a while, but I think I've got a good grasp now! Very useful trick.
Set operations also work with inplace operators like |= and -=. In newer Python versions "|" also works with dicts. Walrus operator is great for regex matching i.e. "if match := re.match(...)". Currying is super useful for giving parameters to decorators. Also Callable should be used with parameters to give a more accurate type.
As well as | for dicts you can also use the other set operations on dict.keys(). This can be very useful if you want to iterate over part of a dict: for k in record.keys() - {'password'}: print(f"{k}: {record[k]}") but you do have to be careful that while dict.keys() is ordered sets aren't so don't do this if the order matters.
Who on earth came up with the term "walrus operator" for := ? I can't see any connection to a walrus.
@@__christopher__ I think the idea is if you turn your head on its side you get a face with two eyes ':' and a walrus moustache '='. Maybe.
Thanks to bring them up. 💯
Thanks for the video. I do think the jump cuts where the code changes between the cuts (to fix a bug, for example) makes it harder for beginners to follow along. It would be better to fix the errors in the video, IMO.
Thanks for sharing, the set portion is very valuable.
Nice video! Loved the little tips and tricks. At least for set operations though, I guess I will keep using the dot method because when I will open the code after a week, I would have probably forgotten what those meant and find myself in a mess. 😅
The dot operators are just as good, but think of it like this: a & b = the elements that are in a AND are in b (intersectoin) a | b = the elements that are in a OR are in b (union) You can even use - to get the set difference: a - b = the elements in a that are not in b (difference) Symmetric difference is easy, too: (a - b) } (b - a) = the elements that are in a but not b, and the elements of b that are not in a. Seems strange that + cannot be used for unions of sets, though.
7:34 if, instead of `Any` you could set `format_spec` to be an enum, an array, or a union type, `__format__` would be more useful, and would not require documentation. At least for the IDE, if not the runtime, it would autocomplete. I don't know python enough. Maybe this is already possible, but as you didn't mention this option, I assume it can't.
You can also use Literal["time", "caps"]
So I can understand better, do you mind providing a quick example of what you mean by that? What I was trying to say in the video is that it's nearly impossible to use any of these format specifiers without reading documentation, or even taking a glance at the code of the class first. With a lot of classes, you can intuitively use its methods and functionality without having to open up the class, but with format specifiers, I have no idea how you would guess which ones you could use with such a random object as Book() from the start.
@@Indently I was hoping that something like that would trigger the IDE's autocomplete (in `print(f'{hairy_potter:`), but I was probably expecting too much :) ``` from typing import Literal, Type BookFormatSpec: Type[str] = Literal['time', 'caps'] class Book: def __init__(self, title: str, pages: int): self.title = title self.pages = pages def __format__(self, format_spec: BookFormatSpec) -> str: if format_spec == 'time': return f'{self.title} will take {self.pages//60} hours to read' elif format_spec == 'caps': return self.title.upper() else: raise ValueError(f'Unknown format {format_spec}') def main(): hairy_potter = Book('Very Hairy Potter', 300) python_daily = Book('Python Daily', 20) print(f'{hairy_potter: if __name__ == "__main__": main() ```
Now I get what you mean, it would be super cool to get that kind of context completion, I agree!
Editors such as vscode usually pop up the docstring when you're typing a function call. They could easily display the docstring for the object's __format__ function (assuming the type is known) but so far as I can see vscode doesn't bother doing that. I haven't checked PyCharm. If you use Literal for the type of the format string vscode will offer completion on the format but it also offers all other names in the program. so not a big help unless you start all the format strings with 'z' or some unique prefix. The problem with literal is it does have to be literal, you can't do formats with embedded numbers that way.
This is a totally fine "python features I love" video, but i have one recommendation for the young folks out there. Try not to use the build in set operators as recommend in the video. Stay with the methods which are way more explicit in what they are doing compared to the single characters of the build in operators. They can hide some nasty bugs when not 100% tested.
Using single operators seems more pythonic to me. Calling the methods reminds me the Java way. It's more explicit for someone that doesn't know Python as much, I think it's more verbose. Correct me if I'm wrong, please. It's just an opinion.
Good tips! I used currying to create a text-based prefix notation calculator interface where the parser didn’t need to worry or know about function arity because all functions have an arity of one.
Some very neat tricks, also very useful, thanks Indently for your continued efforts to improve the world of python.
Oh yeah, I'mve use walrus operators so many times, especially for validating user input in a while loop. It's so much easier than having to set a default value.
I've been using the set operators for ages, but I've only just discovered f-strings and match. I still need to learn more about match.
Whenever programming in numpy (or it's children) the combination of slice objects and boolean index masks are so powerful. You can make the hardest part of convolutional neural networks (from scratch) as legible as a standard loop and multiply pattern.
You r the best.... python teacher...! love from bangladesh.
I did not know about slice(), nice one! Also, I somehow missed that type hints are now in Python (since 3.5, see PEP 484).
Oh! This is the first time I know about custom format specifiers! I'd love to use them in my personal projects too! Would be nice to be able to quickly get some commonly used value from a class without going through the whole hierarchical tree of objects...
Thanks. Very interesting.
What about using literal type hint with the format dunder method?
Hey could you do a series on try exceptions? I still don't full get it the different errors or exceptions. Thanks
Is the walrus variable scoped to the then&else branches? Or does it still exist once the if is done, ie. past line 6? If it's scoped then that's a massive point in favour in my book :-) Thanks for the clear and to the point video!
I thought scoping was the main feature of the walrus operator. Turns out I was wrong - there is no scoping
Very cool, thanks! I don't think all of them are particularly readable, but it's probably partly due to that I'm not accustomed to them. I'll definitely want to learn and adopt some of the operators from here (especially from #2 and #4) 😉
informative video as always.
I use the walrus operator quite often. I think python has made a good effort to minimize the risk of having accidental assignment instead of comparison in boolean evaluations like you'd have in c-like languages.
What font is used in this video?
Regarding set ops: if you can be explicit: rather use the member functions!! They also work with other iterable types!
Thanks for video.
All of this tips are awesome. I think Jetbrains IDEs should support format string completions
The literal type helps with custom format operations.
Walrus operator is so cool!!!
7:29 Could add this to the class: (a)property def specifiers() -> set[str]: return {'caps', 'time'}
what IDE do you use? I cant recognize it.. (stuck to VSCode for years, but yours look really clean!)
It's pycharm....basically designed for python
@@resresres1thanks, i didnt noticed because it is not the default theme
@@agent_artifical JetBrains recently updated the UI.
There is a slightly cleaner way of building slice objects. The issue is that the slice function doesn't use slice notation. I much prefer using a 'slicebuilder' object, constructed such that you would get the same as slice(None, None, -1) by writing slicebuilder[::-1]. It really isn't hard to do, it is just an object that has __getitem__(self, key) returning the key. This lets you build slices using standard slice notation.
I really wish there was a built-in python methods to do these conversions. slice[x:y:z]? slice.from_str(''x:y:z")?
I learn fastapi and i find out that i use currying, when set up post, delete methods. This 2 operations require identifier to find item. So i put find_by_id function inside those metods and then define next steps. Some sort of state managment
The walrus operator is useful for me for like error checking, when i only need the value if i go in the branch and i dont want to use a line for it. One big downside is that it has a very low precedence, meaning "if user := users.get(3) is None" would actually mean the value of user would be the result of the "users.get(3) is None", so it's always good to use parentheses. Another thing that came to my mind from this video is sometimes (especially for newer features) it might be useful to include the minimum python version it requires. All your examples are supported in 3.8 so it's not relevant here, but I noticed you also use the type union (at 8:30) which is only supported in 3.10 I had a funny issue with that because in an environment i run my codes actually run on 3.8 and the file was failing silently only showing that my code did not exist and took hours to figure it out.
You're right, I should start mentioning what versions features are supported in. Now that the channel has grown, and I'm not a little boy anymore, I have a duty to provide more information in my videos (or at least mention when a feature is relatively new) :)
gotta thank the walrus operator for saving me on my exam, such a great feature
I have yet to find a use case for reversing a string, beside academics
On the topic of custom format specifiers, I think theres an argument to be made about providing an interface for truly unique ones, but implementing standard ones also has its benefits. For instance, maybe you want to adhere to printf format specifiers, so %d is for the 32-bit signed integer representation of your object. Meanwhile, I know that C# has some short format specifiers, such as DateTime having an "s" for "sortable" string formats. Personally, this is kind of nice, because I have had the situation where __repr__ and __str__ weren't enough for the different formats I wanted to provide, but I wasnt aware of any alternatives. For those hearing about these for the first time, __str__ is generally the "pretty" version of your data, while __repr__ is the stringified version of how an outside would represent your object, often using the __init__ signature, but an argument can be made for alternatives. Also, there's a failover that can happen (I believe from __str__ down to __repr__) but, as previously mentioned, they are supposed to be used for two different reasons
First four are a great display of python features, the last one tho, it's not really a python feature as it is a functional design pattern present in any language with higher order functions. I still feel like it's kind of awkward in Python and is much more intuitive in Scala. But partial helps a bunch with that. I kinda feel bad using Callable as a return type. It's a shame that arrow can't be used to declare a function type like def func(a: flaot) -> float -> float. It's not perfect but i feel like it gives more info of what's actually geting returned
In haskell you write function normally and get curried function by default.
7:49 Enums? Would that work with that syntax?
Got a score of 3 out of 5 (if you include partials as currying) 😎 I'm struggling to see why you wouldn't just use partials, though it's funny to see that partials and decorators are technically created in the same way lmao.
I'm curious about the font of the thumbnail. Can anyone tell me?
4:50 could the raise Value Error be replaced with raise NotImplementedError?
You could, but I think ValueError is better because the feature is indeed implemented, but an unrecognized value was used
Useful video
i'm too new to python to comment on whether this is a good style of coding, with my little experience, mainly with ttk tkinter, i find it somewhat lacking in the manner by which data is passed, probably because i am so knew, i was able to construct the proper functionality regardless, through trial and error, but i think what you are talkning about could make a difference in how i code using lists, i tried something like what you describe in this video to connect a str to a list of ints in order to display the results from a buttonpress, but i obviously didn't it get the results i wanted and ended up going with a simple if statement, i would like to be able to use a single variable to set to conditions then reset to do it again, so i think i can use your dictionary concept to do that, i subscribed, so somewhere in the future if i am successful at it, i will let you know, anyway, great video
Walrus operator in Python is a default behavior of assignments in Perl.
One thing I noticed when playing with this format function is that it will implicitly cast anything to string, if you have f"{foo:1}" you will have "1" in the foo's format class. Also you can't use variable or funtions here, their names will simply be given over as strings. Also Python will raise a TypeError Error if you try to return anything other than a string in __format__. Next you can use the walrus operator even in list comprahention: import string from itertools import product lower=string.ascii_lowercase upper=string.ascii_uppercase print([(i, U, l) if U.lower()
You can use variables or call functions inside the format string, but you have to enclose them in curly braces: print(f"{foo:strange {bar} format}") subtitutes the stringified value of 'bar' in the format string before calling foo.__format__.
These kinds of videos makes me relize how much I don't know about python
Code is exprssion language. You really good express common language
Hey Indently. Just so you know, there is a lot of noise in the sound on the low-end, especially popping out of my sub when you type on your keyboard. Could be a good idea to dampen the frequencies you record that are outside the range of your enjoyable voice. Much respect. Peace.
I like Python's slice syntax, and it's good that I've seen this video to know that I can save a slice format because this is yet another feature I think my own language was missing. I finally upgraded my local copy of Python to 3.9 last year, and apparently the "walrus" operator and the match statement were added in 3.10, which is kind of annoying. Oh well, just need to checkout a later version, and I'm aiming for v3.11.0 and ask me in a couple of hours if it works, because yes I am that paranoid to run `make test`. One thing I keep wondering though, why doesn't Python implement operator+ for most things. For sets it makes sense to have operator| instead, but it wouldn't hurt to make operator+ be an alias or even do something weird like collapse a set into an array. I implemented + and += for all of the container classes in my standard library, both for single elements and other containers. It makes no sense to me why people keep pushing back on that.
I didn't understand how the multiply-setup() works. We provide only parameter "a", but where does the parameter "b" come from in multiply()?
The b parameter is coming from the enclosed def multiply(b). The multiply_setup(a) returns that multiply(b) function, so when the result is called, that becomes the b parameter.
`multiply_setup` returns a function which accepts one parameter, which is `b`. So `double = multiply_setup(2)` is setting `double` to a function, and calling `double(3)` will call the function with `b = 3`.
Thanks, I almost broke my brain figuring this out🎉 Not sure if it is really worth, maybe I just need a a better use case. My problem was that I watched at the callable, but completely omitted the double and 'triple' examples. After that it went smooth❤
Basically multiply-setup() is being used to create some functions with similar, uh, functionality. So when you call multiply-setup(2) it's going to return a function that will multiply anything by 2. In this case, it's called double() If I was asked to do this I'd use lambdas, because I use lambdas a lot in my python code, but that's just me.
@@chemicals8582i use lambdas a lot in other languages, but the python syntax is kinda clunky imo, "lambda x: x * x" is more clunky than "(x) => x * x" or "|x| x * x"
the := operator is so foreign for python. I would want to have (as) keyword: if (dict.get(something) as something): we use something here
18:30 you dont need to import "Callable", the type "callable" already is in the defaults
Callable != callable
Counting the total characters should be done with something like sum(map(len, words)) instead of len(''.join(words)). That way you dont build the entire string in memory, but just count the individual words
In the currying example, why wouldn't you just use lambda? Something like: def multiplier(a: float) -> Callable[[float], float]: return lambda x: x * a double = multiplier(2) triple = multiplier(3)
Because that's an unrealistically easy example that I only used to teach the concept of currying, if it gets more complicated your lambda may be impossible to read.
Your python code looks like Rust and I love it
Python seemingly never runs out of syntactic sugar to discover.
Python is all sugar syntax, if you wanna be a real man, learn C.
Important: when using dict.get, remember to check against is None, rather than an implicit truth check. Empty strings are considered falsy, which may lead to unexpected behaviour. These are 2 extra words that will help you not write bugs
For the format spec, why not just do if format_spec == '': elif format_spec == '': (... and so on) also I dont think it should be Any for format_spec, it should be format_spec: str. I tried this and it results in a TypeError: class something: pass def __format__(self, format_spec): if format_spec == 's': return 'Spec1' elif format_spec == 99: return 'Spec2' x = something() y = 99 print(f'{x:s}') print(f'{x:{y}}')
What is that syntax set_a:
What's the IDE he is using here ?
The walrus operator irks me a little. In a handful of simple ifs (and possibly in list comprehensions) its probably fine, but using it pretty much anywhere else I'd argue is a code smell.
14:05 OMG, what was that?! 😮 What‘s the shortcut? Please
The concept of "Callable" is kind of a joke for JavaScript where you live surrounded by functions that return functions than take function as parameters
My first thought when I saw that was "oh, so a factory function"
What’s the difference between | and union?
Nothing, it’s just syntactic sugar.
Valrus operator: saves one line, by ruining the readability of another
that's actually not true, in golang it's a very common operator, and for someone with experience in go, i'm glad that we can also do that in python. With experience this can help a developer or a team of developers to have a better knowledge of what variables are being used by the code and where, and if this is just used on that piece of code, this is probably the best way to use this variable, since the variable will be deleted after the use.
Zig also has something like this, and it is a language that prioritizes readability over writing code if (something) |variable| { }
It can actually improve readability in cases like simultaneously assigning a variable and evaluating its boolean value for a conditional. Especially if that variable is only used inside the *if* block
That being said, I think the example used in this video is not the best use case. I still prefer to use a separate line in that case
huh, ok, so in the set_b - set_a example, why was the order of elements changed? I would have expected the results to be {6, 7, 8} not {8, 6, 7}. Also, that's not an "up arrow", that's a caret.
I am no Python guru, but I recall that set is as a whole an unordered collection, so it doesn't really matter whether its elements are ordered or not.
Hey Mr.Indently (sry I don't know your name) Do we need to declare datatypes to make the code run faster...? I think it makes even more slower ...plz clarify this
It's neither faster nor slower. Type declarations are merely automatically checked documentation comments.
@@vytah then why declaring it on the first place
@@k.kaiserahmed8013because they can be automatically checked. Also, they're documentation.
It's slower because the parser has more work to do@@vytah
@@climatechangedoesntbargain9140 The difference is negligible and only exist at load time. After loading, the speed of the code is identical.
Interesting videos but you have some issues with terminology... ^ is called 'caret' not up-arrow. A | B is 'set union' which you don't mention.
It's my teachings style, I try not to confuse beginners with too much terminology. What you said is accurate, but it's not appropriate for this video. I accept that I will get roasted by more experienced / pedantic devs for this. Thank you for trying to help though!
@@IndentlyNo worries, good of you to reply, it's ok to use vernacular but please also teach the correct term afterwards, as you did with "symmetric difference" for example.
I'll work on improving that!
Can you say IDE name pls?
That's PyCharm with the New UI
thx!👍@@BrunoGarciaB
And threaded multithreads
Now they are common.
📝 Summary of Key Points: 📌 The first trick shared in the video is about creating slice objects in Python to avoid repetitive code when slicing iterables. By using slice objects, you can easily modify the slicing implementation in one place. 🧐 The second trick involves using set operators in Python to perform set operations like combining sets, subtracting elements, finding intersections, and getting unique elements efficiently. 🚀 The third trick demonstrates how to make a class compatible with F-strings by defining custom format specifiers using the __format__ method. This allows for specialized formatting of class attributes in F-strings. 💡 Additional Insights and Observations: 💬 One memorable concept introduced is the use of the walrus operator in Python to streamline code and assign values within conditional statements efficiently. 📊 The video showcases practical examples of currying functions in Python, which can simplify repetitive function calls with predefined setups. 📣 Concluding Remarks: The video covers five uncommon Python tricks and features, including creating slice objects, utilizing set operators, customizing F-string specifiers, leveraging the walrus operator, and implementing currying functions. These tricks offer practical ways to enhance code efficiency and readability in Python programming. Generated using TalkBud
someone give this man code lenses.
The second parameter of slice _is not_ the index! It's _how many_ elements long the slice should be. You'll notice that in the list, "index 5" would actually be 6, since indices in Python start at 0 😉 Off-by-one, anybody?
If I said that I misspoke, thank you for pointing it out for anyone who got confused by that. I tried my best to specify that you can use a slice object the same way you use slice notation, so regardless of what I said, it should be fine if people follow that principle 😎
I would have loved to see curry used in a way that couldn't be substituted w/ power()
For anyone that hasn't programmed in a functionnal language at its core, this is not currying. It achieves the same goal, but it's almost as inneficient as passing the parameter by hand.
the set one is not really an uncommon python feature, that's just operator overloading for sets
caution : converation can't receive space
Last example is little bit weird, it seems to be better using two arguments, instead of writing this code 🤓
This reminds me a lot when I was a student, when I tough all those languages tricks would help me in my professional life. Who the f uses this notations at work? Seriously python implement some useless stuff when they still need to do some basic sh*t. When will we be able to use exhaustive match on enum with only ONE member and mypy not bugin? When will we have type (hint) inference inside lambda ?
Another way to make your code unreadable is to program in assembler. Exotic language features are a good way to obfuscate your code if that is the goal.
Before you make your examples, read the Zen of Python.
Third trick, better create methods to do those things
Silly billy
This is way too advanced for me
2:33 not in 3.8!!
bismillah, great video my brother, thank you