Operaciones básicas de diccionarios y conjuntos en Python

Primero, el funcionamiento básico del diccionario.

1.1 Diccionario vacío y actualización de diccionario

1.1.1 Agregar entrada 

Definir un diccionario vacío es asignar un par de llaves vacías "{}" a la variable del diccionario.

 Formato de gramática: nombre de diccionario [clave] = valor

>>> dictArea = {}
>>> dictArea
{}
>>> dictArea['中国'] = 1200
>>> dictArea['美国'] = 1100
>>> dictArea['法国'] = 1000
>>> dictArea
{'中国': 1200, '美国': 1100, '法国': 1000}

1.1.2 Modificar una entrada 

Formato de gramática: nombre de diccionario [clave] = valor

>>> dictArea
{'中国': 1200, '美国': 1100, '法国': 1000}
>>> dictArea['法国'] = 900
>>> dictArea
{'中国': 1200, '美国': 1100, '法国': 900}

Se puede ver que modificar una entrada y agregar una entrada son la misma operación, por lo que cuando se usa para modificar una entrada, la clave especificada debe corresponder a una entrada existente, de lo contrario, se está agregando una entrada. También se debe tener en cuenta que la modificación de una entrada esencialmente modifica el valor asociado con la clave, y una clave única no se puede modificar.

1.2 Eliminar entradas del diccionario 

Hay muchas formas de eliminar entradas del diccionario, pero todas usan teclas para especificar las entradas que se eliminarán. 

 1.2.1 Use el comando del para eliminar una entrada específica

 Formato de sintaxis: del nombre del diccionario [clave]

>>> dictArea
{'中国': 1200, '美国': 1100, '法国': 900}
>>> del dictArea['法国']
>>> dictArea
{'中国': 1200, '美国': 1100}

1.2.2 Utilice el método pop() para eliminar la entrada especificada 

 Formato de gramática: nombre del diccionario.pop (clave, valor predeterminado)

>>> dictArea
{'中国': 1200, '美国': 1100}
>>> dictArea.pop('美国')
1100
>>> dictArea
{'中国': 1200}

Nota: Cuando utilice el método pop(), asegúrese de que la clave eliminada exista en el diccionario. Si no está seguro de si existe, debe proporcionar un valor predeterminado; de lo contrario, se informará un error. Además, se debe incluir al menos un parámetro utilizado para especificar la clave. Si los parámetros son todos predeterminados, el sistema informará un error. 

 1.2.3 Eliminar aleatoriamente entradas de diccionario con el método popitem()

Formato de gramática: nombre del diccionario.popitem() 

>>> dictArea
{'中国': 1500, '美国': 1400, '法国': 1300, '日本': 1200, '英国': 1100}
>>> dictArea.popitem()
('英国', 1100)
>>> dictArea
{'中国': 1500, '美国': 1400, '法国': 1300, '日本': 1200}

Las entradas eliminadas se devuelven como una tupla. Después de la versión 3.6, el método popitem() devuelve el último elemento agregado al diccionario de forma predeterminada. 

1.2.4 Entradas de diccionario vacías con el método clear() 

 Formato de gramática: nombre del diccionario.clear()

>>> dictArea
{'中国': 1500, '美国': 1400, '法国': 1300, '日本': 1200}
>>> dictArea.clear()
>>> dictArea
{}

Llamar al método clear() en el diccionario elimina todas las entradas, pero sigue siendo un diccionario vacío. 

1.2.5 Eliminar todo el diccionario directamente 

del nombre del diccionario 

>>> dictArea
{'中国': 1500, '美国': 1400, '法国': 1300, '日本': 1200, '英国': 1100}
>>> del dictArea
>>> dictArea
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dictArea' is not defined

1.3 Encontrar entradas de diccionario 

 1.3.1 Operador de membresía en

Formato de gramática: clave en el diccionario 

>>> dictArea
{'中国': 1500, '美国': 1400, '法国': 1300, '日本': 1200, '英国': 1100}
>>> '中国' in dictArea
True
>>> '俄国' in dictArea
False

1.3.2 Obtener el valor de una entrada con el método get() 

DictionaryName.get(clave, predeterminado) 

>>> dictArea
{'中国': 1500, '美国': 1400, '法国': 1300, '日本': 1200, '英国': 1100}
>>> dictArea.get('中国')
1500
>>> dictArea.get('俄国')
>>> 

1.4 Travesía de diccionarios 

1.4.1 Recorrer todas las claves del diccionario

Los diccionarios tienen un método llamado keys() que devuelve todas las claves del diccionario.

>>> dictAreas
{'中国': 1500, '美国': 1300, '英国': 1200, '法国': 1000}
>>> dictAreas.keys()
dict_keys(['中国', '美国', '英国', '法国'])
>>> for key in dictAreas.keys():
    print(key)

中国
美国
英国
法国
>>> for key in dictAreas.keys():
    print(key,dictAreas[key])

中国 1500
美国 1300
英国 1200
法国 1000

 1.4.2 Recorrer todos los valores del diccionario

El diccionario también proporciona un método de valores () para devolver todos los valores;

>>> dictAreas
{'中国': 1500, '美国': 1300, '英国': 1200, '法国': 1000}
>>> dictAreas.values()
dict_values([1500, 1300, 1200, 1000])
>>> for value in dictAreas.values():
    print(value)

1500
1300
1200
1000

  1.4.3 Recorrer todas las entradas del diccionario 

El método items() del diccionario puede devolver todos los elementos en forma de (clave, valor);

>>> dictAreas
{'中国': 1500, '美国': 1300, '英国': 1200, '法国': 1000}
>>> dictAreas.items()
dict_items([('中国', 1500), ('美国', 1300), ('英国', 1200), ('法国', 1000)])
>>> for item in dictAreas.items():
    print(item)

('中国', 1500)
('美国', 1300)
('英国', 1200)
('法国', 1000)

1.5 Clasificación de diccionarios 

Las entradas en el diccionario no están en orden. Estrictamente hablando, el diccionario no admite la clasificación. Solo podemos mostrar las entradas en el diccionario en el orden que queramos.

Dado que la clasificación del chino implica problemas de codificación, la clave se cambia a inglés.

>>> dictArea
{'China': 1500, 'Russia': 1300, 'Canada': 1200}
>>> sorted(dictArea)
['Canada', 'China', 'Russia']
>>> dictArea
{'China': 1500, 'Russia': 1300, 'Canada': 1200}
>>> ls = sorted(dictArea)
>>> ls
['Canada', 'China', 'Russia']
>>> for country in ls:
    print(country,dictArea[country])

Canada 1200
China 1500
Russia 1300

1.6 Fusión de diccionarios 

1.6.1 Usando el bucle for

>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> for k,v in dictArea2.items():
    dictArea1[k] = v

>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000, '张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}

 1.6.2 Hacer el método update() del diccionario

update() es un método de diccionario, que se utiliza para agregar el diccionario de parámetros al diccionario del método de llamada.

Formato de gramática: nombre del diccionario. actualización (nombre del diccionario del parámetro) 

>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> dictArea1.update(dictArea2)
>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000, '张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}

  1.6.3 Usando la función dict() 

>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> ls = list(dictArea1.items()) + list(dictArea2.items())
>>> ls
[('中国', 1500), ('法国', 1300), ('美国', 1200), ('英国', 1000), ('张三', 1100), ('李四', 1000), ('王五', 900), ('小阿丁', 500)]
>>> dictArea = dict(ls)
>>> dictArea
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000, '张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}

  1.6.4 Otra forma de usar la función dict()  

>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> dictArea1 = dict(dictArea1,**dictArea2)
>>> dictArea1
{'中国': 1500, '法国': 1300, '美国': 1200, '英国': 1000, '张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}
>>> dictArea2
{'张三': 1100, '李四': 1000, '王五': 900, '小阿丁': 500}

Nota: En términos generales, las claves en los dos diccionarios que participan en la fusión son diferentes. Si aparece la misma clave en los dos diccionarios, solo se conservará un conjunto de entradas que contengan la clave modificada después de la fusión.

En segundo lugar, el funcionamiento básico de la colección. 

 2.1 Agregar elementos

 Función o método: s,add(item) o s.update(item)

Diferencia: s.add(item) agrega el parámetro item como un elemento al conjunto s, si item es una secuencia, se agrega al conjunto como un elemento completo. El elemento como parámetro solo puede ser un dato inmutable.

s.update(item) divide y deduplica los elementos en el elemento de secuencia de parámetros y los agrega al conjunto. El elemento del parámetro puede ser datos variables.

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

>>> s = {1,2,3}
>>> s.update([2,3,4])
>>> s
{1, 2, 3, 4}

 2.2 Eliminar elementos 

 Función o método: s.remove(item) o s.discard(item) o s.pop() o s.clear()

>>> s = {1,2,3,4}
>>> s.remove(2)
>>> s
{1, 3, 4}
>>> s.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 5

>>> s = {1,2,3,4}
>>> s.discard(3)
>>> s
{1, 2, 4}
>>> s.discard(5)
>>> 

>>> s = {1,2,3,4}
>>> s.pop()           //随机删除
1

>>> s = {1,2,3,4}
>>> s.clear()
>>> s
set()

  2.3 Juicio de los miembros 

Formato de gramática: elemento en s 

 2.4 Operaciones matemáticas sobre conjuntos  

2.4.1 Unión 

 Operador: A|B  

método: a. unión (B)

>>> A = {1,2,3,4}
>>> B = {3,4,5,6}
>>> A|B
{1, 2, 3, 4, 5, 6}
>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}
>>> A.union(B)
{1, 2, 3, 4, 5, 6}
>>> B
{3, 4, 5, 6}

 2.4.2 Intersección 

Operador: A y B

método: a. intersección (B) 

>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}
>>> A & B
{3, 4}
>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}
>>> A.intersection(B)
{3, 4}

  2.4.3 Conjunto de diferencias 

Operador: A - B

Método: A.diferencia(B)  

>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}
>>> A - B
{1, 2}
>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}

   2.4.4 Hallar diferencias simétricas 

 Operador: A^B

Método: A.diferencia_simétrica(B)

>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}
>>> A.symmetric_difference(B)
{1, 2, 5, 6}
>>> A
{1, 2, 3, 4}
>>> B
{3, 4, 5, 6}