Summary
Demonstrates how to leverage Python’s built-in standard library modules to implement advanced mathematical operations, handle dates and times, and perform system-level interactions.

General domain of usage
Date and time manipulation

Pythonin vakiokirjastot (sisäänrakennetut kirjastot) ovat joukko moduuleja, jotka sisältyvät jokaiseen Python-asennukseen. Ne tarjoavat laajan valikoiman toiminnallisuuksia, joiden avulla voit lisätä ohjelmiisi ominaisuuksia ilman lisämoduulien asentamista. Tarkastellaan muutamia keskeisiä kirjastoja, joita tulet käyttämään usein.

### math-kirjasto
math-kirjasto sisältää funktioita matemaattisiin operaatioihin, jotka menevät peruslaskutoimituksia pidemmälle. Se tarjoaa pääsyn C-standardin määrittelemiin matemaattisiin funktioihin.

Esimerkkejä käytöstä:

import math

# Calculating powers
print(math.pow(2, 3))  # Output: 8.0

# Finding square roots
print(math.sqrt(16))  # Output: 4.0

Tässä on luettelo joistakin hyödyllisimmistä funktioista math-kirjastossa:

### datetime-kirjasto
Kun tarvitset työkalun päivämäärien ja aikojen käsittelyyn, datetime-kirjasto on ensisijainen ratkaisu. Se mahdollistaa päivämäärien muunnokset, aikavyöhykkeiden käsittelyn ja paljon muuta.

import datetime

# Getting today's date
today = datetime.date.today()
print(today)  # Output: YYYY-MM-DD

# Calculating a future date
future = today + datetime.timedelta(days=10)
print(future)  # Output: YYYY-MM-DD + 10 days

### Muita merkittäviä kirjastoja
- `os`: mahdollistaa käyttöjärjestelmäriippuvaisten toimintojen, kuten tiedostojen luku ja kirjoitus;
- `sys`: tarjoaa pääsyn joihinkin tulkin käyttämiin tai ylläpitämiin muuttujiin sekä toimintoihin, jotka ovat tiiviisti yhteydessä tulkkiin;
- `json`: JSON-datan jäsentämiseen Python-olioiksi ja päinvastoin.

import os

print(os.getcwd())  # Outputs the current working directory.


import unittest
import user_code
import ast
import re
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_logarithm_of_10(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        import math
        expected_value = math.log(10)
        expected_line = normalize_text(f"The natural logarithm of 10 is: {expected_value}")
        _dynamic_test(
            self,
            expected_line in output,
            "Correctly prints the natural logarithm of 10.",
            f"Expected output line: '{expected_line}' not found in output: '{output}'",
        )

    def test_factorial_of_5(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        import math
        expected_value = math.factorial(5)
        expected_line = normalize_text(f"The factorial of 5 is: {expected_value}")
        _dynamic_test(
            self,
            expected_line in output,
            "Correctly prints the factorial of 5.",
            f"Expected output line: '{expected_line}' not found in output: '{output}'",
        )

    def test_trig_of_30_degrees(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        import math
        radians = math.radians(30)
        sin_val = math.sin(radians)
        cos_val = math.cos(radians)
        tan_val = math.tan(radians)
        sin_line = normalize_text(f"The sine of 30 degrees is: {sin_val}")
        cos_line = normalize_text(f"The cosine of 30 degrees is: {cos_val}")
        tan_line = normalize_text(f"The tangent of 30 degrees is: {tan_val}")
        _dynamic_test(
            self,
            sin_line in output,
            "Correctly prints the sine of 30 degrees.",
            f"Expected output line: '{sin_line}' not found in output: '{output}'",
        )
        _dynamic_test(
            self,
            cos_line in output,
            "Correctly prints the cosine of 30 degrees.",
            f"Expected output line: '{cos_line}' not found in output: '{output}'",
        )
        _dynamic_test(
            self,
            tan_line in output,
            "Correctly prints the tangent of 30 degrees.",
            f"Expected output line: '{tan_line}' not found in output: '{output}'",
        )

    def test_ceil_and_floor_of_9_2(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        import math
        ceil_val = math.ceil(9.2)
        floor_val = math.floor(9.2)
        ceil_line = normalize_text(f"The ceiling value of 9.2 is: {ceil_val}")
        floor_line = normalize_text(f"The floor value of 9.2 is: {floor_val}")
        _dynamic_test(
            self,
            ceil_line in output,
            "Correctly prints the ceiling value of 9.2.",
            f"Expected output line: '{ceil_line}' not found in output: '{output}'",
        )
        _dynamic_test(
            self,
            floor_line in output,
            "Correctly prints the floor value of 9.2.",
            f"Expected output line: '{floor_line}' not found in output: '{output}'",
        )

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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

Saat käytännön taitoja Pythonin moduulien ja tuontien hallintaan tehokasta koodin hallintaa varten. Hallitse kehittyneitä virheenkäsittelytekniikoita luotettavampien sovellusten rakentamiseksi, automatisoi tiedostojen käsittely ja opi vankkoja testausstrategioita Pytestin ja Unittestin avulla varmistaaksesi koodisi eheyden.

Jos koet turhautumista tuontilauseiden, moduulien ja kirjastojen erojen tai Python-projektin rakenteen hallinnan kanssa, tämä osio tarjoaa selkeyttä.

Haluatko debugata koodiasi tehokkaasti ja ymmärtää erilaisten virheiden hyödyntämisen merkityksen? Tämä osio selventää virheenkäsittelyä Pythonissa ja osoittaa, miksi näiden taitojen hallinta on kehittäjille olennaista vankkojen sovellusten rakentamisessa.

Haluatko automatisoida tiedosto-operaatiot projekteissasi? Tämä osio perehtyy Pythonin tiedostojen käsittelyn perusteisiin ja antaa käyttöösi työkalut tiedostojen lukemiseen, kirjoittamiseen ja hallintaan tehokkaasti sujuvampien ja monipuolisempien sovellusten toteuttamiseksi.

Opit Pytestin testauksen yksityiskohdat ja testivetoisen kehityksen (TDD) perusteet. Tämä osio ohjaa sinut luomaan vankkoja testejä, jotka parantavat koodisi luotettavuutta ja tehostavat kehitysprosessiasi.

Hallitse automaatiotestaus Unittestin avulla. Opi kattamaan erilaiset testitapaukset tehokkaasti hyödyntämällä setup-, teardown- ja mocking-toimintoja.

Pythonissa iteraattorit ja generaattorit ovat keskeisiä käsitteitä, jotka mahdollistavat tehokkaan ja muistia säästävän datankäsittelyn. Iteraattorit noudattavat tiettyä protokollaa tietojen peräkkäiseen käsittelyyn, kun taas generaattorit yksinkertaistavat iteraatiota tuottamalla arvoja tarpeen mukaan yield-avainsanalla. Tässä osiossa käsitellään näitä käsitteitä ja niiden käytännön sovelluksia, mikä auttaa hallitsemaan muistitehokasta ohjelmointia.

Pythonin Vakiokirjasto: Olennaiset Moduulit Jokapäiväisiin Tehtäviin

math-kirjasto

datetime-kirjasto

Muita merkittäviä kirjastoja

Ratkaisu