Сравнить коммиты
77 Коммитов
main-py11
|
После Ширина: | Высота: | Размер: 2.4 KiB |
|
После Ширина: | Высота: | Размер: 32 KiB |
|
После Ширина: | Высота: | Размер: 14 KiB |
|
После Ширина: | Высота: | Размер: 5.5 KiB |
|
После Ширина: | Высота: | Размер: 23 KiB |
|
После Ширина: | Высота: | Размер: 28 KiB |
|
После Ширина: | Высота: | Размер: 48 KiB |
|
После Ширина: | Высота: | Размер: 49 KiB |
@ -0,0 +1,6 @@
|
|||||||
|
#Программа по Теме 1 Ефимова Людмила Алексеевна
|
||||||
|
print('Hello')
|
||||||
|
h=input('Your name=')
|
||||||
|
import os
|
||||||
|
os.chdir('C:\\Users\\u207-03\\Desktop\\ПОАС\\python-labs\\TEMA1\\report')
|
||||||
|
|
||||||
@ -0,0 +1,88 @@
|
|||||||
|
# Отчет по теме 1
|
||||||
|
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## 1 Изучение среды IDLE
|
||||||
|
|
||||||
|
## 1.1 Знакомство с Python 3.4 (command line)
|
||||||
|
|
||||||
|
```
|
||||||
|
>>> print('Hello')
|
||||||
|
Hello
|
||||||
|
>>> h=input('Your name=')
|
||||||
|
Your name=Lyudmila
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
## 1.2 Изучение графической оболочки IDLE
|
||||||
|
|
||||||
|
```
|
||||||
|
import os
|
||||||
|
os.chdir('C:\\Users\\u207-03\\Desktop\\ПОАС\\python-labs\\TEMA1\\report')
|
||||||
|
```
|
||||||
|
Скриншоты настройки среды.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
## 1.3 Создание программы по пунктам 3,4,8:
|
||||||
|
Создан файл pr0:
|
||||||
|
|
||||||
|
```
|
||||||
|
#Программа по Теме 1 Ефимова Людмила Алексеевна
|
||||||
|
print('Hello')
|
||||||
|
h=input('Your name=')
|
||||||
|
import os
|
||||||
|
os.chdir('C:\\Users\\u207-03\\Desktop\\ПОАС\\python-labs\\TEMA1\\report')
|
||||||
|
```
|
||||||
|
Вывод программы:
|
||||||
|
|
||||||
|
```
|
||||||
|
================== RESTART: C:\Users\u207-03\Desktop\ПОАС\python-labs\TEMA1\report\pr0.py ==================
|
||||||
|
Hello
|
||||||
|
Your name=Ludmila
|
||||||
|
```
|
||||||
|
|
||||||
|
## 1.4 Проверка программы prb1:
|
||||||
|
|
||||||
|
```
|
||||||
|
import prb1
|
||||||
|
Как Вас зовут? Людмила
|
||||||
|
Привет, Людмила
|
||||||
|
```
|
||||||
|
|
||||||
|
## 1.5 Изучение каталога __pycache__
|
||||||
|
|
||||||
|
Открыла каталог и запустила в текстовом редакторе файл pr0.cpython-311.pyc:
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Данный файл нужен для исполнения кода виртуальной машиной python.
|
||||||
|
Файл расширения .pyc это скомпилированный файл для изначального кода. В нем содержится кеш выполнения программы
|
||||||
|
|
||||||
|
## 1.6 Изучение команды help
|
||||||
|
|
||||||
|
В среде пограммирования введены команды help(print) и help(input)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Получили вывод - инструкции по работе с командами.
|
||||||
|
|
||||||
|
## 1.7 Выполнение функции 15
|
||||||
|
|
||||||
|
В редакторе открыла файл prb1 и запустила его.
|
||||||
|
Получен вывод:
|
||||||
|
|
||||||
|
```
|
||||||
|
============== RESTART: C:\Users\u207-03\Desktop\ПОАС\python-labs\TEMA1\report\prb1.py =============
|
||||||
|
Как Вас зовут? Людмила
|
||||||
|
Привет, Людмила
|
||||||
|
```
|
||||||
|
|
||||||
|
Открыт файл tdemo_chaos, изучено его содержимое.
|
||||||
|
|
||||||
|
|
||||||
|
После запуска получен вывод программы:
|
||||||
|
|
||||||
|
|
||||||
|
Запущен пример программы Часы (Clock) из пакета Turtle:
|
||||||
|
|
||||||
@ -0,0 +1,51 @@
|
|||||||
|
# Общее контрольное задание по теме 2
|
||||||
|
Ефимова Людмила Алексеевна, А-03-23
|
||||||
|
|
||||||
|
## Задание
|
||||||
|
Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия: • Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
|
||||||
|
|
||||||
|
• Создать переменную со значением, совпадающим с первой буквой из familia.
|
||||||
|
|
||||||
|
• Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
|
||||||
|
|
||||||
|
• Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
|
||||||
|
|
||||||
|
• Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
|
||||||
|
|
||||||
|
• Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
|
||||||
|
|
||||||
|
• Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
|
||||||
|
|
||||||
|
• Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
|
||||||
|
|
||||||
|
## Решение
|
||||||
|
|
||||||
|
```py
|
||||||
|
familia = "Efimova"
|
||||||
|
first = familia[0] # значение первая буква из familia
|
||||||
|
first
|
||||||
|
'E'
|
||||||
|
|
||||||
|
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") # удаляем элемент 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 = ("Lyudmila", "Maria", "Danil", "Dima")
|
||||||
|
type(kort_nam)
|
||||||
|
<class 'tuple'>
|
||||||
|
|
||||||
|
kort_nam += ("Artem", "Ilya")
|
||||||
|
kort_nam
|
||||||
|
('Lyudmila', 'Maria', 'Danil', 'Dima', 'Artem', 'Ilya')
|
||||||
|
kort_nam.count("Dima")
|
||||||
|
1
|
||||||
|
|
||||||
|
dict_bas = {'строка' : familia, 'список' : sp_kw, 'кортеж' : kort_nam} # создаем словарь
|
||||||
|
dict_bas
|
||||||
|
{'строка': 'Efimova', 'список': ['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'], 'кортеж': ('Lyudmila', 'Maria', 'Danil', 'Dima', 'Artem', 'Ilya')}
|
||||||
|
```
|
||||||
@ -0,0 +1,22 @@
|
|||||||
|
# Индивидуальное контрольное задание
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## Задание вариант 17
|
||||||
|
Создайте два списка: один – с фамилиями 3-х студентов вашей группы, другой – с 5 числами: 11,12,13,14,15.
|
||||||
|
|
||||||
|
Напишите инструкцию создания словаря, в котором фамилии студентов были бы ключами, а числа – значениями.
|
||||||
|
|
||||||
|
Отобразите получившийся словарь.
|
||||||
|
|
||||||
|
Отобразите его ключи с упорядочением по фамилиям студентов.
|
||||||
|
|
||||||
|
## Решение
|
||||||
|
```py
|
||||||
|
familii = ['Ефимова', 'Девятова','Беженарь']
|
||||||
|
num = [11, 12, 13, 14, 15]
|
||||||
|
dic = dict(zip(familii, num))
|
||||||
|
print(dic)
|
||||||
|
{'Ефимова': 11, 'Девятова': 12, 'Беженарь': 13}
|
||||||
|
sorted(dic.keys())
|
||||||
|
['Беженарь', 'Девятова', 'Ефимова']
|
||||||
|
```
|
||||||
@ -0,0 +1,664 @@
|
|||||||
|
# Отчет по теме 3
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## 1. Запустила оболочку IDLE, создала рабочий протокол
|
||||||
|
|
||||||
|
## 2. Преобразование простых базовых типов объектов
|
||||||
|
### 2.1. Преобразовали объекты в логческий тип
|
||||||
|
|
||||||
|
```py
|
||||||
|
logiz1=bool(56) # целые числа, кроме 0, преобразуются в True
|
||||||
|
print(logiz1, ' ', type(logiz1))
|
||||||
|
True <class 'bool'>
|
||||||
|
logiz2=bool(0) # 0 преобразуется в False
|
||||||
|
print(logiz2, ' ', type(logiz2))
|
||||||
|
False <class 'bool'>
|
||||||
|
logiz3=bool("Beta") # не пустая строка преобразуется в True
|
||||||
|
print(logiz3, ' ', type(logiz3))
|
||||||
|
True <class 'bool'>
|
||||||
|
logiz4=bool("") # пустая строка преобразуется в False
|
||||||
|
print(logiz4, ' ', type(logiz4))
|
||||||
|
False <class 'bool'>
|
||||||
|
```
|
||||||
|
|
||||||
|
### 2.2. Преобразование в целое десятичное число
|
||||||
|
|
||||||
|
Функция int(<Объект>[,<Система счисления, в которой определен
|
||||||
|
объект>]) позволяет преобразовать объект в целое десятичное число
|
||||||
|
|
||||||
|
```py
|
||||||
|
tt1=int(198.6) #Отбрасывается дробная частьtt1
|
||||||
|
198
|
||||||
|
tt2=int("-76") #Число – в строке символов, система по умолчанию - десятичная
|
||||||
|
tt2
|
||||||
|
-76
|
||||||
|
tt3=int("B",16)
|
||||||
|
tt3
|
||||||
|
11
|
||||||
|
tt4=int("71",8)
|
||||||
|
tt4
|
||||||
|
57
|
||||||
|
tt5=int("98.76") # Число передающееся в виде строки должно быть целым
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#28>", line 1, in <module>
|
||||||
|
tt5=int("98.76")
|
||||||
|
ValueError: invalid literal for int() with base 10: '98.76'
|
||||||
|
```
|
||||||
|
С помощью функции float(<Объект>) преобразуем объекты в вещественное число
|
||||||
|
|
||||||
|
```py
|
||||||
|
flt1=float(789)
|
||||||
|
flt1
|
||||||
|
789.0
|
||||||
|
flt2=float(-6.78e2)
|
||||||
|
flt2
|
||||||
|
-678.0
|
||||||
|
flt3=float("Infinity")
|
||||||
|
flt3
|
||||||
|
inf
|
||||||
|
flt4=float("-inf")
|
||||||
|
flt4
|
||||||
|
-inf
|
||||||
|
```
|
||||||
|
|
||||||
|
### 2.3. Преобразование десятичных чисел в другие системы счисления
|
||||||
|
С помощью команд bin oct hex преобразовали объекты в строку с двоичным, вомьмеричным, шестнадцатиричным
|
||||||
|
представлениями. С помощью команды int() сделали обратные преобразования.
|
||||||
|
```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
|
||||||
|
'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}) #Преобразуем словарь
|
||||||
|
strk5
|
||||||
|
"{'A': 1, 'B': 2, 'C': 9}"
|
||||||
|
```
|
||||||
|
### 3.2. Преобразование объектов в список
|
||||||
|
|
||||||
|
Преобразовали объекты в список функцией list(<Объект>).
|
||||||
|
|
||||||
|
```py
|
||||||
|
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(<Объект>).
|
||||||
|
|
||||||
|
```py
|
||||||
|
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 можно удалить объекты из оперативной памяти
|
||||||
|
```py
|
||||||
|
del strk5, kort8
|
||||||
|
dir()
|
||||||
|
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'spis6', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
|
||||||
|
```
|
||||||
|
Создадим строку со своей фамилией и инициалами преобразуем ее в список, затем список в кортеж, затем в строку
|
||||||
|
|
||||||
|
```py
|
||||||
|
strk1 = "ЕфимоваЛА"
|
||||||
|
spis = list(strk1)
|
||||||
|
spis
|
||||||
|
['Е', 'ф', 'и', 'м', 'о', 'в', 'а', 'Л', 'А']
|
||||||
|
kort = tuple(spis)
|
||||||
|
kort
|
||||||
|
('Е', 'ф', 'и', 'м', 'о', 'в', 'а', 'Л', 'А')
|
||||||
|
strk2 = str(kort)
|
||||||
|
"('Е', 'ф', 'и', 'м', 'о', 'в', 'а', 'Л', 'А')"
|
||||||
|
```
|
||||||
|
## 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!
|
||||||
|
print(a, ' ', type(a))
|
||||||
|
3.9555555555555557 <class 'float'>
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.4. Деление c округлением вниз
|
||||||
|
|
||||||
|
```py
|
||||||
|
b = 178 // 45 # 3.956 округляется вниз, т.е. до 3
|
||||||
|
b
|
||||||
|
3
|
||||||
|
type(b)
|
||||||
|
<class 'int'>
|
||||||
|
c = -24.6 // 12.1 # -2.033 округляется вниз, т.е. до -3
|
||||||
|
c
|
||||||
|
-3.0
|
||||||
|
type(c)
|
||||||
|
<class 'float'>
|
||||||
|
12 // 6.5
|
||||||
|
1.0
|
||||||
|
12.0 // 5
|
||||||
|
2.0
|
||||||
|
```
|
||||||
|
### 4.5. Получение остатка от деления
|
||||||
|
|
||||||
|
```py
|
||||||
|
148%33 #Остаток от деления двух целых чисел
|
||||||
|
16
|
||||||
|
12.6%3.8 #Остаток от деления двух вещественных чисел
|
||||||
|
1.2000000000000002
|
||||||
|
```
|
||||||
|
### 4.6. Возведение в степень
|
||||||
|
```py
|
||||||
|
14**3 #Целое число возводится в целую степень
|
||||||
|
2744
|
||||||
|
e=2.7**3.6 #Вещественное число возводится в вещественную степень
|
||||||
|
e
|
||||||
|
35.719843790663525
|
||||||
|
```
|
||||||
|
С комплексными числами
|
||||||
|
|
||||||
|
```py
|
||||||
|
z1 = 1 + 1j
|
||||||
|
z2 = 2 + 2j
|
||||||
|
z1+z2
|
||||||
|
(3+3j)
|
||||||
|
z1 - z2
|
||||||
|
(-1-1j)
|
||||||
|
z1 * z2
|
||||||
|
4j
|
||||||
|
z1 / z2
|
||||||
|
(0.5+0j)
|
||||||
|
z1 ** 2
|
||||||
|
2j
|
||||||
|
z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
|
||||||
|
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#12>", line 1, in <module>
|
||||||
|
z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
|
||||||
|
TypeError: unsupported operand type(s) for //: 'complex' and 'int'
|
||||||
|
|
||||||
|
z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#13>", line 1, in <module>
|
||||||
|
z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
|
||||||
|
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
|
||||||
|
```
|
||||||
|
При проведении арифметических операций над числами разных типов, получается число, имеющее более сложный тип из использованных при его получении.
|
||||||
|
|
||||||
|
## 5. Операции с двоичными представлениями целых чисел
|
||||||
|
### 5.1. Двоичная инверсия
|
||||||
|
Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на
|
||||||
|
противоположное значение (0 на 1, 1 на 0)
|
||||||
|
```py
|
||||||
|
dv1=9
|
||||||
|
bin(dv1)
|
||||||
|
'0b1001'
|
||||||
|
dv2=~dv1
|
||||||
|
bin(dv2)
|
||||||
|
'-0b1010'
|
||||||
|
```
|
||||||
|
|
||||||
|
### 5.2. Двоичное «И»
|
||||||
|
Двоичное «И» - логическое умножение, побитовое совпадение двоичных представлений чисел.
|
||||||
|
```py
|
||||||
|
7&9 # 0111 и 1001 = 0001
|
||||||
|
1
|
||||||
|
bin(7)
|
||||||
|
'0b111'
|
||||||
|
bin(9)
|
||||||
|
'0b1001'
|
||||||
|
7&8 # 0111 и 1000 = 0000
|
||||||
|
0
|
||||||
|
bin(8)
|
||||||
|
'0b1000'
|
||||||
|
```
|
||||||
|
### 5.3. Двоичное «ИЛИ»
|
||||||
|
Двоичное «ИЛИ» - логическое сложение, побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда равны 0.
|
||||||
|
```py
|
||||||
|
7|9 # 0111 или 1001 = 1111
|
||||||
|
15
|
||||||
|
7|8 # 0111 или 1000 = 1111
|
||||||
|
15
|
||||||
|
14|5 # 1110 или 0101 = 1111
|
||||||
|
15
|
||||||
|
bin(15)
|
||||||
|
'0b1111'
|
||||||
|
```
|
||||||
|
|
||||||
|
### 5.4. Двоичное «исключаещее ИЛИ»
|
||||||
|
Двоичное «исключающее ИЛИ» - побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда имеют одинаковые значения.
|
||||||
|
```py
|
||||||
|
14^5 # 1110 исключающее или 0101 = 1011
|
||||||
|
11
|
||||||
|
bin(11)
|
||||||
|
'0b1011'
|
||||||
|
```
|
||||||
|
### 5.5. Поразрядный сдвиг
|
||||||
|
Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с
|
||||||
|
дополнением нулями, соответственно справа или слева
|
||||||
|
```py
|
||||||
|
h=14 #Двоичное представление = 1110
|
||||||
|
bin(h)
|
||||||
|
'0b1110'
|
||||||
|
g=h<<2 # Новое двоичное представление = 111000
|
||||||
|
bin(g)
|
||||||
|
'0b111000'
|
||||||
|
g1=h>>1 # Новое двоичное представление = 0111
|
||||||
|
bin(g1)
|
||||||
|
'0b111'
|
||||||
|
g2=h>>2 # Новое двоичное представление = 0011
|
||||||
|
bin(g2)
|
||||||
|
'0b11'
|
||||||
|
```
|
||||||
|
Операции с двоичными числами на практике
|
||||||
|
|
||||||
|
```py
|
||||||
|
a = 251
|
||||||
|
bin(a)
|
||||||
|
'0b11111011'
|
||||||
|
b = 293
|
||||||
|
bin(b)
|
||||||
|
'0b100100101'
|
||||||
|
~a
|
||||||
|
-252
|
||||||
|
bin(~a)
|
||||||
|
'-0b11111100'
|
||||||
|
a&b # 011111011 и 100100101 = 000100001
|
||||||
|
33
|
||||||
|
bin(a&b)
|
||||||
|
'0b100001'
|
||||||
|
a|b # двоичное или - 011111011 и 100100101 = 111111111
|
||||||
|
511
|
||||||
|
bin(a|b)
|
||||||
|
'0b111111111'
|
||||||
|
a ^ b # Двоичное «исключающее ИЛИ» 0 если совпадают
|
||||||
|
478
|
||||||
|
bin(a^b)
|
||||||
|
'0b111011110'
|
||||||
|
bin(a>>3) # поразрядовый сдвиг вправо на 3
|
||||||
|
'0b11111'
|
||||||
|
```
|
||||||
|
## 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
|
||||||
|
'ля-ля-ля-ля-ля-'
|
||||||
|
['ку','-']*3 #Повторение списка 3 раза
|
||||||
|
['ку', '-', 'ку', '-', 'ку', '-']
|
||||||
|
('кис','-')*4 #Повторение кортежа 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,)*7signal2
|
||||||
|
(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
|
||||||
|
```
|
||||||
|
### 6.3. Проверка наличия заданного элемента в последовательности
|
||||||
|
Наличие элемента в последовательность можно проверить с помощью оператора in.
|
||||||
|
```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 %(sravn)s %(zn2)g' # вставка и сспользованием данных из словаря
|
||||||
|
stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
|
||||||
|
'Температура = 16 меньше 25'
|
||||||
|
```
|
||||||
|
## 7. Оператор присваивания
|
||||||
|
### 7.1. Обычное присваивание значения переменной
|
||||||
|
```py
|
||||||
|
zz=-12
|
||||||
|
zz
|
||||||
|
-12
|
||||||
|
```
|
||||||
|
### 7.2. Увеличение значения переменной на заданную величину или уменьшение
|
||||||
|
Операторы += и -= позволяют увеличить или уменьшить значение переменной на заданную величину соответственно.
|
||||||
|
```py
|
||||||
|
zz+=5 # Значение zz увеличивается на 5
|
||||||
|
zz
|
||||||
|
-7
|
||||||
|
zz-=3 # Значение уменьшается на 3
|
||||||
|
zz
|
||||||
|
-10
|
||||||
|
stroka='Система'
|
||||||
|
stroka+=' регулирования' stroka+=' регулирования'
|
||||||
|
stroka
|
||||||
|
'Система регулирования'
|
||||||
|
```
|
||||||
|
### 7.3. Умножение текущего значения переменной на заданную величину или деление
|
||||||
|
Операторы /= и *= позволяют разделить или умножить значение переменной на заданную величину соответственно.
|
||||||
|
```py
|
||||||
|
zz/=2
|
||||||
|
zz
|
||||||
|
-5.0
|
||||||
|
zz*=5
|
||||||
|
zz
|
||||||
|
-12.5
|
||||||
|
str = 'ля'
|
||||||
|
str*=3 # повторение заданной строки 3 раза
|
||||||
|
str
|
||||||
|
'ляляля'
|
||||||
|
```
|
||||||
|
### 7.4. Операции деления с округлением вниз получения остатка от деления и возведения в
|
||||||
|
степень
|
||||||
|
|
||||||
|
```py
|
||||||
|
a = 6
|
||||||
|
a//=5 # целочисленное деление
|
||||||
|
a
|
||||||
|
1
|
||||||
|
b = 13
|
||||||
|
b%=6 # получение остатка от деления
|
||||||
|
b
|
||||||
|
1
|
||||||
|
c = 2
|
||||||
|
c **= 3 # возведение в степень
|
||||||
|
c
|
||||||
|
8
|
||||||
|
```
|
||||||
|
### 7.5. Множественное присваивание
|
||||||
|
Присваивать определенные значения можно сразу нескольким переменным за раз.
|
||||||
|
```py
|
||||||
|
w=v=10 # Переменным присваивается одно и то же значение
|
||||||
|
w,v
|
||||||
|
(10, 10)
|
||||||
|
n1,n2,n3=(11,-3,'all') #Значения переменных берутся из кортежа
|
||||||
|
n1,n2,n3
|
||||||
|
(11, -3, 'all')
|
||||||
|
n1,n2,n3= [11, 12, 13] # можно из списка
|
||||||
|
n1, n2, n3
|
||||||
|
(11, 12, 13)
|
||||||
|
n1,n2,n3= '12','rrr', 'iuuiui' # можно строки
|
||||||
|
n1, n2, n3
|
||||||
|
('12', 'rrr', 'iuuiui')
|
||||||
|
n1,n2,n3= {1: 11, 2: 12, 3: 'eeee'} # можно словарь
|
||||||
|
n1, n2, n3
|
||||||
|
(1, 2, 3)
|
||||||
|
n1,n2,n3= {11, 12, 'eeee'} # множество
|
||||||
|
n1, n2, n3
|
||||||
|
(11, 12, 'eeee')
|
||||||
|
```
|
||||||
|
## 8. Логические операции
|
||||||
|
### 8.1. Операции сравнения
|
||||||
|
```py
|
||||||
|
w == v
|
||||||
|
True
|
||||||
|
w != v
|
||||||
|
False
|
||||||
|
w +=1
|
||||||
|
w < v
|
||||||
|
False
|
||||||
|
w > v
|
||||||
|
True
|
||||||
|
w <= v
|
||||||
|
False
|
||||||
|
w>=v
|
||||||
|
True
|
||||||
|
```
|
||||||
|
### 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также
|
||||||
|
проверка наличия ключа в словаре
|
||||||
|
Наличие элемента в сложном объекте также можно проверить с помощью оператора in
|
||||||
|
|
||||||
|
```py
|
||||||
|
mnoz1={'pen','book','pen','iPhone','table','book'} # с множеством
|
||||||
|
'book' in mnoz1True
|
||||||
|
'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': ['A01-15','A-02-15']}
|
||||||
|
'UII' in dct1['Depart']
|
||||||
|
True
|
||||||
|
dct1['Depart'][1] == 'MM' # сравнение значения словаря по ключу
|
||||||
|
False
|
||||||
|
```
|
||||||
|
### 8.3. Создание больших логических выражений
|
||||||
|
С помощью соединительных слов and, or и not можно создавать большие логические выражения.
|
||||||
|
```py
|
||||||
|
a=17
|
||||||
|
b=-6
|
||||||
|
(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
|
||||||
|
True
|
||||||
|
(a%2==1) and ("pen" in mnoz1) or (120 in dic1.values())
|
||||||
|
True
|
||||||
|
not (b < 0) or (len(mnoz1)== 4)
|
||||||
|
True
|
||||||
|
```
|
||||||
|
### 8.4. Проверка ссылок переменных на один и тот же объект
|
||||||
|
Сравнивать ссылки на объект можно с помощью оператора is.
|
||||||
|
|
||||||
|
```py
|
||||||
|
w=v=10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
|
||||||
|
w is v
|
||||||
|
True
|
||||||
|
w1=['A','B']
|
||||||
|
v1=['A','B']
|
||||||
|
w1 is v1
|
||||||
|
False
|
||||||
|
```
|
||||||
|
В последнем случае значение False так как переменные создавались отдельно, хоть их значения и совпадают.
|
||||||
|
Они хранятся в разных ячейках памяти и их ссылки разные.
|
||||||
|
|
||||||
|
## 9. Операции с объектами, выполняемые с помощью методов
|
||||||
|
### 9.1 Методы для работы со строками
|
||||||
|
|
||||||
|
```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']
|
||||||
|
stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста или значение -1
|
||||||
|
5
|
||||||
|
stroka='Микропроцессорная система управления'
|
||||||
|
stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста или значение -1
|
||||||
|
5
|
||||||
|
stroka.count("с") #Подсчет числа вхождений строки “с” в stroka
|
||||||
|
4
|
||||||
|
stroka.replace(' у',' автоматического у')
|
||||||
|
'Микропроцессорная система автоматического управления'
|
||||||
|
spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит заданный разделитель
|
||||||
|
spis22
|
||||||
|
['Микропроцессорная', 'система', 'управления']
|
||||||
|
stroka.upper() #Возвращает строку со всеми заглавными буквами
|
||||||
|
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
|
||||||
|
stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка
|
||||||
|
stroka3
|
||||||
|
'Микропроцессорная система управления'
|
||||||
|
stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева('Микропроце', 'с', 'сорная система управления')
|
||||||
|
stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа
|
||||||
|
('Микропроцессорная си', 'с', 'тема управления')
|
||||||
|
```
|
||||||
|
Метод format() используется для форматирования строк по следующему принципу:
|
||||||
|
1. Если в форматированной строке не указан порядок вставки элементов, то они войдут в неё в порядке их передачи в метод,
|
||||||
|
2. Если в форматированной строке указан порядок вставки элементов, то они войдут в неё в с таким же порядком,
|
||||||
|
3. Если в форматированной строке поименно указаны позиции вставки элементов, то они войдут в неё в соответствии с ними.
|
||||||
|
```py
|
||||||
|
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 = [1, 2, 3, 4, 5, 6]
|
||||||
|
spsk.pop(2) # удаление элемента по индексу, с возвращением его значения
|
||||||
|
3
|
||||||
|
spsk
|
||||||
|
[1, 2, 4, 5, 6]
|
||||||
|
spsk.append('c') # добавление элемента в конец списка
|
||||||
|
spsk
|
||||||
|
[1, 2, 4, 5, 6, 'c']
|
||||||
|
spsk.insert(2,'a') # добавление элемента на указанную позицию
|
||||||
|
spsk
|
||||||
|
[1, 2, 'a', 4, 5, 6, 'c']
|
||||||
|
spsk.count('a') # подсчет количества соответсвующих элементо
|
||||||
|
1
|
||||||
|
```
|
||||||
|
### 9.3. Методы для работы с кортежами
|
||||||
|
|
||||||
|
```py
|
||||||
|
kortezh = (1, 2, 3, 4, 5, 6, 7)
|
||||||
|
kortezh.count(3) # количество соответсвующих элементов в кортеже
|
||||||
|
1
|
||||||
|
kortezh.index(2) # вычисление индекса переданного элемента если он есть в кортеже
|
||||||
|
1
|
||||||
|
```
|
||||||
|
### 9.4. Методы для словарей и множеств
|
||||||
|
|
||||||
|
```py
|
||||||
|
dictionary = {"A" : 1, "B" : 2, "C" : 3, "D" : 4, "E" : 5}
|
||||||
|
dictionary.get("D") # Получение значения из словаря по соответствующему ему ключу
|
||||||
|
|
||||||
|
dictionary.items() # Получение списка кортежей всех пар ключ-значений в словаре
|
||||||
|
dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5)])
|
||||||
|
|
||||||
|
dictionary.keys() # Получение списка всех ключей в словаре
|
||||||
|
dict_keys(['A', 'B', 'C', 'D', 'E'])
|
||||||
|
|
||||||
|
dictionary.values() # Получение списка всех значений в словаре
|
||||||
|
dict_values([1, 2, 3, 4, 5])
|
||||||
|
|
||||||
|
dictionary.pop("C") # Удаление определенной пары ключ-значение из словаря по переданному ключу
|
||||||
|
3
|
||||||
|
dictionary
|
||||||
|
{'A': 1, 'B': 2, 'D': 4, 'E': 5}
|
||||||
|
|
||||||
|
dictionary.popitem() # Удаление последней пары ключ-значение из словаря
|
||||||
|
('E', 5)
|
||||||
|
dictionary
|
||||||
|
{'A': 1, 'B': 2, 'D': 4}
|
||||||
|
|
||||||
|
dictionary.update({"A" : 5}) # Обновление словаря новыми значениями
|
||||||
|
dictionary
|
||||||
|
{'A': 5, 'B': 2, 'D': 4}
|
||||||
|
|
||||||
|
dictionary.clear() # Очистка словаря
|
||||||
|
dictionary
|
||||||
|
{}
|
||||||
|
```
|
||||||
|
Методы для работы с множествами отчасти схожи с методами словарей, однако среди них также есть и уникальные методы.
|
||||||
|
|
||||||
|
```py
|
||||||
|
mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
|
||||||
|
mnozhestvo.add("Banana") # Добавление элемента в множество
|
||||||
|
mnozhestvo
|
||||||
|
{'Banana', 'Pear', 'Peach', 'Apple', 'Orange'}
|
||||||
|
mnozhestvo2 = mnozhestvo.copy() # Копирование множества
|
||||||
|
mnozhestvo2
|
||||||
|
{'Peach', 'Banana', 'Apple', 'Orange', 'Pear'}
|
||||||
|
mnozhestvo2.remove("Apple") # Удаление элемента из множества
|
||||||
|
mnozhestvo2
|
||||||
|
{'Peach', 'Banana', 'Orange', 'Pear'}
|
||||||
|
mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
|
||||||
|
{'Apple'}
|
||||||
|
mnozhestvo2.clear() # Очистка множества
|
||||||
|
mnozhestvo2
|
||||||
|
set()
|
||||||
|
```
|
||||||
|
|
||||||
|
## 10. Завершение работы со средой.
|
||||||
@ -0,0 +1,52 @@
|
|||||||
|
# Индивидуальное контрольное задание модуль 1
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## Задание вариант 9
|
||||||
|
|
||||||
|
1.В каком месте инструкции и как можно написать комментарий?
|
||||||
|
|
||||||
|
После любой инструкции или на отдельной строке после знака #
|
||||||
|
|
||||||
|
2.Создайте объект-список с 10 элементами - русскоязычными названиями продуктов. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа.
|
||||||
|
Напишите инструкцию отображения списка атрибутов созданного объекта.
|
||||||
|
|
||||||
|
```py
|
||||||
|
spis = ["Помидор", "Огурец", "Сухарики","Сыр","Шоколадка","Молоко","Пицца","Чипсы","Яйца","Кофе"]
|
||||||
|
type(spis)
|
||||||
|
<class 'list'>
|
||||||
|
dir(spis)
|
||||||
|
['__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']
|
||||||
|
```
|
||||||
|
|
||||||
|
3. Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
|
||||||
|
|
||||||
|
```py
|
||||||
|
spis.remove(spis[5])
|
||||||
|
spis.remove(spis[4])
|
||||||
|
spis
|
||||||
|
['Помидор', 'Огурец', 'Сухарики', 'Сыр', 'Пицца', 'Чипсы', 'Яйца', 'Кофе']
|
||||||
|
spis[3]="трюфель"
|
||||||
|
spis
|
||||||
|
['Помидор', 'Огурец', 'Сухарики', 'трюфель', 'Пицца', 'Чипсы', 'Яйца', 'Кофе']
|
||||||
|
```
|
||||||
|
|
||||||
|
4. Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
|
||||||
|
|
||||||
|
```py
|
||||||
|
kort=tuple(spis)
|
||||||
|
kort
|
||||||
|
('Помидор', 'Огурец', 'Сухарики', 'трюфель', 'Пицца', 'Чипсы', 'Яйца', 'Кофе')
|
||||||
|
kort_1=kort[0:3] + kort[4:] # кортеж неизменяем, создаем новый
|
||||||
|
kort_1
|
||||||
|
('Помидор', 'Огурец', 'Сухарики', 'Пицца', 'Чипсы', 'Яйца', 'Кофе')
|
||||||
|
```
|
||||||
|
|
||||||
|
5.Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
|
||||||
|
|
||||||
|
```py
|
||||||
|
"Молоко" in spis
|
||||||
|
False
|
||||||
|
spis.append("Молоко")
|
||||||
|
spis
|
||||||
|
['Помидор', 'Огурец', 'Сухарики', 'трюфель', 'Пицца', 'Чипсы', 'Яйца', 'Кофе', 'Молоко']
|
||||||
|
```
|
||||||
@ -0,0 +1,79 @@
|
|||||||
|
# Общее контрольно задание по теме 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. Создать объект - символьную строку с текстом данного предложения. Из символьной строки
|
||||||
|
создать список, элементами которого будут отдельные слова из созданной строки. Заменить в
|
||||||
|
списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить
|
||||||
|
получившийся список.
|
||||||
|
|
||||||
|
```py
|
||||||
|
a = int("45", 8) #1 пункт
|
||||||
|
a
|
||||||
|
37
|
||||||
|
|
||||||
|
D = {"усиление":23, "запаздывание":12, "постояннаявремени":78} #2 пункт
|
||||||
|
D_key = list(D.keys())
|
||||||
|
D_values = list(D.values())
|
||||||
|
D_key, D_values
|
||||||
|
(['усиление', 'запаздывание', 'постояннаявремени'], [23, 12, 78])
|
||||||
|
D_tuple = tuple(zip(D_key, D_values)) # создали кортеж, он неизменяемый в отличие от списка
|
||||||
|
D_tuple
|
||||||
|
(('усиление', 23), ('запаздывание', 12), ('постояннаявремени', 78))
|
||||||
|
|
||||||
|
((1768//24.8)%3) ** 2.4 # 3 пункт
|
||||||
|
5.278031643091577
|
||||||
|
|
||||||
|
(~ (13 & 27) ^ 14) << 2 # 4 пункт
|
||||||
|
-32
|
||||||
|
|
||||||
|
spis = ["колебат"] * 4 # 5 пункт
|
||||||
|
spis
|
||||||
|
['колебат', 'колебат', 'колебат', 'колебат']
|
||||||
|
"аткол" in spis[1] + spis[2]
|
||||||
|
True
|
||||||
|
|
||||||
|
dir(D) # 6 пункт
|
||||||
|
['__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.value()
|
||||||
|
dict_values([23, 12, 78])
|
||||||
|
|
||||||
|
string = "Создать объект - символьную строку с текстом данного предложения." # 7 пункт
|
||||||
|
string_list = string.split(" ")
|
||||||
|
string_list
|
||||||
|
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
|
||||||
|
string_list[string_list.index("-")] = ","
|
||||||
|
string_list
|
||||||
|
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
|
||||||
|
string_list.remove('данного')
|
||||||
|
string_list
|
||||||
|
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
|
||||||
|
```
|
||||||
|
После Ширина: | Высота: | Размер: 42 KiB |
|
После Ширина: | Высота: | Размер: 56 KiB |
|
После Ширина: | Высота: | Размер: 34 KiB |
|
После Ширина: | Высота: | Размер: 14 KiB |
|
После Ширина: | Высота: | Размер: 38 KiB |
@ -0,0 +1,304 @@
|
|||||||
|
# Отчет по теме 4
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## 1. Запустила оболочку IDLE создала рабочий протокол
|
||||||
|
## 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
|
||||||
|
type(round(123.456,1)
|
||||||
|
<class 'float'>
|
||||||
|
type(round(123.456,0))
|
||||||
|
<class 'float'>
|
||||||
|
round(123.456)
|
||||||
|
123
|
||||||
|
type(round(123.456))
|
||||||
|
<class '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) # создает последовательность целых чисел от 0 до 22 с шагом 1
|
||||||
|
list(range(23))
|
||||||
|
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
|
||||||
|
type(gg)
|
||||||
|
<class 'range'>
|
||||||
|
```
|
||||||
|
### 2.3. Функция создания общего объекта, элементами которого являются кортежи zip().
|
||||||
|
|
||||||
|
```py
|
||||||
|
qq = ["Ефимова", "Девятова", "Беженарь", "Антонов"]
|
||||||
|
ff=zip(gg,qq)
|
||||||
|
ff # итерируемый объект просто так нельзя увидеть
|
||||||
|
<zip object at 0x000001F7810C4340>
|
||||||
|
tuple(ff)
|
||||||
|
((76, 'Ефимова'), (85, 'Девятова'), (94, 'Беженарь'), (103, 'Антонов'))
|
||||||
|
ff[1] # нельзя обращаться с помощью индекса
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#12>", line 1, in <module>
|
||||||
|
ff[1]
|
||||||
|
TypeError: 'zip' object is not subscriptable
|
||||||
|
```
|
||||||
|
Длина результирующего объекта равна длине самого короткого объекта из переданных функции.
|
||||||
|
|
||||||
|
### 2.4. Функция вычисляющая значения выражения, корректно записанного на языке Python и представленного в виде символьной строки eval()
|
||||||
|
|
||||||
|
```py
|
||||||
|
fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
|
||||||
|
коэффициент усиления=3
|
||||||
|
dan
|
||||||
|
-141.0
|
||||||
|
```
|
||||||
|
### 2.5. Похожая на eval() функция exec().
|
||||||
|
Xтение и выполнение объекта-аргумента функции.
|
||||||
|
Этот объект должен представлять собой строку символов с совокупностью инструкций на языке Python.
|
||||||
|
|
||||||
|
```py
|
||||||
|
exec(input('введите инструкции:'))
|
||||||
|
введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
|
||||||
|
gg
|
||||||
|
221.456
|
||||||
|
```
|
||||||
|
### 2.6. Функции abs, pow, max, min, sum, divmod, len, map.
|
||||||
|
|
||||||
|
```py
|
||||||
|
abs(-100) # Получение модуля числа
|
||||||
|
100
|
||||||
|
pow(2, 5) # Возведение чисда в степень
|
||||||
|
32
|
||||||
|
max(1, 2, 3, 10) # Получение максимального числа из переданной последовательности
|
||||||
|
10
|
||||||
|
min(1, 2, 3, 10) # Получение минимального числа из переданной последовательности
|
||||||
|
1
|
||||||
|
sum([1, 2, 3, 10]) # Суммирование элементов переданной последовательности
|
||||||
|
16
|
||||||
|
divmod(11, 4) # Получение кортежа с двумя элементами: результатами целочисленного деления и деления с остатком
|
||||||
|
(2, 3)
|
||||||
|
len([1, 2, 3, 10])
|
||||||
|
4
|
||||||
|
|
||||||
|
def cube(x):
|
||||||
|
return x ** 2
|
||||||
|
map(cube, [1, 2, 3, 10]) # Применение заданной функции ко всем элементам переданной последовательности
|
||||||
|
<map object at 0x000001F783989F60>
|
||||||
|
list(map(cube, [1, 2, 3, 10]))
|
||||||
|
[1, 4, 9, 100]
|
||||||
|
```
|
||||||
|
## 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
|
||||||
|
math.sin(math.pi / 6) # Расчет синуса числа
|
||||||
|
0.49999999999999994
|
||||||
|
math.acos(0.5) * 180 / math.pi # Расчет арккосинуса числа
|
||||||
|
60.00000000000001
|
||||||
|
math.degrees(math.pi / 6) # Перевод угла в радианах в градусы
|
||||||
|
29.999999999999996
|
||||||
|
math.radians(60) # Перевод угла в градусах в радианы
|
||||||
|
1.0471975511965976
|
||||||
|
math.exp(2) # Возведение числа Эйлера в определенную степень
|
||||||
|
7.38905609893065
|
||||||
|
math.log(8, 2) # Вычисление логарифма с определенным основанием
|
||||||
|
3.0
|
||||||
|
math.log10(100) # Вычисление десятичного логарифма
|
||||||
|
2.0
|
||||||
|
math.sqrt(64) # Вычисление квадратного корня
|
||||||
|
8.0
|
||||||
|
math.ceil(4.25) # Округление в большую сторону
|
||||||
|
5
|
||||||
|
math.floor(4.25) # Округление в меньшую сторону
|
||||||
|
4
|
||||||
|
|
||||||
|
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() #задает случайное начальное состояние для псевдослучайных чисел
|
||||||
|
random.random() # Равномерно распределенное случайное число
|
||||||
|
0.3956737606722922
|
||||||
|
random.uniform(1, 2) # Равномерно распределенное случайное число
|
||||||
|
1.2506275428676115
|
||||||
|
random.randint(5, 6) # Случайное целое число
|
||||||
|
5
|
||||||
|
random.gauss(5, 0.2) # Нормально распределенное случайное число
|
||||||
|
4.575306564580744
|
||||||
|
random.choice(["Apple", "Orange", "Pear"]) # Случайный выбор элемента из совокупности
|
||||||
|
'Orange'
|
||||||
|
fruits = ["Apple", "Orange", "Pear"]
|
||||||
|
random.shuffle(fruits) # Перемешивание элементов списка
|
||||||
|
fruits
|
||||||
|
['Orange', 'Apple', 'Pear']
|
||||||
|
random.sample(fruits, 2) # Получение выборки заданной размерности из совокупности
|
||||||
|
['Apple', 'Orange']
|
||||||
|
random.betavariate(1, 2) # Случайное число с бета-распределением
|
||||||
|
0.19723446300643666
|
||||||
|
random.gammavariate(1, 2) # Случайное число с гамма-распределением
|
||||||
|
0.004344283624993138
|
||||||
|
```
|
||||||
|
Cписок с 4 случайными значениями подчиняющимися равномерному, нормальному, бета и гамма – распределениям.
|
||||||
|
|
||||||
|
```py
|
||||||
|
[random.uniform(1, 5), random.gauss(2, 1), random.betavariate(1, 2), random.gammavariate(1, 2)]
|
||||||
|
[1.937226676440678, 1.2213894819097244, 0.9228424699324803, 0.8536430488572739]
|
||||||
|
```
|
||||||
|
## 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() # Время в секундах, прошедшее с начала эпохи 1.1.1970
|
||||||
|
c1
|
||||||
|
1761258327.4259675
|
||||||
|
c2=time.time()-c1 # Получение времени со ввода предыдущей команды
|
||||||
|
c2
|
||||||
|
19.33849573135376
|
||||||
|
dat=time.gmtime() # Получение полной информации о текущем времени
|
||||||
|
dat
|
||||||
|
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=23, tm_hour=22, tm_min=26, tm_sec=24, tm_wday=3, tm_yday=296, tm_isdst=0)
|
||||||
|
dat.tm_mon # Получение текущего месяца
|
||||||
|
10
|
||||||
|
dat.tm_hour # Получение текущего часа
|
||||||
|
22
|
||||||
|
datLocal = time.localtime() # Получение полной информации о текущем "местном" времени
|
||||||
|
datLocal
|
||||||
|
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=1, tm_min=28, tm_sec=16, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||||
|
time.asctime(datLocal) # Преобразование представления времени из кортежа в строку
|
||||||
|
'Fri Oct 23 01:28:16 2025'
|
||||||
|
time.ctime(c1) # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
|
||||||
|
'Fri Oct 23 01:25:27 2025'
|
||||||
|
time.sleep(10) # Прерывание работы программы на заданное количество секунд
|
||||||
|
time.mktime(datLocal) # Преобразование времени из кортежа или структуры в число секунд с начала эпохи
|
||||||
|
1761258496.0
|
||||||
|
```
|
||||||
|
## 7. Графические функции.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import pylab
|
||||||
|
x=list(range(-3,55,4))
|
||||||
|
t=list(range(15))
|
||||||
|
pylab.plot(t,x) #Создание графика в оперативной памяти
|
||||||
|
pylab.title('Первый график')
|
||||||
|
pylab.xlabel('время')
|
||||||
|
pylab.ylabel('сигнал')
|
||||||
|
pylab.show() #Отображение графика на экране
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
На одном рисунке можно изображать несколько графиков
|
||||||
|
|
||||||
|
```py
|
||||||
|
X1=[12,6,8,10,7]
|
||||||
|
X2=[5,7,9,11,13]
|
||||||
|
pylab.plot(X1)
|
||||||
|
pylab.plot(X2)
|
||||||
|
pylab.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Построение круговой диаграммы
|
||||||
|
|
||||||
|
```py
|
||||||
|
region=['Центр','Урал','Сибирь','Юг'] #Метки для диаграммы
|
||||||
|
naselen=[65,12,23,17] # Значения для диаграммы
|
||||||
|
pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
|
||||||
|
pylab.show() #Отображение диаграммы
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
Построение гистограммы
|
||||||
|
```py
|
||||||
|
pylab.hist([1, 2, 3, 1, 1, 2, 2, 2, 2, 4, 4], bins = 4)
|
||||||
|
pylab.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
```py
|
||||||
|
pylab.bar(region, naselen)
|
||||||
|
pylab.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
## 8. Статистические функции из модуля statistics.
|
||||||
|
|
||||||
|
```py
|
||||||
|
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.mean([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднего
|
||||||
|
5
|
||||||
|
statistics.stdev([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднеквадратичного отклонения
|
||||||
|
2.7386127875258306
|
||||||
|
statistics.median([1, 2, 3, 4, 5, 6, 7, 8]) # Вычисление медианы
|
||||||
|
4.5
|
||||||
|
```
|
||||||
|
|
||||||
|
## 9. Завершила работу со средой
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,61 @@
|
|||||||
|
# Общее контрольное задание по теме 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) определения временных параметров.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import cmath # пункт 1
|
||||||
|
divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
|
||||||
|
(8.0, 2.6000000000000014)
|
||||||
|
|
||||||
|
import time # пункт 2
|
||||||
|
Time=time.time()
|
||||||
|
MosSec= Time + 3*60*60
|
||||||
|
MosTime=time.gmtime(MosSec)
|
||||||
|
print("Current time: {}:{}".format(MosTime.tm_hour, MosTime.tm_min))
|
||||||
|
Current time: 23:1
|
||||||
|
|
||||||
|
import random # пункт 3
|
||||||
|
Days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
|
||||||
|
random.sample(Days, 3)
|
||||||
|
['Wednesday', 'Tuesday', 'Monday']
|
||||||
|
|
||||||
|
random.choice(range(14, 33, 3)) # пункт 4
|
||||||
|
32
|
||||||
|
|
||||||
|
N = math.floor(random.gauss(15, 4)) # пункт 5
|
||||||
|
N
|
||||||
|
19
|
||||||
|
import string # модуль с латинским алфавитом
|
||||||
|
letters = random.sample(string.ascii_letters, N)
|
||||||
|
letters
|
||||||
|
['p', 'A', 'h', 'X', 'F', 'a', 'C', 'M', 'b', 'L', 'e', 'P', 'G', 'k', 'u', 'o', 'K', 'E', 'B']
|
||||||
|
|
||||||
|
timeDiff = round(time.time() - time.mktime(localTime)) # пункт 6
|
||||||
|
print(timeDiff // 60, "minutes and", timeDiff % 60, "seconds")
|
||||||
|
40 minutes and 36 seconds
|
||||||
|
```
|
||||||
@ -0,0 +1,40 @@
|
|||||||
|
# Индивидуальное контрольное задание по теме 4
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## Задание вариант 23
|
||||||
|
|
||||||
|
Напишите инструкцию запоминания в переменной Московского регионального времени.
|
||||||
|
```py
|
||||||
|
import time
|
||||||
|
time_now = time.localtime() # полное время
|
||||||
|
time_now
|
||||||
|
time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=12, tm_min=13, tm_sec=23, tm_wday=4, tm_yday=297, tm_isdst=0)
|
||||||
|
time_now = time.time() # время в секундах
|
||||||
|
time_now
|
||||||
|
1761296218.109631
|
||||||
|
```
|
||||||
|
Добавьте к этому времени 3 часа.
|
||||||
|
Отобразите результат в виде: «Число секунд =ХХХХХ».
|
||||||
|
```py
|
||||||
|
time_new = time_now+(3*60*60) # 3 часа перевод в секунды
|
||||||
|
print("Число секунд = ", time_new)
|
||||||
|
Число секунд = 1761307018.109631
|
||||||
|
```
|
||||||
|
Создайте комплексное число, у которого вещественная и мнимая части – случайные, нормально распределенные числа с математическим ожиданием -55 и стандартным отклонением 12.
|
||||||
|
|
||||||
|
Извлеките из этого числа квадратный корень.
|
||||||
|
|
||||||
|
Отобразите результат в виде: «Результат = ХХХ+ХХj».
|
||||||
|
|
||||||
|
```py
|
||||||
|
import random
|
||||||
|
import cmath
|
||||||
|
a = random.normalvariate(-55, 12) # случайные нормально распределенные числа с мат ожиданием -55, и стандартным отклонением 12.
|
||||||
|
b = random.normalvariate(-55, 12)
|
||||||
|
z = complex(a, b)
|
||||||
|
z
|
||||||
|
(-48.00248180546525-48.574962483174176j)
|
||||||
|
sqr = cmath.sqrt(z)
|
||||||
|
print('Результат = ', sqr.real, sqr.imag, 'j')
|
||||||
|
Результат = 3.185065441113534 -7.625426130364191j
|
||||||
|
```
|
||||||
|
После Ширина: | Высота: | Размер: 114 KiB |
|
После Ширина: | Высота: | Размер: 43 KiB |
@ -0,0 +1,290 @@
|
|||||||
|
# Отчет по теме 5
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## 1. Открыла интерактивуню оболочку IDLE и создала файл отчета.
|
||||||
|
|
||||||
|
## 2. Ветвление по условию - управляющая конструкция if else
|
||||||
|
Задали некоторые числовые значения объектам porog, rashod1, rashod2. Выполнили операцию
|
||||||
|
для определения значения dohod:
|
||||||
|
```py
|
||||||
|
porog = 3
|
||||||
|
rashod1 = 5
|
||||||
|
rashod2 = 4
|
||||||
|
|
||||||
|
if rashod1>=porog:
|
||||||
|
dohod=12
|
||||||
|
elif rashod2==porog:
|
||||||
|
dohod=0
|
||||||
|
else:
|
||||||
|
dohod=-8
|
||||||
|
dohod
|
||||||
|
12
|
||||||
|
|
||||||
|
if rashod1>=3 and rashod2==4:
|
||||||
|
dohod=rashod1
|
||||||
|
if rashod2==porog or rashod1<rashod2:
|
||||||
|
dohod=porog
|
||||||
|
|
||||||
|
dohod
|
||||||
|
5
|
||||||
|
|
||||||
|
if porog==3:
|
||||||
|
dohod=1
|
||||||
|
elif porog==4:
|
||||||
|
dohod=2
|
||||||
|
elif porog==5:
|
||||||
|
dohod=3
|
||||||
|
else:
|
||||||
|
dohod=0
|
||||||
|
|
||||||
|
dohod
|
||||||
|
1
|
||||||
|
```
|
||||||
|
Условные инструкции могут записываться также в одну строку в операторе присваивания по
|
||||||
|
следующей схеме:
|
||||||
|
<Объект>=<значение 1> if <условие> else <значение 2>
|
||||||
|
или
|
||||||
|
if <условие>: <инструкция1>[;<инструкция2>….]
|
||||||
|
|
||||||
|
```py
|
||||||
|
dohod=2 if porog>=4 else 0
|
||||||
|
dohod
|
||||||
|
0
|
||||||
|
if porog>=5 : rashod1=6; rashod2=0
|
||||||
|
rashod1, rashod2
|
||||||
|
(5, 4)
|
||||||
|
```
|
||||||
|
|
||||||
|
## 3. Цикл по перечислению - управляющая констркуция for
|
||||||
|
|
||||||
|
### 3.1. Простой цикл
|
||||||
|
|
||||||
|
```py
|
||||||
|
temperatura=5
|
||||||
|
for i in range(3,18,3): # цикл от 3 до 18 с шагом 3
|
||||||
|
temperatura+=i
|
||||||
|
temperatura
|
||||||
|
50
|
||||||
|
```
|
||||||
|
### 3.2. Более сложный цикл
|
||||||
|
|
||||||
|
```py
|
||||||
|
sps=[2,15,14,8]
|
||||||
|
for k in sps:
|
||||||
|
if len(sps)<=10:sps.append(sps[0])
|
||||||
|
else:break
|
||||||
|
|
||||||
|
sps
|
||||||
|
[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
|
||||||
|
```
|
||||||
|
### 3.3. Пример создания списка с 10 целыми случайными числами
|
||||||
|
|
||||||
|
```py
|
||||||
|
for i in range(10):
|
||||||
|
sps5.append(rn.randint(1,100))
|
||||||
|
ss=sum(sps5)
|
||||||
|
if ss>500: break
|
||||||
|
else:
|
||||||
|
print(ss)
|
||||||
|
|
||||||
|
sps5
|
||||||
|
[27, 84, 92, 90, 10, 39, 46, 63, 88]
|
||||||
|
ss
|
||||||
|
539
|
||||||
|
|
||||||
|
# Вывод ss происходит только в случае если цикл for завершается самостоятельно без break т.е. ss < 500
|
||||||
|
|
||||||
|
for i in range(3):
|
||||||
|
sps5.append(rn.randint(1,100))
|
||||||
|
ss=sum(sps5)
|
||||||
|
if ss>500: break
|
||||||
|
else:
|
||||||
|
print(ss)
|
||||||
|
|
||||||
|
186
|
||||||
|
```
|
||||||
|
### 3.4. Пример с символьной строкой
|
||||||
|
|
||||||
|
```py
|
||||||
|
# цикл идет по каждому символу и сохраняет их в ss
|
||||||
|
stroka='Это – автоматизированная система'
|
||||||
|
stroka1=""
|
||||||
|
for ss in stroka:
|
||||||
|
stroka1+=" "+ss
|
||||||
|
|
||||||
|
stroka1
|
||||||
|
' Э т о – а в т о м а т и з и р о в а н н а я с и с т е м а'
|
||||||
|
```
|
||||||
|
### 3.5. Запись цикла в строке.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import math
|
||||||
|
sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
|
||||||
|
pylab.title('График синусоидального сигнала')
|
||||||
|
pylab.plot(sps2)
|
||||||
|
pylab.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
## 4. Цикл "пока истинно условие" - управляющая конструкция While
|
||||||
|
### 4.1 Цикл со счетчиком
|
||||||
|
|
||||||
|
```py
|
||||||
|
rashod=300
|
||||||
|
while rashod: # Цикл закончится когда rashod = 0
|
||||||
|
print("Расход=",rashod)
|
||||||
|
rashod-=50
|
||||||
|
|
||||||
|
Расход= 300
|
||||||
|
Расход= 250
|
||||||
|
Расход= 200
|
||||||
|
Расход= 150
|
||||||
|
Расход= 100
|
||||||
|
Расход= 50
|
||||||
|
```
|
||||||
|
### 4.2. Пример с символьной строкой
|
||||||
|
|
||||||
|
```py
|
||||||
|
import math
|
||||||
|
stroka='Расчет процесса в объекте регулирования'
|
||||||
|
i=0
|
||||||
|
sps2=[]
|
||||||
|
while i<len(stroka):
|
||||||
|
r=1-2/(1+math.exp(0.1*i))
|
||||||
|
sps2.append(r)
|
||||||
|
print('Значение в момент',i,"=",r)
|
||||||
|
i+=1
|
||||||
|
Значение в момент 0 = 0.0
|
||||||
|
Значение в момент 1 = 0.049958374957880025
|
||||||
|
Значение в момент 2 = 0.09966799462495568
|
||||||
|
Значение в момент 3 = 0.14888503362331795
|
||||||
|
Значение в момент 4 = 0.197375320224904
|
||||||
|
Значение в момент 5 = 0.2449186624037092
|
||||||
|
Значение в момент 6 = 0.2913126124515909
|
||||||
|
Значение в момент 7 = 0.3363755443363322
|
||||||
|
Значение в момент 8 = 0.3799489622552249
|
||||||
|
Значение в момент 9 = 0.421899005250008
|
||||||
|
Значение в момент 10 = 0.4621171572600098
|
||||||
|
Значение в момент 11 = 0.5005202111902354
|
||||||
|
Значение в момент 12 = 0.5370495669980353
|
||||||
|
Значение в момент 13 = 0.5716699660851172
|
||||||
|
Значение в момент 14 = 0.6043677771171636
|
||||||
|
Значение в момент 15 = 0.6351489523872873
|
||||||
|
Значение в момент 16 = 0.6640367702678489
|
||||||
|
Значение в момент 17 = 0.6910694698329307
|
||||||
|
Значение в момент 18 = 0.7162978701990245
|
||||||
|
Значение в момент 19 = 0.7397830512740043
|
||||||
|
Значение в момент 20 = 0.7615941559557649
|
||||||
|
Значение в момент 21 = 0.7818063576087741
|
||||||
|
Значение в момент 22 = 0.8004990217606297
|
||||||
|
Значение в момент 23 = 0.8177540779702878
|
||||||
|
Значение в момент 24 = 0.8336546070121553
|
||||||
|
Значение в момент 25 = 0.8482836399575129
|
||||||
|
Значение в момент 26 = 0.8617231593133063
|
||||||
|
Значение в момент 27 = 0.874053287886007
|
||||||
|
Значение в момент 28 = 0.8853516482022625
|
||||||
|
Значение в момент 29 = 0.8956928738431645
|
||||||
|
Значение в момент 30 = 0.9051482536448664
|
||||||
|
Значение в момент 31 = 0.9137854901178277
|
||||||
|
Значение в момент 32 = 0.9216685544064713
|
||||||
|
Значение в момент 33 = 0.9288576214547277
|
||||||
|
Значение в момент 34 = 0.935409070603099
|
||||||
|
Значение в момент 35 = 0.9413755384972874
|
||||||
|
Значение в момент 36 = 0.9468060128462683
|
||||||
|
Значение в момент 37 = 0.9517459571646616
|
||||||
|
Значение в момент 38 = 0.9562374581277391
|
||||||
|
```
|
||||||
|
|
||||||
|
Представим в виде графика
|
||||||
|
|
||||||
|
```py
|
||||||
|
pylab.title('Сигнал на выходе инерционного звена')
|
||||||
|
pylab.plot(sps2, color='violet')
|
||||||
|
pylab.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
### 4.3. Определение является ли число простым
|
||||||
|
|
||||||
|
```py
|
||||||
|
chislo=267 #Проверяемое число
|
||||||
|
kandidat =chislo // 2 # Для значений chislo > 1
|
||||||
|
while kandidat > 1:
|
||||||
|
if chislo%kandidat == 0: # Остаток от деления
|
||||||
|
print(chislo, ' имеет множитель ', kandidat)
|
||||||
|
break # else выполняться не будет
|
||||||
|
kandidat -= 1
|
||||||
|
else: # При завершении цикла без break
|
||||||
|
print(chislo, ' является простым!')
|
||||||
|
|
||||||
|
267 имеет множитель 89
|
||||||
|
```
|
||||||
|
|
||||||
|
Выявим все простые числа от 250 до 300
|
||||||
|
|
||||||
|
```py
|
||||||
|
for chislo in range(250,301):
|
||||||
|
kandidat = chislo // 2
|
||||||
|
while kandidat > 1:
|
||||||
|
if chislo%kandidat == 0: # Остаток от деления
|
||||||
|
print(chislo, ' имеет множитель ', kandidat)
|
||||||
|
break # else выполняться не будет
|
||||||
|
kandidat -= 1
|
||||||
|
else: # При завершении цикла без break
|
||||||
|
print(chislo, ' является простым!')
|
||||||
|
|
||||||
|
|
||||||
|
250 имеет множитель 125
|
||||||
|
251 является простым!
|
||||||
|
252 имеет множитель 126
|
||||||
|
253 имеет множитель 23
|
||||||
|
254 имеет множитель 127
|
||||||
|
255 имеет множитель 85
|
||||||
|
256 имеет множитель 128
|
||||||
|
257 является простым!
|
||||||
|
258 имеет множитель 129
|
||||||
|
259 имеет множитель 37
|
||||||
|
260 имеет множитель 130
|
||||||
|
261 имеет множитель 87
|
||||||
|
262 имеет множитель 131
|
||||||
|
263 является простым!
|
||||||
|
264 имеет множитель 132
|
||||||
|
265 имеет множитель 53
|
||||||
|
266 имеет множитель 133
|
||||||
|
267 имеет множитель 89
|
||||||
|
268 имеет множитель 134
|
||||||
|
269 является простым!
|
||||||
|
270 имеет множитель 135
|
||||||
|
271 является простым!
|
||||||
|
272 имеет множитель 136
|
||||||
|
273 имеет множитель 91
|
||||||
|
274 имеет множитель 137
|
||||||
|
275 имеет множитель 55
|
||||||
|
276 имеет множитель 138
|
||||||
|
277 является простым!
|
||||||
|
278 имеет множитель 139
|
||||||
|
279 имеет множитель 93
|
||||||
|
280 имеет множитель 140
|
||||||
|
281 является простым!
|
||||||
|
282 имеет множитель 141
|
||||||
|
283 является простым!
|
||||||
|
284 имеет множитель 142
|
||||||
|
285 имеет множитель 95
|
||||||
|
286 имеет множитель 143
|
||||||
|
287 имеет множитель 41
|
||||||
|
288 имеет множитель 144
|
||||||
|
289 имеет множитель 17
|
||||||
|
290 имеет множитель 145
|
||||||
|
291 имеет множитель 97
|
||||||
|
292 имеет множитель 146
|
||||||
|
293 является простым!
|
||||||
|
294 имеет множитель 147
|
||||||
|
295 имеет множитель 59
|
||||||
|
296 имеет множитель 148
|
||||||
|
297 имеет множитель 99
|
||||||
|
298 имеет множитель 149
|
||||||
|
299 имеет множитель 23
|
||||||
|
300 имеет множитель 150
|
||||||
|
```
|
||||||
|
## 5. Завершила работу со средой и сохранила файл отчета.
|
||||||
@ -0,0 +1,94 @@
|
|||||||
|
# Общее контрольное задание по теме 5
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Реализовать, записать в текстовый файл программы и результаты их выполнения при решении
|
||||||
|
следующих задач:
|
||||||
|
|
||||||
|
1. Для заданной символьной строки с англоязычным текстом определите порядковый номер каждой буквы в английском алфавите.
|
||||||
|
|
||||||
|
```py
|
||||||
|
alphabet = "abcdefghijklmnopqrstuvwxyz"
|
||||||
|
for letter in alphabet:
|
||||||
|
if letter.isalpha():
|
||||||
|
position = ord(letter) - 96
|
||||||
|
print(letter, ' Номер буквы: ', position)
|
||||||
|
a Номер буквы: 1
|
||||||
|
b Номер буквы: 2
|
||||||
|
c Номер буквы: 3
|
||||||
|
d Номер буквы: 4
|
||||||
|
e Номер буквы: 5
|
||||||
|
f Номер буквы: 6
|
||||||
|
g Номер буквы: 7
|
||||||
|
h Номер буквы: 8
|
||||||
|
i Номер буквы: 9
|
||||||
|
j Номер буквы: 10
|
||||||
|
k Номер буквы: 11
|
||||||
|
l Номер буквы: 12
|
||||||
|
m Номер буквы: 13
|
||||||
|
n Номер буквы: 14
|
||||||
|
o Номер буквы: 15
|
||||||
|
p Номер буквы: 16
|
||||||
|
q Номер буквы: 17
|
||||||
|
r Номер буквы: 18
|
||||||
|
s Номер буквы: 19
|
||||||
|
t Номер буквы: 20
|
||||||
|
u Номер буквы: 21
|
||||||
|
v Номер буквы: 22
|
||||||
|
w Номер буквы: 23
|
||||||
|
x Номер буквы: 24
|
||||||
|
y Номер буквы: 25
|
||||||
|
z Номер буквы: 26
|
||||||
|
```
|
||||||
|
2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли
|
||||||
|
в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о
|
||||||
|
нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с
|
||||||
|
отсутствующим словом).
|
||||||
|
|
||||||
|
```py
|
||||||
|
stroka = '''Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли
|
||||||
|
в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о
|
||||||
|
нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с
|
||||||
|
отсутствующим словом).'''
|
||||||
|
if 'привет' in stroka:
|
||||||
|
print('такое слово есть')
|
||||||
|
else:
|
||||||
|
print('такого слова не нашлось(')
|
||||||
|
|
||||||
|
такого слова не нашлось(
|
||||||
|
|
||||||
|
if 'список' in stroka:
|
||||||
|
print('такое слово есть')
|
||||||
|
else:
|
||||||
|
print('такого слова не нашлось(')
|
||||||
|
|
||||||
|
такое слово есть
|
||||||
|
```
|
||||||
|
|
||||||
|
3. Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней
|
||||||
|
сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных
|
||||||
|
списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции,
|
||||||
|
позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям
|
||||||
|
|
||||||
|
|
||||||
|
```py
|
||||||
|
familii = ['Антонов', 'Девятова', 'Ефимова']
|
||||||
|
marks_summer = [5,5,4]
|
||||||
|
familii2 = ['Ефимова', 'Антонов', 'Девятова']
|
||||||
|
marks_winter = [4,5,5]
|
||||||
|
name = input('Введите фамилию: ')
|
||||||
|
Введите фамилию: Антонов
|
||||||
|
|
||||||
|
for name in familii:
|
||||||
|
result = (marks_summer[familii.index(name)] + marks_winter[familii2.index(name)])/2
|
||||||
|
print('Средний балл: ', result)
|
||||||
|
break
|
||||||
|
|
||||||
|
Средний балл: 5.0
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,33 @@
|
|||||||
|
# Индивидуальное контрольное задание вариант 25
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## Задание
|
||||||
|
Создайте список с 50 элементами – целыми случайными числами из диапазона значений от -1 до +1.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import random
|
||||||
|
for i in range(50):
|
||||||
|
sps.append(random.randint(-1, 1))
|
||||||
|
sps
|
||||||
|
[1, 0, 0, 1, -1, -1, 1, 1, 0, -1, -1, -1, 0, 1, 1, -1, -1, -1, 0, 0, -1, 1, 0, -1, 1, -1, 1, 0, 0, -1, 0, 1, 0, 0, 1, -1, 1, 0, 0, -1, 0, -1, 0, -1, 1, 1, -1, -1, 1, 1]
|
||||||
|
```
|
||||||
|
|
||||||
|
Определите по этому списку, сколько раз последующее число было меньше предыдущего, сколько – больше и сколько – равным.
|
||||||
|
Отобразите результат в виде строки: «Больше=ХХ, меньше=ХХ, равно=ХХ».
|
||||||
|
|
||||||
|
```py
|
||||||
|
big = 0 # счетчики
|
||||||
|
small =0
|
||||||
|
equal = 0
|
||||||
|
for i in range(len(sps)-1):
|
||||||
|
current = sps[i]
|
||||||
|
next_num = sps[i+1]
|
||||||
|
if next_num < current:
|
||||||
|
small += 1
|
||||||
|
elif next_num > current:
|
||||||
|
big += 1
|
||||||
|
else: equal += 1
|
||||||
|
|
||||||
|
print('Больше =', big, ' Меньше =', small, ' Равно = ', equal)
|
||||||
|
Больше = 16 Меньше = 18 Равно = 33
|
||||||
|
```
|
||||||
@ -0,0 +1,373 @@
|
|||||||
|
# Отчет по теме 6
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## 1. Запустила интерактивную оболочку и создала файл отчета
|
||||||
|
|
||||||
|
## 2. Вывод данных на экран дисплея
|
||||||
|
### 2.1. Вывод в командной строке
|
||||||
|
Эхо-вывод строки. Нельзя использовать в пользовательских функциях.
|
||||||
|
|
||||||
|
```py
|
||||||
|
stroka='Автоматизированная система управления'
|
||||||
|
stroka
|
||||||
|
'Автоматизированная система управления'
|
||||||
|
```
|
||||||
|
|
||||||
|
### 2.2. Вывод с использованием функции print
|
||||||
|
|
||||||
|
```py
|
||||||
|
fff=234.5;gg='Значение температуры = '
|
||||||
|
print(gg, fff) #Можно вывести несколько объектов за одно обращение к функции
|
||||||
|
Значение температуры = 234.5
|
||||||
|
print(gg, fff, sep='/') # изменили разделитель по умолчанию на /
|
||||||
|
Значение температуры = /234.5
|
||||||
|
```
|
||||||
|
После вывода автоматически осуществляется переход на другую строку. Если курсор надо
|
||||||
|
оставить в той же строке, то следует использовать еще один аргумент.
|
||||||
|
После end указано какими символами кончается строка
|
||||||
|
```py
|
||||||
|
print(gg, fff,sep='/',end='***'); print('____')
|
||||||
|
Значение температуры = /234.5***____
|
||||||
|
```
|
||||||
|
Оператор вывода может располагаться на нескольких строках с использованием
|
||||||
|
тройных кавычек
|
||||||
|
```py
|
||||||
|
print(""" Здесь может выводиться
|
||||||
|
большой текст,
|
||||||
|
занимающий несколько строк""")
|
||||||
|
Здесь может выводиться
|
||||||
|
большой текст,
|
||||||
|
занимающий несколько строк
|
||||||
|
print("Здесь может выводиться",
|
||||||
|
"большой текст,",
|
||||||
|
"занимающий несколько строк")
|
||||||
|
Здесь может выводиться большой текст, занимающий несколько строк
|
||||||
|
```
|
||||||
|
### 2.3. Вывод с использованием метода write объекта sys.stdout.
|
||||||
|
stdout представляет собой
|
||||||
|
поток стандартного вывода – объект, в который программы выводят символьное представление данных.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import sys
|
||||||
|
sys.stdout.write('Функция write')
|
||||||
|
Функция write13
|
||||||
|
sys.stdout.write('Функция write\n') # \n перенос на следующую строку
|
||||||
|
Функция write
|
||||||
|
14
|
||||||
|
```
|
||||||
|
|
||||||
|
## 3. Ввод данных с клавиатуры
|
||||||
|
|
||||||
|
```py
|
||||||
|
psw=input('Введите пароль:')
|
||||||
|
Введите пароль: 1234
|
||||||
|
psw
|
||||||
|
' 1234'
|
||||||
|
type(psw)
|
||||||
|
<class 'str'>
|
||||||
|
```
|
||||||
|
Ввод с контролем значения
|
||||||
|
```py
|
||||||
|
while True:
|
||||||
|
znach=float(input('Задайте коэф.усиления = '))
|
||||||
|
if znach<17.5 or znach>23.8:
|
||||||
|
print('Ошибка!')
|
||||||
|
else:
|
||||||
|
break
|
||||||
|
|
||||||
|
Задайте коэф.усиления = 4
|
||||||
|
Ошибка!
|
||||||
|
Задайте коэф.усиления = 20
|
||||||
|
```
|
||||||
|
Вывод и обработка выражения, подлежащего расчету
|
||||||
|
|
||||||
|
```py
|
||||||
|
import math
|
||||||
|
print(eval(input('введите выражение для расчета = ')))
|
||||||
|
введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
|
||||||
|
1.34504378689765
|
||||||
|
```
|
||||||
|
## 4. Ввод-вывод данных при работе с файлами
|
||||||
|
Работа с файлом требует указания источника данных - полного имени файла с путем доступа к его расположению.
|
||||||
|
|
||||||
|
### 4.1. Функции для работы с путем к файлу
|
||||||
|
```py
|
||||||
|
os.getcwd ()
|
||||||
|
'C:\\Users\\Людмила\\AppData\\Local\\Programs\\Python\\Python313'
|
||||||
|
way = os.getcwd() # сохранили путь в переменную
|
||||||
|
way
|
||||||
|
'C:\\Users\\Людмила\\AppData\\Local\\Programs\\Python\\Python313'
|
||||||
|
```
|
||||||
|
Установили новый рабочий каталог
|
||||||
|
```py
|
||||||
|
os.chdir('H:\\study\\ПОАС')
|
||||||
|
os.getcwd ()
|
||||||
|
'H:\\study\\ПОАС'
|
||||||
|
```
|
||||||
|
В модуле os также есть функции, позволяющие удалять и создавать директории.
|
||||||
|
|
||||||
|
```py
|
||||||
|
os.listdir() #Возвращает список имен файлов находящихся в рабочей директории
|
||||||
|
['New directory', 'report — копия.odt', 'report3.md', 'report4.md', 'report5.md', 'report6.txt', 'Ris1.png', 'Ris2.png', 'task.md', 'task3.md', 'task4.md', 'Методические указания по ПОАС.pdf', 'репозиторий', 'Тест по модулю 1 ПОАС.docx']
|
||||||
|
os.path.isdir("New directory"); os.path.isdir("test333") # Проверка наличия директории в рабочем каталоге
|
||||||
|
True
|
||||||
|
False
|
||||||
|
os.rmdir('New directory') # Удаление директории
|
||||||
|
os.listdir()
|
||||||
|
['report — копия.odt', 'report3.md', 'report4.md', 'report5.md', 'report6.txt', 'Ris1.png', 'Ris2.png', 'task.md', 'task3.md', 'task4.md', 'Методические указания по ПОАС.pdf', 'репозиторий', 'Тест по модулю 1 ПОАС.docx']
|
||||||
|
```
|
||||||
|
Можно также получить путь к файлу
|
||||||
|
|
||||||
|
```py
|
||||||
|
fil=os.path.abspath("report5.md")
|
||||||
|
fil
|
||||||
|
'H:\\study\\ПОАС\\report5.md'
|
||||||
|
drkt = os.path.dirname(fil)
|
||||||
|
drkt
|
||||||
|
'H:\\study\\ПОАС'
|
||||||
|
name = os.path.basename(fil) # Выделение имени файла
|
||||||
|
name
|
||||||
|
'report5.md'
|
||||||
|
directory, fileName = os.path.split(fil) # Разделяет путь к файлу на путь доступа к файлу и его имя (Возвращает кортеж из этих двух составляющих)
|
||||||
|
print(directory);print(fileName)
|
||||||
|
H:\study\ПОАС
|
||||||
|
report5.md
|
||||||
|
```
|
||||||
|
Проверка указывает ли путь к нужному файлу
|
||||||
|
|
||||||
|
```py
|
||||||
|
os.path.isfile(fil) # Проверка пути к файлу
|
||||||
|
True
|
||||||
|
os.path.isfile("test.txt")
|
||||||
|
False
|
||||||
|
```
|
||||||
|
### 4.2. Общая схема работы с файлами
|
||||||
|
|
||||||
|
Для обмена данными с файлом необходимо выполнить следующие операции:
|
||||||
|
Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
|
||||||
|
|
||||||
|
Выполнение одной или нескольких операций обмена данными с файлом;
|
||||||
|
|
||||||
|
Закрытие файла.
|
||||||
|
|
||||||
|
### 4.3. Открытие файла для записи или чтения данных - функция open
|
||||||
|
При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним.
|
||||||
|
fp – это файловый объект, сохраняет ссылку на открываемый файл.
|
||||||
|
|
||||||
|
w – запись с созданием нового файла или перезапись существующего файла,
|
||||||
|
w+ - чтение и запись/перезапись файла,
|
||||||
|
r – только чтение (это значение - по умолчанию),
|
||||||
|
r+ - чтение и/или запись в существующий файл,
|
||||||
|
a – запись в конец существующего файла или, если его нет, запись с созданием файла,
|
||||||
|
a+ - то же, что и в «a», но с возможностью чтения из файла.
|
||||||
|
|
||||||
|
```py
|
||||||
|
fp=open(file=drkt+'\\zapis1.txt',mode='w') # открыли файл для записи данных
|
||||||
|
fp=open(drkt+'\\zapis1.txt','w') # имена аргументов можно опустить
|
||||||
|
fp=open('zapis1.txt','w') # Открытие файла, путь к которому совпадает с рабочим каталогом
|
||||||
|
|
||||||
|
type(fp)
|
||||||
|
<class '_io.TextIOWrapper'>
|
||||||
|
dir(fp)
|
||||||
|
['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
|
||||||
|
```
|
||||||
|
### 4.4. Закрытие файла
|
||||||
|
```py
|
||||||
|
fp.close()
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.5. Запись информации в файл
|
||||||
|
Можно записать информацию в файл с помощью метода write
|
||||||
|
|
||||||
|
```py
|
||||||
|
sps=list(range(1,13))
|
||||||
|
sps
|
||||||
|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||||
|
fp2 = open("zapis3.txt", "w") # запись первых 4 значений и перенос строки
|
||||||
|
fp2.write(str(sps[:4])+'\n')
|
||||||
|
13
|
||||||
|
fp2.write(str(sps[4:8])+'\n')
|
||||||
|
13
|
||||||
|
fp2.write(str(sps[8:])+'\n')
|
||||||
|
16
|
||||||
|
fp2.close()
|
||||||
|
```
|
||||||
|
Содержимое файла
|
||||||
|
```py
|
||||||
|
[1, 2, 3, 4]
|
||||||
|
[5, 6, 7, 8]
|
||||||
|
[9, 10, 11, 12]
|
||||||
|
```
|
||||||
|
Запись данных внутри цикла
|
||||||
|
```py
|
||||||
|
sps3 = [["Иванов И.", 1], ["Петров П.", 2], ["Сидоров С.", 3]]
|
||||||
|
for i in range(len(sps3)):
|
||||||
|
stroka4=sps3[i][0]+' '+str(sps3[i][1])
|
||||||
|
fp3.write(stroka4)
|
||||||
|
|
||||||
|
11
|
||||||
|
11
|
||||||
|
12
|
||||||
|
fp3.close()
|
||||||
|
```
|
||||||
|
Содержимое файла
|
||||||
|
```py
|
||||||
|
Иванов И. 1Петров П. 2Сидоров С. 3
|
||||||
|
```
|
||||||
|
Запишем иначе
|
||||||
|
```py
|
||||||
|
fp3=open('zapis5.txt','w')
|
||||||
|
for r in sps3:
|
||||||
|
fp3.write(r[0]+' '+str(r[1])+'\n')
|
||||||
|
|
||||||
|
12
|
||||||
|
12
|
||||||
|
13
|
||||||
|
for r in sps3: fp3.write(r[0]+' '+str(r[1])+'\n') # в одну строку
|
||||||
|
12
|
||||||
|
12
|
||||||
|
13
|
||||||
|
```
|
||||||
|
Содержимое файла
|
||||||
|
```py
|
||||||
|
Иванов И. 1
|
||||||
|
Петров П. 2
|
||||||
|
Сидоров С. 3
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.6. Чтение информации из текстового файла внутри цикла.
|
||||||
|
Чтение данных из файла происходит последовательно, начиная с некоторого символа. В качестве примера прочитан ранее созданный файл zapis3.txt:
|
||||||
|
```py
|
||||||
|
fp=open('zapis3.txt')
|
||||||
|
for stroka in fp:
|
||||||
|
stroka=stroka.rstrip('\n')
|
||||||
|
stroka=stroka.replace('[','')
|
||||||
|
stroka=stroka.replace(']','')
|
||||||
|
sps1=sps1+stroka.split(',')
|
||||||
|
|
||||||
|
fp.close()
|
||||||
|
sps1
|
||||||
|
['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
|
||||||
|
```
|
||||||
|
Сделаем чтобы элементы совпадали с исходными
|
||||||
|
|
||||||
|
```py
|
||||||
|
for i in range(len(sps1)):
|
||||||
|
sps1[i] = int(sps1[i])
|
||||||
|
sps1
|
||||||
|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
|
||||||
|
```
|
||||||
|
### 4.7. Чтение информации с помощью метода read
|
||||||
|
Метод read, также как и write, относится к объекту - файловой переменной.
|
||||||
|
|
||||||
|
```py
|
||||||
|
fp=open('zapis3.txt')
|
||||||
|
stroka1=fp.read(12)
|
||||||
|
stroka2=fp.read()
|
||||||
|
fp.close()
|
||||||
|
stroka2
|
||||||
|
'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
|
||||||
|
stroka1
|
||||||
|
'[1, 2, 3, 4]'
|
||||||
|
```
|
||||||
|
### 4.8. Чтение информации с помощью методов readline и readlines
|
||||||
|
|
||||||
|
```py
|
||||||
|
fp = open("zapis3.txt")
|
||||||
|
stroka1 = fp.readline() # Чтение первой строки файла
|
||||||
|
stroka2 = fp.readline() # Чтение второй строки файла
|
||||||
|
fp.close()
|
||||||
|
fp = open("zapis3.txt")
|
||||||
|
stroka3 = fp.readlines() # Чтение всех строк файла
|
||||||
|
fp.close()
|
||||||
|
stroka1
|
||||||
|
'[1, 2, 3, 4]\n'
|
||||||
|
stroka2
|
||||||
|
'[5, 6, 7, 8]\n'
|
||||||
|
stroka3
|
||||||
|
['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
|
||||||
|
```
|
||||||
|
### 4.9. Ввод-вывод объектов с использованием функций из модуля pickle.
|
||||||
|
Для работы с бинарными файлами можно пользоваться функциями из модуля pickle. Примером этого может послужить запись объекта-множества в бинарный файл:
|
||||||
|
```py
|
||||||
|
import pickle
|
||||||
|
mnoz1={'pen','book','pen','iPhone','table','book'} #Объект типа «множество»
|
||||||
|
fp=open('zapis6.mnz','wb') # Бинарный файл – на запись
|
||||||
|
pickle.dump(mnoz1,fp) #dump – метод записи объекта в файл
|
||||||
|
fp.close()
|
||||||
|
|
||||||
|
fp=open('zapis6.mnz','rb')
|
||||||
|
mnoz2=pickle.load(fp) #load – метод чтения объекта из бинарного файла
|
||||||
|
fp.close()
|
||||||
|
mnoz1
|
||||||
|
{'iPhone', 'pen', 'book', 'table'}
|
||||||
|
mnoz2
|
||||||
|
{'pen', 'table', 'book', 'iPhone'}
|
||||||
|
mnoz2 == mnoz1
|
||||||
|
True
|
||||||
|
```
|
||||||
|
Получение объекта из файла можно осуществить с помощью метода load:
|
||||||
|
|
||||||
|
```py
|
||||||
|
fp = open("zapis6.mnz", "rb")
|
||||||
|
mnoz2 = pickle.load(fp) # Получение объекта из файла
|
||||||
|
fp.close()
|
||||||
|
fp = open("zapis7.2ob", "wb")
|
||||||
|
pickle.dump(mnoz1, fp)
|
||||||
|
pickle.dump(sps3, fp)
|
||||||
|
fp.close()
|
||||||
|
fp = open("zapis7.2ob", "rb")
|
||||||
|
obj1 = pickle.load(fp) # Получение объекта, записанного первым
|
||||||
|
obj2 = pickle.load(fp) # Получение объекта, записанного вторым
|
||||||
|
fp.close()
|
||||||
|
obj1
|
||||||
|
{'pen', 'table', 'book', 'iPhone'}
|
||||||
|
obj2
|
||||||
|
[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
|
||||||
|
```
|
||||||
|
## 5. Перенаправление потоков ввода и вывода данных.
|
||||||
|
Потоки ввода-вывода можно перенаправлять, например в файл:
|
||||||
|
|
||||||
|
```py
|
||||||
|
import sys
|
||||||
|
vr_out = sys.stdout # Сохранение текущего потока вывода
|
||||||
|
fc = open("Stroka.txt", "w")
|
||||||
|
sys.stdout = fc # Перезапись потока вывода с экрана на файл
|
||||||
|
print("Запись строки в файл")
|
||||||
|
fc.close()
|
||||||
|
sys.stdout = vr_out # Возвращение истинного значения потока вывода
|
||||||
|
print("Запись строки на экран")
|
||||||
|
Запись строки на экран
|
||||||
|
```
|
||||||
|
Содержимое файла
|
||||||
|
|
||||||
|
```py
|
||||||
|
Запись строки в файл
|
||||||
|
```
|
||||||
|
Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
|
||||||
|
|
||||||
|
```py
|
||||||
|
tmp_in = sys.stdin # Сохранение текущего потока ввода
|
||||||
|
fd = open("Stroka.txt", "r") # Открываем файл для ввода (чтения)
|
||||||
|
sys.stdin = fd # Перенацеливаем ввод на файл вместо клавиатуры
|
||||||
|
sys.stdin
|
||||||
|
<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
|
||||||
|
while True:
|
||||||
|
try:
|
||||||
|
line = input() # Чтение строки из файла
|
||||||
|
print(line)
|
||||||
|
except EOFError:
|
||||||
|
break
|
||||||
|
|
||||||
|
|
||||||
|
Запись строки в файл
|
||||||
|
|
||||||
|
fd.close()
|
||||||
|
```
|
||||||
|
## 6. Завершила работу со средой
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,90 @@
|
|||||||
|
# Общее контрольное задание по теме 6
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56,
|
||||||
|
представленными в виде символьных строк.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import random as rn
|
||||||
|
kort = tuple(str(rn.randint(6, 56)) for i in range(126))
|
||||||
|
kort
|
||||||
|
('42', '36', '38', '37', '20', '52', '26', '16', '21', '41', '7', '18', '56', '40', '16', '40', '10', '55', '13', '44', '26', '11', '49', '29', '51', '37', '11', '32', '51', '50', '22', '25', '6', '11', '17', '36', '34', '10', '35', '45', '36', '34', '30', '28', '13', '50', '53', '19', '54', '30', '55', '33', '27', '46', '33', '55', '41', '26', '44', '18', '51', '52', '13', '23', '38', '34', '9', '6', '18', '12', '37', '30', '46', '10', '40', '46', '20', '18', '7', '14', '38', '11', '16', '50', '31', '22', '37', '6', '34', '38', '11', '44', '27', '10', '35', '39', '10', '50', '47', '24', '29', '6', '38', '50', '15', '56', '9', '22', '55', '10', '17', '14', '8', '34', '37', '28', '50', '22', '41', '10', '34', '34', '9', '8', '18', '40')
|
||||||
|
```
|
||||||
|
|
||||||
|
Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
|
||||||
|
```py
|
||||||
|
sps = ['Ефимова', 'Антонов', 'Девятова', 'Гордиевских']
|
||||||
|
```
|
||||||
|
|
||||||
|
Записывается кортеж в бинарный файл.
|
||||||
|
Записывается в этот же файл список и закрывается файл.
|
||||||
|
```py
|
||||||
|
import pickle
|
||||||
|
import os
|
||||||
|
os.chdir('H:\\study\\ПОАС')
|
||||||
|
fp = open('task.bin', 'wb')
|
||||||
|
pickle.dump(kort, fp)
|
||||||
|
```
|
||||||
|
Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
|
||||||
|
```py
|
||||||
|
pickle.dump(sps, fp)
|
||||||
|
fp.close()
|
||||||
|
```
|
||||||
|
Проверяется на совпадение новых объектов с исходными и выводится соответствующее
|
||||||
|
сообщение.
|
||||||
|
```py
|
||||||
|
fp = open("task.bin", "rb")
|
||||||
|
newKort = pickle.load(fp)
|
||||||
|
obj1=pickle.load(fp)
|
||||||
|
fp.close()
|
||||||
|
newKort == kort; obj1 == sps
|
||||||
|
True
|
||||||
|
True
|
||||||
|
newKort
|
||||||
|
('42', '36', '38', '37', '20', '52', '26', '16', '21', '41', '7', '18', '56', '40', '16', '40', '10', '55', '13', '44', '26', '11', '49', '29', '51', '37', '11', '32', '51', '50', '22', '25', '6', '11', '17', '36', '34', '10', '35', '45', '36', '34', '30', '28', '13', '50', '53', '19', '54', '30', '55', '33', '27', '46', '33', '55', '41', '26', '44', '18', '51', '52', '13', '23', '38', '34', '9', '6', '18', '12', '37', '30', '46', '10', '40', '46', '20', '18', '7', '14', '38', '11', '16', '50', '31', '22', '37', '6', '34', '38', '11', '44', '27', '10', '35', '39', '10', '50', '47', '24', '29', '6', '38', '50', '15', '56', '9', '22', '55', '10', '17', '14', '8', '34', '37', '28', '50', '22', '41', '10', '34', '34', '9', '8', '18', '40')
|
||||||
|
obj1
|
||||||
|
['Ефимова', 'Антонов', 'Девятова', 'Гордиевских']
|
||||||
|
```
|
||||||
|
Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде
|
||||||
|
отдельных списков со своими именами.
|
||||||
|
```py
|
||||||
|
a={}
|
||||||
|
for i in range(0, len(kort), 5):
|
||||||
|
a['группа ' + str(i//5)] = list(kort[i:i+5])
|
||||||
|
|
||||||
|
for group_name, numbers in a.items():
|
||||||
|
print(f"{group_name}: {numbers}")
|
||||||
|
|
||||||
|
|
||||||
|
группа0: ['42', '36', '38', '37', '20']
|
||||||
|
группа1: ['52', '26', '16', '21', '41']
|
||||||
|
группа2: ['7', '18', '56', '40', '16']
|
||||||
|
группа3: ['40', '10', '55', '13', '44']
|
||||||
|
группа4: ['26', '11', '49', '29', '51']
|
||||||
|
группа5: ['37', '11', '32', '51', '50']
|
||||||
|
группа6: ['22', '25', '6', '11', '17']
|
||||||
|
группа7: ['36', '34', '10', '35', '45']
|
||||||
|
группа8: ['36', '34', '30', '28', '13']
|
||||||
|
группа9: ['50', '53', '19', '54', '30']
|
||||||
|
группа10: ['55', '33', '27', '46', '33']
|
||||||
|
группа11: ['55', '41', '26', '44', '18']
|
||||||
|
группа12: ['51', '52', '13', '23', '38']
|
||||||
|
группа13: ['34', '9', '6', '18', '12']
|
||||||
|
группа14: ['37', '30', '46', '10', '40']
|
||||||
|
группа15: ['46', '20', '18', '7', '14']
|
||||||
|
группа16: ['38', '11', '16', '50', '31']
|
||||||
|
группа17: ['22', '37', '6', '34', '38']
|
||||||
|
группа18: ['11', '44', '27', '10', '35']
|
||||||
|
группа19: ['39', '10', '50', '47', '24']
|
||||||
|
группа20: ['29', '6', '38', '50', '15']
|
||||||
|
группа21: ['56', '9', '22', '55', '10']
|
||||||
|
группа22: ['17', '14', '8', '34', '37']
|
||||||
|
группа23: ['28', '50', '22', '41', '10']
|
||||||
|
группа24: ['34', '34', '9', '8', '18']
|
||||||
|
группа25: ['40']
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,55 @@
|
|||||||
|
# Индивидуальное контрольное задание вариант 11
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Запросите у пользователя и введите имя функции из библиотеки math для обработки данных.
|
||||||
|
```py
|
||||||
|
import math
|
||||||
|
import os
|
||||||
|
import pickle
|
||||||
|
import random
|
||||||
|
|
||||||
|
func = input("Имя функции из модуля math: ")
|
||||||
|
Имя функции из модуля math: sqrt
|
||||||
|
func1 = getattr(math, func)
|
||||||
|
```
|
||||||
|
|
||||||
|
Создайте кортеж с 20 случайными равномерно распределенными числами из диапазона значений от 11 до 40.
|
||||||
|
```py
|
||||||
|
data = tuple(random.uniform(11, 40) for i in range(20))
|
||||||
|
print(data)
|
||||||
|
(27.586471737691216, 21.881793540024304, 32.028176641070715, 13.113820051694203, 26.94302061378759, 37.26299607155637, 19.024847631740833, 29.51898579825734, 11.113814609881052, 24.804710396240207, 14.220720732639323, 23.141556713603123, 25.602521683956827, 29.559769008668546, 15.73803346599436, 23.54457430801797, 22.29227709666803, 33.30664014943534, 38.76321330079019, 17.242719629575422)
|
||||||
|
```
|
||||||
|
|
||||||
|
Напишите инструкцию создания списка, содержащего значения, равные результаты вычисления заданной пользователем функции от соответствующих элементов кортежа.
|
||||||
|
```py
|
||||||
|
result = [func1(i) for i in data]
|
||||||
|
print(result)
|
||||||
|
[5.252282526453734, 4.6777979370665745, 5.659344188249263, 3.6213008783715006, 5.190666682978939, 6.104342394685637, 4.361748231127152, 5.433137748875629, 3.3337388334842686, 4.980432751904217, 3.7710370897989485, 4.8105671925047595, 5.059893445909393, 5.436889644702065, 3.9671190385460275, 4.85227516820903, 4.72146980257928, 5.771190531375249, 6.226011026394845, 4.152435385358262]
|
||||||
|
```
|
||||||
|
|
||||||
|
Выведите кортеж и результирующий список в бинарный файл с любым именем.
|
||||||
|
```py
|
||||||
|
os.chdir('L:\\III курс\\А-3-23\\Efimova lyudmila')
|
||||||
|
fp = open('test1.bin', 'wb')
|
||||||
|
pickle.dump(result, fp)
|
||||||
|
```
|
||||||
|
|
||||||
|
Рассчитайте среднее значение разностей элементов списка, находящихся на соседних четных и нечетных позициях.
|
||||||
|
Отобразите результат на экране.
|
||||||
|
```py
|
||||||
|
for i in range(1, len(result), 2):
|
||||||
|
diff = [result[i] - result[i-1]]
|
||||||
|
average = sum(diff)/len(diff)
|
||||||
|
print('Среднее значение разностей: ', average)
|
||||||
|
|
||||||
|
Среднее значение разностей: -0.5744845893871595
|
||||||
|
Среднее значение разностей: -2.0380433098777626
|
||||||
|
Среднее значение разностей: 0.9136757117066976
|
||||||
|
Среднее значение разностей: 1.0713895177484778
|
||||||
|
Среднее значение разностей: 1.646693918419948
|
||||||
|
Среднее значение разностей: 1.039530102705811
|
||||||
|
Среднее значение разностей: 0.3769961987926722
|
||||||
|
Среднее значение разностей: 0.8851561296630028
|
||||||
|
Среднее значение разностей: 1.0497207287959691
|
||||||
|
Среднее значение разностей: -2.073575641036583
|
||||||
|
```
|
||||||
|
После Ширина: | Высота: | Размер: 17 KiB |
|
После Ширина: | Высота: | Размер: 22 KiB |
@ -0,0 +1,490 @@
|
|||||||
|
# Отчет по теме 7
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
# Создание пользовательских функций
|
||||||
|
## 1. Настройка текущего каталога
|
||||||
|
|
||||||
|
```py
|
||||||
|
import os
|
||||||
|
os.chdir("H:\\study\\ПОАС")
|
||||||
|
```
|
||||||
|
## 2. Создание пользовательской функции
|
||||||
|
Создание функции предполагает выполнение трех операций: формирование функции, ее
|
||||||
|
сохранение и использование.
|
||||||
|
|
||||||
|
### 2.1. Пример функции без аргументов
|
||||||
|
|
||||||
|
```py
|
||||||
|
def uspeh():
|
||||||
|
"""Подтверждение успеха операции"""
|
||||||
|
print('Выполнено успешно!')
|
||||||
|
uspeh()
|
||||||
|
Выполнено успешно!
|
||||||
|
type(uspeh)
|
||||||
|
<class 'function'>
|
||||||
|
dir() # убедились что функция появилась в пространстве имен
|
||||||
|
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
|
||||||
|
help(uspeh) # инструкция выводит описание функции, указанное в тройных кавычках
|
||||||
|
Help on function uspeh in module __main__:
|
||||||
|
|
||||||
|
uspeh()
|
||||||
|
Подтверждение успеха операции
|
||||||
|
```
|
||||||
|
### 2.2. Пример функции с аргументами
|
||||||
|
|
||||||
|
```py
|
||||||
|
def sravnenie(a,b):
|
||||||
|
"""Сравнение a и b"""
|
||||||
|
if a>b:
|
||||||
|
print(a,' больше ',b)
|
||||||
|
elif a<b:
|
||||||
|
print(a, ' меньше ',b)
|
||||||
|
else:
|
||||||
|
print(a, ' равно ',b)
|
||||||
|
|
||||||
|
n,m=16,5;sravnenie(n,m)
|
||||||
|
16 больше 5
|
||||||
|
|
||||||
|
n,m="привет","пока";sravnenie(n,m) # сравнение символьных строк
|
||||||
|
привет больше пока
|
||||||
|
```
|
||||||
|
### 2.3. Пример функции, содержащей return.
|
||||||
|
|
||||||
|
```py
|
||||||
|
def logistfun(b,a):
|
||||||
|
"""Вычисление логистической функции"""
|
||||||
|
import math
|
||||||
|
return a/(1+math.exp(-b))
|
||||||
|
|
||||||
|
v,w=1,0.7;z=logistfun(w,v)
|
||||||
|
z
|
||||||
|
0.6681877721681662
|
||||||
|
```
|
||||||
|
### 2.4. Сложение для разных типов аргументов
|
||||||
|
|
||||||
|
```py
|
||||||
|
def slozh(a1,a2,a3,a4):
|
||||||
|
""" Сложение значений четырех аргументов"""
|
||||||
|
return a1+a2+a3+a4
|
||||||
|
|
||||||
|
slozh(1,2,3,4) # Сложение чисел
|
||||||
|
10
|
||||||
|
|
||||||
|
slozh('1','2','3','4') # Сложение строк
|
||||||
|
'1234'
|
||||||
|
b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
|
||||||
|
|
||||||
|
q=slozh(b1,b2,b3,b4) #Сложение списков
|
||||||
|
q
|
||||||
|
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||||
|
|
||||||
|
slozh((1, 2), (3, 4), (-1, -2), (-3,-4)) #Сложение кортежей
|
||||||
|
(1, 2, 3, 4, -1, -2, -3, -4)
|
||||||
|
|
||||||
|
slozh({1,2,3,4}, {'pym', True, 'pyrym', False}, {"l", "a", "n", 13}, {"hi", "i", "miss", "you"}) #Сложение множеств
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#31>", line 1, in <module>
|
||||||
|
slozh({1,2,3,4}, {'pym', True, 'pyrym', False}, {"l", "a", "n", 13}, {"hi", "i", "miss", "you"}) #Сложение множеств
|
||||||
|
File "<pyshell#23>", line 3, in slozh
|
||||||
|
return a1+a2+a3+a4
|
||||||
|
TypeError: unsupported operand type(s) for +: 'set' and 'set'
|
||||||
|
dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4}
|
||||||
|
|
||||||
|
slozh(dict1, dict2, dict3, dict4) #Сложение словарей
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#33>", line 1, in <module>
|
||||||
|
slozh(dict1, dict2, dict3, dict4) #Сложение словарей
|
||||||
|
File "<pyshell#23>", line 3, in slozh
|
||||||
|
return a1+a2+a3+a4
|
||||||
|
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
|
||||||
|
```
|
||||||
|
|
||||||
|
### 2.5. Функция, реализующая модель "Вход х - Выход у"
|
||||||
|
|
||||||
|
```py
|
||||||
|
def inerz(x,T,ypred):
|
||||||
|
""" Модель устройства с памятью:
|
||||||
|
x - текущее значение вх.сигнала,
|
||||||
|
T - постоянная времени,
|
||||||
|
ypred - предыдущее значение выхода устройства"""
|
||||||
|
y=(x+T*ypred)/(T+1)
|
||||||
|
return y
|
||||||
|
|
||||||
|
sps=[0]+[1]*100
|
||||||
|
spsy=[] #Заготовили список для значений выхода
|
||||||
|
TT=20 #Постоянная времени
|
||||||
|
yy=0 #Нулевое начальное условие
|
||||||
|
for xx in sps:
|
||||||
|
yy=inerz(xx,TT,yy)
|
||||||
|
spsy.append(yy)
|
||||||
|
|
||||||
|
plt.xlabel("t, время")
|
||||||
|
plt.ylabel("Выходной синал")
|
||||||
|
plt.grid(True)
|
||||||
|
plt.plot(spsy, label = "Выходной сигнал", color='purple')
|
||||||
|
plt.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
## 3. Функции как объекты
|
||||||
|
### 3.1. Получение списка атрибутов объекта-функции
|
||||||
|
|
||||||
|
```py
|
||||||
|
dir(inerz)
|
||||||
|
['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
|
||||||
|
inerz.__doc__ # пример использования атрибута функции
|
||||||
|
'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
|
||||||
|
help(inerz)
|
||||||
|
Help on function inerz in module __main__:
|
||||||
|
|
||||||
|
inerz(x, T, ypred) # получаем обработанную документацию
|
||||||
|
Модель устройства с памятью:
|
||||||
|
x- текущее значение вх.сигнала,
|
||||||
|
T -постоянная времени,
|
||||||
|
ypred - предыдущее значение выхода устройства
|
||||||
|
```
|
||||||
|
### 3.2. Сохранение ссылки на объект-функцию в другой переменной
|
||||||
|
```py
|
||||||
|
fnkt=sravnenie # сохраняем ссылку на функцию sravnenie в переменной fnkt
|
||||||
|
v=16fnkt(v,23)
|
||||||
|
16 меньше 23
|
||||||
|
```
|
||||||
|
### 3.3. Альтернативное определение функции в программе
|
||||||
|
|
||||||
|
```py
|
||||||
|
if typ_fun==1:
|
||||||
|
def func():
|
||||||
|
print('Функция 1')
|
||||||
|
else:
|
||||||
|
def func():
|
||||||
|
print('Функция 2')
|
||||||
|
|
||||||
|
func()
|
||||||
|
Функция 2 # так как значение не равно 1, то выполняется else
|
||||||
|
```
|
||||||
|
## 4. Аргументы функции
|
||||||
|
### 4.1. Использование функции в качестве аргумента другой функции
|
||||||
|
```py
|
||||||
|
def fun_arg(fff,a,b,c):
|
||||||
|
"""fff-имя функции, используемой
|
||||||
|
в качестве аргумента функции fun_arg"""
|
||||||
|
return a+fff(c,b)
|
||||||
|
|
||||||
|
zz=fun_arg(logistfun,-3,1,0.7)
|
||||||
|
zz
|
||||||
|
-2.3318122278318336
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.2. Обязательные и необязательные аргументы
|
||||||
|
|
||||||
|
```py
|
||||||
|
def logistfun(a,b=1): #Аргумент b – необязательный; значение по умолчанию=1
|
||||||
|
"""Вычисление логистической функции"""
|
||||||
|
import math
|
||||||
|
return b/(1+math.exp(-a))
|
||||||
|
|
||||||
|
logistfun(0.7) #Вычисление со значением b по умолчанию
|
||||||
|
0.6681877721681662
|
||||||
|
logistfun(0.7,2) #Вычисление с заданным значением b1.3363755443363323
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.3. Обращение к функции с произвольным (непозиционным) расположением аргументов
|
||||||
|
|
||||||
|
```py
|
||||||
|
logistfun(b=0.5,a=0.8) # Ссылки на аргументы поменялись местами
|
||||||
|
0.34498724056380625
|
||||||
|
```
|
||||||
|
### 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже
|
||||||
|
|
||||||
|
```py
|
||||||
|
b1234=[b1,b2,b3,b4] # Список списков из п.2.4
|
||||||
|
qq=slozh(*b1234) # Перед ссылкой на список или кортеж надо ставить звездочку
|
||||||
|
b1234
|
||||||
|
[[1, 2], [-1, -2], [0, 2], [-1, -1]]
|
||||||
|
qq
|
||||||
|
[1, 2, -1, -2, 0, 2, -1, -1]
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.5. Значения аргументов функции, содержащиеся в словаре
|
||||||
|
|
||||||
|
```py
|
||||||
|
dic4={"a1":1,"a2":2,"a3":3,"a4":4}
|
||||||
|
qqq=slozh(**dic4) #Перед ссылкой на словарь надо ставить две звездочки
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4.6. Смешанные ссылки
|
||||||
|
|
||||||
|
```py
|
||||||
|
e1=(-1,6);dd2={'a3':3,'a4':9}
|
||||||
|
qqqq=slozh(*e1,**dd2)
|
||||||
|
qqqq
|
||||||
|
17
|
||||||
|
```
|
||||||
|
### 4.7. Переменное число аргументов у функции
|
||||||
|
|
||||||
|
```py
|
||||||
|
def func4(*kort7):
|
||||||
|
"""Произвольное число аргументов в составе кортежа"""
|
||||||
|
smm=0
|
||||||
|
for elt in kort7:
|
||||||
|
smm+=elt
|
||||||
|
return smm
|
||||||
|
func4(-1,2) #Обращение к функции с 2 аргументами
|
||||||
|
1
|
||||||
|
func4(-1,2,0,3,6) #Обращение к функции с 5 аргументами
|
||||||
|
10
|
||||||
|
```
|
||||||
|
### 4.8. Комбинация аргументов
|
||||||
|
|
||||||
|
```py
|
||||||
|
def func4(a,b=7,*kort7): # Аргументы: a-позиционный, b- по умолчанию + кортеж
|
||||||
|
"""Кортеж - сборка аргументов - должен быть последним!"""
|
||||||
|
smm=0
|
||||||
|
for elt in kort7:
|
||||||
|
smm+=elt
|
||||||
|
return a*smm+b
|
||||||
|
func4(-1,2,0,3,6)
|
||||||
|
-7
|
||||||
|
|
||||||
|
def func5(a, b = 7, **slov7): # со словарем
|
||||||
|
"""Словарь - сборка аргументов - должен быть последним!"""
|
||||||
|
smm = 0
|
||||||
|
for elt in slov7.items():
|
||||||
|
smm = sum (slov7.values())
|
||||||
|
return a * smm + b
|
||||||
|
|
||||||
|
numbers = {"a1": 1, "a2": 2, "a3": 3, "a4": 4}
|
||||||
|
func5(1,2,**numbers)
|
||||||
|
12
|
||||||
|
```
|
||||||
|
### 4.9. Изменение значений объектов, используемых в качестве аргументов функции
|
||||||
|
|
||||||
|
```py
|
||||||
|
a=90 # Числовой объект – не изменяемый тип
|
||||||
|
def func3(b):
|
||||||
|
b=5*b+67
|
||||||
|
|
||||||
|
func3(a)
|
||||||
|
a # значение не изменилось
|
||||||
|
90
|
||||||
|
```
|
||||||
|
Пример со списком
|
||||||
|
|
||||||
|
```py
|
||||||
|
sps1=[1,2,3,4] #Список – изменяемый тип объекта
|
||||||
|
def func2(sps):
|
||||||
|
sps[1]=99
|
||||||
|
|
||||||
|
func2(sps1)
|
||||||
|
print(sps1)
|
||||||
|
[1, 99, 3, 4] # список изменился
|
||||||
|
|
||||||
|
kort=(1,2,3,4) #Кортеж – неизменяемый тип объекта
|
||||||
|
func2(kort)
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#104>", line 1, in <module>
|
||||||
|
func2(kort)
|
||||||
|
File "<pyshell#100>", line 2, in func2
|
||||||
|
sps[1]=99
|
||||||
|
TypeError: 'tuple' object does not support item assignment
|
||||||
|
```
|
||||||
|
## 5. Специальные типы пользовательских функций
|
||||||
|
### 5.1. Анонимные функции(лямбда-функции)
|
||||||
|
Функции без имени
|
||||||
|
```py
|
||||||
|
anfun1=lambda: 1.5+math.log10(17.23) #Анонимная функция без аргументов
|
||||||
|
anfun1() # Обращение к объекту-функции
|
||||||
|
2.7362852774480286
|
||||||
|
|
||||||
|
anfun2=lambda a,b: a+math.log10(b) #Анонимная функция с 2 аргументами
|
||||||
|
anfun2(17,234)
|
||||||
|
19.369215857410143
|
||||||
|
|
||||||
|
anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
|
||||||
|
anfun3(100)
|
||||||
|
102.36921585741014
|
||||||
|
```
|
||||||
|
### 5.2. Функции-генераторы
|
||||||
|
Это – такие функции, которые используются в итерационных процессах, позволяя на каждой
|
||||||
|
итерации получать одно из значений.
|
||||||
|
```py
|
||||||
|
def func5(diap,shag):
|
||||||
|
""" Итератор, возвращающий значения
|
||||||
|
из диапазона от 1 до diap с шагом shag"""
|
||||||
|
for j in range(1,diap+1,shag):
|
||||||
|
yield j # приостанавливает выполнение и возвращает очередное значение
|
||||||
|
|
||||||
|
for mm in func5(7,3):
|
||||||
|
print(mm)
|
||||||
|
1
|
||||||
|
4
|
||||||
|
7
|
||||||
|
```
|
||||||
|
метод __next__, активирует очередную итерацию выполнения функции
|
||||||
|
|
||||||
|
```py
|
||||||
|
alp=func5(7,3)
|
||||||
|
print(alp.__next__())
|
||||||
|
1
|
||||||
|
print(alp.__next__())
|
||||||
|
4
|
||||||
|
print(alp.__next__())
|
||||||
|
7
|
||||||
|
print(alp.__next__())
|
||||||
|
Traceback (most recent call last): # Функция уже выполнила последнюю итерацию, вернулась ошибка
|
||||||
|
File "<pyshell#122>", line 1, in <module>
|
||||||
|
print(alp.__next__())
|
||||||
|
StopIteration
|
||||||
|
```
|
||||||
|
## 6. Локализация объектов в функциях
|
||||||
|
Все объекты могут быть определены глобально или локально. Глобально определены вне функций
|
||||||
|
|
||||||
|
### 6.1. Примеры на локализацию объектов
|
||||||
|
Пример 1 Одноименные локальный и глобальный объекты:
|
||||||
|
```py
|
||||||
|
glb=10
|
||||||
|
def func7(arg):
|
||||||
|
loc1=15
|
||||||
|
glb=8
|
||||||
|
return loc1*arg
|
||||||
|
|
||||||
|
res=func7(glb)
|
||||||
|
res
|
||||||
|
150
|
||||||
|
glb # глобальное значение не изменилось
|
||||||
|
10
|
||||||
|
```
|
||||||
|
Пример 2 Ошибка в использовании локального объекта
|
||||||
|
|
||||||
|
```py
|
||||||
|
def func8(arg):
|
||||||
|
loc1=15
|
||||||
|
print(glb)
|
||||||
|
glb=8
|
||||||
|
return loc1*arg
|
||||||
|
|
||||||
|
res=func8(glb)
|
||||||
|
Traceback (most recent call last): # ошибка происходит так как вывод функции осуществляется в 3 строке функции, а ее объявляение в 4
|
||||||
|
File "<pyshell#131>", line 1, in <module>
|
||||||
|
res=func8(glb)
|
||||||
|
File "<pyshell#130>", line 3, in func8
|
||||||
|
print(glb)
|
||||||
|
UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
|
||||||
|
```
|
||||||
|
Пример 3 Переопределение локализации объекта
|
||||||
|
```py
|
||||||
|
glb=11
|
||||||
|
def func7(arg):
|
||||||
|
loc1=15
|
||||||
|
global glb
|
||||||
|
print(glb)
|
||||||
|
glb=8
|
||||||
|
return loc1*arg
|
||||||
|
|
||||||
|
res=func7(glb)
|
||||||
|
11
|
||||||
|
glb # значение изменится так как мы обратились к глобальной переменной внутри функции
|
||||||
|
8
|
||||||
|
```
|
||||||
|
### 6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins
|
||||||
|
|
||||||
|
```py
|
||||||
|
globals().keys() #Перечень глобальных объектов
|
||||||
|
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'b'])
|
||||||
|
locals().keys() #Перечень локальных объектов
|
||||||
|
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'b'])
|
||||||
|
```
|
||||||
|
Сейчас они не отличаются, так как эти методы возвращают объекты на уровне вызова этих функций.
|
||||||
|
|
||||||
|
```py
|
||||||
|
hh=func8(glb)
|
||||||
|
dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'b']) # глобальные переменные
|
||||||
|
dict_keys(['arg', 'loc1', 'glb']) # локальные переменные
|
||||||
|
'glb' in globals().keys()
|
||||||
|
True
|
||||||
|
```
|
||||||
|
### 6.3. Локализация объектов при использовании вложенных функций
|
||||||
|
|
||||||
|
```py
|
||||||
|
def func9(arg2,arg3):
|
||||||
|
def func9_1(arg1):
|
||||||
|
loc1=15
|
||||||
|
glb1=8
|
||||||
|
print('glob_func9_1:',globals().keys())
|
||||||
|
print('locl_func9_1:',locals().keys())
|
||||||
|
return loc1*arg1
|
||||||
|
loc1=5
|
||||||
|
glb=func9_1(loc1)
|
||||||
|
print('loc_func9:',locals().keys())
|
||||||
|
print('glob_func9:',globals().keys())
|
||||||
|
return arg2+arg3*glb
|
||||||
|
kk=func9(10,1)
|
||||||
|
|
||||||
|
glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'b', 'hh', 'func9'])
|
||||||
|
locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
|
||||||
|
loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
|
||||||
|
glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'dict1', 'dict2', 'dict3', 'dict4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'numbers', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'b', 'hh', 'func9'])
|
||||||
|
```
|
||||||
|
|
||||||
|
### 6.4. Моделирование системы
|
||||||
|
|
||||||
|
```py
|
||||||
|
znach=input('k1,T,k2,Xm,A,F,N=').split(',')
|
||||||
|
k1,T,k2,Xm,A,F,N=1, 4, 6, 8, 0.1, 100, 77
|
||||||
|
k1=float(znach[0]) # распаковка каждого значения из списка в отдельную переменную
|
||||||
|
T=float(znach[1])k2=float(znach[2])
|
||||||
|
Xm=float(znach[3])
|
||||||
|
A=float(znach[4])
|
||||||
|
F=float(znach[5])
|
||||||
|
N=int(znach[6])
|
||||||
|
import math
|
||||||
|
vhod=[]
|
||||||
|
for i in range(N): # реализация входного сигнала
|
||||||
|
vhod.append(A*math.sin((2*i*math.pi)/F))
|
||||||
|
|
||||||
|
vhod
|
||||||
|
[0.0, 0.006279051952931338, 0.012533323356430426, 0.01873813145857246, 0.02486898871648548, 0.03090169943749474, 0.03681245526846779, 0.042577929156507266, 0.04817536741017153, 0.05358267949789967, 0.058778525229247314, 0.06374239897486897, 0.06845471059286887, 0.07289686274214116, 0.07705132427757894, 0.08090169943749474, 0.08443279255020152, 0.08763066800438638, 0.09048270524660196, 0.09297764858882514, 0.09510565162951536, 0.09685831611286311, 0.09822872507286887, 0.09921147013144778, 0.09980267284282716, 0.1, 0.09980267284282716, 0.0992114701314478, 0.09822872507286888, 0.09685831611286311, 0.09510565162951537, 0.09297764858882515, 0.09048270524660196, 0.08763066800438635, 0.0844327925502015, 0.08090169943749476, 0.07705132427757894, 0.07289686274214115, 0.06845471059286888, 0.06374239897486898, 0.05877852522924733, 0.0535826794978997, 0.048175367410171525, 0.042577929156507294, 0.03681245526846782, 0.030901699437494753, 0.024868988716485525, 0.01873813145857246, 0.012533323356430454, 0.006279051952931359, 1.2246467991473533e-17, -0.006279051952931335, -0.01253332335643043, -0.018738131458572477, -0.02486898871648546, -0.03090169943749473, -0.03681245526846779, -0.04257792915650723, -0.04817536741017154, -0.053582679497899646, -0.05877852522924727, -0.06374239897486897, -0.06845471059286884, -0.07289686274214116, -0.07705132427757894, -0.08090169943749474, -0.08443279255020153, -0.08763066800438636, -0.09048270524660199, -0.09297764858882515, -0.09510565162951536, -0.09685831611286312, -0.09822872507286888, -0.09921147013144778, -0.09980267284282716, -0.1, -0.09980267284282716]
|
||||||
|
```
|
||||||
|
Функции реализующие компоненты системы
|
||||||
|
|
||||||
|
```py
|
||||||
|
def realdvig(xtt,kk1,TT,yti1,ytin1):
|
||||||
|
#Модель реального двигателя
|
||||||
|
yp=kk1*xtt #усилитель
|
||||||
|
yti1=yp+yti1 #Интегратор
|
||||||
|
ytin1=(yti1+TT*ytin1)/(TT+1)
|
||||||
|
return [yti1,ytin1]
|
||||||
|
|
||||||
|
def tahogen(xtt,kk2,yti2):
|
||||||
|
#Модель тахогенератора
|
||||||
|
yp=kk2*xtt #усилитель
|
||||||
|
yti2=yp+yti2 #интегратор
|
||||||
|
return yti2
|
||||||
|
|
||||||
|
def nechus(xtt,gran):
|
||||||
|
#зона нечувствит
|
||||||
|
if xtt<gran and xtt>(-gran):
|
||||||
|
ytt=0
|
||||||
|
elif xtt>=gran:
|
||||||
|
ytt=xtt-gran
|
||||||
|
elif xtt<=(-gran):
|
||||||
|
ytt=xtt+gran
|
||||||
|
return ytt
|
||||||
|
```
|
||||||
|
Соединение компонент в соответствии с заданием
|
||||||
|
|
||||||
|
```py
|
||||||
|
yi1=0;yin1=0;yi2=0
|
||||||
|
vyhod=[]
|
||||||
|
for xt in vhod:
|
||||||
|
xt1=xt-yi2 #отрицательная обратная связь
|
||||||
|
[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
|
||||||
|
yi2=tahogen(yin1,k2,yi2)
|
||||||
|
yt=nechus(yin1,Xm)
|
||||||
|
vyhod.append(yt)
|
||||||
|
|
||||||
|
print('y=',vyhod)
|
||||||
|
y= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.5141467180616637, 2.436597981398414, 0, -23.648551283064812, -14.586132260625703, 32.08584980450739, 89.54211200549014, 25.7748383079563, -159.50156906660678, -269.78397091031354, 10.068957187950126, 609.1466943956274, 710.2274755410508, -432.96310970489685, -2071.215944848495, -1597.6603885543427, 2476.1333543804712, 6477.956582202103, 2626.2544178282487, -10653.374481183546, -18710.49654358021, -114.61846653968969, 39934.80067535607, 49244.49063253727, -25137.392758059512, -136326.86476806158, -113347.77120772432, 152977.09900234317, 430425.27047852875, 200239.35715241256, -676334.6538246117, -1258436.7595393702, -94814.83077922332, 2579157.721342821, 3366440.70542351, -1395363.2125185598, -8922019.998095734, -7954112.681058888, 9354374.734397378, 28510095.7464239, 14931466.339167053, -42752396.61128703, -84417589.66346069, -11966716.801496733, 166137062.55300295, 229398711.23742872, -74491804.49954477, -582713905.5745344, -555144565.8307699, 567231399.1647252, 1884775004.5638165, 1096722694.409165, -2691873575.07944]
|
||||||
|
```
|
||||||
|
## 7. Закончила сеанс работы с IDLE
|
||||||
|
|
||||||
@ -0,0 +1,53 @@
|
|||||||
|
# Общее контрольное задание по теме 7
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t)
|
||||||
|
для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с
|
||||||
|
задержкой на заданное время Т.
|
||||||
|
|
||||||
|
```py
|
||||||
|
def delay(signal, T):
|
||||||
|
""""Расчёт выхода y(t) для устройства задержки
|
||||||
|
signal - входной сигнал
|
||||||
|
T-параметр задержки сигнала"""
|
||||||
|
output=[]
|
||||||
|
for i in range(len(signal)+T):
|
||||||
|
if i < T:
|
||||||
|
output.append(0)
|
||||||
|
else:
|
||||||
|
output.append(signal[i-T])
|
||||||
|
return output
|
||||||
|
|
||||||
|
x = [1, 2, 3, 4, 5, 6]
|
||||||
|
res = delay(x, 6)
|
||||||
|
res
|
||||||
|
[0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6]
|
||||||
|
```
|
||||||
|
|
||||||
|
Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной
|
||||||
|
величины с каким-то распределением.
|
||||||
|
|
||||||
|
```py
|
||||||
|
def hist(f, x):
|
||||||
|
"""Функция, строящая гистограмму
|
||||||
|
f - выборка
|
||||||
|
x - количество интервалов
|
||||||
|
Возвращает число элементов в каждом интервале"""
|
||||||
|
pylab.hist(f, x)
|
||||||
|
pylab.show()
|
||||||
|
|
||||||
|
f=[random.gauss(0, 1) for _ in range(10)]
|
||||||
|
histogramm(f, 6)
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y
|
||||||
|
линейной регрессии при значении переменной Х
|
||||||
|
Y=b1+b2*X
|
||||||
|
и имеющую аргументы b1, b2 и X.
|
||||||
|
|
||||||
|
```py
|
||||||
|
Y = lambda b1,b2,X: b1+b2*X
|
||||||
|
Y(1, 2, 3)
|
||||||
|
7
|
||||||
|
```
|
||||||
@ -0,0 +1,50 @@
|
|||||||
|
# Индивидуальное контрольное задание вариант 18
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Разработайте функцию с двумя аргументами: имя некоторого объекта-последовательности и имя текстового файла вывода.
|
||||||
|
Функция должна осуществлять запись указанного объекта в заданный файл вывода, причем если объект – это символьная строка, то его надо записать в файл на одной строке, если объект – список или кортеж, то каждый элемент должен записываться на одной строке файла.
|
||||||
|
|
||||||
|
```py
|
||||||
|
def func(obj, file):
|
||||||
|
""" Запись объекта-последовательности в текстовый файл
|
||||||
|
obj - имя объекта
|
||||||
|
file - имя файла для записи"""
|
||||||
|
with open(file, 'w', encoding='utf-8') as fp:
|
||||||
|
if type(obj)==str:
|
||||||
|
fp.write(obj)
|
||||||
|
elif type(obj)==list:
|
||||||
|
for i in obj:
|
||||||
|
fp.write(str(i)+'\n')
|
||||||
|
elif type(obj)==tuple:
|
||||||
|
for i in obj:
|
||||||
|
fp.write(str(i)+'\n')
|
||||||
|
else:
|
||||||
|
print('Неверный тип')
|
||||||
|
```
|
||||||
|
|
||||||
|
Проверить функцию с объектами разных классов.
|
||||||
|
|
||||||
|
```py
|
||||||
|
func([1, 'Hi', 3.33], "file2.txt") # Проверка для списка
|
||||||
|
func('пум пум пум пурум', "file5.txt") # Проверка для строки
|
||||||
|
func(('банан', 'пум пум', 'ноль'), "file3.txt") # Проверка для кортежа
|
||||||
|
```
|
||||||
|
Содержимое файла file2.txt
|
||||||
|
|
||||||
|
```py
|
||||||
|
1
|
||||||
|
Hi
|
||||||
|
3.33
|
||||||
|
```
|
||||||
|
|
||||||
|
Содержимое файла file5.txt
|
||||||
|
```py
|
||||||
|
пум пум пум пурум
|
||||||
|
```
|
||||||
|
|
||||||
|
Содержимое файла file3.txt
|
||||||
|
```py
|
||||||
|
банан
|
||||||
|
пум пум
|
||||||
|
ноль
|
||||||
|
```
|
||||||
@ -0,0 +1,2 @@
|
|||||||
|
import MM2
|
||||||
|
print("y =", MM2.vyhod)
|
||||||
@ -0,0 +1,21 @@
|
|||||||
|
def realdvig(xtt, kk1, TT, yti1, ytin1):
|
||||||
|
# Модель реального двигателя
|
||||||
|
yp = kk1 \* xtt # Усилитель
|
||||||
|
yti1 = yp + yti1 # Усилитель
|
||||||
|
ytin1 = (yti1 + TT \* ytin1) / (TT + 1)
|
||||||
|
return \[yti1, ytin1]
|
||||||
|
|
||||||
|
def tahogen(xtt, kk2, yti2):
|
||||||
|
# Модель тахогенератора
|
||||||
|
yp = kk2 * xtt # Усилитель
|
||||||
|
yti2 = yp + yti2 # Интегратор
|
||||||
|
return yti2
|
||||||
|
|
||||||
|
def nechus(xtt, gran):
|
||||||
|
# Зона нечувствительности
|
||||||
|
if xtt < gran and xtt > (-gran):
|
||||||
|
return 0
|
||||||
|
elif xtt >= gran:
|
||||||
|
return xtt - gran
|
||||||
|
elif xtt <= (-gran):
|
||||||
|
return xtt + gran
|
||||||
@ -0,0 +1,21 @@
|
|||||||
|
znach = input("k1, T, k2, Xm, A, F, N = ").split(",")
|
||||||
|
k1 = float(znach[0])
|
||||||
|
T = float(znach[1])
|
||||||
|
k2 = float(znach[2])
|
||||||
|
Xm = float(znach[3])
|
||||||
|
A = float(znach[4])
|
||||||
|
F = float(znach[5])
|
||||||
|
N = int(znach[6])
|
||||||
|
import math
|
||||||
|
vhod = []
|
||||||
|
for i in range(N):
|
||||||
|
vhod.append(A * math.sin((2 * i * math.pi) / F))
|
||||||
|
import MM1 as mod
|
||||||
|
yi1 = 0; yin1 = 0; yi2 = 0
|
||||||
|
vyhod = []
|
||||||
|
for xt in vhod:
|
||||||
|
xt1 = xt - yi2
|
||||||
|
[yi1, yin1] = mod.realdvig(xt1, k1, T, yi1, yin1)
|
||||||
|
yi2 = mod.tahogen(yin1, k2, yi2)
|
||||||
|
yt = mod.nechus(yin1, Xm)
|
||||||
|
vyhod.append(yt)
|
||||||
@ -0,0 +1,7 @@
|
|||||||
|
def read(name):
|
||||||
|
nums = []
|
||||||
|
fp=open(name)
|
||||||
|
for i in fp:
|
||||||
|
for y in i.strip().split():
|
||||||
|
nums.append(float(y))
|
||||||
|
return nums
|
||||||
@ -0,0 +1,7 @@
|
|||||||
|
import statistics
|
||||||
|
def corel(lst1, lst2):
|
||||||
|
n=min(len(lst1), len(lst2))
|
||||||
|
lst1=lst1[:n]
|
||||||
|
lst2=lst2[:n]
|
||||||
|
res=statistics.correlation(lst1, lst2)
|
||||||
|
return res
|
||||||
@ -0,0 +1,8 @@
|
|||||||
|
import Modul1, Modul2
|
||||||
|
x=input('Введите название файла 1: ')
|
||||||
|
y=input('Введите название файла 2: ')
|
||||||
|
file1 = Modul1.read(x)
|
||||||
|
file2 = Modul1.read(y)
|
||||||
|
res = Modul2.corel(file1, file2)
|
||||||
|
print(res)
|
||||||
|
print('Коэффициент корреляции: ', round(res, 3))
|
||||||
@ -0,0 +1,363 @@
|
|||||||
|
# Отчет по теме 8
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
# Модули и структурирование программы
|
||||||
|
## 1. Установка рабочего каталога
|
||||||
|
|
||||||
|
```py
|
||||||
|
import importlib
|
||||||
|
import os,sys
|
||||||
|
os.getcwd() #Контролируем корректность установки текущего каталога
|
||||||
|
'H:\\study\\ПОАС'
|
||||||
|
```
|
||||||
|
## 2. Создание и использование модулей в среде Python
|
||||||
|
Модулем в среде Python называется любая часть программного кода на этом языке, записанная в
|
||||||
|
отдельном файле
|
||||||
|
|
||||||
|
### 2.1. Запуск модуля на выполнение путем его импорта
|
||||||
|
Создала файл Mod1.py с содержимым:
|
||||||
|
```py
|
||||||
|
perm1=input('Mod1:Введите значение = ')
|
||||||
|
print('Mod1:Значение perm1=',perm1)
|
||||||
|
```
|
||||||
|
Запустила модуль Mod1.py
|
||||||
|
```py
|
||||||
|
import Mod1
|
||||||
|
Mod1:Введите значение = 3
|
||||||
|
Mod1:Значение perm1= 3
|
||||||
|
|
||||||
|
type(Mod1)
|
||||||
|
<class 'module'>
|
||||||
|
dir(Mod1)
|
||||||
|
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
|
||||||
|
Mod1.perm1 # Обращение к переменной perm из модуля Mod1
|
||||||
|
'3'
|
||||||
|
```
|
||||||
|
При повторном вызове через import ничего не происходит
|
||||||
|
|
||||||
|
```py
|
||||||
|
import Mod1
|
||||||
|
importlib.reload(Mod1) # для повторного вызова модуля используем reload
|
||||||
|
Mod1:Введите значение = 5
|
||||||
|
Mod1:Значение perm1= 5
|
||||||
|
<module 'Mod1' from 'H:\\study\\ПОАС\\Mod1.py'>
|
||||||
|
Mod1.perm1
|
||||||
|
'5'
|
||||||
|
```
|
||||||
|
### 2.2. Вывод импортированных модулей
|
||||||
|
Импортированные модули заносятся в словарь - значение атрибута sys.modules, поэтому их можно увидеть с помощью инструкции keys().
|
||||||
|
```py
|
||||||
|
print(sorted(sys.modules.keys()))
|
||||||
|
['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_suggestions', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
|
||||||
|
```
|
||||||
|
Для повторного импорта удалим его из словаря.
|
||||||
|
|
||||||
|
```py
|
||||||
|
print(sorted(sys.modules.keys()))
|
||||||
|
['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib',...]
|
||||||
|
import Mod1 # еще раз импортировали модуль
|
||||||
|
Mod1:Введите значение = 4
|
||||||
|
Mod1:Значение perm1= 4
|
||||||
|
sys.modules.pop('Mod1') # еще раз удалили модуль
|
||||||
|
<module 'Mod1' from 'H:\\study\\ПОАС\\Mod1.py'>
|
||||||
|
```
|
||||||
|
### 2.3. Запуск модуля на выполнение с помощью функции exec()
|
||||||
|
Для запуска через exec() не трубуется импортировать модуль, но модуль при этом не создается, все созданные при выполнении модуля объекты становятся объектами главной программы
|
||||||
|
```py
|
||||||
|
exec(open('Mod1.py').read())
|
||||||
|
Mod1:Введите значение = 11111
|
||||||
|
Mod1:Значение perm1= 11111
|
||||||
|
exec(open("Mod1.py", encoding = "utf-8").read()) # изменили кодировку
|
||||||
|
Mod1:Введите значение = 11111111
|
||||||
|
Mod1:Значение perm1= 11111111
|
||||||
|
perm1
|
||||||
|
'11111111'
|
||||||
|
exec(open("Mod1.py", encoding = "utf-8").read())
|
||||||
|
Mod1:Введите значение = 777
|
||||||
|
Mod1:Значение perm1= 777
|
||||||
|
perm1
|
||||||
|
'777'
|
||||||
|
```
|
||||||
|
### 2.4. Использование инструкции from … import …
|
||||||
|
В одном модуле может содержаться несколько программных единиц (функций, объектов).
|
||||||
|
Можно осуществить частичный импорт объектов
|
||||||
|
|
||||||
|
```py
|
||||||
|
'777'
|
||||||
|
from Mod1 import perm1
|
||||||
|
Mod1:Введите значение = 1111
|
||||||
|
Mod1:Значение perm1= 1111
|
||||||
|
dir()
|
||||||
|
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'importlib', 'os', 'perm1', 'sys']
|
||||||
|
"Mod1" in dir() # Модуль Mod1 не появился в памяти
|
||||||
|
False
|
||||||
|
perm1 # переменная модуля стала переменной программы
|
||||||
|
'1111'
|
||||||
|
```
|
||||||
|
Создала второй модуль Mod2:
|
||||||
|
|
||||||
|
```py
|
||||||
|
def alpha():
|
||||||
|
print('****ALPHA****')
|
||||||
|
t=input('Значение t=')
|
||||||
|
return t
|
||||||
|
def beta(q):
|
||||||
|
import math
|
||||||
|
expi=q*math.pi
|
||||||
|
return math.exp(expi)
|
||||||
|
```
|
||||||
|
Импортировали только функцию beta
|
||||||
|
|
||||||
|
```py
|
||||||
|
from Mod2 import beta
|
||||||
|
g=beta(2)
|
||||||
|
g
|
||||||
|
535.4916555247646
|
||||||
|
"Mod2" in dir()
|
||||||
|
False
|
||||||
|
alpha() # Функция alpha не была импортировна, поэтому к ней нельзя обращаться
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#205>", line 1, in <module>
|
||||||
|
alpha() # Функция alpha не была импортировна, поэтому к ней нельзя обращаться
|
||||||
|
NameError: name 'alpha' is not defined
|
||||||
|
```
|
||||||
|
Импортируем alpha из Mod2
|
||||||
|
|
||||||
|
```py
|
||||||
|
from Mod2 import alpha as al # присвоили имя al
|
||||||
|
al()
|
||||||
|
****ALPHA****
|
||||||
|
Значение t=5
|
||||||
|
'5'
|
||||||
|
from Mod2 import alpha as al, beta as bt # можем импортировать обе функции
|
||||||
|
dir()
|
||||||
|
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'al', 'bt', 'g', 'importlib', 'os', 'perm1', 'sys']
|
||||||
|
del al,beta # удалили импортированные объекты
|
||||||
|
from Mod2 import * # импорт всего содержимого
|
||||||
|
tt=alpha() #На запрос введите значение 0.12
|
||||||
|
****ALPHA****
|
||||||
|
Значение t=0.12
|
||||||
|
uu=beta(float(tt))uu
|
||||||
|
1.4578913609506803
|
||||||
|
```
|
||||||
|
## 3.Создание многомодульных программ
|
||||||
|
### 3.1. Пример простой многомодульной программы
|
||||||
|
|
||||||
|
Создали Mod0:
|
||||||
|
```py
|
||||||
|
#Модуль 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)
|
||||||
|
```
|
||||||
|
Программа состоит из нескольких модулей
|
||||||
|
|
||||||
|
```py
|
||||||
|
sys.modules.pop("Mod1") # удалили лишние модули
|
||||||
|
<module 'Mod1' from 'H:\\study\\ПОАС\\Mod1.py'>
|
||||||
|
sys.modules.pop("Mod2")
|
||||||
|
<module 'Mod2' from 'H:\\study\\ПОАС\\Mod2.py'>
|
||||||
|
|
||||||
|
import Mod0
|
||||||
|
Mod1:Введите значение = 111
|
||||||
|
Mod1:Значение perm1= 111
|
||||||
|
perm1= 111
|
||||||
|
****ALPHA****
|
||||||
|
Значение t=77
|
||||||
|
tt= 77
|
||||||
|
qq= 1.1401952983082614e+105
|
||||||
|
|
||||||
|
Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
|
||||||
|
'77'
|
||||||
|
1.1401952983082614e+105
|
||||||
|
'111'
|
||||||
|
```
|
||||||
|
### 3.2. Создание многомодульной программы на примере функций из Темы 7
|
||||||
|
|
||||||
|
Создала модуль MM1.py в который записала модель системы из темы 7
|
||||||
|
```py
|
||||||
|
def realdvig(xtt, kk1, TT, yti1, ytin1):
|
||||||
|
# Модель реального двигателя
|
||||||
|
yp = kk1 \* xtt # Усилитель
|
||||||
|
yti1 = yp + yti1 # Усилитель
|
||||||
|
ytin1 = (yti1 + TT \* ytin1) / (TT + 1)
|
||||||
|
return \[yti1, ytin1]
|
||||||
|
|
||||||
|
def tahogen(xtt, kk2, yti2):
|
||||||
|
# Модель тахогенератора
|
||||||
|
yp = kk2 * xtt # Усилитель
|
||||||
|
yti2 = yp + yti2 # Интегратор
|
||||||
|
return yti2
|
||||||
|
|
||||||
|
def nechus(xtt, gran):
|
||||||
|
# Зона нечувствительности
|
||||||
|
if xtt < gran and xtt > (-gran):
|
||||||
|
return 0
|
||||||
|
elif xtt >= gran:
|
||||||
|
return xtt - gran
|
||||||
|
elif xtt <= (-gran):
|
||||||
|
return xtt + gran
|
||||||
|
```
|
||||||
|
|
||||||
|
Ввод параметров сохранила в модуль MM2.py
|
||||||
|
|
||||||
|
```py
|
||||||
|
znach = input("k1, T, k2, Xm, A, F, N = ").split(",")
|
||||||
|
k1 = float(znach[0])
|
||||||
|
T = float(znach[1])
|
||||||
|
k2 = float(znach[2])
|
||||||
|
Xm = float(znach[3])
|
||||||
|
A = float(znach[4])
|
||||||
|
F = float(znach[5])
|
||||||
|
N = int(znach[6])
|
||||||
|
import math
|
||||||
|
vhod = []
|
||||||
|
for i in range(N):
|
||||||
|
vhod.append(A * math.sin((2 * i * math.pi) / F))
|
||||||
|
import MM1 as mod
|
||||||
|
yi1 = 0; yin1 = 0; yi2 = 0
|
||||||
|
vyhod = []
|
||||||
|
for xt in vhod:
|
||||||
|
xt1 = xt - yi2
|
||||||
|
[yi1, yin1] = mod.realdvig(xt1, k1, T, yi1, yin1)
|
||||||
|
yi2 = mod.tahogen(yin1, k2, yi2)
|
||||||
|
yt = mod.nechus(yin1, Xm)
|
||||||
|
vyhod.append(yt)
|
||||||
|
```
|
||||||
|
Программа запускающая остальные модули MM0.py
|
||||||
|
```py
|
||||||
|
import MM2
|
||||||
|
print("y =", MM2.vyhod)
|
||||||
|
```
|
||||||
|
Запуск многомодульной программы
|
||||||
|
```py
|
||||||
|
import MM0
|
||||||
|
k1, T, k2, Xm, A, F, N = 8, 5, 3, 5, 3, 50, 20
|
||||||
|
y = [0, 0, 0, 0, 0, 0, -0.5901518991576866, 3.452634704774537, 0.3642909010247486, -28.2151620053697, 26.675026712827304, 51.21473287127543, -172.66693667770392, 78.76799406127618, 417.8318242176528, -859.8658159198188, -43.91966881153879, 2710.4996464065, -3753.6472426408995, -2892.354195893288]
|
||||||
|
```
|
||||||
|
### 3.3. Области действия объектов в модулях
|
||||||
|
Обратимся из одной функции к другой в модуле Mod2.py
|
||||||
|
Вставим в функцию alpha обращение к функции beta и, наоборот, из beta – к alpha.
|
||||||
|
```py
|
||||||
|
def alpha():
|
||||||
|
print("****ALPHA****")
|
||||||
|
print("Вызов функции beta из функции alpha:", beta(0))
|
||||||
|
t = input("Значение t = ")
|
||||||
|
return t
|
||||||
|
```
|
||||||
|
Запуск модуля
|
||||||
|
```py
|
||||||
|
import Mod2
|
||||||
|
Mod2.alpha()
|
||||||
|
****ALPHA****
|
||||||
|
Вызов функции beta из функции alpha: 1.0
|
||||||
|
Значение t = 202020
|
||||||
|
'202020'
|
||||||
|
```
|
||||||
|
Для функции beta в модуле Mod2.py
|
||||||
|
```py
|
||||||
|
def beta(q):
|
||||||
|
print("****BETA****")
|
||||||
|
print("Вызов функции alpha из функции beta:", alpha())
|
||||||
|
import math
|
||||||
|
expi = q * math.pi
|
||||||
|
return math.exp(expi)
|
||||||
|
```
|
||||||
|
Запустим модуль
|
||||||
|
```py
|
||||||
|
import Mod2
|
||||||
|
Mod2.beta(4)
|
||||||
|
****BETA****
|
||||||
|
****ALPHA****
|
||||||
|
Значение t = 5
|
||||||
|
Вызов функции alpha из функции beta: 5
|
||||||
|
286751.31313665316
|
||||||
|
```
|
||||||
|
Отобразим на экране в модуле Mod0 значения объектов t и expi
|
||||||
|
Модуль Mod1
|
||||||
|
```py
|
||||||
|
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)
|
||||||
|
print("t =", t)
|
||||||
|
print("expi =", expi)
|
||||||
|
```
|
||||||
|
```py
|
||||||
|
import Mod0
|
||||||
|
Mod1: Введите значение = 1
|
||||||
|
Mod1: Значение perm1 = 1
|
||||||
|
perm1 = 1
|
||||||
|
****ALPHA****
|
||||||
|
Значение t = 2
|
||||||
|
tt = 2
|
||||||
|
****BETA****
|
||||||
|
qq = 535.4916555247646
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#252>", line 1, in <module>
|
||||||
|
import Mod0
|
||||||
|
File "H:\\study\\ПОАС\\Mod0.py"
|
||||||
|
print("t =", t, " expi =", expi)
|
||||||
|
NameError: name 't' is not defined. Did you mean: 'tt'?
|
||||||
|
```
|
||||||
|
При обращении к переменной t, будет ошибка, так как переменная определена в другом модуле и к ней нельзя обратиться напрямую
|
||||||
|
аналогично с переменной expi
|
||||||
|
|
||||||
|
Попробуем в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после
|
||||||
|
этого на экране.
|
||||||
|
|
||||||
|
```py
|
||||||
|
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)
|
||||||
|
Mod1.perm1 *= 3
|
||||||
|
print("perm1 * 3 =", Mod1.perm1)
|
||||||
|
```
|
||||||
|
Запустим
|
||||||
|
```py
|
||||||
|
import Mod0
|
||||||
|
Mod1: Введите значение = 1
|
||||||
|
Mod1: Значение perm1 = 1
|
||||||
|
perm1 = 1
|
||||||
|
****ALPHA****
|
||||||
|
Значение t = 2
|
||||||
|
tt = 2
|
||||||
|
****BETA****
|
||||||
|
qq = 535.4916555247646
|
||||||
|
perm1 * 3 = 111
|
||||||
|
```
|
||||||
|
Попробуем в командной строке (в главном модуле) увеличить в 2 раза значения объектов
|
||||||
|
perm1, tt, qq.
|
||||||
|
```py
|
||||||
|
perm1 *= 2
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#254>", line 1, in <module>
|
||||||
|
perm1 *= 2
|
||||||
|
NameError: name 'perm1' is not defined
|
||||||
|
tt *= 2
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#255>", line 1, in <module>
|
||||||
|
tt *= 2
|
||||||
|
```
|
||||||
|
Аналогично
|
||||||
|
|
||||||
|
Эти переменные локальные для модулей и обращение к ним из командной строке выводит ошибку.
|
||||||
|
|
||||||
|
## 4. Завершила работу со средой
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,55 @@
|
|||||||
|
# Общее контрольное задание по теме 8
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Разработайте программу, состоящую из трех модулей:
|
||||||
|
- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным
|
||||||
|
именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько
|
||||||
|
на строке с разделением пробелом. Числа элементов в строках могут быть разными.
|
||||||
|
Полученный список должен возвращаться в вызывающую программу.
|
||||||
|
|
||||||
|
```py
|
||||||
|
def read(name):
|
||||||
|
nums = []
|
||||||
|
fp=open(name)
|
||||||
|
for i in fp:
|
||||||
|
for y in i.strip().split():
|
||||||
|
nums.append(float(y))
|
||||||
|
return nums
|
||||||
|
```
|
||||||
|
- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам
|
||||||
|
(аргументы функции – имена двух списков). Числа элементов в списках могут различаться.
|
||||||
|
Значение коэффициента должно возвращаться в вызывающую программу.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import statistics
|
||||||
|
def corel(lst1, lst2):
|
||||||
|
n=min(len(lst1), len(lst2))
|
||||||
|
lst1=lst1[:n]
|
||||||
|
lst2=lst2[:n]
|
||||||
|
res=statistics.correlation(lst1, lst2)
|
||||||
|
return res
|
||||||
|
```
|
||||||
|
- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными,
|
||||||
|
дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов.
|
||||||
|
Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2
|
||||||
|
и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
|
||||||
|
Подготовьте два текстовых файла с числовыми данными и проверьте по ним работу программы.
|
||||||
|
```py
|
||||||
|
import Modul1, Modul2
|
||||||
|
x=input('Введите название файла 1: ')
|
||||||
|
y=input('Введите название файла 2: ')
|
||||||
|
file1 = Modul1.read(x)
|
||||||
|
file2 = Modul1.read(y)
|
||||||
|
res = Modul2.corel(file1, file2)
|
||||||
|
print(res)
|
||||||
|
print('Коэффициент корреляции: ', round(res, 3))
|
||||||
|
```
|
||||||
|
Проверка
|
||||||
|
|
||||||
|
```py
|
||||||
|
import Modul3
|
||||||
|
Введите название файла 1: sps.txt
|
||||||
|
Введите название файла 2: sps2.txt
|
||||||
|
0.9970501410659874
|
||||||
|
Коэффициент корреляции: 0.997
|
||||||
|
```
|
||||||
@ -0,0 +1,48 @@
|
|||||||
|
# Индивидуальное контрольное задание вариант 18
|
||||||
|
|
||||||
|
Разработайте функцию с двумя аргументами: имя некоторого объекта-последовательности и имя текстового файла вывода.
|
||||||
|
Функция должна осуществлять запись указанного объекта в заданный файл вывода, причем если объект – это символьная строка, то его надо записать в файл на одной строке, если объект – список или кортеж, то каждый элемент должен записываться на одной строке файла.
|
||||||
|
|
||||||
|
Разработайте функцию, на ее основе создайте модуль.
|
||||||
|
Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
|
||||||
|
|
||||||
|
module1.py
|
||||||
|
```py
|
||||||
|
def func(obj, file):
|
||||||
|
""" Запись объекта-последовательности в текстовый файл
|
||||||
|
obj - имя объекта
|
||||||
|
file - имя файла для записи"""
|
||||||
|
with open(file, 'w', encoding='utf-8') as fp:
|
||||||
|
if type(obj)==str:
|
||||||
|
fp.write(obj)
|
||||||
|
elif type(obj)==list:
|
||||||
|
for i in obj:
|
||||||
|
fp.write(str(i)+'\n')
|
||||||
|
elif type(obj)==tuple:
|
||||||
|
for i in obj:
|
||||||
|
fp.write(str(i)+'\n')
|
||||||
|
else:
|
||||||
|
print('Неверный тип')
|
||||||
|
```
|
||||||
|
module2.py
|
||||||
|
|
||||||
|
```py
|
||||||
|
import module1
|
||||||
|
|
||||||
|
obj = input("Введите список/строку/кортеж: ")
|
||||||
|
name = input("Введите имя файла для записи: ")
|
||||||
|
module1.func(obj, name)
|
||||||
|
```
|
||||||
|
Запустим из консоли программу
|
||||||
|
|
||||||
|
```py
|
||||||
|
import module2
|
||||||
|
Введите список/строку/кортеж: '12456'
|
||||||
|
Введите имя файла для записи: sps.txt
|
||||||
|
```
|
||||||
|
|
||||||
|
Содержимое файла sps.txt
|
||||||
|
|
||||||
|
```py
|
||||||
|
12456
|
||||||
|
```
|
||||||
|
После Ширина: | Высота: | Размер: 53 KiB |
|
После Ширина: | Высота: | Размер: 42 KiB |
|
После Ширина: | Высота: | Размер: 57 KiB |
@ -0,0 +1,289 @@
|
|||||||
|
# Отчет по теме 9
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
## Создание пользовательских классов и объектов
|
||||||
|
|
||||||
|
### 2. Создание классов и их наследников
|
||||||
|
#### 2.1. Создание автономного класса
|
||||||
|
|
||||||
|
```py
|
||||||
|
|
||||||
|
class Class1: # Объявление класса
|
||||||
|
def zad_zn(self, znach): # Метод класса для задания значения поля data
|
||||||
|
self.data = znach # self - ссылка на экземпляр класса Class1
|
||||||
|
def otobrazh(self): # Метод класса для отображения значения поля data
|
||||||
|
print(self.data)
|
||||||
|
|
||||||
|
z1 = Class1() # Создание 1-го экземпляра класса
|
||||||
|
z2 = Class1() # Создание 2-го экземпляра класса
|
||||||
|
z1.zad_zn("Экземпляр класса 1")
|
||||||
|
z2.zad_zn(-632.453)
|
||||||
|
z1.otobrazh()
|
||||||
|
Экземпляр класса 1
|
||||||
|
z2.otobrazh()
|
||||||
|
-632.453
|
||||||
|
z1.data = "Новое значение атрибута у экземпляра 1"
|
||||||
|
z1.otobrazh()
|
||||||
|
Новое значение атрибута у экземпляра 1
|
||||||
|
```
|
||||||
|
|
||||||
|
#### 2.2. Создание класса наследника
|
||||||
|
В объявлении класса после его имени в скобках перечисляются его «родительские классы»
|
||||||
|
```py
|
||||||
|
class Class2(Class1): # Объявление класса-наследника другого класса
|
||||||
|
def otobrazh(self): # Переопределение метода класса-родителя
|
||||||
|
print("Значение =", self.data)
|
||||||
|
|
||||||
|
z3 = Class2()
|
||||||
|
dir(z3)
|
||||||
|
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
|
||||||
|
z3.zad_zn("Совсем новое")
|
||||||
|
z3.otobrazh() # Сработал переопределенный метод otobrazh класса Class2
|
||||||
|
Значение = Совсем новое
|
||||||
|
z1.otobrazh() # Значение поля data класса Class1 не изменилось
|
||||||
|
Новое значение атрибута у экземпляра 1
|
||||||
|
del z1, z2, z3
|
||||||
|
```
|
||||||
|
### 3.Использование классов, содержащихся в модулях
|
||||||
|
Создала модуль Mod3 с содержанием:
|
||||||
|
|
||||||
|
```py
|
||||||
|
class Class1:
|
||||||
|
def zad_zn(self, znach):
|
||||||
|
self.data = znach
|
||||||
|
def otobrazh(self):
|
||||||
|
print(self.data)
|
||||||
|
|
||||||
|
class Class2(Class1):
|
||||||
|
def otobrazh(self):
|
||||||
|
print("Значение =", self.data)
|
||||||
|
|
||||||
|
def otobrazh(obj):
|
||||||
|
print("Значение объекта =", obj)
|
||||||
|
```
|
||||||
|
Импортируем первый класс из модуля:
|
||||||
|
|
||||||
|
```py
|
||||||
|
from Mod3 import Class1
|
||||||
|
z4 = Class1()
|
||||||
|
z4.otobrazh() # Поле data класса не было инициализировано, поэтому его еще нет в классе
|
||||||
|
Traceback (most recent call last):
|
||||||
|
File "<pyshell#29>", line 1, in <module>
|
||||||
|
z4.otobrazh()
|
||||||
|
File "H:\study\ПОАС\Mod3.py", line 5, in otobrazh
|
||||||
|
print(self.data)
|
||||||
|
AttributeError: 'Class1' object has no attribute 'data'
|
||||||
|
z4.data = "Значение поля data у экземпляра 4" # Прямая инициализация поля data
|
||||||
|
z4.otobrazh() # Использован метод для отображения значения поля, описанный в Class1
|
||||||
|
Значение поля data у экземпляра 4
|
||||||
|
del z4
|
||||||
|
```
|
||||||
|
Импортируем полностью модуль
|
||||||
|
```py
|
||||||
|
from Mod3 import Class1
|
||||||
|
z4=Class1()
|
||||||
|
z4.data='значение данного data у экз.4'
|
||||||
|
z4.otobrazh()
|
||||||
|
значение данного data у экз.4
|
||||||
|
del z4
|
||||||
|
```
|
||||||
|
|
||||||
|
### 4. Использование специальных методов
|
||||||
|
Имена специальных методов предваряются одним или двумя подчерками и имеют вид: <имя
|
||||||
|
специального метода>
|
||||||
|
|
||||||
|
```py
|
||||||
|
class Class3(Class2):
|
||||||
|
def __init__(self, znach): # Специальный метод-конструктор
|
||||||
|
self.data = znach
|
||||||
|
def __add__(self, another_zn): # Специальный метод для сложения
|
||||||
|
return Class3(self.data + another_zn)
|
||||||
|
def zad_another_zn(self, povtor): # Обычный пользовательский метод
|
||||||
|
self.data *= povtor
|
||||||
|
|
||||||
|
z5 = Class3("abc")
|
||||||
|
z5.otobrazh()
|
||||||
|
Значение = abc
|
||||||
|
z6 = z5 + "def"
|
||||||
|
z6.otobrazh()
|
||||||
|
Значение = abcdef
|
||||||
|
z6.zad_another_zn(3)
|
||||||
|
z6.otobrazh()
|
||||||
|
Значение = abcdefabcdefabcdef
|
||||||
|
```
|
||||||
|
|
||||||
|
### 5. Присоединение атрибутов к классу
|
||||||
|
```py
|
||||||
|
dir(Class3)
|
||||||
|
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_another_zn', 'zad_zn']
|
||||||
|
Class3.fio='Иванов И.И.'
|
||||||
|
z7=Class3(123)
|
||||||
|
dir(Class3)
|
||||||
|
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_another_zn', 'zad_zn']
|
||||||
|
z7 = Class3(123)
|
||||||
|
dir(z7) # Отображение списка атрибутов объекта класса после добавления в него поля fio
|
||||||
|
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_another_zn', 'zad_zn']
|
||||||
|
dir(z7) == dir(Class3)
|
||||||
|
False
|
||||||
|
z7.fio
|
||||||
|
'Иванов И.И.'
|
||||||
|
Class3.fio
|
||||||
|
'Иванов И.И.'
|
||||||
|
z7.rozden = "1987"
|
||||||
|
dir(z7)
|
||||||
|
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_another_zn', 'zad_zn']
|
||||||
|
dir(Class3)
|
||||||
|
['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_another_zn', 'zad_zn']
|
||||||
|
"rozden" in dir(z7) # проверим что поле rozden появилось в объекте класса
|
||||||
|
True
|
||||||
|
"rozden" in dir(Class3) # поле rozden не появилось в самом классе
|
||||||
|
False
|
||||||
|
```
|
||||||
|
|
||||||
|
### 6. Выявление родительских классов
|
||||||
|
Такое выявление делается с помощью специального атрибута __bases__
|
||||||
|
```py
|
||||||
|
Class3.__bases__
|
||||||
|
(<class '__main__.Class2'>,)
|
||||||
|
Class2.__bases__
|
||||||
|
(<class '__main__.Class1'>,)
|
||||||
|
Class1.__bases__
|
||||||
|
(<class 'object'>,)
|
||||||
|
```
|
||||||
|
Для получения всей цепочки наследования используем атрибут __mro__:
|
||||||
|
|
||||||
|
```py
|
||||||
|
Class3.__mro__
|
||||||
|
(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
|
||||||
|
ZeroDivisionError.__mro__
|
||||||
|
(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
|
||||||
|
```
|
||||||
|
|
||||||
|
### 7. Создание свойств класса
|
||||||
|
Свойство (property) класса – это особый атрибут класса, с которым можно производить операции
|
||||||
|
чтения или задания его значения, а также удаление значения этого атрибута.
|
||||||
|
```py
|
||||||
|
class Class4:
|
||||||
|
def __init__ (self, znach):
|
||||||
|
self.__prm = znach
|
||||||
|
def chten(self):
|
||||||
|
return self.__prm
|
||||||
|
def zapis(self, znch):
|
||||||
|
self.__prm = znch
|
||||||
|
def stiran(self):
|
||||||
|
del self.__prm
|
||||||
|
svojstvo = property(chten, zapis, stiran)
|
||||||
|
|
||||||
|
exempl=Class4(12)
|
||||||
|
exempl.svojstvo
|
||||||
|
12
|
||||||
|
exempl.svojstvo = 45
|
||||||
|
print(exempl.svojstvo)
|
||||||
|
45
|
||||||
|
del exempl.svojstvo
|
||||||
|
exempl.svojstvo # Отображения отсутсвующего в объекте класса свойства вызывает ошибку
|
||||||
|
File "<pyshell#54>", line 5, in chten
|
||||||
|
return self.__prm
|
||||||
|
AttributeError: 'Class4' object has no attribute '_Class4__prm'
|
||||||
|
```
|
||||||
|
### 8. Представление некоторой модели в виде класса
|
||||||
|
модель системы автоматического регулирования (САР), состоящей из последовательного соединения усилителя и двух
|
||||||
|
инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
|
||||||
|
|
||||||
|
Создали модуль SAU.py
|
||||||
|
```py
|
||||||
|
class SAU:
|
||||||
|
def __init__ (self, zn_param):
|
||||||
|
self.param = zn_param
|
||||||
|
self.ypr = [0, 0]
|
||||||
|
|
||||||
|
def zdn_zn(self, upr):
|
||||||
|
self.x = upr
|
||||||
|
|
||||||
|
def model(self):
|
||||||
|
def inerz(x, T, yy):
|
||||||
|
return (x + T * yy) / (T + 1)
|
||||||
|
|
||||||
|
y0 = self.x - self.ypr[1] * self.param[3] # Обратная связь с усилителем 2
|
||||||
|
y1 = self.param[0] * y0 # Усилитель 1
|
||||||
|
y2 = inerz(y1, self.param[1], self.ypr[0]) # Инерционное звено 1
|
||||||
|
y3 = inerz(y2, self.param[2], self.ypr[1]) # Инерционное звено 2
|
||||||
|
self.ypr[0] = y2
|
||||||
|
self.ypr[1] = y3
|
||||||
|
|
||||||
|
def otobrazh(self):
|
||||||
|
print("y =", self.ypr[1])
|
||||||
|
```
|
||||||
|
```py
|
||||||
|
from SAU import *
|
||||||
|
prm = [2.5, 4, 1.3, 0.8] # Параметры модели: K1, T1, T2, K2
|
||||||
|
xx = [0] + [1] * 20 # Входной сигнал – «ступенька»
|
||||||
|
SAUe = SAU(prm)
|
||||||
|
yt = []
|
||||||
|
|
||||||
|
for xt in xx:
|
||||||
|
SAUe.zdn_zn(xt)
|
||||||
|
SAUe.model()
|
||||||
|
SAUe.otobrazh()
|
||||||
|
yt.append(SAUe.ypr[1])
|
||||||
|
|
||||||
|
import pylab
|
||||||
|
pylab.plot(yt)
|
||||||
|
pylab.title("График выходного сигнала")
|
||||||
|
pylab.xlabel("Время - t")
|
||||||
|
pylab.ylabel("Выходной сигнал - y(t)")
|
||||||
|
pylab.grid(True)
|
||||||
|
pylab.show()
|
||||||
|
```
|
||||||
|
Результат работы программы
|
||||||
|
```py
|
||||||
|
import main_SAU
|
||||||
|
y = 0.0
|
||||||
|
y = 0.2173913043478261
|
||||||
|
y = 0.4763705103969754
|
||||||
|
y = 0.686594887811293
|
||||||
|
y = 0.8199324616478645
|
||||||
|
y = 0.8837201137353929
|
||||||
|
y = 0.8994188484874774
|
||||||
|
y = 0.8892777072047301
|
||||||
|
y = 0.870097963179993
|
||||||
|
y = 0.8518346102696789
|
||||||
|
y = 0.8387499784485772
|
||||||
|
y = 0.8314204114211459
|
||||||
|
y = 0.8286051955249649
|
||||||
|
y = 0.8285656555914835
|
||||||
|
y = 0.8297915186846528
|
||||||
|
y = 0.8312697736438287
|
||||||
|
y = 0.8324765218921963
|
||||||
|
y = 0.8332456979978418
|
||||||
|
y = 0.8336163607592184
|
||||||
|
y = 0.8337101315489143
|
||||||
|
y = 0.833654237067147
|
||||||
|
```
|
||||||
|
|
||||||
|
При других значениях параметров
|
||||||
|
prm = [5, 2, 3, 2]
|
||||||
|
```py
|
||||||
|
y = 0.0
|
||||||
|
y = 0.4166666666666667
|
||||||
|
y = 0.6597222222222223
|
||||||
|
y = 0.5931712962962963
|
||||||
|
y = 0.43282214506172834
|
||||||
|
y = 0.3725606031378601
|
||||||
|
y = 0.41758261263288754
|
||||||
|
y = 0.47397622246692106
|
||||||
|
y = 0.48436149012259344
|
||||||
|
y = 0.462222758004719
|
||||||
|
y = 0.44411586377478934
|
||||||
|
y = 0.4446228748662676
|
||||||
|
y = 0.4539720784512614
|
||||||
|
y = 0.4591722749967687
|
||||||
|
y = 0.45753112118915107
|
||||||
|
y = 0.4539736831952871
|
||||||
|
y = 0.4527190879360086
|
||||||
|
y = 0.4537659596983615
|
||||||
|
y = 0.45500393252270654
|
||||||
|
y = 0.4552026474557314
|
||||||
|
y = 0.4546995780878234
|
||||||
|
```
|
||||||
|
|
||||||
@ -0,0 +1,164 @@
|
|||||||
|
# Модуль 3 варианть 2
|
||||||
|
Ефимова Людмила, А-03-23
|
||||||
|
|
||||||
|
Создайте модуль М1, содержащий две функции:
|
||||||
|
|
||||||
|
- функция 1: аргументы - имя текстового файла с числовыми данными (может быть разное число значений на каждой строке) и пороговое значение КК;
|
||||||
|
считываются значения из указанного файла и записываются в два новых текстовых файла, имена которых совпадают с именем входного файла с добавлением 1 и 2 - в первый файл записываются значения, превышающие заданный порог, а во второй - не превышающие его.
|
||||||
|
Исходные данные в виде списка возвращаются в вызывающую программу;
|
||||||
|
|
||||||
|
- функция 2: аргумент - имя текстового файла с исходными данными; считываются значения из указанного файла, формируются в виде списка и по нему рассчитываются: среднее, медиана, наименьшее и наибольшее значения, стандартное отклонение - это возвращаемые результаты функции.
|
||||||
|
```py
|
||||||
|
import math
|
||||||
|
import statistics
|
||||||
|
|
||||||
|
def func1(filename, KK):
|
||||||
|
with open(filename, 'r', encoding = 'utf-8') as f:
|
||||||
|
nums = []
|
||||||
|
for i in f:
|
||||||
|
nums_line = list(map(float,line.strip().split()))
|
||||||
|
nums.extend(nums_line)
|
||||||
|
|
||||||
|
above = []
|
||||||
|
below = []
|
||||||
|
for n in nums:
|
||||||
|
if n > KK:
|
||||||
|
above.append(n)
|
||||||
|
else:
|
||||||
|
below.append(n)
|
||||||
|
|
||||||
|
x = filename.split('.')[0]
|
||||||
|
with open(x + '1.txt') as f: # запись в новый файл превышающих
|
||||||
|
for num in above:
|
||||||
|
f.write(str(num) +'\n')
|
||||||
|
|
||||||
|
with open(x + '2.txt') as f: # запись в новый файл не превышающих
|
||||||
|
for num in below:
|
||||||
|
f.write(str(num) +'\n')
|
||||||
|
return nums
|
||||||
|
|
||||||
|
def func2(filename):
|
||||||
|
with open(filename, 'r', encoding = 'utf-8') as f:
|
||||||
|
nums = []
|
||||||
|
for i in f:
|
||||||
|
nums_line = list(map(float,line.strip().split()))
|
||||||
|
nums.extend(nums_line)
|
||||||
|
n = len(nums)
|
||||||
|
mean = sum(nums)/n
|
||||||
|
|
||||||
|
median = statistics.median(nums) # медиана
|
||||||
|
std = statistics.stdev(nums) # стандартное отклонение
|
||||||
|
print(mean, median, min(nums), max(nums), std)
|
||||||
|
|
||||||
|
return [mean, median, min(nums), max(nums), std]
|
||||||
|
```
|
||||||
|
|
||||||
|
Создайте еще один модуль М2, в котором должны:
|
||||||
|
|
||||||
|
- запрашиваться имя файла с исходными данными, проверяться его наличие и при отсутствии - повторение запроса;
|
||||||
|
|
||||||
|
- запрос порогового значения КК;
|
||||||
|
|
||||||
|
- вызов функции 1 с указанным именем;
|
||||||
|
|
||||||
|
- трижды вызвать функцию 2: с именем указанного в ответе на запрос файла, а также с каждым из файлов, созданных в функции 1; отобразить результаты расчетов.
|
||||||
|
|
||||||
|
```py
|
||||||
|
import os
|
||||||
|
|
||||||
|
from M1 import func1, func2
|
||||||
|
|
||||||
|
def main():
|
||||||
|
while True:
|
||||||
|
filename = input("Исходный файл: ")
|
||||||
|
if os.path.exists(filename):
|
||||||
|
break
|
||||||
|
print("Нет такого файла...")
|
||||||
|
|
||||||
|
KK = float(input("Введите пороговое значение K: "))
|
||||||
|
data = func1(filename, KK)
|
||||||
|
|
||||||
|
x = filename.split('.')[0]
|
||||||
|
|
||||||
|
print("CТАТИСТИКИ")
|
||||||
|
print("1. Исходный файл: ", func2(filename))
|
||||||
|
print("2. Выше порога: ", func2(x + '1.txt'))
|
||||||
|
print("3. Ниже порога: ", func2(x + '2.txt'))
|
||||||
|
|
||||||
|
return data
|
||||||
|
```
|
||||||
|
|
||||||
|
Создайте модуль М0 - главную программу, которая вызывает М2, отображает исходные данные в виде графика и записывает их в бинарный файл RES2a.bin.
|
||||||
|
```py
|
||||||
|
import M2
|
||||||
|
import matplotlib.pyplot as plt
|
||||||
|
import pickle
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
data = M2.main()
|
||||||
|
|
||||||
|
print("ГРАФИК:")
|
||||||
|
|
||||||
|
plt.figure(figsize=(12, 5))
|
||||||
|
plt.plot(numbers)
|
||||||
|
plt.axhline(y=k, color='r')
|
||||||
|
plt.title(f"Данные из файла: {filename}")
|
||||||
|
plt.xlabel("Номер элемента")
|
||||||
|
plt.ylabel("Значение")
|
||||||
|
plt.grid(True)
|
||||||
|
plt.show()
|
||||||
|
|
||||||
|
with open("Res2a.bin", 'wb') as f:
|
||||||
|
pickle.dump(data, f)
|
||||||
|
```
|
||||||
|
Подготовьте файл с не менее, чем с 20 числовыми значениями с разным числом элементов на разных строках и проверьте с ним разработанную программу.
|
||||||
|
Создала файл datatest.txt с содержимым
|
||||||
|
```py
|
||||||
|
10 20 30 20
|
||||||
|
22 33
|
||||||
|
60 70 80 90
|
||||||
|
15 23 25 27 76
|
||||||
|
5 12 34 67 36
|
||||||
|
```
|
||||||
|
|
||||||
|
Результат работы программы
|
||||||
|
```py
|
||||||
|
Введите имя файла (например: data.txt): datatest.txt
|
||||||
|
Введите пороговое значение K: 23
|
||||||
|
|
||||||
|
СТАТИСТИКИ:
|
||||||
|
1. Исходный файл: Среднее: 37.75, Медиана: 28.50, Мин: 5.00, Макс: 90.00, Отклонение: 26.02
|
||||||
|
2. Выше порога: Среднее: 52.33, Медиана: 48.00, Мин: 25.00, Макс: 90.00, Отклонение: 23.73
|
||||||
|
3. Ниже порога: Среднее: 15.88, Медиана: 17.50, Мин: 5.00, Макс: 23.00, Отклонение: 6.45
|
||||||
|
|
||||||
|
ГРАФИК:
|
||||||
|
Данные сохранены в файл 'Res2a.bin'
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
Содержимое файла above:
|
||||||
|
```py
|
||||||
|
30.0
|
||||||
|
33.0
|
||||||
|
60.0
|
||||||
|
70.0
|
||||||
|
80.0
|
||||||
|
90.0
|
||||||
|
25.0
|
||||||
|
27.0
|
||||||
|
76.0
|
||||||
|
34.0
|
||||||
|
67.0
|
||||||
|
36.0
|
||||||
|
```
|
||||||
|
Содержимое файла below:
|
||||||
|
```py
|
||||||
|
10.0
|
||||||
|
20.0
|
||||||
|
20.0
|
||||||
|
22.0
|
||||||
|
15.0
|
||||||
|
23.0
|
||||||
|
5.0
|
||||||
|
12.0
|
||||||
|
```
|
||||||
Загрузка…
Ссылка в новой задаче