Python 3: i 50 migliori consigli e trucchi

Blog

Python 3: i 50 migliori consigli e trucchi

Ecco un elenco di suggerimenti e trucchi di Python per aiutarti a scrivere un elegante Pitone 3 codice! Questo articolo è suddiviso in diversi tipi di trucchi:



  • Trucchi Python iterabili.
  • Trucchi per la comprensione di Python.
  • Trucchi di disimballaggio di Python.
  • Trucchi per gli itertool di Python.
  • Trucchi per le raccolte Python.
  • Python altri trucchi.
  • Uova di Pasqua di pitone.
  • Trucchi Python per capire il contesto .

1. Trucchi Python Iterables

Creazione di una sequenza di numeri (da zero a dieci con salti).

>>> range(0,10,2) [0, 2, 4, 6, 8]

Sommando una sequenza di numeri (calcolando la somma da zero a dieci con salti).



>>> l = range(0,10,2) >>> sum(l) 20

Verifica se un elemento nella sequenza è Vero (verifica se gli elementi compresi tra zero e dieci con omissioni sono pari).

>>> any(a % 2==0 for a in range(0,10,2)) True

Verifica se tutti gli elementi nella sequenza sono Veriti (verifica se tutti gli elementi compresi tra zero e dieci con omissioni sono pari).



>>> all(a % 2==0 for a in range(0,10,2)) True

Somma cumulativa di una sequenza di numeri (calcolo della somma cumulativa da zero a dieci con salti).

>>> import numpy as np >>> res = list(np.cumsum(range(0,10,2))) >>> res [ 0, 2, 6, 12, 20]

Dato ogni iterabile costruiamo una tupla aggiungendo un indice.

>>> a = ['Hello', 'world', '!'] >>> list(enumerate(a)) [(0, 'Hello'), (1, 'world'), (2, '!')]

Concatenazione iterabile a una singola stringa.

>>> a = ['python','really', 'rocks'] >>> ' '.join(a) 'python really rocks'

Combinazione di due iterabili di tuple o iterabili nidificati pivot.

# Combining two iterables >>> a = [1, 2, 3] >>> b = ['a', 'b', 'c'] >>> z = zip(a, b) >>> z [(1, 'a'), (2, 'b'), (3, 'c')] # Pivoting list of tuples >>> zip(*z) [(1, 2, 3), ('a', 'b', 'c')]

Ottenere min/max da iterabile (con/senza funzione specifica).

cos'è la moneta di Einsteinio?
# Getting maximum from iterable >>> a = [1, 2, -3] >>> max(a) 2 # Getting maximum from iterable >>> min(a) 1 # Bot min/max has key value to allow to get maximum by appliing function >>> max(a,key=abs) 3

Ottenere ordinato iterabile (può ordinare per funzione di confronto).

>>> a = [1, 2, -3] >>> sorted(a) [-3, 1, 2] >>> sorted(a,key=abs) [1, 2, -3]

Divisione di una singola stringa in elenco.

>>> s = 'a,b,c' >>> s.split(',') ['a', 'b', 'c']

Inizializzazione di un elenco riempito con un numero ripetitivo.

>> [1]* 10 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Unione/sovrapposizione di due dizionari.

>>> a = {'a':1, 'b':1} >>> b = {'b':2, 'c':1} >>> a.update(b) >>> a {'a':1, 'b':2, 'c':1}

Denominazione e salvataggio di porzioni di iterable.

# Naming slices (slice(start, end, step)) >>> a = [0, 1, 2, 3, 4, 5] >>> LASTTHREE = slice(-3, None) >>> LASTTHREE slice(-3, None, None) >>> a[LASTTHREE] [3, 4, 5]

Trovare l'indice di un elemento in un elenco.

>>> a = ['foo', 'bar', 'baz'] >>> a.index('bar') 1

Trovare l'indice dell'elemento min/max in un iterabile.

>>> a = [2, 3, 1] >>> min(enumerate(a),key=lambda x: x[1])[0] 2

Rotazione iterabile di k elementi.

>>> a = [1, 2, 3, 4] >>> k = 2 >>> a[-2:] + a[:-2] [3, 4, 1, 2]

Rimozione di caratteri inutili alla fine/inizio/entrambi della stringa.

>>> name = '//George//' >>> name.strip('/') 'George' >>> name.rstrip('/') '//George' >>> name.lstrip('/') 'George//'

Invertire un ordine di wit iterabile (stringa, elenco, ecc.).

# Reversing string >>> s = 'abc' >>> s[::-1] 'cba' # Reversing list >>> l = ['a', 'b', 'c'] >>> l[::-1] ['c', 'b', 'a']

2. Trucchi di ramificazione Python

Predicati multipli scorciatoia.

>>> n = 10 >>> 1

For-else costrutto utile quando si cerca qualcosa e lo si trova.

# For example assume that I need to search through a list and process each item until a flag item is found and # then stop processing. If the flag item is missing then an exception needs to be raised. for i in mylist: if i == theflag: break process(i) else: raise ValueError('List argument missing terminal flag.')

Operatore formatore.

>>> 'Python ROCK' if True else ' I AM GRUMPY' 'Python ROCK'

Costrutto Try-catch-else.

try: foo() except Exception: print('Exception occured') else: print('Exception didnt occur') finally: print('Always gets here')

Costrutto While-else.

i = 5 while i > 1: print('Whil-ing away!') i -= 1 if i == 3: break else: print('Finished up!')

3. Trucchi per la comprensione di Python

Comprensione delle liste.

dove acquistare token celsius
>>> m = [x ** 2 for x in range(5)] >>> m [0, 1, 4, 9, 16]

Comprensione imposta.

>>> m = {x ** 2 for x in range(5)} >>> m {0, 1, 4, 9, 16}

Comprensione del detto.

>>> m = {x: x ** 2 for x in range(5)} >>> m {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Comprensione del generatore.

# A generator comprehension is the lazy version of a list comprehension. >>> m = (x ** 2 for x in range(5)) >>> m >>> list(m) [0, 1, 4, 9, 16] >>> m = (x ** 2 for x in range(5)) >>> next(m) 0 >>> list(m) [1, 4, 9, 16]

Comprensione della lista con il valore attuale e precedente.

>>> a = [1, 2, 4,2] >>> [y - x for x,y in zip(a,a[1:])] [1, 2, -2]

Nota: tutta la comprensione può utilizzare predicati con l'istruzione if.

4. Trucchi per scompattare Python

Decomprimere le variabili da iterable.

# One can unpack all iterables (tuples, list etc) >>> a, b, c = 1, 2, 3 >>> a, b, c (1, 2, 3) >>> a, b, c = [1, 2, 3] >>> a, b, c (1, 2, 3)

Scambia i valori delle variabili.

>>> a, b = 1, 2 >>> a, b = b, a >>> a, b (2, 1)

Decomprimere le variabili da iterable senza indicare tutti gli elementi.

>>> a, *b, c = [1, 2, 3, 4, 5] >>> a 1 >>> b [2, 3, 4] >>> c 5

Decomprimere le variabili utilizzando l'operatore splat.

>>> def test(x, y, z): >>> print(x, y, z) >>> res = test(*[10, 20, 30]) 10 20 30 >>> res = test(**{'x': 1, 'y': 2, 'z': 3} ) 10 20 30

5. Trucchi Python Itertools

Appiattisci gli iterabili.

>>> a = [[1, 2], [3, 4], [5, 6]] >>> list(itertools.chain.from_iterable(a)) [1, 2, 3, 4, 5, 6]

Creazione di prodotti cartesiani da iterables.

>>> for p in itertools.product([1, 2, 3], [4, 5]): >>> print(''.join(str(x) for x in p)) (1, 4) (1, 5) (2, 4) (2, 5) (3, 4) (3, 5)

Creazione di permutazioni da iterabile.

>>> for p in itertools.permutations([1, 2, 3, 4]): >>> print(''.join(str(x) for x in p)) 123 132 213 231 312 321

Creazione di ngram da iterable.

>>> from itertools import islice >>> def n_grams(a, n): ... z = (islice(a, i, None) for i in range(n)) ... return zip(*z) ... >>> a = [1, 2, 3, 4, 5, 6] >>> n_grams(a, 3) [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)] >>> n_grams(a, 2) [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)] >>> n_grams(a, 4) [(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

Combinazione di due iterabili di tuple con padding o pivot nidificati iterabili con padding.

>>> import itertools as it >>> x = [1, 2, 3, 4, 5] >>> y = ['a', 'b', 'c'] >>> list(zip(x, y)) [(1, 'a'), (2, 'b'), (3, 'c')] >>> list(it.zip_longest(x, y)) [(1, 'a'), (2, 'b'), (3, 'c'), (4, None), (5, None)]

Creazione di una combinazione di k cose da un iterabile di n

>>> import itertools >>> bills = [20, 20, 20, 10, 10, 10, 10, 10, 5, 5, 1, 1, 1, 1, 1] >>> list(itertools.combinations(bills, 3)) [(20, 20, 20), (20, 20, 10), (20, 20, 10), ... ]

Creare risultati accumulati di iterabile data una funzione

>>> import itertools >>> list(itertools.accumulate([9, 21, 17, 5, 11, 12, 2, 6], min)) [9, 9, 9, 5, 5, 5, 2, 2]

Creazione di un iteratore che restituisce elementi dall'iterabile purché il predicato sia vero

>>> import itertools >>> itertools.takewhile(lambda x: x >> it.dropwhile(lambda x: x <3, [0, 1, 2, 3, 4]) [3, 4]

Creazione di un iteratore che filtri gli elementi da iterabile restituendo solo quelli per cui il predicato è _False_

>>> import itertools # keeping only false values >>> list(itertools.filterfalse(bool, [None, False, 1, 0, 10])) [None, False, 0]

Creare un iteratore che calcola la funzione utilizzando argomenti ottenuti dall'iterabile di iterabili

>>> import itertools >>> import operator >>> a = [(2, 6), (8, 4), (7, 3)] >>> list(itertools.starmap(operator.mul, a)) [12, 32, 21]

6. Trucchi per le raccolte Python

Imposta le operazioni di base.

dove posso comprare akita crypto?
>>> A = {1, 2, 3, 3} >>> A set([1, 2, 3]) >>> B = {3, 4, 5, 6, 7} >>> B set([3, 4, 5, 6, 7]) >>> A | B set([1, 2, 3, 4, 5, 6, 7]) >>> A & B set([3]) >>> A - B set([1, 2]) >>> B - A set([4, 5, 6, 7]) >>> A ^ B set([1, 2, 4, 5, 6, 7]) >>> (A ^ B) == ((A - B) | (B - A)) True

Struttura dei dati del contatore (una raccolta non ordinata in cui gli elementi sono archiviati come chiavi del dizionario e i loro conteggi sono archiviati come valori del dizionario) .

import collections >>> A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7]) >>> A Counter({3: 4, 1: 2, 2: 2, 4: 1, 5: 1, 6: 1, 7: 1}) >>> A.most_common(1) [(3, 4)] >>> A.most_common(3) [(3, 4), (1, 2), (2, 2)]

Struttura del dizionario predefinita (una sottoclasse del dizionario che recupera il valore predefinito quando si accede a una chiave inesistente).

>>> import collections >>> m = collections.defaultdict(int) >>> m['a'] 0 >>> m = collections.defaultdict(str) >>> m['a'] '' >>> m['b'] += 'a' >>> m['b'] 'a' >>> m = collections.defaultdict(lambda: '[default value]') >>> m['a'] '[default value]' >>> m['b'] '[default value]' >>> m = collections.defaultdict(list) >>> m['a'] []

Struttura ordinata dict (una sottoclasse del dizionario che mantiene l'ordine).

>>> from collections import OrderedDict >>> d = OrderedDict.fromkeys('abcde') >>> d.move_to_end('b') >>> ''.join(d.keys()) 'acdeb' >>> d.move_to_end('b', last=False) >>> ''.join(d.keys()) 'bacde'

Deques struttura ( I deque sono una generalizzazione di pile e code ).

>>> import collection >>> Q = collections.deque() >>> Q.append(1) >>> Q.appendleft(2) >>> Q.extend([3, 4]) >>> Q.extendleft([5, 6]) >>> Q deque([6, 5, 2, 1, 3, 4]) >>> Q.pop() 4 >>> Q.popleft() 6 >>> Q deque([5, 2, 1, 3]) >>> Q.rotate(3) >>> Q deque([2, 1, 3, 5]) >>> Q.rotate(-3) >>> Q deque([5, 2, 1, 3]) >>> last_three = collections.deque(maxlen=3) >>> for i in range(4): ... last_three.append(i) ... print ', '.join(str(x) for x in last_three) ... 0 0, 1 0, 1, 2 1, 2, 3 2, 3, 4

Struttura di tuple con nome (crea oggetti simili a tuple che hanno campi accessibili tramite la ricerca di attributi oltre ad essere indicizzabili e iterabili).

>>> import collections >>> Point = collections.namedtuple('Point', ['x', 'y']) >>> p = Point(x=1.0, y=2.0) >>> p Point(x=1.0, y=2.0) >>> p.x 1.0 >>> p.y 2.0

Usa un dizionario per memorizzare un interruttore.

>>> func_dict = {'sum': lambda x, y: x + y, 'subtract': lambda x, y: x - y} >>> func_dict['sum'](9,3) 12 >>> func_dict['subtract'](9,3) 6

Struttura delle classi di dati

>>> from dataclasses import dataclass >>> @dataclass >>> class DataClassCard: >>> rank: str >>> suit: str >>> queen_of_hearts = DataClassCard('Q', 'Hearts') >>> queen_of_hearts.rank 'Q' >>> queen_of_hearts DataClassCard(rank='Q', suit='Hearts') >>> queen_of_hearts == DataClassCard('Q', 'Hearts') True

7. Altri trucchi di Python

Generazione di uuid.

# This creates a randomized 128-bit number that will almost certainly be unique. # In fact, there are over 2¹²² possible UUIDs that can be generated. That’s over five undecillion (or 5,000,000,000,000,000,000,000,000,000,000,000,000). >>> import uuid >>> user_id = uuid.uuid4() >>> user_id UUID('7c2faedd-805a-478e-bd6a-7b26210425c7')

Memoizzazione tramite cache LRU.

laravel 5 cheat sheet
import functools @functools.lru_cache(maxsize=128) def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 return fibonacci(n - 1) + fibonacci(n - 2)

Soppressione delle espressioni

>>> from contextlib import suppress >>> with contextlib.suppress(ZeroDivisionError): >>> 10/0 # No exception raised

Un modo elegante per gestire un percorso di file (3.4≥)

>>> from pathlib import Path >>> data_folder = Path('source_data/text_files/') # Path calculation and metadata >>> file_to_open = data_folder / 'raw_data.txt' >>> file_to_open.name 'raw_data.txt' >>> file_to_open.suffix 'txt' >>>file_to_open.stem 'raw_data' # Files functions >>> f = open(file_to_open) >>> f.read() # content of the file >>> file_to_open.exists() True

Creazione decoratore per separare le preoccupazioni

>>>from functools import wraps >>>def add_sandwich(wrapped): >>> @wraps(wrapped) >>> def wrapper(*args, **kwargs): >>> return wrapped(*args, **kwargs) + ' sandwich' >>> return wrapper >>>@add_sandwich >>>def ham(): >>> return 'ham' >>>ham() 'ham sandwich'

Utilizzo della resa per creare un semplice iteratore

>>> def foo(lst): >>> for x in lst: >>> yield x >>> yield x*2 >>> a = [1, 3] >>> list(foo(a)) [1, 2, 3, 6]

8. Uova di Pasqua di pitone

Anti gravità

import antigravity antigravity.fly()

Lo Zen di Python

>>> import this The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one and preferably only one obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea let's do more of those!

Elenco attributi dell'oggetto

>>> dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__'] >>> dir('Hello World') ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Riepilogo

_Se pensi che dovrei aggiungere altro o avere suggerimenti, faccelo sapere nei commenti. Grazie per aver letto!

#Python #Python3 #Python Tricks #Coding #Programmazione