Trabajo Python - 3 Corte

Universidad de Pamplona
Villa del Rosario - Norte de Santander - Colombia

Tels: (7) 5685303 - 5685304 - 5685305 - Fax: 5682750 - www.unipamplona.edu.co
1Python
Ricardo Fuentes, Jessica Julio & Nayeli Sanabria.

Mayo 2020.
Universidad de Pamplona.
Facultad de ingenierías y arquitectura.
Programación l
Formando líderes para la construcción de un

1
nuevo país en paz
Abstract
Python es un lenguaje de scripting independiente de plataforma y orientado a objetos, preparado
para realizar cualquier tipo de programa, desde aplicaciones Windows a servidores de red o
incluso, páginas web. El creador del lenguaje es un europeo llamado Guido Van Rossum. El
desarrollo de Python duró varios años, durante los que trabajó en diversas compañías de Estados
Unidos. En el 2000 ya disponía de un producto bastante completo y un equipo de desarrollo con el
que se había asociado incluso en proyectos empresariales.
Una de las características de python es que da uso de un lenguaje interpretado, lo que significa que
no se necesita compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas como la
rapidez de desarrollo e inconvenientes como una menor velocidad.
En el presente trabajo se dan a conocer diferentes aspectos de python, para un correcto desarrollo a
la hora de trabajar el mismo, en un ámbito muy amplio, desde cosas básicas hasta la creación de
funciones haciendo uso de sentencias y bucles.

2
nuevo país en paz
Tabla de contenidos
Python.................................................................................................................................................6
1. ¿Qué es?..................................................................................................................................6
2. Historia de Python...................................................................................................................6
3. Características de Python 3.1 Propósito general....................................................................7
4. Empezar a utilizar Python.......................................................................................................8
......................................................................................................................................................13
11. Conversión.........................................................................................................................13
13.1 Operaciones comunes..........................................................................................................18
Operadores de cadenas de caracteres: adición y multiplicación..................................................20
Métodos para cadenas de caracteres: buscar, cambiar.................................................................21
15.2 Operador Resta..................................................................................................................25
15.3 Operador Negación............................................................................................................25
15.4 Operador Multiplicación...................................................................................................26
15.5 Operador Exponente..........................................................................................................26
15.6 Operador división...............................................................................................................26
15.8 Operador división entera...................................................................................................26
15.9 Operador Modulo...............................................................................................................27
15.10 Orden de precedencia......................................................................................................27
16.1 Operador and......................................................................................................................28
16.2 Operador or........................................................................................................................28
16.3 Operador not.......................................................................................................................29
18.1 Bucle ‘for’ con Listas.....................................................................................................30
Bucle ‘for’ con Listas y función ‘range’: A continuación, se presenta un ejemplo del uso del
bucle for con tipos de estructuras de datos listas con la función range() y la función len():...31
18.2 Bucle ‘for’ con Tuplas....................................................................................................31
18.3 Bucle ‘for’ con Diccionarios..........................................................................................31
18.4 Bucle ‘for’ con ‘else’.......................................................................................................32

3
nuevo país en paz
19.1 Bucle ‘while’ controlado por Conteo............................................................................33

19.2 Bucle ‘while’ controlado por Evento............................................................................34
19.3 Bucle ‘while’ con ‘else’...................................................................................................34
19.4 Sentencia break...............................................................................................................35
19.5 Sentencia continue..........................................................................................................36
La sentencia if EXPRESION, significa, Si se cumple la expresión condicional se ejecuta el
bloque de sentencias seguidas......................................................................................................37
21.1 Sentencia def.......................................................................................................................38
21.2 Argumentos y parámetros.................................................................................................41
21.2.2 Por nombre..................................................................................................................42
21.2.3 Por posición y nombre................................................................................................43
21.2.4 Llamada sin argumentos.............................................................................................43
21.2.5 Parámetros por defecto...............................................................................................44
Como puede ver el el código anterior, se indica el final de la función luego de la sentencia print,
usando la sentencia return aunque no devuelva nada. Argumentos indeterminados: En alguna
ocasión usted no sabe previamente cuantos elementos necesita enviar a una función. En estos
casos puede utilizar los parámetros indeterminados por posición y por nombre.........................44
21.3 Sentencia pass.....................................................................................................................44
21.4 Sentencia return.................................................................................................................45
21.4.1 Retorno múltiple..........................................................................................................46
22. Ejemplos de funciones.....................................................................................................47
Referencias bibliográficas................................................................................................................48

4
nuevo país en paz
Lista de ilustraciones
Ilustración 1. Ejemplo de comentarios en el programa python. (Tutorial python, 2016)................10

Ilustración 2. Definición de variables numéricas en python............................................................11
Ilustración 3. Definición de variables de texto en python. (Tutorial python, 2016)........................11
Ilustración 4. Definición de Print en python. (Tutorial python, 2016).............................................12
Ilustración 5. Tipo de datos utilizados en python. (crlpiban, 2017).................................................12
Ilustración 6. Ejemplo de declaración de variables en python.........................................................13
Ilustración 7. Ejemplo del operador lógico ‘in’. (Tutorial python, 2016)........................................29

5
nuevo país en paz
Python
1. ¿Qué es?
Python es un lenguaje de scripting independiente de plataforma y orientado a objetos,
preparado para realizar cualquier tipo de programa, desde aplicaciones Windows a servidores de
red o incluso, páginas web. Es un lenguaje interpretado, lo que significa que no se necesita
compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas como la rapidez de
desarrollo e inconvenientes como una menor velocidad.
2. Historia de Python
El creador del lenguaje es un europeo llamado Guido Van Rossum. Hace ya más de una
década que diseño Python, ayudado y motivado por su experiencia en la creación de otro lenguaje
llamado ABC. El objetivo de Guido era cubrir la necesidad de un lenguaje orientado a objetos de
sencillo uso que sirviese para tratar diversas tareas dentro de la programación que habitualmente se
hacía en Unix usando C.
El desarrollo de Python duró varios años, durante los que trabajó en diversas compañías de
Estados Unidos. En el 2000 ya disponía de un producto bastante completo y un equipo de
desarrollo con el que se había asociado incluso en proyectos empresariales. Actualmente trabaja en
Zope, una plataforma de gestión de contenidos y servidor de aplicaciones para el web, por
supuesto, programada por completo en Python.
3. Características de Python
3.1 Propósito general
Se pueden crear todo tipo de programas. No es un lenguaje creado específicamente para la
web, aunque entre sus posibilidades sí se encuentra el desarrollo de páginas.

6
nuevo país en paz
3.2 Multiplataforma
Hay versiones disponibles de Python en muchos sistemas informáticos distintos.
Originalmente se desarrolló para Unix, aunque cualquier sistema es compatible con el lenguaje
siempre y cuando exista un intérprete programado para él.
3.3 Interpretado
Quiere decir que no se debe compilar el código antes de su ejecución. En realidad sí que se
realiza una compilación, pero esta se realiza de manera transparente para el programador. En
ciertos casos, cuando se ejecuta por primera vez un código, se producen unos bytecodes que se
guardan en el sistema y que sirven para acelerar la compilación implícita que realiza el intérprete
cada vez que se ejecuta el mismo código.
3.4 Interactivo
Python dispone de un intérprete por línea de comandos en el que se pueden introducir
sentencias. Cada sentencia se ejecuta y produce un resultado visible, que puede ayudarnos a
entender mejor el lenguaje y probar los resultados de la ejecución de porciones de código
rápidamente.
3.5 Orientado a Objetos
La programación orientada a objetos está soportada en Python y ofrece en muchos casos
una manera sencilla de crear programas con componentes reutilizables.
3.6 Funciones y librerías
Dispone de muchas funciones incorporadas en el propio lenguaje, para el tratamiento de
strings, números, archivos, etc. Además, existen muchas librerías que podemos importar en los
programas para tratar temas específicos como la programación de ventanas o sistemas en red o
cosas tan interesantes como crear archivos comprimidos en .zip.

7
nuevo país en paz
3.7 Sintaxis clara
Por último, destacar que Python tiene una sintaxis muy visual, gracias a una notación
identada (con márgenes) de obligado cumplimiento. En muchos lenguajes, para separar porciones
de código, se utilizan elementos como las llaves o las palabras clave begin y end. Para separar las
porciones de código en Python se debe tabular hacia dentro, colocando un margen al código que
iría dentro de una función o un bucle. Esto ayuda a que todos los programadores adopten unas
mismas notaciones y que los programas de cualquier persona tengan un aspecto muy similar.
4. Empezar a utilizar Python
En Python existen dos versiones oficiales en mantenimiento, la versión 2 se seguirá
manteniendo durante unos cuantos años y se usa bastante debido a que hay mucho código que
depende de esta versión, la versión 3 salió hace unos cuantos años y es la actual rama de desarrollo
y la que va evolucionando por lo que es el presente y futuro de Python. Rompe la compatibilidad
con la versión 2 en algunas cosas pero hay formas de hacer código que sea compatible tanto con
Python 2 como con Python 3 sin excesivos problemas.
Si se parte de cero en el lenguaje, es recomendable empezar por Python 3. Si dependes de
código que no funciona en Python 3 es recomendable hacerlo funcionar en Python 3 porque
Python 2, más pronto que tarde, el tiempo pasa volando, se dejará de mantener y estarás listo para
ese momento.
5. Aplicación básica “hola mundo”
Un programa Hola Mundo es el que imprime el texto «¡Hola, Mundo!» en un dispositivo
de visualización, en la mayoría de los casos una pantalla de monitor. Este programa suele ser
usado como introducción al estudio de un lenguaje de programación, siendo un primer ejercicio
típico, y se lo considera fundamental desde el punto de vista didáctico.

8
nuevo país en paz
El Hola Mundo se caracteriza por su sencillez, especialmente cuando se ejecuta en una
interfaz de línea de comandos. En interfaces gráficas la creación de este programa requiere de más
pasos.
El programa Hola Mundo también puede ser útil como prueba de configuración para
asegurar que el compilador, el entorno de desarrollo y el entorno de ejecución estén instalados
correctamente y funcionando.
Programa ¡Hola, Mundo! en diversas versiones de Python:
Python 2.x:
print "Hola Mundo"
Python 3.x:
print("Hola Mundo");
6. Ejecución
Dependiendo del sistema operativo que esté usando debe realizar procedimientos distintos
para cada plataforma cuando usted quiere escribir y ejecutar un programa Python. Ejemplo:
6.1 Ejecución de un programa en Windows
Se debe crear un directorio llamado proyectos la unidad C:\ y dentro de este, crear un
archivo de texto plano con el siguiente nombre holamundo.py y escribir la sintaxis de Python
2 o Python 3 respectivamente.
Luego ejecute desde la consola de MS-DOS el siguiente comando:
C:\Python27\python C:\proyectos\holamundo.py
Se debe ver la línea Hola Mundo.
Y así se ejecuta un programa en Python.
7. Comentarios en python

9
nuevo país en paz
Los comentarios en Python, al igual que sucede en otros lenguajes de programación, sirven
para explicar a las personas que puedan leer el programa en el futuro, qué es lo que hace el
programa, así como explicar algunas partes del código. Estos comentarios son ignorados por las
computadoras cuando ejecutan el código.
En python los comentarios se pueden realizar de dos formas: Escribiendo el símbolo
almohadilla delante de la línea de texto donde está el comentario. Y escribiendo triple comilla
doble («»») al principio y al final del comentario (que puede ocupar más de una línea).
Ilustración 1. Ejemplo de comentarios en el programa python. [ CITATION Tut16 \l 9226 ]
8. Variables en python
Cada variable tiene que tener un nombre con el que referirnos a ella. Python tiene en cuenta
si escribimos en mayúsculas o minúsculas la variable (lo que se conoce como case sensitive). No
es lo mismo una variable que se llame f1 que una que se llame F1.
Como es lógico y, para evitar confusiones, el nombre de la variable no puede coincidir con
los nombres de los «comandos» de python (if, for, etc.). Tampoco podremos usar nombres de
variables con tildes o con ñ. Las variables más comunes en python son:
8.1 Número. En números hay dos tipos principales, los números enteros (llamados int) y
los reales (llamados float). El separador decimal que tenemos que usar es el punto. Si no decimos

10
nuevo país en paz
el tipo de número que se va a usar, Python intentará decidir por sí mismo cuál es el más apropiado
y esto en ocasiones puede producir errores.
Ilustración 2. Definición de variables numéricas en python.
8.2 Textos. Las variables que almacenan texto se denominan strings (str). Tienen que estar
entre comillas sencillas (‘) o dobles («), o si el texto ocupa varias líneas, entre triples comillas
dobles («»»).
Ilustración 3. Definición de variables de texto en python. [ CITATION Tut16 \l 9226 ]
Al igual que sucedía con los números, Python supone que lo que introducimos es un texto
al estar entre comillas, aunque siempre podemos forzarle a interpretarlo como texto usando el
comando str.
Para unir dos textos, basta con usar el operador +.

11
nuevo país en paz
8.3 Print. El comando print es de gran utilidad para que el programa pueda comunicarse
con el usuario. Este comando muestra el texto que se pone, o incluso el valor que hay dentro de
una variable.
En el caso de que se junten texto y números, se debe tomar la precaución de convertir los números
en texto, ya que si no, Python no sabe cómo se hace la suma de un texto y un número.
Ilustración 4. Definición de Print en python. [ CITATION Tut16 \l 9226 ]
9. Tipo de datos en python
Ilustración 5. Tipo de datos utilizados en python. [ CITATION crl17 \l 9226 ]

12
nuevo país en paz
10. Obtención del tipo de variable
Ilustración 6. Ejemplo de declaración de variables en python.
11. Conversión
Usar el operador + para juntar dos cadenas de texto puede ser muy útil a la hora de construir
mensajes.
Supóngase, por ejemplo, que has calculado el retorno de tu inversión y quieres resumir los
resultados en una cadena. Asumiendo que las variables flotantes savings y result están definidas,
puedes intentar algo como esto:
print ("Yo comencé con $" + savings + " y ahora tengo $" + result + ". ¡Impresionante!")
Sin embargo, esto no funcionará debido a que no puedes simplemente sumar variables de
tipo str con float.
Para arreglar este error, necesitarás convertir explícitamente los tipos de tus variables. Más
específicamente, necesitarás str() para convertir un valor en una cadena. Por ejemplo, str
(savings) convertirá el número flotante savings en una cadena.
Funciones similares como int(), float() y bool() te ayudarán a convertir valores de Python
en cualquier tipo.

13
nuevo país en paz
12. Colecciones de tipos de datos
Una colección permite agrupar varios objetos bajo un mismo nombre. Por ejemplo, si necesitamos
almacenar en nuestro programa los nombres de los alumnos de un curso de programación, será
más conveniente ubicarlos a todos dentro de una misma colección de nombre alumnos , en lugar
de crear los objetos alumno1 , alumno2 , etc. En Python existen tres colecciones básicas, a saber:
las listas, las tuplas y los diccionarios
12.1 Lista
Una lista es un conjunto ordenado de objetos. Por objetos entendemos cualquiera de los
tipos de dato ya mencionados, incluso otras listas. Para crear una lista, especificamos
sus elementos entre corchetes y separados por comas.
>>> lenguajes = ["Python", "Java", "C", "C++"]
Dado que se trata de una colección ordenada, accedemos a cada uno de los elementos a
partir de su posición, comenzando desde el 0.
0.
>>> lenguajes [0]
'Python'
>>> lenguajes [1]
'Java'
(En Python, las cadenas de caracteres pueden estar formadas tanto por comillas dobles
como por comillas simples). La posición de un elemento, también conocida como índice, aumenta
de izquierda a derecha cuando éste es positivo. Indicando un número negativo, los elementos se
obtienen de derecha a izquierda.

14
nuevo país en paz
>>> lenguajes [-1]
'C++'
>>> lenguajes [-2]
'C'
Para cambiar un elemento, combinamos la nomenclatura descrita con la asignación.
>>> lenguajes [1] = "Rust"
>>> lenguajes
['Python', 'Rust', 'C', 'C++']
Para remover un elemento, utilizamos la palabra reservada del .
>>> del lenguajes [1]
>>> lenguajes
['Python', 'C', 'C++']
Nótese que cuando un elemento es eliminado, a excepción del último, todos los que lo
suceden se corren una posición hacia la izquierda.
La operación inversa es la de insertar un elemento en una posición determinada,
desplazando el resto que le sucede una posición hacia la derecha, vía el método (volveremos sobre
este concepto más adelante) insert() .
# Insertar la cadena "Elixir" en la posición 1.
>>> lenguajes.insert(1, "Elixir")
>>> lenguajes
['Python', 'Elixir', 'C', 'C++']

15
nuevo país en paz
Por último, la operación más común es la de agregar un elemento al final de la lista. Para
ello empleamos append() .
>>> lenguajes.append("Haskell")
>>> lenguajes
['Python', 'Elixir', 'C', 'C++', 'Haskell']
12.2 Tuplas
Las tuplas, al igual que las listas, son colecciones ordenadas. No obstante, a diferencia de
éstas, son inmutables. Es decir, una vez asignados los elementos, no pueden ser alterados. En
términos funcionales, podría decirse que las tuplas son un subconjunto de las listas, por cuanto
soportan las operaciones con índices para acceder a sus elementos, pero no así las de asignación.
# Indicamos los elementos entre paréntesis.
>>> lenguajes = ("Python", "Java", "C", "C++")
>>> lenguajes [0]
'Python'
>>> lenguajes [-1]
'C++'
Un intento por remover un elemento de una tupla o asignarle un nuevo valor arrojará un
error. Ahora bien, si las listas hacen todo lo que hace una tupla, ¿para qué, entonces, existen las
tuplas? Sencillamente porque una tupla, justamente por carecer de todas las funcionalidades de
mutación de elementos, es un objeto más liviano y que se crea más rápido.

16
nuevo país en paz
La función del programador será la de dirimir si para una determinada colección ordenada
de objetos le conviene más una lista o una tupla, según sus elementos deban ser alterados en el
futuro o no.
13. Diccionarios
Los diccionarios, a diferencia de las listas y las tuplas, son colecciones no ordenadas de
objetos. Además, sus elementos tienen una particularidad: siempre conforman un par clave-valor.
Es decir, cuando añadimos un valor a un diccionario, se le asigna una clave única con la que luego
se podrá acceder a él (pues la posición ya no es un determinante).
Para crear un diccionario, indicamos los pares clave-valor separados por comas y estos, a
su vez, separados por dos puntos.
>>> d = {"Python": 1991, "C": 1972, "Java": 1996}
En este ejemplo, creamos un diccionario con tres elementos, cuyas claves
son "Python" , "C" y "Java" y sus valores los años en los que fueron creados, a
saber: 1991 , 1972 y 1996 , respectivamente.
Para acceder a cualquiera de los valores, debemos indicar su clave entre corchetes.
>>> d["Java"]
1996
Las operaciones de añadir, modificar o eliminar valores son similares a las de las listas.
# Añadir un par clave/valor.
>>> d["Elixir"] = 2011
# Modificar uno existente.

17
nuevo país en paz
>>> d["Python"] = 3000
# Eliminar.
>>> del d["C"]
>>> d
{'Python': 3000, 'Java': 1996, 'Elixir': 2011}
Las claves típicamente serán números o cadenas, aunque bien podrían ser de cualquier otro
tipo de dato inmutable (todos los vistos hasta ahora son inmutables, a excepción de las listas y los
diccionarios). Además, nunca puede haber claves repetidas, ya que actúan como identificadores
únicos para un valor determinado. Los valores, en cambio, pueden ser de cualquier tipo de dato,
¡incluyendo otros diccionarios!
13.1 Operaciones comunes
Hemos visto cómo del se aplica tanto a listas como a diccionarios. Existen varias
funciones que operan sobre distintos tipos de colecciones. Por ejemplo, la función
incorporada len() retorna el número de elementos en una colección.
>>> len ([1, 2, 3, 4])
>>> len({"Python": 1991, "C": 1972})
>>> len (("¡Hola, mundo!",))
En la tercera llamada pasamos como argumento una tupla que contiene un solo elemento
(una cadena). No obstante, dado que para definir tuplas se emplean paréntesis, es necesario añadir
18
nuevo país en paz
una coma al final para que Python entienda que se trata de una tupla en lugar de una expresión (los
paréntesis también son utilizados para agrupar expresiones, como en matemática).
Una cadena es, en rigor, una colección de caracteres. Por ello también soporta las
operaciones de acceso a sus elementos (¡no así las de asignación, ya que son inmutables!).
>>> s = "¡Hola, mundo!"
>>> s[4]
'a'
>>> len(s)
13
Por último, para saber si un elemento está dentro de una colección, empleamos la palabra
reservada in .
>>> 10 in (1, 2, 3, 4)
False
>>> "mundo" in "¡Hola, mundo!"
True
>>> "Python" in {"Python": 1991, "C": 1972}
True
14. Cadenas de caracteres en Python
Si has estado expuesto antes a otro lenguaje de programación, sabrás que
necesitas declarar o escribir variables antes de que puedas almacenar cualquier cosa en ellas. Esto

19
nuevo país en paz
no es necesario cuando trabajas con cadenas de caracteres en Python. Podemos crear una cadena
de caracteres simplemente encerrando contenido entre comillas después de un signo de igual (=).
mensaje = “Hola Mundo”
Operadores de cadenas de caracteres: adición y multiplicación
Una cadena de caracteres en un objeto que consiste precisamente en una serie de signos o
caracteres. Python sabe cómo tratar un número de representaciones poderosas y de propósito
general, incluidas las cadenas de caracteres. Una forma de manipular cadenas de caracteres es
utilizar operadores de cadenas de caracteres. Dichos operadores se representan con símbolos que
asociamos a las matemáticas, como +, -, *, / y =. Estos signos realizan acciones similares a sus
contrapartes matemáticas cuando se usan con las cadenas de caracteres, aunque no iguales.
14.1 Concatenar. Este término significa juntar cadenas de caracteres. El proceso
de concatenación se realiza mediante el operador de suma (+). Ten en cuenta que debes marcar
explícitamente dónde quieres los espacios en blanco y colocarlos entre comillas.
En este ejemplo, la cadena de caracteres “mensaje1” tiene el contenido “Hola Mundo”
mensaje1 = 'Hola' + ' ' + 'Mundo'
print(mensaje1)
-> Hola Mundo
14.2 Multiplicar. Si quieres varias copias de una cadena de caracteres utiliza el operador
de multiplicación (*). En este ejemplo, la cadena de caracteres mensaje2a lleva el contenido
“Hola” tres veces, mientras que la cadena de caracteres mensaje2b tiene el contenido “Mundo”.
Ordenemos imprimir las dos cadenas.
mensaje2a = 'Hola ' * 3
mensaje2b = 'Mundo'
20
nuevo país en paz
print (mensaje2a + mensaje2b)
-> Hola Hola Hola Mundo
14.3 Añadir. ¿Qué pasa si quieres añadir material de manera sucesiva al final de una
cadena de caracteres? El operador especial para ello es compuesto (+=).
mensaje3 = 'Hola'
mensaje3 += ' '
mensaje3 += 'Mundo'
print(mensaje3)
-> Hola Mundo
Métodos para cadenas de caracteres: buscar, cambiar
En adición a los operadores, Python trae preinstalado docenas de métodos que te permiten
hacer cosas con las cadenas de caracteres. Solos o en combinación, los métodos pueden hacer casi
todo lo que te imagines con las cadenas de caracteres. Puedes usar como referencia la lista de
métodos de cadenas de caracteres (String Methods) en el sitio web de Python, que incluye
información de cómo utilizar correctamente cada uno. Para asegurar que tengas una comprensión
básica de métodos para cadenas de caracteres, lo que sigue es una breve descripción de los
utilizados más comúnmente.
14.4 Extensión. Puedes determinar el número de caracteres en una cadena utilizando el
método len. Acuérdate que los espacios en blanco cuentan como un carácter.
mensaje4 = 'hola' + ' ' + 'mundo'
print(len(mensaje4))
-> 10

21
nuevo país en paz
14.5 Encontrar. Puedes buscar una sub-cadena en una cadena de caracteres utilizando el
método find y tu programa te indicará el índice de inicio de la misma. Esto es muy útil para
procesos que veremos más adelante. Ten en mente que los índices están numerados de izquierda a
derecha y que el número en el que se comienza a contar la posición es el 0, no el 1.
mensaje5 = "Hola Mundo"
mensaje5a = mensaje5.find("Mundo")
print(mensaje5a)
-> 5
Si la sub-cadena no está presente el programa imprimirá el valor -1.
mensaje6a = mensaje6.find("ardilla")
print(mensaje6a)
-> -1
14.6 Minúsculas. A veces es útil convertir una cadena de caracteres a minúsculas. Para
ello se utiliza el método lower. Por ejemplo, al uniformar los caracteres permitimos que la
computadora reconozca fácilmente que “Algunas Veces” y “algunas veces” son la misma frase.
mensaje7 = "HOLA MUNDO"
mensaje7a = mensaje7.lower()
print(mensaje7a)
-> hola mundo
Convertir las minúsculas en mayúsculas se logra cambiando. lower () por upper ().
14.7 Reemplazar. Si necesitas cambiar una sub-cadena de una cadena se puede utilizar el
método replace.
mensaje8 = "HOLA MUNDO"

22
nuevo país en paz
mensaje8a = mensaje7.replace("L", "pizza")
print(mensaje8a)
-> HOpizzaA MUNDO
14.8 Cortar. Si quieres cortar partes que no quieras del principio o del final de la cadena
de caracteres, lo puedes hacer creando una sub-cadena. El mismo tipo de técnica te permite separar
una cadena muy larga en componentes más manejables.
mensaje9a = mensaje9[1:8]
print(mensaje9a)
-> ola Mun
Puedes sustituir las variables por números enteros como en este ejemplo:
startLoc = 2
endLoc = 8
mensaje9b = mensaje9[startLoc: endLoc]
print(mensaje9b)
-> la MunEsto hace mucho más simple usar este método en conjunción con el método find como
en el
Próximo ejemplo, que busca la letra “d” en los seis primeros caracteres de “Hola Mundo” y
correctamente nos dice que no se encuentra ahí (-1). Esta técnica es mucho más eficaz en cadenas
largas -documentos enteros, por ejemplo. Observa que la ausencia de un número entero antes de
los dos puntos significa que queremos empezar desde el principio de la cadena. Podemos usar la
misma técnica para decirle al programa que pase hasta el final de la cadena de caracteres dejando

23
nuevo país en paz
vacío después de los dos puntos. Y recuerda que la posición del índice empieza a contar desde 0,
no desde 1.
print(mensaje9[:5].find("d"))
-> -1
Hay muchos más, pero los métodos para cadenas de caracteres anteriores son un buen
comienzo. Fíjate que en el ejemplo anterior utilizamos corchetes en vez de paréntesis. Esta
diferencia en los símbolos de la sintaxis es muy importante. Los paréntesis en Python son
utilizados generalmente para llevar un argumento a una función. De tal manera que cuando vemos
algo como:
print(len(mensaje7))
Quiere decir que se lleva la cadena de caracteres “mensaje7” a la función len y entonces
enviar el valor resultante de esa función a la declaración print para ser impresa. Una función puede
ser llamada sin un argumento, pero de todas formas tienes que incluir un par de paréntesis vacíos
después del nombre de la función. Vimos un ejemplo de ello también.
mensaje7a = mensaje7.lower()
print(mensaje7a)
-> Hola Mundo
Esta declaración le dice a Python que aplique la función lower a la cadena mensaje7 y
guarde el valor resultante en la cadena mensaje7a.
Los corchetes sirven para propósitos diferentes. La cadena es una secuencia de caracteres;
así que si quieres acceder al contenido de la cadena a partir de su posición en la secuencia, tienes
24
nuevo país en paz
que indicarle a Python un lugar en la secuencia. Eso es lo que hacen los corchetes: señalan el lugar
del principio y del final de la secuencia, tal y como vimos en el método cortar.
15. Operadores aritméticos
Los valores numéricos son además el resultado de una serie de operadores aritméticos y
matemáticos:
15.1 Operador Suma
El operador + suma los valores de tipo de datos numéricos.
>>> 3 + 2
15.2 Operador Resta
El operador - resta los valores de tipo de datos numéricos.
>>> 4 - 7
-3
15.3 Operador Negación
El operador - asigna un valor negativo a un tipo de datos numéricos.
>>> -7
-7
15.4 Operador Multiplicación
El operador * multiplica los valores de tipo de datos numéricos.
>>> 2 * 6
12
15.5 Operador Exponente
El operador ** calcula el exponente entre valores de tipo de datos numéricos.
>>> 2 ** 6
25
nuevo país en paz
64
15.6 Operador división
El operador división el resultado que se devuelve es un número real.
>>> 3.5 / 2
1.75
15.8 Operador división entera
El operador división entera el resultado que se devuelve es solo la parte entera.
>>> 3.5 // 22
1.0
No obstante, hay que tener en cuenta que, si utilizamos dos operandos enteros, Python determinará
que quiere que la variable resultado también sea un entero, por lo que el resultado de, por
ejemplo, 3 / 2 y 3 // 2 sería el mismo: 1.
Si quisiéramos obtener los decimales necesitaríamos que al menos uno de los operandos fuera un
número real, bien indicando los decimales:
r = 3.0 / 2
O bien utilizando la función float() para convertir a entero coma flotante o real:
r = float (3) / 2
Esto es así porque cuando se mezclan tipos de números, Python convierte todos los operandos al
tipo más complejo de entre los tipos de los operandos.
15.9 Operador Modulo
El operador módulo no hace otra cosa que devolver el resto de la división entre los dos operandos.
En el ejemplo, 7 / 2 sería 3, con 1 de resto, luego el módulo es 1.
>>> 7 % 2
1
26
nuevo país en paz
15.10 Orden de precedencia
El orden de precedencia de ejecución de los operadores aritméticos es:
Exponente: **
Negación: -
Multiplicación, División, División entera, Módulo: *, /, //, %
Suma, Resta: +, -
Eso quiere decir que se debe usar así:
>>> 2**1/12
0.16666666666666666
>>>
Más igualmente usted puede omitir este orden de precedencia de ejecución de los operadores
aritméticos usando paréntesis () anidados entre cada nivel calculo, por ejemplo:
>>> 2**(1/12)
1.0594630943592953
>>>
16. Operadores lógicos
Estos son los distintos tipos de operadores con los que puede trabajar con valores booleanos, los
llamados operadores lógicos o condicionales:
16.1 Operador and
El operador and evalúa si el valor del lado izquierdo y el lado derecho se cumple.
>>> True and False
False
Ejemplo de operador lógico and:
if (a and b):
27
nuevo país en paz
print "Las variables 'a' y 'b' son VERDADERO."
else:
print "O bien la variable 'a' no es VERDADERO " + \
"o la variable 'b' no es VERDADERO."
16.2 Operador or
El operador or evalúa si el valor del lado izquierdo o el lado derecho se cumple.
>>> True or False
True
Ejemplo de operador lógico or:
if (a or b):
print "O bien la variable 'a' es VERDADERA " + \
"o la variable 'b' es VERDADERA " + \
"o ambas variables son VERDADERAS."
else:
print "Ni la variable 'a' es VERDADERA ni " + \
"la variable 'b' es VERDADERA."
16.3 Operador not
El operador not devuelve el valor opuesto el valor booleano.
>>> not True
False
Si la expresión es True el valor devuelto es False, de lo contrario si la expresión es False el valor
devuelto es True.
>>> not False
True
28
nuevo país en paz
Ejemplo de operador lógico not:
if not (a and b):
print "Ni la variable 'a' NO es VERDADERA " + \
"o la variable 'b' NO es VERDADERA."
else:
print "Las variables 'a' y 'b' son VERDADERAS."
17. Operador ‘in’
Aprovechando que nos hemos dado de bruces con los booleanos, vamos a explicar un
elemento más de Python: la propiedad IN. Es importante advertir que nos estamos refiriendo
a in como tal, en solitario, y no asociada al iterador FOR (FOR/IN), que estudiaremos cuando
hayamos concluido con los principales tipos de datos de Python, y cuyo significado particular,
como no puede ser de otra manera, es el mismo en ambos casos: 'en'.
IN se apoya en el tipo de dato booleano y nos resultará muy útil cuando, por ejemplo, estemos
haciendo un listado "generoso" de ítems y no sepamos si hemos incluido en él un ítem concreto.
Al usar in en una expresión referida a una variable que almacene una colección de datos, como
una string, por ejemplo, que almacena una colección de caracteres literales, nos devolverá True si
encuentra lo que le hemos pedido buscar, o False en caso de no encontrarlo. Su sintaxis es muy
sencilla: ítem in nombre_de_la_variable.
He aquí un ejemplo de uso:

29
nuevo país en paz
Ilustración 7. Ejemplo del operador lógico ‘in’. [ CITATION Tut16 \l 9226 ]
18. Bucle for en python.
La sentencia for en Python difiere un poco de lo que uno puede estar acostumbrado en
lenguajes como C o Pascal. En lugar de siempre iterar sobre una progresión aritmética de números
(como en Pascal) o darle al usuario la posibilidad de definir tanto el paso de la iteración como la
condición de fin (como en C), la sentencia for de Python itera sobre los ítems de cualquier
secuencia (una lista o una cadenas de caracteres), en el orden que aparecen en la secuencia. A
continuación, se presentan algunos ejemplos del uso del bucle for:
18.1 Bucle ‘for’ con Listas
A continuación, se presenta un ejemplo del uso del bucle for con tipos de estructuras de
datos listas:
animales = ['gato', 'perro', 'serpiente']
for animal in animales:
print "El animal es: {0}, tamaño de palabra es: {1}".format(
animal, len(animal))
Bucle ‘for’ con Listas y función ‘range’: A continuación, se presenta un ejemplo del uso del
bucle for con tipos de estructuras de datos listas con la función range() y la función len():
oración = 'Mary entiende muy bien Python'

30
nuevo país en paz
frases = oracion.split() # convierte a una lista cada palabra
print "La oración analizada es:", oración, ".\n"
for palabra in range(len(frases)):
print "Palabra: {0}, en la frase su posición es: {1}".format(
frases[palabra], palabra)
Si se necesita iterar sobre una secuencia de números. Genera una lista conteniendo progresiones
aritméticas, por ejemplo, como se hace en el fragmento de código fuente anterior.
18.2 Bucle ‘for’ con Tuplas
datos Tuplas:
conexion_bd = "127.0.0.1","root","123456","nomina"
for parametro in conexion_bd:
print parámetro
El ejemplo anterior itera una tupla de parámetros.
18.3 Bucle ‘for’ con Diccionarios
datos diccionarios:
datos básicos = {
"nombres":"Leonardo Jose",
"apellidos":"Caballero Garcia",
"cedula":"26938401",
"fecha_nacimiento":"03/12/1980",
"lugar_nacimiento":"Maracaibo, Zulia, Venezuela",
"nacionalidad":"Venezolana",
31
nuevo país en paz
"estado_civil":"Soltero"
clave = datos_basicos. keys ()
valor = datos_basicos.values()
cantidad_datos = datos_basicos.items()
for clave, valor in cantidad_datos:
print clave + ": " + valor
El ejemplo anterior itera un diccionario con datos básicos de una persona.
18.4 Bucle ‘for’ con ‘else’
Al igual que la sentencia if y el bucle while, la estructura for también puede combinarse con una
sentencia else.
El nombre de la sentencia else es equivocada, ya que el bloque else se ejecutará en todos los casos,
es decir, cuando la expresión condicional del bucle for sea False, (a comparación de la sentencia
if).
db_connection = "127.0.0.1","5432","root","nomina"
for parametro in db_connection:
print parámetro
else:
print """El comando PostgreSQL es:
$ psql -h {server} -p {port} -U {user} -d {db_name}""".format(
server=db_connection[0], port=db_connection[1],
user=db_connection[2], db_name=db_connection[3])

32
nuevo país en paz
La sentencia else tiene la ventaja de mantener el mismo nombre y la misma sintaxis que en las
demás estructuras de control.
19. Bucle while
En Python tiene una palabra reservada llamada while que nos permite ejecutar ciclos, o
bien secuencias periódicas que nos permiten ejecutar código múltiples veces.
El ciclo while nos permite realizar múltiples iteraciones basándonos en el resultado de una
expresión lógica que puede tener como resultado un valor True o False. A continuación, se
presentan algunos ejemplos del uso del bucle while:
19.1 Bucle ‘while’ controlado por Conteo
A continuación, se presenta un ejemplo del uso del bucle while controlado por conteo:
suma, numero = 0, 1
while numero <= 10:
suma = numero + suma
numero = numero + 1
print "La suma es " + str(suma)
En este ejemplo tiene un contador con un valor inicial de cero, cada iteración del while manipula
esta variable de manera que incremente su valor en 1, por lo que después de su primera iteración el
contador tendrá un valor de 1, luego 2, y así sucesivamente.
Eventualmente cuando el contador llegue a tener un valor de 10, la condición del
ciclo numero <= 10 será False, por lo que el ciclo terminará arrojando el siguiente resultado.
19.2 Bucle ‘while’ controlado por Evento
A continuación, se presenta un ejemplo del uso del bucle while controlado por Evento:
promedio, total, contar = 0.0, 0, 0

33
nuevo país en paz
print "Introduzca la nota de un estudiante (-1 para salir): "
grado = int (raw input ())
while grado! = -1:
total = total + grado
contar = contar + 1
print "Introduzca la nota de un estudiante (-1 para salir): "
grado = int(raw_input())
promedio = total / contar
print "Promedio de notas del grado escolar es: " + str(promedio)
En este casi el evento que se dispara cuando el usuario ingresa el valor -1, causando que el
bucle while se interrumpo o no se inicie.
19.3 Bucle ‘while’ con ‘else’
Al igual que la sentencia if, la estructura while también puede combinarse con una sentencia else).
El nombre de la sentencia else es equivocada, ya que el bloque else se ejecutará en todos los casos,
es decir, cuando la expresión condicional del while sea False, (a comparación de la sentencia if).
promedio, total, contar = 0.0, 0, 0
mensaje = "Introduzca la nota de un estudiante (-1 para salir): "
grado = int (raw input(mensaje))
while grado! = -1:
total = total + grado
contar += 1
grado = int(raw input(mensaje))

34
nuevo país en paz
else:
promedio = total / contar
print "Promedio de notas del grado escolar: " + str(promedio)
La sentencia else tiene la ventaja de mantener el mismo nombre y la misma sintaxis que en las
demás estructuras de control.
19.4 Sentencia break
A continuación, se presenta un ejemplo del uso del bucle while controlado la sentencia break:
variable = 10
while variable > 0:
print 'Actual valor de variable:', variable
variable = variable -1
if variable == 5:
break
Adicionalmente existe una forma alternativa de interrumpir o cortar los ciclos utilizando la palabra
reservada break.
Esta nos permite salir del ciclo incluso si la expresión evaluada en while (o en otro ciclo como for)
permanece siendo True. Para comprender mejor use el mismo ejemplo anterior pero se interrumpe
el ciclo usando la sentencia break.
19.5 Sentencia continue
A continuación, se presenta un ejemplo del uso del bucle while controlado la sentencia continue:
variable = 10
while variable > 0:

35
nuevo país en paz
variable = variable -1
if variable == 5:
continue
print 'Actual valor de variable:', variable
La sentencia continue hace que pase de nuevo al principio del bucle aunque no se haya terminado
de ejecutar el ciclo anterior. Ejemplos
Sucesión de Fibonacci
Ejemplo de la Sucesión de Fibonacci con bucle while:
a, b = 0, 1
while b < 100:
print b,
a, b = b, a + b
20. Condicional if
La sentencia condicional if se usa para tomar decisiones, este evaluá básicamente una
operación lógica, es decir una expresión que de como resultado True o False, y ejecuta la pieza de
código siguiente siempre y cuando el resultado sea verdadero.
A continuación, un de estructura condicional if/elif/else completo:
numero = int (raw_input("\nIngresa un número entero, por favor: "))
if numero < 0:
numero = 0
print 'El número ingresado es negativo cambiado a cero.\n'
elif numero == 0:
print 'El número ingresado es 0.\n'

36
nuevo país en paz
elif numero == 1:
print 'El número ingresado es 1.\n'
else:
print 'El número ingresado es mayor que uno.\n'
En el ejemplo anterior usa dos funciones integradas en el intérprete Python:
 La función int() que convierte el valor ingresado a número entero.
 La función raw_input() lee el valor ingresado por la entrada estándar.
El valor es ingresado en la variable numero comprobará en la sentencia condicional if, si la
comprobación devuelve False intentará con el siguiente bloque condicional elif, si la
comprobación devuelve False nuevamente intentará con el siguiente bloque condicional elif si de
nuevo la comprobación devuelve False por ultimo intentará con el siguiente bloque
condicional else la cual se ejecutara sin comprobación.
La sentencia if EXPRESION, significa, Si se cumple la expresión condicional se ejecuta el bloque
de sentencias seguidas.
La sentencia elif EXPRESION, significa, De lo contrario Si se cumple la expresión
condicional se ejecuta el bloque de sentencias seguidas.
La sentencia else, significa, De lo contrario se cumple sin evaluar ninguna expresión
condicional y ejecuta el bloque de sentencias seguidas.
21. Funciones
Una función es un bloque de código con un nombre asociado, que recibe cero o más
argumentos como entrada, sigue una secuencia de sentencias, la cuales ejecuta una operación
deseada y devuelve un valor y/o realiza una tarea, este bloque puede ser llamado cuando se
necesite.

37
nuevo país en paz
El uso de funciones es un componente muy importante del paradigma de la programación
llamada estructurada, y tiene varias ventajas:
 modularización: permite segmentar un programa complejo en una serie de partes o
módulos más simples, facilitando así la programación y el depurado.
 reutilización: permite reutilizar una misma función en distintos programas.
Python dispone de una serie de funciones integradas al lenguaje, y también permite crear
funciones definidas por el usuario para ser usadas en su propio programa.
21.1 Sentencia def
La sentencia def es una definición de función usada para crear objetos funciones definidas
por el usuario.
Una definición de función es una sentencia ejecutable. Su ejecución enlaza el nombre de la
función en el namespace local actual a un objecto función (un envoltorio alrededor del código
ejecutable para la función). Este objeto función contiene una referencia al namespace local global
como el namespace global para ser usado cuando la función es llamada.
La definición de función no ejecuta el cuerpo de la función; esto es ejecutado solamente
cuando la función es llamada.
La sintaxis para una definición de función en Python es:
def NOMBRE(LISTA_DE_PARAMETROS):
"""DOCSTRING_DE_FUNCION"""
SENTENCIAS
RETURN [EXPRESION]
A continuación, se detallan el significado de pseudo código fuente anterior:
 NOMBRE, es el nombre de la función.
 LISTA_DE_PARAMETROS, es la lista de parámetros que puede recibir una función.

38
nuevo país en paz
 DOCSTRING_DE_FUNCION, es la cadena de caracteres usada para documentar la
función.
 SENTENCIAS, es el bloque de sentencias en código fuente Python que realizar cierta
operación dada.
 RETURN, es la sentencia return en código Python.
 EXPRESION, es la expresión o variable que devuelve la sentencia return.
Un ejemplo simple de función esta seguidamente:
>>> def hola(arg):
... """El docstring de la función"""
... print "Hola", arg, "!"
...
>>> hola("Plone")
¡Hola Plone!
La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la
función en el ejemplo anterior hola() y la lista de parámetros formales entre paréntesis. Las
sentencias que forman el cuerpo de la función empiezan en la línea siguiente, y deben estar
indentado.
La primera sentencia del cuerpo de la función puede ser opcionalmente una cadena de
caracteres literal; esta es la cadenas de caracteres de documentación de la función, o docstrings.
(Puedes encontrar más acerca de docstrings en la sección Cadenas de texto de documentación).
Hay herramientas que usan las docstrings para producir automáticamente documentación
en línea o imprimible, o para permitirle al usuario que navegue el código en forma interactiva; es
una buena práctica incluir docstrings en el código que uno escribe, por lo que se debe hacer un
hábito de esto.
39
nuevo país en paz
¡La ejecución de la función hola () muestra la impresión de un mensaje Hola Plone! que se
imprime por consola. Devolver el objeto por los valores de retorno opcionales.
La ejecución de una función introduce una nueva tabla de símbolos usada para las variables
locales de la función. Más precisamente, todas las asignaciones de variables en la función
almacenan el valor en la tabla de símbolos local; así mismo la referencia a variables primero mira
la tabla de símbolos local, luego en la tabla de símbolos local de las funciones externas, luego la
tabla de símbolos global, y finalmente la tabla de nombres predefinidos. Así, no se les puede
asignar directamente un valor a las variables globales dentro de una función (a menos se las
nombre en la sentencia global), aunque si pueden ser referenciadas.
Los parámetros reales (argumentos) de una función se introducen en la tabla de símbolos
local de la función llamada cuando esta es ejecutada; así, los argumentos son pasados por valor
(dónde el valor es siempre una referencia a un objeto, no el valor del objeto). Cuando una función
llama a otra función, una nueva tabla de símbolos local es creada para esa llamada.
La definición de una función introduce el nombre de la función en la tabla de símbolos
actual. El valor del nombre de la función tiene un tipo que es reconocido por el interprete como
una función definida por el usuario. Este valor puede ser asignado a otro nombre que luego puede
ser usado como una función. Esto sirve como un mecanismo general para renombrar.
21.2 Argumentos y parámetros
Al definir una función los valores los cuales se reciben se denominan parámetros, pero durante la
llamada los valores que se envían se denominan argumentos.
21.2.1 Por posición
Cuando enviá argumentos a una función, estos se reciben por orden en los parámetros definidos.
Se dice por tanto que son argumentos por posición:
>>> def resta(a, b):

40
nuevo país en paz
... return a - b
...
>>> resta (30, 10)
20
En el ejemplo anterior el argumento 30 es la posición 0 por consiguiente es el parámetro de la
función a, seguidamente el argumento 10 es la posición 1 por consiguiente es el parámetro de la
función b.
Usted debe crear una lista dinámica de argumentos, es decir, un tipo tupla, definiendo el parámetro
con un asterisco, para recibir los parámetros indeterminados por posición:
>>> def indeterminados_posicion(*args):
... for arg in args:
... print arg
...
>>> indeterminados_posicion(5,"Hola Plone",[1,2,3,4,5])
Hola Plone
[1, 2, 3, 4, 5]
21.2.2 Por nombre
Sin embargo es posible evadir el orden de los parámetros si indica durante la llamada que valor
tiene cada parámetro a partir de su nombre:
>>> def resta (a, b):
... return a - b
...
41
nuevo país en paz
>>> (b=30, a=10)
-20
Para recibir un número indeterminado de parámetros por nombre (clave-valor o en inglés keyword
args), usted debe crear un diccionario dinámico de argumentos definiendo el parámetro con dos
asteriscos:
>>> def indeterminados_nombre(**kwargs):
... print kwargs
...
>>> indeterminados_nombre(n=5, c="Hola Plone", l=[1,2,3,4,5])
{'c': 'Hola Plone', 'l': [1, 2, 3, 4, 5], 'n': 5}
Al recibirse como un diccionario, puede iterarlo y mostrar la clave y valor de cada argumento:
>>> def indeterminados_nombre(**kwargs):
... for kwarg in kwargs:
... print kwarg, "=>", kwargs[kwarg]
...
>>> indeterminados_nombre(n=5, c="Hola Plone", l=[1,2,3,4,5])
c => Hola Plone
l => [1, 2, 3, 4, 5]
n => 5
21.2.3 Por posición y nombre
Si requiere aceptar ambos tipos de parámetros simultáneamente en una función, entonces debe
crear ambas colecciones dinámicas. Primero los argumentos indeterminados por valor y luego los
cuales son por clave y valor:

42
nuevo país en paz
>>> def super_funcion(*args,**kwargs):
... total = 0
... for arg in args:
... total += arg
... print "sumatorio => ", total
... for kwarg in kwargs:
... print kwarg, "=>", kwargs[kwarg]
...
>>> super_funcion (50, -1, 1.56, 10, 20, 300, cms="Plone", edad=38)
sumatorio => 380.56
edad => 38
cms => Plone
Los nombres args y kwargs no son obligatorios, pero se suelen utilizar por convención.
Muchos frameworks y librerías los utilizan por lo que es una buena práctica llamarlos así.
21.2.4 Llamada sin argumentos
Al momento de llamar una función la cual tiene definidos unos parámetros, si no pasa los
argumentos correctamente provocará una excepción TypeError:
>>> resta()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: resta () takes exactly 2 arguments (0 given)
21.2.5 Parámetros por defecto

43
nuevo país en paz
Para solucionar la excepción TypeError ejecutada al momento de la llamada a una función sin
argumentos, entonces usted puede asignar unos valores por defecto nulos a los parámetros, de esa
forma puede hacer una comprobación antes de ejecutar el código de la función:
>>> def resta (a=None, b=None):
... if a == None or b == None:
... print "Error, debes enviar dos números a la función"
... return
... return a - b
...
>>> resta(30, 10)
20
>>> resta ()
Error, debes enviar dos números a la función
Como puede ver el el código anterior, se indica el final de la función luego de la sentencia print,
usando la sentencia return aunque no devuelva nada. Argumentos indeterminados: En alguna
ocasión usted no sabe previamente cuantos elementos necesita enviar a una función. En estos
casos puede utilizar los parámetros indeterminados por posición y por nombre.
21.3 Sentencia pass
Es una operación nula — cuando es ejecutada, nada sucede. Eso es útil como un contenedor
cuando una sentencia es requerida sintácticamente, pero no necesita código que ser ejecutado, por
ejemplo:
>>> # una función que no hace nada (aun)
... def consultar_nombre_genero(letra_genero): pass
...
44
nuevo país en paz
>>> type(consultar_nombre_genero)
<type 'function'>
>>> consultar_nombre_genero("M")
>>>
>>> # una clase sin ningún método (aun)
... class Persona: pass
...
>>> macagua = Persona
>>> type(macagua)
<type 'classobj'>
21.4 Sentencia return
Las funciones pueden comunicarse con el exterior de las mismas, al proceso principal del
programa usando la sentencia return. El proceso de comunicación con el exterior se
hace devolviendo valores. A continuación, un ejemplo de función usando return:
def suma(numero1,numero2):
'''función la cual suma dos números'''
print numero1 + numero2
print "\n"
Esta función se llama de la siguiente forma:
>>> suma(23,74)
97
Nota
Por defecto, las funciones retorna el valor None.
21.4.1 Retorno múltiple

45
nuevo país en paz
Una característica interesante, es la posibilidad de devolver valores múltiples separados por
comas:
>>> def prueba():
... return "Plone CMS", 20, [1,2,3]
...
>>> prueba()
('Plone CMS', 20, [1, 2, 3])
En el código anterior los valores múltiples se tratan en conjunto como una tupla inmutable y se
pueden reasignar a distintas variables:
>>> def prueba():
... return "Plone CMS", 20, [1,2,3]
...
>>> prueba()
('Plone CMS', 20, [1, 2, 3])
>>> cadena, numero, lista = prueba()
>>> print cadena, type(cadena)
Plone CMS <type 'str'>
>>> print numero, type(numero)
20 <type 'int'>
>>> print lista, type(lista)
[1, 2, 3] <type 'list'>
En el código anterior puede observar cómo se asignar a distintas variables en base a los valores de
la tupla inmutable.
22. Ejemplos de funciones

46
nuevo país en paz
A continuación, se presentan algunos ejemplos de su uso:
22.1 Definición de funciones
A continuación, se presenta un ejemplo del uso de definir funciones:
def iva():
'''función básica para el calculo del IVA'''
iva = 12
costo = input ('¿Cuál es el monto a calcular?: ')
calculo = costo * iva / 100
print "El cálculo de IVA es: " + str(calculo) + "\n"
22.3 Invocar funciones
A continuación, se presenta un ejemplo del uso de llamar funciones:
>>> iva ()
¿Cuál es el monto a calcular?: 300
36
22.4 Funciones con argumentos múltiple
A continuación, se presenta un ejemplo del uso de funciones con argumentos múltiple:
def suma(numero1, numero2):
'''función la cual suma dos números'''
print numero1 + numero2
print "\n"
Y se llama de la siguiente forma:
>>> suma (23,74)
97

47
nuevo país en paz
Referencias bibliográficas
0.7.1, S. 1. (2014 - 2018). covantec. Obtenido de covantec: https://entrenamiento-python-
basico.readthedocs.io/es/latest/leccion5/funciones.html
crlpiban. (7 de diciembre de 2017). Obtenido de crlpiban:

https://crlpiban.wordpress.com/2017/12/07/python-tipos-de-datos/
desarrolloweb. (19 de noviembre de 2003). Obtenido de desarrolloweb:

https://desarrolloweb.com/articulos/1325.php
pybonacci.org. (11 de octubre de 2014). Obtenido de pybonacci.org:

https://pybonacci.org/2014/11/11/quieres-empezar-con-python/
turorial de python . (2013 - 2019). Obtenido de tutorial de python:

https://tutorial.recursospython.com/colecciones/
Tutorial python. (2016). Obtenido de Tutorial python: https://www.tutorialpython.com/variables-

en-python/

48
nuevo país en paz

Trabajo Python - 3 Corte

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Trabajo Python - 3 Corte

Cargado por

Copyright:

Formatos disponibles

Universidad de Pamplona

Villa del Rosario - Norte de Santander - Colombia

Ricardo Fuentes, Jessica Julio & Nayeli Sanabria.

Formando líderes para la construcción de un

Python es un lenguaje de scripting independiente de plataforma y orientado a objetos, preparado

Unidos. En el 2000 ya disponía de un producto bastante completo y un equipo de desarrollo con el

que se había asociado incluso en proyectos empresariales.

rapidez de desarrollo e inconvenientes como una menor velocidad.

funciones haciendo uso de sentencias y bucles.

Formando líderes para la construcción de un

Formando líderes para la construcción de un

19.1 Bucle ‘while’ controlado por Conteo............................................................................33

Formando líderes para la construcción de un

Ilustración 1. Ejemplo de comentarios en el programa python. (Tutorial python, 2016)................10

Formando líderes para la construcción de un

Python es un lenguaje de scripting independiente de plataforma y orientado a objetos,

desarrollo e inconvenientes como una menor velocidad.

hacía en Unix usando C.

Estados Unidos. En el 2000 ya disponía de un producto bastante completo y un equipo de

supuesto, programada por completo en Python.

3.1 Propósito general

Se pueden crear todo tipo de programas. No es un lenguaje creado específicamente para la

web, aunque entre sus posibilidades sí se encuentra el desarrollo de páginas.

Formando líderes para la construcción de un

Hay versiones disponibles de Python en muchos sistemas informáticos distintos.

siempre y cuando exista un intérprete programado para él.

cada vez que se ejecuta el mismo código.

Python dispone de un intérprete por línea de comandos en el que se pueden introducir

entender mejor el lenguaje y probar los resultados de la ejecución de porciones de código

3.5 Orientado a Objetos

La programación orientada a objetos está soportada en Python y ofrece en muchos casos

una manera sencilla de crear programas con componentes reutilizables.

3.6 Funciones y librerías

Dispone de muchas funciones incorporadas en el propio lenguaje, para el tratamiento de

cosas tan interesantes como crear archivos comprimidos en .zip.

Formando líderes para la construcción de un

3.7 Sintaxis clara

4. Empezar a utilizar Python

En Python existen dos versiones oficiales en mantenimiento, la versión 2 se seguirá

y la que va evolucionando por lo que es el presente y futuro de Python. Rompe la compatibilidad

Python 2 como con Python 3 sin excesivos problemas.

Si se parte de cero en el lenguaje, es recomendable empezar por Python 3. Si dependes de

código que no funciona en Python 3 es recomendable hacerlo funcionar en Python 3 porque

5. Aplicación básica “hola mundo”

Un programa Hola Mundo es el que imprime el texto «¡Hola, Mundo!» en un dispositivo

usado como introducción al estudio de un lenguaje de programación, siendo un primer ejercicio

típico, y se lo considera fundamental desde el punto de vista didáctico.

Formando líderes para la construcción de un

El Hola Mundo se caracteriza por su sencillez, especialmente cuando se ejecuta en una

El programa Hola Mundo también puede ser útil como prueba de configuración para

asegurar que el compilador, el entorno de desarrollo y el entorno de ejecución estén instalados

Programa ¡Hola, Mundo! en diversas versiones de Python:

print "Hola Mundo"

6.1 Ejecución de un programa en Windows

Se debe crear un directorio llamado proyectos la unidad C:\ y dentro de este, crear un

archivo de texto plano con el siguiente nombre holamundo.py y escribir la sintaxis de Python

Luego ejecute desde la consola de MS-DOS el siguiente comando:

Se debe ver la línea Hola Mundo.

Y así se ejecuta un programa en Python.

Formando líderes para la construcción de un

computadoras cuando ejecutan el código.

En python los comentarios se pueden realizar de dos formas: Escribiendo el símbolo

almohadilla delante de la línea de texto donde está el comentario. Y escribiendo triple comilla

Ilustración 1. Ejemplo de comentarios en el programa python. [ CITATION Tut16 \l 9226 ]