Повысьте свою производительность с помощью этих экономящих время решений на Python
За последние пять лет Python был моим надежным инструментом для решения всевозможных ежедневных задач. Будь то оптимизация задач, упрощение рабочих процессов или разрешение сложных вопросов программирования, Python постоянно демонстрирует отличные результаты. В последнее время я оттачиваю свои навыки программирования и открываю техники и трюки, которые действительно увеличивают мою продуктивность. В этом блоге мне интересно поделиться наиболее полезными фрагментами кода на Python, которые помогают мне справляться с повседневными проблемами.
Как сказал великий Билл Гейтс:
“Я выбираю ленивого человека для выполнения сложной работы, потому что ленивый человек найдет простой способ сделать это.”
Зачем изобретать велосипед, если эти фрагменты кода на Python могут упростить вашу работу и сэкономить время?
1. Доступ к определенному листу в файле Excel с помощью Pandas
Во время работы с файлами Excel вам может потребоваться работать с данными конкретного листа. Pandas упрощает эту задачу, позволяя вам указывать конкретный лист при загрузке ваших данных.
import pandas as pd
# Load a specific sheet from an Excel file
df = pd.read_excel('your_file.xlsx', sheet_name='Sheet2')
# Display the DataFrame
print(df)2. Быстро установить столбец «Дата» в качестве индекса
Вы можете заменить индекс на столбец с датами с помощью метода set_index(), чтобы упростить анализ данных временных рядов.
df.set_index(df['Date'],drop=True)3. Получить количество пропущенных значений в каждом столбце
Обработка пропущенных данных — это распространенная задача при работе с большими наборами данных. Этот код позволит вам быстро получить количество пропущенных значений в каждом столбце, что облегчит идентификацию неполных данных и поможет принять решение о том, как с ними справиться.
import pandas as pd
df = pd.read_csv('data.csv')
missing_values_count = df.isnull().sum()
print("Count of Missing Values in Each Column:")
print(missing_values_count)4. Объединение двух словарей
Это пригодится, когда вы работаете с базами данных или файлами JSON и вам нужно объединить данные из разных источников. Объединение словарей может привести к конфликту, если один и тот же ключ существует в нескольких словарях. В таких случаях вы можете выбрать значение из второго словаря, чтобы переопределить первое, как показано ниже.
basic_information = {"name":['karl','Lary'],"mobile":["0134567894","0123456789"]}
academic_information = {"name": ["Zara", "Alex"], "grade":["A","B"]}
# Dictionary Comprehension Method
details = {key: value for data in (basic_information, academic_information) for key,value in data.items()}
print(details)
# Dictionary unpacking
details = {**basic_information ,**academic_information}
print(details)
# Copy and Update Method
details = basic_information.copy()
details.update(academic_information)
print(details)
# Using | Operator
details = basic_information | academic_information
print(details)
"""OUTPUT"""
{'name': ['Zara', 'Alex'], 'mobile': ['0134567894', '0123456789'], 'grade': ['A', 'B']}
{'name': ['Zara', 'Alex'], 'mobile': ['0134567894', '0123456789'], 'grade': ['A', 'B']}
{'name': ['Zara', 'Alex'], 'mobile': ['0134567894', '0123456789'], 'grade': ['A', 'B']}
{'name': ['Zara', 'Alex'], 'mobile': ['0134567894', '0123456789'], 'grade': ['A', 'B']}5. Сортировка списка строк
Может быть полезно, когда у вас есть список, содержащий имена студентов, города и т.д., и вы хотите отсортировать все имена.
list1 = ["Karl","Robert","Jenny","Zuck"]
# Method 1: sort() : Modifies current list.
list1.sort()
# Method 2: sorted(): Creates a new list containing sorted version.
sorted_list = sorted(list1)
# Method 3: Brute Force Method (Not Recommended)
size = len(list1)
for i in range(size):
for j in range(size):
if list1[i] < list1[j]:
temp = list1[i]
list1[i] = list1[j]
list1[j] = temp
print(list1)6. Оптимизированные присваивания
Мы часто сталкиваемся с ситуациями, когда необходимо присвоить значение переменной в рамках выражения, но выполнение этого в несколько этапов может показаться неэффективным. Оператор моржа (:=) решает эту проблему, позволяя выполнять присваивание непосредственно внутри выражения. Это особенно полезно при оптимизации кода в циклах или условиях, что снижает избыточность и улучшает читаемость.
Этот небольшой, но мощный оператор может помочь вам писать более лаконичный и элегантный код в повседневных задачах, таких как проверка условий при одновременном обновлении значений.
# Example 1
## Reading lines from a file until an empty line is encountered
with open('myfile.txt') as file:
while (line := file.readline().rstrip()):
print(line)
# Example: 2
## Using the walrus operator to both assign and filter user data
user_data = [
{"name": "Alice", "age": 30, "email": "alice@example.com"},
{"name": "Bob", "age": 24, "email": "bob@example.com"},
{"name": "Charlie", "age": 28, "email": "charlie@example.com"},
{"name": "David", "age": 35, "email": "david@example.com"}
]
### Filter users who are at least 30 years old and extract their email addresses
emails_of_older_users = [email for user in user_data if (age := user['age']) >= 30 and (email := user['email'])]
print(emails_of_older_users)
"""Output"""
['alice@example.com', 'david@example.com']7. Генерация списков с if и else
Этот фрагмент кода полезен, когда вы хотите создавать или преобразовывать списки, эффективно применяя условную логику.
# Generate FizzBuzz list using list comprehension (if & else)
fizzbuzz = ["FizzBuzz" if i % 3 == 0 and i % 5 == 0 else "Fizz" if i % 3 == 0 else "Buzz" if i % 5 == 0 else str(i) for i in range(1, 15)]
# Print the results
for item in fizzbuzz:
print(item,end = ' ')
""" OUTPUT """
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14
# Generic (IF)
By_7 = ['Divided by 7' if i%7==0 else i for i in range(1,20)]
print('\n',By_7)
""" OUTPUT """
[1, 2, 3, 4, 5, 6, 'Divided by 7', 8, 9, 10, 11, 12, 13, 'Divided by 7', 15, 16, 17, 18, 19]8. Проверка на анаграмму
Анаграмма — это слово, которое образуется путем перестановки букв другого слова, используя все оригинальные буквы ровно один раз.
def check_anagram(first_word, second_word):
return sorted(first_word) == sorted(second_word)
print(check_anagram("silent", "listen")) # True
print(check_anagram("ginger", "danger")) # False9. Преобразование двух списков в словарь
При работе с двумя связанными списками — такими как ключи и значения — часто возникает необходимость объединить их в словарь для упрощения поиска или организации. Этот фрагмент кода решает повседневную задачу преобразования двух списков в словарь, упрощая ваши данные в пары “ключ-значение”.
list1 = ['karl','lary','keera']
list2 = [28934,28935,28936]
# Method 1: zip()
dictt0 = dict(zip(list1,list2))
# Method 2: dictionary comprehension
dictt1 = {key:value for key,value in zip(list1,list2)}
# Method 3: Using a For Loop (Not Recommended)
tuples = zip(list1, list2)
dictt2 = {}
for key, value in tuples:
if key in dictt2:
pass
else:
dictt2[key] = value
print(dictt0, dictt1, dictt2, sep = "\n")
""" OUTPUT """
{'karl': 28934, 'lary': 28935, 'keera': 28936}
{'karl': 28934, 'lary': 28935, 'keera': 28936}
{'karl': 28934, 'lary': 28935, 'keera': 28936}10. Подсказки типов для улучшения качества кода
Подсказки типов помогают сделать код более читаемым, понятным и удобным для сопровождения.
from typing import List, Union
def analyze_data(data: List[Union[int, str, float]]) -> None:
for entry in data:
if isinstance(entry, int):
print(f"Analyzing integer: {entry}")
elif isinstance(entry, str):
print(f"Analyzing string: {entry}")
analyze_data(["cherry", 123, "mango", 4.21])
'''
List: Specifies that data is a list.
Union[int, str,float]: Indicates that each element in the list can be either an integer, float or a string, meaning no Boolean (Yes, No) is allowed.
-> None: This part of the annotation indicates that the function does not return any value (i.e., it returns None).
'''11. Сложение элементов двух списков
Допустим, у вас есть два списка, и вы хотите объединить их элементы, складывая соответствующие элементы. Это может быть полезно, когда вам нужно эффективно агрегировать или объединять данные из различных источников.
maths = [59, 64, 75, 86]
physics = [78, 98, 56, 56]
# Brute Force Method
list1 = [
maths[0]+physics[0],
maths[1]+physics[1],
maths[2]+physics[2],
maths[3]+physics[3]
]
# List Comprehension
list1 = [x + y for x,y in zip(maths,physics)]
# Using Maps
import operator
all_devices = list(map(operator.add, maths, physics))
# Using Numpy Library
import numpy as np
list1 = np.add(maths,physics)
'''Output
[137 162 131 142]
'''12. Использование контекстного менеджера для управления ресурсами
Контекстные менеджеры в Python — это удобный способ управления ресурсами, например, открытия и закрытия файлов, с минимальными затратами кода. Они обеспечивают надлежащую очистку ресурсов после использования. Пользовательские контекстные менеджеры могут быть созданы с помощью модуля contextlib, который упрощает этот процесс.
from contextlib import contextmanager
import sqlite3
@contextmanager
def db_connection(db_name):
connection = sqlite3.connect(db_name)
try:
yield connection
finally:
connection.close()
# Usage
with db_connection('mydatabase.db') as conn:
cursor = conn.cursor()
cursor.execute('SELECT * FROM my_table')
rows = cursor.fetchall()
for row in rows:
print(row)13. Упрощение запоминания с помощью functools.cache
В Python 3.9 и более поздних версиях декоратор functools.cache предоставляет простой способ реализации запоминания. Запоминание — это метод сохранения результатов дорогостоящих вызовов функций и их повторного использования при повторном использовании одних и тех же входных данных. Cache decorator автоматически обрабатывает это, кэшируя возвращаемые значения функций, что упрощает реализацию запоминания.
import time
from functools import cache
# Function without caching
def fibonacci_no_cache(n):
return n if n <= 1 else fibonacci_no_cache(n - 1) + fibonacci_no_cache(n - 2)
# Function with caching
@cache
def fibonacci_with_cache(n):
return n if n <= 1 else fibonacci_with_cache(n - 1) + fibonacci_with_cache(n - 2)
# Measure time for non-cached version
start_time = time.time()
fibonacci_no_cache(30)
print(f"Time without cache: {time.time() - start_time:.4f} seconds")
# Measure time for cached version
start_time = time.time()
fibonacci_with_cache(30)
print(f"Time with cache: {time.time() - start_time:.4f} seconds")
интересный вопрос для интервью….
14. Часто задаваемый вопрос на собеседовании для начинающих: Создайте простой калькулятор, не используя условные конструкции if/else.
## METHOD: 1 (Using the operator module)
import operator
action = {
"+" : operator.add,
"-" : operator.sub,
"/" : operator.truediv,
"*" : operator.mul,
"**" : pow
}
print(action['/'](37, 5)) # 7.4
## METHOD: 2 (Using eval())
def calculator(a, b, operation):
return eval(f"{a} {operation} {b}")
print(calculator(37,5,'/')) # 7.4
## METHOD: 3 (Using Match & Case)
def calculator(a, b, operation):
match operation:
case '+':
return a + b
case '-':
return a - b
case '*':
return a * b
case '/':
return a / b
case _:
return "Invalid operation"
print(calculator(37,5,'/')) # 7.415. Рекурсивные функции для обхода дерева
Рекурсия — это мощный инструмент для обхода древовидных структур данных. Распространенным вариантом использования является обход дерева, при котором вы посещаете каждый узел в определенном порядке.
class Node:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
# Pre-order traversal: Root -> Left -> Right
def preorder_traversal(root):
if root:
print(root.value, end=" ")
preorder_traversal(root.left)
preorder_traversal(root.right)
# Example tree
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
# Call the traversal
preorder_traversal(root)16. Быстрый тест на сходство строк
Иногда, когда вы имеете дело с пользовательским вводом или совпадающими строками, вам может потребоваться сравнить сходство между двумя строками. Модуль difflib в Python позволяет легко измерить сходство и найти совпадающие части.
import difflib
# Two similar strings with minor differences
str1 = "Raman Noodels"
str2 = "Spicy Raman Noodels"
# Calculate similarity ratio
similarity_ratio = difflib.SequenceMatcher(None, str1, str2).ratio()
print(f"Similarity Ratio: {similarity_ratio}")17. Итерация по итератам разной длины с использованием zip_longest
Функция zip_longest является частью модуля itertools в Python и используется для параллельной итерации по нескольким итерируемым объектам, заполняя отсутствующие значения указанным значением, если итерируемые объекты имеют разную длину. Это может быть особенно полезно, когда необходимо работать с последовательностями различной длины и избежать потери данных или возникновения ошибок из-за несоответствия длин.
from itertools import zip_longest
# Example logs from different systems
logins = ['2024-01-01 08:00', '2024-01-01 09:30', '2024-01-01 10:15']
purchases = ['2024-01-01 08:05', '2024-01-01 10:20']
messages = ['2024-01-01 08:10']
# Combine logs with missing entries filled with 'No Data'
combined_logs = list(zip_longest(logins, purchases, messages, fillvalue='No Data'))
# Print the combined logs
for index, (login, purchase, message) in enumerate(combined_logs, start=1):
print(f"Entry {index}: Login: {login}, Purchase: {purchase}, Message: {message}")18. Динамическое создание функций
Функция exec() в Python позволяет выполнять динамический код на Python, включая создание функций во время выполнения. Это может быть полезно для генерации кода на основе переменных входных данных или конфигураций.
# Define the dynamic code as a string
function_code = """
def dynamic_operation(x, y):
return x {operator} y
"""
# User input for the operator
operator = '+'
# Use exec to create the function with the operator
exec(function_code.format(operator=operator))
# Call the dynamically created function
result = dynamic_operation(10, 5)
print("Result of 10 {0} 5: {1}".format(operator, result))
"""OUTPUT""
Result of 10 + 5: 1519. Выполнение структурного сопоставления шаблонов
Python 3.10 представил мощную функцию, называемую структурным сопоставлением шаблонов. Эта функция позволяет использовать более выразительную и читаемую условную логику, сопоставляя шаблоны со структурами данных. Оператор match предоставляет способ проверки и деструктивного сопоставления данных, что упрощает работу с комплексными условиями и сценариями.
def describe_shape(shape):
match shape:
case {"type": "circle", "radius": radius}:
print(f"A circle with radius {radius}")
case {"type": "rectangle", "width": width, "height": height}:
print(f"A rectangle with width {width} and height {height}")
case {"type": "triangle", "a": a, "b": b, "c": c}:
print(f"A triangle with sides {a}, {b}, and {c}")
case _:
print("Unknown shape")
# Test cases
describe_shape({"type": "circle", "radius": 5})
describe_shape({"type": "rectangle", "width": 10, "height": 20})
describe_shape({"type": "triangle", "a": 3, "b": 4, "c": 5})
describe_shape({"type": "hexagon"})20. LinkShort
URL (Унифицированный указатель ресурса) — это адрес уникального ресурса в Интернете. URL состоит из пяти частей: схема, подсеть, домен верхнего уровня, домен второго уровня и подпапка. Не все URL содержат все пять частей, но те, которые их содержат, становятся слишком длинными и трудными для обмена.
import pyshorteners
url = input("Enter your url: ")
print("Your url: ", pyshorteners.Shortener().tinyurl.short(url))
"""
Your url: https://tinyurl.com/2zsb85wx
"""21. Множества Frozenset для неизменяемого хранения данных
Множества Frozenset — это неизменяемые версии множеств. Они полезны, когда вам нужна структура, похожая на множество, которая не может быть изменена после создания. Несмотря на свою неизменяемость, они все равно поддерживают операции, такие как объединение, пересечение и разность.
# Creating a frozenset
my_frozenset = frozenset([1, 2, 3, 4])
# Attempting to modify it will raise an error
try:
my_frozenset.add(5)
except AttributeError as e:
print(f"Error: {e}")
# Frozenset supports operations like union and intersection
another_set = frozenset([3, 4, 5, 6])
union_set = my_frozenset | another_set
print(f"Union: {union_set}")
intersection_set = my_frozenset & another_set
print(f"Intersection: {intersection_set}")Это особенно полезно в сценариях, где вам нужен набор уникальных элементов, которые должны оставаться неизменными, например, при определенных стратегиях кэширования или запоминания.
22. Увеличение изображений для генерации данных
Данные — ключ к каждой модели машинного обучения. Чем лучше данные, тем лучше будет работать наша модель. Существует простое правило для повышения производительности модели — собирать больше данных. Но на практике это не так просто, особенно когда речь идет об изображениях.
from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
datagen = ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
brightness_range= [0.5, 1.5],
rescale=1./255,
shear_range=0.2,
zoom_range=0.4,
horizontal_flip=True,
fill_mode='nearest',
zca_epsilon=True)
path = '/content/drive/MyDrive/cat.jpg' ## Image Path
img = load_img(f"{path}")
x = img_to_array(img)
x = x.reshape((1,) + x.shape)
i = 0
### Create 25 Augmentated Images and Save Them In `aug_img` directory
for batch in datagen.flow(x, batch_size=1,
save_to_dir="/content/drive/MyDrive/aug_imgs", save_prefix='img', save_format='jpeg'):
i += 1
if i > 25: ## Total 25 Augmented Images
break
23. Планировщик скорости обучения для оптимизированного обучения
Планировщик скорости обучения регулирует скорость обучения, помогая моделям быстрее сходиться и избегать превышения минимума в функции потерь.
from tensorflow.keras.callbacks import LearningRateScheduler
# Define a custom learning rate schedule
def scheduler(epoch, lr):
if epoch < 10:
return lr
else:
return lr * 0.1
# Add the scheduler to the model training process
callback = LearningRateScheduler(scheduler)
model.compile(optimizer='adam', loss='categorical_crossentropy')
model.fit(train_data, train_labels, epochs=20, callbacks=[callback])24. Параллельная обработка с помощью concurrent.futures
Модуль concurrent.futures позволяет выполнять несколько задач параллельно, повышая производительность операций, связанных с центральным процессором.
import concurrent.futures
import time
# Example function
def slow_task(n):
time.sleep(n)
return f"Task {n} finished"
# Run tasks in parallel
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = [executor.submit(slow_task, i) for i in range(5)]
for future in concurrent.futures.as_completed(futures):
print(future.result())25. Быстрый анализ тональности
При работе с текстовыми данными иногда нам просто хочется проверить распределение тональности в определенном тексте. Textbox в Python — это как раз та идеальная библиотека, которая поможет вам в этом.
from textblob import TextBlob
text = "I love using this product, it's amazing!"
blob = TextBlob(text)
# Analyze sentiment polarity (-1 = negative, 1 = positive)
sentiment = blob.sentiment.polarity
print(f"Sentiment polarity: {sentiment}")26. Обработка отсутствующих данных
Отсутствующие данные часто встречаются в реальных наборах данных. Библиотека pandas предлагает различные методы для эффективной обработки пропущенных значений.
## Sample Dataset
import pandas as pd
import numpy as np
data = {'A': [1, 2, np.nan, 4, 5], 'B': [np.nan, 2, 3, np.nan, 5], 'C': [1, np.nan, np.nan, 4, 5]}
df = pd.DataFrame(data)
""" Different Methods 🤠"""
# 1. Fill with Mean ➡ (useful for continuous data)
df.fillna(df.mean())
# 2. Fill with Median ➡ (better for skewed distributions)
df.fillna(df.median())
# 3. Fill with Mode ➡ (best for categorical data)
df.fillna(df.mode().iloc[0])
# 4. Fill with Custom Value ➡ (Best when value distribution is known)
df.fillna(0)
# 5. Forward Fill (ffill) ➡ (useful for time series)
df.fillna(method='ffill')
# 6. Backward Fill (bfill) ➡ (When forward fill isn't appropriate)
df.fillna(method='bfill')
# 7. Interpolation ➡ (ideal for continuous and time series data)
df.interpolate()
# 8. Drop Missing Values ➡ (useful when missing data is sparse or insignificant)
df_dropped = df.dropna()
# 9. Using Custom Libraries (when you need more flexibility in pipelines)
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df_sklearn = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)27. Загружайте все изображения с веб-страницы
При работе над проектами машинного обучения или веб-скрейпинга одной из распространенных задач является загрузка больших наборов изображений для обучающих наборов данных. Загрузка этих изображений вручную, особенно если они разбросаны по веб-странице, может занять много времени и быть неэффективной.
import requests
from bs4 import BeautifulSoup
import os
url = 'https://example.com'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
img_tags = soup.find_all('img')
if not os.path.exists('images'):
os.makedirs('images')
for img in img_tags:
img_url = img['src']
img_data = requests.get(img_url).content
img_name = os.path.join('images', img_url.split('/')[-1])
with open(img_name, 'wb') as img_file:
img_file.write(img_data)28. Создание облаков слов из текста
Когда-нибудь работали над отчетом или набором данных, где вам нужно было быстро понять самые распространенные термины? Облака слов — это отличный способ визуально отобразить частоту слов в текстовом документе, позволяя вам сразу увидеть, какие слова или темы доминируют в обсуждении.
Это особенно полезно в текстовом анализе, создании контента и составлении отчетов по данным. Независимо от того, анализируете ли вы отзывы клиентов, новостные статьи или документацию кода, создание облака слов может помочь вам быстро выявить тенденции.
from wordcloud import WordCloud
import matplotlib.pyplot as plt
text = "Python is simple, readable, and powerful."
wordcloud = WordCloud(width=800, height=400).generate(text)
plt.figure(figsize=(8, 4))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()29. Поиск файлов по расширению
При управлении большими наборами данных или работе с большим количеством файлов в проекте поиск определенных файлов по их расширению (например, .csv, .jpg) может стать повторяющейся задачей. Этот фрагмент позволяет легко просканировать каталог и найти все файлы с определенным расширением.
import os
directory = 'path/to/directory'
extension = '.csv'
files = [f for f in os.listdir(directory) if f.endswith(extension)]
print(files)30. Перенос обучения с помощью Keras (предварительно обученной модели)
Машинное обучение становится стандартным инструментом для многих задач, но обучение моделей с нуля часто требует огромных объемов данных и вычислительных мощностей. Передача обучения решает эту проблему, позволяя вам взять предобученную модель и донастроить ее под вашу задачу.
from tensorflow.keras.applications import VGG16
from tensorflow.keras import layers, models
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
model = models.Sequential([
base_model,
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(1, activation='sigmoid')
])
# Fine-tune model
base_model.trainable = False
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Model training
# model.fit(train_data, train_labels, epochs=10)31. Извлечение ключевых слов из текста (алгоритм RAKE)
В таких областях, как создание контента, SEO и анализ данных, понимание основных тем документа имеет важное значение. Вместо того чтобы вручную просматривать абзацы текста, вы можете автоматизировать процесс извлечения ключевых слов с помощью алгоритма RAKE (Быстрое Автоматическое Извлечение Ключевых Слов).
Он идеально подходит для таких задач, как генерация ключевых слов для SEO, резюмирование текстов для научных статей или просто получение быстрого обзора основных пунктов статьи.
from rake_nltk import Rake
text = "Python is a powerful programming language. It is widely used for web development, data science, and more."
r = Rake()
r.extract_keywords_from_text(text)
keywords = r.get_ranked_phrases()
print(keywords)32. Изменение размера всех изображений в директории
Изменение размера изображений — это общая задача в веб-разработке, предварительной обработке данных или при управлении файлами изображений для повышения производительности и согласованности. Часто необходимо убедиться, что все изображения в директории изменены до заданных размеров для обеспечения однородности. Это особенно полезно при загрузке изображений на сайт или подготовке их для моделей машинного обучения, которые требуют фиксированного размера входных данных.
from PIL import Image
import os
input_folder = 'path/to/images'
output_folder = 'path/to/resized_images'
new_size = (800, 800)
# Create output folder if it doesn't exist
if not os.path.exists(output_folder):
os.makedirs(output_folder)
# Resize all images in the input folder
for filename in os.listdir(input_folder):
if filename.endswith(('.png', '.jpg', '.jpeg')):
img_path = os.path.join(input_folder, filename)
img = Image.open(img_path)
img_resized = img.resize(new_size)
img_resized.save(os.path.join(output_folder, filename))
print("All images resized successfully!")33. Профилирование и оптимизация производительности кода
Это общая задача в веб-разработке, предварительной обработке данных или при управлении файлами изображений для повышения производительности и согласованности. Часто необходимо убедиться, что все изображения в директории изменены до заданных размеров для обеспечения однородности. Это особенно полезно при загрузке изображений на сайт или подготовке их для моделей машинного обучения, которые требуют фиксированного размера входных данных.
## Sample Code Snippet
import cProfile
import math
# Check if a number is prime
def is_prime(n):
if n < 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
# Function to get prime numbers from a list
def find_primes(limit):
primes = []
for n in range(limit):
if is_prime(n):
primes.append(n)
return primes
# Large limit to simulate a heavy operation
def process_data():
print("Processing primes up to 100,000...")
primes = find_primes(100000)
print(f"Found {len(primes)} prime numbers")
# Use cProfile to profile this process
if __name__ == "__main__":
cProfile.run('process_data()')Используйте cProfile, чтобы выявить медленные части вашего кода. Независимо от того, создаете ли вы веб-приложение, конвейер обработки данных или модель машинного обучения, определение узких мест помогает стратегически оптимизировать производительность.
Обсуждение закрыто.