---

Escuela de Ingeniería de Sistemas y Computación

Universidad del Valle

INTRODUCCIÓN A LA PROGRAMACIÓN PARA ANALÍTICA

Profesor: Ph.D, Robinson Duque ([email protected])

Última modificación: Julio de 2020

---

# Consideraciones:

Parte de los textos y ejemplos incluidos en este notebook de fundamentación en programación

para Python fueron tomados y ajustados de los libros:

* [Python para Todos](http://www.utic.edu.py/citil/images/Manuales/Python_para_todos.pdf) de

Raúl González Duque. La obra está bajo una licencia Creative Commons (Reconocimiento) 2.5 que
permite: copiar, distribuir y comunicar públicamente la obra, hacer obras derivadas, bajo la
condicion de reconocer y dar crédito al autor original (Raúl González Duque).

* [Manual de Python](https://aprendeconalf.es/python/manual/) de Alfredo Sánchez Alberca. La

obra está bajo una licencia Atribución–No comercial–Compartir igual 4.0 Internacional de Creative
Commons que permite: copiar y redistribuir el material en cualquier medio o formato, remezclar,
transformar y construir a partir del material.

Este material presenta cambios dirigidos hacia textos orientados a la versión 3.0 de Python, para lo
cual se han incluido nuevos ejemplos y se proponen ejercicios para validar los conocimientos de
los estudiantes orientados al propósito del curso de _Introducción a la Programación para
Analítica_ de la Universidad del Valle.

# Hola, Python!

Algunas características antes de comenzar:

* Lenguaje de programación creado por Guido van Rossum (1990)

* Lenguaje de programación interpretado

* Tipado dinámico

* Fuertemente tipado

* Multiplataforma

* Orientado a objetos, programación (imperativa y funcional)

Principales Ventajas:

* Es de código abierto

* Es fácil de aprender gracias a que su sintaxis es bastante legible para los humanos

* Es un lenguaje maduro

* Es fácilmente extensible e integrable en otros lenguajes (C, java)

* Esta mantenido por una gran comunidad de desarrolladores y hay multitud de recursos para su
aprendizaje

# Uso de Comentarios:

> Antes de discutir cómo escribir programas con Python, es importante comprender la sintaxis que
le permite agregar comentarios a su código. Dado que el código de la computadora puede ser
difícil de entender, los comentarios son útiles para ayudar a escribir el significado y el propósito de
su código.

En Python, el texto se marca como comentario poniéndolo después del símbolo `#`. Todo, desde el
`#` hasta el final de la línea, es un comentario y no será tenido en cuenta por el interpretador de
Python. Ejemplo:

# hola esto es un comentario

# Puedes ejecutar esta celda presionando las teclas Shift+Enter y las líneas comentadas serán
ignoradas...

print("Hola, Python!") #Esta función permite 'imprimir' mensajes y valores

# Definición de Variables

> Dado que los programas en computadora implican trabajar con mucha información, se necesita
una forma de almacenar y consultar esa información. Esto se logra con **variables**:
> - En Python, puede pensar en ellas como en "cajas" que se referencian con "etiquetas" o
"identificadores" para almacenar datos. Después de colocar los datos en una "caja", puede hacer
referencia a esos datos por la "etiqueta" definida.

> - Los nombres de variables pueden contener cualquier combinación de letras, números, puntos o
guines bajos

( \_ ), aunque deben comenzar con una letra y no utilizar caracteres especiales.

>

>_Importante:_ Los nombres de las variables distinguen entre mayúsculas y minúsculas. Es una
buena práctica hacer que los nombres de las variables sean informativos sobre los datos que
contienen.

# Ejemplos de variables válidas

nombre = "Robinson"

print(nombre)

x=9

y = x*2

print(x)

print(y)

x = 4.5

print(x)

# Ejemplos de variables no permitidas

x5 = 9

preciocantidad = 8

# Otros ejemplos con variables

lenguaje = 'Python'

x=2

x += 3.14

print(x)
# Tipos Básicos

>En Python los tipos básicos (primitivos) y se dividen en:

>

> * **Números**: 10 (entero), 15.57 (de coma flotante) o 7 + 5j (complejos)

> * **Cadenas de texto**: "Hola Mundo"

> * **Booleanos**: `True` (cierto) y `False` (falso).

>

>También existen tipos de datos compuestos (llamados colecciones o contenedores)

>

> * **Listas**: Colección de objetos, secuencia ordenada (distintos tipos). `[3, "manzana", 4,
True]`.

> * **Tuplas**: Colección de objetos, secuencia ordenada (distintos tipos). `(3, "manzana", 4,
True)`.

> * **Diccionarios**: Colecciones de objetos con una clave asociada. Por ejemplo: `{"pi":3.1416,
"e":2.718}`.

>

>**Objetos mutables:** Listas y Diccionarios

>

>**Objetos inmutables:** Números, cadenas, booleanos y tuplas

>

> |Categoría| Tipo|

|----|----|

|Tipo Texto (String):| str|

|Tipo numérico:| int, float, complex|

|Tipo Secuencia:| list, tuple, range|

|Tipo Mapeo:| dict|

|Tipo Booleano:| bool|

>
>|Ejemplo| Tipo de Dato|

|---|---|

|x = "Hello World"| str|

|x = 20|int|

|x = 20.5| float|

|x = 1j| complex |

|x = ["apple", "banana", "cherry"]| list|

|x = ("apple", "banana", "cherry")|tuple|

|x = range(6)| range|

|x = {"name" : "John", "age" : 36}| dict|

|x = True| bool|

# Espacio para ejemplos de asignación de variables a distintos tipos

pass

# Espacio para ejemplos de verificación de tipos utilizando 'type'

pass

# Números

> ## Operadores aritméticos

> |Operador|Nombre|Descripción|

|---|---|---|

|a + b| Suma| Suma de `a` y `b`|

|a - b| Resta|Diferencia de `a` y `b`|

|a * b| Multiplicación| Producto de `a` y `b`|

|a / b| División| Cociente de `a` y `b`|

|a // b|Division piso (entera)| Cociente de `a` y `b`, removiendo la parte fracción|

|a % b| MóduloEntero| Residuo de la división de `a` en `b`|

|a ** b| Exponenciación| `a` elevado a la potencia de `b`|

|-a |Negación| La negación de `a`|

>

> ## Prioridad de la evaluación

Es importante tener presente el orden en que se realizan las operaciones en Python para evitar
errores a la hora de implementar programas:

>

>|Orden|Operador|

|---|---|

|1| Parentesis `()`|

|2| Exponentes `**`|

|3| Multiplicaciones y Divisiones `(*, /, //, %)`|

|4| Sumas y restas `(+,-)`|

# Espacio para ejemplos con operadores para Números (int, float, complex)

x=5

y=7

z = y%x

print(z)

w = x ** 2

print(w)

g = 10//3

print(g)

l = None

print(l)

print(type(l))

print(3+4*5)
print( (3+4)*5 )

print( 10/2*3 )

print( 3+4+2*2+4+5*7+9/3 )

# Ejemplo: Cálculo del IVA al precio de un producto utilizando variables y asignación.

Precio = 500 # Precio es una variable a la que se le ha asignado un valor numérico

IVA = Precio * 0.19 # Aquí se calcula el Impuesto y se asigna en la variable IVA

# Si presionas Shift+Enter se realizan los cálculos pero no se ve ningún resultado.

# Esto sucede porque no hay una instrucción que permita ver o 'imprimir' los valores contenidos
en las variables.

# Descomenta las tres líneas que aparecen abajo y presiona Shift+Enter:

print("Precio del producto: ",Precio)

print("IVA calculado: ",IVA)

print("TOTAL", Precio + IVA)

Precio = int( input("Ingrese el precio del producto:") )

IVA = Precio * 0.19

print("Precio del producto: ",Precio)

print("IVA calculado: ",IVA)

print("TOTAL", Precio + IVA)

---

# Booleanos

> `True` (cierto) y `False` (falso). Estos valores son especialmente importantes para las expresiones
condicionales y los bucles, como veremos más adelante.

>

> ## Operadores lógicos

>

> |Operador|Descripción|Ejemplo|

|---|---|---|

|and |¿se cumple `a` y `b`?| `r = (True and False) # r es False`|

|or |¿se cumple `a` o `b`?| `r = (True or False) # r es True`|

|not |Negación de `a`|`r = not True # r es False`|

>

> ## Tabla de verdad

>

>|x| y| not x| x and y| x or y|

|---|---|---|---|---|

|False| False| True| False| False|

|False| True| True| False| True|

|True| False| False| False| True|

|True| True| False| True| True|

>

> ## Operadores relacionales

>

> |Operador| Descripción| Ejemplo|

|---|---|---|

|== |¿son iguales `a` y `b`?| `r= (5==3) # r es False` |

|!= |¿son distintos `a` y `b`?| `r= (5!=3) # r es True`|

|< |¿es `a` menor que `b`?| `r= (5<3) # r es False`|

|<= |¿es `a` menor o igual que `b`?| `r= (5<=5) # r es True`|

|> |¿es `a` mayor que `b`?| `r= (5>3) # r es True`|

|>= |¿es `a` mayor o igual que `b`?| `r= (5>=3) # r es True`|

l = True
c = True

d = not l and c

print(d)

#d = l or c

#print(d)

P1 = False

P2 = False

P3 = int(P1) + int(P2)

P4 = (P3==1)

print(P4)

x=9

y=3

z = (x!=y)

w = (x>=y)

print(z)

print(w)

# Ejemplos de creación de variables booleanas

pass

# Ejemplos del uso de operadores lógicos y tablas de verdad (and, or, not)

pass

# Ejemplos de operadores relacionales (<,>,<=,>=,==,!=)

pass
> ## Operadores a Nivel de Bit (o Elemento a Elemento)

> Estos operadores pueden ser utilizados a nivel de bit para comparar lógicamente ("bit a bit") dos
números. Por ejemplo, si veis una operación como 3 & 2, lo que estas viendo es un `and` bit a bit
entre los números binarios 11 y 10 (las representaciones en binario de 3 y 2).

>

> Sin embargo, en este curso los utilizaremos principalmente para realizar operaciones lógicas
(`and, or, xor`) similares a las que vimos arriba para encontrar el valor de verdad de una expresión
o variable booleana. Pero adicionalmente, nos permitirán operar arreglos con valores booleanos
`True` o `False` "elemento a elemento" (que veremos en detalle más adelante en el curso).

>

> |Operador|Descripción|Ejemplo|

|---|---|---|

|& |and| `r = (True & False) # r es False`|

|\| |or | `r = (True \| False) # r es True`|

|^ |xor|r = `not True # r es False`|

|~ |not|r = `not True # r es False`|

# Ejemplos de operadores a nivel de bit - Utilizando booleanos

pass

P1 = False

P2 = False

Vivo = (P1 ^ P2)

print(Vivo)

# Este ejemplo lo pongo simplemente para mostrar las operaciones sobre arreglos

# "elemento a elemento" que retomaremos más adelante en el curso. Por ahora sólo

# ejecutalo para analizar los resultados.

import numpy as np

a = np.array([True, True, False, True])

b = np.array([True, False, True, False])

c=a&b

print(c)

---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

Cuál es el resultado de ejecutar: (4*2+10//3)

a)10

b)11

c)10.3

d)11.3

e)6

-->

2. Oculta aquí (TF).

<!--

Cuál es el valor de la variable w después de ejecutar:

x = True

y = False

z = (5>3)

w = (x or y) and z

a)True

b)False

-->

---

# Cadenas
> Las cadenas `str` no son más que texto encerrado entre comillas simples (\'cadena\'), dobles
("cadena"), o triples ("""cadena""").

>

> ## Operadores Para Cadenas

>

> * Concatenación: `c1 + c2`

> * Repetición: `c1 * int`

> * ¿`c1` pertenece a `c2`?: `c1 in c2`

> * ¿`c1` no pertenece a `c2`?: `c1 not in c2`

> * ¿`c1` igual a `c2`?: `c1 == c2`

> * ¿`c1` diferente de `c2`?: `c1 != c2`

> * ¿`c1` sucede a `c2`?: `c1 > c2` (también con `>=`)

> * ¿`c1` antecede a `c2`?: `c1 < c2` (también con `<=`)

x = "Hola estudiantes\nde \t\tprogramación"

print(x)

y = """¿Hola amigos

como

están?"""

print(y)

edad = 37

direccion = "Calle 12B # 1 1"

cadena = "Hola, tengo "+str(edad)+" años y vivo en "+direccion

print(cadena)

texto2 = "Hola, tengo {} años y vivo en {} ".format(edad,direccion)

print(texto2)

edad = 37

direccion = "Calle 12B # 1 1"

nombre = "Robinson"

texto2 = "Hola, tengo {0} años. Repito, tengo {0} años y me llamo {1} y vivo en {2}
".format(edad,nombre,direccion)
print(texto2)

x = "Python"

y = x *3

print(y)

y = "Hola, tengo 37 años. Repito, tengo 37 años y me llamo Robinson y vivo en Calle 12B # 1 1 "

x = "37" not in y

print(x)

x = "Hola"

y = "hola"

z = (x==y)

print(z)

a = "a"

b = "A"

c = a>b

print(c)

# Ejemplo de cadena con comilla simple

pass

# Ejemplo de cadena con comilla doble

pass

# Ejemplo de cadena con comilla triple

pass

# Ejemplo de cadena con caracteres especiales "\n", "\t"

pass
# Ejemplo de concatenación

pass

# Ejemplo de repetición

pass

# Ejemplos de pertenencia, no pertenencia, igualdad, diferencia...

pass

> ## Slicing

> Cada carácter tiene asociado un índice que permite acceder a él:

>

>|Cadena|P|y|t|h|o|n|

|----|---|---|---|---|---|---|

|Indice positivo|0|1|2|3|4|5|

|Indice negativo|-6|-5|-4|-3|-2|-1|

>

>El índice del primer carácter de la cadena es `c[0]` y no `c[1]`.

>

>También se pueden utilizar índices negativos para recorrer la cadena del final al principio.

# Ejemplos con índices positivos y negativos

t = "Python"

print(t[0])

print(t[2])

print(t[-1])

> También es posible obtener subcadenas utilizando `c[inicio:fin]` o `c[inicio:fin:salto]`. Devuelve la

subcadena de `c` desde el carácter con el índice `inicio` hasta el carácter anterior al índice `fin`,
tomando caracteres cada `salto`.
# Ejemplos de slicing utilizando c[inicio:fin] y c[inicio:fin:salto]

t = "Python sirve para programar con datos"

print(t[0:3])

print(t[2:])

print(t[3:20])

print(t[3:20:2])

print(t[::-1])

> ## Métodos para strings

>

> * `c.upper( )` : Devuelve la cadena con los mismos caracteres que la cadena `c` pero en
mayúsculas.

> * `c.lower( )` : Devuelve la cadena con los mismos caracteres que la cadena `c` pero en
minúsculas.

> * `c.title( )` : Devuelve la cadena con los mismos caracteres que la cadena `c` con el primer
carácter en mayúsculas y el resto en minúsculas.

> * `c.split(delimitador)` : Devuelve la lista formada por las subcadenas que resultan de partir la
cadena `c` usando como `delimitador` la cadena delimitador. Si no se especifica el delimitador
utiliza por defecto el espacio en blanco.

> * `c.count( str )` : Cuenta la ocurrencia del string `str` dentro de la cadena `c`.

> * `c.find( str )` : Busca dentro del string `c` la letra o palabra `str` y retorna el índice desde donde
la puedes encontrar.

> * `c.replace( old, new)` : Reemplaza un string `old` por otro `new` dentro del string `c`.

> * `c.format(valores)`: Devuelve la cadena `c` tras sustituir los valores de la secuencia valores en
los marcadores de posición de `c`. Los marcadores de posición se indican mediante llaves`{}` en la
cadena `c`.

>

>

> Ver todos los métodos utilizando `?` o `help( )`

>

> ## Built-in Functions (Strings)

> Existen también algunas funciones predefinidas en Python para strings que podrán ser de mucha
utilidad, quizá las que más usaremos son:

>

> * `len( c )`: permite retornar la longitud de un string `c`

> * `str( c )`: convierte un objeto `c` a su representación `str`

> * `min( c )`: retorna el carácter menor de la cadena `c`

> * `max( c )`: retorna el carácter mayor de la cadena `c`

x = "Hola python, es un buen lenguaje"

y = x.title()

print(y)

x = "Hola python, es un buen lenguaje"

y = x.split(" ")

print(y)

x = "Hola python, es un buen lenguaje"

y = x.count(" ")

print(y)

x = "Hola python, es un buen lenguaje"

y = x.find("es")

print(y)

print(x[13:15])

x = "Hola python, es un buen lenguaje"

y = x.replace("python","R")

print(y)

x = "Hola "

y = len(x)
print(y)

---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

Cuál es el resultado de ejecutar:

x = "Bienvenidos"

print(x[3::2])

a)ineio

b)neio

c)ineios

d)neios

e)Bevnds

-->

2. Oculta aquí (MC).

<!--

Cuál es el valor de la variable 'y' después de ejecutar:

x = "Hola"

y = x * len( x.upper() )

a) "HolaHolaHolaHola"

b) "Hola + Hola + Hola + Hola"

c) "HOLAHOLAHOLAHOLA"

d) "HOLA + HOLA + HOLA + HOLA"

e) "HOLA4"

-->

---

### Accediendo Documentación con `?` y la función `help`

> El lenguaje Python y su ecosistema para para ciencia de datos están desarrollados pensando en
el usuario. Cada objeto continen una referencia a un string que se conoce como **docstring** y en
la mayoría de casos contiene información resumida del objeto y cómo utilizarlo. También es
posible acceder al docstring utilizando la función `help`

>

> Es posible acceder a las funciones disponibles de algunos objetos utilizando la notación punto "."
y presionando

la tecla "tabulador". Esto se denomina TAB COMPLETION y también funciona con variables u
objetos definidos dentro del script.

# Ejemplo de uso de '?' y help

pass

# Conversion de tipos de datos primitivos

> Las siguientes funciones convierten un dato de un tipo en otro, siempre y cuando la conversión
sea posible:

>

> * `int( )` convierte a entero.

> * `float( )` convierte a real.

> * `str( )` convierte a cadena.

> * `bool( )` convierte a lógico

# Ejemplos de conversiones de tipos de datos

#x=int("9")

#type(x)

y = bool("hola")
print(y)

print(type(y))

# Listas

> Una lista es una secuencia ordenada de objetos de distintos tipos.

>

> Se construyen poniendo los elementos entre corchetes `[ ]` separados por comas.

>

>Se caracterizan por:

> * Tienen orden.

> * Pueden contener elementos de distintos tipos.

> * Son mutables, es decir, pueden alterarse durante la ejecución de un programa.

> * Al igual que los strings, se pueden acceder los elementos con índices (positivos o negativos)

> * Al igual que los strings, también se puede aplicar la operación **slicing**

l = ["hola", 1, 5, 7, True]

print(type(l))

print(l[0])

print(l[1])

y = not l[4]

print(y)

l = ["hola", 1, 5, 7, True, 6,7,8,9]

print(l[1:3])

print(l[-1])

print(l[::-1])

print(l[2:7:2])

l =[ [1,2,3,"a"],[6,True,4,3], "hola"]

print(l[0][3])

print(l[1][1])
# Ejemplos de listas y acceso con índices

pass

# Mostrar que cada elemento de la lista conserva su tipo (utilizando

# la función 'type' o accediendo a métodos específicos)

pass

# Ejemplos de slicing con listas

pass

> ## Modificación de una lista

> Podemos utilizar el operador `[ ]` para modificar un elemento de la lista si lo colocamos en la

parte izquierda de una asignación. Por ejemplo: `c[0] = 9`

l = list( range(1,20) )

print(l)

l[2] = -9

print(l)

l[4] = [-2,-3,-6]

print(l)

print(l[4][1])

> ## Funciones y métodos de listas

>

> * `len(l)` : Devuelve el número de elementos de la lista `l`.

> * `min(l)` : Devuelve el mínimo elemento de la lista `l` siempre que los datos sean comparables.

> * `max(l)` : Devuelve el máximo elemento de la lista `l` siempre que los datos sean comparables.

> * `sum(l)` : Devuelve la suma de los elementos de la lista `l`, siempre que los datos se puedan
sumar.

> * `all(l)` : Devuelve `True` si todos los elementos de la lista `l` son `True` y `False` en caso
contrario.
> * `any(l)` : Devuelve `True` si algún elemento de la lista `l` es `True` y `False` en caso contrario

> * `dato in l` : Devuelve `True` si el dato `dato` pertenece a la lista `l` y `False` en caso contrario.

> * `l.index(dato)` : Devuelve la posición que ocupa en la lista `l` el primer elemento con valor
`dato`.

> * `l.count(dato)` : Devuelve el número de veces que el valor `dato` está contenido en la lista `l`.

# Ejemplos de uso de funciones y métodos para listas

l = list(range(3,15))

print(l)

l[4]=-5

print(l)

m = min(l)

print(m)

ma = max(l)

print(ma)

s = sum(l)

print(s)

l[-1] = None

print(l)

print( all(l))

z = -5 in l

print(z)
ind = l.index(-5)

print(ind)

> Continuación:

>

> * `l1 + l2` : Crea una nueva lista concatenan los elementos de la listas `l1` y `l2`.

> * `l.append(dato)` : Añade `dato` al final de la lista `l`.

> * `l.insert(índice, dato)` : Inserta `dato` en la posición `índice` de la lista `l` y desplaza los
elementos una posición a partir de la posición `índice`.

> * `l.remove(dato)` : Elimina el primer elemento con valor `dato` en la lista `l` y desplaza los que
están por detrás de él una posición hacia delante.

> * `l.pop([índice])` : Devuelve el dato en la posición `índice` y lo elimina de la lista `l`, desplazando
los elementos por detrás de él una posición hacia delante.

> * `l.sort()` : Ordena los elementos de la lista `l` de acuerdo al orden predefinido, siempre que los
elementos sean comparables.

> * `l.reverse()` : invierte el orden de los elementos de la lista `l`.

# Ejemplos de uso de funciones y métodos para listas

l1 = ["a", "b", "c"]

l2 = [1,3,4,7,8, True]

l3 = l1+l2

print(l3)

l1.append(9)

print(l1)

l1.insert(1, -8)

print(l1)

l1.remove("b")

print(l1)

valor=l1.pop(2)

print(l1)
print(valor)

> ## Copia de listas

>

>Existen dos formas de copiar listas:

>

> * **Copia por referencia** `l1 = l2`

> * **Copia por valor** `l1 = list(l2)`

# Ejemplos de copia por referencia y por valor de listas

l1 = [2,5,7,9]

l2 = l1

l1.append(-7)

print(l1)

print(l2)

l1 = [2,5,7,9,7,6,5,4,3]

l2 = l1[2:7]

print(l1)

print(l2)

l2[0]=-9

print(l1)

print(l2)

l1 = [2,5,7,9]

l2 = l1.copy()

l1.append(-7)

print(l1)

print(l2)

l = list(range(1000000000))

print("hola")

l2 = l1.copy()
---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = [1,2,3,4,5]

y = x[3] + x[1] * x[3]

a) 16

b) 20

c) 24

d) 12

e) 10

-->

2. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = [0,1,2,3,4,5,6,7,8]

y = x[5:9] + x[0:5]

a)[5, 6, 7, 8, 0, 1, 2, 3, 4, 5]

b)[5, 6, 7, 8, 9, 0, 1, 2, 3, 4]

c)[5, 6, 7, 8, 9, 1, 2, 3, 4, 5]

d)[5, 6, 7, 8, 0, 1, 2, 3, 4]
e)[1, 2, 3, 4, 5, 6, 7, 8, 0]

-->

---

# Tuplas

> Una tupla es una secuencia ordenada de objetos de distintos tipos.

>

> Se construyen poniendo los elementos entre paréntesis ( ) separados por comas.

>

>Se caracterizan por:

>

> * Tienen orden.

> * Pueden contener elementos de distintos tipos.

> * Son inmutables, es decir, no pueden alterarse durante la ejecución de un programa.

> * Al igual que los strings y las listas, se pueden acceder los elementos con índices (positivos o
negativos)

> * Al igual que los strings y las listas, también se puede aplicar la operación **slicing**

x = (2,5,7, "hola", True)

print(x[2:])

print(x.index("hola"))

type(x)

x = (2,5,7, "hola", [3,4])

print(x[4].append(5))

print(x)

x =[2,3,4]

print(x)

type(x)

x = ([1,2,3,[4,6,[9,1,2],8]], list(range(5)), True, "hola")

print(x)
> ## Funciones y métodos de tuplas

>

> * `len(t)` : Devuelve el número de elementos de la tupla `t`.

> * `min(t)` : Devuelve el mínimo elemento de la tupla `t` siempre que los datos sean comparables.

> * `max(t)` : Devuelve el máximo elemento de la tupla `t` siempre que los datos sean
comparables.

> * `sum(t)` : Devuelve la suma de los elementos de la tupla `t`, siempre que los datos se puedan
sumar.

> * `all(t)` : Devuelve `True` si todos los elementos de la tupla `t` son `True` y `False` en caso
contrario.

> * `any(t)` : Devuelve `True` si algún elemento de la tupla `t` es `True` y `False` en caso contrario

> * `dato in t` : Devuelve `True` si el dato `dato` pertenece a la tupla `t` y `False` en caso contrario.

> * `t.index(dato)` : Devuelve la posición que ocupa en la tupla `t` el primer elemento con valor
`dato`.

> * `t.count(dato)` : Devuelve el número de veces que el valor `dato` está contenido en la tupla `t`.

# Ejemplos de métodos y funciones para tuplas

pass

---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = (1,2,0,4,5)

y=(5-0)*5

a) 25

b) 20

c) 22
d) 16

e) 28

-->

2. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = (1,2,3,4,5)

y = sum((3,4,5))

a) 9

b) 12

c) 7

d) 14

e) 15

-->

---

# Diccionarios

> Un diccionario es una colección de pares formados por una 'clave' y un 'valor' asociado a la clave.

>

> Se construyen poniendo los pares entre llaves `{clave1: valor1, clave2: valor2 ...}` separados por
comas, y separando la clave del valor con dos puntos `:`.

>

>Se caracterizan por:

>

> * No tienen orden.

> * Pueden contener elementos de distintos tipos.

> * Son mutables, es decir, pueden alterarse durante la ejecución de un programa.

> * Las claves son únicas, es decir, no pueden repetirse en un mismo diccionario, y **pueden ser
de cualquier tipo de datos inmutable**.

> * **No se puede aplicar** la operación **slicing**. Se utilizan las claves definidas para acceder a
los datos o valores.

d = { 1: "Azul", 3: "Rojo", "favorito": "negro", "numero":9 }

print(d["numero"])

des = [

{"nombre":"Robinson","apellido":"Duque","edad": 37},

{"nombre":"Kellys","apellido":"Santa","edad": 20},

{"nombre":"Jose","apellido":"Sanchez","edad": 25, "notas":[5.0, 3.4,4.6]}

print(des[0]["nombre"])

print(des[0]["apellido"])

print(des[0]["edad"])

print(des[1]["nombre"])

print(des[1]["apellido"])

print(des[1]["edad"])

print(des[2]["nombre"])

print(des[2]["apellido"])

print(des[2]["edad"])

print(des[2]["notas"][1])

> ## Funciones y métodos de diccionarios

>

> * `len(d)` : Devuelve el número de elementos del diccionario `d`.

> * `min(d)` : Devuelve la mínima clave del diccionario `d` siempre que las claves sean
comparables.

> * `max(d)` : Devuelve la máxima clave del diccionario `d` siempre que las claves sean
comparables.

> * `sum(d)` : Devuelve la suma de las claves del diccionario `d`, siempre que las claves se puedan
sumar

> * `clave in d` : Devuelve `True` si la clave `clave` pertenece al diccionario `d` y `False` en caso
contrario.

> * `d.keys()` : Devuelve un iterador sobre las claves de un diccionario.

> * `d.values()` : Devuelve un iterador sobre los valores de un diccionario.

> * `d.items()` : Devuelve un iterador sobre los pares clave-valor de un diccionario.

# Ejemplos de diccionarios y uso de funciones y métodos

d ={1:40 , 2:30, 3:50}

v = d.values()

print(type(v))

print(sum(v))

# Ejemplos de diccionarios y uso de funciones y métodos

d ={1:40 , 2:30, 3:50}

print(sum( d.values() ))

v = list(d.items())

print(v)

> Continuación:

>

> `d[clave] = valor` : Añade al diccionario `d` el par formado por la clave clave y el valor `valor`.

> * `d.update(d2)`. Añade los pares del diccionario `d2` al diccionario `d`.

> * `d.pop(clave, alternativo)` : Devuelve del valor asociado a la clave `clave` del diccionario `d` y lo
elimina del diccionario. Si la clave no está devuelve el valor alternativo.

> * `d.popitem()` : Devuelve la tupla formada por la clave y el valor del último par añadido al
diccionario `d` y lo elimina del diccionario.
> * `del d[clave]` : Elimina del diccionario `d` el par con la clave `clave`.

> * `d.clear()` : Elimina todos los pares del diccionario `d` de manera que se queda vacío.

# Ejemplos con funciones y operadores adicionales

d ={1:40 , 2:30, 3:50}

d["nuevo"]=-8

d[2]=-30

print(d)

> ## Copia de diccionarios

>

>Existen dos formas de copiar diccionarios:

>

> * **Copia por referencia** `d1 = d2`

> * **Copia por valor** `d1 = dict(d2)`

# Ejemplos de copia de diccionarios por valor y por referencia

pass

---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = {1:"Azul", 2:"Rojo", 3:"Verde"}

y = x[1] + x[2]

a) "Azul Rojo"

b) Error

c) "AzulRojo"

d) "1:Azul2:Rojo"
e) "12"

-->

2. Oculta aquí (MC).

<!--

Cuál es el valor de 'x' después de ejecutar:

x = {1:'Azul', 2:'Rojo', 3:'Verde'}

x[1],x[2] = x[2],x[1]

x[6] = "Naranja"

del x[3]

a) {1: 'Rojo', 2: 'Azul', 3: 'Verde', 6: 'Naranja'}

b) Error

c) {1: 'Rojo', 2: 'Azul', 6: 'Naranja'}

d) {1: 'Azul', 2: 'Rojo', 6: 'Naranja'}

e) {1: 'Rojo', 2: 'Rojo', 3: 'Naranja'}

-->

---

# Condicionales

>

> ```ipython

if condición1:

bloque código

elif condición2:

bloque código

...

else:

bloque código
> ```

>

> Evalúa la expresión lógica `condición` y ejecuta el primer bloque de código si es `True`; si no,
evalúa la siguientes condiciones hasta llegar a la primera que es `True` y ejecuta el bloque de
código asociado. Si ninguna condición es `True` ejecuta el bloque de código después de `else`.

>

>Pueden aparecer varios bloques `elif` pero solo uno `else` al final.

# Ejemplo de condicional 'if'

# Ej: Validar si un número es positivo

n = int(input("Ingrese un número"))

if n>=0:

print("El número es positivo")

print("El número es {}".format(n))

x = n*2

print("El doble de {} es {}".format(n,x))

# Ejemplo de condicional 'if...else'

n = int(input("Ingrese un número"))

if n>=0:

print("El número es positivo")

print("El número es {}".format(n))

x = n*2

print("El doble de {} es {}".format(n,x))

else:

print("El número es negativo")

print("El número es {}".format(n))

x = abs(n)

print("El valor absoluto de {} es {}".format(n,x))

# Ejemplo d condicional 'if...elif...elif...else'

n = int(input("Ingrese un número"))

if n>0:
 print("El número es positivo")

print("El número es {}".format(n))

x = n*2

print("El doble de {} es {}".format(n,x))

elif n==0:

print("El número es cero")

else:

print("El número es negativo")

print("El número es {}".format(n))

x = abs(n)

print("El valor absoluto de {} es {}".format(n,x))

n = int(input("Ingrese un número"))

if n>0:

print("El número es positivo")

print("El número es {}".format(n))

x = n*2

print("El doble de {} es {}".format(n,x))

if n%2==0:

print("...Además el número es par")

else:

print("...Además el número es impar")

elif n==0:

print("El número es cero")

else:

print("El número es negativo")

print("El número es {}".format(n))

x = abs(n)
 print("El valor absoluto de {} es {}".format(n,x))

# Bucles de repetición

> En Python existen los bucles `while` y `for`. Particularmente nos enfocaremos más a fondo en los
bucles `for` puesto que son los que utilizaremos principalmente en el curso para recorrer
secuencias de datos.

>

> ## Bucle `while`

>

> ```ipython

while condición:

bloque código

>```

>

> Repite la ejecución del bloque de código mientras la expresión lógica 'condición' sea cierta. Se
puede interrumpir en cualquier momento la ejecución del bloque de código con la instrucción
`break`.

num = None

while num != 0:

num = int(input('Introduce un número: '))

n=0

while n <= 100:

n+=1;

print(n)

> ## Bucle `for`

> ```ipython

for i in secuencia:

bloque código

> ```
>

> Repite la ejecución del bloque de código para cada elemento de la secuencia secuencia, asignado
dicho elemento a i en cada repetición.

>

>Se puede interrumpir en cualquier momento la ejecución del bloque de código con la instrucción
`break` o saltar la ejecución para un determinado elemento de la secuencia con la instrucción
`continue`.

>

> Se utiliza fundamentalmente para recorrer colecciones de objetos como cadenas, listas, tuplas o
diccionarios.

# Ejemplos de bucle for para recorrer cadenas

c = "Hola estudiantes de programación"

aux=""

for i in c:

if i=="a":

aux+="A"

else:

aux+=i

print(aux)

#c2= c.replace("a","A")

#print(c2)

# Ejemplos de bucle for para recorrer listas

l = list(range(5)) + [-3,4]

print(l)

nl=[]

for i in l:

if i>=0:
 nl.append(i)

else:

nl.append(abs(i))

print(nl)

nl2=[]

for i in l:

if i>=0:

nl2.append(i)

else:

break

print(nl2)

# Ejemplos de bucle for para recorrer tuplas

t = tuple( list(range(5)) + [-3,4])

print(t)

aux=[]

for i in t:

if i%2==1 and i>=0:

aux.append(i)

print(aux)

# Ejemplos de bucle for para recorrer diccionarios

des = [
{"nombre":"Robinson","apellido":"Duque","edad": 37},

{"nombre":"Kellys","apellido":"Santa","edad": 20},

{"nombre":"Jose","apellido":"Sanchez","edad": 25, "notas":[5.0, 3.4,4.6]}

#for i in des:

# print(i["apellido"])

d = {"nombre":"Robinson","apellido":"Duque","edad": 37}

valores=[]

for i in d.values() :

valores.append(i)

print(valores)

print(list(d.values()))

print(list(d.keys()))

print(list(d.items()))

# Ejemplos de bucle for utilizando 'range(fin)', 'range(inicio,fin)'

# y range'(inicio,fin,salto)'

for i in range(0,90,5):

print(i)
---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = [1,-2,3,4,-7,8]

y = []

for i in x:

if i>=0:

y.append(i)

a) Error

b) [1, 3, 4, 8]

c) [-2, -7]

d) [3, 4, 8]

e) [1, 3, 4]

-->

2. Oculta aquí (MC).

<!--

Cuál es el valor de 'y' después de ejecutar:

x = "Fundamentos"
y = []

for i in x:

if i != "a":

y.append(i.upper())

else:

y.append(i)

a) Error

b) ["f","u","n","d","a","m","e","n","t","o","s"]

c) "fundAmentos"

d) "FUNDaMENTOS"

e) ['F', 'U', 'N', 'D', 'a', 'M', 'E', 'N', 'T', 'O', 'S']

-->

---

# Colecciones por Comprensión

> En muchas aplicaciones es habitual aplicar una función o realizar una operación con los
elementos de una colección (lista, tupla o diccionario) y obtener una nueva colección de elementos
transformados. Aunque esto se puede hacer recorriendo la secuencia con un bucle iterativo,
Python incorpora un mecanismo muy potente que permite esto mismo de manera más simple y
eficiente.

>

> ## Comprensión de Listas/Generadores/Diccionarios/Conjuntos

>* **Listas:** \[expresion `for` variable `in` secuencia `if` condicion\]

>

>* **Generadores:** \(expresion `for` variable `in` secuencia `if` condicion\)

>

>* **Diccionarios:** \{exp-clave : exp-valor `for` variable `in` secuencia `if` condicion\}

>
>* **Conjuntos:** \{expresion `for` variable `in` secuencia `if` condicion\}

l=[3,4,5,-2,-7,9]

l2 = [i*2 for i in l if i%2==0 ]

print(l2)

l3 = [ (i,i*2,i*3) for i in l]

print(l3)

l4 = [i*2 if i%2==0 else

i+2 if i>3 else i

for i in l ]

print(l4)

def funcionCondicion(x):

if x%2==0:

return x*2

elif x>3:

return x+2

else:

return x

[funcionCondicion(i) for i in l]

l = [4,5,6,6,6,7,7,3,4,5]

c = set(l)

print(c)

c2= { i:i*2 for i in c }

print(c2)

gen = (i for i in range(20))

print(gen)

print(type(gen))

for i in gen:

print(i)

if i == 10:

break

print("sigue generando datos")

for i in gen:

print(i)

#Una secuencia puede ser: 'str', 'list', 'range', 'tuple', 'dict'

# Ejemplos de listas por comprensión (sin condición)

pass

# Ejemplos de listas por comprensión (Con condición)

l = [x for x in range(15) if x % 2 == 0]

print(l)

pass

# Ejemplos de generadores por comprensión (sin condición)

pass

# Ejemplos de generadores por comprensión (con condición)

pass
# Ejemplos de diccionarios por comprensión (sin condición)

pass

# Ejemplos de diccionarios por comprensión (sin condición)

pass

# Ejemplos de conjuntos por comprensión (sin condición)

pass

# Ejemplos de conjuntos por comprensión (sin condición)

pass

d = {"nombre":"Robinson","apellido":"Duque","edad": 37}

l = [str(i) for i in d.values()]

l2 = [ int(i) for i in l if str.isnumeric(i)]

print(l2)

---

# Pregunta en Socrative...

1. Oculta aquí (MC).

<!--

El valor de 'y' después de ejecutar lo siguiente es:

x = [1,2,3,4,5,6]

y = [i*2 for i in x[:] ]

a) [2, 4, 6, 8]

b) [2, 4, 6, 8, 10]

c) [8, 6, 4, 2]

d) [10, 8, 6, 4, 2]

e) Error

-->

x = [1,2,3,4,5,6]

y = [i*2 for i in x[:5] ]

print(y)

2. Oculta aquí (MC).

<!--

El valor de 'y' después de ejecutar lo siguiente es:

x = [1,2,3,3,2,2,1,4]

y = { i for i in x }

a) [1, 2, 3, 4]

b) [1, 1, 2, 2, 2, 3, 3, 4]

c) {1, 1, 2, 2, 2, 3, 3, 4}

d) {1, 2, 3, 4}

e) Error

-->

3. Oculta aquí (MC).

<!--

El valor de 'y' después de ejecutar lo siguiente es:

x = [1,2,3,4,5,6]

y = { i*2 : i for i in x }

a) {2: 1, 4: 2, 6: 3, 8: 4, 10: 5, 12: 6}

b) {1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12}

c) {2, 4, 6, 8, 10, 12}

d) [2, 4, 6, 8, 10, 12]

e) Error

-->

---

# Funciones

> Una función es un bloque de código que tiene asociado un nombre, de manera que cada vez que
se quiera ejecutar el bloque de código basta con invocar el nombre de la función.

> ```ipython

def <nombre-funcion> (<parámetros>):

bloque código

return <objeto>

```

# Ejemplo de función con parámetros y su respectiva invocación con argumentos

pass

# Ejemplo de función con parámetros y valor de retorno

pass

# Ejemplo con retorno de tuplas y desempaquetado

pass
# Ejemplo de función sin parámetros y su respectiva invocación

def funcionRara():

print("Hola mundo")

x = funcionRara()

print(x)

def funcionSuma(a,b,lista):

l1 = list(range(a))

l2 = list(range(b))

return l1+l2+lista

x=6

y = funcionSuma(x,7, [4,5,6,7,8])

print(y)

a,*b = (4,5,6,7,1,2)

print(a)

print(b)

a,*b,c = (4,5,6,7,1,2)

print(a)

print(b)

print(c)

def miFuncion(a,b):

a = b*2

b = a*3

return (a,b)

v1,v2 = miFuncion(8,9)

print(v1)

print(v2)
> ## Invocación

>Los valores que se pasan a la función en una llamada o invocación concreta de ella se conocen
como argumentos y se asocian a los parámetros de la declaración de la función.

>

>Los argumentos se pueden indicar de dos formas:

>

>* Argumentos posicionales

>* Argumentos por nombre

>

> Por otro lado, también existen **argumentos por defecto**. En la definición de una función se
puede asignar a cada parámetro un argumento por defecto `parámetro=argumento`, de manera
que si se invoca la función sin proporcionar ningún argumento para ese parámetro, se utiliza el
argumento por defecto.

# Ejemplo de invocación utlizando argumentos posicionales

pass

# Ejemplo de invocación utlizando argumentos por nombre

pass

# Ejemplo de definición de función con argumentos por defecto

pass

def multiplicar(a,b=1):

return (a, b)

print(multiplicar(3,4))

print(multiplicar(5))

print(multiplicar(a=3,b=5))
print(multiplicar(b=5,a=3))

> ## Ámbito de variables y parámetros de funciones

>Los parámetros y las variables declaradas dentro de una función son de **ámbito local**,
mientras que las definidas fuera de ella son de **ámbito ámbito global**.

# Ejemplos de ambito de parámetros y variables de una función

pass

l = [9,5,6,7]

def miFuncionRara(lista,pos,val):

lista[pos] = val

print(l)

miFuncionRara(l,2,4)

print(l)

x=5

def miFuncion(y):

z = y*2

return z

miFuncion(x)

print(z)

> ## Paso de argumentos por valor y referencia

> En Python el paso de argumentos a una función es siempre por referencia, es decir, se pasa una
referencia al objeto del argumento, de manera que cualquier cambio que se haga dentro de la
función mediante el parámetro asociado afectará al objeto original, siempre y cuando este sea
mutable (e.g., listas, diccionarios).

>

>Recordemos que en Python existen objetos inmutables, como los enteros, strings, booleanos y las
tuplas, por lo que si intentáramos modificar una tupla pasada como parámetro lo que ocurriría en
realidad es que se crearía una nueva instancia, por lo que los cambios no se verían fuera de la
función.

>

> **En resumen:** Los valores mutables (listas y diccionarios) se comportan como paso por
referencia, y los inmutables como paso por valor.

# Ejemplo de paso de argumentos por valor y referencia

pass

> ## Documentación de funciones

> También podemos encontrarnos con una cadena de texto como primera línea del cuerpo de la
función. Estas cadenas se conocen con el nombre de **docstring** (cadena de documentación) y
sirven, como su nombre indica, a modo de documentación de la función. Esto es lo que imprime el
opeardor `?` de iPython o la función `help`.

def area_triangulo(base, altura):

"""Función que calcula el área de un triángulo.

Parámetros:

- base: La base del triángulo.

- altura: La altura del triángulo.

Resultado:

El área del triángulo con la base y altura especificadas.

"""

return base * altura / 2

area_triangulo?