ikz

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 <Сарайкина Вера Кирилловна>
+print('Hello')
+h=input('Vera')
+import os
+os.chdir('C:\\Users\\u207-09\\python-labs\\TEMA1\\')

TEMA1/report.md

@@ -0,0 +1,112 @@
+# Отчет по теме 1
+
+Сарайкина Вера, А-02-23.
+## Пункт 1
+ Создание рабочей папки
+на рабочем столе создала рабочую папку
+
+## Пункт 2 
+Запуск программы-интерпретатора
+
+ запустила программу "Python 3.4"
+
+## Пункт 3 
+Проверка работы интерпретатора
+
+```py
+print("Hello")
+```
+Hello
+
+## Пункт 4 
+Ввод еще 1 инструкции
+
+```py
+h = input("Your name = ")
+```
+Your name = Vera
+
+## Пункт 5
+Завершение работы с интерпретатором
+
+Ввела инструкцию:
+```py
+exit()
+```
+И таким образом вышла из интерпретатора
+
+## Пункт 6
+Запустила графическую оболочку IDLE 
+
+## Пункт 7
+Изучила окно среды
+
+## Пункт 8 
+Настройка рабочего каталога среды
+
+```py
+import os
+os.chdir('C:\\Users\\u207-09\\python-labs\\TEMA1')
+```
+Таким образом я настроила свой рабочий каталог в папе Тема1
+
+## Пункт 9 
+Изучила главное меню и сделала шрифт типа Arial CYR, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая
+
+## Пункт 10 
+Создание файла с интсрукциями
+
+```py
+# Протокол по Теме 1 <Сарайкина Вера Кирилловна>
+print('Hello')
+h = input('Your name = ')
+import os
+os.chdir('C:\\Users\\u207-09\\python-labs\\TEMA1')
+```
+Запустила эту программу 3 разными способами:
+Через run module,через f5 и через ввод инструкции:
+```py
+import Pr0
+```
+
+## Пункт 11
+Из консол вызван файл prb1.py 
+```py
+import prb1
+Как Вас зовут? Вера
+Привет, Вера
+```
+## Пункт 12
+Открыла файл в текстовом редакторе Pr0.cpython-34.pyc – результат работы компилятора среды.
+
+Результат компиляции тяжел для восприятия человеком з-за нессоответствия кодировок. 
+Компиляция необходима для того, чтобы переести команды в машинный код. при выполнении скрипта питон сначата преобразовывает его в байт- код, а затем компилруется с помощоью виртуальной машины. это ускорит полвторную загрузку программы.
+## Пункт 13
+Изучила программу help
+```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.
+```
+## Пункт 13
+Запустила другую программу из данного файла
+
+```py
+import tdemo_chaos
+```
+Рассмотрели файл в текстовом редакторе а затем с помощью меню запустили демонстрацию и выбрали несколько вариантов изображений
+![Скриншот диалога открытия файла](pic0.PNG)
+![Скриншот диалога открытия файла](pic1.PNG)
+## Пункт 14
+Завершен сеанс работы сосредой

TEMA2/report.md

@@ -0,0 +1,494 @@
+# Отчет по теме 2
+
+**Сарайкина Вера, А-02-23**
+
+### 1. Настройка текущего каталога
+```py
+import os
+os.chdir('C:\\Users\\Yarik\\Desktop\\labi\\python-labs\\TEMA2//')
+```
+
+### 2.Изучение простых объектов
+```py
+f1=16;f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+- Получение атрибутов и определение классовой принадлежности объекта f1
+```py
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+```
+- Удаление созданных переменных
+```py
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+### 3. Изучение правил именования объектов в Python. 
+Примеры правильных и неправильных имён:
+
+```py
+gg = 1.6
+hh1 = 'строка'
+73sr=3
+SyntaxError: invalid decimal literal
+and=7
+SyntaxError: invalid syntax
+```
+
+### 4.Вывод списка ключевых слов 
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+keywords = keyword.kwlist
+```
+
+### 5.Встроенные функции
+
+- Cписок встроенных идентификаторов
+```py
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+- Получение помощи по функциям и их применение
+```py
+help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+```
+В дальнейшем получение помощи не будет вставлено в отчёт.
+
+- Функции abs и len
+```py
+abs(-12)
+12
+len("Hello, World!")
+13
+list1=(12,14,63,24,32,52)
+len(list1)
+6
+```
+- Функции min и max
+```py
+max(12,14,63,24,32,52)
+63
+min(12,14,63,24,32,52)
+12
+max("Москва", "Санкт-Петербург", "Владивосток")
+'Санкт-Петербург'
+min("Москва", "Санкт-Петербург", "Владивосток")
+'Владивосток'
+```
+- Функции pow и round
+```py
+pow(12, 2)
+144
+pow(25, -2)
+0.0016
+pow(5, 2, 7)
+4
+round(3.14)
+3
+round(3.14135413, 1)
+3.1
+round(123.45, -1)
+120.0
+```
+- Функция сортировки и суммы 
+```py
+sorted({12,-32,42,11,-2,7,-42,63})
+[-42, -32, -2, 7, 11, 12, 42, 63]
+sorted({12,-32,42,11,-2,7,-42,63}, reverse=True)
+[63, 42, 12, 11, 7, -2, -32, -42]
+sorted(["Москва","Санкт-Петербург","Сочи","Владивосток","Архангельск"],key=len)
+['Сочи', 'Москва', 'Владивосток', 'Архангельск', 'Санкт-Петербург']
+sorted(["Москва","Санкт-Петербург","Сочи","Владивосток","Архангельск"])
+['Архангельск', 'Владивосток', 'Москва', 'Санкт-Петербург', 'Сочи']
+sum([10,41,11,3,8])
+73
+sum([10,41,11,3,8],12)
+85
+sum(x for x in range(3, 12))
+63
+```
+- Функция zip
+```py
+names = ["Анна", "Иван", "Мария"]
+ages = [25, 30, 28]
+cities = ["Москва", "Сочи", "Казань"]
+zip1 = list(zip(names, ages, cities))
+zip1
+[('Анна', 25, 'Москва'), ('Иван', 30, 'Сочи'), ('Мария', 28, 'Казань')]
+names.pop(1)
+'Иван'
+zip1
+[('Анна', 25, 'Москва'), ('Мария', 30, 'Сочи')]
+
+```
+
+### 6.Влияние регистра
+```py
+Gg1=45
+Gg1
+45
+gg1
+1.6
+```
+
+### 7.Простые базовые типы объектов
+#### 7.1 Логический тип
+```py
+bb1=True; bb2=False
+bb1;bb2
+True
+False
+type(bb1)
+<class 'bool'>
+```
+
+#### 7.2 Другие простые типы
+```py
+ii1=-1234567890
+ff1=-8.9876e-12
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+shest1=0x7109af6
+cc1=2-3j
+a=3.67; b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j
+```
+#### 7.3 Изучение строк 
+```py
+ss1='Это - строка символов'
+ss1="Это - строка символов"
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ss1b= 'Меня зовут: \n <Сарайкина В. К.>'
+print(ss1b)
+Меня зовут: 
+ <Сарайкина В. К.>
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+- Способы обращений к частям строк и операция «разрезания» или «создания среза»
+```py
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+ss1[17:3:-2]
+'омсаот '
+ss1[-4:3:-2]
+'омсаот '
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#86>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+print(ss1)
+Это = строка символов
+```
+-Создание объектов с разными срезами 
+```py
+ss1b[0]
+'М'
+ss1b[2]
+'н'
+ss1b[-5]
+'.'
+ss1b[3:7]
+'я зо'
+ss1b[:7]
+'Меня зо'
+ss1b[7:]
+'вут: \n <Сарайкина В. К.>'
+ss1b[11:2:-3]
+' уз'
+```
+#### 7.4 Создание объектов и проверка их типов 
+```py
+a = 11
+type(a)
+<class 'int'>
+b=11.11
+type(b)
+<class 'float'>
+c=3+7j
+type(c)
+<class 'complex'>
+d='vera'
+type(d)
+<class 'str'>
+e=True
+type(e)
+<class 'bool'>
+f=None
+type(f)
+<class 'NoneType'>
+```
+
+### 8. Сложные типы объектов
+
+#### 8.1 Списки
+```py
+spis1=[111,'Spisok',5-9j]
+stup=[0,0,1,1,1,1,1,1,1]
+spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+
+spis1[-1]
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+spis1[1]='Список'
+print(spis1)
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+```
+- Методы объекта находятся в списке его атрибутов
+```py
+dir()
+['Gg1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'bb1', 'bb2', 'builtins', 'c', 'cc1', 'cc2', 'd', 'dv1', 'e', 'ff1', 'gg1', 'hh1', 'i', 'ii1', 'j', 'keyword', 'keywords', 'list1', 'mnogo', 'os', 'shest1', 'spis', 'spis1', 'ss1', 'ss1a', 'ss1b', 'stup', 'vsm1']
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+- Методы добавления и удаления элемента в списке
+```py
+spis1.append(ss1b)
+print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>']
+spis1.pop(1)
+'Список'
+print(spis1)
+[111, (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>']
+```
+- Изучение методов insert и remove
+```py
+spis1.insert(1,"осень")
+spis1.remove(111)
+print(spis1)
+['осень', (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>']
+```
+- extend и clear
+```py
+spis1.extend([3, 5])
+spis2 =['11', 'a', 'b']
+spis1.extend(spis2)
+print(spis1)
+['осень', (5-9j), 'New item', 'Меня зовут: \n <Сарайкина В. К.>', 3, 5, '11', 'a', 'b']
+spis2.clear()
+print(spis2)   
+[]
+```
+- Метод sort 
+```py
+spis2 = [5, 4, 2, 3, 1]
+spis2.sort()
+print(spis2)
+[1, 2, 3, 4, 5]
+spis2.sort(reverse=True)
+print(spis2)
+[5, 4, 3, 2, 1]
+spis2.clear()
+spis2 = ['a', 'b', 'C', 'd']
+spis2.sort()
+print(spis2)
+['C', 'a', 'b', 'd']
+```
+- Методы reverse, count и copy
+```py
+spis2.reverse()
+print(spis2)
+['d', 'b', 'a', 'C']
+spis1.reverse()
+                 
+print(spis1)
+                 
+['b', 'a', '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень']
+copy1 = spis1.copy()
+copy2 = spis2.copy()
+print(copy1, copy2)
+['b', 'a', '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень'] ['d', 'b', 'a', 'C']
+spis1.count('a')
+1
+spis2.count('a')
+1
+spis1.count(11)
+1
+spis2.count(100)
+0
+spis1.index('New item')
+6
+spis2.index('b')
+1
+spis1.index(3)
+4
+```
+- Вложенные списки и обращение к элементам в них
+```py
+spis2=[spis1,[4,5,6,7]]
+print(spis2)
+[['b', 'a', '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень'], [4, 5, 6, 7]]
+spis2[0][1]
+'a'
+spis2[0][1]=78
+print(spis2)
+[['b', 78, '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень'], [4, 5, 6, 7]]
+print(spis1)
+['b', 78, '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень']
+#Когда мы изменяем spis2[0][1], то мы изменяем второй элемент списка spis1, так как spis2[0] и spis1 - это один и тот же объект в памяти.
+spisok = [768, "Hello", True, [1, 2, 3], spis1.copy()]
+                 
+print(spisok)
+                 
+[768, 'Hello', True, [1, 2, 3], ['b', 78, '11', 5, 3, 'Меня зовут: \n <Сарайкина В. К.>', 'New item', (5-9j), 'осень']]
+
+#### 8.2 Объект-кортеж 
+- Создание кортежа, переопределение и методы
+```py
+kort1=(222,'Kortezh',77+8j)
+print(kort1)
+(222, 'Kortezh', (77+8j))
+kort1= kort1+(1,2)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n <Сарайкина В. К.>')
+kort2=kort1[:2]+kort1[3:]
+print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n <Сарайкина В. К.>')
+kort1.index(2)
+4
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#201>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+- Создание своего кортежа
+```py
+print(my_tuple)
+                 
+(87, 'proga', [1, 2, 3], (4, 5, 6))
+```
+
+#### 8.3 Объект-словарь
+
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Orel']
+56
+dic1['Pskov']=78   
+dic1        
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+- Сортировка словарей 
+```py
+sorted(dic1.keys())  #по ключам
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())  #по значениям 
+[45, 56, 78, 145]
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+'standart deviation'
+```
+- Создание словарей с помощью функций dict и zip
+```py
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут-\n <Похил А.А>'}
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут-\n <Похил А.А>'}
+```
+- Создание своего словаря
+```py
+kortezh = (4, 'h', 6, True, 11, (1,6), 'cucumber')
+                 
+spisok = [11, 'b', 5.71, False, 'tomato']
+                 
+slovar = dict(zip(kortezh, spisok))
+                 
+slovar
+                 
+{4: 11, 'h': 'b', 6: 5.71, True: False, 11: 'tomato'}
+
+```
+Длина словаря равна 5, потому что функция zip() создает пары только до длины более короткой коллекции (списка из 5 элементов)
+
+
+#### 8.4 Объект-множество
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'датчик', 'двигатель', 'микропроцессор', 'линия связи'}
+```
+- Некоторые операции с множеством 
+```py
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1.remove('линия связи')
+mnoz1
+{'реле', 'датчик', 'двигатель', 'микропроцессор'}
+```
+- Создание своего объекта
+```py
+s1={True,2,4.2,'mpei', True}
+len(s1)
+4
+s1
+{'mpei', True, 2, 4.2}
+'mpei' in s1
+True
+```

TEMA2/task.md

@@ -0,0 +1,63 @@
+# Общее контрольное задание по теме 2
+
+**Сарайкина Вера, А-02-23**
+
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия
+1. Создать переменную с именем familia и со значением - символьной строкой – своей фамили-ей в латинской транскрипции.
+2. Создать переменную со значением, совпадающим с первой буквой из familia.
+3. Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+4. Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+5. Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+6. Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
+7. Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+8. Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам. 
+## Решение
+#### 1. Создание переменной familia.  
+```py
+familia = 'Saraikina'
+```
+
+#### 2. Создание переменной, которая равна первой букве familia.
+```py
+firstL = familia[0]
+```
+#### 3. Создание переменной с именем sp_kw.
+```py
+import keyword
+dir(keyword)
+['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'iskeyword', 'issoftkeyword', 'kwlist', 'softkwlist']
+sp_kw = keyword.kwlist
+```
+
+#### 4. Удаление из списка sp_kw значения 'nonlocal'.
+```py
+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']
+```
+#### 5. Создание кортежа names.
+```py
+names = ('Вера', 'Елизавета', 'Татьяна', 'Стас')
+type(names)
+<class 'tuple'>
+```
+#### 6. Добавление в names имена двух студентов. 
+```py
+names = names + ('Анастасия', 'Дана')
+names
+('Вера', 'Елизавета', 'Татьяна', 'Стас', 'Анастасия', 'Дана')
+```
+
+#### 7. Определяю, сколько раз в кортеже присутствуют студенты с именем «Дима».
+```py
+names.count('Дима')
+0
+```
+#### 8. Создание словаря dict_bas.
+```py
+dict_bas = {'строка': [familia,firstL],'список': sp_kw,'кортеж': names}
+                 
+print(dict_bas)
+{'строка': ['Saraikina', 'S'], 'список': ['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'], 'кортеж': ('Вера', 'Елизавета', 'Татьяна', 'Стас', 'Анастасия', 'Дана')}
+```

TEMA2/tesst1.md

@@ -0,0 +1,39 @@
+# Тест по модулю 1. Вариант 16
+Сарайкина Вера, А-02-23
+
+## 1)
+	Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+## для плучения помощи можно воспользоваться командой help(), где в скобочкках необходимо указать коману,по которой требуется помощь, так же в интерактивном меню IDLE есть раздел "help", где так же можно посмотреть помощь, еще помощь можно получить через официальную документацию python
+
+## 2)	Создайте объект-строку с текстом: "Среда Python - эффективное средство разработки ПО". Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+```py
+s = "Среда Python - эффективное средство разработки ПО"
+type(s)
+<class 'str'>
+dir(s)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+## 3)	Напишите инструкцию, создающую новую строку добавлением перед словом "эффективное" слова "очень". Отобразите получившийся объект.
+```py
+a = s.replace("эффективное", "очень эффективное")
+print(a)
+Среда Python - очень эффективное средство разработки ПО
+```
+## 4)	Преобразуйте строку в список. Отобразите полученный объект. Подсчитайте, сколько раз в этот список входит символ "е". Проверьте, есть ли в этом списке символ "Q".
+```py
+spis=list(a)
+print(spis)
+['С', 'р', 'е', 'д', 'а', ' ', 'P', 'y', 't', 'h', 'o', 'n', ' ', '-', ' ', 'о', 'ч', 'е', 'н', 'ь', ' ', 'э', 'ф', 'ф', 'е', 'к', 'т', 'и', 'в', 'н', 'о', 'е', ' ', 'с', 'р', 'е', 'д', 'с', 'т', 'в', 'о', ' ', 'р', 'а', 'з', 'р', 'а', 'б', 'о', 'т', 'к', 'и', ' ', 'П', 'О']
+spis.count("е")
+5
+"Q" in spis
+False
+```
+## 5)	Создайте на основе строки кортеж с подстроками, разделенными в исходной строке символами "пробел".
+```py
+kort=tuple(a.split( ))
+print(kort)
+('Среда', 'Python', '-', 'очень', 'эффективное', 'средство', 'разработки', 'ПО')
+
+```

TEMA3/report.md

@@ -0,0 +1,696 @@
+# Отчет по теме 3
+
+Сарайкина Вера, А-02-23
+
+### 1. Настройка текущего каталога.
+```py
+import os
+os.chdir('C:\\Users\\Yarik\\Desktop\\labi\\python-labs\\TEMA2//')
+
+```
+### 2. Преобразование простых базовых типов объектов.
+
+#### 2.1. Преобразование в логический тип с помощью функции bool(<Объект>)
+
+```py
+logiz1 = bool(56)
+logiz2 = bool(0)
+logiz3 = bool("Beta")
+logiz4 = bool("")
+logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+type(logiz1)
+<class 'bool'>
+```
+
+#### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления
+- Примеры использования функции int:
+
+```py
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B",16)
+tt3
+11
+tt4 = int("71",8)
+tt4
+57
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+- Преобразование целых чисел или строк символов в вещественное число 
+
+```py
+flt1 = float(789)
+flt1
+789.0
+flt2 = float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+```
+
+#### 2.3. Преобразование десятичных чисел в другие системы счисления:
+
+```py
+hh = 567
+dv1 = bin(hh)  #Преобразование в строку с двоичным представлением
+vos1 = oct(hh)  # Преобразование в строку с восьмеричным представлением
+shs1 = hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+dv1
+'0b1000110111'
+vos1
+'0o1067'
+shs1
+'0x237'
+int(dv1,2)
+567
+int(vos1, 8)
+567
+int(shs1, 16)
+567
+```
+
+### 3. Преобразования более сложных базовых типов объектов.
+
+#### 3.1. Преобразование в строку символов
+
+
+```py
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+strk2
+'True'
+strk3 = str(["A","B","C"])  #Преобразуем список
+strk3
+"['A', 'B', 'C']"
+strk4 = str(("A","B","C"))  #Преобразуем кортеж
+strk4
+"('A', 'B', 'C')"
+strk5 = str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+#### 3.2. Преобразование элементов объекта в список
+
+```py
+spis1 = list("Строка символов")  #Заданная строка разделяется на символы
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2 = list((124,236,-15,908))  #Кортеж превращается в список
+spis2
+[124, 236, -15, 908]
+spis3 = list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+spis3
+['A', 'B', 'C']
+```
+- Методы .values(), .items()
+
+```py
+spis3 = list({"A":1,"B":2,"C":9}.values())
+spis3
+[1, 2, 9]
+spis3 = list({"A":1,"B":2,"C":9}.items())
+spis3
+[('A', 1), ('B', 2), ('C', 9)]
+```
+#### 3.3. Преобразование элементов объектов в кортеж
+
+```py
+kort7 = tuple('Строка символов')  #Преобразование строки символов в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2)  #Преобразование списка в кортеж
+kort8
+(124, 236, -15, 908)
+kort9 = tuple({"A":1,"B":2,"C":9})  #Преобразование словаря в кортеж
+kort9
+('A', 'B', 'C')
+```
+
+#### 3.4. Удаление обьектов
+
+```py
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#62>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#63>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+str_A = "Сарайкина В.К"
+spis_A = list(str_A)
+spis_A
+['С', 'а', 'р', 'а', 'й','к','и','н','а', ' ', 'В', '.', 'К']
+kort_A = tuple(spis_A)
+kort_A
+('С', 'а', 'р', 'а', 'й','к','и','н','а', ' ', 'В', '.', 'К')
+str_AA = str(kort_A)
+str_AA
+"('С', 'а', 'р', 'а', 'й','к','и','н','а', ' ', 'В', '.', 'К')"
+```
+
+### 4. Арифметические операции.
+
+#### 4.1. Сложение и вычитание
+
+```py
+12+7+90  # Сложение целых чисел
+109
+5.689e-1 - 0.456  #Вычитание вещественных чисел
+0.11289999999999994
+23.6+54  #Сложение вещественного и целого чисел
+77.6
+14-56.7+89  #Сложение и вычитание целых и вещественных чисел
+46.3
+```
+
+#### 4.2. Умножение
+
+```py
+>-6.7*12  #Умножение вещественного числа на целое число
+-80.4
+```
+
+#### 4.3. Деление
+
+```py
+-234.5/6  #Деление вещественного числа на целое
+-39.083333333333336
+a = 178/45  #Деление двух целых чисел
+a
+3.9555555555555557
+type(a)
+<class 'float'>
+```
+
+#### 4.4. Деление с округлением вниз
+
+```py
+b = 178//45   #Деление двух целых чисел
+b
+3
+type(b)
+<class 'int'>
+c = -24.6//12.1  #Деление двух вещественных чисел
+c
+-3.0
+type(c)
+<class 'float'>
+d = 33.3//11
+d
+3.0
+type(d)
+<class 'float'>
+d = 9//3
+d
+3.0
+type(d)
+<class 'float'>
+d = 11//55
+d
+0
+type(d)
+<class 'int'>
+
+```
+
+#### 4.5. Получение остатка от деление
+
+```py
+148%33  #Остаток от деления двух целых чисел
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+43.2%12
+7.200000000000003
+323%23.2
+21.40000000000001
+```
+
+#### 4.6. Возведение в степень
+
+```py
+14**3  #Целое число возводится в целую степень
+2744
+e = 2.7**3.6  #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+23**1.9
+386.6187287073183
+1.7**13
+990.4578032905933
+```
+
+#### 4.7. Операции с комплексными числами
+
+```py
+z1 = 2 + 5j
+z2 = 4 - 3j
+z1 + z2
+(6+2j)
+z1 * z2
+(23+14j)
+z1 / z2
+(-0.28+1.04j)
+z1 // z2
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    z1//z2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+z1 % z2
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    z1%z2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+z1**z2
+(28648.976313547988-8542.480374144212j)
+```
+
+### 5. Операции с двоичными представлениями целых чисел.
+
+#### 5.1. Двоичная инверсия
+
+```py
+dv1 = 9
+dv2 = ~dv1
+dv2
+-10
+```
+
+#### 5.2. Двоичное "И"
+
+```py
+7 & 9  # 111 и 1001 = 0001
+1
+7 & 8  # 111 и 1000 = 0000
+0
+```
+
+#### 5.3. Двоичное "ИЛИ"
+
+```py
+7 | 9     # 111 или 1001 = 1111
+15
+7 | 8     # 111 или 1000 = 1111
+15
+14 | 5   # 1110 или 0101 = 1111
+15
+```
+
+#### 5.4. Двоичное «исключающее ИЛИ»
+
+```py
+14 ^ 5  # 1110 исключающее или 0101 = 1011
+11
+```
+
+Число 11 получилось при переводе 1011 из двоичной системы в десятичную.
+
+#### 5.5. Сдвиг двоичного представления на заданное число разрядов влево или вправо с дополнением нулями
+
+```py
+h = 14   #Двоичное представление = 1110
+g = h<<2  # Новое двоичное представление = 111000
+g
+56
+g1 = h>>1  # Новое двоичное представление = 0111
+g1
+7
+g2 = h>>2  # Новое двоичное представление = 0011
+g2
+3
+h0 = 134
+bin(h0)
+'0b10000110'
+g0 = h0<<1
+g0
+268
+bin(g0)
+'0b100001100'
+g0 = h0>>3
+g0
+16
+bin(g0)
+'0b10000'
+```
+Создание двух двоичных чисел с 7-ю знаками и выполнение операций над ними:
+
+
+```py
+b1 = int("1110011",2)
+b2 = int("1000101",2)
+b_2 = ~b2
+b_2
+-70
+b1 & b2
+65
+b1 | b2
+119
+b1^b2
+54
+b1 >> 1
+57
+b2 << 3
+552
+b1
+115
+b2
+121
+```
+
+### 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
+signal2 = (0,)*3 + (1,)*5 + (0,)*7
+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, 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
+zz
+-12
+```
+
+#### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+
+```py
+zz += 5   # Значение zz увеличивается на 5
+zz -= 3  # Значение уменьшается на 3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+
+#### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+
+```py
+zz /= 2
+zz
+-5.0
+zz *= 5
+zz
+-25.0
+stroka='Система регулирования'
+stroka *= 2
+stroka
+'Система регулированияСистема регулирования'
+```
+
+#### 7.4.Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+
+```py
+zz //= 7
+zz
+-4.0
+zz %= 3
+zz
+2.0
+zz **= 4
+zz
+16.0
+```
+
+##### 7.5. Множественное присваивание
+
+```py
+w = v = 10  # Переменным присваивается одно и то же значение
+w
+10
+v
+10
+n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+n1;n2;n3
+11
+-3
+'all'
+n1,n2,n3 = "11", "-3", "all"
+n1;n2;n3
+'11'
+'-3'
+'all'
+n1,n2,n3 = [11,-3,'all']
+n1;n2;n3
+11
+-3
+'all'
+n1,n2,n3 = {11: 1,-3:2,'all':3}
+n1;n2;n3
+11
+-3
+'all'
+```
+
+### 8. Логические операции.
+
+#### 8.1. Операции сравнения
+
+```py
+w = v = 10
+w != v
+False
+w == v
+True
+w > v
+False
+w < v
+False
+w >= v
+True
+w <= v
+True
+```
+
+#### 8.2. Проверка наличия заданного элемента в последовательности или в множестве
+
+```py
+mnoz1 = {'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+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
+(12 < 13) and ('Vologda' in dic1) and not ('azbuka' in mnoz1)
+True
+(81 > 14) and (12 < 5) or ("Orel" in dic1)
+True
+```
+
+#### 8.4. Проверка ссылок переменных на один и тот же объект (is)
+
+```py
+w = v = 10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1 = ['A','B']
+v1 = ['A','B']
+w1 is v1 #Оператор is в Python проверяет, ссылаются ли две переменные на один и тот же объект в памяти, а не на одинаковые значения.
+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 = [2, 4, 1, 7, 'a']
+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)
+1
+spsk
+[2, 4, 7, 'a']
+spsk.append('c')
+spsk
+[2, 4, 7, 'a', 'c']
+spsk.insert(2, 'a')
+spsk
+[2, 4, 'a', 7, 'a', 'c']
+spsk.count('a')
+2
+```
+
+#### 9.3. Методы для работы с кортежами
+
+```py
+t = (3, 3, 5, 6, 7)
+dir(t)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+t.count(3)
+2
+t.index(7)
+4
+len(t)
+5
+t[1]
+3
+```
+
+#### 9.4. Методы для работы со словарями и множествами
+
+```py
+#словарь
+d = {'a': 1, 'b': 2, 'c': 3, 'd':4}
+dir(d)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+d.keys()
+dict_keys(['a', 'b', 'c', 'd'])
+d.values()
+dict_values([1, 2, 3, 4])
+d.get('b')
+2
+d.update({'t': 4})
+e
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+#множество
+s = {2, 4, 7, 1, 3}
+dir(s)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+s.add(5)
+s
+{1, 2, 3, 4, 5, 7}
+s.remove(4)
+s
+{1, 2, 3, 5, 7}
+s.intersection({1, 7}) #пересечение множеств
+{1, 7}
+```
+
+### 10. Закончен сеанс работы с IDLE.

TEMA3/task.md

@@ -0,0 +1,39 @@
+# Тест по модулю 1. Вариант 16
+Сарайкина Вера, А-02-23
+
+## 1)
+	Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+## для плучения помощи можно воспользоваться командой help(), где в скобочкках необходимо указать коману,по которой требуется помощь, так же в интерактивном меню IDLE есть раздел "help", где так же можно посмотреть помощь, еще помощь можно получить через официальную документацию python
+
+## 2)	Создайте объект-строку с текстом: "Среда Python - эффективное средство разработки ПО". Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+```py
+s = "Среда Python - эффективное средство разработки ПО"
+type(s)
+<class 'str'>
+dir(s)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+## 3)	Напишите инструкцию, создающую новую строку добавлением перед словом "эффективное" слова "очень". Отобразите получившийся объект.
+```py
+a = s.replace("эффективное", "очень эффективное")
+print(a)
+Среда Python - очень эффективное средство разработки ПО
+```
+## 4)	Преобразуйте строку в список. Отобразите полученный объект. Подсчитайте, сколько раз в этот список входит символ "е". Проверьте, есть ли в этом списке символ "Q".
+```py
+spis=list(a)
+print(spis)
+['С', 'р', 'е', 'д', 'а', ' ', 'P', 'y', 't', 'h', 'o', 'n', ' ', '-', ' ', 'о', 'ч', 'е', 'н', 'ь', ' ', 'э', 'ф', 'ф', 'е', 'к', 'т', 'и', 'в', 'н', 'о', 'е', ' ', 'с', 'р', 'е', 'д', 'с', 'т', 'в', 'о', ' ', 'р', 'а', 'з', 'р', 'а', 'б', 'о', 'т', 'к', 'и', ' ', 'П', 'О']
+spis.count("е")
+5
+"Q" in spis
+False
+```
+## 5)	Создайте на основе строки кортеж с подстроками, разделенными в исходной строке символами "пробел".
+```py
+kort=tuple(a.split( ))
+print(kort)
+('Среда', 'Python', '-', 'очень', 'эффективное', 'средство', 'разработки', 'ПО')
+
+```

TEMA3/tesst1.md

@@ -0,0 +1,39 @@
+int('45', 8)
+37
+D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+listK = list(D.keys())
+listV = list(D.values())
+listK
+['усиление', 'запаздывание', 'постоянная времени']
+listV
+[23, 12, 78]
+result1 = (keys_list, values_list)
+result1
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+(1768 // 24.8 % 3) ** 2.4
+5.278031643091577
+((~(13 & 27) ^ 14) << 2)
+-32
+list1 = ['колебат'] * 4
+list1
+['колебат', 'колебат', 'колебат', 'колебат']
+'аткол' in (list1[1] + list1[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']
+list(D.keys())
+['усиление', 'запаздывание', 'постоянная времени']
+list(D.values())
+[23, 12, 78]
+object = "Создать объект - символьную строку с текстом данного предложения."
+object
+'Создать объект - символьную строку с текстом данного предложения.'
+newsp = object.split()
+newsp
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+newsp[newsp.index('-')] = ','
+newsp
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+newsp.remove('данного')
+newsp
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']

TEMA4/report.md

@@ -0,0 +1,313 @@
+# Отчет по теме 4
+
+Сарайкина Вера, А-02-23
+
+### 1. Настройка текущего каталога.
+```py
+import os
+os.chdir('C:\Users\Yarik\Desktop\labi\python-labs\TEMA4')
+```
+### 2. Стандартные функции.
+
+#### 2.1. Функция округления числа с заданной точностью
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+type(round(123.456,0))
+<class 'float'>
+type(round(123.456,1))
+<class 'float'>
+round(123.456)
+123
+type(round(123.456))
+<class 'int'>
+
+```
+
+#### 2.2. Функция range 
+
+```py
+gg=range(76,123,9)
+gg
+range(76, 123, 9)
+type(gg)
+<class 'range'>
+list(gg)
+[76, 85, 94, 103, 112, 121]
+range(23)
+range(0, 23)
+#range(23) создает последовательность целых чисел от 0 до 22 с шагом 1
+list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+#### 2.3. Функция zip 
+
+```py
+qq = ["Похил", "Сарайкина", "Снегура", "Шинкаренко"]
+ff=zip(gg,qq)
+ff
+<zip object at 0x00000293529A1180>
+tuple(ff)
+((76, 'Похил'), (85, 'Сарайкина'), (94, 'Снегура'), (103, 'Шинкаренко'))
+ff[0]
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+```
+
+
+## 2.4. Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки. 
+```py
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=5
+fff
+5.0
+dan
+-131.0
+```
+
+## 2.5. Функция exec – чтение и выполнение объекта-аргумента функции (Этот объект должен представлять собой строку символов  с совокупностью инструкций на языке Python)
+```py
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+## 2.6.  Самостоятельное изучение функций abs, pow, max, min, sum, divmod, len, map. 
+```py
+gg
+221.456
+abs(-5)
+5
+pow(2, 3)
+8
+max([1, 5, 2])
+5
+min([1, 5, 2])
+1
+sum([1, 2, 3])
+6
+divmod(10, 3) # частное и остаток
+(3, 1)
+len("abc")
+3
+list(map(str, [1, 2, 3])) # применяет функцию к каждому элементу
+['1', '2', '3']
+```
+## 3.	Функции из стандартного модуля math – совокупность разнообразных математических функций.
+```py
+math.sin(3.14)
+0.0015926529164868282
+math.acos(0.5)
+1.0471975511965979
+math.degrees(1)
+57.29577951308232
+math.radians(57.29577951308232)
+1.0
+math.exp(1)
+2.718281828459045
+math.log(2.302585092994046) # натуральный логарифм
+0.834032445247956
+math.log10(100)
+2.0
+math.sqrt(16)
+4.0
+math.ceil(1.2) # округление вверх
+2
+math.floor(0.9) # округление вниз
+0
+math.pi
+3.141592653589793
+math.sin(2 * math.pi / 7 + math.exp(0.23))
+0.8334902641414562
+```
+## 4.	 Функции из модуля cmath – совокупность функций для работы с комплексными числами.
+```py
+import cmath
+dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+cmath.phase(1-0.5j) # угол в радианах
+-0.4636476090008061
+```
+## 5.	 Стандартный модуль random – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```py
+import random
+dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__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 (равно-мерно распределенное случайное число), uniform (равномерно распределенное случайное число), randint (случайные целые числа), gauss (нормально распределенное случайное число), randint (случайное целое число), choice (случайный выбор из совокупности), shuffle (случайная переста-новка элементов списка), sample (случайный выбор подмножества элементов), betavariate(случайное число с бета-распределением), gammavariate(случайное число с гамма-распределением).
+```py
+random.random()
+0.6199792494543297
+random.uniform(1, 10)
+7.745269197841402
+random.randint(1, 6)
+3
+random.gauss(0, 1)
+1.0442172814729307
+random.choice(['a','b','c'])
+'b'
+lst = [1,2,3]; random.shuffle(lst)
+lst
+[3, 2, 1]
+random.sample([1,2,3,4], 2)
+[4, 2]
+random.betavariate(2, 5)
+0.27219690103691246
+random.gammavariate(2, 1)
+2.5239555636492557
+```
+Создам список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+```py
+spisok = [random.uniform(1, 10), random.gauss(0, 1), random.betavariate(2, 5), random.gammavariate(2, 1)]
+spisok
+[4.813064235823525, -0.2439125318449509, 0.12581423894318752, 1.940336067871031]
+```
+## 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()
+c2=time.time()-c1
+c2
+18.061716318130493
+c1
+1760287587.2442193
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=16, tm_min=51, tm_sec=23, tm_wday=6, tm_yday=285, tm_isdst=0)
+dat.tm_mon
+10
+local_time = time.localtime()
+local_time
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=19, tm_min=54, tm_sec=1, tm_wday=6, tm_yday=285, tm_isdst=0)
+print(f"Год: {local_time.tm_year}")
+Год: 2025
+```
+Изучу и попробую применить функции: asctime (преобразование представления времени из кортежа в строку) , ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку), sleep (прерывание работы программы на заданное время), mktime (преобразова-ние времени из типа кортежа или struct_time в число секунд с начала эпохи). Обратное преобразование из секунд в местное время осуществляется той же функцией localtime()
+time.localtime(c1)
+```py
+c1 = time.time()
+local_struct = time.localtime(c1)
+local_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=19, tm_min=59, tm_sec=42, tm_wday=6, tm_yday=285, tm_isdst=0)
+time_str = time.asctime(local_struct)
+time_str
+'Sun Oct 12 19:59:42 2025'
+time_str2 = time.ctime(c1)
+time.sleep(2)
+seconds = time.mktime(local_struct)
+seconds
+1760288382.0
+new_struct = time.localtime(seconds)
+new_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=19, tm_min=59, tm_sec=42, tm_wday=6, tm_yday=285, tm_isdst=0)
+```
+## 7.	 Графические функции.
+```py
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+t
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x00000130A1F4E990>]
+pylab.title
+<function title at 0x00000130A1BD8F40>
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+![](Ris1.png)
+
+Рассмотрим способ построения нескольких графиков на одном рисунке.
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000026ABB1756D0>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000026ABB175810>]
+>>> pylab.show()
+```
+![](Ris2.png)
+Изучение возможности построения круговой диаграммы
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000026ABA668050>, <matplotlib.patches.Wedge object at 0x0000026ABD80B110>, <matplotlib.patches.Wedge object at 0x0000026ABD80B4D0>, <matplotlib.patches.Wedge object at 0x0000026ABD80B750>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+![](Ris3.png)
+попробую применить функции hist и bar для построения гистограмм и столбиковых диаграмм. 
+```py
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+pylab.hist(data,5)
+(array([1., 2., 3., 2., 1.]), array([1. , 1.8, 2.6, 3.4, 4.2, 5. ]), <BarContainer object of 5 artists>)
+pylab.show()
+c = ['A', 'B', 'C']
+v = [10, 25, 15]
+pylab.bar(c, v)
+<BarContainer object of 3 artists>
+pylab.show()
+```
+получились следующие графики
+![](hist.png)
+![](bar.png)
+
+## 8.	Самостоятельное изучение состава статистического модуля statistics.
+```py
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5] 
+import statistics 
+sred = statistics.mean(data) # среднее значение
+moda = statistics.mode(data) # Мода (наиболее частое значение)
+often
+3
+mediana = statistics.median(data) # медиана
+mediana
+3
+```

TEMA4/test.md

@@ -0,0 +1,26 @@
+Индивидуальное контрольное задание
+Сарайкина Вера, А-02-23
+Задание:
+10.Создайте кортеж с 5 значениями – случайными числами с равномерным законом распределения в интервале от 7.6 до 8.3. Создайте список со значениями, равными натуральным логарифмам от значений соответствующих элементов кортежа. Зафиксируйте текущее Московское время и отобразите его в виде строки «В Москве сейчас <значение> часов и <значение> минут».
+```py
+import random
+import math
+import time
+tuple1 = tuple(random.uniform(7.6, 8.3) for i in range(5))
+
+
+logarifm = [math.log(x) for x in tuple1]
+
+a = time.localtime()
+a
+
+print("Кортеж:", tuple1)
+print("Натуральные логарифмы:", logarifm)
+print("В Москве сейчас" ,time.localtime().tm_hour, "часов и", time.localtime().tm_min, "минут")
+```
+Вывод:
+```py
+Кортеж: (8.275202376847693, 8.108903471913068, 7.705466784938912, 7.724839785452687, 8.235811729418307)
+Натуральные логарифмы: [2.113263377380713, 2.092962652070268, 2.0419300490186827, 2.0444410828215127, 2.1084919294358673]
+В Москве сейчас 14 часов и 35 минут
+```