🚀 go-pugleaf

On 09.11.2011, hubert depesz lubaczewski <depesz@depesz.com> wroted:

> zaczynam poznawać pythona, nie do końca z własnej woli, i jako całkowity
> beginner, a w dodatku z naleciałościami z perla, mam od razu następujące
> pytania:
> 1. jakiś odpowiednik Data::Dumpera? chodzi o wypisanie dowolnie
> skomplikownaych struktur danych (lista dictów dictów itp.), ale z
> wcięciami, tak aby się to łątwo czytało. print zmienna pokazuje
> zawartość, ale wszystko w jednej linii.

import pprint
pprint.pprint(moja_struktura)

> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?

Najważniejsze: tuple są "immutable", czyli niemodyfikowalne,
oraz niehomogeniczne (znaczy, mogą być). Tupla może zawierać 
kolekcję obiektów różnych typów.

GS
-- 
Grzegorz Staniak   <gstaniak _at_ gmail [dot] com>

Dnia 09-11-2011 o 19:14:55 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> hej
> zaczynam poznawać pythona, nie do końca z własnej woli, i jako całkowity
> beginner, a w dodatku z naleciałościami z perla, mam od razu następujące
> pytania:
> 1. jakiś odpowiednik Data::Dumpera? chodzi o wypisanie dowolnie
> skomplikownaych struktur danych (lista dictów dictów itp.), ale z
> wcięciami, tak aby się to łątwo czytało. print zmienna pokazuje
> zawartość, ale wszystko w jednej linii.

 from pprint import pprint
dowolnie skomplikowane to może nie, ale lista dictów tupli -- czemu nie

> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?

podstawowa różnica jest taka, że lista jest mutable, a krotka immutable

ponadto różnica jest w typowych zastosowaniach: lista jest uzywana jako  
kolekcja, stadko wartosci traktowanych tak samo,
zaś przy krotce oczekujesz zwykle ze ma jakas stala dlugosc i kazdy  
element jest traktowany nieco inaczej

np. punkt moze byc opisany para (x,y), uzywamy wtedy tupli o ktorej wiemy  
ze powinna miec dlugosc 2
rowniez dict.items() iteruje po parach k,v

-- 
Jordan Szubert

On 2011-11-09, Jordan Szubert <usenet@joru.us.to> wrote:
>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
> podstawowa różnica jest taka, że lista jest mutable, a krotka immutable
> ponadto różnica jest w typowych zastosowaniach: lista jest uzywana jako  
> kolekcja, stadko wartosci traktowanych tak samo,
> zaś przy krotce oczekujesz zwykle ze ma jakas stala dlugosc i kazdy  
> element jest traktowany nieco inaczej

hmm ... nie jestem pewny czy rozumiem. tzn. chodzi mi o to, że nie za
bardzo widzę usecase gdzie tupla pasuje, a lista nie. ale pewnie to brak
doświadczenia/perlizm.

dzięki.

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-09, Jordan Szubert <usenet@joru.us.to> wrote:
>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>> podstawowa różnica jest taka, że lista jest mutable, a krotka immutable
>> ponadto różnica jest w typowych zastosowaniach: lista jest uzywana jako  
>> kolekcja, stadko wartosci traktowanych tak samo,
>> zaś przy krotce oczekujesz zwykle ze ma jakas stala dlugosc i kazdy  
>> element jest traktowany nieco inaczej
> 
> hmm ... nie jestem pewny czy rozumiem. tzn. chodzi mi o to, że nie za
> bardzo widzę usecase gdzie tupla pasuje, a lista nie. ale pewnie to brak
> doświadczenia/perlizm.
	... np cos takiego, czasami chcesz sie ograniczyc:
smtp:/home/adam>python
Python 2.4.3 (#1, May  5 2011, 16:39:09) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-50)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a=(1,2,3)
>>> a
(1, 2, 3)
>>> a[0]=1
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
>>> a=[1,2,3]
>>> a[0]=6
>>> a
[6, 2, 3]
>>> 
Z powazaniem
								Adam Przybyla

On 2011-11-09, hubert depesz lubaczewski <depesz@depesz.com> wrote:
> hej
> zaczynam poznawać pythona, nie do końca z własnej woli, i jako całkowity
> beginner, a w dodatku z naleciałościami z perla,

Patrz, jaki ten internet mały :)

> mam od razu następujące
> pytania:
> 1. jakiś odpowiednik Data::Dumpera? chodzi o wypisanie dowolnie
> skomplikownaych struktur danych (lista dictów dictów itp.), ale z
> wcięciami, tak aby się to łątwo czytało. print zmienna pokazuje
> zawartość, ale wszystko w jednej linii.

Ja już dobrą chwilę temu darowałem sobie Data::Dumpera na rzecz modułów
YAML i YAML::Syck. Jakoś tak przyjemniej się to czyta niż kod nie
pasujący do mojego stylu wcięć kod.

W Pythonie też bym użył serializatora YAML:
#v+
import yaml

print yaml.dump([1, 2, 3, {'a': 'b', 'c': 'd'}])
#v-

> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?

W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
  http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
powinien, inaczej element musiałby wędrować po strukturze albo byłby
problem z jego namierzeniem przy dostępie).

Inne co mi przychodzi do głowy, to operator formatowania % (odpowiednik
sprintf()):

#v+
>>> print "a %s %s b" % ("foo", "bar")
a foo bar b
>>> print "a %s %s b" % ["foo", "bar"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not enough arguments for format string
#v-

-- 
Secunia non olet.
Stanislaw Klekot

On 09.11.2011, hubert depesz lubaczewski <depesz@depesz.com> wroted:

>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>> podstawowa różnica jest taka, że lista jest mutable, a krotka immutable
>> ponadto różnica jest w typowych zastosowaniach: lista jest uzywana jako  
>> kolekcja, stadko wartosci traktowanych tak samo,
>> zaś przy krotce oczekujesz zwykle ze ma jakas stala dlugosc i kazdy  
>> element jest traktowany nieco inaczej
>
> hmm ... nie jestem pewny czy rozumiem. tzn. chodzi mi o to, że nie za
> bardzo widzę usecase gdzie tupla pasuje, a lista nie. ale pewnie to brak
> doświadczenia/perlizm.

Jak to kiedyś ktoś ładnie ujął: lista ma porządek, krotka ma strukturę.

GS
-- 
Grzegorz Staniak   <gstaniak _at_ gmail [dot] com>

On 2011-11-10, Grzegorz Staniak <gstaniak@gmail.com> wrote:
> On 09.11.2011, hubert depesz lubaczewski <depesz@depesz.com> wroted:
>
>>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>>> podstawowa różnica jest taka, że lista jest mutable, a krotka immutable
>>> ponadto różnica jest w typowych zastosowaniach: lista jest uzywana jako  
>>> kolekcja, stadko wartosci traktowanych tak samo,
>>> zaś przy krotce oczekujesz zwykle ze ma jakas stala dlugosc i kazdy  
>>> element jest traktowany nieco inaczej
>>
>> hmm ... nie jestem pewny czy rozumiem. tzn. chodzi mi o to, że nie za
>> bardzo widzę usecase gdzie tupla pasuje, a lista nie. ale pewnie to brak
>> doświadczenia/perlizm.
>
> Jak to kiedyś ktoś ładnie ujął: lista ma porządek, krotka ma strukturę.

Sądzę że depesz nie ma najmniejszego problemu ze zrozumieniem intencji.
Pytał jednak o praktyczne różnice, do których się zalicza niezmienność
krotki.

-- 
Secunia non olet.
Stanislaw Klekot

On 2011-11-09, Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
> Patrz, jaki ten internet mały :)

:)

> W Pythonie też bym użył serializatora YAML:
> #v+
> import yaml
>
> print yaml.dump([1, 2, 3, {'a': 'b', 'c': 'd'}])
> #v-

jakoś nie przepadam za yamlem. ale ok. ma to pewien sens.

>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>
> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
> powinien, inaczej element musiałby wędrować po strukturze albo byłby
> problem z jego namierzeniem przy dostępie).

czy tych haszy się do czegoś używa?

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On 2011-11-09, Jordan Szubert <usenet@joru.us.to> wrote:
>  from pprint import pprint
> dowolnie skomplikowane to może nie, ale lista dictów tupli -- czemu nie

chyba robię coś źle:

>>> from pprint import pprint                                                                                                                                                                     
>>> z=[1,2,3]
>>> x={"a":123,"b":12,"c":(5,6,7)}
>>> q=(z, x)
>>> print q
([1, 2, 3], {'a': 123, 'c': (5, 6, 7), 'b': 12})
>>> pprint(q)
([1, 2, 3], {'a': 123, 'b': 12, 'c': (5, 6, 7)})

nie za bardzo widzę różnicę.

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-09, Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>> Patrz, jaki ten internet mały :)
> 
> :)
> 
>> W Pythonie też bym użył serializatora YAML:
>> #v+
>> import yaml
>>
>> print yaml.dump([1, 2, 3, {'a': 'b', 'c': 'd'}])
>> #v-
> 
> jakoś nie przepadam za yamlem. ale ok. ma to pewien sens.
> 
>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>>
>> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>> powinien, inaczej element musiałby wędrować po strukturze albo byłby
>> problem z jego namierzeniem przy dostępie).
> 
> czy tych haszy się do czegoś używa?
	... przyspieszajak dostep, jak to hashe;-) Z powazaniem
								Adam Przybyla

On 2011-11-10, hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-09, Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>> W Pythonie też bym użył serializatora YAML:
>> #v+
>> import yaml
>>
>> print yaml.dump([1, 2, 3, {'a': 'b', 'c': 'd'}])
>> #v-
>
> jakoś nie przepadam za yamlem. ale ok. ma to pewien sens.

Ja go uwielbiam. Genialny do trzymania nie za dużych struktur w pliku,
a dzięki czytelności dla człowieka -- fantastyczny jako format pliku
konfiguracyjnego.

>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>>
>> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>> powinien, inaczej element musiałby wędrować po strukturze albo byłby
>> problem z jego namierzeniem przy dostępie).
>
> czy tych haszy się do czegoś używa?

Depesz, no przestań! A jak twoim zdaniem jest zbudowany słownik (Python)
czy %tablica (Perl)? Haszkod jest używany do zlokalizowania wartości
w pamięci (odpowiedniego kubełka).

-- 
Secunia non olet.
Stanislaw Klekot

On 11/10/2011 02:39 PM, hubert depesz lubaczewski wrote:
>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>> >
>> >  W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>> >     http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>> >  Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>> >  powinien, inaczej element musiałby wędrować po strukturze albo byłby
>> >  problem z jego namierzeniem przy dostępie).
> czy tych haszy się do czegoś używa?

 >>> key1 = (1,2,3)
 >>> key2 = [1,2,3]
 >>> d1 = { key1 : 'raz dwa trzy'}
 >>> d1[key2] = 'lista'
Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
 >>>

Edek

Dnia 10-11-2011 o 14:41:11 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-09, Jordan Szubert <usenet@joru.us.to> wrote:
>>  from pprint import pprint
>> dowolnie skomplikowane to może nie, ale lista dictów tupli -- czemu nie
>
> chyba robię coś źle:
>
>>>> from pprint import pprint
>>>> z=[1,2,3]
>>>> x={"a":123,"b":12,"c":(5,6,7)}
>>>> q=(z, x)
>>>> print q
> ([1, 2, 3], {'a': 123, 'c': (5, 6, 7), 'b': 12})
>>>> pprint(q)
> ([1, 2, 3], {'a': 123, 'b': 12, 'c': (5, 6, 7)})
>
> nie za bardzo widzę różnicę.

o fakt, domyślnie stara się wpakować w jedna linijkę, jak się nie uda to  
wcina dopiero

>>> pprint({1:2,3:4})
{1: 2, 3: 4}
>>> pprint({1:2,3:4},width=1)
{1: 2,
  3: 4}
>>>

-- 
Jordan Szubert

On 2011-11-10, Adam Przybyla <adam@rybnik.pl> wrote:
>>> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>>>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>>> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>>> powinien, inaczej element musiałby wędrować po strukturze albo byłby
>>> problem z jego namierzeniem przy dostępie).
>> czy tych haszy się do czegoś używa?
> 	... przyspieszajak dostep, jak to hashe;-) Z powazaniem

moment. a czy ty czasem nie mówisz o dictach?

w tego bloga rozumiem, że chodzi o .__hash__()

i o użyteczność tego się pytałem.

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On 2011-11-10, Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>>>
>>> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>>>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>>> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>>> powinien, inaczej element musiałby wędrować po strukturze albo byłby
>>> problem z jego namierzeniem przy dostępie).
>>
>> czy tych haszy się do czegoś używa?
>
> Depesz, no przestań! A jak twoim zdaniem jest zbudowany słownik (Python)
> czy %tablica (Perl)? Haszkod jest używany do zlokalizowania wartości
> w pamięci (odpowiedniego kubełka).

moment. dict to dict.

a hasz tupli to coś innego:

>>> x=(1,2,3)
>>> x.__hash__();
2528502973977326415

i to tych haszy nie można robić z modyfikowalnych rzeczy. np. wsadzenie
listy do tupli psuje haszowalność:

>>> ( 1, 2, [3,4]).__hash__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'list'


więc czy te hasze są do czegoś użyteczne?

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On 10.11.2011, hubert depesz lubaczewski <depesz@depesz.com> wroted:

>>  from pprint import pprint
>> dowolnie skomplikowane to może nie, ale lista dictów tupli -- czemu nie
>
> chyba robię coś źle:
>
>>>> from pprint import pprint                                                                                                                                                                     
>>>> z=[1,2,3]
>>>> x={"a":123,"b":12,"c":(5,6,7)}
>>>> q=(z, x)
>>>> print q
> ([1, 2, 3], {'a': 123, 'c': (5, 6, 7), 'b': 12})
>>>> pprint(q)
> ([1, 2, 3], {'a': 123, 'b': 12, 'c': (5, 6, 7)})
>
> nie za bardzo widzę różnicę.

Zobaczycz przy pprintowaniu listy list krotek, dłuższej niż te kilka
pozycji.

GS
-- 
Grzegorz Staniak   <gstaniak _at_ gmail [dot] com>

On 2011-11-10, Edek <edek.pienkowski@gmail.com> wrote:
>> czy tych haszy się do czegoś używa?
>
> >>> key1 = (1,2,3)
> >>> key2 = [1,2,3]
> >>> d1 = { key1 : 'raz dwa trzy'}
> >>> d1[key2] = 'lista'
> Traceback (most recent call last):
>    File "<stdin>", line 1, in <module>
> TypeError: unhashable type: 'list'
> >>>

chyba nie do końca kumam. jaki jest cel robienia klucza w d1 w taki
sposób?

i powiązane - jak zrobić przypisanie do "dicta w dictcie"?

np. w perlu mam:

$hash->{'klucz'}->{'pod-klucz'} = 123;

jak to zrobić w pythonie?

probowalem:
>>> d1["a"]["b"]="123"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  KeyError: 'a'

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-09, Jordan Szubert <usenet@joru.us.to> wrote:
>>  from pprint import pprint
>> dowolnie skomplikowane to może nie, ale lista dictów tupli -- czemu nie
> 
> chyba robię coś źle:
> 
>>>> from pprint import pprint                                                                                                                                                                     
>>>> z=[1,2,3]
>>>> x={"a":123,"b":12,"c":(5,6,7)}
>>>> q=(z, x)
>>>> print q
> ([1, 2, 3], {'a': 123, 'c': (5, 6, 7), 'b': 12})
>>>> pprint(q)
> ([1, 2, 3], {'a': 123, 'b': 12, 'c': (5, 6, 7)})
> 
> nie za bardzo widzę różnicę.
	... czasami bywa roznica:
>>> pprint.pprint([10**20]*10)
[100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L,
 100000000000000000000L]
>>> ([10**20]*10)
[100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L, 100000000000000000000L]
>>> 

Z powazaniem
								Adam Przybyla

On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
>> nie za bardzo widzę różnicę.
>
> o fakt, domyślnie stara się wpakować w jedna linijkę, jak się nie uda to  
> wcina dopiero
>
>>>> pprint({1:2,3:4})
> {1: 2, 3: 4}
>>>> pprint({1:2,3:4},width=1)
> {1: 2,
>   3: 4}
>>>>

ok. super. to teraz pytanie drążące:
gdzie/jak można to samemu znaleźć?

tzn. w perlu mam cośt takiego jak "perldoc"
np. perldoc DBI pokazuje mi dokumentację do modułu DBI. jak zrobić coś
takiego w pythonie?

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On 2011-11-10, hubert depesz lubaczewski <depesz@depesz.com> wrote:
> więc czy te hasze są do czegoś użyteczne?


ok. temat zamknięty. z tego co kumam teraz (na przykładzie z kluczem
hasza który jest tuplą) - __hash__() (o ile dla danej wartości działa)
oznacza, że dana wartośc może być kluczem w dict'cie.

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

Dnia 10-11-2011 o 16:37:27 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-10, Stachu 'Dozzie' K.  
> <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>>>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>>>>
>>>> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>>>>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>>>> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>>>> powinien, inaczej element musiałby wędrować po strukturze albo byłby
>>>> problem z jego namierzeniem przy dostępie).
>>>
>>> czy tych haszy się do czegoś używa?
>>
>> Depesz, no przestań! A jak twoim zdaniem jest zbudowany słownik (Python)
>> czy %tablica (Perl)? Haszkod jest używany do zlokalizowania wartości
>> w pamięci (odpowiedniego kubełka).
>
> moment. dict to dict.
>
> a hasz tupli to coś innego:
>
>>>> x=(1,2,3)
>>>> x.__hash__();
> 2528502973977326415
>
> i to tych haszy nie można robić z modyfikowalnych rzeczy. np. wsadzenie
> listy do tupli psuje haszowalność:
>
>>>> ( 1, 2, [3,4]).__hash__()
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   TypeError: unhashable type: 'list'
>
>
> więc czy te hasze są do czegoś użyteczne?

no te wlasnie hashe sa potrzebne dictowi, kluczem w slowniku moze byc  
wylacznie obiekt hashowalny, jak tuple, frozenset, str, int etc., zas  
lista, set, dict nie moga byc kluczem w slowniku (choc moga byc wartoscia)
http://en.wikipedia.org/wiki/Hash_table tu pewnie pisza, jak dokladnie  
dict tego hasha uzywa

-- 
Jordan Szubert

Dnia 10-11-2011 o 16:41:56 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-10, Edek <edek.pienkowski@gmail.com> wrote:
>>> czy tych haszy się do czegoś używa?
>>
>> >>> key1 = (1,2,3)
>> >>> key2 = [1,2,3]
>> >>> d1 = { key1 : 'raz dwa trzy'}
>> >>> d1[key2] = 'lista'
>> Traceback (most recent call last):
>>    File "<stdin>", line 1, in <module>
>> TypeError: unhashable type: 'list'
>> >>>
>
> chyba nie do końca kumam. jaki jest cel robienia klucza w d1 w taki
> sposób?
>
> i powiązane - jak zrobić przypisanie do "dicta w dictcie"?
>
> np. w perlu mam:
>
> $hash->{'klucz'}->{'pod-klucz'} = 123;
>
> jak to zrobić w pythonie?
>
> probowalem:
>>>> d1["a"]["b"]="123"
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
>   KeyError: 'a'
>
> depesz
>

d1=dict()
d1["a"]=dict()
di["a"]["b"]="123"


-- 
Jordan Szubert

Dnia 10-11-2011 o 17:00:34 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
>>> nie za bardzo widzę różnicę.
>>
>> o fakt, domyślnie stara się wpakować w jedna linijkę, jak się nie uda to
>> wcina dopiero
>>
>>>>> pprint({1:2,3:4})
>> {1: 2, 3: 4}
>>>>> pprint({1:2,3:4},width=1)
>> {1: 2,
>>   3: 4}
>>>>>
>
> ok. super. to teraz pytanie drążące:
> gdzie/jak można to samemu znaleźć?
>
> tzn. w perlu mam cośt takiego jak "perldoc"
> np. perldoc DBI pokazuje mi dokumentację do modułu DBI. jak zrobić coś
> takiego w pythonie?
>
> depesz
>

import pprint
help(pprint)
help(pprint.pprint)

-- 
Jordan Szubert

On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
> import pprint
> help(pprint)
> help(pprint.pprint)

dzięki. już kumam.

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
> d1=dict()
> d1["a"]=dict()
> di["a"]["b"]="123"

hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
koniecznie mieć 10 poziomów wgłąb?

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On Thu, 10 Nov 2011 17:09:28 +0100 "Jordan Szubert" <usenet@joru.us.to>
wrote:

> > ok. super. to teraz pytanie drążące:
> > gdzie/jak można to samemu znaleźć?
> >
> > tzn. w perlu mam cośt takiego jak "perldoc"
> > np. perldoc DBI pokazuje mi dokumentację do modułu DBI. jak zrobić
> > coś takiego w pythonie?
> >
> > depesz
> >
> 
> import pprint
> help(pprint)
> help(pprint.pprint)

I jeszcze dir(obiekt) - zwraca listę metod i pól obiektu.

w.

On 11/10/2011 05:48 PM, hubert depesz lubaczewski wrote:
> On 2011-11-10, Jordan Szubert<usenet@joru.us.to>  wrote:
>> d1=dict()
>> d1["a"]=dict()
>> di["a"]["b"]="123"
>
> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
> koniecznie mieć 10 poziomów wgłąb?

Jeżeli wcześniejsze poziomy nie mają doczepionych wartości:
d1[("a", "b", "c")] = "123"
d1[("a", "b")] = "12"

W skrócie:
d1[tuple(someIterable)] = value

Jeżeli mają, to hmm....

depthList = ["a","b","c"]
d1 = {}

reduce(lambda d,k: d.get(k, {}), \
	depthList[0:-2], d1)[depthList[-1]] = "123"

Tu każdy "level" może mieć pod kluczem albo wartość albo drzewo,
a nie i jedno i drugie, czyli "nie udało mi się", a łatwiej
z krotką jako klucz.

Trzebaby doczepiać i wartość i subtree - w krotce? :-)

Edek

On Thu, 10 Nov 2011 17:48:16 +0100
hubert depesz lubaczewski <depesz@depesz.com> wrote:

> > d1=dict()
> > d1["a"]=dict()
> > di["a"]["b"]="123"
> 
> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
> koniecznie mieć 10 poziomów wgłąb?

d1 = {'a': {'b': "123"}} …?

-- 
      -^-  _        coś tam w tle sobie gra, np:
   _ /O)_\//        Slayer - Spirit In Black
  (_(|__(_(_) grf.  

On Thu, 10 Nov 2011 17:00:34 +0100
hubert depesz lubaczewski <depesz@depesz.com> wrote:

> On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
> >> nie za bardzo widzę różnicę.
> >
> > o fakt, domyślnie stara się wpakować w jedna linijkę, jak się nie uda to  
> > wcina dopiero
> >
> >>>> pprint({1:2,3:4})
> > {1: 2, 3: 4}
> >>>> pprint({1:2,3:4},width=1)
> > {1: 2,
> >   3: 4}
> >>>>
> 
> ok. super. to teraz pytanie drążące:
> gdzie/jak można to samemu znaleźć?
> 
> tzn. w perlu mam cośt takiego jak "perldoc"
> np. perldoc DBI pokazuje mi dokumentację do modułu DBI. jak zrobić coś
> takiego w pythonie?

$ pydoc pprint

-- 
      -^-  _        coś tam w tle sobie gra, np:
   _ /O)_\//        Slayer - Spirit In Black
  (_(|__(_(_) grf.  

Dnia 10-11-2011 o 17:48:16 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
>> d1=dict()
>> d1["a"]=dict()
>> di["a"]["b"]="123"
>
> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
> koniecznie mieć 10 poziomów wgłąb?

moze niekoniecznie w glab, d1[("a","b")]="123" moze?

d1.setdefault("a",dict())["b"]="123"

dla M[0][1][2][3][4]=5 chyba powinno dzialac  
M.setdefault(0,dict()).setdefault(1,dict()).setdefault(2,dict()).setdefault(3,dict())[4]=5

-- 
Jordan Szubert

On 2011-11-10, Roman Dobosz <gryf_esm-no@spam-o2.pl> wrote:
> On Thu, 10 Nov 2011 17:48:16 +0100
> hubert depesz lubaczewski <depesz@depesz.com> wrote:
>
>> > d1=dict()
>> > d1["a"]=dict()
>> > di["a"]["b"]="123"
>> 
>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>> koniecznie mieć 10 poziomów wgłąb?
>
> d1 = {'a': {'b': "123"}} …?

ale to nadpisuje całe d1.

ok. rozumiem, że nie ma prostej metody na wpisanie czegoś na n-ty poziom
zagnieżdżenia, z auto-tworzeniem poziomów jeśli nie istnieją.

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On 2011-11-10, Wojciech Muła <wojciech_mula@poczta.null.onet.pl.invalid> wrote:
> I jeszcze dir(obiekt) - zwraca listę metod i pól obiektu.

tak, ale output z tego jest mocno kryptyczny.

>>> dir("aa")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
'__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__',
'__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__',
'__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'_formatter_field_name_split', '_formatter_parser', 'capitalize',
'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower',
'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip',
'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip',
'swapcase', 'title', 'translate', 'upper', 'zfill']

jest jakaś metoda by doczytać co robi np. _formatter_parser ?

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

Dnia 10-11-2011 o 18:30:05 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-10, Wojciech Muła <wojciech_mula@poczta.null.onet.pl.invalid>  
> wrote:
>> I jeszcze dir(obiekt) - zwraca listę metod i pól obiektu.
>
> tak, ale output z tego jest mocno kryptyczny.
>
>>>> dir("aa")
> ['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
> '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
> '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__',
> '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__',
> '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__',
> '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
> '_formatter_field_name_split', '_formatter_parser', 'capitalize',
> 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find',
> 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower',
> 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip',
> 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
> 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip',
> 'swapcase', 'title', 'translate', 'upper', 'zfill']
>
> jest jakaś metoda by doczytać co robi np. _formatter_parser ?

no help("aa"._fromatter_parser), chyba ze do danego pola nie ma po prostu  
w ogole dokumentacji (co calkiem mozliwe, jako ze zaczyna sie od _ )

-- 
Jordan Szubert

On Thu, 10 Nov 2011 18:29:01 +0100
hubert depesz lubaczewski <depesz@depesz.com> wrote:

> > d1 = {'a': {'b': "123"}} …?
> ale to nadpisuje całe d1.

Racja. W takim razie pozostaje setdefault()

> ok. rozumiem, że nie ma prostej metody na wpisanie czegoś na n-ty poziom
> zagnieżdżenia, z auto-tworzeniem poziomów jeśli nie istnieją.

Wprost z pudełka - nie, ale można podziedziczyć po słowniku i zrobić
coś w stylu:

http://stackoverflow.com/questions/635483/what-is-the-best-way-to-implement-nested-dictionaries-in-python

-- 
      -^-  _        coś tam w tle sobie gra, np:
   _ /O)_\//        Slayer - Born Of Fire
  (_(|__(_(_) grf.  

On Thu, 10 Nov 2011 18:30:05 +0100 hubert depesz lubaczewski
<depesz@depesz.com> wrote:

> On 2011-11-10, Wojciech Muła
> <wojciech_mula@poczta.null.onet.pl.invalid> wrote:
> > I jeszcze dir(obiekt) - zwraca listę metod i pól obiektu.
> 
> tak, ale output z tego jest mocno kryptyczny.

Ta funkcja raczej służy do tego, aby zobaczyć, co jest w środku
obiektu. Przynajmniej wiesz, czego szukać w dokumentacji. :)

Możesz dość łatwo przejrzeć helpa dla wszystkich pól.

obj = "aa"
for field in [f for f in dir(obj) if not f.startswith("__")]:
	help(getattr(obj, field))

w.

On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
> no help("aa"._fromatter_parser), chyba ze do danego pola nie ma po prostu  
> w ogole dokumentacji (co calkiem mozliwe, jako ze zaczyna sie od _ )

a _xx jest jakieś specjalne?
czy to obejmuje też __xx__ ?

depesz

-- 
The best thing about modern society is how easy it is to avoid contact with it.
                                                             http://depesz.com/

On Thu, 10 Nov 2011 18:59:23 +0100
hubert depesz lubaczewski <depesz@depesz.com> wrote:

> a _xx jest jakieś specjalne?
> czy to obejmuje też __xx__ ?

Zobacz sekcję Naming conventions w http://www.python.org/dev/peps/pep-0008

__xx__: tak nazywane są specjalne metody lub atrybuty obiektów
(__init__, __call__, __cmp__, __import__, __name__ itd)

_xx: przyjęło się oznaczać zmienne prywatne lub protected (lub po
prostu takie, których nie chcemy, by były używane wprost)

__xx: zmienne prywatne, do których nie ma(?) dostępu z zewnątrz kontekstu,
np:

$ python
Python 2.7.2 (default, Oct 24 2011, 16:38:44) 
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
'starting up...'
>>> class Foo(object):
...     def __init__(self):
...             self.x = 1
...             self._x = 2
...             self.__x = 3
... 
>>> foo = Foo()
>>> foo.x
1
>>> foo._x
2
>>> foo.__x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__x'
>>> # ale....
... 
>>> foo._Foo__x
3
>>>

-- 
      -^-  _        coś tam w tle sobie gra, np:
   _ /O)_\//        Slayer - War Ensemble
  (_(|__(_(_) grf.  

On 2011-11-10, hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-10, Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>>>>> 2. jaka jest praktyczna różnica między [listą] a (tuplą) ?
>>>>
>>>> W dyskusji pojawia się niehaszowalność listy, w odróżnieniu od krotki:
>>>>   http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/
>>>> Co zresztą ma sens, skoro krotka jest niezmienna (haszkod też nie
>>>> powinien, inaczej element musiałby wędrować po strukturze albo byłby
>>>> problem z jego namierzeniem przy dostępie).
>>>
>>> czy tych haszy się do czegoś używa?
>>
>> Depesz, no przestań! A jak twoim zdaniem jest zbudowany słownik (Python)
>> czy %tablica (Perl)? Haszkod jest używany do zlokalizowania wartości
>> w pamięci (odpowiedniego kubełka).
>
> moment. dict to dict.
>
> a hasz tupli to coś innego:

Zgadza się. Ale czego używa dict, będący strukturą danych nazywaną
"tablica haszująca", do rozrzucania obiektów po kubełkach? No chyba
hasza.

> więc czy te hasze są do czegoś użyteczne?

Tak, do obliczenia wartości klucza, tak żeby klucz typu krotka był
porównywalny z kluczem typu int albo kluczem typu string. Żebyś krotką
mógł indeksować hasztablicę (tu reprezentowaną przez wbudowany typ
dict).

-- 
Secunia non olet.
Stanislaw Klekot

On 2011-11-10, hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-10, Roman Dobosz <gryf_esm-no@spam-o2.pl> wrote:
>> On Thu, 10 Nov 2011 17:48:16 +0100
>> hubert depesz lubaczewski <depesz@depesz.com> wrote:
>>
>>> > d1=dict()
>>> > d1["a"]=dict()
>>> > di["a"]["b"]="123"
>>> 
>>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>>> koniecznie mieć 10 poziomów wgłąb?
>>
>> d1 = {'a': {'b': "123"}} …?
>
> ale to nadpisuje całe d1.
>
> ok. rozumiem, że nie ma prostej metody na wpisanie czegoś na n-ty poziom
> zagnieżdżenia, z auto-tworzeniem poziomów jeśli nie istnieją.

Nie, to perlizm. Moim zdaniem dość swobodny (czy też niechlujny).

-- 
Secunia non olet.
Stanislaw Klekot

Dnia 10-11-2011 o 18:59:23 hubert depesz lubaczewski <depesz@depesz.com>  
napisał(a):

> On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
>> no help("aa"._fromatter_parser), chyba ze do danego pola nie ma po  
>> prostu
>> w ogole dokumentacji (co calkiem mozliwe, jako ze zaczyna sie od _ )
>
> a _xx jest jakieś specjalne?
> czy to obejmuje też __xx__ ?
>
> depesz
>

http://www.python.org/dev/peps/pep-0008/

-- 
Jordan Szubert

On 2011-11-10, hubert depesz lubaczewski <depesz@depesz.com> wrote:
> On 2011-11-10, Jordan Szubert <usenet@joru.us.to> wrote:
>>> nie za bardzo widzę różnicę.
>>
>> o fakt, domyślnie stara się wpakować w jedna linijkę, jak się nie uda to  
>> wcina dopiero
>>
>>>>> pprint({1:2,3:4})
>> {1: 2, 3: 4}
>>>>> pprint({1:2,3:4},width=1)
>> {1: 2,
>>   3: 4}
>>>>>
>
> ok. super. to teraz pytanie drążące:
> gdzie/jak można to samemu znaleźć?
>
> tzn. w perlu mam cośt takiego jak "perldoc"
> np. perldoc DBI pokazuje mi dokumentację do modułu DBI. jak zrobić coś
> takiego w pythonie?

pydoc, ale jakość pydoców (nawet ze standardowej dystrybucji Pythona)
jest moim zdaniem daleko w tyle za tym, co zwykle dostajemy w Perlu.

-- 
Secunia non olet.
Stanislaw Klekot

On 10.11.2011, hubert depesz lubaczewski <depesz@depesz.com> wroted:

> ok. rozumiem, że nie ma prostej metody na wpisanie czegoś na n-ty poziom
> zagnieżdżenia, z auto-tworzeniem poziomów jeśli nie istnieją.

Zapomnij o tworzeniu czegokolwiek "domyślnie" i chodzeniu na skróty. 
Nie będzie żadnych list tworzonych i wypełnianych nullami po odwołaniu 
do nieistniejącej listy z nieistniejącym indeksem. Będzie wyjątek.

GS
-- 
Grzegorz Staniak   <gstaniak _at_ gmail [dot] com>

(10.11.2011 18:29), hubert depesz lubaczewski wrote:
> On 2011-11-10, Roman Dobosz<gryf_esm-no@spam-o2.pl>  wrote:
>> On Thu, 10 Nov 2011 17:48:16 +0100
>> hubert depesz lubaczewski<depesz@depesz.com>  wrote:
>>
>>>> d1=dict()
>>>> d1["a"]=dict()
>>>> di["a"]["b"]="123"
>>>
>>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>>> koniecznie mieć 10 poziomów wgłąb?
>>
>> d1 = {'a': {'b': "123"}} …?
>
> ale to nadpisuje całe d1.
>
> ok. rozumiem, że nie ma prostej metody na wpisanie czegoś na n-ty poziom
> zagnieżdżenia, z auto-tworzeniem poziomów jeśli nie istnieją.

defaultdict ?

p. m.

In the darkest hour on Thu, 10 Nov 2011 17:47:39 +0100,
hubert depesz lubaczewski <depesz@depesz.com> screamed:
>> import pprint
>> help(pprint)
>> help(pprint.pprint)
>
> dzięki. już kumam.
>

Polecam ipythona. Dopełnianie tabem i wiele innych rzeczy w stylu:

In [1]: import pprint
In [2]: pprint?
Type:             module
Base Class:       <type 'module'>
String Form:   <module 'pprint' from '/usr/lib/python2.7/pprint.pyc'>
Namespace:        Interactive
File:             /usr/lib/python2.7/pprint.py
Docstring:
    Support to pretty-print lists, tuples, & dictionaries recursively.
[...]

In [3]: pprint.pprint?
Type:           function
Base Class:     <type 'function'>
String Form:    <function pprint at 0x7f6e450fa410>
Namespace:      Interactive
File:           /usr/lib/python2.7/pprint.py
Definition:     pprint.pprint(object, stream=None, indent=1, width=80,
depth=None)
Docstring:
    Pretty-print a Python object to a stream [default is sys.stdout].

In [4]: pprint.pprint??
Type:           function
Base Class:     <type 'function'>
String Form:    <function pprint at 0x7f6e450fa410>
Namespace:      Interactive
File:           /usr/lib/python2.7/pprint.py
Definition:     pprint.pprint(object, stream=None, indent=1, width=80,
depth=None)
Source:
def pprint(object, stream=None, indent=1, width=80, depth=None):
    """Pretty-print a Python object to a stream [default is sys.stdout]."""
        printer = PrettyPrinter(
            stream=stream, indent=indent, width=width, depth=depth)
        printer.pprint(object)

itd...

-- 
[ Artur M. Piwko : Pipen : AMP29-RIPE : RLU:100918 : From == Trap! : SIG:232B ]
[ 10:07:22 user up 12984 days, 22:02,  1 user, load average: 0.43, 0.01, 0.64 ]

         Between two evils, I always pick the one I never tried before.

On 10 Lis, 17:48, hubert depesz lubaczewski <dep...@depesz.com> wrote:
> On 2011-11-10, Jordan Szubert <use...@joru.us.to> wrote:
>
> > d1=dict()
> > d1["a"]=dict()
> > di["a"]["b"]="123"
>
> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
> koniecznie mieć 10 poziomów wgłąb?

Tak od kopa nie ma, ale zawsze możesz coś zrobić swojego:


>>> class ddict(dict):
...     def __getitem__(self, name):
...         if name not in self.__dict__:
...             self.__dict__[name] = ddict()
...         return self.__dict__[name]
...     def __setitem__(self, name, value):
...         self.__dict__[name] = value
...
>>> if __name__ == '__main__':
...     di = ddict()
...     di["a"]["b"]="123"
...     di["a"]["e"]["f"]="123f"
...     print di["a"]["b"]
...     print di["a"]["e"]["f"]
...
123
123f

metody __getitem__, __setitem__ to do dictow, list ... . Czyli jak
wkładasz coś do dicta/listy to wołana jest metoda __setitem__ itd

sa jeszcze metody __getattr__ / __getattribute__ , __setattr__ to do
atrybutów "depesz.attrybut" itp (opcjonalnie getattr(obiekt, attr,
default) i setattr(obiekt, attr, value).

--
Paweł Socha

On 2011-11-13, merlin <pawel.socha@gmail.com> wrote:
> On 10 Lis, 17:48, hubert depesz lubaczewski <dep...@depesz.com> wrote:
>> On 2011-11-10, Jordan Szubert <use...@joru.us.to> wrote:
>>
>> > d1=dict()
>> > d1["a"]=dict()
>> > di["a"]["b"]="123"
>>
>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>> koniecznie mieć 10 poziomów wgłąb?
>
> Tak od kopa nie ma, ale zawsze możesz coś zrobić swojego:

Typowa przypadłość Pascalowca: "nie ma w bibliotece standardowej, ale
łatwo to napisać samemu". Nieważne że być może właśnie niełatwo. Trochę
zbyt często to widzę u piszących w Pythonie.

-- 
Secunia non olet.
Stanislaw Klekot

(15.11.2011 00:16), Stachu 'Dozzie' K. wrote:
> On 2011-11-13, merlin<pawel.socha@gmail.com>  wrote:
>> On 10 Lis, 17:48, hubert depesz lubaczewski<dep...@depesz.com>  wrote:
>>> On 2011-11-10, Jordan Szubert<use...@joru.us.to>  wrote:
>>>
>>>> d1=dict()
>>>> d1["a"]=dict()
>>>> di["a"]["b"]="123"
>>>
>>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>>> koniecznie mieć 10 poziomów wgłąb?
>>
>> Tak od kopa nie ma, ale zawsze możesz coś zrobić swojego:
>
> Typowa przypadłość Pascalowca: "nie ma w bibliotece standardowej, ale
> łatwo to napisać samemu". Nieważne że być może właśnie niełatwo. Trochę
> zbyt często to widzę u piszących w Pythonie.
>

Zwłaszcza że to *jest* w bibliotece standardowej od 2.5

p. m.

Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
> On 2011-11-13, merlin <pawel.socha@gmail.com> wrote:
>> On 10 Lis, 17:48, hubert depesz lubaczewski <dep...@depesz.com> wrote:
>>> On 2011-11-10, Jordan Szubert <use...@joru.us.to> wrote:
>>>
>>> > d1=dict()
>>> > d1["a"]=dict()
>>> > di["a"]["b"]="123"
>>>
>>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>>> koniecznie mieć 10 poziomów wgłąb?
>>
>> Tak od kopa nie ma, ale zawsze możesz coś zrobić swojego:
> 
> Typowa przypadłość Pascalowca: "nie ma w bibliotece standardowej, ale
> łatwo to napisać samemu". Nieważne że być może właśnie niełatwo. Trochę
> zbyt często to widzę u piszących w Pythonie.
	... jst kupe gotowego kodu. Warto czasami poszukac;-) Np. tu:
ftp://ftp.ertel.com.pl/Centos/pytoolkit/ ;-)
Z powazaniem
								Adam Przybyla

On 2011-11-15, Adam Przybyla <adam@rybnik.pl> wrote:
> Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>> On 2011-11-13, merlin <pawel.socha@gmail.com> wrote:
>>> On 10 Lis, 17:48, hubert depesz lubaczewski <dep...@depesz.com> wrote:
>>>> On 2011-11-10, Jordan Szubert <use...@joru.us.to> wrote:
>>>>
>>>> > d1=dict()
>>>> > d1["a"]=dict()
>>>> > di["a"]["b"]="123"
>>>>
>>>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>>>> koniecznie mieć 10 poziomów wgłąb?
>>>
>>> Tak od kopa nie ma, ale zawsze możesz coś zrobić swojego:
>> 
>> Typowa przypadłość Pascalowca: "nie ma w bibliotece standardowej, ale
>> łatwo to napisać samemu". Nieważne że być może właśnie niełatwo. Trochę
>> zbyt często to widzę u piszących w Pythonie.
> 	... jst kupe gotowego kodu. Warto czasami poszukac;-) Np. tu:
> ftp://ftp.ertel.com.pl/Centos/pytoolkit/ ;-)

Adamie, wiem że można znaleźć różne moduły, ale nie o tym mówię. Mówię
o mentalności starego, zatwardziałego Pascalowca, który nie rozumie
w czym problem, że czegoś brakuje, bo przecież każdy może to łatwo
dorobić.

-- 
Secunia non olet.
Stanislaw Klekot

Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
> On 2011-11-15, Adam Przybyla <adam@rybnik.pl> wrote:
>> Stachu 'Dozzie' K. <dozzie@go.eat.some.screws.spammer.invalid> wrote:
>>> On 2011-11-13, merlin <pawel.socha@gmail.com> wrote:
>>>> On 10 Lis, 17:48, hubert depesz lubaczewski <dep...@depesz.com> wrote:
>>>>> On 2011-11-10, Jordan Szubert <use...@joru.us.to> wrote:
>>>>>
>>>>> > d1=dict()
>>>>> > d1["a"]=dict()
>>>>> > di["a"]["b"]="123"
>>>>>
>>>>> hmm .. a nie ma jakiegoś shortcuta, gdybym na przykład uznał, że muszę
>>>>> koniecznie mieć 10 poziomów wgłąb?
>>>>
>>>> Tak od kopa nie ma, ale zawsze możesz coś zrobić swojego:
>>> 
>>> Typowa przypadłość Pascalowca: "nie ma w bibliotece standardowej, ale
>>> łatwo to napisać samemu". Nieważne że być może właśnie niełatwo. Trochę
>>> zbyt często to widzę u piszących w Pythonie.
>>       ... jst kupe gotowego kodu. Warto czasami poszukac;-) Np. tu:
>> ftp://ftp.ertel.com.pl/Centos/pytoolkit/ ;-)
> 
> Adamie, wiem że można znaleźć różne moduły, ale nie o tym mówię. Mówię
> o mentalności starego, zatwardziałego Pascalowca, który nie rozumie
> w czym problem, że czegoś brakuje, bo przecież każdy może to łatwo
> dorobić.
	... piszac po raz tysieczny mplementacje slownika, taak, masz racje,
sa tacy ludzie ... juz na wyginieciu na szczescie albo na uczelniach;-) Z powazaniem
								Adam Przybyla