ответвлено от main/python-labs
Сравнить коммиты
1 Коммитов
6de200f325
...
main
| Автор | SHA1 | Дата | |
|---|---|---|---|
| 8c2687d139 |
@@ -1,6 +1,7 @@
|
||||
# Программное обеспечение автоматизированных систем: лабораторные работы
|
||||
|
||||
[Репозиторий с методическими указаниями и заданиями.](http://uit.mpei.ru/git/main/python)
|
||||
Обратите внимание на файл с комментариями в репозитории по ссылке.
|
||||
|
||||
## Работа с Git
|
||||
|
||||
@@ -109,7 +110,7 @@
|
||||
|
||||
### Оформление решений
|
||||
|
||||
Решение всех заданий оформляется по образцу:
|
||||
Решение всех заданий и тестов оформляется по образцу:
|
||||
|
||||
# Общее контрольное задание по теме 2
|
||||
|
||||
@@ -129,5 +130,8 @@
|
||||
|
||||
Для темы 1 вместо «Задания» — «Вопрос», вместо «Решения» — «Ответ».
|
||||
|
||||
Для тем 3, 6 и 9 вместо «Индивидуального контрольного задания по теме 3 (6, 9)» —
|
||||
«Тест по модулю 1 (2, 3)».
|
||||
|
||||
Для тем 8 и 9 раздела «Решение» не нужно,
|
||||
вместо этого решение размещается в отдельных файлах `*.py`.
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
#Программа по Теме 1 <Цветкова Т. А.>
|
||||
print('Hello')
|
||||
h=input('Your name=')
|
||||
import os
|
||||
os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
|
||||
156
TEMA1/laba1.md
156
TEMA1/laba1.md
@@ -1,156 +0,0 @@
|
||||
# Отчет.
|
||||
## Модуль 1 Основы языка программирования Python.
|
||||
## Тема 1. Знакомство с интерпретатором и интерактивной оболочкой IDLE.
|
||||
|
||||
## Пункт1:
|
||||
Была создана папка и распакован архив Tema1/
|
||||
|
||||
## Пункт2:
|
||||
Запустили на выполнение интерпетатор Python 3.11
|
||||
|
||||
## Пункт3:
|
||||
Ввели команду print и убедились в ее работоспособности.
|
||||
```py
|
||||
>>> print('Hello')
|
||||
Hello
|
||||
```
|
||||
|
||||
## Пункт4:
|
||||
Изучили команду input.
|
||||
```py
|
||||
>>> h=input('Your Name=')
|
||||
Your Name=Tanya
|
||||
>>> h
|
||||
'Tanya'
|
||||
```
|
||||
|
||||
## Пункт5:
|
||||
Завершили работу интерпретатора с помощью команды
|
||||
```py
|
||||
>>>exit().
|
||||
```
|
||||
|
||||
## Пункт6:
|
||||
Запустили IDLE Python 3.11
|
||||
|
||||
## Пункт7:
|
||||
Изучили устройство главного командного окна
|
||||
|
||||
## Пункт8:
|
||||
Ввели инструкции настройки рабочего каталога среды
|
||||
```py
|
||||
>>>import os
|
||||
>>>os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
|
||||
```
|
||||
|
||||
## Пункт9:
|
||||
Установили в среде шрифт типа Arial CYR, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая
|
||||
|
||||
## Пункт10:
|
||||
Создали новый фйл Pr0.py
|
||||
```py
|
||||
Программа по Теме 1 <ЦветковаТА>
|
||||
>>>print('Hello')
|
||||
>>>h=input('Your name=')
|
||||
>>>import os
|
||||
>>>os.chdir('C:\\Users\\Admin\\Desktop\\TsvetkovaTA\\Tema1\\')
|
||||
```
|
||||
|
||||
Запустили модуль и получили результат
|
||||
```py
|
||||
>>>import Pr0
|
||||
Hello
|
||||
Your name=Tanya
|
||||
```
|
||||
|
||||
## Пункт11:
|
||||
Запустили модуль prb1
|
||||
```py
|
||||
>>>import prb1
|
||||
Как Вас зовут? Таня
|
||||
Привет, Таня
|
||||
```
|
||||
|
||||
## Пункт12:
|
||||
Попробовали открыть файл Pr0.cpython-34.pyc и поняли, что из-за скомпилированного бинарного файла текстовый редактор как раз-таки выдает ошибку, тк не может считать файл .рус, ожидая стандартную для него кодировку.
|
||||
Комплиляция программ необходима, чтобы перевести команды из человекопонятной формы в машинный код, который может быть обработан процессором.
|
||||
При выполнении скрипта Python сначала преобразовывает его в байт-код (.рус), а затем уже он компилируется с помощью виртуальный машины.
|
||||
Это ускорит повторную загрузку программы.
|
||||
|
||||
## Пункт13:
|
||||
В текстовом редакторе оболочки IDLE открыли новое окно.
|
||||
Сохранили все из командного окна
|
||||
|
||||
## Пункт14:
|
||||
В разделе помощи можно увидеть следующее
|
||||
```py
|
||||
About IDLE - информация о версии IDLE
|
||||
IDLE Help - документация по самой IDLE
|
||||
Python Docs - документация по языку Python
|
||||
Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
|
||||
```
|
||||
```py
|
||||
>>>help(print)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
```
|
||||
```py
|
||||
>>>help(print), help(input)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt='', /)
|
||||
Read a string from standard input. The trailing newline is stripped.
|
||||
|
||||
The prompt string, if given, is printed to standard output without a
|
||||
trailing newline before reading input.
|
||||
|
||||
If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
|
||||
On *nix systems, readline is used if available.
|
||||
|
||||
(None, None)
|
||||
```
|
||||
при F1 открывается справочное окно
|
||||
|
||||
## Пункт15:
|
||||
Узнали, что опция Окно (Window)» помогает перемещаться между открытыми окнами
|
||||
```py
|
||||
>>>import tdemo_chaos
|
||||
>>>tdemo_chaos.main()
|
||||
'Done!'
|
||||
```
|
||||
|
||||
Вывели на экран графическое представление
|
||||
программы с часами. Есть и другие примеры программ модуля turtle,
|
||||
которые можно брать за основу собственных программ, изменять или реализовывать
|
||||
свои идеи
|
||||
|
||||
## Пункт16:
|
||||
Звершили работу со средой
|
||||
```py
|
||||
>>>exit
|
||||
```
|
||||
@@ -1,15 +0,0 @@
|
||||
#Программа по Теме 1 <Цветкова Т. А.>
|
||||
|
||||
import os
|
||||
os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
|
||||
|
||||
import Pr0
|
||||
Hello
|
||||
Your name=Tatyana
|
||||
|
||||
import os
|
||||
os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1')
|
||||
|
||||
import prb1
|
||||
Как Вас зовут? Tatyana
|
||||
Привет, Tatyana
|
||||
604
TEMA2/lab2.md
604
TEMA2/lab2.md
@@ -1,604 +0,0 @@
|
||||
# Протокол по Теме 2 <ЦветковаТА>»
|
||||
## пункт2:
|
||||
изучили простые объекты и присваивание
|
||||
```py
|
||||
>>>f1=16; f2=3
|
||||
>>>f1,f2
|
||||
(16, 3)
|
||||
```
|
||||
Или через точку с запятой. тогда друг за другом:
|
||||
```py
|
||||
>>> f1; f2
|
||||
16
|
||||
3
|
||||
```
|
||||
Узнаем какие объекты уже существуют в среде
|
||||
```py
|
||||
>>>dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
|
||||
```
|
||||
|
||||
Еще эта функция может показать атрибуты объекта:
|
||||
```py
|
||||
|
||||
>>> dir (f1)
|
||||
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__',
|
||||
'__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__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__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag',
|
||||
'numerator', 'real', 'to_bytes']
|
||||
```
|
||||
Функция del необходима для удаления объекта
|
||||
```py
|
||||
>>> del f1,f2
|
||||
>>>dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
|
||||
```
|
||||
## Пункт3:
|
||||
```py
|
||||
>>>gg1=1.6 #значение в виде вещественного числа
|
||||
>>>hh1='Строка' #значение в виде символьной строки
|
||||
>>>73sr=3 #неправильное имя – начинается с цифры - будет диагностика!
|
||||
SyntaxError: invalid decimal literal
|
||||
>>>and=7 #недопустимое имя – совпадает с ключевым словом - будет диагностика!
|
||||
SyntaxError: invalid syntax
|
||||
```
|
||||
## Пункт4:
|
||||
Вывели список ключевых слов и присвоили команду к переменной
|
||||
```py
|
||||
>>>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']
|
||||
>>>k=keyword.kwlist
|
||||
k
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
```
|
||||
## Пункт5:
|
||||
Выведем список встроенных идеентификаторов
|
||||
```py
|
||||
>>>import builtins
|
||||
>>>dir(builtins)
|
||||
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
|
||||
```
|
||||
модуль
|
||||
```py
|
||||
>>>abs(-7)
|
||||
7
|
||||
```
|
||||
длинна
|
||||
```py
|
||||
>>>len([1,2])
|
||||
2
|
||||
```
|
||||
максимум и минимум
|
||||
```py
|
||||
>>>max(20,5)
|
||||
20
|
||||
>>>min(20,5)
|
||||
5
|
||||
```
|
||||
|
||||
возведение в степень
|
||||
```py
|
||||
>>>pow(4,2)
|
||||
16
|
||||
```
|
||||
возведение в степень по модулю
|
||||
```py
|
||||
>>>pow (5, 2, 2)
|
||||
1
|
||||
```
|
||||
округление
|
||||
```py
|
||||
>>>round (33.2)
|
||||
33
|
||||
```
|
||||
округление с определенной точностью
|
||||
```py
|
||||
>>>round (33.45826, 3)
|
||||
33.458
|
||||
```
|
||||
сумма
|
||||
```py
|
||||
>>>sum ([2, 5])
|
||||
7
|
||||
```
|
||||
сортировка и иобратная сортировка
|
||||
```py
|
||||
>>>sorted ([5, 4, 18, 40, -6, 0])
|
||||
[-6, 0, 4, 5, 18, 40]
|
||||
>>>sorted ([5, 4, 18, 40, -6, 0], reverse = True)
|
||||
[40, 18, 5, 4, 0, -6]
|
||||
```
|
||||
Объединение объектов в кортеж (возвращается указатель на участок памяти)
|
||||
```py
|
||||
>>> list1 = [1, 2, 3]
|
||||
>>> list2 = [4, 5, 6]
|
||||
>>> zip (list1, list2)
|
||||
<zip object at 0x0000000002C42E88>
|
||||
Это итератор - указатель на объект памяти. Чтобы увидеть сам кортеж, итератор надо
|
||||
преобразовать в другой объект
|
||||
>>> list(zipped)
|
||||
[(1, 4), (2, 5), (3, 6)]
|
||||
```
|
||||
## Пункт6:
|
||||
Регестрочувствительность
|
||||
```py
|
||||
>>>Gg=45
|
||||
>>>Gg
|
||||
45
|
||||
>>>gg
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#39>", line 1, in <module>
|
||||
gg
|
||||
NameError: name 'gg' is not defined. Did you mean: 'Gg'?
|
||||
```
|
||||
## Пункт7:
|
||||
Типы объектов
|
||||
```py
|
||||
>>>bb1=True; bb2=False
|
||||
>>>bb1;bb2
|
||||
True
|
||||
False
|
||||
>>>type(bb1)
|
||||
<class 'bool'>
|
||||
тип (класс) объекта
|
||||
```
|
||||
Целое число (десятичное)
|
||||
```py
|
||||
>>> ii1 = 1234567890
|
||||
>>> type(ii1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
Экспоненциальная форма записи числа
|
||||
```py
|
||||
>>> ff1 = 8.987e-12
|
||||
>>> type(ff1)
|
||||
<class 'float'>
|
||||
```
|
||||
Двоичное число (префикс 0b - binary)
|
||||
```py
|
||||
>>> dv1 = 0b1100101
|
||||
>>> type(bb1)
|
||||
<class 'bool'>
|
||||
```
|
||||
Восьмеричное число (0о - octal)
|
||||
```py
|
||||
>>> vsm1 = 0o52765
|
||||
>>> type(vsm1)
|
||||
<class 'int'>
|
||||
```
|
||||
Шестнадцатеричное число (0х - hexadecimal)
|
||||
```py
|
||||
>>> shest1 = 0x7109af6
|
||||
>>> type(shest1)
|
||||
<class 'int'>
|
||||
```
|
||||
Комплексное число
|
||||
```py
|
||||
>>> cc1 = 2 - 3j
|
||||
>>> type(cc1)
|
||||
<class 'complex'>
|
||||
```
|
||||
```py
|
||||
>>> a = 3.67
|
||||
>>> b = 0.45
|
||||
>>> cc2 = complex (a, b)
|
||||
>>> cc2
|
||||
(3.67+0.45j)
|
||||
>>> type (cc2)
|
||||
<class 'complex'>
|
||||
```
|
||||
Строка символов
|
||||
```py
|
||||
>>> ss1='Это - строка символов'
|
||||
>>> ss1="Это - строка символов"
|
||||
>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
|
||||
>>> print(ss1a)
|
||||
Это - " строка символов ",
|
||||
выводимая на двух строках
|
||||
>>> ss1b= 'Меня зовут: \n <Цветкова ТА>'
|
||||
>>> print(ss1b)
|
||||
Меня зовут:
|
||||
<Цветкова ТА>
|
||||
```
|
||||
```py
|
||||
>>> mnogo="""Нетрудно заметить , что в результате операции
|
||||
... над числами разных типов получается число,
|
||||
... имеющее более сложный тип из тех, которые участвуют в операции."""
|
||||
>>> print(mnogo)
|
||||
Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции.
|
||||
```
|
||||
При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.
|
||||
|
||||
|
||||
Обратимся к отдельным элементам с помощью квадратных кавычек
|
||||
(нумерация с нуля):
|
||||
```py
|
||||
>>> mnogo[5]
|
||||
'д'
|
||||
```
|
||||
Обращение начиная с последнего элемента:
|
||||
```py
|
||||
>>> ss1b[-1]
|
||||
'>'
|
||||
```
|
||||
Срезы:
|
||||
```py
|
||||
>>> ss1[7:10]
|
||||
'тро'
|
||||
```
|
||||
Срез с шагом в 2:
|
||||
```py
|
||||
>>> ss1[7:14:2]
|
||||
'тоас'
|
||||
```
|
||||
```py
|
||||
>>> ss1[5:-8]
|
||||
' строка '
|
||||
```
|
||||
|
||||
Задав шаг -1, можно вывести строку в обратном порядке:
|
||||
```py
|
||||
>>> ss1[::-1]
|
||||
'воловмис акортс - отЭ'
|
||||
```
|
||||
К элементу можно обратиться как по нумерации с начала, так и с конца:
|
||||
```py
|
||||
>>> ss1[17:3:-2]
|
||||
'омсаот '
|
||||
>>> ss1[-4:3:-2]
|
||||
'омсаот '
|
||||
```
|
||||
|
||||
Строка является неизменяемым объектом
|
||||
```py
|
||||
>>> ss1[4]='=' # Будет диагностика!
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'str' object does not support item assignment
|
||||
>>> ss1=ss1[:4]+'='+ss1[5:]
|
||||
>>> print(ss1)
|
||||
Это = строка символов
|
||||
```
|
||||
Новый объект на основе среза из старого:
|
||||
```py
|
||||
>>> ss1b_cut = ss1b [::-1]
|
||||
>>> ss1b_cut
|
||||
'>АТ авоктевЦ< \n :тувоз янеМ'
|
||||
```
|
||||
## Пункт8:
|
||||
Список
|
||||
```py
|
||||
>>> 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]
|
||||
>>> pis=[1,2,3,4,
|
||||
... 5,6,7,
|
||||
... 8,9,10]
|
||||
>>> pis
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
>>> spis1 [-1]
|
||||
(5-9j)
|
||||
>>> stup [-8 :: 2]
|
||||
[0, 1, 1, 1]
|
||||
>>> spis1[1]='Список'
|
||||
>>> spis1
|
||||
['111', 'Список', (5-9j)]
|
||||
>>> len(spis1)
|
||||
3
|
||||
```
|
||||
Методы списка
|
||||
Добавление в конец (append)
|
||||
```py
|
||||
>>> 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') # В конец списка добавлен элемент «New item»
|
||||
>>> spis1
|
||||
['111', 'Список', (5-9j), 'New item']
|
||||
>>> spis1+['New item']
|
||||
Только возвращает результат, но не фиксирует такое значение!
|
||||
['111', 'Список', (5-9j), 'New item', 'New item']
|
||||
```
|
||||
Удаление элемента по индексу
|
||||
```py
|
||||
>>> spis1.pop(1)
|
||||
'Список'
|
||||
>>> spis1
|
||||
['111', (5-9j), 'New item', 'Меня зовут: \n <Цветкова ТА>']
|
||||
```
|
||||
Вставка элемента в определенное место по индексу (insert)
|
||||
```py
|
||||
>>> spis1.insert(2, "hello")
|
||||
>>> spis1
|
||||
['111', (5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>']
|
||||
```
|
||||
Удаление элемента по значению (remove)
|
||||
```py
|
||||
>>> 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 <Цветкова ТА>']
|
||||
```
|
||||
```py
|
||||
>>> spis1.remove('222')
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#39>", line 1, in <module>
|
||||
spis1.remove('222')
|
||||
```
|
||||
Добавление элементов объекта в конец другого объекта (extend)
|
||||
```py
|
||||
>>> help(spis1.extend)
|
||||
Help on built-in function extend:
|
||||
|
||||
extend(iterable, /) method of builtins.list instance
|
||||
Extend list by appending elements from the iterable.
|
||||
>>> end1 = [77, "lab"]
|
||||
>>> spis1.extend(end1)
|
||||
>>> spis1
|
||||
[(5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '77', 'lab']
|
||||
```
|
||||
|
||||
Полное очищение списка (clear)
|
||||
```py
|
||||
>>> help(spis1.clear)
|
||||
Help on built-in function clear:
|
||||
|
||||
clear() method of builtins.list instance
|
||||
Remove all items from list.
|
||||
|
||||
>>> end1.clear()
|
||||
>>> end1
|
||||
[]
|
||||
```
|
||||
Сортировка списка БЕЗ создания нового объекта (sort)
|
||||
```py
|
||||
>>> 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.
|
||||
>>> abc = [4,7,-3,0]
|
||||
>>> abc.sort(key = abs, reverse = True)
|
||||
>>> abc
|
||||
[7, 4, -3, 0]
|
||||
```
|
||||
При этом некоторые key's не применимы для некоторых типов (у string нет abs,
|
||||
у complex нет длины и т.д.)
|
||||
|
||||
Создание копии списка (copy)
|
||||
```py
|
||||
>>> help(abc.copy)
|
||||
Help on built-in function copy:
|
||||
|
||||
copy() method of builtins.list instance
|
||||
Return a shallow copy of the list.
|
||||
|
||||
>>> abccopy=abc.copy()
|
||||
>>> abccopy
|
||||
[7, 4, -3, 0]
|
||||
```
|
||||
Поиск индекса по значению (index)
|
||||
```py
|
||||
>>> help(abccopy.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.
|
||||
|
||||
>>> abccopy.index(0)
|
||||
3
|
||||
```
|
||||
Подсчет количества элементов по значению (count)
|
||||
```py
|
||||
>>> help(abccopy.count)
|
||||
Help on built-in function count:
|
||||
|
||||
count(value, /) method of builtins.list instance
|
||||
Return number of occurrences of value.
|
||||
|
||||
>>> abccopy.count(4)
|
||||
1
|
||||
```
|
||||
Вложенные списки:
|
||||
```py
|
||||
>>> spis2=[spis1,[4,5,6,7]]
|
||||
>>> spis2
|
||||
[['111', (5-9j), 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '77', 'lab'], [4, 5, 6, 7]]
|
||||
>>> spis2[0][1]
|
||||
(5-9j)
|
||||
>>> spis2[0][1]=78
|
||||
>>> spis2
|
||||
[['111', 78, 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '77', 'lab'], [4, 5, 6, 7]]
|
||||
>>> spis1
|
||||
[['111', 78, 'hello', 'New item', 'Меня зовут: \n <Цветкова ТА>', '>'
|
||||
```
|
||||
spis1 тоже изменился. Это происходит потому, что python работает не просто с
|
||||
объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке,
|
||||
а не по значению.
|
||||
|
||||
Кортеж: последовательность как список, но неизменяемая как строка.
|
||||
```py
|
||||
>>> kort1=(222,'Kortezh',77+8j)
|
||||
>>> kort1= kort1+(1,2)
|
||||
>>> kort1= kort1+(ss1b,)
|
||||
>>> kort1
|
||||
(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n <Цветкова ТА>')
|
||||
>>> kort2=kort1[:2]+kort1[3:]
|
||||
>>> kort2
|
||||
(222, 'Kortezh', 1, 2, 'Меня зовут: \n <Цветкова ТА>')
|
||||
>>> kort1.index(2)
|
||||
4
|
||||
>>> kort1.count(222)
|
||||
1
|
||||
>>> kort1[2]=90
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
>>> kortstr = ("gjgvu", 4, [1,2,3], (1,2))
|
||||
>>> kortstr
|
||||
('gjgvu', 4, [1, 2, 3], (1, 2))
|
||||
>>> type(kortstr[3])
|
||||
<class 'tuple'>
|
||||
>>> type(kortstr[2])
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
Словарь (dictionary) - содержит в себе совокупность пар
|
||||
"ключ (key) (неизменяемый)": "значение (value) (любого типа)"
|
||||
```py
|
||||
>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
>>> dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
|
||||
>>> dic1[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#99>", 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 <Цветкова ТА>'}
|
||||
```
|
||||
Создание собственного словаря на основе кортежа из семи элементов и списка из пяти:
|
||||
```py
|
||||
>>> a0223=('спать', 'учиться','работать', 'кмы','барс','лекции','общежитие')
|
||||
>>> a0123=['1', '2', '3', '4', '5']
|
||||
>>> MPEI=dict(zip(a0123, a0223))
|
||||
>>> MPEI
|
||||
{'1': 'спать', '2': 'учиться', '3': 'работать', '4': 'кмы', '5': 'барс'}
|
||||
```
|
||||
В итоговом словаре пять объектов. Это связано с работой функции zip:
|
||||
длина итогового объекта = минимальной длине составляющего
|
||||
объекта.
|
||||
|
||||
Словари: состоят из НЕповторяющихся неизменяемых элементов
|
||||
```py
|
||||
>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
|
||||
>>> mnoz1
|
||||
{'двигатель', 'линия связи', 'датчик', 'микропроцессор'}
|
||||
>>> len(mnoz1)
|
||||
4
|
||||
>>> 'датчик' in mnoz1
|
||||
True
|
||||
>>> mnoz1.add('реле')
|
||||
>>> mnoz1.remove('линия связи')
|
||||
>>> mnoz1
|
||||
{'реле', 'микропроцессор', 'датчик', 'двигатель'}
|
||||
```
|
||||
|
||||
|
||||
Общее контрольное задание:
|
||||
|
||||
1. Создать переменную с именем familia и со значением -
|
||||
символьной строкой – своей фамилией в латинской транскрипции.
|
||||
```py
|
||||
>>> familia = 'Tsvetkova'
|
||||
```
|
||||
2. Создать переменную со значением, совпадающим с первой
|
||||
буквой из familia.
|
||||
```py
|
||||
>>> fam1 = familia[0]
|
||||
>>> fam1
|
||||
'T'
|
||||
```
|
||||
3. Создать переменную с именем sp_kw со значением –
|
||||
списком всей ключевых слов языка Python.
|
||||
```py
|
||||
>>> import keyword
|
||||
>>> sp_kw = keyword.kwlist
|
||||
>>> sp_kw
|
||||
['False', 'None', 'True', '__peg_parser__', '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 убедитесь, что это значение удалено из списка.
|
||||
```py
|
||||
>>> sp_kw.remove('nonlocal')
|
||||
>>> sp_kw
|
||||
['False', 'None', 'True', '__peg_parser__', '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.
|
||||
```py
|
||||
>>> kort_nam = ('Stas', 'Dana', 'Katya', 'Tanya')
|
||||
>>> type(kort_nam)
|
||||
<class 'tuple'>
|
||||
```
|
||||
6. Напишите инструкцию, добавляющую в kort_nam имена
|
||||
еще двух студентов.
|
||||
```py
|
||||
>>> kort_nam += ('Andrey', 'Nastya')
|
||||
>>> kort_nam
|
||||
('Stas', 'Dana', 'Katya', 'Tanya', 'Andrey', 'Nastya')
|
||||
```
|
||||
7. Напишите инструкцию, позволяющую определить, сколько раз в
|
||||
кортеже присутствуют студенты с именем «Дима».
|
||||
```py
|
||||
>>> kort_nam.count("Dima")
|
||||
0
|
||||
```
|
||||
8. Создайте словарь dict_bas, в котором ключами являются русские
|
||||
названия типов переменных, использованных в предыдущих операторах,
|
||||
а значениями – ранее созданные переменные, соответствующие этим типам.
|
||||
```py
|
||||
>>> dict_bas = {"строка": familia, "символ": fam1, "список": sp_kw,
|
||||
"кортеж": kort_nam,}
|
||||
>>> dict_bas
|
||||
{'строка': 'Tsvetkova', 'символ': 'T', 'список': ['False', 'None', 'True',
|
||||
'__peg_parser__', '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'], 'кортеж': ('Stas', 'Dana', 'Katya', 'Tanya', 'Andrey', 'Nastya')}
|
||||
```
|
||||
@@ -1,48 +0,0 @@
|
||||
## 1)Для чего предназначено предложение "Окно (Window)" главного меню?
|
||||
Для быстрого переключения между различными открытыми окнами в среде IDLE
|
||||
|
||||
## 2)Создайте объект-кортеж с 5 произвольными двоичными элементами. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
|
||||
```py
|
||||
>>> bin(4)
|
||||
'0b100'
|
||||
>>> bin(6)
|
||||
'0b110'
|
||||
>>> bin(7)
|
||||
'0b111'
|
||||
>>> bin(44)
|
||||
'0b101100'
|
||||
>>> bin(99)
|
||||
'0b1100011'
|
||||
>>> k=(0b100, 0b110, 0b111, 0b101100,0b1100011)
|
||||
>>> type(k)
|
||||
<class 'tuple'>
|
||||
>>> dir(k)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
|
||||
|
||||
```
|
||||
## 3)Напишите инструкцию создания нового кортежа, в который включите два последних элемента ранее созданного кортежа, и два элемента - символы "a" и "b". Отобразите созданный объект на экране.
|
||||
```py
|
||||
>>> k1=k[-2:]+('a','b')
|
||||
>>> k1
|
||||
(44, 99, 'a', 'b')
|
||||
```
|
||||
## 4) Преобразуйте кортеж в список. Вставьте в качестве второго элемента списка значение "Автоматизированная система". Отобразите полученный объект.
|
||||
```py
|
||||
>>> spisok=list(k1)
|
||||
>>> spisok.insert(1, 'Автоматизированная система')
|
||||
>>> spisok
|
||||
[44, 'Автоматизированная система', 99, 'a', 'b']
|
||||
```
|
||||
## 5) Напишите инструкции, обеспечивающие подсчет суммы числовых элементов кортежа. С использованием формата отобразите результат по шаблону: "Сумма элементов=:".
|
||||
```py
|
||||
>>> sum_rez=0
|
||||
>>> for element in k1:
|
||||
... if type(element)==int:
|
||||
... sum_rez += element
|
||||
...
|
||||
>>> sum_rez
|
||||
143
|
||||
>>> s="Сумма элементов=:"+str(sum_rez)
|
||||
>>> s
|
||||
'Сумма элементов=:143'
|
||||
```
|
||||
813
TEMA3/lab3.md
813
TEMA3/lab3.md
@@ -1,813 +0,0 @@
|
||||
# Отчет
|
||||
## Тема 3.
|
||||
Операции с объектами
|
||||
## Пункт 2.
|
||||
Преобразование простых базисов типов объектов
|
||||
## 2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
|
||||
```py
|
||||
>>>logiz1=bool(56)
|
||||
>>>logiz1
|
||||
True
|
||||
>>>logiz2=bool(0)
|
||||
>>>logiz2
|
||||
False
|
||||
>>>logiz3=bool("Beta")
|
||||
>>>logiz3
|
||||
True
|
||||
>>>logiz4=bool("")
|
||||
>>>logiz4
|
||||
False
|
||||
```
|
||||
## 2.2 Преобразование в целое десятичное число
|
||||
```py
|
||||
>>>tt1= int(198.6)
|
||||
>>>tt1
|
||||
198
|
||||
>>>tt2=int('-76')
|
||||
>>>tt2
|
||||
-76
|
||||
>>>tt3= int('B',16)
|
||||
>>>tt3
|
||||
11
|
||||
>>>tt4=int("71",8)
|
||||
>>>tt4
|
||||
57
|
||||
>>> tt5=int("98.76")
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#34>", line 1, in <module>
|
||||
tt5=int("98.76")
|
||||
ValueError: invalid literal for int() with base 10: '98.76'
|
||||
```
|
||||
Функция int() может преобразовывать в целое число только строки, которые содержат целое число (например, "98"). Строка "98.76" содержит десятичную точку, поэтому возникает ошибка.
|
||||
Решить эту проблему можно так:
|
||||
```py
|
||||
>>>tt5 = int(float("98.76"))
|
||||
>>>tt5
|
||||
98
|
||||
```
|
||||
## 2.3 Преобразование десятичных чисел в другие системы счисления
|
||||
```py
|
||||
>>>hh=123
|
||||
>>>dv1=bin(hh) #в двоичную сс
|
||||
>>>dv1
|
||||
'0b1111011'
|
||||
>>>vos1=oct(hh) #в восьмеричную сс
|
||||
>>>vos1
|
||||
'0o173'
|
||||
>>>shs1=hex(hh) #в шеснадцатеричную сс
|
||||
>>>shs1
|
||||
'0x7b'
|
||||
```
|
||||
Для проверки выполним обратные преобразования
|
||||
|
||||
```py
|
||||
>>>int (dv1,2)
|
||||
123
|
||||
>>int(vos1,8)
|
||||
123
|
||||
>>int(shs1,16)
|
||||
123
|
||||
```
|
||||
## Пункт 3.
|
||||
Преобразование более сложных базовых типов объектов
|
||||
## 3.1 Преобразование в строку символов с помощью функции str(<Объект>)
|
||||
```py
|
||||
>>>strk=str(23.6)
|
||||
>>>strk
|
||||
'23.6'
|
||||
>>>strk2=str(logiz3)
|
||||
>>>strk2
|
||||
'True'
|
||||
>>>strk3=str(["A","B","C"]) #Преобразуем список
|
||||
>>>strk3
|
||||
"['A', 'B', 'C']"
|
||||
>>>strk4=str(("A","B","C")) #Преобразуем кортеж
|
||||
>>>strk4
|
||||
"('A', 'B', 'C')"
|
||||
>>>strk5=str({"A":1,"B":2,"C":9}) #Преобразуем словарь
|
||||
>>>strk5
|
||||
"{'A': 1, 'B': 2, 'C': 9}"
|
||||
```
|
||||
## 3.2 Преобразование элементов объекта в список с помощью функции list(<Объект>)
|
||||
```py
|
||||
>>>spis1=list("Строка символов") #Заданная строка разделяется на символы
|
||||
>>>spis1
|
||||
['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
|
||||
>>>spis2=list((124,236,-15,908)) #Кортеж превращается в список
|
||||
>>>spis2
|
||||
[124, 236, -15, 908]
|
||||
>>>spis3=list({"A":1,"B":2,"C":9}) #Преобразование словаря в список
|
||||
>>>spis3
|
||||
['A', 'B', 'C']
|
||||
>>> spis4 = list({"A":1,"B":2,"C":9}.values())
|
||||
>>> spis4
|
||||
[1, 2, 9]
|
||||
```
|
||||
## 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>)
|
||||
```py
|
||||
>>>kort7=tuple('Строка символов') #Преобразование строки символов в кортеж
|
||||
>>>kort7
|
||||
('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
|
||||
|
||||
>>>kort8=tuple(spis2) #Преобразование списка в кортеж
|
||||
>>>kort8
|
||||
(124, 236, -15, 908)
|
||||
>>>kort9=tuple({"A":1,"B":2,"C":9}) #Преобразование словаря в кортеж
|
||||
>>>kort9
|
||||
('A', 'B', 'C')
|
||||
>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values()))
|
||||
>>> kort9
|
||||
(1, 2, 9)
|
||||
```
|
||||
## 3.4. Удаление объектов
|
||||
```py
|
||||
>>>del strk5, kort8
|
||||
Проверим
|
||||
>>>dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1']
|
||||
```
|
||||
Создадим строку со своей фамилией и инициалами, преобразуем её в список, затем список – в кортеж и, наконец, кортеж – в строку.
|
||||
```py
|
||||
>>> f= 'ЦветковаТА'
|
||||
>>> spis= list(f)
|
||||
>>> spis
|
||||
['Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А']
|
||||
>>> k=tuple(spis)
|
||||
>>> k
|
||||
('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')
|
||||
>>> kk=str(k)
|
||||
>>> kk
|
||||
"('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')"
|
||||
>>> sttr = ''.join(k)
|
||||
>>> sttr
|
||||
'ЦветковаТА'
|
||||
```
|
||||
## Пункт 4. Арифметические операции.
|
||||
## 4.1. Сложение и вычитание (+ и -)
|
||||
```py
|
||||
>>> 12+7+90
|
||||
109
|
||||
>>> 5.689e-1 - 0.456
|
||||
0.11289999999999994
|
||||
>>> 23.6+54
|
||||
77.6
|
||||
>>> 14-56.7+89
|
||||
46.3
|
||||
```
|
||||
## 4.2. Умножение (*)
|
||||
```py
|
||||
>>> -6.7*12
|
||||
-80.4
|
||||
```
|
||||
## 4.3. Деление (/). Результатом деления всегда будет вещественное число!
|
||||
```py
|
||||
>>> -234.5/6
|
||||
-39.083333333333336
|
||||
>>> a=178/45
|
||||
>>> a
|
||||
3.9555555555555557
|
||||
>>> type(a)
|
||||
<class 'float'>
|
||||
```
|
||||
## 4.4. Деление с округлением вниз (//). Здесь результат может быть целым или вещественным.
|
||||
```py
|
||||
>>> b=178//45
|
||||
>>> b
|
||||
3
|
||||
>>> type(b)
|
||||
<class 'int'>
|
||||
>>> c=-24.6//12.1
|
||||
>>> c
|
||||
-3.0
|
||||
>>> type(c)
|
||||
<class 'float'>
|
||||
```
|
||||
## 4.5. Получение остатка от деления (%).
|
||||
```py
|
||||
>>> 148%33
|
||||
16
|
||||
>>> 12.6%3.8
|
||||
1.2000000000000002
|
||||
>>> 56.97%6
|
||||
2.969999999999999
|
||||
```
|
||||
## 4.6. Возведение в степень (**).
|
||||
```py
|
||||
>>> 14**3
|
||||
2744
|
||||
>>> e=2.7**3.6
|
||||
>>> e
|
||||
35.719843790663525
|
||||
>>> d=2.7**3
|
||||
>>> d
|
||||
19.683000000000003
|
||||
```
|
||||
Попробуем проделать арифметические операции над комплексными числами. Создадим два
|
||||
комплексных числа
|
||||
```py
|
||||
>>> k1=(2+1j)
|
||||
>>> k2=(1+2j)
|
||||
>>> k1+k2
|
||||
(3+3j)
|
||||
>>> k2-k1
|
||||
(-1+1j)
|
||||
>>> k1*k2
|
||||
5j
|
||||
>>> k1/k2
|
||||
(0.8-0.6j)
|
||||
>>> k1**k2
|
||||
(-0.42589434775182566+0.7753703444218832j)
|
||||
>>> k1//k2
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
|
||||
>>>k1//2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#115>", line 1, in <module>
|
||||
k1//2
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'int'
|
||||
>>> k1%k2
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||
>>>k1%2
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'int'
|
||||
|
||||
```
|
||||
## Пункт 5. Операции с двоичными представлениями целых чисел.
|
||||
|
||||
## 5.1 Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0)
|
||||
```py
|
||||
>>> dv1=9
|
||||
>>> dv2=~dv1
|
||||
>>> dv2
|
||||
-10
|
||||
```
|
||||
## 5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
|
||||
```py
|
||||
>>> 7&9
|
||||
1
|
||||
>>> 7&8
|
||||
0
|
||||
```
|
||||
Проверим
|
||||
```py
|
||||
>>> bin(7)
|
||||
'0b111'
|
||||
>>> bin(9)
|
||||
'0b1001'
|
||||
>>> bin(7&9)
|
||||
'0b1'
|
||||
```
|
||||
## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
|
||||
```py
|
||||
>>> 7|9 # 0111 или 1001 = 1111
|
||||
15
|
||||
>>> 7|8 # 0111 или 1000 = 1111
|
||||
|
||||
15
|
||||
>>> 14|5 # 1110 или 0101 = 1111
|
||||
15
|
||||
>>> bin(15)
|
||||
'0b1111'
|
||||
```
|
||||
## 5.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
|
||||
```py
|
||||
>>> 14^5 #1110 ^ 0101 = 1011
|
||||
11
|
||||
>>> bin(11)
|
||||
'0b1011'
|
||||
>>> bin(14)
|
||||
'0b1110'
|
||||
>>> bin(5)
|
||||
'0b101'
|
||||
```
|
||||
## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
|
||||
```py
|
||||
>>> h=14
|
||||
>>> bin(14)
|
||||
'0b1110'
|
||||
>>> g=h<<2
|
||||
>>> bin(g)
|
||||
'0b111000'
|
||||
>>> g1=h>>1
|
||||
>>> bin(g1)
|
||||
'0b111'
|
||||
>>> g2=h>>2
|
||||
>>> bin(g2)
|
||||
'0b11'
|
||||
```
|
||||
Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
|
||||
```py
|
||||
>>> bin(76)
|
||||
'0b1001100'
|
||||
>>> bin(112)
|
||||
'0b1110000'
|
||||
>>> 76&112
|
||||
64
|
||||
>>> bin(64)
|
||||
'0b1000000'
|
||||
>>> 76|112
|
||||
124
|
||||
>>> bin(124)
|
||||
'0b1111100'
|
||||
>>> 76^112
|
||||
60
|
||||
>>> g=76<<2
|
||||
>>> g
|
||||
304
|
||||
>>> bin(g)
|
||||
'0b100110000'
|
||||
```
|
||||
## 6. Операции при работе с последовательностями (строками, списками, кортежами).
|
||||
## 6.1. Объединение последовательностей (конкатенация)(+)
|
||||
```py
|
||||
>>>'Система '+'регулирования' #Соединение двух строк символов
|
||||
'Система регулирования'
|
||||
>>>['abc','de','fg']+['hi','jkl'] # Объединение двух списков
|
||||
['abc', 'de', 'fg', 'hi', 'jkl']
|
||||
>>>('abc','de','fg')+('hi','jkl') # Объединение двух кортежей
|
||||
('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
```
|
||||
## 6.2 Повторение (*)
|
||||
```py
|
||||
>>> 'ля-'*5
|
||||
'ля-ля-ля-ля-ля-'
|
||||
>>> ['ку','-']*3
|
||||
['ку', '-', 'ку', '-', 'ку', '-']
|
||||
|
||||
>>> ('кис','-')*4
|
||||
('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
|
||||
>>> signal1=[0]*3+[1]*99
|
||||
>>> signal1
|
||||
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
|
||||
>>> signal2=(0,)*3+(1,)*5+(0,)*7
|
||||
>>> signal2
|
||||
(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
|
||||
```
|
||||
## 6.3. Проверка наличия заданного элемента в последовательности (in)
|
||||
```py
|
||||
>>> stroka='Система автоматического управления'
|
||||
>>> 'автомат' in stroka
|
||||
True
|
||||
>>> 'ку' in ['ку','-']*3
|
||||
True
|
||||
>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
False
|
||||
```
|
||||
## 6.4. Подстановка значений в строку с помощью оператора «%»
|
||||
```py
|
||||
>>> stroka='Температура=%g %s %g'
|
||||
>>> stroka
|
||||
'Температура=%g %s %g'
|
||||
>>> stroka % (16,' меньше ',25)
|
||||
'Температура=16 меньше 25'
|
||||
>>> stroka % (66,' меньше ',77)
|
||||
'Температура=66 меньше 77'
|
||||
>>> stroka='Температура = %(zn1)g %(sravn)s %(zn2)g'
|
||||
>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
|
||||
'Температура = 16 меньше 25'
|
||||
```
|
||||
## 7. Оператор присваивания
|
||||
## 7.1. Обычное присваивание значения переменной (=)
|
||||
```py
|
||||
>>> zz=-12
|
||||
```
|
||||
## 7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=)
|
||||
```py
|
||||
>>> zz+=5
|
||||
>>> zz
|
||||
-7
|
||||
>>> zz-=3
|
||||
>>> zz
|
||||
-10
|
||||
>>> stroka='Система'
|
||||
>>> stroka+=' регулирования'
|
||||
>>> stroka
|
||||
'Система регулирования'
|
||||
```
|
||||
## 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
|
||||
```py
|
||||
>>> zz/=2
|
||||
>>> zz
|
||||
-5.0
|
||||
>>> zz*=5
|
||||
>>> zz
|
||||
-25.0
|
||||
```
|
||||
## 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
|
||||
```py
|
||||
>>> zz//=2
|
||||
>>> zz
|
||||
-13.0
|
||||
>>> zz**=2
|
||||
>>> zz
|
||||
169.0
|
||||
>>> zz%=5
|
||||
>>> zz
|
||||
4.0
|
||||
```
|
||||
## 7.5. Множественное присваивание
|
||||
Присваивание одного значения нескольким переменным
|
||||
```py
|
||||
>>> w=v=10
|
||||
>>> w
|
||||
10
|
||||
>>> v
|
||||
10
|
||||
```
|
||||
Присваивание кортежа
|
||||
```py
|
||||
>>> n1,n2,n3=(11,-3,'all')
|
||||
>>> n1,n2,n3
|
||||
(11, -3, 'all')
|
||||
```
|
||||
Присваивание списка
|
||||
```py
|
||||
>>> a1,a2,a3=[1,2,3]
|
||||
>>> a1,a2,a3
|
||||
(1, 2, 3)
|
||||
```
|
||||
Присваивание словаря
|
||||
```py
|
||||
>>> s1,s2,s3={'один':1,'два':2,'три':3}
|
||||
>>> s1,s2,s3
|
||||
('один', 'два', 'три')
|
||||
```
|
||||
Если необходимо присвоить значения, то это можно сделать через .values()
|
||||
```py
|
||||
>>> s1,s2,s3={'один':1,'два':2,'три':3}.values()
|
||||
>>> s1,s2,s3
|
||||
(1, 2, 3)
|
||||
```
|
||||
Если необходимо присвоить ключи и значения, то это можно сделать через .items()
|
||||
```py
|
||||
>>> f1,f2,f3={'один':1,'два':2,'три':3}.items()
|
||||
>>> f1,f2,f3
|
||||
(('один', 1), ('два', 2), ('три', 3))
|
||||
>>> f1
|
||||
('один', 1)
|
||||
>>> f2
|
||||
('два', 2)
|
||||
>>> f3
|
||||
('три', 3)
|
||||
```
|
||||
Присваивание множества
|
||||
```py
|
||||
>>> m1,m2,m3={0,89,6}
|
||||
>>> m1,m2,m3
|
||||
(0, 89, 6)
|
||||
```
|
||||
Присваивание строки
|
||||
```py
|
||||
>>> c1,c2,c3='1','2','3'
|
||||
>>> c1,c2,c3
|
||||
('1', '2', '3')
|
||||
```
|
||||
## 8. Логические операции (True или False)
|
||||
## 8.1. Операции сравнение
|
||||
```py
|
||||
>>> v==w
|
||||
True
|
||||
>>> v!=w
|
||||
False
|
||||
>>> v>w
|
||||
False
|
||||
>>> v<w
|
||||
False
|
||||
>>> v>=w
|
||||
True
|
||||
>>> v<=w
|
||||
True
|
||||
>>> 5==4
|
||||
False
|
||||
>>> 5!=4
|
||||
True
|
||||
>>> 5>4
|
||||
True
|
||||
>>> 5<4
|
||||
False
|
||||
>>> 5>=4
|
||||
True
|
||||
>>> 5<=4
|
||||
False
|
||||
```
|
||||
## 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также про-верка наличия ключа в словаре (in).
|
||||
Операции с множеством
|
||||
```py
|
||||
>>> mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
>>> 'book' in mnoz1
|
||||
True
|
||||
>>> 'cap' in mnoz1
|
||||
False
|
||||
```
|
||||
Операции со словарем
|
||||
```py
|
||||
>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
>>> 'Vologda' in dic1
|
||||
True
|
||||
>>> 'Pskov' in dic1
|
||||
False
|
||||
>>> 56 in dic1.values()
|
||||
True
|
||||
```
|
||||
Ещё пример работы со словарем:
|
||||
```py
|
||||
>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
|
||||
>>> 'UII' in dct1['Depart']
|
||||
True
|
||||
>>> dct1['Depart'][1] == 'MM'
|
||||
False
|
||||
```
|
||||
## 8.3. Создание больших логических выражений с использованием соединительных слов: логиче-ское «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).
|
||||
```py
|
||||
>>> a=17
|
||||
>>> b=-6
|
||||
>>> (a>=b)and('book' in mnoz1)and not('Pskov' in dic1 )
|
||||
True
|
||||
>>> (5==4)or(a==17)
|
||||
True
|
||||
>>> (5==4)and(a==17)
|
||||
False
|
||||
>>> ((5==4)and(a==17))or(not(5==4)and(a==17))
|
||||
True
|
||||
```
|
||||
## 8.4. Проверка ссылок переменных на один и тот же объект (is).
|
||||
|
||||
```py
|
||||
>>> w=v=10
|
||||
>>> w1=['A','B']
|
||||
>>> v1=['A','B']
|
||||
>>> w1==v2
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
NameError: name 'v2' is not defined. Did you mean: 'v'?
|
||||
>>> w1==v1
|
||||
True
|
||||
>>> w1 is v1
|
||||
False
|
||||
>>> w is v
|
||||
True
|
||||
```
|
||||
Оператор is сравнивает адреса объектов в памяти. Целые числа из одной строки хранятся по одному адресу, поэтому is возвращает True. Словари же, созданные отдельно, размещаются в разных местах памяти, и is для них дает False.
|
||||
## Пункт 9. Операции с объектами, выполняемые с помощью методов.
|
||||
Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например,
|
||||
```py
|
||||
>>> stroka='Микропроцессорная система управления'
|
||||
>>> dir(stroka)
|
||||
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
|
||||
```
|
||||
## 9.1. Методы для работы со строками
|
||||
```py
|
||||
>>> stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста или значение -1
|
||||
5
|
||||
>>> stroka.count("с") #Подсчет числа вхождений строки "с" в stroka
|
||||
4
|
||||
>>> stroka.replace(' у',' автоматического у')
|
||||
'Микропроцессорная система автоматического управления'
|
||||
>>> spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит за-данный разделитель
|
||||
>>> spis22
|
||||
['Микропроцессорная', 'система', 'управления']
|
||||
>>> stroka.upper() #Возвращает строку со всеми заглавными буквами
|
||||
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||
>>> stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка
|
||||
>>> stroka3
|
||||
'Микропроцессорная система управления'
|
||||
>>> stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева
|
||||
('Микропроце', 'с', 'сорная система управления')
|
||||
>>> stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа
|
||||
('Микропроцессорная си', 'с', 'тема управления')
|
||||
```
|
||||
## Mетод format
|
||||
Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.
|
||||
```py
|
||||
>>> strk1='Момент времени {}, значение = {}'
|
||||
>>> strk1
|
||||
'Момент времени {}, значение = {}'
|
||||
>>> strk1.format(1,89.7)
|
||||
'Момент времени 1, значение = 89.7'
|
||||
>>> strk2='Момент времени {1}, значение = {0}:{2}'
|
||||
```
|
||||
Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргумен-тов формата. Поэтому такой способ называют основанным на позиционных аргументах. Например,
|
||||
```py
|
||||
>>> strk2.format(36.7,2,'норма!')
|
||||
'Момент времени 2, значение = 36.7:норма!'
|
||||
>>> strk3='Момент времени {num}, значение = {znch}'
|
||||
```
|
||||
Здесь в скобках указаны имена аргументов – вставок. Поэтому такой способ основан на имено-ванных аргументах.
|
||||
```py
|
||||
>>> strk3.format(znch=89.7,num=2)
|
||||
'Момент времени 2, значение = 89.7'
|
||||
```
|
||||
## 9.2. Методы для работы со списками.
|
||||
```py
|
||||
>>> spsk = [1, (2, 3), 'hello Sergey Alexandrovich', 3.14 , 'pi']
|
||||
>>> spsk.pop(2) #Удаление элемента по индексу
|
||||
'hello Sergey Alexandrovich'
|
||||
>>> spsk.append('c') #Вставка элемента в конец
|
||||
>>> spsk
|
||||
[1, (2, 3), 3.14, 'pi', 'c']
|
||||
>>> spsk.insert(2,'a') #Вставка элемента в конкретное место по индексу
|
||||
>>> spsk
|
||||
[1, (2, 3), 'a', 3.14, 'pi', 'c']
|
||||
>>> spsk.count('a') #Подсчет количества элементов по значению
|
||||
1
|
||||
## 9.3. Mетоды кортежей
|
||||
У кортежей методов меньше, тк он являетя неизменяемым и методов на добавление/удаление объекта - нет
|
||||
```py
|
||||
>>> km2=(5,'пять', 5.55, 'мопсикии',4+1j)
|
||||
>>> km2.count(5)
|
||||
1
|
||||
>>> km2.index('мопсикии')
|
||||
3
|
||||
```
|
||||
## 9.4 Методы словарей
|
||||
```py
|
||||
>>> d={'key1':1, 'key2':2,'key3':3,'key4':4}
|
||||
Cоздание копии
|
||||
```py
|
||||
>>> d1=d.copy()
|
||||
>>> d1
|
||||
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4}
|
||||
```
|
||||
Возвращение значения по ключу
|
||||
```py
|
||||
>>> d.get('key3')
|
||||
3
|
||||
```
|
||||
Возвращение кортежей из пар ключ-значение
|
||||
```py
|
||||
>>> d.items()
|
||||
dict_items([('key1', 1), ('key2', 2), ('key3', 3), ('key4', 4)])
|
||||
```
|
||||
Возвращение объекта только из ключей
|
||||
```py
|
||||
>>> d.keys()
|
||||
dict_keys(['key1', 'key2', 'key3', 'key4'])
|
||||
```
|
||||
Возвращение объекта только из значений
|
||||
```py
|
||||
>>> d.values()
|
||||
dict_values([1, 2, 3, 4])
|
||||
```
|
||||
Добавление ключ-значения
|
||||
```py
|
||||
>>> d['key5']=5
|
||||
>>> d
|
||||
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
|
||||
```
|
||||
Удаление ключ-значения
|
||||
```py
|
||||
>>> d.pop('key1')
|
||||
1
|
||||
>>> d
|
||||
{'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
|
||||
```
|
||||
Очищение словаря
|
||||
```py
|
||||
>>> d.clear()
|
||||
>>> d
|
||||
{}
|
||||
```
|
||||
|
||||
## Методы множеств
|
||||
|
||||
```py
|
||||
>>> mn={1,'dva',3.33}
|
||||
```
|
||||
Добавление элемента
|
||||
```py
|
||||
>>> mn.add(4)
|
||||
>>> mn
|
||||
{1, 3.33, 4, 'dva'}
|
||||
```
|
||||
Создание копии
|
||||
```py
|
||||
>>> cop=mn.copy()
|
||||
>>> cop
|
||||
{1, 3.33, 4, 'dva'}
|
||||
```
|
||||
Удаление элемента по значению
|
||||
```py
|
||||
>>> mn.remove(1)
|
||||
>>> mn
|
||||
{3.33, 4, 'dva'}
|
||||
```
|
||||
Удаление элемента по значению
|
||||
```py
|
||||
>>> mn.discard('dva')
|
||||
>>> mn
|
||||
{3.33, 4}
|
||||
```
|
||||
Очищение множества
|
||||
```py
|
||||
>>> mn.clear()
|
||||
>>> mn
|
||||
set()
|
||||
```
|
||||
Удаление и возвращение случайного элемента из множества
|
||||
```py
|
||||
>>> cop.pop()
|
||||
1
|
||||
>>> cop
|
||||
{3.33, 4, 'dva'}
|
||||
```
|
||||
Добавление элементов
|
||||
```py
|
||||
>>> cop.update({False,'t'})
|
||||
>>> cop
|
||||
{False, 3.33, 4, 't', 'dva'}
|
||||
```
|
||||
|
||||
## Общее контрольное задание
|
||||
Преобразовать восьмеричное значение 45 в целое число.
|
||||
```py
|
||||
|
||||
>>> octv = '45'
|
||||
>>> decv = int(octv, 8)
|
||||
>>> decv
|
||||
37
|
||||
```
|
||||
Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12,
|
||||
"постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и
|
||||
значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж
|
||||
от списка?
|
||||
```py
|
||||
>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
|
||||
>>> keyD = list(D.keys())
|
||||
>>> keyD
|
||||
['усиление', 'запаздывание', 'постоянная времени']
|
||||
>>> valD = list(D.values())
|
||||
>>> valD
|
||||
[23, 12, 78]
|
||||
>>> tupD = (keyD, valD)
|
||||
>>> tupD
|
||||
(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
|
||||
|
||||
```
|
||||
Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с
|
||||
округлением вниз, с определением после этого остатка от деления получившегося значения
|
||||
на 3 и затем возведения результата в степень 2.4.
|
||||
```py
|
||||
>>> ((1768 // 24.8) % 3) ** 2.4
|
||||
5.278031643091577
|
||||
```
|
||||
Напишите и выполните единое выражение, последовательно осуществляющее следующие
|
||||
операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее
|
||||
ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
```py
|
||||
>>> ((~(13 & 27)) ^ 14) << 2
|
||||
-32
|
||||
```
|
||||
Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки
|
||||
наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов
|
||||
этого списка.
|
||||
```py
|
||||
>>> lst = ["колебат"] * 4
|
||||
>>> lst[1] += lst[2]
|
||||
>>> lst
|
||||
['колебат', 'колебатколебат', 'колебат', 'колебат']
|
||||
>>> lst.pop(2)
|
||||
'колебат'
|
||||
>>> lst
|
||||
['колебат', 'колебатколебат', 'колебат']
|
||||
>>> 'аткол' in lst[1]
|
||||
True
|
||||
```
|
||||
Определить список методов, доступных у ранее созданного словаря D. Поочередно
|
||||
использовать его методы keys и values, определить, что можно получить с применением
|
||||
этих методов.
|
||||
```py
|
||||
>>> 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 особые объекты, которые ссылаются на элементы исходного словаря.
|
||||
|
||||
Создать объект - символьную строку с текстом данного предложения. Из символьной строки
|
||||
создать список, элементами которого будут отдельные слова из созданной строки. Заменить в
|
||||
списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить
|
||||
получившийся список.
|
||||
```py
|
||||
>>> sen = "Создать объект - символьную строку с текстом данного предложения"
|
||||
>>> senl = sen.split()
|
||||
>>> senl
|
||||
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
>>> senl[senl.index("-")] = ","
|
||||
>>> senl
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
>>> senl.remove("данного")
|
||||
>>> senl
|
||||
['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
|
||||
```
|
||||
@@ -1,26 +0,0 @@
|
||||
26) Напишите инструкцию определения и запоминания в переменной текущего московского ка-лендарного времени. Создайте список с 40 элементами – числами от 3 с шагом 6. Создайте кортеж с 12 элементами - случайным подмножеством из элементов списка. Создайте новый кортеж с элементами из первого кортежа, упорядоченными по убыванию величина. Рассчитайте сумму элементов второго кортежа, начиная с 4-го от начала и до 8-го. Отобразите ре-зультат на экране в виде «Сумма элементов кортежа = ХХХ». Определите, сколько времени в секундах прошло с начала выполнения задания
|
||||
```py
|
||||
>>> import time #начальное время
|
||||
>>> import random #начальное время для Москвы
|
||||
>>> start_time = time.time()
|
||||
>>> start_time
|
||||
1760354973.1996331
|
||||
>>> here = time.localtime()
|
||||
>>> here
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=29, tm_sec=44, tm_wday=0, tm_yday=286, tm_isdst=0)
|
||||
>>> numbers_list = list(range(3, 3 + 40*6, 6)) #список с 40 элементами – числами от 3 с шагом 6
|
||||
>>> numbers_list
|
||||
[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99, 105, 111, 117, 123, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195, 201, 207, 213, 219, 225, 231, 237]
|
||||
>>> random_tuple = tuple(random.sample(numbers_list, 12)) #кортеж с 12 элементами - случайным подмножеством из элементов списка
|
||||
>>> random_tuple
|
||||
(189, 159, 153, 171, 219, 183, 201, 93, 237, 111, 165, 225)
|
||||
>>> r_tuple=tuple(sorted(random_tuple, reverse=True)) #сортировка в обратном порядке в кортеж
|
||||
>>> r_tuple
|
||||
(237, 225, 219, 201, 189, 183, 171, 165, 159, 153, 111, 93)
|
||||
>>> sum_elements = sum(r_tuple[3:8]) #суммa элементов второго кортежа
|
||||
>>> sum_elements
|
||||
909
|
||||
>>> end_time = time.time()
|
||||
>>> end_time
|
||||
1760355380.4714587
|
||||
```
|
||||
30
TEMA4/26.md
30
TEMA4/26.md
@@ -1,30 +0,0 @@
|
||||
26. Напишите инструкцию определения и запоминания в переменной текущего московского ка-лендарного времени. Создайте список с 40 элементами – числами от 3 с шагом 6. Создайте кортеж с 12 элементами - случайным подмножеством из элементов списка. Создайте новый кортеж с элементами из первого кортежа, упорядоченными по убыванию величина. Рассчитайте сумму элементов второго кортежа, начиная с 4-го от начала и до 8-го. Отобразите ре-зультат на экране в виде «Сумма элементов кортежа = ХХХ». Определите, сколько времени в секундах прошло с начала выполнения задания.
|
||||
импорт библиотек
|
||||
```py
|
||||
>>> import time
|
||||
>>> import random
|
||||
```
|
||||
```py
|
||||
>>> start_time = time.time() #начальное время
|
||||
>>> here = time.localtime() #начальное время для Москвы
|
||||
>>> here
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=12, tm_sec=58, tm_wday=0, tm_yday=286, tm_isdst=0)
|
||||
>>> start_time
|
||||
1760353951.7821183
|
||||
>>> numbers_list = list(range(3, 3 + 40*6, 6)) #список с 40 элементами – числами от 3 с шагом 6
|
||||
>>> numbers_list
|
||||
[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99, 105, 111, 117, 123, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195, 201, 207, 213, 219, 225, 231, 237]
|
||||
>>> reverse_tuple = tuple(sorted(numbers_list, reverse=True)) #сортировка в обратном порядке в кортеж
|
||||
>>> reverse_tuple
|
||||
(237, 231, 225, 219, 213, 207, 201, 195, 189, 183, 177, 171, 165, 159, 153, 147, 141, 135, 129, 123, 117, 111, 105, 99, 93, 87, 81, 75, 69, 63, 57, 51, 45, 39, 33, 27, 21, 15, 9, 3)
|
||||
>>> sum_elements = sum(sorted_kortezh[3:8])
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
NameError: name 'sorted_kortezh' is not defined
|
||||
|
||||
>>> sum_elements = sum(reverse_tuple[3:8]) #рассчитайте сумму элементов второго кортежа
|
||||
>>> sum_elements
|
||||
1035
|
||||
>>> end_time = time.time() #финальное время
|
||||
>>> end_time
|
||||
1760354435.6719537
|
||||
Двоичные данные
TEMA4/Ris2.png
Двоичные данные
TEMA4/Ris2.png
Двоичный файл не отображается.
|
До Ширина: | Высота: | Размер: 26 KiB |
Двоичные данные
TEMA4/Ris3.png
Двоичные данные
TEMA4/Ris3.png
Двоичный файл не отображается.
|
До Ширина: | Высота: | Размер: 15 KiB |
Двоичные данные
TEMA4/Ris4.png
Двоичные данные
TEMA4/Ris4.png
Двоичный файл не отображается.
|
До Ширина: | Высота: | Размер: 7.2 KiB |
748
TEMA4/lab4.md
748
TEMA4/lab4.md
@@ -1,748 +0,0 @@
|
||||
### Отчет тема 4
|
||||
## Пункт 2 Стандартные функции (модуль builtins, импортированный по умолчанию)
|
||||
## Пункт 2.1
|
||||
round() - округление с заданной точностью
|
||||
```py
|
||||
>>> 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.
|
||||
```
|
||||
```py
|
||||
>>> round(123.456,1)
|
||||
123.5
|
||||
>>> type(round(123.456,1))
|
||||
<class 'float'>
|
||||
```
|
||||
```py
|
||||
>>> round(123.456,0)
|
||||
123.0
|
||||
>>> type(round(123.456,0))
|
||||
<class 'float'>
|
||||
```
|
||||
```py
|
||||
>>> round(123.456)
|
||||
123
|
||||
>>> type(round(123.456))
|
||||
<class 'int'>
|
||||
```
|
||||
Если ndigits не указан, функция возвращает округленное целое число.
|
||||
Если указано, то число с плавающей точкой
|
||||
|
||||
## Пункт 2.2
|
||||
Функция range создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
|
||||
```py
|
||||
>>> gg=range(76,123,9)
|
||||
>>> gg
|
||||
range(76, 123, 9)
|
||||
>>> type(gg)
|
||||
<class 'range'>
|
||||
>>> list(gg)
|
||||
[76, 85, 94, 103, 112, 121]
|
||||
```
|
||||
Можно и не задавать шаг
|
||||
```py
|
||||
>>> range(23)
|
||||
range(0, 23)
|
||||
>>> list(range(23))
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
|
||||
```
|
||||
## Пункт 2.3 zip – создание общего объекта, элементами которого являются кортежи, составленные из эле-ментов двух или более объектов-последовательностей
|
||||
```py
|
||||
>>> qq = ['Цветкова', 'Снегура','Зеленкина']
|
||||
>>> ff=zip(gg,qq)
|
||||
>>> ff
|
||||
<zip object at 0x000001903C06A5C0>
|
||||
>>> tuple(ff)
|
||||
((76, 'Цветкова'), (85, 'Снегура'), (94, 'Зеленкина'))
|
||||
>>> ff[0]
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
```
|
||||
```py
|
||||
>>> ff[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#34>", line 1, in <module>
|
||||
ff[1]
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
```
|
||||
Объект класса zip неизменяемый.
|
||||
|
||||
## Пункт 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
|
||||
```py
|
||||
>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
||||
коэффициент усиления=5
|
||||
>>> dan
|
||||
-131.0
|
||||
>>> fff
|
||||
5.0
|
||||
```
|
||||
eval() — Это встроенная функция в Python, которая выполняет строку кода как программу.
|
||||
Как работает:
|
||||
1)Компилирует строку в байт-код
|
||||
2)Выполняет этот байт-код в заданном контексте
|
||||
## Пункт 2.5. Похожая на eval функция exec – чтение и выполнение объекта-аргумента функции. Этот объ-ект должен представлять собой строку символов с совокупностью инструкций на языке Python.
|
||||
```py
|
||||
>>> exec(input('введите инструкции:'))
|
||||
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
||||
>>> gg
|
||||
221.456
|
||||
Пояснение:
|
||||
eval превращает текст в работающий код
|
||||
exec может выполнять любой код, но не возвращает значение.
|
||||
## Пункт 2.6. Самостоятельно изучите и попробуйте применить функции abs, pow, max, min, sum, divmod, len, map.
|
||||
```py
|
||||
Возведение модуля (abs)
|
||||
```py
|
||||
>>> abs(-5)
|
||||
5
|
||||
>>> abs(5+5j)
|
||||
7.0710678118654755
|
||||
>>> abs(4**(-10))
|
||||
9.5367431640625e-07
|
||||
>>> abs(-4**10)
|
||||
1048576
|
||||
>>> abs(-4**(-10))
|
||||
9.5367431640625e-07
|
||||
```
|
||||
Возведение степени
|
||||
```py
|
||||
>>> pow(5,2)
|
||||
25
|
||||
>>> pow(-5,-2)
|
||||
0.04
|
||||
>>> pow(5,4,2)
|
||||
1
|
||||
>>> pow(5+5j,2)
|
||||
50j
|
||||
```
|
||||
Максимальное значение
|
||||
|
||||
```py
|
||||
>>> max(2,5.8,7)
|
||||
7
|
||||
>>> max([4,0,-7])
|
||||
4
|
||||
>>> max({'a': 1, 'b': 2, 'c': 3}) #выбор большего происходит из ключей
|
||||
'c'
|
||||
>>> max(["ee", "eee", "eeeeeee"], key = len)
|
||||
'eeeeeee'
|
||||
>>> max("b", "B") #сравнивает коды символов в unicode
|
||||
'b'
|
||||
>>> max([34,5,6, "e", 5+2j])
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: '>' not supported between instances of 'str' and 'int'
|
||||
```
|
||||
Видно что с разными типами данных не работает
|
||||
|
||||
Минимальное значение
|
||||
```py
|
||||
>>> min(2,5.8,7)
|
||||
2
|
||||
>>> min(({'a': 1, 'b': 2, 'c': 3})) #по ключу
|
||||
'a'
|
||||
>>> min(-7,-6,abs(-8))
|
||||
-7
|
||||
```
|
||||
Сумма элементов
|
||||
```py
|
||||
>>> sum([1,2,3,4])
|
||||
10
|
||||
>>> sum([1,2,3,4], -2)
|
||||
8
|
||||
```
|
||||
```py
|
||||
>>> sum("bbbb", "аааа")
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: sum() can't sum strings [use ''.join(seq) instead]
|
||||
>>> sum(5+5j,3)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'complex' object is not iterable
|
||||
>>> sum(5+5j,5+5j)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'complex' object is not iterable
|
||||
>>> sum(4.5,5)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'float' object is not iterable
|
||||
>>> sum(4.5,4.5)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: 'float' object is not iterable
|
||||
```
|
||||
Возвращение кортежа из целой части и остатка от деления
|
||||
```py
|
||||
>>> 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(20,3)
|
||||
(6, 2) #20 // 3 = 6 (целая часть) 20 % 3 = 2 (остаток)
|
||||
>>> divmod(20,-3)
|
||||
(-7, -1) 20 ÷ (-3) = -6.666... округляем вниз -7 20 % -3 = 1
|
||||
```
|
||||
|
||||
Длина объекта
|
||||
```py
|
||||
>>> len((1,2,2))
|
||||
3
|
||||
>>> len("aaaaaaaaaa")
|
||||
10
|
||||
>>> len(["aaaa","ddddddddddd"])
|
||||
2
|
||||
>>> len({'a': 1, 'b': 2, 'c': 3})
|
||||
3
|
||||
>>> len(12)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: object of type 'int' has no len()
|
||||
```
|
||||
Применение функции к каждому элементу коллекции
|
||||
```py
|
||||
>>> 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", "2"])
|
||||
<map object at 0x000001903C2BB5E0>
|
||||
>>> list(map(int, ["1", "2"]))
|
||||
[1, 2]
|
||||
```
|
||||
Останавливается когда самая короткая коллекция заканчивается
|
||||
"Лишние" элементы из более длинных коллекций игнорируются
|
||||
|
||||
## Пункт 3 Стандартный модуль math
|
||||
```py
|
||||
>>> 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
|
||||
```
|
||||
Нахождение синуса
|
||||
```py
|
||||
>>> help(math.sin)
|
||||
Help on built-in function sin in module math:
|
||||
|
||||
sin(x, /)
|
||||
Return the sine of x (measured in radians).
|
||||
>>> math.sin(math.pi/2)
|
||||
1.0
|
||||
>>> math.sin(0.96)
|
||||
0.8191915683009983
|
||||
```
|
||||
Нахождение арккосинуса
|
||||
```py
|
||||
>>> math.acos(1)
|
||||
0.0
|
||||
>>> math.acos(-1)
|
||||
3.141592653589793
|
||||
>>> math.acos(-0.54)
|
||||
2.1412334361948187
|
||||
>>> math.acos(5) #больше 1 нельзя
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
ValueError: math domain error
|
||||
```
|
||||
Перевод из радиан в градусы
|
||||
```py
|
||||
>>> help(math.degrees)
|
||||
Help on built-in function degrees in module math:
|
||||
|
||||
degrees(x, /)
|
||||
Convert angle x from radians to degrees.
|
||||
|
||||
>>> math.radians(math.pi)
|
||||
0.05483113556160755
|
||||
|
||||
>>> math.radians(360)
|
||||
6.283185307179586
|
||||
|
||||
>>> math.radians(90)
|
||||
1.5707963267948966
|
||||
```
|
||||
|
||||
Число е в степени заданного
|
||||
```py
|
||||
>>> 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
|
||||
>>> math.exp(1/2)
|
||||
1.6487212707001282
|
||||
```
|
||||
Нахождение логарифма
|
||||
```py
|
||||
>>> 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
|
||||
>>> math.log(-25,5) #с отрицательными числами не работает
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
ValueError: math domain error
|
||||
>>> math.log(25,-5)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
ValueError: math domain error
|
||||
```
|
||||
Десятичный логарифм
|
||||
```py
|
||||
>>> math.log10(10)
|
||||
1.0
|
||||
>>> math.log10(0.01)
|
||||
-2.0
|
||||
```
|
||||
Извлечение квадратного корня
|
||||
```py
|
||||
>>> math.sqrt(25)
|
||||
5.0
|
||||
>>> math.sqrt(26)
|
||||
5.0990195135927845
|
||||
>>> math.sqrt(26.7)
|
||||
5.167204273105526
|
||||
>>> math.sqrt(-25)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
ValueError: math domain error
|
||||
>>> math.sqrt(26.7+7j)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: must be real number, not complex
|
||||
```
|
||||
Округление числа до ближайшего целого вверх
|
||||
```py
|
||||
>>> 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(1.2)
|
||||
2
|
||||
>>> math.ceil(9.99)
|
||||
10
|
||||
>>> math.ceil(-6.2)
|
||||
-6
|
||||
>>> math.ceil(-6.9)
|
||||
-6
|
||||
```
|
||||
Округление вниз
|
||||
```py
|
||||
>>> math.floor(1.2)
|
||||
1
|
||||
>>> math.floor(9.99)
|
||||
9
|
||||
>>> math.floor(-6.2)
|
||||
-7
|
||||
>>> math.floor(-6.9)
|
||||
-7
|
||||
>>> math.floor(-6.9+5j)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: must be real number, not complex
|
||||
```
|
||||
Константа: число пи
|
||||
```py
|
||||
>>> math.pi
|
||||
3.141592653589793
|
||||
```
|
||||
комбинированное использование
|
||||
```py
|
||||
>>> math.sin(2 * math.pi / 7 + math.exp(0.23))
|
||||
0.8334902641414562
|
||||
```
|
||||
## Пункт 4 Модуль cmath для работы с комплексными числами
|
||||
```py
|
||||
>>> import cmath
|
||||
>>> dir(cmath)
|
||||
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
|
||||
>>> cmath.sqrt(1.2-0.5j)
|
||||
(1.118033988749895-0.22360679774997896j)
|
||||
>>> cmath.phase(1-0.5j)
|
||||
-0.4636476090008061
|
||||
```
|
||||
## Пункт 5 Модуль random для генерации псевдослучайных чисел и работы с ними
|
||||
```py
|
||||
>>> import random
|
||||
>>> dir(random)
|
||||
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_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()
|
||||
```
|
||||
```py
|
||||
>>> help(random.random)
|
||||
Help on built-in function random:
|
||||
|
||||
random() method of random.Random instance
|
||||
random() -> x in the interval [0, 1).
|
||||
```
|
||||
Случайное число от 0 до 1
|
||||
```py
|
||||
>>> random.random()
|
||||
0.23002075073724337
|
||||
>>> random.random()
|
||||
0.535712008113208
|
||||
>>> random.random()
|
||||
0.4738049347613569
|
||||
>>> 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.
|
||||
```
|
||||
Равномерно распределенное случайное число
|
||||
```py
|
||||
>>> random.uniform(20,30)
|
||||
22.41214721441803
|
||||
```
|
||||
Равномерное случайное целое
|
||||
```py
|
||||
>>> 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(20,30)
|
||||
21
|
||||
>>> random.randint(20,30)
|
||||
27
|
||||
```
|
||||
Случайное из коллекции
|
||||
```py
|
||||
>>> help(random.choice)
|
||||
Help on method choice in module random:
|
||||
|
||||
choice(seq) method of random.Random instance
|
||||
Choose a random element from a non-empty sequence.
|
||||
|
||||
>>> random.choice([ъъъ, "уууууууe", 80, 7, 5+5j])
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
NameError: name 'ъъъ' is not defined
|
||||
>>> random.choice(["ffff", "уууууууe", 80, 7, 5+5j])
|
||||
80
|
||||
>>> random.choice(["ffff", "уууууууe", 80, 7, 5+5j])
|
||||
(5+5j)
|
||||
```
|
||||
|
||||
Нормально распределенное случайное число
|
||||
```py
|
||||
>>> help(random.gauss)
|
||||
Help on method gauss in module random:
|
||||
|
||||
gauss(mu=0.0, sigma=1.0) method of random.Random instance
|
||||
Gaussian distribution.
|
||||
|
||||
mu is the mean, and sigma is the standard deviation. This is
|
||||
slightly faster than the normalvariate() function.
|
||||
|
||||
Not thread-safe without a lock around calls.
|
||||
|
||||
>>> random.gauss(0,1)
|
||||
-0.43812614222540897
|
||||
>>> random.gauss(7,8)
|
||||
11.287669776968896
|
||||
```
|
||||
Случайное подмножество
|
||||
```py
|
||||
>>> 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.
|
||||
|
||||
Returns a new list containing elements from the population while
|
||||
leaving the original population unchanged. The resulting list is
|
||||
in selection order so that all sub-slices will also be valid random
|
||||
samples. This allows raffle winners (the sample) to be partitioned
|
||||
into grand prize and second place winners (the subslices).
|
||||
|
||||
Members of the population need not be hashable or unique. If the
|
||||
population contains repeats, then each occurrence is a possible
|
||||
selection in the sample.
|
||||
|
||||
Repeated elements can be specified one at a time or with the optional
|
||||
counts parameter. For example:
|
||||
|
||||
sample(['red', 'blue'], counts=[4, 2], k=5)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
|
||||
|
||||
To choose a sample from a range of integers, use range() for the
|
||||
population argument. This is especially fast and space efficient
|
||||
for sampling from a large population:
|
||||
|
||||
sample(range(10000000), 60)
|
||||
|
||||
>>> lst=('a','b','c')
|
||||
>>> random.sample(lst, 2)
|
||||
['a', 'c']
|
||||
>>> random.sample(lst, 0)
|
||||
[]
|
||||
>>> random.sample(list, 7)
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.11_3.11.2544.0_x64__qbz5n2kfra8p0\Lib\random.py", line 439, in sample
|
||||
raise TypeError("Population must be a sequence. "
|
||||
TypeError: Population must be a sequence. For dicts or sets, use sorted(d).
|
||||
```
|
||||
Случайное число, подчиняющееся бета-распределению
|
||||
```py
|
||||
>>> 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(3,4)
|
||||
0.4104754948305531
|
||||
>>> random.betavariate(3,4)
|
||||
0.4104754948305531
|
||||
```
|
||||
Случайное число, подчиняющееся гамма-распределению
|
||||
```py
|
||||
>>> 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(3,4)
|
||||
18.75253913135498
|
||||
```
|
||||
Список из четырех чисел с разными законами распределения:
|
||||
```py
|
||||
>>> rd=[random.uniform(3,4),random.gauss(3,4),random.betavariate(3,4),random.gammavariate(3,4)]
|
||||
>>> rd
|
||||
[3.9065412706472173, 5.093585831129117, 0.423027969366889, 7.115102862880251]
|
||||
```
|
||||
## Пункт 6 time - модуль для работы со временем
|
||||
```py
|
||||
>>> import time
|
||||
>>> dir(time)
|
||||
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
|
||||
```
|
||||
UNIX-время
|
||||
```py
|
||||
>>> c1=time.time()
|
||||
>>> c1
|
||||
1760272978.995956
|
||||
>>> c2=time.time()-c1
|
||||
>>> c2
|
||||
12.162038326263428
|
||||
```
|
||||
Текущее время
|
||||
```py
|
||||
>>> 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()
|
||||
>>> list(dat)
|
||||
[2025, 10, 12, 12, 44, 15, 6, 285, 0]
|
||||
>>> dat.tm_year
|
||||
2025
|
||||
>>> dat.tm_yday
|
||||
285
|
||||
>>> dat.tm_isdst #Показывает, действует ли летнее время (0 - нет, 1 - да, -1 - нет данных)
|
||||
0
|
||||
```
|
||||
Текущее время с учетом часового пояса
|
||||
```py
|
||||
>>> here = time.localtime()
|
||||
>>> here
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=15, tm_min=44, tm_sec=59, tm_wday=6, tm_yday=285, tm_isdst=0)
|
||||
```
|
||||
Время из кортежа в строку
|
||||
```py
|
||||
>>> time.asctime(here)
|
||||
'Sun Oct 12 15:44:59 2025'
|
||||
```
|
||||
Время из секунд в строку
|
||||
```py
|
||||
>>> time.ctime()
|
||||
'Sun Oct 12 15:46:30 2025'
|
||||
```
|
||||
Пауза
|
||||
```py
|
||||
>>> time.sleep(5)
|
||||
```
|
||||
Из кортежа в секунды с начала эпохи
|
||||
```py
|
||||
>>> time.mktime(here)
|
||||
1760273099.0
|
||||
```
|
||||
## Пункт 7 Графические функции модуля pylab пакета matplotlib
|
||||
```py
|
||||
>>> 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()
|
||||
```
|
||||
Два графика на одном окне
|
||||
```py
|
||||
>>> X1=[12,6,8,10,7]
|
||||
>>> X2=[5,7,9,11,13]
|
||||
>>> pylab.plot(X1) #Создание графика в оперативной памяти
|
||||
[<matplotlib.lines.Line2D object at 0x000001905007A090>]
|
||||
>>> pylab.plot(X2)
|
||||
[<matplotlib.lines.Line2D object at 0x0000019050064D90>]
|
||||
>>> pylab.show()
|
||||
```
|
||||
|
||||
Круговая диаграмма:
|
||||
```py
|
||||
>>> region=['Центр','Урал','Сибирь','Юг']
|
||||
>>> naselen=[65,12,23,17]
|
||||
>>> pylab.pie(naselen,labels=region)
|
||||
([<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()
|
||||
```
|
||||
Гистограмма:
|
||||
```py
|
||||
>>> region=['Центр','Урал','Сибирь','Юг'] #Метки для диаграммы
|
||||
>>> naselen=[65,12,23,17] # Значения для диаграммы
|
||||
>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
|
||||
([<matplotlib.patches.Wedge object at 0x000001904BFBD350>, <matplotlib.patches.Wedge object at 0x000001904F822550>, <matplotlib.patches.Wedge object at 0x000001904F83E5D0>, <matplotlib.patches.Wedge object at 0x000001904F83FC50>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
|
||||
>>> pylab.show() #Отображение диаграммы
|
||||
```
|
||||
Столбиковая диаграмма:
|
||||
```py
|
||||
>>> a=['cat','dog','frog']
|
||||
>>> v=[10,55,100]
|
||||
>>> pylab.bar(a,v,color='purple')
|
||||
<BarContainer object of 3 artists>
|
||||
>>> pylab.show()
|
||||
```
|
||||
## Пункт 8
|
||||
|
||||
Статистический модуль statistics
|
||||
```py
|
||||
>>> import statistics
|
||||
>>> dir(statistics)
|
||||
['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_mean_stdev', '_normal_dist_inv_cdf', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'mul', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sys', 'tau', 'variance']
|
||||
```
|
||||
Математическое ожидание
|
||||
```py
|
||||
>>> data = [0,11,8,5]
|
||||
>>> statistics.mean(data)
|
||||
6
|
||||
```
|
||||
Медиана
|
||||
```py
|
||||
>>> statistics.median(data)
|
||||
6.5
|
||||
```
|
||||
Среднеквадратичное отклонение
|
||||
```py
|
||||
>>> statistics.stdev(data)
|
||||
4.69041575982343
|
||||
```
|
||||
Дисперсия
|
||||
```py
|
||||
>>> statistics.variance(data)
|
||||
22
|
||||
```
|
||||
Квантили
|
||||
```py
|
||||
>>> statistics.quantiles(data)
|
||||
[1.25, 6.5, 10.25]
|
||||
```
|
||||
59
TEMA4/o.md
59
TEMA4/o.md
@@ -1,59 +0,0 @@
|
||||
|
||||
|
||||
ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ
|
||||
|
||||
• Напишите и исполните единое выражение, реализующее последовательное выполнение
|
||||
следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата
|
||||
до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из
|
||||
двух значений: округленное вниз значение от деления результата на 3 и остатка от этого
|
||||
деления
|
||||
|
||||
>>> divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
|
||||
(8.0, 2.6000000000000014)
|
||||
|
||||
• Создайте объект класса struct_time с временными параметрами для текущего
|
||||
московского времени. Создайте строку с текущим часом и минутами.
|
||||
|
||||
>>> nowtime = time.localtime()
|
||||
>>> nowtime
|
||||
time.struct_time(tm_year=2024, tm_mon=9,
|
||||
tm_mday=30, 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
|
||||
'1 44'
|
||||
|
||||
• Создайте список с элементами – названиями дней недели. Сделайте случайную выборку
|
||||
из этого списка с тремя днями недели.
|
||||
|
||||
>>> week = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
|
||||
>>> random.sample(week, 3)
|
||||
['вторник', 'суббота', 'четверг']
|
||||
|
||||
• Напишите инструкцию случайного выбора числа из последовательности целых чисел от
|
||||
14 до 32 с шагом 3.
|
||||
|
||||
>>> random.choice(range(14, 32, 3))
|
||||
26
|
||||
>>> random.choice(range(14, 32, 3))
|
||||
14
|
||||
|
||||
• Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и
|
||||
стандартным отклонением 4 и округлите его до целого значения. Создайте список с N
|
||||
элементами – случайно выбранными буквами латинского алфавита.
|
||||
|
||||
>>> N = round(random.gauss(15,4))
|
||||
>>> N
|
||||
13
|
||||
>>> lst = list("abcdefghijgklmnopqrstuvwxyz")
|
||||
>>> random.sample(lst, N)
|
||||
['i', 'g', 'g', 'j', 't', 's', 'r', 'v', 'f', 'y', 'b', 'z', 'l']
|
||||
|
||||
Или в одну строку:
|
||||
>>> random.sample(list("abcdefghijgklmnopqrstuvwxyz"), round(random.gauss(15,4)))
|
||||
['l', 'u', 'z', 'g', 't', 'd', 'f', 'e', 'm', 'k']
|
||||
|
||||
• Напишите инструкцию для определения временного интервала в минутах, прошедшего с
|
||||
момента предыдущего (из п.2) определения временных параметров.
|
||||
|
||||
>>> (time.mktime(nowtime) - time.mktime(time.localtime())) / 60
|
||||
-27.216666666666665
|
||||
27
TEMA5/17.md
27
TEMA5/17.md
@@ -1,27 +0,0 @@
|
||||
17. Создайте список с 20 комплексными числами, у которых вещественная и мнимая части – слу-чайные, нормально распределенные числа с математическим ожиданием 15 и стандартным отклонением 8. Рассчитайте среднее значение фаз по элементам множества и отобразите ре-зультат с округлением до 2-х знаков после точки в виде строки вида: «Среднее фаз = ХХХ.ХХ».
|
||||
```py
|
||||
>>> import random
|
||||
>>> import math
|
||||
>>> import cmath
|
||||
# Создаем список с 20 комплексными числами
|
||||
>>> compl_n=[]
|
||||
>>> for _ in range(20):
|
||||
# Генерируем вещественную и мнимую части с нормальным распределением
|
||||
... p1=random.gauss(15,8) # мат. ожидание = 15, стандартное отклонение = 8
|
||||
... p2=random.gauss(15,8) # мат. ожидание = 15, стандартное отклонение = 8
|
||||
... c=complex(p1,p2)
|
||||
... compl_n.append(c)
|
||||
...
|
||||
# Рассчитываем фазы для каждого комплексного числа
|
||||
>>> phases=[]
|
||||
>>> for n in compl_n:
|
||||
... phase = cmath.phase(n)
|
||||
... phases.append(phase)
|
||||
...
|
||||
# Вычисляем среднее значение фаз
|
||||
>>> average_phase = sum(phases) / len(phases)
|
||||
#Округляем до 2-х знаков после точки
|
||||
>>> result = f"Среднее фаз = {average_phase:.2f}"
|
||||
>>> result
|
||||
'Среднее фаз = 0.92'
|
||||
```
|
||||
Двоичные данные
TEMA5/Figure_1.png
Двоичные данные
TEMA5/Figure_1.png
Двоичный файл не отображается.
|
До Ширина: | Высота: | Размер: 30 KiB |
Двоичные данные
TEMA5/Figure_2.png
Двоичные данные
TEMA5/Figure_2.png
Двоичный файл не отображается.
|
До Ширина: | Высота: | Размер: 18 KiB |
432
TEMA5/Lab5.md
432
TEMA5/Lab5.md
@@ -1,432 +0,0 @@
|
||||
### Отчет тема 5
|
||||
## Пункт 2. Изучите ветвление по условию – управляющая инструкция if.
|
||||
Общий вид выглядит так:
|
||||
|
||||
```py
|
||||
if <условие>:
|
||||
<отступы> <Блок инструкций, выполняемый, если условие истинно>
|
||||
[elif <условие2>:
|
||||
<отступы><Блок инструкций2, выполняемый, если условие2 истинно>
|
||||
]
|
||||
[else:
|
||||
< отступы><Блок инструкций3, выполняемый, если условие ложно>
|
||||
]
|
||||
```
|
||||
Причем elif и else вместе или по отдельности могут отсуствовать.
|
||||
|
||||
Пример
|
||||
```py
|
||||
>>> prog=4
|
||||
>>> rashod1 = 8
|
||||
>>> rashod2 = 5
|
||||
>>> if rashod1 >= prog:
|
||||
... dohod=12
|
||||
... elif rashod2==prog:
|
||||
... dohod=0
|
||||
... else:
|
||||
... dohod=8
|
||||
...
|
||||
>>> dohod
|
||||
12
|
||||
```
|
||||
Посмотрим другой цикл
|
||||
```py
|
||||
>>> rashod2 = 4
|
||||
>>> porog = 4
|
||||
>>> if rashod1>=3 and rashod2==4:
|
||||
... dohod=rashod1
|
||||
... if rashod2==porog or rashod1<rashod2:
|
||||
... dohod=porog
|
||||
...
|
||||
>>> dohod
|
||||
4
|
||||
```
|
||||
И ещё одна операция с множественным ветвлением линий потока:
|
||||
```py
|
||||
>>> if porog==3:
|
||||
... dohod=1
|
||||
... elif porog==4:
|
||||
... dohod=2
|
||||
... elif porog==5:
|
||||
... dohod=3
|
||||
... else:
|
||||
... dohod=0
|
||||
...
|
||||
>>> dohod
|
||||
2
|
||||
```
|
||||
Еще одна форма записи условных управляющих инструкций - тернарный оператор (от лат. "тройной"):
|
||||
<Объект> = <значение 1> if <условие> else <значение 2>
|
||||
или ещё:
|
||||
```py
|
||||
if <условие>: <инструкция1>[;<инструкция2>….]
|
||||
```
|
||||
```py
|
||||
>>> dohod=2 if porog>=4 else 0
|
||||
>>> dohod
|
||||
2
|
||||
```
|
||||
Эквивалент
|
||||
```py
|
||||
if porog >= 4:
|
||||
dohod = 2
|
||||
else:
|
||||
dohod = 0
|
||||
```
|
||||
Если в блоке инструкций всего одна строка, можно записать всё в одну строку:
|
||||
```py
|
||||
>>> porog = 2
|
||||
>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
|
||||
...
|
||||
>>> rashod1
|
||||
8
|
||||
>>> rashod2
|
||||
4
|
||||
```
|
||||
Тк условие не было выполнено рассмотрим другой пример
|
||||
```py
|
||||
>>> porog = 7
|
||||
>>> if porog >= 5 : rashod1 = 6; rashod2 = 0
|
||||
...
|
||||
>>> rashod1
|
||||
6
|
||||
>>> rashod2
|
||||
0
|
||||
```
|
||||
## Пункт 3. Цикл по перечислению (for)
|
||||
|
||||
Общее правило написания:
|
||||
```py
|
||||
for <Объект-переменная цикла> in <объект>:
|
||||
<отступы><Блок инструкций 1 – тело цикла>
|
||||
[else:
|
||||
< отступы ><Блок инструкций 2 – если в цикле не сработал break>]
|
||||
```
|
||||
Здесь <объект> - любой определенный до начала цикла объект из классов строка, список, кортеж, множество, словарь. <Объект-переменная цикла> - объект, в качестве значений которого пооче-редно будут задаваться элементы объекта, которые могут быть объектами любого типа. <Блок инструкций 1 – тело цикла> - совокупность инструкций, которая может содержать или не содер-жать инструкцию break, вызывающую досрочное завершение цикла при некоторых условиях. Блок инструкций 1 обычно выполняется многократно по мере того, как объект-переменная цикла принимает значения из сложного объекта. Если в цикле имеется необязательная часть: else и Блок инструкций 2, то он будет выполняться перед завершением цикла только в том случае, если при выполнении цикла не было его прерывания по инструкции break.
|
||||
Если Блоке инструкций 1 или в Блоке инструкций 2 только одна инструкция, то её можно запи-сывать без отступов сразу за двоеточием.
|
||||
|
||||
## 3.1. Простой цикл.
|
||||
```py
|
||||
>>> temperatura=5
|
||||
>>> for i in range(3,18,3):
|
||||
... temperatura+=i
|
||||
...
|
||||
>>> temperatura
|
||||
50
|
||||
```
|
||||
## 3.2. Более сложный цикл
|
||||
```py
|
||||
>>> 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 (это можно понять не только по
|
||||
смыслу, но и по табуляции)
|
||||
|
||||
Рассмотрим другой вариант:
|
||||
```py
|
||||
>>> 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, и список, изменяющийся внутри цикла - это объекты,
|
||||
имеющие разные адреса. Это можно проверить:
|
||||
```py
|
||||
>>> id(sps)
|
||||
1684034116672
|
||||
>>> id(sps[:])
|
||||
1684069134400
|
||||
```
|
||||
|
||||
## Пункт 3.3
|
||||
```py
|
||||
>>> sps5=[]
|
||||
>>> for i in range(10):
|
||||
... sps5.append(rn.randint(1,100))
|
||||
... ss=sum(sps5)
|
||||
... if ss>500: break
|
||||
... else:
|
||||
... print(ss)
|
||||
...
|
||||
```
|
||||
Программа ничего не вывела. Посмотрим, почему именно:
|
||||
```py
|
||||
>>> sps5
|
||||
[89, 38, 86, 57, 21, 44, 43, 32, 13, 88]
|
||||
>>> ss
|
||||
511
|
||||
>>> sps5 = []
|
||||
>>> for i in range(10):
|
||||
... sps5.append(rn.randint(1,100))
|
||||
... ss = sum(sps5)
|
||||
... else:
|
||||
... print(ss)
|
||||
...
|
||||
517
|
||||
>>> sps5
|
||||
[11, 75, 48, 46, 3, 67, 78, 92, 63, 34]
|
||||
```
|
||||
В этот раз программа вывела ответ самостоятельно, потому что сработал else, потому что
|
||||
за все десять итераций цикла так и не успел выполниться break по условию if.
|
||||
|
||||
## Пункт 3.4. Пример с символьной строкой
|
||||
```py
|
||||
>>> stroka='Это - автоматизированная система'
|
||||
>>> stroka1=""
|
||||
>>> for ss in stroka:
|
||||
... stroka1+=" "+ss
|
||||
...
|
||||
>>> stroka
|
||||
'Это - автоматизированная система'
|
||||
>>> stroka1
|
||||
' Э т о - а в т о м а т и з и р о в а н н а я с и с т е м а'
|
||||
```
|
||||
Переменная ss проходит по всему строковому объекту, на каждой итерации принимая значение
|
||||
одного знака. Этот знак с предшествующим пробелом дописывается в конец другой, изначально
|
||||
пустой строки. Цикл закончится, когда закончится исходная строка.
|
||||
|
||||
## 3.5. Запись цикла в строке. Пример: создание списка с синусоидальным сигналом.
|
||||
```py
|
||||
>>> 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]
|
||||
```
|
||||
|
||||
Эту синусоиду можно отобразить на графике:
|
||||
```py
|
||||
>>> import pylab
|
||||
>>> pylab.plot(sps2, label='Синусоидальный сигнал', color = 'green')
|
||||
[<matplotlib.lines.Line2D object at 0x000002B914A005D0>]
|
||||
>>> pylab.show()
|
||||
```
|
||||
График прикреплен отдельным файлом Figure_1.png
|
||||
|
||||
|
||||
|
||||
## Пункт 4. Цикл "пока истинно условие" (while)
|
||||
|
||||
Общий вид:
|
||||
```py
|
||||
while <Условие>:
|
||||
<отступы><Блок инструкций 1 – тело цикла>
|
||||
[else:
|
||||
<отступы><Блок инструкций 2 – если в цикле не сработал break>]
|
||||
```
|
||||
break и else работают аналогично предыдущему случаю.
|
||||
## 4.1. Цикл со счетчиком.
|
||||
```py
|
||||
>>> rashod=300
|
||||
>>> while rashod:
|
||||
... print("Расход=",rashod)
|
||||
... rashod-=50
|
||||
...
|
||||
Расход= 300
|
||||
Расход= 250
|
||||
Расход= 200
|
||||
Расход= 150
|
||||
Расход= 100
|
||||
Расход= 50
|
||||
```
|
||||
Как именно произошло завершение цикла? Нужно вспомнить, что все числа, кроме нуля, при
|
||||
конвертации в логический тип данных имеют логическое значение True:
|
||||
```py
|
||||
>>> bool(50)
|
||||
True
|
||||
```
|
||||
|
||||
И только нуль имеет значение False:
|
||||
```py
|
||||
>>> bool(0)
|
||||
False
|
||||
```
|
||||
Сравниваемая в управляющей инструкции переменная уменьшается в самом цикле, поэтому, когда
|
||||
строка со сравнением обнаружит 0, то воспримет это как False, и действия по выводу
|
||||
и уменьшению числа выполняться больше не будут.
|
||||
## Пункт 4.2. Пример с символьной строкой
|
||||
```py
|
||||
>>> import math
|
||||
>>> stroka='Расчет процесса в объекте регулирования'
|
||||
>>> i=0
|
||||
>>> sps2=[]
|
||||
>>> while i<len(stroka):
|
||||
... r=1-2/(1+math.exp(0.1*i))
|
||||
... sps2.append(r)
|
||||
... print('Значение в момент',i,"=",r)
|
||||
... i+=1
|
||||
...
|
||||
Значение в момент 0 = 0.0
|
||||
Значение в момент 1 = 0.049958374957880025
|
||||
Значение в момент 2 = 0.09966799462495568
|
||||
Значение в момент 3 = 0.14888503362331795
|
||||
Значение в момент 4 = 0.197375320224904
|
||||
Значение в момент 5 = 0.2449186624037092
|
||||
Значение в момент 6 = 0.2913126124515909
|
||||
Значение в момент 7 = 0.3363755443363322
|
||||
Значение в момент 8 = 0.3799489622552249
|
||||
Значение в момент 9 = 0.421899005250008
|
||||
Значение в момент 10 = 0.4621171572600098
|
||||
Значение в момент 11 = 0.5005202111902354
|
||||
Значение в момент 12 = 0.5370495669980353
|
||||
Значение в момент 13 = 0.5716699660851172
|
||||
Значение в момент 14 = 0.6043677771171636
|
||||
Значение в момент 15 = 0.6351489523872873
|
||||
Значение в момент 16 = 0.6640367702678489
|
||||
Значение в момент 17 = 0.6910694698329307
|
||||
Значение в момент 18 = 0.7162978701990245
|
||||
Значение в момент 19 = 0.7397830512740043
|
||||
Значение в момент 20 = 0.7615941559557649
|
||||
Значение в момент 21 = 0.7818063576087741
|
||||
Значение в момент 22 = 0.8004990217606297
|
||||
Значение в момент 23 = 0.8177540779702878
|
||||
Значение в момент 24 = 0.8336546070121553
|
||||
Значение в момент 25 = 0.8482836399575129
|
||||
Значение в момент 26 = 0.8617231593133063
|
||||
Значение в момент 27 = 0.874053287886007
|
||||
Значение в момент 28 = 0.8853516482022625
|
||||
Значение в момент 29 = 0.8956928738431645
|
||||
Значение в момент 30 = 0.9051482536448664
|
||||
Значение в момент 31 = 0.9137854901178277
|
||||
Значение в момент 32 = 0.9216685544064713
|
||||
Значение в момент 33 = 0.9288576214547277
|
||||
Значение в момент 34 = 0.935409070603099
|
||||
Значение в момент 35 = 0.9413755384972874
|
||||
Значение в момент 36 = 0.9468060128462683
|
||||
Значение в момент 37 = 0.9517459571646616
|
||||
Значение в момент 38 = 0.9562374581277391
|
||||
```
|
||||
У цикла 38 повторений, по числу элементов в строке, но на 1 меньше. На каждой итерации
|
||||
значение i на единицу меньше, чем в предыдущей.
|
||||
```py
|
||||
>>> pylab.plot(sps2, label='Сигнал выхода', color='red')
|
||||
[<matplotlib.lines.Line2D object at 0x000002B9191077D0>]
|
||||
>>> pylab.title("Сигнал на выходе инерционного звена")
|
||||
Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
|
||||
>>> pylab.show()
|
||||
```
|
||||
|
||||
График прикреплен файлом Figure_2.png
|
||||
## Пункт 4.3. Определение, является ли число простым (делится только на самого себя или 1).
|
||||
```py
|
||||
>>> 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.
|
||||
```py
|
||||
>>> 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.
|
||||
|
||||
Она используется, когда надо при определенном условии не завершить весь цикл, а завершить
|
||||
только текущую итерацию.
|
||||
|
||||
Пример (вывести только нечетные числа):
|
||||
```py
|
||||
>>> n=[1,2,3,4,5,6,7,8,9,10]
|
||||
>>> for k in n:
|
||||
... if k%2==0:
|
||||
... continue
|
||||
... print(k)
|
||||
...
|
||||
1
|
||||
3
|
||||
5
|
||||
7
|
||||
9
|
||||
```
|
||||
|
||||
102
TEMA5/task.md
102
TEMA5/task.md
@@ -1,102 +0,0 @@
|
||||
|
||||
### ОБЩЕЕ КОНТРОЛЬНОЕ ЗАДАНИЕ
|
||||
|
||||
• Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи)
|
||||
определите порядковый номер каждой буквы в английском алфавите.
|
||||
```py
|
||||
>>> 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 порядковый номер в алфавите
|
||||
```
|
||||
• Создайте список со словами из задания данного пункта. Для этого списка – определите,
|
||||
есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о
|
||||
нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с
|
||||
отсутствующим словом).
|
||||
```py
|
||||
>>> 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("Слова нет")
|
||||
|
||||
Слова нет
|
||||
```
|
||||
|
||||
• Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в
|
||||
летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных
|
||||
списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции,
|
||||
позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние
|
||||
баллы по двум сессиям.
|
||||
```py
|
||||
>>> studs = ["Snegura", "Turov", "Zelenkina1", "Zelenkina2"]
|
||||
>>> summer_marks = [4.75, 4.13, 4.24, 4.32]
|
||||
>>> studs2 = ["Zelenkina1", "Turov", "Zelenkina2", "Snegura"]
|
||||
>>> winter_marks = [4.3, 4.23, 4.16, 4.82]
|
||||
|
||||
>>> student = input("Введите фамилию: ")
|
||||
Введите фамилию: Zelenkina2
|
||||
>>> 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.32
|
||||
Зимой: 4.16
|
||||
Средний : 4.24
|
||||
Введите фамилию (q для выхода): Snegura
|
||||
Балл летом: 4.75
|
||||
Зимой: 4.82
|
||||
Средний : 4.78
|
||||
Введите фамилию (q для выхода): Tsvetkova
|
||||
Такого студента нет
|
||||
Введите фамилию (q для выхода): q
|
||||
```
|
||||
|
||||
|
||||
90
TEMA6/7.md
90
TEMA6/7.md
@@ -1,90 +0,0 @@
|
||||
1) С помощью текстового редактора создайте текстовый файл с некоторым именем, в котором будет 4 строки и на каждой строке будет по 3 числа, разделенных запятыми.
|
||||
```py
|
||||
>>> import os
|
||||
>>> os.getcwd()
|
||||
'C:\\WINDOWS\\System32'
|
||||
>>> os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6')
|
||||
>>> f = 'data.txt'
|
||||
>>> fp = open(f, 'w')
|
||||
>>> fp.write("1, 2, 3\n")
|
||||
8
|
||||
>>> fp.write("4, 5, 6\n")
|
||||
8
|
||||
>>> fp.write("7, 8, 9\n")
|
||||
8
|
||||
>>> fp.close()
|
||||
>>> fp = open(f, 'r')
|
||||
>>> sod = fp.read()
|
||||
>>> fp.close()
|
||||
>>> print('Содержание лабы:')
|
||||
Содержание лабы:
|
||||
>>> print(sod)
|
||||
1, 2, 3
|
||||
4, 5, 6
|
||||
7, 8, 9
|
||||
```
|
||||
|
||||
2) Запросите у пользователя и введите имя файла с данными для обработки. Обеспечьте вывод сообщения при вводе пустой строки и повторный ввод.
|
||||
```py
|
||||
>>> while True:
|
||||
... f = input("Введите имя файла с данными для обработки: ")
|
||||
... f_cl = f.strip() # Убираем пробелы в начале и конце строки
|
||||
... if f_c != "":
|
||||
... f = f_c
|
||||
... break
|
||||
... print("Ошибка: введена пустая строка. Повторите ввод.")
|
||||
...
|
||||
Введите имя файла с данными для обработки:
|
||||
Ошибка: введена пустая строка. Повторите ввод.
|
||||
Введите имя файла с данными для обработки: data.txt
|
||||
>>> print(f)
|
||||
data.txt
|
||||
```
|
||||
3) Введите данные из указанного файла и представьте их в виде списка.
|
||||
```py
|
||||
>>> f='data.txt'
|
||||
>>> numbers = []
|
||||
>>> fp = open(f, 'r')
|
||||
SyntaxError: invalid syntax
|
||||
>>> for line in fp:
|
||||
... for num_str in line.strip().split(','): #убираем пробелы, разбиваем по запятым
|
||||
... numbers.append(float(num_str))
|
||||
...
|
||||
>>> fp.close()
|
||||
>>> print(numbers)
|
||||
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
|
||||
```
|
||||
|
||||
4) Рассчитайте по введенным данным среднее значение синусов элементов списка.
|
||||
```py
|
||||
>>> import math
|
||||
>>> s=[]
|
||||
>>> for number in numbers:
|
||||
... ss=math.sin(number)
|
||||
... s.append(ss)
|
||||
... print(number)
|
||||
...
|
||||
1.0
|
||||
2.0
|
||||
3.0
|
||||
4.0
|
||||
5.0
|
||||
6.0
|
||||
7.0
|
||||
8.0
|
||||
9.0
|
||||
>>> sum_s=sum(s)
|
||||
>>> sum_s
|
||||
1.9552094821073802
|
||||
>>> count_s=len(s)
|
||||
>>> count_s
|
||||
9
|
||||
>>> sr=sum_s/count_s
|
||||
>>> sr
|
||||
0.21724549801193113
|
||||
```
|
||||
5) Выведите рассчитанное значение на экран по шаблону: " По <число элементов в списке> элементам среднее синусов = <рассчитанное среднее>". При этом значение среднего должно быть округлено до двух знаков после точки.
|
||||
```py
|
||||
>>> print("По", count_s, "элементам среднее синусов =", round(sr, 2))
|
||||
```
|
||||
По 9 элементам среднее синусов = 0.22
|
||||
135
TEMA6/lab6.md
135
TEMA6/lab6.md
@@ -1,135 +0,0 @@
|
||||
# Пункт 2. Вывод данных на экран дисплея.
|
||||
##Пункт 2.1. Вывод данных в командной строке.
|
||||
|
||||
Эхо-вывод в терминал (не работает в файлах!)
|
||||
>>> stroka='Автоматизированная система управления'
|
||||
>>> stroka
|
||||
'Автоматизированная система управления'
|
||||
##Пункт 2.2 Вывод с использованием функции print
|
||||
>>> fff=234.5;gg='Значение температуры = '
|
||||
>>> print(gg, fff)
|
||||
Значение температуры = 234.5
|
||||
По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разде-литель его можно указать в отдельном аргументе sep, например,
|
||||
>>> print(gg, fff, sep='/')
|
||||
Значение температуры = /234.5
|
||||
После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например,
|
||||
|
||||
>>> print(gg, fff,sep='/',end='***'); print('____')
|
||||
Значение температуры = /234.5***____
|
||||
|
||||
После end= надо указать какими символами должна закончиться выводимая строка или ука-зать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую стро-ку, можно использовать такое обращение к функции:
|
||||
|
||||
>>> print()
|
||||
|
||||
Если текст большой, можно расположить его в несколько строк с использованием тройных кавычек
|
||||
>>> print(""" Здесь может выводиться
|
||||
... большой текст,
|
||||
... занимающий несколько строк""")
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
|
||||
Или переносить отдельные объекты, разделенные запятой:
|
||||
|
||||
>>> print("Здесь может выводиться",
|
||||
... "большой текст,",
|
||||
... "занимающий несколько строк")
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
|
||||
Разница в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был
|
||||
введен. В тексте были введены переносы строки, но они были введены не как символ \n, а
|
||||
в обычном человекопонятном виде. Тем не менее, при желании на них можно посмотреть:
|
||||
|
||||
>> print(repr(""" Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк"""))
|
||||
' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
|
||||
|
||||
(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
|
||||
табуляции)
|
||||
Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как
|
||||
обычный print(), разделяющий объекты с помощью пробелов, если не указано иное.
|
||||
|
||||
## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
|
||||
>>> import sys
|
||||
>>> 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. Ввод данных с клавиатуры.
|
||||
>>> psw=input('Введите пароль:')
|
||||
Введите пароль:sewfx
|
||||
>>> psw
|
||||
'sewfx'
|
||||
>>> type(psw)
|
||||
<class 'str'>
|
||||
|
||||
input() не воспринимает символы табуляции, считывая их как обычные строки. Более того, возможно
|
||||
такое:
|
||||
|
||||
>>> input()
|
||||
dpdpdp\n
|
||||
'dpdpdp\\n'
|
||||
|
||||
Так происходит из-за того, что input() считал все символы как символы, то есть "p", "d", ... "\",
|
||||
"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
|
||||
"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
|
||||
python'у воспринять его как символ табуляции.
|
||||
|
||||
|
||||
>>> while True:
|
||||
... znach=float(input('Задайте коэф. усиления= '))
|
||||
... if znach<17.5 or znach>23.8:
|
||||
... print('Ошибка!')
|
||||
... else:
|
||||
... break
|
||||
...
|
||||
Задайте коэф. усиления= 16
|
||||
Ошибка!
|
||||
Задайте коэф. усиления= 26.7
|
||||
Ошибка!
|
||||
Задайте коэф. усиления= 20
|
||||
|
||||
|
||||
>>> import math
|
||||
>>> print(eval(input('введите выражение для расчета=')))
|
||||
введите выражение для расчета=math.log10(23/(1+math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
|
||||
Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(),
|
||||
они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий
|
||||
результату вычислений и задаваемый автоматически:
|
||||
>>> type(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = 2+3
|
||||
<class 'int'>
|
||||
|
||||
>>> type(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||
<class 'float'>
|
||||
|
||||
# Пункт 4. Ввод-вывод при работе с файлами.
|
||||
## Пункт 4.1. Функции для работы с путём к файлу.
|
||||
|
||||
>>> import os
|
||||
>>> os.getcwd()
|
||||
'C:\\WINDOWS\\System32'
|
||||
624
TEMA6/laba5.md
624
TEMA6/laba5.md
@@ -1,624 +0,0 @@
|
||||
# Пункт 2. Вывод данных на экран дисплея.
|
||||
## Пункт 2.1. Вывод данных в командной строке.
|
||||
|
||||
Эхо-вывод в терминал (не работает в файлах!)
|
||||
```py
|
||||
>>> stroka='Автоматизированная система управления'
|
||||
>>> stroka
|
||||
'Автоматизированная система управления'
|
||||
```
|
||||
# Пункт 2.2 Вывод с использованием функции print
|
||||
```py
|
||||
>>> fff=234.5;gg='Значение температуры = '
|
||||
>>> print(gg, fff)
|
||||
Значение температуры = 234.5
|
||||
```
|
||||
По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разде-литель его можно указать в отдельном аргументе sep, например,
|
||||
```py
|
||||
>>> print(gg, fff, sep='/')
|
||||
Значение температуры = /234.5
|
||||
```
|
||||
После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например,
|
||||
```py
|
||||
>>> print(gg, fff,sep='/',end='***'); print('____')
|
||||
Значение температуры = /234.5***____
|
||||
```
|
||||
После end= надо указать какими символами должна закончиться выводимая строка или ука-зать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую стро-ку, можно использовать такое обращение к функции:
|
||||
```py
|
||||
>>> print()
|
||||
```
|
||||
Если текст большой, можно расположить его в несколько строк с использованием тройных кавычек
|
||||
```py
|
||||
>>> print(""" Здесь может выводиться
|
||||
... большой текст,
|
||||
... занимающий несколько строк""")
|
||||
Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк
|
||||
```
|
||||
Или переносить отдельные объекты, разделенные запятой:
|
||||
```py
|
||||
>>> print("Здесь может выводиться",
|
||||
... "большой текст,",
|
||||
... "занимающий несколько строк")
|
||||
Здесь может выводиться большой текст, занимающий несколько строк
|
||||
```
|
||||
Разница в том, что в первом случае тройные кавычки воспроизводят текст ровно так, как он был
|
||||
введен. В тексте были введены переносы строки, но они были введены не как символ \n, а
|
||||
в обычном человекопонятном виде. Тем не менее, при желании на них можно посмотреть:
|
||||
```py
|
||||
>> print(repr(""" Здесь может выводиться
|
||||
большой текст,
|
||||
занимающий несколько строк"""))
|
||||
' Здесь может выводиться\nбольшой текст,\nзанимающий несколько строк'
|
||||
```
|
||||
(Функция repr() показывает то, как объект видит python, а не человек, отображая все символы
|
||||
табуляции)
|
||||
Во втором случае три выводимых объекта-строки перечисленны через запятую, и это работает как
|
||||
обычный print(), разделяющий объекты с помощью пробелов, если не указано иное.
|
||||
|
||||
## Пункт 2.3. Вывод с использованием write объекта stdout (поток стандартного вывода) модуля sys.
|
||||
```py
|
||||
>>> import sys
|
||||
>>> sys.stdout.write('Функция write')
|
||||
Функция write13
|
||||
>>> sys.stdout.write('Функция write\n')
|
||||
Функция write
|
||||
14
|
||||
```
|
||||
Важно отметить, что функция выводит текст, но возвращает число. Это число - количество
|
||||
введенных символов, причем \n считается за один символ, а не за два.
|
||||
```py
|
||||
>>> type(sys.stdout.write("Функция write"))
|
||||
Функция write<class 'int'>
|
||||
```
|
||||
Если вызвать эту функцию без аргументов, вернется ошибка:
|
||||
```py
|
||||
>>> sys.stdout.write()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
TypeError: write() missing 1 required positional argument: 's'
|
||||
```
|
||||
Если сообщить пустую строку, то, соответственно, 0.
|
||||
```py
|
||||
>>> sys.stdout.write("")
|
||||
0
|
||||
```
|
||||
## Пункт 3. Ввод данных с клавиатуры.
|
||||
```py
|
||||
>>> psw=input('Введите пароль:')
|
||||
Введите пароль:sewfx
|
||||
>>> psw
|
||||
'sewfx'
|
||||
>>> type(psw)
|
||||
<class 'str'>
|
||||
```
|
||||
input() не воспринимает символы табуляции, считывая их как обычные строки. Более того, возможно
|
||||
такое:
|
||||
```py
|
||||
>>> input()
|
||||
dpdpdp\n
|
||||
'dpdpdp\\n'
|
||||
```
|
||||
Так происходит из-за того, что input() считал все символы как символы, то есть "p", "d", ... "\",
|
||||
"n". Но при выводе в консоль внутри самой функции input() используется вышеупомянутое
|
||||
"техническое" отображение repr(). Оно всегда дублирует ("экранирует") бэкслеш, чтобы не дать
|
||||
python'у воспринять его как символ табуляции.
|
||||
|
||||
```py
|
||||
>>> while True:
|
||||
... znach=float(input('Задайте коэф. усиления= '))
|
||||
... if znach<17.5 or znach>23.8:
|
||||
... print('Ошибка!')
|
||||
... else:
|
||||
... break
|
||||
...
|
||||
Задайте коэф. усиления= 16
|
||||
Ошибка!
|
||||
Задайте коэф. усиления= 26.7
|
||||
Ошибка!
|
||||
Задайте коэф. усиления= 20
|
||||
```
|
||||
```py
|
||||
>>> import math
|
||||
>>> print(eval(input('введите выражение для расчета=')))
|
||||
введите выражение для расчета=math.log10(23/(1+math.exp(-3.24)))
|
||||
1.34504378689765
|
||||
```
|
||||
Введенная через input() строка преобразуется в исполнительные инструкции с помощью eval(),
|
||||
они потом выполняются и результат выводится на экран. Строка имеет тип, соответствующий
|
||||
результату вычислений и задаваемый автоматически:
|
||||
```py
|
||||
>>> type(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = 2+3
|
||||
<class 'int'>
|
||||
```
|
||||
```py
|
||||
>>> type(eval(input('введите выражение для расчета = ')))
|
||||
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||
<class 'float'>
|
||||
```
|
||||
# Пункт 4. Ввод-вывод при работе с файлами.
|
||||
## Пункт 4.1. Функции для работы с путём к файлу.
|
||||
```py
|
||||
>>> import os
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6'
|
||||
>>> tsvetkova=os.getcwd()
|
||||
>>> print(tsvetkova)
|
||||
C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA6
|
||||
>>> print(type(tsvetkova))
|
||||
<class 'str'>
|
||||
```
|
||||
По умолчанию:
|
||||
```py
|
||||
>>> import os
|
||||
>>> os.getcwd()
|
||||
'C:\\WINDOWS\\System32'
|
||||
```
|
||||
Сменим директорию и посмотрим, что смена произошла:
|
||||
```py
|
||||
>>> os.chdir(r'C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA1')
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA1'
|
||||
```
|
||||
Сменим директорию на верную:
|
||||
```py
|
||||
os.chdir(r'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6')
|
||||
```
|
||||
познкомимся с другими командами модуля os
|
||||
```py
|
||||
>>>help(os.mkdir)
|
||||
Help on built-in function mkdir in module nt:
|
||||
|
||||
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. Where it is used, the current umask
|
||||
value is first masked out.
|
||||
```
|
||||
Создание каталога (mkdir)
|
||||
```py
|
||||
>>> os.mkdir('lalala')
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6'
|
||||
>>> os.listdir()
|
||||
['.gitkeep', 'lab5.txt', 'lalala']
|
||||
```
|
||||
удаление папки
|
||||
```py
|
||||
>>> 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.
|
||||
```
|
||||
```py
|
||||
>>> os.rmdir('lalala')
|
||||
>>> os.listdir()
|
||||
['.gitkeep', 'lab5.txt']
|
||||
```py
|
||||
Одако, если мы будем находиться в самой папке, которую хотим удалить, то у нас это не получится и питон выведет ошибку. Чтобы это исправить необходимо сменить путь и выйти из папки. Можно использовать команду
|
||||
```py
|
||||
os.chdir('../') # Поднимает нас на одну папку выше. ../../ - для двух папок и т.д.
|
||||
```
|
||||
Просмотр списка директории
|
||||
```py
|
||||
>>> os.listdir()
|
||||
['.gitkeep', 'lab5.txt']
|
||||
```
|
||||
Проверка существования каталога
|
||||
```py
|
||||
>>> 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 в противном случае.
|
||||
```py
|
||||
>>> os.path.isdir('gagagaga')
|
||||
False
|
||||
>>> os.mkdir('lalala')
|
||||
>>> os.path.isdir('lalala')
|
||||
True
|
||||
```
|
||||
Функция os.path.abspath() в Python преобразует путь, переданный в качестве аргумента, в
|
||||
абсолютный путь
|
||||
```py
|
||||
>>> fil=os.path.abspath("oplata.dbf")
|
||||
>>> fil
|
||||
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\oplata.dbf'
|
||||
>>> fil=os.path.abspath("lalala")
|
||||
>>> fil
|
||||
'C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\lalala'
|
||||
```
|
||||
Абсолютный путь — это полный путь к файлу или каталогу, начиная от
|
||||
корневого каталога системы, а не относительный путь (который зависит от текущего рабочего
|
||||
каталога)
|
||||
|
||||
Если передать в os.path.abspath() несуществующий файл или каталог, функция не проверяет
|
||||
наличие этого файла в файловой системе. Она просто преобразует путь в абсолютный, не
|
||||
проверяя его существование.
|
||||
|
||||
Отделение из абсолютного пути только каталога/только имени файла
|
||||
Функция os.path.dirname() из абсолютного пути выделяется путь доступа (от диска до последней
|
||||
папки). Функция os.path.basename(), наоборот, убирает из абсолютного пути все, кроме имени
|
||||
файла.
|
||||
|
||||
Выделите путь доступа к файлу из строки, содержащей и этот путь, и имя файла с помощью функции os.path.dirname
|
||||
```py
|
||||
>>> drkt = os.path.dirname(fil)
|
||||
>>> print(drkt)
|
||||
C:\Users\Admin\Documents\Tsvetkova\python-labs\TEMA6
|
||||
```
|
||||
Bыделить имя файла из этой строки с отбрасыванием пути можно с помощью функции os.path.basename
|
||||
```py
|
||||
>>> bsnm=os.path.basename(fil)
|
||||
>>> print(bsnm)
|
||||
lalala
|
||||
```
|
||||
Разделение на кортеж из пути и из имени файла
|
||||
```py
|
||||
>>> help(os.path.split)
|
||||
Help on function split in module ntpath:
|
||||
|
||||
split(p)
|
||||
Split a pathname.
|
||||
|
||||
Return tuple (head, tail) where tail is everything after the final slash.
|
||||
Either part may be empty.
|
||||
```
|
||||
```py
|
||||
>>> os.path.split(fil)
|
||||
('C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6', 'lalala')
|
||||
>>> type(os.path.split(fil))
|
||||
<class 'tuple'>
|
||||
```
|
||||
Проверка существования любого объекта (пути или файла)
|
||||
```py
|
||||
>>> os.path.exists("D:/GAMES") # Такой каталог есть на ПК
|
||||
True
|
||||
>>> os.path.exists("D:/Arts")
|
||||
False
|
||||
>>> os.path.exists("D:/Games/Heavy Rain/unins000.exe") # Такой файл есть
|
||||
True
|
||||
>>> os.path.exists("D:/Games/Heavy Rain/unins00000.exe")
|
||||
False
|
||||
>>> os.path.isfile("D:/Games/Sid Meiers Civilization VI/unins000.exe") # Это есть и это файл
|
||||
True
|
||||
>>> os.path.isfile("D:/Games/Sid Meiers Civilization VI/") # Это есть, но это не файл!
|
||||
False
|
||||
>>> os.path.isfile("D:/Games/sss.jpg") # Это файл, но это не существует
|
||||
False
|
||||
```
|
||||
## Пункт 4.2 Общая схема работы с файлом
|
||||
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||
• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||
• Выполнение одной или нескольких операций обмена данными с файлом;
|
||||
• Закрытие файла.
|
||||
|
||||
4.3. Открытие файла для записи или чтения данных – функция open.
|
||||
При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция open. Запросите помощь по этой функ-ции, обратите внимание на возможные аргументы этой функции.
|
||||
```py
|
||||
>>> fp = open(file = drkt+'\\zapis1.txt', mode='w')
|
||||
>>> type(fp)
|
||||
<class '_io.TextIOWrapper'>
|
||||
```
|
||||
Объект класса _io.TextIOWrapper - файловый объект для текстовых данных, имеющий ряд атрибутов
|
||||
и методов.
|
||||
```py
|
||||
>>> fp
|
||||
<_io.TextIOWrapper name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
|
||||
```
|
||||
Здесь перечислены атрибуты объекта:
|
||||
name - абсолютный путь
|
||||
mode - режим:
|
||||
r - чтение
|
||||
w - запись (если такой файл уже есть, его содержимое будет удалено, если нет,
|
||||
создается. Содержимое удаляется в момент открытия, а не в момент первой
|
||||
записи)
|
||||
a - дозапись (в конец)
|
||||
x - открывает для записи, но только если файл есть, иначе FileExistsError.
|
||||
+ - чтение и запись:
|
||||
r+ - чтение и запись, файл должен существовать.
|
||||
w+ - запись и чтение, файл создаётся или перезаписывается.
|
||||
a+ - добавление и чтение, файл создаётся, если не существует.
|
||||
|
||||
rb, wb, ab, xb - все то же, но в бинарном режиме (читаются байты)
|
||||
|
||||
encoding - кодировка:
|
||||
В Windows в консоли по умолчанию cp1251 или cp1252 в зависимости от языка системы.
|
||||
В файлах чаще UTF-8
|
||||
Linux, MacOS - UTF-8.
|
||||
Еще есть атрибут-флаг closed: True, если файл закрыт, False, если открыт.
|
||||
```py
|
||||
>>> fp.closed
|
||||
False
|
||||
```
|
||||
Если имя файла на первом месте, а режим на втором, то имена можно не указывать. (позиционные аргументы
|
||||
всегда должны идти первыми, а именованные — после них)
|
||||
|
||||
Путь можно опустить, если он совпадает с текущей рабочей директории:
|
||||
```py
|
||||
>>> fp = open('zapis1.txt','w')
|
||||
>>> fp
|
||||
<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='cp1251'>
|
||||
```
|
||||
Список атрибутов объекта fp:
|
||||
```py
|
||||
>>> 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']
|
||||
```
|
||||
Пример открытия бинарного файла:
|
||||
```py
|
||||
>>> fp1 = open(drkt + '\\zapis2.bin', mode = 'wb+')
|
||||
>>> fp1
|
||||
<_io.BufferedRandom name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis2.bin'>
|
||||
```
|
||||
## Пункт 4.4. Закрытие файла.
|
||||
Когда файл успешно открывается / создается и открывается, ему задается целочисленный
|
||||
номер, называемый файловым дескриптором. Он создается только на один сеанс работы и указывает,
|
||||
с каким именно файлом нужно работать.
|
||||
|
||||
После того, как программа отработала, надо очистить ресурсы, связанные с файлом (область
|
||||
в оперативной памяти, в буфере при буферизации), и удалить дескриптор. Если не закрыть
|
||||
файл, это может его повредить, данные могут быть утеряны или система может быть перегружена,
|
||||
т.к. исчерпается ресурс оперативной памяти. Для закрытия есть метод close().
|
||||
|
||||
После закрытия на объект все еще можно посмотреть:
|
||||
```py
|
||||
>>> fp.close()
|
||||
>>> fp
|
||||
<_io.TextIOWrapper name='C:\\Users\\Admin\\Documents\\Tsvetkova\\python-labs\\TEMA6\\zapis1.txt' mode='w' encoding='cp1251'>
|
||||
```
|
||||
Но значение атрибута closed сменится на True:
|
||||
```py
|
||||
>>> fp.closed
|
||||
True
|
||||
```
|
||||
|
||||
## 4.5. Запись информации в файл с помощью метода write.
|
||||
Пример 1
|
||||
```py
|
||||
>>> sps=list(range(1,13))
|
||||
>>> fp2=open('zapis3.txt','w')
|
||||
>>> fp2.write(str(sps[:4])+'\n')
|
||||
13
|
||||
>>> fp2.write(str(sps[4:8])+'\n')
|
||||
13
|
||||
>>> fp2.write(str(sps[8:])+'\n')
|
||||
16
|
||||
>>> fp2.close()
|
||||
```
|
||||
открыли файл и увидели
|
||||
```py
|
||||
[1, 2, 3, 4]
|
||||
[5, 6, 7, 8]
|
||||
[9, 10, 11, 12]
|
||||
```
|
||||
Пример 2
|
||||
```py
|
||||
>>> sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
|
||||
>>> fp3=open('zapis4.txt','w')
|
||||
>>> for i in range(len(sps3)):
|
||||
... stroka4=sps3[i][0]+' '+str(sps3[i][1])
|
||||
... fp3.write(stroka4)
|
||||
...
|
||||
11
|
||||
11
|
||||
12
|
||||
>>> fp3.close()
|
||||
```
|
||||
Открыли файл и увидели
|
||||
```py
|
||||
Иванов И. 1Петров П. 2Сидоров.
|
||||
```
|
||||
Легко заметить, что информация записана в файл не очень удачно.Тогда попробум сделать так:
|
||||
```py
|
||||
>>> gh=open('zapis5.txt','w')
|
||||
>>> for r in sps3:
|
||||
... gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
...
|
||||
12
|
||||
12
|
||||
13
|
||||
>>> gh.close()
|
||||
```
|
||||
Открыли файл и увидели
|
||||
```py
|
||||
Иванов И. 1
|
||||
Петров П. 2
|
||||
Сидоров С. 3
|
||||
```
|
||||
можно было записать цикл как
|
||||
```py
|
||||
for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
|
||||
```
|
||||
4.6 Первый способ чтения информации из текстового файла.
|
||||
```py
|
||||
>>> sps1=[]
|
||||
>>> fp=open('zapis3.txt')
|
||||
>>> for stroka in fp:
|
||||
... stroka=stroka.rstrip('\n')
|
||||
... stroka=stroka.replace('[','')
|
||||
... stroka=stroka.replace(']','')
|
||||
... sps1=sps1+stroka.split(',') # на этот моменте целые числа превращаются в строки
|
||||
...
|
||||
>>> fp.close()
|
||||
>>> sps1
|
||||
['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
|
||||
```
|
||||
Обратите внимание, что в функции открытия файла использован только один аргумент, остальные – со значениями «по умолчанию».
|
||||
Здесь, перед занесением строки в список с помощью метода rstrip, из неё удаляется сим-вол конца строки, а с помощью метода replace – скобки.
|
||||
Видно, что полученный список отличается от исходного sps, в первую очередь, типом данных.
|
||||
К тому же, в sps1 убрались не все пробелы.
|
||||
Преобразовать sps1 в sps можно, например, так:
|
||||
```py
|
||||
>>> 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.
|
||||
Метод read, как и write, относится к объекту – файловой переменной. В качестве аргумен-та этого метода может задаваться целое число – количество символов или, если открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или би-нарного файла, начиная с текущего положения маркера. Если указанное число превышает коли-чество оставшихся символов (байт) в файле, то считываются все оставшиеся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла. Например,
|
||||
```py
|
||||
>>> 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, если он есть в файле.
|
||||
```py
|
||||
>>> file = open("zapis5.txt")
|
||||
>>> file.readline()
|
||||
'Иванов И. 1\n'
|
||||
>>> file.seek(0) # Вовзращение указателя обратно в начало, чтобы нагляднее выполнить
|
||||
readlines
|
||||
0
|
||||
>>> file.readlines()
|
||||
['Иванов И. 1\n', 'Петров П. 2\n', 'Сидоров С. 3\n']
|
||||
```
|
||||
## Пункт 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
|
||||
В модуле pickle содержатся функции для работы с бинарными файлами, в которые могут после-довательно записываться или считываться целиком один или несколько объектов из оперативной памяти. Рассмотрите этот способ работы с файлами на следующем примере:
|
||||
```py
|
||||
>>> import pickle
|
||||
>>> mnoz1={'pen','book','pen','iPhone','table','book'} #Объект типа «множество»
|
||||
>>> fp=open('zapis6.mnz','wb') # Бинарный файл - на запись
|
||||
>>> pickle.dump(mnoz1,fp) #dump - метод записи объекта в файл
|
||||
>>> fp.close()
|
||||
```
|
||||
Откроем получившийся файл в текстовом редакторе, увидим подобную строку.
|
||||
```py
|
||||
Ђ•# Џ”(ЊiPhone”Њbook”Њtable”Њpen”ђ.
|
||||
```
|
||||
Так происходит, потому что байты в этом файле не предназначены для текстового представления.
|
||||
Они могут содержать символы, которые не могут быть корректно интерпретированы в рамках
|
||||
любой текстовой кодировки. Но в некоторых байтах содержатся символы, которые попадают в
|
||||
диапазон, поддерживаемый текстовым редактором и конкретной кодировкой (в моем случае ANSI),
|
||||
поэтому правильно дешифрованные буквы все же есть.
|
||||
|
||||
|
||||
Десериализуем множество обратно:
|
||||
```py
|
||||
>>> fp = open('zapis6.mnz','rb')
|
||||
>>> mnoz2 = pickle.load(fp)
|
||||
>>> fp.close()
|
||||
>>> mnoz2
|
||||
{'book', 'iPhone', 'table', 'pen'}
|
||||
>>> mnoz1
|
||||
{'book', 'iPhone', 'table', 'pen'}
|
||||
>>> mnoz1 == mnoz2
|
||||
True
|
||||
```
|
||||
mnoz1 не совпадает с тем, что было задано, потому что это множество. Оно исключает
|
||||
повторяющиеся элементы, оставляя только один, а еще не содержит конкретный порядок элементов.
|
||||
Но два множества равны, если у них равны все элементы и их одинаковое количество, вне
|
||||
зависимости от порядка, так что сравнение возвращает True.
|
||||
```py
|
||||
>>> 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', 'iPhone', 'table', 'pen'}
|
||||
>>> obj2
|
||||
[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
|
||||
>>> mnoz1 == obj1
|
||||
True
|
||||
>>> obj2 == sps3
|
||||
True
|
||||
```
|
||||
# Пункт 5. Перенаправление потоков ввода и вывода данных.
|
||||
|
||||
Поток в python и других ЯП - это абстракция, которая позволяет регулировать источники
|
||||
ввода информации и то, куда её выводить. Всего их по умолчанию три (еще можнно создать
|
||||
пользовательские):
|
||||
sys.stdin — поток ввода (обычно клавиатура)
|
||||
sys.stdout — поток вывода
|
||||
sys.stderr — поток ошибок (оба обычно экран)
|
||||
|
||||
Для работы с потоками импортируем модуль sys:
|
||||
```py
|
||||
>>> import sys
|
||||
```
|
||||
Сохраним адрес в памяти текущего потока вывода:
|
||||
```py
|
||||
>>> vr_out = sys.stdout
|
||||
>>> vr_out
|
||||
<idlelib.run.StdOutputFile object at 0x0000018C2F7961C0>
|
||||
```
|
||||
Откроем (созадем) файл на запись:
|
||||
```py
|
||||
>>> fc = open('Stroka.txt','w')
|
||||
```
|
||||
Теперь зададим в качестве потока вывода этот файл:
|
||||
```py
|
||||
>>> sys.stdout = fc
|
||||
>>> print('запись строки в файл')
|
||||
```
|
||||
Видно, что в консоли не появилось строки. Вернем поток по умолчанию обратно:
|
||||
```py
|
||||
>>> sys.stdout = vr_out
|
||||
>>> print('запись строки на экран')
|
||||
запись строки на экран
|
||||
>>> fc.close()
|
||||
```
|
||||
В файле Stroka.txt находится: запись строки в файл
|
||||
|
||||
Можно перенаправить и поток ввода тоже. Например, на файл:
|
||||
```py
|
||||
>>> 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
|
||||
```
|
||||
@@ -1,62 +0,0 @@
|
||||
• Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56,
|
||||
представленными в виде символьных строк.
|
||||
```py
|
||||
>>> nums = tuple(str(random.randint(6, 56)) for _ in range(125))
|
||||
>>> nums
|
||||
('41', '37', '13', '26', '9', '33', '55', '50', '51', '44', '38', '17', '18', '18', '36',
|
||||
'23', '43', '38', '41', '42', '53', '16', '41', '34', '38', '48', '37', '17', '36', '48',
|
||||
'31', '34', '51', '18', '12', '37', '42', '50', '47', '26', '27', '30', '26', '11', '19',
|
||||
'56', '15', '7', '6', '45', '22', '37', '36', '54', '31', '35', '46', '54', '31', '13',
|
||||
...'41', '9', '9', '22')
|
||||
```
|
||||
Примечание: если итератор не надо использовать в теле цикла, принято просто обозначать его _
|
||||
|
||||
• Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
|
||||
```py
|
||||
>>> group = ["Tsvetkova", "Konovalova", "Kiselyov", "Kirsanov", "Romanov"]
|
||||
```
|
||||
• Записывается кортеж в бинарный файл.
|
||||
```py
|
||||
>>> fl = open("okz.okz", "wb")
|
||||
>>> pickle.dump(nums, fl)
|
||||
```
|
||||
• Записывается в этот же файл список и закрывается файл.
|
||||
```py
|
||||
>>> pickle.dump(group, fl)
|
||||
>>> fl.close()
|
||||
```
|
||||
• Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
|
||||
```py
|
||||
>>> fl = open("okz.okz", "rb")
|
||||
>>> nums1 = pickle.load(fl)
|
||||
>>> nums1
|
||||
('41', '37', ... '41', '9', '9', '22')
|
||||
>>> group1 = pickle.load(fl)
|
||||
>>> group1
|
||||
['Tsvetkova', 'Konovalova', 'Kiselyov', 'Kirsanov', 'Romanov']
|
||||
```
|
||||
Примечание: при чтении с помощью pickle.load() тоже есть указатель, который останавливается
|
||||
при достижении /n, так что можно просто вызвать ее два раза, чтобы записать эти два объекта.
|
||||
Если вызвать ее третий раз, будет EOFError.
|
||||
|
||||
• Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
|
||||
```py
|
||||
>>> print("Файлы nums совпадают!") if nums == nums1 else print("Файлы nums не совпадают :(")
|
||||
Файлы nums совпадают!
|
||||
>>> print("Файлы group совпадают!") if group == group1 else print("Файлы group не совпадают :(")
|
||||
Файлы group совпадают!
|
||||
```
|
||||
• Разделяется кортеж на совокупности по 5 чисел в каждой и
|
||||
они записываются в виде отдельных списков со своими именами. (Динамические имена, согласно
|
||||
примечанию на git uit)
|
||||
```py
|
||||
>>> for i in range(125//5):
|
||||
exec('list' + str(i) + '=' + str(list(nums1[i:i+5])))
|
||||
```
|
||||
Можно вызвать конкретные списки для проверки:
|
||||
```py
|
||||
>>> list1
|
||||
['37', '13', '26', '9', '33']
|
||||
>>> list6
|
||||
['55', '50', '51', '44', '38']
|
||||
```
|
||||
739
TEMA7/7.md
739
TEMA7/7.md
@@ -1,739 +0,0 @@
|
||||
# Пункт 2. Создание пользовательской функции.
|
||||
|
||||
Общий вид:
|
||||
```py
|
||||
def <Имя функции>([<Список аргументов >]):
|
||||
[<отступы> """<Комментарий по назначению функции>"""]
|
||||
<отступы> <Блок инструкций – тело функции>
|
||||
[<отступы> return <Значение или вычисляемое выражение>]
|
||||
```
|
||||
Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем
|
||||
в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то
|
||||
выполнение функции прекращается с возвратом значения, следующего за этой инструкцией.
|
||||
В Python, если функция не содержит оператора return, она автоматически возвращает значение
|
||||
None.
|
||||
|
||||
## Пункт 2.1. Функция без аргументов.
|
||||
```py
|
||||
>>> def uspeh():
|
||||
"""Подтверждение успеха операции"""
|
||||
print('Выполнено успешно!')
|
||||
>>> uspeh()
|
||||
Выполнено успешно!
|
||||
```
|
||||
Функция - класс function:
|
||||
```py
|
||||
>>> type(uspeh)
|
||||
<class 'function'>
|
||||
```
|
||||
Видно, что такой объект появился в рабочем пространстве:
|
||||
```py
|
||||
>>> dir()
|
||||
['__annotations__', '__builtins__',
|
||||
'__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
|
||||
```
|
||||
```py
|
||||
>>> help(uspeh)
|
||||
Help on function uspeh in module __main__:
|
||||
uspeh()
|
||||
Подтверждение успеха операции
|
||||
```
|
||||
Видно, что help вернуло имя функции и то описание, которое было указано в тройных кавычках
|
||||
при её определении.
|
||||
|
||||
## Пункт 2.2. Функция с аргументами.
|
||||
```py
|
||||
>>> def sravnenie(a, b):
|
||||
"""Сравнение a и b"""
|
||||
if a > b:
|
||||
print(a, ' больше ', b)
|
||||
elif a < b:
|
||||
print(a, ' меньше ', b)
|
||||
else:
|
||||
print(a, ' равно ',b)
|
||||
|
||||
```
|
||||
```py
|
||||
>>> n, m = 16, 5; sravnenie(n,m)
|
||||
16 больше 5
|
||||
```
|
||||
Так как при описании функции мы не конкретизировали, какой тип данных хотим получить, то
|
||||
python сможет принять любые данные, которые можно сравнить. Если что-то нельзя сравнить,
|
||||
вернется TypeError
|
||||
```py
|
||||
>>> sravnenie(2+3j > 1+2j)
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: '>' not supported between instances of 'complex' and 'complex'
|
||||
>>> sravnenie(2+3j == 2+3j)
|
||||
True
|
||||
>>>sravnenie("abbb", "baaaaa") # abbb меньше baaaa (т.к. 'a' < 'b')
|
||||
>>>sravnenie("abbb", "abbbbb") # abbb меньше abbbbb (короткая строка меньше)
|
||||
>>>sravnenie("10", "2") # 10 меньше 2 (т.к. '1' < '2')
|
||||
>>>sravnenie([1, 2, 3], [1, 2, 4]) # [1, 2, 3] меньше [1, 2, 4] (т.к. 3 < 4)
|
||||
>>>sravnenie([1, 2], [1, 2, 0]) # [1, 2] меньше [1, 2, 0] (короткий список меньше)
|
||||
|
||||
```
|
||||
## Пункт 2.3. Функция с return.
|
||||
```py
|
||||
>>> def logistfun(b, a):
|
||||
"""Вычисление логистической функции"""
|
||||
import math
|
||||
return a / (1 + math.exp(-b))
|
||||
```
|
||||
```py
|
||||
>>> v=1
|
||||
>>> w = 0.7
|
||||
>>> z = logistfun(w, v)
|
||||
>>> z
|
||||
0.6681877721681662
|
||||
```
|
||||
## 2.4. Сложение для разных типов аргументов
|
||||
```py
|
||||
>>> def slozh(a1,a2,a3,a4):
|
||||
... """ Сложение значений четырех аргументов"""
|
||||
... return a1+a2+a3+a4
|
||||
...
|
||||
```
|
||||
```py
|
||||
>>> 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}, {"аааа", True, None}, {6, 6, "a"}) #Для множеств
|
||||
...
|
||||
TypeError: unsupported operand type(s) for +: 'set' and 'set'
|
||||
```
|
||||
Как видно, операция сложения для множеств не применима. Если нужно объединить два множества,
|
||||
для этого есть специальная операция set union вида set1 | set2 | set3
|
||||
```py
|
||||
>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4} #Для словарей
|
||||
...
|
||||
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
|
||||
```
|
||||
Словари тоже нельзя сложить плюсом. Для объединения словарей есть оператор распаковывания
|
||||
**dict1.
|
||||
|
||||
```py
|
||||
>>> slozh(1, "а", 2, "б") #Число и строка
|
||||
...
|
||||
TypeError: unsupported operand type(s) for +: 'int' and 'str'
|
||||
```
|
||||
С коллекциями без явного преобразования тоже не сработает.
|
||||
```py
|
||||
>>> slozh(1, True, 2, False) #Число и логический тип
|
||||
4
|
||||
>>> slozh(1, 3.44, 2.0, 7) #Целое число и число с плавающей точкой
|
||||
13.44
|
||||
```
|
||||
## Пункт 2.5. Функция, реализующая модель некоторого устройства,
|
||||
на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
|
||||
```py
|
||||
>>> def inerz(x,T,ypred):
|
||||
""" Модель устройства с памятью:
|
||||
x - текущее значение вх.сигнала,
|
||||
T - постоянная времени,
|
||||
ypred - предыдущее значение выхода устройства"""
|
||||
y = (x + T * ypred) / (T + 1)
|
||||
return y
|
||||
```
|
||||
Создаем список с измерениями значений входного сигнала – в виде «ступеньки»:
|
||||
```py
|
||||
>>> sps = [0] + [1] * 100
|
||||
>>> spsy = []
|
||||
>>> TT = 20
|
||||
>>> yy = 0
|
||||
>>> for xx in sps:
|
||||
yy = inerz(xx,TT,yy)
|
||||
spsy.append(yy)
|
||||
```
|
||||
```py
|
||||
>>> import pylab as plt
|
||||
>>> plt.plot(spsy, label = "Выходной сигнал")
|
||||
[<matplotlib.lines.Line2D object at 0x00000241DC815370>]
|
||||
>>> plt.show()
|
||||
```
|
||||
График сохранен в файле с именем Figure_1.
|
||||
|
||||
|
||||
# Пункт 3. Функции как объекты.
|
||||
|
||||
## Пункт 3.1. Получение списка атрибутов объекта-функции.
|
||||
```py
|
||||
>>> 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__:
|
||||
```
|
||||
Если нет, то inerz.__doc__ будет иметь значение None.
|
||||
|
||||
Примеры других атрибутов функций:
|
||||
```py
|
||||
>>> 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. Сохранение ссылки на объект-функцию в другой переменной.
|
||||
```py
|
||||
>> fnkt = sravnenie
|
||||
>>> v = 16
|
||||
>>> fnkt(v, 23)
|
||||
16 меньше 23
|
||||
```
|
||||
Здесь происходит присвоение функции sravnenie переменной fnkt. Функции можно передавать в
|
||||
переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую
|
||||
функцию, что и sravnenie.
|
||||
|
||||
## Пункт 3.3. Возможность альтернативного определения функции в программе.
|
||||
```py
|
||||
>>> typ_fun=8
|
||||
>>> 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. Возможность использования функции в качестве аргумента другой функции
|
||||
```py
|
||||
>>> 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. Обязательные и необязательные аргументы.
|
||||
```py
|
||||
>>> def logistfun(a,b=1): #Аргумент b – необязательный; значение по умолчанию=1
|
||||
"""Вычисление логистической функции"""
|
||||
import math
|
||||
return b/(1+math.exp(-a))
|
||||
|
||||
>>> logistfun(0.7) #Вычисление со значением b по умолчанию
|
||||
0.6681877721681662
|
||||
>>> logistfun(0.7,2) #Вычисление с заданным значением b
|
||||
1.3363755443363323
|
||||
```
|
||||
## Пункт 4.3. Возможность обращения к функции с произвольным расположением аргументов.
|
||||
```py
|
||||
>>> logistfun(b = 0.5, a = 0.8)
|
||||
0.34498724056380625
|
||||
```
|
||||
Но при этом нельзя сделать так:
|
||||
```py
|
||||
>>> logistfun(b = 2, 0.7)
|
||||
SyntaxError: positional argument follows keyword argument
|
||||
```
|
||||
Python ожидает, что все позиционные аргументы будут переданы первыми, а затем уже
|
||||
могут следовать именованные аргументы.
|
||||
|
||||
## Пункт 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
|
||||
```py
|
||||
>>> 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. Пример со значениями аргументов функции, содержащимися в словаре
|
||||
```py
|
||||
>>> dic4 = {"a1": 1, "a2": 2, "a3": 3, "a4": 4}
|
||||
>>> qqq = slozh(**dic4)
|
||||
>>> qqq
|
||||
10
|
||||
```
|
||||
В данном случае распаковка произошла так, что ключи на входе функции восприниимаются как
|
||||
значения позиционных переменных, а значения, соответственно, как значения.
|
||||
|
||||
Примечание: Если поставить только одну звездочку, python попытается интерпретировать
|
||||
ключи, а не значения словаря как позиционные аргументы. Получается так:
|
||||
```py
|
||||
>>> slozh(*dic4)
|
||||
'a1a2a3a4'
|
||||
```
|
||||
## Пункт 4.6. Смешанные ссылки
|
||||
```py
|
||||
>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9}
|
||||
>>> qqqq = slozh(*e1,**dd2)
|
||||
>>> qqqq
|
||||
17
|
||||
```
|
||||
То есть (-1) + 6 + 3 + 9 = 17
|
||||
|
||||
## Пункт 4.7. Переменное число аргументов у функции.
|
||||
```py
|
||||
>>> 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. Комбинация аргументов
|
||||
```py
|
||||
>>> 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.
|
||||
|
||||
Если захочется НЕ передавать b, придется переопределить функцию так, чтобы
|
||||
именованный параметр b был в конце, а позиционный кортеж - перед ним. Например,
|
||||
так:
|
||||
```py
|
||||
>>> def func4(a, *kort7, b = 7):
|
||||
smm = 0
|
||||
for elt in kort7:
|
||||
smm += elt
|
||||
return a * smm + b
|
||||
|
||||
>>> func4(5, *[1, 2, 3])
|
||||
37
|
||||
```
|
||||
Примечание:
|
||||
|
||||
В общем виде *args и **kwargs - способы передать не уточненное заранее число
|
||||
элементов, причем:
|
||||
|
||||
*args — переменное количество позиционных аргументов. Переданные с одной
|
||||
звездочкой аргументы собираются в кортеж.
|
||||
|
||||
**kwargs — переменное количество именованных аргументов. Все переданные аргументы,
|
||||
которые указываются по имени, собираются в словарь.
|
||||
|
||||
Как и всегда, *args всегда должно идти перед **kwargs.
|
||||
|
||||
## Пункт 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
|
||||
```py
|
||||
>>> a = 90
|
||||
>>> def func3(b):
|
||||
b = 5*b+67
|
||||
|
||||
|
||||
>>> func3(a)
|
||||
>>> a
|
||||
90
|
||||
```
|
||||
Поскольку функция ничего не возвращает (то есть, формально, является процедурой), то вычисленное
|
||||
значение b = 5*b+67 существует только локально внутри нее и не выносится в глобальную область видимости
|
||||
Для наглядности:
|
||||
```py
|
||||
>>> def func3(b):
|
||||
b = 5*b+67
|
||||
print(b)
|
||||
|
||||
|
||||
>>> func3(a)
|
||||
517
|
||||
>>> a
|
||||
90
|
||||
```
|
||||
```py
|
||||
|
||||
>>> sps1=[1,2,3,4]
|
||||
>>> def func2(sps):
|
||||
sps[1] = 99
|
||||
|
||||
|
||||
>>> func2(sps1)
|
||||
>>> print(sps1)
|
||||
[1, 99, 3, 4]
|
||||
```
|
||||
В отличие от предыдущего примера с переменной численного типа, список передается по ссылке, а не по
|
||||
значению, поэтому изменяется именно тот объект, который был передан.
|
||||
Для наглядности:
|
||||
```py
|
||||
>>> def func3(b):
|
||||
b = 5*b+67
|
||||
print(id(b))
|
||||
|
||||
>>> func3(a)
|
||||
2763070067568
|
||||
>>> id(a)
|
||||
2763028911248 # Разные адреса
|
||||
|
||||
>>> def func3(b):
|
||||
b = 5*b+67
|
||||
print(id(b))
|
||||
|
||||
>>> func3(a)
|
||||
2763070067568
|
||||
>>> id(a)
|
||||
2763028911248 # Одинаковые адреса
|
||||
```
|
||||
```py
|
||||
>>> 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. Анонимные функции (лямбда-функции).
|
||||
```py
|
||||
>>> 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
|
||||
```
|
||||
Вызов лямбда-функции создает объект класса "функция", который потом можно положить в другую переменную
|
||||
и далее вызывать. Но это делать необязательно: если она используется один раз, можно вызвать ее сразу,
|
||||
например:
|
||||
```py
|
||||
>>> r = (lambda a, b: a**2 + b)(5, 2) # Это результат функции, а не объект класса "функция"
|
||||
>>> r
|
||||
27
|
||||
```
|
||||
Внутри лямбда-функции не могут использоваться многострочные выражения, например:
|
||||
```py
|
||||
>>> r1 = lambda: (for i in range(5): print(i))
|
||||
SyntaxError: invalid syntax
|
||||
```
|
||||
Но при этом:
|
||||
```py
|
||||
>>> r1 = lambda: (print(i) for i in range(5))
|
||||
|
||||
```
|
||||
Аналогично нельзя использовать if-else, но можно использовать тернарный оператор.
|
||||
|
||||
## Пункт 5.2. Функции-генераторы
|
||||
|
||||
Иногда в циклах на каждой итерации нужно получать одно из значений. Для этого есть оператор yield.
|
||||
Это похоже на return, но в отличие от return не останавливает полностью выполнение программы.
|
||||
Когда выполнение генератора возобновляется после yield, оно продолжается с того места, где было
|
||||
приостановлено, до следующего оператора yield (или до конца функции).
|
||||
Вместе с yield, можно использовать next(). Например:
|
||||
```py
|
||||
>>> def test():
|
||||
for i in range(3):
|
||||
yield i
|
||||
|
||||
|
||||
>>> l = test()
|
||||
>>> l
|
||||
<generator object test at 0x0000028353CCFF90>
|
||||
>>> next(l)
|
||||
0
|
||||
>>> next(l)
|
||||
1
|
||||
```
|
||||
Аналогично, можно использовать и метод __next__
|
||||
```py
|
||||
>>> print(l.__next__())
|
||||
2
|
||||
```
|
||||
Другой пример:
|
||||
```py
|
||||
>>> alp=func5(7,3)
|
||||
>>> print(alp.__next__())
|
||||
1
|
||||
>>> print(alp.__next__())
|
||||
5
|
||||
>>> print(alp.__next__())
|
||||
4
|
||||
...
|
||||
```
|
||||
__next__ помогает вывести значение, которое yield передает на каждй итерации цикла. Если функция
|
||||
отработала последнюю итерацию, но мы все попытаемся сделать вызов, вернется ошибка:
|
||||
```py
|
||||
>>> print(alp.__next__())
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#96>", line 1, in <module>
|
||||
print(alp.__next__())
|
||||
StopIteration
|
||||
```
|
||||
# Пункт 6. Локализация объектов в функциях.
|
||||
|
||||
Все объекты - переменные, коллекции, функции и т.д. - могут быть определены глобально или локально.
|
||||
Глобально - значит вне всяких функций.Локальные переменные определены внутри функции, и если хочется
|
||||
использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
|
||||
|
||||
## Пункт 6.1. Примеры
|
||||
```py
|
||||
>>> glb = 10
|
||||
>>> def func7(arg):
|
||||
loc1 = 15
|
||||
glb = 8
|
||||
return loc1*arg
|
||||
|
||||
>>> res = func7(glb)
|
||||
>>> res
|
||||
150
|
||||
```
|
||||
Проверим:
|
||||
```py
|
||||
>>> glb
|
||||
10
|
||||
```
|
||||
|
||||
Посмотрим подробнее, что происходит внутри функции:
|
||||
```py
|
||||
>>> def func7(arg):
|
||||
loc1=15
|
||||
glb=8
|
||||
print(glb, arg)
|
||||
return loc1*arg
|
||||
|
||||
>>> res=func7(glb)
|
||||
8 10
|
||||
```
|
||||
Видно, что внутри объект с именем glb принял значение 8, но глобальная переменная при этом после выполнения
|
||||
функции значения не поменяла. Это происходит потому, что технически, локальный glb и глобальный glb -
|
||||
это два разных объекта. В этом можно убедиться:
|
||||
```py
|
||||
>>> res=func7(glb) #При определенении func7 добавлена строка print(id(glb))
|
||||
2763028720144
|
||||
8 10
|
||||
>>> id(glb)
|
||||
276302872020
|
||||
```
|
||||
|
||||
Пример 2.
|
||||
```py
|
||||
>>> 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():
|
||||
```py
|
||||
>>> 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()
|
||||
|
||||
Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно,
|
||||
локальными или глобальными на уровне вызова этих функций.
|
||||
```py
|
||||
>>> globals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
|
||||
'__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
|
||||
'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3',
|
||||
'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
>>> locals().keys()
|
||||
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__',
|
||||
'__builtins__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
|
||||
'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
|
||||
'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8'])
|
||||
```
|
||||
Сейчас различий нет, потому что эти методы возвращают объекты на уровне вызова этих функций, но мы
|
||||
вызвали обе самом внешнем уровне, не внутри какой-либо функции, а в самом рабочем пространстве, где
|
||||
локальная и глобальная области видимости совпадают.
|
||||
```py
|
||||
>>> 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__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number', 'a',
|
||||
'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5', 'mm', 'r',
|
||||
'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh']) # Тут глобальное glb
|
||||
{'arg': 10, 'loc1': 15, 'glb': 8} # Это локальное glb
|
||||
>>> glb # Снова глобальное glb
|
||||
10
|
||||
```
|
||||
## Пункт 6.3. Локализация объектов при использовании вложенных функций.
|
||||
```py
|
||||
>>> 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__', '__file__', 'math', 'random', 'pickle',
|
||||
'task', 't', 'number', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1',
|
||||
'anfun2', 'anfun3', 'func5', 'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb',
|
||||
'func7', 'res', 'func8', 'hh', 'func9', 'loc1'])
|
||||
|
||||
locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1']) # Содержит только объекты, определенные внутри func9_1,
|
||||
а также объект, переданный как аргумент функции
|
||||
|
||||
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__', '__file__', 'math', 'random', 'pickle', 'task', 't', 'number',
|
||||
'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'anfun2', 'anfun3', 'func5',
|
||||
'mm', 'r', 'r1', 'test', 'l', 'alp', 'glb', 'func7', 'res', 'func8', 'hh',
|
||||
'func9', 'loc1']) # Такой же, как glob_func9_1
|
||||
```
|
||||
## Пункт 6.4. Моделирование САУ
|
||||
```py
|
||||
>>> 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]
|
||||
|
||||
```
|
||||
Двоичные данные
TEMA7/Figure_1.png
Двоичные данные
TEMA7/Figure_1.png
Двоичный файл не отображается.
|
До Ширина: | Высота: | Размер: 15 KiB |
@@ -1,89 +0,0 @@
|
||||
|
||||
Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для
|
||||
устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на
|
||||
заданное время Т.
|
||||
```py
|
||||
def delays (signal, T):
|
||||
for i in range(len(signal)):
|
||||
signal[i] += T
|
||||
return signal
|
||||
```
|
||||
Входной сигнал:
|
||||
```py
|
||||
>>> y = [random.gauss(3, 1.5) for _ in range(40)]
|
||||
>>> y
|
||||
[0.9991072002742722, 1.5968849542569137, 2.3438553070732215, 3.5914160170650784, 4.037092622456526,
|
||||
2.918114740779675, 4.802139541704564, 3.2313443629034646, 2.329031244833026, 4.450860002446187,
|
||||
1.4135232524868848, 5.914364290743276, 3.7898798373923634, 2.364244259128151, 4.9786840892253235,
|
||||
1.4351490690602144, 2.351122955511408, 1.8798309616294469, 0.7931480954519166, 3.811575392065204,
|
||||
2.524732026173494, 2.8373060222940696, 4.497504412830464, 3.406940931674363, 3.876506913067825,
|
||||
1.7529616032820314, 2.6542411737897087, 1.948604542902865, 6.138099312505814, 1.4111492356181103,
|
||||
3.736820673744037, 4.509373750771566, 1.7486314440126465, 4.70122140759552,
|
||||
-0.6513915222680815, 0.171219291885647, 2.2079783562880486, 4.390489704586708, 0.9670198540727273,
|
||||
1.6420724788248429]
|
||||
|
||||
>>> yd = delays(y, 4)
|
||||
>>> yd
|
||||
[4.999107200274272, 5.596884954256914, 6.3438553070732215, 7.591416017065079, 8.037092622456527,
|
||||
6.918114740779675, 8.802139541704564, 7.231344362903465, 6.3290312448330255, 8.450860002446188,
|
||||
5.413523252486884, 9.914364290743276, 7.7898798373923634, 6.364244259128151, 8.978684089225323,
|
||||
5.435149069060214, 6.351122955511408, 5.879830961629446, 4.793148095451917, 7.811575392065204,
|
||||
6.524732026173494, 6.83730602229407, 8.497504412830464, 7.406940931674363, 7.876506913067825,
|
||||
5.752961603282031, 6.654241173789709, 5.948604542902865, 10.138099312505814, 5.41114923561811,
|
||||
7.736820673744036, 8.509373750771566, 5.748631444012647, 8.70122140759552,
|
||||
3.3486084777319185, 4.171219291885647, 6.207978356288049, 8.390489704586708, 4.967019854072728, 5.642072478824843]
|
||||
```
|
||||
Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то
|
||||
распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов
|
||||
выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения
|
||||
случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
|
||||
```py
|
||||
import numpy as np
|
||||
import random
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
def histo(data, num):
|
||||
minval, maxval = min(data), max(data)
|
||||
parts = np.linspace(minval, maxval, num + 1)
|
||||
rows = [0] * num
|
||||
for now in data:
|
||||
for i in range(num):
|
||||
if parts[i] <= now < parts[i + 1]:
|
||||
rows[i] += 1
|
||||
break
|
||||
if now == maxval:
|
||||
rows[-1] += 1
|
||||
|
||||
plt.hist(data, bins=parts)
|
||||
plt.xlabel('Значения выборки')
|
||||
plt.ylabel('Число элементов')
|
||||
plt.title('Гистограмма выборки')
|
||||
plt.show()
|
||||
|
||||
return rows
|
||||
|
||||
sample = [random.gauss(random.random(), random.random()) for _ in range(random.randint(10,200))]
|
||||
intervals = int(input("Введите количество интервалов разбиения: "))
|
||||
output = histo(sample, intervals)
|
||||
|
||||
======================= RESTART: D:/STUDY/POAS/Тема7/hist.py ======================
|
||||
Введите количество интервалов разбиения: 12
|
||||
[1, 0, 3, 4, 11, 21, 43, 57, 22, 6, 2, 3]
|
||||
|
||||
```
|
||||
Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х
|
||||
Y=b1+b2*X
|
||||
и имеющую аргументы b1, b2 и X.
|
||||
```py
|
||||
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
|
||||
```
|
||||
Ссылка в новой задаче
Block a user