Incapsulamento
Esplori concetti avanzati della programmazione orientata agli oggetti.
Incapsulamento è una lezione Python For Kids gratuita su CoddyKit. Questa è la lezione 4 di 5. 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 For Kids, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python For Kids include 5 lezioni in totale.
Incapsulamento
La lezione sulla programmazione orientata agli oggetti (OOP) continua! Oggi impareremo a conoscere l'incapsulamento in Python, un concetto fondamentale che aiuta a proteggere dati e metodi all'interno delle classi.
Che cos'è l'incapsulamento
L'incapsulamento è il concetto di raggruppare dati (attributi) e metodi (funzioni) che operano su tali dati all'interno di una singola unità, nota come classe. Limita inoltre l'accesso diretto ad alcuni componenti di un oggetto, nascondendone la rappresentazione interna all'esterno.
- Nascondimento dei dati: protezione dello stato interno di un oggetto da interferenze indesiderate.
- Controllo degli accessi: definizione delle modalità di accesso o modifica di dati e metodi.
L'incapsulamento garantisce che gli oggetti controllino i propri dati ed espongano solo ciò che è necessario.
Modificatori di accesso
In Python, l'incapsulamento viene implementato utilizzando modificatori di accesso per controllare la visibilità dei membri della classe (attributi e metodi). Esistono tre tipi di modificatori di accesso:
- Pubblico: accessibile da qualsiasi punto.
- Protetto: accessibile all'interno della classe e delle sue sottoclassi.
- Privato: accessibile solo all'interno della classe stessa.
Vediamo come utilizzare questi modificatori di accesso in Python.
Attributi e metodi pubblici
I membri pubblici sono accessibili dall'esterno della classe. Per impostazione predefinita, tutti gli attributi e i metodi sono pubblici, salvo diversa indicazione.
Esempio:
# Defines the Person class with public attributes and methods
class Person:
def __init__(self, name, age):
self.name = name # Public attribute
self.age = age # Public attribute
def greet(self):
print("Hello, my name is " + self.name + "!") # Public method
# Creates an object of the Person class
person1 = Person("Alice", 30)
# Accesses public attributes and methods
print(person1.name) # Output: Alice
person1.greet() # Output: Hello, my name is Alice!
Attributi e metodi protetti
I membri protetti sono indicati dal prefisso costituito da un singolo carattere di sottolineatura (_). Sono accessibili all'interno della classe e delle sue sottoclassi, ma non dovrebbero essere utilizzati direttamente dall'esterno della classe.
Esempio:
# Defines the Employee class with protected attributes and methods
class Employee:
def __init__(self, name, salary):
self._name = name # Protected attribute
self._salary = salary # Protected attribute
def _increase_salary(self, amount):
self._salary += amount # Protected method
print(self._name + "'s new salary is " + str(self._salary))
# Creates an object of the Employee class
employee1 = Employee("Bob", 50000)
# Accesses protected attributes and methods (not recommended)
print(employee1._name) # Output: Bob
employee1._increase_salary(5000) # Output: Bob's new salary is 55000
Attributi e metodi privati
I membri privati sono indicati dal prefisso costituito da due caratteri di sottolineatura (__). Sono accessibili solo all'interno della classe stessa e non è possibile accedervi direttamente dall'esterno della classe.
Esempio:
# Defines the BankAccount class with private attributes and methods
class BankAccount:
def __init__(self, owner, balance):
self.__owner = owner # Private attribute
self.__balance = balance # Private attribute
def deposit(self, amount):
self.__balance += amount # Modifies private attribute
print("Deposited:", amount)
self.__show_balance()
def __show_balance(self):
print("Current Balance:", self.__balance) # Private method
# Creates an object of the BankAccount class
account1 = BankAccount("Charlie", 1000)
# Attempts to access private attributes and methods (will cause errors)
# print(account1.__owner) # AttributeError
# account1.__show_balance() # AttributeError
# Uses public methods to interact with private attributes
account1.deposit(500) # Output:
# Deposited: 500
# Current Balance: 1500
Perché utilizzare l'incapsulamento
L'incapsulamento offre diversi vantaggi:
- Controllo: controllare le modalità di accesso o modifica dei dati.
- Sicurezza: proteggere lo stato interno di un oggetto da modifiche indesiderate.
- Manutenibilità: rendere il codice più facile da mantenere e meno soggetto a errori.
L'incapsulamento contribuisce a creare applicazioni solide e sicure.
Esempio di incapsulamento: classe Car
Creiamo una classe Car che utilizza l'incapsulamento per proteggere i propri attributi e metodi.
Codice:
# Defines the Car class with encapsulated attributes and methods
class Car:
def __init__(self, make, model, year):
self.make = make # Public attribute
self.model = model # Public attribute
self.__year = year # Private attribute
def get_year(self):
return self.__year # Public method to access private attribute
def set_year(self, year):
if year > 0:
self.__year = year # Public method to modify private attribute
print("Year updated to", self.__year)
else:
print("Invalid year!")
def __display_info(self):
print(self.make, self.model, self.__year) # Private method
def show_info(self):
self.__display_info() # Public method that calls a private method
# Creates an object of the Car class
car1 = Car("Tesla", "Model S", 2020)
# Accesses public attributes and methods
print(car1.make) # Output: Tesla
print(car1.get_year()) # Output: 2020
# Modifies the private attribute using a public method
car1.set_year(2021) # Output: Year updated to 2021
# Calls a public method that interacts with a private method
car1.show_info() # Output: Tesla Model S 2021
# Attempts to access private attributes and methods directly (will cause errors)
# print(car1.__year) # AttributeError
# car1.__display_info() # AttributeError
# Defines the Student class with encapsulated attributes
class Student:
def __init__(self, name, grade):
self.name = name # Public attribute
self.__grade = grade # Private attribute
def get_grade(self):
return self.__grade # Public method to access private attribute
def set_grade(self, grade):
if 0 <= grade <= 100:
self.__grade = grade # Updates the grade
else:
print("Invalid grade!")
# Creates an object of the Student class
student1 = Student("Diana", 85)
# Accesses and modifies the grade using public methods
print(student1.get_grade()) # Output: 85
student1.set_grade(90)
print(student1.get_grade()) # Output: 90
# Attempts to access the private attribute directly (will cause an error)
# print(student1.__grade) # AttributeError
Ottimo lavoro!
Ha imparato a usare l'incapsulamento in Python per proteggere dati e metodi all'interno delle classi. L'incapsulamento aiuta a controllare l'accesso ai dati degli oggetti, rendendo i programmi più sicuri e facili da manutenere. Continui a esercitarsi progettando classi con modificatori di accesso appropriati per migliorare le Sue competenze di programmazione!
Domande Frequenti
La lezione «Incapsulamento» è gratuita?
Sì — il testo completo di «Incapsulamento» è 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 For Kids, passa a CoddyKit PRO. Il corso Python For Kids include 5 lezioni in totale.
Cosa imparerò in «Incapsulamento»?
Esplori concetti avanzati della programmazione orientata agli oggetti. Eserciti Python For Kids 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 For Kids?
Non è richiesta alcuna esperienza precedente. Python For Kids 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 5.
Quanto tempo richiede la lezione «Incapsulamento»?
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 For Kids?
Sì. Ogni lezione Python For Kids 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
- Introduzione alla programmazione orientata agli oggetti
- Creare classi e oggetti
- Ereditarietà
- Incapsulamento
- Polimorfismo