Сравнить коммиты
19 Коммитов
| Автор | SHA1 | Дата | |
|---|---|---|---|
| 910e0fa86f | |||
| caa29a9717 | |||
| c5016ff2f6 | |||
| 8ddb9e9363 | |||
|
7aabb0121a | ||
|
|
1cfbe1d662 | ||
|
|
657e7196ab | ||
| a84abc4ad3 | |||
| 479e946f64 | |||
| bbaa758337 | |||
| f4c861af6f | |||
| 4eb98639ba | |||
| 58d8da35c7 | |||
| 948f2c5176 | |||
| b543adbed1 | |||
| caa40a0ceb | |||
| 754fea8b03 | |||
| c9c1024c18 | |||
| 04d815ce6d |
@@ -1,7 +1,6 @@
|
||||
# Программное обеспечение автоматизированных систем: лабораторные работы
|
||||
|
||||
[Репозиторий с методическими указаниями и заданиями.](http://uit.mpei.ru/git/main/python)
|
||||
Обратите внимание на файл с комментариями в репозитории по ссылке.
|
||||
|
||||
## Работа с Git
|
||||
|
||||
@@ -110,7 +109,7 @@
|
||||
|
||||
### Оформление решений
|
||||
|
||||
Решение всех заданий и тестов оформляется по образцу:
|
||||
Решение всех заданий оформляется по образцу:
|
||||
|
||||
# Общее контрольное задание по теме 2
|
||||
|
||||
@@ -130,8 +129,5 @@
|
||||
|
||||
Для темы 1 вместо «Задания» — «Вопрос», вместо «Решения» — «Ответ».
|
||||
|
||||
Для тем 3, 6 и 9 вместо «Индивидуального контрольного задания по теме 3 (6, 9)» —
|
||||
«Тест по модулю 1 (2, 3)».
|
||||
|
||||
Для тем 8 и 9 раздела «Решение» не нужно,
|
||||
вместо этого решение размещается в отдельных файлах `*.py`.
|
||||
|
||||
6
TEMA1/Pr0.py
Обычный файл
6
TEMA1/Pr0.py
Обычный файл
@@ -0,0 +1,6 @@
|
||||
# Программа по Теме 1 Девятова МЕ
|
||||
|
||||
print('Hello')
|
||||
h=input('Your name=')
|
||||
import os
|
||||
os.chdir('C:\\Users\\u207-05\\Desktop\\ПОАС\\python-labs\\TEMA1\\')
|
||||
Двоичные данные
TEMA1/figure01.PNG
Обычный файл
Двоичные данные
TEMA1/figure01.PNG
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 32 KiB |
Двоичные данные
TEMA1/figure02.PNG
Обычный файл
Двоичные данные
TEMA1/figure02.PNG
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 16 KiB |
Двоичные данные
TEMA1/figure03.PNG
Обычный файл
Двоичные данные
TEMA1/figure03.PNG
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 24 KiB |
Двоичные данные
TEMA1/figure04.PNG
Обычный файл
Двоичные данные
TEMA1/figure04.PNG
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 6.0 KiB |
Двоичные данные
TEMA1/figure05.PNG
Обычный файл
Двоичные данные
TEMA1/figure05.PNG
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 48 KiB |
Двоичные данные
TEMA1/figure06.PNG
Обычный файл
Двоичные данные
TEMA1/figure06.PNG
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 52 KiB |
104
TEMA1/report.md
Обычный файл
104
TEMA1/report.md
Обычный файл
@@ -0,0 +1,104 @@
|
||||
# Отчет по теме 1
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Знакомство с интерпретатором и интерактивной оболочкой IDLE
|
||||
|
||||
## 1.1 Настройка текущего каталога и окна IDLE
|
||||
|
||||
```
|
||||
import os
|
||||
os.chdir('C:\\Users\\u207-05\\Desktop\\ПОАС\\python-labs\\TEMA1\\')
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 1.2 Запуск программы в командном окне
|
||||
|
||||
Был создан файл Pr0.py, в командном окне IDLE был запущен на выполнение + файл prb1.py, данный изначально.
|
||||
Результаты выполнения:
|
||||
|
||||
```
|
||||
import Pr0
|
||||
Hello
|
||||
Your name=Maria
|
||||
import prb1
|
||||
Как Вас зовут? Maria
|
||||
Привет, Maria
|
||||
```
|
||||
|
||||
## 1.3 Содержимое файла в папке pycache
|
||||
|
||||
После запуска Pr0.py в рабочем каталоге появилась папка pycache, в которой расположен файл Pr0.cpython-311.pyc
|
||||
Данный файл содержит байт-код для исходного Pr0.py, который интерпретируется виртуальной машиной Python.
|
||||
Фрагмент файла, открытый в текстовом редакторе, приведен ниже:
|
||||
|
||||
|
||||
|
||||
## 1.4 Изучение раздела help
|
||||
|
||||
Было выполнено обращение к помощи по функции print(), затем по функциям print(), input()
|
||||
|
||||
```
|
||||
help(print)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
```
|
||||
|
||||
```
|
||||
help(print); help(input)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt='', /)
|
||||
Read a string from standard input. The trailing newline is stripped.
|
||||
|
||||
The prompt string, if given, is printed to standard output without a
|
||||
trailing newline before reading input.
|
||||
|
||||
If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
|
||||
On *nix systems, readline is used if available.
|
||||
```
|
||||
|
||||
## 1.5 Выполнение пункта 15
|
||||
|
||||
```
|
||||
======= RESTART: C:\Users\u207-05\Desktop\ПОАС\python-labs\TEMA1\prb1.py =======
|
||||
Как Вас зовут? Maria
|
||||
Привет, Maria
|
||||
```
|
||||
```
|
||||
import tdemo_chaos
|
||||
```
|
||||
|
||||
|
||||
|
||||
Через раздел помощи Help был запущен пример clock, результат ниже:
|
||||
|
||||
|
||||
819
TEMA2/report.md
Обычный файл
819
TEMA2/report.md
Обычный файл
@@ -0,0 +1,819 @@
|
||||
# Отчет по теме 2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск оболочки IDLE, подготовка к работе
|
||||
|
||||
Был запущен IDLE Python 3.11, установлен текущий каталог:
|
||||
|
||||
```
|
||||
import os
|
||||
os.chdir('C:\\Users\\ASUS X507UF\\Desktop\\поас\\python-labs\\TEMA2\\')
|
||||
```
|
||||
|
||||
## 2 Изучение простых объектов
|
||||
|
||||
Были созданы две переменные со значениями 16 и 3
|
||||
|
||||
```
|
||||
f1=16; f2=3
|
||||
```
|
||||
|
||||
Чтобы узнать значения нескольких переменных, достаточно перечислить имена переменных через запятую или точку с запятой.
|
||||
|
||||
```
|
||||
f1,f2
|
||||
(16, 3)
|
||||
f1;f2
|
||||
16
|
||||
3
|
||||
```
|
||||
|
||||
Использование функции dir() без аргументов позволяет узнать, какие объекты в данный момент cуществуют в среде Python.
|
||||
|
||||
```
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__',
|
||||
'__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
|
||||
```
|
||||
|
||||
Если эту же функцию использовать с именем объекта в качестве аргумента (например, f1), то будет выведен список атрибутов этого объекта.
|
||||
|
||||
```
|
||||
dir(f1)
|
||||
['__abs__', '__add__', '__and__', '__bool__', '__ceil__',
|
||||
'__class__', '__delattr__', '__dir__', '__divmod__',
|
||||
'__doc__', '__eq__', '__float__', '__floor__',
|
||||
'__floordiv__', '__format__', '__ge__', '__getattribute__',
|
||||
'__getnewargs__', '__getstate__', '__gt__', '__hash__',
|
||||
'__index__', '__init__', '__init_subclass__', '__int__',
|
||||
'__invert__', '__le__', '__lshift__', '__lt__', '__mod__',
|
||||
'__mul__', '__ne__', '__neg__', '__new__', '__or__',
|
||||
'__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__',
|
||||
'__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__',
|
||||
'__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__',
|
||||
'__rpow__', '__rrshift__', '__rshift__', '__rsub__',
|
||||
'__rtruediv__', '__rxor__', '__setattr__', '__sizeof__',
|
||||
'__str__', '__sub__', '__subclasshook__', '__truediv__',
|
||||
'__trunc__', '__xor__', 'as_integer_ratio', 'bit_count',
|
||||
'bit_length', 'conjugate', 'denominator', 'from_bytes',
|
||||
'imag', 'numerator', 'real', 'to_bytes']
|
||||
```
|
||||
|
||||
Классовую принадлежность объекта можно определить с помощью функции type(). Объект f2 принадлежит к целочисленному типу данных.
|
||||
|
||||
```
|
||||
type(f2)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
Было произведено удаление ранее созданных объектов f1 и f2, а также проверено с функцией dir().
|
||||
Объекты действительно были удалены из оперативной памяти.
|
||||
|
||||
```
|
||||
del f1,f2
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__',
|
||||
'__name__', '__package__', '__spec__', 'os']
|
||||
```
|
||||
|
||||
## 3 Правила именования объектов
|
||||
|
||||
При именовании объектов в Python необходимо руководствоваться следующими правилами:
|
||||
1) имена должны состоять из латинских букв, цифр и символов подчеркивания;
|
||||
2) имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
|
||||
3) заглавные и строчные буквы в именах различаются (чувствительность к регистру);
|
||||
4) имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python.
|
||||
Были выполнены следующие операции:
|
||||
|
||||
```
|
||||
gg1=1.6
|
||||
gg1
|
||||
1.6
|
||||
hh1='Строка'
|
||||
hh1
|
||||
'Строка'
|
||||
73sr=3
|
||||
SyntaxError: invalid decimal literal
|
||||
and=7
|
||||
SyntaxError: invalid syntax
|
||||
```
|
||||
|
||||
Ошибки были выведены при создании переменной с цифрой в начале имени и с именем, совпадающим с ключевым словом.
|
||||
Остальные переменные получили введенное значение.
|
||||
|
||||
## 4 Вывод списка ключевых слов
|
||||
|
||||
Был выведен список ключевых слов.
|
||||
|
||||
```
|
||||
import keyword
|
||||
keyword.kwlist
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async',
|
||||
'await', 'break', 'class', 'continue', 'def', 'del', 'elif',
|
||||
'else', 'except', 'finally', 'for', 'from', 'global', 'if',
|
||||
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
|
||||
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
```
|
||||
|
||||
Данный список был сохранен в переменной с именем kw.
|
||||
|
||||
```
|
||||
kw = keyword.kwlist
|
||||
kw
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async',
|
||||
'await', 'break', 'class', 'continue', 'def', 'del', 'elif',
|
||||
'else', 'except', 'finally', 'for', 'from', 'global', 'if',
|
||||
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
|
||||
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
```
|
||||
|
||||
## 5 Список встроенных идентификаторов и изучение некоторых функций
|
||||
|
||||
Был выведен список встроенных идентификаторов.
|
||||
|
||||
```
|
||||
import builtins
|
||||
dir(builtins)
|
||||
['ArithmeticError', 'AssertionError', 'AttributeError',
|
||||
'BaseException', 'BaseExceptionGroup', 'BlockingIOError',
|
||||
'BrokenPipeError', 'BufferError', 'BytesWarning',
|
||||
'ChildProcessError', 'ConnectionAbortedError',
|
||||
'ConnectionError', 'ConnectionRefusedError',
|
||||
'ConnectionResetError', 'DeprecationWarning',
|
||||
'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError',
|
||||
'Exception', 'ExceptionGroup', 'False', 'FileExistsError',
|
||||
'FileNotFoundError', 'FloatingPointError', 'FutureWarning',
|
||||
'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning',
|
||||
'IndentationError', 'IndexError', 'InterruptedError',
|
||||
'IsADirectoryError', 'KeyError', 'KeyboardInterrupt',
|
||||
'LookupError', 'MemoryError', 'ModuleNotFoundError',
|
||||
'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
|
||||
'NotImplementedError', 'OSError', 'OverflowError',
|
||||
'PendingDeprecationWarning', 'PermissionError',
|
||||
'ProcessLookupError', 'RecursionError', 'ReferenceError',
|
||||
'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
|
||||
'StopAsyncIteration', 'StopIteration', 'SyntaxError',
|
||||
'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError',
|
||||
'TimeoutError', 'True', 'TypeError', 'UnboundLocalError',
|
||||
'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError',
|
||||
'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
|
||||
'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError',
|
||||
'_', '__build_class__', '__debug__', '__doc__', '__import__',
|
||||
'__loader__', '__name__', '__package__', '__spec__', 'abs',
|
||||
'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool',
|
||||
'breakpoint', 'bytearray', 'bytes', 'callable', 'chr',
|
||||
'classmethod', 'compile', 'complex', 'copyright', 'credits',
|
||||
'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval',
|
||||
'exec', 'exit', 'filter', 'float', 'format', 'frozenset',
|
||||
'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
|
||||
'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
|
||||
'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',
|
||||
'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',
|
||||
'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set',
|
||||
'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum',
|
||||
'super', 'tuple', 'type', 'vars', 'zip']
|
||||
```
|
||||
|
||||
Можно отметить, что в нем присутствуют уже использованные функции type() и dir().
|
||||
Было изучено назначение функций: abs, len, max, min, pow, round, sorted, sum, zip.
|
||||
abs - модуль объекта.
|
||||
|
||||
```
|
||||
abs(-20)
|
||||
20
|
||||
```
|
||||
|
||||
len - длина объекта.
|
||||
|
||||
```
|
||||
len([1, 3, 5, 7, 9, 11])
|
||||
6
|
||||
```
|
||||
|
||||
max/min - максимум/минимум объекта.
|
||||
|
||||
```
|
||||
max(0, -50, 23)
|
||||
23
|
||||
min(0, -50, 23)
|
||||
-50
|
||||
```
|
||||
|
||||
pow - возведение в степень.
|
||||
|
||||
```
|
||||
pow(3, 2)
|
||||
9
|
||||
```
|
||||
|
||||
round - округление (в кач-ве второго аргумента - кол-во знаков после запятой, по умолчанию none, т.е. округление до целого).
|
||||
|
||||
```
|
||||
round(5.5276)
|
||||
6
|
||||
round(5.5276, 3)
|
||||
5.528
|
||||
```
|
||||
|
||||
sorted - сортировка элементов в объекте (по умолчанию - по возрастанию, при reverse=True - по убыванию).
|
||||
|
||||
```
|
||||
sorted([2, -7, 4, 0])
|
||||
[-7, 0, 2, 4]
|
||||
sorted([2, -7, 4, 0], reverse=True)
|
||||
[4, 2, 0, -7]
|
||||
```
|
||||
|
||||
sum - сумма элементов (в кач-ве второго аргумента - начальное значение, по умолчанию 0).
|
||||
|
||||
```
|
||||
sum([1, 4, 7])
|
||||
12
|
||||
sum([1, 4, 7], 5)
|
||||
17
|
||||
```
|
||||
|
||||
zip - поэлементное объединение объектов в набор кортежей, при разной длине объектов функция создает кортежи до длины самого короткого объекта.
|
||||
|
||||
```
|
||||
list(zip('efghi', [2, 6, 3], [7, 9, 0, 0]))
|
||||
[('e', 2, 7), ('f', 6, 9), ('g', 3, 0)]
|
||||
```
|
||||
|
||||
## 6 Проверка на чувствительность к регистру
|
||||
|
||||
Была создана переменная Gg1 с присвоенным значением, отличным от присвоенного ранее объекту gg1. Проверка показала, что gg1 и Gg1 - разные объекты, т.е. Python чувствителен к регистру.
|
||||
|
||||
```
|
||||
Gg1=45
|
||||
gg1; Gg1
|
||||
1.6
|
||||
45
|
||||
```
|
||||
|
||||
## 7 Простые базовые типы объектов
|
||||
|
||||
### 7.1 Логический тип
|
||||
|
||||
```
|
||||
bb1=True; bb2=False
|
||||
bb1; bb2
|
||||
True
|
||||
False
|
||||
type(bb1)
|
||||
<class 'bool'>
|
||||
```
|
||||
|
||||
### 7.2 Другие простые типы
|
||||
|
||||
ii1 - целое число, десятичное
|
||||
|
||||
```
|
||||
ii1=-1234567890
|
||||
type(ii1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
ff1 - экспоненциальная форма записи вещественного числа
|
||||
|
||||
```
|
||||
ff1=-8.9876e-12
|
||||
type(ff1)
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
dv1 - двоичное число
|
||||
|
||||
```
|
||||
dv1=0b1101010
|
||||
type(dv1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
vsm1 - восьмеричное число
|
||||
|
||||
```
|
||||
vsm1=0o52765
|
||||
type(vsm1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
shest1 - шестнадцатеричное число
|
||||
|
||||
```
|
||||
shest1=0x7109af6
|
||||
type(shest1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
cc1 и cc2 - комплексные числа
|
||||
|
||||
```
|
||||
cc1=2-3j
|
||||
type(cc1)
|
||||
<class 'complex'>
|
||||
a=3.67; b=-0.45
|
||||
cc2=complex(a,b)
|
||||
cc2
|
||||
(3.67-0.45j)
|
||||
```
|
||||
|
||||
### 7.3 Строка символов
|
||||
|
||||
Была двумя способами создана строка - с использованием одинарных и двойных кавычек. Оба способа дают идентичный результат (но важно, чтобы открывающие и закрывающие кавычки были одинаковыми).
|
||||
|
||||
```
|
||||
ss1='Это - строка символов'
|
||||
ss1
|
||||
'Это - строка символов'
|
||||
ss1="Это - строка символов"
|
||||
ss1
|
||||
'Это - строка символов'
|
||||
```
|
||||
|
||||
Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.
|
||||
|
||||
```
|
||||
ss1a="Это - \" строка символов \", \n \t выводимая на
|
||||
двух строках"
|
||||
print(ss1a)
|
||||
Это - " строка символов ",
|
||||
выводимая на двух строках
|
||||
```
|
||||
```
|
||||
ss1b= 'Меня зовут: \n Девятова М.Е.'
|
||||
print(ss1b)
|
||||
Меня зовут:
|
||||
Девятова М.Е.
|
||||
```
|
||||
|
||||
Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.
|
||||
|
||||
```
|
||||
mnogo="""Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции."""
|
||||
print(mnogo)
|
||||
Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции.
|
||||
```
|
||||
|
||||
Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. Нумерация начинается с 0. При знаке минус отсчет идет от конца строки.
|
||||
|
||||
```
|
||||
ss1[0]
|
||||
'Э'
|
||||
ss1[8]
|
||||
'р'
|
||||
ss1[-2]
|
||||
'о'
|
||||
```
|
||||
|
||||
Операция создания "среза".
|
||||
С 6-го индекса по 8-й, 9-й не включая.
|
||||
C 13-го индекса и до конца.
|
||||
С начала и до 12-го индекса включительно.
|
||||
C 5-го индекса и до 8-го с конца
|
||||
С 3-го по 16-й с шагом 2
|
||||
|
||||
```
|
||||
ss1[6:9]
|
||||
'стр'
|
||||
ss1[13:]
|
||||
'символов'
|
||||
ss1[:13]
|
||||
'Это - строка '
|
||||
ss1[5:-8]
|
||||
' строка '
|
||||
ss1[3:17:2]
|
||||
' тоасм'
|
||||
```
|
||||
|
||||
При отрицательном значении шага. Если 17 заменить на -4, то результат будет тот же.
|
||||
|
||||
```
|
||||
ss1[17:3:-2]
|
||||
'омсаот '
|
||||
ss1[-4:3:-2]
|
||||
'омсаот '
|
||||
```
|
||||
|
||||
Строка является неизменяемым объектом.
|
||||
|
||||
```
|
||||
ss1[4]='='
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#89>", line 1, in <module>
|
||||
ss1[4]='='
|
||||
TypeError: 'str' object does not support item assignment
|
||||
```
|
||||
|
||||
Выход из положения - переопределение строки с ипользованием срезов.
|
||||
|
||||
```
|
||||
ss1=ss1[:4]+'='+ss1[5:]
|
||||
ss1
|
||||
'Это = строка символов'
|
||||
```
|
||||
|
||||
С использованием ранее созданной строки ss1b были созданы объекты с разными срезами.
|
||||
|
||||
```
|
||||
ss1b[1::3]
|
||||
'е в: во Е'
|
||||
ss1b[0]
|
||||
'М'
|
||||
ss1b[12]
|
||||
'\n'
|
||||
ss1b[5:10]
|
||||
'зовут'
|
||||
ss1b[14:-8]
|
||||
'Девят'
|
||||
ss1b[-8:14:-2]
|
||||
'ояе'
|
||||
```
|
||||
|
||||
Были созданы объекты разных типов с отображением их типов.
|
||||
|
||||
```
|
||||
obj1=9.87609
|
||||
type(obj1)
|
||||
<class 'float'>
|
||||
obj2=654
|
||||
type(obj2)
|
||||
<class 'int'>
|
||||
obj3=8+5j
|
||||
type(obj3)
|
||||
<class 'complex'>
|
||||
obj4='о'
|
||||
type(obj4)
|
||||
<class 'str'>
|
||||
obj7="""две
|
||||
строки"""
|
||||
type(obj7)
|
||||
<class 'str'>
|
||||
```
|
||||
|
||||
## 8 Списки, кортежи, словари, множества
|
||||
|
||||
### 8.1 Списки
|
||||
|
||||
Список – это упорядоченная последовательность объектов произвольных типов, список является изменяемым объектом.
|
||||
Был создан список с 3 элементами разных типов.
|
||||
|
||||
```
|
||||
spis1=[111,'Spisok',5-9j]
|
||||
spis1
|
||||
[111, 'Spisok', (5-9j)]
|
||||
type(spis1)
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
Еще пример: список, содержащий последовательность отсчетов сигнала в виде "единичной ступеньки".
|
||||
|
||||
```
|
||||
stup=[0,0,1,1,1,1,1,1,1]
|
||||
stup
|
||||
[0, 0, 1, 1, 1, 1, 1, 1, 1]
|
||||
type(stup)
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
Список можно вводить на нескольких строках, для завершения ввода должна быть введена закрывающая квадратная скобка.
|
||||
|
||||
```
|
||||
spis=[1,2,3,4,
|
||||
5,6,7,
|
||||
8,9,10]
|
||||
spis
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
```
|
||||
|
||||
При работе с элементами списка можно использовать индексы точно так же, как это производилось с элементами символьной строки.
|
||||
|
||||
```
|
||||
spis1[-1]
|
||||
(5-9j)
|
||||
stup[-8::2]
|
||||
[0, 1, 1, 1]
|
||||
```
|
||||
|
||||
Список - изменяемый объект, поэтому его элементам можно присваивать новые значения.
|
||||
|
||||
```
|
||||
spis1[1]='Список'
|
||||
spis1
|
||||
[111, 'Список', (5-9j)]
|
||||
```
|
||||
|
||||
Функция len() отображает кол-во элементов в списке.
|
||||
|
||||
```
|
||||
len(spis1)
|
||||
3
|
||||
```
|
||||
|
||||
Был выведен список атрибутов списка и с помощью функции help() - описание одного из методов.
|
||||
|
||||
```
|
||||
dir(spis1)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__',
|
||||
'__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__',
|
||||
'__format__', '__ge__', '__getattribute__', '__getitem__',
|
||||
'__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__',
|
||||
'__init__', '__init_subclass__', '__iter__', '__le__',
|
||||
'__len__', '__lt__', '__mul__', '__ne__', '__new__',
|
||||
'__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
|
||||
'__rmul__', '__setattr__', '__setitem__', '__sizeof__',
|
||||
'__str__', '__subclasshook__', 'append', 'clear', 'copy',
|
||||
'count', 'extend', 'index', 'insert', 'pop', 'remove',
|
||||
'reverse', 'sort']
|
||||
help(spis1.append)
|
||||
Help on built-in function append:
|
||||
|
||||
append(object, /) method of builtins.list instance
|
||||
Append object to the end of the list.
|
||||
```
|
||||
|
||||
Добавить элемент в список можно двумя способами, но при конкатенации (второй способ) добавленный элемент не сохраняется в списке:
|
||||
|
||||
```
|
||||
spis1.append('New item')
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item']
|
||||
spis1+['New item']
|
||||
[111, 'Список', (5-9j), 'New item', 'New item']
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item']
|
||||
```
|
||||
|
||||
```
|
||||
spis1.append(ss1b)
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.']
|
||||
```
|
||||
|
||||
Из списка был удален элемент с индексом 1.
|
||||
|
||||
```
|
||||
spis1.pop(1)
|
||||
'Список'
|
||||
spis1
|
||||
[111, (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.']
|
||||
```
|
||||
|
||||
Также были изучены еще некоторые методы.
|
||||
insert вставляет элемент (второй аргумент функции) по номеру индекса (первый аргумент функции).
|
||||
|
||||
```
|
||||
sss=[1, 3, 'Hello', 47+9j, 1, 666]
|
||||
sss
|
||||
[1, 3, 'Hello', (47+9j), 1, 666]
|
||||
sss.insert(2, ')')
|
||||
sss
|
||||
[1, 3, ')', 'Hello', (47+9j), 1, 666]
|
||||
```
|
||||
|
||||
remove удаляет первый элемент со значением, указанным в кач-ве аргумента. В примере элементы с индексами 0 и 5 имеют значение 1, но функция удалила только элемент с индексом 0.
|
||||
|
||||
```
|
||||
sss.remove(1)
|
||||
sss
|
||||
[3, ')', 'Hello', (47+9j), 1, 666]
|
||||
```
|
||||
|
||||
extend принимает объект в кач-ве аргумента и добавляет его в конец списка.
|
||||
В сравнении с append данная функция может распаковывать сложные типы как список и добавлять его поэлементно, в то время как append добавляет список как один объект.
|
||||
|
||||
```
|
||||
sss.extend([1, 2, 3, 'X'])
|
||||
sss
|
||||
[3, ')', 'Hello', (47+9j), 1, 666, 1, 2, 3, 'X']
|
||||
sss.append([1, 2, 3, 'X'])
|
||||
sss
|
||||
[3, ')', 'Hello', (47+9j), 1, 666, 1, 2, 3, 'X', [1, 2, 3, 'X']]
|
||||
```
|
||||
|
||||
sort - сортировка элементов, по умолчанию - по возрастанию.
|
||||
|
||||
```
|
||||
sss1=[1, -5, 9, 0, -43]
|
||||
sss1.sort()
|
||||
sss1
|
||||
[-43, -5, 0, 1, 9]
|
||||
```
|
||||
|
||||
reverse - обратный порядок элементов.
|
||||
|
||||
```
|
||||
sss.reverse()
|
||||
sss
|
||||
[[1, 2, 3, 'X'], 'X', 3, 2, 1, 666, 1, (47+9j), 'Hello', ')', 3]
|
||||
```
|
||||
|
||||
copy - создание копии списка.
|
||||
|
||||
```
|
||||
s00=sss.copy()
|
||||
s00
|
||||
[[1, 2, 3, 'X'], 'X', 3, 2, 1, 666, 1, (47+9j), 'Hello', ')', 3]
|
||||
```
|
||||
|
||||
count - счетчик элементов по значению.
|
||||
|
||||
```
|
||||
sss.count(1)
|
||||
2
|
||||
sss.count(9)
|
||||
0
|
||||
```
|
||||
|
||||
index - индекс первого элемента с заданным в аргументе значением.
|
||||
|
||||
```
|
||||
sss.index(1)
|
||||
4
|
||||
```
|
||||
|
||||
clear - полное очищение списка
|
||||
|
||||
```
|
||||
sss.clear()
|
||||
sss
|
||||
[]
|
||||
```
|
||||
|
||||
Списки могут быть вложенными.
|
||||
Пример обращения к элементу вложенного списка. При изменении элемента вложенного списка, сам spis1 изменяется, потому что при создании spis2 использовалась не копия spis1, а ссылка на него.
|
||||
|
||||
```
|
||||
spis2=[spis1,[4,5,6,7]]
|
||||
spis2
|
||||
[[111, (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.'], [4, 5, 6, 7]]
|
||||
spis2[0][1]
|
||||
(5-9j)
|
||||
spis2[0][1]=78
|
||||
spis2[0][1]
|
||||
78
|
||||
spis1
|
||||
[111, 78, 'New item', 'Меня зовут: \n Девятова М.Е.']
|
||||
```
|
||||
|
||||
Объект-список, элементами которого объекты разных типов: число, строка, логическое значение, список
|
||||
|
||||
```
|
||||
myspis=[gg1, ss1, bb2, sss]
|
||||
myspis
|
||||
[1.6, 'Это = строка символов', False, []]
|
||||
type(myspis[0])
|
||||
<class 'float'>
|
||||
type(myspis[1])
|
||||
<class 'str'>
|
||||
type(myspis[2])
|
||||
<class 'bool'>
|
||||
type(myspis[3])
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
### 8.2 Кортежи
|
||||
|
||||
Объект-кортеж похож на список, но является неизменяемым, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки.
|
||||
Создание кортежа. Вместо изменения кортежа - его переопределение.
|
||||
|
||||
```
|
||||
kort1=(222,'Kortezh',77+8j)
|
||||
kort1= kort1+(1,2)
|
||||
kort1
|
||||
(222, 'Kortezh', (77+8j), 1, 2)
|
||||
kort1= kort1+(ss1b,)
|
||||
kort1
|
||||
(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Девятова М.Е.')
|
||||
kort2=kort1[:2]+kort1[3:]
|
||||
kort2
|
||||
(222, 'Kortezh', 1, 2, 'Меня зовут: \n Девятова М.Е.')
|
||||
```
|
||||
|
||||
Два метода кортежа, одинаковых со списком.
|
||||
|
||||
```
|
||||
kort1.index(2)
|
||||
4
|
||||
kort1.count(222)
|
||||
1
|
||||
```
|
||||
|
||||
Была произведена попытка заменить элемент кортежа, но результат - сообщение о невозможности изменения кортежа.
|
||||
|
||||
```
|
||||
kort1[2]=90
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#241>", line 1, in <module>
|
||||
kort1[2]=90
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
```
|
||||
|
||||
Был создан объект-кортеж с элементами разных типов: число, строка, список, кортеж.
|
||||
|
||||
```
|
||||
mykort=(a, ss1, spis1, kort2)
|
||||
mykort
|
||||
(3.67, 'Это = строка символов', [111, 78, 'New item', 'Меня зовут: \n Девятова М.Е.'], (222, 'Kortezh', 1, 2, 'Меня зовут: \n Девятова М.Е.'))
|
||||
type(mykort)
|
||||
<class 'tuple'>
|
||||
type(mykort[0])
|
||||
<class 'float'>
|
||||
type(mykort[1])
|
||||
<class 'str'>
|
||||
type(mykort[2])
|
||||
<class 'list'>
|
||||
type(mykort[3])
|
||||
<class 'tuple'>
|
||||
```
|
||||
|
||||
### 8.3 Словари
|
||||
|
||||
Словарь - неупорядоченная совокупность элементов. Содержанием словаря является совокупность пар: "ключ (key)":"значение (value)".
|
||||
В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа.
|
||||
Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению.
|
||||
Был создан словарь. Обращение к элементам производилось не по индексам, а по ключам.
|
||||
Был добавлен элемент в словарь. Из-за неупорядоченности словарей элементы при выводе могут располагаться не в том порядке, что и при формировании словаря.
|
||||
|
||||
```
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
|
||||
dic1['Orel']
|
||||
56
|
||||
dic1['Pskov']=78
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
|
||||
```
|
||||
|
||||
С использованием методов keys, values, создающие списки ключей и значений, и функции sorted можно сформировать списки упорядоченных ключей и значений словаря.
|
||||
|
||||
```
|
||||
sorted(dic1.keys())
|
||||
['Orel', 'Pskov', 'Saratov', 'Vologda']
|
||||
sorted(dic1.values())
|
||||
[45, 56, 78, 145]
|
||||
```
|
||||
|
||||
Элементы словаря могут быть любого типа.
|
||||
Были рассмотрены разные способы создания словаря, а также обращение к элементу вложенного словаря.
|
||||
При создании словаря с использованием zip необходимо помнить, что при разных длинах объектов функция объединяет элементы до длины самого короткого объекта (пример: dic555)
|
||||
|
||||
```
|
||||
dic2={1:'mean',2:'standart deviation',3:'correlation'}
|
||||
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
|
||||
dic3['statistics'][2]
|
||||
'standart deviation'
|
||||
dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
|
||||
dic4
|
||||
{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Девятова М.Е.'}
|
||||
dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
|
||||
dic5
|
||||
{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Девятова М.Е.'}
|
||||
dic555=dict(zip(('1', '2', '3', '4', '5', '6', '7'), ['one', 'two', 'three', 'four', 'five']))
|
||||
dic555
|
||||
{'1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five'}
|
||||
AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
|
||||
AVTI['Курс III'][5]
|
||||
15
|
||||
```
|
||||
|
||||
### 8.4 Множества
|
||||
|
||||
Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).
|
||||
Было создано множество и продемонстрировано, что элементы в нем не повторяются, подсчитано кол-во элементов в нем, проверено наличие элемента, затем добавлен новый элемент и удален другой.
|
||||
|
||||
```
|
||||
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
|
||||
mnoz1
|
||||
{'микропроцессор', 'двигатель', 'датчик', 'линия связи'}
|
||||
len(mnoz1)
|
||||
4
|
||||
'датчик' in mnoz1
|
||||
True
|
||||
mnoz1.add('реле')
|
||||
mnoz1
|
||||
{'микропроцессор', 'датчик', 'двигатель', 'линия связи', 'реле'}
|
||||
mnoz1.remove('линия связи')
|
||||
mnoz1
|
||||
{'микропроцессор', 'датчик', 'двигатель', 'реле'}
|
||||
```
|
||||
|
||||
Было создано еще одно множество и проведены некоторые операции над ним.
|
||||
|
||||
```
|
||||
mnoz2={a, ss1, bb2}
|
||||
mnoz2
|
||||
{False, 3.67, 'Это = строка символов'}
|
||||
mnoz2.remove(3.67)
|
||||
mnoz2
|
||||
{False, 'Это = строка символов'}
|
||||
mnoz2.add(90)
|
||||
mnoz2
|
||||
{False, 90, 'Это = строка символов'}
|
||||
```
|
||||
42
TEMA2/task.md
Обычный файл
42
TEMA2/task.md
Обычный файл
@@ -0,0 +1,42 @@
|
||||
# Общее контрольное задание по теме 2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1) Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
|
||||
2) Создать переменную со значением, совпадающим с первой буквой из familia.
|
||||
3) Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
|
||||
4) Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
|
||||
5) Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
|
||||
6) Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
|
||||
7) Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
|
||||
8) Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
|
||||
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
familia='Deviatova'
|
||||
d=familia[0]
|
||||
d
|
||||
'D'
|
||||
import keyword
|
||||
sp_kw=keyword.kwlist
|
||||
sp_kw
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
sp_kw.remove('nonlocal')
|
||||
sp_kw
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
kort_nam=('Maria', 'Lyudmila', 'Danil', 'Ilya')
|
||||
type(kort_nam)
|
||||
<class 'tuple'>
|
||||
kort_nam=kort_nam + ('Vadim', 'Nikita')
|
||||
kort_nam
|
||||
('Maria', 'Lyudmila', 'Danil', 'Ilya', 'Vadim', 'Nikita')
|
||||
kort_nam.count('Dima')
|
||||
0
|
||||
dict_bas={'строка':familia, 'символ':d, 'список':sp_kw, 'кортеж':kort_nam}
|
||||
dict_bas
|
||||
{'строка': 'Deviatova', 'символ': 'D', 'список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'кортеж': ('Maria', 'Lyudmila', 'Danil', 'Ilya', 'Vadim', 'Nikita')}
|
||||
```
|
||||
22
TEMA2/task1.md
Обычный файл
22
TEMA2/task1.md
Обычный файл
@@ -0,0 +1,22 @@
|
||||
# Индивидуаьное контрольное задание по теме 2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
# Вариант №14
|
||||
|
||||
## Задание
|
||||
|
||||
Создайте объект
|
||||
fg={'b':23,'c':45,'a':-12}
|
||||
К какому классу относится этот объект? Напишите инструкцию, создающую словарь, у которого упорядоченным по алфавиту ключам объекта fg соответствуют упорядоченные по величине значения этого объекта.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
fg={'b':23,'c':45,'a':-12}
|
||||
type(fg)
|
||||
<class 'dict'>
|
||||
fg_sort=dict(zip(sorted(fg.keys()), sorted(fg.values())))
|
||||
fg_sort
|
||||
{'a': -12, 'b': 23, 'c': 45}
|
||||
```
|
||||
716
TEMA3/report.md
Обычный файл
716
TEMA3/report.md
Обычный файл
@@ -0,0 +1,716 @@
|
||||
# Отчет по теме 3
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск интерактивной оболочки IDLE, стандартные подготовительные операции
|
||||
|
||||
## 2 Преобразование простых базовых типов объектов
|
||||
|
||||
### 2.1 Преобразование в логический тип с помощью функции bool().
|
||||
|
||||
С помощью функции bool() были преобразованы объекты в логический тип. В примерах возвращает True, если передаваемое целое число не равно нулю или если передаваемая строка не является пустой.
|
||||
|
||||
```
|
||||
logiz1=bool(56); logiz1; type(logiz1)
|
||||
True
|
||||
<class 'bool'>
|
||||
logiz2=bool(0); logiz2; type(logiz2)
|
||||
False
|
||||
<class 'bool'>
|
||||
logiz3=bool("Beta"); logiz3; type(logiz3)
|
||||
True
|
||||
<class 'bool'>
|
||||
logiz4=bool(""); logiz4; type(logiz4)
|
||||
False
|
||||
<class 'bool'>
|
||||
```
|
||||
|
||||
### 2.2 Преобразование в целое десятичное или вещественное число
|
||||
|
||||
С помощью функции int() были преобразованы объекты в целочисленный тип данных. Вторым аргументом можно указывать систему счисления, в которой представлен объект. По умолчанию десятичная.
|
||||
|
||||
```
|
||||
tt1=int(198.6); tt1; type(tt1)
|
||||
198
|
||||
<class 'int'>
|
||||
tt2=int("-76"); tt2; type(tt2)
|
||||
-76
|
||||
<class 'int'>
|
||||
tt3=int("B",16); tt3; type(tt3)
|
||||
11
|
||||
<class 'int'>
|
||||
tt4=int("71",8); tt4; type(tt4)
|
||||
57
|
||||
<class 'int'>
|
||||
tt5=int("98.76"); tt5; type(tt5)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#18>", line 1, in <module>
|
||||
tt5=int("98.76"); tt5; type(tt5)
|
||||
ValueError: invalid literal for int() with base 10: '98.76'
|
||||
```
|
||||
|
||||
При передаче строки, в которой записано вещественное число, возникает ошибка, потому как функция принимает строку только с цифровыми символами.
|
||||
Было произведено преобразование целых чисел или строк символов в вещественное число – с помощью функции float().
|
||||
|
||||
```
|
||||
flt1=float(789); flt1; type(flt1)
|
||||
789.0
|
||||
<class 'float'>
|
||||
flt2=float(-6.78e2); flt2; type(flt2)
|
||||
-678.0
|
||||
<class 'float'>
|
||||
flt3=float("Infinity"); flt3; type(flt3)
|
||||
inf
|
||||
<class 'float'>
|
||||
flt4=float("-inf"); flt4; type(flt4)
|
||||
-inf
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
### 2.3 Преобразование десятичных чисел в другие системы счисления.
|
||||
|
||||
Было произведено преобразование десятичного числа 123 соотвественно в двоичную, восьмеричную и шестнадцатеричную системы счисления. Для проверки были проведены обратные преобразования.
|
||||
|
||||
```
|
||||
hh=123
|
||||
dv1=bin(hh); dv1
|
||||
'0b1111011'
|
||||
vos1=oct(hh); vos1
|
||||
'0o173'
|
||||
shs1=hex(hh); shs1
|
||||
'0x7b'
|
||||
int(dv1, 2)
|
||||
123
|
||||
int(vos1, 8)
|
||||
123
|
||||
int(shs1, 16)
|
||||
123
|
||||
```
|
||||
|
||||
## 3 Преобразования более сложных базовых типов объектов
|
||||
|
||||
### 3.1 Преобразование в строку символов с помощью функции str().
|
||||
|
||||
Было продемонстрировано преобразование объектов различных типов в строку.
|
||||
|
||||
```
|
||||
strk1=str(23.6); strk1
|
||||
'23.6'
|
||||
strk2=str(logiz3); strk2
|
||||
'True'
|
||||
strk3=str(["A","B","C"]); strk3
|
||||
"['A', 'B', 'C']"
|
||||
strk4=str(("A","B","C")); strk4
|
||||
"('A', 'B', 'C')"
|
||||
strk5=str({"A":1,"B":2,"C":9})
|
||||
```
|
||||
|
||||
### 3.2 Преобразование элементов объекта в список с помощью функции list().
|
||||
|
||||
Были преобразованы объекты различных типов в списки.
|
||||
|
||||
```
|
||||
spis1=list("Строка символов"); spis1
|
||||
['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
|
||||
spis2=list((124,236,-15,908)); spis2
|
||||
[124, 236, -15, 908]
|
||||
spis3=list({"A":1,"B":2,"C":9}); spis3
|
||||
['A', 'B', 'C']
|
||||
```
|
||||
|
||||
Т.к. при преобразовании словаря получается список ключей словаря, ниже представлены дополнительные инструкции для получения списка значений и списка пар "ключ - значение"
|
||||
|
||||
```
|
||||
spis4=list({"A":1,"B":2,"C":9}.values()); spis4
|
||||
[1, 2, 9]
|
||||
spis5=list({"A":1,"B":2,"C":9}.items()); spis5
|
||||
[('A', 1), ('B', 2), ('C', 9)]
|
||||
```
|
||||
|
||||
### 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple().
|
||||
|
||||
```
|
||||
kort7=tuple('Строка символов'); kort7
|
||||
('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
|
||||
kort8=tuple(spis2); kort8
|
||||
(124, 236, -15, 908)
|
||||
kort9=tuple({"A":1,"B":2,"C":9}); kort9
|
||||
('A', 'B', 'C')
|
||||
```
|
||||
|
||||
### 3.4 Удаление объектов
|
||||
|
||||
Была очищена оперативная память от ранее созданных объектов с помощью инструкции del. Затем формально было проверено отсутствие указанных объектов.
|
||||
|
||||
```
|
||||
del strk5, kort8
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis44', 'spis5', 'spis55', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
|
||||
```
|
||||
|
||||
По заданию была создана строка с фамилией и инициалами, преобразована в список, затем список – в кортеж, кортеж – в строку.
|
||||
|
||||
```
|
||||
str0='Девятова М.Е.'
|
||||
spis0=list(str0)
|
||||
spis0
|
||||
['Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.']
|
||||
kort0=tuple(spis0); kort0
|
||||
('Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.')
|
||||
str00=str(kort0); str00
|
||||
"('Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.')"
|
||||
```
|
||||
|
||||
## 4 Арифметические операции.
|
||||
|
||||
### 4.1 Сложение/вычитание.
|
||||
|
||||
```
|
||||
12+7+90
|
||||
109
|
||||
5.689e-1 - 0.456
|
||||
0.11289999999999994
|
||||
23.6+54
|
||||
77.6
|
||||
14-56.7+89
|
||||
46.3
|
||||
```
|
||||
|
||||
### 4.2 Умножение.
|
||||
|
||||
```
|
||||
-6.7*12
|
||||
-80.4
|
||||
```
|
||||
|
||||
### 4.3 Деление.
|
||||
|
||||
```
|
||||
-234.5/6
|
||||
-39.083333333333336
|
||||
a=178/45; a; type(a)
|
||||
3.9555555555555557
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
### 4.4 Деление с округлением вниз.
|
||||
|
||||
```
|
||||
b=178//45; b; type(b)
|
||||
3
|
||||
<class 'int'>
|
||||
c=-24.6//12.1; c; type(c)
|
||||
-3.0
|
||||
<class 'float'>
|
||||
d=120//54.5; d; type(d)
|
||||
2.0
|
||||
<class 'float'>
|
||||
e=120.1//54; e; type(e)
|
||||
2.0
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
### 4.5 Получение остатка от деления.
|
||||
|
||||
```
|
||||
148%33
|
||||
16
|
||||
12.6%3.8
|
||||
1.2000000000000002
|
||||
12.6%3
|
||||
0.5999999999999996
|
||||
12%3.8
|
||||
0.6000000000000005
|
||||
```
|
||||
|
||||
### 4.6 Возведение в степень. Операции над комплексными числами
|
||||
|
||||
```
|
||||
14**3
|
||||
2744
|
||||
2.7**3.6
|
||||
35.719843790663525
|
||||
2.7**3
|
||||
19.683000000000003
|
||||
2**3.6
|
||||
12.125732532083186
|
||||
```
|
||||
|
||||
Были проделаны различные операции над комплексными числами. Операции деления с округлением вниз и получения остатка от деления не применяются для чисел такого типа.
|
||||
|
||||
```
|
||||
c1=5+7j
|
||||
c2=1-3j
|
||||
c1+c2
|
||||
(6+4j)
|
||||
c1-c2
|
||||
(4+10j)
|
||||
c1*c2
|
||||
(26-8j)
|
||||
c1/c2
|
||||
(-1.6+2.1999999999999997j)
|
||||
c2**4.6
|
||||
(171.38366786889966+102.16827023666599j)
|
||||
c1//2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#87>", line 1, in <module>
|
||||
c1//2
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'int'
|
||||
c1%c2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#88>", line 1, in <module>
|
||||
c1%c2
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||
```
|
||||
|
||||
## 5 Операции с двоичными представлениями целых чисел.
|
||||
|
||||
### 5.1 Двоичная инверсия (~).
|
||||
|
||||
Значение каждого бита в представлении числа заменяется на противоположное значение.
|
||||
|
||||
```
|
||||
dv1=9; bin(dv1)
|
||||
'0b1001'
|
||||
dv2=~dv1; bin(dv2); dv2
|
||||
'-0b1010'
|
||||
-10
|
||||
```
|
||||
|
||||
### 5.2 Двоичное «И» (&).
|
||||
|
||||
Логическое умножение, возвращает 1, если оба соответствующих бита сравниваемых чисел равны 1.
|
||||
|
||||
```
|
||||
dv3=7; dv4=8
|
||||
bin(dv3); bin(dv1)
|
||||
'0b111'
|
||||
'0b1001'
|
||||
dv3&dv1
|
||||
1
|
||||
bin(dv3&dv1)
|
||||
'0b1'
|
||||
bin(dv3); bin(dv4)
|
||||
'0b111'
|
||||
'0b1000'
|
||||
bin(dv3&dv4)
|
||||
'0b0'
|
||||
```
|
||||
|
||||
### 5.3 Двоичное «ИЛИ» (|).
|
||||
|
||||
Логическое сложение, 0 получается, только если оба сравниваемых разряда равны 0.
|
||||
|
||||
```
|
||||
bin(dv3); bin(dv1)
|
||||
'0b111'
|
||||
'0b1001'
|
||||
dv3|dv1
|
||||
15
|
||||
bin(dv3|dv1)
|
||||
'0b1111'
|
||||
bin(dv3); bin(dv4)
|
||||
'0b111'
|
||||
'0b1000'
|
||||
dv3|dv4
|
||||
15
|
||||
bin(dv3|dv4)
|
||||
'0b1111'
|
||||
dv5=5; dv6=14
|
||||
bin(dv5); bin(dv6)
|
||||
'0b101'
|
||||
'0b1110'
|
||||
dv5|dv6
|
||||
15
|
||||
bin(dv5|dv6)
|
||||
'0b1111'
|
||||
```
|
||||
|
||||
### 5.4 Двоичное «исключающее ИЛИ»(^).
|
||||
|
||||
Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
|
||||
|
||||
```
|
||||
bin(dv5); bin(dv6)
|
||||
'0b101'
|
||||
'0b1110'
|
||||
dv5^dv6
|
||||
11
|
||||
bin(dv5^dv6)
|
||||
'0b1011'
|
||||
```
|
||||
|
||||
### 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>).
|
||||
|
||||
```
|
||||
h=14; bin(h)
|
||||
'0b1110'
|
||||
g=h<<2; g; bin(g)
|
||||
56
|
||||
'0b111000'
|
||||
g1=h>>1; g1; bin(g1)
|
||||
7
|
||||
'0b111'
|
||||
g2=h>>2; g2; bin(g2)
|
||||
3
|
||||
'0b11'
|
||||
```
|
||||
|
||||
Были проделаны операции над двумя числами в двоичном представлении.
|
||||
|
||||
```
|
||||
b1=int("0110011", 2); b2=int("0010110", 2); b1; b2
|
||||
51
|
||||
22
|
||||
bin(~b1)
|
||||
'-0b110100'
|
||||
~b1
|
||||
-52
|
||||
b1&b2; bin(b1&b2)
|
||||
18
|
||||
'0b10010'
|
||||
b1|b2; bin(b1|b2)
|
||||
55
|
||||
'0b110111'
|
||||
b1^b2; bin(b1^b2)
|
||||
37
|
||||
'0b100101'
|
||||
b1<<2; bin(b1<<2)
|
||||
204
|
||||
'0b11001100'
|
||||
b2>>3; bin(b2>>3)
|
||||
2
|
||||
'0b10'
|
||||
```
|
||||
|
||||
## 6 Операции при работе с последовательностями (строками, списками, кортежами).
|
||||
|
||||
### 6.1 Объединение последовательностей (конкатенация)(+).
|
||||
|
||||
```
|
||||
'Система '+'регулирования'
|
||||
'Система регулирования'
|
||||
['abc','de','fg']+['hi','jkl']
|
||||
['abc', 'de', 'fg', 'hi', 'jkl']
|
||||
('abc','de','fg')+('hi','jkl')
|
||||
('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
```
|
||||
|
||||
### 6.2 Повторение (*).
|
||||
|
||||
```
|
||||
'ля-'*5
|
||||
'ля-ля-ля-ля-ля-'
|
||||
['ку','-']*3
|
||||
['ку', '-', 'ку', '-', 'ку', '-']
|
||||
('кис','-')*4
|
||||
('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
|
||||
signal1=[0]*3+[1]*99; signal1
|
||||
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
|
||||
signal2=(0,)*3+(1,)*5+(0,)*7; signal2
|
||||
(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
|
||||
```
|
||||
|
||||
### 6.3 Проверка наличия заданного элемента в последовательности (in).
|
||||
|
||||
```
|
||||
stroka='Система автоматического управления'
|
||||
'автомат' in stroka
|
||||
True
|
||||
'ку' in ['ку','-']*3
|
||||
True
|
||||
'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
False
|
||||
```
|
||||
|
||||
### 6.4 Подстановка значений в строку с помощью оператора «%».
|
||||
|
||||
```
|
||||
stroka='Температура = %g %s %g'
|
||||
stroka % (16,' меньше ',25)
|
||||
'Температура = 16 меньше 25'
|
||||
stroka='Температура = %(zn1)g %(sravn)s %(zn2)g'
|
||||
stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
|
||||
'Температура = 16 меньше 25'
|
||||
```
|
||||
|
||||
## 7 Оператор присваивания.
|
||||
|
||||
### 7.1 Обычное присваивание значения переменной (=)
|
||||
|
||||
```
|
||||
zz=-12
|
||||
```
|
||||
|
||||
### 7.2 Увеличение значения переменной на заданную величину (+=) или уменьшение (-=).
|
||||
|
||||
Для последовательностей (например, строка) операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
|
||||
|
||||
```
|
||||
zz+=5; zz
|
||||
-7
|
||||
zz-=3; zz
|
||||
-10
|
||||
stroka='Система'
|
||||
stroka+=' регулирования'
|
||||
stroka
|
||||
'Система регулирования'
|
||||
```
|
||||
|
||||
### 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=).
|
||||
|
||||
Для строк операция (*=) означает повторение текущего значения объекта заданное число раз.
|
||||
|
||||
```
|
||||
zz/=2; zz
|
||||
-5.0
|
||||
zz*=5; zz
|
||||
-25.0
|
||||
stroka*=2; stroka
|
||||
'Система регулированияСистема регулирования'
|
||||
```
|
||||
|
||||
### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень (**=).
|
||||
|
||||
```
|
||||
zz//=7; zz
|
||||
-4.0
|
||||
zz%=3; zz
|
||||
2.0
|
||||
zz
|
||||
2.0
|
||||
zz**=5; zz
|
||||
32.0
|
||||
```
|
||||
|
||||
### 7.5 Множественное присваивание.
|
||||
|
||||
```
|
||||
w=v=10; w; v
|
||||
10
|
||||
10
|
||||
n1,n2,n3=(11,-3,'all'); n1; n2; n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
n1,n2,n3="11","-3","all"; n1; n2; n3
|
||||
'11'
|
||||
'-3'
|
||||
'all'
|
||||
n1,n2,n3=[11,-3,'all']; n1; n2; n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
n1,n2,n3={11: 0,-3: 3,'all': 1}; n1; n2; n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
n1,n2,n3={11,-3,'all'}; n1; n2; n3
|
||||
11
|
||||
'all'
|
||||
-3
|
||||
```
|
||||
|
||||
## 8 Логические операции
|
||||
|
||||
### 8.1 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=).
|
||||
|
||||
```
|
||||
w==v
|
||||
True
|
||||
w!=v
|
||||
False
|
||||
v+=8
|
||||
w>v
|
||||
False
|
||||
w<v
|
||||
True
|
||||
v>=w
|
||||
True
|
||||
v<=w
|
||||
False
|
||||
```
|
||||
|
||||
### 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in).
|
||||
|
||||
```
|
||||
mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
'book' in mnoz1
|
||||
True
|
||||
'cap' in mnoz1
|
||||
False
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
'Vologda' in dic1
|
||||
True
|
||||
'Pskov' in dic1
|
||||
False
|
||||
56 in dic1.values()
|
||||
True
|
||||
dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
|
||||
'UII' in dct1['Depart']
|
||||
True
|
||||
dct1['Depart'][1] == 'MM'
|
||||
False
|
||||
```
|
||||
|
||||
### 8.3 Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).
|
||||
|
||||
```
|
||||
a=17; b=-6
|
||||
(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
|
||||
True
|
||||
(a==b) or (145 in dic1.values()) or not ('VMSS' in dct1['Depart'])
|
||||
True
|
||||
(a>0) or ('pen' in mnoz1) and ('Moscow' in dic1)
|
||||
False
|
||||
```
|
||||
|
||||
### 8.4 Проверка ссылок переменных на один и тот же объект (is).
|
||||
|
||||
```
|
||||
w=v=10
|
||||
w is v
|
||||
True
|
||||
w1=['A','B']; v1=['A','B']
|
||||
w1 is v1
|
||||
False
|
||||
```
|
||||
|
||||
## 9 Операции с объектами, выполняемые с помощью методов.
|
||||
|
||||
Полный список атрибутов объекта с использованием dir():
|
||||
|
||||
```
|
||||
dir(stroka)
|
||||
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
|
||||
```
|
||||
|
||||
### 9.1 Методы для работы со строками.
|
||||
|
||||
```
|
||||
stroka.find('пр')
|
||||
5
|
||||
stroka.count("с")
|
||||
4
|
||||
stroka.replace(' у',' автоматического у')
|
||||
'Микропроцессорная система автоматического управления'
|
||||
spis22=stroka.split(' ')
|
||||
spis22
|
||||
['Микропроцессорная', 'система', 'управления']
|
||||
stroka.upper()
|
||||
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||
stroka3=" ".join(spis22); stroka3
|
||||
'Микропроцессорная система управления'
|
||||
stroka3.partition("с")
|
||||
('Микропроце', 'с', 'сорная система управления')
|
||||
stroka3.rpartition("с")
|
||||
('Микропроцессорная си', 'с', 'тема управления')
|
||||
strk1='Момент времени {}, значение = {}'
|
||||
strk1.format(1,89.7); strk1
|
||||
'Момент времени 1, значение = 89.7'
|
||||
'Момент времени {}, значение = {}'
|
||||
strk1.format(1,89.7)
|
||||
'Момент времени 1, значение = 89.7'
|
||||
strk2='Момент времени {1}, значение = {0}:{2}'
|
||||
strk2.format(36.7,2,'норма!')
|
||||
'Момент времени 2, значение = 36.7:норма!'
|
||||
strk3='Момент времени {num}, значение = {znch}'
|
||||
strk3.format(znch=89.7,num=2)
|
||||
'Момент времени 2, значение = 89.7'
|
||||
```
|
||||
|
||||
### 9.2 Методы работы со списками.
|
||||
|
||||
```
|
||||
spsk=[1, 'abc', (8, 5), [2, 5], 1+7j]
|
||||
spsk.pop(2); spsk
|
||||
(8, 5)
|
||||
[1, 'abc', [2, 5], (1+7j)]
|
||||
spsk.append('c'); spsk
|
||||
[1, 'abc', [2, 5], (1+7j), 'c']
|
||||
spsk.insert(2,'a'); spsk
|
||||
[1, 'abc', 'a', [2, 5], (1+7j), 'c']
|
||||
spsk.count('a')
|
||||
1
|
||||
```
|
||||
|
||||
### 9.3 Методы работы с кортежами.
|
||||
|
||||
```
|
||||
kort_m=(1, 5, 8+6j, 'u')
|
||||
dir(kort_m)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
|
||||
kort_m.count(5)
|
||||
1
|
||||
kort_m.index('u')
|
||||
3
|
||||
```
|
||||
|
||||
### 9.4 Методы работы со словарями и множествами.
|
||||
|
||||
Словари:
|
||||
|
||||
```
|
||||
dict_m={'a': '21', 'b': 't', 'c': 90}
|
||||
dir(dict_m)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
|
||||
dict_m.items()
|
||||
dict_items([('a', '21'), ('b', 't'), ('c', 90)])
|
||||
dict_m.values()
|
||||
dict_values(['21', 't', 90])
|
||||
dict_m.keys()
|
||||
dict_keys(['a', 'b', 'c'])
|
||||
dict_m.get('b')
|
||||
't'
|
||||
dict_m.popitem()
|
||||
('c', 90)
|
||||
dict_m.pop('b')
|
||||
't'
|
||||
dict_m
|
||||
{'a': '21'}
|
||||
dict_m.update({'v': 0, 'q': 'x'})
|
||||
dict_m
|
||||
{'a': '21', 'v': 0, 'q': 'x'}
|
||||
dict_m.clear()
|
||||
dict_m
|
||||
{}
|
||||
```
|
||||
|
||||
Множества:
|
||||
|
||||
```
|
||||
mn_m={'red','blue','green','black','blue'}
|
||||
mn_m
|
||||
{'green', 'red', 'blue', 'black'}
|
||||
dir(mn_m)
|
||||
['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
|
||||
mn_m.add('white')
|
||||
mn_m
|
||||
{'white', 'blue', 'black', 'red', 'green'}
|
||||
mn_m.remove('green')
|
||||
mn_m
|
||||
{'white', 'blue', 'black', 'red'}
|
||||
mn_m1=mn_m.copy()
|
||||
mn_m1
|
||||
{'red', 'white', 'blue', 'black'}
|
||||
mn_m1.add('yellow')
|
||||
mn_m
|
||||
{'white', 'blue', 'black', 'red'}
|
||||
mn_m1
|
||||
{'white', 'blue', 'black', 'yellow', 'red'}
|
||||
mn_m.difference(mn_m1)
|
||||
set()
|
||||
mn_m1.difference(mn_m)
|
||||
{'yellow'}
|
||||
mn_m2={'orange', 'violet', 'black'}
|
||||
mn_m3=mn_m.union(mn_m2); mn_m3
|
||||
{'violet', 'white', 'blue', 'black', 'orange', 'red'}
|
||||
mn_m3.symmetric_difference(mn_m2)
|
||||
{'blue', 'white', 'red'}
|
||||
mn_m3.intersection(mn_m2)
|
||||
{'violet', 'black', 'orange'}
|
||||
mn_m.issubset(mn_m1)
|
||||
True
|
||||
mn_m.isdisjoint(mn_m1)
|
||||
False
|
||||
```
|
||||
93
TEMA3/task.md
Обычный файл
93
TEMA3/task.md
Обычный файл
@@ -0,0 +1,93 @@
|
||||
# Общее контрольное задание по теме 3
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1) Преобразовать восьмеричное значение 45 в целое число.
|
||||
2) Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
|
||||
3) Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
|
||||
4) Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
5) Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
|
||||
6) Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
|
||||
7) Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
|
||||
|
||||
## Решение
|
||||
|
||||
1)
|
||||
|
||||
```
|
||||
int('45', 8)
|
||||
37
|
||||
```
|
||||
|
||||
2)
|
||||
|
||||
```
|
||||
D={"усиление":23, "запаздывание":12, "постоянная времени":78}
|
||||
D_k=list(D.keys()); D_k
|
||||
['усиление', 'запаздывание', 'постоянная времени']
|
||||
D_v=list(D.values()); D_v
|
||||
[23, 12, 78]
|
||||
K=tuple(D_k+D_v); K
|
||||
('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
|
||||
```
|
||||
|
||||
3)
|
||||
|
||||
```
|
||||
((1768//24.8)%3)**2.4
|
||||
5.278031643091577
|
||||
```
|
||||
|
||||
4)
|
||||
|
||||
```
|
||||
((~(13&27))^14)<<2
|
||||
-32
|
||||
```
|
||||
|
||||
5)
|
||||
|
||||
```
|
||||
spis=["колебат"]*4
|
||||
spis
|
||||
['колебат', 'колебат', 'колебат', 'колебат']
|
||||
"аткол" in spis[1]+spis[2]
|
||||
True
|
||||
```
|
||||
|
||||
6)
|
||||
|
||||
```
|
||||
dir(D)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
|
||||
help(D.keys)
|
||||
Help on built-in function keys:
|
||||
|
||||
keys() method of builtins.dict instance
|
||||
Return a set-like object providing a view on the dict's keys.
|
||||
|
||||
D.keys()
|
||||
dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
|
||||
help(D.values)
|
||||
Help on built-in function values:
|
||||
|
||||
values() method of builtins.dict instance
|
||||
Return an object providing a view on the dict's values.
|
||||
|
||||
D.values()
|
||||
dict_values([23, 12, 78])
|
||||
```
|
||||
|
||||
7)
|
||||
|
||||
```
|
||||
strok='Создать объект - символьную строку с текстом данного предложения'
|
||||
st_list=list(strok.split()); st_list
|
||||
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
st_list[st_list.index('-')]=','; st_list
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
st_list.remove('данного'); st_list
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
|
||||
```
|
||||
60
TEMA3/test.md
Обычный файл
60
TEMA3/test.md
Обычный файл
@@ -0,0 +1,60 @@
|
||||
# Тест по модулю 1
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание, вариант M1_24
|
||||
|
||||
1)Какое назначение имеют демонстрационные примеры в системе помощи?
|
||||
|
||||
2)Создайте объект-кортеж с 5 элементами - произвольными восьмеричными числами. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
|
||||
|
||||
3)Напишите инструкцию, позволяющую определить, сколько элементов в кортеже. Напишите инструкцию, позволяющую выделить из кортежа второе по порядку число и записать его в виде отдельной переменной. Отобразите на экране получившийся объект.
|
||||
|
||||
4)Преобразуйте кортеж в список. Вставьте в список на третью позицию число 888. Отобразите получившийся объект. Преобразуйте список в строку и уберите из неё разделители чисел. Отобразите строку.
|
||||
|
||||
5)Используя метод форматирования написать инструкцию вывода на экран заданного номером элемента кортежа по шаблону: "Элемент кортежа №4 = <значение элемента>".
|
||||
|
||||
## Выполнение
|
||||
|
||||
1) Демонстрационные примеры в системе помощи имеют назначение предоставить пользователю, который обратился к справочной информации, например, о какой-либо функции, реальный пример применения функции или метода, который можно реализовать и проверить его выполнение.
|
||||
|
||||
2)
|
||||
|
||||
```
|
||||
v=(oct(21), oct(7), oct(62), oct(32), oct(11)); v
|
||||
('0o25', '0o7', '0o76', '0o40', '0o13')
|
||||
type(v)
|
||||
<class 'tuple'>
|
||||
dir(v)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
|
||||
```
|
||||
|
||||
3)
|
||||
|
||||
```
|
||||
len(v)
|
||||
5
|
||||
v2=v[1]; v2
|
||||
'0o7'
|
||||
```
|
||||
|
||||
4)
|
||||
|
||||
```
|
||||
spisv=list(v); spisv
|
||||
['0o25', '0o7', '0o76', '0o40', '0o13']
|
||||
spisv.insert(2, 888); spisv
|
||||
['0o25', '0o7', 888, '0o76', '0o40', '0o13']
|
||||
strv=str(spisv); strv
|
||||
"['0o25', '0o7', 888, '0o76', '0o40', '0o13']"
|
||||
strv=strv.replace(', ', ' '); strv
|
||||
"['0o25' '0o7' 888 '0o76' '0o40' '0o13']"
|
||||
```
|
||||
|
||||
5)
|
||||
|
||||
```
|
||||
sss='Элемент кортежа №4 = {}'
|
||||
sss.format(v[3])
|
||||
'Элемент кортежа №4 = 0o40'
|
||||
```
|
||||
Двоичные данные
TEMA4/Ris1.png
Обычный файл
Двоичные данные
TEMA4/Ris1.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 20 KiB |
Двоичные данные
TEMA4/Ris11.png
Обычный файл
Двоичные данные
TEMA4/Ris11.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 28 KiB |
Двоичные данные
TEMA4/Ris2.png
Обычный файл
Двоичные данные
TEMA4/Ris2.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 15 KiB |
Двоичные данные
TEMA4/Ris3.png
Обычный файл
Двоичные данные
TEMA4/Ris3.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 8.4 KiB |
Двоичные данные
TEMA4/Ris4.png
Обычный файл
Двоичные данные
TEMA4/Ris4.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 8.3 KiB |
367
TEMA4/report.md
Обычный файл
367
TEMA4/report.md
Обычный файл
@@ -0,0 +1,367 @@
|
||||
# Отчет по теме 4
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск IDLE
|
||||
|
||||
## 2 Стандартные функции
|
||||
|
||||
### 2.1 Функция round
|
||||
|
||||
Округление числа с заданной точностью
|
||||
|
||||
```
|
||||
a=round(123.456,1); a; type(a)
|
||||
123.5
|
||||
<class 'float'>
|
||||
b=round(123.456,0); b; type(b)
|
||||
123.0
|
||||
<class 'float'>
|
||||
c=round(123.456); c; type(c)
|
||||
123
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
### 2.2 Функция range
|
||||
|
||||
Создание последовательности целых чисел с заданным шагом (по умолчанию с шагом 1).
|
||||
|
||||
```
|
||||
gg=range(76,123,9)
|
||||
gg
|
||||
range(76, 123, 9)
|
||||
list(gg)
|
||||
[76, 85, 94, 103, 112, 121]
|
||||
gg1=range(23); list(gg1)
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
|
||||
```
|
||||
|
||||
### 2.3 Функция zip
|
||||
|
||||
Создание общего объекта, элементами которого являются кортежи, составленные из элементов двух или более объектов-последовательностей
|
||||
|
||||
```
|
||||
qq=['Девятова', 'Ефимова', 'Беженарь', 'Гордиевских']
|
||||
ff=zip(gg,qq)
|
||||
ff
|
||||
<zip object at 0x000002B6596E6C00>
|
||||
tuple(ff)
|
||||
((76, 'Девятова'), (85, 'Ефимова'), (94, 'Беженарь'), (103, 'Гордиевских'))
|
||||
ff[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#16>", line 1, in <module>
|
||||
ff[1]
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
```
|
||||
|
||||
### 2.4 Функция eval
|
||||
|
||||
Вычисление значения выражения, записанного в виде символьной строки
|
||||
|
||||
```
|
||||
fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
||||
коэффициент усиления=81
|
||||
dan
|
||||
249.0
|
||||
```
|
||||
|
||||
### 2.5 Функция exec
|
||||
|
||||
Выполнение инструкций, переданных в аргумент функции в строковом виде
|
||||
|
||||
```
|
||||
exec(input('введите инструкции:'))
|
||||
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
||||
gg
|
||||
221.456
|
||||
```
|
||||
|
||||
### 2.6 Функции abs, pow, max, min, sum, divmod, len, map
|
||||
|
||||
```
|
||||
abs(-9)
|
||||
9
|
||||
pow(7, 3)
|
||||
343
|
||||
max(7, 9, 0)
|
||||
9
|
||||
min(-9, 0, 8)
|
||||
-9
|
||||
sum([1, -8, 7, 2])
|
||||
2
|
||||
divmod(43, 6)
|
||||
(7, 1)
|
||||
divmod(-43, 6)
|
||||
(-8, 5)
|
||||
divmod(-43, -6)
|
||||
(7, -1)
|
||||
len(qq)
|
||||
4
|
||||
length_words=map(len, qq); list(length_words)
|
||||
[8, 7, 8, 11]
|
||||
```
|
||||
|
||||
## 3 Функции из стандартного модуля math
|
||||
|
||||
```
|
||||
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.pi
|
||||
3.141592653589793
|
||||
math.degrees(1)
|
||||
57.29577951308232
|
||||
math.radians(60)
|
||||
1.0471975511965976
|
||||
math.sin(math.radians(30))
|
||||
0.49999999999999994
|
||||
math.degrees(math.acos(0.5))
|
||||
60.00000000000001
|
||||
math.degrees(math.acos(12))
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#70>", line 1, in <module>
|
||||
math.degrees(math.acos(12))
|
||||
ValueError: math domain error
|
||||
math.exp(2)
|
||||
7.38905609893065
|
||||
math.log(math.e)
|
||||
1.0
|
||||
math.log(49, 7)
|
||||
2.0
|
||||
math.log(-49, 7)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#73>", line 1, in <module>
|
||||
math.log(-49, 7)
|
||||
ValueError: math domain error
|
||||
math.log10(10)
|
||||
1.0
|
||||
math.sqrt(121)
|
||||
11.0
|
||||
math.sqrt(-49)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#79>", line 1, in <module>
|
||||
math.sqrt(-49)
|
||||
ValueError: math domain error
|
||||
math.ceil(11/2)
|
||||
6
|
||||
math.floor(11/2)
|
||||
5
|
||||
```
|
||||
|
||||
## 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', '_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()
|
||||
random.random()
|
||||
0.03177690077737194
|
||||
random.random()
|
||||
0.42660420133444044
|
||||
random.random()
|
||||
0.6029016351661705
|
||||
random.uniform(3, 8)
|
||||
3.349556259329991
|
||||
random.randint(3, 8)
|
||||
7
|
||||
random.gauss()
|
||||
1.3115168238883617
|
||||
random.gauss(5, 8)
|
||||
18.723843368888335
|
||||
lst=[13, 'cat', 5-8j, (1, 7), 67.8]
|
||||
random.choice(lst)
|
||||
(1, 7)
|
||||
random.shuffle(lst)
|
||||
lst
|
||||
[(1, 7), 13, 'cat', (5-8j), 67.8]
|
||||
random.sample(lst, 3)
|
||||
['cat', 67.8, (5-8j)]
|
||||
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(3, 7)
|
||||
0.5892004380254151
|
||||
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(4, 6)
|
||||
21.738935796671953
|
||||
rand=[random.uniform(1,2), random.gauss(), random.betavariate(2,5), random.gammavariate(3, 4)]
|
||||
rand
|
||||
[1.0853816485082923, -1.2263412989631917, 0.44973003958419866, 8.863321797224248]
|
||||
```
|
||||
|
||||
## 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']
|
||||
c1=time.time()
|
||||
c1
|
||||
1761126046.1433933
|
||||
c2=time.time()-c1; c2
|
||||
12.040217399597168
|
||||
dat=time.gmtime(); dat
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=9, tm_min=41, tm_sec=17, tm_wday=2, tm_yday=295, tm_isdst=0)
|
||||
type(dat)
|
||||
<class 'time.struct_time'>
|
||||
KeyboardInterrupt
|
||||
dat.tm_mon
|
||||
10
|
||||
dat.tm_yday
|
||||
295
|
||||
msc=time.localtime()
|
||||
msc
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=12, tm_min=43, tm_sec=12, tm_wday=2, tm_yday=295, tm_isdst=0)
|
||||
time.asctime()
|
||||
'Wed Oct 22 12:57:32 2025'
|
||||
time.ctime()
|
||||
'Wed Oct 22 12:58:08 2025'
|
||||
time.sleep(5)
|
||||
time.mktime(msc)
|
||||
1761126192.0
|
||||
time.localtime(c1)
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=12, tm_min=40, tm_sec=46, tm_wday=2, tm_yday=295, tm_isdst=0)
|
||||
```
|
||||
|
||||
## 7 Графические функции
|
||||
|
||||
```
|
||||
import pylab
|
||||
x=list(range(-3,55,4))
|
||||
t=list(range(15))
|
||||
pylab.plot(t,x)
|
||||
[<matplotlib.lines.Line2D object at 0x000002B66266AD50>]
|
||||
pylab.title('Первый график')
|
||||
Text(0.5, 1.0, 'Первый график')
|
||||
pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
|
||||
pylab.plot(X1)
|
||||
[<matplotlib.lines.Line2D object at 0x000002B664343610>]
|
||||
pylab.plot(X2)
|
||||
[<matplotlib.lines.Line2D object at 0x000002B664343750>]
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
region=['Центр','Урал','Сибирь','Юг']
|
||||
naselen=[65,12,23,17]
|
||||
pylab.pie(naselen,labels=region)
|
||||
([<matplotlib.patches.Wedge object at 0x000002B66264DD30>, <matplotlib.patches.Wedge object at 0x000002B663849090>, <matplotlib.patches.Wedge object at 0x000002B663849450>, <matplotlib.patches.Wedge object at 0x000002B6638496D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```
|
||||
pylab.hist([2, 3, 4, 21, 14, 0, 13, 19, 7, 9, 11], bins=4)
|
||||
(array([4., 2., 3., 2.]), array([ 0. , 5.25, 10.5 , 15.75, 21. ]), <BarContainer object of 4 artists>)
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```
|
||||
pylab.bar(region, naselen)
|
||||
<BarContainer object of 4 artists>
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 8 Некоторые функции статистического модуля statistics
|
||||
|
||||
```
|
||||
import statistics
|
||||
dir(statistics)
|
||||
['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_kernel_invcdfs', '_mean_stdev', '_newton_raphson', '_normal_dist_inv_cdf', '_quartic_invcdf', '_quartic_invcdf_estimate', '_random', '_rank', '_sqrt_bit_width', '_sqrtprod', '_ss', '_sum', '_triweight_invcdf', '_triweight_invcdf_estimate', 'acos', 'asin', 'atan', 'bisect_left', 'bisect_right', 'correlation', 'cos', 'cosh', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'isfinite', 'isinf', 'itemgetter', 'kde', 'kde_random', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pi', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sin', 'sqrt', 'stdev', 'sumprod', 'sys', 'tan', 'tau', 'variance']
|
||||
statistics.mode(['banana', 'apple', 'strawberry', 'lemon', 'apple', 'pineapple', 'lemon', 'apple'])
|
||||
'apple'
|
||||
statistics.mode(['banana', 'apple', 'strawberry', 'lemon', 'apple', 'pineapple', 'lemon', 'banana'])
|
||||
'banana'
|
||||
statistics.correlation(X1, X2)
|
||||
-0.3939192985791677
|
||||
statistics.stdev(X1)
|
||||
2.4083189157584592
|
||||
statistics.mean(X1)
|
||||
8.6
|
||||
```
|
||||
50
TEMA4/task.md
Обычный файл
50
TEMA4/task.md
Обычный файл
@@ -0,0 +1,50 @@
|
||||
# Общее контрольное задание по теме 4
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
|
||||
2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
|
||||
3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
|
||||
4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
|
||||
5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
|
||||
6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
import cmath
|
||||
divmod((round(cmath.phase(0.2+0.8j), 2))*20, 3)
|
||||
(8.0, 2.6000000000000014)
|
||||
import time
|
||||
t=time.localtime()
|
||||
t
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=23, tm_hour=23, tm_min=15, tm_sec=34, tm_wday=3, tm_yday=296, tm_isdst=0)
|
||||
msc_time=str(t.tm_hour)+':'+str(t.tm_min); msc_time
|
||||
'23:15'
|
||||
week=['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
|
||||
import random
|
||||
random.sample(week, 3)
|
||||
['sunday', 'tuesday', 'friday']
|
||||
random.choice(range(14, 32, 3))
|
||||
20
|
||||
N=round(random.gauss(15, 4))
|
||||
N
|
||||
11
|
||||
alphabet=[]
|
||||
for i in range(ord('a'), ord('z')+1):
|
||||
alphabet.append(chr(i))
|
||||
|
||||
|
||||
for i in range(ord('A'), ord('Z')+1):
|
||||
alphabet.append(chr(i))
|
||||
|
||||
|
||||
alphabet
|
||||
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
|
||||
R=random.sample(alphabet, N); R
|
||||
['j', 'u', 'U', 'w', 'p', 'I', 'g', 'R', 'h', 'P', 'G']
|
||||
time.localtime().tm_min-t.tm_min
|
||||
20
|
||||
```
|
||||
30
TEMA4/test.md
Обычный файл
30
TEMA4/test.md
Обычный файл
@@ -0,0 +1,30 @@
|
||||
# Индивидуальное контрольное задание по теме 4
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
Напишите инструкцию запоминания текущего Московского времени в некоторой переменной.
|
||||
Создайте кортеж с целочисленными значениями от 0 до 136 с шагом 17. Подсчитайте число элементов в кортеже.
|
||||
Создайте нормально распределенное число Z с математическим ожиданием 47 и стандартным отклонением 22.
|
||||
Нацело разделите сумму элементов кортежа на округленное до целого значения Z.
|
||||
Отобразите результат в виде символьной строки вида «Результат = ХХ» с использование формата.
|
||||
Определите время в минутах, прошедшее с начала выполнения данного задания.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
import time; import random
|
||||
t1=time.localtime(); t1
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=4, tm_sec=41, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
cort=tuple(range(0, 136, 17)); cort; len(cort)
|
||||
(0, 17, 34, 51, 68, 85, 102, 119)
|
||||
8
|
||||
Z=random.gauss(47, 22); Z
|
||||
107.92112395720454
|
||||
res=sum(cort)//round(Z)
|
||||
print("Результат = {}".format(res))
|
||||
Результат = 4
|
||||
time.localtime().tm_min-t1.tm_min
|
||||
5
|
||||
```
|
||||
Двоичные данные
TEMA5/Figure_1.png
Обычный файл
Двоичные данные
TEMA5/Figure_1.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 41 KiB |
Двоичные данные
TEMA5/Figure_2.png
Обычный файл
Двоичные данные
TEMA5/Figure_2.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 21 KiB |
326
TEMA5/report.md
Обычный файл
326
TEMA5/report.md
Обычный файл
@@ -0,0 +1,326 @@
|
||||
# Отчет по теме 5
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск IDLE
|
||||
|
||||
## 2 Ветвление по условию – управляющая инструкция if
|
||||
|
||||
На данном этапе используются блоки инструкций. Блок инструкций может располагаться на нескольких строках.
|
||||
Отступы во всех строках блока должны быть одинаковыми по отношению к первому символу управляющей инструкции.
|
||||
Если имеется вложенная управляющая инструкция, то она вводится с таким же отступом,
|
||||
а все строки ее блоков – отступают по отношению к ее первому символу.
|
||||
|
||||
Если в блоке инструкций только одна инструкция, её можно записывать без отступов сразу за знаком «:».
|
||||
|
||||
```
|
||||
porog=10; rashod1=4; rashod2=21
|
||||
if rashod1>=porog:
|
||||
dohod=12
|
||||
elif rashod2==porog:
|
||||
dohod=0
|
||||
else:
|
||||
dohod=-8
|
||||
|
||||
dohod
|
||||
-8
|
||||
if rashod1>=3 and rashod2==4:
|
||||
dohod=rashod1
|
||||
if rashod2==porog or rashod1<rashod2:
|
||||
dohod=porog
|
||||
|
||||
|
||||
dohod
|
||||
-8
|
||||
if porog==3:
|
||||
dohod=1
|
||||
elif porog==4:
|
||||
dohod=2
|
||||
elif porog==5:
|
||||
dohod=3
|
||||
else:
|
||||
dohod=0
|
||||
|
||||
dohod
|
||||
0
|
||||
```
|
||||
|
||||
Условные инструкции могут записываться также в одну строку.
|
||||
|
||||
```
|
||||
dohod=2 if porog>=4 else 0
|
||||
dohod
|
||||
2
|
||||
if porog>=5 : rashod1=6; rashod2=0
|
||||
|
||||
rashod1; rashod2
|
||||
6
|
||||
0
|
||||
```
|
||||
|
||||
## 3 Цикл по перечислению – управляющая инструкция for
|
||||
|
||||
### 3.1 Простой цикл
|
||||
|
||||
```
|
||||
temperatura=5
|
||||
for i in range(3,18,3):
|
||||
temperatura+=i
|
||||
|
||||
temperatura
|
||||
50
|
||||
```
|
||||
|
||||
### 3.2 Более сложный цикл
|
||||
|
||||
```
|
||||
sps=[2,15,14,8]
|
||||
for k in sps:
|
||||
if len(sps)<=10:sps.append(sps[0])
|
||||
else:break
|
||||
|
||||
sps
|
||||
[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
|
||||
```
|
||||
|
||||
Нужно учитывать, что в первом случае происходит проход k по объекту sps, который в самом цикле расширяется (в него добавляются новые элементы), т.е. без условия if-else был бы получен бесконечный цикл, т.к. k бы никогда не доходил до конца списка.
|
||||
В случае, когда вместо объекта sps используется его срез (копия списка), проход k происходит по созданной копии. Т.к. длина созданной копии списка 4, то и было добавлено всего 4 элемента.
|
||||
|
||||
```
|
||||
sps=[2,15,14,8]
|
||||
for k in sps[:]:
|
||||
if len(sps)<=10:sps.append(sps[0])
|
||||
else:break
|
||||
|
||||
sps
|
||||
[2, 15, 14, 8, 2, 2, 2, 2]
|
||||
```
|
||||
|
||||
### 3.3 Пример с использованием случайных чисел
|
||||
|
||||
Пример: создание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране. Если сумма элементов превышает 500, то вывода не будет, что продемонстрировано в примерах ниже.
|
||||
|
||||
```
|
||||
import random as rn
|
||||
sps5=[]
|
||||
for i in range(10):
|
||||
sps5.append(rn.randint(1,100))
|
||||
ss=sum(sps5)
|
||||
if ss>500: break
|
||||
else:
|
||||
print(ss)
|
||||
|
||||
|
||||
466
|
||||
```
|
||||
|
||||
```
|
||||
sps5=[]
|
||||
for i in range(10):
|
||||
sps5.append(rn.randint(1,100))
|
||||
ss=sum(sps5)
|
||||
if ss>500: break
|
||||
else:
|
||||
print(ss)
|
||||
|
||||
|
||||
ss
|
||||
562
|
||||
```
|
||||
|
||||
### 3.4 Пример с символьной строкой
|
||||
|
||||
```
|
||||
stroka='Это – автоматизированная система'; stroka1=""
|
||||
for ss in stroka:
|
||||
stroka1+=" "+ss
|
||||
|
||||
|
||||
stroka1
|
||||
' Э т о – а в т о м а т и з и р о в а н н а я с и с т е м а'
|
||||
```
|
||||
|
||||
### 3.5 Запись цикла в строке. Пример: создание списка с синусоидальным сигналом.
|
||||
|
||||
```
|
||||
import math
|
||||
sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
|
||||
sps2
|
||||
[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
|
||||
import pylab
|
||||
pylab.plot(sps2)
|
||||
[<matplotlib.lines.Line2D object at 0x000002C4F1336990>]
|
||||
pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
## 4 Цикл «пока истинно условие» – управляющая инструкция while.
|
||||
|
||||
### 4.1 Цикл со счетчиком.
|
||||
|
||||
```
|
||||
rashod=300
|
||||
while rashod:
|
||||
print("Расход=",rashod)
|
||||
rashod-=50
|
||||
|
||||
Расход= 300
|
||||
Расход= 250
|
||||
Расход= 200
|
||||
Расход= 150
|
||||
Расход= 100
|
||||
Расход= 50
|
||||
```
|
||||
|
||||
Цикл выполняется, пока логическое значение rashod истинно, т.е. при преобразовании в логический тип объект имеет значение True.
|
||||
Это условие выполняется всегда, пока rashod != 0. Как только rashod приобрёл значение 0, при преобразовании в логический тип получаем False, поэтому при проверке условия на истинность rashod происходит выход из цикла.
|
||||
|
||||
### 4.2 Пример с символьной строкой.
|
||||
|
||||
```
|
||||
import math
|
||||
stroka='Расчет процесса в объекте регулирования'
|
||||
i=0; sps2=[]
|
||||
while i<len(stroka):
|
||||
r=1-2/(1+math.exp(0.1*i))
|
||||
sps2.append(r)
|
||||
print('Значение в момент',i,"=",r)
|
||||
i+=1
|
||||
|
||||
Значение в момент 0 = 0.0
|
||||
Значение в момент 1 = 0.049958374957880025
|
||||
Значение в момент 2 = 0.09966799462495568
|
||||
Значение в момент 3 = 0.14888503362331795
|
||||
Значение в момент 4 = 0.197375320224904
|
||||
Значение в момент 5 = 0.2449186624037092
|
||||
Значение в момент 6 = 0.2913126124515909
|
||||
Значение в момент 7 = 0.3363755443363322
|
||||
Значение в момент 8 = 0.3799489622552249
|
||||
Значение в момент 9 = 0.421899005250008
|
||||
Значение в момент 10 = 0.4621171572600098
|
||||
Значение в момент 11 = 0.5005202111902354
|
||||
Значение в момент 12 = 0.5370495669980353
|
||||
Значение в момент 13 = 0.5716699660851172
|
||||
Значение в момент 14 = 0.6043677771171636
|
||||
Значение в момент 15 = 0.6351489523872873
|
||||
Значение в момент 16 = 0.6640367702678489
|
||||
Значение в момент 17 = 0.6910694698329307
|
||||
Значение в момент 18 = 0.7162978701990245
|
||||
Значение в момент 19 = 0.7397830512740043
|
||||
Значение в момент 20 = 0.7615941559557649
|
||||
Значение в момент 21 = 0.7818063576087741
|
||||
Значение в момент 22 = 0.8004990217606297
|
||||
Значение в момент 23 = 0.8177540779702878
|
||||
Значение в момент 24 = 0.8336546070121553
|
||||
Значение в момент 25 = 0.8482836399575129
|
||||
Значение в момент 26 = 0.8617231593133063
|
||||
Значение в момент 27 = 0.874053287886007
|
||||
Значение в момент 28 = 0.8853516482022625
|
||||
Значение в момент 29 = 0.8956928738431645
|
||||
Значение в момент 30 = 0.9051482536448664
|
||||
Значение в момент 31 = 0.9137854901178277
|
||||
Значение в момент 32 = 0.9216685544064713
|
||||
Значение в момент 33 = 0.9288576214547277
|
||||
Значение в момент 34 = 0.935409070603099
|
||||
Значение в момент 35 = 0.9413755384972874
|
||||
Значение в момент 36 = 0.9468060128462683
|
||||
Значение в момент 37 = 0.9517459571646616
|
||||
Значение в момент 38 = 0.9562374581277391
|
||||
import pylab
|
||||
pylab.plot(sps2)
|
||||
[<matplotlib.lines.Line2D object at 0x000002C4F23BBED0>]
|
||||
pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
pylab.title('Сигнал на выходе инерционного звена')
|
||||
Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
### 4.3 Определение, является ли число простым (делится только на самого себя или 1).
|
||||
|
||||
```
|
||||
chislo=267
|
||||
kandidat=chislo // 2
|
||||
while kandidat > 1:
|
||||
if chislo%kandidat == 0:
|
||||
print(chislo, ' имеет множитель ', kandidat)
|
||||
break
|
||||
kandidat -= 1
|
||||
else:
|
||||
print(chislo, ' является простым!')
|
||||
|
||||
|
||||
267 имеет множитель 89
|
||||
for chislo in range(250, 301):
|
||||
kandidat=chislo//2
|
||||
while kandidat > 1:
|
||||
if chislo%kandidat == 0:
|
||||
print(chislo, ' имеет множитель ', kandidat)
|
||||
break
|
||||
kandidat -= 1
|
||||
else:
|
||||
print(chislo, ' является простым!')
|
||||
|
||||
|
||||
250 имеет множитель 125
|
||||
251 является простым!
|
||||
252 имеет множитель 126
|
||||
253 имеет множитель 23
|
||||
254 имеет множитель 127
|
||||
255 имеет множитель 85
|
||||
256 имеет множитель 128
|
||||
257 является простым!
|
||||
258 имеет множитель 129
|
||||
259 имеет множитель 37
|
||||
260 имеет множитель 130
|
||||
261 имеет множитель 87
|
||||
262 имеет множитель 131
|
||||
263 является простым!
|
||||
264 имеет множитель 132
|
||||
265 имеет множитель 53
|
||||
266 имеет множитель 133
|
||||
267 имеет множитель 89
|
||||
268 имеет множитель 134
|
||||
269 является простым!
|
||||
270 имеет множитель 135
|
||||
271 является простым!
|
||||
272 имеет множитель 136
|
||||
273 имеет множитель 91
|
||||
274 имеет множитель 137
|
||||
275 имеет множитель 55
|
||||
276 имеет множитель 138
|
||||
277 является простым!
|
||||
278 имеет множитель 139
|
||||
279 имеет множитель 93
|
||||
280 имеет множитель 140
|
||||
281 является простым!
|
||||
282 имеет множитель 141
|
||||
283 является простым!
|
||||
284 имеет множитель 142
|
||||
285 имеет множитель 95
|
||||
286 имеет множитель 143
|
||||
287 имеет множитель 41
|
||||
288 имеет множитель 144
|
||||
289 имеет множитель 17
|
||||
290 имеет множитель 145
|
||||
291 имеет множитель 97
|
||||
292 имеет множитель 146
|
||||
293 является простым!
|
||||
294 имеет множитель 147
|
||||
295 имеет множитель 59
|
||||
296 имеет множитель 148
|
||||
297 имеет множитель 99
|
||||
298 имеет множитель 149
|
||||
299 имеет множитель 23
|
||||
300 имеет множитель 150
|
||||
```
|
||||
|
||||
## 5 Завершение работы
|
||||
108
TEMA5/task.md
Обычный файл
108
TEMA5/task.md
Обычный файл
@@ -0,0 +1,108 @@
|
||||
# Общее контрольное задание ао теме 5
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
|
||||
1. Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
|
||||
2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
|
||||
3. Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
|
||||
|
||||
## Выполнение
|
||||
|
||||
1.
|
||||
|
||||
```
|
||||
alphabet = 'abcdefghijklmnopqrstuvwxyz'
|
||||
text = 'Laugh when you can. It’s a cheap medicine'
|
||||
for letter in text.lower():
|
||||
if letter not in alphabet:
|
||||
continue
|
||||
else:
|
||||
i = alphabet.index(letter)+1
|
||||
print('Буква {} имеет порядковый номер {} в алфавите'.format(letter, i))
|
||||
|
||||
|
||||
Буква l имеет порядковый номер 12 в алфавите
|
||||
Буква a имеет порядковый номер 1 в алфавите
|
||||
Буква u имеет порядковый номер 21 в алфавите
|
||||
Буква g имеет порядковый номер 7 в алфавите
|
||||
Буква h имеет порядковый номер 8 в алфавите
|
||||
Буква w имеет порядковый номер 23 в алфавите
|
||||
Буква h имеет порядковый номер 8 в алфавите
|
||||
Буква e имеет порядковый номер 5 в алфавите
|
||||
Буква n имеет порядковый номер 14 в алфавите
|
||||
Буква y имеет порядковый номер 25 в алфавите
|
||||
Буква o имеет порядковый номер 15 в алфавите
|
||||
Буква u имеет порядковый номер 21 в алфавите
|
||||
Буква c имеет порядковый номер 3 в алфавите
|
||||
Буква a имеет порядковый номер 1 в алфавите
|
||||
Буква n имеет порядковый номер 14 в алфавите
|
||||
Буква i имеет порядковый номер 9 в алфавите
|
||||
Буква t имеет порядковый номер 20 в алфавите
|
||||
Буква s имеет порядковый номер 19 в алфавите
|
||||
Буква a имеет порядковый номер 1 в алфавите
|
||||
Буква c имеет порядковый номер 3 в алфавите
|
||||
Буква h имеет порядковый номер 8 в алфавите
|
||||
Буква e имеет порядковый номер 5 в алфавите
|
||||
Буква a имеет порядковый номер 1 в алфавите
|
||||
Буква p имеет порядковый номер 16 в алфавите
|
||||
Буква m имеет порядковый номер 13 в алфавите
|
||||
Буква e имеет порядковый номер 5 в алфавите
|
||||
Буква d имеет порядковый номер 4 в алфавите
|
||||
Буква i имеет порядковый номер 9 в алфавите
|
||||
Буква c имеет порядковый номер 3 в алфавите
|
||||
Буква i имеет порядковый номер 9 в алфавите
|
||||
Буква n имеет порядковый номер 14 в алфавите
|
||||
Буква e имеет порядковый номер 5 в алфавите
|
||||
```
|
||||
|
||||
2.
|
||||
|
||||
```
|
||||
tt = 'Создайте список со словами из задания данного пункта Для этого списка определите есть ли в нем некоторое заданное значение и выведите соответствующее сообщение: либо о нахождении элемента либо о его отсутствии в списке проверить как с имеющимся так и с отсутствующим словом'
|
||||
ss = tt.split(' ')
|
||||
ss
|
||||
['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение:', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
|
||||
word=input('Введите искомое слово в списке: '); mess='Слово есть в списке!' if word in ss else 'Слова нет в списке!'; print(mess)
|
||||
Введите искомое слово в списке: списка
|
||||
Слово есть в списке!
|
||||
word=input('Введите искомое слово в списке: '); mess='Слово есть в списке!' if word in ss else 'Слова нет в списке!'; print(mess)
|
||||
Введите искомое слово в списке: списка
|
||||
Слово есть в списке!
|
||||
word=input('Введите искомое слово в списке: '); mess='Слово есть в списке!' if word in ss else 'Слова нет в списке!'; print(mess)
|
||||
Введите искомое слово в списке: спис
|
||||
Слова нет в списке!
|
||||
```
|
||||
|
||||
3.
|
||||
|
||||
```
|
||||
spis1=['Ефимова', 'Гордиевских', 'Антонов']
|
||||
mark1=[4.12, 4.56, 5.0]
|
||||
spis2=['Антонов', 'Гордиевских', 'Ефимова']
|
||||
mark2=[4.91, 4.83, 4.78]
|
||||
stud=input('Введите фамилию студента: ')
|
||||
Введите фамилию студента: Антонов
|
||||
if (stud in spis1) and (stud in spis2):
|
||||
summer=mark1[spis1.index(stud)]
|
||||
winter=mark2[spis2.index(stud)]
|
||||
print('Балл студента с фамилией {} на летней сессии: {}, на зимней сессии: {}'.format(stud, summer, winter))
|
||||
else:
|
||||
print('Студента с фамилией {} нет в списках'.format(stud))
|
||||
|
||||
|
||||
Балл студента с фамилией Антонов на летней сессии: 5.0, на зимней сессии: 4.91
|
||||
stud=input('Введите фамилию студента: ')
|
||||
Введите фамилию студента: Корнеев
|
||||
if (stud in spis1) and (stud in spis2):
|
||||
summer=mark1[spis1.index(stud)]
|
||||
winter=mark2[spis2.index(stud)]
|
||||
print('Балл студента с фамилией {} на летней сессии: {}, на зимней сессии: {}'.format(stud, summer, winter))
|
||||
else:
|
||||
print('Студента с фамилией {} нет в списках'.format(stud))
|
||||
|
||||
|
||||
Студента с фамилией Корнеев нет в списках
|
||||
```
|
||||
23
TEMA5/test.md
Обычный файл
23
TEMA5/test.md
Обычный файл
@@ -0,0 +1,23 @@
|
||||
# Индивидуальное контрольное задание по теме 5
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание 11
|
||||
|
||||
Создайте символьную строку с текстом: «я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство». Напишите инструкции, позволяющие определить, каких букв русского алфавита нет в этой строке.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
stroka='я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство'
|
||||
alphabet='абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
|
||||
for letter in alphabet:
|
||||
if letter not in stroka:
|
||||
print('Буквы {} нет в строке'.format(letter))
|
||||
|
||||
|
||||
Буквы ё нет в строке
|
||||
Буквы п нет в строке
|
||||
Буквы ы нет в строке
|
||||
```
|
||||
|
||||
49
TEMA6/module2.md
Обычный файл
49
TEMA6/module2.md
Обычный файл
@@ -0,0 +1,49 @@
|
||||
# Выполнение модуля №2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1. Создайте словарь с 3 элементами: ключи - OTDEL, SOTRUD, DOLZHN, значения - списки, соответственно отделов предприятия (3-4 отдела с наименованиями вида "Отдел1":), список сотрудников (3-4 фамилии), список должностей сотрудников.
|
||||
|
||||
2. Запросите у пользователя и введите 3 целых числа: номер отдела по списку, порядковый номер сотрудника по списку, порядковый номер должности. Проверьте соответствие введенных чисел числу соответствующих элементов списков. При отсутствии соответствия повторить ввод.
|
||||
|
||||
3. Выведите на экран сообщение по шаблону: " Отдел: <название отдела из списка>, сотрудник: <ФИО сотрудника из списка>, должность: <название должности из списка> в соответствии с выбором пользователя и со значениями из словаря.
|
||||
|
||||
4. Запишите это же сообщение в текстовый файл с некоторым именем в режиме добавления строки.
|
||||
|
||||
5. Удалите из памяти все созданные объекты-переменные.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
otd=['Отдел1', 'Отдел2', 'Отдел3']
|
||||
sotr=['Ефимова', 'Беженарь', 'Антонов']
|
||||
dolzhn=['инженер-проектировщик', 'финансовый директор', 'инженер-технолог']
|
||||
job={'OTDEL': otd, 'SOTRUD': sotr, 'DOLZHN': dolzhn}
|
||||
while True:
|
||||
c1=int(input('Введите номер отдела '))
|
||||
c2=int(input('Введите номер сотрудника '))
|
||||
c3=int(input('Введите номер должности '))
|
||||
if c1<=len(job['OTDEL']) and c2<=len(job['SOTRUD']) and c3<=len(job['DOLZHN']):
|
||||
stroka= 'Отдел: ' + str(job['OTDEL'][c1-1]) + ' Сотрудник: ' + str(job['SOTRUD'][c2-1]) + ' Должность: ' + str(job['DOLZHN'][c3-1])
|
||||
print(stroka)
|
||||
fp=open('test.txt', 'w')
|
||||
fp.write(stroka)
|
||||
fp.close()
|
||||
break
|
||||
else:
|
||||
print('Введено число, превышающее длину одного из списков. Повторите попытку')
|
||||
|
||||
|
||||
Введите номер отдела 3
|
||||
Введите номер сотрудника 1
|
||||
Введите номер должности 6
|
||||
Введено число, превышающее длину одного из списков. Повторите попытку
|
||||
Введите номер отдела 1
|
||||
Введите номер сотрудника 3
|
||||
Введите номер должности 2
|
||||
Отдел: Отдел1 Сотрудник: Антонов Должность: финансовый директор
|
||||
63
|
||||
del otd, job, dolzhn, sotr, c1, c2, c3, fp, stroka
|
||||
```
|
||||
473
TEMA6/report.md
Обычный файл
473
TEMA6/report.md
Обычный файл
@@ -0,0 +1,473 @@
|
||||
# Отчет по теме 6
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск IDLE
|
||||
|
||||
## 2 Вывод данных на экран дисплея
|
||||
|
||||
### 2.1 Вывод в командной строке
|
||||
|
||||
Вывод содержимого объекта простым упоминанием в командной строке называется "эхо-выводом" (пригоден только при работе в командной строке)
|
||||
|
||||
```
|
||||
stroka='Автоматизированная система управления'
|
||||
stroka
|
||||
'Автоматизированная система управления'
|
||||
```
|
||||
|
||||
### 2.2 Вывод с использованием функции print
|
||||
|
||||
По умолчанию sep=' ', т.е. при выводе нескольких объектов они разделяются пробелом, но можно задать и другое значение sep.
|
||||
|
||||
```
|
||||
fff=234.5;gg='Значение температуры = '
|
||||
print(gg, fff)
|
||||
Значение температуры = 234.5
|
||||
print(gg, fff, sep='/')
|
||||
Значение температуры = /234.5
|
||||
```
|
||||
|
||||
По умолчанию end='\n', т.е. выводимая строка заканчивается переносом на новую строку, но аналогично можно задать другое значение.
|
||||
При использовании print() без аргументов так же происходит переход на новую строку.
|
||||
|
||||
```
|
||||
print(gg, fff,sep='/',end='***'); print('____')
|
||||
Значение температуры = /234.5***____
|
||||
print()
|
||||
|
||||
```
|
||||
|
||||
Также возможно расположение выводимого текста на нескольких строках при использовании тройных кавычек или перечисление выводимых строк в двойных кавычках через запятую.
|
||||
Разница будет в том, что при использовании тройных кавычек текст выводится на экран ровно так, как был передан (с переносами строки), а при перечислении объектов через запятую, несмотря на то, что они передавались на разных строках, вывод будет в одну строку, с использованием пробела как разделителя.
|
||||
|
||||
```
|
||||
print(""" Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк""")
|
||||
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
print("Здесь может выводиться",
|
||||
"большой текст,",
|
||||
"занимающий несколько строк")
|
||||
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
```
|
||||
|
||||
### 2.3 Вывод с использованием метода write объекта sys.stdout
|
||||
|
||||
Объект stdout - поток стандартного вывода. Объект находится в модуле sys.
|
||||
При использовании метода write необходимо учитывать, что после вывода не происходит переноса на следующую строку, поэтому необходимо в конце строки добавить '\n'.
|
||||
Также метод в конце строки возвращает целое число - кол-во символов в строке (\n - 1 символ)
|
||||
|
||||
```
|
||||
import sys
|
||||
sys.stdout.write('Функция write')
|
||||
Функция write13
|
||||
sys.stdout.write('Функция write\n')
|
||||
Функция write
|
||||
14
|
||||
```
|
||||
|
||||
## 3 Ввод данных с клавиатуры
|
||||
|
||||
Для ввода с клавиатуры используется функция input. Полученный объект имеет строковый тип данных.
|
||||
|
||||
```
|
||||
psw=input('Введите пароль:')
|
||||
Введите пароль:1111
|
||||
psw
|
||||
'1111'
|
||||
type(psw)
|
||||
<class 'str'>
|
||||
```
|
||||
|
||||
Пример 1. Ввод с контролем значения.
|
||||
|
||||
```
|
||||
while True:
|
||||
znach=float(input('Задайте коэф.усиления = '))
|
||||
if znach<17.5 or znach>23.8:
|
||||
print('Ошибка!')
|
||||
else:
|
||||
break
|
||||
|
||||
Задайте коэф.усиления = 15.4
|
||||
Ошибка!
|
||||
Задайте коэф.усиления = 21.6
|
||||
```
|
||||
|
||||
Пример 2. Ввод и обработка выражения
|
||||
|
||||
```
|
||||
import math
|
||||
print(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
```
|
||||
|
||||
## 4 Ввод-вывод при работе с файлами
|
||||
|
||||
### 4.1 Функции для работы с путем к файлу
|
||||
|
||||
Используя функцию os.getcwd(), можно получить путь к текущему рабочему каталогу.
|
||||
При обычном эхо-выводе отображаются двойные обратные слэши, при использовании print() - одинарные.
|
||||
|
||||
```
|
||||
import os
|
||||
os.getcwd()
|
||||
'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA6'
|
||||
Devyatova=os.getcwd(); print(Devyatova)
|
||||
C:\Users\Necroa\Desktop\ПОАС\python-labs\TEMA6
|
||||
```
|
||||
|
||||
Была использована функция os.chdir() для смены рабочего каталога.
|
||||
|
||||
```
|
||||
os.chdir('C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA5')
|
||||
os.getcwd()
|
||||
'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA5'
|
||||
```
|
||||
|
||||
Функция os.mkdir() создаёт новый каталог.
|
||||
|
||||
```
|
||||
os.mkdir('alice')
|
||||
os.chdir('alice')
|
||||
os.getcwd()
|
||||
'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA6\\alice'
|
||||
```
|
||||
|
||||
Функция os.listdir() возвращает список каталогов и файлов, находящихся внутри данного каталога.
|
||||
|
||||
```
|
||||
os.chdir('../')
|
||||
os.listdir()
|
||||
['.gitkeep', 'alice', 'report.md']
|
||||
```
|
||||
|
||||
Удаление каталога через os.rmdir().
|
||||
|
||||
```
|
||||
os.rmdir('alice')
|
||||
os.listdir()
|
||||
['.gitkeep', 'report.md']
|
||||
```
|
||||
os.path.isdir() позволяет проверить наличие каталога. Для несуществующих каталогов, ровно как и для любых файлов (которые не являются в свою очередь каталогами), возвращает False.
|
||||
|
||||
```
|
||||
os.path.isdir('report.md')
|
||||
False
|
||||
os.chdir('../')
|
||||
os.path.isdir('TEMA6')
|
||||
True
|
||||
```
|
||||
|
||||
Был получен путь до файла, имя которого передаётся в качестве аргумента в os.path.abspath(). Затем из абсолютного пути был извлечен путь до каталога, в котором находится файл, затем имя самого файла, после чего был получен кортеж с путём до каталога и именем файла, находящегося внутри него.
|
||||
|
||||
```
|
||||
fil=os.path.abspath('report.md'); print(fil)
|
||||
C:\Users\Necroa\Desktop\ПОАС\python-labs\TEMA6\report.md
|
||||
drkt=os.path.dirname(fil); print(drkt)
|
||||
C:\Users\Necroa\Desktop\ПОАС\python-labs\TEMA6
|
||||
bsn=os.path.basename(fil); print(bsn)
|
||||
report.md
|
||||
os.path.split(fil)
|
||||
('C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA6', 'report.md')
|
||||
```
|
||||
|
||||
Было проверено, существует ли путь, передаваемый в виде символьной строки.
|
||||
|
||||
```
|
||||
os.path.exists(fil)
|
||||
True
|
||||
filf=drkt+'\\alice'; print(filf)
|
||||
C:\Users\Necroa\Desktop\ПОАС\python-labs\TEMA6\alice
|
||||
os.path.exists(filf)
|
||||
False
|
||||
```
|
||||
|
||||
Проверка на наличие файла с известным расположением.
|
||||
|
||||
```
|
||||
os.path.isfile(fil)
|
||||
True
|
||||
os.path.isfile(os.path.dirname(fil)+'fil1.txt')
|
||||
False
|
||||
```
|
||||
|
||||
### 4.2 Общая схема работы с файлом
|
||||
|
||||
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||
1. Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||
2. Выполнение одной или нескольких операций обмена данными с файлом;
|
||||
3. Закрытие файла.
|
||||
|
||||
### 4.3 Открытие файла для записи или чтения данных – функция open
|
||||
|
||||
Был создан файловый объект fp класса _io.TextIOWrapper для работы с текстовыми данными.
|
||||
В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования.
|
||||
Файл по такой инструкции открывается только для записи в файл. Если требуются другие операции с открываемым файлом, то для второго аргумента mode могут быть заданы следующие значения:
|
||||
w – запись с созданием нового файла или перезапись существующего файла,
|
||||
w+ - чтение и запись/перезапись файла,
|
||||
r – только чтение (это значение - по умолчанию),
|
||||
r+ - чтение и/или запись в существующий файл,
|
||||
a – запись в конец существующего файла или, если его нет, запись с созданием файла,
|
||||
a+ - то же, но с возможностью чтения из файла.
|
||||
|
||||
```
|
||||
fp=open(file=drkt+'\\zapis1.txt',mode='w')
|
||||
type(fp); dir(fp)
|
||||
<class '_io.TextIOWrapper'>
|
||||
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
|
||||
```
|
||||
|
||||
Вообще говоря, аргументы функции при указании их имен могут располагаться в любом порядке.
|
||||
Если же имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать, а вводить в соответствующем порядке.
|
||||
Также если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла.
|
||||
|
||||
```
|
||||
fp=open(drkt+'\\zapis1.txt','w')
|
||||
fp=open('zapis1.txt','w')
|
||||
```
|
||||
|
||||
Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ b.
|
||||
|
||||
```
|
||||
fp1=open(drkt+'\\zapis2.bin',mode='wb+')
|
||||
```
|
||||
|
||||
### 4.4 Закрытие файла
|
||||
|
||||
```
|
||||
fp.close()
|
||||
```
|
||||
|
||||
### 4.5 Запись информации в файл с помощью метода write
|
||||
|
||||
Был создан список и записан несколькими срезами в файл. Метод write возвращает число записанных в файл символов.
|
||||
|
||||
```
|
||||
sps=list(range(1,13))
|
||||
fp2=open('zapis3.txt','w')
|
||||
fp2.write(str(sps[:4])+'\n')
|
||||
13
|
||||
fp2.write(str(sps[4:8])+'\n')
|
||||
13
|
||||
fp2.write(str(sps[8:])+'\n')
|
||||
16
|
||||
fp2.close()
|
||||
```
|
||||
|
||||
Содержимое файла zapis3.txt:
|
||||
|
||||
```
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
```
|
||||
|
||||
Пример со списком, содержащим внутри себя списки. Пример неудачной построчной записи элементов в файл:
|
||||
|
||||
```
|
||||
sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
|
||||
fp3=open('zapis4.txt','w')
|
||||
for i in range(len(sps3)):
|
||||
stroka4=sps3[i][0]+' '+str(sps3[i][1])
|
||||
fp3.write(stroka4)
|
||||
|
||||
11
|
||||
11
|
||||
12
|
||||
fp3.close()
|
||||
```
|
||||
|
||||
```
|
||||
Иванов И. 1Петров П. 2Сидоров С. 3
|
||||
```
|
||||
|
||||
Поэтому добавляем '\n':
|
||||
|
||||
```
|
||||
gh=open('zapis5.txt','w')
|
||||
for r in sps3:
|
||||
gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
|
||||
12
|
||||
12
|
||||
13
|
||||
gh.close()
|
||||
```
|
||||
|
||||
```
|
||||
Иванов И. 1
|
||||
Петров П. 2
|
||||
Сидоров С. 3
|
||||
```
|
||||
|
||||
Либо с представлением цикла в одной строке:
|
||||
|
||||
```
|
||||
gh=open('zapis5.txt','w')
|
||||
for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
|
||||
12
|
||||
12
|
||||
13
|
||||
gh.close()
|
||||
```
|
||||
|
||||
```
|
||||
Иванов И. 1
|
||||
Петров П. 2
|
||||
Сидоров С. 3
|
||||
```
|
||||
|
||||
### 4.6 Один из способов чтения информации из текстового файла
|
||||
|
||||
```
|
||||
sps1=[]
|
||||
fp=open('zapis3.txt')
|
||||
for stroka in fp:
|
||||
stroka=stroka.rstrip('\n')
|
||||
stroka=stroka.replace('[','')
|
||||
stroka=stroka.replace(']','')
|
||||
sps1=sps1+stroka.split(',')
|
||||
|
||||
fp.close()
|
||||
sps1
|
||||
['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
|
||||
sps
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
```
|
||||
|
||||
Полученный при чтении файла список sps1 содержит элементы строкового типа (необходим целочисленный, как в sps). Преобразуем элементы списка:
|
||||
|
||||
```
|
||||
sps3=list(map(int, sps1))
|
||||
sps3
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
```
|
||||
|
||||
### 4.7 Чтение информации из файла с помощью метода read
|
||||
|
||||
В методе read в качестве аргумента можно передавать количество символов, которые нужно прочитать. Если число не указано, то чтение ведется от маркера и до конца файла.
|
||||
|
||||
```
|
||||
fp=open('zapis3.txt')
|
||||
stroka1=fp.read(12)
|
||||
stroka2=fp.read()
|
||||
fp.close()
|
||||
stroka1; stroka2
|
||||
'[1, 2, 3, 4]'
|
||||
'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
|
||||
```
|
||||
|
||||
### 4.8 Чтение информации с помощью методов readline и readlines
|
||||
|
||||
```
|
||||
fp=open('zapis3.txt')
|
||||
s1=fp.readline()
|
||||
s2=fp.readlines()
|
||||
fp.close()
|
||||
s1; s2
|
||||
'[1, 2, 3, 4]\n'
|
||||
['[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
|
||||
```
|
||||
|
||||
### 4.9 Ввод-вывод объектов с использованием функций из модуля pickle
|
||||
|
||||
В модуле pickle содержатся функции для работы с бинарными файлами, в которые могут последовательно записываться или считываться целиком один или несколько объектов из оперативной памяти.
|
||||
|
||||
```
|
||||
import pickle
|
||||
mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
fp=open('zapis6.mnz','wb')
|
||||
pickle.dump(mnoz1,fp)
|
||||
fp.close()
|
||||
```
|
||||
|
||||
Содержимое файла zapis6.mnz:
|
||||
|
||||
```
|
||||
Ђ•# Џ”(Њbook”Њtable”Њpen”ЊiPhone”ђ.
|
||||
```
|
||||
|
||||
При прочтении данных из файла было получено то же самое множество, что и созданное ранее (учитывая, что все элементы в множестве должны быть уникальны).
|
||||
|
||||
```
|
||||
fp=open('zapis6.mnz','rb')
|
||||
mnoz2=pickle.load(fp)
|
||||
fp.close()
|
||||
mnoz2
|
||||
{'book', 'table', 'pen', 'iPhone'}
|
||||
mnoz1 == mnoz2
|
||||
True
|
||||
```
|
||||
|
||||
Были записаны и прочитаны два разных объекта: множество и ранее созданный список.
|
||||
При считывании каждое обращение к load считывает один объект, в том порядке, в котором объекты записывались в файл.
|
||||
Было проверено, что полученные при чтении файла объекты совпадают с теми, что были использованы при записи в файл.
|
||||
|
||||
```
|
||||
fp=open('zapis7.2ob','wb')
|
||||
pickle.dump(mnoz1,fp)
|
||||
pickle.dump(sps3,fp)
|
||||
fp.close()
|
||||
fp=open('zapis7.2ob','rb')
|
||||
obj1=pickle.load(fp)
|
||||
obj2=pickle.load(fp)
|
||||
fp.close()
|
||||
obj1; obj2
|
||||
{'book', 'table', 'pen', 'iPhone'}
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
obj1 == mnoz1; obj2 == sps3
|
||||
True
|
||||
True
|
||||
```
|
||||
|
||||
## 5 Перенаправление потоков ввода и вывода данных
|
||||
|
||||
Поток вывода был перенаправлен в файл, потом снова восстановлен для вывода на экран.
|
||||
|
||||
```
|
||||
import sys
|
||||
vr_out=sys.stdout
|
||||
fc=open('Stroka.txt','w')
|
||||
sys.stdout=fc
|
||||
print('запись строки в файл')
|
||||
sys.stdout=vr_out
|
||||
print('запись строки в файл')
|
||||
запись строки в файл
|
||||
fc.close()
|
||||
```
|
||||
|
||||
Содержимое файла Stroka.txt:
|
||||
|
||||
```
|
||||
запись строки в файл
|
||||
```
|
||||
|
||||
Подобным образом можно перенаправить и поток ввода.
|
||||
|
||||
```
|
||||
tmp_in = sys.stdin
|
||||
fd = open("Stroka.txt", "r")
|
||||
sys.stdin = fd
|
||||
sys.stdin
|
||||
<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
|
||||
while True:
|
||||
try:
|
||||
line = input ()
|
||||
print(line)
|
||||
except EOFError:
|
||||
break
|
||||
|
||||
запись строки в файл
|
||||
fd.close()
|
||||
sys.stdin=tmp_in
|
||||
```
|
||||
|
||||
## 6 Завершение работы
|
||||
68
TEMA6/task.md
Обычный файл
68
TEMA6/task.md
Обычный файл
@@ -0,0 +1,68 @@
|
||||
# Общее контрольное задание по теме 6
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
|
||||
1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
|
||||
2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
|
||||
3. Записывается кортеж в бинарный файл.
|
||||
4. Записывается в этот же файл список и закрывается файл.
|
||||
5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
|
||||
6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
|
||||
7. Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде отдельных списков со своими именами.
|
||||
|
||||
## Выполнение
|
||||
|
||||
Инструкции для выполнения задания присутствуют в файле [task.py](task.py)
|
||||
|
||||
1. Создание кортежа
|
||||
```
|
||||
import random
|
||||
tup1=[]
|
||||
for i in range(125): tup1.append(str(random.randint(6, 56)))
|
||||
tup1=tuple(tup1); tup1
|
||||
('46', '43', '25', '14', '47', '19', '41', '28', '26', '24', '24', '10', '30', '37', '45', '19', '6', '28', '47', '21', '51', '30', '29', '12', '23', '10', '11', '41', '22', '53', '15', '24', '41', '30', '52', '33', '31', '35', '41', '38', '9', '21', '49', '44', '22', '7', '13', '49', '55', '46', '36', '25', '29', '14', '31', '37', '39', '14', '9', '47', '15', '10', '29', '27', '39', '55', '25', '34', '47', '11', '22', '29', '37', '8', '32', '51', '14', '47', '51', '44', '38', '46', '51', '47', '50', '15', '47', '17', '47', '32', '33', '13', '28', '27', '43', '16', '33', '29', '28', '52', '47', '26', '54', '16', '37', '21', '22', '28', '27', '8', '46', '6', '51', '14', '54', '6', '20', '8', '38', '22', '29', '40', '31', '25', '16')
|
||||
```
|
||||
|
||||
2-4. Создание списка, запись кортежа и списка в бинарный файл, чтение обоих объектов из файла
|
||||
|
||||
```
|
||||
sps1=['Девятова', 'Ефимова', 'Беженарь', 'Антонов', 'Гордиевских']
|
||||
import pickle
|
||||
fp=open('fil.mnz', 'wb')
|
||||
pickle.dump(tup1, fp)
|
||||
pickle.dump(sps1, fp)
|
||||
fp.close()
|
||||
fp=open('fil.mnz', 'rb')
|
||||
tup2=pickle.load(fp)
|
||||
sps2=pickle.load(fp)
|
||||
fp.close()
|
||||
```
|
||||
|
||||
5. Проверка на совпадение объектов
|
||||
|
||||
```
|
||||
print('Кортежи совпадают') if tup1 == tup2 else print('Кортежи не совпадают')
|
||||
Кортежи совпадают
|
||||
print('Списки совпадают') if sps1 == sps2 else print('Списки не совпадают')
|
||||
Списки совпадают
|
||||
```
|
||||
|
||||
6. Разделение кортежа на списки по 5 чисел, представленных в строковом виде. Для контроля выведены некоторые из созданных объектов
|
||||
|
||||
```
|
||||
for i in range(0, len(tup1), 5):
|
||||
exec('spisk' + str(i//5+1) + '=' + str(list(tup1[i:i+5])))
|
||||
|
||||
|
||||
spisk1
|
||||
['46', '43', '25', '14', '47']
|
||||
spisk25
|
||||
['29', '40', '31', '25', '16']
|
||||
spisk2
|
||||
['19', '41', '28', '26', '24']
|
||||
spisk3
|
||||
['24', '10', '30', '37', '45']
|
||||
```
|
||||
25
TEMA6/task.py
Обычный файл
25
TEMA6/task.py
Обычный файл
@@ -0,0 +1,25 @@
|
||||
import random
|
||||
tup1=[]
|
||||
for i in range(125):
|
||||
tup1.append(str(random.randint(6, 56)))
|
||||
tup1=tuple(tup1)
|
||||
print(tup1)
|
||||
|
||||
sps1=['Девятова', 'Ефимова', 'Беженарь', 'Антонов', 'Гордиевских']
|
||||
|
||||
import pickle
|
||||
fp=open('fil.mnz', 'wb')
|
||||
pickle.dump(tup1, fp)
|
||||
pickle.dump(sps1, fp)
|
||||
fp.close()
|
||||
|
||||
fp=open('fil.mnz', 'rb')
|
||||
tup2=pickle.load(fp)
|
||||
sps2=pickle.load(fp)
|
||||
fp.close()
|
||||
|
||||
print('Кортежи совпадают') if tup1 == tup2 else print('Кортежи не совпадают')
|
||||
print('Списки совпадают') if sps1 == sps2 else print('Списки не совпадают')
|
||||
|
||||
for i in range(0, len(tup1), 5):
|
||||
exec('spisk' + str(i//5+1) + '=' + str(list(tup1[i:i+5])))
|
||||
1
TEMA6/test.txt
Обычный файл
1
TEMA6/test.txt
Обычный файл
@@ -0,0 +1 @@
|
||||
Отдел: Отдел1 Сотрудник: Антонов Должность: финансовый директор
|
||||
Двоичные данные
TEMA7/Figure_1.png
Обычный файл
Двоичные данные
TEMA7/Figure_1.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 17 KiB |
Двоичные данные
TEMA7/Figure_2.png
Обычный файл
Двоичные данные
TEMA7/Figure_2.png
Обычный файл
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 6.1 KiB |
533
TEMA7/report.md
Обычный файл
533
TEMA7/report.md
Обычный файл
@@ -0,0 +1,533 @@
|
||||
# Отчет по теме 7
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск IDLE
|
||||
|
||||
## 2 Создание пользовательской функции
|
||||
|
||||
### 2.1 Первый пример: функция – без аргументов.
|
||||
|
||||
```
|
||||
def uspeh():
|
||||
"""Подтверждение успеха операции"""
|
||||
print('Выполнено успешно!')
|
||||
|
||||
uspeh()
|
||||
Выполнено успешно!
|
||||
type(uspeh)
|
||||
<class 'function'>
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
|
||||
help(uspeh)
|
||||
Help on function uspeh in module __main__:
|
||||
|
||||
uspeh()
|
||||
Подтверждение успеха операции
|
||||
```
|
||||
|
||||
В качестве справочной информации по созданной функции возвращается строка, ранее заданная в тройных кавычках. Отсюда можно сделать вывод, что помощь нужно организовывать, используя данный прием.
|
||||
|
||||
### 2.2 Пример функции с аргументами
|
||||
|
||||
```
|
||||
def sravnenie(a,b):
|
||||
"""Сравнение a и b"""
|
||||
if a>b:
|
||||
print(a,' больше ',b)
|
||||
elif a<b:
|
||||
print(a, ' меньше ',b)
|
||||
else:
|
||||
print(a, ' равно ',b)
|
||||
|
||||
n,m=16,5;sravnenie(n,m)
|
||||
16 больше 5
|
||||
s1='stroka'; s2='STROCHKA'; sravnenie(s1, s2)
|
||||
stroka больше STROCHKA
|
||||
b1='s'; b2='a'; sravnenie(b1, b2)
|
||||
s больше a
|
||||
t1='root'; t2='roots'; sravnenie(t1, t2)
|
||||
root меньше roots
|
||||
t1='root'; t3='root'; sravnenie(t1, t3)
|
||||
root равно root
|
||||
```
|
||||
|
||||
В качестве аргументов можно передавать строки, сравнение проводится между каждой парой символов (точнее между их значениями в кодировке Unicode) до первого различия или конца одной из строк.
|
||||
|
||||
### 2.3 Пример функции, содержащей return.
|
||||
|
||||
```
|
||||
def logistfun(b,a):
|
||||
"""Вычисление логистической функции"""
|
||||
import math
|
||||
return a/(1+math.exp(-b))
|
||||
|
||||
v,w=1,0.7;z=logistfun(w,v)
|
||||
z
|
||||
0.6681877721681662
|
||||
```
|
||||
|
||||
### 2.4 Сложение для разных типов аргументов
|
||||
|
||||
```
|
||||
def slozh(a1,a2,a3,a4):
|
||||
""" Сложение значений четырех аргументов"""
|
||||
return a1+a2+a3+a4
|
||||
|
||||
slozh(1,2,3,4)
|
||||
10
|
||||
slozh('1','2','3','4')
|
||||
'1234'
|
||||
b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
|
||||
q=slozh(b1,b2,b3,b4)
|
||||
q
|
||||
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||
c1=(0,7);c2=(-1,8);c3=(-10,2);c4=(5,-5)
|
||||
cc=slozh(c1,c2,c3,c4); cc
|
||||
(0, 7, -1, 8, -10, 2, 5, -5)
|
||||
m1={'orange', 'apple'}; m2={'coffee', 'tea'}; m3={'ice', 'fire'}; m4={'white', 'yellow'}
|
||||
mm=slozh(m1,m2,m3,m4); mm
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#27>", line 1, in <module>
|
||||
mm=slozh(m1,m2,m3,m4); mm
|
||||
File "<pyshell#16>", line 3, in slozh
|
||||
return a1+a2+a3+a4
|
||||
TypeError: unsupported operand type(s) for +: 'set' and 'set'
|
||||
d1={'fruit': ['orange', 'apple']}; d2={'coffee': ['espresso', 'latte'], 'tea': ['black tea', 'green tea']}; d3={'antonyms': ['ice', 'fire']}; d4={'colour': ['white', 'yellow']}
|
||||
dd=slozh(d1,d2,d3,d4); dd
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#31>", line 1, in <module>
|
||||
dd=slozh(d1,d2,d3,d4); dd
|
||||
File "<pyshell#16>", line 3, in slozh
|
||||
return a1+a2+a3+a4
|
||||
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
|
||||
```
|
||||
|
||||
### 2.5 Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y
|
||||
|
||||
```
|
||||
def inerz(x,T,ypred):
|
||||
""" Модель устройства с памятью:
|
||||
x- текущее значение вх.сигнала,
|
||||
T -постоянная времени,
|
||||
ypred - предыдущее значение выхода устройства"""
|
||||
y=(x+T*ypred)/(T+1)
|
||||
return y
|
||||
|
||||
sps=[0]+[1]*100
|
||||
spsy=[]
|
||||
TT=20
|
||||
yy=0
|
||||
for xx in sps:
|
||||
yy=inerz(xx,TT,yy)
|
||||
spsy.append(yy)
|
||||
|
||||
import pylab
|
||||
pylab.plot(spsy)
|
||||
[<matplotlib.lines.Line2D object at 0x0000021CFFE1A710>]
|
||||
pylab.xlabel('t, time'); pylab.ylabel('y, output signal')
|
||||
Text(0.5, 0, 't, time')
|
||||
Text(0, 0.5, 'y, output signal')
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 3 Функции как объекты
|
||||
|
||||
### 3.1 Получение списка атрибутов объекта-функции
|
||||
|
||||
```
|
||||
dir(inerz)
|
||||
['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
|
||||
inerz.__doc__
|
||||
'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
|
||||
help(inerz)
|
||||
Help on function inerz in module __main__:
|
||||
|
||||
inerz(x, T, ypred)
|
||||
Модель устройства с памятью:
|
||||
x- текущее значение вх.сигнала,
|
||||
T -постоянная времени,
|
||||
ypred - предыдущее значение выхода устройства
|
||||
```
|
||||
|
||||
### 3.2 Сохранение ссылки на объект-функцию в другой переменной
|
||||
|
||||
```
|
||||
fnkt=sravnenie
|
||||
v=16
|
||||
fnkt(v,23)
|
||||
16 меньше 23
|
||||
```
|
||||
|
||||
### 3.3 Возможность альтернативного определения функции в программе
|
||||
|
||||
```
|
||||
typ_fun=8
|
||||
if typ_fun==1:
|
||||
def func():
|
||||
print('Функция 1')
|
||||
else:
|
||||
def func():
|
||||
print('Функция 2')
|
||||
|
||||
func()
|
||||
Функция 2
|
||||
```
|
||||
|
||||
## 4 Аргументы функции
|
||||
|
||||
### 4.1 Использование функции в качестве аргумента другой функции
|
||||
|
||||
```
|
||||
def fun_arg(fff,a,b,c):
|
||||
"""fff-имя функции, используемой
|
||||
в качестве аргумента функции fun_arg"""
|
||||
return a+fff(c,b)
|
||||
|
||||
zz=fun_arg(logistfun,-3,1,0.7)
|
||||
zz
|
||||
-2.3318122278318336
|
||||
```
|
||||
|
||||
### 4.2 Обязательные и необязательные аргументы
|
||||
|
||||
```
|
||||
def logistfun(a,b=1):
|
||||
"""Вычисление логистической функции"""
|
||||
import math
|
||||
return b/(1+math.exp(-a))
|
||||
|
||||
logistfun(0.7)
|
||||
0.6681877721681662
|
||||
logistfun(0.7, 2)
|
||||
1.3363755443363323
|
||||
```
|
||||
|
||||
### 4.3 Возможность обращения к функции с произвольным (непозиционным) расположением аргументов
|
||||
|
||||
Для этого необходимо в обращении к функции указывать имена аргументов
|
||||
|
||||
```
|
||||
logistfun(b=0.5,a=0.8)
|
||||
0.34498724056380625
|
||||
```
|
||||
|
||||
### 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже
|
||||
|
||||
```
|
||||
b1234=[b1,b2,b3,b4]; b1234
|
||||
[[1, 2], [-1, -2], [0, 2], [-1, -1]]
|
||||
qq=slozh(*b1234); qq
|
||||
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||
```
|
||||
|
||||
### 4.5 Пример со значениями аргументов функции, содержащимися в словаре
|
||||
|
||||
```
|
||||
dic4={"a1":1,"a2":2,"a3":3,"a4":4}
|
||||
qqq=slozh(**dic4)
|
||||
qqq
|
||||
10
|
||||
```
|
||||
|
||||
### 4.6 Смешанные ссылки
|
||||
|
||||
```
|
||||
e1=(-1,6);dd2={'a3':3,'a4':9}
|
||||
qqqq=slozh(*e1,**dd2); qqqq
|
||||
17
|
||||
```
|
||||
|
||||
### 4.7 Переменное число аргументов у функции.
|
||||
|
||||
```
|
||||
def func4(*kort7):
|
||||
"""Произвольное число аргументов в составе кортежа"""
|
||||
smm=0
|
||||
for elt in kort7:
|
||||
smm+=elt
|
||||
return smm
|
||||
|
||||
func4(-1,2)
|
||||
1
|
||||
func4(-1,2,0,3,6)
|
||||
10
|
||||
```
|
||||
|
||||
### 4.8 Комбинация аргументов
|
||||
|
||||
```
|
||||
def func4(a,b=7,*kort7):
|
||||
"""Кортеж - сборка аргументов - должен быть последним!"""
|
||||
smm=0
|
||||
for elt in kort7:
|
||||
smm+=elt
|
||||
return a*smm+b
|
||||
|
||||
func4(-1,2,0,3,6)
|
||||
-7
|
||||
```
|
||||
|
||||
Со словарем:
|
||||
|
||||
```
|
||||
def func44(a,b=7,**dict11):
|
||||
"""Словарь - сборка аргументов - должен быть последним!"""
|
||||
smm=0
|
||||
for elt in dict11.values():
|
||||
smm+=elt
|
||||
return a*smm+b
|
||||
|
||||
dddd={'c1': 2, 'c2': 0, 'c3': 3, 'c4': 6}
|
||||
func44(-1, **dddd)
|
||||
-4
|
||||
```
|
||||
|
||||
### 4.9 Изменение значений объектов, используемых в качестве аргументов функции.
|
||||
|
||||
Такое изменение возможно только у объектов изменяемого типа (например, списки).
|
||||
|
||||
```
|
||||
a=90
|
||||
def func3(b):
|
||||
b=5*b+67
|
||||
|
||||
|
||||
func3(a)
|
||||
a
|
||||
90
|
||||
sps1=[1,2,3,4]
|
||||
def func2(sps):
|
||||
sps[1]=99
|
||||
|
||||
|
||||
func2(sps1)
|
||||
sps1
|
||||
[1, 99, 3, 4]
|
||||
kort=(1,2,3,4)
|
||||
func2(kort)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#99>", line 1, in <module>
|
||||
func2(kort)
|
||||
File "<pyshell#94>", line 2, in func2
|
||||
sps[1]=99
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
```
|
||||
|
||||
## 5 Специальные типы пользовательских функций
|
||||
|
||||
### 5.1 Анонимные функции
|
||||
|
||||
Анонимные функции или по-другому лямбда-функции – функции без имени
|
||||
|
||||
```
|
||||
anfun1=lambda: 1.5+math.log10(17.23)
|
||||
anfun1()
|
||||
2.7362852774480286
|
||||
anfun2=lambda a,b : a+math.log10(b)
|
||||
anfun2(17,234)
|
||||
19.369215857410143
|
||||
anfun3=lambda a,b=234: a+math.log10(b)
|
||||
anfun3(100)
|
||||
102.36921585741014
|
||||
```
|
||||
|
||||
### 5.2 Функции-генераторы
|
||||
|
||||
```
|
||||
def func5(diap,shag):
|
||||
""" Итератор, возвращающий значения
|
||||
из диапазона от 1 до diap с шагом shag"""
|
||||
for j in range(1,diap+1,shag):
|
||||
yield j
|
||||
|
||||
|
||||
for mm in func5(7,3):
|
||||
print(mm)
|
||||
|
||||
|
||||
1
|
||||
4
|
||||
7
|
||||
alp=func5(7,3)
|
||||
print(alp.__next__())
|
||||
1
|
||||
print(alp.__next__())
|
||||
4
|
||||
print(alp.__next__())
|
||||
7
|
||||
```
|
||||
|
||||
## 6 Локализация объектов в функциях
|
||||
|
||||
### 6.1 Примеры на локализацию объектов
|
||||
|
||||
Пример 1. Одноименные локальный и глобальный объекты
|
||||
|
||||
```
|
||||
glb=10
|
||||
def func7(arg):
|
||||
loc1=15
|
||||
glb=8
|
||||
return loc1*arg
|
||||
|
||||
res=func7(glb); res
|
||||
150
|
||||
glb
|
||||
10
|
||||
```
|
||||
|
||||
Пример 2. Ошибка в использовании локального объекта.
|
||||
|
||||
```
|
||||
def func8(arg):
|
||||
loc1=15
|
||||
print(glb)
|
||||
glb=8
|
||||
return loc1*arg
|
||||
|
||||
res=func8(glb); res
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#29>", line 1, in <module>
|
||||
res=func8(glb); res
|
||||
File "<pyshell#28>", line 3, in func8
|
||||
print(glb)
|
||||
UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
|
||||
```
|
||||
|
||||
В данном примере локальной переменной glb внутри пользовательской функции присваивается значение, поэтому print принимает именно локальную переменную.
|
||||
Но из-за того, что присваивание значения происходит после print, происходит ошибка.
|
||||
|
||||
Пример 3. Переопределение локализации объекта
|
||||
|
||||
```
|
||||
glb=11
|
||||
def func7(arg):
|
||||
loc1=15
|
||||
global glb
|
||||
print(glb)
|
||||
glb=8
|
||||
return loc1*arg
|
||||
|
||||
res=func7(glb); res; glb
|
||||
11
|
||||
165
|
||||
8
|
||||
```
|
||||
|
||||
### 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
|
||||
|
||||
```
|
||||
globals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
locals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
```
|
||||
|
||||
В возвращенных списках элементы совпадают, т.к. locals() вернул локальные объекты на уровне рабочего пространства, где содержатся глобальные.
|
||||
|
||||
```
|
||||
def func8(arg):
|
||||
loc1=15
|
||||
glb=8
|
||||
print(globals().keys())
|
||||
print(locals().keys())
|
||||
return loc1*arg
|
||||
|
||||
hh=func8(glb)
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
dict_keys(['arg', 'loc1', 'glb'])
|
||||
'glb' in globals().keys()
|
||||
True
|
||||
```
|
||||
|
||||
В данном примере списки отличаются, т.к. на уровне пользовательской функции глобальные и локальные объекты разные
|
||||
|
||||
### 6.3 Локализация объектов при использовании вложенных функций
|
||||
|
||||
```
|
||||
def func9(arg2,arg3):
|
||||
def func9_1(arg1):
|
||||
loc1=15
|
||||
glb1=8
|
||||
print('glob_func9_1:',globals().keys())
|
||||
print('locl_func9_1:',locals().keys())
|
||||
return loc1*arg1
|
||||
loc1=5
|
||||
glb=func9_1(loc1)
|
||||
print('loc_func9:',locals().keys())
|
||||
print('glob_func9:',globals().keys())
|
||||
return arg2+arg3*glb
|
||||
|
||||
kk=func9(10,1)
|
||||
glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
|
||||
locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
|
||||
loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
|
||||
glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
|
||||
```
|
||||
|
||||
Глобальные объекты для обеих функций совпадают. Список локальных объектов функции func9 содержит имена arg2,arg3,loc1, glb и имя вложенной функции func9_1. Среди локальных объектов вложенной функции arg1,loc1,glb1, при этом loc1 в функциях func9 и func9_1 - две разные переменные
|
||||
|
||||
### 6.4 Большой пример
|
||||
|
||||
Здесь происходит моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала.
|
||||
Реальный двигатель: последовательное соединение усилителя с коэффициентом усиления k1,интегратора: y(t)=x(t)+y(t-1), и инерционного звена: y(t)=(x(t)+T*y(t-1)) / (T+1) с постоянной времени Т.
|
||||
Тахогенератор: последовательное соединение усилителя с коэффициентом усиления k2 и интегратора: y(t)=x(t)+y(t-1).
|
||||
Нелинейное звено типа «зона нечувствительности»: y=0 при -xm≤ x ≤xm, y=x-xm при x>xm, y=x+xm при x<-xm.
|
||||
Таким образом, система характеризуется параметрами: k1, T, k2, xm. Входной сигнал характеризуется параметрами: A (амплитуда синусоиды) и F (период синусоиды).
|
||||
Еще один параметр задачи : N – время (число тактов) подачи сигнала.
|
||||
|
||||
```
|
||||
znach=input('k1,T,k2,Xm,A,F,N=').split(',')
|
||||
k1,T,k2,Xm,A,F,N=15,10,30,0.2,5,0.001,50
|
||||
k1=float(znach[0])
|
||||
T=float(znach[1])
|
||||
k2=float(znach[2])
|
||||
Xm=float(znach[3])
|
||||
A=float(znach[4])
|
||||
F=float(znach[5])
|
||||
N=int(znach[6])
|
||||
vhod=[]
|
||||
for i in range(N):
|
||||
vhod.append(A*math.sin((2*i*math.pi)/F))
|
||||
|
||||
|
||||
vhod
|
||||
[0.0, -3.2141664592756336e-12, -6.428332918551267e-12, -5.09502586896226e-12, -1.2856665837102534e-11, -2.428411769784245e-12, -1.019005173792452e-11, -1.7951691706064795e-11, -2.571333167420507e-11, -3.347497164234534e-11, -4.85682353956849e-12, -4.8998251578625896e-11, -2.038010347584904e-11, 8.238044626927816e-12, -3.590338341212959e-11, -8.004481145118699e-11, -5.142666334841014e-11, -2.2808515245633285e-11, -6.694994328469069e-11, -3.833179518191383e-11, -9.71364707913698e-12, -5.385507511819438e-11, -9.799650315725179e-11, -1.421379311963092e-10, -4.076020695169808e-11, 6.061751729291303e-11, 1.647608925385563e-11, -2.7665338785201775e-11, -7.180676682425918e-11, 2.957095742035194e-11, -1.6008962290237398e-10, -5.871189865776288e-11, -1.0285332669682028e-10, -1.4756024522091648e-12, -4.561703049126657e-11, -8.975845853032398e-11, -1.3389988656938137e-10, -3.2522162324770265e-11, -7.666359036382766e-11, -1.2080501840288506e-10, -1.942729415827396e-11, -2.0908787448099986e-10, -1.0771015023638876e-10, -1.5185157827544617e-10, -1.9599300631450358e-10, 5.090387021377606e-11, -2.842758623926184e-10, -3.7378985864338755e-11, -8.152041390339616e-11, -1.2566184194245356e-10]
|
||||
def realdvig(xtt,kk1,TT,yti1,ytin1):
|
||||
yp=kk1*xtt
|
||||
yti1=yp+yti1
|
||||
ytin1=(yti1+TT*ytin1)/(TT+1)
|
||||
return [yti1,ytin1]
|
||||
|
||||
def tahogen(xtt,kk2,yti2):
|
||||
yp=kk2*xtt
|
||||
yti2=yp+yti2
|
||||
return yti2
|
||||
|
||||
def nechus(xtt,gran):
|
||||
if xtt<gran and xtt>(-gran):
|
||||
ytt=0
|
||||
elif xtt>=gran:
|
||||
ytt=xtt-gran
|
||||
elif xtt<=(-gran):
|
||||
ytt=xtt+gran
|
||||
return ytt
|
||||
|
||||
vyhod=[]
|
||||
yi1=0;yin1=0;yi2=0
|
||||
for xt in vhod:
|
||||
xt1=xt-yi2
|
||||
[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
|
||||
yi2=tahogen(yin1,k2,yi2)
|
||||
yt=nechus(yin1,Xm)
|
||||
vyhod.append(yt)
|
||||
|
||||
|
||||
print('y=',vyhod)
|
||||
y= [0, 0, 0, 0, 0, 0, 0, 0, 0.28235063576021646, -18.09317618367068, 693.569780896497, -26311.05967697136, 997855.8681822185, -37843749.77748839, 1435226439.7890663, -54431047009.38599, 2064300653896.8462, -78288723509751.45, 2969104436030480.0, -1.126034600750363e+17, 4.2704928351466476e+18, -1.6195869152587386e+20, 6.142292885938634e+21, -2.3294681835969964e+23, 8.834521764361373e+24, -3.3504975665500395e+26, 1.2706781694446622e+28, -4.8190544187315804e+29, 1.8276292179353242e+31, -6.931294540413311e+32, 2.62869752433907e+34, -9.969350796127492e+35, 3.780882143191306e+37, -1.433901772847203e+39, 5.438080893044959e+40, -2.0623953717959402e+42, 7.821646557419368e+43, -2.966364049581635e+45, 1.1249953075805503e+47, -4.266551309697657e+48, 1.6180920894178406e+50, -6.136623750159777e+51, 2.3273181605240858e+53, -8.826367789232948e+54, 3.3474051666947687e+56, -1.269505374983769e+58, 4.81460658885228e+59, -1.8259423758419422e+61, 6.9248971818694355e+62, -2.626271322354932e+64]
|
||||
```
|
||||
|
||||
## 7 Завершение работы
|
||||
57
TEMA7/task.md
Обычный файл
57
TEMA7/task.md
Обычный файл
@@ -0,0 +1,57 @@
|
||||
# Общее контрольное задание по теме 7
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
|
||||
2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
|
||||
3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х, Y=b1+b2*X и имеющую аргументы b1, b2 и X.
|
||||
|
||||
## Выполнение
|
||||
|
||||
1.
|
||||
|
||||
```
|
||||
in_signal=[math.sin(i*math.pi/3+2) for i in range(20)]
|
||||
in_signal
|
||||
[0.9092974268256817, 0.0942549812584854, -0.8150424455671963, -0.9092974268256817, -0.09425498125848553, 0.8150424455671966, 0.9092974268256818, 0.09425498125848654, -0.8150424455671961, -0.9092974268256818, -0.09425498125848489, 0.8150424455671961, 0.9092974268256819, 0.09425498125848501, -0.815042445567195, -0.9092974268256835, -0.0942549812584869, 0.815042445567197, 0.909297426825682, 0.09425498125848703]
|
||||
def zader(s, T):
|
||||
"""Функция преобразования входного сигнала s в выходной с заданной задержкой T"""
|
||||
s_out=[]
|
||||
for i in range(len(s)+T):
|
||||
if i<T:
|
||||
s_out.append(0)
|
||||
else:
|
||||
s_out.append(s[i-T])
|
||||
return s_out
|
||||
|
||||
out_signal=zader(in_signal, 5); out_signal
|
||||
[0, 0, 0, 0, 0, 0.9092974268256817, 0.0942549812584854, -0.8150424455671963, -0.9092974268256817, -0.09425498125848553, 0.8150424455671966, 0.9092974268256818, 0.09425498125848654, -0.8150424455671961, -0.9092974268256818, -0.09425498125848489, 0.8150424455671961, 0.9092974268256819, 0.09425498125848501, -0.815042445567195, -0.9092974268256835, -0.0942549812584869, 0.815042445567197, 0.909297426825682, 0.09425498125848703]
|
||||
```
|
||||
|
||||
2.
|
||||
|
||||
```
|
||||
def hist(X, n_bin):
|
||||
"""Функция, строящая гистограмму для выборки X с количеством интервалов n_bin
|
||||
Возвращает число элементов в каждом интервале"""
|
||||
pylab.hist(X, n_bin)
|
||||
pylab.show()
|
||||
|
||||
|
||||
import pylab
|
||||
import random
|
||||
x=[random.gauss(0, 1) for _ in range(100)]
|
||||
hist(x, 10)
|
||||
```
|
||||
|
||||
|
||||
|
||||
3.
|
||||
|
||||
```
|
||||
Y= lambda b1,b2,X: b1+b2*X
|
||||
Y(2, 6, 15)
|
||||
92
|
||||
```
|
||||
37
TEMA7/test.md
Обычный файл
37
TEMA7/test.md
Обычный файл
@@ -0,0 +1,37 @@
|
||||
# ИКЗ по теме 7, вариант 15
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
Разработайте функцию, которая получает символьную строку с текстом на русском языке (аргумент функции),
|
||||
создаёт на её основе подстроку, содержащую только согласные буквы,
|
||||
отображает её на экране и записывает ее в файл с заданным именем (аргумент функции).
|
||||
Проверьте функцию на примере строки, запрашиваемой у пользователя.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
def strsogl(strr, file):
|
||||
res=''
|
||||
sogl='бвгджзйклмнпрстфхцчшщ'
|
||||
for letter in strr.lower():
|
||||
if letter in sogl:
|
||||
res=res+letter
|
||||
print(res)
|
||||
fp=open(file, 'w')
|
||||
fp.write(res)
|
||||
fp.close()
|
||||
|
||||
stroka=input('Введите строку: ')
|
||||
Введите строку: Я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство
|
||||
file='test.txt'
|
||||
strsogl(stroka, file)
|
||||
влкймгчйншвждсмчмщтмзхвтлбднлфсскцрств
|
||||
```
|
||||
|
||||
Содержимое файла test.txt:
|
||||
|
||||
```
|
||||
влкймгчйншвждсмчмщтмзхвтлбднлфсскцрств
|
||||
```
|
||||
2
TEMA8/MM0.py
Обычный файл
2
TEMA8/MM0.py
Обычный файл
@@ -0,0 +1,2 @@
|
||||
import MM2
|
||||
print('y=',MM2.vyhod)
|
||||
19
TEMA8/MM1.py
Обычный файл
19
TEMA8/MM1.py
Обычный файл
@@ -0,0 +1,19 @@
|
||||
def realdvig(xtt,kk1,TT,yti1,ytin1):
|
||||
yp=kk1*xtt
|
||||
yti1=yp+yti1
|
||||
ytin1=(yti1+TT*ytin1)/(TT+1)
|
||||
return [yti1,ytin1]
|
||||
|
||||
def tahogen(xtt,kk2,yti2):
|
||||
yp=kk2*xtt
|
||||
yti2=yp+yti2
|
||||
return yti2
|
||||
|
||||
def nechus(xtt,gran):
|
||||
if xtt<gran and xtt>(-gran):
|
||||
ytt=0
|
||||
elif xtt>=gran:
|
||||
ytt=xtt-gran
|
||||
elif xtt<=(-gran):
|
||||
ytt=xtt+gran
|
||||
return ytt
|
||||
23
TEMA8/MM2.py
Обычный файл
23
TEMA8/MM2.py
Обычный файл
@@ -0,0 +1,23 @@
|
||||
znach=input('k1,T,k2,Xm,A,F,N=').split(',')
|
||||
k1=float(znach[0])
|
||||
T=float(znach[1])
|
||||
k2=float(znach[2])
|
||||
Xm=float(znach[3])
|
||||
A=float(znach[4])
|
||||
F=float(znach[5])
|
||||
N=int(znach[6])
|
||||
|
||||
import math
|
||||
vhod=[]
|
||||
for i in range(N):
|
||||
vhod.append(A*math.sin((2*i*math.pi)/F))
|
||||
|
||||
import MM1 as mod
|
||||
yi1=0;yin1=0;yi2=0
|
||||
vyhod=[]
|
||||
for xt in vhod:
|
||||
xt1=xt-yi2
|
||||
[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
|
||||
yi2=mod.tahogen(yin1,k2,yi2)
|
||||
yt=mod.nechus(yin1,Xm)
|
||||
vyhod.append(yt)
|
||||
307
TEMA8/report.md
Обычный файл
307
TEMA8/report.md
Обычный файл
@@ -0,0 +1,307 @@
|
||||
# Отчет по теме 8
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск IDLE
|
||||
|
||||
```
|
||||
import os, sys, importlib
|
||||
os.chdir('C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8')
|
||||
os.getcwd()
|
||||
'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8'
|
||||
```
|
||||
|
||||
## 2 Создание и использование модулей в среде Python
|
||||
|
||||
### 2.1 Запуск модуля на выполнение путем его импорта
|
||||
|
||||
В данном пункте используется модуль [Mod1](Mod1.py)
|
||||
|
||||
```
|
||||
import Mod1
|
||||
Mod1:Введите значение = 5
|
||||
Mod1:Значение perm1= 5
|
||||
type(Mod1)
|
||||
<class 'module'>
|
||||
dir(Mod1)
|
||||
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
|
||||
Mod1.perm1
|
||||
'5'
|
||||
import Mod1
|
||||
importlib.reload(Mod1)
|
||||
Mod1:Введите значение = 3
|
||||
Mod1:Значение perm1= 3
|
||||
<module 'Mod1' from 'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
|
||||
Mod1.perm1
|
||||
'3'
|
||||
```
|
||||
|
||||
### 2.2 Значение атрибута sys.modules
|
||||
|
||||
```
|
||||
print(sorted(sys.modules.keys()))
|
||||
['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
sys.modules.pop('Mod1')
|
||||
<module 'Mod1' from 'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
|
||||
print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
import Mod1
|
||||
Mod1:Введите значение = 8
|
||||
Mod1:Значение perm1= 8
|
||||
sys.modules.pop('Mod1')
|
||||
<module 'Mod1' from 'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
|
||||
```
|
||||
|
||||
### 2.3 Запуск модуля на выполнение с помощью функции exec()
|
||||
|
||||
```
|
||||
exec(open('Mod1.py', encoding='utf-8').read())
|
||||
Mod1:Введите значение = 6
|
||||
Mod1:Значение perm1= 6
|
||||
perm1
|
||||
'6'
|
||||
exec(open('Mod1.py', encoding='utf-8').read())
|
||||
Mod1:Введите значение = 7
|
||||
Mod1:Значение perm1= 7
|
||||
perm1
|
||||
'7'
|
||||
exec(open('Mod1.py', encoding='utf-8').read())
|
||||
Mod1:Введите значение = 2
|
||||
Mod1:Значение perm1= 2
|
||||
perm1
|
||||
'2'
|
||||
```
|
||||
|
||||
### 2.4 Использование инструкции from … import …
|
||||
|
||||
```
|
||||
from Mod1 import perm1
|
||||
Mod1:Введите значение = 0
|
||||
Mod1:Значение perm1= 0
|
||||
perm1
|
||||
'0'
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'importlib', 'os', 'perm1', 'sys']
|
||||
print(sorted(sys.modules.keys()))
|
||||
['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
```
|
||||
|
||||
Как видно, в памяти объекта Mod1 нет, но в sys.modules.keys() появился. Кроме того, в рабочем пространстве появился объект perm1, импортированный из модуля, поэтому к нему можно обращаться про по имени perm1.
|
||||
Далее используется модуль [Mod2](Mod2.py)
|
||||
|
||||
```
|
||||
from Mod2 import beta
|
||||
g=beta(2)
|
||||
****BETA****
|
||||
g
|
||||
535.4916555247646
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
|
||||
print(sorted(sys.modules.keys()))
|
||||
['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
alpha()
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#12>", line 1, in <module>
|
||||
alpha()
|
||||
NameError: name 'alpha' is not defined
|
||||
from Mod2 import alpha as al
|
||||
al()
|
||||
****ALPHA****
|
||||
Значение t=9
|
||||
'9'
|
||||
del al,beta
|
||||
from Mod2 import alpha as al, beta as bt
|
||||
del al,bt
|
||||
from Mod2 import *
|
||||
tt=alpha()
|
||||
****ALPHA****
|
||||
Значение t=12
|
||||
uu=beta(float(tt)); uu
|
||||
****BETA****
|
||||
2.357850396855819e+16
|
||||
```
|
||||
|
||||
## 3 Создание многомодульных программ
|
||||
|
||||
### 3.1 Простая многомодульная программа
|
||||
|
||||
В данном пункте используется модуль [Mod0](Mod0.py)
|
||||
|
||||
```
|
||||
sys.modules.pop('Mod1', 'Mod2')
|
||||
<module 'Mod1' from 'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
|
||||
sys.modules.pop('Mod2')
|
||||
<module 'Mod2' from 'C:\\Users\\Necroa\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod2.py'>
|
||||
print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
import Mod0
|
||||
Mod1:Введите значение = 4
|
||||
Mod1:Значение perm1= 4
|
||||
perm1= 4
|
||||
****ALPHA****
|
||||
Значение t=13
|
||||
tt= 13
|
||||
****BETA****
|
||||
qq= 5.456229130771732e+17
|
||||
Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
|
||||
'13'
|
||||
5.456229130771732e+17
|
||||
'4'
|
||||
```
|
||||
|
||||
### 3.2 Еще один пример
|
||||
|
||||
Были созданы модули [MM0](MM0.py), [MM1](MM1.py), [MM2](MM2.py)
|
||||
|
||||
```
|
||||
import MM0
|
||||
k1,T,k2,Xm,A,F,N=15,10,30,0.2,5,0.001,50
|
||||
y= [0, 0, 0, 0, 0, 0, 0, 0, 0.28235063576021646, -18.09317618367068, 693.569780896497, -26311.05967697136, 997855.8681822185, -37843749.77748839, 1435226439.7890663, -54431047009.38599, 2064300653896.8462, -78288723509751.45, 2969104436030480.0, -1.126034600750363e+17, 4.2704928351466476e+18, -1.6195869152587386e+20, 6.142292885938634e+21, -2.3294681835969964e+23, 8.834521764361373e+24, -3.3504975665500395e+26, 1.2706781694446622e+28, -4.8190544187315804e+29, 1.8276292179353242e+31, -6.931294540413311e+32, 2.62869752433907e+34, -9.969350796127492e+35, 3.780882143191306e+37, -1.433901772847203e+39, 5.438080893044959e+40, -2.0623953717959402e+42, 7.821646557419368e+43, -2.966364049581635e+45, 1.1249953075805503e+47, -4.266551309697657e+48, 1.6180920894178406e+50, -6.136623750159777e+51, 2.3273181605240858e+53, -8.826367789232948e+54, 3.3474051666947687e+56, -1.269505374983769e+58, 4.81460658885228e+59, -1.8259423758419422e+61, 6.9248971818694355e+62, -2.626271322354932e+64]
|
||||
```
|
||||
|
||||
### 3.3 Области дейтсвия объектов в модулях
|
||||
|
||||
Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
|
||||
|
||||
```
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
beta(t)
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
print('****BETA****')
|
||||
import math
|
||||
expi=q*math.pi
|
||||
return math.exp(expi)
|
||||
```
|
||||
|
||||
```
|
||||
Mod1:Введите значение = 8
|
||||
Mod1:Значение perm1= 8
|
||||
perm1= 8
|
||||
****ALPHA****
|
||||
Значение t=6
|
||||
tt= 6
|
||||
****BETA****
|
||||
qq= 153552935.39544657
|
||||
```
|
||||
|
||||
```
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
print('****BETA****')
|
||||
import math
|
||||
expi=alpha()*math.pi
|
||||
return math.exp(expi)
|
||||
```
|
||||
|
||||
```
|
||||
Mod1:Введите значение = 5
|
||||
Mod1:Значение perm1= 5
|
||||
perm1= 5
|
||||
****ALPHA****
|
||||
Значение t=8
|
||||
tt= 8
|
||||
****BETA****
|
||||
qq= 82226315585.59491
|
||||
```
|
||||
|
||||
Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
|
||||
Из-за того, что функция alpha() возвращает t, проблем с её отображением нет.
|
||||
А вот expi напрямую вывести нельзя, потому как это локальная переменная функции beta() и она не возвращается данной функцией.
|
||||
Т.к. возвращаемая переменная qq содержит expi в показателе степени экспоненты, то один из путей решения - проделать обратную операцию (взять натуральный логарифм от qq)
|
||||
|
||||
```
|
||||
Mod1:Введите значение = 5
|
||||
Mod1:Значение perm1= 5
|
||||
perm1= 5
|
||||
****ALPHA****
|
||||
Значение t=1
|
||||
t= 1
|
||||
****BETA****
|
||||
Traceback (most recent call last):
|
||||
File "C:/Users/Necroa/Desktop/ПОАС/python-labs/TEMA8/Mod0_copy.py", line 9, in <module>
|
||||
print('expi=', Mod2.expi)
|
||||
NameError: name 'Mod2' is not defined. Did you mean: 'Mod1'?
|
||||
```
|
||||
|
||||
```
|
||||
#Модуль Mod0
|
||||
import Mod1, math
|
||||
print('perm1=',Mod1.perm1)
|
||||
from Mod2 import alpha as al
|
||||
tt=al()
|
||||
print('t=',tt)
|
||||
from Mod2 import beta
|
||||
qq=beta(float(tt))
|
||||
print('expi=', math.log(qq))
|
||||
```
|
||||
|
||||
```
|
||||
Mod1:Введите значение = 6
|
||||
Mod1:Значение perm1= 6
|
||||
perm1= 6
|
||||
****ALPHA****
|
||||
Значение t=1
|
||||
t= 1
|
||||
****BETA****
|
||||
expi= 3.141592653589793
|
||||
```
|
||||
|
||||
Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
|
||||
Т.к. perm1 имеет строковый тип, то без приведения к целочисленному типу при умножении будет повторение введённого значения 3 раза.
|
||||
|
||||
```
|
||||
#Модуль Mod0
|
||||
import Mod1, math
|
||||
print('perm1=',Mod1.perm1)
|
||||
print('3*perm1=', 3*Mod1.perm1)
|
||||
```
|
||||
|
||||
```
|
||||
Mod1:Введите значение = 2
|
||||
Mod1:Значение perm1= 2
|
||||
perm1= 2
|
||||
3*perm1= 222
|
||||
```
|
||||
|
||||
```
|
||||
#Модуль Mod0
|
||||
import Mod1, math
|
||||
print('perm1=',Mod1.perm1)
|
||||
print('3*perm1=', 3*int(Mod1.perm1))
|
||||
```
|
||||
|
||||
```
|
||||
Mod1:Введите значение = 2
|
||||
Mod1:Значение perm1= 2
|
||||
perm1= 2
|
||||
3*perm1= 6
|
||||
```
|
||||
|
||||
Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
|
||||
Из-за того, что perm1 и tt представлены изначально в строковом виде, то ситуация будет такой же, как и ранее. При необходимости их можно предварительно перевести в целочисленный тип
|
||||
|
||||
```
|
||||
import Mod0
|
||||
Mod1:Введите значение = 1
|
||||
Mod1:Значение perm1= 1
|
||||
perm1= 1
|
||||
****ALPHA****
|
||||
Значение t=1
|
||||
tt= 1
|
||||
****BETA****
|
||||
qq= 23.140692632779267
|
||||
Mod0.Mod1.perm1*2
|
||||
'11'
|
||||
Mod0.tt*2
|
||||
'11'
|
||||
Mod0.qq*2
|
||||
46.281385265558534
|
||||
```
|
||||
78
TEMA8/task.md
Обычный файл
78
TEMA8/task.md
Обычный файл
@@ -0,0 +1,78 @@
|
||||
# Общее контрольное задание по теме 8
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
Разработайте программу, состоящую из трех модулей:
|
||||
1) Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла).
|
||||
Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными.
|
||||
Полученный список должен возвращаться в вызывающую программу.
|
||||
2) Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков).
|
||||
Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
|
||||
3) Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов.
|
||||
Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
|
||||
Подготовьте два текстовых файла с числовыми данными и проверьте по ним работу программы.
|
||||
|
||||
## Выполнение
|
||||
|
||||
Текст модуля [task1](task1.py)
|
||||
|
||||
```
|
||||
def reading(file_n):
|
||||
numbers = []
|
||||
fp=open(file_n)
|
||||
for line in fp:
|
||||
numbers.extend(map(float, line.split()))
|
||||
fp.close()
|
||||
return numbers
|
||||
```
|
||||
|
||||
Текст модуля [task2](task2.py)
|
||||
|
||||
```
|
||||
import statistics
|
||||
|
||||
def corr(list1, list2):
|
||||
n=min(len(list1), len(list2))
|
||||
list1=list1[:n]
|
||||
list2=list2[:n]
|
||||
coeff=statistics.correlation(list1, list2)
|
||||
return coeff
|
||||
```
|
||||
|
||||
Текст модуля [task3](task3.py)
|
||||
|
||||
```
|
||||
import task1, task2
|
||||
|
||||
file1=input('Введите название первого текстового файла ')
|
||||
file2=input('Введите название второго текстового файла ')
|
||||
x1=task1.reading(file1)
|
||||
x2=task1.reading(file2)
|
||||
print('Полученный список 1: ', x1, '\nПолученный список 2: ', x2)
|
||||
print('Коэффициент корреляции: ', round(task2.corr(x1, x2), 3))
|
||||
```
|
||||
|
||||
Содержимое текстового файла spis1.txt:
|
||||
|
||||
```
|
||||
1 7 -2 -5 4 10 -2
|
||||
```
|
||||
|
||||
Содержимое текстового файла spis2.txt:
|
||||
|
||||
```
|
||||
0 0 1 2
|
||||
```
|
||||
|
||||
Выполнение:
|
||||
|
||||
```
|
||||
import task3
|
||||
Введите название первого текстового файла spis1.txt
|
||||
Введите название второго текстового файла spis2.txt
|
||||
Полученный список 1: [1.0, 7.0, -2.0, -5.0, 4.0, 10.0, -2.0]
|
||||
Полученный список 2: [0.0, 0.0, 1.0, 2.0]
|
||||
Коэффициент корреляции: -0.866
|
||||
```
|
||||
10
TEMA8/task1.py
Обычный файл
10
TEMA8/task1.py
Обычный файл
@@ -0,0 +1,10 @@
|
||||
def reading(file_n):
|
||||
numbers = []
|
||||
fp=open(file_n)
|
||||
for line in fp:
|
||||
numbers.extend(map(float, line.split()))
|
||||
fp.close()
|
||||
return numbers
|
||||
|
||||
|
||||
|
||||
8
TEMA8/task2.py
Обычный файл
8
TEMA8/task2.py
Обычный файл
@@ -0,0 +1,8 @@
|
||||
import statistics
|
||||
|
||||
def corr(list1, list2):
|
||||
n=min(len(list1), len(list2))
|
||||
list1=list1[:n]
|
||||
list2=list2[:n]
|
||||
coeff=statistics.correlation(list1, list2)
|
||||
return coeff
|
||||
8
TEMA8/task3.py
Обычный файл
8
TEMA8/task3.py
Обычный файл
@@ -0,0 +1,8 @@
|
||||
import task1, task2
|
||||
|
||||
file1=input('Введите название первого текстового файла ')
|
||||
file2=input('Введите название второго текстового файла ')
|
||||
x1=task1.reading(file1)
|
||||
x2=task1.reading(file2)
|
||||
print('Полученный список 1: ', x1, '\nПолученный список 2: ', x2)
|
||||
print('Коэффициент корреляции: ', round(task2.corr(x1, x2), 3))
|
||||
165
TEMA8/test.md
Обычный файл
165
TEMA8/test.md
Обычный файл
@@ -0,0 +1,165 @@
|
||||
# ИКЗ по теме 8, вариант 9
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7,
|
||||
разработайте функцию, на ее основе создайте модуль.
|
||||
Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
|
||||
|
||||
Разработайте функцию с 3 параметрами: х, yT и T, реализующую расчет по значениям последовательности значений входного сигнала х значений выходного сигнала по формуле:
|
||||
y= (x+T*yТ)/(T+1). Здесь х- одно текущее значение входного сигнала, yT – значение выходного сигнала в предыдущий момент времени, Т – постоянная времени инерционного звена.
|
||||
Создайте список с последовательностью из 100 значений входного синусоидального сигнала с амплитудой 2, периодом 7 и фазой 0.35.
|
||||
Рассчитайте последовательность значений выходных сигналов, принимая Т=3 и yT равным предыдущему в последовательности вычисленных значений y
|
||||
(для первого значения х принять yT=0). Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
|
||||
|
||||
## Выполнение
|
||||
|
||||
Содержимое модуля [test1](test1.py)
|
||||
|
||||
```
|
||||
def signal(x, yT, T):
|
||||
Y=[]
|
||||
fp=open('testt.txt', 'w')
|
||||
fp.write('Xi\tYi\n')
|
||||
for ins in x:
|
||||
outs=(ins+T*yT)/(T+1)
|
||||
Y.append(outs)
|
||||
yT=outs
|
||||
fp.write(str(ins)+'\t'+str(outs)+'\n')
|
||||
fp.close
|
||||
return Y
|
||||
```
|
||||
|
||||
Содержимое модуля [test2](test2.py)
|
||||
|
||||
```
|
||||
import math
|
||||
from test1 import signal
|
||||
|
||||
X=[2*math.sin(i/7+0.35) for i in range(100)]
|
||||
print('Значения входного сигнала: \n', X)
|
||||
T=3
|
||||
yT=0
|
||||
Y=signal(X, yT, T)
|
||||
print('Значения выходного сигнала: \n', Y)
|
||||
```
|
||||
|
||||
Результат выполнения
|
||||
|
||||
```
|
||||
import os
|
||||
os.chdir('C:\\Users\\u202-13\\Desktop\\python-labs\\TEMA8')
|
||||
import test2
|
||||
Значения входного сигнала:
|
||||
[0.6857956149109027, 0.9462898296904173, 1.1875048283957854, 1.4045262222906436, 1.5929325305407531, 1.7488852611613968, 1.8692071144536306, 1.9514467156533182, 1.993928557963668, 1.9957871384579535, 1.9569845913853061, 1.8783114596277994, 1.7613705885915596, 1.6085444706693701, 1.4229467055816887, 1.2083585655177917, 0.9691519574658317, 0.7102003522571565, 0.4367794950101486, 0.1544599198472869, -0.1310065412654169, -0.4138039433467995, -0.6881707194341071, -0.9485170637471333, -1.1895388154794926, -1.4063255230079892, -1.5944604868761643, -1.7501107433283989, -1.8701051551168981, -1.9519990186001612, -1.9941238708615385, -1.9956214821036073, -1.9564613407750173, -1.8774412751969445, -1.7601711990244597, -1.6070403117043117, -1.4211684221699186, -1.206342387479247, -0.9669389613616545, -0.7078356245172404, -0.4343112133656951, -0.15193837178280983, 0.13352998304311092, 0.4162778675493755, 0.6905447236185105, 0.9507427811887152, 1.191570900570458, 1.4081225751051951, 1.595985893776254, 1.7513334271857646, 1.871000205607518, 1.9525482004315637, 1.9943159952891567, 1.9954526348844288, 1.955934961914334, 1.8765680888634773, 1.7589689950617298, 1.6055335831896365, 1.4193878664052093, 1.2043242805801755, 0.964724419186966, 0.7054697649956605, 0.4318422372867545, 0.14941658077906955, -0.13605321131532275, -0.4187511261515769, -0.692917623668242, -0.9529669784563898, -1.1936010804195147, -1.4099173757088976, -1.5975087488020008, -1.7525533107785047, -1.8718922644943639, -1.9530942602694217, -1.9945049309393286, -1.995280597070394, -1.9554054556449019, -1.8756919020235652, -1.7577639786256143, -1.6040242875345, -1.4176050411345522, -1.2023042480473982, -0.9625083344826699, -0.7031027774752642, -0.42937257072105733, -0.14689455086824513, 0.13857622204758316, 0.4212237151988264, 0.6952894157891905, 0.9551896519938152, 1.1956293517805443, 1.4117099219493288, 1.5990290495184591, 1.7537703921561092, 1.8727813303510932, 1.9536371972406208, 1.9946906775099587, 1.9951053689365787, 1.9548728228133652, 1.8748127160781716]
|
||||
Значения выходного сигнала:
|
||||
[0.17144890372772567, 0.3651591352183986, 0.5707455585127453, 0.7791907244572198, 0.9826261759781032, 1.1741909472739267, 1.3479449890688526, 1.498820420714969, 1.6225974550271438, 1.7158948758848462, 1.7761673047599613, 1.801703343476921, 1.7916201547555806, 1.745851233734028, 1.6651251016959432, 1.5509334676514053, 1.405488090105012, 1.2316661556430482, 1.0329444904848233, 0.8133233478254392, 0.5772408755527252, 0.329479670827844, 0.07506707326235623, -0.18082896099001616, -0.43300642461238525, -0.6763361992112862, -0.9058672711275058, -1.116928139177729, -1.3052223931625213, -1.4669165495219314, -1.5987183798568332, -1.6979441554185268, -1.7625734517576495, -1.7912904076174732, -1.7835106054692198, -1.739393032027993, -1.6598368795634744, -1.5464632565424175, -1.4015821827472266, -1.2281455431897301, -1.0296869607337213, -0.8102498134959935, -0.5743048643612174, -0.3266591813835692, -0.07235820513304927, 0.18341704144739185, 0.4354555062281584, 0.6786222734474175, 0.9079631785296267, 1.1188057406936611, 1.3068543569221254, 1.468277817799485, 1.5997873621719028, 1.6987036803500344, 1.7630115007411093, 1.7914006477717013, 1.7832927345942085, 1.7388529467430653, 1.6589866766586012, 1.5453210776389947, 1.4001719130259875, 1.2264963760184058, 1.027832841335493, 0.8082287761963871, 0.5721582793184598, 0.3244309279509506, 0.07009379004615243, -0.18567140207948313, -0.437653821664491, -0.6807197101755926, -0.9099169698321946, -1.1205760550687722, -1.3084051074251701, -1.469577395636233, -1.6008092794620068, -1.6994271088641035, -1.7634216955593032, -1.7914892471753685, -1.78305793003793, -1.7382995194120725, -1.6581258998426924, -1.5441704868938688, -1.398754948791069, -1.2248419059621178, -1.0259745721518527, -0.8062045668309509, -0.5700093696113174, -0.3222010984087815, -0.06782846985928853, 0.18792606060398742, 0.43985188339812664, 0.6828163930359272, 0.9118695571565603, 1.1223447659064476, 1.309953907017609, 1.470874729573362, 1.6018287165575111, 1.700147879652278, 1.7638291154425498, 1.7915750156014552]
|
||||
```
|
||||
|
||||
Содержимое файла testt.txt
|
||||
|
||||
```
|
||||
Xi Yi
|
||||
0.6857956149109027 0.17144890372772567
|
||||
0.9462898296904173 0.3651591352183986
|
||||
1.1875048283957854 0.5707455585127453
|
||||
1.4045262222906436 0.7791907244572198
|
||||
1.5929325305407531 0.9826261759781032
|
||||
1.7488852611613968 1.1741909472739267
|
||||
1.8692071144536306 1.3479449890688526
|
||||
1.9514467156533182 1.498820420714969
|
||||
1.993928557963668 1.6225974550271438
|
||||
1.9957871384579535 1.7158948758848462
|
||||
1.9569845913853061 1.7761673047599613
|
||||
1.8783114596277994 1.801703343476921
|
||||
1.7613705885915596 1.7916201547555806
|
||||
1.6085444706693701 1.745851233734028
|
||||
1.4229467055816887 1.6651251016959432
|
||||
1.2083585655177917 1.5509334676514053
|
||||
0.9691519574658317 1.405488090105012
|
||||
0.7102003522571565 1.2316661556430482
|
||||
0.4367794950101486 1.0329444904848233
|
||||
0.1544599198472869 0.8133233478254392
|
||||
-0.1310065412654169 0.5772408755527252
|
||||
-0.4138039433467995 0.329479670827844
|
||||
-0.6881707194341071 0.07506707326235623
|
||||
-0.9485170637471333 -0.18082896099001616
|
||||
-1.1895388154794926 -0.43300642461238525
|
||||
-1.4063255230079892 -0.6763361992112862
|
||||
-1.5944604868761643 -0.9058672711275058
|
||||
-1.7501107433283989 -1.116928139177729
|
||||
-1.8701051551168981 -1.3052223931625213
|
||||
-1.9519990186001612 -1.4669165495219314
|
||||
-1.9941238708615385 -1.5987183798568332
|
||||
-1.9956214821036073 -1.6979441554185268
|
||||
-1.9564613407750173 -1.7625734517576495
|
||||
-1.8774412751969445 -1.7912904076174732
|
||||
-1.7601711990244597 -1.7835106054692198
|
||||
-1.6070403117043117 -1.739393032027993
|
||||
-1.4211684221699186 -1.6598368795634744
|
||||
-1.206342387479247 -1.5464632565424175
|
||||
-0.9669389613616545 -1.4015821827472266
|
||||
-0.7078356245172404 -1.2281455431897301
|
||||
-0.4343112133656951 -1.0296869607337213
|
||||
-0.15193837178280983 -0.8102498134959935
|
||||
0.13352998304311092 -0.5743048643612174
|
||||
0.4162778675493755 -0.3266591813835692
|
||||
0.6905447236185105 -0.07235820513304927
|
||||
0.9507427811887152 0.18341704144739185
|
||||
1.191570900570458 0.4354555062281584
|
||||
1.4081225751051951 0.6786222734474175
|
||||
1.595985893776254 0.9079631785296267
|
||||
1.7513334271857646 1.1188057406936611
|
||||
1.871000205607518 1.3068543569221254
|
||||
1.9525482004315637 1.468277817799485
|
||||
1.9943159952891567 1.5997873621719028
|
||||
1.9954526348844288 1.6987036803500344
|
||||
1.955934961914334 1.7630115007411093
|
||||
1.8765680888634773 1.7914006477717013
|
||||
1.7589689950617298 1.7832927345942085
|
||||
1.6055335831896365 1.7388529467430653
|
||||
1.4193878664052093 1.6589866766586012
|
||||
1.2043242805801755 1.5453210776389947
|
||||
0.964724419186966 1.4001719130259875
|
||||
0.7054697649956605 1.2264963760184058
|
||||
0.4318422372867545 1.027832841335493
|
||||
0.14941658077906955 0.8082287761963871
|
||||
-0.13605321131532275 0.5721582793184598
|
||||
-0.4187511261515769 0.3244309279509506
|
||||
-0.692917623668242 0.07009379004615243
|
||||
-0.9529669784563898 -0.18567140207948313
|
||||
-1.1936010804195147 -0.437653821664491
|
||||
-1.4099173757088976 -0.6807197101755926
|
||||
-1.5975087488020008 -0.9099169698321946
|
||||
-1.7525533107785047 -1.1205760550687722
|
||||
-1.8718922644943639 -1.3084051074251701
|
||||
-1.9530942602694217 -1.469577395636233
|
||||
-1.9945049309393286 -1.6008092794620068
|
||||
-1.995280597070394 -1.6994271088641035
|
||||
-1.9554054556449019 -1.7634216955593032
|
||||
-1.8756919020235652 -1.7914892471753685
|
||||
-1.7577639786256143 -1.78305793003793
|
||||
-1.6040242875345 -1.7382995194120725
|
||||
-1.4176050411345522 -1.6581258998426924
|
||||
-1.2023042480473982 -1.5441704868938688
|
||||
-0.9625083344826699 -1.398754948791069
|
||||
-0.7031027774752642 -1.2248419059621178
|
||||
-0.42937257072105733 -1.0259745721518527
|
||||
-0.14689455086824513 -0.8062045668309509
|
||||
0.13857622204758316 -0.5700093696113174
|
||||
0.4212237151988264 -0.3222010984087815
|
||||
0.6952894157891905 -0.06782846985928853
|
||||
0.9551896519938152 0.18792606060398742
|
||||
1.1956293517805443 0.43985188339812664
|
||||
1.4117099219493288 0.6828163930359272
|
||||
1.5990290495184591 0.9118695571565603
|
||||
1.7537703921561092 1.1223447659064476
|
||||
1.8727813303510932 1.309953907017609
|
||||
1.9536371972406208 1.470874729573362
|
||||
1.9946906775099587 1.6018287165575111
|
||||
1.9951053689365787 1.700147879652278
|
||||
1.9548728228133652 1.7638291154425498
|
||||
1.8748127160781716 1.7915750156014552
|
||||
```
|
||||
13
TEMA8/test1.py
Обычный файл
13
TEMA8/test1.py
Обычный файл
@@ -0,0 +1,13 @@
|
||||
def signal(x, yT, T):
|
||||
Y=[]
|
||||
fp=open('testt.txt', 'w')
|
||||
fp.write('Xi\tYi\n')
|
||||
for ins in x:
|
||||
outs=(ins+T*yT)/(T+1)
|
||||
Y.append(outs)
|
||||
yT=outs
|
||||
fp.write(str(ins)+'\t'+str(outs)+'\n')
|
||||
fp.close
|
||||
return Y
|
||||
|
||||
|
||||
9
TEMA8/test2.py
Обычный файл
9
TEMA8/test2.py
Обычный файл
@@ -0,0 +1,9 @@
|
||||
import math
|
||||
from test1 import signal
|
||||
|
||||
X=[2*math.sin(i/7+0.35) for i in range(100)]
|
||||
print('Значения входного сигнала: \n', X)
|
||||
T=3
|
||||
yT=0
|
||||
Y=signal(X, yT, T)
|
||||
print('Значения выходного сигнала: \n', Y)
|
||||
Ссылка в новой задаче
Block a user