devfzn/Apuntes_Python
devfzn/Apuntes_Python
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

mejora markdown REAMDE Curso Modulo 1

Browse Source
This commit is contained in:
devfzn 2022-12-25 16:04:37 -03:00
parent b41be38b22
commit 8edb6f019a
1 changed files with 142 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
01_curso/Modulo_1/README.md
View File

@ -48,9 +48,6 @@ a, b = 0, 1
while b < 10: while b < 10:
print(b, end=', ') print(b, end=', ')
a, b = b, a+b a, b = b, a+b
# shift + Enter para terminar de ingresar el ciclo while
# en consola, o agregar otra linea con Enter.
``` ```
Print básico Print básico
@ -120,10 +117,10 @@ tiene soporte integrado para **números complejos**.
> usa **j** o **J** para indicar la parte imaginaria, ej. > usa **j** o **J** para indicar la parte imaginaria, ej.
> **` 3+5+j `** > **` 3+5+j `**
### Strings ### Strings
Cadena Cruda **r'cadena'** Cadena Cruda **r'cadena'**
```python ```python
print(r'C:\\algun\directorio') print(r'C:\\algun\directorio')
@ -216,9 +213,10 @@ len(letras)
a = ['a', 'b', 'c'] a = ['a', 'b', 'c']
n = [1, 2, 3] n = [1, 2, 3]
x = [a, n] x = [a, n]
x
x[0] x # [['a', 'b', 'c'], [1, 2, 3]]
x[0][1] x[0] # ['a', 'b', 'c']
x[0][1] # 'b'
``` ```
[1-1_primeros_pasos.py](https://gitea.kickto.net/devfzn/Apuntes_Python/src/branch/master/01_curso/Modulo_1/1-1_primeros_pasos.py) [1-1_primeros_pasos.py](https://gitea.kickto.net/devfzn/Apuntes_Python/src/branch/master/01_curso/Modulo_1/1-1_primeros_pasos.py)
@ -270,7 +268,6 @@ Consola python: `python -i`
* ` numero + 1 ` : Expresión que combina **una variable**, **un valor** y **un operador**. * ` numero + 1 ` : Expresión que combina **una variable**, **un valor** y **un operador**.
### Operadores: ### Operadores:
* **Unarios** y **Binarios**, que requieren uno o dos operandos. * **Unarios** y **Binarios**, que requieren uno o dos operandos.
@ -299,28 +296,28 @@ Ejemplos operadores de comparación
#### and #### and
|Op1|Op2|Resultado |Var. A|Op.|Var. B|Resultado
|-|-|-| |-|-|-|-|
| True | True | True | | `True` | **and** | `True` | True |
| True | False | False | | `True` | **and** | `False` | False |
| False | True | False | | `False` | **and** | `True` | False |
| False | False | False | | `False` | **and** | `False` | False |
#### or #### or
|Op1|Op2|Resultado |Var. A|Op.|Var. B|Resultado
|-|-|-| |-|-|-|-|
| True | True | True | | True | **or** | True | True |
| True | False | True | | True | **or** | False | True |
| False | True | True | | False | **or** | True | True |
| False | False | False | | False | **or** | False | False |
#### not #### not
|Op|Resultado | Op. | Var. | Resultado |
|-|-| |-|-|-|
| True |False| | **not** | True | False |
| False|True | | **not** | False | True |
### Precedencia de operadores ### Precedencia de operadores
@ -625,13 +622,13 @@ else:
ej. ej.
```python ```python
def cero(): def cero():
return 0 return 0
cero() # 0 cero() # 0
cero() + 1 # 1 cero() + 1 # 1
c = cero() c = cero()
c # 0 c # 0
``` ```
```python ```python
@ -754,8 +751,8 @@ fibo(2000)
``` ```
- **return**: - **return**:
Devuelve un valor en una función, **sin una expresión** como argumento retorna **None**, Devuelve un valor en una función, **sin una expresión** como argumento
si se alcanza el fuba de una función, también retorna **None**. retorna **None**, si se alcanza el fuba de una función, también retorna **None**.
```python ```python
f = fibo f = fibo
@ -805,7 +802,7 @@ def fibo(n):
print(fibo(35)) print(fibo(35))
``` ```
#### Función que rercibe entrada de usuario #### Función que recibe entrada de usuario
```python ```python
def pedir_confirmacion(prompt, reintentos=4, msj='Intenta nuevamente'): def pedir_confirmacion(prompt, reintentos=4, msj='Intenta nuevamente'):
@ -850,6 +847,7 @@ def pedir_confirmacion(prompt, reintentos=4, msj='Intenta nuevamente'):
Los valores por omisión son evaluados en el momento de la definición de la función, Los valores por omisión son evaluados en el momento de la definición de la función,
en el ámbito de la definición, entonces: en el ámbito de la definición, entonces:
```python ```python
i = 5 i = 5
@ -868,10 +866,12 @@ f()
#5 #5
``` ```
El valor por omisión es evaluado solo una vez. Existe una diferencia cuando el valor por omisión es El valor por omisión es evaluado solo una vez. Existe una diferencia cuando
un objeto mutable como una lista, diccionario, o instancia de la mayoría de las clases. Por ejemplo. el valor por omisión es un objeto mutable como una lista, diccionario, o
instancia de la mayoría de las clases. Por ejemplo.
La siguiente función acumula los argumentos que se le pasan en subsiguientes llamadas: La siguiente función acumula los argumentos que se le pasan en subsiguientes llamadas:
```python ```python
def f(a, L=[]): def f(a, L=[]):
L.append(a) L.append(a)
@ -882,9 +882,9 @@ print(f(2)) #[1, 2]
print(f(3)) #[1, 2, 3] print(f(3)) #[1, 2, 3]
``` ```
Si no se quiere que el valor por omisión sea compartido entre subsiguientes
llamadas, la función se puede escribir así:
Si no se quiere que el valor por omisión sea compartido entre subsiguientes llamadas,
la función se puede escribir así:
```python ```python
def f(a, L=None): def f(a, L=None):
if L is None: if L is None:
@ -905,17 +905,13 @@ print(f(1, [1,2,3]))
# [1, 2, 3, 1] # [1, 2, 3, 1]
``` ```
#### Palabras clave como argumentos
Las funciones también puede ser llamadas usando argumentos de palabras clave
(o **argumentos nombrados**) de la forma `keyword = value`. Por ejemplo: (o **argumentos nombrados**) de la forma `keyword = value`. Por ejemplo:
```python ```python
def loro(tension, estado='muerto', accion='explotar', tipo='Azul Nordico'): def loro(tension, estado='muerto', accion='explotar', color='Azul Nordico'):
print("-- Este loro no va a", accion, end=' ') print("-- Este loro no va a", accion, end=' ')
print("si le aplicas", tension, "voltios.") print("si le aplicas", tension, "voltios.")
print("-- Gran plumaje tiene el", tipo) print("-- Hermoso plumaje", color)
print("-- Está", estado,"!") print("-- Está", estado,"!")
``` ```
@ -923,7 +919,7 @@ def loro(tension, estado='muerto', accion='explotar', tipo='Azul Nordico'):
```python ```python
loro(1000) loro(1000)
# -- Este loro no va a explotar si le aplicas 1000 voltios. # -- Este loro no va a explotar si le aplicas 1000 voltios.
# -- Gran plumaje tiene el Azul Nordico # -- Hermoso plumaje Azul Nordico
# -- Está muerto ! # -- Está muerto !
``` ```
@ -931,23 +927,23 @@ def loro(tension, estado='muerto', accion='explotar', tipo='Azul Nordico'):
```python ```python
loro(tension=1000) loro(tension=1000)
# -- Este loro no va a explotar si le aplicas 1000 voltios. # -- Este loro no va a explotar si le aplicas 1000 voltios.
# -- Gran plumaje tiene el Azul Nordico # -- Hermoso plumaje Azul Nordico
# -- Está muerto ! # -- Está muerto !
``` ```
- 2 argumentos nombrados - 2 argumentos nombrados
```python ```python
loro(tension=1000000, accion='VOOOOM') loro(tension=1000000, accion='volar')
# -- Este loro no va a VOOOOM si le aplicas 1000000 voltios. # -- Este loro no va a volar si le aplicas 1000000 voltios.
# -- Gran plumaje tiene el Azul Nordico # -- Hermoso plumaje Azul Nordico
# -- Está muerto ! # -- Está muerto !
``` ```
- 2 argumentos nombrados - 2 argumentos nombrados
```python ```python
loro(accion='VOOOOM', tension=1000000) loro(accion='volar', tension=1000000)
# -- Este loro no va a VOOOOM si le aplicas 1000000 voltios. # -- Este loro no va a volar si le aplicas 1000000 voltios.
# -- Gran plumaje tiene el Azul Nordico # -- Hermoso plumaje Azul Nordico
# -- Está muerto ! # -- Está muerto !
``` ```
@ -955,15 +951,16 @@ def loro(tension, estado='muerto', accion='explotar', tipo='Azul Nordico'):
```python ```python
loro('un millón', 'despojado de vida', 'saltar') loro('un millón', 'despojado de vida', 'saltar')
# -- Este loro no va a saltar si le aplicas un millón voltios. # -- Este loro no va a saltar si le aplicas un millón voltios.
# -- Gran plumaje tiene el Azul Nordico # -- Hermoso plumaje Azul Nordico
# -- Está despojado de vida ! # -- Está despojado de vida !
``` ```
- 1 arg. posicional y 1 nombrado. - 1 arg. posicional y 1 nombrado.
```python ```python
loro('mil', estado='viendo crecer las flores desde abajo') loro('mil', estado='viendo crecer las flores desde abajo')
# -- Este loro no va a explotar si le aplicas mil voltios. # -- Este loro no va a explotar si le aplicas mil voltios.
# -- Gran plumaje tiene el Azul Nordico # -- Hermoso plumaje Azul Nordico
# -- Está viendo crecer las flores desde abajo ! # -- Está viendo crecer las flores desde abajo !
``` ```
@ -1033,11 +1030,13 @@ def muchos_items(archivo, separador, *args):
archivo.write(separador.join(args)) archivo.write(separador.join(args))
``` ```
Generalmente, argumentos de cantidad variable son útilmos en la lista de parametros Generalmente, argumentos de cantidad variable son útilmos en la lista de
formales, porque toman el remanente de argumentos q se pasan a la función. parametros formales, porque toman el remanente de argumentos q se pasan a la
función.
Cualquier parametro que suceda luego del +args solo sera del tipo **nombrado**, Cualquier parametro que suceda luego del +args solo sera del tipo **nombrado**,
es decir, solo se pueden utilizar nombradros y no posicionales. es decir, solo se pueden utilizar nombradros y no posicionales.
```python ```python
concatenar("tierra", "marte", "venus") concatenar("tierra", "marte", "venus")
# 'tierra/marte/venus' # 'tierra/marte/venus'
@ -1050,6 +1049,7 @@ concatenar("tierra", "marte", "venus", sep=" @ ")
Cuando los argumentos ya pertences a una lista o tupla, se pueden desempaquetar Cuando los argumentos ya pertences a una lista o tupla, se pueden desempaquetar
para llamar una funcion que requiere argumetnoss posicionaes separados. para llamar una funcion que requiere argumetnoss posicionaes separados.
ej. `range()` espera los argumentos inicio y fin. ej. `range()` espera los argumentos inicio y fin.
También se puede llamar a la función con el operador para desempaquetar argumentos También se puede llamar a la función con el operador para desempaquetar argumentos
@ -1066,7 +1066,6 @@ list (range(*args))
# [3, 4, 5] # [3, 4, 5]
``` ```
Los **diccionarios** pueden entregar argumentos nombrados con el operador ` ** ` Los **diccionarios** pueden entregar argumentos nombrados con el operador ` ** `
```python ```python
@ -1098,10 +1097,11 @@ un objeto de tipo función.
Están sintácticamente restringidas a una sola expresión. Están sintácticamente restringidas a una sola expresión.
Semánticamente, son solo azúcar sintáctica para definiciones normales de funciones. Semánticamente, son solo azúcar sintáctica para definiciones normales de
funciones.
Al igual que las funciones anidadas, las funciones lambda pueden hacer referencia a Al igual que las funciones anidadas, las funciones lambda pueden hacer
variables desde el ámbito que la contiene. referencia a variables desde el ámbito que la contiene.
```python ```python
def hacer_incrementador(n): def hacer_incrementador(n):
@ -1149,6 +1149,7 @@ f(5) = 6
## Docstrings ## Docstrings
### Ejemplo de un **docstring multi-línea** ### Ejemplo de un **docstring multi-línea**
```python ```python
def mi_funcion(): def mi_funcion():
"""Esta funcion solo muestra documentacion. """Esta funcion solo muestra documentacion.
@ -1168,14 +1169,16 @@ print(mi_funcion.__doc__)
Se almacenan en el atributo ***__annotations__*** de la función como un Se almacenan en el atributo ***__annotations__*** de la función como un
diccionario y no tienen efecto enninguna otra parte de la función. diccionario y no tienen efecto enninguna otra parte de la función.
Las anotaciones de los parámetros se definen luego de dos puntos Las anotaciones de los parámetros se definen luego de dos puntos después del
después del nombre delparámetro, seguido de una expresión que evalúa nombre del parámetro, seguido de una expresión que evalúa al valor de la
al valor de la anotación. anotación.
Las anotaciones de retorno son definidas por el literal **` -> `**, seguidas de una expresión, Las anotaciones de retorno son definidas por el literal **` -> `**, seguidas
entre la lista de parámetros y los **` : `** que marcan el final de la declaración **` def `**. de una expresión, entre la lista de parámetros y los **` : `** que marcan el
final de la declaración **` def `**.
El siguiente ejemplo tiene **un argumento posicional, uno nombrado, y el valor de retorno anotado**. El siguiente ejemplo tiene **un argumento posicional, uno nombrado, y el valor
de retorno anotado**.
```python ```python
def f(jamon: str, huevos: str = 'huevos') -> str: def f(jamon: str, huevos: str = 'huevos') -> str:
@ -1223,7 +1226,9 @@ print([1,2,3,4,5])
``` ```
### if ### if
Consola python: `python -i` Consola python: `python -i`
```python ```python
x = int(input("Ingresa un entero: ")) x = int(input("Ingresa un entero: "))
@ -1247,6 +1252,7 @@ else:
### for ### for
Midiendo cadenas de texto Midiendo cadenas de texto
```python ```python
palabras = ['gato','ventana','defenestrado'] palabras = ['gato','ventana','defenestrado']
@ -1486,13 +1492,15 @@ while True:
``` ```
Es usada normalmente para crear **clases** en su mínima expresión Es usada normalmente para crear **clases** en su mínima expresión
```python ```python
class MyClaseVacia: class MyClaseVacia:
pass pass
``` ```
Otro lugar donde se puede usar "pass" es como marca de para una función o un cuerpo Otro lugar donde se puede usar "pass" es como marca de para una función o un
condicional (ej. en código nuevo), te permite pensar a un nivel de abstracción mayor. cuerpo condicional (ej. en código nuevo), te permite pensar a un nivel de
abstracción mayor.
El pass se ignora silenciosamente: El pass se ignora silenciosamente:
@ -1593,18 +1601,19 @@ bn(4,[0,1,2,3,4,5,6])
# 4 # 4
``` ```
Python tiene una manera de poner definiciones en un archivo y usarlos en un script Python tiene una manera de poner definiciones en un archivo y usarlos en un
o en una instancia interactiva del intérprete. script o en una instancia interactiva del intérprete.
Tal archivo es llamado módulo, las definiciones de un módulo pueden ser Tal archivo es llamado módulo, las definiciones de un módulo pueden ser
importadas a otros módulos o al módulo principal. importadas a otros módulos o al módulo principal.
Un módulo contiene definiciones y declaraciones de Python, Un módulo contiene definiciones y declaraciones de Python, el nombre del
el nombre del archivo es ***modulo***.py archivo es ***modulo***.py
**` __name__ `** : variable global que contiene el nombre del modulo **` __name__ `** : variable global que contiene el nombre del modulo.
Usando módulo de ejemplo creado como ***[fibo.py](#modulo-fibo)*** Usando módulo de ejemplo creado como ***[fibo.py](#modulo-fibo)***
Consola python: `python -i` Consola python: `python -i`
```python ```python
@ -1639,6 +1648,7 @@ directamente al espacio de nombres del módulo que hace la importación.
``` ```
Variante para importar todos los nombres que un módulo define: Variante para importar todos los nombres que un módulo define:
```python ```python
>>> from fibo import * >>> from fibo import *
>>> fib(500) >>> fib(500)
@ -1664,6 +1674,7 @@ python fibo.py <argumentos>
El codigo en el módulo es ejecutado como si fuese importado producto de : **`__name__ = "__main__"`**. El codigo en el módulo es ejecutado como si fuese importado producto de : **`__name__ = "__main__"`**.
Si agregamos al final del modulo [fibo.py](#modulo-fibo) Si agregamos al final del modulo [fibo.py](#modulo-fibo)
```python ```python
if __name__ == "__main__": if __name__ == "__main__":
import sys import sys
@ -1671,18 +1682,21 @@ if __name__ == "__main__":
``` ```
en terminal: en terminal:
```bash ```bash
$ python fibo.py 50 $ python fibo.py 50
1 1 2 3 5 8 13 21 34 1 1 2 3 5 8 13 21 34
``` ```
Si el módulo se importa, ese código no se ejecuta: Si el módulo se importa ese código no se ejecuta:
``` ```
>>> import fibo >>> import fibo
>>> >>>
``` ```
Importar módulos individuales Importar módulos individuales
```python ```python
import sound.effects.echo import sound.effects.echo
@ -1691,6 +1705,7 @@ sound.effects.echo.echofilter(input, output, delay=0.7, atten=4){1}
``` ```
Otra alternativa para importar el submódulos es: Otra alternativa para importar el submódulos es:
```python ```python
from sound.effects import echo from sound.effects import echo
@ -1736,10 +1751,12 @@ if __name__ == "__main__":
Tipos de datos que pueden ser recorridos secuencialmente mediante el uso del ciclo for. Tipos de datos que pueden ser recorridos secuencialmente mediante el uso del ciclo for.
Los objetos iterables dében responder los mensajes: **`__iter__`** y **`__next__`** Los objetos iterables dében responder los mensajes: **`__iter__`** y **`__next__`**
- **` __iter__ `** : retorna un objeto iterador. - **` __iter__ `** : retorna un objeto iterador.
- **` __next__ `** : retorna el próximo elemento de la secuencia. - **` __next__ `** : retorna el próximo elemento de la secuencia.
ej: ej:
```python ```python
lista = [1, 2, 3, 4, 5] lista = [1, 2, 3, 4, 5]
@ -1749,21 +1766,22 @@ for elemento in lista:
# 1 2 3 4 5 # 1 2 3 4 5
``` ```
**`for`** llama a la función **`iter()`** de la **`lista`** (objeto iterable) y recibe un **`for`** llama a la función **`iter()`** de la **`lista`** (objeto iterable)
elemento definido por **`__next__`**. y recibe un elemento definido por **`__next__`**.
Cuando no hay mas elementos __next__ levanta una excepción del tipo **Stoplteration** Cuando no hay mas elementos __next__ levanta una excepción del tipo
que notifica al ciclo for que debe finalizar. **Stoplteration** que notifica al ciclo for que debe finalizar.
Conociendo el uso interno del ciclo for podemos crear iteradores propios. Conociendo el uso interno del ciclo for podemos crear iteradores propios.
**`__next__`** : debe contiener la lógica de como acceder al siguiente elemento de la secuencia. **`__next__`** : debe contiener la lógica de como acceder al siguiente elemento
de la secuencia.
**`__iter__`** y **`__next__`** : y todos aquellos metodos que comienzan y terminan con **`__iter__`** y **`__next__`** : y todos aquellos metodos que comienzan y
**doble guión** bajo, su proposito es ser invocado por Python internamente, terminan con **doble guión** bajo, su proposito es ser invocado por Python
en este ejemplo por el ciclo for. internamente, en este ejemplo por el ciclo for.
Ejemplo de un iterador que recorre elementos de una lista en sentido inverso Ejemplo de un iterador que recorre elementos de una lista en sentido inverso.
```python ```python
class Reversa: class Reversa:
@ -1890,6 +1908,7 @@ pdb.set_trace()
``` ```
ej. breakpoint **`pdb.set_trace()`** ej. breakpoint **`pdb.set_trace()`**
```python ```python
pdb.set_trace() # <-- Breakpoint pdb.set_trace() # <-- Breakpoint
def a_function(a_number): def a_function(a_number):
@ -1971,10 +1990,12 @@ eval()
Crear un programa que simule la tirada de dados. Crear un programa que simule la tirada de dados.
Cada vez que ejecutamos el programa, éste elegirá dos números aleatorios entre el 1 y el 6. Cada vez que ejecutamos el programa, éste elegirá dos números aleatorios
entre el 1 y el 6.
El programa deberá imprimirlos en pantalla, imprimir su suma y preguntarle
al usuario si quiere tirar los dados otra vez.
El programa deberá imprimirlos en pantalla, imprimir su suma y preguntarle al usuario si
quiere tirar los dados otra vez.
```python ```python
from random import random # importe de la función random() del modulo random from random import random # importe de la función random() del modulo random