Python 101: Learn the 5 Must-Know Concepts
HTML-код
- Опубликовано: 21 май 2024
- See NordPass Business in action now with a 3-month free trial here nordpass.com/techwithtim with code techwithtim
If you're interested in becoming a developer that writes any type of code in python, then you need to understand these 5 Python concepts. In today's video, I'm going to break down 5 key Python concepts for any aspiring developer. Master Python, elevate your skills.
💻 Master Blockchain and Web 3.0 development today by using BlockchainExpert: 🔗 algoexpert.io/blockchain (Use code "tim" for a discount!)
💻 Accelerate your software engineering career with ProgrammingExpert: 🔗 programmingexpert.io/tim (Use code "tim" for a discount!)
🎬 Timestamps
00:00 | Introduction
00:38 | Sponsor
01:43 | Mutable vs Immutable
06:20 | List Comprehensions
08:22 | Function Argument & Parameter Types
14:44 | if _name_ == "__main__"
16:34 | Global Interpreter Lock (GIL)
◼️◼️◼️◼️◼️◼️◼️◼️◼️◼️◼️
👕 Merchandise: 🔗 teespring.com/stores/tech-wit...
📸 Instagram: 🔗 / tech_with_tim
📱 Twitter: 🔗 / techwithtimm
🔊 Discord: 🔗 / discord
📝 LinkedIn: 🔗 / tim-ruscica-82631b179
🌎 Website: 🔗 techwithtim.net
📂 GitHub: 🔗 github.com/techwithtim
One-Time Donations: 💲 www.paypal.com/donate?hosted_...
Patreon: 💲 / techwithtim
◼️◼️◼️◼️◼️◼️◼️◼️◼️◼️◼️
⭐️ Tags ⭐️
- Tech With Tim
- Top 5 Python Concepts
- Master Python
⭐️ Hashtags ⭐️
#techwithtim #top5python #pythonprogramming
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
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 😂
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
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.
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.
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.
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.
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.
There is an error in the time stamps ,names of function arguments and if __ are interchanged
thanks, just fixed it :)
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.
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
😂❤
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.
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++?
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!!!
Really quality content and you can see that Tim really put some effort in explaining things, making topics captivating, and clear. Thanks!!
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.
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.
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.
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! 😅🧐💫💫
Thank you you are right on point, we miss these understandings and start scratching our head when we get errors.
Hi Tim, Great content as always. Would appreciate a separate detailed video on GIL
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.
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!
This video made the concepts much easier to understand than others that I have seen. Thanks so much!
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
Great refresher been diging into C++ some time your forget the basics concepts great job thanks
The explainer of mutable and immutable is really really clear, concise and useful...
In a long time, I kept thinking that multiple-threads speed up my process until I watch your video. Great video Tim! Hope that you will make a video about this crazy global interpreter lock.
As usual, great work! Nothing fancy, well explained! Thx!
Most important concept in programming: Boolean algebra.
Many programmers do not get that right, but that is the basics of all computation.
Thanks for clarifying these concepts Tim!
Interesting and amazing video, Tim. I’m currently learning Python and I was struggling with some concepts until I saw this! Simply thank you and greetings from DR 🇩🇴
Ya tu sabe
This video has actually closed some gaps in my understanding of Python. It's truly a very cool and useful video, thank you
This was simply phenomenal. Brilliantly done.
Great explanation style, thanks for your work!
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 ?
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.
Your'e True Legend for us as Python Developer! Thankyou
I am just learning Python and this video is VERY helpful. Thank you!
This helped me alot, thank you. What about multiprocessing though? I know it's not a standard module but it does say in the Docs that it does side step the global interpreter lock. I've been thinking of trying it out.
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.
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 so much like the way you explained.. It's fantastic. and as well like your content, it's beneficial
Thank you for this video! Very clear overview of important concepts in Python
Fiiiiinally I understand those *args/**kwargs!!! Thank youuuuuuu!! 🎉🎉
Thank you for your demonstration of mutable!
Thanks so much for so many useful videos. Can you please take some small Python projects and show the requirement gathering, design, and development of it?
Thank you for the video! I find it very interesting how you show how to work with Python.
Hi, Tim. Learning lots of things from you! Many thanks from South Korea.
Please make an entire GIL video!
thanks bro tim, love you for your time , you are a hardworking individual :)
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.
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?
Great video/content,
definitely want more informations/contents about GIL and multiprocessing in Python/Cython ;-)
Thanks you for your work !
Thanks for the info as always! Really helpful
Multithreading is highly advantageous for tackling large problems. I suggest creating a video to elaborate on its benefits for our audience.
Very informative, thank you!
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 :')
thank for sharing, this is very important to beginner like me.
Thanks for the help TechWithJim!
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).
It's starts at 1:45, if you're in a hurry.
Your *args, **kwargs explanation was amazing... Positional Argument & Keyword Argument... You made it very very Easy to Understand the Concept❤️❤️
I appreciate the tutorial! Great job!
hello Tim, I have a question. Do you have any recommended courses for learning django or flask?
good video! I learned few new things. thank you.
I am always surprised how informative your videos are. I have a question, what's the point then to have multi threading in python if only 1 is being executed at a time ?
Also Tim, I would love to see a video about top 5 useful algorithms in programming.
There are a few good answers to the in the comments 👍🏻
Threads occur concurrently, while processes occur in parallel. Threads are better for I/O bound operations while processes are better for CPU bound operations.
Thanks a lot for this tutorial as improved my understanding a lot. Request to kindly upload more of these beneficial vedios. 🙏🏼🙏🏼
Incredible, love seeing your content. You inspired my learn a lot of my current programming knowledge and curiosity
Bro, your videos are awesome!
Thx
Thanks, I wasn't sure about the second to last and never heard of the GIL.
I appreciate the explanations, thanks for the video
super useful
thanks Tim
Thumbs up. Tq Tim. Good tips.
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, I really appreciate this video. It has been really helpful to me on my Python learning journey. :)
I would like to know more about the GIL!
I love your videos because you distill the essence of what is important of these complex topics. I can say I have never fully understood the functionality of if __name__== __main__.
I thought this was just something you do to initialize a class. Thank you for making this concrete.
thanks for the vid Tim
Nice video, can you also make something like this but for the C++ program language?
Another awesome py video thanks man!
Thank you sir. You getting old😅 can remember your first pygame turorials i followed years ago. Wow Kudos sir keep it up!
I LOVE the transition music
Very informative for beginners! Thanks you for putting this together!!
thanks tim for sharing these
Very useful video ❤ keep up the good work tim😊
Thanks for this video and also to share your knowlege.
Very good video, i am saving to see it one more time!
My cat's breath smell like cat food.
def me_fail_python() -> str: return "That's unpossible"
you're a genius
Really helpful video for pythonistas trying to become better
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!
I'm not a Pythonist, so maybe I'm messing with some insiders language, however, the first section "Mutable vs Immutable' seems to me like it's dealing rather with "reference type vs value type" problem. At least in other languages, reference types can be either mutable or immutable, which refers to if the object's value can change or not. But the phenomena shown in this example, with assigning a list to another variable, or passing it to a function and then observing both variables change when either of them is modified, this is (as the author stated) because both variables are references to the same object. Wether that object is mutable itself, that is yet another topic.
THANK YOU TIM!!
good stuff thanks, I'd love to see real life examples of when you would use *args and **kwargs for functions.
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.
I love your knowledge on Python 👍😃
Your videos are great! The only problem I'm having is, the text, at the bottom of the screen is covering your examples when you run the code...
16:34 Sir, we can import concurrent.futures and multiprocessing modules for multiple cores and parallel executions.
Thanks Tim can you discuss the different libraries also I was told that if the code is made not to rewrite it. How can I go about finding these codes
Hi there, In the args and kwargs section. I am getting the feeling, that using kwargs seems to be the cleanest/fail proof way to deal with arguments. In what scenarios would args be better? Any thoughts?