Сравнить коммиты
61 Коммитов
@ -0,0 +1,5 @@
|
||||
#Программа по Теме 1 Ходюк Максим Романович
|
||||
print('Hello')
|
||||
h=input('Your name=')
|
||||
import os
|
||||
os.chdir('D:\\POAS\\Hodyuk\\Tema1\\')
|
||||
@ -0,0 +1,156 @@
|
||||
# Отчёт по Теме 1 Ходюк Максим Романович
|
||||
|
||||
## Пункт 1
|
||||
Создал на рабочем диске в папке со своей фамилией папку Tema1
|
||||
и записал туда файлы из архива Tema1.rar
|
||||
|
||||
## Пункт 2
|
||||
Запустил программу-интерпретатор Python 3.11
|
||||
|
||||
## Пункт 3
|
||||
Ввел инструкцию в диалоговом окне интерпретатора
|
||||
```
|
||||
>>> print('Hello')
|
||||
Hello
|
||||
```
|
||||
|
||||
## Пункт 4
|
||||
Ввёл ещё одну инструкцию и в появившейся строке ввёл своё имя
|
||||
```
|
||||
>>> h=input('Your name=')
|
||||
Your name=Maxim
|
||||
```
|
||||
|
||||
## Пункт 5
|
||||
Завершил работу интерпретатора
|
||||
```
|
||||
>>> exit()
|
||||
```
|
||||
|
||||
## Пункт 6-7
|
||||
Открыл интерактивную графическую оболочку IDLE среды Python и изучил устройство главного командного окна среды
|
||||
|
||||
## Пункт 8
|
||||
Ввёл инструкции настройки рабочего каталога среды
|
||||
```
|
||||
import os
|
||||
os.chdir('L:\III курс\А-1-23\HodyukMR\POAS\\Tema1\\')
|
||||
```
|
||||
## Пункт 9
|
||||
В меню Options Установил шрифт типа Arial CYR, 11 размер, высота начального окна 50 символов, ширина 100 символов, подкраска комментариев - коричневая
|
||||
|
||||
## Пункт 10
|
||||
Открыл текстовый редактор среды и согдал программу [Pr0.py](Pr0.py) следующего содержания
|
||||
```
|
||||
## Программа по Теме 1 Ходюк Максим Романович
|
||||
print('Hello')
|
||||
h=input('Your name=')
|
||||
import os
|
||||
os.chdir('L:\III курс\А-1-23\HodyukMR\POAS\\Tema1\\')
|
||||
```
|
||||
|
||||
При запуске программы с помощью меню Run module получаю следующий вывод
|
||||
```
|
||||
============ RESTART: L:/III курс/А-1-23/HodyukMR/POAS/Tema1/Pr0.py ============
|
||||
Hello
|
||||
Your name=Maxim
|
||||
```
|
||||
Использую другой вариант запуска программы:
|
||||
```
|
||||
import Pr0
|
||||
Hello
|
||||
Your name=Maxim
|
||||
```
|
||||
Также использую третий вариант запуска, с помощью горячей клавиши F5, вывод получаю такой же, как при первом варианте запуска
|
||||
|
||||
## Пункт 11
|
||||
Запускаю на выполнение программу из файла [prb1.py](prb1.py)
|
||||
```
|
||||
import prb1
|
||||
Как Вас зовут? Максим
|
||||
Привет, Максим
|
||||
```
|
||||
|
||||
## Пункт 12
|
||||
Открыл файл Pr0.cpython-311.рус, внутри находится байт-код - скомпилированная версия исходного кода python
|
||||
Компиляция программ в Python нужна для для преобразования кода на понятном человеку языке в байт-код, который затем выполняется виртуальной машиной Python
|
||||
|
||||
## Пункт 13
|
||||
Скопировал все верно выполненные команды в отдельный файл
|
||||
|
||||
## Пункт 14
|
||||
Изучил раздел помощи Help главного меню
|
||||
Ввёл инструкцию обращения к оперативной помощи по функции print()
|
||||
```
|
||||
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.
|
||||
|
||||
(None, None)
|
||||
```
|
||||
|
||||
Изучил возможность вызова оперативной помощи с помощью функциональной клафиши F1 и с помощью предложения Help главного меню
|
||||
|
||||
## Пункт 15
|
||||
Выбрал предложения File - Open и открыл файл prb1.py и изучил возможность переключения между открытыми окнами используя предложения Window
|
||||
Сделал активным окно prb1.py и запустил на выполнение программу с помощью Run - Run Module
|
||||
```
|
||||
=========== RESTART: L:\III курс\А-1-23\HodyukMR\POAS\Tema1\prb1.py ==========
|
||||
Как Вас зовут? Максим
|
||||
Привет, Максим
|
||||
```
|
||||
|
||||
Открыл Pr0.py и закрыл окна с помощью File - Close
|
||||
|
||||
Используя инструкцию import запустил программу [tdemo_chaos.py](tdemo_chaos.py) на выполнение
|
||||
```
|
||||
import tdemo_chaos
|
||||
```
|
||||
|
||||
Используя предложения Help - Turtle Demo - Examples - Clock запустил программу, которая выводит графическое представление - циферблат часов,
|
||||
на котором можно наблюдать движение стрелок часов
|
||||
В окне демонстраций есть много примеров, которые очень удобны, так как на основе примеров можно изучать графические возможности языка,
|
||||
а так же брать их за основу своих программ либо брать оттуда готовые части кода
|
||||
|
||||
## Пункт 16
|
||||
Завершил работу со средой, используя предложения File - Exit
|
||||
@ -0,0 +1,15 @@
|
||||
# Индивидуальное контрольное задание по Теме 1
|
||||
Ходюк Максим Романович, А-01-23,
|
||||
Вопрос №4
|
||||
## Вопрос
|
||||
Можно ли писать несколько инструкций в одной строке командного окна?
|
||||
|
||||
## Ответ
|
||||
|
||||
Да, в одной строке командного окна можно писать несколько инструкций, разграничивая их с помощью знака ;
|
||||
Например:
|
||||
```
|
||||
>>> a=13;b=15;c=14
|
||||
>>> print(a,b,c)
|
||||
13 15 14
|
||||
```
|
||||
@ -0,0 +1,13 @@
|
||||
familia = 'Hodyuk'
|
||||
first=familia[0]
|
||||
import keyword
|
||||
sp_kw=keyword.kwlist
|
||||
sp_kw.remove('nonlocal')
|
||||
print(sp_kw)
|
||||
kort_nam=("Максим","Дима","Даня","Саня")
|
||||
type(kort_nam)
|
||||
kort_nam=kort_nam+("Лиза","Паша")
|
||||
kort_nam.count("Дима")
|
||||
dict_bas=dict(zip(["Строка","Список","Кортеж"],[familia,sp_kw,kort_nam]))
|
||||
print(dict_bas)
|
||||
print("\nПрограмма выполнена")
|
||||
@ -0,0 +1,771 @@
|
||||
# Отчёт по Теме 2
|
||||
Ходюк Максим Романович, А-01-23
|
||||
|
||||
## Пункт 1
|
||||
Запустил оболочку IDLE
|
||||
|
||||
## Пункт 2
|
||||
Изучил простые объекты
|
||||
Создал переменные f1 f2 и присвоил им значения
|
||||
```
|
||||
f1=16; f2=3
|
||||
```
|
||||
Посмотрел значения созданных переменных двумя способами
|
||||
```
|
||||
f1,f2
|
||||
(16, 3)
|
||||
f1;f2
|
||||
16
|
||||
3
|
||||
```
|
||||
|
||||
Использовал функцию dir, чтобы узнать, какие обьекты существуют в данный момент в среде
|
||||
```
|
||||
dir()
|
||||
['annotations', 'builtins', 'doc', 'loader', 'name', 'package',
|
||||
'spec', 'f1', 'f2']
|
||||
```
|
||||
|
||||
Та же функция используется для получения списка атрибутов любого объекта
|
||||
```
|
||||
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', 'is_integer', 'numerator', 'real', 'to_bytes']
|
||||
```
|
||||
|
||||
Посмотрел классовую принадлежность ранее созданной переменной f2
|
||||
```
|
||||
type(f2)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
Удалил объекты с помощью функции del и убедился, что объектов больше нет в памяти
|
||||
```
|
||||
del f1,f2
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
|
||||
```
|
||||
|
||||
## Пункт 3
|
||||
Изучение правил именования объектов
|
||||
Задал значение в виде вещественного числа:
|
||||
```
|
||||
gg1=1.6
|
||||
```
|
||||
Задал значение в виде символьной строки
|
||||
```
|
||||
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']
|
||||
```
|
||||
Cохранил выведенный список в отдельную переменную
|
||||
```
|
||||
SpisKeyword=keyword.kwlist
|
||||
SpisKeyword
|
||||
['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', 'PythonFinalizationError', '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', '_', '_IncompleteInputError', '__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']
|
||||
```
|
||||
|
||||
Самостоятельно изучил назначение и применил некоторые из встроенных функций
|
||||
```
|
||||
help(abs)
|
||||
Help on built-in function abs in module builtins:
|
||||
|
||||
abs(x, /)
|
||||
Return the absolute value of the argument.
|
||||
|
||||
help(len)
|
||||
Help on built-in function len in module builtins:
|
||||
|
||||
len(obj, /)
|
||||
Return the number of items in a container.
|
||||
|
||||
help(max)
|
||||
Help on built-in function max in module builtins:
|
||||
|
||||
max(...)
|
||||
max(iterable, *[, default=obj, key=func]) -> value
|
||||
max(arg1, arg2, *args, *[, key=func]) -> value
|
||||
|
||||
With a single iterable argument, return its biggest item. The
|
||||
default keyword-only argument specifies an object to return if
|
||||
the provided iterable is empty.
|
||||
With two or more positional arguments, return the largest argument.
|
||||
|
||||
help(min)
|
||||
Help on built-in function min in module builtins:
|
||||
|
||||
min(...)
|
||||
min(iterable, *[, default=obj, key=func]) -> value
|
||||
min(arg1, arg2, *args, *[, key=func]) -> value
|
||||
|
||||
With a single iterable argument, return its smallest item. The
|
||||
default keyword-only argument specifies an object to return if
|
||||
the provided iterable is empty.
|
||||
With two or more positional arguments, return the smallest argument.
|
||||
|
||||
help(pow)
|
||||
Help on built-in function pow in module builtins:
|
||||
|
||||
pow(base, exp, mod=None)
|
||||
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
|
||||
|
||||
Some types, such as ints, are able to use a more efficient algorithm when
|
||||
invoked using the three argument form.
|
||||
|
||||
help(round)
|
||||
Help on built-in function round in module builtins:
|
||||
|
||||
round(number, ndigits=None)
|
||||
Round a number to a given precision in decimal digits.
|
||||
|
||||
The return value is an integer if ndigits is omitted or None. Otherwise
|
||||
the return value has the same type as the number. ndigits may be negative.
|
||||
|
||||
help(sorted)
|
||||
Help on built-in function sorted in module builtins:
|
||||
|
||||
sorted(iterable, /, *, key=None, reverse=False)
|
||||
Return a new list containing all items from the iterable in ascending order.
|
||||
|
||||
A custom key function can be supplied to customize the sort order, and the
|
||||
reverse flag can be set to request the result in descending order.
|
||||
|
||||
help(sum)
|
||||
Help on built-in function sum in module builtins:
|
||||
|
||||
sum(iterable, /, start=0)
|
||||
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
|
||||
|
||||
When the iterable is empty, return the start value.
|
||||
This function is intended specifically for use with numeric values and may
|
||||
reject non-numeric types.
|
||||
|
||||
help(zip)
|
||||
Help on class zip in module builtins:
|
||||
|
||||
class zip(object)
|
||||
| zip(*iterables, strict=False)
|
||||
|
|
||||
| The zip object yields n-length tuples, where n is the number of iterables
|
||||
| passed as positional arguments to zip(). The i-th element in every tuple
|
||||
| comes from the i-th iterable argument to zip(). This continues until the
|
||||
| shortest argument is exhausted.
|
||||
|
|
||||
| If strict is true and one of the arguments is exhausted before the others,
|
||||
| raise a ValueError.
|
||||
|
|
||||
| >>> list(zip('abcdefg', range(3), range(4)))
|
||||
| [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
|
||||
|
|
||||
| Methods defined here:
|
||||
|
|
||||
| __getattribute__(self, name, /)
|
||||
| Return getattr(self, name).
|
||||
|
|
||||
| __iter__(self, /)
|
||||
| Implement iter(self).
|
||||
|
|
||||
| __next__(self, /)
|
||||
| Implement next(self).
|
||||
|
|
||||
| __reduce__(self, /)
|
||||
| Return state information for pickling.
|
||||
|
|
||||
| __setstate__(self, object, /)
|
||||
| Set state information for unpickling.
|
||||
|
|
||||
| ----------------------------------------------------------------------
|
||||
| Static methods defined here:
|
||||
|
|
||||
| __new__(*args, **kwargs)
|
||||
| Create and return a new object. See help(type) for accurate signature.
|
||||
abs(-25)
|
||||
25
|
||||
len(SpisKeyword)
|
||||
35
|
||||
max(24,26,91,12341)
|
||||
12341
|
||||
min(12,-14,241,2)
|
||||
-14
|
||||
pow(2,4)
|
||||
16
|
||||
round(2.4231)
|
||||
2
|
||||
round(2.78)
|
||||
3
|
||||
sorted([1,2,6,3,7,4])
|
||||
[1, 2, 3, 4, 6, 7]
|
||||
sum([1,1,1,1,1])
|
||||
5
|
||||
A=[13,15,2,10]
|
||||
sum(A)
|
||||
40
|
||||
sp1 = ['cat','dog','horse']
|
||||
sp2 = [20,3,14]
|
||||
sp3 = ['home','cabin','stable']
|
||||
zipped = zip(sp1,sp2,sp3)
|
||||
list(zipped)
|
||||
[('cat', 20, 'home'), ('dog', 3, 'cabin'), ('horse', 14, 'stable')]
|
||||
```
|
||||
|
||||
## Пункт 6
|
||||
Убедился, что малые и большие буквы при именовании объектов различаются
|
||||
```
|
||||
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=-1234567890
|
||||
```
|
||||
Экспоненциальная форма записи вещественного числа
|
||||
```
|
||||
ff1=-8.9876e-12
|
||||
```
|
||||
Двоичное число
|
||||
```
|
||||
dv1=0b1101010
|
||||
```
|
||||
Восьмеричное число
|
||||
```
|
||||
vsm1=0o52765
|
||||
```
|
||||
шестнадцатиричное число
|
||||
```
|
||||
shest1=0x7109af6
|
||||
```
|
||||
|
||||
Работа с комплексными числами
|
||||
```
|
||||
cc1=2-3j
|
||||
a=3.67; b=-0.45
|
||||
cc2=complex(a,b)
|
||||
```
|
||||
|
||||
### Пункт 7.3
|
||||
Строка символов
|
||||
|
||||
Создал строку символов, убедился, что строки можно заключать в апотрофы и двойные кавычки
|
||||
```
|
||||
ss1='Это - строка символов'
|
||||
ss1
|
||||
'Это - строка символов'
|
||||
ss1="Это - строка символов"
|
||||
ss1
|
||||
'Это - строка символов'
|
||||
```
|
||||
|
||||
Применил внутри строки экранированные последовательности, создал следующую строку
|
||||
```
|
||||
ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
|
||||
print(ss1a)
|
||||
Это - " строка символов ",
|
||||
выводимая на двух строках
|
||||
```
|
||||
Создал ещё одну строку, выводимую на двух строках
|
||||
```
|
||||
ss1b= 'Меня зовут: \n Ходюк М. Р.'
|
||||
print(ss1b)
|
||||
Меня зовут:
|
||||
Ходюк М. Р.
|
||||
```
|
||||
|
||||
Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек
|
||||
```
|
||||
mnogo="""Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции."""
|
||||
print(mnogo)
|
||||
Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции.
|
||||
```
|
||||
|
||||
Изучил возможность обращения к частям строки по индексам символов начиная с 0
|
||||
```
|
||||
ss1[0]
|
||||
'Э'
|
||||
ss1[0]
|
||||
'Э'
|
||||
ss1[8]
|
||||
'р'
|
||||
ss1[-2]
|
||||
'о'
|
||||
ss1[6:9]
|
||||
'стр'
|
||||
ss1[13:]
|
||||
'символов'
|
||||
ss1[:13]
|
||||
'Это - строка '
|
||||
ss1[5:-8]
|
||||
' строка '
|
||||
ss1[3:17:2]
|
||||
' тоасм'
|
||||
```
|
||||
|
||||
При задании отрицательного шага, результатом выполнения будет часть строки, в которую символы будут взяты в обратной последовательности
|
||||
```
|
||||
ss1[17:3:-2]
|
||||
'омсаот '
|
||||
```
|
||||
Также можно вместо 17 использовать индекс -4, и получить такой же результат
|
||||
```
|
||||
ss1[-4:3:-2]
|
||||
'омсаот '
|
||||
```
|
||||
Убедился, что строка является неизменяемым объектом
|
||||
```
|
||||
ss1[4]='='
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#78>", line 1, in <module>
|
||||
ss1[4]='='
|
||||
TypeError: 'str' object does not support item assignment
|
||||
```
|
||||
Однако строку можно изменить, переопределив её
|
||||
```
|
||||
ss1=ss1[:4]+'='+ss1[5:]
|
||||
ss1
|
||||
'Это = строка символов'
|
||||
```
|
||||
На основе ранее созданной строки ss1b создал обьекты с разными срезами исходной строки
|
||||
```
|
||||
ss1b[:15]
|
||||
'Меня зовут: \n Х'
|
||||
ss1c=ss1b[:3]+'12345'+ss1b[5:]
|
||||
ss1c
|
||||
'Мен12345зовут: \n Ходюк М. Р.'
|
||||
```
|
||||
|
||||
Задал несколько объектов разных типов
|
||||
```
|
||||
Flag = False
|
||||
type(Flag)
|
||||
<class 'bool'>
|
||||
Stroka="СТРОКА"
|
||||
A=453
|
||||
B=4231
|
||||
complex(A,B)
|
||||
(453+4231j)
|
||||
Flag
|
||||
False
|
||||
Stroka
|
||||
'СТРОКА'
|
||||
```
|
||||
|
||||
## Пункт 8
|
||||
Изучение более сложных типов объектов
|
||||
|
||||
### Пункт 8.1
|
||||
Списки
|
||||
|
||||
Создал примеры списков:
|
||||
```
|
||||
spis1=[111,'Spisok',5-9j]
|
||||
spis1
|
||||
[111, 'Spisok', (5-9j)]
|
||||
stup=[0,0,1,1,1,1,1,1,1]
|
||||
stup
|
||||
[0, 0, 1, 1, 1, 1, 1, 1, 1]
|
||||
```
|
||||
|
||||
Попробовал создать список, введя его на нескольких строках
|
||||
```
|
||||
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(spis1)
|
||||
3
|
||||
```
|
||||
Изучил возможность добавления элементов в списки с помощью метода append и с помощью конкатенации
|
||||
```
|
||||
spis1.append('New item')
|
||||
spis1+['New item']
|
||||
[111, 'Список', (5-9j), 'New item', 'New item']
|
||||
```
|
||||
В последней инструкции объект только выводится, но не сохраняется
|
||||
```
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item']
|
||||
```
|
||||
Добавил в конец списка spis1 строку ss1b
|
||||
```
|
||||
spis1.append(ss1b)
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Ходюк М. Р.']
|
||||
```
|
||||
|
||||
Изучил возможность удаления элемента
|
||||
```
|
||||
spis1.pop(1)
|
||||
'Список'
|
||||
spis1
|
||||
[111, (5-9j), 'New item', 'Меня зовут: \n Ходюк М. Р.']
|
||||
```
|
||||
Метод удалил из списка элемент с индексом 1
|
||||
|
||||
Самостоятельно изучил другие методы списков и применил их
|
||||
```
|
||||
help(spis.insert)
|
||||
Help on built-in function insert:
|
||||
|
||||
insert(index, object, /) method of builtins.list instance
|
||||
Insert object before index.
|
||||
|
||||
spis1.insert(3,'home')
|
||||
spis1
|
||||
[111, (5-9j), 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.']
|
||||
|
||||
help(spis.remove)
|
||||
Help on built-in function remove:
|
||||
|
||||
remove(value, /) method of builtins.list instance
|
||||
Remove first occurrence of value.
|
||||
|
||||
Raises ValueError if the value is not present.
|
||||
|
||||
spis23=[1,2,3,1]
|
||||
spis23.remove(1)
|
||||
spis23
|
||||
[2, 3, 1]
|
||||
|
||||
help(spis.extend)
|
||||
Help on built-in function extend:
|
||||
|
||||
extend(iterable, /) method of builtins.list instance
|
||||
Extend list by appending elements from the iterable.
|
||||
|
||||
spis23.extend(spis1)
|
||||
spis23
|
||||
[2, 3, 1, 111, (5-9j), 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.']
|
||||
|
||||
help(spis.clear)
|
||||
Help on built-in function clear:
|
||||
|
||||
clear() method of builtins.list instance
|
||||
Remove all items from list.
|
||||
|
||||
spis24=[1,2,3,4,5]
|
||||
spis24
|
||||
[1, 2, 3, 4, 5]
|
||||
spis24.clear()
|
||||
spis24
|
||||
[]
|
||||
|
||||
spis24=[1,2,8,3,6,4,12,7]
|
||||
spis24.sort()
|
||||
spis24
|
||||
[1, 2, 3, 4, 6, 7, 8, 12]
|
||||
|
||||
spis24.reverse()
|
||||
spis24
|
||||
[12, 8, 7, 6, 4, 3, 2, 1]
|
||||
|
||||
help(spis.copy)
|
||||
Help on built-in function copy:
|
||||
|
||||
copy() method of builtins.list instance
|
||||
Return a shallow copy of the list.
|
||||
|
||||
spis25=spis24.copy()
|
||||
spis25
|
||||
[12, 8, 7, 6, 4, 3, 2, 1]
|
||||
|
||||
help(spis.count)
|
||||
Help on built-in function count:
|
||||
|
||||
count(value, /) method of builtins.list instance
|
||||
Return number of occurrences of value.
|
||||
|
||||
stup
|
||||
[0, 0, 1, 1, 1, 1, 1, 1, 1]
|
||||
stup.count(0)
|
||||
2
|
||||
|
||||
help(spis.index)
|
||||
Help on built-in function index:
|
||||
|
||||
index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
|
||||
Return first index of value.
|
||||
|
||||
Raises ValueError if the value is not present.
|
||||
|
||||
stup.index(1)
|
||||
2
|
||||
```
|
||||
|
||||
Списки могут быть вложенными
|
||||
```
|
||||
spis2=[spis1,[4,5,6,7]]
|
||||
```
|
||||
Обратился к элементам вложенного списка и изменение их
|
||||
```
|
||||
spis2[0][1]
|
||||
(5-9j)
|
||||
spis2[0][1]=78
|
||||
spis2
|
||||
[[111, 78, 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.'], [4, 5, 6, 7]]
|
||||
```
|
||||
При изменении элементов вложенного списка изменяется и сам список, который был вложен в другой
|
||||
```
|
||||
spis1
|
||||
[111, 78, 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.']
|
||||
```
|
||||
Чтобы spis1 не изменялся при изменении spis2, можно создать их следующим образом
|
||||
```
|
||||
spis1 = [13,'A',14,'cat','dog']
|
||||
spis1
|
||||
[13, 'A', 14, 'cat', 'dog']
|
||||
spis2 = [list(spis1),'uuuuu',731]
|
||||
spis2[0][1]
|
||||
'A'
|
||||
spis2[0][1]='C'
|
||||
spis2
|
||||
[[13, 'C', 14, 'cat', 'dog'], 'uuuuu', 731]
|
||||
spis1
|
||||
[13, 'A', 14, 'cat', 'dog']
|
||||
```
|
||||
Создал свой объект список
|
||||
```
|
||||
spisok=[12, 'Strocka', Flag, spis25]
|
||||
spisok
|
||||
[12, 'Strocka', False, [12, 8, 7, 6, 4, 3, 2, 1]]
|
||||
```
|
||||
|
||||
### Пункт 8.2
|
||||
Объект-кортеж
|
||||
Изучил примеры операций с кортежами:
|
||||
Создание:
|
||||
```
|
||||
kort1=(222,'Kortezh',77+8j)
|
||||
```
|
||||
Переопределение(т.к.кортеж является неизменяемым объектом)
|
||||
```
|
||||
kort1= kort1+(1,2)
|
||||
kort1= kort1+(ss1b,)
|
||||
kort1
|
||||
(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Ходюк М. Р.')
|
||||
```
|
||||
|
||||
Переопределил кортеж с удалением комплексного значения
|
||||
```
|
||||
kort2=kort1[:2]+kort1[3:]
|
||||
kort2
|
||||
(222, 'Kortezh', 1, 2, 'Меня зовут: \n Ходюк М. Р.')
|
||||
```
|
||||
Изучил важные методы кортежей
|
||||
Получение индекса заданного элемента(index) и подсчёт числа вхождений заданного элемента(count)
|
||||
```
|
||||
kort1.index(2)
|
||||
4
|
||||
kort1.count(222)
|
||||
1
|
||||
```
|
||||
Попробовал операцию изменения элемента кортежа и убедился в невозможности его изменения
|
||||
```
|
||||
kort1[2]=90
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#174>", line 1, in <module>
|
||||
kort1[2]=90
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
```
|
||||
Самостроятельно создал кортеж:
|
||||
```
|
||||
kortej=(12, 'Strocka', Flag, spis25)
|
||||
kortej
|
||||
(12, 'Strocka', False, [12, 8, 7, 6, 4, 3, 2, 1])
|
||||
```
|
||||
|
||||
### Пункт 8.3
|
||||
Словари
|
||||
Пример создания словаря и обращения к его элементам по ключам
|
||||
```
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
dic1['Orel']
|
||||
56
|
||||
```
|
||||
|
||||
Пример пополнения словаря
|
||||
|
||||
```
|
||||
dic1['Pskov']=78
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
|
||||
```
|
||||
|
||||
Применил методы получения списка ключей и значений в словаре:
|
||||
```
|
||||
dic1.keys()
|
||||
dict_keys(['Saratov', 'Orel', 'Vologda', 'Pskov'])
|
||||
dic1.values()
|
||||
dict_values([145, 56, 45, 78])
|
||||
```
|
||||
|
||||
Применил функцию sorted для получения списков, упорядоченные по ключам/значениям
|
||||
```
|
||||
sorted(dic1.keys())
|
||||
['Orel', 'Pskov', 'Saratov', 'Vologda']
|
||||
sorted(dic1.values())
|
||||
[45, 56, 78, 145]
|
||||
```
|
||||
|
||||
Убедился, что элементы словаря могут быть в том числе и словарями:
|
||||
```
|
||||
dic2={1:'mean',2:'standart deviation',3:'correlation'}
|
||||
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
|
||||
```
|
||||
|
||||
Обращение к элементу вложенного словаря:
|
||||
```
|
||||
dic3['statistics'][2]
|
||||
'standart deviation'
|
||||
```
|
||||
|
||||
Создал более сложный словарь с использованием функции dict
|
||||
```
|
||||
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 Ходюк М. Р.'}
|
||||
```
|
||||
|
||||
Создал ещё один словарь с использованием функций dict и zip
|
||||
```
|
||||
dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
|
||||
dic5
|
||||
{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Ходюк М. Р.'}
|
||||
```
|
||||
|
||||
Создал объект-кортеж с 7 элементами и список с 5 элементами, и попробовал создать из них словарь:
|
||||
```
|
||||
kort801 = (1, 48, 'NICOLAI', '67W', 'Батон', 'name', 1453)
|
||||
spisocek = [1,4553, 'Maxim',4,6]
|
||||
dic6=dict(zip(kort801, spisocek))
|
||||
dic6
|
||||
{1: 1, 48: 4553, 'NICOLAI': 'Maxim', '67W': 4, 'Батон': 6}
|
||||
```
|
||||
Как можно заметить, словарь создался с 5ю элементами, из чего можно сделать вывод, что при неодиноковом количестве задаваемых ключей и значений, словарь создастся с кол-вом
|
||||
элементов, равным меньшему их кол-ву
|
||||
|
||||
Пример словаря с описанием состава студентов, обучающихся на АВТИ:
|
||||
```
|
||||
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={7,'Ronaldo',10,'Messi',18,'Bruno'}
|
||||
mnoz2
|
||||
{18, 7, 'Bruno', 10, 'Ronaldo', 'Messi'}
|
||||
len(mnoz2)
|
||||
6
|
||||
mnoz2.add('Pele')
|
||||
mnoz2
|
||||
{18, 'Pele', 7, 'Bruno', 10, 'Ronaldo', 'Messi'}
|
||||
mnoz2.remove('Messi')
|
||||
mnoz2
|
||||
{18, 'Pele', 7, 'Bruno', 10, 'Ronaldo'}
|
||||
```
|
||||
|
||||
## Пункт 9
|
||||
Закончил сеанс работы с IDLE
|
||||
@ -0,0 +1,68 @@
|
||||
# Общее контрольное задание Тема 2 Ходюк
|
||||
Скрипт для ОКЗ в файле [OKZ.py](OKZ.py)
|
||||
|
||||
## Пункт 1
|
||||
Создал переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
|
||||
```
|
||||
familia = 'Hodyuk'
|
||||
```
|
||||
|
||||
## Пункт 2
|
||||
Создал переменную со значением, совпадающим с первой буквой из строки familia
|
||||
```
|
||||
first=familia[0]
|
||||
first
|
||||
'H'
|
||||
```
|
||||
|
||||
## Пункт 3
|
||||
Создание переменной sp_kw со списком всех ключевых слов языка Python
|
||||
```
|
||||
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']
|
||||
```
|
||||
|
||||
## Пункт 4
|
||||
Удалил из списка sp_kw значение 'nonlocal' и вывел список
|
||||
```
|
||||
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']
|
||||
```
|
||||
|
||||
## Пункт 5
|
||||
Создал кортеж kort_nam с 4 именами: моим, и еще 3-х студентов моей группы
|
||||
```
|
||||
kort_nam=("Максим","Дима","Даня","Саня")
|
||||
```
|
||||
Вывел тип получившегося объекта
|
||||
```
|
||||
type(kort_nam)
|
||||
<class 'tuple'>
|
||||
```
|
||||
|
||||
## Пункт 6
|
||||
Добавил в кортеж из предыдущего пункта ещё 2 имени
|
||||
```
|
||||
kort_nam=kort_nam+("Лиза","Паша")
|
||||
kort_nam
|
||||
('Максим', 'Дима', 'Даня', 'Саня', 'Лиза', 'Паша')
|
||||
```
|
||||
|
||||
## Пункт 7
|
||||
Написал инструкцию для подсчёта количества присутствия имени "Дима" в кортеже
|
||||
```
|
||||
kort_nam.count("Дима")
|
||||
1
|
||||
```
|
||||
|
||||
## Пункт 8
|
||||
Создал словарь, в котором в качестве ключей задал русские названия типов переменных,
|
||||
созданных ранее в ОКЗ, и в качестве значений - переменные этих типов
|
||||
```
|
||||
dict_bas=dict(zip(["Строка","Список","Кортеж"],[familia,sp_kw,kort_nam]))
|
||||
dict_bas
|
||||
{'Строка': 'Hodyuk', 'Список': ['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'], 'Кортеж': ('Максим', 'Дима', 'Даня', 'Саня', 'Лиза', 'Паша')}
|
||||
```
|
||||
@ -0,0 +1,23 @@
|
||||
# Индивидуальное контрольное задание по Теме 2
|
||||
Ходюк Максим Романович, А-01-23
|
||||
|
||||
## Задание
|
||||
Вариант 12
|
||||
Предполагается выполнить инструкцию
|
||||
fg={'a':23,'b':45,'c':-12}
|
||||
К какому классу будет относиться созданный объект? Напишите инструкцию расчета суммы значений первого и третьего элементов.
|
||||
|
||||
## Решение
|
||||
Созданный объект fg будет относиться к классу dict - словарь
|
||||
```
|
||||
fg={'a':23,'b':45,'c':-12}
|
||||
type(fg)
|
||||
<class 'dict'>
|
||||
```
|
||||
|
||||
Инструкция расчёта суммы значений первого и третьего элементов
|
||||
```
|
||||
sum([fg['a'],fg['c']])
|
||||
11
|
||||
```
|
||||
|
||||
@ -0,0 +1,704 @@
|
||||
# Отчёт по теме 3
|
||||
Ходюк Максим Романович, А-01-23
|
||||
|
||||
# 2. Преобразование простых базовых типов объектов
|
||||
## 2.1. Преобразование в логический тип с помощью функции bool(<Объект>).
|
||||
Создал 4 переменные логического типа из объектов других типов:
|
||||
```
|
||||
logiz1=bool(56)
|
||||
logiz2=bool(0)
|
||||
logiz3=bool("Beta")
|
||||
logiz4=bool("")
|
||||
```
|
||||
Результат:
|
||||
```
|
||||
logiz1
|
||||
True
|
||||
logiz2
|
||||
False
|
||||
logiz3
|
||||
True
|
||||
logiz4
|
||||
False
|
||||
```
|
||||
|
||||
## 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]).
|
||||
Попробовал применить примеры использования данной функции:
|
||||
```
|
||||
tt1=int(198.6)
|
||||
tt1
|
||||
198
|
||||
tt2=int("-76")
|
||||
tt2
|
||||
-76
|
||||
tt3=int("B",16)
|
||||
tt3
|
||||
11
|
||||
tt4=int("71",8)
|
||||
tt4
|
||||
57
|
||||
tt5=int("98.76")
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#17>", line 1, in <module>
|
||||
tt5=int("98.76")
|
||||
ValueError: invalid literal for int() with base 10: '98.76'
|
||||
```
|
||||
При применении последней инструкции выдало диагностическое сообщение, потому что функция int при передавании в неё строки ожидает увидеть там целое число, а "98.76" содержит десятичную точку, из-за чего функция int не может её преобразовать
|
||||
|
||||
|
||||
Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).
|
||||
Примеры:
|
||||
flt1=float(789)
|
||||
flt2=float(-6.78e2)
|
||||
flt3=float("Infinity")
|
||||
flt4=float("-inf")
|
||||
flt1
|
||||
789.0
|
||||
flt2
|
||||
-678.0
|
||||
flt3
|
||||
inf
|
||||
flt4
|
||||
-inf
|
||||
|
||||
## 2.3. Преобразование десятичных чисел в другие системы счисления
|
||||
```
|
||||
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})
|
||||
strk5
|
||||
"{'A': 1, 'B': 2, 'C': 9}"
|
||||
```
|
||||
## Преобразование элементов объекта в список с помощью функции 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']
|
||||
```
|
||||
В последней инструкции из словаря в список попали ключи, чтобы создать список значений, применил следующую инструкцию
|
||||
```
|
||||
spis3=list({"A":1,"B":2,"C":9}.values())
|
||||
spis3
|
||||
[1, 2, 9]
|
||||
```
|
||||
|
||||
## 3.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>).
|
||||
Примеры преобразований:
|
||||
```
|
||||
kort7=tuple('Строка символов')
|
||||
kort7
|
||||
('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
|
||||
kort8=tuple(spis2)
|
||||
kort8
|
||||
(23, 12, 78)
|
||||
kort9=tuple({"A":1,"B":2,"C":9})
|
||||
kort9
|
||||
('A', 'B', 'C')
|
||||
```
|
||||
|
||||
## 3.4. Удаление объектов.
|
||||
Удалил объекты и убедился в их отсутствии в оперативной памяти
|
||||
```
|
||||
del strk5, kort8
|
||||
strk5
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#62>", line 1, in <module>
|
||||
strk5
|
||||
NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
|
||||
kort8
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#63>", line 1, in <module>
|
||||
kort8
|
||||
NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
|
||||
```
|
||||
|
||||
Создал строку со своей фамилией и инициалами, преобразовал её в список,затем в кортёж, а затем в строку:
|
||||
```
|
||||
strr="KhoduykMR"
|
||||
lstrr=list(strr)
|
||||
lstrr
|
||||
['K', 'h', 'o', 'd', 'u', 'y', 'k', 'M', 'R']
|
||||
klstrr=tuple(lstrr)
|
||||
klstrr
|
||||
('K', 'h', 'o', 'd', 'u', 'y', 'k', 'M', 'R')
|
||||
strr2=str(klstrr)
|
||||
strr2
|
||||
"('K', 'h', 'o', 'd', 'u', 'y', 'k', 'M', 'R')"
|
||||
```
|
||||
|
||||
# 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
|
||||
```
|
||||
Проверил тип объекта а
|
||||
```
|
||||
type(a)
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
## 4.4. Деление с округлением вниз (//).
|
||||
```
|
||||
b=178//45
|
||||
b
|
||||
3
|
||||
c=-24.6//12.1
|
||||
c
|
||||
-3.0
|
||||
```
|
||||
Попробовал смешанные комбинации типов чисел в этой операции
|
||||
```
|
||||
178//12.1
|
||||
14.0
|
||||
-24.6//15
|
||||
-2.0
|
||||
```
|
||||
|
||||
## 4.5. Получение остатка от деления (%).
|
||||
```
|
||||
148%33
|
||||
16
|
||||
12.6%3.8
|
||||
1.2000000000000002
|
||||
```
|
||||
Попробовал применить в этой операции смешанные типы чисел
|
||||
```
|
||||
148%3.8
|
||||
3.6000000000000068
|
||||
12.6%33
|
||||
12.6
|
||||
12.6%3
|
||||
0.5999999999999996
|
||||
```
|
||||
|
||||
## 4.6. Возведение в степень (**).
|
||||
```
|
||||
14**3
|
||||
2744
|
||||
e=2.7**3.6
|
||||
e
|
||||
35.719843790663525
|
||||
```
|
||||
Попробовал смешанные типы чисел и в операции возведения в степень
|
||||
```
|
||||
14**3.6
|
||||
13367.830445904418
|
||||
2.7**3
|
||||
19.683000000000003
|
||||
```
|
||||
|
||||
Попробовал применить операции, представленные в пункте 4, с участием комплексных чисел
|
||||
```
|
||||
14**(3+8j)
|
||||
(-1751.1118980727824+2112.6152324614004j)
|
||||
(3+8j)*14
|
||||
(42+112j)
|
||||
(3+8j)/(15+883j)
|
||||
(0.009115107563141576-0.0032426652169341747j)
|
||||
(3+8j)//(15+883j)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#98>", line 1, in <module>
|
||||
(3+8j)//(15+883j)
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
|
||||
(3+8j)%(15+883j)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#99>", line 1, in <module>
|
||||
(3+8j)%(15+883j)
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||
```
|
||||
К комплексным числам можно применить все действия, кроме деления с округлением и получения остатка от деления
|
||||
|
||||
# 5. Операции с двоичными представлениями целых чисел.
|
||||
## 5.1. Двоичная инверсия (~).
|
||||
При применении двоичной инверсии значение каждого бита в представлении числа меняется на противоположное:
|
||||
```
|
||||
dv1=9
|
||||
dv2=~dv1
|
||||
dv2
|
||||
-10
|
||||
```
|
||||
|
||||
## 5.2. Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
|
||||
При применении данной команды результат - это число в десятичной системе счисления, которое в двоичной системе счисления представляется как результат побитового совпадения разрядов(то есть 1 в разряде получится только если в этом разряде у обоих сравниваемых чисел стоит 1)
|
||||
```
|
||||
7&9 #111 и 1001 = 0001
|
||||
1
|
||||
7&8 #111 и 1000 = 0000
|
||||
0
|
||||
```
|
||||
|
||||
## 5.3. Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел
|
||||
Результат также как в предыдущем случае десятичное число, но на этот раз в двоичном представлении у числа будет 0 только если у обоих сравниваемых чисел в этом разряде 0
|
||||
```
|
||||
7|9
|
||||
15
|
||||
7|8
|
||||
15
|
||||
14|5
|
||||
15
|
||||
```
|
||||
|
||||
## 5.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел
|
||||
В данной операции получаем 0, если оба сравниваемых разряда имеют одинаковые значения
|
||||
```
|
||||
14^5
|
||||
11
|
||||
```
|
||||
|
||||
## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
|
||||
Применение:
|
||||
```
|
||||
h=14
|
||||
g=h<<2
|
||||
g1=h>>1
|
||||
g2=h>>2
|
||||
g
|
||||
56
|
||||
g1
|
||||
7
|
||||
g2
|
||||
3
|
||||
```
|
||||
Создал двоичное число с 11 знаками и попробовал к нему применить различные операции
|
||||
```
|
||||
hh=1924 #11110000100
|
||||
gg=hh<<5
|
||||
gg
|
||||
61568
|
||||
gg1=hh>>6
|
||||
gg1
|
||||
30
|
||||
```
|
||||
|
||||
# 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
|
||||
('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
|
||||
```
|
||||
Применил примеры: Создание списка со 100 отсчётами сигнала-ступеньки
|
||||
```
|
||||
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='Система автоматического управления'
|
||||
stroka
|
||||
'Система автоматического управления'
|
||||
'автомат' in stroka
|
||||
True
|
||||
'ку' in ['ку','-']*3
|
||||
True
|
||||
'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
False
|
||||
```
|
||||
|
||||
## 6.4. Подстановка значений в строку с помощью оператора «%»
|
||||
Применил пример 1:
|
||||
```
|
||||
stroka='Температура = %g %s %g'
|
||||
stroka
|
||||
'Температура = %g %s %g'
|
||||
stroka % (16,' меньше ',25)
|
||||
'Температура = 16 меньше 25'
|
||||
```
|
||||
Применил пример 2:
|
||||
```
|
||||
stroka='Температура = %(zn1)g %(sravn)s %(zn2)g'
|
||||
stroka
|
||||
'Температура = %(zn1)g %(sravn)s %(zn2)g'
|
||||
stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
|
||||
'Температура = 16 меньше 25'
|
||||
```
|
||||
|
||||
# 7.Оператор присваивания
|
||||
## 7.1. Обычное присваивание значения переменной (=)
|
||||
```
|
||||
zz=-12
|
||||
zz
|
||||
-12
|
||||
```
|
||||
## 7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=)
|
||||
```
|
||||
zz+=5
|
||||
zz
|
||||
-7
|
||||
zz-=3
|
||||
zz
|
||||
-10
|
||||
```
|
||||
Проверил работу сочетания знаков (+=) на строках
|
||||
```
|
||||
stroka='Система'
|
||||
stroka
|
||||
'Система'
|
||||
stroka+=' регулирования'
|
||||
stroka
|
||||
'Система регулирования'
|
||||
```
|
||||
Для строк эта операция означает конкатенацию текущего значения с заданным дополнением
|
||||
|
||||
## 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
|
||||
```
|
||||
zz/=2
|
||||
zz
|
||||
-5.0
|
||||
zz*=5
|
||||
zz
|
||||
-25.0
|
||||
```
|
||||
Попробовал данную операцию на строке: она означает повторение текущего значения заданное количество раз
|
||||
```
|
||||
stroka*=2
|
||||
stroka
|
||||
'Система регулированияСистема регулирования'
|
||||
```
|
||||
|
||||
## 7.4. Самостоятельное изучение операций (//=), (%=), (**=)
|
||||
```
|
||||
zz//=2
|
||||
zz
|
||||
-13.0
|
||||
zz%=3
|
||||
zz
|
||||
2.0
|
||||
zz**=4
|
||||
zz
|
||||
16.0
|
||||
```
|
||||
|
||||
## 7.5. Множественное присваивание
|
||||
```
|
||||
w=v=10
|
||||
w;v
|
||||
10
|
||||
10
|
||||
n1,n2,n3=(11,-3,'all')
|
||||
n1;n2;n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
```
|
||||
Самостоятельно проверил,можно ли вместо кортежа справа в последней инструкции использовать строку, список, словарь, множество
|
||||
Список:
|
||||
```
|
||||
k1,k2,k3=[11,-3,'gfgdg']
|
||||
k1;k2;k3
|
||||
11
|
||||
-3
|
||||
'gfgdg'
|
||||
```
|
||||
Строка:
|
||||
```
|
||||
s1,s2,s3='123'
|
||||
s1;s2;s3
|
||||
'1'
|
||||
'2'
|
||||
'3'
|
||||
```
|
||||
Словарь:
|
||||
```
|
||||
d1,d2,d3={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
d1;d2;d3
|
||||
'Saratov'
|
||||
'Orel'
|
||||
'Vologda'
|
||||
```
|
||||
Множество:
|
||||
```
|
||||
m1,m2,m3={'двигатель','датчик','линия связи'}
|
||||
m1;m2;m3
|
||||
'двигатель'
|
||||
'линия связи'
|
||||
'датчик'
|
||||
```
|
||||
# 8. Логические операции
|
||||
## 8.1. Операции сравнение
|
||||
Придумал примеры использования операций сравнения и сравнил ранее созданные переменные w и v
|
||||
```
|
||||
w==v
|
||||
True
|
||||
w>v
|
||||
False
|
||||
w>=v
|
||||
True
|
||||
12>2
|
||||
True
|
||||
1<7
|
||||
True
|
||||
w!=v
|
||||
False
|
||||
```
|
||||
|
||||
## Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in).
|
||||
Применил операции со множеством:
|
||||
```
|
||||
mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
'book' in mnoz1
|
||||
True
|
||||
'cap' in mnoz1
|
||||
False
|
||||
```
|
||||
Применил операции со словарём:
|
||||
```
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
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).
|
||||
Использовал приведённый в методичке пример сложного логического выражения и придумал 2 своих
|
||||
```
|
||||
a=17
|
||||
b=-6
|
||||
(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
|
||||
((w==v) or (18>234)) and ('pen' in mnoz1) and not (123<1) and (('M' in 'Messi') or ('M' in 'Nicolay'))
|
||||
True
|
||||
not (dct1['Depart'][1] == 'MM') and not (163.5>163.6) and ('Vologda' in dic1)
|
||||
True
|
||||
```
|
||||
|
||||
## 8.4. Проверка ссылок переменных на один и тот же объект (is).
|
||||
Проверил, что при одновременном присваивании переменные ссылаются на один и тот же объект
|
||||
```
|
||||
w=v=10
|
||||
w is v
|
||||
True
|
||||
```
|
||||
После присвоил переменным одинаковые значения, но не одновременным присваиванием,поэтому переменные просто содержат одинаковые значения, но не ссылаются на одну и ту же "ячейку" в опертивной памяти
|
||||
```
|
||||
w1=['A','B']
|
||||
w1
|
||||
['A', 'B']
|
||||
v1=['A','B']
|
||||
w1 is v1
|
||||
False
|
||||
```
|
||||
|
||||
# 9.Операции с объектами, выполняемые с помощью методов.
|
||||
Применил функцию dir() для получения списка атрибутов объекта
|
||||
```
|
||||
stroka='Микропроцессорная система управления'
|
||||
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. Методы для работы со строками.
|
||||
Рассмотрел и применил примеры таких методом
|
||||
Возвращение позиции первого вхождения контекста или -1 если он не встречается:
|
||||
```
|
||||
stroka.find('пр')
|
||||
5
|
||||
```
|
||||
Подстчет числа вхождений подстрки в строку
|
||||
```
|
||||
stroka.count("с")
|
||||
4
|
||||
```
|
||||
Замена первого вхождения указанной подстроки на вторую подстроку
|
||||
```
|
||||
stroka.replace(' у',' автоматического у')
|
||||
'Микропроцессорная система автоматического управления'
|
||||
```
|
||||
Возвращение списка подстрок с заданным разделителем:
|
||||
```
|
||||
spis22=stroka.split(' ')
|
||||
```
|
||||
Возвращение строки со всеми заглавными буквами:
|
||||
```
|
||||
stroka.upper()
|
||||
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||
```
|
||||
Создание строки, собранной из элементов списка:
|
||||
```
|
||||
stroka3=" ".join(spis22)
|
||||
```
|
||||
Создание кортежей с результатами поиска "с" слева и "с" справа:
|
||||
```
|
||||
stroka3.partition("с")
|
||||
('Микропроце', 'с', 'сорная система управления')
|
||||
stroka3.rpartition("с")
|
||||
('Микропроцессорная си', 'с', 'тема управления')
|
||||
```
|
||||
|
||||
Изучение метода format
|
||||
Создал строку и вместо фигурных скобок вставил значения с помощью метода format
|
||||
```
|
||||
strk1='Момент времени {}, значение = {}'
|
||||
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)
|
||||
```
|
||||
|
||||
## 9.2. Методы для работы со списками.
|
||||
Создал список spsk с 5 элементами, применил к нему следующие методы:
|
||||
```
|
||||
spsk=[1,2,'ggwp', 'ss', 'Roman']
|
||||
spsk
|
||||
[1, 2, 'ggwp', 'ss', 'Roman']
|
||||
spsk.pop(2)
|
||||
'ggwp'
|
||||
spsk.append('c')
|
||||
spsk
|
||||
[1, 2, 'ss', 'Roman', 'c']
|
||||
spsk.insert(2,'a')
|
||||
spsk
|
||||
[1, 2, 'a', 'ss', 'Roman', 'c']
|
||||
spsk.count('a')
|
||||
1
|
||||
```
|
||||
Метод pop() удаляет из списка элемент с заданным индексом, метод append() добавляет новый элемент в конец списка
|
||||
insert() вставляет в список перед заданным индексом заданный элемент, а count() подсчитывает число вхождений элемента в список
|
||||
|
||||
## 9.3 Методы для работы с кортежами
|
||||
Применил к ранее созданному кортежу методы index и count, первый возвращает индекс первого вхождения элемента в кортёж, а второй подсчитывает число вхождений элемента в кортёж
|
||||
```
|
||||
kort1.index(222)
|
||||
0
|
||||
kort1.count(222)
|
||||
1
|
||||
```
|
||||
Методов pop, append и insert у кортежей нет, так как это неизменяемые объекты
|
||||
|
||||
## 9.4. Методы словарей и множеств
|
||||
Применил методы для добавления и удаления элементов из множеств:
|
||||
```
|
||||
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
|
||||
mnoz1.add('реле')
|
||||
mnoz1
|
||||
{'датчик', 'линия связи', 'микропроцессор', 'реле', 'двигатель'}
|
||||
mnoz1.remove('линия связи')
|
||||
mnoz1
|
||||
{'датчик', 'микропроцессор', 'реле', 'двигатель'}
|
||||
```
|
||||
|
||||
Создал словарь и применил к нему методы для: получения списка ключей, получения списка значений, и получения списка из пар ключ/значение
|
||||
```
|
||||
student = {
|
||||
"name": "Анна",
|
||||
"age": 20,
|
||||
"course": "Информатика",
|
||||
"grades": [4, 5, 4, 3],
|
||||
"city": "Москва"
|
||||
}
|
||||
student.keys()
|
||||
dict_keys(['name', 'age', 'course', 'grades', 'city'])
|
||||
student.values()
|
||||
dict_values(['Анна', 20, 'Информатика', [4, 5, 4, 3], 'Москва'])
|
||||
student.items()
|
||||
dict_items([('name', 'Анна'), ('age', 20), ('course', 'Информатика'), ('grades', [4, 5, 4, 3]), ('city', 'Москва')])
|
||||
removed_city = student.pop("city")
|
||||
removed_city
|
||||
'Москва'
|
||||
```
|
||||
|
||||
# 10. Сохранил отчёт работы и закончил сеанс работы с IDLE
|
||||
@ -0,0 +1,86 @@
|
||||
# Общее контрольное задание по Теме 3
|
||||
Ходюк Максим Романович, А-01-23
|
||||
|
||||
## Задание
|
||||
Преобразовать восьмеричное значение 45 в целое число.
|
||||
|
||||
Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
|
||||
|
||||
Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
|
||||
|
||||
Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
|
||||
Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
|
||||
|
||||
Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
|
||||
|
||||
Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
|
||||
|
||||
### Решение
|
||||
```
|
||||
vos=oct(45)
|
||||
vos
|
||||
'0o55'
|
||||
des=int(vos,8)
|
||||
des
|
||||
45
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
D={"усиление":23, "запаздывание":12, "постоянная времени":78}
|
||||
spis1=list(D)
|
||||
spis2=list(D.values())
|
||||
spis1
|
||||
['усиление', 'запаздывание', 'постоянная времени']
|
||||
spis2
|
||||
[23, 12, 78]
|
||||
kort=tuple(spis1+spis2)
|
||||
kort
|
||||
('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
|
||||
```
|
||||
|
||||
Кортежи отличаются от списков тем, что они являются неизменяемыми обьектами
|
||||
|
||||
|
||||
```
|
||||
((1768//24.8)%3)**2.4
|
||||
5.278031643091577
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
(~(13&27)^14)<<2
|
||||
-32
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
sps=["колебат","колебат","колебат","колебат"]
|
||||
"аткол" in (sps[1]+sps[2])
|
||||
True
|
||||
```
|
||||
|
||||
```
|
||||
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']
|
||||
D.keys()
|
||||
dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
|
||||
D.values()
|
||||
dict_values([23, 12, 78])
|
||||
```
|
||||
|
||||
С помощью методов keys и values можно получить списки ключей и значений из словаря соответственно
|
||||
|
||||
```
|
||||
str1="Создать объект - символьную строку с текстом данного предложения"
|
||||
spisW=str1.split()
|
||||
spisW
|
||||
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
spisW[spisW.index('-')]=','
|
||||
spisW
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
spisW.remove('данного')
|
||||
spisW
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
|
||||
```
|
||||
@ -0,0 +1,46 @@
|
||||
# Индивидуальное контрольное задание: тест по модулю 1
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
M1_1
|
||||
1) Почему текстовый редактор оболочки IDLE предпочтителен при написании программ на языке Python?
|
||||
|
||||
2) Создайте объект - символьную строку с текстом данного предложения. Напишите инструкции, заменяющие дефис, точку и запятую на знаки пробелов.
|
||||
|
||||
3) Напишите инструкцию создания списка с отдельными словами из строки символов. Подсчитайте число слов в списке.
|
||||
|
||||
4) Напишите инструкции создания списка с целочисленными элементами, значения которых равны числу символов в соответствующих словах из первого списка.
|
||||
|
||||
5) Подсчитайте среднюю длину слов в рассматриваемом предложении.
|
||||
|
||||
### Решение
|
||||
1)Текстовый редактор оболочки IDLE предпочтителен при написании программ на языке Python, так как в нём можно создавать скрипты(файлы с расширением .py), которые не получится создать при работе с консольным окном, а также скрипты можно запускать много раз без повторного ввода команд
|
||||
|
||||
2)
|
||||
```
|
||||
string = "Создайте объект - символьную строку с текстом данного предложения. Напишите инструкции, заменяющие дефис, точку и запятую на знаки пробелов."
|
||||
string = string.replace('-',' ')
|
||||
string = string.replace('.',' ')
|
||||
string = string.replace(',',' ')
|
||||
string
|
||||
'Создайте объект символьную строку с текстом данного предложения Напишите инструкции заменяющие дефис точку и запятую на знаки пробелов '
|
||||
```
|
||||
3)
|
||||
```
|
||||
spisW=string.split()
|
||||
spisW
|
||||
['Создайте', 'объект', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения', 'Напишите', 'инструкции', 'заменяющие', 'дефис', 'точку', 'и', 'запятую', 'на', 'знаки', 'пробелов']
|
||||
len(spisW)
|
||||
18
|
||||
```
|
||||
4)
|
||||
```
|
||||
spis2=[len(word) for word in spisW]
|
||||
spis2
|
||||
[8, 6, 10, 6, 1, 7, 7, 11, 8, 10, 10, 5, 5, 1, 7, 2, 5, 8]
|
||||
```
|
||||
5)
|
||||
```
|
||||
srznac=sum(spis2)//len(spis2)
|
||||
srznac
|
||||
6
|
||||
```
|
||||
|
После Ширина: | Высота: | Размер: 20 KiB |
|
После Ширина: | Высота: | Размер: 26 KiB |
|
После Ширина: | Высота: | Размер: 15 KiB |
|
После Ширина: | Высота: | Размер: 6.5 KiB |
|
После Ширина: | Высота: | Размер: 10 KiB |
@ -0,0 +1,449 @@
|
||||
# Отчёт по Теме 4
|
||||
Ходюк Максим Романович, А-01-23
|
||||
|
||||
## 2. Изучение стандартных функций модуля builtins
|
||||
### 2.1. Функция round
|
||||
Использовал функцию на следующих примерах:
|
||||
```
|
||||
round(123.456,1)
|
||||
123.5
|
||||
round(123.456,0)
|
||||
123.0
|
||||
```
|
||||
Как можно заметить, второй аргумент означает количество цифр в дробной части, до которой округляется число, и при введении этого аргумента результат получается типа float
|
||||
Если этот аргумент не задать:
|
||||
```
|
||||
round(123.456)
|
||||
123
|
||||
type(round(123.456))
|
||||
<class 'int'>
|
||||
```
|
||||
То число округлится до целых и будет типа int
|
||||
|
||||
### 2.2. Функция range
|
||||
Пример:
|
||||
```
|
||||
gg=range(76,123,9)
|
||||
gg
|
||||
range(76, 123, 9)
|
||||
```
|
||||
Эта инструкция создает, так называемый, «итерируемый объект» класса range. Чтобы увидеть получившуюся последовательность чисел, его надо преобразовать, например, в список, обычным способом:
|
||||
```
|
||||
list(gg)
|
||||
[76, 85, 94, 103, 112, 121]
|
||||
```
|
||||
Если вызвать эту функцию с одним аргументом, то создатся диапазон от 0 до заданного числа с шагом 1:
|
||||
```
|
||||
range(23)
|
||||
range(0, 23)
|
||||
list(range(23))
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
|
||||
```
|
||||
### 2.3. Функция zip
|
||||
Создал обьект список с именем qq, после чего применил функцию zip к qq и ранее созданному списку gg
|
||||
```
|
||||
qq = ['Hodyuk','Kovalenko','Ivanov', 'Lykova']
|
||||
ff=zip(gg,qq)
|
||||
```
|
||||
Как и в range здесь получается «итерируемый объект» класса zip, поэтому чтобы увидеть содержимое создал кортёж
|
||||
```
|
||||
tuple(ff)
|
||||
((76, 'Hodyuk'), (85, 'Kovalenko'), (94, 'Ivanov'), (103, 'Lykova'))
|
||||
```
|
||||
Элементов в полученном кортеже 4, так как из аргументов функции zip меньшую длину имел список qq, равную 4
|
||||
|
||||
Проверил, можно ли обратиться к полученному обьекту по индексу:
|
||||
```
|
||||
ff[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#14>", line 1, in <module>
|
||||
ff[1]
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
```
|
||||
К объекту zip нельзя обращаться по индексу
|
||||
|
||||
### 2.4. Функция eval
|
||||
Применил пример использования, отобразил результат(переменную dan):
|
||||
```
|
||||
fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
||||
коэффициент усиления=13
|
||||
dan
|
||||
-91.0
|
||||
```
|
||||
### 2.5 Функция exec
|
||||
Функция выполняет совокупность инструкций на языке Python, например:
|
||||
```
|
||||
exec(input('введите инструкции:'))
|
||||
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
||||
gg
|
||||
221.456
|
||||
```
|
||||
### 2.6. Самостоятельное изучение других стандартных функций
|
||||
Применил ранее известные функции:
|
||||
```
|
||||
abs(dan)
|
||||
91.0
|
||||
pow(2,4)
|
||||
16
|
||||
max([1,3,6,1])
|
||||
6
|
||||
min([1,16, -591, 0])
|
||||
-591
|
||||
sum([1,2,3,4])
|
||||
10
|
||||
len(qq)
|
||||
4
|
||||
```
|
||||
Изучил функции divmod и map, и применил их
|
||||
```
|
||||
help(divmod)
|
||||
Help on built-in function divmod in module builtins:
|
||||
|
||||
divmod(x, y, /)
|
||||
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
|
||||
|
||||
divmod(15,4)
|
||||
(3, 3)
|
||||
divmod(17,2)
|
||||
(8, 1)
|
||||
help(map)
|
||||
Help on class map in module builtins:
|
||||
|
||||
class map(object)
|
||||
| map(function, iterable, /, *iterables)
|
||||
|
|
||||
| Make an iterator that computes the function using arguments from
|
||||
| each of the iterables. Stops when the shortest iterable is exhausted.
|
||||
|
|
||||
| Methods defined here:
|
||||
|
|
||||
| __getattribute__(self, name, /)
|
||||
| Return getattr(self, name).
|
||||
|
|
||||
| __iter__(self, /)
|
||||
| Implement iter(self).
|
||||
|
|
||||
| __next__(self, /)
|
||||
| Implement next(self).
|
||||
|
|
||||
| __reduce__(self, /)
|
||||
| Return state information for pickling.
|
||||
|
|
||||
| ----------------------------------------------------------------------
|
||||
| Static methods defined here:
|
||||
|
|
||||
| __new__(*args, **kwargs)
|
||||
| Create and return a new object. See help(type) for accurate signature.
|
||||
|
||||
map(len,qq)
|
||||
<map object at 0x000002694337F220>
|
||||
list(map(len,qq))
|
||||
[6, 9, 6, 6]
|
||||
```
|
||||
## 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']
|
||||
```
|
||||
Применил некоторые функции из модуля, включая factorial
|
||||
```
|
||||
math.factorial(5)
|
||||
120
|
||||
math.sin(math.pi/2)
|
||||
1.0
|
||||
math.acos(math.sqrt(3)/2)
|
||||
0.5235987755982989
|
||||
help(math.degrees)
|
||||
Help on built-in function degrees in module math:
|
||||
|
||||
degrees(x, /)
|
||||
Convert angle x from radians to degrees.
|
||||
|
||||
math.degrees(math.pi/2)
|
||||
90.0
|
||||
math.radians(90)
|
||||
1.5707963267948966
|
||||
math.log(15)
|
||||
2.70805020110221
|
||||
math.log(8,2)
|
||||
3.0
|
||||
math.exp
|
||||
<built-in function exp>
|
||||
math.log10(100)
|
||||
2.0
|
||||
math.ceil(25.181926)
|
||||
26
|
||||
math.floor(25.181915)
|
||||
25
|
||||
```
|
||||
После применения всех необходимых функций написал инструкцию для вычисления значения выражения sin(2π/7+e0.23 )
|
||||
```
|
||||
math.sin((2*math.pi/7)+math.exp(0.23))
|
||||
0.8334902641414562
|
||||
```
|
||||
## 4. Модуль cmath
|
||||
Испортировал модуль,вывел его содержание и изучил функции вычисления корня и получения фазы комплексного числа
|
||||
```
|
||||
import cmath
|
||||
dir(cmath)
|
||||
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
|
||||
cmath.sqrt(1.2-0.5j)
|
||||
(1.118033988749895-0.22360679774997896j)
|
||||
cmath.phase(1-0.5j)
|
||||
-0.4636476090008061
|
||||
```
|
||||
## 5. Модуль random
|
||||
Снова импортировал модуль и вывел список функций в модуле:
|
||||
```
|
||||
import random
|
||||
dir(random)
|
||||
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_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']
|
||||
```
|
||||
Изучил функцию seed, задающую случайное начальное состояние для псевдослучайных чисел:
|
||||
```
|
||||
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 (равномерно распределенное случайное число), uniform (равномерно распределенное случайное число), randint (случайные целые числа), gauss (нормально распределенное случайное число), randint (случайное целое число), choice (случайный выбор из совокупности), shuffle (случайная перестановка элементов списка), sample (случайный выбор подмножества элементов), betavariate(случайное число с бета-распределением), gammavariate(случайное число с гамма-распределением).
|
||||
```
|
||||
random.random()
|
||||
0.8415073202155561
|
||||
help(random.uniform)
|
||||
Help on method uniform in module random:
|
||||
|
||||
uniform(a, b) method of random.Random instance
|
||||
Get a random number in the range [a, b) or [a, b] depending on rounding.
|
||||
|
||||
The mean (expected value) and variance of the random variable are:
|
||||
|
||||
E[X] = (a + b) / 2
|
||||
Var[X] = (b - a) ** 2 / 12
|
||||
|
||||
random.uniform(4,13)
|
||||
12.083229701608595
|
||||
random.randint(1,4)
|
||||
1
|
||||
help(random.randint)
|
||||
Help on method randint in module random:
|
||||
|
||||
randint(a, b) method of random.Random instance
|
||||
Return random integer in range [a, b], including both end points.
|
||||
|
||||
help(random.gauss)
|
||||
Help on method gauss in module random:
|
||||
|
||||
gauss(mu=0.0, sigma=1.0) method of random.Random instance
|
||||
Gaussian distribution.
|
||||
|
||||
mu is the mean, and sigma is the standard deviation. This is
|
||||
slightly faster than the normalvariate() function.
|
||||
|
||||
Not thread-safe without a lock around calls.
|
||||
|
||||
random.gauss()
|
||||
0.9495673914994565
|
||||
random.gauss(mu=3,sigma=2)
|
||||
3.7978130361127436
|
||||
help(random.choice)
|
||||
Help on method choice in module random:
|
||||
|
||||
choice(seq) method of random.Random instance
|
||||
Choose a random element from a non-empty sequence.
|
||||
|
||||
random.choice([1,3,5,2,1,5,7,8,9])
|
||||
5
|
||||
random.shuffle([1,3,5,2,1,5,7,8,9])
|
||||
aa=random.shuffle([1,3,5,2,1,5,7,8,9])
|
||||
aa
|
||||
help(random.shuffle)
|
||||
Help on method shuffle in module random:
|
||||
|
||||
shuffle(x) method of random.Random instance
|
||||
Shuffle list x in place, and return None.
|
||||
|
||||
aa=[1,3,5,2,1,5,7,8,9]
|
||||
random.shuffle(aa)
|
||||
aa
|
||||
[5, 1, 7, 5, 3, 8, 9, 1, 2]
|
||||
random.sample(aa,4)
|
||||
[1, 3, 5, 5]
|
||||
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(13,2)
|
||||
0.9768043355909166
|
||||
random.gammavariate(4,6)
|
||||
6.383419053564046
|
||||
```
|
||||
Создал список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям:
|
||||
```
|
||||
spis=[random.uniform(4,13),random.gauss(mu=3,sigma=2),random.betavariate(13,2),random.gammavariate(4,6)]
|
||||
spis
|
||||
[8.823603554451614, 0.9688486416723059, 0.8365506057159969, 10.812180117279787]
|
||||
```
|
||||
## Модуль 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']
|
||||
```
|
||||
Изучил функцию time, возвращающую время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
|
||||
```
|
||||
c1=time.time()
|
||||
c2=time.time()-c1
|
||||
```
|
||||
Получил в переменную dat "Всемирное координатное время", и научился обращаться к компонентам получившегося объекта:
|
||||
```
|
||||
dat=time.gmtime()
|
||||
dat
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=7, tm_min=19, tm_sec=44, tm_wday=0, tm_yday=286, tm_isdst=0)
|
||||
dat.tm_mon
|
||||
10
|
||||
dat.tm_mday
|
||||
13
|
||||
dat.tm_wday
|
||||
0
|
||||
```
|
||||
Получил местное время функцией localtime()
|
||||
```
|
||||
time.localtime()
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=10, tm_min=21, tm_sec=49, tm_wday=0, tm_yday=286, tm_isdst=0)
|
||||
```
|
||||
Изучил функции из модуля time:asctime (преобразование представления времени из кортежа в строку) , ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку), sleep (прерывание работы программы на заданное время), mktime (преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи).
|
||||
```
|
||||
help(time.asctime)
|
||||
Help on built-in function asctime in module time:
|
||||
|
||||
asctime(...)
|
||||
asctime([tuple]) -> string
|
||||
|
||||
Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
|
||||
When the time tuple is not present, current time as returned by localtime()
|
||||
is used.
|
||||
|
||||
time.asctime(time.localtime())
|
||||
'Mon Oct 13 10:23:33 2025'
|
||||
help(time.ctime)
|
||||
Help on built-in function ctime in module time:
|
||||
|
||||
ctime(...)
|
||||
ctime(seconds) -> string
|
||||
|
||||
Convert a time in seconds since the Epoch to a string in local time.
|
||||
This is equivalent to asctime(localtime(seconds)). When the time tuple is
|
||||
not present, current time as returned by localtime() is used.
|
||||
|
||||
time.ctime(156323)
|
||||
'Fri Jan 2 22:25:23 1970'
|
||||
time.ctime(1)
|
||||
'Thu Jan 1 03:00:01 1970'
|
||||
help(time.sleep)
|
||||
Help on built-in function sleep in module time:
|
||||
|
||||
sleep(object, /)
|
||||
sleep(seconds)
|
||||
|
||||
Delay execution for a given number of seconds. The argument may be
|
||||
a floating-point number for subsecond precision.
|
||||
|
||||
time.sleep(3)
|
||||
time.mktime(time.localtime())
|
||||
1760340425.0
|
||||
```
|
||||
Преобразование из секунд в местное время также осуществляется функцией localtime:
|
||||
```
|
||||
time.localtime(c1)
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=10, tm_min=19, tm_sec=23, tm_wday=0, tm_yday=286, tm_isdst=0)
|
||||
```
|
||||
## Графические функции
|
||||
Импортировал модуль pylab из пакета matplotlib, после чего создал списки и научился создавать графики
|
||||
```
|
||||
import pylab
|
||||
x=list(range(-3,55,4))
|
||||
t=list(range(15))
|
||||
pylab.plot(t,x)
|
||||
[<matplotlib.lines.Line2D object at 0x000002695C316850>]
|
||||
pylab.title('Первый график')
|
||||
Text(0.5, 1.0, 'Первый график')
|
||||
pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
pylab.show()
|
||||
```
|
||||
Сохранил получившийся график в файле Figure0.png
|
||||
|
||||
Рассмотрел возможность создания нескольких графиков на одном экране
|
||||
```
|
||||
X1=[12,6,8,10,7]
|
||||
X2=[5,7,9,11,13]
|
||||
pylab.plot(X1)
|
||||
[<matplotlib.lines.Line2D object at 0x000002695D9BF110>]
|
||||
pylab.plot(X2)
|
||||
[<matplotlib.lines.Line2D object at 0x000002695D9BF250>]
|
||||
pylab.show()
|
||||
```
|
||||
Сохранил в файл с названием Figure1.png
|
||||
|
||||
Построил круговую диаграмму, сохранил результат в файл Figure2.png
|
||||
```
|
||||
region=['Центр','Урал','Сибирь','Юг']
|
||||
naselen=[65,12,23,17]
|
||||
pylab.pie(naselen,labels=region)
|
||||
([<matplotlib.patches.Wedge object at 0x000002695C2FD940>, <matplotlib.patches.Wedge object at 0x000002695D2E0B90>, <matplotlib.patches.Wedge object at 0x000002695D2E0F50>, <matplotlib.patches.Wedge object at 0x000002695D2E11D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
|
||||
pylab.show()
|
||||
```
|
||||
Изучил функции bar и hist, результаты сохранил в файлы Figure3.png и Figure4.png соответственно
|
||||
```
|
||||
pylab.bar(X1,X1)
|
||||
<BarContainer object of 5 artists>
|
||||
pylab.show()
|
||||
pylab.hist(X2,bins=3)
|
||||
(array([2., 1., 2.]), array([ 5. , 7.66666667, 10.33333333, 13. ]), <BarContainer object of 3 artists>)
|
||||
pylab.show()
|
||||
```
|
||||
## 8.Статистика
|
||||
Импортировал модуль statistics и применил 3 функции из этого модуля
|
||||
```
|
||||
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.mean(X1)
|
||||
8.6
|
||||
statistics.correlation(X1,X2)
|
||||
-0.3939192985791677
|
||||
statistics.covariance(X1,X2)
|
||||
-3.0
|
||||
```
|
||||
@ -0,0 +1,81 @@
|
||||
# Общее контрольное задание по Теме 4
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
• Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
|
||||
|
||||
• Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
|
||||
|
||||
• Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
|
||||
|
||||
• Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
|
||||
|
||||
• Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
|
||||
|
||||
• Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
|
||||
|
||||
### Решение
|
||||
```
|
||||
import cmath
|
||||
divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
|
||||
(8.0, 2.6000000000000014)
|
||||
kort = divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
|
||||
kort
|
||||
(8.0, 2.6000000000000014)
|
||||
```
|
||||
|
||||
```
|
||||
MosTime=time.localtime()
|
||||
MosTime
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=11, tm_min=17, tm_sec=51, tm_wday=0, tm_yday=286, tm_isdst=0)
|
||||
string='Текущее время по МСК: часы - {}, минуты-{}'
|
||||
string=string.format(MosTime.tm_hour,MosTime.tm_min)
|
||||
string
|
||||
'Текущее время по МСК: часы - 11, минуты-17'
|
||||
```
|
||||
|
||||
```
|
||||
spis = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
|
||||
random.sample(spis,3)
|
||||
['Wednesday', 'Friday', 'Tuesday']
|
||||
```
|
||||
|
||||
```
|
||||
random.choice(range(14,33,3))
|
||||
29
|
||||
```
|
||||
|
||||
```
|
||||
N=random.gauss(15,4)
|
||||
N
|
||||
20.856697509675403
|
||||
N=round(N)
|
||||
```
|
||||
|
||||
```
|
||||
import string
|
||||
alf=string.ascii_lowercase
|
||||
alf
|
||||
'abcdefghijklmnopqrstuvwxyz'
|
||||
ALF=list(alf)
|
||||
ALF
|
||||
['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']
|
||||
spis1=list(random.choice(ALF)for i in range(N))
|
||||
spis1
|
||||
['d', 'i', 'g', 'g', 't', 'm', 'c', 'y', 'z', 'm', 'w', 'd', 'j', 'h', 'q', 't', 'k', 'v', 'i', 'r', 'w']
|
||||
```
|
||||
|
||||
```
|
||||
import time
|
||||
MosTime1=time.localtime()
|
||||
MosTime1
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=42, tm_sec=27, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
MosTime2=time.localtime()
|
||||
MosTime2
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=46, tm_sec=4, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
interval=time.mktime(MosTime2)-time.mktime(MosTime1)
|
||||
interval
|
||||
217.0
|
||||
IntervMin=interval/60
|
||||
IntervMin
|
||||
3.6166666666666667
|
||||
```
|
||||
@ -0,0 +1,27 @@
|
||||
# Индивидуальное контрольное задание по Теме 4
|
||||
Ходюк Максим Романович, А-01-23
|
||||
## Задание, Вариант 6
|
||||
|
||||
Создайте переменную с календарными сведениями для текущего момента времени и выведите информацию в виде строки «Текущая дата: <день>-<месяц>-<год>». Создайте объект со значением 5-2j. Извлеките из него квадратный корень с записью результата в новый объект. Эту операцию выполните с использованием функции exec.
|
||||
|
||||
### Выполнение
|
||||
Создание переменной с календарными сведениями и форматный вывод:
|
||||
```
|
||||
import time
|
||||
MosTime=time.localtime()
|
||||
LocalDate='Текущая дата:{day}-{month}-{year}'
|
||||
LocalDate.format(day=MosTime.tm_mday, month=MosTime.tm_mon, year=MosTime.tm_year)
|
||||
'Текущая дата:24-10-2025'
|
||||
```
|
||||
|
||||
Создание обьекта-комплексного числа и извлечение из него квадратного корня с помощью функции exec
|
||||
```
|
||||
import cmath
|
||||
perem=5-2j
|
||||
perem
|
||||
(5-2j)
|
||||
exec(input("Введите инструкцию для извлечения квадратного корня из комплексного числа в переменной perem и записи в новую переменную: "))
|
||||
Введите инструкцию для извлечения квадратного корня из комплексного числа в переменной perem и записи в новую переменную: PeremSqrt=cmath.sqrt(perem)
|
||||
PeremSqrt
|
||||
(2.27872385417085-0.4388421169022545j)
|
||||
```
|
||||
|
После Ширина: | Высота: | Размер: 16 KiB |
|
После Ширина: | Высота: | Размер: 37 KiB |
@ -0,0 +1,10 @@
|
||||
import random as rn
|
||||
kort=tuple(range(-24,769,11))
|
||||
k = 0
|
||||
spis = []
|
||||
for i in range(40):
|
||||
spis.append(rn.choice(kort))
|
||||
if i>0 and spis[i]>spis[i-1]:
|
||||
k += 1
|
||||
|
||||
print(f'Повышение в списке:{k} раз')
|
||||
@ -0,0 +1,269 @@
|
||||
# Отчёт по Теме 5
|
||||
Ходюк Максим Романович А-01-23
|
||||
## 2. Ветвление по условию
|
||||
Применил примеры использования конструкции if:
|
||||
```
|
||||
porog = 4
|
||||
rashod1 = 1
|
||||
rashod2 = 3
|
||||
if rashod1>=porog:
|
||||
dohod=12
|
||||
elif rashod2==porog:
|
||||
dohod=0
|
||||
else:
|
||||
dohod=-8
|
||||
|
||||
|
||||
dohod
|
||||
-8
|
||||
rashod1 = 3
|
||||
rashod2 = 4
|
||||
if rashod1>=3 and rashod2==4:
|
||||
dohod=rashod1
|
||||
if rashod2==porog or rashod1<rashod2:
|
||||
dohod=porog
|
||||
|
||||
dohod
|
||||
4
|
||||
if porog==3:
|
||||
dohod=1
|
||||
elif porog==4:
|
||||
dohod=2
|
||||
elif porog==5:
|
||||
dohod=3
|
||||
else:
|
||||
dohod=0
|
||||
|
||||
dohod
|
||||
2
|
||||
|
||||
dohod=2 if porog>=4 else 0
|
||||
dohod
|
||||
2
|
||||
if porog>=5 : rashod1=6; rashod2=0
|
||||
|
||||
rashod1;rashod2
|
||||
3
|
||||
4
|
||||
```
|
||||
|
||||
## 3. Цикл по перечислению
|
||||
### 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]
|
||||
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
|
||||
```
|
||||
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)
|
||||
|
||||
ss
|
||||
537
|
||||
|
||||
sps5=[]
|
||||
for i in range(10):
|
||||
sps5.append(rn.randint(1,100))
|
||||
ss=sum(sps5)
|
||||
if ss>500: break
|
||||
else:
|
||||
print(ss)
|
||||
|
||||
|
||||
ss
|
||||
531
|
||||
sps5=[]
|
||||
for i in range(10):
|
||||
sps5.append(rn.randint(1,100))
|
||||
ss=sum(sps5)
|
||||
if ss>500: break
|
||||
else:
|
||||
print(ss)
|
||||
|
||||
|
||||
410
|
||||
```
|
||||
### 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]
|
||||
```
|
||||
Отображение сигнала на графике:
|
||||
```
|
||||
pylab.plot(range(100),sps2)
|
||||
[<matplotlib.lines.Line2D object at 0x0000027FA0ABEFD0>]
|
||||
pylab.show()
|
||||
```
|
||||
График:
|
||||
|
||||
|
||||
## 4. Цикл "пока истинно условие"
|
||||
|
||||
### 4.1. Цикл со счетчиком
|
||||
```
|
||||
rashod=300
|
||||
while rashod:
|
||||
print("Расход=",rashod)
|
||||
rashod-=50
|
||||
|
||||
Расход= 300
|
||||
Расход= 250
|
||||
Расход= 200
|
||||
Расход= 150
|
||||
Расход= 100
|
||||
Расход= 50
|
||||
```
|
||||
### 4.2 Пример с символьной строкой
|
||||
```
|
||||
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(range(39),sps2)
|
||||
|
||||
[<matplotlib.lines.Line2D object at 0x0000027FA129E710>]
|
||||
pylab.show()
|
||||
```
|
||||
График сохранён в файле Figure0.png
|
||||
|
||||
### 4.3. Определение, является ли число простым
|
||||
```
|
||||
chislo=267
|
||||
kandidat =chislo // 2
|
||||
while kandidat > 1:
|
||||
if chislo%kandidat == 0: # Остаток от деления
|
||||
print(chislo, ' имеет множитель ', kandidat)
|
||||
break # else выполняться не будет
|
||||
kandidat -= 1
|
||||
else: # При завершении цикла без break
|
||||
print(chislo, ' является простым!')
|
||||
|
||||
267 имеет множитель 89
|
||||
```
|
||||
Дополнил программу, чтобы она выводила все простые числа в диапазоне от 250 до 300
|
||||
```
|
||||
for chislo in range(250,301):
|
||||
kandidat = chislo // 2
|
||||
while kandidat > 1:
|
||||
if chislo%kandidat == 0:
|
||||
break
|
||||
kandidat -= 1
|
||||
else: print(chislo, ' является простым!')
|
||||
|
||||
|
||||
251 является простым!
|
||||
257 является простым!
|
||||
263 является простым!
|
||||
269 является простым!
|
||||
271 является простым!
|
||||
277 является простым!
|
||||
281 является простым!
|
||||
283 является простым!
|
||||
293 является простым!
|
||||
```
|
||||
### Использование инструкции continue
|
||||
```
|
||||
print("Нечетные числа от 1 до 10:")
|
||||
Нечетные числа от 1 до 10:
|
||||
for i in range(1, 11):
|
||||
if i % 2 == 0:
|
||||
continue
|
||||
print(i)
|
||||
|
||||
|
||||
1
|
||||
3
|
||||
5
|
||||
7
|
||||
9
|
||||
```
|
||||
|
||||
@ -0,0 +1,73 @@
|
||||
# Общее контрольное задание по Теме 5
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
• Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
|
||||
|
||||
• Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
|
||||
|
||||
• Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
|
||||
|
||||
### Выполнение
|
||||
Создание символьной строки и определение порядкового номера в алфавите:
|
||||
```
|
||||
text = 'You cannot kill me! I am Omega! You cannot kill me! I am Subhuman!'
|
||||
|
||||
from string import ascii_lowercase
|
||||
for el in text:
|
||||
index = ascii_lowercase.find(el.lower())
|
||||
if index != -1:
|
||||
print( index + 1, end = '_')
|
||||
else:
|
||||
print(el, end='')
|
||||
|
||||
|
||||
25_15_21_ 3_1_14_14_15_20_ 11_9_12_12_ 13_5_! 9_ 1_13_ 15_13_5_7_1_! 25_15_21_ 3_1_14_14_15_20_ 11_9_12_12_ 13_5_! 9_ 1_13_ 19_21_2_8_21_13_1_14_!
|
||||
```
|
||||
|
||||
Список со словами из пункта задания и поиск в нём заданного слова
|
||||
```
|
||||
words = ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
|
||||
KeyWord = input('Введите слово, искомое в списке: ')
|
||||
Введите слово, искомое в списке: Создайте
|
||||
if KeyWord in words:
|
||||
res='присутствует в списке'
|
||||
else:res='отсутствует в списке'
|
||||
|
||||
print(f'слово {KeyWord} {res}')
|
||||
слово Создайте присутствует в списке
|
||||
KeyWord = input('Введите слово, искомое в списке: ')
|
||||
Введите слово, искомое в списке: ДАНТЕ
|
||||
if KeyWord in words:
|
||||
res='присутствует в списке'
|
||||
else:res='отсутствует в списке'
|
||||
|
||||
print(f'слово {KeyWord} {res}')
|
||||
слово ДАНТЕ отсутствует в списке
|
||||
```
|
||||
|
||||
Список из фамилий и оценок на сессиях, вывод по указанной фамилии средних баллов студента:
|
||||
```
|
||||
surnames1 = ['Коваленко', 'Лыкова', 'Ходюк']
|
||||
marks1 = [5, 4, 5]
|
||||
surnames2 = ['Лыкова', 'Ходюк', 'Коваленко']
|
||||
marks2 = [4.5, 4.2, 5]
|
||||
|
||||
student = input('Введите фамилию студента: ')
|
||||
Введите фамилию студента: Спардович
|
||||
if student in surnames1:
|
||||
print(f'Средний балл введённого студента за летнюю сессию - {marks1[surnames1.index(student)]}, а за зимнюю сессию - {marks2[surnames2.index(student)]}')
|
||||
else:
|
||||
print(f'Студента {student} не существует')
|
||||
|
||||
|
||||
Студента Спардович не существует
|
||||
student = input('Введите фамилию студента: ')
|
||||
Введите фамилию студента: Лыкова
|
||||
if student in surnames1:
|
||||
print(f'Средний балл введённого студента за летнюю сессию - {marks1[surnames1.index(student)]}, а за зимнюю сессию - {marks2[surnames2.index(student)]}')
|
||||
else:
|
||||
print(f'Студента {student} не существует')
|
||||
|
||||
|
||||
Средний балл введённого студента за летнюю сессию - 4, а за зимнюю сессию - 4.5
|
||||
```
|
||||
@ -0,0 +1,36 @@
|
||||
# Индивидуальное контрольное задание по Теме 5
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание,Вариант 20
|
||||
Создайте кортеж с целыми числами в диапазоне от -24 до 768 через 11. Напишите инструкцию создания списка с 40 случайно выбранными элементами из кортежа. Подсчитайте, сколько раз в этом списке последующий элемент оказался больше предыдущего. Отобразите результат в виде строки вида: «Повышение в списке: ХХХ раз».
|
||||
### Выполнение
|
||||
Скрипт для выполнения данного задания в файле [TestCode.py](TestCode.py)
|
||||
|
||||
```
|
||||
kort=tuple(range(-24,769,11))
|
||||
kort
|
||||
(-24, -13, -2, 9, 20, 31, 42, 53, 64, 75, 86, 97, 108, 119, 130, 141, 152, 163, 174, 185, 196, 207, 218, 229, 240, 251, 262, 273, 284, 295, 306, 317, 328, 339, 350, 361, 372, 383, 394, 405, 416, 427, 438, 449, 460, 471, 482, 493, 504, 515, 526, 537, 548, 559, 570, 581, 592, 603, 614, 625, 636, 647, 658, 669, 680, 691, 702, 713, 724, 735, 746, 757, 768)
|
||||
k = 0
|
||||
spis = []
|
||||
import random as rn
|
||||
for i in range(40):
|
||||
spis.append(rn.choice(kort))
|
||||
if i>0 and spis[i]>spis[i-1]:
|
||||
k += 1
|
||||
|
||||
|
||||
spis
|
||||
[757, 383, 757, 64, 185, 372, 262, 724, 350, 53, 306, 614, -2, 53, 416, 97, 262, 416, 350, 64, 394, 20, 405, 493, 207, 493, 86, 768, 757, -2, 119, 339, 306, 361, 713, 229, 119, 240, 53, 548]
|
||||
k
|
||||
21
|
||||
len(spis)
|
||||
40
|
||||
print(f'Повышение в списке:{k} раз')
|
||||
Повышение в списке:21 раз
|
||||
|
||||
|
||||
======================= RESTART: D:\POAS\Hodyuk\Tema5\TestCode.py ======================
|
||||
Повышение в списке:16 раз
|
||||
|
||||
======================= RESTART: D:\POAS\Hodyuk\Tema5\TestCode.py ======================
|
||||
Повышение в списке:19 раз
|
||||
```
|
||||
Двоичный файл не отображается.
Двоичный файл не отображается.
@ -0,0 +1,13 @@
|
||||
-6.301
|
||||
-8.685
|
||||
-4.592
|
||||
-7.139
|
||||
-5.445
|
||||
-7.428
|
||||
-7.014
|
||||
-5.985
|
||||
-5.544
|
||||
-7.975
|
||||
-4.388
|
||||
-4.993
|
||||
-4.873
|
||||
@ -0,0 +1 @@
|
||||
запись строки в файл
|
||||
@ -0,0 +1,29 @@
|
||||
import os
|
||||
os.chdir('D:\\POAS\\Hodyuk\\Tema6\\')
|
||||
import random as rn
|
||||
kort = []
|
||||
for i in range(125): kort.append(str(rn.choice(range(6,57))))
|
||||
kort = tuple(kort)
|
||||
spis = ['Hodyuk','Timoshenko','Kovalenko','Lykova','Ivanov']
|
||||
fp = open('TestDan.mnz','wb')
|
||||
if !fp.closed:
|
||||
pickle.dump(kort,fp)
|
||||
pickle.dump(spis,fp)
|
||||
fp.close()
|
||||
|
||||
fp = open('TestDan.mnz','rb')
|
||||
if !fp.closed:
|
||||
kort1=pickle.load(fp)
|
||||
spis1=pickle.load(fp)
|
||||
if kort1==kort and spis1==spis:
|
||||
print("новые обьекты совпадают с теми, что были записаны в файл")
|
||||
else:
|
||||
print("Ошибка записи или чтения")
|
||||
fp.close()
|
||||
|
||||
for i in range(len(kort)//5):
|
||||
exec('list' + str(i) + '=' + str(list(kort[i:i+5])))
|
||||
|
||||
|
||||
|
||||
|
||||
Двоичный файл не отображается.
|
После Ширина: | Высота: | Размер: 33 KiB |
|
После Ширина: | Высота: | Размер: 33 KiB |
|
После Ширина: | Высота: | Размер: 14 KiB |
|
После Ширина: | Высота: | Размер: 14 KiB |
|
После Ширина: | Высота: | Размер: 14 KiB |
|
После Ширина: | Высота: | Размер: 11 KiB |
@ -0,0 +1,468 @@
|
||||
# Отчёт по Теме 6
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Пункт 1
|
||||
Запустил среду IDLE и выставил рабочий каталог:
|
||||
```
|
||||
import os
|
||||
os.chdir('D:\\POAS\\Hodyuk\\Tema6\\')
|
||||
```
|
||||
|
||||
## Пункт 2
|
||||
### 2.1. Вывод в командной строке
|
||||
```
|
||||
stroka='Автоматизированная система управления'
|
||||
stroka
|
||||
'Автоматизированная система управления'
|
||||
```
|
||||
Данный способ вывода называется Эхо-выводом
|
||||
|
||||
### 2.2 Функция print
|
||||
Пример использования
|
||||
```
|
||||
fff=234.5;gg='Значение температуры = '
|
||||
print(gg, fff)
|
||||
Значение температуры = 234.5
|
||||
```
|
||||
|
||||
Можно изменить разделитель при выводе аргументом sep и символы, оканчивающие вывод с помощью аргумента end
|
||||
```
|
||||
print(gg, fff, sep='/')
|
||||
Значение температуры = /234.5
|
||||
print(gg, fff,sep='/',end='***'); print('____')
|
||||
Значение температуры = /234.5***____
|
||||
print()
|
||||
```
|
||||
|
||||
Оператор вывода может располагаться на нескольких строках:
|
||||
```
|
||||
print(""" Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк""")
|
||||
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
print("Здесь может выводиться",
|
||||
"большой текст,",
|
||||
"занимающий несколько строк")
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
```
|
||||
|
||||
### 2.3 Функция write
|
||||
Импортирую модуль sys и применяю функцию write
|
||||
```
|
||||
import sys
|
||||
sys.stdout.write('Функция write')
|
||||
Функция write13
|
||||
sys.stdout.write('Функция write\n')
|
||||
Функция write
|
||||
14
|
||||
```
|
||||
|
||||
## Пункт 3. Функция input (ввод с клавиатуры)
|
||||
|
||||
```
|
||||
psw=input('Введите пароль:')
|
||||
Введите пароль: 12345
|
||||
psw
|
||||
' 12345'
|
||||
```
|
||||
|
||||
Пример 1. Ввод с контролем значения
|
||||
```
|
||||
while True:
|
||||
znach=float(input('Задайте коэф.усиления = '))
|
||||
if znach<17.5 or znach>23.8:
|
||||
print('Ошибка!')
|
||||
else:
|
||||
break
|
||||
|
||||
Задайте коэф.усиления = 20
|
||||
while True:
|
||||
znach=float(input('Задайте коэф.усиления = '))
|
||||
if znach<17.5 or znach>23.8:
|
||||
print('Ошибка!')
|
||||
else:
|
||||
break
|
||||
|
||||
|
||||
Задайте коэф.усиления = 3
|
||||
Ошибка!
|
||||
Задайте коэф.усиления = 5
|
||||
Ошибка!
|
||||
Задайте коэф.усиления = 19
|
||||
```
|
||||
|
||||
Пример 2. Ввод и обработка выражения
|
||||
```
|
||||
import math
|
||||
print(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
```
|
||||
|
||||
## Пункт 4.
|
||||
### 4.1 Функции для работы с путём к файлу
|
||||
|
||||
Модуль os был импортирован ранее, а также выставлен рабочий каталог, поэтому сразу перейду к использованию других функций в этом модуле
|
||||
Использование функции для создания и удаления каталога:
|
||||
```
|
||||
os.mkdir('gg')
|
||||
```
|
||||
На рис.1 представлен скриншот созданного каталога gg
|
||||
Рис. 1:
|
||||
|
||||
|
||||
```
|
||||
os.rmdir('gg')
|
||||
```
|
||||
|
||||
На рис. 2 представлен скриншот после выполнения функций удаления каталога
|
||||
|
||||
Рис. 2:
|
||||
|
||||
|
||||
Использовал функцию для выводе всех файлов, находящихся в выбранном каталоге(при пустых аргументах выдаёт содержимое рабочего каталога)
|
||||
```
|
||||
os.listdir()
|
||||
['photo1.png', 'photo2.png', 'report.md']
|
||||
```
|
||||
|
||||
Использования функции isdir из модуля os.path (для проверки наличия подкаталога в каталоге)
|
||||
```
|
||||
help(os.path.isdir)
|
||||
Help on built-in function _path_isdir in module nt:
|
||||
|
||||
_path_isdir(s)
|
||||
Return true if the pathname refers to an existing directory.
|
||||
|
||||
os.mkdir('test_isdir')
|
||||
os.path.isdir('test_isdir')
|
||||
True
|
||||
```
|
||||
|
||||
Пусть в рабочем каталоге находится файл OPLATA.DBF. С помощью функции os.path.abspath можно получить символьную строку, содержащую имя файла вместе с полным путем доступа к нему:
|
||||
|
||||
```
|
||||
fil=os.path.abspath("oplata.dbf")
|
||||
fil
|
||||
'D:\\POAS\\Hodyuk\\Tema6\\oplata.dbf'
|
||||
|
||||
fil=os.path.abspath("photo1.png")
|
||||
fil
|
||||
'D:\\POAS\\Hodyuk\\Tema6\\photo1.png'
|
||||
```
|
||||
|
||||
Выделил путь доступа к файлу из строки с помощью следующей функции:
|
||||
```
|
||||
drkt=os.path.dirname(fil)
|
||||
drkt
|
||||
'D:\\POAS\\Hodyuk\\Tema6'
|
||||
```
|
||||
Далее выделил имя файла из этой строки
|
||||
```
|
||||
bn=os.path.basename(fil)
|
||||
bn
|
||||
'photo1.png'
|
||||
```
|
||||
|
||||
Самостоятельно применил функцию os.path.split
|
||||
```
|
||||
help(os.path.split)
|
||||
Help on function split in module ntpath:
|
||||
|
||||
split(p)
|
||||
Split a pathname.
|
||||
|
||||
Return tuple (head, tail) where tail is everything after the final slash.
|
||||
Either part may be empty.
|
||||
|
||||
os.path.split(fil)
|
||||
('D:\\POAS\\Hodyuk\\Tema6', 'photo1.png')
|
||||
```
|
||||
Функция возвращает кортёж из пути доступа к файлу и его имени, отделив их друг от друга
|
||||
|
||||
С помощью функции os.path.exists можно проверить существует ли путь, заданный в символьной строке – аргументе функции.
|
||||
```
|
||||
os.path.exists(drkt)
|
||||
True
|
||||
os.path.exists('D:test\\wrong\\way\\')
|
||||
False
|
||||
```
|
||||
|
||||
Проверил наличие файла с известным расположением(если как аргумент задать только имя файла, функция будет искать файл в рабочем каталоге)
|
||||
```
|
||||
os.path.isfile(fil)
|
||||
True
|
||||
os.path.isfile(os.path.dirname(fil)+'fil1.txt')
|
||||
False
|
||||
```
|
||||
|
||||
### 4.2 Общая схема работы с файлом
|
||||
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||
|
||||
• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||
|
||||
• Выполнение одной или нескольких операций обмена данными с файлом;
|
||||
|
||||
• Закрытие файла.
|
||||
|
||||
### 4.3 Открытие файла для записи или чтения - функция open
|
||||
Открыл файл zapis1.txt для записи данных
|
||||
```
|
||||
fp=open(file=drkt+'\\zapis1.txt',mode='w')
|
||||
```
|
||||
Проверил наличие открываемого файла:
|
||||
```
|
||||
os.path.isfile(drkt+'\\zapis1.txt')
|
||||
True
|
||||
```
|
||||
Вообще говоря, аргументы функции с их именами могут располагаться в любом порядке. Если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать и просто вводить
|
||||
```
|
||||
fp=open(drkt+'\\zapis1.txt','w')
|
||||
```
|
||||
С помощью функции closed проверил, открыт ли файл(соответственно, если функция возвращает True - файл закрыт, а если False - то открыт). Далее буду использовать этот способ для проверки открытия файла
|
||||
|
||||
```
|
||||
fp.closed
|
||||
False
|
||||
```
|
||||
Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
|
||||
```
|
||||
fp=open('zapis1.txt','w')
|
||||
fp.closed
|
||||
False
|
||||
```
|
||||
Отобразил тип и список атрибутов объекта fp
|
||||
```
|
||||
type(fp)
|
||||
<class '_io.TextIOWrapper'>
|
||||
dir(fp)
|
||||
['_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']
|
||||
```
|
||||
|
||||
Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ «b».
|
||||
```
|
||||
fp1=open(drkt+'\\zapis2.bin',mode='wb+')
|
||||
fp1.closed
|
||||
False
|
||||
```
|
||||
|
||||
### 4.4 Закрытие файла
|
||||
```
|
||||
fp.close()
|
||||
fp.closed
|
||||
True
|
||||
```
|
||||
|
||||
### 4.5 Запись в файл с помощью функции write
|
||||
Рассмотрел пример создания списка и записи его в файл
|
||||
```
|
||||
sps=list(range(1,13))
|
||||
sps
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
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](zapis3.txt) представлено на рис.3
|
||||
Рис. 3:
|
||||
|
||||
|
||||
Следующий пример
|
||||
```
|
||||
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()
|
||||
```
|
||||
Содержимое файла [zapis4.txt](zapis4.txt) представлено на рис.4
|
||||
Рис. 4:
|
||||
|
||||
|
||||
Легко заметить, что информация записана в файл не очень удачно.
|
||||
|
||||
Пробую записать информацию в файл другим способом
|
||||
```
|
||||
gh=open('zapis5.txt','w')
|
||||
for r in sps3:
|
||||
gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
|
||||
12
|
||||
12
|
||||
13
|
||||
gh.close()
|
||||
```
|
||||
|
||||
Содержимое файла [zapis5.txt](zapis5.txt) представлено на рис.5
|
||||
Рис. 5:
|
||||
|
||||
|
||||
Представил цикл в одной строке:
|
||||
```
|
||||
gh=open('zapis5.txt','w')
|
||||
for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
|
||||
12
|
||||
12
|
||||
13
|
||||
gh.close()
|
||||
```
|
||||
После выполнения цикла содержимое файла такое же, как было
|
||||
|
||||
|
||||
### 4.6 Чтений информации из текстового файла: Способ Первый
|
||||
|
||||
Прочитал информацию из созданного ранее файла zapis3.txt
|
||||
```
|
||||
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']
|
||||
```
|
||||
Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется символ конца строки, а с помощью метода replace – скобки.
|
||||
Видно, что полученный список отличается от исходного sps, в первую очередь, типом данных
|
||||
Преобразовать sps1 в sps можно, например, так:
|
||||
```
|
||||
sps2 = [int(i.strip()) for i in sps1]
|
||||
sps2
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
```
|
||||
|
||||
### 4.7 Чтение с помощью метода read
|
||||
|
||||
```
|
||||
fp=open('zapis3.txt')
|
||||
stroka1=fp.read(12)
|
||||
stroka2=fp.read()
|
||||
fp.close()
|
||||
stroka1
|
||||
'[1, 2, 3, 4]'
|
||||
stroka2
|
||||
'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
|
||||
```
|
||||
|
||||
### 4.8 Самостоятельно изучил чтение информации с помощью методов readline и readlines
|
||||
```
|
||||
fp=open('zapis3.txt')
|
||||
stroka3=fp.readline()
|
||||
stroka3
|
||||
'[1, 2, 3, 4]\n'
|
||||
stroka4=fp.readline()
|
||||
stroka4
|
||||
'[5, 6, 7, 8]\n'
|
||||
strokaAll=fp.readlines()
|
||||
strokaAll
|
||||
['[9, 10, 11, 12]\n']
|
||||
fp.close()
|
||||
fp=open('zapis3.txt')
|
||||
strokaAll=fp.readlines()
|
||||
strokaAll
|
||||
['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
|
||||
```
|
||||
|
||||
### 4.9 Ввод-вывод с помощью модуля pickle
|
||||
Пример этого способа работы с файлами
|
||||
```
|
||||
import pickle
|
||||
mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
fp=open('zapis6.mnz','wb')
|
||||
fp.closed
|
||||
False
|
||||
pickle.dump(mnoz1,fp)
|
||||
fp.close()
|
||||
```
|
||||
|
||||
Теперь прочитаю из файла zapis6.mnz
|
||||
```
|
||||
fp=open('zapis6.mnz','rb')
|
||||
mnoz2=pickle.load(fp)
|
||||
fp.close()
|
||||
mnoz2
|
||||
{'book', 'pen', 'table', 'iPhone'}
|
||||
mnoz1 == mnoz2
|
||||
True
|
||||
```
|
||||
Как можно заметить, визуально файлы отличаются, но проверка на совпадение выдаёт результат True
|
||||
mnoz2 не совпадает с тем, что было задано, потому что это множество. Оно исключает повторяющиеся элементы, оставляя только один, а еще не содержит конкретный порядок элементов. Но два множества равны, если у них равны все элементы и их одинаковое количество, вне зависимости от порядка, так что сравнение возвращает True.
|
||||
|
||||
А теперь с использованием тех же функций запишите в файл, а затем прочитайте два объекта разных типов: то же множество mnoz1 и ранее созданный список sps3.
|
||||
```
|
||||
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', 'pen', 'table', 'iPhone'}, [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]])
|
||||
obj1 == mnoz1
|
||||
True
|
||||
obj2 == sps3
|
||||
True
|
||||
```
|
||||
Убедился в совпадении прочитанных данных с введёнными
|
||||
|
||||
|
||||
## Пункт 5. Перенаправление потоков ввода и вывода
|
||||
Пример 1
|
||||
```
|
||||
vr_out=sys.stdoutmnoz1
|
||||
fc=open('Stroka.txt','w')
|
||||
sys.stdout=fc
|
||||
print('запись строки в файл')
|
||||
sys.stdout=vr_out
|
||||
print('запись строки на экран')
|
||||
запись строки на экран
|
||||
fc.close()
|
||||
```
|
||||
В результате получаю файл [Stroka.txt](Stroka.txt) со следующим содержанием
|
||||
Рис. 6:
|
||||
|
||||
|
||||
Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
|
||||
|
||||
```
|
||||
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
|
||||
Закончил сеанс работы с IDLE
|
||||
|
||||
@ -0,0 +1,87 @@
|
||||
# Общее контрольное задание по Теме 6
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
• Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
|
||||
|
||||
• Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
|
||||
|
||||
• Записывается кортеж в бинарный файл.
|
||||
|
||||
• Записывается в этот же файл список и закрывается файл.
|
||||
|
||||
• Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
|
||||
|
||||
• Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
|
||||
|
||||
• Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде отдельных списков со своими именами.
|
||||
|
||||
### Выполнение
|
||||
|
||||
Скрипт для выполнения OKZ в файле [TaskCode.py](TaskCode.py)
|
||||
|
||||
Создание необходимого кортежа
|
||||
```
|
||||
import random as rn
|
||||
kort = []
|
||||
for i in range(125): kort.append(str(rn.choice(range(6,57))))
|
||||
|
||||
kort
|
||||
['34', '35', '31', '40', '51', '53', '18', '19', '42', '51', '18', '16', '20', '56', '21', '37', '29', '19', '22', '48', '31', '47', '40', '42', '51', '28', '20', '36', '37', '33', '14', '21', '9', '24', '16', '46', '38', '15', '37', '49', '48', '21', '45', '10', '55', '7', '33', '53', '42', '31', '56', '32', '8', '53', '7', '20', '45', '52', '11', '52', '28', '18', '8', '30', '30', '17', '36', '25', '47', '44', '25', '40', '27', '18', '20', '12', '53', '30', '20', '45', '17', '12', '21', '36', '45', '32', '30', '7', '48', '36', '12', '10', '30', '19', '19', '30', '12', '42', '52', '9', '55', '44', '22', '6', '38', '27', '27', '38', '55', '41', '52', '16', '6', '16', '43', '30', '33', '18', '12', '28', '29', '29', '28', '11', '6']
|
||||
kort = tuple(kort)
|
||||
kort
|
||||
('34', '35', '31', '40', '51', '53', '18', '19', '42', '51', '18', '16', '20', '56', '21', '37', '29', '19', '22', '48', '31', '47', '40', '42', '51', '28', '20', '36', '37', '33', '14', '21', '9', '24', '16', '46', '38', '15', '37', '49', '48', '21', '45', '10', '55', '7', '33', '53', '42', '31', '56', '32', '8', '53', '7', '20', '45', '52', '11', '52', '28', '18', '8', '30', '30', '17', '36', '25', '47', '44', '25', '40', '27', '18', '20', '12', '53', '30', '20', '45', '17', '12', '21', '36', '45', '32', '30', '7', '48', '36', '12', '10', '30', '19', '19', '30', '12', '42', '52', '9', '55', '44', '22', '6', '38', '27', '27', '38', '55', '41', '52', '16', '6', '16', '43', '30', '33', '18', '12', '28', '29', '29', '28', '11', '6')
|
||||
```
|
||||
Создание списка
|
||||
```
|
||||
spis = ['Hodyuk','Timoshenko','Kovalenko','Lykova','Ivanov']
|
||||
```
|
||||
Открытие бинарного файла [TestDan.mnz](TestDan.mnz) и запись в него кортежа и списка, после чего закрытие файла(атрибутом .closed роисходит проверка на то,удалось ли программе открыть файл)
|
||||
```
|
||||
fp = open('TestDan.mnz','wb')
|
||||
fp.closed
|
||||
False
|
||||
pickle.dump(kort,fp)
|
||||
pickle.dump(spis,fp)
|
||||
fp.close()
|
||||
fp.closed
|
||||
True
|
||||
```
|
||||
Открытие файла для чтения из него в новые объекты данных, записанных в него
|
||||
```
|
||||
fp = open('TestDan.mnz','rb')
|
||||
kort1=pickle.load(fp)
|
||||
spis1=pickle.load(fp)
|
||||
kort1
|
||||
('34', '35', '31', '40', '51', '53', '18', '19', '42', '51', '18', '16', '20', '56', '21', '37', '29', '19', '22', '48', '31', '47', '40', '42', '51', '28', '20', '36', '37', '33', '14', '21', '9', '24', '16', '46', '38', '15', '37', '49', '48', '21', '45', '10', '55', '7', '33', '53', '42', '31', '56', '32', '8', '53', '7', '20', '45', '52', '11', '52', '28', '18', '8', '30', '30', '17', '36', '25', '47', '44', '25', '40', '27', '18', '20', '12', '53', '30', '20', '45', '17', '12', '21', '36', '45', '32', '30', '7', '48', '36', '12', '10', '30', '19', '19', '30', '12', '42', '52', '9', '55', '44', '22', '6', '38', '27', '27', '38', '55', '41', '52', '16', '6', '16', '43', '30', '33', '18', '12', '28', '29', '29', '28', '11', '6')
|
||||
spis1
|
||||
['Hodyuk', 'Timoshenko', 'Kovalenko', 'Lykova', 'Ivanov']
|
||||
```
|
||||
Проверка на совпадение новых переменных с записываемыми
|
||||
```
|
||||
if kort1==kort and spis1==spis:
|
||||
print("новые обьекты совпадают с теми, что были записаны в файл")
|
||||
else:
|
||||
print("Ошибка записи или чтения")
|
||||
```
|
||||
|
||||
новые обьекты совпадают с теми, что были записаны в файл
|
||||
```
|
||||
fp.close()
|
||||
```
|
||||
|
||||
Разделение кортежа на совокупность списков по 5 чисел, проверка их наличия в памяти
|
||||
|
||||
```
|
||||
for i in range(len(kort)//5):
|
||||
exec('list' + str(i) + '=' + str(list(kort[i:i+5])))
|
||||
|
||||
|
||||
list1
|
||||
['35', '31', '40', '51', '53']
|
||||
list0
|
||||
['34', '35', '31', '40', '51']
|
||||
list6
|
||||
['18', '19', '42', '51', '18']
|
||||
list25
|
||||
['28', '20', '36', '37', '33']
|
||||
```
|
||||
@ -0,0 +1,123 @@
|
||||
# Индивидуальное контрольное задание по Теме 6
|
||||
Ходюк Максим Романович, А-01-23
|
||||
## Задание, Вариант 12
|
||||
|
||||
M2_12
|
||||
1) Создайте список с 25 случайными элементами, подчиняющимися нормальному распределению с математическим ожиданием -6.7 и стандартным отклонением 1.23. Округлите значения элементов до 3-х знаков после точки.
|
||||
|
||||
2) Из элементов списка с нечетными индексами сформируйте кортеж и запишите его в бинарный файл. Остальные элементы запишите в текстовый файл по одному числу на строке.
|
||||
|
||||
3) Удалите из памяти список и кортеж.
|
||||
|
||||
4) Прочитайте числа из текстового файла с записью их в список. Рассчитайте сумму элементов списка. Отобразите результат расчета по шаблону: " Сумма элементов списка=<значение> единиц". Выводите значение с точностью до одного знака после точки.
|
||||
|
||||
5) Запишите это же сообщение в текстовый файл с именем, совпадающим с именем бинарного файла, и с расширением ТХТ.
|
||||
|
||||
### Выполнение
|
||||
Создание списка:
|
||||
```
|
||||
import random
|
||||
spis=[]
|
||||
for i in range(25):
|
||||
spis.append(round(random.gauss(mu=-6.7,sigma=1.23),3))
|
||||
|
||||
|
||||
spis
|
||||
[-6.301, -8.251, -8.685, -5.54, -4.592, -5.929, -7.139, -5.715, -5.445, -9.013, -7.428, -6.661, -7.014, -5.691, -5.985, -5.061, -5.544, -5.526, -7.975, -7.513, -4.388, -8.961, -4.993, -6.828, -4.873]
|
||||
```
|
||||
Создание кортежа:
|
||||
```
|
||||
kort=()
|
||||
SpisToKort= []
|
||||
for i in range(1,25,2):
|
||||
SpisToKort.append(spis[i])
|
||||
|
||||
|
||||
kort = tuple(SpisToKort)
|
||||
kort
|
||||
(-8.251, -5.54, -5.929, -5.715, -9.013, -6.661, -5.691, -5.061, -5.526, -7.513, -8.961, -6.828)
|
||||
```
|
||||
Запись в файлы [KORT.mnz](KORT.mnz) и [SPIS.txt](SPIS.txt) необходимых данных:
|
||||
```
|
||||
import os
|
||||
os.chdir('D:\\POAS\\Hodyuk\\TEMA6\\')
|
||||
|
||||
fpK=open('KORT.mnz','wb+')
|
||||
import pickle
|
||||
pickle.dump(kort,fpK)
|
||||
fpK.close()
|
||||
fpS=open('SPIS.txt','w')
|
||||
for i in range(0,25,2):
|
||||
fpS.write(str(spis[i])+'\n')
|
||||
|
||||
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
7
|
||||
fpS.close()
|
||||
```
|
||||
|
||||
Удаление списка и кортежа из памяти и проверка наличия:
|
||||
```
|
||||
del spis
|
||||
del kort
|
||||
spis
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#41>", line 1, in <module>
|
||||
spis
|
||||
NameError: name 'spis' is not defined
|
||||
kort
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#42>", line 1, in <module>
|
||||
kort
|
||||
NameError: name 'kort' is not defined
|
||||
```
|
||||
|
||||
Чтение данных из файла [SPIS.txt](SPIS.txt)
|
||||
```
|
||||
fpS=open('SPIS.txt','r')
|
||||
for i in range(0,25,2):
|
||||
chislo= fpS.readline()
|
||||
chislo=chislo.rstrip('\n')
|
||||
chislo=float(chislo)
|
||||
NewSpis.append(chislo)
|
||||
|
||||
|
||||
NewSpis
|
||||
[-6.301, -8.685, -4.592, -7.139, -5.445, -7.428, -7.014, -5.985, -5.544, -7.975, -4.388, -4.993, -4.873]
|
||||
|
||||
fpS.close()
|
||||
```
|
||||
|
||||
Вычисление суммы элементов списка и вывод сообщения с округлением суммы до 1 знака после запятой
|
||||
```
|
||||
summa=sum(NewSpis)
|
||||
summa
|
||||
-80.362
|
||||
|
||||
print(f'Сумма элементов списка = {round(summa,1)} единиц')
|
||||
Сумма элементов списка = -80.4 единиц
|
||||
```
|
||||
|
||||
Вывод того же сообщения в файл [KORT.txt](KORT.txt)
|
||||
```
|
||||
fp = open('KORT.txt','w')
|
||||
import sys
|
||||
vr_out=sys.stdout
|
||||
sys.stdout=fp
|
||||
print(f'Сумма элементов списка = {round(summa,1)} единиц')
|
||||
sys.stdout=vr_out
|
||||
fp.close()
|
||||
```
|
||||
|
||||
|
||||
Двоичный файл не отображается.
Двоичный файл не отображается.
@ -0,0 +1,3 @@
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
@ -0,0 +1 @@
|
||||
Иванов И. 1Петров П. 2Сидоров С. 3
|
||||
@ -0,0 +1,3 @@
|
||||
Иванов И. 1
|
||||
Петров П. 2
|
||||
Сидоров С. 3
|
||||
|
После Ширина: | Высота: | Размер: 15 KiB |
|
После Ширина: | Высота: | Размер: 16 KiB |
Различия файлов скрыты, потому что одна или несколько строк слишком длинны
@ -0,0 +1,83 @@
|
||||
# Общее контрольное задание по Теме 7
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
• Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
|
||||
|
||||
• Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращае-мый результат функции: список с числами элементов выборки в интервалах разбиения.
|
||||
|
||||
• Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
|
||||
### Решение
|
||||
|
||||
#### Пункт 1:
|
||||
```
|
||||
def DelayDevice(x,T):
|
||||
Delayed = x.copy()
|
||||
if T<len(x):
|
||||
Delayed = [0]*T+x[:-T]
|
||||
else:
|
||||
Delayed = [0]*len(x)
|
||||
return Delayed
|
||||
|
||||
import random as rn
|
||||
x = [rn.gauss(3, 1.5) for i in range(40)]
|
||||
x
|
||||
[3.1589137709718664, 0.15786881651624274, 3.655937104939686, 1.3856988790368416, 2.4149579106455343, 3.568139429890449, 0.6502982925728604, 2.1288342216840332, 0.10248162468353073, 5.438586993036432, 1.297796576373099, 3.514772803475419, 0.3936488059210079, 3.3886107922050206, 2.673091880093213, 4.618651491868087, 4.317410501200125, 3.0369790324418533, 2.6505882683872373, 2.526249500767949, 4.45594490411977, 3.0154987709680396, 1.60901116619933, 3.686469689169056, 2.66935184492142, 0.8004068095518924, -0.06600109304723034, 0.8947107481055605, 4.979471939334061, 2.8688993459163132, 1.7797761176870224, 1.1081847381986072, 4.7503090811221185, 5.261889235788347, 2.715216417011531, 4.564748747903588, 2.32931481167102, 5.32068272026709, 3.686288757113939, 3.7262748782542134]
|
||||
y = DelayDevice(x,3)
|
||||
y
|
||||
[0, 0, 0, 3.1589137709718664, 0.15786881651624274, 3.655937104939686, 1.3856988790368416, 2.4149579106455343, 3.568139429890449, 0.6502982925728604, 2.1288342216840332, 0.10248162468353073, 5.438586993036432, 1.297796576373099, 3.514772803475419, 0.3936488059210079, 3.3886107922050206, 2.673091880093213, 4.618651491868087, 4.317410501200125, 3.0369790324418533, 2.6505882683872373, 2.526249500767949, 4.45594490411977, 3.0154987709680396, 1.60901116619933, 3.686469689169056, 2.66935184492142, 0.8004068095518924, -0.06600109304723034, 0.8947107481055605, 4.979471939334061, 2.8688993459163132, 1.7797761176870224, 1.1081847381986072, 4.7503090811221185, 5.261889235788347, 2.715216417011531, 4.564748747903588, 2.32931481167102]
|
||||
```
|
||||
#### Пункт 2:
|
||||
```
|
||||
def histog(Data, NumOfBins):
|
||||
PartIntervals = np.linspace(min(Data),max(Data),NumOfBins+1)
|
||||
Bins = [0]*NumOfBins
|
||||
for x in Data:
|
||||
for i in range(NumOfBins):
|
||||
if PartIntervals[i]<= x < PartIntervals[i+1]:
|
||||
Bins[i] += 1
|
||||
break
|
||||
if x == max(Data):
|
||||
Bins[-1] += 1
|
||||
return Bins, PartIntervals
|
||||
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
|
||||
data = [rn.gauss(rn.random(), rn.random()) for i in range(rn.randint(10,200))]
|
||||
data
|
||||
[0.5378216995683558, 1.1641589082566997, 0.9147103596009363, 0.5776633502983135, 0.2792996433359695, -0.5380463152699617, -0.11398986117548277, 0.464250090411372, -0.1180243219953355, 0.9392621334129809, 0.2602467488731561, 0.11137063002511538, 1.0143704999861716, 0.9405864021219105, 0.30064634170255167, 0.8562856595996535, 0.051083247475117444, 0.34072284772951444, -0.5532354093325268, 0.6866962172012473, 0.8965397875222096, 0.9929453387120099, -0.5953523836268519, 0.8021587960226041, 1.9546837866138094, -0.7424097094091009, -0.0956552481747655, 0.6924390955614415, 1.0250337911920306, 0.8275003913021624, 0.10994750512663758, 0.5289757668604967, 0.26799949912357107, 0.37973524002087466, 1.5113353518207422, 1.1939154246440982, -0.8249955650037828, 1.126892111969929, -1.016215293110937, 0.9759837638837126, 0.6950225161885795, 0.7572837212456087, -0.5265904134149108, 2.457010568216869, 0.44672225119196785, -0.5509641066519938, 0.4696290378726147, 0.8814765811801879, 0.6762491768403642, 0.17190218474929633, 0.8218627371754621, 0.5416170394630445, 0.9114921616592224, 0.3544816188119451, 0.4756829010056257, 0.00782646665602904, 1.2358999602753222, 0.8083393494705281, 1.2588457987982808, 0.805988133090431, 0.16219883634120713, 0.4518205658327258, 0.1599602558137734, 0.5097603200711073, -0.4610511433897865, -0.3819260879741204, 1.5600558952457446, 0.339825431792831, -0.17078684174281955, 0.20058378403870256, 1.0033775253872794, 1.0724613439660726, 0.032684733867573895, -0.7728994174164051, 0.48671452779023466, 0.9724145477348829, 1.135568097372498, 0.7199643203270871, -0.3531333720621094, 1.072205774213457, 0.7677224563206929, 1.0049793264905427, 1.8202742272818593, 1.8932219658939857, 0.6290284540098144, 1.312187448195754, -1.0052240958876464, -0.2512858370869674, 0.5643550634286253, 0.9573448967654771, 0.31651970752940917, 0.9738021341667136, 0.6345303352005807, -1.1491797486267818, 0.7906710751543553, 0.33372584330754596, 0.058350198023357724, 0.9341769987228196, 0.4012483646843851, -0.005374018323411889, 0.744254234579628, 0.12330272842228102, 0.6786227936939597, -0.37632710171874495, 0.9245031060710469, 0.8035701765839196, 2.6078433227329296, 0.07119641031349294, 0.6102599343061698, 0.49953869236728743, 0.5448863221554354, 0.4586548778361403, 0.7942965401929633, 0.31567333732179226, 0.32774877428259147, 0.25933335901074467, 1.0225612714563157, 1.374256108299675, 0.3097228764845623, 0.13431896141567445, 0.924405334005902, -0.22299081295116258, 0.7964179022876605, 1.1184587921307172, 0.779729411597617, 0.8926712397832665, -0.17674282596964386, 0.8829109759002627, 0.8186014299523164, -0.057807379612117044, -0.04785851777817823, 1.2294159898452923, -0.13041631377597987, 0.6675005746749451, 0.9915678237703984]
|
||||
N = int(input('Введите количество интервалов разбиения'))
|
||||
|
||||
Введите количество интервалов разбиения 5
|
||||
import numpy as np
|
||||
bins, partintervals = histog(data,N)
|
||||
plt.hist(data, bins=partintervals)
|
||||
(array([12., 39., 67., 13., 4.]), array([-1.14917975, -0.39777513, 0.35362948, 1.10503409, 1.85643871,
|
||||
2.60784332]), <BarContainer object of 5 artists>)
|
||||
plt.xlabel('Значения выборки')
|
||||
Text(0.5, 0, 'Значения выборки')
|
||||
plt.ylabel('Число элементов')
|
||||
Text(0, 0.5, 'Число элементов')
|
||||
plt.title('Гистограмма выборки')
|
||||
Text(0.5, 1.0, 'Гистограмма выборки')
|
||||
plt.show()
|
||||
print("кол-во элементов в корзинах:", bins)
|
||||
кол-во элементов в корзинах: [12, 39, 67, 13, 4]
|
||||
```
|
||||
Полученный график:
|
||||
|
||||
|
||||
|
||||
#### Пункт 3:
|
||||
```
|
||||
LinRegr = lambda b1,b2,X: b1+b2*X
|
||||
b1 = float(input("Введите коэффициент b1 линейной регрессии: "))
|
||||
Введите коэффициент b1 линейной регрессии: 5
|
||||
b2 = float(input("Введите коэффициент b2 линейной регрессии: "))
|
||||
Введите коэффициент b2 линейной регрессии: 7
|
||||
X = float(input("Введите значение x: "))
|
||||
Введите значение x: 12
|
||||
print(LinRegr(b1,b2,X))
|
||||
89.0
|
||||
```
|
||||
|
||||
@ -0,0 +1,39 @@
|
||||
# Индивидуальное контрольное задание по Теме 7
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
Вариант 5
|
||||
|
||||
Разработайте функцию с 2 аргументами: x и В, реализующую преобразование входного сигна-ла x по формуле: y=0 при -B≤x≤B, y=x - B при x>B, y=x+B при x<-B. Создайте список со 100 значениями входного сигнала х – случайными, нормально распределенными числами с мате-матическим ожиданием 0.5 и дисперсией 25. Для элементов списка с помощью функции рас-считайте список со значениями выходного сигнала y при В=4.5. Записать результаты в тексто-вый файл в виде двух столбцов: хi, yi.
|
||||
### Выполнение
|
||||
Создание функции:
|
||||
```
|
||||
def transform(x,B):
|
||||
y = []
|
||||
for xi in x:
|
||||
if -B<=xi<=B:
|
||||
y.append(0)
|
||||
elif xi>B:
|
||||
y.append(xi-B)
|
||||
else:
|
||||
y.append(xi+B)
|
||||
return y
|
||||
```
|
||||
Создание данных и применение функции
|
||||
```
|
||||
import random as rn
|
||||
import math
|
||||
x = [rn.gauss(0.5,math.sqrt(25)) for i in range(100)]
|
||||
x
|
||||
[0.26397882118320026, 2.5669334322451287, 1.458303017652087, 8.610013575540764, -8.138607057785759, 3.432294826411966, 11.2276125902589, 4.730306952360786, 4.161136447888679, 6.901374205465032, -1.0126061327352323, -1.6125262920643002, 0.9206192155603055, -5.103701726056998, -3.252867614279044, -11.065716944607981, 4.366773668680859, 4.76989751550616, -4.484818214302562, 4.6371364240509685, -12.114476940364137, -3.213637816226469, 2.2020194476802963, -1.0605781700564538, 1.6260043158745168, -7.667450696462312, 10.521122887098112, 2.518672711827453, 2.501786002073765, -4.862413182269662, 0.8355437456938446, 4.191578422423441, 2.8948229334279016, 7.9844076987958505, 4.923356571370169, 9.363777242099875, -1.8133151178346925, -6.240180360161059, -1.7279981467691283, -6.022669361417824, 2.4830020464089855, 10.547024490013719, 9.149740686920369, -0.255190723006106, -0.5421597668067644, -0.859942656635438, 1.9278193949999298, 7.804755032116398, 6.646134977368288, 8.190999570566689, 0.6003283454307713, -0.20593312281412546, -5.197889647622478, 3.8343550269905804, -9.531535689308328, 1.325784085494855, 0.5534870659018295, -7.102874222066001, -13.675762550943762, 3.9636575618555803, -1.749294987934169, 1.2030521567236219, 6.232233252361516, -8.400948358967225, -0.0401645842059255, 7.029215929691404, 11.192892070385724, 6.096802546687919, 6.426480403802853, -9.26147331014739, -1.4716299105736765, -3.1840381441570633, -2.3059280944683342, 6.164419831200721, 5.681731221213691, -0.1669023554988457, -6.081636275522419, 3.3173364492848805, 3.6957709191976957, 10.289002607429847, 3.897251367951322, -9.728289414967538, -0.5357291708806988, -6.635059244643971, 3.4328517368277622, 1.0423563347617755, -0.36800794583401675, 2.6924764746597685, 1.434281875577846, -0.6660585695563244, 8.375208669468924, 0.5656132745209681, 13.852985702287752, 0.3122876528114459, -3.079416106753241, -7.846632087876243, 6.191694931110419, 3.83634269275283, -4.2409001708395815, -0.8595283155417268]
|
||||
y = transform(x,4.5)
|
||||
y
|
||||
[0, 0, 0, 4.110013575540764, -3.6386070577857588, 0, 6.7276125902589, 0.23030695236078635, 0, 2.401374205465032, 0, 0, 0, -0.6037017260569977, 0, -6.565716944607981, 0, 0.2698975155061598, 0, 0.1371364240509685, -7.614476940364137, 0, 0, 0, 0, -3.1674506964623124, 6.021122887098112, 0, 0, -0.3624131822696617, 0, 0, 0, 3.4844076987958505, 0.423356571370169, 4.863777242099875, 0, -1.7401803601610588, 0, -1.5226693614178242, 0, 6.047024490013719, 4.649740686920369, 0, 0, 0, 0, 3.3047550321163977, 2.1461349773682876, 3.6909995705666887, 0, 0, -0.6978896476224783, 0, -5.031535689308328, 0, 0, -2.602874222066001, -9.175762550943762, 0, 0, 0, 1.7322332523615156, -3.9009483589672254, 0, 2.5292159296914036, 6.692892070385724, 1.5968025466879192, 1.9264804038028531, -4.761473310147389, 0, 0, 0, 1.6644198312007212, 1.181731221213691, 0, -1.5816362755224187, 0, 0, 5.789002607429847, 0, -5.228289414967538, 0, -2.135059244643971, 0, 0, 0, 0, 0, 0, 3.8752086694689236, 0, 9.352985702287752, 0, 0, -3.346632087876243, 1.691694931110419, 0, 0, 0]
|
||||
```
|
||||
Запись данных в файл [test_file.txt](test_file.txt):
|
||||
```
|
||||
file = open('test_file.txt','w')
|
||||
if not file.closed:
|
||||
for i in range(100):
|
||||
file.write(f'{x[i]} {y[i]} \n')
|
||||
file.close()
|
||||
```
|
||||
@ -0,0 +1,100 @@
|
||||
0.26397882118320026 0
|
||||
2.5669334322451287 0
|
||||
1.458303017652087 0
|
||||
8.610013575540764 4.110013575540764
|
||||
-8.138607057785759 -3.6386070577857588
|
||||
3.432294826411966 0
|
||||
11.2276125902589 6.7276125902589
|
||||
4.730306952360786 0.23030695236078635
|
||||
4.161136447888679 0
|
||||
6.901374205465032 2.401374205465032
|
||||
-1.0126061327352323 0
|
||||
-1.6125262920643002 0
|
||||
0.9206192155603055 0
|
||||
-5.103701726056998 -0.6037017260569977
|
||||
-3.252867614279044 0
|
||||
-11.065716944607981 -6.565716944607981
|
||||
4.366773668680859 0
|
||||
4.76989751550616 0.2698975155061598
|
||||
-4.484818214302562 0
|
||||
4.6371364240509685 0.1371364240509685
|
||||
-12.114476940364137 -7.614476940364137
|
||||
-3.213637816226469 0
|
||||
2.2020194476802963 0
|
||||
-1.0605781700564538 0
|
||||
1.6260043158745168 0
|
||||
-7.667450696462312 -3.1674506964623124
|
||||
10.521122887098112 6.021122887098112
|
||||
2.518672711827453 0
|
||||
2.501786002073765 0
|
||||
-4.862413182269662 -0.3624131822696617
|
||||
0.8355437456938446 0
|
||||
4.191578422423441 0
|
||||
2.8948229334279016 0
|
||||
7.9844076987958505 3.4844076987958505
|
||||
4.923356571370169 0.423356571370169
|
||||
9.363777242099875 4.863777242099875
|
||||
-1.8133151178346925 0
|
||||
-6.240180360161059 -1.7401803601610588
|
||||
-1.7279981467691283 0
|
||||
-6.022669361417824 -1.5226693614178242
|
||||
2.4830020464089855 0
|
||||
10.547024490013719 6.047024490013719
|
||||
9.149740686920369 4.649740686920369
|
||||
-0.255190723006106 0
|
||||
-0.5421597668067644 0
|
||||
-0.859942656635438 0
|
||||
1.9278193949999298 0
|
||||
7.804755032116398 3.3047550321163977
|
||||
6.646134977368288 2.1461349773682876
|
||||
8.190999570566689 3.6909995705666887
|
||||
0.6003283454307713 0
|
||||
-0.20593312281412546 0
|
||||
-5.197889647622478 -0.6978896476224783
|
||||
3.8343550269905804 0
|
||||
-9.531535689308328 -5.031535689308328
|
||||
1.325784085494855 0
|
||||
0.5534870659018295 0
|
||||
-7.102874222066001 -2.602874222066001
|
||||
-13.675762550943762 -9.175762550943762
|
||||
3.9636575618555803 0
|
||||
-1.749294987934169 0
|
||||
1.2030521567236219 0
|
||||
6.232233252361516 1.7322332523615156
|
||||
-8.400948358967225 -3.9009483589672254
|
||||
-0.0401645842059255 0
|
||||
7.029215929691404 2.5292159296914036
|
||||
11.192892070385724 6.692892070385724
|
||||
6.096802546687919 1.5968025466879192
|
||||
6.426480403802853 1.9264804038028531
|
||||
-9.26147331014739 -4.761473310147389
|
||||
-1.4716299105736765 0
|
||||
-3.1840381441570633 0
|
||||
-2.3059280944683342 0
|
||||
6.164419831200721 1.6644198312007212
|
||||
5.681731221213691 1.181731221213691
|
||||
-0.1669023554988457 0
|
||||
-6.081636275522419 -1.5816362755224187
|
||||
3.3173364492848805 0
|
||||
3.6957709191976957 0
|
||||
10.289002607429847 5.789002607429847
|
||||
3.897251367951322 0
|
||||
-9.728289414967538 -5.228289414967538
|
||||
-0.5357291708806988 0
|
||||
-6.635059244643971 -2.135059244643971
|
||||
3.4328517368277622 0
|
||||
1.0423563347617755 0
|
||||
-0.36800794583401675 0
|
||||
2.6924764746597685 0
|
||||
1.434281875577846 0
|
||||
-0.6660585695563244 0
|
||||
8.375208669468924 3.8752086694689236
|
||||
0.5656132745209681 0
|
||||
13.852985702287752 9.352985702287752
|
||||
0.3122876528114459 0
|
||||
-3.079416106753241 0
|
||||
-7.846632087876243 -3.346632087876243
|
||||
6.191694931110419 1.691694931110419
|
||||
3.83634269275283 0
|
||||
-4.2409001708395815 0
|
||||
-0.8595283155417268 0
|
||||
@ -0,0 +1,2 @@
|
||||
import math
|
||||
MathFunc = lambda x, a, b: math.exp((-(x-a)**2)/b)/((2*math.pi*b)**(0.5))
|
||||
@ -0,0 +1,26 @@
|
||||
import math
|
||||
from IKZMod1 import MathFunc
|
||||
from numpy import arange
|
||||
a = float(input('введите значение константы a: '))
|
||||
b = float(input('введите значение константы b: '))
|
||||
|
||||
LeftBord = a-3*b**(0.5)
|
||||
RightBord = a+3*b**(0.5)
|
||||
Step = 0.2*b**(0.5)
|
||||
|
||||
y = []
|
||||
for x in arange(LeftBord,RightBord,Step):
|
||||
y.append(MathFunc(x, a, b))
|
||||
|
||||
with open('TestFile.txt','w') as file:
|
||||
for i in range(0,len(y),2):
|
||||
if i+1<len(y):
|
||||
file.write(f'{y[i]}, {y[i+1]} \n')
|
||||
else:
|
||||
file.write(f'{y[i]}\n')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,4 @@
|
||||
import MM2
|
||||
print('y =', MM2.vyhod)
|
||||
|
||||
|
||||
@ -0,0 +1,23 @@
|
||||
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
|
||||
|
||||
|
||||
@ -0,0 +1,24 @@
|
||||
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)
|
||||
|
||||
@ -1,9 +1,10 @@
|
||||
#Модуль Mod0
|
||||
import Mod1
|
||||
print('perm1=',Mod1.perm1)
|
||||
from Mod2 import alpha as al
|
||||
tt=al()
|
||||
print('tt=',tt)
|
||||
from Mod2 import beta
|
||||
qq=beta(float(tt))
|
||||
print('qq=',qq)
|
||||
#Модуль Mod0
|
||||
import Mod1
|
||||
print('perm1=',Mod1.perm1)
|
||||
from Mod2 import alpha as al
|
||||
tt=al()
|
||||
print('tt=',tt)
|
||||
from Mod2 import beta
|
||||
qq=beta(float(tt))
|
||||
print('qq=',qq)
|
||||
|
||||
|
||||
@ -1,2 +1,2 @@
|
||||
perm1=input('Mod1:Введите значение = ')
|
||||
print('Mod1:Значение perm1=',perm1)
|
||||
perm1=input('Mod1:Введите значение = ')
|
||||
print('Mod1:Значение perm1=',perm1)
|
||||
|
||||
@ -1,11 +1,9 @@
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
print('****BETA****')
|
||||
import math
|
||||
expi=q*math.pi
|
||||
return math.exp(expi)
|
||||
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
import math
|
||||
expi=q*math.pi
|
||||
return math.exp(expi)
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
def ReadFile(file):
|
||||
Spis = []
|
||||
with open(file) as fl:
|
||||
for line in fl:
|
||||
Spis.extend(map(float,line.split()))
|
||||
return Spis
|
||||
|
||||
@ -0,0 +1,14 @@
|
||||
import statistics as st
|
||||
def CalcCorr(s1,s2):
|
||||
n = min(len(s1),len(s2))
|
||||
mean1 = st.mean(s1)
|
||||
mean2 = st.mean(s2)
|
||||
cov = sum((s1i - mean1) * (s2i - mean2) for s1i, s2i in zip(s1, s2)) / n
|
||||
stdS1 = st.stdev(s1)
|
||||
stdS2 = st.stdev(s2)
|
||||
if stdS1 == 0 or stdS2 == 0:
|
||||
return 0
|
||||
return cov/(stdS1*stdS2)
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,12 @@
|
||||
from ModOKZ1 import ReadFile
|
||||
from ModOKZ2 import CalcCorr
|
||||
|
||||
file1 = input('Введите имя первого файла: ')
|
||||
file2 = input('Введите имя второго файла: ')
|
||||
|
||||
spis1 = ReadFile(file1)
|
||||
spis2 = ReadFile(file2)
|
||||
|
||||
if not(spis1 == []) and not(spis2 == []):
|
||||
print(f'Коэффициент корреляции: {CalcCorr(spis1,spis2)}')
|
||||
|
||||
@ -0,0 +1,16 @@
|
||||
2.099318746451056e-05, 6.69668672647875e-05
|
||||
0.00019719596463353917, 0.0005360342073088022
|
||||
0.0013450654850770993, 0.003115665271240636
|
||||
0.006662152960521624, 0.013150275377486781
|
||||
0.02396136399563107, 0.04030367676515082
|
||||
0.06257980984579728, 0.08969748220957399
|
||||
0.11868141280309415, 0.14495780494004476
|
||||
0.1634394686817576, 0.17010955993225252
|
||||
0.16343946868175718, 0.14495780494004407
|
||||
0.11868141280309329, 0.08969748220957313
|
||||
0.06257980984579653, 0.040303676765150245
|
||||
0.023961363995630612, 0.01315027537748653
|
||||
0.006662152960521497, 0.0031156652712405583
|
||||
0.00134506548507706, 0.0005360342073087869
|
||||
0.00019719596463353375, 6.696686726478525e-05
|
||||
2.0993187464509702e-05
|
||||
Различия файлов скрыты, потому что одна или несколько строк слишком длинны
@ -0,0 +1,79 @@
|
||||
# Общее контрольное задание по Теме 8
|
||||
Ходюк Максим Романович
|
||||
## Задание
|
||||
Разработайте программу, состоящую из трех модулей:
|
||||
|
||||
- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
|
||||
|
||||
- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
|
||||
|
||||
- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
|
||||
|
||||
Подготовьте два текстовых файла с числовыми данными и проверьте по ним работу программы.
|
||||
|
||||
### Выполнение
|
||||
Содержание файла [ModOKZ1.py](ModOKZ1.py):
|
||||
```
|
||||
def ReadFile(file):
|
||||
Spis = []
|
||||
with open(file) as fl:
|
||||
for line in fl:
|
||||
Spis.extend(map(float,line.split()))
|
||||
return Spis
|
||||
|
||||
```
|
||||
|
||||
Содержание файла [ModOKZ2.py](ModOKZ2.py):
|
||||
```
|
||||
import statistics as st
|
||||
def CalcCorr(s1,s2):
|
||||
n = min(len(s1),len(s2))
|
||||
mean1 = st.mean(s1)
|
||||
mean2 = st.mean(s2)
|
||||
cov = sum((s1i - mean1) * (s2i - mean2) for s1i, s2i in zip(s1, s2)) / n
|
||||
stdS1 = st.stdev(s1)
|
||||
stdS2 = st.stdev(s2)
|
||||
if stdS1 == 0 or stdS2 == 0:
|
||||
return 0
|
||||
return cov/(stdS1*stdS2)
|
||||
```
|
||||
|
||||
Содержание файла [ModOKZ3.py](ModOKZ3.py):
|
||||
```
|
||||
from ModOKZ1 import ReadFile
|
||||
from ModOKZ2 import CalcCorr
|
||||
|
||||
file1 = input('Введите имя первого файла: ')
|
||||
file2 = input('Введите имя второго файла: ')
|
||||
|
||||
spis1 = ReadFile(file1)
|
||||
spis2 = ReadFile(file2)
|
||||
|
||||
if not(spis1 == []) and not(spis2 == []):
|
||||
print(f'Коэффициент корреляции: {CalcCorr(spis1,spis2)}')
|
||||
```
|
||||
|
||||
Содержание текстовых файлов с данными:
|
||||
[testdata1.txt](testdata1.txt)
|
||||
```
|
||||
10.0 9.5 9.0 8.5 8.0
|
||||
7.5 3.2 6.5
|
||||
```
|
||||
|
||||
[testdata2.txt](testdata2.txt)
|
||||
```
|
||||
10.0 9.5 9.0 8.5 8.0
|
||||
7.5 3.2 6.5
|
||||
```
|
||||
|
||||
Вызов программы:
|
||||
```
|
||||
import os
|
||||
os.chdir('D:\\POAS\\Hodyuk\\Tema8\\')
|
||||
import ModOKZ3
|
||||
Введите имя первого файла: testdata1.txt
|
||||
Введите имя второго файла: testdata2.txt
|
||||
Коэффициент корреляции: -0.4838833004874475
|
||||
```
|
||||
|
||||
|
||||
@ -0,0 +1,67 @@
|
||||
# Индивидуальное контрольное задание по Теме 8
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
Вариант 12
|
||||
|
||||
По указанному преподавателем варианту контрольного задания обратитесь к индивидуально-му заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Со-здайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
|
||||
|
||||
Разработайте анонимную функцию с 3 аргументами: х, a, b, вычисляющую значение exp(-(x-a)2/b)/(2*π*b)1/2. Рассчитайте значения функции в диапазоне значений х от a-3*b1/2 до a+3*b1/2 с шагом 0.2*b1/2 и запишите эти значения в текстовый файл по два значения на строке, разде-ленных запятыми.
|
||||
|
||||
### Выполнение
|
||||
Создал модуль с функцией MathFunc - [IKZMod1.py](IKZMod1.py) со следующим содержанием:
|
||||
```
|
||||
import math
|
||||
MathFunc = lambda x, a, b: math.exp((-(x-a)**2)/b)/((2*math.pi*b)**(0.5))
|
||||
```
|
||||
|
||||
Создал модуль с выполнением оставшейся части задания - [IKZMod2.py](IKZMod2.py):
|
||||
```
|
||||
import math
|
||||
from IKZMod1 import MathFunc
|
||||
from numpy import arange
|
||||
a = float(input('введите значение константы a: '))
|
||||
b = float(input('введите значение константы b: '))
|
||||
|
||||
LeftBord = a-3*b**(0.5)
|
||||
RightBord = a+3*b**(0.5)
|
||||
Step = 0.2*b**(0.5)
|
||||
|
||||
y = []
|
||||
for x in arange(LeftBord,RightBord,Step):
|
||||
y.append(MathFunc(x, a, b))
|
||||
|
||||
with open('TestFile.txt','w') as file:
|
||||
for i in range(0,len(y),2):
|
||||
if i+1<len(y):
|
||||
file.write(f'{y[i]}, {y[i+1]} \n')
|
||||
else:
|
||||
file.write(f'{y[i]}\n')
|
||||
|
||||
```
|
||||
|
||||
Вызов программы:
|
||||
```
|
||||
import IKZMod2
|
||||
введите значение константы a: 13.2
|
||||
введите значение константы b: 5.5
|
||||
```
|
||||
|
||||
Содержание текстового файла [TestFile.txt](TestFile.txt) после выполнения программы:
|
||||
```
|
||||
2.099318746451056e-05, 6.69668672647875e-05
|
||||
0.00019719596463353917, 0.0005360342073088022
|
||||
0.0013450654850770993, 0.003115665271240636
|
||||
0.006662152960521624, 0.013150275377486781
|
||||
0.02396136399563107, 0.04030367676515082
|
||||
0.06257980984579728, 0.08969748220957399
|
||||
0.11868141280309415, 0.14495780494004476
|
||||
0.1634394686817576, 0.17010955993225252
|
||||
0.16343946868175718, 0.14495780494004407
|
||||
0.11868141280309329, 0.08969748220957313
|
||||
0.06257980984579653, 0.040303676765150245
|
||||
0.023961363995630612, 0.01315027537748653
|
||||
0.006662152960521497, 0.0031156652712405583
|
||||
0.00134506548507706, 0.0005360342073087869
|
||||
0.00019719596463353375, 6.696686726478525e-05
|
||||
2.0993187464509702e-05
|
||||
```
|
||||
@ -0,0 +1,3 @@
|
||||
1.2 1.0 5.0 7.3 8.3
|
||||
6.0 7.5 3.5 3.1
|
||||
|
||||
@ -0,0 +1,2 @@
|
||||
10.0 9.5 9.0 8.5 8.0
|
||||
7.5 3.2 6.5
|
||||
|
После Ширина: | Высота: | Размер: 14 KiB |
|
После Ширина: | Высота: | Размер: 54 KiB |
|
После Ширина: | Высота: | Размер: 51 KiB |
|
После Ширина: | Высота: | Размер: 52 KiB |
@ -0,0 +1,8 @@
|
||||
import M2
|
||||
import pickle
|
||||
result_signal = M2.M1_execution()
|
||||
|
||||
name = input("Введите имя бинарного файла, в который хотите записать полученный сигнал: ")
|
||||
with open(name,'wb') as file:
|
||||
pickle.dump(result_signal,file)
|
||||
|
||||
@ -0,0 +1,22 @@
|
||||
import matplotlib.pyplot as plt
|
||||
def func1(sps,vh):
|
||||
i = len(sps) - 1
|
||||
while True:
|
||||
value = (vh - sps[i] * 8) / 9
|
||||
sps.append(value)
|
||||
i+=1
|
||||
if abs(sps[i]-sps[i-1])< 0.05:
|
||||
break
|
||||
return sps
|
||||
|
||||
def func2(sps):
|
||||
"""
|
||||
Функция 2: отображает график сигнала
|
||||
"""
|
||||
plt.figure(figsize=(10, 6))
|
||||
plt.plot(sps, linewidth=2, markersize=5)
|
||||
plt.xlabel('Номер отсчета (i)', fontsize=12)
|
||||
plt.ylabel('Значение SPS[i]', fontsize=12)
|
||||
plt.title('График выходного сигнала системы', fontsize=14)
|
||||
plt.grid(True, alpha=0.3)
|
||||
plt.show()
|
||||
@ -0,0 +1,18 @@
|
||||
import M1
|
||||
def M1_execution():
|
||||
|
||||
sps = [0]
|
||||
while True:
|
||||
|
||||
zn = float(input('Введите требуемое значение на выходе системы: '))
|
||||
if zn==0:
|
||||
print('Было введено zn = 0. Завершение работы модуля M2')
|
||||
break
|
||||
|
||||
result = M1.func1(sps.copy(), zn)
|
||||
|
||||
print(f'Итоговый список: \n{result}')
|
||||
|
||||
M1.func2(result)
|
||||
|
||||
return result
|
||||
@ -0,0 +1,29 @@
|
||||
import os
|
||||
os.chdir('D:\\POAS\\Hodyuk\\Tema9\\')
|
||||
|
||||
from Sotrudniki import Sotrudniki
|
||||
|
||||
sot1 = Sotrudniki("Пронин А.Д", "Кафедра Управления и информационных технологий", "Ассистент",60000)
|
||||
sot2 = Sotrudniki("Бирюков А.М.", "Кафедра Математического и компьютерного моделирования", "Доцент", 75000)
|
||||
|
||||
|
||||
print("=== НАЧАЛЬНЫЕ ДАННЫЕ ===")
|
||||
print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
|
||||
print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
|
||||
|
||||
print("\n=== ОПЕРАЦИИ С СОТРУДНИКАМИ ===")
|
||||
|
||||
sot2.salary_raise(20000)
|
||||
sot1.change_department("Кафедра Математического и компьютерного моделирования")
|
||||
sot1.change_position("Старший преподаватель")
|
||||
sot2.add_pooshrenie("За преданность делу")
|
||||
sot1.add_pooshrenie("За создание позитивной атмосферы")
|
||||
|
||||
print("\n=== ИТОГОВЫЕ ДАННЫЕ ===")
|
||||
|
||||
print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
|
||||
print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
|
||||
|
||||
print("\n=== ПЕРЕЧЕНЬ ПООЩРЕНИЙ ===")
|
||||
print(f"Поощрения {sot1.fio}: {sot1.pooshrenia}")
|
||||
print(f"Поощрения {sot2.fio}: {sot2.pooshrenia}")
|
||||
@ -0,0 +1,10 @@
|
||||
class Class1: #Объявление класса Class1 в модуле
|
||||
def zad_zn(self,znach): # 1 Метод класса
|
||||
self.data=znach # self - ссылка на экземпляр класса Class1
|
||||
def otobrazh(self): # 2 Метод класса
|
||||
print(self.data)#Отображение данных экземпляра
|
||||
class Class2(Class1): #Class2 - наследник класса Class1
|
||||
def otobrazh(self): # Метод класса Class2
|
||||
print('значение=',self.data)#Отображение данных экземпляра
|
||||
def otobrazh(objekt): #Объявление самостоятельной функции
|
||||
print('значение объекта=',objekt)
|
||||
@ -0,0 +1,21 @@
|
||||
class SAU:
|
||||
def __init__(self,zn_param):
|
||||
self.param=zn_param
|
||||
self.ypr=[0,0]
|
||||
|
||||
def zdn_zn(self,upr):
|
||||
self.x=upr
|
||||
|
||||
def model(self):
|
||||
def inerz(x,T,yy):
|
||||
return (x+T*yy)/(T+1)
|
||||
|
||||
y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
|
||||
y1=self.param[0]*y0 #Усилитель1
|
||||
y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
|
||||
y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
|
||||
self.ypr[0]=y2
|
||||
self.ypr[1]=y3
|
||||
|
||||
def otobraz(self):
|
||||
print('y=',self.ypr[1])
|
||||
@ -0,0 +1,30 @@
|
||||
class Sotrudniki:
|
||||
def __init__(self, fio, otdel, dolzhnost, oklad):
|
||||
self.fio = fio
|
||||
self.otdel = otdel
|
||||
self.dolzhnost = dolzhnost
|
||||
self.oklad = oklad
|
||||
self._pooshrenia = []
|
||||
|
||||
def salary_raise(self, summa):
|
||||
if summa > 0:
|
||||
self.oklad += summa
|
||||
print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
|
||||
else:
|
||||
print("Сумма для повышения оклада должна быть больше нуля.")
|
||||
|
||||
def change_department(self, new_department):
|
||||
print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
|
||||
self.otdel = new_department
|
||||
|
||||
def change_position(self, new_position):
|
||||
print(f"Должность сотрудника {self.fio} изменена с {self.dolzhnost} на {new_position}.")
|
||||
self.dolzhnost = new_position
|
||||
|
||||
@property
|
||||
def pooshrenia(self):
|
||||
return self._pooshrenia
|
||||
|
||||
def add_pooshrenie(self, tekst):
|
||||
self._pooshrenia.append(tekst)
|
||||
print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")
|
||||
@ -0,0 +1,253 @@
|
||||
# Отчёт к Теме 9
|
||||
Ходюк Максим Романович, А-01-23
|
||||
## Пункт 1
|
||||
Запустил интерактивную оболочку IDLE и выставил рабочий каталог
|
||||
```
|
||||
import os,sys,importlib as imp
|
||||
os.chdir('D:\\POAS\\Hodyuk\\Tema9\\')
|
||||
```
|
||||
## Пункт 2
|
||||
### 2.1. Создание автономного класса
|
||||
Создал класс , содержащий 2 функции, реализующие его методы
|
||||
```
|
||||
class Class1: #Объявление класса
|
||||
def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
|
||||
self.data=znach # self - ссылка на экземпляр класса
|
||||
def otobrazh(self): # Метод 2 класса1
|
||||
print(self.data)#Отображение данных экземпляра класса
|
||||
```
|
||||
Создал 2 экземпляра этого класса и задал разные значения атрибута у двух экземпляра:
|
||||
```
|
||||
z1=Class1()
|
||||
z2=Class1()
|
||||
z1.zad_zn('экз.класса 1')
|
||||
z2.zad_zn(-632.453)
|
||||
z1.otobrazh()
|
||||
экз.класса 1
|
||||
z2.otobrazh()
|
||||
-632.453
|
||||
z1.data='Новое значение атрибута у экз.1'
|
||||
z1.otobrazh()
|
||||
Новое значение атрибута у экз.1
|
||||
```
|
||||
|
||||
### 2.2. Создание класса-наследника
|
||||
В объявлении класса после его имени в скобках перечисляются его «родительские классы»
|
||||
```
|
||||
class Class2(Class1): #Class2 - наследник класса Class1
|
||||
def otobrazh(self): # Метод класса Class2 – переопределяет метод родителя
|
||||
print('значение=',self.data)#Отображение данных экземпляра
|
||||
```
|
||||
Создаю экземпляр второго класса и смотрю список его атрибутов:
|
||||
```
|
||||
z3=Class2()
|
||||
dir(z3)
|
||||
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
|
||||
z3.zad_zn('Совсем новое')
|
||||
z3.otobrazh()
|
||||
значение= Совсем новое
|
||||
```
|
||||
Сработал метод класса Class2
|
||||
|
||||
|
||||
```
|
||||
z1.otobrazh()
|
||||
Новое значение атрибута у экз.1
|
||||
del z1,z2,z3
|
||||
```
|
||||
Значение у объекта z1 не изменилось
|
||||
|
||||
## Пункт 3
|
||||
Создал модуль с именем [Mod3.py](Mod3.py)
|
||||
|
||||
Импортирую первый класс из модуля и выполняю инструкцию
|
||||
```
|
||||
from Mod3 import Class1
|
||||
z4=Class1()
|
||||
z4.otobrazh()
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#22>", line 1, in <module>
|
||||
z4.otobrazh()
|
||||
File "D:\POAS\Hodyuk\Tema9\Mod3.py", line 5, in otobrazh
|
||||
print(self.data)#Отображение данных экземпляра
|
||||
AttributeError: 'Class1' object has no attribute 'data'
|
||||
```
|
||||
Инструкция выдаёт ошибку, так как до вызова функции zad_zn у класса не существует объекта data
|
||||
|
||||
Пробую сделать так:
|
||||
```
|
||||
from Mod3 import Class1
|
||||
z4=Class1()
|
||||
z4.data='значение данного data у экз.4'
|
||||
z4.otobrazh()
|
||||
значение данного data у экз.4
|
||||
del z4
|
||||
```
|
||||
После удаления экземпляра z4 и импортирую модуль целиком
|
||||
```
|
||||
import Mod3
|
||||
z4=Mod3.Class2()
|
||||
z4.zad_zn('Класс из модуля')
|
||||
z4.otobrazh()
|
||||
значение= Класс из модуля
|
||||
Mod3.otobrazh('Объект')
|
||||
значение объекта= Объект
|
||||
```
|
||||
Разница в том, что в первом случае я импортирую только Class1, и создаю экземпляр именно Class1, а во втором импортирую весь модуль, и создаю экземпляр Class2, а далее я вызываю отдельную функцию из модуля
|
||||
|
||||
## Пункт 4
|
||||
Использование специальных методом
|
||||
Создаю класс, содержащий 2 специальных метода
|
||||
```
|
||||
class Class3(Class2): #Наследник класса Class2, а через него – и класса Class1
|
||||
def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
|
||||
self.data=znach
|
||||
def __add__(self,drug_zn): #Вызывается, когда экземпляр участвует в операции «+»
|
||||
return Class3(self.data+drug_zn)
|
||||
def zad_dr_zn(self,povtor): #А это - обычный метод
|
||||
self.data*=povtor
|
||||
```
|
||||
Метод __add__ - это один из методов, осуществляющих так называемую «перегрузку» операто-ров.
|
||||
Создаю экземпляр класса Class3 и отображаю его
|
||||
```
|
||||
z5=Class3('abc')
|
||||
z5.otobrazh()
|
||||
значение= abc
|
||||
z6=z5+'def'
|
||||
z6.otobrazh()
|
||||
значение= abcdef
|
||||
z6.zad_dr_zn(3)
|
||||
z6.otobrazh()
|
||||
значение= abcdefabcdefabcdef
|
||||
```
|
||||
## Пункт 5
|
||||
Присоединение атрибутов к классу
|
||||
|
||||
Вывожу список атрибутов класса
|
||||
```
|
||||
dir(Class3)
|
||||
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
|
||||
Class3.fio='Иванов И.И.'
|
||||
dir(Class3)
|
||||
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
|
||||
```
|
||||
Убедился в том, что после задания нового атрибута класса он появился при выполнении функции dir
|
||||
Создаю новый экземпляр
|
||||
```
|
||||
z7=Class3(123)
|
||||
dir(z7)==dir(Class3)
|
||||
False
|
||||
z7.fio
|
||||
'Иванов И.И.'
|
||||
z7.rozden='1987'
|
||||
dir(z7)
|
||||
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
|
||||
dir(Class3)
|
||||
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
|
||||
```
|
||||
В объекте z7 появился атрибут rozden, а у Class3 нет
|
||||
|
||||
## Пункт 6
|
||||
Выявление родительских классов
|
||||
|
||||
Проверяю родительские классы для Class3, Class2 и Class1
|
||||
```
|
||||
Class3.__bases__
|
||||
(<class '__main__.Class2'>,)
|
||||
Class2.__bases__
|
||||
(<class '__main__.Class1'>,)
|
||||
Class1.__bases__
|
||||
(<class 'object'>,)
|
||||
```
|
||||
Получение полной цепочки наследования:
|
||||
```
|
||||
Class3.__mro__
|
||||
(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
|
||||
ZeroDivisionError.__mro__
|
||||
(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
|
||||
```
|
||||
|
||||
## Пункт 7
|
||||
Создание свойства класса
|
||||
Создаю класс с определённым в нём свойством
|
||||
```
|
||||
class Class4:
|
||||
def __init__(sam,znach):
|
||||
sam.__prm=znach
|
||||
def chten(sam):
|
||||
return sam.__prm
|
||||
def zapis(sam,znch):
|
||||
sam.__prm=znch
|
||||
def stiran(sam):
|
||||
del sam.__prm
|
||||
svojstvo=property(chten,zapis,stiran)
|
||||
```
|
||||
|
||||
Пробую некоторые операции с этим свойством
|
||||
```
|
||||
exempl=Class4(12)
|
||||
exempl.svojstvo
|
||||
12
|
||||
exempl.svojstvo=45
|
||||
print(exempl.svojstvo)
|
||||
45
|
||||
del exempl.svojstvo
|
||||
exempl.svojstvo
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#61>", line 1, in <module>
|
||||
exempl.svojstvo
|
||||
File "<pyshell#55>", line 5, in chten
|
||||
return sam.__prm
|
||||
AttributeError: 'Class4' object has no attribute '_Class4__prm'
|
||||
```
|
||||
Ошибка возникает потому, что мы удаляем все атрибуты обьекта exempl, а после пытаемся вывести значение __prm, которое не задаём заново
|
||||
|
||||
Создаю модуль [SAU.py](SAU.py)
|
||||
|
||||
Тестирую этот класс с помощью следующей программы:
|
||||
```
|
||||
prm=[2.5,4,1.3,0.8]
|
||||
from SAU import *
|
||||
xx=[0]+[1]*20
|
||||
SAUe=SAU(prm)
|
||||
|
||||
yt=[]
|
||||
for xt in xx: # Прохождение входного сигнала
|
||||
SAUe.zdn_zn(xt)
|
||||
SAUe.model()
|
||||
SAUe.otobraz()
|
||||
yt.append(SAUe.ypr[1])
|
||||
|
||||
y= 0.0
|
||||
y= 0.2173913043478261
|
||||
y= 0.4763705103969754
|
||||
y= 0.686594887811293
|
||||
y= 0.8199324616478645
|
||||
y= 0.8837201137353929
|
||||
y= 0.8994188484874774
|
||||
y= 0.8892777072047301
|
||||
y= 0.870097963179993
|
||||
y= 0.8518346102696789
|
||||
y= 0.8387499784485772
|
||||
y= 0.8314204114211459
|
||||
y= 0.8286051955249649
|
||||
y= 0.8285656555914835
|
||||
y= 0.8297915186846528
|
||||
y= 0.8312697736438287
|
||||
y= 0.8324765218921963
|
||||
y= 0.8332456979978418
|
||||
y= 0.8336163607592184
|
||||
y= 0.8337101315489143
|
||||
y= 0.833654237067147
|
||||
import pylab
|
||||
pylab.plot(yt)
|
||||
[<matplotlib.lines.Line2D object at 0x000001F6E6DB2710>]
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
Полученный график:
|
||||
|
||||
|
||||
## Пункт 9
|
||||
Закончил сеанс работы с IDLE
|
||||
|
||||
@ -0,0 +1,100 @@
|
||||
# Общее контрольное задание по Теме 9
|
||||
Ходюк Максим Романович А-01-23
|
||||
## Задание
|
||||
Создайте и запишите в модуль класс, содержащий следующие компоненты:
|
||||
- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов, некоторые начальные значения;
|
||||
- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
|
||||
- метод для обеспечения перевода сотрудника из одного отдела в другой;
|
||||
- метод для изменения должности сотрудника;
|
||||
- свойство, содержащее перечень (список) поощрений сотрудника.
|
||||
Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
|
||||
|
||||
### Выполнение
|
||||
Модуль с созданным необходимым классом [Sotrudniki.py](Sotrudniki.py):
|
||||
```
|
||||
class Sotrudniki:
|
||||
def __init__(self, fio, otdel, dolzhnost, oklad):
|
||||
self.fio = fio
|
||||
self.otdel = otdel
|
||||
self.dolzhnost = dolzhnost
|
||||
self.oklad = oklad
|
||||
self._pooshrenia = []
|
||||
|
||||
def salary_raise(self, summa):
|
||||
if summa > 0:
|
||||
self.oklad += summa
|
||||
print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
|
||||
else:
|
||||
print("Сумма для повышения оклада должна быть больше нуля.")
|
||||
|
||||
def change_department(self, new_department):
|
||||
print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
|
||||
self.otdel = new_department
|
||||
|
||||
def change_position(self, new_position):
|
||||
print(f"Должность сотрудника {self.fio} изменена с {self.dolzhnost} на {new_position}.")
|
||||
self.dolzhnost = new_position
|
||||
|
||||
@property
|
||||
def pooshrenia(self):
|
||||
return self._pooshrenia
|
||||
|
||||
def add_pooshrenie(self, tekst):
|
||||
self._pooshrenia.append(tekst)
|
||||
print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")
|
||||
```
|
||||
|
||||
Модуль для выполнения необходимых операций с классом Sotrudniki: [Main.py](Main.py)
|
||||
|
||||
```
|
||||
from Sotrudniki import Sotrudniki
|
||||
|
||||
sot1 = Sotrudniki("Пронин А.Д", "Кафедра Управления и информационных технологий", "Ассистент",60000)
|
||||
sot2 = Sotrudniki("Бирюков А.М.", "Кафедра Математического и компьютерного моделирования", "Доцент", 75000)
|
||||
|
||||
|
||||
print("=== НАЧАЛЬНЫЕ ДАННЫЕ ===")
|
||||
print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
|
||||
print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
|
||||
|
||||
print("\n=== ОПЕРАЦИИ С СОТРУДНИКАМИ ===")
|
||||
|
||||
sot2.salary_raise(20000)
|
||||
sot1.change_department("Кафедра Математического и компьютерного моделирования")
|
||||
sot1.change_position("Старший преподаватель")
|
||||
sot2.add_pooshrenie("За преданность делу")
|
||||
sot1.add_pooshrenie("За создание позитивной атмосферы")
|
||||
|
||||
print("\n=== ИТОГОВЫЕ ДАННЫЕ ===")
|
||||
|
||||
print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
|
||||
print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
|
||||
|
||||
print("\n=== ПЕРЕЧЕНЬ ПООЩРЕНИЙ ===")
|
||||
print(f"Поощрения {sot1.fio}: {sot1.pooshrenia}")
|
||||
print(f"Поощрения {sot2.fio}: {sot2.pooshrenia}")
|
||||
```
|
||||
|
||||
Вывод программы:
|
||||
```
|
||||
========================================================================= RESTART: D:\POAS\Hodyuk\Tema9\Main.py ========================================================================
|
||||
=== НАЧАЛЬНЫЕ ДАННЫЕ ===
|
||||
Пронин А.Д, Кафедра Управления и информационных технологий, Ассистент, оклад: 60000
|
||||
Бирюков А.М., Кафедра Математического и компьютерного моделирования, Доцент, оклад: 75000
|
||||
|
||||
=== ОПЕРАЦИИ С СОТРУДНИКАМИ ===
|
||||
Оклад сотрудника Бирюков А.М. увеличен на 20000. Новый оклад: 95000
|
||||
Сотрудник Пронин А.Д переведен из отдела Кафедра Управления и информационных технологий в отдел Кафедра Математического и компьютерного моделирования.
|
||||
Должность сотрудника Пронин А.Д изменена с Ассистент на Старший преподаватель.
|
||||
Сотрудник Бирюков А.М. теперь имеет поощрение: За преданность делу
|
||||
Сотрудник Пронин А.Д теперь имеет поощрение: За создание позитивной атмосферы
|
||||
|
||||
=== ИТОГОВЫЕ ДАННЫЕ ===
|
||||
Пронин А.Д, Кафедра Математического и компьютерного моделирования, Старший преподаватель, оклад: 60000
|
||||
Бирюков А.М., Кафедра Математического и компьютерного моделирования, Доцент, оклад: 95000
|
||||
|
||||
=== ПЕРЕЧЕНЬ ПООЩРЕНИЙ ===
|
||||
Поощрения Пронин А.Д: ['За создание позитивной атмосферы']
|
||||
Поощрения Бирюков А.М.: ['За преданность делу']
|
||||
```
|
||||
|
||||
@ -0,0 +1,119 @@
|
||||
# Тест по модулю 3
|
||||
Ходюк Максим Романович, А-01-23
|
||||
|
||||
## Задание:
|
||||
Вариант 15
|
||||
1) Создайте модуль М1, содержащий две функции:
|
||||
|
||||
- функция 1: аргументы - список с отсчетами выходного сигнала SPS некоторой системы и заданное входное воздействие VH; в функции список SPS дополняется по формуле:
|
||||
|
||||
SPS[i]=(VH-SPS[i-1]*8)/9
|
||||
|
||||
Расчеты продолжаются до тех пор, пока не окажется |SPS[i] - SPS[i-1]|<0.05; удлиненный список SPS возвращается в вызывающую программу;
|
||||
|
||||
- функция 2: аргумент - список с отсчетами сигнала; в функции должно быть выполнено отображение сигнала на графике с разметкой его осей.
|
||||
|
||||
2) Создайте еще один модуль М2, в котором должны выполняться операции:
|
||||
|
||||
- создается начальный список с одним нулевым элементом;
|
||||
|
||||
- запрашивается требуемое значение ZN на выходе системы;
|
||||
|
||||
- производится обращение к функции 1 со списком и значением ZN; отображается результирующий список;
|
||||
|
||||
- отображается полученный сигнал путем обращения к функции 2;
|
||||
|
||||
- запрос и обращения к функциям повторяются с изменением значения ZN до тех пор, пока не будет введено значение ZN=0.
|
||||
|
||||
3) Создайте модуль М0 - главную программу, которая вызывает М2 и после завершения ее работы запрашивает имя бинарного файла и записывает в него полученный сигнал.
|
||||
|
||||
4) Проверьте работу программы, задавая значения ZN, равные 6, 10, -3 и 0.
|
||||
|
||||
### Выполнение
|
||||
|
||||
Содержимое модуля [M1](M1.py):
|
||||
```
|
||||
import matplotlib.pyplot as plt
|
||||
def func1(sps,vh):
|
||||
i = len(sps) - 1
|
||||
while True:
|
||||
value = (vh - sps[i] * 8) / 9
|
||||
sps.append(value)
|
||||
i+=1
|
||||
if abs(sps[i]-sps[i-1])< 0.05:
|
||||
break
|
||||
return sps
|
||||
|
||||
def func2(sps):
|
||||
"""
|
||||
Функция 2: отображает график сигнала
|
||||
"""
|
||||
plt.figure(figsize=(10, 6))
|
||||
plt.plot(sps, linewidth=2, markersize=5)
|
||||
plt.xlabel('Номер отсчета (i)', fontsize=12)
|
||||
plt.ylabel('Значение SPS[i]', fontsize=12)
|
||||
plt.title('График выходного сигнала системы', fontsize=14)
|
||||
plt.grid(True, alpha=0.3)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Содержимое модуля [M2](M2.py):
|
||||
```
|
||||
import M1
|
||||
def M1_execution():
|
||||
|
||||
sps = [0]
|
||||
while True:
|
||||
|
||||
zn = float(input('Введите требуемое значение на выходе системы: '))
|
||||
if zn==0:
|
||||
print('Было введено zn = 0. Завершение работы модуля M2')
|
||||
break
|
||||
|
||||
result = M1.func1(sps.copy(), zn)
|
||||
|
||||
print(f'Итоговый список: \n{result}')
|
||||
|
||||
M1.func2(result)
|
||||
|
||||
return result
|
||||
```
|
||||
|
||||
Содержимое модуля [M0](M0.py):
|
||||
```
|
||||
import M2
|
||||
import pickle
|
||||
result_signal = M2.M1_execution()
|
||||
|
||||
name = input("Введите имя бинарного файла, в который хотите записать полученный сигнал: ")
|
||||
with open(name,'wb') as file:
|
||||
pickle.dump(result_signal,file)
|
||||
```
|
||||
|
||||
Запуск программы:
|
||||
```
|
||||
====================== RESTART: D:/POAS/Hodyuk/Tema9/M0.py =====================
|
||||
Введите требуемое значение на выходе системы: 6
|
||||
Итоговый список:
|
||||
[0, 0.6666666666666666, 0.07407407407407411, 0.6008230452674898, 0.13260173754000912, 0.5487984555199918, 0.17884581731556282, 0.5076926068306108, 0.2153843494839015, 0.4752139115698653, 0.2442543008267864, 0.44955173259841213, 0.26706512657918924, 0.4292754430407207, 0.28508849507491496, 0.41325467104452, 0.29932918129375996, 0.4005962832944356, 0.31058108151605723, 0.3905945942079491, 0.31947147181515634, 0.3826920250531944, 0.3264959777304939, 0.37644801979511655]
|
||||
Введите требуемое значение на выходе системы: 10
|
||||
Итоговый список:
|
||||
[0, 1.1111111111111112, 0.12345679012345674, 1.001371742112483, 0.2210028959000151, 0.91466409253332, 0.2980763621926044, 0.846154344717685, 0.3589739158065022, 0.7920231859497758, 0.40709050137797703, 0.7492528876640203, 0.4451085442986486, 0.7154590717345345, 0.4751474917915249, 0.6887577850742002, 0.4988819688229332, 0.6676604721573928, 0.5176351358600954, 0.6509909903465819, 0.5324524530252606, 0.6378200417553239, 0.5441599628841565, 0.6274133663251943, 0.5534103410442718, 0.6191908079606473, 0.560719281812758, 0.6126939717219929, 0.5664942473582285]
|
||||
Введите требуемое значение на выходе системы: -3
|
||||
Итоговый список:
|
||||
[0, -0.3333333333333333, -0.037037037037037056, -0.3004115226337449, -0.06630086877000456, -0.2743992277599959, -0.08942290865778141, -0.2538463034153054, -0.10769217474195075, -0.23760695578493266, -0.1221271504133932, -0.22477586629920607, -0.13353256328959462, -0.21463772152036034, -0.14254424753745748, -0.20662733552226, -0.14966459064687998, -0.2002981416472178, -0.15529054075802862]
|
||||
Введите требуемое значение на выходе системы: 0
|
||||
Было введено zn = 0. Завершение работы модуля M2
|
||||
Введите имя бинарного файла, в который хотите записать полученный сигнал: testov_dan.mnz
|
||||
```
|
||||
|
||||
Графики, полученный при разных значениях zn:
|
||||
Для значения zn=6
|
||||
|
||||
|
||||
Для значения zn=10
|
||||
|
||||
|
||||
Для значения zn=-3
|
||||
|
||||
|
||||
Загрузка…
Ссылка в новой задаче