30 practical Python scripts that are ready to use!

文章来源：数据分析与统计学之美

Hello everyone, I am Brother Tao. Today I will share with you 30 practical Python scripts that are ready to use. The full text is about 5,000 words and takes 10 minutes to read.

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 scripts 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.

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) # Falseall_unique(y) # True

Character element composition determination

Check whether the elements of two strings are the same.

from collections import Counterdef anagram(first, second):    return Counter(first) == Counter(second)anagram("abcd3", "3acdb") # True

Memory usage

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

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('') # 4byte_size('Hello World') # 11

Print string N times

This code block prints the string N times without looping.

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

Capitalize 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 Awesome

Block

Given a specific size, define a function to cut the list according to this size.

from math import ceildef 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]

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 ]

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')]

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) # False

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, swimming

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 redef count_vowels(str):    return len(len(re.findall(r'[aeiou]', str, re.IGNORECASE)))count_vowels('foobar') # 3count_vowels('gym') # 0

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'

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 retdef deep_flatten(lst):    result = []    result.extend(spread(list(map(lambda x: deep_flatten(x) if type(x) == list else x, lst))))    return resultdeep_flatten([1, [2], [[3], 4], 5]) # [1,2,3,4,5]

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]

Taking difference by 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 floordifference_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 } ]

Chained function calls

You can call multiple functions in one line of code.

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

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) # False

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 ca={'x':1,'y':2}b={'y':3,'z':4}print(merge_two_dicts(a,b))#{'y':3,'x':1,'z':4}

在 Python 3.5 或更高版本中，我们也可以用以下方式合并字典：

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}

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}

Use 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)

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)

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*3except TypeError:   print("An exception was raised")else:   print("Thank God, no exceptions were raised.")#Thank God, no exceptions were raised.

element frequency

The following method 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)

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.

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

Calculator without if-else

This piece of code can implement addition, subtraction, multiplication, division, and exponentiation operations without using conditional statements. It is implemented through the dictionary data structure:

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

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]

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 retspread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]

exchange value

No additional operations are required to exchange the values of two variables.

def swap(a, b):    return b, aa, b = -1, 14swap(a, b) # (14, -1)spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9

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

Organizing useful notes

100 Frequently Asked Questions about Reptiles.pdf, so comprehensive!

124 Python cases, complete source code!

PYTHON 3.10 Chinese version official documentation

"The Road to Python 2.0.pdf", which took three months to compile, is open for download

The most classic programming textbook "Think Python" open source Chinese version.PDF download

Great sense of accomplishment

30 practical Python scripts that are ready to use!

Guess you like