Digitazione senza fare apparire nulla su schermo

 Per immettere password da linea di comando o comunque dati che non vogliamo fare visualizzare a video, questo è lo script di esempio scritto in python:

import termios

import sys

def getch():

  fd = sys.stdin.fileno()

  old_settings = termios.tcgetattr(fd)

  try:

    new_settings = termios.tcgetattr(fd)

    new_settings[3] &= ~termios.ICANON & ~termios.ECHO

    termios.tcsetattr(fd, termios.TCSANOW, new_settings)

    car = sys.stdin.read(1)

  finally:

    termios.tcsetattr(fd, termios.TCSANOW, old_settings)

  return car

stringa=""

while True:

  carattere = getch()

  if carattere == "\n":

    break

  else:

    stringa=stringa+carattere

print("Hai digitato:",stringa,end='')

Python Thread e animazione barretta di caricamento

Un programma in python che dimostra l'uso di Thread e l'animazione su prompt di una barretta che gira su se stessa.

import threading

import time

def animazione_barra(termina):

    while not termina.is_set():

        for char in '|/-\\':

            print('\r' + char, end='', flush=True)

            time.sleep(0.1)

def conteggio_numeri(termina):

    for i in range(1, 11):

        print(f'\r {i}', end='', flush=True)

        time.sleep(1)

    

    termina.set()

if __name__ == '__main__':

    termina_animazione = threading.Event()

    

    thread_animazione = threading.Thread(target=animazione_barra, args=(termina_animazione,))

    thread_conteggio = threading.Thread(target=conteggio_numeri, args=(termina_animazione,))

    

    thread_animazione.start()

    thread_conteggio.start()

    

    thread_animazione.join()

    thread_conteggio.join()

Integrale in Python

Integrale in Python senza l'uso di math.

import matplotlib.pyplot as plt

import numpy as np

import math

def sen(x):

    n=10

    rad = x * (3.14159 / 180)  # Converti l'angolo in radianti

    seno = 0

    

    for i in range(n):

        termine = ((-1) ** i) * (rad ** (2 * i + 1)) / math.factorial(2 * i + 1)

        seno += termine

    

    return seno

def f(x):

    return sen(x)

def integral(a, b, n):

    # a e b sono gli estremi di integrazione

    # n è il numero di rettangoli utilizzati per l'approssimazione

    delta_x = (b - a) / n

    result = 0

    for i in range(n):

        x = a + i * delta_x

        result += f(x) * delta_x

    return result

def plot_function_and_integral(a, b, n, r):

    x = np.linspace(a, b, n)

    y = f(x)

    fig, ax = plt.subplots()

    ax.plot(x, y, label='f(x)')

    ax.fill_between(x, y, 0, alpha=0.3, label='Integrale')

    ax.legend()

    ax.grid(True)

    plt.title(f'Integrale {r}')

    plt.show()

# Esempio di utilizzo

a = 0

b = 400

n = 1000

r =  integral(a, b, n)

plot_function_and_integral(a, b, n,r)

Grafico MACD e prezzo

import requests

import matplotlib.pyplot as plt

import pandas as pd

import numpy as np

from datetime import datetime

def get_binance_data(symbol, interval, limit):

    url = f"https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&limit={limit}"

    response = requests.get(url)

    data = response.json()

    df = pd.DataFrame(data)

    df.columns = ['timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 'quote_asset_volume', 'number_of_trades', 'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume', 'ignore']

    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

    df['close'] = df['close'].astype(float)

    return df

def calculate_moving_average(data, window):

    return data['close'].rolling(window=window).mean()

def calculate_macd(data, fast_period, slow_period, signal_period):

    macd = data['close'].ewm(span=fast_period, adjust=False).mean() - data['close'].ewm(span=slow_period, adjust=False).mean()

    signal = macd.ewm(span=signal_period, adjust=False).mean()

    histogram = macd - signal

    return macd, signal, histogram

def plot_chart(data, ma_50, ma_99, macd, signal, histogram):

    fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(12, 8))

    ax1.plot(data['timestamp'], data['close'], label='Close')

    ax1.plot(data['timestamp'], ma_50, label='MA 50')

    ax1.plot(data['timestamp'], ma_99, label='MA 99')

    ax1.legend()

    ax2.plot(data['timestamp'], macd, label='MACD')

    ax2.plot(data['timestamp'], signal, label='Signal')

    ax2.bar(data['timestamp'], histogram, label='Histogram', color='gray')

    ax2.legend()

    plt.xlabel('Timestamp')

    plt.show()

symbol = 'BTCUSDT'

interval = '1d'

limit = 500

data = get_binance_data(symbol, interval, limit)

ma_50 = calculate_moving_average(data, 50)

ma_99 = calculate_moving_average(data, 99)

macd, signal, histogram = calculate_macd(data, 12, 26, 9)

plot_chart(data, ma_50, ma_99, macd, signal, histogram)

Regressione Lineare IA

La regressione lineare è una tecnica statistica utilizzata per studiare la relazione tra una variabile dipendente (o target) e una o più variabili indipendenti (o feature). Lo scopo della regressione lineare è quello di trovare una linea retta che rappresenti al meglio la relazione tra le variabili.

La regressione lineare viene utilizzata principalmente per due scopi:

1. Predizione: una volta stabilita la relazione tra le variabili, è possibile utilizzare il modello per fare previsioni sulla variabile dipendente, dato un valore delle variabili indipendenti. Ad esempio, se si ha un dataset contenente informazioni sulle dimensioni delle case (variabili indipendenti) e sui prezzi (variabile dipendente), è possibile utilizzare la regressione lineare per fare previsioni sui prezzi delle case, date le loro dimensioni.

2. Analisi della relazione: la regressione lineare permette di capire se e in che modo le variabili indipendenti influenzano la variabile dipendente. Attraverso l'analisi dei coefficienti della regressione, è possibile determinare l'entità e la direzione dell'effetto che ogni variabile indipendente ha sulla variabile dipendente. Ad esempio, se si utilizza la regressione lineare per analizzare la relazione tra l'età e il reddito, è possibile determinare se c'è una correlazione positiva o negativa tra le due variabili.

Per calcolare la regressione lineare, si utilizza l'algoritmo dei minimi quadrati. L'obiettivo dell'algoritmo è quello di minimizzare la somma dei quadrati delle differenze tra i valori osservati della variabile dipendente e i valori predetti dal modello. In altre parole, si cerca di trovare la linea retta che minimizza l'errore di previsione.

La regressione lineare può essere applicata a diversi tipi di dati, sia numerici che categorici. Nel caso di variabili categoriche, è necessario utilizzare una codifica appropriata, come la codifica one-hot.

Python offre diverse librerie per eseguire la regressione lineare, come scikit-learn e statsmodels. Queste librerie forniscono funzioni per addestrare il modello di regressione lineare, fare previsioni e analizzare i risultati.

In conclusione, la regressione lineare è uno strumento statistico fondamentale per analizzare la relazione tra variabili e fare previsioni. È ampiamente utilizzata in molti campi, come l'economia, la finanza, la medicina e l'ingegneria.

Qui sotto il link da dove scaricare liberamente il file .py che esegue predizioni su Bitcoin. Ricordo che le previsioni di questo programma non sono affidabili, ma solo un esempio di regressione lineare.

https://drive.google.com/file/d/19dtKuD7OjQMKGP0KiVnsnhawVBN4IzoC/view?usp=drivesdk

Calcolo pivot point in automatico

Questa funzione Python trova la candela

 importante nel dataframe DF e ne 

calcola il Pivot Point e le due

 resistenze e due supporti.

def pivot_point(df):
        pp=0
        r1=0
        r2=0
        s1=0
        s2=0
        ppa=[]
        r1a=[]
        r2a=[]
        s1a=[]
        s2a=[]
        dd=30
        c=0
        important_cand=0
        for i in range(len(df)):
            comp_cand=abs(df['open'][i]-df['close'][i])
            if comp_cand>important_cand:
                important_cand=comp_cand
                nci=i
            pp=(df['high'][nci]+df['low'][nci]+df['close'][nci])/3
            ppa.append(pp)
            r1=(pp*2)-df['low'][nci]
            r1a.append(r1)
            r2=pp+(df['high'][nci]-df['low'][nci])
            r2a.append(r2)
            s1=(pp*2)-df['high'][nci]
            s1a.append(s1)
            s2=pp-(df['high'][nci]-df['low'][nci])
            s2a.append(s2)
            c+=1
            if (df['close'][i]>r2) | (df['close'][i]<s2) | (df['open'][i]>r2) | (df['open'][i]<s2): #il prezzo è fuori dai dati pp azzera la candela importante
                important_cand=0
        df['pp']=ppa
        df['r1']=r1a
        df['r2']=r2a
        df['s1']=s1a
        df['s2']=s2a
        return df

DF deve contenere i campi open, close,

 high, low

Regular expression

 Ecco un esempio di codice Python che utilizza le espressioni regolari (regular expressions):

import re

# Definizione del pattern da cercare

pattern = r'\b(\w+)\b'

# Testo di input

testo = "Questo è un esempio di testo. Contiene parole e numeri come 12345."

# Trova tutte le parole nel testo

parole = re.findall(pattern, testo)

# Stampa le parole trovate

for parola in parole:

    print(parola)

In questo esempio, viene utilizzata la libreria `re` di Python per cercare tutte le parole nel testo di input. Il pattern `r'\b(\w+)\b'` corrisponde a una parola completa, dove `\b` indica un confine di parola e `(\w+)` corrisponde a una sequenza di caratteri alfanumerici. La funzione `findall` restituisce una lista di tutte le corrispondenze trovate nel testo. Infine, viene stampata ogni parola trovata.

Le espressioni regolari (o regex) in Python sono un modo potente per cercare, estrarre e manipolare testo in base a pattern specifici. Sono implementate nel modulo `re` di Python.

Le espressioni regolari sono definite utilizzando una combinazione di caratteri letterali e metacaratteri speciali che rappresentano modelli di testo da cercare. Ad esempio, il metacarattere `.` corrisponde a qualsiasi carattere singolo, mentre il metacarattere `*` indica che il carattere precedente può essere ripetuto zero o più volte.

Ecco un esempio di come utilizzare le espressioni regolari in Python:

import re

# Definiamo un pattern per cercare una sequenza di numeri nel testo

pattern = r'\d+'

# Testo di esempio

testo = 'Ho 3 mele e 5 banane nel mio cesto.'

# Utilizziamo il metodo search() per cercare il pattern nel testo

risultato = re.search(pattern, testo)

# Se il pattern viene trovato, otteniamo il risultato

if risultato:

    print('Risultato trovato:', risultato.group())

else:

    print('Nessun risultato trovato.')

    

In questo esempio, il pattern `r'\d+'` cerca una sequenza di uno o più numeri nel testo. Il metodo `search()` restituisce un oggetto `Match` se il pattern viene trovato, altrimenti restituisce `None`. Utilizziamo il metodo `group()` sull'oggetto `Match` per ottenere la corrispondenza effettiva trovata.

Le espressioni regolari offrono molti altri metacaratteri e funzionalità avanzate per manipolare il testo, come la ricerca di parole intere, la sostituzione di corrispondenze, la ricerca di pattern multipli e molto altro ancora. Per saperne di più, puoi consultare la documentazione ufficiale di Python sul modulo `re`.

Ecco una lista dei metacaratteri utilizzati nelle espressioni regolari in Python:

- `.`: corrisponde a qualsiasi carattere, tranne il carattere di nuova riga (\n).

- `^`: corrisponde all'inizio di una stringa.

- `$`: corrisponde alla fine di una stringa.

- `*`: corrisponde a zero o più occorrenze del carattere precedente.

- `+`: corrisponde a una o più occorrenze del carattere precedente.

- `?`: corrisponde a zero o una occorrenza del carattere precedente.

- `{n}`: corrisponde esattamente a n occorrenze del carattere precedente.

- `{n,}`: corrisponde a n o più occorrenze del carattere precedente.

- `{n,m}`: corrisponde da n a m occorrenze del carattere precedente.

- `[]`: specifica un insieme di caratteri da corrispondere.

- `|`: corrisponde a uno dei due pattern separati da |.

- `()`: raggruppa un pattern e restituisce il match trovato.

- `\`: utilizzato per "scappare" un carattere speciale, ad esempio \. corrisponde a un punto letterale.

Questi sono solo alcuni dei metacaratteri disponibili nelle espressioni regolari in Python. È possibile trovare ulteriori informazioni nella documentazione ufficiale di Python.