In [10]:

# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-pytho
n
# For example, here's several helpful packages to load

import numpy as np # linear algebra

import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the read-only "../input/" directory

# For example, running this (by clicking run or pressing Shift+Enter) will list all files
under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))

# You can write up to 5GB to the current directory (/kaggle/working/) that gets preserved
as output when you create a version using "Save & Run All"
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of
the current session

Sintaxis Markdown
Algunos comandos basicos

Titulo de tamaño con prefijo # de acuerdo al tamaño

Titulo tamaño1
Titulo tamaño2

Titulo tamaño3

Titulo tamaño4

Titulo tamaño5

Titulo tamaño6 este es el tamaño mas pequeño

PARRAFOS

El texto en markdown se inserta automaticamente, solo se deja una linea en blanco antes de escribir de nuevo.

LISTAS

listas desordenadas

Se utiliza * asteriscos, - guiones, + simbolo de suma

elemento 1
elemento 2
elemento 3

para crear una lista anidada, solo se deben incluir espacios en blanco antes del siguiente *, -, +
para crear una lista anidada, solo se deben incluir espacios en blanco antes del siguiente *, -, +

elemento 1
elemento 1.1

listas ordenadas

Debes utilizar la sintaxis "numero." 1. la numeracion dependera de el primer numero que coloquemos

1. elemento 1
2. elemento 2
3. elemento 3

CITAS

Se genera utlizando el caracter mayor que > al comienzo.

Un país, una civilización se puede juzgar por la forma en que trata a sus animales. — Mahatma
Gandhi

Ahora si la cita se compone de varios parrafos es necesario incluir el caracter al inicio de cada parrafo.

Creo que los animales ven en el hombre un ser igual a ellos que ha perdido de forma
extraordinariamente peligrosa el sano intelecto animal.

Es decir, que ven en él al animal irracional, al animal que ríe, al animal que llora, al animal infeliz. —
Friedrich Nietzsche

ENFASIS (NEGRITAS Y CURSIVAS) Se utilizan asteriscos o guiones bajos, al principio y final de donde quieres
hacer poner las negritas o cursivas :

Cursiva
cursiva
negrita
negrita

tambien se pueden anidar, usando tres asteriscos o tres guiones bajos:

cursiva y negrita
cursiva y negrita

RECUADRO PARA NOTAS o DEFINICIONES Se utiliza el simbolo > tipo : contenido

Definicion: markdown

Nota : Hola mundo

La suma de n números es:

sum =
n
∑i
i=1

LIGA
LIGA
masescuela

Ejercicios PYTHON
In [65]:
x = 10
x
Out[65]:
10

In [66]:
x.real
Out[66]:
10

In [67]:
x = 10 + 20j
x
Out[67]:

(10+20j)

In [68]:

"Hola Mundo".upper() #pasar a mayusculas

Out[68]:
'HOLA MUNDO'

In [70]:

y = "Hola MUNDO" #convertir a minusculas

y.lower()
Out[70]:
'hola mundo'

In [72]:
# def (funcion)

def factorial(n):
mult = 1
for i in range(1, n+1):
mult *=i
return mult

In [73]:
factorial(3)
Out[73]:
6

In [74]:

factorial(100)
Out[74]:
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463
976156518286253697920827223758251185210916864000000000000000000000000

In [76]:
factorial(1000)
Out[76]:
40238726007709377354370243392300398571937486421071463254379991042993851239862902059204420
84869694048004799886101971960586316668729948085589013238296699445909974245040870737599188
23627727188732519779505950995276120874975462497043601418278094646496291056393887437886487
33711918104582578364784997701247663288983595573543251318532395846307555740911426241747434
93475534286465766116677973966688202912073791438537195882498081268678383745597317461360853
79534524221586593201928090878297308431392844403281231558611036976801357304216168747609675
87134831202547858932076716913244842623613141250878020800026168315102734182797770478463586
81701643650241536913982812648102130927612448963599287051149649754199093422215668325720808
21333186116811553615836546984046708975602900950537616475847728421889679646244945160765353
40819890138544248798495995331910172335555660213945039973628075013783761530712776192684903
43526252000158885351473316117021039681759215109077880193931781141945452572238655414610628
92187960223838971476088506276862967146674697562911234082439208160153780889893964518263243
67161676217916890977991190375403127462228998800519544441428201218736174599264295658174662
83029555702990243241531816172104658320367869061172601587835207515162842255402651704833042
26143974286933061690897968482590125458327168226458066526769958652682272807075781391858178
88965220816434834482599326604336766017699961283186078838615027946595513115655203609398818
06121385586003014356945272242063446317974605946825731037900840244324384656572450144028218
85252470935190620929023136493273497565513958720559654228749774011413346962715422845862377
38753823048386568897646192738381490014076731044664025989949022222176590433990188601856652
64850617997023561938970178600408118897299183110211712298459016419210688843871218556461249
60798722908519296819372388642614839657382291123125024186649353143970137428531926649875337
21894069428143411852015801412334482801505139969429015348307764456909907315243327828826986
46027898643211390835062170950025973898635542771967428222487575867657523442202075736305694
98825087968928162753848863396909959826280956121450994871701244516461260379029309120889086
94202851064018215439945715680594187274899809425474217358240106367740459574178516082923013
53580818400969963725242305608559037006242712434169090041536901059339838357779394109700277
53472000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000

In [ ]:
factorial(10000)

Ejercicios del tutorial de PYTHON del tutorial de GUIDO

Usar PYTHON como una calculadora

Números
ingresas la expresion y despues se escribiran los valores: operadores +, -, *, de igual forma puedes usar
parentesis para grupar operaciones.

In [11]:
# suma
>>> 15+9
Out[11]:
24

In [12]:
# resta
>>> 50-26
Out[12]:
24
In [13]:
# multiplicacion
>>> 4*6
Out[13]:
24

In [14]:
# Agrupando operaciones
>>> (48)-(4*6) + ((8)*(2))
Out[14]:
40

La división (/) siempre retorna un punto flotante. Para hacer floor division y obtener un resultado entero
(descartando cualquier resultado fraccional) se usa el operador //; para calcular el resto se usa % :

In [15]:

>>> 63 / 2
Out[15]:
31.5

In [16]:
>>> 63 // 2
Out[16]:

31

In [17]:
63 % 2
Out[17]:
1

Calcular potencias

In [18]:
>>> 2 ** 8

Out[18]:
256

El signo igual (=) es usado para asignar un valor a una variable. Luego, ningún resultado es mostrado antes del
próximo prompt:

Area de un cuadrado:

In [19]:
>>> ancho = 48
>>> largo = 18 * 2
>>> ancho * largo
Out[19]:
1728

la última expresión impresa es asignada a la variable ( _ ) Esto significa que Python es más fácil seguir
la última expresión impresa es asignada a la variable ( _ ) Esto significa que Python es más fácil seguir
calculando:

In [20]:
>>> impuesto = 12.5 / 100
>>> precio = 100.50
>>> precio * impuesto
Out[20]:
12.5625

In [21]:
>>> precio + (precio*impuesto) #revisar
Out[21]:
113.0625

Cadena de caracteres
Python puede manipula cadenas de texto, que pueden ser expresadas de distintas formas, encerradas en
comillas simples ('') o dobles ("") con el mismo resultado . \ puede ser usado para escapar comillas:

In [22]:

>>> 'Cristina Ramirez' # comillas simples

Out[22]:
'Cristina Ramirez'

In [23]:
>>> 'si\' ok' # usa \' para escapar comillas simples...
Out[23]:
"si'ok"

In [24]:
>>> '"Isn t," she said.'
Out[24]:
'"Isn t," she said.'

In [25]:
>>> '"Isn\' t," she said.'
Out[25]:
'"Isn\'t," she said.'

La función print() produce una salida más legible, omitiendo las comillas que la encierran e imprimiendo
caracteres especiales y escapados:

In [26]:
>>> s = 'Cristina \n ITI' # \n significa nueva línea
>>> print(s) # con print(), \n produce una nueva línea

Cristina
ITI

El caracter \ es interpretado como caracter especial, podemos usar cadenas crudas agregando una r antes de
la primera comilla:
In [27]:
>>> print(r'Cristina\Karina\MJOSE')

Cristina\Karina\MJOSE

Las cadenas de texto literales pueden contener múltiples líneas. Una forma es usar triple comillas: ("""...""")* o
('''...''')* el fin de línea son incluídos automáticamente, pero es posible prevenir esto agregando una \ al final de la
línea.

In [28]:
print("""\
OPCIONES:
-S si
-N no
""")

OPCIONES:
-S si
-N no

In [29]:
# Las cadenas de texto pueden ser concatenadas (pegadas juntas) con el operador + y repet
idas con *:
>>> 3 * 'ui' + 'pom'
Out[29]:
'uiuiuipom'

In [30]:
>>> texto = ('Poné muchas cadenas dentro de paréntesis '
... 'para que ellas sean unidas juntas.' ' asi')
>>> texto
Out[30]:

'Poné muchas cadenas dentro de paréntesis para que ellas sean unidas juntas. asi'

Las cadenas de texto se pueden indexar (subíndices),el primer carácter de la cadena tiene el índice 0. No hay un
tipo de dato para los caracteres; un carácter es simplemente una cadena de longitud uno:

In [31]:
>>> palabra = 'Cristina'
>>> palabra[0] # caracter en la posición 0
Out[31]:
'C'

In [32]:
>>> palabra = 'Cristina'
>>> palabra [-4] #empezando a contar de la derecha
Out[32]:
't'

In [33]:
>>> palabra = 'Cristina'
>>> palabra [0:4] #contando desde la pocision 0(incluida) a 4(excluida)
Out[33]:
'Cris'

Nota : como el primero es siempre incluído, y que el último es siempre excluído. Esto asegura que
s[:i] + s[i:] siempre sea igual a s:

In [34]:
>>> palabra = 'incomprensible'
>>> palabra[:2] + palabra[2:]
Out[34]:
'incomprensible'

In [35]:
#Si necesitás una cadena diferente, deberías crear una nueva:
>>> palabra = 'incomprensible'
>>> palabra[2:9] + 'der'
Out[35]:
'comprender'

Funcion len() devuelve la longitud de una cadena de texto:

In [36]:
>>> s = 'Electroencefalografista'
>>> len(s)
Out[36]:
23

listas
Puede ser escrita como una lista de valores separados por coma (ítems) entre corchetes. Las listas pueden
contener ítems de diferentes tipos, pero usualmente los ítems son del mismo tipo:

In [37]:
>>> cuadrados = [1, 4, 9, 16, 25]
>>> cuadrados
Out[37]:
[1, 4, 9, 16, 25]

In [38]:
# retornar un item
>>> cuadrados = [1, 4, 9, 16, 25]
>>> cuadrados[-1]
Out[38]:
25

In [39]:
# retornar una nueva lista
>>> cuadrados = [1, 4, 9, 16, 25]
>>> cuadrados[-3:]
Out[39]:
[9, 16, 25]
In [40]:
# operaciones con concatenacion
>>> cuadrados = [1, 4, 9, 16, 25]
>>> cuadrados + [36, 49]
Out[40]:
[1, 4, 9, 16, 25, 36, 49]

In [41]:
# lista de tipo mutable, cambiar su contenido
>>> cuadrados = [1, 4, 8, 16, 25] #Esta mal, el cuadrado de 3 es 9
>>> cuadrados[2] = 9
>>> cuadrados
Out[41]:
[1, 4, 9, 16, 25]

In [42]:
#Agregar al final
>>> H_semana = [12, 20, 56, 87, 54, 63]
>>> H_semana.append(24)
>>> H_semana
Out[42]:

[12, 20, 56, 87, 54, 63, 24]

In [43]:
# remplazar varios valores
>>> alfabeto = ['a','b', 'c', 'd', 'e', 'f' ]
>>> alfabeto [3:6] = ['D', 'E']
>>> alfabeto
Out[43]:
['a', 'b', 'c', 'D', 'E']

In [44]:
# remplazar valores por una lista vacia
>>> alfabeto = ['a','b', 'c', 'd', 'e', 'f' ]
>>> alfabeto [:] = []
>>> alfabeto
Out[44]:
[]

In [45]:
# funcion len()
>>> alfabeto = ['a','b', 'c', 'd', 'e', 'f' ]
>>> len(alfabeto)
Out[45]:
6

In [46]:
# anidar listas
>>> a = ['a','b', 'c', 'd', 'e', 'f' ]
>>> b = ['c', 'r', 'i', 's']
>>> c = ['2', '1']
>>> a [2]
Out[46]:
'c'

Primeros pasos hacia la programación

Escribir una subsecuencia inicial de la serie de Fibonacci así:

In [47]:
# Series de Fibonacci:
# la suma de dos elementos define el siguiente

def fib(n):
a, b = 0,1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()
fib(1000)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

LA SENTENCIA Sentencia if:

In [48]:
>>> # Midiendo cadenas de texto
... nombre = ['Cristina', 'Ramirez', '21']
>>> for n in nombre:
... print(n, len(n))
...

Cristina 8
Ramirez 7
21 2

In [49]:
>>> # Midiendo cadenas de texto
... palabras = ['gato', 'ventana', 'defenestrado']
>>> for p in palabras[:]: # hace una copia por rebanada de toda la lista
... if len (p) > 6:
... palabras.insert(0, p)
...
>>> palabras
Out[49]:
['defenestrado', 'ventana', 'gato', 'ventana', 'defenestrado']

La Función
la funcion Range() genera progresiones aritméticas:

In [50]:
>>> for i in range(10):
... print(i)
...

0
1
2
3
4
5
6
7
8
9
In [51]:
#generar valores que empiezan con otro numero o incremento, puede ser negativo
>>> for i in range (1, 8):
... print (i)
...

1
2
3
4
5
6
7

In [52]:

#Para iterar sobre indices de una secuencia, se combianan range() y len()

>>> c = ['kary', 'y Xoch', 'viven', 'en la', 'mansión']
>>> for i in range(len(c)):
... print(i, c[i])
...

0 kary
1 y Xoch
2 viven
3 en la
4 mansión

In [53]:

#La funcion list() para crear listas a partir de iterables

>>> list (range(11))

Out[53]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Las sentencias , , y en lazos

Las sentencias de lazo pueden tener una cláusula else que es ejecutada cuando el lazo termina, luego de agotar
la list (con for) o cuando la condición se hace falsa (con while), pero no cuando el lazo es terminado con la
sentencia break. Ejemplo de lazo, que busca números primos:

In [54]:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
... print(n, 'es igual a', x, '*', n/x)
... break
... else:
... # sigue el bucle sin encontrar un factor
... print(n, 'es un numero primo')
...

# el else pertenece al ciclo for, no al if

4 es igual a 2 * 2.0
6 es igual a 2 * 3.0
8 es igual a 2 * 4.0
9 es igual a 3 * 3.0
9 es un numero primo

La declaración continue, continua con la siguiente iteración del ciclo:

In [55]:

>>> for num in range(2, 10):

... if num % 2 == 0:
... print("Encontré un número par", num)
... continue
... print("Encontré un número", num)

Encontré un número par 2

Encontré un número 3
Encontré un número par 4
Encontré un número 5
Encontré un número par 6
Encontré un número 7
Encontré un número par 8
Encontré un número 9

La sentencia
La sentencia pass no hace nada. Se puede usar cuando una sentencia es requerida por la sintáxis pero el
programa no requiere ninguna acción.

'>>> while True:

... pass # Espera ocupada hasta una interrupción de teclado (Ctrl+C) ...

Se usa para crear clases en su minima expresion:

'>>> class MyEmptyClass:

... pass ...

Definiendo funciones

In [56]:

# escribe la serie de fibonocci hasta un limite determinado

>>> def fib(n): # escribe la serie de Fibonacci hasta n
... """Escribe la serie de Fibonacci hasta n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Ahora llamamos a la funcion que acabamos de definir:
... fib(2000)

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

La definición de una función introduce el nombre de la función en la tabla de símbolos actual. El valor del
nombre de la función tiene un tipo que es reconocido por el interprete como una función definida por el usuario.
Este valor puede ser asignado a otro nombre que luego puede ser usado como una función. Esto sirve como un
mecanismo general para renombrar:

In [57]:

# escribe la serie de fibonocci hasta un limite determinado

>>> def fib(n): # escribe la serie de Fibonacci hasta n
... """Escribe la serie de Fibonacci hasta n."""
... a, b = 0, 1
... while a < n:
... print(a, end=' ')
... a, b = b, a+b
... print()
...
>>> # Ahora llamamos a la funcion que acabamos de definir:
... fib(2000)
>>> fib
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
0 1 1 2 3 5 8 13 21 34 55 89

Una función que retorna una lista con los números de la serie de Fibonacci en lugar de imprimirlos:

In [58]:

>>> def fib2(n): # devuelve la serie de Fibonacci hasta n

... """Devuelve una lista conteniendo la serie de Fibonacci hasta n."""
... result = []
... a, b = 0, 1
... while a < n:
... result.append(a) # ver abajo
... a, b = b, a+b
... return result
...
>>> f100 = fib2(100) # llamarla
>>> f100

Out[58]:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Más sobre definición de funciones

Es posible definir funciones con un numero variable de argumentos, de tres posibles formas que pueden ser
cominadas.

Argumentos con valores por omisión

Esto crea una función que puede ser llamada con menos argumentos que los que permite.

In [59]:
# Ejemplo
def pedir_confirmacion(prompt, reintentos=4, recordatorio='Por favor, intente nuevamente!
'):
while True:
ok = input(prompt)
if ok in ('s', 'S', 'si', 'Si', 'SI'):
return True
if ok in ('n', 'no', 'No', 'NO'):
return False
reintentos = reintentos - 1
if reintentos < 0:
raise ValueError('respuesta de usuario inválida')
print(recordatorio)

#pasando sólo el argumento obligatorio: pedir_confirmacion('¿Realmente queres salir?')

#pasando uno de los argumentos opcionales: pedir_confirmacion('¿Sobreescribir archivo?',
2)
#pasando todos los argumentos: pedir_confirmacion('¿Sobreescribir archivo?', 2, "Vamos, s
olo si o no!)

i = 5
def f(arg=i):
print(arg)
i = 6
f()

Advertencia importante: El valor por omisión es evaluado solo una vez. Existe una diferencia
cuando el valor por omisión es un objeto mutable como una lista, diccionario, o instancia de la
mayoría de las clases. Por ejemplo
In [60]:

#la siguiente función acumula los argumentos que se le pasan en subsiguientes llamadas:
def f(a, L=[]):
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))

[1]
[1, 2]
[1, 2, 3]

In [61]:

#Si no se quiere que el valor por omision sea compartido, se escribe la funcion asi
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L

Palabras claves como argumentos

Las funciones también puede ser llamadas usando argumentos de palabras clave (o argumentos nombrados) de
la forma keyword = value.

In [62]:
def loro(tension, estado='muerto', accion='explotar', tipo='Azul Nordico'):
print("-- Este loro no va a", accion, end=' ')
print("si le aplicás", tension, "voltios.")
print("-- Gran plumaje tiene el", tipo)
print("-- Está", estado, "!")

...acepta un argumento obligatorio (tension) y tres argumentos opcionales (estado, accion, y tipo). Esta función
puede llamarse de cualquiera de las siguientes maneras:

In [63]:
loro(1000) # 1 argumento posicional
loro(tension=1000) # 1 argumento nombrado
loro(tension=1000000, accion='VOOOOOM') # 2 argumentos nombrados
loro(accion='VOOOOOM', tension=1000000) # 2 argumentos nombrados
loro('un millón', 'despojado de vida', 'saltar') # 3 args posicionales
loro('mil', estado='viendo crecer las flores desde abajo') # uno y uno
-- Este loro no va a explotar si le aplicás 1000 voltios.
-- Gran plumaje tiene el Azul Nordico
-- Está muerto !
-- Este loro no va a explotar si le aplicás 1000 voltios.
-- Gran plumaje tiene el Azul Nordico
-- Está muerto !
-- Este loro no va a VOOOOOM si le aplicás 1000000 voltios.
-- Gran plumaje tiene el Azul Nordico
-- Está muerto !
-- Este loro no va a VOOOOOM si le aplicás 1000000 voltios.
-- Gran plumaje tiene el Azul Nordico
-- Está muerto !
-- Este loro no va a saltar si le aplicás un millón voltios.
-- Gran plumaje tiene el Azul Nordico
-- Está despojado de vida !
-- Este loro no va a explotar si le aplicás mil voltios.
-- Gran plumaje tiene el Azul Nordico
-- Está viendo crecer las flores desde abajo !

Tambien son validas:

In [64]:
loro() # falta argumento obligatorio
loro(tension=5.0, 'muerto') # argumento posicional luego de uno nombrado
loro(110, tension=220) # valor duplicado para el mismo argumento
loro(actor='Juan Garau') # nombre del argumento desconocido
File "<ipython-input-64-2e5e946e0326>", line 2
loro(tension=5.0, 'muerto') # argumento posicional luego de uno nombrado
^
SyntaxError: positional argument follows keyword argument

Ningún argumento puede recibir más de un valor al mismo tiempo.

Listas de argumentos arbitrarios

Cualquier parámetro que suceda luego del *args será 'sólo nombrado', o sea que sólo se pueden usar como
nombrados y no posicionales.:

In [ ]:

>>> def concatenar(*args, sep="/"):

... return sep.join(args)
...
>>> concatenar("Lunes", "Martes", "Miercoles", "Jueves")

In [ ]:

>>> def concatenar(*args, sep="/"):

... return sep.join(args)
...
>>> concatenar("Lunes", "Martes", "Miercoles", "Jueves", sep=".")

Expresiones lambda
Esta función retorna la suma de sus dos argumentos: lambda a, b: a + b .

Lambda pueden ser usada en cualquier lugar donde sea requerido un objeto de tipo función.
Están sintácticamente restringidas a una sola expresión.
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 variables desde el
ámbito que la contiene:

In [ ]:

>>> def hacer_incrementador(n):

... return lambda x: x + n
...
>>> f = hacer_incrementador(42)
>>> f(0)

In [ ]:

>>> def hacer_incrementador(n):

... return lambda x: x + n
...
>>> f = hacer_incrementador(42)
>>> f(1)

Cadenas de texto de documentación

ejemplo de un docstring multi-línea:

In [ ]:
>>> def mi_funcion():
... """No hace mas que documentar la funcion.
...
... No, de verdad. No hace nada.
... """
... pass
...
>>> print(mi_funcion.__doc__)

# xD

Anotación de funciones
Ejemplo de un argumento posicional, uno nombrado, y el valor de retorno anotado:

In [ ]:
>>> def f(jamon: str, huevos: str = 'huevos') -> str:
... print("Anotaciones:", f.__annotations__)
... print("Argumentos:", jamon, huevos)
... return jamon + ' y ' + huevos
...
>>> f('carne')