# Отчет по Теме 4

Турханов Артем, А-03-23

## 1 Стандартные функции
```py
>>> help(round)
Help on built-in function round in module builtins:

round(number, ndigits=None)
    Round a number to a given precision in decimal digits.

    The return value is an integer if ndigits is omitted or None.  Otherwise
    the return value has the same type as the number.  ndigits may be negative.

>>> round(123.456,1); round(123.456,0)
123.5
123.0
>>> round(123.456,-1)
120.0
>>> type(round(123.456,1))
<class 'float'>
>>> type(round(123.456,0))
<class 'float'>
>>> round(123.456); type(round(123.456))
123
<class 'int'>
```
Если же в качестве второго аргумента функции round нияего не указывать, то округление будет происходить до целого. Поэтому результат - число целочисленного типа данных (int). В противном же случае результатом будет число вещественного типа.
```py
>>> gg=range(76,123,9); gg; type(gg)
range(76, 123, 9)
<class 'range'>
>>> list(gg)
[76, 85, 94, 103, 112, 121]
>>> range(23)
range(0, 23)
>>> list(range(23))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
```
Если в функцию range передать всего один аргумент, то результатом выполнения функции будет итерируемый объет класса range с целочисленными значениями от 0 до того числа, которое было указано в качестве аргумента, не включительно c шагом по умолчанию, равным единице.

```py
>>> qq = ['Turkhanov', 'Ogarkov', 'Vasiliev', 'Semenov']
>>> ff = zip(gg,qq); ff
<zip object at 0x000001FA9B4AD340>
>>> type(ff)
<class 'zip'>
>>> tuple(ff)
((76, 'Turkhanov'), (85, 'Ogarkov'), (94, 'Vasiliev'), (103, 'Semenov'))
>>> ff[0]; ff[3]
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    ff[0]; ff[3]
TypeError: 'zip' object is not subscriptable
```
В получившемся кортеже мы видим 4 объекта-кортежа, что соответствует длине самого короткого списка из двух (len(gg) = 6, len(qq) = 4). Заметим также, что к объекту ff типа zip нельзя обращаться по индексам.
```py
>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156');
коэффициент усиления=100
>>> dan; type(dan)
344.0
<class 'float'>
>>> 5*100 - 156
344
>>> exec(input('введите инструкции:'))
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
>>> gg
221.456
>>> abs(-10.12)
10.12
>>> pow(2,5)
32
>>> pow(2,5.3)
39.396621227037315
>>> pow(2.4,-5.3)
0.009657849177552984
>>> max(1,-2)
1
>>> min([1,3,-5,-122])
-122
>>> sum([1,3,5,3,7,4])
23
>>> help(divmod)
Help on built-in function divmod in module builtins:

divmod(x, y, /)
    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.

>>> divmod(9,5)
(1, 4)
>>> a = [1,2,3,4,5,6,7,8,9]
>>> len(a)
9
>>> a = map(int, input().split()); a
1 2 3 4 5 6
<map object at 0x000001FA9878E4D0>
>>> list(a)
[1, 2, 3, 4, 5, 6]
```
## 2 Функции из стандартного модуля math
```py
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
>>> help(math.factorial)
Help on built-in function factorial in module math:

factorial(n, /)
    Find n!.

    Raise a ValueError if x is negative or non-integral.

>>> math.factorial(5)
120
>>> math.sin(math.pi/2)
1.0
>>> math.acos(-1)
3.141592653589793
>>> help(math.degrees)
Help on built-in function degrees in module math:

degrees(x, /)
    Convert angle x from radians to degrees.

>>> math.degrees(math.pi)
180.0
>>> math.radians(270)
4.71238898038469
>>> math.pi/2*3
4.71238898038469
>>> math.exp(1); math.exp(3)
2.718281828459045
20.085536923187668
>>> help(math.log)
Help on built-in function log in module math:

log(...)
    log(x, [base=math.e])
    Return the logarithm of x to the given base.

    If the base is not specified, returns the natural logarithm (base e) of x.

>>> math.log(math.exp(1))
1.0
>>> math.log(math.exp(3))
3.0
>>> math.log10(pow(10,5))
5.0
>>> math.sqrt(121); math.sqrt(25)
11.0
5.0
>>> help(math.ceil)
Help on built-in function ceil in module math:

ceil(x, /)
    Return the ceiling of x as an Integral.

    This is the smallest integer >= x.

>>> math.ceil(3.2); math.ceil(6.999)
4
7
>>> help(math.floor)
Help on built-in function floor in module math:

floor(x, /)
    Return the floor of x as an Integral.

    This is the largest integer <= x.

>>> math.floor(3.2); math.floor(6.999)
3
6
>>> math.sin(2*math.pi/7 + pow(math.exp(1), 0.23))
0.8334902641414562
```
## 3 Функции из модуля cmath
```py
>>> import cmath
>>> dir(cmath)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
>>> cmath.sqrt(1.2-0.5j)
(1.118033988749895-0.22360679774997896j)
>>> cmath.phase(1-0.5j)
-0.4636476090008061
```
## 4 Стандартный модуль random
```py
>>> import random
>>> dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
>>> help(random.seed)
Help on method seed in module random:

seed(a=None, version=2) method of random.Random instance
    Initialize internal state from a seed.

    The only supported seed types are None, int, float,
    str, bytes, and bytearray.

    None or no argument seeds from current time or from an operating
    system specific randomness source if available.

    If *a* is an int, all bits are used.

    For version 2 (the default), all of the bits are used if *a* is a str,
    bytes, or bytearray.  For version 1 (provided for reproducing random
    sequences from older versions of Python), the algorithm for str and
    bytes generates a narrower range of seeds.

>>> random.seed()

>>> help(random.uniform)
Help on method uniform in module random:

>>> uniform(a, b) method of random.Random instance
    Get a random number in the range [a, b) or [a, b] depending on rounding.

    The mean (expected value) and variance of the random variable are:

        E[X] = (a + b) / 2
        Var[X] = (b - a) ** 2 / 12

>>> random.uniform(1,10)
7.820969962495622
>>> help(random.random)
Help on built-in function random:

random() method of random.Random instance
    random() -> x in the interval [0, 1).
>>> random.random()
0.21580642037220688
>>> help(random.randint)
Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

>>> random.randint(1,10)
1
>>> help(random.gauss)
Help on method gauss in module random:

gauss(mu=0.0, sigma=1.0) method of random.Random instance
    Gaussian distribution.

    mu is the mean, and sigma is the standard deviation.  This is
    slightly faster than the normalvariate() function.

    Not thread-safe without a lock around calls.

>>> random.gauss(10, 2)
6.560077457806456
>>> help(random.choice)
Help on method choice in module random:

choice(seq) method of random.Random instance
    Choose a random element from a non-empty sequence.

>>> random.choice([1,2,3,4,5,6,7,8,9])
1
>>> help(random.shuffle)
Help on method shuffle in module random:

shuffle(x) method of random.Random instance
    Shuffle list x in place, and return None.

>>> x = [1,2,3,4,5,6,7,8,9]
>>> random.shuffle(x); x
[5, 7, 4, 3, 8, 1, 9, 2, 6]
>>> help(random.betavariate)
Help on method betavariate in module random:

betavariate(alpha, beta) method of random.Random instance
    Beta distribution.

    Conditions on the parameters are alpha > 0 and beta > 0.
    Returned values range between 0 and 1.

    The mean (expected value) and variance of the random variable are:

        E[X] = alpha / (alpha + beta)
        Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
>>> random.betavariate(1,2)
0.31509637997467377
>>> help(random.gammavariate)
Help on method gammavariate in module random:

gammavariate(alpha, beta) method of random.Random instance
    Gamma distribution.  Not the gamma function!

    Conditions on the parameters are alpha > 0 and beta > 0.

    The probability distribution function is:

                x ** (alpha - 1) * math.exp(-x / beta)
      pdf(x) =  --------------------------------------
                  math.gamma(alpha) * beta ** alpha

    The mean (expected value) and variance of the random variable are:

        E[X] = alpha * beta
        Var[X] = alpha * beta ** 2

>>> random.gammavariate(1,2)
0.0676205462545973
>>> ls = [random.uniform(0,10), random.gauss(0,3), random.betavariate(1,2), random.gammavariate(1,2)]; ls
[9.745005344582257, 2.16302978480045, 0.8426318147572717, 0.1932454384006428]
```
## 5 Функции из модуля time
```py
>>> import time
>>> dir(time)
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
>>> c1 = time.time(); c1
1759138103.1649246
>>> c2=time.time()-c1; c2
21.219618320465088
>>> dat=time.gmtime(); dat
time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=9, tm_min=29, tm_sec=17, tm_wday=0, tm_yday=272, tm_isdst=0)
>>> dat.tm_mon
9
>>> dat.tm_year; dat.tm_sec
2025
17
>>> time.localtime()
time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=12, tm_min=30, tm_sec=53, tm_wday=0, tm_yday=272, tm_isdst=0)
>>> help(time.asctime)
Help on built-in function asctime in module time:

asctime(...)
    asctime([tuple]) -> string

    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
    When the time tuple is not present, current time as returned by localtime()
    is used.
>>> time.asctime(time.localtime())
'Mon Sep 29 12:31:59 2025'
>>> time.ctime()
'Mon Sep 29 12:32:27 2025'
>>> help(time.ctime)
Help on built-in function ctime in module time:

ctime(...)
    ctime(seconds) -> string

    Convert a time in seconds since the Epoch to a string in local time.
    This is equivalent to asctime(localtime(seconds)). When the time tuple is
    not present, current time as returned by localtime() is used.

>>> time.ctime(time.time())
'Mon Sep 29 12:33:19 2025'
>>> help(time.sleep)
Help on built-in function sleep in module time:

sleep(object, /)
    sleep(seconds)

    Delay execution for a given number of seconds.  The argument may be
    a floating-point number for subsecond precision.

>>> time.sleep(10)
>>> time.mktime(time.localtime())
1759138661.0
>>> time.time()
1759138670.3741279
```
## 6 Графические функции
```py
>>> import pylab
>>> x=list(range(-3,55,4))
>>> t=list(range(15))
>>> pylab.plot(t,x)
[<matplotlib.lines.Line2D object at 0x0000015807FF87D0>]
>>> pylab.title('Первый график')
Text(0.5, 1.0, 'Первый график')
>>> pylab.xlabel('время')
Text(0.5, 0, 'время')
>>> pylab.ylabel('сигнал')
Text(0, 0.5, 'сигнал')
>>> pylab.show()
```
![Рисунок 1. Первый линейный график](Ris1.png)

На рис. 1 мы видим отображение линйной зависимости x(t) в виде графика функции, являющегося прямой.
```py
>>> X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
>>> pylab.plot(X1)
[<matplotlib.lines.Line2D object at 0x00000158080ACF50>]
>>> pylab.plot(X2)
[<matplotlib.lines.Line2D object at 0x00000158080AD090>]
>>> pylab.show()
```
![Рисунок 2. Несколько графиков на однои рисунке](Ris2.png)
```py
>>> region=['Центр','Урал','Сибирь','Юг']
>>> naselen=[65,12,23,17]
>>> pylab.pie(naselen,labels=region)
([<matplotlib.patches.Wedge object at 0x0000015807183B60>, <matplotlib.patches.Wedge object at 0x000001580AB76990>, <matplotlib.patches.Wedge object at 0x000001580AB76D50>, <matplotlib.patches.Wedge object at 0x000001580AB76FD0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
>>> pylab.show()
```
![Рисунок 3. Круговая диаграмма](Ris3.png)

```py
>>> data = [random.gauss() for i in range(1000)]
>>> pylab.hist(data, bins = 30)
(array([ 1.,  0.,  0.,  0.,  0.,  3.,  4., 15., 10., 19., 35., 53., 53.,
       60., 90., 82., 90., 99., 96., 67., 65., 52., 32., 34.,  9., 14.,
        9.,  4.,  3.,  1.]), array([-3.99649362, -3.76019089, -3.52388816, -3.28758542, -3.05128269,
       -2.81497996, -2.57867722, -2.34237449, -2.10607176, -1.86976903,
       -1.63346629, -1.39716356, -1.16086083, -0.92455809, -0.68825536,
       -0.45195263, -0.2156499 ,  0.02065284,  0.25695557,  0.4932583 ,
        0.72956103,  0.96586377,  1.2021665 ,  1.43846923,  1.67477197,
        1.9110747 ,  2.14737743,  2.38368016,  2.6199829 ,  2.85628563,
        3.09258836]), <BarContainer object of 30 artists>)
>>> pylab.show()
```
![Рисунок 4. Гистограмма по выборке нормально распределенных значений](Ris4.png)

```py
>>> cat = ['Сентябрь', 'Октябрь', 'Ноябрь']
>>> values = [100, 200, 30]
>>> pylab.bar(cat, values)
<BarContainer object of 3 artists>
>>> pylab.title('Столбчатая диаграмма')
Text(0.5, 1.0, 'Столбчатая диаграмма')
>>> pylab.xlabel('Месяц')
Text(0.5, 0, 'Месяц')
>>> pylab.ylabel('Количество заявок, шт')
Text(0, 0.5, 'Количество заявок, шт')
>>> pylab.show()
```
![Рисунок 5. Столбчатая диаграмма](Ris5.png)

## 7 Статистические функции
```py
>>> import statistics
>>> data = [random.gauss(10,3) for i in range(1000)]
>>> statistics.mean(data)
10.13981944059001
>>> statistics.stdev(data)
3.053185233060045
>>> statistics.median(data)
10.073166882507437
```