Python Academy · Lezione

Polimorfismo

Esplori come il polimorfismo consenta di scrivere codice flessibile e dinamico

Polimorfismo è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 4 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 6 lezioni in totale.

Introduzione al polimorfismo

Il polimorfismo è un concetto fondamentale della programmazione orientata agli oggetti (OOP) che consente di trattare oggetti di classi diverse come oggetti di una superclasse comune. Offre flessibilità e riutilizzabilità del codice.

In questa lezione imparerà a implementare il polimorfismo in Python usando metodi e classi.

Che cos'è il polimorfismo?

Il polimorfismo consente ai metodi di classi diverse di avere lo stesso nome e un comportamento differente. Rende il codice più flessibile e facile da estendere.

# Defining a superclass
class Animal:
    # Method in the superclass
    def speak(self):
        print("Animal speaks")  # Generic message for all animals

# Defining a subclass that overrides the speak method
class Dog(Animal):
    def speak(self):
        print("Dog barks")  # Specific behavior for Dog

Polimorfismo con i metodi

Metodi con lo stesso nome in classi diverse possono fornire implementazioni differenti.

# Another subclass with its own implementation of the speak method
class Cat(Animal):
    def speak(self):
        print("Cat meows")  # Specific behavior for Cat

# Function demonstrating polymorphism
# It can accept objects of any subclass of Animal

def animal_sound(animal):
    animal.speak()  # Calls the appropriate speak method based on the object type

# Creating objects of Dog and Cat
dog = Dog()
cat = Cat()

# Calling the function with different objects
animal_sound(dog)  # Outputs: Dog barks
animal_sound(cat)  # Outputs: Cat meows

Esempio di polimorfismo con i metodi

Polimorfismo con i metodi

Metodi con lo stesso nome in classi diverse possono fornire implementazioni differenti.

# Another subclass with its own implementation of the speak method
class Cat(Animal):
    def speak(self):
        print("Cat meows")  # Specific behavior for Cat

# Function demonstrating polymorphism
# It can accept objects of any subclass of Animal

def animal_sound(animal):
    animal.speak()  # Calls the appropriate speak method based on the object type

# Creating objects of Dog and Cat
dog = Dog()
cat = Cat()

# Calling the function with different objects
animal_sound(dog)  # Outputs: Dog barks
animal_sound(cat)  # Outputs: Cat meows

Polimorfismo con le funzioni

Il polimorfismo consente alla stessa funzione di operare su oggetti di tipo diverso.

# Defining two unrelated classes
class Bird:
    def fly(self):
        print("Bird flies")  # Behavior specific to birds

class Plane:
    def fly(self):
        print("Plane flies")  # Behavior specific to planes

# Function demonstrating polymorphism
# It can accept objects of both Bird and Plane

def flying_object(obj):
    obj.fly()  # Calls the appropriate fly method based on the object type

# Creating objects of Bird and Plane
bird = Bird()
plane = Plane()

# Calling the function with different objects
flying_object(bird)  # Outputs: Bird flies
flying_object(plane)  # Outputs: Plane flies

Polimorfismo con l'ereditarietà

Il polimorfismo viene spesso ottenuto tramite l'ereditarietà, in cui le sottoclassi sovrascrivono i metodi della superclasse.

# Superclass representing a generic vehicle
class Vehicle:
    def start(self):
        print("Vehicle starts")  # Generic behavior for all vehicles

# Subclass representing a specific type of vehicle
class Car(Vehicle):
    def start(self):
        print("Car starts")  # Specific behavior for cars

# Subclass representing another specific type of vehicle
class Bike(Vehicle):
    def start(self):
        print("Bike starts")  # Specific behavior for bikes

# Function demonstrating polymorphism
# It can accept objects of any subclass of Vehicle

def start_vehicle(vehicle):
    vehicle.start()  # Calls the appropriate start method based on the object type

# Creating objects of Car and Bike
car = Car()
bike = Bike()

# Calling the function with different objects
start_vehicle(car)  # Outputs: Car starts
start_vehicle(bike)  # Outputs: Bike starts

Vantaggi del polimorfismo

Il polimorfismo offre diversi vantaggi:

Riutilizzabilità e flessibilità del codice.
Migliore leggibilità e organizzazione del codice.
Promuove l'uso di interfacce comuni.

Esempio del mondo reale

Ecco un esempio del mondo reale che utilizza il polimorfismo.

# Real-world example of polymorphism
class Developer:
    def work(self):
        print("Writing code")  # Specific task for developers

class Designer:
    def work(self):
        print("Designing user interfaces")  # Specific task for designers

# Function demonstrating polymorphism
# It can accept objects of both Developer and Designer

def workday(employee):
    employee.work()  # Calls the appropriate work method based on the object type

# Creating objects of Developer and Designer
developer = Developer()
designer = Designer()

# Calling the function with different objects
workday(developer)  # Outputs: Writing code
workday(designer)  # Outputs: Designing user interfaces

Errori comuni con il polimorfismo

Ecco alcuni errori da evitare:

Dimenticare di sovrascrivere i metodi nelle sottoclassi quando necessario.
Confondere l'ordine di risoluzione dei metodi (MRO) nell'ereditarietà multipla.
Usare il polimorfismo senza necessità per attività semplici.

Che cosa abbiamo imparato?

In questa lezione ha imparato:

Che cos'è il polimorfismo e come funziona in Python.
Come implementare il polimorfismo con i metodi e l'ereditarietà.
I vantaggi dell'uso del polimorfismo nella programmazione orientata agli oggetti.

Ottimo lavoro! Passiamo al prossimo argomento.

Domande Frequenti

La lezione «Polimorfismo» è gratuita?

Sì — il testo completo di «Polimorfismo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 6 lezioni in totale.

Cosa imparerò in «Polimorfismo»?

Esplori come il polimorfismo consenta di scrivere codice flessibile e dinamico Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 6.

Quanto tempo richiede la lezione «Polimorfismo»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy