RE: [python] globální proměnné

[Petr Prikryl]

p.kosina napsal...
> Připadá mi to nespravedlivé :-), že u OO se globální
> proměnné vytváří naprosto transparentně self.x=10 v
> kterékoliv metodě a platnost (včetně změn) je napříč celou
> třídou a ještě je to vydáváno za velké plus.

V tomto případě nejde ani o globální proměnnou, ani o
proměnnou platnou v kterékoliv metodě třídy. Vytváří se v
rámci objektu a je platná pouze v rámci objektu (instanci
třídy). Na self.x není nic globálního ani magického. Můžu si
to do češtiny přeložit jako "moje vlastní x", kdy "moje
vlastní" uvažujeme z pohledu objektu samotného.

> Naproti tomu u nás, u proceduráků, u nás je global, které se
> však musí objevovat jednak v každé funkci zvlášť, což je
> velmi netransparentní a ještě je to zavrženíhodné. Dá se to
> samozřejmě obcházet, ale transparentnost je vždy přednost.
> Funkce se dají samozřejmě volat s parametry a také vracet
> výsledky, ale pokud je argumentů více, program se stává
> zbytečně nepřehledným.

Pokud bych chtěl, aby všechny proměnné byly globální, dostal
bych se do počítačového pravěku. Programy pouze s globálními
proměnnými by byly při současném rozsahu kódu nečitelné a
neudržovatelné. Proto se ve funkcích vždy vytváří nové
lokální proměnné. U jazyků, kde se proměnná musí povinně
deklarovat (například Pascal) něco takového jako klíčové
slovo "global" nepotřebuji -- lokální proměnná stejného
jména má vždy přednost. Pokud není definována, bere se
automaticky proměnná "globálnější".

Používání globálních proměnných u složitějších programů vede
k vytváření závislostí, kdy jeden úsek kódu může nečekaným
způsobem ovlivnit jinak naprosto nesouvisející jiný úsek
kódu.

Souhlasím s tím, že špatný objektový návrh může být
nepřehlednější, než dobrý procedurální návrh. Ale dobrý
objektový návrh bude vždy udržovatelnější a přehlednější,
než procedurální návrh. Jedinou nevýhodou může být vytváření
více oddělených částí s kódem a daty (objektů), které se
propojují vzájemnými odkazy (tj. zvýšení stupně nepřímosti
odkazů). Na druhou stranu právě tento rys vynucuje čistší
rozhraní, snižuje vzájemné závislosti a usnadňuje budoucí
údržbu. I když, všechno se dá sprasit ;-)

> Chci uvést jednu z transparentnější metod (možná jsem
> objevil objevené, ale já jsem dosud používal seznamy nebo to
> hrozné global):
> 
> class globalniTrida:
>    pass
> 
> def r():
>    Global.delka=10
> 
> Global=globalniTrida()
> r()
> Global.delka=Global.delka+20
> print Global.delka
>  >>> 30

Následující příklad je významově naprosto shodný:

globalni_promenna = 10
globalni_promenna = globalni_promenna + 20
print globalni_promenna

Výše uvedenou třídou globalniTrida a vytvořením její
instance Global se pouze zavede něco jako prostor jmen.
Pokud si zavedu svůj modul -- soubor Global.py takto...

Global.py
------------------------------------------------------
delka = 10
------------------------------------------------------

... pak můžu ve svém programu psát:

import Global

Global.delka = Global.delka + 20
print Global.delka

Definice a použití funkce r() a použití třídy do toho nic
nového nevnáší. Je to jen krkolomě zapsané vytvoření
inicializace proměnné uvnitř existujícího objektu.