Давайте начнем с начала и исследователя немного глубже:
Итак, у вас есть два списка:
list_1=['01','98'] list_2=[['01','98']]
И мы должны скопируйте оба списка, начиная с первого списка:
Итак, сначала попробуем общий метод копирования:
copy=list_1
Теперь, если вы думаете, что копия скопировала список_1, вы можете Неправильно, давайте проверим:
The id() function shows us that both variables point to the same list object, i.e. they share this object.
print(id(copy)) print(id(list_1))
output:
4329485320 4329485320
Удивлен? Итак, давайте рассмотрим это:
Итак, поскольку мы знаем, что python ничего не хранит в переменной, переменные просто ссылаются на объект и объект хранят значение. Здесь object
list
, но мы создали две ссылки на тот же объект двумя разными именами переменных. Таким образом, обе переменные указывают на один и тот же объект:, поэтому, когда вы делаете
copy=list_1
, что на самом деле его делает:Здесь в изображении list_1 и copy находятся два имени переменной, но объект одинаковый для обеих переменных, который является
list
. Поэтому, если вы попытаетесь изменить скопированный список, он также изменит исходный список, потому что список там будет только один, вы внесете этот список из скопированного списка или из исходного списка:
copy[0]="modify" print(copy) print(list_1)
output:
['modify', '98'] ['modify', '98']
Так что он изменил Исходный список:
Что такое решение?
Решение:
Теперь перейдем ко второму питоническому методу копирования списка :
copy_1=list_1[:]
Теперь этот метод исправить то, с чем мы столкнулись в первом выпуске, давайте проверим его:
print(id(copy_1)) print(id(list_1)) 4338792136 4338791432
Итак, мы можем видеть, что оба наших списка имеют разные id и это означает, что обе переменные указывают на разные объекты, так что здесь происходит следующее:
N ow давайте попробуем изменить список и посмотрим, остаемся ли мы перед предыдущей проблемой:
copy_1[0]="modify" print(list_1) print(copy_1)
Выход:
['01', '98'] ['modify', '98']
Итак, вы можете видеть, что он не изменяет первоначальный список, он только изменил скопированный список, поэтому с нами все в порядке.
Итак, теперь я думаю, что мы закончили? подождите, мы должны скопировать второй вложенный список, так что давайте попробуем pythonic way:
copy_2=list_2[:]
Итак, list_2 должен ссылаться на другой объект, который является копией list_2, давайте проверим:
print(id((list_2)),id(copy_2))
получаем результат:
4330403592 4330403528
Теперь мы можем предположить, что оба списка указывают на другой объект, поэтому теперь давайте попробуем его модифицировать и посмотрим, что он дает то, что мы хотим:
Поэтому, когда мы пытаемся:
copy_2[0][1]="modify" print(list_2,copy_2)
, он дает нам вывод:
[['01', 'modify']] [['01', 'modify']]
Теперь, это немного запутывает, мы использовали питоновский путь, и все же мы сталкиваемся с той же проблемой .
давайте поймем это:
Итак, когда мы делаем:
copy_2=list_2[:]
, мы фактически копируем только внешний список, а не вложенный список, поэтому вложенный list - тот же объект для обоих списков, давайте проверим:
print(id(copy_2[0])) print(id(list_2[0]))
output:
4329485832 4329485832
Так что, фактически, когда мы делаем
copy_2=list_2[:]
, это происходит:Создает копию списка, но только внешнюю копию списка, а не вложенную копию списка, вложенный список одинаковый для обеих переменных, поэтому, если вы попытаетесь изменить modi fy вложенного списка, то он также изменит исходный список, потому что вложенный объект списка одинаковый для обоих вложенных списков.
Итак, каково решение?
Решение -
deep copy
from copy import deepcopy deep=deepcopy(list_2)
Итак, теперь давайте проверим:
print(id((list_2)),id(deep))
вывод:
4322146056 4322148040
оба идентификатора разные, теперь давайте проверим идентификатор вложенного списка:
print(id(deep[0])) print(id(list_2[0]))
output:
4322145992 4322145800
Как вы можете видеть, оба идентификатора различны, поэтому мы можем предположить, что оба вложенных списка теперь указывают на другой объект.
So когда вы делаете
deep=deepcopy(list_2)
, что на самом деле происходит:Таким образом, оба вложенных списка указывают на другой объект, и теперь они имеют отдельную копию вложенного списка.
Теперь попробуем изменить вложенный список и посмотрим, разрешила ли он предыдущую проблему или нет:
, так что если мы это сделаем:
deep[0][1]="modify" print(list_2,deep)
вывод:
[['01', '98']] [['01', 'modify']]
Итак, вы можете видеть, что он не изменил исходный вложенный список, он только изменил скопированный список.
Если вам понравился мой подробный ответ, сообщите мне об этом, если вы сомневаетесь в этом ответе, прокомментируйте:)
Вы не можете возвращать незафиксированные изменения вообще.
Ранее поставленные изменения (git add
) должны быть восстановлены из объектов индекса, поэтому, если вы это сделали, используйте git fsck --lost-found
для поиска связанных с ним объектов.
Если нет, ответ здесь будет: посмотрите на свою резервную копию. Возможно, ваш редактор / IDE хранит временные копии в / tmp или C: \ TEMP и тому подобное. [1]
git reset HEAD@{1}
Это восстановит предыдущую HEAD
[1 ] vim eg опционально сохраняет постоянную отмену, IDE-хранилище eclipse хранит локальную историю ; такие функции могут сэкономить ваш **
ответьте на это SO
$ git reflog show
93567ad HEAD@{0}: reset: moving to HEAD@{6}
203e84e HEAD@{1}: reset: moving to HEAD@{1}
9937a76 HEAD@{2}: reset: moving to HEAD@{2}
203e84e HEAD@{3}: checkout: moving from master to master
203e84e HEAD@{4}: reset: moving to HEAD~1
9937a76 HEAD@{5}: reset: moving to HEAD~1
d5bb59f HEAD@{6}: reset: moving to HEAD~1
9300f9d HEAD@{7}: commit: fix-bug
# said the commit to be recovered back is on 9300f9d (with commit message fix-bug)
$ git reset HEAD@{7}
У вас есть свой день назад! :)
git checkout HEAD@{19}
позволило мне проверить потерянные файлы в отдельном состоянии. Затем использовали git checkout -b new-branch-name
, чтобы добавить их обратно в репо в "прикрепленном" государство.
– NightOwl888
2 October 2016 в 19:29
Я случайно запустил git reset --hard
в моем репо сегодня, также имея нефиксированные изменения сегодня. Чтобы вернуть его, я побежал git fsck --lost-found
, который написал все unreferenced blobs в <path to repo>/.git/lost-found/
. Поскольку файлы были нефиксированы, я нашел их в каталоге other
в <path to repo>/.git/lost-found/
. Оттуда я могу увидеть незафиксированные файлы, скопировать кадры и переименовать их.
Примечание. Это работает, только если вы добавили файлы, которые хотите сохранить в индекс (с помощью git add .
). Если файлы не были в индексе, они теряются.
lost-found
. Но я мог бы сделать git show
, чтобы получить содержимое.
– Mitar
17 September 2013 в 05:28
#!/bin/bash cd PATH_TO_PROJECT/.git/lost-found/other FILES=* COUNTER = 0 for f in $FILES do echo "Processing $f file..." git show $f > "PATH_TO_RECOVERY_DIRECTORY/$COUNTER.m" let COUNTER=COUNTER+1 done
– rwolst
22 October 2014 в 15:08
Да, ВЫ МОЖЕТЕ ВОССТАНОВИТЬСЯ из жесткого сброса в git.
Используйте:
git reflog
, чтобы получить идентификатор вашей фиксации. Затем используйте:
git reset --hard <commit-retrieved-using-reflog>
Этот трюк спас мою жизнь пару раз.
Вы можете найти документацию reflog ЗДЕСЬ .
git reset --hard
с помощью другого git reset --hard
, но если вы не используете переключатель --hard
, вы останетесь с элементами в рабочей области, которые эффективно вернут работу, которую вы только что восстановили.
– Ryan H.
17 March 2017 в 18:07
git show 67db6072093a119fef0cfe946191e09d861360d5 > path-to-file
, но использование git reset --hard <commit-retrieved-using-reflog>
спасло бы мне скуку. По крайней мере, я знаю в следующий раз (надеюсь, никогда не будет в следующий раз).
– Nick Bolton
27 July 2018 в 13:37
Пока я работал над локальным проектом, я хотел переместить его в GitHub, а затем создал новый репозиторий. Хотя я пытался добавить все эти файлы в новый репозиторий с помощью .gitignore, я случайно добавил неверный файл, а затем попытался его очистить.
Я побежал git reset --hard origin/master
: P
Затем все мои локальные файлы удалены, потому что репо было пустым. Я думал, что все прошло.
Это спасло мою жизнь:
git reflog show
git reset HEAD@{1}
git push
Надеюсь, что это спасет другую жизнь.
Справочный ответ из этого SO,
После запуска git reflog show скажите, что вы хотите перейти на фиксацию 9300f9d
после запуска git reset 9300f9d
, вы можете do git status, а затем вам может потребоваться проверить ваши файлы для восстановления ваших изменений
git checkout - filepath / name
Это то, что я обычно делаю, если я потеряю некоторые изменения.
git reflog
git checkout <commit id> // now you are in where you want but you cannot push from detached branch to master
manually copy and paste changes from detached branch to master or working branch
git reset --hard HEAD // if needed
git add ... > git commit ... > git push ...
, чтобы вернуть указатель назад к вашим предыдущим записям, но сохраняя изменения, внесенные вами до последнего момента в вашей последней проверке фиксации git reset --soft dadada
Если вы, к счастью, открыли те же файлы в другом редакторе (например, Sublime Text), попробуйте ctrl-z. Это просто спасло меня.
Вы можете вернуть фиксацию после выполнения reset --hard HEAD
.
Использовать «git reflog
» для проверки истории HEAD
в ветке.
Вы увидите свою фиксацию и ее идентификатор здесь.
Сделайте
git reset {commit Id of the commit you want to bring back}
Если вы используете что-то вроде IntelliJ:
http://blog.jetbrains.com/idea/2008/01/using-local-history-to-restore-deleted-files/
Это только что заставило мою задницу стрелять!
Когда мы делаем git reset --hard, и все локальные неуправляемые изменения удаляются. Чтобы восстановить изменения - в IDE щелкните файл, сравните файл с локальной историей, в которой будут перечислены изменения в соответствии с датой, и мы сможем восстановить данные. Ваш день сохранен!
По определению, git reset --hard
выкинет незафиксированные изменения без возможности для их восстановления (ваша резервная система может помочь, но не Git).
На самом деле очень мало случаев, когда git reset --hard
- хорошая идея. В большинстве случаев есть более безопасная команда, чтобы сделать то же самое:
git stash
. Он сохранит резервную копию этих изменений, срок действия которых истечет через некоторое время, если вы запустите git gc
. Если вы на 99,9% уверены, что вам никогда не понадобится эти изменения, то git stash
все равно ваш друг для случая 0,1%. Если вы на 100% уверены, то git stash
все еще ваш друг, потому что у этих 100% есть ошибка измерения; -). HEAD
и кончик текущего ветвь в истории, тогда git reset --keep
- ваш друг. Он будет делать то же, что и git reset --hard
, но not отменит ваши локальные изменения. git stash && git reset --keep
является вашим другом. Научите свои пальцы не использовать git reset --hard
, он окупится один день.
Информация потеряна.
Поскольку вы не совершали, ваш .git никогда не хранил эту информацию. Таким образом, в основном git
не может восстановить его для вас.
Но, если вы только что сделали git diff
, вы можете восстановить с помощью вывода терминала следующие 3 простых шага.
git diff
. Сохраните файл o / p в файле с именем diff.patch patch -p1 < diff.patch
) Вы спасены! :)
Примечание. При копировании данных с терминала в файл будьте осторожны и четко видите, что данные являются непрерывными и не содержат избыточных данных (из-за нажатия стрелок вверх и вниз) , В противном случае вы можете испортить это.
Если вы работаете в Netbeans, посмотрите между вкладками файлов и областью редактирования файлов. Существует «Источник» и «История». В разделе «История» вы увидите изменения, сделанные с помощью контроля версий (git / other), а также изменения, сделанные локально. В этом случае локальные изменения могут спасти вас.
Я обнаружил, что любые незафиксированные файлы до того, как git reset --hard <commit>
удаляются из истории git. Тем не менее, мне посчастливилось сохранить открытый сеанс редактора кода в течение всего времени, когда я вытягивал свои волосы, что я обнаружил, что простой control + z
в каждом из затронутых файлов возвратил состояние файла обратно в версию прежде чем Гит так услужливо сбросил все, о чем я не спросил его конкретно. Hooray!!
Если вы пытаетесь использовать код ниже:
git reflog show
# head to recover to
git reset HEAD@{1}
и по какой-то причине получают:
error: неизвестный переключатель `e '
blockquote>, затем попробуйте обернуть
HEAD@{1}
в кавычкиgit reset 'HEAD@{1}'
Я только что сделал git reset --hard
и потерял все мои незафиксированные изменения. К счастью, я использую редактор (IntelliJ), и мне удалось восстановить изменения в Local History. Eclipse должен позволить вам сделать то же самое.
git reset HEAD@{1}
– jan groth 27 May 2014 в 23:36