u/Mental_Primary_5558

bonjour tout le monde, j'aimerais executer un code dont la logique est exactement la même:

import numpy as np

limport numpy as np

l=[0,1]

def albert():

p=np.random.choice(l)

if p==0:

name='einstein'

else:

name2='camus'

return (name or name2)

albert()

https://preview.redd.it/odlbduaf6t9h1.png?width=1920&format=png&auto=webp&s=ba1eeafea6b98d17e36c42f2b11c0636503225c0

name n'a aucun problème pour afficher einstein mais pour name2 il ne s'affiche jamais j'ai juste une erreur sur name " UnboundLocalError: cannot access local variable 'name' where it is not associated with a value "

quelqu'un à t-il la solution

Hi guys, I'm a physics student, I don't know much of maths concerning topology, metric spaces etc a part from basic linear algebra (Matrix diagonalization) so don't go to far with your explanation to my question!

I'm currently working on a project (diffusion limited agregation) where we get some fractal trees at the end of the simulation and in order to calculate its dimension I use the Box-Counting method, but why does it actually work? I mean like Hausdorff dimension is based on a definition, "dimension is related to how much the objet scales itself, as N^d=r" but what is the box_counting based on?

Bonjour à tous j'aurais besoin d'un retour sur une partie de mon rapport:

https://preview.redd.it/inajpn37w08h1.png?width=812&format=png&auto=webp&s=d4a242e044b30ae08e82e1d95bd8425683afbafd

Est-ce comprehensible ou y'a t-il des trucs à rajouter, une question qu'un lecteur pourrait se poser etc c'est comme ça que je serai noté, merci de votre retour!

j'ai une liste L d'une certaine longeurs (3275 en l'occurence) qui contient des valeurs entre 0 et 4. j'ai voulu prendre toutes les valeurs=2 en faisant:

d=np.where(L==2)

j'ai le message d'erreur suivant: ValueError: Calling nonzero on 0d arrays is not allowed. Use np.atleast_1d(scalar).nonzero() instead. If the context of this error is of the form `arr[nonzero(cond)]`, just use `arr[cond]`.

pouvez vous me dire comment contourner ce problème et si possible d'ou vient-il?

PS: je mettrai un flair résolu si jamais je trouve une solution entre temps, merci de bien vouloir y répondre

Hi guys, is it possible to add two tuples? For example, (x,y)+(a,b) such that the sum is (x+a, y+b) and not a concatenation (x,y,a,b). Thanks for your help.

Bonjour les gars, est-ce qu'on peut additionner deux tuple? par exemple (x,y)+(a,b) tel que la somme vaut (x+a, y+b) et non pas une concatenation (x,y,a,b). Merci de bien vouloir répondre

J'aurais une petite question, est ce que le fait que ma formation souhaitée n'apparaisse pas dans le moteur de rechercheparcoursup le premier jour de la phase complementaire veut dire que mes chances d'y candidater pour la rentrée en Septembre 2026 sont nul? ou peut-il encore y'avoir des desistement notamment juillet/Aout? si vous avez des réponses n'hesitez pas, merci!

PS: je suis déjà dans une autre licence et j'ai validé une L2, je voulais candidtater à une autre formation en parallèle qui est en distancielle!

Bonjour à tous, executer le code suivant pour que vous puissiez comprendre le problème poser:

import numpy as np

grid=np.arange(128**2).reshape((128,128))

size=2**7

def divide_box(grid):

global grid3

grid3=\[\]

for i in range(int(np.log(size)/np.log(2))+1):

    j=2\*\*i

    grid2=np.vsplit(grid,j)

    for k in range(j):

    griddd=np.hsplit(grid2\[k\],j)

    grid3.append(griddd)

return grid3

divide_box(grid)

on a une grille de taille 128*128 soit 2^7*2^7.

divide_box divise cette grille 7 fois et le nombre de sous carré lui suit une loi en 4^n n allant jusqu'a 7 dans ce cas).

donc on aurait aimé finir avec grid3 contenant 8 liste dont la première sous liste contient 4^0 grille de coté (2^7)/(2^0), la deuixème contiennent une 4^1 grilles de coté (2^7)/2^1) et ainsi de suite jusqu'a la septième liste contenat 4^7 grilles de coté (2^7)/2^7)

mais du fait du vsplit qui est separé du hsplit on a la deuxième liste (represantant la première division) qui se divise en 2, 3e en 4, 4e en 8, 5e en 16, la 6e en 32, la 7e en 64, et la 8e en 128.

j'aimerais sommé les listes de meme taille comme par exemple la deuxième et la trosième sur la liste (voir image suivante) qui ont la meme taille:

on m'a proposer le code suivant:

liste = []

for i in range(8):

m = 0

for j in range(2\*\*i):

m += grid3\[j\]

liste.append(m)

print(liste)

mais lorsque j'execute ça affiche: " unsupported operand type(s) for +=: 'int' and 'list' " dans la console

Aidez moi s'il vous plait

Bonjour à tous, executer le code suivant pour que vous puissiez comprendre le problème poser:

import numpy as np

grid=np.arange(128**2).reshape((128,128))

size=2**7

def divide_box(grid):

global grid3

grid3=\[\]

for i in range(int(np.log(size)/np.log(2))+1):

    j=2\*\*i

    grid2=np.vsplit(grid,j)

    for k in range(j):

    griddd=np.hsplit(grid2\[k\],j)

    grid3.append(griddd)

return grid3

divide_box(grid)

on a une grille de taille 128*128 soit 2^7*2^7.

divide_box divise cette grille 7 fois et le nombre de sous carré lui suit une loi en 4^n n allant jusqu'a 7 dans ce cas).

donc on aurait aimé finir avec grid3 contenant 8 liste dont la première sous liste contient 4^0 grille de coté (2^7)/(2^0), la deuixème contiennent une 4^1 grilles de coté (2^7)/2^1) et ainsi de suite jusqu'a la septième liste contenat 4^7 grilles de coté (2^7)/2^7)

mais du fait du vsplit qui est separé du hsplit on a la deuxième liste (represantant la première division) qui se divise en 2, 3e en 4, 4e en 8, 5e en 16, la 6e en 32, la 7e en 64, et la 8e en 128.

j'aimerais sommé les listes de meme taille comme par exemple la deuxième et la trosième sur la liste (voir image suivante) qui ont la meme taille:

on m'a proposer le code suivant:

liste = []

for i in range(8):

m = 0

for j in range(2\*\*i):

m += grid3\[j\]

liste.append(m)

print(liste)

mais lorsque j'execute ça affiche: " unsupported operand type(s) for +=: 'int' and 'list' " dans la console

Aidez moi s'il vous plait

voici un exemple plus concret de ce que j'essaie de faire, grid3 est une liste qui va de 0 à 127 et j'aimerais remplir liste[] avec 0, puis 0+1, puis 0+1+2+3, puis 0+1+2+3+4+5+6+7, et ainsi de suite. Pouvez vous m'aider s'il vous plait?

import numpy as np

grid3=np.arange(128)

liste=[]

for i in range(8):

for j in range(2**i):

m=np.sum(grid3[j])

liste.append(m)

Bonjour, alors je travaille actuellement sur un projet dans le cadre de mon stage et je suis à un point ou après avoir générer des 1 aléatoirement suivant une certaine densité dans une grille de taille (2^n)*(2^n) et les avoir fait bouger aléatoirement et ensuite implémenter des deux dans la grille la règle étant que les deux représente des graines, les 1 les particules libres qui se déplacent et les zéros des cases vide, les particules ne se déplacent que dans les cases vide ( en haut en bas a gauche et à droite ) et lorsqu'elle se trouve à coté d'une graine elle s'agrège à elle et ainsi au bout d'un certain nombre d'itération on fini avec une image qui ressemble à la suivante:

https://preview.redd.it/lpzzra0nff5h1.png?width=1920&format=png&auto=webp&s=245772a232af4830bfdd42254d9a6c8f9fdb764d

ici la le nombre d'itérations de ma boucle étant pas suffisant certaine particule ne sont pas agrégés et reste donc libre (les bleus) et maintenant la tâche restante étant que je dois diviser la boite par 2 (horizontalement et verticalement) et on se retrouve avec un nombre de carré qui suit une loi en 4*n (dans mon cas n=7, pas l'image que j'ai fourni) et à chaque fois je dois compter les cases qui contiennent au moins une graine. L'initialisation commence à 0 donc 4^0 étant égale 1 on regard et la boite en entier et on regarde si il y'a une graine, ensuite 4^1 la boite se divise en 4 boite et on regarde dans les 4 boites combien en contiennent au mois une graine.

j'ai proposé le code suivant avec une fonction qui elle divise verticalement ici (mais qui pourrait tout aussi bien le faire horizontalement)

size==2^n (je tiens à le précisé)

# aggregation_density=[]

# for i in range((np/log(size)/np.log(2))+1): # cette ligne permet de savoir le nombre totale #de division permis, ça donne n en gros et le +1 car range s'arrête à i-1

# j=2**i

# gridd=np.vsplit(grid,j)

# for k in range(j+1)

# if np.any(gridd[j]==2):

# m=m+1 # ici je veux juste dire que je fais un compteur qui n'est pas correcte ici certes # mais que je que je corrigerais après!

# if k==j:

# aggregation_density.append(i)

# else:

# continue

si j'avais une fonction qui elle divise en verticalement et horizontalement j'aurais proposé le code suivant qui est identique avec la seul différence du range qui serait de (np/log(size^2)/np.log(4))+1 et ainsi je pourrais avoir. Est ce que vous connaitriez une fonction qui puisse découper une grille verticalement et horizontalement pour que je puisse résoudre ce problème.

PS: ça fait 2 jours je bloque là-dessus