TEMA2/report.md

TEMA1/lb1.md

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

TEMA1/report.md

@@ -56,107 +56,10 @@ import Pr0.py
 
 ```py
 import prb1
-Как Вас зовут? Evgeny
+Как Вас зовут? Евгений
-Привет, Evgeny
+Привет, Евгений
 ```
-## 12-13. Просмотр каталога _pycache_
+## 12-13. Просмотр pycache
 
-### При открытии файла находящего в каталоге мы наблюдаем следующие кракозябры:
 
-```
-у
-
-    BоєhJ   г                   у&   • \ " S 5
      r
\" S
\
5        g)u   Как Вас Р·РѕРІСѓС‚? u
-   Привет,N)ЪinputЪnameЪprint© у    Ъ1C:\Users/Evgeny/Desktop/python-labs/TEMA1\prb1.pyЪ<module>r   
   s   р


ЩР
-)У*ЂЩ ЂoђtХ r   
-```
-Разберемся что всё это значит:
-Заголовок - BоєhJ   г                   у&   • \ " S 5
      r
\" S
\
5        g)u   Как Вас Р·РѕРІСѓС‚? u
-BоєhJ - идентификатор версии python, далее таймстамп последнего изменения и размер исходного файла
-
-u Как Вас зовут? 
-u Привет, - закодированные строки программы, которые декадируются как "Как Вас зовут?" и "Привет,"
-
-ЪinputЪnameЪprint - имена функций и переменных (input,name, print)
-
-Ъ1C:\Users/Evgeny/Desktop/python-labs/TEMA1\prb1.py - пусть к исходному файлу prb1.py
-
-.рус файлы нужны для экономии времени на компиляцию (при первом запуске питон компилирует код в байт-код для ВМ,
- а при повторном запуске использует готовый байт-файл
-
-## 14. Вызов раздела помощи
-
-```py
-help(print)
-```
-Вывод:
-```
-Help on built-in function print in module builtins:
-
-print(*args, sep=' ', end='\n', file=None, flush=False)
-    Prints the values to a stream, or to sys.stdout by default.
-
-    sep
-      string inserted between values, default a space.
-    end
-      string appended after the last value, default a newline.
-    file
-      a file-like object (stream); defaults to the current sys.stdout.
-    flush
-      whether to forcibly flush the stream.
-```
-```py
-help(print); help(input)
-```
-Вывод:
-```
-Help on built-in function print in module builtins:
-
-print(*args, sep=' ', end='\n', file=None, flush=False)
-    Prints the values to a stream, or to sys.stdout by default.
-
-    sep
-      string inserted between values, default a space.
-    end
-      string appended after the last value, default a newline.
-    file
-      a file-like object (stream); defaults to the current sys.stdout.
-    flush
-      whether to forcibly flush the stream.
-
-Help on built-in function input in module builtins:
-
-input(prompt='', /)
-    Read a string from standard input.  The trailing newline is stripped.
-
-    The prompt string, if given, is printed to standard output without a
-    trailing newline before reading input.
-
-    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
-    On *nix systems, readline is used if available.
-```
-Также были рассмотрены другие способы получения раздела помощи.
-
-## 15. Перемещение между окнами
-
-### 15.1 Открыт prb1.py
-
-### 15.2 Перемещение меж окнами
-
-### 15.3 Запуск программы из окна редактора:
-
-==================== RESTART: C:\Users\Evgeny\Desktop\python-labs\TEMA1\prb1.py ====================
-Как Вас зовут? Evgeny
-Привет, Evgeny
-
-### 15.4 Была запущена программа tdemo_chaos
-
-![](15.4.png)
-
-### 15.5 Рассмотрение примеров использования графической составляющией среды Python
-
-![](15.5.png)
-
-Данные примеры способны помочь в плане структуризации собственного кода и изучении новых команд.
 
-## 16. Выход из среды

TEMA2/report.md

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

TEMA2/task.md

@@ -0,0 +1,46 @@
+# Общее контрольное задание по теме 2
+
+Туровец Евгений, А-02-23
+
+## Задание
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фами-лией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите 
+инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные пере-менные, соответствующие этим типам.
+
+## Решение
+```py
+>>> familia = 'Turovets'
+>>> bukva = familia[0]
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw.remove('nonlocal')
+>>> print(sp_kw)
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> print(sp_kw.count('nonlocal'))
+0
+>>> kort_nam = ('Stas', 'Dana', 'Andrew', 'Zhenya')
+>>> print(type(kort_nam))
+<class 'tuple'>
+>>> kort_nam = kort_nam + ('Katya', 'Ksenia')
+>>> print(kort_nam.count('Dima'))
+0
+>>> key = ['str', 'list', 'tuple']
+>>> value = ['familia', 'sp_kw', 'kort_nam']
+>>> dict_bas = dict(zip(key, value))
+>>> print(dict_bas)
+{'str': 'familia', 'list': 'sp_kw', 'tuple': 'kort_nam'}
+
+```

TEMA2/task.py

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