On this channel, I post videos about programming and software design to help you take your coding skills to the next level. I'm an entrepreneur and a university lecturer in computer science, with more than 20 years of experience in software development and design. If you're a software developer and you want to improve your development skills, and learn more about programming in general, make sure to subscribe for helpful videos.
I post a video here every Friday. If you have any suggestion for a topic you'd like me to cover, just leave a comment on any of my videos and I'll take it under consideration.
There are a lot of people who think JavaScript (of all languages) is better than Python because it is faster. That is such a load of cr@p. As the UNIX gurus knew, "Programmer time is expensive. Computer time is cheap." So I will consider a language that makes me more productive as a programmer far superior compared to a language that runs my code a bit faster. Note that this maxim is from the seventies. Compared to back then, computer time has become many orders of magnitude cheaper, and programmer time quite a bit more expensive. And while Python is from a later age and not quite a scripting language, scripting languages were invented by the UNIX people for exactly this reason.
When handling default arguments, I often use the following line to set them at runtime: `timestamp = timestamp or time.time()` This works if the default value is `None`, because `None` is a "False" value and a valid timestamp is a `True` value. It also uses the fact that Python passes on the actual value of the first `True` element in an `or` operation, and does not evaluate the second value if the first one is already `True`. If the first value is `False`, it yields the second value regardless of whether it is `True` or `False`.
I have a question about dataclass VS normal class. When I use dataclass define one kind of data, at the beginning it is perfect. However, then more and more methods were added based on the attributes of the dataclass and the class is becoming more and more heavy and some of the methods doing something very complicated. I am not sure whether this is a good practice and whether I should convert the dataclass to a normal class. Could you please give me some suggestion about the use case of normal and data classes?
I also read that the function name specificity should be inversely proportional to its scope, e.g. a function collect_and_summarize_invoices might be used once or twice within the same class/module, but if a function is used all over the place, it should have a very short name, e.g. python's "open" function. thank you for another great video.
What if there was a global variable named "T" in the code base ? I know that we aren't supposed to name variables like that. But would the generics still work ?
Also crucial: function arguments should always be annotated with the most general protocol possible, but the return type should always be as specific as possible type as possible.
I disagree about the options object. It’s an approach that is very common in Java and C#, because those languages only know positional arguments, but in Python the configurable fields of the options object are more commonly passed as keyword arguments.
I tried to make this work on classes that takes different arguments like taking differ entire table object, and couldn't able to implement it. I think this approach doesn't suit that I guess
If one can start from A and finish at B by just using function, then why use class? Classes look and feel complicating, more codes are needed to use classes, with no major benefit compared to functions. Seems like classes are only useful in some really edge cases. Thanks for listening to my rants.
You can also define your own types as variables, and the IDE will recognize them as doctypes (at least PyCharm does). Just define, for example: Real = int | float And use it as: def whatever_function(arg: Real) -> Real: ... It works for me in the latest version of PyCharm.
wow. you make VS look so useful. It seems that if you use the docstring helper, you will end up with soem really professional looking docstrings. It makes other people think that you really pay attention to details and make very beautiful looking code. And by using VS, you don't have to expend mental bandwidth trying to figure out what to format a docstring. Nice. You make a good case for VS. If I were a developer, I would def see that VS is a high on the list of preferred ide
when I try to hint that my output is generator, I get an error saying generator is undefined. I have to from typing import Generator as generator. Only then, can I hint def fx() -> generator:
An approach I use is by going a level up to the function that is calling the one I'm about to write. In that calling function, the name and arguments should read in plain English, almost like a story. Ultimately, if you've got your face in a function you can see what it does, but if you are in the outer scope, a good signature means you don't need to dig deeper on that line to reason about what's going on. Great video, thank you!
Even `calculate_total_minus_discount` is ambiguous. Is the discount subtracted per item? Is the discount a percentage of the total? If the discount is a percentage, should the user pass the percentage as an actual percentage (ie 25%) or a fractional proportion (ie 0.25)? Definitely the best function name would be `calculate _total_of_all_items_and_then_subtract_discount(item_prices: Iterable[int], total_discount_as_an_amount_of_money: int)`. If only there was a way to somehow leave a comment for a function that would document such particulars!
A tip I want to share which is slightly related is the “extract function” feature that a lot of IDEs have, which allows you to highlight a code block and press a hotkey to turn it into a function automatically. At least pycharm has this, and I guess you can find extensions for it for most of the popular editors. You can also do the inverse operation, meaning turning a function into inline code).
Regarding options for functions, I think it is a pretty neat solution to use typing.Unpack together with TypedDict. It basically enables you to add keyword arguments to a function that gets type-checked and provides completion. You would get a function signature such as: def function_x(session: Session, **options: Unpack[Options]): ... With Options defined as: class Options(TypedDict, total=False): """Options for function X.""" begin: datetime end: datetime count: int descending: bool I frequently use this when I'm creating functions that wraps an API endpoint or Database model. It allows me to create fairly general functions but still allow customization about for example how many elements should be returned, certain filters, or ordering. In case of a SQLAlchemy model, this could look like: def function_x(session: Session, **options: Unpack[Options]): query = session.query(Measurements) if begin := options.get("begin"): query = query.filter(Measurements.timestamp >= begin) if descending := options.get("descending"): query = query.order_by(Measurements.timestamp.desc()) if end := options.get("end"): query = query.filter(Measurements.timestamp <= end) if count := options.get("count"): query = query.limit(count) return query.all()
Hi Arjan, thanks alot for the Video. What do you think about retuning a bool for functions that otherwise could return None? When using a bool as return one can control the main process by knowing If the function actually did work or would you argue that Program flow determines this anyway? Cheers
(a) I do usually teach my guys to use "Iterator" when a (single) yield-statement is used in a function. The editor may detect Generator as the actual return type but it's not a good idea to be that specific. (b) I do also teach my guys to try to use "None" as the default as often as possible, and the actual non-nullable value can be set in a single line after the header - "value = value if value is not None else default". That's even more readable than a full if-block. In terms of string-values you would also want "value = value if value else default" anyway as usually an empty string is not an acceptable value.
I can't write a function without type hints now, it's just automatic. They are worth using for the IDE hints alone IMO, in Neovim if I have set a function to take an int and accidently returned a string elsewhere, I know before even running any code. Saves a lot of time and frustration in our dynamic typing world.
Maybe that's related to my programming history - I was tought pure C (K&R 2nd ed.) back in the late 1980ies - but how about abbreviating object names ? E.g. "calculate_total_price_including_discount" becomes something like "calc_ttl_prc_incl_dscnt" with arguments abbreviated similarly ? Is this an absolute no-go ? I hope not ... ;-)
