From 4bc86f481a733701d08e6cac176de56664fe9b6f Mon Sep 17 00:00:00 2001 From: TimoshenkoAA Date: Sat, 27 Sep 2025 12:14:00 +0000 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=20=D0=BE=D1=82=D1=87=D0=B5=D1=82=20=D0=BF=D0=BE=20=D0=9B?= =?UTF-8?q?=D0=A04?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA4/report.md | 858 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 858 insertions(+) create mode 100644 TEMA4/report.md diff --git a/TEMA4/report.md b/TEMA4/report.md new file mode 100644 index 0000000..5a80819 --- /dev/null +++ b/TEMA4/report.md @@ -0,0 +1,858 @@ +# Тема 4. Встроенные функции +#Выполнил : Тимошенко А.А. +#Проверил : Козлюк Д.А. + +## Пункт 1 +``` +>>> import os +>>> os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА4") +``` +## Пункт 2 + +Стандартные функции (модуль builtins, импортированный по умолчанию во все скрипты) + +### Пункт 2.1 + +round() - округление с заданной точностью +``` +>>> 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) +123.5 +>>> type(round(123.456,1)) + +>>> round(123.456,0) +123.0 +>>> type(round(123.456,0)) + +>>> round(123.456) +123 +>>> type(round(123.456)) + +``` +Таким образом, если ndigits не указан, функция возвращает округленное целое число. +Если указан, пускай даже ноль, то число с плавающей точкой. + + +### Пункт 2.2 + +range() - генерация последовательности +``` +>>> help(range) +Help on class range in module builtins: + +class range(object) + | range(stop) -> range object + | range(start, stop[, step]) -> range object + | + | Return an object that produces a sequence of integers from start (inclusive) + | to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1. + | start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3. + | These are exactly the valid indices for a list of 4 elements. + | When step is given, it specifies the increment (or decrement). + +>>> gg=range(76,123,9) +>>> gg +range(76, 123, 9) +``` +Функция возвращает итерируемый объект типа range: +``` +>>> type(range(76,123,9)) + +``` +Чтобы прочитать результат, можно записать в список: +``` +>>> list(gg) +[76, 85, 94, 103, 112, 121] +``` +### Пункт 2.3 + +zip() - создание итерируемого объекта из кортежей +``` +>>> qq=["Тимошенко","Ходюк","Коваленко","Иванов"] +>>> ff = zip (gg, qq) +>>> ff + +>>> tuple(ff) +((76, 'Тимошенко'), (85, 'Ходюк'), (94, 'Коваленко'), (103, 'Иванов')) +``` +1. Длина получившегося объекта - меньшая из длин объектов-параметров. В данном случае, это 4. +2. Объект класса zip не итерируемый: +``` +>>> ff[1] +Traceback (most recent call last): + File "", line 1, in + ff[1] +TypeError: 'zip' object is not subscriptable +``` +3. Объект класса zip неизменяемый. + +### Пункт 2.4 + +eval - вычисление выражения строкой +``` +>>> help(eval) +Help on built-in function eval in module builtins: + +eval(source, globals=None, locals=None, /) + Evaluate the given source in the context of globals and locals. + + The source may be a string representing a Python expression + or a code object as returned by compile(). + The globals must be a dictionary and locals can be any mapping, + defaulting to the current globals and locals. + If only globals is given, locals defaults to it. + +>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156') +коэффициент усиления=13 +>>> fff +13.0 +>>> dan +-91.0 +``` +Пояснение: + Если выражение будет записанно некорректно, будет возвращена SyntaxError. + По умолчанию eval() имеет доступ к глобальным именам. + eval() выполняет следующую последовательность действий: + Парсинг выражения + Компилирование в байт-код + Выполнение кода + Возвращение результата + + +### Пункт 2.5 + +exec - выполнение операций строкой +``` +>>> help(exec) +Help on built-in function exec in module builtins: + +exec(source, globals=None, locals=None, /) + Execute the given source in the context of globals and locals. + + The source may be a string representing one or more Python statements + or a code object as returned by compile(). + The globals must be a dictionary and locals can be any mapping, + defaulting to the current globals and locals. + If only globals is given, locals defaults to it. + +>>> exec(input('введите инструкции:')) +введите инструкции:perem=-123.456; gg=round(abs(perem)+98,3) +>>> gg +221.456 +``` +Пояснение: + eval используется только для вычисления выражений и возвращает результат. + exec может выполнять любой код, но не возвращает значение. + +### Пункт 2.6 + +Возвращение модуля (abs): +``` +>>> abs(-98) +98 +>>> abs(5 + 4j) +6.4031242374328485 +``` +Возведение в степень: +``` +>>> help(pow) +Help on built-in function pow in module builtins: +pow(base, exp, mod=None) + Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments + + Some types, such as ints, are able to use a more efficient algorithm when + invoked using the three argument form. + +>>> pow(5,5) +3125 +>>> pow(5,5,10) +5 +``` +Максимальное из значений: +``` +>>> help(max) +Help on built-in function max in module builtins: + +max(...) + max(iterable, *[, default=obj, key=func]) -> value + max(arg1, arg2, *args, *[, key=func]) -> value + With a single iterable argument, return its biggest item. The + default keyword-only argument specifies an object to return if + the provided iterable is empty. + With two or more arguments, return the largest argument. + +Обычный пример использования: +``` +>>> max(35,4,-3) +35 +``` +Со списком: +``` +>>> max([5,0,-10]) +5 +``` +Со словарем: +``` +>>> max({'a': 1, 'b': 2, 'c': 3}) +'c' +``` +Пояснение: + 1. Видно, что выбор большего происходит из ключей + 2. Видно, что среди буквенных символов больше то, которое ближе к концу алфавита + +С разными типами: +``` +>>> max([34,5,6, "hehe", 5+2j]) +Traceback (most recent call last): + File "", line 1, in + max([34,5,6, "hehe", 5+2j]) +TypeError: '>' not supported between instances of 'str' and 'int' +``` +Пояснение: + Видно, что внутри функции max заложен оператор сравнения, и между разными типами + он не работает. + +Одинаковые символы разного регистра: +``` +>>> max("b", "B") +'b' +``` +Пояснение: тут python сравнивает коды символов в unicode. у "b" это 98, а у "B" - 66. + +Поиск минимума: + +Нюансы аналогичны максимуму, поэтому детально расписаны не будут. +``` +>>> min(float("-inf"), -99, 0, 12) +-inf +``` +Сумма элементов: +``` +>>> help(sum) +Help on built-in function sum in module builtins: + +sum(iterable, /, start=0) + Return the sum of a 'start' value (default: 0) plus an iterable of numbers + When the iterable is empty, return the start value. + This function is intended specifically for use with numeric values and may + reject non-numeric types. +``` +Просто суммирование: +``` +>>> sum([1,2,3,4]) +10 +``` +Суммирование с значением, которое добавляется к сумме: +``` +>>> sum([1,2,3,4], -5) +5 +``` +Возвращение кортежа из целой части и остатка от деления: +``` +>>> 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(14, 3) +(4, 2) +``` +Иногда результаты для отрицательных чисел могут быть неочевидны: +``` +>>> divmod(14, -3) +(-5, -1) +``` +Длина объекта: +``` +>>> len((1,2,3,4,10)) +5 +>>> len("kukukukukuku") +12 +>>> len(["kukukukukkuuk","kuku"]) +2 +>>> len({'a': 1, 'b': 2, 'c': 3}) +3 +``` +Но при этом: +``` +>>> len(43) +Traceback (most recent call last): + File "", line 1, in + len(43) +TypeError: object of type 'int' has no len() +``` +Применение функции к каждому элементу коллекции: +``` +>>> help(map) +Help on class map in module builtins: +class map(object) + | map(func, *iterables) --> map object + | + | Make an iterator that computes the function using arguments from + | each of the iterables. Stops when the shortest iterable is exhausted. +``` +Пример: +``` +>>> map(int, ["1", "14"]) + +>>> list(map(int, ["1", "14"])) +[1, 14] +``` +Как следует из справки, если сообщается несколько коллекций, map закончится, когда применит +функцию к самой короткой из них. + +## Пункт 3 + +Стандартный модуль math +``` +>>> import math +>>> dir(math) +['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', + 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', + 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', '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', 'tan', 'tanh', 'tau', 'trunc', 'ulp'] + +>>> help(math.factorial) +Help on built-in function factorial in module math: + +factorial(x, /) + Find x!. + + Raise a ValueError if x is negative or non-integral. + +>>> math.factorial(5) +120 +``` +Нахождение синуса: +``` +>>> help(math.sin) +Help on built-in function sin in module math: +sin(x, /) + Return the sine of x (measured in radians). + +>>> math.sin(3.141) +0.0005926535550994539 +>>> math.sin(-1) +-0.8414709848078965 +``` +Нахождение арккосинуса: +``` +>>> math.acos(1) +0.0 +>>> math.acos(11) +Traceback (most recent call last): + File "", line 1, in + math.acos(11) +ValueError: math domain error + +>>> 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(6.28) +359.817495342157 + +>>> math.degrees(1) +57.29577951308232 +``` +Перевод из градусов в радианы: +``` +>>> help(math.radians) +Help on built-in function radians in module math: +radians(x, /) + Convert angle x from degrees to radians. + +>>> math.radians(360) +6.283185307179586 +>>> math.radians(90) +1.5707963267948966 +>>> math.radians(57) +0.9948376736367679 +>>> math.radians(3.1415) +0.05482951845140187 +``` +Число е в степени заданного: +``` +>>> help(math.exp) +Help on built-in function exp in module math: +exp(x, /) + Return e raised to the power of x. + +>>> math.exp(0) +1.0 +>>> math.exp(1) +2.718281828459045 +>>> math.exp(-5) +0.006737946999085467 +``` +Нахождение логарифма: +``` +>>> 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 not specified, returns the natural logarithm (base e) of x. +``` +Если основание логарифма не задано, то он натуральный. +``` +>>> math.log(math.e) +1.0 +>>> math.log(5) +1.6094379124341003 +>>> math.log(25,5) +2.0 +``` +Согласно нормам математики, логарифмируемое выражение и основание логарифма не могут быть +отрицательными. Это есть и в python, попытка задать такие значения вернет ValueError. + +Десятичный логарифм: +``` +>>> math.log10(0.0001) +-4.0 +>>> math.log10(10000) +4.0 +``` +Извлечение квадратного корня: +``` +>>> math.sqrt(49) +7.0 +``` +В данном случае, в отличие от канонов матанализа, задание отрицательного аргумента вернет +ValueError, а не комплексное число. + +Округление числа до ближайшего целого вверх: +``` +>>> 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(5.77) +6 +>>> math.ceil(6.00001) +7 +>>> math.ceil(-6.7) +-6 +>>> math.ceil(-6) +-6 +``` +Округление вниз: +``` +>>> math.floor(7.99) +7 +>>> math.floor(-3.7) +-4 +``` +Константа: число пи: +``` +>>> math.pi +3.141592653589793 +``` +Пример комбинированного использования: +``` +>>> math.sin(2 * math.pi / 7 + math.exp(0.23)) +0.8334902641414562 +``` + +## Пункт 4 +``` +Модуль cmath для работы с комплексными числами + +>>> 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 +``` +## Пункт 5 + +Модуль random для генерации псевдослучайных чисел и работы с ними +``` +>>> import random +>>> dir(random) +['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', + 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', + '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', + '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi', + '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', + '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', + 'getrandbits', 'getstate', 'lognormvariate', '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() +``` +Эта функция инициализирует сид, т.е. начальное значение для дальнейшей генерации. Если ничего +не указано в скобках, то random.seed() вызывает time.time(), а эта функция, в свою очередь, +возвращает время в Unix-формате. То есть в качестве сида используется текущее время. + +Случайное число от 0 до 1: +``` +>>> 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.009279717292968392 +>>> random.random() +0.8044346046065457 +>>> random.random() +0.2928444484701447 +``` +Равномерно распределенное случайное число: +``` +>>> 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. + +>>> random.uniform(2,5) +4.803201121309196 +``` +Равномерное случайное целое: +``` +>>> 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(3,18) +5 +>>> random.randint(3,18) +13 +``` +Случайное из коллекции: +``` +>>> 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. +``` +Вернет IndexError, если коллекция пустая. +``` +>>> random.choice([False, "hehehe", 67, 90.7, 5+8j]) +90.7 +``` +Случайное перемешивание элементов коллекции: +``` +>>> help(random.shuffle) +Help on method shuffle in module random: + +shuffle(x, random=None) method of random.Random instance + Shuffle list x in place, and return None. + Optional argument random is a 0-argument function returning a + random float in [0.0, 1.0); if it is the default None, the + standard random.random will be used. + +>>> lst = [False, "hehehe", 67, 90.7, 5+8j] +>>> random.shuffle(lst) +>>> lst +[67, False, 90.7, (5+8j), 'hehehe'] +``` +Возвращает None, изменяет исходный объект. Работает только с изменяемами типами. + +Нормально распределенное случайное число: +``` +>>> help(random.gauss) +Help on method gauss in module random: + +gauss(mu, sigma) 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. +``` +Без заданных матожидания и дисперсии, в отличие, например, от R, возвращает TypeError, а не +берет 0 и 1 как значения по умолчанию. +``` +>>> random.gauss(0,1) +1.1859475053515318 +``` +Случайное подмножество: +``` +>>> help(random.sample) +Help on method sample in module random: + +sample(population, k, *, counts=None) method of random.Random instance + Chooses k unique random elements from a population sequence or set. + + Returns a new list containing elements from the population while + leaving the original population unchanged. <...> + +>>> random.sample(lst, 5) +['cherry', 'tangerine', 'banana', 'pineapple', 'peach'] +>>> random.sample(lst, 1) +['tangerine'] +>>> random.sample(lst, 0) +[] +``` +Поставить как k число большее, чем длина коллекции, нельзя (TypeError) + +Случайное число, подчиняющееся бета-распределению: +``` +>>> 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. + +>>> random.betavariate(1,2) +0.4074810441922475 +``` +Случайное число, подчиняющееся гамма-распределению: +``` +>>> 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 + +>>> random.gammavariate(2,4) +1.9359228890418254 +``` +Список из четырех чисел с разными законами распределения: +``` +>>> rl = [0] * 4 +>>> rl[0] = random.uniform(2,6) +>>> rl[1] = random.gauss(2, 0.5) +>>> rl[2] = random.betavariate(2,6) +>>> rl[3] = random.gammavariate(2,6) +>>> rl +[2.6190336401985204, 1.82010731374589, 0.18732603571429413, 20.348843073887398] +``` +## Пункт 6 +``` +time - модуль для работы со временем +>>> 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'] +``` +UNIX-время: +``` +>>> c1 = time.time() +>>> c1 +1758971496.5712385 +>>> c2=time.time()-c1 +>>> c2 +8.266037702560425 +``` +Возвращается время в секундах с начала эпохи UNIX: 00:00:00 UTC 1 января 1970 года. + +Текущее время: +``` +>>> time.gmtime + + +>>> help(time.gmtime) +Help on built-in function gmtime in module time: + +gmtime(...) + gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min, + tm_sec, tm_wday, tm_yday, tm_isdst) + + Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a. + GMT). When 'seconds' is not passed in, convert the current time instead. + + If the platform supports the tm_gmtoff and tm_zone, they are available as + attributes only.>>> dat=time.gmtime() + +>>> dat=time.gmtime() +>>> list(dat) +[2025, 9, 27, 11, 12, 18, 5, 270, 0] +>>> dat.tm_mon +9 +>>> dat.tm_year +2025 +>>> dat.tm_yday +270 +>>> dat.tm_isdst #Показывает, действует ли летнее время (0 - нет, 1 - да, -1 - нет данных) +0 +``` +Текущее время с учетом часового пояса: +``` +>>> here = time.localtime() +>>> list(here) +[2025, 9, 27, 14, 16, 28, 5, 270, 0] +``` +Время из кортежа в строку: +``` +>>> time.asctime(here) +'Sat Sep 27 14:16:28 2025' +``` +Время из секунд в строку: +``` +>>> time.ctime() +'Sat Sep 27 14:17:07 2025' +``` +Пауза: +``` +>>> time.sleep(5) +``` +Из кортежа в секунды с начала эпохи: +``` +>>> time.mktime(here) +1758971788.0 +``` +## Пункт 7 +``` +Графические функции модуля pylab пакета matplotlib + +>>> import matplotlib +>>> import pylab + +>>> x=list(range(-3,55,4)) +>>> t=list(range(15)) + +>>> pylab.plot(t,x) #Создание графика в оперативной памяти +[] + +>>> pylab.title('Первый график') +Text(0.5, 1.0, 'Первый график') + +>>> pylab.xlabel('время') +Text(0.5, 0, 'время') +>>> pylab.ylabel('сигнал') +Text(0, 0.5, 'сигнал') + +>>> pylab.show() +``` +Открылось внешнее окно с графиком. Файл сохранен с именем Ris1 + +Два графика на одном окне: +``` +>>> X1=[12,6,8,10,7] +>>> X2=[5,7,9,11,13] +>>> pylab.plot(X1) +[] +>>> pylab.plot(X2) +[] +>>> pylab.show() +``` +Появились две ломаные линии синего и оранжевого цвета. + +Круговая диаграмма: +``` +>>> region=['Центр','Урал','Сибирь','Юг'] +>>> naselen=[65,12,23,17] +>>> naselen=[65,12,23,17] +([, , , ], [Text(-0.1910130855889933, 1.083288512416601, 'Центр'), Text(-0.8613283319035216, -0.6841882085072037, 'Урал'), Text(0.04429273729355889, -1.0991078898011077, 'Сибирь'), Text(0.9873752043868569, -0.4848610169543564, 'Юг')]) +>>> pylab.show() +``` +Сохранено в Ris2 + +Столбиковая диаграмма: +``` +>>> fruits = ["apple", "date", "apricot", "raspberry", "watermelon"] +>>> values = [10, 15, 7, 20, 3] +>>> pylab.bar(fruits, values, color='skyblue') + +>>> pylab.show() +``` +Сохранено в Ris4 + +## Пункт 8 + +Статистический модуль statistics +``` +>>> dir(s) +['Counter', 'Decimal', 'Fraction', 'NormalDist', 'StatisticsError', '__all__', + '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', + '__package__', '__spec__', '_coerce', '_convert', '_exact_ratio', '_fail_neg', + '_find_lteq', '_find_rteq', '_isfinite', '_normal_dist_inv_cdf', '_ss', '_sum', + 'bisect_left', 'bisect_right', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', + 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'log', 'math', 'mean', 'median', + 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'numbers', 'pstdev', + 'pvariance', 'quantiles', 'random', 'sqrt', 'stdev', 'tau', 'variance'] +``` +Математическое ожидание: +``` +>>> data = [10, 20, 30, 40, 50] +>>> statistics.mean(data) +30 +``` +Если объект пустой, вернет StatisticsError + +Медиана: +``` +>>> statistics.median(data) +30 +``` +Среднеквадратичное отклонение: +``` +>>> statistics.stdev(data) +15.811388300841896 +``` +Среднее можно сообщить самостоятельно: stdev(data, xbar=None) + +Дисперсия: +``` +>>> statistics.variance(data) +250 +``` +Квантили: +``` +>>> data = [10, 56, 73, 7, 20, 30, 40, 50, 56, 77, 3] +>>> statistics.quantiles(data) +[10.0, 40.0, 56.0] +``` +По умолчанию n = 4, это квартили. Можно указать 100, например, для процентилей. + +