Prefacio
El texto y las imágenes de este artículo son de Internet y son únicamente con fines de aprendizaje y comunicación. No tienen ningún uso comercial. Si tiene alguna pregunta, comuníquese con nosotros para su procesamiento.
PD: Si necesita materiales de aprendizaje de Python, puede hacer clic en el enlace de abajo para obtenerlo usted mismo.
Cómo aprender Python es lo más rápido, por supuesto, es luchar contra varios proyectos pequeños. Solo cuando piensas y escribes tú mismo puedes recordar las reglas. Este artículo tiene 30 tareas mínimas, los principiantes pueden intentar lograrlo por sí mismos; este artículo también tiene 30 piezas de código, los desarrolladores de Python también pueden ver si hay usos inesperados.
1. Determinación de elementos duplicados
- El siguiente método puede verificar si hay elementos duplicados en una lista dada. Utilizará la función set () para eliminar todos los elementos duplicados.
def all_unique(lst):
return len(lst)== len(set(lst))
x = [1,1,2,2,3,2,3,4,5,6]
y = [1,2,3,4,5]
all_unique(x) # False
all_unique(y) # True
2. Determinación de la composición de los elementos de carácter
- Compruebe si los elementos de las dos cadenas son iguales.
from collections import Counter
def anagram(first, second):
return Counter(first) == Counter(second)
anagram("abcd3", "3acdb") # True
3. Uso de memoria
import sys
variable = 30
print(sys.getsizeof(variable)) # 24
4. Bytes ocupados
- El siguiente bloque de código puede verificar el número de bytes ocupados por una cadena.
def byte_size(string):
return(len(string.encode('utf-8')))
byte_size('') # 4
byte_size('Hello World') # 11
5. Imprime la cadena N veces
- Este bloque de código puede imprimir la cadena N veces sin declaraciones de bucle.
n = 2
s ="Programming"
print(s * n)
# ProgrammingProgramming
6.En mayúscula la primera letra
- El siguiente bloque de código usa el método title () para poner en mayúscula la primera letra de cada palabra en la cadena.
s = "programming is awesome"
print(s.title())
# Programming Is Awesome
7. Bloqueo
- Dado un tamaño específico, defina una función para cortar la lista de acuerdo con este tamaño.
from math import ceil
def chunk(lst, size):
return list(
map(lambda x: lst[x * size:x * size + size],
list(range(0, ceil(len(lst) / size)))))
chunk([1,2,3,4,5],2)
# [[1,2],[3,4],5]
8. Compresión
- Este método puede eliminar valores booleanos, como (Falso, Ninguno, 0, "") y utiliza la función filter ().
def compact(lst):
return list(filter(bool, lst))
compact([0, 1, False, 2, '', 3, 'a', 's', 34])
# [ 1, 2, 3, 'a', 's', 34 ]
9. Desembalar
- El siguiente fragmento de código puede descomprimir la lista emparejada empaquetada en dos tuplas diferentes.
array = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip(*array)
print(transposed)
# [('a', 'c', 'e'), ('b', 'd', 'f')]
10.Comparación de cadenas
- Podemos usar diferentes operadores para comparar múltiples elementos diferentes en una línea de código.
a = 3
print( 2 < a < 8) # True
print(1 == a < 2) # False
11.Conexión por coma
- El siguiente código puede concatenar la lista en una sola cadena y establecer la separación entre cada elemento en una coma.
hobbies = ["basketball", "football", "swimming"]
print("My hobbies are: " + ", ".join(hobbies))
# My hobbies are: basketball, football, swimming
12. Estadísticas de vocales
- El siguiente método contará el número de vocales ('a', 'e', 'i', 'o', 'u') en una cadena, y se realiza mediante expresiones regulares.
import re
def count_vowels(str):
return len(len(re.findall(r'[aeiou]', str, re.IGNORECASE)))
count_vowels('foobar') # 3
count_vowels('gym') # 0
13. Iniciales en minúscula
- El siguiente método unificará el primer carácter de una cadena dada en minúsculas.
def decapitalize(string):
return str[:1].lower() + str[1:]
decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar') # 'fooBar'
14. Expande la lista
- Este método expandirá de forma recursiva el anidamiento de la lista en una sola lista.
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]
15. La diferencia de la lista
- Este método devolverá los elementos de la primera lista, que no están en la segunda lista. Si desea retroalimentar los elementos únicos de la segunda lista al mismo tiempo, debe agregar un set_b.difference (set_a).
def difference(a, b):
set_a = set(a)
set_b = set(b)
comparison = set_a.difference(set_b)
return list(comparison)
difference([1,2,3], [1,2,4]) # [3]
16. Toma la diferencia por función
- El siguiente método primero aplica una función determinada y luego devuelve los elementos de la lista con resultados diferentes después de aplicar la función.
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. Llamada a función encadenada
- Puede llamar a varias funciones en una línea de código.
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.Compruebe si hay duplicados
- El siguiente código verificará si hay duplicados en las dos listas.
def has_duplicates(lst):
return len(lst) != len(set(lst))
x = [1,2,3,4,5,5]
y = [1,2,3,4,5]
has_duplicates(x) # True
has_duplicates(y) # False
19. Fusionar dos diccionarios
- El siguiente método se utilizará para fusionar dos diccionarios.
def merge_two_dicts(a, b):
c = a.copy() # make a copy of a
c.update(b) # modify keys and values of a with the once from b
return c
a={'x':1,'y':2}
b={'y':3,'z':4}
print(merge_two_dicts(a,b))
#{'y':3,'x':1,'z':4}
- En Python 3.5 o superior, también podemos fusionar diccionarios de las siguientes formas:
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}
20. Convierta dos listas en diccionarios
- El siguiente método convertirá dos listas en un solo diccionario.
def to_dictionary(keys, values):
return dict(zip(keys, values))
keys = ["a", "b", "c"]
values = [2, 3, 4]
print(to_dictionary(keys, values))
#{'a': 2, 'c': 4, 'b': 3}
21. Use enum
- A menudo usamos bucles For para recorrer una lista, y también podemos enumerar el índice y el valor de la lista.
list = ["a", "b", "c", "d"]
for index, element in enumerate(list):
print("Value", element, "Index ", index, )
# ('Value', 'a', 'Index ', 0)
# ('Value', 'b', 'Index ', 1)
#('Value', 'c', 'Index ', 2)
# ('Value', 'd', 'Index ', 3)
22. Tiempo de ejecución
- El siguiente bloque de código se puede utilizar para calcular el tiempo que se tarda en ejecutar un código específico.
import time
start_time = time.time()
a = 1
b = 2
c = a + b
print(c) #3
end_time = time.time()
total_time = end_time - start_time
print("Time: ", total_time)
# ('Time: ', 1.1205673217773438e-05)
23 Prueba otra cosa
- También podemos agregar una cláusula else al usar la instrucción try / except. Si no se dispara ningún error, esta cláusula se ejecutará.
try:
2*3
except TypeError:
print("An exception was raised")
else:
print("Thank God, no exceptions were raised.")
#Thank God, no exceptions were raised.
24. Frecuencia del elemento
- El siguiente método tomará los elementos más comunes de la lista según la frecuencia del elemento.
def most_frequent(list):
return max(set(list), key = list.count)
list = [1,2,1,2,3,2,1,4,2]
most_frequent(list)
25. Secuencia palíndromo
- El siguiente método verificará si la cadena dada es una secuencia palíndromo. Primero convertirá todas las letras a minúsculas y eliminará los símbolos de letras que no estén en inglés. Finalmente, compara si la cuerda es igual a la cuerda invertida, que se representa como una secuencia palíndromo.
def palindrome(string):
from re import sub
s = sub('[\W_]', '', string.lower())
return s == s[::-1]
palindrome('taco cat') # True
26. Calculadora sin if-else
- Este fragmento de código puede implementar operaciones de suma, resta, multiplicación, división y exponenciación sin usar declaraciones condicionales. Se implementa a través de la estructura de datos del diccionario:
import operator
action = {
"+": operator.add,
"-": operator.sub,
"/": operator.truediv,
"*": operator.mul,
"**": pow
}
print(action['-'](50, 25)) # 25
27 Barajar
- Este algoritmo interrumpirá el orden de los elementos de la lista, principalmente ordenará la nueva lista a través del algoritmo de Fisher-Yates:
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]
28. Expandir la lista
- Expanda todos los elementos de la lista, incluidas las sublistas, en una lista.
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]
29. Valor de cambio
- No se requieren operaciones adicionales para intercambiar los valores de dos variables.
def swap(a, b):
return b, a
a, b = -1, 14
swap(a, b) # (14, -1)
spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]
30. Valores predeterminados del diccionario
- Tome el valor de Valor correspondiente a través de Clave y establezca el valor predeterminado de las siguientes maneras. Si el método get () no establece un valor predeterminado, devolverá None si encuentra una clave inexistente.
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3