Categorías
Python

Entrevista comunidad Python Con Ali Spittel

 

Tabla de Contenidos

  • ¿Cuál es Git? Versión ControlDistributed Control Versión
  • Control Versión
  • Versión de Control Distribuido
  • básico UsageCreating un nuevo RepoAdding un nuevo FileCommitting Cambios
  • Creación de una nueva Repo
  • Adición de un nuevo archivo
  • Cometer Los cambios
  • Aparte: El área de ensayo
  • .gitignore
  • Qué NO Añadir a una Git Repo
  • Aparte: ¿Qué es un SHA
  • Git Entrar
  • retroceder en el tiempo: Control de salida de una versión particular de su código
  • ramificación BasicsMergingRebasingCherry-Picking
  • la fusión
  • Rebase
  • cherry picking
  • de trabajo con control remoto ReposCloneFetchPullPush
  • Clon
  • Fetch
  • Tire
  • empuje
  • Poniendo todo junto: simple Git flujo de trabajo
  • de control de versiones
  • Distributed control Versión
  • Creación de una nueva Repo
  • Adición de un nuevo archivo
  • confirmar los cambios
  • La fusión
  • Rebase
  • cherry picking
  • Clon
  • Fetch
  • Tire
  • empuje

reloj ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Introducción a Git y Github para Python Desarrolladores

¿Alguna vez trabajó en un proyecto de Python que dejó de funcionar después de realizar un cambio aquí o una limpieza PEP-8 allí, y usted no estaba muy seguro de cómo recuperarlo? Los sistemas de control de versiones pueden ayudar a resolver ese problema y otras relacionadas. Git es uno de los más populares sistemas de control de versiones en la actualidad.

En este tutorial, te voy a caminar a través de lo Git es, cómo utilizarlo para sus proyectos personales, y cómo usarlo en conjunción con GitHub para trabajar con otras personas en proyectos de mayor envergadura. Vamos a ver cómo crear un acuerdo de recompra, cómo agregar dos archivos nuevos y modificados, y cómo navegar a través de la historia de su proyecto para que pueda “volver” a su proyecto cuando estaba trabajando.

Este artículo se supone que ya tiene Git instalado en su sistema. Si no lo hace, el excelente libro Pro Git tiene una sección sobre cómo hacerlo.

¿Qué es Git?

Git es un sistema de control de versiones distribuido (DVCS). La ruptura de permitir que eso un poco y ver lo que significa. sistema de control de versiones

Control Versión

Un (VCS) es un conjunto de herramientas que hacen un seguimiento de la historia de un conjunto de archivos. Esto significa que usted puede decirle a su VCS (Git, en nuestro caso) para guardar el estado de sus archivos en cualquier momento. A continuación, puede seguir editando los archivos y almacenar ese estado también. Almacenamiento del estado es similar a crear una copia de seguridad del directorio de trabajo. Al usar Git, nos referimos a este ahorro de Estado como hacer un commit .

Cuando realiza una confirmación en Git, se agrega un mensaje de registro que explica en un alto nivel de cambios que hizo en este compromiso. Git se puede mostrar la historia de todas las confirmaciones y sus mensajes de confirmación. Esto proporciona una historia útil de lo que el trabajo que han hecho y realmente puede ayudar a identificar cuando un error deslizado en el sistema.

Además de que muestra el registro de los cambios que ha realizado, Git también le permite comparar archivos entre diferentes confirmaciones. Como he mencionado anteriormente, Git también le permitirá devolver cualquier archivo (o todos los archivos) a una anterior de comprometerse con poco esfuerzo.

Distributed Control Versión

bien, así que es un sistema de control de versiones . ¿Cuál es la distribuye parte? Es probable que sea más fácil responder a esta pregunta, comenzando con un poco de historia. sistema de control de versión temprana s trabajó mediante el almacenamiento de todas esas confirmaciones localmente en el disco duro. Esta colección de confirmaciones se llama repositorio . Esto resolvió el “tengo que volver a donde estaba” problema pero no escala bien para un equipo que trabaja en la misma base de código.

como grupos más grandes comenzaron a trabajar (y las redes se hicieron más comunes), VCSs cambiaron para almacenar el repositorio en un servidor central que fue compartida por muchos desarrolladores. Si bien esto resuelve muchos problemas, sino que también crea otros nuevos, como el bloqueo de archivos.

Siguiendo el ejemplo de algunos otros productos, Git rompió con ese modelo. Git no tiene un servidor central que tiene la versión definitiva del repositorio. Todos los usuarios tienen una copia completa del repositorio. Esto significa que conseguir todos los desarrolladores de vuelta en la misma página a veces puede ser complicado, pero también significa que los desarrolladores pueden trabajar fuera de línea la mayor parte del tiempo, sólo se conecta a otros repositorios cuando tienen que compartir su trabajo.

Ese último párrafo puede parecer un poco confuso al principio, porque hay una gran cantidad de desarrolladores que utilizan GitHub como un repositorio central de la que todo el mundo debe tirar. Esto es cierto, pero Git no impone esto. Es sólo conveniente en algunas circunstancias para tener un lugar central para compartir el código. El repositorio completo todavía se almacena en todos los repositorios locales, incluso cuando se utiliza GitHub. Uso

básico

Ahora que ya hemos hablado de lo que está en Git, generalidad nos dejó a través de un ejemplo y verlo en acción. Vamos a empezar por trabajar con Git sólo en nuestra máquina local. Una vez que el cuelgue de que, añadiremos GitHub y explicamos cómo se puede interactuar con él.

Creación de un trabajo de Nueva Repo

Para con Git, primero tiene que decir que lo que eres. Puede configurar su nombre de usuario con el comando git config:

$ git config --global user.name "your name goes here"

Una vez que es ste arriba, necesitará un acuerdo de recompra a un trabajo en Creación de un acuerdo de recompra es simple.. Utilice el comando git init en un directorio:

$ mkdir example
$ cd example
$ git init
Initialized empty Git repository in /home/jimamp/example/.git/

Una vez que tenga un acuerdo de recompra, y pregunta al respecto Git. El comando Git va a utilizar con más frecuencia es git status. Trate de que ahora:

$ git status
On branch master

Initial commit

nothing to commit (create/copy files and use "git add" to track)

Esto demuestra que un par de bits de información: qué rama que estás, maestro (hablaremos de las ramas más adelante), y que tiene nada para cometer . Este último medio de piezas que no hay archivos en este directorio Git que no conoce. Eso es bueno, ya que acabamos de crear el directorio.

Adición de un nuevo archivo

Ahora crear un archivo que Git no sabe nada. Con su editor favorito, crear el archivo hello.py, que tiene sólo una declaración de impresión en ella.

# hello.py
print('hello Git!')

Si ejecuta git status de nuevo, verá un resultado diferente:

$ git status
On branch master

Initial commit

Untracked files:
(use "git add ..." to include in what will be committed)

hello.py

nothing added to commit but untracked files present (use "git add" to track)

Ahora Git ve el nuevo archivo y se dice que es sin seguimiento . Eso es sólo forma de decir que el archivo no es parte de la cesión temporal y no está bajo el control de versiones de Git. Podemos arreglar esto añadiendo el archivo en Git. Utilice el comando git add para que esto suceda:

$ git add hello.py
$ git status
On branch master

Initial commit

Changes to be committed:
(use "git rm --cached ..." to unstage)

new file: hello.py

Ahora Git sabe de hello.py y listas bajo cambia a estar comprometido . Añadiendo el archivo en Git mueve en la zona puesta en escena (véase más adelante) y los medios nos podemos comprometer a la cesión temporal.

confirmar los cambios

Cuando comprometerse cambios, le está diciendo Git para hacer una instantánea de este estado en el repositorio. Hacerlo ahora utilizando el git cometer comando. La opción -m le dice a Git utilizar el cometer mensaje que sigue. Si usted no usa -m, Git se abrirá un editor para crear el mensaje de consignación . En general, usted quiere que su cometer mensajes para reflejar lo que ha cambiado en el comprometerse :

$ git commit -m "creating hello.py"
[master (root-commit) 25b09b9] creating hello.py
1 file changed, 3 insertions(+)
create mode 100755 hello.py

$ git status
On branch master
nothing to commit, working directory clean

se puede ver que el commit comando devuelve un montón de información, la mayoría de los cuales no es tan útil, pero se dice usted que sólo el 1 archivo modificado (que tiene sentido ya que hemos añadido un archivo). También le indica la SHA del commit (25b09b9). Tendremos un aparte sobre SHA un poco más tarde.

Al ejecutar el comando git status vuelve a demostrar que tenemos un limpia directorio de trabajo, lo que significa que todos los cambios se han comprometido a Git.

En este punto, tenemos que dejar nuestro tutorial y tener una breve charla sobre el área de ensayo.

Aparte: El área de ensayo

diferencia de muchos sistemas de control de versiones, Git tiene un área de ensayo (a menudo referido como el índice ). El área de ensayo es como Git realiza un seguimiento de los cambios que desea estar en tu próxima confirmación. Cuando nos encontramos con git add anterior, dijimos que queríamos Git para mover el nuevo hello.py archivo en el área de ensayo . Este cambio se refleja en el estado de git. El archivo pasó de las páginas sin seguimiento a la ser la sección de la salida cometido.

Tenga en cuenta que el área de ensayo refleja el contenido exacto del archivo al ejecutar git add. Si modifica de nuevo, el archivo aparecerá tanto en el por etapas y poco realizaron porciones de la salida de estado.

En cualquier punto de trabajar con un archivo en Git (suponiendo que ya se ha comprometido una vez), no puede haber tres versiones del archivo que puede trabajar:

  • la versión en el disco duro que está editando
  • una distintas versiones de Git que ha almacenado en su área de ensayo
  • la versión más reciente registró en el repositorio

los tres de estos pueden ser diferentes versiones del archivo. Mover los cambios en el área de ensayo y luego cometer los trae todas estas versiones de nuevo en sincronía.

Cuando empecé con Git, me encontré con el área de preparación un poco confuso y un poco molesto. Parecía añadir pasos adicionales al proceso sin añadir ningún beneficio. Cuando se está aprendiendo Git, eso es realmente cierto. Después de un tiempo, habrá situaciones en las que se llega a realmente aprecio tener esa funcionalidad. Por desgracia, esas situaciones están más allá del alcance de este tutorial.

Si está interesado en información más detallada sobre el área de ensayo, lo recomiendo esta entrada del blog.

.gitignore

El comando de estado es muy práctico, y se encontrará usando con frecuencia. Pero a veces usted encontrará que hay un montón de archivos que aparecen en el sin seguimiento sección y que desea a Git que simplemente no ver. Ahí es donde el archivo viene en .gitignore. Pie de

Let través de un ejemplo. Crear un nuevo archivo de Python en el mismo directorio llamado myname.py.

# myname.py
def get_name():
return "Jim"

A continuación, modificar su hello.py incluir MiNombre y llamar a su función:

# hello.py
import myname

name = myname.get_name()
print("hello {}".format(name))

Al importar un módulo local, Python compilarlo a código de bytes para usted y dejar que los archivos de su sistema de archivos. En Python 2, se dejará un archivo llamado myname.pyc, pero vamos a suponer que se está ejecutando Python 3. En ese caso, se creará un directorio __pycache__ y almacenar un archivo de PYC allí. Eso es lo que se muestra a continuación:

$ ls
hello.py myname.py
$ ./hello.py
hello Jim!
$ ls
hello.py myname.py __pycache__

Ahora si ejecuta git status, verá que el directorio en el sin seguimiento sección. También tenga en cuenta que su nuevo archivo myname.py es sin seguimiento , mientras que los cambios realizados en hello.py están en una nueva sección llamada “Los cambios por etapas para no cometer”. Esto sólo significa que esos cambios todavía no se han añadido a la zona de estacionamiento. Vamos a tratar de usted mismo:

$ git status
On branch master
Changes not staged for commit:
(use "git add ..." to update what will be committed)
(use "git checkout -- ..." to discard changes in working directory)

modified: hello.py

Untracked files:
(use "git add ..." to include in what will be committed)

__pycache__/
myname.py

no changes added to commit (use "git add" and/or "git commit -a")

Antes de pasar al archivo gitignore, vamos a limpiar el desorden que hemos hecho un poco. En primer lugar vamos a añadir los archivos myname.py y hello.py, tal como lo hicimos anteriormente: de

$ git add myname.py hello.py
$ git status
On branch master
Changes to be committed:
(use "git reset HEAD ..." to unstage)

modified: hello.py
new file: myname.py

Untracked files:
(use "git add ..." to include in what will be committed)

__pycache__/

Let confirmar esos cambios y terminar nuestra la limpieza:

$ git commit -m "added myname module"
[master 946b99b] added myname module
2 files changed, 8 insertions(+), 1 deletion(-)
create mode 100644 myname.py

Ahora, cuando corremos el estado, todo lo que vemos es que __pycache__ directorio :

$ git status
On branch master
Untracked files:
(use "git add ..." to include in what will be committed)

__pycache__/

nothing added to commit but untracked files present (use "git add" to track)

para obtener todos los directorios __pycache__ (y su contenido) a ser ignorados, vamos a añadir un archivo .gitignore a nuestro repositorio. Esto es tan simple como suena. Editar el archivo (recordar el punto delante del nombre!) En su editor favorito.

# .gitignore
__pycache__

Ahora, cuando se corre git status, ya no vemos el directorio __pycache__. Nosotros, sin embargo, vemos la nueva .gitignore! Echar un vistazo:

$ git status
On branch master
Untracked files:
(use "git add ..." to include in what will be committed)

.gitignore

nothing added to commit but untracked files present (use "git add" to track)

Ese archivo es un archivo de texto normal y se puede agregar a la que Repo como cualquier otro archivo. Hacerlo ahora:

$ git add .gitignore
$ git commit -m "created .gitignore"
[master 1cada8f] created .gitignore
1 file changed, 1 insertion(+)
create mode 100644 .gitignore

Otra entrada común en el archivo .gitignore es el directorio se almacenan los entornos virtuales en Usted puede aprender más sobre virtualenvs aquí, pero el directorio virtualenv se suele llamar env o Venv.. Puede añadir estos a su archivo .gitignore. Si los archivos o directorios están presentes, serán ignoradas. Si no es así, entonces no pasará nada.

También es posible tener un archivo mundial .gitignore almacena en su directorio personal. Esto es muy útil si su editor le gusta dejar archivos temporales o de copia de seguridad en el directorio local.

Aquí está un ejemplo de un simple archivo de Python .gitignore:

# .gitignore
__pycache__
venv
env
.pytest_cache
.coverage

Para un ejemplo más completo, mira aquí o, si se quiere construir su propia, git ayuda gitignore ofrece todos los detalles necesarios.

Qué NO Añadir a una Git Repo

Cuando empiece a trabajar con cualquier herramienta de control de versiones, especialmente Git, que podría estar tentado a poner todo lo en el repositorio. Esto es generalmente un error. Existen limitaciones en Git, así como los problemas de seguridad que la fuerza para limitar los tipos de información que se suman a la cesión temporal. inicio de

Vamos con la regla básica sobre todos sistemas de control de versiones.

Sólo puso fuente archivos en el control de versiones, no genera archivos.

En este contexto, un archivo fuente es cualquier archivo se crea, por lo general mediante la tipificación en un editor. Un genera archivo es algo que el equipo crea, por lo general mediante el procesamiento de un archivo fuente . Por ejemplo, hello.py es un archivo fuente , mientras hello.pyc habría una genera archivo .

Hay dos razones para no incluir archivos generados en el repositorio. La primera es que hacerlo es una pérdida de tiempo y espacio. Los archivos generados pueden ser recreados en cualquier momento y pueden necesitar ser creado en una forma diferente. Si alguien está usando Jython o IronPython mientras se está usando el intérprete Cython, los archivos .pyc podrían ser muy diferentes. Cometer un sabor particular de archivos puede causar conflictos

La segunda razón para no almacenar archivos generados es que estos archivos son a menudo más grandes que los archivos originales. Poniéndolos en los medios de reporto que todo el mundo necesita ahora para descargar y almacenar los archivos generados, incluso si no los está utilizando.

este segundo punto nos lleva a otra regla general sobre repositorios Git: Confirmar archivos binarios con precaución y evitar cometer fuertemente archivos de gran tamaño. Esta regla tiene mucho que ver con el funcionamiento de Git.

Git no almacena una copia completa de cada versión de cada archivo de comprometerse. Más bien, se utiliza un algoritmo complicado basado en las diferencias entre las versiones posteriores de un archivo a reducir en gran medida la cantidad de almacenamiento que necesita. Los archivos binarios (como archivos JPG o archivos MP3) en realidad no tienen buenas herramientas de diferenciación, por lo Git con frecuencia sólo tiene que almacenar todo el archivo cada vez que se ha comprometido.

Cuando se trabaja con Git, y especialmente cuando se trabaja con GitHub, nunca se puso información confidencial en un acuerdo de recompra, especialmente uno que podría compartir públicamente. Esto es tan importante que voy a decirlo una vez más:

Precaución: Nunca poner información confidencial en un repositorio público en GitHub. Contraseñas, claves de la API, y artículos similares no deben estar comprometidos con un acuerdo de recompra. Alguien se encontrarlos con el tiempo. Aparte

: ¿Qué es un SHA

Cuando Git almacena cosas (archivos, directorios, las confirmaciones, etc) en tu repositorio, los almacena de una manera complicada que implica una función hash . No necesitamos entrar en los detalles aquí, pero una función hash tarda una cosa y produce un identificador único para esa cosa que es mucho más corto (20 bytes, en nuestro caso). Este ID se denomina “SHA” en Git. No se garantiza que sea único, pero para la mayoría de las aplicaciones prácticas es.

Git utiliza su algoritmo de hash para indexar todo en tu repositorio. Cada archivo tiene un SHA que refleja el contenido de ese archivo. Cada directorio, a su vez, es ordenado. Si un archivo en ese directorio cambia, entonces el SHA del directorio cambia también.

cada confirmación contiene el SHA del directorio de nivel superior en tu repositorio, junto con alguna otra información. Así es como un número único de 20 bytes describe todo el estado de tu repositorio.

Usted puede notar que a veces Git utiliza el valor total de 20 caracteres se puede mostrar el SHA:

commit 25b09b9ccfe9110aed2d09444f1b50fa2b4c979c

A veces se muestra una versión más corta:

[master (root-commit) 25b09b9] creating hello.py

Por lo general, se le mostrará la cadena completa de caracteres, pero usted don’ t siempre tiene que usarlo. La regla para Git es que sólo tiene que dar suficientes caracteres para asegurar que el SHA es único en su repositorio. En general, siete caracteres es más que suficiente.

Cada vez que confirme los cambios de la cesión temporal, Git crea un nuevo SHA que describe ese estado. Vamos a ver cómo SHA son útiles en las siguientes secciones.

Git Entrar

Otro comando que se utiliza con mucha frecuencia Git es git log. Git log que muestra la historia de las confirmaciones de que ha realizado hasta este punto:

$ git log
commit 1cada8f59b43254f621d1984a9ffa0f4b1107a3b
Author: Jim Anderson
Date: Sat Mar 3 13:23:07 2018 -0700

created .gitignore

commit 946b99bfe1641102d39f95616ceaab5c3dc960f9
Author: Jim Anderson
Date: Sat Mar 3 13:22:27 2018 -0700

added myname module

commit 25b09b9ccfe9110aed2d09444f1b50fa2b4c979c
Author: Jim Anderson
Date: Sat Mar 3 13:10:12 2018 -0700

creating hello.py

como se puede ver en la lista anterior, todos los mensajes de commit se muestran para nuestro repositorio en orden. El inicio de cada confirmación está marcado con la palabra “comprometerse”, seguido por el SCS de que cometió. git log le da la historia de cada uno de los agentes de mantenimiento.

retroceder en el tiempo: Control de salida de una versión particular de su código

Debido a Git recuerda cada confirmación que usted ha hecho con su SHA, puede indicar a Git para ir a cualquiera de esas confirmaciones y ver el repositorio tal como existía entonces. El siguiente diagrama muestra lo que piensa Git está en nuestro repositorio:

no se preocupe por lo que amo y HEAD significan en el diagrama. Vamos a explicar los de sólo un poco.

cambiar el lugar donde nos encontramos en nuestra historia, vamos a utilizar el comando git checkout para contar Git, que SHA queremos mirar. try de dejar que eso:

$ git checkout 946b99bfe1641102d39f95616ceaab5c3dc960f9
Note: checking out '946b99bfe1641102d39f95616ceaab5c3dc960f9'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

git checkout -b

HEAD is now at 946b99b... added myname module

OK, así que hay una gran cantidad de información que aquí es confuso. Vamos a empezar por definir algunos de esos términos. Vamos a empezar con HEAD.

cabeza es el nombre de Git por cualquier SHA le toca estar mirando en cualquier momento. NO quiere decir que lo que está en su sistema de archivos o lo que es en el área de preparación. Significa lo que piensa Git haber efectuado su salida. Por lo tanto, si se ha editado un archivo, la versión de su sistema de archivos es diferente de la versión en cabeza (y sí, cabeza está en mayúsculas).

Luego, tenemos rama. La forma más fácil pensar en una rama es que se trata de una etiqueta en un SHA. Tiene algunas otras propiedades que son útiles, pero por ahora, pensar en una rama como una etiqueta SHA.

Nota: Aquellos de ustedes que han trabajado con otros sistemas de control de versiones (estoy mirando a ti, Subversion) tendrá una idea muy diferente de lo que es una rama. Git trata ramas de manera diferente, y eso es una buena cosa.

Cuando ponemos toda esta información, vemos que separa CABEZA simplemente significa que su cabeza está señalando a un SHA que no tiene una rama (o etiqueta) asociado a él. Git muy bien te dice cómo solucionar esa situación. Habrá ocasiones en las que se desea para solucionarlo, y habrá momentos en los que se puede trabajar en ese estado separado CABEZA bien. Atrás de

Vamos a nuestra demo. Si nos fijamos en el estado del sistema ahora, se puede ver que el archivo .gitignore ya no está presente. Nosotros volvimos al estado del sistema antes de hacer esos cambios. A continuación se muestra el diagrama de nuestro repositorio en este estado. Observe cómo los punteros HEAD y maestros están apuntando a diferentes SHA:

bien. Ahora bien, ¿cómo podemos volver a donde estábamos? Hay dos maneras, una de las cuales usted debe saber ya: git checkout 1cada8f. Esto le llevará de nuevo a la SHA estabas cuando empezó a moverse.

Nota: Una cosa rara, al menos en mi versión de Git, es que todavía le da una advertencia CABEZA individual, a pesar de que está de vuelta a la SHA asociado con una rama.

La otra forma de volver es más común: echa un vistazo a la rama que se encontraba. Git siempre comienza con una rama llamada maestro. Vamos a aprender cómo hacer otras ramas más tarde, pero por ahora vamos a seguir con maestría.

para volver a donde, donde, sólo tiene que hacer git checkout master. Esto lo regresará a la última SHA comprometido con la rama principal, que en nuestro caso tiene el mensaje de confirmación “.gitignore creado”. Para decirlo de otra manera, el maestro le dice a Git git checkout para hacer punto de la cabeza a la SHA marcado por la etiqueta, o rama, maestro.

Tenga en cuenta que hay varios métodos para especificar un determinado cometió. El SHA es probablemente el más fácil de entender. Los otros métodos utilizan diferentes símbolos y nombres para especificar cómo llegar a un determinado cometen desde un lugar conocido, como la cabeza. No voy a ir en esos detalles en este tutorial, pero si desea más detalles puede encontrar aquí.

ramificación Fundamentos

Hablemos un poco más sobre las ramas. Ramas proporcionan una forma para que usted mantenga corrientes separadas de desarrollo aparte. Si bien esto puede ser útil cuando se trabaja solo, es casi imprescindible cuando se trabaja en equipo.

Imagínese que estoy trabajando en un equipo pequeño y tienen una función para añadir al proyecto. Mientras yo estoy trabajando en ello, no quiero añadir mis cambios de dominar, ya que aún no funciona correctamente y el poder desordenar miembros de mi equipo.

yo sólo podía esperar para confirmar los cambios hasta que esté completamente terminado, pero eso no es muy seguro y no siempre es práctico. Así, en lugar de trabajar en maestro, voy a crear una nueva rama:

$ git checkout -b my_new_feature
Switched to a new branch 'my_new_feature'
$ git status
On branch my_new_feature
nothing to commit, working directory clean

Se utilizó la opción -b de la orden de pago para decirle a Git que queríamos para crear una nueva rama. Como se puede ver arriba, correr git status en nuestras sucursales nos muestra que el nombre de la sucursal tiene, de hecho, cambiado. Echemos un vistazo al registro:

$ git log
commit 1cada8f59b43254f621d1984a9ffa0f4b1107a3b
Author: Jim Anderson
Date: Thu Mar 8 20:57:42 2018 -0700

created .gitignore

commit 946b99bfe1641102d39f95616ceaab5c3dc960f9
Author: Jim Anderson
Date: Thu Mar 8 20:56:50 2018 -0700

added myname module

commit 25b09b9ccfe9110aed2d09444f1b50fa2b4c979c
Author: Jim Anderson
Date: Thu Mar 8 20:53:59 2018 -0700

creating hello.py

como espero que se esperaba, las miradas de registro exactamente lo mismo. Cuando se crea una nueva rama, la nueva sucursal se iniciará en el lugar que estabas en. En este caso, estábamos en la parte superior del maestro, 1cada8f59b43254f621d1984a9ffa0f4b1107a3b, así que es donde se inicie la nueva sucursal.

Ahora, el trabajo nos dejó en esa función. Realizar un cambio en el archivo hello.py y cometerlo. Te voy a mostrar los comandos para su revisión, pero voy a dejar que muestra la salida de los comandos para las cosas que ya hemos visto:

$ git add hello.py
$ git commit -m "added code for feature x"

Ahora bien, si git log, verá que nuestro nuevo commit está presente . En mi caso, tiene una 4a4f4492ded256aa7b29bf5176a17f9eda66efbb SHA, pero tu repositorio es muy probable que tenga un SHA diferentes: de nuevo el interruptor

$ git log
commit 4a4f4492ded256aa7b29bf5176a17f9eda66efbb
Author: Jim Anderson
Date: Thu Mar 8 21:03:09 2018 -0700

added code for feature x

commit 1cada8f59b43254f621d1984a9ffa0f4b1107a3b
... the rest of the output truncated ...

Ahora a la principal rama y la mirada en el registro:

git checkout master
git log

es el nuevo comprometerse “código añadido para la función x”hay?

Git tiene un sistema incorporado en forma de comparar el estado de dos ramas por lo que no tiene que trabajar tan duro. Es el comando show-rama. Esto es lo que parece:

$ git show-branch my_new_feature master
* [my_new_feature] added code for feature x
! [master] created .gitignore
--
* [my_new_feature] added code for feature x
*+ [master] created .gitignore

El gráfico que genera es un poco confuso al principio, así que vamos a pie, aunque en detalle. En primer lugar, se llama al comando utilizando el nombre de dos ramas. En nuestro caso que fue my_new_feature y señor.

La primera dos líneas de la salida son la clave para decodificar el resto del texto. El primer carácter que no sea espacio en cada línea es bien * o! seguido del nombre de la rama, y ​​luego el mensaje de registro para el más reciente informe de cambios en esa rama. El carácter * se utiliza para indicar que la rama está desprotegido actualmente mientras que el! se utiliza para todas las demás ramas. El personaje está en las confirmaciones columna coincidentes en la tabla a continuación.

La tercera línea es un separador.

a partir de la cuarta línea, hay confirmaciones que se encuentran en una rama, pero no el otro. En nuestro caso actual, esto es bastante fácil. Hay una cometen en my_new_feature que no está en maestro. Se puede ver que en la cuarta línea. Observe cómo esa línea comienza con un * en la primera columna. Esto es para indicar que se ramifican este cometer es en.

Finalmente, la última línea de la salida muestra la primera común cometen para las dos ramas.

Este ejemplo es bastante fácil. Para hacer un mejor ejemplo, he hecho más interesante añadiendo un poco más de commit my_new_feature y algunos de dominar. Eso hace que el aspecto de salida como:

$ git show-branch my_new_feature master
* [my_new_feature] commit 4
! [master] commit 3
--
* [my_new_feature] commit 4
* [my_new_feature^] commit 1
* [my_new_feature~2] added code for feature x
+ [master] commit 3
+ [master^] commit 2
*+ [my_new_feature~3] created .gitignore

ya se puede ver que hay diferentes comete en cada rama. Tenga en cuenta que el [~ 2 my_new_feature] texto es uno de los métodos de selección de cometer he mencionado antes. Si prefiere ver las SHA, puede hacer que se les muestran añadiendo la opción de nombre de -sha1 al comando:

$ git show-branch --sha1-name my_new_feature master
* [my_new_feature] commit 4
! [master] commit 3
--
* [6b6a607] commit 4
* [12795d2] commit 1
* [4a4f449] added code for feature x
+ [de7195a] commit 3
+ [580e206] commit 2
*+ [1cada8f] created .gitignore

Ahora usted tiene una rama con un montón de diferentes compromete en él. ¿Qué se hace cuando finalmente termine esa característica y está listo para conseguir que el resto de su equipo?

Hay tres formas principales para obtener confirmaciones de una rama a otra: la fusión, cambio de base, y la cereza-cosecha. Vamos a cubrir cada uno de estos a su vez en las siguientes secciones. La fusión de

La fusión es el más simple de los tres de entender y utilizar. Cuando se hace una fusión, Git va a crear un nuevo commit que combina las SHA superiores de dos ramas si es necesario. Si todas las confirmaciones en el otro brazo por delante son (basado en) la parte superior de la rama actual, se acaba de hacer una fusión rápida -foward y colocar esas nuevas confirmaciones en esta rama. espalda de

Let hasta el punto de que nuestro resultado de show-rama veía así:

$ git show-branch --sha1-name my_new_feature master
* [my_new_feature] added code for feature x
! [master] created .gitignore
--
* [4a4f449] added code for feature x
*+ [1cada8f] created .gitignore

Ahora, queremos conseguir que cometen 4a4f449 estar en maestro. Confirmar principal y ejecutar el comando git merge allí:

$ git checkout master
Switched to branch 'master'

$ git merge my_new_feature
Updating 1cada8f..4a4f449
Fast-forward
hello.py | 1 +
1 file changed, 1 insertion(+)

Ya que estábamos en la rama principal, hicimos una fusión de la rama my_new_feature a nosotros. Se puede ver que se trata de una combinación de avance rápido y que los archivos se han cambiado. Echemos un vistazo al registro de ahora:

commit 4a4f4492ded256aa7b29bf5176a17f9eda66efbb
Author: Jim Anderson
Date: Thu Mar 8 21:03:09 2018 -0700

added code for feature x

commit 1cada8f59b43254f621d1984a9ffa0f4b1107a3b
Author: Jim Anderson
Date: Thu Mar 8 20:57:42 2018 -0700

created .gitignore
[rest of log truncated]

Si hubiéramos hecho cambios en maestro antes de fusionamos, Git habría creado un nuevo commit que era la combinación de los cambios de las dos ramas.

Una de las cosas Git es bastante bueno es la comprensión de los ancestros comunes de las diferentes ramas y fusionar automáticamente los cambios juntos. Si la misma sección de código ha sido modificado en ambas ramas, Git no puede averiguar qué hacer. Cuando esto sucede, se detiene la parte del camino a través de combinación y le da instrucciones sobre cómo solucionar el problema. Esto se llama un conflicto de combinación .

Rebase

Rebase es similar a la fusión, pero se comporta de manera diferente. En una fusión, si ambas ramas tienen cambios, a continuación, una nueva combinación de cometer se crea . En cambio de base, Git tomará las confirmaciones de una rama y reproducirlas, uno a la vez, en la parte superior de la otra rama. No

voy a hacer una demostración detallada de rebase aquí porque la creación de una demo para mostrar que esto es un poco complicado en el texto y porque hay una excelente página web que cubre el tema bien y que voy referencia al final de esta sección.

cherry picking

cherry picking es otro método para mover confirmaciones de una rama a otra. A diferencia de la fusión y cambio de base, con la cereza-picking se especifica exactamente que compromete a que se refiere. La forma más sencilla de hacer esto es simplemente introduciendo una única SHA:

$ git cherry-pick 4a4f4492ded256aa7b29bf5176a17f9eda66efbb

Esto le dice a Git para llevar a los cambios que entraron en 4a4f449 y aplicarlos a la rama actual.

Esta característica puede ser muy útil cuando se desea un cambio específico, pero no toda la rama de que el cambio se hizo en.

Consejo rápido Acerca de ramificación: no puedo dejar este tema sin recomendar un excelente recurso para aprender sobre las ramas de Git. La ramificación aprender Git tiene un conjunto de ejercicios utilizando representaciones gráficas de confirmaciones y ramas de explicar claramente la diferencia entre la fusión, cambio de base, y la cereza-cosecha. Me altamente recomendamos pasar algún tiempo trabajando a través de estos ejercicios.

de trabajo con control remoto Repos

Todos los comandos que hemos discutido hasta este punto de trabajo sólo con tu repositorio local. Ellos no hacen ninguna comunicación a un servidor oa través de la red. Resulta que sólo hay cuatro principales comandos de Git que en realidad hablan con los repos remotas:

  • clon
  • Fetch
  • tirón
  • empuje

eso es todo. Todo lo demás se lleva a cabo en la máquina local. (OK, para ser completamente exacta, hay son otros comandos que hablar con mandos a distancia, pero no entran en la categoría básica.) La mirada de

Veamos cada uno de estos comandos en turno.

Clon

Git clon es el comando que utiliza cuando se tiene la dirección de un repositorio conocido y que desea hacer una copia local. Para este ejemplo, vamos a utilizar una pequeña reporto que tengo en mi cuenta de GitHub, github-patio de recreo. página

El GitHub para ese repo vive aquí. En esa página se encuentra un botón “Clone o Descargar” que le da la URI para utilizar con el comando git clone. Si copia que, a continuación, puede clonar el repositorio con:

git clone git@github.com:jima80525/github-playground.git

Ahora usted tiene un repositorio completo de ese proyecto en su máquina local. Esto incluye todas las confirmaciones y todas las ramas que se han hecho en él. ( Nota:. Esta cesión temporal fue utilizado por algunos amigos mientras estaban aprendiendo Git he copiado o bifurcada de otra persona.)

Si quieres jugar con los otros comandos remotos, se debe crear una nueva operación en GitHub y siga los mismos pasos. Usted es bienvenido a desembolsar el repositorio GitHub-parque infantil a su cuenta y usar eso. Bifurcan en GitHub se realiza haciendo clic en el botón de “tenedor” en la interfaz de usuario.

Fetch

para explicar el comando fetch claramente, tenemos que tomar un paso atrás y hablar de cómo Git maneja la relación entre tu repositorio local y un acuerdo de recompra a distancia. La siguiente parte es de fondo, y aunque no es algo que se va a utilizar en una base del día a día, que hará que la diferencia entre olas de alcance y de tracción más sentido.

When you clone a new repo, Git doesn’t just copy down a single version of the files in that project. It copies the entire repository and uses that to create a new repository on your local machine.

Git does not make local branches for you except for master. However, it does keep track of the branches that were on the server. To do that, Git creates a set of branches that all start with remotes/origin/.

Only rarely (almost never), will you check out these remotes/origin branches, but it’s handy to know that they are there. Remember that every branch that existed on the remote when you cloned the repo will have a branch in remotes/origin.

When you create a new branch and the name matches an existing branch on the server, Git will mark you local branch as a tracking branch that is associated with a remote branch. We’ll see how that is useful when we get to pull.

Now that you know about the remotes/origin branches, understanding git fetch will be pretty easy. All fetch does is update all of the remotes/origin branches. It will modify only the branches stored in remotes/origin and not any of your local branches.

Pull

Git pull is simply the combination of two other commands. First, it does a git fetch to update the remotes/origin branches. Then, if the branch you are on is tracking a remote branch, then it does a git merge of the corresponding remote/origin branch to your branch.

For example, say you were on the my_new_feature branch, and your coworker had just added some code to it on the server. If you do a git pull, Git will update ALL of the remotes/origin branches and then do a git merge remotes/origin/my_new_feature, which will get the new commit onto the branch you’re on!

There are, of course, some limitations here. Git won’t let you even try to do a git pull if you have modified files on your local system. That can create too much of a mess.

If you have commits on your local branch, and the remote also has new commits (ie “the branches have diverged”), then the git merge portion of the pull will create a merge commit, just as we discussed above.

Those of you who have been reading closely will see that you can also have Git do a rebase instead of a merge by doing git pull -r.

Push

As you have probably guessed, git push is just the opposite of git pull. Well, almost the opposite. Push sends the info about the branch you are pushing and asks the remote if it would like to update its version of that branch to match yours.

Generally, this amounts to you pushing your new changes up to the server. There are a lot of details and complexity here involving exactly what a fast-forward commit is.

There is a fantastic write-up here. The gist of it is that git push makes your new commits available on the remote server.

Putting It All Together: Simple Git Workflow

At this point, we’ve reviewed several basic Git commands and how you might use them. I’ll wrap up with a quick description of a possible workflow in Git. This workflow assumes you are working on your local repo and have a remote repo to which you will push changes. It can be GitHub, but it will work the same with other remote repos. It assumes you’ve already cloned the repo.

This is one of the more basic flows through the system. There are many, many ways to use Git, and you’ve just scratched the surface with this tutorial. If you use Vim or Sublime as your editor, you might want to checkout these tutorials, which will show you how to get plugins to integrate Git into your editor:

  • VIM and Python – A Match Made in Heaven
  • Setting Up Sublime Text 3 for Full Stack Python Development
  • Emacs – The Best Python Editor?

If you’d like to take a deeper dive into Git, I can recommend these books:

  • The free, online Pro Git is a very handy reference.
  • For those of you who like to read on paper, there’s a print version of Pro Git and I found O’Reilly’s Version Control with Git to be useful.

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Watch it together with the written tutorial to deepen your understanding: Introduction to Git and GitHub for Python Developers

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *