Clasificación de las Estructuras de Datos





Clasificación de las Estructuras de Datos en Phyton




Tipos y Estructuras de Dato en Phyton


En Python tiene varios tipos de datos compuestos estándar disponibles por defecto en el interprete, como los tipos numéricos, secuencias, mapeos y conjuntos usados para agrupar otros valores.

Para el caso de las estructuras de datos se usan variables y constantes las cuales usan operadores para tratar los tipos de datos estándar.

En esta lección se describen las variables, operadores y sus tipos de datos en el lenguaje Python, los cuales se resumieron en esta tabla. A continuación el temario de esta lección:

Jerarquía de tipos estándar

A continuación se muestra una lista de los tipos que están integrados en Python. Los módulos de extensión (escritos en C, Java u otros lenguajes, dependiendo de la implementación) pueden definir tipos adicionales. Las versiones futuras de Python pueden agregar tipos a la jerarquía de tipos (por ejemplo, números racionales, arrays de enteros almacenados eficientemente, etc.).

Algunas de las descripciones de tipo a continuación contienen un párrafo que enumera los «atributos especiales». Estos son atributos que proporcionan acceso a la implementación y no están destinados para uso general. Su definición puede cambiar en el futuro.

En Python tiene varios tipos de datos compuestos estándar disponibles por defecto en el interprete, como los tipos numéricos, secuencias, mapeos y conjuntos usados para agrupar otros valores.

Para el caso de las estructuras de datos se usan variables y constantes las cuales usan operadores para tratar los tipos de datos estándar.

Clasificación

Los tipos de datos compuestos estándar se pueden clasificar como los dos siguientes:

Mutable: su contenido (o dicho valor) puede cambiarse en tiempo de ejecución.
Inmutable: su contenido (o dicho valor) no puede cambiarse en tiempo de ejecución.
Se pueden resumir los tipos de datos compuestos estándar en la siguiente tabla:



Otros tipos de datos incorporados, se describen a continuación:



Objectos Type

Los objectos Type representan the various object types. Un objecto type es accedido por la función integrada type(). No hay operaciones especiales en los tipos. El módulo estándar types defines los nombres para todos los tipos integrados estándar.
Los tipos son escritos como esto: «».




Variables y constantes

Variables

Es un nombre que se refiere a un objeto que reside en la memoria. El objeto puede ser de alguno de los tipos vistos (número o cadena de texto), o alguno de los otros tipos existentes en Python.

Cada variable debe tener un nombre único llamado identificador. Eso es muy de ayuda pensar las variables como contenedores que contienen data el cual puede ser cambiado después a través de técnicas de programación.

Alcance de las variables

Las variables en Python son locales por defecto. Esto quiere decir que las variables definidas y utilizadas en el bloque de código de una función, sólo tienen existencia dentro de la misma, y no interfieren con otras variables del resto del código.

A su vez, las variables existentes fuera de una función, no son visibles dentro de la misma.

En caso de que sea conveniente o necesario, una variable local puede convertirse en una variable global declarándola explícitamente como tal con la sentencia global.

Ejemplos de variables

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

Ejemplo de asignar valor a variable

A continuación, se creará un par de variables a modo de ejemplo. Una de tipo cadenas de caracteres y una de tipo entero:

>>> c = "Hola Mundo" # cadenas de caracteres
>>> type(c) # comprobar tipo de dato

>>> e = 23 # número entero
>>> type(e) # comprobar tipo de dato


Como puede ver en Python, a diferencia de muchos otros lenguajes, no se declara el tipo de la variable al crearla. En Java, por ejemplo, definir una variable seria así:

String c = "Hola Mundo";
int e = 23;

También nos ha servido el pequeño ejemplo para presentar los comentarios en linea en Python: cadenas de caracteres que comienzan con el carácter # y que Python ignora totalmente. Hay más tipos de comentarios, de los cuales se tratarán más adelante.

Ejemplo de cambiar valor a variable

A continuación, se cambiará el valor para una variable de tipo cadenas de caracteres a modo de ejemplo:

>>> c = "Hola Plone" # cadenas de caracteres
>>> c
'Hola Plone'

Ejemplo de asignar múltiples valores a múltiples variables

A continuación, se creará múltiples variables (entero, coma flotante, cadenas de caracteres) asignando múltiples valores:

>>> a, b, c = 5, 3.2, "Hola"
>>> print a
5
>>> print b
3.2
>>> print c
'Hola'

Si usted quiere asignar el mismo valor a múltiples variables al mismo tiempo, usted puede hacer lo siguiente:

>>> x = y = z = True
>>> print x
True
>>> print y
True
>>> print z
True

El segundo programa asigna el mismo valor booleano a todas las tres variables x, y, z.

Constantes

Una constante es un tipo de variable la cual no puede ser cambiada. Eso es muy de ayuda pensar las constantes como contenedores que contienen información el cual no puede ser cambiado después.

En Python, las constantes son usualmente declaradas y asignadas en un módulo. Aquí, el módulo significa un nuevo archivo que contiene variables, funciones, etc; el cual es importada en el archivo principal. Dentro del módulo, las constantes son escritas en letras MAYÚSCULAS y separadas las palabras con el carácter underscore _.

Constantes integradas

Un pequeño número de constantes vive en el espacio de nombres incorporado. Son las siguientes:

None
Más información consulte sobre None.
NotImplemented
Más información consulte sobre NotImplemented.
Ellipsis
Más información consulte sobre Ellipsis.
False El valor falso del tipo booleano.
True
El valor verdadero del tipo booleano.
__debug__

Esta constante su valor es True si Python no se inició con una opción -O. Véase también la sentencia assert.
Nota

Los nombres None y __debug__ no se pueden reasignar (asignaciones a ellos, incluso como un nombre de atributo, causa una excepción SyntaxError), por lo que pueden considerarse constantes «verdaderas».

Ejemplo de constantes

A continuación, se presentan algunos ejemplos del uso de constantes:
Ejemplo de constantes desde un módulo externo
Crear un archivo llamado constantes.py con el siguiente contenido:

PORT_DB_SERVER = 3307
USER_DB_SERVER = "root"
PASSWORD_DB_SERVER = "123456"
DB_NAME = "nomina"

Crear un archivo llamado main.py con el siguiente contenido:

print ("scp -v -P {0} {1}@{2}:/{3}/{4}/{4}.sql /srv/backup".format(
str(constantes.PORT_DB_SERVER), constantes.USER_DB_SERVER,
constantes.IP_DB_SERVER, constantes.USER_DB_SERVER,
constantes.DB_NAME))
Luego ejecuta el programa de la siguiente forma:

python main.py

Cuando usted ejecuta el programa, la salida será:

scp -v -P 3307 root@127.0.0.1:/root/webapp/db.sql /srv/backup
En el programa anterior, existe un archivo de módulo constantes.py. Entonces en este se asignan los valores de constantes IP_DB_SERVER, PORT_DB_SERVER, USER_DB_SERVER, PASSWORD_DB_SERVER y DB_NAME. Ademas, existe el archivo de módulo main.py el cual importa el módulo constantes. Finalmente, se imprime una linea de conexión del comando scp de Linux usando la función integrada en la librería estándar Python llamada format().

Nota
En realidad, no se usa las constantes en Python. El módulo globals o constants es usado a lo largo de los programas de Python.

Palabras reservadas

Existen ciertas palabras que tienen significado especial para el intérprete de Python. Estas no pueden utilizarse para ningún otro fin (como ser nombrar valores) excepto para el que han sido creadas. Estas son:

and.
as.
assert.
break.
class.
continue.
def.
del.
elif.
else.
except.
exec.
finally.
for.
from.
global.
if.
import.
in.
is.
lambda.
not.
or.
pass.
print.
raise.
return.
try.
while.
with.
yield.

Nota Para Python 2.7 son un total de 31 palabras reservadas.

Puede verificar si una palabra esta reservada utilizando el módulo integrado keyword, de la siguiente forma:

>>> import keyword
>>> keyword.iskeyword('as')
True
>>> keyword.iskeyword('x')
False
Para obtener una lista de todas las palabras reservadas

>>> import keyword
>>> keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def',
'del', 'elif', 'else', 'except', 'exec', 'finally', 'for',
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not',
'or', 'pass', 'print', 'raise', 'return', 'try', 'while',
'with', 'yield']

Reglas y convención de nombres

Algunas reglas y convenciones de nombres para las variables y constantes:

Nunca use símbolos especiales como !, @, #, $, %, etc.
El primer carácter no puede ser un número o dígito.
Las constantes son colocadas dentro de módulos Python y significa que no puede ser cambiado.
Los nombres de constante y variable debería tener la combinación de letras en minúsculas (de a a la z) o MAYÚSCULAS (de la A a la Z) o dígitos (del 0 al 9) o un underscore (_). Por ejemplo:

snake_case
MACRO_CASE
camelCase
CapWords

Los nombres que comienzan con guión bajo (simple _ o doble __) se reservan para variables con significado especial
No pueden usarse como identificadores, las palabras reservadas .

Sentencia del

La sentencia del se define recursivamente muy similar a la forma en el cual se define la asignación. A continuación unos ejemplos donde se inicializan variables:

>>> cadena, numero, lista = "Hola Plone", 123456, [7,8,9,0]
>>> tupla = (11, "Chao Plone", True, None)
>>> diccionario = {"nombre":"Leonardo","apellido":"Caballero"}

Luego de inicializar las variables del código anterior, usted puede usar la función vars() para obtener un diccionario conteniendo ámbito actual de las variables, ejecutando:

>>> vars()
{'tupla': (11, 'Chao Plone', True, None),
'__builtins__': ,
'numero': 123456, '__package__': None, 'cadena': 'Hola Plone',
'diccionario': {'apellido': 'Caballero', 'nombre': 'Leonardo'},
'__name__': '__main__', 'lista': [7, 8, 9, 0], '__doc__': None}

Si desea eliminar la referencia a la variable cadena, ejecuta:

>>> del cadena
>>> vars()
{'tupla': (11, 'Chao Plone', True, None),
'__builtins__': ,
'numero': 123456, '__package__': None,
'diccionario': {'apellido': 'Caballero', 'nombre': 'Leonardo'},

'__name__': '__main__', 'lista': [7, 8, 9, 0], '__doc__': None}

Como pudo ver en el ejemplo anterior que elimino la referencia a la variable cadena, incluso al volver a la función vars() ya no sale en el ámbito de variables disponibles.

La eliminación de una lista de objetivos elimina recursivamente cada objetivo, de izquierda a derecha.

>>> del numero, lista, tupla, diccionario
>>> vars()
{'__builtins__': ,
'__package__': None, '__name__': '__main__', '__doc__': None}

Como pudo ver en el ejemplo anterior que elimino las referencias a las variables numero, lista, tupla, diccionario que incluso al volver a la función vars() ya no están en el ámbito de variables disponibles.

La eliminación de un nombre elimina el enlace de ese nombre del espacio de nombres local o global, dependiendo de si el nombre aparece en una sentencia «global» en el mismo bloque de código. Si el nombre no está vinculado, se generará una excepción «NameError».

Truco

Es ilegal eliminar un nombre del espacio de nombres local si aparece como una variable libre en un bloque anidado.

La eliminación de las referencias de atributos, suscripciones y segmentaciones se pasa al objeto primario involucrado; la eliminación de un corte es en general equivalente a la asignación de un corte vacío del tipo correcto (pero incluso esto está determinado por el objeto cortado).

Sentencia global

La sentencia global es una declaración que se mantiene para todo el bloque de código actual. Eso significa que los identificadores listados son interpretados como globales. Eso podría ser imposible asignar a una variable global sin la sentencia global, aunque las variables libres pueden referirse a globales sin ser declaradas globales.

>>> variable1 = "variable original"
>>> def variable_global():
... global variable1
... variable1 = "variable global modificada"
...
>>> print variable1
variable original
>>> variable_global()
>>> print variable1

variable global modificada

Como se puede ver, después de llamar a la función variable_global(), la variable variable1 queda modificada. En general, este procedimiento debe utilizarse con precaución.

Importante

Usted puede descargar el código usado en esta sección haciendo clic en los siguientes enlaces: constantes.py y main.py.

Truco

Para ejecutar el código constantes.py y main.py, abra una consola de comando, acceda al directorio donde se encuentra ambos programas:

leccion3/
├── constantes.py
└── main.py

Si tiene la estructura de archivo previa, entonces ejecute el siguiente comando:

python main.py

Operadores de asignaciones

Los operadores de asignación se utilizan para

Existe en Python todo un grupo de operadores los cuales le permiten básicamente asignar un valor a una variable, usando el operador «=». Con estos operadores pueden aplicar la técnica denominada asignación aumentada.

Operador =

El operador igual a, (=), es el más simple de todos y asigna a la variable del lado izquierdo cualquier variable o resultado del lado derecho.

Operador +=

El operador += suma a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r += 10; r
15 En el ejemplo anterior si la variable «r» es igual a 5 y r += 10, entonces la variable «r» sera igual a 15. Su equivalente seria el siguiente:

>>> r = 5; r = r + 10; r
15

Operador -=

El operador -= resta a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r -= 10; r
-5

En el ejemplo anterior si la variable «r» es igual a 5 y r -= 10, entonces la variable «r» sera igual a -5. Su equivalente seria el siguiente:

>>> r = 5; r = r - 10; r
-5

Operador *=

El operador *= multiplica a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r *= 10; r
50

En el ejemplo anterior si la variable «r» es igual a 5 y r *= 10, entonces la variable «r» sera igual a 50. Su equivalente seria el siguiente:

>>> r = 5; r = r * 10; r
50

Operador /=

El operador /= divide a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r /= 10; r
0

En el ejemplo anterior si la variable «r» es igual a 5 y r /= 10, entonces la variable «r» sera igual a 0. Su equivalente seria el siguiente:

>>> r = 5; r = r / 10; r
0

Operador **=

El operador **= calcula el exponente a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r **= 10; r
9765625
En el ejemplo anterior si la variable «r» es igual a 5 y r **= 10, entonces la variable «r» sera igual a 9765625. Su equivalente seria el siguiente:

>>> r = 5; r = r ** 10; r
9765625

Operador //=

El operador //= calcula la división entera a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r //= 10; r
0

En el ejemplo anterior si la variable «r» es igual a 5 y r //= 10, entonces la variable «r» sera igual a 0. Su equivalente seria el siguiente:

>>> r = 5; r = r // 10; r 0

Operador %=

El operador %= devuelve el resto de la división a la variable del lado izquierdo el valor del lado derecho.

>>> r = 5; r %= 10; r
5

En el ejemplo anterior si la variable «r» es igual a 5 y r %= 10, entonces la variable «r» sera igual a 5. Su equivalente seria el siguiente:

>>> r = 5; r = r % 10; r
5

Asignación aumentada

Es frecuente que una variable tenga que ser definida de nuevo en función de sí misma. Normalmente usted escribir la siguiente sintaxis:

>>> contador = contador + 1
El código anterior, se puede abreviar a su equivalente, usando la asignación aumentada, de la siguiente manera:

>>> contador += 1
El código anterior, no sólo es más corto de escribir, sino también más eficiente en tiempo de ejecución.

Ejemplos

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

print ("Valor de variable 'a':", a)
print ("Valor de variable 'b':", b)

c = a + b
print ("Operador = | El valor de variable 'c' es ", c)

c += a
print ("Operador += | El valor de variable 'c' es ", c)

c *= a
print ("Operador *= | El valor de variable 'c' es ", c)

c /= a
print ("Operador /= | El valor de variable 'c' es ", c)

c = 2
c %= a print ("Operador %= | El valor de variable 'c' es ", c)

c **= a
print ("Operador **= | El valor de variable 'c' es ", c)

c //= a
print ("Operador //= | El valor de variable 'c' es ", c)

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código operadores_asignaciones.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_asignaciones.py

Operadores aritméticos

Los valores numéricos son además el resultado de una serie de operadores aritméticos y matemáticos:

Operador Suma

El operador + suma los valores de tipo de datos numéricos.

>>> 3 + 2
5

Operador Resta

El operador - resta los valores de tipo de datos numéricos.

>>> 4 - 7
-3

Operador Negación

El operador - asigna un valor negativo a un tipo de datos numéricos.

>>> -7
-7

Operador Multiplicación

El operador * multiplica los valores de tipo de datos numéricos.

>>> 2 * 6
12

Operador Exponente

El operador ** calcula el exponente entre valores de tipo de datos numéricos.

>>> 2 ** 6
64

Operador división

El operador división el resultado que se devuelve es un número real.

>>> 3.5 / 2
1.75

Operador división entera

El operador división entera el resultado que se devuelve es solo la parte entera.

>>> 3.5 // 22
1.0

No obstante hay que tener en cuenta que si utilizamos dos operandos enteros, Python determinará que quiere que la variable resultado también sea un entero, por lo que el resultado de, por ejemplo, 3 / 2 y 3 // 2 sería el mismo: 1.

Si quisiéramos obtener los decimales necesitaríamos que al menos uno de los operandos fuera un número real, bien indicando los decimales:

r = 3.0 / 2
O bien utilizando la función float() para convertir a entero coma flotante o real:

r = float(3) / 2
Esto es así porque cuando se mezclan tipos de números, Python convierte todos los operandos al tipo más complejo de entre los tipos de los operandos.

Operador Módulo

El operador módulo no hace otra cosa que devolver el resto de la división entre los dos operandos. En el ejemplo, 7 / 2 sería 3, con 1 de resto, luego el módulo es 1.

>>> 7 % 2
1

Orden de precedencia

El orden de precedencia de ejecución de los operadores aritméticos es:

Exponente: **
Negación: -
Multiplicación, División, División entera, Módulo: *, /, //, %
Suma, Resta: +, -

Eso quiere decir que se debe usar así:

>>> 2**1/12
0.16666666666666666 >>>

Más igualmente usted puede omitir este orden de precedencia de ejecución de los operadores aritméticos usando paréntesis () anidados entre cada nivel calculo, por ejemplo:

>>> 2**(1/12)
1.0594630943592953
>>>

Ejemplos

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

Ejemplo de definir variables numéricas
Ejemplo de operador aritmético Suma, Añade valores a cada lado del operador.
Ejemplo de operador aritmético Resta, Resta el operando de la derecha del operador del lado izquierdo.
Ejemplo de operador aritmético Multiplicación, Multiplica los valores de ambos lados del operador.
Ejemplo de operador aritmético Exponente, Realiza el cálculo exponencial (potencia) de los operadores.
Ejemplo de operador aritmético División.
Ejemplo de operador aritmético División entera.
Ejemplo de operador aritmético Cociente de una división, la división de operandos que el resultado es el cociente en el cual se eliminan los dígitos después del punto decimal.
Ejemplo de operador aritmético Módulo, el cual divide el operando de la izquierda por el operador del lado derecho y devuelve el resto.

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código operadores_aritmeticos.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_aritmeticos.py

Operadores relacionales

Los valores booleanos son además el resultado de expresiones que utilizan operadores relacionales (comparaciones entre valores):

Operador ==

El operador == evalua que los valores sean iguales para varios tipos de datos.

>>> 5 == 3 False >>> 5 == 5 True >>> "Plone" == 5 False >>> "Plone" == "Plone" True >>> type("Plone") == str True

Operador !=

El operador != evalua si los valores son distintos.

>>> 5 != 3 True >>> "Plone" != 5 True >>> "Plone" != False True

Operador <

El operador < evalua si el valor del lado izquierdo es menor que el valor del lado derecho.

>>> 5 < 3
False
Operador >

El operador > evalua si el valor del lado izquierdo es mayor que el valor del lado derecho.

>>> 5 > 3
True

Operador <=

El operador <= evalua si el valor del lado izquierdo es menor o igual que el valor del lado derecho.

>>> 5 <= 3
False
Operador >=

El operador >= evalua si el valor del lado izquierdo es mayor o igual que el valor del lado derecho.

>>> 5 >= 3
True
Ejemplos

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

Ejemplo de definir variables numéricas
cadena1, cadena2 = 'Hola', 'Adiós'
lista1, lista2 = [1, 'Lista Python', 23], [11, 'Lista Python', 23]

Ejemplo de operador relacional Igual

print (c)

cadenas = cadena1 == cadena2
print (cadenas)
listas = lista1 == lista2
print (listas)
Ejemplo de operador relacional Diferente

print (d)
cadena0 = cadena1 != cadena2
print (cadena0)
Ejemplo de operador relacional Menor que

print (f)

Ejemplo de operador relacional Mayor que
print (e)

Ejemplo de operador relacional Menor o igual que
print (h)

Ejemplo de operador relacional Mayor o igual que
print (g)

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código operadores_relacionales.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python operadores_relacionales.py

Tipo números

Estos tipos de datos se crean mediante literales numéricos y se devuelven como resultados por operadores aritméticos y funciones aritméticas integradas. Los objetos numéricos son inmutables; Una vez creado su valor nunca cambia.

Por supuesto, los números de Python están fuertemente relacionados con los números matemáticos, pero están sujetos a las limitaciones de la representación numérica en las computadoras.

Python distingue entre enteros, números de punto flotante y números complejos:



Enteros

Los números enteros son aquellos que no tienen decimales, tanto positivos como negativos (además del cero). En Python se pueden representar mediante el tipo int (de integer, entero) o el tipo long (largo). La única diferencia es que el tipo long permite almacenarnúmeros más grandes. Es aconsejable no utilizar el tipo long a menos que sea necesario, para no malgastar memoria.

El tipo int de Python se implementa a bajo nivel mediante un tipo long de C. Y dado que Python utiliza C por debajo, como C, y a diferencia de Java, el rango de los valores que puede representar depende de la plataforma. En la mayor parte de las máquinas el long de C se almacena utilizando 32 bits, es decir, mediante el uso de una variable de tipo int de Python puede almacenar números de -231 a 231 – 1, o lo que es lo mismo, de -2.147.483.648 a 2.147.483.647. En plataformas de 64 bits, el rango es de -9.223.372.036.854.775.808 hasta 9.223.372.036.854.775.807.

Ejemplo de enteros

A continuación, se presentan un ejemplo de su uso:
Ejemplo de definición de un tipo entero
print (entero, type(entero))

Enteros long

El tipo long de Python permite almacenar números de cualquier precisión, limitado por la memoria disponible en la máquina.

Al asignar un número a una variable esta pasará a tener tipo int, a menos que el número sea tan grande como para requerir el uso del tipo long.

>>> entero = 23
>>> type(entero)


También puede indicar a Python que un número se almacene usando long añadiendo una L al final:

>>> entero = 23L
>>> type(entero)


El literal que se asigna a la variable también se puede expresar como un octal, anteponiendo un cero:

# 027 octal = 23 en base 10
entero = 027
o bien en hexadecimal, anteponiendo un 0x:

# 0x17 hexadecimal = 23 en base 10
entero = 0x17
Ejemplo de enteros long

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

Ejemplo de definición de un tipo entero long

print (float_1, type(float_1))
print (float_2, type(float_2))

Coma flotante

Los números reales son los que tienen decimales. En Python se expresan mediante el tipo float. En otros lenguajes de programación, como C, tiene también el tipo double, similar a float pero de mayor precisión (double = doble precisión).

Python, sin embargo, implementa su tipo float a bajo nivel mediante una variable de tipo double de C, es decir, utilizando 64 bits, luego en Python siempre se utiliza doble precisión, y en concreto se sigue el estándar IEEE 754: 1 bit para el signo, 11 para el exponente, y 52 para la mantisa. Esto significa que los valores que puede representar van desde ±2,2250738585072020 x 10-308 hasta ±1,7976931348623157×10308.

La mayor parte de los lenguajes de programación siguen el mismo esquema para la representación interna. Pero como muchos sabréis esta tiene sus limitaciones, impuestas por el hardware.

Por eso desde Python 2.4 cuenta también con un nuevo tipo Decimal, para el caso de que se necesite representar fracciones de forma más precisa. Sin embargo este tipo está fuera del alcance de este tutorial, y sólo es necesario para el ámbito de la programación científica y otros relacionados.

Para aplicaciones normales puedes utilizar el tipo float sin miedo, como ha venido haciéndose desde hace años, aunque teniendo en cuenta que los números en coma flotante no son precisos (ni en este ni en otros lenguajes de programación).

Para representar un número real en Python se escribe primero la parte entera, seguido de un punto y por último la parte decimal.

real = 0.2703

También se puede utilizar notación científica, y añadir una e (de exponente) para indicar un exponente en base 10. Por ejemplo:

real = 0.1e-3
sería equivalente a 0.1 x 10-3 = 0.1 x 0.001 = 0.0001

Ejemplo de enteros float

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

Ejemplo de definición de tipo entero coma flotante

# Este número tiene un exponente en base 10
# es decir, multiplicado por 10 a la N
real = 0.56e-3
print (real, type(real))

Ejemplo de definición de tipo entero coma flotante con exponente en base 10

print (complejo, complejo.imag, complejo.real, type(complejo))

Complejos

Los números complejos son aquellos que tienen parte imaginaria. Si no conocías de su existencia, es más que probable que nunca lo vayas a necesitar, por lo que puede saltarte este apartado tranquilamente.

De hecho la mayor parte de lenguajes de programación carecen de este tipo, aunque sea muy utilizado por ingenieros y científicos en general.

En el caso de que necesite utilizar números complejos, o simplemente tiene curiosidad, este tipo, llamado complex en Python, también se almacena usando coma flotante, debido a que estos números son una extensión de los números reales.

En concreto se almacena en una estructura de C, compuesta por dos variables de tipo double, sirviendo una de ellas para almacenar la parte real y la otra para la parte imaginaria.

Los números complejos en Python se representan de la siguiente forma:

complejo = 2.1 + 7.8j

Ejemplo de enteros complex

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

Ejemplo de definición de tipo entero complejos

Convertir a numéricos

Para convertir a tipos numéricos debe usar las siguientes funciones integradas en el interprete Python:

La función int() devuelve un tipo de datos número entero.
La función long() devuelve un tipo de datos número entero long.
La función float() devuelve un tipo de datos número entero float.
La función complex() devuelve un tipo de datos número complejo.

Ayuda integrada

Usted puede consultar toda la documentación disponible sobre las números enteros desde la consola interactiva de la siguiente forma:

>>> help(int)
Para salir de esa ayuda presione la tecla q.

Usted puede consultar toda la documentación disponible sobre las números enteros long desde la consola interactiva de la siguiente forma:

>>> help(long)
Para salir de esa ayuda presione la tecla q.

Usted puede consultar toda la documentación disponible sobre las números coma flotante desde la consola interactiva de la siguiente forma:

>>> help(float)
Para salir de esa ayuda presione la tecla q.

Usted puede consultar toda la documentación disponible sobre las números complejos desde la consola interactiva de la siguiente forma:

>>> help(complex)
Para salir de esa ayuda presione la tecla q.

Truco Para más información consulte las funciones integradas para operaciones numéricas.

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco Para ejecutar el código tipo_numericos.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_numericos.py

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.



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 caracteres, tuplas, listas, diccionarios 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)

>>> str(True)
'True'
>>> type(str(True))

>>>
>>> type(False)

>>> str(False)
'False'
>>> type(str(False))


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

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

Ejemplo de operadores booleanos

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")

Ayuda integrada

Usted puede consultar toda la documentación disponible sobre los booleanos desde la consola interactiva de la siguiente forma:

>>> help(bool)
Para salir de esa ayuda presione la tecla q.

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código tipo_booleanos.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_booleanos.py

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)
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)

>>> vocales = U"äóè"
>>> type(vocales)


Cadenas de escape

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



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 carácteres 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

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 cadenas de caracteres con comillas simples

# Comillas dobles
Ejemplo de cadenas de caracteres con comillas dobles

# Cadena con código escapes
Ejemplo de cadenas de caracteres con código escapes

# Cadena varias lineas
Ejemplo de cadenas de caracteres con varias lineas

linea 3
linea 4
.
.
.
.
.
linea N"""
print (cadena4 + ",", type(cadena4))

# Repetición de cadena con el operador de multiplicación
Ejemplo operadores de repetición de cadenas de caracteres

# Concatenación de cadena
Ejemplo operadores de concatenación de cadenas de caracteres

print (nombre_completo + ",", type(nombre_completo))

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

# Acceder a rango de cadena
Ejemplo de acceder a rango de la cadena

# Formato de impresión de cadena usando la función format()
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

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)
Para salir de esa ayuda presione la tecla q.

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código tipo_cadenas.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_cadenas.py

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 "", line 1, in
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 "", line 1, in
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 establecer una colección ordenada/arreglos o vectores

# Acceder a un elemento especifico
Ejemplo de acceder a un elemento especifico de una lista

# Acceder a un elemento a una lista anidada
Ejemplo de acceder a un elemento a una lista anidada

# Establecer nuevo valor de un elemento de lista
Ejemplo de establecer nuevo valor de un elemento de lista

lista[1] = "CMS"

# Obtener un rango de elemento especifico
Ejemplo de obtener un rango de elemento especifico

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

l5 = lista[1::2]
print (l5)

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.

Ayuda integrada

Usted puede consultar toda la documentación disponible sobre las listas desde la consola interactiva de la siguiente forma:

>>> help(list)

Importante

Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código tipo_listas.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_listas.py

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 "", line 1, in
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 simple de tupla

# Ejemplo de tuplas anidadas
Ejemplo de tuplas anidadas

# operación asignación de valores de una tupla en variables
Operación asignar de valores de una tupla en variables

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:

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:

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""")

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

Ayuda integrada

Usted puede consultar toda la documentación disponible sobre las tuplas desde la consola interactiva de la siguiente forma:

>>> help(tuple)
Importante
Usted puede descargar el código usado en esta sección haciendo clic aquí.

Truco

Para ejecutar el código tipo_tuplas.py, abra una consola de comando, acceda al directorio donde se encuentra el mismo, y ejecute el siguiente comando:
python tipo_tuplas.py

Tipo diccionarios





































© 2019 Dance School. All Rights Reserved | Design by W3layouts