Overload the initialization function
Overloading initialization functions means that multiple constructors are defined in the same class and can be constructed through a variety of different methods.
For example, if we create a student class, when creating a student, we need to provide the student's name and date of birth, for the date of birth, we consider using the date object and initializing it directly. You can also use the year, month and day to initialize it separately. Alternatively, it can also be initialized using a time string such as 2024-11-14.
There is no direct function overloading in python, however, we have multiple ways to implement similar functions.
python implementation
According to object type
This method implements parsing through different methods according to the type of parameters passed in. But the disadvantage is that when there are many types, the code becomes very complicated.
from datetime import date
class Student:
def __init__(self, name, birth_date):
if isinstance(birth_date, date):
self.birth_date = birth_date
elif isinstance(birth_date, str):
try:
year, month, day = map(int, birth_date.split("-"))
self.birth_date = date(year, month, day)
except ValueError:
raise ValueError("Date string format should be YYYY-MM-DD")
elif isinstance(birth_date, tuple) and len(birth_date) == 3:
year, month, day = birth_date
self.birth_date = date(year, month, day)
else:
raise TypeError("birth_dateMust bedateObject，YYYY-MM-DDFormat string，or(Year, moon, day)Tuples of")
= name
def __str__(self):
return f"Student(name={}, birth_date={self.birth_date})"
student1 = Student("sagegrass", date(2011, 11, 11))
student2 = Student("sagegrass", "2011-11-11")
student3 = Student("sagegrass", (2011, 11, 11))
print(student1)
print(student2)
print(student3)Use class methods
Typically, using class methods is considered the best practice method, with the only downside of being slightly different from regular initialization, so some users may not be able to adapt.
from datetime import date
class Student:
def __init__(self, name, birth_date):
if not isinstance(birth_date, date):
raise TypeError("birth_date must be type")
= name
self.birth_date = birth_date
@classmethod
def from_string(cls, name, birth_date_str):
try:
year, month, day = map(int, birth_date_str.split("-"))
birth_date = date(year, month, day)
return cls(name, birth_date)
except ValueError:
raise ValueError("Date string format should be YYYY-MM-DD")
@classmethod
def from_year_month_day(cls, name, year, month, day):
try:
birth_date = date(year, month, day)
return cls(name, birth_date)
except ValueError:
raise ValueError("The date is invalid, please use the correct year, month and date")
def __str__(self):
return f"Student(name={}, birth_date={self.birth_date})"
student1 = Student("sagegrass", date(2011, 11, 11))
student2 = Student.from_string("sagegrass", "2011-11-11")
student3 = Student.from_year_month_day("sagegrass", 2011, 11, 11)
print(student1)
print(student2)
print(student3)Using static methods
It is also feasible to change the class method you used before to a static method, so that you no longer need to access the class itself.
from datetime import date
class Student:
def __init__(self, name, birth_date):
if not isinstance(birth_date, date):
raise TypeError("birth_date must be type")
= name
self.birth_date = birth_date
@staticmethod
def from_year_month_day(name, year, month, day):
try:
birth_date = date(year, month, day)
return Student(name, birth_date)
except ValueError:
raise ValueError("The date is invalid, please use the correct year, month and date")
def __str__(self):
return f"Student(name={}, birth_date={self.birth_date})"
student = Student.from_year_month_day("sagegrass", 2011, 11, 11)
print(student)However, it should be noted that in general, class methods should be used instead of static methods. Because in the case of inheritance relationships, the class method can always guarantee that the instance of the subclass is returned. The static method returns an instance of the parent class, resulting in a situation that does not meet expectations.
Use parameters with default values
When a large number of default value parameters are provided, the initialization function becomes complex and difficult to understand, and the disadvantage is similar to initializing according to the object type.
from datetime import date
class Student:
def __init__(self, name, birth_date=None, year=None, month=None, day=None):
if birth_date is not None:
if not isinstance(birth_date, date):
raise TypeError("birth_date must be type")
self.birth_date = birth_date
elif all([year, month, day]):
try:
self.birth_date = date(year, month, day)
except ValueError:
raise ValueError("The date is invalid, please use the correct year, month and date")
else:
raise ValueError("Birth_date or a combination of year, month and day must be provided")
= name
def __str__(self):
return f"Student(name={}, birth_date={self.birth_date})"
student1 = Student("sagegrass", birth_date=date(2011, 11, 11))
student2 = Student("sagegrass", year=2011, month=11, day=11)
print(student1)
print(student2)Moreover, using this method usually cannot satisfy the use of positional parameters for incoming at the same time, so it is also possible to consider prohibiting the use of positional parameters.
# Disable location parametersdef __init__(self, name, *, birth_date=None, year=None, month=None, day=None):
pass
# Or allow birth_date to use positional parameters, but not year, month, day, daydef __init__(self, name, birth_date=None, *, year=None, month=None, day=None):
passThis is the article about the detailed explanation of the method of python reloading initialization functions. For more related contents of python reloading initialization functions, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!