Categorías
Python

OOP Método Tipo en Python: @classmethod vs @staticmethod vs Métodos de instancia

 

Tabla de Contenidos

  • la definición de un diccionario
  • Acceso diccionario
  • Valores

  • Claves de diccionario vs. lista Índices
  • la construcción de un diccionario Restricciones incremental
  • en Claves de diccionario Restricciones
  • sobre los valores diccionario
  • Operadores

  • y
  • funciones incorporadas

  • diccionario incorporado Methodsd.clear () d.get ( [, ]) d.Items () d.keys () d.values ​​() d.pop ( [, ]) d.popitem () d.update (obj>)
  • d.clear ()
  • d.get ( [, ]) d.Items
  • ()
  • d. (teclas) d.values ​​
  • ()
  • d.pop ( [, ])
  • d.popitem ()
  • d.update ()
  • Conclusión
  • d.clear ()
  • d.get ([, ] )
  • d.Items () d.keys
  • () d.values ​​
  • ()
  • d.pop ( [, ])
  • d.popitem ()
  • d.update ()

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Diccionarios en Python

Python proporciona otro tipo de datos compuesto llama un diccionario , que es similar a una lista en la que se trata de una colección de objetos.

Esto es lo que aprenderá en este tutorial: usted cubrirá las características básicas de los diccionarios de Python y aprender a acceder y gestionar los datos de diccionario. Una vez que haya terminado este tutorial, usted debe tener una buena idea de cuándo un diccionario es el tipo de datos apropiado utilizar, y cómo hacerlo.

Diccionarios y listas comparten las siguientes características:

  • Ambos son mutables.
  • Ambos son dinámicos. Pueden crecer y reducir el tamaño según sea necesario.
  • Ambos se pueden anidar. Una lista puede contener otra lista. Un diccionario puede contener otro diccionario. Un diccionario también puede contener una lista, y viceversa.

Diccionarios difieren de las listas principalmente en cómo se accede a los elementos: elementos

    Lista

  • se accede por su posición en la lista, a través de la indexación.
  • diccionario

  • elementos se accede a través de las teclas.

Tome el Cuestionario: Prueba sus conocimientos con nuestro cuestionario interactivo “Python Diccionarios”. Al finalizar, recibirá una puntuación para que pueda controlar su progreso en el aprendizaje a través del tiempo:

Contesta la trivia »

la definición de un diccionario

Diccionarios son la implementación de una estructura de datos que está más generalmente conocida como una matriz asociativa de Python. Un diccionario consiste en una colección de pares de clave y valor. Cada par clave-valor se asigna la clave de su valor asociado.

Se puede definir un diccionario encerrando una lista separada por comas de pares de valores clave entre llaves ({}). Los dos puntos (:) separa cada tecla de su valor asociado:

d = {
: ,
: ,
.
.
.
:
}

A continuación se definen un diccionario que mapea una ubicación para el nombre de su correspondiente equipo de las Grandes Ligas:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }

También puede construir un diccionario con el incorporado en función dict (). El argumento para dict () debe ser una secuencia de pares de clave y valor. Una lista de tuplas funciona bien para esto:

d = dict([
(, ),
(, , )
])

MLB_team puede entonces también ser definida de esta manera:

>>> MLB_team = dict([
... ('Colorado', 'Rockies'),
... ('Boston', 'Red Sox'),
... ('Minnesota', 'Twins'),
... ('Milwaukee', 'Brewers'),
... ('Seattle', 'Mariners')
... ])

Si los valores de las claves son cadenas simples, que pueden ser especificados como argumentos de palabra clave. Así que aquí es otra manera de definir MLB_team:

>>> MLB_team = dict(
... Colorado='Rockies',
... Boston='Red Sox',
... Minnesota='Twins',
... Milwaukee='Brewers',
... Seattle='Mariners'
... )

Una vez que haya definido un diccionario, puede mostrar su contenido, lo mismo que usted puede hacer para obtener una lista. Los tres de las definiciones mostradas anteriormente aparecen como sigue cuando se muestra:

>>> type(MLB_team)

>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Las entradas en la pantalla diccionario en el orden en que fueron definidos. Pero eso es irrelevante cuando se trata de recuperarlos. elementos de los diccionarios no son accesibles por índice numérico:

>>> MLB_team[1]
Traceback (most recent call last):
File "", line 1, in
MLB_team[1]
KeyError: 1

Diccionario Acceso a valores

Por supuesto, los elementos de diccionario deben ser accesibles de alguna manera. Si no los consigue mediante un índice, entonces ¿cómo se consigue?

Un valor se recupera de un diccionario especificando su tecla correspondiente entre corchetes ([]):

>>> MLB_team['Minnesota']
'Twins'
>>> MLB_team['Colorado']
'Rockies'

Si se refiere a una llave que no está en el diccionario, Python lanza una excepción:

>>> MLB_team['Toronto']
Traceback (most recent call last):
File "", line 1, in
MLB_team['Toronto']
KeyError: 'Toronto'

Adición de una entrada a un diccionario existente es simplemente una cuestión de la asignación de una nueva clave y el valor:

>>> MLB_team['Kansas City'] = 'Royals'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners', 'Kansas City': 'Royals'}

Si desea actualizar una entrada, sólo se puede asignar un nuevo valor a una clave existente:

>>> MLB_team['Seattle'] = 'Seahawks'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Seahawks', 'Kansas City': 'Royals'}

para borrar una entrada, utilice la instrucción del , especificando la tecla para borrar:

>>> del MLB_team['Seattle']
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Kansas City': 'Royals'}

Vete, Seahawks! Eres un equipo de la NFL.

Claves de diccionario vs. lista Índices

Usted puede haber notado que el intérprete plantea la misma excepción, KeyError, cuando se accede a un diccionario, ya sea con una clave indefinido o por un índice numérico:

>>> MLB_team['Toronto']
Traceback (most recent call last):
File "", line 1, in
MLB_team['Toronto']
KeyError: 'Toronto'

>>> MLB_team[1]
Traceback (most recent call last):
File "", line 1, in
MLB_team[1]
KeyError: 1

De hecho, es la misma error. En este último caso, [1] se parece a un índice numérico, pero no lo es.

Usted verá más adelante en este tutorial que un objeto de cualquier tipo inmutable puede ser utilizado como una clave de diccionario. Por consiguiente, no hay ninguna razón por la que no puede utilizar números enteros:

>>> d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
>>> d
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

>>> d[0]
'a'
>>> d[2]
'c'

en las expresiones MLB_team [1], D [0] y D [2], los números entre corchetes aparecen como si ellos podrían ser los índices. Pero ellos no tienen nada que ver con el orden de los elementos en el diccionario. Python que está interpretando como claves de diccionario. Si define este mismo diccionario en orden inverso, sigue recibiendo los mismos valores utilizando las mismas claves:

>>> d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
>>> d
{3: 'd', 2: 'c', 1: 'b', 0: 'a'}

>>> d[0]
'a'
>>> d[2]
'c'

La sintaxis puede ser similar, pero no se puede tratar a un diccionario como una lista:

>>> type(d)

>>> d[-1]
Traceback (most recent call last):
File "", line 1, in
d[-1]
KeyError: -1

>>> d[0:2]
Traceback (most recent call last):
File "", line 1, in
d[0:2]
TypeError: unhashable type: 'slice'

>>> d.append('e')
Traceback (most recent call last):
File "", line 1, in
d.append('e')
AttributeError: 'dict' object has no attribute 'append'

Nota: Aunque el acceso a los artículos en un diccionario no depende de la orden, Python hace garantía de que el orden de los elementos en un diccionario se conserva. Cuando se muestra, los elementos aparecerán en el orden en que fueron definidos, y la iteración a través de las teclas ocurrirán en ese orden también. Los productos añadidos a un diccionario se añaden al final. Si se eliminan los elementos, el orden de los elementos restantes se conserva.

Sólo se puede contar con esta conservación del orden hace muy poco tiempo. Se añade como parte de la especificación del lenguaje Python en versión 3.7. Sin embargo, era cierto partir de la versión 3.6, así, por casualidad, como resultado de la aplicación, pero no garantizada por la especificación del lenguaje.

La construcción de un diccionario de forma incremental

la definición de un diccionario que se utilizan llaves y una lista de pares de valores clave, como se muestra arriba, está bien si usted sabe todas las claves y valores de antelación. Pero lo que si usted quiere construir un diccionario sobre la marcha?

Puede empezar por crear un diccionario vacío, que se especifica mediante llaves vacías. A continuación, puede añadir nuevas claves y valores de uno a la vez:

>>> person = {}
>>> type(person)

>>> person['fname'] = 'Joe'
>>> person['lname'] = 'Fonebone'
>>> person['age'] = 51
>>> person['spouse'] = 'Edna'
>>> person['children'] = ['Ralph', 'Betty', 'Joey']
>>> person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}

Una vez creado el diccionario de esta manera, sus valores se accede a la misma forma que cualquier otro diccionario:

>>> person
{'fname': 'Joe', 'lname': 'Fonebone', 'age': 51, 'spouse': 'Edna',
'children': ['Ralph', 'Betty', 'Joey'], 'pets': {'dog': 'Fido', 'cat': 'Sox'}}

>>> person['fname']
'Joe'
>>> person['age']
51
>>> person['children']
['Ralph', 'Betty', 'Joey']

recuperación de los valores en la lista secundaria o subdictionary requiere una índice adicional o clave:

>>> person['children'][-1]
'Joey'
>>> person['pets']['cat']
'Sox'

en este ejemplo se exhibe otra de las características de los diccionarios: los valores contenidos en el diccionario no tienen que ser del mismo tipo. En persona, algunos de los valores son cadenas, uno es un número entero, se trata de una lista, y uno es otro diccionario.

Del mismo modo que los valores de un diccionario no tienen que ser del mismo tipo, las teclas no sea:

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

>>> foo[42]
'aaa'
>>> foo[2.78]
'bbb'
>>> foo[True]
'ccc'

Aquí, una de las claves es un entero, es un flotador, y uno es un booleano . No es obvio cómo esto sería útil, pero nunca se sabe.

Aviso lo versátil diccionarios de Python son. En MLB_team, la misma pieza de información (el nombre del equipo de béisbol) se mantiene para cada una de varias localizaciones geográficas diferentes. persona, por el contrario, las tiendas de diversos tipos de datos para una sola persona.

Puede usar los diccionarios para una amplia gama de propósitos porque hay tan pocas limitaciones en las claves y valores que se permiten. Pero hay algo más. Leyendo! Restricciones

en Diccionario Claves

Casi cualquier tipo de valor se pueden utilizar como una clave de diccionario en Python. Que acaba de ver este ejemplo, donde entero, flotante, y los objetos booleanos se utilizan como claves:

>>> foo = {42: 'aaa', 2.78: 'bbb', True: 'ccc'}
>>> foo
{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

Usted puede incluso utilizar los objetos incorporados como tipos y funciones:

>>> d = {int: 1, float: 2, bool: 3}
>>> d
{: 1, : 2, : 3}
>>> d[float]
2

>>> d = {bin: 1, hex: 2, oct: 3}
>>> d[oct]
3

Sin embargo, hay un par de restricciones que las claves de diccionario deben cumplir por.

En primer lugar, una clave determinada puede aparecer en un diccionario sólo una vez. llave duplicada no son permitidos. Un diccionario mapea cada clave a un valor correspondiente, por lo que no tiene sentido para asignar una clave particular más de una vez.

que viste anteriormente que cuando se asigna un valor a una clave de diccionario ya existente, no se le añade la tecla una segunda vez, pero reemplaza el valor existente:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }

>>> MLB_team['Minnesota'] = 'Timberwolves'
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Timberwolves',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Del mismo modo, si se especifica una clave por segunda vez durante la primera creación de un diccionario, la segunda aparición anulará la primera:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Timberwolves',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners',
... 'Minnesota': 'Twins'
... }
>>> MLB_team
{'Colorado': 'Rockies', 'Boston': 'Red Sox', 'Minnesota': 'Twins',
'Milwaukee': 'Brewers', 'Seattle': 'Mariners'}

Vete, Timberwolves! Eres un equipo de NBA. Algo así como.

En segundo lugar, una clave de diccionario debe ser de un tipo que es inmutable. Ya ha visto ejemplos en los que varios de los tipos inmutables que están familiarizados-entero, flotante, cadena, y Boole-ha servido como claves de diccionario.

Una tupla también puede ser una clave de diccionario, porque tuplas son inmutables:.

>>> d = {(1, 1): 'a', (1, 2): 'b', (2, 1): 'c', (2, 2): 'd'}
>>> d[(1,1)]
'a'
>>> d[(2,1)]
'c'

(Recordemos de la discusión sobre las tuplas que una justificación del uso de una tupla en lugar de una lista es que hay circunstancias en las que se requiere un tipo inmutable Este es uno de ellos)

Sin embargo, ni una lista ni otro diccionario puede servir como clave de diccionario, porque las listas y diccionarios son mutables:.

>>> d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
Traceback (most recent call last):
File "", line 1, in
d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
TypeError: unhashable type: 'list'

técnicos Nota: ¿Por qué el mensaje de error digamos “unhashable”?

Técnicamente, no es del todo correcto decir que un objeto debe ser inmutable para ser utilizado como una clave de diccionario. Más precisamente, un objeto debe ser hashable, lo que significa que se puede pasar a una función hash. Una función hash toma los datos de tamaño arbitrario y lo asigna a un valor de tamaño fijo relativamente simple llamado un valor hash (o simplemente hash), que se utiliza para búsqueda en la tabla y la comparación. La función del

Python integrado de hash () devuelve el valor hash para un objeto que es hashable, y plantea una excepción para un objeto que no es:

>>> hash('foo')
11132615637596761

>>> hash([1, 2, 3])
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'

Todos los tipos inmutables incorporados que ha aprendido sobre lo que va son hashable, y los tipos de contenedores mutable (listas y diccionarios) no lo son. Así que para los propósitos presentes, se puede pensar en hashable e inmutable como más o menos sinónimos. futuros tutoriales

En, se encontrará con objetos mutables que son también hashable. Restricciones

en diccionario Valores

Por el contrario, no hay restricciones sobre los valores del diccionario. Literalmente ninguno en absoluto. Un valor diccionario puede ser cualquier tipo de objeto admite Python, incluyendo los tipos mutables como listas y diccionarios, y los objetos definidos por el usuario, que usted aprenderá acerca de los próximos tutoriales.

También hay ninguna restricción en contra de un determinado valor que aparece en un diccionario varias veces:

>>> d = {0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d
{0: 'a', 1: 'a', 2: 'a', 3: 'a'}
>>> d[0] == d[1] == d[2]
True

Operadores y funciones incorporadas

Ya se han familiarizado con muchos de los operadores y funciones integradas que se pueden utilizar con cuerdas , listas y tuplas. Algunos de estos trabajos con los diccionarios también.

Por ejemplo, la entrada y no en los operadores Verdadero o Falso según volver a si la especifica el operando se produce como una llave en el diccionario:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }

>>> 'Milwaukee' in MLB_team
True
>>> 'Toronto' in MLB_team
False
>>> 'Toronto' not in MLB_team
True

Usted puede utilizar el operador in junto con la evaluación de cortocircuito para evitar la formación de un error cuando tratando de acceder a una clave que no está en el diccionario:

>>> MLB_team['Toronto']
Traceback (most recent call last):
File "", line 1, in
MLB_team['Toronto']
KeyError: 'Toronto'

>>> 'Toronto' in MLB_team and MLB_team['Toronto']
False

en el segundo caso, debido a la evaluación de cortocircuito, la expresión MLB_team [ ‘Toronto no se evalúa, por lo que no se produce la excepción KeyError.

El len () devuelve el número de pares de valores clave en un diccionario:

>>> MLB_team = {
... 'Colorado' : 'Rockies',
... 'Boston' : 'Red Sox',
... 'Minnesota': 'Twins',
... 'Milwaukee': 'Brewers',
... 'Seattle' : 'Mariners'
... }
>>> len(MLB_team)
5

diccionario incorporado Métodos

Al igual que con cadenas y listas, hay varios métodos incorporados que pueden ser invocados en los diccionarios. De hecho, en algunos casos, la lista y métodos de diccionario comparten el mismo nombre. (En el examen de la programación orientada a objetos, se verá que es perfectamente aceptable para los diferentes tipos de disponer de métodos con el mismo nombre.)

La siguiente es una descripción general de los métodos que se aplican a los diccionarios:

d.clear ( )

Borra un diccionario.

d.clear () vacía el diccionario d de todos los pares de valores clave:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> d.clear()
>>> d
{}

d.get ( [, ])

Devuelve el valor de una clave si es que existe en el diccionario.

El método de Python diccionario .get () proporciona una manera conveniente de obtener el valor de una clave de un diccionario sin comprobar de antemano si existe la clave, y sin elevar un error.

d.get () busca en el diccionario de d y devuelve el valor asociado, si se comprueba. Si no se encuentra, devuelve None:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> print(d.get('b'))
20
>>> print(d.get('z'))
None

Si no se encuentra y la opcional argumento se especifica, este valor se devuelve en lugar de Ninguno: d.Items

>>> print(d.get('z', -1))
-1

()

Devuelve una lista de pares de valores clave en un diccionario.

d.Items () devuelve una lista de tuplas que contienen los pares de valores clave en d. El primer elemento de cada tupla es la clave, y el segundo elemento es el valor de la clave: d.keys

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.items())
[('a', 10), ('b', 20), ('c', 30)]
>>> list(d.items())[1][0]
'b'
>>> list(d.items())[1][1]
20

()

Devuelve una lista de claves en un diccionario.

d.keys () devuelve una lista de todas las claves en d: d.values ​​

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.keys())
['a', 'b', 'c']

()

Devuelve una lista de valores en un diccionario. d.values ​​

() devuelve una lista de todos los valores d:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d
{'a': 10, 'b': 20, 'c': 30}

>>> list(d.values())
[10, 20, 30]

Cualquier valores duplicados en d se devolverá todas las veces que se producen:

>>> d = {'a': 10, 'b': 10, 'c': 10}
>>> d
{'a': 10, 'b': 10, 'c': 10}

>>> list(d.values())
[10, 10, 10]

técnicos Nota: Los .items (), .keys (), y .values ​​() métodos vuelven en realidad algo que se llama un objeto de vista . Un diccionario objeto vista es más o menos como una ventana a las claves y valores. A efectos prácticos, se puede pensar de estos métodos como devolver una lista de claves y valores del diccionario.

d.pop ( [, ])

elimina una clave de un diccionario, si está presente, y devuelve su valor.

Si está presente en d, d.pop () Elimina y devuelve su valor asociado:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('b')
20
>>> d
{'a': 10, 'c': 30}

d.pop () plantea una excepción KeyError si no es en d:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.pop('z')
Traceback (most recent call last):
File "", line 1, in
d.pop('z')
KeyError: 'z'

Si no está en D, y el opcional se especifica el argumento, a continuación, que se devuelve el valor, y se eleva no es una excepción:

>>> d = {'a': 10, 'b': 20, 'c': 30}
>>> d.pop('z', -1)
-1
>>> d
{'a': 10, 'b': 20, 'c': 30}

d.popitem ()

Elimina una clave par-valor de un diccionario.

d.popitem () elimina a, arbitraria par clave-valor aleatorio de d y la devuelve como una tupla:

>>> d = {'a': 10, 'b': 20, 'c': 30}

>>> d.popitem()
('c', 30)
>>> d
{'a': 10, 'b': 20}

>>> d.popitem()
('b', 20)
>>> d
{'a': 10}

Si d es vacía, d.popitem () plantea una excepción KeyError:

>>> d = {}
>>> d.popitem()
Traceback (most recent call last):
File "", line 1, in
d.popitem()
KeyError: 'popitem(): dictionary is empty'

d.update ( )

Merges un diccionario con otro diccionario o con un iterable de pares de clave y valor.

Si es un diccionario, d.update () combina las entradas de en d. Para cada clave en :

  • Si la llave no está presente en d, el par clave-valor de se añade a d.
  • Si la clave ya está presente en d, el valor correspondiente en d para esa clave se actualiza con el valor de .

He aquí un ejemplo que muestra dos diccionarios se fusionaron:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d2 = {'b': 200, 'd': 400}

>>> d1.update(d2)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

En este ejemplo, la tecla ‘b’ ya existe en d1, por lo que su valor se actualiza a 200, el valor de esa tecla de d2. Sin embargo, no hay ninguna clave ‘d’ en d1, de modo que par clave-valor se añade a partir de d2.

también puede ser una secuencia de pares de valores clave, similar a cuando se utiliza la función dict () para definir un diccionario. Por ejemplo, se puede especificar como una lista de tuplas:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update([('b', 200), ('d', 400)])
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

O los valores de fusionar pueden especificarse como una lista de argumentos de palabra clave:

>>> d1 = {'a': 10, 'b': 20, 'c': 30}
>>> d1.update(b=200, d=400)
>>> d1
{'a': 10, 'b': 200, 'c': 30, 'd': 400}

Conclusión

En este tutorial, todo cubierto las propiedades básicas de la diccionario de Python y aprendió a acceder y manipular los datos diccionario . Listas

y diccionarios son dos de los tipos de Python utilizados con mayor frecuencia. Como han visto, tienen varias similitudes, pero difieren en la forma de acceder a sus elementos. Listas elementos se accede por índice numérico basado en el orden, y diccionario de elementos se accede por clave

Debido a esta diferencia, listas y diccionarios tienden a ser apropiados para diferentes circunstancias. Ahora debe tener una buena idea de lo que, si bien, sería mejor para una situación dada.

A continuación, aprenderá acerca de Python establece . El conjunto es otro tipo de datos compuesto, pero es muy diferente de una lista o diccionario.

Tome el Cuestionario: Prueba sus conocimientos con nuestro cuestionario interactivo “Python Diccionarios”. Al finalizar, recibirá una puntuación para que pueda controlar su progreso en el aprendizaje a través del tiempo:

Contesta la trivia »

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Diccionarios en Python

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *