I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
En cambio, si alguno de los números es real:
Can you write Python code for it?

divisor = 3.0
resultado = dividendo / divisor
print resultado
print type(resultado)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Esto cambia en Python 3, donde la / hace la división real (por más que le pases dos números enteros) y la // hace la división entera.
Complejos
Python, a diferencia de la mayoría de los lenguajes, también soporta los números complejos. Tal vez éste es uno de los motivos por los que Python se usa tanto en el campo científico.
Can you write Python code for it?

complejo = 5 + 3j
print complejo
print type(complejo)
complejo_cuadrado = complejo ** 2
print '(5+3j)*(5+3j) = 5*5 + 5*3j + 3j*5 + 3j*3j = (25-9) + 30j'
print complejo_cuadrado


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Ingreso de datos desde teclado
Can you write Python code for it?

numero = raw_input('Ingrese un número: ')
print numero
print type(numero)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Muchas formas de imprimir el número 25
Can you write Python code for it?

print "--{0}--".format(25)
print "--{0:4}--".format(25)  # Ocupando 4 espacios
print "--{0:04}--".format(25)  # Ocupando 4 espacios y rellenando con 0
print "--{0:b}--".format(25)  # En binario
print "--{0:x}--".format(25)  # En hexadecimal
print "--{0:04x}--".format(25)  # En binario y ocupando 4 espacios y rellenando con 0


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
None
None es el tipo de dato nulo que sólo puede tomar un valor: None. Aunque parezca que es muy inútil, en realidad se usa mucho.
<!--
## Mutables vs Inmutables

En algunas ocasiones

-->

Estructuras de control
Así como en Pascal se delimitan los bloques de código con las palabras reservadas begin y end, en Python se usan la indentación (espacios) para determinar qué se encuentra dentro de una estructura de control y qué no.
if
Can you write Python code for it?

numero1 = 1
numero2 = 2

if numero1 == numero2:
    print 'Los números son iguales'

print 'Este string se imprime siempre'

print 'Ahora cambio el valor de numero2'
numero2 = 1

if numero1 == numero2:
    print 'Los números son iguales'

print 'Este string se imprime siempre'


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Operaciones entre reales y enteros
¿Y si dividimos dos números enteros?, ¿dará un número real?
Can you write Python code for it?

dividendo = 5
divisor = 3
resultado = dividendo / divisor
print resultado
print type(resultado)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Reales
Can you write Python code for it?

numero_real = 7.5
print numero_real
print type(numero_real)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Si bien Python soporta aritmética de complejos, la verdad es que no es uno de los tipos de datos más usados. Sin embargo, es bueno saber que existe.
Booleanos
Python también soporta el tipo de dato booleano:
Can you write Python code for it?

boolean = True
print boolean
print not boolean
print type(boolean)
print True or False and True


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
También se puede crear un boolean a partir de comparar dos números:
Can you write Python code for it?


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
if-else
Can you write Python code for it?

numero1 = 1
numero2 = 1

if numero1 == numero2:
    print 'Los números son iguales'
else:
    print 'Los números son distintos'


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
short-if
Otra forma de escribir el if en una sola línea es poner:
Python
variable = valor1 if condicion else valor2
Por ejemplo:
Can you write Python code for it?

num = 5
es_par = True if (num % 2 == 0) else False
print '5 es par?:', es_par

num = 6
es_par = True if (num % 2 == 0) else False

print '6 es par?:', es_par

nulo = None
print nulo
print type(nulo)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
¿Y qué pasa si a un entero le sumamos un real?
Can you write Python code for it?

print numero_entero + numero_real
print type(numero_entero + numero_real)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
¿Y si ahora le sumamos 1?
Can you write Python code for it?

numero_muy_grande += 1
print numero_muy_grande
print type(numero_muy_grande)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
¿Y si queremos hacer la división entera por más que uno de los números sea real?
Can you write Python code for it?

cociente = dividendo // divisor
print "cociente: ", cociente
print type(cociente)

resto = dividendo % divisor
print "resto: ", resto
print type(resto)


I am working on the file "Clase 01 - Introducción y estructuras selectivas.ipynb".
The first task is:
Índices y Slice en string
Si queremos obtener un caracter del string podemos acceder a él simplemente con poner entre corchetes su posición (comenzando con la 0):
Can you write Python code for it?

cadena_caracteres = 'Hola mundo'
print cadena_caracteres
print 'El septimo caracter de la cadena "{0}" es "{1}"'.format(cadena_caracteres, cadena_caracteres[6])


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Diccionarios
El equivalente a los registros de Pascal serían los diccionarios, pero éstos también ofrecen mayor flexibilidad:
Can you write Python code for it?

print 'Podría usar los registros para guardar los datos de un alumno'

registro = {
    'padron': 98128,
    'nombre': 'Rodriguez, Carlos'
}

print registro
print type(registro)
print

print 'Y una vez que el alumno rinda el parcial, le puedo agregar',
print ' la nota a ese registro'

registro['nota'] = 6
print registro
print

print 'Incluso le puedo agregar un diccionario que tenga las notas',
print 'de los trabajos prácticos. '
registro['TPs'] = {1: 4, 2: 8}
print registro
print 'Prestar atención que las claves del diccionario de trabajo',
print 'práctico son números enteros.'
print 'La nota del TP 2 es:', registro['TPs'][2]


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
El operador in también funciona para strings (es case sensitive):
Can you write Python code for it?

print 'mundo in "Hola mundo": ', 'mundo' in "Hola mundo"
print 'MUNDO in "Hola mundo": ', 'MUNDO' in "Hola mundo"


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
En ningún momento dijimos que la lista era de enteros, por lo que tranquilamente podemos guardar elementos de distintos tipos de datos
Can you write Python code for it?

lista_de_cosas = [2, 5.5, 'letras', [1, 2, 3],
                  ('tupla', 'de', 'strings')]
print lista_de_cosas


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Existe una función llamada range que crea permite crear listas de números:
Can you write Python code for it?

print range.__doc__
print
print 'Ejemplos:'
print '  range(15):', range(15)
print '  range(15)[2:9]:', range(15)[2:9]
print '  range(15)[2:9:3]:', range(15)[2:9:3]
print '  range(2,9):', range(2,9)
print '  range(2,9,3):', range(2,9,3)


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Incluso, si queremos imprimir los valores de una lista que nosotros armamos, también podemos hacerlo:
Can you write Python code for it?


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Las listas tienen una función llamada pop que lo que hace es tomar el último elemento de ella y lo elimina:
Can you write Python code for it?

lista = range(5)
print 'La lista antes de entrar al while tiene:', lista
while lista:  # Si la lista no esta vacía, sigo sacando elementos
    print lista.pop()

print 'La lista después de salir del while tiene:', lista


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Los tipos de datos inmutables son:
* int
* str
* long
* float
* bool
* None
* tuple
Los tipos de datos mutables son:
* list
* dict
* set
Para más información sobre la modificación de variables mutables e inmutables pueden ver el siguiente link
Estructuras de control repetitivas
Así como en Pascal se delimitan los bloques de código con las palabras reservadas begin y end, en Python se usan la indentación (espacios) para determinar qué se encuentra dentro de una estructura de control y qué no.
for
Si queremos imprimir los números del 0 al 14 podemos crear una lista con range y usar el for para imprimir cada valor:
Can you write Python code for it?

print range(15)
for i in range(15):
    print i


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
O incluso se le puede cambiar el tipo de dato a un campo y agregar uno nuevo:
Can you write Python code for it?

alumno = {
    'nombre': 'Juan',
    'apellido': 'Perez',
    'parcial': 2
}
print 'Alumno:', alumno

alumno['parcial'] = [2, 6]  # Cambio el tipo de dato de int a list
print 'Agrego la nota del recuperatorio:', alumno

alumno['coloquio'] = 8  # Agrego un nuevo campo
print 'Agrego la nota del coloquio:', alumno

del alumno['parcial']  # Elimino el campo nota
print 'Elimino las notas del parcial:', alumno


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Si se quiere saber si un número se encuentra en una lista o no, es muy simple, sólo hay que usar el operador in:
Can you write Python code for it?

print 'El {} esta en {}?: {}'.format(5, lista_de_numeros, 5 in lista_de_numeros)
print 'El {} esta en {}?: {}'.format(7, lista_de_numeros, 7 in lista_de_numeros)


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
También se puede usar la función zip para ir tomando los primeros elementos de una lista, después los segundos, y así sucesivamente
Can you write Python code for it?

for par in zip([1, 2, 3], [4, 5, 6]):
    print par


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Tuplas
Las tuplas son listas inmutables, es decir, que no se pueden modificar.
Si no se pueden modificar, ¿para qué existen?. Porque crearlas es mucho más eficiente que crear listas y en muchas ocasiones, como con las constantes, queremos crear variables que no se modifiquen.
Can you write Python code for it?

tupla = (1, 2, 3, 4)  # Se usa paréntesis en lugar de corchetes
print tupla

tupla = tupla[2:4]
print tupla
print type(tupla)


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
Y si le queremos modificar la nota a un alumno, sólo tenemos que acceder a ese campo y asignarle un nuevo valor:
Can you write Python code for it?

alumno = {
    'nombre': 'Juan',
    'apellido': 'Perez',
    'nota': 2
}
print alumno

alumno['nota'] = 5
print alumno


I am working on the file "Clase 02 - Tipos de datos computestos y ciclos.ipynb".
The first task is:
while
El ciclo while también ejecuta un bloque de código mientras la condición sea verdadera:
Can you write Python code for it?

numero = 5
while numero < 10:
    print numero
    numero += 1


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Además, a esta función le podría agregar comentarios (docstrings) para que al hacer help de la función se entienda qué es lo que hace:
Can you write Python code for it?

def sumar(x, y):
    """Suma dos elementos y retorna el resultado.
    """
    return x + y

help(sumar)


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Ahora, si la función es un tipo de dato, significa que se lo puedo asignar a una variable...
Can you write Python code for it?


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Entonces, nos podría quedar:
Python
def suma_y_resta(x, y):
    """Función que suma y resta dos números."""
    return x+y, x-y
Y si vamos un poco más allá, el unpacking de una lista o tupla se puede hacer en una sóla instrucción
Can you write Python code for it?

x, y, z = [1, [2, 3, 4, 5], 3]
print x
print y
print z


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Lista de parámetros
¿Qué pasa cuando no sabemos cuántos parámetros nos pueden pasar, pero si sabemos qué hacer con ellos?
Can you write Python code for it?

def sumar(*lista_de_numeros):
    suma = 0
    for e in lista_de_numeros:
        suma += e

    return suma

print sumar(1, 2)
print sumar(1, 2, 3, 4, 5)
print sumar(*[1, 2, 3, 4, 5, 6])
print sumar


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Lo mismo pasa si lo que quiero cambiar es el cuatro parámetro:
Can you write Python code for it?


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Parámetros por defecto
Algo más común que no saber la cantidad de parámetros que nos van a pasar es asumir que ciertos parámetros pueden no pasarlos y para ellos asumiremos un valor por defecto. <br>
Por ejemplo:
Can you write Python code for it?

def imprimir_parametros(param1, param2, param3=5,
                        param4="es el cuarto parametro",
                        param5=False):
    print param1, param2, param3, param4, param5


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Pasaje de parámetros
A diferencia de otros lenguajes, en Python todos los parámetros que se le pasan a una función son siempre por referencia, es decir, cualquier modificación que sufran dentro de la función, también se verá reflejada fuera de la misma. <br>
Sin embargo, cuando le pasamos un parámetro inmutable, como puede ser un int, bool o una tupla, si el parámetro formal se modifica, el parámetro actual no verá esa moficación ya que en realidad se modificó otra posición de memoria:
Can you write Python code for it?

def multiplicar_y_agregar(num, lista):
    num *= 2
    lista.append(num)
    print 'Dentro de la función num vale {num} y ' \
          'lista vale {lista}'.format(num=num, lista=lista)

lista = []
n = 2
print '1. Al comenzar num vale {num} y lista ' \
      'vale {lista}'.format(num=n, lista=lista)
multiplicar_y_agregar(n, lista)
print '2. Fuera de la función num vale {num} y ' \
      'lista vale {lista}'.format(num=n, lista=lista)
print
n *= 3
print 'Ahora multiplico por 3: n *= 3 --> n = {}'.format(n)
multiplicar_y_agregar(n, lista)
print '3. Fuera de la función num vale {num} y lista ' \
      'vale {lista}'.format(num=n, lista=lista)


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Por lo que también podemos cambiar la forma en que se desempacan esos valores que retorna la función y nos podría quedar:
Can you write Python code for it?

def suma_y_resta(x, y):
    """Función que suma y resta dos números."""
    return x+y, x-y

suma, resta = suma_y_resta(23, 5)

print 'La suma es: ', suma
print 'La resta es: ', resta


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Si bien puede parecer innecesario el uso de parámetros nombrados, en algunas oportunidades se suele usar para agregar claridad y legibilidad al código, y en otros para pasarle un diccionario:
Can you write Python code for it?

parametros = {
    'param1': 1,
    'param2': 2,
    'param3': 3,
    'param4': 4,
    'param5': 5,
}

imprimir_parametros(**parametros)


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
Uso de módulos externos
Así como en Pascal usando la cláusula Uses podíamos usar código que no pertenecía al archivo que estábamos codificando, en Python podemos hacer lo mismo usando la cláusula import y poniendo a continuación el nombre del módulo.

Por ejemplo, si queremos importar el módulo datetime para trabajar con fechas y horas, tendríamos que hacer:
Python
import datetime
Para usarlo simplemente tenemos que poner el nombre del módulo, un punto y la función que queramos usar.

En este caso, dentro del módulo datetime vamos a usar la función que se encuentra en date y se llama today().
Can you write Python code for it?

import datetime

print datetime.date.today()


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
¿Y qué pasa si ahora llamo a mi_suma con los parámetros 1 y 2 como hice antes con sumar?
Can you write Python code for it?

print mi_suma(1, 2)
print id(mi_suma)
print id(sumar)


I am working on the file "Clase 03 - Funciones y modulos.ipynb".
The first task is:
¿Y qué pasa si quiero pasarle los parámetros 1, 2 y el 5?. <br>
No es problema, para eso tenemos que usar parámetros nombrados:
Can you write Python code for it?

imprimir_parametros(1, 2, param5="Este el parametro5")
imprimir_parametros(1, 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Acá podemos ver todo el traceback o stacktrace, que son el cómo se fueron llamando las distintas funciones entre sí hasta que llegamos al error.

Pero no es bueno que este tipo de excepciones las vea directamente el usuario, por lo que podemos controlarlas en distintos momentos. Se pueden controlar inmediatamente donde ocurre el error, como mostramos antes, o en cualquier parte de este stacktrace.

En el caso de la regla_de_tres no nos conviene poner el try/except encerrando la línea x/y, ya que en ese punto no tenemos toda la información que necesitamos para informarle correctamente al usuario, por lo que podemos ponerla en:
Can you write Python code for it?

def dividir(x, y):
    return x/y

def regla_de_tres(x, y, z):
    resultado = 0
    try:
        resultado = dividir(z*y, x)
    except ZeroDivisionError:
        print 'No se puede calcular la regla de tres ' \
              'porque el divisor es 0'

    return resultado

print regla_de_tres(0, 1, 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Crear excepciones
Pero así como podemos usar las excepciones estándares, también podemos crear nuestras propias excepciones:
```Python
class MiPropiaExcepcion(Exception):
def __str__(self):
    return 'Mensaje del error'

```
Por ejemplo:
Can you write Python code for it?

class ExcepcionDeDivisionPor2(Exception):

    def __str__(self):
        return 'ERROR: No se puede dividir por dos'

def dividir_numeros(x, y):
    if y == 2:
        raise ExcepcionDeDivisionPor2()

    resultado = x/y

try:
    dividir_numeros(1, 2)
except ExcepcionDeDivisionPor2:
    print 'No se puede dividir por 2'

dividir_numeros(1, 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
En cambio, si le pasamos 0 en el lugar de x:
Can you write Python code for it?

resultado = regla_de_tres(0, 13, 100)
print 'Porcentaje de aprobados: %0.2f %%' % resultado


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
En esos casos podemos capturar más de una excepción de la siguiente forma:
Can you write Python code for it?

def dividir_numeros(x, y):
    try:
        resultado = x/y
        print 'El resultado es: %s' % resultado
    except TypeError:
        print 'ERROR: Ha ocurrido un error por mezclar tipos de datos'
    except ZeroDivisionError:
        print 'ERROR: Ha ocurrido un error de división por cero'
    except Exception:
        print 'ERROR: Ha ocurrido un error inesperado'

dividir_numeros(1, 0)
dividir_numeros(10, 2)
dividir_numeros("10", 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Excepciones
Una excepción es la forma que tiene el intérprete de que indicarle al programador y/o usuario que ha ocurrido un error. Si la excepción no es controlada por el desarrollador ésta llega hasta el usuario y termina abruptamente la ejecución del sistema. <br>
Por ejemplo:
Can you write Python code for it?


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Funciones anónimas
Hasta ahora, a todas las funciones que creamos les poníamos un nombre al momento de crearlas, pero cuando tenemos que crear funciones que sólo tienen una línea y no se usan en una gran cantidad de lugares se pueden usar las funciones lambda:
Can you write Python code for it?

help("lambda")

mi_funcion = lambda x, y: x+y

resultado = mi_funcion(1,2)
print resultado


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Incluso, si queremos que los dos errores muestren el mismo mensaje podemos capturar ambas excepciones juntas:
Can you write Python code for it?

def dividir_numeros(x, y):
    try:
        resultado = x/y
        print 'El resultado es: %s' % resultado
    except (ZeroDivisionError, TypeError):
        print 'ERROR: No se puede calcular la división'

dividir_numeros(1, 0)
dividir_numeros(10, 2)
dividir_numeros("10", 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Jerarquía de excepciones
Existe una jerarquía de excepciones, de forma que si se sabe que puede venir un tipo de error, pero no se sabe exactamente qué excepción puede ocurrir siempre se puede poner una excepción de mayor jerarquía:

Por lo que el error de división por cero se puede evitar como:
Can you write Python code for it?

try:
    print 1/0
except ZeroDivisionError:
    print 'Ha ocurrido un error de división por cero'


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Pero en este caso igual muestra 0, por lo que si queremos, podemos poner los try/except incluso más arriba en el stacktrace:
Can you write Python code for it?

def dividir(x, y):
    return x/y

def regla_de_tres(x, y, z):
    return dividir(z*y, x)

try:
    print regla_de_tres(0, 1, 2)
except ZeroDivisionError:
    print 'No se puede calcular la regla de tres ' \
          'porque el divisor es 0'


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Pero no hay que tenerle miedo a las excepciones, sólo hay que tenerlas en cuenta y controlarlas en el caso de que ocurran:
Can you write Python code for it?

dividendo = 1
divisor = 0
print 'Intentare hacer la división de %d/%d' % (dividendo, divisor)
try:
    resultado = dividendo / divisor
    print resultado
except ZeroDivisionError:
    print 'No se puede hacer la división ya que el divisor es 0.'


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Si bien no son funciones que se usen todos los días, se suelen usar cuando una función recibe otra función como parámetro (las funciones son un tipo de dato, por lo que se las pueden asignar a variables, y por lo tanto, también pueden ser parámetros).
Por ejemplo, para ordenar los alumnos por padrón podríamos usar:
Python
sorted(curso, key=lambda x: x['padron'])
Ahora, si quiero ordenar la lista anterior por nota decreciente y, en caso de igualdad, por padrón podríamos usar:
Can you write Python code for it?

curso = crear_alumnos(15)
print 'Curso original'
imprimir_curso(curso)

lista_ordenada = sorted(curso, key=lambda x: (-x['nota'], x['padron']))
print 'Curso ordenado'
imprimir_curso(lista_ordenada)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
También es muy fácil saber si un elemento no esta en la lista:
Can you write Python code for it?

lista = [11, 4, 6, 1, 3, 5, 7]

if 3 not in lista:
    print '3 NO esta en la lista'
else:
    print '3 SI esta en la lista'


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Todos los casos son distintos y no hay UN lugar ideal dónde capturar la excepción; es cuestión del desarrollador decidir dónde conviene ponerlo para cada problema.
Capturar múltiples excepciones
Una única línea puede lanzar distintas excepciones, por lo que capturar un tipo de excepción en particular no me asegura que el programa no pueda lanzar un error en esa línea que supuestamente es segura:
En algunos casos tenemos en cuenta que el código puede lanzar una excepción como la de ZeroDivisionError, pero eso puede no ser suficiente:
Can you write Python code for it?

def dividir_numeros(x, y):
    try:
        resultado = x/y
        print 'El resultado es: %s' % resultado
    except ZeroDivisionError:
        print 'ERROR: Ha ocurrido un error por mezclar tipos de datos'

dividir_numeros(1, 0)
dividir_numeros(10, 2)
dividir_numeros("10", 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas y ordenamientos.ipynb".
The first task is:
Y también como:
Can you write Python code for it?

try:
    print 1/0
except Exception:
    print 'Ha ocurrido un error inesperado'


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Ahora, para todos estos casos lo que hice fue buscar un elemento completo, es decir, que tenía que conocer todo lo que buscaba y no sólamente una parte, como podría ser el padrón de un alumno.
Can you write Python code for it?

curso = crear_curso()
print 'La lista tiene los alumnos:'
imprimir_curso(curso)

alumno_93716 = (alumno for alumno in curso if alumno['padron'] == 93716).next()
print 'El alumno de padron 93716 se llama {nombre}'.format(**alumno_93716)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Búsquedas en listas
Para saber si un elemento se encuentra en una lista, alcanza con usar el operador in:
Can you write Python code for it?

lista = [11, 4, 6, 1, 3, 5, 7]

if 3 in lista:
    print '3 esta en la lista'
else:
    print '3 no esta en la lista'

if 15 in lista:
    print '15 esta en la lista'
else:
    print '15 no esta en la lista'


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
En esos casos podemos capturar más de una excepción de la siguiente forma:
Can you write Python code for it?


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Funciones anónimas
Hasta ahora, a todas las funciones que creamos les poníamos un nombre al momento de crearlas, pero cuando tenemos que crear funciones que sólo tienen una línea y no se usan en una gran cantidad de lugares se pueden usar las funciones lambda:
Can you write Python code for it?

help("lambda")

mi_funcion = lambda x, y: x+y

resultado = mi_funcion(1, 2)
print resultado
print type(mi_funcion)

def mi_funcion2(x, y):
    return x + y

resultado = mi_funcion2(1, 2)
print resultado
print type(mi_funcion2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Jerarquía de excepciones
Existe una jerarquía de excepciones, de forma que si se sabe que puede venir un tipo de error, pero no se sabe exactamente qué excepción puede ocurrir siempre se puede poner una excepción de mayor jerarquía:

Por lo que el error de división por cero se puede evitar como:
Can you write Python code for it?


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Lanzar excepciones
Hasta ahora vimos cómo capturar un error y trabajar con él sin que el programa termine abruptamente, pero en algunos casos somos nosotros mismos quienes van a querer lanzar una excepción. Y para eso, usaremos la palabra reservada raise:
Can you write Python code for it?

def dividir_numeros(x, y):
    if y == 0:
        raise Exception('Error de división por cero')

    resultado = x/y
    print 'El resultado es {0}'.format(resultado)

try:
    dividir_numeros(1, 0)
except ZeroDivisionError as e:
    print 'ERROR: División por cero'
except Exception as e:
    print 'ERROR: ha ocurrido un error del tipo Exception'

print '----------'
dividir_numeros(1, 0)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Pero entonces, ¿por qué no poner ese código dentro del try-except?. Porque tal vez no queremos capturar con las cláusulas except lo que se ejecute en ese bloque de código:
Can you write Python code for it?

def dividir_numeros(x, y):
    try:
        resultado = x/y
        print 'El resultado es {}'.format(resultado)
    except ZeroDivisionError:
        print 'Error: División por cero'
    else:
        print 'Ahora hago que ocurra una excepción'
        print 1/0
    finally:
        print 'Este bloque de código se muestra siempre'

dividir_numeros(1, 0)
print '-------------'
dividir_numeros(10, 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
También es muy fácil saber si un elemento no esta en la lista:
Can you write Python code for it?


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Todos los casos son distintos y no hay UN lugar ideal dónde capturar la excepción; es cuestión del desarrollador decidir dónde conviene ponerlo para cada problema.
Capturar múltiples excepciones
Una única línea puede lanzar distintas excepciones, por lo que capturar un tipo de excepción en particular no me asegura que el programa no pueda lanzar un error en esa línea que supuestamente es segura:
En algunos casos tenemos en cuenta que el código puede lanzar una excepción como la de ZeroDivisionError, pero eso puede no ser suficiente:
Can you write Python code for it?

def dividir_numeros(x, y):
    try:
        resultado = x/y
        print 'El resultado es: %s' % resultado
    except ZeroDivisionError:
        print 'ERROR: Ha ocurrido un error por dividir por 0'

dividir_numeros(1, 0)
dividir_numeros(10, 2)
dividir_numeros("10", 2)


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
Y también como:
Can you write Python code for it?


I am working on the file "Clase 04 - Excepciones, funciones lambda, búsquedas.ipynb".
The first task is:
¿Y si lo que quiero ordenar es una lista de registros?. <br>
Podemos pasarle una función que sepa cómo comparar esos registros o una que sepa devolver la información que necesita comparar.
Can you write Python code for it?

def crear_curso():
    curso = [
        {'nombre': 'Rodriguez, Carlos', 'nota': 6, 'padron': 98128},
        {'nombre': 'Perez, Lucas', 'nota': 6, 'padron': 93453},
        {'nombre': 'Gonzalez, Ramiro', 'nota': 8, 'padron': 93716},
        {'nombre': 'Gonzalez, Carlos', 'nota': 6, 'padron': 90464},
        {'nombre': 'Lopez, Carlos', 'nota': 7, 'padron': 98569}
    ]

    return curso

def imprimir_curso(lista):
    for idx, x in enumerate(lista):
        msg = '    {pos:2}. {padron} - {nombre}: {nota}'
        print msg.format(pos=idx, **x)

def obtener_padron(alumno):
    return alumno['padron']

curso = crear_curso()
print 'La lista tiene los alumnos:'
imprimir_curso(curso)

lista_ordenada = sorted(curso, key=obtener_padron)
print 'Y la lista ordenada por padrón:'
imprimir_curso(lista_ordenada)


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Aunque Python también nos ofrece otra forma de recorer un archivo, y es usando una de las estructuras que ya conocemos: for
Can you write Python code for it?

arch = open("ejemplo.txt")

# Si no sabemos la cantidad de líneas que tiene
# el archivo que queremos recorrer podemos hacer:

x = 0
for linea in arch:
    x += 1
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)

arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Aunque en realidad los números no son obligatorios:
Can you write Python code for it?

print 'El nombre del jugador número {} es {}'.format(10, 'Lionel Messi')


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Escritura de archivos
Para escribir en un archivo podemos usar las las primitivas write(string) y writelines(lista_strings), que la primera es para escribir una cadena de caracteres y la segunda para escribir una lista de strings, uno a continuación del otro. Es importante destacar que en ningún caso se escribe algún carácter que no figure en los strings, como por ejemplo, caracteres de fin de línea.

El uso de writelines es equivalente a recorrer la lista y hacerle un write a cada elemento.

Pero el costo de escribir algo en el disco es mucho mayor a escribirlo en memoria por lo que, al igual que en C, se usa un buffer, que no es más que una porción de memoria para ir guardando en forma temporal los datos y cuando alcanzan un tamaño considerable se lo manda a escribir al disco. Otra forma de asegurarse que se haga la escritura es usando la primitiva flush, la cual guarda en el disco el contenido del buffer y lo vacía.

Can you write Python code for it?

arch2 = open("ejemplo2.txt", "w")
arch2.write("Es la primer cadena")
arch2.write("Seguida de la segunda con un fin de linea\n")
arch2.writelines(["1. Primero de la lista sin fin de línea. ", "2. Segundo string con fin de línea.\n", "3. Tercero con\\n.\n", "4. y último."])
arch2.flush()
arch2.close()
arch2 = open("ejemplo2.txt", "r+a")
strfile = arch2.read()
print strfile


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Incluso, si en lugar de pasarle cada uno de los parámetros le pasamos un diccionario usando el operador **
Can you write Python code for it?

alumno = {
    'padron': 123,
    'nombre': 'Carlos Sanchez',
    'nota': 8
}

print 'La nota del alumno {padron} - {nombre} es un {nota}.'.\
    format(**alumno)


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
La única condición que tenemos para usar este método es que el archivo lo hayamos abierto en modo lectura.
Can you write Python code for it?

arch2 = open("ejemplo2.txt", "w")
arch2.read()

# Y si intentamos con un append?
arch3 = open("ejemplo1.txt", "a")
arch3.read()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
O, incluso, usar enumerate para saber qué línea estoy leyendo:
Can you write Python code for it?

arch = open("ejemplo.txt")

# Si no sabemos la cantidad de líneas que tiene
# el archivo que queremos recorrer podemos hacer:

# Usando enumerate y comenzando en 1
for x, linea in enumerate(arch, 1):
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)

arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Otra forma de asegurarse que se escriba lo que hay en el disco es cerrándolo.
Moverse en un archivo
Al igual que en los archivos binarios de Pascal, en Python también podemos saltar a distintas posiciones mediante la primitiva seek(pos) la cual recibe, como mínimo un parámetro que indica la posición a la que nos queremos mover. Opcionalmente puede recibir un segundo parámetro:
* 0: La posición es desde el inicio del archivo y debe ser mayor o igual a 0
* 1: La posición es relativa a la posición actual; puede ser positiva o negativa
* 2: La posición es desde el final del archivo, por lo que debe ser negativa
Can you write Python code for it?

arch = open("ejemplo.txt")
arch.seek(30)        # Voy a la posición número 30 del archivo
print arch.read(7)   # Debería salir 'y 1990s'
arch.seek(-5,1)      # Me muevo 5 posiciones para atrás desde mi posición actual.
print arch.read(7)   # Debería imprimir '1990s b'
arch.seek(-12,2)     # Me muevo a la posición número 12, comenzando a contar desde el final.
print arch.read(10)  # Debería imprimir 'compatible'

arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Otra primitiva que podemos usar es readline, que al igual que read, también puede recibir un parámetro que indique la cantidad máxima de bytes a leer. Si no se le pasa ningún parámetro, lee toda la línea.
Can you write Python code for it?

arch = open("ejemplo.txt")
linea = arch.readline()  # Notar que también imprime el Enter o \n
print linea
linea = arch.readline(7)  # La segunda línea es 'Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands'
print linea
arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Pero no es necesario que leamos de a una sola línea, sino que también podemos leer todas las líneas del archivo y guardarlas en una lista haciendo uso de la primitiva readlines.
Can you write Python code for it?

arch = open("ejemplo.txt")
lineas = arch.readlines()
print lineas
arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Pero si no queremos imprimir ese último Enter lo que tenemos que hacer es poner una coma al final de la línea:
Can you write Python code for it?

print 'Pero al imprimir con la coma al final',
print 'cambia el enter por un espacio'
print 'También puedo escribir lo mismo' ' en dos partes'
print 'Lo que puedo usar ' \
    'cuando un string es muy largo' \
    'si le agrego una contrabarra'


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Pueden ver más ejemplos en la documentación oficial de Python<br>
También se puese usar el signo % para construir un string, aunque no suele quedar tan claro el código:
Funciones de los strings
También existen varias funciones que podemos usar cuando trabajamos con strings:
Can you write Python code for it?

cadena_caracteres = 'Hola mundo'
print '"{0}" cambia a "{1}" con title'.format(cadena_caracteres, cadena_caracteres.title())
print '"{0}" cambia a "{1}" con lower'.format(cadena_caracteres, cadena_caracteres.lower())
print '"{0}" cambia a "{1} con upper"'.format(cadena_caracteres, cadena_caracteres.upper())
print '"{0}" cambia a "{1}" con capitalize'.format(cadena_caracteres, cadena_caracteres.capitalize())
print '"{0}" cambia a "{1}" cuando reemplazamos las o por 0'.format(cadena_caracteres, cadena_caracteres.replace('o', '0'))

x = 'mi string'
y = x.replace('i', 'AA')
print x, y
print id(x)
x += 'Hola mundo'
print id(x)


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Sin embargo, la forma más Pythonic de leer el archivo por líneas es usando la estructura for y quedaría casi como lo diríamos en castellano: "Para cada línea del archivo. <br>
Por ejemplo, si queremos imprimir la cantidad de caracteres de cada línea podríamos hacer:
Can you write Python code for it?

arch = open("ejemplo.txt")
for linea in arch:
    print len(linea)

arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
String formating
Existen varias formas crear, concatenar e imprimir strings:
¿Cómo imprimir un string?
Para imprimir un string sólo es necesario usar la palabra print:
Can you write Python code for it?

print 'Hola mundo'
print 'Pero el print también imprime un Enter al terminar la línea'


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Unicodes
Los strings ocupan 1 byte en memoria, por lo que sólo se pueden representar 256 caractéres distintos; pero, si queremos representar los caracteres de todos los idiomas, 255 caracteres no son suficientes. Debido a esto, es que surgieron distintas codificaciones de los archivos, como pueden latin-1 (iso-8859-1), utf-8, etc.

Y si bien en un principio esto fue una solución, la verdad es que con el tiempo trajo mucho problemas por no saber cómo interpretar cada letra.

Para solucionar este problema es que Python introdujo en la versión 2.0 los caracteres de tipo unicode que pasaron a ocupar 2 bytes, por lo que ahora se pueden representar 65.536 todos los caracteres necesarios.

En Python 3 todos los strings pasaron a ser del tipo Unicode.
Persistencia de datos
Pero todo lo que vimos por el momento se guarda en memoria dinámica, por lo que al apagar la computadora, o simplemente con cerrar el programa y volver a abrirlo perdimos todos los datos que nos teníamos. La alternativa para esto siguen siendo los archivos.
Apertura de archivos
Al igual que en C, en Python en el mismo momento que abrimos el archivo, se lo asignamos a uno físico y elegimos el modo de apertura, que si no le indicamos nada, tomará por defecto el de lectura.

El modo de apertura puede ser cualquier combinación de:

'r' Lectura: el archivo debe existir. Similar al reset de Pascal.
'w' Escritura: no es necesario que el archivo exista, pero si existe lo sobre escribe. Similar al rewrite de Pascal.
'a' Append: Solo agrega al final y no es necesario que el archivo exista. Similar al append de Pascal.
't' Texto: Archivo de texto
'b' Binario: Archivo binario
'+' *Permite lectura y escrituras simultáneas

La primitiva del lenguaje para abrir y asignar un archivo es open, la cual puede recibir uno o dos parámetros. El primero es obligatorio, y corresponde a la ubicación relativa o absoluta del archivo físico. El segundo parámetro indica el modo de apertura y es opcional. Si no se lo pasamos asumirá que lo queremos abrir en...
Can you write Python code for it?

arch = open("ejemplo.txt")
cadena = arch.read(15)
print "# Imprimo los primeros 15 caracteres del archivo. Tiene que ser 'Python was crea'"
print cadena

print "# Leo otros 7 caracteres y dejo el cursor del archivo en la siguiente posición. Tiene que ser 'ted in '"
cadena = arch.read(7)
print cadena

print "# Ahora leo el resto del archivo."
cadena = arch.read()
print cadena

print '# Cierro el archivo'
arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
Y así como podemos movernos en un archivo, también podemos averiguar nuestra posición usando la primitiva tell().
Can you write Python code for it?

arch = open("ejemplo.txt")
arch.seek(30)
print arch.tell()    # Debería imprimir 30
arch.seek(-5,1)      # Retrocedo 5 posiciones
print arch.tell()    # Debería imprimir 25
arch.seek(-12,2)     # Voy a 12 posiciones antes del fin de archivo
print arch.tell()    # Debería imprimir 1132
print arch.read(10)  # Leo 10 caracteres
print arch.tell()    # Debería imprimir 1142


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
¿Cómo recorrer todo un archivo?
Cuando llegamos al final de un archivo de texto usando la función read o readline Python no arroja ningún valor, pero tampoco retorna ningún caracter, por lo que podríamos usar eso como condición de corte:
Can you write Python code for it?

arch = open("ejemplo.txt")

# El archivo ejemplo.txt tiene 22 líneas, por lo que
# si quiero imprimirlo completo anteponiendo el
# número de línea y la cantidad de caracteres
# puedo hacer:

for x in range(1, 25):
    linea = arch.readline()
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)

arch.close()


I am working on the file "Clase 05 - Manejo de strings y Archivos de texto .ipynb".
The first task is:
¿Y si lo que quiero es imprimir un número pegado al string?
Can you write Python code for it?

print 'Entonces tengo que ponerlo después de la coma:', 5
print 'Al que también le agrega la coma para separarlo'
print 'También puedo ponerlo en el medio:\nHoy es', 29, 'de Octubre'


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
Actualizar archivo con novedades
Cuando tiene toda la información en un único archivo (comúnmente llamado archivo maestro) y en cierto momento se la quiere actualizar a partir de un segundo archivo llamado novedades se genera un tercer archivo con toda la información consolidada. <br>
Los archivos maestro y novedades deberán estar ordenados por la misma clave, por lo que el nuevo archivo maestro también debe quedar ordenado.
Por ejemplo, si contamos con un archivo llamado cuentas.pkl que en casa posición tiene la información correspondiente a una cuenta bancaria:

nro_cuenta: Número de cuenta
tituar: Titular de la cuenta
saldo: Saldo de la cuenta
tipo_cuenta: Tipo de cuenta
moneda: Moneda en la cual opera la cuenta

Y uno que tenga las novedades diarias llamado movimientos.pkl con la siguiente información:

tipo: Tipo de movimiento, es un string de una letra que puede ser A (alta), B (baja), M (modificación)
nro_cuenta
Si es:
alta(se asume saldo 0):
titular
tipo_cuenta
moneda

modificación:
tipo_movimiento: Un string que será una de las siguientes opciones: "credito" (cuando ingresa plata a la cuenta) o "debito" (cuando extraen plata de la cuenta)
monto: Monto a acreditar o debitar de la cuenta

baja: no es necesario agregar más campos
Can you write Python code for it?

import utils

def crear_archivo_maestro():
    cuentas = [
        {'nro_cuenta': 1, 'saldo': 7094, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_1'},
        {'nro_cuenta': 2, 'saldo': 2896, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_2'},
        {'nro_cuenta': 3, 'saldo': 14424, 'moneda': '$',
         'tipo_cuenta': 'corriente', 'titular': 'cliente_3'},
        {'nro_cuenta': 5, 'saldo': 7156, 'moneda': '$',
         'tipo_cuenta': 'corriente', 'titular': 'cliente_5'},
        {'nro_cuenta': 8, 'saldo': 7500, 'moneda': '$',
         'tipo_cuenta': 'corriente', 'titular': 'cliente_8'},
        {'nro_cuenta': 9, 'saldo': 2128, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_9'},
        {'nro_cuenta': 13, 'saldo': 13524, 'moneda': '$',
         'tipo_cuenta': 'corriente', 'titular': 'cliente_13'},
        {'nro_cuenta': 15, 'saldo': 9479, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_15'},
        {'nro_cuenta': 21, 'saldo': 8462, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_21'},
        {'nro_cuenta': 25, 'saldo': 6258, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_25'},
        {'nro_cuenta': 32, 'saldo': 14082, 'moneda': '$',
         'tipo_cuenta': 'debito', 'titular': 'cliente_32'}
    ]
    with open('cuentas.pkl', 'wb') as archivo:
        for cuenta in cuentas:
            utils.guardar_en_archivo(archivo, cuenta)

def crear_archivo_novedades():
    novedades = [
        {'nro_cuenta': 1, 'tipo': 'B'},
        {'nro_cuenta': 2, 'monto': 731,
         'tipo_movimiento': 'debito', 'tipo': 'M'},
        {'nro_cuenta': 3, 'monto': 791,
         'tipo_movimiento': 'debito', 'tipo': 'M'},
        {'nro_cuenta': 4, 'moneda': '$',
         'tipo_cuenta': 'corriente',
         'titular': 'cliente_4', 'tipo': 'A'},
        {'nro_cuenta': 8, 'monto': 750,
         'tipo_movimiento': 'debito', 'tipo': 'M'},
        {'nro_cuenta': 11, 'moneda':...


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
Ejemplo 2: Guardo una lista de elementos
Así como en el ejemplo anterior guardamos de a un elemento por vez, también podríamos guardar una lista completa que tenga todos los elementos en memoria. De ésta forma, los archivos podrían usarse para cargar los datos al comenzar el programa y guardarlos todos juntos antes de terminar. <br>
Suponiendo que estoy desarrollando un juego en que no van a haber muchos jugadores compitiendo entre si, podría tener una lista con los puntajes y hacer:
Can you write Python code for it?

lista = [  # Creo la lista que quiero guardar
    {'usuario': 'csanchez', 'puntaje': 5},
    {'usuario': 'pperez', 'puntaje': 3},
    {'usuario': 'jromero', 'puntaje': 1},
]

# Guardo la lista en el archiv
with open('ejemplo_2.pkl', 'wb') as archivo:
    pkl = pickle.Pickler(archivo)
    pkl.dump(lista)


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
Para leer de un archivo pickle no puedo usar el método readline que usa la estructura for, por lo que no me queda otra que siempre intentar leer hasta que lance una excepción del tipo EOFError:
Can you write Python code for it?

import pickle
with open('ejemplo.pkl', 'rb') as archivo:
    print pickle.load(archivo)  # lista1
    print pickle.load(archivo)  # None
    print pickle.load(archivo)  # lista2
    print pickle.load(archivo)  # Hola mundo
    print pickle.load(archivo)  # ''
    print pickle.load(archivo)  # diccionario
    print pickle.load(archivo)  # 1
    print pickle.load(archivo)  # Fin de archivo

with open('ejemplo.pkl', 'rb') as archivo:
    seguir_leyendo = True
    while seguir_leyendo:
        try:
            dato = pickle.load(archivo)  # Leo del archivo un elemento
            print dato
        except EOFError:
            seguir_leyendo = False


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
Si bien es muy práctica esta alternativa, tiene el gran inconveniente de no hacer un uso eficiente de la memoria.

Si el archivo contiene millones de usuarios, los estaríamos levantando todos a memoria, con el gran costo que tiene eso (no sólo en espacio, sino también en tiempo) con el único objetivo de sumarle 3 puntos a un único usuario. Y una vez que actualizamos el puntaje de ese usuario, tendríamos que volver a guardar todo el archivo en el disco.
Abstrayendonos del uso de los pickles
Si bien el uso de los pickles puede resultar muy útil, la forma de leer la información guardada en ellos no suele ser muy cómoda. Por lo que podríamos implementar en un archivo utils.py las siguientes dos funciones para abstraernos un poco de cómo se accede a los datos:
```Python
encoding: utf8
import pickle
def guardar_en_archivo(archivo, contenido):
    """Guarda lo que le pasen como segundo parámetro en el archivo
    que recibe como primer parámetro.
    El parámetro llamado archivo tiene que estar abieto en modo
    binario y para escritura (wb)
    """
    pickler = pickle.Pickler(archivo)
    pickler.dump(contenido)
def leer_desde_archivo(archivo, valor_por_defecto=None):
    """Lee del archivo archivo un registro y lo retorna junto con una
    variable booleana que indica si llegó al fin de archivo o no.
    El parámetro llamado archivo tiene que estar abieto en modo
    binario y para lectura (rb).
    Si se intenta leer más allá del fin de archivo, data valdrá lo que le
    hayan pasado en valor_por_defecto (si no le pasan nada será None)
    y fin_de_archivo será True. En cualquier otro caso fin_de_archivo
    será False.
    """
    try:
        data = pickle.load(archivo)
        fin_de_archivo = False
    except EOFError:
        data = valor_por_defecto
        fin_de_archivo = True
    return data, fin_de_archivo
```
En este caso, se podría considerar que la función leer_desde_archivo funciona similar a cómo lo hacen los archivos con un registro centinella.

Por lo que podríamos usar:
Can you write Python code for it?

import utils

curso = [
    {'nombre': 'Sanchez, Lucas', 'nota': 8, 'padron': 90431, 'grupo': 1},
    {'nombre': 'Alvarez, Javier', 'nota': 2, 'padron': 92953, 'grupo': 1},
    {'nombre': 'Perez, Matias', 'nota': 10, 'padron': 92407, 'grupo': 1},
    {'nombre': 'Lopez, Pablo', 'nota': 9, 'padron': 96556, 'grupo': 2},
    {'nombre': 'Gonzalez, Marcelo', 'nota': 7, 'padron': 92143, 'grupo': 2},
    {'nombre': 'Rodriguez, Pablo', 'nota': 9, 'padron': 92431, 'grupo': 2},
    {'nombre': 'Gomez, Matias', 'nota': 4, 'padron': 98306, 'grupo': 3},
    {'nombre': 'Diaz, Juan', 'nota': 8, 'padron': 97972, 'grupo': 3},
    {'nombre': 'Garcia, Matias', 'nota': 2, 'padron': 93108, 'grupo': 4},
    {'nombre': 'Rodriguez, Agustin', 'nota': 5, 'padron': 96739, 'grupo': 5},
]

print 'Creo el archivo vacío usando el modo "wb"'
print 'Si tenía algo, ya lo borre...'
MAX = {'padron': 999999999999}
with open('curso.pkl', 'wb') as archivo:
    for alumno in curso:
        print 'Guardando el alumno {} en el archivo'.format(alumno)
        utils.guardar_en_archivo(archivo, alumno)

print
print 'Abro el archivo en modo lectura...'
with open('curso.pkl', 'rb') as archivo:
    alumno, fin_de_archivo = utils.leer_desde_archivo(archivo)
    while not fin_de_archivo:
        print 'Leyendo el alumno {} en el archivo'.format(alumno)
        alumno, fin_de_archivo = utils.leer_desde_archivo(archivo)


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
Si bien no cerramos explícitamente el archivo usando la función close, al salir del bloque de código que encierra el with el archivo se encontrará cerrado.
Pickles
Los pickles son una forma de guardar estructuras de datos complejas y recuperarlas fácilmente, sin necesidad de convertirlas a texto y luego parsearlas:
Ejemplo 1: Guardar de a un elemento
Se puede usar los pickles como se hacía con los viejos archivos de Pascal, donde se guardaba un registro detrás del otro; pero con la diferencia de que en este caso no es necesario que todos los registros sean del mismo tipo:
Can you write Python code for it?

import pickle  # Importo la biblioteca necesaria

# Creo la variable archivo
with open('ejemplo.pkl', 'wb') as archivo:
    pkl = pickle.Pickler(archivo)  # Creo mi punto de acceso a los datos a partir del archivo

    lista1 = [1, 2, 3]
    lista2 = [4, 5]
    diccionario = {'campo1': 1, 'campo2': 'dos'}

    pkl.dump(lista1)         # Guardo la lista1 de [1, 2, 3]
    pkl.dump(None)           # Guardo el valor None
    pkl.dump(lista2)
    pkl.dump('Hola mundo')
    pkl.dump('')
    pkl.dump(diccionario)
    pkl.dump(1)


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
Y si ahora quiero sumarle 3 puntos a un usuario en particular tendría que:

Leer todo el archivo en una lista
Buscar el usuario y actualizarle los puntos
Guardar toda la lista en el archivo
Can you write Python code for it?

def imprimir_puntajes(lista_puntajes):
    for puntaje in lista_puntajes:
        print '    ', puntaje

# Leo del archivo
with open('ejemplo_2.pkl', 'rb') as archivo:
    lista_puntajes = pickle.load(archivo)

# Actualizo el puntaje
print 'La lista antes de hacer el cambio es:'
imprimir_puntajes(lista_puntajes)

pos =  0
lista_puntajes[pos]['puntaje'] += 3

print 'La lista una vez hecho el cambio es:'
imprimir_puntajes(lista_puntajes)

# Guardo la lista en el archiv
with open('ejemplo_2.pkl', 'wb') as archivo:
    pkl = pickle.Pickler(archivo)
    pkl.dump(lista_puntajes)


I am working on the file "Clase 06 - Archivos binarios, Corte de control.ipynb".
The first task is:
¿Y si el archivo fuera de texto?

Es simple, tratamos de llevar el problema a la solución que conocemos. Para eso podríamos crearnos una función que se comporte de una forma similar a la que se encuentra en utils:
```Python
def leer_desde_archivo(archivo, valor_por_defecto):
    try:
        linea = archivo.readline()
        codigo_cliente, factura, monto = linea.strip().split(',')
        data = {
            'cliente': codigo_cliente,
            'factura': int(factura),
            'monto': int(monto)
        }
        fin_de_archivo = False
    except StopIteration:
        data = valor_por_defecto
        fin_de_archivo = True
return data, fin_de_archivo

``
Esta función, no sólo lee cada línea, sino que una vez leída:
1. usa de la funciónstrippara quitar el\nque tiene al final de la línea
1. usa la funciónsplitpara separar el string por comas
1. hace uso del _unpacking_ para guardar en 3 variables distintas cada uno de los campos de la línea
1. crea un diccionario con cada uno de los datos que obtuvo de la línea, pero antes, convierte el número de factura y el monto a entero usando la funciónint`
Por último, si ya habíamos llegado al final del archivo e intentamos leer de nuevo, el intérprete va a lanzar la excepción StopIteration que la capturamos con el try-except y, en ese caso, devolvemos el valor que nos pasaron por parámetro.

Entonces, después el algoritmo nos queda igual, a excepción de que ahora no importamos a la utils y la forma de crear y abrir el archivo va a ser distinta:
Can you write Python code for it?

def leer_desde_archivo(archivo, valor_por_defecto):
    try:
        linea = archivo.readline()
        codigo_cliente, factura, monto = linea.strip().split(',')
        data = {
            'cliente': codigo_cliente,
            'factura': int(factura),
            'monto': int(monto)
        }
        fin_de_archivo = False
    except Exception:
        data = valor_por_defecto
        fin_de_archivo = True

    return data, fin_de_archivo

def crear_archivo_de_ventas():
    ventas = """001,2020452,916
002,12069115,772
002,14534467,264
002,1424980,752
002,16214863,424
003,6882583,590
003,18817277,654
003,1944327,211
003,16837776,595
003,10145610,444
004,4671025,393
004,13453769,556
005,7126081,35
005,16497082,367
"""
    print 'Creo el archivo vacío usando el modo "wt"'
    with open('ventas.csv', 'wt') as archivo:
        archivo.write(ventas)

def mostrar_ventas_por_cliente(archivo):
    valor_por_defecto = {'cliente': None, 'monto':0}
    total = 0
    # Leo el primer registro del archivo
    venta, fin_de_archivo = leer_desde_archivo(archivo, valor_por_defecto)
    codigo_cliente = venta['cliente']
    while not fin_de_archivo:
        codigo_cliente = venta['cliente']
        subtotal = 0  # Inicializo las ventas de este cliente
        # Mientras siga procesando el mismo cliente...
        while venta['cliente'] == codigo_cliente:
            total += venta['monto']  # Acumulo las ventas totales
            subtotal += venta['monto']  # Acumulo las ventas de este cliente
            venta, fin_de_archivo = leer_desde_archivo(archivo, valor_por_defecto)

        print '      El cliente {cliente} gastó {monto:4}'.format(cliente=codigo_cliente, monto=subtotal)

    print 'El total es de ${}'.format(total)

crear_archivo_de_ventas()
print 'Abro el archivo en modo lectura...'
# Abro el archivo usando el with para asegurarme
# que, pase lo que pase, el archivo quede cerrado
with open('ventas.csv', 'rt') as archivo:
    mostrar_ventas_por_cliente(archivo)


I am working on the file "Clase 09 -  Introducción POO.ipynb".
The first task is:
Como vemos, el método __init__ (aunque en realidad pasará lo mismo con casi todos los métodos de la clase), recibe como primer parámetro uno que se llama self. En realidad el nombre no tiene por qué ser ese, pero se suele usar por convención.

La traducción de self es uno mismo, y con eso quieren decir que en el primer parámetro que Python siempre será el mismo objeto (la instancia) del cual están ejecutando el método. Si bien self aparece entre los parámetros formales, no se ve entre los parámetros actuales, y eso es porque lo inserta el interprete automáticamente. No tiene que hacerlo uno mismo.

Así como este objeto esta compuesto por tres objetos estándar de Python (un int y dos str), también podría estar compuesto por objetos creados por nosotros:
Can you write Python code for it?

class TablaRectangular(object):
    base = None
    altura = None

    def __init__(self, base, altura):
        self.base = base
        self.altura = altura

class TablaRedonda(object):
    radio = None

    def __init__(self, radio):
        self.radio = radio

class Pata(object):
    altura = None

    def __init__(self, altura):
        self.altura = altura

class Mesa(object):
    tabla = None
    patas = None

    def __init__(self, tabla, patas):
        self.tabla = tabla
        self.patas = patas

tabla = TablaRectangular(100, 150)
pata_1 = Pata(90)
pata_2 = Pata(90)
pata_3 = Pata(90)
pata_4 = Pata(90)
mi_mesa = Mesa(tabla, [pata_1, pata_2, pata_3, pata_4])


I am working on the file "Clase 09 -  Introducción POO.ipynb".
The first task is:
En este caso, no sólo es importante ver cómo se hace para invocar un método de un objeto (que es poniendo el nombre del objeto, un punto y el nombre del método seguido por todos sus parámetros entre paréntesis) sino también cómo se puede conjugar el uso de los objetos. <br>
En la función obtener_superficie_de_apoyo de la clase Mesa podemos ver que la única responsabilidad que tiene ese objeto es redirigir la consulta que se le hizo al objeto tabla. Es decir, podía preguntárselo a cualquiera de sus patas o a la tabla, pero sabía a quién tenía que preguntarselo. Y no importa si es una tabla redonda o rectangular, las dos clases saben cómo responder la pregunta de calcular_superficie.
Python
    def obtener_superficie_de_apoyo(self):
        return self.tabla.calcular_superficie()
Otro ejemplo
Volviendo un poco al ejemplo planteado antes de querer modelar una materia, podríamos implementar los alumnos de la siguiente manera:
```Python
class Alumno(object):
def __init__(self, padron, nombre, apellido):
    self.padron = padron
    self.nombre = nombre
    self.apellido = apellido
    self.parciales = []
    self.tps = []
    self.coloquios = []

def rendir_parcial(self, nota):
    self.parciales.append(nota)

def entregar_trabajo_practico(self, nota):
    self.tps.append(nota)

def rendir_coloquio(self, nota):
    self.coloquios.append(nota)

def aprobo_algun_parcial(self):
    aprobo_alguno = False
    for nota in self.parciales:
        if nota >= 4:
            aprobo_alguno = True

    return aprobo_alguno

def aprobo_todos_los_tp(self):
    aprobo_todos = True
    for nota in self.parciales:
        if nota < 4:
            aprobo_todos = False

    return aprobo_todos

def puede_rendir_coloquio(self):
    return self.aprobo_algun_parcial() and self.aprobo_todos_los_tp()

```
Después, para usa estas variables sólo es necesario definir una variable de la clase Alumno pasandole los parametros necesarios para poder inicializarlo:
```Python
alum = Alumno(12345, 'Juan',...
Can you write Python code for it?

class Alumno(object):

    def __init__(self, padron, nombre, apellido):
        self.padron = padron
        self.nombre = nombre
        self.apellido = apellido
        self.parciales = []
        self.tps = []
        self.coloquios = []

    def rendir_parcial(self, nota):
        self.parciales.append(nota)

    def entregar_trabajo_practico(self, nota):
        self.tps.append(nota)

    def rendir_coloquio(self, nota):
        self.coloquios.append(nota)

    def aprobo_algun_parcial(self):
        aprobo_alguno = False
        for nota in self.parciales:
            if nota >= 4:
                aprobo_alguno = True

        return aprobo_alguno

    def aprobo_todos_los_tp(self):
        aprobo_todos = True
        for nota in self.tps:
            if nota < 4:
                aprobo_todos = False

        return aprobo_todos

    def puede_rendir_coloquio(self):
        return self.aprobo_algun_parcial() and self.aprobo_todos_los_tp()

alum = Alumno(12345, 'Juan', 'Perez')
alum.rendir_parcial(2)
alum.entregar_trabajo_practico(7)
alum.entregar_trabajo_practico(9)

if alum.puede_rendir_coloquio():
    print 'El alumno puede rendir coloquio'
else:
    print 'El alumno no puede rendor coloquio'

print '¿Y si después rinde el parcial y se saca un 7?'
alum.rendir_parcial(7)

if alum.puede_rendir_coloquio():
    print 'El alumno puede rendir coloquio'
else:
    print 'El alumno no puede rendor coloquio'


I am working on the file "Clase 09 -  Introducción POO.ipynb".
The first task is:
Y como dijimos antes, una objeto no sólo agrupa sus características, sino también los métodos que nos permiten trabajar con él, como por ejemplo, podría ser calcular su superficie de apoyo:
Can you write Python code for it?

import math

class TablaRectangular(object):
    base = None
    altura = None

    def __init__(self, base, altura):
        self.base = base
        self.altura = altura

    def calcular_superficie(self):
        return self.base * self.altura

class TablaRedonda(object):
    radio = None

    def __init__(self, radio):
        self.radio = radio

    def calcular_superficie(self):
        return math.pi * self.radio**2

class Pata(object):
    altura = None

    def __init__(self, altura):
        self.altura = altura

class Mesa(object):
    tabla = None
    patas = None

    def __init__(self, tabla, patas):
        self.tabla = tabla
        self.patas = patas

    def obtener_superficie_de_apoyo(self):
        return self.tabla.calcular_superficie()

tabla = TablaRectangular(100, 150)
pata_1 = Pata(90)
pata_2 = Pata(90)
pata_3 = Pata(90)
pata_4 = Pata(90)
mi_mesa = Mesa(tabla, [pata_1, pata_2, pata_3, pata_4])

sup = mi_mesa.obtener_superficie_de_apoyo()
print 'La superficie de la mesa es {} cm2'.format(sup)


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Calculamos tambien la energía potencial de cada eslabon:
Can you write Python code for it?


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Cambiamos el ambiente de matplotlib, para poder graficar interactivamente, y declaramos una función que tome la cinematica del robot y grafique los puntos:
Can you write Python code for it?

%matplotlib inline

def grafica_scara(q1, q2, q3, l1, l2, L):
    xs, ys , zs = cinematica_scara(q1, q2, q3, l1, l2, L)

    fig = figure(figsize=(8, 8))

    ax = fig.gca(projection='3d')

    ax.plot(xs, ys, zs, "-o")

    ax.set_xlim(-2, 2)
    ax.set_ylim(-2, 2)
    ax.set_zlim(0, 1.5);

grafica_scara(τ/12, τ/9, 0.2, 1, 1, 1)


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Declaramos $\omega_i$ como la velocidad angular de cada eslabon:
Can you write Python code for it?


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Desempacamos los elementos que nos entrega odeint:
Can you write Python code for it?

q1, q2, q3, q̇1, q̇2, q̇3 = list(zip(*estados_simulados.tolist()))


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Dinámica del Robot Manipulador SCARA
Se tiene un robot manipulador tipo SCARA, como el de la siguiente figura, del cual se quiere obtener sus ecuaciones de movimiento, asi como una simulación bajo cierta ley de  control.
Empezaremos obteniendo una representación simple de las posiciones de los centros de masa para los eslabones del robot.
Primero tenemos que importar las librerias de computo simbolico:
Can you write Python code for it?

from sympy import var, sin, cos, Matrix, Integer, eye, Function, Rational, exp, Symbol, I, solve, pi, trigsimp, dsolve, sinh, cosh, simplify
from sympy.physics.mechanics import mechanics_printing
mechanics_printing()


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Hacemos la grafica de las trayectorias del sistema, $q_1$, $q_2$ y $q_3$:
Can you write Python code for it?


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Importamos la libreria para interactuar con los datos y le pasamos la función que grafica:
Can you write Python code for it?

# Se importan widgets de IPython para interactuar con la funcion
from IPython.html.widgets import interact, fixed

# Se llama a la funcion interactiva
interact(grafica_scara, q1=(0, τ), q2=(0, τ), q3=(0, 1.0), l1=fixed(1), l2=fixed(1), L=fixed(1))


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Para realizar una animación con los datos de la simulación primero importamos la libreria necesaria y creamos la misma grafica dentro del ambiente de animación:
Can you write Python code for it?

from matplotlib import animation
from numpy import arange

# Se define el tamaño de la figura
fig = figure(figsize=(8, 8))

# Se define una sola grafica en la figura y se dan los limites de los ejes x y y
axi = fig.add_subplot(111, autoscale_on=False, xlim=(-2, 2), ylim=(-2, 2), projection='3d')

# Se utilizan graficas de linea para el resorte y amortiguador
robot, = axi.plot([], [], [], "-o", lw=2)

def init():
    # Esta funcion se ejecuta una sola vez y sirve para inicializar el sistema
    robot.set_data([], [])
    return robot

def animate(i):
    # Esta funcion se ejecuta para cada cuadro del GIF

    # Se obtienen las coordenadas del robot y se meten los datos en su grafica de linea
    xs, ys, zs = cinematica_scara(q1[i], q2[i], q3[i], 1, 1, 1)
    robot.set_data(xs, ys)
    robot .set_3d_properties(zs)

    return robot

# Se hace la animacion dandole el nombre de la figura definida al principio, la funcion que
# se debe ejecutar para cada cuadro, el numero de cuadros que se debe de hacer, el periodo
# de cada cuadro y la funcion inicial
ani = animation.FuncAnimation(fig, animate, arange(1, len(q1)), interval=25,
                              blit=True, init_func=init)

# Se guarda el GIF en el archivo indicado
ani.save('./imagenes/simulacion-scara.gif', writer='imagemagick');


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Para utilizar la función odeint, debemos crear una función, que describa la dinámica del sistema:
Can you write Python code for it?

def scara(estado, tiempo):
    # Se importan funciones necesarias
    from numpy import sin, cos, matrix
    # Se desenvuelven variables del estado y tiempo
    q1, q2, q3, q̇1, q̇2, q̇3 = estado
    t = tiempo

    # Se declaran constantes del sistema
    m1, m2, m3 = 1, 1, 1
    J1, J2, J3 = 1, 1, 1
    l1, l2 = 0.5, 0.5
    L1, L2 = 1, 1
    L = 1
    g = 9.81

    # Se declaran constantes del control
    kp1, kp2, kp3 = -30, -60, -60
    kv1, kv2, kv3 = -20, -20, -18

    # Señales de control nulas
    #tau1, tau2, tau3 = 0, 0, 0

    # Posiciones a alcanzar
    qd1, qd2, qd3 = 1, 1, 1

    # Se declaran señales de control del sistema
    tau1 = kp1*(q1 - qd1) + kv1*q̇1
    tau2 = kp2*(q2 - qd2) + kv2*q̇2
    tau3 = kp3*(q3 - qd3) + kv3*q̇3- m3*g

    # Se calculan algunos terminos comunes
    λ1 = m1*L1*(l2 + L2)
    λ2 = m1*(l2**2 + L2**2)
    λ3 = m1*(l1**2 + L1**2)

    # Se calculan las matrices de masas, Coriolis,
    # y vectores de gravedad, control, posicion y velocidad
    M = matrix([[J1 + 2*λ1*cos(q2) + m1*L1**2 + λ2 + λ3, λ1*cos(q2) + λ2, 0],
                [λ1*cos(q2) + λ2, J2 + λ2, 0],
                [0, 0, m1]])
    C = matrix([[-2*q̇1, -q̇2, 0], [q̇1, 0, 0], [0, 0, 0]])
    G = matrix([[0], [0], [-m3*g]])
    Tau = matrix([[tau1], [tau2], [tau3]])
    q = matrix([[q1], [q2], [q3]])
    q̇ = matrix([[q̇1], [q̇2], [q̇3]])

    # Se calcula la derivada del estado del sistema
    qp1 = q̇1
    qp2 = q̇2
    qp3 = q̇3

    qpp = M.I*(Tau - C*q̇ - G)
    qpp1, qpp2, qpp3 = qpp.tolist()

    return [qp1, qp2, qp3, qpp1[0], qpp2[0], qpp3[0]]


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Por lo que ahora solo tenemos que aplicar la ecuación de Euler-Lagrange para obtener las ecuaciones de movimiento del sistema:
Can you write Python code for it?

τ1 = (L.diff(q1.diff(t)).diff(t) - L.diff(q1)).simplify().expand().collect(q1.diff(t).diff(t)).collect(q2.diff(t).diff(t))

τ2 = (L.diff(q2.diff(t)).diff(t) - L.diff(q2)).simplify().expand().collect(q1.diff(t).diff(t)).collect(q2.diff(t).diff(t))

τ3 = (L.diff(q3.diff(t)).diff(t) - L.diff(q3)).simplify().expand().collect(q1.diff(t).diff(t)).collect(q2.diff(t).diff(t))

τ1

τ2

τ3


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Realizamos la cinemática del manipulador para poder graficar en 3D:
Can you write Python code for it?


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Y declaramos todas las constantes involucradas en este calculo simbolico:
Can you write Python code for it?

var("m1 m2 m3 J1 J2 J3 l1 l2 L1 L2 L0 t g")


I am working on the file "Clases/.ipynb_checkpoints/Dinamica SCARA-checkpoint.ipynb".
The first task is:
Y declarar un arreglo con todos los tiempos a simular, mandar a llamar a la función odeint, y listo!
Can you write Python code for it?

t = linspace(0, 10, 1000)
estados_simulados = odeint(func = scara, y0  = [0, 0, 0, 0, 0, 0], t = t)


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Asi como algunas de las variables de nuestro problema:
Can you write Python code for it?

q1 = Function("q1")(t)
q2 = Function("q2")(t)
q3 = Function("q3")(t)


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Declaramos $\omega_i$ como la velocidad angular de cada eslabon:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Desempacamos los elementos que nos entrega odeint:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Importamos la libreria para interactuar con los datos y le pasamos la función que grafica:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Para realizar una animación con los datos de la simulación primero importamos la libreria necesaria y creamos la misma grafica dentro del ambiente de animación:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Para utilizar la función odeint, debemos crear una función, que describa la dinámica del sistema:
Can you write Python code for it?

def scara(estado, tiempo):
    # Se importan funciones necesarias
    from numpy import sin, cos, matrix
    # Se desenvuelven variables del estado y tiempo
    q1, q2, q3, q̇1, q̇2, q̇3 = estado
    t = tiempo

    # Se declaran constantes del sistema
    m1, m2, m3 = 1, 1, 1
    J1, J2, J3 = 1, 1, 1
    l1, l2 = 0.5, 0.5
    L1, L2 = 1, 1
    L = 1
    g = 9.81

    # Se declaran constantes del control
    kp1, kp2, kp3 = -30, -60, -60
    kv1, kv2, kv3 = -20, -20, -18

    # Señales de control nulas
    #tau1, tau2, tau3 = 0, 0, 0

    # Posiciones a alcanzar
    qd1, qd2, qd3 = 1, 1, 1

    # Se declaran señales de control del sistema
    tau1 = kp1*(q1 - qd1) + kv1*q̇1
    tau2 = kp2*(q2 - qd2) + kv2*q̇2
    tau3 = kp3*(q3 - qd3) + kv3*q̇3 + m3*g

    # Se calculan algunos terminos comunes
    λ1 = m1*L1*(l2 + L2)
    λ2 = m1*(l2**2 + L2**2)
    λ3 = m1*(l1**2 + L1**2)

    # Se calculan las matrices de masas, Coriolis,
    # y vectores de gravedad, control, posicion y velocidad
    M = matrix([[J1 + 2*λ1*cos(q2) + m1*L1**2 + λ2 + λ3, λ1*cos(q2) + λ2, 0],
                [λ1*cos(q2) + λ2, J2 + λ2, 0],
                [0, 0, m1]])
    C = matrix([[-2*q̇1, -q̇2, 0], [q̇1, 0, 0], [0, 0, 0]])
    G = matrix([[0], [0], [-m3*g]])
    Tau = matrix([[tau1], [tau2], [tau3]])
    q = matrix([[q1], [q2], [q3]])
    q̇ = matrix([[q̇1], [q̇2], [q̇3]])

    # Se calcula la derivada del estado del sistema
    qp1 = q̇1
    qp2 = q̇2
    qp3 = q̇3

    qpp = M.I*(Tau - C*q̇ - G)
    qpp1, qpp2, qpp3 = qpp.tolist()

    return [qp1, qp2, qp3, qpp1[0], qpp2[0], qpp3[0]]


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Por lo que ya podemos calcular tanto la energía cinética de nuestro sistema como la potencial:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Y declaramos todas las constantes involucradas en este calculo simbolico:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
Y procedemos al calculo de la energía cinética de cada eslabon:
Can you write Python code for it?


I am working on the file "Clases/Dinamica SCARA.ipynb".
The first task is:
y el Lagrangiano queda:
Can you write Python code for it?


I am working on the file "Class Notebooks/Air Quality Activity.ipynb".
The first task is:
Air Particulate concentration results
Input data for 2.5 micron particulate matter concentrations (ug/m^3) from each team.
Inside the classroom
Can you write Python code for it?

#Opens csv files chosen by the user
# "/Users/alihanks/TouchScreen_1_air_quality2018-05-14_07-09-37.csv"
# "/Users/alihanks/TouchScreen_1_air_quality2018-05-14_07-04-47.csv"
# "/Users/alihanks/TouchScreen_1_air_quality2018-05-14_06-46-24.csv"
# "/Users/alihanks/Touchscreen_2_air_quality2018-05-14_08-01-30.csv"
# "/Users/alihanks/Touchscreen_2_air_quality2018-05-14_07-49-45.csv"
user_file1 = input("File Name 1: ")
aq_in_results1 = csv.reader(open(user_file1), delimiter=',')

user_file2 = input("File Name 2: ")
aq_in_results2 = csv.reader(open(user_file2), delimiter=',')

user_file3 = input("File Name 3: ")
aq_in_results3 = csv.reader(open(user_file3), delimiter=',')

user_file4 = input("File Name 4: ")
aq_in_results4 = csv.reader(open(user_file4), delimiter=',')

user_file5 = input("File Name 5: ")
aq_in_results5 = csv.reader(open(user_file5), delimiter=',')

PM25_in_1 = []
PM25_in_2 = []
PM25_in_3 = []
PM25_in_4 = []
PM25_in_5 = []

PM25_in_1 = get_data(aq_in_results1,8)
PM25_in_2 = get_data(aq_in_results2,8)
PM25_in_3 = get_data(aq_in_results3,8)
PM25_in_4 = get_data(aq_in_results4,8)
PM25_in_5 = get_data(aq_in_results5,8)

mean_PM25_1,std_PM25_1 = get_stats(PM25_in_1,"PM25 inside",1)
mean_PM25_2,std_PM25_2 = get_stats(PM25_in_2,"PM25 inside",2)
mean_PM25_3,std_PM25_3 = get_stats(PM25_in_3,"PM25 inside",3)
mean_PM25_4,std_PM25_4 = get_stats(PM25_in_4,"PM25 inside",4)
mean_PM25_5,std_PM25_5 = get_stats(PM25_in_5,"PM25 inside",5)

nbins = 10
fig, ax = plt.subplots()
plt.hist(PM25_in_1,bins=nbins, alpha=0.5, label='Device 1')
plt.hist(PM25_in_2,bins=nbins, alpha=0.5, label='Device 2')
plt.hist(PM25_in_3,bins=nbins, alpha=0.5, label='Device 3')
plt.hist(PM25_in_4,bins=nbins, alpha=0.5, label='Device 4')
plt.hist(PM25_in_5,bins=nbins, alpha=0.5, label='Device 5')

plt.legend(loc='best')
plt.title('Air Quality 2.5 micron particulate matter inside the classroom')
plt.ylabel('Frequency')
plt.xlabel('PM 2.5 ug/m^3')


I am working on the file "Class Notebooks/Air Quality Activity.ipynb".
The first task is:
At unique locations on campus
Can you write Python code for it?

#Opens csv files chosen by the user
user_file1 = input("File Name 1: ")
co2_results1 = csv.reader(open(user_file1), delimiter=',')

user_file2 = input("File Name 2: ")
co2_results2 = csv.reader(open(user_file2), delimiter=',')

user_file3 = input("File Name 3: ")
co2_results3 = csv.reader(open(user_file3), delimiter=',')

user_file4 = input("File Name 4: ")
co2_results4 = csv.reader(open(user_file4), delimiter=',')

user_file5 = input("File Name 5: ")
co2_results5 = csv.reader(open(user_file5), delimiter=',')

CO2_1 = []
CO2_2 = []
CO2_3 = []
CO2_4 = []
CO2_5 = []

CO2_1 = get_data(co2_results1,1)
CO2_2 = get_data(co2_results2,1)
CO2_3 = get_data(co2_results3,1)
CO2_4 = get_data(co2_results4,1)
CO2_5 = get_data(co2_results5,1)

mean_CO2_1,std_CO2_1 = get_stats(CO2_1,"CO2 (ppm) at location 1",1)
mean_CO2_2,std_CO2_2 = get_stats(CO2_2,"CO2 (ppm) at location 2",2)
mean_CO2_3,std_CO2_3 = get_stats(CO2_3,"CO2 (ppm) at location 3",3)
mean_CO2_4,std_CO2_4 = get_stats(CO2_4,"CO2 (ppm) at location 4",4)
mean_CO2_5,std_CO2_5 = get_stats(CO2_5,"CO2 (ppm) at location 5",5)

nbins = 10
fig, ax = plt.subplots()
plt.hist(CO2_1,bins=nbins, alpha=0.5, label='Location 1')
plt.hist(CO2_2,bins=nbins, alpha=0.5, label='Location 2')
plt.hist(CO2_3,bins=nbins, alpha=0.5, label='Location 3')
plt.hist(CO2_4,bins=nbins, alpha=0.5, label='Location 4')
plt.hist(CO2_5,bins=nbins, alpha=0.5, label='Location 5')

plt.legend(loc='best')
plt.title('CO2 parts-per-million at unique locations')
plt.ylabel('Frequency')
plt.xlabel('CO2 ppm')


#Opens csv files chosen by the user
user_file1 = input("File Name 1: ")
aq_results1 = csv.reader(open(user_file1), delimiter=',')

user_file2 = input("File Name 2: ")
aq_results2 = csv.reader(open(user_file2), delimiter=',')

user_file3 = input("File Name 3: ")
aq_results3 = csv.reader(open(user_file3), delimiter=',')

user_file4 = input("File Name 4: ")
aq_results4 = csv.reader(open(user_file4), delimiter=',')

user_file5 = input("File Name 5: ")
aq_results5 = csv.reader(open(user_file5), delimiter=',')

PM25_1 = []
PM25_2 = []
PM25_3 = []
PM25_4 = []
PM25_5 = []

PM25_1 = get_data(aq_results1,8)
PM25_2 = get_data(aq_results2,8)
PM25_3 = get_data(aq_results3,8)
PM25_4 = get_data(aq_results4,8)
PM25_5 = get_data(aq_results5,8)

mean_PM25_1,std_PM25_1 = get_stats(PM25_1,"PM25 at location 1",1)
mean_PM25_2,std_PM25_2 = get_stats(PM25_2,"PM25 at location 2",2)
mean_PM25_3,std_PM25_3 = get_stats(PM25_3,"PM25 at location 3",3)
mean_PM25_4,std_PM25_4 = get_stats(PM25_4,"PM25 at location 4",4)
mean_PM25_5,std_PM25_5 = get_stats(PM25_5,"PM25 at location 5",5)

nbins = 10
fig, ax = plt.subplots()
plt.hist(PM25_1,bins=nbins, alpha=0.5, label='Location 1')
plt.hist(PM25_2,bins=nbins, alpha=0.5, label='Location 2')
plt.hist(PM25_3,bins=nbins, alpha=0.5, label='Location 3')
plt.hist(PM25_4,bins=nbins, alpha=0.5, label='Location 4')
plt.hist(PM25_5,bins=nbins, alpha=0.5, label='Location 5')

plt.legend(loc='best')
plt.title('Air Quality 2.5 micron particulate matter at unique locations')
plt.ylabel('Frequency')
plt.xlabel('PM 2.5 ug/m^3')

#Choose the number of data points to combine and average
n_merge = int(input("n data points to combine:"))
ndata_a = len(Val25a)
ndata_b = len(Val25b)
nsum_data_a= int(ndata_a/n_merge)
nsum_data_b= int(ndata_b/n_merge)

data_ave_a = []
data_ave_b = []
data_unc_a = []
data_unc_b = []
merge_times_a = []
merge_times_b = []

for i in range(nsum_data_a):
    #Calculate the mean and standard deviation
    idata = Val25a[i*n_merge:(i+1)*n_merge]
    idata_array = np.asarray(idata) #Convert...


I am working on the file "Class and Inheritance/Python_Class and Inheritance.ipynb".
The first task is:
In the case, Electric use the structure from Pokemon. Methods from Pokemon can be directly used. We can also define  specfic methods:
Can you write Python code for it?

class Electric(Pokemon):
    def __init__(self, name, attack, defence):
        Pokemon.__init__(self, name, attack, defence)

    def __str__(self):
        return 'My name is %s, and my attack is %d, defence is %d. I am electric type.' %(self.name, self.attack, self.defence)

Raichu = Electric('Raichu', 200, 100)
Raichu.poko_state()

### __str__ method from Pokemon is replaced in Electric.
print(Raichu)


I am working on the file "Class and Inheritance/Python_Class and Inheritance.ipynb".
The first task is:
So a method in a class always have self as its first variable, which means getting the contents of the instance.
Can you write Python code for it?

### To make it clear, here's an example.
### Standard way of calling `poko_name`:
Pikachu.poko_name()
### In the case, `self` represents the Pikachu instance itself, and is automatically passed into the function by Python.

### Inconventional way:
Pokemon.poko_name(Pikachu)

### if we didn't do that
Pokemon.poko_name()
### then there is a variable missed.


I am working on the file "Class and Inheritance/Python_Class and Inheritance.ipynb".
The first task is:
Subclass

Sometimes a single class is not enough. For example, there are 18 types of the Pokemon, like grass, fire, water, etc.
We can make another class that is a Pokemon but is also specifically a electric type Pokemon. This gives us the structure from Pokemon but also any structure we want to specify for Electric type.
Can you write Python code for it?

class Electric(Pokemon):
    def __init__(self, name, attack, defence):
        Pokemon.__init__(self, name, attack, defence)

Raichu = Electric('Raichu', 200, 100)
print(Raichu)


I am working on the file "Class and Inheritance/Python_Class and Inheritance.ipynb".
The first task is:
What is __str__?

It's also a special method like __init__. (Actually, you will find that something in double underscores always has special function in Python.)
This method defines the format if print out.
Can you write Python code for it?


I am working on the file "Class and Inheritance/Python_Class and Inheritance.ipynb".
The first task is:
Why is 13?
<img src="multinher_example1.jpeg">

You might notice that in this case, __init__ method in the base class is executed twice.  However, most of time, we want it to execute for only one time.

Super()

When you have multiple inheritance, the super() helps to ensure that the proper method resolution order (MRO) is followed when moving up the inheritance tree.
Super() is to find next class in MRO.
It is also a shortcut to allow you to access the base class of a derived class, without having to know or type the base class name.
Can you write Python code for it?

# Define a simple class named A
class A():
    def __init__(self, a):
        print('enter A')
        self.a = a
        print(self.a)
        print('leave A')

    def method(self):
        print()
        print('method from A')
        print(self.a)

# Try
instance = A(3)
instance.method()

# Define a class named B which is inherited from A.
class A():
    def __init__(self, a):
        print('enter A')
        self.a = a
        print(self.a)
        print('leave A')

    def method(self):
        print()
        print('method from A')
        print(self.a)

class B(A):
    def __init__(self, b):
        print('enter B')
        super(B, self).__init__('I give from B')
        self.a = 'self.a is changed from B'
        print(self.a)
        print('leave B')

instance = B(1)
instance.method()

# Another example using super()
class B(A):
    def __init__(self, b):
        print('enter B')
        super().__init__('I give from B')
        self.a = 'self.a is changed from B'
        print(self.a)
        print('leave B')

instance = B(1)
instance.method()

# Use inheritance method I mentioned at beginning.
class B(A):
    def __init__(self, b):
        print('enter B')
        A.__init__(self, 'I give from B')
        self.a = 'self.a is changed from B'
        print(self.a)
        print('leave B')

instance = B(1)
instance.method()


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Correlation among features
When we train any algorithm, the number of features and their correlation plays an important role. If there are features and many of the features are highly correlated, then training an algorithm with all the featues will reduce the accuracy. Thus features selection should be done carefully
Can you write Python code for it?

X = iris[['SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm']]
Y = iris['Species']

plt.figure(figsize=(10,8))
sns.heatmap(X.corr(),annot=True,cmap='cubehelix_r') #draws  heatmap with input as the correlation matrix calculted by(iris.corr())
plt.show()


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Data Visualization
Can you write Python code for it?

# We can plot things is using the .plot extension from Pandas dataframes
# We'll use this to make a scatterplot of the Iris features.
%matplotlib inline
iris.plot(kind="scatter", x="SepalLengthCm", y="SepalWidthCm")

# Importing some visualization libraries
import warnings
warnings.filterwarnings("ignore")
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
sns.set(style="white", color_codes=True)

# One piece of information missing in the plots above is what species each plant is
# We'll use seaborn's FacetGrid to color the scatterplot by species
sns.FacetGrid(iris, hue="Species", size=5) \
   .map(plt.scatter, "SepalLengthCm", "SepalWidthCm") \
   .add_legend()

# We can look at an individual feature in Seaborn through a boxplot
sns.boxplot(x="Species", y="PetalLengthCm", data=iris)

# Another useful seaborn plot is the pairplot, which shows the bivariate relation
# between each pair of features
#
# From the pairplot, we'll see that the Iris-setosa species is separataed from the other
# two across all feature combinations
sns.pairplot(iris.drop("Id", axis=1), hue="Species", size=3)

# Box plots can also be made using DataFrame
iris.drop("Id", axis=1).boxplot(by="Species",figsize=(12, 12))


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Exploring the Iris dataset
Can you write Python code for it?

# Reading the csv file using pandas into a DataFrame
iris = pd.read_csv('Iris.csv')
iris.head(10)

iris.describe()

iris.info()

iris['Species'].value_counts()


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Lets see how we can add a new column to our DataFrame
Can you write Python code for it?

import numpy as np
data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon', 'Pastrami','corned beef', 'Bacon', 'pastrami', 'honey ham','nova lox'],
                 'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
# Creates a new column protien and assigns 9 random values to it
data = data.assign(protien = np.random.random(9))
data

# Lets remove the added columns
data.drop('protien',axis='columns',inplace=True)
data


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Machine Learning Algorithms and Decision Boundaries
Since our Species column which contains these three class labels contain categorical data, the first thing to do would be to encode them numerically as follows:
Can you write Python code for it?

target_map = {'Iris-setosa':0, 'Iris-versicolor':1,'Iris-virginica':2 }
# Use the pandas apply method to numerically encode our attrition target variable
iris['Species'] = iris['Species'].apply(lambda x: target_map[x])
iris

# importing alll the necessary packages to use the various classification algorithms
from sklearn.linear_model import LogisticRegression  # for Logistic Regression algorithm
from sklearn.cross_validation import train_test_split #to split the dataset for training and testing
from sklearn import metrics #for checking the model accuracy
from sklearn.tree import DecisionTreeClassifier #for using Decision Tree Algoithm
from sklearn.ensemble import RandomForestClassifier # A combine model of many decision trees


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Often, we get data sets with duplicate rows, which is nothing but noise. Therefore, before training the model, we need to make sure we get rid of such inconsistencies in the data set. Let's see how we can remove duplicate rows.
Can you write Python code for it?

data = pd.DataFrame({'k1':['one']*3 + ['two']*4, 'k2':[3,2,1,3,3,4,4]})
data.sort_values(by='k2')

#remove duplicates
data.drop_duplicates()


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
Plotting Decision Surface
Can you write Python code for it?

from sklearn.preprocessing import StandardScaler
import plotly.graph_objs as go
import plotly.offline as py
py.init_notebook_mode(connected=True)
import plotly.graph_objs as go
from plotly import tools

X = iris.iloc[:, :2]  # Take only the first two features.
y = iris.Species
h = .02  # step size in the mesh
X = StandardScaler().fit_transform(X)

# Implement 3 Logistic Regression models with varying values of C
clf = LogisticRegression(C=0.01)
clf.fit(X, y)

clf2 = LogisticRegression(C=1)
clf2.fit(X, y)

clf3 = LogisticRegression(C=100)
clf3.fit(X, y)

# Define our usual decision surface bounding plots
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1

xx, yy = np.meshgrid(np.arange(x_min, x_max, h)
                     , np.arange(y_min, y_max, h))
y_ = np.arange(y_min, y_max, h)

Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

trace1 = go.Heatmap(x=xx[0], y=y_, z=Z,
                  colorscale='Viridis',
                  showscale=True)

trace2 = go.Scatter(x=X[:, 0], y=X[:, 1],
                    mode='markers',
                    showlegend=False,
                    marker=dict(size=10,
                                color=y,
                                colorscale='Viridis',
                                line=dict(color='black', width=1))
                    )
layout= go.Layout(
    autosize= True,
    title= 'Logistic Regression (C=0.01)',
    hovermode= 'closest',
    showlegend= False)

data = [trace1, trace2]
fig = go.Figure(data=data, layout=layout)
py.iplot(fig)

Z = clf2.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
#Z = Z.reshape((xx.shape[0], xx.shape[1], 3))

trace3 = go.Heatmap(x=xx[0], y=y_,
                    z=Z,
                    colorscale='Viridis',
                    showscale=True)

trace4 = go.Scatter(x=X[:, 0], y=X[:, 1],
                    mode='markers',
                    showlegend=False,
                    marker=dict(size=10,
                ...


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
We can also use a query method to select columns based on a criterion
Can you write Python code for it?

#list all columns where A is greater than C
df.query('A > C')

#using OR condition
df.query('A < B | C > A')


I am working on the file "Class-4/Introduction to Pandas and Exploring Iris Dataset.ipynb".
The first task is:
We used all the features of iris in above models. Now we will use Petals and Sepals Seperately
Can you write Python code for it?

petal=iris[['PetalLengthCm','PetalWidthCm','Species']]
sepal=iris[['SepalLengthCm','SepalWidthCm','Species']]

train_p,test_p=train_test_split(petal,test_size=0.3,random_state=0)  #petals
train_x_p=train_p[['PetalWidthCm','PetalLengthCm']]
train_y_p=train_p.Species
test_x_p=test_p[['PetalWidthCm','PetalLengthCm']]
test_y_p=test_p.Species

train_s,test_s=train_test_split(sepal,test_size=0.3,random_state=0)  #Sepal
train_x_s=train_s[['SepalWidthCm','SepalLengthCm']]
train_y_s=train_s.Species
test_x_s=test_s[['SepalWidthCm','SepalLengthCm']]
test_y_s=test_s.Species

model = LogisticRegression()
model.fit(train_x_p,train_y_p)
prediction=model.predict(test_x_p)
print('The accuracy of the Logistic Regression using Petals is:',metrics.accuracy_score(prediction,test_y_p))

model.fit(train_x_s,train_y_s)
prediction=model.predict(test_x_s)
print('The accuracy of the Logistic Regression using Sepals is:',metrics.accuracy_score(prediction,test_y_s))

model=DecisionTreeClassifier()
model.fit(train_x_p,train_y_p)
prediction=model.predict(test_x_p)
print('The accuracy of the Decision Tree using Petals is:',metrics.accuracy_score(prediction,test_y_p))

model.fit(train_x_s,train_y_s)
prediction=model.predict(test_x_s)
print('The accuracy of the Decision Tree using Sepals is:',metrics.accuracy_score(prediction,test_y_s))


I am working on the file "Class01/Class01.ipynb".
The first task is:
As you can see, the 'target' column is no longer numerical, but a text entry that is one of the three possible iris varieties. We also see that the default column headings are a bit long and will get tiring to type out when we want to reference them. Let's rename the columns first.
Can you write Python code for it?


I am working on the file "Class01/Class01.ipynb".
The first task is:
Now we want to visualize the data. We don't know what to expect, so let's just pick a couple of variables and see what the data look like.
Can you write Python code for it?


I am working on the file "Class01/Class01.ipynb".
The first task is:
So we see that there are entries at a number of different points, but it would be really nice to be able to identify which point correpsonds to which variety. We will use another python library to do this. We'll also set the default style to 'white' which looks better.
Can you write Python code for it?

import seaborn as sns
sns.set_style('white')


I am working on the file "Class01/Class01.ipynb".
The first task is:
So we see the first row is gone. That's what we wanted. However, this doesn't really tell us much by itself. It is better to start investigating how the output variable ('Target' in this case) depends on the inputs. We'll visualize the data one at a time to look at this. We'll make a scatter plot where we look at the Target as a function of the Age column. The first entry provides the 'x' values where the second provides the 'y' values. The final input tells the plotting software to plot the data points as dots, not connected lines. We'll almost always use this feature.
Can you write Python code for it?


I am working on the file "Class01/Class01.ipynb".
The first task is:
This doesn't tell us much. It looks like there isn't a large dependence on age - othewise we would have seen something more specific than a large blob of data. Let's try other inputs. We'll plot a bunch of them in a row.
Jupyter Hint: Clicking in the white space next to the output cell will expand and contract the output contents. This is helpful when you have lots of output.
Can you write Python code for it?


I am working on the file "Class01/Class01.ipynb".
The first task is:
We see that there are some of these plots that show there might be a way to distinuish the three different varieties. We'll look at how to do that later on, but this gives us a start.
Import Image Data
The last type of data we are going to look at are image data. This type of data provides information about each pixel (or element) in an image. We'll start by working with gray-scale images where each pixel could be a value anywhere between 0 (black) and 255 (white). We'll read in the data then look at how to create the image. This data set are handwritten digits from 0 to 9 that have been digitized. We will eventually try to teach the computer to read the handwritten digits.
Can you write Python code for it?

digitDF = pd.read_csv('Class01_digits_data.csv')

digitDF.head()