Lộ trình học Python: Từ Python Newbie đến Pro

Giới thiệu:

Python là một trong những ngôn ngữ lập trình linh hoạt và được sử dụng rộng rãi nhất trên thế giới, được biết đến với tính đơn giản, dễ đọc và linh hoạt. Trong bài viết này, chúng ta sẽ khám phá một loạt các tình huống ví dụ trong đó mã được phát triển bởi các lập trình viên ở ba cấp độ chuyên môn khác nhau: người mới bắt đầu, trung cấp và chuyên gia.

Người trung cấp và chuyên gia thường sử dụng như sau:

• Khả năng hiểu danh sách: Một cách ngắn gọn để tạo danh sách với một dòng mã.

squares = [x**2 for x in range(1, 6)]
print(squares)  
# Output: [1, 4, 9, 16, 25]

squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)  
# Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

nums = [1, 2, 3, 4, 5]
doubles = list(map(lambda x: x * 2, nums))
print(doubles)  # Output: [2, 4, 6, 8, 10]

def greet_decorator(func):
    def wrapper():
        print("Hello!")
        func()
        print("Welcome!")
    return wrapper

@greet_decorator
def greet_name():
    print("John")

greet_name()
# Output:
# Hello!
# John
# Welcome!

with open("file.txt", "r") as file:
    content = file.read()
    print(content)

from typing import List

def sum_elements(elements: List[int]) -> int:
    return sum(elements)

result = sum_elements([1, 2, 3, 4, 5])
print(result)  # Output: 15

def fibonacci_gen(n: int):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci_gen(5):
    print(num, end=" ")
# Output: 0 1 1 2 3

import re

text = "The email addresses are [email protected] and [email protected]"
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(pattern, text)
print(emails)  # Output: ['[email protected]', '[email protected]']

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"An error occurred: {e}")
# Output: An error occurred: division by zero

# Importing the 'math' module and using its 'sqrt' function
import math

sqrt_result = math.sqrt(25)
print(sqrt_result)  # Output: 5.0

import threading

def print_square(num):
    print(f"Square: {num * num}")

def print_cube(num):
    print(f"Cube: {num * num * num}")

thread1 = threading.Thread(target=print_square, args=(4,))
thread2 = threading.Thread(target=print_cube, args=(4,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

# Output:
# Square: 16
# Cube: 64

# Built-in functions
numbers = [2, 4, 1, 6, 3, 8, 5, 7]
max_num = max(numbers)  # Find the maximum number in the list
min_num = min(numbers)  # Find the minimum number in the list
sorted_nums = sorted(numbers)  # Sort the list in ascending order
reversed_nums = list(reversed(numbers))  # Reverse the list

print("Maximum number:", max_num)
print("Minimum number:", min_num)
print("Sorted numbers:", sorted_nums)
print("Reversed numbers:", reversed_nums)

# Standard library modules
from collections import Counter
from itertools import combinations

# Counter (from collections module)
word = "mississippi"
counter = Counter(word)  # Count the occurrences of each character
print("Character count:", counter)

# Combinations (from itertools module)
combos = list(combinations(numbers, 2))  # Find all combinations of size 2
print("Combinations of size 2:", combos)

• PEP 8 và phong cách viết mã: Tuân thủ hướng dẫn về phong cách chính thức của Python (PEP 8) và các phương pháp hay nhất khác để mã có thể đọc được và nhất quán.

# PEP 8 compliant code snippet

def calculate_area(radius):
    """Calculate the area of a circle given its radius.

    Args:
        radius (float): The radius of the circle.

    Returns:
        float: The area of the circle.
    """
    pi = 3.14159
    return pi * radius**2


def main():
    # Collect user input for the radius
    radius = float(input("Enter the radius of the circle: "))

    # Calculate the area using the defined function
    area = calculate_area(radius)

    # Display the result with appropriate formatting
    print(f"The area of the circle with radius {radius} is {area:.2f}")


if __name__ == "__main__":
    main()

import unittest

def add_numbers(a, b):
    return a + b

class TestAddition(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(add_numbers(2, 3), 5)

if __name__ == '__main__':
    unittest.main(argv=['first-arg-is-ignored'], exit=False)
# Output: .
# ----------------------------------------------------------------------
# Ran 1 test in 0.002s
#
# OK

Người bắt đầu:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_sum = 0

for num in numbers:
    if num % 2 == 0:
        even_sum += num

print("The sum of even numbers is:", even_sum)

• Kiểm tra xem một số có chẵn không bằng cách sử dụng toán tử mô đun
• Thêm số chẵn vào biến tổng

def is_even(num):
    return num % 2 == 0

def even_sum(numbers):
    result = 0
    for num in numbers:
        if is_even(num):
            result += num
    return result

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = even_sum(numbers)
print("The sum of even numbers is:", result)

• Tạo hàm even_sumtính tổng các số chẵn
• Mã có nhiều mô-đun hơn và dễ bảo trì hơn

def even_sum(numbers):
    return sum(filter(lambda num: num % 2 == 0, numbers))

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = even_sum(numbers)
print("The sum of even numbers is:", result)

• Sử dụng hàm lambda để lọc các số chẵn ngắn gọn và hiệu quả
• Mã nhỏ gọn hơn, tận dụng khả năng lập trình chức năng của Python

Người bắt đầu:

text = "hello world"
char_count = {}

for char in text:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1

print("Character counts:", char_count)

#Character counts: {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

• Kiểm tra xem một ký tự đã có trong từ điển chưa và cập nhật số lượng tương ứng.

def count_characters(text):
    char_count = {}
    for char in text:
        char_count[char] = char_count.get(char, 0) + 1
    return char_count

text = "hello world"
result = count_characters(text)
print("Character counts:", result)

• Sử dụng dict.get()phương pháp để đơn giản hóa mã.

from collections import Counter

def count_characters(text):
    return Counter(text)

text = "hello world"
result = count_characters(text)
print("Character counts:", result)

• Tận dụng tính năng tích hợp sẵn Counterđể đếm số lần xuất hiện của ký tự một cách hiệu quả.

Người bắt đầu:

numbers = [1, 2, 3, 4, 5]
total = 0

for num in numbers:
    total += num

average = total / len(numbers)
print("The average is:", average)

• Chia tổng cho độ dài của danh sách để tính giá trị trung bình

def calculate_average(numbers):
    return sum(numbers) / len(numbers)

numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print("The average is:", average)

• Sử dụng chức năng tích hợp sumđể đơn giản hóa mã

from statistics import mean

def calculate_average(numbers):
    return mean(numbers)

numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print("The average is:", average)

• Tận dụng chức năng tích hợp meanđể tính trung bình

Người bắt đầu:

text = "hello"
reversed_text = ""

for char in text:
    reversed_text = char + reversed_text

print("Reversed text:", reversed_text)
#text = "Hello"
#Reversed text: olleH

• Nối các ký tự theo thứ tự đảo ngược để tạo chuỗi đảo ngược

def reverse_string(text):
    return "".join(reversed(text))

text = "hello"
reversed_text = reverse_string(text)
print("Reversed text:", reversed_text)

• Sử dụng reversedhàm và joinphương thức để đảo ngược chuỗi

def reverse_string(text):
    return text[::-1]

text = "hello"
reversed_text = reverse_string(text)
print("Reversed text:", reversed_text)

5. Tìm số lớn nhất trong một dãy:

Người bắt đầu:

numbers = [1, 3, 7, 2, 5]
max_number = numbers[0]

for num in numbers:
    if num > max_number:
        max_number = num

print("The largest number is:", max_number)

#The largest number is: 7

• So sánh từng số với mức tối đa hiện tại và cập nhật mức tối đa tương ứng

def find_max(numbers):
    return max(numbers)

numbers = [1, 3, 7, 2, 5]
max_number = find_max(numbers)
print("The largest number is:", max_number)

• Sử dụng chức năng tích hợp maxđể tìm số lượng lớn nhất

from functools import reduce

def find_max(numbers):
    return reduce(lambda x, y: x if x > y else y, numbers)

numbers = [1, 3, 7, 2, 5]
max_number = find_max(numbers)
print("The largest number is:", max_number)

• Tận dụng reducechức năng với hàm lambda để tìm số lượng tối đa

Người bắt đầu:

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = []

for item in original_list:
    if item not in unique_list:
        unique_list.append(item)

print("Unique list:", unique_list)

• Kiểm tra xem một mục không có trong danh sách duy nhất và thêm nó nếu không có

def remove_duplicates(items):
    return list(set(items))

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = remove_duplicates(original_list)
print("Unique list:", unique_list)

• Sử dụng cấu trúc dữ liệu tích hợp setđể loại bỏ các bản sao và chuyển đổi nó trở lại danh sách

def remove_duplicates(items):
    return list(dict.fromkeys(items))

original_list = [1, 2, 3, 1, 2, 3, 4, 5]
unique_list = remove_duplicates(original_list)
print("Unique list:", unique_list)

7. Bình phương tất cả các số trong một danh sách:

Người bắt đầu:

numbers = [1, 2, 3, 4, 5]
squared_numbers = []

for num in numbers:
    squared_numbers.append(num ** 2)

print("Squared numbers:", squared_numbers)
#Squared numbers: [1, 4, 9, 16, 25]

• Nối bình phương của mỗi số vào danh sách số bình phương

def square_numbers(numbers):
    return [num ** 2 for num in numbers]

numbers = [1, 2, 3, 4, 5]
squared_numbers = square_numbers(numbers)
print("Squared numbers:", squared_numbers)

• Sử dụng khả năng hiểu danh sách để tạo danh sách số bình phương

def square_numbers(numbers):
    return list(map(lambda x: pow(x, 2), numbers))

numbers = [1, 2, 3, 4, 5]
squared_numbers = square_numbers(numbers)
print("Squared numbers:", squared_numbers)

      
                

                    
                    
                
            

Người bắt đầu:

numbers = [1, 2, 3, 4, 5]
positions = 2

rotated_list = numbers[-positions:] + numbers[:-positions]
print("Rotated list:", rotated_list)
#Rotated list: [4, 5, 1, 2, 3]

Trung cấp:

def rotate_list(numbers, positions):
    return numbers[-positions:] + numbers[:-positions]

numbers = [1, 2, 3, 4, 5]
positions = 2
rotated_list = rotate_list(numbers, positions)
print("Rotated list:", rotated_list)

• Sử dụng cú pháp cắt lát của Python để xoay danh sách theo số lượng vị trí đã chỉ định

from collections import deque

def rotate_list(numbers, positions):
    rotated_numbers = deque(numbers)
    rotated_numbers.rotate(positions)
    return list(rotated_numbers)

numbers = [1, 2, 3, 4, 5]
positions = 2
rotated_list = rotate_list(numbers, positions)
print("Rotated list:", rotated_list)

• Tận dụng dequelớp và rotatephương thức của nó để xoay danh sách một cách hiệu quả theo số lượng vị trí đã chỉ định

Người bắt đầu:

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = []

for num in list1:
    if num in list2:
        common_elements.append(num)

print("Common elements:", common_elements)
#Common elements: [4, 5]

• Kiểm tra xem một phần tử có trong danh sách thứ hai hay không và nối nó vào danh sách phần tử chung nếu tìm thấy

def find_common_elements(list1, list2):
    return [num for num in list1 if num in list2]

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = find_common_elements(list1, list2)
print("Common elements:", common_elements)

• Sử dụng khả năng hiểu danh sách để tạo danh sách các phần tử phổ biến

def find_common_elements(list1, list2):
    return list(set(list1) & set(list2))

list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = find_common_elements(list1, list2)
print("Common elements:", common_elements)

• Chuyển đổi kết quả trở lại danh sách

Người bắt đầu:

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

transposed_matrix = []

for i in range(len(matrix[0])):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed_matrix.append(transposed_row)

print("Transposed matrix:", transposed_matrix)

• Nối các phần tử từ mỗi hàng trong ma trận ban đầu để tạo ma trận chuyển vị

def transpose_matrix(matrix):
    return [[row[i] for row in matrix] for i in range(len(matrix[0]))]

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
transposed_matrix = transpose_matrix(matrix)
print("Transposed matrix:", transposed_matrix)

• Sử dụng khả năng hiểu danh sách lồng nhau để tạo ma trận chuyển vị

def transpose_matrix(matrix):
    return list(zip(*matrix))

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
transposed_matrix = transpose_matrix(matrix)
print("Transposed matrix:", transposed_matrix)

11. Kiểm tra xem một chuỗi có phải là một palindrome hay không:

Người bắt đầu:

string = "madam"
is_palindrome = True

for i in range(len(string) // 2):
    if string[i] != string[-(i + 1)]:
        is_palindrome = False
        break

print(f"Is '{string}' a palindrome?:", is_palindrome)
#Is 'madam' a palindrome?: True

• So sánh từng ký tự với ký tự tương ứng từ cuối chuỗi và đặt is_palindromethành Sai nếu chúng không khớp

def is_palindrome(string):
    return string == string[::-1]

string = "madam"
result = is_palindrome(string)
print(f"Is '{string}' a palindrome?:", result)

• Sử dụng cú pháp cắt của Python để đảo ngược chuỗi và so sánh nó với chuỗi ban đầu

Người bắt đầu:

num = 60
prime_factors = []

for i in range(2, num + 1):
    while num % i == 0:
        prime_factors.append(i)
        num = num // i

print("Prime factors:", prime_factors)
#Prime factors: [2, 2, 3, 5]

• Sử dụng vòng lặp while để chia nhiều lần một số cho một thừa số khi nó chia hết
• Nối các thừa số nguyên tố vào danh sách

def prime_factors(num):
    factors = []
    for i in range(2, num + 1):
        while num % i == 0:
            factors.append(i)
            num = num // i
    return factors

num = 60
result = prime_factors(num)
print("Prime factors:", result)

• Sử dụng các vòng lặp lồng nhau để xác định các thừa số nguyên tố và nối chúng vào danh sách

def prime_factors(num):
    factors = []
    i = 2
    while i * i <= num:
        if num % i:
            i += 1
        else:
            num //= i
            factors.append(i)
    if num > 1:
        factors.append(num)
    return factors

num = 60
result = prime_factors(num)
print("Prime factors:", result)

• Sử dụng một vòng lặp while duy nhất để chia nhiều lần số cho ước số nhỏ nhất
• Nối các thừa số nguyên tố vào danh sách và kiểm tra xem số còn lại có lớn hơn 1 để tính thừa số nguyên tố cuối cùng không

Người bắt đầu:

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = []

for sublist in nested_list:
    for item in sublist:
        flat_list.append(item)

print("Flat list:", flat_list)
#Flat list: [1, 2, 3, 4, 5, 6, 7, 8, 9]

• Nối từng mục vào danh sách phẳng mới

def flatten_list(nested_list):
    return [item for sublist in nested_list for item in sublist]

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = flatten_list(nested_list)
print("Flat list:", flat_list)

• Sử dụng khả năng hiểu danh sách lồng nhau để tạo danh sách phẳng

from itertools import chain

def flatten_list(nested_list):
    return list(chain.from_iterable(nested_list))

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat_list = flatten_list(nested_list)
print("Flat list:", flat_list)

• Định nghĩa một hàm flatten_listsử dụng chain.from_iterablehàm để làm phẳng danh sách lồng nhau

Người bắt đầu:

sentence = "apple banana apple kiwi banana apple"
word_count = {}

for word in sentence.split():
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

print("Word count:", word_count)

• Sử dụng vòng lặp for cơ bản để lặp lại các từ và đếm số lần xuất hiện của chúng trong từ điển

from collections import Counter

def count_words(sentence):
    return Counter(sentence.split())

sentence = "apple banana apple kiwi banana apple"
word_count = count_words(sentence)
print("Word count:", word_count)

• Định nghĩa một hàm count_wordssử dụng Counterlớp để đếm tần suất xuất hiện của các từ trong câu

from collections import defaultdict

def count_words(sentence):
    word_count = defaultdict(int)
    for word in sentence.split():
        word_count[word] += 1
    return word_count

sentence = "apple banana apple kiwi banana apple"
word_count = count_words(sentence)
print("Word count:", word_count)

• Định nghĩa một hàm count_wordssử dụng một defaultdict với các giá trị số nguyên để đếm tần suất của các từ
• Sử dụng splitphương thức để mã hóa câu và vòng lặp for để tăng số lượng từ

Người bắt đầu:

def merge_dicts(d1, d2):
    merged_dict = d1.copy()
    merged_dict.update(d2)
    return merged_dict

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

#Merged dictionary: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

• Sử dụng copyphương thức để tạo một bản sao của từ điển đầu tiên và updatephương thức cập nhật từ điển với các cặp khóa-giá trị từ từ điển thứ hai

def merge_dicts(d1, d2):
    return {**d1, **d2}

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

• Sử dụng giải nén từ điển ( **d1, **d2) để hợp nhất các từ điển

from collections import ChainMap

def merge_dicts(d1, d2):
    return dict(ChainMap(d1, d2))

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'d': 4, 'e': 5}
result = merge_dicts(dict1, dict2)
print("Merged dictionary:", result)

• Định nghĩa một chức năng merge_dictsđể hợp nhất hai từ điển
• Sử dụng ChainMaplớp để tạo chế độ xem kết hợp của hai từ điển và chuyển đổi kết quả thành từ điển

Người bắt đầu:

def list_difference(lst1, lst2):
    difference = []
    for item in lst1:
        if item not in lst2:
            difference.append(item)
    return difference

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

#List difference: [1, 2, 3]

• Sử dụng vòng lặp for cơ bản để lặp qua các phần tử trong danh sách đầu tiên và kiểm tra xem mỗi phần tử không có trong danh sách thứ hai hay không
• Nối các phần tử duy nhất vào danh sách khác biệt

def list_difference(lst1, lst2):
    return list(set(lst1) - set(lst2))

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

• Chuyển đổi danh sách thành tập hợp và sử dụng toán tử chênh lệch tập hợp ( -) để tìm các phần tử duy nhất
• Chuyển đổi kết quả trở lại danh sách

def list_difference(lst1, lst2):
    return [item for item in lst1 if item not in set(lst2)]

lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 7, 8]
result = list_difference(lst1, lst2)
print("List difference:", result)

• Sử dụng khả năng hiểu danh sách với một điều kiện để tạo danh sách các phần tử duy nhất
• Chuyển đổi danh sách thứ hai thành một bộ để tối ưu hóa thử nghiệm thành viên

Người bắt đầu:

def create_dict(keys, values):
    result = {}
    for key, value in zip(keys, values):
        result[key] = value
    return result

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

#Dictionary: {'name': 'Alice', 'age': 25, 'gender': 'Female'}

• Sử dụng vòng lặp for có zipchức năng lặp lại đồng thời các khóa và giá trị
• Xây dựng từ điển bằng cách gán từng giá trị cho khóa tương ứng của nó

def create_dict(keys, values):
    return dict(zip(keys, values))

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

• Sử dụng ziphàm để ghép các khóa và giá trị, sau đó sử dụng dicthàm tạo để tạo từ điển

def create_dict(keys, values):
    return {key: value for key, value in zip(keys, values)}

keys = ['name', 'age', 'gender']
values = ['Alice', 25, 'Female']
result = create_dict(keys, values)
print("Dictionary:", result)

• Sử dụng hiểu từ điển với zipchức năng tạo từ điển

Người bắt đầu:

def replace_word(sentence, old_word, new_word):
    return sentence.replace(old_word, new_word)

sentence = "I like apples. Apples are tasty."
old_word = "apples"
new_word = "oranges"
print(replace_word(sentence, old_word, new_word))

#I like oranges. Apples are tasty.

import re

def replace_word(sentence, old_word, new_word):
    return re.sub(r'\b' + old_word + r'\b', new_word, sentence, flags=re.IGNORECASE)

sentence = "I like apples. Apples are tasty."
old_word = "apples"
new_word = "oranges"
print(replace_word(sentence, old_word, new_word))

      
                

                    
                    
                
            

Người bắt đầu:

def mean(numbers):
    return sum(numbers) / len(numbers)

def standard_deviation(numbers):
    avg = mean(numbers)
    return (sum((x - avg) ** 2 for x in numbers) / len(numbers)) ** 0.5

numbers = [1, 2, 3, 4, 5]
print(standard_deviation(numbers))

#1.4142135623730951

import numpy as np

numbers = [1, 2, 3, 4, 5]
print(np.std(numbers))

      
                

                    
                    
                
            

Người bắt đầu:

from sklearn.preprocessing import OneHotEncoder

data = [['apple'], ['banana'], ['orange'], ['apple'], ['banana']]
encoder = OneHotEncoder()
one_hot_encoded = encoder.fit_transform(data).toarray()
print(one_hot_encoded)

import pandas as pd

data = pd.DataFrame({'fruit': ['apple', 'banana', 'orange', 'apple', 'banana']})
one_hot_encoded = pd.get_dummies(data, columns=['fruit'])
print(one_hot_encoded)

      
                

                    
                    
                
            

Người bắt đầu:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = []
odd_numbers = []

for num in numbers:
    if num % 2 == 0:
        even_numbers.append(num)
    else:
        odd_numbers.append(num)

grouped_numbers = {'even': even_numbers, 'odd': odd_numbers}
print("Grouped numbers:", grouped_numbers)
#Grouped numbers: {'even': [2, 4, 6, 8], 'odd': [1, 3, 5, 7, 9]}

• Nối các số chẵn vào even_numbersdanh sách và các số lẻ vào odd_numbersdanh sách
• Nhóm các số vào một từ điển

def group_by_parity(numbers):
    return {
        'even': [num for num in numbers if num % 2 == 0],
        'odd': [num for num in numbers if num % 2 != 0],
    }

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
grouped_numbers = group_by_parity(numbers)
print("Grouped numbers:", grouped_numbers)

• Sử dụng hiểu từ điển và hiểu danh sách để tạo từ điển được nhóm

from collections import defaultdict

def group_by_parity(numbers):
    grouped_numbers = defaultdict(list)
    for num in numbers:
        key = 'even' if num % 2 == 0 else 'odd'
        grouped_numbers[key].append(num)
    return grouped_numbers

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
grouped_numbers = group_by_parity(numbers)
print("Grouped numbers:", grouped_numbers)

• Định nghĩa một hàm group_by_paritysử dụng một defaultdict để nhóm các số theo tính chẵn lẻ của chúng
• Lặp lại các số và nối chúng với khóa thích hợp ('chẵn' hoặc 'lẻ') trong từ điển được nhóm

Người bắt đầu:

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
element_count = {}

for num in numbers:
    if num in element_count:
        element_count[num] += 1
    else:
        element_count[num] = 1

most_common_element = max(element_count, key=element_count.get)
print("Most common element:", most_common_element)

#Most common element: 4

• Sử dụng maxhàm với keyđối số để tìm phần tử phổ biến nhất

from collections import Counter

def most_common_element(lst):
    return Counter(lst).most_common(1)[0][0]

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
result = most_common_element(numbers)
print("Most common element:", result)

• Định nghĩa một hàm `most_common_element` sử dụng lớp `Counter` để đếm số lần xuất hiện của các phần tử trong danh sách

from statistics import mode

def most_common_element(lst):
    return mode(lst)

numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5]
result = most_common_element(numbers)
print("Most common element:", result)

• Định nghĩa một hàm most_common_elementsử dụng modehàm để tìm phần tử phổ biến nhất trong danh sách
• Hàm modetrả về phần tử phổ biến nhất trong danh sách

Người bắt đầu:

def dict_to_tuples(d):
    return [(key, value) for key, value in d.items()]

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

# List of tuples: [('a', 1), ('b', 2), ('c', 3)]

• Sử dụng cách hiểu danh sách với itemsphương thức của từ điển để tạo danh sách các bộ dữ liệu

def dict_to_tuples(d):
    return list(d.items())

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

• Sử dụng itemsphương thức của từ điển để lấy các cặp khóa-giá trị dưới dạng bộ dữ liệu và chuyển đổi kết quả thành danh sách

from operator import itemgetter

def dict_to_tuples(d):
    return sorted(d.items(), key=itemgetter(0))

dictionary = {'a': 1, 'b': 2, 'c': 3}
result = dict_to_tuples(dictionary)
print("List of tuples:", result)

• Định nghĩa một chức năng dict_to_tuplesđể chuyển đổi một từ điển thành một danh sách các bộ dữ liệu
• Sử dụng itemsphương thức của từ điển để lấy các cặp khóa-giá trị dưới dạng bộ dữ liệu và sắp xếp kết quả dựa trên các khóa

Người bắt đầu:

def find_max_min(numbers):
    max_value = max(numbers)
    min_value = min(numbers)
    return max_value, min_value

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

# Maximum value: 5
# Minimum value: 1

• Sử dụng các hàm maxvà mintích hợp để tìm các giá trị lớn nhất và nhỏ nhất

def find_max_min(numbers):
    return max(numbers), min(numbers)

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

• Sử dụng các hàm maxvà mintích hợp sẵn để tìm các giá trị lớn nhất và nhỏ nhất và trả về chúng dưới dạng một bộ

from functools import reduce

def find_max_min(numbers):
    return reduce(lambda acc, x: (max(acc[0], x), min(acc[1], x)), numbers, (float('-inf'), float('inf')))

numbers = [1, 2, 3, 4, 5]
max_value, min_value = find_max_min(numbers)
print("Maximum value:", max_value)
print("Minimum value:", min_value)

• Định nghĩa một hàm find_max_minđể tìm các giá trị lớn nhất và nhỏ nhất trong một danh sách các số
• Sử dụng reducehàm có hàm lambda để tính giá trị lớn nhất và nhỏ nhất bằng cách so sánh từng phần tử với giá trị tích lũy
• Khởi tạo bộ tích lũy với vô cực âm và dương để xử lý các trường hợp cạnh

Người bắt đầu:

def calculate_mean(numbers):
    return sum(numbers) / len(numbers)

def calculate_median(numbers):
    numbers.sort()
    n = len(numbers)
    if n % 2 == 0:
        return (numbers[n // 2 - 1] + numbers[n // 2]) / 2
    else:
        return numbers[n // 2]

def calculate_mode(numbers):
    counts = {}
    for num in numbers:
        if num in counts:
            counts[num] += 1
        else:
            counts[num] = 1
    return max(counts, key=counts.get)

numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
mean = calculate_mean(numbers)
median = calculate_median(numbers)
mode = calculate_mode(numbers)
print(f"Mean: {mean}, Median: {median}, Mode: {mode}")

#Mean: 5.333333333333333, Median: 5.0, Mode: 4

• Hàm calculate_meantìm giá trị trung bình bằng cách chia tổng các số cho độ dài của danh sách.
• Hàm calculate_mediansắp xếp danh sách và tìm (các) phần tử ở giữa để tính trung vị.
• Hàm calculate_modesử dụng một từ điển để đếm số lần xuất hiện của mỗi số và tìm số có số lượng cao nhất.

from statistics import mean, median, mode

def calculate_mean_median_mode(numbers):
    return mean(numbers), median(numbers), mode(numbers)

numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
mean, median, mode = calculate_mean_median_mode(numbers)
print(f"Mean: {mean}, Median: {median}, Mode: {mode}")

• Hàm calculate_mean_median_modetrả về giá trị trung bình, trung vị và chế độ dưới dạng một bộ.

from statistics import mean, median, mode
from typing import List, Tuple

def calculate_mean_median_mode(numbers: List[float]) -> Tuple[float, float, float]:
    return mean(numbers), median(numbers), mode(numbers)

def main():
    numbers = [4, 6, 4, 7, 4, 5, 6, 4, 7, 8, 5, 4]
    mean_val, median_val, mode_val = calculate_mean_median_mode(numbers)
    print(f"Mean: {mean_val}, Median: {median_val}, Mode: {mode_val}")

if __name__ == "__main__":
    main()

• Hàm sử dụng statisticsmô-đun để tính giá trị trung bình, trung bình và chế độ.
• Mã này được tổ chức thành một mainhàm, được gọi khi tập lệnh được thực thi.

Người bắt đầu:

def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    result.extend(list1[i:])
    result.extend(list2[j:])
    return result

list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
merged_list = merge_sorted_lists(list1, list2)
print(merged_list)

• Hàm sử dụng hai con trỏ (i và j) để lặp qua hai danh sách đầu vào và so sánh các phần tử để tạo danh sách được hợp nhất.
• Các phần tử còn lại từ một trong hai danh sách được thêm vào kết quả.

from heapq import merge
from typing import List

def merge_sorted_lists(list1: List[int], list2: List[int]) -> List[int]:
    return list(merge(list1, list2))

def main():
    list1 = [1, 3, 5, 7]
    list2 = [2, 4, 6, 8]
    merged_list = merge_sorted_lists(list1, list2)
    print(merged_list)

if __name__ == "__main__":
    main()

• Chú thích loại được bao gồm cho các tham số đầu vào và loại trả về.
• Mã này được tổ chức thành một mainhàm, được gọi khi tập lệnh được thực thi.

Người bắt đầu:

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

number = 5
result = factorial(number)
print(f"The factorial of {number} is {result}.")
#The factorial of 5 is 120.

• Hàm bao gồm một trường hợp cơ sở khi nbằng 0, trả về 1.
• Trường hợp đệ quy tính giai thừa bằng cách nhân nvới giai thừa của n - 1.

from functools import lru_cache
from typing import Optional

@lru_cache(maxsize=None)
def factorial(n: int) -> Optional[int]:
    if n < 0:
        print("Error: Factorial is not defined for negative numbers.")
        return None
    if n == 0:
        return 1
    return n * factorial(n - 1)

def main():
    number = 5
    result = factorial(number)
    if result is not None:
        print(f"The factorial of {number} is {result}.")
    else:
        print("Could not calculate factorial.")

if __name__ == "__main__":
    main()

• Trình @lru_cachetrang trí được sử dụng để ghi nhớ hàm giai thừa, lưu vào bộ đệm các kết quả trung gian để có hiệu suất tốt hơn.
• Hàm kiểm tra các giá trị đầu vào âm và cung cấp thông báo lỗi cho các đầu vào không hợp lệ.
• Mã này sử dụng mainchức năng này để tổ chức mã và xử lý các trường hợp có thể xảy ra khi không thể tính được giai thừa.

Người bắt đầu:

import pandas as pd

def load_csv(file_path):
    return pd.read_csv(file_path)

file_path = "data.csv"
df = load_csv(file_path)
print(df.head())

• Xác định chức năng load_csvtải tệp CSV vào DataFrame bằng read_csvphương thức từpandas
• In một vài hàng đầu tiên của DataFrame bằng headphương thức

import pandas as pd

def load_csv(file_path, use_cols=None, parse_dates=None):
    return pd.read_csv(file_path, usecols=use_cols, parse_dates=parse_dates)

file_path = "data.csv"
selected_columns = ['column1', 'column3']
date_columns = ['date_column']
df = load_csv(file_path, use_cols=selected_columns, parse_dates=date_columns)
print(df.head())

• Xác định một hàm load_csvvới các tham số tùy chọn use_colsvà parse_datesđể chọn cột và phân tích cột ngày tương ứng
• Tải các cột được chỉ định từ tệp CSV, phân tích cú pháp các cột ngày thành đối tượng ngày giờ
• In một vài hàng đầu tiên của DataFrame

def max_product(arr):
    max_product = float('-inf')
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            product = arr[i] * arr[j]
            if product > max_product:
                max_product = product
    return max_product

arr = [1, 3, 5, 2, 6, 4]
max_product_result = max_product(arr)
print("Maximum product of two integers:", max_product_result)
#30

• Hàm sử dụng các vòng lặp lồng nhau để xem xét tất cả các cặp số nguyên có thể có trong mảng.
• Đối với mỗi cặp, sản phẩm được tính toán và giá trị sản phẩm tối đa được cập nhật tương ứng.

from typing import List

def max_product(arr: List[int]) -> int:
    arr.sort(reverse=True)
    return arr[0] * arr[1]

def main():
    arr = [1, 3, 5, 2, 6, 4]
    max_product_result = max_product(arr)
    print("Maximum product of two integers:", max_product_result)

if __name__ == "__main__":
    main()

• Hàm sắp xếp mảng theo thứ tự giảm dần và trả về tích của hai phần tử đầu tiên, là phần tử lớn nhất.
• Mã được tổ chức với một mainchức năng để có cấu trúc tốt hơn và dễ đọc hơn.

from typing import List
from heapq import nlargest

def max_product(arr: List[int]) -> int:
    largest_nums = nlargest(2, arr)
    return largest_nums[0] * largest_nums[1]

def main():
    arr = [1, 3, 5, 2, 6, 4]
    max_product_result = max_product(arr)
    print("Maximum product of two integers:", max_product_result)

if __name__ == "__main__":
    main()

• Hàm trả về tích của hai số nguyên lớn nhất.
• Mã này được tổ chức thành một mainhàm, được gọi khi tập lệnh được thực thi.

Người bắt đầu:

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

arr = [1, 2, 4, 5, 6, 7, 9, 10]
target = 7
index = binary_search(arr, target)
print(f"Index of {target}:", index)

• Hàm sử dụng một whilevòng lặp để liên tục thu hẹp phạm vi tìm kiếm dựa trên giá trị của phần tử ở giữa.
• Nếu tìm thấy giá trị đích, hàm trả về chỉ mục của phần tử ở giữa; ngược lại, nó trả về -1.

from typing import List
from bisect import bisect_left

def binary_search(arr: List[int], target: int) -> int:
    index = bisect_left(arr, target)
    return index if index != len(arr) and arr[index] == target else -1

def main():
    arr = [1, 2, 4, 5, 6, 7, 9, 10]
    target = 7
    index = binary_search(arr, target)
    print(f"Index of {target}:", index)

if __name__ == "__main__":
    main()

• Hàm kiểm tra xem giá trị mục tiêu có tồn tại ở chỉ mục được tìm thấy hay không và trả về chỉ mục nếu nó khớp với mục tiêu; ngược lại, nó trả về -1.
• Mã này được tổ chức thành một mainhàm, được gọi khi tập lệnh được thực thi.

Các lập trình viên mới bắt đầu tập trung vào các khái niệm cơ bản và cú pháp cơ bản, các lập trình viên trung cấp giới thiệu các tối ưu hóa và mã mô-đun, trong khi các lập trình viên chuyên nghiệp tận dụng các kỹ thuật nâng cao, xử lý lỗi, tổ chức mã và độ bền tổng thể. Để tìm hiểu thêm xin vui lòng kiểm tra các tài liệu tham khảo.

Người giới thiệu:

1. Tài liệu chính thức của Python.org:
   Liên kết:https://docs.python.org/3/tutorial/index.html
2. Khóa học Python của Codecademy:
   Liên kết:https://www.codecademy.com/learn/learn-python-3
3. Coursera's Python cho mọi người:
   Liên kết:https://www.coursera.org/specializations/python
4. Lớp Python của Google:
   Liên kết:https://developers.google.com/edu/python
5. LeetCode:
   Liên kết:https://leetcode.com
6. HackerRank:
   Liên kết:https://www.hackerrank.com/domains/tutorials/10-days-of-python
7. Codewars:
   Liên kết:https://www.codewars.com
8. Tràn ngăn xếp:
   Liên kết:https://stackoverflow.com/questions/tagged/python
9. Cộng đồng Python Reddit (r/Python):
   Liên kết:https://www.reddit.com/r/Python/
10. Cộng đồng bất hòa Python:
    Liên kết:https://pythondiscord.com

Cảm ơn vì đã là một phần của cộng đồng của chúng tôi! Trước khi bạn đi:

• Vỗ tay cho truyện và theo dõi tác giả
• Xem thêm nội dung trong ấn phẩm Level Up Coding
• Khóa học phỏng vấn mã hóa miễn phí ⇒ Xem khóa học
• Theo dõi chúng tôi: Twitter | LinkedIn | bản tin