@Pythonetc compilation, august 2019

A new selection of Python tips and programming from my @pythonetc feed.



← Previous collections









If the class instance does not have an attribute with the given name, then it tries to access the class attribute with the same name.

>>> class A: ... x = 2 ... >>> Ax 2 >>> A().x 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

An instance can easily have an attribute that the class does not have, or have an attribute with a different value:

 >>> class A: ... x = 2 ... def __init__(self): ... self.x = 3 ... self.y = 4 ... >>> A().x 3 >>> Ax 2 >>> A().y 4 >>> Ay AttributeError: type object 'A' has no attribute 'y'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

If you want the instance to behave as if it does not have an attribute, although the class has it, then you will have to create a custom handle that prohibits access from this instance:

 class ClassOnlyDescriptor: def __init__(self, value): self._value = value self._name = None # see __set_name__ def __get__(self, instance, owner): if instance is not None: raise AttributeError( f'{instance} has no attribute {self._name}' ) return self._value def __set_name__(self, owner, name): self._name = name class_only = ClassOnlyDescriptor class A: x = class_only(2) print(Ax) # 2 A().x # raises AttributeError
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

See also how the classonlymethod



Django decorator classonlymethod



: https://github.com/django/django/blob/b709d701303b3877387020c1558a590713b09853/django/utils/decorators.py#L6









Functions declared in the class body are not accessible to the scope of this class. This is because this scope exists only during the creation of the class.

 >>> class A: ... x = 2 ... def f(): ... print(x) ... f() ... [...] NameError: name 'x' is not defined
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

This is usually not a problem: methods are declared inside the class just to become methods and be called later:

 >>> class A: ... x = 2 ... def f(self): ... print(self.x) ... >>> >>> >>> A().f() 2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Surprisingly, the same is true for comprehensions. They have their own scope and they also do not have access to the scope of the classes. This is very logical from the point of view of generator comprehensions: the code in them is executed when the class is already created.

 >>> class A: ... x = 2 ... y = [x for _ in range(5)] ... [...] NameError: name 'x' is not defined
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

However, comprehensions do not have access to self



. The only way to provide access to x



is to add another scope (yeah, stupid solution):

 >>> class A: ... x = 2 ... y = (lambda x=x: [x for _ in range(5)])() ... >>> Ay [2, 2, 2, 2, 2]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

In Python, None



equivalent to None



, so it might seem like you can check for None



with ==



:

 ES_TAILS = ('s', 'x', 'z', 'ch', 'sh') def make_plural(word, exceptions=None): if exceptions == None: # ← ← ← exceptions = {} if word in exceptions: return exceptions[word] elif any(word.endswith(t) for t in ES_TAILS): return word + 'es' elif word.endswith('y'): return word[0:-1] + 'ies' else: return word + 's' exceptions = dict( mouse='mice', ) print(make_plural('python')) print(make_plural('bash')) print(make_plural('ruby')) print(make_plural('mouse', exceptions=exceptions))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

But that will be a mistake. Yes, None



is equal to None



, but not only that. Custom objects can also be None



:

 >>> class A: ... def __eq__(self, other): ... return True ... >>> A() == None True >>> A() is None False
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

The only correct way to compare with None



is to use is None



.











Floating point numbers in Python can have NaN values. For example, such a number can be obtained using math.nan



. nan



not equal to anything, including itself:

 >>> math.nan == math.nan False
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

In addition, a NaN object is not unique; you can have several different NaN objects from different sources:

 >>> float('nan') nan >>> float('nan') is float('nan') False
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

This means that, in general, you cannot use NaN as a dictionary key:

 >>> d = {} >>> d[float('nan')] = 1 >>> d[float('nan')] = 2 >>> d {nan: 1, nan: 2}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

typing



allows you to define types for generators. Additionally, you can specify which type is generated, which is passed to the generator, and which is returned using return



. For example, Generator[int, None, bool]



generates integers, returns Booleans, and does not support g.send()



.



But the example is more complicated. chain_while



data from other generators until one of them returns a value that is a stop signal in accordance with the condition



function:

 from typing import Generator, Callable, Iterable, TypeVar Y = TypeVar('Y') S = TypeVar('S') R = TypeVar('R') def chain_while( iterables: Iterable[Generator[Y, S, R]], condition: Callable[[R], bool], ) -> Generator[Y, S, None]: for it in iterables: result = yield from it if not condition(result): break def r(x: int) -> Generator[int, None, bool]: yield from range(x) return x % 2 == 1 print(list(chain_while( [ r(5), r(4), r(3), ], lambda x: x is True, )))
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Setting annotations for a factory method is not as easy as it might seem. Just want to use something like this:

 class A: @classmethod def create(cls) -> 'A': return cls()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

But it will be wrong. The trick is that create



returns not A



, it returns cls



, which is A



or one of its descendants. Take a look at the code:

 class A: @classmethod def create(cls) -> 'A': return cls() class B(A): @classmethod def create(cls) -> 'B': return super().create()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

The result of the mypy check is the error error: Incompatible return value type (got "A", expected "B")



. Once again, the problem is that super().create()



annotated as returning A



, although in this case it returns B







This can be fixed if annotating cls



using TypeVar



:

 AType = TypeVar('AType') BType = TypeVar('BType') class A: @classmethod def create(cls: Type[AType]) -> AType: return cls() class B(A): @classmethod def create(cls: Type[BType]) -> BType: return super().create()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

create



now returns an instance of the cls



class. However, these annotations are too vague, we have lost information that cls



is a subtype of A



:

 AType = TypeVar('AType') class A: DATA = 42 @classmethod def create(cls: Type[AType]) -> AType: print(cls.DATA) return cls()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

We "Type[AType]" has no attribute "DATA"



error "Type[AType]" has no attribute "DATA"



.



To fix it, you must explicitly define AType



as a subtype of A



For this, TypeVar



with the bound



argument is used.

 AType = TypeVar('AType', bound='A') BType = TypeVar('BType', bound='B') class A: DATA = 42 @classmethod def create(cls: Type[AType]) -> AType: print(cls.DATA) return cls() class B(A): @classmethod def create(cls: Type[BType]) -> BType: return super().create()