Dynamické volání method základních datových typů – Python – Fórum – Programujte.com

Zdravím,

mohu v Pythonu dynamicky sestavit volání metody pro základní typ např  str? Pokud bych chtěl dynamicky sestavit např. "{0}".format("jmeno") jak na to?

Pomocí funkce getattr se mi daří dynamicky sestavit volání metody pouze instance vlastních tříd.

Pokud toho v Pythonu u základních typů nelze docílit - proč tomu tak je? Např. v Ruby bez problémů

Díky

#1 Ales
Možná, kdybych z toho pochopil, o co ti jde, odpověděl bych ano.

Nejjednodušeji se to dělá přes objekty. Každému objektu vytvoříš metody se stejnými názvy a pak je ti vcelku jedno, jakého typu ten objekt je - prostě zavoláš metodu pod tím názvem, která pro různé objekty dělá různou funkčnost.

Zrovna v uvedeném případě si myslím, že na to jdeš špatně a že se to dá krásně udělat přes metodu __str__().

Proč nechceš používat vlastní třídy?

#2 Kit
Upřímně - nerozumím tvojí odpovědi. Proč jsi usoudil, že nechci používat vlastní třídy? Nebo proč na to jdu špatně, ikdyž je to možné samo. Ano, vím co je polymorfismus, díky.

Nevím jak se jinak lépe zeptat - jak dynamicky sestavím volání metody vestavěného typu, např. str.metoda? VlastniTyp.metoda jde přes getattr(object, method), ale getattr(VestavenyTyp, method) mi vrací none. Proč? A jak to dynamicky sestavit? Můžeš mi pls vložit malou ukázku jak jsi to myslel se speciální metodou __str__?

Představ si objekt x, který má vlastnost, do které ukládám instanci třídy y, pokud objekt x nerozumí zaslané zprávě/metodě, pokusí se ji předat objektu y. ( If hasattr(...): getattr(...) )

Snad je to srozumitelnější. Díky za reakci

#3 Ales
Netuším, k čemu je ti getattr(). Pokud potřebuješ prezentovat objekt, stačí mu jen dopsat metodu __str__(), která ten objekt převede na string. Pak už jen stačí použít print(objekt) nebo str(objekt) a nemusíš se obtěžovat s formátováním.

#4 Kit

No, nerozumíme si. Říká ti něco princip přesměrování zpráv? 

#5 Ales
Říká. Říká ti něco princip zapouzdření? Proč ten string nenaformátuješ v objektu a místo toho se to snažíš pytlíkovat přes getattr()?

#6 Kit
A jakou zásadu podle tebe porušuji v rámci zapouzdření? Přesměrování zpráv právě respektuje objekt jako černou skříňku. Když právě dodržím zapozdření tak ani nemusím vědět, že objekt, který zprávě nerozuměl jí předal jinému objektu. Co tam přesně vidíš za problém se zapouzdřením?

Můžeš mi tedy, prosím, poslat ukázku, jak lze podle tebe implementovat přesměrování zprávy jakémukoliv (vestavěnému i vlastnímu) typu, který je předán pomocí vlastnosti? Teda pokud ti to ego dovolí.

Princip v Ruby:

class RubyObject
  attr_accessor :server
  def method_missing(id, *args, &block)
    return @server.send(id, *args, &block)
  end 
end

Jak tedy v Pythonu vytvořím alternativu k obj.send bez getattr funkce tak, abych dokázal dynamicky sestavit obj.zprava() pro vestavěný a vlastní typ? Naformátováním stringu v objektu? - Nechápu, jak přesně pls?

Díky

#7 Ales
Pokoušíš se z vnějšku pracovat s atributy objektu. Tím porušuješ zapouzdření. Okolí objektu nezná jeho atributy, na které se snažíš dotazovat.

Potřeba přesměrování spíš svědčí o potřebě dědičnosti. V daném případě bych však použil funkci str(), která pro integer, string nebo objekt vždy vrací string. Nemusíš tedy nic přesměrovávat a vždy dostaneš stringovou reprezentaci objektu nebo proměnné primitivního typu.

Ruby neznám, uvedený příklad mi nic neříká. V Pythonu se accessory nepoužívají.

#8 Kit
S tím zapouzdřením to samozřejmě - v tomto případě - není pravda. Pouze zasílám objektu zprávu, pokud objekt zprávě nerozumí předá ho jinému objektu - serveru. Pořád s objektem pracuji jako s černou skříňkou. Programátor ani nemusí vědět, že objekt zprávu předal. Synu oprav motor - neumím - předám otcovi. Vše se děje za horizontem zapouzdření. Kde se pokouším z venku pracovat s atributy objektu? V ukázce, kterou jsem poslal je evidentní, že využiji jen API objektu (vlastnost server), zbytek se děje v rámci zapouzdření.

attr_accessor :server v ruby vytvoří vlastnost server pro čtení a zápis. method_missing se zavolá vždy, pokud objekt zaslané zprávě nerozumí. Metoda/zpráva send odešle objektu (server) zprávu.

Dědičnosti se snažím vyhnout vždy, když je to možné. Např. pomocí rozšíření tříd, delegátem a  třeba právě přesměrováním zpráv. Důvodů proč se vyhnout dědění a využít raději alternativních postupů je celá řada. To poslední co potřebuji je další potomek, nepotřebuji ho.

Evidentně máme každý jiný názor na OOP, ale pokud vypustíme, podle tebe lepší možnosti, a soustředíme se na podstatu dotaz - uměl bys pls poradit?

Díky moc za reakce

#9 Ales
Uniká mi, jak uvedený příklad souvisí s původním dotazem.

Vyhýbat se dědičnosti jen proto, abych se vyhnul dědičnosti, je nesmysl. Netvrdím však, že zrovna tohle nutně musí být případ na dědičnost. Delegátům se však vyhýbám.

#10 Kit
U dědičnosti - zejména ve větším systému - vzniká efekt joja - dá se dohledat na netu. Nebo další problémy jako "fragile base class" apod. Vzniká nepřehledný systém, přitom - většinou - existují vhodnější alternativy. Dědění je zbytečně nadužívané. Zejména v dynamicky typovaném systému existují vhodné alternativy. Ale to je vlastně jedno - teď nejde o dědění.

Původní zadání s příkladem souvisi, jde mi o alternativu k rubiovskému obj.send, funkce pythonu getattr zdá se nepracuje s vestavěnými typy. V Ruby je to snadné, pokud se budu držet ukázky co jsem poslal (ta už je snad jasná), použití by vypadalo takto.

s = RubyObject.new()
s.server = "Text"
s.lenght # vrátí 4
#nebo
s.server= VlastniTyp.new()
s.zprava

#jak toto přesměrování implementovat v Pythonu?:

s = PyObj()
s.server = "{0}"
s.format("Text") # vrací none, proč?
#nebo (toto dokáži)
s.server = VlastniTyp()
s.zprava

Tady fakt nevidím problém se zapouzdřením.

Víc už ze sebe nevymáčknu - vzdávám to tady. Měj se hezky a díky za reakce

#11 Ales
zprava chápej zprava() / metoda(). Čau

#11 Ales

Vždyť je to jednoduché a ani na rozdíl od tebe neporušuji zapouzdření:

s = "Text"
print(s)

class PyObj:
    def __init__(self, form, text):
        self.form = form
        self.text = text
    def format(self, text):
        return self.form.format(text)    def __str__(self):
        return self.form.format(self.text)

s = PyObj("{0}", "Text")
print(s)
print(s.format("jiny text"))

s = VlastniTyp()
print(s)

#13 Kit

1. Jednoduché to je, ale o principu přesměrování zpráv zde nemůže být řeč.

2. Kde přesně jsem porušil zapouzdření? 

Ztráta času pro oba

#14 Ales

1. Reflexi se vyhýbám, jak jen to jde. Místo přesměrování obvykle dělám adaptér.
2. Zapouzdření porušuješ všude, kde mimo objekt pracuješ s jeho atributy.

Pro mne to ztráta času nebyla. Aspoň vidím, jak rozdílné mohou být výklady vzorů a pravidel.

Pro mne jsou tvé postupy nepřijatelné a zřejmě proto jsme nenalezli společnou řeč. Třeba ti poradí někdo jiný.

#7 Ales
Ahoj, moc nechápu, co přesně chceš. Vypadá to, že chceš používat něco jako extension methods v C#. To v Pythonu nejde, protože vestavěnné typy jsou napsané kvůli rychlosti v C.

Funkce gettatr získává atributy a metody z objektů/tříd. 

string_join = getattr(str, "join")
result = string_join(" ", ["things", "to", "append"])
print(result) # to samé jako " ".join(["things", "to", "append"])

Používal jsi to takhle nějak?

Viděl bych to na dvě možnosti, jak řešit tvůj problém. Jak psal Kit, udělej si wrapper nad vestavěnými třídami. Nebo můžeš použít vestavěnou funkci eval.

print(eval('"x".join(["7", "6"])'))

Tam si dej pozor na to, abys nedostal data z venčí, pokud ten program není pro tvé osobní potřeby. Pokud je něco nejasné nebo se chceš na něco zeptat, tak se klidně ozvi. Popřípadně můžeš napsat o co *přesně* se snažíš, určitě existuje nějaké rozumné řešení, než takovéhle složité hacky.

#15 Kit
No, nejsou to moje postupy, ale objektová paradigma. Nikde jsem zapouzření neporušil, využívám pouze API objektu viz ukázka v Ruby, kterou jsi nepochopil - nic ve zlém

Každopádně ti děkuji za tvůj čas

#17 Ales
No vždyť jsem to psal. Každý z nás uchopil objektové paradigma jinak.

Pokud je někde takové neobjektové API, tak je nutné na něj navázat a dál ve své aplikaci pokračovat objektově.

#16 gcx11

Ahoj gcx11, děkuji ti za reakci,

nepotřebuji rozšířit třídu za běhu, to zvládám pomocí monkey-patching. Jde mi opravdu jen o přesměrování zpráv - to za složitý hack nepovažuji, protože je to běžně užívaná technika a to zejména u kachnotypích jazyků. Nechci sem pořád zatahovat Ruby, ale tam se to používá běžně. Zkusím vysvětlit:

Jak v jazycích staticky i dynamicky typovaných se občas využívá vkládání objektů, tj něco takového:

class Obj():
  server = Nejakytyp()
...

Může to být v __init__, ale to je nepodstatné. Ve třídě/typu se vytváří instance dalšího objektu (tzv. vkládaného), na kterého se  - za horizontem zapouzdření - přesměrují "služby" objektu (Obj()). Já ale nechci implementovat všechny "služby" ručně a přesměrovávat každou zprávu zvlášť - chci, aby se za horizontem zapouzdření o to přesměrování zpráv postaral objekt, který (např v ukázce v Ruby předávám pomocí vlastnosti server) ve kterém jsou služby implementovány. A samozřejmě postup v úkázce, kromě zbytečné dřiny pro programátora není úplně zrovna elegantní řešení, ale to je nepodstatné, jde jen o vysvětlení podstatného. 

Můj problém je vlastně takový, že potřebuji alternativu k rubiovskému obj.send, která umí dynamicky sestavit obj.zprava() pro vestavěný a vlastní typ. Jinak řečeno: umí nepřímo zaslat zprávu jinému objektu. Díky, ale nestojím o jiné postupy a návrhy. Jde to nějak v Pythonu nebo ne tak, abych to mohl využít pro přesměrování zpráv? To je moje otázka.

Přesměrování jsem si nevymyslel sám, ale jiný uznávaní odborníci, který tento princip za porušení OOP principů nepovažují, spíše naopak - je v souladu s myšlenkou předávání zpráv - tak jako v reálném životě se může objekt rozhodnout, jak na zprávu zareaguje (přijmout a vykonat službu, odmítnout, nebo předat). Vše se děje za horizontem zapouzdření, programátor ani nemusí vědět, že objekt zprávu předal jinému objektu, který se o služby postará. Nerozumím té argumentaci o porušení zapouzření - kde proboha? Valstně jsou to z mé strany spíše parafráze - není to z mé hlavy. 

Díky za ukázky, určitě je doma prostuduji a uvidím zda by mi v tomto ohledu mohli pomoci.

#19 Ales
Předávání zpráv je jedním z principů OOP, o tom není sporu.

Ovšem využívání reflexe už sporné je, včetně manipulace s atributy objektu vně objektu. Ani jedno z toho už do OOP nepatří.

#20 Kit
A kde jsi viděl, že jsem použil reflexi nebo manipuloval s atributy objektu vně objektu?

#20 Kit
Btw, položím otázku znovu:

Jde to nějak v Pythonu implemetovat přesměrování zpráv? Existuje vhodná alternativa k obj.send, abych tedy podle tvých opřesvědčení neporušoval zapouzdření? To je moje otázka. 

#21 Ales
Na druhém řádku modifikuješ atribut "server", tedy interní atribut objektu a děláš to vně objektu:

s = RubyObject.new()
s.server = "Text"

 A zde využívání reflexe:

def method_missing(id, *args, &block)
    return @server.send(id, *args, &block)
end 

#16 gcx11
Ještě k těm vestavěným typům a rozšíření. Tady samozřejmě nepomůže nic, dict jsou jen pro čtení. To je škoda mimochodem. Rozšíření tříd může být vhodnější alternativa k dědění. Na co dědit, když můžu existující typ rozšířit a to i dokonce již existující instance. Opět v Ruby není problém. Škoda.

Ještě jednou díky

#22 Ales
Myslíš něco takového? 

class MyRubylikeThing(object):
    #...

    def __getattr__(self, name):
        def _missing(*args, **kwargs):
            print "A missing method was called."
            print "The object was %r, the method was %r. " % (self, name)
            print "It was called with %r and %r as arguments" % (args, kwargs)
        return _missing

r = MyRubylikeThing()
r.hello("there", "world", also="bye")

#23 Kit
Ani jendo ani druhé

Server je API objektu - vlastnost

Method_missing nelze brát jako reflexi, koukni do dokumentace

#25 Kit
Ukázku až kam jsem se dostal mám doma, ale je to skoro ono. Akorát jsem v _missing volám fce hasattr, kdyby objekt na kterého chci zprávu přesměrovat taky nerozumněl a getattr jako alternativu k obj.send, ale ta mi u vestavěných typů vrací none.

Vyzkouším teď. Díky

#26 Ales
To říkám: Blbě udělané API.

#27 Ales
To jsem teď vygooglil na SO pomocí klíčových slov "method_missing" a "python".

#19 Ales
http://stackoverflow.com/…nd-in-python

V tom případě to getattr. Pak lze i využít dekorátory a udělat to složitější, třeba nastavit ve třídě, kam se to bude přesměrovávat a na jaké metody to má aplikovat. Ale nevím, jestli by se Ti to chtělo psát + není to tak jednoduché.

#28 Kit
Jak blbě?

Mám pocit, že chceš ze mě dělat trochu vola. "Vždyť je to snadné...", "Vygooglil jsem..." Narazil jsem na to taky, ale potřebuji alternativu k obj.send taky

#30 gcx11
Ano z tohoto jsem čerpal, getattr mi vrací none pro vestavěné typy a s tím jsem se sem obrátil

#32 Ales
Pošli mi kód, který to dělá.

#33 gcx11
Rád, ale mohu až z domova, později k večeru. Když tam objevíš nějakou mojí volovinu budu moc rád. Přechod z Ruby na Python je pro mě občas matoucí.

Díky za ochotu a čas kluci

#31 Ales
To jsem psal, abys věděl, že jsem to jen zkopíroval a nijak neupravoval pro tvé podmínky. Předpokládal jse, že si z toho vezmeš tu myšlenku a upravíš podle svých potřeb.

To API by podle běžných principů OOP mělo vypadat spíš takto: 

s = RubyObject.new("Text")
s.lenght() # vrátí 4

#nebo
s = VlastniTyp.new()
s.zprava("Text zprávy") # pošle zprávu

#35 Kit
Už jsem tě konečně pochopil. Pokud to návrh dovoluje je určitě lepší předat hodnoty už v "konstruktoru" nebo chceš li po zavolání __init__. No, nejsem si jistý jestli je to přímo princip OOP, ikdyž to může být vnímáno jako porušení zapouzdření. Ok. Každopádně je to nyní nepodstatné. Spíše to vzniklo jako tvoje rekace na dotaz ohledně přesměrování zpráv viz #4 a #5

Ještě jednou díky

#36 Ales
Záleží na druhu objektu. Některé představují výkonné části - ty by se měly konfigurovat v konstruktoru. Vznikne tak virtuální procesor. Pak jsou tu objekty typu datový kontejner, který mezi těmito procesory cestuje - zprávy.

Druhé jmenované se občas dělávají podle vzoru Messenger, u kterého se na zapouzdření tolik nehledí. U dynamických jazyků často bývají nahrazeny strukturou nebo dokonce primitivním typem. Používání primitivních typů však s sebu nese hromadu nevýhod a to jak z hlediska údržby kódu (chovají se jako "beztypové" - nejsou schopny si udržet referenční integritu), tak i z hlediska výkonu (předání jednoho kontejneru s 10 atributy je levnější, než předání 10 primitivních zpráv). Ideální však je, když se kontejner svému příjemci dokáže přímo prezentovat v potřebném formátu, např. jako CSV, JSON, DOM, XML, SQL apod.

#33 gcx11

Tak domů se jen tak nedostanu - v rychlosti jsem to splácal do toho co posílal Kit, snad to není v rozporu tím co jsem spatlal doma a bude to dávat smysl. Nějaké prohřešky nesouvisející s dotazem mi pls promiňte - nejsem v Pythonu zběhlí a psal jsem to v bombách

class MyRubylikeThing(object):

    def __init__(self, server):
        self.server = server

    def __getattr__(self, name):
        def _missing(*args, **kwargs):
            if hasattr(self.server, name):
                getattr(self.server, name)(*args, **kwargs)
            else:
                print("Unknown message: " + name)
        return _missing

class MyServer(object):

    def __init__(self, text):
        self.t = text

    @property
    def prop(self):
        return self._prop
    
    @prop.setter
    def prop(self, value):
        self._prop = value

    def hello(self):
        print(str(self.t))

    def cau(self, text):
        print(str(text))

#vlastní typ
s = MyServer("hello boy")
r = MyRubylikeThing(s)
r.UnknownMsg() #Test return Unknown message
r.hello() # return hello boy
r.cau("kamo") #return kamo
#-----

#vestavěný typ str
s = "text"
r = MyRubylikeThing(s)
print(r.capitalize()) #return None

#vestavěný typ int
s = 58
r = MyRubylikeThing(s)
print(r.bit_length()) #return None

#
s = MyServer("nejakyText")
s.prop = "DatovyAtribut"
print(str(s.prop)) #return DatovyAtribut

r = MyRubylikeThing(s)
print(str(r.prop)) #Nerozumím :)

#37 Kit
No musím přiznat, že to dává smysl. Díky za to

#38 Ales

Sem fakt lachtan, sorry

class Proxy(object):
    
    def __init__(self, server):
        self.server = server

    def __getattr__(self, name):
        def _method_missing(*args, **kwargs):
            if hasattr(self.server, name):
                output = getattr(self.server, name)(*args, **kwargs)
                return output
            else:
                print("Unknown message: " + name)
        return _method_missing

Díky moc