Сравнить коммиты
117 Коммитов
TimoshenkoAA
@ -0,0 +1,159 @@
|
||||
# Отчет по ЛР 1 ПО АС
|
||||
Выполнил: Тимошенко А.А.
|
||||
Проверил: Козлюк Д.А.
|
||||
|
||||
## Пункт 1
|
||||
В папку L:\III курс\А-1-23\TimoshenkoAA\Tema1\ПО АС 2025 перенесены материалы и распакован архив Tema1.rar
|
||||
|
||||
## Пункт 2
|
||||
Запущен интепретатор Phyton
|
||||
|
||||
## Пункт 3
|
||||
```
|
||||
>>> print("hello")
|
||||
hello
|
||||
```
|
||||
## Пункт 4
|
||||
```
|
||||
>>> h=input('Your name= ')
|
||||
Your name= Alexander
|
||||
>>> h
|
||||
'Alexander'
|
||||
```
|
||||
## Пункт 5
|
||||
Завершена работа с интерпретатором
|
||||
```
|
||||
>>> exit()
|
||||
```
|
||||
## Пункты 6-7
|
||||
Запущена IDLE Python 3.11, изучено устройство главного командного окна
|
||||
среды
|
||||
|
||||
## Пункт 8
|
||||
```
|
||||
import os
|
||||
os.chdir('L:\III курс\А-1-23\TimoshenkoAA\Tema1\ПО АС 2025')
|
||||
```
|
||||
## Пункт 9
|
||||
Шрифт изменен на Arial CYR, кегль 11, размер начального окна 50*100 символов,
|
||||
комментарии подсвечиваются коричневым
|
||||
|
||||
В текстовом редакторе IDLE создана программа следующего содержания:
|
||||
|
||||
Программа по теме 1 Тимошенко Александр Анатольевич
|
||||
```
|
||||
import os
|
||||
|
||||
print("hello")
|
||||
h = input('Your name = ')
|
||||
|
||||
os.chdir('L:\III курс\А-1-23\TimoshenkoAA\Tema1\ПО АС 2025')
|
||||
Она делает следующий вывод:
|
||||
= RESTART: L:/III курс/А-1-23/TimoshenkoAA/Tema1/ПО АС 2025/Pr0.py
|
||||
Hello
|
||||
Your name=Alexander
|
||||
|
||||
import Pr0
|
||||
Hello
|
||||
Your name=Alexander
|
||||
```
|
||||
При нажатии f5 в активном окне редактора:
|
||||
```
|
||||
= RESTART: L:/III курс/А-1-23/TimoshenkoAA/Tema1/ПО АС 2025/Pr0.py
|
||||
Hello
|
||||
Your name=
|
||||
```
|
||||
## Пункт 11
|
||||
|
||||
Из консоли вызван файл prb1.py
|
||||
```
|
||||
>>> import prb1
|
||||
Как Вас зовут? Александр
|
||||
Привет, Александр
|
||||
```
|
||||
## Пункт 12
|
||||
|
||||
Файл Pr0.cpython-311.pyc открыт,внутри находится байт код, версия скомпилированного исходного кода python, он создаётся для того, чтобы виртуальная машина Python могла выполнить его, а файл с байт-кодом создаётся, чтобы при повторном запуске интрепретатору не нужно было заново преобразовывать код на языке python в байт-код, чтобы тратилось меньше ресурсов. Видно, что результат компиляции невозможен для восприятия человеком. Компиляция программ производится для преобразования кода на понятном человеку языке в байт-код, который затем выполняется виртуальной машиной Python.
|
||||
## Пункт 13
|
||||
|
||||
Все верные команды из командного окна IDLE скопированы в отдельный файл
|
||||
|
||||
## Пункт 14
|
||||
|
||||
В разделе помощи help можно найти следующие опции:
|
||||
|
||||
About IDLE - описание характеристик текущей среды (версия, путь и пр.)
|
||||
|
||||
IDLE Help - помощь по работе со средой
|
||||
|
||||
Python Docs - документация по языку
|
||||
|
||||
Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
|
||||
```
|
||||
>>> help (print)
|
||||
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(...)
|
||||
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
|
||||
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
Optional keyword arguments:
|
||||
file: a file-like object (stream); defaults to the current sys.stdout.
|
||||
sep: string inserted between values, default a space.
|
||||
end: string appended after the last value, default a newline.
|
||||
flush: whether to forcibly flush the stream.
|
||||
|
||||
>>> help(print), help(input)
|
||||
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(...)
|
||||
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
|
||||
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
Optional keyword arguments:
|
||||
file: a file-like object (stream); defaults to the current sys.stdout.
|
||||
sep: string inserted between values, default a space.
|
||||
end: string appended after the last value, default a newline.
|
||||
flush: whether to forcibly flush the stream.
|
||||
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt=None, /)
|
||||
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 -> Указатель -> print() (built-in function) выводит справку по этой
|
||||
функции
|
||||
|
||||
То же диалоговое окно появляется при help - Python Docs
|
||||
|
||||
## Пункт 15
|
||||
|
||||
File - Open - prb1.py
|
||||
|
||||
С помощью Window можно переключаться между всеми открытыми окнами
|
||||
|
||||
prb1.py - Run
|
||||
```
|
||||
======= RESTART: L:\III курс\А-1-23\TimoshenkoAA\Tema1\ПО АС 2025\prb1.py ======
|
||||
Как Вас зовут? Александр
|
||||
Привет, Александр
|
||||
```
|
||||
```
|
||||
>>> import tdemo_chaos
|
||||
```
|
||||
Help - Turtle Demo - clock - Start выводит на экран графическое представление
|
||||
программы - циферблат с часами. Есть и другие примеры программ модуля turtle,
|
||||
которые можно брать за основу собственных программ.
|
||||
|
||||
## Пункт 16
|
||||
Завершена работа со средой: File - exit
|
||||
@ -0,0 +1,30 @@
|
||||
# Индивидуальное контрольное задание по Теме1.
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
## Вопрос 6
|
||||
Какие способы могут использоваться для получения помощи при работе со средой Python?
|
||||
|
||||
### Вариант 1. Встроенная функция help.
|
||||
About IDLE - описание характеристик текущей среды (версия, путь и пр.)
|
||||
help(какой-нибудь объект)
|
||||
```
|
||||
>>> help (print)
|
||||
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(...)
|
||||
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
|
||||
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
Optional keyword arguments:
|
||||
file: a file-like object (stream); defaults to the current sys.stdout.
|
||||
sep: string inserted between values, default a space.
|
||||
end: string appended after the last value, default a newline.
|
||||
flush: whether to forcibly flush the stream.
|
||||
|
||||
```
|
||||
### Вариант 2. Справка в IDLE
|
||||
Help → Python Docs - полная документация
|
||||
|
||||
Help → IDLE Help - справка по среде разработки
|
||||
### Вариант 3.
|
||||
Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
|
||||
@ -0,0 +1,634 @@
|
||||
# Протокол ПО АС по теме 2
|
||||
Выполнил: Тимошенко А.А. Проверил : Козлюк Д. А.
|
||||
|
||||
# Пункт 1
|
||||
|
||||
Рабочая среда настроена на нахождение в нужной директории:
|
||||
```
|
||||
import os
|
||||
os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА2")
|
||||
```
|
||||
# Пункт 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', 'os']
|
||||
```
|
||||
Еще эта функция может показать атрибуты объекта:
|
||||
```
|
||||
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']
|
||||
```
|
||||
Для определения классовой принадлежности любого объекта следует использовать функцию type():
|
||||
```
|
||||
type(f2)
|
||||
<class 'int'>
|
||||
```
|
||||
Удалим объекты из рабочего пространства:
|
||||
```
|
||||
del f1, f2
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
|
||||
```
|
||||
# Пункт 3
|
||||
|
||||
Правила именования объектов:
|
||||
```
|
||||
gg1 = 1.6
|
||||
hh1 = 'example'
|
||||
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']
|
||||
|
||||
keyWordList = keyword.kwlist
|
||||
keyWordList
|
||||
['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']
|
||||
type(keyWordList)
|
||||
<class 'list'>
|
||||
```
|
||||
# Пункт 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']
|
||||
```
|
||||
Среди этих имен есть полезные функции, например:
|
||||
|
||||
Взятие модуля
|
||||
```
|
||||
abs(-5)
|
||||
5
|
||||
```
|
||||
Длина объекта
|
||||
```
|
||||
len([1,2,3])
|
||||
3
|
||||
```
|
||||
Максимум значений
|
||||
max(14,8)
|
||||
14
|
||||
Минимум значений
|
||||
```
|
||||
min(15,0)
|
||||
0
|
||||
```
|
||||
Возведение в степень
|
||||
```
|
||||
pow(5,2)
|
||||
25
|
||||
```
|
||||
Можно возводить в степень по модулю
|
||||
```
|
||||
pow(5, 2, 2)
|
||||
1
|
||||
```
|
||||
Округление
|
||||
```
|
||||
round(3,124)
|
||||
3
|
||||
```
|
||||
Можно указать порядок, до которого округляем (по умолчанию - до целого)
|
||||
```
|
||||
round(4.87945, 2)
|
||||
4.88
|
||||
```
|
||||
Суммирование
|
||||
```
|
||||
sum([7,3,5])
|
||||
15
|
||||
```
|
||||
Можно указать еще и начальное значение
|
||||
```
|
||||
sum([7,3,5],7)
|
||||
22
|
||||
```
|
||||
Сортировка по возрастанию или по убыванию:
|
||||
```
|
||||
sorted ([3, 7, 9, 75, 0, -1])
|
||||
[-1, 0, 3, 7, 9, 75]
|
||||
```
|
||||
Объединение объектов в кортеж
|
||||
```
|
||||
sorted ([3, 7, 9, 75, 0, -1], reverse = True)
|
||||
[75, 9, 7, 3, 0, -1]
|
||||
```
|
||||
```
|
||||
list1 = [1,2,3]
|
||||
list2 = [4,5,6]
|
||||
zip(list1, list2)
|
||||
<zip object at 0x00000189450C6C00>
|
||||
```
|
||||
|
||||
# Пункт 6.
|
||||
Python - регистрочувствительный язык
|
||||
```
|
||||
Gg1 = 45
|
||||
gg1, Gg1
|
||||
(1.6, 45)
|
||||
gg1 == Gg1
|
||||
False
|
||||
```
|
||||
# Пункт 7.1 Логический тип:
|
||||
```
|
||||
bb1 = True
|
||||
bb2 = False
|
||||
type(bb1)
|
||||
<class 'bool'>
|
||||
```
|
||||
# Пункт 7.2 Целое число (десятичное)
|
||||
```
|
||||
ii1 = 1234567890
|
||||
type(ii1)
|
||||
<class 'int'>
|
||||
```
|
||||
Экспоненциальная форма записи числа
|
||||
```
|
||||
ff1 = 8.987e-12
|
||||
type(ff1)
|
||||
<class 'float'>
|
||||
Двоичное число (префикс 0b - binary)
|
||||
dv1 = 0b1100101
|
||||
type(bb1)
|
||||
<class 'bool'>
|
||||
Восьмеричное число (0о - octal)
|
||||
vsm1 = 0o52765
|
||||
type(vsm1)
|
||||
<class 'int'>
|
||||
Шестнадцатеричное число (0х - hexadecimal)
|
||||
shest1 = 0x7109af6
|
||||
type(shest1)
|
||||
<class 'int'>
|
||||
Комплексное число
|
||||
cc1 = 2 - 3j
|
||||
type(cc1)
|
||||
<class 'complex'>
|
||||
a = 3.67
|
||||
b = 0.45
|
||||
cc2 = complex(a,b)
|
||||
cc2
|
||||
(3.67+0.45j)
|
||||
type(cc2)
|
||||
<class 'complex'>
|
||||
```
|
||||
# Пункт 7.3 Строковые данные
|
||||
|
||||
Одинарные и двойные кавычки взаимозаменяемы, но если открыта одинарная, то закрыта тоже
|
||||
должна быть одинарная
|
||||
```
|
||||
ss1 = "Это - строка символов"
|
||||
ss2 = "Это - строка символов"
|
||||
ss1 == ss2
|
||||
True
|
||||
ss1a = "Это - \"строка символов\", \n \t выводимая на двух строках"
|
||||
print(ss1a)
|
||||
Это - "строка символов",
|
||||
выводимая на двух строках
|
||||
ss1b = 'Меня зовут: \n Тимошенко А.А.'
|
||||
print(ss1b)
|
||||
Меня зовут:
|
||||
Тимошенко А.А.
|
||||
```
|
||||
|
||||
Обратимся к отдельным элементам с помощью квадратных кавычек
|
||||
(нумерация с нуля):
|
||||
Большую строку можно записать в тройных кавычках:
|
||||
mnogo="""Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции."""
|
||||
```
|
||||
print(mnogo)
|
||||
Нетрудно заметить , что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые участвуют в операции.
|
||||
```
|
||||
Обратимся к отдельным элементам с помощью квадратных кавычек
|
||||
(нумерация с нуля):
|
||||
```
|
||||
mnogo[3]
|
||||
'р'
|
||||
ss1b[-1] - первый с конца
|
||||
'.'
|
||||
```
|
||||
|
||||
Срезы:
|
||||
```
|
||||
ss1[6:9]
|
||||
'стр'
|
||||
ss1[3:17:2]
|
||||
' тоасм'
|
||||
ss1[5:-8]
|
||||
' строка '
|
||||
Задав шаг -1, можно вывести строку в обратном порядке:
|
||||
ss1[::-1]
|
||||
'воловмис акортс - отЭ'
|
||||
```
|
||||
К элементу можно обратиться как по нумерации с начала, так и с конца:
|
||||
```
|
||||
ss1[17:3:-2]
|
||||
'омсаот '
|
||||
ss1[-4:3:-2]
|
||||
'омсаот '
|
||||
```
|
||||
Строка - неизменяемый тип данных:
|
||||
```
|
||||
ss1[4] = "="
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#86>", line 1, in <module>
|
||||
ss1[4] = "="
|
||||
TypeError: 'str' object does not support item assignment
|
||||
ss1b_cut = ss1b [::-2]
|
||||
```
|
||||
Но если возникает необходимость изменить строку, то можно пересобрать
|
||||
ее из исходной строки:
|
||||
```
|
||||
ss1=ss1[:4]+'='+ss1[5:]
|
||||
ss1
|
||||
'Это = строка символов'
|
||||
```
|
||||
Новый объект на основе среза из старого:
|
||||
ss1b_cut = ss1b [::-2]
|
||||
ss1b_cut
|
||||
'.. кеои твзяе'
|
||||
|
||||
Собственное создание разных типов данных:
|
||||
```
|
||||
num10 = 26
|
||||
type(num10)
|
||||
<class 'int'>
|
||||
|
||||
num16 = hex(num10)
|
||||
num16
|
||||
'0x1a'
|
||||
type(num16)
|
||||
<class 'str'>
|
||||
KeyboardInterrupt
|
||||
str1 = str(num10) + ' в десятичной - это ' + str(num16) + ' в шестнадцатеричной '
|
||||
str1
|
||||
'26 в десятичной - это 0x1a в шестнадцатеричной '
|
||||
str1[5:16:3]
|
||||
|
||||
'дячй'
|
||||
```
|
||||
# Пункт 8. Списки, кортежи, словари, множества
|
||||
|
||||
Список list - изменяемый тип данных. Это упорядоченная последовательность из элементов
|
||||
одного или разных типов.
|
||||
```
|
||||
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]
|
||||
spis[-1]
|
||||
10
|
||||
spis1[-1]
|
||||
(5-9j)
|
||||
stup[-8::2]
|
||||
[0, 1, 1, 1]
|
||||
spis1[1]='Список'
|
||||
spis1
|
||||
['111', 'Список', (5-9j)]
|
||||
len(spis1)
|
||||
3
|
||||
```
|
||||
Методы списков:
|
||||
|
||||
1. Добавление в конец (append)
|
||||
```
|
||||
help(spis1.append)
|
||||
Help on built-in function append:
|
||||
|
||||
append(object, /) method of builtins.list instance
|
||||
Append object to the end of the list.
|
||||
|
||||
spis1.append('New item')
|
||||
spis1
|
||||
['111', 'Список', (5-9j), 'New item']
|
||||
spis1+['New item']
|
||||
|
||||
Только возвращает результат, но не фиксирует такое значение!
|
||||
|
||||
['111', 'Список', (5-9j), 'New item', 'New item']
|
||||
spis1
|
||||
['111', 'Список', (5-9j), 'New item']
|
||||
Конкатенация строк:
|
||||
spis1 += ss1b
|
||||
spis1
|
||||
['111', 'Список', (5-9j), 'New item', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', 'Т', 'и', 'м', 'о', 'ш', 'е', 'н', 'к', 'о', ' ', 'А', '.', 'А', '.']
|
||||
spis1 = [111, 'Список', (5-9j), 'New item']
|
||||
|
||||
spis1.append(ss1b)
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Тимошенко А.А.']
|
||||
```
|
||||
2. Удаление элемента по индексу (pop):
|
||||
```
|
||||
spis1.pop(1)
|
||||
'Список'
|
||||
spis1
|
||||
[111, (5-9j), 'New item', 'Меня зовут: \n Тимошенко А.А.']
|
||||
Если указать индекс, которого нет:
|
||||
|
||||
spis1.pop(7)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#122>", line 1, in <module>
|
||||
spis1.pop(7)
|
||||
IndexError: pop index out of range
|
||||
```
|
||||
3. Вставка элемента в определенное место по индексу (insert)
|
||||
```
|
||||
help(spis1.insert)
|
||||
Help on built-in function insert:
|
||||
|
||||
insert(index, object, /) method of builtins.list instance
|
||||
Insert object before index.
|
||||
|
||||
spis1.insert(2, "hello")
|
||||
spis1
|
||||
[111, (5-9j), 'hello', 'New item', 'Меня зовут: \n Тимошенко А.А.']
|
||||
|
||||
Если указать число большее чем длина списка, то просто вставится в конец:
|
||||
|
||||
spis1.insert(8, "test")
|
||||
spis1
|
||||
[111, (5-9j), 'hello', 'New item', 'Меня зовут: \n Тимошенко А.А.', 'test']
|
||||
```
|
||||
4. Удаление элемента по значению (remove)
|
||||
```
|
||||
help(spis1.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.
|
||||
|
||||
spis1.remove(111)
|
||||
spis1
|
||||
[(5-9j), 'hello', 'New item', 'Меня зовут: \n Тимошенко А.А.', 'test']
|
||||
spis1.remove('kitten')
|
||||
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#132>", line 1, in <module>
|
||||
spis1.remove('kitten')
|
||||
help(spis1.extend)
|
||||
```
|
||||
5. Добавление элементов объекта в конец другого объекта (extend)
|
||||
```
|
||||
Help on built-in function extend:
|
||||
|
||||
extend(iterable, /) method of builtins.list instance
|
||||
Extend list by appending elements from the iterable.
|
||||
|
||||
end1 = [123, "mew", (1,2)]
|
||||
|
||||
spis1.extend(end1)
|
||||
|
||||
spis1
|
||||
[(5-9j), 'hello', 'New item', 'Меня зовут: \n Тимошенко А.А.', 'test', 123, 'mew', (1, 2)]
|
||||
```
|
||||
6. Полное очищение списка (clear)
|
||||
```
|
||||
help(spis1.clear)
|
||||
|
||||
Help on built-in function clear:
|
||||
|
||||
clear() method of builtins.list instance
|
||||
Remove all items from list.
|
||||
|
||||
end1.clear()
|
||||
|
||||
end1
|
||||
[]
|
||||
```
|
||||
7. Сортировка списка БЕЗ создания нового объекта (sort)
|
||||
```
|
||||
help(spis1.sort)
|
||||
|
||||
Help on built-in function sort:
|
||||
|
||||
sort(*, key=None, reverse=False) method of builtins.list instance
|
||||
Sort the list in ascending order and return None.
|
||||
|
||||
The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
|
||||
order of two equal elements is maintained).
|
||||
|
||||
If a key function is given, apply it once to each list item and sort them,
|
||||
ascending or descending, according to their function values.
|
||||
|
||||
The reverse flag can be set to sort in descending order.
|
||||
|
||||
end1 = [5, 6, 9.99999, 384, 0, -5]
|
||||
|
||||
end1.sort(key = abs, reverse = True)
|
||||
|
||||
end1
|
||||
[384, 9.99999, 6, 5, -5, 0]
|
||||
|
||||
```
|
||||
8. Создание копии списка (copy)
|
||||
```
|
||||
help(end1.copy)
|
||||
|
||||
Help on built-in function copy:
|
||||
|
||||
copy() method of builtins.list instance
|
||||
Return a shallow copy of the list.
|
||||
|
||||
endcopy = end1.copy()
|
||||
|
||||
endcopy
|
||||
[384, 9.99999, 6, 5, -5, 0]
|
||||
```
|
||||
9. Поиск индекса по значению (index)
|
||||
```
|
||||
help(endcopy.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.
|
||||
|
||||
endcopy.index(0)
|
||||
5
|
||||
|
||||
endopy.index("hehehe")
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#150>", line 1, in <module>
|
||||
endopy.index("hehehe")
|
||||
ValueError: 'hehehe' is not in list
|
||||
```
|
||||
10. Подсчет количества элементов по значению (count)
|
||||
```
|
||||
help(endcopy.count)
|
||||
|
||||
Help on built-in function count:
|
||||
|
||||
count(value, /) method of builtins.list instance
|
||||
Return number of occurrences of value.
|
||||
|
||||
endcopy.count(5)
|
||||
1
|
||||
|
||||
endcopy.count(666666)
|
||||
0
|
||||
```
|
||||
# Пункт 8.1 Вложенные списки:
|
||||
```
|
||||
spis2=[spis1,[4,5,6,7]]
|
||||
|
||||
spis2
|
||||
[[(5-9j), 'hello', 'New item', 'Меня зовут: \n Тимошенко А.А.', 'test', 123, 'mew', (1, 2)], [4, 5, 6, 7]]
|
||||
spis2[0][1]
|
||||
|
||||
'hello'
|
||||
spis2[0][1]=78
|
||||
|
||||
spis2
|
||||
[[(5-9j), 78, 'New item', 'Меня зовут: \n Тимошенко А.А.', 'test', 123, 'mew', (1, 2)], [4, 5, 6, 7]]
|
||||
spis1
|
||||
[(5-9j), 78, 'New item', 'Меня зовут: \n Тимошенко А.А.', 'test', 123, 'mew', (1, 2)]
|
||||
```
|
||||
Как видно, spis1 тоже изменился. Это происходит потому, что python работает не просто с
|
||||
объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке,
|
||||
а не по значению.
|
||||
Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]]
|
||||
мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе
|
||||
spis2 отобраажются на исходном spis1.
|
||||
|
||||
# Пункт 8.2. Кортеж: последовательность как список, но неизменяемая как строка.
|
||||
```
|
||||
kort1=(222,'Kortezh',77+8j)
|
||||
kort1= kort1+(1,2)
|
||||
kort1
|
||||
(222, 'Kortezh', (77+8j), 1, 2)
|
||||
kort1= kort1+(ss1b,)
|
||||
kort1
|
||||
(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Тимошенко А.А.')
|
||||
kort2=kort1[:2]+kort1[3:]
|
||||
|
||||
kort2
|
||||
(222, 'Kortezh', 1, 2, 'Меня зовут: \n Тимошенко А.А.')
|
||||
kort1.index(2)
|
||||
4
|
||||
kort1.count(222)
|
||||
1
|
||||
kort1[2]=90
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#170>", line 1, in <module>
|
||||
kort1[2]=90
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
>>> kortstr = ("h", "lambda", "always", 54, [1,2,3], (6,7))
|
||||
|
||||
SyntaxError: invalid syntax
|
||||
kortstr = ("h", "lambda", "always", 54, [1,2,3], (6,7))
|
||||
|
||||
kortstr
|
||||
|
||||
('h', 'lambda', 'always', 54, [1, 2, 3], (6, 7))
|
||||
type(kortstr[5])
|
||||
|
||||
<class 'tuple'>
|
||||
type(kortstr[4])
|
||||
|
||||
<class 'list'>
|
||||
```
|
||||
# Пункт 8.3. Словарь (dictionary) - содержит в себе совокупность пар
|
||||
```
|
||||
"ключ (key) (неизменяемый)": "значение (value) (любого типа)"
|
||||
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
|
||||
dic1[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#178>", line 1, in <module> #как видно, обратиться по индексу нельзя
|
||||
dic1[1]
|
||||
KeyError: 1
|
||||
dic1['Orel']
|
||||
|
||||
56
|
||||
dic1['Pskov']=78
|
||||
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
|
||||
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'
|
||||
dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
|
||||
dic4
|
||||
{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Тимошенко А.А.'}
|
||||
dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
|
||||
dic5
|
||||
{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Тимошенко А.А.'}
|
||||
```
|
||||
Создание собственного словаря на основе кортежа из семи элементов и списка из пяти:
|
||||
```
|
||||
terms_tuple = ("mean", "median", "mode", "variance", "standard deviation", "correlation", "regression")
|
||||
|
||||
count_list = ["one", "two", "three", "four", "five"]
|
||||
KeyboardInterrupt
|
||||
count_list = ["one", "two", "three", "four", "five"]
|
||||
|
||||
terms_dict = dict(zip(count_list, terms_tuple))
|
||||
|
||||
terms_dict
|
||||
{'one': 'mean', 'two': 'median', 'three': 'mode', 'four': 'variance', 'five': 'standard deviation'}
|
||||
```
|
||||
# Пункт 8.4. Объект-множество: состоят из НЕповторяющихся неизменяемых элементов
|
||||
```
|
||||
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
|
||||
mnoz1
|
||||
{'датчик', 'линия связи', 'микропроцессор', 'двигатель'}
|
||||
len(mnoz1)
|
||||
4
|
||||
'датчик' in mnoz1
|
||||
|
||||
True
|
||||
mnoz1.add('реле')
|
||||
mnoz1.remove('линия связи')
|
||||
|
||||
mnoz1
|
||||
{'датчик', 'реле', 'двигатель', 'микропроцессор'}
|
||||
```
|
||||
|
||||
@ -0,0 +1,58 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 2
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Пункт 1
|
||||
Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
|
||||
```
|
||||
familia = 'Timoshenko'
|
||||
```
|
||||
## Пункт 2
|
||||
Создать переменную со значением, совпадающим с первой буквой из familia.
|
||||
```
|
||||
fam1 = familia[0]
|
||||
fam1
|
||||
'T'
|
||||
```
|
||||
## Пункт 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'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
|
||||
```
|
||||
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 с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
|
||||
```
|
||||
kort_nam = ("Sasha", "Maksim", "Dmitriy", "Danya")
|
||||
type(kort_nam)
|
||||
<class 'tuple'>
|
||||
```
|
||||
## Пункт 6
|
||||
Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
|
||||
```
|
||||
kort_nam += ("Liza","Nikita")
|
||||
kort_nam
|
||||
('Sasha', 'Maksim', 'Dmitriy', 'Danya', 'Liza', 'Nikita')
|
||||
```
|
||||
## Пункт 7
|
||||
Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
|
||||
```
|
||||
kort_nam.count("Dmitriy")
|
||||
1
|
||||
```
|
||||
## Пункт 8
|
||||
Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах,а значениями – ранее созданные переменные, соответствующие этим типам.
|
||||
```
|
||||
dict_bas = {"строка": familia, "символ": fam1, "список": sp_kw,
|
||||
"кортеж": kort_nam,}
|
||||
dict_bas
|
||||
{'строка': 'Timoshenko', 'символ': 'T', 'список': ['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'], 'кортеж': ('Sasha', 'Maksim', 'Dmitriy', 'Danya', 'Liza', 'Nikita')}
|
||||
```
|
||||
@ -0,0 +1,16 @@
|
||||
# Индивидуальное контрольное задание
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
## Задание:
|
||||
Вариант 6: Пусть создан объект
|
||||
hh=-12.2758
|
||||
Напишите инструкцию вывода на экран значения этого объекта, округленного до двух знаков после точки.
|
||||
## Решение:
|
||||
Создан объект
|
||||
```
|
||||
hh=-12.2758
|
||||
```
|
||||
C помощью функции round производим округление:
|
||||
```
|
||||
print(round(hh, 2))
|
||||
-12.28
|
||||
```
|
||||
@ -0,0 +1,46 @@
|
||||
# Тест по модулю 1
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Вопрос 1
|
||||
Какова роль компилятора в среде Python? Чем отличаются файлы с расширением .pyc от файлов с расширением .py?
|
||||
|
||||
В Python компилятор не создает самостоятельный исполняемый файл, как в компилируемых языках. Его задача — преобразовать исходный код (файл .py) в байт-код — упрощенный набор инструкций для виртуальной машины Python. Этот байт-код сохраняется в файлах с расширением .pyc. Затем интерпретатор выполняет этот байт-код.
|
||||
Файлы .py - это исходный код на Python, который читается человеком.
|
||||
Файлы .pyc - это скомпилированный байт-код, который выполняется виртуальной машиной Python.
|
||||
|
||||
## Вопрос 2
|
||||
Напишите инструкцию, создающую список со словами из данного предложения. Подсчитайте и отобразите на экране число слов.
|
||||
```
|
||||
>>> a = "Какова роль компилятора в среде Python?"
|
||||
>>> word_list = a.split()
|
||||
>>> word_count = len(word_list)
|
||||
>>> print("Список слов:", word_list)
|
||||
Список слов: ['Какова', 'роль', 'компилятора', 'в', 'среде', 'Python?']
|
||||
>>> print("Число слов:", word_count)
|
||||
Число слов: 6
|
||||
```
|
||||
## Вопрос 3
|
||||
Создайте кортеж с именами 10 любых студентов вашей группы. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
|
||||
```
|
||||
>>> students_tuple = ('Тимошенко Александр', 'Ходюк Максим', 'Коваленко Дмитрий', 'Иванов Даниил', 'Лыкова Елизавета', 'Соловьева Екатерина', 'Таболин Иван', 'Филиппов Даниил', 'Подольский Никита', 'Терехов Федор')
|
||||
>>> print("Тип объекта:", type(students_tuple))
|
||||
Тип объекта: <class 'tuple'>
|
||||
>>> print("Атрибуты и методы объекта:", dir(students_tuple))
|
||||
Атрибуты и методы объекта: ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
|
||||
|
||||
```
|
||||
## Вопрос 4
|
||||
Превратите кортеж во множество. Подсчитайте число элементов множества и отобразите на экране с помощью формата по шаблону: "Во множестве ХХ студентов".
|
||||
```
|
||||
>>> students_set = set(students_tuple)
|
||||
>>> number_of_students = len(students_set)
|
||||
>>> print(f"Во множестве {number_of_students} студентов.")
|
||||
Во множестве 10 студентов.
|
||||
```
|
||||
## Вопрос 5
|
||||
Напишите инструкцию, создающую строку из элементов списка из п.2. Отобразите строку на экране.
|
||||
```
|
||||
>>> new_string = ' '.join(word_list)
|
||||
>>> print("Полученная строка:", new_string)
|
||||
Полученная строка: Какова роль компилятора в среде Python?
|
||||
```
|
||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
@ -0,0 +1,102 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 3
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Пункт 1
|
||||
Преобразовать восьмеричное значение 45 в целое число.
|
||||
```
|
||||
>>> octv = '45'
|
||||
>>> decv = int(octv, 8)
|
||||
>>> decv
|
||||
37
|
||||
```
|
||||
## Пункт 2
|
||||
Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12,
|
||||
"постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и
|
||||
значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж
|
||||
от списка?
|
||||
```
|
||||
>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
|
||||
>>> keyD = list(D.keys())
|
||||
>>> keyD
|
||||
['усиление', 'запаздывание', 'постоянная времени']
|
||||
>>> valD = list(D.values())
|
||||
>>> valD
|
||||
[23, 12, 78]
|
||||
>>> tupD = (keyD, valD)
|
||||
>>> tupD
|
||||
(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
|
||||
```
|
||||
Кортежи не изменяемы, инициируются с помощью круглых скобок. Списки изменяемы, инициируются
|
||||
с помощью квадратных скобок.
|
||||
|
||||
## Пункт 3
|
||||
Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с
|
||||
округлением вниз, с определением после этого остатка от деления получившегося значения
|
||||
на 3 и затем возведения результата в степень 2.4.
|
||||
```
|
||||
>>> ((1768 // 24.8) % 3) ** 2.4
|
||||
5.278031643091577
|
||||
```
|
||||
## Пункт 4
|
||||
Напишите и выполните единое выражение, последовательно осуществляющее следующие
|
||||
операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее
|
||||
ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
```
|
||||
>>> ((~(13 & 27)) ^ 14) << 2
|
||||
-32
|
||||
```
|
||||
## Пункт 5
|
||||
Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки
|
||||
наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов
|
||||
этого списка.
|
||||
```
|
||||
>>> lst = ["колебат"] * 4
|
||||
>>> lst[1] += lst[2]
|
||||
>>> lst
|
||||
['колебат', 'колебатколебат', 'колебат', 'колебат']
|
||||
>>> lst.pop(2)
|
||||
'колебат'
|
||||
>>> lst
|
||||
['колебат', 'колебатколебат', 'колебат']
|
||||
>>> 'аткол' in lst[1]
|
||||
True
|
||||
```
|
||||
## Пункт 6
|
||||
Определить список методов, доступных у ранее созданного словаря D. Поочередно
|
||||
использовать его методы keys и values, определить, что можно получить с применением
|
||||
этих методов.
|
||||
```
|
||||
>>> D
|
||||
{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
|
||||
>>> dir(D)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__',
|
||||
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
|
||||
'__getitem__', '__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])
|
||||
```
|
||||
dict_keys и dict_values - особые объекты, которые ссылаются на элементы исходного словаря.
|
||||
|
||||
## Пункт 7
|
||||
Создать объект - символьную строку с текстом данного предложения. Из символьной строки
|
||||
создать список, элементами которого будут отдельные слова из созданной строки. Заменить в
|
||||
списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить
|
||||
получившийся список.
|
||||
```
|
||||
>>> sen = "Создать объект - символьную строку с текстом данного предложения"
|
||||
>>> senl = sen.split()
|
||||
>>> senl
|
||||
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
>>> senl[senl.index("-")] = ","
|
||||
>>> senl
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
>>> senl.remove("данного")
|
||||
>>> senl
|
||||
['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
|
||||
```
|
||||
|
После Ширина: | Высота: | Размер: 20 KiB |
|
После Ширина: | Высота: | Размер: 15 KiB |
|
После Ширина: | Высота: | Размер: 11 KiB |
@ -0,0 +1,855 @@
|
||||
# Тема 4. Встроенные функции
|
||||
Выполнил : Тимошенко А.А.
|
||||
Проверил : Козлюк Д.А.
|
||||
|
||||
## Пункт 1
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА4")
|
||||
```
|
||||
## Пункт 2
|
||||
|
||||
Стандартные функции (модуль builtins, импортированный по умолчанию во все скрипты)
|
||||
|
||||
### Пункт 2.1
|
||||
|
||||
round() - округление с заданной точностью
|
||||
```
|
||||
>>> help(round)
|
||||
Help on built-in function round in module builtins:
|
||||
|
||||
round(number, ndigits=None)
|
||||
Round a number to a given precision in decimal digits.
|
||||
|
||||
The return value is an integer if ndigits is omitted or None. Otherwise
|
||||
the return value has the same type as the number. ndigits may be negative.
|
||||
|
||||
>>> round(123.456,1)
|
||||
123.5
|
||||
>>> type(round(123.456,1))
|
||||
<class 'float'>
|
||||
>>> round(123.456,0)
|
||||
123.0
|
||||
>>> type(round(123.456,0))
|
||||
<class 'float'>
|
||||
>>> round(123.456)
|
||||
123
|
||||
>>> type(round(123.456))
|
||||
<class 'int'>
|
||||
```
|
||||
Таким образом, если ndigits не указан, функция возвращает округленное целое число.
|
||||
Если указан, пускай даже ноль, то число с плавающей точкой.
|
||||
|
||||
|
||||
### Пункт 2.2
|
||||
|
||||
range() - генерация последовательности
|
||||
```
|
||||
>>> help(range)
|
||||
Help on class range in module builtins:
|
||||
|
||||
class range(object)
|
||||
| range(stop) -> range object
|
||||
| range(start, stop[, step]) -> range object
|
||||
|
|
||||
| Return an object that produces a sequence of integers from start (inclusive)
|
||||
| to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.
|
||||
| start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.
|
||||
| These are exactly the valid indices for a list of 4 elements.
|
||||
| When step is given, it specifies the increment (or decrement).
|
||||
|
||||
>>> gg=range(76,123,9)
|
||||
>>> gg
|
||||
range(76, 123, 9)
|
||||
```
|
||||
Функция возвращает итерируемый объект типа range:
|
||||
```
|
||||
>>> type(range(76,123,9))
|
||||
<class 'range'>
|
||||
```
|
||||
Чтобы прочитать результат, можно записать в список:
|
||||
```
|
||||
>>> list(gg)
|
||||
[76, 85, 94, 103, 112, 121]
|
||||
```
|
||||
### Пункт 2.3
|
||||
|
||||
zip() - создание итерируемого объекта из кортежей
|
||||
```
|
||||
>>> qq=["Тимошенко","Ходюк","Коваленко","Иванов"]
|
||||
>>> ff = zip (gg, qq)
|
||||
>>> ff
|
||||
<zip object at 0x00000207EA67BD80>
|
||||
>>> tuple(ff)
|
||||
((76, 'Тимошенко'), (85, 'Ходюк'), (94, 'Коваленко'), (103, 'Иванов'))
|
||||
```
|
||||
1. Длина получившегося объекта - меньшая из длин объектов-параметров. В данном случае, это 4.
|
||||
2. Объект класса zip не итерируемый:
|
||||
```
|
||||
>>> ff[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#14>", line 1, in <module>
|
||||
ff[1]
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
```
|
||||
3. Объект класса zip неизменяемый.
|
||||
|
||||
### Пункт 2.4
|
||||
|
||||
eval - вычисление выражения строкой
|
||||
```
|
||||
>>> help(eval)
|
||||
Help on built-in function eval in module builtins:
|
||||
|
||||
eval(source, globals=None, locals=None, /)
|
||||
Evaluate the given source in the context of globals and locals.
|
||||
|
||||
The source may be a string representing a Python expression
|
||||
or a code object as returned by compile().
|
||||
The globals must be a dictionary and locals can be any mapping,
|
||||
defaulting to the current globals and locals.
|
||||
If only globals is given, locals defaults to it.
|
||||
|
||||
>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
||||
коэффициент усиления=13
|
||||
>>> fff
|
||||
13.0
|
||||
>>> dan
|
||||
-91.0
|
||||
```
|
||||
Пояснение:
|
||||
Если выражение будет записанно некорректно, будет возвращена SyntaxError.
|
||||
По умолчанию eval() имеет доступ к глобальным именам.
|
||||
eval() выполняет следующую последовательность действий:
|
||||
Анализ последовательности символов выражения
|
||||
Компилирование в байт-код
|
||||
Выполнение кода
|
||||
Возвращение результата
|
||||
|
||||
|
||||
### Пункт 2.5
|
||||
|
||||
exec - выполнение операций строкой
|
||||
```
|
||||
>>> help(exec)
|
||||
Help on built-in function exec in module builtins:
|
||||
|
||||
exec(source, globals=None, locals=None, /)
|
||||
Execute the given source in the context of globals and locals.
|
||||
|
||||
The source may be a string representing one or more Python statements
|
||||
or a code object as returned by compile().
|
||||
The globals must be a dictionary and locals can be any mapping,
|
||||
defaulting to the current globals and locals.
|
||||
If only globals is given, locals defaults to it.
|
||||
|
||||
>>> exec(input('введите инструкции:'))
|
||||
введите инструкции:perem=-123.456; gg=round(abs(perem)+98,3)
|
||||
>>> gg
|
||||
221.456
|
||||
```
|
||||
Пояснение:
|
||||
eval используется только для вычисления выражений и возвращает результат.
|
||||
exec может выполнять любой код, но не возвращает значение.
|
||||
|
||||
### Пункт 2.6
|
||||
|
||||
Возвращение модуля (abs):
|
||||
```
|
||||
>>> abs(-98)
|
||||
98
|
||||
>>> abs(5 + 4j)
|
||||
6.4031242374328485
|
||||
```
|
||||
Возведение в степень:
|
||||
```
|
||||
>>> help(pow)
|
||||
Help on built-in function pow in module builtins:
|
||||
pow(base, exp, mod=None)
|
||||
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
|
||||
|
||||
Some types, such as ints, are able to use a more efficient algorithm when
|
||||
invoked using the three argument form.
|
||||
|
||||
>>> pow(5,5)
|
||||
3125
|
||||
>>> pow(5,5,10)
|
||||
5
|
||||
```
|
||||
Максимальное из значений:
|
||||
```
|
||||
>>> help(max)
|
||||
Help on built-in function max in module builtins:
|
||||
|
||||
max(...)
|
||||
max(iterable, *[, default=obj, key=func]) -> value
|
||||
max(arg1, arg2, *args, *[, key=func]) -> value
|
||||
With a single iterable argument, return its biggest item. The
|
||||
default keyword-only argument specifies an object to return if
|
||||
the provided iterable is empty.
|
||||
With two or more arguments, return the largest argument.
|
||||
```
|
||||
Обычный пример использования:
|
||||
```
|
||||
>>> max(35,4,-3)
|
||||
35
|
||||
```
|
||||
Со списком:
|
||||
```
|
||||
>>> max([5,0,-10])
|
||||
5
|
||||
```
|
||||
Со словарем:
|
||||
```
|
||||
>>> max({'a': 1, 'b': 2, 'c': 3})
|
||||
'c'
|
||||
```
|
||||
Пояснение:
|
||||
1. Видно, что выбор большего происходит из ключей
|
||||
2. Видно, что среди буквенных символов больше то, которое ближе к концу алфавита
|
||||
|
||||
С разными типами:
|
||||
```
|
||||
>>> max([34,5,6, "hehe", 5+2j])
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#60>", line 1, in <module>
|
||||
max([34,5,6, "hehe", 5+2j])
|
||||
TypeError: '>' not supported between instances of 'str' and 'int'
|
||||
```
|
||||
Пояснение:
|
||||
Видно, что внутри функции max заложен оператор сравнения, и между разными типами
|
||||
он не работает.
|
||||
|
||||
Одинаковые символы разного регистра:
|
||||
```
|
||||
>>> max("b", "B")
|
||||
'b'
|
||||
```
|
||||
Пояснение: тут python сравнивает коды символов в unicode. у "b" это 98, а у "B" - 66.
|
||||
|
||||
Поиск минимума:
|
||||
|
||||
Нюансы аналогичны максимуму, поэтому детально расписаны не будут.
|
||||
|
||||
Сумма элементов:
|
||||
```
|
||||
>>> help(sum)
|
||||
Help on built-in function sum in module builtins:
|
||||
|
||||
sum(iterable, /, start=0)
|
||||
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
|
||||
When the iterable is empty, return the start value.
|
||||
This function is intended specifically for use with numeric values and may
|
||||
reject non-numeric types.
|
||||
```
|
||||
Просто суммирование:
|
||||
```
|
||||
>>> sum([1,2,3,4])
|
||||
10
|
||||
```
|
||||
Суммирование с значением, которое добавляется к сумме:
|
||||
```
|
||||
>>> sum([1,2,3,4], -5)
|
||||
5
|
||||
```
|
||||
Возвращение кортежа из целой части и остатка от деления:
|
||||
```
|
||||
>>> help(divmod)
|
||||
Help on built-in function divmod in module builtins:
|
||||
divmod(x, y, /)
|
||||
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
|
||||
|
||||
>>> divmod(14, 3)
|
||||
(4, 2)
|
||||
```
|
||||
Результаты для отрицательных чисел:
|
||||
```
|
||||
>>> divmod(14, -3)
|
||||
(-5, -1)
|
||||
```
|
||||
Длина объекта:
|
||||
```
|
||||
>>> len((1,2,3,4,10))
|
||||
5
|
||||
>>> len("kukukukukuku")
|
||||
12
|
||||
>>> len(["kukukukukkuuk","kuku"])
|
||||
2
|
||||
>>> len({'a': 1, 'b': 2, 'c': 3})
|
||||
3
|
||||
```
|
||||
Но при этом:
|
||||
```
|
||||
>>> len(43)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#90>", line 1, in <module>
|
||||
len(43)
|
||||
TypeError: object of type 'int' has no len()
|
||||
```
|
||||
Применение функции к каждому элементу коллекции:
|
||||
```
|
||||
>>> help(map)
|
||||
Help on class map in module builtins:
|
||||
class map(object)
|
||||
| map(func, *iterables) --> map object
|
||||
|
|
||||
| Make an iterator that computes the function using arguments from
|
||||
| each of the iterables. Stops when the shortest iterable is exhausted.
|
||||
```
|
||||
Пример:
|
||||
```
|
||||
>>> map(int, ["1", "14"])
|
||||
<map object at 0x00000158BF19F250>
|
||||
>>> list(map(int, ["1", "14"]))
|
||||
[1, 14]
|
||||
```
|
||||
Как следует из справки, если сообщается несколько коллекций, map закончится, когда применит
|
||||
функцию к самой короткой из них.
|
||||
|
||||
## Пункт 3
|
||||
|
||||
Стандартный модуль math
|
||||
```
|
||||
>>> import math
|
||||
>>> dir(math)
|
||||
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
|
||||
'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees',
|
||||
'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp',
|
||||
'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
|
||||
|
||||
>>> help(math.factorial)
|
||||
Help on built-in function factorial in module math:
|
||||
|
||||
factorial(x, /)
|
||||
Find x!.
|
||||
|
||||
Raise a ValueError if x is negative or non-integral.
|
||||
|
||||
>>> math.factorial(5)
|
||||
120
|
||||
```
|
||||
Нахождение синуса:
|
||||
```
|
||||
>>> help(math.sin)
|
||||
Help on built-in function sin in module math:
|
||||
sin(x, /)
|
||||
Return the sine of x (measured in radians).
|
||||
|
||||
>>> math.sin(3.141)
|
||||
0.0005926535550994539
|
||||
>>> math.sin(-1)
|
||||
-0.8414709848078965
|
||||
```
|
||||
Нахождение арккосинуса:
|
||||
```
|
||||
>>> math.acos(1)
|
||||
0.0
|
||||
>>> math.acos(11)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#120>", line 1, in <module>
|
||||
math.acos(11)
|
||||
ValueError: math domain error
|
||||
|
||||
>>> math.acos(-1)
|
||||
3.141592653589793
|
||||
```
|
||||
Перевод из радиан в градусы:
|
||||
```
|
||||
>>> help(math.degrees)
|
||||
Help on built-in function degrees in module math:
|
||||
degrees(x, /)
|
||||
Convert angle x from radians to degrees.
|
||||
|
||||
>>> math.degrees(6.28)
|
||||
359.817495342157
|
||||
|
||||
>>> math.degrees(1)
|
||||
57.29577951308232
|
||||
```
|
||||
Перевод из градусов в радианы:
|
||||
```
|
||||
>>> help(math.radians)
|
||||
Help on built-in function radians in module math:
|
||||
radians(x, /)
|
||||
Convert angle x from degrees to radians.
|
||||
|
||||
>>> math.radians(360)
|
||||
6.283185307179586
|
||||
>>> math.radians(90)
|
||||
1.5707963267948966
|
||||
>>> math.radians(57)
|
||||
0.9948376736367679
|
||||
>>> math.radians(3.1415)
|
||||
0.05482951845140187
|
||||
```
|
||||
Число е в степени заданного:
|
||||
```
|
||||
>>> help(math.exp)
|
||||
Help on built-in function exp in module math:
|
||||
exp(x, /)
|
||||
Return e raised to the power of x.
|
||||
|
||||
>>> math.exp(0)
|
||||
1.0
|
||||
>>> math.exp(1)
|
||||
2.718281828459045
|
||||
>>> math.exp(-5)
|
||||
0.006737946999085467
|
||||
```
|
||||
Нахождение логарифма:
|
||||
```
|
||||
>>> help(math.log)
|
||||
Help on built-in function log in module math:
|
||||
|
||||
log(...)
|
||||
log(x, [base=math.e])
|
||||
Return the logarithm of x to the given base.
|
||||
If the base not specified, returns the natural logarithm (base e) of x.
|
||||
```
|
||||
Если основание логарифма не задано, то он натуральный.
|
||||
```
|
||||
>>> math.log(math.e)
|
||||
1.0
|
||||
>>> math.log(5)
|
||||
1.6094379124341003
|
||||
>>> math.log(25,5)
|
||||
2.0
|
||||
```
|
||||
Согласно нормам математики, логарифмируемое выражение и основание логарифма не могут быть
|
||||
отрицательными. Это есть и в python, попытка задать такие значения вернет ValueError.
|
||||
|
||||
Десятичный логарифм:
|
||||
```
|
||||
>>> math.log10(0.0001)
|
||||
-4.0
|
||||
>>> math.log10(10000)
|
||||
4.0
|
||||
```
|
||||
Извлечение квадратного корня:
|
||||
```
|
||||
>>> math.sqrt(49)
|
||||
7.0
|
||||
```
|
||||
В данном случае, в отличие от канонов матанализа, задание отрицательного аргумента вернет
|
||||
ValueError, а не комплексное число.
|
||||
|
||||
Округление числа до ближайшего целого вверх:
|
||||
```
|
||||
>>> help(math.ceil)
|
||||
Help on built-in function ceil in module math:
|
||||
ceil(x, /)
|
||||
Return the ceiling of x as an Integral.
|
||||
This is the smallest integer >= x.
|
||||
|
||||
>>> math.ceil(5.77)
|
||||
6
|
||||
>>> math.ceil(6.00001)
|
||||
7
|
||||
>>> math.ceil(-6.7)
|
||||
-6
|
||||
>>> math.ceil(-6)
|
||||
-6
|
||||
```
|
||||
Округление вниз:
|
||||
```
|
||||
>>> math.floor(7.99)
|
||||
7
|
||||
>>> math.floor(-3.7)
|
||||
-4
|
||||
```
|
||||
Константа: число пи:
|
||||
```
|
||||
>>> math.pi
|
||||
3.141592653589793
|
||||
```
|
||||
Пример комбинированного использования:
|
||||
```
|
||||
>>> math.sin(2 * math.pi / 7 + math.exp(0.23))
|
||||
0.8334902641414562
|
||||
```
|
||||
|
||||
## Пункт 4
|
||||
```
|
||||
Модуль cmath для работы с комплексными числами
|
||||
|
||||
>>> import cmath
|
||||
>>> dir(cmath)
|
||||
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
|
||||
'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite',
|
||||
'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin',
|
||||
'sinh', 'sqrt', 'tan', 'tanh', 'tau']
|
||||
>>> cmath.sqrt(1.2-0.5j)
|
||||
(1.118033988749895-0.22360679774997896j)
|
||||
>>> cmath.phase(1-0.5j)
|
||||
-0.4636476090008061
|
||||
```
|
||||
## Пункт 5
|
||||
|
||||
Модуль random для генерации псевдослучайных чисел и работы с ними
|
||||
```
|
||||
>>> import random
|
||||
>>> dir(random)
|
||||
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom',
|
||||
'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__',
|
||||
'__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos',
|
||||
'_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi',
|
||||
'_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom',
|
||||
'_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss',
|
||||
'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes',
|
||||
'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular',
|
||||
'uniform', 'vonmisesvariate', 'weibullvariate']
|
||||
|
||||
>>> help(random.seed)
|
||||
Help on method seed in module random:
|
||||
|
||||
seed(a=None, version=2) method of random.Random instance
|
||||
Initialize internal state from a seed.
|
||||
|
||||
The only supported seed types are None, int, float,
|
||||
str, bytes, and bytearray.
|
||||
|
||||
None or no argument seeds from current time or from an operating
|
||||
system specific randomness source if available.
|
||||
|
||||
If *a* is an int, all bits are used.
|
||||
|
||||
For version 2 (the default), all of the bits are used if *a* is a str,
|
||||
bytes, or bytearray. For version 1 (provided for reproducing random
|
||||
sequences from older versions of Python), the algorithm for str and
|
||||
bytes generates a narrower range of seeds.
|
||||
|
||||
>>> random.seed()
|
||||
```
|
||||
Эта функция инициализирует сид, т.е. начальное значение для дальнейшей генерации. Если ничего
|
||||
не указано в скобках, то random.seed() вызывает time.time(), а эта функция, в свою очередь,
|
||||
возвращает время в Unix-формате. То есть в качестве сида используется текущее время.
|
||||
|
||||
Случайное число от 0 до 1:
|
||||
```
|
||||
>>> help(random.random)
|
||||
Help on built-in function random:
|
||||
random() method of random.Random instance
|
||||
random() -> x in the interval [0, 1).
|
||||
|
||||
>>> random.random()
|
||||
0.009279717292968392
|
||||
>>> random.random()
|
||||
0.8044346046065457
|
||||
>>> random.random()
|
||||
0.2928444484701447
|
||||
```
|
||||
Равномерно распределенное случайное число:
|
||||
```
|
||||
>>> help(random.uniform)
|
||||
Help on method uniform in module random:
|
||||
|
||||
uniform(a, b) method of random.Random instance
|
||||
Get a random number in the range [a, b) or [a, b] depending on rounding.
|
||||
|
||||
>>> random.uniform(2,5)
|
||||
4.803201121309196
|
||||
```
|
||||
Равномерное случайное целое:
|
||||
```
|
||||
>>> help(random.randint)
|
||||
Help on method randint in module random:
|
||||
randint(a, b) method of random.Random instance
|
||||
Return random integer in range [a, b], including both end points.
|
||||
|
||||
>>> random.randint(3,18)
|
||||
5
|
||||
>>> random.randint(3,18)
|
||||
13
|
||||
```
|
||||
Случайное из коллекции:
|
||||
```
|
||||
>>> help(random.choice)
|
||||
Help on method choice in module random:
|
||||
|
||||
choice(seq) method of random.Random instance
|
||||
Choose a random element from a non-empty sequence.
|
||||
```
|
||||
Вернет IndexError, если коллекция пустая.
|
||||
```
|
||||
>>> random.choice([False, "hehehe", 67, 90.7, 5+8j])
|
||||
90.7
|
||||
```
|
||||
Случайное перемешивание элементов коллекции:
|
||||
```
|
||||
>>> help(random.shuffle)
|
||||
Help on method shuffle in module random:
|
||||
|
||||
shuffle(x, random=None) method of random.Random instance
|
||||
Shuffle list x in place, and return None.
|
||||
Optional argument random is a 0-argument function returning a
|
||||
random float in [0.0, 1.0); if it is the default None, the
|
||||
standard random.random will be used.
|
||||
|
||||
>>> lst = [False, "hehehe", 67, 90.7, 5+8j]
|
||||
>>> random.shuffle(lst)
|
||||
>>> lst
|
||||
[67, False, 90.7, (5+8j), 'hehehe']
|
||||
```
|
||||
Возвращает None, изменяет исходный объект. Работает только с изменяемами типами.
|
||||
|
||||
Нормально распределенное случайное число:
|
||||
```
|
||||
>>> help(random.gauss)
|
||||
Help on method gauss in module random:
|
||||
|
||||
gauss(mu, sigma) method of random.Random instance
|
||||
Gaussian distribution.
|
||||
mu is the mean, and sigma is the standard deviation. This is
|
||||
slightly faster than the normalvariate() function.
|
||||
Not thread-safe without a lock around calls.
|
||||
```
|
||||
Без заданных матожидания и дисперсии, в отличие, например, от R, возвращает TypeError, а не
|
||||
берет 0 и 1 как значения по умолчанию.
|
||||
```
|
||||
>>> random.gauss(0,1)
|
||||
1.1859475053515318
|
||||
```
|
||||
Случайное подмножество:
|
||||
```
|
||||
>>> help(random.sample)
|
||||
Help on method sample in module random:
|
||||
|
||||
sample(population, k, *, counts=None) method of random.Random instance
|
||||
Chooses k unique random elements from a population sequence or set.
|
||||
|
||||
Returns a new list containing elements from the population while
|
||||
leaving the original population unchanged. <...>
|
||||
|
||||
>>> random.sample(lst, 5)
|
||||
['cherry', 'tangerine', 'banana', 'pineapple', 'peach']
|
||||
>>> random.sample(lst, 1)
|
||||
['tangerine']
|
||||
>>> random.sample(lst, 0)
|
||||
[]
|
||||
```
|
||||
Поставить как k число большее, чем длина коллекции, нельзя (TypeError)
|
||||
|
||||
Случайное число, подчиняющееся бета-распределению:
|
||||
```
|
||||
>>> help(random.betavariate)
|
||||
Help on method betavariate in module random:
|
||||
|
||||
betavariate(alpha, beta) method of random.Random instance
|
||||
Beta distribution.
|
||||
Conditions on the parameters are alpha > 0 and beta > 0.
|
||||
Returned values range between 0 and 1.
|
||||
|
||||
>>> random.betavariate(1,2)
|
||||
0.4074810441922475
|
||||
```
|
||||
Случайное число, подчиняющееся гамма-распределению:
|
||||
```
|
||||
>>> help(random.gammavariate)
|
||||
Help on method gammavariate in module random:
|
||||
|
||||
gammavariate(alpha, beta) method of random.Random instance
|
||||
Gamma distribution. Not the gamma function!
|
||||
|
||||
Conditions on the parameters are alpha > 0 and beta > 0.
|
||||
|
||||
The probability distribution function is:
|
||||
|
||||
x ** (alpha - 1) * math.exp(-x / beta)
|
||||
pdf(x) = --------------------------------------
|
||||
math.gamma(alpha) * beta ** alpha
|
||||
|
||||
>>> random.gammavariate(2,4)
|
||||
1.9359228890418254
|
||||
```
|
||||
Список из четырех чисел с разными законами распределения:
|
||||
```
|
||||
>>> rl = [0] * 4
|
||||
>>> rl[0] = random.uniform(2,6)
|
||||
>>> rl[1] = random.gauss(2, 0.5)
|
||||
>>> rl[2] = random.betavariate(2,6)
|
||||
>>> rl[3] = random.gammavariate(2,6)
|
||||
>>> rl
|
||||
[2.6190336401985204, 1.82010731374589, 0.18732603571429413, 20.348843073887398]
|
||||
```
|
||||
## Пункт 6
|
||||
```
|
||||
time - модуль для работы со временем
|
||||
>>> import time
|
||||
>>> dir(time)
|
||||
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__',
|
||||
'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime',
|
||||
'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time',
|
||||
'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time',
|
||||
'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
|
||||
```
|
||||
UNIX-время:
|
||||
```
|
||||
>>> c1 = time.time()
|
||||
>>> c1
|
||||
1758971496.5712385
|
||||
>>> c2=time.time()-c1
|
||||
>>> c2
|
||||
8.266037702560425
|
||||
```
|
||||
Возвращается время в секундах с начала эпохи UNIX: 00:00:00 UTC 1 января 1970 года.
|
||||
|
||||
Текущее время:
|
||||
```
|
||||
>>> time.gmtime
|
||||
<built-in function gmtime>
|
||||
|
||||
>>> help(time.gmtime)
|
||||
Help on built-in function gmtime in module time:
|
||||
|
||||
gmtime(...)
|
||||
gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
|
||||
tm_sec, tm_wday, tm_yday, tm_isdst)
|
||||
|
||||
Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
|
||||
GMT). When 'seconds' is not passed in, convert the current time instead.
|
||||
|
||||
If the platform supports the tm_gmtoff and tm_zone, they are available as
|
||||
attributes only.>>> dat=time.gmtime()
|
||||
|
||||
>>> dat=time.gmtime()
|
||||
>>> list(dat)
|
||||
[2025, 9, 27, 11, 12, 18, 5, 270, 0]
|
||||
>>> dat.tm_mon
|
||||
9
|
||||
>>> dat.tm_year
|
||||
2025
|
||||
>>> dat.tm_yday
|
||||
270
|
||||
>>> dat.tm_isdst #Показывает, действует ли летнее время (0 - нет, 1 - да, -1 - нет данных)
|
||||
0
|
||||
```
|
||||
Текущее время с учетом часового пояса:
|
||||
```
|
||||
>>> here = time.localtime()
|
||||
>>> list(here)
|
||||
[2025, 9, 27, 14, 16, 28, 5, 270, 0]
|
||||
```
|
||||
Время из кортежа в строку:
|
||||
```
|
||||
>>> time.asctime(here)
|
||||
'Sat Sep 27 14:16:28 2025'
|
||||
```
|
||||
Время из секунд в строку:
|
||||
```
|
||||
>>> time.ctime()
|
||||
'Sat Sep 27 14:17:07 2025'
|
||||
```
|
||||
Пауза:
|
||||
```
|
||||
>>> time.sleep(5)
|
||||
```
|
||||
Из кортежа в секунды с начала эпохи:
|
||||
```
|
||||
>>> time.mktime(here)
|
||||
1758971788.0
|
||||
```
|
||||
## Пункт 7
|
||||
```
|
||||
Графические функции модуля pylab пакета matplotlib
|
||||
|
||||
>>> import matplotlib
|
||||
>>> import pylab
|
||||
|
||||
>>> x=list(range(-3,55,4))
|
||||
>>> t=list(range(15))
|
||||
|
||||
>>> pylab.plot(t,x) #Создание графика в оперативной памяти
|
||||
[<matplotlib.lines.Line2D object at 0x00000158D9921670>]
|
||||
|
||||
>>> pylab.title('Первый график')
|
||||
Text(0.5, 1.0, 'Первый график')
|
||||
|
||||
>>> pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
>>> pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
|
||||
>>> pylab.show()
|
||||
```
|
||||
Открылось внешнее окно с графиком. Файл сохранен с именем Ris1
|
||||
|
||||
Два графика на одном окне:
|
||||
```
|
||||
>>> X1=[12,6,8,10,7]
|
||||
>>> X2=[5,7,9,11,13]
|
||||
>>> pylab.plot(X1)
|
||||
[<matplotlib.lines.Line2D object at 0x00000158D9AEB130>]
|
||||
>>> pylab.plot(X2)
|
||||
[<matplotlib.lines.Line2D object at 0x00000158D9AEB3D0>]
|
||||
>>> pylab.show()
|
||||
```
|
||||
Появились две ломаные линии синего и оранжевого цвета.
|
||||
|
||||
Круговая диаграмма:
|
||||
```
|
||||
>>> region=['Центр','Урал','Сибирь','Юг']
|
||||
>>> naselen=[65,12,23,17]
|
||||
>>> naselen=[65,12,23,17]
|
||||
([<matplotlib.patches.Wedge object at 0x00000158DBCC8820>, <matplotlib.patches.Wedge object at 0x00000158DBCC8760>, <matplotlib.patches.Wedge object at 0x00000158DBCC8FD0>, <matplotlib.patches.Wedge object at 0x00000158DBCDE490>], [Text(-0.1910130855889933, 1.083288512416601, 'Центр'), Text(-0.8613283319035216, -0.6841882085072037, 'Урал'), Text(0.04429273729355889, -1.0991078898011077, 'Сибирь'), Text(0.9873752043868569, -0.4848610169543564, 'Юг')])
|
||||
>>> pylab.show()
|
||||
```
|
||||
Сохранено в Ris2
|
||||
|
||||
Столбиковая диаграмма:
|
||||
```
|
||||
>>> fruits = ["apple", "date", "apricot", "raspberry", "watermelon"]
|
||||
>>> values = [10, 15, 7, 20, 3]
|
||||
>>> pylab.bar(fruits, values, color='skyblue')
|
||||
<BarContainer object of 5 artists>
|
||||
>>> pylab.show()
|
||||
```
|
||||
Сохранено в Ris4
|
||||
|
||||
## Пункт 8
|
||||
|
||||
Статистический модуль statistics
|
||||
```
|
||||
>>> dir(statistics)
|
||||
['Counter', 'Decimal', 'Fraction', 'NormalDist', 'StatisticsError', '__all__',
|
||||
'__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
|
||||
'__package__', '__spec__', '_coerce', '_convert', '_exact_ratio', '_fail_neg',
|
||||
'_find_lteq', '_find_rteq', '_isfinite', '_normal_dist_inv_cdf', '_ss', '_sum',
|
||||
'bisect_left', 'bisect_right', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean',
|
||||
'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'log', 'math', 'mean', 'median',
|
||||
'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'numbers', 'pstdev',
|
||||
'pvariance', 'quantiles', 'random', 'sqrt', 'stdev', 'tau', 'variance']
|
||||
```
|
||||
Математическое ожидание:
|
||||
```
|
||||
>>> data = [10, 20, 30, 40, 50]
|
||||
>>> statistics.mean(data)
|
||||
30
|
||||
```
|
||||
Если объект пустой, вернет StatisticsError
|
||||
|
||||
Медиана:
|
||||
```
|
||||
>>> statistics.median(data)
|
||||
30
|
||||
```
|
||||
Среднеквадратичное отклонение:
|
||||
```
|
||||
>>> statistics.stdev(data)
|
||||
15.811388300841896
|
||||
```
|
||||
Среднее можно сообщить самостоятельно: stdev(data, xbar=None)
|
||||
|
||||
Дисперсия:
|
||||
```
|
||||
>>> statistics.variance(data)
|
||||
250
|
||||
```
|
||||
Квантили:
|
||||
```
|
||||
>>> data = [10, 56, 73, 7, 20, 30, 40, 50, 56, 77, 3]
|
||||
>>> statistics.quantiles(data)
|
||||
[10.0, 40.0, 56.0]
|
||||
```
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,66 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 4
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Пункт 1
|
||||
Напишите и исполните единое выражение, реализующее последовательное выполнение
|
||||
следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата
|
||||
до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из
|
||||
двух значений: округленное вниз значение от деления результата на 3 и остатка от этого
|
||||
деления
|
||||
```
|
||||
>>> divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
|
||||
(8.0, 2.6000000000000014)
|
||||
```
|
||||
## Пункт 2
|
||||
Создайте объект класса struct_time с временными параметрами для текущего
|
||||
московского времени. Создайте строку с текущим часом и минутами.
|
||||
```
|
||||
>>> nowtime = time.localtime()
|
||||
>>> nowtime
|
||||
time.struct_time(tm_year=2025, tm_mon=9,
|
||||
tm_mday=27, tm_hour=1, tm_min=44, tm_sec=10, tm_wday=0, tm_yday=274, tm_isdst=0)
|
||||
>>> nows = str(nowtime.tm_hour) + " " + str(nowtime.tm_min)
|
||||
>>> nows
|
||||
'15 19'
|
||||
```
|
||||
## Пункт 3
|
||||
Создайте список с элементами – названиями дней недели. Сделайте случайную выборку
|
||||
из этого списка с тремя днями недели.
|
||||
```
|
||||
>>> week = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
|
||||
>>> random.sample(week, 3)
|
||||
['воскресенье', 'понедельник', 'пятница']
|
||||
```
|
||||
## Пункт 4
|
||||
Напишите инструкцию случайного выбора числа из последовательности целых чисел от
|
||||
14 до 32 с шагом 3.
|
||||
```
|
||||
>>> random.choice(range(14, 32, 3))
|
||||
26
|
||||
>>> random.choice(range(14, 32, 3))
|
||||
14
|
||||
```
|
||||
## Пункт 5
|
||||
Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и
|
||||
стандартным отклонением 4 и округлите его до целого значения. Создайте список с N
|
||||
элементами – случайно выбранными буквами латинского алфавита.
|
||||
```
|
||||
>>> N = round(random.gauss(15,4))
|
||||
>>> N
|
||||
10
|
||||
>>> lst = list("abcdefghijgklmnopqrstuvwxyz")
|
||||
>>> random.sample(lst, N)
|
||||
['q', 'g', 'i', 'z', 'h', 'y', 'r', 'o', 'f', 'n']
|
||||
```
|
||||
Или в одну строку:
|
||||
```
|
||||
>>> random.sample(list("abcdefghijgklmnopqrstuvwxyz"), round(random.gauss(15,4)))
|
||||
['y', 'l', 'f', 'x', 'o', 'e', 'h', 'i', 'b', 'd', 't', 'm', 'n', 'a', 'j', 'u', 'g', 'g', 's']
|
||||
```
|
||||
## Пункт 6
|
||||
Напишите инструкцию для определения временного интервала в минутах, прошедшего с
|
||||
момента предыдущего (из п.2) определения временных параметров.
|
||||
```
|
||||
>>> (time.mktime(nowtime) - time.mktime(time.localtime())) / 60
|
||||
-4.166666666666667
|
||||
```
|
||||
@ -0,0 +1,15 @@
|
||||
# Индивидуальное контрольное задание по Теме 4
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
## Задание:
|
||||
Вариант 8: Напишите инструкцию создания переменной со значением – календарными данными момента начала выполнения контрольного задания. Создайте кортеж с последовательностью элементов со значениями от -26 до 46 с шагом 9. Подсчитайте число элементов в созданном кортеже. Отобразите результат в виде строки по шаблону: «Число элементов = <значение>». Напишите инструкцию определения числа секунд, прошедших с начала выполнения контрольного задания.
|
||||
## Решение:
|
||||
```
|
||||
>>> start_time = time.time()
|
||||
>>> a = tuple(range(-26, 47, 9))
|
||||
>>> count = len(a)
|
||||
>>> print(f"Число элементов = {count}")
|
||||
Число элементов = 9
|
||||
>>> proshlo_sekund = time.time() - start_time
|
||||
>>> print(f"Прошло секунд: {proshlo_sekund:.6f}")
|
||||
Прошло секунд: 258.212157
|
||||
```
|
||||
|
После Ширина: | Высота: | Размер: 30 KiB |
|
После Ширина: | Высота: | Размер: 18 KiB |
@ -0,0 +1,445 @@
|
||||
# Тема 5. Блоки инструкций, управляющие инструкции
|
||||
Выполнил: Тимошенко А.А.
|
||||
Проверил: Козлюк Д. А.
|
||||
|
||||
## Пункт 1.
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА5")
|
||||
```
|
||||
## Пункт 2. Ветвление по условию (if)
|
||||
|
||||
Общий вид выглядит так:
|
||||
|
||||
if <условие>:
|
||||
<отступы> <Блок инструкций, выполняемый, если условие истинно>
|
||||
[elif <условие2>:
|
||||
<отступы><Блок инструкций2, выполняемый, если условие2 истинно>
|
||||
]
|
||||
[else:
|
||||
< отступы><Блок инструкций3, выполняемый, если условие ложно>
|
||||
]
|
||||
|
||||
Причем elif и else вместе или по отдельности могут отсуствовать.
|
||||
|
||||
Пример:
|
||||
```
|
||||
>>> porog = 6
|
||||
>>> rashod1 = 8
|
||||
>>> rashod2 = 5
|
||||
>>> if rashod1 >= porog:
|
||||
dohod = 12 # Это выполняется, если rashod1 >= porog
|
||||
elif rashod2 == porog:
|
||||
dohod = 0 # Это выполняется, если первое условие ложно, но rashod2 == porog
|
||||
else:
|
||||
dohod = -8 # Это выполняется, если ни первое, ни второе условие не были истинными
|
||||
|
||||
>>> dohod
|
||||
12
|
||||
```
|
||||
Оператор rashod1 >= porog (например, в числах, 8 >= 5) возвращает логическое значение True,
|
||||
поэтому будет выполняться блок инструкций, соответствующий этому условию. Важно понимать,
|
||||
что в конструкции if-elif-else всегда выполняется только одна ветвь. Даже если условие
|
||||
в elif также истинно, оно не будет проверено и, соответственно, не выполнится, если до
|
||||
этого уже выполнился блок if. Это связано с тем, что после выполнения любого блока
|
||||
инструкции (будь то if, elif или else) остальные части конструкции игнорируются.
|
||||
|
||||
Перезададим некоторые значения и выполним другую управляющую инструкцию:
|
||||
```
|
||||
>>> rashod2 = 4
|
||||
>>> porog = 4
|
||||
>>> if rashod1 >= 3 and rashod2 == 4: #Верно
|
||||
dohod = rashod1
|
||||
if rashod2 == porog or rashod1 < rashod2: #Тоже верно
|
||||
dohod = porog
|
||||
|
||||
>>> dohod
|
||||
4
|
||||
```
|
||||
В данном случае выполняются оба if, потому что один находится в блоке инструкций другого
|
||||
вложенное условие). Вложенное условие будет проверяться в любом случае, если выполнилось
|
||||
внешнее.
|
||||
```
|
||||
>>> if porog == 3: #Неверно
|
||||
dohod = 1
|
||||
elif porog == 4: #Верно
|
||||
dohod = 2
|
||||
elif porog == 5: #Игнорируется
|
||||
dohod = 3
|
||||
else: #Игнорируется
|
||||
dohod = 0
|
||||
|
||||
>>> dohod
|
||||
2
|
||||
```
|
||||
Еще одна форма записи условных управляющих инструкций - тернарный оператор (от лат. "тройной"):
|
||||
|
||||
<Объект> = <значение 1> if <условие> else <значение 2>
|
||||
```
|
||||
>>> dohod = 2 if porog >= 4 else 0
|
||||
>>> dohod
|
||||
2
|
||||
```
|
||||
Если в блоке инструкций всего одна строка, можно записать всё в одну строку:
|
||||
```
|
||||
>>> porog = 2
|
||||
>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
|
||||
|
||||
>>> rashod1
|
||||
8
|
||||
>>> rashod2
|
||||
4
|
||||
```
|
||||
Поскольку сейчас значение porog было задано таким, чтобы не удовлетворять условию, то
|
||||
эта строка полностью не была выполнена и не повлияла на значения переменных. Но в другом
|
||||
случае:
|
||||
```
|
||||
>>> porog = 7
|
||||
>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
|
||||
|
||||
>>> rashod1
|
||||
6
|
||||
>>> rashod2
|
||||
0
|
||||
```
|
||||
Выполняется условие и выполняются инструкции.
|
||||
|
||||
## Пункт 3. Цикл по перечислению (for)
|
||||
|
||||
for <Объект-переменная цикла> in <объект>:
|
||||
<отступы> <Блок инструкций 1 – тело цикла>
|
||||
[else:
|
||||
<отступы> <Блок инструкций 2 – если в цикле не сработал break>]
|
||||
|
||||
В качестве объекта сойдёт любая коллекция или, например, диапазон range. Если сообщить
|
||||
словарь, то будут перебираться его ключи. Если сообщить множество, перебор будет осуществлен,
|
||||
но порядок будет неочевидным.
|
||||
|
||||
|
||||
### Пункт 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]
|
||||
```
|
||||
Как видно, в конец цикла добавляется двойка до тех пор, пока длина не превысит 10. Важно
|
||||
понимать, что sps - это и объект, по которому проходит k, и объект, изменяющийся
|
||||
внутри цикла. То есть k будет двигаться по циклу бесконечно, и выполнение останавливается
|
||||
именно из-за условия if - else.
|
||||
(При этом else в данном случае относится к if, а не к for (это можно понять не только по
|
||||
смыслу, но и по табуляции)
|
||||
|
||||
Рассмотрим другой вариант:
|
||||
```
|
||||
>>> 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]
|
||||
```
|
||||
Как видно, итог другой, и вот почему. Операция взятия среза sps[:] создает полную копию
|
||||
исходного списка (грубо говоря, срез от начала до конца включительно).
|
||||
Теперь список, по которому пробегается k, и список, изменяющийся внутри цикла - это объекты,
|
||||
имеющие разные адреса. Это можно проверить:
|
||||
```
|
||||
>>> id(sps)
|
||||
1684034116672
|
||||
>>> id(sps[:])
|
||||
1684069134400
|
||||
```
|
||||
Следовательно, else не успеет сработать, потому что итерируемый в управляющей инструкции
|
||||
объект окажется короче и завершит цикл раньше:
|
||||
|
||||
### Пункт 3.3
|
||||
```
|
||||
>>> 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
|
||||
501
|
||||
>>> sps5
|
||||
[25, 66, 4, 30, 8, 97, 87, 11, 51, 57, 65]
|
||||
```
|
||||
После того, как прошло одиннадцать итераций, сумма элементов списка уже была больше 500, поэтому
|
||||
цикл закончился из-за if, а не из-за окончания диапазона range(10).
|
||||
|
||||
Попробуем обнулить список и выполнить ту же программу еще раз:
|
||||
```
|
||||
>>> sps5 = []
|
||||
>>> for i in range(10):
|
||||
sps5.append(rn.randint(1,100))
|
||||
ss = sum(sps5)
|
||||
if ss > 500: break
|
||||
else:
|
||||
print(ss)
|
||||
|
||||
436
|
||||
```
|
||||
В этот раз программа вывела ответ самостоятельно, потому что сработал else, потому что
|
||||
за все десять итераций цикла так и не успел выполниться break по условию if.
|
||||
|
||||
Примечание:
|
||||
Рассмотрим строку >>> import random as rn
|
||||
Если мы попробуем вызвать функцию из этого модуля по ее исходному названию, ничего не
|
||||
выйдет:
|
||||
```
|
||||
>>> random.randint(4,7)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#105>", line 1, in <module>
|
||||
random.randint(4,7)
|
||||
NameError: name 'random' is not defined
|
||||
```
|
||||
Так происходит потому, что на этапе преобразования программы в байт-код python связывает
|
||||
модуль random, найденный где-то в каталогах, принадлежащих python, с именем rs. Модуль
|
||||
random становится объектом в пространстве имен, создаётся ссылка на объект модуля random
|
||||
и ему присваивается имя rn. Но имя random ему НЕ присваивается, поэтому обратиться к
|
||||
методам и атрибутам по имени random нельзя.
|
||||
|
||||
|
||||
### Пункт 3.4. Пример с символьной строкой
|
||||
```
|
||||
>>> stroka = 'Это – автоматизированная система'
|
||||
>>> stroka1 = ""
|
||||
>>> for ss in stroka:
|
||||
stroka1 += " " + ss
|
||||
|
||||
|
||||
>>> stroka1
|
||||
' Э т о – а в т о м а т и з и р о в а н н а я с и с т е м а'
|
||||
```
|
||||
Переменная ss проходит по всему строковому объекту, на каждой итерации принимая значение
|
||||
одного знака. Этот знак с предшествующим пробелом дописывается в конец другой, изначально
|
||||
пустой строки. Цикл закончится, когда закончится исходная строка.
|
||||
|
||||
### Пункт 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]
|
||||
```
|
||||
Такая конструкция называется list comprehention (генератор списков). В общем
|
||||
виде она выглядит так:
|
||||
|
||||
<итоговый список> = [<выражение> for <элемент> in <исходный объект> if <условие>]
|
||||
|
||||
Эту синусоиду можно отобразить на графике:
|
||||
```
|
||||
>>> import pylab
|
||||
>>> pylab.plot(sps2, label='Синусоидальный сигнал', color = 'green')
|
||||
[<matplotlib.lines.Line2D object at 0x0000018834CBB460>]
|
||||
>>> pylab.show()
|
||||
```
|
||||
Полученный график корректен и и сохранен в файле Figure_1
|
||||
|
||||
|
||||
## Пункт 4. Цикл "пока истинно условие" (while)
|
||||
|
||||
Общий вид:
|
||||
```
|
||||
while <Условие>:
|
||||
<отступы><Блок инструкций 1 – тело цикла>
|
||||
[else:
|
||||
<отступы><Блок инструкций 2 – если в цикле не сработал break>]
|
||||
|
||||
break и else работают аналогично предыдущему случаю.
|
||||
```
|
||||
### Пункт 4.1. Цикл со счетчиком
|
||||
```
|
||||
>>> rashod = 300
|
||||
>>> while rashod:
|
||||
print("Расход =",rashod)
|
||||
rashod -= 50
|
||||
|
||||
Расход = 300
|
||||
Расход = 250
|
||||
Расход = 200
|
||||
Расход = 150
|
||||
Расход = 100
|
||||
Расход = 50
|
||||
```
|
||||
Как именно произошло завершение цикла? Нужно вспомнить, что все числа, кроме нуля, при
|
||||
конвертации в логический тип данных имеют логическое значение True:
|
||||
```
|
||||
>>> bool(50)
|
||||
True
|
||||
```
|
||||
И только нуль имеет значение False:
|
||||
```
|
||||
>>> bool(0)
|
||||
False
|
||||
```
|
||||
Сравниваемая в управляющей инструкции переменная уменьшается в самом цикле, поэтому, когда
|
||||
строка со сравнением обнаружит 0, то воспримет это как False, и действия по выводу
|
||||
и уменьшению числа выполняться больше не будут.
|
||||
|
||||
### Пункт 4.2. Пример с символьной строкой
|
||||
```
|
||||
>>> import math
|
||||
>>> stroka='Расчет процесса в объекте регулирования'
|
||||
>>> i=0
|
||||
>>> sps2=[]
|
||||
>>> while i<len(stroka):
|
||||
r=1-2/(1+math.exp(0.1*i))
|
||||
sps2.append(r)
|
||||
print('Значение в момент',i,"=",r)
|
||||
i+=1
|
||||
|
||||
|
||||
Значение в момент 0 = 0.0
|
||||
Значение в момент 1 = 0.049958374957880025
|
||||
Значение в момент 2 = 0.09966799462495568
|
||||
Значение в момент 3 = 0.14888503362331795
|
||||
...
|
||||
Значение в момент 37 = 0.9517459571646616
|
||||
Значение в момент 38 = 0.9562374581277391
|
||||
```
|
||||
У цикла 38 повторений, по числу элементов в строке, но на 1 меньше. На каждой итерации
|
||||
значение i на единицу меньше, чем в предыдущей.
|
||||
```
|
||||
>>> pylab.plot(sps2, label='Сигнал выхода', color='red')
|
||||
[<matplotlib.lines.Line2D object at 0x00000188336D9FA0>]
|
||||
>>> pylab.title("Сигнал на выходе инерционного звена")
|
||||
Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
|
||||
>>> pylab.show()
|
||||
```
|
||||
График сохранен под именем Figure_2.
|
||||
|
||||
|
||||
### Пункт 4.3. Определение, является ли число простым (делится только на самого себя или 1).
|
||||
```
|
||||
>>> chislo = 267
|
||||
>>> kandidat = chislo // 2
|
||||
>>> while kandidat > 1:
|
||||
if chislo % kandidat == 0:
|
||||
print(chislo, ' имеет множитель ', kandidat)
|
||||
break
|
||||
kandidat -= 1
|
||||
else:
|
||||
print(chislo, ' является простым!')
|
||||
|
||||
|
||||
267 имеет множитель 89
|
||||
```
|
||||
Программа работает так: переменная kandidat отвечает за потенциальный делитель заданного
|
||||
числа. Изначально мы задаем половину от заданного числа, потому что у числа не может быть
|
||||
делителя большего, чем половина от него. Далее мы последовательно уменьшаем потенциальный
|
||||
множитель, каждый раз проверяя, получилось ли поделить без остатка. Если получилось, то
|
||||
число непростое, и цикл можно прекращать досрочно. Если цикл отработал до конца, не
|
||||
прервавшись, то число простое.
|
||||
|
||||
Дополниим программу так, чтобы она проверяла все числа от 250 до 300.
|
||||
```
|
||||
>>> chislo = [x for x in range (250, 301)]
|
||||
>>> for now in chislo:
|
||||
kandidat = now // 2
|
||||
while kandidat > 1:
|
||||
if now % kandidat == 0:
|
||||
print(now, ' имеет множитель ', kandidat)
|
||||
break
|
||||
kandidat -= 1
|
||||
else: #ОБЯЗАТЕЛЬНО относится не к if и не к for, а к while
|
||||
print(now, " является простым!")
|
||||
|
||||
|
||||
250 имеет множитель 125
|
||||
251 является простым!
|
||||
252 имеет множитель 126
|
||||
253 имеет множитель 23
|
||||
254 имеет множитель 127
|
||||
255 имеет множитель 85
|
||||
256 имеет множитель 128
|
||||
257 является простым!
|
||||
258 имеет множитель 129
|
||||
259 имеет множитель 37
|
||||
260 имеет множитель 130
|
||||
261 имеет множитель 87
|
||||
262 имеет множитель 131
|
||||
263 является простым!
|
||||
264 имеет множитель 132
|
||||
265 имеет множитель 53
|
||||
266 имеет множитель 133
|
||||
267 имеет множитель 89
|
||||
268 имеет множитель 134
|
||||
269 является простым!
|
||||
270 имеет множитель 135
|
||||
271 является простым!
|
||||
272 имеет множитель 136
|
||||
273 имеет множитель 91
|
||||
274 имеет множитель 137
|
||||
275 имеет множитель 55
|
||||
276 имеет множитель 138
|
||||
277 является простым!
|
||||
278 имеет множитель 139
|
||||
279 имеет множитель 93
|
||||
280 имеет множитель 140
|
||||
281 является простым!
|
||||
282 имеет множитель 141
|
||||
283 является простым!
|
||||
284 имеет множитель 142
|
||||
285 имеет множитель 95
|
||||
286 имеет множитель 143
|
||||
287 имеет множитель 41
|
||||
288 имеет множитель 144
|
||||
289 имеет множитель 17
|
||||
290 имеет множитель 145
|
||||
291 имеет множитель 97
|
||||
292 имеет множитель 146
|
||||
293 является простым!
|
||||
294 имеет множитель 147
|
||||
295 имеет множитель 59
|
||||
296 имеет множитель 148
|
||||
297 имеет множитель 99
|
||||
298 имеет множитель 149
|
||||
299 имеет множитель 23
|
||||
300 имеет множитель 150
|
||||
```
|
||||
### Пункт 4.4. Инструкция continue.
|
||||
|
||||
Она используется, когда надо при определенном условии не завершить весь цикл, а завершить
|
||||
только текущую итерацию.
|
||||
|
||||
Пример (вывести только положительные числа):
|
||||
```
|
||||
>>> nums = [rn.randint(-30, 30) for x in range(15)]
|
||||
>>> nums
|
||||
[-11, -1, 25, -11, 12, 24, -28, -16, -2, 15, -25, -2, -15, 9, -4]
|
||||
|
||||
>>> for now in nums:
|
||||
if now < 0: continue
|
||||
print(now, " > 0")
|
||||
else: print("все числа обработаны")
|
||||
|
||||
25 > 0
|
||||
12 > 0
|
||||
24 > 0
|
||||
15 > 0
|
||||
9 > 0
|
||||
все числа обработаны
|
||||
```
|
||||
@ -0,0 +1,98 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 5
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Задание
|
||||
Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи)
|
||||
определите порядковый номер каждой буквы в английском алфавите.
|
||||
Создайте список со словами из задания данного пункта. Для этого списка – определите,
|
||||
есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о
|
||||
нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с
|
||||
отсутствующим словом).
|
||||
Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в
|
||||
летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных
|
||||
списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции,
|
||||
позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние
|
||||
баллы по двум сессиям.
|
||||
|
||||
## Решение
|
||||
```
|
||||
>>> alphabet = "abcdefghijklmnopqrstuvwxyz"
|
||||
>>> text = "There is a house in New Orleans, They call The Rising Sun"
|
||||
>>> for now in range(len(text)):
|
||||
low = text.lower()
|
||||
letter = low[now]
|
||||
if not letter in alphabet:
|
||||
continue
|
||||
else:
|
||||
print("Буква ", letter, " имеет ", alphabet.index(letter) + 1,
|
||||
"порядковый номер в алфавите")
|
||||
|
||||
Буква t имеет 20 порядковый номер в алфавите
|
||||
Буква h имеет 8 порядковый номер в алфавите
|
||||
Буква e имеет 5 порядковый номер в алфавите
|
||||
Буква r имеет 18 порядковый номер в алфавите
|
||||
...
|
||||
Буква g имеет 7 порядковый номер в алфавите
|
||||
Буква s имеет 19 порядковый номер в алфавите
|
||||
Буква u имеет 21 порядковый номер в алфавите
|
||||
Буква n имеет 14 порядковый номер в алфавите
|
||||
|
||||
>>> text = """Создайте список со словами из задания данного пункта Для этого
|
||||
списка определите есть ли в нем некоторое заданное значение и выведите соответствующее
|
||||
сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с
|
||||
имеющимся так и с отсутствующим словом"""
|
||||
>>> lst = text.split(" ")
|
||||
>>> lst
|
||||
['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого',
|
||||
'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и',
|
||||
'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо',
|
||||
'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и',
|
||||
'с', 'отсутствующим', 'словом']
|
||||
|
||||
>>> target = "либо"
|
||||
>>> for now in lst:
|
||||
if now == target:
|
||||
print ("Такое слово есть")
|
||||
break
|
||||
else:
|
||||
print("Такого слова нет")
|
||||
|
||||
Такое слово есть
|
||||
|
||||
>>> target = "космос"
|
||||
>>> for now in lst:
|
||||
if now == target:
|
||||
print ("Такое слово есть")
|
||||
break
|
||||
else:
|
||||
print("Такого слова нет")
|
||||
|
||||
Такого слова нет
|
||||
|
||||
>>> studs = ["Timoshenko", "Hodyk", "Kovalenko", "Ivanov"]
|
||||
>>> summer_marks = [4.52, 4.50, 4.40, 4.10]
|
||||
>>> studs2 = ["Ivanov", "Kovalenko", "Hodyk", "Timoshenko"]
|
||||
>>> winter_marks = [4.3, 4.23, 4.16, 4.82]
|
||||
|
||||
>>> student = input("Введите фамилию: ")
|
||||
Введите фамилию: Timoshenko
|
||||
>>> while student != "q":
|
||||
if (student in studs) and (student in studs2):
|
||||
sum_answer = summer_marks[studs.index(student)]
|
||||
win_answer = winter_marks[studs2.index(student)]
|
||||
print("Балл летом: ", sum_answer, "\nЗимой: ", win_answer, "\nСредний :",
|
||||
(sum_answer + win_answer)/2)
|
||||
else:
|
||||
print("Такого студента нет :(")
|
||||
student = input("Введите фамилию (q для выхода): ")
|
||||
|
||||
|
||||
Балл летом: 4.52
|
||||
Зимой: 4.82
|
||||
Средний : 4.67
|
||||
Введите фамилию (q для выхода): Kovalenko
|
||||
Балл летом: 4.4
|
||||
Зимой: 4.23
|
||||
Средний : 4.315
|
||||
Введите фамилию (q для выхода): q
|
||||
```
|
||||
@ -0,0 +1,61 @@
|
||||
# Индивидуальное контрольное задание по Теме 5
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
## Задание:
|
||||
Вариант 4: Создайте список с 20 случайными, нормально распределенными (математическое ожидание равно 3400, стандартное отклонение равно 121) числами. Рассчитайте по нему среднее значе-ние и число элементов, значение которых превышает это среднее.
|
||||
## Решение:
|
||||
```
|
||||
>>> import random
|
||||
>>> # Параметры распределения из задания
|
||||
>>> mu = 3400
|
||||
>>> sigma = 121
|
||||
>>> n = 20
|
||||
>>> # Создам пустой список для хранения чисел
|
||||
>>> numbers = []
|
||||
>>> # Заполню список случайными числами
|
||||
>>> for i in range(n):
|
||||
... # Генерирую случайное число с нормальным распределением
|
||||
... # Использую формулу преобразования: x = mu + sigma * random.gauss(0, 1)
|
||||
... number = mu + sigma * random.gauss(0, 1)
|
||||
... numbers.append(number)
|
||||
>>> # Здесь я вывожу сгенерированные числа
|
||||
>>> print("Сгенерированные числа:")
|
||||
>>> for i in range(n):
|
||||
... print("Число", i+1, ":", "%.2f" % numbers[i])
|
||||
>>> # Рассчитываю среднее значение
|
||||
>>> summa = 0
|
||||
>>> for num in numbers:
|
||||
... summa += num
|
||||
>>> mean_value = summa / n
|
||||
>>> print("\nСреднее значение:", "%.2f" % mean_value)
|
||||
>>> # Подсчитываю числа выше среднего
|
||||
>>> count_above = 0
|
||||
>>> for num in numbers:
|
||||
... if num > mean_value:
|
||||
... count_above += 1
|
||||
>>> print("Количество чисел выше среднего:", count_above)
|
||||
Сгенерированные числа:
|
||||
Число 1: 3300.47
|
||||
Число 2: 3641.42
|
||||
Число 3: 3422.97
|
||||
Число 4: 3415.40
|
||||
Число 5: 3300.32
|
||||
Число 6: 3385.84
|
||||
Число 7: 3297.38
|
||||
Число 8: 3426.89
|
||||
Число 9: 3489.59
|
||||
Число 10: 3452.55
|
||||
Число 11: 3574.94
|
||||
Число 12: 3439.11
|
||||
Число 13: 3377.13
|
||||
Число 14: 3219.63
|
||||
Число 15: 3339.65
|
||||
Число 16: 3307.97
|
||||
Число 17: 3333.71
|
||||
Число 18: 3273.80
|
||||
Число 19: 3332.02
|
||||
Число 20: 3309.60
|
||||
|
||||
Среднее значение: 3382.02
|
||||
Количество чисел выше среднего: 9
|
||||
|
||||
```
|
||||
@ -0,0 +1,4 @@
|
||||
1,2,3
|
||||
4,5,6
|
||||
7,8,9
|
||||
10,11,12
|
||||
@ -0,0 +1,38 @@
|
||||
# Тест по модулю 2
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Задание(Вариант 7)
|
||||
1) С помощью текстового редактора создайте текстовый файл с некоторым именем, в котором будет 4 строки и на каждой строке будет по 3 числа, разделенных запятыми.
|
||||
|
||||
2) Запросите у пользователя и введите имя файла с данными для обработки. Обеспечьте вывод сообщения при вводе пустой строки и повторный ввод.
|
||||
|
||||
3) Введите данные из указанного файла и представьте их в виде списка.
|
||||
|
||||
4) Рассчитайте по введенным данным среднее значение синусов элементов списка.
|
||||
|
||||
5) Выведите рассчитанное значение на экран по шаблону: " По <число элементов в списке> элементам среднее синусов = <рассчитанное среднее>". При этом значение среднего должно быть округлено до двух знаков после точки.
|
||||
|
||||
## Решение
|
||||
```
|
||||
import os
|
||||
import math
|
||||
|
||||
file_name = input('Введите имя файла: ')
|
||||
while file_name == '':
|
||||
print('Ошибка! Введите имя файла.')
|
||||
file_name = input('Введите имя файла: ')
|
||||
|
||||
with open(file_name, 'r') as f:
|
||||
data_list = []
|
||||
for line in f:
|
||||
numbers = line.strip().split(',') #тут я убрал пробелы и переносы в начале и конце строки, и разбил строку на части по запятым
|
||||
data_list.extend([float(x) for x in numbers])#тут добавил числа в общий список
|
||||
|
||||
sin_sum = sum(math.sin(x) for x in data_list)
|
||||
average = sin_sum / len(data_list)
|
||||
|
||||
print(f'По {len(data_list)} элементам среднее синусов = {average:.2f}')
|
||||
|
||||
Введите имя файла: module.txt
|
||||
По 12 элементам среднее синусов = -0.01
|
||||
```
|
||||
@ -0,0 +1,736 @@
|
||||
# Тема 6. Ввод-вывод данных и операции с файлами
|
||||
Выполнил: Тимошенко А.А.
|
||||
Проверил: Козлюк Д.А.
|
||||
|
||||
## Пункт 1
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir("C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6")
|
||||
```
|
||||
## Пункт 2. Вывод данных на экран дисплея.
|
||||
### Пункт 2.1. Вывод данных в командной строке.
|
||||
|
||||
Эхо-вывод в терминал
|
||||
```
|
||||
>>> stroka='Автоматизированная система управления'
|
||||
>>> stroka
|
||||
'Автоматизированная система управления'
|
||||
```
|
||||
### Пункт 2.2 Вывод с использованием функции print
|
||||
```
|
||||
>>> help(print)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(...)
|
||||
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
|
||||
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
Optional keyword arguments:
|
||||
file: a file-like object (stream); defaults to the current sys.stdout.
|
||||
sep: string inserted between values, default a space.
|
||||
end: string appended after the last value, default a newline.
|
||||
flush: whether to forcibly flush the stream.
|
||||
|
||||
>>> fff = 234.5; gg = 'Значение температуры = '
|
||||
>>> print(gg, fff)
|
||||
Значение температуры = 234.5
|
||||
```
|
||||
Это работает и в терминале, и в скриптах, которые записаны в файлы .ру. Причем видно, что
|
||||
вывод через print() убирает у строки кавычки при выводе.
|
||||
|
||||
По умолчанию выводимые объекты разделяются через пробел, но это можно изменить, задав
|
||||
значение сепаратору sep:
|
||||
```
|
||||
>>> print(gg, fff, sep='/')
|
||||
Значение температуры = /234.5
|
||||
```
|
||||
По умолчанию после того, как функция print() сделала вывод, происходит перенос курсора на
|
||||
следующую строку. Это тоже можно изменить. Параметр end по умолчанию имеет значение "\n",
|
||||
его можно изменить на другое.
|
||||
```
|
||||
>>> print(gg, fff,sep = '/', end = '***'); print('____')
|
||||
Значение температуры = /234.5***____
|
||||
```
|
||||
Можно просто вызвать перенос курсора без какого-либо текста, вызвав print() без аргументов:
|
||||
```
|
||||
>>> print()
|
||||
|
||||
>>>
|
||||
```
|
||||
Если текст большой, можно расположить его в несколько строк:
|
||||
```
|
||||
>>> print(""" Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк""")
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
```
|
||||
Или переносить отдельные объекты, разделенные запятой:
|
||||
```
|
||||
>>> print("Здесь может выводиться",
|
||||
"большой текст,",
|
||||
"занимающий несколько строк")
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
```
|
||||
Разница в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был
|
||||
введен. В тексте были введены переносы строки, но они были введены не как символ \n, а
|
||||
в обычном, человеку понятном виде.
|
||||
Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как
|
||||
обычный print(), разделяющий объекты с помощью пробелов, если не указано иное.
|
||||
|
||||
### Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
|
||||
```
|
||||
>>> import sys
|
||||
|
||||
>>> help(sys.stdout.write)
|
||||
Help on method write in module idlelib.run:
|
||||
|
||||
write(s) method of idlelib.run.StdOutputFile instance
|
||||
Write string to stream.
|
||||
Returns the number of characters written (which is always equal to
|
||||
the length of the string).
|
||||
|
||||
|
||||
>>> sys.stdout.write("Функция write")
|
||||
Функция write13
|
||||
```
|
||||
По умолчанию каретка не переводится! Если нужно перевести, это нужно указать вручную.
|
||||
```
|
||||
>>> sys.stdout.write("Функция write\n")
|
||||
Функция write
|
||||
14
|
||||
```
|
||||
Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
|
||||
введенных символов, причем \n считается за один символ, а не за два.
|
||||
Это можно проверить:
|
||||
```
|
||||
>>> type(sys.stdout.write("Функция write"))
|
||||
Функция write<class 'int'>
|
||||
```
|
||||
Если вызвать эту функцию без аргументов, вернется ошибка:
|
||||
```
|
||||
>>> sys.stdout.write()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
TypeError: write() missing 1 required positional argument: 's'
|
||||
```
|
||||
Если сообщить пустую строку, то, соответственно, 0.
|
||||
```
|
||||
>>> sys.stdout.write("")
|
||||
0
|
||||
```
|
||||
|
||||
## Пункт 3. Ввод данных с клавиатуры.
|
||||
```
|
||||
>>> help(input)
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt=None, /)
|
||||
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.
|
||||
```
|
||||
Функция input() приостанавливает дальнейшее выполнение программы и ожидает ввод от пользователя.
|
||||
Выполнение программы продолжится только после нажатия Enter. input() всегда возвращает строку,
|
||||
даже если ввести числа или, например, функцию. Если нужна не строка, то input надо поместить
|
||||
внутрь функции, изменяющей тип данных. Например, int(input()).
|
||||
|
||||
input() может принимать один аргумент: приглашение для пользователя. Это тоже строка, и с
|
||||
помощью нее можно конкретизировать для человека, что означают данные, которые он вводит.
|
||||
При этом после вывода строки-приглашения каретка не переносится, пробел не ставится.
|
||||
```
|
||||
>>> psw = input('Введите пароль:')
|
||||
Введите пароль:123456789
|
||||
>>> psw
|
||||
'123456789'
|
||||
>>> type(psw)
|
||||
<class 'str'>
|
||||
```
|
||||
|
||||
Пример 1
|
||||
```
|
||||
>>> while True:
|
||||
znach=float(input('Задайте коэф.усиления = '))
|
||||
if znach < 17.5 or znach > 23.8:
|
||||
print('Ошибка!')
|
||||
else:
|
||||
break
|
||||
|
||||
|
||||
Задайте коэф.усиления = 15.4
|
||||
Ошибка!
|
||||
Задайте коэф.усиления = 21.6
|
||||
```
|
||||
Пример 2
|
||||
```
|
||||
>>> import math
|
||||
>>> print(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23 / (1 + math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
```
|
||||
Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(),
|
||||
они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий
|
||||
результату вычислений и задаваемый автоматически:
|
||||
```
|
||||
>>> type(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = 1+2
|
||||
<class 'int'>
|
||||
```
|
||||
```
|
||||
>>> type(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
## Пункт 4. Ввод-вывод при работе с файлами.
|
||||
### Пункт 4.1. Функции для работы с путём к файлу.
|
||||
```
|
||||
>>> import os
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6'
|
||||
>>> timoshenko = os.getcwd()
|
||||
>>> timoshenko # Если просто сделать эхо-вывод, бекслеши будут двойными.
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6'
|
||||
>>> print(timoshenko) # Если сделать вывод с print(), то одинарными.
|
||||
C:\Users\mapon\OneDrive\Рабочий стол\ПО АС\ТЕМА6
|
||||
```
|
||||
Сменим директорию и посмотрим, что смена произошла:
|
||||
```
|
||||
>>> os.chdir("C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6")
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6'
|
||||
```
|
||||
Создание каталога (mkdir)
|
||||
```
|
||||
>>> help(os.mkdir)
|
||||
mkdir(path, mode=511, *, dir_fd=None)
|
||||
Create a directory.
|
||||
|
||||
If dir_fd is not None, it should be a file descriptor open to a directory,
|
||||
and path should be relative; path will then be relative to that directory.
|
||||
dir_fd may not be implemented on your platform.
|
||||
If it is unavailable, using it will raise a NotImplementedError.
|
||||
|
||||
The mode argument is ignored on Windows.
|
||||
|
||||
|
||||
>>> help(os.mkdir)
|
||||
>>> os.chdir("test")
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6\\test'
|
||||
```
|
||||
Теперь путь от самого диска можно не указывать, т.к. мы уже находимся в нужной корневой папке.
|
||||
Функция вернет FileExistsError, если папка с таким именем уже существует в текущей директории.
|
||||
|
||||
mode - нужно для настройки прав доступа.
|
||||
|
||||
Удаление каталога
|
||||
```
|
||||
>>> help(os.rmdir)
|
||||
Help on built-in function rmdir in module nt:
|
||||
|
||||
rmdir(path, *, dir_fd=None)
|
||||
Remove a directory.
|
||||
|
||||
If dir_fd is not None, it should be a file descriptor open to a directory,
|
||||
and path should be relative; path will then be relative to that directory.
|
||||
dir_fd may not be implemented on your platform.
|
||||
If it is unavailable, using it will raise a NotImplementedError.
|
||||
```
|
||||
|
||||
|
||||
1) Не получится удалить каталог, в котором находимся мы, обратившись по полному пути. Это вернет
|
||||
ошибку:
|
||||
```
|
||||
>>> os.rmdir('C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6\\test')
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#43>", line 1, in <module>
|
||||
os.rmdir('C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6\\test')
|
||||
PermissionError: [WinError 32] Процесс не может получить доступ к файлу, так как этот файл занят другим процессом: 'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6\\test'
|
||||
```
|
||||
2) Для того, чтобы корректно выполнить удаление той папки, где мы находимся, надо сначала
|
||||
подняться на уровень выше, и уже там произвести удаление:
|
||||
```
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6\\test'
|
||||
>>> os.chdir('../') # Поднимает нас на одну папку выше. ../../ - для двух папок и т.д.
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\еще тема 6'
|
||||
>>> os.rmdir("test")
|
||||
```
|
||||
3) Попробуем удалить эту папку еще раз.
|
||||
```
|
||||
>>> os.rmdir("test")
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#48>", line 1, in <module>
|
||||
os.rmdir("test")
|
||||
FileNotFoundError: [WinError 2] Не удается найти указанный файл: 'test'
|
||||
```
|
||||
Показать список всех файлов и папок, вложенных в текущую
|
||||
```
|
||||
>>> help(os.listdir)
|
||||
Help on built-in function listdir in module nt:
|
||||
|
||||
listdir(path=None)
|
||||
Return a list containing the names of the files in the directory.
|
||||
|
||||
path can be specified as either str, bytes, or a path-like object. If path is bytes,
|
||||
the filenames returned will also be bytes; in all other circumstances
|
||||
the filenames returned will be str.
|
||||
If path is None, uses the path='.'.
|
||||
On some platforms, path may also be specified as an open file descriptor;\
|
||||
the file descriptor must refer to a directory.
|
||||
If this functionality is unavailable, using it raises NotImplementedError.
|
||||
|
||||
The list is in arbitrary order. It does not include the special
|
||||
entries '.' and '..' even if they are present in the directory.
|
||||
|
||||
```
|
||||
Проверка существования каталога
|
||||
```
|
||||
>>> help(os.path.isdir)
|
||||
Help on function isdir in module genericpath:
|
||||
|
||||
isdir(s)
|
||||
Return true if the pathname refers to an existing directory.
|
||||
```
|
||||
Функция isdir() модуля os.path возвращает True если путь path существует и является каталогом,
|
||||
False в противном случае.
|
||||
```
|
||||
>>> os.path.isdir("ИКЗ")
|
||||
True
|
||||
>>> os.path.isdir("фотографии людей")
|
||||
False
|
||||
>>> os.path.isdir("testest.txt") # Такой файл существует, но это не каталог, поэтому False.
|
||||
False
|
||||
```
|
||||
Возвращение абсолютного пути
|
||||
|
||||
Функция os.path.abspath() в Python преобразует путь, переданный в качестве аргумента, в
|
||||
абсолютный путь.
|
||||
```
|
||||
>>> fil = os.path.abspath("testest.txt") # Такой файл есть
|
||||
>>> fil
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\testest.txt'
|
||||
>>> fil = os.path.abspath("test.txt") #Такого файла не существует
|
||||
>>> fil
|
||||
'C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\test.txt'
|
||||
```
|
||||
Абсолютный путь — это полный путь к файлу или каталогу, начиная от
|
||||
корневого каталога системы, а не относительный путь (который зависит от текущего рабочего
|
||||
каталога).
|
||||
|
||||
Если передать в os.path.abspath() несуществующий файл или каталог, функция не проверяет
|
||||
наличие этого файла в файловой системе. Она просто преобразует путь в абсолютный, не
|
||||
проверяя его существование.
|
||||
|
||||
Отделение из абсолютного пути только каталога/только имени файла
|
||||
|
||||
Функция os.path.dirname() из абсолютного пути выделяется путь доступа (от диска до последней
|
||||
папки). Функция os.path.basename(), наоборот, убирает из абсолютного пути все, кроме имени
|
||||
файла.
|
||||
```
|
||||
>>> drkt = os.path.dirname(fil)
|
||||
>>> print(drkt)
|
||||
C:\Users\mapon\OneDrive\Рабочий стол\ПО АС\ТЕМА6
|
||||
|
||||
>>> bsnm = os.path.basename(fil)
|
||||
>>> print(bsnm)
|
||||
test.txt
|
||||
```
|
||||
Разделение на кортеж из пути и из имени файла
|
||||
```
|
||||
>>> os.path.split(fil)
|
||||
('C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6', 'test.txt')
|
||||
```
|
||||
```
|
||||
>>> type(os.path.split(fil))
|
||||
<class 'tuple'>
|
||||
```
|
||||
Проверка существования любого объекта (пути или файла)
|
||||
```
|
||||
>>> os.path.exists("C:/GAMES") # Такой каталог есть на ПК
|
||||
True
|
||||
>>> os.path.exists("C:/Arts") # Такого каталога нет
|
||||
False
|
||||
>>> os.path.exists("C:/Users/mapon/OneDrive/Рабочий стол/NIR/Тимошенко А-01-23 НИР Этап2.docx")
|
||||
# Такой файл есть
|
||||
True
|
||||
>>> os.path.exists("C:/GAMES/abcd.jpg") # Такого файла нет
|
||||
False
|
||||
```
|
||||
Проверка существования файла
|
||||
```
|
||||
>>> os.path.isfile("C:/Users/mapon/OneDrive/Рабочий стол/NIR/Тимошенко А-01-23 НИР Этап2.docx")
|
||||
# Это есть и это файл
|
||||
True
|
||||
>>> os.path.isfile("C:/Users/mapon/OneDrive/Рабочий стол/NIR/") # Это есть, но это не файл!
|
||||
False
|
||||
>>> os.path.isfile("C:/GAMES/abcd.jpg") # Это файл, но его не существует
|
||||
False
|
||||
```
|
||||
### Пункт 4.2 Общая схема работы с файлом
|
||||
|
||||
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||
• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||
• Выполнение одной или нескольких операций обмена данными с файлом;
|
||||
• Закрытие файла.
|
||||
|
||||
### Пункт 4.3 Открытие файла для записи или чтения
|
||||
```
|
||||
>>> fp = open(file = drkt+'\\zapis1.txt', mode='w')
|
||||
>>> type(fp)
|
||||
<class '_io.TextIOWrapper'>
|
||||
```
|
||||
Объект класса _io.TextIOWrapper - файловый объект для текстовых данных, имеющий ряд атрибутов
|
||||
и методов.
|
||||
```
|
||||
>>> fp
|
||||
<_io.TextIOWrapper name='C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\zapis1.txt' mode='w' encoding='cp1251'>
|
||||
```
|
||||
Здесь перечислены атрибуты объекта:
|
||||
name - абсолютный путь
|
||||
mode - режим:
|
||||
r - чтение
|
||||
w - запись (если такой файл уже есть, его содержимое будет удалено, если нет,
|
||||
создается. Содержимое удаляется в момент открытия, а не в момент первой
|
||||
записи)
|
||||
a - дозапись (в конец)
|
||||
x - открывает для записи, но только если файл есть, иначе FileExistsError.
|
||||
+ - чтение и запись:
|
||||
r+ - чтение и запись, файл должен существовать.
|
||||
w+ - запись и чтение, файл создаётся или перезаписывается.
|
||||
a+ - добавление и чтение, файл создаётся, если не существует.
|
||||
```
|
||||
>>> fp.closed
|
||||
False
|
||||
```
|
||||
Если имя файла на первом месте, а режим на втором, то имена можно не указывать. (позиционные аргументы
|
||||
всегда должны идти первыми, а именованные — после них)
|
||||
|
||||
Путь можно опустить, если он совпадает с текущей рабочей директории:
|
||||
```
|
||||
>>> fp = open('zapis1.txt','w')
|
||||
>>> fp
|
||||
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
|
||||
```
|
||||
Список атрибутов объекта fp:
|
||||
```
|
||||
>>> dir(fp)
|
||||
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__',
|
||||
'__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__gt__',
|
||||
'__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__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']
|
||||
```
|
||||
|
||||
Пример открытия бинарного файла:
|
||||
```
|
||||
>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
|
||||
>>> fp1
|
||||
<_io.BufferedRandom name='C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА6\\zapis2.bin'>
|
||||
```
|
||||
|
||||
### Пункт 4.4. Закрытие файла.
|
||||
|
||||
Когда файл успешно открывается / создается и открывается, ему задается целочисленный
|
||||
номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
|
||||
с каким именно файлом нужно работать.
|
||||
|
||||
После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
|
||||
в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
|
||||
файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
|
||||
т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
|
||||
|
||||
После закрытия на объект все еще можно посмотреть:
|
||||
```
|
||||
>>> fp.close()
|
||||
>>> fp
|
||||
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
|
||||
```
|
||||
Но значение атрибута closed сменится на True:
|
||||
```
|
||||
>>> fp.closed
|
||||
True
|
||||
```
|
||||
|
||||
### Пункт 4.5. Запись информации в файл.
|
||||
```
|
||||
>>> help(fp.write)
|
||||
Help on built-in function write:
|
||||
|
||||
write(text, /) method of _io.TextIOWrapper instance
|
||||
Write string to stream.
|
||||
Returns the number of characters written (which is always equal to
|
||||
the length of the string).
|
||||
```
|
||||
Выполним операции над файлом:
|
||||
```
|
||||
>>> 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()
|
||||
```
|
||||
Посмотрим, как выглядит файл, в текстовом редакторе:
|
||||
```
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
```
|
||||
В файл записались преобразованные в строки срезы списка. Второй и последущие вызовы write()
|
||||
в рамках одного сеанса не стирают содержимое файла.
|
||||
Метод выполняет действия по записи данных в файл, но возвращает количество записанных
|
||||
символов.
|
||||
|
||||
Создадим другой список и попробуем записать его в файл:
|
||||
```
|
||||
>>> sps3 = [['Тимошенко А.',1],['Ходюк М.',2],['Коваленко Д.',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)
|
||||
|
||||
14
|
||||
10
|
||||
14
|
||||
>>> fp3.close()
|
||||
```
|
||||
Файл в текстовом редакторе выглядит так:
|
||||
|
||||
Тимошенко А. 1Ходюк М. 2Коваленко Д. 3
|
||||
|
||||
Видно, что строки склеились там, где не надо. Попробуем по-другому.
|
||||
```
|
||||
>>> gh = open('zapis5.txt','w')
|
||||
>>> for r in sps3:
|
||||
gh.write(r[0] + ' '+str(r[1]) + '\n')
|
||||
|
||||
15
|
||||
11
|
||||
15
|
||||
>>> gh.close()
|
||||
```
|
||||
Мы добавили перенос каретки на каждой итерации цикла и пробел в нужном месте. Стало так:
|
||||
|
||||
Тимошенко А. 1
|
||||
Ходюк М. 2
|
||||
Коваленко Д. 3
|
||||
```
|
||||
>>> gh = open('zapis5.txt','w')
|
||||
>>> for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
|
||||
15
|
||||
11
|
||||
15
|
||||
>>> gh.close()
|
||||
```
|
||||
Тимошенко А. 1
|
||||
Ходюк М. 2
|
||||
Коваленко Д. 3
|
||||
|
||||
### Пункт 4.6. Чтение из файла, способ 1.
|
||||
```
|
||||
>>> sps1 = []
|
||||
>>> fp = open('zapis3.txt')
|
||||
```
|
||||
Здесь используется только один аргумент — имя файла, что означает, что файл будет открыт
|
||||
в режиме чтения по умолчанию.
|
||||
```
|
||||
>>> for stroka in fp:
|
||||
stroka = stroka.rstrip('\n')
|
||||
stroka = stroka.replace('[','')
|
||||
stroka = stroka.replace(']','')
|
||||
sps1 = sps1 + stroka.split(',') # на этот моменте целые числа превращаются в строки
|
||||
```
|
||||
Метод .rstrip() убирает символы с конца строки. Если не задавать аргументов,
|
||||
он удалит любые пробелы (пробел, табуляция, символы новой строки и т.п.) с конца строки.
|
||||
|
||||
Метод .replace() заменяет первый агрумент на второй. С помощью него мы убираем скобки.
|
||||
```
|
||||
>>> fp.close()
|
||||
>>> sps1
|
||||
['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
|
||||
```
|
||||
Видно, что полученный список отличается от исходного sps, в первую очередь, типом данных.
|
||||
К тому же, в sps1 убрались не все пробелы.
|
||||
Преобразовать sps1 в sps можно, например, так:
|
||||
```
|
||||
>>> sps2 = [int(i.strip()) for i in sps1]
|
||||
>>> sps2
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||
```
|
||||
Это list comprehension, который у каждого элемента sps1 убирает лишние пробелы с обеих
|
||||
сторон (в этом отличие rstrip от strip). Затем полученная строка конвертируется в число.
|
||||
|
||||
|
||||
### Пункт 4.7. Чтение информации из файла с помощью метода read.
|
||||
|
||||
Этой функции передается количество символов или, если открыт бинарный файл, - количество
|
||||
байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла,
|
||||
начиная с текущего положения маркера. Если указать число большее, чем длина файла,
|
||||
или любое отрицательное, или не передавать вообще, будет прочитан весь файл до EOF.
|
||||
```
|
||||
>>> fp = open('zapis3.txt')
|
||||
>>> stroka1 = fp.read(12) # Чтение первых 12 файлов, курсор остановится на 13-ом (/n)
|
||||
>>> stroka2 = fp.read() # Чтение всех оставшихся файлов вплоть до EOF
|
||||
>>> fp.close()
|
||||
>>> stroka1
|
||||
'[1, 2, 3, 4]'
|
||||
>>> stroka2
|
||||
'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
|
||||
```
|
||||
|
||||
### Пункт 4.8. Чтение информации с помощью readline и readlines.
|
||||
|
||||
Метод readline() считывает одну строку из файла за один вызов. Он читает символы до тех пор,
|
||||
пока не встретит символ новой строки (\n; включается в строку) или конец файла (EOF).
|
||||
Если файл содержит только одну строку или указатель чтения находится в конце файла, то при
|
||||
вызове readline() будет возвращена пустая строка.
|
||||
|
||||
Метод readlines() считывает все строки файла и возвращает их в виде списка, где каждая
|
||||
строка — это отдельный элемент списка. Каждая строка в списке будет содержать символ новой
|
||||
строки \n, если он есть в файле.
|
||||
```
|
||||
>>> file = open("zapis5.txt")
|
||||
>>> file.readline()
|
||||
'Тимошенко А. 1\n'
|
||||
>>> file.seek(0) # Вовзращение указателя обратно в начало, чтобы нагляднее выполнить
|
||||
readlines
|
||||
0
|
||||
>>> file.readlines()
|
||||
['Тимошенко А. 1\n', 'Ходюк М. 2\n', 'Коваленко Д. 3\n']
|
||||
```
|
||||
|
||||
### Пункт 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
|
||||
|
||||
Этот модуль предназначен для сериализации (перевода в бинарную форму) объектов.
|
||||
```
|
||||
>>> import pickle
|
||||
>>> mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
>>> fp = open('zapis6.mnz', 'wb') # открывается с предварительным созданием файл на
|
||||
бинарную запись
|
||||
>>> pickle.dump(mnoz1, fp) # сериализация - запись в бинарный вид
|
||||
>>> fp.close()
|
||||
```
|
||||
Откроем получившийся файл в текстовом редакторе, увидим подобную строку.
|
||||
|
||||
耄锣 鐨谄扯潫钌մ慢汥钌٩偨潮斔调灥溔逮
|
||||
|
||||
Так происходит, потому что байты в этом файле не предназначены для текстового представления.
|
||||
Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках
|
||||
любой текстовой кодировки. Но в некоторых байтах содержатся символы, которые попадают в
|
||||
диапазон, поддерживаемый текстовым редактором и конкретной кодировкой (в моем случае ANSI),
|
||||
поэтому правильно дешифрованные буквы все же есть.
|
||||
|
||||
Десериализуем множество обратно:
|
||||
```
|
||||
>>> fp = open('zapis6.mnz','rb')
|
||||
>>> mnoz2=pickle.load(fp)
|
||||
>>> fp.close()
|
||||
>>> mnoz2
|
||||
{'book', 'iPhone', 'table', 'pen'}
|
||||
>>> mnoz1
|
||||
{'iPhone', 'book', 'pen', 'table'}
|
||||
>>> mnoz1 == mnoz2
|
||||
True
|
||||
```
|
||||
mnoz1 не совпадает с тем, что было задано, потому что это множество. Оно исключает
|
||||
повторяющиеся элементы, оставляя только один, а еще не содержит конкретный порядок элементов.
|
||||
Но два множества равны, если у них равны все элементы и их одинаковое количество, вне
|
||||
зависимости от порядка, так что сравнение возвращает True.
|
||||
```
|
||||
>>> 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
|
||||
{'book', 'table', 'iPhone', 'pen'}
|
||||
>>> obj2
|
||||
[['Тимошенко А.', 1], ['Ходюк М.', 2], ['Коваленко Д.', 3]]
|
||||
>>> mnoz1 == obj1
|
||||
True
|
||||
>>> obj2 == sps3
|
||||
True
|
||||
```
|
||||
Примечание: .mnz и .2ob - пользовательские расширения, не относящиеся к стандартным.
|
||||
|
||||
|
||||
## Пункт 5. Перенаправление потоков ввода и вывода данных.
|
||||
|
||||
Поток в python и других ЯП - это абстракция, которая позволяет регулировать источники
|
||||
ввода информации и то, куда её выводить. Всего их по умолчанию три (еще можнно создать
|
||||
пользовательские):
|
||||
sys.stdin — поток ввода (обычно клавиатура)
|
||||
sys.stdout — поток вывода
|
||||
sys.stderr — поток ошибок (оба обычно экран)
|
||||
|
||||
Для работы с потоками импортируем модуль sys:
|
||||
```
|
||||
>>> import sys
|
||||
```
|
||||
Сохраним адрес в памяти текущего потока вывода:
|
||||
```
|
||||
>>> vr_out = sys.stdout
|
||||
>>> vr_out
|
||||
<idlelib.run.StdOutputFile object at 0x000002CCB1927040>
|
||||
```
|
||||
Откроем (созадем) файл на запись:
|
||||
```
|
||||
>>> fc = open('Stroka.txt','w')
|
||||
```
|
||||
Теперь зададим в качестве потока вывода этот файл:
|
||||
```
|
||||
>>> sys.stdout = fc
|
||||
>>> print('запись строки в файл')
|
||||
```
|
||||
Видно, что в консоли не появилось строки. Вернем поток по умолчанию обратно:
|
||||
```
|
||||
>>> sys.stdout = vr_out
|
||||
>>> print('запись строки на экран')
|
||||
запись строки на экран
|
||||
>>> fc.close()
|
||||
```
|
||||
В файле Stroka.txt находится: запись строки в файл
|
||||
|
||||
Можно перенаправить и поток ввода тоже. Например, на файл:
|
||||
```
|
||||
>>> tmp_in = sys.stdin
|
||||
>>> fd = open("Stroka.txt", "r")
|
||||
>>> sys.stdin = fd
|
||||
>>> sys.stdin
|
||||
<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
|
||||
>>> while True:
|
||||
try: # Конструкция try-except предназначена для отладки исключений
|
||||
# То есть если возвращается ошибка, можно ее перехватить и
|
||||
# указать, что делать в таком случае
|
||||
line = input()
|
||||
print(line)
|
||||
except EOFError:
|
||||
break
|
||||
запись строки в файл
|
||||
>>> fd.close()
|
||||
>>> sys.stdin = tmp_in #Вернул стандартное назначение для потока ввода
|
||||
```
|
||||
|
||||
@ -0,0 +1,54 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 5
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Задание
|
||||
Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следую-щие операции:
|
||||
• Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
|
||||
• Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
|
||||
• Записывается кортеж в бинарный файл.
|
||||
• Записывается в этот же файл список и закрывается файл.
|
||||
• Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
|
||||
• Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
|
||||
• Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде от-дельных списков со своими именами.
|
||||
|
||||
## Решение
|
||||
```
|
||||
>>> nums = tuple(str(random.randint(6, 56)) for _ in range(125))
|
||||
>>> nums
|
||||
('7', '34', '42', '20', '50', '45', '9', '29', '17', '9', '51', '51', '39', '22', '49', '34', '45', '29', '49', '48', '56', '28', '48', '47', '41', '43', '33', '44', '49', '10', '30', '6', '49', '14', '41', '18', '7', '41', '20', '42', '56', '54', '20', '40', '18', '13', '32', '40', '44', '40', '37', '39', '8', '43', '33', '40', '20', '10', '10', '39', '46', '37', '9', '52', '45', '10', '37', '18', '56', '47', '46', '20', '30', '42', '49', '43', '22', '11', '23', '30', '30', '47', '31', '43', '32', '27', '20', '24', '25', '50', '54', '15', '42', '40', '24', '27', '10', '13', '39', '27', '34', '43', '11', '44', '41', '14', '38', '21', '45', '31', '17', '48', '18', '54', '21', '38', '30', '48', '35', '32', '38', '35', '35', '56', '24')
|
||||
```
|
||||
Примечание: если итератор не надо использовать в теле цикла, принято просто обозначать его _
|
||||
```
|
||||
>>> group = ["Timoshenko", "Hodyk", "Kovalenko", "Filippov", "Goloshchapov"]
|
||||
>>> fl = open("okz.okz", "wb")
|
||||
>>> pickle.dump(nums, fl)
|
||||
>>> pickle.dump(group, fl)
|
||||
>>> fl.close()
|
||||
>>> fl = open("okz.okz", "rb")
|
||||
>>> nums1 = pickle.load(fl)
|
||||
>>> nums1
|
||||
('7', '34', '42', '20', '50', '45', '9', '29', '17', '9', '51', '51', '39', '22', '49', '34', '45', '29', '49', '48', '56', '28', '48', '47', '41', '43', '33', '44', '49', '10', '30', '6', '49', '14', '41', '18', '7', '41', '20', '42', '56', '54', '20', '40', '18', '13', '32', '40', '44', '40', '37', '39', '8', '43', '33', '40', '20', '10', '10', '39', '46', '37', '9', '52', '45', '10', '37', '18', '56', '47', '46', '20', '30', '42', '49', '43', '22', '11', '23', '30', '30', '47', '31', '43', '32', '27', '20', '24', '25', '50', '54', '15', '42', '40', '24', '27', '10', '13', '39', '27', '34', '43', '11', '44', '41', '14', '38', '21', '45', '31', '17', '48', '18', '54', '21', '38', '30', '48', '35', '32', '38', '35', '35', '56', '24')
|
||||
>>> group1 = pickle.load(fl)
|
||||
>>> group1
|
||||
['Timoshenko', 'Hodyk', 'Kovalenko', 'Filippov', 'Goloshchapov']
|
||||
```
|
||||
Примечание: при чтении с помощью pickle.load() тоже есть указатель, который останавливается
|
||||
при достижении /n, так что можно просто вызвать ее два раза, чтобы записать эти два объекта.
|
||||
Если вызвать ее третий раз, будет EOFError.
|
||||
```
|
||||
>>> print("Файлы nums совпадают") if nums == nums1 else print("Переменные nums не совпадают")
|
||||
Переменные nums совпадают
|
||||
>>> print("Переменные group совпадают") if group == group1 else print("Переменные group не совпадают")
|
||||
Переменные group совпадают
|
||||
|
||||
>>> for i in range(125//5):
|
||||
exec('list' + str(i) + '=' + str(list(nums1[i:i+5])))
|
||||
```
|
||||
Можно вызвать конкретные списки для проверки:
|
||||
```
|
||||
>>> list1
|
||||
['34', '42', '20', '50', '45']
|
||||
>>> list6
|
||||
['9', '29', '17', '9', '51']
|
||||
```
|
||||
|
||||
|
После Ширина: | Высота: | Размер: 15 KiB |
|
После Ширина: | Высота: | Размер: 13 KiB |
@ -0,0 +1,679 @@
|
||||
# Тема 7. Создание пользовательских функций
|
||||
Выполнил: Тимошенко А.А.
|
||||
Проверил: Козлюк Д.А.
|
||||
|
||||
## Пункт 1.
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА7")
|
||||
```
|
||||
## Пункт 2. Создание пользовательской функции.
|
||||
|
||||
Общий вид:
|
||||
def <Имя функции>([<Список аргументов >]):
|
||||
[<отступы> """<Комментарий по назначению функции>"""]
|
||||
<отступы> <Блок инструкций – тело функции>
|
||||
[<отступы> return <Значение или вычисляемое выражение>]
|
||||
|
||||
Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем
|
||||
в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то
|
||||
выполнение функции прекращается с возвратом значения, следующего за этой инструкцией.
|
||||
В Python, если функция не содержит оператора return, она автоматически возвращает значение
|
||||
None.
|
||||
|
||||
### Пункт 2.1. Функция без аргументов.
|
||||
```
|
||||
>>> def uspeh():
|
||||
"""Подтверждение успеха операции"""
|
||||
print('Выполнено успешно!')
|
||||
>>> uspeh()
|
||||
Выполнено успешно!
|
||||
```
|
||||
Функция является объектом класса function:
|
||||
```
|
||||
>>> type(uspeh)
|
||||
<class 'function'>
|
||||
```
|
||||
Видно, что такой объект появился в рабочем пространстве:
|
||||
```
|
||||
>>> dir()
|
||||
['__annotations__', '__builtins__',
|
||||
'__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
|
||||
```
|
||||
Вызовем помощь по этой функции:
|
||||
```
|
||||
>>> help(uspeh)
|
||||
Help on function uspeh in module __main__:
|
||||
|
||||
uspeh()
|
||||
Подтверждение успеха операции
|
||||
```
|
||||
Видно, что help вернуло имя функции и то описание, которое было указано в тройных кавычках
|
||||
при её определении. Это называется docstring или документ-строка. Они используются
|
||||
для написания документации. Она должна быть первой строкой внутри блока.
|
||||
|
||||
### Пункт 2.2. Функция с аргументами.
|
||||
```
|
||||
>>> def sravnenie(a, b):
|
||||
"""Сравнение a и b"""
|
||||
if a > b:
|
||||
print(a, ' больше ', b)
|
||||
elif a < b:
|
||||
print(a, ' меньше ', b)
|
||||
else:
|
||||
print(a, ' равно ',b)
|
||||
|
||||
|
||||
>>> n, m = 16, 5; sravnenie(n,m)
|
||||
16 больше 5
|
||||
```
|
||||
Так как при описании функции мы не конкретизировали, какой тип данных хотим получить, то
|
||||
python сможет принять любые данные, которые можно сравнить. Если что-то нельзя сравнить,
|
||||
вернется TypeError.
|
||||
```
|
||||
>>> sravnenie("house", "building")
|
||||
house больше building
|
||||
```
|
||||
### Пункт 2.3. Функция с return.
|
||||
```
|
||||
>>> def logistfun(b, a):
|
||||
"""Вычисление логистической функции"""
|
||||
import math
|
||||
return a / (1 + math.exp(-b))
|
||||
```
|
||||
```
|
||||
>>> v, w = 1, 0.7; z = logistfun(w, v)
|
||||
>>> z
|
||||
0.6681877721681662
|
||||
```
|
||||
### Пункт 2.4. Сложение для разных типов аргументов.
|
||||
```
|
||||
>>> def slozh(a1, a2, a3, a4):
|
||||
""" Сложение значений четырех аргументов"""
|
||||
return a1 + a2 + a3 + a4
|
||||
```
|
||||
Для чисел:
|
||||
```
|
||||
>>> slozh(1, 2, 3, 4)
|
||||
10
|
||||
```
|
||||
Для строк:
|
||||
```
|
||||
>>> slozh('1','2','3','4')
|
||||
'1234'
|
||||
```
|
||||
Для списков:
|
||||
```
|
||||
>>> b1 = [1, 2]; b2 = [-1, -2]; b3 = [0, 2]; b4 = [-1, -1]
|
||||
>>> q = slozh(b1, b2, b3, b4)
|
||||
>>> q
|
||||
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||
```
|
||||
Для кортежей:
|
||||
```
|
||||
>>> slozh((1, 2), (3, 4), (-5, 0), (-7, -3))
|
||||
(1, 2, 3, 4, -5, 0, -7, -3)
|
||||
```
|
||||
Для множеств:
|
||||
```
|
||||
>>> slozh({1,1,1,1}, {2}, {"privet", True, None}, {6, 6, "a"})
|
||||
...
|
||||
TypeError: unsupported operand type(s) for +: 'set' and 'set'
|
||||
```
|
||||
Как видно, операция сложения для множеств не применима. Если нужно объединить два множества,
|
||||
для этого есть специальная операция set union
|
||||
|
||||
Для словарей:
|
||||
```
|
||||
>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4}
|
||||
>>> slozh(dict1, dict2, dict3, dict4)
|
||||
...
|
||||
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
|
||||
```
|
||||
Словари тоже нельзя сложить плюсом. Для объединения словарей есть оператор распаковывания
|
||||
**dict1.
|
||||
|
||||
Комбинирование типов:
|
||||
```
|
||||
Число и строка:
|
||||
>>> slozh(1, "а", 2, "б")
|
||||
...
|
||||
TypeError: unsupported operand type(s) for +: 'int' and 'str'
|
||||
```
|
||||
С коллекциями без явного преобразования тоже не сработает.
|
||||
|
||||
Число и логический тип:
|
||||
```
|
||||
>>> slozh(1, True, 2, False)
|
||||
4
|
||||
```
|
||||
Целое число и число с плавающей точкой:
|
||||
```
|
||||
>>> slozh(1, 3.44, 2.0, 7)
|
||||
13.44
|
||||
```
|
||||
### Пункт 2.5. Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
|
||||
```
|
||||
>>> def inerz(x,T,ypred):
|
||||
""" Модель устройства с памятью:
|
||||
x - текущее значение вх.сигнала,
|
||||
T - постоянная времени,
|
||||
ypred - предыдущее значение выхода устройства"""
|
||||
y = (x + T * ypred) / (T + 1)
|
||||
return y
|
||||
|
||||
>>> sps = [0] + [1] * 100
|
||||
>>> spsy = []
|
||||
>>> TT = 20
|
||||
>>> yy = 0
|
||||
>>> for xx in sps:
|
||||
yy = inerz(xx,TT,yy)
|
||||
spsy.append(yy)
|
||||
|
||||
|
||||
>>> import pylab as plt
|
||||
>>> plt.plot(spsy, label = "Выходной сигнал")
|
||||
[<matplotlib.lines.Line2D object at 0x00000241DC815370>]
|
||||
>>> plt.show()
|
||||
```
|
||||
График сохранен в файле с именем Figure_1.
|
||||
|
||||
|
||||
## Пункт 3. Функции как объекты.
|
||||
|
||||
### Пункт 3.1. Получение списка атрибутов объекта-функции.
|
||||
```
|
||||
>>> dir(inerz)
|
||||
['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__',
|
||||
'__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
|
||||
'__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__',
|
||||
'__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__',
|
||||
'__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__',
|
||||
'__setattr__', '__sizeof__', '__str__', '__subclasshook__']
|
||||
|
||||
>>> inerz.__doc__
|
||||
' Модель устройства с памятью:\nx- текущее значение вх.сигнала,\n\tT -постоянная времени,\n\typred - предыдущее значение выхода устройства'
|
||||
>>> help(inerz)
|
||||
Help on function inerz in module __main__:
|
||||
```
|
||||
Этот атрибут содержит значение docstring, если при инициализации функции она была задана.
|
||||
Если не была, то inerz.__doc__ будет иметь значение None.
|
||||
```
|
||||
inerz(x, T, ypred)
|
||||
Модель устройства с памятью:
|
||||
x- текущее значение вх.сигнала,
|
||||
T -постоянная времени,
|
||||
ypred - предыдущее значение выхода устройства
|
||||
```
|
||||
Примеры других атрибутов функций:
|
||||
```
|
||||
>>> def f(a : int, b : int, c = 10):
|
||||
return
|
||||
|
||||
>>> f.__annotations__
|
||||
{'a': <class 'int'>, 'b': <class 'int'>} # Возвращает типы аргументов, если они заданы
|
||||
|
||||
>>> f.__defaults__ # Возвращает значения по умолчанию, если они заданы
|
||||
(10,)
|
||||
>>> f.__name__ # Возвращает имя функции (для функций, определенных внутри других, возвращает
|
||||
полный путь
|
||||
'f'
|
||||
```
|
||||
### Пункт 3.2. Сохранение ссылки на объект-функцию в другой переменной.
|
||||
```
|
||||
>>> n, m = 16, 5; sravnenie(n, m)
|
||||
16 больше 5
|
||||
>>> fnkt = sravnenie
|
||||
>>> v = 16
|
||||
>>> fnkt(v, 23)
|
||||
16 меньше 23
|
||||
```
|
||||
Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в
|
||||
переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую
|
||||
функцию, что и sravnenie.
|
||||
|
||||
### Пункт 3.3. Возможность альтернативного определения функции в программе.
|
||||
```
|
||||
>>> typ_fun = 8
|
||||
>>> if typ_fun == 1:
|
||||
def func():
|
||||
print("Функция 1")
|
||||
|
||||
|
||||
>>> if typ_fun == 1:
|
||||
def func():
|
||||
print('Функция 1')
|
||||
else:
|
||||
def func():
|
||||
print('Функция 2')
|
||||
|
||||
>>> func()
|
||||
Функция 2
|
||||
```
|
||||
Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и
|
||||
выполняется блок else, в котором функция func определена как выводящая, собственно,
|
||||
"Функция 2". Функция становится доступной только после того, как интерпретатор достигает
|
||||
строки с её определением.
|
||||
|
||||
## Пункт 4. Аргументы функции.
|
||||
|
||||
### Пункт 4.1. Возможность использования функции в качестве аргумента другой функции
|
||||
```
|
||||
>>> def fun_arg(fff,a,b,c):
|
||||
"""fff-имя функции, используемой
|
||||
в качестве аргумента функции fun_arg"""
|
||||
return a+fff(c,b)
|
||||
|
||||
>>> zz=fun_arg(logistfun,-3,1,0.7)
|
||||
>>> print(zz)
|
||||
-2.3318122278318336
|
||||
```
|
||||
Python передаёт ссылку на объект функции logistfun в переменную fff. Внутри
|
||||
функции выполняется операция: a + fff(c, b), что эквивалентно -3 + logistfun(0.7, 1)
|
||||
|
||||
### Пункт 4.2. Обязательные и необязательные аргументы.
|
||||
```
|
||||
>>> def logistfun(a,b=1): #Аргумент b – необязательный; значение по умолчанию=1
|
||||
"""Вычисление логистической функции"""
|
||||
import math
|
||||
return b/(1+math.exp(-a))
|
||||
|
||||
>>> logistfun(0.7)
|
||||
0.6681877721681662
|
||||
>>> logistfun(0.7,2)
|
||||
1.3363755443363323
|
||||
```
|
||||
### Пункт 4.3. Возможность обращения к функции с произвольным расположением аргументов.
|
||||
```
|
||||
>>> logistfun(b = 0.5, a = 0.8)
|
||||
0.34498724056380625
|
||||
```
|
||||
Но при этом нельзя сделать так:
|
||||
```
|
||||
>>> logistfun(b = 2, 0.7)
|
||||
SyntaxError: positional argument follows keyword argument
|
||||
```
|
||||
Python ожидает, что все позиционные аргументы будут переданы первыми, а затем уже
|
||||
могут следовать именованные аргументы.
|
||||
|
||||
### Пункт 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
|
||||
```
|
||||
>>> b1234 = [b1, b2, b3, b4]
|
||||
>>> b1234
|
||||
[[1, 2], [-1, -2], [0, 2], [-1, -1]]
|
||||
>>> qq = slozh(*b1234)
|
||||
>>> qq
|
||||
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||
```
|
||||
Со звёздочкой коллекции передаются как набор аргументов функции, Она также называется
|
||||
"оператор распаковки". Это было бы эквивалентно записи slozh(b1,b2,b3,b4)
|
||||
|
||||
### Пункт 4.5. Пример со значениями аргументов функции, содержащимися в словаре
|
||||
```
|
||||
>>> dic4 = {"a1": 1, "a2": 2, "a3": 3, "a4": 4}
|
||||
>>> qqq = slozh(**dic4)
|
||||
>>> qqq
|
||||
10
|
||||
```
|
||||
В данном случае распаковка произошла так, что ключи на входе функции восприниимаются как
|
||||
значения позиционных переменных, а значения, соответственно, как значения.
|
||||
|
||||
Примечание: Если поставить только одну звездочку, python попытается интерпретировать
|
||||
ключи, а не значения словаря как позиционные аргументы. Получается так:
|
||||
```
|
||||
>>> slozh(*dic4)
|
||||
'a1a2a3a4'
|
||||
```
|
||||
### Пункт 4.6. Смешанные ссылки
|
||||
```
|
||||
>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9}
|
||||
>>> qqqq = slozh(*e1,**dd2)
|
||||
>>> qqqq
|
||||
17
|
||||
То есть (-1) + 6 + 3 + 9 = 17
|
||||
```
|
||||
### Пункт 4.7. Переменное число аргументов у функции.
|
||||
```
|
||||
>>> def func4(*kort7):
|
||||
"""Произвольное число аргументов в составе кортежа"""
|
||||
smm = 0
|
||||
for elt in kort7:
|
||||
smm += elt
|
||||
return smm
|
||||
|
||||
>>> func4(-1,2)
|
||||
1
|
||||
>>> func4(-1,2,0,3,6)
|
||||
10
|
||||
```
|
||||
Переменное число аргументов с использованием * упаковывается в кортеж.
|
||||
|
||||
### Пункт 4.8. Комбинация аргументов
|
||||
```
|
||||
>>> def func4(a, b = 7, *kort7): #Аргументы: a - позиционный, b - по умолчанию + кортеж
|
||||
"""Кортеж - сборка аргументов - должен быть последним!"""
|
||||
smm=0
|
||||
for elt in kort7:
|
||||
smm += elt
|
||||
return a * smm + b
|
||||
|
||||
>>> func4(-1,2,0,3,6)
|
||||
-7
|
||||
```
|
||||
То есть -1 * 9 + 2 = -7.
|
||||
|
||||
|
||||
### Пункт 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
|
||||
```
|
||||
>>> a = 90
|
||||
>>> def func3(b):
|
||||
b = 5*b+67
|
||||
|
||||
|
||||
>>> func3(a)
|
||||
>>> a
|
||||
90
|
||||
```
|
||||
Поскольку функция ничего не возвращает (то есть, формально, является процедурой), то вычисленное
|
||||
значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости
|
||||
Для наглядности:
|
||||
```
|
||||
>>> def func3(b):
|
||||
b = 5*b+67
|
||||
print(b)
|
||||
|
||||
|
||||
>>> func3(a)
|
||||
517
|
||||
>>> a
|
||||
90
|
||||
```
|
||||
Пример со списком:
|
||||
```
|
||||
>>> sps1=[1,2,3,4]
|
||||
>>> def func2(sps):
|
||||
sps[1] = 99
|
||||
>>> func2(sps1)
|
||||
>>> print(sps1)
|
||||
[1, 99, 3, 4]
|
||||
```
|
||||
В отличие от предыдущего примера с переменной численного типа, список передается по ссылке, а не по
|
||||
значению, поэтому изменяется именно тот объект, который был передан.
|
||||
|
||||
Кортеж:
|
||||
```
|
||||
>>> kort = (1,2,3,4)
|
||||
>>> func2(kort)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#41>", line 1, in <module>
|
||||
func2(kort)
|
||||
File "<pyshell#40>", line 2, in func2
|
||||
sps[1] = 99
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
```
|
||||
Кортеж - неизменяемая коллекция, так что переназначение значения в таком виде, как здесь, не работает.
|
||||
|
||||
## Пункт 5. Специальные типы пользовательских функций
|
||||
|
||||
### Пункт 5.1. Анонимные функции (лямбда-функции).
|
||||
```
|
||||
>>> anfun1 = lambda: 1.5 + math.log10(17.23)
|
||||
>>> type(anfun1)
|
||||
<class 'function'>
|
||||
|
||||
>>> anfun1()
|
||||
2.7362852774480286
|
||||
|
||||
>>> anfun2 = lambda a,b : a+math.log10(b)
|
||||
>>> anfun2(17, 234)
|
||||
19.369215857410143
|
||||
|
||||
>>> anfun3 = lambda a, b=234: a+math.log10(b)
|
||||
>>> anfun3(100)
|
||||
102.36921585741014
|
||||
```
|
||||
Вызов лямбда-функции создает объект класса "функция", который потом можно положить в другую переменную
|
||||
и далее вызывать.
|
||||
|
||||
### Пункт 5.2. Функции-генераторы
|
||||
|
||||
Иногда в циклах на каждой итерации нужно получать одно из значений. Для этого есть оператор yield.
|
||||
Это похоже на return, но в отличие от return не останавливает полностью выполнение программы.
|
||||
Когда выполнение генератора возобновляется после yield, оно продолжается с того места, где было
|
||||
приостановлено, до следующего оператора yield (или до конца функции).
|
||||
Вместе с yield, можно использовать next(). Например:
|
||||
```
|
||||
>>> def test():
|
||||
for i in range(3):
|
||||
yield i
|
||||
|
||||
|
||||
>>> l = test()
|
||||
>>> l
|
||||
<generator object test at 0x000001AAA0453640>
|
||||
>>> next(l)
|
||||
0
|
||||
>>> next(l)
|
||||
1
|
||||
```
|
||||
Аналогично, можно использовать и метод __next__
|
||||
```
|
||||
>>> print(l.__next__())
|
||||
2
|
||||
```
|
||||
Другой пример:
|
||||
```
|
||||
>>> alp=func5(7,3)
|
||||
>>> print(alp.__next__())
|
||||
1
|
||||
>>> print(alp.__next__())
|
||||
5
|
||||
>>> print(alp.__next__())
|
||||
4
|
||||
...
|
||||
```
|
||||
__next__ помогает вывести значение, которое yield передает на каждй итерации цикла. Если функция
|
||||
отработала последнюю итерацию, но мы все попытаемся сделать вызов, вернется ошибка:
|
||||
```
|
||||
>>> print(alp.__next__())
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#96>", line 1, in <module>
|
||||
print(alp.__next__())
|
||||
StopIteration
|
||||
```
|
||||
## Пункт 6. Локализация объектов в функциях.
|
||||
|
||||
Все объекты - переменные, коллекции, функции и т.д. - могут быть определены глобально или локально.
|
||||
Глобально - значит вне всяких функций.Локальные переменные определены внутри функции, и если хочется
|
||||
использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
|
||||
|
||||
### Пункт 6.1. Примеры
|
||||
```
|
||||
>>> glb = 10
|
||||
>>> def func7(arg):
|
||||
loc1 = 15
|
||||
glb = 8
|
||||
return loc1*arg
|
||||
|
||||
>>> res = func7(glb)
|
||||
>>> res
|
||||
150
|
||||
```
|
||||
Проверим:
|
||||
```
|
||||
>>> glb
|
||||
10
|
||||
```
|
||||
Посмотрим подробнее, что происходит внутри функции:
|
||||
```
|
||||
>>> def func7(arg):
|
||||
loc1=15
|
||||
glb=8
|
||||
print(glb, arg)
|
||||
return loc1*arg
|
||||
|
||||
>>> res=func7(glb)
|
||||
8 10
|
||||
```
|
||||
Видно, что внутри объект с именем glb принял значение 8, но глобальная переменная при этом после выполнения
|
||||
функции значения не поменяла. Это происходит потому, что технически, локальный glb и глобальный glb -
|
||||
это два разных объекта. В этом можно убедиться:
|
||||
```
|
||||
>>> res=func7(glb) #При определенении func7 добавлена строка print(id(glb))
|
||||
8 10
|
||||
>>> id(glb)
|
||||
140726606628040
|
||||
```
|
||||
Пример 2.
|
||||
```
|
||||
>>> def func8(arg):
|
||||
loc1=15
|
||||
print(glb)
|
||||
glb=8
|
||||
return loc1*arg
|
||||
|
||||
>>> res=func8(glb)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#119>", line 1, in <module>
|
||||
res=func8(glb)
|
||||
File "<pyshell#118>", line 3, in func8
|
||||
print(glb)
|
||||
UnboundLocalError: local variable 'glb' referenced before assignment
|
||||
```
|
||||
Ошибка возникает, потому что когда python видит внутри функции переменную, он по умолчанию считает ее
|
||||
локальной. И получается, что вызов локальной переменной glb происходит раньше объявления локальной
|
||||
переменной glb, на что нам и указывает ошибка. Можно исправить эту проблему, переопределив лоаклизацию
|
||||
glb внутри func8():
|
||||
```
|
||||
>>> glb=11
|
||||
>>> def func7(arg):
|
||||
loc1=15
|
||||
global glb
|
||||
print(glb)
|
||||
glb=8
|
||||
return loc1*arg
|
||||
|
||||
>>> res=func7(glb)
|
||||
11
|
||||
>>> glb
|
||||
8
|
||||
```
|
||||
Здесь мы явно указали, что в функции имеем в виду глобальную переменную, так что она изменилась.
|
||||
|
||||
### Пункт 6.2. locals() и globals()
|
||||
|
||||
Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно,
|
||||
локальными или глобальными на уровне вызова этих функций.
|
||||
```
|
||||
>>> globals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
>>> locals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
```
|
||||
Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций, но мы
|
||||
вызвали обе самом внешнем уровне, не внутри какой-либо функции, а в самом рабочем пространстве, где
|
||||
локальная и глобальная области видимости совпадают.
|
||||
```
|
||||
>>> glb = 10
|
||||
>>> def func8(arg):
|
||||
loc1=15
|
||||
glb=8
|
||||
print(globals().keys()) #Перечень глобальных объектов «изнутри» функции
|
||||
print(locals()) #Перечень локальных объектов «изнутри» функции (для наглядности отобразим и значения тоже)
|
||||
return loc1*arg
|
||||
|
||||
>>> hh=func8(glb)
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
{'arg': 10, 'loc1': 15, 'glb': 8}
|
||||
>>> glb # Снова глобальное glb
|
||||
10
|
||||
```
|
||||
### Пункт 6.3. Локализация объектов при использовании вложенных функций.
|
||||
```
|
||||
>>> def func9(arg2,arg3):
|
||||
def func9_1(arg1):
|
||||
loc1=15
|
||||
glb1=8
|
||||
print('glob_func9_1:',globals().keys())
|
||||
print('locl_func9_1:',locals().keys())
|
||||
return loc1*arg1
|
||||
loc1=5
|
||||
glb=func9_1(loc1)
|
||||
print('loc_func9:',locals().keys())
|
||||
print('glob_func9:',globals().keys())
|
||||
return arg2+arg3*glb
|
||||
|
||||
>>> kk=func9(10,1)
|
||||
glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
|
||||
locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) # Содержит только объекты, определенные внутри func9
|
||||
а также объект, переданный как аргумент функции
|
||||
|
||||
loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb']) # Содержит все то же, что и locl_func9_1, но еще и arg3, переданный func9, и саму func9_1
|
||||
|
||||
glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'f', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'r', 'r1', 'test', 'l', 'func5', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
|
||||
```
|
||||
### Пункт 6.4. Моделирование САУ
|
||||
```
|
||||
>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
|
||||
k1,T,k2,Xm,A,F,N=8,5,3,10,2,0.5,1000
|
||||
>>> k1=float(znach[0])#распаковываю значения из списка в отдельные объекты - числовые переменные
|
||||
>>> T=float(znach[1])
|
||||
>>> k2=float(znach[2])
|
||||
>>> Xm=float(znach[3])
|
||||
>>> A=float(znach[4])
|
||||
>>> F=float(znach[5])
|
||||
>>> N=int(znach[6])
|
||||
>>> vhod=[]#входной сигнал
|
||||
>>> for i in range(N):
|
||||
vhod.append(A*math.sin((2*i*math.pi)/F))
|
||||
|
||||
>>> vhod
|
||||
[0.0, -9.797174393178826e-16, -1.959434878635765e-15, -2.9391523179536475e-15, -3.91886975727153e-15,
|
||||
-4.898587196589413e-15, -5.878304635907295e-15, -6.858022075225178e-15,
|
||||
...
|
||||
1.1010469343064857e-13,
|
||||
-8.856348540728095e-13, -1.8813744015762676e-12, 7.608648580119871e-13, -2.3487468949147107e-13, -1.
|
||||
2306142369949293e-12, -2.226353784498387e-12, 4.1588547508986746e-13, -5.798540724135906e-13,
|
||||
-1.5755936199170489e-12]
|
||||
|
||||
>>> 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
|
||||
|
||||
>>> yi1 = 0; yin1 = 0; yi2 = 0
|
||||
>>> vyhod = []
|
||||
>>> for xt in vhod:
|
||||
xt1 = xt - yi2 #отрицательная обратная связь
|
||||
[yi1,yin1] = realdvig(xt1,k1,T,yi1,yin1)
|
||||
yi2 = tahogen(yin1,k2,yi2)
|
||||
yt = nechus(yin1,Xm)
|
||||
vyhod.append(yt)
|
||||
>>> print('y=',vyhod)
|
||||
y = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1.0183086292055208, 0, 26.39885775889784,
|
||||
-36.65029553691161, -34.19982663883278, 196.29963397615063, -151.6919482160481,
|
||||
-388.32493988337274, 1057.8073200868555, -308.3186572590445,
|
||||
...
|
||||
2.37392249152569e+226, -2.801972415904499e+226, -3.2288710633399875e+226,
|
||||
1.321721142591339e+227, -9.144734174579399e+226]
|
||||
```
|
||||
@ -0,0 +1,88 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 7
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Задание
|
||||
• Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
|
||||
|
||||
• Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращае-мый результат функции: список с числами элементов выборки в интервалах разбиения.
|
||||
|
||||
• Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х
|
||||
Y=b1+b2*X и имеющую аргументы b1, b2 и X.
|
||||
|
||||
## Решение
|
||||
```
|
||||
def delay_signal(signal, T):
|
||||
delayed_signal = signal.copy()
|
||||
if T < len(signal):
|
||||
# Сдвигаю сигнал вправо на T отсчетов, начало заполняем нулями
|
||||
delayed_signal = [0] * T + signal[:-T]
|
||||
else:
|
||||
# Если задержка больше длины сигнала - возвращаем нули
|
||||
delayed_signal = [0] * len(signal)
|
||||
|
||||
return delayed_signal
|
||||
|
||||
>>> y = [random.gauss(3, 1.5) for _ in range(40)]
|
||||
>>> y
|
||||
[5.325416780634114, 2.3593622133749808, 1.2470676959301887, -0.593060108499694, 1.4340279482713292, 2.162904911751828, 3.5966381215435743, 3.1215233313521367, 3.278769015552392, 1.4600848702469413, 2.227188218562767, -0.02101290555432689, 2.9015754761132713, 5.507229347318583, 4.392918705255052, 2.893096608173657, 2.400184728443876, 2.3464420973774045, -0.29207940771891217, 4.868968794420769, 5.1569207689963275, 2.966999923764223, 0.9443978469937528, 5.562190945114451, 3.4834584941068765, 1.7250255447073042, 3.013873484634806, 3.783067951814041, 4.602220595567667, 2.283163010872606, 4.563248136396248, 5.370530689941988, -0.5394330191088121, 4.481730159619498, 2.6088804215267345, 3.562728440630803, 4.422684655442551, 1.846276163481897, 3.8925551687094426, 4.720299420830592]
|
||||
|
||||
>>> yd = delay_signal(y, 4)
|
||||
>>> yd
|
||||
[0, 0, 0, 0, 5.325416780634114, 2.3593622133749808, 1.2470676959301887, -0.593060108499694, 1.4340279482713292, 2.162904911751828, 3.5966381215435743, 3.1215233313521367, 3.278769015552392, 1.4600848702469413, 2.227188218562767, -0.02101290555432689, 2.9015754761132713, 5.507229347318583, 4.392918705255052, 2.893096608173657, 2.400184728443876, 2.3464420973774045, -0.29207940771891217, 4.868968794420769, 5.1569207689963275, 2.966999923764223, 0.9443978469937528, 5.562190945114451, 3.4834584941068765, 1.7250255447073042, 3.013873484634806, 3.783067951814041, 4.602220595567667, 2.283163010872606, 4.563248136396248, 5.370530689941988, -0.5394330191088121, 4.481730159619498, 2.6088804215267345, 3.562728440630803]
|
||||
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
def calculate_histogram(data, num_bins):
|
||||
min_val, max_val = min(data), max(data)
|
||||
bins = np.linspace(min_val, max_val, num_bins + 1)
|
||||
counts = [0] * num_bins
|
||||
|
||||
for value in data:
|
||||
for i in range(num_bins):
|
||||
if bins[i] <= value < bins[i + 1]:
|
||||
counts[i] += 1
|
||||
break
|
||||
if value == max_val:
|
||||
counts[-1] += 1
|
||||
|
||||
return counts, bins
|
||||
|
||||
def plot_histogram(data, bins, counts):
|
||||
plt.hist(data, bins=bins, alpha=0.7, edgecolor='black')
|
||||
plt.xlabel('Значения выборки')
|
||||
plt.ylabel('Число элементов')
|
||||
plt.title('Гистограмма выборки')
|
||||
plt.show()
|
||||
|
||||
def histo(data, num_bins):
|
||||
"""
|
||||
Основная функция для работы с гистограммой
|
||||
"""
|
||||
counts, bins = calculate_histogram(data, num_bins)
|
||||
plot_histogram(data, bins, counts)
|
||||
return counts
|
||||
|
||||
sample = [random.gauss(random.random(), random.random()) for _ in range(random.randint(10,200))]
|
||||
intervals = int(input("Введите количество интервалов разбиения: "))
|
||||
output = histo(sample, intervals)
|
||||
|
||||
======= RESTART: C:\Users\mapon\OneDrive\Рабочий стол\ПО АС\ТЕМА7\OKZ2.py ======
|
||||
Введите количество интервалов разбиения: 12
|
||||
Список с числами элементов в интервалах: [3, 4, 10, 10, 6, 8, 7, 0, 1, 0, 0, 1]
|
||||
|
||||
#График сохранен под именем Figure_2
|
||||
|
||||
|
||||
|
||||
linreg = lambda b1, b2, x: b1 + b2 * x
|
||||
b1 = float(input("Введите коэффициент b1 линейной регрессии: "))
|
||||
b2 = float(input("Введите коэффициент b2 линейной регрессии: "))
|
||||
x_val = float(input("Введите значение x: "))
|
||||
print(linreg(b1, b2, x_val))
|
||||
|
||||
|
||||
Введите коэффициент b1 линейной регрессии: 2
|
||||
Введите коэффициент b2 линейной регрессии: 3
|
||||
Введите значение x: 5
|
||||
17.0
|
||||
```
|
||||
@ -0,0 +1,393 @@
|
||||
# Тема 8. Модули и структурирование программы
|
||||
Выполнил: Тимошенко А.А.
|
||||
Проверил: Козлюк Д. А.
|
||||
|
||||
## Пункт 1. Импорт библиотек
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir("C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8")
|
||||
>>> import sys, importlib
|
||||
```
|
||||
## Пункт 2. Создание и использование модулей в среде Python.
|
||||
### Пункт 2.1. Запуск модуля на выполнение путем его импорта.
|
||||
|
||||
Файл mod1.py содержит команды:
|
||||
```
|
||||
perm1 = input('Mod1: Введите значение = ')
|
||||
print('Mod1: Значение perm1 = ', perm1)
|
||||
```
|
||||
Вызов файла как импортируемого модуля:
|
||||
```
|
||||
>>> import mod1
|
||||
Mod1: Введите значение = 5
|
||||
Mod1: Значение perm1 = 5
|
||||
>>> mod1.perm1
|
||||
'5'
|
||||
>>> import mod1
|
||||
>>> import mod1
|
||||
```
|
||||
Все следующие после первого вызовы не инициируют ввод значения
|
||||
perm1. В Python модули импортируются один раз в рамках одного запуска интерпретатора.
|
||||
Если попытаться импортировать модуль повторно, используется уже загруженная версия из кэша.
|
||||
Если нужно повторно импортировать модуль как в первый раз, можно сделать так:
|
||||
```
|
||||
>>> importlib.reload(mod1)
|
||||
Mod1: Введите значение = 6
|
||||
Mod1: Значение perm1 = 6
|
||||
<module 'mod1' from 'C:\\Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8\\mod1.py'>
|
||||
>>> mod1.perm1
|
||||
'6'
|
||||
```
|
||||
### Пункт 2.2. Словарь импортированных модулей
|
||||
```
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'mod1', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
|
||||
>>> sys.modules.pop('mod1')
|
||||
<module 'mod1' from 'C:\\Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8\\mod1.py'>
|
||||
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
```
|
||||
Пояснение: принципиальное отличие importlib.reload() от sys.modules.pop() заключается
|
||||
в следующем: importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из кэша. Он имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из кэша, при повторном импорте он уже будет иметь другой адрес, а старые зависимости ссылаются на пустой объект.
|
||||
```
|
||||
>>> import mod1
|
||||
Mod1: Введите значение = 9
|
||||
Mod1: Значение perm1 = 9
|
||||
>>> mod1.perm1
|
||||
'9'
|
||||
```
|
||||
### Пункт 2.3. Запуск модуля на выполнение с помощью функции exec().
|
||||
```
|
||||
>>> exec(open('mod1.py', encoding='utf-8').read())
|
||||
Mod1: Введите значение = 7
|
||||
Mod1: Значение perm1 = 7
|
||||
>>> mod1.perm1
|
||||
'9'
|
||||
>>> perm1
|
||||
'7'
|
||||
>>> exec(open('mod1.py', encoding='utf-8').read())
|
||||
Mod1: Введите значение = 99
|
||||
Mod1: Значение perm1 = 99
|
||||
>>> perm1
|
||||
'99'
|
||||
>>> exec(open('mod1.py', encoding='utf-8').read())
|
||||
Mod1: Введите значение = 40
|
||||
Mod1: Значение perm1 = 40
|
||||
>>> perm1
|
||||
'40'
|
||||
```
|
||||
### Пункт 2.4. Использование инструкции from … import …
|
||||
|
||||
Пример 1.
|
||||
```
|
||||
>>> sys.modules.pop('mod1')
|
||||
<module 'mod1' from 'C:\\Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8\\mod1.py'>
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
|
||||
>>> from mod1 import perm1
|
||||
Mod1: Введите значение = 89
|
||||
Mod1: Значение perm1 = 89
|
||||
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'mod1', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
|
||||
>>> perm1
|
||||
'89' - измененный объект тоже доступен из глобальной области видимости.
|
||||
```
|
||||
Как видно, объект mod1 всё же появился в sys.modules.keys(). Аналогично обычному import, при первом импорте команда
|
||||
инициализирует ввод, но при последующих ничего не делает.
|
||||
|
||||
Пример 2.
|
||||
```
|
||||
>>> from mod2 import beta
|
||||
>>> g = beta(2)
|
||||
>>> g
|
||||
535.4916555247646
|
||||
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'mod1', 'mod2', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
```
|
||||
Объект mod2 появился в списке всех модулей.
|
||||
```
|
||||
>>> h = alpha(2)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
NameError: name 'alpha' is not defined
|
||||
```
|
||||
Импортируем alpha, используя для него псевдоним.
|
||||
```
|
||||
>>> from mod2 import alpha as al
|
||||
>>> al()
|
||||
****ALPHA****
|
||||
Значение t=90
|
||||
'90'
|
||||
```
|
||||
Если мы попробуем вызвать функцию по обычному ее имени, ничего не выйдет.
|
||||
```
|
||||
>>> alpha()
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
NameError: name 'alpha' is not defined
|
||||
```
|
||||
Так происходит потому, что на этапе преобразования программы в байт-код python связывает
|
||||
модуль, найденный в рабочей директории, с именем al. Модуль становится объектом в пространстве имен,
|
||||
создаётся ссылка на объект модуля alpha и ему присваивается имя al. Но имя alpha ему НЕ присваивается,
|
||||
поэтому обратиться к методам и атрибутам по имени alpha нельзя.
|
||||
```
|
||||
>>> del al, beta
|
||||
>>> from mod2 import alpha as al, beta as bt
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'mod1', 'mod2', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
|
||||
>>> sys.modules.pop('mod2')
|
||||
<module 'mod2' from 'C:\\Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8\\mod2.py'>
|
||||
>>> sys.modules.pop('mod1')
|
||||
<module 'mod1' from 'C:\\Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8\\mod1.py'>
|
||||
>>> from mod2 import *
|
||||
>>> print(sorted(sys.modules.keys()))
|
||||
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'mod2', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||
```
|
||||
Протестируем функции после импорта:
|
||||
```
|
||||
>>> tt = alpha()
|
||||
****ALPHA****
|
||||
Значение t=0.13
|
||||
>>> uu = beta(float(tt))
|
||||
>>> uu
|
||||
1.5044194029024176
|
||||
```
|
||||
## Пункт 3. Создание многомодульных программ.
|
||||
### Пункт 3.1. Пример простой многомодульной программы.
|
||||
|
||||
Создадим файл mod0.py:
|
||||
```
|
||||
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)
|
||||
```
|
||||
Вызовем его в терминале, предварительно убедившись, что ни один
|
||||
из трех модулей не упоминается в sys.modules.keys():
|
||||
```
|
||||
>>> import mod0
|
||||
Mod1: Введите значение = 8
|
||||
Mod1: Значение perm1 = 8
|
||||
perm1 = 8
|
||||
****ALPHA****
|
||||
Значение t=2
|
||||
tt = 2
|
||||
qq = 535.4916555247646
|
||||
```
|
||||
Теперь обратимся к каждому из объектов в рабочем пространстве:
|
||||
```
|
||||
>>> mod0.tt
|
||||
'2'
|
||||
>>> mod0.qq
|
||||
535.4916555247646
|
||||
```
|
||||
Обращение к perm1 выглядит несколько иначе:
|
||||
```
|
||||
>>> mod0.perm1
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module> - неверно
|
||||
|
||||
AttributeError: module 'mod0' has no attribute 'perm1'
|
||||
>>> mod0.mod1.perm1
|
||||
'8' - верно
|
||||
```
|
||||
Ошибка возникает, потому что переменная perm1 находится в пространстве имен
|
||||
модуля mod1, а не модуля mod0. Чтобы сделать её доступной через mod0, нужно явно
|
||||
импортировать её с помощью такой строки:
|
||||
from mod1 import perm1.
|
||||
|
||||
### Пункт 3.2.
|
||||
|
||||
Файл mm0.py:
|
||||
```
|
||||
import mm2
|
||||
print('y =', mm2.vyhod)
|
||||
```
|
||||
Файл mm1.py:
|
||||
```
|
||||
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
|
||||
```
|
||||
Файл mm2.py:
|
||||
```
|
||||
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)
|
||||
```
|
||||
Тестирование:
|
||||
|
||||
k1,T,k2,Xm,A,F,N=9,6,4,11,3,0.5,1500
|
||||
y = [0, 0, ... 0, -70.20177063675057, 0, 257.73311334096866, -677.4095530135962, ... -6.270038281034423e+306, -1.198995988522659e+307]
|
||||
|
||||
### Области действия объектов в модулях:
|
||||
Обращение в функции alpha к функции beta:
|
||||
```
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
beta(int(t))
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
import math
|
||||
expi=q*math.pi
|
||||
return math.exp(expi)
|
||||
```
|
||||
Тестирование:
|
||||
```
|
||||
Mod1: Введите значение = 8
|
||||
Mod1: Значение perm1 = 8
|
||||
perm1 = 8
|
||||
****ALPHA****
|
||||
Значение t=4
|
||||
tt = 4
|
||||
qq = 286751.31313665316
|
||||
```
|
||||
Обращение в функции beta к функции alpha:
|
||||
```
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
import math
|
||||
expi = int(alpha())*math.pi
|
||||
return math.exp(expi)
|
||||
```
|
||||
Тестирование:
|
||||
```
|
||||
Mod1: Введите значение = 8
|
||||
Mod1: Значение perm1 = 8
|
||||
perm1 = 8
|
||||
****ALPHA****
|
||||
Значение t=4
|
||||
tt = 4
|
||||
****ALPHA****
|
||||
Значение t=4
|
||||
qq = 286751.31313665316
|
||||
```
|
||||
Ввод запускается два раза - первый от самой функции alpha, а второй - от той, которая
|
||||
упоминалась в beta.
|
||||
|
||||
Отобразить на экране в модуле Mod0 значения объектов t и expi:
|
||||
|
||||
Одна из попыток:
|
||||
```
|
||||
#Модуль 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)
|
||||
print(f't = {al.t}, expi = {beta.expi}')
|
||||
|
||||
Traceback (most recent call last):
|
||||
File "C:\Users\mapon\OneDrive\Рабочий стол\ПО АС\ТЕМА8\mod0.py", line 9, in <module>
|
||||
print(f't = {al.t}, expi = {beta.expi}')
|
||||
AttributeError: 'function' object has no attribute 't'
|
||||
```
|
||||
Не получится вызвать эти переменные по их непосредственному имени (t и expi),
|
||||
упоминая объекты, атрибутами которых они являются, без изменения кода (например,
|
||||
объявления t в alpha как глобальную переменную, или задание его как метода.
|
||||
Но, так как мы знаем, что alpha возвращает t, то узнать t можем по имени al.
|
||||
С expi и beta так не получится:
|
||||
```
|
||||
Traceback (most recent call last):
|
||||
File "C:\Users\mapon\OneDrive\Рабочий стол\ПО АС\ТЕМА8\mod0.py", line 10, in <module>
|
||||
print(f't = {al}, expi = {beta.expi}')
|
||||
^^^^^^^^^
|
||||
AttributeError: 'function' object has no attribute 'expi'
|
||||
```
|
||||
В модуле Mod0 увеличить в 3 раза значение
|
||||
объекта perm1 и отобразить его после этого на экране.
|
||||
|
||||
Так как perm1 имеет тип str, то умножение напрямую без преобразования типов
|
||||
будет выглядеть так:
|
||||
```
|
||||
...
|
||||
print('perm1 = ', mod1.perm1)
|
||||
print('Умножено:' , mod1.perm1 * 3)
|
||||
...
|
||||
Mod1: Введите значение = 4
|
||||
Mod1: Значение perm1 = 4
|
||||
perm1 = 4
|
||||
Умножено: 444
|
||||
```
|
||||
Преобразовав тип perm1, можно получить классическое умножение:
|
||||
```
|
||||
...
|
||||
print('Умножено:' , int(mod1.perm1) * 3)
|
||||
...
|
||||
Mod1: Введите значение = 4
|
||||
Mod1: Значение perm1 = 4
|
||||
perm1 = 4
|
||||
Умножено: 12
|
||||
```
|
||||
В командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq:
|
||||
```
|
||||
>>> mod1.perm1 * 2
|
||||
'55'
|
||||
>>> mod0.tt * 2
|
||||
'44'
|
||||
>>> mod0.qq * 2
|
||||
573502.6262733063
|
||||
```
|
||||
perm1 и tt, как упоминалось ранее, имеют строковый тип, так что умножение
|
||||
дублирует содержимое строки.
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,75 @@
|
||||
# ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ по Теме 8
|
||||
Выполнил: Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
## Задание
|
||||
Разработайте программу, состоящую из трех модулей:
|
||||
- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколь-ко на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полу-ченный список должен возвращаться в вызывающую программу.
|
||||
- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
|
||||
- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. За-тем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
|
||||
Подготовьте два текстовых файла с числовыми данными и проверьте по ним работу программы.
|
||||
|
||||
## Решение
|
||||
okz1.py
|
||||
```
|
||||
def reading (file):
|
||||
nums = []
|
||||
with open(file, 'r') as file:
|
||||
for line in file:
|
||||
nums.extend(map(float, line.split()))
|
||||
return nums
|
||||
```
|
||||
okz2.py
|
||||
```
|
||||
import math
|
||||
def correlation(l1, l2):
|
||||
n = min(len(l1), len(l2))
|
||||
sum1 = sum(l1)
|
||||
sum2 = sum(l2)
|
||||
sum1sq = sum(now ** 2 for now in l1)
|
||||
sum2sq = sum(now ** 2 for now in l2)
|
||||
sum12 = sum(x * y for x, y in zip(l1, l2))
|
||||
|
||||
part1 = n * sum12 - sum1 * sum2
|
||||
part2 = math.sqrt((n * sum1sq - sum1 ** 2) * (n * sum2sq - sum2 ** 2))
|
||||
|
||||
try:
|
||||
corr = part1 / part2
|
||||
return corr
|
||||
except ZeroDivisionError:
|
||||
print("Ошибка деления на ноль!")
|
||||
return
|
||||
```
|
||||
okz3.py
|
||||
```
|
||||
from okz1 import reading
|
||||
from okz2 import correlation
|
||||
|
||||
file1 = input("Введите имя первого файла: ")
|
||||
file2 = input("Введите имя второго файла: ")
|
||||
|
||||
arr1 = reading(file1)
|
||||
arr2 = reading(file2)
|
||||
|
||||
if arr1 is None or arr2 is None:
|
||||
print("Не удалось считать данные из файлов.")
|
||||
else:
|
||||
corr = correlation(arr1, arr2)
|
||||
if corr is not None:
|
||||
print(f"Коэффициент корреляции: {corr:.2f}")
|
||||
```
|
||||
Содержимое файлов:
|
||||
```
|
||||
data1.txt
|
||||
1.0 2.0 3.0 4.0 5.0
|
||||
6.0 7.0 8.0 9.0 10.0
|
||||
|
||||
data2.txt
|
||||
10.0 9.5 9.0 8.5 8.0
|
||||
7.5 7.0 6.5 6.0 1.0
|
||||
```
|
||||
```
|
||||
================ RESTART: C:/Users/mapon/OneDrive/Рабочий стол/ПО АС/ТЕМА8/okz3.py ================
|
||||
Введите имя первого файла: data1.txt
|
||||
Введите имя второго файла: data2.txt
|
||||
Коэффициент корреляции: -0.88
|
||||
```
|
||||
@ -0,0 +1,138 @@
|
||||
#Отчет по ЛР 1 ПО АС Выполнил: студент группы А-01-23 Тимошенко А.А. Проверил: Козлюк Д.А.
|
||||
|
||||
#Пункт 1 В папку L:\\III курс\\А-1-23\\TimoshenkoAA\\Tema1\\ПО АС 2025
|
||||
перенесены материалы и распакован архив Tema1.rar
|
||||
|
||||
#Пункт 2 Запущен интепретатор Phyton
|
||||
|
||||
#Пункт 3 \>\>\> print(\"hello\") hello
|
||||
|
||||
#Пункт 4 \>\>\> h=input(\'Your name= \') Your name= Alexander \>\>\> h
|
||||
\'Alexander\'
|
||||
|
||||
#Пункт 5 \>\>\> exit()
|
||||
|
||||
#Пункты 6-7 Запущена IDLE Python 3.11, изучено устройство главного
|
||||
командного окна среды
|
||||
|
||||
#Пункт 8 import os os.chdir(\'L:\\III
|
||||
курс\\А-1-23\\TimoshenkoAA\\Tema1\\ПО АС 2025\')
|
||||
|
||||
#Пункт 9 Шрифт изменен на Arial CYR, кегль 11, размер начального окна
|
||||
50\*100 символов, комментарии подсвечиваются коричневым
|
||||
|
||||
#В текстовом редакторе IDLE создана программа следующего содержания:
|
||||
|
||||
#Программа по теме 1 Тимошенко Александр Анатольевич
|
||||
|
||||
import os
|
||||
|
||||
print(\"hello\") h = input(\'Your name = \')
|
||||
|
||||
os.chdir(\'L:\\III курс\\А-1-23\\TimoshenkoAA\\Tema1\\ПО АС 2025\') Она
|
||||
делает следующий вывод: = RESTART: L:/III
|
||||
курс/А-1-23/TimoshenkoAA/Tema1/ПО АС 2025/Pr0.py Hello Your
|
||||
name=Alexander
|
||||
|
||||
import Pr0 Hello Your name=Alexander
|
||||
|
||||
При нажатии f5 в активном окне редактора:
|
||||
|
||||
= RESTART: L:/III курс/А-1-23/TimoshenkoAA/Tema1/ПО АС 2025/Pr0.py Hello
|
||||
Your name=
|
||||
|
||||
#Пункт 11
|
||||
|
||||
Из консоли вызван файл prb1.py
|
||||
|
||||
\>\>\> import prb1 Как Вас зовут? Александр Привет, Александр
|
||||
|
||||
#Пункт 12
|
||||
|
||||
Файл Pr0.cpython-34.pyc открыт в NotePad ++. Видно, что разультат
|
||||
компиляции тяжел для восприятия человеком, вероятно, из-за
|
||||
несоответствия кодировок. Комплиляция программ необходима, чтобы
|
||||
перевести команды из человекопонятной формы в машинный код, который
|
||||
может быть обработан процессором. При выполнении скрипта Python сначала
|
||||
преобразовывает его в байт-код (.рус), а затем уже он компилируется с
|
||||
помощью виртуальный машины. Это ускорит повторную загрузку программы.
|
||||
|
||||
#Пункт 13
|
||||
|
||||
Все верные команды из командного окна IDLE скопированы в отдельный файл
|
||||
|
||||
#Пункт 14
|
||||
|
||||
В разделе помощи help можно найти следующие опции:
|
||||
|
||||
About IDLE - описание характеристик текущей среды (версия, путь и пр.)
|
||||
|
||||
IDLE Help - помощь по работе со средой
|
||||
|
||||
Python Docs - документация по языку
|
||||
|
||||
Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
|
||||
|
||||
\>\>\> help (print)
|
||||
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(\...) print(value, \..., sep=\' \', end=\'\\n\', file=sys.stdout,
|
||||
flush=False)
|
||||
|
||||
Prints the values to a stream, or to sys.stdout by default. Optional
|
||||
keyword arguments: file: a file-like object (stream); defaults to the
|
||||
current sys.stdout. sep: string inserted between values, default a
|
||||
space. end: string appended after the last value, default a newline.
|
||||
flush: whether to forcibly flush the stream.
|
||||
|
||||
\>\>\> help(print), help(input)
|
||||
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(\...) print(value, \..., sep=\' \', end=\'\\n\', file=sys.stdout,
|
||||
flush=False)
|
||||
|
||||
Prints the values to a stream, or to sys.stdout by default. Optional
|
||||
keyword arguments: file: a file-like object (stream); defaults to the
|
||||
current sys.stdout. sep: string inserted between values, default a
|
||||
space. end: string appended after the last value, default a newline.
|
||||
flush: whether to forcibly flush the stream.
|
||||
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt=None, /) 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 -\> Указатель -\> print() (built-in function) выводит справку по этой
|
||||
функции
|
||||
|
||||
То же диалоговое окно появляется при help - Python Docs
|
||||
|
||||
#Пункт 15
|
||||
|
||||
File - Open - prb1.py
|
||||
|
||||
С помощью Window можно переключаться между всеми открытыми окнами
|
||||
|
||||
prb1.py - Run
|
||||
|
||||
======= RESTART: L:\\III курс\\А-1-23\\TimoshenkoAA\\Tema1\\ПО АС
|
||||
2025\\prb1.py ====== Как Вас зовут? Александр Привет, Александр
|
||||
|
||||
\>\>\> import tdemo_chaos
|
||||
|
||||
Help - Turtle Demo - clock - Start выводит на экран графическое
|
||||
представление программы - циферблат с часами. Есть и другие примеры
|
||||
программ модуля turtle, которые можно брать за основу собственных
|
||||
программ.
|
||||
|
||||
16\. Завершена работа со средой: File - exit
|
||||
Загрузка…
Ссылка в новой задаче