It would be strange to write a class that accepts "arbitrary keyword" arguments for the __init__(). But you aren't doing that. You are replacing the __dict__ object that normally holds all the class attributes with an external dictionary. That is even stranger. Why are you doing this?
Normally a class is aware of what attributes instances of the class are likely to have. Methods of the class can perform operations on the attributes with some confidence that the attributes exist. Your User can only be confident that it can access attributes that it added to the data dictionary. For example, I create two users that have a location, but I make a typo when entering one of the users. Flo Rida has a location attribute, but there is no location attribute for Junior, and that raises an exception when we ask User Junior for their location.
class User:
def __init__(self, fname, lname, **data):
self.data = data
self.data["first name"] = fname
self.data["last name"] = lname
self.data["login_attempts"] = 0
def __getitem__(self, index):
"""Adds [] indexing to class."""
return self.data[index]
def __str__(self):
return "\n".join(f"{key} : {value}" for key, value in self.data.items())
flo_rida = User("Flo", "Rida", location="Florida")
junior_rida = User("Junior", "Rida", loc="Florida")
print(flo_rida, "\n")
print(junior_rida, "\n")
print(flo_rida["location"])
print(junior_rida["location"])Output:
location : Florida
first name : Flo
last name : Rida
login_attempts : 0
loc : Florida
first name : Junior
last name : Rida
login_attempts : 0
Florida
Error:
Traceback (most recent call last):
File ..., line 19, in <module>
print(junior_rida["location"])
Classes should offer more than dictionaries. They should guarantee a commonality amongst their instances and provide an API for using instances of the class. I would write your code like this:
class Privileges:
def __init__(self, *args):
self.privileges = list(*args)
def __str__(self):
return str(self.privileges)
class User:
def __init__(self, fname, lname, location=None, priv=None):
self.first_name = fname
self.last_name = lname
self.login_attempts = 0
self.location = location
self.privileges = Privileges(priv or [])
def __str__(self):
return "\n".join((
self.__class__.__name__,
f"First Name: {self.first_name}",
f"Last Name: {self.last_name}",
f"Location: {self.location}",
f"Priviledges: {self.privileges}"
))
def increment_login_attempts(self):
self.login_attempts += 1
def reset_login_attempts(self):
self.login_attempts = 0
class Admin(User):
def __init__(self, *args, priv=None, **kwargs):
priv = priv or ("can add a post", "can delete a post", "can ban a user")
super().__init__(*args, priv=priv, **kwargs)
admin = Admin("Derrick", "Brown", location="Florida, USA")
print(admin, "\n")
user = User("Flo", "Rida", priv=["can add a post"])
print(user)Output:
Admin
First Name: Derrick
Last Name: Brown
Location: Florida, USA
Priviledges: ['can add a post', 'can delete a post', 'can ban a user']
User
First Name: Flo
Last Name: Rida
Location: None
Priviledges: ['can add a post']
I would also consider making User and Administrator dataclasses..
from dataclasses import dataclass
class Privileges:
def __init__(self, *args):
self.privileges = list(*args)
def __str__(self):
return str(self.privileges)
@dataclass
class User:
first_name: str
last_name: str
location: str = None
privileges: Privileges = Privileges()
login_attempts: int = 0
def increment_login_attempts(self):
self.login_attempts += 1
def reset_login_attempts(self):
self.login_attempts = 0
@dataclass
class Admin(User):
def __init__(self, *args, privileges=None, **kwargs):
privileges = privileges or ("can add a post", "can delete a post", "can ban a user")
super().__init__(*args, privileges=privileges, **kwargs)
admin = Admin("Derrick", "Brown", location="Florida, USA")
print(admin, "\n")
user = User("Flo", "Rida", privileges=["can add a post"])
print(user)Output:
Admin(first_name='Derrick', last_name='Brown', location='Florida, USA', privileges=('can add a post', 'can delete a post', 'can ban a user'), login_attempts=0)
User(first_name='Flo', last_name='Rida', location=None, privileges=['can add a post'], login_attempts=0)
And if, for some reason, you really want to have a class that assigns some arbitrary attributes in the __init__(), you can do that like this:
class Privileges:
def __init__(self, *args):
self.privileges = list(*args)
def __str__(self):
return str(self.privileges)
class User:
def __init__(self, fname, lname, location=None, priv=None, extras=None):
self.first_name = fname
self.last_name = lname
self.login_attempts = 0
self.location = location
self.privileges = Privileges(priv or [])
if extras:
for key, value in extras.items():
setattr(self, key, value)
def __str__(self):
fields = [self.__class__.__name__] + [f"{key:15}: {value}" for key, value in self.__dict__.items()]
return "\n".join(fields)
def increment_login_attempts(self):
self.login_attempts += 1
def reset_login_attempts(self):
self.login_attempts = 0
class Admin(User):
def __init__(self, *args, priv=None, **kwargs):
priv = priv or ("can add a post", "can delete a post", "can ban a user")
super().__init__(*args, priv=priv, **kwargs)
user = User("Flo", "Rida", priv=["can add a post"], extras={"occupation":"Rapper"})
print(user)Output:
User
first_name : Flo
last_name : Rida
login_attempts : 0
location : None
privileges : ['can add a post']
occupation : Rapper
