{"id":357,"date":"2024-10-26T18:35:34","date_gmt":"2024-10-26T18:35:34","guid":{"rendered":"https:\/\/equipomedios.com\/blog\/?p=357"},"modified":"2024-10-18T18:38:55","modified_gmt":"2024-10-18T18:38:55","slug":"tipos-de-datos-tipo-diccionarios-python","status":"publish","type":"post","link":"https:\/\/equipomedios.com\/blog\/tipos-de-datos-tipo-diccionarios-python\/","title":{"rendered":"Tipos de Datos | Tipo Diccionarios | Python"},"content":{"rendered":"

Tipo diccionarios<\/h1>\n

El diccionario, define una relaci\u00f3n uno a uno entre claves y valores.<\/p>\n\n\n\n\n\n<\/colgroup>\n\n\n\n
Clase<\/strong><\/td>\nTipo<\/strong><\/td>\nNotas<\/strong><\/td>\nEjemplo<\/strong><\/td>\n<\/tr>\n
dict<\/span><\/code><\/td>\nMapeos<\/td>\nMutable, sin orden.<\/td>\n{'cms':\"Plone\",<\/span>\u00a0'version':5}<\/span><\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Un objeto\u00a0mapping<\/em>\u00a0mapea valores\u00a0hashable<\/em>\u00a0a objetos arbitrariamente. Los objetos Mapeos son objetos mutable. El\u00a0diccionario<\/strong>\u00a0es el \u00fanico tipo de mapeo est\u00e1ndar actual. Para otro contenedores ver los integrados en las clases \u00ablista<\/span>\u00bb, \u00abconjuntos<\/span>\u00bb, y \u00abtupla<\/span>\u00bb, y el modulo \u00abcollections<\/span><\/code>\u00bb.<\/p>\n

Los diccionarios pueden ser creados colocando una lista separada por coma de pares \u00abkey:value\u00bb entre\u00a0{}<\/span><\/code>, por ejemplo: \u00ab{'python':<\/span>\u00a027,<\/span>\u00a0'plone':<\/span>\u00a051}<\/span><\/code>\u00bb o \u00ab{27:'python',<\/span>\u00a051:'plone'}<\/span><\/code>\u00bb, o por el constructor \u00abdict()<\/span>\u00bb.<\/p>\n

\n
\n
>>> <\/span>diccionario<\/span> =<\/span> {<\/span>\r\n... <\/span>    \"clave1\"<\/span>:<\/span>234<\/span>,<\/span>\r\n... <\/span>    \"clave2\"<\/span>:<\/span>True<\/span>,<\/span>\r\n... <\/span>    \"clave3\"<\/span>:<\/span>\"Valor 1\"<\/span>,<\/span>\r\n... <\/span>    \"clave4\"<\/span>:[<\/span>1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>]<\/span>\r\n... <\/span>}<\/span>\r\n>>> <\/span>print<\/span> diccionario<\/span>,<\/span> type<\/span>(<\/span>diccionario<\/span>)<\/span>\r\n{'clave4': [1, 2, 3, 4], 'clave1': 234,<\/span>\r\n'clave3': 'Valor 1', 'clave2': True} <type 'dict'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Usted puede acceder a los valores del diccionario usando cada su clave, se presenta unos ejemplos a continuaci\u00f3n:<\/p>\n
\n
\n
>>> <\/span>diccionario<\/span>[<\/span>'clave1'<\/span>]<\/span>\r\n234<\/span>\r\n>>> <\/span>diccionario<\/span>[<\/span>'clave2'<\/span>]<\/span>\r\nTrue<\/span>\r\n>>> <\/span>diccionario<\/span>[<\/span>'clave3'<\/span>]<\/span>\r\n'Valor 1'<\/span>\r\n>>> <\/span>diccionario<\/span>[<\/span>'clave4'<\/span>]<\/span>\r\n[1, 2, 3, 4]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Un diccionario puede almacenar los diversos tipos de datos integrados en Python usando la funci\u00f3n\u00a0type()<\/span>, usted puede pasar el diccionario con la clave que usted desea determinar el tipo de dato, se presenta unos ejemplos a continuaci\u00f3n:<\/p>\n
\n
\n
>>> <\/span>type<\/span>(<\/span>diccionario<\/span>[<\/span>'clave1'<\/span>])<\/span>\r\n<type 'int'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>diccionario<\/span>[<\/span>'clave2'<\/span>])<\/span>\r\n<type 'bool'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>diccionario<\/span>[<\/span>'clave3'<\/span>])<\/span>\r\n<type 'str'><\/span>\r\n>>> <\/span>type<\/span>(<\/span>diccionario<\/span>[<\/span>'clave4'<\/span>])<\/span>\r\n<type 'list'><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Operaciones<\/h2>\n
Los objetos de tipo\u00a0diccionario<\/strong>\u00a0permite una serie de operaciones usando operadores integrados en el interprete Python para su tratamiento, a continuaci\u00f3n algunos de estos:<\/p>\n
<\/span><\/p>\n
Acceder a valor de clave<\/h3>\n
Esta operaci\u00f3n le permite acceder a un valor especifico del\u00a0diccionario<\/em>\u00a0mediante su clave.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>,<\/span> django<\/span>=<\/span>2.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>[<\/span>'zope'<\/span>]<\/span>\r\n2.13<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Asignar valor a clave<\/h3>\n
Esta operaci\u00f3n le permite asignar el valor especifico del\u00a0diccionario<\/em>\u00a0mediante su clave.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> {<\/span>'python'<\/span>:<\/span> 2.7<\/span>,<\/span> 'zope'<\/span>:<\/span> 2.13<\/span>,<\/span> 'plone'<\/span>:<\/span> None<\/span>}<\/span>\r\n>>> <\/span>versiones<\/span>[<\/span>'plone'<\/span>]<\/span>\r\n>>> <\/span>versiones<\/span>[<\/span>'plone'<\/span>]<\/span> =<\/span> 5.1<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{'python': 2.7, 'zope': 2.13, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>[<\/span>'plone'<\/span>]<\/span>\r\n5.1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Iteraci\u00f3n in<\/h3>\n
Este operador es el mismo operador integrado\u00a0in<\/span>\u00a0en el interprete Python pero aplicada al uso de la secuencia de tipo\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>,<\/span> django<\/span>=<\/span>2.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}<\/span>\r\n>>> <\/span>'plone'<\/span> in<\/span> versiones<\/span>\r\nTrue<\/span>\r\n>>> <\/span>'flask'<\/span> in<\/span> versiones<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el ejemplo anterior este operador devuelve\u00a0True<\/span><\/code>\u00a0si la clave esta en el diccionario\u00a0versiones<\/span><\/code>, de lo contrario devuelve\u00a0False<\/span><\/code>.<\/p>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
M\u00e9todos<\/h2>\n
Los objetos de tipo\u00a0diccionario<\/strong>\u00a0integra una serie de m\u00e9todos integrados a continuaci\u00f3n:<\/p>\n
<\/span><\/p>\n
clear()<\/h3>\n
Este m\u00e9todo remueve todos los elementos desde el\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>clear<\/span>()<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
copy()<\/h3>\n
Este m\u00e9todo devuelve una copia superficial del tipo\u00a0diccionario<\/strong>:<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>otro_versiones<\/span> =<\/span> versiones<\/span>.<\/span>copy<\/span>()<\/span>\r\n>>> <\/span>versiones<\/span> ==<\/span> otro_versiones<\/span>\r\nTrue<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
fromkeys()<\/h3>\n
Este m\u00e9todo crea un nuevo\u00a0diccionario<\/strong>\u00a0con\u00a0claves<\/em>\u00a0a partir de un tipo de dato\u00a0secuencia<\/em>. El valor de\u00a0value<\/span><\/code>\u00a0por defecto es el tipo\u00a0None<\/span>.<\/p>\n
\n
\n
>>> <\/span>secuencia<\/span> =<\/span> (<\/span>'python'<\/span>,<\/span> 'zope'<\/span>,<\/span> 'plone'<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span> =<\/span> dict<\/span>.<\/span>fromkeys<\/span>(<\/span>secuencia<\/span>)<\/span>\r\n>>> <\/span>print<\/span> \"Nuevo Diccionario : <\/span>%s<\/span>\"<\/span> %<\/span>  str<\/span>(<\/span>versiones<\/span>)<\/span>\r\nNuevo Diccionario : {'python': None, 'zope': None, 'plone': None}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el ejemplo anterior inicializa los valores de cada clave a\u00a0None<\/span><\/code>, mas puede inicializar un\u00a0valor<\/em>\u00a0com\u00fan por defecto para cada\u00a0clave<\/em>:<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>.<\/span>fromkeys<\/span>(<\/span>secuencia<\/span>,<\/span> 0.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> \"Nuevo Diccionario : <\/span>%s<\/span>\"<\/span> %<\/span>  str<\/span>(<\/span>versiones<\/span>)<\/span>\r\nNuevo Diccionario : {'python': 0.1, 'zope': 0.1, 'plone': 0.1}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
get()<\/h3>\n
Este m\u00e9todo devuelve el valor en base a una coincidencia de b\u00fasqueda en un diccionario mediante una clave, de lo contrario devuelve el objeto\u00a0None<\/span>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>get<\/span>(<\/span>'plone'<\/span>)<\/span>\r\n5.1<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>get<\/span>(<\/span>'php'<\/span>)<\/span>\r\n>>><\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
has_key()<\/h3>\n
Este m\u00e9todo devuelve el valor\u00a0True<\/span><\/code>\u00a0si el diccionario tiene presente la clave enviada como argumento.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>has_key<\/span>(<\/span>'plone'<\/span>)<\/span>\r\nTrue<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>has_key<\/span>(<\/span>'django'<\/span>)<\/span>\r\nFalse<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
items()<\/h3>\n
Este m\u00e9todo devuelve una lista de pares de diccionarios (clave, valor), como 2 tuplas.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>items<\/span>()<\/span>\r\n[('zope', 2.13), ('python', 2.7), ('plone', 5.1)]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
iteritems()<\/h3>\n
Este m\u00e9todo devuelve un\u00a0iterador<\/span>\u00a0sobre los elementos (clave, valor) del diccionario. Lanza una excepci\u00f3n\u00a0StopIteration<\/span>\u00a0si llega al final de la posici\u00f3n del\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>iteritems<\/span>()<\/span>\r\n<dictionary-itemiterator object at 0x7fab9dd4bc58><\/span>\r\n>>> <\/span>for<\/span> clave<\/span>,<\/span>valor<\/span> in<\/span> versiones<\/span>.<\/span>iteritems<\/span>():<\/span>\r\n... <\/span>    print<\/span> clave<\/span>,<\/span>valor<\/span>\r\n...<\/span>\r\nzope 2.13<\/span>\r\npython 2.7<\/span>\r\nplone 5.1<\/span>\r\n>>> <\/span>versionesIterador<\/span> =<\/span> versiones<\/span>.<\/span>iteritems<\/span>()<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\n('zope', 2.13)<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\n('python', 2.7)<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\n('plone', 5.1)<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nStopIteration<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
iterkeys()<\/h3>\n
Este m\u00e9todo devuelve un\u00a0iterador<\/span>\u00a0sobre las claves del diccionario. Lanza una excepci\u00f3n\u00a0StopIteration<\/span>\u00a0si llega al final de la posici\u00f3n del\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>iterkeys<\/span>()<\/span>\r\n<dictionary-keyiterator object at 0x7fab9dd4bcb0><\/span>\r\n>>> <\/span>for<\/span> clave<\/span> in<\/span> versiones<\/span>.<\/span>iterkeys<\/span>():<\/span>\r\n... <\/span>    print<\/span> clave<\/span>\r\n...<\/span>\r\nzope<\/span>\r\npython<\/span>\r\nplone<\/span>\r\n>>> <\/span>versionesIterador<\/span> =<\/span> versiones<\/span>.<\/span>iterkeys<\/span>()<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\nzope<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\npython<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\nplone<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nStopIteration<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
itervalues()<\/h3>\n
Este m\u00e9todo devuelve un\u00a0iterador<\/span>\u00a0sobre los valores del diccionario. Lanza una excepci\u00f3n\u00a0StopIterati<\/span><\/a>o<\/span>n<\/span><\/a>\u00a0si llega al final de la posici\u00f3n del\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>itervalues<\/span>()<\/span>\r\n<dictionary-valueiterator object at 0x7fab9dd4bc58><\/span>\r\n>>> <\/span>for<\/span> valor<\/span> in<\/span> versiones<\/span>.<\/span>itervalues<\/span>():<\/span>\r\n... <\/span>    print<\/span> valor<\/span>\r\n...<\/span>\r\n2.13<\/span>\r\n2.7<\/span>\r\n5.1<\/span>\r\n>>> <\/span>versionesIterador<\/span> =<\/span> versiones<\/span>.<\/span>itervalues<\/span>()<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\n2.13<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\n2.7<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\n5.1<\/span>\r\n>>> <\/span>print<\/span> versionesIterador<\/span>.<\/span>next<\/span>()<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nStopIteration<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
keys()<\/h3>\n
Este m\u00e9todo devuelve una lista de las claves del diccionario:<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>keys<\/span>()<\/span>\r\n['zope', 'python', 'plone']<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
pop()<\/h3>\n
Este m\u00e9todo remueve espec\u00edficamente una clave de\u00a0diccionario<\/strong>\u00a0y devuelve valor correspondiente. Lanza una excepci\u00f3n\u00a0KeyError<\/span>\u00a0si la\u00a0clave<\/strong>\u00a0no es encontrada.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>pop<\/span>(<\/span>'zope'<\/span>)<\/span>\r\n2.13<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>pop<\/span>(<\/span>'django'<\/span>)<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nKeyError<\/span>: 'django'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
popitem()<\/h3>\n
Este m\u00e9todo remueve y devuelve alg\u00fan par (clave, valor) del\u00a0diccionario<\/strong>\u00a0como una 2 tuplas. Lanza una excepci\u00f3n\u00a0KeyError<\/span>\u00a0si el\u00a0diccionario<\/strong>\u00a0esta vaci\u00f3.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>popitem<\/span>()<\/span>\r\n('zope', 2.13)<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>popitem<\/span>()<\/span>\r\n('python', 2.7)<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{'plone': 5.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>popitem<\/span>()<\/span>\r\n('plone', 5.1)<\/span>\r\n>>> <\/span>versiones<\/span>\r\n{}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>popitem<\/span>()<\/span>\r\nTraceback (most recent call last):<\/span>\r\n  File \"<stdin>\"<\/span>, line 1<\/span>, in <module><\/span>\r\nKeyError<\/span>: 'popitem(): dictionary is empty'<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
setdefault()<\/h3>\n
Este m\u00e9todo es similar a\u00a0get(key, default_value)<\/span>, pero adem\u00e1s asigna la clave\u00a0key<\/span><\/code>\u00a0al valor por\u00a0default_value<\/span><\/code>\u00a0para la clave si esta no se encuentra en el\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
D<\/span>.<\/span>setdefault<\/span>(<\/span>key<\/span>[,<\/span>default_value<\/span>])<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
A continuaci\u00f3n un ejemplo de como trabaja el m\u00e9todo\u00a0setdefault()<\/span><\/code>\u00a0cuando la clave esta en el diccionario:<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>zope<\/span> =<\/span> versiones<\/span>.<\/span>setdefault<\/span>(<\/span>'zope'<\/span>)<\/span>\r\n>>> <\/span>print<\/span> 'Versiones instaladas:'<\/span>,<\/span> versiones<\/span>\r\nVersiones instaladas: {'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>print<\/span> 'Versi\u00f3n de Zope:'<\/span>,<\/span> zope<\/span>\r\nVersi\u00f3n de Zope: 2.13<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
A continuaci\u00f3n un ejemplo de como trabaja el m\u00e9todo\u00a0setdefault()<\/span><\/code>\u00a0la clave no esta en el diccionario:<\/p>\n
\n
\n
>>> <\/span>paquetes<\/span> =<\/span> {<\/span>'python'<\/span>:<\/span> 2.7<\/span>,<\/span> 'zope'<\/span>:<\/span> 2.13<\/span>}<\/span>\r\n>>> <\/span>print<\/span> paquetes<\/span>\r\n{'python': 2.7, 'zope': 2.13}<\/span>\r\n>>> <\/span>plone<\/span> =<\/span> paquetes<\/span>.<\/span>setdefault<\/span>(<\/span>'plone'<\/span>)<\/span>\r\n>>> <\/span>print<\/span> 'paquetes: '<\/span>,<\/span> paquetes<\/span>\r\npaquetes:  {'python': 2.7, 'zope': 2.13, 'plone': None}<\/span>\r\n>>> <\/span>print<\/span> 'plone: '<\/span>,<\/span> plone<\/span>\r\nplone:  None<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Si el valor no es prove\u00eddo, el valor\u00a0default_value<\/span><\/code>\u00a0ser\u00e1 el tipo objeto integrado\u00a0None<\/span>.<\/p>\n
A continuaci\u00f3n un ejemplo de como trabaja el m\u00e9todo\u00a0setdefault()<\/span><\/code>\u00a0la clave no esta en el diccionario pero esta vez el\u00a0default_value<\/span><\/code>\u00a0es prove\u00eddo:<\/p>\n
\n
\n
>>> <\/span>pkgs<\/span> =<\/span> {<\/span>'python'<\/span>:<\/span> 2.7<\/span>,<\/span> 'zope'<\/span>:<\/span> 2.13<\/span>,<\/span> 'plone'<\/span>:<\/span> None<\/span>}<\/span>\r\n>>> <\/span>print<\/span> pkgs<\/span>\r\n{'python': 2.7, 'zope': 2.13, 'plone': None}<\/span>\r\n>>> <\/span>django<\/span> =<\/span> paquetes<\/span>.<\/span>setdefault<\/span>(<\/span>'django'<\/span>,<\/span> 2.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> 'paquetes ='<\/span>,<\/span> pkgs<\/span>\r\npaquetes = {'python': 2.7, 'zope': 2.13, 'plone': None}<\/span>\r\n>>> <\/span>print<\/span> 'django ='<\/span>,<\/span> django<\/span>\r\ndjango = 2.1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
A continuaci\u00f3n otro ejemplo en donde puedes agrupar N\u00a0tuplas<\/span>\u00a0por el valor el cual se repite m\u00e1s y construir un diccionario que cuyas claves son los valores mas repetidos y cuyos valores este agrupados en tipo\u00a0listas<\/span>:<\/p>\n
\n
\n
>>> <\/span>PKGS<\/span> =<\/span> ((<\/span>'zope'<\/span>,<\/span> 'Zope2'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'zope'<\/span>,<\/span> 'pytz'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'plone'<\/span>,<\/span> 'Plone'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'plone'<\/span>,<\/span> 'diazo'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'plone'<\/span>,<\/span> 'z3c.form'<\/span>),)<\/span>\r\n>>><\/span>\r\n>>> <\/span>paquetes<\/span> =<\/span> {}<\/span>\r\n>>> <\/span>for<\/span> clave<\/span>,<\/span> valor<\/span> in<\/span> PKGS<\/span>:<\/span>\r\n... <\/span>    if<\/span> paquetes<\/span>.<\/span>has_key<\/span>(<\/span>clave<\/span>):<\/span>\r\n... <\/span>        paquetes<\/span>[<\/span>clave<\/span>]<\/span>.<\/span>append<\/span>(<\/span>valor<\/span>)<\/span>\r\n... <\/span>    else<\/span>:<\/span>\r\n... <\/span>        paquetes<\/span>[<\/span>clave<\/span>]<\/span> =<\/span> [<\/span>valor<\/span>]<\/span>\r\n...<\/span>\r\n>>> <\/span>print<\/span> paquetes<\/span>\r\n{'zope': ['Zope2', 'pytz'], 'plone': ['Plone', 'diazo', 'z3c.form']}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el tipo tupla\u00a0PKGS<\/span><\/code>\u00a0los elementos mas repetidos son\u00a0'zope'<\/span><\/code>\u00a0y\u00a0'plone'<\/span><\/code>\u00a0estos se convierten en clave del diccionario\u00a0paquetes<\/span><\/code>\u00a0y los otros elementos se agrepan en listas como sus respectivos valores.<\/p>\n
A continuaci\u00f3n un mejor aprovechamiento implementando el m\u00e9todo\u00a0setdefault()<\/span><\/code>:<\/p>\n
\n
\n
>>> <\/span>PKGS<\/span> =<\/span> ((<\/span>'zope'<\/span>,<\/span> 'Zope2'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'zope'<\/span>,<\/span> 'pytz'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'plone'<\/span>,<\/span> 'Plone'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'plone'<\/span>,<\/span> 'diazo'<\/span>),<\/span>\r\n... <\/span>       (<\/span>'plone'<\/span>,<\/span> 'z3c.form'<\/span>),)<\/span>\r\n>>> <\/span>paquetes<\/span> =<\/span> {}<\/span>\r\n>>> <\/span>for<\/span> clave<\/span>,<\/span> valor<\/span> in<\/span> PKGS<\/span>:<\/span>\r\n... <\/span>    paquetes<\/span>.<\/span>setdefault<\/span>(<\/span>clave<\/span>,<\/span> [])<\/span>.<\/span>append<\/span>(<\/span>valor<\/span>)<\/span>\r\n...<\/span>\r\n>>> <\/span>print<\/span> paquetes<\/span>\r\n{'zope': ['Zope2', 'pytz'], 'plone': ['Plone', 'diazo', 'z3c.form']}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el ejemplo anterior puede ver que el aprovechamiento del m\u00e9todo\u00a0setdefault()<\/span><\/code>\u00a0a comparaci\u00f3n de no usar el respectivo m\u00e9todo.<\/p>\n<\/div>\n
<\/span><\/p>\n
update()<\/h3>\n
Este m\u00e9todo actualiza un\u00a0diccionario<\/strong>\u00a0agregando los pares clave-valores en un segundo diccionario. Este m\u00e9todo no devuelve nada.<\/p>\n
El m\u00e9todo\u00a0update()<\/span><\/code>\u00a0toma un diccionario o un objeto iterable de pares clave\/valor (generalmente tuplas). Si se llama a\u00a0update()<\/span><\/code>\u00a0sin pasar par\u00e1metros, el diccionario permanece sin cambios.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n>>> <\/span>versiones_adicional<\/span> =<\/span> dict<\/span>(<\/span>django<\/span>=<\/span>2.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones_adicional<\/span>\r\n{'django': 2.1}<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>update<\/span>(<\/span>versiones_adicional<\/span>)<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Como puede apreciar este m\u00e9todo no devuelve nada, m\u00e1s si muestra de nuevo el diccionario\u00a0versiones<\/span><\/code>\u00a0puede ver que este fue actualizado con el otro diccionario\u00a0versiones_adicional<\/span><\/code>.<\/p>\n
\n
\n
>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
values()<\/h3>\n
Este m\u00e9todo devuelve una lista de los valores del diccionario:<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>values<\/span>()<\/span>\r\n[2.13, 2.7, 5.1]<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
viewitems()<\/h3>\n
Este m\u00e9todo devuelve un objeto como un conjunto mutable proveyendo una vista en los elementos del diccionario:<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>viewkeys<\/span>()<\/span>\r\ndict_keys(['zope', 'python', 'plone'])<\/span>\r\n>>> <\/span>for<\/span> clave<\/span>,<\/span>valor<\/span> in<\/span> versiones<\/span>.<\/span>iteritems<\/span>():<\/span>\r\n... <\/span>    print<\/span> clave<\/span>,<\/span>valor<\/span>\r\n...<\/span>\r\nzope 2.13<\/span>\r\npython 2.7<\/span>\r\nplone 5.1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
viewkeys()<\/h3>\n
Este m\u00e9todo devuelve un objeto proveyendo una vista de las claves del\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>viewkeys<\/span>()<\/span>\r\ndict_keys(['zope', 'python', 'plone'])<\/span>\r\n>>> <\/span>for<\/span> clave<\/span> in<\/span> versiones<\/span>.<\/span>viewkeys<\/span>():<\/span>\r\n... <\/span>    print<\/span> clave<\/span>\r\n...<\/span>\r\nzope<\/span>\r\npython<\/span>\r\nplone<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
viewvalues()<\/h3>\n
Este m\u00e9todo devuelve un objeto proveyendo una vista de los valores del\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones<\/span>.<\/span>viewvalues<\/span>()<\/span>\r\ndict_values([2.13, 2.7, 5.1])<\/span>\r\n>>> <\/span>for<\/span> valor<\/span> in<\/span> versiones<\/span>.<\/span>viewvalues<\/span>():<\/span>\r\n... <\/span>    print<\/span> valor<\/span>\r\n...<\/span>\r\n2.13<\/span>\r\n2.7<\/span>\r\n5.1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Funciones<\/h2>\n
Los objetos de tipo\u00a0diccionario<\/strong>\u00a0tienen disponibles una serie de\u00a0funciones<\/em>\u00a0integradas en el interprete Python para su tratamiento, a continuaci\u00f3n algunas de estas:<\/p>\n
<\/span><\/p>\n
cmp()<\/h3>\n
Esta funci\u00f3n es la misma funci\u00f3n integrada\u00a0cmp()<\/span>\u00a0en el interprete Python pero aplicada al uso de la secuencia de tipo\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones_proyecto1<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>versiones_proyecto2<\/span> =<\/span> dict<\/span>(<\/span>django<\/span>=<\/span>2.1<\/span>,<\/span> django<\/span>-<\/span>filter<\/span>=<\/span>1.1<\/span>.<\/span>0<\/span>)<\/span>\r\n>>> <\/span>print<\/span> cmp<\/span>(<\/span>versiones_proyecto1<\/span>,<\/span> versiones_proyecto2<\/span>)<\/span>\r\n1<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
La funci\u00f3n\u00a0cmp()<\/span><\/code>\u00a0es usado en Python para comparar valores y claves de dos diccionarios. Si la funci\u00f3n devuelve el valor\u00a00<\/span><\/code>\u00a0si ambos diccionarios son igual, devuelve el valor\u00a01<\/span><\/code>\u00a0si el primer diccionario es mayor que el segundo diccionario y devuelve el valor\u00a0-1<\/span><\/code>\u00a0si el primer diccionario es menor que el segundo diccionario.<\/p>\n<\/div>\n
<\/span><\/p>\n
len()<\/h3>\n
Esta funci\u00f3n es la misma funci\u00f3n integrada\u00a0len()<\/span>\u00a0en el interprete Python pero aplicada al uso de la secuencia de tipo\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>)<\/span>\r\n>>> <\/span>len<\/span>(<\/span>versiones<\/span>)<\/span>\r\n3<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
Sentencias<\/h2>\n
Los objetos de tipo\u00a0diccionario<\/strong>\u00a0tienen disponibles una serie de\u00a0sentencias<\/em>\u00a0integradas en el interprete Python para su tratamiento, a continuaci\u00f3n algunas de estas:<\/p>\n
<\/span><\/p>\n
del<\/h3>\n
Esta sentencia es la misma sentencia integrada\u00a0del<\/span><\/a>\u00a0en el interprete Python pero aplicada al uso de la secuencia de tipo\u00a0diccionario<\/strong>.<\/p>\n
\n
\n
>>> <\/span>versiones<\/span> =<\/span> dict<\/span>(<\/span>python<\/span>=<\/span>2.7<\/span>,<\/span> zope<\/span>=<\/span>2.13<\/span>,<\/span> plone<\/span>=<\/span>5.1<\/span>,<\/span> django<\/span>=<\/span>2.1<\/span>)<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}<\/span>\r\n>>> <\/span>del<\/span> versiones<\/span>[<\/span>'django'<\/span>]<\/span>\r\n>>> <\/span>print<\/span> versiones<\/span>\r\n{'zope': 2.13, 'python': 2.7, 'plone': 5.1}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
En el c\u00f3digo fuente anterior se usa la sentencia\u00a0del<\/span><\/code>\u00a0para eliminar un elemento del diccionario mediante su respectiva clave.<\/p>\n<\/div>\n<\/div>\n
\n
Convertir a diccionarios<\/h2>\n
Para convertir a\u00a0tipos diccionarios<\/em>\u00a0debe usar la funci\u00f3n\u00a0dict()<\/span>\u00a0la cual\u00a0esta integrada<\/span>\u00a0en el interprete Python.<\/p>\n
\n
Truco<\/p>\n
Para m\u00e1s informaci\u00f3n consulte las funciones integradas para\u00a0operaciones de secuencias<\/span>.<\/p>\n<\/div>\n<\/div>\n
<\/span><\/p>\n
26Ejemplos<\/h2>\n
A continuaci\u00f3n, se presentan un ejemplo de su uso:<\/p>\n
Ejemplo de definir un diccionario<\/strong><\/p>\n
\n
\n
datos_basicos<\/span> =<\/span> {<\/span>\r\n    \"nombres\"<\/span>:<\/span>\"Leonardo Jose\"<\/span>,<\/span>\r\n    \"apellidos\"<\/span>:<\/span>\"Caballero Garcia\"<\/span>,<\/span>\r\n    \"cedula\"<\/span>:<\/span>\"26938401\"<\/span>,<\/span>\r\n    \"fecha_nacimiento\"<\/span>:<\/span>\"03\/12\/1980\"<\/span>,<\/span>\r\n    \"lugar_nacimiento\"<\/span>:<\/span>\"Maracaibo, Zulia, Venezuela\"<\/span>,<\/span>\r\n    \"nacionalidad\"<\/span>:<\/span>\"Venezolana\"<\/span>,<\/span>\r\n    \"estado_civil\"<\/span>:<\/span>\"Soltero\"<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Ejemplo de operaciones con tipo diccionario con funciones propias<\/strong><\/p>\n
\n
\n
print<\/span> (<\/span>\"<\/span>\\n<\/span>Claves de diccionario:\"<\/span>,<\/span> datos_basicos<\/span>.<\/span>keys<\/span>())<\/span>\r\nprint<\/span> (<\/span>\"<\/span>\\n<\/span>Valores de diccionario:\"<\/span>,<\/span> datos_basicos<\/span>.<\/span>values<\/span>())<\/span>\r\nprint<\/span> (<\/span>\"<\/span>\\n<\/span>Elementos de diccionario:\"<\/span>,<\/span> datos_basicos<\/span>.<\/span>items<\/span>())<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Ejemplo de iteraci\u00f3n avanzada sobre diccionarios con funci\u00f3n iteritems<\/strong><\/p>\n
\n
\n
for<\/span> key<\/span>,<\/span> value<\/span> in<\/span> iter<\/span>(<\/span>datos_basicos<\/span>.<\/span>items<\/span>()):<\/span>\r\n    print<\/span>(<\/span>'Clave: <\/span>%s<\/span>, tiene el valor: <\/span>%s<\/span>'<\/span> %<\/span> (<\/span>key<\/span>,<\/span> value<\/span>))<\/span>\r\n<\/pre>\n<\/div>\n<\/div>\n
Ejemplo real de usar tipo diccionario<\/strong><\/p>\n
\n
\n
print<\/span> (<\/span>\"<\/span>\\n\\n<\/span>Inscripci\u00f3n de Curso\"<\/span>)<\/span>\r\nprint<\/span> (<\/span>\"====================\"<\/span>)<\/span>\r\n\r\nprint<\/span> (<\/span>\"<\/span>\\n<\/span>Datos de participante\"<\/span>)<\/span>\r\nprint<\/span> (<\/span>\"---------------------\"<\/span>)<\/span>\r\n\r\nprint<\/span> (<\/span>\"C\u00e9dula de identidad: \"<\/span>,<\/span> datos_basicos<\/span>[<\/span>'cedula'<\/span>])<\/span>\r\nprint<\/span> (<\/span>\"Nombre completo: \"<\/span> +<\/span> datos_basicos<\/span>[<\/span>'nombres'<\/span>]<\/span> +<\/span> \" \"<\/span> +<\/span> \\\r\ndatos_basicos<\/span>[<\/span>'apellidos'<\/span>])<\/span>\r\nimport<\/span> datetime<\/span>,<\/span> locale<\/span>,<\/span> os<\/span>\r\nlocale<\/span>.<\/span>setlocale<\/span>(<\/span>locale<\/span>.<\/span>LC_ALL<\/span>,<\/span> os<\/span>.<\/span>environ<\/span>[<\/span>'LANG'<\/span>])<\/span>\r\nprint<\/span> (<\/span>\"Fecha y lugar de nacimiento:\"<\/span>,<\/span> datetime<\/span>.<\/span>datetime<\/span>.<\/span>strftime<\/span>(<\/span>\r\n    datetime<\/span>.<\/span>datetime<\/span>.<\/span>strptime<\/span>(<\/span>\r\n        datos_basicos<\/span>[<\/span>'fecha_nacimiento'<\/span>],<\/span> '<\/span>%d<\/span>\/%m\/%Y'<\/span>\r\n    ),<\/span> \"<\/span>%d<\/span> de %B de %Y\"<\/span>\r\n)<\/span> +<\/span> \" en \"<\/span> +<\/span> datos_basicos<\/span>[<\/span>'lugar_nacimiento'<\/span>]<\/span> +<\/span> \".\"<\/span>)<\/span>\r\nprint<\/span> (<\/span>\"Nacionalidad:\"<\/span>,<\/span> datos_basicos<\/span>[<\/span>'nacionalidad'<\/span>])<\/span>\r\nprint<\/span> (<\/span>\"Estado civil:\"<\/span>,<\/span> datos_basicos<\/span>[<\/span>'estado_civil'<\/span>])<\/span><\/pre>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
Tipo diccionarios El diccionario, define una relaci\u00f3n uno a uno entre claves y valores. Clase Tipo Notas Ejemplo dict Mapeos Mutable, sin orden. {‘cms’:\u00bbPlone\u00bb,\u00a0‘version’:5} Un objeto\u00a0mapping\u00a0mapea valores\u00a0hashable\u00a0a objetos arbitrariamente. Los objetos Mapeos son objetos mutable. El\u00a0diccionario\u00a0es el \u00fanico tipo de mapeo est\u00e1ndar actual. Para otro contenedores ver los integrados en las clases \u00ablista\u00bb, \u00abconjuntos\u00bb, y […]<\/p>\n","protected":false},"author":1,"featured_media":331,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[39,40],"tags":[],"class_list":["post-357","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programacion","category-python"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/equipomedios.com\/blog\/wp-content\/uploads\/2024\/08\/python-logo-master-v3-TM.png?fit=601%2C203&ssl=1","jetpack_sharing_enabled":true,"jetpack-related-posts":[],"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/357","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/comments?post=357"}],"version-history":[{"count":1,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/357\/revisions"}],"predecessor-version":[{"id":358,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/posts\/357\/revisions\/358"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media\/331"}],"wp:attachment":[{"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/media?parent=357"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/categories?post=357"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/equipomedios.com\/blog\/wp-json\/wp\/v2\/tags?post=357"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}