**criando 8 coordenadas:**

from random import choice

sinais = set()
while True:
for _ in range(4):
sinais.add((choice([1,-1]), choice([1,-1])))
if len(sinais) == 4:
break
else:
sinais = set()
sinais_2 = set()
while True:
for _ in range(4):
escolha = (choice([1,-1,0]), choice([1,-1,0]))
if escolha == (0, 0):
break
elif escolha in sinais:
break
else:
sinais_2.add(escolha)
if len(sinais_2) == 4:
break
else:
sinais_2 = set()

todos_sinais = sinais.union(sinais_2)

------------------------------------

**salvar um script python:**

%%writefile simple1.py

------------------------------------

**calcula o uso de mémoria de uma função:**

from memory_profiler import memory_usage

memory_usage((f), max_usage=True)

------------------------------------

**cria um frame:**

import cv2
import numpy as np

# Cria uma imagem em branco

img = np.zeros((200, 200, 3), dtype=np.uint8)

# Loop para criar frames

for i in range(5):
# Pinta a imagem de uma cor diferente em cada frame
img[:, :] = np.random.randint(0, 256, size=(200, 200, 3), dtype=np.uint8)
 # Converte a imagem para o tipo de dados adequado
img_display = img.astype(np.uint8)

# Exibe a imagem
cv2.imshow('Frame', img_display)

# Aguarda um breve período (milissegundos)

cv2.waitKey(500)

# Fecha a janela ao final

cv2.destroyAllWindows()

------------------------------------

**cria um gráfico:**

import plotly.express as px

fig = px.scatter(x=inds_estrela_unica_angulos[:,0],
y=inds_estrela_unica_angulos[:,1], text=np.round(inds_estrela_unica_angulos[:,-2],
2))

fig.add_trace(px.scatter(x=centro_estrela_unica[:,0], y=centro_estrela_unica[:,1],
color_discrete_sequence=['green']).data[0])

fig.update_traces(marker=dict(size=3), textposition='top center')

# alteração no tamanho do 'marcador' individualmente:

# fig.data[1]['marker']['size'] = 10

fig.update_layout(xaxis=dict(scaleanchor="y", scaleratio=1),
yaxis=dict(scaleanchor="x", scaleratio=1))

fig.update_layout(
margin=dict(l=20, r=20, t=20, b=20),
paper_bgcolor="LightSteelBlue",
width = 600
)

fig.show()

------------------------------------

**criar pasta:**

import os

# Especificar o caminho da nova pasta

for i in range(10):
caminho_nova_pasta = f"C:\\Users\\marco\\amostras\\numbers\\big\\{i}" #
Substitua pelo caminho desejado

# Tente criar a nova pasta

try:
os.mkdir(caminho_nova_pasta)
print(f"Pasta '{caminho_nova_pasta}' criada com sucesso!")
except FileExistsError:
print(f"A pasta '{caminho_nova_pasta}' já existe.")
 except Exception as e:
print(f"Erro ao criar a pasta: {e}")

---------------------------------------------------

**mover aquivos:**

import shutil
dirs = os.listdir('C:\\Users\\marco\\amostras\\numbers\\big')
for i in range(10):
for j in dirs:
if str(i) == j[0]:
caminho_do_arquivo = f"C:\\Users\\marco\\amostras\\numbers\\big\\{j}"
# Substitua pelo caminho real do arquivo
caminho_destino = f"C:\\Users\\marco\\amostras\\numbers\\big\\{i}" #
Substitua pelo caminho real da pasta de destino

# Tente mover o arquivo para a pasta de destino

try:
shutil.move(caminho_do_arquivo, caminho_destino)
print(f"Arquivo '{caminho_do_arquivo}' movido para
'{caminho_destino}' com sucesso!")
except FileNotFoundError:
print(f"O arquivo '{caminho_do_arquivo}' não foi encontrado.")
except Exception as e:
print(f"Erro ao mover o arquivo: {e}")

----------------------------------------

**renomear arquivos:**

import os

caminho_dos_arquivos = "C:\\Users\\marco\\amostras\\numbers\\small" # Substitua

pelo caminho real do diretório

# Listar os arquivos no diretório

arquivos = os.listdir(caminho_dos_arquivos)

# Iterar sobre os arquivos e renomear

for arquivo in arquivos:
caminho_antigo = os.path.join(caminho_dos_arquivos, arquivo)
caminho_novo = os.path.join(caminho_dos_arquivos, arquivo + 'mudança')

# Renomear o arquivo
os.rename(caminho_antigo, caminho_novo)

print("Arquivos renomeados com sucesso!")

------------------------------------------------------

**reduzir uma imagem através da média:**

import numpy as np

def based_redution_mean(img, n_times):

for number in range(n_times):
reduced_matrix = np.zeros((img.shape[0], img.shape[1], img.shape[2]))
[::n_times, ::n_times]
 img = cv2.imread(f'C:\\Users\\marco\\amostras\\numbers\\skinny_numbers\\
{number}.png')
for red_i, i in enumerate(range(0, img.shape[0], n_times)):
for red_j, j in enumerate(range(0, img.shape[1], n_times)):
mean1 = np.mean(img[i: i+n_times, j: j+n_times], axis=1)
mean2 = np.mean(mean1, axis=0)
reduced_matrix[red_i, red_j] = mean2
cv2.imwrite('C:\\Users\\marco\\amostras\\numbers\\skinny_numbers\\' +
str(number) + '.1.png', reduced_matrix)

-------------------------------------------------------

**gerar caracteres no illustrator:**

from time import sleep

import pyautogui as pa
import string
from random import sample

def escolher_fontes_aleatorias_illustrator(k_, time_step):

alpha = string.ascii_lowercase
# alpha = alpha.replace('w','')
samples = sample([i for i in alpha], k=k_)
sleep(5)
for j in range(10):
for i in range(10):
sleep(time_step)
pa.write(str(j))
sleep(time_step)
pa.click(x=932, y=414)
sleep(time_step)
pa.write(samples.pop())
sleep(time_step)
pa.press('enter')
if samples:
pass
else:
samples = sample([i for i in alpha], k=k_)

----------------------------------------------------------------

**limpar print a cada print:**

from IPython.display import clear_output

# Seu código aqui

clear_output(wait=True)

---------------------------------------------------------------

**calcular o tempo do código:**

import timeit

codigo = """
soma = 0
for i in range(1000):
soma += i
"""

tempo_execucao = timeit.timeit(stmt=codigo, number=1000)

print(f"Tempo de execução: {tempo_execucao} segundos")

------------------------------------------------------------------

**Distância euclidiana entre dois pontos:**

import math

def distancia_euclidiana(x1, y1, x2, y2):

return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

# Exemplo de uso
ponto1 = (1, 2)
ponto2 = (4, 6)

distancia = distancia_euclidiana(ponto1[0], ponto1[1], ponto2[0], ponto2[1])

print(f"A distância euclidiana entre os pontos é: {distancia:.2f}")

------------------------------------------------------------------------

**calcular a 'lei dos cossenos' para encontrar os ângulos de um triângulo com

'lados fornecidos:**

import math

def calcular_angulo(a, b, c):

# Converter para radianos
a_rad = math.radians(a)
b_rad = math.radians(b)
c_rad = math.radians(c)

# Calcular os ângulos usando a lei dos cossenos

angulo_A = math.degrees(math.acos((b**2 + c**2 - a**2) / (2 * b * c)))
angulo_B = math.degrees(math.acos((a**2 + c**2 - b**2) / (2 * a * c)))
angulo_C = math.degrees(math.acos((a**2 + b**2 - c**2) / (2 * a * b)))

return angulo_A, angulo_B, angulo_C

# Exemplo de uso
lado_a = 3
lado_b = 4
lado_c = 5

angulos = calcular_angulo(lado_a, lado_b, lado_c)

print(f"Ângulo A: {angulos[0]:.2f}°")
print(f"Ângulo B: {angulos[1]:.2f}°")
print(f"Ângulo C: {angulos[2]:.2f}°")

-----------------------------------------------------------------------------------
-----------------------------------------------------------
**encontra os 3 angulos de todos os indices de um conjunto de dados:**

def angulos_todos_inds(inds):
# precisa da funcao 'calcular_angulo'
angulos = []
hip = ((inds[:,0]-0)**2 + (inds[:,1]-0)**2)**.5
for num in range(inds.shape[0]):
c1, c2 = inds[num]
h = hip[num]
try:
if 0 in inds[num]:
ang = (0,0,0)
angulos.append(ang)
else:
ang = calcular_angulo(h, abs(c1) , abs(c2))
angulos.append(ang)

except:
ang = (0,0,0)
angulos.append(ang)
return np.array(angulos)

-----------------------------------------------------------------------------------
-----------------------------------------------------------

**cria uma cópia aprofundada:**

import copy

copy.deepcopy(dicionario_original)

--------------------------------------------------------------------

**cria um mapeamento através de uma função:**

- usando 'map'

list(map(tuple, array.tolist()))

--------------------------------------------------------------------

**verificação se tecla foi pressionada:**

import keyboard

# Função para verificar a tecla pressionada

def verificar_tecla(tecla):
if keyboard.is_pressed(tecla):
print(f"A tecla {tecla} foi pressionada.")
else:
print(f"A tecla {tecla} não está sendo pressionada.")

# Exemplo de uso
tecla_a_verificar = "a"

verificar_tecla(tecla_a_verificar)
------------------------------------------------------------

import numpy as np
import matplotlib.pyplot as plt

X = np.array([1, 2, 3, 4, 5])
Y = np.array([2, 3, 4, 5, 6])

# Aqui, 1 é a ordem do polinômio, o que resulta em uma regressão linear.

coefficients conterá os coeficientes da reta ajustada.
coefficients = np.polyfit(X, Y, 1)

linear_function = np.poly1d(coefficients)

Y_pred = linear_function(X)

plt.scatter(X, Y, label='Dados Originais')

plt.plot(X, Y_pred, color='red', label='Regressão Linear')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.show()

**cores hexadecimais:**

cores = ['#FF0000',
'#00FF00',
'#0000FF',
'#FFFF00',
'#FF00FF',
'#00FFFF',
'#FFA500',
'#800080',
'#008000',
'#000000']

#FF0000 (vermelho)
#00FF00 (verde)
#0000FF (azul)
#FFFF00 (amarelo)
#FF00FF (magenta)
#00FFFF (ciano)
#FFA500 (laranja)
#800080 (roxo)
#008000 (verde escuro)
#000000 (preto)

------------------------------------------------------

**grafo de largura:**

from collections import deque

def bfs(graph, start):

 visited = set()
queue = deque([start])

while queue:
node = queue.popleft()
if node not in visited:
print(node)
visited.add(node)
queue.extend(graph[node])

# Exemplo de uso:
graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F'],
'D': [],
'E': ['F'],
'F': []
}

bfs(graph, 'A')

--------------------------------------------------------

**grafo de profundidade:**

def dfs(graph, node, visited):

if node not in visited:
print(node)
visited.add(node)
for neighbor in graph[node]:
dfs(graph, neighbor, visited)

# Exemplo de uso:
graph = {
'A': ['B', 'C'],
'B': ['D', 'E'],
'C': ['F'],
'D': [],
'E': ['F'],
'F': []
}

visited_nodes = set()
dfs(graph, 'C', visited_nodes)

----------------------------------------------

**criar vizinhos das coordenadas cartesianas:**

def vizinhos_todas_coordenadas(array, concatenar=False):

vetores = np.array([(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1,
0), (1, 1)])
vetores_multiplicados = np.tile(vetores, array.shape[0])
vetores_mult_remodelado = vetores_multiplicados.reshape(-1, array.shape[0],
array.shape[1])
vizinhos = (array + vetores_mult_remodelado)
if concatenar:
 vizinhos = np.concatenate(vizinhos)
else:
pass
return vizinhos

----------------------------------------------

**encontrar as bordas de um aglomerado denso de coordenadas cartesianas,

precisa de "vizinhos_todas_coordenadas":**

def bordas_img(inds):

# precisa da função 'vizinhos_todas_coordenadas'

vizinhos = vizinhos_todas_coordenadas(inds, concatenar=True)

conj_inds_mais_bordas_externas = set(map(tuple, vizinhos))
conj_inds = set(map(tuple, inds))
conj_bordas_externas = conj_inds_mais_bordas_externas.difference(conj_inds)
numpy_bordas_externas = np.array(list(conj_bordas_externas))
vizinhos_bordas_externas = vizinhos_todas_coordenadas(numpy_bordas_externas,
concatenar=True)
conj_vizinhos_bordas_externas = set(map(tuple, vizinhos_bordas_externas))
conj_bordas = conj_vizinhos_bordas_externas.intersection(conj_inds)
numpy_bordas = np.array(list(conj_bordas))
return numpy_bordas

-------------------------------------------------

**vizinhos de cada ponto no plano cartesiano, precisa de

"vizinhos_todas_coordenadas":**

def vizinhos_cada_pixel(vizinhos_todas_coordenadas):
todos_vizinhos = []
comprimento_1 = vizinhos_todas_coordenadas.shape[1]
for num in range(comprimento_1):
vizinhos = vizinhos_todas_coordenadas[:,num::comprimento_1]
vizinhos = np.concatenate(vizinhos)
todos_vizinhos.append(vizinhos)
return np.array(todos_vizinhos)

-------------------------------------------------

**cria uma curva de bezier:**

import numpy as np

def bezier_curve(t, control_points):

n = len(control_points) - 1
result = np.zeros_like(control_points[0], dtype=float)
for i, point in enumerate(control_points):
result += point * binomial(n, i) * (t ** i) * ((1 - t) ** (n - i))
return result

def binomial(n, k):

return np.math.factorial(n) / (np.math.factorial(k) * np.math.factorial(n - k))

# Define os pontos de controle

control_points = np.array([[0, 0], [1, 1], [1, 0]])
# Calcula os pontos da curva de Bezier
num_points = 100
t_values = np.linspace(0, 1, num_points)
curve_points = np.array([bezier_curve(t, control_points1) for t in t_values])

--------------------------------------------------------------

**fazer operação entre valores em um numpy array:**

import numpy as np

def operacao_n_n_mais_1(inds, eixos=2, fechar_ciclo=False):

# lembrar que vai estar sempre faltando 1 pois o último não opera
# após, só se sua intenção é fechar um ciclo
if inds.shape[0] % 2 == 0:
print('par')
dois_em_dois_0 = inds[::2]
dois_em_dois_1 = inds[1::2]
dois_em_dois_2 = inds[2::2]
var1 = dois_em_dois_1 - dois_em_dois_0
menos_o_ultimo = dois_em_dois_1[:-1]
var2 = dois_em_dois_2 - menos_o_ultimo
var1_menos_o_ultimo = var1[:-1]
concatenados_faltando_ultimo =
np.concatenate((var1_menos_o_ultimo.reshape(-1,eixos), var2.reshape(-1,eixos)),
axis=1)
remodelando_array = concatenados_faltando_ultimo.reshape(-1,eixos)
ultimo = var1[-1]
todos_concatenados = np.concatenate((remodelando_array, [ultimo]))
if fechar_ciclo:
todos_concatenados = np.concatenate((todos_concatenados, [inds[-1] -
inds[0]]))
else:
print('o shape do "array de saída" está com 1 a menos que o shape do
"array de entrada"')
pass
return todos_concatenados
else:
print('impar')
dois_em_dois_0 = inds[::2]
dois_em_dois_1 = inds[1::2]
dois_em_dois_2 = inds[2::2]
var1 = dois_em_dois_1 - dois_em_dois_0[:-1]
var2 = dois_em_dois_2 - dois_em_dois_1
todos_concatenados = np.concatenate((var1.reshape(-1,eixos), var2.reshape(-
1,eixos)), axis=1)
todos_concatenados = todos_concatenados.reshape(-1,eixos)
if fechar_ciclo:
todos_concatenados = np.concatenate((todos_concatenados, [inds[-1] -
inds[0]]))
else:
print('o shape do "array de saída" está com 1 a menos que o shape do
"array de entrada"')
pass
return todos_concatenados

--------------------------------------------------

**criar um grafico 'ANIMADO' com a trajetoria de pontos:**

import matplotlib.pyplot as plt
import numpy as np
import time
from IPython.display import clear_output

for num in range(numpy_nos_ordenados.shape[0]-1):

plt.figure(figsize=(6, 6))
plt.scatter(inds[:, 0], inds[:, 1], color="#000000", s=20)
plt.plot(numpy_nos_ordenados[0:num+2][:, 0], numpy_nos_ordenados[0:num+2][:,
1], color="red")
plt.scatter(numpy_nos_ordenados[num+1][0], numpy_nos_ordenados[num+1][1],
color="red", s=20) # Adiciona o ponto atual
plt.gca().set_aspect('equal', adjustable='box')
plt.xlim(min(inds[:, 0])-10, max(inds[:, 0])+10)
plt.ylim(min(inds[:, 1])-10, max(inds[:, 1])+10)
plt.grid(True)
plt.tight_layout()
plt.show()
time.sleep(.01)
clear_output(wait=True)

----------------------------------------------

**criando um grafico simples:**

import matplotlib.pyplot as plt

import numpy as np

plt.figure(figsize=(6, 6)) # (6,6) --> valores expressos em polegadas (1 pol ==

2.54 cm)
plt.scatter(bordas[:, 0], bordas[:, 1], color="#000000", s=20)
# plt.text(np.mean(array,axis=0)[0], np.mean(array,axis=0)[1], 'Linha 1',
fontsize=12, color='blue')
plt.gca().set_aspect('equal', adjustable='box')
plt.xlim(min(bordas[:, 0])-10, max(bordas[:, 0])+10)
plt.ylim(min(bordas[:, 1])-10, max(bordas[:, 1])+10)
plt.grid(True)
plt.tight_layout()
plt.show()

----------------------------------------------

**encontrando os limites dos dados a partir dos vizinhos de um ponto:**

import numpy as np

def vizinho_com_mais_liberdade(inds, vizinhos_copiados, vetores, node):

lista_pertencentes = []
conj_inds = set(map(tuple, inds))
comprimento_vizinhos = len(vizinhos_copiados)
iterador = iter(range(comprimento_vizinhos))
while True:
try:
indice = next(iterador)
except:
break
num = 1
 while True:
vizinho_mesmo_vetor = vizinhos_copiados[indice] + (vetores[indice] *
num)
tupla_vizinho_mesmo_vetor = tuple(vizinho_mesmo_vetor)
conj_vizinho_mesmo_vetor = set()
conj_vizinho_mesmo_vetor.add(tupla_vizinho_mesmo_vetor)
nao_pertence = conj_vizinho_mesmo_vetor.isdisjoint(conj_inds)
if nao_pertence:
# pois os 'vizinhos_copiados' termina fora dos limites de 'inds'
maior_raio_vizinho = (vizinho_mesmo_vetor - vetores[indice])
lista_pertencentes.append(maior_raio_vizinho)
break
else:
pass
num += 1

limites_maximos_vizinhos = np.array(lista_pertencentes)

return limites_maximos_vizinhos

-----------------------------------------------------------------------------------
---

**extraindo o a maior distancia:**

def max_dist_vizinho_node(node, limites_maximos_vizinhos):

dists = ((node[0] - limites_maximos_vizinhos[:,0])**2 + ((node[1]) -
limites_maximos_vizinhos[:,1])**2)**0.5
max_dist = max(dists)
mascara_maior_dist = (dists == max_dist)
raio_maximo = limites_maximos_vizinhos[mascara_maior_dist]
return raio_maximo

-----------------------------------------------------------------------------------
-----

def media_dos_vetores(node, inds, vetor_maior_raio):

# pois o valor de 'maior raio' pode pertencer a mais de uma 'coordenada'
unico_vetor = vetor_maior_raio[0]
dists_node_inds = ((node[0] - inds[:,0])**2 + ((node[1]) - inds[:,1])**2)**0.5
raio_max = np.where(np.all(inds == unico_vetor, axis=-1))[0]
raios_menores_igual_raio_max = inds[dists_node_inds <=
dists_node_inds[raio_max]]
media = np.mean(raios_menores_igual_raio_max, axis=0)
return media, raios_menores_igual_raio_max

-----------------------------------------------------------------------------------
-----

**criando pontos para experimentação:**

import numpy as np
import pyautogui as pa
import time

def pontos_na_tela(quatidade_pontos, tempo):

posicoes = []
 for num in range(quatidade_pontos):
time.sleep(tempo)
posicao = pa.position()
x = posicao[0]
y = posicao[1]
coord = (x,y)
posicoes.append(coord)
print(f'ponto {num}: {coord}')
return np.array(posicoes)

-----------------------------------------------------------------

**reduzir vetores para 0,1:**

def calcular_vetores_x_y(distancia_x_y):
if np.any(distancia_x_y == 0):
mascara_distancia_diferente_0 = (distancia_x_y != 0)
coord_diferente_zero = distancia_x_y[mascara_distancia_diferente_0]
# para preservar o o sinal após a divisão
eliminando_sinal = abs(coord_diferente_zero)
unidade = (coord_diferente_zero // eliminando_sinal)
array_vazio = np.zeros((2), dtype='int')
array_vazio[mascara_distancia_diferente_0] = unidade
vetor = array_vazio
return vetor

else:
vetor = distancia_x_y // abs(distancia_x_y)
return vetor

------------------------------------------------------------------

**vetores:**

vetores = np.array([(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1),(1,
-1)])

----------------------------------------------------------------------

**pesquisa por largura e profundidade:**

import numpy as np

def pesquisa(lista_nos, graph, start, reverse=True):

nos = lista_nos
visited = set()
stack = [tuple(start)]
if reverse:
print('pesquisa por largura')
else:
print('pesquisa por profundidade')

while stack:
node = stack.pop()
if node not in visited:
nos.append(node)
visited.add(node)
vizinhos = graph[:,-2:][np.all(graph[:,:2] == node, axis=-1)]
 vizinhos = list(map(tuple,vizinhos))
if reverse:
stack.extend(vizinhos[::-1])
else:
stack.extend(vizinhos)

return np.array(lista_nos)

----------------------------------------------------------------

**criando vizinhos numpy array:**

def criando_vizinhos_np_array(inds):

# precisa das funcoes: 'vizinhos_todas_coordenadas', 'bordas_img',

'vizinhos_cada_pixel'

vizinhos = vizinhos_todas_coordenadas(inds, concatenar=True)

bordas, bordas_externas = bordas_img(vizinhos)

vizinhos_inds = vizinhos_todas_coordenadas(inds, concatenar=False)

todos_vizinhos = vizinhos_cada_pixel(vizinhos_inds)
com_apenas_um_eixo_para_cada_coord = todos_vizinhos[:,:,np.newaxis]
mascara_1 = np.all(com_apenas_um_eixo_para_cada_coord == bordas_externas,
axis=-1)
mascara_2 = (~(np.any(mascara_1, axis=-1)))
eixo_0, eixo_1 = np.where(mascara_2)

vizinhos_internos = todos_vizinhos[mascara_2]
nohs_repetidos = inds[eixo_0]
no_vizinho = np.concatenate((nohs_repetidos, vizinhos_internos), axis=1)

no_vizinho = no_vizinho.astype(int)

return no_vizinho

---------------------------------------------------------------------------------

**definindo o alcance dos dados a partir de um raio:**

# precisa das funcoes: 'vizinho_com_mais_liberdade', 'max_dist_vizinho_node'

def criando_circulo(inds, node, vetor_maior_raio):

# pois o valor de 'maior raio' pode pertencer a mais de uma 'coordenada'
unico_vetor = vetor_maior_raio[0]
pdb.set_trace()
dists_node_inds = ((node[0] - inds[:,0])**2 + ((node[1]) - inds[:,1])**2)**0.5
raio_max = np.where(np.all(inds == unico_vetor, axis=-1))[0]
raios_menores_igual_raio_max = inds[dists_node_inds <=
dists_node_inds[raio_max]]
return raios_menores_igual_raio_max

-----------------------------------------------------------------------------------

**definindo a média desse alcance:**

# precisa da funcao: 'criando_circulo'

def media_dos_vetores(circulo):
media = np.mean(circulo, axis=0)
return media

-----------------------------------------------------------------------------------

**extraindo um parte dos dados baseada na distancia euclidiana:**

import numpy as np

def distancia_euclidiana(node, inds):

return ((inds[:,0] - node[0])**2 + (inds[:,1] - node[1])**2)**.5

def raios(inds, node, fim, inicio=1):

dists = distancia_euclidiana(node, inds)
return inds[(dists >= inicio) & (dists <= fim)]

-----------------------------------------------------------------------------------
---

**encontrar circulos através dos extremos dos vizinhos dos 'nodes':**

def todos_extremos_dos_nodes(inds):
# precisa da funcao 'criando vizinhos'
todos_extremos = []
partes_dos_circulos = []

node_axis_0_vizinhos_axis_1 = criando_vizinhos_np_array(inds)
reshaped = node_axis_0_vizinhos_axis_1.reshape(-1,2)
# subtraindo 'vizinho' com 'node'
vetores = reshaped[1::2] - reshaped[::2]
nodes = node_axis_0_vizinhos_axis_1[:,:-2]
unique_nodes = np.unique(nodes, axis=0)

for node in unique_nodes:

mascara = np.all(nodes == node, axis=-1)
todos_vizinhos = node_axis_0_vizinhos_axis_1[:,-2:]
vizinhos_node = todos_vizinhos[mascara]
vetores_vizinhos = vetores[mascara]
extremos_node = vizinho_com_mais_liberdade(inds, vizinhos_node,
vetores_vizinhos, node)
todos_extremos.append(extremos_node)

for num in range(unique_nodes.shape[0]):

parte_do_circulo = []
node = unique_nodes[num]
extremos_node = todos_extremos[num]
vetor_maior_raio = max_dist_vizinho_node(node, extremos_node)
circulo = criando_circulo(inds, node, vetor_maior_raio)
node_vizinhos = criando_vizinhos_np_array(circulo)
graph = node_vizinhos
start = node
pesquisa(parte_do_circulo, graph, start, reverse=True)
partes_dos_circulos.append(parte_do_circulo)

# 'todos_extremos' = list, 'unique_nodes' = np.array() 'partes_dos_circulos' =

list
return todos_extremos, unique_nodes, partes_dos_circulos
----------------------------------------------------------------

**criando pontes entre pontos distantes:**

import copy
import numpy as np

def criando_pontes_entre_coords_distantes(inds, distancia_max):

def distancia_euclidiana(node, inds):
return ((inds[:,0] - node[0])**2 + (inds[:,1] - node[1])**2)**.5

def faixas(ind, vizinhos):

linhas_colunas = []
for vizinho in vizinhos:
linha = vizinho[0]
coluna = vizinho[1]

if linha > ind[0]:

linhas = np.arange(ind[0], linha)
elif ind[0] == 0:
linhas = np.arange(linha, ind[0])
elif linha == ind[0]:
linhas = np.array([[]])

else:
linhas = np.arange(linha, ind[0])[::-1]

if coluna > ind[1]:

colunas = np.arange(ind[1], coluna)
elif ind[1] == 0:
colunas = np.arange(coluna, ind[1])
elif coluna == ind[1]:
colunas = np.array([[]])

else:
colunas = np.arange(coluna, ind[1])[::-1]

linhas_colunas.append(linhas)
linhas_colunas.append(colunas)

return linhas_colunas

todos_vizinhos = []
for ind in inds:
dists = distancia_euclidiana(ind, inds)
vizinhos = inds[(dists < distancia_max) & (dists != 0)]
todos_vizinhos.append(vizinhos)

pontes = []
for ind, vizinhos in zip(inds, todos_vizinhos):
lista_incompleta_vizinhos_faltantes = faixas(ind, vizinhos)
pontes.append(lista_incompleta_vizinhos_faltantes)

lenghts = []
juntar_lenghts = []
for ponte in pontes:
lenghts.append(list(map(len, ponte)))
 for lenght in lenghts:
juntar_lenghts.extend(lenght)

numpy_juntar_lenghts = np.array(juntar_lenghts)
minimo = min(numpy_juntar_lenghts[(numpy_juntar_lenghts != 0) &
(numpy_juntar_lenghts != 1)])

copia_pontes = copy.deepcopy(pontes)

for num_1 in range(len(pontes)):

for num_2 in range(len(pontes[num_1])):
shape = pontes[num_1][num_2].shape[0]

if shape == 0:
copia_pontes[num_1][num_2] = np.zeros((minimo))
elif shape == 1:
ind = inds[num_1]
vizinho = todos_vizinhos[num_1][num_2//2]
mascara = (ind == vizinho)
mesmo_eixo_vizinho = vizinho[mascara]
copia_pontes[num_1][num_2] = np.tile(mesmo_eixo_vizinho, minimo)

elif shape != minimo and shape != 0:

# -1 é a quantidade de dados que deve ser reduzida para que todos
tenham o mesmo 'shape'
copia_pontes[num_1][num_2] = pontes[num_1][num_2][1:]
else:
pass
pontes_concatenadas = np.concatenate(copia_pontes)

x = pontes_concatenadas[::2]
y = pontes_concatenadas[1::2]

numpy_pontes = np.concatenate((x.reshape(-1,1), y.reshape(-1,1)), axis=1)

numpy_pontes = np.unique(numpy_pontes, axis=0)

return numpy_pontes.astype(int)

---------------------------------------------------------------------

**verifica se um numero float é inteiro ou decimal:**

def tem_parte_decimal(numero):
if isinstance(numero, float):
return numero.is_integer() == True
else:
return False

-----------------------------------------------------------------------

**encontrando os outliers da média:**

def vazios_nos_dados(eixo_nao_nulo):
# precisa da 'saida' da funcao 'operacao_n_n_mais_1'
valores_maximos = []
media_atual = np.round(np.mean(eixo_nao_nulo))

while True:
 valor_maximo = max(eixo_nao_nulo)
mascara_valor_maximo = (eixo_nao_nulo == valor_maximo)
dados_sem_valor_maximo = eixo_nao_nulo[~(mascara_valor_maximo)]
nova_media = np.round(np.mean(dados_sem_valor_maximo))
if nova_media != media_atual:
valores_maximos.append(valor_maximo)
media_atual = nova_media
continue
else:
break
return np.array(valores_maximos)

----------------------------------------------------------------------

**quando o resultado é negativo ou positivo:**

def operando_em_positivos_ou_negativos(num):
abs_num = abs(num)
proximo_abs_num = abs_num + 1
proxim_num = num * ((proximo_abs_num *100 )/abs_num)/100
return proxim_num

------------------------------------------------------------------------

**rotaciona a matriz:**

import cv2
import numpy as np

# Carregar a imagem
image = cv2.imread('C:\\Users\\marco\\Desktop\\2.png')

# Definir o ângulo de rotação desejado em graus

angulo = 22.5

# Obter o centro da imagem

altura, largura = image.shape[:2]
centro = (largura / 2, altura / 2)

# Criar a matriz de rotação

matriz_rotacao = cv2.getRotationMatrix2D(centro, angulo, 1.0)

# Aplicar a rotação na imagem

imagem_rotacionada = cv2.warpAffine(image, matriz_rotacao, (largura, altura),
flags=cv2.INTER_LINEAR)

# Mostrar a imagem original e a imagem rotacionada

cv2.imshow('Imagem Original', image)
cv2.imshow('Imagem Rotacionada', imagem_rotacionada)
cv2.waitKey(0)
cv2.destroyAllWindows()

funcao

def girar_matriz(img, angulo):

altura, largura = img.shape[:2]
centro = (altura//2, largura//2)
matriz_rotacao = cv2.getRotationMatrix2D(centro, angulo, 1)
imagem_rotacionada = cv2.warpAffine(img, matriz_rotacao, (largura, altura),
flags=cv2.INTER_LINEAR)
return imagem_rotacionada

----------------------------------------------------------------

**calcula os dados que menos desviaram da média ou os que mais desviaram:**

def dados_padrao_nao_padrao(array, padrao=True):

desvios_padroes = array.std(axis=0).astype(int)
valores_centrados = (array - np.mean(array, axis=0)).astype(int)
distancia_do_padrao = abs(abs(valores_centrados) - desvios_padroes)
media_desvios_colunas = np.mean(distancia_do_padrao, axis=1)
media_minima = min(media_desvios_colunas)
mascara_padrao = (media_minima == media_desvios_colunas)
mascara_nao_padrao = ~(media_minima == media_desvios_colunas)
if padrao:
cores = array[mascara_padrao]
else:
cores = array[mascara_nao_padrao]
# pois o padrão de cores é BGR e nao RGB
cores = cores[:,::-1]
return cores

-----------------------------------------------------------------

**gerar mais de um gráfico de barras lado a lado:**

import plotly.graph_objects as go

# Dados fictícios de vendas mensais

meses = ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho',
'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro']
vendas1 = [50, 45, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]
vendas2 = [60, 55, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110]

# Criando o trace para o primeiro gráfico

trace1 = go.Bar(x=meses, y=vendas1, name='Gráfico 1')

# Criando o trace para o segundo gráfico

trace2 = go.Bar(x=meses, y=vendas2, name='Gráfico 2')

# Criando a figura com os dois gráficos lado a lado

fig = go.Figure(data=[trace1, trace2])
fig.update_layout(barmode='group', title='Vendas Mensais')
fig.show()

----------------------------------------------------------------------

**padronizar os dados:**

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
dados_padronizados = scaler.fit_transform(dados)

---------------------------------------------------------------------

**Cria um 'conjunto de arrays' com 'mesmo comprimento' do 'array maior'**

import re
import numpy as np

def docs_suited_to_the_largest_doc(tokens_list, max_length):

list_length = len(tokens_list)
amount_empty = (max_length - list_length)
list_of_number_voids = [''] * amount_empty
tokens_list.extend(list_of_number_voids)
return tokens_list

array_docs = np.array(list(map(lambda x: docs_suited_to_the_largest_doc(x,

max_length), lista_de_listas_de_tokens)))

--------------------------------------------------------------------------------

**transforma as palavras em tokens:**

import nltk
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize

# Texto de exemplo
texto = 'igual somos iguais igualdade a lei'

# Tokenize o texto em palavras

tokens = word_tokenize(texto)

---------------------------------------------------------------------------------

**aplica stemming nos tokens:**

# Importe o módulo necessário

from nltk.stem import PorterStemmer
from nltk.tokenize import word_tokenize

# Texto de exemplo
texto = 'igual somos iguais igualdade a lei'

# Tokenize o texto em palavras

tokens = word_tokenize(texto)

# Crie uma instância da classe PorterStemmer

ps = PorterStemmer()

# Exemplo de palavras
# words = ["program", "programs", "programmer", "programming", "programmers"]

# Stemming de cada palavra e imprima o resultado

for w in tokens:
print(f"{w} : {ps.stem(w)}")

-----------------------------------------------------------------------------

**stemming lingua portuguesa:**

import nltk

# nltk.download('rslp')
stemmer = nltk.stem.RSLPStemmer()

palavra = "amigos"

palavra_stemmed = stemmer.stem(palavra)

print(palavra_stemmed) # Saída: "amig"

-----------------------------------------------------------------------------

**inicia o modelo spacy em portugues:**

import spacy
# linguagem em pt-br
nlp = spacy.load('pt_core_news_sm')

#linguagem em ingles
nlp = spacy.load('en_core_web_sm')

#significado das abreviações:

# en - ingles; core - inclui vocabulario, sintaxe e entidades;
# web - modelo treinado em texto da web (blogs, notícias, comentários);
# sm - tamanho do modelo 'small' pode ser 'md'(medium) e 'lg'(large)

----------------------------------------------------------------------------

**gera a 'PALAVRA (token.text)' mais o 'POS (token.pos_)' - (Part of Speech)

(Classe Gramatical):**

import spacy
nlp = spacy.load('pt_core_news_sm')
doc = nlp("Eu amo programar em Python.")
for token in doc:
print(token.text, token.pos_)

saída:
Eu PRON
amo VERB
programar VERB
em ADP
Python PROPN
. PUNCT

-------------------------------------------------------------------------------

**retorna entidades nomeadas:**

import spacy

# Carregar o modelo de linguagem em inglês

nlp = spacy.load('en_core_web_sm')

# Processar um texto
doc = nlp("Apple is looking at buying U.K. 2024/01/1 startup for $1 billion")

# Iterar sobre as entidades

for ent in doc.ents:
print(ent.text, ent.start_char, ent.end_char, ent.label_)
saída:
Apple 0 5 ORG
U.K. 27 31 GPE
2024/01/1 32 41 CARDINAL
$1 billion 54 64 MONEY

--------------------------------

**para não precisar compilar o padrao a cada iteração:**

import re

padrao = re.compile(rf"{re.escape(padrao)}\d*")

---------------------------------

**separa as sentenças pelos pontos:**

import re

padrao = re.compile(r'(?<=[.!?]) +')

re.split(padrao, texto_integra)

----------------------------------

**Pega o inicio do texto mais o resto do conteúdo até o 'espaço':**

import re

# Defina sua string específica

sua_string = "sua_string_aqui"

# Crie o padrão regex

padrao = re.compile(rf"{re.escape(sua_string)}\S*")

# Exemplo de uso com re.findall()

texto = "sua_string_aqui qualquer_coisa até o primeiro espaço em branco"
resultado = padrao.findall(texto)
print(resultado) # Saída: ['sua_string_aqui']

-------------------------------------

**abrir janela do google:**

from selenium import webdriver

from selenium.webdriver.chrome.service import Service

path_to_chromedriver='C:\\Users\\marco\\Downloads\\chromedriver-win64\\
chromedriver.exe'

s = Service(path_to_chromedriver)

driver = webdriver.Chrome(service=s)
# Inicialize o driver do navegador (neste caso, Google Chrome)
driver = webdriver.Chrome()

# Defina o tamanho da janela para 1024x768

driver.set_window_size(300, 300)

# Navegue até a página da web desejada

driver.get('http://www.google.com')

# Feche o navegador
driver.quit()

---------------------------------------------

**converte as cores do 'cv2' em formato 'RGB':**

cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

---------------------------------------------

**Codificação padrão**

import sys

print("Codificação padrão:", sys.getdefaultencoding())

----------------------------------------------

**criar tokens no spaCy:**

import spacy
from spacy.tokens import Token

# Defina suas regras de tokenização

custom_tokenization_rules = {
"patterns": [
# Exemplo: Tokenizar números como "123" e "456" como TOKEN_NUM
{"label": "TOKEN_NUM", "pattern": [{"IS_DIGIT": True}]}
]
}

# Crie um novo componente para adicionar suas regras ao pipeline

def add_custom_tokenization_rules(nlp):
for rule in custom_tokenization_rules["patterns"]:
nlp.tokenizer.add_special_case(rule["pattern"][0]["LOWER"], [rule])

# Adicione o novo componente ao pipeline

nlp = spacy.load("pt_core_news_sm")
add_custom_tokenization_rules(nlp)

# Teste a tokenização
doc = nlp("123 456")
for token in doc:
print(token.text, token.pos_)

-----------------------------------

**caminho do executável do pytesseract:**

pytesseract.pytesseract.tesseract_cmd = r'C:\\Program Files\\Tesseract-OCR\\

tesseract.exe'
----------------------------------------

**converte a imagem em string:**

texto = pytesseract.image_to_string(img)

----------------------------------------

**função distância euclidiana**

import numpy as np

def distancia_euclidiana(node, inds):

return ((inds[:,0] - node[0])**2 + (inds[:,1] - node[1])**2)**.5

----------------------------------------

**exibe a imagem na tela e sai ao apertar 'q'**

import cv2

# Carregar a imagem
imagem = cv2.imread('exemplo.jpg')

# Mostrar a imagem
cv2.imshow('Imagem', imagem)

# Esperar indefinidamente até que a tecla 'q' seja pressionada para fechar a janela
while True:
if cv2.waitKey(1) & 0xFF == ord('q'):
break

# Fechar todas as janelas

cv2.destroyAllWindows()

---------------------------------------

**encontra uma 'submatriz' em uma 'matriz':**

import numpy as np

# Matriz maior
matriz_maior = matriz

# Matriz menor que queremos encontrar

matriz_menor = submatriz

# Encontrar a matriz menor usando indexação booleana

indices_linha, indices_coluna = np.where(matriz_maior == matriz_menor[0, 0])
indices_menor = list(zip(indices_linha, indices_coluna))

for indice in indices_menor:

submatriz = matriz_maior[indice[0]:indice[0]+len(matriz_menor),
indice[1]:indice[1]+len(matriz_menor[0])]
if np.array_equal(submatriz, matriz_menor):
print("Matriz menor encontrada nas coordenadas:", indice)
break
------------------------------------------

**informa se a 'submatriz' existe na 'matriz':**

import numpy as np

# Definir a matriz principal

matriz_principal = matriz

# Definir a parte da matriz que desejamos verificar se está contida na matriz

principal
parte_matriz = submatriz

# Verificar se a parte da matriz está contida na matriz principal

esta_contida = False
for i in range(len(matriz_principal) - len(parte_matriz) + 1):
for j in range(len(matriz_principal[0]) - len(parte_matriz[0]) + 1):
if np.array_equal(matriz_principal[i:i+len(parte_matriz),
j:j+len(parte_matriz[0])], parte_matriz):
esta_contida = True
break

print("A parte da matriz está contida na matriz principal:", esta_contida)

---------------------------------------------------

**achar o percentil**

import numpy as np

np.percentile(dados, 100)

----------------------------------------------------

**arco cosseno**

import numpy as np

np.arccos()

----------------------------------------------------

** operações lógicas com 'and' **

import numpy as np

np.logical_and(dados >= -1, dados <= 1)

---------------------------------------------------

**matrizes esparsas**

# coo_matrix - A sparse matrix in COOrdinate format

# csc_matrix - Compressed Sparse Column matrix
# csr_matrix - Compressed Sparse Row matrix
from scipy.sparse import coo_matrix

coo_matrix(dados)

---------------------------------------------------

**busca binária recursiva**

def binary_search_recursive(array, target, low, high):

if low > high:
return -1 # Elemento não encontrado

mid = (low + high) // 2

if array[mid] == target:
return mid # Elemento encontrado

elif array[mid] < target

return binary_search_recursive(array, target, mid + 1, high) # Busca na
metade superior

else:
return binary_search_recursive(array, target, low, mid - 1) # Busca na
metade inferior

----------------------------------------------------

**desenha retangulos nos caracteres encontrados na imagem**

import cv2
import pytesseract

# Carregar a imagem
image = cv2.imread('C:\\Users\\marco\\Desktop\\test_tela_maior.png')

# Converter a imagem para escala de cinza

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Aplicar OCR (Optical Character Recognition) usando o Pytesseract

text = pytesseract.image_to_string(gray)

# Saída do texto reconhecido

print("Texto reconhecido:")
print(text)

# Encontrar as coordenadas do texto na imagem original

h, w, _ = image.shape
boxes = pytesseract.image_to_boxes(gray)
for b in boxes.splitlines():
b = b.split()
x, y, x2, y2 = int(b[1]), int(b[2]), int(b[3]), int(b[4])
cv2.rectangle(image, (x, h - y), (x2, h - y2), (0, 255, 0), 2)

# Mostrar a imagem com as caixas delimitadoras do texto

cv2.imshow('Texto Reconhecido', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
------------------------------------------------

**código para impedir que usemos indices além dos 'length' da lista**

# Definindo uma lista de elementos

lista = [10, 20, 30, 40, 50]

# Índice desejado
indice_desejado = 7

# Usando o operador de resto da divisão para calcular o índice dentro dos limites
da lista
indice_corrigido = indice_desejado % len(lista)

# Acessando o elemento da lista usando o índice corrigido

elemento = lista[indice_corrigido]

print(f"O elemento na posição {indice_desejado} é {elemento}")

# note que o elemento que será escolhido como índice é o

resto da divisão'indice_desejado'

-------------------------------------------------------------------

**Verificar Versão**

nome_da_biblioteca.__version__

------------------------------------------------------------------

**Transforma documentos textuais(strings) em um 'vocabulário' de palavras**

from sklearn.feature_extraction.text import CountVectorizer

#cria o modelo vetorizador

#padrão tokeniza antes de transformar em uma matriz esparsa

vectorizer = CountVectorizer()

#se os dados já estiverem tokenizados, apenas transforma em uma matriz esparsa

vectorizer = CountVectorizer(tokenizer=None)

# transforma os docs em uma coleção de letras e as transforma numa matriz esparsa

vectorizer = CountVectorizer(analyzer='char')

#treina e transforma os dados

dados_transformados = vectorizer.fit_transform(dados)

#acessa os nomes em suas devidas posições

vectorizer.get_feature_names_out()

-----------------------------------------------------------------

**Criador de Tópicos**

from sklearn.decomposition import LatentDirichletAllocation as LDA

LDA(n_components=valor, random_state=42)
-----------------------------------------------------------------

**reduz os elementos de uma lista**

from functools import reduce

lst =[47,11,42,13]
reduce(lambda x,y: x+y,lst)

-----------------------------------------------------------------

**Abre um arquivo e BeatufulSoup prepara ele pra extração de dados da web**

from bs4 import BeautifulSoup

with open('C:\\Users\\marco\\Desktop\\Periodic_table_large-pt_BR.xml', 'r',

encoding='UTF-8') as f:
data = f.read()

soup = BeautifulSoup(data, 'xml')

-----------------------------------------------------------------

**Tokeniza as palavras de um texto**

from nltk.tokenize import word_tokenize

word_tokenize(text)

-----------------------------------------------------------------

#confere os tipos de strings

valor = "123"
if valor.isdigit():
print("O valor é numérico.")

valor = "abc123"
if valor.isalnum():
print("O valor é alfanumérico.")

valor = "abc"
if valor.isalpha():
print("O valor é composto apenas de letras.")

-----------------------------------------------------------------

**rotacionar as coordenadas**

import math

def rotacionar_coordenadas(x, y, angulo):

# Converter o ângulo para radianos
angulo_rad = math.radians(angulo)

# Calcular as novas coordenadas após a rotação

novo_x = x * math.cos(angulo_rad) - y * math.sin(angulo_rad)
 novo_y = x * math.sin(angulo_rad) + y * math.cos(angulo_rad)

return novo_x, novo_y

# Definir as coordenadas originais

x_original = 3
y_original = 4

# Definir o ângulo de rotação desejado (em graus)

angulo = 45

# Rotacionar as coordenadas
x_rotacionado, y_rotacionado = rotacionar_coordenadas(x_original, y_original,
angulo)

print("Coordenadas originais:", (x_original, y_original))

print("Coordenadas rotacionadas:", (x_rotacionado, y_rotacionado))

-----------------------------------------------------------------

**abre um arquivo de áudio e executa o áudio**

import librosa
import sounddevice as sd

# Carrega o arquivo de áudio

audio_path = 'caminho/para/seu/arquivo/audio.wav'
y, sr = librosa.load(audio_path, sr=None)

# Reproduz o áudio
sd.play(y, sr)
sd.wait()

---------------------------------------------------------------------

**cria um gráfico de tempo de um arquivo de som**

import librosa
import matplotlib.pyplot as plt

# Carrega o arquivo de áudio

audio_path = 'caminho/para/seu/arquivo/audio.wav'
y, sr = librosa.load(audio_path, sr=None)

# Cria o eixo de tempo

tempo = librosa.times_like(y, sr=sr)

# Plota o áudio
plt.figure(figsize=(10, 4))
plt.plot(tempo, y)
plt.xlabel('Tempo (s)')
plt.ylabel('Amplitude')
plt.title('Forma de onda do áudio')
plt.show()

----------------------------------------------------------------------

**interpolação linear**
import numpy as np

# Pontos conhecidos
xp = [1, 2, 3, 4, 5]
fp = [2, 3, 5, 7, 11]

# Valor de x para o qual queremos estimar y

x = 2.5

# Interpolação linear para estimar y

y = np.interp(x, xp, fp) # xp = x points ; fp = function points;

print("Estimativa de y para x =", x, ":", y)

**interpolação linear fórmula**

import numpy as np

def interpolacao(x,x1,x2,y1,y2):
return y1 + ((x-x1)*(y2-y1))/(x2-x1)

----------------------------------------------

import re

#greedy match - correspondência gananciosa

##o ponto "." é selecionar qualquer caractere
##o asterístico "*" a ganância
re.compile(r'\d.*')

#non-greedy match ou lazy match - correspondência não gananciosa

##o ponto "." é selecionar qualquer caractere

##o asterístico "*" a ganância
re.compile(r'\d.*')

##a interrogação "?" reduz a ganância

re.compile(r'\d.*?')

----------------------------------------------

**Especifica os pontos vizinhos a um determinado raio**

from scipy.spatial import KDTree

# Lista de pontos (cada ponto é uma tupla com coordenadas x, y)

pontos = [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

# Construir a árvore KD
tree = KDTree(pontos)

# Raio de busca para vizinhos

raio = 1.5

# Consultar vizinhos para cada ponto

for i, ponto in enumerate(pontos):
vizinhos = tree.query_ball_point(ponto, raio)
vizinhos.remove(i) # Remove o próprio ponto da lista de vizinhos
 print(f'Vizinhos do ponto {ponto}: {vizinhos}')

-------------------------------------------------------------

**extraindo as casas decimais de um número**

numero = 1234

# Casa decimal dos milhares

milhares = numero // 1000
print("Milhares:", milhares)

# Casa decimal das centenas

centenas = (numero // 100) % 10
print("Centenas:", centenas)

# Casa decimal das dezenas

dezenas = (numero // 10) % 10
print("Dezenas:", dezenas)

# Casa decimal das unidades

unidades = numero % 10
print("Unidades:", unidades)

--------------------------------------------------------------

**Uso de flags**

**sem flag**

import re

texto = "Linha 1\nLinha 2\nLinha 3"

padrao = r'^Linha \d+'
correspondencias = re.findall(padrao, texto)
print(correspondencias) # Saída: ['Linha 1']

**com flag**

import re

texto = "Linha 1\nLinha 2\nLinha 3"

padrao = r'^Linha \d+'
correspondencias = re.findall(padrao, texto, flags=re.MULTILINE)
print(correspondencias) # Saída: ['Linha 1', 'Linha 2', 'Linha 3']

**substituir**

import re

# Sua string original

string_original = '''
categorias:
categ 1:
categ 2:
categ 3:
'''
# Expressão regular para encontrar as linhas que começam com "categ" seguido de
espaço e dígitos
padrao = r'^(categ \d+):'

# Função de substituição para trocar ":" por "="

def substituir(match):
return match.group(1) + ' ='

# Aplicar a substituição usando a expressão regular

string_substituida = re.sub(padrao, substituir, string_original,
flags=re.MULTILINE)

# Imprimir o resultado
print(string_substituida)