Python is een objectgeoriënteerde programmeertaal die klassen biedt, die een krachtig hulpmiddel zijn voor het schrijven van herbruikbare code. Om objecten met gedeelde kenmerken en gedragingen te beschrijven, worden klassen gebruikt. In dit artikel zullen we Pythons ideeën over klassen en objecten onderzoeken.
Lessen in Python:
In Python is een klasse een door de gebruiker gedefinieerd gegevenstype dat zowel de gegevens zelf bevat als de methoden die kunnen worden gebruikt om deze te manipuleren. In zekere zin dienen klassen als een sjabloon om objecten te maken. Ze bieden de kenmerken en bewerkingen die de objecten zullen gebruiken.
Stel dat een klasse een prototype is van een gebouw. Een gebouw bevat alle details over de vloer, kamers, deuren, ramen etc. Op basis van deze details kunnen we zoveel gebouwen maken als we willen. Daarom kan het gebouw als een klasse worden gezien en kunnen we zoveel mogelijk objecten van deze klasse maken.
Klassen maken in Python
In Python kan een klasse worden gemaakt door het trefwoord class te gebruiken, gevolgd door de klassenaam. Hieronder vindt u de syntaxis voor het maken van een klasse.
Syntaxis
polymorfisme
class ClassName: #statement_suite
In Python moeten we opmerken dat elke klasse is gekoppeld aan een documentatiereeks die toegankelijk is via .__doc__. Een klasse bevat een statementsuite inclusief velden, constructor, functie, etc. definitie.
Voorbeeld:
Code:
Java voegt tekenreeksen samen
class Person: def __init__(self, name, age): # This is the constructor method that is called when creating a new Person object # It takes two parameters, name and age, and initializes them as attributes of the object self.name = name self.age = age def greet(self): # This is a method of the Person class that prints a greeting message print('Hello, my name is ' + self.name)
Naam en leeftijd zijn de twee eigenschappen van de klasse Person. Bovendien heeft het een functie genaamd greet die een begroeting afdrukt.
Objecten in Python:
Een object is een specifiek exemplaar van een klasse met unieke kenmerken en functies. Nadat een klasse is vastgesteld, kunt u er objecten op baseren. Door de klassenconstructor te gebruiken, kunt u een object van een klasse in Python maken. De attributen van het object worden geïnitialiseerd in de constructor, wat een speciale procedure is met de naam __init__.
Syntaxis:
# Declare an object of a class object_name = Class_Name(arguments)
Voorbeeld:
opgeslagen programmabesturing
Code:
class Person: def __init__(self, name, age): self.name = name self.age = age def greet(self): print('Hello, my name is ' + self.name) # Create a new instance of the Person class and assign it to the variable person1 person1 = Person('Ayan', 25) person1.greet()
Uitgang:
'Hello, my name is Ayan'
De zelfparameter
De self-parameter verwijst naar de huidige instantie van de klasse en heeft toegang tot de klassevariabelen. We kunnen alles gebruiken in plaats van self, maar het moet de eerste parameter zijn van elke functie die tot de klasse behoort.
_ _init_ _ methode
Om een instantie van een klasse in Python te maken, wordt een specifieke functie genaamd __init__ aangeroepen. Hoewel het wordt gebruikt om de attributen van het object in te stellen, wordt er vaak naar verwezen als een constructor.
algoritme voor rsa
Het zelfargument is het enige dat vereist is bij de __init__-methode. Dit argument verwijst naar de nieuw gegenereerde instantie van de klasse. Om de waarden van elk attribuut dat aan de objecten is gekoppeld te initialiseren, kunt u extra argumenten declareren in de __init__ methode.
Klasse- en instantievariabelen
Alle instanties van een klasse wisselen klassevariabelen uit. Ze functioneren onafhankelijk van welke klassemethode dan ook en zijn toegankelijk via het gebruik van de klassenaam. Hier is een illustratie:
Code:
class Person: count = 0 # This is a class variable def __init__(self, name, age): self.name = name # This is an instance variable self.age = age Person.count += 1 # Accessing the class variable using the name of the class person1 = Person('Ayan', 25) person2 = Person('Bobby', 30) print(Person.count)
Uitgang:
2
Terwijl instantievariabelen specifiek zijn voor elke instantie van een klasse. Ze worden gespecificeerd met behulp van het zelfargument in de __init__-methode. Hier is een illustratie:
Code:
lijst Java
class Person: def __init__(self, name, age): self.name = name # This is an instance variable self.age = age person1 = Person('Ayan', 25) person2 = Person('Bobby', 30) print(person1.name) print(person2.age)
Uitgang:
Ayan 30
Klassevariabelen worden afzonderlijk van alle klassenmethoden gemaakt en worden gedeeld door alle klassenkopieën. Elke instantie van een klasse heeft zijn eigen instantievariabelen, die worden gespecificeerd in de __init__-methode met behulp van het zelfargument.
Conclusie:
Kortom, de klassen- en objectbegrippen van Python zijn sterke ideeën waarmee je herbruikbare programma's kunt schrijven. U kunt informatie en mogelijkheden combineren in één enkele entiteit die kan worden gebruikt om vele objecten te bouwen door een klasse op te zetten. Met behulp van de puntnotatie heeft u toegang tot de methoden en eigenschappen van een object nadat het is gemaakt. Je kunt logischere, effectievere en beheersbare code ontwikkelen door de klassen en objecten van Python te begrijpen.