import module_name

import module_name as alias_name

from module_name import function_name/variable_name

type(variable_name)

new_variable = required_type(variable_name)

isinstance(variable_name, required_type)

new_string = origin_string.lower()/origin_string.upper()

new_string = ''.join(list/tuple)

new_list = origin_string.split(split_char)

list_name.append(new_element)

list_name[position_index]

list_name.reverse()

dictionary_name[key_name]

dictionary_name[new_key] = new_value

del dictionary_name[key_name]

for element in list_name:
    # do something with element

for key, value in dictionary_name.items():
    # do something with key and value

for index, element in enumerate(list_name):
    # do something with index and element

def function_name(argument1, argument2, ...):
    # do something
    return result

def function_name(argument1, argument2=default_value):
    # do something
    return result

function_name(argument1=value1, argument2=value2)

try:
    # do something
except ExceptionType as e:
    # handle exception

raise ExceptionType('exception message')

try:
    # do something
except ExceptionType:
    # handle exception
finally:
    # clean up

file_handler = open(file_path, mode='r'/'w'/'a')
file_content = file_handler.read()  # or file_handler.write(content)
file_handler.close()

file_content = file_handler.readlines()  # or file_handler.writelines(lines_list)

import os
os.chdir(target_directory)

import datetime
current_datetime = datetime.datetime.now()

formatted_string = datetime.datetime.strftime(origin_datetime, format_str)

import datetime
time_delta = datetime.datetime(end_year, end_month, end_day) - datetime.datetime(start_year, start_month, start_day)

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

from flask import request
arg_value = request.args.get('arg_name')

from flask import jsonify
return jsonify({'key1': value1, 'key2': value2, ...})

import pandas as pd
data_frame = pd.read_csv(file_path)

selected_rows = data_frame.loc[data_frame['column_name'] == selected_value]

aggregated_data = data_frame.groupby(['column1', 'column2'])['column3'].agg(['count', 'mean'])

from sklearn import preprocessing
scaler = preprocessing.StandardScaler().fit(data)
scaled_data = scaler.transform(data)

from sklearn import linear_model
model = linear_model.LinearRegression()
model.fit(X_train, y_train)

from sklearn import metrics

# evaluate model
y_pred = model.predict(X_test)
mse = metrics.mean_squared_error(y_test, y_pred)

# optimize model
param_grid = {'alpha': [0.1, 1, 10]}
grid_search = GridSearchCV(linear_model.Ridge(), param_grid)
grid_search.fit(X_train, y_train)

import requests
response = requests.get(url)

from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc, 'html.parser')
element = soup.find('tag_name', {'attr_name': 'attr_value'})

import re
pattern = re.compile(r'regex_pattern')
match = pattern.search(text)

import tkinter as tk

root = tk.Tk()
label = tk.Label(root, text='Hello, World!')
button = tk.Button(root, text='Click', command=clicked)

root.mainloop()

def clicked():
    # do something after button is clicked
button = tk.Button(root, text='Click', command=clicked)

entry = tk.Entry(root)  # for single line text input
text = tk.Text(root)  # for multi-line text input and output

from PIL import Image
image = Image.open(image_file_path)
image.save(new_image_file_path)

resized_image = image.resize(new_size)
cropped_image = image.crop(crop_box)

from PIL import ImageDraw
draw = ImageDraw.Draw(image)
draw.text(text_point, text_content)  # for text
draw.rectangle(box, outline='blue', width=3)  # for rectangle

import tensorflow as tf

x = tf.placeholder(tf.float32, [None, input_size])
W = tf.Variable(tf.zeros([input_size, output_size]))
b = tf.Variable(tf.zeros([output_size]))
y = tf.nn.softmax(tf.matmul(x, W) + b)

# loss function and training
y_ = tf.placeholder(tf.float32, [None, output_size])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)

# model evaluation
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

from keras.models import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Dense(hidden_size, activation='relu', input_dim=input_size))
model.add(Dense(output_size, activation='softmax'))

model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])

model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size)
score = model.evaluate(X_test, y_test, batch_size=batch_size)

import cv2

image = cv2.imread(image_file_path)
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
edges_image = cv2.Canny(gray_image, threshold1, threshold2)

# contours detection
contours, hierarchy = cv2.findContours(edges_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(image, contours, -1, (0,255,0), 3)

# face detection
face_cascade = cv2.CascadeClassifier(face_cascade_file_path)
faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
for (x,y,w,h) in faces:
    cv2.rectangle(image, (x,y), (x+w,y+h), (255,0,0), 2)