Ciao a tutti, non so bene come fare per inizializzare una lista bidimensionale di valori diversi (non tutti 0 o altro):
Per valori uguali posso fare così:

>>> l=[[0]*3]*3
>>> l
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> 

ma io vorrei una cosa del genere:
[[0,1,2],[3,4,5],[6,7,8]]
Forse con una piccola modifica al codice sopra( l=[[0]*3]*3) è possibile farlo, ma forse mi mancano ancora cose che non conosco (probabile)
Ho provato a modificare con:

l=[[for i in range(5)]*3]*3

Ma non funziona
Ho cercato allora di far andare il cervello per puro esercizio, poi al limite proseguendo lo studio, o magari con qualche vostra dritta imparerò altri trucchi.
Sono "approdato" a questo. vorrei sapere da voi se può essere accettabile (è un po' C style a dire il vero...non sono propiamente soddisfatto):

l=[]
val=0
for i in range (5):
	l1=[]
	for x in range (5):
		l1.append(val)
		val+=1
	l.append(l1)
print (l)

output:

gila@gila-pc:~/Scrivania$ python3 x.py
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19], [20, 21, 22, 23, 24]]

grazie a tutti in anticipo

se vuoi manipolare tensori comincia a far andare il cervello con numpy e scordati le liste

Non ti ho capito. A volte potrebbero servirmi liste bidimensionali già inizializzate. bhò...grazie lo stesso, ma non mi sei di aiuto così
Forse non ti è chiaro che sono un neofita

No, nessuna controindicazione, mi sembra solo prematuro al mio stato attuale. Comunque grazie, perl lo meno, adesso sapro' che ci sono approcci migliori. Mi puo' tornare utile in futuro

Ciao
 intrigato dal post ho voluto provare una list comprehensions per il "dilemma" iniziale posto da @Gila, una introduzione in merito della tecnica è nel link (sono niubbo quanto lui)

>>> l = [[y+5*x for y in range(5)] for x in range(5)]
>>> l
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19], [20, 21, 22, 23, 24]]

non cambia molto dal punto di vista "efficienza" ma segnalo

@Caron non ti crucciare ... penso che al momento @gila miri principalmente ad apprendere come padroneggiare gli "attrezzi" di base ed acquisire una "furma mentis" adeguata a python, ripulita dei concetti ereditati da precedenti esperienze, cosa che, per altro, occorre anche a me. Passo necessario, questo, prima di procedere ad acquisire concetti e metodi "altri", per poter valutare e scegliere quali mezzi utilizzare in una propria applicazione.

Ciò non toglie che è molto interessante il Tuo esempio con numpy

>>> import numpy as np
>>> a=25
>>> b=5
>>> np.arange(a).reshape(b,b)
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])
>>> 

Personalmente, non avevo neanche la definizione di "tensore" (vettore di vettori?) ma è interessante ciò che ho trovato, pur essendo lontano dal calcolo scientifico una volta soddisfatte le "basi" certamente numpy è tra le librerie da studiarsi. L'indicazione data è certamente utiissima

@Nuzzo ha capito perfettamente la questione: io per ora voglio esercitarmi con le basi, cio' non toglie come dici tu caronte che sia una cattiva abitudine, e hai fatto bene a dirmelo. Non sapevo nemmeno esistesse quella libreria.
Lo so sono esempi sciocchi, ma piu' o meno ci siamo passati tutti.
Grazie degli esempi, sta sera dopo il lavoro li studio.
Ps: in definitiva numpy usa degli array piu' o meno come il c mi sembra di capire

Se proprio ci si vuol far male a maneggiare numeri con liste:

>>> from copy import deepcopy
>>> from itertools import repeat
>>> row = [0] * 10
>>> row
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

>>> py_mat = list(repeat(deepcopy(row), 10))

>>> from pprint import pprint
>>> pprint(py_mat)
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

Che in numpy diventa:

>>> import numpy as np
>>> np_mat = np.zeros((10, 10), dtype=int)
>>> np_mat
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])

Se ora guardiamo il consumo di memoria:

>>> getsizeof(py_mat[0]) * 10 + getsizeof(py_mat)
2208
>>> np_mat.nbytes
800

e capirai perche' tutti usano numpy: semplicemente perche' espone la memoria cosi' com'e', nuda e cruda