Rozumienie listy w języku Python składa się z nawiasów zawierających wyrażenie, które jest wykonywane dla każdego elementu wraz z pętlą for w celu iteracji po każdym elemencie listy w języku Python.
Przykład:
Pyton
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Wyjście
[24, 26, 28]>
Składnia rozumienia list w Pythonie
Składnia: Nowa lista = [ wyrażenie (element) Do element W stara lista Jeśli stan ]
Parametr:
wyrażenie : reprezentuje operację, którą chcesz wykonać na każdym elemencie iterowalnym. element : Termin zmienna odnosi się do każdej wartości pobranej z iterowalnej. iterable : określ sekwencję elementów, po których chcesz iterować (np. lista, krotka lub ciąg znaków). warunek : (Opcjonalnie) Filtr pomaga zdecydować, czy element powinien zostać dodany do nowej listy.
Powrót: Wartością zwracaną przez zrozumienie listowe jest nowa lista zawierająca zmodyfikowane elementy spełniające podane kryteria.
Rozumienie list w Pythonie zapewnia znacznie krótszą składnię do tworzenia nowej listy na podstawie wartości istniejącej listy.
Rozumienie list w przykładzie Pythona
Oto przykład użycia rozumienia list do znalezienia kwadratu liczby w Pythonie.
Pyton
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Wyjście
[1, 4, 9, 16, 25]>
Iteracja ze zrozumieniem listy
W tym przykładzie przypisujemy do listy liczby 1, 2 i 3, a następnie drukujemy listę przy użyciu funkcji List Comprehension.
Pyton
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Wyjście
[1, 2, 3]>
Lista parzysta przy użyciu rozumienia listy
W tym przykładzie drukujemy liczby parzyste od 0 do 10 przy użyciu funkcji List Comprehension.
Pyton
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Wyjście
[0, 2, 4, 6, 8, 10]>
Macierz wykorzystująca rozumienie list
W tym przykładzie przypisujemy liczby całkowite od 0 do 2 do 3 wierszy macierzy i drukujemy je przy użyciu funkcji List Comprehension.
Pyton
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Wyjście
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Rozumienie list a pętla For
Istnieją różne sposoby iteracji po liście. Jednak najczęstszym podejściem jest użycie Do pętla . Spójrzmy na poniższy przykład:
Pyton
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Wyjście
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Powyżej znajduje się implementacja tradycyjnego podejścia do iteracji po liście, łańcuchu znaków, krotce itp. Teraz zrozumienie list w Pythonie wykonuje to samo zadanie, a także upraszcza program.
List Comprehensions tłumaczy tradycyjne podejście iteracyjne przy użyciu dla pętli w prostą formułę, dzięki czemu są łatwe w użyciu. Poniżej znajduje się podejście do iteracji po liście, łańcuchu znaków, krotce itp. przy użyciu rozumienia list w Pythonie.
Pyton
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Wyjście
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Analiza czasu w wyrażeniach listowych i pętli
Wyrażenia listowe w Pythonie są wydajniejsze zarówno pod względem obliczeniowym, jak i pod względem przestrzeni i czasu kodowania niż pętla for. Zazwyczaj są one zapisywane w jednym wierszu kodu. Poniższy program przedstawia różnicę pomiędzy pętlami i rozumieniem list w oparciu o wydajność.
Pyton
Wiek Salmana Khana Khana
# Import required module> import> time> > > # define function to implement for loop> def> for_loop(n):> >result>=> []> >for> i>in> range>(n):> >result.append(i>*>*>2>)> >return> result> > > # define function to implement list comprehension> def> list_comprehension(n):> >return> [i>*>*>2> for> i>in> range>(n)]> > > # Driver Code> > # Calculate time taken by for_loop()> begin>=> time.time()> for_loop(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for_loop:'>,>round>(end>->begin,>2>))> > # Calculate time takens by list_comprehension()> begin>=> time.time()> list_comprehension(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for list_comprehension:'>,>round>(end>->begin,>2>))> |
>
>
Wyjście
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Z powyższego programu widać, że interpretacje list są znacznie szybsze niż pętla for.
Zagnieżdżone wyrażenia listowe
Zagnieżdżone wyrażenia listowe są niczym innym jak zrozumieniem listy w ramach innego rozumienia listy, które jest całkiem podobne do zagnieżdżonych pętli for. Poniżej znajduje się program implementujący zagnieżdżoną pętlę:
Pyton
matrix>=> []> > for> i>in> range>(>3>):> > ># Append an empty sublist inside the list> >matrix.append([])> > >for> j>in> range>(>5>):> >matrix[i].append(j)> > print>(matrix)> |
>
>
Wyjście
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Teraz, używając zagnieżdżonych wyrażeń listowych, ten sam wynik można wygenerować w mniejszej liczbie wierszy kodu.
Pyton
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Wyjście
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Listy złożone i lambda
Wyrażenia lambda to nic innego jak skrócone reprezentacje funkcji Pythona. Używanie wyrażeń listowych z lambdą tworzy wydajną kombinację. Spójrzmy na poniższe przykłady:
W tym przykładzie wstawiamy na listę liczby od 10 do 50 i drukujemy je.
Pyton
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Wyjście
czy klasa abstrakcyjna może mieć konstruktora?
[10, 20, 30, 40, 50]>
Tutaj użyliśmy pętli for do wydrukowania tabeli 10.
Pyton
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Wyjście
[10, 20, 30, 40, 50]>
W tym przypadku do wyświetlenia tabeli 10 użyliśmy wyłącznie rozumienia listy.
Pyton
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Wyjście
[10, 20, 30, 40, 50]>
Na koniec używamy lambda + rozumienia list, aby wyświetlić tabelę 10. Ta kombinacja jest bardzo przydatna, aby uzyskać wydajne rozwiązania w mniejszej liczbie wierszy kodu w przypadku złożonych problemów.
Warunki warunkowe w rozumieniu list
Do zrozumienia listy możemy także dodać instrukcje warunkowe. Listę możemy utworzyć za pomocą zakres(), operatorzy itp. i cal również stosują pewne warunki do listy za pomocą jeśli stwierdzenie .
Kluczowe punkty
- Zrozumienie listy jest skutecznym sposobem opisywania i konstruowania list w oparciu o aktualne listy.
- Ogólnie rzecz biorąc, zrozumienie list jest lekkie i prostsze niż standardowe funkcje i pętle do tworzenia list.
- Nie powinniśmy pisać długich kodów dla wyrażeń listowych, aby zapewnić przyjazny dla użytkownika kod.
- Każde zrozumienie listy można przepisać w pętli for, ale w kontekście interpretacji listy nie można przepisać każdej pętli for.
Poniżej znajduje się kilka przykładów ilustrujących użycie wyrażeń listowych zamiast tradycyjnego podejścia do iteracji po iterowalności:
Rozumienie list w Pythonie za pomocą If-else.
W przykładzie sprawdzamy, czy od 0 do 7, jeśli liczba jest parzysta, wstawiamy Liczba parzysta do listy jeszcze wstaw Liczba nieparzysta do listy.
Pyton
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Wyjście
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
Zagnieżdżony JEŻELI ze zrozumieniem listy
W tym przykładzie wstawiamy na listę liczby będące wielokrotnością liczby 10 do 100 i drukujemy je.
Pyton
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Wyjście
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Wyświetl kwadrat liczb od 1 do 10
W tym przykładzie wstawimy kwadrat od 1 do 10, aby wyświetlić listę i wydrukować listę.
Pyton
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Wyjście
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Wyświetl transpozycję macierzy 2D
W tym przykładzie dokonujemy transpozycji macierzy przy użyciu rozumienia list.
Pyton
# Assign matrix> twoDMatrix>=> [[>10>,>20>,>30>],> >[>40>,>50>,>60>],> >[>70>,>80>,>90>]]> > # Generate transpose> trans>=> [[i[j]>for> i>in> twoDMatrix]>for> j>in> range>(>len>(twoDMatrix[>0>]))]> > print>(trans)> |
>
>
Wyjście
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Przełącz wielkość liter każdego znaku w ciągu
W tym przykładzie przełączamy wielkość liter każdego znaku w danym ciągu za pomocą operatora XOR z liczbą 32 i zapisujemy wynik na liście.
Pyton
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Wyjście
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Odwróć każdy ciąg w krotce
W tym przykładzie odwracamy ciągi znaków w pętli for, wstawiamy je do listy i drukujemy listę.
Pyton
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Wyjście
['skeeG', 'rof', 'skeeG']>
Tworzenie listy krotek z dwóch oddzielnych list
W tym przykładzie utworzyliśmy dwie listy imiona i wiek. Używamy zamek błyskawiczny() w rozumieniu listy i wstawiamy imię i wiek jako krotkę do listy. Na koniec drukujemy listę krotek.
algorytm Bellforda
Pyton
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Wyjście:
[('G', 25), ('G', 30), ('g', 35)]> Wyświetla sumę cyfr wszystkich nieparzystych elementów listy.
W tym przykładzie stworzyliśmy listę i znajdujemy sumę cyfr każdego nieparzystego elementu na liście.
Pyton
# Explicit function> def> digitSum(n):> >dsum>=> 0> >for> ele>in> str>(n):> >dsum>+>=> int>(ele)> >return> dsum> > > # Initializing list> List> => [>367>,>111>,>562>,>945>,>6726>,>873>]> > # Using the function on odd elements of the list> newList>=> [digitSum(i)>for> i>in> List> if> i &>1>]> > # Displaying new list> print>(newList)> |
>
>
Wyjście
[16, 3, 18, 18]>
Zalety rozumienia list
- Bardziej efektywne czasowo i przestrzennie niż pętle.
- Wymagaj mniejszej liczby linii kodu.
- Przekształca instrukcję iteracyjną w formułę.
Pytania do ćwiczeń ze zrozumieniem listy w języku Python
Poniżej znajdują się dwa pytania ćwiczeniowe dotyczące rozumienia list w Pythonie. Omówiliśmy podstawowy kod rozumienia list, służący do znajdowania sześcianu liczb, oraz kod umożliwiający znajdowanie długości słowa przy użyciu rozumienia list i funkcji len().
Pytanie 1. Pytanie ćwiczeniowe dotyczące sześcianu liczb ze zrozumieniem list
Pyton
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Wyjście
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Pytanie 2. Znajdowanie pytań ćwiczeniowych dotyczących długości słowa przy użyciu rozumienia list
Pyton
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Wyjście
[5, 6, 6, 6]>