Question

Represent people by a class hierarchy. Classes are often used to model objects in the real world. We may represent the data about a person in a program by a class Person, containing the person's name, address, phone number, date of birth, and nationality. A method __str__ may print the person's data. Implement such a class Person. A worker is a person with a job. In a program, a worker is naturally represented as class Worker derived from class Person, because a worker is a person, i.e., we have an is-a relationship. Class Worker extends class Person with additional data, say name of company, company address, and job phone number. The print functionality must be modified accordingly. Implement this Worker class. A scientist is a special kind of a worker. Class Scientist may therefore be derived from class Worker. Add data about the scientific discipline (physics, chemistry, mathematics, computer science,...). One may also add the type of scientist: theoretical, experimental, or computational. The value of such a type attribute should not be restricted to just one category, since a scientist may be classified as, e.g., both experimental and computational (i.e., you can represent the value as a list or tuple). Implement class Scientist. Researcher, postdoc, and professor are special cases of a scientist. One can either create classes for these job positions, or one may add an attribute (position) for this information in class Scientist. We adopt the former strategy. When, e.g., a researcher is represented by a class Researcher, no extra data or methods are needed. In Python we can create such an "empty" class by writing pass (the empty statement) as the class body: It is a continuous debate in computer science whether multiple inheritance is a good idea or not. One obvious problem \(^{11}\) in the present example is that class Professor inherits two names, one via Teacher and one via Scientist (both these classes inherit from Person). Neither of the two widely used languages Java and C# allow multiple inheritance. Nor in this book will we persue the idea of multiple inheritance further. Name of program file: Person.py.

Short answer

Create a class hierarchy: `Person`, `Worker`, `Scientist`, with specific classes `Researcher`, `Postdoc`, and `Professor`. Use inheritance properly and `pass` for empty classes.

Step-by-step solution

Define the Person Class

Create a class named `Person` that will include attributes to store basic personal details such as name, address, phone number, date of birth, and nationality. Additionally, define the `__str__` method that outputs these details in a string format.

Extend Person to Create Worker Class

Derive a new class `Worker` from the `Person` class. Add attributes specific to a worker such as company name, company address, and job phone number. Override the `__str__` method to include the new worker-specific details while also displaying the inherited personal details.

Extend Worker to Create Scientist Class

Derive a new class `Scientist` from the `Worker` class. Add attributes for scientific discipline and type of scientist, allowing the type to be specified as a list or tuple. Override the `__str__` method to include these new attributes, along with those inherited from `Worker` and `Person`.

Create Specific Classes for Researcher, Postdoc, and Professor

Define classes `Researcher`, `Postdoc`, and `Professor`, each inheriting from the `Scientist` class. Since no new attributes or methods are required, use the `pass` statement to create these classes.

Key concepts

Class Inheritance

The concept of "Class Inheritance" is a cornerstone of Object-Oriented Programming (OOP). Inheritance allows a class, known as the "child" or "derived" class, to inherit properties and behaviors (attributes and methods) from another class, referred to as the "parent" or "base" class. This feature promotes code reusability and logical hierarchy in program design.
In Python, inheritance is implemented by defining a new class that specifies an existing class in parentheses. For instance, if we have a `Person` class, a `Worker` class can be derived using:

• `class Worker(Person):`

With this single line, `Worker` inherits all the features of `Person`. It can also introduce additional attributes and methods or modify the inherited ones. In our exercise solution, this is demonstrated by the `Worker` class adding job-related details and modifying how personal data is printed to include these new details.
Class inheritance especially shines when the "is-a" relationship is evident. For example, a "Worker is-a Person," making `Worker` a logical child of `Person`. Such relationships create clean and maintainable code structures.

Python Programming

Python Programming provides a user-friendly way to implement Object-Oriented concepts like class inheritance and class hierarchies. Python classes are easy to create using the `class` keyword, and features like inheritance are straightforward to use.
The Python `__str__` method, which we use here, is a special method that defines a class's string representation. In a way, it acts like the `toString()` method available in other programming languages. When we print an object of the class, the `__str__` method is called automatically, allowing us to customize what gets printed. For example, our `Person` class uses `__str__` to output personal details. The `Worker` class, which extends `Person`, overrides this method to include additional details, such as company information.
Python's flexibility lies in its ability to use dynamic types, enabling attributes like the type of scientist in a class `Scientist` to be defined as a list or tuple. This way, we can store multiple types of scientific expertise in one attribute, showcasing Python's dynamic and yet robust approach to data handling.

Class Hierarchies

Class Hierarchies in programming help us create organized and logical structures for representing real-world objects and their relationships. Hierarchies start with a base or parent class and extend down to more specific subclasses.
In our exercise, we begin with a `Person` class, which forms the base of the hierarchy. As we move down, the `Worker` class extends `Person`, while `Scientist` builds upon `Worker`. Each step down the hierarchy represents a refinement and specialization of the class. For example, a `Scientist` is a kind of `Worker`, who is originally a `Person`. The hierarchy allows us to manage both common and specific data effectively.
Further, we see more specific classes like `Researcher`, `Postdoc`, and `Professor` derived from `Scientist`. These classes do not introduce new attributes but demonstrate how to extend a hierarchy when specific differentiation is needed, often for clarity or future expansion. The empty use of these classes with a `pass` statement in Python signifies their readiness to expand while maintaining the existing hierarchical structure.