Python is learning from iPhone and just skipping numbers that are bad for marketing, like the unlucky number 4 in Japan xD

I thought it said "Python 5," too, and I was initially like, "Wait a minute, what the hell?"

Wait till you hear about Python 95 and Python 98 😂

Yes, David Hilbert said if he were awoken in 100 years, his first question would be -has the Riemann Hypothesis been proved- what version of python is in beta?

commenting to share that was my immediate reason for clicking this video too lol

Agreed

I learned something today.

ooo... I like that.

It's not the worst name, it was inspired by assembly loops, where you have an if(generally a jump too but whatever) block which executes iteratively using jumps and we can kind of use an else here

I agree very much with this sentiment. I've used it in many scenarios where it made sense to use it. The feature is great, but the naming could be better. Cool that "else" makes sense in the context of assembly jumps, but it just doesn't make any sense in the context of Python.

C doesn't have a string concatenation operator, Python does. Python breaks with tons of C traditions (it's one of very few who put bit operators &, | above comparisons ==, > etc in the priority table!) - and it has a philosophy of 'one correct way', so making the + concatenation optional goes against its core values.

​@@sharpfangThe "one correct way" has been broken many times; it is merely a preference. It is in no way to be followed. PEP 584 directly addresses this. "In practice, this preference for “only one way” is frequently violated in Python....We should not be too strict about rejecting useful functionality because it violates “only one way”." The language "violates" the philosophy when there's a good functionality, multiple times throughout its history.

@@moho472 Except this functionality generates very hard to catch bugs, so it's very arguable if it's a good functionality.

@@sharpfang That could be said for every single language, and is not unique to Python.

I do agree, implicit string concat is just unnecessary, and it kindof forces one to use a linter to catch stray cases like strings inside a list, for the expense of code looking a bit nicer in some cases.

Personally In day to day code; If I have a try...except block I'm NOT expecting a exception to happen, I PREPARE my code to RESPOND to something in the case it happens, but sure enough I'm not expecting it to happen, because the proper and complete execution of the code depends on the program not triggering an exception (I guess there are special task that the normal execution path expects or requires an exception to be triggered... I would never write code like that tho); but depending on the exception to execute to achieve a task seems counterintuitive on 99.99% of tasks. It's like paying insurance: You don't pay because you expect to crash your car, you pay just to be able to handle the UNEXPECTED event of a crash... Just thinking on having to debug code, that depends on a exception to happen to achieve the normal program flow gives me a headache. They are called "exceptions" for a reason: They respond to EXCEPTIONAL conditions in the program, not to the normal and desired conditions. I LIKE the else in the try block, as it allows to handle the correct execution path in a very elegant way, but NOT to respond if there where not an exception that I was expecting for. That's extremely counterintuitive.

@@setsunaes For loop iteration for example depends on the iterable sending "loop over" exception. As an example of expected exception

Unless they've changed this behavior, you _can't_ have it without an "except" even though you can have a "try" without an "except" ("try . . . finally"). Thus, it's really "except . . . else", because either "except" or else "else".

@@MAlanThomasII Exactly. So it actually makes sense in that context.

It makes sense to me because i think of except as "if exception." I never knew it worked with loops though, that behavior is weird.

@@Fanta666 This. The alternative is `except` being replaced by `if except`, though the suggested alternate syntax of "noexcept"/"nobreak" is also an agreeable compromise.

@@MAlanThomasII What would you use "try...else" for? If this were valid syntax, I would just remove it because there's no difference between "try: print(1) else: print(2)" and "print(1); print(2)". Don't be silly.

Way back when python first started catching on, there were some variants which added back in (optional) typing, blocks denoted by curly braces, ect. I liked that. But alas, most folks didn't... The lack of strictness is a bit of a tradeoff between ease for small stuff and scripts, and making it harder for large/complicated things. However, the real brilliance of python IMO is being able to fairly easily include lower level C and C++ code as modules. It also beats the hell out of perl

completely agree, that's the one that's totally unintuitive. It should be for ... then ...

@@francoismolinier6924 this makes a lot more sense!

This made me screw up a leetcode problem

Oh dear, I did not know that... although I think the only time I ever used that, was when I was creating a numpy array, which I'm pretty sure creates a deepcopy.

Luckily the list comprehension for this isn’t too hard; it’s just [[0]*5 for _ in range(5)]

this is good, because lists aren't arrays, and you should not be using them as arrays. Use an array, otherwise you are violating POLA.

@@DrDeuteron well, what are arrays in python?

R is used a lot in my field. I do my best to avoid it like the plague.

Messing up your nesting is just a skill issue

the 'else' in 'for' and 'while' I would expect means 'if there were no elements reached by the loop' which is nearly the opposite of what it actually means

​@@MagicGonadsThe idea is that you'd often loop to find some particular element. If you find it, you break out of the loop and continue from there. But if you reach the end of the iterator... Well, now, you need to do something else. This something else in case of this failure, you'd put in the else block, knowing it's only ran if you failed to break out of the loop.

@@gJonii but semantically 'for all of these things, otherwise this' is what a construct 'for-else' would mean intuitively, is what I'm saying. For loops may often be a search, but not every for loop is a search.

Yeah, its very confusing in the for and while loops, and even for the try/except i feel like its not even worth it. A "nobreak" or even a good old "then" would make it much clearer But the whole thing could be much less ambiguous by explicitly setting a boolean variable (e.g. found, error, etc) before the loop and changing that variable in the same line as the break/exception, then using an if after the loop to explicitly run some code if the variable was changed. You don't need a new keyword for every possible scenario, or else we'll end up with a "noop" keyword for when the loop is iterating over an empty list or something

@@sutirk yeah my interpretation of how 'else' would work would also be called 'empty' (the case in which the iterator is empty) and often you just handle this explicitly

sain?

A trip abroad where you aren't allowed to use the toilet?

without the “s”?

obviously a programmer as they made an off-by-one error

@@ShunyValdez shallow copies are: >>>func = functools,.partial(filter, 's'.__ne__) >>>"".join(*func(''Spain'.casefold())) 'pain' is safer. Why index?

Yes. The exception may occurre at a really deep level. In the Rust language, when a function is able to error, it returns an enum Result with Ok(value) or Err(Error). Yes, enums have values inside in rust.

@@denizsincar29 That's because what Rust calls an "enum", languages with saner naming conventions would call a "sum type". Calling them enums is _really weird._ And yeah on the main topic, catching Exception is _good practice._ What's the alternative, just allow your program to blow up when it comes across an exception type you didn't anticipate? Exception is a base class of the other exceptions for a very good reason.

@@isodoubIet If there's an exception of type you didn't anticipate, it seems the only sane way to handle it is to allow it to blow up the program.

@@gJonii And then you'll never find out because it won't be logged, your customers will call asking why the service is down, and you'll have no idea why. "Allow it to blow up the program" is never acceptable.

@@isodoubIet This is not necessarily true. Unless the exception is expected and can be handled in some way (maybe how it should be handled is logged and forcing the user to redo the previous step), allowing a program to continue in an invalid state that caused the exception in the first place can lead to problems like security leaks, bugs, etc. In many cases, it is better for a service to be down and fixed rather than broken and running.

Yeah I agree, the for-else blocks require you to think of a for loop as a series of checks for which "breaking" is the sign you've found what you're looking for. Most people are taught that loops are for doing something, and break is for when you want to stop doing that thing early...which is kind of conceptually the opposite. I don't read it as applying if there were no interactions at all though, I read it as "if any of them failed (had a break)"

it does run the else block if the loop had no iterations. It's useful if say you count successes: for count, item in enumerate(container, start=1): break else: count = 0 print(f"Found {count} items) w/o the else block, you get a NameError, and to prevent that you would need to predefine count=0, which is U G L Y, and unpythonic.

The use case presented for it is element search. You loop over an iterator, searching for some element. If you find it, you'd have "if element == target: do stuff; break" But now you'd write code after the loop. Can you trust you've found the element? Perhaps not. Perhaps your loop just ended naturally, and your cool break logic never ran. What to do then? How would you even know that happened? Enter else-block. It's only ran in this scenario, so you know your break-logic was never ran. You'd have absolutely no benefit from this also-block that runs if broken out from loop, since you could put this logic manually to the "if condition: break" section for much more readability.

FYI if you want to run code when a for loop is broken, the way you would do that is to put the code before the break. Something like: for x in xs: if x is None: print("Got unexpected value, breaking loop") break else: print("Processed all values successfully") You can also kind of see how it DOES make sense with the if. In this example, which is how for...else is usually used, the "else" only runs if the "if" never runs. In expanded form, the above code translates to something like this: if xs[0] is None: ... elif xs[1] is None: ... elif xs[2] is None: ... else: print("Processed all values successfully")

@@gJonii​​⁠that makes sense but it’s weird to me that python cares about this very niche use case but doesn’t have named breaks to allow breaking out of multiple nested loops. Rust lets you break out to any scope you want by name and even “return” a value with your break statement which can be used to solve this problem too. I mean I get it, python is much older and is full of tons of design decisions that we wouldn’t choose again knowing what we know now. But it’s just a bit frustrating when a “low level” language lets me often write higher level code than a “high level” language.

map everything into `id` if it's not a primitive

I'm almost ready to bet, for the people that did encounter it, that they probably didn't notice it. It's not something that messes up your code as much as the user's experience when they read those typos. But I am curious to hear if anyone did experience a major bug because of this?

​@@Indently 2 years in programming. Sometimes I make this mistake myself. Although I always manage to notice it before running the code. But I can easily imagine that it will be difficult for others to notice this mistake. In general, it often happens if I edit an existing block of code. Usually this doesn’t happen to me if I’m writing code from scratch

I think by its very nature, the bugs will be minor. If you are dealing with a list of strings, it's more likely to be loaded dynamically and bypass this language behavior entirely. If it's not, then it should be caught quickly by developer testing or it's going to crop up as a small formatting error with minimal impact to the program's behavior.

I've written hundreds of lines of python over 10ish weeks, and at least twice f'd by that.

⁠@@Indently I did encounter a serious bug in C with the same implicit concatenation I had a big enum for each error case in my program. In my main function, I would get the final status code, and if it wasn’t a success, it would simply do printf(ERROR_TEXTS[ERROR_CODE]). This works only because my ERROR_CODE enum has the same number of values as my array of error strings. Now guess what would happen if, by mistake, you forgot a comma a the 7th element ? Well the error codes 7 now prints 2 errors, everything above error 7 prints the wrong thing, and the last error code just prints garbage (again, C, not python)

Doesn't fix this particular problem since new is called only once at function definition.

forget about speed, just reducing cyclomatic complexity is a win.

he agreed, his only 0xDEADBEEF was the name in the for/while context. I do love the construction, and have no problem with the name...for me it's "BREAK or ELSE"....

"Explicit is better than implicit." literally, from python zen, lol

@@viktor67990 python is literally cluttered with implicit features, this doesn't mean we must not use them. The string implicit concatenation is useful in some contexts, like the ones I mentioned, and it's also performed at compile time, so it's more efficient than joining string constants at runtime.

triple quote strings though

@@viktor67990 The Zen of python is like literally a list of things Python designers decided _not_ to do.

Mostly to drive people away from the language.

You'd almost always want to use a shallow copy on a list containing immutable data. Like a list of strings: A = ["1", "2", "3"] B = a.copy() B[1] = "c" print(A) # ["1", "2", "3"] print(B) # ["1", "c", "3"] Strings are immutable in Python, so you never have to worry about the pitfalls of modifications to B propagating to A. This means that A and B require less memory to store than if B deep copied A, because they both have the same references to elements 0 and 2. So only 2 new objects have to be created (B and "c"). A deep copy would require 5 new objects be created (B, "1", "2", "3", and "c").

When you want the elements in the list to be reference identical. Perhaps they're being used as dict keys, or will share mutations.

bytes() is explicitly made to work with ASCII text, why would you pass in an int? I assume that passing an int works as a handy way to get x number of NUL bytes because otherwise it would be incredibly ambiguous. In your case, should bytes(int("1")) be parsed as 1 in hex (\x01) or as the string "1" (\x31)? What if we pass in bytes(int("111"))? Do we expect it to give us the character "o" (\x6f) or the character "1" three times (\x31\x31\x31)? I guess you can see how it would be useless either way because you're either limited by only outputting the bytes 1-9 over and over again; or your input would have to be made of a concatenated mess of a bunch of decimal values for characters making a truly meaningless int, and which would be even more ambiguous to parse if you consider multiple characters, and then extended ascii and encodings like UTF-8...

Your first question can be answered with a similar question: str() is explicitly made to work with abstract text, why would you pass in an int? bytes(int("1")) => b"1" bytes(int("111")) => b"111" Rationale: int(b"1") => 1 int(b"111") => 111 For non-ascii:: int(u"一") => ValueError, only characters 0-9 are recognized so bytes doesn't have to handle that either. My view on this in general, which should address your arguments that I did not explicitly mention above: mapping an int to bytes *is* ambiguous but it is the same amount of ambiguity as mapping an int to a str and mapping bytes to ints. The decision as to which of the possible outcomes Python will use for those values has been made. So for roundtripping with int and symmetry with str(), bytes() should have been implemented with the same choice.

It's the appropriate type annotation according to the docs.

True. Seems like more of a skill issue

Frankly speaking, if you think shallow copies are a deal-breaker then I think it speaks more about yourself than the language. You mention numerical applications, so I would say the ability to have shallow copies is actually extremely useful for the performance of numerical applications by not having to create deep copies for everything. If you need a deep copy, then you can make a deep copy, but you're not forced to sacrifice memory for deep copies when you don't need them.

What I'm understanding is that list.copy() DOESNT fully copy the nested list. It only fully copies the outer layer elements, and creates a reference to the inner list (which comes from the same memory location as the original list) and thus, editing the nested list of the copy created with the list.copy() method would actually be altering the original nested list that is referenced in the copies list.

@@valerielboss yes, so a_copy[0] *= 2 will also change a[0]. One way to test is evaluate the boolean: >>>a is a_copy False which compares the id()'s. So in his 1st example: >>>a_copy == a, a_copy[1] is a[1] (True, True) while: >>>a_copy is a False. (but I didn't test those in an interpreter, but all pyhtonistas should try it out to learn it).

It gets easier to understand the behavior if you understand memory and pointers/references. In his example, you have a = [1, ["a", "b"], 2] What that actually means is (in some very generic pseudocode notation): mem0 = ["a", "b"] pointer0 = address(mem0) mem1 = [1, pointer0, 2] a = address(mem1) So what "a_copy = a" does is that both variables point to the same memory address: a_copy = address(mem1) In this case both a and a_copy are exactly the same, they point to the same memory and have the same content. The shallow copy "a_copy = a.copy()" copies that region of memory along with every *value* in it: mem2 = [1, pointer0, 2] a_copy = address(mem2) In this case, a and a_copy have exactly the same content, but one of its values is a pointer to another object, so both a and a_copy share this object, and when this object changes it will affect both a and a_copy. Finally, the deep copy "a_copy = deepcopy(a)" actually goes into every pointer and copies that memory region too, saving the new memory addresses in the list: mem3 = ["a", "b"] pointer3 = address(mem3) mem4 = [1, pointer3, 2] a_copy = address(mem4) In this case, a and a_copy have the exact same values, but are completely independent, whatever you change in one will never affect the other, because a references pointer0, whilst a_copy references pointer3.

"else" with while and for loops works completely different than other uses of the "else" keyword, the behaviour doesn't really have anything in common, that's why it's bad

The thing that makes it worse, is that in if else blocks, else gets ran when the if condition is false, whereas else gets ran when a try or while loop finishes successfully. Now yes, you could make the argument that else gets ran when the while condition returns false, but that's not the way people think about it.

​@@b4ttlemast0r The else makes sense if you think about how it is implemented. A while loop would be something like this (Yes, this is a mix of asm and python): :loopstart # your loop content if loop_cond: goto loopstart else: # your "else" code :loopend Now you imagine "break" as "goto loopend". It is similar for try: # try-block if error_happened: # except block else: # else block # finally block I hope you can understand what I mean, this is how I memorize it :)

What kind of limitations? If you want full fledged console UI, there are libs/frameworks for that: curses, Textual, PikoTUI. If you mean handling arguments, then arparse is for you.

@@MrShoorf *argparse

the "readline" module allows fancier input, but I have never used it, so idk if it has what you want.

@@DrDeuteron thanks

@@DrDeuteron thanks

a[:] also returns a shallow copy

@@IndentlyAs said, I’m a beginner, but would there be any benefit in the supplied example (17:41)? The contained list - [‘a’, ‘b’] - is hard coded. I understand that there would have been a difference if the list in the variable “a” were to have contained another list variable. Example: a = [1, 2] b = [a, 3] b_copy = b[:] Then b_copy would, in my understanding, be affected by changes in a, but not by changes in b, nor b be affected by changes in b_copy. By the way, thanks for your informative videos.

That's correct. The slice operator creates a new object with shallow copies of the objects in the sublist you picked. Shallow copies of basic data types are just a new copy of the data. Shallow copies of complex data types are not (Technically it's a new copy of the pointer pointing to the object, but then I'd have to talk about pointers).

​@@bjorn_ It depends on what the type is of the value you're operating on in any given list. When you make a shallow copy of a list, you create a new list containing references to the same elements held by the original list. This means that if the original list contains primitive types (like integers or strings), they appear to be copied. But in reality, the new list simply points to the same memory locations. If the original list contains mutable objects (like lists or dictionaries), these are not copied; both the original and copied list refer to the same objects. So, if you modify a mutable object in one list, the change is reflected in the other. On the other hand, when you make a deep copy of a list, you create a new list and also create new copies of every item contained in the original list. This includes creating copies of all mutable objects. So, if you modify an object in one list, it does not affect the other list. Here's an example: from copy import deepcopy # Original list a = [1, 2] b = [a, 3] # Shallow copy b_copy = b[:] b_copy[0][0] = 'x' print(a) # Output: ['x', 2] # Deep copy a = [1, 2] b = [a, 3] b_deep_copy = deepcopy(b) b_deep_copy[0][0] = 'x' print(a) # Output: [1, 2]

I think I went with "success" because even if you found a match in your for...loop, you then used "break" to break the for...loop, which resulted in not finishing the for...loop. So in terms of the for...loop it was a failure, even if your intent was a success because you found the element you were searching for. I can see we all have different ways of looking at it, so maybe "else" was the most neutral option in the end. But would be fun if Python.org made an official poll for this!

@@Indently we reach the 'else' if a for or while loop control iterator reached its end naturally. So I comment it 'iterator finished' - nothing to do with success or failure of the intention of the loop.

You can divide success and failure sans-loop with: loop = itertools.dropwhile(not_found, sequence): try: answer = next(loop) except StopIteration [failure block here] else: [success block here] finally: print('but idk')

no, because the code path for default and not are different, when the user provides a list it actually does want to mutate it