test-commit

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+ #Программа по Теме 1 <Зеленкина КМ>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\\Users\\user\\python-labs\\TEMA1')

TEMA1/protocol.py

@@ -0,0 +1,15 @@
+ #Программа по Теме 1 <Зеленкина КМ>
+
+import os
+os.chdir(r'C:\\Users\\user\\python-labs\\TEMA1')
+
+import Pr0
+Hello
+Your name=Katerina
+
+import os
+os.chdir(r'C:\\Users\\user\\python-labs\\TEMA1')
+
+import prb1
+Как Вас зовут? Katerina
+Привет, Katerina

TEMA1/report.md

@@ -0,0 +1,156 @@
+# Отчёт по теме 1
+Зеленкина Катерина, А-02-23
+
+## Пункты 1-2. Запуск программы
+Запустила программу-интерпретатор IDLE  
+![Скриншот иконки программы](image1.png)
+
+## Пункты 3-5. Изучение диалогового окна
+
+Ввела инструкции вывода и ввода, а затем завершила работу интерпретатора:
+
+```py
+>>> print('Hello')
+Hello
+>>> h=input('Your name=')
+Your name=Katerina
+>>> exit()
+```
+
+	
+## Пункты 6-8. Интерактивная графическая оболочка IDLE среды Python
+Запустила обратно ярлык «IDLE (Python 3.Х GUI )» и изучила устройство главного командного окна среды
+
+Настроила рабочий каталог:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\user\python-labs\TEMA1')
+```
+
+## Пункт 9. Изучение предложений главного и выпадающих меню  
+
+Нажала "Options/Configure IDLE": 
+1) Нажала "Fonts",установила шрифт типа Arial CYR размером 11
+![Скриншот параметров шрифта](image3.png)
+
+2) Нажала "Windows", установила размер начального окна - высота 50, ширина 100
+![Скриншот начального окна](image4.png)
+
+3) Изменила подкраску комментариев: перешла в раздел "Highlights", нажала "#Click selects item/Choose color for/*Выбрала коричневый цвет*/OK"
+![Скриншот комментариев] (image5.png)
+
+## Пункт 10. Текстовый редактор
+Нажала "Файл/Новый файл". Вставила инструкции из п. п. 3,4 и 8. Сохранила как Pr0.py
+
+![Скриншот текстового редактора](image6.png)
+
+Запустила модуль "Run/Run Modul", или с помощью "import Pr0", или F5
+
+Результат:
+```py
+========================== RESTART: C:\Users\user\python-labs\TEMA1\Pr0.py =========================
+Hello
+Your name=Katerina
+>>> import Pr0
+Hello
+Your name=Katerina
+```
+
+## Пункт 11. Запуск файла prb1
+Запустила файл prb1.py 
+
+```py
+>>> import prb1
+Как Вас зовут? Katerina
+Привет, Katerina
+```
+
+## Пункт 12-13. Изучение каталога pycache
+
+Открыла файл Pr0.cpython-313.рус в текстовом редакторе
+
+![Cкриншот кода](image7.png)
+
+Вывод: Код представлен в двоичном коде. Компиляция перевела программу с языка программирования, понятный человеку, на машинный код понятный процессору.
+
+## Пункт 14. Раздел "HELP"
+
+Я спросила про функцию"print":
+
+```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.
+```
+
+Также для обращения к оперативной помощи можно использовать F1 или нажать "Help/Python Docs"
+
+## Пункт 15. Перемещение между окнами
+## 15.1. Открытие и запуск файла prb1
+Открыла файл prb1.py в среде питон и запустила его:
+![Скриншот prb1](image8.png)
+
+Результат:
+```py
+============================================================== RESTART: C:\Users\user\python-labs\TEMA1\prb1.py =============================================================
+Как Вас зовут?  Katerina
+Привет,  Katerina
+```
+
+## 15.2. Запуск файла tdemo_chaos
+Запустила файл tdemo_chaos, результат:
+![Скриншот графика](image9.png)
+
+## 15.3. Turtle Demo
+Нажала на "Help/Turtle Demo/Examples/ Clock/Start"
+![Скриншот часов](image10.png)
+
+Также посмотрела примеры других программ. Пример:
+![Скриншот дерева](image11.png)
+
+## Пункт 16. Выход из среды
+
+
+

TEMA1/vopros.md

@@ -0,0 +1,9 @@
+# Индивидуальное контрольное задание по Теме 1
+Зеленкина Катерина, А-02-23
+
+## Вопрос
+12) Если требуется повторить с небольшим изменением ранее введенную инструкцию, работая в командном окне IDLE, как это лучше сделать?
+
+## Ответ
+
+Перейти на строку с инструкцией, которую нужно повторить, нажать "Enter" (тогда скопируется инструкция) и внести нужные изменения

TEMA2/report.md

@@ -0,0 +1,810 @@
+# Отчёт по теме 2
+Зеленкина Катерина, А-02-23
+
+## Пункт 1. Запуск оболочки IDLE
+
+Установим рабочий каталог:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\user\python-labs\TEMA2')
+```
+## Пункт 2. Простые объекты
+Рассмотрела операции присваивания:
+
+```py
+f1=16; f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+```
+
+Просмотрела уже существующие объекты в данный момент в среде Python:
+
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+Просмотрела список атрибутов объекта f1:
+
+```py
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Определила классовую принадлежность объекта f2:
+
+```py
+>>> type(f2)
+<class 'int'>
+```
+
+Удалила объекты f1 и f2:
+
+```py
+>>> del f1,f2
+>>> f1;f2
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    f1;f2
+NameError: name 'f1' is not defined
+```
+
+## Пункт 3. Правила именования объектов в Python.
+
+Выполнила следующие предложенные операции. Последние две из них имели недопустимые имена:
+
+```py
+>>> gg1=1.6
+>>> gg1
+1.6
+>>> hh1='Строка'
+>>> hh1
+'Строка'
+>>> 73sr=3 - неправильное именование
+SyntaxError: invalid decimal literal
+>>> and=7 - неправильное именование
+SyntaxError: invalid syntax
+```
+
+## Пункты 4-5. Список ключевых слов и встроенных идентификаторов 
+
+Вывела список ключевых слов и сохранила его в переменную
+
+```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']
+>>> a = keyword.kwlist
+>>> a
+['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']
+```
+
+Вывела список встроенных идентификаторов:
+
+```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', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+### Функция abs()
+
+```py
+>>> help (abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+>>> abs(-1)
+1
+```
+
+### Функция len()
+
+```py
+>>> help (len)
+Help on built-in function len in module builtins:
+
+len(obj, /)
+    Return the number of items in a container.
+
+>>> b=[0,1,2,3,4,5,6,7,8,9,10]
+>>> b
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> len(b)
+11
+```
+
+### Функции max()/min()
+
+```py
+>>> help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    max(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its biggest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the largest argument.
+
+>>> help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+    min(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its smallest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the smallest argument.
+
+>>> max(b)
+10
+>>> min(b)
+0
+```
+
+### Функция pow()
+
+```py
+>>> help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
+
+    Some types, such as ints, are able to use a more efficient algorithm when
+    invoked using the three argument form.
+
+>>> pow(6,2)
+36
+```
+
+### Функция 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.
+
+>>> round(3.8)
+4
+```
+
+### Функция sorted()
+
+```py
+>>> help(sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+>>> c=[10, 4, 9, 1, 23]
+>>> c
+[10, 4, 9, 1, 23]
+>>> sorted(c)
+[1, 4, 9, 10, 23]
+```
+
+### Функция sum()
+
+```py
+>>> help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+>>> sum(c)
+47
+```
+
+### Функция zip()
+
+```py
+>>> help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+ |  shortest argument is exhausted.
+ |
+ |  If strict is true and one of the arguments is exhausted before the others,
+ |  raise a ValueError.
+ |
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |
+ |  Methods defined here:
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __next__(self, /)
+ |      Implement next(self).
+ |
+ |  __reduce__(self, /)
+ |      Return state information for pickling.
+ |
+ |  __setstate__(self, object, /)
+ |      Set state information for unpickling.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+
+>>> c
+[10, 4, 9, 1, 23]
+>>> d=[1,2,3,4,5]
+>>> d
+[1, 2, 3, 4, 5]
+>>> h=zip(c,d)
+>>> h
+<zip object at 0x0000021067B5EC80>
+>>> list(h)
+[(10, 1), (4, 2), (9, 3), (1, 4), (23, 5)]
+```
+
+## Пункт 6. Регистр букв
+Проверила влияние больших и малых букв в имени переменных
+
+```py
+>>> Gg1=45
+>>> gg1
+1.6
+>>> Gg1
+45
+```
+
+## Пункт 7. Простые базовые типы объектов
+### 7.1 Логический тип (bool)
+
+```py
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+```
+
+### 7.2 Другие простые типы
+
+```py
+>>> ii1=-1234567890
+>>> type(ii1)
+<class 'int'>
+
+>>> ff1=-8.9876e-12
+>>> type(ff1)
+<class 'float'>
+
+>>> dv1=0b1101010 #Двоичное число
+>>> type(dv1)
+<class 'int'>
+```
+Двоичное число сохранено в объекте класса int
+
+```py
+>>> vsm1=0o52765 #Восьмеричное число
+>>> type(vsm1)
+<class 'int'>
+
+>>> shest1=0x7109af6 #Шестнадцатеричное число
+>>> type(shest1)
+<class 'int'>
+
+cc1=2-3j
+type(cc1)
+<class 'complex'>
+```
+
+Создание комплексного числа:
+
+```py
+a=3.67; b=-0.45
+cc2=complex(a,b)
+type(cc2)
+<class 'complex'>
+```
+
+### 7.3 Строка символов
+
+Строки выделяются апострофами:
+```py
+>>> ss1='Это - строка символов'
+>>> ss1
+'Это - строка символов'
+```
+
+Строки выделяются двойными кавычками:
+```py
+>>> ss1="Это - строка символов"
+>>> ss1
+'Это - строка символов'
+```
+
+Попробовала экранированные последовательности:
+
+```py
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+
+Создала строку по шаблону:
+
+```py
+>>> ss1b= 'Меня зовут: \n Зеленкина К. М.'
+>>> print(ss1b)
+Меня зовут: 
+ Зеленкина К. М.
+```
+Многострочные строки:
+
+```py
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Обратилась к частям строки с помощью индексов:
+
+```py
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+```
+
+Выполнила операцию «разрезания»/«создания среза»:
+```py
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+```
+
+При отрицательном значении шага перечислились элементы с индексами от 3 до 17 в обратном порядке:
+```py
+>>> ss1[17:3:-2]
+'омсаот '
+```
+
+Заменив 17 на -4, мы получим тот-же результат, т. к. символ под индексом 17 и  -4 один и тот же:
+
+```py
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+Строка является неизменяемым объектом, поэтому нам выдаст ошибку при попытке внести изменения:
+
+```py
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+```
+
+```py
+>>> sk1=ss1b[:4]+' именовать'+ss1b[12:]; print(sk1)
+Меня именовать
+ Зеленкина К. М.
+```
+Самостоятельно придумала значения и создала объекты разных типов:
+
+```py
+>>> flag = True
+>>> type(flag)
+<class 'bool'> 
+
+>>> n=16
+>>> type(n)
+<class 'int'>
+
+>>> k = 'Привет'
+>>> type(k)
+<class 'str'>
+```
+
+## Пункт 8. Сложные типы объектов
+### 8.1 Списки
+
+__Список__ — это упорядоченная коллекция элементов произвольных типов (числа, строки, другие объекты).
+
+Список с элементами разных типов:
+
+```py
+>>> spis1=[111, 'Spisok' ,5-9j]
+>>> spis1
+[111, 'Spisok', (5-9j)]
+```
+
+Вводить элементы в списках можно на разных строках до закрытия квадратной скобкой:
+
+```py
+>>> stup=[0,0,1,1,1,1,1,1,1]; stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+В списках тоже можно обращаться к элементам по индексам:
+
+```py
+>>> spis1[-1]
+(5-9j)
+
+>>> stup[-8::2]
+[0, 1, 1, 1] 
+```
+
+Пояснение: Вошло 4 элемента. Элемент под индексом '-8' есть элемент с индексом 1, срез произойдёт до последнего элемента с шагом 2
+
+Заменила второй элемент в spis1:
+
+```py
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+>>> len(spis1)
+3
+```
+
+Добавление элементов в список:
+
+
+```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')
+spis1
+[111, 'Список', (5-9j), 'New item']
+
+
+>>> spis1.append(ss1b)
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+```
+
+### Другие методы:
+__insert__ - вставляет элемент в нужную позицию
+
+```py
+>>> spis1.insert(0, 24); spis1
+[24, 111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+```
+__remove__ - удалит элемент, указанный в скобках
+
+```py
+>>> spis1.remove(24); spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.']
+```
+
+__extend__ - добавляет каждый элемент аргумента
+
+```py
+>>> spis1.extend('24'); spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.', '2', '4']
+```
+
+__clear__ - удаляет всё из списка
+
+```py
+>>> spis1.clear(); spis1
+[]
+```
+
+__sort__ - сортирует элементы в списке по возрастанию, а буквы по алфавиту
+
+```py
+>>> spis1=[20, 4, 63, 2, 1, 0, 13, 7]; spis1
+[20, 4, 63, 2, 1, 0, 13, 7]
+>>> spis1.sort()
+>>> spis1
+[0, 1, 2, 4, 7, 13, 20, 63]
+
+>>> spis2 = ['д', 'с','г','а','ш']
+>>> spis2.sort()
+>>> spis2
+['а', 'г', 'д', 'с', 'ш']
+```
+
+__reverse__ - сортирует элементы в обратном порядке
+
+```py
+>>> spis1.reverse(); spis1
+[63, 20, 13, 7, 4, 2, 1, 0]
+
+>>> spis2.reverse();spis2
+['ш', 'с', 'д', 'г', 'а']
+```
+
+__copy__ - копирует список
+
+```py
+>>> vv=spis1.copy(); vv
+[63, 20, 13, 7, 4, 2, 1, 0]
+```
+
+__count__ - cчитает количество заданного аргумента в скобках в списке
+
+```py
+>>> spis2.count('д')
+1
+```
+
+__index__ - выдаёт индекс элемента
+
+```py
+>>> spis1.index(20)
+1
+```
+
+#### Вложенные списки
+
+```py
+>>> spis2=[spis1,[4,5,6,7]]; spis2
+[[63, 20, 13, 7, 4, 2, 1, 0], [4, 5, 6, 7]]
+>>> spis2[0][1] #обращение к элементу списка spis1
+20
+>>> spis2[0][1]=78; spis2 #Замена значения элемента на 78
+[[63, 78, 13, 7, 4, 2, 1, 0], [4, 5, 6, 7]]
+
+>>> spis1
+[63, 78, 13, 7, 4, 2, 1, 0]
+```
+
+Пояснение: Список spis1 отличается от первоначального, потому что он лежит в другом списке, в котором мы и поменяли значение
+
+Создала список с разными типами данных
+
+```py
+>>>spisok = [89, 'дом', True, ['яблоко', 'помидор', 'хлеб']]; spisok
+          
+[89, 'дом', True, ['яблоко', 'помидор', 'хлеб']]
+>>> type(spisok)
+          
+<class 'list'>
+```
+
+### 8.2 Кортежи
+
+__Кортеж__ – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки.
+
+```py
+>>> kort1=(222,'Kortezh',77+8j); kort1
+          
+(222, 'Kortezh', (77+8j))
+```
+
+Переопределим кортеж:
+
+1. Добавим элементы
+
+```py
+>>> kort1= kort1+(1,2)          
+>>> kort1         
+(222, 'Kortezh', (77+8j), 1, 2)
+
+>>> kort1= kort1+(ss1b,); kort1        
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Зеленкина К. М.')
+```
+
+2. Удалим элементы:
+
+```py
+>>> kort2=kort1[:2]+kort1[3:]; kort2      
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Зеленкина К. М.')
+```
+
+Узнала индекс заданного элемента:
+
+```py
+>>> kort1.index(2)         
+4
+```
+
+Подсчитала количество вхождений заданного элемента в кортеже:
+
+```py
+>>> kort1.count(222)         
+1
+```
+
+Т. к. кортежи неизменяемы, то у них отсутствуют методы append и pop.
+Попробуем заменить элемент в кортеже (выдаст ошибку):
+
+```py
+>>> kort1[2]=90          
+Traceback (most recent call last):
+  File "<pyshell#161>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+
+### Создаю объект-кортеж с разными типами данных:
+
+```py
+>>> kort2=(23, 'Тыква', [4, 5, 6, 7], (4, 6, 8, 10))   
+kort2         
+(23, 'Тыква', [4, 5, 6, 7], (4, 6, 8, 10))
+type(kort2)
+          
+<class 'tuple'>
+```
+
+## 8.3 Словарь
+__Словарь__ - совокупность пар: «ключ (key)»:«значение (value)».
+
+Создадим словарь:
+
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}; dic1         
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+```
+В словарях обращение к элементам происходит по ключам:
+
+```py
+>>> dic1['Orel']         
+56
+```
+Изменение словаря, добавление элемента:
+
+```py
+ >>> dic1['Pskov']=78
+ >>> dic1
+{'Saratov': 120, 'Vologda': 45, 'Pskov': 78, 'Orel': 56}
+```
+Отобразим сортированный словарь с помощью функции sorted (Отображает, но не сортирует):
+
+```py
+>>> sorted(dic1.keys())        
+['Orel', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())        
+[45, 56, 145]
+```
+
+Элементы словаря могут быть любого типа, даже словарём:
+
+```py
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}         
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']} 
+>>> dic3        
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}  
+    
+>>> dic3['statistics'][2]         
+'standart deviation'
+```
+
+Создадим более сложный словарь: 
+
+```py
+>>> 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
+>>> spisok01=(1, 5, 7, 9, 3, 0,10); spisok01         
+(1, 5, 7, 9, 3, 0, 10)
+>>> spisok02=[22,10,7,45,100]; spisok02             
+[22, 10, 7, 45, 100]
+>>>spisok03=dict(zip(spisok01,spisok02)); spisok03             
+{1: 22, 5: 10, 7: 7, 9: 45, 3: 100}
+
+>>> len(spisok03)           
+5 #Элементов 5, потому что в spisok02 всего пять элементов
+```
+
+Пример словаря с описанием состава студентов, обучающихся на АВТИ:
+
+```py
+AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
+
+AVTI['Курс III'][5]
+15
+```
+
+## 8.4 Множество
+
+__Объект-множество__ – это неупорядоченная совокупность неповторяющихся элементов.
+
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}; mnoz1          
+{'линия связи', 'микропроцессор', 'двигатель', 'датчик'}
+
+>>> len(mnoz1)             
+4
+
+>>> 'датчик' in mnoz1            
+True
+
+>>> mnoz1.add('реле')              
+>>> mnoz1            
+{'линия связи', 'датчик', 'двигатель', 'реле', 'микропроцессор'}
+
+>>> mnoz1.remove('линия связи'); mnoz1             
+{'датчик', 'двигатель', 'реле', 'микропроцессор'}
+```
+
+Создадим своё множество:
+
+```py
+>>> mnoz2={5, 'яблоко', False, (10, 6, 0)}; mnoz2             
+{False, 5, (10, 6, 0), 'яблоко'}
+
+>>> mnoz2.add(100); mnoz2            
+{False, 100, 5, (10, 6, 0), 'яблоко'}
+
+>>> mnoz2.remove('яблоко'); mnoz2             
+{False, 100, 5, (10, 6, 0)}
+
+>>>False in mnoz2            
+True
+```
+
+## 9. Конец сеанса
+

TEMA2/task.md

@@ -0,0 +1,40 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+
+1. Создать переменную с именем familia и со значением - символьной строкой – своей фами-лией в латинской транскрипции.
+2. Создать переменную со значением, совпадающим с первой буквой из familia.
+3. Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+4. Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убе-дитесь, что это значение удалено из списка.
+5. Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напи-шите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+6. Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+7. Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+8. Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам.
+
+
+## Решение
+
+```py
+>>> familia = 'Zelenkina'
+>>> b = familia[0]; b
+'Z'
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw.remove('nonlocal'); sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> sp_kw.count('nonlocal')
+0
+>>> kort_nam = ('Kate', 'Ksenia', 'Nasty', 'Liza')
+>>> type(kort_nam)
+<class 'tuple'>
+>>> kort_nam=kort_nam+('Dana', 'Dima'); kort_nam
+('Kate', 'Ksenia', 'Nasty', 'Liza', 'Dana', 'Dima')
+>>> kort_nam.count('Dima')
+1
+>>> a=['Строка', 'Список', 'Кортеж']
+>>> c = [familia, sp_kw, kort_nam]
+>>> dict_bas = dict(zip(a, c)); dict_bas
+{'Строка': 'Zelenkina', 'Список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'Кортеж': ('Kate', 'Ksenia', 'Nasty', 'Liza', 'Dana', 'Dima')}
+```

TEMA2/task.py

@@ -0,0 +1,14 @@
+familia = 'Zelenkina'
+b = familia[0]; b
+import keyword
+sp_kw = keyword.kwlist
+sp_kw.remove('nonlocal')
+print(sp_kw)
+sp_kw.count('nonlocal')
+kort_nam = ('Kate', 'Ksenia', 'Nasty', 'Liza')
+type(kort_nam)
+kort_nam=kort_nam+('Dana', 'Dima'); kort_nam
+kort_nam.count('Dima')
+a=['Строка', 'Список', 'Кортеж']
+c = [familia, sp_kw, kort_nam]
+dict_bas = dict(zip(a, c)); dict_bas

TEMA2/test.md

@@ -0,0 +1,33 @@
+# Индивидуальное контрольное задание по теме 2
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+
+Предполагается выполнить следующие инструкции:
+```py 
+s=(1,2,3,4,5)
+d=[11,22,33,44,55]
+sd=(s,d)
+```
+Объекты каких классов будут созданы в результате их выполнения? Какое значение будет выведено по инструкции: print(sd[1][3])
+
+## Решение
+
+```py
+s=(1,2,3,4,5)
+d=[11,22,33,44,55]
+sd=(s,d);sd
+((1, 2, 3, 4, 5), [11, 22, 33, 44, 55])
+```
+Будут созданы два кортежа(s,sd) и один список (d):
+
+```py
+type(s), type(d), type(sd)
+(<class 'tuple'>, <class 'list'>, <class 'tuple'>)
+```
+По инструкции "print(sd[1][3])" будет выведено значение "44":
+```py
+print(sd[1][3])
+44
+```

TEMA3/report.md

@@ -0,0 +1,697 @@
+# Отчёт по теме 3
+Зеленкина Катерина Михайловна, А-02-23
+
+## Пункт 1. Запуск оболочки IDLE
+
+Установим рабочий каталог:
+
+```py
+import os
+os.chdir(r'C:\Users\user\python-labs\TEMA3')
+```
+
+## Пункт 2. Простые базовые типы объектов.
+### Пункт 2.1. Логический тип bool.
+
+Воспользумеся функцией __bool__:
+
+```py
+>>> logiz1=bool(56); logiz1
+True
+>>> logiz2=bool(0); logiz2
+False
+>>> logiz3=bool("Beta"); logiz3
+True
+>>> logiz4=bool(""); logiz4
+False
+```
+
+### Пункт 2.2. Преобразование в целое десятичное число.
+Преобразуем с помощью функции __int__:
+
+```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"); tt5
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    tt5=int("98.76"); tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+__Пояснение__: Последняя функция выдаёт ошибку, потому что функция int() работает только с целочисленными строками. Для чисел с плавающей точкой нужно сначала использовать float(), а потом преобразовать в целое число.
+
+#### Функция float
+
+Примеры преобразований:
+
+```py
+>>> flt1=float(789); flt1
+789.0
+>>> flt2=float(-6.78e2); flt2
+-678.0
+>>> flt3=float("Infinity"); flt3
+inf
+>>> flt4=float("-inf"); flt4
+-inf
+```
+
+## Пункт 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.1. Преобразование в строку.
+
+Воспользуемся функцией __str__:
+
+```py
+>>> strk1=str(23.6); strk1
+'23.6'
+>>> strk2=str(logiz3); strk2
+'True'
+>>> strk3=str(["A","B","C"]); strk3
+"['A', 'B', 'C']"
+>>> strk4=str(("A","B","C")); strk4
+"('A', 'B', 'C')"
+>>> strk5=str({"A":1,"B":2,"C":9}); strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+### Пункт 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']
+```
+
+### Пункт 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')
+```
+
+### Пункт 3.4 Удаление объектов.
+
+Воспользуемся функцией __del__:
+
+```py
+>>> del strk5, kort8
+>>> strk5
+Traceback (most recent call last):
+  File "<pyshell#37>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+>>> kort8
+Traceback (most recent call last):
+  File "<pyshell#38>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+#### Создание своей строки.
+
+```py
+>>> a = 'Zelenkina K.M.'
+>>> spisok = list(a); spisok, type(spisok) #Преобразование в список
+(['Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.'], <class 'list'>)
+>>> kort = tuple(spisok); kort; type(kort) #Преобразование в кортеж
+('Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.')
+<class 'tuple'>
+>>> str0 = str(kort); str0; type(str0) #Преобразование в строку
+"('Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.')"
+<class 'str'>
+```
+
+## Пункт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; type(a)  #Деление двух целых чисел
+3.9555555555555557
+<class 'float'>
+```
+
+### Пункт 4.4. Деление с округлением вниз.
+
+```py
+>>> b=178//45; b; type(b) #Деление двух целых чисел
+3
+<class 'int'>
+>>> c=-24.6//12.1; c; type(c) #Деление двух вещественных чисел
+-3.0
+<class 'float'>
+
+>>> f = 100//20.5; f; type(f)
+4.0
+<class 'float'>
+>>> p= 25.3//9; p; type(p)
+2.0
+<class 'float'>
+```
+
+## Пункт 4.5. Остаток от деления.
+
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+
+>>> 45.3%9
+0.29999999999999716
+>>> 70%10.5
+7.0
+```
+
+## Пункт 4.6. Возведение в степень.
+
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6; e
+35.719843790663525
+
+>>> 2.7**3
+19.683000000000003
+>>> 3**2.7
+19.419023519771343
+```
+
+### Операции с комплексными числами.
+
+```py
+>>> k=1+2j
+>>> n=3+4j
+>>> k+n
+(4+6j)
+>>> k-n
+(-2-2j)
+>>> k*n
+(-5+10j)
+>>> k/n
+(0.44+0.08j)
+>>> k//n
+Traceback (most recent call last):
+  File "<pyshell#75>", line 1, in <module>
+    k//n
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+>>> k%n
+Traceback (most recent call last):
+  File "<pyshell#76>", line 1, in <module>
+    k%n
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+__Вывод:__ к комплексным числа нельзя применять деление с округлением вниз и определения остатка
+
+
+## Пункт 5. Операции с двоичными представлениями целых чисел. 
+### Пункт 5.1. Двоичная инверсия.
+
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+
+```py
+>>> dv1=9
+>>> dv2=~dv1; dv2
+-10
+```
+
+### Пункт 5.2. Двоичное «И»
+
+```py
+>>> 7&9
+1
+>>> 7&8
+0
+```
+
+### Пункт 5.3. Двоичное «ИЛИ»
+
+```py
+>>> 7|9
+15
+>>> 7|8
+15
+>>> 14|5
+15
+```
+
+### Пункт 5.4. Двоичное «исключающее ИЛИ»
+
+```py
+>>> 14^5
+11
+>>> bin(11)
+'0b1011' - двоичное
+```
+
+В десятичном представлении получилось число «11»
+
+### Пункт 5.5. Сдвиг двоичного представления
+
+```py
+>>> h=14
+>>> bin(h)
+'0b1110'
+>>> g=h<<2; g; bin(g)
+56
+'0b111000'
+>>> g1=h>>1; g1; bin(g1)
+7
+'0b111'
+>>> g2=h>>2; g2; bin(g2)
+3
+'0b11'
+```
+
+Придумала свои два двоичных знака:
+
+```py
+>>> a = 0b11011011
+>>> b = 0b01101101
+>>> bin(~a); bin(~b)
+'-0b11011100'
+'-0b1101110'
+>>> bin(a&b)
+'0b1001001'
+>>> bin(a|b)
+'0b11111111'
+>>> bin(a^b)
+'0b10110110'
+>>> n=a<<2; n; bin(n)
+876
+'0b1101101100'
+>>> n1=b>>3;n1;bin(n1)
+13
+'0b1101'
+```
+
+## Пункт 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
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+```
+
+Пример. Создание списка со 100 отсчетами сигнала-ступеньки:
+
+```py
+>>> 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 Проверка наличия заданного элемента в последовательности.
+
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka
+True
+>>> 'ку' in ['ку','-']*3
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+
+### Пункт 6.4. Подстановка значений в строку.
+__Пример1__
+
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+__Пример 2.__ Вставка с использованием данных из словаря.
+
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+## Пункт 7.Оператор присваивания
+### Пункт 7.1. Обычное присваивание значения переменной (=)
+
+```py
+>>> zz=-12; zz
+-12
+```
+
+### Пункт 7.2. Увеличение (+=) или уменьшение (-=)
+```py
+>>> zz+=5; zz
+-7
+>>> zz-=3;zz
+-10
+```
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+
+```py
+>>> stroka='Система'
+>>> stroka+=' регулирования'; stroka
+'Система регулирования'
+```
+
+### Пункт 7.3. Умножение (*=) или деление (/=)
+
+```py
+>>> zz/=2; zz
+-5.0
+>>> zz*=5; zz
+-25.0
+```
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз:
+
+```py
+>>> stroka='Арбуз'
+>>> stroka*=4; stroka
+'АрбузАрбузАрбузАрбуз'
+```
+### Пункт 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) 
+
+```py
+>>> zz=10
+>>> zz//=4; zz #округление вниз
+2
+>>> zz%=6; zz #остаток от деления
+2
+>>> zz**=2;zz #возведение в степень
+4
+```
+
+### Пункт 7.5. Множественное присваивание
+
+```py
+>>> w=v=10; w; v
+10
+10
+>>> n1,n2,n3=(11,-3,'all'); n1;n2;n3
+11
+-3
+'all'
+```
+
+```py
+>>> n1,n2,n3='yes'; n1;n2;n3
+'y'
+'e'
+'s'
+
+>>> n1,n2,n3=[11,-3,'all']; n1;n2;n3
+11
+-3
+'all'
+
+>>> n1,n2,n3 = {'a1': 11, 'a2': -3, 'stroke': 'all'}; n1; n2; n3 #берутся ключи
+'a1'
+'a2'
+'stroke'
+
+>>> n = {'a1': 11, 'a2': -3, 'a3': 'all'}
+>>> n1,n2,n3=n.values(); n1;n2;n3
+11
+-3
+'all'
+
+>>> n1,n2,n3 = {11, -3, 'all'}; n1;n2;n3
+11
+'all'
+-3
+```
+
+## Пункт 8. Логические операции 
+### Пункт 8.1. Операции сравнение
+
+```py
+>>> w
+10
+>>> v
+10
+>>> w==v
+True
+>>> z=8
+>>> w!=z
+True
+>>> v<z
+False
+>>> w>z
+True
+>>> v<=z
+False
+>>> w>=z
+True
+```
+
+### Пунтк 8.2. Проверка наличия заданного элемента
+Операции с множеством:
+```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. Большие логические выражения
+
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Придумала ещё 2 примера:
+```py
+>>> (a>b) and ('Piter' in dic1) and not ('pen' in mnoz1)
+False
+>>> not (a==b) and ('table' in mnoz1) and (b<a)
+True
+```
+
+### Пункт 8.4. Проверка ссылок 
+
+```py
+>>> w=v=10 
+>>> w is v
+True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1 is v1
+False 
+```
+
+## Пункт 9. Операции с объектами с помощью методов
+
+```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('пр') 
+5
+>>> stroka.count("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' '); spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22); stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")  
+('Микропроцессорная си', 'с', 'тема управления')
+```
+#### Метод format
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+### 9.2. Методы для работы со списками
+
+```py
+>>> spsk=[1,10,'bob',['a','b','c'],'hehe']; spsk
+[1, 10, 'bob', ['a', 'b', 'c'], 'hehe']
+>>> spsk.pop(2)
+'bob'
+>>> spsk
+[1, 10, ['a', 'b', 'c'], 'hehe']
+>>> spsk.append('c'); spsk
+[1, 10, ['a', 'b', 'c'], 'hehe', 'c']
+>>> spsk.insert(2,'a'); spsk
+[1, 10, 'a', ['a', 'b', 'c'], 'hehe', 'c']
+>>> spsk.count('a')
+1
+```
+
+### 9.3. Методы с кортежами
+
+```py
+>>> kor = ('sweets', 56, 'hehe', [3,2,1], 120); kor; type(kor)
+('sweets', 56, 'hehe', [3, 2, 1], 120)
+<class 'tuple'>
+>>> dir(kor)
+['__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']
+>>> kor.count('hehe')
+1
+>>> kor.index(56)
+1
+>>> kor +=(10, 'home'); kor
+('sweets', 56, 'hehe', [3, 2, 1], 120, 10, 'home')
+>>>type(kor)
+<class 'tuple'>
+```
+
+### 9.4. Методы со словарями и множествами
+#### 9.4.1. Методы со словарями
+
+```py
+sl = {'Gorod':'Moscow', 'Name': 'Katy', 'Age':19}; type(sl)
+<class 'dict'>
+dir(sl)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+sl.pop('Gorod')
+'Moscow'
+sl
+{'Name': 'Katy', 'Age': 19}
+sl.keys()
+dict_keys(['Name', 'Age'])
+sl.items()
+dict_items([('Name', 'Katy'), ('Age', 19)])
+sl.update({'Like': 'eat', 'Money':2000}); sl
+{'Name': 'Katy', 'Age': 19, 'Like': 'eat', 'Money': 2000}
+sl.values()
+dict_values(['Katy', 19, 'eat', 2000])
+```
+#### 9.4.2. Методы со множествами
+
+```py
+>>> mnoch={1,2,3,4,5,'a'}
+>>> type(mnoch)
+<class 'set'>
+>>> mnoch.add('hehe'); mnoch
+{1, 2, 3, 4, 5, 'a', 'hehe'}
+>>> mnoch.remove(1);mnoch
+{2, 3, 4, 5, 'a', 'hehe'}
+>>> mnoch1={'l','k',60}
+>>> mnoch2=mnoch.union(mnoch1);mnoch2
+{2, 3, 4, 5, 'a', 'k', 'hehe', 60, 'l'}
+```
+
+## Пункт 10. Закончила сеанс работы с IDLE

TEMA3/task.md

@@ -0,0 +1,58 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности ин-струкций, выполняющих следующие действия:
+1. Преобразовать восьмеричное значение 45 в целое число.
+2. Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная вре-мени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+3. Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+4. Напишите и выполните единое выражение, последовательно осуществляющее следующие опе-рации: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+5. Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+6. Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов.
+7. Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+
+```py
+>>> a='45'
+>>> int(a,8)
+37
+
+>>> D = {"усиление":23, "запаздывание":12, "постоянная вре-мени":78}
+>>> keys = list(D.keys());keys
+['усиление', 'запаздывание', 'постоянная вре-мени']
+>>> values = list(D.values()); values
+[23, 12, 78]
+
+>>> M= tuple(keys + values); M
+('усиление', 'запаздывание', 'постоянная вре-мени', 23, 12, 78)
+
+>>> ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+
+>>> ((~(13 & 27)) ^ 14) << 2
+-32
+
+>>> sp = ['колебат'] * 4; sp
+['колебат', 'колебат', 'колебат', 'колебат']
+>>> 'аткол' in sp[1]+sp[2]
+True
+
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная вре-мени'])
+>>> D.values()
+dict_values([23, 12, 78])
+
+>>> s='Создать объект - символьную строку с текстом данного предложения'
+>>> s1=s.split();s1
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+
+>>> s1[s1.index('-')]=','; s1
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+
+>>> s1.remove('данного');s1
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/task.py

@@ -0,0 +1,17 @@
+a='45'
+print(int(a,8))
+D = {"усиление":23, "запаздывание":12, "постоянная вре-мени":78}
+keys = list(D.keys())
+print(keys)
+values = list(D.values()); print(values)
+M= tuple(keys + values); print(M)
+print(((1768 // 24.8) % 3) ** 2.4)
+print(((13 & 27) ^ 14) << 2)
+sp = ['колебат'] * 4; print(sp)
+print('аткол' in sp[1]+sp[2])
+print(D.keys())
+print(D.values())
+s='Создать объект - символьную строку с текстом данного предложения'
+s1=s.split(); print(s1)
+s1[s1.index('-')]=','; print(s1)
+s1.remove('данного'); print(s1)

TEMA3/test.md

@@ -0,0 +1,53 @@
+# Индивидуальное контрольное задание по теме 2
+
+Зеленкина Катерина, А-02-23
+Вариант 8
+
+## Задание
+
+1. При каких условиях можно создавать программы для среды Python с помощью других текстовых редакторов? Назовите примеры таких редакторов.
+2. Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов.
+3. Создайте кортеж, содержащий слова из итогового созданного объекта в п.2. Напишите инструкции подсчета числа слов и отобразите с использованием формата результат на экране по шаблону: "в кортеже ХХ элементов".
+4. Напишите инструкции создания словаря, в котором ключами будут порядковые номера, а значениями - слова из кортежа, созданного в п.3.
+5. Преобразуйте значения из словаря во множество. Подсчитайте и выведите на экран число элементов этого множества. 
+
+## Решение
+#### Пункт 1.
+1. Программы для среды Python можно создавать в любых текстовых редакторах при условии сохранения файла с расширением .py. Например: Блокнот, Notepad++ и др.
+
+```py
+#Пункт 2.
+
+>>> text = "Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов."
+
+>> slova = text.split(); slova
+['Создайте', 'объект,', 'содержащий', 'текст', 'задания', 'данного', 'пункта.', 'Создайте', 'новый', 'объект,', 'в', 'который', 'включите', 'из', 'первого', 'объекта', 'только', 'слова,', 'находящиеся', 'на', 'четных', 'позициях.', 'Напишите', 'инструкции', 'определения', 'класса', 'созданного', 'объекта', 'и', 'списка', 'его', 'атрибутов.']
+>>> p = slova[1::2]
+['объект,', 'текст', 'данного', 'Создайте', 'объект,', 'который', 'из', 'объекта', 'слова,', 'на', 'позициях.', 'инструкции', 'класса', 'объекта', 'списка', 'атрибутов.']
+>>> text1 = ' '.join(p); text1
+'объект, текст данного Создайте объект, который из объекта слова, на позициях. инструкции класса объекта списка атрибутов.'
+
+>>> type(text1)
+<class 'str'>
+>>> dir(text1)
+['__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']
+
+
+#Пункт 3.
+>>> cort=tuple(slova); cort
+('Создайте', 'объект,', 'содержащий', 'текст', 'задания', 'данного', 'пункта.', 'Создайте', 'новый', 'объект,', 'в', 'который', 'включите', 'из', 'первого', 'объекта', 'только', 'слова,', 'находящиеся', 'на', 'четных', 'позициях.', 'Напишите', 'инструкции', 'определения', 'класса', 'созданного', 'объекта', 'и', 'списка', 'его', 'атрибутов.')
+>> len(cort)
+32
+>>> "в кортеже {} элемента".format(len(cort))
+'в кортеже 32 элемента'
+
+# Пункт 4. 
+slovar = dict(zip(range(1, len(cort)+1), cort)); slovar
+{1: 'Создайте', 2: 'объект,', 3: 'содержащий', 4: 'текст', 5: 'задания', 6: 'данного', 7: 'пункта.', 8: 'Создайте', 9: 'новый', 10: 'объект,', 11: 'в', 12: 'который', 13: 'включите', 14: 'из', 15: 'первого', 16: 'объекта', 17: 'только', 18: 'слова,', 19: 'находящиеся', 20: 'на', 21: 'четных', 22: 'позициях.', 23: 'Напишите', 24: 'инструкции', 25: 'определения', 26: 'класса', 27: 'созданного', 28: 'объекта', 29: 'и', 30: 'списка', 31: 'его', 32: 'атрибутов.'}
+
+# Пункт 5.
+>>> mnoz = set(slovar.values()); mnoz
+{'находящиеся', 'позициях.', 'на', 'и', 'его', 'текст', 'созданного', 'слова,', 'инструкции', 'объекта', 'в', 'определения', 'задания', 'списка', 'из', 'первого', 'пункта.', 'содержащий', 'включите', 'данного', 'новый', 'который', 'Создайте', 'только', 'четных', 'атрибутов.', 'Напишите', 'объект,', 'класса'}
+>>> len(mnoz)
+29
+```

TEMA3/test.py

@@ -0,0 +1,12 @@
+text = "Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов."
+slova = text.split(); print(slova)
+p = slova[1::2]
+text1 = ' '.join(p); print(text1)
+print(type(text1))
+print(dir(text1))
+cort=tuple(slova); print(cort)
+print(len(cort))
+print("в кортеже {} элемента".format(len(cort))) 
+slovar = dict(zip(range(1, len(cort)+1), cort)); print(slovar)
+mnoz = set(slovar.values()); print(mnoz)
+print(len(mnoz))

TEMA4/report.md

@@ -0,0 +1,378 @@
+# Отчёт по теме 4
+Зеленкина Катерина Михайловна, А-02-23
+
+## Пункт 1. Запуск IDLE
+## Пункт 2. Стандартные функции
+### Пункт 2.1. Функция round 
+__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.
+
+>>> a=round(123.456,1); a; type(a)
+123.5
+<class 'float'>
+>>> b=round(123.456,0); b; type(b)
+123.0
+<class 'float'>
+```
+__Пояснение:__ Разница только в количестве знаков после запятой в результате (в первом - до 1 десятичного знака, во-втором - до 0), но тип данных одинаковый
+
+```py
+>>> c=round(123.456); c; type(c)
+123
+<class 'int'>
+```
+__Пояснение:__ Произошло округление до целого, и сохранился в "int"
+
+## Пункт 2.2. Функция range 
+__range__ - создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+
+```py
+>>> gg=range(76,123,9); gg #генерирует числа с 76 до 123 (пока не будет больше/равно) с шагом 9
+range(76, 123, 9)
+>>> type(gg)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23) #Будет последовательность от 0 до 22 включительно с шагом 1
+range(0, 23)
+```
+
+## Пункт 2.3. Функция zip 
+__zip__ - создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей
+
+```py
+>>> qq=["Зеленкина", "Криви", "Цветкова", "Коломейцев"]
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> ff=zip(gg,qq); ff
+<zip object at 0x0000020E046D74C0>
+>>> type(ff)
+<class 'zip'>
+>>> tuple(ff)
+((76, 'Зеленкина'), (85, 'Криви'), (94, 'Цветкова'), (103, 'Коломейцев'))
+>>> ff[0]
+Traceback (most recent call last):
+  File "<pyshell#175>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+>>> ff_list= list(zip(gg, qq)); ff_list[0]
+(76, 'Зеленкина')
+```
+
+### Пункт 2.4. Функция eval 
+__eval__ - вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки
+
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=20
+>>> dan
+-56.0
+```
+
+### Пункт 2.5. Функция exec
+
+__exec__ - чтение и выполнение объекта-аргумента функции.
+
+```py
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+
+### Пункт 2.6. Самостоятельное применение функций
+
+```py
+>>> abs(-100)
+100
+
+>>> pow(5,2)
+25
+
+>>> max(1,2,3,4,199, 13)
+199
+
+>>> min(4,5,-10,-3,2)
+-10
+
+>>> sum([4,8,3])
+15
+
+>>> divmod(8,2)
+(4, 0)
+
+>>> len('Привет, друг!')
+13
+
+>>> n=[10,20,30,45]
+>>> map(str,n)
+<map object at 0x0000020E046CB100>
+>>> list(map(str,n))
+['10', '20', '30', '45']
+```
+## Пункт 3. Функции из стандартного модуля math 
+
+```py
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+```
+Функции модуля: sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi:
+
+```py
+>>> math.sin(45)
+0.8509035245341184
+>>> math.acos(0.8509035245341184)
+0.553093477052002
+>>> math.degrees(180)
+10313.240312354817
+>>> math.exp(1)
+2.718281828459045
+>>> math.log(10)
+2.302585092994046
+>>> math.log(4,2)
+2.0
+>>> math.log10(10)
+1.0
+>>> math.sqrt(16)
+4.0
+>>> math.ceil(10.8)
+11
+>>> math.ceil(-10.8)
+-10
+>>> math.floor(5.5)
+5
+>>> math.pi
+3.141592653589793
+```
+
+## Пункт 4. Функции из модуля cmath 
+Cовокупность функций для работы с комплексными числами.
+
+```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
+Cовокупность функций для выполнения операций с псевдослучайными числами и выборками.
+
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>> random.seed()
+
+>>> random.seed(52)
+>>> random.random()
+0.9783548583709967
+>>> random.uniform(1, 5)
+1.2180906200418296
+>>> random.randint(1, 10)
+9
+>>> random.gauss(0, 2)
+-4.744196627534718
+>>> a=[15,6,8,10]
+>>> random.shuffle(a); a
+[8, 6, 15, 10]
+>>> random.sample(range(10), 2)
+[7, 0]
+>>> random.sample(range(10), 3)
+[0, 8, 6]
+>>> random.betavariate(3, 2)
+0.7782580563898469
+>>> random.gammavariate(3, 2)
+7.541042451721967
+```
+
+Создайте список с 4 случайными значениями^
+
+```py
+>>> r = [random.uniform(0, 20), random.gauss(13, 33),
+random.betavariate(5, 15), random.gammavariate(9, 2)]; r
+[9.981907966137051, 20.964805026393023, 0.13659209100569777, 10.30243231589178]
+```
+## Пункт 6. Функции из модуля time
+Работа с календарем и со временем.
+
+```py
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+
+>>> c1=time.time(); c1
+1759666696.7083006
+>>> c2=time.time()-c1; c2
+15.599524736404419
+
+>>> dat=time.gmtime(); dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=12, tm_min=20, tm_sec=10, tm_wday=6, tm_yday=278, tm_isdst=0)
+>>>dat.tm_mon
+10
+>>> dat.tm_year
+2025
+>>> dat.tm_mday
+5
+>>> dat.tm_hour
+12
+>>> dat.tm_min
+20
+>>> dat.tm_sec
+10
+>>> dat.tm_wday
+6
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=15, tm_min=23, tm_sec=36, tm_wday=6, tm_yday=278, tm_isdst=0)
+>>> time.asctime()
+'Sun Oct  5 15:23:46 2025'
+>>> time.ctime()
+'Sun Oct  5 15:23:52 2025'
+>>> time.sleep(3)
+
+>>> t=(2025, 10, 5, 15, 23, 36, 6, 278, 0)
+>>> obj= time.struct_time(t); obj
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=15, tm_min=23, tm_sec=36, tm_wday=6, tm_yday=278, tm_isdst=0)
+>>> s=time.mktime(obj);s
+1759667016.0
+>>> back=time.localtime(s);back
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=5, tm_hour=15, tm_min=23, tm_sec=36, tm_wday=6, tm_yday=278, tm_isdst=0)
+```
+
+## Пункт 7. Графические функции
+
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000001FA91846350>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show()
+```
+
+![Скриншот графика1](график1.png)
+
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000001FA92FFED50>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000001FA92FFEE90>]
+>>> pylab.show()
+```
+
+![Скриншот графика2](график2.png)
+
+#### Построение круговой диаграммы
+
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000001FA918016A0>, <matplotlib.patches.Wedge object at 0x000001FA9257CB90>, <matplotlib.patches.Wedge object at 0x000001FA9257CF50>, <matplotlib.patches.Wedge object at 0x000001FA9257D1D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+![Скриншот графика3](график3.png)
+
+#### Гистограммы и столбиковые диаграммы 
+Построим гистограмму:
+```py
+>>> import matplotlib.pyplot as plt
+>>> ocenki = [3, 4, 4, 5, 5, 5, 4, 3, 5, 4, 5, 5, 4, 3]
+>>> plt.hist(ocenki, color='orange', edgecolor='black')
+(array([3., 0., 0., 0., 0., 5., 0., 0., 0., 6.]), array([3. , 3.2, 3.4, 3.6, 3.8, 4. , 4.2, 4.4, 4.6, 4.8, 5. ]), <BarContainer object of 10 artists>)
+>>> plt.title('Распределение оценок в классе')
+Text(0.5, 1.0, 'Распределение оценок в классе')
+>>> plt.xlabel('Оценки')
+Text(0.5, 0, 'Оценки')
+>>> plt.ylabel('Количество учеников')
+Text(0, 0.5, 'Количество учеников')
+>>> plt.show()
+```
+![Скриншот графика4](график4.png)
+
+Построим столбиковую диаграмму:
+```py
+>>> name = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт']
+>>> number = [10, 25, 15, 30, 20]
+>>> plt.bar(name, number, color='skyblue')
+<BarContainer object of 5 artists>
+>>> plt.title('Моя диаграмма')
+Text(0.5, 1.0, 'Моя диаграмма')
+>>> plt.xlabel('Дни недели')
+Text(0.5, 0, 'Дни недели')
+>>> plt.ylabel('Значения')
+Text(0, 0.5, 'Значения')
+>>> plt.show()
+```
+![Скриншот графика5](график5.png)
+
+## Пункт 8. Состав модуля statistics
+
+```py
+>>> import statistics
+>>> g = [45, 50, 55, 60, 65, 70, 75, 80, 85, 200]
+>>> mean = statistics.mean(g); mean
+78.5
+>>> mode = statistics.mode(g); mode
+45
+>>>stdev = statistics.stdev(g); stdev
+44.60007473835292
+>>> variance = statistics.variance(g); variance
+1989.1666666666667
+>>> quantiles = statistics.quantiles(g, n=4); quantiles
+[53.75, 67.5, 81.25]
+>>> harmonic_mean = statistics.harmonic_mean(g); harmonic_mean
+66.96171069719155
+```
+
+## Пунтк 9. Завершение сеанса IDLE

TEMA4/task.md

@@ -0,0 +1,56 @@
+# Общее контрольное задание
+
+Зеленкина Катерина, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности ин-струкций, выполняющих следующие действия:
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следу-ющих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух зна-чений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из это-го списка с тремя днями недели. 
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+>>> import math
+>>> import cmath
+>>> import time
+>>> import random
+>>> import string
+>>> import statistics
+
+>>> divmod(((round(cmath.phase(0.2+0.8j),2)) * 20),3)
+(8.0, 2.6000000000000014)
+
+>>> msc_time = time.gmtime(time.time() + 3 * 3600);msc_time
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=31, tm_sec=45, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> hm=(f'{msc_time.tm_hour}:{msc_time.tm_min}'); hm
+'10:31'
+
+
+>>> wd = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+>>> p = random.sample(wd, 3); p
+['Суббота', 'Среда', 'Понедельник']
+
+>>> k = list(range(14, 33, 3)); k
+[14, 17, 20, 23, 26, 29, 32]
+>>> rand = random.choice(k);rand
+14
+
+>>> N = round(random.gauss(15, 4)); N
+14
+>>> p=random.sample(string.ascii_letters, N); p
+['s', 'h', 'd', 'L', 'i', 'C', 'z', 'P', 'k', 'y', 'D', 'l', 'H', 'Z']
+
+>>> c = time.time()+3*3600;c
+1760912196.5972443
+>>> inter_sec = c - time.mktime(msc_time);inter_sec
+11362.597244262695
+>>> inter_min = round(inter_sec / 60, 2); inter_min
+189.38
+```
+
+

TEMA4/task.py

@@ -0,0 +1,27 @@
+import math
+import cmath
+import time
+import random
+import string
+import statistics
+print(divmod(((round(cmath.phase(0.2+0.8j),2)) * 20),3))
+msc_time = time.gmtime(time.time() + 3 * 3600);msc_time
+hm=(f'{msc_time.tm_hour}:{msc_time.tm_min}')
+print(hm)
+wd = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+p = random.sample(wd, 3);
+print(p)
+k = list(range(14, 33, 3))
+print(k)
+rand = random.choice(k)
+print(rand)
+N = round(random.gauss(15, 4))
+print(N)
+p=random.sample(string.ascii_letters, N)
+print(p)
+c = time.time()+3*3600
+print(c)
+inter_sec = c - time.mktime(msc_time)
+print(inter_sec)
+inter_min = round(inter_sec / 60, 2)
+print(inter_min)

TEMA4/test.md

@@ -0,0 +1,31 @@
+# Индивидуальное контрольное задание по теме 4
+
+Зеленкина Катерина, А-02-23
+Вариант 4
+
+## Задание
+Создайте список с 20 случайными, нормально распределенными (математическое ожидание равно 3400, стандартное отклонение равно 121) числами. Рассчитайте по нему среднее значение и число элементов, значение которых превышает это среднее.
+
+## Решение
+
+```py
+import random
+import statistics
+sps = []
+for i in range(20):
+    a = random.gauss(3400, 121)
+    sps.append(a) 
+print('Список: ', sps)
+sr = statistics.mean(sps)
+print('Среднее значение: ', sr)
+i=0
+for el in sps:
+    if el>sr:
+        i+=1
+print('Кол-во элементов больше среднего: ', i)
+
+
+Список:  [3497.797538406104, 3267.084579757765, 3433.5344588585167, 3467.31945703132, 3219.709391355155, 3319.3524633811053, 3247.9415423402065, 3396.8815287460775, 3510.7463491419835, 3307.80163577245, 3277.148366159288, 3409.7495053002212, 3474.074399355259, 3471.4930101011246, 3433.352490022768, 3509.521992706484, 3145.302863435359, 3359.933986462906, 3455.6657952685296, 3525.085510243645]
+Среднее значение:  3386.4748431923135
+Кол-во элементов больше среднего:  12
+```

TEMA4/test.py

@@ -0,0 +1,14 @@
+import random
+import statistics
+sps = []
+for i in range(20):
+    a = random.gauss(3400, 121)
+    sps.append(a) 
+print('Список: ', sps)
+sr = statistics.mean(sps)
+print('Среднее значение: ', sr)
+i=0
+for el in sps:
+    if el>sr:
+        i+=1
+print('Кол-во элементов больше среднего: ', i)