Bloques de código y estructuras de control | Condificional IF | Python

Condicional if

La sentencia condicional if se usa para tomar decisiones, este evaluá básicamente una operación lógica, es decir una expresión que de como resultado True o False, y ejecuta la pieza de código siguiente siempre y cuando el resultado sea verdadero.

A continuación un de estructura condicional if/elif/else completo:

numero = int(input("\nIngresa un número entero, por favor: "))

if numero < 0:
    numero = 0
    print ('El número ingresado es negativo cambiado a cero.\n')
elif numero == 0:
    print ('El número ingresado es 0.\n')
elif numero == 1:
    print ('El número ingresado es 1.\n')
else:
    print ('El número ingresado es mayor que uno.\n')

En el ejemplo anterior usa dos funciones integradas en el interprete Python:

  • La función int() que convierte el valor ingresado a número entero.
  • La función raw_input() lee el valor ingresado por la entrada estándar.

El valor es ingresado en la variable numero comprobará en el sentencia condicional if, si la comprobación devuelve False intentará con el siguiente bloque condicional elif, si la comprobación devuelve False nuevamente intentará con el siguiente bloque condicional elif si de nuevo la comprobación devuelve False por ultimo intentará con el siguiente bloque condicional else la cual se ejecutara sin comprobación.

Sentencia if

La sentencia if EXPRESION, significa, Si se cumple la expresión condicional se ejecuta el bloque de sentencias seguidas.

Sentencia elif

La sentencia elif EXPRESION, significa, De lo contrario Si se cumple la expresión condicional se ejecuta el bloque de sentencias seguidas.

Sentencia else

La sentencia else, significa, De lo contrario se cumple sin evaluar ninguna expresión condicional y ejecuta el bloque de sentencias seguidas.

Operador is

El operador is, significa, que prueba identidad: ambos lados de la expresión condicional debe ser el mismo objecto:

>>> 1 is 1.
False
>>> a, b = 1, 1
>>> a is b
True

Operador in

El operador in, significa, para cualquier colección del valor del lado izquierdo contenga el valor del lado derecho:

>>> b = [1, 2, 3]
>>> 2 in b
True
>>> 5 in b
False

En el ejemplo anterior, si b es una lista, este prueba que 2 y 5 sean elementos de la lista b.

Operador not in

El operador not in, el contrario de operador in, devuelve True cuando un elemento no está en una secuencia.

>>> b = [1, 2, 3]
>>> 4 not in b
True
>>> 1 not in b
False

En el ejemplo anterior, si b es una lista, este prueba que 4 y 1 sean elementos de la lista b.

Expresiones condicional

Estos son los distintos tipos de expresiones condicionales:

Expresión if

La expresión de la sentencia if se evaluá a False cuando se cumple las siguientes expresiones están presente:

  • Cualquier numero igual a cero (0, 0.0, 0+0j).
  • Un contenedor vació (listatuplaconjuntodiccionario).
  • FalseNone.

De lo contrario evaluá a True cuando se cumple la siguiente expresión esta presente:

  • cualquier cosa de lo contrario.
if EXPRESION:
    pass

Expresión ==

Esta expresión usa el operador == para validar la misma.

Expresión is

Esta expresión usa el operador is para validar la misma.

Expresión in

Esta expresión usa el operador in para validar la misma.

Ejemplos

A continuación, se presenta un ejemplo del uso de condicionales if:

Definir variables usadas en los siguientes ejemplos:

dato1, dato2, dato3, dato4 = 21, 10, 5, 20;

Ejemplo de operador de comparación Igual:

if (dato1 == dato2):
    print ("'dato1' y 'dato2' son iguales.")
else:
    print ("'dato1' y 'dato2' no son iguales.")

Ejemplo de operador de comparación Distinto:

if (dato1 != dato2):
    print ("'dato1' y 'dato2' son distintas/diferentes.")
else:
    print ("'dato1' y 'dato2' no son distintas/diferentes.")

Ejemplo de operador de comparación Diferente:

if (dato1 != dato2):
    print ("'dato1' y 'dato2' son distintas/diferentes.")
else:
    print ("'dato1' y 'dato2' no son distintas/diferentes.")

Ejemplo de operador de comparación Menor que:

if (dato1 < dato2):
    print ("'dato1' es menor que 'dato2'.")
else:
    print ("'dato1' no es menor que 'dato2'.")

Ejemplo de operador de comparación Mayor que:

if (dato1 > dato2):
    print ("'dato1' es mayor que 'dato2'.")
else:
    print ("'dato1' no es mayor que 'dato2'.")

Ejemplo de operador de comparación Menor o igual que:

if (dato3 <= dato4):
    print ("'dato3' es menor o igual que 'dato4'.")
else:
    print ("'dato3' no es menor o igual que 'dato4'.")

Ejemplo de operador de comparación Mayor o igual que:

if (dato4 >= dato3):
    print ("'dato4' es mayor o igual que 'dato3'.")
else:
    print ("'dato4' no es mayor o igual que 'dato3'.")

Tipos de Datos | Tipo Diccionarios | Python

Tipo diccionarios

El diccionario, define una relación uno a uno entre claves y valores.

Clase Tipo Notas Ejemplo
dict Mapeos Mutable, sin orden. {'cms':"Plone", 'version':5}

Un objeto mapping mapea valores hashable a objetos arbitrariamente. Los objetos Mapeos son objetos mutable. El diccionario es el único tipo de mapeo estándar actual. Para otro contenedores ver los integrados en las clases «lista», «conjuntos», y «tupla», y el modulo «collections».

Los diccionarios pueden ser creados colocando una lista separada por coma de pares «key:value» entre {}, por ejemplo: «{'python': 27, 'plone': 51}» o «{27:'python', 51:'plone'}», o por el constructor «dict()».

>>> diccionario = {
...     "clave1":234,
...     "clave2":True,
...     "clave3":"Valor 1",
...     "clave4":[1,2,3,4]
... }
>>> print diccionario, type(diccionario)
{'clave4': [1, 2, 3, 4], 'clave1': 234,
'clave3': 'Valor 1', 'clave2': True} <type 'dict'>

Usted puede acceder a los valores del diccionario usando cada su clave, se presenta unos ejemplos a continuación:

>>> diccionario['clave1']
234
>>> diccionario['clave2']
True
>>> diccionario['clave3']
'Valor 1'
>>> diccionario['clave4']
[1, 2, 3, 4]

Un diccionario puede almacenar los diversos tipos de datos integrados en Python usando la función type(), usted puede pasar el diccionario con la clave que usted desea determinar el tipo de dato, se presenta unos ejemplos a continuación:

>>> type(diccionario['clave1'])
<type 'int'>
>>> type(diccionario['clave2'])
<type 'bool'>
>>> type(diccionario['clave3'])
<type 'str'>
>>> type(diccionario['clave4'])
<type 'list'>

Operaciones

Los objetos de tipo diccionario permite una serie de operaciones usando operadores integrados en el interprete Python para su tratamiento, a continuación algunos de estos:

Acceder a valor de clave

Esta operación le permite acceder a un valor especifico del diccionario mediante su clave.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1, django=2.1)
>>> versiones['zope']
2.13

Asignar valor a clave

Esta operación le permite asignar el valor especifico del diccionario mediante su clave.

>>> versiones = {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> versiones['plone']
>>> versiones['plone'] = 5.1
>>> versiones
{'python': 2.7, 'zope': 2.13, 'plone': 5.1}
>>> versiones['plone']
5.1

Iteración in

Este operador es el mismo operador integrado in en el interprete Python pero aplicada al uso de la secuencia de tipo diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1, django=2.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}
>>> 'plone' in versiones
True
>>> 'flask' in versiones
False

En el ejemplo anterior este operador devuelve True si la clave esta en el diccionario versiones, de lo contrario devuelve False.

Métodos

Los objetos de tipo diccionario integra una serie de métodos integrados a continuación:

clear()

Este método remueve todos los elementos desde el diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.clear()
>>> print versiones
{}

copy()

Este método devuelve una copia superficial del tipo diccionario:

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> otro_versiones = versiones.copy()
>>> versiones == otro_versiones
True

fromkeys()

Este método crea un nuevo diccionario con claves a partir de un tipo de dato secuencia. El valor de value por defecto es el tipo None.

>>> secuencia = ('python', 'zope', 'plone')
>>> versiones = dict.fromkeys(secuencia)
>>> print "Nuevo Diccionario : %s" %  str(versiones)
Nuevo Diccionario : {'python': None, 'zope': None, 'plone': None}

En el ejemplo anterior inicializa los valores de cada clave a None, mas puede inicializar un valor común por defecto para cada clave:

>>> versiones = dict.fromkeys(secuencia, 0.1)
>>> print "Nuevo Diccionario : %s" %  str(versiones)
Nuevo Diccionario : {'python': 0.1, 'zope': 0.1, 'plone': 0.1}

get()

Este método devuelve el valor en base a una coincidencia de búsqueda en un diccionario mediante una clave, de lo contrario devuelve el objeto None.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.get('plone')
5.1
>>> versiones.get('php')
>>>

has_key()

Este método devuelve el valor True si el diccionario tiene presente la clave enviada como argumento.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.has_key('plone')
True
>>> versiones.has_key('django')
False

items()

Este método devuelve una lista de pares de diccionarios (clave, valor), como 2 tuplas.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.items()
[('zope', 2.13), ('python', 2.7), ('plone', 5.1)]

iteritems()

Este método devuelve un iterador sobre los elementos (clave, valor) del diccionario. Lanza una excepción StopIteration si llega al final de la posición del diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.iteritems()
<dictionary-itemiterator object at 0x7fab9dd4bc58>
>>> for clave,valor in versiones.iteritems():
...     print clave,valor
...
zope 2.13
python 2.7
plone 5.1
>>> versionesIterador = versiones.iteritems()
>>> print versionesIterador.next()
('zope', 2.13)
>>> print versionesIterador.next()
('python', 2.7)
>>> print versionesIterador.next()
('plone', 5.1)
>>> print versionesIterador.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

iterkeys()

Este método devuelve un iterador sobre las claves del diccionario. Lanza una excepción StopIteration si llega al final de la posición del diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.iterkeys()
<dictionary-keyiterator object at 0x7fab9dd4bcb0>
>>> for clave in versiones.iterkeys():
...     print clave
...
zope
python
plone
>>> versionesIterador = versiones.iterkeys()
>>> print versionesIterador.next()
zope
>>> print versionesIterador.next()
python
>>> print versionesIterador.next()
plone
>>> print versionesIterador.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

itervalues()

Este método devuelve un iterador sobre los valores del diccionario. Lanza una excepción StopIteration si llega al final de la posición del diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.itervalues()
<dictionary-valueiterator object at 0x7fab9dd4bc58>
>>> for valor in versiones.itervalues():
...     print valor
...
2.13
2.7
5.1
>>> versionesIterador = versiones.itervalues()
>>> print versionesIterador.next()
2.13
>>> print versionesIterador.next()
2.7
>>> print versionesIterador.next()
5.1
>>> print versionesIterador.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

keys()

Este método devuelve una lista de las claves del diccionario:

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.keys()
['zope', 'python', 'plone']

pop()

Este método remueve específicamente una clave de diccionario y devuelve valor correspondiente. Lanza una excepción KeyError si la clave no es encontrada.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.pop('zope')
2.13
>>> versiones
{'python': 2.7, 'plone': 5.1}
>>> versiones.pop('django')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'django'

popitem()

Este método remueve y devuelve algún par (clave, valor) del diccionario como una 2 tuplas. Lanza una excepción KeyError si el diccionario esta vació.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones.popitem()
('zope', 2.13)
>>> versiones
{'python': 2.7, 'plone': 5.1}
>>> versiones.popitem()
('python', 2.7)
>>> versiones
{'plone': 5.1}
>>> versiones.popitem()
('plone', 5.1)
>>> versiones
{}
>>> versiones.popitem()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

setdefault()

Este método es similar a get(key, default_value), pero además asigna la clave key al valor por default_value para la clave si esta no se encuentra en el diccionario.

D.setdefault(key[,default_value])

A continuación un ejemplo de como trabaja el método setdefault() cuando la clave esta en el diccionario:

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> zope = versiones.setdefault('zope')
>>> print 'Versiones instaladas:', versiones
Versiones instaladas: {'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> print 'Versión de Zope:', zope
Versión de Zope: 2.13

A continuación un ejemplo de como trabaja el método setdefault() la clave no esta en el diccionario:

>>> paquetes = {'python': 2.7, 'zope': 2.13}
>>> print paquetes
{'python': 2.7, 'zope': 2.13}
>>> plone = paquetes.setdefault('plone')
>>> print 'paquetes: ', paquetes
paquetes:  {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> print 'plone: ', plone
plone:  None

Si el valor no es proveído, el valor default_value será el tipo objeto integrado None.

A continuación un ejemplo de como trabaja el método setdefault() la clave no esta en el diccionario pero esta vez el default_value es proveído:

>>> pkgs = {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> print pkgs
{'python': 2.7, 'zope': 2.13, 'plone': None}
>>> django = paquetes.setdefault('django', 2.1)
>>> print 'paquetes =', pkgs
paquetes = {'python': 2.7, 'zope': 2.13, 'plone': None}
>>> print 'django =', django
django = 2.1

A continuación otro ejemplo en donde puedes agrupar N tuplas por el valor el cual se repite más y construir un diccionario que cuyas claves son los valores mas repetidos y cuyos valores este agrupados en tipo listas:

>>> PKGS = (('zope', 'Zope2'),
...        ('zope', 'pytz'),
...        ('plone', 'Plone'),
...        ('plone', 'diazo'),
...        ('plone', 'z3c.form'),)
>>>
>>> paquetes = {}
>>> for clave, valor in PKGS:
...     if paquetes.has_key(clave):
...         paquetes[clave].append(valor)
...     else:
...         paquetes[clave] = [valor]
...
>>> print paquetes
{'zope': ['Zope2', 'pytz'], 'plone': ['Plone', 'diazo', 'z3c.form']}

En el tipo tupla PKGS los elementos mas repetidos son 'zope' y 'plone' estos se convierten en clave del diccionario paquetes y los otros elementos se agrepan en listas como sus respectivos valores.

A continuación un mejor aprovechamiento implementando el método setdefault():

>>> PKGS = (('zope', 'Zope2'),
...        ('zope', 'pytz'),
...        ('plone', 'Plone'),
...        ('plone', 'diazo'),
...        ('plone', 'z3c.form'),)
>>> paquetes = {}
>>> for clave, valor in PKGS:
...     paquetes.setdefault(clave, []).append(valor)
...
>>> print paquetes
{'zope': ['Zope2', 'pytz'], 'plone': ['Plone', 'diazo', 'z3c.form']}

En el ejemplo anterior puede ver que el aprovechamiento del método setdefault() a comparación de no usar el respectivo método.

update()

Este método actualiza un diccionario agregando los pares clave-valores en un segundo diccionario. Este método no devuelve nada.

El método update() toma un diccionario o un objeto iterable de pares clave/valor (generalmente tuplas). Si se llama a update() sin pasar parámetros, el diccionario permanece sin cambios.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}
>>> versiones_adicional = dict(django=2.1)
>>> print versiones_adicional
{'django': 2.1}
>>> versiones.update(versiones_adicional)

Como puede apreciar este método no devuelve nada, más si muestra de nuevo el diccionario versiones puede ver que este fue actualizado con el otro diccionario versiones_adicional.

>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}

values()

Este método devuelve una lista de los valores del diccionario:

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.values()
[2.13, 2.7, 5.1]

viewitems()

Este método devuelve un objeto como un conjunto mutable proveyendo una vista en los elementos del diccionario:

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.viewkeys()
dict_keys(['zope', 'python', 'plone'])
>>> for clave,valor in versiones.iteritems():
...     print clave,valor
...
zope 2.13
python 2.7
plone 5.1

viewkeys()

Este método devuelve un objeto proveyendo una vista de las claves del diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.viewkeys()
dict_keys(['zope', 'python', 'plone'])
>>> for clave in versiones.viewkeys():
...     print clave
...
zope
python
plone

viewvalues()

Este método devuelve un objeto proveyendo una vista de los valores del diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones.viewvalues()
dict_values([2.13, 2.7, 5.1])
>>> for valor in versiones.viewvalues():
...     print valor
...
2.13
2.7
5.1

Funciones

Los objetos de tipo diccionario tienen disponibles una serie de funciones integradas en el interprete Python para su tratamiento, a continuación algunas de estas:

cmp()

Esta función es la misma función integrada cmp() en el interprete Python pero aplicada al uso de la secuencia de tipo diccionario.

>>> versiones_proyecto1 = dict(python=2.7, zope=2.13, plone=5.1)
>>> versiones_proyecto2 = dict(django=2.1, django-filter=1.1.0)
>>> print cmp(versiones_proyecto1, versiones_proyecto2)
1

La función cmp() es usado en Python para comparar valores y claves de dos diccionarios. Si la función devuelve el valor 0 si ambos diccionarios son igual, devuelve el valor 1 si el primer diccionario es mayor que el segundo diccionario y devuelve el valor -1 si el primer diccionario es menor que el segundo diccionario.

len()

Esta función es la misma función integrada len() en el interprete Python pero aplicada al uso de la secuencia de tipo diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1)
>>> len(versiones)
3

Sentencias

Los objetos de tipo diccionario tienen disponibles una serie de sentencias integradas en el interprete Python para su tratamiento, a continuación algunas de estas:

del

Esta sentencia es la misma sentencia integrada del en el interprete Python pero aplicada al uso de la secuencia de tipo diccionario.

>>> versiones = dict(python=2.7, zope=2.13, plone=5.1, django=2.1)
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1, 'django': 2.1}
>>> del versiones['django']
>>> print versiones
{'zope': 2.13, 'python': 2.7, 'plone': 5.1}

En el código fuente anterior se usa la sentencia del para eliminar un elemento del diccionario mediante su respectiva clave.

Convertir a diccionarios

Para convertir a tipos diccionarios debe usar la función dict() la cual esta integrada en el interprete Python.

Truco

Para más información consulte las funciones integradas para operaciones de secuencias.

26Ejemplos

A continuación, se presentan un ejemplo de su uso:

Ejemplo de definir un diccionario

datos_basicos = {
    "nombres":"Leonardo Jose",
    "apellidos":"Caballero Garcia",
    "cedula":"26938401",
    "fecha_nacimiento":"03/12/1980",
    "lugar_nacimiento":"Maracaibo, Zulia, Venezuela",
    "nacionalidad":"Venezolana",
    "estado_civil":"Soltero"
}

Ejemplo de operaciones con tipo diccionario con funciones propias

print ("\nClaves de diccionario:", datos_basicos.keys())
print ("\nValores de diccionario:", datos_basicos.values())
print ("\nElementos de diccionario:", datos_basicos.items())

Ejemplo de iteración avanzada sobre diccionarios con función iteritems

for key, value in iter(datos_basicos.items()):
    print('Clave: %s, tiene el valor: %s' % (key, value))

Ejemplo real de usar tipo diccionario

print ("\n\nInscripción de Curso")
print ("====================")

print ("\nDatos de participante")
print ("---------------------")

print ("Cédula de identidad: ", datos_basicos['cedula'])
print ("Nombre completo: " + datos_basicos['nombres'] + " " + \
datos_basicos['apellidos'])
import datetime, locale, os
locale.setlocale(locale.LC_ALL, os.environ['LANG'])
print ("Fecha y lugar de nacimiento:", datetime.datetime.strftime(
    datetime.datetime.strptime(
        datos_basicos['fecha_nacimiento'], '%d/%m/%Y'
    ), "%d de %B de %Y"
) + " en " + datos_basicos['lugar_nacimiento'] + ".")
print ("Nacionalidad:", datos_basicos['nacionalidad'])
print ("Estado civil:", datos_basicos['estado_civil'])

Tipos de Datos | Tipo Tuplas | Python

Tipo tuplas

Las tuplas son objetos de tipo secuencia, específicamente es un tipo de dato lista inmutable. Esta no puede modificarse de ningún modo después de su creación.

Métodos

Son muy similares a las listas y comparten varias de sus funciones y métodos integrados, aunque su principal diferencia es que son inmutables. El objeto de tipo tupla integra una serie de métodos integrados a continuación:

count()

Este método recibe un elemento como argumento, y cuenta la cantidad de veces que aparece en la tupla.

>>> valores = ("Python", True, "Zope", 5)
>>> print "True ->", valores.count(True)
True -> 1
>>> print "'Zope' ->", valores.count('Zope')
'Zope' -> 1
>>> print "5 ->", valores.count(5)
5 -> 1

index()

Comparte el mismo método index() del tipo lista. Este método recibe un elemento como argumento, y devuelve el índice de su primera aparición en la tupla.

>>> valores = ("Python", True, "Zope", 5)
>>> print valores.index(True)
1
>>> print valores.index(5)
3

El método devuelve un excepción ValueError si el elemento no se encuentra en la tupla, o en el entorno definido.

>>> valores = ("Python", True, "Zope", 5)
>>> print valores.index(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple

Convertir a tuplas

Para convertir a tipos tuplas debe usar la función tuple(), la cual está integrada en el interprete Python.

Truco

Para más información consulte las funciones integradas para operaciones de secuencias.

Ejemplos

A continuación, se presentan algunos ejemplos de su uso:

Ejemplo de definir simple de tupla

tupla = 12345, 54321, 'hola!'

Ejemplo de definir tuplas anidadas

otra = tupla, (1, 2, 3, 4, 5)

Operación asignar de valores de una tupla en variables

x, y, z = tupla

Cuidar seguimiento del número de la numeración

Una tarea común es iterar sobre una secuencia mientras cuidas el seguimiento de la numeración de un elemento.

Podría usar un bucle while con un contador o un bucle for usando la función range() y la función len():

>>> tecnologias = ('Zope', 'Plone', 'Pyramid')
>>> for i in range(0, len(tecnologias)):
...     print i, tecnologias[i]
...
0 Zope
1 Plone
2 Pyramid

Pero, Python provee la palabra reservada enumerate para esto:

print ("\nIterar tupla con función enumerate")
print ("==================================\n")

for index, item in enumerate(conexion_completa):
    print (index, item)

Caso real de conexión a BD

A continuación, un ejemplo más apegado a la realidad que busca establecer una conexión a una BD:

print ("\nDefiniendo conexión a BD MySQL")
print ("==============================\n")

conexion_bd = "127.0.0.1","root","qwerty","nomina",
print ("Conexión típica:", conexion_bd)
print (type(conexion_bd))
conexion_completa = conexion_bd, "3307","10",
print ("\nConexión con parámetros adicionales:", conexion_completa)
print (type(conexion_completa))

print ("\n")

print ("IP de la BD:",  conexion_completa[0][0])
print ("Usuario de la BD:",  conexion_completa[0][1])
print ("Contraseña de la BD:",  conexion_completa[0][2])
print ("Nombre de la BD:",  conexion_completa[0][3])
print ("Puerto de conexión:", conexion_completa[1])
print ("Tiempo de espera en conexión:", conexion_completa[2])

print ("""\nMás información acerca de MySQL y Python \
http://mysql-python.sf.net/MySQLdb.html\n""")

Tipos de Datos | Tipo Listas | Python

Tipo listas

En Python tiene varios tipos de datos compuestos y dentro de las secuencias, están los tipos de cadenas de caracteres. Otro tipo muy importante de secuencia son las listas.

Entre las secuencias, el más versátil, es la lista, para definir una, usted debe escribir es entre corchetes, separando sus elementos con comas cada uno.

La lista en Python son variables que almacenan arrays, internamente cada posición puede ser un tipo de datos distinto.

>>> factura = ['pan', 'huevos', 100, 1234]
>>> factura
['pan', 'huevos', 100, 1234]

Las listas en Python son:

  • heterogéneas: pueden estar conformadas por elementos de distintos tipo, incluidos otras listas.
  • mutables: sus elementos pueden modificarse.

Una lista en Python es una estructura de datos formada por una secuencia ordenada de objetos.

Los elementos de una lista pueden accederse mediante su índice, siendo 0 el índice del primer elemento.

>>> factura[0]
'pan'
>>> factura[3]
1234

La función len() devuelve la longitud de la lista (su cantidad de elementos).

>>> len(factura)
4

Los índices de una lista inicia entonces de 0 hasta el tamaño de la lista menos uno (len(factura) - 1):

>>> len(factura) - 1
3

Pueden usarse también índices negativos, siendo -1 el índice del último elemento.

>>> factura[-1]
1234

Los índices negativos van entonces de -1 (último elemento) a -len(factura) (primer elemento).

>>> factura[-len(factura)]
'pan'

A través de los índices, pueden cambiarse los elementos de una lista en el lugar.

>>> factura[1] = "carne"
>>> factura
['pan', 'carne', 100, 1234

De esta forma se cambia el valor inicial de un elemento de la lista lo cual hacen una la lista mutable

Métodos

El el objeto de tipo lista integra una serie de métodos integrados a continuación:

append()

Este método agrega un elemento al final de una lista.

>>> versiones_plone = [2.5, 3.6, 4, 5]
>>> print versiones_plone
[2.5, 3.6, 4, 5]
>>> versiones_plone.append(6)
>>> print versiones_plone
[2.5, 3.6, 4, 5, 6]

count()

Este método recibe un elemento como argumento, y cuenta la cantidad de veces que aparece en la lista.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print "6 ->", versiones_plone.count(6)
6 -> 1
>>> print "5 ->", versiones_plone.count(5)
5 -> 1
>>> print "2.5 ->", versiones_plone.count(2.5)
2.5 -> 1

extend()

Este método extiende una lista agregando un iterable al final.

>>> versiones_plone = [2.1, 2.5, 3.6]
>>> print versiones_plone
[2.1, 2.5, 3.6]
>>> versiones_plone.extend([4])
>>> print versiones_plone
[2.1, 2.5, 3.6, 4]
>>> versiones_plone.extend(range(5,7))
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5, 6]

index()

Este método recibe un elemento como argumento, y devuelve el índice de su primera aparición en la lista.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6, 4]
>>> print versiones_plone.index(4)
3

El método admite como argumento adicional un índice inicial a partir de donde comenzar la búsqueda, opcionalmente también el índice final.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6, 4]
>>> versiones_plone[2]
3.6
>>> print versiones_plone.index(4, 2)
3
>>> versiones_plone[3]
4
>>> print versiones_plone.index(4, 5)
6
>>> versiones_plone[6]
4

El método devuelve un excepción ValueError si el elemento no se encuentra en la lista, o en el entorno definido.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6, 4]
>>> print versiones_plone.index(9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 9 is not in list

insert()

Este método inserta el elemento x en la lista, en el índice i.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5, 6]
>>> versiones_plone.insert(2, 3.7)
>>> print versiones_plone
[2.1, 2.5, 3.7, 3.6, 4, 5, 6]

pop()

Este método devuelve el último elemento de la lista, y lo borra de la misma.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print versiones_plone.pop()
6
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5]

Opcionalmente puede recibir un argumento numérico, que funciona como índice del elemento (por defecto, -1)

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print versiones_plone.pop(2)
3.6
>>> print versiones_plone
[2.1, 2.5, 4, 5, 6]

remove()

Este método recibe como argumento un elemento, y borra su primera aparición en la lista.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5, 6]
>>> versiones_plone.remove(2.5)
>>> print versiones_plone
[2.1, 3.6, 4, 5, 6]

El método devuelve un excepción ValueError si el elemento no se encuentra en la lista.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5, 6]
>>> versiones_plone.remove(7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

reverse()

Este método invierte el orden de los elementos de una lista.

>>> versiones_plone = [2.1, 2.5, 3.6, 4, 5, 6]
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5, 6]
>>> versiones_plone.reverse()
>>> print versiones_plone
[6, 5, 4, 3.6, 2.5, 2.1]

sort()

Este método ordena los elementos de una lista.

>>> versiones_plone = [4, 2.5, 5, 3.6, 2.1, 6]
>>> print versiones_plone
[4, 2.5, 5, 3.6, 2.1, 6]
>>> versiones_plone.sort()
>>> print versiones_plone
[2.1, 2.5, 3.6, 4, 5, 6]

El método sort() admite la opción reverse, por defecto, con valor False. De tener valor True, el ordenamiento se hace en sentido inverso.

>>> versiones_plone.sort(reverse=True)
>>> print versiones_plone
[6, 5, 4, 3.6, 2.5, 2.1]

Convertir a listas

Para convertir a tipos listas debe usar la función list() la cual esta integrada en el interprete Python.

Truco

Para más información consulte las funciones integradas para operaciones de secuencias.


Ejemplos

A continuación, se presentan algunos ejemplos de su uso:

Ejemplo de definir una colección ordenada/arreglos o vectores

# Definir una colección ordenada / arreglos o vectores
lista = [2, "CMS", True, ["Plone", 10]]

Ejemplo de acceder a un elemento especifico de una lista

# Acceder a un elemento especifico
l2 = lista[1]

Ejemplo de acceder a un elemento en una lista anidada

# Acceder a un elemento en una lista anidada
l3 = lista[3][0]

Ejemplo de definir nuevo valor de un elemento de lista

# Definir nuevo valor de un elemento de lista
lista[1] = 4

Ejemplo de obtener un rango de elemento especifico

# Obtener un rango de elemento especifico
l3 = lista[0:3]

Ejemplos de obtener un rango con saltos de elementos específicos

# Obtener un rango con saltos de elementos específicos
l4 = lista[0:3:2]

Ejemplo de iterar sobre cualquier secuencia

Usted puede iterar sobre cualquier secuencia (cadenas de caracteres, lista, claves en un diccionario, lineas en un archivo, …):

Ejemplo de iterar sobre una cadenas de caracteres

>>> vocales = 'aeiou'
>>> for letra in 'hermosa':
...     if letra in vocales:
...         print letra,
e o a

Ejemplo de iterar sobre una lista

Para separar una cadena en frases, los valores pueden separarse con la función integrada split().

>>> mensaje = "Hola, como estas tu?"
>>> mensaje.split() # retorna una lista
['Hola,', 'como', 'estas', 'tu?']
>>> for palabra in mensaje.split():
...     print palabra
...
Hola,
como
estas
tu?

Ejemplo de iterar sobre dos o más secuencias

Para iterar sobre dos o más secuencias al mismo tiempo, los valores pueden emparejarse con la función integrada zip().

>>> preguntas = ['nombre', 'objetivo', 'sistema operativo']
>>> respuestas = ['Leonardo', 'aprender Python y Plone', 'Linux']
>>> for pregunta, respuesta in zip(preguntas, respuestas):
...     print '¿Cual es tu {0}?, la respuesta es: {1}.'.format(
...         pregunta, respuesta)
...
¿Cual es tu nombre?, la respuesta es: Leonardo.
¿Cual es tu objetivo?, la respuesta es: aprender Python y Plone.
¿Cual es tu sistema operativo?, la respuesta es: Linux.

Tipos de Datos | Cadena de caracteres | Python

Tipo cadenas de caracteres

Las cadenas de caracteres, son secuencias inmutables que contienen caracteres encerrado entre comillas.

Cadenas cortas

Son caracteres encerrado entre comillas simples (') o dobles (").

>>> 'Hola Mundo'
'Hola Mundo'

Cadenas largas

Son caracteres encerrados entre grupo comillas triples simples (''') o dobles ("""), están son generalmente son referenciadas como cadenas de triple comillas.

>>> """Clase que representa una Persona"""
'Clase que representa una Persona'
>>> '''Clase que representa un Supervisor'''
'Clase que representa un Supervisor'

Clases

A continuación, una lista de clases integradas Python para los tipos de cadenas de caracteres:

basestring

Es la clase base de las clases str y unicode.

str

Son secuencias inmutables de cadenas de caracteres con soporte a caracteres ASCII.

>>> 'Hola Mundo'
'Hola Mundo'
>>> "Hola Mundo"
'Hola Mundo'

unicode

Son secuencias inmutables de cadenas de caracteres con soporte a caracteres Unicode.

>>> u'Jekechitü'
u'Jekechit\xfc'

Prefijo de cadenas

Una cadena puede estar precedida por el carácter:

  • r/R, el cual indica, que se trata de una cadena raw (del inglés, cruda). Las cadenas raw se distinguen de las normales en que los caracteres escapados mediante la barra invertida (\) no se sustituyen por sus contrapartidas. Esto es especialmente útil, por ejemplo, para usar las expresiones regulares.

    >>> raw = r"\t\nHola Plone\n"
    >>> type(raw)
    <type 'str'>
    
  • u/U, el cual indica, que se trata de una cadena que utiliza codificación unicode.

    >>> saber_mas = u"Atüjaa oo'omüin..."
    >>> type(saber_mas)
    <type 'unicode'>
    >>> vocales = U"äóè"
    >>> type(vocales)
    <type 'unicode'>
    

Cadenas de escape

Para escapar caracteres dentro de cadenas de caracteres se usa el carácter \ seguido de cualquier carácter ASCII.

Secuencia Escape Significado
\newline Ignorado
\\ Backslash (\)
\' Comillas simple (')
\" Comillas doble (")
\a Bell ASCII (BEL)
\b Backspace ASCII (BS)
\f Formfeed ASCII (FF)
\n Linefeed ASCII (LF)
\N{name} Carácter llamado name en base de datos Unicode (Solo Unicode)
\r Carriage Return ASCII (CR)
\t Tabulación Horizontal ASCII (TAB)
\uxxxx Carácter con valor hex 16-bit xxxx (Solamente Unicode). Ver hex.
\Uxxxxxxxx Carácter con valor hex 32-bit xxxxxxxx (Solamente Unicode). Ver hex.
\v Tabulación Vertical ASCII (VT)
\ooo Carácter con valor octal ooo. Ver octal.
\xhh Carácter con valor hex hh. Ver hex.

También es posible encerrar una cadena entre triples comillas (simples o dobles). De esta forma puede escribir el texto en varias líneas, y al imprimir la cadena, se respetarán los saltos de línea que se introdujeron sin tener que recurrir a los caracteres escapados y las comillas como los anteriores.

Operaciones

Las cadenas también admiten operadores aritméticos como los siguientes:

  • El operador suma para realizar concatenación de cadenas de caracteres:

    >>> a, b = "uno", "dos"
    >>> a + b
    'unodos'
    
  • El operador multiplicación para repetir la cadena de caracteres por N veces definidas en la multiplicación:

    >>> c = "tres"
    >>> c * 3
    'trestrestres'
    
  • El operador modulo usado la técnica de interpolación variables dentro de una cadena de caracteres. Más información consulte la sección formateo %.

Comentarios

Son cadenas de caracteres las cuales constituyen una ayuda esencial tanto para quien está desarrollando el programa, como para otras personas que lean el código.

Los comentarios en el código tienen una vital importancia en el desarrollo de todo programa, algunas de las funciones más importantes que pueden cumplir los comentarios en un programa, son:

  • Brindar información general sobre el programa.
  • Explicar qué hace cada una de sus partes.
  • Aclarar y/o fundamentar el funcionamiento de un bloque específico de código, que no sea evidente de su propia lectura.
  • Indicar cosas pendientes para agregar o mejorar.

El signo para indicar el comienzo de un comentario en Python es el carácter numeral #, a partir del cual y hasta el fin de la línea, todo se considera un comentario y es ignorado por el intérprete Python.

>>> # comentarios en linea
...
>>>

El carácter # puede estar al comienzo de línea (en cuyo caso toda la línea será ignorada), o después de finalizar una instrucción válida de código.

>>> # Programa que calcula la sucesión
... # de números Fibonacci
...
>>> # se definen las variables
... a, b = 0, 1
>>> while b < 100: # mientras b sea menor a 100 itere
...     print b,
...     a, b = b, a + b # se calcula la sucesión Fibonacci
...
1 1 2 3 5 8 13 21 34 55 89

Comentarios multilínea

Python no dispone de un método para delimitar bloques de comentarios de varias líneas.

Al igual que los comentarios de un sola linea, son cadenas de caracteres, en este caso van entre triples comillas (simples o dobles), esto tiene el inconveniente que, aunque no genera código ejecutable, el bloque delimitado no es ignorado por el intérprete Python, que crea el correspondiente objeto de tipo cadena de caracteres.

>>> """comentarios en varias lineas"""
'comentarios en varias lineas'
>>> '''comentarios en varias lineas'''
'comentarios en varias lineas'

A continuación, una comparación entre comentarios multilínea y comentarios en solo una linea:

>>> # Calcula la sucesión
... # de números Fibonacci
...
>>> """Calcula la sucesión
... de números Fibonacci"""
'Calcula la sucesi\xc3\xb3n \nde n\xc3\xbameros Fibonacci'

Entonces existen al menos dos (02) alternativas para introducir comentarios multilínea son:

  • Comentar cada una de las líneas con el carácter #: en general todos los editores de programación y entornos de desarrollo (IDEs) disponen de mecanismos que permiten comentar y descomentar fácilmente un conjunto de líneas.
  • Utilizar triple comillas (simples o dobles) para generar una cadena multilínea: si bien este método es aceptado.

A continuación, un ejemplo de Comentarios multilínea y de solo una linea:

>>> u"""Calcula la sucesiónde números Fibonacci"""
u'Calcula la sucesi\xf3nde n\xfameros Fibonacci'
>>> # se definen las variables
... a, b = 0, 1
>>> while b < 100:
...     print b,
...     # se calcula la sucesión Fibonacci
...     a, b = b, a + b
...
1 1 2 3 5 8 13 21 34 55 89

Los comentarios multilínea usado con mucha frecuencia como en las varias sintaxis Python como comentarios de documentación a continuación se listan las sintaxis más comunes:

  • Módulos.
  • Funciones.
  • Clases.
  • Métodos.

Docstrings

En Python todos los objetos cuentan con una variable especial llamada __doc__, gracias a la cual puede describir para qué sirven los objetos y cómo se usan. Estas variables reciben el nombre de docstrings, o cadenas de documentación.

Ten en cuenta, una buena documentación siempre dará respuesta a las dos preguntas:

  • ¿Para qué sirve?
  • ¿Cómo se utiliza?

Funciones

Python implementa un sistema muy sencillo para establecer el valor de las docstrings en las funciones, únicamente tiene que crear un comentario en la primera línea después de la declaración.

>>> def hola(arg):
...     """El docstring de la función"""
...     print "Hola", arg, "!"
...
>>> hola("Plone")
Hola Plone !

Puede puede consultar la documentación de la función hola() debe utilizar la función integrada help() y pasarle el argumento del objeto de función hola():

>>> help(hola)

Help on function hola in module __main__:

hola(arg)
    El docstring de la función

>>>
>>> print hola.__doc__
El docstring de la función

Clases y métodos

De la misma forma puede establecer la documentación de la clase después de la definición, y de los métodos, como si fueran funciones:

>>> class Clase:
...
...     """El docstring de la clase"""
...     def __init__(self):
...         """El docstring del método constructor de clase"""
...
...     def metodo(self):
...         """El docstring del método de clase"""
...
>>> o = Clase()
>>> help(o)

Help on instance of Clase in module __main__:

class Clase
 |  El docstring de la clase
 |
 |  Methods defined here:
 |
 |  __init__(self)
 |      El docstring del método constructor de clase
 |
 |  metodo(self)
 |      El docstring del método de clase

>>> o.__doc__
'El docstring de la clase'
>>> o.__init__.__doc__
'El docstring del método constructor de clase'
>>> o.metodo.__doc__
'El docstring del método de clase'

Scripts y módulos

Cuando tiene un script o módulo, la primera línea del mismo hará referencia al docstrings del módulo, en él debe explicar el funcionamiento del mismo:

En el archivo mi_modulo.py debe contener el siguiente código:

"""El docstring del módulo"""

def despedir():
    """El docstring de la función despedir"""
    print "Adiós! desde función despedir() del módulo prueba"

def saludar():
    """El docstring de la función saludar"""
    print "Hola! desde función saludar() del módulo prueba"

Entonces, usted debe importar el módulo anterior, para consultar la documentación del módulo mi_modulo debe utilizar la función integrada help() y pasarle el argumento el nombre de módulo mi_modulo, de la siguiente manera:

>>> import mi_modulo
>>> help(mi_modulo)

Help on module mi_modulo:

NAME
    mi_modulo - El docstring del módulo
FUNCTIONS
    despedir()
        El docstring de la función despedir
    saludar()
        El docstring de la función saludar

También puede consultar la documentación de la función despedir() dentro del módulo mi_modulo, usando la función integrada help() y pasarle el argumento el formato nombre_modulo.nombre_funcion, es decir, mi_modulo.despedir, de la siguiente manera:

>>> help(mi_modulo.despedir)

Help on function despedir in module mi_modulo:

despedir()
    El docstring de la función despedir

Opcionalmente , usted puede listar las variables y funciones del módulo con la función dir(), de la siguiente manera:

>>> dir(mi_modulo)
['__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'despedir',
 'saludar']

Como puede apreciar, muchas de estas variables son especiales, puede comprobar sus valores:

>>> print mi_modulo.__name__     # Nombre del módulo
'mi_modulo'
>>> print mi_modulo.__doc__      # Docstring del módulo
'El docstring del módulo'
>>> print mi_modulo.__package__  # Nombre del paquete del módulo

Formateo de cadenas

Python soporta múltiples formas de formatear una cadena de caracteres. A continuación se describen:

Formateo %

El carácter modulo % es un operador integrado en Python. Ese es conocido como el operador de interpolación. Usted necesitará proveer el % seguido por el tipo que necesita ser formateado o convertido. El operador % entonces substituye la frase “%tipodato” con cero o mas elementos del tipo de datos especificado:

>>> tipo_calculo = "raíz cuadrada de dos"
>>> valor = 2**0.5
>>> print "el resultado de %s es %f" % (tipo_calculo, valor)
el resultado de raíz cuadrada de dos es 1.414214

También aquí se puede controlar el formato de salida. Por ejemplo, para obtener el valor con 8 dígitos después de la coma:

>>> tipo_calculo = "raíz cuadrada de dos"
>>> valor = 2**0.5
>>> print "el resultado de %s es %.8f" % (tipo_calculo, valor)
el resultado de raíz cuadrada de dos es 1.41421356

Con esta sintaxis hay que determinar el tipo del objeto:

  • %c = str, simple carácter.
  • %s = str, cadena de carácter.
  • %d = int, enteros.
  • %f = float, coma flotante.
  • %o = octal.
  • %x = hexadecimal.

A continuación un ejemplo por cada tipo de datos:

>>> print "CMS: %s, ¿Activar S o N?: %c" % ("Plone", "S")
CMS: Plone, ¿Activar S o N?: S
>>> print "N. factura: %d, Total a pagar: %f" % (345, 658.23)
N. factura: 345, Total a pagar: 658.230000
>>> print "Tipo Octal: %o, Tipo Hexadecimal: %x" % (027, 0x17)
Tipo Octal: 27, Tipo Hexadecimal: 17

Clase formatter

formatter es una de las clases integradas string. Ese provee la habilidad de hacer variable compleja de substituciones y formateo de valores usando el método format(). Es le permite crear y personalizar sus propios comportamientos de formatos de cadena de caracteres para reescribir los métodos públicos y contiene: format()vformat(). Ese tiene algunos métodos que son destinado para ser remplazados por las sub-clases: parse()get_field()get_value()check_unused_args()format_field() y convert_field().

format()

Este método devuelve una versión formateada de una cadena de caracteres, usando substituciones desde argumentos args y kwargs. Las substituciones son identificadas entre llaves { } dentro de la cadena de caracteres (llamados campos de formato), y son sustituidos en el orden con que aparecen como argumentos de format(), contando a partir de cero (argumentos posicionales).

Esto es una forma más clara y elegante es referenciar objetos dentro de la misma cadena, y usar este método para sustituirlos con los objetos que se le pasan como argumentos.

>>> tipo_calculo = "raíz cuadrada de dos"
>>> valor = 2**0.5
>>> print "el resultado de {} es {}".format(tipo_calculo, valor)
el resultado de raíz cuadrada de dos es 1.41421356237

También se puede referenciar a partir de la posición de los valores utilizando índices:

>>> tipo_calculo = "raíz cuadrada de dos"
>>> valor = 2**0.5
>>> print "el resultado de {0} es {1}".format(tipo_calculo, valor)
el resultado de raíz cuadrada de dos es 1.41421356237

Los objetos también pueden ser referenciados utilizando un identificador con una clave y luego pasarla como argumento al método:

>>> tipo_calculo = "raíz cuadrada de dos"
>>> print "el resultado de {nombre} es {resultado}".format(
...     nombre=tipo_calculo, resultado=2**0.5)
el resultado de raíz cuadrada de dos es 1.41421356237

Formateo avanzado

Este método soporta muchas técnicas de formateo, aquí algunos ejemplos:

Alinear una cadena de caracteres a la derecha en 30 caracteres, con la siguiente sentencia:

>>> print "{:>30}".format("raíz cuadrada de dos")
     raíz cuadrada de dos

Alinear una cadena de caracteres a la izquierda en 30 caracteres (crea espacios a la derecha), con la siguiente sentencia:

>>> print "{:30}".format("raíz cuadrada de dos")
raíz cuadrada de dos

Alinear una cadena de caracteres al centro en 30 caracteres, con la siguiente sentencia:

>>> print "{:^30}".format("raíz cuadrada de dos")
    raíz cuadrada de dos

Truncamiento a 9 caracteres, con la siguiente sentencia:

>>> print "{:.9}".format("raíz cuadrada de dos")
raíz cua

Alinear una cadena de caracteres a la derecha en 30 caracteres con truncamiento de 9, con la siguiente sentencia:

>>> print "{:>30.9}".format("raíz cuadrada de dos")
                     raíz cua

Formateo por tipo

Opcionalmente se puede poner el signo de dos puntos después del número o nombre, y explicitar el tipo del objeto:

  • s para cadenas de caracteres (tipo str).
  • d para números enteros (tipo int).
  • f para números de coma flotante (tipo float).

Esto permite controlar el formato de impresión del objeto. Por ejemplo, usted puede utilizar la expresión .4f para determinar que un número de coma flotante (f) se imprima con cuatro dígitos después de la coma (.4).

>>> tipo_calculo = "raíz cuadrada de dos"
>>> valor = 2**0.5
>>> print "el resultado de {0} es {resultado:.4f}".format(
...     tipo_calculo, resultado=valor)
el resultado de raíz cuadrada de dos es 1.4142

Formateo de números enteros, rellenados con espacios, con las siguientes sentencias:

>>> print "{:4d}".format(10)
  10
>>> print "{:4d}".format(100)
 100
>>> print "{:4d}".format(1000)
1000

Formateo de números enteros, rellenados con ceros, con las siguientes sentencias:

>>> print "{:04d}".format(10)
0010
>>> print "{:04d}".format(100)
0100
>>> print "{:04d}".format(1000)
1000

Formateo de números flotantes, rellenados con espacios, con las siguientes sentencias:

>>> print "{:7.3f}".format(3.1415926)
  3.142
>>> print "{:7.3f}".format(153.21)
153.210

Formateo de números flotantes, rellenados con ceros, con las siguientes sentencias:

>>> print "{:07.3f}".format(3.1415926)
003.142
>>> print "{:07.3f}".format(153.21)
153.210

3.8.10. Convertir a cadenas de caracteres

Para convertir a tipos cadenas de caracteres debe usar la función str() la cual esta integrada en el interprete Python.

Truco

Para más información consulte las funciones integradas para operaciones en cadenas de caracteres.


Ejemplos

A continuación, se presentan algunos ejemplos de su uso:

Ejemplo de definir cadenas de caracteres con comillas simples

# Definir comillas simples
cadena1 = 'Texto entre comillas simples,'

Ejemplo de definir cadenas de caracteres con comillas dobles

# Definir comillas dobles
cadena2 = "Texto entre comillas dobles,"

Ejemplo de definir cadenas de caracteres con código escapes

# Definir cadena con código escapes
cadena3 = 'Texto entre \n\tcomillas simples,'

Ejemplo de definir cadenas de caracteres con varias lineas

# Definir cadena varias lineas
cadena4 = """Texto linea 1
linea 2
linea 3
linea 4
.
.
.
.
.
linea N"""

Ejemplo operadores de repetición de cadenas de caracteres

cadena5 = "Cadena" * 3
print (cadena5 + ",", type(cadena5))

Ejemplo operadores de concatenación de cadenas de caracteres

nombre, apellido = "Leonardo", "Caballero"
nombre_completo = nombre + " " + apellido
print (nombre_completo + ",", type(nombre_completo))

Ejemplo de medir tamaño de la cadena con función «len()»

print ("El tamaño de la cadena es:", len(nombre_completo))

Ejemplo de acceder a rango de la cadena

print ("Acceso a rango de cadena: ", nombre_completo[3:13])

Ejemplo de consulta de ayuda a la función len

>>> help(len)

Help on built-in function len in module __builtin__:

len(...)
    len(object) -> integer

    Return the number of items of a sequence or collection.

Ejemplo de consulta de ayuda a la clase int

>>> help(int)

Help on class int in module __builtin__:

class int(object)
 |  int(x=0) -> int or long
 |  int(x, base=10) -> int or long
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is floating point, the conversion truncates towards zero.
 |  If x is outside the integer range, the function returns a long instead.

Ejemplo de consulta de ayuda del módulo

>>> import datetime
>>> help(datetime)

Help on built-in module datetime:

NAME
    datetime - Fast implementation of the datetime type.

FILE
    (built-in)

CLASSES
    __builtin__.object
        date
            datetime

3.8.12. Ayuda integrada

Usted puede consultar toda la documentación disponible sobre las cadenas de caracteres desde la consola interactiva de la siguiente manera:

>>> help(str)

Para salir de esa ayuda presione la tecla q.

Usted puede consultar toda la documentación disponible sobre las cadenas de caracteres unicode desde la consola interactiva de la siguiente manera:

>>> help(unicode)

Tipos de datos | Tipo Booleanos | Python

Tipo booleanos

El tipo booleano sólo puede tener dos valores: True (verdadero) y False (falso). Estos valores son especialmente importantes para las expresiones condicionales y los bucles, como verá más adelante.

Clase Tipo Notas Ejemplo
bool Números Valor booleano falso. False
bool Números Valor booleano verdadero. True

En el contexto de las operaciones booleanas, y también cuando las expresiones son usadas bajo sentencias de flujo de control, los siguientes valores son interpretados como False:

  • False.
  • None.
  • Número cero en todos los tipos.
  • Cadena de caracteres vaciás.
  • Contenedores, incluyendo cadenas de caracterestuplaslistasdiccionarios y conjuntos mutables e inmutables.

A continuación, varios ejemplos en códigos de los citado previamente:

>>> False
False
>>> False == False
True
>>> 0 == False
True
>>> "" == False
False
>>> None == False
False
>>> [] == False
False
>>> () == False
False
>>> {} == False
False
>>> ['', ''] == False
False

Todos los otros valores son interpretados por defecto a True. El operador lógico not produce True si su argumento es falso, False de lo contrario.

Los tipos integrados False y True son solamente dos instancias de la clase bool. En realidad el tipo bool es una subclase del tipo int o entero plano, es decir, sus valores son 0 y 1 respectivamente, en casi todos los contextos:

>>> int(False)
0
>>> int(True)
1

En el ejemplo anterior se convierte tipos booleanos a tipo enteros, siempre devuelve sus valores numéricos 0 y 1. La excepción a la regla anterior sucede cuando un tipo booleano es convertido a un tipo de cadenas de caracteres, las cadenas “False” y/o “True” son retornadas, respectivamente:

>>> type(True)
<type 'bool'>
>>> str(True)
'True'
>>> type(str(True))
<type 'str'>
>>>
>>> type(False)
<type 'bool'>
>>> str(False)
'False'
>>> type(str(False))
<type 'str'>

Puede que esto para usted, no lo entienda mucho, si no conoces los términos de la orientación a objetos, que se tocará más adelante, aunque tampoco es nada importante.

Importante

Los tipos booleanos no puede ser a su vez una subclase.

Convertir a booleanos

Para convertir a tipos booleanos debe usar la función bool() la cual esta integrada en el interprete Python.

Ejemplos

A continuación, se presentan algunos ejemplos de su uso:

Ejemplo de tipos de datos booleanos

aT, aF = True, False
print ("El valor es", aT, "de tipo:", type(aT), "\n")
print ("El valor es", aF, "de tipo:", type(aF))

Ejemplo de operadores booleanos

aAnd = True and False
print ("SI es Verdadero Y Falso, es", aAnd, "de", type(aAnd), "\n")
aOr = True or False
print ("SI es Verdadero O Falso, es", aOr, "de", type(aOr), "\n")
aNot = not True
print ("Si NO es Verdadero, es", aNot, "de", type(aNot), "\n")