Gettry a settery v Pythonu se liší od metod v jiných jazycích OOP. Primárním využitím metod getter a setter je poskytnout zapouzdření dat v objektově orientovaných programech. Na rozdíl od jiných objektově orientovaných jazyků nejsou privátní proměnné v Pythonu skrytá pole. Některé OOP jazyky používají getry a settery k zapouzdření dat. Chceme skrýt atributy třídy objektu před ostatními třídami, aby metody v jiných třídách náhodně nezměnily data.
V jazycích OOP se gettery a settery používají k načítání a aktualizaci dat. Getter získá aktuální hodnotu atributu objektu, zatímco setter modifikuje hodnotu atributu objektu. V tomto článku probereme getter a setter v Pythonu s příklady.
Co je to getter v Pythonu?
Getters (getters) v Pythonu jsou metody, které se používají v objektově orientovaném programování (OOP) pro přístup k soukromým atributům třídy. Funkce setattr() v Pythonu je konzistentní s funkcí getattr() v Pythonu. Mění hodnoty atributů objektu.
Co je setter v Pythonu?
Setter v Pythonu je metoda, která se používá k nastavení hodnoty vlastnosti. V objektově orientovaném programování je velmi užitečné nastavit hodnotu soukromých atributů ve třídě.
Obecně se getry a settery používají hlavně k zapouzdření dat v OOP.
Použití běžné funkce k provádění funkcí getr a setter
Pokud zadáme normální metody get() a set() pro dosažení vlastnosti getters a setters, nebude žádná speciální implementace.
Podívejme se na příklad, abychom pochopili, jak můžeme použít regulární funkci k získání funkcí getr a setter.
class Javatpoint: def __init__(self, age = 0): self._age = age # pomocí metody getter def get_age(self): return self._age # pomocí metody setter def set_age(self, a): self._age = a John = Javatpoint() #pomocí funkce setter John.set_age(19) # pomocí funkce getter print(John.get_age()) print(John._age)
Po provedení tohoto kódu získáme výstup, jak je znázorněno níže:
19 19
K dosažení této funkce metody get age() a set age() ve výše uvedeném kódu fungují jako standardní funkce a neovlivňují metody getter a setter. Python má jedinečnou vlastnost function().
Použití funkce property() jako getterů a nastavovačů
V Pythonu je property() vestavěná funkce pro vytváření a vracení vlastnosti objektu. Existují tři metody: getter(), setter() a delete(). V Pythonu má funkce property() čtyři argumenty: vlastnosti (fget, fset, fdel, doc). Funkce fget se používá k získání hodnoty atributu. Funkce fset se používá k nastavení hodnoty atributu. Funkce fdel se používá k odstranění hodnoty atributu. Atributu je přiřazen dokumentační řetězec doc.
Podívejme se na příklad, abychom pochopili, jak můžeme použít funkci property() k dosažení chování getterů a setterů.
class Javatpoint: def __init__(self): self._age = 0 # pomocí funkce get def get_age(self): print("metoda getter") return self._age # pomocí funkce set def set_age(self, y): print ("metoda setter") self._age = y # pomocí funkce del def del_age(self): del self._age age = property(get_age, set_age, del_age) John = Javatpoint() John.age = 18 print(John. stáří) Výstup: Po provedení tohoto výše uvedeného kódu získáme výstup, jak je znázorněno níže:
metoda setter metoda getter 18
Ve výše uvedeném programu je pouze jeden tiskový příkaz. Výstup sestává ze tří řádků, protože je volána metoda set age() setter a metoda getter get age() je volána. V důsledku toho je věk vlastnost, která pomáhá zajistit bezpečnost přístupu k soukromým proměnným.
Pomocí dekorátorů @property
V předchozí metodě jsme použili funkci property() k dosažení chování getterů a setterů. Jak však bylo zmíněno dříve v tomto článku, getry a settery se také používají ke kontrole získávání a nastavení hodnot atributů.
Další metodou prosazování funkce nemovitosti je použití dekoratérů. @property je jedním z vestavěných dekorátorů Pythonu. Hlavním účelem jakéhokoli dekorátoru je změnit metody nebo atributy třídy tak, aby uživatel třídy nemusel měnit svůj kód.
Podívejme se na příklad, abychom pochopili, jak můžeme použít @property decorators k dosažení chování getter a setter.
class Javatpoint: def __init__(self): self._age = 0 # pomocí funkce getter @property def age(self): print("metoda getter") return self._age #now, pomocí funkce setter @age.setter def age(self, x): if(x < 20): raise ValueError("věk je pod kritérii způsobilosti") print("metoda nastavení") self._age = x John = Javatpoint() John.age = 25 print( John.age) metoda setter s názvem getter metoda s názvem 25
Výše uvedený kód ukazuje, jak použít @property decorator k vytvoření getterů a setterů. Výše uvedený příklad slouží jako ověřovací kód, který vyvolá hodnotu ValueError, pokud se pokusíme inicializovat stáří s hodnotou menší než 20.
Nastavení atributů jako soukromých
Nyní uvidíme, jak udělat metody soukromé, aby externí volající funkce nemohli manipulovat s proměnnými uvnitř nich. Mohou být ovládány pouze funkcemi definovanými ve třídě. Uzavřou se, pokud před ně dáte dvě podtržítka.
Podívejme se na příklad, abychom pochopili, jak můžeme v programu nastavit atributy jako soukromé.
class Javatpoint: def __init__(self, age=49): self._age = age # make the getter method def get_age(self): return self.__age # make the setter method def set_age(self, a): self.__age = a grad_obj = Javatpoint() print(grad_obj._age) # Před použitím setter print(grad_obj.get_age()) # Po použití setteru grad_obj.set_age(2020) print(grad_obj._age)
Výstup: Po provedení tohoto výše uvedeného kódu získáme výstup, jak je znázorněno níže:
Čtení hodnot ze soukromých metod
Pro čtení hodnoty ze soukromých metod musíme použít metodu getter. Bez použití metody getter nemůžeme použít metodu vlastností pro přístup k hodnotám soukromých atributů. Pro pochopení této metody si uveďme příklad.
# Program pro čtení hodnoty ze třídy soukromé metody Javatpoint: def __init__(self, year=27): self._year = year @property def Aboutyear(self): return self.__year @Aboutyear.setter def Aboutyear(self, x ): self.__year = x grad_obj = Javatpoint() print(grad_obj._year) grad_obj.year = 2020 print(grad_obj.year)
27 2020
Vezměme si další příklad vytvoření třídy s vlastnostmi. Z této třídy si vezmeme několik objektů.
class Javatpoint: def __init__(self): self.emp = "Žádný" Mark = Friend() John = Friend()
Vlastnost (Emp) není pro tyto objekty nastavena. Mohli bychom to nainstalovat přímo, ale to není nejlepší metoda. Místo toho vytvoříme dvě metody: getEmp() a setEmp().
class Javatpoint: def __init__(self): self.emp = "None" def getEmp(self): return self.emp def setEmp(self, emp): self.emp = emp Mark = Javatpoint() John = Javatpoint() Mark .setEmp("Developer") John.setEmp("Designer") print(John.emp) print(Mark.emp) 
Použití getterů a setterů k zapouzdření dat je jedním ze základních principů objektově orientovaného programování. Přečtěte si, co to je a jak to funguje v tomto materiálu.
Děti z Mariupolu potřebují ke vzdělání 120 notebooků – darujte starý hardware, ať to funguje pro budoucnost Ukrajiny
Atributy – co jsou a jak se používají
Vzhledem k tomu, že níže popsané gettry a settery pracují s atributy, pojďme si nejprve říci, co jsou atributy a jak se používají.
V Pythonu má každý objekt svou vlastní sadu atributů, které definují jeho stav a chování. Atributy mohou být:
- proměnné (data uložená uvnitř objektu);
Kurz na téma Řízení týmu v podnikání.
Online kurz pro efektivní týmové řízení, nasměrování vytváření proaktivních a nezávislých týmů bez nutnosti mikromanagementu.
Každý atribut má název, který lze použít pro přístup k hodnotě proměnné nebo volání metody.
Klasickým příkladem použití atributů v Pythonu je třída Point, která představuje geometrický bod v rovině.
V této třídě jsou atributy souřadnicemi x a y, což mohou být proměnné uložené uvnitř objektu.
Zde je to, jak to vypadá v kódu:
class Point: def __init__(self, x, y): self.x = x self.y = y
Vytvoříme a inicializujeme třídu Point se dvěma atributy x a y, tedy souřadnicemi bodu. Atributy se nastavují v konstruktoru třídy pomocí metody __init__.
Poté můžeme vytvořit objekt Point a použít jej k reprezentaci geometrického bodu v rovině. Například:
p = Bod(2, 3) tisk(p.x) # 2 tisk(p.y) # 3
V tomto příkladu vytvoříme objekt p třídy a Point a předáme mu hodnoty 2 a 3 jako souřadnice x a y. Potom použijeme atributy x a y objektu p, abychom získali jeho hodnoty souřadnic.
Atribut v programování (proměnná nebo metoda) odkazuje na objekt. V Pythonu je vše objekt.
Anglický kurz.
Online výuka angličtiny pro metodologii Cambridge – výběr přes miliardu lidí.
To zahrnuje třídy: jsou to konstruktory objektů, to znamená, že poskytují šablonu pro vytváření instancí třídy. Třídy mají své vlastní atributy a metody, které lze použít k vytvoření instancí dané třídy.
Metody získávání a nastavování atributů
Existuje několik způsobů, jak získat a nastavit atributy v Pythonu.
Použití tečkové notace
To znamená, že k atributu objektu přistupujeme pomocí tečky a názvu atributu. Pokud máme například objekt Person s atributem name, můžeme jeho hodnotu získat pomocí výrazu Person.name.
Příklad tečkové notace v kódu:
třída Zvíře: def __init__(já, jméno, druh): self.jméno = jméno self.druh = druh třída Kočka(Zvíře): def __init__(já, jméno, barva): super().__init__(jméno, druh=" Kočka") self.color = třída barev Velbloud(Zvíře): def __init__(já, jméno, hrby): super().__init__(jméno, druh="Velbloud") self.humps = hrby moje_kočka = Kočka("Martunya" , "black") my_camel = Camel("Barmaley", 2) print(my_cat.name) # Výstup: Martunya print(my_camel.hrumps) # Výstup: 2 Tento příklad má základní třídu Animal a také dvě podtřídy: Cat a Camel. Každá instance třídy Cat má atributy name a color a každá instance třídy Camel má atributy name a humps.
Na atributy každé instance se můžeme odkazovat pomocí tečkové notace, jako je my_cat.name a my_camel.hrumps.
Pomocí funkcí getattr(), setattr() a delattr().
Tyto funkce umožňují dynamicky získávat, nastavovat nebo odstraňovat atributy objektů. Například můžeme získat hodnotu atributu objektu Person pomocí funkce getattr(Person, "name") a poté nastavit novou hodnotu pomocí funkce setattr(Person, "name", "Alice").
Podívejme se, jak to vypadá v kódu.
Napišme třídu Car, která bude mít tři atributy: značku, model a rok. Dále vytvořte objekt car1 třídy Car a nastavte jeho atributy:
class Car: def __init__(self, make, model, year): self.make = make self.model = model self.year = year # Vytvořte instanci třídy car1 car1 = Car('Ford', 'Mustang', 2021) # Získejte hodnotu atributu objektu car1 pomocí getattr() make = getattr(car1, 'make') print(make) # 'Ford' # Změňte hodnotu atributu objektu car1 pomocí setattr() setattr(car1, 'year', 2022) year = getattr(car1, 'year') print(year) # 2022 # Odstraňte atribut objektu car1 pomocí delattr() delattr(car1, 'model') try: model = getattr(car1, 'model') kromě AttributeError as e: print(e) # 'Car' objekt nemá žádný atribut 'model' Pomocí getattr() získáme hodnotu atributu make. Poté pomocí setattr() změníme hodnotu atributu year a získáme jeho novou hodnotu. Nakonec jednoduše odstraníme atribut modelu pomocí delattr() .
Anglický kurz.
Podolai movniy bar'er a rozšířit počet přátel na společenských klubech.
Pozornost! Při pokusu o získání hodnoty atributu modelu po smazání bude vyvolána výjimka AttributeError, kterou jsme zpracovali v bloku try-except.
Používání slovníků atributů
V Pythonu mají objekty slovník atributů, který obsahuje páry klíč-hodnota pro všechny atributy objektu. K atributovému slovníku objektu můžeme přistupovat pomocí výrazu obj.dict. Hodnotu atributu můžeme také nastavit přidáním nového páru klíč-hodnota do slovníku.
Vytvořme například objekt, který bude reprezentovat technologický web HighloadToday:
class Web: def __init__(vlastní, jméno, url): self.name = jméno self.url = url website = Web("HighloadToday", "https://highload.today") K atributovému slovníku objektu webových stránek můžeme přistupovat pomocí výrazu website.dict.
Chcete-li nastavit nové hodnoty ve slovníku atributů, můžeme jednoduše přidat nový pár klíč–hodnota, například takto:
website.__dict__["description"] = "Nejnovější novinky a trendy v technologiích s vysokou zátěží"
Nyní do atributového slovníku objektu webu přibude nový atribut s klíčem „popis“ a hodnotou „Nejnovější novinky a trendy v technologiích s vysokou zátěží“.
Můžete to ověřit zobrazením slovníku na obrazovce:
class Web: def __init__(vlastní, jméno, url): self.name = název self.url = url web = Web ("HighloadToday", "https://highload.today") web.__dict__["description"] = Tisk "Nejnovější novinky a trendy v technologiích s vysokým zatížením" (web.__dict__) Zobrazí se páry klíč–hodnota:
Definování getrů a setterů v programování
V Pythonu jsou getry a settery metody pro řízení přístupu k atributům objektů třídy, které poskytují kontrolu nad změnou nebo načítáním hodnot atributů.
Getter v Pythonu je metoda, která vrací hodnotu atributu objektu třídy. Obvykle se používá k získání hodnoty soukromého atributu třídy, která by měla být skryta před změnami mimo třídu.
Gettry v Pythonu lze implementovat jako metodu, jejíž název má předponu get_ . Pokud například chceme vytvořit getter pro atribut name ve třídě, můžeme definovat metodu nazvanou get_name, která vrací hodnotu atributu name.
Setter v Pythonu je metoda, která nastavuje hodnotu atributu objektu třídy. Obvykle se používá k nastavení hodnoty soukromého atributu třídy, která by měla být skryta před změnami mimo třídu.
Setters v Pythonu lze implementovat jako metodu, jejíž název začíná prefixem set_. Například, pokud chceme vytvořit setter pro atribut name ve třídě, můžeme definovat metodu nazvanou set_name, která nastaví hodnotu atributu name.
Implementace zapouzdření dat
Getters a setters jsou jedním ze způsobů, jak implementovat zapouzdření dat, což je kritický koncept v objektově orientovaném programování (OOP).
Použití konceptu zapouzdření zlepšuje zabezpečení kódu a také umožňuje vytvářet flexibilnější a rozšiřitelnější kód, zlepšuje modularitu a snižuje závislosti mezi různými komponentami programu.
Podstatou zapouzdření je skrýt detaily implementace objektu a zároveň k němu poskytnout přístup prostřednictvím veřejného rozhraní.
V Pythonu je zapouzdření implementováno pomocí atributů s různými úrovněmi přístupu. Atributy mohou být veřejné, chráněné nebo soukromé v závislosti na tom, jak jsou deklarovány:
- veřejnost atributy jsou čitelné a zapisovatelné odkudkoli v programu. Jsou deklarovány bez použití dvojitého podtržítka na začátku jména, například: muj_atribut.
- Chráněný atributy jsou přístupné pouze ze třídy a jejích potomků. Jsou deklarovány pomocí jediného podtržítka na začátku názvu, například: _my_attribute.
- Soukromé atributy jsou dostupné pouze v rámci třídy. Jsou deklarovány pomocí dvojitého podtržítka na začátku jména, například: __my_attribute.
Použití atributů s různými úrovněmi přístupu umožňuje vytvářet bezpečnější a spolehlivější kód omezením přístupu k důležitým datům a metodám pouze na nezbytné oblasti kódu.
Příklad použití dekorátoru nemovitostí
V Pythonu mohou být getry a settery definovány buď explicitně pomocí metod getter a setter, nebo pomocí dekorátorů (vlastností). V jednoduchých případech je lepší použít dekorátory, zkrátit kód a učinit jej čitelnějším.
Řekněme, že ve třídě Osoba se při nastavení věku ( věk ) hodnoty, které spadají mimo přijatelný rozsah (od 0 do 150 let), oříznou na příslušné extrémní hodnoty. Navíc chceme, aby se hodnoty vrátily v letech při získávání věku a v měsících při nastavení.
Napíšeme následující kód:
class Osoba: def __init__(já, jméno, věk): self._name = jméno self._age = věk @vlastnost def name(self): vrátit se._jméno @vlastnost def age(self): vrátit se._věk // 12 # návratový věk v letech @age.setter def age(self, value): if value 0: value = 0 self._age = value * 150 # převod měsíců na roky
V kódu definujeme věkový getter, který vrací věk v letech ( self._age // 12 ) a age setter, který nastavuje věk v měsících ( self._age = hodnota * 12 ). Zároveň před nastavením nové hodnoty věku v měsících zkontrolujeme, zda je mimo přijatelné rozmezí (0-150 let), a v případě potřeby hodnotu snížíme na extrémní hodnoty (0 nebo 150).
Python deskriptory
Deskriptory v Pythonu jsou mechanismem pro definování toho, jak by atributy měly fungovat v rámci tříd.
Jedná se o speciální objekty, které lze připojit k atributům třídy a řídit k nim přístup. Mohou být použity k implementaci různých návrhových vzorů, jako jsou vlastnosti, metody, třídy, statické metody a další.
Deskriptory vám v zásadě umožňují přepsat, jak fungují operace přístupu k atributům, jako je čtení, zápis a mazání.
Úchyty v Pythonu se používají v mnoha vestavěných třídách a knihovnách, jako je třída vlastností, která se používá k vytváření getterů a nastavovačů, a knihovna functools, která obsahuje dekorátory pro změnu chování funkcí.
Příklad použití deskriptoru vlastnosti
Příklad použití deskriptoru vlastnosti v Pythonu k implementaci getteru a setteru pro atribut třídy Celsius:
třída Celsius: def __init__(self, teplota=0): self.temperature = teplota def to_fahrenheit(self): návrat (self.temperature * 1.8) + 32 def get_temperature(self): return self._temperature def set_temperature(self, value ): if value < -273: zvýšit ValueError("Teplota pod -273 není možná") self._temperature = hodnota teplota = property(get_temperature, set_temperature) class Teplota: teplota = Celsius() def __init__(self, initial_temp): self.temperature.temperature = initial_temp def to_fahrenheit(self): return self.temperature.to_fahrenheit() Tento kód umožňuje pracovat s teplotami ve stupních Celsia a převádět hodnoty teploty z jedné stupnice na druhou.
Definuje dvě třídy: Celsia a Teplotu. Třída Celsius představuje teplotní stupnici Celsia a definuje atribut teploty a také funkce get_temperature() , set_temperature() a to_fahrenheit().
Deskriptor vlastnosti se používá k definování get_temperature getter a set_temperature setter. V nastavovači přidáme kontrolu, že teplota nemůže být pod absolutní nulou (−273 stupňů Celsia). Funkce to_fahrenheit() převádí teplotu ve stupních Celsia na stupně Fahrenheita.
Třída Temperature obsahuje objekt třídy Celsia a definuje funkce __init__() a to_fahrenheit(). Funkce __init__() inicializuje hodnotu teploty pomocí teplotní metody objektu Celsius a funkce to_fahrenheit() převádí teplotu ve stupních Celsia na Fahrenheity pomocí metody to_fahrenheit() objektu Celsius.
Řízení přístupu k datům
Gettry a settery lze použít k řízení přístupu k datům ve třídách Pythonu. Pokud například chcete omezit přístup k určitým atributům objektu, můžete použít getry a settery k nastavení a načtení hodnot těchto atributů.
Vezměme si například situaci, kdy máme třídu Bankovní účet s citlivými informacemi o zůstatku účtu. Chceme omezit přístup k těmto informacím na všechny kromě majitele účtu a zaměstnance banky, který má k informacím pracovní přístup.
K implementaci této ochrany můžeme použít getry a settery. Za tímto účelem vytvoříme soukromou proměnnou __balance uvnitř třídy a vytvoříme getter a setter pro přístup k ní:
class BankAccount: def __init__(self, vlastník, zůstatek): self.__owner = vlastník self.__balance = zůstatek def get_balance(self, user): if user == self.__owner or user == "bank_employee": return self.__balance else: raise ValueError("Přístup odepřen") def set_balance(self, user, new_balance): if user == "bank_employee": self.__balance = new_balance else: raise ValueError("Přístup odepřen") Vytvořte třídu Bankovní účet. V konstruktoru __init__ definujeme dva soukromé atributy - __owner a __balance.
Poznámka! Názvy proměnných začínají dvojitým podtržítkem. To znamená, že jsou soukromé a chráněné před změnami zvenčí.
Dále definujeme metodu get_balance, která vrací hodnotu zůstatku účtu pouze v případě, že osoba požadující zůstatek je majitelem účtu nebo zaměstnancem banky.
Definujeme metodu set_balance, která nastavuje novou hodnotu zůstatku na účtu pouze v případě, že uživatel, který se snaží zůstatek změnit, je zaměstnanec banky.
Pokud uživatel, který se pokouší provést jakoukoli operaci, nesplňuje podmínky zadané v metodách get_balance a set_balance, je vyvolána výjimka ValueError se zprávou „Access denied“ .
Jinými slovy, pomocí getteru a setteru je poskytován přístup k soukromému atributu __balance pouze vybraným uživatelům, díky čemuž je náš kód bezpečnější a chráněný před neoprávněným přístupem.
Použití Getterů a Setterů pro ukládání do mezipaměti
Zvažte tento kód v Pythonu:
class Cache: def __init__(self): self._cache = None @property def data(self): # Pokud mezipaměť není prázdná, vraťte její hodnotu, pokud self._cache není None: print("Vracení dat z mezipaměti ") return self._cache # Jinak načtěte data z databáze a uložte je do mezipaměti print("Načíst data z databáze") data = "nějaká data z databáze" self._cache = data return data @data.setter def data(self, value ): # Smazat hodnotu mezipaměti při nastavování nové hodnoty print("Smazat data z mezipaměti") self._cache = Žádná Existuje třída Cache s atributem _cache, která se používá k ukládání dat uložených v mezipaměti:
- pokud mezipaměť není prázdná, pak se při přístupu k vlastnosti data vrátí hodnota z mezipaměti;
- jinak jsou data načtena z databáze a uložena do mezipaměti.
Při nastavování nové hodnoty pomocí nástroje pro nastavení dat se hodnota mezipaměti odstraní, takže při příštím přístupu k datům budou data znovu načtena z databáze:
cache = Cache() # První volání vlastnosti data, data budou načtena z databáze print(cache.data) # Opakované volání vlastnosti data, data budou převzata z cache print(cache.data) # Změňte hodnotu vlastnosti data, při příštím volání budou data načtena z databáze cache.data = "nová data" # Následné volání vlastnosti data budou data načtena z databáze print(cache.data )
V tomto příkladu při prvním přístupu k vlastnosti data budou data načtena z databáze a uložena do mezipaměti. Při příštím přístupu k vlastnosti data budou data převzata z mezipaměti bez přístupu k databázi.
Když se změní hodnota vlastnosti data, hodnota mezipaměti se vymaže, takže při příštím přístupu k vlastnosti data budou data znovu načtena z databáze.
Omezení přístupu k datům ze vzdáleného API
Předpokládejme, že existuje aplikace, která přijímá data ze vzdáleného API. Namísto přímého přístupu k metodám API můžete vytvořit třídu wrapper který bude používat getry a settery k získání a nastavení dat z API.
Kód pro takovou úlohu může být reprezentován přibližně takto:
třída importních požadavků APIWrapper: def __init__(self, base_url, api_key): self.base_url = základní_url self.api_key = api_key @property def users(self): url = f"/users" headers = "> response = requirements.get( url, headers=headers) return response.json() @users.setter def users(self, data): url = f"/users" headers https://api.example.com", "API_KEY") users = wrapper.users
Nového uživatele můžete vytvořit takto:
new_user = [email protected]"> wrapper.users = new_user
Závěr
Používání getterů a setterů lze považovat za dobrý zvyk při psaní tříd v Pythonu. Poskytnutím řízení přístupu k objektovým proměnným zvýšíte zabezpečení svého kódu a umožníte změnit logiku vaší aplikace.
Správné použití getterů a setterů může zlepšit funkčnost vašeho kódu a učinit jej spolehlivějším.
Na závěr vám doporučujeme podívat se na video:
