xxxxxxxxxx
class Person:#set name of class to call it
def __init__(self, name, age):#func set ver
self.name = name#set name
self.age = age#set age
def myfunc(self):#func inside of class
print("Hello my name is " + self.name)# code that the func dose
p1 = Person("barry", 50)# setting a ver fo rthe class
p1.myfunc() #call the func and whitch ver you want it to be with
xxxxxxxxxx
class Person:
# class static variable
person_type = "Human"
# class constructor
def __init__(self, first_name, last_name, age):
self.first_name = first_name
self.last_name = last_name
self.age = age
# initialized class method
def get_full_name(self):
return f"{self.first_name} {self.last_name}"
# initialized class method
def introduce(self):
return f"Hi. I'm {self.first_name} {self.last_name}. I'm {self.age} years old."
# class static method
@staticmethod
def class_name(self):
return 'Person'
# class method
@classmethod
def create_anonymous(cls):
return Person('John', 'Doe', 25)
# dunder method - return class as a string when typecast to a string
def __str__(self):
return f"str firstname: {self.first_name} lastname: {self.last_name} age: {self.age}"
# dunder method - return class a string then typecast to representative
def __repr__(self):
return f"repr firstname: {self.first_name} lastname: {self.last_name} age: {self.age}"
# dunder method - return sum of ages when using the + operator on two Person classes
def __add__(self, other):
return self.age + other.age
# create a person class
bob = Person(first_name="John", last_name="Doe", age=41)
# print static method
print(Person.class_name(Person))
# print new class person
print(Person.create_anonymous().get_full_name())
# print class static method
print(Person.person_type)
# print string representation of class
print(bob)
# print representation of class
print(repr(bob))
# add Person classes ages using dunder method
print(bob + bob)
xxxxxxxxxx
class Animal(object): # Doesn't need params but put it there anyways.
def __init__(self, species, price):
self.species = species # Sets species name
self.price = price # Sets price of it
def overview(self): # A function that uses the params of the __init__ function
print(f"This species is called a {self.species} and the price for it is {self.price}")
class Fish(Animal): # Inherits from Animal
pass # Don't need to add anything because it's inherited everything from Animal
salmon = Fish("Salmon", "$20") # Make a object from class Fish
salmon.overview() # Run a function with it
dog = Animal("Golden retriever", "$400") # Make a object from class Animal
dog.overview() # Run a function with it
xxxxxxxxxx
class Dog(object):
def __init__(self, name, age):
self.name = name
self.age = age
def speak(self):
print("Hi I'm ", self.name, 'and I am', self.age, 'Years Old')
JUB0T = Dog('JUB0T', 55)
Friend = Dog('Doge', 10)
JUB0T.speak()
Friend.speak()
xxxxxxxxxx
class Dog:
def bark(self):
print("Woof!")
def roll(self):
print("*rolling*")
def greet(self):
print("Greetings, master")
def speak(self):
print("I cannot!")
# Creating the Dog class instance and saving it to the variable <clyde>
clyde = Dog()
clyde.bark() # --> Woof!
clyde.roll() # --> *rolling*
clyde.greet() # --> Greetings, master
clyde.speak() # --> I cannot!
# Creating another Dog instance
jenkins = Dog()
jenkins.bark() # --> Woof!
jenkins.roll() # --> *rolling*
# .. And other methods
# .. Infinite objects can be created this way, all implementing the same methods defined in our class
xxxxxxxxxx
class MyClass:
def __init__(self, name, age):
self.name = name
self.age = age
def say_hello(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
# Example usage:
obj = MyClass("John", 25)
obj.say_hello()
xxxxxxxxxx
class Human():
def __init__(self, _name, _age):
self.name = _name
self.age = _age
def walk(self):
print("walking...")
Person = Human('John', 32)
Person.walk()
xxxxxxxxxx
class Car():
def __init__(self, _name, _year):
self.name = _name
self.age = _age
def start(self):
print("starting...")
def drive(self):
print("Vroom Vroom!")
myCar = Car('Audi', 2019)
myCar.start()
myCar.drive()