What is the fastest way to learn Python? Of course, it is to practice various small projects. Only by thinking and writing by yourself can you remember the rules.
This article is 30 small Python tasks that beginners can try to implement on their own.
There are also 30 pieces of code. Python developers can also see if there are any unexpected uses.
1 Duplicate element determination
The following method checks if there are duplicate elements in a given list. It uses the set() function to remove all duplicate elements.
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) # True2 character element composition determination
Check whether the elements of two strings are the same.
from collections import Counter
def anagram(first, second):
return Counter(first) == Counter(second)
anagram("abcd3", "3acdb") # True3Memory usage
import sys
variable = 30
print(sys.getsizeof(variable)) # 244 bytes occupied
The following code block checks the number of bytes occupied by a string.
def byte_size(string):
return(len(string.encode('utf-8')))
byte_size('') # 4
byte_size('Hello World') # 115Print the string N times
This code block prints the string N times without looping.
n = 2
s ="Programming"
print(s * n)
# ProgrammingProgramming6 Capitalize the first letter
The following code block uses the title() method to capitalize the first letter of each word in a string.
s = "programming is awesome"
print(s.title())
# Programming Is Awesome7 chunks
Given a specific size, define a function to cut the list according to this size.
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 compression
This method can remove Boolean values, such as (False, None, 0, ""), which uses the filter() function.
def compact(lst):
return list(filter(bool, lst))
compact([0, 1, False, 2, '', 3, 'a', 's', 34])
# [ 1, 2, 3, 'a', 's', 34 ]9 Unpack
The following code snippet can unpack the packed pair list into two different sets of tuples.
array = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip(*array)
print(transposed)
# [('a', 'c', 'e'), ('b', 'd', 'f')]10 chain comparison
We can compare multiple different elements using different operators in one line of code.
a = 3
print( 2 < a < 8) # True
print(1 == a < 2) # False11 comma concatenation
The following code concatenates the list into a single string, with commas separating each element.
hobbies = ["basketball", "football", "swimming"]
print("My hobbies are: " + ", ".join(hobbies))
# My hobbies are: basketball, football, swimming12 Vowel Statistics
The following method will count the number of vowels ('a', 'e', 'i', 'o', 'u') in a string, which is done through regular expressions.
import re
def count_vowels(str):
return len(len(re.findall(r'[aeiou]', str, re.IGNORECASE)))
count_vowels('foobar') # 3
count_vowels('gym') # 013. Lowercase first letter
The following method will make the first character of the given string lowercase.
def decapitalize(string):
return str[:1].lower() + str[1:]
decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar') # 'fooBar'14 Expand list
This method will recursively expand a nested list into a single list.
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 list difference
This method will return the elements of the first list that are not in the second list. If you want to feed back the unique elements of the second list at the same time, you need to add 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 Taking difference through function
The following method first applies a given function, and then returns the list elements with different results after applying the function.
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 Chained function calls
You can call multiple functions in one line of code.
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)) # 918 Check for duplicates
The following code will check whether there are duplicates in two lists.
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) # False19 Merge two dictionaries
The following method will be used to merge two dictionaries.
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}In Python 3.5 or higher, we can also merge dictionaries in the following way:
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 Convert two lists into dictionaries
The following method will convert two lists into a single dictionary.
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 Using enumerations
We often use For loops to traverse a list, and we can also enumerate the indexes and values of the list.
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 execution time
The following code block can be used to calculate the time taken to execute a specific code.
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 Try else
We can also add an else clause when using the try/except statement. If no error is triggered, this clause will be executed.
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 element frequencies
The method below will take the most common element in the list based on element frequency.
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 palindromic sequence
The following method will check whether the given string is a palindrome sequence. It first converts all letters to lowercase and removes non-English alphabetic symbols. Finally, it compares the string and the reverse string to see if they are equal. If equal, it is represented as a palindrome sequence.
def palindrome(string):
from re import sub
s = sub('[\W_]', '', string.lower())
return s == s[::-1]
palindrome('taco cat') # True26 Calculator without if-else
This piece of code can realize addition, subtraction, multiplication, division, and exponentiation without using conditional statements. It is implemented through the data structure of dictionary:
import operator
action = {
"+": operator.add,
"-": operator.sub,
"/": operator.truediv,
"*": operator.mul,
"**": pow
}
print(action['-'](50, 25)) # 2527 Shuffle
This algorithm shuffles the order of the list elements, and it basically sorts the new list using the Fisher-Yates algorithm:
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 Expand list
Expand all elements in the list, including sublists, into a list.
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 exchange value
No additional operations are required to exchange the values of two 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,930 dictionary default value
Get the corresponding Value value through Key, and set the default value in the following ways. If the get() method does not set a default value, it will return None if it encounters a non-existent Key.
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3