testmodul

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Туровец Евгений
+print ('hello!')
+h=input ('Your name = ')
+import os
+os.chdir(r'C:\Users\Evgeny\Desktop\python-labs\TEMA1')

TEMA1/lb1.md

@@ -0,0 +1,31 @@
+# Отчёт по теме 1
+
+Туровец Евгений Юрьевич
+
+## 1-2 Запуск
+
+Была запущена программа-интерпретатор:
+![1-2](1-2.png)
+
+## 3-5. Диалоговое окно
+
+Ввели несколько команд в окно интерпретатора:
+```py
+>>> print ('Hello!')
+Hello!
+>>> h=input('Your name = ')
+Your name = Evgeny
+>>> exit() - закрывает окно интерпретатора
+```
+## 6-7. Интерактивная графическая оболочка IDLE и её устройство
+
+Было изучено устройство главного командного окна среды
+![6-7](6-7.png)
+
+## 8. Настройка рабочего каталога.
+
+```py
+import os
+os.chdir(r'C:\Users\Evgeny\Desktop\python-labs\TEMA1')
+```
+

TEMA1/report.md

@@ -0,0 +1,161 @@
+# Отчёт по теме 1
+
+Туровец Евгений Юрьевич
+
+## 1-2 Запуск
+
+Была запущена программа-интерпретатор:
+![1-2](1-2.png)
+
+## 3-5. Диалоговое окно
+
+Ввели несколько команд в окно интерпретатора:
+```py
+>>> print ('Hello!')
+Hello!
+>>> h=input('Your name = ')
+Your name = Evgeny
+>>> exit() - закрывает окно интерпретатора
+```
+## 6-7. Интерактивная графическая оболочка IDLE и её устройство
+
+Было изучено устройство главного командного окна среды
+![6-7](6-7.png)
+
+## 8. Настройка рабочего каталога.
+
+```py
+import os
+os.chdir(r'C:\Users\Evgeny\Desktop\python-labs\TEMA1')
+```
+## 9. Персонализация среды.
+
+Я настроил размер шрифта, размер начального окна, темную тему приложения и цвет комментариев
+
+![](9.1.png)
+![](9.2.png)
+![](9.3.png)
+![](9.4.png)
+
+## 10. Окно редактора
+
+###Воспользуемся окном редактора для написания кода.
+
+1) Запишим в редактор код, который мы использовали ранее
+2) Запустим выполнение программы с помощью f5
+3) Сохраним нашу программу в рабочий каталог
+4) Получаем результат
+
+![](10.png)
+
+также рассмотрим другие варианты запуска компиляции:
+import Pr0.py 
+Через меню редатора - Run module
+
+## 11. Запуск prb1
+
+```py
+import prb1
+Как Вас зовут? Evgeny
+Привет, Evgeny
+```
+## 12-13. Просмотр каталога _pycache_
+
+###При открытии файла находящего в каталоге мы наблюдаем следующие кракозябры:
+
+у
+
+    BоєhJ   г                   у&   • \ " S 5
      r
\" S
\
5        g)u   Как Вас Р·РѕРІСѓС‚? u
+   Привет,N)ЪinputЪnameЪprint© у    Ъ1C:\Users/Evgeny/Desktop/python-labs/TEMA1\prb1.pyЪ<module>r   
   s   р


ЩР
+)У*ЂЩ ЂoђtХ r   
+
+Разберемся что всё это значит:
+Заголовок - BоєhJ   г                   у&   • \ " S 5
      r
\" S
\
5        g)u   Как Вас Р·РѕРІСѓС‚? u
+BоєhJ - идентификатор версии python, далее таймстамп последнего изменения и размер исходного файла
+
+u Как Вас зовут? 
+u Привет, - закодированные строки программы, которые декадируются как "Как Вас зовут?" и "Привет,"
+
+ЪinputЪnameЪprint - имена функций и переменных (input,name, print)
+
+Ъ1C:\Users/Evgeny/Desktop/python-labs/TEMA1\prb1.py - пусть к исходному файлу prb1.py
+
+.рус файлы нужны для экономии времени на компиляцию (при первом запуске питон компилирует код в байт-код для ВМ,
+ а при повторном запуске использует готовый байт-файл
+
+## 14. Вызов раздела помощи
+
+```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.
+
+Также были рассмотрены другие способы получения раздела помощи.
+
+## 15. Перемещение между окнами
+
+### 15.1 Открыт prb1.py
+
+### 15.2 Перемещение меж окнами
+
+### 15.3 Запуск программы из окна редактора:
+
+==================== RESTART: C:\Users\Evgeny\Desktop\python-labs\TEMA1\prb1.py ====================
+Как Вас зовут? Evgeny
+Привет, Evgeny
+
+### 15.4 Была запущена программа tdemo_chaos
+
+![](15.4.png)
+
+### 15.5 Рассмотрение примеров использования графической составляющией среды Python
+
+![](15.5.png)
+
+Данные примеры способны помочь в плане структуризации собственного кода и изучении новых команд.
+
+## 16. Выход из среды

TEMA2/report.md

@@ -0,0 +1,935 @@
+# Отчет по теме 2
+
+Туровец Евгений, А-02-23
+
+## 1. Запуск.
+
+### 1.1 Запуск оболочки IDLE и установка рабочего каталога.
+
+```py
+import os
+os.chdir('C:\Program Files (x86)\учёха 3 курс\pythonsky\python-labs\TEMA2')
+```
+
+![](1.png)
+
+### 1.2 Текстового редактора и его сохранение в рабочий каталог
+
+![](1.2.png)
+
+В дальнейшем мы будем прописывать инстукции в данный текстовый редактор
+
+## 2. Изучение простых объектов.
+
+### 2.1 Операции присваивания
+
+познакомимся с операциями присваивания и выводом их значений
+
+```py
+f1=16; f2=3
+f1,f2
+```
+Вывод:
+```
+(16, 3)
+```
+```py
+f1;f2
+
+```
+Вывод:
+```
+16
+3
+```
+### 2.2 Функция dir()
+
+Познакомимся с функцией dir(), которая выводит объекты, уже существующие в среде питона
+```py
+dir()
+
+```
+Вывод:
+```
+['__annotations__', '__builtins__', '__doc__', '__file__',
+ '__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__', '__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']
+```
+
+### 2.3 Функция type()
+
+Для определения класса объекта воспользуемся функцией type()
+
+```py
+type(f1)
+```
+Вывод:
+```
+<class 'int'>
+```
+
+### 2.4 Функция del()
+
+Удалим переменные f1, f2:
+
+```py
+del f1,f2
+dir()
+```
+Вывод:
+```
+['__annotations__', '__builtins__', '__doc__', '__file__',
+ '__loader__', '__name__', '__package__', '__spec__']
+```
+Как мы видим, переменных f1,f2 нет в памяти
+
+## 3-4. Правила именования и сохранение списка под именем:
+
+Были введены некоторые предложенные команды, две из которых не соответствовали правилам именования:
+
+![](3.png)
+
+В первом случае получаем ошибку синтаксиса, т.к переменная начинается с цифры,
+а во втором т.к нейминг переменной совпадает с ключевым словом
+
+Создадим список и запишем его в переменную a
+![](4.png)
+
+## 5. Встроенные идентификаторы.
+
+### 5.1  Вывод списка встроенных идентификаторов:
+
+![](5.1.png)
+
+### 5.2 Изучение назначения функций:
+
+#### 5.2.1 Функция ABS:
+
+![](abs.png)
+
+#### 5.2.2 Функция len:
+
+Создадиим последовательность чисел от 0 до 99, чтобы понять функционал len()
+
+![](len.png)
+
+На выводе получаем длину последовательности
+
+#### 5.2.3 Функция max,min
+
+![](minmax.png)
+
+#### 5.2.4 Функция pow
+
+![](pow.png)
+
+#### 5.2.5 Функция round
+
+![](round.png)
+
+#### 5.2.6 Функция sorted
+
+![](sorted.png)
+
+#### 5.2.7 Функция sum
+
+![](sum.png)
+
+#### 5.2.8 Функция zip
+
+![](zip.png)
+ 
+Функция zip() объединяет несколько интегрируемых объектов в кортежи,
+но т.к функция возвращает итератор, то чтобы увидеть результат - нужно перобразовать его в список
+
+## 6. Типы объектов.
+
+![](6.png)
+
+## 7. Изучение базовых типов объектов:
+
+int — целые числа (положительные, отрицательные или нуль).
+float — числа с плавающей точкой (дробные числа).
+complex — комплексные числа (имеют действительную и мнимую части).
+str — строковый тип данных для хранения текстовой информации. Строка может содержать буквы, цифры, пробелы, символы.
+bool в Python — это логический тип, принимать только два значения: True и False.
+
+### 7.1 Логический тип:
+
+![](7.1.png)
+
+### 7.2 Иные простые типы:
+
+![](7.2.png)
+
+### 7.3 Строка символов:
+
+Одинарные и двойные ковычки несут один и тот же смысл
+
+Чтобы изменить вывод теста можно использовать "экранированные последовательности"
+
+![](7.3.png)
+
+#### Создадим строку по шаблону:
+
+```py
+ss1b= 'Меня зовут: \n Туровец Е.Ю'
+print(ss1b)
+```
+Вывод:
+
+```
+Меня зовут: 
+ Туровец Е.Ю
+```
+#### Создадим строку со значением объекта при помощи тройных кавычек:
+
+![](7.4.png)
+
+При выводе такой строки не будет появлятьс символ приглашения - >>> , до следующего вводв тройных кавычек.
+
+#### К элементам строки можно обращаться используя индексацию:
+
+![](7.5.png)
+
+Можно также делать срезы текста
+
+![](7.6.png)
+
+![](7.7.png)
+
+В данном случае 17 можно заменить на -4, т.к это тот же элемент, если считать с конца
+
+![](7.8.png)
+
+В таком случае мы переопределяем элемент по индексом 4
+
+Сделаем срез текста присвоенного переменной ss1b:
+
+![](7.9.png)
+
+## 8. Списки, кортежи, словари и множества.
+
+```py
+help(list)
+```
+Вывод:
+```
+Help on class list in module builtins:
+
+class list(object)
+ |  list(iterable=(), /)
+ |
+ |  Built-in mutable sequence.
+ |
+ |  If no argument is given, the constructor creates a new empty list.
+ |  The argument must be an iterable if specified.
+ |
+ |  Methods defined here:
+ |
+ |  __add__(self, value, /)
+ |      Return self+value.
+ |
+ |  __contains__(self, key, /)
+ |      Return bool(key in self).
+ |
+ |  __delitem__(self, key, /)
+ |      Delete self[key].
+ |
+ |  __eq__(self, value, /)
+ |      Return self==value.
+ |
+ |  __ge__(self, value, /)
+ |      Return self>=value.
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __getitem__(self, index, /)
+ |      Return self[index].
+ |
+ |  __gt__(self, value, /)
+ |      Return self>value.
+ |
+ |  __iadd__(self, value, /)
+ |      Implement self+=value.
+ |
+ |  __imul__(self, value, /)
+ |      Implement self*=value.
+ |
+ |  __init__(self, /, *args, **kwargs)
+ |      Initialize self.  See help(type(self)) for accurate signature.
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __le__(self, value, /)
+ |      Return self<=value.
+ |
+ |  __len__(self, /)
+ |      Return len(self).
+ |
+ |  __lt__(self, value, /)
+ |      Return self<value.
+ |
+ |  __mul__(self, value, /)
+ |      Return self*value.
+ |
+ |  __ne__(self, value, /)
+ |      Return self!=value.
+ |
+ |  __repr__(self, /)
+ |      Return repr(self).
+ |
+ |  __reversed__(self, /)
+ |      Return a reverse iterator over the list.
+ |
+ |  __rmul__(self, value, /)
+ |      Return value*self.
+ |
+ |  __setitem__(self, key, value, /)
+ |      Set self[key] to value.
+ |
+ |  __sizeof__(self, /)
+ |      Return the size of the list in memory, in bytes.
+ |
+ |  append(self, object, /)
+ |      Append object to the end of the list.
+ |
+ |  clear(self, /)
+ |      Remove all items from list.
+ |
+ |  copy(self, /)
+ |      Return a shallow copy of the list.
+ |
+ |  count(self, value, /)
+ |      Return number of occurrences of value.
+ |
+ |  extend(self, iterable, /)
+ |      Extend list by appending elements from the iterable.
+ |
+ |  index(self, value, start=0, stop=9223372036854775807, /)
+ |      Return first index of value.
+ |
+ |      Raises ValueError if the value is not present.
+ |
+ |  insert(self, index, object, /)
+ |      Insert object before index.
+ |
+ |  pop(self, index=-1, /)
+ |      Remove and return item at index (default last).
+ |
+ |      Raises IndexError if list is empty or index is out of range.
+ |
+ |  remove(self, value, /)
+ |      Remove first occurrence of value.
+ |
+ |      Raises ValueError if the value is not present.
+ |
+ |  reverse(self, /)
+ |      Reverse *IN PLACE*.
+ |
+ |  sort(self, /, *, key=None, reverse=False)
+ |      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.
+ |
+ |  ----------------------------------------------------------------------
+ |  Class methods defined here:
+ |
+ |  __class_getitem__(object, /)
+ |      See PEP 585
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+ |
+ |  ----------------------------------------------------------------------
+ |  Data and other attributes defined here:
+ |
+ |  __hash__ = None
+```
+```py
+help(tuple)
+```
+Вывод:
+```
+Help on class tuple in module builtins:
+
+class tuple(object)
+ |  tuple(iterable=(), /)
+ |
+ |  Built-in immutable sequence.
+ |
+ |  If no argument is given, the constructor returns an empty tuple.
+ |  If iterable is specified the tuple is initialized from iterable's items.
+ |
+ |  If the argument is a tuple, the return value is the same object.
+ |
+ |  Built-in subclasses:
+ |      asyncgen_hooks
+ |      UnraisableHookArgs
+ |
+ |  Methods defined here:
+ |
+ |  __add__(self, value, /)
+ |      Return self+value.
+ |
+ |  __contains__(self, key, /)
+ |      Return bool(key in self).
+ |
+ |  __eq__(self, value, /)
+ |      Return self==value.
+ |
+ |  __ge__(self, value, /)
+ |      Return self>=value.
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __getitem__(self, key, /)
+ |      Return self[key].
+ |
+ |  __getnewargs__(self, /)
+ |
+ |  __gt__(self, value, /)
+ |      Return self>value.
+ |
+ |  __hash__(self, /)
+ |      Return hash(self).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __le__(self, value, /)
+ |      Return self<=value.
+ |
+ |  __len__(self, /)
+ |      Return len(self).
+ |
+ |  __lt__(self, value, /)
+ |      Return self<value.
+ |
+ |  __mul__(self, value, /)
+ |      Return self*value.
+ |
+ |  __ne__(self, value, /)
+ |      Return self!=value.
+ |
+ |  __repr__(self, /)
+ |      Return repr(self).
+ |
+ |  __rmul__(self, value, /)
+ |      Return value*self.
+ |
+ |  count(self, value, /)
+ |      Return number of occurrences of value.
+ |
+ |  index(self, value, start=0, stop=9223372036854775807, /)
+ |      Return first index of value.
+ |
+ |      Raises ValueError if the value is not present.
+ |
+ |  ----------------------------------------------------------------------
+ |  Class methods defined here:
+ |
+ |  __class_getitem__(object, /)
+ |      See PEP 585
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+```
+```py
+help(dict)
+```
+Вывод:
+
+```
+Help on class dict in module builtins:
+
+class dict(object)
+ |  dict() -> new empty dictionary
+ |  dict(mapping) -> new dictionary initialized from a mapping object's
+ |      (key, value) pairs
+ |  dict(iterable) -> new dictionary initialized as if via:
+ |      d = {}
+ |      for k, v in iterable:
+ |          d[k] = v
+ |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
+ |      in the keyword argument list.  For example:  dict(one=1, two=2)
+ |
+ |  Methods defined here:
+ |
+ |  __contains__(self, key, /)
+ |      True if the dictionary has the specified key, else False.
+ |
+ |  __delitem__(self, key, /)
+ |      Delete self[key].
+ |
+ |  __eq__(self, value, /)
+ |      Return self==value.
+ |
+ |  __ge__(self, value, /)
+ |      Return self>=value.
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __getitem__(self, key, /)
+ |      Return self[key].
+ |
+ |  __gt__(self, value, /)
+ |      Return self>value.
+ |
+ |  __init__(self, /, *args, **kwargs)
+ |      Initialize self.  See help(type(self)) for accurate signature.
+ |
+ |  __ior__(self, value, /)
+ |      Return self|=value.
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __le__(self, value, /)
+ |      Return self<=value.
+ |
+ |  __len__(self, /)
+ |      Return len(self).
+ |
+ |  __lt__(self, value, /)
+ |      Return self<value.
+ |
+ |  __ne__(self, value, /)
+ |      Return self!=value.
+ |
+ |  __or__(self, value, /)
+ |      Return self|value.
+ |
+ |  __repr__(self, /)
+ |      Return repr(self).
+ |
+ |  __reversed__(self, /)
+ |      Return a reverse iterator over the dict keys.
+ |
+ |  __ror__(self, value, /)
+ |      Return value|self.
+ |
+ |  __setitem__(self, key, value, /)
+ |      Set self[key] to value.
+ |
+ |  __sizeof__(self, /)
+ |      Return the size of the dict in memory, in bytes.
+ |
+ |  clear(self, /)
+ |      Remove all items from the dict.
+ |
+ |  copy(self, /)
+ |      Return a shallow copy of the dict.
+ |
+ |  get(self, key, default=None, /)
+ |      Return the value for key if key is in the dictionary, else default.
+ |
+ |  items(self, /)
+ |      Return a set-like object providing a view on the dict's items.
+ |
+ |  keys(self, /)
+ |      Return a set-like object providing a view on the dict's keys.
+ |
+ |  pop(self, key, default=<unrepresentable>, /)
+ |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+ |
+ |      If the key is not found, return the default if given; otherwise,
+ |      raise a KeyError.
+ |
+ |  popitem(self, /)
+ |      Remove and return a (key, value) pair as a 2-tuple.
+ |
+ |      Pairs are returned in LIFO (last-in, first-out) order.
+ |      Raises KeyError if the dict is empty.
+ |
+ |  setdefault(self, key, default=None, /)
+ |      Insert key with a value of default if key is not in the dictionary.
+ |
+ |      Return the value for key if key is in the dictionary, else default.
+ |
+ |  update(...)
+ |      D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
+ |      If E is present and has a .keys() method, then does:  for k in E.keys(): D[k] = E[k]
+ |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
+ |      In either case, this is followed by: for k in F:  D[k] = F[k]
+ |
+ |  values(self, /)
+ |      Return an object providing a view on the dict's values.
+ |
+ |  ----------------------------------------------------------------------
+ |  Class methods defined here:
+ |
+ |  __class_getitem__(object, /)
+ |      See PEP 585
+ |
+ |  fromkeys(iterable, value=None, /)
+ |      Create a new dictionary with keys from iterable and values set to value.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+ |
+ |  ----------------------------------------------------------------------
+ |  Data and other attributes defined here:
+ |
+ |  __hash__ = None
+```
+### 8.1 Список
+
+Список может состоять из элемнтов различных типов:
+
+![](8.1.png)
+
+Список можно вводить на разных строках, т.к вывод не закончится,
+ пока не будет введена закрывающая скобка
+
+![](8.1.1.png)
+
+С элементами списка можно так же работать используя индексацию.
+
+```py
+stup=[0,0,1,1,1,1,1,1,1]
+stup[-8::2]
+```
+Вывод:
+```
+[0, 1, 1, 1]
+```
+элемент под индексом -8 = элементу до индексом 1. Срез происходит до последнего элемента с шагом 2,
+т.к не задан конечный элемент.
+
+```py 
+spis1[1]='Список'
+spis1
+```
+Вывод:
+```
+[111, 'Список', (5-9j)]
+```
+Также можно узнать число элементов в списке с помощью функции len():
+
+```py
+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.
+```
+С помоющью .append можно добавлять элементы в список, а с помощью .pop - удалить
+
+```py
+spis1.append('New item')  # В конец списка добавлен элемент «New item»
+spis1
+```
+Вывод:
+```
+[111, 'Список', (5-9j), 'New item']
+```
+Как мы видим в конец списка добавлен новый элемент
+
+```py
+spis1.append(ss1b)
+spis1
+```
+Вывод:
+```
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']
+```
+Изучим такие функции как:
+insert, remove, extend, clear, sort, reverse, copy, count, index
+```py
+spis1.insert(1, 'Привет')  #вставит второй аргумент под номер индекса элемента.
+spis1
+[111, 'Привет', 78, (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']
+spis1.remove('Привет')  #удалит тот элемент, который полностью соответствует указанному в команде аргументу.
+spis1
+[111, 78, (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']
+spis1.extend('5-9')  #добавит каждый элемент аргумента в конце списка
+spis1
+[111, 78, (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю', '5', '-', '9']
+spis1.clear()  #удаляет все элементы из списка
+spis1
+[]
+spis1=[5, 3, 2, 1, 7, 6, 9]
+spis1.sort()  #сортировка списка как и по числам
+spis1
+[1, 2, 3, 5, 6, 7, 9]
+spis12=['b', 'a', 'c', 'g', 't']  #так и по алфовиту
+spis12.sort()
+spis12
+['a', 'b', 'c', 'g', 't']
+spis12.reverse()  #перемешивает элементы в обратном порядке
+spis12
+['t', 'g', 'c', 'b', 'a']
+spiscop=spis12.copy()
+spiscop
+['t', 'g', 'c', 'b', 'a']
+spis1.count(5) #считает то, сколько раз элемент из аргумента появляется в списке
+1
+spis1.index(9) #возвращает индекс элемента, совпадающего по значению с аргументом
+6
+```
+Списки также могут быть вложенными:
+
+```py
+spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+spis2[0][1]  #обращение к элементу списка spis1
+'Список'
+spis2[0][1]=78  #Убедитесь, что значение элемента заменено на 78
+spis2[0][1]
+78
+```
+```py
+spis1
+```
+Вывод:
+```
+[1, 78, 3, 5, 6, 7, 9]
+```
+был видоизменен, ведь является элементом другого списка,
+ к которому мы обратились и изменили соответственно
+
+#### Был придуман список, содержащий в себе 4 элемента разных типов: число, строка, логическое значение и список
+```py
+list=[10,'Евгений',True,['a','b']]
+list
+```
+Вывод:
+```
+[10, 'Евгений', True, ['a', 'b']]
+```
+### 8.2 Кортеж.
+
+*Похож на список, но изменить его нельзя
+```py
+kort1=(222,'Kortezh',77+8j)
+kort1[0]=10
+```
+Вывод:
+```
+Traceback (most recent call last):
+  File "<pyshell#165>", line 1, in <module>
+    kort1[0]=10
+TypeError: 'tuple' object does not support item assignment
+```
+Получаем ошибку
+
+Кортеж нельзя изменить, но можно переопределить
+
+```py
+kort1= kort1+(1,2)
+kort1
+```
+Вывод:
+```
+(222, 'Kortezh', (77+8j), 1, 2)
+```
+Добавим ещё один элемент:
+```py
+kort1= kort1+(ss1b,)
+kort1
+```
+Вывод:
+```
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Туровец Е.Ю')
+```
+Удаление элементов из кортежа можно делать путем переопределения срезом:
+```py
+kort2=kort1[:2]+kort1[3:]
+kort2
+```
+Вывод:
+```
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Туровец Е.Ю')
+```
+.index и .count в кортежах работают так же как и в списках
+
+Методов append и pop у кортежей нет, т.к. они являются неизменяемыми
+
+Создадим собственный кортеж и элементами различных типов:
+```py
+korte=(10,'stroka',[10,'a'],(50,'b'))
+korte
+```
+Вывод:
+```
+(10, 'stroka', [10, 'a'], (50, 'b'))
+```
+
+### 8.3 Словарь
+
+Словарь является совокупностью пар типа 'key:value'
+
+Создадим словарь:
+
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+```
+При обращении к ключу Orel получим:
+```py
+dic1['Orel']
+```
+Вывод:
+```
+56
+```
+Пополнение словаря:
+```py
+dic1['Pskov']=78
+dic1
+```
+Вывод:
+```
+dic1['Pskov']=78
+dic1
+```
+Словарь можно отсортировать по ключам или значениям:
+```py
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+```
+Также можно создавать вложенные словари:
+```py
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+```
+Вывод:
+```
+'standart deviation'
+```
+Более сложные словари с помощью функций dist и zip
+![](8.3.png)
+
+Создадим собственный словарь:
+```py
+cort=('a','b','c','d','e','f','g')
+sp1s=[1,2,3,4,5]
+ob=dict(zip(cort,sp1s))
+ob
+```
+Вывод:
+```
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+```
+```py
+len(ob)
+```
+Вывод:
+```
+5
+```
+Элементов 5, т.к команда zip работала столько раз, сколько элементов в наиболее маленьком объекте
+
+```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
+```
+Вывод:
+```
+{'линия связи', 'датчик', 'двигатель', 'микропроцессор'}
+```
+Как мы видим дубли были удалены
+
+Выведем число элементов в множестве:
+
+```py
+len(mnoz1)
+4
+```
+Проверка наличия элемента во множестве:
+
+```py
+'датчик' in mnoz1
+True
+```
+Добавление элемента:
+
+```py
+mnoz1.add('реле')
+mnoz1
+{'линия связи', 'датчик', 'реле', 'микропроцессор', 'двигатель'}
+```
+Удаление элемента:
+```py
+mnoz1.remove('линия связи')
+mnoz1
+{'датчик', 'реле', 'микропроцессор', 'двигатель'}
+```
+Было создано множество:
+```py
+mnoz1 = {'лев', '1', True, ('тигр', 1, 3)}
+mnoz1
+{('тигр', 1, 3), True, 'лев', '1'}
+mnoz1.remove(True)
+mnoz1
+{('тигр', 1, 3), 'лев', '1'}
+mnoz1.add('осёл')
+mnoz1
+{('тигр', 1, 3), 'лев', '1', 'осёл'}
+```
+## 9.
+```py
+exit()
+```
+
+

TEMA2/task.md

@@ -0,0 +1,46 @@
+# Общее контрольное задание по теме 2
+
+Туровец Евгений, А-02-23
+
+## Задание
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фами-лией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите 
+инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные пере-менные, соответствующие этим типам.
+
+## Решение
+```py
+>>> familia = 'Turovets'
+>>> bukva = familia[0]
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw.remove('nonlocal')
+>>> print(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']
+>>> print(sp_kw.count('nonlocal'))
+0
+>>> kort_nam = ('Stas', 'Dana', 'Andrew', 'Zhenya')
+>>> print(type(kort_nam))
+<class 'tuple'>
+>>> kort_nam = kort_nam + ('Katya', 'Ksenia')
+>>> print(kort_nam.count('Dima'))
+0
+>>> key = ['str', 'list', 'tuple']
+>>> value = ['familia', 'sp_kw', 'kort_nam']
+>>> dict_bas = dict(zip(key, value))
+>>> print(dict_bas)
+{'str': 'familia', 'list': 'sp_kw', 'tuple': 'kort_nam'}
+
+```

TEMA2/task.py

@@ -0,0 +1,15 @@
+familia = 'Turovets'
+bukva = familia[0]
+import keyword
+sp_kw = keyword.kwlist
+sp_kw.remove('nonlocal')
+print(sp_kw)
+print(sp_kw.count('nonlocal'))
+kort_nam = ('Stas', 'Dana', 'Andrew', 'Zhenya')
+print(type(kort_nam))
+kort_nam = kort_nam + ('Katya', 'Ksenia')
+print(kort_nam.count('Dima'))
+key = ['str', 'list', 'tuple']
+value = ['familia', 'sp_kw', 'kort_nam']
+dict_bas = dict(zip(key, value))
+print(dict_bas)

TEMA3/22.py

@@ -0,0 +1,25 @@
+# 1) Ответ: Да, можно, если разделить инструкции точкой с запятой ;. Пример: `a = 5; b = 10; print(a + b)`
+
+# 2) Создание списка комплексных чисел
+complex_list = [1+2j, 3-1j, -2+4j, 5j, 7-3j, -4-2j, 0+1j, 9+0j, 2.5+1.5j, -1-1j]
+print("Тип объекта:", type(complex_list))
+print("Атрибуты объекта:", dir(complex_list))
+
+# 3) Удаление, добавление элементов
+del complex_list[2]
+print("Число элементов после удаления:", len(complex_list))
+complex_list.extend([10+10j, 20-20j, 30+30j])
+print("Список после добавления:", complex_list)
+
+# 4) Преобразование во множество и проверка
+complex_set = set(complex_list)
+print("Множество:", complex_set)
+check_value = 2-3j
+is_present = check_value in complex_set
+print(f"Есть ли {check_value} во множестве? {is_present}")
+
+# 5) Сумма и замена элемента
+total_sum = sum(complex_list)
+print("Сумма элементов списка:", total_sum)
+complex_list[2] = -2+3j
+print("Список после замены 3-го элемента:", complex_list)

TEMA3/modul1.md

@@ -0,0 +1,53 @@
+# Модуль 1 22 вариант
+## Задание 22 вариант
+```
+1)	Можно ли писать несколько инструкций в одной строке рабочего окна? Подтвердите ответ примером.
+
+2)	Создайте объект-список с 10 элементами - комплексными числами. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, удаляющую из списка третий от начала элемент. Определите число элементов в получившемся списке. Одной инструкцией добавьте к списку еще 3 элемента - комплексных числа. Отобразите получившийся объект.
+
+4)	Напишите инструкцию преобразования списка во множество. Отобразите полученный объект. Проверьте наличие в этом множестве элемента со значением 2-3j.
+
+5)	Напишите инструкцию, позволяющую рассчитать сумму элементов списка. Замените 3-й от начала элемент списка на число -2+3j. Отобразите полученный объект.
+```
+### Решение
+
+```py
+# 1) Ответ: Да, можно, если разделить инструкции точкой с запятой ;. Пример: `a = 5; b = 10; print(a + b)`
+
+# 2) Создание списка комплексных чисел
+complex_list = [1+2j, 3-1j, -2+4j, 5j, 7-3j, -4-2j, 0+1j, 9+0j, 2.5+1.5j, -1-1j]
+print("Тип объекта:", type(complex_list))
+print("Атрибуты объекта:", dir(complex_list))
+
+# 3) Удаление, добавление элементов
+del complex_list[2]
+print("Число элементов после удаления:", len(complex_list))
+complex_list.extend([10+10j, 20-20j, 30+30j])
+print("Список после добавления:", complex_list)
+
+# 4) Преобразование во множество и проверка
+complex_set = set(complex_list)
+print("Множество:", complex_set)
+check_value = 2-3j
+is_present = check_value in complex_set
+print(f"Есть ли {check_value} во множестве? {is_present}")
+
+# 5) Сумма и замена элемента
+total_sum = sum(complex_list)
+print("Сумма элементов списка:", total_sum)
+complex_list[2] = -2+3j
+print("Список после замены 3-го элемента:", complex_list)
+```
+Вывод:
+```
+Тип объекта: <class 'list'>
+Атрибуты объекта: ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+Число элементов после удаления: 9
+Список после добавления: [(1+2j), (3-1j), 5j, (7-3j), (-4-2j), 1j, (9+0j), (2.5+1.5j), (-1-1j), (10+10j), (20-20j), (30+30j)]
+Множество: {1j, (2.5+1.5j), (1+2j), (10+10j), (9+0j), (30+30j), 5j, (20-20j), (-4-2j), (-1-1j), (3-1j), (7-3j)}
+Есть ли (2-3j) во множестве? False
+Сумма элементов списка: (77.5+22.5j)
+Список после замены 3-го элемента: [(1+2j), (3-1j), (-2+3j), (7-3j), (-4-2j), 1j, (9+0j), (2.5+1.5j), (-1-1j), (10+10j), (20-20j), (30+30j)]
+```

TEMA3/report.md

@@ -0,0 +1,778 @@
+# Тема 3. Туровец Е.Ю
+
+## 1. Запуск интерактивной оболочки IDLE. Создание текстового файла.
+## 2. Преобразование простых базовых типов объектов.
+
+### 2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
+```py
+logiz1=bool(56)
+logiz2=bool(0)
+logiz3=bool("Beta")
+logiz4=bool("")
+logiz1; type(logiz1)
+```
+```
+True
+<class 'bool'>
+```
+```py
+logiz2; type(logiz2)
+```
+```
+False
+<class 'bool'>
+```
+```py
+logiz3; type(logiz3)
+```
+```
+True
+<class 'bool'>
+```
+```py
+logiz4; type(logiz4)
+```
+```
+False
+<class 'bool'>
+```
+Как мы видим если число не равно 0, то при преобразовании в логический тип - оно примет значение True
+
+### 2.2 Преобразование в целое десятичное число объект с заданной системой счисления.
+
+```py
+tt1=int(198.6) #Отбрасывается дробная часть
+tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+tt3=int("B",16)
+tt4=int("71",8)
+tt5=int("98.76")
+```
+Получаем ошибку:
+
+```
+Traceback (most recent call last):
+  File "<pyshell#12>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+```py
+tt1
+198
+tt2
+-76
+tt3
+11
+tt4
+57
+```
+На последней инструкции онибка возникает из-за того, что в кавычках мы пишем дробное число.
+Если же мы хотим чтобы эта инструкция работала без ошибок, то нас надо перевести число сначала в дробный тип, а только потом в целый
+
+```py
+flt1=float(789)
+flt2=float(-6.78e2)
+flt3=float("Infinity")
+flt4=float("-inf")
+flt1
+789.0
+flt2
+-678.0
+flt3
+inf
+flt4
+-inf
+```
+
+### 2.3 Преобразование десятичных чисел в другие системы счисления:
+
+Для того, чтобы перевести число в различные системы счисления можно использовать следующие команды:
+
+```py
+hh=123
+dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+vos1=oct(hh)   #Преобразование в строку с восьмеричным представлением
+shs1=hex(hh)   #Преобразование в строку с шестнадцатеричным представлением
+
+Для обратного перевода будем использовать команду int() с указанием системы счисления переводимого объекта:
+int(dv1, 2)
+123
+dv1
+'0b1111011'
+vos1
+'0o173'
+int(vos1,8)
+123
+shs1
+'0x7b'
+int(shs1,16)
+123
+```
+## 3. Изучение преобразования более сложных базовых типов объектов.
+
+### 3.1. Преобразование в строку символов
+
+```py
+strk1=str(23.6)
+strk2=str(logiz3)
+strk3=str(["A","B","C"])  #Преобразуем список
+strk4=str(("A","B","C"))  #Преобразуем кортеж
+strk5=str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+strk1
+'23.6'
+strk2
+'True'
+strk3
+"['A', 'B', 'C']"
+strk4
+"('A', 'B', 'C')"
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+### 3.2. Преобразование объектов в список
+
+```py
+spis1=list("Строка символов")  #Заданная строка разделяется на символы
+spis2=list((124,236,-15,908))   #Кортеж превращается в список
+spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2
+[124, 236, -15, 908]
+spis3
+['A', 'B', 'C'] #По умолчанию в список попадают только ключи
+```
+Чтобы звнести в список только значения из словаря - можем написать такую инструкцию:
+```py
+spis3=list({"A":1,"B":2,"C":9}.values()); spis3
+[1, 2, 9]
+```
+Чтобы занести в список и ключи и значения словаря - поступим следующим образом:
+
+```py
+spis3=list({"A":1,"B":2,"C":9}.items()); spis3
+[('A', 1), ('B', 2), ('C', 9)]
+```
+### 3.3 Преобразование объектов в кортеж
+
+```py
+kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+kort8=tuple(spis2)   #Преобразование списка в кортеж
+kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8
+(124, 236, -15, 908)
+kort9
+('A', 'B', 'C')
+```
+### 3.4 Удаление объектов
+
+```py
+del strk5, kort8
+strk5
+```
+Вывод:
+```
+Traceback (most recent call last):
+  File "<pyshell#65>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+```
+```py
+kort8
+```
+Вывод:
+
+```
+Traceback (most recent call last):
+  File "<pyshell#66>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+Создадим строку с своей фамилией и инициалами:
+
+```py
+fio='Туровец Е.Ю.'
+```
+
+Переведем строку в список:
+
+```py
+spisok=list(fio)
+spisok
+['Т', 'у', 'р', 'о', 'в', 'е', 'ц', ' ', 'Е', '.', 'Ю', '.']
+kortej=tuple(spisok);kortej
+('Т', 'у', 'р', 'о', 'в', 'е', 'ц', ' ', 'Е', '.', 'Ю', '.')
+stro=str(kortej)
+stro
+"('Т', 'у', 'р', 'о', 'в', 'е', 'ц', ' ', 'Е', '.', 'Ю', '.')"
+```
+
+При множественном преобразовании строка потеряла изначальный вид, поэтому воспользуемся другим способом:
+
+```py
+stro=''.join(kortej)
+stro
+'Туровец Е.Ю.'
+```
+В таком случае мы "склеиваем" нашу строку
+
+## 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!
+a
+3.9555555555555557
+type(a)
+<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'>
+```
+
+### 4.5. Получение остатка от деления
+
+```py
+148%33   #Остаток от деления двух целых чисел
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+```
+
+### 4.6. Возведение в степень 
+
+```py
+14**3  #Целое число возводится в целую степень
+2744
+e=2.7**3.6  #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+type(e)
+<class 'float'>
+m=2.7**36
+m
+3381391913522734.5
+type(m)
+<class 'float'>
+n=27**3.6
+n
+142203.2594411396
+type(n)
+<class 'float'>
+```
+
+### Попробуем вышеперечисленные операции для комплексных чмсел:
+
+```py
+a1=1+2j
+a2=2+5j
+a1+a2
+(3+7j)
+a2-a1
+(1+3j)
+a1*a2
+(-8+9j)
+a2/a1
+(2.4+0.2j)
+a2//a1
+Traceback (most recent call last):
+  File "<pyshell#26>", line 1, in <module>
+    a2//a1
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+a1%a2
+Traceback (most recent call last):
+  File "<pyshell#27>", line 1, in <module>
+    a1%a2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+a1**a2
+(0.01969615658538202-0.0008927103407394184j)
+```
+Как мы видим, операции деления с округлением вниз и нахождение остатка от деления недоступны для комплексных чисел
+
+## 5. Операции с двоичными представлениями целых чисел.
+
+### 5.1. Двоичная инверсия.
+
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0)
+
+```py
+dv1=9
+bin(dv1)
+'0b1001' #питон опускает ведущие нули, на самом деле там 00001001
+dv2=~dv1
+dv2
+-10
+bin(dv2)
+'-0b1010' #-11110110
+```
+
+### 5.2. Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+
+```py
+7&9    # 0111 и 1001 = 0001 совпадение в одном последнем символе
+1
+7&8    # 0111 и 1000 = 0000 совпадений нет
+0
+bin(7)
+'0b111'
+bin(8)
+'0b1000'
+bin(9)
+'0b1001'
+```
+
+### 5.3. Двоичное «ИЛИ» (|)
+
+побитовое сравнение двоичных представлений чисел и 0 получается,
+только если оба сравниваемых разряда равны 0
+
+```py
+7|9     # 0111 или 1001 = 1111
+15
+bin(15)
+'0b1111'
+7|8     # 0111 или 1000 = 1111
+15
+14|5    # 1110 или 0101 = 1111
+15
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+bin(15)
+'0b1111'
+```
+### 5.4. Двоичное «исключающее ИЛИ»(^)
+
+Побитовое сравнение двоичных представлений чисел и 0 получается,
+только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+
+```py
+14^5  #1110 исключающее или 0101 = 1011 на 1,3,4 местах стоят несовпадающие значения, а на 2 месте в обоих числах стоит "1"
+11
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+bin(11)
+'0b1011'
+```
+
+### 5.5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями,
+ соответственно справа или слева.
+
+```py
+h=14   #Двоичное представление = 1110
+bin(h)
+'0b1110'
+g=h<<2  #Новое двоичное представление = 111000
+bin(g)
+'0b111000'
+g1=h>>1  #Новое двоичное представление = 0111
+bin(g1)
+'0b111'
+g2=h>>2  #Новое двоичное представление = 0011
+bin(g2)
+'0b11'
+```
+### 5.6. Действия с двумя моими двоичными числами
+
+```py
+a = 0b10110101
+b = 0b01101011
+c=~a
+bin(c)
+'-0b10110110'
+bin(a&b)
+'0b100001'
+bin(a|b)
+'0b11111111'
+bin(a^b)
+'0b11011110'
+d=a<<2
+bin(d)
+'0b1011010100'
+e=b>>2
+bin(e)
+'0b11010'
+```
+## 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   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99 #Создание списка со 100 отсчетами сигнала-ступеньки
+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 % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+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=-12
+zz+=5   # Значение zz увеличивается на 5
+zz
+-7
+zz-=3  # Значение уменьшается на 3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+
+### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+
+```py
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+stroka='Система'
+stroka*=3
+stroka
+'СистемаСистемаСистема'
+```
+### 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+
+```py
+zz=7
+zz//=3 #округление вниз
+zz
+2
+zz%=8 #остаток от деления
+zz
+2
+zz**=3 #возведение в степень
+zz
+8
+```
+
+### 7.5. Множественное присваивание
+
+```py
+w=v=10  # Переменным присваивается одно и то же значение
+w
+10
+v
+10
+n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+n1
+11
+n2
+-3
+n3
+'all'
+n1,n2,n3="all" #Значения переменных берутся из строки
+n1
+'a'
+n2
+'l'
+n3
+'l'
+n1,n2,n3=[11,-3,'all']  #Значения переменных берутся из списка
+n1
+11
+n2
+-3
+n3
+'all'
+n1,n2,n3 = {"a": 11, "b": -3, "c": "all"} #Значения переменных берутся из словаря(ключи)
+n1
+'a'
+n2
+'b'
+n3
+'c'
+r = {"a": 11, "b": -3, "c": "all"} #Значения переменных берутся из словаря(значения)
+n1,n2,n3 = r.values()
+n1
+11
+n2
+-3
+n3
+'all'
+n1,n2,n3 = {11, -3, 'all'} #Значения переменных берутся из множества(порядок не гарантирован)
+n1
+11
+n2
+-3
+n3
+'all'
+```
+
+## 8. Логические операции – при создании логических выражений,
+ дающих в результате вычисления значения True или False.
+
+### 8.1. Операции сравнение: равенство (==), не равно (!=),
+ меньше (<), больше (>), меньше или равно (<=),
+ больше или равно (>=) – придумайте примеры этих операций. 
+
+```py
+w
+10
+v
+10
+w==v
+True
+z=6
+w!=z
+True
+w<z
+False
+v>z
+True
+v<=z
+False
+w>=z
+True
+```
+
+### 8.2. Проверка наличия заданного элемента в последовательности или во множестве,
+ а также  проверка наличия ключа в словаре (in).
+
+#### 8.2.1. Операции с множеством 
+```py
+mnoz1={'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+```
+
+#### 8.2.2. Операции со словарем
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+
+### 8.3. Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). 
+
+```py
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a<b) and ('Vologda' in dic1) and ('cap' in mnoz1)
+False
+(a>=b) and (a==b) and not (a!=b)
+False
+```
+
+### 8.4. Проверка ссылок переменных на один и тот же объект (is).
+```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('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()   #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+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,'a',2,'b',3,'c',4]
+dir(spsk) #отображение атрибутов
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spsk.pop(2) #удаляет из списка элемент с индексом 2 и выводит его
+2
+spsk
+[1, 'a', 'b', 3, 'c', 4]
+spsk.append('c') #добавление в конец списка 'c'
+spsk
+[1, 'a', 'b', 3, 'c', 4, 'c']
+spsk.insert(2,'a') #вставляет 'a' на позицию с индексом 2
+spsk
+[1, 'a', 'a', 'b', 3, 'c', 4, 'c']
+spsk.count('a') #считает количество 'a' в списке
+2
+```
+### 9.3. Методы для работы с кортежами.
+```py
+kortezh = (1, 'a', 'b', 3, 'c', 4)
+kortezh.count(3) #считает количество 3 в списке
+1
+kortezh.index('b') #выводит с каким индексом в кортеже 'b'
+2
+kortezh + (5, 6) #добавляет 5, 6 в кортеж
+(1, 'a', 'b', 3, 'c', 4, 5, 6)
+```
+### 9.4. Методы для работы со словарями.
+```py
+slvr = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+slvr.keys() #получение ключей словаря
+dict_keys(['a', 'b', 'c', 'd'])
+slvr.values() #получение значений словаря
+dict_values([1, 2, 3, 4])
+slvr.items() #получение пар ключ-значение из словаря
+dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
+slvr.get('b') #получение значений по ключу
+2
+slvr.update({'e': 5, 'f': 6}) #добавление двух пар в словарь
+slvr
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
+slvr.pop('c') #удаление по ключу
+3
+slvr
+{'a': 1, 'b': 2, 'd': 4, 'e': 5, 'f': 6}
+```
+### 9.5. Методы для работы с множествами.
+```py
+mng={1,'a',2,'b',3,'c',4}
+mng.add('d') #добавление в множество mng элемента 'd'
+mng
+{1, 2, 3, 4, 'b', 'd', 'a', 'c'}
+mng.remove(3) #удаление из множества mng элемента 3
+mng
+{1, 2, 4, 'b', 'd', 'a', 'c'}
+mng1={5,'e',6}
+mng2=mng.union(mng1) #объединение множеств mng и mng1
+mng2
+{1, 2, 4, 5, 6, 'a', 'e', 'b', 'd', 'c'}
+mng3=mng2.intersection(mng) #пересечение множеств mng и mng2, получили mng так как mng входит в mng2
+mng3
+{1, 2, 4, 'a', 'b', 'd', 'c'}
+mng4=mng2.difference(mng) #разность множеств mng и mng2, получили mng1, так как mng+mng1=mng2
+mng4
+{'e', 5, 6}
+```
+## 10.Завершение сеанса работы с IDLE.

TEMA3/task.md

@@ -0,0 +1,67 @@
+# Общее контрольное задание по теме 3
+
+Туровец Евгений, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+    • Преобразовать восьмеричное значение 45 в целое число.
+    • Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+    • Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+    • Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+    • Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+    • Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+    • Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>>a = int("45", 8)
+>>>a
+37
+>>>D={"усиление":23, "запаздывание":12, "постоянная времени":78}
+>>>spis1=list(D)
+>>>spis1
+['усиление', 'запаздывание', 'постоянная времени']
+>>>spis2=list(D.values())
+>>>spis2
+[23, 12, 78]
+>>>kor=tuple(spis1)+tuple(spis2) #Список отличается от кортежа тем, что список изменяем, а кортеж нет.
+>>>kor
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+>>>((1768//24.8)%3)**2.4
+5.278031643091577
+>>>((~(13&27))^14)<<2
+-32
+>>>spis3=["колебат", "колебат", "колебат",  "колебат" ]
+>>>'аткол' in spis3[1] + spis3[2]
+True
+>>>dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>>help(D.keys)
+Help on built-in function keys:
+
+keys() method of builtins.dict instance
+    Return a set-like object providing a view on the dict's keys.
+
+>>>help(D.values)
+Help on built-in function values:
+
+values() method of builtins.dict instance
+    Return an object providing a view on the dict's values.
+
+>>>D.keys() #Этот метод отображает ключи словаря
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>>D.values() #Этот метод отображает знаечния словаря
+dict_values([23, 12, 78])
+>>>S="Создать объект - символьную строку с текстом данного предложения"
+>>>L=list(S.split())
+>>>L
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>>L[L.index("-")] = ","
+>>>L
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>>L.remove("данного")
+>>>L
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA4/iz.md

@@ -0,0 +1,29 @@
+##	Напишите инструкцию запоминания в переменной текущего времени в секундах с начала эпохи. Преобразуйте это время в Московское региональное время. Создайте кортеж с элементами – целыми числами от 27 до 147 через 15. Рассчитайте сумму элементов кортежа и определите значение отношения синуса этой суммы к корню квадратному из неё. Отобразите полученное значение в виде: «Результат = ХХХ» с округлением до 5 знаков после точки.
+```py
+import time
+
+# Текущее время в секундах
+time.time()
+1759145565.96384
+
+# Московское время
+time.localtime(секунды + 3*3600)
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=17, tm_min=30, tm_sec=34, tm_wday=0, tm_yday=272, tm_isdst=0)
+# или
+print(f"Московское время: {time.asctime(мск_время)}")
+Московское время: Mon Sep 29 17:30:34 2025
+
+# Кортеж с целыми числами
+кортеж = tuple(range(27, 148, 15))
+кортеж
+(27, 42, 57, 72, 87, 102, 117, 132, 147)
+sum(кортеж)
+783
+сумма = sum(кортеж)
+
+# Отношение синуса суммы к корню
+import math
+результат=round(math.sin(сумма) / math.sqrt(сумма), 5)
+print("Результат =", результат)
+Результат = -0.02419
+```

TEMA4/iz.py

@@ -0,0 +1,2 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.

TEMA4/obsheekz.md

@@ -0,0 +1,57 @@
+## Общее контрольное задание Снегура Дана
+```py
+import math
+import cmath
+import time
+import random
+import string
+import statistics
+```
+# 1. Комплексное число и операции
+```py
+math.floor((round(cmath.phase(0.2+0.8j), 2) * 20) / 3), (round(cmath.phase(0.2+0.8j), 2) * 20) % 3
+(8, 2.6000000000000014)
+```
+# 2. Текущее московское время
+```py
+moscow_time = time.localtime(time.time() + 3 * 3600)  # UTC+3 для Москвы
+current_time_str = f"{moscow_time.tm_hour:02d}:{moscow_time.tm_min:02d}"
+moscow_time
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=19, tm_hour=20, tm_min=43, tm_sec=20, tm_wday=4, tm_yday=262, tm_isdst=0)
+current_time_str
+'20:43'
+```
+# 3. Случайная выборка дней недели
+```py
+week_days = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+random_days = random.sample(week_days, 3)
+random_days
+['Вторник', 'Пятница', 'Воскресенье']
+```
+# 4. Случайный выбор числа из последовательности
+```py
+sequence = list(range(14, 33, 3))
+random_number = random.choice(sequence)
+random_number
+20
+sequence
+[14, 17, 20, 23, 26, 29, 32]
+```
+# 5. Генерация нормально распределенного числа и списка букв
+```py
+N = round(random.gauss(15, 4))
+N = max(1, N)  # Гарантируем хотя бы 1 элемент
+random_letters = random.choices(string.ascii_uppercase, k=N)
+N
+11
+random_letters
+['O', 'U', 'J', 'Y', 'U', 'Y', 'Y', 'S', 'D', 'K', 'G']
+```
+# 6. Временной интервал в минутах
+```py
+current_time = time.time()
+time_interval_seconds = current_time - time.mktime(moscow_time)
+time_interval_minutes = round(time_interval_seconds / 60, 2)
+time_interval_minutes
+-170.05
+```

TEMA4/obsheekz.py

@@ -0,0 +1,40 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+import math
+import cmath
+import time
+import random
+import string
+import statistics
+math.floor((round(cmath.phase(0.2+0.8j), 2) * 20) / 3), (round(cmath.phase(0.2+0.8j), 2) * 20) % 3
+(8, 2.6000000000000014)
+time.localtime(time.time() + 3 * 3600)
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=19, tm_hour=20, tm_min=42, tm_sec=40, tm_wday=4, tm_yday=262, tm_isdst=0)
+moscow_time = time.localtime(time.time() + 3 * 3600)  # UTC+3 для Москвы
+current_time_str = f"{moscow_time.tm_hour:02d}:{moscow_time.tm_min:02d}"
+moscow_time
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=19, tm_hour=20, tm_min=43, tm_sec=20, tm_wday=4, tm_yday=262, tm_isdst=0)
+>>> current_time_str
+'20:43'
+>>> week_days = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+>>> random_days = random.sample(week_days, 3)
+>>> random_days
+['Вторник', 'Пятница', 'Воскресенье']
+>>> sequence = list(range(14, 33, 3))
+>>> random_number = random.choice(sequence)
+>>> random_number
+20
+>>> sequence
+[14, 17, 20, 23, 26, 29, 32]
+>>> N = round(random.gauss(15, 4))
+>>> N = max(1, N)  # Гарантируем хотя бы 1 элемент
+>>> random_letters = random.choices(string.ascii_uppercase, k=N)
+>>> N
+11
+>>> random_letters
+['O', 'U', 'J', 'Y', 'U', 'Y', 'Y', 'S', 'D', 'K', 'G']
+>>> current_time = time.time()
+>>> time_interval_seconds = current_time - time.mktime(moscow_time)
+>>> time_interval_minutes = round(time_interval_seconds / 60, 2)
+>>> time_interval_minutes
+-170.05

TEMA4/otch.py

@@ -0,0 +1,114 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+time_tuple = (2025, 9, 18, 16, 12, 46, 3, 261, 0)
+time_obj = time.struct_time(time_tuple)
+Traceback (most recent call last):
+  File "<pyshell#1>", line 1, in <module>
+    time_obj = time.struct_time(time_tuple)
+NameError: name 'time' is not defined. Did you forget to import 'time'?
+import time
+time_obj = time.struct_time(time_tuple)
+time_obj
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
+seconds = time.mktime(time_obj)
+seconds
+1758201166.0
+back_to_time = time.localtime(seconds
+                              )
+back_to_time
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
+import pylab
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    import pylab
+ModuleNotFoundError: No module named 'pylab'
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000027668162490>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show() #Отображение графика на экране
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000027669976C10>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000027669976D50>]
+pylab.show()
+pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
+Traceback (most recent call last):
+  File "<pyshell#24>", line 1, in <module>
+    pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
+NameError: name 'grades' is not defined
+grades = [85, 92, 78, 65, 90, 85, 88, 72, 95, 81, 85, 90, 78, 85, 92]
+categories = ['A', 'B', 'C', 'D', 'F']
+values = [3, 7, 8, 2, 1]
+pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
+(array([1., 1., 3., 5., 5.]), array([65., 71., 77., 83., 89., 95.]), <BarContainer object of 5 artists>)
+pylab.title('Гистограмма распределения оценок')
+Text(0.5, 1.0, 'Гистограмма распределения оценок')
+pylab.xlabel('Оценки')
+Text(0.5, 0, 'Оценки')
+pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+pylab.show()
+pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
+(array([1., 1., 3., 5., 5.]), array([65., 71., 77., 83., 89., 95.]), <BarContainer object of 5 artists>)
+pylab.title('Гистограмма распределения оценок')
+Text(0.5, 1.0, 'Гистограмма распределения оценок')
+pylab.xlabel('Оценки')
+Text(0.5, 0, 'Оценки')
+pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+data = [23, 45, 67, 34, 89, 56, 72, 41, 58, 64, 39, 51, 47, 62, 55]
+pylab.bar(categories, values, color=['red', 'orange', 'yellow', 'green', 'blue'], alpha=0.7)
+<BarContainer object of 5 artists>
+pylab.title('Столбчатая диаграмма распределения по категориям')
+Text(0.5, 1.0, 'Столбчатая диаграмма распределения по категориям')
+pylab.xlabel('Категории')
+Text(0.5, 0, 'Категории')
+pylab.ylabel('Количество')
+Text(0, 0.5, 'Количество')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+mean_value = statistics.mean(data)
+Traceback (most recent call last):
+  File "<pyshell#48>", line 1, in <module>
+    mean_value = statistics.mean(data)
+NameError: name 'statistics' is not defined. Did you forget to import 'statistics'?
+import statistics
+>>> mean_value = statistics.mean(data)
+>>> median_value = statistics.median(data)
+>>> mode_value = statistics.mode(data)
+>>> stdev_value = statistics.stdev(data)
+>>> variance_value = statistics.variance(data)
+>>> quantiles_value = statistics.quantiles(data, n=4)
+>>> harmonic_mean_value = statistics.harmonic_mean(data)
+>>> pylab.hist(data, bins=6, edgecolor='black', alpha=0.7, color='lightgreen', label='Распределение данных')
+(array([1., 3., 4., 4., 2., 1.]), array([23., 34., 45., 56., 67., 78., 89.]), <BarContainer object of 6 artists>)
+>>> pylab.axvline(mean_value, color='red', linestyle='--', linewidth=2, label=f'Среднее: {mean_value:.2f}')
+<matplotlib.lines.Line2D object at 0x000002766864C2D0>
+>>> pylab.axvline(median_value, color='blue', linestyle='--', linewidth=2, label=f'Медиана: {median_value}')
+<matplotlib.lines.Line2D object at 0x000002766864C410>
+>>> pylab.axvline(mode_value, color='green', linestyle='--', linewidth=2, label=f'Мода: {mode_value}')
+<matplotlib.lines.Line2D object at 0x000002766864C550>
+>>> pylab.title('Гистограмма данных со статистическими показателями')
+Text(0.5, 1.0, 'Гистограмма данных со статистическими показателями')
+>>> pylab.xlabel('Значения')
+Text(0.5, 0, 'Значения')
+>>> pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+>>> pylab.legend()
+<matplotlib.legend.Legend object at 0x000002766813F620>
+>>> pylab.grid(alpha=0.3)
+>>> pylab.show()

TEMA4/otche.py

@@ -0,0 +1,244 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+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.
+
+type(round)
+<class 'builtin_function_or_method'>
+range(23)
+range(0, 23)
+gg=range(76,123,9)
+qq=["Снегура", "Туровец", "Хатюхин", "Шабатов"]
+ff=zip(gg,qq)
+tuple(ff)
+((76, 'Снегура'), (85, 'Туровец'), (94, 'Хатюхин'), (103, 'Шабатов'))
+a=tuple(ff)
+a[1]
+Traceback (most recent call last):
+  File "<pyshell#8>", line 1, in <module>
+    a[1]
+IndexError: tuple index out of range
+b=list(ff)
+b[1]
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    b[1]
+IndexError: list index out of range
+gg
+range(76, 123, 9)
+tuple(gg)
+(76, 85, 94, 103, 112, 121)
+list(gg)
+[76, 85, 94, 103, 112, 121]
+c= list(zip(gg, qq))
+c[1]
+(85, 'Туровец')
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+numbers = [1, 2, 3, 4, 5]
+list(map(str, numbers))
+['1', '2', '3', '4', '5']
+divmod(3,7)
+(0, 3)
+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!.
+
+math.factorial(5)
+120
+math.sin(180)
+-0.8011526357338304
+heip(math.sin)
+Traceback (most recent call last):
+  File "<pyshell#26>", line 1, in <module>
+    heip(math.sin)
+NameError: name 'heip' is not defined. Did you mean: 'help'?
+help(math.sin)
+Help on built-in function sin in module math:
+
+sin(x, /)
+    Return the sine of x (measured in radians).
+
+help(math.acos)
+Help on built-in function acos in module math:
+
+acos(x, /)
+    Return the arc cosine (measured in radians) of x.
+
+    The result is between 0 and pi.
+
+math.acos(-0.8011526357338304)
+2.500015072176682
+heip(math.degrees)
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    heip(math.degrees)
+NameError: name 'heip' is not defined. Did you mean: 'help'?
+help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+math.degrees(180)
+10313.240312354817
+hep(math.exp)
+Traceback (most recent call last):
+  File "<pyshell#33>", line 1, in <module>
+    hep(math.exp)
+NameError: name 'hep' is not defined. Did you mean: 'hex'?
+help(math.exp)
+Help on built-in function exp in module math:
+
+exp(x, /)
+    Return e raised to the power of x.
+
+math.exp(2)
+7.38905609893065
+math.log(10)
+2.302585092994046
+math.log(8, 2)
+3.0
+math.log10(10)
+1.0
+math.sqrt(4)
+2.0
+math.ceil(2.3)
+3
+math.ceil(2.3)
+3
+math.floor(2.3)
+2
+math.floor(-2.3)
+-3
+math.ceil(-2.3)
+-2
+math.pi
+3.141592653589793
+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
+dir(random)
+Traceback (most recent call last):
+  File "<pyshell#50>", line 1, in <module>
+    dir(random)
+NameError: name 'random' is not defined. Did you forget to import 'random'?
+import random
+dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+random.seed()
+random.seed(42)
+random.random()
+0.6394267984578837
+random.uniform(5, 15)
+5.25010755222667
+random.randint(1, 100)
+36
+random.gauss(0, 1)
+0.017593105583573694
+a=[1,2,3,4,5,6,7]
+random.choice(a)
+1
+random.shuffle(a)
+a
+[4, 2, 3, 1, 5, 7, 6]
+random.sample(range(100), 5)
+[4, 3, 11, 27, 29]
+random.betavariate(2, 5)
+0.3918844780644009
+random.gammavariate(2, 1)
+2.219353519271194
+random_values = [
+    # 1. Равномерное распределение [0, 10)
+    random.uniform(0, 10),
+    
+    # 2. Нормальное распределение (mu=50, sigma=10)
+    random.gauss(50, 10),
+    
+    # 3. Бета-распределение (alpha=2, beta=5)
+    random.betavariate(2, 5),
+    
+    # 4. Гамма-распределение (alpha=3, beta=2)
+    random.gammavariate(3, 2)
+]
+random_values
+[5.892656838759088, 55.47961646339978, 0.5314696353281997, 2.163791803055314]
+distributions = [
+    "Равномерное [0, 10)",
+    "Нормальное (μ=50, σ=10)",
+    "Бета (α=2, β=5)",
+    "Гамма (α=3, β=2)"
+]
+list(zip(random_values, distributions))
+[(5.892656838759088, 'Равномерное [0, 10)'), (55.47961646339978, 'Нормальное (μ=50, σ=10)'), (0.5314696353281997, 'Бета (α=2, β=5)'), (2.163791803055314, 'Гамма (α=3, β=2)')]
+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
+1758211745.990668
+c2=time.time()-c1
+с2
+Traceback (most recent call last):
+  File "<pyshell#76>", line 1, in <module>
+    с2
+NameError: name 'с2' is not defined
+>>> c2
+87.25691390037537
+>>> dat=time.gmtime()
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
+>>> dat.tm_mon
+9
+>>> dat.tm_year
+2025
+>>> dat.tm_mday
+18
+>>> dat.tm_hour
+16
+>>> dat.tm_min
+12
+>>> dat.tm_sec
+46
+>>> dat.tm_wday
+3
+>>> dat.tm_yday
+261
+>>> dat.tm_isdst
+0

TEMA4/otchet.py

@@ -0,0 +1,39 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+dir(round)
+['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
+type(123.5)
+<class 'float'>
+type(round(123.0)
+     )
+<class 'int'>
+type(round(123.456,1))
+<class 'float'>
+>>> type(round(123.456,0))
+<class 'float'>
+>>> type(123.0)
+<class 'float'>
+>>> round(123.456)
+123
+>>> type(123)
+<class 'int'>
+>>> gg=range(76,123,9)
+>>> type(gg)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23)
+range(0, 23)
+>>> qq="Снегура"
+>>> qq=["Снегура", "Туровец", "Хатюхин", "Шабатов"]
+>>> ff=zip(gg,qq)
+>>> ff
+<zip object at 0x00000203B0C7EF40>
+>>> type(ff)
+<class 'zip'>
+>>> tuple(ff)
+((76, 'Снегура'), (85, 'Туровец'), (94, 'Хатюхин'), (103, 'Шабатов'))

TEMA4/report.md

@@ -0,0 +1,373 @@
+#Тема 4 Туровец Евгений
+## 2. Стандартные функции. Находятся в модуле builtins, который становится доступным без импорта при запуске среды IDLE.
+### 2.1. Функция round – округление числа с заданной точностью. 
+```py
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+type(round(123.456,1))
+<class 'float'>
+type(round(123.456,0))
+<class 'float'>
+type(123.0)
+<class 'float'>
+type(123.5)
+<class 'float'>
+round(123.456)
+123
+type(123)
+<class 'int'>
+type(round)
+<class 'builtin_function_or_method'>
+```
+### 2.2. Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+gg=range(76,123,9) #генерирует числа, начиная с 76 и прибавляя 9, пока не достигнет числа, которое больше или равно 123
+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 0x00000203B0C7EF40>
+type(ff) #количество элементов-кортежей в объекте определяется размерностью меньшего объекта 
+<class 'zip'>
+tuple(ff) 
+((76, 'Снегура'), (85, 'Туровец'), (94, 'Хатюхин'), (103, 'Шабатов'))
+ff[1]  #непосредственно объект ff, возвращаемый функцией zip, является итератором. У итераторов нет метода __getitem__, который позволяет обращаться к элементам по индексу. Попытка сделать это вызовет ошибку TypeError.
+Traceback (most recent call last):
+  File "<pyshell#21>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+c= list(zip(gg, qq)) #для обращения по индексу можно преобразовать в другой тип 
+c[1]
+(85, 'Туровец')
+```
+### 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и пред-ставленного в виде символьной строки. 
+```py
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=4
+dan
+-136.0
+```
+### 2.5. Функция exec – чтение и выполнение объекта-аргумента функции. Этот объект должен представ-лять собой строку символов  с совокупностью инструкций на языке Python. 
+```py
+exec(input('введите инструкции:')) #ввела perem=-123.456;gg=round(abs(perem)+98,3) после инструкции
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3) 
+gg
+221.456
+```
+### 2.6. Самостоятельно изучите и попробуйте применить функции abs, pow, max, min, sum, divmod, len, map.
+```py
+abs(-5)
+5
+```
+```py
+len('Длина строки')
+12
+```
+```py
+max(2,3,4)
+4
+```
+```py
+min(2,3,4)
+2
+```
+```py
+pow(2,3)
+8
+```
+```py
+sum(a) 
+22
+```
+```py
+numbers = [1, 2, 3, 4, 5]
+list(map(str, numbers))
+['1', '2', '3', '4', '5']
+```
+```py
+#divmod() — это встроенная функция, которая принимает два числа и возвращает пару чисел (кортеж), состоящую из результата целочисленного деления (частного) и остатка от деления.
+divmod(3,7)
+(0, 3)
+```
+## 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!.
+
+math.factorial(5)
+120
+math.sin(180) #из радиан в значение синуса
+-0.8011526357338304
+math.acos(-0.8011526357338304) #из радиан в значение косинуса
+2.500015072176682
+math.degrees(180) #из радиан в градусы
+10313.240312354817
+math.exp(2) #e в степени 2
+7.38905609893065
+math.log(10) #натуральный логарифм по основанию e
+2.302585092994046
+math.log(8, 2) #логарифм 8 по основанию 2
+3.0
+math.log10(10) #логарифм 10 по основанию 10
+1.0
+math.sqrt(4)
+2.0
+math.ceil(2.3) #наименьшее целое число, большее или равное 2.3(округление вверх)
+3
+math.ceil(-2.3)
+-2
+math.floor(2.3) #округление вниз
+2
+math.floor(-2.3)
+-3
+math.pi
+3.141592653589793
+```
+## 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', '__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(42)  # Фиксируем seed для одинаковых результатов
+#random() - равномерное распределение [0, 1)
+random.random()
+0.6394267984578837
+# uniform(a, b) - равномерное распределение [a, b]
+random.uniform(5, 15)
+5.25010755222667
+# randint(a, b) - случайное целое [a, b]
+random.randint(1, 100)
+36
+# gauss(mu, sigma) - нормальное распределение
+random.gauss(0, 1)
+0.017593105583573694
+# choice(sequence) - случайный выбор
+a=[1,2,3,4,5,6,7]
+random.choice(a)
+1
+# shuffle(sequence) - перемешивание
+random.shuffle(a)
+a
+[4, 2, 3, 1, 5, 7, 6]
+# sample(population, k) - выборка без повторений
+random.sample(range(100), 5)
+[4, 3, 11, 27, 29]
+# betavariate(alpha, beta) - бета-распределение
+random.betavariate(2, 5)
+0.3918844780644009
+# gammavariate(alpha, beta) - гамма-распределение
+random.gammavariate(2, 1)
+2.219353519271194
+```
+## 5.1. Создание списка с 4 случайными значениями
+```py
+random_values = [
+    # 1. Равномерное распределение [0, 10)
+    random.uniform(0, 10),
+    
+    # 2. Нормальное распределение (mu=50, sigma=10)
+    random.gauss(50, 10),
+    
+    # 3. Бета-распределение (alpha=2, beta=5)
+    random.betavariate(2, 5),
+    
+    # 4. Гамма-распределение (alpha=3, beta=2)
+    random.gammavariate(3, 2)
+]
+random_values
+[5.892656838759088, 55.47961646339978, 0.5314696353281997, 2.163791803055314]
+distributions = [
+    "Равномерное [0, 10)",
+    "Нормальное (μ=50, σ=10)",
+    "Бета (α=2, β=5)",
+    "Гамма (α=3, β=2)"
+]
+list(zip(random_values, distributions))
+[(5.892656838759088, 'Равномерное [0, 10)'), (55.47961646339978, 'Нормальное (μ=50, σ=10)'), (0.5314696353281997, 'Бета (α=2, β=5)'), (2.163791803055314, 'Гамма (α=3, β=2)')]
+```
+## 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() #функция time возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
+c1
+1758211745.990668
+c2=time.time()-c1 #временной интервал в секундах, со времени ввода предыдущей инструкции
+c2
+87.25691390037537
+dat=time.gmtime() #получение объекта класса struct_time, содержащего полную информацию о текущем времени. Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC). Московское время MSK опережает UTC на 3 часа
+dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
+dat.tm_mon
+9
+dat.tm_year
+2025
+dat.tm_mday
+18
+dat.tm_hour
+16
+dat.tm_min
+12
+dat.tm_sec
+46
+dat.tm_wday #День недели - четверг (дни недели: 0=понедельник, 1=вторник, 2=среда, 3=четверг, 4=пятница, 5=суббота, 6=воскресенье)
+3
+dat.tm_yday #День года - 261-й день в году (считая с 1 января = 1)
+261
+dat.tm_isdst #Летнее время - не действует (0 = зимнее время, 1 = летнее время, -1 = неизвестно)
+0
+```
+```py
+time.localtime() #Получение местного времени
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=19, tm_min=22, tm_sec=25, tm_wday=3, tm_yday=261, tm_isdst=0)
+time.asctime() #Получение текущего времени, представление времени из кортежа в строку
+'Thu Sep 18 19:26:35 2025'
+time.ctime() #Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+'Thu Sep 18 19:28:56 2025'
+time.sleep(3) #Прерывание работы программы на заданное время(3 секунды)
+time_tuple = (2025, 9, 18, 16, 12, 46, 3, 261, 0)
+time_obj = time.struct_time(time_tuple)
+time_obj
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, tm_isdst=0)
+seconds = time.mktime(time_obj) #Преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи
+seconds
+1758201166.0
+back_to_time = time.localtime(seconds) #Обратное преобразование
+back_to_time
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=16, tm_min=12, tm_sec=46, tm_wday=3, tm_yday=261, 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 0x0000027668162490>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show() #Отображение графика на экране
+```
+![alt text]({58781A87-6633-474F-A77A-BE36643822E4}.png)
+```py
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000027669976C10>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000027669976D50>]
+pylab.show()
+```
+![alt text]({32B82522-D8D5-43AA-9C7F-4991CE02A603}.png)
+```py
+# Данные для гистограмм и столбчатых диаграмм
+grades = [85, 92, 78, 65, 90, 85, 88, 72, 95, 81, 85, 90, 78, 85, 92]
+categories = ['A', 'B', 'C', 'D', 'F']
+values = [3, 7, 8, 2, 1]
+pylab.hist(grades, bins=5, edgecolor='black', alpha=0.7, color='skyblue')
+(array([1., 1., 3., 5., 5.]), array([65., 71., 77., 83., 89., 95.]), <BarContainer object of 5 artists>)
+pylab.title('Гистограмма распределения оценок')
+Text(0.5, 1.0, 'Гистограмма распределения оценок')
+pylab.xlabel('Оценки')
+Text(0.5, 0, 'Оценки')
+pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+```
+![alt text]({A5B2DC00-DB40-42EF-B410-DAA0781F2422}.png)
+```py
+pylab.bar(categories, values, color=['red', 'orange', 'yellow', 'green', 'blue'], alpha=0.7)
+<BarContainer object of 5 artists>
+pylab.title('Столбчатая диаграмма распределения по категориям')
+Text(0.5, 1.0, 'Столбчатая диаграмма распределения по категориям')
+pylab.xlabel('Категории')
+Text(0.5, 0, 'Категории')
+pylab.ylabel('Количество')
+Text(0, 0.5, 'Количество')
+pylab.grid(axis='y', alpha=0.75)
+pylab.show()
+```
+![alt text]({7D368B80-7126-4808-B3BC-84E476BAECC5}.png)
+```py
+# Данные для статистического анализа
+data = [23, 45, 67, 34, 89, 56, 72, 41, 58, 64, 39, 51, 47, 62, 55]
+import statistics
+mean_value = statistics.mean(data)
+median_value = statistics.median(data)
+mode_value = statistics.mode(data)
+stdev_value = statistics.stdev(data)
+variance_value = statistics.variance(data)
+quantiles_value = statistics.quantiles(data, n=4)
+harmonic_mean_value = statistics.harmonic_mean(data)
+pylab.hist(data, bins=6, edgecolor='black', alpha=0.7, color='lightgreen', label='Распределение данных')
+(array([1., 3., 4., 4., 2., 1.]), array([23., 34., 45., 56., 67., 78., 89.]), <BarContainer object of 6 artists>)
+pylab.axvline(mean_value, color='red', linestyle='--', linewidth=2, label=f'Среднее: {mean_value:.2f}')
+<matplotlib.lines.Line2D object at 0x000002766864C2D0>
+pylab.axvline(median_value, color='blue', linestyle='--', linewidth=2, label=f'Медиана: {median_value}')
+<matplotlib.lines.Line2D object at 0x000002766864C410>
+pylab.axvline(mode_value, color='green', linestyle='--', linewidth=2, label=f'Мода: {mode_value}')
+<matplotlib.lines.Line2D object at 0x000002766864C550>
+pylab.title('Гистограмма данных со статистическими показателями')
+Text(0.5, 1.0, 'Гистограмма данных со статистическими показателями')
+pylab.xlabel('Значения')
+Text(0.5, 0, 'Значения')
+pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+pylab.legend()
+<matplotlib.legend.Legend object at 0x000002766813F620>
+pylab.grid(alpha=0.3)
+pylab.show()
+```
+![alt text]({30B6F251-3FE2-4A0E-9F0D-99FBE95923B5}.png)

TEMA4/zadanie.md

@@ -0,0 +1,51 @@
+# Контрольное задание по ЛР4
+## Туровец Евгений В23
+### Задание:
+```
+	Напишите инструкцию запоминания в переменной Московского регионального времени.
+ Добавьте к этому времени 3 часа. Переведите полученное время в секунды от начала эпохи.
+ Отобразите результат в виде: «Число секунд =ХХХХХ». Создайте комплексное число, у которого вещественная и мнимая части – случайные,
+ нормально распределенные числа с математическим ожиданием -55 и стандартным отклонением 12. Извлеките из этого числа квадратный корень.
+ Отобразите результат в виде: «Результат = ХХХ+ХХj»
+```
+Решение:
+
+```py
+import time
+import random
+import cmath
+
+# Получаем текущее время в секундах от начала эпохи (MSC)
+current_seconds = time.time()
+
+# Преобразуем в читаемый формат с помощью gmtime
+moscow_time = time.ctime(current_seconds)
+print(f"Текущее Московское время: {moscow_time}")
+
+# Добавляем еще 3 часа
+new_seconds = current_seconds + (3*60*60)
+new_time = time.ctime(new_seconds)
+
+print(f"Московское время + 3 часа: {new_time}")
+print(f"Число секунд = {int(new_seconds)}")
+
+# 2. Комплексное число с нормально распределенными частями
+mean = -55
+std_dev = 12
+
+real_part = random.gauss(mean, std_dev)
+imag_part = random.gauss(mean, std_dev)
+
+complex_num = complex(real_part, imag_part)
+sqrt_result = cmath.sqrt(complex_num)
+
+print(f"Результат = {sqrt_result}")
+```
+Вывод:
+
+```
+Текущее Московское время: 13.10.2025 14:35:44
+Московское время + 3 часа: 13.10.2025 17:35:44
+Число секунд = 1760376944
+Результат = (2.5860782837869523-8.943261083279255j)
+```

TEMA4/zadanie.py

@@ -0,0 +1,29 @@
+import time
+import random
+import cmath
+
+# Получаем текущее время в секундах от начала эпохи (MSC)
+current_seconds = time.time()
+
+# Преобразуем в читаемый формат с помощью gmtime
+moscow_time = time.ctime(current_seconds)
+print(f"Текущее Московское время: {moscow_time}")
+
+# Добавляем еще 3 часа
+new_seconds = current_seconds + (3*60*60)
+new_time = time.ctime(new_seconds)
+
+print(f"Московское время + 3 часа: {new_time}")
+print(f"Число секунд = {int(new_seconds)}")
+
+# 2. Комплексное число с нормально распределенными частями
+mean = -55
+std_dev = 12
+
+real_part = random.gauss(mean, std_dev)
+imag_part = random.gauss(mean, std_dev)
+
+complex_num = complex(real_part, imag_part)
+sqrt_result = cmath.sqrt(complex_num)
+
+print(f"Результат = {sqrt_result}")

TEMA5/32232.py

@@ -0,0 +1,13 @@
+a = 1
+b= 0
+
+while a<5:
+    if a % 2 != 0 and a<5:
+        b+= 1
+        print(a)
+    if b == 3:
+        print("конец")
+        break
+    
+    a = a + 2
+else: print("fdgdgfdgdfgfdg")

TEMA5/control_task_results.txt

@@ -0,0 +1,31 @@
+Результаты выполнения контрольного задания
+==================================================
+
+1. Порядковые номера букв в тексте:
+Буква 'p': позиции [16, 16, 16, 16, 16]
+Буква 'y': позиции [25]
+Буква 't': позиции [20, 20, 20]
+Буква 'h': позиции [8, 8, 8]
+Буква 'o': позиции [15, 15, 15]
+Буква 'n': позиции [14, 14, 14, 14, 14, 14]
+Буква 'i': позиции [9, 9, 9, 9]
+Буква 's': позиции [19, 19]
+Буква 'a': позиции [1, 1, 1, 1, 1]
+Буква 'e': позиции [5, 5, 5, 5, 5, 5, 5, 5, 5]
+Буква 'r': позиции [18, 18, 18, 18, 18, 18]
+Буква 'd': позиции [4]
+Буква 'g': позиции [7, 7, 7, 7, 7, 7]
+Буква 'l': позиции [12, 12, 12, 12]
+Буква 'v': позиции [22]
+Буква 'u': позиции [21, 21]
+Буква 'm': позиции [13, 13]
+
+2. Результаты поиска слов:
+Слово 'строки' найдено: True
+Слово 'программирование' найдено: False
+
+3. Данные студентов:
+Туровец: лето - 4.5, зима - 4.3
+Снегура: лето - 3.8, зима - 4.6
+Ефремов: лето - 4.2, зима - 3.9
+Хатюхин: лето - 4.7, зима - 4.8

TEMA5/kz.md

@@ -0,0 +1,42 @@
+# 30.Создайте кортеж с 50 случайными целочисленными значениями из диапазона от 20 до 40. Определите,
+ сколько среди этих значений четных и сколько кратных 3, 4 и 5.
+### Код:
+```py 
+import random
+
+numbers = tuple(random.randint(20, 40) for _ in range(50))
+
+print("Кортеж:", numbers)
+
+a = 0
+b = 0
+c = 0
+s = 0
+
+
+for num in numbers:
+    if num % 2 == 0:
+        a += 1
+    if num % 3 == 0:
+        b+= 1
+    if num % 4 == 0:
+        c += 1
+    if num % 5 == 0:
+        s += 1
+
+print(f"\nРезультаты анализа:")
+print(f"Четных чисел: {a}")
+print(f"Кратных 3: {b}")
+print(f"Кратных 4: {c}")
+print(f"Кратных 5: {s}")
+```
+Вывод:
+```
+Кортеж: (37, 24, 26, 29, 39, 23, 24, 21, 23, 29, 21, 31, 37, 35, 22, 28, 29, 22, 24, 38, 24, 27, 24, 34, 22, 38, 20, 28, 28, 22, 27, 24, 30, 33, 35, 32, 36, 29, 20, 33, 27, 36, 28, 23, 29, 38, 31, 28, 34, 27)
+
+Результаты анализа:
+Четных чисел: 27
+Кратных 3: 18
+Кратных 4: 16
+Кратных 5: 5
+```

TEMA5/kz.py

@@ -0,0 +1,27 @@
+import random
+
+numbers = tuple(random.randint(20, 40) for _ in range(50))
+
+print("Кортеж:", numbers)
+
+a = 0
+b = 0
+c = 0
+s = 0
+
+
+for num in numbers:
+    if num % 2 == 0:
+        a += 1
+    if num % 3 == 0:
+        b+= 1
+    if num % 4 == 0:
+        c += 1
+    if num % 5 == 0:
+        s += 1
+
+print(f"\nРезультаты анализа:")
+print(f"Четных чисел: {a}")
+print(f"Кратных 3: {b}")
+print(f"Кратных 4: {c}")
+print(f"Кратных 5: {s}")

TEMA5/obshee_kz.md

@@ -0,0 +1,159 @@
+# общее контрольное задание
+## 1. Для заданной символьной строки с англоязычным текстом определите порядковый номер каждой буквы в английском алфавите.
+```py
+def letter_positions(text): #Объявление функции с именем letter_positions, которая принимает один параметр text (текст для анализа).
+    """Определяет порядковый номер каждой буквы в английском алфавите""" #Строка документации - описание того, что делает функция.
+    result = {} #Создание пустого словаря result, где: ключи - буквы алфавита;значения - списки позиций этих букв в тексте
+    for char in text.lower(): #Цикл по каждому символу текста. Метод .lower() преобразует весь текст в нижний регистр, чтобы 'A' и 'a' считались одинаковыми буквами.
+        if 'a' <= char <= 'z': #Проверка: является ли символ английской буквой. Отсеивает пробелы, цифры, знаки препинания и т.д.
+            position = ord(char) - ord('a') + 1 #Вычисление порядкового номера буквы: ord(char) - получает ASCII-код символа; ord('a') - ASCII-код буквы 'a' (97); Вычитание дает смещение от 'a' (например: 'c' - 'a' = 2); + 1 - чтобы нумерация была с 1, а не с 0
+            if char in result: #Проверка: есть ли уже такая буква в словаре
+                result[char].append(position) #Если буква уже есть - добавляем новую позицию в существующий список
+            else:
+                result[char] = [position] #Если буквы еще нет - создаем новую запись в словаре со списком из одной позиции
+    return result #Возврат результата - готового словаря с позициями всех букв
+# Текст из помощи Python
+help_text = "Python is an interpreted, high-level, general-purpose programming language."
+positions = letter_positions(help_text)
+print("1. Порядковые номера букв в тексте:")
+1. Порядковые номера букв в тексте:
+for letter, pos_list in positions.items():
+    print(f"Буква '{letter}': позиции {pos_list}")
+
+    
+Буква 'p': позиции [16, 16, 16, 16, 16]
+Буква 'y': позиции [25]
+Буква 't': позиции [20, 20, 20]
+Буква 'h': позиции [8, 8, 8]
+Буква 'o': позиции [15, 15, 15]
+Буква 'n': позиции [14, 14, 14, 14, 14, 14]
+Буква 'i': позиции [9, 9, 9, 9]
+Буква 's': позиции [19, 19]
+Буква 'a': позиции [1, 1, 1, 1, 1]
+Буква 'e': позиции [5, 5, 5, 5, 5, 5, 5, 5, 5]
+Буква 'r': позиции [18, 18, 18, 18, 18, 18]
+Буква 'd': позиции [4]
+Буква 'g': позиции [7, 7, 7, 7, 7, 7]
+Буква 'l': позиции [12, 12, 12, 12]
+Буква 'v': позиции [22]
+Буква 'u': позиции [21, 21]
+Буква 'm': позиции [13, 13]
+```
+## 2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение.
+```py
+# Создаем список из слов этого задания
+task_words = ["Для", "заданной", "символьной", "строки", "с", "англоязычным", 
+             "текстом", "определите", "порядковый", "номер", "каждой", "буквы"]
+print("\n2. Поиск слова в списке:")
+
+2. Поиск слова в списке:
+print(f"Список слов: {task_words}")
+Список слов: ['Для', 'заданной', 'символьной', 'строки', 'с', 'англоязычным', 'текстом', 'определите', 'порядковый', 'номер', 'каждой', 'буквы']
+# Проверяем наличие существующего слова
+search_word = "строки"
+if search_word in task_words:
+    print(f"Слово '{search_word}' найдено в списке")
+else:
+    print(f"Слово '{search_word}' отсутствует в списке")
+
+    
+Слово 'строки' найдено в списке
+# Проверяем наличие отсутствующего слова
+search_word = "программирование"
+if search_word in task_words:
+    print(f"Слово '{search_word}' найдено в списке")
+else:
+    print(f"Слово '{search_word}' отсутствует в списке")
+
+Слово 'программирование' отсутствует в списке
+```
+## 3. Создайте список студентов и списки баллов
+```py
+# Список студентов
+students = ["Туровец", "Снегура", "Ефремов", "Хатюхин"]
+# Баллы за летнюю сессию (в порядке списка студентов)
+summer_grades = [4.5, 3.8, 4.2, 4.7]
+# Баллы за зимнюю сессию (в другом порядке)
+winter_grades = [4.3, 4.6, 3.9, 4.8]
+print("\n3. Поиск средних баллов студента:")
+
+3. Поиск средних баллов студента:
+# Запрашиваем фамилию студента
+student_name = input("Введите фамилию студента: ")
+Введите фамилию студента: Снегура
+if student_name in students:
+    # Находим индекс студента
+    student_index = students.index(student_name)
+    
+    # Получаем баллы за летнюю сессию
+    summer_grade = summer_grades[student_index]
+    
+    # Для зимней сессии создаем словарь для быстрого поиска
+    winter_dict = dict(zip(students, winter_grades))
+    winter_grade = winter_dict[student_name]
+    
+    print(f"Студент {student_name}:")
+    print(f"  Летняя сессия: {summer_grade}")
+    print(f"  Зимняя сессия: {winter_grade}")
+    print(f"  Средний балл: {(summer_grade + winter_grade) / 2:.2f}")
+else:
+    print(f"Студент {student_name} не найден в списке")
+
+    
+Студент Туровец:
+  Летняя сессия: 4.5
+  Зимняя сессия: 4.3
+  Средний балл: 4.40
+# Дополнительно: вывод всех студентов с их баллами
+for i, student in enumerate(students):
+    winter_grade = winter_grades[i]  # winter_grades уже в правильном порядке
+    print(f"{student}: лето - {summer_grades[i]}, зима - {winter_grade}")
+# Сохранение результатов в файл
+with open('control_task_results.txt', 'w', encoding='utf-8') as f:
+    f.write("Результаты выполнения контрольного задания\n")
+    f.write("=" * 50 + "\n\n")
+    
+    f.write("1. Порядковые номера букв в тексте:\n")
+    for letter, pos_list in positions.items():
+        f.write(f"Буква '{letter}': позиции {pos_list}\n")
+    
+    f.write("\n2. Результаты поиска слов:\n")
+    f.write(f"Слово 'строки' найдено: {'строки' in task_words}\n")
+    f.write(f"Слово 'программирование' найдено: {'программирование' in task_words}\n")
+    
+    f.write("\n3. Данные студентов:\n")
+    for i, student in enumerate(students):
+        f.write(f"{student}: лето - {summer_grades[i]}, зима - {winter_grades[i]}\n")
+
+43
+52
+36
+40
+24
+32
+29
+32
+44
+32
+28
+35
+47
+44
+23
+38
+36
+24
+28
+28
+28
+29
+40
+22
+32
+32
+32
+32
+print("\nРезультаты сохранены в файл 'control_task_results.txt'")
+
+Результаты сохранены в файл 'control_task_results.txt'
+```

TEMA5/obshee_kz.py

@@ -0,0 +1,97 @@
+
+def letter_positions(text):
+    """Определяет порядковый номер каждой буквы в английском алфавите"""
+    result = {}
+    for char in text.lower():
+        if 'a' <= char <= 'z':
+            position = ord(char) - ord('a') + 1
+            if char in result:
+                result[char].append(position)
+            else:
+                result[char] = [position]
+    return result
+
+help_text = "Python is an interpreted, high-level, general-purpose programming language."
+positions = letter_positions(help_text)
+print("1. Порядковые номера букв в тексте:")
+#1. Порядковые номера букв в тексте:
+for letter, pos_list in positions.items():
+    print(f"Буква '{letter}': позиции {pos_list}")
+
+task_words = ["Для", "заданной", "символьной", "строки", "с", "англоязычным", 
+             "текстом", "определите", "порядковый", "номер", "каждой", "буквы"]
+print("\n2. Поиск слова в списке:")
+
+#2. Поиск слова в списке:
+print(f"Список слов: {task_words}")
+search_word = "строки"
+if search_word in task_words:
+    print(f"Слово '{search_word}' найдено в списке")
+else:
+    print(f"Слово '{search_word}' отсутствует в списке")
+
+    
+search_word = "программирование"
+if search_word in task_words:
+    print(f"Слово '{search_word}' найдено в списке")
+else:
+    print(f"Слово '{search_word}' отсутствует в списке")
+
+students = ["Туровец", "Снегура", "Ефремов", "Хатюхин"]
+summer_grades = [4.5, 3.8, 4.2, 4.7]
+winter_grades = [4.3, 4.6, 3.9, 4.8]
+print("\n3. Поиск средних баллов студента:")
+
+#3. Поиск средних баллов студента:
+student_name = input("Введите фамилию студента: ")
+if student_name in students:
+    # Находим индекс студента
+    student_index = students.index(student_name)
+    
+    # Получаем баллы за летнюю сессию
+    summer_grade = summer_grades[student_index]
+    
+    # Для зимней сессии создаем словарь для быстрого поиска
+    winter_dict = dict(zip(students, winter_grades))
+    winter_grade = winter_dict[student_name]
+    
+    print(f"Студент {student_name}:")
+    print(f"  Летняя сессия: {summer_grade}")
+    print(f"  Зимняя сессия: {winter_grade}")
+    print(f"  Средний балл: {(summer_grade + winter_grade) / 2:.2f}")
+else:
+    print(f"Студент {student_name} не найден в списке")
+
+print("\nВсе студенты и их баллы:")
+for i, student in enumerate(students):
+    winter_grade = winter_grades[i]  # winter_grades уже в правильном порядке
+    print(f"{student}: лето - {summer_grades[i]}, зима - {winter_grade}")
+
+
+print("\nВсе студенты и их баллы:")
+
+
+for i, student in enumerate(students):
+    winter_grade = winter_grades[i]  # winter_grades уже в правильном порядке
+    print(f"{student}: лето - {summer_grades[i]}, зима - {winter_grade}")
+
+    
+
+with open('control_task_results.txt', 'w', encoding='utf-8') as f:
+    f.write("Результаты выполнения контрольного задания\n")
+    f.write("=" * 50 + "\n\n")
+    
+    f.write("1. Порядковые номера букв в тексте:\n")
+    for letter, pos_list in positions.items():
+        f.write(f"Буква '{letter}': позиции {pos_list}\n")
+    
+    f.write("\n2. Результаты поиска слов:\n")
+    f.write(f"Слово 'строки' найдено: {'строки' in task_words}\n")
+    f.write(f"Слово 'программирование' найдено: {'программирование' in task_words}\n")
+    
+    f.write("\n3. Данные студентов:\n")
+    for i, student in enumerate(students):
+        f.write(f"{student}: лето - {summer_grades[i]}, зима - {winter_grades[i]}\n")
+print("\nРезультаты сохранены в файл 'control_task_results.txt'")
+
+

TEMA5/otche.py

@@ -0,0 +1,182 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+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
+sps2
+[0.0, 0.049958374957880025, 0.09966799462495568, 0.14888503362331795, 0.197375320224904, 0.2449186624037092, 0.2913126124515909, 0.3363755443363322, 0.3799489622552249, 0.421899005250008, 0.4621171572600098, 0.5005202111902354, 0.5370495669980353, 0.5716699660851172, 0.6043677771171636, 0.6351489523872873, 0.6640367702678489, 0.6910694698329307, 0.7162978701990245, 0.7397830512740043, 0.7615941559557649, 0.7818063576087741, 0.8004990217606297, 0.8177540779702878, 0.8336546070121553, 0.8482836399575129, 0.8617231593133063, 0.874053287886007, 0.8853516482022625, 0.8956928738431645, 0.9051482536448664, 0.9137854901178277, 0.9216685544064713, 0.9288576214547277, 0.935409070603099, 0.9413755384972874, 0.9468060128462683, 0.9517459571646616, 0.9562374581277391]
+stroka = 'Расчет процесса в объекте регулирования'
+i = 0
+sps2 = []
+time_points = []  # Создадим список для моментов времени
+while i < len(stroka):
+    r = 1 - 2 / (1 + math.exp(0.1 * i))
+    sps2.append(r)
+    time_points.append(i)  # Запоминаем момент времени
+    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
+plt.plot(time_points, sps2, 'b-', marker='o', linewidth=2, markersize=4, label='Выходной сигнал инерционного звена')
+Traceback (most recent call last):
+  File "<pyshell#15>", line 1, in <module>
+    plt.plot(time_points, sps2, 'b-', marker='o', linewidth=2, markersize=4, label='Выходной сигнал инерционного звена')
+NameError: name 'plt' is not defined
+import matplotlib.pyplot as plt
+plt.plot(time_points, sps2, 'b-', marker='o', linewidth=2, markersize=4, label='Выходной сигнал инерционного звена')
+[<matplotlib.lines.Line2D object at 0x000001B8EE6F9450>]
+plt.title('Сигнал на выходе инерционного звена\n(Переходная характеристика)')
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена\n(Переходная характеристика)')
+plt.xlabel('Время, i (дискр. отсчеты)')
+Text(0.5, 0, 'Время, i (дискр. отсчеты)')
+plt.ylabel('Значение сигнала, r(i)')
+Text(0, 0.5, 'Значение сигнала, r(i)')
+plt.grid(True, which='major', linestyle='--', linewidth=0.5)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B8EE711010>
+plt.show()
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		# Для значений chislo > 1
+while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+                                print(chislo, ' является простым!')
+
+                                
+267  имеет множитель  89
+for chislo in range(250, 301):
+    if chislo < 2:  # Числа меньше 2 не являются простыми
+        continue
+... 
+...     
+>>> 
+>>> 
+>>> 
+>>> for chislo in range(250, 301):
+...     if chislo < 2:  # Числа меньше 2 не являются простыми
+...         continue
+...     
+...     # Проверяем делители от 2 до квадратного корня из числа (оптимизация)
+...     kandidat = int(chislo ** 0.5) + 1
+...     is_prime = True
+...     
+...     while kandidat > 1:
+...         if chislo % kandidat == 0:
+...             # Найден делитель, число не простое
+...             is_prime = False
+...             break
+...         kandidat -= 1
+...     
+...     if is_prime:
+...         print(chislo, 'является простым!')
+... 
+...         
+251 является простым!
+257 является простым!
+263 является простым!
+269 является простым!
+271 является простым!
+277 является простым!
+281 является простым!
+283 является простым!
+293 является простым!

TEMA5/otchet.py

@@ -0,0 +1,137 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+porog=4
+rashod1=7
+rashod2=11
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+
+dohod
+12
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+
+dohod
+12
+del dohod
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+
+			
+dohod
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    dohod
+NameError: name 'dohod' is not defined
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+
+dohod
+2
+del dohod
+dohod=2 if porog>=4 else 0
+dohod
+2
+if porog>=5 : rashod1=6; rashod2=0
+
+rashod1
+7
+rashod2
+11
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+
+SyntaxError: multiple statements found while compiling a single statement
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+
+	
+temperatura
+50
+sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+	
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+sps=[2,15,14,8]
+for k in sps[:]:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+import random as rn
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+369
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+438
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+495
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+	
+SyntaxError: multiple statements found while compiling a single statement
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+
+	
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+>>> 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]

TEMA5/report.md

@@ -0,0 +1,297 @@
+# Тема 5. Блоки инструкций, управляющие инструкции 
+## 2. Изучите ветвление по условию – управляющая инструкция if. Общее правило написания:
+if <условие>:
+<отступы><Блок инструкций, выполняемый, если условие истинно>
+      [elif <условие2>:
+<отступы><Блок инструкций2, выполняемый, если условие2 истинно>
+]
+[else:
+< отступы><Блок инструкций3, выполняемый, если условие ложно>
+]
+```py
+porog=4
+rashod1=7
+rashod2=11
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+
+dohod
+12
+del dohod
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+
+			
+dohod
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    dohod
+NameError: name 'dohod' is not defined
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+
+dohod
+2
+```
+```py
+del dohod
+dohod=2 if porog>=4 else 0
+dohod
+2
+if porog>=5 : rashod1=6; rashod2=0
+
+rashod1
+7
+rashod2
+11
+```
+## 3.Цикл по перечислению – управляющая инструкция for. Общее правило написания:
+for <Объект-переменная цикла> in <объект>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else: 
+< отступы ><Блок инструкций 2 – если  в цикле не сработал break>]
+### 3.1. 
+```py
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+
+	
+temperatura
+50
+```
+### 3.2.
+#### 3.2.1.
+```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]
+```
+#### 3.2.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]
+#Отличие: Во втором случае используется sps[:] - это создает копию списка для итерации.
+```
+### 3.3. Пример: создание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
+```py
+import random as rn
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+369
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+438
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+495
+#Возможные сценарии:
+#Сумма НЕ превысила 500 за 10 итераций → цикл завершается естественно → выполняется else → выводится сумма
+
+#Сумма превысила 500 на какой-то итерации → срабатывает break → цикл прерывается → else НЕ выполняется
+```
+### 3.4. 
+```py
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+
+	
+stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+### 3.5. 
+```py
+import math
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+import pylab
+pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x000002A57ED02490>]
+pylab.title('Синусоидальный сигнал')
+Text(0.5, 1.0, 'Синусоидальный сигнал')
+pylab.xlabel('Отсчеты')
+Text(0.5, 0, 'Отсчеты')
+pylab.ylabel('Амплитуда')
+Text(0, 0.5, 'Амплитуда')
+pylab.show()
+```
+![alt text]({CB8B8C9B-3DFE-45B6-85B7-10ABD03573AA}.png)
+## 4. Цикл «пока истинно условие» – управляющая инструкция while. Общее правило написания:
+# while <Условие>:
+# <отступы><Блок инструкций 1 – тело цикла>
+# [else:
+# <отступы><Блок инструкций 2 – если в цикле не сработал break>]
+### 4.1. Цикл со счетчиком.
+```py
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+# Цикл завершился, потому что условие while rashod: стало ложным (False), когда значение переменной rashod достигло 0.
+```
+### 4.2. Пример с символьной строкой
+```py
+import math
+stroka = 'Расчет процесса в объекте регулирования'
+i = 0
+sps2 = []
+time_points = []  # Создадим список для моментов времени
+while i < len(stroka):
+    r = 1 - 2 / (1 + math.exp(0.1 * i))
+    sps2.append(r)
+    time_points.append(i)  # Запоминаем момент времени
+    print('Значение в момент', i, "=", r)
+    i += 1
+
+    
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+import matplotlib.pyplot as plt
+plt.plot(time_points, sps2, 'b-', marker='o', linewidth=2, markersize=4, label='Выходной сигнал инерционного звена')
+[<matplotlib.lines.Line2D object at 0x000001B8EE6F9450>]
+plt.title('Сигнал на выходе инерционного звена\n(Переходная характеристика)')
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена\n(Переходная характеристика)')
+plt.xlabel('Время, i (дискр. отсчеты)')
+Text(0.5, 0, 'Время, i (дискр. отсчеты)')
+plt.ylabel('Значение сигнала, r(i)')
+Text(0, 0.5, 'Значение сигнала, r(i)')
+plt.grid(True, which='major', linestyle='--', linewidth=0.5)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B8EE711010>
+plt.show()
+```
+![alt text]({82E82C36-9007-4A55-9244-B2D65C9C50FB}.png)
+### 4.3. Определение, является ли число простым (делится только на самого себя или 1).
+```py
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		# Для значений chislo > 1
+while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+         print(chislo, ' является простым!')
+
+                                
+267  имеет множитель  89
+```
+```py
+# Проверка простых чисел в диапазоне от 250 до 300
+for chislo in range(250, 301):
+    if chislo < 2:  # Числа меньше 2 не являются простыми
+        continue
+    
+    # Проверяем делители от 2 до квадратного корня из числа (оптимизация)
+	#Если число составное, то у него есть хотя бы один делитель, не превышающий его квадратного корня. Поэтому достаточно проверять делители только до √n, так как больший делитель автоматически подразумевает существование меньшего парного делителя.
+    kandidat = int(chislo ** 0.5) + 1
+    is_prime = True
+    
+    while kandidat > 1:
+        if chislo % kandidat == 0:
+            # Найден делитель, число не простое
+            is_prime = False
+            break
+        kandidat -= 1
+    
+    if is_prime:
+        print(chislo, 'является простым!')
+
+        
+251 является простым!
+257 является простым!
+263 является простым!
+269 является простым!
+271 является простым!
+277 является простым!
+281 является простым!
+283 является простым!
+293 является простым!
+```

TEMA6/Modul.md

@@ -0,0 +1,41 @@
+# Вариант 29 Туровец Евгений Юрьевич
+## Задание:
+```
+1)	Создайте словарь с 4 элементами. Ключи элементов: Институт, Кафедра, Группа, Студенты. Значения - списки из 3-4 элементов. Например, "Институт":[АВТИ, ИЭЭ, ИРЭ].
+
+2)	Запросите у пользователя и введите значение ключа словаря. Проверьте его наличие среди существующих значений ключей. При отсутствии - выдайте сообщение и повторите запрос.
+
+3)	Отобразите на экране значения для указанного пользователем ключа по шаблону: "Ключ = <Указанное значение ключа> : Значения = <Список значений ключа>"
+
+4)	Запишите словарь в бинарный файл с некоторым именем.
+
+5)	Удалите словарь из памяти.
+```
+Код реализации:
+```py
+import pickle
+data = {
+    "Институт": ["ИВТИ", "ИЭЭ", "ИРЭ"],
+    "Кафедра": ["Информатика", "Математика", "Физика"],
+    "Группа": ["А-02-23", "ПИ-22", "ПИ-23"],
+    "Студенты": ["Туровец", "Петров", "Сидоров"]
+}
+while True:
+    key = input("Введите ключ (Институт, Кафедра, Группа, Студенты): ")
+    if key in data:
+        break
+    print("Такого ключа нет! Попробуйте еще раз.")
+print(f"Ключ = {key} : Значения = {data[key]}")
+with open("data.bin", "wb") as f:
+    pickle.dump(data, f)
+del data
+print("Словарь удален из памяти")
+```
+Пример вывода:
+```
+Введите ключ (Институт, Кафедра, Группа, Студенты): авыаыв
+Такого ключа нет! Попробуйте еще раз.
+Введите ключ (Институт, Кафедра, Группа, Студенты): Студенты
+Ключ = Студенты : Значения = ['Туровец', 'Петров', 'Сидоров']
+Словарь удален из памяти
+```

TEMA6/Stroka.txt

@@ -0,0 +1 @@
+запись строки в файл

TEMA6/iz25.md

@@ -0,0 +1,98 @@
+## #Задание:
+
+# Создайте список с 10 элементами - комплексными числами, у которых вещественная и мнимая части - случайные целые числа в диапазоне значений [-10, 30].
+
+# Запросите у пользователя имя текстового файла для вывода.
+
+# Запишите список в этот файл по одному числу на строке.
+
+# Удалите список из памяти
+
+# Прочитайте содержимое файла в новый список
+
+```py
+import random
+
+# 1) Создание списка комплексных чисел
+complex_list = []
+for i in range(10):
+    real_part = random.randint(-10, 30)
+    imag_part = random.randint(-10, 30)
+    complex_num = complex(real_part, imag_part)
+    complex_list.append(complex_num)
+
+print("Созданный список комплексных чисел:")
+for i, num in enumerate(complex_list):
+    print(f"Элемент {i+1}: {num}")
+
+Элемент 1: (9-2j)
+Элемент 2: (13+7j)
+Элемент 3: (5+9j)
+Элемент 4: (14-7j)
+Элемент 5: (30-6j)
+Элемент 6: (24+26j)
+Элемент 7: (18+24j)
+Элемент 8: (13+9j)
+Элемент 9: (-7-3j)
+Элемент 10: (-3+0j)
+
+# 2) Запрос имени файла
+filename = input("Введите имя текстового файла для вывода: ")
+
+# 3) Запись списка в файл
+with open(filename, 'w', encoding='utf-8') as file:
+    for complex_num in complex_list:
+        file.write(str(complex_num) + '\n')
+
+7
+8
+7
+8
+8
+9
+9
+8
+8
+8
+print(f"Список записан в файл: {filename}")
+Список записан в файл: iz25.txt
+
+# 4) Удаление списка из памяти
+del complex_list
+
+# Проверка удаления
+try:
+    print(complex_list)
+except NameError:
+    print("Список complex_list успешно удален из памяти")
+
+Список complex_list успешно удален из памяти    
+
+# 5) Чтение содержимого файла в новый список
+new_complex_list = []
+with open(filename, 'r', encoding='utf-8') as file:
+    for line in file:
+        line = line.strip()
+        # Преобразование строки обратно в комплексное число
+        complex_num = complex(line.replace('(','').replace(')',''))
+        new_complex_list.append(complex_num)
+
+print("\nПрочитанный из файла список комплексных чисел:")
+
+Прочитанный из файла список комплексных чисел:
+for i, num in enumerate(new_complex_list):
+    print(f"Элемент {i+1}: {num}")
+
+Элемент 1: (9-2j)
+Элемент 2: (13+7j)
+Элемент 3: (5+9j)
+Элемент 4: (14-7j)
+Элемент 5: (30-6j)
+Элемент 6: (24+26j)
+Элемент 7: (18+24j)
+Элемент 8: (13+9j)
+Элемент 9: (-7-3j)
+Элемент 10: (-3+0j)
+print(f"Всего прочитано {len(new_complex_list)} элементов")
+Всего прочитано 10 элементов
+```

TEMA6/iz25.py

@@ -0,0 +1,111 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+import random
+complex_list = []
+for i in range(10):
+    real_part = random.randint(-10, 30)
+    imag_part = random.randint(-10, 30)
+    complex_num = complex(real_part, imag_part)
+    complex_list.append(complex_num)
+
+    
+print("Созданный список комплексных чисел:")
+Созданный список комплексных чисел:
+for i, num in enumerate(complex_list):
+    print(f"Элемент {i+1}: {num}")
+
+    
+Элемент 1: (9-2j)
+Элемент 2: (13+7j)
+Элемент 3: (5+9j)
+Элемент 4: (14-7j)
+Элемент 5: (30-6j)
+Элемент 6: (24+26j)
+Элемент 7: (18+24j)
+Элемент 8: (13+9j)
+Элемент 9: (-7-3j)
+Элемент 10: (-3+0j)
+filename = input("Введите имя текстового файла для вывода: ")
+Введите имя текстового файла для вывода: iz25.txt
+with open(filename, 'w', encoding='utf-8') as file:
+    for complex_num in complex_list:
+        file.write(str(complex_num) + '\n')
+
+        
+7
+8
+7
+8
+8
+9
+9
+8
+8
+8
+print(f"Список записан в файл: {filename}")
+Список записан в файл: iz25.txt
+del complex_list
+try:
+    print(complex_list)
+except NameError:
+    print("Список complex_list успешно удален из памяти")
+
+    
+Список complex_list успешно удален из памяти
+new_complex_list = []
+with open(filename, 'r', encoding='utf-8') as file:
+...     for line in file:
+...         line = line.strip()
+...         # Преобразование строки обратно в комплексное число
+...         complex_num = complex(line.replace('(', '').replace(')', '').replace('j', ''))
+...         new_complex_list.append(complex_num)
+... 
+...         
+Traceback (most recent call last):
+  File "<pyshell#16>", line 5, in <module>
+    complex_num = complex(line.replace('(', '').replace(')', '').replace('j', ''))
+ValueError: complex() arg is a malformed string
+>>> with open(filename, 'r', encoding='utf-8') as file:
+...     for line in file:
+...         line = line.strip()
+... 
+...         
+>>> with open(filename, 'r', encoding='utf-8') as file:
+...     for line in file:
+...         line = line.strip()
+...         # Преобразование строки обратно в комплексное число
+...         complex_num = complex(line.replace('(', '').replace(')', '').replace('j', ''))
+...         new_complex_list.append(complex_num)
+... 
+...         
+Traceback (most recent call last):
+  File "<pyshell#20>", line 5, in <module>
+    complex_num = complex(line.replace('(', '').replace(')', '').replace('j', ''))
+ValueError: complex() arg is a malformed string
+>>> with open(filename, 'r', encoding='utf-8') as file:
+...     for line in file:
+...         line = line.strip()
+...         # Преобразование строки обратно в комплексное число
+...         complex_num = complex(line.replace('(','').replace(')',''))
+...         new_complex_list.append(complex_num)
+... 
+...         
+>>> print("\nПрочитанный из файла список комплексных чисел:")
+
+Прочитанный из файла список комплексных чисел:
+>>> for i, num in enumerate(new_complex_list):
+...     print(f"Элемент {i+1}: {num}")
+... 
+...     
+Элемент 1: (9-2j)
+Элемент 2: (13+7j)
+Элемент 3: (5+9j)
+Элемент 4: (14-7j)
+Элемент 5: (30-6j)
+Элемент 6: (24+26j)
+Элемент 7: (18+24j)
+Элемент 8: (13+9j)
+Элемент 9: (-7-3j)
+Элемент 10: (-3+0j)
+>>> print(f"Всего прочитано {len(new_complex_list)} элементов")
+Всего прочитано 10 элементов

TEMA6/modul.py

@@ -0,0 +1,17 @@
+import pickle
+data = {
+    "Институт": ["ИВТИ", "ИЭЭ", "ИРЭ"],
+    "Кафедра": ["Информатика", "Математика", "Физика"],
+    "Группа": ["А-02-23", "ПИ-22", "ПИ-23"],
+    "Студенты": ["Туровец", "Петров", "Сидоров"]
+}
+while True:
+    key = input("Введите ключ (Институт, Кафедра, Группа, Студенты): ")
+    if key in data:
+        break
+    print("Такого ключа нет! Попробуйте еще раз.")
+print(f"Ключ = {key} : Значения = {data[key]}")
+with open("data.bin", "wb") as f:
+    pickle.dump(data, f)
+del data
+print("Словарь удален из памяти")

TEMA6/obshee.md

@@ -0,0 +1,67 @@
+```py
+import random
+import pickle
+import os
+
+num = list(range(1, 126, 1))
+kor = ()
+for i in num:
+    kor = kor + (random.randint(6, 56),)
+print('Кортеж = ', kor, '\n')
+print('Длина кортежа = ', len(kor))
+str_kor = tuple(map(str, kor))
+
+fam = ["Туровец", "Снегура", "Ефремов", "Хатюхин", "Шабатов"]
+
+os.chdir(r'C:\Users\Evgeny\Desktop\python-labs\TEMA6')
+
+f = open('bin.mnz', 'wb')
+pickle.dump(str_kor, f)
+pickle.dump(fam, f)
+f.close()
+
+f = open('bin.mnz', 'rb')
+obj1 = pickle.load(f)
+obj2_spis = pickle.load(f)
+print('Первый считанный объект', obj1)
+print('Второй считанный объект', obj2_spis)
+
+
+if obj1 == str_kor:
+    print('Первый объект совпадает с изначальным символьным кортежем\n')
+else:
+    print('Первый объект НЕ совпадает с изначальным символьным кортежем\n')
+
+if obj2_spis == fam:
+    print('Второй объект совпадает с изначальным списком\n')
+else:
+    print('Второй объект НЕ совпадает с изначальным списком\n')
+
+
+List = []
+for i in range(0, 125, 5):
+    List.append(list(str_kor[i:i + 5]))   
+print('Список списков =', List)
+
+for i in range(25):
+    list_name = f"list{i + 1}"  # Создается имя переменной (list1, list2,..)
+    globals()[list_name] = List[i]
+
+print('Список 1 = ', list1)
+print('Список 2 =', list2)
+```
+Вывод:
+```
+Кортеж =  (53, 54, 24, 35, 12, 9, 48, 11, 33, 26, 40, 41, 49, 45, 6, 31, 43, 11, 32, 50, 34, 14, 52, 11, 31, 39, 20, 54, 35, 47, 15, 17, 17, 29, 22, 47, 32, 54, 10, 6, 24, 23, 54, 29, 13, 16, 44, 53, 17, 41, 51, 21, 26, 12, 33, 11, 8, 37, 41, 16, 12, 44, 7, 54, 10, 45, 31, 9, 18, 13, 52, 31, 52, 41, 46, 24, 35, 44, 28, 31, 22, 52, 20, 30, 28, 8, 52, 56, 36, 15, 24, 45, 41, 35, 26, 37, 35, 54, 43, 18, 39, 9, 10, 48, 13, 31, 37, 35, 48, 14, 32, 27, 18, 30, 32, 50, 24, 34, 15, 46, 45, 54, 38, 12, 52) 
+
+Длина кортежа =  125
+Первый считанный объект ('53', '54', '24', '35', '12', '9', '48', '11', '33', '26', '40', '41', '49', '45', '6', '31', '43', '11', '32', '50', '34', '14', '52', '11', '31', '39', '20', '54', '35', '47', '15', '17', '17', '29', '22', '47', '32', '54', '10', '6', '24', '23', '54', '29', '13', '16', '44', '53', '17', '41', '51', '21', '26', '12', '33', '11', '8', '37', '41', '16', '12', '44', '7', '54', '10', '45', '31', '9', '18', '13', '52', '31', '52', '41', '46', '24', '35', '44', '28', '31', '22', '52', '20', '30', '28', '8', '52', '56', '36', '15', '24', '45', '41', '35', '26', '37', '35', '54', '43', '18', '39', '9', '10', '48', '13', '31', '37', '35', '48', '14', '32', '27', '18', '30', '32', '50', '24', '34', '15', '46', '45', '54', '38', '12', '52')
+Второй считанный объект ['Туровец', 'Снегура', 'Ефремов', 'Хатюхин', 'Шабатов']
+Первый объект совпадает с изначальным символьным кортежем
+
+Второй объект совпадает с изначальным списком
+
+Список списков = [['53', '54', '24', '35', '12'], ['9', '48', '11', '33', '26'], ['40', '41', '49', '45', '6'], ['31', '43', '11', '32', '50'], ['34', '14', '52', '11', '31'], ['39', '20', '54', '35', '47'], ['15', '17', '17', '29', '22'], ['47', '32', '54', '10', '6'], ['24', '23', '54', '29', '13'], ['16', '44', '53', '17', '41'], ['51', '21', '26', '12', '33'], ['11', '8', '37', '41', '16'], ['12', '44', '7', '54', '10'], ['45', '31', '9', '18', '13'], ['52', '31', '52', '41', '46'], ['24', '35', '44', '28', '31'], ['22', '52', '20', '30', '28'], ['8', '52', '56', '36', '15'], ['24', '45', '41', '35', '26'], ['37', '35', '54', '43', '18'], ['39', '9', '10', '48', '13'], ['31', '37', '35', '48', '14'], ['32', '27', '18', '30', '32'], ['50', '24', '34', '15', '46'], ['45', '54', '38', '12', '52']]
+Список 1 =  ['53', '54', '24', '35', '12']
+Список 2 = ['9', '48', '11', '33', '26']
+```

TEMA6/obshee.py

@@ -0,0 +1,55 @@
+import random
+import pickle
+import os
+
+# Создаем кортеж
+num = list(range(1, 126, 1))
+kor = ()
+for i in num:
+    kor = kor + (random.randint(6, 56),)
+print('Кортеж = ', kor, '\n')
+print('Длина кортежа = ', len(kor))
+str_kor = tuple(map(str, kor))
+
+fam = ["Туровец", "Снегура", "Ефремов", "Хатюхин", "Шабатов"]
+
+# Исправленный путь - используем сырую строку или двойные слеши
+os.chdir(r'C:\Users\Evgeny\Desktop\python-labs\TEMA6')
+
+# Запись в файл
+f = open('bin.mnz', 'wb')
+pickle.dump(str_kor, f)
+pickle.dump(fam, f)
+f.close()
+
+# Чтение из файла
+f = open('bin.mnz', 'rb')
+obj1 = pickle.load(f)
+obj2_spis = pickle.load(f)
+print('Первый считанный объект', obj1)
+print('Второй считанный объект', obj2_spis)
+
+# Исправлены условия сравнения (добавлено двоеточие)
+if obj1 == str_kor:
+    print('Первый объект совпадает с изначальным символьным кортежем\n')
+else:
+    print('Первый объект НЕ совпадает с изначальным символьным кортежем\n')
+
+if obj2_spis == fam:
+    print('Второй объект совпадает с изначальным списком\n')
+else:
+    print('Второй объект НЕ совпадает с изначальным списком\n')
+
+# Создание списка списков
+List = []
+for i in range(0, 125, 5):
+    List.append(list(str_kor[i:i + 5]))   
+print('Список списков =', List)
+
+# Создание отдельных переменных для каждого списка
+for i in range(25):
+    list_name = f"list{i + 1}"  # Создается имя переменной (list1, list2,..)
+    globals()[list_name] = List[i]
+
+print('Список 1 = ', list1)
+print('Список 2 =', list2)

TEMA6/repor.py

@@ -0,0 +1,252 @@
+Python 3.13.7 (tags/v3.13.7:bcee1c3, Aug 14 2025, 14:15:11) [MSC v.1944 64 bit (AMD64)] on win32
+Enter "help" below or click "Help" above for more information.
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+print()
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+
+Здесь может выводиться большой текст, занимающий несколько строк
+import sys
+sys.stdout.write('Функция write')
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14
+psw=input('Введите пароль:')
+Введите пароль:12g
+psw
+'12g'
+while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	    
+Задайте коэф.усиления = 17.5
+while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	    
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+os.getcwd()
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    os.getcwd()
+NameError: name 'os' is not defined. Did you forget to import 'os'?
+import 'os'
+SyntaxError: invalid syntax
+import os
+os.getcwd()
+'C:\\Users\\User-PC\\AppData\\Local\\Programs\\Python\\Python313'
+os.chdir('C:\Users\User-PC\python-labs\TEMA6')
+SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape
+os.chdir('C:/Users/User-PC/python-labs/TEMA6')
+os.getcwd()
+'C:\\Users\\User-PC\\python-labs\\TEMA6'
+snegura = str(os.getcwd())
+snegura
+'C:\\Users\\User-PC\\python-labs\\TEMA6'
+os.chdir('C:\\Users\\User-PC\\AppData\\Local\\Programs\\Python\\Python313')
+snegura = str(os.getcwd())
+snegura
+'C:\\Users\\User-PC\\AppData\\Local\\Programs\\Python\\Python313'
+os.chdir('C:/Users/User-PC/python-labs/TEMA6')
+os.mkdir("папка новая")
+os.rmdir("папка новая")
+os.mkdir("папка новая")
+os.rmdir("папка новая")
+os.listdir()
+['.gitkeep', 'repor.py', 'report.md', 'report.py', '{2CA98D5E-ED50-4F53-8FA4-B86C3DDE9001}.png']
+os.path.isdir("папка новая")
+False
+os.path.isdir("report.md")
+False
+fil=os.path.abspath("report.md")
+fil
+'C:\\Users\\User-PC\\python-labs\\TEMA6\\report.md'
+drkt=os.path.dirname(fil)
+drkt
+'C:\\Users\\User-PC\\python-labs\\TEMA6'
+name = os.path.basename(fil)
+name
+'report.md'
+head, tail = os.path.split(fil)
+head
+'C:\\Users\\User-PC\\python-labs\\TEMA6'
+tail
+'report.md'
+os.path.exists('C:\\Users\\User-PC\\python-labs\\TEMA6')
+True
+os.path.exists('C:\\Users\\User-PC\\python-labs\\TEMA60')
+False
+os.path.isfile(fil)
+True
+open
+<built-in function open>
+help(open)
+
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+fp=open(drkt+'\\zapis1.txt','w')
+fp=open('zapis1.txt','w')
+type(fp)
+<class '_io.TextIOWrapper'>
+fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+fp.close()
+fp1.close()
+sps=list(range(1,13))
+sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+fp2=open('zapis3.txt','w')
+fp2.write(str(sps[:4])+'\n')
+13
+fp2.write(str(sps[4:8])+'\n')
+13
+fp2.write(str(sps[8:])+'\n')
+16
+fp2.close()
+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()
+gh=open('zapis5.txt','w')
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+ 
+gh.close()
+SyntaxError: multiple statements found while compiling a single statement
+gh=open('zapis5.txt','w')
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+gh.close()
+SyntaxError: invalid syntax
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+
+    
+12
+12
+13
+gh.close()
+gh=open('zapis6.txt','w')
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+
+12
+12
+13
+gh.close()
+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()
+sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+fp=open('zapis3.txt')
+stroka1=fp.read(12)
+stroka2=fp.read()
+fp.close()
+stroka1
+'[1, 2, 3, 4]'
+stroka2
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+fp.close()
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+fp.close()
+mnoz1
+{'pen', 'book', 'iPhone', 'table'}
+mnoz2
+{'pen', 'book', 'iPhone', 'table'}
+fp=open('zapis7.2ob','wb')
+pickle.dump(mnoz1,fp)
+pickle.dump(sps3,fp)
+fp.close()
+fp=open('zapis7.2ob','rb')
+obj1=pickle.load(fp)  #Первое обращение к load читает первый объект
+obj2=pickle.load(fp)  #Второе – читает второй
+fp.close()
+obj1
+{'pen', 'book', 'iPhone', 'table'}
+obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+mnoz1
+{'pen', 'book', 'iPhone', 'table'}
+sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+import sys
+vr_out=sys.stdout  #Запоминаем текущий поток вывода
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+ print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+ 
+SyntaxError: unexpected indent
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+fc.close()
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+while True:
+    try:
+        line = input () #Считываем из файла строку
+...         print(line)  # Отображаем считанное
+...     except EOFError:
+...         break
+... 
+...     
+запись строки в файл
+>>>  fd.close()
+...  
+SyntaxError: unexpected indent
+>>> fd.close()
+>>> sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода

TEMA6/report.md

@@ -0,0 +1,438 @@
+# Отчет по теме 6
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение вывода данных на экран дисплея
+
+Были изучены и применены различные способы вывода данных на экран.
+
+## 2.1 Изучение эхо-вывода
+
+```py
+>>>stroka='Автоматизированная система управления'
+>>>stroka
+'Автоматизированная система управления'
+```
+
+## 2.2 Изучение вывода данных с помощью печати
+
+Была изучена функция print для вывода текста. Текст был выведен в одну строку, далее в две строки с использованием экранированных последовательностей, далее был выведен текст с дописанным в конце текстом, используя аргумент end. И также был выведен текст в три строки, используя троиные кавычки.
+
+```py
+>>>fff=234.5;gg='Значение температуры = '
+>>>print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+>>>print(gg, fff, sep="\n")
+      
+Значение температуры = 
+234.5
+>>>print(gg, fff,sep='\n',end='***'); print('____')
+      
+Значение температуры = 
+234.5***____
+>>>print()
+      
+
+>>>print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""") #В этом варианте текст выводится в три отдельные строки как и при вводе команды, благодаря троиным кавычкам.
+      
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+>>>print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк") #В данном случае текст выводится подряд в одну строку.
+      
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+## 2.3 Изучение вывода данных с помощью функции write
+
+Был испортирован модуль sys, и использована функция write, которая записывает и выводит текст, а так же возвращается количество байтов, записанных в строку.
+
+```
+>>>import sys
+>>>sys.stdout.write('Функция write')
+Функция write13
+>>>sys.stdout.write('Функция write')
+Функция write13
+>>>sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+
+## 3 Изучение ввода данных с клавиатуры
+
+С помощью функции input был произведен вывод текста, введенного с клавиатуры. Так же был создан цикл, который просит пользователя ввести значение до тех пор, пока оно не будет удовлетворять определенному интервалу, а потом выводит это значение на дисплей. Также с помощью функции eval Была создана команда, благодаря которой выражение, введенное пользователен с консоли исполняется, и выдается результат расчета.
+
+```py
+>>>psw=input('Введите пароль:')
+Введите пароль:12g
+>>>psw
+'12g'
+>>>type(psw)
+<class 'str'>
+```
+Ввод с контролем значения. Пусть вводится число, которое должно находиться в интервале значе-ний от 17.5 до 23.8.
+
+```py
+>>>while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+
+	    
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+Ввод и обработка выражения, подлежащего расчету.
+```py
+>>>import math
+>>>print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4 Изучение различных способов чтения данных из файла и записи в файл
+
+Были изучены и применены разные способы чтения и записи данных.
+
+## 4.1 Изучение модуля os для работы с путями к файлам
+
+Был просмотрен текущий рабочий каталог, занесен в переменную d. После этого совершен переход в другой рабочий католог. Были самостоятельно изучены и применены методы из модуля os и подмодуля os.path:
+
+mkdir - создает папку в рабочем каталоге (в приложенном фото видно, что в каталоге появилвсь папка); 
+![alt text]({2CA98D5E-ED50-4F53-8FA4-B86C3DDE9001}.png)
+rmdir - удаляет из каталога пустую папку;
+listdir - возвращает список имен файлов/папок в указанном каталоге (или если аргумент не указан, то в текущем каталоге);
+path.isdir - возвращает true, если папка является существующей в каталоге.
+
+Далее была создана переменная, содержащая строку - путь в файлу report и имя данного файла. Используя эту переменную, с помощью функций модуля os была создана строка содержащая только путь, потом только имя, а потом применена функция, которая разделяет в одну переменную - путь, в другую - имя файла. Далее было проверено существование определенного пути, и существование определенного файла с указаном каталоге. 
+
+```py
+>>>import os
+>>>os.getcwd()
+'C:\\Users\\User-PC\\AppData\\Local\\Programs\\Python\\Python313'
+>>>turovets = str(os.getcwd())
+>>turovets
+'C:\\Users\\User-PC\\AppData\\Local\\Programs\\Python\\Python313'
+>>>os.chdir('C:/Users/User-PC/python-labs/TEMA6')
+>>>os.mkdir("папка новая")
+>>>os.rmdir("папка новая")
+>>>os.listdir()
+['.gitkeep', 'repor.py', 'report.md', 'report.py', '{2CA98D5E-ED50-4F53-8FA4-B86C3DDE9001}.png']
+>>>os.path.isdir("папка новая")
+False
+>>>fil=os.path.abspath("report.md")
+>>>fil
+'C:\\Users\\User-PC\\python-labs\\TEMA6\\report.md'
+>>>drkt=os.path.dirname(fil)
+>>>drkt
+'C:\\Users\\User-PC\\python-labs\\TEMA6'
+>>>name = os.path.basename(fil)
+>>>name
+'report.md'
+>>>head, tail = os.path.split(fil)
+>>>head
+'C:\\Users\\User-PC\\python-labs\\TEMA6'
+>>>tail
+'report.md'
+>>>os.path.exists('C:\\Users\\User-PC\\python-labs\\TEMA6')
+True
+>>>os.path.exists('C:\\Users\\User-PC\\python-labs\\TEMA60')
+False
+>>>os.path.isfile(fil)
+True
+```
+
+## 4.2 Изучение обобщенного процесса работы с файлами
+
+Было определено, что для обмена данными с файлами необходимо:
+
+    • Открыть файла с указанием его имени и цели;
+    • Выполнить операции обмена данными с файлом;
+    • Закрыть файл.
+
+## 4.3 Изучение функции open для открытия файлов с разной целью
+
+Была применена команда open с различным написанием аргументов, создан файловый обьект. Выведен тип и список атрибутов этого обьекта.
+
+```py
+>>>fp=open(file=drkt+'\\zapis1.txt',mode='w')
+                                                          
+>>>fp=open(drkt+'\\zapis1.txt','w') #если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать
+                                                          
+>>>fp=open('zapis1.txt','w') #путь в переменной drkt совпадает с рабочим каталогом, значит его можно опустить, оставив только имя открываемого файла
+                                                          
+>>>type(fp)
+                                                          
+<class '_io.TextIOWrapper'>
+>>>dir(fp)
+                                                          
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+
+>>>fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+```
+
+## 4.4 Изучение закрытия файла
+
+Файл был закрыт.
+
+```py
+>>>fp.close()
+>>>fp1.close()
+```
+
+## 4.5 Изучение функции write для записи данных в текст
+
+Был создан список из 12 элементов и поочередно в файл записаны числа из списка в три строки.
+
+```py
+>>>sps=list(range(1,13))
+         
+>>>sps
+         
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>>fp2=open('zapis3.txt','w')
+         
+>>>fp2.write(str(sps[:4])+'\n')
+         
+13
+>>>fp2.write(str(sps[4:8])+'\n')
+         
+13
+>>>fp2.write(str(sps[8:])+'\n')
+         
+16
+>>>fp2.close()
+```
+
+![alt text]({BDBC12A7-03FA-405C-B54E-67BB26CD9BB4}.png)
+
+Далее был создан список из трех списков и с помощью цикла for все элементы списка были вписаны в файл в одну строку.
+
+```py         
+>>>sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+         
+>>>sps3
+         
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>fp3=open('zapis4.txt','w')
+         
+>>>for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+
+         
+11
+11
+12
+>>>fp3.close()
+```
+Вывод:
+```
+Иванов И. 1Петров П. 2Сидоров С. 3
+```
+         
+Далее с помощью цикла for три списка из общего списка были вписаны в файл поочередно в три строки. Запись цикла была сжата в одну строку, и проверено, что при написании той же инструкции в одну строку, содержимое файла не изменяется, относительно предыдущего метода с этими же инструкциями.
+
+```py
+>>>gh=open('zapis5.txt','w')
+         
+>>>for r in sps3:
+	gh.write(r[0]+' '+str(r[1])+'\n')
+         
+12
+12
+13
+>>>gh.close()
+```
+Вывод:
+```
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+```py         
+>>>gh=open('zapis6.txt','w')
+         
+>>>for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+
+         
+12
+12
+13
+>>>gh.close()
+```
+Вывод:
+```
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+
+## 4.6 Изучение одного из способов чтения данных из файла с помощью цикла for
+
+С помощью open был открыт файл для чтения, и из его символов был сконструирован список, состоящий из символов. После символы в списке были преобразованы в числа, и список стал идентичен тому, который создавался ранее и записывался в файл.
+
+```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()
+>>>sps
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+>>>sps1
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+>>>sps2=[]
+>>>for i in sps1:
+    sps2.append(int(i))
+    
+>>>sps2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+## 4.7 Изучение способа чтения данных из файла с помощью функции read
+
+Был открыт текстовый файл и с помощью функции read из него сначала было прочитано и отображено 12 символов, а потом прочитаны остальные символы с помощью функции read без указания аргумента.
+
+```py
+>>>fp=open('zapis3.txt')
+         
+>>>stroka1=fp.read(12)
+         
+>>>stroka2=fp.read()
+         
+>>>fp.close()
+         
+>>>stroka1
+         
+'[1, 2, 3, 4]'
+>>>stroka2
+         
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+## 4.8 Изучение чтения данных из файла по строкам
+
+Самостоятельно были изучены и применены функции: readline - которая читает одну строку, начиная с указателя текущей позиции, и функция readlines, которая по такому же принципу читает все строки и возвращает их в виде списка.
+
+```py
+>>>fp=open('zapis3.txt')
+         
+>>>s1 = fp.readline()
+         
+>>>s2=fp.readline()
+         
+>>>s1
+         
+'[1, 2, 3, 4]\n'
+>>>s2
+         
+'[5, 6, 7, 8]\n'
+>>>fp.close()
+         
+>>>fp=open('zapis3.txt')
+>>>s3 = fp.readlines()
+>>>s3
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\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
+>>>fp=open('zapis6.mnz','rb')
+>>>mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+>>>fp.close()
+>>>mnoz2 #Результат не такой как при вводе множества mnoz1, так как множество не имеет повторений и порядка элементов, поэтому автоматически множество обьединило повторяющиеся слова.
+{'pen', 'iPhone', 'book', 'table'}
+mnoz1 == mnoz2
+True
+```
+
+Также в файл было записано два обьекта и прочитано поочередно с помощью load.
+
+```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)  #Первое обращение к load читает первый объект
+>>>obj2=pickle.load(fp)  #Второе – читает второй
+>>>fp.close()
+>>>obj1
+{'pen', 'iPhone', 'book', 'table'}
+>>>mnoz1
+{'pen', 'book', 'iPhone', 'table'}
+>>>obj2
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>>sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+## 5 Перенаправление потоков ввода и вывода данных.
+
+Был создан текстовый файл, куда с помощью модуля sys и методы stdout был перенаправлен поток вывода, и в нем был напечатан текст. Далее поток вывода был перенаправлен обратно и проведена проверка с помощью print.
+
+```py
+>>>import sys
+>>>vr_out=sys.stdout  #Запоминаем текущий поток вывода
+>>>fc=open('Stroka.txt','w') #Откроем файл вывода
+>>>sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>>print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>>sys.stdout=vr_out  #Восстановление текущего потока
+>>>print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>>fc.close()
+```
+
+Также был перенаправлен ввод на файл, и реализован цикл, в котором считывается текст из файла и печатается на экран.
+
+```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:
+		line = input () #Считываем из файла строку
+		print(line)  # Отображаем считанное
+	except EOFError:
+		break
+
+	    
+запись строки в файл
+>>>fd.close()
+>>>sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+ 
+## 6 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA6/test.py

@@ -0,0 +1,9 @@
+import pickle as pi
+import random as rd
+num=[rd.randint(1,10) for i in range(10)]
+f=open('file.bin', 'wb')
+pi.dump(num,f)
+f=open('file.bin','rb')
+list=pi.load(f)
+print(list)
+

TEMA6/zapis3.txt

@@ -0,0 +1,3 @@
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]

TEMA6/zapis4.txt

@@ -0,0 +1 @@
+Иванов И. 1Петров П. 2Сидоров С. 3