Comprensión y división de listas de Python

La comprensión de listas es una forma elegante de definir y crear una lista en Python. Podemos crear listas como enunciados matemáticos y en una sola línea. La sintaxis de la comprensión de listas es más fácil de entender. 

Una lista de comprensión generalmente consta de estas partes: 

1. expresión de salida,
2. Secuencia de entrada,
3. Una variable que representa un miembro de la secuencia de entrada y
4. Una parte de predicado opcional.

For example :

lst  =  [x ** 2  for x in range (1, 11)   if  x % 2 == 1] 

here, x ** 2 is output expression, 
      range (1, 11)  is input sequence, 
      x is variable and   
      if x % 2 == 1 is predicate part.

Ejemplo 1: 

# Python program to demonstrate list comprehension in Python 
   
# below list contains square of all odd numbers from 
# range 1 to 10 
odd_square = [x ** 2 for x in range(1, 11) if x % 2 == 1] 
print (odd_square) 
   
# for understanding, above generation is same as, 
odd_square = [] 
for x in range(1, 11): 
    if x % 2 == 1: 
        odd_square.append(x**2) 
print (odd_square) 
   
# below list contains power of 2 from 1 to 8 
power_of_2 = [2 ** x for x in range(1, 9)] 
print (power_of_2) 
   
# below list contains prime and non-prime in range 1 to 50 
noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)] 
primes = [x for x in range(2, 50) if x not in noprimes] 
print (primes) 
   
# list for lowering the characters 
print ([x.lower() for x in ["A","B","C"]] )
   
# list which extracts number 
string = "my phone number is : 11122 !!"
   
print("\nExtracted digits") 
numbers = [x for x in string if x.isdigit()] 
print (numbers) 
   
# A list of list for multiplication table 
a = 5
table = [[a, b, a * b] for b in range(1, 11)] 
   
print("\nMultiplication Table") 
for i in table: 
    print (i)

Producción: 

[1, 9, 25, 49, 81]
[1, 9, 25, 49, 81]
[2, 4, 8, 16, 32, 64, 128, 256]
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
['a', 'b', 'c']

Extracted digits
['1', '1', '1', '2', '2']

Multiplication Table
[5, 1, 5]
[5, 2, 10]
[5, 3, 15]
[5, 4, 20]
[5, 5, 25]
[5, 6, 30]
[5, 7, 35]
[5, 8, 40]
[5, 9, 45]
[5, 10, 50]

Después de obtener la lista, podemos obtener una parte de ella usando el operador de corte de python que tiene la siguiente sintaxis: 

[start : stop : steps]  

which means that slicing will start from index start
 will go up to stop in step of steps. 
 Default value of start is 0, stop is last index of list
 and for step it is 1 

Entonces [: stop] dividirá la lista desde el inicio hasta el índice de parada y [start : ] dividirá la lista desde el índice de inicio hasta el final. El valor negativo de los pasos muestra un recorrido de derecha a izquierda en lugar de un recorrido de izquierda a derecha, por eso [: : -1] imprime la lista en orden inverso.

Ejemplo 2: 

# Let us first create a list to demonstrate slicing
# lst contains all number from 1 to 10
lst =list(range(1, 11))
print (lst)
    
#  below list has numbers from 2 to 5
lst1_5 = lst[1 : 5]
print (lst1_5)
    
#  below list has numbers from 6 to 8
lst5_8 = lst[5 : 8]
print (lst5_8)
    
#  below list has numbers from 2 to 10
lst1_ = lst[1 : ]
print (lst1_)
    
#  below list has numbers from 1 to 5
lst_5 = lst[: 5]
print (lst_5)
    
#  below list has numbers from 2 to 8 in step 2
lst1_8_2 = lst[1 : 8 : 2]
print (lst1_8_2)
    
#  below list has numbers from 10 to 1
lst_rev = lst[ : : -1]
print (lst_rev)
    
#  below list has numbers from 10 to 6 in step 2
lst_rev_9_5_2 = lst[9 : 4 : -2]
print (lst_rev_9_5_2)

Producción: 

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5]
[6, 7, 8]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5]
[2, 4, 6, 8]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[10, 8, 6]

Podemos usar la función de filtro para filtrar una lista en función de alguna condición proporcionada como una expresión lambda como primer argumento y la lista como segundo argumento, un ejemplo de lo cual se muestra a continuación:

Ejemplo 3:  

import functools
   
#  filtering odd numbers
lst = filter(lambda x : x % 2 == 1, range(1, 20))
print (list(lst))
    
#  filtering odd square which are divisible by 5
lst = filter(lambda x : x % 5 == 0, 
      [x ** 2 for x in range(1, 11) if x % 2 == 1])
print (list(lst))
    
#   filtering negative numbers
lst = filter((lambda x: x < 0), range(-5,5))
print (list(lst))
    
#  implementing max() function, using
print (functools.reduce(lambda a,b: a if (a > b) else b, [7, 12, 45, 100, 15]))

Producción: 

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
[25]
[-5, -4, -3, -2, -1]
100

Este artículo es una contribución de Utkarsh Trivedi. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.