Aprendizaje de Lenguaje de Programación Python

¿Qué es Python?
Python es un lenguaje de programación fácil de aprender y potente. Python es un
lenguaje de programación dinámico orientado a objetos. Es un lenguaje de programación
de propósito general.

Python
• Python es un alto nivel, de propósito general, multi plataforma, lenguaje interpretado.
• Se puede utilizar para muchos tipos de desarrollo de software.
• El propósito del diseño del lenguaje Python hace hincapié en la productividad del
programador y legibilidad del código.
• Python es un proyecto de código abierto, administrado por la Python Software Foundation.
• Hoy en día, Python es mantenido por un numeroso grupo de voluntarios en todo el
mundo.
• Python es un software de código abierto.
• Frecuentemente comparado lenguajes como Tcl, Perl, Scheme, Java y Ruby.
GENERALIDADES

CARACTERISITICAS DE PYTHON
• Python es un lenguaje muy expresivo, es decir, los programas Python son muy compactos.
• Sintaxis de Python es muy elegante y permite la escritura de programas cuya lectura resulta sencilla.
• Python ofrece un entorno interactivo para pruebas y depuración.
• Python puede usarse como lenguaje procedimental o como lenguaje orientado a objetos.
• Posee un rico juego de estructuras de datos que se pueden manipular de modo sencillo.
• Se trata de un lenguaje interpretado con tipado dinámico, fuertemente tipado, multiplataforma y orientado
a objetos.
• Un lenguaje interpretado es aquel que se ejecuta utilizando un programa intermedio llamado intérprete, en
lugar de compilar el código a lenguaje máquina que pueda comprender y ejecutar directamente una
computadora tal cual lo hacen los lenguajes compilados.
• La ventaja de los lenguajes compilados es que su ejecución es más rápida. Sin embargo los lenguajes
interpretados son más flexibles y más portables.
• Python tiene, no obstante, muchas de las características de los lenguajes compilados, por lo que se podría
decir que es semi interpretado. En Python, como en Java y muchos otros lenguajes, el código fuente se
traduce a un pseudo código máquina intermedio llamado bytecode la primera vez que se ejecuta,
generando archivos .pyc o .pyo (bytecode optimizado), que son los que se ejecutarán en sucesivas
ocasiones.

CARACTERISITICAS ESPECIFICAS DE PYTHON
• Tipado Dinámico, no es necesario declarar tipo de dato que contiene una variables , este se
asigna automáticamente al darle un valor a la variable.
• Fuertemente Tipado, No se permite tratar a una variable como si fuera de un tipo diferente.
• Multiplaforma, disponible para sistemas operativos Unix, GNU/Linux, Solaris, Mac OS,
Windows, entre Otros.
• Multiparadigma, Python es un lenguaje orientado a objetos pero también permite usar otros
paradigmas de programación tales como programación estructurada, programación funcional y
programación orientada a aspectos.

PORQUE USAR PYTHON
Por su sintaxis simple, sencilla y clara. Fácil de aprender y recordar.
Por la gran cantidad de librerías y módulos libres disponibles.
Por su gestor de memoria.
La potencia del lenguaje.
La facilidad para desarrollar grandes proyectos de software.
Rápido tanto en rendimiento de maquina, como en rendimiento del desarrollador.
Sin embargo Python no es adecuado para la programación de bajo nivel o para
aplicaciones en las que el rendimiento sea crítico.

TRABAJANDO CON PYTHON
Modo Interactivo
Antes de sumergirnos en la programación con Python vamos a explorar el modo de ejecución interactiva.
Este modo de Python nos ofrece un interprete de comandos, en este caso expresiones y funciones de Python,
donde podemos ejecutar ordenes directamente al interprete y obtener una respuesta inmediata para cada
una de ellas. Es decir, no es necesario escribir un programa completo para empezar a obtener resultados de
ejecución, sino que podemos “dialogar” con el interprete del lenguaje de programación.

Aprendizaje de Lenguaje de Programación Python

Estructura y
elementos del
lenguaje
Dentro de los lenguajes informáticos, Python, pertenece al grupo de los lenguajes de programación
y puede ser clasificado como un lenguaje interpretado, de alto nivel, multiplataforma, de tipado
dinámico y multiparadigma. A diferencia de la mayoría de los lenguajes de programación, Python nos
provee de reglas de estilos, a fin de poder escribir código fuente más legible y de manera
estandarizada. Estas reglas de estilo, son definidas a través de la Python Enhancement Proposal Nº 8
(PEP 8)

Elementos del Lenguaje
Comentarios
Un archivo, no solo puede contener código fuente. También puede incluir comentarios (notas que como
programadores, indicamos en el código para poder comprenderlo mejor).
Los comentarios pueden ser de dos tipos: de una sola línea o multi-línea y se expresan de la siguiente
manera:
# Esto es un comentario de una sola línea
mi_variable = 15
"""Y este es un comentario
de varias líneas"""
mi_variable = 15
mi_variable = 15 # Este comentario es de una línea también
Los datos se almacenan en direcciones de memoria. Para verificar la dirección de memoria que apunta una
variable se utiliza el método id(variable).
Ejmp print(id(mi_variable)

Elementos del Lenguaje
Como en la mayoría de los lenguajes de programación de alto nivel, en Python se compone de una serie de
elementos que alimentan su estructura. Entre ellos, podremos encontrar los siguientes:
Una variable es un espacio para almacenar datos modificables, en la memoria de un ordenador. En Python, una variable se
define con la sintaxis:
nombre_de_la_variable = valor_de_la_variable
Cada variable, tiene un nombre y un valor, el cual define a la vez, el tipo de datos de la variable.
Existe un tipo de “variable”, denominada constante, la cual se utiliza para definir valores fijos, que no requieran ser
modificados.

Tipo de dato numérico
En python tenemos: números enteros, números decimales (de punto flotante) y números complejos.
Los números enteros representan todos los números "Enteros" (positivos y negativos), ejemplo: 1, 0, -5 (Tipo de dato
int)
Los números decimales son todos los números que contiene dígitos después de un punto decimal, ejemplo: 1.0 , -6.5,
etc (tipo de dato Float)
También existe los números complejos, que son utilizados generalmente para funciones matemáticas, ejemplo: 3i + 4j
En python un String o Cadena es una secuencia (ordenada de izquierda a derecha) de caracteres. Las cadenas comienzan
y terminan con comillas dobles o simples. Declarar una cadena es simple:
>>> blog = "Mi Diario Python"
En caso de olvidarnos de cerrar o abrir una comilla, python nos devolverá un error
Tipo de dato String o Cadena

Tipo de dato Boolean (True y False)
El tipo de datos más simple de construir es el tipo Booleano (verdadero y falso). Muy útil en las expresiones
condicionales y cualquier otro lugar que se necesite la verdad o falsedad de una condición.
El operador and devuelve su primer operando si este es falso y el segundo en caso contrario.
El operador or devuelve su primero operando si este es cierto y el segundo en caso contrario.
El operador not devuelve False si su operando es cierto y True si es falso.
Para Python, falso es):
• El valor False .
• El valor 0.
• Una secuencia vacia (lista, tupla o cadena).
• Un diccionario vacıo.
• El valor None
.

Propiedades de los datos estructurados

Caracteres especiales en las cadenas
La contra barra () se utiliza para introducir un caracter especial. Veamos la siguiente tabla:
n -- Salto de línea (nueva línea)
t -- Tabulación horizontal
-- Contra barra
' -- Comilla simple
"-- Comilla doble
>>> print "Esta es una contra barra ()"
Esta es una contra barra ()
>>> print "Esta es una t tabulacion horizontal"
Esta es una tabulacion horizontal
>>> print "Esta es una 'simple comilla'"
Esta es una 'simple comilla'

Modulo String
En Python, todo es un objeto y por tanto, cualquier variable cuyo valor sea de tipo string, podrá ser tratada como un
subtipo del objeto string, el cuál dispone de métodos que son heredados por dicho subtipo.
Convertir a mayúscula la primera letra
Método: capitalize()
Retorna: una copia de la cadena con la primera letra en mayúsculas.
>>> cadena = "bienvenido a mi aplicación"
>>> print cadena.capitalize()
Bienvenido a mi aplicación
Convertir una cadena a minúsculas
Método: lower()
Retorna: una copia de la cadena en minúsculas.
>>> cadena = "Hola Mundo"
>>> print cadena.lower()
hola mundo
Convertir una cadena a mayúsculas
Método: upper()
Retorna: una copia de la cadena en mayúsculas.
>>> print cadena.upper()
HOLA MUNDO
Convertir mayúsculas a minúsculas y viceversa
Método: swapcase()
Retorna: una copia de la cadena convertidas las mayúsculas en minúsculas y
viceversa.
>>> print cadena.swapcase()
hOLA mUNDO
Convertir una cadena en Formato Título
Método: title()
Retorna: una copia de la cadena convertida.
>>> cadena = "hola mundo"
>>> print cadena.title()
Hola Mundo

Modulo String
Centrar un texto
Método: center(longitud[, "caracter de relleno"])
Retorna: una copia de la cadena centrada.
>>> cadena = "bienvenido a mi aplicación".capitalize()
>>> print cadena.center(50, "=")
===========Bienvenido a mi aplicación============
>>> print cadena.center(50, " ")
Alinear texto a la izquierda
Método: ljust(longitud[, "caracter de relleno"])
Retorna: una copia de la cadena alineada a la izquierda.
>>> print cadena.ljust(50, "=")
Bienvenido a mi aplicación=======================
Alinear texto a la derecha
Método: rjust(longitud[, "caracter de relleno"])
Retorna: una copia de la cadena alineada a la derecha.
>>> print cadena.rjust(50, "=")
=======================Bienvenido a mi aplicación
>>> print cadena.rjust(50, " ")
Rellenar un texto anteponiendo ceros
Método: zfill(longitud)
Retorna: una copia de la cadena rellena con ceros a la izquierda
hasta alcanzar la longitud final indicada.
>>> numero_factura = 1575
>>> print str(numero_factura).zfill(12)
000000001575

Modulo String Métodos de validacion
Saber si una cadena comienza con una subcadena determinada
Método: startswith("subcadena" [, posicion_inicio, posicion_fin])
Retorna: True o False
>>> print cadena.startswith("Bienvenido")
True
>>> print cadena.startswith("aplicación")
False
>>> print cadena.startswith("aplicación", 16)
True
Saber si una cadena finaliza con una subcadena determinada
Método: endswith("subcadena" [, posicion_inicio, posicion_fin])
>>> print cadena.endswith("aplicación")
True
>>> print cadena.endswith("Bienvenido")
False
>>> print cadena.endswith("Bienvenido", 0, 10)
True
Saber si una cadena es alfanumérica
Método: isalnum()
>>> cadena = "pepegrillo 75"
>>> print cadena.isalnum()
False
>>> cadena = "pepegrillo"
True
>>> cadena = "pepegrillo75"
True
Saber si una cadena es alfabética
Método: isalpha()
>>> print cadena.isalpha()
False
>>> cadena = "pepegrillo"
True
False
Saber si una cadena es numérica
Método: isdigit()
>>> print cadena.isdigit()
False
>>> cadena = "7584"
True
>>> cadena = "75 84"
False
>>> cadena = "75.84"
False

Modulo String Métodos de validacion
Saber si una cadena contiene solo minúsculas
Método: islower()
>>> cadena = "pepe grillo"
>>> print cadena.islower()
True
>>> cadena = "Pepe Grillo"
False
>>> cadena = "Pepegrillo"
False
True
Saber si una cadena contiene solo mayúsculas
Método: isupper()
>>> cadena = "PEPE GRILLO"
>>> print cadena.isupper()
True
False
>>> cadena = "Pepegrillo"
False
>>> cadena = "PEPEGRILLO"
True
Saber si una cadena contiene solo espacios
en blanco
Método: isspace()
>>> cadena = "pepe grillo"
>>> print cadena.isspace()
False
>>> cadena = " "
>>> print cadena.isspace()
True
Saber si una cadena tiene Formato De
Título
Método: istitle()
>>> print cadena.istitle()
True
>>> cadena = "Pepe grillo"
>>> print cadena.istitle()
False

Modulo String Métodos de sustitucion
Dar formato a una cadena, sustituyendo texto dinámicamente
Método: format(*args, **kwargs)
Retorna: la cadena formateada.
>>> cadena = "bienvenido a mi aplicación {0}"
>>> print cadena.format("en Python")
bienvenido a mi aplicación en Python
>>> cadena = "Importe bruto: ${0} + IVA: ${1} = Importe neto: {2}"
>>> print cadena.format(100, 21, 121)
Importe bruto: $100 + IVA: $21 = Importe neto: 121
>>> cadena = "Importe bruto: ${bruto} + IVA: ${iva} = Importe neto: {neto}"
>>> print cadena.format(bruto=100, iva=21, neto=121)
>>> print cadena.format(bruto=100, iva=100 * 21 / 100, neto=100 * 21 / 100 + 100)
Reemplazar texto en una cadena
Método: replace("subcadena a buscar", "subcadena por la cual reemplazar")
Retorna: la cadena reemplazada.
>>> buscar = "nombre apellido"
>>> reemplazar_por = "Juan Pérez"
>>> print "Estimado Sr. nombre apellido:".replace(buscar, reemplazar_por)
Estimado Sr. Juan Pérez:
Eliminar caracteres a la izquierda y derecha de una cadena
Método: strip(["caracter"])
Retorna: la cadena sustituida.
>>> cadena = " www.eugeniabahit.com "
>>> print cadena.strip()
www.eugeniabahit.com
>>> print cadena.strip(' ')
Eliminar caracteres a la izquierda de una cadena
Método: lstrip(["caracter"])
Retorna: la cadena sustituida.
>>> cadena = "www.eugeniabahit.com"
>>> print cadena.lstrip("w." )
eugeniabahit.com
>>> cadena = " www.eugeniabahit.com"
>>> print cadena.lstrip()

Métodos de búsqueda
Contar cantidad de apariciones de una subcadena
Método: count("subcadena" [, posicion_inicio, posicion_fin])
Retorna: un entero representando la cantidad de apariciones de subcadena dentro de cadena.
>>> print cadena.count("a")
3
Buscar una subcadena dentro de una cadena
Método: find("subcadena" [, posicion_inicio, posicion_fin])
Retorna: un entero representando la posición donde inicia la subcadena dentro de cadena. Si no la encuentra,
retorna -1.
>>> print cadena.find("mi")
13
>>> print cadena.find("mi", 0, 10)
-1

Listas
Python tiene varios tipos de datos compuestos, usados para agrupar otros valores. El más versátil es la lista, la cual puede ser escrita como
una lista de valores separados por coma (ítems) entre corchetes. No es necesario que los ítems de una lista tengan todos el mismo tipo.
Como los índices de las cadenas de texto, los índices de las listas comienzan en 0, y las listas pueden ser rebanadas, concatenadas y todo lo
demás:

Listas
A diferencia de las cadenas de texto, que son inmutables, es posible cambiar un elemento individual de
una lista:
También es posible asignar a una rebanada, y esto incluso
puede cambiar la longitud de la lista o vaciarla totalmente:

Algunos Métodos para las Listas

0,0 0,1 0,2
1,0 1,1 1,2
2,0 2,1 2,2

Accediendo a los elementos de la matriz
Creando una tabla o matriz

En Python, un conjunto es una estructura de datos que almacena elementos desordenados. Los elementos del
conjunto tampoco están indexados. Como una lista, un conjunto permite la adición y eliminación de elementos.
Sin embargo, hay algunas características únicas que definen un conjunto y lo separan de otras estructuras de
datos:
 Un conjunto no contiene elementos duplicados.
 Los elementos del conjunto son inmutables, es decir, no se pueden cambiar, pero el conjunto en sí es
mutable, es decir, se puede cambiar.
 Dado que los elementos del conjunto no están indexados, los conjuntos no admiten operaciones de
segmentación o indexación.
Hay dos formas de crear conjuntos en Python.
Podemos crear un conjunto pasando todos los elementos del conjunto dentro de llaves {} y separe los elementos usando
comas (,). Un conjunto puede contener cualquier número de elementos y los elementos pueden ser de diferentes tipos, por
ejemplo, enteros, cadenas, tuplas, etc. Sin embargo, un conjunto no acepta un elemento que sea mutable, por ejemplo, una
lista, diccionario, etc.

También podemos crear un conjunto a partir de una lista. Esto se puede hacer llamando al código integrado
de Python set() función. Por ejemplo:
Los conjuntos no contienen elementos duplicados. Supongamos que nuestra lista tiene elementos duplicados, como se muestra a
continuación:
El conjunto eliminó los duplicados y devolvió solo uno de cada elemento
duplicado. Esto también sucede cuando creamos un conjunto desde cero. Por
ejemplo:

La creación de un conjunto vacío es algo complicada. Si usa llaves vacías {} en Python, crea un diccionario vacío en lugar de un conjunto
vacío. Por ejemplo:
Como se muestra en la salida, el tipo de variable x es un diccionario.
Para crear un conjunto vacío en Python debemos usar el set() función sin pasar ningún
valor para los parámetros, como se muestra a continuación:
Python no nos proporciona una forma de acceder a un elemento de conjunto individual. Sin embargo, podemos usar un for bucle para recorrer todos
los elementos de un conjunto. Por ejemplo:

También podemos verificar la presencia de un elemento en un conjunto usando el in palabra clave como se muestra a continuación:
Python nos permite agregar nuevos elementos a un conjunto a través del add() función. Por ejemplo:

Python nos permite eliminar un elemento de un conjunto, pero sin usar un índice, ya que los elementos del conjunto no están indexados. Los
elementos se pueden eliminar utilizando el discard() o remove() métodos.
Tenga en cuenta que el discard() El método no generará un error si el elemento no se encuentra en el conjunto. Sin embargo, si el remove() se utiliza
el método y no se encuentra el elemento, se generará un error.
Demostremos cómo eliminar un elemento usando el discard() método:
Con el pop() método, podemos eliminar y devolver un elemento. Dado que los elementos están
desordenados, no podemos decir ni predecir el elemento que se eliminará. Por ejemplo:
El Python clear() El método nos ayuda a eliminar todos los elementos de un conjunto.

Suponga que tenemos dos conjuntos, A y B. La unión de los dos conjuntos es un conjunto con todos los elementos de ambos conjuntos. Tal
operación se logra a través de Python union() función.
Aquí hay un ejemplo:
También se puede realizar una unión en más de dos conjuntos, y todos sus elementos se combinarán en un solo conjunto. Por
ejemplo:
| El operador también se puede utilizar para encontrar la unión de dos o más conjuntos
Si desea realizar una unión en más de dos conjuntos, separe los nombres de los
conjuntos utilizando el | operador. Por ejemplo:

Suponga que tiene dos conjuntos A y B. Su intersección es un conjunto con elementos que son comunes tanto en A como en B.
La operación de intersección en conjuntos se puede lograr mediante el & operador o el intersection() método. Por ejemplo:
Suponga que tiene dos conjuntos A y B. La diferencia de A y B (A – B) es el conjunto con todos los elementos que están en A pero no en B. En
consecuencia, (B – A) es el conjunto con todos los elementos B pero no en A.
Para determinar las diferencias de conjuntos en Python, podemos usar el difference() función o la - operador. Por ejemplo:
Solo los primeros tres elementos del conjunto set_a no están disponibles en el set set_b, por lo tanto,
forman nuestra salida. El menos - El operador también se puede utilizar para encontrar la diferencia entre
los dos conjuntos como se muestra a continuación:

La diferencia simétrica de los conjuntos A y B es el conjunto con todos los elementos que están en A y B excepto los elementos que son
comunes en ambos conjuntos. Se determina utilizando Python symmetric_difference() método o el ^ operador. Por ejemplo:
Establecer comparación
Podemos comparar conjuntos en función de los elementos que tengan. De esta manera, podemos saber si un conjunto es un superconjunto o un
subconjunto de otro conjunto. El resultado de tal comparación será True o False.
Para comprobar si el conjunto A es un subconjunto del conjunto B,
podemos usar la siguiente operación: A <= B
Para comprobar si B es un superconjunto de A, podemos usar la siguiente
operación: B >=A
El subconjunto y el superconjunto también se pueden comprobar
utilizando issubset() y issuperset() métodos como se muestra a
continuación:

Python viene con numerosos métodos de conjuntos integrados, incluidos los siguientes:
Copiar()
Este método devuelve una copia del conjunto en cuestión. Por
ejemplo:
Este método comprueba si los conjuntos en cuestión tienen una intersección o no. Si los conjuntos no tienen elementos
comunes, este método devuelve True, de lo contrario vuelve False. Por ejemplo:
isdisjoint()
len ()
Este método devuelve la longitud de un conjunto, que es el número total de elementos del conjunto. Por
ejemplo:

Los diccionarios son una de las estructuras de datos más utilizadas en todo el desarrollo de software,
y por una buena razón. Nos permiten almacenar nuestros datos en claves ordenadas, pares de
valores, lo que a su vez nos da la capacidad de, en promedio, acceder a nuestros datos.

Para definir un diccionario, se encierra el listado de valores entre llaves. Las parejas de clave y
valor se separan con comas, y la clave y el valor se separan con dos puntos. Se puede utilizar
valores de cualquier tipo para crear diccionarios

dictionary = {"gato": "chat", "perro": "chien", "caballo": "cheval"}
phone_numbers = {'jefe': 5551234567, 'Suzy': 22657854310}
empty_dictionary = {}
print(dictionary)
print(phone_numbers)
print(empty_dictionary)
En este primer ejemplo, el diccionario emplea claves y valores las cuales ambas son cadenas.
En el segundo, las claves con cadenas pero los valores son enteros. El orden inverso (claves →
números, valores → cadenas) también es posible, así como la combinación número a número.
La lista de todos los pares es encerrada con llaves, mientras que los pares son separados por
comas, y las claves y valores por dos puntos.
El primer diccionario es muy simple, es un diccionario Español-Francés. El segundo es un directorio
telefónico muy pequeño.
Los diccionarios vacíos son construidos por un par vacío de llaves - nada inusual.

Un diccionario en Python funciona de la misma manera que un diccionario bilingüe. Por ejemplo, se tiene
la palabra en español "gato" y se necesita su equivalente en francés. Lo que se haría es buscar en el
diccionario para encontrar la palabra "gato". Eventualmente la encontrarás, y sabrás que la palabra
equivalente en francés es "chat".
En el mundo de Python, la palabra que se esta buscando se denomina key. La palabra que se obtiene del
diccionario es denominada value.
Esto significa que un diccionario es un conjunto de pares de key y value.
Nota:
•cada clave debe de ser única - no es posible tener una clave duplicada;
•una clave puede ser un de dato de cualquier tipo - puede ser un número (entero o flotante), incluso una
cadena, pero no una lista;
•un diccionario no es una lista - una lista contiene un conjunto de valores numerados, mientras que
un diccionario almacena pares de valores;
•la función len() aplica también para los diccionarios - regresa la cantidad de pares (clave-valor) en el
diccionario;
•un diccionario es una herramienta de un solo sentido - si fuese un diccionario español-francés,
podríamos buscar en español para encontrar su contraparte en francés más no viceversa.

Los diccionarios se pueden iterar de manera muy similar a las listas u otras estructuras de datos. Para imprimir los key.
Se puede imprimir también solo el value
O si queremos imprimir el key y el value a la vez
print(dictionary[‘gato'])
print(phone_numbers['Suzy'])
El obtener el valor de un diccionario es semejante a la
indexación, gracias a los corchetes alrededor del valor de la
clave.
Nota:
•si una clave es una cadena, se tiene que especificar como una
cadena;
•las claves son sensibles a las mayúsculas y
minúsculas: 'Suzy' sería diferente a 'suzy'.

Ahora algo muy importante: No se puede utilizar una clave que no exista. Hacer algo como lo siguiente:
Provocará un error de ejecución. Inténtalo.
Afortunadamente, existe una manera simple de evitar dicha situación. El operador in, junto con su
acompañante, not in, pueden salvarnos de esta situación.

Nota Cuando escribes una expresión grande o larga, puede ser una buena idea mantenerla alineada
verticalmente. Así es como puede hacer que el código sea más legible y más amigable para el
programador, por ejemplo:
Este tipo de formato se llama sangría francesa.

Los diccionarios en Python pueden contener uno dentro de otro. Podemos ver como los valores anidado uno y dos del
diccionario d contienen a su vez otro diccionario.
Métodos diccionarios Python
clear()
El método clear() elimina todo el contenido del
diccionario.
get(<key>[,<default>])
El método get() nos permite consultar el value para un key determinado. El
segundo parámetro es opcional, y en el caso de proporcionarlo es el valor a
devolver si no se encuentra la key.

El método keys()
¿Pueden los diccionarios ser examinados utilizando el bucle for, como las listas o tuplas?
No y si.
No, porque un diccionario no es un tipo de dato secuencial - el bucle for no es útil aquí.
Si, porque hay herramientas simples y muy efectivas que pueden adaptar cualquier diccionario a los
requerimientos del bucle for (en otras palabras, se construye un enlace intermedio entre el diccionario y una
entidad secuencial temporal).
El primero de ellos es un método denominado keys(), el cual es parte de todo diccionario. El método retorna o
regresa una lista de todas las claves dentro del diccionario. Al tener una lista de claves se puede acceder a todo
el diccionario de una manera fácil y útil.
A continuación se muestra un ejemplo:
Otra manera de hacerlo es utilizar el método items(). Este
método retorna una lista de tuplas (este es el primer ejemplo
en el que las tuplas son mas que un ejemplo de si
mismas) donde cada tupla es un par de cada clave con su
valor.

Métodos diccionarios Python
items()
El método items() devuelve una lista con los keys y values del
diccionario. Si se convierte en list se puede indexar como si de
una lista normal se tratase, siendo los primeros elementos las
key y los segundos los value.
keys()
El método keys() devuelve una lista con todas las keys del
diccionario
values()
El método values() devuelve una lista con todos los values o
valores del diccionario.
pop(<key>[,<default>])
El método pop() busca y elimina la key que se pasa como parámetro y
devuelve su valor asociado. Daría un error si se intenta eliminar una key
que no existe
También se puede pasar un segundo parámetro que es el valor a
devolver si la key no se ha encontrado. En este caso si no se encuentra
no habría error
popitem()
El método popitem() elimina de manera aleatoria un elemento del
diccionario.
update(<obj>)
El método update() se llama sobre un diccionario y tiene como entrada otro
diccionario. Los value son actualizados y si alguna key del nuevo diccionario no
esta, es añadida.

La función sorted()
¿Deseas que la salida este ordenada? Solo hay que agregar al bucle for lo siguiente:
Agregando nuevas claves
El agregar una nueva clave con su valor a un diccionario es tan simple como cambiar un valor. Solo se tiene que
asignar un valor a una nueva clave que no haya existido antes.
Nota: este es un comportamiento muy diferente comparado a las listas, las cuales no permiten asignar valores a
índices no existentes.
A continuación se agrega un par nuevo al diccionario - un poco extraño pero válido:
Nota También es posible insertar un elemento al diccionario
utilizando el método update(), por ejemplo:

d1 = {'Adam Smith': 'A', 'Judy Paxton': 'B+'}
d2 = {'Mary Louis': 'A', 'Patrick White': 'C'}
d3 = {}
for item in (d1, d2):
# Escribe tu código aquí.
print(d3)
Escribe un programa que "una" los dos diccionarios
(d1 y d2) para crear uno nuevo (d3).
Escribe un programa que convierta la lista my_list en una
tupla.
my_list = ["car", "Ford", "flower", "Tulip"]
t = # Escribe tu código aquí.
print(t)
Escribe un programa que convierta la tupla colors en un
diccionario.
colors = (("green", "#008000"), ("blue", "#0000FF"))
# Escribe tu código aquí.
print(colors_dictionary)
¿Cuál es la salida del siguiente programa?
colors = {
"blanco": (255, 255, 255),
"gris": (128, 128, 128),
"rojo": (255, 0, 0),
"verde": (0, 128, 0)
}
for col, rgb in colors.items():
print(col, ":", rgb)

Las tuplas y los diccionarios pueden trabajar juntos
Se ha preparado un ejemplo sencillo, mostrando como las tuplas y los diccionarios pueden trabajar juntos.
Imaginemos el siguiente problema:
•necesito un programa para calcular los promedios de alumnos;
•el programa pide el nombre del alumno seguido de su calificación;
•los nombres son ingresados en cualquier orden;
•el ingresar un nombre vacío finaliza el ingreso de los datos (Nota 1: ingresar una puntuación vacía generará la excepción ValueError
•una lista con todos los nombres y el promedio de cada alumno debe ser mostrada al final.
Ahora se analizará línea por línea:
•línea 1: crea un diccionario vacío para ingresar los datos; el nombre del alumno
es empleado como clave, mientras que todas las calificaciones asociadas son
almacenadas en una tupla (la tupla puede ser el valor de un diccionario, esto no
es un problema)
•línea 3: se ingresa a un bucle "infinito"
•línea 4: se lee el nombre del alumno aquí;
•línea 5-6: si el nombre es una cadena vacía (), salimos del bucle;
•línea 8: se pide la calificación del estudiante (un valor entero en el rango del 0-
10)
•línea 9-10: si la puntuación ingresada no está dentro del rango de 0 a 10, se
abandona el bucle;
•línea 12-13: si el nombre del estudiante ya se encuentra en el diccionario, se
alarga la tupla asociada con la nueva calificación (observa el operador +=)
•línea 14-15: si el estudiante es nuevo (desconocido para el diccionario), se crea
una entrada nueva, su valor es una tupla de un solo elemento la cual contiene la
calificación ingresada;
•línea 17: se itera a través de los nombres ordenados de los estudiantes;
•línea 18-19: inicializa los datos necesarios para calcular el promedio (sum y
counter).
•línea 20-22: se itera a través de la tupla, tomado todas las calificaciones

Estructuras de Control de Flujo
Una estructura de control, es un bloque de código que permite agrupar instrucciones de manera controlada.
Existe dos estructuras de control:
• Estructuras de control condicionales
• Estructuras de control iterativas
Identación
Para hablar de estructuras de control de flujo en Python, es imprescindible primero, hablar de identación.
¿Qué es la identación? En un lenguaje informático, la identación es lo que la sangría al lenguaje humano escrito (a nivel formal). Así como para el
lenguaje formal, cuando uno redacta una carta, debe respetar ciertas sangrías, los lenguajes informáticos, requieren una identación.
No todos los lenguajes de programación, necesitan de una identación, aunque sí, se estila implementarla, a fin de otorgar mayor legibilidad al
código fuente. Pero en el caso de Python, la identación es obligatoria, ya que de ella, dependerá su estructura.
Una estructura de control, entonces, se define de la siguiente forma:
inicio de la estructura de control:
expresiones

Estructuras de control de flujo condicionales
“[...] Los condicionales nos permiten comprobar condiciones y hacer que nuestro programa se comporte de una forma u
otra, que ejecute un fragmento de código u otro, dependiendo de esta condición [...]”
Cita textual del libro “Python para Todos” de Raúl González Duque
(http://mundogeek.net/tutorial-python/)
Las estructuras de control condicionales, son aquellas que nos permiten evaluar si una o más condiciones se cumplen, para decir qué acción vamos a
ejecutar. La evaluación de condiciones, solo puede arrojar 1 de 2 resultados: verdadero o falso (True o False).
En la vida diaria, actuamos de acuerdo a la evaluación de condiciones, de manera mucho más frecuente de lo que en realidad creemos: Si el semáforo
está en verde, cruzar la calle. Sino, esperar a que el semáforo se ponga en verde. A veces, también evaluamos más de una condición para ejecutar
una determinada acción: Si llega la factura de la luz y tengo dinero, pagar la factura.
Para describir la evaluación a realizar sobre una condición, se utilizan operadores relacionales (o de comparación):

Las estructuras de control de flujo condicionales, se definen mediante el uso de tres palabras claves reservadas, del lenguaje:
if (si), elif (sino, si) y else (sino).

Estructuras de control de flujo condicionales if

Estructuras de control de flujo condicionales if - else
Se puede construir instrucciones mas complejas

Estructuras de control de flujo condicionales if - else

Estructuras de control de flujo condicionales if – elif - else

Estructuras de control iterativas
A diferencia de las estructuras de control condicionales, las iterativas (también llamadas cíclicas o bucles),
nos permiten ejecutar un mismo código, de manera repetida, mientras se cumpla una condición.
En Python se dispone de dos estructuras cíclicas:
• El bucle while
• El bucle for

Estructuras de control iterativas

En Python, cada uno de nuestros archivos .py se denominan
módulos. Estos módulos, a la vez, pueden formar parte de
paquetes. Un paquete, es una carpeta que contiene archivos
.py. Pero, para que una carpeta pueda ser considerada un
paquete, debe contener un archivo de inicio llamado __init__.py.
Este archivo, no necesita contener ninguna instrucción. De
hecho, puede estar completamente vacío.
Los módulos tienen un doble propósito:
 Dividir un programa con muchas líneas de código en partes más
pequeñas.
 Extraer un conjunto de definiciones que se utiliza frecuentemente
en los programas para ser reutilizadas. Esto evita, por ejemplo,
tener que estar copiando funciones de un programa a otro.

Practica: Crear un Modulo y utilizarlo con el interprete de python
Sitúece en un directorio para un nuevo proyecto y crea en él un fichero llamado mis_funciones.py con el
siguiente contenido:
Ahora, desde una consola, sitúese en el directorio anterior y ejecuta el comando python para ejecutar el
intérprete de Python.
Una vez dentro del intérprete, ejecute el siguiente comando:
Con el comando anterior estamos importando el módulo mis_funciones en el intérprete. Ahora puede llamar
ahora a la función saludo() de este modo:

En Python, cada uno de nuestros archivos .py se denominan módulos. Estos módulos, a la vez, pueden formar parte de
paquetes. Un paquete, es una carpeta que contiene archivos .py. Pero, para que una carpeta pueda ser considerada un
paquete, debe contener un archivo de inicio llamado __init__.py. Este archivo, no necesita contener ninguna instrucción.
De hecho, puede estar completamente vacío.

El contenido de cada módulo, podrá ser utilizado a la vez, por otros módulos. Para ello, es necesario importar los módulos
que se quieran utilizar. Para importar un módulo, se utiliza la instrucción import, seguida del nombre del paquete (si aplica)
más el nombre del módulo (sin el .py) que se desee importar.
# -*- coding: utf-8 *-*
import modulo # importar un módulo que no pertenece a un paquete
import paquete.modulo1 # importar un módulo que está dentro de un
paquete
import paquete.subpaquete.modulo1
La instrucción import seguida de nombre_del_paquete.nombre_del_modulo, nos permitirá hacer uso de todo el código
que dicho módulo contenga.
Teniendo en cuenta el diagrama de la sección anterior, si en el módulo
app.pedidos.vistas se quiere importar el módulo app.usuarios.dao,
simplemente hay que añadir la siguiente sentencia:

Para acceder (desde el módulo donde se realizó la importación), a cualquier elemento del módulo importado, se realiza mediante el
namespace, seguido de un punto (.) y el nombre del elemento que se desee obtener. En Python, un namespace, es el nombre que se ha
indicado luego de la palabra import, es decir la ruta (namespace) del módulo:
print modulo.CONSTANTE_1
print paquete.modulo1.CONSTANTE_1
print paquete.subpaquete.modulo1.CONSTANTE_1
Es posible también, abreviar los namespaces mediante un “alias”. Para ello, durante la importación, se asigna la palabra clave as seguida del
alias con el cuál nos referiremos en el futuro a ese namespace importado:
import modulo as m
import paquete.modulo1 as pm
import paquete.subpaquete.modulo1 as psm
Luego, para acceder a cualquier elemento de los módulos importados, el namespace
utilizado será el alias indicado durante la importación:
print m.CONSTANTE _1
print pm.CONSTANTE _1
print psm.CONSTANTE_1

En Python, es posible también, importar de un módulo solo los elementos que se desee utilizar. Para ello se utiliza la instrucción from seguida del
namespace, más la instrucción import seguida del elemento que se desee importar:
from paquete.modulo1 import CONSTANTE_1
En este caso, se accederá directamente al elemento, sin recurrir a su namespace:
print CONSTANTE_1
Es posible también, importar más de un elemento en la misma instrucción. Para ello, cada elemento irá separado por una coma (,) y un espacio
en blanco:
from paquete.modulo1 import CONSTANTE_1, CONSTANTE_2
Pero ¿qué sucede si los elementos importados desde módulos diferentes tienen los mismos nombres? En estos casos, habrá que
prevenir fallos, utilizando alias para los elementos:
from paquete.modulo1 import CONSTANTE_1 as C1, CONSTANTE_2 as C2
from paquete.subpaquete.modulo1 import CONSTANTE_1 as CS1, CONSTANTE_2 as CS2
print C1
print C2
print CS1
print CS2

Módulos de sistema
Entre los módulos de sistema que Python nos provee a través de su librería estándar, podemos destacar tres: os, sys, y
subprocess.
Módulo os
El módulo os nos permite acceder a funcionalidades dependientes
del Sistema Operativo. Sobre todo, aquellas que nos refieren
información sobre el entorno del mismo y nos permiten manipular la
estructura de directorios (para leer y escribir archivos)
Archivos y directorios
El módulo os nos provee de varios métodos para trabajar de forma
portable con las funcionalidades del sistema operativo. Veremos a
continuación, los métodos más destacados de este módulo.

Módulos que resuelven necesidades funcionales
Obtener datos aleatorios
Con el módulo random de la librería estándar de Python, es posible obtener datos aleatorios. Entre los métodos de los cuáles dispone, se destacan los
siguientes:

Obtener elementos aleatorios de una secuencia

Módulos e Internet
Acceder al navegador Web
Abrir una URL en una nueva pestaña del navegador:
Conectarse vía FTP
El módulo ftplib de la librería estándar de Python, nos provee de los métodos necesarios para crear clientes FTP de forma rápida y sencilla.
Conectarse a un servidor FTP
Para conectarse a un servidor FTP, el módulo ftplib nos provee de la clase FTP. El método constructor de la clase FTP (método __init__()), recibe como
parámetros al host, usuario, clave, de forma tal que pasando estos parámetros durante la instancia a FTP, se ahorra el uso de los métodos connect(host, port,
timeout) y login(user, pass).

Medir la velocidad de internet con Python
La velocidad de Internet puede referirse a la velocidad de la conexión entre tu computadora y el servidor web que aloja
su conexión de Internet. Cuando mida la velocidad de su conexión a Internet, se está midiendo la cantidad de datos que
la computadora envía a través de la conexión a Internet en un período de tiempo determinado.
La velocidad de conexión a Internet se puede medir en megabytes por segundo (Mbps) o gigabytes por segundo (Gbps).
La velocidad de Internet se convierte en un problema cuando se intenta descargar o cargar archivos grandes (por
ejemplo, archivos de video).
Ahora, es importante saber que tan rápido se pueden cargar o descargar archivos y lo podremos hacer usando Python.
Para acceder a la biblioteca de Python, se debe instalarla en el entorno de Python, usando el siguiente comando:
pip install speedtest-cli
Ahora, importamos el paquete en nuestro script de Python.
import speedtest
Creemos una instancia de Speedtest y llamémosla st
st = speedtest.Speedtest()
Avancemos y verifiquemos la velocidad de descarga. Usaremos el método download para obtener la velocidad y
almacenar en d_st
d_st = st.download()
De manera similar, para verificar la velocidad de carga, usaremos el método upload para obtener la velocidad y almacenarla
en u_st
u_st = st.upload()
Una vez hecho esto, mostraremos la velocidad de descarga y carga.DUPDO

Una vez hecho esto, mostraremos la velocidad de descarga y carga.DUPDO
print("Tu velocidad de descarga es", d_st)
print("Tu velocidad de subida es", u_st)
Medir la velocidad de internet con Python

Módulo Math
Este módulo está siempre disponible. Proporciona acceso a las funciones matemáticas definidas por el estándar C.
Estas funciones no pueden usarse con números complejos; use las funciones del mismo nombre del módulo cmath si necesita soporte para
números complejos.
math. ceil ( x )
Devuelve el techo de x , el entero más pequeño mayor o igual
que x . Si x no es un flotante, delega a x.__ceil__() , que debería
devolver un valor Integral .
math. copysign ( x , y )
Devuelve un flotador con la magnitud (valor absoluto) de x pero
el signo de y . En plataformas que admiten ceros firmados,
copysign(1.0, -0.0) devuelve -1.0 .
math. fabs ( x )
Devuelve el valor absoluto de x .
math. factorial ( x )
Vuelve x factorial. Aumenta ValueError si x no es integral o es
negativo.
math. floor ( x )
Devuelve el piso de x , el entero más grande menor o igual que x . Si
x no es un flotante, delega a x.__floor__() , que debe devolver un valor
Integral .
math. fmod ( x , y )
Devuelve fmod(x, y) , tal como lo define la biblioteca C de la plataforma. Tenga
en cuenta que la expresión de Python x % y puede no devolver el mismo
resultado. La intención del estándar C es que fmod(x, y) sea exactamente
(matemáticamente; con una precisión infinita)
math. frexp ( x )
Devuelve la mantisa y el exponente de x como el par (m, e) . m es un flotador y
e es un número entero tal que x == m * 2**e exactamente. Si x es cero, devuelve
(0.0, 0) , de lo contrario 0.5 <= abs(m) < 1 . Esto se utiliza para "separar" la
representación interna de un flotador de una manera portátil.
math. gcd ( a , b )
Devuelve el mayor divisor común de los enteros ay b . Si a o b es distinto de
cero, entonces el valor de gcd(a, b) es el mayor entero positivo que divide a y b .
gcd(0, 0) devuelve 0 .
math. trunc ( x )
Devuelva el valor Real x truncado a una Integral (generalmente un entero).
Delegados a x.__trunc__() .

Módulo Math Poder y funciones logarítmicas
math. exp ( x )
Devuelva e elevado a la potencia x , donde e = 2.718281 ... es la base de
los logaritmos naturales. Esto suele ser más preciso que math.e ** x o
pow(math.e, x) .
math. expm1 ( x )
Devuelva e elevado a la potencia x , menos 1. Aquí e es la base de los
logaritmos naturales. Para los flotadores pequeños x , la resta en exp(x) - 1
puede resultar en una pérdida significativa de precisión ; La función
expm1() proporciona una forma de calcular esta cantidad con total
precisión:
math. log ( x [ , base ] )
Con un argumento, devuelva el logaritmo natural de x (para basar e ).
Con dos argumentos, devuelva el logaritmo de x a la base dada, calculada
como log(x)/log(base) .
math. log1p ( x )
Devuelve el logaritmo natural de 1 + x (base e ). El resultado se calcula de
forma precisa para x cerca de cero.
math. log2 ( x )
Devuelve el logaritmo base-2 de x . Esto suele ser más preciso que log(x, 2) .
int.bit_length() devuelve el número de bits necesarios para representar un
entero en binario, excluyendo el signo y los ceros iniciales.
math. log10 ( x )
Devuelve el logaritmo en base 10 de x . Esto suele ser más preciso que log(x,
10) .
math. pow ( x , y )
Vuelve x elevado a la potencia y . Casos excepcionales siguen el Anexo 'F' de la
norma C99 en la medida de lo posible. En particular, pow(1.0, x) y pow(x, 0.0)
siempre devuelven 1.0 , incluso cuando x es un cero o un NaN. Si tanto x como y
son finitos, x es negativo, y y no es un número entero, entonces pow(x, y) no está
definido, y genera ValueError .
A diferencia del operador ** math.pow() , math.pow() convierte ambos
argumentos en tipo float . Use ** o la función pow() incorporada para calcular las
potencias enteras exactas.
math. sqrt ( x )
Devuelve la raíz cuadrada de x .

Modulo Math Funciones Trigonométricas
math. acos ( x )
Devuelve el arco coseno de x , en radianes.
math. asin ( x )
Devuelve el arco seno de x , en radianes.
math. atan ( x )
Devuelve el arco tangente de x , en radianes.
math. atan2 ( y , x )
Devuelve atan(y / x) , en radianes. El resultado es entre -pi y pi
. El vector en el plano desde el origen hasta el punto (x, y) forma
este ángulo con el eje X positivo.
math. cos ( x )
Devuelve el coseno de x radianes.
math. hypot ( x , y )
Devuelva la norma euclidiana, sqrt(x*x + y*y) . Esta es la longitud del
vector desde el origen hasta el punto (x, y) .
math. sin ( x )
Devuelve el seno de x radianes.
math. tan ( x )
Devuelve la tangente de x radianes.
math. degrees ( x )
Convertir el ángulo x de radianes a grados.
math. radians ( x )
Convertir el ángulo x de grados a radianes.
math. acosh ( x )
Devuelve el coseno hiperbólico inverso de x .
math. asinh ( x )
Devuelve el seno hiperbólico inverso de x .
math. atanh ( x )
Devuelve la tangente hiperbólica inversa de x .
math. cosh ( x )
Devuelve el coseno hiperbólico de x .
math. sinh ( x )
Devuelve el seno hiperbólico de x .
math. tanh ( x )
Devuelve la tangente hiperbólica de x .

Modulo Math Funciones Especiales y constantes
math. pi
La constante matemática π = 3.141592…, hasta la precisión
disponible.
math. e
La constante matemática e = 2.718281…, a la precisión disponible.
math. tau
La constante matemática τ = 6.283185…, a la precisión disponible.
Tau es una constante de círculo igual a 2 π , la relación de la
circunferencia de un círculo a su radio. Para obtener más información
sobre Tau, echa un vistazo al video Pi de Vi Hart (aún) está equivocado
, ¡y comienza a celebrar el día de Tau comiendo el doble de pastel!
Nuevo en la versión 3.6.
math. inf
Un infinito positivo de punto flotante. (Para infinito negativo, use -
math.inf .) Equivalente a la salida de float('inf') .
Nuevo en la versión 3.5.
math. nan
Un valor de punto flotante "no es un número" (NaN). Equivalente a
la salida de float('nan') .

Una función, es la forma de agrupar expresiones y sentencias (algoritmos) que realicen
determinadas acciones, pero que éstas, solo se ejecuten cuando son llamadas. Es decir,
que al colocar un algoritmo dentro de una función, al ejecutar el archivo, el algoritmo no
será ejecutado si no se ha hecho una referencia a la función que lo contiene.
Las funciones en Python, y en cualquier lenguaje de programación, son estructuras esenciales de
código. Una función es un grupo de instrucciones que constituyen una unidad lógica del programa y
resuelven un problema muy concreto.

En Python constituyen unidades lógicas de un programa y tienen un doble objetivo:
•Dividir y organizar el código en partes más sencillas.
•Encapsular el código que se repite a lo largo de un programa para ser reutilizado.
Objetivo de las Funciones
Python ya define de serie un conjunto de funciones que podemos utilizar directamente en nuestras aplicaciones. Por
ejemplo, la función len(), que obtiene el número de elementos de un objeto contenedor como una lista, una tupla, un
diccionario o un conjunto. También hemos visto la función print(), que muestra por consola un texto.
Sin embargo, se puede definir propias funciones para estructurar el código de manera que sea más legible y para reutilizar
aquellas partes que se repiten a lo largo de una aplicación. Esto es una tarea fundamental a medida que va creciendo el
número de líneas de un programa.

Funciones en Python
En principio, un programa es una secuencia ordenada de instrucciones que se ejecutan una a
continuación de la otra. Sin embargo, cuando se utilizan funciones, se puede agrupar parte de esas
instrucciones como una unidad más pequeña que ejecuta dichas instrucciones y suele devolver un
resultado.

En Python, la definición de funciones se realiza mediante la instrucción def más un nombre de función descriptivo -para el cuál,
aplican las mismas reglas que para el nombre de las variables- seguido de paréntesis de apertura y cierre. Como toda
estructura de control en Python, la definición de la función finaliza con dos puntos (:) y el algoritmo que la compone, irá
identado con 4 espacios:
En último lugar y de manera opcional, se añade la instrucción con la palabra reservada
return para devolver un resultado.

Cuando acaba la última instrucción de una función, el flujo del programa continúa por la instrucción que sigue a la llamada de dicha
función. Hay una excepción: usar la sentencia return. return hace que termine la ejecución de la función cuando aparece y el programa
continúa por su flujo normal.
Además, return se puede utilizar para devolver un valor.
La sentencia return es opcional, puede devolver, o no, un valor y es posible que aparezca más de una vez dentro de una misma función.
En Python, es posible devolver más de un valor con una sola sentencia return. Por defecto, con return se puede devolver una tupla de
valores. Un ejemplo sería la siguiente función cuadrado_y_cubo() que devuelve el cuadrado y el cubo de un número:

Python, a diferencia de otros lenguajes de programación, no tiene procedimientos. Un procedimiento sería como
una función pero que no devuelve ningún valor.
¿Por qué no tiene procedimientos si hemos vistos ejemplos de funciones que no retornan ningún valor? Porque
Python, internamente, devuelve por defecto el valor None cuando en una función no aparece la sentencia return o
esta no devuelve nada.

Es importante tomar en cuenta que, por defecto, los valores de los
argumentos se asignan a los parámetros en el mismo orden en el que los
pasas al llamar a la función. Pero veremos que esta circunstancia puede
cambiar.
¿Qué es un parámetro y un argumento en Python?
En la definición de una función los valores que se reciben se
denominan parámetros, pero durante la llamada los valores que se envían se
denominan argumentos.

Tal como se ha indicado, una función puede definir, opcionalmente, una secuencia de parámetros con los que
invocarla. ¿Cómo se asignan en Python los valores a los parámetros? ¿Se puede modificar el valor de una
variable dentro de una función?
Antes de contestar a estas dos preguntas, tenemos que conocer los conceptos de programación paso por
valor y paso por referencia.
•Paso por valor: Un lenguaje de programación que utiliza paso por valor de los argumentos, lo que realmente
hace es copiar el valor de las variables en los respectivos parámetros. Cualquier modificación del valor del
parámetro, no afecta a la variable externa correspondiente.
•Paso por referencia: Un lenguaje de programación que utiliza paso por referencia, lo que realmente hace es
copiar en los parámetros la dirección de memoria de las variables que se usan como argumento. Esto implica
que realmente hagan referencia al mismo objeto/elemento y cualquier modificación del valor en el parámetro
afectará a la variable externa correspondiente.
Muchos lenguajes de programación usan a la vez paso por valor y por referencia en función del tipo de la
variable. Por ejemplo, paso por valor para los tipos simples: entero, float, … y paso por referencia para los
objetos.
Sin embargo, en Python todo es un objeto. Entonces, ¿cómo se pasan los argumentos en Python, por valor o por
referencia? Lo que ocurre en Python realmente es que se pasa por valor la referencia del objeto ¿Qué implicaciones
tiene esto? Básicamente que si el tipo que se pasa como argumento es inmutable, cualquier modificación en el valor
del parámetro no afectará a la variable externa pero, si es mutable (como una lista o diccionario), sí se verá afectado
por las modificaciones. Así que, ¡¡¡cuidado!!!

Parámetros por Defecto.- Son aquellos que pueden tener un valor inicial que pueden ser tomados cuando la función
es invocada.
Orden de los Parámetros.- Pyhton respeta el orden de los parámetros tomando en cuenta el orden de los argumentos
Número variable de parámetros.- Se puede invocar a una función con un numero indeterminado de parámetros, este
parámetro recibe los datos en una estructura compuesta llamada tupla

Un espacio de nombres es una colección aislada de nombres (o identificadores) que referencian a objetos. Como
veremos a continuación, en un mismo script o programa Python pueden coexistir varios espacios de nombres a la vez.
Cuando accedemos a un intérprete de Python o ejecutamos un programa, todos los identificadores que define el
lenguaje son añadidos a un espacio de nombres al que es posible acceder desde cualquier punto de un script. Es por
esto que las funciones como print() o len() están siempre accesibles. Este espacio de nombres es conocido como
espacio de nombres incorporado (o built-in namespace)
Además, cada módulo en Python crea su propio espacio de
nombres global. Los espacios de nombres están aislados.
Esa es la razón por la que en diferentes módulos se pueden
usar los mismos nombres y estos no interfieren entre sí.
A su vez, en un módulo existen funciones y clases. Cuando
se invoca a una función se crea un espacio de nombres
local asociado a dicha función que contiene todos los
nombres definidos dentro de la misma (sucede algo similar
para las clases).

En cualquier lenguaje de programación de alto nivel, toda variable está definida dentro
de un ámbito. Esto es, los sitios en los que la variable tiene sentido y dónde se puede
utilizar.
Los parámetros y variables definidos dentro de una función tienen un ámbito local, local
a la propia función. Por tanto, estos parámetros y variables no pueden ser utilizados
fuera de la función porque no serían reconocidos.
El ciclo de vida de una variable determina el tiempo en que una variable permanece en
memoria. Una variable dentro de una función existe en memoria durante el tiempo en
que está ejecutándose dicha función. Una vez que termina su ejecución, sus variables y
parámetros desaparecen de memoria y, por tanto, no pueden ser referenciados.
•Python distingue tres tipos de variables: las variables locales y dos tipos de variables
libres (globales y no locales):
• variables locales: las que pertenecen al ámbito de la subrutina (y que
pueden ser accesibles a niveles inferiores)
• variables globales: las que pertenecen al ámbito del programa principal.
• variables no locales: las que pertenecen a un ámbito superior al de la
subrutina, pero que no son globales.
Las variables definidas fuera de una función tienen un ámbito conocido
como global y son visibles dentro de las funciones, dónde solo se
puede consultar su valor.

Un ámbito define los límites de un programa en los que un espacio de nombres puede ser accedido sin utilizar un
prefijo.
Existen, como mínimo, tres ámbitos. Uno por cada espacio de nombres:
•Ámbito de la función actual, que tiene los nombres locales a la función.
•Ámbito a nivel de módulo, que tiene los nombres globales, los que se definen en el propio módulo.
•Ámbito incorporado, el más externo, que tiene los nombres que define Python.
Cuando desde dentro de una función se hace referencia a un nombre, este se busca en primer lugar en el espacio de
nombres local, luego en el espacio de nombres global y finalmente en el espacio de nombres incorporado.
Si hay una función dentro de otra función, se anida un nuevo ámbito dentro del ámbito local.
local, nonlocal y global en Python
Tenemos una variable x que está definida en el espacio de nombres global, una variable y
definida en el espacio de nombres local de la función funcion_a y una variable z que está
definida en el espacio de nombres local de la función funcion_b.
Dentro de la función funcion_b. La variable z es local (está en el ámbito local), y es no local y ;
x es global. Esto quiere decir que podemos acceder y modificar la variable z pero solo
podemos consultar el valor de x e y puesto que se encuentran en un ámbito diferente al
nuestro.
Si dentro de la función funcion_b asignamos un valor a una variable y, realmente estamos
creando una nueva variable en nuestro espacio de nombres local. Esta variable es diferente a
la variable no local y que está definida en la función funcion_a. Lo mismo ocurriría con la
variable global x.
Para poder modificar la variable x dentro de funcion_b, debemos definir la variable como
global. Y para modificar la variable y, hay que definirla como nonlocal.

VARIABLES LOCALES
Si no se han declarado como globales o no locales, las variables a las que se asigna valor en una función se consideran variables locales, es decir, sólo
existen en la propia función, incluso cuando en el programa exista una variable con el mismo nombre, como muestra el siguiente ejemplo:

VARIABLES LOCALES
Las variables locales sólo existen en la propia función y no son accesibles desde niveles superiores
Si en el interior de una función se asigna valor a una variable que no se ha declarado como global o no local, esa
variable es local a todos los efectos. Por ello el siguiente programa da error:

VARIABLES LIBRES GLOBALES O NO LOCALES
Si a una variable no se le asigna valor en una función, Python la considera libre y busca su valor en los niveles superiores de esa función,
empezando por el inmediatamente superior y continuando hasta el programa principal. Si a la variable se le asigna valor en algún nivel
intermedio la variable se considera no local y si se le asigna en el programa principal la variable se considera global
En el ejemplo siguiente, la variable libre "a" de la función subrutina() se considera global porque obtiene su valor del programa principal:

VARIABLES NO LOCALES
En el ejemplo siguiente, la variable libre "a" de la función sub_subrutina() se considera no local porque obtiene su valor de una función intermedia:

VARIABLES NO LOCALES
Si a una variable que Python considera libre (porque no se le asigna valor en la función) tampoco se le asigna valor en
niveles superiores, Python dará un mensaje de error.

Variables declaradas global o nonlocal
Si queremos asignar valor a una variable en una subrutina, pero no queremos que Python la considere local, debemos declararla en
la función como global o nonlocal,

El programa no llega a ejecutarse puesto que Python detecta un error de sintaxis.
•La variable "a" de la función subrutina() es una variable libre global. Es una variable libre porque no está definida en la
función. Python busca su valor en un nivel superior, que para esa función es el programa principal. En el programa
principal sí que hay una variable "a", por lo que la variable "a" de la función subrutina() se considera global. Python
tomaría su valor de la variable "a" del programa principal.
•La variable "a" de la función sub_subrutina() está declarada como nonlocal, por lo que Python busca su valor en una
función superior que no sea el programa principal. El problema es que la variable "a" de la función subrutina() es global,
así que Python no la puede tomar para dar valor a la variable "a" de la función sub_subrutina().
•Ante la imposibilidad de dar valor a la variable "a" de la función sub_subrutina() se produce un error de sintaxis.
Si a una variable declarada global o nonlocal en una función no se le asigna valor en el nivel superior correspondiente, Python dará un
error de sintaxis,
Variables declaradas global o nonlocal

Ejercicios
Ejercicio: Determinar la suma de los primeros “n” números naturales
Ejercicio: Determinar el producto de dos números de manera
recursiva
a = 0 0
b = 0 0
a = 1 b
b = 1 a
a + (a,b-1)
n = 1 1
n = 0 0
n+(n-1)
Determinar la potencia de un numero con funciones
recursivas
e = 0 1
e = 1 b
b(b,e-1)
2 *4 = 8
2 + 2 + 2 + 2 = 8
2* 0 = 0
0 * 2 = 0
1 * 2 = 2
2 * 1 = 2

Determinar la potencia de un numero con funciones
recursivas
e = 0 1
e = 1 b
b(b,e-1)
Ejercicio: Ingresar un numero y mostrar el numero de forma invertida ejemplo 123 – 321 ej:
81 18
2 ^3 = 2*2* 2 = 8

Ejercicios
Ejercicio: Ingresar un numero y mostrar el numero de forma invertida ejemplo 123
– 321
Ejercicio: Ingresar un numero y mostrar su equivalente en binario usando una
funcion recursiva

Manejo de excepciones en python
Crear software es una tarea abrumadora. Para mejorar su software, su aplicación debe continuar funcionando en
circunstancias imprevistas. Por ejemplo, suponga que su aplicación necesita obtener información de Internet.
¿Qué sucede si la persona que usa la aplicación pierde su conexión a Internet?
Otro problema común es qué hacer si el usuario ingresa una entrada no válida. O intente abrir un archivo que su
aplicación no admita.
Todas estas situaciones se pueden manejar usando las capacidades integradas de manejo de excepciones de
Python. Estas características generalmente son try cuando except declaración.
Comencemos por comprender algunas de las excepciones más comunes.

La rama try-except
En el mundo de Python, hay una regla que dice: "Es mejor pedir perdón que pedir permiso".
En realidad, la regla dice: "es mejor manejar un error cuando ocurre que tratar de evitarlo".
"De acuerdo," puedes decir, "pero ¿cómo debo pedir perdón cuando el programa finaliza y no queda nada que más por
hacer?" Aquí es donde algo llamado excepción entra en escena.
Puedes ver dos bloques aquí:
•El primero, comienza con la palabra clave reservada try este es el lugar donde se coloca el código que se sospecha que es riesgoso y puede
terminar en caso de un error; nota: este tipo de error lleva por nombre excepción, mientras que la ocurrencia de la excepción se le
denomina generar - podemos decir que se genera (o se generó) una excepción;
•El segundo, la parte del código que comienza con la palabra clave reservada except esta parte fue diseñada para manejar la excepción; depende
de ti lo que quieras hacer aquí: puedes limpiar el desorden o simplemente puede barrer el problema debajo de la alfombra (aunque se prefiere la
primera solución)
Entonces, podríamos decir que estos dos bloques funcionan así:
•La palabra clave reservada try marca el lugar donde intentas hacer algo sin permiso;
•la palabra clave reservada except comienza un lugar donde puedes mostrar tu talento para disculparte o pedir perdón.
Como puedes ver, este enfoque acepta errores (los trata como una parte normal de la vida del programa) en lugar de intensificar los esfuerzos para
evitarlos por completo.

Excepción más común en python
Python admite muchas excepciones diferentes. A continuación se muestra una lista de sugerencias que puede ver cuando
comience a usar el lenguaje.
Exception – Excepciones básicas en las que se basa todo lo demás
AttributeError – Ocurre cuando una asignación o referencia de propiedad falla.
ImportError Ocurre cuando la instrucción -import no puede encontrar una definición de módulo, o… import no puede encontrar el
nombre para importar.
ModuleNotFoundError – Subclase de ImportError causada por la importación cuando no se encuentra el módulo
IndexError – Ocurre cuando el índice de secuencia está fuera de los límites.
KeyError – Ocurre cuando una clave de mapa (diccionario) no se puede encontrar en un conjunto de claves existente.
KeyboardInterrupt – Ocurre cuando el usuario presiona la tecla de pausa (generalmente) Control-C Devolver a Delete).
NameError – Ocurre cuando no se puede encontrar un nombre local o global.
OSError – Ocurre cuando una función devuelve un error relacionado con el sistema.
RuntimeError– Se produce cuando se detecta un error que no encaja en ninguna de las otras categorías.
SyntaxError – Se produce cuando se produce un error de sintaxis en el analizador.
TypeError – Ocurre cuando se aplica una acción o función a un objeto del tipo incorrecto. El valor asociado es una cadena que
detalla la discrepancia de tipo.
ValueError – Se produce cuando una operación o función integrada es del tipo correcto pero recibe un argumento con un valor
incorrecto y la situación no se describe mediante una excepción más precisa, como IndexError.
ZeroDivisionError – Ocurre cuando el segundo argumento de una operación de división o módulo es cero.
Puede encontrar la documentación de Python aquí para obtener una lista completa de las excepciones integradas.
https://docs.python.org/3/library/exceptions.html..

Las excepciones en Python son una herramienta
muy potente que la gran mayoría de lenguajes de
programación modernos tienen. Se trata de una
forma de controlar el comportamiento de un
programa cuando se produce un error.
Esto es muy importante ya que salvo que tratemos
este error, el programa se parará, y esto es algo que
en determinadas aplicaciones no es una opción
válida.
Imaginemos que tenemos el siguiente código con
dos variables a y b y realizamos su división a/b.
Pero imaginemos ahora que por cualquier motivo las
variables tienen otro valor, y que por ejemplo b tiene
el valor 0. Si intentamos hacer la división entre cero,
este programa dará un error y su ejecución terminará
de manera abrupta.
Ese “error” que decimos que ha ocurrido es lanzado por Python (raise
en Inglés) ya que la división entre cero es una operación que
matemáticamente no está definida.
Se trata de la excepción ZeroDivisionError.
¿Que pasaría si intentásemos sumar un número con un texto? Evidentemente esto no tiene ningún sentido, y
Python define una excepción para esto llamada TypeError.
En base a esto es muy importante controlar las excepciones, porque por muchas comprobaciones que realicemos es
posible que en algún momento ocurra una, y si no se hace nada el programa se parará.

Podemos realizar una comprobación manual de que no estamos dividiendo por
cero, para así evitar tener un error tipo ZeroDivisionError.
Sin embargo es complicado escribir código que contemple y que prevenga todo
tipo de excepciones. Para ello, veremos más adelante el uso de except.
Uso de raise
También podemos ser nosotros los que levantemos o lancemos una
excepción. Volviendo a los ejemplos usados, podemos ser nosotros los
que levantemos ZeroDivisionError o NameError usando raise. La
sintaxis sería
Visto esto, ya sabemos como una excepción puede ser lanzada. Existen dos maneras principalmente:
• Hacemos una operación que no puede ser realizada (como dividir por cero). En este caso Python se encarga de lanzar
automáticamente la excepción.
• O también podemos lanzar nosotros una excepción manualmente, usando raise.
• Habría un tercer caso que sería lanzar una excepción que no pertenece a las definidas por defecto en Python.
A continuación veremos que podemos hacer para controlar estas excepciones, y que hacer cuando se lanza una para que no se
interrumpa la ejecución del programa.

Las excepciones que hemos visto antes, pueden ser capturadas y manejadas adecuadamente, sin que el programa se
detenga. Veamos un ejemplo con la división entre cero.
Lo que hay dentro del try es la sección del código que podría lanzar la excepción que se
está capturando en el except. Por lo tanto cuando ocurra una excepción, se entra en el
except pero el programa no se para.
También se puede capturar diferentes excepciones como
se ve en el siguiente ejemplo.
Se puede también hacer que un determinado número de
excepciones se traten de la misma manera con el mismo
bloque de código. Sin embargo suele ser más interesante
tratar a diferentes excepciones de diferente manera.
Otra forma si no sabe que excepción puede saltar, se
puede usar la clase genérica Exception. En este caso se
controla cualquier tipo de excepción. De hecho todas las
excepciones heredan de Exception.

No obstante hay una forma de saber que excepción ha sido la que ha
ocurrido
Uso de else
Al ya explicado try y except le podemos añadir un bloque más, el else.
Dicho bloque se ejecutará si no ha ocurrido ninguna excepción. Fíjese
en la diferencia entre los siguientes códigos.
Sin embargo en el siguiente código la división se puede realizar sin
problema, por lo que el bloque except no se ejecuta pero el else si es
ejecutado.

Uso de finally
A los ya vistos bloques try, except y else podemos añadir un bloque
más, el finally. Dicho bloque se ejecuta siempre, haya o no haya habido
excepción.
Este bloque se suele usar si queremos ejecutar algún tipo de acción de
limpieza. Si por ejemplo estamos escribiendo datos en un fichero pero
ocurre una excepción, tal vez queramos borrar el contenido que hemos
escrito con anterioridad, para no dejar datos inconsistentes en el
fichero.

¿Cuál es la salida del siguiente programa si el usuario ingresa un 0?
try:
value = int(input("Ingresa un número entero: "))
print(value/value)
except ValueError:
print("Entrada incorrecta...")
except ZeroDivisionError:
print("Entrada errónea...")
except:
print("¡Buuuu!")
value = input("Ingresa un número entero: ")
print(10/value)
¿Cuál es la salida del siguiente programa si el usuario ingresa un 0?

Introducción a las matrices en Python
La matrices no son una estructura propia de Python. Simplemente, una matriz
es una lista de listas que nosotros interpretamos desde el punto de vista
matemático. Es decir, la estructura m = [[1,2],[3,4]] nosotros la interpretamos
como la matriz 2x2 cuya primera fila es (1,2) y cuya segunda fila es (3,4), pero
esto no deja de ser una interpretación.

Introducción a las matrices en Python
Pasos para crear una matriz en Pyhton:
1. Crear una Matriz Vacia o una lista con sublistas
f,c=4,4
matriz=[]
for i in range(f):
matriz.append([0]*c)
print(matriz1)
2. Llenamos la matriz
contador=2
for i in range(f):
for j in range(c):
matriz1[i][j]=contador
contador+=2
print(matriz1)
3. Visualizamos los datos como matriz
for i in matriz1:
print (i)
Defina las siguientes funciones:
• creaMatriz(n,m)
• llenaMatriz(matriz,dato)

En Pyhton existen errores de tipo sintácticos, de tipo en tiempo de ejecución y semanticos
Errores en tiempo de Ejecucion Excepiones
En este caso Python compila y ejecuta el programa pues no hay errores de sintaxis
Si el programa arroja una excepción en este caso pyton imprime un mensaje que incluye el nombre
de la excepción. Este error se lo conoce como TraceBack

Aprendizaje de Lenguaje de Programación Python

Más contenido relacionado

Similar a Aprendizaje de Lenguaje de Programación Python (20)

Más de Cesar Oswaldo Osorio Agualongo (20)

Último (20)

Aprendizaje de Lenguaje de Programación Python

Notas del editor