Was sind einige sehr praktische Python-Fähigkeiten?

1. Einzigartigkeit

Die folgende Methode kann prüfen, ob Duplikate in einer bestimmten Liste vorhanden sind, und das set()-Attribut verwenden, um diese aus der Liste zu entfernen.

x = [1,1,2,2,3,2,3,4,5,6]
y = [1,2,3,4,5]
len(x)== len(set(x)) # False
len(y)== len(set(y)) # True

2. Anagramme (Wörter mit den gleichen Buchstaben in unterschiedlicher Reihenfolge)

Mit dieser Methode kann überprüft werden, ob zwei Zeichenfolgen Anagramme sind.

from collections import Counter
>>> Counter('abadfsdafsdfjsdaf')
Counter({'a': 4, 'd': 4, 'f': 4, 's': 3, 'b': 1, 'j': 1})

def anagram(first, second):
    return Counter(first) == Counter(second)
anagram("abcd3", "3acdb") # True

3. Speicher

Mit diesem Codeausschnitt kann die Speichernutzung eines Objekts überprüft werden.

import sys 
variable = 30 
print(sys.getsizeof(variable)) # 28

4. Bytegröße

Diese Methode kann die Bytegröße des Strings ausgeben.

print(len(''.encode('utf-8')))# 0
print(len('hellow sdfsdaf'.encode('utf-8'))) # 14

5. Drucken Sie eine Zeichenfolge N-mal.

Dieses Codefragment kann eine Zeichenfolge mehrmals ohne Schleife drucken.

n = 2; 
s ="Programming"; 
print(s * n); # ProgrammingProgramming

6. Den ersten Buchstaben groß schreiben

Das folgende Codefragment verwendet nur title(), um den ersten Buchstaben jedes Wortes in der Zeichenfolge groß zu schreiben.

s = "programming is awesome"
print(s.title()) # Programming Is Awesome

7. Listensegmentierung

Diese Methode unterteilt die Liste in Listen einer bestimmten Größe.

>>> list = list(range(12))
>>> size=3
>>> [list[i:i+size] for i in range(0,len(list), size)]
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
>>>

8. Komprimierung

Der folgende Code verwendet filter(), um Fehlerwerte (False, None, 0 und „“) aus der Liste zu entfernen.

list(filter(bool, [0, 1, False, 2, '', 3, 'a', 's', 34]))

9. Counting

Der folgende Code kann zum Transponieren der 2D-Array-Anordnung verwendet werden.

array = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip(*array)
print(transposed)  # [('a', 'c', 'e'), ('b', 'd', 'f')]

10. Kettenvergleich

Der folgende Code kann mehrere Vergleiche für verschiedene Operatoren durchführen.

a = 3
print( 2 < a < 8) # True
print(1 == a < 2) # False

11. Komma getrennt

Dieser Codeausschnitt wandelt eine Liste von Zeichenfolgen in eine einzelne Zeichenfolge um und trennt dabei jedes Element in der Liste durch ein Komma.

hobbies = ["basketball", "football", "swimming"]
print("My hobbies are: " + ", ".join(hobbies)) # My hobbies are: basketball, football, swimming

12. Vokalzählung

Diese Methode kann die Vokale („a“, „e“, „i“, „o“, „u“ in der Zeichenfolge zählen ") Nummer.

import re
print(len(re.findall(r'[aeiou]', 'foobar', re.IGNORECASE)))   # 3
print(len(re.findall(r'[aeiou]', 'gym', re.IGNORECASE)))   # 0

13. Der erste Buchstabe ist Kleinbuchstabe

Diese Methode wandelt den ersten Buchstaben der angegebenen Zeichenfolge in den Kleinbuchstabenmodus um.

'FooBar'[:1].lower() + 'FooBar'[1:] # 'fooBar'
'FooBar'[:1].lower() + 'FooBar'[1:]   # 'fooBar'

14. Liste erweitern

Der folgende Code verwendet eine rekursive Methode, um eine potenziell tiefe Liste zu erweitern.

def spread(arg):
    ret = []
    for i in arg:
        if isinstance(i, list):
            ret.extend(i)
    else:
        ret.append(i)
    return ret

def deep_flatten(lst):
    result = []
    result.extend(
        spread(list(map(lambda x: deep_flatten(x) if type(x) == list else x, lst))))
    return result
deep_flatten([1, [2], [[3], 4], 5])  # [1,2,3,4,5]
print(deep_flatten([1, [2], [[3], 4], 5]))  # [1,2,3,4,5]

15. Finden Sie den Unterschied

Diese Methode behält nur die Werte aus der ersten Iteration, um den Unterschied zwischen den beiden Iterationen zu ermitteln

set([1,2,3])-set([1,2,4]) # [3]

#🎜🎜 # 16. Den Unterschied ausgeben

Die folgende Methode verwendet vorhandene Funktionen, um den Unterschied zwischen den beiden Listen zu finden und auszugeben.

def difference_by(a, b, fn):
    b = set(map(fn, b))
    return [item for item in a if fn(item) not in b]
from math import floor
difference_by([2.1, 1.2], [2.3, 3.4],floor) # [1.2]
difference_by([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], lambda v : v['x']) # [ { x: 2 } ]

17. Kettenfunktionsaufruf

Die folgende Methode kann mehrere Funktionen in einer Zeile aufrufen

def add(a, b):
    return a + b
def subtract(a, b):
    return a – b
a, b = 4, 5
print((subtract if a > b else add)(a, b)) # 9

18.

# 🎜🎜 #In Python3.5 und aktualisierten Versionen können Sie den Schrittcode auch auf folgende Weise ausführen:

def merge_dictionaries(a, b):
    return {**a, **b}
a = { 'x': 1, 'y': 2}
b = { 'y': 3, 'z': 4}
print(merge_dictionaries(a, b)) # {'y': 3, 'x': 1, 'z': 4}

19. Konvertieren Sie die beiden Listen in Schriftarten

Die folgende Methode kann verwendet werden. Konvertieren Sie beide Listen in Schriftarten.

keys = ["a", "b", "c"] 
values = [2, 3, 4]
print(dict(zip(keys, values))) # {'a': 2, 'c': 4, 'b': 3}

20 Das Element mit der höchsten Häufigkeit des Auftretens

Diese Methode gibt das Element mit der höchsten Häufigkeit des Auftretens in der Liste aus.

def most_frequent(list):
    return max(set(list), key = list.count)
list = [1,2,1,2,3,2,1,4,2]
most_frequent(list)

21. Palindrom (die gleiche Zeichenfolge wird vorwärts und rückwärts gelesen)

Der folgende Code prüft, ob die angegebene Zeichenfolge ein Palindrom ist. Konvertieren Sie die Zeichenfolge zunächst in Kleinbuchstaben, entfernen Sie dann nicht-alphabetische Zeichen daraus und vergleichen Sie schließlich die neue Zeichenfolgenversion mit der Originalversion.

def palindrome(string):
    from re import sub
    s = sub('[\W_]', '', string.lower())
    return s == s[::-1]
palindrome('taco cat') # True

22. Rechner ohne if-else-Anweisungen

Der folgende Codeausschnitt zeigt, wie man einen einfachen Rechner ohne if-else-Bedingungsanweisungen schreibt.

import operator
action = {
 "+": operator.add,
 "-": operator.sub,
 "/": operator.truediv,
 "*": operator.mul,
 "**": pow
}
print(action['-'](50, 25)) # 25

23. Zufällige Sortierung

Dieser Algorithmus verwendet den Fisher-Yates-Algorithmus, um die Elemente in der neuen Liste zufällig zu sortieren.

from copy import deepcopy
from random import randint

def shuffle(lst):
    temp_lst = deepcopy(lst)
    m = len(temp_lst)
    while (m):
        m -= 1
    i = randint(0, m)
    temp_lst[m], temp_lst[i] = temp_lst[i], temp_lst[m]
    return temp_lst

foo = [1, 2, 3]
shuffle(foo)  # [2,3,1] , foo = [1,2,3]

24. Erweitern Sie die Liste

Diese Methode kann nur 2 Ebenen verschachtelter Listen erweitern, aber nicht mehr als 2 Ebenen

def spread(arg):
    ret = []
    for i in arg:
        if isinstance(i, list):
            ret.extend(i)
        else:
            ret.append(i)
    return ret
spread([1, 2, 3, [4, 5, 6], [7], 8, 9])  # [1,2,3,4,5,6,7,8,9]
print(spread([1, 2, 3, [4, 5,[10,11,12,132,4,[1,2,3,4,5,6]], 6], [7], 8, 9]))  #[1, 2, 3, 4, 5, [10, 11, 12, 132, 4, [1, 2, 3, 4, 5, 6]], 6, 7, 8, 9]

Das obige ist der detaillierte Inhalt vonWas sind einige sehr praktische Python-Fähigkeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!