Изменил(а) на 'TEMA4/report.md'

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по теме 1 Лыковой Е.А
+print("Hello")
+h=input("Your name=")
+import os
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova")

TEMA1/protokol.py

@@ -0,0 +1,60 @@
+#Протокол по теме 1 Лыковой Е.А
+import os
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova\\TEMA1\\")
+
+============= RESTART: C:/Users/u207-06/Desktop/Lykova/TEMA1/Pr0.py ============
+Hello
+Your name=Lizp
+import Pr0
+Hello
+Your name=Lizp
+import prb1
+Как Вас зовут? Лизп
+Привет, Лизп
+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.
+
+help(print),help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+============ RESTART: C:\Users\u207-06\Desktop\Lykova\TEMA1\prb1.py ============
+Как Вас зовут? Лизп
+Привет, Лизп
+import tdemo_chaos

TEMA1/report.md

@@ -0,0 +1,123 @@
+# Отчет по теме 1
+
+Лыкова Елизавета, А-01-23
+
+## 1. Создание копии репозитория 
+
+```
+$ git clone http://uit.mpei.ru/git/LykovaYA/python-labs.git
+```
+
+## 1.1 Клонирование форка на рабочий стол, перебазирование личного форка на исходный репозиторий
+
+```
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git remote add upstream http://uit.mpei.ru/git/main/python-labs.git
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git fetch upstream
+From http://uit.mpei.ru/git/main/python-labs
+ * [new branch]      main       -> upstream/main
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git stash push
+No local changes to save
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git rebase upstream/main
+Current branch main is up to date.
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git stash pop
+No stash entries found.
+```
+
+## 2. Запуск Питона
+
+## 2.1 Изучение интерпретатора
+
+>>> print("Hello")
+Hello
+
+>>> h=input("Your name=")
+Your name=Lizp
+
+>>> exit()
+
+## 3. Ввод интрукций настройки рабочего каталога среды
+
+import os
+
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova\\TEMA1\\")
+
+## 4. Создание файла "Программа по теме 1", её запуск
+
+#Программа по теме 1 Лыковой Е.А
+
+print("Hello")
+
+h=input("Your name=")
+
+import os
+
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova")
+
+
+## 5. Запуск программы prb1.py из рабочего каталога
+
+## 5.1 Попытка открыть файл Pr0.cpython-311 из каталога `pycache`.
+При попытке открыть файл в текстовом редакторе человек вместо привычных букв увидит странные символы и/или надписи NUL.
+Так происходит из-за того, что информация записана в двоичном коде. Компиляция программ происходит для преобразования текста в машинный код, оптимизации.
+
+## 6. Создание файла "Протокол по теме 1"
+
+## 6.1 Изучение раздела Help.
+В этом разделе можно найти актуальную информацию про IDLE, по типу версии, обновлений, лицензии. Так же здесь присутсвует краткий гайд для использования программы.
+В наличии так же демо-версия программы TURTLE и справочник по Python.
+
+## 6.2 
+
+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.
+
+help(print),help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+## 7. Перемещение между различными окнами программы благодаря Window. В TURTLE присутсвуют готовые примеры программ с доступным кодом.

TEMA1/test.md

@@ -0,0 +1,11 @@
+# Индивидуальное контрольное задание по теме 1
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Для чего предназначено предложение "Окно (Window)" главного меню?
+
+## Ответ
+
+Предложение "Окно"("Window") главного меню предназначено для возможности быстрого перемещения между окнами программы, благодаря выпадающему меню, в котором записаны все открытые на данный момпент файлы.

TEMA2/report.md

@@ -0,0 +1,484 @@
+# Отчет по теме 2
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\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']
+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'>
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## 3. Изучение правил наименования объектов.
+
+```py
+gg1 = 1.6
+hh1 = "Строка"
+73sr = 3
+SyntaxError: invalid decimal literal
+and = 7
+SyntaxError: invalid syntax
+```
+
+## 4. Список ключевых слов.
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+keyword_list = keyword.kwlist
+```
+
+## 5. Список встроенных идентификаторов.
+
+```py
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError',
+'BaseException', 'BaseExceptionGroup', 'BlockingIOError',
+'BrokenPipeError', 'BufferError', 'BytesWarning',
+'ChildProcessError',...]
+help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+help (len)
+Help on built-in function len in module builtins:
+
+len(obj, /)
+    Return the number of items in a container.
+
+help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    max(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its biggest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the largest argument.
+
+help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+    min(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its smallest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the smallest argument.
+
+help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
+
+    Some types, such as ints, are able to use a more efficient algorithm when
+    invoked using the three argument form.
+
+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.
+
+help(sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+help (sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+ |  shortest argument is exhausted.
+ |
+ |  If strict is true and one of the arguments is exhausted before the others,
+ |  raise a ValueError.
+ |
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |
+ |  Methods defined here:
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __next__(self, /)
+ |      Implement next(self).
+ |
+ |  __reduce__(self, /)
+ |      Return state information for pickling.
+ |
+ |  __setstate__(self, object, /)
+ |      Set state information for unpickling.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+
+abs(-5)
+5
+len('primer')
+6
+max(9,8,3)
+9
+min(9,8,3)
+3
+pow(2,3)
+8
+round (5.2381, 2)
+5.24
+pack = (2,5,1,0,4)
+sorted(pack)
+[0, 1, 2, 4, 5]
+sum(pack)
+12
+pack2 = ('A','B','C','D','E')
+fullpack = list(zip(pack,pack2))
+print(fullpack)
+[(2, 'A'), (5, 'B'), (1, 'C'), (0, 'D'), (4, 'E')]
+```
+
+## 6. Убеждаемся, что малые и большие буквы в именах объектов различаются.
+
+```py
+Gg1=45
+gg1,Gg1
+(1.6, 45)
+```
+
+## 7. Изучение простых базовых типов объектов.
+
+## 7.1. Логический тип
+
+```py
+bb1=True;bb2=False
+bb1,bb2
+(True, False)
+type(bb1)
+<class 'bool'>
+```
+
+## 7.2. Остальные типы
+
+```py
+ii1=-1234567890
+ii1
+-1234567890
+type(ii1)
+<class 'int'>
+ff1=-8.9876e-12
+ff1
+-8.9876e-12
+type(ff1)
+<class 'float'>
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+vsm1
+22005
+type(vsm1)
+<class 'int'>
+shest1=0x7109af6
+shest1
+118528758
+type(shest1)
+<class 'int'>
+cc1=2-3j
+cc1
+(2-3j)
+type(cc1)
+<class 'complex'>
+a=3.67;b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j)
+```
+
+## 7.3 Символьная строка.
+
+```py
+ss1='Это-строка символов'
+ss1="Это-строка символов"
+ssa1 = "Это - \"строка символов\", \n \t выводимая на двух строках"
+print(ssa1)
+Это - "строка символов", 
+ 	 выводимая на двух строках
+ss1b = 'Меня зовут: \n Лыкова Е.А'
+print(ss1b)
+Меня зовут: 
+ Лыкова Е.А
+mnogo = """Нетрудно заметить, что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвут в операции."""
+print(mnogo)
+Нетрудно заметить, что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвут в операции.
+ss1[0]
+'Э'
+ss1[8]
+'к'
+ss1[-2]
+'о'
+ss1[6:9]
+'рок'
+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#82>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+ss1
+'Это-=трока символов'
+print(ss1b)
+Меня зовут: 
+ Лыкова Е.А
+ss1b[5:8]
+'зов'
+ss1b[::-2]
+'АЕаоы  твзяе'
+ss1b[-6:10:3]
+''
+```
+
+## 8. Изучение более сложных типов объектов.
+
+## 8.1 Списки.
+
+```py
+spis1 = [111,'Spisok',5-9j]
+spis1
+[111, 'Spisok', (5-9j)]
+stup = [0,0,1,1,1,1,1,1,1]
+stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+spis = [1,2,3,4,
+        5,6,7,
+        8,9,10]
+spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+spis[-1]
+10
+stup[-8::2]
+[0, 1, 1, 1]
+```
+
+В этот список вошло четыре элемента. В исходном списке они имели индексы 1, 3, 5, 7
+
+```py
+spis1[1] = 'Список'
+spis1
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+dir(spis1)
+['__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']
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+spis1.append('New item')
+spis1
+[111, 'Список', (5-9j), 'New item']
+spis1+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+spis1.append(ss1b)
+spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.pop(1)
+'Список'
+spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.insert(1, 'Vesch')
+spis1
+[111, 'Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.remove(111)
+spis1
+['Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.extend(['lol'])
+spis1
+['Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А', 'lol']
+spis1.clear()
+spis1
+[]
+spisnew = [ 'V', 'C', 'O', 'S']
+spisnew.sort()
+spisnew
+['C', 'O', 'S', 'V']
+spisnew.reverse()
+spisnew
+['V', 'S', 'O', 'C']
+spisnew.copy()
+['V', 'S', 'O', 'C']
+spiscopy = spisnew.copy()
+spiscopy
+['V', 'S', 'O', 'C']
+spisnew.count('O')
+1
+spisnew.index('O')
+2
+spis2=[spis1,[4,5,6,7]]
+spis2[0][1]
+'Spisok'
+spis2[0][1]=78
+spis2
+[[111, 78, (5-9j)], [4, 5, 6, 7]]
+spis1
+[111, 78, (5-9j)]
+```
+
+Объект spis1 отличается от своего изначального вида, поскольку мы использовали на нём различные функции,
+которые добавляли, убирали и изменяли объекты в нём.
+
+```py
+spisochek = [17, 17, 17, 16]
+moispisok = [1991, 'Stroka', False, spisochek]
+moispisok
+[1991, 'Stroka', False, [17, 17, 17, 16]]
+```
+
+## 8.2 Объект-кортеж
+
+```py
+kort1 = (222,'Kortezh',77+8j)
+kort1 = kort1 + (1,2)
+kort1 = kort1 + (ss1b,)
+kort2 = kort1[:2]+kort1[3:]
+kort2.index(2)
+3
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#177>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+moikort = (2005,'StrokaNovaya',spisochek,kort1)
+moikort
+(2005, 'StrokaNovaya', [17, 17, 17, 16], (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Лыкова Е.А'))
+```
+
+## 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}
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+dic2={1:'mean',2:'standart devation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+'standart devation'
+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 Лыкова Е.А'}
+kortezh = ('A','B','C','D','E','F','G')
+spisok = (1,2,3,4,5)
+slovar = dict(zip(kortezh,spisok))
+print(slovar,len(slovar))
+{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5} 5
+```
+
+## 8.4. Объект-множество
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'микропроцессор', 'линия связи', 'датчик', 'двигатель'}
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1.remove('линия связи')
+mnoz1
+{'микропроцессор', 'двигатель', 'датчик', 'реле'}
+mnozestvo = {'огурец','дикий огурец','кукуруза'}
+len(mnozestvo)
+3
+'кукуруза' in mnozestvo
+True
+mnozestvo.add('кукуруза сейчас')
+mnozestvo
+{'дикий огурец', 'огурец', 'кукуруза сейчас', 'кукуруза'}
+mnozestvo.remove('огурец')
+mnozestvo
+{'дикий огурец', 'кукуруза сейчас', 'кукуруза'}
+```

TEMA2/task.md

@@ -0,0 +1,33 @@
+# Общее контрольное задание по теме 2
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия.
+
+## Решение
+
+```py
+familia = 'Lykova'
+sovpad = familia[0]
+import keyword
+sp_kw = keyword.kwlist
+sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+sp_kw.remove('nonlocal')
+sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+kort_nam = ('Елизавета','Екатерина','Дмитрий','Даниил')
+print('Тип переменной:', type(kort_nam))
+Тип переменной: <class 'tuple'>
+kort_nam = kort_nam + ('Иван','Федор')
+kort_nam
+('Елизавета', 'Екатерина', 'Дмитрий', 'Даниил', 'Иван', 'Федор')
+count = kort_nam.count('Дима')
+count
+0
+dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
+dict_bas
+{'Строка': 'Lykova', 'Список': ['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/test.md

@@ -0,0 +1,23 @@
+# Индивидуальное контрольное задание по теме 2
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Пусть создан объект dd = [11,2,-4,23,12,56]
+К какому классу он относится? Как расположить его элементы в порядке убывания?
+
+## Решение
+
+```py
+dd = [11,2,-4,23,12,56]
+print('Класс объекта:', type(dd))
+Класс объекта: <class 'list'>
+dd.sort(reverse=True)
+dd
+[56, 23, 12, 11, 2, -4]
+# Ещё можно вот так (создается новый список)
+dds = sorted(dd, reverse=True)
+dds
+[56, 23, 12, 11, 2, -4]
+```

TEMA3/report.md

@@ -0,0 +1,680 @@
+# Отчет по теме 3
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA3")
+```
+
+## 2. Преобразование простых базовых типов объектов.
+
+## 2.1 Логическая функция bool.
+
+```py
+logiz1 = bool(56)
+logiz1, type(logiz1)
+(True, <class 'bool'>)
+logiz2 = bool(0)
+logiz2, type(logiz2)
+(False, <class 'bool'>)
+logiz3 = bool("Beta")
+logiz3, type(logiz3)
+(True, <class 'bool'>)
+logiz4 = bool("")
+logiz4, type(logiz4)
+(False, <class 'bool'>)
+```
+
+## 2.2.1 Функция int.
+
+```py
+tt1 = int(198.6)
+tt1, type(tt1)
+(198, <class 'int'>)
+tt2 = int('-76')
+tt2, type(tt2)
+(-76, <class 'int'>)
+tt3 = int('B',16)
+tt3, type(tt3)
+(11, <class 'int'>)
+tt4 = int('71',8)
+tt4, type(tt4)
+(57, <class 'int'>)
+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'
+```
+
+Диагностическое сообщение было выведено из-за того, что int ожидает в кавычках целое число, а не дробное.
+
+## 2.2.2 Функция float.
+
+```py
+flt1 = float(789)
+flt1, type(flt1)
+(789.0, <class 'float'>)
+flt2 = float(-6.78e2)
+flt2, type(flt2)
+(-678.0, <class 'float'>)
+flt3 = float('Infinity')
+flt3, type(flt3)
+(inf, <class 'float'>)
+flt4 = float('-inf')
+flt4, type(flt4)
+(-inf, <class 'float'>)
+```
+
+## 2.3. Другие системы счисления.
+
+```py
+hh = 123
+dv1 = bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(vos1,8)
+123
+int(shs1,16)
+123
+```
+
+## 3. Сложные базовые типы объектов.
+
+## 3.1 Функция str.
+
+```py
+strk1 = str(23.6)
+strk1, type(strk1)
+('23.6', <class 'str'>)
+strk2 = str(logiz3)
+strk2, type(strk2)
+('True', <class 'str'>)
+strk3 = str(['A','B','C'])
+strk3, type(strk3)
+("['A', 'B', 'C']", <class 'str'>)
+strk4 = str(('A','B','C'))
+strk4, type(strk4)
+("('A', 'B', 'C')", <class 'str'>)
+strk5 = str({'A':1,'B':2,'C':9})
+strk5, type(strk5)
+("{'A': 1, 'B': 2, 'C': 9}", <class 'str'>)
+```
+
+## 3.2 Функция list.
+
+```py
+spis1 = list('Строка символов')
+spis1, type(spis1)
+(['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'], <class 'list'>)
+spis2 = list((124,236,-15,908))
+spis2, type(spis2)
+([124, 236, -15, 908], <class 'list'>)
+spis3 = list({'A':1,'B':2,'C':9})
+spis3, type(spis3)
+(['A', 'B', 'C'], <class 'list'>)
+# Список со значениями
+spis4 = list({'A':1,'B':2,'C':9}.values())
+spis4, type(spis4)
+([1, 2, 9], <class 'list'>)
+# Словарь полностью
+spis4 = list({'A':1,'B':2,'C':9}.items())
+spis4, type(spis4)
+([('A', 1), ('B', 2), ('C', 9)], <class 'list'>)
+```
+
+## 3.3 Функция tuple.
+
+```py
+kort7=tuple('Строка символов')
+kort7, type(kort7)
+(('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'), <class 'tuple'>)
+kort8 = tuple(spis2)
+kort8, type(kort8)
+((124, 236, -15, 908), <class 'tuple'>)
+kort9 = tuple({'A':1,'B':2,'C':9})
+kort9, type(kort9)
+(('A', 'B', 'C'), <class 'tuple'>)
+```
+
+## 3.4 Удаление объектов.
+
+```py
+del strk5, kort8
+print(strk5)
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    print(strk5)
+NameError: name 'strk5' is not defined
+print(kort8)
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    print(kort8)
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+imya = 'Lykova E.A'
+imya
+'Lykova E.A'
+spis = list(imya)
+spis
+['L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A']
+kort = tuple(spis)
+kort
+('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')
+strk = str(kort)
+strk
+"('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')"
+```
+
+## 4. Арифметические операции.
+
+## 4.1 Сложение и вычитание.
+
+```py
+12+7+90
+109
+5.689e-1-0.456
+0.11289999999999994
+23.6 + 54
+77.6
+14 - 56.7 + 89
+46.3
+```
+
+## 4.2 Умножение.
+
+```py
+-6.7 * 12
+-80.4
+```
+
+## 4.3 Деление.
+
+```py
+-234.5/6
+-39.083333333333336
+a = 178/45
+a, type(a)
+(3.9555555555555557, <class 'float'>)
+```
+
+## 4.4 Деление с округлением вниз.
+
+```py
+b = 178//45
+b, type(b)
+(3, <class 'int'>)
+c = -24.6//12.1
+c, type(c)
+(-3.0, <class 'float'>)
+d = 178//12.1
+d, type(d)
+(14.0, <class 'float'>)
+e = -24.6//45
+e, type(e)
+(-1.0, <class 'float'>)
+```
+
+## 4.5 Остаток от деления.
+
+```py
+148%33
+16
+12.6%3.8
+1.2000000000000002
+148%3.8
+3.6000000000000068
+12.6%33
+12.6
+```
+
+## 4.6 Возведение в степень.
+
+```py
+14**3
+2744
+e = 2.7**3.6
+e
+35.719843790663525
+14**3.6
+13367.830445904418
+2.7**3
+19.683000000000003
+c1 = 3 + 4j
+c2 = 1 - 2j
+c1 + c2
+(4+2j)
+c1 - c2
+(2+6j)
+c1 * c2
+(11-2j)
+c1/c2
+(-1+2j)
+c1//c2
+Traceback (most recent call last):
+  File "<pyshell#50>", line 1, in <module>
+    c1//c2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+c1%c2
+Traceback (most recent call last):
+  File "<pyshell#51>", line 1, in <module>
+    c1%c2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+c1** 2
+(-7+24j)
+```
+
+Как мы видим, для работы с комплексными числами нельзя применять операции остатка от деления и деление с округлением вниз.
+
+## 5. Операции с двоичным представдением целых чисел.
+
+## 5.1 Двоичная инверсия.
+
+```py
+dv1 = 9
+dv2 = ~dv1
+bin(dv1)
+'0b1001'
+dv2
+-10
+bin(dv2)
+'-0b1010'
+```
+
+## 5.2 Двоичное 'И'.
+
+```py
+7&9
+1
+bin(7&9)
+'0b1'
+7&8
+0
+bin(7&8)
+'0b0'
+```
+
+## 5.3 Двоичное 'ИЛИ'.
+
+```py
+7|9
+15
+bin(7|9)
+'0b1111'
+7|8
+15
+bin(7|8)
+'0b1111'
+14|5
+15
+bin(14|5)
+'0b1111'
+```
+
+## 5.4 Двоичное исключающее 'ИЛИ'.
+
+```py
+14^5
+11
+bin(14^5)
+'0b1011'
+```
+
+## 5.5 Сдвиг двоичного представления на заданное число разрядов.
+
+```py
+l1 = 68
+l2 = 71
+bin(l1)
+'0b1000100'
+bin(l2)
+'0b1000111'
+bin(~l1)
+'-0b1000101'
+bin(~l2)
+'-0b1001000'
+bin(l1&l2)
+'0b1000100'
+bin(l1|l2)
+'0b1000111'
+bin(l1^l2)
+'0b11'
+bin(l1>>2)
+'0b10001'
+bin(l2<<1)
+'0b10001110'
+```
+
+## 6. Операции при работе с последовательностями.
+
+## 6.1 Объединение последовательностей.
+
+```py
+'Система' + 'регулирования'
+'Системарегулирования'
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+## 6.2 Повторение
+
+```py
+'ля'*5
+'ляляляляля'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2 = (0,)*3+(1,)*5+(0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+## 6.3 Проверка наличия заданного элемента в последовательности.
+
+```py
+stroka = 'Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc','de','fg','hi','jkl')
+False
+```
+
+## 6.4 Подстановка значений в строку.
+
+```py
+stroka = 'Температура = %g %s %g'
+stroka
+'Температура = %g %s %g'
+stroka % (16, 'меньше', 25)
+'Температура = 16 меньше 25'
+stroka = 'Температура = %(zn1)g%(sptavn)s %(zn2)g'
+stroka
+'Температура = %(zn1)g%(sptavn)s %(zn2)g'
+stroka %{'zn1':16,'sptavn':'меньше','zn2':25}
+'Температура = 16меньше 25'
+```
+
+## 7. Оператор присваивания.
+
+## 7.1 Обычное присваивание.
+
+```py
+zz=-12
+zz
+-12
+```
+
+## 7.2 Увеличение значения на заданную величину.
+
+```py
+zz+=5
+zz
+-7
+zz-=3
+zz
+-10
+stroka = 'Система'
+stroka+= 'регулирования'
+stroka
+'Системарегулирования'
+```
+
+## 7.3 Умножение на заданную величину.
+
+```py
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+strokan = 'ля'
+strokan *= 5
+strokan
+'ляляляляля'
+```
+
+## 7.4 Операция деления с округлением, получение остатка от деления и возведение в степень.
+
+```py
+ll = 77
+ll//=3
+ll
+25
+ll%=3
+ll
+1
+ll**=7
+ll
+1
+```
+
+## 7.5 Множественное присваивание.
+
+```py
+w = v = 10
+n1,n2,n3=(11,-3,'all')
+w
+10
+v
+10
+n1
+11
+n2
+-3
+n3
+'all'
+a1,a2,a3 = 'na', 'no', 'nu'
+a1,a2,a3
+('na', 'no', 'nu')
+a1,a2,a3 = 'abc'
+a1,a2,a3
+('a', 'b', 'c')
+b1,b2,b3 = ['la','lo','lu']
+b1,b2,b3
+('la', 'lo', 'lu')
+c1,c2,c3 = {'ha':1,'ho':2,'he':3}
+c1,c2,c3
+('ha', 'ho', 'he')
+d1,d2,d3 = {'me','ma','mo'}
+d1,d2,d3
+('ma', 'me', 'mo')
+```
+
+## 8. Логические операции.
+
+## 8.1 Операции сравнения.
+
+```py
+w == v
+True
+w != v
+False
+w < v
+False
+w > v
+False
+w <= v
+True
+w >= v
+True
+```
+
+## 8.2 Проверка наличия заданного элемента.
+
+```py
+mnoz1 = {'pen','book','pen','iPhone','table','book'}
+mnoz1
+{'pen', 'table', 'iPhone', '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 Создание больших логических выражений.
+
+```py
+a = 17
+b = -6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a < b) or ('Saratov' in dic1) or ('deck' in mnoz1)
+True
+('Saratov' in dic1) and not (a<b) and not ('pen' in mnoz1)
+False
+```
+
+## 8.4 Проверка ссылок на один и тот же объект.
+
+```py
+w=v=10
+w is v
+True
+w1 =['A','B']
+v1 = ['A','B']
+w1 is v1
+False
+```
+
+В первом случае обе переменные присваиваются к одному уже существующему в памяти объекту, когда как во втором переменные ипсользуют два разных списка.
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+
+```py
+stroka = 'Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+## 9.1 Методы для работы со строками.
+
+```py
+stroka.find('пр')
+5
+stroka.count('c')
+0
+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 = [167, 'haha', 'meme', 89.7, 'sasalele']
+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)
+'meme'
+spsk.append('с')
+spsk
+[167, 'haha', 89.7, 'sasalele', 'с']
+spsk.insert(2,'a')
+spsk
+[167, 'haha', 'a', 89.7, 'sasalele', 'с']
+spsk.count('a')
+1
+```
+
+## 9.3 Методы работы с кортежом.
+
+```py
+tupl = (178, 'nana', 'jaja', 456, 90.4)
+dir(tupl)
+['__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']
+tupl.count(456)
+1
+tupl.index('nana')
+1
+```
+
+## 9.4 Методы словарей и множеств.
+
+```py
+slvr = {'A':'wot','B':45,'C':39,'D':'meme','F':'pepe'}
+slvr
+{'A': 'wot', 'B': 45, 'C': 39, 'D': 'meme', 'F': 'pepe'}
+dir(slvr)
+['__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']
+slvr.keys()
+dict_keys(['A', 'B', 'C', 'D', 'F'])
+slvr.items()
+dict_items([('A', 'wot'), ('B', 45), ('C', 39), ('D', 'meme'), ('F', 'pepe')])
+slvr.values()
+dict_values(['wot', 45, 39, 'meme', 'pepe'])
+slvr.get('A')
+'wot'
+mnozh = {'haha', 763, 'ikk', 98.6, 'fsfs'}
+dir(mnozh)
+['__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']
+mnozh.pop()
+98.6
+mnozh.pop()
+'fsfs'
+mnozh
+{763, 'haha', 'ikk'}
+mnozh.add('pfff')
+mnozh
+{'pfff', 763, 'haha', 'ikk'}
+mnozh.remove('haha')
+mnozh
+{'pfff', 763, 'ikk'}
+```
+
+
+
+
+
+
+

TEMA3/task.md

@@ -0,0 +1,61 @@
+# Общее контрольное задание по теме 3
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия.
+
+• Преобразовать восьмеричное значение 45 в целое число.
+
+• Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+• Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+• Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+• Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+• Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+• Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+int('45',8)
+37
+D = {'Усиление':23,'Запаздывание':12,'Постоянная времени':78}
+D
+{'Усиление': 23, 'Запаздывание': 12, 'Постоянная времени': 78}
+D1 = list(D.keys())
+D1
+['Усиление', 'Запаздывание', 'Постоянная времени']
+D2 = list(D.values())
+D2
+[23, 12, 78]
+D3 = tuple(zip(D1,D2))
+D3
+(('Усиление', 23), ('Запаздывание', 12), ('Постоянная времени', 78))
+## В отличие от кортежа список является изменяемым.
+((1768//24.8)%3)**2.4
+5.278031643091577
+((~(13&27))^14)<<2
+-32
+spis = ['колебат']*4
+'аткол' in (spis[1] + spis[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']
+D.keys()
+dict_keys(['Усиление', 'Запаздывание', 'Постоянная времени'])
+D.values()
+dict_values([23, 12, 78])
+# С помощью keys нам выводятся ключи, а с помощью values - значения.
+strk = 'Создать объект - символьную строку с текстом данного предложения.'
+strk1 = strk.split()
+strk1[strk1.index('-')] = ','
+strk1.remove('данного')
+strk1
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/test.md

@@ -0,0 +1,62 @@
+# Тест 1 Вариант 3
+
+Лыкова Елизавета, А-01-23
+
+## Задание 
+
+1)	Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
+
+2)	Создайте объект-словарь с 6 элементами: ключи - названия звеньев в схеме регулятора ("инерционное звено1",:) (названия могут повторяться с точностью до порядкового номера), значения - список параметров соответствующего звена. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, позволяющую увеличить в два раза второй параметр инерционного звена в словаре. Отобразите на экране получившийся объект.
+
+4)	Напишите инструкции, позволяющие создать список названий звеньев из словаря. Преобразуйте этот список во множество. Отобразите полученный объект. Добавьте к полученному множеству элемент "гистерезис".
+
+5)	Напишите инструкцию, позволяющую подсчитать число элементов в схеме. Удалите из словаря один из его элементов. Отобразите результат.
+
+## Решение 
+
+1) Для запуска программы, чей исходный код находится в текстовом файле с расширением .txt, можно переименовать расширение файла в .py и запустить
+
+2) 
+```py
+slov = {'инерционное звено1': [5,7,0],'усилительное звено': [8,3,3],'интегрирующее звено': [9,1,4],'дифференцирующее звено': [9,4,5],'пропорциональное звено': [7,2,3],'инерционное звено': [4,6,2]}
+slov
+{'инерционное звено1': [5, 7, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+type(slov)
+<class 'dict'>
+dir(slov)
+['__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']
+```
+
+3)
+```py
+slov['инерционное звено1'][1]*=2
+slov
+{'инерционное звено1': [5, 14, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+```
+
+4)
+```py
+spis = slov.keys()
+spis
+dict_keys(['инерционное звено1', 'усилительное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено', 'инерционное звено'])
+mnoz = set(spis)
+mnoz
+{'инерционное звено1', 'усилительное звено', 'инерционное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено'}
+mnoz.add('гистерезис')
+mnoz
+{'инерционное звено1', 'усилительное звено', 'инерционное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено', 'гистерезис'}
+```
+
+5)
+```py
+slov
+{'инерционное звено1': [5, 14, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+len(slov)
+6
+slov.pop('усилительное звено')
+[8, 3, 3]
+slov
+{'инерционное звено1': [5, 14, 0], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+```

TEMA4/report.md

@@ -0,0 +1,542 @@
+# Отчет по теме 4
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA4")
+```
+
+## 2. Стандартные функции.
+
+## 2.1 Функция round.
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+a = round(123.456,1)
+b = round(123.456,0)
+type(a)
+<class 'float'>
+type(b)
+<class 'float'>
+c = round(123.456)
+c
+123
+type(c)
+<class 'int'>
+```
+
+В первых двух случаях типы получившихся данных - float, когда во втором - int.
+
+## 2.2 Функция range.
+
+```py
+gg = range(76,123,9)
+gg
+range(76, 123, 9)
+list(gg)
+[76, 85, 94, 103, 112, 121]
+range(23)
+range(0, 23)
+d = range(23)
+list(d)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+Диапазон начинается от нуля и заканчивается предыдущим числом заданных 23-х. Шаг - единица.
+
+## 2.3 Функция zip.
+
+```py
+qq = ['Лыкова','Соловьёва','Коваленко','Голощапов']
+ff = zip(gg,qq)
+tuple(ff)
+((76, 'Лыкова'), (85, 'Соловьёва'), (94, 'Коваленко'), (103, 'Голощапов'))
+print(ff[0])
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    print(ff[0])
+TypeError: 'zip' object is not subscriptable
+tt = tuple(ff)
+tt
+((76, 'Лыкова'), (85, 'Соловьёва'), (94, 'Коваленко'), (103, 'Голощапов'))
+print(tt[1])
+(85, 'Соловьёва')
+```
+
+К объекту ff можно обратиться с указанием индекса, преобразовав его в кортеж.
+
+## 2.4 Функция eval.
+
+```py
+fff = float(input('Коэффициент усиления='));dan = eval('5*fff-156')
+Коэффициент усиления=3
+dan
+-141.0
+```
+
+## 2.5 Функция exec.
+
+```py
+exec(input('Введите инструкции:'))
+Введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+
+## 2.6 Функции abs,pow,max,min,sum,dinmod,len,map.
+
+```py
+abs(-5)
+5
+abs(10-15)
+5
+#Возвращает модуль числа
+pow(2,3)
+8
+pow(5,2)
+25
+#Возводит в степень
+chis = [4,5,2,8]
+max(chis)
+8
+min(chis)
+2
+slova = ['Радуга','Яблоко','Ананас','Груша']
+max(slova)
+'Яблоко'
+min(slova)
+'Ананас'
+#Находят максимальное и минимальное значения
+sum(chis)
+19
+sum(chis,10)
+29
+#Находит сумму элементов
+divmod(10,3)
+(3, 1)
+#Находит частное и остаток от деления
+len(chis)
+4
+строка  = 'Hallo!'
+len(строка)
+6
+slov = {'a':10,'b':20,'c':30}
+len(slov)
+3
+#Возвращает количество элементов в объекте
+list(map(str,chis))
+['4', '5', '2', '8']
+list(map(lambda x:x*2,chis))
+[8, 10, 4, 16]
+#Применение функции к каждому элементу последовательности
+```
+
+## 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
+help(math.sin)
+Help on built-in function sin in module math:
+
+sin(x, /)
+    Return the sine of x (measured in radians).
+
+math.sin(1)
+0.8414709848078965
+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.5)
+1.0471975511965979
+help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+math.degrees(45)
+2578.3100780887044
+help(math.radians)
+Help on built-in function radians in module math:
+
+radians(x, /)
+    Convert angle x from degrees to radians.
+
+math.radians(45)
+0.7853981633974483
+help(math.exp)
+Help on built-in function exp in module math:
+
+exp(x, /)
+    Return e raised to the power of x.
+
+math.exp(3)
+20.085536923187668
+help(math.log)
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+
+    If the base is not specified, returns the natural logarithm (base e) of x.
+
+math.log(4,3)
+1.2618595071429148
+help(math.log10)
+Help on built-in function log10 in module math:
+
+log10(x, /)
+    Return the base 10 logarithm of x.
+
+math.log10(3)
+0.47712125471966244
+help(math.sqrt)
+Help on built-in function sqrt in module math:
+
+sqrt(x, /)
+    Return the square root of x.
+
+math.sqrt(5)
+2.23606797749979
+help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+
+    This is the smallest integer >= x.
+
+math.ceil(3.2)
+4
+help(math.floor)
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+
+    This is the largest integer <= x.
+
+math.floor(3.8)
+3
+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()
+help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+random.random()
+0.3783037280071182
+help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = (a + b) / 2
+        Var[X] = (b - a) ** 2 / 12
+
+random.uniform(3,5)
+4.139029942389151
+help(random.randint)
+Help on method randint in module random:
+
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+random.randint(4,88)
+5
+help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu=0.0, sigma=1.0) method of random.Random instance
+    Gaussian distribution.
+
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+
+    Not thread-safe without a lock around calls.
+
+random.gauss()
+0.11579183153210448
+help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+random.choice(qq)
+'Лыкова'
+help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x) method of random.Random instance
+    Shuffle list x in place, and return None.
+
+random.shuffle(qq)
+qq
+['Коваленко', 'Лыкова', 'Соловьёва', 'Голощапов']
+help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence.
+
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  The resulting list is
+    in selection order so that all sub-slices will also be valid random
+    samples.  This allows raffle winners (the sample) to be partitioned
+    into grand prize and second place winners (the subslices).
+
+    Members of the population need not be hashable or unique.  If the
+    population contains repeats, then each occurrence is a possible
+    selection in the sample.
+
+    Repeated elements can be specified one at a time or with the optional
+    counts parameter.  For example:
+
+        sample(['red', 'blue'], counts=[4, 2], k=5)
+
+    is equivalent to:
+
+        sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
+
+    To choose a sample from a range of integers, use range() for the
+    population argument.  This is especially fast and space efficient
+    for sampling from a large population:
+
+        sample(range(10000000), 60)
+
+random.sample(qq,3)
+['Соловьёва', 'Лыкова', 'Голощапов']
+help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha / (alpha + beta)
+        Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
+random.betavariate(2,5)
+0.5473034184133493
+help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+
+    The probability distribution function is:
+
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha * beta
+        Var[X] = alpha * beta ** 2
+
+random.gammavariate(2,5)
+4.616261402628337
+spis = [random.uniform(0,10),random.gauss(50,15),random.betavariate(2,5),random.gammavariate(2,5)]
+spis
+[0.21672125817392973, 25.399177937155795, 0.14356042747670408, 10.552855133080406]
+```
+
+## 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
+c1,c2
+(1761295798.980248, 5.403235197067261)
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=8, tm_min=50, tm_sec=26, tm_wday=4, tm_yday=297, tm_isdst=0)
+dat.tm_mon
+10
+local_time = time.localtime()
+local_time
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=50, tm_sec=50, tm_wday=4, tm_yday=297, tm_isdst=0)
+print(f"Год: {local_time.tm_year}")
+Год: 2025
+c1 = time.time()
+local_struct = time.localtime(c1)
+local_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=54, tm_sec=13, tm_wday=4, tm_yday=297, tm_isdst=0)
+time_str = time.asctime(local_struct)
+time_str
+'Fri Oct 24 11:54:13 2025'
+time_str2 = time.ctime(c1)
+time.sleep(2)
+seconds = time.mktime(local_struct)
+seconds
+1761296053.0
+new_struct = time.localtime(seconds)
+new_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=54, tm_sec=13, tm_wday=4, tm_yday=297, 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 0x000002487CE9E990>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+
+![Ris1](ris1.png)
+
+```py
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002487D263390>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002487D2634D0>]
+pylab.show()
+```
+
+![Ris2](ris2.png)
+
+```py
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002487CE1DFD0>, <matplotlib.patches.Wedge object at 0x000002487D305090>, <matplotlib.patches.Wedge object at 0x000002487D305450>, <matplotlib.patches.Wedge object at 0x000002487D3056D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+
+![Ris3](ris3.png)
+
+```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()
+```
+
+![Ris4](ris4.png)
+
+```py
+c = ['A', 'B', 'C']
+v = [10, 25, 15]
+pylab.bar(c, v)
+<BarContainer object of 3 artists>
+pylab.show()
+```
+
+![Ris5](ris5.png)
+
+
+## 8. Модуль statistics.
+
+```py
+import statistics
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+sred = statistics.mean(data)
+sred
+3
+moda = statistics.mode(data)
+moda
+3
+mediana = statistics.median(data)
+mediana
+3