|
|
#Тема 4 Туровец Евгений
|
|
|
## 2. Стандартные функции. Находятся в модуле builtins, который становится доступным без импорта при запуске среды IDLE.
|
|
|
### 2.1. Функция round – округление числа с заданной точностью.
|
|
|
```py
|
|
|
round(123.456,1)
|
|
|
123.5
|
|
|
round(123.456,0)
|
|
|
123.0
|
|
|
type(round(123.456,1))
|
|
|
<class 'float'>
|
|
|
type(round(123.456,0))
|
|
|
<class 'float'>
|
|
|
type(123.0)
|
|
|
<class 'float'>
|
|
|
type(123.5)
|
|
|
<class 'float'>
|
|
|
round(123.456)
|
|
|
123
|
|
|
type(123)
|
|
|
<class 'int'>
|
|
|
type(round)
|
|
|
<class 'builtin_function_or_method'>
|
|
|
```
|
|
|
### 2.2. Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
|
|
|
```py
|
|
|
gg=range(76,123,9) #генерирует числа, начиная с 76 и прибавляя 9, пока не достигнет числа, которое больше или равно 123
|
|
|
type(gg)
|
|
|
<class 'range'>
|
|
|
list(gg)
|
|
|
[76, 85, 94, 103, 112, 121]
|
|
|
range(23) #функция создаст последовательность чисел от 0 до 22 включительно с шагом 1
|
|
|
range(0, 23)
|
|
|
```
|
|
|
### 2.3. Функция zip – создание общего объекта, элементами которого являются кортежи, составленные из элементов двух или более объектов-последовательностей (zip – застежка-«молния»). Длина результирующего объекта равна длине самого короткого объекта из двух аргументов функции.
|
|
|
```py
|
|
|
qq=["Снегура", "Туровец", "Хатюхин", "Шабатов"]
|
|
|
list(gg)
|
|
|
[76, 85, 94, 103, 112, 121]
|
|
|
ff=zip(gg,qq)
|
|
|
ff
|
|
|
<zip object at 0x00000203B0C7EF40>
|
|
|
type(ff) #количество элементов-кортежей в объекте определяется размерностью меньшего объекта
|
|
|
<class 'zip'>
|
|
|
tuple(ff)
|
|
|
((76, 'Снегура'), (85, 'Туровец'), (94, 'Хатюхин'), (103, 'Шабатов'))
|
|
|
ff[1] #непосредственно объект ff, возвращаемый функцией zip, является итератором. У итераторов нет метода __getitem__, который позволяет обращаться к элементам по индексу. Попытка сделать это вызовет ошибку TypeError.
|
|
|
Traceback (most recent call last):
|
|
|
File "<pyshell#21>", line 1, in <module>
|
|
|
ff[1]
|
|
|
TypeError: 'zip' object is not subscriptable
|
|
|
c= list(zip(gg, qq)) #для обращения по индексу можно преобразовать в другой тип
|
|
|
c[1]
|
|
|
(85, 'Туровец')
|
|
|
```
|
|
|
### 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и пред-ставленного в виде символьной строки.
|
|
|
```py
|
|
|
fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
|
|
коэффициент усиления=4
|
|
|
dan
|
|
|
-136.0
|
|
|
```
|
|
|
### 2.5. Функция exec – чтение и выполнение объекта-аргумента функции. Этот объект должен представ-лять собой строку символов с совокупностью инструкций на языке Python.
|
|
|
```py
|
|
|
exec(input('введите инструкции:')) #ввела perem=-123.456;gg=round(abs(perem)+98,3) после инструкции
|
|
|
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
|
|
gg
|
|
|
221.456
|
|
|
```
|
|
|
### 2.6. Самостоятельно изучите и попробуйте применить функции abs, pow, max, min, sum, divmod, len, map.
|
|
|
```py
|
|
|
abs(-5)
|
|
|
5
|
|
|
```
|
|
|
```py
|
|
|
len('Длина строки')
|
|
|
12
|
|
|
```
|
|
|
```py
|
|
|
max(2,3,4)
|
|
|
4
|
|
|
```
|
|
|
```py
|
|
|
min(2,3,4)
|
|
|
2
|
|
|
```
|
|
|
```py
|
|
|
pow(2,3)
|
|
|
8
|
|
|
```
|
|
|
```py
|
|
|
sum(a)
|
|
|
22
|
|
|
```
|
|
|
```py
|
|
|
numbers = [1, 2, 3, 4, 5]
|
|
|
list(map(str, numbers))
|
|
|
['1', '2', '3', '4', '5']
|
|
|
```
|
|
|
```py
|
|
|
#divmod() — это встроенная функция, которая принимает два числа и возвращает пару чисел (кортеж), состоящую из результата целочисленного деления (частного) и остатка от деления.
|
|
|
divmod(3,7)
|
|
|
(0, 3)
|
|
|
```
|
|
|
## 3. Функции из стандартного модуля 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!.
|
|
|
|
|
|
math.factorial(5)
|
|
|
120
|
|
|
math.sin(180) #из радиан в значение синуса
|
|
|
-0.8011526357338304
|
|
|
math.acos(-0.8011526357338304) #из радиан в значение косинуса
|
|
|
2.500015072176682
|
|
|
math.degrees(180) #из радиан в градусы
|
|
|
10313.240312354817
|
|
|
math.exp(2) #e в степени 2
|
|
|
7.38905609893065
|
|
|
math.log(10) #натуральный логарифм по основанию e
|
|
|
2.302585092994046
|
|
|
math.log(8, 2) #логарифм 8 по основанию 2
|
|
|
3.0
|
|
|
math.log10(10) #логарифм 10 по основанию 10
|
|
|
1.0
|
|
|
math.sqrt(4)
|
|
|
2.0
|
|
|
math.ceil(2.3) #наименьшее целое число, большее или равное 2.3(округление вверх)
|
|
|
3
|
|
|
math.ceil(-2.3)
|
|
|
-2
|
|
|
math.floor(2.3) #округление вниз
|
|
|
2
|
|
|
math.floor(-2.3)
|
|
|
-3
|
|
|
math.pi
|
|
|
3.141592653589793
|
|
|
```
|
|
|
## 4. Функции из модуля 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
|
|
|
```
|
|
|
## 5. Стандартный модуль 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(42) # Фиксируем seed для одинаковых результатов
|
|
|
#random() - равномерное распределение [0, 1)
|
|
|
random.random()
|
|
|
0.6394267984578837
|
|
|
# uniform(a, b) - равномерное распределение [a, b]
|
|
|
random.uniform(5, 15)
|
|
|
5.25010755222667
|
|
|
# randint(a, b) - случайное целое [a, b]
|
|
|
random.randint(1, 100)
|
|
|
36
|
|
|
# gauss(mu, sigma) - нормальное распределение
|
|
|
random.gauss(0, 1)
|
|
|
0.017593105583573694
|
|
|
# choice(sequence) - случайный выбор
|
|
|
a=[1,2,3,4,5,6,7]
|
|
|
random.choice(a)
|
|
|
1
|
|
|
# shuffle(sequence) - перемешивание
|
|
|
random.shuffle(a)
|
|
|
a
|
|
|
[4, 2, 3, 1, 5, 7, 6]
|
|
|
# sample(population, k) - выборка без повторений
|
|
|
random.sample(range(100), 5)
|
|
|
[4, 3, 11, 27, 29]
|
|
|
# betavariate(alpha, beta) - бета-распределение
|
|
|
random.betavariate(2, 5)
|
|
|
0.3918844780644009
|
|
|
# gammavariate(alpha, beta) - гамма-распределение
|
|
|
random.gammavariate(2, 1)
|
|
|
2.219353519271194
|
|
|
```
|
|
|
## 5.1. Создание списка с 4 случайными значениями
|
|
|
```py
|
|
|
random_values = [
|
|
|
# 1. Равномерное распределение [0, 10)
|
|
|
random.uniform(0, 10),
|
|
|
|
|
|
# 2. Нормальное распределение (mu=50, sigma=10)
|
|
|
random.gauss(50, 10),
|
|
|
|
|
|
# 3. Бета-распределение (alpha=2, beta=5)
|
|
|
random.betavariate(2, 5),
|
|
|
|
|
|
# 4. Гамма-распределение (alpha=3, beta=2)
|
|
|
random.gammavariate(3, 2)
|
|
|
]
|
|
|
random_values
|
|
|
[5.892656838759088, 55.47961646339978, 0.5314696353281997, 2.163791803055314]
|
|
|
distributions = [
|
|
|
"Равномерное [0, 10)",
|
|
|
"Нормальное (μ=50, σ=10)",
|
|
|
"Бета (α=2, β=5)",
|
|
|
"Гамма (α=3, β=2)"
|
|
|
]
|
|
|
list(zip(random_values, distributions))
|
|
|
[(5.892656838759088, 'Равномерное [0, 10)'), (55.47961646339978, 'Нормальное (μ=50, σ=10)'), (0.5314696353281997, 'Бета (α=2, β=5)'), (2.163791803055314, 'Гамма (α=3, β=2)')]
|
|
|
```
|
|
|
## 6. Функции из модуля 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() #функция time возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
|
|
|
c1
|
|
|
1758211745.990668
|
|
|
c2=time.time()-c1 #временной интервал в секундах, со времени ввода предыдущей инструкции
|
|
|
c2
|
|
|
87.25691390037537
|
|
|
dat=time.gmtime() #получение объекта класса struct_time, содержащего полную информацию о текущем времени. Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC). Московское время MSK опережает UTC на 3 часа
|
|
|
dat
|
|
|
time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
|
|
|
dat.tm_mon
|
|
|
9
|
|
|
dat.tm_year
|
|
|
2025
|
|
|
dat.tm_mday
|
|
|
18
|
|
|
dat.tm_hour
|
|
|
16
|
|
|
dat.tm_min
|
|
|
12
|
|
|
dat.tm_sec
|
|
|
46
|
|
|
dat.tm_wday #День недели - четверг (дни недели: 0=понедельник, 1=вторник, 2=среда, 3=четверг, 4=пятница, 5=суббота, 6=воскресенье)
|
|
|
3
|
|
|
dat.tm_yday #День года - 261-й день в году (считая с 1 января = 1)
|
|
|
261
|
|
|
dat.tm_isdst #Летнее время - не действует (0 = зимнее время, 1 = летнее время, -1 = неизвестно)
|
|
|
0
|
|
|
```
|
|
|
```py
|
|
|
time.localtime() #Получение местного времени
|
|
|
time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=19, tm_min=22, tm_sec=25, tm_wday=3, tm_yday=261, tm_isdst=0)
|
|
|
time.asctime() #Получение текущего времени, представление времени из кортежа в строку
|
|
|
'Thu Sep 18 19:26:35 2025'
|
|
|
time.ctime() #Преобразование времени в секундах, прошедшего с начала эпохи, в строку
|
|
|
'Thu Sep 18 19:28:56 2025'
|
|
|
time.sleep(3) #Прерывание работы программы на заданное время(3 секунды)
|
|
|
time_tuple = (2025, 9, 18, 16, 12, 46, 3, 261, 0)
|
|
|
time_obj = time.struct_time(time_tuple)
|
|
|
time_obj
|
|
|
time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
|
|
|
seconds = time.mktime(time_obj) #Преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи
|
|
|
seconds
|
|
|
1758201166.0
|
|
|
back_to_time = time.localtime(seconds) #Обратное преобразование
|
|
|
back_to_time
|
|
|
time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
|
|
|
```
|
|
|
## 7. Графические функции.
|
|
|
```py
|
|
|
import pylab
|
|
|
x=list(range(-3,55,4))
|
|
|
t=list(range(15))
|
|
|
pylab.plot(t,x) #Создание графика в оперативной памяти
|
|
|
[<matplotlib.lines.Line2D object at 0x0000027668162490>]
|
|
|
pylab.title('Первый график')
|
|
|
Text(0.5, 1.0, 'Первый график')
|
|
|
pylab.xlabel('время')
|
|
|
Text(0.5, 0, 'время')
|
|
|
pylab.ylabel('сигнал')
|
|
|
Text(0, 0.5, 'сигнал')
|
|
|
pylab.show() #Отображение графика на экране
|
|
|
```
|
|
|
|
|
|
```py
|
|
|
X1=[12,6,8,10,7]
|
|
|
X2=[5,7,9,11,13]
|
|
|
pylab.plot(X1)
|
|
|
[<matplotlib.lines.Line2D object at 0x0000027669976C10>]
|
|
|
pylab.plot(X2)
|
|
|
[<matplotlib.lines.Line2D object at 0x0000027669976D50>]
|
|
|
pylab.show()
|
|
|
```
|
|
|
|
|
|
```py
|
|
|
# Данные для гистограмм и столбчатых диаграмм
|
|
|
grades = [85, 92, 78, 65, 90, 85, 88, 72, 95, 81, 85, 90, 78, 85, 92]
|
|
|
categories = ['A', 'B', 'C', 'D', 'F']
|
|
|
values = [3, 7, 8, 2, 1]
|
|
|
pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
|
|
|
(array([1., 1., 3., 5., 5.]), array([65., 71., 77., 83., 89., 95.]), <BarContainer object of 5 artists>)
|
|
|
pylab.title('Гистограмма распределения оценок')
|
|
|
Text(0.5, 1.0, 'Гистограмма распределения оценок')
|
|
|
pylab.xlabel('Оценки')
|
|
|
Text(0.5, 0, 'Оценки')
|
|
|
pylab.ylabel('Частота')
|
|
|
Text(0, 0.5, 'Частота')
|
|
|
pylab.grid(axis='y', alpha=0.75)
|
|
|
pylab.show()
|
|
|
```
|
|
|
|
|
|
```py
|
|
|
pylab.bar(categories, values, color=['red', 'orange', 'yellow', 'green', 'blue'], alpha=0.7)
|
|
|
<BarContainer object of 5 artists>
|
|
|
pylab.title('Столбчатая диаграмма распределения по категориям')
|
|
|
Text(0.5, 1.0, 'Столбчатая диаграмма распределения по категориям')
|
|
|
pylab.xlabel('Категории')
|
|
|
Text(0.5, 0, 'Категории')
|
|
|
pylab.ylabel('Количество')
|
|
|
Text(0, 0.5, 'Количество')
|
|
|
pylab.grid(axis='y', alpha=0.75)
|
|
|
pylab.show()
|
|
|
```
|
|
|
|
|
|
```py
|
|
|
# Данные для статистического анализа
|
|
|
data = [23, 45, 67, 34, 89, 56, 72, 41, 58, 64, 39, 51, 47, 62, 55]
|
|
|
import statistics
|
|
|
mean_value = statistics.mean(data)
|
|
|
median_value = statistics.median(data)
|
|
|
mode_value = statistics.mode(data)
|
|
|
stdev_value = statistics.stdev(data)
|
|
|
variance_value = statistics.variance(data)
|
|
|
quantiles_value = statistics.quantiles(data, n=4)
|
|
|
harmonic_mean_value = statistics.harmonic_mean(data)
|
|
|
pylab.hist(data, bins=6, edgecolor='black', alpha=0.7, color='lightgreen', label='Распределение данных')
|
|
|
(array([1., 3., 4., 4., 2., 1.]), array([23., 34., 45., 56., 67., 78., 89.]), <BarContainer object of 6 artists>)
|
|
|
pylab.axvline(mean_value, color='red', linestyle='--', linewidth=2, label=f'Среднее: {mean_value:.2f}')
|
|
|
<matplotlib.lines.Line2D object at 0x000002766864C2D0>
|
|
|
pylab.axvline(median_value, color='blue', linestyle='--', linewidth=2, label=f'Медиана: {median_value}')
|
|
|
<matplotlib.lines.Line2D object at 0x000002766864C410>
|
|
|
pylab.axvline(mode_value, color='green', linestyle='--', linewidth=2, label=f'Мода: {mode_value}')
|
|
|
<matplotlib.lines.Line2D object at 0x000002766864C550>
|
|
|
pylab.title('Гистограмма данных со статистическими показателями')
|
|
|
Text(0.5, 1.0, 'Гистограмма данных со статистическими показателями')
|
|
|
pylab.xlabel('Значения')
|
|
|
Text(0.5, 0, 'Значения')
|
|
|
pylab.ylabel('Частота')
|
|
|
Text(0, 0.5, 'Частота')
|
|
|
pylab.legend()
|
|
|
<matplotlib.legend.Legend object at 0x000002766813F620>
|
|
|
pylab.grid(alpha=0.3)
|
|
|
pylab.show()
|
|
|
```
|
|
|
|
