Escribir su primer programa en Python

arearect.py
# The program calculates area of rectangle
l=8
b=5
a=l*b
print ("Area of rectangle is ", a)
seleccione Ejecutar> Módulo Ejecutar en el menú o simplemente presione F5. Usted
recibirá el
siguiente resultado:

Area of rectangle is 40

Elementos básicos en un programa

literales
Un literal es un número o una cadena que aparece directamente en un
programa. Los siguientes son todos los literales en Python:

10
# Integer literal
10.50
# Floating-point literal
10.50j
# Imaginary literal
'Hello'
# String literal
"World!"
# String literal
'''Hello World!
It might rain today
# Triple-quoted string literal
Tomorrow is Sunday'''
En Python, puede usar tanto comillas simples y dobles para representar cadenas.
Las cadenas que se ejecutan a través de múltiples líneas están representados por
comillas triples.

Variables
Las variables se utilizan para almacenar datos en un programa. Para definir una
variable, se elige un nombre para la variable y, a continuación, utiliza el signo
igual seguido de los datos que almacena. Las variables pueden ser letras,
números o palabras. Por ejemplo,
l = 10
length = 10
length_rectangle = 10.0
k="Hello World!"
Se puede ver en los ejemplos anteriores la variable puede ser un solo carácter o
una palabra o palabras unidas por guiones bajos. En función de los datos
almacenados en una variable, que se ha denominado como número entero, punto
flotante, cadena, booleano, y la lista o tuplas. Al igual que en los ejemplos
anteriores, las variables l y la duración son variables enteras, length_rectangle
es
una variable de punto flotante, y k es una variable de cadena. Los siguientes son
ejemplos de boolean, lista, y las variables de tupla:
a=True # Boolean variable
b=[2,9,4] # List variable
c=('apple', 'mango', 'banana') # tuple variable
A tuple in python language refers to an ordered, immutable (non
changeable) set of
values of any data type.

Keywords - Palabras clave

Python tiene 30 palabras clave, que son identificadores que Python se reserva
para uso especial. Palabras clave contienen sólo letras minúsculas. No puede
utilizar palabras clave como identificadores regulares. Las siguientes son las
palabras clave de Python:
and assert break class continue def del elif else except exec finally for
from global if import in is lambda

Comments
# This program computes area of rectangle
a=b+c # values of b and c are added and stored in a

Printing
Para los mensajes de impresión y los resultados de los cálculos, la función print
() se utiliza con la siguiente sintaxis,

print(["message"][variable list])
donde el message es la cadena de texto encerrada entre comillas simples o
dobles. La lista de variables puede ser una o más variables que contienen el
resultado de cálculo, como se muestra en estos ejemplos:
print
print
print
print

("Hello World!")
(10)
(l)
("Length is ",l)

Puede mostrar un mensaje de texto, valores constantes, y los valores de

variables a través de la sentencia print, como se muestra en los ejemplos
anteriores.
Después de imprimir el mensaje / valor deseado, la función print() también
imprime el carácter de nueva línea, es decir, el cursor se desplaza a la siguiente
línea después de mostrar el mensaje / valor requerido. Como resultado, el
mensaje / valor visualizado a través de la siguiente funcion print() aparece la
función en la línea siguiente. Para suprimir la impresión del carácter de nueva
línea, poner fin a la línea de impresión con end = " " seguido de una coma (,)
después de la expresión para que la función print() imprime un espacio extra en
lugar de un carácter de nueva línea.
Por ejemplo, las cadenas mostradas a través de los dos funciones siguientes de
print() aparecerán en la misma línea con un espacio entre ellos:

print("Hello World!", end=" “)

print('It might rain today')
También puede concatenar cadenas en la salida mediante el uso de un signo más
(+) o una coma (,) entre cadenas. Por ejemplo, la función print() siguiente
mostrará las dos cadenas en la misma línea, separadas por un espacio:

print('Hello World!', 'It might rain today')

La siguiente declaración se funde los dos mensajes y las muestra sin
ningún espacio entre ellos:

print('Hello World!'+'It might rain today')

También puede concatenar cadenas en la salida mediante el uso de un signo más
(+) o una coma (,) entre cadenas. Por ejemplo, la función print() siguiente
mostrará las dos cadenas en la misma línea, separadas por un espacio:

print('Hello World!', 'It might rain today')

La siguiente declaración se funde los dos mensajes y las muestra sin ningún
espacio entre ellos:

print('Hello World!'+'It might rain today')

Con el fin de obtener un espacio entre las cadenas, hay que concatenar un
espacio en blanco entre las cadenas:

print('Hello World!'+ ' '+ 'It might rain today')

También puede utilizar una coma para la visualización de los
valores de las variables, junto con las cadenas:
print ("Length is ", l, " and Breadth is ", b)
Suponiendo que los valores de las variables L y B son 8 y 5,
respectivamente, la declaración anterior se mostrará el
siguiente resultado:
Length is 8 and Breadth is 5
También puede utilizar códigos de formato (%) para la
sustitución de los valores en las variables en el lugar
deseado en el mensaje:
print ("Length is %d and Breadth is %d" %(l,b))
donde %d es un código de formato que indica un número entero
tiene que ser sustituido en su lugar. Es decir, los valores
de las variables L y B sustituirán a los códigos de formato
respectivos.
Note
Si el tipo de datos de los valores de las variables no
coincide con los códigos de formato, conversión automática se
lleva a cabo.
La lista de los códigos de formato es como se muestra en la
Tabla 1.1. Usted va a aprender a aplicar los códigos de
formato en el próximo capítulo.
El programa siguiente muestra cómo utilizar la función
print() para la visualización de salida diferente:
printex.py
print (10)
print('Hello World! \
It might rain today. \
Tomorrow is Sunday.')
print('''Hello World!
It might rain today.
Tomorrow is Sunday.''')
Output:
10
Hello World! It might rain today. Tomorrow is Sunday.
Hello World!
It might rain today.
Tomorrow is Sunday.

Chapter 2. Getting Wet in Python

Capítulo 2. Mojarse en Python
En este capítulo se tratan los siguientes temas:
• Realizar operaciones aritméticas
• Usar secuencias de escape
• Viendo Valores octales y hexa
• Realizar operaciones bit a bit
• El uso de números complejos
• Toma de decisiones: si ... Else
• Usando Loops: while y for Loops
• Romper y continua de un bucle
• Uso de operadores: Operadores lógicos y operadores de membresía

Performing Arithmetic Operations

Realizar operaciones aritméticas
Los operadores aritméticos juegan un papel importante en la
programación, y es esencial para entender el uso de los diferentes
operadores para la programación eficiente.
Python proporciona varios operadores aritméticos para realizar
diferentes operaciones en datos numéricos. La lista de operadores
aritméticos utilizados en Python se muestra en la Tabla 2.1.

La Tabla 2.1 muestra los operadores aritméticos habituales, tales

como suma, resta y multiplicación. Los operadores de multiplicación
y división tienen mayor prioridad que los operadores de suma y
resta. El operador de módulo devuelve el resto de la operación de
división. ¿Cuál es la diferencia entre el operador de división y el
operador de división truncar? Vamos a ver.

Division Operator

El operador de división truncar (//), también conocida como la

división de piso, trunca el resultado a un entero (ignorando el
resto) y funciona tanto con números enteros y números de punto
flotante. El operador de división verdadero (/) también se trunca el
resultado a un entero si los operandos son enteros. También
significa que el operador de división real devuelve un resultado de
punto flotante si cualquier operando es un número de coma flotante.

Note
Cuando ambos operandos son enteros, el operador / se comporta
como //
El siguiente programa utiliza el verdadero operador de división para
calcular el área de un triángulo.
areatriangle.py
b=17
h=13
a=1.0/2.0*b*h
print ("Area of triangle is", a)
print ("Base= %d, Height is %d, Area of triangle is %f" %(b,h,a))
Output:
Area of triangle is 110.5
Base= 17, Height is 13, Area of triangle is 110.500000

En este programa, que está utilizando el verdadero operador de

división, /, que devuelve un entero si ambos operandos son enteros.
Para obtener el resultado correcto, 1/2 se convierte en un flotador,
1.0/2.0, para que el resultado del operador de división verdad, va a
ser un flotador.
Una cosa a observar en la salida del programa es que la directiva %f
devuelve el valor flotante de hasta seis cifras decimales. ¿Puede
ser redondeado a 2 o 3 cifras decimales? Vamos a ver.
El siguiente programa calcula el promedio de los tres valores y
muestra el resultado se redondea al número deseado de cifras
decimales:

average1.py
p=q=r=10
a=1.0/3.0*(p+q+r)
print ("Average of three variables is", a)
print ("Average of three variables is %.2f" %a)
print ("Average of three variables is %d" %a)

Output:
Average of three variables is 10.0
Average of three variables is 10.00
Average of three variables is 10
En este programa, se ve que el resultado de punto flotante se
redondea a 2 lugares mediante el uso de %.2f. Además, se ve que el
valor de punto flotante se trunca a un valor decimal cuando se
aplica % e código de formato a la misma.
Mientras se utiliza el operador de división verdadera, /, es
necesario asegurarse de que alguno de los operandos es un número de
punto flotante para evitar que un entero truncar correctos. Mientras
se utiliza el operador de división cierto, es mejor comenzar el
archivo fuente con esta declaración:

from _ _future_ _ import division

Esta declaración se asegura de que el operador de división real de
trabajo sin truncamiento en operandos de cualquier tipo.
Básicamente, la declaración de __ future__ asegura que el guión
utiliza el operador de división de punto flotante de nuevo estilo.

average2.py
from __future__ import division
p=q=r=10
a=(p+q+r)/3
print ("Average of three variables is", a)
Output:
Average of three variables is 10.0

Exponentiation
Para aplicar la exponenciación, utilice dos asteriscos: **. Por
ejemplo, a ** b signifca ab .
Usted recibe una excepción si a es menor que cero y b es un valor de
punto flotante con una parte fraccional no nulo.También puede
utilizar la función incorporada pow() para aplicar exponenciación.
Por ejemplo, pow(a, b) es el mismo que a**b.
Usted aprenderá acerca de la gestión de excepciones en el Capítulo
6, "Administración de archivos."
Vamos a escribir un programa para calcular el volumen de una esfera.
La fórmula es 4/3 * pi * r3, donde se sabe que el valor de radio r
debe ser 3.

volsphere.py
from __future__ import division
r=3
pi=22/7
v=4/3*pi*pow(r,3)
print ("Volume of sphere is %.2f" %v)
Output:
Volume of sphere is 113.14
En este programa, se puede ver que r3 se calcula a través de
pow(). La expresión pow(r, 3) también puede ser sustituida por
r**3, ya que ambos hacen la misma tarea.
¿Hay alguna manera de obtener el valor de Pi en lugar de calcular
manualmente como 22/7?
Sí, el módulo de matemáticas, además de otras funciones importantes,
también proporciona el valor de pi para usar directamente en
expresiones aritméticas. Usted aprenderá acerca del módulo de
matemáticas en detalle en el Capítulo 4, "Funciones y Módulos."
Por ahora, vamos a ver cómo el valor de pi se puede utilizar a
través del módulo de matemáticas. Modificar el programa anterior
para utilizar el valor de pi proporcionada por el módulo de
matemáticas.

from __future__ import division

from math import pi
r=3
v=4/3*pi*pow(r,3)
print ("Volume of sphere is %.2f" %v)
La sentencia de import math pi importa el valor de pi del
módulo de matemáticas a ser utilizado en la expresión
aritmética. El valor representado será 3.1415926535897931

Multiple Assignment Statement

Sentencia de asignación múltiple
La sentencia de asignación básica puede hacer más que asignar el
resultado de una sola expresión a una única variable. También puede
asignar múltiples variables de una sola vez. La regla es que los
lados izquierdo y derecho deben tener el mismo número de elementos y
los valores serán asignados sobre una base de uno a uno.

Examples
p,q,r = 10,20,30
sum, avg = p+q+r,(p+q+r)/3
Los valores en el lado derecho del operador de asignación se
asignarán sobre una base de uno a uno; por ejemplo, 10 se le
asignará a la variable p, 20 se le asignará a la variable q, y así
sucesivamente.
Del mismo modo, en el segundo ejemplo, el resultado de la expresión
p + q + r se asignará a la variable de suma, y el resultado de la
expresión (p + q + r) / 3 se asigna a la variable promedio.

Using Escape Sequences

Usar secuencias de escape
Las secuencias de escape son caracteres especiales que representan
caracteres no imprimibles como tabulaciones, saltos de línea, y tal.
Estos caracteres especiales comienzan con una barra invertida.
Cuando Python ve una barra invertida, interpreta el siguiente
carácter con un significado especial. El cuadro 2.2 muestra una
lista de los caracteres de escape que se pueden usar en los scripts
de Python.
Note
En una cadena entre comillas dobles, un carácter de escape se interpreta; en
una cadena entre comillas simples, se conserva un carácter de escape.

El siguiente programa muestra el uso de secuencias de escape en un

programa:

escapeseq.py
print('Hello World\nIt\'s hot today')
print('Festival Discount\b\b\b\b\b\b\b\b\b Offer')
print("Isn't it?")
print('Isn\'t it?')
print("He said: \"I am going \"")
print('\\Text enclosed in back slashes\\')
print ('Bell sound \a')
print('Name\tEmail Address\tContact Number')

La salida se muestra en la Figura 2.1.

En la salida se ve que el texto Hello World y hace calor hoy
aparecer en dos por cuestiones de carácter de nueva línea entre
diferentes.
El texto Festival descuento aparece como Festival Offerunt porque
después de visualizar el término Festival de descuento cuando el
cursor estaba de pie después de la t carácter de la palabra
descuento, el cursor se desplaza hacia atrás nueve caracteres donde
el D es.
At the location of character D, the text Offer is displayed,
overwriting the first five characters of the word Discount and
leaving unt to appear after Offer. Displaying of the text Isn't it
twice reveals that the single quote can be displayed either when
enclosed within double quotes or when preceded by \ when enclosed
within single quotes. Similarly, you use \ to display the text I am
going enclosed within double quotes. Similarly, Text enclosed in
back slashes appears with \ on either side because of \\. The \a
escape character makes a bell sound, and \t makes Name, Email
Address, and Contact Number appear at the tab stops.

Note

El IDLE (Python GUI) no reconoce algunos caracteres de

secuencia de escape, incluyendo \a y \b. Por lo tanto, cuando
se ejecuta el programa anterior en IDLE en lugar del símbolo
del sistema, no hay sonido de campana aparecerá y obtendrá la
siguiente salida:
Hello World
It's hot today
Festival Discount••••••••• Offer
Isn' t it?
Isn' t it?
He said: "I am going "
\Text enclosed in back slashes\
Bell sound •
Name
Email Address
Contact Number
Se puede ver que \b y \a aparecer como algunos símbolos poco
comunes.

Finding a Data Type - Encontrar un tipo de datos.

Para encontrar el tipo de datos del objeto especificado, se utiliza la funcion
type(), que devuelve el tipo de datos del objeto que se le pasa.

Syntax:
type(x)
donde x es el objeto cuyo tipo de datos se devolverán. La función acepta todo
tipo de parámetros, tales como números enteros, cadenas, listas, diccionarios,
tuplas, funciones, clases y módulos.

Examples:
type(10)
type('Hello')
El programa siguiente muestra los tipos de datos enteros,
flotadores, cadenas, booleanos, y así sucesivamente.

typeexample.py
a=10
b=15.5
c="Hello"
d=[2,9,4]
e=('apple', 'mango', 'banana')
f=True
print (type(a))
print (type(b))
print (type(c))
print (type(d))
print (type(e))
print (type(f))
Output:
<class 'int' >
<class 'float'>
<class 'str' >
<class 'list' >
<class 'tuple'>
<class 'bool' >
Este programa inicializa las variables a, b, c, d, e, y
de datos enteros, punto flotante, cadena, lista, tupla,
respectivamente. A partir de entonces, el tipo de datos
variables se determina y se visualiza usando la función

f para tipos
y Booleno,
de estas
type().

Displaying Octal and Hexa Values

Viendo Valores octales y hexa
Para asignar un valor octal a una variable, el número debe estar precedido por
0o. Del mismo modo, si un número está precedido por 0x, se considera un valor
hexa. El programa siguiente muestra la conversión de un valor decimal en octal y
hexadecimal, y viceversa.

octhex.py
a=0o25
b=0x1af
print ('Value of a in decimal is', a)
c=19
print ('19 in octal is %o and in hex is %x' %(c,c))
d=oct(c)
e=hex(c)
print ('19 in octal is', d, 'and in hexa is', e)
Output:
Value of a in decimal is 21
19 in octal is 23 and in hex is 13
19 in octal is 0o23 and in hexa is 0x13
En este programa, las variables a y b se les asignan valores octales
y hexa, respectivamente. El valor octal se convierte y se muestra
como un decimal. Del mismo modo, el valor decimal 19 se convierte en
octal y hexa y visualiza usando las directivas %O y % x,
respectivamente. Además, mediante el uso de las funciones oct() y
hex(), el número 19 se convierte a octal y hexadecimal,
respectivamente.

Getting Data - Obtención de datos

Para obtener la entrada del usuario, se utiliza el método input. Se
le pide al usuario que introduzca los datos y lee una línea de la
entrada estándar y lo devuelve como una cadena que puede ser
consecuencia asigna a una variable.

Syntax:
variable=input ('Message')
Los datos introducidos por el usuario se asigna a la variable en
formato de cadena. Si desea que los datos en otro formato (entero,
flotante, etc), se tiene que convertir de forma explícita. Antes de
ver la conversión explícita, vamos a hablar acerca de la conversión
automática (coerción) en Python.

Coercion
En Python, si usted hace algunas operaciones aritméticas sobre los
operandos del mismo tipo de datos, no hay conversión automática o la
coacción se lleva a cabo. Cuando se calculan los operandos de
diferentes tipos de datos, la coacción tiene lugar.
Python convierte el operando con el tipo "más pequeño" para el tipo
"más grande". Por ejemplo, si alguno de los operandos es un número
flotante, entonces el otro operando es también convierte a float
punto. Si el argumento es un número complejo, el otro también se
convierte en complejo.
Del mismo modo, si bien es de tipo long, el otro es convertido a
largo. Un operando entero se convierte a float mediante la adición
de 0,0 a la misma.
Un tipo no complejo se convierte en un número complejo mediante la
adición de un cero componente imaginario, 0j, a ella.
Para la conversión explícita, las funciones que se le con frecuencia
utilizando son int (), float (), y str (). La función que se
necesita para el siguiente programa es una función int().

Converting Explicitly into integer Type

Convirtiendo explícitamente en Tipo entero
Para convertir la cadena numérica o especificado en un tipo de datos
entero, utilice la función int().

int()

Los datos que se van a convertir en el número entero se pasa como

argumento a la función int().

Syntax:
int([x[, base]])
La objeto x especificado se convierte en formato entero. El
parámetro de base
26 y se refiere a
de la base es 10.
cae. Por ejemplo,

puede ser cualquier valor en el intervalo de 2 a

la base para la conversión. El valor por defecto
Si el argumento contiene una parte fraccional, se
int (7.5) devolverá 7.

El siguiente programa calcula y muestra el área de un rectángulo. El

área de un rectángulo es la multiplicación de la longitud y anchura,
y sus valores serán suministrados por el usuario.
Los valores suministrados por el usuario serán a través de la
función de input(), que devuelve los valores proporcionados en
formato de cadena y por lo tanto se convierte en el tipo de datos
entero usando la función int().

arearectinput.py
l=input("Enter length: ")
b=input("Enter width: ")
a=int(l)*int(b)
print ("Area of rectangle is",a)
Output:
Enter length: 9
Enter width: 5
Area of rectangle is 45
Los valores suministrados por el usuario serán a través de la
función de input(), que devuelve los valores proporcionados en
formato de cadena y por lo tanto se convierte en el tipo de datos
entero usando la función int().
Los valores introducidos por el usuario serán asignados a las
variables L y B, respectivamente. Como se dijo anteriormente, el
método de entrada devuelve datos en formato de cadena, por lo tanto,
los valores en las variables L y B se convierte en primer lugar de
la cadena en formato entero a través de la función int() antes de
que se utilizan en cualquier operación aritmética.
El siguiente programa calcula y devuelve el área de un círculo. La
fórmula es pi * r 2 . El r en la fórmula se refiere al radio, y su
valor será suministrado por el usuario.

areacircleinput.py
from math import pi
r=int(input("Enter radius: "))
a=pi*r*r
print ("Area of the circle is", a)
print ("Area of the circle is %.2f" %a)
Output:
Enter radius: 5
Area of the circle is 78.53981633974483
Area of the circle is 78.54

Bitwise Operations
Operaciones bit a bit
Cada numérica que se introduce en un ordenador
internamente en forma de dígitos binarios. Por
decimal 25 se representa internamente en forma
como 11001. Los operadores bit a bit operan en
binarios para dar los resultados deseados.

se representa
ejemplo, el valor
de dígitos binarios
estos dígitos

Note

Los operadores de desplazamiento y bit a bit sólo se pueden

aplicar a números enteros y números enteros largos.
Teniendo en cuenta x e y como dos operandos siguientes son los
operadores movedizas y bit a bit:
x << y (izquierda turno binario): Devuelve x con los bits
desplazados a la izquierda por lugares y. El dígito se rellena
con 0s en el lado derecho. Esta operación es el mismo que
multiplicar x por 2 ** Y.
• x >> y (desplazamiento binario derecha): Devuelve x con los
bits desplazado hacia la derecha por lugares y. Esta operación
es el mismo que dividir x por 2 ** Y.
• X & Y (AND bit a bit): Correspondiente bits de x e y se
comparan. Retorna 1 si el bit correspondiente de x e y es 1; de
lo contrario se devuelve 0.
• x | y (AND bit a bit): Correspondiente bits de x e y se
comparan. Devuelve 0 si el bit correspondiente de x y de y es
0; de lo contrario devuelve 1. Es decir, si X o Y es 1, el
operador devuelve 1
• x ^ y (exclusivo binaria AND): bits correspondientes de x e y
son en comparación. Devuelve 1 si x o y es 1; de lo contrario
devuelve 0. Esto es, el operador devuelve 0 si los bits
correspondientes de x e y son el mismo.
• ~ X (inversión bit a bit): Devuelve el complemento de x; es
decir, dígito binario 1 se convierte a 0, y 0 se convierte en
1.
El programa siguiente muestra la aplicación de AND, OR,
Operadores de desplazamiento EXCLUSIVOS Y, e izquierda y derecha.
•

bitwise.py
a=10
b=7
c=a&b
d=a ^ b
e= a | b
print ('The result of 10 and 7 operation is', c)
print ('The result of 10 exclusive or 7 operation is' , d)
print ('The result of 10 or 7 operation is', e)
g=a<<2
print ('Left shifting - Multiplying 10 by 4 becomes:' , g)
h=a>>1
print ('Right shifting - Dividing 10 by 2 becomes:',h)
Output:
The result of 10 and 7 operation is 2
The result of 10 exclusive or 7 operation is 13
The result of 10 or 7 operation is 15
Left shifting - Multiplying 10 by 4 becomes: 40
Right shifting - Dividing 10 by 2 becomes: 5
Los enteros 10 y 7 y el resultado de la aplicación del operador
&(AND) en ellos se muestran en la Figura 2.2 (a). La figura muestra
que el operador AND devuelve 1 si ambos enteros son 1; de lo
contrario devuelve 0. Figura 2.2 (b) muestra el resultado de aplicar
el operador exclusiva o en los dos enteros, 10 y 7. Usted puede ver
que el operador OR exclusivo devuelve 1 si cualquiera de los dos
enteros es 1.
Figura 2.2 (c) muestra el resultado de aplicar el operador OR;
devuelve 1 si uno o ambos de los números enteros son 1.

Figura 2.3 (a) muestra el resultado de la izquierda cambiando el

valor de 10 por 2. Usted puede ver que dos 0s se añaden a la derecha
del número. En cada desplazamiento a la izquierda, el valor del
número se multiplica por 2. Es decir, a la izquierda, cambiará el
número por dos, el número se multiplica por 4, dando el resultado
como 40.
Figura 2.3 (b) muestra el número 10 se movió un poco hacia la
derecha. El bit más a la derecha del número se redujo, y un 0 se
añade a su izquierda, dividiendo el número por 2 y dar el resultado
como 5.

Complex Numbers
Un número complejo es la combinación de un real y una imaginaria
componente, donde ambos están representados por-punto flotante tipo
de datos. El componente imaginaria del número complejo es un
múltiplo de la raíz cuadrada de menos uno y se denota por j.

Example:
3+1.2j
En este ejemplo, 3 es un componente real, y 1,2 es el
componente imaginario y es igual a 1,2 × √ -1.
Los componentes real e imaginaria de un objeto complejo se
puede acceder mediante el uso de sus atributos real y imag.
El siguiente programa muestra la suma de dos números complejos:

complex.py
a = 3.0 + 1.2j
b= -2.0 - 9.0j
print
c=a+b
print
print
print

('The two complex numbers are', a, 'and', b)

('The addition of two complex numbers is:', c)
('The addition of two real numbers is:', a.real+b.real)
('The addition of two imaginary number is:', a.imag+b.imag)

Output:
The
The
The
The

two complex
addition of
addition of
addition of

numbers are (3+1.2j) and (-2-9j)

two complex numbers is: (1-7.8j)
two real numbers is: 1.0
two imaginary number is: -7.8

Este programa define dos números complejos, a y b. Los componentes

real e imaginaria del número complejo son un 3,0 y 1,2,
respectivamente. Del mismo modo, los componentes real e imaginaria
del número complejo B son -2,0 y -9,0, respectivamente. Mientras que
la adición del complejo números, se añaden los respectivos
componentes reales e imaginarias de los dos números complejos, como
se muestra en la Figura 2.4. El programa también tiene acceso a los
componentes reales e imaginarias de los dos números complejos
mediante la adición de sus atributos reales y imag.

Note
Los números complejos se muestran entre paréntesis()
Al escribir programas, se encuentra con una situación en la que se
desea ejecutar una sentencia de bloque de los dos bloques. Es decir,
es necesario controlar el flujo del programa y ejecute una
instrucción de bloque de opciones disponibles, dependiendo de las
condiciones prevalecientes. Vamos a ver cómo tomar decisiones en
Python.

Making Decisions
Toma de decisiones
La afirmación de que ayuda en la toma de decisiones y el control de
flujo del programa es la instrucción if ... else.

if...else statement
La instruccion if ... else decide que el bloque de instrucciones que
se ejecutarán sobre la base de la expresión lógica incluido.
Un bloque de instrucciones se adjunta con el caso, así como con los
demás, y cuando se evalúa la expresión lógica, ya sea el caso de if
o de else sera ejecutado.

Syntax:
if (logical expression):
statement(s)
else:
statement(s)
Si la expresión lógica se evalúa como true, la sentencia if es
ejecutado; de lo contrario, se ejecuta la sentencia else.

Note
The else statement is optional.
Vamos a escribir un programa que pide al usuario que introduzca las
calificaciones del estudiante. Si las calificaciones son mayores o
iguales a 60, el programa debe mostrar un mensaje, Primera División.
Si no es así, se debe mostrar el mensaje de la Segunda División.

ifelse1.py
m=int(input("Enter grades: "))
if(m >=60):
print ("First Division")
else:
print ("Second Division")
Output:
Enter grades: 75
First Division
Enter grades: 50
Second Division
Se puede ver en este programa que el usuario introduce los grados a
través de un método de input(). Dado que el valor introducido por el
input() es en formato de cadena, se convierte a entero y se asigna a
la variable m. El uso de una instrucción if ... else, se comprueba
el valor de m variables. Si el valor en la variable m es mayor que o
igual a 60, el Si se ejecuta el bloque, la visualización de la
primera división mensaje.
Si el valor introducido es inferior a 60, el bloque else va a ser
ejecutado, muestra el texto Segunda División. La salida del programa
confirma esto.
En este programa, mayor que o igual a (> =) compara el valor de la
variable m con 60. Tabla 2.3 se enumeran los operadores de
comparación.

En el próximo programa, de nuevo le pide al usuario que introduzca

las calificaciones del estudiante. Si los grados introducidos son
mayores que o igual a 60, un mensaje de la Primera División se
mostrará.
Si las calificaciones registradas son mayores que o igual a 45 pero
inferior a 60, la Segunda División de mensaje se mostrará. Si las
calificaciones registradas son menos de 45, la Tercera División se
mostrará. Para este tipo de programas, es un nido if ... else bloque
dentro del bloque else del exterior if... else. Vamos a ver cómo
esta anidación se hace en el siguiente programa:

ifelse2.py
m=int(input("Enter grades: "))
if(m >=60):
print ("First Division")
else:
if(m >=45):
print ("Second Division")
else:
print ("Third Division")

Output:
Enter grades: 75
First Division
Enter grades: 50
Second Division
Enter grades: 40
Third Division
Se puede ver en este programa que una instrucción if
se escribe dentro de una sentencia más de lo externo
else. El si ... else ejecutará sentencia else dentro
sentencia else if la expresión lógica incluida en el
sentencia if se evalúa como False

... else
if ...
de la
exterior

Es decir, si el usuario introduce un valor inferior a 60, el

interior de if ...else se ejecutará para comprobar si el valor
introducido es mayor que 45, y se mostrará el mensaje
correspondiente.

if-elif-else statement
Si tiene varias expresiones lógicas para evaluar, y sobre la base de
esas expresiones lógicas que desea ejecutar un conjunto específico
de bloque de código, es necesario utilizar una sentencia if-elifelse

Syntax:
if (logical expression):
statement(s)
elif (logical expression 1):
statement(s)
[elif (logical expression n):
statement(s)]
else:
statement(s)
Se puede ver que la sentencia else y la sentencia if anidado
en ella se fusionan para formar una declaración elif. Una
declaración elif es útil para evitar el sangrado excesivo. El
ifelse2.py programa que usted escribió anteriormente puede
reescribirse con una instrucción if-elif-else, como se
muestra aquí:
ifelif.py
m=int(input("Enter grades: "))
if(m >=60):
print ("First Division")
elif (m >=45):
print ("Second Division")
else:
print ("Third Division")
¿Qué pasa si necesita combinar más de una expresión lógica? Utilice
los operadores lógicos para conectar las expresiones lógicas. Vamos
a echar un vistazo rápido a los operadores lógicos.

Logical Operators
Al escribir expresiones lógicas, a veces es necesario combinar dos o
más lógicas expresiones. Las expresiones lógicas se suelen combinar
con los operadores lógicos AND, OR y NOT. La lista de operadores
lógicos con una breve descripción se muestra en la Tabla 2.4.

Considere la lógica expresiones x e y conectado con el operador

lógico AND como se muestra a continuación:

x and y
En la combinación de las expresiones lógicas por el operador lógico
AND, primero se evalúa la expresión lógica x, y si devuelve false,
el resultado de la combinación será x; de otro modo, el resultado
será Y.
Del mismo modo, en la combinación de las expresiones lógicas x e y
por el operador lógico OR, primero se evalúa la expresión lógica x,
y si el resultado es true, el resultado de la combinación será x; de
otro modo, el resultado será Y.
El ifelse2.py programa que usted escribió anteriormente puede
reescribirse combinando las expresiones lógicas con operadores
lógicos:

ifelse3.py
m=int(input("Enter grades: "))
if(m >=60):
print ("First Division")
if(m >=45 and m<60):
print ("Second Division")
if (m<45):
print ("Third Division")
Usted ve que si el grado introducido es mayor que 60, el primer caso
se ejecutará el bloque, mostrando la primera división mensaje. Si la
calificación introducido es mayor que 45 y menor de 60, ambas
expresiones lógicas, m> = 45 y m <60, que es verdadero, y el mensaje
en el segundo bloque if, Segunda División, se mostrará. Si la nota
introducida es inferior a 45, el tercer bloque if se ejecutará,
mostrando el mensaje de la Tercera División.

Chaining Comparison Operators

Encadenamiento de Operadores de comparación
Considere los siguientes operadores de comparación, que están
conectados con el operador AND:

x<=y and y<=z

Estos operadores de comparación se pueden encadenar como

x<=y <=z
Como era de esperar, si la expresión lógica x <= y es cierto,
entonces sólo la expresión lógica y <= z se evaluará.
Por ejemplo, la declaración se utiliza en el programa anterior, m> =
45 y m <60, se pueden encadenar para que aparezca como 45 <= m <60.
Vamos a volver a escribir el programa por el encadenamiento de los
operadores de comparación.

ifelschaining.py
m=int(input("Enter grades: "))
if(m >=60):
print ("First Division")
if(45<= m <60):
print ("Second Division")
if(m<45):
print ("Third Division")
Si el grado introducido es mayor que o igual a 45, la siguiente
parte de los operadores de cadena se evalúa para ver si el valor
introducido es menos de 60.
El siguiente programa pide al usuario que introduzca un valor entre
1 y 10 e imprime un mensaje basado en el valor introducido:

opr1.py
m=int(input("Enter a number between 1 and 10: "))
if 1<= m <=10:
print ("Number is within range")
else:
print ("Number is out of range")
Output:
Enter a number between 1 and 10: 3
Number is within range
Enter a number between 1 and 10: 15
Number is out of range
Se puede ver que el programa imprime el número de mensajes está
dentro del rango si el valor introducido es entre 1 y 10; de lo
contrario, se imprime el número de mensajes está fuera de rango
El siguiente programa determina si el valor introducido es par o
impar. El programa utiliza el operador de módulo,%. Recuerde que el
operador módulo devuelve el resto de la división.

evenodd.py
m=int(input("Enter a number "))
n = m%2
if n ==0:
print ("Number is even")
else:
print ("Number is odd")
Output:
Enter a number 6
Number is even
Enter a number 9
Number is odd
En este programa, se pide al usuario que introduzca un número que se
asigna a la variable m. La variable m se divide por 2, y si el resto
es 0, es decir, el número es un múltiplo de 2, un número de mensaje
es incluso se muestra. Del mismo modo, si el resto de la operación
de división no es 0, el número no es múltiplo de 2, y el número es
impar se muestra.

Note
Python proporciona una función DIVMOD, que tiene dos numérica
argumentos y devuelve el cociente y el resto, por lo que no
tiene que usar tanto / / para el cociente y el% para el resto
Al escribir programas, a veces desea ejecutar algunas declaraciones
en varias ocasiones. Para tales situaciones, se utiliza bucles.
Vamos a ver cómo utilizar bucles en Python.

Loops- Bucles
Loops se utilizan para ejecutar un conjunto de instrucciones
mientras una expresión lógica es verdadera. Usted aprenderá dos
lazos en esta sección: el bucle while y el bucle for.

The while Loop

Un bucle while se ejecuta repetidamente un bloque de código mientras
una expresión lógica especificada siendo cierto.
La expresión lógica en un bucle while se evalúa en primer lugar, y
si se evalúa como falsa, el cuerpo del bucle while no se ejecutará.
Si la expresión lógica se evalúa como verdadera, se ejecuta el
bloque de código en el bucle while.
Después de ejecutar el cuerpo, el control salta de nuevo al
principio del bucle para confirmar si la expresión lógica sigue
siendo cierto. El bucle continuará ejecutándose hasta que la
expresión lógica se evalúa como falsa, en cuyo caso la ejecución del
programa continúa a partir de la instrucción que sigue el bucle
while.
Syntax:
while expression :
statement1
statement2
statement3
Aquí vemos que el bloque de código en el bucle while se sangra. ¿Por
qué?

Indentation – sangría
Python utiliza sangría para expresar la estructura de bloque de un
programa. A diferencia de otros lenguajes, Python no utiliza
aparatos ortopédicos o comenzar delimitadores / fin para denotar
bloques. En su lugar utiliza la sangría para representar bloques de
instrucciones.
Un bloque es una secuencia contigua de líneas lógicas, todos con
sangría en la misma cantidad, y una línea lógica con menos sangría
termina el bloque. La primera instrucción de un bloque no debe tener
sangría-no debe comenzar con cualquier espacio en blanco. Usted
puede utilizar tabuladores o espacios para declaraciones de sangría.
Python sustituye cada ficha con hasta ocho espacios.

Note
No mezclar espacios y tabuladores para el sangrado, como
pestañas pueden ser tratados de manera diferente por
diferentes editores.
El programa siguiente muestra los números de 1 a 10 usando el bucle
while:

whileloop.py
k=1
while k <=10 :
print (k)
k=k+1
Output:
1
2
3
4
5
6
7
8
9
10
Se puede ver que el bucle while se establece para ejecutar siempre
que el valor de la variable k es menor o igual a 10. En el bucle, se
imprime el valor de la variable k y el incremento de su valor en 1
para imprimir el siguiente valor sucesivo .
También se puede ver que el bucle while termina cuando la expresión
lógica se evalúa como falsa. ¿Hay alguna otra manera de terminar un
bucle? Además, ¿y si desea saltar el bucle sobre la aparición de
alguna condición? La siguiente sección explica cómo terminar y pase
un bucle.

Breaking and Continuing a Loop

Romper y continua de un bucle
Hay dos situaciones en las que un ciclo termina y sale de un bucle:
cuando la expresión lógica se evalúa como falsa, y en presencia de
una sentencia break en el bucle.

The break Statement - La sentencia break

La instrucción break termina y sale del bucle actual y continúa con
la ejecución del programa de la instrucción que sigue el bucle.
Normalmente se utiliza en un bucle infinito.

Syntax:
break
El programa siguiente muestra cómo utilizar una sentencia break para
terminar un bucle while para imprimir 10 números:

breakex1.py
k=1
while 1 :
print (k)
k=k+1
if(k>10):
break
Output:
1
2
3
4
5
6
7
8
9
10
Inicializa la variable k al valor 1. Además, se establece un bucle
while para ejecutar infinitamente. En el bucle, se muestra variable
k y luego incrementas su valor en 1. Cuando k se convierte en más de
10, que sale del bucle infinito a través de la sentencia break.
Recuerde que el valor 1 representa el valor true. También puede
reemplazar while 1 por while True para crear un bucle infinito.
Ahora echemos un vistazo a la declaración que le dice a Python para
omitir la parte del bucle actual y comenzar con la siguiente
iteración.

The continue Statement - La sentencia continue

La sentencia continue detiene la ejecución de la iteración actual
saltarse el resto del bucle y continuar la ejecución del bucle con
el siguiente valor iterativo.

Syntax:
continue
El siguiente programa imprime los números del 1 al 10, excepto para
el valor 7:

continueex.py
k=1
while k <=10 :
if k==7:
k+=1
continue
print (k)
k=k+1
Output:
1
2
3
4
5
6
8
9
10
En primer lugar, inicializar variable k para 1. Entonces, establecer
el bucle while para ejecutar siempre y cuando k es menor que o igual
a 10. En el bucle while, imprima el valor de k y luego incrementar
su valor en 1. Asimismo, omita el cuerpo del bucle a través de una
sentencia continue cuando el valor de k es 7. Es decir, no se
imprimen k pero sólo se incrementa su valor en 1 para ejecutar el
bucle con el siguiente valor de la secuencia.

The pass Statement

La sentencia pass se utiliza en Python para indicar un bloque vacío
de enunciados. También se utiliza como marcador de posición para el
código que desea escribir más adelante y actúa como un recordatorio
de que un programa se puede ampliar.
Puede volver a escribir el programa anterior para mostrar los
números del 1 al 10, excepto para 7 mediante la instrucción de pass,
como se muestra aquí:

passex1.py
k=1
while k <=10 :
if k==7:
pass
else:
print (k)
k+=1
Output:
1
2
3
4
5
6
8
9
10
Se puede ver que el valor de k se inicializa a 1. El bucle
while se ejecutará hasta k se hace mayor que 10. En el bucle
while, se muestra el valor de k, y su valor se incrementa en
1 cuando el valor de k es igual a 7, se ejecuta la sentencia
pass.; k no se muestra y se incrementa en 1 para ejecutar el
bucle con el siguiente valor de secuencia.

The range () Function

La función range() genera y devuelve una secuencia de números
enteros y es muy utilizado en bucle declaraciones. Hay tres
variaciones de la función range(), dependiendo del número de
parámetros pasados a la misma:
•

range (x): Devuelve una lista cuyos elementos son

números enteros consecutivos desde 0 (incluidas) para x
(no incluidos).
range (x, y): Devuelve una lista cuyos elementos son
números enteros consecutivos de x (incluidas) a y
(excluido). El resultado es una lista vacía si x es
mayor o igual a y.
range(x, y, paso): Devuelve una lista de enteros de x
(incluido) a y(excluido), y la diferencia entre cada
valor sucesivo es el valor definido por paso. Si el paso
es menor que 0, rango de una cuenta atrás de x a y, La
función return de una lista vacía cuando x es mayor o
igual a y y paso es mayor que 0, o cuando x es menor que
o igual a Y y el paso es menor que 0. 0 Si se especifica
como el valor de paso, la función range() genera una
excepción. Cuando no se especifica el paso, su valor por
defecto es 1.

The for Loop

El bucle for itera a través de una secuencia de objetos. Una
secuencia es un objeto de contenedor que puede ser en forma de una
lista, tupla o cadena.

Note
Contenedores en Python comprende el conjunto, secuencias, como
listas, tuplas, y cadenas, y las asignaciones, como diccionarios.
Usted aprenderá acerca de estos contenedores en detalle en el
Capítulo 3, "Secuencias".

Syntax:
for iterating_var in sequence:
statement1
statement2
statement3
El primer elemento de la secuencia se asigna a la variable de
iteración iterating_var y se ejecuta el bloque de instrucciones. Uno
por uno, cada elemento de la secuencia se asigna a iterating_var, y
el bloque de instrucciones se ejecuta hasta que se termine toda la
secuencia.
El programa siguiente muestra los números de 1 a 10:

forloop.py
for i in range(1,11):
print (i)
Esto imprime una secuencia de números, que se generan de 1 a 10
utilizando la función integrada range(). Dado que no se indica el
valor de paso, el valor por defecto de 1 es el valor del paso.
El programa siguiente muestra los números impares entre 1 y 10. Los
dos valores impares sucesivos difieren en 2, por lo que utilizan el
valor de paso de 2 en la funcion range().

forloop2.py
print ("Odd numbers between 1 and 10 are:")
for i in range(1,11,2):
print (i)
Output:
Odd numbers between 1 and 10 are:
1
3
5
7
9
La función range(1,11,2) en primer lugar generar un valor de 1. A
este valor se añadirá el valor del paso 2 para generar el siguiente
valor de la lista, 3. El proceso continuará hasta que el valor
generado es menor o igual a 10.
Un bucle se puede utilizar para imprimir valores aleatorios a partir
de una tupla. Vamos a discutir tuplas en detalle en el próximo
capítulo. Por ahora es suficiente saber que una tupla es un objeto
inmutable que se puede utilizar para representar un conjunto de
valores de cualquier tipo de datos.
Los valores o elementos de una tupla se incluyen entre paréntesis,
(). Un objeto inmutable es uno que no se puede cambiar una vez que
se haya creado. Usted va a utilizar los operadores de membresía para
mostrar los elementos de la tupla.

Membership Operators
Operadores de membresía
Pruebas de un operador de membresía para formar parte de una
secuencia, como cadenas, listas o tuplas. Hay dos operadores de
afiliación, como se muestra en la Tabla 2.5.

He aquí algunos ejemplos:

•

ab en abcde-Devuelve true porque la cadena ab se encuentra en

el abcde cadena.

2 en (10,3,5,2,1): vuelve verdaderos porque existe el valor 2

en el tupla.

bob no en ab-Devuelve true porque el bob cadena no se encuentra

en la cadena de ab.

El programa siguiente muestra los valores aleatorios incluidos en

una tupla utilizando el operador de pertenencia a través de un bucle
for:

for i in ( 7, 3, 8, 1, 4 ):
print i
Aquí usted proporciona una tupla de valores en el bucle for.
El primer valor de la tupla se asignará a la variable i, y se
ejecuta el bucle. A continuación, el siguiente valor de la tupla
será asignado a i y el bucle se ejecuta. El bucle se ejecutará con
cada valor de la tupla. En el cuerpo del bucle se muestra sólo el
valor asignado a la i, que muestra todos los valores de la tupla uno
por uno.
El programa siguiente muestra un valor aleatorio entre 1 y 9. Para
obtener valores aleatorios, utilizará una función eleccion:
choice().

The choice () Function

La funcion choice() recoge y devuelve un artículo al azar a partir
de una secuencia. Se puede utilizar con listas, tuplas, o cadenas.
Syntax:
choice(sequence)
donde la secuencia puede ser una lista, tupla o cadena.

Note
Para utilizar la función opción() en un programa, es
necesario importar un módulo random.

Example:
k=choice([2,4,6,8,10])
Usted recibirá un valor aleatorio extraído desde la secuencia
especificada, lo cual puede ser de 2, 6, o algún otro valor de la
lista.

randomnumber.py
from random import choice
k=choice(range(1,10))
print ("Random number is",k)
Output:
Random number is 4
Random number is 1
En este programa, la función range() devolverá valores entre 1 y 9.
La función choice() recogerá cualquier valor al azar de estos nueve
valores y asignarla a la variable k, que luego se muestra en la
pantalla. Cada vez que se ejecuta el programa, la función choice()
devuelve un valor aleatorio.
La siguiente imprime los números primos entre 1 y 100.

primes.py
print (1)
for i in range(2,101):
x=1
for j in range(2, i):
n=i%j
if n==0:
x=0
break
if x==1:
print (i)
Output:
1
2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

Este programa muestra el valor 1, sabiendo que es un número primo. A

continuación, utiliza un bucle para generar valores de 2 a 100, y
cada valor se asigna a la variable i. El valor de la variable i se
divide por 2 a i-1 valores. Si se divide por cualquiera de estos
valores, no es un número primo y no es visualizada. Se muestra el
valor de i variable cuando no divide por cualquier valor entre 2 y
i-1.

Summary
En este capítulo usted aprendió a aplicar operaciones aritméticas y
diferentes operadores lógicos y de membresía en programas Python.
También vio el uso de secuencias de escape. Para mejorar la
interacción con el usuario, que ha aprendido a obtener datos del
usuario y procesar los datos entrantes. Ustedes vieron la conversión
de los datos en diferentes tipos. También ha aprendido a mostrar los
valores octales y hexa, realizar operaciones a nivel de bits y
utilizar los números complejos. También vio el uso de if ... else en
la toma de decisiones. Por último se vio usando bucles while y for
para realizar tareas repetitivas.
En el próximo capítulo, usted va a aprender sobre los recipientes:
secuencias, correspondencias y conjuntos. Una secuencia incluye
cadenas, listas y tuplas, y las asignaciones incluyen diccionarios.
También aprenderá a realizar operaciones en secuencias a través de
sus respectivos métodos. Además, usted aprenderá acerca de una y
matrices bidimensionales. Por último, aprenderá a aplicar las
operaciones de conjuntos tales como los sindicatos, las
intersecciones y diferencias ..

Chapter 3. Sequences
En este capítulo se tratan los siguientes temas:
•

Cómo los datos se almacenan en una cadena

•
•
•
•
•

Creación y visualización de arrays de una y dos dimensiones

Rebanar Lista y sus métodos
Creación de tuplas y la búsqueda de elementos
Pares clave / valor y sus métodos
Operadores de la Unión, intersección y diferencia

Sequences
Una secuencia contiene objetos que se guardan en un orden
específico. Se puede identificar un objeto en una secuencia por su
ubicación de índice. Además, se puede extraer de una secuencia con
la operación de corte. En este capítulo se verá en tres ejemplos de
secuencias: listas, tuplas, y cadenas.
•
•
•

cadenas utilizan comillas, como "Hola", "Hola", "Hola" ',

"" "Hola" "".
Listas utilizan corchetes, como[Tiger, Café, 1, 'a', 10.50,
'b']
Las tuplas utilizan paréntesis, como(Tiger, Café, 1, 'a',
10.50, 'b').

Las tuplas y las cadenas son inmutables-que no pueden ser

modificados después de su creación. Se crea una copia de una cadena
o una tupla cuando se aplica a una operación para la cadena o tupla
inicial.
Una lista es mutable; puede añadir elementos, eliminar elementos
existentes o reorganizar los elementos. Todas las modificaciones de
la lista se hacen sin crear un nuevo objeto de la lista.
Las tres operaciones que se aplican comúnmente a las secuencias son
las siguientes:
1. + Va a concatenar secuencias para hacer secuencias más largas.
2. * Se utiliza con un dígito numérico para repetir la secuencia
varias veces.
3. [] Se vende a un elemento particular de la secuencia
(indexación) oun subconjunto de elementos de la secuencia
(cortar).

Note

Las posiciones se numeran desde cero en secuencias; es decir, el

primer elemento de una secuencia es al valor de índice de 0.
Strings
Una cadena es una secuencia de caracteres que se utilizan para
almacenar y representar la información de texto. Un literal de
cadena se puede encerrar en simple ('), dobles (") o comillas
triples (''') Las cadenas son inmutables en Python,. Usted no puede
modificar un objeto cadena existente Cuando se realiza una operación
en un objeto de cadena, usted. crear un nuevo objeto de cadena.
Ejemplos de cadenas en comillas simples, dobles y triples son los
siguientes:
k='Hello World!'
k="Hello World!"
k='''
Hello World!
It\' s hot today
Let\'s party '''

Para hacer que la cadena aparezca en dos líneas, puede incrustar un

salto de línea en la cadena:
k="Hello World!\nIt's hot"

Si el literal de cadena se extiende por varias líneas, utilice una

barra invertida como el último carácter de una línea para indicar
que la siguiente línea es una continuación:
k="Hello World!\
It's hot"

Para mostrar una comilla en una cadena, es necesario utilizar el

carácter de escape:
k='Isn\'t it?'
No hay necesidad de utilizar un carácter de escape para mostrar una
comilla dentro de una cadena entre comillas dobles.
k="Isn't it?"
Una cadena de triple citado puede estar encerrada en la adecuación
de los tríos de caracteres de comillas ('' 'o "" ") La cadena
literal anterior también se puede escribir como:
k="""
Hello World!
It' s hot today
Let' s party"""
En una cadena de triple comilla literal, saltos de línea en el
literal se conservan como caracteres de nueva línea. No se puede
utilizar una barra invertida en una cadena triple citado .

Note
A diferencia de otros lenguajes de programación, no hay ningún
tipo de datos de carácter independiente en Python. Un carácter
se considera una cadena de longitud uno.

¿Cómo los caracteres son almacenados en un String.

Cuando se asigna texto a una cadena, cada uno de sus personajes se
almacena en un lugar determinado índice. Por ejemplo, la declaración
k = "David" le asignará el texto David a la variable k.
Internamente, los caracteres se almacenan en la variable k, como se
muestra en la Figura 3.1.

Dónde 0,1 ... son el índice. Una cadena es terminada por un carácter
NULL, \ 0. Puede acceder a cualquier carácter de la cadena a través
de su índice. Por ejemplo, K [0] accede al primer carácter, D, K [1]
accede al segundo carácter, una, y así sucesivamente.
Cadenas de Python soportan varios métodos y funciones. ¿Cuál es la
diferencia entre las funciones y los métodos?

Diferencias entre Funciones y métodos

Una función es un módulo de código que se llama por su nombre. Puede
pasar datos a la función en forma de argumentos, y puede devolver
algún valor. Los datos que se pasan a la función tiene que ser
aprobado de forma explícita. Un método también es llamado por su
nombre y puede devolver un valor. La principal diferencia entre un
método y una función que es un método se asocia con un objeto, y el
objeto para el que se llama se pasa implícitamente a ella. También,
un método es capaz de operar en los datos que está contenida dentro
de la clase. La lista de métodos y funciones se da en la Tabla 3.1.
Encontrar la longitud de una cadena
Para encontrar el número de caracteres de una cadena, utilice la
función len(). Como se indica en la Tabla 3.1, el funcion len ()
cuenta y devuelve el número de caracteres en una secuencia (cadena,
tupla o lista). El programa para hacerlo se muestra aquí:
string1.py
n=input("Enter your name: ")
l=len(n)
print ("The name entered is", n, "and its length is", l)
Output:
Enter your name: John
The name entered is John and its length is 4
En este programa, usted le pide al usuario que introduzca una cadena
que se almacena temporalmente en una variable n. Luego, a través de
la función len(), se entera de la longitud de la cadena y lo
mostramos.
Las siguientes revisiones del programa si el valor introducido es
numérico o no numérico:
ifelse4.py
m=input("Enter marks: ")
if m.isdigit():
print ("Entered data is numeric")
else:
print ("Entered data is not numeric")
Output:
Enter marks:
Entered data
Enter marks:
Entered data

50
is numeric
fifty
is not numeric

El programa utiliza el método isdigit() para saber si el valor

introducido es un valor numérico o no. El método isdigit() devuelve
el valor true si el objeto referenciado es numérico; de otra forma
se devuelve false.
El siguiente programa muestra el uso de los métodos seguidos
upper(), lower(), title(), capitalize(), y swapcase (). Una cadena,
Hello World!, Se convierte a mayúsculas, minúsculas, mayúsculas, y
swapcase (las letras mayúsculas se cambian a minúsculas y
viceversa).
string2.py
s="Hello World!"
print ("Original String is", s)
print('String after toggling the case:', s.swapcase())
print ("String in uppercase is", s.upper())
if (s.istitle()):
print("String in lowercase is", s.lower())
print("String,", s, "is in title case:", s.istitle())
print ("String in capitalized form is", s.capitalize())
Output:
Original String is Hello World!
String after toggling the case: hELLO wORLD!
String in uppercase is HELLO WORLD!
String in lowercase is hello world!
String, Hello World! is in title case: true
String in capitalized form is Hello world!
El siguiente programa muestra el primer carácter de la cadena
introducida. Además, la cadena introducida se muestra carácter sabia
cada carácter se muestra uno por uno
characterwise.py
s=input("Enter a string: ")
n=len(s)
print ("The first character of", s, "is", s[0])
print ("The entered string will appear character wise as:")
for i in range(0,n):
print (s[i])
print ("The entered string will appear character wise as:")
for i in s:
print (i)
print ("String with its characters sorted is", sorted(s))
print ("String in reverse form is", "".join(reversed(s)))
Output:
….
A sabiendas de que el índice de una cadena está basado en cero, se
muestra el primer carácter de la cadena mediante el acceso a la
ubicación de índice 0ª. El programa también encuentra la longitud de
la cadena introducida e imprime cada uno de sus caracteres través de
su índice. Además, el programa utiliza el operador de miembro para
acceder y mostrar cada carácter de la cadena. El programa muestra
los caracteres de la cadena después de ordenar alfabéticamente. Por
último, la cadena se invierte y se muestra el uso de la función
reserved().
El siguiente programa muestra el carácter máximo y mínimo alfabético
en una cadena introducida. Además, el programa convierte el número
introducido en el tipo de datos de cadena, que cuenta el número de
dígitos, y muestra su primera cifra mediante la aplicación de las
funciones de cadena a la misma.
string3.py
s=input('Enter a string: ')
print ('The string entered is:', s)
print('The maximum alphabetical character from the string is:' , max(s))
print('The minimum alphabetical character from the string is:' , min(s))
n=int(input('Enter a number: '))
m=str(n)
print('The number in string form is', m, 'its length is', len(m), 'and its first
digit is', m[0])

Output:
Enter a string: enormous
The string entered is: enormous
The maximum alphabetical character from the string is: u
The minimum alphabetical character from the string is: e
Enter a number: 53
The number in string form is 53 its length is 2 and its first digit is 5

El programa pide al usuario que introduzca una cadena de caracteres

y muestra sus máximos y mínimos alfabéticos. Los caracteres máximos
y mínimos son los que tienen los valores más altos y más bajos
ASCII, respectivamente. Además, el programa muestra la forma de un
valor numérico se convierte introducción tipo de cadena mediante la
función str().
Una vez que el número se convierte en el tipo de cadena, se puede
aplicar una función de cadena, como len() para contar el número de
dígitos en el mismo. También se puede ver el primer dígito del
número que se accede mediante el acceso a los contenidos en la
ubicación de índice 0.
El programa siguiente muestra la concatenación de cadenas, la
aplicación del operador * para repetir una cadena varias veces y
unirse a los textos:
stringconcat1.py
s="Hello World!"
t="Nice Day"
print (s+t)
print (s+" "+t)
print (s*3)
u="#"
print('The string after joining character # to the string', t,':', u.join(t))
u="hello"
print('The string after joining word, hello to the string',t,':', u.join(t))
Output:
Hello World!Nice Day
Hello World! Nice Day
Hello World!Hello World!Hello World!
The string after joining character # to the string Nice Day : N#i#c#e# #D#a#y
The string after joining word, hello to the string Nice Day :
Nhelloihellochelloehello
helloDhelloahelloy

En este programa, las dos cadenas Hola Mundo! y Nice Day se

concatenan sin un espacio y con un espacio. A continuación, la
cadena Hello World! aparece tres veces usando el operador *. El
método join() se utiliza para demostrar unirse a un personaje a
todos los caracteres de la cadena especificada. Además, una cadena
completa se une a cada carácter de la cadena dada.
El siguiente programa pide al usuario que introduzca dos cadenas y
luego se une a una cadena a cada uno de los caracteres de otra
cadena:
stringjoin.py
p=input("Enter a string: ")
q=input("Enter another string: ")
print ("The first string is:", p)
print ("The second string is:", q)
print ("The combination is", p.join(q))
Output:
Enter a string: Hello
Enter another string: ABC
The first string is: Hello
The second string is: ABC
The combination is AhelloBHelloC

Se puede ver que las dos cadenas son introducidos Hola y ABC. La
cadena Hola se une a cada carácter de la cadena de ABC.
Haga cadenas en los métodos de soporte de Python que ayudan en la
búsqueda o la búsqueda de una subcadena en una cadena? Sí. La Tabla
3.2 muestra los métodos de las cadenas que ayudan en la búsqueda de
subcadenas de una cadena.
Table 3.2. String Methods Used to Find Substrings in
a String
El programa siguiente muestra el uso de diferentes funciones para
contar el número de las vocales en una frase:
countvowel.py
s=input('Enter a sentence: ')
n=len(s)
c=0
for i in range(0,n):
if(s[i]=='a' or s[i]=='A' or s[i]=='e' or s[i]=='E' or s[i]=='i' or
s[i]=='I' or s[i]
=='o' or s[i]=='O' or s[i]=='u' or s[i]=='U'):
c+=1
print ('The number of vowels in the sentence is' , c)
t=s.count('a', 0, n)+ s.count('A', 0, n)+ s.count('e', 0, n)+s.count('E', 0, n)+
s.count('i', 0, n)+ s.count('I', 0, n)+ s.count('o', 0, n)+ s.count('O', 0, n)+
s.count('u', 0, n)+s.count('U', 0, n)
print ('The number of vowels in the sentence is' , t)
v=s.count('a')+ s.count('A')+ s.count('e')+s.count('E')+ s.count('i' )+
s.count('I')+ s.count('o')+ s.count('O')+ s.count('u')+s.count('U')
print ('The number of vowels in the sentence is' , v)
Output:
Enter a sentence: amazing day in alaska
The number of vowels in the sentence is 8
The number of vowels in the sentence is 8
The number of vowels in the sentence is 8

En este programa, se pide al usuario que introduzca una frase.

Utilizando el índice, se accede a todos los personajes de la
sentencia para ver si es una vocal. Una variable c que se inicializa
a 0 se incrementa en 1 cada vez que una vocal se encuentra en la
frase. El programa también muestra las dos formas de utilizar la
función count() para contar las vocales en la oración.
El siguiente programa utiliza operadores de afiliación para ver si
una subcadena entrado en una cadena:
checkstr.py
m=input("Enter a string: ")
n=input("Enter a substring: ")
if n in m:
print (n, "is found in the string", m)
else:
print (n,"does not exist in the string", m)
Output:
Enter a string: education
Enter a substring: cat
cat is found in the string education
Enter a string: education
Enter a substring: cari
cari does not exist in the string education
El siguiente programa es un paso por delante del programa anterior.
No sólo informa si una subcadena se encuentra en una cadena o no,
pero también muestra que la subcadena aparece en la cadena dada, si
se comprueba. El programa utiliza el método find().
searchstr1.py
p=input("Enter a string: ")
print ("Entered String is ", p)
q=input("Enter the substring to search: ")
r=p.find(q)
if r==-1:
print (q, "not found in", p)
else:
print (q, "found in", p, "at location", r+1)
Output:
Enter a string: katherine
Entered String is katherine
Enter the substring to search: her
her found in katherine at location 4

Aquí usted le pide al usuario que introduzca una cadena principal y

una sub-cadena y asignarlos a la p de variables y q,
respectivamente. Entonces, el método find() se utiliza para buscar
en la q subcadena en la cadena p. El método find() devuelve el valor
-1 si la subcadena no se encuentra en la cadena o la ubicación más
bajo índice de donde se produce la subcadena en la cadena.
Sobre la base del valor devuelto por el método find(), ya sea un
mensaje diciendo que la subcadena no se encuentra en la cadena o la
ubicación de la ocurrencia de la subcadena en se muestra la cadena.
Usted puede usar el método find()
subcadena en la cadena dada, pero
ocurrencias de la subcadena en la
metodo count(), como se demuestra

para encontrar la ocurrencia de la

no se puede usar para contar las
cadena. Para ello, se utiliza el
en el siguiente programa:

searchstr2.py
p=input("Enter a string: ")
print ("Entered String is", p)
q=input("Enter the substring to search: ")
r=p.count(q)
if r==0:
print (q, "not found in", p)
else:
print (q, "occurs in", p, r, "times")
Output:
Enter a string: alabalabalab
Entered String is alabalabalab
Enter the substring to search: la
la occurs in alabalabalab 3 times
Este programa acepta una cadena y una subcadena desde el usuario y
utiliza el método count() para contar las apariciones de la
subcadena en la cadena dada. Aparece entonces el conteo.
¿Existe algún método de cadena para ver si una cadena comienza o
termina con un prefijo o sufijo dado? Sí, y son los siguientes:
startswith(s, [start], [end])—Devuelve true si la cadena comienza con el prefijo
especificado, de lo contrario devuelve false. El prefijo puede ser una única cadena
o una
secuencia de cadenas individuales.
endswith(suffix, [start], [end])—Devuelve true si la cadena termina con el sufijo
especificado; se devuelve false en caso contrario. La sufijo puede ser una única
cadena o
una secuencia del cadenas individuales.

El siguiente programa pide al usuario que introduzca una frase y

luego comprueba si empieza o termina con el prefijo o sufijo dado.
stringfunc2.py
s=input("Enter a sentence: ")
print ('The original sentence is:', s)
if s.startswith('It'):
print('The entered sentence begins with the word It' )
if s.startswith('It', 0, 2):
print('The entered sentence begins with the word It' )
if s.endswith('today'):
print('The entered sentence ends with the word today' )
if s.endswith('today', 10, 15):
print('The entered sentence ends with the word today' )
Output:
Enter a sentence: It is hot today
The original sentence is: It is hot today
The entered sentence begins with the word It
The entered sentence begins with the word It
The entered sentence ends with the word today
The entered sentence ends with the word today

En este programa, la frase introducida por el usuario se comprueba

para ver si se comienza con el prefijo It o ends con el sufijo de
today; a continuación, se muestra el mensaje correspondiente. El
programa muestra el uso de los metodos startswith() y endswith().
Puede que tenga que dividir una cadena en partes. O puede que tenga
que sustituir ciertos caracteres específicos o una subcadena en una
cadena con otros datos. Python proporciona métodos de cadena para
esto. La Tabla 3.3 muestra los métodos de cadena para romper una
cadena y sustitución de subcadenas.
El siguiente programa rompe la sentencia entró en palabras y
devoluciones:
splitting.py
p=input("Enter a sentence: ")
print ("The sentence entered is:", p)
print ("The words in the sentence are")
print (p.split())
Output:
Enter a sentence: It is a great day
The sentence entered is: It is a great day
The words in the sentence are
['It', 'is', 'a', 'great', 'day']
Este programa busca los espacios en blanco en la oración y la divide
en palabras a la aparición de espacios en blanco. Las palabras de la
oración se devuelven como una matriz de cadenas.:
El siguiente programa pide al usuario que introduzca un nombre que
consiste en un primer y un apellido y luego lo muestra después de
intercambiar los dos:
interchangenme.py
n=input('Enter your first name and last name: ')
k=n.partition(' ')
print('The name after interchanging first and last name:', k[2], k[0])

Output:
Enter your first name and last name: Caroline Stevens
The name after interchanging first and last name: Stevens Caroline
En este programa, los nombres y apellidos introducidos por el
usuario se asigna a la variable n. El nombre de la variable n se
divide en tres partes sobre la presencia del espacio blanco, con el
metodo partition(): el nombre, el espacio en blanco, y apellido.
Para intercambiar el nombre y apellido, se muestra la tercera parte,
seguido de la primera parte de la cadena.
El programa siguiente muestra tres métodos: partition(), replace() y
split():
breaking.py
s='education '
k=s.partition('cat')
print('The word', s, 'is partitioned into three parts')
print('The first part is', k[0], 'separator is', k[1], 'and the third part
is',k[2])
t=input('Enter a sentence: ')
print('The original sentence is', t)
print('The sentence after replacing all the characters "a" by "#" is:',
t.replace('a','#'))
print('The sentence after replacing first three "a" characters by "#" is:',
t.replace('a', '#', 3))
u=t.split(' ')
print('The words in the entered sentence are', u)
print('The words in the entered sentence are')
for i in range(0, len(u)):
print(u[i])
u=t.split(' ',1)
print('The sentence is split into two parts:', u[0], 'and', u[1])
Output:
The word education is partitioned into three parts
The first part is edu separator is cat and the third part is ion
Enter a sentence: amazing day in alaska
The original sentence is amazing day in alaska
The sentence after replacing all the characters "a" by "#" is: #m#zing d#y in
#l#sk#
The sentence after replacing first three "a" characters by "#" is: #m#zing d#y in
alaska
The words in the entered sentence are ['amazing', 'day', 'in', 'alaska']
The words in the entered sentence are
amazing
day
in
alaska
The sentence is split into two parts: amazing and day in Alaska

La cadena education se divide en tres partes en el corte de

subcadena utilizando el método partición().
Las tres partes serán edu, cat, y ion. Además, el programa utiliza
replace() para reemplazar el carácter de una en la frase de #.
El programa utiliza replace() para reemplazar sólo los primeros tres
ocurrencias de un carácter por #.
El programa divide la frase en una matriz de cadenas usando split()
y muestra sus palabras. Por último, el programa divide la frase en
dos partes sobre la ocurrencia de un espacio en blanco.
Ustedes han visto ejemplos que tienen que ver con arreglos de
caracteres. Ahora echemos un vistazo a los ejemplos que tienen que
ver con matrices de números.

Arrays
Matrices numéricas se utilizan para almacenar datos numéricos.
Puesto que no tienen caracteres NULL, arrays numéricos no son
terminados por caracteres NULL como con las cadenas, pero el
concepto de índice todavía se aplica a ellos para tener acceso a sus
elementos. Las matrices son de dos tipos, las matrices de una y de
dos dimensiones.

One-Dimensional Arrays- Matrices unidimensionales

Considere la posibilidad de una matriz numérica, p, que tiene cinco
valores numéricos:. 8, 3,1, 6, y 2 Estos valores se pueden
representar por la estructura que se muestra en la Figura 3.2.

Los valores son los índices que se pueden utilizar para acceder a
los elementos de la matriz. Es decir, p [0] será acceder al primer
elemento de la matriz 8, p [1], accederá a la segundo elemento de la
matriz 3, y así sucesivamente.
El programa siguiente muestra la creación de una matriz numérica de
cinco elementos:
numericarr.py
p= [ 0 for i in range(5) ]
print ("Enter five numbers")
for i in range(5):
p[i]= int(input())
print ("Numbers entered in the array are", p)
print ("Numbers entered in the array are")
for n in p:
print (n)
Output:
Enter five numbers
8
3
1
6
2
Numbers entered in the array are [8, 3, 1, 6, 2]
Numbers entered in the array are
8
3
1
6
2

La primera línea del programa declara que p es una matriz de 5

números. El uso de un bucle, el usuario se le pide que ingrese cinco
números que se almacenarán en los respectivos índices, p [0], p [1],
p [2], p [3] y P [4]. A continuación, se muestran los valores
numéricos de la matriz p.
Ahora vamos a ver cómo se crean matrices bidimensionales en Python.

Two-Dimensional Arrays
Arrays de dos dimensiones se dividen en filas y columnas. . Los
índices de fila y columna comienzan a valor 0 Para acceder a cada
elemento de la matriz, debe especificar dos índices; uno representa
la fila, y el otro representa la columna. Ambos se encuentran
encerrados entre corchetes.
En la figura 3.3 se ve que todos los lugares de la matriz está
representado por una fila y ubicación de la columna. El índice p [0]
[0] hace referencia al elemento almacenado en fila 0 y la posición
de columna 0. Del mismo modo, el índice p [0] [1] se refiere al
elemento que se almacena en la fila 0 y la posición primera columna
de la matriz de dos dimensiones.

El programa siguiente crea una matriz bidimensional de 3 filas y 3

columnas. El programa también calcula y muestra la suma de elementos
de la matriz.
matrix1.py
table= [ [ 0 for i in range(3) ] for j in range(3) ]
print ("Enter values for a matrix of order 3 x 3")
for d1 in range(3):
for d2 in range(3):
table[d1][d2]= int(input())
print ("Elements of the matrix are", table)
print ("Elements of the matrix are")
for row in table:
print (row)
s=0
for row in table:
for n in row:
s+=n
print ("The sum of elements in matrix is",s)

Output:
Enter values for a matrix of order 3 x 3
1
2
3
4
5
6
7
8
9 Elements of the matrix are [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Elements of the matrix are
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
The sum of elements in matrix is 45

Los datos suministrados por el usuario se introduce en la matriz de

dos dimensiones en forma importante fila (véase la Figura 3.4).
Cuando la primera fila está llena, los elementos se almacenan en la
segunda fila, y así sucesivamente.

La primera línea declara tabla como una matriz bidimensional de tres

filas y tres columnas. Los valores introducidos por el usuario se
almacenan en la matriz de dos dimensiones a través de dos bucles for
anidados. En la visualización de una fila de la matriz de dos
dimensiones, la fila aparecerá con sus elementos entre corchetes. El
programa también añade y muestra la suma de los elementos.
El programa siguiente muestra adición de elementos de matrices
bidimensionales. Se añadirán y muestran los elementos en las dos
matrices que consisten de tres filas y tres columnas.
matrix2.py
m1 = [ [1, 2], [3, 4], [5, 6], [7, 8] ]
m2 = [ [9, 8], [7, 6], [5, 4], [3, 2] ]
m3= [ 2*[0] for i in range(4) ]
print("Addition of two matrices is")
for i in range(4):
for j in range(2):
m3[i][j]= m1[i][j]+m2[i][j]
for row in m3:
print (row)
Output:
Addition of two matrices is
[10, 10]
[10, 10]
[10, 10]
[10, 10]

Los elementos en los arrays bidimensionales m1 y m2 están dispuestos

como se muestra en la Figura 3.5.

Para el almacenamiento de la adición de los elementos de las

matrices bidimensionales m1 y m2, se declara otra matriz
bidimensional, m3.
Usando bucles for anidados, puede acceder a los elementos de la fila
respectiva y la posición de la columna de las dos matrices
bidimensionales y almacenar su adición en la tercera matriz, m3. La
adición de m1 y m2 se calcula y se almacena en la matriz M3 (véase
la figura 3.6), que se muestra a continuación.
Figure 3.6. Addition of two-dimensional arrays.

Esto termina nuestra discusión sobre arrays. Luego viene otra

secuencia, listas.
Lists – listas
Una lista es una colección de elementos, que podría incluir otras
listas. Listas comienzan y terminan con un corchete, y los elementos
en el interior se separan con comas.
["John", "Kelly", 1, 2, [Sugar, Butter, 10]]

El primer elemento de la lista está en el índice 0, el segundo es en

valor de índice 1, y así sucesivamente. El último elemento está en
el índice -1.
El siguiente ejemplo muestra el primer y el último elemento de una
lista:
list1.py
names=['John', 'Kelly', 'Caroline', 'Paula']
print (names[0])
print (names[-1])
Output:
John
Paula

El índice de valores de 0 y -1 se refieren a los primeros y los

últimos elementos de la lista, John y Paula.

Finding the Length of the List

Encontrar la longitud de la lista.
Para encontrar la longitud de una lista, se utiliza la función
len(), que devuelve la longitud como una ubicación de índice del
último elemento más uno. De esto, se puede decir que la ubicación
del índice del último elemento de la lista es len (list) -1. Del
mismo modo, la ubicación del índice del segundo al último elemento
de la lista se calcula como len(list) -2. Además de utilizar el
método len() para encontrar la ubicación del índice del último
elemento, no existe una forma más: la ubicación del índice del
último elemento se define como -1 por defecto.
De esta manera, se puede calcular la ubicación del índice de la
segunda a la última como elemento de -2 y así sucesivamente. En
otras palabras, la lista [len (lista) -1] y lista [-1] son los
mismos y se mostrará el último elemento de la lista. Por tanto,
cualquier elemento de la lista puede ser indexado de dos maneras:
por el frente (usando la función len() ) y de la parte posterior
(con -1).
El siguiente ejemplo muestra todos los elementos de la lista:
list2.py
names=['John', 'Kelly', 'Caroline', 'Paula']
for i in range(0,len(names)):
print (names[i])
Output:
John
Kelly
Caroline
Paula

En este caso, la función len () devolverá la longitud de la lista

como 4. Rango(0,4) devolverá los valores de 0 a 3 (excluyendo 4),
por lo que se mostrarán todos los elementos de la lista de ubicación
de índice de 0 a 3 .
También puede acceder a los elementos de la lista con el número de
miembros en el operador in como se muestra en el siguiente programa:
list3.py
names=['John', 'Kelly', 'Caroline', 'Paula']
for n in names:
print (n)
Output:
John
Kelly
Caroline
Paula

El operador in con una sentencia if se puede utilizar para buscar un

elemento en la lista. El siguiente ejemplo busca el contenido
deseado en la lista:
list4.py
names=['John', 'Kelly', 'Caroline', 'Paula']
n=input("Enter a name: ")
if n in names:
print ("Entered name is present in the list")
else:
print ("Sorry the entered name is not in the list")
Output:
Enter a name: Susan
Sorry the entered name is not in the list
Enter a name: Caroline
Entered name is present in the list

El siguiente programa pide al usuario que introduzca un valor

numérico para un mes y muestra el nombre del mes en forma de texto.
Por ejemplo, si el usuario introduce 1, el programa mostrará la
salida en enero. Si el usuario introduce 2, el programa va a
imprimir febrero, y así sucesivamente.
list5.py

months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',

'August','September', 'October', 'November', 'December']
n = int(input("Enter a value between 1 and 12: "))
if 1 <= n <= 12:
print ("The month is", months[n-1])
else:
print ("Value is out of the range")
Output:
Enter a value between 1 and 12: 5
The month is May
Enter a value between 1 and 12: 13
Value is out of the range

Los elementos en la lista de meses se almacenarán como se muestra en

la Figura 3.7.

Cuando un usuario introduce un valor, se asigna a la variable n.

Usted disminuir el valor de n en 1, porque los lugares de índice en
la lista empiezan en 0 y no 1. Su valor se convertirá en 4, y se
imprime el elemento en la ubicación de índice de 4, que es la salida
deseada, mayo. Para evitar la introducción de un valor por encima
del rango dado, se valida el valor introducido mediante la
aplicación de encadenamiento de los operadores de comparación para
garantizar que el valor introducido por el usuario es de entre 1 y
12.
Ahora vamos a ver cómo las listas se pueden dividir o cortados en
piezas.

List Slicing - Lista rebanar

Puede cortar una lista en partes para obtener los elementos
deseados. Para cortar una lista, se especifica la ubicación de
índice desde el que se desea extraer elementos.
Syntax:
list[first_index:following_index]
Devuelve los elementos de first_index al índice antes se devuelve
following_index.
nota
Si no se especifica first_index, a continuación, se supone que
el principio de la lista. Si no se especifica following_index,
a continuación, se supone que el resto de la lista.
Para entender mejor el concepto de corte, vamos a suponer que usted
tiene una lista llamada tmplist con estos contenidos:
tmplist=['John', 'Kelly', 10, 'Caroline', 15, 'Steve', 'Katheline']
Ahora hay que observar la salida de los siguientes ejemplos:
tmplist [0:3] devolverá los elementos en el valor de índice de 0 a 2
['John', 'Kelly', 10].
tmplist [2:4] devolverá los elementos en el valor del índice de 2 a
3 [10, 'Caroline'].
tmplist [-4] devolverá el cuarto elemento de la última ['Caroline'].
tmplist [-4: -2] devolverá el cuarto elemento de la última a través
del tercer elemento de el último ['Caroline', 15].
tmplist [-5:5] devolverá el quinto elemento de la última a través
del cuarto elemento de el principio [10, 'Caroline', 15].
tmplist [: 3] devolverá los tres primeros elementos de la lista
['John', 'Kelly', 10].
tmplist [3:] devolverá los elementos de valor de índice 3 al final
de la lista ['Caroline', 15 ,'Steve', 'Catalina'].
tmplist [: -3] devolverá el elemento de valor de índice 0 hasta el
tercer elemento de la última ['John', 'Kelly', 10, 'Caroline'].
tmplist [-3:] devolverá el tercer elemento desde el último hasta el
final de la lista [15, 'Steve', 'Catalina'].
Tabla 3.4 muestra algunos de los métodos que se pueden aplicar a las
listas.

El siguiente programa realiza el corte para mostrar la lista de los

primeros cuatro elementos de la lista, encuentra la longitud de la
lista, añade los nuevos elementos a la lista, se elimina un elemento
de la lista, y muestra los elementos de la lista.
list6.py
tmplist=['John', 'Kelly', 10, 'Caroline', 15, 'Steve', 'Katheline']
print ("The original list is", tmplist)
print ("The first four elements in the list are:", tmplist[0:4])
print ("The number of elements in the list are", len(tmplist))
m=input ("Enter a name to add to the list ")
tmplist.append(m)
print ("The elements in the list now are", tmplist)
n=int(input ("Enter the element number to delete "))
del tmplist[n-1]
print ("The elements in the list now are", tmplist)
print ("The elements in the list can also be displayed as shown:")
for i in range(0, len(tmplist)):
print (tmplist[i])
Output:
The original list is ['John', 'Kelly', 10, 'Caroline', 15, 'Steve', 'Katheline']
The first four elements in the list are: ['John', 'Kelly', 10, 'Caroline']
The number of elements in the list are 7
Enter a name to add to the list Rebecca
The elements in the list now are ['John', 'Kelly', 10, 'Caroline', 15, 'Steve', '
Katheline','Rebecca']
Enter the element number to delete 2
The elements in the list now are ['John', 10, 'Caroline', 15, 'Steve', 'Katheline'
,'Rebecca']
The elements in the list can also be displayed as shown:
John
10
Caroline
15
Steve
Katheline
Rebecca

Este programa define siete elementos por el nombre tmplist. En

primer lugar, mostrar todos los elementos de la lista. Luego, con el
método de la división, se muestra los primeros cuatro elementos de
la lista.
Imprimir el recuento de los elementos de la lista mediante la
función len(). Luego pida al usuario que introduzca un elemento que
se van a añadir a la lista. Los datos introducidos por el usuario se
añaden a la lista mediante el método append().
Luego le pide al usuario que introduzca la ubicación del elemento
que se requiere para ser removido de la lista. Sabiendo que el
usuario contará el lugar comenzando desde el valor 1, mientras que
los elementos de la lista comienzan a valor de índice 0, disminuir
la ubicación introducida por el usuario para el 1 de manera que
coincida con la ubicación del índice del elemento que el usuario
desea eliminar de la lista. Por último, con el método del(), el
elemento en esa ubicación de índice se elimina de la lista.
El programa siguiente muestra cómo agregar nuevos elementos a la
lista, la búsqueda de un elemento en la lista, y la actualización
del elemento.
list7.py
names=[]
n=int(input("How many names? "))
print("Enter", n, "names")
for i in range (0,n):
m=input()
names.append(m)
print ("The original list of names is", names)
p=input ("Enter the name to search: ")
if p in names:
print ("The name", p, "is found in the list at location ", names.index(p)+1)
else:
print ("The name", p, "is not found in the list ")
q=input ("Enter the name to update/change: ")
if q in names:
loc=names.index(q)
r=input("Enter the new name: ")
names[loc]=r
print ("The name", q, "in the list is changed to", r)
else:
print ("The name", q, "is not found in the list")
names.sort()
print ("Sorted names are", names)
Output:
How many names? 4
Enter 4 names
Kelly
Caroline
David
Beth
The original list of names is ['Kelly', 'Caroline', 'David', 'Beth']
Enter the name to search: David
The name David is found in the list at location 3
Enter the name to update/change: Caroline
Enter the new name: Candace
The name Caroline in the list is changed to Candace
Sorted names are ['Beth', 'Candace', 'David', 'Kelly']

El programa crea una lista vacía, nombres, y pide al usuario que

añada el número deseado de nombres (el texto) a la misma.
Después se agregan algunos nombres a la lista, se muestra su
contenido original. Luego le pide al usuario que introduzca el
nombre que desea buscar. El nombre introducido se busca en la lista
con el número de miembros en el operador. Si el nombre se encuentra
en la lista, se muestra su ubicación; de lo contrario, se muestra el
nombre del mensaje no encontrado.
Después de buscar la actualización viene. El programa pide al
usuario que introduzca el nombre de actualizar. Si no se encuentra
el nombre introducido, se accede a la ubicación de índice utilizando
el método index(), y el nuevo nombre se almacena en esa ubicación
del índice, reemplazando el nombre antiguo. Por último, el programa
muestra todos los nombres en la lista después de ordenar
alfabéticamente utilizando sort().
Tuples -Tuplas
Las tuplas son un tipo de secuencia, como cadenass. Pero a
diferencia de las cadenas, que pueden contener sólo caracteres,
tuplas pueden contener elementos de cualquier tipo. Una tupla es un
objeto inmutable que no se puede cambiar una vez que se haya creado.
Al igual que con todas las secuencias, los índices de tupla se basan
en cero; el primer elemento está en el índice 0, y el último
elemento está en el índice -1.
El programa siguiente muestra cómo se define una tupla y cómo se
accede y visualiza sus elementos:
tup1.py
names=('John', 'Kelly', 'Caroline', 'Steve', 'Katheline')
print ("The names in the tuple are:", names)
print ("The first name in the tuple is", names[0])
print ("The last name in the tuple is", names[len(names)-1])
print ("The names in the tuple are")
for n in names:
print (n)
Output:
The names in the tuple are: ('John', 'Kelly', 'Caroline', 'Steve',
'Katheline')
The first name in the tuple is John
The last name in the tuple is Katheline
The names in the tuple are
John
Kelly
Caroline
Steve
Katheline

En este programa, los nombres de tupla se define que contiene cinco

elementos: John, Kelly, Caroline, Steve, y Catalina. Se muestran
todos los elementos de la tupla, seguido por el primer y el último
elemento. El programa también muestra cómo se accede a elementos de
una tupla usando el operador in.
El siguiente programa demuestra la búsqueda de un elemento de una
tupla y la concatenación de dos tuplas.
tup2.py
names=('John', 'Kelly', 'Caroline', 'Steve', 'Katheline')
n=input("Enter the name to search: ")
if n in names:
print ("The name", n, "is present in the tuple")
else:
print ("The name", n, "does not exist in the tuple")
countries=('U.S.', 'U.K', 'India')
names+=countries
print ("The tuples are concatenated. The concatenated tuple is", names)
Output:
Enter the name to search: Beth
The name Beth does not exist in the tuple
The tuples are concatenated. The concatenated tuple is ('John', 'Kelly',
'Caroline','Steve', 'Katheline', 'U.S.', 'U.K', 'India')

Aquí, los nombres se define como un conjunto de cinco elementos. Se

le pide al usuario que introduzca un nombre que desea buscar. Usando
el número de miembros en el operador, el nombre introducido se busca
en la tupla nombres, y se muestra un mensaje.
También, una tupla más, countries, se define para incluir tres
elementos. Los elementos en los países se añaden a la tupla nombres.
A continuación, se muestran los elementos de la tupla concatenados,
nombres.
Asignaciones(mappings) son objetos mutables que se utilizan para
valores de asignación a los objetos. El mapeado estándar que
discutiremos a continuación es el diccionario.

Dictionary
Un diccionario es una combinación de pares key/value en el que cada
key tiene que ser único. Pares clave / valor están separados por dos
puntos, y los pares se separan por comas. Los pares clave / valor
están encerrados en una llaves.
Syntax:
d = {key1 : value1, key2 : value2 }

Los diccionarios son mutables, lo que significa un diccionario puede

ser modificado, y usted no tiene que crear una copia del mismo para
modificarlo. Claves de los diccionarios son sensibles e inmutable
porque Python los asocia con un número único llamado hash. Además,
las claves de diccionario pueden ser de tipos mixtos de datos:
cadenas, enteros, y otros. Tabla 3.5 muestra algunos de los métodos
que se pueden aplicar al diccionario.
El programa siguiente muestra cómo recuperar un valor del
diccionario mediante el suministro de una clave. Además, el programa
muestra cómo agregar un par clave / valor a un diccionario existente
y eliminar un par clave / valor existente. El programa muestra el
uso del diccionario en el acceso a la capital del país cuyo nombre
sea escrito por el usuario.
dict1.py
countrycap={'U.S.':'Washington D.C.','U.K.':'London','India':'New Delhi', }

n=input('Enter country: ')

if n in countrycap:
print ('The capital of', n , 'is', countrycap[n])
else:
print ('Sorry the country', n, 'does not exist in our dictionary')
countrycap['Australia']='Sweden'
print ('The dictionary after adding a country:')
for country, capital in countrycap.items():
print ('Capital of', country, 'is' , capital)
m=input('Enter the country to delete:')
del countrycap[m]
print ('The dictionary after deleting a country:')
for country, capital in countrycap.items():
print ('Capital of', country, 'is' , capital)
Output:
Enter country: U.S.
The capital of U.S is Washington D.C.
The dictionary after adding a country:
Capital of U.S. is Washington D.C.
Capital of Australia is Sweden
Capital of India is New Delhi
Capital of U.K. is London
Enter the country to delete: U.K.
The dictionary after deleting a country:
Capital of U.S. is Washington D.C.
Capital of Australia is Sweden
Capital of India is New Delhi

Este programa define un diccionario llamado countrycap con tres

pares clave / valor en ella. Las claves son los nombres de los
países de Estados Unidos, Reino Unido y la India, y los valores de
estas claves son las respectivas capitales de los países. Usted le
pide al usuario que introduzca el nombre de un país cuya capital es
obligatorio. Tomando el nombre del país ingresó como clave, se
accede y visualiza su valor respectivo. Un par clave / valor se
añade al diccionario, con Australia como clave y Suecia como su
valor. El programa también muestra los elementos del diccionario,
cada país con su respectiva capital. El programa también elimina el
par de países / capitales que desee en el diccionario.
El siguiente programa muestra el uso de metodos items(), keys(),
values() y get() del diccionario. Además, muestra cómo se fusionan
dos diccionarios.
dictexample.py
student1={'John' : 60, 'Kelly' : 70, 'Caroline' : 80}
student2=dict([('David', 90), ('John',55)])
print ('The items in dictionary student1 are:', student1.items())
print ('The keys in student1 dictionary are:', student1.keys())
print ('The values in student1 dictionary are:', student1.values())
student1.update(student2)
print ('The items in dictionary student1 after merging with student2
dictionary are:',student1.items())
n=input('Enter name whose marks you want to see: ')
if n in student1:
print ('The marks of', n , 'are' , student1.get(n))
else:
print ('Sorry the name', n, 'does not exist in student1 dictionary')
Output:
The items in dictionary student1 are: dict_items([('Kelly', 70), ('John', 60),
('Caroline', 80)])
The keys in student1 dictionary are: dict_keys(['Kelly', 'John', 'Caroline'])
The values in student1 dictionary are: dict_values([70, 60, 80])
The items in dictionary student1 after merging with student2 dictionary are:
dict_items([('Kelly', 70), ('John', 55), ('Caroline', 80), ('David', 90)])
Enter name whose marks you want to see: Caroline
The marks of Caroline are 80
El programa define dos diccionarios, student1 y student2. El
diccionario student2 se crea mediante la aplicación de la función
dict() a los pares de valores.
Todos los pares clave / valor del diccionario student1 se muestran
usando la función items(). Además, se accede a las claves y los
valores del diccionario student1 a través de las funciones de las
keys() y values() y se muestran. Los pares clave / valor de la
student2 diccionario se fusionan con el diccionario studen1.
Si bien la fusión, los valores de las claves en el diccionario de
student1 se actualizarán con los valores de las claves
correspondientes en el diccionario de student2. Se muestran los
pares clave / valor fusionadas. Asimismo, el usuario se le pide que
ingrese el nombre de un estudiante cuyas marcas son obligatorios.
Uso de la función get(), se accede y visualiza el nombre
proporcionado.
Vamos a terminar el capítulo discutiendo un objeto más contenedor,
sets.

Sets – Conjuntos
Un conjunto es una colección de ciertos valores. Puede llevar a cabo
una serie de operaciones de conjunto, incluyendo la unión (|),
intersección (&), diferencia (-), y diferencia simétrica (^). Vamos
a comenzar con la operación de unión.

Union (|)
En una operación de unión, un elemento aparece en la union si existe
en un grupo u otro. Por ejemplo, considere los dos conjuntos S1 y S2
con los siguientes elementos:
S1=set([3,5,6,10,11,100])
S2=set([1,3,5,6,11,15])

S1|S2 mostrará la unión como:

set([1,3,5,6,10,11,15,100]

Intersection (&)
En una operación de intersección, los elementos que aparecen en
ambos conjuntos aparecen en la intersección.
S1 & S2 se mostrarán la intersección como:
set([3, 5, 6, 11])

Difference (-)
En una operación de diferencia, todos los elementos que están en el
conjunto de la izquierda, pero no en el conjunto de la derecha van a
aparecer en la operación de diferencia.
S1-S2 mostrará la diferencia como:
set([10, 100])

Del mismo modo, S2-S1 mostrará la diferencia como:

set([1, 15])

Echemos un vistazo a los métodos y las funciones que se pueden

aplicar a los conjuntos. Recuerde que una función es un módulo de
código que se llama por su nombre, y los datos se pasan a ella
explícitamente. Puede devolver un valor. Un método se asocia con un
objeto, y el objeto para el que se llama se pasa al implícitamente.
La lista de funciones y métodos que se pueden aplicar a los
conjuntos se da en la Tabla 3.6.

El siguiente programa muestra el uso de métodos set como max (), min
(), any(), all(), sum(), y se sorted(). El programa también
demuestra la aplicación de unión, intersección, diferencia, y las
operaciones de fusion de los conjuntos .
setexample.py
S1=set([3,5,6,10,11,100])
S2=set([1,3,5,6,11,15])
print ('Length of set S1 is:', len(S1))
print ('Maximum value in set S1 is:' , max(S1))
print ('Minimum value in set S2 is:' , min(S2))
print ('Sum of items in set S1 is:', sum(S1))
print ('Applying any() to set S1 results into:', any(S1))
print ('Union of the two sets is:', S1 j S2)
print ('Intersection of the two sets is:', S1 & S2)
print ('Difference of S1-S2 is:' , S1 - S2)
print ('Difference of S2-S1 is:' , S2 - S1)
S1.add(0)
print ('The items in set S1 after adding an item are:' , sorted(S1))
print ('As set S1 now has a value 0, so all() will result into:',
all(S1))
S1.update(S2)
print ('The items in set S1 after merging set S2 are:' , sorted(S1))
Output:
Length of set S1 is: 6
Maximum value in set S1 is: 100
Minimum value in set S2 is: 1
Sum of items in set S1 is: 135
Applying any() to set S1 results into: true
Union of the two sets is: {1, 3, 100, 5, 6, 10, 11, 15}
Intersection of the two sets is: {11, 3, 5, 6}
Difference of S1-S2 is: {10, 100}
Difference of S2-S1 is: {1, 15}
The items in set S1 after adding an item are: [0, 3, 5, 6, 10, 11, 100]
As set S1 now has a value 0, so all() will result into: false
The items in set S1 after merging set S2 are: [0, 1, 3, 5, 6, 10, 11,
15, 100]

Este programa muestra el recuento del número de elementos en el

conjunto, el valor más alto, el valor más bajo, y la suma de los
valores en el conjunto. La aplicación de la función de any() en
conjunto S1 devuelve true, ya que contiene varios valores distintos
de cero. El programa también muestra la unión, la intersección y la
diferencia de los conjuntos.
Un valor de 0 se añade a la S1 conjunto mediante el método add ().
Además, el conjunto S1 se muestra después de la clasificación de sus
elementos. La aplicación de la función de all() en el set S1
devuelve false ya que ahora contiene un valor de 0. Los elementos en
conjunto S2 se combinan con los elementos del conjunto S1, y el
conjunto resultante de la fusión se muestra después de ordenar sus
elementos.
Summary
En este capítulo se centra en diferentes recipientes. Usted aprendió
a realizar diferentes operaciones en las cadenas, incluida la
concatenación, la división, y su conversión en diferentes casos como
mayúsculas, caso del título, y en minúsculas.
También ha aprendido sobre la lista de corte y elementos en búsqueda
de tuplas. Ha realizado operaciones en conjuntos como la búsqueda de
su unión, intersección y diferencia. Usted vio cómo se mantienen los
pares clave / valor en un diccionario y cómo añadir, eliminar y
modificar los pares clave / valor. Por último, ha creado matrices de
una y dos dimensiones.

Chapter 4. Functions and Modules

En este capítulo se tratan los siguientes temas:
•
•
•
•
•
•
•
•
•
•

Creación y uso de funciones

El uso de parámetros de valor predeterminado y argumentos de
palabras clave
Uso de variables locales y globales
Creación de funciones lambda
La aplicación de funciones a las secuencias
El uso de atributos de función
La implementación de la recursividad
Utilización de iteradores, generadores, y las expresiones
generadoras
Importación y uso de módulos
Utilizando argumentos de la línea de comandos

Comencemos el capítulo con las funciones y sus declaraciones.

Functions
Una función es un grupo de sentencias que se pueden invocar
cualquier número de veces. Además de las funciones incorporadas,
puede definir sus propias funciones. La afirmación de que invoca una
función se conoce como una llamada de función.
Al llamar a una función, se pueden pasar argumentos a ella para
realizar el cálculo deseado. En Python, una función siempre devuelve
un valor que puede ser None o que representa la tarea realizada por
la función.
En Python, las funciones son tratados como objetos, y por lo que
puede pasar una función como argumento a otra función. Del mismo
modo, una función puede devolver otra función. Además, una función,
al igual que cualquier otro objeto, se puede enlazar a una variable,
un elemento de un contenedor o un atributo de un objeto.
Echemos un vistazo a las afirmaciones utilizadas en la definición de
una función.
The def Statement - La Declaración def
La instrucción def se usa para definir una función.
Syntax:
def function-name(parameters):
statement(s)
donde nombre-función es un identificador para reconocer la función.
parámetros es una lista opcional de identificadores que se enlazan a
los valores proporcionados como argumentos al llamar a la función.
Cuando se llama a una función, los datos que envíe a la función se
llama argumentos y las variables de la función que reciben los
argumentos se llaman parámetros. Por lo tanto, mientras que llamar a
una función, se debe pasar el mismo número de argumentos, ya que hay
parámetros que figuran en la definición de la función. Los
parámetros son variables locales de la función, y cada llamada a la
función se une estas variables locales a los valores
correspondientes se pasan como argumentos. El cuerpo de la función
puede contener cero o más apariciones de la sentencia return.
El programa siguiente muestra la suma de dos valores numéricos
utilizando un función.
func1.py
def sum(a, b):
return a + b
k=sum(10,20)
print ("Sum is", k)
Output:
Sum is 30
En este programa, una función sum() se llama, que pasa dos
argumentos 10 y 20. Los argumentos 10 y 20 serán asignados a los
parámetros a y b, se define en la función suma().
La función suma() calcula la suma de los valores asignados a los
parámetros a y b y devuelve el resultado al programa principal. El
resultado se asigna a la variable k en el programa principal, que se
muestra a continuación.

The return Statement - La Declaración de retorno

La instrucción de retorno se utiliza para el retorno de salida de la
función. La declaración está opcionalmente seguido de una expresión.
Cuando el retorno se ejecuta, la función termina, y el valor de la
expresión se pasa a la persona que llama. Cuando no hay nada que se
devolverá a la persona que llama, la función devuelve Ninguno-None.
Si una función no requiere datos externos al proceso, se puede
definir sin parámetros. El programa siguiente muestra una función
que toma ningún parámetro y devuelve un valor:
func3.py
def quantity():
return 10
print (quantity())
q=quantity()
print (q)
Output:
10
10
En este programa, una función de la cantidad() se define que no toma
parámetros. Al llamar a la función en una sentencia de impresión,
imprime el valor de 10 que se devuelve. En la siguiente llamada de
función, se asigna el valor devuelto a la variable de q, que se
muestra a continuación.
El siguiente programa pide al usuario que introduzca un valor
numérico entre 1 y 4 y lo muestra en forma de texto. Por ejemplo, si
el usuario introduce 1, el programa mostrará uno. Si el usuario
introduce 2, el programa mostrará dos, y así sucesivamente.
func4.py
def conv(x):
if x==1:
return
if x==2:
return
if x==3:
return
if x==4:
return

"one"
"two"
"three"
"four"

n=int(input("Enter a number between 1 and 4: "))

print (n, "in words is", conv(n))
Output:
Enter a number between 1 and 4: 3
3 in words is three
El programa pide al usuario que introduzca un valor entre 1 y 4 que
se convierte a entero tipo de datos y se asigna a una variable n. La
variable n se pasa como un argumento a la función conv(). En conv(),
n se asigna al parámetro x. El uso de sentencias if, se analiza el
valor del parámetro x, y se devuelve su forma de texto.
A veces usted quiere una función para devolver un valor de None.
Considere una situación en la que el valor pasado al parámetro de la
función no se encuentra dentro del rango esperado. Es decir, los
datos pasados no es adecuado para realizar cualquier procesamiento
en él. Usted desea que la función para omitir su cuerpo y devolver
Ninguno. El programa siguiente muestra el formato de texto del
número pasado entre 1 y 4. Si el número pasado es 0, la salida será
None.
passex2.py
def conv(x):
if x==0:
pass
if x==1:
return
if x==2:
return
if x==3:
return
if x==4:
return

"one"
"two"
"three"
"four"

print (conv(2))
print (conv(0))
Output:
two
None
Se puede ver que cuando el valor 2 se pasa como un argumento a la
función conv(), el respectivo si se ejecuta la declaración para
mostrar el texto dos. Cuando 0 se pasa a la función conv(), el
primero si se ejecuta la declaración de la función.
No hace nada, ya que contiene la sentencia pass, por lo que se
devuelve None. Recuerde que la sentencia pass indica un bloque vacío
de enunciados. Se utiliza por lo general como un marcador de
posición para el código va a escribir más tarde.

Default Value Parameters- Parámetros Valor predeterminado

Los parámetros enumerados en la definición de la función pueden ser
obligatorios u opcionales. Los parámetros obligatorios son aquellos
cuyo valor tiene que ser suministrado en forma de argumentos cuando
se llama a la función. Los parámetros opcionales son aquellos cuyo
valor puede o no puede ser pasado al llamar a la función. Un
parámetro opcional se define con la siguiente sintaxis:
identifier=expression
La expresión se evalúa y se asigna como el valor predeterminado para
el identificador. Cuando una llamada de función no proporciona un
argumento corresponde a un parámetro opcional, la llamada se enlaza
el parámetro a su valor por defecto.
El programa siguiente muestra el uso de un parámetro predeterminado.
En este programa, se define una función que tiene dos parámetros;
una es obligatoria, y la otra es opcional o el defecto. Cuando la
llamada a la función pasa el valor para el parámetro por defecto, se
aplica el valor pasado; de lo contrario se aplica el valor
predeterminado.
func2.py
def sum(x, y=10):
return x+y
print (sum(10))
print (sum(5,8))
Output:
20
13
En este programa, la función sum() se llama dos veces. En la primera
llamada, sólo un argumento, 10, se transmite y se asigna al
parámetro x. La función tomará el valor por defecto del parámetro y
(10), mientras que la ejecución de la función. En la segunda llamada
a la función suma(), los argumentos 5 y 8 se pasan y se asignan a
los parámetros x e y, respectivamente. El valor por defecto de y, el
10, se ignora, y se aplica el valor pasado como argumento (8).

Keyword Arguments-Argumentos por clave

Si al llamar a una función que se desea suministrar argumentos para
sólo unos pocos de sus parámetros, lo hace al nombrar los parámetros
cuando el paso de argumentos. Un valor pasado a un parámetro por
referencia a su nombre se conoce como un argumento de palabra clave.
La ventaja de utilizar este método es que usted no tiene que
preocuparse por el orden de los argumentos.
El siguiente programa muestra el uso de argumentos de palabra clave
cuando se llama a una función.

keywordarg.py
def volume(l, b=5, h=10):
print ('l is', l, 'and b is', b, 'and h is', h, 'and volume
is', l*b*h)
volume(2, 4)
volume(3, h=6)
volume(h=7, l=2)
Output:
l is 2 and b is 4 and h is 10 and volume is 80
l is 3 and b is 5 and h is 6 and volume is 90
l is 2 and b is 5 and h is 7 and volume is 70
La función de volumen() tiene tres parámetros, uno que no tiene
ningún valor predeterminado y dos parámetros que hacen. En la
primera llamada a la función, el volumen (2,4), el parámetro l
obtiene el valor 2, el parámetro b se obtiene el valor 4, y h toma
su valor por defecto, 10. En la segunda llamada a la función, el
volumen (3, h = 6), el parámetro l obtiene el valor 3, debido a la
posición del argumento. Entonces, el parámetro h obtiene el valor 6
como un argumento de palabra clave. El parámetro b toma su valor por
defecto, 5. En la tercera llamada a la función, volumen (h = 7, l =
2), utiliza argumentos de palabra clave para especificar los valores
de los parámetros h y l. El parámetro h tendrá 7, l obtendrá 2, y b
obtendrá el valor por defecto 5.
El ámbito de las variables en una función depende de si se define a
nivel local o global.

Local and Global Variables

Variables locales y globales
Las variables locales tienen un alcance dentro del cuerpo de la
función en la que se definen. Es decir, las variables locales son
accesibles dentro de la función. Las variables globales son
accesibles dentro y fuera de las funciones.
nota
Usted obtiene un error si se intenta acceder a una variable
local fuera de la función.

Global Variables
Las variables globales no están vinculados a cualquier función
particular, y se puede acceder dentro del cuerpo de la función,
fuera del cuerpo de la función, o por cualquier otra función. Los
cambios realizados en una variable global por cualquier función
serán visibles por otras funciones. Si una función de las
necesidades de las variables globales, la primera declaración de la
función debe ser la siguiente:
global identifiers
donde los identificadores es uno o más identificadores separados por
comas. Identificadores enumerados en una declaración global se
conocen como variables globales.
Se utiliza la palabra clave global para definir una variable global;
de otro modo, una excepción Error UnboundLocal se eleva debido a que
la variable es una variable sin inicializar (sin consolidar) local.
El siguiente programa se explica el concepto de variables globales.
Lo más importante a observar en este programa es cómo los cambios
realizados en la variable global por una de las funciones se pueden
ver en otra función.
globalvar.py
def compute():
global x
print ("Value of x in compute function is", x)
x += 5
return None
def dispvalue():
global x
print ("Value of x in dispvalue function is", x)
x-=2
return None
x=0
compute()
dispvalue()
compute()
Output:
Value of x in compute function is 0
Value of x in dispvalue function is 5
Value of x in compute function is 3

En este programa, se definen dos funciones, compute()y dispvalue().

Ambas funciones definen una variable global, x. Recuerde, las
variables globales están disponibles en todas las partes del
programa, en el programa principal, así como funciones. Los cambios
realizados en las variables globales son visibles en otras partes
del programa. Usted puede ver que la variable global x se inicializa
a 0 en el programa principal. El programa principal llama a la
función de compute() para imprimir el valor de la variable global y
modificar su valor.
El valor de la variable global x es 0, la funcion compute() imprime
0, incrementa su valor por 5, y vuelve al programa principal. El
programa principal llama al dispvalue() para mostrar y modificar la
variable global. El valor de la variable global x se fijó a 5 por la
función compute() y por lo tanto la función dispvalue() imprime su
valor como 5 y disminuye su valor por 2, por lo que es 3, y vuelve
al programa principal.
El programa principal llama a la función de compute() de nuevo para
ver si los cambios realizados en x en la función dispvalue() son
visibles en compute(). La función de compute() muestra el valor
actual de x (3) e incrementa el valor de x por 5, por lo que es 8, y
vuelve al programa principal. Esto confirma que la variable global
es accesible en todas las partes del programa, y los cambios
realizados en la variable global en una parte del programa se verá
en otra parte.
Veamos ahora cómo se definen y se puede acceder en función de
variables locales.

Local Variables
De forma predeterminada, cualquier variable que se une dentro de un
cuerpo de la función es una variable local. Cada función tiene su
propia copia de una variable local, y su valor no es accesible o
modificable fuera del cuerpo de la función.
El siguiente programa muestra el uso de variables locales:
localvar.py
def compute(x):
x += 5
print ("Value of x in function is", x)
return None
x=10
compute(x)
print ("Value of x is still", x)
Output:
Value of x in function is 15
Value of x is still 10
El programa principal inicializa el valor de la variable local x en
10. La variable x se pasa a la función de computo() como un
argumento. En la función de computo(), el valor del parámetro x se
incrementa en 5, haciendo su valor 15. Pero ellos x es local para la
función, el valor modificado de x (15) sólo es visible dentro del
cuerpo de la función compute(). Cuando se muestra el valor de x en
la función cómpute(), se imprimirá el valor modificado 15, pero
cuando regresa al programa principal, el programa recoge el valor
anterior de x (10). Por lo tanto, el programa principal se imprime
el valor antiguo de x, 10.
A veces es necesario crear funciones muy pequeñas, que consiste en
una única línea. ¿Se puede manejar este tipo de pequeñas funciones
en Python? Sí. Vamos a ver cómo.

Lambda Functions
Para las funciones que son lo suficientemente pequeñas (una
expresión de una sola línea) y que van a ser usados sólo una vez,
por lo general no define los objetos de función. En cambio, el uso
de funciones lambda.
Una función lambda es una función anónima y de sólo un solo uso que
puede tener cualquier número de parámetros y que hace algún cálculo.
El cuerpo de la función lambda es pequeño, una sola expresión. El
resultado de la expresión es el valor cuando se aplica la lambda
para un argumento. No hay necesidad de una instrucción de retorno en
las funciones lambda.
nota
El ámbito de aplicación de una función lambda es limitada. Sólo
existe en el ámbito de la ejecución de una sola sentencia.
Considere una pequeña función que multiplica un argumento pasado por
2 y devuelve, como se muestra aquí:
def f(x):
return x*2
f(3)
6
Se puede ver que una función f toma un parámetro x que vuelva al
multiplicar por 2. Al llamar a la función con el argumento 3,
volverá 6 como salida. Puede volver a escribir esta función como una
función lambda:
g = lambda x: x*2
g(3)
6
Se puede ver que la función lambda no tiene nombre y se llama a
través de la variable que está asignado.
Usted puede utilizar una función lambda incluso sin asignarla a una
variable. La siguiente es una función lambda sin nombre que acepta
un solo argumento. Se multiplica el argumento por 2 y devuelve el
resultado:
(lambda x: x*2)(3)
6
Se puede ver que no hay paréntesis alrededor de la lista de
argumentos, y la palabra clave return no se encuentra. El regreso
está implícita en la función lambda como toda la función se compone
de una sola expresión.
nota
Una función lambda no puede contener comandos y no puede
contener más de una expresión.

Applying Functions to Sequences

La aplicación de funciones a secuencias
Ahora que usted sabe acerca de la definición y llamar a funciones,
vamos a aplicar a las secuencias. En el capítulo anterior, usted
aprendió sobre los tres tipos de secuencias: secuencias, listas y
tuplas. Los tres métodos de esta sección son filter(), map(), y
reduce(). Para poner en práctica estos métodos, el uso de funciones.
filter(function, sequence)
El método filter() devuelve una secuencia que consta de los
elementos para los cuales la función devuelve true, incluidos los
que cumplen con los criterios que figuran en la función
especificada.
Si la función se incluye None, el método devuelve los elementos de
la secuencia que se supone deben ser devueltos cuando la función
devuelve True. Vamos a examinar el uso de este método con un
ejemplo. El siguiente programa filtra los valores impares y devuelve
sólo los valores pares utilizando el método filter().
def evenval(x):
return x % 2 ==0
evens=filter(evenval, range(1,11))
print(list(evens))
Output:
[2,4,6,8,10]
En este ejemplo, se ve que el método filter() utiliza una función
evenval() y un método range(). El método de rango (1,11) generará
valores numéricos de 1 a 10, que luego se pasa a la función
evenval()como argumentos.
La función evenval() divide el valor del parámetropor 2, se compara
con el resto 0, y devuelve true o false. La función devolverá
verdadero si el resultado de la operación mod es 0, lo que indica
que el valor del parámetro es par.
La función devolverá false si el resultado de la operación mod es 1,
lo que indica que el valor del parámetro es impar. Dado que el
método filter() sólo devolverá aquellos valores para los cuales la
función incluida devuelve true, el programa mostrará sólo los
valores pares.
map(function, sequence)
El método de mapa llama a la función incluida para cada uno de los
elementos de la secuencia y devuelve una lista de los valores
devueltos.
El siguiente ejemplo muestra los valores cuadrados de los 10
primeros números de la secuencia utilizando el metodo mapa():
def square(x):
return x*x
sqr=map(square, range(1, 11))
print(list(sqr))
Output:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
En este ejemplo, el método de map() incluye una función cuadrado() y
un método range(). El método de rango (1,11) generará valores
numéricos de 1 a 10, que luego se pasa a la función cuadrado() como
argumentos. La función cuadrado() simplemente devuelve el cuadrado
del parámetro proporcionado. El programa mostrará los valores
cuadrados de los 10 primeros números de secuencia.
Veamos un ejemplo del método map() que convierte los elementos de la
secuencia suministrada en valores enteros.
k=map( int, [ 5, 10.15, 20, 25.628, 7 ] )
print (list(k))
Output:
[5, 10, 20, 25, 7]
En este programa, se ve que el método del map() incluye una función
de int() y una lista de valores. La lista incluye los valores de
diferentes tipos, incluyendo números enteros, punto flotante y
enteros largos. La función int() trunca los elementos de la lista de
números enteros.
nota
También se puede pasar más de una secuencia en un método map().
La función incluida en su map() se establece a continuación
para aceptar varios argumentos. Los elementos correspondientes
de cada secuencia se proporcionan como argumentos de la
función. Si cualquier secuencia se queda corto, ninguno se
utiliza para los valores perdidos.
reduce(function, sequence)
El método reduce() devuelve un valor único que se produce al llamar
a la función de los dos primeros elementos de la secuencia. La
función a continuación, se llama en el resultado de la función y el
siguiente elemento de la secuencia, y así sucesivamente. Por
ejemplo, la siguiente metodo reduce() método calcula la suma de los
números del 1 al 10:
import functools
def add(x,y):
return x+y
r=functools.reduce(add, range(1, 11))
print(r)
Output:
55
Aquí, el método de reduce(), que es la parte de módulo de functools,
incluye una función de add() y un método range(). El método del
rango (1,11) devolverá los valores de 1 a 10. Los dos primeros
valores generados por el metodo rango() se pasan a la función
especificada, add (), y el resultado (3) y el siguiente valor en el
secuencia (3) son de nuevo pasa a la función add().
Una vez más, el resultado de la suma (6) y el siguiente valor de la
secuencia (4) se pasa a la función add(). Cuando se aplican todos
los valores generados por el método range(), el resultado final es
devuelto por la función add () para la exhibición.
nota
El módulo functools se importa en la parte superior debido a
que el metodo reduce() se define en ese módulo. Usted aprenderá
más acerca de los módulos más adelante en este capítulo
Python proporciona una facilidad para acceder a información más
específica de una función de atributos de función.

Function Attributes –Atributos de función

Un objeto de función tiene una serie de atributos que se pueden
utilizar para obtener más información acerca de una función.
También, usted puede cambiar estos atributos. Una lista de los
atributos de la función se muestra en la Tabla 4.1.
Table 4.1. Function Attributes
Attribute

Description

functionname.__doc__

Representa la cadena de documentación de la

primera línea del cuerpo de la función.

functionname.__name__

Representa el nombre de la función.

functionname.__module__

Representa el nombre del módulo en el que se

define la función.

functionname.__defaults__

Representa la tupla con los valores por defecto

que se asignará a los argumentos predeterminados
de la función.

functionname.__code__

Representa el objeto de código actual, las

declaraciones contenidas en el cuerpo de la
función.

functionname.__dict__

Representa el diccionario que define el espacio de

nombres local para los atributos de la función.

nota
Puede configurar y obtener sus propios atributos de función,
también.
El siguiente programa muestra el uso de la función de los atributos
para mostrar información específica de la función, como su versión,
autor, docstring y argumentos por defecto.
funcattrib.py
def sum(a, b=5):
"Adds the two numbers"
return a + b
sum.version= "1.0"
sum.author= "bintu"
k=sum(10,20)
print ('Sum is', k)
print('The documentation string is', sum.__doc__)
print('The function name is', sum.__name__)
print('The default values of the function are', sum.__defaults__)
print('The code object of the function is', sum.__code__)
print('The dictionary of the function is', sum.__dict__)
Output:
Sum is 30
The documentation string is Adds the two numbers
The function name is sum
The default values of the function are (5,)
The code object of the function is <code object sum at 0x00F11250, file
"D:\python\
funcattrib.py", line 1>
The dictionary of the function is {'version': '1.0', 'author': 'bintu'}
En este programa, la información de la versión y el autor de la
función suma() se encuentra en la forma de un diccionario, en el
patrón de clave/valor. A partir de entonces, la función suma() se
llama con dos argumentos, 10 y 20, que se asignan a los parámetros a
y b, respectivamente. La primera línea en el cuerpo de la función es
la cadena de documentación. Es decir, la cadena de documentación o
atributo __ doc__ de la función, sum(), se establece en el texto
Añade los dos números.
A partir de entonces, la cadena de documentación y sus argumentos
por defecto se visualizan mediante la impresión de los atributos
__doc__, __name__ y __defaults__. Por último, el objeto de código y
el diccionario de la función se visualizan a través de los atributos
__code__ y __dict__.

Documentation String
La cadena de documentación (docstring) ayuda a documentar el
programa mejor y hace que sea más fácil de entender. Una cadena en
la primera línea lógica de una función es la cadena de documentación
para esa función. Para mostrar una cadena de documentación, se
utiliza el atributo siguiente:
__doc__

Esto muestra la documentación de la función, una clase o módulo.

nota
La cadena de documentación se aplica
las clases de las que hablaremos más
declaración en el cuerpo de la clase
compilador se une que la cadena como
documentación de la clase.

también a los módulos y

adelante. Si la primera
es una cadena literal, el
el atributo de cadena de

El programa siguiente muestra la cadena de documentación de varias

líneas de una función:
docstr.py
def rect(l,b):
'''Computes the area of rectangle
Values for length and breadth are passed to the function for
computation'''
print ('Area of rectangle is', l*b)
rect(5,8)
print (rect.__doc__)
Output:
Area of rectangle is 40
Computes the area of rectangle
Values for length and breadth are passed to the function for computation

El atributo __ doc__ muestra la cadena de documentación de la

función.
¿Puede una función llame a sí mismo? Si el procedimiento se llama
recursividad.

Recursion - La recursividad
La recursividad se dice que ocurre cuando una función se llama a sí
mismo. Como era de esperar, una función que se autodenomina generará
llamadas a funciones recursivas y resultar en un bucle infinito.
Cuando la aplicación de la recursión, una condición de salida debe
ser incluido en la función.
nota
La recursión se implementa con la ayuda de una estructura
conocida como una pila.
Vamos a examinar el concepto de recursividad a través de un ejemplo.
El siguiente programa calcula la suma de 10 números utilizando
recursividad:
recurfunc.py
def addseq(x):
if x == 1: return 1
else: return x + addseq(x-1)
print ('The sum of first 10 sequence numbers is', addseq(10))
Output:
The sum of first 10 sequence numbers is 55

La función addseq() es llamada, pasando el valor 10 a la misma, que

será asignado a su parámetro x. En el cuerpo de la función, se ve
que la primera línea define la condición de salida. La función
termina o salidas, volviendo 1, si el valor del parámetro x es 1.
Dado que el valor actual del parámetro es 10, se ejecuta una
instrucción else, que es 10 + addseq (9).
La sentencia else llama a la función addseq() recursivamente,
pasando el valor 9 para el parámetro x. Una vez más la sentencia
else se llama, que ejecuta la sentencia 9 + addseq (8)
Una vez más, la función addseq() se llama, que pasa 8 a su parámetro
x, lo que resulta en una instrucción que se está ejecutando otra
cosa. El proceso continúa hasta que el valor del parámetro x se
convierte en 1, en cuyo caso se cierra la función, volviendo 1 La
ejecución de la función se muestra aquí:
10+addseq(9)
9+ addseq(8)
8+ addseq(7)
...
...
2+ addseq(1)
1
La expresión final devuelve desde la funcion addseq(10) llamado es
10 9 8 7 6 ... 1. El programa muestra 55, que es la suma de los
números 10.
Vamos a escribir un programa más en la recursividad. El siguiente
programa calcula el factorial de 5 a través de la recursividad.
factorial.py
def fact(x):
if x == 1: return 1
else: return x * fact(x-1)
print ('The factorial of 5 is', fact(5))
Output:
The factorial of 5 is 120

La llamada a la funcion fact(5) pasa 5 a la función fact(), que se

asignará a su parámetro x. La primera sentencia de la función es una
condición de salida que asegura que la función terminará,
devolviendo a 1 si el valor del parámetro x se convierte en 1. Dado
que el valor del parámetro x en la primera llamada a la función es
5, la declaracion else se ejecuta y devuelve la siguiente
declaración:

5 * fact(4)
La llamada a la funcion fact(4) pasará 4 al parámetro x, y de nuevo
se ejecutará la sentencia else y regresar la siguiente declaración:

4* fact(3)
Una vez más la llamada a la funcion fact(3) pasará 3 al parámetro x,
lo que resulta en la ejecución de la sentencia else otra vez. El
proceso continúa hasta que el valor asignado al parámetro x es 1, en
cuyo caso se cierra la función, devolviendo 1. La expresión completa
que resulta en la ejecución de la programa es la siguiente:

5*4*3*2*fact(1) or
5*4*3*2*1
El programa imprime el resultado como 120, que es el factorial de 5.

Iterators - Los iteradores

Los iteradores se utilizan para recorrer a través de las colecciones
de datos. Cada vez que utilice un bucle en una lista, iteradores se
invocan en el fondo para la recuperación de datos. Un iterador tiene
un método next() que se puede llamar para obtener cada valor de la
secuencia. Cuando se aplican todos los valores, se produce una
excepción StopIteration. Usted aprenderá acerca de la gestión de
excepciones en el Capítulo 6, "Administración de archivos." Por el
momento es suficiente saber que lanzar una excepción significa una
ocurrencia de algún tipo de error.
Para crear un objeto iterador, es necesario llamar al método iter().

iter(object)
El método iter() se utiliza para obtener un objeto iterador. El
método iter (objeto) se pide que el metodo de objeto __ iter__
conseguir un objeto iterador. Una vez, se obtiene un objeto
iterador, se puede recorrer en iteración el objeto utilizando su
método next().
El siguiente programa muestra todos los elementos de una lista con
el objeto iterador:
createiter.py
names=['John', 'Kelly', 'Caroline', 'Paula']
i = iter(names)
print (i.__next__())
print (i.__next__())
print (i.__next__())
print (i.__next__())
print (i.__next__())
Output:
John
Kelly
Caroline
Paula
Traceback (most recent call last):
File "D:\python\createiter.py", line 7, in <module>
print (i.__next__())
StopIteration

En este programa, la lista está definido, los names, que contiene

cuatro elementos: John, Kelly, Caroline, y Paula. Un objeto
iterador, i, se crea a partir de la lista names mediante la
invocación del método iter().
A partir de entonces, iterar sobre el objeto i mediante el uso de su
método next() y mostrar todos los cuatro elementos de la lista. La
última llamada a next() se hace deliberadamente para aumentar la
excepción StopIteration y para mostrar el mensaje de error que
genera.
Las dos formas de crear iteradores que vamos a discutir la próxima
están utilizando generadores y el uso de las expresiones
generadoras.
Generators – Generadores
Un generador es una función que crea un iterador. Para una función
para convertirse en un generador, debe devolver un valor mediante la
palabra clave de yield. En otras palabras, la función de generador
utiliza la palabra clave de yield para obtener el siguiente valor en
el recipiente.

yield
La declaración de yield se utiliza sólo cuando se define una funcion
de generador funciones y sólo se utiliza en el cuerpo de la función
de generador. La presencia de una declaración de yield en una
definición de la función normal de la convierte en una función de
generador. Cuando un generador de funciones se llama, devuelve un
iterador conocido como un iterador generador, o simplemente un
generador. El cuerpo de la función del generador es ejecutada por
una llamada al método del generador __ next__ () varias veces hasta
que se produzca una excepción.
generatorex.py
def fruits(seq):
for fruit in seq:
yield '%s' % fruit
f=fruits(['Apple', 'Orange', 'Mango', 'Banana' ])
print ('The list of fruits is:' )
print (f.__next__())
print (f.__next__())
print (f.__next__())
print (f.__next__())
f=fruits(['Apple', 'Orange', 'Mango', 'Banana' ])
print ('The list of fruits is:' )
for x in f:
print (x)
Output:
The list of fruits is:
Apple
Orange
Mango
Banana
The list of fruits is:
Apple
Orange
Mango
Banana
En este programa, la función de las frutas() se ha convertido en un
generador de funciones, ya que contiene una palabra clave de yield.
El generador de esta funcion frutas() devuelve esta asignacion a una
variable, f. En una llamada al método __ next__() de la f generador,
la primera cadena de la lista, Apple, se rindió. Cuando se llama al
método __ next__() por primera vez en el generador, la ejecución del
generador de la función de frutas comienza y continúa hasta que se
encuentra la palabra clave de yield.
En cada llamada sucesiva del método __ next__ (), la ejecución de la
función de generador continuará en la instrucción que sigue a la
palabra clave de rendimiento, lo que resulta en que produce la
siguiente cadena en secuencia. Desde la declaración de rendimiento
se produce dentro de un bucle, la ejecución continuará dentro del
bucle. El programa también muestra todos los cadenas a través del
objeto generador.
Si se llama a __ next__() después de eso, usted consigue una
excepción:
Traceback (most recent call last):
File "D:\python\generatorex.py", line 12, in <module>
print (f.__next__())
StopIteration

Al lado de los generadores, hay una forma más para crear iteradores,
y que es a través de la expresión del generador.

Generator Expression - Expresión Generador

Una expresión generadora es una expresión entre paréntesis que crea
un objeto iterador. Al llegar el objeto iterador, se puede llamar al
método __ next__ () para obtener el siguiente valor del iterador
como se ha visto en los dos programas anteriores. La expresión
generador es como una función anónima que produce valores y por lo
general se compone de al menos una de cláusula y cero o más si
cláusulas. La expresión generadora que se va a utilizar en el
siguiente programa consiste en un bucle for:

(squarenum(x) for x in range(6))

Esta expresión generador producirá un objeto iterador.
genexpression.py
def squarenum(x):
return x*x
iteratorobj = (squarenum(x) for x in range(6))
print('The squares of first five sequence numbers')
print (iteratorobj.__next__())
print (iteratorobj.__next__())
print (iteratorobj.__next__())
print (iteratorobj.__next__())
print (iteratorobj.__next__())
print (iteratorobj.__next__())
Output:
The squares of first five sequence numbers
0
1
4
9
16
25

En este programa, se puede ver que la expresión de generador

(squarenum (x) for x in range (6)) crea un objeto iterador, que
luego se asigna a iteratorobj. La expresión generadora llama a la
función squarenum () y utiliza un bucle para producir los cuadrados
de los valores numéricos de 0 a 5. A partir de entonces, el uso de
la __ next__(), se accede a los valores cuadrados del objeto
iterador uno por uno.

Modules
Un módulo es un archivo que consta de un par de funciones y
variables que se utilizan para una tarea particular. Un módulo puede
ser reutilizado en cualquier otro programa que lo importa. Las
funciones y variables del módulo que se disponga en el programa
actual y se pueden utilizar en el mismo. El nombre de archivo del
módulo debe tener una extensión .py.
Para importar un módulo a un programa, se utiliza la sentencia
import. Puede utilizar la importación en varias formas. Considere la
posibilidad de un módulo de calendario que muestra un calendario de
un mes y el año especificado. Vamos a echar un vistazo a las
diferentes formas de importar un módulo de calendario en el programa
actual. La primera forma es a través de esta declaración:
import calendar

bloque principal de ese módulo se ejecutan de manera que sus

funciones pueden ser reutilizadas en el programa actual. Es decir,
todas las funciones del módulo de calendar se hacen accesibles en el
programa actual. Para consultar una función prcal() del módulo de
calendar, escriba la siguiente declaración:
calendar.prcal()

La segunda forma de importar un módulo de calendario para el

programa actual es a través de esta declaración:
from calendar import prcal

Esto importa la función prcal() del módulo de calendar. Ahora se

puede hacer referencia directamente a la función prcal() en el
programa actual sin prefijar el nombre del módulo de calendar a la
misma:
prcal()

La tercera forma de importar un módulo de calendario para el

programa actual es a través de esta declaración:
from calendar import *

Esto importa todos los objetos del módulo de calendario. Se puede

acceder a cualquier función del módulo de calendario directamente
sin prefijar el nombre del módulo a la función. Para hacer
referencia a la función prcal() del módulo de calendario, se puede
escribir:
prcal()

La cuarta forma de importar un módulo de calendario para el programa

actual es a través de esta declaración:
import calendar as cal

Se importa el módulo de calendario en el programa actual y hace que

sea accesible a través de la expresión cal. Su función prcal() ahora
se puede acceder mediante un prefijo con el término cal:
cal.prcal()

El siguiente programa importa un módulo de calendario en el programa

y muestra el calendario del año especificada con su funcion prcal().
module1.py
import calendar
year = int(input("Type in the year number:"))
calendar.prcal(year)

También puede volver a escribir el programa como se muestra aquí:

from calendar import prcal
year = int(input("Type in the year number:"))
prcal(year)

La salida del programa será el calendario del año entrado, como se

muestra en la Figura 4.1.
Este programa muestra el calendario del año introducido por el
usuario. La técnica de llamar a la funcion prcal() cambia de acuerdo
con el método utilizado en la importación del módulo de calendario
para el programa.
El siguiente programa imprime la hora del reloj del sistema
infinitamente:
module2.py
from time import time, ctime
prev_time = ""
while(True):
curr_time = ctime(time())
if(prev_time != curr_time):
print ("The time is:",ctime(time()))
prev_time = curr_time
Output:
The time is: Wed Feb 02 10:16:33 2011
The time is: Wed Feb 02 10:16:34 2011
The time is: Wed Feb 02 10:16:35 2011
The time is: Wed Feb 02 10:16:36 2011
The time is: Wed Feb 02 10:16:37 2011
En este programa, que desea mostrar el reloj del sistema
infinitamente y no quieren al mismo tiempo que se repita de nuevo.
Recuerde, los ciclos de la máquina de la CPU es mucho más rápido que
un reloj y ejecutar un bucle o un programa varias veces en un
segundo. Por lo tanto, al mismo tiempo se mostrará una y otra vez.
Para evitar esto, se utilizan dos variables: uno almacena la hora
del reloj del sistema actual, y el otro espera para el momento de
cambiar.
Primero, el programa importa las funciones de tiempo y ctime del
módulo de tiempo en el programa actual. A continuación se ejecuta un
bucle infinito. En el bucle, se accede a la hora del reloj del
sistema actual y se almacena temporalmente en la variable curr_time.
Se muestra el tiempo en curr_time y asignado a otra variable,
prev_time. En la siguiente iteración del bucle while, la hora del
reloj del sistema es más descabellada y se almacena en la variable
curr_time. Hasta el momento en curr_time difiere del tiempo en
prev_time, no se mostrará el nuevo tiempo exagerado en curr_time.
Después de mostrar la nueva hora en curr_time, se le asigna a la
variable prev_time, y el bucle continúa.

The math Module

El módulo de matemáticas no sólo contiene las funciones
trigonométricas comunes, sino también varias constantes y funciones:
•
•
•
•

math.pi—Returns the value of pi, 3.1415926535897931.

math.e—Returns the value of e, 2.7182818284590451.
ceil(x)—Muestra el número entero más grande.
floor(x)—Muestra el número entero más pequeño.

El módulo matemático se pone a disposición del programa a través de

esta declaración:
import math

El siguiente programa calcula y muestra los siguientes números

enteros más grandes y más pequeñas del valor float especificada
utilizando las funciones del módulo de matemáticas ceil() y el
floor().
mathmethod.py
import math
print (math.ceil(7.3))
print (math.ceil(-7.3))
print (math.floor(7.9))
print (math.floor(-7.9))
Output:
8 7
7 8
En este programa, se importa el módulo matemático y utiliza sus
metodos ceil() y el floor() para mostrar los próximos números
enteros grandes y más pequeños.
¿Proporciona una función de Python que se puede utilizar para ver
todos los identificadores definidos en un módulo? Sí, y el nombre de
la función es dir().

The dir() Function

La función dir() se usa para listar los identificadores definidos
por un módulo. Los identificadores son las funciones, clases y
variables definidas en ese módulo. Cuando se proporciona un nombre
de módulo para la función dir(), devuelve una lista de los nombres
definidos en dicho módulo. Cuando no se aplica el argumento de que,
la función dir() devuelve una lista de los nombres en el ámbito
local actual.
El siguiente programa muestra la lista de identificadores definidos
en losmódulos de sys y calendar:
direx.py
import sys, calendar
print("The list of methods and attributes in the local scope:",dir())
print ("\nThe list of methods and attributes in the calendar module:",
dir(calendar))
print ("\nThe list of methods and attributes in the sys module:", dir(sys))
Output:
The list of methods and attributes in the local scope: ['__builtins__',
'__doc__' ,
'__name__', '__package__', 'calendar', 'sys']
The list of methods and attributes in the calendar module: ['Calendar', 'EPOCH', '
FRIDAY',
'February', 'HTMLCalendar', 'IllegalMonthError', 'IllegalWeekdayError', ' January'
, 'LocaleHTMLCalendar', 'LocaleTextCalendar' , 'MONDAY', 'SATURDAY', 'SUNDAY' ,
'THURSDAY', 'TUESDAY', 'TextCalendar', 'WEDNESDAY' , '_EPOCH_ORD', '__all__' ,
'__builtins__' , '__cached__', '__doc__', '__file__', '__name__' , '__package__' ,
'_colwidth', '_locale', '_localized_day', '_localized_month', '_spacing', 'c', '
calendar',
'datetime', 'day_abbr', 'day_name', 'different_locale', 'error', ' firstweekday'
, 'format' , 'formatstring' , 'isleap', 'leapdays' , 'main', 'mdays', 'month' ,
'month_abbr' , 'month_name', 'monthcalendar' , 'monthrange', 'prcal', 'prmonth' ,
'prweek', 'setfirstweekday', 'sys', 'timegm', 'week', 'weekday', 'weekheader']
The list of methods and attributes in the sys module: ['__displayhook__',
'__doc__' ,
'__excepthook__', '__name__' , '__package__' , '__stderr__' , '__stdin__' ,
'__stdout__' , '_clear_type_cache', '_current_frames' , '_getframe', '_xoptions' ,
'api_version', 'argv', 'builtin_module_names' , 'byteorder', 'call_tracing' , '
callstats',
'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info' ,
'excepthook', 'exec_prefix', 'executable', 'exit', 'flags' , 'float_info', '
float_
repr_style', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding' ,
'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval'
,
'gettrace', 'getwindowsversion', 'hash_info', 'hexversion' , 'int_info',
'intern' ,
'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', '
path_importer_
cache', 'platform', 'prefix', 'setcheckinterval', 'setprofile', '
setrecursionlimit',
'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion' ,
'version', 'version_info', 'warnoptions', 'winver'

Command-Line Arguments - Argumentos de línea de

comandos
Argumentos de la línea de comandos se utilizan para pasar argumentos
a un programa mientras se está ejecutando ello. Cada argumento de
línea de comandos que se pasa al programa se almacenará en la
variable sys.argv. La variable sys.argv es una lista que siempre
tiene una longitud de al menos 1. El elemento en el índice 0 es el
nombre del programa en Python que está ejecutando.
nota
Argumentos de la línea de comandos se separan con espacios.
El programa siguiente se enumeran los argumentos de la línea de
comandos pasados al programa, su count, y el path de la instalación
de Python.
commandline1.py
import sys
print ('There are %d arguments' % len(sys.argv))
print ('The command line arguments are:' )
print (sys.argv)
for i in sys.argv:
print(i)
print ('Path of the Python is' , sys.path)

La salida se muestra en la Figura 4.2.

Figure 4.2. Command-line arguments passed to the program.
Summary – resumen
En este capítulo usted aprendió acerca de las diferentes
declaraciones que definen y valores devueltos de funciones. También
aprendió a utilizar los parámetros de valor predeterminado y
argumentos de palabras clave en una función. Usted aprendió a
utilizar las variables locales y globales. Para las expresiones más
pequeñas, usted aprendió a crear funciones lambda. También, usted
vio cómo aplicar funciones a las secuencias utilizando diferentes
atributos de función e implementar recursividad. Para acceder a las
colecciones de datos, usted aprendió a utilizar iteradores,
generadores, y las expresiones generadoras. Para utilizar las
funciones incorporadas, usted aprendió a importar y utilizar
módulos. Por último, usted vio cómo pasar argumentos de línea de
comandos para un programa Python.
El siguiente capítulo tratará de la programación orientada a objetos
(POO). Usted aprenderá a definir las clases, definir funciones en
una clase, y el uso de atributos de clase. Usted aprenderá a
inicializar las variables de instancia a través del método __init__.
Usted aprenderá a definir y utilizar clases y métodos estáticos.
Usted verá cómo Python elimina los objetos que salen de alcance a
través de la recolección de basura. El capítulo también trata un
tema importante en la programación orientada a objetos, la herencia.
Usted aprenderá a aplicar sola, multinivel, y la herencia múltiple.
Usted también aprenderá a aplicar el método de primer orden y las
operaciones aritméticas a través de las instancias la sobrecarga de
operadores. En el capítulo también se explicará el concepto de
polimorfismo y el uso de propiedades y descriptores.

Chapter 5. Classes
En este capítulo se tratan los siguientes temas:
• Definición de las clases
• El uso de atributos de clase
• Definición de funciones en una clase
• Acceso a variables de clase en los métodos de instancia
• Creación de instancias e inicializar variables de instancia a
través del método __init__ ()
• Uso de clases y métodos estáticos
• Entender Recolección de basura
• Comprender-herencia simple, multinivel, y la herencia múltiple
• El uso de los especificadores de control de acceso
• Método primordial
• La sobrecarga de operadores
• polimorfismo
• Utilización de las propiedades y los descriptores

The Class Statement- La sentencia Class

Python admite la programación orientada a objetos y proporciona

código reutilizable en forma de clases. Siempre es mejor utilizar el
código antiguo que empezar de cero porque el código ya existente ya
ha sido usado y probado, por lo que ahorra tiempo en la depuración
de un proyecto.
Una clase es como una plantilla o modelo para datos y operaciones.
Se compone de un número de atributos que incluyen variables y
métodos. Las variables se denominan miembros de datos y los métodos
se llaman funciones miembro. Las funciones definen las operaciones
que se pueden aplicar a los miembros de datos. De las clases, crear
instancias, también conocidos como objetos. Las instancias tendrán
acceso automáticamente a los miembros de datos y métodos.
Para crear una clase, se utiliza la instrucción de clase, una
sentencia ejecutable que se utiliza para crear un objeto de clase.
No sólo crea un nuevo objeto de la clase, sino también se le asigna
el nombre especificado.
Syntax:
class classname(base-classes):
statement(s)
donde nombre de clase es un identificador que se enlaza a la clase
de objeto. Puede crear ya sea una clase independiente o una que
herede de otras clases. La clase que hereda también se conoce como
una clase derivada o una sub-clase, y la clase que se hereda de que
se conoce como un súper o clase base.
Al crear una clase derivada, se especifica las clases de base
delimitados por comas de
que la nueva clase va a ser derivada. Las clases base también son
conocidos como los padres de la nueva clase que se está creando. La
nueva clase hereda los atributos de sus clases padre. Se puede
reemplazar cualquiera de los atributos de los padres y puede añadir
atributos propios. Las clases base son opcionales. Para crear una
clase sin bases, se puede omitir (base-clases), colocando los dos
puntos después de nombre de clase o classname.
La secuencia de instrucciones que sigue a la declaración de clase se
conoce como el cuerpo de la clase, donde se especifican las
funciones y otros atributos de la clase.

Attributes of Class Objects - Atributos de los objetos de

clase
Para especificar un atributo de un objeto de la clase, se enlaza un
valor a un identificador dentro del cuerpo de la clase. Por ejemplo:
class rect:
l = 8
print (rect.l)
En este ejemplo, rect es un objeto de la clase con un atributo
llamado l que se enlaza con el valor 8, y rect.l refiere a ese
atributo.
El siguiente ejemplo muestra un objeto de clase, rect, con dos
atributos, l y b, con destino a los valores de 8 y 5.
rectclass1.py
class rect:
l=8
b=5
print ("Length is %d, Breadth is %d" %(rect.l, rect.b))
Output:
Length is 8, Breadth is 5

Se puede ver que cuando se hace referencia a los atributos, la clase

de objeto se antepone a los atributos.
Usted también puede tener una clase que no hace nada, como se
muestra en el siguiente ejemplo:
passex.py
class rect(object):
pass
rect.l = 10
print (rect.l)
Output:
10

La sentencia pass no hace nada y representa un bloque vacío de

enunciados. Actúa como un marcador de posición para el código que va
a escribir más tarde. En este programa, se puede ver que el atributo
l de la clase de objeto rect está ligado al valor de 10 fuera del
cuerpo de la clase que se muestra a continuación.

Built-In Class Attributes

Atributos en clase incorporada
Una declaración de clase establece implícitamente algunos atributos
de clase. Puede utilizar estos atributos de clase para obtener
información acerca de una clase. Una lista de los atributos de clase
se muestra en la Tabla 5.1.

Table 5.1. Class Attributes

Attribute

Description
__name__

El identificador de nombre de la
clase utilizada en la declaración de
clase.

__bases__

La tupla de objetos de clase

especificados como las clases base
en la declaración de clase.

__dict__

El objeto de diccionario que la

clase utiliza para mantener sus
otros atributos. Para asignar un
valor a un atributo, se utiliza el
objeto de diccionario. El ejemplo
siguiente asigna el valor 8 al
atributo l de la clase de objeto
rect: rect.__dict__ ['l'] = 8

__doc__

La cadena de documentación de la
clase.

__module__

El nombre del módulo en el que se

define la clase.

El siguiente programa muestra el nombre de la clase, de la clase

base, diccionario de objetos, y así sucesivamente con la clase de
atributos:
rectclass2.py
class rect:
l=8
b=5
print ("Length is %d, Breadth is %d" %(rect.l, rect.b))
print ("Length is %d, Breadth is %d" %(rect.l, rect.b))
print ("Class name is ", rect.__name__, " and Base class is
",rect.__bases__)
print ("Attributes of this class are ", rect.__dict__)
Output:
Length is 8, Breadth is 5
Class name is rect and Base class is (<class 'object'>,)
Attributes of this class are {'__module__': '__main__', 'b': 5, 'l': 8,
'__dict__':
<attribute '__dict__' of 'rect' objects>, '__weakref__': <attribute
'__weakref__' of
'rect' objects>, '__doc__': None}

Este programa define e inicializa dos atributos del objeto de la

clase rec, l y b, a los valores de 8 y 5. El l y atributos b, nombre
de la clase, y la base de nombre de la clase se visualizan. El
programa también muestra los atributos de la clase a través de un
objeto de diccionario.
nota
Si no especifica una clase base, el valor predeterminado es
objeto.

Defining Functions in a Class

Definición de funciones en una clase
Las funciones definidas en una clase se conocen como métodos. Un
método definido en una clase siempre tiene un primer parámetro
obligatorio llamado self (auto) que hace referencia a la instancia
en la que se llama al método.
El parámetro self juega un papel especial en las llamadas a métodos.
Los métodos que se le de definición en la clase son llamados métodos
de instancia. Más adelante se verá la forma de definir los métodos
de clase en una clase. El formato de la clase con métodos añadidos
es la siguiente:
class classname(base-classes):
class variable(s)
def method 1(self):
instance variable(s)
statement(s)
[def method n(self):
instance variable(s)
statement(s)]

Una clase puede tener dos tipos de miembros de datos:

Class variable—Clase variable .-El miembro de datos que se
encuentra fuera de cualquier método de la clase se conoce como una
variable de clase. Todas las instancias de la clase comparten las
variables de clase, y los cambios realizados en la variable de clase
por una instancia serán vistos por otras instancias.
Instance variable— Instancia variable.- Las variables que se
definen dentro de un método sólo pertenecen a la instancia actual
del objeto y se conocen como variables de instancia. Los cambios
realizados en las variables de instancia por ninguna instancia se
limitan a ese caso concreto y no afectan a las variables de
instancia de otras instancias.
Vamos a ver cómo crear un método de instancia y cómo se puede
utilizar para acceder a las variables de clase.

Acceso a variables de clase en Métodos de instancia

Para acceder a las variables de clase, los métodos definidos
cuerpo de primer nivel deben utilizar un nombre completo; el
de la clase debe tener el prefijo de las variables de clase.
siguiente ejemplo muestra el acceso a las variables de clase
método de instancia:
class rect:
l = 8

en un
objeto
El
en un
b=5
def area(self):
print rect.l*rect.b

Dos variables de clase, l y b, se inicializan a 8 y 5. La instancia

del metodo área() se refiere a la clase l, y las variables b, usando
los nombres totalmente calificados rect.l y rect.b
No se puede entender el concepto de variables de instancia hasta que
usted sepa acerca de las instancias de una clase y cómo crearlos.

Instances
Una clase es una plantilla o modelo de datos y operaciones; utilizar
los datos y operaciones de forma independiente, lo que necesita para
crear instancias. Una instancia es una variable que actúa como una
réplica de una clase. Puedes crear tantas instancias de una clase si
lo deseas.
Cada instancia recibe una copia por separado de los métodos y los
atributos definidos en la clase. Cada instancia puede tener acceso a
los métodos y atributos de la clase de forma independiente, y un
atributo de una instancia no interferir con un atributo de la otra
instancia. También significa que a través de los casos, puede
utilizar una clase para realizar operaciones con varios conjuntos de
datos diferentes. Para crear una instancia de una clase, se llama a
la clase de objeto como si fuera sin parámetros, como se muestra
aquí:
r=rect()
Usted puede ver que el objeto de clase rect se llama como si se
trata de una función. Cada llamada devuelve una nueva instancia de
esa clase. La declaración anterior devuelve una nueva instancia de
la clase, rect, y lo asigna a la variable r.
El siguiente programa calcula el área de un rectángulo mediante la
creación de una instancia de la clase y la invocación de un método a
través de la instancia:
rectclass3.py
class rect:
l=8
b=5
def rectarea(self):
return rect.l * rect.b
r=rect()
print ("Area of rectangle is ", r.rectarea())
Output:
Area of rectangle is 40

En este programa, se crea una instancia de la clase rect con el

nombre de r. La clase tiene dos variables de clase, l y b,
inicializados a 8 y 5. El método rectarea () de la clase se invoca a
través de la r ejemplo, que calcula y devuelve el área de un
rectángulo. Recuerde, usted necesita especificar self de forma
explícita en la definición del método, mientras que no se especifica
que cuando se llama al método, tal como Python lo agrega
automáticamente.
nota
Python añade el argumento de self automáticamente cuando se
llama a los métodos a través de ejemplo, por lo que no tiene
que incluir el término self cuando se llama a los métodos de la
clase.
En este programa, las variables l y b definidas en la clase rect son
las variables de clase, y las variables de clase están
implícitamente compartidos por todas las instancias de la clase.
También significa que los cambios aplicados a las variables de clase
por una instancia pueden ser vistos por otra instancia de la clase.
Este problema se resolverá cuando se crean las variables de
instancia.
El método que vamos a discutir la próxima ayuda al inicializar las
variables de una instancia.

The __init__() Method - El metodo __init__()

El método __ init__ es el primer método que se ejecutará después de
la creación de una instancia. Este método es como un constructor de
lenguajes C + + y Java y se utiliza para realizar la inicialización.
Los argumentos pueden o no pueden ser pasados al método __ init__.
nota La instancia ya se construye en el momento en __ init__ es
llamado.
El primer argumento de cada método de clase es una referencia a la
instancia actual de la clase. Este primer argumento es llamado self.
En el método __ init__, self se refiere a la instancia recién
creada; en otros métodos de la clase, se refiere a la instancia cuyo
método ha sido llamado. Al definir __ init__, debe recordar llamar
método del ancestro __ init__ explícitamente si está allí.
For example:
class rect:
def __init__(self):
self.l = 8
self.b = 5
r=rect()

En este ejemplo, se crea una instancia de la clase rect por nombre

r. El método __ init__ se ejecutará de forma automática para
realizar la tarea de inicialización de las variables de la
instancia. En este caso, el método __ init__ inicializa las
variables l y b de la instancia r a 8 y 5. Las variables l y b
definidas en la clase son variables de instancia.
nota
El método __ init__ no debe devolver un valor, o bien se
lanzara una excepción TypeError.
El programa siguiente muestra el método __ init__ al inicializar las
variables de instancia y también calcula el área de un rectángulo:
defaultcons.py
class rect:
def __init__(self):
self.l = 8
self.b = 5
def rectarea(self):
return self.l * self.b
r=rect()
print ("Area of rectangle is ", r.rectarea())
Output:
Area of rectangle is 40

Una instancia de la clase de objeto rect es creado por nombre de r.

El método __ init__ se ejecutará automáticamente para inicializar
las variables de la instancia r. Las variables l y b de la instancia
de r se inicializan a 8 y 5. Finalmente, el método de la rectArea()
se llama a través de ejemplo R y calcula y devuelve el área del
rectángulo.
Después de la creación de una instancia, el método __ init__ se
ejecuta automáticamente. ¿Se puede pasar argumentos al método
__ init__ para inicializar las variables de instancia?

Passing Arguments to the __init__ Method

Pasar argumentos al método __ init__
El programa siguiente muestra el paso de argumentos al método
__ init__:
paramcons.py
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def rectarea(self):
return self.l * self.b
r=rect(5,8)
print ("Area of rectangle is ", r.rectarea())
Output:
Area of rectangle is 40

Una instancia de la clase de objeto rect es creado por nombre de r.

Los dos argumentos, 5 y 8, que se suministran durante la creación de
la instancia, r se pasarán al método __ init__ como argumentos. Es
decir, los valores de 5 y 8 serán asignados a los parámetros x e y
del método __ init__ de donde serán asignados a las variables de
instancia l y b. Finalmente, el método rectArea() se llama a través
de instancia r que calcula y devuelve el área del rectángulo.
nota
Los argumentos que se pasa al método __ init__ si alguna tiene
que ser suministrado en la inicialización de la instancia.
¿Se puede tener parámetros de valores por defecto en el método __
init__ como en las funciones normales? Sí.

Defining Default Value Parameters in the __init__ Method

Definición de los parámetros de valor por defecto en el
método __ init__
Este ejemplo muestra cómo se especifican los valores predeterminados
para los parámetros del método __ init__ de modo que si el valor de
cualquier parámetro no se suministra al inicializar una instancia,
se utiliza el valor por defecto.
El siguiente programa muestra el uso de parámetros de valor por
defecto en el método __ init__. El programa demuestra crea dos
instancias: una que proporciona los argumentos y otro que no
suministran ningún argumento. Los valores por defecto serán
considerados para la instancia que no proporciona argumentos. Aquí
está el código:
constructor.py
class rect:
def __init__(self,x=8, y=5):
self.l = x
self.b = y
def rectarea(self):
return self.l * self.b
r=rect()
s=rect(10,20)
print ("Area of rectangle is ", r.rectarea())
print ("Area of rectangle is ", s.rectarea())
Output:
Area of rectangle is 40
Area of rectangle is 200

Se puede ver que el método __ init__ define los valores por defecto
para los parámetros x e y como 8 y 5. Las dos instancias de rect se
crean como r y s. La instancia r no tiene argumentos para el método
__ init__ y por lo tanto, los valores por defecto 8 y 5 en los
parámetros x e y se utilizará para inicializar sus variables de
instancia l y b.
La instancia s suministra los argumentos 10 y 20 cuando se
inicializa y se asignará a los parámetros x e y desde donde se van a
asignar a sus variables de instancia l y b. El método rectArea()
cuando se invoca por los dos casos calculará y devolver el área de
un rectángulo sobre la base de los valores asignados a sus variables
de instancia, l y b.
Por ahora, usted sabe cómo crear una instancia y cómo inicializar
sus variables a través de __ init__. Ahora vamos a ver el
procedimiento para imprimir la instancia. Recuerde, usted no está
imprimiendo las variables de instancia, pero la propia instancia.
Cuando la impresión de una instancia, se convierte en una cadena.

String Representation of an Instance

Representación de cadena de una instancia
El método __ str__ es llamado por el str() y declaraciones de
impresión para mostrar la representación de cadena de una instancia.
classstr.py
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def __str__(self):
return 'Length is %d, Breadth is %d' %(self.l, self.b)
def rectarea(self):
return self.l * self.b
r=rect(5,8)
print (r)
print ("Area of rectangle is ", r.rectarea())
Output:
Length is 5, Breadth is 8
Area of rectangle is 40

Este programa crea una instancia r de la clase rect y pasa los

valores de 5 y 8 con el método __ init__ para asignarlos a sus
variables de instancia l y b. Entonces, instancia r se pasa a una
sentencia print que se traduce en la creación de la representación
de cadena de la instancia y, por tanto invoca el método __ str__. El
método __ str__ devuelve un mensaje que muestra los valores de las
variables de instancia l y b, por lo que toda la instancia se
devuelve en forma de cadena. El programa también calcula y muestra
el área del rectángulo a través rectarea()
Además de los métodos de instancia, también se pueden crear métodos
de clase y los métodos estáticos en una clase.
Vamos a aprender acerca de ellos.
Class Methods
Métodos de la clase
Un método de clase no tiene ningún argumento self y recibe una clase
como su primer argumento. Por convención, el argumento al método de
la clase se llama cls. Es decir, en un método de clase, la clase en
la que se llama se le pasa como primer argumento. El método de la
clase también se puede llamar directamente a través del objeto de
clase sin crear instancias de la clase.
Un método de clase se define utilizando el decorador @classmethod.
Un decorador proporciona un método conveniente para insertar y
modificar el código en funciones o clases.

Syntax:
@classmethod
def f(cls, parm1, parm2, . . .):
body of the method
Este muestra un método de clase, f, con pocos parámetros parm1,
parm2, y así sucesivamente.
El programa siguiente crea una clase, así como un método de
instancia y accede a ellos para mostrar el contenido de las
variables de instancia y de clase.
classmethod.py
class book:
price=100
@classmethod
def display(cls):
print (cls.price)
def show(self,x):
self.price=x
print (self.price)
b=book()
c=book()
book.display()
b.display()
b.show(200)
c.show(300)
Output:
100
100
200
300

Este programa define un objeto de clase, book, que contiene una

variable de clase, precio, inicializado a 100. Además, la clase
contiene un método de clase, display() y un método de instancia,
show().Dos instancias, b y c, se crean de la clase book. El método
de clase display() se llama a través de la clase de objeto, book,
que muestra el valor de la variable clase de precio, 100. El método
de clase display() se llama a través de la instancia b, que de nuevo
muestra el valor de la variable precio de clase como 100. A
continuación, el método de instancia show () es llamado a través de
instancia b, pasando el valor 200 a la misma, que se asigna a su
parámetro x, y que, finalmente, se asigna a la variable de
instancia, precio. Ahora, hay dos variables de precios, una variable
de clase inicializado valorar 100, que es común para todas las
instancias, y una variable de instancia de la instancia b conjunto a
200.
El metodo de instancia show() se llama a través de la instancia de
c, pasando el valor 300 como argumento para ser asignado a su
variable de instancia, el precio.
Hay una alternativa al método de clase conocida como el método
estático.

Static Methods - Métodos estáticos

Un método estático es una función ordinaria que se construyeron
usando el decorador @staticmethod y que se une a su resultado a un
atributo de clase. La diferencia entre un método estático y un
método de clase es que un método estático tiene ningún parámetro
cls. No utiliza el parámetro de self, tampoco. Hay otra diferenciael método de
clase se hereda de forma automática por cualquier
clases hijas, mientras que el método estático no es. Además, la
definición de un método estático es inmutable a través de la
herencia. Un método estático se puede llamar en una clase o en
cualquier instancia de una clase.
Syntax:
@staticmethod
def name (parm. . .) :
body of the method
Esto muestra un método estático, name, con parámetros parm ....
El programa siguiente se define una clase que contiene un método
estático y accede a ella a través de un objeto de clase, así como a
través de una instancia.
staticmethod.py
class rect:
@staticmethod
def disp_message():
l=50
print ("Length is ", l)
rect.disp_message()
r=rect()
r.disp_message()
Output:
Length is 50
Length is 50
El programa crea una clase rect con un método estático
disp_message() en ella. En primer lugar, disp_message() se llama a
través de la rect objeto de clase. El método inicializa un atributo
l al valor 50 y lo muestra. Entonces, una instancia r se crea de
rect, y disp_message() se llama a través de la instancia de r.
En disp_message(), otra vez, el valor del atributo l se establece en
50 y se muestra. Por lo tanto, el programa confirma que el método
estático puede ser llamado en una clase, así como en una instancia
de una clase.
El programa siguiente crea una clase que contiene un método estático
y un método de clase y muestra cómo se visualiza una variable de
clase a través de los dos métodos:
staticlassmethod.py
class product:
count = 0
def __init__(self, name):
self.name=name
product.count += 1
@staticmethod
def prodstatcount():
return product.count
@classmethod
def prodclasscount(cls):
print('Class info: ', cls)
print ('Class method - The product count is: ', cls.count)
p1=product('Camera')
p2=product('Cell')
print('Static method - The product count is: ', product.prodstatcount())
p2.prodclasscount()
Output:
Static method - The product count is: 2
Class info: <class '__main__.product'>
Class method - The product count is: 2

El programa define una clase de producto que contiene una variable

de clase, count, inicializado a 0. La clase contiene un método
estático y un método de clase, prodstatcount() y prodclasscount().
Una instancia, p1, de la clase producto se crea que pasa la cadena
'Camera' al método __ init__ que se asignará a su variable de
instancia, name. El método __ init__ también incrementa el valor de
la variable de clase count en 1. Del mismo modo, otra instancia, p2,
se crea que pasa la cadena 'teléfono' al método __ init__ que se
asignará a su variable de instancia, name. El método __ init__ de
nuevo incrementa el valor de la cuenta por variable de clase 1, por
lo que su valor de 2. A partir de entonces, el método estatico
prodstatcount() se llama en el objeto de la clase de producto, que
devuelve el valor de la variable de clase count, 2. Finalmente, el
método de clase prodclasscount() se invoca en la instancia p2,
pasando por la clase de producto a la misma a través de la parámetro
cls. La información de la clase se muestra mediante la impresión del
parámetro cls, y se muestra el valor de la variable de clase count.

Assigning One Instance to Another

La asignación de una instancia a otra
Python proporciona una facilidad para asignar una instancia a otra.
Asignación de una instancia a otra resultados en la creación de una
nueva instancia si no existe. Por ejemplo, suponiendo inst1 y inst2
son instancias de alguna clase, entonces la siguiente declaración:
inst1=inst2
creará la instancia inst1 , si no existe, y se inicializan todas las
variables de instancia de inst1 a valores iguales a los de las
variables de instancia de inst2.
El programa siguiente muestra cómo se asigna una instancia a otro y
los resultados en la asignación de los atributos de una instancia a
otra instancia.
assignobj.py
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def rectarea(self):
return self.l * self.b
r=rect(5,8)
s=r
print ("Area of rectangle is ", r.rectarea())
print ("Area of rectangle is ", s.rectarea())
Output:
Area of rectangle is 40
Area of rectangle is 40

En este programa, un objeto r se crea la clase Rect. Los argumentos

5 y 8 se pasan al método __ init__, y a continuación, se asignan a
los variables l y b de la instancia de r. El contenido de la
instancia de r se asigna a la instancia s. Es decir, la instancia de
s también tendrá sus variables de instancia inicializan a 5 y 8.
Esto se comprueba mediante el cálculo del área de un rectángulo
invocando rectArea () a través tanto de las instancias, y el área
que sale de la misma.

Garbage Collection - Recolección de Basura

La recolección de basura es un procedimiento de liberar la memoria
utilizada por las variables o instancias que ya no son necesarios.
La memoria que se utiliza en los casos generalmente se libera
automáticamente cuando las variables asignadas a ellos fuera de
ámbito. Es por eso que las pérdidas de memoria son raros en Python.
Para la recolección de basura, Python utiliza un mecanismo de lucha
contra el de referencia. Cada objeto tiene un contador de referencia
que indica el número de referencias que existen para ese objeto. Los
incrementos de referencia count para cada referencia añaden al
objeto y se disminuye mediante la eliminación de la referencia a ese
objeto. Cuando el recuento de referencia llega a cero, el objeto es
basura recogida.
El
Se
la
de

programa siguiente muestra el concepto de recolección de basura.

crean dos instancias. Una variable de clase se incrementa en 1 en
creación de una instancia y se disminuye en 1 en la eliminación
una instancia.

destructor.py
class rect:
n=0
def __init__(self,x,y):
rect.n +=1
self.l=x
self.b=y
def __del__(self):
rect.n -=1
class_name = self.__class__.__name__
print(class_name,' destroyed')
def rectarea(self):
print ('Area of rectangle is ', self.l * self.b)
def noOfObjects(self):
print ('Number of objects are: ', rect.n)
r=rect(3,5)
r.rectarea()
s=rect(5,8)
s.rectarea()
r.noOfObjects()
del r
s.noOfObjects()
del s
Output:
Area of rectangle
Area of rectangle
Number of objects
rect destroyed
Number of objects
rect destroyed

is 15
is 40
are: 2
are: 1

En este programa, se crea una instancia r y pasa los valores de 3 y

5 como argumentos al método __ init__ para asignarlos a sus
variables de instancia l y b. En la creación de la instancia de r,
la variable de clase que se estableció inicialmente en 0 se
incrementa en 1. Del mismo modo, otro ejemplo, s, se crea, el paso
de argumentos 5 y 8 a su método __ init__ para la asignación a sus
variables de instancia l y b .
Una vez más, el valor de la variable de clase n se incrementa en 1,
por lo que su valor de 2. El área de un rectángulo se calcula en
instancias r y s. El método noOfObjects() muestra el valor de la
variable de clase n (2), lo que confirma la existencia de dos
instancias de la clase. Cuando se elimina la instancia de r, el
método __ del__ se ejecuta, el valor de la variable de clase n se
reduce, y se muestra un mensaje que confirma la destrucción de la
instancia.
Después de eliminar la instancia de r, cuando se llama al metodo
noOfObjects(), el valor de la variable de clase n se muestra como 1,
lo que confirma que se deja sólo una única instancia de la clase
rect. Por último, s también se suprime, lo que reduce el valor de la
variable de clase 0.

Inheritance – herencia
La herencia es una técnica de copiar los miembros de datos y las
funciones miembro de una clase existente en otra clase. Es decir, en
lugar de comenzar desde cero, una clase existente se puede heredar,
y los miembros adicionales de datos y funciones de miembro puede ser
definido. La clase que se hereda se llama clase base o la super
clase, y la clase heredada se denomina clase derivada o subclase. La
subclase hereda todas las propiedades de la clase base y por lo
tanto da lugar a ahorrar tiempo y esfuerzo.

Types of Inheritance -Tipos de Herencia

Voy a hablar de tres tipos de herencia:
• herencia simple
• herencia multinivel
• La herencia múltiple

Single Inheritance - herencia individual

Este es el tipo más simple de la herencia, donde una clase se deriva
de otra clase única, como se muestra en la Figura 5.1.

Clase B hereda la
clase A o clase B se
deriva de la clase A. Una clase derivada tiene que identificar la
clase de la que se deriva. Supongamos, por ejemplo, desea obtener la
clase de triángulo de la clase Rect. La definición de la clase de
triángulo aparecerá así:

class triangle(rect):
Esta declaración indica que rect es una clase base, y el triángulo
es una clase derivada.
Considere el siguiente programa de la herencia simple. En este
programa, una clase de triángulo hereda la clase base, rect, como
resultado de la cual la instancia de la clase triángulo puede
acceder a las funciones miembro públicas de la clase Rect (al lado
de sus propias funciones miembro).
inherit1.py
from __future__ import division
class rect:
def __init__(self):
self.l = 8
self.b = 5
def rectarea(self):
return self.l * self.b
class triangle(rect):
def __init__(self):
rect.__init__(self)
self.x = 17
self.y = 13
def trigarea(self):
return 1/2*self.x * self.y
r=triangle()
print ("Area of rectangle is ", r.rectarea())
print ("Area of triangle is ", r.trigarea())
Output:
Area of rectangle is 40
Area of triangle is 110.5

nota
Si tiene __ init__ en ambas clases, el método de la clase base
__ init__ debe hacerse desde el método __ init__ de la clase
derivada.
Este programa define una clase Rect que consiste en un __ init__ y
un método rectArea(). Una clase más, triángulo, se define en el
programa que se deriva de Rect. La clase triángulo formado por
metodos __ init__ y trigarea().
Se crea una instancia r de triángulo. Puesto que la clase triángulo
deriva de rect, la instancia de r puede invocar los métodos de la
clase base rect, así como la de su propia clase. Después de la
creación de la instancia de r, el método __ init__ de triángulo se
ejecuta, lo que a su vez invoca el método __ init__ de su clase
base, rect. Recordemos que el método __ init__ debe llamar
explícitamente al método del ancestro __ init__ si está allí. El
método __ init__ de la clase Rect inicializa los valores de las
variables de instancia l y b a 8 y 5.
Después de la ejecución del método __ init__ de la clase Rect, el
método __ init__ de la clase triángulo se ejecutará, que inicializa
los valores de las variables de instancia x e y a 17 y 13. Ser capaz
de llamar a los métodos de ambos las clases, la instancia r invoca
los metodos rectArea() y trigarea() para calcular y mostrar el área
del rectángulo y el triángulo.

Access Control Specifiers

Los especificadores de control de acceso
Especificadores de control de acceso definen la visibilidad de los
miembros de la clase. Todos los miembros de la clase se les asigna
un límite en el que se puede acceder mediante estos especificadores
de control. Hay dos palabras claves, pública y privada.
Public Miembro - Consultado-desde el interior como en el exterior de
la clase.
private miembro - puede acceder privado desde el exterior del cuerpo
de la clase. Un miembro privado está precedido por un subrayado
doble (__).

Accessing public Members - Tener acceso a miembros públicos

El programa siguiente muestra cómo definir y acceso a los miembros
públicos:
publicaccess.py
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def rectarea(self):
return self.l * self.b
r=rect(5,8)
print ("Area of rectangle is ", r.rectarea())
print ("Area of rectangle is ", r.l* r.b)
Output:
Area of rectangle is 40
Area of rectangle is 40

El programa crea una instancia de r rect y pasa 5 y 8 como

argumentos al método __ init__ para asignar a sus variables de
instancia, l y b. El programa calcula el área de un rectángulo
mediante la invocación del método rectArea() en la instancia de r,
así como por el acceso y la multiplicación de las variables de
instancia de l y b fuera del cuerpo de la clase, lo que confirma que
las variables de instancia l y b son de acceso público.

Accessing private Members

Tener acceso a miembros privados
Cuando en un procedimiento de un cuerpo de la clase, un
identificador se definen partiendo con dos signos de subrayado, pero
no termina con guiones bajos, se considera un identificador privado
de la clase. Los identificadores privados no se puede acceder desde
fuera del cuerpo de la clase.
El programa siguiente muestra cómo definir variables de acceso
privado en una clase:
privateaccess.py
class rect:
def __init__(self, x,y):
self.__l = x
self.__b = y
def rectarea(self):
return self.__l * self.__b
r=rect(5,8)
print ("Area of rectangle is ", r.rectarea())
print ("Area of rectangle is ", r._rect__l* r._rect__b)
Output:
Area of rectangle is 40
Area of rectangle is 40

Este programa define dos variables de instancia privada, l y b,

representados por __ l y __ b. Se puede acceder dentro del cuerpo de
la clase. Si se intenta acceder a los miembros privados como r.__l *
r.__b, obtendrá AttributeError: 'rect' no tiene ningún atributo
'__l'. Para acceder a las variables privadas de fuera del cuerpo de
la clase, es necesario utilizar el nombre de clase, junto con el
nombre de instancia como r._rect__l.
Una clase derivada puede tener acceso a los miembros de datos
públicos y las funciones miembro de la clase base. Tal vez la clase
derivada tiene que acceder a una función miembro de la clase base,
pero con una ligera modificación. Por ejemplo, supongamos que la
clase base tiene una función miembro llamada comisión() que calcula
comisión equivalente al 5% de una cantidad, mientras que la clase
derivada necesita una función miembro que calcula comisión del 10%.
En este caso, la clase derivada necesita redefinir la funcion
mienbro comisión() que calcula la comisión de 10% en su propio
cuerpo, anulando la función miembro de la clase base. Vamos a ver el
concepto en detalle.

Method Overriding - el reemplazo de métodos

Si en una clase derivada tiene una función miembro con la misma
firma que el de la clase base, a continuación, decir que la función
de miembro de la clase derivada es reemplazar la función miembro de
la clase base. Si la función miembro es invocado por la instancia de
la clase derivada, se ejecuta la función miembro de la clase
derivada (y no a la función miembro de la clase base).
El programa siguiente muestra el concepto de método de reemplazo.
Una clase de triángulo se hereda de la clase Rect y anula e metodo
área() de la clase base por redefinirlo. Aquí está el código:
override.py
from __future__ import division
class rect:
def __init__(self):
self.l = 8
self.b = 5
def area(self):
return self.l * self.b
class triangle(rect):
def __init__(self):
rect.__init__(self)
self.x = 17
self.y = 13
def area(self):
return 1/2*self.x * self.y
r=triangle()
print ("Area of triangle is ", r.area())
Output:
Area of triangle is 110.5

El programa crea un instancia r de la clase triángulo. Puesto que la

clase triángulo hereda de la clase Rect, su instancia puede ejecutar
los métodos de rect, así como los de triángulo. En la creación de la
instancia, el método __ init__ de triángulo se invoca, que a su vez
invoca el método __ init__ de rect, inicializar las variables de
instancia l, b, x, y y los valores de 8, 5, 17 y 13. Triángulo anula
el metodo area(), por lo que cuando se invoca el método area () en
la instancia de r, se ejecutará el metodo área() de la clase de
triángulo, calculando y devolviendo el área del triángulo en lugar
de el área del rectángulo.
¿Qué pasa si quiero obtener el área del rectángulo, así como el área
del triángulo? Para esto, es necesario llamar al método de la clase
base de la clase derivada.

Accessing Methods of a Base Class from a Derived Class

Acceso a métodos de una clase base desde una clase derivada
Se puede acceder a los métodos de la clase base de la clase derivada
utilizando un nombre completo, anteponiendo el nombre de clase para
el nombre del método. El programa siguiente muestra cómo acceder a
un método de la clase base de la clase derivada:
inherit2.py
from __future__ import division
class rect:
def __init__(self):
self.l = 8
self.b = 5
def area(self):
print ("Area of rectangle is ", self.l * self.b)
class triangle(rect):
def __init__(self):
rect.__init__(self)
self.x = 17
self.y = 13
def area(self):
rect.area(self)
print ("Area of triangle is ", 1/2*self.x * self.y)
r=triangle()
r.area()
Output:
Area of rectangle is 40
Area of triangle is 110.5

El programa contiene dos clases, rect y el triángulo, los dos

consistentes en los métodos __ init__ y area(). La clase triángulo
hereda de la clase Rect, por lo que anula el metodo área() de la
clase base, rect. Se crea una instancia r de triángulo, y el área()
se invoca en él. Como era de esperar, se invocará el método area()
de la clase derivada, triángulo. En el método de área() de la clase
triángulo, el método de la area() de la clase base, Rect, se invoca,
y el programa imprime el área del rectángulo, así como el área del
triángulo.
Ahora vamos a aprender acerca de la herencia de varios niveles.
Multilevel Inheritance
herencia multinivel
Cuando una clase hereda de una clase que a su vez es heredado por
alguna otra clase, usted lo llama herencia multinivel, como se
muestra en la Figura 5.2.

La clase B hereda de la clase A, que a su vez es heredada por la

clase C. B puede tener acceso a los miembros públicos de A y C puede
tener acceso a los miembros públicos de B y por lo tanto de A.
Por ejemplo, considere lo siguiente:

class worker:
...
...
class officer(worker):
...
...
class manager(officer):
...
...
La clase de administrador hereda de la clase de oficiales, que es
una clase derivada de la clase trabajadora. En este escenario,
worker es la clase base, officer es una clase base intermedia, y el
manager es una clase derivada.
Administrador hereda las propiedades de officer directamente y las
propiedades de la clase worker indirectamente a través de la clase
de officer. La clase de administrador puede tener acceso a los
miembros públicos de la clase de officer, que a su vez pueden tener
acceso a los miembros públicos de la clase worker.
Vamos a examinar el concepto a través de un programa.
multilevel.py
from __future__ import division
class worker:
def __init__(self, c, n, s):
self.code = c
self.name= n
self.salary = s
def showworker(self):
print ("Code is ", self.code)
print ("Name is ", self.name)
print ("Salary is ", self.salary)
class officer(worker):
def __init__(self, c,n,s):
worker.__init__(self,c,n,s)
self.hra = s*60/100
def showofficer(self):
worker.showworker(self)
print ("HRA - House Rent Allowance is ", self.hra)
class manager(officer):
def __init__(self, c,n,s):
officer.__init__(self,c,n,s)
self.da = s*98/100
def showmanager(self):
officer.showofficer(self)
print ("DA - Dearness Allowance is ", self.da)
w=worker(101, 'John' , 2000)
o=officer(102, 'David', 4000)
m=manager(103, 'Ben' , 5000)
print ("Information of worker is ")
w.showworker()
print ("\nInformation of officer is ")
o.showofficer()
print ("\nInformation of manager is ")
m.showmanager()
Output:
Information of worker is
Code is 101
Name is John
Salary is 2000
Information of officer is
Code is 102
Name is David
Salary is 4000
HRA - House Rent Allowance is 2400.0
Information of manager is
Code is 103
Name is Ben
Salary is 5000
HRA - House Rent Allowance is 3000.0
DA - Dearness Allowance is 4900.0

El programa contiene tres clases: worker, officer, y manager.

officer hereda de worker. La clase de administrador hereda de
officer. La clase de administrador puede tener acceso a los métodos
de la officer, que a su vez puede tener acceso a los métodos de la
clase trabajador.
Las instancias del trabajador, oficial, y el gerente son creados por
los nombres de w, o, y m. trabajador se supone que debe mostrar el
código, el nombre y el salario. La clase de los oficiales se supone
que mostrará el código, nombre, salario y hra. gerente se supone que
mostrará el código, nombre, salario, hra, y da.
En la herencia de varios niveles, una clase se hereda de otra clase
que a su vez es heredada por una tercera clase. ¿Puede una clase
heredar de dos o más clases?

Two Classes Inheriting from the Same Base Class

Dos clases que heredan de la misma clase base
Considere una situación en la que desea crear dos clases, A y B, que
tienen atributos en común. Clase A se compone de atributos p, q, y
r, y B se compone de atributos p, q, y s. Se puede ver que tanto las
clases tienen p y q en común. En esta situación, es mejor crear una
tercera clase C con dos atributos p y q y dejar que A y B se heredan
de C. Este enfoque ayuda a reducir el código y esfuerzo, ya que sólo
es necesario escribir código para el atributo r para A y para el
atributo s para B.
En el siguiente programa, dos clases heredan de la misma clase base.
Usted desea almacenar el código, el nombre y la información del
sueldo de los officers y managers. Los atributos necesarios para la
recogida de información para los officer son de código, nombre,
salario y hra, y que para los gerentes es de código, nombre,
salario, hra, y da. Ambas clases tienen tres atributos en común:
código, nombre y salario. Así que, para ahorrar tiempo y esfuerzo,
es mejor crear una clase llamado trabajador que consiste en tres
atributos: código, nombre y sueldo y permiten tanto oficiales como
gerente heredan de esta clase. Aquí está el código completo:
inherit3.py
from __future__ import division
class worker:
def __init__(self, c, n, s):
self.code = c
self.name= n
self.salary = s
def showworker(self):
print ("Code is ", self.code)
print ("Name is ", self.name)
print ("Salary is ", self.salary)
class officer(worker):
def __init__(self, c,n,s):
worker.__init__(self,c,n,s)
self.hra = s*60/100
def showofficer(self):
worker.showworker(self)
print ("HRA - House Rent Allowance is ", self.hra)
class manager(worker):
def __init__(self, c,n,s):
worker.__init__(self,c,n,s)
self.hra=s*60/100
self.da = s*98/100
def showmanager(self):
worker.showworker(self)
print ("HRA - House Rent Allowance is ", self.hra)
print ("DA - Dearness Allowance is ", self.da)
w=worker(101, 'John' , 2000)
o=officer(102, 'David', 4000)
m=manager(103, 'Ben' , 5000)
print ("Information of worker is ")
w.showworker()
print ("\nInformation of officer is ")
o.showofficer()
print ("\nInformation of manager is ")
m.showmanager()
Output:
Information of worker is
Code is 101
Name is John
Salary is 2000
Information of officer is
Code is 102
Name is David
Salary is 4000
HRA - House Rent Allowance is 2400.0
Information of manager is
Code is 103
Name is Ben
Salary is 5000
HRA - House Rent Allowance is 3000.0
DA - Dearness Allowance is 4900.0

Este programa define una clase trabajador que consta de tres

atributos: código, nombre y salario. La clase de oficial hereda de
la clase trabajador y su método __ init__, y, además de llamar al
método __ init__ de la clase trabajador, también calcula el atributo
hra. Del mismo modo, la clase de administrador hereda de la clase
trabajador, y su método __ init__, después de llamar al método __
init__ de la clase trabajador, calcula los atributos hra y da. La
idea es que los atributos comunes tratados por una clase común y de
los demás tratados por la clase heredada, lo que reduce el código y
esfuerzo.
Echemos un vistazo a un programa más que demuestra una clase de ser
heredado por dos clases. Supongamos que desea almacenar la
información de los estudiantes de ciencia y los de artes. Los
atributos que desea almacenar para los estudiantes de ciencias son
rollo, el nombre, la física y la química. Para los estudiantes de
artes que desea almacenar rollo, nombre, historia y geografía. Ambas
clases tienen dos atributos en común, rollo y el nombre. Una clase
de estudiantes se crea con estos dos atributos comunes, rollo y el
nombre, y ambas clases se heredan de la clase de los estudiantes.
Aquí está el código completo:
inherit4.py
class student:
def __init__(self, r, n):
self.roll = r
self.name= n
def showstudent(self):
print ("Roll : ", self.roll)
print ("Name is ", self.name)
class science(student):
def __init__(self, r,n,p,c):
student.__init__(self,r,n)
self.physics = p
self.chemistry=c
def showscience(self):
student.showstudent(self)
print ("Physics marks : ", self.physics)
print ("Chemistry marks : ", self.chemistry)
class arts(student):
def __init__(self, r,n,h,g):
student.__init__(self,r,n)
self.history = h
self.geography=g
def showarts(self):
student.showstudent(self)
print ("History marks : ", self.history)
print ("Geography marks : ", self.geography)
s=science(101, 'David', 65, 75)
a=arts(102, 'Ben', 70, 60)
print ("Information of science student is ")
s.showscience()
print ("\nInformation of arts student is ")
a.showarts()
Output:
Information of science student is
Roll : 101
Name is David
Physics marks : 65
Chemistry marks : 75
Information of arts student is
Roll : 102
Name is Ben
History marks : 70
Geography marks : 60

El programa crea dos instancias de la clase ciencia y de artes, s y

a, y dos de ellos pasan la información para el estudiante como un
argumento a sus métodos __ init__. Dado que ambas clases heredan de
la clase del estudiante, su método __ init__ invoca el método __
init__ de la clase del estudiante para inicializar las variables de
instancia, rollo y el nombre, que son comunes a ambas instancias.
Después de eso, los métodos __ init__ de las clases de ciencias y
artes se invocan para asignar las marcas para el resto de los
atributos, como la física y la química marcas de los estudiantes de
ciencias e historia y las marcas de la geografía de los estudiantes
de artes. Para mostrar la información del estudiante de la ciencia,
el metodo showscience () en la instancia de s se invoca, que a su
vez invoca el metodo showstudent() de la clase del estudiante para
imprimir el atributos comunes, rollo y el nombre. La información de
los otros atributos, la física y la química, se muestra a través de
la método showscience (). Del mismo modo, la información del
estudiante de artes se muestra a través del metodo showarts(), que
invoca el metodo showstudent() para mostrar los atributos comunes,
rollo y el nombre.
¿Puede una clase heredar una o más clases? ¡Sí! Y el procedimiento
se llama herencia múltiple.

Multiple Inheritance
herencia múltiple
Si una clase se deriva de más de una clase base, usted lo llama
herencia múltiple, como se muestra en la Figura 5.3. Por lo general,
cuando se necesita para utilizar los miembros de dos o más clases
(sin relación) a través de otra clase, que combina las
características de todas las clases heredando ellos.

La clase C hereda de ambos A y B. Ahora C puede tener acceso a los

miembros públicos de A y B.
Por ejemplo, considere lo siguiente:
class worker
{ ...
...
}
class officer
{ ...
...
}
class manager(worker,officer)
{ ...
...
}

Ya ves que, sin conexión entre ellos, las dos clases de bases,
trabajador y oficial, se heredan de la clase manager. Ahora
administrador puede tener acceso a los miembros públicos de los
trabajadores, así como de oficiales.
nota
Todas las clases de base que han de ser heredado tienen que ser
separados por comas.
El siguiente programa explica la herencia múltiple. Dos clases, los
estudiantes y la ciencia, son heredadas por tercera clase,
resultados.
multiple.py
from __future__ import division
class student:
def __init__(self, r, n):
self.roll = r
self.name= n
def showstudent(self):
print ("Roll : ", self.roll)
print ("Name is ", self.name)
class science:
def __init__(self, p,c):
self.physics = p
self.chemistry=c
def showscience(self):
print ("Physics marks : ", self.physics)
print ("Chemistry marks : ", self.chemistry)
class results(student,science):
def __init__(self, r,n,p,c):
student.__init__(self,r,n)
science.__init__(self,p,c)
self.total = self.physics+self.chemistry
self.percentage=self.total/200*100
def showresults(self):
student.showstudent(self)
science.showscience(self)
print ("Total marks : ", self.total)
print ("Percentage marks : ", self.percentage)
s=results(101, 'David', 65, 75)
print ("Result of student is ")
s.showresults()
Output:
Result of student is
Roll : 101
Name is David
Physics marks : 65
Chemistry marks : 75
Total marks : 140
Percentage marks : 70.0

estudiante está definido por dos atributos, r y n, que representan

roll y el nombre. Una clase más, ciencia, se define que tiene
atributos p y c, que representa a la física y la química. Una clase
de resultados se define que se hereda de ambos estudiante y la
ciencia, por lo que los resultados pueden tener acceso a los
atributos de los estudiantes y la ciencia: r, n, p, y c. La clase de
resultados calcula total y el porcentaje de p y c (fisica y la
química) y muestra todos los seis atributos.
En caso de herencia múltiple, puede surgir un estado confuso.

Two Base Classes Having a Method with the Same Name and
Signature
Dos clases de base que tiene un método con el mismo nombre
y firma
¿Qué sucederá si las dos clases que se derivan de una tercera clase
contiene un método con la misma firma? Supongamos que hay dos
clases, A y B, que tienen un método con el mismo nombre y la firma,
area(), y una tercera clase C hereda de ambos A y B. La instancia de
C tendrá dos copias del método área(). ¿Qué métodode area() va a
ejecutar, el de A o el de B?
La respuesta es que se ejecutará el método de la clase A. El
siguiente programa confirma que será visitada el método de la
primera clase, si dos clases tienen un procedimiento de la misma
firma en la herencia múltiple:
basefunc.py
from __future__ import division
class rect:
def __init__(self):
self.l = 8
self.b = 5
def area(self):
return self.l * self.b
class triangle:
def __init__(self):
self.x = 17
self.y = 13
def area(self):
return 1/2*self.x * self.y
class both(rect, triangle):
pass
r=both()
print ("Area of rectangle is ", r.area())
Output:
Area of rectangle is 40

El programa contiene dos clases, rect y el triángulo, los dos

consistentes en __ init__ y métodos area(). Ambas clases se accede
por una clase denominada both. tanto no tiene métodos propios.
Además, su instancia r tendrá dos copias del método área(). Al
acceder area() a través de r, se observa que se accede al métodode
area() de rect, mostrando el área del rectángulo.
Puede aplicar operaciones aritméticas sobre las instancias de la
clase de la misma manera como se las aplica en los números. Vamos a
aprender más sobre él.

Operator Overloading
sobrecarga de operadores
Para sobrecargar un operador estándar significa que usted solicita
operadores aritméticos para una instancia de clase para realizar las
operaciones deseadas. Puede sumar, restar, multiplicar y dividir los
casos utilizando los operadores estándar de la misma forma en que se
utilizan con los números. Por ejemplo, el método __ add__ se utiliza
para agregar instancias al igual que hace el operador de suma (+).
Cuando se utiliza un operador como +, Python llama al método
especial __ add__ en el fondo. Todo lo que necesitas hacer es
implementar __ add__ para agregar dos instancias.
El siguiente programa, añade las instancias r1 y r2 de la clase rect
mediante el operador +:
operatorovr1.py
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def __str__(self):
return 'Length is %d, Breadth is %d' %(self.l, self.b)
def __add__(self, other):
return rect(self.l+ other.l, self.b+other.b)
def rectarea(self):
return self.l * self.b
r1=rect(5,8)
r2=rect(10,20)
r3=r1+r2
print (r3)
print ("Area of rectangle is ", r3.rectarea())
Output:
Length is 15, Breadth is 28
Area of rectangle is 420

En este programa, r1 y r2 son creados de la clase Rect. Las

variables de instancia L y B de la instancia de r1 se inicializan a
valores de 5 y 8. L y B de la instancia de r2 se inicializan a los
valores 10 y 20. Entonces, r1 y r2 se añaden a través del operador
+, y el resultado se almacena en el recién creado instancia r3.
El operador + se invoca a través de instancias r1, haciéndose pasar
y la segunda instancia, r2, al metodo __ add__, donde l y b ambaos
instancias son añadidas, regresando y asignando a la instancia r3.
El método __ str__ se invoca al llamar una sentencia print para
mostrar la representación de cadena dela instancia r3 . El método __
str__ muestra los valores de las variables de instancia de r3. El
programa también calcula y muestra el área del rectángulo en la
instancia añadida.

Overloading the Comparison Operator (==)

La sobrecarga del operador de comparación (= =)
El siguiente programa explica cómo sobrecargar el operador de
comparación (==) para ver si las dos instancias tienen variables de
instancia con el mismo valor.
operatorovr2.py
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def __str__(self):
return 'Length is %d, Breadth is %d' %(self.l, self.b)
def __eq__(self, other):
return ((self.l== other.l) and (self.b==other.b))
def rectarea(self):
return self.l * self.b
r1=rect(5,8)
r2=rect(10,20)
if r1==r2 :
print('The two instances are equal')
else:
print('The two instances are not equal')
Output:
The two instances are not equal

El programa crea dos instancias de la clase rect, r1 y r2. Las

variables de instancia l y b de la instancia de r1 se inicializan a
5 y 8. Las variables de instancia l y b de la instancia de r2 se
inicializan a 10 y 20. Las instancias r1 y r2 son comparados a
través del operador igual (==) para ver si son la misma. Dado que
los valores de las variables de instancia de las dos instancias no
son iguales, el programa muestra un mensaje, Las dos instancias no
son iguales.

Polymorphism
polimorfismo
Poli significa muchos, y metamorfosis significa cambio. A través de
polimorfismo, se puede tener un método con el mismo nombre en
diferentes clases para realizar diferentes tareas. Usted puede
manejar objetos de diferentes tipos de la misma manera.
Para implementar el polimorfismo, se define un número de clases o
subclases que tienen el método (s) con el mismo nombre. Estas clases
o subclases son polimórficos. Puede acceder a los métodos
polimórficos sin saber que clase o subclase es incovado.
Por ejemplo, el porcentaje de comisión por la venta de un libro
puede ser diferente para un almacenero, un distribuidor y un
minorista. Se puede definir un método de comisión() en tres clasesalmacenistas,
distribuidores y minoristas, donde cada método calcula
un porcentaje diferente de comisión.
En la ejecución del programa, el método respectiva comisión() se
llama en cada instancia. Este es un programa completo que muestra
polimorfismo.
polymorphism.py
class book:
def __init__(self,x):
self.price = x
class stockist(book):
def __init__(self,x):
book.__init__(self,x)
def commission(self):
self.comm=self.price*5/100
print ("Commission of Stockist is %.2f" %self.comm)
class distributor(book):
def __init__(self,x):
book.__init__(self,x)
def commission(self):
self.comm=self.price*8/100
print ("Commission of Distributor is %.2f" %self.comm)
class retailer(book):
def __init__(self,x):
book.__init__(self,x)
def commission(self):
self.comm=self.price*10/100
print ("Commission of Retailer is %.2f" %self.comm)
r = stockist(100)
s = distributor(100)
t = retailer(100)
prncomm = [r,s,t]
for c in prncomm:
c.commission()
Output:
Commission of Stockist is 5.00
Commission of Distributor is 8.00
Commission of Retailer is 10.0

El programa crea r, s, y t instancias del almacenista, distribuidor

y minorista. Las tres clases, almacenista, distribuidor y minorista,
heredan la clase book.
Las tres instancias inicializa su instancia de la variable price
mediante la invocación del método __ init__ de la clase book. Se
crea una lista prncomm que contiene los tres casos.
Se accede a una instancia a la vez de prncomm, y se accede a su
método de comisión () para calcular y mostrar la comisión de la
clase respectiva. Desde la salida, se observa que el método de
comisión() de cada clase calcula y muestra a la Comisión, por lo
tanto, la implementación de polimorfismo.

Properties - Propiedades
Las propiedades se utilizan para administrar los atributos con
métodos get / set. En versiones anteriores de Python, la gestión de
los atributos se hace reemplazando con metodos __ getattr__ y __
setattr__.
Para evitar la sobrecarga de anular estos dos métodos, se utilizan
las propiedades. Se utiliza propiedades para redirigir conjunto de
un atributo, obtener, o incluso borrar la operación a una función.
propertyex.py
class product(object):
def __init__(self, name):
self._name = name
def set_name(self, name):
print ('Setting product name: %s' % name)
self._name = name
def get_name(self):
return self._name
def del_name(self):
del self._name
name = property(get_name, set_name)
p = product('Camera')
print('Getting product name ', p.name)
p.name='Cell'
print('Getting product name ', p.name)
Output:
Getting product name Camera
Setting product name: Cell
Getting product name Cell

Este programa crea una propiedad de nombre que consta de dos

métodos, get_name y set_name, en la clase de producto. Una instancia
de productos, p, se crea que inicializa su instancia de variable
_name para la Camara mediante la invocación de su método __ init__.
El acceso a la propiedad name en p, el método get_name de la
propiedad se invocará automáticamente y devolver el valor de la
variable de instancia _name. Del mismo modo, en la asignación de
valor a la propiedad del nombre, el método set-name se invocará,
asignando el valor pasado a la propiedad a la variable de instancia,
_name.
Hay otra manera de administrar los atributos de instancia,
descriptores. Un descriptor es un superconjunto de propiedades.

Descriptors – Descriptor
Los descriptores son las clases que nos permiten gestionar instancia
atribuye de manera eficiente. Para administrar los atributos de
instancia, se utilizan tres métodos: __ set__, __ get__ y __
delete__. Los descriptores son de dos tipos:
-Los datos no descriptor.-La clase que implementa sólo el
método __ get__ para un objeto se conoce como un descriptor no
datos.
-Descriptor de datos.- La clase que implementa los metodos __
delete__ y __ set__ así como el método __ get__ para un objeto
que se conoce como un descriptor de datos.
Al acceder a un atributo de instancia, Python obtiene el valor del
atributo llamando __ get__ en el descriptor correspondiente. Del
mismo modo, cuando se asigna un valor a una instancia de atributo
con un descriptor correspondiente, el valor de ese atributo se
establece llamando __ set__ en el descriptor.
La sintaxis de los descriptores de codificación es la siguiente:

class Descriptor:
def __get__(self, instance, owner):
...
def __set__(self, instance, value):
...
def __delete__(self, instance):
...
El programa siguiente muestra cómo utilizar los metodos __ set __ y
__ get__ en establecer y obtener instancia atributos:
descript.py
class product:
def __init__(self, name, x=5):
self.name = name
self.price=x
def __set__(self, obj, value):
print ('Setting attribute' , self.name)
self.price = value
def __get__(self, obj, objtype):
print ('Getting attribute',self.name)
return self.price
class cart:
p = product('butter',7)
k=cart()
print(k.p)
k.p=10
print(k.p)
Output:
Getting attribute butter
7 Setting attribute butter
Getting attribute butter
10

Una clase de producto se define, que consta de tres métodos, __

init__, __ set__ y __ get__. Otra clase, cart, se define que
contenga una instancia p de producto. p inicializa su variables de
instancia, el nombre y el precio, a butter y 7.
Se crea una instancia k de la clase cart. Se accede a la instancia p
de producto a través de k en una sentencia de impresión. El método
__ get__ se invoca automáticamente al acceder a una instancia. El
método __ get__ devuelve los valores de las variables de instancia
name y precio para mostrar la información en ellos.
Además, el programa asigna 10 a la instancia de p de la instancia de
k. Como era de esperar, el método __ set__ se invoca en la
asignación de un valor a cualquier variable de instancia. El método
__ set__ asigna el valor pasado 10 a la variable instancia de precio
de la instancia de p.
Para leer y escribir los atributos de clase, puede utilizar los
metodos de __ getattr__ y __setattr__.

The __setattr__ Method

El método __ setattr__
El método __ setattr__ se llama cada vez que se intenta asignar un
valor a una variable de instancia. Al asignar un valor a un
atributo, se debe tener cuidado de que el valor no se puede asignar
de la forma habitual, como se muestra aquí:
self.name = value,
Esto dará lugar a un número infinito de llamadas recursivas a __
setattr__. Por lo tanto, se utiliza el diccionario para asignar
valores a las variables de instancia:
def __setattr__(self, name, value):
self.__dict__[name] = value
El método __ setattr__ también se puede utilizar para llevar a cabo
la comprobación de tipos en los valores antes de asignarlos a
variables de instancia.

The __getattr__ Method

El método __ getattr__ obtiene un atributo de una instancia mediante
un objeto de cadena y se llama cuando se produce un error de
búsqueda de atributos, es decir, cuando se intenta acceder a un
atributo definido. El método __ getattr__ debe devolver el valor (de
cualquier tipo) de la variable de instancia o lanzar una excepción
AttributeError.
def __getattr__(self, name):
return self.name

The __delattr__ Method

El método __ delattr__ se llama cuando un atributo de una instancia
se elimina a través de la sentencia del.
def __delattr__(self, name):
del self.name
El siguiente programa muestra el uso delos metodos __ setattr__ y
__getattr__ para establecer y obtener atributos de instancia:

getsetattr.py
class product:
price=25
def __init__(self, name):
self.name=name
def __setattr__(self,name,value):
self.__dict__[name]=value
def __getattr__(self,name):
return self.name
p=product('Camera')
print (p.price)
print (p.name)
p.price=15
p.name="Cell"
print (p.name)
print(p.price)
Output:
25
Camera
Cell
15
Una clase de producto se define mediante tres métodos: __ init__, __
setattr__ , __getattr__. La clase contiene un atributo de clase,
precio, inicializado a 25. Se crea una instancia p de producto que
inicializa su variable de instancia nombre a la cámara.
A continuación se accede a precio y name de los atributos de
instancia, lo que resulta en la invocación __ getattr__. El método
__ getattr__ devuelve el valor de la variable de instancia nombre.
Además, el programa asigna los valores 15 y Cell al precio y nombre,
lo que resulta en __ setattr__ está invocando. En el método __
setattr__, los valores se asignan a las variables de instancia
utilizando el diccionario para evitar las llamadas recursivas.

Summary -

resumen

En este capítulo se centra en clases. Usted aprendió a definir una

clase, definir funciones para ello, inicializar sus variables de
instancia, y el uso de clases y métodos estáticos. También aprendió
a utilizar los atributos de clase para mostrar información
específica relacionada con la clase. Nos fijamos en la recolección
de basura y su papel en la liberación de memoria consumida por los
objetos que están fuera de su alcance. Usted aprendió a aplicar la
herencia simple, multinivel, y múltiples a través de ejemplos de
funcionamiento. Usted aprendió el uso de especificadores de acceso
público y privado y la forma de aplicar el método de primer orden y
la sobrecarga de operadores para realizar operaciones aritméticas
sobre instancias. Por último, usted aprendió sobre el polimorfismo y
la configuración y obtener los valores de los atributos de instancia
a través de las propiedades y los descriptores.
En el próximo capítulo usted aprenderá sobre el manejo de archivos.
Usted aprenderá a abrir los archivos en diferentes modos y realizar
diferentes tareas como la lectura, actualización, eliminación y
añadiendo contenido a un archivo. Usted aprenderá a copiar el
contenido de un archivo a otro.

Chapter 6. File Handling

Capítulo 6. Manejo de Archivos
En este capítulo se tratan los siguientes temas:
• La apertura de un archivo
• Realizar acciones en un archivo
• Visualización de la información de un objeto de archivo
• La lectura de un archivo
• Añadir el contenido a un archivo
• Copiar un archivo
• Eliminación de contenido de un archivo
• Actualización de contenido de un archivo
• Leyendo el contenido de un archivo al azar
• El acceso a contenido específico de un archivo
• Creación de un archivo binario
• Serialización (pickling)
• El manejo de excepciones
• El uso de un bloque try / except
• El uso de un try / finally
• Lanzar excepciones
Un archivo es un contenedor para una secuencia de objetos de datos,
representados como secuencias de bytes. Manejo de archivos es una
técnica mediante la cual es posible almacenar datos y puede
recuperar más tarde. Cuando se ejecuta un programa, éste le pide que
introduzca algunos datos (para transformación), y la información
procesada se muestra en la pantalla.
Los datos que introduzca durante la ejecución de un programa se
almacena en la memoria RAM, que es de carácter temporal, por lo que
si más adelante desea ver los datos que se ha especificado, no se
puede conseguir. Para recuperar los datos en el futuro, es necesario
que sea persistente.
Usted tendrá que lidiar con tres tipos de archivos: texto, binario,
y los objetos pickle:
•

Los archivos de texto se codifican y se guardan en un formato

que puede ser visto por muchos programas, así como las
personas. Los archivos de texto son difíciles de actualizar en
su lugar.
Los archivos binarios se formatean para optimizar la velocidad
de procesamiento. Un archivo binario típicamente colocar datos
•

en desplazamientos conocidos, por lo que es posible acceder a

cualquier byte de particular usando el metodo seek().
Archivos pikled se formatean a los objetos almacenados. Los
objetos se almacenan en formato binario para optimizar el
rendimiento.

Se requieren los siguientes tres pasos para trabajar con archivos:

•
•
•

La apertura de un archivo
Realización de acciones en el archivo (lectura, escritura,
actualización de los contenidos)
Cierre el archivo

Opening a File – Abriendo un Archivos

La sintaxis para la apertura de un archivo es la siguiente:
open(file_name, mode)
file_name representa el nombre del archivo, y el mode especifica el
propósito de abrir el archivo.
El método open() devuelve un identificador de archivos que
representa el archivo en el disco. El manejador de archivos también
se puede colocar en lugares de bytes deseados en el archivo para
leer o escribir contenido específico del archivo. La Tabla 6.1
muestra las opciones de modo de abrir un archivo.

For example:
f = open('xyz.txt', 'w')

Esto crea la xyz.txt archivo en modo de escritura y devuelve el

manejador de archivo para f variable. Cualquier contenido
anteriormente en xyz.txt se borrará.
Performing Actions on a File
Realización de acciones en un archivo
Después de abrir un archivo, el siguiente paso es llevar a cabo
alguna tarea en el archivo, como la escritura, la lectura,
estableciendo el controlador de archivo en una ubicación específica,
o conseguir la ubicación del controlador de archivo. Vamos a echar
un vistazo rápido a los métodos de archivo diferentes. Tabla 6.2
muestra los métodos utilizados para el funcionamiento de un archivo
en Python.
metodo

proposito

close()

Cierra el archivo, el lavado de

todos los datos.

read([n])

Lee el número n de caracteres o

bytes desde el archivo. Si el
valor de n es opcional
negativo o se omite, se lee el
resto del archivo.

readline([n])

Lee la siguiente línea del

archivo. Si n es negativo o se
omite, la siguiente línea
completa se lee. El valor
positivo del parámetro n es si se
proporciona leerán n número de
caracteres del archivo. Si una
línea completa se lee, se incluye
el carácter de nueva línea, \ n.

readlines([n])

Lee las siguientes líneas del

archivo. Si se proporciona el
valor opcional n, el método lee
las siguientes líneas de los
siguientes n caracteres del
archivo. Si n es negativo o se
omite, se lee el resto del
archivo. Todas las líneas tendrán
incluir el carácter de salto de
línea final, \ n

flush()

Vacía todos los datos de los

buffers internos para el archivo
del sistema operativo.

write(string)
Escribe la cadena dada en el
fichero.

writelines(list)

Escribe la lista de cadenas en el

archivo.

seek(offset,location)

Establece la ubicación del

controlador de archivo en el
desplazamiento especificado. La
ubicación define si el
desplazamiento se refiere a la
posición actual del controlador
de archivo, a partir del archivo,
o el final del archivo. El valor
predeterminado de la ubicación es
0. Ejemplos: f.seek (0) mueve el
controlador de archivo al
principio del archivo. f.seek
(10, 1) se mueve el controlador
de archivo de 10 bytes a partir
de su posición actual.Si el
desplazamiento – offset es
negativo, el controlador de
archivo se moverá hacia atrás
desde su posición actual. f.seek
(10, 2) mueve el controlador de
archivo a la décima de bytes
desde el final del archivo.
f.seek (0, 2) se mueve el
controlador de archivo en el byte
0 ª desde el final del archivo.
Esto posiciona el manejador de
archivo al final del archivo, por
lo que es posible anexar
contenidos en el fichero.
tell()

Para entender
programas. El
aboutbook.txt
escrito en el
pantalla.

Devuelve la posición del

controlador de archivo.

el uso de estos métodos, vamos a escribir algunos

siguiente programa crea un archivo denominado
y escribe un par de líneas en el mismo. El texto
archivo es entonces accede y se visualiza en la

createfile1.py
matter = '''Python is a great language
Easy to understand and learn
Supports object Oriented Programming
Also used in web development '''
f = open('aboutbook.txt', 'w')
f.write(matter)
f.close()
f = open('aboutbook.txt')
while True:
line = f.readline()
if len(line) == 0:
break
print (line,)
f.close()
Output:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development

Texto multilínea se asigna a la variable asunto. Un archivo llamado

aboutbook.txt se abre en modo de escritura, borrar su contenido, si
la hay. El manejador de archivo para el archivo aboutbook.txt se
asigna a la variable f. El texto de varias líneas en la variable de
asunto se escribe en el archivo con el metodo write(), y se cierra
el archivo. Para confirmar el contenido está escrito en el archivo,
se abre en modo de lectura, y se accede y se asigna a una variable
de la línea, que luego se muestra en la pantalla las líneas de texto
en el archivo.
nota
Una línea en blanco lleva un carácter de nueva línea \n y se
considera una cadena de longitud 1.

Displaying Information from a File Object

Visualización de la información de un objeto File
En la creación de un objeto de archivo, puede utilizar diferentes
métodos y atributos para obtener información detallada sobre el
estado del objeto. Métodos y atributos del objeto de archivo se
muestran en la Tabla 6.3.
Table 6.3. Methods and Attributes of a File Object
Method/Attribute

Method/Attribute

fileno()

Devuelve el descriptor de fichero

interno utilizado por la
biblioteca OS cuando se trabaja
con este archivo.

isatty()

Devuelve true si el archivo está

conectado a la consola o el
teclado.

closed

Este atributo es true si el

archivo está cerrado.

mode

Este atributo es el modo del

archivo que se utilizó para crear
el objeto de archivo a través de
la función open().

name

Este atributo es el nombre del

archivo que se pasa a la función
open() al crear el objeto de
archivo.

Lo que sigue es un programa que muestra los atributos de un objeto

de archivo:
fileattrib.py
f = open("aboutbook.txt", "r")
print ("Name of the file:", f.name)
print ("Closed?", f.closed)
print ("Opening mode:", f.mode)
print ("File number descriptor is:", f.fileno())
f.close()
Output:
Name of the file: aboutbook.txt
Closed? False
Opening mode: r
File number descriptor is: 3

El programa se abre aboutbook.txt en modo de escritura. El manejador

de archivo del archivo está representado por una variable f. El
nombre del archivo, su modo, su descriptor de archivo y su estado
(abierto o cerrado) se muestran llamando a los métodos y los
atributos respectivos.

Reading from a File

Leer en un archivo
En el programa createfile1.py que utilizó readLine () en un bucle
para acceder a una línea a la vez desde el archivo para que aparezca
en la pantalla. El programa siguiente muestra cómo leer todo el
contenido del archivo.
fileread.py
f = open('aboutbook.txt', 'r')
lines = f.read()
print (lines)
f.close()
Output:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development

El programa abre el archivo aboutbook.txt que creó en el programa

anterior en modo de lectura. Se accede al contenido del archivo a
través de read() y se asigna a la variable líneas, que luego se
muestran en la pantalla. Por último, se cierra el archivo.
En este programa, que se abrió el archivo aboutbook.txt en modo de
lectura. ¿Y si el aboutbook.txt archivo no existe? Python muestra un
mensaje de error técnico cuando se intenta abrir un archivo que no
existe, como se muestra aquí:
Traceback (most recent call last):
File "C:\pythonprograms\fileread.py", line 1, in <module>
f = open('aboutbook.txt', 'r')
IOError: [Errno 2]No such file or directory: 'aboutbook.txt'

El mensaje de error se muestra a través del controlador de errores

Python por defecto. Puede hacer que el mensaje de error más legible
a través de la gestión de excepciones. Usted aprenderá el manejo de
excepciones en detalle en la siguiente sección, pero aquí está un
pequeño ejemplo:
filereadtry.py
import sys
try:
f = open('aboutbook.txt', 'r')
lines = f.read()
except IOError:
print ('File aboutbook.txt does not exist')
sys.exit(1)
f.close()
print (lines)
Output:
File aboutbook.txt does not exist
Traceback (most recent call last):
File "C:\pythonprograms\filereadtry.py", line 7, in <module>
sys.exit(1)
SystemExit:1

Al abrir un archivo para lectura, se produce una excepción IOError

si el archivo no existe. Sin un bloque try / except, Python
simplemente imprime el mensaje de error en el lenguaje técnico, como
se vio en un programa anterior
Cuando se utiliza el mismo enfoque con un bloque try / except, la
IOException es capturado por la cláusula de excepción, y la
declaración, en la cláusula salvo que se ejecuta para mostrar el
mensaje de error legible(s) con el fin de guiar al usuario a tomar
medidas correctivas.
La cláusula de excepción se omitirá si el archivo que está
intentando abrir ya existe. El contenido del archivo se mostrarán
sin ningún mensaje de error en ese caso.
Los stdin, stdout y stderr variables contienen objetos de flujo
correspondientes a flujos a E / S estándar . Usted las puede
utilizar para tener un mejor control sobre los flujos. El siguiente
programa muestra el uso de la salida estándar para la visualización
de los contenidos en la pantalla:
fileread2.py
import sys
f = open('aboutbook.txt', 'r')
lines = f.readlines()
f.close()
print('The contents in the file are:', lines)
print('\nThe contents in the file are:')
for line in lines:
sys.stdout.write(line)
print('\n\nThe contents in the file are:')
for i in range(0, len(lines)):
sys.stdout.write(lines[i])
Output:
The contents in the file are: ['Python is a great language\n', 'Easy to
understand and
learn\n', 'Supports Object Oriented Programming\n', 'Also used in web
development ']
The contents in the file are:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development
The contents in the file are:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development

El módulo sys se importa en el programa. El archivo aboutbook.txt se

abre en modo de lectura. Se accede a todo el texto en el archivo y
se almacena en una variable de lines. lines es una lista en la que
cada elemento representa una línea del archivo. Entonces la salida
estándar stdout se utiliza para mostrar cada elemento en lines.

Appending Content to a File - Añadiendo contenido a un

archivo
El programa siguiente muestra cómo anexar el contenido en un
archivo:
fileappend.py
import sys
matter2 = ''' Its very hot today
Lets have a Cold drink '''
f = open('aboutbook.txt', 'a' )
f.write("\n%s" %matter2)
f.close()
f = open('aboutbook.txt', 'r' )
lines = f.readlines()
f.close()
print('The contents in the file are:')
for line in lines:
sys.stdout.write(line)
Output:
The contents in the file are:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development
Its very hot today
Lets have a Cold drink

Texto multilínea se asigna a una variable, matter2. Un archivo

aboutbook.txt se abre en modo de adición de forma que su manejador
de archivo se coloca en el extremo del archivo. El texto en matter2
se añade al final de aboutbook.txt. El archivo se cierra. Para
confirmar si el texto es realmente anexa al archivo, puede abrirlo
en el modo de lectura, y se accede y se almacena en una variable de
las lines de su contenido. En la visualización de los contenidos en
línes, usted observa que el contenido en matter2 se añaden a los
contenidos anteriores en aboutbook.txt.

Copying a File – Copiando

un archivo

El programa siguiente muestra cómo hacer una copia del archivo

aboutbook.txt y el nombre de copyaboutbook.txt:
filecopy.py
f = open('aboutbook.txt', 'r')
lines = f.read()
f.close()
g = open('copyaboutbook.txt', 'w' )
g.write(lines)
g.close()
print('The copy of the file is made')
g = open('copyaboutbook.txt', 'r' )
lines = g.read()
print (lines)
g.close()
Output:
The copy of the file is made
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development

El programa se abre aboutbook.txt en modo de lectura, lee su

contenido, y lo almacena en la varable línes. El archivo se cierra.
Después de eso, un archivo llamado copyaboutbook.txt se abre en modo
de escritura. El contenido del archivo aboutbook.txt en línes se
escribe en copyaboutbook.txt. Para confirmar si el contenido se
copia correctamente al copyaboutbook.txt, puede abrirlo en el modo
de lectura, y se accede y se muestra su contenido.
Deleting Content from a File – Borrando el contenido de un
archivo
El programa siguiente muestra el procedimiento de borrar el
contenido de un archivo. El procedimiento es bastante simple.
Primero se abre el archivo en modo de lectura, y su contenido
existente se copia temporalmente en una lista. Entonces el contenido
sera borrado y se borran de la lista. El archivo se abre en modo de
escritura, borrar todo su contenido. El contenido de la lista que
representa los datos deseados y de la que ya se extrae el contenido
no deseado se copia en el archivo. El código para borrar el
contenido de un archivo aparece como se muestra aquí:
delfilecontent.py
import sys
f = open('aboutbook.txt', 'r' )
lines = f.readlines()
print('Original content of the file:')
for line in lines:
sys.stdout.write(line)
f.close()
del lines[1:3]
f = open('aboutbook.txt', 'w' )
f.writelines(lines)
f.close()
print('\nThe content of the file after deleting second and third line:')
f = open('aboutbook.txt', 'r' )
lines = f.read()
print (lines)
f.close()
Output:
Original content of the file:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development
The content of the file after deleting second and third line:
Python is a great language
Also used in web development

El programa abre aboutbook.txt en modo de lectura y recuperaciones y

almacena su contenido en las línes. El archivo se cierra. El
contenido que se va a eliminar del archivo se borra de línes.
aboutbook.txt y se abre en modo de escritura, borrando su contenido
existente. El contenido de las línes se escribe en aboutbook.txt, y
se cierra el archivo. Para confirmar que los datos se eliminan del
archivo, puede abrirlo en el modo de lectura, y se muestra su
contenido. La salida confirma que el contenido no deseado se elimina
del archivo.

Updating the Content of a File – actualizando el contenido

de un archivo
El programa siguiente muestra la tarea de actualizar el contenido de
un archivo. Primero se abre el archivo en modo de lectura, y su
contenido existente se copia temporalmente en una variable, líneas.
El contenido original en el archivo se muestra a partir de líneas.
Entonces se le pide al usuario que especifique el número de línea
para actualizar. El nuevo contenido introducido por el usuario se
almacena en la ubicación en líneas especificadas por el usuario, la
sustitución de su contenido anterior. El archivo se abre en modo de
escritura, borrar todo su contenido. El contenido de la lista que
representa los datos actualizados se copia en el archivo. El código
para la actualización de contenidos en un archivo aparece aquí:
updatefilecont.py
import sys
f = open('aboutbook.txt', 'r')
lines = f.readlines()
print('Original content of the file:')
for line in lines:
sys.stdout.write(line)
f.close()
n=int(input ("\n\nEnter the line number to change: "))
if n <=len(lines):
r=input("Enter the new content: ")
lines[n-1]=r+"\n"
f = open('aboutbook.txt', 'w' )
f.writelines(lines)
f.close()
print('The content of the file after updating line' , n)
f = open('aboutbook.txt', 'r' )
lines = f.read()
print (lines)
f.close()
else:
print ("The line number", n, "is not found in the file" )
Output:
Original content of the file:
Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development
Enter the line number to change: 2
Enter the new content: Easy to develop applications
The content of the file after updating line 2
Python is a great language
Easy to develop applications
Supports Object Oriented Programming
Also used in web development

El programa se abre aboutbook.txt en modo de lectura y

recuperaciones y almacena su contenido en las líneas. El contenido
original del archivo se muestran mostrando elementos en líneas. El
archivo se cierra. Se le pide al usuario que especifique el número
de línea (s) para modificar y su nuevo contenido. El nuevo contenido
introducido por el usuario se almacenan en la lista en los lugares
de índice especificadas, sustituyendo el contenido anterior. El
contenido de las líneas se escribe en aboutbook.txt, seguido de
cerrar el archivo. Para confirmar que los datos se actualizan en el
archivo, éste se abre en modo de lectura, y su contenido se
muestran. La salida confirma que el contenido en el archivo se
actualiza.

Reading the Content of a File Randomly

Leyendo el contenido de un archivo al azar
¿Se puede leer el contenido del archivo al azar? Es decir, en lugar
de leer el contenido del archivo desde el principio, se puede leer
desde cualquier ubicación que desea? ¡Sí! Este programa hace eso.
filerandomread.py
f = open('aboutbook.txt', 'r')
line=f.readline()
print('A line from file is:', line)
f.seek(5)
line=f.readline()
print('The line from character 6 till end of line is:', line)
print ('The pointer is at location', f.tell())
f.seek(10)
line=f.read(15)
print ('The fifteen characters starting at location 11 are as:', line)
Output:
A line from file is: Python is a great language
The line from character 6 till end of line is: n is a great language
The pointer is at location 28
The fifteen characters starting at location 11 are as: a great language

El programa abre aboutbook.txt en modo de lectura. Al abrir el

archivo, el controlador de archivo se coloca en el principio del
archivo por defecto. Por lo tanto, la lectura de una línea desde el
archivo cuando el manejador de archivos está en el principio del
archivo se mostrará la primera línea del archivo. A continuación, el
controlador de archivo se coloca en el quinto byte desde el
principio del archivo con el metodo seek() para leer toda la línea
que comienza en el sexto carácter. Una vez más, el controlador de
archivo se coloca en el décimo byte desde el principio del archivo
para leer 15 caracteres iniciales desde el carácter undécima.

Accessing Specific Content in a File

Acceso a contenido específico en un archivo
¿Hay alguna manera de acceder a una línea específica de texto del
archivo en lugar de acceder al archivo completo? Sí, y aquí está el
código para hacerlo. El siguiente programa accede y visualiza la
tercera línea de aboutbook.txt.
fileanyline.py
import linecache
line=linecache.getline('aboutbook.txt', 3)
print ('The content of the third line is:', line)
Output:
The content of the third line is: Supports Object Oriented Programming

Esto supone que aboutbook.txt tiene el siguiente contenido:

Python is a great language
Easy to understand and learn
Supports Object Oriented Programming
Also used in web development

Este programa importa el módulo linecache y utiliza su método

getline para acceder a la tercera línea de aboutbook.txt, que luego
se muestra en la pantalla.
Ahora vamos a ver cómo crear un archivo numérico. El siguiente
programa crea un archivo y almacena números en ella:
filenumerical.py
f = open('numbers.txt', 'w' )
n=int(input('How many numbers? ' ))
print('Enter', n, 'numbers' )
for i in range(0,n):
m=input()
f.write("%s\n" %m)
f.close()
f = open('numbers.txt')
lines = f.readlines()
f.close()
print('The numbers stored in the file are')
for line in lines:
print (int(line),)
print('The numbers in the file multiplied by 2')
for line in lines:
print (int(line)*2,)
Output:
How many numbers? 5
Enter 5 numbers
1
2
3
4
5
The numbers stored in the file are
1
2
3
4
5
The numbers in the file multiplied by 2
2
4
6
8
10

Este programa abre un archivo numbers.text en modo de escritura y

pide al usuario que especifique cuántos números se van a almacenar
en él. Los números introducidos por el usuario se almacenan en el
archivo y el archivo es cerrado. Para confirmar que el archivo fue
creado y ha entrado en el contenido, que se abre en modo de lectura,
y se accede a su contenido y se muestra en la pantalla. Para
confirmar que el contenido en el archivo es de tipo numérico, el
programa muestra todos los números en él después de multiplicarlos
por 2.

Creating a Binary File

Creación de un archivo binario
El siguiente programa crea un archivo binario y almacena una cadena
en el mismo:
binaryfile1.py
str = 'Hello World!'
f = open("filebinary.bin","wb" )
f.write(str.encode('utf-8'))
f.close()
f = open("filebinary.bin","rb" )
fcontent=f.read()
f.close()
print('The content in the file is:')
print (fcontent.decode('utf-8'))
Output:
The content in the file is:
Hello World!

El programa abre un archivo llamado filebinary.bin en modo de

escritura y almacena una cadena, Hello World!, En el mismo. La
cadena se codifica primero en UTF-8 antes de ser escritos en el
archivo. El archivo se cierra. Para confirmar si la cadena se
almacena correctamente en el archivo, éste se abre en modo de
lectura, y la cadena almacenada en ella se recupera, decodifica y
muestra en la pantalla.

Serialization(Pickling) - Serialización(decapado)
Serialización (también conocido como pickling - decapado) es un
proceso de conversión de datos estructurados en formato de flujo de
datos. A través de la serialización, estructuras como listas,
tuplas, funciones y clases se conservan utilizando caracteres ASCII
entre valores de datos. El formato de datos en serie está
estandarizada, por lo que las estructuras serializados con la
serialización se pueden deserializar con cPickle y viceversa.
La serialización se hace cuando el almacenamiento de datos, y
deserialización se hace cuando la recuperación de datos. Para
decapado- pickling, puede utilizar cualquiera de los módulos, Pickle
o cPickle. Ambos módulos funcionan de la misma, excepto que el
módulo cPickle está escrito en el lenguaje C y es más rápido y da
como resultado un mejor rendimiento. El siguiente programa utiliza
el módulo Pickle para almacenar una instancia en un archivo:
pickleprog.py
import pickle
class rect:
def __init__(self, x,y):
self.l = x
self.b = y
def rectarea(self):
return "Area of rectangle is", self.l * self.b
r=rect(5,8)
f = open('studentinfo.bin', 'wb')
pickle.dump(r, f)
f.close()
del r
f = open('studentinfo.bin','rb')
storedobj = pickle.load(f)
print (storedobj.rectarea())
Output:
('Area of rectangle is',40)

El programa define una clase Rect que consta de dos métodos,

__ init__ y rect-area(). Se crea una instancia r de la clase rect,
y sus variables de instancia, l y b, se inicializa a 5 y 8.
Un archivo binario, studentinfo.bin, se abre en modo de escritura, y
r es pickled y vertidó - dumped en él. El archivo se cierra. r se
elimina después de que se copia en el archivo binario. Para leer r
desde el archivo y lo puso de nuevo en forma utilizable, se abre el
archivo en modo de lectura, y la instancia se lee desde el archivo
con pickle.load(), unpickled, y se asigna a storedobj. El área del
rectángulo se calcula y visualiza llamando rectArea() en el objeto
storedobj.
Este programa demuestra decapado y deserialiación(pickling y
unpickling) una instancia de un archivo. Vamos a usar el proceso
para conservar en pickle y unpickle más de una instancia. El
siguiente programa almacena la información por decapado una
instancia de la clase de user. Además, el programa unpickles los
casos para mostrar la información almacenada.
pickleprog2.py
import pickle
class user:
def __init__(self, x,y,z):
self.id = x
self.name = y
self.emailadd=z
def dispuser(self):
print('User ID:', self.id)
print('User Name:', self.name)
print('Email Address:', self.emailadd)
f = open('UsersInfo.bin', 'wb')
n=int(input('How many users? ' ))
print('Enter', n, 'numbers')
for i in range(0,n):
u=input('User ID: ')
n=input('User Name: ')
e=input('Email Address: ')
usrobj=user(u,n,e)
pickle.dump(usrobj,f)
f.close()
print('\nInformation of the users is:')
f = open('UsersInfo.bin','rb')
while True:
try:
usrobj = pickle.load(f)
except EOFError:
break
else:
usrobj.dispuser()
f.close()
Output:
How many users? 3
Enter 3 numbers
User ID: johny111
User Name: John
Email Address: johny@gmail.com
User ID: kelly222
User Name: Kelly
Email Address: kelly@hotmail.com
User ID: bintu333
User Name: Bintu
Email Address: bintu@yahoo.com
Information of the users is:
User ID: johny111
User Name: John
Email Address: johny@gmail.com
User ID: kelly222
User Name: Kelly
Email Address: kelly@hotmail.com
User ID: bintu333
User Name: Bintu
Email Address: bintu@yahoo.com

El programa define una clase de usuario que consta de dos métodos,

__ init__ y disp-user(). El método __ init__ es para inicializar las
variables de instancia de la instancia respectiva del identificador
de clase de usuario, el nombre y emailadd. El método dispuser() es
para la visualización de la información almacenada en las variables
de instancia. Un archivo binario UsersInfo.bin se abre en modo de
escritura. Se le pide al usuario que especifique el número de
usuarios cuya información debe ser almacenada en el archivo. Con la
ayuda de un bucle, el ID de usuario, nombre, dirección de correo
electrónico y la información de un determinado número de usuarios se
introducen y se utilizan para inicializar el id, nombre y emailadd
variables de instancia de la instancia usrobj de la clase usuario.
La instancia usrobj que contiene información de un usuario que se
pickled y dumped en el archivo binario. El archivo se cierra. Para
leer las instancias del archivo y ponerlos de nuevo en una forma
utilizable, se abre el archivo en modo de lectura y, a través
pickle.load(), las instancias se leen desde el archivo uno por uno,
unpickled, y asignados a usrobj. La información en usrobj se muestra
llamando dispuser() en el objeto usrobj.

Exception Handling
Manejo de excepciones
Las excepciones se producen cuando ciertas situaciones surgen en un
programa. Por ejemplo, la división de un valor de 0, el acceso a un
elemento de la lista fuera de su rango de índice, o la lectura de un
archivo que no existe, son situaciones que provocan excepciones.
Cuando se produce una excepción, Python normalmente muestra un
mensaje técnico que es un poco difícil de entender. Para hacerlo más
fácil para un usuario para entender lo que salió mal y ofrecer una
oportunidad de corregir el error, puede capturar las excepciones
específicas y mostrar mensajes de uso fácil. Los errores de sintaxis
son diferentes de las excepciones en que los errores de sintaxis se
producen cuando cualquier declaración no coincide con la gramática
de la intérprete de Python. Falta de ortografía en una declaración o
un paréntesis o comilla faltante son todos los errores de sintaxis.
Para controlar las excepciones, se escribe el código en un bloque
que comienza con la palabra try. Hay dos tipos de bloques try:
try/except: El código que podría generar un error se escribe en
el bloque try, y todos los errores y las excepciones se manejan
a través de la cláusula de excepción. La cláusula except puede
manejar un solo error o excepción especificada. Si no se
especifica ningún nombre de error o excepción, salvo se
encargará de todos los errores y excepciones que aparecen en el
código escrito en el bloque try. Tiene que haber al menos una
cláusula except asociado con cada bloque try. Si no se maneja
cualquier error o excepción, entonces el manejador de Python
por defecto se invoca, lo que detiene la ejecución del programa
y muestra el mensaje de error.
try/finally: El código escrito en el bloque finally siempre se
ejecuta si se produce una excepción o no. Es decir, el código
que se desea ejecutar en todas las situaciones se escribe en un
bloque finally. Por lo general, las declaraciones de cierre los
archivos abiertos, liberando la memoria, y como se escriben en
un bloque finally.

Using a try/except Block

El uso de un bloque try / except
Para el manejo de excepciones a través de un bloque try / except, se
especifica el código que podría dar lugar a una excepción, junto con
un grupo de cláusulas except. Cada excepto nombres cláusula una
clase de excepción y proporciona las instrucciones a ejecutar en
respuesta a esa excepción.
Syntax:
try:
statement(s)
except SomeException:
code for handling exception
[else:
statement(s)]
Usted puede
bloque try.
controlador
try/excepto

tener un número ilimitado de cláusulas except en un solo

El cuerpo de cada cláusula except es conocido como un
de excepciones. Manejo de exception con bloque un
se hace de la siguiente manera:

1. Python ejecuta las sentencias en el bloque try.

2. Si ninguna de las sentencias del bloque try lanza una excepción,
la excepción de las cláusulas son ignorados.
3. Si alguna de las sentencias del bloque try lanza una excepción,
el resto de las sentencias en el bloque try se omiten, y cada una de
las cláusulas de excepción se examina para localizar una cláusula
que coincide con la excepción planteada. Si hay una coincidencia,
Python ejecuta la cláusula except.
4. Si la excepción planteada no coincide con ninguna de las
cláusulas de excepción, Python busca un manejador de excepciones
coincidente en cualquier código que el bloque try se anida pulg Si
Python no encuentra un controlador de excepciones coincidente,
Python usa su base de en manejador de excepciones e imprime el
mensaje de error técnico.
5. La cláusula else se ejecuta sólo si el bloque try se ejecuta
correctamente y completamente. Es decir, si no es la excepción se
eleva o se ejecuta ninguna instrucción de bloque de salir, la
cláusula else se ejecuta. Las sentencias que desea que se ejecutarán
si la cláusula try no plantea una excepción están escritos en la
cláusula else.
Una vez que una excepción se ha manejado, el programa continúa su
ejecución de la primera línea después del bloque try / except.
nota
Puede anidar los bloques try.
Tabla 6.4 muestra excepciones que se pueden controlar, mientras que
un programa se ejecuta.
Tabla 6.4. Las excepciones que se pueden manejar durante la
ejecución de un Programa:

Exception

Description

AssertionError

Se produce cuando asertion falla.

AttributeError

Se produce cuando un atributo no se

encuentra en un objeto.

EOFError

Se produce cuando se intenta leer

más allá del final de un archivo.

FloatingPointError

Se produce cuando falla una

operación de punto flotante.

IOError

Se produce cuando una operación

de E / S ha fallado.

IndexError

Se produce cuando se utiliza un

valor de índice que está fuera de
rango.

KeyError

Se produce cuando no se encuentra

una clave de mapeo.

OSError

Se produce cuando falla una

llamada al sistema operativo.
OverflowError

Se produce cuando un valor es

demasiado grande para ser
representado.

TypeError

Se produce cuando se suministra

un argumento de tipo inapropiado.

ValueError

Se produce cuando se suministra

un valor de argumento
inapropiado.
ZeroDivisionError

Se produce cuando un número se

divide por 0 o cuando el segundo
argumento en una operación de
módulo es cero.

Vamos a ver cómo se produce una excepción y cómo se maneja para

mostrar un mensaje fácil de usar y de adoptar medidas correctivas a
través de un ejemplo de ejecución. El siguiente programa demuestra
ocurrencia y manejo de una excepción EOFError:
try1.py
import sys
try:
n = input('Enter your name ')
except EOFError:
print ('EOF error has occurred' )
sys.exit(1)
except:
print ('Some error has occurred' )
print ('The name entered is', n)
Output:
Enter your name
EOF error has occurred
Traceback (most recent call last):
File "C:\pythonprograms\try1.py", line 6, in <module>
sys.exit(1)
SystemExit:1
Enter your name Bintu
The name entered is Bintu
Este programa pide al usuario que introduzca un nombre. La
declaración pide el nombre de usuario está encerrado en un bloque
try. Si el usuario presiona Ctrl + D en lugar de introducir un
nombre, se generará una excepción EOFError, mostrando error EOF ha
ocurrido seguido de salir de la aplicación. El programa también
muestra ha producido algún error si se produce alguna excepción que
no sea EOFError. No hay ningún mensaje de error se mostrará si el
usuario introduce un nombre. El nombre introducido por el usuario se
muestra en la pantalla cuando se produce una excepción. Puede volver
a escribir el programa anterior mediante el uso de la cláusula else
en el bloque try / except. Recuerde que la declaración en el bloque
else se ejecuta solamente cuando se produce una excepción.
tryelse.py
import sys
try:
n = input('Enter your name ')
except EOFError:
print ('EOF error has occurred' )
sys.exit(1)
except:
print ('Some error has occurred' )
else:
print('The name entered is', n)
Output:
Enter your name
EOF error has occurred
Traceback (most recent call last):
File "D:\pythonprograms\tryelse.py", line 6, in <module>
sys.exit(1)
SystemExit:1
Enter your name John
The name entered is John
El programa siguiente muestra cómo se producen execpciones TypeError
y ZeroDivisionError y cómo se manejan. Recuerde que una excepción
TypeError ocurre cuando se suministra un argumento de tipo
inadecuado, y una excepción ZeroDivisionError ocurre cuando un
número se divide por 0.
try2.py
from __future__ import division
import sys
n = input('Enter a number ')
if n.isdigit():
n=int(n)
try:
m=15/n
except TypeError as ex:
print ('You have not entered a numeric value:', ex)
sys.exit(1)
except ZeroDivisionError as ex:
print ('You have entered zero value:', ex)
sys.exit(1)
print ('The result is', m)
Output:
Enter a number John
You have not entered a numeric value unsupported operand type(s) for /: 'int' and
'str'

Traceback (most recent call last):

File "D:\pythonprograms\try2.py", line 11, in >module>
sys.exit(1)
SystemExit: 1
Enter a number 0
You have entered zero value: division by zero
Traceback (most recent call last):
File "C:\pythonprograms\try2.py", line 14, in >module>
sys.exit(1)
SystemExit: 1
Enter a number 5
The result is 3.0
El programa pide al usuario que introduzca un número que se utiliza
en una operación de división. Si el número introducido no es de tipo
numérico, una excepción TypeError se produce y no se ha introducido
un valor numérico se muestra en la pantalla, seguido por salir de la
aplicación. Si la información ingresada es de tipo numérico y su
valor es 0, ocurre una excepción ZeroDivisionError y Ha introducido
se visualiza el valor cero, seguido de salir de la aplicación. Si
ninguna de las dos excepciones se produce, lo que significa que el
usuario introduce un valor numérico distinto de cero, el resultado
de la operación de división se muestra en la pantalla.

Using a try/finally Block

El uso de un bloque try / finally
Cuando se produce una excepción, el programa normalmente detiene la
ejecución y se cierra. Hay ciertas declaraciones esenciales que
usted desea para ser ejecutado si se produce una excepción o no.
Estas declaraciones, que pueden incluir la liberación de memoria o
cerrar un archivo abierto, están escritos en un bloque finally.
El try/finally sigue estos pasos:
1. Python ejecuta las sentencias en el bloque try.
2. Si ninguna de las sentencias del bloque try lanza una excepción,
se ejecutan las sentencias en el bloque finally.
3. Si hay un bloque que sale de la declaración en el bloque try,
como return, break, o continue, la cláusula finally se ejecuta en la
salida.
4. Si se produce una excepción en el bloque try, Python se salta el
resto del bloque, se ejecuta la cláusula finally y, a continuación,
lanza la excepción de nuevo.
El programa siguiente muestra cómo utilizar el bloque finally para
ejecutar las sentencias que desea ejecutar si se produce una
excepción o no:
filetryfinal.py
import sys
try:
f = open('aboutbook.txt', 'r')
try:
lines = f.read()
finally:
f.close()
except IOError:
print ('File aboutbook.txt does not exist')
sys.exit(1)
print (lines)
Output:
File aboutbook.txt does not exist
Traceback (most recent call last):
File "D:\pythonprograms\filertryfinal.py", line 11, in >module>
sys.exit(1)
SystemExit: 1
Este programa abre aboutbook.txt en modo de lectura en el bloque
try. Si una excepción IOError se produce al abrir el archivo, a
continuación, Archivo aboutbook.txt no existe en la pantalla,
seguido por salir de la aplicación. Además, las líneas del archivo
se leen a través de read(), y si se produce una excepción o no, el
archivo se cierra a través del bloque finally.

Raising an Exception
Lanzar una excepción
Las excepciones son lanzados de forma automática cuando alguna
situación no deseada se produce durante la ejecución del programa.
Puede provocar una excepción explícita a través de la sentencia
raise en un bloque try/except.
Syntax:
raise customException, statement for customException
Al plantear una excepción en un bloque try, el formato será el
siguiente:
try:
if condition:
raise customException, statement for customException
except customException, e:
statements for customException
El programa siguiente muestra cómo crear y elevar una excepción:
raiseexcepclass.py
class myException(Exception):
def __init__(self, quantity):
Exception.__init__(self)
self.quantity = quantity
try:
s = int(input('Enter quantity '))
if s <=0 :
raise myException(s)
except EOFError:
print ('You pressed EOF ')
except myException as ex:
print ('myException: The quantity entered is %d, it must be
some positive value' % ex.quantity)
else:
print ('No exception raised.')
Output:
Enter quantity -3
myException: The quantity entered is -3, it must be some positive value

Enter quantity 5
No exception raised.
El programa crea una clase MyException que hereda de la clase
Exception. La clase contiene __ init__, que inicializa la variable
de instancia la cantidad de la clase y que llama al método __ init__
de la superclase, Excepción. Se le pide al usuario que introduzca la
cantidad de un artículo que se asigna a la variable s. Si el valor
introducido es inferior a cero, el excepción personalizada
MyException se eleva, la invocación de la clase y pasar el valor de
la cantidad a la misma. Si el usuario presiona Ctrl + D en lugar de
proporcionar un valor para la cantidad, se produce una excepción
EOFError, mostrando Ha pulsado EOF. Cuando se eleva MyException,
MyException: La cantidad introducida es _, debe ser que aparezca
algún valor positivo. Si la excepción no es lanzada , se ejecuta la
sentencia en el bloque de los demás, mostrando ninguna excepción
lanzada.
The program creates a myException class that inherits from the Exception class. The
class
contains __init__, which initializes the quantity instance variable of the class
and that
calls the __init__ method of the super class, Exception. The user is asked to enter
the
quantity of an item that is assigned to variable s. If the value entered is less
than zero, the
custom exception myException is raised, invoking the class and passing the value of
quantity to it. If the user presses Ctrl+D instead of providing a value for
quantity, an
EOFError exception is raised, displaying You pressed EOF. When myException is
raised,
myException: The quantity entered is _, it must be some positive value is
displayed. If no exception is raised, the statement in the else block will be
executed,
displaying No exception raised.

The assert Statement - La sentencia assert

La sentencia assert se utiliza para colocar una declaración de
comprobación de errores en el programa. Es una manera conveniente
para depurar un programa. A través de una sentencia assert, puede
comprobar los valores de las variables en la mitad del programa.
La sentencia assert devuelve true si todos los valores de las
variables son como se esperaba, no importa lo que las entradas son
proporcionados. Si algo está mal en el programa, la sentencia assert
devuelve false. La excepción AssertionError se provoca cuando la
sentencia assert devuelve false.
assertex.py
n=int(input('Enter a positive value: '))
assert(n >=0), "Entered value is not a positive value"
Output:
Enter a positive value: -5
Traceback (most recent call last):
File "D:\python\assertex.py", line 2, in >module>
assert(n >=0), "Entered value is not a positive value"
AssertionError: Entered value is not a positive value
Enter a positive value: 5

Summary
En este capítulo usted aprendió a realizar diferentes operaciones en
los archivos. Usted aprendió a abrir un archivo en diferentes modos
y para leer su contenido, actualizar el contenido existente, borrar
el contenido, y añadir nuevo contenido. También vio cómo copiar un
archivo, leer un archivo secuencialmente o al azar, y sólo lectura
de contenido específico. También ha aprendido a crear un archivo
binario y de pickle y objetos unpickle. Por último, ha aprendido
para implementar el control de excepciones y el procedimiento de
elevar excepciones.
En el próximo capítulo usted aprenderá a desarrollar aplicaciones
GUI en Python a través de PyQt. Usted aprenderá a instalar y
utilizar PyQt Qt Designer para desarrollar Aplicaciones GUI.

Chapter 7. PyQt
En el capítulo anterior usted aprendió sobre el manejo de archivos.
Usted aprendió a abrir un archivo en diferentes modos, leer su
contenido, actualizar el contenido existente, borrar el contenido,
añadir nuevos contenidos, y hacer una copia. Usted aprendió a leer
los archivos de forma secuencial, así como al azar. Además de esto,
también aprendió a crear archivos binarios, pickle y objetos
unpickle, y poner en práctica el manejo de excepciones.
Las aplicaciones que se han creado hasta ahora son las aplicaciones
basadas en la consola. De ahora en adelante será aprender a
desarrollar la interfaz gráfica de usuario (GUI) aplicaciones en
Python a través de PyQt. En este capítulo se tratan los siguientes
temas:
•
•
•
•
•
•
•
•
•
•
•
•
•

Introducción a Qt toolkit y PyQt

instalación PyQt
Ventana y diálogos
Creación de aplicaciones GUI a través de la codificación
Usar el diseñador de Qt
La comprensión fundamental widgets Label, Line Editar y Push
Botón
Manipulación Evento en PyQt
Primera aplicación en Qt Designer
Conexión a las ranuras(slots) predefinidas
El uso de ranuras(slots) personalizados
Conversión de tipos de datos
Definición de buddies y establecer el orden de tabulación

Vamos a comenzar el capítulo con una introducción a Qt toolkit.

Qt Toolkit
Toolkit Qt, conocido simplemente como Qt, es una aplicación multiplataforma y un
marco de interfaz de usuario desarrollado por
Trolltech que se utiliza para el desarrollo de aplicaciones GUI. Se
ejecuta en varias plataformas, incluyendo Windows, Mac OS X, Linux y
otras plataformas UNIX. También se le conoce como un conjunto de
herramientas Widget porque proporciona widgets, como botones,
etiquetas, cuadros de texto, botones y cuadros de lista, que son
necesarios en el diseño de una interfaz gráfica de usuario. lo
incluye un conjunto de plataformas cruzadas de las clases, las
herramientas de desarrollo integradas y un IDE multiplataforma.

PyQt
PyQt es un conjunto de enlaces Python para el conjunto de
herramientas Qt. PyQt combina todas las ventajas de Qt y Python. Con
PyQt, puede incluir librerías Qt en el código Python, lo que le
permite escribir aplicaciones gráficas en Python. En otras palabras,
PyQt le permite acceder a todos los servicios proporcionados por Qt
a través del código Python. Desde PyQt necesita las librerías Qt
para ejecutar, al instalar PyQt, la versión necesaria de Qt también
se instala automáticamente en el equipo.

Installing PyQt
You need to have Python Interpreter installed on your system before
you install PyQt. Recall from Chapter 1, “Python and its Features,”
that you have already installed Python 3.2 on your system, so you
can go ahead and download PyQt from
http://www.riverbankcomputing.co.uk/software/pyqt/download. The
latest version at the time of this writing is PyQt version 4.8.5 for
Python 3.2. The name of the downloaded file is PyQt-Py3.2-x86-gpl4.8.5-1.exe. Just
double-click the downloaded file to begin
installation. The first screen that you see is a welcome screen to
the PyQt Setup Wizard, as shown in Figure 7.1. The screen displays
general information about the components that come with PyQt. Select
Next to move forward.

Note
Your operating system may complain, saying the program is from
an unknown publisher and may harm your computer. Select the Yes
button to proceed with the installation. If you don’t see a Yes
button, select Actions to see the list of possible actions. In the
dialog that appears, select the More Options drop-down and select
Run to begin with the installation procedure.

The next screen shows the License Agreement, which you need to read
and agree to before installing PyQt. Select I Agree to continue
installation. Next, you get a screen that shows the list of
components that you can install with PyQt (see Figure 7.2). You can
select or deselect any component. The dialog also shows the disk
space that will be required for installing the selected components.

Let’s go ahead with Full Installation and select Next to move on.
The next screen will prompt you to specify the name and location of
the folder where Python 3.2 is installed. The reason is that PyQt is
installed in the sitepackages folder of the Python installation. The
wizard auto-detects and shows the location of the Python
installation by default, as shown in Figure 7.3. You can also select
Browse to modify the folder name. After specifying the location of
the Python installation, select Install to begin copying and
installing the PyQt files.
When PyQt files are copied and installed, you will be prompted to
select Finish to close the wizard.
Note
Don’t forget to set the path of the PyQt folder so that you can
access it from any folder on your computer.

¡Felicitaciones! Ha instalado con éxito PyQt en su ordenador. Ahora

puede empezar a crear sus aplicaciones GUI. Al hacerlo, se le
solicitará que especifique si desea crear una aplicación de ventana
principal o una aplicación de diálogo. ¿Qué quiere decir esto? Vamos
a ver.

Window and Dialogs

Ventana y cuadros de diálogo
Una aplicación de interfaz gráfica de usuario puede constar de una
ventana principal con varios cuadros de diálogo o sólo diálogos. Una
aplicación de interfaz gráfica de usuario pequeña por lo general
consiste de al menos un cuadro de diálogo. Una aplicación de diálogo
contiene botones. No contiene una barra de menús, barra de
herramientas, barra de estado, o un widget en el centro, mientras
que una aplicación ventana principal normalmente tiene todo eso. Un
widget central es aquella que contiene otros widgets.
Los diálogos son de dos tipos: modales y no modales. Un cuadro de
diálogo modal es el que impide que el usuario interactúa con otras
partes de la aplicación. El cuadro de diálogo es la única parte de
la aplicación que el usuario que puede interactuar con el. Hasta que
el diálogo se cierra, se puede acceder a ninguna otra parte de la
aplicación. El diálogo no modal es lo contrario de un cuadro de
diálogo modal. Cuando un cuadro de diálogo no modal está activo, el
usuario es libre para interactuar con el cuadro de diálogo y con el
resto de la aplicación.

Ways of Creating GUI Applications

Maneras de Crear aplicaciones GUI
Hay dos maneras de escribir una aplicación de GUI:
• Desde el principio con un editor de texto simple.
• Con Qt Designer, una herramienta de diseño visual que viene con
PyQt.
Obviamente, usted va a usar Qt Designer para desarrollar
aplicaciones GUI en PyQt. Antes de hacer eso, para entender la
estructura de una aplicación con interfaz gráfica, vamos a crear una
a través de la codificación.

Creating a GUI Application with Code

Crear una aplicación GUI con Código
La aplicación que se va a crear mostrará un botón con el texto en él
Close. Al hacer clic en el botón Cerrar, la aplicación terminará.
Escriba el siguiente código en cualquier editor de texto y guarde el
archivo con la extensión .pyw. Sin embargo, no incluya los números
de línea en el código, ya que son sólo la intención de identificar
cada declaración individual para explicar su papel.
nota
Las aplicaciones de consola que creó antes de este capítulo se
guarda con la extensión .py. Las aplicaciones GUI que se van a
desarrollar ahora se guardarán con la extensión .pyw. Esta es
invocar el intérprete pythonw.exe lugar del python.exe
intérprete, de manera que no aparece ninguna ventana de consola en
la ejecución de una aplicación Python GUI.
1. import sys
2. from PyQt4 import QtGui, QtCore
3. class demowind(QtGui.QWidget):
4.
def __init__(self, parent=None):
5.
QtGui.QWidget.__init__(self, parent)
6.
self.setGeometry(300, 300, 200, 200)
7.
self.setWindowTitle('Demo window')
8.
quit = QtGui.QPushButton('Close', self)
9.
quit.setGeometry(10, 10, 70, 40)
10.
self.connect(quit, QtCore.SIGNAL('clicked()'), QtGui.qApp,
QtCore.SLOT('quit()'))
11. app = QtGui.QApplication(sys.argv)
12. dw = demowind()
13. dw.show()
14. sys.exit(app.exec_())

en pyscriter:

Antes de ejecutar esta aplicación, vamos a ver lo que hace el código

en diferentes líneas.
1, 2. Importaciones de los módulos necesarios. Los widgets básicos
interfaz gráfica de usuario se encuentran en el módulo de QtGui.
3. QWidget es la clase base de todos los objetos de la interfaz de
usuario en PyQt4, por lo que están creando una nueva clase demowind
que hereda de la clase base, Qwidget.
4, 5. Proporciona el constructor predeterminado para QWidget. El
constructor por defecto no tiene padre, y un widget con ningún padre
se le conoce como una ventana.
6. SetGeometry() establece el tamaño de la ventana y define dónde
colocarlo. Los dos primeros parámetros son los x y Y ubicaciones a
las que se colocará la ventana. La tercera es la anchura, y la
cuarta es la altura de la ventana. Una ventana de 200 píxeles de
alto y se posicionará en las coordenadas 300,300.
7. Esta declaración establece el título de la ventana de Demo
Window. El título será visible en la barra de título.
8. Crea un botón con el texto Cerrar.
9. Define la anchura y la altura del boton como 70 y 40 píxeles,
respectivamente, y posicionarla en el QWidget (ventana) en las
coordenadas 10,10.
10. Manipulación de evento en PyQt4 utiliza señales y slots. Una
señal es un evento, y un slot es un método que se ejecuta sobre la
aparición de una señal. Por ejemplo, al hacer clic en un botón, un
evento clicked(), también conocida como una señal, se produce, o se
dice que es emitida. El método QtCore.QObject.connect() conecta las
señales con los slots. En este caso, el slot es un método PyQt4
predefinido: quit(). Es decir, cuando el usuario hace clic en el
botón, se invocará el método quit(). Vas a aprender sobre el manejo
de eventos con detalle en breve.
11. Crea un objeto de aplicación con el nombre de app a través del
método QApplication() del módulo QtGui. Cada aplicación PyQt4 debe
crear un objeto de aplicación. sys.argv, que contiene una lista de
argumentos de la línea de comandos, se pasa al método al crear el
objeto de aplicación. sys.argv ayuda al pasar y controlar los
atributos de inicio de una secuencia de comandos.
12. Se crea una instancia de la clase demowind con el nombre dw.
13. El método show() mostrará el widget en la pantalla.
14. Comienza el bucle de control de eventos de la aplicación. El
bucle del manejador de eventos espera un evento que ocurra y luego
lo envía evento para realizar alguna tarea. El bucle de control de
eventos continúa trabajando hasta que el metodo exit() se llama o el
widget principal se destruye. El método sys.exit() garantiza una
salida limpia, la liberación de recursos de memoria.
nota
El método exec_() tiene un guión porque exec es una palabra
clave de Python.
Al ejecutar el programa anterior, se obtiene una ventana titulada
Demo Window con un botón con el texto Close en él, como se muestra
en la Figura 7.4. Cuando se selecciona el botón, el método quit() se
ejecutará, de terminar la aplicación.
Ahora, vamos a ver cómo la herramienta Qt Designer, que viene con
PyQt, hace que la tarea de crear interfaces de usuario más rápida y
más fácil.

Using Qt Designer -Usar el diseñador de Qt

Aunque se pueden escribir programas PyQt desde cero utilizando un
simple editor de texto, también puede utilizar Qt Designer, que
viene con PyQt. Para el desarrollo de aplicaciones GUI en PyQt,
utilizando Qt Designer es una manera rápida y fácil de diseñar
interfaces de usuario sin necesidad de escribir una sola línea de
código. Para abrir Qt Designer, haga clic en el botón Inicio y
seleccione Todos los programas> PyQt GPL v4.8.5 para Python v3.2
(x86)> Qt Designer.
Qt Designer es para la creación de interfaces gráficas de usuario.
Esto hace que sea muy fácil para usted para crear cuadros de diálogo
o ventanas principales el uso de plantillas predefinidas, como se
muestra en la Figura 7.5.
probando:
Qt Designer ofrece plantillas predefinidas para una nueva
aplicación:
•

De diálogo con botones en la parte inferior: Crea un formulario

con botones Aceptar y Cancelar en la esquina inferior derecha.

Diálogo con botones a la derecha: Crea un formulario con

botones Aceptar y Cancelar en la parte derecha.

Diálogo sin botones: Crea un formulario vacío en la que puede

colocar widgets. La superclase para los diálogos es QDialog.
Usted aprenderá más acerca de estas clases pronto.
•

Ventana principal: Proporciona una ventana principal de la

aplicación con una barra de menús y una barra de herramientas
que se puede quitar si no es necesario.

Widget: Crea un formulario cuya superclase se QWidget mejor que

Qdialog.
nota
Al crear una aplicación GUI, es necesario especificar un widget de
nivel superior, que suele ser QDialog, Qwidget o QmainWindow. Si
crea una aplicación basada en la plantilla de Diálogo, el widget de
nivel superior o la primera clase que se hereda es QDialog. Del
mismo modo, si la solicitud se basa en la plantilla de la ventana
principal, el widget de nivel superior será QmainWindow, y si se
utiliza la plantilla Widget para su aplicación, el widget de nivel
superior será QWidget. Los widgets que utiliza para la interfaz de
usuario se tratan como widgets hijos de las clases.
Qt Designer muestra una barra de menú y barra de herramientas en la
parte superior. Muestra un cuadro del widget en su izquierda que
contiene una variedad de widgets que se utilizan para desarrollar
aplicaciones, agrupados por secciones. Todo lo que tienes que hacer
es arrastrar y soltar los widgets que desee en el formulario.
Puede organizar los widgets en los diseños, puesto su apariencia,
proporcionar atributos iniciales, y conectar sus señales a los
slots. La interfaz de usuario que se crea con Qt Designer se
almacena en un archivo de interfaz de usuario que incluye toda la
información de la forma: Sus widgets, diseño, etc. El archivo de ui.
Es un archivo XML, y hay que convertirlo a código Python.
De esa manera, usted puede mantener una clara separación entre la
interfaz visual y el comportamiento implementado en el código.
Pronto verás los métodos de conversión .ui en código Python.
nota
Puede crear widgets con código, también.
En el lado derecho de Qt Designer se encuentran tres ventanas por
defecto, como se muestra en la Figura 7.6.

probando:
•

Inspector de Objetos: muestra una lista jerárquica de todos los

objetos presentes en el formulario. Usted puede seleccionar
cualquier objeto en un formulario haciendo clic en el nombre
correspondiente en el Inspector de Objetos. Por lo general,
seleccione un objeto en la ventana Inspector de objetos cuando
se tiene objetos superpuestos. La ventana también muestra el
estado de diseño de los contenedores. Los contenedores son los
widgets que pueden almacenar otros widgets u objetos.
Contenedores incluyen marcos - frames, cuadros de grupo -group
boxes, widgets, widgets apilados, tab widgets y caja de
herramientas widgets.

Editor de propiedades: Se utiliza para ver y cambiar las

propiedades de la form y widgets. Se compone de dos columnas,
la propiedad y valor. La columna de propiedades enumera los
nombres de propiedades, y la columna Valor muestra los valores
correspondientes. Para cambiar una propiedad en el mismo valor
para un conjunto de widgets, seleccione todos ellos. Para
seleccionar un conjunto de widgets, haga clic en uno de los
widgets y luego Shift + clic en los demás, uno por uno. Cuando
se selecciona un conjunto de widgets, la ventana del Editor de
Propiedades mostrará las propiedades que son comunes en todos
los widgets seleccionados, y cualquier cambio realizado en una
propiedad será aplicada a los widgets seleccionados.

Navegador de recursos: Qt Designer le permite mantener los

recursos como imágenes, audio, vídeo, etc, de sus aplicaciones
a través del explorador de recursos. Para todas las formas de
su aplicación, se mantiene un archivo de recursos
independiente. Puede definir, cargar y editar archivos de
recursos de su aplicación a través del explorador de recursos.
Por debajo de la ventana del Explorador de recursos, se
encuentran dos pestañas más, el Editor de señales / slots y
Editor de acciones.

Signal/Slot Editor: Esta ventana muestra las conexiones de

señal /slot entre objetos. Puede editar las conexiones de
señal/slot a través de esta ventana.

Editor de acciones: El Editor de acciones le permite gestionar

las acciones de sus aplicaciones. Para iniciar las acciones, la
barra de la barra de herramientas y el menú están diseñados en
una aplicación. La acción respectiva o tarea para cada uno de
los iconos de la barra de herramientas y elementos de menú de
la barra de menú se definen a través del Editor de acciones.
Puede crear nuevas acciones, las acciones de eliminación,
editar acciones y definir iconos para las acciones a través del
Editor de acciones.
Además, se puede asociar acciones respectivas con los elementos
de menú y barras de herramientas.
nota
Para las acciones rápidas y manejables, Qt Designer proporciona
un menú contextual que se obtiene haciendo clic derecho en un
objeto.

El componente principal utilizado para la creación de una interfaz

de usuario es widgets. Button, menús y scrollbars - barras de
desplazamiento son ejemplos de widgets y no sólo se utilizan para
recibir la entrada del usuario, sino también para la visualización
de los datos y la información de estado. Los widgets se pueden
anidar dentro de otro en una relación padre-hijo.
Un widget que no tiene ningún widget padre se llama una ventana. La
clase de widgets, QWidget, proporciona métodos para hacerlos en la
pantalla, recibir entradas del usuario, y manejar diferentes
eventos. Todos los elementos de interfaz de usuario que Qt ofrece
son subclases de QWidget. Qt Designer muestra una lista de los
widgets en una Caja Widget que muestra en el lado izquierdo.

Widget Box – caja Widget

El Widget Box (véase la Figura 7.7) muestra una lista categorizada
de widgets y otros objetos que se pueden utilizar para el diseño de
una interfaz de usuario rápida y fácilmente. Widgets con funciones y
usos similares se agrupan en categorías. Es muy simple para crear
una interfaz gráfica de usuario al pasar al modo de edición de
Widget. Seleccione un icono de la barra de herramientas y desplazar
los widgets deseados al formulario.

Figure 7.7. Widget Box.

Usted puede también agrupar widgets que utiliza a menudo en una
categoría creada por usted, también conocida como una categoría
scratch pad. Para colocar los widgets en la categoría scratch pad,
simplemente arrástrelos desde la forma y soltarlos en la categoría.
Estos widgets se pueden utilizar en la misma forma que cualquier
otro control. Puede cambiar el nombre de cualquier widget y retírela
del scratch pad con el menú de contexto.
Los widgets son objetos de sus respectivas clases. (Qt Designer no
utiliza nombres de clase para sus widgets, el nombre del widget
significa la clase se refiere.)

Los widgets en Widget Box se agrupan en las siguientes categorías:

•
•
•
•
•
•
•
•
•

Layouts - presentaciones
Spacers - espaciadores
Buttons - botones
Item Views (Model-Based)- Articulos Vistas(basado en modelos)
Item Widgets (Item-Based)
Containers - contenedores
Input Widgets
Display Widgets
Phonon

Una descripción de los widgets en cada categoría es la siguiente.

Layouts

Layouts se utilizan para la organización de los widgets de una

manera deseada. El layout controla el tamaño de los widgets dentro
de ella, y los widgets se redimensionan automáticamente cuando se
cambia el tamaño del formulario. Los widgets en el grupo Layouts se
muestra en la Tabla 7.1.
Table 7.1. Widgets in the Layouts Group
Widget

Description

Vertical Layout
(QVBoxLayout)

Organiza los widgets

verticalmente, uno debajo del
otro.

Horizontal Layout
(QHBoxLayout)

Organiza los widgets

horizontalmente, uno al lado del
otro.

Grid Layout (QGridLayout

Organiza los widgets en filas y

columnas.

Form Layout (QFormLayout

Organiza los widgets en un diseño

de dos columnas. La primera
columna muestra generalmente
mensaje (s) en las etiquetas, y
la segunda, por lo general
contiene los widgets, que permite
al usuario introducir / editar
los datos correspondientes a las
etiquetas en la primera columna.
Spacers

Los espaciadores no son visibles durante la ejecución de un

formulario y se utilizan para insertar espacios entre widgets o
grupos de widgets. Los widgets en el de grupo Los espaciadores se
muestran en la Tabla 7.2.
Table 7.2. Widgets in the Spacers Group
Widget

Description

Horizontal Spacer
(Spacer)

Inserta espacios horizontales

entre widgets.

Vertical Spacer
(Spacer)

Inserta espacios verticales entre

widgets.

Buttons

Los botones se utilizan para iniciar una acción. Son generadores de

eventos o señales que se pueden utilizar para realizar tareas. Los
widgets en el grupo de botones se muestran en la Tabla 7.3.
Table 7.3. Widgets in the Buttons Group

Widget

Description
Push Button (QPushButton)

Muestra un botón de comando.

Tool Button (QToolButton)

Muestra un botón para acceder a

comandos u opciones. Se utiliza
en el interior de una barra de
herramientas.

Radio Button
(QRadioButton)

Muestra un botón de radio con una

etiqueta de texto.

Check Box (QCheckBox)

Muestra una casilla de

verificación con una etiqueta de
texto.

Command Link Button

(QCommandLinkButton)

Muestra un botón de vínculo de

comando.

Button Box
(QDialogButtonBox)

Una subclase de QWidget que

presenta un conjunto de botones
en un diseño.

Item Views (Model-Based)

Artículo Vistas widgets se utilizan para la visualización de grandes

volúmenes de datos. Modelo basado significa que los widgets son
parte de un marco de modelo / vista y le permiten presentar los
datos en diferentes formatos ya través de múltiples puntos de vista.
Las clases de estos widgets implementan las interfaces definidas por
la clase QAbstractItemView para que pueda visualizar los datos
proporcionados por los modelos derivados de la clase
QAbstractItemModel. Los widgets en el grupo de artículos Vistas
(basado en modelos) se muestran en la Tabla 7.4.

Table 7.4. Widgets in the Item Views (Model-Based) Group

Widget

Description
List View (QListView)

Se utiliza para mostrar una lista

de elementos. Se debe utilizar
con una subclase
QAbstractItemModel.

Tree View
(QTreeView)

Se utiliza para mostrar datos

jerárquicos. Se debe utilizar con
una subclase QAbstractItemModel.

Table View
(QTableView

Se utiliza para mostrar los datos

en forma de tabla. Puede mostrar
iconos, así como el texto en cada
celda. Debe ser usado en
conjunción con una subclase
QAbstractItemModel.

Column View
(QColumnView)

Proporciona una implementación de

modelo / vista de una columna de
vista. Muestra los datos de una
serie de vistas de listas.

Item Widgets (Item-Based)

Reproductores de elementos - item Widgets tienen vistas

independientes. Los widgets en los widgets elemento de grupo (ItemBased) se
muestran en la Tabla 7.5.
Table 7.5. Widgets in the Item Widgets (Item-Based)Group
Widget
Description
List Widget
(QListWidget)

Se utiliza para mostrar una lista

de elementos. Tiene un modelo
integrado, por lo que los
elementos se puede agregar a él
directamente.

Tree Widget
(QTreeWidget)

Se utiliza para mostrar datos

jerárquicos. Tiene un modelo
integrado, por lo que los
elementos se puede agregar a él
directamente.

Table Widget
(QTableWidget)

Se utiliza para mostrar los datos

en forma de tabla. Puede mostrar
iconos, así como el texto en cada
celda. Tiene un modelo integrado,
por lo que los elementos se puede
agregar a él directamente.

Containers

Widgets de contenedores se utilizan para controlar una colección de

objetos en un formulario. Un widget se dejó caer en un recipiente se
convierte en un objeto secundario del contenedor. Los objetos
secundarios en un contenedor también se pueden organizar en los
diseños deseados. Los widgets en el grupo de contenedores se
muestran en la Tabla 7.6.
Table 7.6. Widgets in the Containers Group
Widget

Description

Group Box (QGroupBox)

Se utiliza para agrupar un

conjunto de widgets de función
similar.

Scroll Area (QScrollArea)

Se utiliza para mostrar el

contenido de un widget hijo
dentro de un marco. Si el widget
hijo supera el tamaño del marco,
las barras de desplazamiento
aparecen para que pueda ver todo
el widget hijo.

Tool Box (QToolBox)

Muestra una serie de páginas o

secciones en una caja de
herramientas.

Tab Widget (QTabWidget)

Muestra pestañas que se pueden

utilizar para mostrar
información. Un gran volumen de
información se puede mostrar
mediante su división en trozos y
mostrarla en fichas individuales
Stacked Widget
(QStackedWidget)

Muestra una pila de widgets donde

sólo un widget es visible a la
vez.

Frame (QFrame)

Se utiliza para encerrar y

agrupar widgets. También puede
ser utilizado como un marcador de
posición en las formas.

Widget (QWidget)

La clase base de todos los

objetos de la interfaz de
usuario.

MdiArea (QMdiArea)

Proporciona un área para la

visualización de ventanas MDI.

Dock Widget (QDockWidget)

Puede ser acoplado dentro de una

ventana principal o flotaba como
una ventana de herramientas
independiente.

Input Widgets

Reproductores de entrada-input widgets son para utilizar para

interactuar con el usuario. El usuario puede suministrar datos a la
aplicación a través de estos widgets. Los widgets del grupo
Reproductores de entrada se muestran en la Tabla 7.7.
Table 7.7. Widgets in the Input Widgets Group

Widget

Description

Combo Box (QComboBox)

Muestra una lista desplegable.

Font Combo Box

(QFontComboBox)

Muestra un cuadro combinado que

permite la selección de la
fuente.

Line Edit (QLineEdit)

Muestra un cuadro de texto de una

línea para introducir / editar
texto sin formato.

Text Edit (QTextEdit)

Se utiliza para editar texto

plano o HTML.

Plain Text Edit

(QPlainTextEdit)

Se utiliza para editar y mostrar

el texto sin formato.

Spin Box (QSpinBox)

Muestra un cuadro de número.

Double Spin Box

(QDoubleSpinBox)

Muestra un cuadro de número de

valores dobles.

Time Edit (QTimeEdit)

Se utiliza para la edición de los

tiempos

Date Edit (QDateEdit)

Se utiliza para las fechas de

edición.

Date/Time Edit
(QDateTimeEdit)

Se utiliza para fechas y horas de

edición.
Dial (QDial)

Muestra un control de rango

redondeado.

Horizontal Scrollbar (QScrollBar)

Muestra una barra de

desplazamiento horizontal.

Vertical Scrollbar
(QScrollBar)

Muestra una barra de

desplazamiento vertical.

Horizontal Slider (QSlider)

Muestra un deslizador horizontal.

Vertical Slider (QSlider)

Muestra un control deslizante

vertical.

QsciScintilla

Scintilla es un componente de
edición que realiza el estilo de
sintaxis, autocompletado de
código, romper puntos, sangría
automática, y otras tareas.
Es muy útil en la edición y
depurar el código fuente. El
componente Scintilla está dentro
QsciScintilla y utiliza de Qt
Designer para desarrollar
aplicaciones GUI como cualquier
otro widget de Qt.

Display Widgets

Mostrar los widgets se utilizan para la visualización de información

o mensajes al usuario. Los widgets del grupo Reproductores-widgets
Display se muestran en la Tabla 7.8.
Table 7.8. Widgets in the Display Widgets Group
Widget
Description

Label (QLabel)

Muestra el texto o imágenes.

Text Browser
(QTextBrowser)

Muestra una de sólo lectura

casilla de texto de varias líneas
que puede mostrar tanto texto
como HTML plano, incluyendo
listas, tablas e imágenes. Es
compatible con hacer clic en
enlaces, así como las hojas de
estilo en cascada.

Graphics View
(QGraphicsView)

Se utiliza para displays

gráficos.
Calendar
(QCalenderWidget)

Muestra un calendario mensual que

le permite seleccionar una fecha.

LCD Number (QLCDNumber)

Muestra los dígitos en la

pantalla LCD similares.

Progress Bar
(QProgressBar)

Muestra barras de progreso

horizontales y verticales.

Horizontal Line (QFrame)

Muestra una línea horizontal.

Vertical Line (QFrame)

Muestra una línea vertical.

QDeclarativeView

Una subclase QGraphicsView

proporcionado para la
visualización de las interfaces
QML. Para mostrar una interfaz
QML dentro de las aplicaciones
basadas en GUI QWidget que no
utilizan el marco Vista Gráfica,
se utiliza Qdeclarative.
QDeclarativeView inicializa
QGraphicsView para un rendimiento
óptimo con QML para que los
objetos de la interfaz de usuario
se pueden colocar en un
QGraphicsScene estándar y se
muestran con Qgraphics-View.
QML es un lenguaje declarativo
utilizado para describir la
interfaz de usuario en un árbol
de objetos con propiedades.

QWebView

Se utiliza para ver y editar

documentos Web.

Phonon

Phonon es una API de multimedia que ofrece una capa de abstracción

para capturar, mezclar, procesamiento y reproducción de audio y
vídeo. Los widgets en el grupo de Phonon se muestran en la Tabla
7.9.
Table 7.9. Widgets in the Phonon Group
Widget

Description

Phonon::VideoPlayer

Se utiliza para mostrar el vídeo.

Phonon::SeekSlider

Muestra slider para ajustar las

posiciones de flujo de medios.

Phonon::VolumeSlide

Muestra control deslizante para

controlar el volumen de salida de
audio.

Qt Designer muestra una barra

que muestra los iconos de las
guardar archivos, cambiar los
Echemos un vistazo a la barra

de herramientas en la parte superior

tareas más frecuentes, como abrir y
modos, y la aplicación de diseños.
de herramientas.

Toolbar
En la parte superior de Qt Designer es una barra de herramientas con
iconos como se muestra en la Figura 7.8.
Figure 7.8. Qt Designer toolbar.

La siguiente es una breve descripción de los iconos mostrados en la

barra de herramientas:
• New: Muestra un cuadro de diálogo nuevo formulario (consulte la
Figura 7.5) muestra diferentes plantillas para la creación de
una nueva forma.
• Open: Abre el cuadro de diálogo Abrir formulario, que se puede
utilizar para navegar por el disco duro para buscar y
seleccionar un archivo .ui para trabajar.
• Save: Se usa para guardar el formulario.
• Enviar al fondo – send to back: envía el widget seleccionado al
fondo en los widgets de solapamiento, por lo que es invisible.
Consideremos dos botones superpuestos, PushButton1 y
PushButton2. Si selecciona PushButton1 y haga clic en Enviar al
fondo, PushButton1 se ocultará detrás PushButton2, como se
muestra en la Figura 7.9 (a).
•

Traer al frente – Bring to front: Trae el widget seleccionado

en la parte delantera, por lo que es visible. Este icono sólo
funciona cuando los widgets se solapan entre sí. Si selecciona
PushButton1 y haga clic en Traer al frente, se hará visible,
como se muestra en la Figura 7.9 (b).
Editar Widgets: El modo Widget edición le permite editar las
propiedades de widgets. Además, se puede eliminar widgets en
diseños existentes en el formulario en este modo. También puede
arrastrar los widgets entre las formas. También puede clonar un
widget arrastrándolo con la tecla Ctrl pulsada. Para activar el
modo de edición de Widget, puede elegir cualquiera de las tres
opciones: presione F3, seleccione Edición> Editar Widgets desde
el menú, o haga clic en el icono Editar Widgets en la barra de
herramientas.
Edit Signals/Slots:Las Señales y metodos mode de edición se
utiliza para la representación y edicion de signal / slots
conectados entre objetos en un formulario. Para cambiar a las
señales y metodos en modo de edición, puede pulsar la tecla F4,
seleccione Edit> Editar Signal / Slots Edit, o seleccione el
icono Editar Signals / slots desd barra de herramientas. El
modo muestra todas las conexiones de señal y metodos-slots en
forma de flechas para que usted sepa qué objeto está conectado
a qué. También puede crear nuevas conexiones de señal y slot
entre los widgets en este modo y borre una señal existente. Las
señales y los slots se refieren a diferentes eventos y los
métodos correspondientes que se ejecutan en la ocurrencia de un
evento. Para establecer la señal y la conexión de metodo entre
dos objetos en un formulario, seleccione un objeto haciendo
clic con el botón izquierdo del ratón y arrastre el ratón hacia
el objeto al que se quiere conectar y suelte el botón del
ratón. También puede cancelar la conexión mientras se arrastra
el ratón pulsando la tecla Esc.Cuando suelte el ratón sobre el
objeto de destino, aparece un cuadro de diálogo de conexión,
que le pide que seleccione una señal desde el objeto de origen
y un slot- metodo del objeto de destino. Después de seleccionar
la señal y el slot correspondiente, seleccione Aceptar para
establecer la conexión de señal / slot. También puede
seleccionar Cancelar en el cuadro de diálogo Conexión de
cancelar la operación de conexión. La señal y slot seleccionada
aparecerán como etiquetas en la flecha que conectan los dos
objetos. Para modificar una conexión, haga doble clic en la
ruta de conexión o una de sus etiquetas para mostrar el cuadro
de diálogo de conexión. Desde el diálogo de conexión se puede
editar una señal o un slot como se desee. Para eliminar una
conexión de señal / slot, seleccione la flecha en el formulario
y pulse la tecla Supr. La conexión de signal /slot también se
puede establecer entre un objeto y formulario; usted puede
•

•
•

conectar señales de los objetos a los slots en el formulario.

Para conectar un objeto del formulario, seleccione el objeto,
arrastre el ratón y suelte el botón del ratón sobre el
formulario. El punto final de la conexión cambia al símbolo de
tierra eléctrica. Para salir de las señales y el modo de slots
Edición, seleccione Edición> Editar Widgets o presione la tecla
F3.
Edit Buddies: Modo de Edición de Buddy-amigo se utiliza para
ajustar el foco del teclado en los widgets que no pueden
aceptar la entrada del teclado. Es decir, al hacer un widget
que puede aceptar la entrada de teclado a un compañero, los
widgets que no pueden aceptar la entrada del teclado también
obtendrán el foco del teclado. Aparecen flechas para mostrar
las relaciones entre los widgets-controles y sus buddiescompinches. Para activar el
modo de edición de Buddy -amigos,
puede seleccionar la opción Edit> Edit Buddies en el menú, o
haga clic en el icono Editar Buddies-Amigos en la barra de
herramientas.
Edit Tab Order:En este modo, puede especificar el orden en que
los widgets de entrada pueden obtener el foco del teclado. El
orden de tabulación predeterminado se basa en el orden en que
los widgets se colocan en el formulario.
Lay Out Horizontally:Distribuye los widgets seleccionados en
una disposición horizontal junto a la otra. Tecla de método
abreviado es Ctrl +1.
Lay Out Vertically:Organiza los widgets seleccionados en un
diseño vertical, uno debajo de otro. Tecla de método abreviado
es Ctrl +2.
Lay Out Horizontally in Splitter:En este diseño, los widgets se
colocan en un divisor, dispuestas de forma horizontal y que le
permite ajustar la cantidad de espacio asignado para cada
widget. Tecla de método abreviado es Ctrl +3.
Lay Out Vertically in Splitter: Los widgets están dispuestos
verticalmente, lo que permite al usuario ajustar la cantidad de
espacio asignado para cada widget. Tecla de método abreviado es
Ctrl +4.
Lay Out in a Grid:Organiza los widgets en una cuadrícula
similar a una tabla (filas y columnas). Cada widget ocupa una
celda de la tabla que se puede modificar para abarcar varias
celdas.
Lay Out in a Form Layout:Organiza los widgets seleccionados en
un formato de dos columnas. La columna de la izquierda es por
lo general para los widgets de la etiqueta que muestra los
mensajes, y la columna de la derecha muestra widgets para la
escritura / edición / mostrar los datos de las etiquetas
correspondientes en la primera columna, como la línea de
edición-line edit, cuadro combinado-combo box, y fecha de
edición-Date edit.
Break Layout:Una vez que los widgets se arreglan en un diseño,
no se puede mover y cambiar el tamaño de forma individual, ya
que su geometría se controla con el diseño. Este icono es
romper el diseño. Tecla de método abreviado es Ctrl +0.
Adjust Size:Ajusta el tamaño del diseño para dar cabida a los
widgets contenidas y para asegurar que cada uno tiene el
espacio suficiente para que sea visible. Tecla de método
abreviado es Ctrl + J.
En casi todas las aplicaciones, necesita algunos widgets muy
fundamentales como etiquetas, Línea ediciones y pulsadores-Push
Buttons. Se requiere que estos widgets para mostrar mensajes de
texto, para aceptar la entrada del usuario, y para iniciar alguna
acción, respectivamente. Echemos un vistazo a estos widgets
fundamentales.

Understanding Fundamental Widgets

Entender Reproductores Fundamentales
El primer widget vamos a discutir es el widget Label, una forma muy
popular de mostrar información de texto o en una aplicación GUI.

Displaying Text
Para mostrar texto no editable o una imagen, se utilizan widgets de
etiquetas; Una etiqueta es una instancia de la clase QLabel. Un
widget Label es un widget muy popular para la visualización de
mensajes y la información al usuario. Los métodos proporcionados por
la clase QLabel se muestran en la Tabla 7.10.
Tabla 7.10. Métodos proporcionados por la clase Qlabel
Methods

Usage

setText()

Asigna texto para el widget

Label.

setPixmap()

Asigna un mapa de píxeles, una

instancia de la clase QPixmap, al
widget Label.

setNum()

Asigna un número entero o doble

valor al widget Label.

clear()

Borra el texto desde el widget

Label.

El texto predeterminado de un QLabel es TextLabel. Es decir, cuando

se agrega un QLabel a un formulario arrastrando un widget Label y
soltándolo en el formulario, se mostrará "TextLabel." Además de
utilizar setText (), también puede asignar texto a un QLabel
seleccionado estableciendo su propiedad de texto en la ventana del
Editor de propiedades. Por ejemplo, si establece la propiedad de
texto para introducir su nombre, el QLabel seleccionada se mostrará
el texto "Escriba su nombre" en el formulario.

Entering Single-Line Data

Entrando en una sola línea de datos
Para permitir al usuario introducir o editar los datos de una sola
línea, se utiliza el widget Line Edit, que es una instancia de
QLineEdit. El widget soporta mecanismos simples de edición, como
deshacer, rehacer, cortar y pegar. Los métodos proporcionados por
QLineEdit se muestran en la Tabla 7.11.
Table 7.11. Methods Provided by QlineEdit
Tabla 7.11. Métodos proporcionados por QlineEdit
Method

Usage

setEchoMode()

Se utiliza para establecer el

modo de repeticion del widget
Line Editar para determinar cómo
se muestra el contenido del
widget Line Edit. Las opciones
disponibles son las siguientes:
Normal: El modo por defecto.
Muestra los caracteres a medida
que se introducen.
NoEcho: No muestra nada.
Password: Muestra los asteriscos
que el usuario introduzca datos.
PasswordEchoOnEdit: muestra
caracteres al editar; de lo
contrario, se muestran
asteriscos.

maxLength()

Se utiliza para especificar la

longitud máxima del texto que el
usuario puede entrar. Para la
edición de múltiples líneas,
utilice QTextEdit.

setText()

Asigna texto para el widget Line

Edit.

text()

Obtiene el texto introducido en

el widget Line Edit.

clear()

Borra el contenido del widget

Line Edit.

setReadOnly()

Pasa el valor Booleano true para

este método para hacer el widget
Line Edit sólo lectura. El
usuario no puede modificar el
contenido del widget Line Edit
pero puede copiarlo. El cursor se
convertirá en invisible en modo
de sólo lectura.

isReadOnly()

Devuelve true si el widget Line

Edit se encuentra en modo de sólo
lectura.

setEnabled()

El widget de edición de línea

será borrosa, lo que indica que
está desactivada. No se puede
editar el contenido de un widget
de edición de línea desactivada,
pero puede asignar un texto a
través del método setText().

setFocus()

Se utiliza para establecer el

cursor en el widget de edición de
línea- Line Edit especificado.

Las señales emitidas por el widget Line Edit son los siguientes:
TextChanged(): La señal se emite cuando se cambia el texto en el
widget Line Edit.
returnPressed(): La señal se emite cuando se pulsa Return o Enter.
editingFinished (): La señal se emite cuando el foco se pierde en el
widget Line Edit, lo que confirma la tarea de edición ha terminado
en él.
El siguiente widget es la forma más común de iniciar acciones en
cualquier aplicación.

Displaying Buttons
Viendo Botones
Para mostrar botones (normalmente Botones de comando) en una
aplicación, es necesario crear una instancia de la clase
QpushButton. Al asignar texto a los botones, puede crear teclas de
acceso directo precediendo cualquier carácter en el texto con un
símbolo de unión. Por ejemplo, si el texto asignado a un pulsador es
&Click Me, se subrayó el carácter C para indicar que se trata de una
tecla de acceso, y el usuario puede seleccionar el botón pulsando
Alt + C. El botón emite una señal clicked() si se activó.
Además de texto, un icono también se puede mostrar en el pulsadorpushbutton. Los
métodos para la visualización de texto y un icono de
un botón son estas:
setText(): Se utiliza para asignar el texto al pulsador.
setIcon(): Se utiliza para asignar icono para el botón.
El único concepto dejó de examinar antes de comenzar con su primera
aplicación en QtDesigner es la gestión de eventos. Vamos a ver cómo
los eventos se manejan en PyQt.

Event Handling in PyQt

Control de eventos en PyQt
En PyQt, el mecanismo de control de eventos también se conoce como
señales y slots. Cada control emitirá señales cuando cambia su
estado. Cada vez que se emite una señal, simplemente se va a
producir. Para realizar una tarea en respuesta a una señal, la señal
tiene que ser conectado a un slot. Un slot se refiere al método que
contiene el código que se desea ejecutar en la aparición de una
señal. La mayoría de los widgets se han predefinido slots, usted no
tiene que escribir código para conectar una señal predefinida a un
slot predefinida. Para responder a las señales emitidas, se
identifica el QObject y la señal que emite y llama al método
asociado. Puede usar Qt Designer para conectar señales con slots
incorporadas. ¿Cómo? Veamos mediante la creación de una aplicación.
nota
Señales difieren según el tipo de widget.

First Application in Qt Designer

Primera aplicación en Qt Designer
Vamos a crear una aplicación en Qt Designer para demostrar cómo
conectar señales con slots incorporadas. En la apertura, Qt Designer
le pedirá que seleccione una plantilla para su nueva aplicación,
como se mostró anteriormente en la Figura 7.5.

Qt Designer proporciona una serie de plantillas que son adecuados

para diferentes tipos de aplicaciones. Usted puede elegir cualquiera
de estas plantillas y, a continuación, seleccione el botón Crear.
Seleccione diálogo con botones inferior y haga clic en el botón
Crear.
Un nuevo formulario se creó con una leyenda o caption "sin título".
El formulario contiene un cuadro de botón que tiene dos botones,
Aceptar y Cancelar, como se muestra en la figura 7.10. Las
conexiones de señal-slot del botones Aceptar y Cancelar ya están
configurados por defecto.
Figure 7.10. Dialog box with two buttons, OK and Cancel.

Con el fin de aprender a conectar señales con los slots de forma

manual, seleccione la casilla de botón haciendo clic cualquiera de
los botones, a continuación, elimínelo (que elimina los botones).
Ahora usted tiene una forma completamente en blanco.
Añadir una QLabel, QLineEdit y QPushButton al formulario arrastrando
y soltando un Label, Line Edit, y empuje el control Botón de la caja
del widget en el formulario. La propiedad de texto predeterminado de
la etiqueta es TextLabel, como se muestra en la Figura 7.11 (a). Se
puede cambiar si cambia la propiedad de texto en el Editor de
propiedades. Seleccione el widget Label y establezca su propiedad de
texto para introducir texto a través del Editor de propiedades. Del
mismo modo, establecer el texto del widget Button Push a Clear, como
se muestra en la figura 7.11 (b).
Figure 7.11. (a) Three widgets dropped on the form. (b) Widgets on
the form with the text property set.
Figura 7.11. (a) Tres reproductores- widgtes arrastrados en el
formulario. (b) Widgets en el formulario con el conjunto de
propiedades de texto.
En pratica:

nota
Para una vista previa de un formulario durante la edición,
seleccione el Formulario, Vista previa o Ctrl + R.
¿Quieres un poco de acción a pasar cuando el usuario selecciona
Borrar en el formulario, por lo que necesita para conectar la señal
de empuje de Button al slots de la línea de edición.

Connecting to Predefined Slots

Coneccion a slots predefinidos
Actualmente, está en el modo de edición del widget, y para aplicar
las conexiones de señal / slot, es necesario cambiar primero a las
señales y slots modo de edición. Seleccione el icono Editar
Señales / slots de la barra de herramientas para cambiar a señales y
slots modo de edición.
En el formulario, seleccione el botón Borrar y arrastre el ratón
para el widget Line Edit y suelte el botón del ratón. El cuadro de
diálogo Configurar conexión aparecerá, lo que le permite establecer
una conexión de señal-slot entre el botón Borrar y el widget Line
Edit, como se muestra en la figura 7.12.
Figure 7.12. Configure Connection dialog displaying predefined
slots.

Cuando el usuario selecciona el botón Borrar, usted quiere ningún

texto en el widget Line Editar para ser eliminado. Para que esto
suceda, usted tiene que conectar la señal clicked() del botton al
slot clear() de la línea de edición. Así, en el cuadro de diálogo
Configurar conexión, seleccione la señal clicked () de la columna de
PushButton y el slot clear() de la columna de la línea de edición y
seleccione Aceptar. En el formulario, verá que aparece una flecha,
lo que representa la conexión de la señal-slot entre las dos
widgets, como se muestra en la figura 7.13.
Figure 7.13. The signal-slot connection in widgets represented with
arrows.

Vamos a guardar el formulario con el nombre FirstApp. La ubicación

predeterminada en la que se guardará el formulario es C: \
Python32 \ Lib \ site-packages \ PyQt4. El formulario se guarda en
un archivo con la extensión .ui. El archivo FirstApp.ui contendrá
toda la información del formulario, sus widgets, diseño, etc. . El
archivo ui es un archivo XML, y contiene el siguiente código:
el codigo lo podemos ver con notepad++ y lo configuramos al color
de un xml en herramientas/complemento/Macroformater y seria asi:
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Dialog</class>
<widget class="QDialog" name="Dialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Dialog</string>
</property>
<widget class="QLabel" name="label">
<property name="geometry">
<rect>
<x>40</x>
<y>70</y>
<width>61</width>
<height>16</height>
</rect>
</property>
<property name="text">
<string>Enter Text</string>
</property>
</widget>
<widget class="QPushButton" name="pushButton">
<property name="geometry">
<rect>
<x>140</x>
<y>190</y>
<width>75</width>
<height>23</height>
</rect>
</property>
<property name="text">
<string>Clear</string>
</property>
</widget>
<widget class="QLineEdit" name="lineEdit">
<property name="geometry">
<rect>
<x>140</x>
<y>70</y>
<width>113</width>
<height>20</height>
</rect>
</property>
</widget>
</widget>
<resources/>
<connections>
<connection>
<sender>pushButton</sender>
<signal>clicked()</signal>
<receiver>lineEdit</receiver>
<slot>clear()</slot>
<hints>
<hint type="sourcelabel">
<x>193</x>
<y>196</y>
</hint>
<hint type="destinationlabel">
<x>208</x>
<y>82</y>
</hint>
</hints>
</connection>
</connections>
</ui>
Para utilizar el archivo, primero debe convertirlo en script Python.
La utilidad del sistema que va a utilizar para convertir un archivo
de ui. En un script de Python es pyuic4.
En Windows, la utilidad pyuic4 se lía con PyQt. Para realizar la
conversión, usted necesita abrir una ventana de símbolo del sistema
y navegue a la carpeta donde está guardado el archivo y ejecuta la
orden:
C:\Python32\Lib\site-packages\PyQt4>pyuic4 FirstApp.ui -o FirstApp.py
El comando muestra la conversión del archivo FirstApp.ui en un
script de Python, FirstApp.py
nota
El código Python que genera este método no debe ser modificado
de forma manual, ya que cualquier cambio se sobrescribirán la
próxima vez que se ejecuta el comando pyuic4.
El archivo de script Python FirstApp.py puede tener el siguiente
código. El código generado puede variar ligeramente en comparación
con el siguiente código, ya que depende de varios factores,
incluyendo el tamaño de la ventana, ubicación del botón, y así
sucesivamente:
# -*- coding: utf-8 -*# Form implementation generated from reading ui file
'FirstApp.ui'
#
# Created: Thu Jul 17 16:48:13 2014
#
by: PyQt4 UI code generator 4.9.6
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
try:
_encoding = QtGui.QApplication.UnicodeUTF8
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig,
_encoding)
except AttributeError:
def _translate(context, text, disambig):
return QtGui.QApplication.translate(context, text, disambig)
class Ui_Dialog(object):
def setupUi(self, Dialog):
Dialog.setObjectName(_fromUtf8("Dialog"))
Dialog.resize(400, 300)
self.label = QtGui.QLabel(Dialog)
self.label.setGeometry(QtCore.QRect(40, 70, 61, 16))
self.label.setObjectName(_fromUtf8("label"))
self.pushButton = QtGui.QPushButton(Dialog)
self.pushButton.setGeometry(QtCore.QRect(140, 190, 75, 23))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.lineEdit = QtGui.QLineEdit(Dialog)
self.lineEdit.setGeometry(QtCore.QRect(140, 70, 113, 20))
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.retranslateUi(Dialog)
QtCore.Qobject.connect(self.pushButton,QtCore.SIGNAL(_fromUtf8("clicked()")
),self.lineEdit.clear)

QtCore.QMetaObject.connectSlotsByName(Dialog)

def retranslateUi(self, Dialog):

Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
self.label.setText(_translate("Dialog", "Enter Text", None))
self.pushButton.setText(_translate("Dialog", "Clear", None))
Este script es muy fácil de entender. Se crea una clase con el
nombre del objeto de nivel superior, con Ui_ antepondrá. Desde
entonces, el objeto de nivel superior usado en nuestra aplicación es
de diálogo, la clase Ui_Dialog se crea y almacena los elementos de
la interfaz de nuestro widget. Esa clase tiene dos métodos,setupUi()
y retranslateUi().
El método setupUi() establece los reproductores o widgets; crea los
widgets que usted utilizó durante la definición de la interfaz de
usuario en Qt Designer. El método crea los widgets de uno en uno y
también establece sus propiedades. El método setupUi() toma un
único argumento, que es el widget de nivel superior en el que se
crea la interfaz de usuario (widgets hijos). En nuestra aplicación,
que es una instancia de QDialog. El método retranslateUi() traduce
la interfaz. El archivo de las importaciones de todo, desde los dos
módulos, QtCore y la QtGui, ya que va a necesitar en el desarrollo
de aplicaciones GUI.
QtCore: El módulo QtCore constituye la base de todas las
aplicaciones basadas en Qt. Contiene las clases más
fundamentales, como QCoreApplication, QObject, y así
sucesivamente. Estas clases realizan varias tareas importantes,
tales como el manejo de archivos, manejo a través del bucle de
eventos, la aplicación de las señales y el mecanismo de slot,
control de concurrencia, y mucho más caso. El módulo incluye
varias clases, incluyendo QFile, QDir, QIODevice, QTimer,
QString, método QDate y método Qtime.
QtGui: El módulo QtGUI contiene las clases necesarias en el
desarrollo de aplicaciones GUI multiplataforma. El módulo
contiene la mayoría de las clases de interfaz gráfica de
usuario, incluyendo QCheckBox, QComboBox, QDateTimeEdit,
QLineEdit, QPushButton, QPainter, QPaintDevice, QApplication,
QTextEdit, y QtextDocument.
Usted estara tratando el código como un archivo de cabecera, y se le
importarla al archivo de origen desde el que se va a invocar su
diseño de interfaz de usuario. Vamos a crear el archivo de origen
con el nombre callFirstApp.pyw e importar el código FirstApp.py a
ella. El código en el archivo es como se muestra aquí:
el archivo CallFirstApp.pyw debe estar en la misma carpeta de
FirstApp.py
El módulo sys es importado para que pueda acceder a los argumentos
de la línea de comandos almacenados en la lista sys.argv. En primer
lugar se crea un objeto QApplication. Todas las aplicaciones PyQt
GUI debe tener un objeto QApplication para proporcionar acceso a
información como el directorio de la aplicación, tamaño de la
pantalla, y así sucesivamente.
Al crear un objeto QApplication, se pasa los argumentos de línea de
comandos a la misma por la sencilla razón de que PyQt puede actuar
sobre los argumentos de línea de comandos, si es necesario. Se crea
una instancia de MyForm y llama a su método show(), que añade un
nuevo evento a la cola de eventos del objeto QApplication: una
solicitud para pintar los reproductores o widgets especificados en
la clase, MyForm. El app.exec_() se llama para iniciar ciclo de
eventos del objeto QApplication.
Una vez que el ciclo de eventos comienza, el widget de nivel
superior usado en la clase, MyForm, se muestra junto con sus widgets
hijos. Todos los eventos que se producen, ya sea a través de la
interacción del usuario o generado por el sistema, se agregan a la
cola de eventos. Bucle de eventos de la aplicación comprueba
continuamente para ver si ha ocurrido algún evento. Si es así, el
bucle de eventos procesa y, finalmente, pasa al método asociado.
Cuando se cierra el widget de nivel superior que se muestra, se
entra en el modo oculto y PyQt elimina el widget y realiza una
terminación limpia de la aplicación.
En PyQt, cualquier control puede ser utilizado como una ventana de
nivel superior. Declarar QDialog como una ventana de nivel superior,
todo lo que necesita es declarar que el padre de la clase MyForm
como None. Así que para el método __ init__() de nuestra clase
MyForm, se pasa un padre por defecto None para indicar que el
QDialog muestra a través de esta clase es una ventana de nivel
superior.
nota
Un widget que no tiene padre se convierte en una ventana de
nivel superior.
Recordemos que el diseño de la interfaz de usuario se crea una
instancia llamando al setupUI() de la clase que se creó en el código
Python (Ui_Dialog). Lo que necesita es crear una instancia de la
clase Ui_Dialog, la clase que se creó en el código Python, e invocar
su método setupUi(). El widget de diálogo se creará como el padre de
todos los elementos de interfaz de usuario y se muestra en la
pantalla.
nota
QDialog, QMainWindow, y todos PyQt de widgets se derivan de
Qwidget.
En la ejecución del script Python anteriormente, la aplicación
solicitará introducir texto en el widget Line Edit, como se muestra
en la figura 7.14.
Figure 7.14. Output of FirstApp application.
Cualquier texto en el widget Line Edit se borrará cuando se
selecciona el botón Borrar.
Enhorabuena por la creación y ejecución de su primera aplicación GUI
con éxito.
En esta aplicación, usted vio cómo conectar las señales integradas
con slots. ¿Qué pasa si usted quiere un método personalizado para
ejecutar una ocurrencia de un evento?

Using Custom Slots

Usando Slots personalizados