วีดีโอ

Thanks!

That happens automatically withing JupyterLab with an extension.

Which extension, like MS Word?

Glad it helped!

My pleasure!

Thanks :)

That is actually a wonderful observation you made. I like the term "manager". It's not formal but explains the idea in a beginner friendly way. Thanks!

The `random.random()` function allows us to fine-tune the probabilities in a way more convenient way than the `random.choice()` function. Think of the expression `random.random() < p_heads` which is `True` exactly "p_heads %" of the time.

Hi. I think you unfortunately watched the old playlist on the Python contents in my book. Here is the newer videos with shorter videos and video titles on a per topic basis that make a lot more sense: th-cam.com/play/PL-2JV1G3J10kRUPgP7EwLhyeN5lOZW2kH.html

Hi Richard. There is no such method on any data types in Python, at least not the built-in ones. You are confusing them the ".is_float()" method a) with the ".is_integer()" method on the `float` object or b) you simply want to know if an object is a `float` which you can find out with the type(obj) function

Because the pro's all use Linux and not Mac ;)

Just kidding. Double D should work in Mac as well. You probably forgot to "leave" the cell with the "Escape" key first. Let me know if that works.

I have solved this following your instructions. Thanks.@@webartifex

Thanks :)

Really?

Nope. ".sort()" belongs to other data types, e.g., the list data type

Noted!

Glad you liked it!

i will do that for my next recording of my lectures :)

Thanks

That part you mention is the MAIN difference. In addition, because of that difference, tuples do not have methods that mutate a list.

You are welcome!

You're welcome!

Lists within lists may lead to "weird" situation from a beginner's point of view, especially if the outer list is copied somehow (or sliced). That happens because then we have more than one outer list referring to the same inner lists, which are not copied.

Yes, practically, runtime errors can occurs. Python by default can only store up to 3000 concurrent function calls in memory. That number can be changed but will always be some finite limit. Beyond that, we will see an error message

The word "subsumes" here means "contains" => Therefore, the opposite is true: A substring IS subsumED by another string

And PEP8 is only considered the bare minimum style guide. In practice, people use even more styling rules

What do you mean with further changes?

From how I interpret your understanding of "dynamic", that is exactly what f-strings are for: They are a template containing a "dynamic" part

Kind of: "dir(math)" shows all the functions and constants while "help(math)" shows even more descriptions

In Python, if you can find a looping solution, it will be more memory efficient because Python then does not need to manage all the ongoing function calls

Which part?

They are useful in places where one needs to provide a function however there is no need to call that more than once. (Normal) functions with names are mainly there to be re-used!

Great attention to detail you have. Generally, a mere function call is only an expression and should not have a side effect. However, as you noticed, we can create "modifier" functions that kind of have a side effect. However, such "modifier" functions should not be created in the first place (i.e., a best practice). Instead, one should create methods that modify objects. To fully understand that, see Chapter 11 in my book. But really, great attention to detail.

th eiterative approach is much more efficient because it only looks at the two predecessor numbers and does not need to store the other numbers in memory. Therefore, it needs less computing power and memory. The recursive approach looks at the whole thing and therefore needs exponential computing power which is a lot more inefficient and the reason why this approach only works with the smaller numbers. Hope this helps. Please correct me if I am wrong here @Alexander Hess - Pythonista

Kind of. The iterative version does all the individual computational steps only once whereas the recursive version re-computes the same individual steps over and over again.

Glad you enjoyed it!

Glad it was helpful!

Glad it was helpful! At first sight, iterators seem a bit "advanced" but they are really everywhere in Python and are very powerful in the context of big data.

Yes, but the reverse is not true. Expressions are all code fragments that are evaluated into objects (i.e., "results") by the Python interpreter. The concept of statements contains the concept of expressions in addition to statements that do NOT evaluate into objects. Such statements have a (permanent) side effect in the computer's memory though (e.g., the assignment statement creates a variable name).

@@webartifex had exactly the same question, thanks for clarifying

Noted!

Not really. In your picture, it is almost the opposite. The concrete ones are "subsets" of the abstract ones. Yet, the term "subset" is wrong here. For simplicity, see the abstract types as simply "group names", and the concrete ones are then put into various groups depending on their behavior.

Good idea. The next version of the videos will do that then.

You're very welcome!

No. Or I misunderstand your question. Once there will be only more 0s to the left, the notation usually cuts them off, just like leading 0s in the decimal system.

That is a good point. An absolute beginner may not understand the difference for indenting and not indenting. I'll take that into account for the next version :)

This really depends on the exact logic one wants to model. The point here is that the "elif"s are only checked if the preceeding "if" does not apply.

Because we are checking for conditions that are INDEPENDENT of each other, in a conceptually way. Also, note the "early exit pattern" at work in the example. So, I leave out a lot of "else"s and "return" from the function "early"

To summarize: In terms of computational steps, there should not be much of a difference. In terms of memory usage: recursion needs some memory to keep all the functions running before the recursion returns. So, in practice, the looping approach is often regarded as a little better.

There is no way to answer this question briefly :) For detailed info, search for "Python virtual environments" on the internet, or the "Python import system" (there is actually a nice but technical talk on a PyCon TH-cam channel on that). What you should know, in brief: 1) Besides the "system" Python (on Linux or Mac) which holds all packages available everywhere, there may exist 2) "copies" in so-called virtual enviroment, which are typically used on a per-project basis. 3) !pip in JupyterLab installs into whatever Python folder that is currently running JuypterLab. I should do a talk on this at some point because it's a topic of much confusion. Regarding the imports, they are indeed relative (or absolute) depending on how you import.

The practitioner may wonder why he should learn such things. But the binary system is at the heart of a lot of CS theory and I think is quite an interesting thing to know as a person living in the 21st century :)

What a program does when running out of memory depends a bit on the programming language. Typically one would observe a computer freezing, or at least the program in question becoming unresponsive. Yet, in Python there is a fail safe system built in that simply quits the program with a MemoryError message instead of the computer freezing. In both cases, the program most likely will not save anything permanently onto a hard disk and whatever data/state is in the (working) memory will then be lost.

Absolutely, it is an error occuring during runtime. Yet, experienced Python dev's would tell you that there are actually ways to discover TypeError's WITHOUT running the code. But that is beyond this intro video.

The answer to that needs some more theory that I think goes too much into detail. The correct answer is that the number of digits modeled in memory depends on the magnitude of the number. Numbers closer to 0 in abs. terms have more digits. Yet, it's a good practice to pretend there are only up to 14 digits as that is the lower bound that works for all floating-point numbers. If you are really interested in this, check the the wiki page on the floating-point standard :)