5 Really Cool Python Functions
Вставка
- Опубліковано 16 чер 2024
- In this video we are going to be learning about 5 really cool Python functions that I've loved using throughout the years.
▶ Become job-ready with Python:
www.indently.io
▶ Follow me on Instagram:
/ indentlyreels
00:00 Learning Python made simple
00:05 Intro
00:22 exec()
03:17 partial()
08:43 2 functions*
13:32 3 functions*
16:35 askopenfilename()
19:35 Summing it up
Hello everyone, I made an error with the type declarations for the permutations section. I forgot to run Mypy there and when I did it, I got a bunch of errors. Sorry about the inconvenience of that section, I will run Mypy next time to ensure I'm using the correct types (and not just use the code editor's hover feature which is a bit wonky).
ALSO, as some of you have mentioned, I apologise about my poor example with "exec()". I thought I made it clear that you should never execute code or files that you do not trust, but then I proceeded to talk about examples about downloading files from the internet (which you really shouldn't do). I'm a one man team and I make mistakes as well sometimes. So I'm always grateful when you guys point things out :)
The error indicates that the code attempted to index or key on an object that does not support subscription operations, for example operations like indexing or slicing. You try to access permutations at index str, which does not make sense. The error occurs because permutations from the itertools module is not a generic type that can be subscripted with int or any other type. When you write permutations[int], it is interpreted as trying to subscript the permutations class.
As for why it works inside the function, my hypothesis is: the type hint is part of a local variable annotation, which does not affect the actual execution. Python does not try to evaluate the type hint in a way that would cause an error. This is why you don't see an error when the type hint permutations[int] is used inside the function. Even though you use permutations[int] here, Python essentially ignores the type hint at runtime. Type hints are mostly used for static type checking and do not affect the execution of the code. Python's runtime type evaluation kicks in and tries to interpret permutations[int] as a valid type, which it is not, hence raising a TypeError saying "'type' object is not subscriptable". This is because, unlike inside a function, the interpreter processes annotations immediately when they are at the top level of a script or module.
I'm very familiar with what the error means, my shock came from the fact that I copied and pasted my code and it didn't work literally from one screen to the next xD
@@IndentlyI can feel that. That would scare the hell out of me if that happened to me. It seems like PyCharm indications are not always good, because of Python weird features.
@@markusklyver6277For you, my friend, I have to tell you that you are absolutely right. For some strange reason, Python tries to evaluate type annotations when they are in global scope. When the type annotations are inside a function, they just go directly into the ___annotations___ attribute and nothing else happens. A bit of a bizarre feature if you ask me xD
@@markusklyver6277My bad, I correct myself. The type annotations inside a function just dissapear xD (see by yourself if you want, they just disappear).
"exec is really cool because you can download text from the Internet and execute it" - My IT sec brain initiating a heart attack
AAAAAAAAAAAAAAAAAAAAA
congrats you speedrunned life at:
241,056 hours
Mathematician here, I'd just like to mention that permutations and combinations are not interchangeable terms. For permutations, order matters and for combinations, order does not.
Bruh acting like a mathematician because he knows a fun fact from middle School pre algebra
@@josephbrandenburg4373 calm down joseph
@@josephbrandenburg4373 bruh acting like he knows the person by reading one comment made by them
Your warnings about the misuse of exec were just not strong enough, in my view. Exec'ing user input? ABSOLUTELY NOT. Never do that, folks. The legitimate uses of exec that cannot be implemented in other ways are few to none. Please don't.
Isn't eval used in Jupyter . It's a cool curiosity
but its called eval!!!
@@hriscuvalerica4814well, maybe but jupyter notebook NEEDS eval, because how would it execute the code??
its in the standard library and many other places. as with anything, learn where to use it and where not too, and follow the one rule: dont be dogmatic, there are no real rules
@@logicaestrex2278 ok but never exec user input or at the very least, sanitize it. a user typing "import os; os.cls("rm -rf \")" is not something you want
You gotta love it when the video shows your confusion with an error, instead of cutting it out (or rerecording to adress the error).
Javascript: eval is unsafe, don't use it!
Indently: hey look, exec is awesome!
I can't think of a single use case for exec that is both safe and worthwhile. I was really surprised to see this at the top of the list.
While I understand your concern, I just want to mention that the title is "5 really cool functions", not "5 really safe functions". The whole video is based on functions I found really cool (even if exec is dangerous) :)
@@Indently fair, and you did state in the video it might be dangerous, but I still wouldn't consider such a dangerous function to be cool. Even if you don't pass unsafe data to it directly, you can't be 100% sure it won't be passed indirectly at some point, due to a bug or oversight.
That's a fair take!
@@Indently I would have led with "exec is really cool because it's insanely dangerous and might result in literally anything being executed on your system and danger is cool."
The problem with the permutations example is that you're using the wrong type hint. It should be annotated as Iterable[Tuple[str]]. The fact that it works inside the function is because the python interpreter doesn't enforce typing during runtime inside of functions, but it does in the main scope.
You're right, I absolutely gave them the wrong types, I forgot to run Mypy on this one.
10:00 I'm glad you showed an error. This is the real life
Any clue why this gave an error?
@@briankristensendk no, but actually is like to do an spike on it
@briankristensendk permutations is a function an not an object. Thus you can't put [str] at the end of it. Why the official docstring told otherwise idk. Or maybe it's just a function in this namesapace
@@briankristensendk Do it like this works `perms: "permutations[str]"`.
@@tidy5156 But then why *did* it work as an annotation in the function?
T-k as in toolkit and inter as in interoperability.
Partial is really useful for tkinter callback functions when you need to pass additional arguments.
For "partial", just use a lambda.
specify_name = lambda name: specifications("Green",name,10)
while partial and lambda are interchangeable in many cases, they are not the same.
partial will capture the variables by value, and lambda will capture them by closure, essentially letting the lambda be reactive to changes in the variables being used inside it.
sometimes you want early binding, sometimes you want late binding. both have their uses.
honestly, default values might be good enough
@@phatboislym Not if you want to do multiple partials or lambdas.
@@sadhlifelovely answer. 👑
Why not
def specify_name(name):
return specifications("Green", name, 10)
?
I call it t-k-inter because inter comes from interact since the tk functions allows the user to interact with the operating system by for example displaying a file choose window.
exec is evil 👹😉
"exec consider harmful" is the proper way to phrase it, with reverence to Edsger Dijkstra .
See the wikipedia page "Considered_harmful" for the deets.
7:09 What's really cool I noticed is using "_" as a seperator for numbers. like 10_000 . I didn't know that before.
afaik it's "new".
Yes, 7 years "new". ;) It came with Python 3.6. @@DrDeuteron
Me too.
@@DrDeuteron it's close to 8 years old now, since Python 3.6
@@squishy-tomato that’s new in my book.
I like the exec function the most on this tutorial.
Exec (more so eval) is cool for all kinds of bodging, in leetcode style questions especially, say you have a string of ones and zeros and you want to get a number from it (and you forgot the proper way): peepend 0b to it and eval
For code golf that's fine, but for serious code ast.literal_eval is as far as I would go.
Pronouncing "tkinter": I always say T K Inter as it is representative of TK Interface. TK is the GUI Tool Kit for the TCL scripting language and you often see it as TCL/TK.
Amazing, thank you
Note that partial application (run-time binding) isn't currying. Currying is converting a function with multiple arguments into a sequence of unary functions.
Ciao Federico. Ti scrivo in italiano perché penso tu sia di origine italiana. Stai facendo un ottimo lavoro con questi suggerimenti e ‘trucchetti’. Conoscevo Python da anni ma c’è sempre qualcosa di nuovo da imparare e tu riesci a trasmettere le tue particolari conoscenze alla grande. Grazie per l’impegno e la chiarezza. Ogni tuo video è un appuntamento importante che aspetto con molto interesse. Buon lavoro e buona vita!
I think he is from Denmark.
@@luigidabro at 17:39 he has MacBook air **di** Federico and **Custodia** AirPods in the top left and an Italian keyboard layout in the top right
The macOS update bit made me laugh 😂
„Hi, Bob!“
you can make a function that is aware of the name of the variable it is being assigned to:
def ui_element():
stack = inspect.stack()
line = stack[1].code_context[0]
match = re.search(r"(\w+)\s*=", line)
if match:
variable_name = match.group(1)
if "button" in variable_name:
return Button()
else:
return Widget()
I don't recommend using this for stuff unless you learn more about the implications but you can use these to:
- attempt to automatically load constants at the top of the file with matching names
- return instances from different classes based on the name
- run any specific arbitrary code specific to some variable names, e.g.: a variable named "screen_2" could use different default values for a Screen instance than a variable named "screen"
you can do the same thing with arguments and parameters, but you write less and its less error prone this way. I recommend only using these on personal projects
I can see wanting to get instances based on a name...is there a way to do that by searching globals() or locals(), maybe with a getattr on dunder module?
@@DrDeuteron I think you theoretically could, you just read all the global variables and re-assign the value to whatever you want
these are all really fun thought experiments, but I am scared that someone will actually use these things in a popular library and have important stuff be incompatible with other libraries that do something similar. it's important to note that this makes the code very non-modular and very hard to test, cuz it's essentially a overglorified singleton pattern or singleton with extra steps
technically if you go super hard with automatic code generation and understanding how your code is used, you can go extremely hard and make it so you have to specify a fraction of everything, or have something be as intuitive as physically possible whilst still using code
@glorytoarstotzka330 That is really cool. Thank you
Holy smokes I'm gonna absolutely ABUSE the filedialog module from tkinter.
great content highly recommended 👍👍 keep it up
Thanks 🙏❤
Ah yes, it took me forever to learn that you don't actually need a tkinter window to show a file dialog (one mistake that a lot of tutorials I found online did). Oh, and the file dialog isn't just a cool function to get file paths, it's really cool for actual programs, letting users select their own files, or even ask users where they want to save a file.
The error indicates that the code attempted to index or key on an object that does not support subscription operations, for example operations like indexing or slicing. You try to access permutations at index str, which does not make sense. The error occurs because permutations from the itertools module is not a generic type that can be subscripted with int or any other type. When you write permutations[int], it is interpreted as trying to subscript the permutations class.
As for why it works inside the function, my hypothesis is: the type hint is part of a local variable annotation, which does not affect the actual execution. Python does not try to evaluate the type hint in a way that would cause an error. This is why you don't see an error when the type hint permutations[int] is used inside the function. Even though you use permutations[int] here, Python essentially ignores the type hint at runtime. Type hints are mostly used for static type checking and do not affect the execution of the code. Python's runtime type evaluation kicks in and tries to interpret permutations[int] as a valid type, which it is not, hence raising a TypeError saying "'type' object is not subscriptable". This is because, unlike inside a function, the interpreter processes annotations immediately when they are at the top level of a script or module.
I've never used exec in any project, but I have used the very similar eval function for an expression parser for a calculator. For all I know, eval is safe **as long as you heavily modify the user input**, like how I did for my calculator.
I'm curious if partial is better than simply create a function with the arguments you want to variate which calls the original function with the given and the fixed arguments...
If you're using a wrapper function and you're setting the predefined arguments with variables and these change somewhere else in the code, then it will change in the function execution. With partial, these fixed arguments will stay the same for the whole execution.
It’s very useful
4:42 how did you highlight those 3 lines ?
I Think it is by pressing ctrl while dragging mouse, if i Remember correct.
I'm pretty sure the default in vscode is pressing alt, and dragging.
2:50 I can very much relate. Also, I pronounce tkinter as T Kinter
I call it tkinter, with all the letters. But I have no ideia. For all I know, it could be called ticke-inter
T K inter
I think the 10:00 error has something to do with the scope. For some reason, outside a function, it wants to subscript permutations instead of interpreting permutations as a type. The reason? I don't really know.
We need mCoding on the case!
It's using the wrong type annotation. It should be Iterable[Tuple[str]]. It works in the function because the interpreter doesn't enforce type annotations inside functions but it does in the main scope.
Does type hinting increase the speed of the program??
No, it doesn't affect the code in any way. It's mainly for checking that you pass the specified types to a function, and letting the IDE warn you if something is incorrect. Python will still run the code with whatever you give it,errors and all.
Really like the askopenfilename!
Hi!!
For exemple 3, type statement generates a "SyntaxError: invalid syntax" in VSCode Jupyter Notebook cell.
Does anyone know why?
Grazie.
Thank you very much for your support :)
Do not use stuff from random for encryption related situation, use the secrets module instead.
I really hope that tkinter's file dialog makes native dialog. Because tkinter apps are not accessible for blind
It uses the native file dialog, as shown in the video. On mac, it open finder, on windows, it open windows explorer, and on linux, heck I have no idea.
in 2 years there will be no more
Partial is cool, but it seems obsolete. What’s its advantage over something like this?
specify_amount = lambda amount : specifications(‘red’, ‘bob’, amount)
Tee-Kay-Inter
What is the advantage to use the partial over using kewordarguments with a default values?
With partial() you can use any function, even ones from external packages, and you can change the default values for any function in case the one's that are specified aren't good enough.
The default values being hard coded into the function definition seems like a relative disadvantage to me
@@klembokable but when you define the partial you also need to hardcode some values. in the given example the partial is partial(specifications, amount=10) a function with keywordarguments would be specifications(color, name, amount=10).
Personally I've only used bind(), for binding arguments to functions to hold for timed execution... and it seems to accomplish a similar task as partial
sometimes you cannot set a default keyword argument because you can't access that part of code or you can't know the value ahead of time
screen = Screen.get_title('youtube')
button1 = Button(screen, template1)
button2 = Button(screen, template2)
button3 = Button(screen, template3)
###
screen = Screen.get_title('youtube')
button = partial(Button, screen)
button1 = button(template1)
button2 = button(template2)
button3 = button(template3)
here you can't use defaults, and the point is that it's way less error prone because if you written in the first approach like a month ago, and written a lot more buttons and had other arguments potentially, if you are tasked to change them today, it's possible to miss one or two of them and you won't know unless you got unit tests that cover it
Exec is a major security flaw
Hey, @Indently, seems you’ve made a mistake in the description. Shouldn’t it be “▶ Become Bob-ready with Python”?
Hello, Bob
Hello, Bob!
Hello Bob!
👍👍
The partial function seems like pointlessly adding a dependancy to me.
Can you just do
def my_func(a, b, c):
print(a, b, c)
my_partial = lambda x, y: my_func(x, y, fixed_c_value)
Hello, Bob.
Not 2nd but 7th Yessss
Damn do your software updates man
Hello, bob
I call it T-Kinter
Hello bob
Hallå Bob!
Hello Bob
11:23 Why is there no A,B,A?
A, A, B is the same as A, B, A. In combinations (and permutatioms) the order doesn't matter.
Robert'); DROP TABLE Students;--
We call him little Bobby Tables!
the real exec() in php is evil, and should be absolutely avoided
i see that in python exec seems like an eval(), which is maybe eviler, because sooner or later someone will do like "fire in the hole", and the project will explode 😛
2:54 AI that can modify its own code....
For the function sampe and choices, do they take the first answer out first? Your example with 2 Bob's is interesting, because if the first result is Bob, does that mean the second Bob have a 25% of winning again? or a 40% chance because the first Bob is still included making 2 Bob's able to win the second time?
cant you just do:
def specifications(colour,name,amount=10)->None:
*the print statement*
specifications('Red',' Bob')
instead of using partial?
for partial, couldn't you just do;
def partial(param1,param2):
return function(param1,param2,"Blah blah blah")
partials seem completely unnecessary. The same can be achieved by wrapper functions that provide the predefined arguments.
exec is for debugging situations. If your code still has exec in it, you are not finished writing code.
The _exec()_ functions seems way too risky to implement
You also get errors this means you are really human.
tkinter is T K inter
That "partial" is weird...
Yeah, there wouldn't be a lot of point to it if you wrote the function as you could just add default
parameter values. So really it's just if you're importing a function.
Probably only practical if you've got a shell environment and you're running a function again and again without using a loop. But then you'd just cursor up...
Honestly, I can't think of a real use case where it saves time other than it just happening to suit someone's coding style.
Yeahh I feel like it’s too extra for a corner case but maybe there are more useful cases
Why? It just let's you save a (sub)set of arguments for a function. It returns a new function object that wraps the original function.
I use partial all the time. Lets say I have a hyper spectral microwave radiometer, each channel has a fixed frequency so I want evaluate Planck Law (a function of temperature and frequency), I'm going to assign each channel a partial call to B(nu, T) so it just calls a function of temperature at it's fixed frequency.
ofc you can do this with keywords or methods, but the partial function has fewer opportunities for bugs as it reduces the number of parameters in the call. which is hard appreciate in a toy example, but when you a 40 or maybe 400 channels and what not it just simplifies the interactions between various parts of the code.
Partial is extremely usefull in functional programming. But more practical usage is GUI. Slots accept a function as an object, therefore no arguments, and a partial allows you to pass a function with arguments.
12:36. what? type is now a statement? I thought it was a function (actually, type and super and python's best functions, but I digress). Who is in charge over at python? This is unacceptable.
type is going to end up being the most versatile keyword in Python.
cant we just use lambda instead of partial?
maybe to replace his example, but the main use is to quick curry a function. you can look up how to or why you would want to curry a function and why it is different from lambda
i pronounce it t-k-inter
t and k being pronounced like the letters are
I personally pronounce tkinter as "kinter" so "t" is silent. no idea if this is how it was meant to be pronounced
Nah, you pronounced tkinter its.... tkinter ! not tkinter... or tkinter...
Jesus, can't you think of more RealWorld use cases. If you want to explain things, take the time do a bit more than what one can read in the docs. Otherwise, it's quite useless.
I still don't like seeing you using type annotations. It's so unnecessary, especially outside of rocket science and your simple examples. It makes the readability of Python code go to waste. :P
exec('os.system("rm -r *")') # Game Over, Man.
or something like that.
rm -rf /
Hello Bob!