Овај одељак описује како да генеришете нову листу у Питхон-у уклањањем или издвајањем дупликата из листе (низа).
Овде су описани следећи детаљи.
- Уклоните дупле елементе и генеришете нове листе
- Не чувајте редослед оригиналног уноса:
set() - Чува редослед оригиналног уноса:
dict.fromkeys(),sorted() - Дводимензионални низ (листа листа)
- Не чувајте редослед оригиналног уноса:
- Извуците дупле елементе и генеришете нову листу
- Не чувајте редослед оригиналног уноса
- Чува редослед оригиналног уноса
- Дводимензионални низ (листа листа)
Исти концепт се може применити на тупле уместо на листе.
Погледајте следећи чланак за
- Ако желите да утврдите да ли листа или тупле имају дуплиране елементе
- Ако желите да издвојите елементе који су уобичајени или нису уобичајени међу више листа уместо једне листе
Имајте на уму да листе могу да чувају различите типове података и да се стриктно разликују од низова. Ако желите да рукујете низовима у процесима који захтевају величину меморије и меморијске адресе или нумеричку обраду великих података, користите низ (стандардна библиотека) или НумПи.
Уклоните дупле елементе и генеришете нове листе
Не чувајте редослед оригиналног уноса:set()
Ако нема потребе да се сачува редослед оригиналне листе, користите сет(), који генерише скуп типа скупа.
Тип скупа је тип података који нема дупле елементе. Када се листа или други тип података прослеђује сет(), дупликате вредности се занемарују и враћа се објекат типа сет у коме су само јединствене вредности елементи.
Ако желите да то буде тупле, користите тупле().
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(set(l))
# {1, 2, 3, 4, 5}
print(list(set(l)))
# [1, 2, 3, 4, 5]
Наравно, може се оставити и подешено. Погледајте следећи чланак за више информација о сету типа скупа.
Чува редослед оригиналног уноса:dict.fromkeys(),sorted()
Ако желите да сачувате редослед оригиналне листе, користите метод класе фромкеис() типа речника или уграђену функцију сортед().
дицт.фромкеис() креира нови објекат речника чији су кључеви листе, тупле итд. наведени у аргументима. Ако је други аргумент изостављен, вредност је Ништа.
Пошто кључеви речника немају дуплиране елементе, дупле вредности се занемарују као у сет(). Поред тога, објекат речника може бити прослеђен као аргумент листи() да би се добила листа чији су елементи кључеви речника.
print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}
print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]
Од Питхон-а 3.7 (ЦПитхон је 3.6) гарантовано је да дицт.фромкеис() чува редослед низа аргумената. Раније верзије користе уграђену функцију сортед() на следећи начин.
Одредите методу листе тупле индек() за кључ аргумента сортед, који враћа сортирану листу елемената.
индек() је метода која враћа индекс вредности (број елемента на листи), који се може навести као кључ сортед() за сортирање листе на основу редоследа оригиналне листе. Кључ аргумента је наведен као објекат који се може позвати (позив), тако да немојте писати ().
print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]
Дводимензионални низ (листа листа)
За дводимензионалне низове (листе листа), метод који користи сет() или дицт.фромкеис() доводи до ТипеЕррор.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'
# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'
То је зато што објекти који се не могу хеширати као што су листе не могу бити елементи скупа типа или кључеви типа дицт.
Дефинишите следеће функције. Редослед оригиналне листе је очуван и ради за једнодимензионалне листе и торке.
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]
print(get_unique_list(l))
# [3, 2, 1, 5, 4]
Користи се нотација за разумевање листе.
Овде користимо следеће
- Ако је Кс у „Кс и И“ лажно у процени кратког споја оператора и, тада се И не вреднује (не извршава се).
- Метод аппенд() враћа Ништа.
Ако елементи оригиналне листе сек не постоје у виђеном, онда и после се процењују.
сеен.аппенд(к) се извршава и елемент се додаје у сеен.
Пошто метода аппенд() враћа Ноне и Ноне је Фалсе, нот сеен.аппенд(к) процењује на Тачно.
Условни израз у запису за разумевање листе постаје Тачан и додаје се као елемент коначно генерисане листе.
Ако су елементи оригиналне листе сек присутни у сеен, онда је к нот ин сеен Фалсе, а условни израз за израз за разумевање листе је Фалсе.
Због тога се не додају као елементи коначно генерисане листе.
Други метод је постављање осе аргумента у НумПи-овој функцији нп.уникуе(), иако ће резултат бити сортиран.
Извуците дупле елементе и генеришете нову листу
Не чувајте редослед оригиналног уноса
Да бисте издвојили само дуплиране елементе из оригиналне листе, користите цоллецтионс.Цоунтер().
Враћа збирку. Бројач (подкласа речника) са елементима као кључевима и бројем елемената као вредностима.
import collections
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})
Пошто је то подкласа речника, итемс() се може користити за преузимање кључева и вредности. Довољно је издвојити кључеве чији је број два или више.
print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]
Чува редослед оригиналног уноса
Као што је приказано у горњем примеру, од Питхон-а 3.7, кључеви колекција.Цоунтер задржавају редослед оригиналне листе и тако даље.
У ранијим верзијама, сортирање помоћу сортед() је довољно, као и брисање дупликата елемената.
print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]
Ако желите да издвојите дупликате какве јесу, једноставно оставите елементе са оригиналне листе са бројем од два или више. Очуван је и поредак.
cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]
Дводимензионални низ (листа листа)
За дводимензионалне низове (листе листа) следеће функције су могуће када се не задржава редослед оригиналне листе, односно када се задржава. Такође ради за једнодимензионалне листе и торке.
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
def get_duplicate_list(seq):
seen = []
return [x for x in seq if not seen.append(x) and seen.count(x) == 2]
def get_duplicate_list_order(seq):
seen = []
return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]
print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]
print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]
print(get_duplicate_list(l))
# [3, 1, 2]
print(get_duplicate_list_order(l))
# [3, 2, 1]
Ако желите да издвојите са дупликатима, оставите елементе са оригиналне листе са бројем два или више.
print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]
Имајте на уму да је сложеност рачунања цоунт() О(н), горе приказана функција која више пута извршава цоунт() је веома неефикасна. Можда постоји паметнији начин.
Цоунтер је подкласа речника, тако да ако проследите листу или тупле чији су елементи листе или други објекти који се не могу хеширати у цоллецтионс.Цоунтер(), доћи ће до грешке и нећете моћи да је користите.
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'
