форкнуто от main/python-labs
Сравнить коммиты
Ничего общего в коммитах. 'main' и 'master' имеют совершенно разные истории.
@ -1,3 +0,0 @@
|
||||
__pycache__
|
||||
.*
|
||||
!.gitignore
|
||||
@ -1,133 +0,0 @@
|
||||
# Программное обеспечение автоматизированных систем: лабораторные работы
|
||||
|
||||
[Репозиторий с методическими указаниями и заданиями.](http://uit.mpei.ru/git/main/python)
|
||||
|
||||
## Работа с Git
|
||||
|
||||
**Работы проверяются только после того, как закоммичены по правилам ниже.**
|
||||
|
||||
[Лабораторная работа про Git второго семестра][gitlab]
|
||||
поможет вспомнить, как работать с Git.
|
||||
|
||||
[gitlab]: http://uit.mpei.ru/git/main/cs/src/branch/main/labs/lab02
|
||||
|
||||
1. В начале семестра
|
||||
создать на сервере копию этого репозитория («форкнуть» его), нажав *Fork*.
|
||||
Получится репозиторий-форк `http://uit.mpei.ru/git/IvanovII/python-labs`,
|
||||
где `IvanovII` — ваше имя пользователя.
|
||||
|
||||
1. В начале каждого занятия:
|
||||
|
||||
Клонировать свой форк на рабочий стол
|
||||
(`IvanovII` заменить на свое имя пользователя):
|
||||
|
||||
```sh
|
||||
git clone http://uit.mpei.ru/git/IvanovII/python-labs.git
|
||||
```
|
||||
|
||||
Перебазировать свой форк на исходный репозиторий ("апстрим"):
|
||||
|
||||
```sh
|
||||
# Первую команду нужно запускать только один раз,
|
||||
# иначе будет ошибка "error: remote upstream already exists".
|
||||
git remote add upstream http://uit.mpei.ru/git/main/python-labs.git
|
||||
git fetch upstream
|
||||
git stash push
|
||||
git rebase upstream/main
|
||||
git stash pop
|
||||
```
|
||||
|
||||
Перебазировать нужно, чтобы подтянуть из исходного репозитория обновления.
|
||||
|
||||
1. После того, как отчет написан, закоммитить его как `TEMAn/report.md`.
|
||||
|
||||
**Здесь и далее «закоммитить» для краткости означает:
|
||||
сделать коммит и запушить его на сервер.**
|
||||
|
||||
Здесь и далее `TEMAn` означают каталоги конкретных тем:
|
||||
`TEMA1`, `TEMA2` и т. д.
|
||||
Можно также коммитить по частям в процессе работы.
|
||||
Если для отчета нужны рисунки, то их закоммитить в `TEMAn`,
|
||||
назвав `figure0.png`, `figure1.png` и т. д.
|
||||
|
||||
1. Решение общего контрольного задания (ОКЗ) закоммитить как `TEMAn/task.md`.
|
||||
Исключения:
|
||||
|
||||
* Тема 1 не содержит общего контрольного задания — ничего не делать.
|
||||
* Тема 8 требует нескольких файлов — закоммитить их в каталог `TEMA8/task`.
|
||||
|
||||
1. Решение индивидуального контрольного задания (ИКЗ) по темам 2, 4, 5, 7, 8
|
||||
или решение теста по модуля после тем 3, 6, 9
|
||||
закоммитить как `TEMAn/test.md`.
|
||||
Исключения:
|
||||
|
||||
* Тема 1 вместо ИКЗ содержит контрольный вопрос —
|
||||
закоммитить также в `TEMA1/test.md`.
|
||||
* Тема 8 и тест по модулю 3 (после темы 9) требуют нескольких файлов —
|
||||
закоммитить в каталог `TEMAn/test`.
|
||||
|
||||
## Оформление материалов
|
||||
|
||||
Тексты оформляются в формате [Markdown](https://commonmark.org/help/).
|
||||
Для этого текст со специальной разметкой пишется в файле с расширением `*.md`,
|
||||
а в web-интерфейсе будет отображаться оформленным, подобно этому.
|
||||
|
||||
Образец оформления материалов по каждой теме: [`TEMA0`](TEMA0).
|
||||
|
||||
### Оформление отчетов
|
||||
|
||||
Отчет `TEMAn/report.md` оформляется в формате Markdown по следующему образцу:
|
||||
|
||||
# Отчет по теме 1
|
||||
|
||||
Иванов Иван, А-01-25
|
||||
|
||||
## 1 Изучение среды IDLE
|
||||
|
||||
## 1.1 Настройка текущего каталога
|
||||
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir(r"C:\users\u111-19\Desktop\python\TEMA1")
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\u111-19\\Desktop\\python\\TEMA1'
|
||||
```
|
||||
|
||||
Нажал *Файл / Открыть*, диалог оказался сразу нацелен на установленную папку:
|
||||
|
||||
|
||||
|
||||
Заголовки пунктов должны отражать их суть в нескольких словах,
|
||||
то есть просто скопировать текст пункта в заголовок не подойдет.
|
||||
Вы должны сами придумать осмысленные заголовки, прочитав пункт задания.
|
||||
|
||||
В отчет копируется код, введенный в оболочку (строки, начинающиеся с `>>>`),
|
||||
и вывод соответствующих команд (`'C:\\Users...` в примере).
|
||||
|
||||
Если в пункте задания требуется сделать вывод или объяснить что-то,
|
||||
к коду и выводу добавляется письменный ответ или пояснение.
|
||||
|
||||
### Оформление решений
|
||||
|
||||
Решение всех заданий оформляется по образцу:
|
||||
|
||||
# Общее контрольное задание по теме 2
|
||||
|
||||
Иванов Иван, А-01-25
|
||||
|
||||
## Задание
|
||||
|
||||
Создать переменную `name`, содержащую ваше имя. Определить тип этой переменной.
|
||||
|
||||
## Решение
|
||||
|
||||
```py
|
||||
>>> name = 'Иван'
|
||||
>>> type(name)
|
||||
'str'
|
||||
```
|
||||
|
||||
Для темы 1 вместо «Задания» — «Вопрос», вместо «Решения» — «Ответ».
|
||||
|
||||
Для тем 8 и 9 раздела «Решение» не нужно,
|
||||
вместо этого решение размещается в отдельных файлах `*.py`.
|
||||
@ -1,6 +0,0 @@
|
||||
# Тема 0: образец оформления материалов
|
||||
|
||||
* `README.md` — этот документ, в своих темах создавать не нужно;
|
||||
* [`report.md`](report.md) — отчет;
|
||||
* [`task.md`](task.md) — общее контрольное задание;
|
||||
* [`test.md`](test.md) — индивидуальное контрольное задание.
|
||||
|
До Ширина: | Высота: | Размер: 15 KiB |
@ -1,18 +0,0 @@
|
||||
# Отчет по теме 0
|
||||
|
||||
Иванов Иван, А-01-25
|
||||
|
||||
## 1 Изучение среды IDLE
|
||||
|
||||
## 1.1 Настройка текущего каталога
|
||||
|
||||
```
|
||||
>>> import os
|
||||
>>> os.chdir(r"C:\users\u111-19\Desktop\python\TEMA1")
|
||||
>>> os.getcwd()
|
||||
'C:\\Users\\u111-19\\Desktop\\python\\TEMA1'
|
||||
```
|
||||
|
||||
Нажал *Файл / Открыть*, диалог оказался сразу нацелен на установленную папку:
|
||||
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
# Общее контрольное задание по теме 0
|
||||
|
||||
Иванов Иван, А-01-25
|
||||
|
||||
## Задание
|
||||
|
||||
Создать переменную `name`, содержащую ваше имя. Определить тип этой переменной.
|
||||
|
||||
## Решение
|
||||
|
||||
```py
|
||||
>>> name = 'Иван'
|
||||
>>> type(name)
|
||||
'str'
|
||||
```
|
||||
@ -1,24 +0,0 @@
|
||||
# Индивидуальное контрольное задание по теме 0
|
||||
|
||||
Иванов Иван, А-01-25
|
||||
|
||||
## Задание
|
||||
|
||||
Создать переменную `name`, содержащую ваше имя,
|
||||
и `surname`, содержащую вашу фамилию.
|
||||
Как из них можно создать переменную, содержащую ваше полное имя?
|
||||
|
||||
## Решение
|
||||
|
||||
```py
|
||||
>>> name = 'Иван'
|
||||
>>> surname = 'Иванов'
|
||||
```
|
||||
|
||||
Создать требуемую переменную `full_name` можно так:
|
||||
|
||||
```py
|
||||
>>> full_name = name + ' ' + surname
|
||||
>>> full_name
|
||||
'Иван Иванов'
|
||||
```
|
||||
@ -1,5 +0,0 @@
|
||||
#Программа по теме 1 Лыковой Е.А
|
||||
print("Hello")
|
||||
h=input("Your name=")
|
||||
import os
|
||||
os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova")
|
||||
@ -1,2 +0,0 @@
|
||||
name = input("Как Вас зовут? ")
|
||||
print("Привет,", name)
|
||||
@ -1,60 +0,0 @@
|
||||
#Протокол по теме 1 Лыковой Е.А
|
||||
import os
|
||||
os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova\\TEMA1\\")
|
||||
|
||||
============= RESTART: C:/Users/u207-06/Desktop/Lykova/TEMA1/Pr0.py ============
|
||||
Hello
|
||||
Your name=Lizp
|
||||
import Pr0
|
||||
Hello
|
||||
Your name=Lizp
|
||||
import prb1
|
||||
Как Вас зовут? Лизп
|
||||
Привет, Лизп
|
||||
help(print)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
|
||||
help(print),help(input)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt='', /)
|
||||
Read a string from standard input. The trailing newline is stripped.
|
||||
|
||||
The prompt string, if given, is printed to standard output without a
|
||||
trailing newline before reading input.
|
||||
|
||||
If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
|
||||
On *nix systems, readline is used if available.
|
||||
|
||||
(None, None)
|
||||
|
||||
============ RESTART: C:\Users\u207-06\Desktop\Lykova\TEMA1\prb1.py ============
|
||||
Как Вас зовут? Лизп
|
||||
Привет, Лизп
|
||||
import tdemo_chaos
|
||||
@ -1,123 +0,0 @@
|
||||
# Отчет по теме 1
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## 1. Создание копии репозитория
|
||||
|
||||
```
|
||||
$ git clone http://uit.mpei.ru/git/LykovaYA/python-labs.git
|
||||
```
|
||||
|
||||
## 1.1 Клонирование форка на рабочий стол, перебазирование личного форка на исходный репозиторий
|
||||
|
||||
```
|
||||
u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
|
||||
$ git remote add upstream http://uit.mpei.ru/git/main/python-labs.git
|
||||
|
||||
u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
|
||||
$ git fetch upstream
|
||||
From http://uit.mpei.ru/git/main/python-labs
|
||||
* [new branch] main -> upstream/main
|
||||
|
||||
u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
|
||||
$ git stash push
|
||||
No local changes to save
|
||||
|
||||
u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
|
||||
$ git rebase upstream/main
|
||||
Current branch main is up to date.
|
||||
|
||||
u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
|
||||
$ git stash pop
|
||||
No stash entries found.
|
||||
```
|
||||
|
||||
## 2. Запуск Питона
|
||||
|
||||
## 2.1 Изучение интерпретатора
|
||||
|
||||
>>> print("Hello")
|
||||
Hello
|
||||
|
||||
>>> h=input("Your name=")
|
||||
Your name=Lizp
|
||||
|
||||
>>> exit()
|
||||
|
||||
## 3. Ввод интрукций настройки рабочего каталога среды
|
||||
|
||||
import os
|
||||
|
||||
os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova\\TEMA1\\")
|
||||
|
||||
## 4. Создание файла "Программа по теме 1", её запуск
|
||||
|
||||
#Программа по теме 1 Лыковой Е.А
|
||||
|
||||
print("Hello")
|
||||
|
||||
h=input("Your name=")
|
||||
|
||||
import os
|
||||
|
||||
os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova")
|
||||
|
||||
|
||||
## 5. Запуск программы prb1.py из рабочего каталога
|
||||
|
||||
## 5.1 Попытка открыть файл Pr0.cpython-311 из каталога `pycache`.
|
||||
При попытке открыть файл в текстовом редакторе человек вместо привычных букв увидит странные символы и/или надписи NUL.
|
||||
Так происходит из-за того, что информация записана в двоичном коде. Компиляция программ происходит для преобразования текста в машинный код, оптимизации.
|
||||
|
||||
## 6. Создание файла "Протокол по теме 1"
|
||||
|
||||
## 6.1 Изучение раздела Help.
|
||||
В этом разделе можно найти актуальную информацию про IDLE, по типу версии, обновлений, лицензии. Так же здесь присутсвует краткий гайд для использования программы.
|
||||
В наличии так же демо-версия программы TURTLE и справочник по Python.
|
||||
|
||||
## 6.2
|
||||
|
||||
help(print)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
|
||||
help(print),help(input)
|
||||
Help on built-in function print in module builtins:
|
||||
|
||||
print(*args, sep=' ', end='\n', file=None, flush=False)
|
||||
Prints the values to a stream, or to sys.stdout by default.
|
||||
|
||||
sep
|
||||
string inserted between values, default a space.
|
||||
end
|
||||
string appended after the last value, default a newline.
|
||||
file
|
||||
a file-like object (stream); defaults to the current sys.stdout.
|
||||
flush
|
||||
whether to forcibly flush the stream.
|
||||
|
||||
Help on built-in function input in module builtins:
|
||||
|
||||
input(prompt='', /)
|
||||
Read a string from standard input. The trailing newline is stripped.
|
||||
|
||||
The prompt string, if given, is printed to standard output without a
|
||||
trailing newline before reading input.
|
||||
|
||||
If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
|
||||
On *nix systems, readline is used if available.
|
||||
|
||||
(None, None)
|
||||
|
||||
## 7. Перемещение между различными окнами программы благодаря Window. В TURTLE присутсвуют готовые примеры программ с доступным кодом.
|
||||
@ -1,59 +0,0 @@
|
||||
# File: tdemo_chaos.py
|
||||
# Author: Gregor Lingl
|
||||
# Date: 2009-06-24
|
||||
|
||||
# A demonstration of chaos
|
||||
|
||||
from turtle import *
|
||||
|
||||
N = 80
|
||||
|
||||
def f(x):
|
||||
return 3.9*x*(1-x)
|
||||
|
||||
def g(x):
|
||||
return 3.9*(x-x**2)
|
||||
|
||||
def h(x):
|
||||
return 3.9*x-3.9*x*x
|
||||
|
||||
def jumpto(x, y):
|
||||
penup(); goto(x,y)
|
||||
|
||||
def line(x1, y1, x2, y2):
|
||||
jumpto(x1, y1)
|
||||
pendown()
|
||||
goto(x2, y2)
|
||||
|
||||
def coosys():
|
||||
line(-1, 0, N+1, 0)
|
||||
line(0, -0.1, 0, 1.1)
|
||||
|
||||
def plot(fun, start, color):
|
||||
pencolor(color)
|
||||
x = start
|
||||
jumpto(0, x)
|
||||
pendown()
|
||||
dot(5)
|
||||
for i in range(N):
|
||||
x=fun(x)
|
||||
goto(i+1,x)
|
||||
dot(5)
|
||||
|
||||
def main():
|
||||
reset()
|
||||
setworldcoordinates(-1.0,-0.1, N+1, 1.1)
|
||||
speed(0)
|
||||
hideturtle()
|
||||
coosys()
|
||||
plot(f, 0.35, "blue")
|
||||
plot(g, 0.35, "green")
|
||||
plot(h, 0.35, "red")
|
||||
# Now zoom in:
|
||||
for s in range(100):
|
||||
setworldcoordinates(0.5*s,-0.1, N+1, 1.1)
|
||||
return "Done!"
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
mainloop()
|
||||
@ -1,11 +0,0 @@
|
||||
# Индивидуальное контрольное задание по теме 1
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## Задание
|
||||
|
||||
Для чего предназначено предложение "Окно (Window)" главного меню?
|
||||
|
||||
## Ответ
|
||||
|
||||
Предложение "Окно"("Window") главного меню предназначено для возможности быстрого перемещения между окнами программы, благодаря выпадающему меню, в котором записаны все открытые на данный момпент файлы.
|
||||
@ -1,484 +0,0 @@
|
||||
# Отчет по теме 2
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## 1. Запуск IDLE, привязка католога, создание файла отчета.
|
||||
|
||||
```py
|
||||
import os
|
||||
os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA2\\")
|
||||
```
|
||||
|
||||
## 2. Изучение простых объектов, операции присваивания.
|
||||
|
||||
```py
|
||||
f1 = 16; f2 = 3
|
||||
f1,f2
|
||||
(16, 3)
|
||||
f1;f2
|
||||
16
|
||||
3
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
|
||||
dir(f1)
|
||||
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
|
||||
type(f2)
|
||||
<class 'int'>
|
||||
del f1,f2
|
||||
dir()
|
||||
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
|
||||
```
|
||||
|
||||
## 3. Изучение правил наименования объектов.
|
||||
|
||||
```py
|
||||
gg1 = 1.6
|
||||
hh1 = "Строка"
|
||||
73sr = 3
|
||||
SyntaxError: invalid decimal literal
|
||||
and = 7
|
||||
SyntaxError: invalid syntax
|
||||
```
|
||||
|
||||
## 4. Список ключевых слов.
|
||||
|
||||
```py
|
||||
import keyword
|
||||
keyword.kwlist
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
keyword_list = keyword.kwlist
|
||||
```
|
||||
|
||||
## 5. Список встроенных идентификаторов.
|
||||
|
||||
```py
|
||||
dir(builtins)
|
||||
['ArithmeticError', 'AssertionError', 'AttributeError',
|
||||
'BaseException', 'BaseExceptionGroup', 'BlockingIOError',
|
||||
'BrokenPipeError', 'BufferError', 'BytesWarning',
|
||||
'ChildProcessError',...]
|
||||
help(abs)
|
||||
Help on built-in function abs in module builtins:
|
||||
|
||||
abs(x, /)
|
||||
Return the absolute value of the argument.
|
||||
|
||||
help (len)
|
||||
Help on built-in function len in module builtins:
|
||||
|
||||
len(obj, /)
|
||||
Return the number of items in a container.
|
||||
|
||||
help(max)
|
||||
Help on built-in function max in module builtins:
|
||||
|
||||
max(...)
|
||||
max(iterable, *[, default=obj, key=func]) -> value
|
||||
max(arg1, arg2, *args, *[, key=func]) -> value
|
||||
|
||||
With a single iterable argument, return its biggest item. The
|
||||
default keyword-only argument specifies an object to return if
|
||||
the provided iterable is empty.
|
||||
With two or more positional arguments, return the largest argument.
|
||||
|
||||
help(min)
|
||||
Help on built-in function min in module builtins:
|
||||
|
||||
min(...)
|
||||
min(iterable, *[, default=obj, key=func]) -> value
|
||||
min(arg1, arg2, *args, *[, key=func]) -> value
|
||||
|
||||
With a single iterable argument, return its smallest item. The
|
||||
default keyword-only argument specifies an object to return if
|
||||
the provided iterable is empty.
|
||||
With two or more positional arguments, return the smallest argument.
|
||||
|
||||
help(pow)
|
||||
Help on built-in function pow in module builtins:
|
||||
|
||||
pow(base, exp, mod=None)
|
||||
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
|
||||
|
||||
Some types, such as ints, are able to use a more efficient algorithm when
|
||||
invoked using the three argument form.
|
||||
|
||||
help (round)
|
||||
Help on built-in function round in module builtins:
|
||||
|
||||
round(number, ndigits=None)
|
||||
Round a number to a given precision in decimal digits.
|
||||
|
||||
The return value is an integer if ndigits is omitted or None. Otherwise
|
||||
the return value has the same type as the number. ndigits may be negative.
|
||||
|
||||
help(sorted)
|
||||
Help on built-in function sorted in module builtins:
|
||||
|
||||
sorted(iterable, /, *, key=None, reverse=False)
|
||||
Return a new list containing all items from the iterable in ascending order.
|
||||
|
||||
A custom key function can be supplied to customize the sort order, and the
|
||||
reverse flag can be set to request the result in descending order.
|
||||
|
||||
help (sum)
|
||||
Help on built-in function sum in module builtins:
|
||||
|
||||
sum(iterable, /, start=0)
|
||||
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
|
||||
|
||||
When the iterable is empty, return the start value.
|
||||
This function is intended specifically for use with numeric values and may
|
||||
reject non-numeric types.
|
||||
|
||||
help(zip)
|
||||
Help on class zip in module builtins:
|
||||
|
||||
class zip(object)
|
||||
| zip(*iterables, strict=False)
|
||||
|
|
||||
| The zip object yields n-length tuples, where n is the number of iterables
|
||||
| passed as positional arguments to zip(). The i-th element in every tuple
|
||||
| comes from the i-th iterable argument to zip(). This continues until the
|
||||
| shortest argument is exhausted.
|
||||
|
|
||||
| If strict is true and one of the arguments is exhausted before the others,
|
||||
| raise a ValueError.
|
||||
|
|
||||
| >>> list(zip('abcdefg', range(3), range(4)))
|
||||
| [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
|
||||
|
|
||||
| Methods defined here:
|
||||
|
|
||||
| __getattribute__(self, name, /)
|
||||
| Return getattr(self, name).
|
||||
|
|
||||
| __iter__(self, /)
|
||||
| Implement iter(self).
|
||||
|
|
||||
| __next__(self, /)
|
||||
| Implement next(self).
|
||||
|
|
||||
| __reduce__(self, /)
|
||||
| Return state information for pickling.
|
||||
|
|
||||
| __setstate__(self, object, /)
|
||||
| Set state information for unpickling.
|
||||
|
|
||||
| ----------------------------------------------------------------------
|
||||
| Static methods defined here:
|
||||
|
|
||||
| __new__(*args, **kwargs)
|
||||
| Create and return a new object. See help(type) for accurate signature.
|
||||
|
||||
abs(-5)
|
||||
5
|
||||
len('primer')
|
||||
6
|
||||
max(9,8,3)
|
||||
9
|
||||
min(9,8,3)
|
||||
3
|
||||
pow(2,3)
|
||||
8
|
||||
round (5.2381, 2)
|
||||
5.24
|
||||
pack = (2,5,1,0,4)
|
||||
sorted(pack)
|
||||
[0, 1, 2, 4, 5]
|
||||
sum(pack)
|
||||
12
|
||||
pack2 = ('A','B','C','D','E')
|
||||
fullpack = list(zip(pack,pack2))
|
||||
print(fullpack)
|
||||
[(2, 'A'), (5, 'B'), (1, 'C'), (0, 'D'), (4, 'E')]
|
||||
```
|
||||
|
||||
## 6. Убеждаемся, что малые и большие буквы в именах объектов различаются.
|
||||
|
||||
```py
|
||||
Gg1=45
|
||||
gg1,Gg1
|
||||
(1.6, 45)
|
||||
```
|
||||
|
||||
## 7. Изучение простых базовых типов объектов.
|
||||
|
||||
## 7.1. Логический тип
|
||||
|
||||
```py
|
||||
bb1=True;bb2=False
|
||||
bb1,bb2
|
||||
(True, False)
|
||||
type(bb1)
|
||||
<class 'bool'>
|
||||
```
|
||||
|
||||
## 7.2. Остальные типы
|
||||
|
||||
```py
|
||||
ii1=-1234567890
|
||||
ii1
|
||||
-1234567890
|
||||
type(ii1)
|
||||
<class 'int'>
|
||||
ff1=-8.9876e-12
|
||||
ff1
|
||||
-8.9876e-12
|
||||
type(ff1)
|
||||
<class 'float'>
|
||||
dv1=0b1101010
|
||||
type(dv1)
|
||||
<class 'int'>
|
||||
vsm1=0o52765
|
||||
vsm1
|
||||
22005
|
||||
type(vsm1)
|
||||
<class 'int'>
|
||||
shest1=0x7109af6
|
||||
shest1
|
||||
118528758
|
||||
type(shest1)
|
||||
<class 'int'>
|
||||
cc1=2-3j
|
||||
cc1
|
||||
(2-3j)
|
||||
type(cc1)
|
||||
<class 'complex'>
|
||||
a=3.67;b=-0.45
|
||||
cc2=complex(a,b)
|
||||
cc2
|
||||
(3.67-0.45j)
|
||||
```
|
||||
|
||||
## 7.3 Символьная строка.
|
||||
|
||||
```py
|
||||
ss1='Это-строка символов'
|
||||
ss1="Это-строка символов"
|
||||
ssa1 = "Это - \"строка символов\", \n \t выводимая на двух строках"
|
||||
print(ssa1)
|
||||
Это - "строка символов",
|
||||
выводимая на двух строках
|
||||
ss1b = 'Меня зовут: \n Лыкова Е.А'
|
||||
print(ss1b)
|
||||
Меня зовут:
|
||||
Лыкова Е.А
|
||||
mnogo = """Нетрудно заметить, что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвут в операции."""
|
||||
print(mnogo)
|
||||
Нетрудно заметить, что в результате операции
|
||||
над числами разных типов получается число,
|
||||
имеющее более сложный тип из тех, которые участвут в операции.
|
||||
ss1[0]
|
||||
'Э'
|
||||
ss1[8]
|
||||
'к'
|
||||
ss1[-2]
|
||||
'о'
|
||||
ss1[6:9]
|
||||
'рок'
|
||||
ss1[13:]
|
||||
'мволов'
|
||||
ss1[5:-8]
|
||||
'трока '
|
||||
ss1[3:17:2]
|
||||
'-тоасмо'
|
||||
ss1[17:3:-2]
|
||||
'оомсаот'
|
||||
ss1[-4:3:-2]
|
||||
'омсаот'
|
||||
ss1[4]='='
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#82>", line 1, in <module>
|
||||
ss1[4]='='
|
||||
TypeError: 'str' object does not support item assignment
|
||||
ss1=ss1[:4]+'='+ss1[5:]
|
||||
ss1
|
||||
'Это-=трока символов'
|
||||
print(ss1b)
|
||||
Меня зовут:
|
||||
Лыкова Е.А
|
||||
ss1b[5:8]
|
||||
'зов'
|
||||
ss1b[::-2]
|
||||
'АЕаоы твзяе'
|
||||
ss1b[-6:10:3]
|
||||
''
|
||||
```
|
||||
|
||||
## 8. Изучение более сложных типов объектов.
|
||||
|
||||
## 8.1 Списки.
|
||||
|
||||
```py
|
||||
spis1 = [111,'Spisok',5-9j]
|
||||
spis1
|
||||
[111, 'Spisok', (5-9j)]
|
||||
stup = [0,0,1,1,1,1,1,1,1]
|
||||
stup
|
||||
[0, 0, 1, 1, 1, 1, 1, 1, 1]
|
||||
spis = [1,2,3,4,
|
||||
5,6,7,
|
||||
8,9,10]
|
||||
spis
|
||||
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
spis[-1]
|
||||
10
|
||||
stup[-8::2]
|
||||
[0, 1, 1, 1]
|
||||
```
|
||||
|
||||
В этот список вошло четыре элемента. В исходном списке они имели индексы 1, 3, 5, 7
|
||||
|
||||
```py
|
||||
spis1[1] = 'Список'
|
||||
spis1
|
||||
[111, 'Список', (5-9j)]
|
||||
len(spis1)
|
||||
3
|
||||
dir(spis1)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
|
||||
help(spis1.append)
|
||||
Help on built-in function append:
|
||||
|
||||
append(object, /) method of builtins.list instance
|
||||
Append object to the end of the list.
|
||||
|
||||
spis1.append('New item')
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item']
|
||||
spis1+['New item']
|
||||
[111, 'Список', (5-9j), 'New item', 'New item']
|
||||
spis1.append(ss1b)
|
||||
spis1
|
||||
[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
|
||||
spis1.pop(1)
|
||||
'Список'
|
||||
spis1
|
||||
[111, (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
|
||||
spis1.insert(1, 'Vesch')
|
||||
spis1
|
||||
[111, 'Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
|
||||
spis1.remove(111)
|
||||
spis1
|
||||
['Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
|
||||
spis1.extend(['lol'])
|
||||
spis1
|
||||
['Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А', 'lol']
|
||||
spis1.clear()
|
||||
spis1
|
||||
[]
|
||||
spisnew = [ 'V', 'C', 'O', 'S']
|
||||
spisnew.sort()
|
||||
spisnew
|
||||
['C', 'O', 'S', 'V']
|
||||
spisnew.reverse()
|
||||
spisnew
|
||||
['V', 'S', 'O', 'C']
|
||||
spisnew.copy()
|
||||
['V', 'S', 'O', 'C']
|
||||
spiscopy = spisnew.copy()
|
||||
spiscopy
|
||||
['V', 'S', 'O', 'C']
|
||||
spisnew.count('O')
|
||||
1
|
||||
spisnew.index('O')
|
||||
2
|
||||
spis2=[spis1,[4,5,6,7]]
|
||||
spis2[0][1]
|
||||
'Spisok'
|
||||
spis2[0][1]=78
|
||||
spis2
|
||||
[[111, 78, (5-9j)], [4, 5, 6, 7]]
|
||||
spis1
|
||||
[111, 78, (5-9j)]
|
||||
```
|
||||
|
||||
Объект spis1 отличается от своего изначального вида, поскольку мы использовали на нём различные функции,
|
||||
которые добавляли, убирали и изменяли объекты в нём.
|
||||
|
||||
```py
|
||||
spisochek = [17, 17, 17, 16]
|
||||
moispisok = [1991, 'Stroka', False, spisochek]
|
||||
moispisok
|
||||
[1991, 'Stroka', False, [17, 17, 17, 16]]
|
||||
```
|
||||
|
||||
## 8.2 Объект-кортеж
|
||||
|
||||
```py
|
||||
kort1 = (222,'Kortezh',77+8j)
|
||||
kort1 = kort1 + (1,2)
|
||||
kort1 = kort1 + (ss1b,)
|
||||
kort2 = kort1[:2]+kort1[3:]
|
||||
kort2.index(2)
|
||||
3
|
||||
kort1.count(222)
|
||||
1
|
||||
kort1[2]=90
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#177>", line 1, in <module>
|
||||
kort1[2]=90
|
||||
TypeError: 'tuple' object does not support item assignment
|
||||
moikort = (2005,'StrokaNovaya',spisochek,kort1)
|
||||
moikort
|
||||
(2005, 'StrokaNovaya', [17, 17, 17, 16], (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Лыкова Е.А'))
|
||||
```
|
||||
|
||||
## 8.3. Объект-словарь
|
||||
|
||||
```py
|
||||
dic1={'Saratov':145,'Orel':56,'Vologda':45}
|
||||
dic1['Orel']
|
||||
56
|
||||
dic1['Pskov']=78
|
||||
dic1
|
||||
{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
|
||||
sorted(dic1.keys())
|
||||
['Orel', 'Pskov', 'Saratov', 'Vologda']
|
||||
sorted(dic1.values())
|
||||
[45, 56, 78, 145]
|
||||
dic2={1:'mean',2:'standart devation',3:'correlation'}
|
||||
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
|
||||
dic3['statistics'][2]
|
||||
'standart devation'
|
||||
dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
|
||||
dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
|
||||
dic4
|
||||
{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Лыкова Е.А'}
|
||||
dic5
|
||||
{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Лыкова Е.А'}
|
||||
kortezh = ('A','B','C','D','E','F','G')
|
||||
spisok = (1,2,3,4,5)
|
||||
slovar = dict(zip(kortezh,spisok))
|
||||
print(slovar,len(slovar))
|
||||
{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5} 5
|
||||
```
|
||||
|
||||
## 8.4. Объект-множество
|
||||
|
||||
```py
|
||||
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
|
||||
mnoz1
|
||||
{'микропроцессор', 'линия связи', 'датчик', 'двигатель'}
|
||||
len(mnoz1)
|
||||
4
|
||||
'датчик' in mnoz1
|
||||
True
|
||||
mnoz1.add('реле')
|
||||
mnoz1.remove('линия связи')
|
||||
mnoz1
|
||||
{'микропроцессор', 'двигатель', 'датчик', 'реле'}
|
||||
mnozestvo = {'огурец','дикий огурец','кукуруза'}
|
||||
len(mnozestvo)
|
||||
3
|
||||
'кукуруза' in mnozestvo
|
||||
True
|
||||
mnozestvo.add('кукуруза сейчас')
|
||||
mnozestvo
|
||||
{'дикий огурец', 'огурец', 'кукуруза сейчас', 'кукуруза'}
|
||||
mnozestvo.remove('огурец')
|
||||
mnozestvo
|
||||
{'дикий огурец', 'кукуруза сейчас', 'кукуруза'}
|
||||
```
|
||||
@ -1,33 +0,0 @@
|
||||
# Общее контрольное задание по теме 2
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## Задание
|
||||
|
||||
Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия.
|
||||
|
||||
## Решение
|
||||
|
||||
```py
|
||||
familia = 'Lykova'
|
||||
sovpad = familia[0]
|
||||
import keyword
|
||||
sp_kw = keyword.kwlist
|
||||
sp_kw
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
sp_kw.remove('nonlocal')
|
||||
sp_kw
|
||||
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
|
||||
kort_nam = ('Елизавета','Екатерина','Дмитрий','Даниил')
|
||||
print('Тип переменной:', type(kort_nam))
|
||||
Тип переменной: <class 'tuple'>
|
||||
kort_nam = kort_nam + ('Иван','Федор')
|
||||
kort_nam
|
||||
('Елизавета', 'Екатерина', 'Дмитрий', 'Даниил', 'Иван', 'Федор')
|
||||
count = kort_nam.count('Дима')
|
||||
count
|
||||
0
|
||||
dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
|
||||
dict_bas
|
||||
{'Строка': 'Lykova', 'Список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'Кортеж': ('Елизавета', 'Екатерина', 'Дмитрий', 'Даниил', 'Иван', 'Федор')}
|
||||
```
|
||||
@ -1,23 +0,0 @@
|
||||
# Индивидуальное контрольное задание по теме 2
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## Задание
|
||||
|
||||
Пусть создан объект dd = [11,2,-4,23,12,56]
|
||||
К какому классу он относится? Как расположить его элементы в порядке убывания?
|
||||
|
||||
## Решение
|
||||
|
||||
```py
|
||||
dd = [11,2,-4,23,12,56]
|
||||
print('Класс объекта:', type(dd))
|
||||
Класс объекта: <class 'list'>
|
||||
dd.sort(reverse=True)
|
||||
dd
|
||||
[56, 23, 12, 11, 2, -4]
|
||||
# Ещё можно вот так (создается новый список)
|
||||
dds = sorted(dd, reverse=True)
|
||||
dds
|
||||
[56, 23, 12, 11, 2, -4]
|
||||
```
|
||||
@ -1,680 +0,0 @@
|
||||
# Отчет по теме 3
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## 1. Запуск IDLE, привязка католога, создание файла отчета.
|
||||
|
||||
```py
|
||||
import os
|
||||
os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA3")
|
||||
```
|
||||
|
||||
## 2. Преобразование простых базовых типов объектов.
|
||||
|
||||
## 2.1 Логическая функция bool.
|
||||
|
||||
```py
|
||||
logiz1 = bool(56)
|
||||
logiz1, type(logiz1)
|
||||
(True, <class 'bool'>)
|
||||
logiz2 = bool(0)
|
||||
logiz2, type(logiz2)
|
||||
(False, <class 'bool'>)
|
||||
logiz3 = bool("Beta")
|
||||
logiz3, type(logiz3)
|
||||
(True, <class 'bool'>)
|
||||
logiz4 = bool("")
|
||||
logiz4, type(logiz4)
|
||||
(False, <class 'bool'>)
|
||||
```
|
||||
|
||||
## 2.2.1 Функция int.
|
||||
|
||||
```py
|
||||
tt1 = int(198.6)
|
||||
tt1, type(tt1)
|
||||
(198, <class 'int'>)
|
||||
tt2 = int('-76')
|
||||
tt2, type(tt2)
|
||||
(-76, <class 'int'>)
|
||||
tt3 = int('B',16)
|
||||
tt3, type(tt3)
|
||||
(11, <class 'int'>)
|
||||
tt4 = int('71',8)
|
||||
tt4, type(tt4)
|
||||
(57, <class 'int'>)
|
||||
tt5 = int('98.76')
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#19>", line 1, in <module>
|
||||
tt5 = int('98.76')
|
||||
ValueError: invalid literal for int() with base 10: '98.76'
|
||||
```
|
||||
|
||||
Диагностическое сообщение было выведено из-за того, что int ожидает в кавычках целое число, а не дробное.
|
||||
|
||||
## 2.2.2 Функция float.
|
||||
|
||||
```py
|
||||
flt1 = float(789)
|
||||
flt1, type(flt1)
|
||||
(789.0, <class 'float'>)
|
||||
flt2 = float(-6.78e2)
|
||||
flt2, type(flt2)
|
||||
(-678.0, <class 'float'>)
|
||||
flt3 = float('Infinity')
|
||||
flt3, type(flt3)
|
||||
(inf, <class 'float'>)
|
||||
flt4 = float('-inf')
|
||||
flt4, type(flt4)
|
||||
(-inf, <class 'float'>)
|
||||
```
|
||||
|
||||
## 2.3. Другие системы счисления.
|
||||
|
||||
```py
|
||||
hh = 123
|
||||
dv1 = bin(hh)
|
||||
dv1
|
||||
'0b1111011'
|
||||
vos1 = oct(hh)
|
||||
vos1
|
||||
'0o173'
|
||||
shs1 = hex(hh)
|
||||
shs1
|
||||
'0x7b'
|
||||
int(dv1,2)
|
||||
123
|
||||
int(vos1,8)
|
||||
123
|
||||
int(shs1,16)
|
||||
123
|
||||
```
|
||||
|
||||
## 3. Сложные базовые типы объектов.
|
||||
|
||||
## 3.1 Функция str.
|
||||
|
||||
```py
|
||||
strk1 = str(23.6)
|
||||
strk1, type(strk1)
|
||||
('23.6', <class 'str'>)
|
||||
strk2 = str(logiz3)
|
||||
strk2, type(strk2)
|
||||
('True', <class 'str'>)
|
||||
strk3 = str(['A','B','C'])
|
||||
strk3, type(strk3)
|
||||
("['A', 'B', 'C']", <class 'str'>)
|
||||
strk4 = str(('A','B','C'))
|
||||
strk4, type(strk4)
|
||||
("('A', 'B', 'C')", <class 'str'>)
|
||||
strk5 = str({'A':1,'B':2,'C':9})
|
||||
strk5, type(strk5)
|
||||
("{'A': 1, 'B': 2, 'C': 9}", <class 'str'>)
|
||||
```
|
||||
|
||||
## 3.2 Функция list.
|
||||
|
||||
```py
|
||||
spis1 = list('Строка символов')
|
||||
spis1, type(spis1)
|
||||
(['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'], <class 'list'>)
|
||||
spis2 = list((124,236,-15,908))
|
||||
spis2, type(spis2)
|
||||
([124, 236, -15, 908], <class 'list'>)
|
||||
spis3 = list({'A':1,'B':2,'C':9})
|
||||
spis3, type(spis3)
|
||||
(['A', 'B', 'C'], <class 'list'>)
|
||||
# Список со значениями
|
||||
spis4 = list({'A':1,'B':2,'C':9}.values())
|
||||
spis4, type(spis4)
|
||||
([1, 2, 9], <class 'list'>)
|
||||
# Словарь полностью
|
||||
spis4 = list({'A':1,'B':2,'C':9}.items())
|
||||
spis4, type(spis4)
|
||||
([('A', 1), ('B', 2), ('C', 9)], <class 'list'>)
|
||||
```
|
||||
|
||||
## 3.3 Функция tuple.
|
||||
|
||||
```py
|
||||
kort7=tuple('Строка символов')
|
||||
kort7, type(kort7)
|
||||
(('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'), <class 'tuple'>)
|
||||
kort8 = tuple(spis2)
|
||||
kort8, type(kort8)
|
||||
((124, 236, -15, 908), <class 'tuple'>)
|
||||
kort9 = tuple({'A':1,'B':2,'C':9})
|
||||
kort9, type(kort9)
|
||||
(('A', 'B', 'C'), <class 'tuple'>)
|
||||
```
|
||||
|
||||
## 3.4 Удаление объектов.
|
||||
|
||||
```py
|
||||
del strk5, kort8
|
||||
print(strk5)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#9>", line 1, in <module>
|
||||
print(strk5)
|
||||
NameError: name 'strk5' is not defined
|
||||
print(kort8)
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#10>", line 1, in <module>
|
||||
print(kort8)
|
||||
NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
|
||||
imya = 'Lykova E.A'
|
||||
imya
|
||||
'Lykova E.A'
|
||||
spis = list(imya)
|
||||
spis
|
||||
['L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A']
|
||||
kort = tuple(spis)
|
||||
kort
|
||||
('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')
|
||||
strk = str(kort)
|
||||
strk
|
||||
"('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')"
|
||||
```
|
||||
|
||||
## 4. Арифметические операции.
|
||||
|
||||
## 4.1 Сложение и вычитание.
|
||||
|
||||
```py
|
||||
12+7+90
|
||||
109
|
||||
5.689e-1-0.456
|
||||
0.11289999999999994
|
||||
23.6 + 54
|
||||
77.6
|
||||
14 - 56.7 + 89
|
||||
46.3
|
||||
```
|
||||
|
||||
## 4.2 Умножение.
|
||||
|
||||
```py
|
||||
-6.7 * 12
|
||||
-80.4
|
||||
```
|
||||
|
||||
## 4.3 Деление.
|
||||
|
||||
```py
|
||||
-234.5/6
|
||||
-39.083333333333336
|
||||
a = 178/45
|
||||
a, type(a)
|
||||
(3.9555555555555557, <class 'float'>)
|
||||
```
|
||||
|
||||
## 4.4 Деление с округлением вниз.
|
||||
|
||||
```py
|
||||
b = 178//45
|
||||
b, type(b)
|
||||
(3, <class 'int'>)
|
||||
c = -24.6//12.1
|
||||
c, type(c)
|
||||
(-3.0, <class 'float'>)
|
||||
d = 178//12.1
|
||||
d, type(d)
|
||||
(14.0, <class 'float'>)
|
||||
e = -24.6//45
|
||||
e, type(e)
|
||||
(-1.0, <class 'float'>)
|
||||
```
|
||||
|
||||
## 4.5 Остаток от деления.
|
||||
|
||||
```py
|
||||
148%33
|
||||
16
|
||||
12.6%3.8
|
||||
1.2000000000000002
|
||||
148%3.8
|
||||
3.6000000000000068
|
||||
12.6%33
|
||||
12.6
|
||||
```
|
||||
|
||||
## 4.6 Возведение в степень.
|
||||
|
||||
```py
|
||||
14**3
|
||||
2744
|
||||
e = 2.7**3.6
|
||||
e
|
||||
35.719843790663525
|
||||
14**3.6
|
||||
13367.830445904418
|
||||
2.7**3
|
||||
19.683000000000003
|
||||
c1 = 3 + 4j
|
||||
c2 = 1 - 2j
|
||||
c1 + c2
|
||||
(4+2j)
|
||||
c1 - c2
|
||||
(2+6j)
|
||||
c1 * c2
|
||||
(11-2j)
|
||||
c1/c2
|
||||
(-1+2j)
|
||||
c1//c2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#50>", line 1, in <module>
|
||||
c1//c2
|
||||
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
|
||||
c1%c2
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#51>", line 1, in <module>
|
||||
c1%c2
|
||||
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||
c1** 2
|
||||
(-7+24j)
|
||||
```
|
||||
|
||||
Как мы видим, для работы с комплексными числами нельзя применять операции остатка от деления и деление с округлением вниз.
|
||||
|
||||
## 5. Операции с двоичным представдением целых чисел.
|
||||
|
||||
## 5.1 Двоичная инверсия.
|
||||
|
||||
```py
|
||||
dv1 = 9
|
||||
dv2 = ~dv1
|
||||
bin(dv1)
|
||||
'0b1001'
|
||||
dv2
|
||||
-10
|
||||
bin(dv2)
|
||||
'-0b1010'
|
||||
```
|
||||
|
||||
## 5.2 Двоичное 'И'.
|
||||
|
||||
```py
|
||||
7&9
|
||||
1
|
||||
bin(7&9)
|
||||
'0b1'
|
||||
7&8
|
||||
0
|
||||
bin(7&8)
|
||||
'0b0'
|
||||
```
|
||||
|
||||
## 5.3 Двоичное 'ИЛИ'.
|
||||
|
||||
```py
|
||||
7|9
|
||||
15
|
||||
bin(7|9)
|
||||
'0b1111'
|
||||
7|8
|
||||
15
|
||||
bin(7|8)
|
||||
'0b1111'
|
||||
14|5
|
||||
15
|
||||
bin(14|5)
|
||||
'0b1111'
|
||||
```
|
||||
|
||||
## 5.4 Двоичное исключающее 'ИЛИ'.
|
||||
|
||||
```py
|
||||
14^5
|
||||
11
|
||||
bin(14^5)
|
||||
'0b1011'
|
||||
```
|
||||
|
||||
## 5.5 Сдвиг двоичного представления на заданное число разрядов.
|
||||
|
||||
```py
|
||||
l1 = 68
|
||||
l2 = 71
|
||||
bin(l1)
|
||||
'0b1000100'
|
||||
bin(l2)
|
||||
'0b1000111'
|
||||
bin(~l1)
|
||||
'-0b1000101'
|
||||
bin(~l2)
|
||||
'-0b1001000'
|
||||
bin(l1&l2)
|
||||
'0b1000100'
|
||||
bin(l1|l2)
|
||||
'0b1000111'
|
||||
bin(l1^l2)
|
||||
'0b11'
|
||||
bin(l1>>2)
|
||||
'0b10001'
|
||||
bin(l2<<1)
|
||||
'0b10001110'
|
||||
```
|
||||
|
||||
## 6. Операции при работе с последовательностями.
|
||||
|
||||
## 6.1 Объединение последовательностей.
|
||||
|
||||
```py
|
||||
'Система' + 'регулирования'
|
||||
'Системарегулирования'
|
||||
['abc','de','fg']+['hi','jkl']
|
||||
['abc', 'de', 'fg', 'hi', 'jkl']
|
||||
('abc','de','fg')+('hi','jkl')
|
||||
('abc', 'de', 'fg', 'hi', 'jkl')
|
||||
```
|
||||
|
||||
## 6.2 Повторение
|
||||
|
||||
```py
|
||||
'ля'*5
|
||||
'ляляляляля'
|
||||
['ку','-']*3
|
||||
['ку', '-', 'ку', '-', 'ку', '-']
|
||||
('кис','-')*4
|
||||
('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
|
||||
signal1=[0]*3+[1]*99
|
||||
signal1
|
||||
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
|
||||
signal2 = (0,)*3+(1,)*5+(0,)*7
|
||||
signal2
|
||||
(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
|
||||
```
|
||||
|
||||
## 6.3 Проверка наличия заданного элемента в последовательности.
|
||||
|
||||
```py
|
||||
stroka = 'Система автоматического управления'
|
||||
'автомат' in stroka
|
||||
True
|
||||
'ку' in ['ку','-']*3
|
||||
True
|
||||
'ля-' in ('abc','de','fg','hi','jkl')
|
||||
False
|
||||
```
|
||||
|
||||
## 6.4 Подстановка значений в строку.
|
||||
|
||||
```py
|
||||
stroka = 'Температура = %g %s %g'
|
||||
stroka
|
||||
'Температура = %g %s %g'
|
||||
stroka % (16, 'меньше', 25)
|
||||
'Температура = 16 меньше 25'
|
||||
stroka = 'Температура = %(zn1)g%(sptavn)s %(zn2)g'
|
||||
stroka
|
||||
'Температура = %(zn1)g%(sptavn)s %(zn2)g'
|
||||
stroka %{'zn1':16,'sptavn':'меньше','zn2':25}
|
||||
'Температура = 16меньше 25'
|
||||
```
|
||||
|
||||
## 7. Оператор присваивания.
|
||||
|
||||
## 7.1 Обычное присваивание.
|
||||
|
||||
```py
|
||||
zz=-12
|
||||
zz
|
||||
-12
|
||||
```
|
||||
|
||||
## 7.2 Увеличение значения на заданную величину.
|
||||
|
||||
```py
|
||||
zz+=5
|
||||
zz
|
||||
-7
|
||||
zz-=3
|
||||
zz
|
||||
-10
|
||||
stroka = 'Система'
|
||||
stroka+= 'регулирования'
|
||||
stroka
|
||||
'Системарегулирования'
|
||||
```
|
||||
|
||||
## 7.3 Умножение на заданную величину.
|
||||
|
||||
```py
|
||||
zz/=2
|
||||
zz
|
||||
-5.0
|
||||
zz*=5
|
||||
zz
|
||||
-25.0
|
||||
strokan = 'ля'
|
||||
strokan *= 5
|
||||
strokan
|
||||
'ляляляляля'
|
||||
```
|
||||
|
||||
## 7.4 Операция деления с округлением, получение остатка от деления и возведение в степень.
|
||||
|
||||
```py
|
||||
ll = 77
|
||||
ll//=3
|
||||
ll
|
||||
25
|
||||
ll%=3
|
||||
ll
|
||||
1
|
||||
ll**=7
|
||||
ll
|
||||
1
|
||||
```
|
||||
|
||||
## 7.5 Множественное присваивание.
|
||||
|
||||
```py
|
||||
w = v = 10
|
||||
n1,n2,n3=(11,-3,'all')
|
||||
w
|
||||
10
|
||||
v
|
||||
10
|
||||
n1
|
||||
11
|
||||
n2
|
||||
-3
|
||||
n3
|
||||
'all'
|
||||
a1,a2,a3 = 'na', 'no', 'nu'
|
||||
a1,a2,a3
|
||||
('na', 'no', 'nu')
|
||||
a1,a2,a3 = 'abc'
|
||||
a1,a2,a3
|
||||
('a', 'b', 'c')
|
||||
b1,b2,b3 = ['la','lo','lu']
|
||||
b1,b2,b3
|
||||
('la', 'lo', 'lu')
|
||||
c1,c2,c3 = {'ha':1,'ho':2,'he':3}
|
||||
c1,c2,c3
|
||||
('ha', 'ho', 'he')
|
||||
d1,d2,d3 = {'me','ma','mo'}
|
||||
d1,d2,d3
|
||||
('ma', 'me', 'mo')
|
||||
```
|
||||
|
||||
## 8. Логические операции.
|
||||
|
||||
## 8.1 Операции сравнения.
|
||||
|
||||
```py
|
||||
w == v
|
||||
True
|
||||
w != v
|
||||
False
|
||||
w < v
|
||||
False
|
||||
w > v
|
||||
False
|
||||
w <= v
|
||||
True
|
||||
w >= v
|
||||
True
|
||||
```
|
||||
|
||||
## 8.2 Проверка наличия заданного элемента.
|
||||
|
||||
```py
|
||||
mnoz1 = {'pen','book','pen','iPhone','table','book'}
|
||||
mnoz1
|
||||
{'pen', 'table', 'iPhone', 'book'}
|
||||
'book' in mnoz1
|
||||
True
|
||||
'cap' in mnoz1
|
||||
False
|
||||
dic1={'Saratov':145,'Orel':56,'Vologda':45}
|
||||
'Vologda' in dic1
|
||||
True
|
||||
'Pskov' in dic1
|
||||
False
|
||||
56 in dic1.values()
|
||||
True
|
||||
dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa':['A-01-15','A-02-15']}
|
||||
'UII' in dct1['Depart']
|
||||
True
|
||||
dct1['Depart'][1] == 'MM'
|
||||
False
|
||||
```
|
||||
|
||||
## 8.3 Создание больших логических выражений.
|
||||
|
||||
```py
|
||||
a = 17
|
||||
b = -6
|
||||
(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
|
||||
True
|
||||
(a < b) or ('Saratov' in dic1) or ('deck' in mnoz1)
|
||||
True
|
||||
('Saratov' in dic1) and not (a<b) and not ('pen' in mnoz1)
|
||||
False
|
||||
```
|
||||
|
||||
## 8.4 Проверка ссылок на один и тот же объект.
|
||||
|
||||
```py
|
||||
w=v=10
|
||||
w is v
|
||||
True
|
||||
w1 =['A','B']
|
||||
v1 = ['A','B']
|
||||
w1 is v1
|
||||
False
|
||||
```
|
||||
|
||||
В первом случае обе переменные присваиваются к одному уже существующему в памяти объекту, когда как во втором переменные ипсользуют два разных списка.
|
||||
|
||||
## 9. Операции с объектами, выполняемые с помощью методов.
|
||||
|
||||
```py
|
||||
stroka = 'Микропроцессорная система управления'
|
||||
dir(stroka)
|
||||
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
|
||||
```
|
||||
|
||||
## 9.1 Методы для работы со строками.
|
||||
|
||||
```py
|
||||
stroka.find('пр')
|
||||
5
|
||||
stroka.count('c')
|
||||
0
|
||||
stroka.replace('у','автоматического у')
|
||||
'Микропроцессорная система автоматического управления'
|
||||
spis22=stroka.split(' ')
|
||||
spis22
|
||||
['Микропроцессорная', 'система', 'управления']
|
||||
stroka.upper()
|
||||
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||
stroka3=''.join(spis22)
|
||||
stroka3
|
||||
'Микропроцессорнаясистемауправления'
|
||||
stroka3.partition('с')
|
||||
('Микропроце', 'с', 'сорнаясистемауправления')
|
||||
stroka3.rpartition('с')
|
||||
('Микропроцессорнаяси', 'с', 'темауправления')
|
||||
strk1='Момент времени {}, значение = {}'
|
||||
strk1.format(1,89.7)
|
||||
'Момент времени 1, значение = 89.7'
|
||||
strk2 = 'Момент времени {1}, значение = {0}:{2}'
|
||||
strk2.format(36.7,2,'норма!')
|
||||
'Момент времени 2, значение = 36.7:норма!'
|
||||
strk3 = 'Момент времени {num}, значение = {znch}'
|
||||
strk3.format(znch=89.7,num=2)
|
||||
'Момент времени 2, значение = 89.7'
|
||||
```
|
||||
|
||||
## 9.2 Методы для работы со списками.
|
||||
|
||||
```py
|
||||
spsk = [167, 'haha', 'meme', 89.7, 'sasalele']
|
||||
dir(spsk)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
|
||||
spsk.pop(2)
|
||||
'meme'
|
||||
spsk.append('с')
|
||||
spsk
|
||||
[167, 'haha', 89.7, 'sasalele', 'с']
|
||||
spsk.insert(2,'a')
|
||||
spsk
|
||||
[167, 'haha', 'a', 89.7, 'sasalele', 'с']
|
||||
spsk.count('a')
|
||||
1
|
||||
```
|
||||
|
||||
## 9.3 Методы работы с кортежом.
|
||||
|
||||
```py
|
||||
tupl = (178, 'nana', 'jaja', 456, 90.4)
|
||||
dir(tupl)
|
||||
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
|
||||
tupl.count(456)
|
||||
1
|
||||
tupl.index('nana')
|
||||
1
|
||||
```
|
||||
|
||||
## 9.4 Методы словарей и множеств.
|
||||
|
||||
```py
|
||||
slvr = {'A':'wot','B':45,'C':39,'D':'meme','F':'pepe'}
|
||||
slvr
|
||||
{'A': 'wot', 'B': 45, 'C': 39, 'D': 'meme', 'F': 'pepe'}
|
||||
dir(slvr)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
|
||||
slvr.keys()
|
||||
dict_keys(['A', 'B', 'C', 'D', 'F'])
|
||||
slvr.items()
|
||||
dict_items([('A', 'wot'), ('B', 45), ('C', 39), ('D', 'meme'), ('F', 'pepe')])
|
||||
slvr.values()
|
||||
dict_values(['wot', 45, 39, 'meme', 'pepe'])
|
||||
slvr.get('A')
|
||||
'wot'
|
||||
mnozh = {'haha', 763, 'ikk', 98.6, 'fsfs'}
|
||||
dir(mnozh)
|
||||
['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
|
||||
mnozh.pop()
|
||||
98.6
|
||||
mnozh.pop()
|
||||
'fsfs'
|
||||
mnozh
|
||||
{763, 'haha', 'ikk'}
|
||||
mnozh.add('pfff')
|
||||
mnozh
|
||||
{'pfff', 763, 'haha', 'ikk'}
|
||||
mnozh.remove('haha')
|
||||
mnozh
|
||||
{'pfff', 763, 'ikk'}
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,61 +0,0 @@
|
||||
# Общее контрольное задание по теме 3
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## Задание
|
||||
|
||||
Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия.
|
||||
|
||||
• Преобразовать восьмеричное значение 45 в целое число.
|
||||
|
||||
• Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
|
||||
|
||||
• Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
|
||||
|
||||
• Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
|
||||
|
||||
• Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
|
||||
|
||||
• Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
|
||||
|
||||
• Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
|
||||
|
||||
## Решение
|
||||
|
||||
```py
|
||||
int('45',8)
|
||||
37
|
||||
D = {'Усиление':23,'Запаздывание':12,'Постоянная времени':78}
|
||||
D
|
||||
{'Усиление': 23, 'Запаздывание': 12, 'Постоянная времени': 78}
|
||||
D1 = list(D.keys())
|
||||
D1
|
||||
['Усиление', 'Запаздывание', 'Постоянная времени']
|
||||
D2 = list(D.values())
|
||||
D2
|
||||
[23, 12, 78]
|
||||
D3 = tuple(zip(D1,D2))
|
||||
D3
|
||||
(('Усиление', 23), ('Запаздывание', 12), ('Постоянная времени', 78))
|
||||
## В отличие от кортежа список является изменяемым.
|
||||
((1768//24.8)%3)**2.4
|
||||
5.278031643091577
|
||||
((~(13&27))^14)<<2
|
||||
-32
|
||||
spis = ['колебат']*4
|
||||
'аткол' in (spis[1] + spis[2])
|
||||
True
|
||||
dir(D)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
|
||||
D.keys()
|
||||
dict_keys(['Усиление', 'Запаздывание', 'Постоянная времени'])
|
||||
D.values()
|
||||
dict_values([23, 12, 78])
|
||||
# С помощью keys нам выводятся ключи, а с помощью values - значения.
|
||||
strk = 'Создать объект - символьную строку с текстом данного предложения.'
|
||||
strk1 = strk.split()
|
||||
strk1[strk1.index('-')] = ','
|
||||
strk1.remove('данного')
|
||||
strk1
|
||||
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
|
||||
```
|
||||
@ -1,62 +0,0 @@
|
||||
# Тест 1 Вариант 3
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## Задание
|
||||
|
||||
1) Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
|
||||
|
||||
2) Создайте объект-словарь с 6 элементами: ключи - названия звеньев в схеме регулятора ("инерционное звено1",:) (названия могут повторяться с точностью до порядкового номера), значения - список параметров соответствующего звена. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
|
||||
|
||||
3) Напишите инструкцию, позволяющую увеличить в два раза второй параметр инерционного звена в словаре. Отобразите на экране получившийся объект.
|
||||
|
||||
4) Напишите инструкции, позволяющие создать список названий звеньев из словаря. Преобразуйте этот список во множество. Отобразите полученный объект. Добавьте к полученному множеству элемент "гистерезис".
|
||||
|
||||
5) Напишите инструкцию, позволяющую подсчитать число элементов в схеме. Удалите из словаря один из его элементов. Отобразите результат.
|
||||
|
||||
## Решение
|
||||
|
||||
1) Для запуска программы, чей исходный код находится в текстовом файле с расширением .txt, можно переименовать расширение файла в .py и запустить
|
||||
|
||||
2)
|
||||
```py
|
||||
slov = {'инерционное звено1': [5,7,0],'усилительное звено': [8,3,3],'интегрирующее звено': [9,1,4],'дифференцирующее звено': [9,4,5],'пропорциональное звено': [7,2,3],'инерционное звено': [4,6,2]}
|
||||
slov
|
||||
{'инерционное звено1': [5, 7, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
|
||||
type(slov)
|
||||
<class 'dict'>
|
||||
dir(slov)
|
||||
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
|
||||
```
|
||||
|
||||
3)
|
||||
```py
|
||||
slov['инерционное звено1'][1]*=2
|
||||
slov
|
||||
{'инерционное звено1': [5, 14, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
|
||||
```
|
||||
|
||||
4)
|
||||
```py
|
||||
spis = slov.keys()
|
||||
spis
|
||||
dict_keys(['инерционное звено1', 'усилительное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено', 'инерционное звено'])
|
||||
mnoz = set(spis)
|
||||
mnoz
|
||||
{'инерционное звено1', 'усилительное звено', 'инерционное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено'}
|
||||
mnoz.add('гистерезис')
|
||||
mnoz
|
||||
{'инерционное звено1', 'усилительное звено', 'инерционное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено', 'гистерезис'}
|
||||
```
|
||||
|
||||
5)
|
||||
```py
|
||||
slov
|
||||
{'инерционное звено1': [5, 14, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
|
||||
len(slov)
|
||||
6
|
||||
slov.pop('усилительное звено')
|
||||
[8, 3, 3]
|
||||
slov
|
||||
{'инерционное звено1': [5, 14, 0], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
|
||||
```
|
||||
@ -1,542 +0,0 @@
|
||||
# Отчет по теме 4
|
||||
|
||||
Лыкова Елизавета, А-01-23
|
||||
|
||||
## 1. Запуск IDLE, привязка католога, создание файла отчета.
|
||||
|
||||
```py
|
||||
import os
|
||||
os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA4")
|
||||
```
|
||||
|
||||
## 2. Стандартные функции.
|
||||
|
||||
## 2.1 Функция round.
|
||||
|
||||
```py
|
||||
help(round)
|
||||
Help on built-in function round in module builtins:
|
||||
|
||||
round(number, ndigits=None)
|
||||
Round a number to a given precision in decimal digits.
|
||||
|
||||
The return value is an integer if ndigits is omitted or None. Otherwise
|
||||
the return value has the same type as the number. ndigits may be negative.
|
||||
|
||||
round(123.456,1)
|
||||
123.5
|
||||
round(123.456,0)
|
||||
123.0
|
||||
a = round(123.456,1)
|
||||
b = round(123.456,0)
|
||||
type(a)
|
||||
<class 'float'>
|
||||
type(b)
|
||||
<class 'float'>
|
||||
c = round(123.456)
|
||||
c
|
||||
123
|
||||
type(c)
|
||||
<class 'int'>
|
||||
```
|
||||
|
||||
В первых двух случаях типы получившихся данных - float, когда во втором - int.
|
||||
|
||||
## 2.2 Функция range.
|
||||
|
||||
```py
|
||||
gg = range(76,123,9)
|
||||
gg
|
||||
range(76, 123, 9)
|
||||
list(gg)
|
||||
[76, 85, 94, 103, 112, 121]
|
||||
range(23)
|
||||
range(0, 23)
|
||||
d = range(23)
|
||||
list(d)
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
|
||||
```
|
||||
|
||||
Диапазон начинается от нуля и заканчивается предыдущим числом заданных 23-х. Шаг - единица.
|
||||
|
||||
## 2.3 Функция zip.
|
||||
|
||||
```py
|
||||
qq = ['Лыкова','Соловьёва','Коваленко','Голощапов']
|
||||
ff = zip(gg,qq)
|
||||
tuple(ff)
|
||||
((76, 'Лыкова'), (85, 'Соловьёва'), (94, 'Коваленко'), (103, 'Голощапов'))
|
||||
print(ff[0])
|
||||
Traceback (most recent call last):
|
||||
File "<pyshell#20>", line 1, in <module>
|
||||
print(ff[0])
|
||||
TypeError: 'zip' object is not subscriptable
|
||||
tt = tuple(ff)
|
||||
tt
|
||||
((76, 'Лыкова'), (85, 'Соловьёва'), (94, 'Коваленко'), (103, 'Голощапов'))
|
||||
print(tt[1])
|
||||
(85, 'Соловьёва')
|
||||
```
|
||||
|
||||
К объекту ff можно обратиться с указанием индекса, преобразовав его в кортеж.
|
||||
|
||||
## 2.4 Функция eval.
|
||||
|
||||
```py
|
||||
fff = float(input('Коэффициент усиления='));dan = eval('5*fff-156')
|
||||
Коэффициент усиления=3
|
||||
dan
|
||||
-141.0
|
||||
```
|
||||
|
||||
## 2.5 Функция exec.
|
||||
|
||||
```py
|
||||
exec(input('Введите инструкции:'))
|
||||
Введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
||||
gg
|
||||
221.456
|
||||
```
|
||||
|
||||
## 2.6 Функции abs,pow,max,min,sum,dinmod,len,map.
|
||||
|
||||
```py
|
||||
abs(-5)
|
||||
5
|
||||
abs(10-15)
|
||||
5
|
||||
#Возвращает модуль числа
|
||||
pow(2,3)
|
||||
8
|
||||
pow(5,2)
|
||||
25
|
||||
#Возводит в степень
|
||||
chis = [4,5,2,8]
|
||||
max(chis)
|
||||
8
|
||||
min(chis)
|
||||
2
|
||||
slova = ['Радуга','Яблоко','Ананас','Груша']
|
||||
max(slova)
|
||||
'Яблоко'
|
||||
min(slova)
|
||||
'Ананас'
|
||||
#Находят максимальное и минимальное значения
|
||||
sum(chis)
|
||||
19
|
||||
sum(chis,10)
|
||||
29
|
||||
#Находит сумму элементов
|
||||
divmod(10,3)
|
||||
(3, 1)
|
||||
#Находит частное и остаток от деления
|
||||
len(chis)
|
||||
4
|
||||
строка = 'Hallo!'
|
||||
len(строка)
|
||||
6
|
||||
slov = {'a':10,'b':20,'c':30}
|
||||
len(slov)
|
||||
3
|
||||
#Возвращает количество элементов в объекте
|
||||
list(map(str,chis))
|
||||
['4', '5', '2', '8']
|
||||
list(map(lambda x:x*2,chis))
|
||||
[8, 10, 4, 16]
|
||||
#Применение функции к каждому элементу последовательности
|
||||
```
|
||||
|
||||
## 3. Функции модуля math.
|
||||
|
||||
```py
|
||||
import math
|
||||
dir(math)
|
||||
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
|
||||
help(math.factorial)
|
||||
Help on built-in function factorial in module math:
|
||||
|
||||
factorial(n, /)
|
||||
Find n!.
|
||||
|
||||
math.factorial(5)
|
||||
120
|
||||
help(math.sin)
|
||||
Help on built-in function sin in module math:
|
||||
|
||||
sin(x, /)
|
||||
Return the sine of x (measured in radians).
|
||||
|
||||
math.sin(1)
|
||||
0.8414709848078965
|
||||
help(math.acos)
|
||||
Help on built-in function acos in module math:
|
||||
|
||||
acos(x, /)
|
||||
Return the arc cosine (measured in radians) of x.
|
||||
|
||||
The result is between 0 and pi.
|
||||
|
||||
math.acos(0.5)
|
||||
1.0471975511965979
|
||||
help(math.degrees)
|
||||
Help on built-in function degrees in module math:
|
||||
|
||||
degrees(x, /)
|
||||
Convert angle x from radians to degrees.
|
||||
|
||||
math.degrees(45)
|
||||
2578.3100780887044
|
||||
help(math.radians)
|
||||
Help on built-in function radians in module math:
|
||||
|
||||
radians(x, /)
|
||||
Convert angle x from degrees to radians.
|
||||
|
||||
math.radians(45)
|
||||
0.7853981633974483
|
||||
help(math.exp)
|
||||
Help on built-in function exp in module math:
|
||||
|
||||
exp(x, /)
|
||||
Return e raised to the power of x.
|
||||
|
||||
math.exp(3)
|
||||
20.085536923187668
|
||||
help(math.log)
|
||||
Help on built-in function log in module math:
|
||||
|
||||
log(...)
|
||||
log(x, [base=math.e])
|
||||
Return the logarithm of x to the given base.
|
||||
|
||||
If the base is not specified, returns the natural logarithm (base e) of x.
|
||||
|
||||
math.log(4,3)
|
||||
1.2618595071429148
|
||||
help(math.log10)
|
||||
Help on built-in function log10 in module math:
|
||||
|
||||
log10(x, /)
|
||||
Return the base 10 logarithm of x.
|
||||
|
||||
math.log10(3)
|
||||
0.47712125471966244
|
||||
help(math.sqrt)
|
||||
Help on built-in function sqrt in module math:
|
||||
|
||||
sqrt(x, /)
|
||||
Return the square root of x.
|
||||
|
||||
math.sqrt(5)
|
||||
2.23606797749979
|
||||
help(math.ceil)
|
||||
Help on built-in function ceil in module math:
|
||||
|
||||
ceil(x, /)
|
||||
Return the ceiling of x as an Integral.
|
||||
|
||||
This is the smallest integer >= x.
|
||||
|
||||
math.ceil(3.2)
|
||||
4
|
||||
help(math.floor)
|
||||
Help on built-in function floor in module math:
|
||||
|
||||
floor(x, /)
|
||||
Return the floor of x as an Integral.
|
||||
|
||||
This is the largest integer <= x.
|
||||
|
||||
math.floor(3.8)
|
||||
3
|
||||
math.pi
|
||||
3.141592653589793
|
||||
math.sin((2*math.pi/7)+(math.exp(0.23)))
|
||||
0.8334902641414562
|
||||
```
|
||||
|
||||
## 4. Функции из модуля cmath.
|
||||
|
||||
```py
|
||||
import cmath
|
||||
dir(cmath)
|
||||
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
|
||||
cmath.sqrt(1.2-0.5j)
|
||||
(1.118033988749895-0.22360679774997896j)
|
||||
cmath.phase(1-0.5j)
|
||||
-0.4636476090008061
|
||||
```
|
||||
|
||||
## 5. Модуль random.
|
||||
|
||||
```py
|
||||
import random
|
||||
dir(random)
|
||||
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
|
||||
help(random.seed)
|
||||
Help on method seed in module random:
|
||||
|
||||
seed(a=None, version=2) method of random.Random instance
|
||||
Initialize internal state from a seed.
|
||||
|
||||
The only supported seed types are None, int, float,
|
||||
str, bytes, and bytearray.
|
||||
|
||||
None or no argument seeds from current time or from an operating
|
||||
system specific randomness source if available.
|
||||
|
||||
If *a* is an int, all bits are used.
|
||||
|
||||
For version 2 (the default), all of the bits are used if *a* is a str,
|
||||
bytes, or bytearray. For version 1 (provided for reproducing random
|
||||
sequences from older versions of Python), the algorithm for str and
|
||||
bytes generates a narrower range of seeds.
|
||||
random.seed()
|
||||
help(random.random)
|
||||
Help on built-in function random:
|
||||
|
||||
random() method of random.Random instance
|
||||
random() -> x in the interval [0, 1).
|
||||
|
||||
random.random()
|
||||
0.3783037280071182
|
||||
help(random.uniform)
|
||||
Help on method uniform in module random:
|
||||
|
||||
uniform(a, b) method of random.Random instance
|
||||
Get a random number in the range [a, b) or [a, b] depending on rounding.
|
||||
|
||||
The mean (expected value) and variance of the random variable are:
|
||||
|
||||
E[X] = (a + b) / 2
|
||||
Var[X] = (b - a) ** 2 / 12
|
||||
|
||||
random.uniform(3,5)
|
||||
4.139029942389151
|
||||
help(random.randint)
|
||||
Help on method randint in module random:
|
||||
|
||||
randint(a, b) method of random.Random instance
|
||||
Return random integer in range [a, b], including both end points.
|
||||
|
||||
random.randint(4,88)
|
||||
5
|
||||
help(random.gauss)
|
||||
Help on method gauss in module random:
|
||||
|
||||
gauss(mu=0.0, sigma=1.0) method of random.Random instance
|
||||
Gaussian distribution.
|
||||
|
||||
mu is the mean, and sigma is the standard deviation. This is
|
||||
slightly faster than the normalvariate() function.
|
||||
|
||||
Not thread-safe without a lock around calls.
|
||||
|
||||
random.gauss()
|
||||
0.11579183153210448
|
||||
help(random.choice)
|
||||
Help on method choice in module random:
|
||||
|
||||
choice(seq) method of random.Random instance
|
||||
Choose a random element from a non-empty sequence.
|
||||
random.choice(qq)
|
||||
'Лыкова'
|
||||
help(random.shuffle)
|
||||
Help on method shuffle in module random:
|
||||
|
||||
shuffle(x) method of random.Random instance
|
||||
Shuffle list x in place, and return None.
|
||||
|
||||
random.shuffle(qq)
|
||||
qq
|
||||
['Коваленко', 'Лыкова', 'Соловьёва', 'Голощапов']
|
||||
help(random.sample)
|
||||
Help on method sample in module random:
|
||||
|
||||
sample(population, k, *, counts=None) method of random.Random instance
|
||||
Chooses k unique random elements from a population sequence.
|
||||
|
||||
Returns a new list containing elements from the population while
|
||||
leaving the original population unchanged. The resulting list is
|
||||
in selection order so that all sub-slices will also be valid random
|
||||
samples. This allows raffle winners (the sample) to be partitioned
|
||||
into grand prize and second place winners (the subslices).
|
||||
|
||||
Members of the population need not be hashable or unique. If the
|
||||
population contains repeats, then each occurrence is a possible
|
||||
selection in the sample.
|
||||
|
||||
Repeated elements can be specified one at a time or with the optional
|
||||
counts parameter. For example:
|
||||
|
||||
sample(['red', 'blue'], counts=[4, 2], k=5)
|
||||
|
||||
is equivalent to:
|
||||
|
||||
sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
|
||||
|
||||
To choose a sample from a range of integers, use range() for the
|
||||
population argument. This is especially fast and space efficient
|
||||
for sampling from a large population:
|
||||
|
||||
sample(range(10000000), 60)
|
||||
|
||||
random.sample(qq,3)
|
||||
['Соловьёва', 'Лыкова', 'Голощапов']
|
||||
help(random.betavariate)
|
||||
Help on method betavariate in module random:
|
||||
|
||||
betavariate(alpha, beta) method of random.Random instance
|
||||
Beta distribution.
|
||||
|
||||
Conditions on the parameters are alpha > 0 and beta > 0.
|
||||
Returned values range between 0 and 1.
|
||||
|
||||
The mean (expected value) and variance of the random variable are:
|
||||
|
||||
E[X] = alpha / (alpha + beta)
|
||||
Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
|
||||
random.betavariate(2,5)
|
||||
0.5473034184133493
|
||||
help(random.gammavariate)
|
||||
Help on method gammavariate in module random:
|
||||
|
||||
gammavariate(alpha, beta) method of random.Random instance
|
||||
Gamma distribution. Not the gamma function!
|
||||
|
||||
Conditions on the parameters are alpha > 0 and beta > 0.
|
||||
|
||||
The probability distribution function is:
|
||||
|
||||
x ** (alpha - 1) * math.exp(-x / beta)
|
||||
pdf(x) = --------------------------------------
|
||||
math.gamma(alpha) * beta ** alpha
|
||||
|
||||
The mean (expected value) and variance of the random variable are:
|
||||
|
||||
E[X] = alpha * beta
|
||||
Var[X] = alpha * beta ** 2
|
||||
|
||||
random.gammavariate(2,5)
|
||||
4.616261402628337
|
||||
spis = [random.uniform(0,10),random.gauss(50,15),random.betavariate(2,5),random.gammavariate(2,5)]
|
||||
spis
|
||||
[0.21672125817392973, 25.399177937155795, 0.14356042747670408, 10.552855133080406]
|
||||
```
|
||||
|
||||
## 6. Функции модуля time.
|
||||
|
||||
```py
|
||||
import time
|
||||
dir(time)
|
||||
['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
|
||||
c1=time.time()
|
||||
c2=time.time()-c1
|
||||
c1,c2
|
||||
(1761295798.980248, 5.403235197067261)
|
||||
dat=time.gmtime()
|
||||
dat
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=8, tm_min=50, tm_sec=26, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
dat.tm_mon
|
||||
10
|
||||
local_time = time.localtime()
|
||||
local_time
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=50, tm_sec=50, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
print(f"Год: {local_time.tm_year}")
|
||||
Год: 2025
|
||||
c1 = time.time()
|
||||
local_struct = time.localtime(c1)
|
||||
local_struct
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=54, tm_sec=13, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
time_str = time.asctime(local_struct)
|
||||
time_str
|
||||
'Fri Oct 24 11:54:13 2025'
|
||||
time_str2 = time.ctime(c1)
|
||||
time.sleep(2)
|
||||
seconds = time.mktime(local_struct)
|
||||
seconds
|
||||
1761296053.0
|
||||
new_struct = time.localtime(seconds)
|
||||
new_struct
|
||||
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=54, tm_sec=13, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||
```
|
||||
|
||||
## 7. Графические функции.
|
||||
|
||||
```py
|
||||
import pylab
|
||||
x=list(range(-3,55,4))
|
||||
t=list(range(15))
|
||||
x
|
||||
[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
|
||||
t
|
||||
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
|
||||
pylab.plot(t,x)
|
||||
[<matplotlib.lines.Line2D object at 0x000002487CE9E990>]
|
||||
pylab.title('Первый график')
|
||||
Text(0.5, 1.0, 'Первый график')
|
||||
pylab.xlabel('время')
|
||||
Text(0.5, 0, 'время')
|
||||
pylab.ylabel('сигнал')
|
||||
Text(0, 0.5, 'сигнал')
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```py
|
||||
X1=[12,6,8,10,7]
|
||||
X2=[5,7,9,11,13]
|
||||
pylab.plot(X1)
|
||||
[<matplotlib.lines.Line2D object at 0x000002487D263390>]
|
||||
pylab.plot(X2)
|
||||
[<matplotlib.lines.Line2D object at 0x000002487D2634D0>]
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```py
|
||||
region=['Центр','Урал','Сибирь','Юг']
|
||||
naselen=[65,12,23,17]
|
||||
pylab.pie(naselen,labels=region)
|
||||
([<matplotlib.patches.Wedge object at 0x000002487CE1DFD0>, <matplotlib.patches.Wedge object at 0x000002487D305090>, <matplotlib.patches.Wedge object at 0x000002487D305450>, <matplotlib.patches.Wedge object at 0x000002487D3056D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```py
|
||||
data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
|
||||
pylab.hist(data,5)
|
||||
(array([1., 2., 3., 2., 1.]), array([1. , 1.8, 2.6, 3.4, 4.2, 5. ]), <BarContainer object of 5 artists>)
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```py
|
||||
c = ['A', 'B', 'C']
|
||||
v = [10, 25, 15]
|
||||
pylab.bar(c, v)
|
||||
<BarContainer object of 3 artists>
|
||||
pylab.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
## 8. Модуль statistics.
|
||||
|
||||
```py
|
||||
import statistics
|
||||
data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
|
||||
sred = statistics.mean(data)
|
||||
sred
|
||||
3
|
||||
moda = statistics.mode(data)
|
||||
moda
|
||||
3
|
||||
mediana = statistics.median(data)
|
||||
mediana
|
||||
3
|
||||
|
До Ширина: | Высота: | Размер: 20 KiB |
|
До Ширина: | Высота: | Размер: 26 KiB |
|
До Ширина: | Высота: | Размер: 15 KiB |
|
До Ширина: | Высота: | Размер: 7.9 KiB |
|
До Ширина: | Высота: | Размер: 5.7 KiB |
@ -1,9 +0,0 @@
|
||||
#Модуль Mod0
|
||||
import Mod1
|
||||
print('perm1=',Mod1.perm1)
|
||||
from Mod2 import alpha as al
|
||||
tt=al()
|
||||
print('tt=',tt)
|
||||
from Mod2 import beta
|
||||
qq=beta(float(tt))
|
||||
print('qq=',qq)
|
||||
@ -1,2 +0,0 @@
|
||||
perm1=input('Mod1:Введите значение = ')
|
||||
print('Mod1:Значение perm1=',perm1)
|
||||
@ -1,11 +0,0 @@
|
||||
def alpha():
|
||||
print('****ALPHA****')
|
||||
t=input('Значение t=')
|
||||
return t
|
||||
|
||||
def beta(q):
|
||||
print('****BETA****')
|
||||
import math
|
||||
expi=q*math.pi
|
||||
return math.exp(expi)
|
||||
|
||||
@ -0,0 +1,2 @@
|
||||
'Окно' ('Window') в главном меню IDLE Python предназначено для управления открытыми окнами редактора и их расположением на экране.
|
||||
Благодаря этому между окнами можно перемещаться без особых затруднений, выбирая нужное в выпадающем списке.
|
||||
Загрузка…
Ссылка в новой задаче