What is the fastest way to learn Python?
Of course, it is a variety of small projects in actual combat. Only when you think and write, can you remember the rules. This article is 30 minimalist tasks that beginners can try to achieve by themselves; This article is also 30 pieces of code. Python developers can also see if there are unexpected uses.
1. Repeated element determination
The following method can check whether there are duplicate elements in a given list. It will use 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) # True
2. Character element composition determination
Check whether the constituent elements of two strings are the same.
from collections import Counter
def anagram(first, second):
return Counter(first) == Counter(second)
anagram("abcd3", "3acdb") # True
3. Memory usage
The following code block checks the number of bytes the string occupies.
import sys variable = 30 print(sys.getsizeof(variable)) # 24
4. Byte occupancy
The following code block checks the number of bytes the string occupies.
def byte_size(string):
return(len(string.encode('utf-8')))
byte_size('') # 4
byte_size('Hello World') # 11
5. Print string N times
This code block can print a string N times without a loop statement.
n = 2 s ="Programming" print(s * n) # ProgrammingProgramming
6. Capital first letter
The following code block uses the title() method to capitalize the first letter of each word in the string.
s = "programming is awesome" print(s.title()) # Programming Is Awesome
7 blocks
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, for example (False, None, 0, ""), and it 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 paired 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 use different operators to compare multiple different elements in one line of code.
a = 3 print( 2 < a < 8) # True print(1 == a < 2) # False
11. Comma concatenation
The following code can connect the list into a single string, and the separation between each element is set to comma.
hobbies = ["basketball", "football", "swimming"]
print("My hobbies are: " + ", ".join(hobbies))
# My hobbies are: basketball, football, swimming
12. Vowel statistics
The following method will count the number of vowels ('a ',' e ',' i ',' o ',' u ') in a string. It 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') # 0
13. Initial lowercase
The following method unifies the first character of a given string to lowercase.
def decapitalize(string):
return str[:1].lower() + str[1:]
decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar') # 'fooBar'
14. Expand list
This method will recursively expand the nesting of the 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 returns the elements of the first list, which 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 a sentence 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. Difference by function
The following method will first apply a given function, and then return 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 call
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)) # 9
18. Check for duplicates
The following code will check whether there are duplicates in the 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) # False
19. 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 later, we can also merge dictionaries in the following ways:
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 to dictionaries
The following method will convert the 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. Use enumeration
We often use the For loop to traverse a list. Similarly, we can 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 blocks can be used to calculate the time spent executing 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 run.
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 frequency
The following method will take the most common elements in the list according to the 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. Palindrome sequence
The following method will check whether the given string is a palindrome sequence. It will first convert all letters to lowercase and remove non English alphabetic symbols. Finally, it compares whether the string is equal to the reverse string, which is expressed as a palindrome sequence.
def palindrome(string):
from re import sub
s = sub('[\W_]', '', string.lower())
return s == s[::-1]
palindrome('taco cat') # True
26. The calculator without if else
This code can realize addition, subtraction, multiplication, division and exponentiation without using conditional statements. It is realized through the data structure of Dictionary:
import operator
action = {
"+": operator.add,
"-": operator.sub,
"/": operator.truediv,
"*": operator.mul,
"**": pow
}
print(action['-'](50, 25)) # 25
27, Shuffle
This algorithm will disturb the order of list elements. It mainly sorts the new list through 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 sub lists, 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
The values of two variables can be exchanged without additional operations.
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. Dictionary default
Get the corresponding Value through the Key. You can set the default Value in the following ways. If the get() method does not set a default Value, if a nonexistent Key is encountered, None will be returned.
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3
Here we have sorted out Python learning materials for you, including basic installation packages and learning tutorials, as well as some items suitable for beginners to practice. You can scan the code to get them if necessary, which may help you learn Python!
