python-labs/TEMA2/report.md

Отчет по теме 2

Туровец Евгений, А-02-23

1. Запуск.

1.1 Запуск оболочки IDLE и установка рабочего каталога.

import os
os.chdir('C:\Program Files (x86)\учёха 3 курс\pythonsky\python-labs\TEMA2')

1.2 Текстового редактора и его сохранение в рабочий каталог

В дальнейшем мы будем прописывать инстукции в данный текстовый редактор

2. Изучение простых объектов.

2.1 Операции присваивания

познакомимся с операциями присваивания и выводом их значений

f1=16; f2=3
f1,f2

Вывод:

(16, 3)

f1;f2

Вывод:

16
3

2.2 Функция dir()

Познакомимся с функцией dir(), которая выводит объекты, уже существующие в среде питона

dir()

Вывод:

['__annotations__', '__builtins__', '__doc__', '__file__',
 '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']

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()

type(f1)

Вывод:

<class 'int'>

2.4 Функция del()

Удалим переменные f1, f2:

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 Строка символов:

Одинарные и двойные ковычки несут один и тот же смысл

Чтобы изменить вывод теста можно использовать "экранированные последовательности"

Создадим строку по шаблону:

ss1b= 'Меня зовут: \n Туровец Е.Ю'
print(ss1b)

Вывод:

Меня зовут: 
 Туровец Е.Ю

Создадим строку со значением объекта при помощи тройных кавычек:

При выводе такой строки не будет появлятьс символ приглашения - >>> , до следующего вводв тройных кавычек.

К элементам строки можно обращаться используя индексацию:

Можно также делать срезы текста

В данном случае 17 можно заменить на -4, т.к это тот же элемент, если считать с конца

В таком случае мы переопределяем элемент по индексом 4

Сделаем срез текста присвоенного переменной ss1b:

8. Списки, кортежи, словари и множества.

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

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.

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 Список

Список может состоять из элемнтов различных типов:

Список можно вводить на разных строках, т.к вывод не закончится, пока не будет введена закрывающая скобка

С элементами списка можно так же работать используя индексацию.

stup=[0,0,1,1,1,1,1,1,1]
stup[-8::2]

Вывод:

[0, 1, 1, 1]

элемент под индексом -8 = элементу до индексом 1. Срез происходит до последнего элемента с шагом 2, т.к не задан конечный элемент.

spis1[1]='Список'
spis1

Вывод:

[111, 'Список', (5-9j)]

Также можно узнать число элементов в списке с помощью функции len():

len(spis1)

Вывод:

3

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 - удалить

spis1.append('New item')  # В конец списка добавлен элемент «New item»
spis1

Вывод:

[111, 'Список', (5-9j), 'New item']

Как мы видим в конец списка добавлен новый элемент

spis1.append(ss1b)
spis1

Вывод:

[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']

Изучим такие функции как: insert, remove, extend, clear, sort, reverse, copy, count, index

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

Списки также могут быть вложенными:

spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
spis2[0][1]  #обращение к элементу списка spis1
'Список'
spis2[0][1]=78  #Убедитесь, что значение элемента заменено на 78
spis2[0][1]
78

spis1

Вывод:

[1, 78, 3, 5, 6, 7, 9]

был видоизменен, ведь является элементом другого списка, к которому мы обратились и изменили соответственно

Был придуман список, содержащий в себе 4 элемента разных типов: число, строка, логическое значение и список

list=[10,'Евгений',True,['a','b']]
list

Вывод:

[10, 'Евгений', True, ['a', 'b']]

8.2 Кортеж.

*Похож на список, но изменить его нельзя

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

Получаем ошибку

Кортеж нельзя изменить, но можно переопределить

kort1= kort1+(1,2)
kort1

Вывод:

(222, 'Kortezh', (77+8j), 1, 2)

Добавим ещё один элемент:

kort1= kort1+(ss1b,)
kort1

Вывод:

(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Туровец Е.Ю')

Удаление элементов из кортежа можно делать путем переопределения срезом:

kort2=kort1[:2]+kort1[3:]
kort2

Вывод:

(222, 'Kortezh', 1, 2, 'Меня зовут: \n Туровец Е.Ю')

.index и .count в кортежах работают так же как и в списках

Методов append и pop у кортежей нет, т.к. они являются неизменяемыми

Создадим собственный кортеж и элементами различных типов:

korte=(10,'stroka',[10,'a'],(50,'b'))
korte

Вывод:

(10, 'stroka', [10, 'a'], (50, 'b'))

8.3 Словарь

Словарь является совокупностью пар типа 'key:value'

Создадим словарь:

dic1={'Saratov':145, 'Orel':56, 'Vologda':45}

При обращении к ключу Orel получим:

dic1['Orel']

Вывод:

56

Пополнение словаря:

dic1['Pskov']=78
dic1

Вывод:

dic1['Pskov']=78
dic1

Словарь можно отсортировать по ключам или значениям:

sorted(dic1.keys())
['Orel', 'Pskov', 'Saratov', 'Vologda']
sorted(dic1.values())
[45, 56, 78, 145]

Также можно создавать вложенные словари:

dic2={1:'mean',2:'standart deviation',3:'correlation'}
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
dic3['statistics'][2]

Вывод:

'standart deviation'

Более сложные словари с помощью функций dist и zip

Создадим собственный словарь:

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}

len(ob)

Вывод:

5

Элементов 5, т.к команда zip работала столько раз, сколько элементов в наиболее маленьком объекте

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 Множество

В множестве могут быть разные типы, но только неизменяемые и неповторяющиеся:

mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
mnoz1

Вывод:

{'линия связи', 'датчик', 'двигатель', 'микропроцессор'}

Как мы видим дубли были удалены

Выведем число элементов в множестве:

len(mnoz1)
4

Проверка наличия элемента во множестве:

'датчик' in mnoz1
True

Добавление элемента:

mnoz1.add('реле')
mnoz1
{'линия связи', 'датчик', 'реле', 'микропроцессор', 'двигатель'}

Удаление элемента:

mnoz1.remove('линия связи')
mnoz1
{'датчик', 'реле', 'микропроцессор', 'двигатель'}

Было создано множество:

mnoz1 = {'лев', '1', True, ('тигр', 1, 3)}
mnoz1
{('тигр', 1, 3), True, 'лев', '1'}
mnoz1.remove(True)
mnoz1
{('тигр', 1, 3), 'лев', '1'}
mnoz1.add('осёл')
mnoz1
{('тигр', 1, 3), 'лев', '1', 'осёл'}

9.

exit()