Comment créer cette liste proprement

Le problème exposé dans ce sujet a été résolu.

Bonjour, Je voudrait créer une liste dans un certains format. J'ai réussit à le faire mais je suis sûr qu'il y à une manière plus propre de faire. Voici le format que j'aimerais :

1
2
3
4
5
[1, 0.21033294644828482, -0.04879441410265284],
 [1, 0.3867614332105196, 0.5507967444065724],
 [1, 0.9448001695726282, -0.5765377066788102],
 [1, 0.5541840188878624, 0.5638237711050023],
 [1, -0.6785874088030366, -0.6431353501372337]]

Et voici le code que j'ai :

1
2
3
4
x = []
for j in range(n):
    x1, x2 = [random.uniform(-1, 1) for i in range(2)]
    x.append([1, x1, x2])

Comme vous l'avez sûrement remarqué, il s'agit de python. J'utilise numpy dans mon code et d'autres lib dans le même genre, donc n'hésitez pas à les utiliser si vous avez une idée ^^

Merci d'avance !

Bonjour,

J'aurais tendance à écrire ça de la sorte :

1
x = [[1, random.uniform(-1, 1), random.uniform(-1, 1)] for j in range(n)]

Ou même, si tu n'as pas nécessairement besoin de listes à l'intérieur de la principale :

1
x = [(1, random.uniform(-1, 1), random.uniform(-1, 1)) for j in range(n)]

Pardon j'avais envie de m'amuser c'est amusant à écrire comme fonction :) (c'est complètement HS, mais des fois que ça intéresse quelqu'un)

1
2
3
4
5
6
7
Random.metaClass.between = { i, j ->
    i + (j - i) * delegate.nextDouble()
}
int n = 10
new Random().with {
    println((1..n).collect { [1, between(-1, 1), between(-1, 1)] })
}

+0 -1

Tout cela va dépendre si le travail s'arrête là ou non… Si tu as beaucoup d'opérations à faire sur tes arrays, j'ai tendance à dire que numpy est conseillé, si par contre ça s'arrête là, je vois pas l'intérêt d'écraser une mouche avec un marteau. Mais je pense que niveau construction seule, la solution d'entwanne est bien plus rapide, dû aux nombres d'opérations que je répète sur mon array.

Je pense tenir plus rapide avec numpy

1
2
array = np.random.uniform(-1, 1, size=(5,3))
array[:, 0] = 1

D'après mes essais on est 2x plus rapide sur cette taille, mais si on ajoute des lignes en grand nombre, alors ma solution explose le temps de la solution d'entwanne.

+0 -0

Je déterre un peu le sujet mais comme c'est tout à fait le même genre de question, inutile d'en recréer un

J'ai une matrice de taille NxP et j'aimerais rajouter un vecteur à la fin. Je vous montre :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[[  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   1.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   3.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   4.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   5.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   6.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   7.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   8.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   9.],
       [  2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,   2.,  10.]]

Sauf que là je l'ai fait automatiquement. En gros j'aimerais coller un vecteur (ou tableau) b de manière à ce que a[i, -1] = b[i]

Comme avant, numpy et python 2.7 sont mes alliés :)

Merci d'avance :)

En fait le choix entre les listes/tuples en intension ou numpy ne devrait pas se faire uniquement sur les performances de la construction d'une liste, mais plutôt en fonction de la nature du programme.

Tu as besoin de manipuler des matrices dans leur ensemble avec beaucoup d'opérations/manipulations de tableaux ? numpy.

Tu n'as besoin que de générer des triplets de valeurs pour itérer dessus ? Dans ce cas n'importe pas l'artillerie numpy pour ça, la liste, voire une expression génératrice suffiront largement.

La question de perfs ne peut être abordée que sur un programme complet, pas sur un micro-détail comme celui-là.

PS :

Si a est un vecteur :

1
[a + [x] for x in b]

Si a est une matrice :

1
[x + [y] for x, y in zip(a, b)]

Edit2 : correction des suggestions

+1 -0

En fait je suis en train d'implémenter un réseau de neurones from scratch (pour bien comprendre comment ça fonctionne). Donc il y à beaucoup de multiplication matricielle. Si je pose ces questions c'est surtout pour l'écrire de manière "pythonesque" parce que sinon je fais des boucles et puis ça marche très bien. Mais j'ai envie d'apprendre à écrire un code propre en python scientifique (donc numpy quand c'est nécessaire) :)

Merci en tout cas ;)

Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte