Fundamentos de Programación y Python

1

¿Por qué aprender Python?

2

Introducción a Python

3

Conceptos Básicos de Programación

4

Práctica: Te doy la bienvenida a los ejercicios interactivos

5

Manipulación de Cadenas de Texto en Python

6

Enteros, Flotantes y Booleanos

7

Todo lo que Debes Saber sobre print en Python

8

Operaciones Matemáticas en Python

9

Operaciones de Entrada/Salida en Consola

Colección y Procesamiento de Datos en Python

10

Listas

11

Método slice

12

Listas de más dimensiones y Tuplas

13

Aplicación de Matrices

14

Diccionarios

15

Comprehension Lists en Python (CLASE NUEVA)

Control de Flujo en Python

16

Estructuras condicionales

17

Bucles y Control de Iteraciones

18

Generadores e Iteradores

Funciones y Manejo de Excepciones en Python

19

Uso de Funciones en Python

20

Funciones Lambda y Programación Funcional en Python

21

¿Cómo realizar una función recursiva en Python?

22

Manejo de Excepciones y Uso de Pass (CLASE NUEVA)

Programación Orientada a Objetos en Python

23

Fundamentos de Programación Orientada a Objetos en Python

24

Ejercicio Biblioteca con POO

25

Herencia en POO con Python

26

Objetos heredados

27

Los 4 pilares de la programacion orientada a objetos

28

Uso de super() en Python (CLASE NUEVA)

29

Superando los Fundamentos de Programación Orientada a Objetos en Python

Lectura y escritura de archivos

30

Manejo de Archivos .TXT (CLASE NUEVA)

31

Manejo de Archivos CSV (CLASE NUEVA)

32

Manejo de Archivos JSON (CLASE NUEVA)

Biblioteca estándar de Python

33

Biblioteca estándar en Python (CLASE NUEVA)

34

Librería Os, Math y Random (CLASE NUEVA)

35

Librería Statistics y Análisis Estadístico (CLASE NUEVA)

36

Proyecto final: Guerra naval

Conceptos avanzados de Python

37

Recapitulación de lo aprendido hasta ahora

38

Escribir código Pythonico y profesional

39

Comentarios y Docstrings en Python

40

Scope y closures: variables locales y globales

41

Anotaciones de tipo

42

Validación de tipos en métodos

43

Librería Collections y Enumeraciones

Decoradores

44

Decoradores en Python

45

Decoradores anidados y con parámetros

46

Uso de Decoradores en clases y métodos

Métodos y estructura de clases en Python

47

Métodos mágicos

48

Sobrecarga de operadores

49

Implementación de `if __name__ == "__main__":`

50

Metaprogramación en Python

51

Uso de *args y **kwargs

52

Métodos privados y protegidos

53

Gestión avanzada de propiedades

54

Métodos estáticos y de clase avanzados

Programación concurrente y asíncrona

55

Introducción a la concurrencia y paralelismo

56

Threading y multiprocessing en Python

57

Asincronismo con asyncio

58

Asincronismo y concurrencia

Creación de módulos y paquetes

59

Creación de módulos en Python

60

Gestión de paquetes

61

Publicación de paquetes en PyPI

Proyecto final

62

Implementación de un sistema completo

63

Implementación de un Sistema Completo

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Python

Curso de Python

Carli Code

Carli Code

Publicación de paquetes en PyPI

61/63
Recursos

Aportes 7

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Lo entendí perfectamente, pero la verdad espero en otra ampliación que creen un modulo de los cursos para hacer un packete y luego subirlo, para posterior a ello descargarlo y utilizarlo, es mucho más practico que leer solo la documentación y se recuerda más <3
Publicar un paquete en el \*\*Python Package Index (PyPI)\*\* permite que otros usuarios puedan instalarlo y utilizarlo fácilmente a través de `pip`. Aquí tienes una guía paso a paso para hacerlo. \### Paso 1: Preparar el Entorno y el Código 1\. \*\*Organiza tu proyecto\*\*: Asegúrate de que tu paquete tiene la estructura correcta y un archivo `\_\_init\_\_.py` en cada carpeta de paquetes o subpaquetes. 2\. \*\*Crea `setup.py`\*\*: Este archivo contiene la configuración para construir e instalar el paquete. 3\. \*\*Crea `README.md`\*\* (opcional pero recomendado): Este archivo sirve como descripción detallada del paquete y se muestra en la página de PyPI. \### Paso 2: Crear el Archivo `setup.py` En la raíz de tu proyecto, crea `setup.py` con la configuración básica del paquete. Ejemplo de `setup.py`: ```python from setuptools import setup, find\_packages setup( name='mi\_paquete', # Nombre único en PyPI version='0.1.0', # Versión inicial packages=find\_packages(), # Encuentra automáticamente submódulos y subpaquetes description='Un paquete de ejemplo para operaciones matemáticas y de texto', long\_description=open('README.md').read(), long\_description\_content\_type='text/markdown', author='Tu Nombre', author\_email='tu\[email protected]', url='https://github.com/tu\_usuario/mi\_paquete', # URL del repositorio classifiers=\[ 'Programming Language :: Python :: 3', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', ], python\_requires='>=3.6', ) ``` \### Paso 3: Crear el Archivo `pyproject.toml` (opcional) Para definir cómo construir el paquete, usa un archivo `pyproject.toml`, aunque no siempre es necesario. Este archivo define las dependencias de construcción, si tu proyecto tiene configuraciones específicas. Ejemplo de `pyproject.toml`: ```toml \[build-system] requires = \["setuptools", "wheel"] build-backend = "setuptools.build\_meta" ``` \### Paso 4: Crear un Entorno Virtual y Empaquetar el Proyecto 1\. \*\*Instala `setuptools` y `wheel`\*\* en tu entorno virtual: ```bash pip install setuptools wheel ``` 2\. \*\*Empaqueta el proyecto\*\*: Esto creará los archivos necesarios en la carpeta `dist/`. ```bash python setup.py sdist bdist\_wheel ``` Esto generará un archivo `.tar.gz` y un archivo `.whl` dentro de la carpeta `dist/`, que son los archivos de distribución del paquete. \### Paso 5: Crear una Cuenta en PyPI 1\. \*\*Regístrate en PyPI\*\*: Si aún no tienes cuenta, ve a \[https://pypi.org/account/register/]\(https://pypi.org/account/register/) y crea una. 2\. \*\*Configura la autenticación\*\*: Una vez registrado, guarda tu nombre de usuario y contraseña, o crea un \*\*token de API\*\* para autenticación. \### Paso 6: Subir el Paquete a PyPI 1\. \*\*Instala `twine`\*\*: Es la herramienta para subir paquetes a PyPI. ```bash pip install twine ``` 2\. \*\*Sube el paquete a PyPI\*\*: ```bash twine upload dist/\* ``` 3\. \*\*Iniciar sesión\*\*: Twine te pedirá tus credenciales de PyPI, o puedes usar un token de API. \### Paso 7: Verificar la Publicación 1\. Visita tu página de PyPI en \[https://pypi.org/project/mi\_paquete]\(https://pypi.org/project/mi\_paquete) (reemplaza `mi\_paquete` con el nombre de tu paquete). 2\. Comprueba que la descripción, las dependencias y los archivos se hayan subido correctamente. \### Paso 8: Instalar el Paquete desde PyPI Para probar el paquete recién publicado, instálalo con `pip`: ```bash pip install mi\_paquete ``` \### Ejemplo Completo de la Estructura Final Estructura típica de un proyecto que se subirá a PyPI: ``` mi\_paquete/ │ ├── mi\_paquete/ # Paquete principal │ ├── \_\_init\_\_.py │ ├── operaciones\_matematicas.py │ └── operaciones\_texto.py │ ├── README.md # Descripción del proyecto (Markdown) ├── setup.py # Configuración de empaquetado └── pyproject.toml # (opcional) Configuración de compilación ``` \### Consejos para Publicaciones en PyPI 1\. \*\*Incrementa la versión\*\*: Cada vez que subas una actualización, incrementa la versión en `setup.py`. 2\. \*\*Buena documentación\*\*: Un `README.md` claro y detallado ayudará a los usuarios a entender cómo usar el paquete. 3\. \*\*Pruebas\*\*: Asegúrate de probar el paquete localmente antes de publicarlo. Este flujo garantiza que el paquete esté listo y sea accesible desde PyPI, permitiendo que otros usuarios puedan instalarlo y utilizarlo de manera sencilla.
### Paso 6: Verificar la Publicación Después de una carga exitosa, tu paquete estará disponible en PyPI y podrás instalarlo usando `pip`: `pip install mi_paquete`
### Paso 5: Publicar en PyPI Para publicar tu paquete, usa `twine`. Primero, instala `twine` si no lo tienes: `pip install twine` Luego, sube tu paquete a PyPI: `twine upload dist/*` Se te pedirá tu nombre de usuario y contraseña de PyPI. Si no tienes una cuenta, puedes crearla en PyPI.
### Paso 3: Crear un Archivo `README.md` Este archivo proporciona una descripción detallada de tu paquete. Es recomendable usar Markdown para formatearlo. ### Paso 4: Construir tu Paquete Usa `setuptools` y `wheel` para construir tu paquete. Primero, asegúrate de tener estas herramientas instaladas: `pip install setuptools wheel` Luego, construye tu paquete `python setup.py sdist bdist_wheel`
### Paso 2: Crear el Archivo `setup.py` El archivo `setup.py` es crucial para definir los metadatos de tu paquete. Aquí tienes un ejemplo básico: ```python from setuptools import setup, find_packages setup( name="mi_paquete", version="0.1.0", packages=find_packages(), install_requires=[ # Lista de dependencias ], author="Tu Nombre", author_email="[email protected]", description="Una breve descripción de tu paquete", long_description=open('README.md').read(), long_description_content_type='text/markdown', url="https://github.com/tu_usuario/mi_paquete", classifiers=[ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], python_requires='>=3.6', ) ```
### Paso 1: Preparar tu Paquete Asegúrate de que tu paquete esté bien estructurado. Una estructura típica podría ser: `mi_paquete/` `│` `├── mi_paquete/` `│ ├── __init__.py` `│ ├── modulo1.py` `│ └── modulo2.py` `├── tests/` `│ ├── __init__.py` `│ └── test_modulo1.py` `├── setup.py` `└── README.md`