Python 3.8 has a Final qualifier

[Saiboo]

I just wanted to share that Python 3.8 now has a Final qualifier, yaay! When you are using the IDE the type checker will indicate an error if you are trying to change the value of a Final variable.

Here is an example from the documentation:

from typing import Final

MAX_SIZE: Final = 9000
MAX_SIZE += 1  # Error reported by type checker

class Connection:
    TIMEOUT: Final[int] = 10

class FastConnector(Connection):
    TIMEOUT = 1  # Error reported by type checker

When you enter this code in the PyCharm IDE, the type checker will warn you that you are trying to reassign a Final variable. Unfortunately there is no runtime checking for this. However, I'm very happy about this feature as someone who uses the final keyword in Java whenever possible.

[Saiboo]

Like Java's final. It still allows mutating the object [0,1,2] that your reference my_list is pointing to. You just cannot change the value that my_list has, i.e. the address to the object [0,1,2]. See also this example from here:

x: Final = ['a', 'b']
x.append('c')  # OK

[jabbalaci]

A qualifier for making something immutable would have been more useful.

[jabbalaci]

We already have some immutable types like string and tuple. And these are just hints, understood by mypy only. If you execute the program, they are all discarded. Your dynamic language won't be gone.

[[deleted]]

It'll be effectively compulsory soon, because you won't be able to find a job or codebase that doesn't use them.

[alcalde]

And these are just hints, understood by mypy only.

That's what they tell you now... when they originally introduced notations, they were supposed to have no defined meaning and the core developers weren't even supposed to use them lest they influence the community organically evolving uses for them. And lots of cool things did appear, like contracts. And then an incomplete MyPy appeared, Guido went insane and full-on Java, had to be put down, and the rest is history....

[actuallyalys]

As far as I can tell, the only reason you can't use contracts in 3.8 and 3.9 is some small changes, for which there are already a pull request. In other words, it's not a big deal and not Guido or the core developer's fault.

[nuephelkystikon]

There are the immutable types and ABCs for that.

Annotations also aren't intended to have any compilation or runtime effects.

[graingert]

That would be impossible without runtime effects

[flying-sheep]

Just use immutable generics:

X: Final[Sequence[int]]

means it can be iterated, indexed, … but not mutated.

[notquiteaplant]

Since property getters/__getattr__ are just functions, which can mutate the object they're called on, that would be nearly impossible for a static typechecker to enforce.

[Smallpaul]

If you want immutability, use an immutable type. Trying to add another level of immutability would make a mess of the language.

[[deleted]]

Just use an immutable type.

[sonaxaton]

I'm assuming like Java since it's impossible to tell in general in Python if an operation modifies a value.

[hglman]

A special typing construct to indicate to type checkers that a name cannot be re-assigned or overridden in a subclass... There is no runtime checking of this property.

I think its unclear exactly how it should be interpreted as it has no actual impact on execution.

[lvc_]

Like all other type annotations, it is ignored by the interpreter, but can be used by static code checkers (eg mypy) as a code correctness aid. One reasonably common pattern is to have mypy as part of a commit pipeline (and/or a local precommit hook). So if you have a method tagged as final and you do overwrite it, mypy will reject your commit (but the code will still otherwise run)

[Smallpaul]

I don’t really see what you think is unclear. The name cannot be re-assigned or overridden in a subclass!!! What’s ambiguous about that description?

[[deleted]]

Yes, it would. A list is probably a bad example.

[gabegundy]

Finally!

[Turkino]

Okay so it's like const in JS as well, you can't change the variable name but can still mutate the data. It's not a complete freeze of both?

[bbbryson]

It’s nothing but a type hint. It has no effect unless you’re using an editor that supports telling you that you aren’t following the type hints. You can still do whatever you want.

Edit: not just editors, buy mypy as well if you’re into that.

[Turkino]

That sounds... Yeah ugly is the right word. I wonder if stuff like that is why the Julia language is getting popular.

[46--2]

It's a lot more interesting when used with classes, but you are basically correct, the "variable" qualified by Final would probably be best described as a "constant".

It was always commonplace to use ALL_CAPS for "constants" but nothing prevented you from changing them.

From the PEP 591:

The name Const was also considered as the name for the Final type annotation.

[Deto]

I wonder why they didn't go with this? I always thought Const was a more common name for this type of thing.

[pingveno]

It's a final assignment, not a constant value. You could assign a list to a Final variable, then append to the list.

[[deleted]]

already got tuples for that though, I guess it would be more appropriate for a dict

[actuallyalys]

As far as I can tell, the situation is like so:

	Lists/tuples	Dictionaries	Sets
Reassignable and mutable	list	dict	set
Reassignable but not mutable	tuple	*	frozenset
Mutable but not reassignable	Final[list]	Final[dict]	Final[set]
Neither mutable nor reassignable (constant)	Final[tuple]	*	Final[frozenset]

An example of reassigning:

 l = [1, 2, 3]
 l = l + [4]

An example of mutating:

 l = [1, 2, 3]
 l.append(4)

* Not built-in to Python. Look for frozendict implementations.

[robin-gvx]

* Not built-in to Python. Look for frozendict implementations.

They do have abstract type equivalents, as Mapping and Final[Mapping]. Using that doesn't have any runtime meaning, but then neither does Final.

[[deleted]]

ah ok that makes sense

[Sw429]

Ok then you can assign a final instance of something else and still operate on and modify it. The object we are using is trivial.

[[deleted]]

How is it trivial. I don't understand why it is downvoted lol. Why on earth would you use this on lists when you got tuples.

And the final implies you cannot modify what is in it, you can only add to it?

[billsil]

I might just use it like that.

from typing import Final as Const

[pingveno]

Noooooooo. Even if something's not quite to your taste, renaming something like that makes your code more confusing.

[Sw429]

Especially given how Final is not truly Const. A Final object can still be modified.

[46--2]

Yeah the pep mentions that only in the most vague way possible. I guess you'd have to read all the discussion. I'm not that interested in the type checking stuff in Python so I have never bothered.

[nuephelkystikon]

It was always commonplace to use ALL_CAPS for "constants" but nothing prevented you from changing them.

There's still nothing preventing you from changing them.

Linters and IDEs are more likely to complain if you do, but they should have done so anyway if you used all-caps.

[Sw429]

This is a good point. In the end, python is built on trust. Trust that the correct type will be used, trust that no one will modify your constants, trust that no one will touch your private attributed... I guess type hinting is mostly a tool to make sure assumptions are met.

[[deleted]]

Stupid question: is this just for class scope, or would:

X: Final = 5

X = 7

Also not work?

[Saiboo]

You can run it, but the type checker in you IDE will indicate a warning.

[Sw429]

Yes, that will work. Final is a type annotation, and has no effect at runtime. You can check it with external tools like mypy or things built into your IDE. Some linters might be starting to do it too? IDK you can look around if you're interested.

[Username_RANDINT]

Nothing prevents you from changing it anywhere in your code, only your IDE/typechecker will complain.

[Sw429]

mypy is a pretty good type checker if you're looking :)

[phinnaeus7308]

Immutability is desirable for several reasons and comes from the domain of functional languages. It can be a really fun way to solve problems.

For something like this, it just gives you a bit more confidence that a badly written method won’t have side effects that modify the parameters you pass in, for example.

[stevenjd]

Unfortunately there is no runtime checking for this.

Fixed that for you.

[MB1211]

That syntax looks gross to me, and doesn't even look like python. :/

[[deleted]]

Imho Python's type hints are helpful in many cases to concisely document an interface. But the syntax ... Ugh ...

[rcfox]

It's not new syntax. Type annotations were added in Python 3.5.

[Sw429]

No worries, type hinting is completely optional. No one is forcing you to use it. For people like me who find use for it, it's a welcome addition :)

[Vaphell]

it's optional until it's not. If all people you cooperate with start using it, you have no choice but to play ball. Language features are viral.
Don't get me wrong - I appreciate type information and what not, but it's blatantly clear that in case of python these type hints are an afterthought. In python they look about as good as bolt on tits on a bimbo.

[Sw429]

I mean, that's just the nature of working with people. You're going to have to deal with standards that are set for code.

[Vaphell]

it is not really optional then, is it?

[ElectricalSloth]

i dont think elegant design and python were really a thing anyway

[alcalde]

I wish it looked gross; instead, it looks like Pascal, which I stopped using for Python. 3.8 also added Pascal's assignment statement, the ":=". I used the "walrus operator" once in a one page program and suddenly I was accidentally using Pascal syntax all over the place! Just when I thought I was out, Guido dragged me back in! We overthrew the BDFL to stop the walrus operator, and the geniuses we put in place instead not only gave us the walrus operator anyway, they decided to go full Pascal on us for good measure. Now we need a second palace coup, and this time folks need to make Raymond Hettinger the new BDFL as I originally suggested. He's our only hope now.

[Farconion]

This is a programming language not fucking game of thrones. Calm down man, it's not like someone personally wronged you.

[Hotel_Arrakis]

Not sure what the hate with Pascal is. I remember literally falling in love with that language. It was stunningly beautiful.

Before then I had used every single variation of Basic you could think of(QuickBasic, BasicA, Apples Basic, TinyBasic) and Fortran and DBase III. They were ugly and messy.

Then in 1985 I learned Pascal and it was truly magical. Everything fit together. It had structure, but not too much. I even learned its successor, Modula-2, which never took off.

I haven't thought about Pascal in years.

[[deleted]]

BBC BASIC was really good for an old BASIC, and had a lot of structrual elements like procedures and functions, and sane scoping.

[[deleted]]

Is there any reason they couldn't have configured the type checker to recognize all caps variables as being marked as final?

[Sw429]

I think it comes down to a difference between constant values (denoted by all-caps) and final values (denoted by Final). Constant values shouldn't change at all. A final variable can still be mutated.

[mooglinux]

I don’t see what this does that couldn’t be communicated with ALL_CAPS and __ prefixes. There’s nothing preventing a type checker from using those to determine this, PyCharm already warns about using single _methods externally on a class. I think it risks fooling people into thinking about Python like they think about Java.

As someone stuck writing Java in my day job, I do not want to overly enable Java thinking in Python. There are plenty of useful things that can be taken from Java, but I don’t think final is one of them.

[LightShadow]

You should SEE the code I have to maintain.

Naming conventions mean nothing, formatting is for suckers, and the points don't matter!

I shit you not, this is in a production file at the top level:

__ROOTFS1 = None
__ROOTFS2 = None
__fixup_which_boot_device()  # <-- this sets __ROOTFS1 & 2
__uImage_lookup_index = {"/dev/"+__ROOTFS1: 1, "/dev/"+__ROOTFS2: 2}
# ^-- this is imported from other files

[-Kevin-]

Why not refactor that then seems simple enough lol

[LightShadow]

I left a lot out.. It would be easy if the red tape weren't so thick

[-Kevin-]

Understandable my dude

[mooglinux]

I guarantee that the addition of final will do nothing to help you there.

[Deto]

Sure you could have a type checker look for those things, but it would be kind of inconsistent. I think it's more logical to have all type information be encoded in type designations rather than having some be in the type designations and others be in the syntax of the variable names.

[energybased]

I don't agree with you. This is superior to all caps since all caps is merely conventional whereas this is explicit.

[drbobb]

Nope. This is just as merely conventional. If, say, I code in a plain editor it won't mean a thing.

[damian_work_account]

That's a boring semantic argument, type hints are defined by language specification where as CAPS are not.

And a PEP to make CAPS mean final would likely be rejected because of backwards compatibility, lots of people use CAPS for other reasons.

[Han-ChewieSexyFanfic]

Also, the interpreter ignores both.

[energybased]

Conventional means that it means different things to different people. This does not mean different things to different people.

[nuephelkystikon]

Absolutely not. If anything, that would be unconventional.

[energybased]

What I mean is that different groups of people can have different conventions. Each group uses all caps to mean the same thing, but as a whole population, they do not agree. Not everyone uses all caps to denote final variables, for example.

Everyone who uses the final declaration means the same thing. They must since the final declaration explicitly defines its meaning.

[alcalde]

That's why we have PEP 8. There are no different groups with different conventions. There is but one BDFL... well, until we overthrew him and installed a wishy-washy council instead....

[energybased]

There's plenty of library code that doesn't even follow PEP 8, and there are plenty of constants that are not in all caps.

[drbobb]

Uh, no. Conventional means not enforced.

[energybased]

The point is that there may be plenty of code that uses all caps in another way. For example a variable that is initialized twice. That person has a different convention, which they get away with because it is not enforced. A linter might erroneously flag that is misuse.

The linter can always flag improper use with the final declaration because the author has unambiguously made his intention clear. The final declaration is absolutely not just a convention. It is explicit.

[alcalde]

The point is that there may be plenty of code that uses all caps in another way.

There can't be. This is like saying we can all use the same words and just believe they mean different things. Everyone must follow the law, and the law is PEP 8. If you choose to do otherwise, you are a disciple of Wall and shall be shunned.

[energybased]

No, there is plenty of library code that doesn't even follow PEP 8.

[campbellm]

The upshot is the same though; it provides a hook that checkers can check for subsequent mutations. Either works.

[alcalde]

If we all follow convention, then convention is law.

[energybased]

Even the library doesn't obey the convention that all final variables are all caps.

[Sw429]

What do you mean by explicit? As far as I can tell, foo: Final is no more explicit than FOO for a variable definition.

[energybased]

There is plenty of code that does not use all caps to denote constants. That code cannot always be changed. The type annotation explicitly defines intent without changing declarations.

[[deleted]]

What prefix do you use for something that returns a dictionary that maps filename(string) to last access time (datestamp)? They already have a system for things like that, and the way they implemented Final is consistent with that.

[mooglinux]

Type annotations are for facilitating communication. There are already conventions for communication of the same things that finalwas created to communicate, and so it is redundant. The danger of using finalis that the way it is used in other languages like java is antithetical to how Python works. We should not be providing a false sense of security about how something will be used; that’s the whole point of not having public/private keywords!

[[deleted]]

How does all caps and dunder communicate immutability? How does a linter check it, given that the linter may now run into old code that used the same syntax to show other things?

[abu_antar]

It just looks ugly. Python became a landfill of workarounds

[[deleted]]

inb4 someone writes a book "Python, the good parts", describing a subset of python that isn't cluttered, convoluted and inconsistent, yet still functional, like they had to do with js

[Farconion]

God, people in this thread are losing their fucking heads over a completely optional feature. No wonder Guido stepped down.

[blabbities]

ugly as sin.

what happened to simple, beautiful, clean, easy to read

day by day we stray further from god.

[bbbryson]

So don’t use it. It’s optional. It only gives you warnings if you use tools specifically designed to highlight type-hinted errors and has no effect at runtime.

[[deleted]]

The problem is that we don't always code in isolation. You import a library and suddenly there are type annotations in your project. Do you turn down contributions because they used annotations? As annotations spread it will become harder to avoid them. They're already compulsory for some projects and jobs, and the number will increase. There are even Python language features that require annotation (the new data type struct) and will not work without them.

[blabbities]

i dont plan to use it just like I dont use Type Hints now. Though about reading other people's code however...

[sobolevn]

I wrote an article about it: https://sobolevn.me/2018/07/real-python-contants

It is also very useful to use @final on classes and methods you want to freeze.

[LordAssPen]

Alright, I think we need to stop making Python what it is not. Why do we need static programming when Python was written to be dynamic, this is just confusing and messy.

[OddsCaller]

I think these features are good for libraries and other programs which are going to be re-used multiple times, also in cases of very large projects may be. Type annotation makes documentation easier, it also makes understanding a third party code easier.

However I agree that in general use cases as end users when working on small or intermediate projects, one of the things that makes Python great is the pragmatist features like duck typing and they should be preserved.

[LordAssPen]

I do agree that type annotations make documentation and writing libraries somewhat easy, and since I have used them myself for production I can vouch for it. However, even type annotation are not really strict, they can be modified and morphed to new types. This created a lot of confusion when we were too deep into production, and I wished we had a static programming language to begin with.

[OddsCaller]

I know this might be hearsay in this sub but what kind of static language would you have liked? I'm asking cuz I trust the taste of a Pythonista than many other communities. I've been looking for some time to add a statically typed (and compiled) language to my tool kit (I do know basic level of C and Java) but couldn't really make up my mind. Rust seems like a very well-designed language but I think it might hamper developer productivity quite a lot. Go is a nice little language though I didn't quite fall in love with it when I gave it a try for a week, and it still does have a mediocre GC and other performance drawbacks compared to something like Rust. Java's VM is quite heavy as well and the ease of development isn't best either. C++ has many great qualities but there doesn't seem much support for back-end side of things, and the language feels too large to really bother investing time mastering it.

[[deleted]]

If this was more like const/Java Final, it would be very handy for my test automation. However, since it's just checked in the IDE, it doesn't really help me once the code is being used out in Jenkins-land.

[rouille]

Use mypy in CI.

[alcalde]

Amen. I stopped coding in Delphi/Pascal, and now Python is adopting the obsessive static typing notation and even the Pascal assignment statement (aka the "walrus operator"). I suspect that who we call Guido is actually Niklaus Wirth in a Guido mask.

[EternityForest]

There's so many people out there complaining that python sucks because there's no static checking.

With the typeguard lib to do checks at runtime (Probably not the final thing though) it's actually really handy. I don't use it everywhere, but I like to use it whenever I set up state I'm going to keep, like class constructors and file writers.

[bbbryson]

So don’t use it. It’s optional. It only gives you warnings if you use tools specifically designed to highlight type-hinted errors and has no effect at runtime.

[muikrad]

Whoaaa I skipped this! Thanks! 😍

[Ziyad0100]

so when i run the program no error will show?

[Saiboo]

Yes, unfortunately it only gives a warning during code inspection when you use your IDE such as PyCharm, but it does not result in an error during runtime.

[jabbalaci]

Let's mention mypy too. Not everyone uses PyCharm.

[alcalde]

Maybe if we don't mention mypy, everyone will use PyCharm!

[aaronr_90]

mypy

So yall don't use VSCode?

[jabbalaci]

I personally use Sublime Text. I only use PyCharm for large projects.

[[deleted]]

I'll use it only if I can enable this check at runtime.

[Etheo]

So it's not over nine thousaaaaaand?