esercizi dizionari python




Come unire due dizionari in una singola espressione? (20)

Ho due dizionari Python e voglio scrivere una singola espressione che restituisca questi due dizionari, uniti. Il metodo update() sarebbe quello che mi serve, se restituisse il risultato invece di modificare un dict sul posto.

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = x.update(y)
>>> print(z)
None
>>> x
{'a': 1, 'b': 10, 'c': 11}

Come posso ottenere quel dettato finale in z , non x ?

(Per essere più chiaro, l'ultimo-vittorie di gestione dei conflitti di dict.update() è quello che sto cercando anche io.)


Come posso unire due dizionari Python in una singola espressione?

Per i dizionari x e y , z diventa un dizionario unito con valori di y sostituiscono quelli di x .

  • In Python 3.5 o versioni successive,:

    z = {**x, **y}
    w = {'foo': 'bar', 'baz': 'qux', **y}  # merge a dict with literal values
    
  • In Python 2, (o 3.4 o inferiore) scrivi una funzione:

    def merge_two_dicts(x, y):
        z = x.copy()   # start with x's keys and values
        z.update(y)    # modifies z with y's keys and values & returns None
        return z
    

    e

    z = merge_two_dicts(x, y)
    

Spiegazione

Supponi di avere due dicts e vuoi unirli in un nuovo dict senza alterare i dict originali:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

Il risultato desiderato è ottenere un nuovo dizionario ( z ) con i valori uniti e i valori del secondo dict che sovrascrivono quelli del primo.

>>> z
{'a': 1, 'b': 3, 'c': 4}

Una nuova sintassi per questo, proposta in PEP 448 e disponibile a partire da Python 3.5 , è

z = {**x, **y}

Ed è davvero una singola espressione. Ora viene mostrato come implementato nella pianificazione dei rilasci per 3.5, PEP 478 , e ora è entrato nel documento What's New in Python 3.5 .

Tuttavia, dal momento che molte organizzazioni sono ancora in Python 2, potresti desiderare di farlo in un modo compatibile con le versioni precedenti. Il modo classico Pythonic, disponibile in Python 2 e Python 3.0-3.4, è quello di fare questo come un processo in due fasi:

z = x.copy()
z.update(y) # which returns None since it mutates z

In entrambi gli approcci, y arriverà al secondo posto e i suoi valori sostituiranno i valori di x , quindi 'b' punterà a 3 nel nostro risultato finale.

Non ancora su Python 3.5, ma voglio una singola espressione

Se non si è ancora in Python 3.5, o si ha bisogno di scrivere codice compatibile con le versioni precedenti, e si desidera che ciò avvenga in una singola espressione , il più performante mentre l'approccio corretto è quello di metterlo in una funzione:

def merge_two_dicts(x, y):
    """Given two dicts, merge them into a new dict as a shallow copy."""
    z = x.copy()
    z.update(y)
    return z

e quindi hai una singola espressione:

z = merge_two_dicts(x, y)

Puoi anche creare una funzione per unire un numero indefinito di dict, da zero a un numero molto grande:

def merge_dicts(*dict_args):
    """
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result

Questa funzione funzionerà in Python 2 e 3 per tutti i dict. ad es. dati dict a a g :

z = merge_dicts(a, b, c, d, e, f, g) 

e le coppie di valori chiave in g avranno la precedenza sui dt a f , e così via.

Critiche di altre risposte

Non utilizzare ciò che vedi nella risposta precedentemente accettata:

z = dict(x.items() + y.items())

In Python 2, crei due elenchi in memoria per ogni dict, crea un terzo elenco in memoria con lunghezza uguale alla lunghezza dei primi due messi insieme, quindi scarta tutti e tre gli elenchi per creare il dict. In Python 3, questo fallirà perché stai aggiungendo due oggetti dict_items insieme, non due liste -

>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'

e dovresti esplicitamente crearli come elenchi, ad esempio z = dict(list(x.items()) + list(y.items())) . Questo è uno spreco di risorse e potere di calcolo.

Allo stesso modo, l'unione di items() in Python 3 ( viewitems() in Python 2.7) avrà esito negativo anche quando i valori sono oggetti non selezionabili (come gli elenchi, ad esempio). Anche se i tuoi valori sono lavabili, poiché gli insiemi sono semanticamente non ordinati, il comportamento non è definito rispetto alla precedenza. Quindi non farlo:

>>> c = dict(a.items() | b.items())

Questo esempio dimostra cosa succede quando i valori sono inattivi:

>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Ecco un esempio in cui y dovrebbe avere la precedenza, ma invece il valore di x viene mantenuto a causa dell'ordine arbitrario di insiemi:

>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}

Un altro trucco che non dovresti usare:

z = dict(x, **y)

Questo usa il costruttore di dict , ed è molto veloce ed efficiente in termini di memoria (anche leggermente più del nostro processo in due fasi) ma a meno che tu non sappia esattamente cosa sta succedendo qui (cioè, il secondo dict viene passato come argomento della parola chiave al costruttore di dict), è difficile da leggere, non è l'uso previsto e quindi non è Pythonic.

Ecco un esempio dell'uso che viene risolto in django .

Dicts è destinato a prendere chiavi hash (ad esempio frozensets o tuple), ma questo metodo fallisce in Python 3 quando le chiavi non sono stringhe.

>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

Dalla mailing list , Guido van Rossum, il creatore della lingua, ha scritto:

Sto bene dichiarando il ditt ({}, ** {1: 3}) illegale, dato che dopotutto è un abuso del ** meccanismo.

e

Apparentemente dict (x, ** y) va in giro come "cool hack" per "call x.update (y) e return x". Personalmente lo trovo più spregevole che bello.

È mia comprensione (così come la comprensione del creatore della lingua ) che l'uso previsto per dict(**y) è per la creazione di dit per scopi di leggibilità, ad esempio:

dict(a=1, b=10, c=11)

invece di

{'a': 1, 'b': 10, 'c': 11}

Risposta ai commenti

Nonostante ciò che dice Guido, il dict(x, **y) è in linea con la specifica dict, che btw. funziona sia per Python 2 che per 3. Il fatto che funzioni solo per le chiavi stringa è una diretta conseguenza del modo in cui i parametri delle parole chiave funzionano e non di uno short-comming di dict. Né sta usando l'operatore ** in questo luogo un abuso del meccanismo, in realtà ** è stato progettato proprio per passare dicts come parole chiave.

Di nuovo, non funziona per 3 quando le chiavi sono non-stringhe. Il contratto di chiamata implicita è che gli spazi dei nomi assumono le ordinarie dict, mentre gli utenti devono solo passare gli argomenti delle parole chiave che sono stringhe. Tutti gli altri callables lo hanno imposto. dict rotto questa coerenza in Python 2:

>>> foo(**{('a', 'b'): None})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{('a', 'b'): None})
{('a', 'b'): None}

Questa incoerenza è stata negativa date le altre implementazioni di Python (Pypy, Jython, IronPython). Quindi è stato corretto in Python 3, poiché questo utilizzo potrebbe essere un cambiamento sostanziale.

Vi presento che è un'incompetenza maliziosa scrivere intenzionalmente un codice che funziona solo in una versione di una lingua o che funziona solo con determinati vincoli arbitrari.

Un altro commento:

dict(x.items() + y.items()) è ancora la soluzione più leggibile per Python 2. La leggibilità conta.

La mia risposta: merge_two_dicts(x, y) realtà mi sembra molto più chiara, se siamo davvero preoccupati della leggibilità. E non è compatibile con le versioni precedenti, poiché Python 2 è sempre più deprecato.

Ad-hoc meno performanti ma corretti

Questi approcci sono meno performanti, ma forniranno un comportamento corretto. Saranno molto meno performanti della copy e update o del nuovo spacchettamento perché iterano su ciascuna coppia chiave-valore a un livello più alto di astrazione, ma rispettano l'ordine di precedenza (questi ultimi hanno la precedenza)

Puoi anche collegare manualmente i dadi all'interno di una comprensione del ditt:

{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7

o in Python 2.6 (e forse già 2.4 quando sono state introdotte le espressioni del generatore):

dict((k, v) for d in dicts for k, v in d.items())

itertools.chain concatena gli iteratori sulle coppie chiave-valore nell'ordine corretto:

import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))

Analisi di performance

Farò solo l'analisi delle prestazioni degli usi noti per comportarsi correttamente.

import timeit

Quanto segue è fatto su Ubuntu 14.04

In Python 2.7 (sistema Python):

>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934

In Python 3.5 (deadsnakes PPA):

>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287

Risorse sui dizionari


Aggiornamento ricorsivo / approfondito di un dett

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

Dimostrazione:

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

Uscite:

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

Grazie rednaw per le modifiche.


Anche se le risposte erano buone per questo dizionario superficiale , nessuno dei metodi qui definiti fa effettivamente un profondo dizionario.

Gli esempi seguono:

a = { 'one': { 'depth_2': True }, 'two': True }
b = { 'one': { 'extra': False } }
print dict(a.items() + b.items())

Ci si aspetterebbe un risultato di qualcosa del genere:

{ 'one': { 'extra': False', 'depth_2': True }, 'two': True }

Invece, otteniamo questo:

{'two': True, 'one': {'extra': False}}

La voce "uno" avrebbe dovuto avere "profondità_2" e "extra" come elementi all'interno del suo dizionario se fosse veramente un'unione.

Anche l'uso della catena non funziona:

from itertools import chain
print dict(chain(a.iteritems(), b.iteritems()))

Risultati in:

{'two': True, 'one': {'extra': False}}

La fusione profonda che rcwesick ha dato crea anche lo stesso risultato.

Sì, funzionerà per unire i dizionari di esempio, ma nessuno di questi è un meccanismo generico da unire. Lo aggiornerò più tardi una volta che scriverò un metodo che fa una vera unione.


Disegnando idee qui e altrove ho compreso una funzione:

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

Utilizzo (testato in python 3):

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

Potresti usare invece una lambda.


In Python 3, puoi utilizzare collections.ChainMap che raggruppa più dicts o altri mapping per creare un'unica vista aggiornabile:

>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = ChainMap({}, y, x)
>>> for k, v in z.items():
        print(k, '-->', v)

a --> 1
b --> 10
c --> 11


In una risposta di follow-up, hai chiesto informazioni sul rendimento relativo di queste due alternative:

z1 = dict(x.items() + y.items())
z2 = dict(x, **y)

Sulla mia macchina, almeno (un abbastanza comune x86_64 con Python 2.5.2), z2 alternativo non è solo più breve e semplice ma anche significativamente più veloce. Puoi verificarlo da solo usando il modulo timeit fornito con Python.

Esempio 1: dizionari identici che associano 20 interi consecutivi a se stessi:

% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'
100000 loops, best of 3: 5.67 usec per loop
% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' 
100000 loops, best of 3: 1.53 usec per loop

z2 vince per un fattore di 3,5 circa. Dizionari diversi sembrano dare risultati molto diversi, ma z2 sembra sempre venire avanti. (Se ottieni risultati incoerenti per lo stesso test, prova a passare in -r con un numero maggiore del valore predefinito 3.)

Esempio 2: dizionari non sovrapposti che associano 252 stringhe brevi a numeri interi e viceversa:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'
1000 loops, best of 3: 260 usec per loop
% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)'               
10000 loops, best of 3: 26.9 usec per loop

z2 vince di circa un fattore di 10. Questa è una vittoria piuttosto grande nel mio libro!

Dopo aver confrontato questi due, mi sono chiesto se la scarsa performance di z1 potesse essere attribuita al sovraccarico di costruzione delle due liste di articoli, il che a sua volta mi ha portato a chiedermi se questa variazione potesse funzionare meglio:

from itertools import chain
z3 = dict(chain(x.iteritems(), y.iteritems()))

Alcuni test rapidi, ad es

% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'
10000 loops, best of 3: 66 usec per loop

portami a concludere che z3 è un po 'più veloce di z1 , ma non così veloce come z2 . Sicuramente non vale la pena di digitare

In questa discussione manca ancora qualcosa di importante, che è un confronto tra prestazioni di queste alternative con il modo "ovvio" di unire due liste: usando il metodo di update . Per cercare di mantenere le cose su un piano di parità con le espressioni, nessuna delle quali modifica x o y, ho intenzione di fare una copia di x invece di modificarla sul posto, come segue:

z0 = dict(x)
z0.update(y)

Un risultato tipico:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'
10000 loops, best of 3: 26.9 usec per loop

In altre parole, z0 e z2 sembrano avere prestazioni essenzialmente identiche. Pensi che questa potrebbe essere una coincidenza? Io non....

In effetti, direi che è impossibile per il puro codice Python fare meglio di così. E se si può fare molto meglio in un modulo di estensione C, immagino che la gente di Python potrebbe essere interessata a incorporare il proprio codice (o una variante del proprio approccio) nel core di Python. Python usa dict in molti posti; ottimizzare le sue operazioni è un grosso problema.

Potresti anche scrivere questo come

z0 = x.copy()
z0.update(y)

come fa Tony, ma (non sorprendentemente) la differenza nella notazione risulta non avere alcun effetto misurabile sulle prestazioni. Usa quello che ti sembra giusto. Certo, ha assolutamente ragione di sottolineare che la versione a due estratti è molto più facile da capire.


La versione migliore che potrei pensare senza usare la copia sarebbe:

from itertools import chain
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
dict(chain(x.iteritems(), y.iteritems()))

È più veloce di dict(x.items() + y.items()) ma non veloce come n = copy(a); n.update(b) n = copy(a); n.update(b) , almeno su CPython. Questa versione funziona anche in Python 3 se si cambia iteritems() in items() , operazione che viene eseguita automaticamente dallo strumento 2to3.

Personalmente mi piace di più questa versione perché descrive abbastanza bene ciò che voglio in una singola sintassi funzionale. L'unico problema minore è che non rende del tutto ovvio che i valori di y hanno la precedenza sui valori di x, ma non credo che sia difficile capirlo.


Per Python 2:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items()+y.items())
print(z)

Per Python 3:

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items()|y.items())
print(z)

Fornisce l'output: {'a': 1, 'c': 11, 'b': 10}


Probabilmente questa non sarà una risposta popolare, ma quasi certamente non vuoi farlo. Se si desidera una copia che è un'unione, quindi utilizzare copia (o deepcopy , a seconda di ciò che si desidera) e quindi aggiornare. Le due righe di codice sono molto più leggibili - più Pythonic - rispetto alla creazione di una singola riga con .items () + .items (). L'esplicito è meglio che implicito.

Inoltre, quando usi .items () (pre Python 3.0), stai creando un nuovo elenco che contiene gli elementi del dict. Se i tuoi dizionari sono grandi, allora è un bel po 'di overhead (due grandi liste che verranno buttate via non appena viene creata la dict unita). update () può funzionare in modo più efficiente, perché può essere eseguito attraverso la seconda voce articolo per articolo.

In termini di time :

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

IMO il piccolo rallentamento tra i primi due ne vale la pena per la leggibilità. Inoltre, gli argomenti delle parole chiave per la creazione del dizionario sono stati aggiunti solo in Python 2.3, mentre copy () e update () funzionano nelle versioni precedenti.


Se pensate che i lambda siano malvagi, non leggere oltre. Come richiesto, è possibile scrivere la soluzione rapida ed efficiente in termini di memoria con un'espressione:

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

Come suggerito sopra, usare due linee o scrivere una funzione è probabilmente un modo migliore per andare.


Sebbene la domanda abbia già ricevuto risposta diverse volte, questa semplice soluzione al problema non è stata ancora elencata.

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

È veloce come z0 e il male z2 di cui sopra, ma è facile da capire e cambiare.


Soluzione semplice con itertools che conserva l'ordine (questi ultimi hanno la precedenza)

import itertools as it
merge = lambda *args: dict(it.chain.from_iterable(it.imap(dict.iteritems, args)))

Ed è l'uso:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> merge(x, y)
{'a': 1, 'b': 10, 'c': 11}

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 4}

Un'alternativa:

z = x.copy()
z.update(y)

Volevo qualcosa di simile, ma con la possibilità di specificare come sono stati uniti i valori delle chiavi duplicate, quindi l'ho violato (ma non l'ho testato pesantemente). Ovviamente questa non è una singola espressione, ma è una chiamata a funzione singola.

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

(Solo per Python2.7 *: esistono soluzioni più semplici per Python3 *.)

Se non sei contrario all'importazione di un modulo di libreria standard, puoi farlo

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

(Il or abit nel lambdaè necessario perché dict.updateritorna sempre Nonein caso di successo.)


Questo può essere fatto con una sola comprensione del ditt:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> { key: y[key] if key in y else x[key]
      for key in set(x) + set(y)
    }

Dal mio punto di vista la migliore risposta per la parte 'single expression' in quanto non sono necessarie funzioni extra, ed è breve.


In Python 3.5 puoi usare decomprimi **per creare un nuovo dizionario. Questo metodo non è stato mostrato nelle risposte precedenti. Inoltre, è meglio usare al {}posto di dict(). Perché {}è un vero pitone e dict()implica una chiamata di funzione.

dict1 = {'a':1}
dict2 = {'b':2}
new_dict = {**dict1, **dict2}
>>>new_dict
{'a':1, 'a':2}

def dict_merge(a, b):
  c = a.copy()
  c.update(b)
  return c

new = dict_merge(old, extras)

Tra queste risposte oscure e discutibili, questo brillante esempio è l'unico ottimo modo per unire i dittici in Python, approvato dal dittatore per la vita Guido van Rossum stesso! Qualcun altro ha suggerito la metà di questo, ma non l'ha messo in una funzione.

print dict_merge(
      {'color':'red', 'model':'Mini'},
      {'model':'Ferrari', 'owner':'Carl'})

dà:

{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}

from collections import Counter
dict1 = {'a':1, 'b': 2}
dict2 = {'b':10, 'c': 11}
result = dict(Counter(dict1) + Counter(dict2))

Questo dovrebbe risolvere il tuo problema.







merge