Python one-liners pentru a codifica ca un programator profesionist

Python este unul dintre cele mai populare limbaje de programare printre dezvoltatori. Motivul din spatele acestuia este sintaxa ușoară.

Python nu reușește să ne surprindă rezolvând probleme complexe într-o singură linie de cod. Există multe probleme complexe legate de programare pe care le putem rezolva folosind Python într-o singură linie de cod.

Aceste unice-line-uri sunt, de asemenea, utile pentru programarea competitivă. Aceste versiuni arată cât de bună înțelegeți limbajul de programare cu care lucrați.

Cu cât exersezi mai mult programarea, cu atât mai mult îți optimizezi codul și scrii logica în linii minime de cod.

În acest articol, am venit cu Python one-liners care sunt foarte utile de utilizat. Să începem!

1. Intrări multiple separate prin spațiu într-o listă

În timp ce rezolvăm problemele de codificare, adesea trebuie să luăm mai multe intrări întregi în codul nostru. Putem folosi funcția map() pentru a converti valoarea input() într-o valoare întreagă și apoi adăugați acele valori întregi în listă.

input_list = list(map(int, input().split()))
print(input_list)

2. Suma cifrelor unui număr

Pentru a găsi suma cifrelor unui număr, folosim operatori matematici precum % (modulo) și diviziunea /. Dar în Python, putem calcula suma într-o singură linie de cod.

Această linie cu o singură linie este utilă pentru a găsi suma cifrelor unui număr.

sum_of_digit = lambda x: sum(map(int, str(x)))
output = sum_of_digit(123)
print("Sum of the digits is: ", output)
Output:
Sum of the digits is: 6

3. Aplatizați o listă de liste

Putem aplatiza o listă de liste într-o singură linie de cod folosind lista de înțelegere.

input_list = [[1], [2,3,4], [5,6], [7,8], [9]]
output_list = [item for sublist in input_list for item in sublist]
print(output_list)
Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9]

4. Întoarceți un șir

Acest cod este util pentru a găsi reversul unui șir. Folosim string slicing pentru a găsi inversul într-o singură linie de cod.

input_string = "Namaste World!"
reversed_string = input_string[::-1]
print("Reversed string is: ", reversed_string)
Output:
Reversed string is: !dlroW etsamaN

5. Uniți două dicționare

Putem îmbina mai multe dicționare într-o singură linie de cod folosind operatorul (**). Trebuie doar să transmitem dicționarele împreună cu (**)operator unui {}, iar acesta va îmbina dicționarele pentru noi.

dictionary1 = {"name": "Joy", "age": 25}
dictionary2 = {"name": "Joy", "city": "New York"} 
merged_dict = {**dictionary1, **dictionary2} 
print("Merged dictionary:", merged_dict)

Output:
Merged dictionary: {'name': 'Joy', 'age': 25, 'city': 'New York'}

6. Schimbați cheile și valorile într-un dicționar

Acest cod cu o singură linie este util pentru a schimba perechile cheie-valoare ale unui dicționar.

dict = {'Name': 'Joy', 'Age': 25, 'Language':'Python'}
result = {v:k for k, v in dict.items()}
print(result)
Output:
{'Joy': 'Name', 25: 'Age', 'Python': 'Language'}

7. Deschideți și citiți un fișier

Putem deschide un fișier și citi conținutul acestuia și să-l atribuim unei variabile folosind această linie:

text = [line.strip() for line in open(filename)]

8. Imprimarea unui model

Pentru a imprima un model, folosim adesea bucle imbricate și scriem logica.

n = 5
for i in range(n):
    for j in range(i+1):
        print("* ", end="")
    print("\n")

Există o modalitate alternativă de a imprima modelul cu o singură linie de cod. Iată un exemplu de cod cu o singură linie:

n=5
print('\n'.join("* " * i for i in range(1,n+1)))

Output:
* 
* * 
* * * 
* * * * 
* * * * *

9. Transpunerea unei matrice

Putem transpune o matrice într-o singură linie de cod cu ajutorul funcției zip() și a listei de înțelegere. Iată cum putem face asta:

import numpy as np
mat = [[1,2,3], [4,5,6], [7,8,9]]
transpose_matrix = [list(item) for item in zip(*mat)]
print(np.maxtix(mat))
print(np.matrix(transposeMatrix)) 

Output:
mat: 
[[1 2 3]
 [4 5 6]
 [7 8 9]]
transpose_matrix:
[[1 4 7]
 [2 5 8]
 [3 6 9]]

10. Seria Fibonacci

Seria Fibonacci este o serie de numere în care fiecare număr este suma a două numere precedente. Folosim liste de înțelegere și o buclă for pentru a crea o serie Fibonacci într-o singură linie de cod.

n=10
fib = [0,1]
[fib.append(fib[-2]+fib[-1]) for _ in range(n)]
print(fib)
Output:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

11. Pătrat al tuturor numerelor dintr-o listă

Putem găsi pătratul tuturor numerelor prezente în listă folosind listele de înțelegere.

numbers = [1,2,3,4,5,6,7]
output = [num**2 for num in numbers]
print(output)
Output:
[1, 4, 9, 16, 25, 36, 49]

Concluzie

Asta e tot din acest articol. În acest articol, am trecut prin câteva versiuni Python. Aceste linii unice sunt foarte utile pentru programarea competitivă și viața de zi cu zi de codare. Așadar, exersați mai mult cu aceste liner-uri pentru a le folosi la îndemână.

Multumesc pentru lectura!

Vă puteți abona la newsletter-ul meu gratuit aici: Buletinul informativ al Pralabh.