Сравнить коммиты
10 Коммитов
| Автор | SHA1 | Дата |
|---|---|---|
 DeviatovaMY
|
bbaa758337 | 5 дней назад |
|
DeviatovaMY
|
f4c861af6f | 5 дней назад |
|
DeviatovaMY
|
4eb98639ba | 5 дней назад |
|
DeviatovaMY
|
58d8da35c7 | 3 недель назад |
|
DeviatovaMY
|
948f2c5176 | 3 недель назад |
|
DeviatovaMY
|
b543adbed1 | 1 месяц назад |
|
DeviatovaMY
|
caa40a0ceb | 1 месяц назад |
|
DeviatovaMY
|
754fea8b03 | 2 месяцев назад |
|
DeviatovaMY
|
c9c1024c18 | 2 месяцев назад |
|
DeviatovaMY
|
04d815ce6d | 2 месяцев назад |
@ -0,0 +1,6 @@
|
||||
# Программа по Теме 1 Девятова МЕ
|
||||
|
||||
print('Hello')
|
||||
h=input('Your name=')
|
||||
import os
|
||||
os.chdir('C:\\Users\\u207-05\\Desktop\\ПОАС\\python-labs\\TEMA1\\')
|
||||
|
После Ширина: | Высота: | Размер: 32 KiB |
|
После Ширина: | Высота: | Размер: 16 KiB |
|
После Ширина: | Высота: | Размер: 24 KiB |
|
После Ширина: | Высота: | Размер: 6.0 KiB |
|
После Ширина: | Высота: | Размер: 48 KiB |
|
После Ширина: | Высота: | Размер: 52 KiB |
@ -0,0 +1,104 @@
|
||||
# Отчет по теме 1
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Знакомство с интерпретатором и интерактивной оболочкой IDLE
|
||||
|
||||
## 1.1 Настройка текущего каталога и окна IDLE
|
||||
|
||||
```
|
||||
import os
|
||||
os.chdir('C:\\Users\\u207-05\\Desktop\\ПОАС\\python-labs\\TEMA1\\')
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 1.2 Запуск программы в командном окне
|
||||
|
||||
Был создан файл Pr0.py, в командном окне IDLE был запущен на выполнение + файл prb1.py, данный изначально.
|
||||
Результаты выполнения:
|
||||
|
||||
```
|
||||
import Pr0
|
||||
Hello
|
||||
Your name=Maria
|
||||
import prb1
|
||||
Как Вас зовут? Maria
|
||||
Привет, Maria
|
||||
```
|
||||
|
||||
## 1.3 Содержимое файла в папке pycache
|
||||
|
||||
После запуска Pr0.py в рабочем каталоге появилась папка pycache, в которой расположен файл Pr0.cpython-311.pyc
|
||||
Данный файл содержит байт-код для исходного Pr0.py, который интерпретируется виртуальной машиной Python.
|
||||
Фрагмент файла, открытый в текстовом редакторе, приведен ниже:
|
||||
|
||||
|
||||
|
||||
## 1.4 Изучение раздела help
|
||||
|
||||
Было выполнено обращение к помощи по функции print(), затем по функциям print(), input()
|
||||
|
||||
```
|
||||
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.
|
||||
```
|
||||
|
||||
## 1.5 Выполнение пункта 15
|
||||
|
||||
```
|
||||
======= RESTART: C:\Users\u207-05\Desktop\ПОАС\python-labs\TEMA1\prb1.py =======
|
||||
Как Вас зовут? Maria
|
||||
Привет, Maria
|
||||
```
|
||||
```
|
||||
import tdemo_chaos
|
||||
```
|
||||
|
||||
|
||||
|
||||
Через раздел помощи Help был запущен пример clock, результат ниже:
|
||||
|
||||
|
||||
@ -0,0 +1,819 @@
|
||||
# Отчет по теме 2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск оболочки IDLE, подготовка к работе
|
||||
|
||||
Был запущен IDLE Python 3.11, установлен текущий каталог:
|
||||
|
||||
```
|
||||
import os
|
||||
os.chdir('C:\\Users\\ASUS X507UF\\Desktop\\поас\\python-labs\\TEMA2\\')
|
||||
```
|
||||
|
||||
## 2 Изучение простых объектов
|
||||
|
||||
Были созданы две переменные со значениями 16 и 3
|
||||
|
||||
```
|
||||
f1=16; f2=3
|
||||
```
|
||||
|
||||
Чтобы узнать значения нескольких переменных, достаточно перечислить имена переменных через запятую или точку с запятой.
|
||||
|
||||
```
|
||||
f1,f2
|
||||
(16, 3)
|
||||
f1;f2
|
||||
16
|
||||
3
|
||||
```
|
||||
|
||||
Использование функции dir() без аргументов позволяет узнать, какие объекты в данный момент cуществуют в среде Python.
|
||||
|
||||
```
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__',
|
||||
'__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
|
||||
```
|
||||
|
||||
Если эту же функцию использовать с именем объекта в качестве аргумента (например, f1), то будет выведен список атрибутов этого объекта.
|
||||
|
||||
```
|
||||
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', 'numerator', 'real', 'to_bytes']
|
||||
```
|
||||
|
||||
Классовую принадлежность объекта можно определить с помощью функции type(). Объект f2 принадлежит к целочисленному типу данных.
|
||||
|
||||
```
|
||||
type(f2)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
Было произведено удаление ранее созданных объектов f1 и f2, а также проверено с функцией dir().
|
||||
Объекты действительно были удалены из оперативной памяти.
|
||||
|
||||
```
|
||||
del f1,f2
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__',
|
||||
'__name__', '__package__', '__spec__', 'os']
|
||||
```
|
||||
|
||||
## 3 Правила именования объектов
|
||||
|
||||
При именовании объектов в Python необходимо руководствоваться следующими правилами:
|
||||
1) имена должны состоять из латинских букв, цифр и символов подчеркивания;
|
||||
2) имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
|
||||
3) заглавные и строчные буквы в именах различаются (чувствительность к регистру);
|
||||
4) имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python.
|
||||
Были выполнены следующие операции:
|
||||
|
||||
```
|
||||
gg1=1.6
|
||||
gg1
|
||||
1.6
|
||||
hh1='Строка'
|
||||
hh1
|
||||
'Строка'
|
||||
73sr=3
|
||||
SyntaxError: invalid decimal literal
|
||||
and=7
|
||||
SyntaxError: invalid syntax
|
||||
```
|
||||
|
||||
Ошибки были выведены при создании переменной с цифрой в начале имени и с именем, совпадающим с ключевым словом.
|
||||
Остальные переменные получили введенное значение.
|
||||
|
||||
## 4 Вывод списка ключевых слов
|
||||
|
||||
Был выведен список ключевых слов.
|
||||
|
||||
```
|
||||
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']
|
||||
```
|
||||
|
||||
Данный список был сохранен в переменной с именем kw.
|
||||
|
||||
```
|
||||
kw = keyword.kwlist
|
||||
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']
|
||||
```
|
||||
|
||||
## 5 Список встроенных идентификаторов и изучение некоторых функций
|
||||
|
||||
Был выведен список встроенных идентификаторов.
|
||||
|
||||
```
|
||||
import builtins
|
||||
dir(builtins)
|
||||
['ArithmeticError', 'AssertionError', 'AttributeError',
|
||||
'BaseException', 'BaseExceptionGroup', 'BlockingIOError',
|
||||
'BrokenPipeError', 'BufferError', 'BytesWarning',
|
||||
'ChildProcessError', 'ConnectionAbortedError',
|
||||
'ConnectionError', 'ConnectionRefusedError',
|
||||
'ConnectionResetError', 'DeprecationWarning',
|
||||
'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError',
|
||||
'Exception', 'ExceptionGroup', 'False', 'FileExistsError',
|
||||
'FileNotFoundError', 'FloatingPointError', 'FutureWarning',
|
||||
'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning',
|
||||
'IndentationError', 'IndexError', 'InterruptedError',
|
||||
'IsADirectoryError', 'KeyError', 'KeyboardInterrupt',
|
||||
'LookupError', 'MemoryError', 'ModuleNotFoundError',
|
||||
'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
|
||||
'NotImplementedError', 'OSError', 'OverflowError',
|
||||
'PendingDeprecationWarning', 'PermissionError',
|
||||
'ProcessLookupError', 'RecursionError', 'ReferenceError',
|
||||
'ResourceWarning', 'RuntimeError', 'RuntimeWarning',
|
||||
'StopAsyncIteration', 'StopIteration', 'SyntaxError',
|
||||
'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError',
|
||||
'TimeoutError', 'True', 'TypeError', 'UnboundLocalError',
|
||||
'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError',
|
||||
'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
|
||||
'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError',
|
||||
'_', '__build_class__', '__debug__', '__doc__', '__import__',
|
||||
'__loader__', '__name__', '__package__', '__spec__', 'abs',
|
||||
'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool',
|
||||
'breakpoint', 'bytearray', 'bytes', 'callable', 'chr',
|
||||
'classmethod', 'compile', 'complex', 'copyright', 'credits',
|
||||
'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval',
|
||||
'exec', 'exit', 'filter', 'float', 'format', 'frozenset',
|
||||
'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
|
||||
'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
|
||||
'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',
|
||||
'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',
|
||||
'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set',
|
||||
'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum',
|
||||
'super', 'tuple', 'type', 'vars', 'zip']
|
||||
```
|
||||
|
||||
Можно отметить, что в нем присутствуют уже использованные функции type() и dir().
|
||||
Было изучено назначение функций: abs, len, max, min, pow, round, sorted, sum, zip.
|
||||
abs - модуль объекта.
|
||||
|
||||
```
|
||||
abs(-20)
|
||||
20
|
||||
```
|
||||
|
||||
len - длина объекта.
|
||||
|
||||
```
|
||||
len([1, 3, 5, 7, 9, 11])
|
||||
6
|
||||
```
|
||||
|
||||
max/min - максимум/минимум объекта.
|
||||
|
||||
```
|
||||
max(0, -50, 23)
|
||||
23
|
||||
min(0, -50, 23)
|
||||
-50
|
||||
```
|
||||
|
||||
pow - возведение в степень.
|
||||
|
||||
```
|
||||
pow(3, 2)
|
||||
9
|
||||
```
|
||||
|
||||
round - округление (в кач-ве второго аргумента - кол-во знаков после запятой, по умолчанию none, т.е. округление до целого).
|
||||
|
||||
```
|
||||
round(5.5276)
|
||||
6
|
||||
round(5.5276, 3)
|
||||
5.528
|
||||
```
|
||||
|
||||
sorted - сортировка элементов в объекте (по умолчанию - по возрастанию, при reverse=True - по убыванию).
|
||||
|
||||
```
|
||||
sorted([2, -7, 4, 0])
|
||||
[-7, 0, 2, 4]
|
||||
sorted([2, -7, 4, 0], reverse=True)
|
||||
[4, 2, 0, -7]
|
||||
```
|
||||
|
||||
sum - сумма элементов (в кач-ве второго аргумента - начальное значение, по умолчанию 0).
|
||||
|
||||
```
|
||||
sum([1, 4, 7])
|
||||
12
|
||||
sum([1, 4, 7], 5)
|
||||
17
|
||||
```
|
||||
|
||||
zip - поэлементное объединение объектов в набор кортежей, при разной длине объектов функция создает кортежи до длины самого короткого объекта.
|
||||
|
||||
```
|
||||
list(zip('efghi', [2, 6, 3], [7, 9, 0, 0]))
|
||||
[('e', 2, 7), ('f', 6, 9), ('g', 3, 0)]
|
||||
```
|
||||
|
||||
## 6 Проверка на чувствительность к регистру
|
||||
|
||||
Была создана переменная Gg1 с присвоенным значением, отличным от присвоенного ранее объекту gg1. Проверка показала, что gg1 и Gg1 - разные объекты, т.е. Python чувствителен к регистру.
|
||||
|
||||
```
|
||||
Gg1=45
|
||||
gg1; Gg1
|
||||
1.6
|
||||
45
|
||||
```
|
||||
|
||||
## 7 Простые базовые типы объектов
|
||||
|
||||
### 7.1 Логический тип
|
||||
|
||||
```
|
||||
bb1=True; bb2=False
|
||||
bb1; bb2
|
||||
True
|
||||
False
|
||||
type(bb1)
|
||||
<class 'bool'>
|
||||
```
|
||||
|
||||
### 7.2 Другие простые типы
|
||||
|
||||
ii1 - целое число, десятичное
|
||||
|
||||
```
|
||||
ii1=-1234567890
|
||||
type(ii1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
ff1 - экспоненциальная форма записи вещественного числа
|
||||
|
||||
```
|
||||
ff1=-8.9876e-12
|
||||
type(ff1)
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
dv1 - двоичное число
|
||||
|
||||
```
|
||||
dv1=0b1101010
|
||||
type(dv1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
vsm1 - восьмеричное число
|
||||
|
||||
```
|
||||
vsm1=0o52765
|
||||
type(vsm1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
shest1 - шестнадцатеричное число
|
||||
|
||||
```
|
||||
shest1=0x7109af6
|
||||
type(shest1)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
cc1 и cc2 - комплексные числа
|
||||
|
||||
```
|
||||
cc1=2-3j
|
||||
type(cc1)
|
||||
<class 'complex'>
|
||||
a=3.67; b=-0.45
|
||||
cc2=complex(a,b)
|
||||
cc2
|
||||
(3.67-0.45j)
|
||||
```
|
||||
|
||||
### 7.3 Строка символов
|
||||
|
||||
Была двумя способами создана строка - с использованием одинарных и двойных кавычек. Оба способа дают идентичный результат (но важно, чтобы открывающие и закрывающие кавычки были одинаковыми).
|
||||
|
||||
```
|
||||
ss1='Это - строка символов'
|
||||
ss1
|
||||
'Это - строка символов'
|
||||
ss1="Это - строка символов"
|
||||
ss1
|
||||
'Это - строка символов'
|
||||
```
|
||||
|
||||
Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.
|
||||
|
||||
```
|
||||
ss1a="Это - \" строка символов \", \n \t выводимая на
|
||||
двух строках"
|
||||
print(ss1a)
|
||||
Это - " строка символов ",
|
||||
выводимая на двух строках
|
||||
```
|
||||
```
|
||||
ss1b= 'Меня зовут: \n Девятова М.Е.'
|
||||
print(ss1b)
|
||||
Меня зовут:
|
||||
Девятова М.Е.
|
||||
```
|
||||
|
||||
Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.
|
||||
|
||||
```
|
||||
mnogo="""Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции."""
|
||||
print(mnogo)
|
||||
Нетрудно заметить , что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвуют в операции.
|
||||
```
|
||||
|
||||
Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. Нумерация начинается с 0. При знаке минус отсчет идет от конца строки.
|
||||
|
||||
```
|
||||
ss1[0]
|
||||
'Э'
|
||||
ss1[8]
|
||||
'р'
|
||||
ss1[-2]
|
||||
'о'
|
||||
```
|
||||
|
||||
Операция создания "среза".
|
||||
С 6-го индекса по 8-й, 9-й не включая.
|
||||
C 13-го индекса и до конца.
|
||||
С начала и до 12-го индекса включительно.
|
||||
C 5-го индекса и до 8-го с конца
|
||||
С 3-го по 16-й с шагом 2
|
||||
|
||||
```
|
||||
ss1[6:9]
|
||||
'стр'
|
||||
ss1[13:]
|
||||
'символов'
|
||||
ss1[:13]
|
||||
'Это - строка '
|
||||
ss1[5:-8]
|
||||
' строка '
|
||||
ss1[3:17:2]
|
||||
' тоасм'
|
||||
```
|
||||
|
||||
При отрицательном значении шага. Если 17 заменить на -4, то результат будет тот же.
|
||||
|
||||
```
|
||||
ss1[17:3:-2]
|
||||
'омсаот '
|
||||
ss1[-4:3:-2]
|
||||
'омсаот '
|
||||
```
|
||||
|
||||
Строка является неизменяемым объектом.
|
||||
|
||||
```
|
||||
ss1[4]='='
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#89>", line 1, in <module>
|
||||
ss1[4]='='
|
||||
TypeError: 'str' object does not support item assignment
|
||||
```
|
||||
|
||||
Выход из положения - переопределение строки с ипользованием срезов.
|
||||
|
||||
```
|
||||
ss1=ss1[:4]+'='+ss1[5:]
|
||||
ss1
|
||||
'Это = строка символов'
|
||||
```
|
||||
|
||||
С использованием ранее созданной строки ss1b были созданы объекты с разными срезами.
|
||||
|
||||
```
|
||||
ss1b[1::3]
|
||||
'е в: во Е'
|
||||
ss1b[0]
|
||||
'М'
|
||||
ss1b[12]
|
||||
'\n'
|
||||
ss1b[5:10]
|
||||
'зовут'
|
||||
ss1b[14:-8]
|
||||
'Девят'
|
||||
ss1b[-8:14:-2]
|
||||
'ояе'
|
||||
```
|
||||
|
||||
Были созданы объекты разных типов с отображением их типов.
|
||||
|
||||
```
|
||||
obj1=9.87609
|
||||
type(obj1)
|
||||
<class 'float'>
|
||||
obj2=654
|
||||
type(obj2)
|
||||
<class 'int'>
|
||||
obj3=8+5j
|
||||
type(obj3)
|
||||
<class 'complex'>
|
||||
obj4='о'
|
||||
type(obj4)
|
||||
<class 'str'>
|
||||
obj7="""две
|
||||
строки"""
|
||||
type(obj7)
|
||||
<class 'str'>
|
||||
```
|
||||
|
||||
## 8 Списки, кортежи, словари, множества
|
||||
|
||||
### 8.1 Списки
|
||||
|
||||
Список – это упорядоченная последовательность объектов произвольных типов, список является изменяемым объектом.
|
||||
Был создан список с 3 элементами разных типов.
|
||||
|
||||
```
|
||||
spis1=[111,'Spisok',5-9j]
|
||||
spis1
|
||||
[111, 'Spisok', (5-9j)]
|
||||
type(spis1)
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
Еще пример: список, содержащий последовательность отсчетов сигнала в виде "единичной ступеньки".
|
||||
|
||||
```
|
||||
stup=[0,0,1,1,1,1,1,1,1]
|
||||
stup
|
||||
[0, 0, 1, 1, 1, 1, 1, 1, 1]
|
||||
type(stup)
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
Список можно вводить на нескольких строках, для завершения ввода должна быть введена закрывающая квадратная скобка.
|
||||
|
||||
```
|
||||
spis=[1,2,3,4,
|
||||
5,6,7,
|
||||
8,9,10]
|
||||
spis
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
```
|
||||
|
||||
При работе с элементами списка можно использовать индексы точно так же, как это производилось с элементами символьной строки.
|
||||
|
||||
```
|
||||
spis1[-1]
|
||||
(5-9j)
|
||||
stup[-8::2]
|
||||
[0, 1, 1, 1]
|
||||
```
|
||||
|
||||
Список - изменяемый объект, поэтому его элементам можно присваивать новые значения.
|
||||
|
||||
```
|
||||
spis1[1]='Список'
|
||||
spis1
|
||||
[111, 'Список', (5-9j)]
|
||||
```
|
||||
|
||||
Функция len() отображает кол-во элементов в списке.
|
||||
|
||||
```
|
||||
len(spis1)
|
||||
3
|
||||
```
|
||||
|
||||
Был выведен список атрибутов списка и с помощью функции help() - описание одного из методов.
|
||||
|
||||
```
|
||||
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
|
||||
[111, 'Список', (5-9j), 'New item']
|
||||
```
|
||||
|
||||
```
|
||||
spis1.append(ss1b)
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.']
|
||||
```
|
||||
|
||||
Из списка был удален элемент с индексом 1.
|
||||
|
||||
```
|
||||
spis1.pop(1)
|
||||
'Список'
|
||||
spis1
|
||||
[111, (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.']
|
||||
```
|
||||
|
||||
Также были изучены еще некоторые методы.
|
||||
insert вставляет элемент (второй аргумент функции) по номеру индекса (первый аргумент функции).
|
||||
|
||||
```
|
||||
sss=[1, 3, 'Hello', 47+9j, 1, 666]
|
||||
sss
|
||||
[1, 3, 'Hello', (47+9j), 1, 666]
|
||||
sss.insert(2, ')')
|
||||
sss
|
||||
[1, 3, ')', 'Hello', (47+9j), 1, 666]
|
||||
```
|
||||
|
||||
remove удаляет первый элемент со значением, указанным в кач-ве аргумента. В примере элементы с индексами 0 и 5 имеют значение 1, но функция удалила только элемент с индексом 0.
|
||||
|
||||
```
|
||||
sss.remove(1)
|
||||
sss
|
||||
[3, ')', 'Hello', (47+9j), 1, 666]
|
||||
```
|
||||
|
||||
extend принимает объект в кач-ве аргумента и добавляет его в конец списка.
|
||||
В сравнении с append данная функция может распаковывать сложные типы как список и добавлять его поэлементно, в то время как append добавляет список как один объект.
|
||||
|
||||
```
|
||||
sss.extend([1, 2, 3, 'X'])
|
||||
sss
|
||||
[3, ')', 'Hello', (47+9j), 1, 666, 1, 2, 3, 'X']
|
||||
sss.append([1, 2, 3, 'X'])
|
||||
sss
|
||||
[3, ')', 'Hello', (47+9j), 1, 666, 1, 2, 3, 'X', [1, 2, 3, 'X']]
|
||||
```
|
||||
|
||||
sort - сортировка элементов, по умолчанию - по возрастанию.
|
||||
|
||||
```
|
||||
sss1=[1, -5, 9, 0, -43]
|
||||
sss1.sort()
|
||||
sss1
|
||||
[-43, -5, 0, 1, 9]
|
||||
```
|
||||
|
||||
reverse - обратный порядок элементов.
|
||||
|
||||
```
|
||||
sss.reverse()
|
||||
sss
|
||||
[[1, 2, 3, 'X'], 'X', 3, 2, 1, 666, 1, (47+9j), 'Hello', ')', 3]
|
||||
```
|
||||
|
||||
copy - создание копии списка.
|
||||
|
||||
```
|
||||
s00=sss.copy()
|
||||
s00
|
||||
[[1, 2, 3, 'X'], 'X', 3, 2, 1, 666, 1, (47+9j), 'Hello', ')', 3]
|
||||
```
|
||||
|
||||
count - счетчик элементов по значению.
|
||||
|
||||
```
|
||||
sss.count(1)
|
||||
2
|
||||
sss.count(9)
|
||||
0
|
||||
```
|
||||
|
||||
index - индекс первого элемента с заданным в аргументе значением.
|
||||
|
||||
```
|
||||
sss.index(1)
|
||||
4
|
||||
```
|
||||
|
||||
clear - полное очищение списка
|
||||
|
||||
```
|
||||
sss.clear()
|
||||
sss
|
||||
[]
|
||||
```
|
||||
|
||||
Списки могут быть вложенными.
|
||||
Пример обращения к элементу вложенного списка. При изменении элемента вложенного списка, сам spis1 изменяется, потому что при создании spis2 использовалась не копия spis1, а ссылка на него.
|
||||
|
||||
```
|
||||
spis2=[spis1,[4,5,6,7]]
|
||||
spis2
|
||||
[[111, (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.'], [4, 5, 6, 7]]
|
||||
spis2[0][1]
|
||||
(5-9j)
|
||||
spis2[0][1]=78
|
||||
spis2[0][1]
|
||||
78
|
||||
spis1
|
||||
[111, 78, 'New item', 'Меня зовут: \n Девятова М.Е.']
|
||||
```
|
||||
|
||||
Объект-список, элементами которого объекты разных типов: число, строка, логическое значение, список
|
||||
|
||||
```
|
||||
myspis=[gg1, ss1, bb2, sss]
|
||||
myspis
|
||||
[1.6, 'Это = строка символов', False, []]
|
||||
type(myspis[0])
|
||||
<class 'float'>
|
||||
type(myspis[1])
|
||||
<class 'str'>
|
||||
type(myspis[2])
|
||||
<class 'bool'>
|
||||
type(myspis[3])
|
||||
<class 'list'>
|
||||
```
|
||||
|
||||
### 8.2 Кортежи
|
||||
|
||||
Объект-кортеж похож на список, но является неизменяемым, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки.
|
||||
Создание кортежа. Вместо изменения кортежа - его переопределение.
|
||||
|
||||
```
|
||||
kort1=(222,'Kortezh',77+8j)
|
||||
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 Девятова М.Е.')
|
||||
```
|
||||
|
||||
Два метода кортежа, одинаковых со списком.
|
||||
|
||||
```
|
||||
kort1.index(2)
|
||||
4
|
||||
kort1.count(222)
|
||||
1
|
||||
```
|
||||
|
||||
Была произведена попытка заменить элемент кортежа, но результат - сообщение о невозможности изменения кортежа.
|
||||
|
||||
```
|
||||
kort1[2]=90
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#241>", line 1, in <module>
|
||||
kort1[2]=90
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
```
|
||||
|
||||
Был создан объект-кортеж с элементами разных типов: число, строка, список, кортеж.
|
||||
|
||||
```
|
||||
mykort=(a, ss1, spis1, kort2)
|
||||
mykort
|
||||
(3.67, 'Это = строка символов', [111, 78, 'New item', 'Меня зовут: \n Девятова М.Е.'], (222, 'Kortezh', 1, 2, 'Меня зовут: \n Девятова М.Е.'))
|
||||
type(mykort)
|
||||
<class 'tuple'>
|
||||
type(mykort[0])
|
||||
<class 'float'>
|
||||
type(mykort[1])
|
||||
<class 'str'>
|
||||
type(mykort[2])
|
||||
<class 'list'>
|
||||
type(mykort[3])
|
||||
<class 'tuple'>
|
||||
```
|
||||
|
||||
### 8.3 Словари
|
||||
|
||||
Словарь - неупорядоченная совокупность элементов. Содержанием словаря является совокупность пар: "ключ (key)":"значение (value)".
|
||||
В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа.
|
||||
Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению.
|
||||
Был создан словарь. Обращение к элементам производилось не по индексам, а по ключам.
|
||||
Был добавлен элемент в словарь. Из-за неупорядоченности словарей элементы при выводе могут располагаться не в том порядке, что и при формировании словаря.
|
||||
|
||||
```
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
|
||||
dic1['Orel']
|
||||
56
|
||||
dic1['Pskov']=78
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
|
||||
```
|
||||
|
||||
С использованием методов keys, values, создающие списки ключей и значений, и функции sorted можно сформировать списки упорядоченных ключей и значений словаря.
|
||||
|
||||
```
|
||||
sorted(dic1.keys())
|
||||
['Orel', 'Pskov', 'Saratov', 'Vologda']
|
||||
sorted(dic1.values())
|
||||
[45, 56, 78, 145]
|
||||
```
|
||||
|
||||
Элементы словаря могут быть любого типа.
|
||||
Были рассмотрены разные способы создания словаря, а также обращение к элементу вложенного словаря.
|
||||
При создании словаря с использованием zip необходимо помнить, что при разных длинах объектов функция объединяет элементы до длины самого короткого объекта (пример: dic555)
|
||||
|
||||
```
|
||||
dic2={1:'mean',2:'standart deviation',3:'correlation'}
|
||||
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
|
||||
dic3['statistics'][2]
|
||||
'standart deviation'
|
||||
dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
|
||||
dic4
|
||||
{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Девятова М.Е.'}
|
||||
dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
|
||||
dic5
|
||||
{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Девятова М.Е.'}
|
||||
dic555=dict(zip(('1', '2', '3', '4', '5', '6', '7'), ['one', 'two', 'three', 'four', 'five']))
|
||||
dic555
|
||||
{'1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five'}
|
||||
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
|
||||
{'микропроцессор', 'датчик', 'двигатель', 'реле'}
|
||||
```
|
||||
|
||||
Было создано еще одно множество и проведены некоторые операции над ним.
|
||||
|
||||
```
|
||||
mnoz2={a, ss1, bb2}
|
||||
mnoz2
|
||||
{False, 3.67, 'Это = строка символов'}
|
||||
mnoz2.remove(3.67)
|
||||
mnoz2
|
||||
{False, 'Это = строка символов'}
|
||||
mnoz2.add(90)
|
||||
mnoz2
|
||||
{False, 90, 'Это = строка символов'}
|
||||
```
|
||||
@ -0,0 +1,42 @@
|
||||
# Общее контрольное задание по теме 2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1) Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
|
||||
2) Создать переменную со значением, совпадающим с первой буквой из familia.
|
||||
3) Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
|
||||
4) Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
|
||||
5) Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
|
||||
6) Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
|
||||
7) Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
|
||||
8) Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
|
||||
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
familia='Deviatova'
|
||||
d=familia[0]
|
||||
d
|
||||
'D'
|
||||
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=('Maria', 'Lyudmila', 'Danil', 'Ilya')
|
||||
type(kort_nam)
|
||||
<class 'tuple'>
|
||||
kort_nam=kort_nam + ('Vadim', 'Nikita')
|
||||
kort_nam
|
||||
('Maria', 'Lyudmila', 'Danil', 'Ilya', 'Vadim', 'Nikita')
|
||||
kort_nam.count('Dima')
|
||||
0
|
||||
dict_bas={'строка':familia, 'символ':d, 'список':sp_kw, 'кортеж':kort_nam}
|
||||
dict_bas
|
||||
{'строка': 'Deviatova', 'символ': 'D', 'список': ['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'], 'кортеж': ('Maria', 'Lyudmila', 'Danil', 'Ilya', 'Vadim', 'Nikita')}
|
||||
```
|
||||
@ -0,0 +1,22 @@
|
||||
# Индивидуаьное контрольное задание по теме 2
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
# Вариант №14
|
||||
|
||||
## Задание
|
||||
|
||||
Создайте объект
|
||||
fg={'b':23,'c':45,'a':-12}
|
||||
К какому классу относится этот объект? Напишите инструкцию, создающую словарь, у которого упорядоченным по алфавиту ключам объекта fg соответствуют упорядоченные по величине значения этого объекта.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
fg={'b':23,'c':45,'a':-12}
|
||||
type(fg)
|
||||
<class 'dict'>
|
||||
fg_sort=dict(zip(sorted(fg.keys()), sorted(fg.values())))
|
||||
fg_sort
|
||||
{'a': -12, 'b': 23, 'c': 45}
|
||||
```
|
||||
@ -0,0 +1,716 @@
|
||||
# Отчет по теме 3
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск интерактивной оболочки IDLE, стандартные подготовительные операции
|
||||
|
||||
## 2 Преобразование простых базовых типов объектов
|
||||
|
||||
### 2.1 Преобразование в логический тип с помощью функции bool().
|
||||
|
||||
С помощью функции bool() были преобразованы объекты в логический тип. В примерах возвращает True, если передаваемое целое число не равно нулю или если передаваемая строка не является пустой.
|
||||
|
||||
```
|
||||
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 Преобразование в целое десятичное или вещественное число
|
||||
|
||||
С помощью функции int() были преобразованы объекты в целочисленный тип данных. Вторым аргументом можно указывать систему счисления, в которой представлен объект. По умолчанию десятичная.
|
||||
|
||||
```
|
||||
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"); tt5; type(tt5)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#18>", line 1, in <module>
|
||||
tt5=int("98.76"); tt5; type(tt5)
|
||||
ValueError: invalid literal for int() with base 10: '98.76'
|
||||
```
|
||||
|
||||
При передаче строки, в которой записано вещественное число, возникает ошибка, потому как функция принимает строку только с цифровыми символами.
|
||||
Было произведено преобразование целых чисел или строк символов в вещественное число – с помощью функции float().
|
||||
|
||||
```
|
||||
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 Преобразование десятичных чисел в другие системы счисления.
|
||||
|
||||
Было произведено преобразование десятичного числа 123 соотвественно в двоичную, восьмеричную и шестнадцатеричную системы счисления. Для проверки были проведены обратные преобразования.
|
||||
|
||||
```
|
||||
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().
|
||||
|
||||
Было продемонстрировано преобразование объектов различных типов в строку.
|
||||
|
||||
```
|
||||
strk1=str(23.6); strk1
|
||||
'23.6'
|
||||
strk2=str(logiz3); strk2
|
||||
'True'
|
||||
strk3=str(["A","B","C"]); strk3
|
||||
"['A', 'B', 'C']"
|
||||
strk4=str(("A","B","C")); strk4
|
||||
"('A', 'B', 'C')"
|
||||
strk5=str({"A":1,"B":2,"C":9})
|
||||
```
|
||||
|
||||
### 3.2 Преобразование элементов объекта в список с помощью функции list().
|
||||
|
||||
Были преобразованы объекты различных типов в списки.
|
||||
|
||||
```
|
||||
spis1=list("Строка символов"); spis1
|
||||
['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
|
||||
spis2=list((124,236,-15,908)); spis2
|
||||
[124, 236, -15, 908]
|
||||
spis3=list({"A":1,"B":2,"C":9}); spis3
|
||||
['A', 'B', 'C']
|
||||
```
|
||||
|
||||
Т.к. при преобразовании словаря получается список ключей словаря, ниже представлены дополнительные инструкции для получения списка значений и списка пар "ключ - значение"
|
||||
|
||||
```
|
||||
spis4=list({"A":1,"B":2,"C":9}.values()); spis4
|
||||
[1, 2, 9]
|
||||
spis5=list({"A":1,"B":2,"C":9}.items()); spis5
|
||||
[('A', 1), ('B', 2), ('C', 9)]
|
||||
```
|
||||
|
||||
### 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple().
|
||||
|
||||
```
|
||||
kort7=tuple('Строка символов'); kort7
|
||||
('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
|
||||
kort8=tuple(spis2); kort8
|
||||
(124, 236, -15, 908)
|
||||
kort9=tuple({"A":1,"B":2,"C":9}); kort9
|
||||
('A', 'B', 'C')
|
||||
```
|
||||
|
||||
### 3.4 Удаление объектов
|
||||
|
||||
Была очищена оперативная память от ранее созданных объектов с помощью инструкции del. Затем формально было проверено отсутствие указанных объектов.
|
||||
|
||||
```
|
||||
del strk5, kort8
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis44', 'spis5', 'spis55', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
|
||||
```
|
||||
|
||||
По заданию была создана строка с фамилией и инициалами, преобразована в список, затем список – в кортеж, кортеж – в строку.
|
||||
|
||||
```
|
||||
str0='Девятова М.Е.'
|
||||
spis0=list(str0)
|
||||
spis0
|
||||
['Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.']
|
||||
kort0=tuple(spis0); kort0
|
||||
('Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.')
|
||||
str00=str(kort0); str00
|
||||
"('Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.')"
|
||||
```
|
||||
|
||||
## 4 Арифметические операции.
|
||||
|
||||
### 4.1 Сложение/вычитание.
|
||||
|
||||
```
|
||||
12+7+90
|
||||
109
|
||||
5.689e-1 - 0.456
|
||||
0.11289999999999994
|
||||
23.6+54
|
||||
77.6
|
||||
14-56.7+89
|
||||
46.3
|
||||
```
|
||||
|
||||
### 4.2 Умножение.
|
||||
|
||||
```
|
||||
-6.7*12
|
||||
-80.4
|
||||
```
|
||||
|
||||
### 4.3 Деление.
|
||||
|
||||
```
|
||||
-234.5/6
|
||||
-39.083333333333336
|
||||
a=178/45; a; type(a)
|
||||
3.9555555555555557
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
### 4.4 Деление с округлением вниз.
|
||||
|
||||
```
|
||||
b=178//45; b; type(b)
|
||||
3
|
||||
<class 'int'>
|
||||
c=-24.6//12.1; c; type(c)
|
||||
-3.0
|
||||
<class 'float'>
|
||||
d=120//54.5; d; type(d)
|
||||
2.0
|
||||
<class 'float'>
|
||||
e=120.1//54; e; type(e)
|
||||
2.0
|
||||
<class 'float'>
|
||||
```
|
||||
|
||||
### 4.5 Получение остатка от деления.
|
||||
|
||||
```
|
||||
148%33
|
||||
16
|
||||
12.6%3.8
|
||||
1.2000000000000002
|
||||
12.6%3
|
||||
0.5999999999999996
|
||||
12%3.8
|
||||
0.6000000000000005
|
||||
```
|
||||
|
||||
### 4.6 Возведение в степень. Операции над комплексными числами
|
||||
|
||||
```
|
||||
14**3
|
||||
2744
|
||||
2.7**3.6
|
||||
35.719843790663525
|
||||
2.7**3
|
||||
19.683000000000003
|
||||
2**3.6
|
||||
12.125732532083186
|
||||
```
|
||||
|
||||
Были проделаны различные операции над комплексными числами. Операции деления с округлением вниз и получения остатка от деления не применяются для чисел такого типа.
|
||||
|
||||
```
|
||||
c1=5+7j
|
||||
c2=1-3j
|
||||
c1+c2
|
||||
(6+4j)
|
||||
c1-c2
|
||||
(4+10j)
|
||||
c1*c2
|
||||
(26-8j)
|
||||
c1/c2
|
||||
(-1.6+2.1999999999999997j)
|
||||
c2**4.6
|
||||
(171.38366786889966+102.16827023666599j)
|
||||
c1//2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#87>", line 1, in <module>
|
||||
c1//2
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'int'
|
||||
c1%c2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#88>", line 1, in <module>
|
||||
c1%c2
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||
```
|
||||
|
||||
## 5 Операции с двоичными представлениями целых чисел.
|
||||
|
||||
### 5.1 Двоичная инверсия (~).
|
||||
|
||||
Значение каждого бита в представлении числа заменяется на противоположное значение.
|
||||
|
||||
```
|
||||
dv1=9; bin(dv1)
|
||||
'0b1001'
|
||||
dv2=~dv1; bin(dv2); dv2
|
||||
'-0b1010'
|
||||
-10
|
||||
```
|
||||
|
||||
### 5.2 Двоичное «И» (&).
|
||||
|
||||
Логическое умножение, возвращает 1, если оба соответствующих бита сравниваемых чисел равны 1.
|
||||
|
||||
```
|
||||
dv3=7; dv4=8
|
||||
bin(dv3); bin(dv1)
|
||||
'0b111'
|
||||
'0b1001'
|
||||
dv3&dv1
|
||||
1
|
||||
bin(dv3&dv1)
|
||||
'0b1'
|
||||
bin(dv3); bin(dv4)
|
||||
'0b111'
|
||||
'0b1000'
|
||||
bin(dv3&dv4)
|
||||
'0b0'
|
||||
```
|
||||
|
||||
### 5.3 Двоичное «ИЛИ» (|).
|
||||
|
||||
Логическое сложение, 0 получается, только если оба сравниваемых разряда равны 0.
|
||||
|
||||
```
|
||||
bin(dv3); bin(dv1)
|
||||
'0b111'
|
||||
'0b1001'
|
||||
dv3|dv1
|
||||
15
|
||||
bin(dv3|dv1)
|
||||
'0b1111'
|
||||
bin(dv3); bin(dv4)
|
||||
'0b111'
|
||||
'0b1000'
|
||||
dv3|dv4
|
||||
15
|
||||
bin(dv3|dv4)
|
||||
'0b1111'
|
||||
dv5=5; dv6=14
|
||||
bin(dv5); bin(dv6)
|
||||
'0b101'
|
||||
'0b1110'
|
||||
dv5|dv6
|
||||
15
|
||||
bin(dv5|dv6)
|
||||
'0b1111'
|
||||
```
|
||||
|
||||
### 5.4 Двоичное «исключающее ИЛИ»(^).
|
||||
|
||||
Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
|
||||
|
||||
```
|
||||
bin(dv5); bin(dv6)
|
||||
'0b101'
|
||||
'0b1110'
|
||||
dv5^dv6
|
||||
11
|
||||
bin(dv5^dv6)
|
||||
'0b1011'
|
||||
```
|
||||
|
||||
### 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>).
|
||||
|
||||
```
|
||||
h=14; bin(h)
|
||||
'0b1110'
|
||||
g=h<<2; g; bin(g)
|
||||
56
|
||||
'0b111000'
|
||||
g1=h>>1; g1; bin(g1)
|
||||
7
|
||||
'0b111'
|
||||
g2=h>>2; g2; bin(g2)
|
||||
3
|
||||
'0b11'
|
||||
```
|
||||
|
||||
Были проделаны операции над двумя числами в двоичном представлении.
|
||||
|
||||
```
|
||||
b1=int("0110011", 2); b2=int("0010110", 2); b1; b2
|
||||
51
|
||||
22
|
||||
bin(~b1)
|
||||
'-0b110100'
|
||||
~b1
|
||||
-52
|
||||
b1&b2; bin(b1&b2)
|
||||
18
|
||||
'0b10010'
|
||||
b1|b2; bin(b1|b2)
|
||||
55
|
||||
'0b110111'
|
||||
b1^b2; bin(b1^b2)
|
||||
37
|
||||
'0b100101'
|
||||
b1<<2; bin(b1<<2)
|
||||
204
|
||||
'0b11001100'
|
||||
b2>>3; bin(b2>>3)
|
||||
2
|
||||
'0b10'
|
||||
```
|
||||
|
||||
## 6 Операции при работе с последовательностями (строками, списками, кортежами).
|
||||
|
||||
### 6.1 Объединение последовательностей (конкатенация)(+).
|
||||
|
||||
```
|
||||
'Система '+'регулирования'
|
||||
'Система регулирования'
|
||||
['abc','de','fg']+['hi','jkl']
|
||||
['abc', 'de', 'fg', 'hi', 'jkl']
|
||||
('abc','de','fg')+('hi','jkl')
|
||||
('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
```
|
||||
|
||||
### 6.2 Повторение (*).
|
||||
|
||||
```
|
||||
'ля-'*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 Проверка наличия заданного элемента в последовательности (in).
|
||||
|
||||
```
|
||||
stroka='Система автоматического управления'
|
||||
'автомат' in stroka
|
||||
True
|
||||
'ку' in ['ку','-']*3
|
||||
True
|
||||
'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
False
|
||||
```
|
||||
|
||||
### 6.4 Подстановка значений в строку с помощью оператора «%».
|
||||
|
||||
```
|
||||
stroka='Температура = %g %s %g'
|
||||
stroka % (16,' меньше ',25)
|
||||
'Температура = 16 меньше 25'
|
||||
stroka='Температура = %(zn1)g %(sravn)s %(zn2)g'
|
||||
stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
|
||||
'Температура = 16 меньше 25'
|
||||
```
|
||||
|
||||
## 7 Оператор присваивания.
|
||||
|
||||
### 7.1 Обычное присваивание значения переменной (=)
|
||||
|
||||
```
|
||||
zz=-12
|
||||
```
|
||||
|
||||
### 7.2 Увеличение значения переменной на заданную величину (+=) или уменьшение (-=).
|
||||
|
||||
Для последовательностей (например, строка) операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
|
||||
|
||||
```
|
||||
zz+=5; zz
|
||||
-7
|
||||
zz-=3; zz
|
||||
-10
|
||||
stroka='Система'
|
||||
stroka+=' регулирования'
|
||||
stroka
|
||||
'Система регулирования'
|
||||
```
|
||||
|
||||
### 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=).
|
||||
|
||||
Для строк операция (*=) означает повторение текущего значения объекта заданное число раз.
|
||||
|
||||
```
|
||||
zz/=2; zz
|
||||
-5.0
|
||||
zz*=5; zz
|
||||
-25.0
|
||||
stroka*=2; stroka
|
||||
'Система регулированияСистема регулирования'
|
||||
```
|
||||
|
||||
### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень (**=).
|
||||
|
||||
```
|
||||
zz//=7; zz
|
||||
-4.0
|
||||
zz%=3; zz
|
||||
2.0
|
||||
zz
|
||||
2.0
|
||||
zz**=5; zz
|
||||
32.0
|
||||
```
|
||||
|
||||
### 7.5 Множественное присваивание.
|
||||
|
||||
```
|
||||
w=v=10; w; v
|
||||
10
|
||||
10
|
||||
n1,n2,n3=(11,-3,'all'); n1; n2; n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
n1,n2,n3="11","-3","all"; n1; n2; n3
|
||||
'11'
|
||||
'-3'
|
||||
'all'
|
||||
n1,n2,n3=[11,-3,'all']; n1; n2; n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
n1,n2,n3={11: 0,-3: 3,'all': 1}; n1; n2; n3
|
||||
11
|
||||
-3
|
||||
'all'
|
||||
n1,n2,n3={11,-3,'all'}; n1; n2; n3
|
||||
11
|
||||
'all'
|
||||
-3
|
||||
```
|
||||
|
||||
## 8 Логические операции
|
||||
|
||||
### 8.1 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=).
|
||||
|
||||
```
|
||||
w==v
|
||||
True
|
||||
w!=v
|
||||
False
|
||||
v+=8
|
||||
w>v
|
||||
False
|
||||
w<v
|
||||
True
|
||||
v>=w
|
||||
True
|
||||
v<=w
|
||||
False
|
||||
```
|
||||
|
||||
### 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in).
|
||||
|
||||
```
|
||||
mnoz1={'pen','book','pen','iPhone','table','book'}
|
||||
'book' in mnoz1
|
||||
True
|
||||
'cap' in mnoz1
|
||||
False
|
||||
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
||||
'Vologda' in dic1
|
||||
True
|
||||
'Pskov' in dic1
|
||||
False
|
||||
56 in dic1.values()
|
||||
True
|
||||
dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
|
||||
'UII' in dct1['Depart']
|
||||
True
|
||||
dct1['Depart'][1] == 'MM'
|
||||
False
|
||||
```
|
||||
|
||||
### 8.3 Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).
|
||||
|
||||
```
|
||||
a=17; b=-6
|
||||
(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
|
||||
True
|
||||
(a==b) or (145 in dic1.values()) or not ('VMSS' in dct1['Depart'])
|
||||
True
|
||||
(a>0) or ('pen' in mnoz1) and ('Moscow' in dic1)
|
||||
False
|
||||
```
|
||||
|
||||
### 8.4 Проверка ссылок переменных на один и тот же объект (is).
|
||||
|
||||
```
|
||||
w=v=10
|
||||
w is v
|
||||
True
|
||||
w1=['A','B']; v1=['A','B']
|
||||
w1 is v1
|
||||
False
|
||||
```
|
||||
|
||||
## 9 Операции с объектами, выполняемые с помощью методов.
|
||||
|
||||
Полный список атрибутов объекта с использованием dir():
|
||||
|
||||
```
|
||||
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 Методы для работы со строками.
|
||||
|
||||
```
|
||||
stroka.find('пр')
|
||||
5
|
||||
stroka.count("с")
|
||||
4
|
||||
stroka.replace(' у',' автоматического у')
|
||||
'Микропроцессорная система автоматического управления'
|
||||
spis22=stroka.split(' ')
|
||||
spis22
|
||||
['Микропроцессорная', 'система', 'управления']
|
||||
stroka.upper()
|
||||
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||
stroka3=" ".join(spis22); stroka3
|
||||
'Микропроцессорная система управления'
|
||||
stroka3.partition("с")
|
||||
('Микропроце', 'с', 'сорная система управления')
|
||||
stroka3.rpartition("с")
|
||||
('Микропроцессорная си', 'с', 'тема управления')
|
||||
strk1='Момент времени {}, значение = {}'
|
||||
strk1.format(1,89.7); strk1
|
||||
'Момент времени 1, значение = 89.7'
|
||||
'Момент времени {}, значение = {}'
|
||||
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 Методы работы со списками.
|
||||
|
||||
```
|
||||
spsk=[1, 'abc', (8, 5), [2, 5], 1+7j]
|
||||
spsk.pop(2); spsk
|
||||
(8, 5)
|
||||
[1, 'abc', [2, 5], (1+7j)]
|
||||
spsk.append('c'); spsk
|
||||
[1, 'abc', [2, 5], (1+7j), 'c']
|
||||
spsk.insert(2,'a'); spsk
|
||||
[1, 'abc', 'a', [2, 5], (1+7j), 'c']
|
||||
spsk.count('a')
|
||||
1
|
||||
```
|
||||
|
||||
### 9.3 Методы работы с кортежами.
|
||||
|
||||
```
|
||||
kort_m=(1, 5, 8+6j, 'u')
|
||||
dir(kort_m)
|
||||
['__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']
|
||||
kort_m.count(5)
|
||||
1
|
||||
kort_m.index('u')
|
||||
3
|
||||
```
|
||||
|
||||
### 9.4 Методы работы со словарями и множествами.
|
||||
|
||||
Словари:
|
||||
|
||||
```
|
||||
dict_m={'a': '21', 'b': 't', 'c': 90}
|
||||
dir(dict_m)
|
||||
['__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']
|
||||
dict_m.items()
|
||||
dict_items([('a', '21'), ('b', 't'), ('c', 90)])
|
||||
dict_m.values()
|
||||
dict_values(['21', 't', 90])
|
||||
dict_m.keys()
|
||||
dict_keys(['a', 'b', 'c'])
|
||||
dict_m.get('b')
|
||||
't'
|
||||
dict_m.popitem()
|
||||
('c', 90)
|
||||
dict_m.pop('b')
|
||||
't'
|
||||
dict_m
|
||||
{'a': '21'}
|
||||
dict_m.update({'v': 0, 'q': 'x'})
|
||||
dict_m
|
||||
{'a': '21', 'v': 0, 'q': 'x'}
|
||||
dict_m.clear()
|
||||
dict_m
|
||||
{}
|
||||
```
|
||||
|
||||
Множества:
|
||||
|
||||
```
|
||||
mn_m={'red','blue','green','black','blue'}
|
||||
mn_m
|
||||
{'green', 'red', 'blue', 'black'}
|
||||
dir(mn_m)
|
||||
['__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']
|
||||
mn_m.add('white')
|
||||
mn_m
|
||||
{'white', 'blue', 'black', 'red', 'green'}
|
||||
mn_m.remove('green')
|
||||
mn_m
|
||||
{'white', 'blue', 'black', 'red'}
|
||||
mn_m1=mn_m.copy()
|
||||
mn_m1
|
||||
{'red', 'white', 'blue', 'black'}
|
||||
mn_m1.add('yellow')
|
||||
mn_m
|
||||
{'white', 'blue', 'black', 'red'}
|
||||
mn_m1
|
||||
{'white', 'blue', 'black', 'yellow', 'red'}
|
||||
mn_m.difference(mn_m1)
|
||||
set()
|
||||
mn_m1.difference(mn_m)
|
||||
{'yellow'}
|
||||
mn_m2={'orange', 'violet', 'black'}
|
||||
mn_m3=mn_m.union(mn_m2); mn_m3
|
||||
{'violet', 'white', 'blue', 'black', 'orange', 'red'}
|
||||
mn_m3.symmetric_difference(mn_m2)
|
||||
{'blue', 'white', 'red'}
|
||||
mn_m3.intersection(mn_m2)
|
||||
{'violet', 'black', 'orange'}
|
||||
mn_m.issubset(mn_m1)
|
||||
True
|
||||
mn_m.isdisjoint(mn_m1)
|
||||
False
|
||||
```
|
||||
@ -0,0 +1,93 @@
|
||||
# Общее контрольное задание по теме 3
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1) Преобразовать восьмеричное значение 45 в целое число.
|
||||
2) Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
|
||||
3) Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
|
||||
4) Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
5) Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
|
||||
6) Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
|
||||
7) Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
|
||||
|
||||
## Решение
|
||||
|
||||
1)
|
||||
|
||||
```
|
||||
int('45', 8)
|
||||
37
|
||||
```
|
||||
|
||||
2)
|
||||
|
||||
```
|
||||
D={"усиление":23, "запаздывание":12, "постоянная времени":78}
|
||||
D_k=list(D.keys()); D_k
|
||||
['усиление', 'запаздывание', 'постоянная времени']
|
||||
D_v=list(D.values()); D_v
|
||||
[23, 12, 78]
|
||||
K=tuple(D_k+D_v); K
|
||||
('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
|
||||
```
|
||||
|
||||
3)
|
||||
|
||||
```
|
||||
((1768//24.8)%3)**2.4
|
||||
5.278031643091577
|
||||
```
|
||||
|
||||
4)
|
||||
|
||||
```
|
||||
((~(13&27))^14)<<2
|
||||
-32
|
||||
```
|
||||
|
||||
5)
|
||||
|
||||
```
|
||||
spis=["колебат"]*4
|
||||
spis
|
||||
['колебат', 'колебат', 'колебат', 'колебат']
|
||||
"аткол" in spis[1]+spis[2]
|
||||
True
|
||||
```
|
||||
|
||||
6)
|
||||
|
||||
```
|
||||
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']
|
||||
help(D.keys)
|
||||
Help on built-in function keys:
|
||||
|
||||
keys() method of builtins.dict instance
|
||||
Return a set-like object providing a view on the dict's keys.
|
||||
|
||||
D.keys()
|
||||
dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
|
||||
help(D.values)
|
||||
Help on built-in function values:
|
||||
|
||||
values() method of builtins.dict instance
|
||||
Return an object providing a view on the dict's values.
|
||||
|
||||
D.values()
|
||||
dict_values([23, 12, 78])
|
||||
```
|
||||
|
||||
7)
|
||||
|
||||
```
|
||||
strok='Создать объект - символьную строку с текстом данного предложения'
|
||||
st_list=list(strok.split()); st_list
|
||||
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
st_list[st_list.index('-')]=','; st_list
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
|
||||
st_list.remove('данного'); st_list
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
|
||||
```
|
||||
@ -0,0 +1,60 @@
|
||||
# Тест по модулю 1
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание, вариант M1_24
|
||||
|
||||
1)Какое назначение имеют демонстрационные примеры в системе помощи?
|
||||
|
||||
2)Создайте объект-кортеж с 5 элементами - произвольными восьмеричными числами. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
|
||||
|
||||
3)Напишите инструкцию, позволяющую определить, сколько элементов в кортеже. Напишите инструкцию, позволяющую выделить из кортежа второе по порядку число и записать его в виде отдельной переменной. Отобразите на экране получившийся объект.
|
||||
|
||||
4)Преобразуйте кортеж в список. Вставьте в список на третью позицию число 888. Отобразите получившийся объект. Преобразуйте список в строку и уберите из неё разделители чисел. Отобразите строку.
|
||||
|
||||
5)Используя метод форматирования написать инструкцию вывода на экран заданного номером элемента кортежа по шаблону: "Элемент кортежа №4 = <значение элемента>".
|
||||
|
||||
## Выполнение
|
||||
|
||||
1) Демонстрационные примеры в системе помощи имеют назначение предоставить пользователю, который обратился к справочной информации, например, о какой-либо функции, реальный пример применения функции или метода, который можно реализовать и проверить его выполнение.
|
||||
|
||||
2)
|
||||
|
||||
```
|
||||
v=(oct(21), oct(7), oct(62), oct(32), oct(11)); v
|
||||
('0o25', '0o7', '0o76', '0o40', '0o13')
|
||||
type(v)
|
||||
<class 'tuple'>
|
||||
dir(v)
|
||||
['__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']
|
||||
```
|
||||
|
||||
3)
|
||||
|
||||
```
|
||||
len(v)
|
||||
5
|
||||
v2=v[1]; v2
|
||||
'0o7'
|
||||
```
|
||||
|
||||
4)
|
||||
|
||||
```
|
||||
spisv=list(v); spisv
|
||||
['0o25', '0o7', '0o76', '0o40', '0o13']
|
||||
spisv.insert(2, 888); spisv
|
||||
['0o25', '0o7', 888, '0o76', '0o40', '0o13']
|
||||
strv=str(spisv); strv
|
||||
"['0o25', '0o7', 888, '0o76', '0o40', '0o13']"
|
||||
strv=strv.replace(', ', ' '); strv
|
||||
"['0o25' '0o7' 888 '0o76' '0o40' '0o13']"
|
||||
```
|
||||
|
||||
5)
|
||||
|
||||
```
|
||||
sss='Элемент кортежа №4 = {}'
|
||||
sss.format(v[3])
|
||||
'Элемент кортежа №4 = 0o40'
|
||||
```
|
||||
|
После Ширина: | Высота: | Размер: 20 KiB |
|
После Ширина: | Высота: | Размер: 28 KiB |
|
После Ширина: | Высота: | Размер: 15 KiB |
|
После Ширина: | Высота: | Размер: 8.4 KiB |
|
После Ширина: | Высота: | Размер: 8.3 KiB |
@ -0,0 +1,367 @@
|
||||
# Отчет по теме 4
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## 1 Запуск IDLE
|
||||
|
||||
## 2 Стандартные функции
|
||||
|
||||
### 2.1 Функция round
|
||||
|
||||
Округление числа с заданной точностью
|
||||
|
||||
```
|
||||
a=round(123.456,1); a; type(a)
|
||||
123.5
|
||||
<class 'float'>
|
||||
b=round(123.456,0); b; type(b)
|
||||
123.0
|
||||
<class 'float'>
|
||||
c=round(123.456); c; type(c)
|
||||
123
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
### 2.2 Функция range
|
||||
|
||||
Создание последовательности целых чисел с заданным шагом (по умолчанию с шагом 1).
|
||||
|
||||
```
|
||||
gg=range(76,123,9)
|
||||
gg
|
||||
range(76, 123, 9)
|
||||
list(gg)
|
||||
[76, 85, 94, 103, 112, 121]
|
||||
gg1=range(23); list(gg1)
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
|
||||
```
|
||||
|
||||
### 2.3 Функция zip
|
||||
|
||||
Создание общего объекта, элементами которого являются кортежи, составленные из элементов двух или более объектов-последовательностей
|
||||
|
||||
```
|
||||
qq=['Девятова', 'Ефимова', 'Беженарь', 'Гордиевских']
|
||||
ff=zip(gg,qq)
|
||||
ff
|
||||
<zip object at 0x000002B6596E6C00>
|
||||
tuple(ff)
|
||||
((76, 'Девятова'), (85, 'Ефимова'), (94, 'Беженарь'), (103, 'Гордиевских'))
|
||||
ff[1]
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#16>", line 1, in <module>
|
||||
ff[1]
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
```
|
||||
|
||||
### 2.4 Функция eval
|
||||
|
||||
Вычисление значения выражения, записанного в виде символьной строки
|
||||
|
||||
```
|
||||
fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
||||
коэффициент усиления=81
|
||||
dan
|
||||
249.0
|
||||
```
|
||||
|
||||
### 2.5 Функция exec
|
||||
|
||||
Выполнение инструкций, переданных в аргумент функции в строковом виде
|
||||
|
||||
```
|
||||
exec(input('введите инструкции:'))
|
||||
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
||||
gg
|
||||
221.456
|
||||
```
|
||||
|
||||
### 2.6 Функции abs, pow, max, min, sum, divmod, len, map
|
||||
|
||||
```
|
||||
abs(-9)
|
||||
9
|
||||
pow(7, 3)
|
||||
343
|
||||
max(7, 9, 0)
|
||||
9
|
||||
min(-9, 0, 8)
|
||||
-9
|
||||
sum([1, -8, 7, 2])
|
||||
2
|
||||
divmod(43, 6)
|
||||
(7, 1)
|
||||
divmod(-43, 6)
|
||||
(-8, 5)
|
||||
divmod(-43, -6)
|
||||
(7, -1)
|
||||
len(qq)
|
||||
4
|
||||
length_words=map(len, qq); list(length_words)
|
||||
[8, 7, 8, 11]
|
||||
```
|
||||
|
||||
## 3 Функции из стандартного модуля math
|
||||
|
||||
```
|
||||
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!.
|
||||
|
||||
Raise a ValueError if x is negative or non-integral.
|
||||
|
||||
math.factorial(5)
|
||||
120
|
||||
math.pi
|
||||
3.141592653589793
|
||||
math.degrees(1)
|
||||
57.29577951308232
|
||||
math.radians(60)
|
||||
1.0471975511965976
|
||||
math.sin(math.radians(30))
|
||||
0.49999999999999994
|
||||
math.degrees(math.acos(0.5))
|
||||
60.00000000000001
|
||||
math.degrees(math.acos(12))
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#70>", line 1, in <module>
|
||||
math.degrees(math.acos(12))
|
||||
ValueError: math domain error
|
||||
math.exp(2)
|
||||
7.38905609893065
|
||||
math.log(math.e)
|
||||
1.0
|
||||
math.log(49, 7)
|
||||
2.0
|
||||
math.log(-49, 7)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#73>", line 1, in <module>
|
||||
math.log(-49, 7)
|
||||
ValueError: math domain error
|
||||
math.log10(10)
|
||||
1.0
|
||||
math.sqrt(121)
|
||||
11.0
|
||||
math.sqrt(-49)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#79>", line 1, in <module>
|
||||
math.sqrt(-49)
|
||||
ValueError: math domain error
|
||||
math.ceil(11/2)
|
||||
6
|
||||
math.floor(11/2)
|
||||
5
|
||||
```
|
||||
|
||||
## 4 Функции из модуля cmath
|
||||
|
||||
```
|
||||
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
|
||||
|
||||
```
|
||||
import random
|
||||
dir(random)
|
||||
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
|
||||
help(random.seed)
|
||||
Help on method seed in module random:
|
||||
|
||||
seed(a=None, version=2) method of random.Random instance
|
||||
Initialize internal state from a seed.
|
||||
|
||||
The only supported seed types are None, int, float,
|
||||
str, bytes, and bytearray.
|
||||
|
||||
None or no argument seeds from current time or from an operating
|
||||
system specific randomness source if available.
|
||||
|
||||
If *a* is an int, all bits are used.
|
||||
|
||||
For version 2 (the default), all of the bits are used if *a* is a str,
|
||||
bytes, or bytearray. For version 1 (provided for reproducing random
|
||||
sequences from older versions of Python), the algorithm for str and
|
||||
bytes generates a narrower range of seeds.
|
||||
|
||||
random.seed()
|
||||
random.random()
|
||||
0.03177690077737194
|
||||
random.random()
|
||||
0.42660420133444044
|
||||
random.random()
|
||||
0.6029016351661705
|
||||
random.uniform(3, 8)
|
||||
3.349556259329991
|
||||
random.randint(3, 8)
|
||||
7
|
||||
random.gauss()
|
||||
1.3115168238883617
|
||||
random.gauss(5, 8)
|
||||
18.723843368888335
|
||||
lst=[13, 'cat', 5-8j, (1, 7), 67.8]
|
||||
random.choice(lst)
|
||||
(1, 7)
|
||||
random.shuffle(lst)
|
||||
lst
|
||||
[(1, 7), 13, 'cat', (5-8j), 67.8]
|
||||
random.sample(lst, 3)
|
||||
['cat', 67.8, (5-8j)]
|
||||
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(3, 7)
|
||||
0.5892004380254151
|
||||
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(4, 6)
|
||||
21.738935796671953
|
||||
rand=[random.uniform(1,2), random.gauss(), random.betavariate(2,5), random.gammavariate(3, 4)]
|
||||
rand
|
||||
[1.0853816485082923, -1.2263412989631917, 0.44973003958419866, 8.863321797224248]
|
||||
```
|
||||
|
||||
## 6 Функции из модуля time
|
||||
|
||||
```
|
||||
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()
|
||||
c1
|
||||
1761126046.1433933
|
||||
c2=time.time()-c1; c2
|
||||
12.040217399597168
|
||||
dat=time.gmtime(); dat
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=9, tm_min=41, tm_sec=17, tm_wday=2, tm_yday=295, tm_isdst=0)
|
||||
type(dat)
|
||||
<class 'time.struct_time'>
|
||||
KeyboardInterrupt
|
||||
dat.tm_mon
|
||||
10
|
||||
dat.tm_yday
|
||||
295
|
||||
msc=time.localtime()
|
||||
msc
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=12, tm_min=43, tm_sec=12, tm_wday=2, tm_yday=295, tm_isdst=0)
|
||||
time.asctime()
|
||||
'Wed Oct 22 12:57:32 2025'
|
||||
time.ctime()
|
||||
'Wed Oct 22 12:58:08 2025'
|
||||
time.sleep(5)
|
||||
time.mktime(msc)
|
||||
1761126192.0
|
||||
time.localtime(c1)
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=12, tm_min=40, tm_sec=46, tm_wday=2, tm_yday=295, tm_isdst=0)
|
||||
```
|
||||
|
||||
## 7 Графические функции
|
||||
|
||||
```
|
||||
import pylab
|
||||
x=list(range(-3,55,4))
|
||||
t=list(range(15))
|
||||
pylab.plot(t,x)
|
||||
[<matplotlib.lines.Line2D object at 0x000002B66266AD50>]
|
||||
pylab.title('Первый график')
|
||||
Text(0.5, 1.0, 'Первый график')
|
||||
pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
|
||||
pylab.plot(X1)
|
||||
[<matplotlib.lines.Line2D object at 0x000002B664343610>]
|
||||
pylab.plot(X2)
|
||||
[<matplotlib.lines.Line2D object at 0x000002B664343750>]
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
```
|
||||
region=['Центр','Урал','Сибирь','Юг']
|
||||
naselen=[65,12,23,17]
|
||||
pylab.pie(naselen,labels=region)
|
||||
([<matplotlib.patches.Wedge object at 0x000002B66264DD30>, <matplotlib.patches.Wedge object at 0x000002B663849090>, <matplotlib.patches.Wedge object at 0x000002B663849450>, <matplotlib.patches.Wedge object at 0x000002B6638496D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```
|
||||
pylab.hist([2, 3, 4, 21, 14, 0, 13, 19, 7, 9, 11], bins=4)
|
||||
(array([4., 2., 3., 2.]), array([ 0. , 5.25, 10.5 , 15.75, 21. ]), <BarContainer object of 4 artists>)
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```
|
||||
pylab.bar(region, naselen)
|
||||
<BarContainer object of 4 artists>
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 8 Некоторые функции статистического модуля statistics
|
||||
|
||||
```
|
||||
import statistics
|
||||
dir(statistics)
|
||||
['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_kernel_invcdfs', '_mean_stdev', '_newton_raphson', '_normal_dist_inv_cdf', '_quartic_invcdf', '_quartic_invcdf_estimate', '_random', '_rank', '_sqrt_bit_width', '_sqrtprod', '_ss', '_sum', '_triweight_invcdf', '_triweight_invcdf_estimate', 'acos', 'asin', 'atan', 'bisect_left', 'bisect_right', 'correlation', 'cos', 'cosh', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'isfinite', 'isinf', 'itemgetter', 'kde', 'kde_random', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pi', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sin', 'sqrt', 'stdev', 'sumprod', 'sys', 'tan', 'tau', 'variance']
|
||||
statistics.mode(['banana', 'apple', 'strawberry', 'lemon', 'apple', 'pineapple', 'lemon', 'apple'])
|
||||
'apple'
|
||||
statistics.mode(['banana', 'apple', 'strawberry', 'lemon', 'apple', 'pineapple', 'lemon', 'banana'])
|
||||
'banana'
|
||||
statistics.correlation(X1, X2)
|
||||
-0.3939192985791677
|
||||
statistics.stdev(X1)
|
||||
2.4083189157584592
|
||||
statistics.mean(X1)
|
||||
8.6
|
||||
```
|
||||
@ -0,0 +1,50 @@
|
||||
# Общее контрольное задание по теме 4
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
|
||||
2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
|
||||
3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
|
||||
4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
|
||||
5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
|
||||
6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
import cmath
|
||||
divmod((round(cmath.phase(0.2+0.8j), 2))*20, 3)
|
||||
(8.0, 2.6000000000000014)
|
||||
import time
|
||||
t=time.localtime()
|
||||
t
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=23, tm_hour=23, tm_min=15, tm_sec=34, tm_wday=3, tm_yday=296, tm_isdst=0)
|
||||
msc_time=str(t.tm_hour)+':'+str(t.tm_min); msc_time
|
||||
'23:15'
|
||||
week=['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
|
||||
import random
|
||||
random.sample(week, 3)
|
||||
['sunday', 'tuesday', 'friday']
|
||||
random.choice(range(14, 32, 3))
|
||||
20
|
||||
N=round(random.gauss(15, 4))
|
||||
N
|
||||
11
|
||||
alphabet=[]
|
||||
for i in range(ord('a'), ord('z')+1):
|
||||
alphabet.append(chr(i))
|
||||
|
||||
|
||||
for i in range(ord('A'), ord('Z')+1):
|
||||
alphabet.append(chr(i))
|
||||
|
||||
|
||||
alphabet
|
||||
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
|
||||
R=random.sample(alphabet, N); R
|
||||
['j', 'u', 'U', 'w', 'p', 'I', 'g', 'R', 'h', 'P', 'G']
|
||||
time.localtime().tm_min-t.tm_min
|
||||
20
|
||||
```
|
||||
@ -0,0 +1,30 @@
|
||||
# Индивидуальное контрольное задание по теме 4
|
||||
|
||||
Девятова Мария, А-03-23
|
||||
|
||||
## Задание
|
||||
|
||||
Напишите инструкцию запоминания текущего Московского времени в некоторой переменной.
|
||||
Создайте кортеж с целочисленными значениями от 0 до 136 с шагом 17. Подсчитайте число элементов в кортеже.
|
||||
Создайте нормально распределенное число Z с математическим ожиданием 47 и стандартным отклонением 22.
|
||||
Нацело разделите сумму элементов кортежа на округленное до целого значения Z.
|
||||
Отобразите результат в виде символьной строки вида «Результат = ХХ» с использование формата.
|
||||
Определите время в минутах, прошедшее с начала выполнения данного задания.
|
||||
|
||||
## Выполнение
|
||||
|
||||
```
|
||||
import time; import random
|
||||
t1=time.localtime(); t1
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=4, tm_sec=41, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
cort=tuple(range(0, 136, 17)); cort; len(cort)
|
||||
(0, 17, 34, 51, 68, 85, 102, 119)
|
||||
8
|
||||
Z=random.gauss(47, 22); Z
|
||||
107.92112395720454
|
||||
res=sum(cort)//round(Z)
|
||||
print("Результат = {}".format(res))
|
||||
Результат = 4
|
||||
time.localtime().tm_min-t1.tm_min
|
||||
5
|
||||
```
|
||||
Загрузка…
Ссылка в новой задаче