Python fornisce diverse operazioni matematiche aggiuntive.

# Default division
print(18 / 4)

# Floor division
print(18 // 4)

# Remainder of the division
print(18 % 4)

# Raising to the power of 4
print(18 ** 4)

### Perché Queste Operazioni Sono Utili?  

Immagina di avere **$50** e di voler comprare il maggior numero possibile di pacchetti di biscotti, con ogni pacchetto che costa **$6**. Per determinare quanti pacchetti puoi comprare e quanti soldi rimarranno, puoi usare queste operazioni:  

- `50 // 6` dà `8`, il che significa che puoi comprare **8 pacchetti**.  
- `50 % 6` risulta in `2`, il che significa che ti rimarranno **$2** dopo l'acquisto.  

import unittest
import importlib
import io
import re
import sys

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_floor_division_present(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        floor_div_check = re.search(r'234\s*//\s*32', user_code_source)

        _dynamic_test(
            self,
            floor_div_check is not None,
            "The floor division operation `234 // 32` is present.",
            "Expected the floor division operation `234 // 32` to be present."
        )

    def test_modulus_operation_present(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        modulus_check = re.search(r'356\s*%\s*17', user_code_source)

        _dynamic_test(
            self,
            modulus_check is not None,
            "The modulus operation `356 % 17` is present.",
            "Expected the modulus operation `356 % 17` to be present."
        )

    def test_floor_division_output_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")

        _dynamic_test(
            self,
            output[0] == "7",
            "The correct result `7` is printed for floor division.",
            f"Expected `7` to be printed, but got `{output[0]}`."
        )

    def test_modulus_output_correct(self):
        import user_code
        captured_output = io.StringIO()
        sys.stdout = captured_output
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        output = captured_output.getvalue().strip().split("\\n")

        _dynamic_test(
            self,
            output[1] == "16",
            "The correct result `16` is printed for modulus.",
            f"Expected `16` to be printed, but got `{output[1]}`."
        )

if __name__ == '__main__':
    unittest.main()


test_main.py

Python è un linguaggio di programmazione interpretato di alto livello e a scopo generale. A differenza di HTML, CSS e JavaScript, che sono utilizzati principalmente per lo sviluppo web, Python è versatile e può essere utilizzato in vari campi, tra cui lo sviluppo software, la scienza dei dati e lo sviluppo back-end. In questo corso, esplorerai gli aspetti fondamentali di Python e, alla fine, sarai in grado di creare le tue funzioni!

Immergiti nei fondamenti di Python, esplora il tuo spazio di lavoro e esegui semplici operazioni matematiche. Impara a scrivere codice leggibile usando i commenti e gestisci espressioni matematiche sia di base che avanzate mentre visualizzi i tuoi risultati.

Impara come memorizzare e gestire i dati in Python lavorando con numeri, testo e variabili. Comprendi come assegnare valori, seguire le convenzioni di denominazione ed esplorare diversi tipi di dati. Acquisisci esperienza pratica con operazioni su stringhe, indicizzazione, slicing e tecniche di richiamo della memoria per manipolare efficacemente il testo in Python.

Impara a utilizzare operatori di confronto e logici, a lavorare con espressioni condizionali e ad applicare confronti di appartenenza e di tipo. Costruisci una solida base nella scrittura di programmi che rispondono dinamicamente a diverse condizioni utilizzando le strutture if/else e if/elif/else.

Espandi la tua comprensione dei tipi di dati imparando a raggruppare più attributi all'interno di una singola variabile. Esplora lists, tuples e dictionaries per memorizzare e gestire in modo efficiente dati strutturati, insieme ai metodi essenziali per la manipolazione e il recupero.

Padroneggia l'arte di scrivere cicli in Python—costrutti essenziali per iterare su liste, tuple, dizionari e altre strutture dati. Impara a usare efficacemente i cicli while e for, esplora la funzione range e lavora con cicli annidati per gestire modelli di iterazione complessi.

Esplora le funzioni essenziali integrate in Python e fai il passo successivo creando le tue. Impara a definire funzioni, utilizzare la logica condizionale, modificare le funzioni esistenti e lavorare con le espressioni lambda per scrivere codice efficiente e riutilizzabile.

Gestire Matematica Più Complessa in Python

Perché Queste Operazioni Sono Utili?

Soluzione

Gestire Matematica Più Complessa in Python

Perché Queste Operazioni Sono Utili?

Soluzione