Ejemplos de estructuras basicas en python

Miguel Alejandro Salgado Zapien

2021-05-11

El Objetivo de hoy

Es comprender el script mencionado en la clase pasada en su totalidad

#!/usr/bin/env python
from collections import defaultdict
from sys import argv
from pathlib import Path
import matplotlib.pyplot as plt

if __name__ == '__main__':
    try:
        _dir = Path(argv[1])
        if not _dir.is_dir():
            raise Exception()
    except:
        print("Invalid directory")
        exit(1)
    exts = defaultdict(lambda: 0)
    for file in _dir.iterdir():
        if file.is_dir():
            exts["directory"] += 1
        else:
            exts[file.suffix] += 1
    fig = plt.figure(figsize=(8, 8))
    ax = fig.add_subplot(1, 1, 1, aspect=1)
    plt.pie(exts.values(), labels = exts.keys())
    plt.show()

No analizaremos directamente el script, mas bien entenderemos los pasos conceptuales para lograr construir dicho script.

Acerca del import

import es una declaración para incluir funcionalidad perteneciente a un módulo.

Los módulos, son colecciones de funciones, variables y objetos en general, que ser pueden hacer accesibles para otros programas o ejecuciones de Python.

Python cuenta con una amplia lista de modulos instalados como parte del lenguaje mismo.

De los módulos estándar nos interesaran principalmente los que nos permiten trabajar con:

También podemos escribir módulos nosotros, estos módulos se organizan en archivos, de manera que podemos tener módulos representados por archivos o por directorios.

${PWD} es una variable en un shell que contiene el working directory o directorio actual.

Si tenemos un archivo nombrado module_A.py, alojado en el directorio ${PWD}, entonces si iniciamos un interprete interactivo de Python en el mismo directorio, podemos ejecutar import module_A, y esto importara el modulo completo y podremos accesar a su contenido bajo el nombre de module_A.<element> donde <element> es el nombre de la variable que buscamos.

Utiliza el siguiente código para crear un modulo y realizar pruebas respecto a lo previamente mencionado.

def foo(*args, **kwargs):
    print(args)
    print(kwargs)

if __name__ == '__main__':
    print("I am the main module")

También podemos tener módulos definidos por directorios, donde todos los archivos nombrados dentro de un directorio serán considerados como módulos dentro de módulos.

Para que un directorio se considere módulo y sea visible para Python como módulo, hay que crear un archivo especial llamado __init__.py dentro del directorio.

De manera que si buscamos que el directorio module_B sea considerado un modulo, tiene que existir el archivo module_B/__init__.py, y cuando realzamos la declaración import module_B vamos a importar el contenido de el archivo nombrado __init__.py.

Adicionalmente pudiéramos tener un archivo dentro del mismo nombrado module_B/example.py y este podrá ser accesible como módulo ejecutando import module_B.example.

Experimente con los previamente mencionado.

Módulos de terceros

Podemos utilizar módulos escritos por terceras personas, estos pueden ser obtenidos por distribución directa (es decir que alguien nos comparte los archivos que constituyen el modulo) o pueden ser obtenidos mediante el manejador de paquetes pip.

Durante la clase anterior instalamos algunos paquetes de esta manera.

Estos módulos generalmente cuentan con una estructura idéntica a la mencionada anteriormente, algunos pueden ser un solo archivo o muchos archivos depende del caso, y si cuentan con archivos adicionales distintos a código de Python pueden ser archivos de configuración o herramientas de distintos tipos para trabajar en el desarrollo del modulo mismo (no en el consumo o uso), también pudieran contener código en otros lenguajes de programación.

Acerca Documentación

La documentación es importante, debido a que nos ofrece maneras de informarnos acerca de la funcionalidad de un módulo, función u objeto.

Para invocar la documentación desde un programa de Python podemos acceder a la variable __doc__ o invocar la función help.

Ejemplos de esto serian:

list.__doc__
help(dict)

Datos básicos

Python es un lenguaje orientado a objetos de tipado fuerte y dinámico, es decir que los objetos tienen un solo tipo, pero que las variables no tienen un tipo definido.

Es decir que una variable puede alojar cualquier tipo de dato, pero que dichos tipos de dato no cambiaran.

Los tipos de dato básicos son, int, float, complex, str, bytes, list, dict, tupple, set.

Los primeros 3 son distintos tipos de números (enteros, punto flotante o decimales, y complejos)

Después vienen las cadenas de texto, (no existe el carácter singular, este sera una cadena de texto de longitud 1).

También están las cadenas binarias, que representan información en binario y podemos codificar a cualquier otro tipo de dato dependiendo el caso. (Esto es imperante porque en general los archivos serán del tipo binario y nosotros tenemos que hacer sentido del contenido desde su forma binaria, hasta obtener un tipo o estructura de dato apropiada).

También tenemos estructuras de dato mas complejas como las list o listas, que son colecciones de objetos heterogéneas indexadas por su posición en la lista.

a = [1, "dos", b"3", 4+0j]
print(a[0] == 1)
print(a[1])
print(a[-1])
print(a[1:-1])

Las listas tienen una serie de métodos y comportamientos de los cuales podemos hacer uso como son los descriptores.

Un descriptor es lo que se localiza enmedio de los corchetes posterior a objeto. a[<descriptor>].

Un descriptor para una lista puede ser un valor numérico entre el negativo de la longitud de la lista, y el predecesor de la longitud de la lista.

Es decir que si la lista es a = [1, 2, 3] los valores que puede tomar el descriptor son -3, -2, -1, 0, 1, 2, de tal manera que el primer elemento es el cero, y el ultimo el elemento es el 2, también podemos acezar a los datos con números negativos tal que el negativo significa tomar un valor iniciando por el final, de manera que el -1 seria el ultimo elemento, y así sucesivamente hasta llegar a -3 que seria el primer elemento (en este caso).

También los descriptores pueden ser lo que se conoce como slice, que son valores separados por :, como los siguientes: 1: 1:2, ::2, :2:1, etc…

Donde se define <inicio>:<fin>:<paso>, es decir que si queremos tomar los elementos pares pudiéramos tomar el slice 1::2, o si quisiéramos.

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(a[1::2])
print(a[::2])
print(a[::-1])
print(a[:5:3])
[2, 4, 6, 8, 10]
[1, 3, 5, 7, 9]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 4]

También tenemos los diccionarios que son estructuras de datos que permiten el uso de los descriptores pero en lugar de ser números enteros pueden ser objetos de Python mismo (la restricción es que sean objetos que soporten hash).

Podemos crear diccionarios de la siguiente manera:

a = dict(llave="uno", key="dos")
b = {"uno": "dos", "trees": 4, "2":2, 2: 3}
b["uno"]
b[2]
b["2"]

Leer mas