Práctica 1.3: Git Básico

P3 - Proyecto local y Git básico¶

En P1 y P2 has creado programas Python. Ahora los guardarás en un repositorio local para poder consultar su evolución. Git registra estados del proyecto; no es una copia automática en la nube. La conexión con GitHub se trabajará en P4.

Antes de empezar: necesitas Python y un IDE preparados en P1, así como uno de los ejercicios de P2. Trabaja con datos de ejemplo: no incluyas contraseñas, tokens ni datos personales en el repositorio.

1. Objetivos¶

Crear un proyecto Python local e inicializar un repositorio Git.
Entender las áreas de trabajo, preparación (staging) y repositorio.
Crear commits, consultar el estado y revisar el historial.
Ignorar archivos generados por el IDE y documentar cambios.

2. Relación con RA1 y criterios de evaluación¶

La práctica se vincula al RA1, especialmente CE b (crear un proyecto) y CE c (utilizar el IDE). Git es una herramienta instrumental para organizar las evidencias de esos criterios; no se presenta como un CE nuevo.

3. Pasos a seguir¶

3.1. Instalar y configurar Git¶

Descarga Git desde git-scm.com. En Windows puedes usar Git Bash; en Linux y macOS, una terminal.

Configura una identidad neutra propia. No copies nombres ni correos de los ejemplos:

git config --global user.name "Tu Nombre"
git config --global user.email "tu-correo@example.com"
git config --global --list

Practica pwd/cd, ls/dir, mkdir y cat/type según tu sistema. Evita borrar carpetas mientras aprendes; basta con crear una carpeta de trabajo como Documentos/ProgPython.

En Git Bash también puedes consultar clear, touch y las flechas del historial. rmdir elimina un directorio vacío: no lo uses sobre el proyecto de la práctica. En Windows, dir y type son alternativas a ls y cat.

3.2. Las tres áreas de trabajo de Git¶

Durante la práctica trabajarás con tres zonas relacionadas:

Directorio de trabajo: contiene los archivos que estás editando.
Área de preparación (staging area o index): contiene los cambios seleccionados para el próximo commit.
Repositorio: conserva los commits y el historial del proyecto.

Áreas de trabajo de un repositorio Git Git separa los archivos editados, los cambios preparados y el historial confirmado.

3.3. Crear el proyecto y el primer commit¶

Abre ProgPython con VS Code, PyCharm u otro IDE. Crea holamundo.py:
```
# Primer programa de la unidad
print("Hola, mundo")
```
Ejecútalo desde el terminal. El comando puede ser python, python3 o py:
```
python holamundo.py
```
Inicializa Git, usa main como rama principal y observa el estado:
```
git init
git branch -M main
git status
```

Añade solo el archivo y confirma el primer estado:

git add holamundo.py
git commit -m "Primera versión de hola mundo"
git status

3.4. Añadir un ejercicio y usar `.gitignore`¶

Crea ejercicios1/prueba1.py desde el IDE:

edad = int(input("Introduce tu edad: "))
if edad >= 18:
    print("Puedes acceder a esta opción.")
else:
    print(f"Con {edad} años no puedes acceder a esta opción.")

Añade un .gitignore en la raíz para no registrar configuraciones locales:
```
.venv/
__pycache__/
*.pyc
.vscode/
.idea/
.DS_Store
```

Comprueba lo que se va a incluir y crea otro commit:

git status
git add .gitignore ejercicios1
git diff --cached
git commit -m "Añade el primer ejercicio y gitignore"

Para añadir de una vez todos los cambios revisados existen git add . y git add -A; úsalos solo después de revisar git status. Para quitar un archivo del staging sin borrar su contenido usa git restore --staged archivo (en Git antiguo, git reset archivo).

3.5. Consultar y corregir de forma segura¶

Consulta el historial corto:
```
git log --oneline --decorate
```
Modifica prueba1.py y observa el cambio con git diff. Si el cambio es correcto, usa git add ejercicios1/prueba1.py y otro commit.
Si el cambio aún no está confirmado y quieres descartarlo, detente y revisa primero git diff. Usa git restore archivo solo si estás seguro de que no necesitas ese trabajo. Para deshacer un commit ya publicado, prefiere crear un commit inverso con git revert <hash>.

Comandos destructivos

No uses `git reset --hard` ni `git checkout .` en esta práctica: pueden borrar cambios sin confirmar. Guarda una copia o crea un commit antes de experimentar con recuperación.

Para inspeccionar un commit sin mover ninguna rama puedes usar `git show
<hash>` o `git switch --detach <hash>` y volver después con `git switch main`.
`git reset --soft <hash>` conserva los cambios preparados, pero no es
necesario para esta práctica.

3.6. Otros comandos que pueden ayudarte¶

Estos comandos amplían el ciclo básico de Git. Antes de ejecutarlos, consulta git status y git diff; algunos cambian el área de preparación, las ramas o los archivos del proyecto.

Para añadir todos los archivos nuevos y modificados del directorio actual: git add ..
Para añadir todos los cambios del repositorio, incluidos los borrados: git add -A.
Para quitar un archivo del área de preparación sin borrar su contenido: git restore --staged archivo.
En versiones antiguas de Git, la operación equivalente es git reset archivo.
Para consultar una versión concreta sin mover una rama: git show <commit_hash>.
Para inspeccionar temporalmente el estado de un commit: git switch --detach <commit_hash>.
Para conservar los cambios preparados al mover HEAD: git reset --soft <commit_hash>.
Para renombrar la rama actual: git branch -m nuevo-nombre.
Para deshacer un commit ya publicado conservando el historial: git revert <commit_hash>.

Comandos que pueden borrar trabajo

`git reset --hard <commit_hash>` elimina los cambios no confirmados y mueve
la rama. `git checkout .` descarta los cambios del directorio de trabajo.
Son comandos válidos para situaciones controladas, pero no los ejecutes en
esta práctica sobre trabajo que quieras conservar. Antes crea una copia o
un commit y verifica exactamente qué vas a descartar.

4. Comprobaciones de finalización¶

git status indica que no quedan cambios sin decidir.
Existen al menos dos commits visibles con git log --oneline.
El programa se ejecuta desde el IDE y desde el terminal.
.gitignore evita registrar .venv, cachés y carpetas del IDE.

5. Ejercicios y entregables¶

Añade al proyecto un programa que hayas resuelto en P2 y crea un commit con un mensaje descriptivo, por ejemplo Añade ejercicio de conversión de temperatura.
Modifica una línea de ese programa, muestra el cambio con git diff y confírmalo con un nuevo commit.
Entrega la carpeta del proyecto —sin .venv/, cachés ni configuración del IDE—, la salida de git log --oneline --decorate y una captura en la que se vea el IDE y el programa ejecutado.

6. Solución orientativa¶

No hay una única solución: los nombres de archivos y los mensajes de commit pueden variar. Al terminar, una posible estructura y un posible historial son estos:

ProgPython/
├── .git/
├── .gitignore
├── ejercicios1/
│   └── prueba1.py
└── holamundo.py

$ git status
On branch main
nothing to commit, working tree clean

$ git log --oneline --decorate
abc1234 (HEAD -> main) Mejora la salida de prueba1
def5678 Añade el primer ejercicio y gitignore
ghi9012 Primera versión de hola mundo

Si tu resultado no coincide exactamente, comprueba que se cumplen las cuatro comprobaciones de la sección anterior. En particular, revisa que los archivos que quieres conservar estén confirmados y que los archivos ignorados no aparezcan como pendientes.