# IWI-131 Programación

## Introducción a Python 3.X

Python es lenguage de programación cuya ejecución es realizada a través de un interprete. Éste interprete lee código desde: 
* La consola de Python.
* Archivos de texto (con extensión .py)

En esta clase nos centraremos mayoritariamente en la **consola de python**.

## Tipos de Datos

Python opera sobre datos de distintos tipos. Cada tipo de datos tiene reglas que establecen la forma en que se deben escribir los valores literales (constantes) de ese tipo. Además, cada tipo de datos cuentan con una serie de operadores y funciones que se pueden aplicar. En algunos casos es posible convertir un dato particular de un tipo a otro, ya sea de forma implícita o explícita.

### Números enteros
Tipo `int` (*integer*)


```python
1
```




    1




```python
+135
```




    135




```python
-124
```




    -124



### Números Reales
Tipo `float` (*floating point*)


```python
-0.36
```




    -0.36




```python
1.0
```




    1.0




```python
6.02e23
```




    6.02e+23



### Valores Lógicos
Tipo `bool`


```python
True
```




    True




```python
False
```




    False



### Texto
Tipo `str` (*strings*)


```python
"hola"
```




    'hola'




```python
'hola'
```




    'hola'




```python
"Let's Go!"
```




    "Let's Go!"




```python
'Ella dijo "Hola"'
```




    'Ella dijo "Hola"'



## Expresiones y operadores

**Expresión:** combinación de valores que pueden ser evaluados y entregan un resultado.
Pueden estar formados por:
- **Valores literales**
- **Variables**
- **Operadores**
- **Llamadas a funciones**

**Operador:** símbolo en una expresión que representa una operación aplicada a los valores sobre los que actúa.

### Operadores Aritméticos

Operan sobre valores numéricos y entregan un valor numérico como resultado.
Pueden ser:
- Operadores binarios
- Operadores unarios

#### Operadores binarios
- Suma (`+`)
- Resta (`-`)
- Multiplicación (`*`)
- División (`/`)
- División Entera (`//`)
- Módulo o resto de la división (`%`)
- Potencia (`**`)


```python
3+2
```




    5




```python
8-5
```




    3




```python
8-5.0
```




    3.0




```python
1/2
```




    0.5




```python
1//2
```




    0




```python
5%2
```




    1




```python
2**2
```




    4



#### Operadores unarios
- Positivo (`+`)
- Negativo (`-`)


```python
+3
```




    3




```python
-5.0
```




    -5.0



## Llamados a funciones y uso de biblioteca

Algunas funciones se encuentran incorporadas al núcleo del lenguaje Python y se pueden utilizar directamente (`round`, `abs`). En otros casos, las funciones están agrupadas en colecciones denominadas bibliotecas (`math`, `random`), y es necesario primero importarlas desde la biblioteca antes de poder utilizarlas.

Algunos ejemplos

**Valor absoluto** $|x|$


```python
abs(4-5)
```




    1



**Redondear**


```python
round(2.456)
```




    2



### Ejemplos de funciones de la biblioteca `math`

**Exponencial** $e^x$


```python
from math import exp
exp(1)
```




    2.718281828459045



**Raíz cuadrada** $\sqrt{x}$


```python
import math
math.sqrt(36)
```




    6.0



### Ejemplos de funciones de la biblioteca `random`

`randint(a,b)` entrega un entero aleatorio entre $[a,b]$


```python
from random import randint
randint(1,10)
```




    10



## Precedencia de Operadores

Las expresiones se evalúan siguiendo reglas de precedencia que resuelven las ambigüedades. La precedencia de operadores, de mayor a menor, es la siguiente:

1. `(, )` (parentesis)
* `abs()`, `sqrt()`, `randint()` (llamada a funciones) 
* `**` 
* `+x`, `-x` (unario)
* `*`, `/`, `//`, `%`
* `+`, `-`

### Asociatividad de Operadores

El operador `**` es asociativo por la derecha. Ejemplo: 


```python
2**3**2
```




    512



Los operadores `*`, `/` y `//` lo son por la izquierda. Ejemplo:


```python
24/4/2
```




    3.0



## Conversión entre tipos de datos (*casting*)


```python
int(3.5)
```




    3




```python
float("1")
```




    1.0




```python
str(25)
```




    '25'




```python
bool(0.0)
```




    False




```python
int("hola")
```

## Asignación de variables
Una asignación de variables tiene la forma: 
<div align="center">
<div style="font-size:2em"> &lt;variable&gt; = &lt;expresion&gt;</div>

</div>

- Primero se evalúa la expresión a la derecha del signo igual.
- El resultado de la evaluación es asignado a la variable a la izquierda del signo igual.

¿Qué valor tienen las siguiente variables?


```python
a = 4 + 5
b = a + 4
a = 2 
d = a - 3
e = e + 1
```

## Entrada de datos


```python
dato = input()
```

    a



```python
nombre = input("Ingrese su nombre: ")
```

    Ingrese su nombre: Juan


¿Qué tipo de dato es la variable `nombre`?


```python
nombre
```




    'Juan'



## Salida de datos


```python
print("Hola mundo")
```

    Hola mundo



```python
a = 6
x = a**2
```


```python
print(a, 'al cuadrado es', x)
```

    6 al cuadrado es 36



```python
print(a, x)
```

    6 36



```python
print(a)
print(x)
```

    6
    36


## Comentarios

- Son textos que serán ignorados por el intérprete de Python
- Se utilizan para explicar el código y hacerlo más fácil de entender
- Existen dos tipos de comentario:
    1. Los que se escriben a la derecha de un caracter `#`
        - Cualquier texto que aparezca a la derecha de un caracter `#` será ignorado
        - Terminan cuando termina la línea
    2. Comentarios de múltiples líneas
        - Se encierran entre tres comillas al inicio y final: `'''`
        - Pueden comprender varias líneas


```python
#El siguiente codigo muestra la suma de 2 + 2 en pantalla
print(2 + 2)
```

    4


## Ejemplos

### Ejemplo 1

Solicitar el nombre del usuario e imprimir el mensaje `"Yo soy nombre"`.


```python
nombre = input("Ingrese nombre: ")
print("Yo soy", nombre)
```

    Ingrese nombre: Juan
    Yo soy Juan


### Ejemplo 2

Desarrollar un programa que convierta temperatura de Farenheit a Celsius. La fórmula de conversión es la siguiente:

\begin{equation}
    C = \frac{5}{9}\,(F - 32)
\end{equation}


```python
f = float(input('Temp. en Farenheit: '))
c = (5/9) * (f-32)
print('El equivalente en Celsius es aproximadamente:', int(round(c)))
```

    Temp. en Farenheit: 32
    El equivalente en Celsius es aproximadamente: 0


## Algunos errores

### Error de ejecución (*runtime error*)

Un error de ejecución ocurre cuando el programa termina abruptamente por una condición que ocurre y que le impide continuar ejecutándose. Por ejemplo, cuando se produce un error aritmético al intentar hacer una división por cero.


```python
n = 8
m = 0
print('Listo')
print(n/m)
```

### Error de sintaxis (*syntax error*)

Un error de sintaxis ocurre cuando nos equivocamos en la forma (sintaxis) de escribir una instrucción de nuestro programa. Por ejemplo, cuando no cerramos la cantidad adecuada de paréntesis, olvidamos una coma, escribimos mal una instrucción de Python.


```python
2*(3+4))
```


```python
n = 6
print(n)
n + 2 = 7
print(n)
```

### Errores de nombre (*name error*)

Un error de nombre ocurre cuando se intenta acceder al contenido de una variable que no ha sido inicializada y que por lo tanto no existe. También puede ocurrir al intentar utilizar una función que no ha sido definida o importada desde una biblioteca.


```python
x = 20
print(5 * x)
print(5 * y)
```

## Reglas para definir identificadores

Los identificadores son los nombres con los que nombramos variables y otros elementos de nuestros programas. En general, como una buena práctica de programación, queremos que nuestras variables y funciones tengan nombres representativos, que indique por sí mismos su propósito. Por ejemplo, una variable para guardar la edad de una persona debería llamarse `edad` y no `x`, a pesar de que el programa funcionará correctamente con cualquiera de las dos.

Python tiene reglas simples para definir identificadores:

1. Un identificador puede contener cualquier combinación de letras (mayúsculas o minúsculas), dígitos y caracteres de guión bajo.
2. El primer caracter debe ser una letra. Las letras mayúsculas y las minúsculas se consideran diferentes, por lo que edad, Edad, y EDAD, son todos identificadores distintos.

Como consecuencia de las reglas 1. y 2., no es posible utilizar espacios en blanco en un identificador. Si queremos tener un identificador compuesto por varias palabras utilizamos guiones bajos para separarlas o una combinación de minúsculas y mayúsculas para destacar las palabras. Por ejemplo: `nombre_cliente` o `nombreCliente`.

## Ejercicios

### Ejercicio 1

Escribir una expresión para sumar los dígitos de un número entero de $3$ dígitos, que se ingrese por pantalla:


```python
n = int(input('Ingrese un número de 3 dígitos: '))
suma = n%10 + (n//10)%10 + n//100
print(suma)
```

    Ingrese un número de 3 dígitos: 123
    6


### Ejercicio 2

Modifique el resultado anterior para que reciba un entero con $3$ dígitos iguales y retorne el resultado ```n//suma```.


```python
n = int(input('Ingresa un numero de 3 digitos iguales: ')) 
suma = n%10 + (n//10)%10 + n//100
resultado = n//suma
print(resultado)
```

    Ingresa un numero de 3 digitos iguales: 111
    37


### Ejercicio 3

Realice un programa que determine el área de un círculo a partir de su radio.


```python
pi = 3.1415
radio = float(input('Ingrese el radio de un círculo: '))
print("El área de la circunferencia es", pi*(radio**2))
```

    Ingrese el radio de un círculo: 4
    El área de la circunferencia es 50.264


### Ejercicio 4

**RUTEO**: Rutee el siguiente programa e indique que es lo que imprime. Cada vez que el valor de una variable cambie, ponga su valor en una nueva fila de la tabla. La tabla tiene filas de sobra:

```python
a = 94567 
b = 28954 
c = 36532 
d = 11404 
e = 40613
a = a//10000
b = (b//1000)%10 
c = (c//100)%10 
d = (d//10)%10
e = e%10
print (a,b,c,d,e)
```

**Solución ruteo**:

|  |  |  |  | |
|---|---|---|---|---|
| **a** | **b** | **c** | **d** | **e** |
| 94567  |   |   |   |   |
|   | 28954  |   |   |   |
|   |   | 36532  |   |   |
|   |   |   | 11404  |   |
|   |   |   |   | 40613  |
| 9  |   |   |   |   |
|   | 8  |   |   |   |
|   |   | 5  |   |   |
|   |   |   | 0  |   |
|   |   |   |   | 3  |

### Ejercicio 5

Realice un programa que calcule el área de un triángulo a partir de las longitudes de sus lados.

Para calcularlo puede utilizar la fórmula de Herón:

\begin{equation}
    A = \sqrt{s\,(s-a)(s-b)(s-c)},
\end{equation}

donde $a$, $b$ y $c$ son las longitudes de cada lado y $s=\dfrac{a+b+c}{2}$ es el semiperímetro.


```python
l1 = float(input("Ingrese longitud de lado 1: "))
l2 = float(input("Ingrese longitud de lado 2: "))
l3 = float(input("Ingrese longitud de lado 3: "))
s = (l1 + l2 + l3) / 2 # semiperímetro

d1 = s-l1 # diferencia1
d2 = s-l2 # diferencia2
d3 = s-l3 # diferencia3
prod = s*d1*d2*d3 # producto de diferencias y semiperimetro
area = prod ** (1 / 2) # raíz cuadrada
# ¿cómo se podría hacer lo mismo utilizando math.sqrt()?

print("El área del triángulo es", area)
```

    Ingrese longitud de lado 1: 3
    Ingrese longitud de lado 2: 4
    Ingrese longitud de lado 3: 5
    El área del triángulo es 6.0


337d1f0678301b7be3e0ef0efa0b7c11be6bbd51
ipynb
Jupyter Notebook
notebooks/02_Intro_Python.ipynb
dsanmartin/IWI-131
77d1eb4bf2638cb83b8114ae6e84ddec3f34511d
BSD-3-Clause
2021-09-07T22:58:53.000Z
2021-09-07T22:58:53.000Z
notebooks/02_Intro_Python.ipynb
dsanmartin/iwi-131
77d1eb4bf2638cb83b8114ae6e84ddec3f34511d
BSD-3-Clause
notebooks/02_Intro_Python.ipynb
dsanmartin/iwi-131
77d1eb4bf2638cb83b8114ae6e84ddec3f34511d
BSD-3-Clause
2020-09-23T21:20:40.000Z
2020-09-23T21:20:40.000Z
Qwen/Qwen-72B
1. YES
2. YES