In Classes functions are called methods. The init-method __init__() in a Class is called whenever a Class is called to create an Object instance using Class(). The init-method define attributes, variables and set the Object instance to a defined initial state. Therefore the init-Method is called constructor.

The Parameter self

Let’s imagine a Class Car that has attributes like brand, color and horsepower. We define the init-method using def __init__(self) and define all attributes using self.<attribut> = <value> in the init-method. A peculiarity of Python is that the init-method has at least one parameter self which is always passed by default.

The parameter self ensure that each attribute and its values will be linked to the correct Object instance stored in a certain memory address space.

 class Car:
	def __init__(self):
		self.brand = None
        self.color = None
        self.horsepower = None
	
car1 = Car()
print(car1)

#Print-Output
#<__main__.Car object at 0x10e0ffc40>

When an Object instance car1 of the Class Car will be created using car1 = Car() the init-method within the Class-Definition will be called and the self parameter will be passed to the new Object instance car1. If we print the Object instance car1 on the console using print(car1) we don’t see a list of attributes or something similar, but we see the specific location in memory where the Object instance car1 has been stored. This memory address is stored in the self parameter.

To show the peculiarity of Python with the self parameter more clearly, please take a look at the following notation.

class Car:
    def __init__(self):
        self.brand = None
        self.color = None
        self.horsepower = None
        self.self = self #reference is stored in self


car1 = Car()
print(car1)
print(car1.self)
print(car1.brand)

#Print-Output
#<__main__.Car object at 0x10e0ffc40>
#<__main__.Car object at 0x10e0ffc40>
#None

Within the init-method the value of the self parameter is assigned to the attribute self.self using self.self = self. The output for print(car1.brand) is None as expected. print(car1) and print(car1.self) show exactly the same print output. The memory address ist stored in the parameter self and the Object instance car1 is a reference to this memory address.

The dot notation

We can assign values to each attribute, access each value and print the value to the console using the dot notation print(<object-instance>.<attribute-name>).

class Car:
	def __init__(self):
		self.brand = None
        self.color = None
        self.horsepower = None
        
car1 = Car()
car1.brand = "BMW"
car1.color = "red"
car1.horsepower = 120

car2 = Car()
car2.brand = "Audi"
car2.color = "blue"
car2.horsepower = 150

print(car1.brand)
print(car2.brand)

#Print-Output
#BMW
#Audi

We create the Object car1 as an instance of the Class Car. car1 is a BMW, is red, has 120 PS. And we create another Object car2. car2 is an Audi, is blue, has 150 PS. car1 and car2 are Object Instances of the Class Car. It is also often said that car1 and car2 are Objects of type Car. We access the individual attributes of the objects with the dot notation and get a print output of the brand using print(car1.brand) and print(car2.brand).

Working with Object instances

To make the code clearer the attribute values ​​can also be passed as parameters directly during object instantiation.

class Car:
	def __init__(self, brand, color, horsepower):
		self.brand = brand
        self.color = color
        self.horsepower = horsepower
        
car1 = Car("BMW", "red", 120)
car2 = Car("Audi", "blue", 150)

print(car1.brand)
print(car2.brand)

#Print-Output
#BMW
#Audi

Therefore the init-method must have beside the parameter self also the parameters brand, color and horsepower. When we create the Object instances car1 and car2 of the Class Car we pass the parameters in the brackets during the call of the Class Car .

As mentioned above, functions in Classes are called methods. We have already got to know one method, the init method __init__() that will be executed when an Object instance will be created.

Classes can have also methods designed by the developer himself as well. In our example we add the drive-Method to the Class Car as follows.

class Car:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.x = 0
        self.y = 0

    def drive(self):
        self.x += 10
        self.y += 15
		print("X and Y have been increased by 10 and 15")

car1 = Car("BMW", "red", 120)

print(car1.x)
print(car1.y)

car1.drive()

print(car1.x)
print(car1.y)

#Print-Output
#0
#0
#X and Y have been increased by 10 and 15
#10
#15	

Here we add 2 additional attributes to the constructor self.x and self.y and set both attributes initially to the value 0. The drive-method drive() is defined to increase the values self.x by 10 and self.y by 15 and to print a string to the console. In the above example you can see that the values of self.x and self.y are 0 when we print them to the console directly after the Object car1 has been created. Then we call the drive-method on the Object instance car1 using car1.drive() and self.x and self.y have been increase by 10 or 15 plus the string has been printed to the console.

Inheritance

There can be several classes in programs, including classes that are very similar and only differ in details. This is where the concept of inheritance comes into play. We want to write a program in which there are 3 classes of vehicles: there are cars, trucks and motorcycles.

We assume all vehicles have the attributes brand, color, and horsepower, but cars should have two drive wheels, trucks four, and motorcycles should have only one drive wheel. In addition, the vehicles have different drive-methods because they can move at different speeds.

class Car:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.drivewheels = 2
        self.x = 0
        self.y = 0

    def drive(self):
        self.x += 10
        self.y += 15
        print("Car accelerates by 10 and 15")

class Truck:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.drivewheels = 4
        self.x = 0
        self.y = 0

    def drive(self):
        self.x += 5
        self.y += 10
        print("Truck accelerates by 5 and 10")

class Motorcycle:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.drivewheels = 1
        self.x = 0
        self.y = 0

    def drive(self):
        self.x += 30
        self.y += 40
        print("Motorcycle accelerates by 30 and 40")

car1 = Car("BMW", "blue", 120)
truck1 = Truck("Volvo", "black", 270)
moto1 = Motorcycle("Yamaha", "green", 70)

print(car1.brand, car1.x, car1.y)
car1.drive()
print(car1.brand, car1.x, car1.y)

print(truck1.brand, truck1.y, truck1.y)
truck1.drive()
print(truck1.brand, truck1.y, truck1.y)

print(moto1.brand, moto1.x, moto1.y)
moto1.drive()
print(moto1.brand, moto1.x, moto1.y)

#Print-Output
#BMW 0 0
#Car accelerates by 10 and 15
#BMW 10 15
#Volvo 0 0
#Truck accelerates by 5 and 10
#Volvo 10 10
#Yamaha 0 0
#Motorcycle accelerates by 30 and 40
#Yamaha 30 40

We create 3 Object instances from Car, Truck and Motorcycle and have access to their attributes and to their individual drive-methods. Everything is working fine but most of the code is redundant.

Instead of duplicating the code in each Class, we can define a parent Class from which all Child classes inherit their properties. The parent Class in our example will be the Class Vehicle.

class Vehicle:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.x = 0
        self.y = 0

	def inheritedmethod(self):
		print("this method was inherited")

class Car(Vehicle):
    drivewheels = 2

    def drive(self):
        self.x += 10
        self.y += 15
        print("Car accelerates by 10 and 15")

class Truck(Vehicle):
    drivewheels = 4

    def drive(self):
        self.x += 5
        self.y += 10
        print("Truck accelerates by 5 and 10")

class Motorcycle(Vehicle):
    drivewheels = 1

    def drive(self):
        self.x += 30
        self.y += 40
        print("Motorcycle accelerates by 30 and 40")


car1 = Car("BMW", "blue", 120)
truck1 = Truck("Volvo", "black", 270)
moto1 = Motorcycle("Yamaha", "green", 70)

print(car1.brand, car1.x, car1.y, car1.drivewheels)
car1.drive()
print(car1.brand, car1.x, car1.y, car1.drivewheels)

print(truck1.brand, truck1.y, truck1.y, truck1.drivewheels)
truck1.drive()
print(truck1.brand, truck1.y, truck1.y, truck1.drivewheels)

print(moto1.brand, moto1.x, moto1.y, moto1.drivewheels)
moto1.drive()
print(moto1.brand, moto1.x, moto1.y, moto1.drivewheels)
moto1.inheritedmethod()

#Print-Output
#BMW 0 0 2
#Car accelerates by 10 and 15
#BMW 10 15 2
#Volvo 0 0 4
#Truck accelerates by 5 and 10
#Volvo 10 10 4
#Yamaha 0 0 1
#Motorcycle accelerates by 30 and 40
#Yamaha 30 40 1
#this method was inherited

The constructor __init__() of the parent-Class Vehicle contain the initial setup that is inherited to the child-Classes. The parent-Class Vehicle also inherit the method inheritedmethod() to each child-Class. Each Object instance created from a child-Class will have this initial setup. The child-Classes itself have no __init__() constructor in these examples. Each Object instance such as car1, truck1 and moto1 created from their child-Classes Car, Truck and Motorcycle can access all inherited properties from their common parent-Class Vehicle and their individual Class attributes drivewheels and the individual methods drive().

note: I will explain Class-attributes later in the text

Inherited methods from the parent-Class can be overwritten in the child-Class.

class Vehicle:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.x = 0
        self.y = 0

    def inheritedmethod(self):
        print("this method was inherited")

class Car(Vehicle):
    drivewheels = 2

    def drive(self):
        self.x += 10
        self.y += 15
        print("Car accelerates by 10 and 15")

    def inheritedmethod(self):
        print("this method was inherited and! overwritten")

car1 = Car("BMW", "blue", 120)

print(car1.brand, car1.x, car1.y, car1.drivewheels)
car1.drive()
print(car1.brand, car1.x, car1.y, car1.drivewheels)
car1.inheritedmethod()

#Print-Output
#BMW 0 0 2
#Car accelerates by 10 and 15
#BMW 10 15 2
#this method was inherited and! overwritten

In order to overwrite an inherited method, the same method head is simply written down again in the child-Class and the code of the method body is then adapted accordingly.

The super() method

A reference to the parent-Class can be established using the super() method. This allows us to take methods from the parent-Class and add additional properties in the code of the method in the child-Class.

class Vehicle:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower
        self.x = 0
        self.y = 0

    def inheritedmethod(self):
        print("this method was inherited")

class Car(Vehicle):
    def __init__(self, brand, color, horsepower, drivewheels):
        super().__init__(brand, color, horsepower)
        self.drivewheels = drivewheels

    def drive(self):
        self.x += 10
        self.y += 15
        print("Car accelerates by 10 and 15")

    def inheritedmethod(self):
        super().inheritedmethod()
        print("this method was inherited and! overwritten")

class Truck(Vehicle):
    def __init__(self, brand, color, horsepower, drivewheels):
        super().__init__(brand, color, horsepower)
        self.drivewheels = drivewheels

    def drive(self):
        self.x += 5
        self.y += 10
        print("Truck accelerates by 5 and 10")
        
car1 = Car("BMW", "blue", 120, 2)
truck1 = Truck("Magirus Deuz", "grey", 177, 4)

print(car1.brand, car1.x, car1.y, car1.drivewheels)
car1.drive()
print(car1.brand, car1.x, car1.y, car1.drivewheels)
car1.inheritedmethod()

print(truck1.brand, truck1.y, truck1.y, truck1.drivewheels)
truck1.drive()
print(truck1.brand, truck1.y, truck1.y, truck1.drivewheels)
truck1.inheritedmethod()

#Print-Output
#BMW 0 0 2
#Car accelerates by 10 and 15
#BMW 10 15 2
#this method was inherited
#this method was inherited and! overwritten
#Magirus Deuz 0 0 4
#Truck accelerates by 5 and 10
#Magirus Deuz 10 10 4
#this method was inherited

We had no __init__() method so far in our child-Classes but we defined for each child-Class the specific Class attribute drivewheels. This approach works fine. To understand how the super() method works we code for each child-Class a specific __init__() method and provide all parameters plus the parameter drivewheels. This means the value for drivewheels will be passed when the Object-instance from the child-Class is created and we have more flexibility there. Finally, it is possible that cars for example can have 4 drive wheels instead of 2. Then we use the super() method to refer to the __init__() method in the parent-Class and pass the properties required there and create the additional property self.drivewheels = drivewheels . In the child-Class Car we also use the super() method in the method inheritedmethod and add additional functionality (simple print command). We don’t do this in the child-Class Truck. Then we create the Object instances car1 and truck1 and access the properties and methods.

Special attributes

The attributes used so far are all 100 percent usable outside of the respective class definition. In the code below I have simplified the classes considerably to focus on the essentials.

class Vehicle:
    def __init__(self, brand, color, horsepower):
        self.brand = brand
        self.color = color
        self.horsepower = horsepower

class Car(Vehicle):
    def __init__(self, brand, color, horsepower, drivewheels):
        super().__init__(brand, color, horsepower)
        self.drivewheels = drivewheels

car1 = Car("BMW", "blue", 120, 2)

print(car1.brand)
car1.brand = "Audi"
print(car1.brand)

#Print-Output
#BMW
#Audi

We access the attribute brand and print the value BMW to the console. Then we change the value from BMW to Audi using the dot notation and overwrite the existing value.

Sometimes developers of a Class want to signal developers that attributes should only be used inside the Class and not outside. Developers can mark attributes with one underscore _ or with two underscores __ to show that attributes should not or can not be easily overridden.

class Vehicle:
    def __init__(self, brand, color, vmax):
        self._brand = brand
        self.__color = color
        self.vmax = vmax

class Car(Vehicle):
    def __init__(self, brand, color, vmax, drivewheels):
        super().__init__(brand, color, vmax)
        self.drivewheels = drivewheels

car1 = Car("BMW", "blue", 100, 2)

print(car1._brand)
car1._brand = "Audi"
print(car1._brand)

print(car1._Vehicle__color)
car1._Vehicle__color = "black"
print(car1._Vehicle__color)

#Print-Output
#BMW
#Audi
#blue
#black

In the example above we have the attribute _brand with one underscore. This shows the developer that _brand is a special attribute which is defined in the parent-Class Vehicle and inherited to the child-Class Car and should not be overwritten. However, overwriting is possible without any problems using the dot notation. The attribute __color is also defined in parent-Class Vehicle and inherited to child-Class Car but can not be overwritten using the standard dot notation. The value of the attribute __color can only be accessed using a different attribute name _Vehicle__color. Obviously the name of the attribute __color can only be accessed if we extend the attribute name at the beginning with <_parent-Classname><__attribute-name>. This is called Name Mangling.

Multiple inheritance

So far we had a parent-Class and single inheritance of properties to a child-Class. But it is also possible to define more parent-Classes and inherit their properties to a child-Class. This is called multiple inheritance. With multiple inheritance we can create complex data structures. In the following code I define 3 parent-Classes Person, Organisation, Building and 2 child-Classes Employee and Location.

class Person:
    def __init__(self, userid, name, lastname, age):
        self.userid = userid
        self.name = name
        self.lastname = lastname
        self.age = age

class Organisation:
    def __init__(self, company, orgunit):
        self.company = company
        self.orgunit = orgunit

class Building:
    def __init__(self, country, postalcode, street, city):
        self.country = country
        self.postalcode = postalcode
        self.street = street
        self.city = city

class Employee(Person, Organisation):
    def __init__(self, userid, name, lastname, age, company, orgunit):
        Person.__init__(self, userid, name, lastname, age)
        Organisation.__init__(self,  company, orgunit)

class Location(Building, Organisation):
    def __init__(self, country, postalcode, street, city, company, orgunit):
        Building.__init__(self, country, postalcode, street, city)
        Organisation.__init__(self, company, orgunit)


employee1 = Employee("12345", "Parick", "Rottländer", 54, "Company 1", "OE123456")
employee2 = Employee("67890", "Carol", "Meier", 32, "Company 2", "OE678901")
location1 = Location("Germany", "81234", "First Street 20", "Munich", "Company 1", "OE123456")
location2 = Location("Italy", "I23345", "Second Street 100", "Verona", "Company 2", "OE678901")

print(employee1.name, employee1.orgunit)
print(employee2.name, employee2.orgunit)
print(location1.country, location1.city)
print(location2.country, location2.city)

#Print-Output
#Parick OE123456
#Carol OE678901
#Germany Munich
#Italy Verona

In the code example above we define the child-Class Employee with properties from the parent-Classes Person and Organisation. Child-Class Building is defined with properties from parent-Classes Location and Organisation. Therefore the child-Class Employee inherits properties from parent-Classes Person and Organization and the child-Class Location inherit properties from parent-Classes Building and Organisation. In each child-Class the first __init__() constructor define the complete setup of an Object instance. Then each inherited parent-Class __init()__ constructor is overwritten using the dot notation <parent-Class>.__init()__. Then we create the object instances employee1, employee2 and location1 and location2 passing all required attributes and have access to each of those attributes using the dot notation.

Instance- and Class-attributes

If attributes of a Class are defined within the __init()__ method, these are Instance-attributes and are available as initial setup in each Object instance created from that Class. If we define attributes in a Class before the __init()__ method then these are Class-attributes.

class Person:
    counter = 0
    def __init__(self, name, lastname, age):
        self.userid = "P" +"-" +str(Person.counter)
        self.name = name
        self.lastname = lastname
        self.age = age
        Person.counter += 1

class Organisation:
    def __init__(self, company, orgunit):
        self.company = company
        self.orgunit = orgunit

class Employee(Person, Organisation):
    def __init__(self, name, lastname, age, company, orgunit):
        Person.__init__(self, name, lastname, age)
        Organisation.__init__(self,  company, orgunit)

print(Person.counter)
employee1 = Employee("Parick", "Rottländer", 54, "Company 1", "OE123456")
print(employee1.userid)
print(Person.counter)
employee2 = Employee("Carol", "Meier", 32, "Company 2", "OE678901")
print(employee2.userid)
print(Person.counter)

#Print-Output
#0
#P-0
#1
#P-1
#2

In the Class Person I define the Class-attribute counter and set its value to 0. Within the __init__() method of the Class Person I access the Class-attribute counter using str(Person.counter) to create a unique userid. Whenever an Object instance of Person is created Person.counter increase by 1 (see the respective print-output).

Modules

In the examples above we write the code in one Python file with the ending <filename>.py. Each Python file is a Module itself and can be executed independently. But a developer must not code any method on his own he or she can use existing code from third parties by loading other modules into his Python file. After modules have been loaded methods and properties defined in those modules can be user in the code.

Python has numerous built-in modules. All of them can be used for free by developers in the code. In the following examples I will use the build-in module math because math contain the parameter pi that we need for the calculation of the area of a circle for a given radius.

#objectMain.py

import math

class Circle:
    def __init__(self, radius):
        self.radius = radius

    #calculate area from given radius
    def area(self):
        return math.pi * self.radius ** 2

c1 = Circle(5)
print(c1.area())

#Print-Output
#78.53981633974483

In the file objectMain.py we first import math and define the Class Circle. Then we pass the parameter radius in the __init()__ constructor. The instance attribute self.radius receive the given value radius when an Object instance is created with a given radius value. The area()method use the parameter pi from the math Module and return the calculated area for the given radius.

But we can also develop methods on our own separately in separate Python files and make them available as modules. We can then either import the entire module or just individual methods from the module. I define a method radius() in a separate module objectModuleCalc.py to calculate the radius from a given area.

#objectModuleCalc.py

import math

#calculate radius from given area
def radius(area):
    return math.sqrt(area/math.pi)

To use the method radius() in my objectMain.py file I must import the module from the objectModuleCalc.py file using import <filename>.

#objectMain.py

import math
import objectModuleCalc

class Circle:
    def __init__(self, radius):
        self.radius = radius

    #calculate area from given radius
    def area(self):
        return math.pi * self.radius ** 2

c1 = Circle(5)
print(c1.area())

print(objectModuleCalc.radius(78.54))

#Print-Output
#78.53981633974483
#5.000005846084075

After the import I can access the method radius() in the imported module using the dot notation<filename>.<method>.

Another way to import the Module from the objectModuleCalc.py file is using an alias import <filename> as <alias>.

#objectMain.py

import math
import objectModuleCalc as calc

class Circle:
    def __init__(self, radius):
        self.radius = radius

    #calculate area from given radius
    def area(self):
        return math.pi * self.radius ** 2

c1 = Circle(5)
print(c1.area())

print(calc.radius(78.54))

#Print-Output
#78.53981633974483
#5.000005846084075

After the import I can access the code in the imported module using the dot notation<alias>.<method>.

In the example above you see that the method area() can only be used when an object instance has been created. The method is used on the Object instance using c1.area().

Static Methods

With static methods we can use a method defined in a class without having created an Object instance. We have no Class reference and no Object reference. We use the Function Decorator @staticmathod before the method definition.

#objectMain.py

import math

class Circle:
    def __init__(self, radius):
        self.radius = radius

    #calculate area from given radius
    @staticmethod
    def area(radius):
        return math.pi * radius ** 2

print(Circle.area(5))

#Print-Output
#78.53981633974483

Static methods have no reference to the Class and no reference to the Object instance once it has been created. Therefore we can not access any attributes defined in the Class like Class-attributes or the Instance-attribute self.radius. This is the reason why we must pass a separate parameter radius into the method area(). The value of the parameter radius can then be used by the variable radius within the method area() when we call the method using <Classname>.<method>(<parameter>).

Class methods

With Class methods we can use a method defined in a Class also without having created an Object instance. We use the Function Decorator @classmethod before the method definition.

#objectMain.py

import math

class Circle:
    counter = 0
    def __init__(self, radius):
        self.radius = radius
        Circle.counter += 1

    #calculate area from given radius
    @staticmethod
    def area(radius):
        return math.pi * radius ** 2

    #print the current counter value
    @classmethod
    def printcounter(cls):
        print("Actual value of counter is: " +str(cls.counter))

Circle.printcounter()
c1 = Circle(5)
Circle.printcounter()

#Print-Output
#Actual value of counter is: 0
#Actual value of counter is: 1

I define the Class method printcounter(cls). The parameter cls is the Class reference to ensure that also Class-attributes like counter can be used within the Class-method. The Class-method is called using <Classname>.<class-method-name>. In the Class Circle we define the Class-attribute counter ant set it to the value of 0. The __init__() constructor create an Object instance of type Circle when we call Circle() . Each time we create an Object instance, the counter value of the Class Circle is incremented by 1. We define the Class-method printcounter(cls) and pass the parameter cls to establish the Class reference. Then we can access the Class attribute counter in the printcounter(cls) method using cls.counter. We call the Class method using <Classname>.<classmethod> and see in the print output that the counter value increased by 1 after we created the Object instance c1.

note: In the __init__() constructor above we still use the parameter radius and we pass a value for radius when we create an Object instance from Class Circle. This does not really make sense in this example because we do not use it as we the method area() is defined as static method and there we pass a separate radius value with the method call. Because we will need passing the radius in the text below I decided to keep the __init__() constructor as it is to avoid confusion.

The Class method printcounter(cls) above return a print() function. So when we call the method printcounter(cls) we get a print output at the console.

A Class-method can also return an Object instance. Therefore I define another Class-method radius(cls, area) in the code below. This Class-method has 2 parameters: cls is the Class parameter and stand for the Class reference to ensure that also Class-attributes can be used within the Class method and area to pass the given area value to calculate the radius.

#objectMain.py

import math

class Circle:
    counter = 0
    def __init__(self, radius):
        self.radius = radius
        Circle.counter += 1

    #calculate area from given radius
    @staticmethod
    def area(radius):
        return math.pi * radius ** 2

    #print the current counter value
    @classmethod
    def printcounter(cls):
        print("Actual value of counter is: " +str(cls.counter))

    #calculate radius from given area
    @classmethod
    def radius(cls, area):
        r = math.sqrt(area / math.pi)
        return Circle(r)

Circle.printcounter()
c1 = Circle(5)
print(type(c1))
print(c1.radius)
Circle.printcounter()
c2 = Circle.radius(78)
print(type(c2))
print(c2.radius)
Circle.printcounter()

#Print-Output
#Actual value of counter is: 0
#<class '__main__.Circle'>
#5
#Actual value of counter is: 1
#<class '__main__.Circle'>
#4.982787485166879
#Actual value of counter is: 2

The Class method radius()here is the same method we defined above in a separate module. Here we use radius() to calculate the radius r for a given area value that we pass with the method call. The Class method radius() return an Object instance of type Circle passing the calculated radius using return Circle(r). After we create the Object instance c1 using c1 = Circle(5) we see in the print output above that c1 is of type Circle class '__main__.Circle . We can access the passed radius value using the dot notation c1.radius. Then we call the Class-method Circle.radius(cls, area) with the area parameter 78 and assign the return value to the variable c2 using c2 = Circle.radius(78). As we expected c2 is also of type class '__main__.Circle . We can access the calculated radius value using c2.radius. In the print output you also see that the counter increased from 0 to 2 meaning that 2 Object instances c1 and c2 both of type Circle have been created.

A Class-method can return an Object instance of type of the calling class. Therefore I define a new child-Class Rim. Rim inherits all properties of the parent-Class Circle using Rim(Circle) and Rim has no __init__() constructor. Instead we use pass so that we can create an Object instance of Rim and all properties come from the parent-Class Circle.

#objectMain.py

import math

class Circle:
    counter = 0
    def __init__(self, radius):
        self.radius = radius
        Circle.counter += 1

    #calculate area from given radius
    @staticmethod
    def area(radius):
        return math.pi * radius ** 2

    #print the current counter value
    @classmethod
    def printcounter(cls):
        print("Actual value of counter is: " +str(cls.counter))

    #calculate radius from given area
    @classmethod
    def radius(cls, area):
        r = math.sqrt(area / math.pi)
        return cls(r)

class Rim(Circle):
    pass

Circle.printcounter()
c2 = Circle.radius(78)
print(type(c2))
print(c2.radius)

Circle.printcounter()
r1 = Rim.radius(120)
print(type(r1))
print(r1.radius)

Circle.printcounter()

#Print-Output
#Actual value of counter is: 0
#<class '__main__.Circle'>
#4.982787485166879
#Actual value of counter is: 1
#<class '__main__.Rim'>
#6.180387232371033
#Actual value of counter is: 2

The Class method radius() in the parent-Class Circle has changed a bit: The method return not necessarily an Object instance of type Circle but an Object instance of the calling Class return cls(r). Then we call the Class method Circle.radius(cls, area) with the area parameter 78 and assign the return value to the variable c2 using c2 = Circle.radius(78). As expected c2 is of type class '__main__.Circle . When we call the Class method using Rim.radius(cls, area) with the area parameter 120 and assign the return value to the variable r1 using r1 = Rim.radius(120) we see that r1 is of type class '__main__.Rim .

Property attributes and setters

In the text above we have already dealt with attributes that begin with one underscore _ or double underscores __ and thus indicate that these attributes should be touched carefully from the outside or even cannot be changed at all in the case when we use double underscores.

Here we want to deal again with accessing attributes and changing their values. To show the problem I use the Class Circle and the method area() that is defined within the Class Circle to calculate the area value for the given radius that we pass when we create an Object instance c1using c1 = Circle(<radius>).

import math

class Circle:
    def __init__(self, radius):
        self.radius = radius

    # calculate area from given radius
    def area(self):
        return math.pi * self.radius ** 2

c1 = Circle(5)
print(c1.radius)
print(c1.area())
c1.radius = -10
print(c1.radius)

#Print-Output
#5
#78.53981633974483
#-10
#print(c1.area())
#314.1592653589793

In the code above you see that we are able to change the value of radius from outside to -10 using c1.radius = -10. This doesn’t make much sense, even if the value of the area is calculated correctly because self.radius ** 2 in the area() method.

Then we define the instance attribute self._radius in the __init__() constructor. The radius value passed when we create the Object instance will be assigned to self_radius using self_radius = radius . The underscore shows that the attribute should be touched carefully from the outside.

import math

class Circle:
    def __init__(self, radius):
        self._radius = radius

    # calculate area from given radius
    def area(self):
        return math.pi * self._radius ** 2

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, radius):
        if radius >= 0:
            self._radius = radius

c1 = Circle(5)

print(c1.radius)
print(c1.area())

c1.radius = -10
print(c1.radius)
print(c1.area())

c1.radius = 10
print(c1.radius)
print(c1.area())

c1._radius = -10
print(c1.radius)
print(c1.area())

#Print-Output
#5
#78.53981633974483
#5
#78.53981633974483
#10
#314.1592653589793
#-10
#314.1592653589793

First we define a Property attribute using the Property Decorator @Property. The Property attribute definition is a method that return self_radius when we call radius. This mean when we can call <Object-Instance>.radius instead of <Object-Instance>._radius when we want to access the Property attribute. Then we define a Property setter using @<Property-attribute>.setter, in this case we use @radius.setter. The Property setter definition is a method that set self._radius = radius only in case radius is greater or equal to 0. In the following we create the Object instance c1 with given radius of 5 and access the given radius using c1.radius. As you see in the print output we are able to change the value to 10. Even if we are not able to change the value to -10 when we use c1.radius = -10 we are still able to change the value to -10 using c1._radius = -10.

We define the instance attribute self.__radius in the __init__() constructor. The radius value passed when we create the Object instance will be assigned to self__radius using self__radius = radius. The double underscore __ shows that the attribute can not be touched from the outside.

class Circle:
    def __init__(self, radius):
        self.__radius = radius

    # calculate area from given radius
    def area(self):
        return math.pi * self.__radius ** 2

    @property
    def radius(self):
        return self.__radius

    @radius.setter
    def radius(self, radius):
        if radius >= 0:
            self.__radius = radius

c1 = Circle(5)
print(c1.radius)
print(c1.area())

c1.radius = -10
print(c1.radius)
print(c1.area())

c1.radius = 10
print(c1.radius)
print(c1.area())

c1.__radius = -10
print(c1.radius)
print(c1.area())

#Print-Output
#5
#78.53981633974483
#5
#78.53981633974483
#10
#314.1592653589793
#10
#314.1592653589793

The Property attribute definition is a method that now return self__radius when we call radius. The Property setter definition is now a method that set self.__radius = radius only in case radius is greater or equal to 0. We create the Object instance c1 with given radius of 5 and access the given radius using c1.radius. As you see in the print output we are able to change the value to 10 but we are not able to change the value to -10 when we use c1.radius = -10 and c1.__radius = -10.

System Python is installed in /usr/bin directory which is owned by root. This mean all files and symlinks in /usr/bin are system owned which means managed by the system and not managed by the user. In /usr/bin you find python symlinks pointing to the Python binaries in /System/Library/Frameworks/Python.framework/Versions/2.7/bin directory.

patrick@PatrickMBNeu ~ % ls -l /usr/bin/python* 

lrwxr-xr-x  1 root  wheel      75  1 Jan  2020 /usr/bin/python -> ../../System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7

lrwxr-xr-x  1 root  wheel      75  1 Jan  2020 /usr/bin/python2 -> ../../System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7

lrwxr-xr-x  1 root  wheel      75  1 Jan  2020 /usr/bin/python2.7 -> ../../System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7

....

patrick@PatrickMBNeu ~ %

The symlinks python, python2 and python2.7 in /usr/bin each point to the same binary in /System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7. So when you type one of these as shell command in your shell terminal the binary in /System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7 will be executed.

patrick@PatrickMBNeu ~ % python --version
Python 2.7.16

patrick@PatrickMBNeu ~ % python2 --version
Python 2.7.16

patrick@PatrickMBNeu ~ % python2.7 --version
Python 2.7.16

patrick@PatrickMBNeu

Type in the command without using the path like /usr/bin/python works because /usr/bin is configured in the shell PATH variable.

patrick@PatrickMBNeu ~ % echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

patrick@PatrickMBNeu ~ %  

The shell lookup for a command in the paths defined in the PATH variable and starts on the left side of the PATH. So python, python2 and python2.7 do not exist in /usr/local/bin but in /usr/bin.

When you came from Catalina and upgraded to BigSur you realized that System Python has not been upgraded from Python 2 to Python 3 for example. So obviously BigSur still relies on Python 2 which is ok for your Mac but maybe not for you as a Developer. You might need newer or different versions of Python on your system. You must install this them separately.

Many people use Homebrew to install software packages on their MacOS. Homebrew can also be used to install a Python version in addition to the System Python. You can check if Python is installed via Homebrew on your system using the command brew info <formula>.

patrick@PatrickMBNeu ~ % brew info python
python@3.9: stable 3.9.7 (bottled)
Interpreted, interactive, object-oriented programming language
https://www.python.org/
/usr/local/Cellar/python@3.9/3.9.7_1 (3,191 files, 56MB) *
  Poured from bottle on 2021-10-15 at 07:09:27
From: https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/python@3.9.rb
License: Python-2.0
==> Dependencies
Build: pkg-config ✔
Required: gdbm ✔, mpdecimal ✔, openssl@1.1 ✔, readline ✔, sqlite ✔, xz ✔
==> Caveats
Python has been installed as
  /usr/local/bin/python3

Unversioned symlinks `python`, `python-config`, `pip` etc. pointing to
`python3`, `python3-config`, `pip3` etc., respectively, have been installed into
  /usr/local/opt/python@3.9/libexec/bin

You can install Python packages with
  pip3 install <package>
They will install into the site-package directory
  /usr/local/lib/python3.9/site-packages

tkinter is no longer included with this formula, but it is available separately:
  brew install python-tk@3.9

See: https://docs.brew.sh/Homebrew-and-Python
==> Analytics
install: 717,857 (30 days), 1,988,212 (90 days), 8,421,529 (365 days)
install-on-request: 322,364 (30 days), 784,390 (90 days), 2,811,664 (365 days)
build-error: 0 (30 days)

patrick@PatrickMBNeu ~ %

Here on my system Python has been installed with Homebrew in the directory /usr/local/bin which is owned by the user. That means all files and symlinks in this directory can be managed by the user. In /usr/local/bin you find the python symlinks python3 and python3.9 pointing to further symlinks in the Homebrew Cellar in /usr/local/Cellar.

patrick@PatrickMBNeu ~ % ls -l /usr/local/bin/python*

lrwxr-xr-x  1 patrick  admin  40 15 Okt 07:09 /usr/local/bin/python3 -> ../Cellar/python@3.9/3.9.7_1/bin/python3

lrwxr-xr-x  1 patrick  admin  42 15 Okt 07:09 /usr/local/bin/python3.9 -> ../Cellar/python@3.9/3.9.7_1/bin/python3.9

...

patrick@PatrickMBNeu ~ %

The python3 symlink in the Homebrew Cellar point again to another python3 symlink in /usr/local/Frameworks/Python.framework/Versions/3.9/bin and this symlink point finally to python3.9 binary /usr/local/Frameworks/Python.framework/Versions/3.9/bin. The python3.9 symlink from the Homebrew Cellar point directly to the python3.9 binary in /usr/local/Frameworks/Python.framework/Versions/3.9/bin.

patrick@PatrickMBNeu ~ % ls -l /usr/local/Frameworks/Python.framework/Versions/3.9/bin
total 136

lrwxr-xr-x  1 patrick  admin      9 30 Aug 21:19 python3 -> python3.9

-rwxr-xr-x  1 patrick  admin  50472 15 Okt 07:09 python3.9

...

patrick@PatrickMBNeu ~ % 

So If you enter python3 or python3.9 as a command in the terminal the shell lookup these symlinks in directory /usr/local/bin and find a match. In any case you always end up with the python3.9 binary in /usr/local/Frameworks/Python.framework/Versions/3.9/bin and execute the same binary.

patrick@PatrickMBNeu ~ % python3 --version
Python 3.9.7

patrick@PatrickMBNeu ~ % python3.9 --version
Python 3.9.7

patrick@PatrickMBNeu ~ %

It is not a problem to install other Python versions with Homebrew in addition to the System Python, but the Homebrew ecosystem has a special feature: dependencies. Python versions that are installed in the Homebrew perimeter can also represent a dependency on other applications. node, for example, needs Python 3.9. If we uninstall Python 3.9, we have a problem with node. Therefore, Python can never be seen completely isolated in the Homebrew ecosystem and this is exactly the problem we solve with pyenv.

patrick@PatrickMBNeu ~ % brew info node   
                                                 
node: stable 16.11.1 (bottled), HEAD
Platform built on V8 to build network applications
https://nodejs.org/
/usr/local/Cellar/node/16.11.1 (1,980 files, 45.4MB) *
  Poured from bottle on 2021-10-15 at 07:09:45
From: https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/node.rb
License: MIT
==> Dependencies
Build: pkg-config ✔
Required: brotli ✔, c-ares ✔, icu4c ✔, libnghttp2 ✔, libuv ✔, openssl@1.1 ✔, python@3.9 ✔
==> Options
--HEAD
	Install HEAD version
==> Analytics
install: 501,912 (30 days), 1,345,537 (90 days), 4,731,822 (365 days)
install-on-request: 404,509 (30 days), 1,070,393 (90 days), 3,650,272 (365 days)
build-error: 0 (30 days)

patrick@PatrickMBNeu ~ %

pyenv create a complete isolated environment for your Python versions. You are able to install, use and uninstall Python versions and you can switch between them. pyenv can be easily installed with Homebrew. pyenv is therefore installed in the /usr/local/bin directory.

patrick@PatrickMBNeu ~ % which pyenv
/usr/local/bin/pyenv

patrick@PatrickMBNeu ~ % pyenv --version
pyenv 2.1.0

patrick@PatrickMBNeu ~ % 

We must adapt the PATH variable for the standard shell. Here in my example this is configured in the .zshrc file in my Home-Directory.

patrick@PatrickMBNeu ~ % cat .zshrc

# ~/.pyenv provides Python before others of the same name
export PYENV_ROOT=$(pyenv root)
export PATH="$PYENV_ROOT/shims:$PATH"

patrick@PatrickMBNeu ~ %

You check the versions managed by pyenv with the following command. As you see pyenv realize the System Python. With the command pyenv install 3.9.7 you install Python 3.9.7 in your pyenv environment. You can switch to your desired Python version using the command pyenv global <version> .

When you then run the command python you are directly connected to global python version you selected.

patrick@PatrickMBNeu ~ % pyenv versions 
*  system

patrick@PatrickMBNeu ~ % pyenv install 3.9.7

.....

patrick@PatrickMBNeu ~ % pyenv versions 
* system
  3.9.7 (set by /Users/patrick/.pyenv/version)

patrick@PatrickMBNeu ~ % pyenv global 3.9.7

patrick@PatrickMBNeu ~ % pyenv versions 
  system
* 3.9.7 (set by /Users/patrick/.pyenv/version)

patrick@PatrickMBNeu ~ % python
Python 3.9.7 (default, Oct 19 2021, 16:02:07) 
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()

patrick@PatrickMBNeu ~ % pyenv global system

patrick@PatrickMBNeu ~ % pyenv versions     
* system (set by /Users/patrick/.pyenv/version)
  3.9.7

patrick@PatrickMBNeu ~ % python             

WARNING: Python 2.7 is not recommended. 
This version is included in macOS for compatibility with legacy software. 
Future versions of macOS will not include Python 2.7. 
Instead, it is recommended that you transition to using 'python3' from within Terminal.

Python 2.7.16 (default, Aug 30 2021, 14:43:11) 
[GCC Apple LLVM 12.0.5 (clang-1205.0.19.59.6) [+internal-os, ptrauth-isa=deploy on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()

patrick@PatrickMBNeu ~ %

Finally: To avoid a warning message from brew when you run brew doctor you must create a brew alias in your .zshrc file.

patrick@PatrickMBNeu ~ % cat .zshrc

alias brew='PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin brew'

# ~/.pyenv provides Python before others of the same name
export PYENV_ROOT=$(pyenv root)
export PATH="$PYENV_ROOT/shims:$PATH"

patrick@PatrickMBNeu ~ %

But first of all I would like to describe my initial situation. I think some Mac users have python installed on their mac by themselves in one way or another and are surprised when checking the current version with python -V or when checking which python binary is currently being executed with the command which python. I installed python 2 and 3 with Homebrew and after executing these commands I was surprised and found that on my system different python versions were running than I expected.

I found that there must be a problem when you install different Python versions on a Mac and I was looking for an easy way to switch between these versions. Switching between the versions is necessary because when you are a developer you might have the need to run your code on a certain version. So it has to be easy to install different python versions on your Mac and to switch between them as needed. There are of course several ways of dealing with this matter. I decided to use the version manager Pyenv. But more on that later. First of all, back to my initial situation.

Initial Situation

It all started with a Homebrew error message after my update to Mac OS Big Sur (Mac OS 11). I had python 2 and 3 installed on my system with Homebrew. I had carried out these installations under Catalina. The brew doctor command gave me the error message saying I had installed kegs without a formula and I should uninstall python@2 because it is an outdated and no longer supported python version. What ?

My first check was on the /usr/local/bin directory because I wanted to know whether the python binaries had been linked correctly from Homebrew.

patrick@PatrickMBNeu ~ % ls -l /usr/local/bin/python*
lrwxr-xr-x  1 patrick  admin   32  6 Mär 10:23 python -> ../Cellar/python@2/2.7.17/bin/python
lrwxr-xr-x  1 patrick  admin   32  6 Mär 10:23 python2 -> ../Cellar/python@2/2.7.17/bin/python2
lrwxr-xr-x  1 patrick  admin   32  6 Mär 10:23 python2.7 -> ../Cellar/python@2/2.7.17/bin/python2.7

Here it seems to me that only python 2 has been installed by Homebrew and the binary links all refer to the python@2 directory in the Homebrew Cellar. My second check was on the Hombrew Cellar directory because I wanted to know whether there are Formulars of the two python versions available.

patrick@PatrickMBNeu ~ % ls -l /usr/local/Cellar/python*
drwxr-xr-x  3 patrick  staff  96 26 Feb 18:46 python@2
drwxr-xr-x  3 patrick  staff  96 26 Feb 18:46 python@3.8

This made it clear: Python 2 is correctly installed and linked in the Cellar (but out of date) but Python 3 was obviously not installed correctly (no binary links in /usr/local/bin). I understood that this must be the message from Homebrews error message. But then I was curious what the version check would tell me.

patrick@PatrickMBNeu ~ % which python
/usr/local/bin/python
patrick@PatrickMBNeu ~ % python --version
2.7.17
patrick@PatrickMBNeu ~ % which python3
/usr/bin/python3
patrick@PatrickMBNeu ~ % python3 --version
3.8.2

The command which python refers to the python 2 version installed with Homebrew in /usr/local/bin but what the hell is in /usr/bin ?

I googled around a bit and finally I found out that it must be the python version that comes with Mac OS. So the command which python3 refers to the python 3 version pre-installed on the Mac in /usr/bin. And I learned that it must be avoided in any case to remove these so-called System Python Versions from the system. Apple install in /usr/bin while Homebrew install in /usr/local/bin and /usr/local/Cellar. So stay away from everything that is installed in /usr/bin with regard to Python.

Then I wanted to understand what Apple installed in /usr/bin.

patrick@PatrickMBNeu ~ % ls -l /usr/bin/python*
lrwxr-xr-x  1 root  wheel      75  1 Jan  2020 /usr/bin/python -> ../../System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7
lrwxr-xr-x  1 root  wheel      75  1 Jan  2020 /usr/bin/python2 -> ../../System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7
lrwxr-xr-x  1 root  wheel      75  1 Jan  2020 /usr/bin/python2.7 -> ../../System/Library/Frameworks/Python.framework/Versions/2.7/bin/python2.7
-rwxr-xr-x  1 root  wheel  137552  1 Jan  2020 /usr/bin/python3
patrick@PatrickMBNeu ~ % 

Apple apparently installs Python 2 and Python 3. But the command which python clearly tells me (see above) that the Python 2 version of Homebrew from /usr/local/bin is currently active in some way, while the command which python3 apparently refers to the System Python 3 version in /usr/bin.

How do I get the mess cleaned up ?

I decided to uninstall the python 2 version of Homebrew normally with the command brew uninstall python@2. And I also removed manually the /usr/local/Cellar/python@3.8 directory. Then I checked the python versions again.

patrick@PatrickMBNeu ~ % which python
/usr/bin/python
patrick@PatrickMBNeu ~ % python --version
2.7.16
patrick@PatrickMBNeu ~ % which python3
/usr/bin/python3
patrick@PatrickMBNeu ~ % python3 --version
3.8.2

I was satisfied with the result. Both System Pythons in /usr/bin are currently active on my system and this is exactly what I wanted to achieve with my clean up. I can now think about how I would like to manage other, different python versions on my system. And this is exactly where I come back to Pyenv.

Managing Python on Mac OS with Pyenv

First I install Pyenv with Homebrew.

patrick@PatrickMBNeu ~ % brew update
patrick@PatrickMBNeu ~ % brew install pyenv

Then I create a ~/.zshrc file in my home directory and add the command pyenv init at the end of the ~/.zshrc configuration file to enable pyenv shims in my PATH variable.

patrick@PatrickMBNeu ~ % echo -e 'eval "$(pyenv init -)" ' >> ~/.zshrc
patrick@PatrickMBNeu ~ % cat .zshrc

eval "$(pyenv init -)"

patrick@PatrickMBNeu ~ % 

It is very important to make sure that the command eval "$(pyenv init -)" is placed at the end of the shell configuration because it manipulates the PATH environment variable during the shell initialization.

Then I close the terminal and restart it again.

With the command pyenv versions you can check the existing python versions on your Mac. After my cleanup the only version on my Mac is the System Python and marked with system.

patrick@PatrickMBNeu ~ % pyenv versions     
* system (set by /Users/patrick/.pyenv/version)
patrick@PatrickMBNeu ~ % python --version
Python 2.7.16
patrick@PatrickMBNeu ~ % python3 --version
Python 3.8.2
patrick@PatrickMBNeu ~ %

When you check the version of the current System Python with the command python --``version and python3 --``version you see that I still run the System Python Versions 2.7.16 and 3.8.2. Thats what I expected.

With Pyenv you can also install Python using the pyenv install command. With the command pyenv install --list you can list all available Python version that can be installed. This would be a long list but you can pipe it into grep to restrict the displayed list a little. Here I restrict the list to all available Python 3.8.* and 3.9.* versions.

patrick@PatrickMBNeu ~ % pyenv install --list | grep " 3\.[89]"  
  3.8.0
  3.8-dev
  3.8.1
  3.8.2
  3.8.3
  3.8.4
  3.8.5
  3.8.6
  3.8.7
  3.9.0
  3.9-dev
  3.9.1
patrick@PatrickMBNeu ~ % 

Then I install Python 3.9.1 which is the latest Python available at the time of writing this article.

patrick@PatrickMBNeu ~ % pyenv install 3.9.1

Then I check the existing pythons again with pyenv versions and I can already see that the 3.9.1 version has been added. Now comes the real advantage of pyenv. With the command pyenv global I set the 3.9.1 version as the currently active one.

patrick@PatrickMBNeu ~ % pyenv versions     
* system (set by /Users/patrick/.pyenv/version)
  3.9.1
patrick@PatrickMBNeu ~ % pyenv global 3.9.1 
patrick@PatrickMBNeu ~ % pyenv versions   
  system
* 3.9.1 (set by /Users/patrick/.pyenv/version)
patrick@PatrickMBNeu ~ % python --version 
Python 3.9.1
patrick@PatrickMBNeu ~ % python3 --version 
Python 3.9.1
patrick@PatrickMBNeu ~ % python
Python 3.9.1 (default, Mar  8 2021, 18:50:54) 
[Clang 12.0.0 (clang-1200.0.32.29)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()
patrick@PatrickMBNeu ~ %  

I check again if the default python is now set to 3.9.1 using the command python --``version. The output in the terminal shows the active version marked with a star. This is Python 3.9.1 and exactly what I expected. Then I login into the interactive python command interpreter and this also confirmed that it is currently the 3.9.1 version.

So I manage my Pythons on my Mac OS Big Sur from now on with Pyenv.

Make Pyenv working perfectly with Homebrew

When I finished installing Pyenv everything worked fine until I tried to use the brew doctor command to check my Homebrew installations.

patrick@PatrickMBNeu ~ % brew doctor
Warning: "config" scripts exist outside your system or Homebrew directories.
`./configure` scripts often look for *-config scripts to determine if
software packages are installed, and what additional flags to use when
compiling and linking.

Having additional scripts in your path can confuse software installed via
Homebrew if the config script overrides a system or Homebrew provided
script of the same name. We found the following "config" scripts:

    /Users/patrick/.pyenv/shims/python-config
    /Users/patrick/.pyenv/shims/python3-config
    /Users/patrick/.pyenv/shims/python3.9-config

patrick@PatrickMBNeu ~ %

I googled a little and I found out this. Very interesting Article about the PATH settings I enforced in my ~/.zshrc file when I installed Pyenv (see above).

Then I checked my environment variables with the command env.

patrick@PatrickMBNeu ~ % env
TMPDIR=/var/folders/zy/3s2n4mh502z3320837q80qdm0000gp/T/
__CFBundleIdentifier=com.apple.Terminal
XPC_FLAGS=0x0
TERM=xterm-256color
SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.ZIRHZWPkYD/Listeners
XPC_SERVICE_NAME=0
TERM_PROGRAM=Apple_Terminal
TERM_PROGRAM_VERSION=440
TERM_SESSION_ID=53DE5B52-55E2-4D61-A4E4-7F47D5C401AC
SHELL=/bin/zsh
HOME=/Users/patrick
LOGNAME=patrick
USER=patrick
PATH=/Users/patrick/.pyenv/shims:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/MacGPG2/bin
SHLVL=1
PWD=/Users/patrick
OLDPWD=/Users/patrick
PYENV_SHELL=zsh
LANG=de_DE.UTF-8
_=/usr/bin/env
patrick@PatrickMBNeu ~ % 

The problem seems to be the PATH which is set by the entry eval "$ (pyenv init -)" in my ~/.zshrc file.

patrick@PatrickMBNeu ~ % cat .zshrc
eval "$(pyenv init -)"

patrick@PatrickMBNeu ~ %

This entry leads to that /Users/patrick/.pyenv/shims is set at the beginning of the PATH variable when zsh is executed.

When you look at the complete PATH you see that the command brew doctor can be executed without specifying /usr/local/bin/brew because the required path specification /usr/local/bin is also available but further back. So brew reads first the path /Users/patrick/.pyenv/shims and only then the path /usr/local/bin and exactly there in /Users/patrick/.pyenv/shims are the *-config files used from Pyenv. So it seems to be that brew has problems with these config files.

Since these config files seems to confuse brew in some way, the best would be if brew could somehow ignore these files. This is possible if we define an alias environment variable. We can define brew as an alias and then instruct zsh that in the event that brew is called a specific PATH applies namely the PATH without the shims directory. For this we have to adapt the ~/.zshrc as follows.

patrick@PatrickMBNeu ~ % cat .zshrc
alias brew='PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin brew'
eval "$(pyenv init -)"
patrick@PatrickMBNeu ~ %

After restarting the terminal I was able to run the brew doctor command without this error message. The problem is solved.

patrick@PatrickMBNeu ~ % brew update 
Already up-to-date.
patrick@PatrickMBNeu ~ % brew doctor     
Your system is ready to brew.
patrick@PatrickMBNeu ~ %