Python OPTIMIZATION Trick!!  

I was just about to ask this. Thanks for pointing this out.

Can you give an example

​@@shreehari2589def func_name(local_var): when using function in main code func_name(global_var)

​@@shreehari2589def func(local_var = 10) You can call the function with a custom local var or use 10 as default if none specified

​​@@shreehari2589I think they mean pass the global_var as a parameter like def function(local_var): and then pass global_var when you call the function

can you explain why we should avoid global variable? I am new to python and been seeing alot of this information, but quite unsure how to workaround on that.

​@@novianandrian global variables sow the seeds of terribly bad practices in learners, and experts never use them anyway. the reason why is because new learners dont fully grasp what a function is. it isnt code you just put under a `def` block because thats what you think you are supposed to do. its not even just "repeatable" code. a function is essentially a "sub"program. suppose you are making a library, and someone imports your functions. that function is a black box to them, and they cant see that it wants to use "x" from the global scope. if the function tried to, and they actually did have an "x" in their global scope, even though they didnt know that was part of the use case, they would almost certainly run into inaccurate outputs with absolutely zero clue as to where said output was coming from, and literally no possible way to debug that. but thats not just to say that globals are bad only in the context of libraries, using global variables like this is genuinely harmful no matter what. they direct your code into a very specific architecture which is completely unmaintainable, unreadable and harder to debug. they promote misconceptions on what functions are and how they are meant to interact with a program. and you will never, ever be able to advance beyond basic scripting while you still maintain this habit, because projects that are better formatted in multiple files are practically a nightmare to debug or expand when even a few globals are being thrown around between scopes and files. in short, one of the biggest things i would tell anyone at this point in their journey to learn programming is to make sure that in every circumstance your functions are able to be run on their own. all of the information they need to function fully should be passed in through parameters. if you feel as though you cant do this for your specific case, it may be a sign that your code architecture is wrong, as I have never had that actually be the case in over 6 years, nor have I heard of anyone who has.

​@@novianandrianbecause it creates a lot of dependencies for your function, and makes the code less organized either pass it as a paramater, or create a class and make the function a member of the class using it for constants is fine not using global variables is a good practice for all programming languages

​@@the_cheese_cultist when you have code that might need constant change or update don't global variables make everything faster? Im doing my capstone college class and im working on a website that deals with different aspects of CSV data surveys. and i approached it with the mindset of "hey making everything global makes it easier to edit later. (side not it was inherited from last year and the whole approach the other team started with was a mess so we could only focus on refactoring.)(we worked with ruby on rails )

@@stilyandimitrov39 I'm gonna need more info to give you an opinion, but there are many sources online about good coding practices, avoiding globals included, that can explain everything better than a RU-vid comment.

thanks to this trick I managed to get a 50000% performance increase!

I switched to NodeJS and then bun.sh!

@@sanchogodinho lmaooo, yeah great... optimization I guess

Thank you❤I started learning binary code😍😍😍🥰🥰😍

@@firstnamelastname2775 nice, congratulations :)

This doesn't have to semantically make sense at all

kinda annoying to keep track of the variables and has to unnecessarily place arguments everytime u call the function

This is common in Pure Functional Programming

​@@vulpritproozeSo, you can set default parameters

exactly this video is super wrong

At least someone knows!

This can make the code very complex when using nested function, see mcoding's video

You have completely missed the point of the video. Hint: adding "global global_variable" at the top of the function doesn't change the bytecode at all. The whole (bad as it might be) point of the video is that accessing a global variable from the inner loop takes more time than loading the global variable into a local variable first.

​@@joergsonnenberger6836 we can declare the variable as global inside the function before the for loop

That's called dependency injection

Yep, DI is the way to go. Reuse your code and it makes it easier to read.

oh my god that is not dependency injection. that's just having a pure function

@@l3gacyb3ta21 Realized after two weeks but who cares i got two likes thanks to misinformation

best reply imo

I mean having faster python is still better than slow python.

@@l3gacyb3ta21 I wouldn't say it's strictly better, it's a tradeoff - because to get faster python you have to decrease the readability by making your code appear a little more complex. You should choose Python when code readability/understandability is important and performance isn't important, because that is what the language is designed for. That's why it's a really good language for one-off quick scripts. But if you are in a problem space where performance is valuable, it's nice to use a language that's really designed for that from the get-go. Where you can actually use the language's nice features without surprise performance problems. That being said, sometimes you inherit a codebase that's already in Python and performance may become an issue so sometimes you have to choose lower code readability for better performance.

Right

If you care about improvement to 0.1 miliseconds from 0.11 miliseconds you should probably not be programming in python ...

Except its done after the mvp and before it's too big to optimise?

⁠@@revimfadli4666yeah, it’s probably a fine optimization if your program is just a counter multiplying by a global, but it is woefully insignificant in the scale of any program larger. Or, if your program is just a big loop, use PyPy. I remember hearing that it’s better at this stuff.

no, that's not

it’s just an example of

He literally profiled it. How's that premature??

Right? I thought he was going to say to pass it into the function as a parameter, since he said “new to python” but I guess not lol

look it's bad practice but people use globals and sometimes they provide value too

Especially his changes also changed the whole program's behaviour as Global_var is no longer updated.

Question, how is he even getting the global variable to work in his function without write global (var_name) at the top of the function?

so you never use a global variable / constant in your code?

It's predetermined but it doesn't mean it has the same cost. Lookup in local scope is faster for many reasons - it can be stored more efficiently, you can have more faith in what you are dealing with etc. For example, if you are dealing with something in outer scope, there are no guarantees about the value assigned to the variable as it may be changed in some other part of the code and global lookup has to be used to ensure that you are using proper value at the time you want to access it. If you copy the global value to a locally scope one, you can avoid that lookup as it is "detached" from its old variable. I don't know how lookups are managed for collections but if they are not explicitly copied, then I would assume they are stilled handled through global lookup rather than a local one based on the same problems with it being stored at a global level.

@@viCoN24 Your reasons are also wrong. The object under reference is stored the same way no matter if it's local or global. "Outer scope" and "global" are two different things, but whether you have "guarantees" about the referenced value or not is irrelevant - cPython has no JIT. It has global interpreter lock, so the dereference doesn't have to do nich Apart from finding the actual memory address. I would invite you to profile this in an actual code, where the local scope has just as many items as the global one.

I think I missed your point. Thanks for the explanation! You focused on the underlying mechanism where it's still one operation rather than two lookups. I don't know how these operations are performed by CPython but one is clearly faster than the other so I tried to provide some reasoning behind it but it's true that GIL simplifies the situation. In principle the lookup resolution behaves as author explained even though the interpreter is able to scope it internally to decide on the proper operation rather performing dynamic lookup and failing at runtime when variable is not found. You are right that it's only one operation but whether it's assigned that one operation or the other is decided in the fashion described by the video maker.

@@KennyWlr Wow! Thank you so much for this detailed explanation. It's good to be wrong sometimes to learn this much. Cheers! :)

Are you sure? I've done a "benchmark" in Google Colab trying it, and the second case gains some performance indeed (Not too much)

Were yall doing AST analysis for a school project 0_0

This is one of the reasons, yes. C and C++ are, by default, pass by value. That means when you pass arguments to a function the values are copied for the function to use. Passing a pointer is still technically pass by value, but the value being copied is the *address* of the data; rather than the data itself. This allows you to save memory for larger variables (e.g., a big struct or a class). It also allows you to modify the original data, since you're being given a pointer to it rather than a copy of it. Note that C++ has references, which are often used over pointers because they are safer (but are very very similar). If you're in C++, default to using references unless you have a reason to use a pointer (e.g., so you can call C functions). For functions which are taking a pointer/reference to save time on copying data, you'll often see `const MyLargeDataType *mldt` or `const std:: string &str`. The `const` part signifies that the data being pointed to will never be modified by the function. Something to keep in mind also is that, for pointers, the following two are not the same: `const int *a`, `int *const b`. Here, `a` can be re-assigned to a new address of another `const int`. However, the contents at the address cannot be changed. For `b`, the contents at the address can be changed, but the address it actually points to cannot be changed. Here are some examples: ``` int c = 123, d = 456; const int *a = &c; int *const b = &c; a = &d; /* okay, we can change where it points */ *a = 789; /* not okay, we can't change the data it ponts to */ b = &d; /* not okay, we can't change where it points */ *b = 1011; /* okay, we change the data it points to */ ``` Note that in C++, all references are `const` (the address they point to cannot be changed), but you can still modify the data they point to so long as the type is not marked as `const`.

@@whirvis Thanks for the explanation. I'm trying to learn C, and pointers are a bit confusing to me, particularly when and why to use them. As I understand it: int a; //declares a variable containing a value. int *b; //essentially declares two variables, one contains a value, the other, an address. *b = 123; //contains a value b = &a; //contains an address void Function(int *c){} //expects an address. Call like this: Function(&a);

@@MortonMcCastle int a; // designates enough memory to store an int but doesn’t say what int to store int *b; // designates enough memory to store an address which, when dereferenced, should point to memory that stores an int (should not be thought of as declaring two variables because it’s only declaring memory for the pointer, not for any actual int value) *b = 123; // is a very insidious bug because you’re modifying data at a random memory location because you never initialized b with a valid pointer so it’s interpreting whatever bits happened to be at that spot in memory before as a memory address. This is the kind of bug that hackers exploit to gain escalated privileges to systems. b = &a; // b is now a pointer to a, so now it is safe to do *b = 123 which is equivalent to a = 123

I dont know which he used, but he most likely used a profiler

Maybe cprofile or mprof or else lineprofiler I guess.

Using Global variables is not good, unless they are constants. If you need a value [especially a variable one] it should be passed as a parameter to the function, so that the function always have the same exact behavior when it is passed the exact same parameters. makes them predictable and individually testable.

@@olivierdulac Use of global variables is fine in some contexts esp when writing smaller scripts or module level variables

You're better off using the global keyword if worrying about scope

If you try writing to global_var it will create a local instance precisely to avoid corrupting it. You have to use the global keyword to specify global_var is global and be able to write to it. But really in the example in the video global_var should just be a parameter that is passed in. 99% of the time globals issues can be solved by just not using them and refactoring your code appropriately or starting with best practices from the beginning.

this optimization doesn't change time complexity, for that function it is O(n). time complexity refers to how well an algorithm scales when the amount of input data is increased. this optimization just reduces cpu cycles required to access the variable.

@@topzozzle6319 Thanks for the info sir

Better - when writing non trivial programs, it's often hard to avoid globals - unless you want to make the call graph a complete mess. If you're determined to kill all globals, you might want to malloc() a singleton (a struct) containing all of them (so you can re-enter the function without side effects) and pass it down all the way - even if you don't use it. That way if you change a function so it requires the use of such singleton, it's there. You might get a few warnings, but it works - and it makes maintenance less of a pain in the neck. BTW, always initialize your global vars in a separate function. You might be in for a surprise if you call it multiple times.

This looks like VScode with maybe the Dracula theme?