Files
python-doc/Docs/Basic/09-standard-libs.md
2026-02-07 17:17:25 +03:30

267 lines
4.1 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 09 Python Standard Library
This document introduces some of the most commonly used **Python standard library** modules:
* `datetime`
* `math`
* `random`
* `decimal`
These modules come bundled with Python and require no external installation.
---
## 1. Date and Time with `datetime`
The `datetime` module provides classes for working with dates and times.
---
### Working with Dates
#### Code
```python
import datetime
date_1 = datetime.date(2026, 1, 1)
print(date_1.year)
print(date_1.month)
print(date_1.day)
print(date_1.weekday)
print(date_1.ctime)
```
#### Explanation
* `datetime.date(year, month, day)` creates a date object.
* `.year`, `.month`, `.day` access individual components.
#### Important Note
```python
date_1.weekday()
```
* Returns the day of the week as an integer:
* Monday = 0
* Sunday = 6
```python
date_1.ctime()
```
* Returns a human-readable string representation of the date.
---
### Working with Time
#### Code
```python
time_1 = datetime.time(12, 12)
print(time_1.hour)
print(time_1.min)
```
#### Explanation
* `datetime.time(hour, minute)` creates a time object.
* `.hour` returns the hour.
* `.minute` returns the minute.
---
### Working with Date and Time Together
#### Code
```python
abbas_birth = datetime.datetime(2026, 1, 1, 12, 12)
today = datetime.date.today()
now = datetime.datetime.now()
diff_time = now - abbas_birth
```
#### Explanation
* `datetime.datetime` includes both date and time.
* `date.today()` returns todays date.
* `datetime.now()` returns the current date and time.
* Subtracting two `datetime` objects returns a `timedelta`.
---
## 2. Mathematical Operations with `math`
The `math` module provides advanced mathematical functions and constants.
---
### Mathematical Constants
```python
import math
print(math.pi)
print(math.e)
print(math.inf)
```
* `math.pi`: π constant
* `math.e`: Eulers number
* `math.inf`: infinity
---
### Power and Rounding
```python
print(math.pow(2, 3))
print(round(4.2))
print(round(4.8))
```
* `math.pow(a, b)` returns `a` raised to the power of `b`.
* `round()` rounds to the nearest integer.
---
### Floor and Ceil
```python
print(math.floor(4.2))
print(math.floor(4.9))
print(math.ceil(4.2))
print(math.ceil(4.9))
```
* `floor`: rounds down
* `ceil`: rounds up
---
### Logarithms
```python
print(math.log(100, 10))
```
* Returns the logarithm of 100 with base 10.
---
## 3. Random Values with `random`
The `random` module is used to generate pseudo-random values.
---
### Random Numbers
```python
import random
print(random.randint(1, 6))
print(random.random())
```
* `randint(a, b)`: random integer between `a` and `b` (inclusive)
* `random()`: random float between `0` and `1`
---
### Random Selection
```python
number_list = list(range(15))
print(random.choice(number_list))
char_list = ['a', 'm', 's']
print(random.choice(char_list))
```
* `choice()` selects a random element from a sequence.
---
### Shuffling
```python
random.shuffle(number_list)
print(number_list)
```
* `shuffle()` randomly rearranges the list in place.
---
## 4. Decimal Precision with `decimal`
The `decimal` module provides precise decimal arithmetic, avoiding floating-point errors.
---
### Decimal Context
```python
import decimal
print(decimal.getcontext())
```
* Shows current precision and rounding settings.
---
### Float vs Decimal
```python
print(decimal.Decimal(0.1))
print(decimal.Decimal('0.1'))
```
* Passing a float carries floating-point error.
* Passing a string preserves exact value.
---
### Precision Comparison
```python
print(0.1 + 0.2 == 0.3)
```
Returns `False` due to floating-point precision issues.
```python
print(decimal.Decimal(0.1) + decimal.Decimal(0.2) == decimal.Decimal(0.3))
```
Still `False` because the floats are imprecise.
```python
print(decimal.Decimal('0.1') + decimal.Decimal('0.2') == decimal.Decimal('0.3'))
```
Returns `True` because strings preserve precision.
---
## Summary
* `datetime` handles dates and times
* `math` provides mathematical constants and functions
* `random` generates pseudo-random values
* `decimal` solves floating-point precision problems
* Always use strings when creating `Decimal` values