Сравнить коммиты
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
|
||||
```
|
||||
Загрузка…
Ссылка в новой задаче