Por Jose R. Zapata

Ultima actualización: 15/Nov/2024

En este notebook se encuentra los temas mas importantes para el uso de python en ciencia de datos, se debe tener un un conocimiento básico de programación para entender completamente el notebook.

!python --version

Python 3.10.14

Tipos de Datos

Python tiene varios tipos de datos, los mismos datos básicos que otros lenguajes: enteros, flotantes, strings y booleanos. Además, las listas son un tipo predefinido en el lenguaje, los diccionarios, tuplas y sets.

La funcion que se utiliza para determinar el tipo de datos es type()

Para escribir comentarios es utiliza el caracter numeral #

Numeros

IPython puede ser usado de forma interactiva como una calculadora. Esto permite que el análisis de datos pueda ser realizado de forma interactiva, de forma similar a como pueden usarse otras herramientas como el lenguaje R o Matlab. A continuación se ejemplifican los cálculos aritméticos básicos.

2 + 3  # Suma

2 * 3  # Multiplicación

7 / 2  # Division con respuesta de numero flotante

3.5

5 // 2  # parte entera de la division

2**4  # Potenciación

8 % 2  # Operación Modulo

5 % 2  # Operación Modulo

53 % 15

Orden específico para realizar las operaciones y resolver fórmulas

Potencias y radicales
Multiplicación, división, división sesgada y módulo
Suma y resta

((2 + 3) * (5**2 + 5)) / 2  # Uso de varias operación en la misma ecuación

75.0

Booleans (Logicos)

# las palabras True y False son palabras restringidas
# valor Verdadero
True

True

# valor Falso
False

False

`type()`

la funcion para conocer el tipo de dato

# función para determinar el tipo de dato Numérico
int  # tipo entero (int)

int

float  # Tipo flotante, se determina por el uso del punto

float

bool

bool

type(5 / 2)  # Numero flotante

float

type(5 // 2)  # Numero entero

int

Asignacion de valores Variables

Las variables en python no necesitan ser declaradas, simplemente se definen al ser utilizadas por primera vez. Además, (si bien no es recomendable) pueden cambiar de tipo volviendo a definir. la variables puede ser de cualqueire tipo de datos que maneja Python

# Los nombres NO pueden empezar con un numero o un carácter especial
name_of_var = 2  # asignación de valores a una variable
type(name_of_var)

int

name_of_var = 5.3  # asignación de valores a una variable
type(name_of_var)

float

x = 2  # asignado valores a diferentes variables
y = 3

z = x + y  # asignar la suma de dos variables

type(z)  # tipo de dato

int

v1 = True
v2 = False

print(f"Valor de v1 = {v1} y v2 = {v2}")

Valor de v1 = True y v2 = False

type(v1)

bool

Strings

"Comillas sencillas"

'Comillas sencillas'

"Comillas dobles"

'Comillas dobles'

" Se puede escribir 'Comillas' de esta forma"

" Se puede escribir 'Comillas' de esta forma"

# para escribir una frase larga se puede hacer asi:
" Científico de datos: Persona que sabe más de estadística que cualquier programador "
"y que a la vez sabe más de programación que cualquier estadístico "

'y que a la vez sabe más de programación que cualquier estadístico '

"""
  Los strings de varias lineas pueden
  escribirse delimitando con tres comillas
  dobles y son usados corrientemente como
  comentarios
"""

'\n  Los strings de varias lineas pueden\n  escribirse delimitando con tres comillas\n  dobles y son usados corrientemente como\n  comentarios\n'

# escribir un string largo
# pero la impresión se hace en una sola linea
a = (
    "El Big data es como el sexo en la adolescencia: todo el mundo habla de ello, "
    "nadie sabe realmente cómo hacerlo, todos piensan que los demás lo están "
    "haciendo, así que todos dicen que también lo hacen..."
)
a

'El Big data es como el sexo en la adolescencia: todo el mundo habla de ello, nadie sabe realmente cómo hacerlo, todos piensan que los demás lo están haciendo, así que todos dicen que también lo hacen...'

type(a)  # tipo de datos

str

# duplicar varias veces un string
"Ciencia de Datos " * 4

'Ciencia de Datos Ciencia de Datos Ciencia de Datos Ciencia de Datos '

# Concatenar strings
palabra = "Amo " + "Programar " + "En Python"
palabra

'Amo Programar En Python'

Imprimir con formato

print("Hola Mundo")

Hola Mundo

x = "Hola"  # asignar variable tipo string

x  # imprimir la variable en jupyter

'Hola'

print(x)  # imprimir una variable en python

Hola

num = 8  # asignación de variables
name = "Matias"

# f-string o string literal format

print(f"Me llamo: {name}, y mi edad es: {num}")

Me llamo: Matias, y mi edad es: 8

Entrada de datos del usuario

entrada = input("Como te llamas? ")  # los datos sera tipo string

type(entrada)  # tipo de dato

str

print(f"Hola {entrada} te deseo lo mejor aprendiendo python para análisis de datos")

Hola Jose Ricardo te deseo lo mejor aprendiendo python para análisis de datos

Listas

Las listas son una de las principales estructuras para almacenar información en Python.

En las listas podemos ingresar todo tipos de datos.
Se utilizan los corchetes [ ] para definir una lista y se separan usando coma.
Las listas son elementos Mutables (se pueden cambiar sus valores)

# definición de listas
uno = [1, 2, 3]
# las listas se delimitan sus elementos entre [ y ] y se usa la , como separación
uno

[1, 2, 3]

type(uno)  # tipo de datos

list

# Una lista puede tener diferentes tipos de datos
[
    "hola",
    1,
    [1, 2, 3],
]  # Esta lista tiene uns string, un numero y una lista como sus elementos

['hola', 1, [1, 2, 3]]

my_list = ["a", "b", "c"]  # creación de una lista
my_list

['a', 'b', 'c']

Indexacion en Listas y Strings

En Python, las listas son vectores; el primer elemento ocupa la posición 0, el segundo la 1 y así sucesivamente. Los índices negativos (iniciando en -1) se usan para indicar la posición contando desde atrás. Por ejemplo:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5
  -6  -5  -4  -3  -2  -1

NOTA IMPORTANTE: En python la numeracion de las posiciones empieza en cero 0

Para acceder a algun elemento de la lista, se utilizan corchetes, Ejemplo

lista_vble = [45,23,38,2,8,17] #creacion de una lista
lista_vble[2] # accediendo al valor que esta en la posicion 3
>> 38

Los strings tienen un comportamiento similar a las List, pero los strings son variables inmutables, mientras que las listas si son mutables.

# La indexacion y slicing de listas y strings es igual
# La primera posición es en 0
word = "Python"
word[0]  # carácter en la posición 0

'P'

word[5]  # carácter en la posición 5

'n'

word[-1]  # Último carácter

'n'

word[-2]  # Ante penúltimo carácter

'o'

word[-6]  # Primer carácter en este ejemplo

'P'

print(word[3])

Selección de varios elementos (Slicing)

El operador : se usa para indicar rangos.

La notación es [inicio:final-1], no se incluye el final

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5
  -6  -5  -4  -3  -2  -1

# El operador `:` se usa para indicar rangos,
#  [inicio:final-1], no se incluye el final

word[0:3]

'Pyt'

word[:2]  # ':2' indica desde el principio hasta la posición 2 (sin incluirla)

'Py'

# python
word[2:5]  # [inicio:final-1], no se incluye el final

'tho'

word[2:]  # Desde la posición 2 hasta el final

'thon'

# python
word[1:6:2]  # [inicio:final-1:paso], Ej inicio = 1, final-1 = 5, paso cada 2 elementos

'yhn'

word[::2]

'Pto'

# python
word[:2] + word[2:]  # Concatenación de strings

'Python'

word[:4] + word[2:]  # Concatenación de strings

'Pyththon'

word[-2:]  # desde la posición -2 hasta el final, o sea, los últimos dos caracteres.

'on'

word[:]  # desde el primero hasta el último carácter.

'Python'

word[::-1]  # Inversión de la palabra

'nohtyP'

type(word)

str

# Asignaciones a una posición especifica en las listas
# Se podrá hacer esta asignación en los strings?
# word[2] = 'e'

las listas son estructuras de datos mutables, entonces se pueden reescribir.

Los strings NO son mutables

# Las Listas son Variables Mutables
H = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
P = H  # copiar todo el contenido de H a P
P[0] = 333
print("Observar el que ocurre con 'H' cuando se cambia el valor de 'P', si P = H")
print(f"P = {P}")  # uso de f-strings para imprimir los resultados
print(f"H = {H}")  # uso de f-strings para imprimir los resultados

Observar el que ocurre con 'H' cuando se cambia el valor de 'P', si P = H
P = [333, 2, 3, 4, 5, 6, 7, 8, 9, 10]
H = [333, 2, 3, 4, 5, 6, 7, 8, 9, 10]

id(P)

136946608489856

id(H)

136946608489856

id(word)

136946700774384

Las listas no se copian al asignarlas a otra variable, ¡es un puntero a la lista original! ¡Esto evita problemas de memoria! pero puede llevar a errores en la programacion, entonces la copia se debe hacer explicita.

# Las Listas son Variables Mutables
H = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
P = H[:]  # copiar todo el contenido de H a P
P[0] = 333
print("Observar el que ocurre con 'H' cuando se cambia el valor de 'P', si P = H[:]")
print(f"P = {P}")  # uso de f-strings para imprimir los resultados
print(f"H = {H}")  # uso de f-strings para imprimir los resultados

Observar el que ocurre con 'H' cuando se cambia el valor de 'P', si P = H[:]
P = [333, 2, 3, 4, 5, 6, 7, 8, 9, 10]
H = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

id(P)

136946608493056

id(H)

136946619334528

Indexacion anidada

nest = [1, 2, 3, [4, 5, ["colombia"]]]  # Lista con otra lista al interior
nest

[1, 2, 3, [4, 5, ['colombia']]]

nest[3]  # Cuarto Elemento de la lista, lo que se retorna es una lista

[4, 5, ['colombia']]

nest[3][2]  # De la lista que es el elemento 4, obtener el elemento 3
# el tipo de resultado es una lista

['colombia']

# obtener el string
# De la lista que es el elemento 4, obtener el elemento 3,
# y obtener el valor de esa lista
nest[3][2][0]

'colombia'

# De la lista que es el elemento 4, obtener el elemento 3,
#  y obtener el valor de esa lista
nest[3][2][0][:2]

'co'

nest

[1, 2, 3, [4, 5, ['colombia']]]

# obtener otro elemento de la lista
# [1,2,3,[4,5,['colombia']]]
nest[3][:2][1]

Agregar datos en una lista

Agregar elementos a una lista se hace con los metodos: .insert() .append()

`.insert()`

list.insert(i, x): Inserta un ítem x en una posición i, los otros elementos despues de la posicion se mueven hacia la derecha.

nest = [1, 2, 3, [4, 5, ["colombia"]]]  # Lista con otra lista al interior
nest

[1, 2, 3, [4, 5, ['colombia']]]

nest.insert(2, "Amo Python")
nest

[1, 2, 'Amo Python', 3, [4, 5, ['colombia']]]

`.append()`

Agrega los elementos al final de la lista

nest

[1, 2, 'Amo Python', 3, [4, 5, ['colombia']]]

# se agrega un dato al final de la lista utilizando el método append()
nest[4][2].append(8)
nest

[1, 2, 'Amo Python', 3, [4, 5, ['colombia', 8]]]

nest[4].append("Pandas")
nest

[1, 2, 'Amo Python', 3, [4, 5, ['colombia', 8], 'Pandas']]

Asignar valores a una posicion

nest[2] = "Python"  # reasignar el valor a una posición de una lista
nest

[1, 2, 'Python', 3, [4, 5, ['colombia', 8], 'Pandas']]

# length
len(nest)  # obtener el tamaño de la lista

Borrar Elementos de una lista

nest[1:3] = []  # Borrar elementos de una lista
nest

[1, 3, [4, 5, ['colombia', 8], 'Pandas']]

len(nest)

# Borrar elementos de una lista conociendo su index

del nest[2][2][0]
nest  # observar que el valor esta dentro de una lista

[1, 3, [4, 5, [8], 'Pandas']]

Concatenar listas

print(nest)
print(my_list)

[1, 3, [4, 5, [8], 'Pandas']]
['a', 'b', 'c']

# Concatenar listas
new_list = nest + my_list
new_list

[1, 3, [4, 5, [8], 'Pandas'], 'a', 'b', 'c']

# agregar una lista al final
nest.append(my_list)
nest

[1, 3, [4, 5, [8], 'Pandas'], ['a', 'b', 'c']]

# Repetir varias veces una lista
repetida = my_list * 4
repetida

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

Diccionarios

Se utilizan las llaves { } para su definicion, Un Diccionario es una estructura de datos con características especiales que nos permite almacenar cualquier tipo de valor como numeros, strings, listas e incluso otras funciones. Estos diccionarios nos permiten además identificar cada elemento por una clave (Key). Las claves son únicas dentro de un diccionario, es decir que no puede haber un diccionario que tenga dos veces la misma clave, si se asigna un valor a una clave ya existente, se reemplaza el valor anterior.

Nota: El algoritmo que usa Python internamente para buscar un elemento en un diccionario es muy distinto que el que utiliza para buscar en listas. los elementos en los diccionarios no tienen un orden determinado.

Para buscar en las listas, se utiliza un algoritmos de comparación que tarda cada vez más a medida que la lista se hace más larga. En cambio, para buscar en diccionarios se utiliza un algoritmo llamado hash, que se basa en realizar un cálculo numérico sobre la clave del elemento, y tiene una propiedad muy interesante: sin importar cuántos elementos tenga el diccionario, el tiempo de búsqueda es siempre aproximadamente igual.

Este algoritmo de hash es también la razón por la cual las claves de los diccionarios deben ser inmutables, ya que la operación hecha sobre las claves debe dar siempre el mismo resultado, y si se utilizara una variable mutable esto no sería posible.

# Crear un diccionario
d = {"identificador1": "elemento1", "identificardor2": "elemento2"}

{'identificador1': 'elemento1', 'identificardor2': 'elemento2'}

type(d)

dict

# acceder al elemento que tiene la clave `identificador1`
d["identificador1"]

'elemento1'

# Un ejemplo de uso de los diccionarios
persona = {"edad": 20, "nombre": "Gabriel", "Apellido": "Garcia", "estatura": 1.77}
persona

{'edad': 20, 'nombre': 'Gabriel', 'Apellido': 'Garcia', 'estatura': 1.77}

print(persona["nombre"])
print(
    persona["Apellido"]
)  # Observar que esta clave empieza con Mayuscula, Python es case sensitive
print(persona["edad"])
print(persona["estatura"])

Gabriel
Garcia
20
1.77

print(
    f"El nombre del paciente es {persona['nombre']} {persona['Apellido']},"
    f"tiene {persona['edad']} años y una estatura de {persona['estatura']}"
)

El nombre del paciente es Gabriel Garcia,tiene 20 años y una estatura de 1.77

persona.keys()

dict_keys(['edad', 'nombre', 'Apellido', 'estatura'])

# Que ocurre si quiero obtener todos los valores del diccionario?
# persona[:]

Tuples

Las tuplas son como las listas (se indexan de la misma forma), pero al igual que los strings no se pueden modificar (son inmutables). Son como unas listas de sólo lectura. Se crean con () (paréntesis) en lugar de [ ] (corchetes). Una vez se crea una tupla, no se puede cambiar ni su contenido ni su tamaño, a menos que hagas una copia de la tupla.

fecha = (25, "Mayo", 1810)
fecha

(25, 'Mayo', 1810)

type(fecha)

tuple

fecha[0]

# Se puede hacer?
# fecha[1] = 'Julio'

Casting

Cambio entre tipos de datos

# Conversion de float a entero
int(5.789)

# Conversion de entero a float
float(3)

3.0

# conversion de numero a string
palabra = str(78345.345)
print(type(palabra))
palabra

<class 'str'>





'78345.345'

# conversion de string a numero, si el string es un numero
numero = int(
    "3456"
)  # recordar que los strings se escriben entre comillas simples o dobles
print(type(numero))
numero

<class 'int'>





3456

# conversion de lista a tuple
tup = ("Python", "Pandas", 3.0, 2018)
lista = list(tup)
type(lista)

list

tup = list(tup)
tup

['Python', 'Pandas', 3.0, 2018]

# conversion de tuple a lista
lista2 = [1, 2, 3, 4, 5, 6, 7, 8]
tup2 = tuple(lista2)
type(tup2)

tuple

# Conversion de un numero a Boolean
# Cualquier numero diferente de cero sera True
print(bool(4))
print(bool(1.65))
print(bool(-3))
print(bool(-5678))

True
True
True
True

# La conversion ser False si el numero es cero
print(bool(0))

False

# Conversion de Boolean a Numérico
int(True)

# Conversion de Boolean a Numérico
int(False)

Operadores de Comparacion y Logicos

Operadores de Comparacion

Python tiene los típicos operadores de comparación:

Operador	Funcion
`==`	Igual que
`!=`	Diferente a
`<`	Menor que
`>`	Mayor que
`<=`	Menor o igual que
`>=`	Mayor o igual que

Sus respuestas son del tipo Boolean

12 > 24  # Mayor que

False

12 < 24  # Menor que

True

10 >= 10  # Mayor o igual que

True

10 <= 42  # Menor o igual que

True

12 == 12  # Igual igual

True

12 != 48  # Diferente

True

"Hola" == "Adios"  # Comparación de igualdad

False

"Hola" != "Adios"  # Comparación de diferencia

True

"Hola" == "hola"  # Comparación de igualdad

False

"Hola" != "hola"

True

Operadores Logicos

Python implementa todos los operadores usuales de la lógica booleana.

Se usan las palabras en inglés and, or, not en lugar de símbolos (||, &&, !, etc)

(1 > 2) and (2 < 3)  # Operador and

False

(1 > 2) or (2 < 3)  # operador or

True

not (2 < 3) or (1 > 2)  # operador not

False

(1 == 2) or (2 == 3) or (4 == 4)

True

Programacion con Python

Condicionales if,elif, else

En Python no hay llaves { } ni begin...end para marcar el comienzo y fin de un bloque, sino que eso se logra con la indentación. La indentación por defecto son 4 espacios en blanco.

Entonces va a ser necesario indentar correctamente para utilizar sentencias if, for o para definir funciones.

El if es como el de otros lenguajes, pero no pide paréntesis y termina con : Su sintaxis es:

if condicion : #se finaliza con dos puntos :
    codigo a realizar#(indentado con 4 espacios)
elif condicion:
    codigo a realizar #(indentando con 4 espacios)
elif condicion:
    codigo a realizar #(indentando con 4 espacios)
else:
    codigo a realizar #(indentado con 4 espacios)

if 1 < 2:
    print("Viva la Música!")

Viva la Música!

if 1 > 2:
    print("Viva la Música!")

if 1 < 2:
    print("Primero")
else:
    print("Ultimo")

Primero

if 1 > 2:
    print("Primero")
else:
    print("Ultimo")

Ultimo

if 1 == 2:
    print("Primero")
elif 3 == 3:
    print("Mitad")
else:
    print("Ultimo")

Mitad

Ciclos for

Los for son parecidos a los if, pero tienen la sintaxis

for variable in lista:. En este caso, variable es la variable que va a ir cambiando, y lista es una lista de python (o un iterable que es parecido)

seq = [1, 2, 3, 4, 5]  # lista de valores
seq

[1, 2, 3, 4, 5]

# en este ciclo nombre_variable tomara cada uno
# de los valores que esta en seq uno por uno
for nombre_variable in seq:
    print(nombre_variable)

# se llama la variable _item  con el carater _
# para indicar que no se va a usar, es una convención no una regla

for _item in seq:
    print("Viva la Música!")

Viva la Música!
Viva la Música!
Viva la Música!
Viva la Música!
Viva la Música!

# [1,2,3,4,5]
for casa in seq:
    print(casa + casa)

lista_mix = ["hola", 2, [4, 5], "python"]

for casa in lista_mix:
    print(casa + casa)

holahola
4
[4, 5, 4, 5]
pythonpython

# Imprimir los strings de mi_lista por separado
mi_lista = ["img", "python", "numpy", "pandas"]
for s in mi_lista:
    print(s)  # este print va con indentación

img
python
numpy
pandas

Ciclos while

Evitar Usarlos, ya que pueden generar ciclos infinitos

i = 1
while i < 5:
    print(f"i es: {i}")
    i = i + 1

i es: 1
i es: 2
i es: 3
i es: 4

Control de ciclos break y continue

Los comandos break y continue son utilizados para terminar/salir de un ciclos for o while.

`break`

Termina la iteracion actual y continua con la ejecución de la siguiente instrucción

for letra in "Python":
    if letra == "h":
        break
    print(f"Letra actual : {letra} ")

print("Uso del comando break")

Letra actual : P
Letra actual : y
Letra actual : t
Uso del comando break

`continue`

Regresa al comienzo del ciclo, ignorando todos los commandos que quedan en la iteración actual del ciclo e inicia la siguiente iteración.

for letra in "Python":
    if letra == "h":
        continue
    print(f"Letra actual : {letra} ")

print("Uso del comando continue")

Letra actual : P
Letra actual : y
Letra actual : t
Letra actual : o
Letra actual : n
Uso del comando continue

List comprehension

Las comprensiones de listas proveen una forma de escribir bucles for más concisamente. Pueden ser muy útiles para crear nuevas listas a partir de listas existentes o iterables, ademas también se puede poner condiciones. Link para mas ejemplos

# Para elevar cada termino al cuadrado de una
# lista se debería hacer asi:
# función para elevar al cuadrado cada uno de los elementos de una lista
x = [1, 2, 3, 4, 5]  # lista de valores

out = []  # crear lista vacía
for item in x:
    out.append(item**2)  # item**2 = item*item
print(out)

[1, 4, 9, 16, 25]

# Usando List comprehension
# *resultado*  = [*operación*  *iteración*  *condición* ]
out = [item**2 for item in x]
out

[1, 4, 9, 16, 25]

# función para elevar al cuadrado cada uno
# de los elementos de una lista
# Solo si el elemento es mayor o igual a 3
out = []
for item in x:
    if item >= 3:
        out.append(item**2)

print(out)

[9, 16, 25]

# *resultado* = [*operación*  *iteración*  *condición*]

resultado = [item**2 for item in x if item >= 3]
resultado

[9, 16, 25]

Funciones

Las funciones se definen con la palabra clave def y tienen la sintaxis

def nombre_funcion(parametros):
    pasos de la funcion

    #si no se pone return, la funcion devuelve None
    return algo

Para devolver un valor utilizamos la palabra clave return.

def hola_python():  # `:` es obligatorio
    print("Hola Python")

hola_python()

Hola Python

def square(x):  # `:` es obligatorio
    # el cuerpo de la función esta definido
    # por la indentación (espacios en blanco)

    # para devolver valores se usa `return`
    return x**2

out = square(8)
out  # En jupyter no es necesario la función print

Ejemplo de funcion recibe una lista de numeros y devuelve la suma de sus elementos

def sumar_todos(lista):
    # recordar la indentación en Python
    suma_total = 0
    for elemento in lista:
        # Indentar nuevamente
        suma_total = suma_total + elemento
    return suma_total

mi_lista = [5, 2, 9, 4]
sumar_todos(mi_lista)

Ejemplo de la misma funcion pero con con algunas buenas practicas de software (documentacion, typing).

No es obligatorio para que funcione, pero es muy recomendable para entender que es lo que hace la funcion y tipos de datos se deben ingresar y que tipo de datos devuelve la funcion.

def sumar_todos(lista: list) -> float:
    """
    Suma todos los elementos de una lista de números.

    Args:
      lista (list): Una lista de valores Numéricos.

    Returns:
      (int o float) La suma de todos los elementos
    """
    suma = 0
    for v in lista:
        suma = suma + v
    return suma

mi_lista = [54, 12, 99, 15]
la_suma = sumar_todos(mi_lista)
print(f"Los elementos de la lista suman = {la_suma}")

Los elementos de la lista suman = 180

Funciones basicas de python

Son funciones que incluye python desde su instalacion, Built-in Functions, estas son palabras restringidas NO USAR


abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	import()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

# la función 'dir' Retorna un listado de atributos y métodos
# que tiene el tipo de datos espacio

dir("casa")  # en este caso el tipo de datos es un string

['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isascii',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'removeprefix',
 'removesuffix',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

"casa".capitalize()

'Casa'

"casa".__class__

str

dir(8)

['__abs__',
 '__add__',
 '__and__',
 '__bool__',
 '__ceil__',
 '__class__',
 '__delattr__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floor__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__index__',
 '__init__',
 '__init_subclass__',
 '__int__',
 '__invert__',
 '__le__',
 '__lshift__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__or__',
 '__pos__',
 '__pow__',
 '__radd__',
 '__rand__',
 '__rdivmod__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rlshift__',
 '__rmod__',
 '__rmul__',
 '__ror__',
 '__round__',
 '__rpow__',
 '__rrshift__',
 '__rshift__',
 '__rsub__',
 '__rtruediv__',
 '__rxor__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__trunc__',
 '__xor__',
 'as_integer_ratio',
 'bit_count',
 'bit_length',
 'conjugate',
 'denominator',
 'from_bytes',
 'imag',
 'numerator',
 'real',
 'to_bytes']

`len()`

Nos entrega la longitud de los elementos que hay en una lista, diccionario, string, etc

mi_lista = [54, 12, 99, 15]
len(mi_lista)

`help()`

Nos entrega la ayuda de una funcion, clase, etc

help(len)

Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

Ayuda de la funcion creada anteriormente

help(sumar_todos)

Help on function sumar_todos in module __main__:

sumar_todos(lista: list) -> float
    Suma todos los elementos de una lista de números.

    Args:
      lista (list): Una lista de valores Numéricos.

    Returns:
      (int o float) La suma de todos los elementos

`range()`

Cuando no tenemos una lista y queremos hacer un for “común” y que la variable que cambia sea un número que va incrementándose, podemos utilizar la función range.

En Python los índices comienzan en 0, y por eso los rangos también

range(5)  # función range de 0 hasta 5 (sin incluir el 5)

range(0, 5)

list(
    range(5)
)  # se obtiene una lista de números enteros desde 0 hasta 5 (sin incluir el 5)

[0, 1, 2, 3, 4]

# Si se usa en un FOR no es necesario convertirlo en un a lista
for i in range(5):  # Este es el uso mas común de la función range
    print(i)

# También se puede comenzar el rango en otro valor en lugar de 0
print("- for de 2 a 5:")
for j in range(2, 6):  # range de 2 hasta 5
    # aca va el código
    print(j)

- for de 2 a 5:
2
3
4
5

`enumerate()`

mi_lista = ["manzana", "banano", "uvas", "pera"]  # listado con frutas

# función enumerate para obtener el numero de la iteracion
# y el valor de la lista que estoy iterando

for posicion, valor in enumerate(mi_lista):
    print(f"En la iteracion {posicion} tiene el valor asignado de {valor}")

En la iteracion 0 tiene el valor asignado de manzana
En la iteracion 1 tiene el valor asignado de banano
En la iteracion 2 tiene el valor asignado de uvas
En la iteracion 3 tiene el valor asignado de pera

NOTA: Se recomienda leer sobre las funciones (map, filter, lambda y reduce) que actuan sobre listas, y que permiten reemplazar los ciclos for

http://www.pythondiario.com/2017/10/programacion-funcional-lambda-map.html

Metodos

Python permite definir clases y crear objetos de esas clases, pero esos temas están fuera de este tutorial. Los métodos se invocan de la siguiente forma objeto.metodo(parametro1,parametro2,…).

Metodos en strings

Existen varios tipos de metodos para los strings, estos se utilizan mucho para hacer la preparacion de datos categoricos, para mas informacion:

Metodos completos para strings

st = "Hola mi nombre es Jose R"

len(st)  # función que determina la longitud de 'st' también sirve con listas

Metodos de Formato

`.lower()`

devuelve el string en minusculas

st.lower()  # devuelve el string en minúsculas

'hola mi nombre es jose r'

st  # la operación no es inplace

'Hola mi nombre es Jose R'

`.upper()`

devuelve el string en Mayusculas

st.upper()  # devuelve el string en Mayúsculas

'HOLA MI NOMBRE ES JOSE R'

st  # la operación no es inplace

'Hola mi nombre es Jose R'

`.swapcase()`

una copia de la cadena convertidas las mayúsculas en minúsculas y viceversa.

st

'Hola mi nombre es Jose R'

st.swapcase()

'hOLA MI NOMBRE ES jOSE r'

`.capitalize()`

una copia de la cadena con la primera letra en mayúsculas.

st = "hola mi nombre es jose r"
st.capitalize()

'Hola mi nombre es jose r'

`.zfill()`

Retorna una copia de la cadena rellena con ceros a la izquierda hasta alcanzar la longitud final indicada.

id_upb = "5789"
id_upb.zfill(9)

'000005789'

Metodos de Busqueda

`.count()`

Retorna un entero representando la cantidad de apariciones de subcadena dentro de cadena

st

'hola mi nombre es jose r'

st.count("e")  # numero de veces que esta la letra 'e'

st.count("nombre")  # numero de veces que esta la palabra 'nombre'

`.find()`

Retorna: un entero representando la posición donde inicia la subcadena dentro de cadena. Si no la encuentra, retorna -1.

st

'hola mi nombre es jose r'

st.find("nombre")

Metodos de Sustiticion

`.replace()`

Reemplazar texto en una cadena

"hola mi nombre es José r".replace("José r", "Jose Ricardo")

'hola mi nombre es Jose Ricardo'

st.replace("jose r", "Jose Ricardo")

'hola mi nombre es Jose Ricardo'

`.strip()`

Eliminar caracteres a la izquierda y derecha de una cadena

st_esp = (
    "   hola mi nombre es jose r           "  # cadena de caracteres con muchos espacios
)
st_esp

'   hola mi nombre es jose r           '

st_esp.strip()  # Eliminar por predeterminado los espacios de izquierda y derecha

'hola mi nombre es jose r'

st_esp = "------hola mi nombre es jose r----"  # cadena de caracteres con muchos guiones
st_esp

'------hola mi nombre es jose r----'

st_esp.strip("-")  # Eliminar los guiones de izquierda y derecha

'hola mi nombre es jose r'

`.lstrip()`

Eliminar caracteres a la izquierda de una cadena

st_esp = "www.kaggle.com"
st_esp

'www.kaggle.com'

st_esp.lstrip(
    "w."
)  # Eliminar desde el inicio de la cadena incluido los caracteres definidos

'kaggle.com'

"0000083746".lstrip("0")

'83746'

`.rstrip()`

Eliminar caracteres a la derecha de una cadena

st_esp.rstrip(
    ".com"
)  # Eliminar desde el inicio de la cadena incluido los caracteres definidos

'www.kaggle'

Metodos de Union y Division

`.join()`

Retorna la cadena unida con el elemento que se desee

palabras = ("Gabriel", "Garcia", "Marquez")

separador = "-"

nombre_unido = separador.join(palabras)
nombre_unido

'Gabriel-Garcia-Marquez'

`.split()`

Retorna una lista con todos elementos encontrados al dividir la cadena por un separador.

palabras = "python, guía, curso, tutorial".split(", ")
palabras

['python', 'guía', 'curso', 'tutorial']

st = "Hola mi nombre es Jose R"
st.split()  # divide el string en 'espacios en blanco por defecto' y devuelve una lista

['Hola', 'mi', 'nombre', 'es', 'Jose', 'R']

tweet = "Viva el Rock and Roll! #Música #Concierto"  # creando un string
tweet

'Viva el Rock and Roll! #Música #Concierto'

tweet.split("#")  # dividir el string y el elemento de division es #

['Viva el Rock and Roll! ', 'Música ', 'Concierto']

tweet.split("#")[1]

'Música '

Metodos en listas

Existen varios tipos de metodos para las listas, para mas informacion: Metodos completos para listas

list.append(x): Agrega un ítem al final de la lista. Equivale a lst[len(lst):] = [x]
list.insert(i, x): Inserta un ítem en una posición dada. El primer argumento es el índice del ítem delante del cual se insertará, por lo tanto a.insert(0, x) inserta al principio de la lista, y lst.insert(len(lst), x) equivale a lst.append(x)
list.remove(x): Quita el primer ítem de la lista cuyo valor sea x. Es un error si no existe tal ítem.
list.pop([i]): Quita el ítem en la posición dada de la lista, y lo devuelve. Si no se especifica un índice, a.pop() quita y devuelve el último ítem de la lista. (Los corchetes que encierran a i en la firma del método denotan que el parámetro es opcional, no que deberías escribir corchetes en esa posición. Verás esta notación con frecuencia en la Referencia de la Biblioteca de Python.)
list.clear(): Quita todos los elementos de la lista. Equivalente a del lst[:].
list.index(x[, start[, end]]): Devuelve el índice basado de la lista del primer ítem cuyo valor sea x. Levanta una excepción ValueError si no existe tal ítem. Los argumentos opcionales start y end son interpetados como la notación de slicing y se usan para limitar la búsqueda a una subsecuencia particular de la lista. El index retornado se calcula de manera relativa al inicio de la secuencia completa en lugar de con respecto al argumento start.
list.count(x): Devuelve el número de veces que x aparece en la lista.
list.sort(key=None, reverse=False): Ordena los ítems de la lista in situ (los argumentos pueden ser usados para personalizar el orden de la lista, ve sorted() para su explicación).
list.reverse(): Invierte los elementos de la lista in situ.
list.copy(): Devuelve una copia superficial de la lista. Equivalente a lst[:].

Las mas usadas son:

lst = [8, 2, 3, 45, 24, 53, 785, 98, 1, 3, 6, 9, 2, 1]  # lista
lst

[8, 2, 3, 45, 24, 53, 785, 98, 1, 3, 6, 9, 2, 1]

len(lst)  # numero de elementos de la lista

`.append(x)`:

Agrega un ítem al final de la lista. Equivale a lst[len(lst):] = [x]

lst.append(37)  # Agrega este valor al final de la lista
lst

[8, 2, 3, 45, 24, 53, 785, 98, 1, 3, 6, 9, 2, 1, 37]

lst

[8, 2, 3, 45, 24, 53, 785, 98, 1, 3, 6, 9, 2, 1, 37]

`.pop([i])`:

Quita el ítem en la posición dada de la lista, y lo devuelve. Si no se especifica un índice, lst.pop() quita y devuelve el último ítem de la lista. (Los corchetes que encierran a i en la firma del método denotan que el parámetro es opcional, no que deberías escribir corchetes en esa posición. Verás esta notación con frecuencia en la Referencia de la Biblioteca de Python.)

# saca el ultimo elemento de la lista, para siempre
aa = lst.pop()
aa

lst

[8, 2, 3, 45, 24, 53, 785, 98, 1, 3, 6, 9, 2, 1]

# saca el 4 elemento de la lista, para siempre
aa = lst.pop(4)
aa

lst

[8, 2, 3, 45, 53, 785, 98, 1, 3, 6, 9, 2, 1]

`.copy()`:

Devuelve una copia superficial de la lista. Equivalente a list[:]

# Hacer una copia de la lista,
new_lst = lst.copy()
new_lst
# también puede ser new_lst=lst[:]

[8, 2, 3, 45, 53, 785, 98, 1, 3, 6, 9, 2, 1]

`.sort(reverse=False)`:

Ordena los ítems de la lista in situ o inplace

lst.sort()  # ordena la lista de menor a mayor
lst

[1, 1, 2, 2, 3, 3, 6, 8, 9, 45, 53, 98, 785]

lst.sort(reverse=True)  # ordena la lista de mayor a menor
lst

[785, 98, 53, 45, 9, 8, 6, 3, 3, 2, 2, 1, 1]

Identificar Elementos en la lista

# identificar si un elemento esta en una lista
"x" in [1, "python", 3]

False

# identificar si un elemento esta en una lista
"x" in [8, 2, "x", "python", 3]

True

Instalar Paquetes o Librerias

El repositorio Principal de donde se encuentran las librerias de Python es:

Pypi: https://pypi.org/

Instalacion en Linea de comando

PIP

pip install [nombre_paquete] #sin corchetes

Ejemplo: pip install pandas

Instalacion en Jupyter Notebook

PIP

!python -m pip install [nombre_paquete] #sin corchetes

Usar este para Google Collaboratory

Ejemplo: !python -m pip install pandas

Ejemplos

Links con Jupyter notebook de ejemplo de diferentes temas, usando Python

https://github.com/donnemartin/data-science-ipython-notebooks

https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks

Referencias

Phd. Jose R. Zapata

Programación Con Python