форкнуто от main/python-labs
Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
936 строки
25 KiB
Markdown
936 строки
25 KiB
Markdown
# Отчет по теме 2
|
|
|
|
Туровец Евгений, А-02-23
|
|
|
|
## 1. Запуск.
|
|
|
|
### 1.1 Запуск оболочки IDLE и установка рабочего каталога.
|
|
|
|
```py
|
|
import os
|
|
os.chdir('C:\Program Files (x86)\учёха 3 курс\pythonsky\python-labs\TEMA2')
|
|
```
|
|
|
|
|
|
|
|
### 1.2 Текстового редактора и его сохранение в рабочий каталог
|
|
|
|
|
|
|
|
В дальнейшем мы будем прописывать инстукции в данный текстовый редактор
|
|
|
|
## 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. Правила именования и сохранение списка под именем:
|
|
|
|
Были введены некоторые предложенные команды, две из которых не соответствовали правилам именования:
|
|
|
|
|
|
|
|
В первом случае получаем ошибку синтаксиса, т.к переменная начинается с цифры,
|
|
а во втором т.к нейминг переменной совпадает с ключевым словом
|
|
|
|
Создадим список и запишем его в переменную a
|
|
|
|
|
|
## 5. Встроенные идентификаторы.
|
|
|
|
### 5.1 Вывод списка встроенных идентификаторов:
|
|
|
|
|
|
|
|
### 5.2 Изучение назначения функций:
|
|
|
|
#### 5.2.1 Функция ABS:
|
|
|
|
|
|
|
|
#### 5.2.2 Функция len:
|
|
|
|
Создадиим последовательность чисел от 0 до 99, чтобы понять функционал len()
|
|
|
|
|
|
|
|
На выводе получаем длину последовательности
|
|
|
|
#### 5.2.3 Функция max,min
|
|
|
|
|
|
|
|
#### 5.2.4 Функция pow
|
|
|
|
|
|
|
|
#### 5.2.5 Функция round
|
|
|
|
|
|
|
|
#### 5.2.6 Функция sorted
|
|
|
|
|
|
|
|
#### 5.2.7 Функция sum
|
|
|
|
|
|
|
|
#### 5.2.8 Функция zip
|
|
|
|
|
|
|
|
Функция zip() объединяет несколько интегрируемых объектов в кортежи,
|
|
но т.к функция возвращает итератор, то чтобы увидеть результат - нужно перобразовать его в список
|
|
|
|
## 6. Типы объектов.
|
|
|
|
|
|
|
|
## 7. Изучение базовых типов объектов:
|
|
|
|
int — целые числа (положительные, отрицательные или нуль).
|
|
float — числа с плавающей точкой (дробные числа).
|
|
complex — комплексные числа (имеют действительную и мнимую части).
|
|
str — строковый тип данных для хранения текстовой информации. Строка может содержать буквы, цифры, пробелы, символы.
|
|
bool в Python — это логический тип, принимать только два значения: True и False.
|
|
|
|
### 7.1 Логический тип:
|
|
|
|
|
|
|
|
### 7.2 Иные простые типы:
|
|
|
|
|
|
|
|
### 7.3 Строка символов:
|
|
|
|
Одинарные и двойные ковычки несут один и тот же смысл
|
|
|
|
Чтобы изменить вывод теста можно использовать "экранированные последовательности"
|
|
|
|
|
|
|
|
#### Создадим строку по шаблону:
|
|
|
|
```py
|
|
ss1b= 'Меня зовут: \n Туровец Е.Ю'
|
|
print(ss1b)
|
|
```
|
|
Вывод:
|
|
|
|
```
|
|
Меня зовут:
|
|
Туровец Е.Ю
|
|
```
|
|
#### Создадим строку со значением объекта при помощи тройных кавычек:
|
|
|
|
|
|
|
|
При выводе такой строки не будет появлятьс символ приглашения - >>> , до следующего вводв тройных кавычек.
|
|
|
|
#### К элементам строки можно обращаться используя индексацию:
|
|
|
|
|
|
|
|
Можно также делать срезы текста
|
|
|
|
|
|
|
|
|
|
|
|
В данном случае 17 можно заменить на -4, т.к это тот же элемент, если считать с конца
|
|
|
|
|
|
|
|
В таком случае мы переопределяем элемент по индексом 4
|
|
|
|
Сделаем срез текста присвоенного переменной ss1b:
|
|
|
|
|
|
|
|
## 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 Список
|
|
|
|
Список может состоять из элемнтов различных типов:
|
|
|
|
|
|
|
|
Список можно вводить на разных строках, т.к вывод не закончится,
|
|
пока не будет введена закрывающая скобка
|
|
|
|
|
|
|
|
С элементами списка можно так же работать используя индексацию.
|
|
|
|
```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
|
|
|
|
|
|
Создадим собственный словарь:
|
|
```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()
|
|
```
|
|
|
|
|