At around the 4 minute mark you are confusing immutability with references. When you do 'y = x' what you are doing is assigning the reference of the object that x is pointing to, to y. When you assign a new object to x it drops the old reference and now refers to a new object, meanwhile y still refers to the original object. You use tuples in this example, but this is true for lists and dicts. When you change to lists, all you are really demonstrating is that x and y refer to the same object. With your get_largest_numbers() example, if you were to pass a tuple into the function you would get an AttributeError because you were passing an immutable object which doesn't have the sort method.
Thank you so much for correcting this section of the video. I hope enough people read this and try it so they can correct their understanding of the concept.
Isn't Python treat immutable types (strings, numbers, tuples) as literals, while lists and dicts are basically objects? Once you assign different value to a string or number or any other immutable type variable, you're actually creating another literal object, but the one you created previously still resides in memory and will be purged later, no?
Actually, Tim was right and was pointing out the possibly-unexpected behavior one can run into with mutable types: If you create x, create y with the value of x, and then REPLACE x by creating x again, then x and y will have different values. Try it yourself: x = [1, 2]; y = x; x = [1, 2, 3]; print(x, y) If you create x, create y with the value of x, and then CHANGE x by reassigning one of its values, then x and y will have the same new value and the original value will be gone. Try it yourself: x = [1, 2]; y = x;x[0] = 9; print(x, y)
Some details skipped about *args and **kwargs: A forward slash "/" can be used to force parameters to be positional only, thereby making them required when calling and not by name. So, def function(a, b, /, c, d, *args, e, f = False, **kwargs) means a and b cannot have default values, are required to be passed when calling function, AND can't be supplied with their parameter names. e must also be supplied with a value when called. Naming the first * is not required. Doing so simply allows the function to take an arbitrary amount of positional parameters. def function(a, b, /, c, d, *, e, f = False) would require at least 5 arguments (no more than 6) passed to it: a and b are required, c and d are also required and optionally passed as keywords, e must be passed as keyword, f is completely optional, and nothing else is allowed. / must always come before *. * must always come before **kwargs. **kwargs must always be last if used.
I didn't know the kwonly args after *args didn't need a default. The posonly arg names can also be used as kwarg keys when the signature accepts kwargs.
Your description is accurate and provides a clear understanding of the use of /, *, and **kwargs in function parameter definitions in Python. Let's break down the key points: / (Forward Slash): When you use / in the function parameter list, it indicates that all parameters before it must be specified as positional arguments when calling the function. This means that parameters before the / cannot have default values and must be passed in the order defined in the parameter list. Parameters after the / can still have default values and can be passed either as keyword arguments or positional arguments. * (Asterisk): When you use * in the function parameter list, it marks the end of positional-only arguments and the start of keyword-only arguments. Parameters defined after * must be passed as keyword arguments when calling the function. They can have default values if desired. **kwargs (Double Asterisks): **kwargs allows you to collect any additional keyword arguments that were not explicitly defined as parameters in the function signature. It must always be the last element in the parameter list if used. Here's an example function that demonstrates these concepts: python Copy code def example_function(a, b, /, c, d, *, e, f=False, **kwargs): """ a and b must be passed as positional arguments. c and d can be passed as positional or keyword arguments. e must be passed as a keyword argument. f is optional and has a default value. Any additional keyword arguments are collected in kwargs. """ print(f"a: {a}, b: {b}, c: {c}, d: {d}, e: {e}, f: {f}") print("Additional keyword arguments:", kwargs) # Valid calls to the function: example_function(1, 2, 3, 4, e=5) example_function(1, 2, c=3, d=4, e=5) example_function(1, 2, 3, 4, e=5, f=True, x=10, y=20) # Invalid calls (will raise TypeError): # example_function(a=1, b=2, c=3, d=4, e=5) # a and b must be positional # example_function(1, 2, 3, 4, 5) # e must be passed as a keyword By using /, *, and **kwargs in your function definitions, you can create more structured and expressive APIs and enforce specific calling conventions for your functions.
He definitely should've included this info in the video. I've learned this before but am not a professional programmer so haven't used it, so seeing it in this video would help non-experts like me. Also, this can be inferred from the explanations above, but maybe still worth stating explicitly: Parameters between / and * can be positional OR named. And the function won't work if * comes before /, since the parameters in between would be required positional and required keyword, which creates a contradiction.
I wanted to mention that the if name is main thing is frequently used for test code for libraries. Your code may have some functions to import elsewhere, then you can do examples in the main of how to use them, or try various failure cases, illustrate how to catch exceptions, etc. Also, to those getting into programming, please do yourself a favor and leave a comment in your code as to what it's for. The most likely person to be reading your code later is you, but if you wrote it 6 months ago, it might as well have been written by someone else, so be kind to yourself.
The GIL can be bypassed by using parallelism which offers about the same capabilities as threads in other languages. This is more of a naming convention issue rather than an actual thing that you can't do in Python. Python threads are still useful for IO and similar async tasks, but they're simply not traditional threads. It's important to highlight these kinds of things even for beginners so that they don't go out into the world thinking that you can't do parallelism in Python. You absolutely can. It's just called something else.
Hello dear sir, You mentioned that 'It's just called something else', and what came up to my mind is that another threading library named _thread which is meant for low level threading and also multiprocess library that allows users to run multiple python clients. Am I correct or did you mean something else?
@@Joel-pl6lh The library of choice for actual parallel processing in Python is _multiprocessing_ It has a similar interface, but gives you actual parallel computing on different CPU cores.
Agree, in the GIL part of the video there is a lot of confusion since multi-threading is mixed with multi-processing, and not a clear definition has been provided, which contributes to confuse who approaches to these concepts. It simply does not exist a multi-threading code, in all the coding languages, that executes threads at the same time
Great content. Keep it up. However, I believe there is a mistake at 3:34. You mention that we have some sort of automatic "copying" going on with "y = x" when using immutable types. This is actually not correct. The assignment still works exactly like with any other object - the reference x is assigned to y. Identifiers x and y are simply referring to the same 2-tuple object. After that, you change what identifier x is referring to (another 3-tuple) and print out the two individual objects. The identifiers are still references - even if using immutable objects.
Came here to say the same. The point can be illustrated with this code, x and y point to the same thing: >>> x = 1 >>> y = x >>> print(hex(id(x)), hex(id(y))) 0x7f82aa9000f0 0x7f82aa9000f0
this is just what ive been searching, please elaborate on python interpretor and how does it differ from C compiler, noting that python is developed in C.
Because of the GIL, Python multi-threading is not useful for processor-bound computing, but it is still great for I/O bound computing (processor waits for input and output; example: disk read/write or networked data). Multiprocessing is a great way to get around the GIL, when you need to.
Certainly! In addition to multithreading, Python also provides the multiprocessing module, which allows for true parallel execution across multiple processor cores. Unlike multithreading, multiprocessing bypasses the limitations imposed by the Global Interpreter Lock (GIL) since each process gets its own Python interpreter and memory space. By utilizing multiprocessing, you can take advantage of multiple processor cores and achieve parallelism, which can significantly improve performance in computationally intensive tasks. Each process operates independently, allowing for efficient utilization of available CPU resources. However, it's important to consider that multiprocessing comes with some overhead due to the need for inter-process communication. Data exchange between processes can be more involved and slower compared to sharing data between threads within a single process. As a result, multiprocessing may not always be the best choice for every situation. To determine whether to use multithreading or multiprocessing, it's crucial to evaluate the specific requirements and characteristics of your application. If the task at hand is primarily CPU-bound and can benefit from true parallel execution, multiprocessing can be a suitable option. On the other hand, if the workload consists of I/O-bound operations or requires a high degree of coordination and shared state, multithreading might be more appropriate. In summary, the multiprocessing module in Python offers a way to achieve true parallelism by leveraging multiple processor cores. While it circumvents the limitations of the GIL, it introduces additional overhead for inter-process communication, which may impact performance. Careful consideration of the specific requirements and trade-offs is necessary to determine the most suitable approach for your use case.
Thanks. Most things I already know, so my takeaway: 1.) immutable types = C#/.NET valuetypes or Java primitive types, plain data types in C/C++, Pascal and mutable types = C#/.NET reference types or Java object types, C++ reference, dereferenced pointer data aka memory location in C/C++/Pascal/Assembler. 2.) List comprehension is reverted looping writing style (like perl?). 3.) Function arguments look similar to other languages here added dynamic argument *args and ** kwargs little bit like C's ... period argument and function. 4.) __name__=="__main__" unique feature? Easy, but unique, as I didn't saw dynamic caller backreference in another language. 5,) I thought GIL is about single threading
At around 11 mins another cool thing you could know mention is that if you provide a default variable that is mutable, say a = [], and say you modify the list to look like within the function to say a= [1,2,3], that default varraible is actually now a = [1,2,3] and could create problems if you call that function twice without giving the a argument
Can you clarify what you mean with a code example? I thought you meant this, but the default value doesn't change in this case (luckily, that would have been disastrous...) >>> def f(x,a=[]): ... print(a) ... a=[3,4,5] ... print(a) ... pass ... >>> f(9) [] [3, 4, 5] >>> f(9) [] [3, 4, 5] How would you make the default value change?
@@HerrNilssonOmJagFarBe yes, here you setting the value with the statement, , a=[3, 4, 5],which as far as I know is now stored at a different place in the memory but try instead by having your default value as say a = [1] and then in the function append a value to the list, something like, def add_item(a = [1] ): a.append(2) print(a)
@@ireonus >>> def f(x,a=[]): ... a.append(2) ... print(a) ... pass ... >>> f(1) [2] >>> f(1) [2, 2] >>> f(1) [2, 2, 2] Oh. Well, that's truly weird...! I also tried a recursing version of f() which made the issue even more spectacular. So 'a' is local to each particular invocation of the function, but the default value itself is the same across calls? What happens to the memory that's claimed by the default value once I've called the function too many times. There is no way to directly reference it outside the function. Can I ever reclaim it (short of redefining the function)?
f.__kwdefaults__['a'] I use this like f(x, *, _cache={}) but have not tested it across imports. Should probably fully understand the implications with good tests before using these for personal projects.
@@kmn1794 Clever. It also made me understand the behaviour. Thanks! But such code seems obscure and abusive of that particular language quirk. How many would understand such code? I certainly wouldn't have until I saw this youtube vid.
Threading just takes advantage of GIL "idle time". (aka I/O wait-states) The Python "Multiprocessing" module allows you to run exclusive processes in multiple cores. (ie CPU-bound applications.). And (believe it or not) you CAN use threading inside an M/P function if it is coded properly. (according to the rules of MP functions and threads...)
Great video! It might have been worth it to mention multiprocessing in Python as a way to overcome the multithreading limitation that you reviewed towards the end.
The statement you made at about 3:30 was not correct. Writing y = x (where x is a tuple) does not create a copy of the object, as you can tell by looking at their ids -- they are identical. So, there is no difference between mutable and immutable objects in this respect. That line only creates a new variable that points to the same object as x did.
Exactly. Additionally, assignment to x just lets x point to another thing and doesn't modify what x pointed to. That whole part was conceptionally wrong.
This is a great video for someone who is learning python as a second, third, or nth language. These are very python specific implementations of universal concepts and I had been wondering about their purpose when seeing python code.
Should I be worried learning these concepts if I'm thoroughly learning Python as my first language? What should I look out for since I plan to move on to C++?
At 3:30, your description of why changing x does not change y is incorrect and seemingly makes the same mistake many new Python developers make when working with mutable objects such as lists. The assignment `y = x` does NOT create a copy of the original tuple in y. y and x both point to the exact same tuple object in memory. This can be shown with either `y is x` (outputs true) or by printing `id(x)` and `id(y)` which will be identical. When you subsequently assign x to a new tuple, x now points at a new tuple object at different location in memory, which you can see by checking id(x) before and after that assignment. All variables in Python are references to objects. Doing an operation like `y = x`, for any type of object in x, simply makes y a reference to the same object, which is why mutable objects passed as arguments to a function can be mutated by that function. Likewise, anytime you assign a new value to a variable referencing an immutable object, you get a brand new object. if a = 1000, and then a += 1, you also change the id of a to a brand new object of For some more interesting examples, if you do something like `for i in range(-1000, 1001, 50): print(i, id(i))`, you'll see the id value change for each value, but in most implementations it alternate back and forth between a couple of ids as the interpreter reuses the memory block that was just freed by the garbage collector from the value in the previous loop. The exception is for ints in the range of -5 to 255 (at least in CPython) you'll get a different set of ids because those int objects are pre-allocated when interpreter starts and remain in memory to improve performance, as do the None object and True/False.
I initially rushed through learning of Python's fundamentals. Whilst these things were mentioned, I didn't grasp the concepts until this video. Thanks.
I am currently doing Python courses and i struggle a lot, i like that you distinguished parameters and arguments correctly and basically everything else what you've said is exactly the same things, that i got myself/what i've been told. But it is good to refresh upon those conceprts and methods to proceed with my further studying, because i when i am given a task almost everytime i find it hard to came up with the right solution and fail to get the right approach to it. Thank you for the video. Subscribed!
HI Tim, Just getting into coding: as you know (motivation level throught the roof - then realise html is not a stepping stone but a foundation of things to understand) Well Done on your coding journey! 😅🧐💫💫
At 3:45 with: x = (1, 2) y = x you are not doing a copy, it is still an assignment to an immutable object. You can check it with: print(x is y) This returns True, meaning that both x and y are referencing the same object - a tuple (1, 2). And of course print(x == y) also returns True, as we are comparing an object with itself.
3:50 It's also an effect of the fact that the file is read from top to bottom. Line 2 get the evaluated before a line you were to swap lines 2 and 4 with 1 anothen X would equal (1, 2, 3).
Really a *DIAMOND MINE* for coders (especially python coders). I scrolled through your channel and instantly knew this is the channel for python coding and subscribed it instantly. This video was very helpful. The way you explained things shows the amount of experience you have on python coding. Thank you very much ❤❤❤
I'm not a Python developer, I'm an iOS developer (Swift, SwiftUI), I'd love to have people teaching new features on iOS with the same clear and concise speech as yours.
Thanks for the video! Very consize and informative. The only thing that I would add about the GIL is that it because of it there are no performance advantages when it comes to so-call CPU-bound operations (like summation that was used as an example in the video). But when we are dealing with input/output-bound operations, such as sending a HTTP-request, then multithreading will improve performance, because instead of waiting for response before continuing executing code, we can use that waiting time to make more HTTP-requests. This can help handling multiple requests that are send to your web-applications, for example.
Hey Lina, i also have a django function on which request lands, it was giving timeout error when 2users were hitting the same fn using url, then i increased the gunicorn worker and now it's working fine. So my qn is, was that a good idea or there is any other way to handle concurrent request on prod. Fyi that fn involve hitting different tables, and storing bulk data in one of tables using orm. So if you can comment over this about the best way to handle these things. Kindly share.
about 4:04 your explanation of changing values in mutable v. immutable types is really weird. You eventually get to saying that variables are actually just pointers to objects, and saying x=y is just reassigning the pointers to be the same (in other words, there is an object that y points towards, and executing x=y is setting the pointers to be the same) but you also say that immutable types do a clone instead which is... wrong. Here's some code that can be used to see that: x = (1, 2) y = x print(y is x) output: > True the two numbers should be the same, but should be different each time you run. The 'y is x' statement is comparing the ids of the numbers, aka where they are in the code. They're the same object. Some more code to show that 'is' is not just a fancy '==': x = (1, 2) y = tuple([1, 2]) print(y is x, y == x) ouput: > False, True Different objects.
3:30 When you typed “y=x” did it actually _make a copy_ or did it make y _point_ to the original location of x on disk? And then your next x assignment pointed x to a new location on disk? Aren’t x and y just storing pointers? The rest of what you are describing is really helpful (thank you!), just wanted to try to clarify this.
Tim bro you never disappointed us ..This is straight up golden content...Really appreciate your work...Can we get more videos of you summarizing concepts in under 30mins once a month maybe ?
00:02 Conceptos importantes de Python Se presentan cinco conceptos importantes de Python que los programadores principiantes e intermedios suelen confundir o cometer errores al leer código de producción. Estos conceptos son fundamentales para comprender y escribir código en Python de manera efectiva. 01:45 Mutable vs Inmutable Se explica la diferencia entre los tipos de datos mutables e inmutables en Python. Los tipos de datos inmutables no pueden ser modificados una vez que se han creado, mientras que los tipos de datos mutables pueden ser modificados. Se proporcionan ejemplos de tipos de datos inmutables (como cadenas, enteros y tuplas) y tipos de datos mutables (como listas y diccionarios). 06:23 Comprensiones de lista Se introduce el concepto de comprensiones de lista en Python. Las comprensiones de lista permiten crear listas de manera concisa y eficiente utilizando una sintaxis compacta. Se muestran ejemplos de comprensiones de lista simples y más complejas. 10:33 Tipos de argumentos y parámetros en Python Se explican los diferentes tipos de argumentos y parámetros en Python. Se cubren los parámetros necesarios, los parámetros opcionales con valores predeterminados, los argumentos posicionales, los argumentos de palabras clave y cómo utilizar el desempaquetado de argumentos y parámetros. 14:15 Uso de asteriscos en Python Se muestra cómo utilizar el asterisco (*) en Python para desempaquetar listas y diccionarios en argumentos y parámetros de funciones. Se explican los usos de *args y **kwargs para aceptar un número variable de argumentos posicionales y argumentos de palabras clave. 17:43 El Global Interpreter Lock (GIL) Se explica el concepto del Global Interpreter Lock (GIL) en Python. El GIL es un mecanismo de bloqueo que permite que solo un hilo se ejecute a la vez en un intérprete de Python. Esto significa que, a pesar de tener múltiples hilos, solo uno puede ejecutarse a la vez, lo que limita el rendimiento en aplicaciones que requieren un alto grado de concurrencia.
3:49 y is not copy of x. After `x=y` , y and x represent name of the same variable, then in line `x=(1,2,3)` you create new variable and named is x. `x=y` never create copy.
Yes. I think Tim misspoke a bit in this section on mutability vs immutability. Setting “y = x” creates a second reference to the tuple which was originally referenced as “x”. This assignment has nothing to do with a “magical” copy of an immutable object. This can be confirmed with “x is y” and “y is x”; both are “True”. Equality checks (with “==“) are also “True”. Subsequent setting of “x = (1, 2, 3)” creates a new 3-element tuple referenced as “x” while “y” becomes the only reference to the original 2-element tuple. I think it might even help to add a 6th must-know concept - “references vs. copies”.
Thank you so much. There is a lack of content on the internet about this. In addition to making things clear, it helped me in my programming midterm too.
I don't wanna be THAT GUY, but actually in the first part, when you do the tuple x = (1, 2) y = x x = (1, 2, 3) you're actually creating only one (1, 2) set in the memory. x points to that set, y points to the same set, so no hard copy. when you assign a new set to x in the third line, you create a new set in memory and only changes the memory address that x points to. The difference is that a set has no x[0] = n assignment (since it's immutable), then you're always reassigning.
Your solution for if __main-- = "__main__" legitimately saved my sanity. I was working on an asynchronous endpoint function and i was having difficulty closing the event loop until using that worked!
That actually was really good thank you very much I just finished a code where it was "downloading 10 files at a time which is 10 times faster"... Now I understand why it doesn't work so well :')
🎯 Key Takeaways for quick navigation: 🧱 Understanding mutable vs. immutable types in Python is crucial for avoiding common mistakes. 🔀 Immutable types like strings, integers, floats, booleans, bytes, and tuples cannot be changed once defined. 🔄 Mutable types like lists, sets, and dictionaries can be modified after being defined. 🔄 Assigning a mutable object to another variable creates a reference to the same object, affecting both variables if modified. 📝 List comprehension simplifies code by creating lists in a concise manner using for loops. 📋 Python supports various argument and parameter types, including positional, keyword, optional, and special types like *args and kwargs. ⚙️ The "if __name__ == '__main__':" statement allows code to be executed only when the Python file is run directly. ⚙️ Python's Global Interpreter Lock (GIL) restricts simultaneous execution of multiple threads, affecting multi-threaded performance. Made with HARPA AI
In the first four minutes of the video, there is already a mistake. At 3:40, the video states that when you do x = (1, 2, 3) and then y = x, you are creating a copy of the object. This is incorrect. Instead, you are making y point to the same reference in memory as x. This applies to all types, whether mutable or immutable. You can prove this by simply doing x is y (which will return True) or checking id(x) and id(y) (both will have the same value). This invalidates the whole narrative of mutable vs immutable in the first 6 minutes of the video. This happens in most programming languages (if not all), not just in python.
4:35 so is it accurate to say that when x was originally an immutable object like a tuple, and when assigning y = x, then x is passed "by value"? And when x was originally a mutable object like a list, when re-assigning x using y = x, then x is passed "by reference"?
So you seem to be confused about the way immutable objects are stored in memory. 03:37 when you write y=x it doesn't make a copy or x. Instead, both x and y point to the same tuple in memory. When you then assign something else to x, y still points to the same tuple and python's garbage collection will not free the memory. In fact one of the reasons to have immutable object is precisely to avoid having to make physcal copies of it in memory. Hope this helps
In which situation is it better to use if name == __main__ rather than split the given script into {a runnable program + a package that only defines stuff} ?
I think it's just a way to keep your project clean, by for example including a simple example/test within the same file instead of having to create another file like 'modulex_example.py' that the user may or may not find.
Dear Tim, regarding Section 01 (mutable vs immutable), if we use string as an example, is the following program a good example ? fruit = "Apple" print (fruit) # Output: "Apple" fruit = "_pple" # Allow print (fruit) # Output: "_pple" print (fruit [0]) # Output: "_" fruit = fruit[0] = "A" # Not allowed
So new to learning python, specifically for data collection and use in Marketing/Digital. My question between immutable and mutable would be use case. My assumption would be that you use a scraper etc. to collect data, then define that as an immutable data type, aka. store the raw data as a string. To manipulate/work with the data, you would then pass that string to a mutable data type, I'd assume a dictionary. From that, you can then pull sections of data, organise the data etc., and clean the data to be able to use it for statistics/interpretation. That way the original data is preserved and cannot be corrupted, but you're able to make as many copies of the raw data for whichever transformations you may need to make and use those different mutable copies for each required purpose. Would that be the correct thinking?
3:50 So and C++, If I want extremely fast applications, I do not allocate memory all the time . I try to allocate my memory up front and any manipulation happens with that existing memory . The idea that you have to create another object to make an assignment is purely useful . Because I have infinite control over the memory and I know exactly what I am doing, I can write extremely fast and extremely stable code
Crazy, I just started watching this video and the speech intonation is exactly the same for almost every computer/video game/programming video on TH-cam. "We like..to talk..like thiiiiiis." Im going to finish watching it because I need something in the back ground
great video finally getting to catch some of the basics through a project based tutorial wish is a great way to know how to implement the basics thank you for your effort
Example at 3:33 is not relative to mutable/immutable. If change to list, result will be the same. Attempt x[n] = m for tuple and list actually will explain all
3:33 That tuple vs. list example is a flawed false analogy. If you take the tuple example and replace () with [] (without modifying anything else in the example), you will get the exact same outcome: y holds a reference to what was formerly referenced by x (until x was set to a new reference). Example: x = [1, 2]; y = x; x = [1, 2, 3]; print(x, y) And nope, the tuple did *not* get (deep) copied. Example: x = (1, 2); y = x; x is y ← This returns True. No deep copies involved.
in your example at 5:00 What is the point of putting return numbers [-n:]? Not sure why you would make it negative. Also why not just return numbers? and also why did you put a 2 there? As far as I can see the two isnt actually doing anything. I wrote my own version of your example and it sems to be doing the exact same thing but a lot simpler: def getlargest(nums): nums.sort() return(nums) nums = [1,23,4,5] print(nums) print(getlargest(nums))
Dude!!! That was a great tutorial. There are so many "beginner" python tutorials out there and it makes it hard to find the more advanced ones. I learnt a bunch! Thanks!!!
I don’t think you understand the first concept. Statement at 3:43 is wrong. Assigning immutable value of x to y on lime 2 does not make a copy, but makes y refer to same object as x. But on line 4 a new immutable object is created and x now refers to that while y still refers to the old object.
Finally someone who has streamlined the nitty gritty... Every other tutorial treats you like you have never seen a computer lol, just a video idea, "most encountered python programming statements" or "intuitively understanding coding arguments in python"
I am using multiple threads in Python to request APIs, since most of the time I am waiting on result from the request or db query or smt like that. If I have 10 threads and each sends request and then waits for response (other threads in the meantime get also to work and send requests one after another), I can run my scripts 10x faster. From a 3 hours runtime where I do a lot of API requests and db queries on around 100k samples, it will finish in around 22 minutes now with a Pool of 10 threads running. So the GIL is still present, but each thread can pass it up to another thread when waiting for a response probably? That is my way of understanding it. And it is a way how to use threads in python and benefit from it
About 5 minutes in... When you called your function Get largest numbers you passed it into a variable called largest? Then you printed a different variable called nums. I would have assumed you would have printed: print(largest) Could you clarify what the variable largest was for if it was not used. Thanks
3:25 Not quite correct. When you said y = x it did NOT make a copy. It made a copy only when you then said x = (1, 2, 3). Python's assignment operator just binds to whatever object the right hand of it returns. For some immutable objects like low integers a python implementation may actually always use the same object. For example if we say x = 3 and then y = 3 then its likely that x and y will be the same object. The idea is that it doesn't matter for most practical purposes if an immutable value is the same object or not so that the implementations are allowed to just make them the same object for efficiency purposes.
Can someone recommend roadmap for automation in python? Do I need to learn DSA or how much basics should I know before I get into automation. My main focus is to support my devops practices. Thank you
6:00 Can you please explain in which cases it is beneficial to make these side effects happen ? I don’t see any case where it’s actually helpful in addition to being confusing.
I recently ran across *args, **kwargs in some code I was stealing, uh borrowing, and it might as well have said *abra **kadabra because I didn't really get how it worked. You made me understand. Thanks.
I didn't know about the "GIL". Your explanation gave me the answer to a question that I had parked for some time: why did concurrency not speed up a specific function that processed a very large list? I hope this will be fixed soon.
should I always use a double * with "kwargs?" For example, if I don't have *args, do I still need to write it as **kwargs or can it then be written as *kwargs?
Start your career in Software Development and make $80k+ per year! coursecareers.com/a/techwithtim?course=software-dev-fundamentals
Your timestamps are mislabeled for if_name and function types.
Hi Tim please make a video about GIL in Python and mulithreading in Python.
what do you think about Mojo programming language
please make a video about GIL and why does python not support multithreading
Mojo programming language is super set of python and it is 35000x faster than python
Working as a python dev and in my 1 year of practicing python... no one ever explained this well... you're a GEM TIM
i find it very informative too
Agree! You got another GEM from me Tim 🤓
I’m a complete beginner at coding. Do you suggest free code camp or something else?
At around the 4 minute mark you are confusing immutability with references. When you do 'y = x' what you are doing is assigning the reference of the object that x is pointing to, to y. When you assign a new object to x it drops the old reference and now refers to a new object, meanwhile y still refers to the original object. You use tuples in this example, but this is true for lists and dicts. When you change to lists, all you are really demonstrating is that x and y refer to the same object.
With your get_largest_numbers() example, if you were to pass a tuple into the function you would get an AttributeError because you were passing an immutable object which doesn't have the sort method.
Thank you so much for correcting this section of the video. I hope enough people read this and try it so they can correct their understanding of the concept.
Isn't Python treat immutable types (strings, numbers, tuples) as literals, while lists and dicts are basically objects? Once you assign different value to a string or number or any other immutable type variable, you're actually creating another literal object, but the one you created previously still resides in memory and will be purged later, no?
Yes, thank you. This kind of sloppy presentation should be career ending.
Actually, Tim was right and was pointing out the possibly-unexpected behavior one can run into with mutable types:
If you create x, create y with the value of x, and then REPLACE x by creating x again, then x and y will have different values. Try it yourself:
x = [1, 2]; y = x; x = [1, 2, 3]; print(x, y)
If you create x, create y with the value of x, and then CHANGE x by reassigning one of its values, then x and y will have the same new value and the original value will be gone. Try it yourself:
x = [1, 2]; y = x;x[0] = 9; print(x, y)
@@CliffordHeindel-ig5hp your type of comment should be career ending 😂
Some details skipped about *args and **kwargs:
A forward slash "/" can be used to force parameters to be positional only, thereby making them required when calling and not by name. So, def function(a, b, /, c, d, *args, e, f = False, **kwargs) means a and b cannot have default values, are required to be passed when calling function, AND can't be supplied with their parameter names. e must also be supplied with a value when called.
Naming the first * is not required. Doing so simply allows the function to take an arbitrary amount of positional parameters. def function(a, b, /, c, d, *, e, f = False) would require at least 5 arguments (no more than 6) passed to it: a and b are required, c and d are also required and optionally passed as keywords, e must be passed as keyword, f is completely optional, and nothing else is allowed.
/ must always come before *. * must always come before **kwargs. **kwargs must always be last if used.
thanks
I didn't know the kwonly args after *args didn't need a default.
The posonly arg names can also be used as kwarg keys when the signature accepts kwargs.
you can also use "*" to force but I the more apt way is to use "/" I guess
Your description is accurate and provides a clear understanding of the use of /, *, and **kwargs in function parameter definitions in Python. Let's break down the key points:
/ (Forward Slash):
When you use / in the function parameter list, it indicates that all parameters before it must be specified as positional arguments when calling the function.
This means that parameters before the / cannot have default values and must be passed in the order defined in the parameter list.
Parameters after the / can still have default values and can be passed either as keyword arguments or positional arguments.
* (Asterisk):
When you use * in the function parameter list, it marks the end of positional-only arguments and the start of keyword-only arguments.
Parameters defined after * must be passed as keyword arguments when calling the function. They can have default values if desired.
**kwargs (Double Asterisks):
**kwargs allows you to collect any additional keyword arguments that were not explicitly defined as parameters in the function signature.
It must always be the last element in the parameter list if used.
Here's an example function that demonstrates these concepts:
python
Copy code
def example_function(a, b, /, c, d, *, e, f=False, **kwargs):
"""
a and b must be passed as positional arguments.
c and d can be passed as positional or keyword arguments.
e must be passed as a keyword argument.
f is optional and has a default value.
Any additional keyword arguments are collected in kwargs.
"""
print(f"a: {a}, b: {b}, c: {c}, d: {d}, e: {e}, f: {f}")
print("Additional keyword arguments:", kwargs)
# Valid calls to the function:
example_function(1, 2, 3, 4, e=5)
example_function(1, 2, c=3, d=4, e=5)
example_function(1, 2, 3, 4, e=5, f=True, x=10, y=20)
# Invalid calls (will raise TypeError):
# example_function(a=1, b=2, c=3, d=4, e=5) # a and b must be positional
# example_function(1, 2, 3, 4, 5) # e must be passed as a keyword
By using /, *, and **kwargs in your function definitions, you can create more structured and expressive APIs and enforce specific calling conventions for your functions.
He definitely should've included this info in the video. I've learned this before but am not a professional programmer so haven't used it, so seeing it in this video would help non-experts like me.
Also, this can be inferred from the explanations above, but maybe still worth stating explicitly:
Parameters between / and * can be positional OR named. And the function won't work if * comes before /, since the parameters in between would be required positional and required keyword, which creates a contradiction.
I wanted to mention that the if name is main thing is frequently used for test code for libraries. Your code may have some functions to import elsewhere, then you can do examples in the main of how to use them, or try various failure cases, illustrate how to catch exceptions, etc.
Also, to those getting into programming, please do yourself a favor and leave a comment in your code as to what it's for. The most likely person to be reading your code later is you, but if you wrote it 6 months ago, it might as well have been written by someone else, so be kind to yourself.
The GIL can be bypassed by using parallelism which offers about the same capabilities as threads in other languages. This is more of a naming convention issue rather than an actual thing that you can't do in Python. Python threads are still useful for IO and similar async tasks, but they're simply not traditional threads.
It's important to highlight these kinds of things even for beginners so that they don't go out into the world thinking that you can't do parallelism in Python. You absolutely can. It's just called something else.
Hello dear sir,
You mentioned that 'It's just called something else', and what came up to my mind is that another threading library named _thread which is meant for low level threading and also multiprocess library that allows users to run multiple python clients. Am I correct or did you mean something else?
Thank you, that was a bit misleading. How can you do "multithreading" in python then?
@@Joel-pl6lh The library of choice for actual parallel processing in Python is _multiprocessing_
It has a similar interface, but gives you actual parallel computing on different CPU cores.
@@TohaBgood2 That's what I found too, thank you because I'd have thought it's not possible. I wonder why he included this in the video?
Agree, in the GIL part of the video there is a lot of confusion since multi-threading is mixed with multi-processing, and not a clear definition has been provided, which contributes to confuse who approaches to these concepts.
It simply does not exist a multi-threading code, in all the coding languages, that executes threads at the same time
Great content. Keep it up. However, I believe there is a mistake at 3:34. You mention that we have some sort of automatic "copying" going on with "y = x" when using immutable types. This is actually not correct. The assignment still works exactly like with any other object - the reference x is assigned to y. Identifiers x and y are simply referring to the same 2-tuple object. After that, you change what identifier x is referring to (another 3-tuple) and print out the two individual objects. The identifiers are still references - even if using immutable objects.
I might be dumb but don't you mean "x" instead of "y" here:
"After that, you change what identifier y is referring to"
Came here to say the same. The point can be illustrated with this code, x and y point to the same thing:
>>> x = 1
>>> y = x
>>> print(hex(id(x)), hex(id(y)))
0x7f82aa9000f0 0x7f82aa9000f0
@@illusionofquality979 Yes, indeed you are correct. I have edited my comment.
Please do a global interpretor lock, love your explanation style, clear and concise. Keep it up
this is just what ive been searching, please elaborate on python interpretor and how does it differ from C compiler, noting that python is developed in C.
Please do this man!!!
@@adrianoros4083 c compiler is very fast than python interpreter due to the defining of type of variable before compiling
@@xxd1167bro you clearly have no clue what you're talking about
@@xxd1167 If you don’t know what you’re talking about, please don’t post anything. Stuff like this hurts those who are here to learn.
Absolutely brilliant for beginners. Crystal clear. I had countless errors due to the lack of understanding of mutable vs immutable variables
I'm glad I stuck around; I had no idea about some of those other tips like in the function calls.
Because of the GIL, Python multi-threading is not useful for processor-bound computing, but it is still great for I/O bound computing (processor waits for input and output; example: disk read/write or networked data). Multiprocessing is a great way to get around the GIL, when you need to.
It's starts at 1:45, if you're in a hurry.
Certainly! In addition to multithreading, Python also provides the multiprocessing module, which allows for true parallel execution across multiple processor cores. Unlike multithreading, multiprocessing bypasses the limitations imposed by the Global Interpreter Lock (GIL) since each process gets its own Python interpreter and memory space.
By utilizing multiprocessing, you can take advantage of multiple processor cores and achieve parallelism, which can significantly improve performance in computationally intensive tasks. Each process operates independently, allowing for efficient utilization of available CPU resources.
However, it's important to consider that multiprocessing comes with some overhead due to the need for inter-process communication. Data exchange between processes can be more involved and slower compared to sharing data between threads within a single process. As a result, multiprocessing may not always be the best choice for every situation.
To determine whether to use multithreading or multiprocessing, it's crucial to evaluate the specific requirements and characteristics of your application. If the task at hand is primarily CPU-bound and can benefit from true parallel execution, multiprocessing can be a suitable option. On the other hand, if the workload consists of I/O-bound operations or requires a high degree of coordination and shared state, multithreading might be more appropriate.
In summary, the multiprocessing module in Python offers a way to achieve true parallelism by leveraging multiple processor cores. While it circumvents the limitations of the GIL, it introduces additional overhead for inter-process communication, which may impact performance. Careful consideration of the specific requirements and trade-offs is necessary to determine the most suitable approach for your use case.
least obvious chatgpt user
Certainly!
@@excessreactant9045 Yes i using ChatGPT to translate from my Native Language in Englisch + I Used it to put more information in it
😂❤
Thanks. Most things I already know, so my takeaway:
1.) immutable types = C#/.NET valuetypes or Java primitive types, plain data types in C/C++, Pascal and mutable types = C#/.NET reference types or Java object types, C++ reference, dereferenced pointer data aka memory location in C/C++/Pascal/Assembler.
2.) List comprehension is reverted looping writing style (like perl?).
3.) Function arguments look similar to other languages here added dynamic argument *args and ** kwargs little bit like C's ... period argument and function.
4.) __name__=="__main__" unique feature? Easy, but unique, as I didn't saw dynamic caller backreference in another language.
5,) I thought GIL is about single threading
There is an error in the time stamps ,names of function arguments and if __ are interchanged
thanks, just fixed it :)
At around 11 mins another cool thing you could know mention is that if you provide a default variable that is mutable, say a = [], and say you modify the list to look like within the function to say a= [1,2,3], that default varraible is actually now a = [1,2,3] and could create problems if you call that function twice without giving the a argument
Can you clarify what you mean with a code example?
I thought you meant this, but the default value doesn't change in this case (luckily, that would have been disastrous...)
>>> def f(x,a=[]):
... print(a)
... a=[3,4,5]
... print(a)
... pass
...
>>> f(9)
[]
[3, 4, 5]
>>> f(9)
[]
[3, 4, 5]
How would you make the default value change?
@@HerrNilssonOmJagFarBe yes, here you setting the value with the statement, , a=[3, 4, 5],which as far as I know is now stored at a different place in the memory but try instead by having your default value as say a = [1] and then in the function append a value to the list, something like,
def add_item(a = [1] ):
a.append(2)
print(a)
@@ireonus
>>> def f(x,a=[]):
... a.append(2)
... print(a)
... pass
...
>>> f(1)
[2]
>>> f(1)
[2, 2]
>>> f(1)
[2, 2, 2]
Oh.
Well, that's truly weird...!
I also tried a recursing version of f() which made the issue even more spectacular.
So 'a' is local to each particular invocation of the function, but the default value itself is the same across calls?
What happens to the memory that's claimed by the default value once I've called the function too many times.
There is no way to directly reference it outside the function. Can I ever reclaim it (short of redefining the function)?
f.__kwdefaults__['a'] I use this like f(x, *, _cache={}) but have not tested it across imports. Should probably fully understand the implications with good tests before using these for personal projects.
@@kmn1794 Clever. It also made me understand the behaviour. Thanks!
But such code seems obscure and abusive of that particular language quirk.
How many would understand such code? I certainly wouldn't have until I saw this youtube vid.
Threading just takes advantage of GIL "idle time". (aka I/O wait-states)
The Python "Multiprocessing" module allows you to run exclusive processes in multiple cores. (ie CPU-bound applications.).
And (believe it or not) you CAN use threading inside an M/P function if it is coded properly. (according to the rules of MP functions and threads...)
Yeah I was doing this on one of my projects and I'm surprised Tim didn't mention it in this video. Made it seem like you just can't do it at all.
Mojo will solve multi-thread problems in Python. Do you need something fast and it is Python? Mojo is the answer for you.
You are correct. Recently did that
Great video! It might have been worth it to mention multiprocessing in Python as a way to overcome the multithreading limitation that you reviewed towards the end.
The statement you made at about 3:30 was not correct. Writing y = x (where x is a tuple) does not create a copy of the object, as you can tell by looking at their ids -- they are identical. So, there is no difference between mutable and immutable objects in this respect. That line only creates a new variable that points to the same object as x did.
Exactly. Additionally, assignment to x just lets x point to another thing and doesn't modify what x pointed to. That whole part was conceptionally wrong.
Yeah, it seems like he never used a language with pointers, so he never understood the concept of a reference.
This is a great video for someone who is learning python as a second, third, or nth language. These are very python specific implementations of universal concepts and I had been wondering about their purpose when seeing python code.
Should I be worried learning these concepts if I'm thoroughly learning Python as my first language? What should I look out for since I plan to move on to C++?
@@nicjolas I would suggest learning English as your first language... 💀
@@mrtecho brUH
Fiiiiinally I understand those *args/**kwargs!!! Thank youuuuuuu!! 🎉🎉
At 3:30, your description of why changing x does not change y is incorrect and seemingly makes the same mistake many new Python developers make when working with mutable objects such as lists.
The assignment `y = x` does NOT create a copy of the original tuple in y. y and x both point to the exact same tuple object in memory. This can be shown with either `y is x` (outputs true) or by printing `id(x)` and `id(y)` which will be identical.
When you subsequently assign x to a new tuple, x now points at a new tuple object at different location in memory, which you can see by checking id(x) before and after that assignment.
All variables in Python are references to objects. Doing an operation like `y = x`, for any type of object in x, simply makes y a reference to the same object, which is why mutable objects passed as arguments to a function can be mutated by that function. Likewise, anytime you assign a new value to a variable referencing an immutable object, you get a brand new object. if a = 1000, and then a += 1, you also change the id of a to a brand new object of
For some more interesting examples, if you do something like `for i in range(-1000, 1001, 50): print(i, id(i))`, you'll see the id value change for each value, but in most implementations it alternate back and forth between a couple of ids as the interpreter reuses the memory block that was just freed by the garbage collector from the value in the previous loop. The exception is for ints in the range of -5 to 255 (at least in CPython) you'll get a different set of ids because those int objects are pre-allocated when interpreter starts and remain in memory to improve performance, as do the None object and True/False.
I initially rushed through learning of Python's fundamentals. Whilst these things were mentioned, I didn't grasp the concepts until this video. Thanks.
I am currently doing Python courses and i struggle a lot, i like that you distinguished parameters and arguments correctly and basically everything else what you've said is exactly the same things, that i got myself/what i've been told. But it is good to refresh upon those conceprts and methods to proceed with my further studying, because i when i am given a task almost everytime i find it hard to came up with the right solution and fail to get the right approach to it. Thank you for the video. Subscribed!
My cat's breath smell like cat food.
def me_fail_python() -> str: return "That's unpossible"
you're a genius
HI Tim, Just getting into coding: as you know (motivation level throught the roof - then realise html is not a stepping stone but a foundation of things to understand) Well Done on your coding journey! 😅🧐💫💫
At 3:45 with:
x = (1, 2)
y = x
you are not doing a copy, it is still an assignment to an immutable object.
You can check it with:
print(x is y)
This returns True, meaning that both x and y are referencing the same object - a tuple (1, 2).
And of course print(x == y) also returns True, as we are comparing an object with itself.
I have never understood Python this clearly as Tim teaches 🔥
Most important concept in programming: Boolean algebra.
Many programmers do not get that right, but that is the basics of all computation.
3:50
It's also an effect of the fact that the file is read from top to bottom. Line 2 get the evaluated before a line you were to swap lines 2 and 4 with 1 anothen X would equal (1, 2, 3).
Really a *DIAMOND MINE* for coders (especially python coders). I scrolled through your channel and instantly knew this is the channel for python coding and subscribed it instantly. This video was very helpful. The way you explained things shows the amount of experience you have on python coding. Thank you very much ❤❤❤
I'm not a Python developer, I'm an iOS developer (Swift, SwiftUI), I'd love to have people teaching new features on iOS with the same clear and concise speech as yours.
Coming back to Python recently and it’s amazing how many of these quirks I have forgotten.
Thanks for the video! Very consize and informative. The only thing that I would add about the GIL is that it because of it there are no performance advantages when it comes to so-call CPU-bound operations (like summation that was used as an example in the video). But when we are dealing with input/output-bound operations, such as sending a HTTP-request, then multithreading will improve performance, because instead of waiting for response before continuing executing code, we can use that waiting time to make more HTTP-requests. This can help handling multiple requests that are send to your web-applications, for example.
Hey Lina, i also have a django function on which request lands, it was giving timeout error when 2users were hitting the same fn using url, then i increased the gunicorn worker and now it's working fine.
So my qn is, was that a good idea or there is any other way to handle concurrent request on prod. Fyi that fn involve hitting different tables, and storing bulk data in one of tables using orm.
So if you can comment over this about the best way to handle these things. Kindly share.
@@shubhamjha5738 Gunicorn is actually running your Django application on two different instances.
This is really useful, thanks. I know a couple of these but having a video going into the details was great!
about 4:04 your explanation of changing values in mutable v. immutable types is really weird. You eventually get to saying that variables are actually just pointers to objects, and saying x=y is just reassigning the pointers to be the same (in other words, there is an object that y points towards, and executing x=y is setting the pointers to be the same) but you also say that immutable types do a clone instead which is... wrong. Here's some code that can be used to see that:
x = (1, 2)
y = x
print(y is x)
output:
> True
the two numbers should be the same, but should be different each time you run.
The 'y is x' statement is comparing the ids of the numbers, aka where they are in the code. They're the same object.
Some more code to show that 'is' is not just a fancy '==':
x = (1, 2)
y = tuple([1, 2])
print(y is x, y == x)
ouput:
> False, True
Different objects.
Your'e True Legend for us as Python Developer! Thankyou
Great refresher been diging into C++ some time your forget the basics concepts great job thanks
3:30 When you typed “y=x” did it actually _make a copy_ or did it make y _point_ to the original location of x on disk? And then your next x assignment pointed x to a new location on disk? Aren’t x and y just storing pointers? The rest of what you are describing is really helpful (thank you!), just wanted to try to clarify this.
Yes, y and x are pointing and not storing! The memory addresses change after modifying their values
Theres a .copy() method to make, well, a copy. It duplicates instead of just making an association
Tim bro you never disappointed us ..This is straight up golden content...Really appreciate your work...Can we get more videos of you summarizing concepts in under 30mins once a month maybe ?
The explainer of mutable and immutable is really really clear, concise and useful...
00:02 Conceptos importantes de Python
Se presentan cinco conceptos importantes de Python que los programadores principiantes e intermedios suelen confundir o cometer errores al leer código de producción. Estos conceptos son fundamentales para comprender y escribir código en Python de manera efectiva.
01:45 Mutable vs Inmutable
Se explica la diferencia entre los tipos de datos mutables e inmutables en Python. Los tipos de datos inmutables no pueden ser modificados una vez que se han creado, mientras que los tipos de datos mutables pueden ser modificados. Se proporcionan ejemplos de tipos de datos inmutables (como cadenas, enteros y tuplas) y tipos de datos mutables (como listas y diccionarios).
06:23 Comprensiones de lista
Se introduce el concepto de comprensiones de lista en Python. Las comprensiones de lista permiten crear listas de manera concisa y eficiente utilizando una sintaxis compacta. Se muestran ejemplos de comprensiones de lista simples y más complejas.
10:33 Tipos de argumentos y parámetros en Python
Se explican los diferentes tipos de argumentos y parámetros en Python. Se cubren los parámetros necesarios, los parámetros opcionales con valores predeterminados, los argumentos posicionales, los argumentos de palabras clave y cómo utilizar el desempaquetado de argumentos y parámetros.
14:15 Uso de asteriscos en Python
Se muestra cómo utilizar el asterisco (*) en Python para desempaquetar listas y diccionarios en argumentos y parámetros de funciones. Se explican los usos de *args y **kwargs para aceptar un número variable de argumentos posicionales y argumentos de palabras clave.
17:43 El Global Interpreter Lock (GIL)
Se explica el concepto del Global Interpreter Lock (GIL) en Python. El GIL es un mecanismo de bloqueo que permite que solo un hilo se ejecute a la vez en un intérprete de Python. Esto significa que, a pesar de tener múltiples hilos, solo uno puede ejecutarse a la vez, lo que limita el rendimiento en aplicaciones que requieren un alto grado de concurrencia.
hola sergio como estas? soy nuevo y quiero aprender python, que me recomiendas para empezar? no se nada de python o programar pero quiero aprender
3:49 y is not copy of x. After `x=y` , y and x represent name of the same variable, then in line `x=(1,2,3)` you create new variable and named is x.
`x=y` never create copy.
Yes. I think Tim misspoke a bit in this section on mutability vs immutability.
Setting “y = x” creates a second reference to the tuple which was originally referenced as “x”.
This assignment has nothing to do with a “magical” copy of an immutable object.
This can be confirmed with “x is y” and “y is x”; both are “True”. Equality checks (with “==“) are also “True”.
Subsequent setting of “x = (1, 2, 3)” creates a new 3-element tuple referenced as “x” while “y” becomes the only reference to the original 2-element tuple.
I think it might even help to add a 6th must-know concept - “references vs. copies”.
Thank you so much. There is a lack of content on the internet about this. In addition to making things clear, it helped me in my programming midterm too.
I don't wanna be THAT GUY, but actually in the first part, when you do the tuple
x = (1, 2)
y = x
x = (1, 2, 3)
you're actually creating only one (1, 2) set in the memory. x points to that set, y points to the same set, so no hard copy. when you assign a new set to x in the third line, you create a new set in memory and only changes the memory address that x points to.
The difference is that a set has no x[0] = n assignment (since it's immutable), then you're always reassigning.
Your solution for if __main-- = "__main__" legitimately saved my sanity. I was working on an asynchronous endpoint function and i was having difficulty closing the event loop until using that worked!
Thank you, i have been using Python for 2-3 years but didn't know about mutable and immutable types..
Your *args, **kwargs explanation was amazing... Positional Argument & Keyword Argument... You made it very very Easy to Understand the Concept❤️❤️
I'm positive I've used multiprocess pools to get significant performance boosts while trying to do machine learning in the past..
Thank you you are right on point, we miss these understandings and start scratching our head when we get errors.
The info in that 3:40 min is gold. Thank you
I am just learning Python and this video is VERY helpful. Thank you!
Really quality content and you can see that Tim really put some effort in explaining things, making topics captivating, and clear. Thanks!!
Concept 6 for Tim to get: Using type hints, so at 14:32 his IDE could smack him when he is passing a string argument to a bool parameter.
This was simply phenomenal. Brilliantly done.
Hi Tim, Great content as always. Would appreciate a separate detailed video on GIL
Just to nitpick, it's not pronounced e-mmu·ta·ble with a long E as in see. It's im·mu·ta·ble with an short I as pronounced in "into"
That actually was really good thank you very much
I just finished a code where it was "downloading 10 files at a time which is 10 times faster"... Now I understand why it doesn't work so well :')
🎯 Key Takeaways for quick navigation:
🧱 Understanding mutable vs. immutable types in Python is crucial for avoiding common mistakes.
🔀 Immutable types like strings, integers, floats, booleans, bytes, and tuples cannot be changed once defined.
🔄 Mutable types like lists, sets, and dictionaries can be modified after being defined.
🔄 Assigning a mutable object to another variable creates a reference to the same object, affecting both variables if modified.
📝 List comprehension simplifies code by creating lists in a concise manner using for loops.
📋 Python supports various argument and parameter types, including positional, keyword, optional, and special types like *args and kwargs.
⚙️ The "if __name__ == '__main__':" statement allows code to be executed only when the Python file is run directly.
⚙️ Python's Global Interpreter Lock (GIL) restricts simultaneous execution of multiple threads, affecting multi-threaded performance.
Made with HARPA AI
Multithreading is highly advantageous for tackling large problems. I suggest creating a video to elaborate on its benefits for our audience.
Thank you for reassuring me that i have a very long way to go to reach intermediate level.
In the first four minutes of the video, there is already a mistake.
At 3:40, the video states that when you do x = (1, 2, 3) and then y = x, you are creating a copy of the object. This is incorrect. Instead, you are making y point to the same reference in memory as x. This applies to all types, whether mutable or immutable. You can prove this by simply doing x is y (which will return True) or checking id(x) and id(y) (both will have the same value).
This invalidates the whole narrative of mutable vs immutable in the first 6 minutes of the video.
This happens in most programming languages (if not all), not just in python.
4:35 so is it accurate to say that when x was originally an immutable object like a tuple, and when assigning y = x, then x is passed "by value"?
And when x was originally a mutable object like a list, when re-assigning x using y = x, then x is passed "by reference"?
Hi, Tim. Learning lots of things from you! Many thanks from South Korea.
Please make an entire GIL video!
Great explanation style, thanks for your work!
So you seem to be confused about the way immutable objects are stored in memory. 03:37 when you write y=x it doesn't make a copy or x.
Instead, both x and y point to the same tuple in memory. When you then assign something else to x, y still points to the same tuple and python's garbage collection will not free the memory.
In fact one of the reasons to have immutable object is precisely to avoid having to make physcal copies of it in memory.
Hope this helps
In which situation is it better to use if name == __main__ rather than split the given script into {a runnable program + a package that only defines stuff} ?
I think it's just a way to keep your project clean, by for example including a simple example/test within the same file instead of having to create another file like 'modulex_example.py' that the user may or may not find.
@@bryanreed742 Thanks :)
Dear Tim, regarding Section 01 (mutable vs immutable), if we use string as an example, is the following program a good example ?
fruit = "Apple"
print (fruit) # Output: "Apple"
fruit = "_pple" # Allow
print (fruit) # Output: "_pple"
print (fruit [0]) # Output: "_"
fruit = fruit[0] = "A" # Not allowed
So new to learning python, specifically for data collection and use in Marketing/Digital. My question between immutable and mutable would be use case.
My assumption would be that you use a scraper etc. to collect data, then define that as an immutable data type, aka. store the raw data as a string. To manipulate/work with the data, you would then pass that string to a mutable data type, I'd assume a dictionary. From that, you can then pull sections of data, organise the data etc., and clean the data to be able to use it for statistics/interpretation. That way the original data is preserved and cannot be corrupted, but you're able to make as many copies of the raw data for whichever transformations you may need to make and use those different mutable copies for each required purpose. Would that be the correct thinking?
16:34 Sir, we can import concurrent.futures and multiprocessing modules for multiple cores and parallel executions.
thanks for the vid Tim
3:50 So and C++, If I want extremely fast applications, I do not allocate memory all the time .
I try to allocate my memory up front and any manipulation happens with that existing memory .
The idea that you have to create another object to make an assignment is purely useful .
Because I have infinite control over the memory and I know exactly what I am doing, I can write extremely fast and extremely stable code
Please do create a short video(5 mins) on MultiProcessing for folks who are unaware of true parallelism in Python.
Crazy, I just started watching this video and the speech intonation is exactly the same for almost every computer/video game/programming video on TH-cam. "We like..to talk..like thiiiiiis." Im going to finish watching it because I need something in the back ground
18:33 - Hi, are you sure there is no efficient way of overcoming it? (to use multiple cores)
great video finally getting to catch some of the basics through a project based tutorial wish is a great way to know how to implement the basics thank you for your effort
Example at 3:33 is not relative to mutable/immutable. If change to list, result will be the same. Attempt x[n] = m for tuple and list actually will explain all
Thank you sir. You getting old😅 can remember your first pygame turorials i followed years ago. Wow Kudos sir keep it up!
3:33 That tuple vs. list example is a flawed false analogy. If you take the tuple example and replace () with [] (without modifying anything else in the example), you will get the exact same outcome: y holds a reference to what was formerly referenced by x (until x was set to a new reference). Example: x = [1, 2]; y = x; x = [1, 2, 3]; print(x, y)
And nope, the tuple did *not* get (deep) copied. Example: x = (1, 2); y = x; x is y ← This returns True. No deep copies involved.
Very cool, finally I could understand what GIL was about
in your example at 5:00
What is the point of putting return numbers [-n:]? Not sure why you would make it negative. Also why not just return numbers? and also why did you put a 2 there? As far as I can see the two isnt actually doing anything.
I wrote my own version of your example and it sems to be doing the exact same thing but a lot simpler:
def getlargest(nums):
nums.sort()
return(nums)
nums = [1,23,4,5]
print(nums)
print(getlargest(nums))
Thanks for clarifying these concepts Tim!
This video has actually closed some gaps in my understanding of Python. It's truly a very cool and useful video, thank you
Dude!!! That was a great tutorial. There are so many "beginner" python tutorials out there and it makes it hard to find the more advanced ones. I learnt a bunch! Thanks!!!
I don’t think you understand the first concept.
Statement at 3:43 is wrong. Assigning immutable value of x to y on lime 2 does not make a copy, but makes y refer to same object as x. But on line 4 a new immutable object is created and x now refers to that while y still refers to the old object.
Finally someone who has streamlined the nitty gritty... Every other tutorial treats you like you have never seen a computer lol, just a video idea, "most encountered python programming statements" or "intuitively understanding coding arguments in python"
Thanks a lot for this tutorial as improved my understanding a lot. Request to kindly upload more of these beneficial vedios. 🙏🏼🙏🏼
I am using multiple threads in Python to request APIs, since most of the time I am waiting on result from the request or db query or smt like that. If I have 10 threads and each sends request and then waits for response (other threads in the meantime get also to work and send requests one after another), I can run my scripts 10x faster. From a 3 hours runtime where I do a lot of API requests and db queries on around 100k samples, it will finish in around 22 minutes now with a Pool of 10 threads running.
So the GIL is still present, but each thread can pass it up to another thread when waiting for a response probably? That is my way of understanding it. And it is a way how to use threads in python and benefit from it
Yes in the case where you are waiting for responses certainly this is a good use of threads!
About 5 minutes in...
When you called your function
Get largest numbers you passed it into a variable called largest? Then you printed a different variable called nums.
I would have assumed you would have printed: print(largest)
Could you clarify what the variable largest was for if it was not used.
Thanks
3:25 Not quite correct. When you said y = x it did NOT make a copy. It made a copy only when you then said x = (1, 2, 3). Python's assignment operator just binds to whatever object the right hand of it returns. For some immutable objects like low integers a python implementation may actually always use the same object. For example if we say x = 3 and then y = 3 then its likely that x and y will be the same object. The idea is that it doesn't matter for most practical purposes if an immutable value is the same object or not so that the implementations are allowed to just make them the same object for efficiency purposes.
Yes I recently read a article on it
Can someone recommend roadmap for automation in python? Do I need to learn DSA or how much basics should I know before I get into automation. My main focus is to support my devops practices. Thank you
6:00 Can you please explain in which cases it is beneficial to make these side effects happen ?
I don’t see any case where it’s actually helpful in addition to being confusing.
I recently ran across *args, **kwargs in some code I was stealing, uh borrowing, and it might as well have said *abra **kadabra because I didn't really get how it worked. You made me understand. Thanks.
Thank you for this video! Very clear overview of important concepts in Python
This video made the concepts much easier to understand than others that I have seen. Thanks so much!
Hello, I am learning to program in programming expert, so far a great experience🎉
Man this video was phenomenal ! Thank you. I'm taking CS50P and its intense lol
I didn't know about the "GIL". Your explanation gave me the answer to a question that I had parked for some time: why did concurrency not speed up a specific function that processed a very large list? I hope this will be fixed soon.
Pure content....this is so basic but most of us never pay attention to this....and boom interviewer asks this 😵💫
should I always use a double * with "kwargs?" For example, if I don't have *args, do I still need to write it as **kwargs or can it then be written as *kwargs?
what does TIm do for a living? he's fkn SHARP!