El primer paso profesional: creación de un entorno virtual

Creando un ambiente virtual con VENV

Creación de ambiente Virtual:

python3 -m venv nombre_venv

• Usualmente el nombre del ambiente virtual es venv.

Activación del ambiente virtual:

• Windows:

.\venv\Scripts\activate

• Unix o MacOS:

source venv/bin/activate

Desactivar el ambiente virtual:

deactivate

Crear un alias en linux/mac:

alias nombre-alias="comando"

`alias avenv=“source venv/bin/activate”``

Clase del curso de Git y Github 👩🏽‍💻

Aquí les dejo los pasos para crear un alias en Linux Ubuntu:
.
Para hacerlo en este sistema operativo, necesitamos que cada que la terminal cargue, el alias sea leído, para ello, la terminal tiene un archivo llamado .bashrc que contiene la configuración inicial, y usualmente se encuentra en nuestro home, por lo que hacemos lo siguiente:
.

1. Ejecutar sudo nano ~/.bashrc
2. Ir al final del archivo
3. Agregar el comando: alias avenv='source venv/bin/activate'
4. Guardar presionando ctrl + o y luego salir con ctrl + x
5. Reejecutar la configuración de la terminal: source ~/.bashrc
6. Activar el entorno vitual avenv

.
De esa forma persistirá siempre, ya que el alias se guarda dentro del archivo de configuración de la termial 😄

Si estas buscando hacer el trabajo en un Git Bash en windows.

La tarea es la siguiente:

El entorno virtual se activa con el siguiente comando:

source venv/Scripts/activate

luego si quieres poner un alias permanente debes seguir los siguientes pasos:

1. Ir a la carpeta C / Program Files /Git/etc/profile.d
2. Abrir el archivo aliases con VSC
3. Pegar el alias con el siguiente formato:

alias avenv="source venv/Scripts/activate"

1. Guarda como administrador y listo tienes todo.

**Para Linux primero ejecuten comando
**

sudo apt-get install python3-venv

para instalar módulos de entornos virtuales de python

Para el alias permanente:
1.- acceder a archivo bashrc por medio de vim

vim ~/.bashrc

2.- Ir hasta abajo del archivo para escribir en archivo presiona letra i y escribe lo siguiente:

#Mis alias personalizados
alias avenv="source venv/bin/activate"

3.- Presiona la tecla ESC y escribe :wq para salir y guardar.
4.- Hasta la siguiente sesion abierta se podrá ejecutar el comando personalizado, si quieres que funcione de una vez ejecuta el siguiente comando :

source ~/.bashrc

5.- ejecuta comando que hiciste y listo

Para aquellos que trabajan con Ubuntu y obtienen el siguiente error al momento de activar el entorno virtual:

bash: venv/bin/activate: No such file or directory

Esto ocurre porque al crear el entorno virtual este se crea de manera incompleta. La manera de resolverlo es instalar el manejador de paquetes para python PIP mediante:

sudo apt install python-pip

Posteriormente se instala el paquete para entornos virtuales:

pip install virtualenv

Despues reinstalamos la dependencia de entornos virtuales de Python para Ubuntu:

sudo apt-get install python3-venv

Finalmente volvemos a crear el entorno virtual mediante:

python3 -m venv venv

Cuando estuve buscando la solucion a este problema encontre formas mas simples para resolver esta misma situacion como crear el entorno virtual sin PIP mediante:

python3 -m venv --without-pip venv

O simplemente borrar la carpeta venv (con todos sus archivos) y volver a crearla.
Sin embargo, considero que la primera solucion nos ayuda a prevenir problemas con esta y otras dependencias, paquetes y librerias en el futuro.

Yo utilizo docker para correr Python y tengo un alias para hacerme la vida un poco mas easy

alias  py="docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp python:3 python"

Creación de un entorno virtual

• Para crear un entorno virtual usamos el módulo (instrucción -m) venv mediante la siguiente sintaxis python3 -m venv <nombre_env>
• Acto seguido se creará una carpeta que contiene una versión de python y en la cual podrás instalar las dependencias (paquetes) de manera ahislada, dentro de esta carpeta nos interesa la carpeta bin, en la que se encuentra el comando de activación
• Activación de entorno, lo hacemos con el comando: source venv\bin\activate (venv o el nombre que le pusiste al entorno virtual)
• Para desactivar el entorno virtual utilizamos el comando deactivate

Alias

• Son atajos que creamos para evitar escribir comandos largos (sobre todo si lo hacemos de manera recurrente)
• Para crear un alias utilizamos la sintaxis: <alias>='<comando>'
• El anterior método funciona solamante para la sesión actual, para guardar el alizas de manera global debemos escribir el anterior comando en el archivo ~/.bashrc con ayuda de un editor de texto (nano o vim si usamos la consola)

Para los de mac

MacOS Catalina y superior

Apple cambió su shell predeterminado a zsh , por lo que los archivos de configuración incluyen ~/.zshenvy ~/.zshrc. Esto es como ~/.bashrc, pero para zsh. Simplemente edite el archivo y agregue lo que necesite; debe obtenerse cada vez que abra una nueva ventana de terminal:

nano ~/.zshenv``alias py=python

Luego haga ctrl + x, y, luego ingrese para guardar.

Este archivo parece ejecutarse sin importar qué (inicio de sesión, no inicio de sesión o script), por lo que parece mejor que el ~/.zshrcarchivo.

Para poder crear un Alias en PowerShell, se debe usar el comando Set-Alias:

Set-Alias  -Name avenv  -Value .\venv\Scripts\activate

Para verificar si quedo registrado, se usa el comando Get-Alias:

Get-Alias  -Name avenv

Creando un entrono virtual en Anaconda

Para crear el entorno virtual en Ananconda, se hace en el environment de conda con:

conda create --name tmp #tmp es el nombre del entorno
activate tmp #en esta línea se activa el entorno creado
conda install spyder=5.0.0 #en esta línea se instala paquete 

Cuando ya se ha terminado se usar se elimina con:

conda env remove --name tmp #tmp es el nombre del entorno a eliminar

Para crear un alias en linux/mac se utiliza el comando alias y la sintaxis es la siguiente:

alias myalias = "comando"

Para el entorno virtual sería:

alias myvenv=“source venv/bin/activate"

Tuve problemas al crear el alias en Windows PowerShell, estuve investigando un poco y me encontré con este video, espero les sirva a los que igual tuvieron problemas:
https://www.youtube.com/watch?v=ZeicmOJyvrk

MIS APUNTES

Creación de un entorno virtual:

1. Crear una carpeta
2. Inicializar un repositorio en git (Opcional)
3. python3 -m name_entorno : -m indicativo para llamar un modulo, name usualmente se llama venv, en otros env. Crea una nueva carpeta dependiedo del SO es su contenido.
    En derivaciones linux: bin
    En windows:            Scripts
4. Activar el entorno virtual:
    En derivaciones linux:    source venv/bin/activate
    En windows:               .\venv\Scripts\activate
5. Indicador de activacion del entorno: es tener (venv) en la linea de comando
6. Desactivar el entorno virtual: deactivate
7. Para activar en una linea mas corta crear un alias.

Crear un alias en mac:

1. Asegúrate de estar en el directorio de tu usuario al correr lo siguiente:
	cd ~
2. Editar tu archivo .bash_profile existente. 
        sudo nano ~/.bash_profile
3. En el editor la macros o accesos directos a diferentes comandos.
        alias avenv = 'source venv/bin/activate'
4. Guardar y salir del archivo.
5. Actualiza ese archivo ejecutando el siguiente comando.
        . ~/.bash_profile
6. Utilizar alias
    avenv

Fuentes:
https://help.dreamhost.com/hc/es/articles/214202148--Cómo-cambiar-la-versión-de-PHP-que-usa-mi-shell-
https://www.imymac.es/mac-tips/how-to-create-a-hidden-folder.html

Si les sale un error al intentar activar el venv en windows (especificamente powerShell) pueden intentar con este comando que me funciono

Set-ExecutionPolicy Unrestricted -Force 

Recuerden tener su PowerShell como admin

Actualización en el método para crear un alias persistente en Ubuntu, usando buenas prácticas:
¡ No editen ~/.bashrc !
No necesitamos, ni debemos de modificar el archivo ~/.bashrc (es casi sagrado y en una actualización se pueden perder tus modificaciones). En su lugar, debemos crear o modificar el archivo ~/.bash_aliases (no es necesario usar sudo)
(nota: si tu teclado es español y no tiene la ~virgülilla~, se puede insertar con la combinación de teclas AltGr+4 o AltGr+ñ. Si tu teclado tiene distribución latinoamericana no tendrás este problema, pero pues ya te sabes otra manera de escribirla ~)
Editamos o creamos ~/.bash_aliases con el comando:

nano ~/.bash_aliases

Luego, en nano, al final del archivo (si es tu primer alias estará vacío), escribimos el comando para el alias tal cual lo escribiríamos en la terminal:

alias avenv="source venv/bin/activate"

Presiona Ctrl+X para salir y dale S para guardar los cambios (o Y si tu Ubuntu está en inglés)
Ahora sólo necesitas cerrar y volver a abrir tu terminal, aunque a algunas personas eso no les funcionó y tuvieron que reinciar la máquina.
¡Felices alias!

Me parece bueno crear ambientes virtuales pero no me gusta todo el espacio en disco duro que ocupan, instalando muchas dependencias. Por ejemplo, para un proyecto con solamente 5 jupyter notebooks, tenia un ambiente que pesaba 1.5Gb. En cambio, en Google Colab pesaba solo 350Kb.

No encontraba como poner alias en la consola con windows y me funcionó
doskey venv1=.\venv\Scripts\activate

Saludos!

Tengo Ubuntu 20.04 - Python 8.3.5

No he podido crear el env. Este es el error luego de sudo apt-get install python3-venv

-->python3-venv : Depends: python3.8-venv (>= 3.8.2-1~) but it is not going to be installed
E: Unable to correct problems, you have held broken packages.

Esta fue la solución que encontré, espero les sirva:

apt-get update && apt-get install python3-virtualenv

En lo particular uso git bash y para activar mi venv tengo que escribir el comando:

source ./venv/Scripts/activate

Y para crear el alias tengo que usar comillas (por la palabra source)

alias avenv="source ./venv/Scripts/activate"

La forma en la que creé el alias permanente fue la siguiente, teniendo en cuenta que tengo la distribución de Ubuntu instalada en mi sistema operativo Windows por medio de WSL2 (Windows Subsystem for Linux 2, en el curso de PreWorking para Windows enseñan de una manera muy clara como instalarlo):

Me dirigí al home (cd ~) y ahí ejecuté el comando (ls -a), ahí se encuentra el archivo .bashrc, con el comando (cat .bashrc) lo abrí para verificar las recomendaciones de la distribución para crear los alias, en la última parte del archivo aparecen los comentarios recomendando poner los alias en un archivo aparte llamado .bash_aliases, busqué ese archivo y no estaba entonces lo creé con el comando (touch .bash_aliases) y con el comando (nano .bash_aliases) ingresé el documento y ahí puse:

alias avenv=‘source venv/bin/activate’

Guardé el documento, cerré la consola y al volverla a abrir, probé el comando y funcionó perfectamente!! 😄

La opción más portable es que sepas usar venv a pesar de que suelas usar otro manejador de ambientes virtuales.
Yo suelo usar conda para administrar mis entornos virtuales es muy bueno. Peeero si lo que te interesa es hacer proyectos de Django por ejemplo, cuando vayas a prodccción vas a tener que hacer el ambiente virtual con venv. La opción más portable es que sepas usar venv a pesar de que suelas usar otro manejador de ambientes virtuales.

Si te sale el error al usar la PowerShell

la ejecución de scripts está deshabilitada en este sistema Para obtener más información, consulta el tema about_Execution_Policies…
sigue estos pasos:

1. Abre Windows PowerShell como admin

   Win + X
   clic en PowerShell (admin), le damos si a los permisos

2. escribimos el siguiente comando:

   Get-ExecutionPolicy -list 
   

3. Tenemos que habilitar la que dice local Machine con este comando:

   Set-ExecutionPolicy RemoteSigned -Force
   

4. Abrimos ejecutar:

   Win + R

   y escribimos

   gpedit.msc
   

5. Buscamos esta ruta

   Configuración del equipo -> Plantillas administrativas -> Componentes de Windows -> Windows PowerShell

   abrimos "Activar la ejecución de scripts"
   le damos en “Habilitada”

   Directiva de ejecución

   Permitir solo scripts frimados
   aplicar y aceptar

y listo

Si estás utilizando Windows, pero no la terminal de Cmder y en su lugar usas PowerShell entonces asegúrate primero de tener permisos de ejecución de scripts:

Get-ExecutionPolicy

si aparece como Restricted entonces necesitarás otorgar permisos con

Set-ExecutionPolicy Unrestricted

después de eso ya es posible hacer un alias para el entorno virtual con la siguiente sintaxis

Set-Alias -Name nombre_alias -Value .\nombre_entorno\Scripts\activate

• Y recordar que de esta manera obtienes alias que son temporales y que si reinicias la terminal de comandos este alias desaparecerá
• También es necesario recordar que para activar y desactivar el ambiente deberás estar “parado” sobre la ruta hasta la carpeta justo donde se creó el entorno virtual de lo contrario no funcionará ni el alias ni el comando directamente para activarlo.

Considerar que venv tiende a generar entornos duros, es decir, si mueves el directorio del entorno a otro este dejará de funcionar a menos que se reemplacen las rutas duras dentro del mismo, en su lugar virtualenv mantiene rutas relativas en todo momento lo que permite mover los proyectos y sus entornos sin este inconveniente.

• Creacion de entorno virtual (dependencia para cada proyecto)

py -m venv venv

• Activacion de entorno virtual en Windows

.\venv\Scripts\activate

• Salir de entorno virtual

deactivate

• Crear alias para activar entorno virtual

alias avenv=.\venv\Scripts\activate

ejecutando el comando me genero el siguiente error

.\env_proyect\Scripts\activate : No se puede cargar el archivo D:\Cursos\Curso Python Intermedio\Proyecto_Ejemplo\env_proyect\Scripts\Activate.ps1 porque la ejecución de scripts está deshabilitada en este   
sistema. Para obtener más información, consulta el tema about_Execution_Policies en https:/go.microsoft.com/fwlink/?LinkID=135170.
En línea: 1 Carácter: 1
+ .\env_proyect\Scripts\activate
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : SecurityError: (:) [], PSSecurityException
    + FullyQualifiedErrorId : UnauthorizedAccess

Lo solucione ingresando al PowerShell como administrador y aplicando este comando

Set-ExecutionPolicy Unrestricted -Force

Creación de alias en Linux

$ alias shortName="your custom command here"

$ vim ~/.bashrc

Se accede a un archivo. Se puede ubicar al final para ingresar el alias y se mantenga permanente.

#My custom aliases
alias home=”ssh -i ~/.ssh/mykep.pem tecmint@192.168.0.100”
alias ll="ls -alF"

Para guardar

$ source ~/.bashrc

Fuente:
https://www.tecmint.com/create-alias-in-linux/

Como instalar ambientes virtuales en python 3.5X+ Para windows / Linux / MacOS

.

• Ingresa al CMD y crea o muevete a la carpeta en donde deseas instalar el virtualvenv

• Una vez alli si es tu primera vez o para evitar errores deberias aplicar este comando

python.exe -m pip install --upgrade pip

• Ya estara actualizado pip en nuestro sistema, ahora debemos iniciar el ambiente virtual de la slgiuiente forma:

python -m venv [la ruta de nuestra carpeta]

#Quedaria de la siguiente forma: 

python -m venv C:\Users\ZeroBits\Desktop\python_intermedio

• Verificar que todo fue instalado correctamente con el comando “ls -a” alli veras archivos nuevos creados tales como Scripts, Lib, etc

• Ahora para activar en W10, tienes que colocar el siguiente comando

Scripts\activate.bat

• Si estas en otros sistemas operativos como linux o MacOS

source bin/activate 

• Listo ya deberias tener instalado totalmente el ambiente virtual

Para los que usan Git Bash en Windows 10, al querer crear el alias permanente, deberá modificar el archivo aliases ubicado en la ruta ‘C:\Program Files\Git\etc\profile.d’ para esto, primero abran su editor de texto en modo administrador y luego abran el archivo y agregan el alias justo como se muestra en la imagen.

Luego no olviden reiniciar la terminal para que los cambios se vean reflejados.
Espero les sirva, Salu2.

Para crear un alias en mac si con zsh y vim

Si usas zsh el archivo de configuracion no se llama .bashrc, se llama .zshrc

Voy a usar VIM un editor de texto por consola
la ruta ~/ que es el home en tu computadora
y el nombre del archivo.

vim ~/.zshrc

Es algo como “abre con vim este archivo en tal ruta”

vas hasta abajo del archivo presionas i para entrar al modo de edicion.
En una nueva linea (todo lo que tenga # son comentarios) escribes lo mismo que n clase, el alias

alias avenv='source venv/bin/activate'

presionas la tecla esc para salir del modo edición he ingresa
:w para guardar
:q para salir del editor

Reinicia tu terminal y ya funciona

👍🏻

Crear alias en MAC (y que no se borre cada vez que cerramos la terminal)

cd
nano bash_profile 

dentro ponemos los alias y guardamos con ctrl x

source bash_profile

Listo!

Si estás usando WSL (Ubuntu) puede que al ejecutar el comando para crear un ambiente virtual, te haya saltado un error, eso es porque no tenemos instalado el comando venv, dependiendo de tu versión de python cambiará el comando, checa esa versión y luego modifica según tu versión:

sudo apt install python3.8-venv

Como puedes ver, ahí lo ejecuté para la versión 3.8 de python. Una vez instalado venv en tu WSL, ya podrás crear ambientes virtuales.

Creación de un entorno virtual estándar en powershell:

Para activar el entorno virtual:

Usando el entorno, nota que primero actualizo pip dentro del entorno.
Instalo requests que es un modulo para hacer peticiones HTTP y con pip freeze listo las dependencias del proyecto que se han instalado.

como el modulo requests tiene dependencias, pip las instala en automático y aparecen listadas con pip freeze.

Encontré una respuesta en stack overflow muy bien explicada al problema del alias persistente en Ubuntu. Se las paso (: Es este link

Si estás en linux y tienes el error:

"The virtual environment was not created successfully because ensurepip is not
available. On Debian/Ubuntu systems, you need to install the python3-venv
package using the following command.

apt-get install python3-venv

You may need to use sudo with that command. After installing the python3-venv
package, recreate your virtual environment."

Simplemente escribe: sudo apt-get install python3.9-venv (3.9 porque es la versión más actualizada)

Luego ejecuta sudo python3.9 -m venv venv y ya debería funcionar correctamente.

Hola, utilizo Ubuntu y para crear un alias permanente primero en la terminal entrara a sudo nano ~/.bashrc

Hay que introducir la contraseña, y se desplegará un código, donde se encuentran todos los alias, al final vamos a escribir nuestras alias personalizadas
La linea debe de tener alias (el nombre del alias) = entre comillas simples ’ la ruta que quiero que siga’ para el ejemplo fue: alias avenv='source venv/bin/activate’

Cuando ya tengamos nuestras alias, vamos a dar clic en ctrl + o para guardar y luego dar enter, para salir presionamos ctrl + x
En este punto me pasó que me marcaba error al tratar de revisar que el alias se habia guardado, para hacer esto escribir en la terminal: source ~/.bashrc, si marca error puedes probar reiniciar el equipo, así lo solucioné 😛 pero antes hay que revisar si lo escribiste bien, si usaste las comillas simples o si hay algun error en alguna linea de código.
Para finalizar solo escribí en la terminal alias y puedes ver la lista de alias, o solo escribe tu alias y hará lo que tiene que hacer

😃

Pasos para crear un alias en Mac OS
Bash o Zsh

• Vamos a nuestro home directory e ingresamos el siguiente comando en nuestra terminal:

➜  ~ cd

• Creamos la carpeta .zshrc para Shell Zsh

➜  ~ nano .zshrc 

• O para quienes usan Bash

➜  ~ nano .bash_profile

• Como se muestra en la imagen ingresamos en la ultima linea o en caso este vacío el file seria la primer linea

alias avenv= "source vent/bin/activate"

• Guardamos los cambios con el comando

> Tecla Control + o

• Para salir de nano usamos el comando

> Tecla Control + x

• Debemos de refrescar el entorno con los comandos dependiendo de tu Shell
• Para Bash

source ~/.bash_profile

• Para Zsh

source ~/.zshrc

Para finalizar

• Seguimos los mismos pasos para cualquier alias que necesitemos que persista en el sistema

Notas 😄
El primer paso profesional: Creación de un entorno virtual.

• Podemos crear un entorno virtual para un proyecto en particular, dentro de una carpeta en específico (donde está el proyecto).
• Es recomendable iniciar un repositorio de Git para cada proyecto 😄.
• Para crear el entorno virtual, primero hacemos python3 -m vevn <nombre de ambiente> , donde la bandera -m nos deja llamar a un módulo, en este caso venv de virtual environment. 🔥
• Una vez que hayamos creado el entorno virtual, debemos entrar en dicho entorno para comenzar a trabajar con el 🤔. Para esto, en WSL, usamos source <nombre de ambiente>/bin/activate. Para que sea más fácil usar esto, podemos crear un alias 👀.
• Para salir del entorno virtual usamos deactivate.
• Para crear un alías temporal en Ubuntu, es igual alias <nombre>="<comando>". Pero para que quede de manera permanente, debes agregarlo al documento .bashrc (el mismo comando).

alias en mac
https://www.youtube.com/watch?v=XVQea3seLfM

Para los que quiza les fallo la inicialización pueden intalar el modulo de venv con el comando:

sudo apt install python3.8-venv

para tener en cuenta en WSL linux desde windows, dejo estos pasos para que no tengan problema:

1 instalamos esto si no lo tienes
$pip install virtualenv
2 luego este para tener el entorno
$sudo apt-get install python3-venv
3 ahora entramos al bashrc donde se hace el alias
$sudo nano ~/.bashrc
4 se abre unos scripts ir a la parte final y escribir:
$alias avenv='source venv/bin/activate'
5 luego le dan ctrl + x para darle una salida te dira que si deseas guardas le das y, luego das enter.
6 luego $source ~/.bashrc
7 luego escribre solamente ya el alias $avenv
8. listo ya tienes activado tu entorno virtual en WSL con un alias que no se borrara.

Para el alias en git bash en windows tienen que poner el comando entre comillas despues del signo de igual:

alias avenv="source venv/Scripts/activate"

Para los que vayan a ver el curso de Git y GitHub no olviden prestar mucha atención en la instalación y cambiar de master a main porque genera un conflicto a la hora de subir sus proyectos al repositorio virtual.

Para agregar aliases en Linux (permanentes), deben editar el archivo .bashrc agregando el comando para definir el alias al final:

# otras cosas

alias avenv="source venv/bin/activate"

Si están usando ZSH, tienen que hacer los mismo pero en el archivo .zshrc. Ambos archivos se encuentran en el HOME (cd ~)

Si ustedes así como yo tienen instalado ohmyzsh, recuerden para crear el alias en Mac NO deben ir a .bashrc sino a .zshrc 😄

Por si alguien usa intellij como IDE y no sabe como agregar el entorno virtual les dejo este link que explica paso a paso como se hace:
Agregar entorno virtual a intellij

Para crear un alias en linux lo que debes hacer es en la terminal escribir:
code bash
Si tienes vs mejor.
escribes alias “el nombre que quieras”=código a asignar.
crl+s para guardar cambios.
Ya en la terminal, escribes bash y ya esta.
Puedes probar tú alias!.

Crear un entorno virtual para python
Windows:
Para crear un entorno virtual en Windows debemos ejecutar el siguiente comando:
py -m venv <nombre_del_entorno>
Para activar el entorno virtual de python debemos ejecutar el siguiente comando:
.\venv\Scripts\activate
Podemos crear un alias para no tener que ejecutar este comando siempre que queramos activar el entorno virtual, los alias en cmder se guardan de manera persistente de manera automática así que solo hay que ejecutar el siguiente comando:
alias avenv=.\venv\Scripts\activate
Linux:
En Linux para crear un entorno virtual debemos de ejecutar el siguiente comando:
python3 -m venv <nombre_del_entorno>
Para activar el entorno virtual ejecutamos el siguiente comando:
source venv/bin/activate
Si queremos guardar un alias y estamos usando bash debemos de ejecutar el siguiente comando para editar o crear el archivo bash_aliases
nano ~/.bash_aliases
Una vez dentro del editor lo que tenemos que hacer es agregar el alias con la siguiente sintaxis:
alias avenv="source venv/bin/activate"
Ahora solamente debemos de salir del editor, si estamos usando nano usamos ctrl+o luego presionamos enter y luego ctrl+x
Si estamos usando zsh debemos de añadir el alias al archivo .zshrc usando el siguiente comando:
nano ~/.zshrc
Al final de este archivo se encontrará la sección para nuestros alias personalizados, solamente tenemos que añadirlo de la misma manera que en bash.
Para salir del entorno virtual el comando que debemos de ejecutar es:
deactivate

Acá las librerías o modelos más poderosos de Python para ciencia de datos y dejo el link con su descripción:

https://techvidvan.com/tutorials/python-libraries-for-data-scientist/

Creación y activación de un entorno virtual

1. Creamos la carpeta donde vamos a trabajar y crear nuestro entorno virtual $ mkdir nombre_carpeta
2. Inicializamos el repositorio con $ git init
3. Creamos el entorno virtual llamando a Python (py), la bandera módulo (-m), el nombre del módulo (venv) y el nombre que le vamos a poner a nuestro entorno virtual $ py -m venv venv el entorno virtual se llama venv
4. Podemos comprobar que la carpeta de entorno virtual fue creada ejecutando ls y nos enlista lo que tenemos y podemos ver las carpetas del entorno virtual ejecutando ls \venv
5. Para activar el entorno virtual .\venv\Scripts\activate nos muestra que estamos en el entorno virtual venv
6. Para desactivar el entorno virtual ejecutamos deactivate
7. Creando un alias al comando de activación para que no tengamos que ejecutar todo eso siempre $ alias avenv= .\venv\Scripts\activate ahora solo ejecutamos avenv y entra a nuestro entorno virtual

En la documentación de Python también se explica el procedimiento para crear un entorno virtual .
Aqui les dejo el link
https://docs.python.org/es/3/tutorial/venv.html

Para la consola de PoweShell funciona de la siguiente manera:

New-alias avenv .\venv\Scripts\activate

para dejar el alias permanente en linux:
desde la terminal escribir el comando: nano .bashrc
al final escribes el alias: alias actev="source venv/bin/activate"
ctrol+o para guardar los cambios
ctrol+x para salir del editor
exit para salir de la terminal
ingresas nuevamente y ya debe correr el alias

Si estas usando el prompt de Windows, usar “doskey” en vez de “alias”.

Existen diferentes entornos virtuales además de venv, personalmente me gustan

• Poetry
• Pipenv

Saludos 😄

para hacer un alias en mac utilizaremos alias avenv=“source venv/bin/activate”

adema si usas la terminal .zsh puedes editar el archivo de la terminal y agregar tu alias para que se quede guardado para siempre

Crear un alias en Z Shell:
abrir el archivo “.zshrc” . Si no existe hay que crearlo con el siguiente comando y después activarlo, si no mal recuerdo el comando es:

touch ~/.zshrc

crear un alias para activar el entorno virtual:

alias pyon="source venv/bin/activate"

y ya que estamos por aquí, creamos un alias para desactivar el entorno virtual:

alias pyoff="deactivate"

Hay que tener en cuenta que para ver los cambios hay que reiniciar / resetear la terminal

La mejor forma que encontré de crear alias en mac es la siguiente:

1 Ir a home en la terminal cd ~
2 Hacer un ls -all solo para ubicar el archivo .bash_profile
3 Abrir el archivo con VScode ejecutando
code .bash_profile
4 Escribir el alias en la parte superior del documento, debajo de los otros alias o directamente hasta arriba si no tenemos ningún otro alias:
alias avenv='source venv/bin/activate’
5 Guardar el archivo cmd + s y reiniciar la terminal.

¿Cómo crear alias en una distro de linux?

Crearlos es un proceso relativamente fácil y rápido, vamos a ver como crearlo.
En linux existen dos tipos de aliases: los temporales y los permanentes.

Creación de alias temporales

Lo que debemos hacer es escribir la palabra alias en la terminal. Después tendremos que utilizar el nombre que queremos usar para ejecutar un comando. Esto irá seguido por el signo ‘=’ y la llamada al comando que queramos utilizar

ejemplo: alias imagenes= " cd /home/user/images/"

–> donde dice user obviamente va el nombre que tienes de usuario en tu maquina

Creación de alias permanentes

Para mantener los alias entre sesiones, vas a tener que guardarlos en el archivo de perfil para la configuración de shell de tu usuario. Estos podrían ser:

Bash → ~/.bashrc
ZSH → ~/.zshrc
Fish → ~/.config/fish/config.fish

La sintaxis que hay que utilizar en este caso, es la misma que cuando creamos uno temporal. La única diferencia viene del hecho de que esta vez lo guardaremos en un archivo.

Entonces, por ejemplo, en bash, puedes abrir el archivo .bashrc con tu editor favorito:
Para mi caso utilizo vim pero tu puedes utilizar nano si así lo deseas

vim ~/.bashrc

Un buen lugar para agregarlos suele ser al final del archivo. Para propósitos de organizaciones, puedes dejar un comentario antes:

#aliases reados por mi

alias actualizarSistema=" sudo apt update && sudo apt upgrade"

Al terminar guarda el archivo.

Nota: Puedes agregar aliases como gustes.

Adicional tambien los aliases los puedes eliminar y se hace de esta manera:

Para eliminar un alias agregado a través de la línea de comandos, se puede utilizar el comando unalias.

unalias nombre_del_alias

En caso de querer eliminar todas las definiciones de alias, podemos ejecutar el siguiente comando:

unalias -a [elimina todos los alias]

Y eso sería todo espero les sea de utiliadad para el desempeño de sus labores diarias :3

- Edit ~/. bash_aliases or ~/. bashrc file using: vi ~/. 		  bash_aliases.
- Append your bash alias.
 For example append: alias update='sudo yum update'

• Save and close the file.
  -Activate alias by typing: source ~/. bash_aliases.

Steps to create a permanent Bash alias:

Open the Terminal app and then type the following commands:

1. Edit ~/.bash_aliases or ~/.bashrc file using:
   vi ~/.bash_aliases
2. Append your bash alias
   For example append: alias update=‘sudo yum update’
3. Save and close the file
4. Activate alias by typing:
   source ~/.bash_aliases

Y listooooooo!!!

Me gusta más manejar los ambientes virtuales con Conda!

Para los que usamos ZSH…

Tenemos que modificar el archivo pueden utilizar el editor de consola que deseen en mi caso utilizo neovim

nvim ~/.zshrc

en mi caso tengo dentro del archivo:

# alias
alias dj='python manager.py'
alias py=python

una vez que hemos creamos los alias actualizamos la consola con:

source ~/.zshrc

y tenemos los nuevos alias.

Hola amigos, esto es ¡excelente!
Entorno virtual. Crea carpeta donde vivirá un Python específico para el proyecto. Se podrá instalar y actualizar los módulos a gusto sin tocar el Python global de la computadora.
Pero hay que activarlo y evitar así que se trabaje con el de la computadora.

Para los que usan “zsh” y desean crear un alias, deben seguir los siguientes pasos.

1. Ubicar el archivo “.zshrc” que lo ubican en el directorio raíz y se agregó al instalar zsh.

$ ~/. zshrc

1. Editar el archivo y agregar una línea con el alias.

alias avenv="source venv/bin/activate"

1. Cerrar y volver a entrar al terminal o escribir el siguiente comando:

$ source ~/. zshrc

1. Usar el alias 😄

Comentario: Siempre nombrar el entorno como venv para que el alias sirva en todos los casos.

Si quieres utilizar cmder dentro de VS Code solo tienes que agregar lo siguiente en settings.json:

{
    "terminal.integrated.profiles.windows": {
        "cmder": {
            "path": "C:\\WINDOWS\\System32\\cmd.exe",
            "args": [
                "/K",
                "C:\\tu\\ruta\\a\\cmder\\vendor\\bin\\vscode_init.cmd"
            ]
        }
    },
    "terminal.integrated.defaultProfile.windows": "cmder"
}

Estas son las rutas donde esta el settings.json:

• Windows %APPDATA%\Code\User\settings.json
• macOS $HOME/Library/Application Support/Code/User/settings.json
• Linux $HOME/.config/Code/User/settings.json

CREACION DE ENTORNO VIRTUAL - cbernacbr256 - 27/09/2021

Crear un entorno virtual nuevo
En Windows:
C:>python -m venv c:\ruta\al\entorno\virtual

En macOS y Linux:
$ python -m venv ruta/al/entorno/virtual

Es recomendado que la carpeta para el entorno virtual sea una subcarpeta del proyecto Python al que está asociado.

Activar un entorno virtual
En Windows:
C:>c:\ruta\al\entorno\virtual\scripts\activate

En macOS y Linux:
$ source ruta/al/entorno/virtual/bin/actívate

Desactivar un entorno virtual
Este comando es idéntico para Windows, macOS y Linux:
$ deactivate

Eliminar un entorno virtual
En Windows:
C:>rmdir c:\ruta\al\entorno\virtual /s

En macOS y Linux:
$ rm -rf ruta/al/entorno/virtual

Para linux

python3 -m venv venv # Creates venv
source venv/bin/activate # Activates venv
deactivate # You got the point
alias avenv='source venv/bin/activate' # Creates alias for the activation path.

[email protected] proyecto % git init
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint: 
hint: 	git config --global init.defaultBranch <name>
hint: 
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint: 
hint: 	git branch -m <name>
Initialized empty Git repository in /Users/macbook/Downloads/python/proyecto/.git/
[email protected] proyecto % python3 -m venv venv
[email protected] proyecto % ls
venv
[email protected] proyecto % source venv/bin/activate
(venv) [email protected] proyecto % 

Para agregar una alias tendremos que ir a la ruta /home/{user} y agregarlo al .**rc esto dependerá del tipo de consola que tengamos para los que tengan la zshell será .zhrc (Mac) o para los que tenemos derivados de debian como ubuntu .bashrc, lo abrimos con nano, gedit o con el editor de su preferencia y lo agregamos de forma permanente así:

luego solo nos resta reiniciarla, pueden usar source .bashrc o reset o simplelemte bash y ya está

para el caso de Ubuntu para Linux, el alias temporal se crea escribiendo la palabra “alias”, luego el nombre que deseamos, seguido del signo “=” y después el comando, por ejemplo:
alias rapido=“cd /opt/lampp/htdocs”

En Linux ya editando mi ~/. zshrc agregamos alias avenv=source venv/bin/activate en la ultima linea salimos “esc” y guardamos :wq

Salu2!

En el caso de macOS se tiene que hacer lo siguiente para crear el entorno virtual. Nos paramos dentro de nuestra carpeta y hacemos lo siguiente:

1. Iniciamos repositorio en git: git init
2. creamos el entorno: python3 -m venv venv
3. activamos el entorno: . venv/bin/active

Para configurar el alias:

• ejecutar el comando alias avenv=". venv/bin/activate"

Para crear un alias en un sistema Linux hay que agregar la siguiente linea en el archivo de configuración ~/.bachrc

alias avenv=./venv/bin/activate

Lo anterior solo funcionara una vez que se ha iniciado una terminal, por lo que si aun no funciona el comando luego de agregar la linea solo hay que recargar el archivo de configuración:

source ~/.bashrc o . ~/.bashrc

Crear un entorno virtual

• Dentro de la carpeta donde ubicamos nuestro proyecto ingresamos el siguiente comando

python3 -m venv venv 

• el ultimo comando siendo el nombre del entorno virtual (venv), le puedes poner el que sea con forme al nombre del proyecto

Activar el entorno virtual

• En la terminal

source venv/bin/activate 

Desactivar el entorno virtual

• Comando

deactivate

Para crear alias permanentes en sistemas basados en *Nix, por lo menos en aquellos con el intérprete de consola (shell) BASH, hay una forma más eficiente y ordenada de hacerlo que poner los alias directamente en el archivo “.bashrc”:

1. Crear dentro del directorio hogar ("~/aquí", o “/home/user/aquí”) el archivo “.bash_aliases”. Es en ESTE archivo donde ponemos todos los alias que queramos, incluyendo el destinado a cargar los entornos virtuales. Para eso, hay que asegurarse de que el intérprete BASH cargue ese archivo al iniciar la terminal, como se ve en el siguiente punto.

2. Con el editor de texto que prefieran (Vim, Nano, Emacs, etc.), agregar las siguientes líneas de código al archivo “.bashrc”:

if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

Muchas distribuciones de Linux ya vienen con estas líneas incorporadas a su archivo “.bashrc”, así que fíjense primero si no están ya ahí.

1. Usar el comando:

source ~.bashrc

para cargar los cambios hechos al archivo. Esto ocurrirá automáticamente la próxima vez que abran la terminal, así que considérenlo un paso opcional, ya que pueden simplemente reiniciar la terminal y tendrá el mismo efecto.

Y listo! Así su archivo “.bashrc” se mantiene relativamente limpiecito. Cada vez que quieran crear alias persistentes nuevos, agrégenlos al archivo “.bash_aliases”, y ejecuten el comando “source .bash_aliases” si quiere que tomen efecto instantáneamente, sin necesidad de reinciar la terminal, aunque tomen en cuenta que hay ocasiones donde sí es necesario reiniciar la terminal después de editar ese archivo, sobre todo cuando se hacen ediciones a alias ya existentes.
Si quieren revisar qué alias hay ya configurados en su sistema, ejecuten el comando

alias

sin argumentos extra. Esto creará una lista de todos los alias que el sistema reconozca en ese momento dado.

si estan en ubuntu y el bin/activate no les funciona, les recomiendo lo siguiente:

sudo apt-get install python3-venv 

y luego ya se pueden dirigir al venv y activarlo

No recordaba el tema de los alias y justamente ya le tengo uso porque con una alumna normalmente los archivos que creamos van directamente en su carpeta y siempre hacía un cd hasta llegar a la carpeta de ella o bien un cd directamente a la ruta de ella.

#Creación de ambiente Virtual:
python3 -m venv nombre_venv

#Windows:
#.\venv\Scripts\activate

#Unix o MacOS:
source venv/bin/activate

#Desactivar el ambiente virtual:
deactivate

#Crear un alias en linux/mac:
#alias nombre-alias="comando"
alias avenv="source venv/bin/activate"
#Para hacerlo de manera permannente agregar la linea
#al archivo ~/.bashrc o ~/.zshrc según sea el caso.

En Mac:

Para crear un comando alias, solo basta con abrir la terminal y escribir la palabra clave alias, seguido del nombre de nuestro comando, seguido del símbolo igual (=), seguido de la sentencia que queremos ejecutar entre comillas dobles.

Ejemplo:

alias avenv=“source venv/bin/activate”

Para crear el alias en Mac realice los siguientes pasos desde la terminal

• sudo nano ~/.bashrc

• guarde los cambios con ctrl + o
• Cerre el archivo con ctrl + x, quedando de nuevo en la terminal
• source ~/.bashrc

• -m Es un indicativo que no dice que vamos a modificar el funcionamiento original por otra cosa. En python -m significa módulo. Es decir vamos a llamar a un módulo interno del lenguaje.
• venv: Significa Virtual Environment (Entorno Virtual)
• Esto va a crear una carpeta en la que va a vivir un python especifico para ese proyecto y donde vamos a poder actualizar e instalar los módulos que deseamos sin tocar el Python que vive en nuestra computadora.
• Ojo con que el Entorno Virtual este creado no es suficiente. Nosotros debemos entrar al Entorno Virtual y tenemos que activar a ese Python Interno para que nuestra consola no trabaje con el Python que esta dentro de nuestra computadora.
• Activar el Entorno Virtual: Para activar el entorno Virtual debemos tocar la carpeta de Scripts . Porque en Scripts es el comando para activar el Entorno Virtual.
• Linux o Mac: Si estas en Linux o Mac el comando que debes usar es source venv/bin/activate porque en Linux y mac no vas a encontrar la carpeta de Scripts.
• Windows: Para activar en Windows .\venv\Scripts\activate
• Para desactivar el Entorno Virtual solo colocamos el comando deactivate
• Como es un fastidio escribir .\venv\Scripts\activate cada vez que vamos a activar el Entorno Virtual podemos crear un alias para poder hacer este paso de forma mas rapida.
• Los alias no se borran de Windows al momento de cerrar la consola. En cambio los Entornos que tiene sistemas operativos de Linux o Mac al momento de cerrar la consola si se pierde el alias.

RETO: Investigar una forma en la cual podemos poner un alias en Linux o Mac para para que al momento de salir de la consola no se borre el alias.

RETO: Investigar una forma en la cual podemos poner un alias en Linux o Mac para para que al momento de salir de la consola no se borre el alias.

Para crear alias en Linux o Mac
alias arbolito=“source venv/bin/activate”

Arbolito seria el alias que almacena la linea de comandos para activar el entorno Virtual. Ya al cerrar no se va a borrar el alias. Esto solo funciona para Linux o Mac.

si no les funciona con alias prueben con doskey

Es muy importante que recordemos que en Windows la ruta para activar el entorno virtual es .\venv\Scripts\activate

Si quieren saber las opciones que tiene el módulo venv, pueden ejecutar el siguiente comando: python3 -m venv -h

compañeros, no se porque no sirve el comando “alias” en mi CMD, lo que si me permitio crearlos fue “doskey” aca encontre donde lo explican y la documentación FYI

doskey alias_name="command"

git init

1. (-m es la bandera de module) (venv es virtual environment)

python3 -m venv venv

source venv/bin/activate

Para salir del entorno virtual

deactivate

Para crear el alias en linux o una consola como lo es git bash se hace lo siguiente:

alias (nombre)= “(comando)”

El ejemplo del alis “avenv” es el siguiete:

alias avenv=“source venv/scripts/activate”

para guardar los alias persistentes es necesario modificar las Variables de entorno del sistema

Crear un alias para activar el entorno(opcion para git BASH):
alias avenv=“source venv/Scripts/activate”

• Hay validar que en el archivo “~./bashrc” se encuentre la siguiente descripción.

# Alias definitions.
# You may want to put all your additions into a separate file like
# /.bash_aliases, instead of adding them here directly.
# See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f /.bash_aliases ]; then
    . /.bash_aliases
fi

            Si no se encuentra, abria que escribir lo.

• Se creal el archivo “.bash_aliases” en la ruta “~”.
• Dentro dl archivo se van agenerando los alias. La sintaxis es la siguiente;

alias "nombre del alias"="'Comandos, flag´s y patch que se van a utilizar, todo va dentro de comillas simples.'"

alias vpy='python3 -m venv venv'

• Al finalizar de editar cada archivo hay que reiniciar lo por lo que se corre lo siguiente, segun corresponda.

source ~/.bashrc

source ~/.bash_aliases

CREAR UN ENTORNO VIRTUAL

ENTORNO VIRTUAL: En un Python aislado para cada proyecto con sus propios módulos.
Te voy a enseñas como crearlo.
Entrando a tu directorio (Puedes entrar al de tu preferencia) en este caso utilizaremos el Cmder ,vamos a seguir los siguientes pasos y al final de cada paso presionamos la tecla ENTER:
Paso 1: vamos a crear una carpeta con el nombre del proyecto con el comando mkdir nombre_de_ proyecto así .

mkdir Proyecto_ejemplo

Paso 2: Una vez creada la carpeta (Proyecto_ejemplo) con el comando cd debes ingresar en ella, para desde allí pasar al Paso 3

cd proyecto_ejemplo

Paso 3: inicializamos un repositorio Git dentro de la carpeta (Proyecto_ejemplo) con el comando git init

git init

Y aparecerá en tu directorio cerrado un paréntesis la palabra (master)

Paso 4: ahora vamos a crear el entorno virtual del proyecto en cual solo va funcionar en dicha carpeta (Proyecto_ejemplo) y en el cual van a vivir todos nuestro módulos, utilizando el siguiente comando py -m venv nombre_del_entorno_virtual (WINDOW) o python3 -m venv nombre_del_entorno_virtual (LINUS) (lo normal es que el entorno virtual se llame igual al comando “venv”).

PARA WINDOWS

py -m venv venv

PARA LINUS O MAC

python3 -m venv venv

py: es el comando para iniciar la consola interactiva de Python en Window o

python3: es el comando para iniciar la consola interactiva de Python en Linus

-m: es un indicativo que le dice al comando que vamos a modificar el funcionamiento original por otra cosa. Particularmente significa -m significa “modulo”. Sirve Para llamar un módulo interno de lenguaje ¿a que modulo vamos a llamar? Al modulo venv

Venv: significa Entorno Virtual (Virtual Environment)

Con este paso se va crear una carpeta en la que va vivir un Python especifico para este proyecto y en que nosotros vamos a poder instalar y actualizar los módulos a gusto, sin tocar el Python que vive globalmente en nuestra computadora.

Paso 5: Con el comando ls podemos ver lo que hay dentro de nuestro proyecto y verificar si esta creada la carpeta venv.

ls 
venv\

y luego con el mismo comando ls verificamos que dentro de la carpeta venv esta los arachivos include/, Lib/, pyvenv.cfg, Scripts/.

ls venv
include/    Lib/    pyvenv.cfg    Scripts/

Peso 6: Como veras, hay una carpeta de nombre Scripts la cual es la que vamos a tocar, porque en ella está el comando para activar el entorno virtual. (En Linus o Mac no te aparece la carpeta Scripts sino una llamada bin) ¿Cómo lo activamos? De la siguiente manera:

En Windows con el siguiente comando: _.\venv\Scripts\activate _

.\venv\Scripts\activate

En Linus o Mac con el siguiente comando: sourcer venv\bin\activate

sourcer venv\bin\activate

Una vez aplicado el comando (.\venv\Scripts\activate) veremos que además de (master) también veremos (venv) en la línea de comando. Esto significa que estamos utilizando el Entorno Virtual de nuestra carpeta que tiene de nombre venv. Y no estamos utilizado en Python global de nuestra PC si no el Python clonado que solo funciona de nuestro proyecto

C:\Users\JAMES\Documents\Python Intermedio\Proyecto_ejemplo(master)
(venv) λ

Para salir del Entorno Virtual (venv) se utiliza el comando: deactivate

(venv) λ deactivate

Veras que desaparece en (venv)

C:\Users\JAMES\Documents\Python Intermedio\Proyecto_ejemplo(master)
λ

NOTA: crearemos un alias al comando (.\venv\Scripts\activate) para hacer más fácil la activación del del Entorno Virtual (venv) así: alias nombre_del_alias=comando_a_nombrar. En esta caso nombraremos nuestra línea de comandos con el alias de “avenv”

alias avenv=.\venv\Scripts\activate

Cree una pequeña función que crea el entorno virtual y con le alias que crearte la activa. Solamente tienes que agregar el alias al zshrc o al bashrc.

# primero tienes que agregar el alias al zsh o bash
alias  activepy='$(pwd)/venv/bin/activate'

Luego copia la función al final del archivo

# create by: jakepy
venvpy () {
	echo -e "[*] Creando entorno virtual"
	python3 -m venv venv ~/$('pwd')
	sleep 1
	activepy
	clear
	echo -e "[*] Todo listo"
}

ahora aganle un source a tu zshrc o basrc
source .zshrc or source .bashrc

ahora con puedes llamar la función venvpy y te creara el entorno virtual y activara por ti.

Espero que les sirva

¡Facundo dean of Python de Platzi, por favooooooooooor! Es un genio este hombre, nació para enseñar.

Por si alguien tiene problemas en ejecutar el Script de activación en Windows, les dejo este video donde explica como habilitarlo. Lo seguí al pie de la letra y funcionó perfecto.

Aquí dejo el articulo que explica como crear los alias en Ubuntu , también funciono para fedora
https://ubunlog.com/alias-temporales-permanentes-comandos/

Para hacer el alias en la consola de Cmder pueden ejecutar el siguiente comando:
alias nombre_del_alias = .\venv\Scripts\activate
en el nombre del alias se puede colocar cualquier nombre en este curso se le coloco avenv.

Manejo de entornos virtuales

Hago la analogía de que crear un entorno virtual es construir la casita de nuestro proyecto XD

Etapas para crear un entorno virtual en macOS

Paso 1:

<Ejecutar la terminal> 

Paso 2:

<cd..> 

Paso 3;

<cd nombre de usuario> 

Paso 4:

<cd Desktop> 

Paso 5:

<cd mkdir "Escribir nombre de la carpeta"> 

Paso 6:

<cd nombre de la carpeta> 

Paso 7:

<git init> 

Paso 8:

<python3.10 -m venv venv> 

Paso 9:

<source venv/bin/activate> 

Paso 10:

<source venv/bin/activate> 

Paso 11:

<deactivate>