Создал(а) 'TEMA9/test.md'

README.md

@@ -1,6 +1,7 @@
 # Программное обеспечение автоматизированных систем: лабораторные работы
 
 [Репозиторий с методическими указаниями и заданиями.](http://uit.mpei.ru/git/main/python)
+Обратите внимание на файл с комментариями в репозитории по ссылке.
 
 ## Работа с Git
 
@@ -109,7 +110,7 @@
 
 ### Оформление решений
 
-Решение всех заданий оформляется по образцу:
+Решение всех заданий и тестов оформляется по образцу:
 
     # Общее контрольное задание по теме 2
 
@@ -129,5 +130,8 @@
 
 Для темы 1 вместо «Задания» — «Вопрос», вместо «Решения» — «Ответ».
 
+Для тем 3, 6 и 9 вместо «Индивидуального контрольного задания по теме 3 (6, 9)» —
+«Тест по модулю 1 (2, 3)».
+
 Для тем 8 и 9 раздела «Решение» не нужно,
 вместо этого решение размещается в отдельных файлах `*.py`.

TEMA3/test.md

@@ -0,0 +1,50 @@
+# Тест по Модулю 1
+Киреев Юрий А-02-23
+
+## Задание
+18 Вариант
+1. Можно ли, используя язык Python, создавать загрузочные программы, исполнимые в среде операционной системы?
+2. Создайте объект-список с 20 убывающими по величине элементами, начиная от 115 с шагом 12. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+3. Напишите инструкцию, проверяющую наличие в списке элемента со значением 47. Если его нет в списке, напишите инструкцию, добавляющую этот элемент в список так, чтобы не нарушить убывающий порядок элементов. Отобразите полученный список.
+4. Преобразуйте список в кортеж. Рассчитайте сумму 6 элементов кортежа, начиная с 5-го от начала. Выведите результат на экран в виде "Сумма элементов=ХХХ".
+5. Добавьте к кортежу элемент со значением 0. Удалите из него элемент со значением 55. Выведите полученный кортеж на экран.
+## Решение
+
+1. С помощью Python нельзя создавать программы, работающие на уровне програмного обеспечения, на "голом железе". Но возможно преобразовать Python-скрипт в исполняемый файл (например, с расширением .exe). Для создания исполняемых файлов используются такие инструменты, как например PyInstaller, Auto-Py-to-Exe или Py2exe.
+2. 
+```py
+>>> spis = list(range(115, 115 - 20 * 12, -12))
+>>> spis
+[115, 103, 91, 79, 67, 55, 43, 31, 19, 7, -5, -17, -29, -41, -53, -65, -77, -89, -101, -113]
+>>> 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. 
+```py
+>>> 45 in spis
+False
+>>> spis = sorted(spis + [47], reverse=True)
+>>> spis
+[115, 103, 91, 79, 67, 55, 47, 43, 31, 19, 7, -5, -17, -29, -41, -53, -65, -77, -89, -101, -113]
+```
+4. 
+```py
+>>> tup = tuple(spis)
+>>> tup
+(115, 103, 91, 79, 67, 55, 47, 43, 31, 19, 7, -5, -17, -29, -41, -53, -65, -77, -89, -101, -113)
+>>> XXX=sum(tup[4:])
+>>> print ("Cумма элементов =",XXX)
+Cумма элементов = -321
+```
+5.
+```py
+>>> tup = tup + (0,)
+>>> tup
+(115, 103, 91, 79, 67, 55, 47, 43, 31, 19, 7, -5, -17, -29, -41, -53, -65, -77, -89, -101, -113, 0)
+>>> index=tup.index(55)
+>>> tup=tup[:index]+tup[index+1:]
+>>> tup
+(115, 103, 91, 79, 67, 47, 43, 31, 19, 7, -5, -17, -29, -41, -53, -65, -77, -89, -101, -113, 0)
+```

TEMA4/report.md

@@ -148,4 +148,473 @@ 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', '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', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
 ```
+Обращение к функциям из импортированного модуля осуществляется с указанием имени модуля, по образцу: <имя модуля>.<имя функции>(<аргументы функции>)
 
+Изучим функцию расчёта факториала:
+```py
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+```
+Попробуем использовать эту функцию:
+```py
+>>>math.factorial(5)
+120
+```
+
+Аналогичным образом изучим и попробуем применить некоторые другие функции из этого модуля:
+```py
+>>> help(math.pi)
+Help on float object:
+
+class float(object)
+ |  float(x=0, /)
+ |  
+ |  Convert a string or number to a floating point number, if possible.
+... # огромная справка
+ |  real
+ |      the real part of a complex number
+>>> help(math.sin)
+Help on built-in function sin in module math:
+
+sin(x, /)
+    Return the sine of x (measured in radians).
+
+>>> math.sin(math.pi/2)
+1.0
+>>>help(math.acos)
+Help on built-in function acos in module math:
+
+acos(x, /)
+    Return the arc cosine (measured in radians) of x.
+    
+    The result is between 0 and pi.
+
+>>> math.acos(1)
+0.0
+>>>help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>> math.degrees(2*math.pi)
+360.0
+>>> help(math.radians)
+Help on built-in function radians in module math:
+
+radians(x, /)
+    Convert angle x from degrees to radians.
+
+>>> math.radians(180)
+3.141592653589793
+>>> help(math.exp)
+Help on built-in function exp in module math:
+
+exp(x, /)
+    Return e raised to the power of x.
+>>> math.exp(5)
+148.4131591025766
+>>> help(math.log)
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+    
+    If the base not specified, returns the natural logarithm (base e) of x.
+
+>>> math.log(10)
+2.302585092994046
+>>> help(math.log10)
+Help on built-in function log10 in module math:
+
+log10(x, /)
+    Return the base 10 logarithm of x.
+
+>>> math.log10(10)
+1.0
+>>> help(math.sqrt)
+Help on built-in function sqrt in module math:
+
+sqrt(x, /)
+    Return the square root of x.
+
+>>> math.sqrt(9)
+3.0
+>>> help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+    
+    This is the smallest integer >= x.
+
+>>> math.ceil(3.14)
+4
+>>> help(math.floor)
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+    
+    This is the largest integer <= x.
+
+>>> math.floor(3.14)
+3
+
+```
+
+## 4. Модуль cmath
+
+Функции из модуля 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
+
+Стандартный модуль random – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+```
+Изучим функцию seed.
+
+```py
+>>> 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() #В настоящий момент начальное состояние для псевдослучайных чисел - это системное время
+```
+
+Попробуем самостоятельно изучить и применить некоторые функции:
+```py
+>>> help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+>>> random.random()
+0.5183251743006774
+>>> help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+>>> random.uniform(1,2)
+1.863883074901376
+>>> help(random.randint)
+Help on method randint in module random:
+
+>>> randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>> random.randint(3, 10)
+7
+>>> help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu, sigma) method of random.Random instance
+    Gaussian distribution.
+    
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+    
+    Not thread-safe without a lock around calls.
+
+>>> random.gauss(0,10)
+-14.080852645068202
+help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+>>> numbers = [1, 2, 3, 4, 5]
+>>> random.choice(numbers)
+5
+>>> help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x, random=None) method of random.Random instance
+    Shuffle list x in place, and return None.
+    
+    Optional argument random is a 0-argument function returning a
+    random float in [0.0, 1.0); if it is the default None, the
+    standard random.random will be used.
+
+>>> random.shuffle(numbers)
+>>> numbers
+[3, 1, 4, 2, 5]
+>>> help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence or set.
+    
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  The resulting list is
+    in selection order so that all sub-slices will also be valid random
+    samples.  This allows raffle winners (the sample) to be partitioned
+    into grand prize and second place winners (the subslices).
+    
+    Members of the population need not be hashable or unique.  If the
+    population contains repeats, then each occurrence is a possible
+    selection in the sample.
+    
+    Repeated elements can be specified one at a time or with the optional
+    counts parameter.  For example:
+    
+        sample(['red', 'blue'], counts=[4, 2], k=5)
+    
+    is equivalent to:
+    
+        sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
+    
+    To choose a sample from a range of integers, use range() for the
+    population argument.  This is especially fast and space efficient
+    for sampling from a large population:
+    
+        sample(range(10000000), 60)
+
+>>> random.sample(numbers,3)
+[2, 5, 1]
+>>> help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+>>> random.betavariate(1, 10)
+0.0334849854614458
+>>> help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    
+    The probability distribution function is:
+    
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+>>> random.gammavariate(1,10)
+21.801817565886562
+```
+Создадим список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+
+```py
+rand_spis = [random.random(), random.uniform(1,2), random.betavariate(1, 10), random.gammavariate(1,10)]
+rand_spis
+[0.855682663095964, 1.3318533389175167, 0.08901765537251825, 5.945577224669993]
+```
+
+## 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']
+```
+
+Изучим функцию time, возвращающую время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
+
+```py
+>>> c1=time.time()
+>>> c1
+1760885662.4458969
+>>> c2=time.time()-c1 #время со ввода предыдущей инструкции
+>>> c2
+13.31933856010437
+```
+
+Изучим функцию gmtime:
+
+```py
+>>> help(time.gmtime)
+Help on built-in function gmtime in module time:
+
+gmtime(...)
+    gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
+                           tm_sec, tm_wday, tm_yday, tm_isdst)
+    
+    Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
+    GMT).  When 'seconds' is not passed in, convert the current time instead.
+    
+    If the platform supports the tm_gmtoff and tm_zone, they are available as
+    attributes only.
+
+>>> dat=time.gmtime()
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=14, tm_min=57, tm_sec=31, tm_wday=6, tm_yday=292, tm_isdst=0)
+>>> dat.tm_mon
+10
+```
+Для получения местного времени применим функцию localtime
+```py
+dat2 = time.localtime()
+dat2
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=59, tm_sec=55, tm_wday=6, tm_yday=292, tm_isdst=0)
+```
+Попробуем изучить и применить другие функции модуля time:
+
+```py
+>>> help(time.asctime)
+Help on built-in function asctime in module time:
+
+asctime(...)
+    asctime([tuple]) -> string
+    
+    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
+    When the time tuple is not present, current time as returned by localtime()
+    is used.
+
+>>> time.asctime(dat)
+'Sun Oct 19 14:57:31 2025'
+>>> help(time.ctime)
+Help on built-in function ctime in module time:
+
+>>> ctime(...)
+    ctime(seconds) -> string
+    
+    Convert a time in seconds since the Epoch to a string in local time.
+    This is equivalent to asctime(localtime(seconds)). When the time tuple is
+    not present, current time as returned by localtime() is used.
+
+>>> time.ctime(c1)
+'Sun Oct 19 17:54:22 2025'
+help(time.sleep)
+Help on built-in function sleep in module time:
+
+sleep(...)
+    sleep(seconds)
+    
+    Delay execution for a given number of seconds.  The argument may be
+    a floating point number for subsecond precision.
+
+time.sleep(1) #произошла пауза в IDLE на 1 секунду
+>>> help(time.mktime)
+Help on built-in function mktime in module time:
+
+mktime(...)
+    mktime(tuple) -> floating point number
+    
+    Convert a time tuple in local time to seconds since the Epoch.
+    Note that mktime(gmtime(0)) will not generally return zero for most
+    time zones; instead the returned value will either be equal to that
+    of the timezone or altzone attributes on the time module.
+
+>>> time.mktime(dat)
+1760875051.0
+>>> time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=54, tm_sec=22, tm_wday=6, tm_yday=292, tm_isdst=0)
+```
+
+## 7. Графические функции
+```py
+>>> import pylab #импортируем модуль
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> x,t
+([-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
+>>> pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x00000208629323B0>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show() #Отображение графика на экране
+```
+Наш график:
+![График](Ris1.png)
+Сохранен в текущем каталоге с именем Ris1.
+
+Рассмотрим способ построения нескольких графиков на одном рисунке:
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x00000208655097B0>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000020865509AB0>]
+>>> pylab.show()
+```
+Графики:
+![Рисунок2](Ris2.png)
+
+Теперь изучим возможность построения круговой диаграммы:
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x000002086B0C6E60>, <matplotlib.patches.Wedge object at 0x000002086B0C6DA0>, <matplotlib.patches.Wedge object at 0x000002086B0C78B0>, <matplotlib.patches.Wedge object at 0x000002086B0C7DF0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+![Диаграмма](Ris3.png)
+Изучим отдельно функции hist и bar:
+```py
+>>> pylab.hist([1, 1, 1, 2, 2, 3], bins=3)
+(array([3., 2., 1.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>> pylab.show()
+```
+Гистограмма:
+![Гистограмма](Ris4.png)
+```py
+>>> pylab.bar(region, naselen)
+<BarContainer object of 4 artists>
+>>> pylab.show()
+```
+Столбиковая диаграмма:
+![Стобиковая диаграмма](Ris5.png)
+
+## 8. Модуль statistic
+```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', '_mean_stdev', '_normal_dist_inv_cdf', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'mul', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sys', '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. Завершил сеанс работы с IDLE

TEMA4/task.md

@@ -0,0 +1,57 @@
+# Общее контрольное задание по теме 4
+Киреев Юрий А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+1.
+```py
+>>> import cmath
+>>> divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+(8.0, 2.6000000000000014)
+```
+2.
+```py
+>>> import time
+>>> MosTime = time.gmtime()
+>>> print("Current time: {}:{}".format(MosTime.tm_hour + 3, MosTime.tm_min))      
+Current time: 19:52
+```
+3.
+```
+>>> Days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]      
+>>> import random
+>>> random.sample(Days, 3)
+['Wednesday', 'Sunday', 'Friday']
+```
+4.
+```py
+>>> random.choice(range(14, 33, 3))
+17
+```
+5.
+```py
+>>> import math
+>>> N = math.floor(random.gauss(15, 4))
+>>> N
+10
+import string
+letters = random.sample(string.ascii_letters, N)
+letters
+['l', 'x', 'J', 'm', 'K', 'C', 'Z', 'c', 'L', 'G']
+```
+6.
+```py
+timediff = round(time.time() - time.mktime(localTime))
+print(timediff // 60, "minutes and", timediff % 60, "seconds")
+18 minutes and 51 seconds
+```
+

TEMA4/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по теме 4
+Киреев Юрий А-02-23
+## Задание
+18 Вариант
+Напишите инструкцию запоминания текущего Московского времени в некоторой переменной. Создайте кортеж с целочисленными значениями от 0 до 136 с шагом 17. Подсчитайте число элементов в кортеже. Создайте нормально распределенное число Z с математическим ожиданием 47 и стандартным отклонением 22. Нацело разделите сумму элементов кортежа на округленное до целого значения Z. Отобразите результат в виде символьной строки вида «Результат = ХХ» с использование формата. Определите время в минутах, прошедшее с начала выполнения данного задания.
+## Решение
+```py
+>>> import time
+>>> MosTime=time.gmtime(time.time() + 3*60*60)
+MosTime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=11, tm_min=13, tm_sec=41, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> Tup = tuple(range(0,137,17))
+>>> Tup
+(0, 17, 34, 51, 68, 85, 102, 119, 136)
+>>> len(Tup)
+9
+>>> import random
+>>> Z = random.gauss(47,22)
+>>> Z
+18.38882285407876
+>>> S = sum(Tup) // round(Z)
+>>> print("Результат = {}".format(S))
+Результат = 34
+>>> time.time()//60 - time.mktime(MosTime)//60
+25.0
+```
+

TEMA5/report.md

@@ -0,0 +1,303 @@
+# Отчёт по теме 5
+Киреев Юрий, А-02-23
+
+## 1. Запуск интерактивной оболочки IDLE
+Создал файл отчёта
+
+## 2. Управляющая инструкция IF
+Зададим некоторые числовые значения объектам porog, rashod1, rashod2. Выполним следующую операцию, определив значение dohod:
+```py
+>>> porog = 10
+>>> rashod1 = 5
+>>> rashod2 = 20
+>>> if rashod1>=porog:
+>>>     dohod=12
+>>> elif rashod2==porog:
+>>>     dohod=0
+>>> else:
+>>>     dohod=-8  
+
+>>> dohod
+-8
+```
+Выполним ещё одну операцию, определим значение dohod:
+```py
+>>> if rashod1>=3 and rashod2==4:
+>>>     dohod=rashod1
+>>>     if rashod2==porog or rashod1<rashod2:
+>>>         dohod=porog
+   
+>>> dohod
+-8
+```
+И ещё одна операция с множественным ветвлением линий потока:
+```py
+>>> if porog==3:
+>>>     dohod=1
+>>> elif porog==4:
+>>>     dohod=2
+>>> elif porog==5:
+>>>     dohod=3
+>>> else:
+>>>     dohod=0
+
+>>> dohod
+0
+```
+Условные инструкции могут записываться также в одну строку в операторе присваивания.
+Примеры:
+```py
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+2
+>>> if porog>=5 : rashod1=6; rashod2=0
+
+>>> rashod1
+6
+>>> rashod2
+0
+```
+
+## 3. Управляющая инструкция FOR
+
+### 3.1. Простой цикл
+```py
+>>> temperatura=5
+>>> for i in range(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]
+```
+Выполним чуть-чуть отличающуюся совокупность операций:
+```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]
+```
+Отличие в этих инструкциях в том, что во второй записи for k in sps[:] идёт обращение к копии sps, которая не изменяется. Исходный список sps изменяется отдельно. Цикл выполнится ровно len(sps) раз (по кол-ву элементов в исходном списке).
+
+### 3.3 Пример: создание списка с 10 целыми случайными числами из диапазона от 1 до 100
+```py
+>>> import random as rn
+>>> sps5=[]
+>>> for i in range(10):
+>>> 	sps5.append(rn.randint(1,100))
+>>> 	ss=sum(sps5)
+>>> 	if ss>500: break
+>>> else:
+>>> 	print(ss)
+
+>>> sps5
+[79, 9, 69, 43, 40, 98, 7, 55, 69, 50]
+```
+После проделывания этих операций ещё несколько раз, стало понятно, что значение ss выдаётся не всегда. Это связано с тем, что сумма элементов списка может превысить 500, и тогда сработает инструкция break, и цикл прервётся. Чтобы значение ss выдавалось, при последней проверке if сумма ss должна быть меньше 500.
+
+### 3.4. Пример с символьной строкой
+```py
+>>> stroka='Это – автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+>>>	stroka1+=" "+ss
+
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+
+### 3.5. List comprehension
+```py
+import math
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+```
+Отобразим сигнал в виде графика:
+```py
+>>> import pylab
+>>> pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x000002316338A5C0>]
+>>> pylab.show()
+```
+![Сигнал](figure0.png)
+
+## 4. Управляющая инструкция while
+
+### 4.1. Цикл со счетчиком
+```py
+>>> rashod=300
+>>> while rashod:
+>>>     print("Расход=",rashod)
+>>>     rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Здесь завершение цикла произошло, когда при проверке значения rashod оно было равно 0.
+
+### 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
+```
+Представим в виде графика сигнал на выходе инерционного звена из списка sps2:
+```py
+>>> pylab.plot(sps2)
+[<matplotlib.lines.Line2D object at 0x0000023166005C90>]
+>>> pylab.show()
+```
+![Сигнал на выходе инерционного звена](figure1.png)
+
+### 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
+>>> while chislo <= 300:
+>>>     kandidat = chislo // 2
+>>>     while kandidat > 1:
+>>>         if chislo%kandidat == 0:
+>>>             print(chislo, ' имеет множитель ', kandidat)
+>>>             break
+>>>         kandidat -= 1
+>>>     else:
+>>>         print(chislo, ' является простым!')
+>>>     chislo += 1
+
+    
+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
+```
+Программу можно переделать так, чтобы выявлялись только простые числа, без сообщения о том, что некоторые числа имеют множитель, убрав строку print(chislo, ' имеет множитель ', kandidat).
+
+### 4.4. Замечание
+Помимо инструкции break в обоих видах циклов могут использоваться инструкции contin-ue, которые не вызывают завершения цикла, но завершают его текущий виток и обеспечивают переход к следующему витку.
+
+## 5. Завершил работу с IDLE.
+
+

TEMA5/task.md

@@ -0,0 +1,87 @@
+# Общее контрольное задание по теме 5
+Киреев Юрий, А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+1. Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+3. Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+1.
+```py
+>>> stroka = 'The row with text in English'
+>>> alphabet = 'abcdefghijklmnopqrstuvwxyz'
+>>> for char in stroka:
+>>>     if char.isalpha():
+>>>         lower_char = char.lower()
+>>>         number = alphabet.index(lower_char) + 1
+>>>         print(f"Буква '{char}' -> номер {number}")
+
+        
+Буква 'T' -> номер 20
+Буква 'h' -> номер 8
+Буква 'e' -> номер 5
+Буква 'r' -> номер 18
+Буква 'o' -> номер 15
+Буква 'w' -> номер 23
+Буква 'w' -> номер 23
+Буква 'i' -> номер 9
+Буква 't' -> номер 20
+Буква 'h' -> номер 8
+Буква 't' -> номер 20
+Буква 'e' -> номер 5
+Буква 'x' -> номер 24
+Буква 't' -> номер 20
+Буква 'i' -> номер 9
+Буква 'n' -> номер 14
+Буква 'E' -> номер 5
+Буква 'n' -> номер 14
+Буква 'g' -> номер 7
+Буква 'l' -> номер 12
+Буква 'i' -> номер 9
+Буква 's' -> номер 19
+Буква 'h' -> номер 8
+```
+2.
+```py
+>>> words = ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке']
+>>> print("Список слов:", words)
+Список слов: ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке']
+>>> search_words = ['Создайте', 'со', 'яблоко', 'я', 'соответствующее']
+>>> for word in search_words:
+>>>     if word in words:
+>>>         print(f"Слово '{word}' НАЙДЕНО в списке")
+>>>     else:
+>>>         print(f"Слово '{word}' ОТСУТСТВУЕТ в списке")
+
+        
+Слово 'Создайте' НАЙДЕНО в списке
+Слово 'со' НАЙДЕНО в списке
+Слово 'яблоко' ОТСУТСТВУЕТ в списке
+Слово 'я' ОТСУТСТВУЕТ в списке
+Слово 'соответствующее' НАЙДЕНО в списке
+```
+
+3.
+```py
+>>> stud_sum = ['Киреев', 'Беженарь', 'Володин']
+>>> stud_win = ['Беженарь', 'Володин', 'Киреев']
+>>> sr_ball_sum = [4.56, 5.00, 4.6]
+>>> sr_ball_win = [5.00, 4.5, 4.73]
+>>> name = input("Введите фамилию студента: ")
+    Введите фамилию студента: Киреев
+>>> if name in stud_sum and name in stud_win:
+>>>     summer_grade = sr_ball_sum[stud_sum.index(name)]
+>>>     winter_grade = sr_ball_win[stud_win.index(name)]
+>>>     print(f"Студент: {name}\nОценка за летнюю сессию: {summer_grade}\nОценка за зимнюю сессию: {winter_grade}")
+>>> else:
+>>>     print(f"Студент {name} не найден")
+ 
+Студент: Киреев
+Оценка за летнюю сессию: 4.56
+Оценка за зимнюю сессию: 4.73
+    
+    Введите фамилию студента: Иванов
+Студент Иванов не найден
+```

TEMA5/test.md

@@ -0,0 +1,42 @@
+# Индивидуальное контрольное задание по теме 5
+Киреев Юрий, А-02-23
+## Задание
+Вариант 14
+
+Запросите у пользователя ввод списка с двумя числовыми элементами. Обеспечьте проверку корректности ввода (что введено, действительно, два элемента) и проверку совпадения знаков у введенных чисел. Если проверка дала негативный результат, выдать сообщение и обеспечить повторение ввода. Если все хорошо, отобразить введенный список с заголовком.
+## Решение
+```py
+while True:
+    user_input = input("Введите список в формате [число1, число2]: ")
+    if len(user_input) < 2 or user_input[0] != '[' or user_input[-1] != ']':
+        print ("Ошибка: неверный формат списка")
+        continue
+    content = user_input[1:-1]
+    elements = content.split(',')
+    if len(elements) != 2:
+        print ("Ошибка: в списке должно быть ровно два числа")
+        continue
+    num1 = float(elements[0])
+    num2 = float(elements[1])
+    if (num1 < 0 and num2 < 0) or (num1 > 0 and num2 > 0) or (num1 == 0 and num2 == 0):
+        print("="*20,"ВВЕДЁННЫЙ СПИСОК","="*20)
+        print(f"[{num1},{num2}]")
+        break
+    else:
+        print("Ошибка: знаки чисел не совпадают")
+```
+Тесты:
+```py
+Введите список в формате [число1, число2]: [-2, -2]
+==================== ВВЕДЁННЫЙ СПИСОК ====================
+[-2.0,-2.0]
+Введите список в формате [число1, число2]: [11, 2]
+==================== ВВЕДЁННЫЙ СПИСОК ====================
+[11.0,2.0]
+Введите список в формате [число1, число2]: [11, -2]
+Ошибка: знаки чисел не совпадают
+Введите список в формате [число1, число2]: [11, -2, -3]
+Ошибка: в списке должно быть ровно два числа
+Введите список в формате [число1, число2]: 11, -2, -3
+Ошибка: неверный формат списка
+```

TEMA6/report.md

@@ -0,0 +1,515 @@
+# Отчёт по теме 6
+Киреев Юрий А-02-23
+## 1. Запуск интерактивной оболочки IDLE
+Создал файл отчёта
+## 2. Вывод данных на экран дисплея
+### 2.1. Вывод в командной строке
+Пока ведется работа с инструкциями, содержимое объекта можно увидеть, с помощью упоминания его в командной строке, например:
+```py
+>>> stroka='Автоматизированная система управления'
+>>> stroka
+'Автоматизированная система управления'
+```
+Этот способ называется «эхо-выводом». Он пригоден при работе в командной строке, однако в пользовательских функциях, которые будут изучаться дальше, этот способ применять нельзя.
+### 2.2. Вывод с использованием функции print
+Пример вывода:
+```py
+>>> fff=234.5;gg='Значение температуры = '
+>>> print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+```
+Если нужен другой разделитель его можно указать в отдельном аргументе sep, например:
+```py
+>>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оста-вить в той же строке, то следует использовать еще один аргумент, например:
+```py
+>>> print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+```
+Наоборот, если в какой-то момент требуется просто перейти на новую строку, можно использо-вать такое обращение к функции:
+```py
+>>> print()
+
+```
+Наконец, оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```py
+>>> print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+
+>>> print("Здесь может выводиться",
+     "большой текст,",
+     "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+### 2.3. Вывод с использованием метода write  объекта sys.stdout.
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных. Обычно это – экран дисплея. Объект находится в модуле sys, который надо импортировать.
+```py
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+```
+Если это требуется, то следует в конце строки добавить один или несколько символов “\n”:
+```py
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+## 3. Ввод данных с клавиатуры
+За ввод отвечает функция input:
+```py
+>>> psw=input('Введите пароль:')
+Введите пароль:123
+>>> psw
+'123'
+>>> type(psw)
+<class 'str'>
+```
+#### Пример 1. Ввод с контролем значения.
+Пусть вводится число, которое должно находиться в интервале значений от 17.5 до 23.8.
+```py
+>>> while True:
+>>> 	znach=float(input('Задайте коэф.усиления = '))
+>>> 	if znach<17.5 or znach>23.8:
+>>> 		print('Ошибка!')
+>>> 	else:
+>>> 		break
+
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+znach
+21.6
+```
+#### Пример 2. Ввод и обработка выражения, подлежащего расчету.
+```py
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+## 4. Ввод-вывод при работе с файлами.
+### 4.1. Функции для работы с путем к файлу.
+Эти функции собраны в модуле os:
+```py
+>>> import os
+>>> os.getcwd()
+'C:\\Users\\user\\AppData\\Local\\Programs\\Python\\Python310'
+>>> KireevYuri = os.getcwd()
+>>> print(KireevYuri)
+C:\Users\user\AppData\Local\Programs\Python\Python310
+```
+Изменить расположение рабочего каталога можно обращением к уже многократно применявшейся функции os.chdir:
+```py
+>>> os.chdir('C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA6')
+```
+Самостоятельно изучим некоторые функции из модуля:
+```py
+>>> os.mkdir("new_folder") #создание нового подкаталога
+>>> print("Папка 'new_folder' создана")
+Папка 'new_folder' создана
+>>> os.rmdir("new_folder") #удаление подкаталога
+>>> os.listdir() #отображение содержимого папки (в данном случае текущего каталога)
+['.gitkeep', 'report.md']
+os.path.isdir('C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA6') #является ли путь директорией
+True
+```
+Попробуем получить символьную строку, содержащую имя файла вместе с полным  путем доступа к нему.
+```py
+>>> fil=os.path.abspath('Методические указания по ПОАС (4)')
+>>> print(fil)
+C:\Users\user\Desktop\ПОАС\python-labs\TEMA6\Методические указания по ПОАС (4)
+```
+Выделим путь доступа к файлу из строки, содержащей и этот путь, и имя файла с помощью функции os.path.dirname:
+```py
+>>> drkt=os.path.dirname(fil)
+>>> print(drkt)
+C:\Users\user\Desktop\ПОАС\python-labs\TEMA6
+```
+Наоборот, выделить имя файла из этой строки с отбрасыванием пути можно с помощью функции os.path.basename:
+```py
+>>> name = os.path.basename(fil); print(name)
+Методические указания по ПОАС (4)
+```
+Cамостоятельно изучите функцию os.path.split.
+```py
+>>> sp = os.path.split(fil)
+>>> print(sp)
+('C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA6', 'Методические указания по ПОАС (4)')
+```
+Проверим, существуют ли заданные пути с помощью функции os.path.exists.
+```py
+>>> os.path.exists(drkt)
+True
+>>> os.path.exists('C:\\Users\\user\\Desktop\\ПОАСC')
+False
+```
+Проверим наличие файла с известным расположением с помощью функции os.path.isfile.
+```py
+os.path.isfile(fil)
+True
+os.path.isfile(os.path.dirname(fil)+'fil1.txt')
+False
+```
+### 4.2. Общая схема работы с файлом
+Для обмена данными с файлом необходимо выполнить следующие операции:
+1. Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+2. Выполнение одной или нескольких операций обмена данными с файлом;
+3. Закрытие файла.
+### 4.3. Открытие файла для записи или чтения данных – функция open.
+```py
+>>> help(open)
+Help on built-in function open in module io:
+
+open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+    Open file and return a stream.  Raise OSError upon failure.
+    
+    file is either a text or byte string giving the name (and the path
+    if the file isn't in the current working directory) of the file to
+    be opened or an integer file descriptor of the file to be
+    wrapped. (If a file descriptor is given, it is closed when the
+    returned I/O object is closed, unless closefd is set to False.)
+    
+    mode is an optional string that specifies the mode in which the file
+    is opened. It defaults to 'r' which means open for reading in text
+    mode.  Other common values are 'w' for writing (truncating the file if
+    it already exists), 'x' for creating and writing to a new file, and
+    'a' for appending (which on some Unix systems, means that all writes
+    append to the end of the file regardless of the current seek position).
+    In text mode, if encoding is not specified the encoding used is platform
+    dependent: locale.getpreferredencoding(False) is called to get the
+    current locale encoding. (For reading and writing raw bytes use binary
+    mode and leave encoding unspecified.) The available modes are:
+    
+    ========= ===============================================================
+    Character Meaning
+    --------- ---------------------------------------------------------------
+    'r'       open for reading (default)
+    'w'       open for writing, truncating the file first
+    'x'       create a new file and open it for writing
+    'a'       open for writing, appending to the end of the file if it exists
+    'b'       binary mode
+    't'       text mode (default)
+    '+'       open a disk file for updating (reading and writing)
+    'U'       universal newline mode (deprecated)
+    ========= ===============================================================
+    
+    The default mode is 'rt' (open for reading text). For binary random
+    access, the mode 'w+b' opens and truncates the file to 0 bytes, while
+    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
+    raises an `FileExistsError` if the file already exists.
+    
+    Python distinguishes between files opened in binary and text modes,
+    even when the underlying operating system doesn't. Files opened in
+    binary mode (appending 'b' to the mode argument) return contents as
+    bytes objects without any decoding. In text mode (the default, or when
+    't' is appended to the mode argument), the contents of the file are
+    returned as strings, the bytes having been first decoded using a
+    platform-dependent encoding or using the specified encoding if given.
+    
+    'U' mode is deprecated and will raise an exception in future versions
+    of Python.  It has no effect in Python 3.  Use newline to control
+    universal newlines mode.
+    
+    buffering is an optional integer used to set the buffering policy.
+    Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
+    line buffering (only usable in text mode), and an integer > 1 to indicate
+    the size of a fixed-size chunk buffer.  When no buffering argument is
+    given, the default buffering policy works as follows:
+    
+    * Binary files are buffered in fixed-size chunks; the size of the buffer
+      is chosen using a heuristic trying to determine the underlying device's
+      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
+      On many systems, the buffer will typically be 4096 or 8192 bytes long.
+    
+    * "Interactive" text files (files for which isatty() returns True)
+      use line buffering.  Other text files use the policy described above
+      for binary files.
+    
+    encoding is the name of the encoding used to decode or encode the
+    file. This should only be used in text mode. The default encoding is
+    platform dependent, but any encoding supported by Python can be
+    passed.  See the codecs module for the list of supported encodings.
+    
+    errors is an optional string that specifies how encoding errors are to
+    be handled---this argument should not be used in binary mode. Pass
+    'strict' to raise a ValueError exception if there is an encoding error
+    (the default of None has the same effect), or pass 'ignore' to ignore
+    errors. (Note that ignoring encoding errors can lead to data loss.)
+    See the documentation for codecs.register or run 'help(codecs.Codec)'
+    for a list of the permitted encoding error strings.
+    
+    newline controls how universal newlines works (it only applies to text
+    mode). It can be None, '', '\n', '\r', and '\r\n'.  It works as
+    follows:
+    
+    * On input, if newline is None, universal newlines mode is
+      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
+      these are translated into '\n' before being returned to the
+      caller. If it is '', universal newline mode is enabled, but line
+      endings are returned to the caller untranslated. If it has any of
+      the other legal values, input lines are only terminated by the given
+      string, and the line ending is returned to the caller untranslated.
+    
+    * On output, if newline is None, any '\n' characters written are
+      translated to the system default line separator, os.linesep. If
+      newline is '' or '\n', no translation takes place. If newline is any
+      of the other legal values, any '\n' characters written are translated
+      to the given string.
+    
+    If closefd is False, the underlying file descriptor will be kept open
+    when the file is closed. This does not work when a file name is given
+    and must be True in that case.
+    
+    A custom opener can be used by passing a callable as *opener*. The
+    underlying file descriptor for the file object is then obtained by
+    calling *opener* with (*file*, *flags*). *opener* must return an open
+    file descriptor (passing os.open as *opener* results in functionality
+    similar to passing None).
+    
+    open() returns a file object whose type depends on the mode, and
+    through which the standard file operations such as reading and writing
+    are performed. When open() is used to open a file in a text mode ('w',
+    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
+    a file in a binary mode, the returned class varies: in read binary
+    mode, it returns a BufferedReader; in write binary and append binary
+    modes, it returns a BufferedWriter, and in read/write mode, it returns
+    a BufferedRandom.
+    
+    It is also possible to use a string or bytearray as a file for both
+    reading and writing. For strings StringIO can be used like a file
+    opened in a text mode, and for bytes a BytesIO can be used like a file
+    opened in a binary mode.
+```
+Откройте файл zapis1.txt для записи данных с помощью инструкции:
+```py
+>>> fp=open(file=drkt+'\\zapis1.txt',mode='w') #в рабочем каталоге был создан файл zapis1.txt
+```
+Вообще говоря, аргументы функции с их именами могут располагаться в любом порядке. Если имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать и просто вводить.
+```py
+>>> fp=open(drkt+'\\zapis1.txt','w')
+```
+Если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла:
+```py
+>>> fp=open('zapis1.txt','w')
+```
+Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели  надо добавить символ «b». Например:
+```py
+fp1=open(drkt+'\\zapis2.bin',mode='wb+') #был создан бинарный файл zapis2.bin в рабочем каталоге.
+```
+### 4.4. Закрытие файла
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. Это делается с помощью метода close, применяемого к объекту – файловой пе-ременной. Например:
+```py 
+>>> fp.close()
+```
+### 4.5. Запись информации в файл с помощью метода write
+Метод write относится к объекту – файловой переменной.
+Пример: Cоздадим список с элементами-числами от 1 до 12 и запишем их в файл по 4 числа на строке:
+```py
+>>> sps=list(range(1,13))
+...                                                          
+>>> fp2=open('zapis3.txt','w')
+...                                                          
+>>> fp2.write(str(sps[:4])+'\n')
+...                                                          
+13
+>>> fp2.write(str(sps[4:8])+'\n')
+...                                                          
+13
+>>> fp2.write(str(sps[8:])+'\n')
+...                                                          
+16
+>>> fp2.close()
+...
+```
+Покажем, что произошло в файле zapis3.txt:
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+Создадим список с элементами-списками и пусть его элементы требуется построчно записать в файл zapis4.txt.
+```py
+>>> sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+>>> fp3=open('zapis4.txt','w')
+>>> 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
+>>> gh=open('zapis5.txt','w')
+                                                          
+>>> for r in sps3:
+>>>     gh.write(r[0]+' '+str(r[1])+'\n')
+
+12
+12
+13
+>>> gh.close()
+```
+Посмотрим на то, что получилось:
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+Этот цикл также можно представить одной строкой
+```py
+>>> gh=open('zapis5.txt','w')                                                          
+>>> for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+
+                                                          
+12
+12
+13
+>>> gh.close()
+```
+В файле ничего не изменилось.
+
+### 4.6. Первый способ чтения информации из текстового файла.
+Прочитаем информацию из ранее созданного файла zapis3.txt.
+```py
+>>> sps1=[]                                                      
+>>> fp=open('zapis3.txt')                                                    
+>>> for stroka in fp:
+>>> 	stroka=stroka.rstrip('\n')
+>>> 	stroka=stroka.replace('[','')
+>>>	stroka=stroka.replace(']','')
+>>> 	sps1=sps1+stroka.split(',')
+>>> fp.close()
+>>> print(sps1)
+                                                          
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+Прочитанные данные несколько отличаются от исходных. Исправить это можно так:
+```py
+>>> sps2 = []
+>>> fp = open('zapis3.txt')
+>>> for stroka in fp:
+>>>     stroka = stroka.rstrip('\n')
+>>>     stroka = stroka.replace('[', '')
+>>>     stroka = stroka.replace(']', '')
+>>>     stroka = stroka.replace(' ', '')
+>>>     sps2 = sps2 + [int(x) for x in stroka.split(',')]    
+>>> fp.close()
+>>> sps2
+[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) # Чтение первых 12 байт (символов)
+>>> stroka2 = fp.read() # Чтение файла полностью
+>>> fp.close()
+>>> stroka1
+    '[1, 2, 3, 4]'
+>>> stroka2
+    '\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+>>> fp.close()
+```
+### 4.8. Чтение информации с помощью методов readline и readlines.
+Методы 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) # Запись объекта в файл
+>>> fp.close()
+```
+Содержимое файла:
+```py
+Ђ•#       Џ”(Њpen”ЊiPhone”Њbook”Њtable”ђ.
+```
+Получение объекта из файла можно осуществить с помощью метода load:
+```py
+>>> fp = open("zapis6.mnz", "rb")
+>>> mnoz2 = pickle.load(fp) # Получение объекта из файла
+>>> fp.close()
+>>> mnoz2
+{'book', 'iPhone', 'table', 'pen'}
+>>> mnoz1 == mnoz2
+True
+```
+Важно подметить, что при считывании из файла объекты имеют тот же порядок, что и при их записи в него:
+```py
+>>> fp = open("zapis7.2ob", "wb")
+>>> pickle.dump(mnoz1, fp)
+>>> pickle.dump(sps3, fp)
+>>> fp.close()
+>>> fp = open("zapis7.2ob", "rb")
+>>> obj1 = pickle.load(fp) # Первое обращение к load читает первый объект
+>>> obj2 = pickle.load(fp) # Второе – читает второй
+>>> fp.close()
+>>> obj1
+{'book', 'iPhone', 'table', 'pen'}
+>>> 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('запись строки на экран')  #Убеждаемся, что вывод на экран восстановился
+    запись строки на экран
+```
+В результате данных действий строка "Запись строки в файл" записалась в файл Stroka.txt:
+```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()
+>>> sys.stdin = tmp_in # Не забыть вернуть стандартное назначение для потока ввода
+```
+## 6. Завершение работы со средой.

TEMA6/task.md

@@ -0,0 +1,84 @@
+# Общее контрольное задание по теме 6
+
+Киреев Юрий, А-02-23
+
+## Задание
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+3. Записывается кортеж в бинарный файл.
+4. Записывается в этот же файл список и закрывается файл.
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+7. Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение
+1.
+```py
+>>> import random
+>>> kort = tuple([str(random.randint(6, 56)) for i in range(125)])
+>>> kort
+('47', '25', '20', '55', '38', '33', '19', '6', '19', '35', '6', '51', '25', '21', '10', '50', '39', '33', '55', '38', '24', '26', '38', '21', '53', '46', '53', '11', '51', '28', '48', '22', '54', '52', '17', '24', '35', '33', '6', '26', '32', '12', '19', '35', '52', '44', '18', '54', '22', '8', '25', '55', '27', '18', '11', '22', '30', '27', '52', '48', '45', '41', '23', '39', '46', '25', '36', '7', '33', '18', '42', '43', '38', '15', '49', '41', '14', '22', '41', '47', '8', '35', '18', '46', '51', '35', '27', '51', '36', '37', '19', '38', '47', '21', '40', '34', '6', '7', '8', '28', '12', '28', '6', '14', '25', '12', '56', '45', '41', '17', '40', '54', '35', '25', '49', '17', '41', '22', '11', '38', '48', '8', '23', '34', '36')
+```
+2.
+```py
+>>> lastnames = ['Киреев', 'Беженарь', 'Володин', 'Криви', 'Кузьменко']
+```
+3.
+```py
+>>> fp = open("binary.bin", "wb")
+>>> pickle.dump(kort, fp)
+```
+4.
+```py
+>>> pickle.dump(lastnames, fp)
+>>> fp.close()
+```
+5.
+```py
+>>> fp = open("binary.bin", "rb")
+>>> kort2 = pickle.load(fp)
+>>> lastnames2 = pickle.load(fp)
+>>> print(kort2, lastnames2)
+('47', '25', '20', '55', '38', '33', '19', '6', '19', '35', '6', '51', '25', '21', '10', '50', '39', '33', '55', '38', '24', '26', '38', '21', '53', '46', '53', '11', '51', '28', '48', '22', '54', '52', '17', '24', '35', '33', '6', '26', '32', '12', '19', '35', '52', '44', '18', '54', '22', '8', '25', '55', '27', '18', '11', '22', '30', '27', '52', '48', '45', '41', '23', '39', '46', '25', '36', '7', '33', '18', '42', '43', '38', '15', '49', '41', '14', '22', '41', '47', '8', '35', '18', '46', '51', '35', '27', '51', '36', '37', '19', '38', '47', '21', '40', '34', '6', '7', '8', '28', '12', '28', '6', '14', '25', '12', '56', '45', '41', '17', '40', '54', '35', '25', '49', '17', '41', '22', '11', '38', '48', '8', '23', '34', '36') ['Киреев', 'Беженарь', 'Володин', 'Криви', 'Кузьменко']
+>>> fp.close()
+```
+6.
+```py
+>>> if (kort2 == kort): print("Кортежи совпадают")
+Кортежи совпадают
+>>> if (lastnames2 == lastnames): print("Списки совпадают")
+Списки совпадают
+```
+7.
+```py
+>>> for i in range(0, len(kort), 5):
+       exec(f'spis{i//5} = list(kort[i:i + 5])')
+>>> for i in range(len(kort) // 5):
+       exec(f'print("spis" + str(i) + ":", spis{i})')       
+spis0: ['47', '25', '20', '55', '38']
+spis1: ['33', '19', '6', '19', '35']
+spis2: ['6', '51', '25', '21', '10']
+spis3: ['50', '39', '33', '55', '38']
+spis4: ['24', '26', '38', '21', '53']
+spis5: ['46', '53', '11', '51', '28']
+spis6: ['48', '22', '54', '52', '17']
+spis7: ['24', '35', '33', '6', '26']
+spis8: ['32', '12', '19', '35', '52']
+spis9: ['44', '18', '54', '22', '8']
+spis10: ['25', '55', '27', '18', '11']
+spis11: ['22', '30', '27', '52', '48']
+spis12: ['45', '41', '23', '39', '46']
+spis13: ['25', '36', '7', '33', '18']
+spis14: ['42', '43', '38', '15', '49']
+spis15: ['41', '14', '22', '41', '47']
+spis16: ['8', '35', '18', '46', '51']
+spis17: ['35', '27', '51', '36', '37']
+spis18: ['19', '38', '47', '21', '40']
+spis19: ['34', '6', '7', '8', '28']
+spis20: ['12', '28', '6', '14', '25']
+spis21: ['12', '56', '45', '41', '17']
+spis22: ['40', '54', '35', '25', '49']
+spis23: ['17', '41', '22', '11', '38']
+spis24: ['48', '8', '23', '34', '36']
+```

TEMA6/test.md

@@ -0,0 +1,85 @@
+# Индивидуальное контрольное задание по модулю 2
+Киреев Юрий, А-02-23
+## Задание
+1)	Создайте список с 25 случайными элементами, подчиняющимися нормальному распределению с математическим ожиданием -6.7 и стандартным отклонением 1.23. Округлите значения элементов до 3-х знаков после точки.
+
+2)	Из элементов списка с нечетными индексами сформируйте кортеж и запишите его в бинарный файл. Остальные элементы запишите в текстовый файл по одному числу на строке.
+
+3)	Удалите из памяти список и кортеж.
+
+4)	Прочитайте числа из текстового  файла с записью их в список. Рассчитайте сумму элементов списка. Отобразите результат расчета по шаблону: "Сумма элементов списка = <значение> единиц". Выводите значение с точностью до одного знака после точки.
+
+5)	Запишите это же сообщение в текстовый файл с именем, совпадающим с именем бинарного файла, и с расширением ТХТ.
+## Решение
+1)
+```py
+spis = [random.gauss(-6.7, 1.23) for x in range (25)]
+spis
+[-8.197422212335816, -7.574367979195539, -8.248648207136844, -7.990453691933484, -8.141501641096257, -7.111273654678145, -6.6380516003931955, -6.734311101253375, -5.507975900785041, -4.813987359682213, -6.6568452400014575, -7.279373137542832, -5.705746481082025, -6.065087925371984, -6.074781438709197, -8.005257284310325, -5.318432003003645, -5.823830096595744, -6.163595205510788, -6.757022447462937, -6.1214339340545685, -6.946666806710584, -3.947016222853067, -6.938975871006476, -5.221201460094965]
+for i in range(len(spis)):
+    spis[i] = round(spis[i], 3)
+
+spis
+[-8.197, -7.574, -8.249, -7.99, -8.142, -7.111, -6.638, -6.734, -5.508, -4.814, -6.657, -7.279, -5.706, -6.065, -6.075, -8.005, -5.318, -5.824, -6.164, -6.757, -6.121, -6.947, -3.947, -6.939, -5.221]
+```
+2)
+```py
+kort = tuple(spis[i] for i in range(len(spis)) if i%2 == 1)
+kort
+(-7.574, -7.99, -7.111, -6.734, -4.814, -7.279, -6.065, -8.005, -5.824, -6.757, -6.947, -6.939)
+import os
+os.chdir('C:\\Users\\u522-13\\Desktop\\zad')
+import pickle
+with open('zapis.kor','wb') as fp:
+    pickle.dump(kort,fp)
+#Содержимое файла:
+Ђ•p       (GАKЖ§пќІGАхВЏ\(цGАq©ызl‹GАпќІ-VGАA‰7KЖЁGАІ-VGАBЏ\(хГGА Џ\(хГGАKЖ§пќІGА+IєGАЙє^5?}GАБ‰7KЖЁt”.
+with open ('zapis2.txt','w') as fp:
+    for i in range (len(spis)):
+        if (i%2 == 0):
+            fp.write(str(spis[i]) + '\n')
+#Содержимое файла
+-8.197
+-8.249
+-8.142
+-6.638
+-5.508
+-6.657
+-5.706
+-6.075
+-5.318
+-6.164
+-6.121
+-3.947
+-5.221
+```
+3)
+```py
+del spis, kort
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'fp', 'i', 'os', 'pickle', 'random']
+```
+4)
+```py
+with open('zapis2.txt') as fp:
+    for stroka in fp:
+        stroka = stroka.rstrip()
+        spis.append(float(stroka))
+spis
+[-8.197, -8.249, -8.142, -6.638, -5.508, -6.657, -5.706, -6.075, -5.318, -6.164, -6.121, -3.947, -5.221]
+print ("Сумма элементов списка =",(round(sum(spis), 1)),"единиц")
+Сумма элементов списка = -81.9 единиц
+```
+5)
+```py
+message = f"Сумма элементов списка = {(round(sum(spis), 1))} единиц"
+message
+'Сумма элементов списка = -81.9 единиц'
+
+with open('zapis.txt','w') as fp:
+    fp.write(message)
+
+37
+#Содержимое файла
+Сумма элементов списка = -81.9 единиц
+```

TEMA7/report.md

@@ -0,0 +1,493 @@
+# Отчёт по теме 7
+Киреев Юрий А-02-23
+## 1. Запуск интерактивной оболочки IDLE
+Создал файл отчёта
+## 2. Создание пользовательской функции.
+### 2.1. Функция без аргументов.
+Пример:
+```py
+>>> def uspeh():
+>>>	"""Подтверждение успеха операции"""
+>>>	print('Выполнено успешно!')
+>>> uspeh()
+Выполнено успешно!
+```
+Определим класс объекта:
+```py
+>>> type(uspeh)
+<class 'function'>
+```
+Класс - функция. Убедимся, что имя функции появилось в пространстве имен:
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'uspeh']
+```
+Введём функцию:
+```py
+>>> help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+Функция help вернула описание, которое мы написали в комментарии по назначению функции.
+### 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
+```
+Проверим, можно ли эту функцию выполнить с аргументами - символьными строками.
+```py
+>>> sravnenie('abc','abcde')
+abc  меньше  abcde
+```
+### 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), (5, 6), (7, -8)) #Сложение кортежей
+(1, 2, 3, 4, 5, 6, 7, 8)
+>>> slozh({1,2,3}, {"Oleg", "Horoshaya", "Rabota"}, {True, False}, {16}) #Сложение множеств
+Traceback (most recent call last):
+  File "<pyshell#17>", line 1, in <module>
+    slozh({1,2,3}, {"Oleg", "Horoshaya", "Rabota"}, {True, False}, {16})
+  File "<pyshell#16>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+Невозможно выполнить данную функцию для сложения множеств. Для объединения множеств применияется операция union.
+```py
+>>> dict1 = {'a': 1}; dict2 = {'b': 2}; dict3 = {'c': 3}; dict4 = {'d': 4} #Сложение словарей
+>>> slozh(dict1, dict2, dict3, dict4)
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    slozh(dict1, dict2, dict3, dict4)
+  File "<pyshell#16>", 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)
+
+>>> import pylab as plt
+>>> plt.plot(spsy, label="Выходной сигнал")
+[<matplotlib.lines.Line2D object at 0x000002F63915A440>]
+plt.show()
+```
+Представим выходной сигнал в виде графика:
+![График выходных значений](figure0.png)
+## 3. Функции как объекты.
+### 3.1. Получение списка атрибутов объекта-функции.
+```py
+>>> dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
+>>> inerz.__doc__
+' Модель устройства с памятью:\nx- текущее значение вх.сигнала,\n\tT -постоянная времени,\n\typred - предыдущее значение выхода устройства'
+>>> help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+            T -постоянная времени,
+            ypred - предыдущее значение выхода устройства
+```
+### 3.2. Сохранение ссылки на объект-функцию в другой переменной.
+```py
+>>> fnkt = sravnenie
+>>> v = 16
+>>> fnkt(v, 23)
+16  меньше  23
+```
+Выполнена операция функции sravnenie, т.к. ссылка на функцию была сохранена в переменной fnkt.
+
+### 3.3. Возможность альтернативного определения функции в программе.
+```py
+>>> typ_fun = 8
+>>> if typ_fun == 1:
+>>>	def func():
+>>>		print("Функция 1")
+>>> else:
+>>>	def func():
+>>>		print('Функция 2')
+
+>>> func()
+Функция 2
+```
+Результат обусловлен тем, что typ_fun не равен единице.
+
+## 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)
+>>> print(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)  #Вычисление с заданным значением b
+1.3363755443363323
+```
+### 4.3. Обращение к функции с произвольным расположением аргументов.
+```py
+>>> logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+```
+### 4.4. Пример со значениями аргументов функции, содержащимися в списке или кортеже.
+```py
+>>> b1234 = [b1, b2, b3, b4]
+>>> qq = slozh(*b1234)
+>>> print(qq)
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+### 4.5. Пример со значениями аргументов функции, содержащимися в словаре
+```py
+>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+>>> qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+>>> print(qqq)
+10
+```
+### 4.6. Смешанные ссылки
+```py
+>>> e1 = (-1, 6); dd2 = {'a3': 3, 'a4': 9}
+>>> qqqq = slozh(*e1,**dd2)
+>>> print(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
+```
+Подобным же образом в списке аргументов функции также можно использовать словарь:
+```py
+>>> def func4(a,b=7,**slov7):
+>>>	smm=0
+>>>	for key, value in slov7.items():
+>>>		smm+=value
+>>>	return a*smm+b
+
+>>> func4(-1,2,x=0,y=3,z=6)
+-7
+```
+### 4.9. Изменение значений объектов, используемых в качестве аргументов функции.
+```py
+>>> a=90 # Числовой объект – не изменяемый тип
+>>> def func3(b):
+>>> 	b = 5*b+67
+	
+>>> func3(a)
+>>> print(a)
+90
+```
+Значение a не изменилось, т.к. все изменения произошли локально внутри функции.
+Пример со списком:
+```py
+>>> sps1=[1,2,3,4] #Список – изменяемый тип объекта
+>>> def func2(sps):
+>>>	sps[1] = 99
+	
+>>> func2(sps1)
+>>> print(sps1)
+[1, 99, 3, 4]
+```
+Список sps1 изменился.
+Попробуем применить эту функцию к кортежу.
+```py
+>>> kort = (1,2,3,4) #Кортеж – неизменяемый тип объекта
+>>> func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#75>", 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#94>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+После выдачи значения 7 генератор завершил работу, при попытке получить следующее значение возникла ошибка StopIteration - как раз для завершенных итераторов.
+## 6. Локализация объектов в функциях.
+
+Все объекты - переменные, коллекции, функции и т.д. - могут быть определены глобально или локально.
+Глобально - значит вне всяких функций.Локальные переменные определены внутри функции, и если хочется
+использовать такую переменную в другой функции, то нужно обрабатывать доступ к ним из других функций.
+
+### 6.1. Примеры на локализацию объектов
+Пример 1. Одноименные локальный и глобальный объекты.
+```py
+>>> glb=10
+>>> def func7(arg):
+>>>	loc1=15
+>>>	glb=8
+>>>	return loc1*arg
+
+>>> res=func7(glb)
+>>> print(res,glb)
+150 10
+```
+При получении результата использовалось глобальное значение glb и локальное loc1. Также видим, что glb не изменилось после выполнения функции.
+Пример 2. Ошибка в использовании локального объекта.
+```py
+>>> def func8(arg):
+>>>	loc1=15
+>>>	print(glb)  
+>>>	glb=8
+>>>	return loc1*arg
+
+>>> res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#100>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#99>", line 3, in func8
+    print(glb)
+UnboundLocalError: local variable 'glb' referenced before assignment
+```
+Внутри функции glb считается локальной переменной, и обращение к ней происходит до того, как её объявили. Вследствие чего и возникла такая ошибка.
+Пример 3. Переопределение локализации объекта.
+```py
+>>> glb=11
+>>> def func7(arg):
+>>>	loc1=15
+>>>	global glb
+>>>	print(glb)
+>>>	glb=8
+>>>	return loc1*arg
+
+>>> res=func7(glb)
+11
+>>> print(glb)
+8
+```
+Значение glb изменилось после завершения работы функции, так как ключевое слово global позволяет функции изменять глобальную переменную, а не создавать локальную с тем же именем.
+### 6.2. Выявление локализации объекта с помощью функций locals() и globals(). 
+Примеры
+```py
+>>> globals().keys() #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+>>> locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+Различий нет, потому что эти функции вызваны в основном рабочем пространстве, а не внутри какой либо функции или файле с программой.
+```py
+>>> def func8(arg):
+>>>	loc1=15
+>>>	glb=8
+>>>	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+>>>	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+>>>	return loc1*arg
+
+>>> hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+```
+Полученные списки: первый - глобальные переменные, второй - локальные переменные данной функции.
+```py
+>>> '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__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', '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__', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'sravnenie', 'fnkt', 'v', 'typ_fun', 'func', 'logistfun', 'fun_arg', 'zz', 'b1', 'b2', 'b3', 'b4', 'b1234', 'slozh', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'kort', 'func2', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+
+glob_func9_1 и glob_func9: #перечень глобальных переменных.
+locl_func9_1: #перечень локальных переменных вложенной функции func9_1
+loc_func9: #перечень локальных переменных функции func9
+```
+### 6.4. Моделирование САУ
+```py
+>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=9,8,7,10,5,0.5,100
+>>> 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])
+>>> vhod=[]
+>>> for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+>>> vhod
+[0.0, -2.4492935982947065e-15, -4.898587196589413e-15, -7.347880794884118e-15, -9.797174393178826e-15, -1.2246467991473532e-14, -1.4695761589768237e-14, -1.7145055188062946e-14, -1.9594348786357652e-14, -2.2043642384652358e-14, -2.4492935982947064e-14, -9.799650315725178e-14, -2.9391523179536473e-14, 3.921345679817883e-14, -3.429011037612589e-14, -1.0779367755043061e-13, -3.9188697572715304e-14, 2.941628240500001e-14, -4.4087284769304716e-14, -1.1759085194360943e-13, -4.898587196589413e-14, 1.9619108011821187e-14, -1.9599300631450355e-13, -1.2738802633678826e-13, -5.878304635907295e-14, 9.82193361864236e-15, 7.842691359635766e-14, -1.371852007299671e-13, -6.858022075225178e-14, 2.475922546353431e-17, -2.1558735510086123e-13, -1.469823751231459e-13, -7.837739514543061e-14, -9.772415167715291e-15, 5.883256481000002e-14, -1.5677954951632475e-13, -8.817456953860943e-14, -1.9569589560894117e-14, -2.3518170388721885e-13, -1.6657672390950356e-13, -9.797174393178826e-14, -3.13583858258113e-13, 3.9238216023642374e-14, -1.763738983026824e-13, -3.919860126290071e-13, -3.9163938347251766e-14, -2.547760526735765e-13, 9.804602160817887e-14, -1.175660927181459e-13, -3.331782070444707e-13, 1.964386723728472e-14, -1.9596824708904002e-13, 1.5685382719271532e-13, -5.875828713360942e-14, -2.743704014599342e-13, 7.84516728218212e-14, -1.3716044150450357e-13, -3.5277255583082833e-13, 4.951845092706862e-17, -2.155625958753977e-13, -4.3117471020172245e-13, -7.835263591996706e-14, -2.939647502462918e-13, 5.885732403546355e-14, -1.5675479029086122e-13, -3.7236690461718595e-13, -1.9544830335430582e-14, -2.351569446617553e-13, 1.1766512962000005e-13, -9.794698470632473e-14, -3.135590990326495e-13, 3.92629752491059e-14, -1.7634913907721887e-13, -3.919612534035436e-13, -3.9139179121788235e-14, -2.54751293448113e-13, -4.703634077744377e-13, -1.1754133349268239e-13, -3.331534478190071e-13, 1.9668626462748253e-14, -1.9594348786357651e-13, -4.1155560218990125e-13, -6.27167716516226e-13, 2.9408854637360953e-13, 7.847643204728475e-14, -1.3713568227904e-13, -3.527477966053648e-13, -5.683599109316896e-13, -7.839720252580142e-13, 1.3728423763182123e-13, -7.832787669450353e-14, -2.939399910208283e-13, -5.09552105347153e-13, -7.251642196734778e-13, 1.9609204321635773e-13, -1.9520071109967048e-14, -2.351321854362918e-13, -4.5074429976261655e-13, -6.663564140889414e-13, 2.548998488008942e-13]
+
+>>> 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
+
+>>> 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, -11.221682976576965, 56.517593465421044, -198.4938430808908, 643.506543727202, -2038.3616992400925, 6410.418726006248, -20114.26644793458, 63067.832981055835, -197702.20103251687, 619702.3868992503, -1942426.7361789877, 6088395.773097905, -19083589.56721709, 59815939.53001698, -187488089.6939353, 587665784.8763827, -1841989359.093071, 5773561877.442508, -18096747684.33722, 56722744717.96331, -177792707487.408, 557276397506.7018, -1746736340307.673, 5474999221529.676, -17160927945422.51, 53789495857764.4, -168598683814381.4, 528458497902730.1, -1656409040019924.2, 5191875840294872.0, -1.6273501345243368e+16, 5.1007931271830376e+16, -1.5988010185603117e+17, 5.011308306794939e+17, -1.5707527487295396e+18, 4.923393346795263e+18, -1.5431965385305592e+19, 4.837020706628768e+19, -1.5161237556062686e+20, 4.75216332889284e+20, -1.4895259190397258e+21, 4.6687946308614147e+21, -1.4633946966973882e+22, 4.58688849615756e+22, -1.4377219026189537e+23, 4.5064192665721635e+23, -1.4124994944530019e+24, 4.4273617340261656e+24, -1.3877195709376152e+25, 4.349691132673771e+25, -1.3633743694252021e+26, 4.273383131144217e+26, -1.339456263450744e+27, 4.198413824919648e+27, -1.3159577603427e+28, 4.124759728846688e+28, -1.292871498875825e+29, 4.052397769779404e+29, -1.270190246965166e+30, 3.981305279351331e+30, -1.2479068994005175e+31, 3.911459986874298e+31, -1.2260144756206116e+32, 3.8428400123618285e+32, -1.2045061175263658e+33, 3.7754238596749417e+33, -1.1833750873324914e+34]
+```
+## 7. Завершил сеанс работы с IDLE.

TEMA7/task.md

@@ -0,0 +1,67 @@
+# Общее контрольное задание по теме 7
+Киреев Юрий, А-02-23
+## Задание
+1) Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т.
+2) Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в ви-де таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращае-мый результат функции: список с числами элементов выборки в интервалах разбиения.
+3) Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+Y=b1+b2*X
+и имеющую аргументы b1, b2 и X.
+## Решение
+1)
+```py
+>>> def delay(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 = [0,1,2,3,4,5,6,7,8,9]
+>>> y=delay(x,5)
+>>> y
+[0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+2)
+```py
+>>> def histogram(data, intervals):
+>>>     low_g = min(data)
+>>>     high_g = max(data)
+>>>     bin_width = (high_g - low_g) / intervals
+>>>     hist = [0] * intervals
+>>>     for i in data:
+>>>         bin_index = int((i - low_g) / bin_width)
+>>>         if bin_index == intervals:
+>>>             bin_index = intervals - 1
+>>>         hist[bin_index] += 1
+>>>     for i in range(intervals):
+>>>         min_gran = low_g + i * bin_width
+>>>         max_gran = low_g + (i + 1) * bin_width
+>>>         print(f"{min_gran:.1f} - {max_gran:.1f}\t\t{hist[i]}")
+>>>     print("Возвращаемый список: ")
+>>>     return hist
+
+>>> data = list(range(1,8))
+>>> histogram(data,4)
+1.0 - 2.5		2
+2.5 - 4.0		1
+4.0 - 5.5		2
+5.5 - 7.0		2
+Возвращаемый список: 
+[2, 1, 2, 2]
+
+>>> data = list(range(1,9))
+>>> histogram(data,3)
+1.0 - 3.3		3
+3.3 - 5.7		2
+5.7 - 8.0		3
+Возвращаемый список: 
+[3, 2, 3]
+```
+3)
+```py
+>>> linreg = lambda b1, b2, x: b1 + b2 * x
+>>> linreg(1, 1, 10)
+11
+```

TEMA7/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по теме 7
+Киреев Юрий А-02-23
+## Задание
+Разработайте анонимную функцию с 3 аргументами: х, a, b, вычисляющую значение exp((-(x-a)^2)/b)/(2*π*b)^1/2. Рассчитайте значения функции в диапазоне значений х от a-3*b^1/2 до a+3*b^1/2 с шагом 0.2*b^1/2 и запишите эти значения в текстовый файл по два значения на строке, разделенных запятыми.
+## Решение
+```py
+>>> import math
+>>> import os
+>>> os.chdir('C:\\Users\\u522-13\\Desktop\\поас')
+>>> raschet = lambda x, a, b: math.exp(-(x - a)**2 / b) / math.sqrt(2 * math.pi * b)
+>>> a=0 # значения a и b можно поменять, можно добавить ввод с клавиатуры
+>>> b=1
+>>> start = a - 3 * math.sqrt(b)
+>>> end = a + 3 * math.sqrt(b)
+>>> step = 0.2 * math.sqrt(b)
+>>> values = []
+>>> x = start
+>>> while x <= end:
+>>>     values.append(raschet(x,a,b))
+>>>     x += step
+>>> print(values)
+[4.9233388666234e-05, 0.0001570512248023814, 0.00046246553014536756, 0.0012571116468828324, 0.0031544581746000837, 0.007306882745280797, 0.015624133620192436, 0.03084012943829092, 0.05619437965598666, 0.09452050033904612, 0.14676266317374007, 0.21035924208613316, 0.2783325845048708, 0.33995618640009767, 0.3832995298410415, 0.3989422804014327, 0.3832995298410414, 0.33995618640009745, 0.27833258450487053, 0.21035924208613285, 0.1467626631737398, 0.09452050033904591, 0.056194379655986504, 0.030840129438290835, 0.01562413362019238, 0.007306882745280764, 0.0031544581746000672, 0.0012571116468828236, 0.0004624655301453643, 0.00015705122480238025]
+>>> with open ('12.txt','w') as fp:
+>>>     for i in range (0, len(values), 2):
+>>>         stroka = str(values[i])+","+str(values[i+1])+"\n"
+>>>         fp.write(stroka)
+```

TEMA8/MM0.py

@@ -0,0 +1,2 @@
+import MM2
+print('y=',MM2.vyhod)

TEMA8/MM1.py

@@ -0,0 +1,22 @@
+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

TEMA8/MM2.py

@@ -0,0 +1,23 @@
+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)

TEMA8/Mod2.py

@@ -1,7 +1,7 @@
 def alpha():
-    print('****ALPHA****')
-    t=input('Значение t=')
-    return t
+   print("****ALPHA****")
+   t = input("Значение t = ")
+   return t
 
 def beta(q):
     print('****BETA****')

TEMA8/file1.txt

@@ -0,0 +1,2 @@
+1 2 3 4 5
+6 7 8 9 10

TEMA8/file2.txt

@@ -0,0 +1,2 @@
+1.1 2.2 3.3 4.4 5.5
+6.6 7.7 8.8 9.9 11.0

TEMA8/file3.txt

@@ -0,0 +1,2 @@
+10 8 6 4 2
+0 -2 -4 -6 -8

TEMA8/file4.txt

@@ -0,0 +1,2 @@
+5 6 1 34 43
+-3 -2 99 9.2 1

TEMA8/mod1okz.py

@@ -0,0 +1,9 @@
+def read_numbers_from_file(filename):
+    """Модуль 1: Чтение числового списка из файла"""
+    numbers = []
+    with open(filename, 'r') as fp:
+        for line in fp:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    return numbers

TEMA8/mod2okz.py

@@ -0,0 +1,22 @@
+def calculate_correlation(list1, list2):
+    """Модуль 2: Вычисляет коэффициент корреляции для двух списков"""
+    # Если списки разной длины, используем минимальную длину
+    n = min(len(list1), len(list2))
+    
+    # Берем только первые n элементов из каждого списка
+    x = list1[:n]
+    y = list2[:n]
+    mean_x = sum(x)/n
+    mean_y = sum(y)/n
+    chisl = 0
+    sum1 = 0
+    sum2 = 0
+    for i in range(n):
+        chisl += (x[i] - mean_x) * (y[i] - mean_y)
+        sum1 += (x[i] - mean_x) ** 2
+        sum2 += (y[i] - mean_y) ** 2
+    znam = (sum1 * sum2) ** 0.5  
+    if znam == 0:
+        return ('Ошибка, деление на ноль')
+    correlation = chisl / znam
+    return correlation

TEMA8/mod3okz.py

@@ -0,0 +1,12 @@
+import mod2okz, mod1okz, os
+file1 = os.path.abspath(input("Введите имя первого файла: "))
+file2 = os.path.abspath(input("Введите имя второго файла: "))
+def read_float_list(filename):
+    nums = []
+    with open(filename, 'r') as f:
+        for line in f:
+            nums.extend([float(x) for x in line.split()])
+    return nums
+list1, list2 = read_float_list(file1), read_float_list(file2)
+result = mod2okz.calculate_correlation(list1, list2)
+print(f"{result:.3f}")

TEMA8/report.md

@@ -0,0 +1,373 @@
+# Отчёт по теме 8
+Киреев Юрий А-02-23
+## 1. Запуск оболочки IDLE
+```py
+>>> import os,sys,importlib
+>>> os.chdir("C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8")
+>>> os.getcwd()
+'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8'
+```
+## 2. Создание и использование модулей
+### 2.1 Запуск модуля на выполнение путем его импорта
+С помощью текстового редактора оболочки IDLE создал в своем текущем каталоге  файл с именем Mod1.py и записал в него программу со следующим содержанием:
+```py
+>>> perm1=input('Mod1:Введите значение = ')
+>>> print('Mod1:Значение perm1=',perm1)
+```
+Запустим модуль из командной строки оболочки IDLE:
+```py
+>>> import Mod1
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+>>> type(Mod1)
+<class 'module'>
+>>> dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+>>> Mod1.perm1 #получили доступ к значению созданного в модуле объекта
+'8'
+```
+Попробуем повторно выполнить модуль с помощью инструкции импорта:
+```
+>>> import Mod1 #ничего не проиходит
+>>> importlib.reload(Mod1) #импорт модуля с помощью функции reload
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+>>> Mod1.perm1
+'3'
+```
+### 2.2. Проверка модулей в словарях
+Импортированные модули заносятся в словарь – значение атрибута sys.modules. Их можно увидеть по инструкции:
+```py
+>>> print(sorted(sys.modules.keys()))
+['Mod1', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_distutils_hack', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_locale', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha512', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_thread', '_tkinter', '_warnings', '_weakref', '_weakrefset', '_winapi', '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', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'msvcrt', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'signal', 'site', 'socket', 'socketserver', 'sre_compile', 'sre_constants', 'sre_parse', 'stat', 'string', 'struct', 'subprocess', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+Для обеспечения возможности повторного импорта и, следовательно, выполнения программы из модуля, его надо удалить из этого словаря:
+```py
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+```
+Еще раз отобразим словарь, убедитесь, что модуль Mod1 из него исчез:
+```py
+>>> print(sorted(sys.modules.keys()))
+['__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_compat_pickle', '_compression', '_datetime', '_distutils_hack', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_locale', '_lzma', '_opcode', '_operator', '_pickle', '_queue', '_random', '_sha512', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_thread', '_tkinter', '_warnings', '_weakref', '_weakrefset', '_winapi', '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', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'msvcrt', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'signal', 'site', 'socket', 'socketserver', 'sre_compile', 'sre_constants', 'sre_parse', 'stat', 'string', 'struct', 'subprocess', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+>>> import Mod1
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4
+>>> sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+```
+### 2.3. Запуск модуля на выполнение с помощью функции exec()
+Пример
+```py
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+```
+При использовании import Python по умолчанию считает, что файл имеет кодировку UTF-8, а также учитывает псевдокомментарии. При использовании open() Python считает, что у файла «системная» кодировка, которая в Linux обычно UTF-8, а в Windows — UTF-16. Передадим open() доп. аргумент.
+```py
+>>> exec(open("Mod1.py", encoding = "utf-8").read())
+Mod1:Введите значение = 7
+Mod1:Значение perm1= 7
+>>> Mod1.perm1
+`4`
+perm1
+'7'
+>>> exec(open("Mod1.py", encoding = "utf-8").read())
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+>>> Mod1.perm1
+'4'
+perm1
+'8'
+>>> exec(open("Mod1.py", encoding = "utf-8").read())
+Mod1:Введите значение = 4674
+Mod1:Значение perm1= 4674
+>>> Mod1.perm1
+'4'
+perm1
+'4674'
+```
+### 2.4. Использование инструкции from … import …
+В одном модуле может содержаться несколько программных единиц (например, функций или пользовательских объектов). Тогда можно осуществлять импорт модуля не целиком, а только часть содержащихся в нем объектов.
+Пример 1.
+```py
+>>> from Mod1 import perm1
+Mod1:Введите значение = 666
+Mod1:Значение perm1= 666
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'importlib', 'os', 'perm1', 'sys'] #модуль Mod1 не появился в памяти
+>>> perm1
+'666'
+```
+Пример 2.
+С помощью текстового редактора создал еще один модуль Mod2, содержащий две функции.
+```py
+>>> def alpha():
+>>>     print('****ALPHA****')
+>>>     t=input('Значение t=')
+>>>     return t
+
+>>> def beta(q):
+>>>     print('****BETA****')
+>>>     import math
+>>>     expi=q*math.pi
+>>>     return math.exp(expi) 
+```
+Импортируем из этого модуля только функцию beta:
+```py
+>>> from Mod2 import beta
+>>> g=beta(2)
+****BETA****
+>>> g
+535.4916555247646
+>>> dir()
+['Mod1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '__warningregistry__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+>>> alpha() #функция alpha не была импортирована
+Traceback (most recent call last):
+  File "<pyshell#51>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+```
+Теперь импортируем функцию alpha из Mod2:
+```py
+>>> from Mod2 import alpha as al
+>>> al()
+****ALPHA****
+Значение t=1
+'1'
+>>> del al,beta
+```
+Повторим импорт двух функций одной инструкцией:
+```py
+>>> from Mod2 import alpha as al, beta as bt
+>>> del al, bt
+>>> from Mod2 import *
+>>> tt=alpha()  #На запрос введите значение 0.12
+****ALPHA****
+Значение t=0.12
+>>> uu=beta(float(tt))
+****BETA****
+>>> uu
+1.4578913609506803
+```
+## 3. Создание многомодульных программ.
+### 3.1. Пример простой многомодульной программы.
+С помощью редактора создадим ещё один модуль:
+```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)
+```
+Теперь наша программа будет состоять из 5 частей: главная программа, которой является команд-ная строка IDLE и из которой будет вызываться модуль Mod0, и 3 модуля, вызываемых из модуля Mod0. Проверим нашу программу:
+```py
+>>> sys.modules.pop("Mod1")
+<module 'Mod1' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod1.py'>
+>>> sys.modules.pop("Mod2")
+<module 'Mod2' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod2.py'>
+>>> import Mod0
+Mod1:Введите значение = 55
+Mod1:Значение perm1= 55
+perm1= 55
+****ALPHA****
+Значение t=52
+tt= 52
+****BETA****
+qq= 8.862788791286627e+70
+>>> Mod0.tt;Mod0.qq;Mod0.Mod1.perm1
+'52'
+8.862788791286627e+70
+'55'
+```
+### 3.2. Еще пример создания многомодульной программы
+Создадим модуль MM1, включив в него разработанные при выполнении предыдущей темы функции, реализующие усилитель, реальный двигатель, тахогенератор и нелинейное звено типа «зона нечувствительности».
+Затем создадим модуль ММ2, включив в него инструкции, обеспечивающие ввод параметров задачи, формирование входного сигнала, импорт модуля ММ1 и реализацию модели при расчете выходного сигнала:
+MM1:
+```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
+
+```
+MM2
+```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)
+
+```
+Наконец, создадим главную программу – модуль ММ0, запускающую на выполнение модуль ММ2 и выводящую полученный выходной сигнал:
+```py
+import MM2
+print('y=',MM2.vyhod)
+```
+Пример работы этой программы:
+```py
+>>> import MM0
+k1,T,k2,Xm,A,F,N=10,5,2,2,2,40,20
+>>> y= [0, 0, 0, 0, 0, 0.9866886115016662, -1.9732935348876697, -3.091965522675575, 13.830506004312246, 0.4743498602389664, -45.654123345832254, 28.379844851189542, 111.82759196582377, -175.83865168130015, -187.57768045826674, 661.5418706401588, 23.17293107123487, -1938.4588367997728, 1453.5699160588447, 4465.240774231551]
+```
+### 3.3. Области действия объектов в модулях.
+Попробуем вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+```py
+>>> def alpha():
+>>>    print("****ALPHA****")
+>>>    print("Вызов функции beta:", beta(5))
+>>>    t = input("Значение t = ")
+>>>    return t
+
+>>> import Mod2
+>>> Mod2.alpha()
+****ALPHA****
+****BETA****
+Вызов функции beta: 6635623.99934113
+Значение t = 6
+'6'
+```
+Теперь из beta - к alpha:
+```py
+>>> def beta(q):
+>>>     print('****BETA****')
+>>>     import math
+>>>     expi=q*math.pi
+>>>     print('обращение к alpha:', alpha())
+>>>     return math.exp(expi)
+
+>>> importlib.reload(Mod2)
+<module 'Mod2' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\Mod2.py'>
+>>> Mod2.beta(52)
+****BETA****
+****ALPHA****
+Значение t = 16
+обращение к alpha: 16
+8.862788791286627e+70
+```
+Попробуем отобразить на экране в модуле Mod0 значения объектов t и expi:
+```py
+#Модуль Mod0
+>>> import Mod1
+>>> print('perm1=',Mod1.perm1)
+>>> from Mod2 import alpha as al
+>>> tt=al()
+>>> print
+>>> print('tt=',tt)
+>>> from Mod2 import beta
+>>> qq=beta(float(tt))
+>>> print('qq=',qq)
+>>> print("t =", t)
+>>> print("expi =", expi)
+
+>>> import Mod0
+Mod1:Введите значение = 16
+Mod1:Значение perm1= 16
+perm1= 16
+****ALPHA****
+Значение t = 52
+tt= 52
+****BETA****
+qq= 8.862788791286627e+70
+Traceback (most recent call last):
+  File "<pyshell#31>", line 1, in <module>
+    import Mod0
+  File "C:\Users\user\Desktop\ПОАС\python-labs\TEMA8\Mod0.py", line 11, in <module>
+    print("t =", t)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+Т.к. переменные определены в другом модуле, доступа напрямую к ним нет.
+Попробуем в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+```py
+#Модуль Mod0
+>>> import Mod1
+>>> print('perm1=',Mod1.perm1)
+>>> Mod1.perm1 = str(int(Mod1.perm1) * 3) #изменение переменной Mod1.perm1
+>>> print ('обновленная переменная:', Mod1.perm1)
+>>> from Mod2 import alpha as al
+>>> tt=al()
+>>> print('tt=',tt)
+>>> from Mod2 import beta
+>>> qq=beta(float(tt))
+>>> print('qq=',qq)
+
+>>> import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+обновленная переменная: 30
+****ALPHA****
+Значение t = 52
+tt= 52
+****BETA****
+qq= 8.862788791286627e+70
+```
+Попробуем в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
+```py
+>>> import Mod0
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+perm1= 10
+****ALPHA****
+Значение t = 5
+tt= 5
+****BETA****
+qq= 6635623.99934113
+
+>>> import Mod1
+>>> Mod1.perm1 = str(int(Mod1.perm1) * 2) #увеличили Mod1.perm1 в 2 раза
+>>> print(Mod1.perm1)
+20
+
+>>> Mod0.tt = float(Mod0.tt) * 2
+>>> print(Mod0.tt)
+10.0
+
+>>> Mod0.qq = Mod0.qq * 2
+>>> print(Mod0.qq)
+13271247.99868226
+```
+Если обращаться к переменным напрямую, без указания модуля, в котором они определены - будет ошибка.
+## 4. Закончил сеанс работы с IDLE

TEMA8/task.md

@@ -0,0 +1,101 @@
+# Общее контрольное задание по теме 8
+Киреев Юрий А-02-23
+## Задание
+Разработайте программу, состоящую из трех модулей:
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+## Решение
+Модуль 1:
+```py
+def read_numbers_from_file(filename):
+    """Модуль 1: Чтение числового списка из файла"""
+    numbers = []
+    with open(filename, 'r') as fp:
+        for line in fp:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    return numbers
+```
+Модуль 2:
+```py
+def calculate_correlation(list1, list2):
+    """Модуль 2: Вычисляет коэффициент корреляции для двух списков"""
+    # Если списки разной длины, используем минимальную длину
+    n = min(len(list1), len(list2))
+    
+    # Берем только первые n элементов из каждого списка
+    x = list1[:n]
+    y = list2[:n]
+    mean_x = sum(x)/n
+    mean_y = sum(y)/n
+    chisl = 0
+    sum1 = 0
+    sum2 = 0
+    for i in range(n):
+        chisl += (x[i] - mean_x) * (y[i] - mean_y)
+        sum1 += (x[i] - mean_x) ** 2
+        sum2 += (y[i] - mean_y) ** 2
+    znam = (sum1 * sum2) ** 0.5  
+    if znam == 0:
+        return ('Ошибка, деление на ноль')
+    correlation = chisl / znam
+    return correlation
+```
+Модуль 3:
+```py
+import mod2okz, mod1okz, os
+file1 = os.path.abspath(input("Введите имя первого файла: "))
+file2 = os.path.abspath(input("Введите имя второго файла: "))
+def read_float_list(filename):
+    nums = []
+    with open(filename, 'r') as f:
+        for line in f:
+            nums.extend([float(x) for x in line.split()])
+    return nums
+list1, list2 = read_float_list(file1), read_float_list(file2)
+result = mod2okz.calculate_correlation(list1, list2)
+print(f"{result:.3f}")
+```
+Файлы для проверки:
+```py
+#file1
+1 2 3 4 5
+6 7 8 9 10
+
+#file2
+1.1 2.2 3.3 4.4 5.5
+6.6 7.7 8.8 9.9 11.0
+
+#file3
+10 8 6 4 2
+0 -2 -4 -6 -8
+
+#file4
+5 6 1 34 43
+-3 -2 99 9.2 1
+```
+
+Проверим результаты:
+```py
+>>> import mod3okz
+Введите имя первого файла: file1.txt
+Введите имя второго файла: file2.txt
+0.999
+
+>>> sys.modules.pop("mod3okz")
+<module 'mod3okz' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\mod3okz.py'>
+>>> import mod3okz
+Введите имя первого файла: file1.txt
+Введите имя второго файла: file3.txt
+-0.976
+
+>>> sys.modules.pop("mod3okz")
+<module 'mod3okz' from 'C:\\Users\\user\\Desktop\\ПОАС\\python-labs\\TEMA8\\mod3okz.py'>
+>>> import mod3okz
+Введите имя первого файла: file1.txt
+Введите имя второго файла: file4.txt
+0.185
+```

TEMA8/test.md

@@ -0,0 +1,37 @@
+# Индивидуальное контрольное задание по теме 8
+Киреев Юрий А-02-23
+## Задание
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+2 вариант 7й темы
+Разработайте функцию с 4 аргументами, создающую последовательность отсчетов случайного, нормально распределенного сигнала типа белого шума с заданными параметрами: математическое ожидание и дисперсия, число отсчетов (аргументы функции). Сигнал должен быть записан построчно, по 3 элемента в строке с разделителем - пробел в текстовый файл с заданным именем (4-й аргумент функции), а также возвращен в вызывающую программу в виде списка.
+## Решение
+Модуль с функцией (modfun):
+```py
+import random
+def generate_noise(mean, variance, otscheti, filename):
+    sto = variance**(1/2)
+    signal=[random.gauss(mean, sto) for x in range(otscheti)] 
+    with open(filename, 'w') as fp: 
+        for i in range(0,otscheti,3):
+            line=" ".join(str(value) for value in signal[i:i+3])
+            fp.write(line+"\n")
+    return signal
+```
+Модуль с инструкциями ввода/вывода (zapusk):
+```py
+from modfun import generate_noise
+noise = generate_noise(0, 1, 5, "test.txt") 
+print(noise)
+```
+Проверка:
+```py
+import os
+os.chdir('C:\\Users\\u522-13\\Desktop\\ПОАС')
+import zapusk
+[-0.698871305720859, -0.7706401494821621, 0.8869359612629606, -1.7573739796230814, 0.22414109065695026]
+```
+Вывод в файле:
+```py
+-0.698871305720859 -0.7706401494821621 0.8869359612629606
+-1.7573739796230814 0.22414109065695026
+```

TEMA9/Mod3.py

@@ -0,0 +1,12 @@
+class Class1:               #Объявление класса Class1 в модуле
+    def zad_zn(self,znach): # 1 Метод класса
+        self.data=znach # self - ссылка на экземпляр класса Class1
+    def otobrazh(self):     # 2 Метод класса
+        print(self.data)#Отображение данных экземпляра
+
+class Class2(Class1):  #Class2 - наследник класса Class1
+    def otobrazh(self):     # Метод  класса Class2
+        print('значение=',self.data)#Отображение данных экземпляра
+	
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)

TEMA9/OKZ.py

@@ -0,0 +1,24 @@
+class SOTRUDNIKI:
+    def __init__ (self, fio="", otdel="", dolzhnost="", oklad=1):
+        self.fio=fio
+        self.otdel=otdel
+        self.dolzhnost=dolzhnost
+        self.oklad=oklad
+        self.__reward=[]
+    def oklad_increase (self, znach):
+        self.oklad += znach
+    def perevod (self, new_otdel):
+        self.otdel = new_otdel
+    def dolzhnost_change(self, new_dolzhnost):
+        self.dolzhnost = new_dolzhnost
+    def get_reward(self):
+        return list(self.__reward)
+    def set_reward(self,reward):
+        self.__reward.append(reward)
+    def __str__(self):
+        return (f"Сотрудник: {self.fio}\n"
+                f"Отдел: {self.otdel}\n"
+                f"Должность: {self.dolzhnost}\n"
+                f"Оклад: {self.oklad}\n"
+                f"Поощрения: {self.__reward}")
+    reward = property(get_reward, set_reward)

TEMA9/SAU.py

@@ -0,0 +1,21 @@
+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 otobraz(self):
+        print('y=',self.ypr[1])

TEMA9/report.md

@@ -0,0 +1,279 @@
+# Отчёт по теме 9
+Киреев Юрий А-02-23
+## 1. Запуск интеративной оболчки IDLE
+## 2. Создание классов и их наследников
+### 2.1. Создание автономного класса
+Создадим класс с именем Class1, содержащий 2 функции, реализующие его методы:
+```py
+>>> class Class1:               #Объявление класса
+>>>     def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+>>>         self.data=znach     # self - ссылка на экземпляр класса
+>>>     def otobrazh(self):     # Метод 2 класса1
+>>>         print(self.data)    #Отображение данных экземпляра класса
+```
+Создадим 2 экземпляра этого класса:
+```py
+>>> z1=Class1()   #Создаём 1-й экземпляр класса
+>>> z2=Class1()   #Создаём 2-й экземпляр класса
+
+>>> z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+>>> z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+
+>>> z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+>>> z2.otobrazh()
+-632.453
+
+>>> z1.data='Новое значение атрибута у экз.1'
+>>> z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+### 2.2. Создание класса-наследника
+В объявлении класса после его имени в скобках перечисляются его «родительские классы»
+```py
+>>> class Class2(Class1):  #Class2 - наследник класса Class1
+>>>     def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+>>>         print('значение=',self.data)#Отображение данных экземпляра
+
+>>> z3=Class2()
+>>> dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__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() #сработал метод второго класса
+значение= Совсем новое
+>>> z1.otobrazh() #значение не изменилось
+Новое значение атрибута у экз.1
+>>> del  z1,z2,z3
+```
+## 3. Использование классов, содержащихся в модулях
+Создал модуль с именем Mod3, в который запишисал следующее:
+```py
+class Class1:               #Объявление класса Class1 в модуле
+    def zad_zn(self,znach): # 1 Метод класса
+        self.data=znach # self - ссылка на экземпляр класса Class1
+    def otobrazh(self):     # 2 Метод класса
+        print(self.data)#Отображение данных экземпляра
+
+class Class2(Class1):  #Class2 - наследник класса Class1
+    def otobrazh(self):     # Метод  класса Class2
+	print('значение=',self.data)#Отображение данных экземпляра
+	
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+Импортировал первый класс из модуля с помощью обычной инструкции
+```py
+>>> from Mod3 import Class1 #Частичный импорт содержимого модуля
+>>> z4=Class1()
+>>> z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#28>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\user\Desktop\ПОАС\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data' #ошибка возникла, так как было совершено обращение к методу otobrazh() без инициализации data в методе zad_zn()
+```
+А теперь попробуем сделать так:
+```py
+>>> from Mod3 import Class1
+>>> z4=Class1()
+>>> z4.data='значение данного data у экз.4'
+>>> z4.otobrazh()
+значение данного data у экз.4
+>>> del z4
+```
+Импортируем модуль целиком:
+```py
+>>> import Mod3  #Полный импорт содержимого модуля
+>>> z4=Mod3.Class2()
+>>> z4.zad_zn('Класс из модуля')
+>>> z4.otobrazh() #обращение к методу класса
+значение= Класс из модуля
+>>> Mod3.otobrazh('Объект') #обращение к функции модуля
+значение объекта= Объект
+```
+## 4. Использование специальных методов
+Для примера создам класс, содержащий два специальных метода:
+```py
+>>> class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+>>>     def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+>>>         self.data=znach
+>>>     def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+>>>         return Class3(self.data+drug_zn)
+>>>     def zad_dr_zn(self,povtor):  #А это - обычный метод
+>>> 	    self.data*=povtor
+```
+Для иллюстрации работы этих методов создам экземпляр класса Class3 и отображу его:
+```py
+>>> z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+>>> z5.otobrazh()
+значение= abc
+
+>>> z6=z5+'def'
+>>> z6.otobrazh()
+значение= abcdef
+
+>>> z6.zad_dr_zn(3)
+>>> z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+## 5. Присоединение атрибутов к классу
+```py
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> Class3.fio='Иванов И.И.'
+>>> dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> z7=Class3(123)
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+>>> dir(z7)==dir(Class3)
+False
+>>> z7.rozden='1987'
+>>> dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+>>> dir(Class3) #атрибут rozden не появился
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+## 6. Выявление родительских классов
+Такое выявление делается с помощью специального атрибута __bases__, например, выведу родительский класс для созданного класса Class3 и Class2:
+```py
+>>> Class3.__bases__
+(<class '__main__.Class2'>,)
+>>> Class2.__bases__
+(<class '__main__.Class1'>,)
+>>> Class1.__bases__
+(<class 'object'>,)
+>>> 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__(sam,znach):
+>>>         sam.__prm=znach
+>>>     def chten(sam):
+>>>         return sam.__prm
+>>>     def zapis(sam,znch):
+>>>         sam.__prm=znch
+>>>     def stiran(sam):
+>>>         del sam.__prm
+>>>     svojstvo=property(chten,zapis,stiran)
+```
+Теперь попробуем некоторые операции с этим свойством
+```py
+>>> exempl=Class4(12)
+>>> exempl.svojstvo
+12
+>>> exempl.svojstvo=45
+>>> print(exempl.svojstvo)
+45
+>>> del exempl.svojstvo
+>>> exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#67>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#61>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm' # Вызывается метод chten, который пытается вернуть sam.__prm но __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 otobraz(self):
+        print('y=',self.ypr[1])
+```
+Тестирование класса произведите с помощью следующей программы:
+```py
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связ
+from SAU import *
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+
+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
+import pylab
+pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x0000016F4C9EB2B0>]
+pylab.show()
+```
+![Скриншот построенного графика](figure0.png)
+Запустим программу с другими параметрами:
+```py
+prm=[5,1,3,0.4]
+...
+y= 0.0
+y= 0.625
+y= 1.25
+y= 1.640625
+y= 1.796875
+y= 1.806640625
+y= 1.7578125
+y= 1.705322265625
+y= 1.671142578125
+y= 1.656646728515625
+y= 1.65496826171875
+y= 1.6587257385253906
+y= 1.6631126403808594
+y= 1.666090488433838
+y= 1.6674232482910156
+y= 1.6676393151283264
+y= 1.6673555970191956
+y= 1.6669908538460732
+y= 1.6667325049638748
+y= 1.6666109347715974
+y= 1.6665862454101443
+pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x0000016F4F649CF0>]
+pylab.show()
+```
+![Скриншот другого графика](figure1.png)
+## 9. Завершил сеанс работы со средой

TEMA9/task.md

@@ -0,0 +1,73 @@
+# Общее контрольное задание по теме 9
+Киреев Юрий А-02-23
+## Задание
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+- метод для изменения должности сотрудника;
+- свойство, содержащее перечень (список) поощрений сотрудника.
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+## Решение
+Модуль OKZ:
+```py
+class SOTRUDNIKI:
+    def __init__ (self, fio="", otdel="", dolzhnost="", oklad=1):
+        self.fio=fio
+        self.otdel=otdel
+        self.dolzhnost=dolzhnost
+        self.oklad=oklad
+        self.__reward=[]
+    def oklad_increase (self, znach):
+        self.oklad += znach
+    def perevod (self, new_otdel):
+        self.otdel = new_otdel
+    def dolzhnost_change(self, new_dolzhnost):
+        self.dolzhnost = new_dolzhnost
+    def get_reward(self):
+        return list(self.__reward)
+    def set_reward(self,reward):
+        self.__reward.append(reward)
+    def __str__(self):
+        return (f"Сотрудник: {self.fio}\n"
+                f"Отдел: {self.otdel}\n"
+                f"Должность: {self.dolzhnost}\n"
+                f"Оклад: {self.oklad}\n"
+                f"Поощрения: {self.__reward}")
+    reward = property(get_reward, set_reward)
+```
+Проверка модуля:
+```py
+>>> import OKZ
+>>> emp1 = OKZ.SOTRUDNIKI("Киреев Ю.П", "CЭО Сила тока", "Командир", -1000)
+>>> emp2 = OKZ.SOTRUDNIKI("Калякин П.А", "СЭО Сила тока", "Комиссар", 0)
+>>> print(emp1)
+Сотрудник: Киреев Ю.П
+Отдел: CЭО Сила тока
+Должность: Командир
+Оклад: -1000
+Поощрения: []
+>>> print(emp2)
+Сотрудник: Калякин П.А
+Отдел: СЭО Сила тока
+Должность: Комиссар
+Оклад: 0
+Поощрения: []
+>>> emp1.perevod ("СЭО База")
+>>> emp2.oklad_increase(5000)
+>>> emp1.dolzhnost_change("Кандидат")
+>>> emp2.set_reward("Значок лучшего бойца")
+>>> emp1.set_reward("Пачка кириешек")
+>>> print(emp1)
+Сотрудник: Киреев Ю.П
+Отдел: СЭО База
+Должность: Кандидат
+Оклад: -1000
+Поощрения: ['Пачка кириешек']
+>>> print(emp2)
+Сотрудник: Калякин П.А
+Отдел: СЭО Сила тока
+Должность: Комиссар
+Оклад: 5000
+Поощрения: ['Значок лучшего бойца']
+```

TEMA9/test.md

@@ -0,0 +1,160 @@
+# Индивидуальное контрольное задание по модулю 3
+Киреев Юрий А-02-23
+## Задание
+1) Создайте модуль М1, содержащий две функции:
+
+- функция 1: аргументы - имя текстового файла с числовыми данными (может быть разное число значений на каждой строке) и пороговое значение КК; считываются значения из указанного файла и записываются в два новых текстовых файла, имена которых совпадают с именем входного файла с добавлением 1 и 2 - в первый файл записываются значения, превышающие заданный порог, а во второй - не превышающие его. Исходные данные в виде списка возвращаются в вызывающую программу;
+
+- функция 2: аргумент - имя текстового файла с исходными данными; считываются значения из указанного файла, формируются в виде списка и по нему  рассчитываются: среднее, медиана, наименьшее и наибольшее значения, стандартное отклонение - это возвращаемые результаты функции.
+
+2) Создайте еще один модуль М2, в котором должны: 
+
+- запрашиваться имя файла с исходными данными, проверяться его наличие и при отсутствии - повторение запроса;
+
+- запрос порогового значения КК;
+
+- вызов функции 1 с указанным именем;
+
+- трижды вызвать функцию 2: с именем указанного в ответе на запрос файла, а также с каждым из файлов, созданных в функции 1; отобразить результаты расчетов.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2, отображает исходные данные в виде графика  и записывает их в бинарный файл RES2a.bin.
+
+4) Подготовьте 2 файла с не менее, чем с 20 числовыми значениями с разным числом элементов на разных строках и проверьте с ними разработанную программу.
+## Решение
+Модуль M1:
+```py
+import statistics
+
+def raspil(filename, KK):
+    numbers = []
+    with open(filename,'r') as fp:
+        for line in fp:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    file_name = filename.split(".")[0]
+    new_name1 = file_name + '1' + '.txt'
+    new_name2 = file_name + '2' + '.txt'
+    with open (new_name1, 'w') as f1, \
+         open (new_name2, 'w') as f2:
+        for x in numbers:
+            if x > KK:
+                f1.write(str(x)+" ")
+            else:
+                f2.write(str(x)+" ")
+    return numbers
+
+def raschet(filename):
+    numbers = []
+    with open(filename,'r') as fp:
+        for line in fp:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    mean_val = statistics.mean(numbers)
+    median_val = statistics.median(numbers)
+    min_val = min(numbers)
+    max_val = max(numbers)
+    std_val = statistics.stdev(numbers)
+    return mean_val, median_val, min_val, max_val, std_val
+```
+Модуль M2:
+```py
+import os
+import M1
+while True:
+    filename = input("Введите имя файла:")
+    if os.path.isfile(filename):
+        break
+    else:
+        print("Такого файла не существует, повторите ввод:")
+KK = float(input("Введите пороговое значение:"))
+numbers = M1.raspil(filename, KK)
+print("Данные из файла:", numbers)
+file_name = filename.split(".")[0]
+file1 = file_name + '1' + '.txt'
+file2 = file_name + '2' + '.txt'
+files = (filename, file1, file2)
+for file in files:
+    mean_val, median_val, min_val, max_val, std_val = M1.raschet(file)
+    print (f"Среднее: {mean_val}")
+    print (f"Медиана: {median_val}")
+    print (f"Минимальное: {min_val}")
+    print (f"Максимальное: {max_val}")
+    print (f"Стандартное отклонение: {std_val}")
+```
+Модуль M0:
+```py
+import pylab
+import pickle
+import M2
+
+pylab.plot(M2.numbers)
+pylab.title('Исходные данные')
+pylab.xlabel('Индекс')
+pylab.ylabel('Значение')
+pylab.show()
+
+with open('RES2a.bin', 'w') as RES:
+    pickle.dump(M2.numbers, RES)
+```
+Файлы:
+super_test_file.txt
+```py
+-1
+2 -3
+4 -5 6
+-7 8 -9 10
+-11 12 -13 14 -15
+16 -17 18 -19 20
+```
+test_file.txt
+```py
+1 2 3
+4 5 6 7 8
+9 10
+11 12 13 14
+15 16 17 18 19 20
+```
+Проверка super_test_file
+```py
+Введите имя файла:super_test_file.txt
+Введите пороговое значение:0
+Данные из файла: [-1.0, 2.0, -3.0, 4.0, -5.0, 6.0, -7.0, 8.0, -9.0, 10.0, -11.0, 12.0, -13.0, 14.0, -15.0, 16.0, -17.0, 18.0, -19.0, 20.0]
+Среднее: 0.5
+Медиана: 0.5
+Минимальное: -19.0
+Максимальное: 20.0
+Стандартное отклонение: 12.2796365452814
+Среднее: 11.0
+Медиана: 11.0
+Минимальное: 2.0
+Максимальное: 20.0
+Стандартное отклонение: 6.0553007081949835
+Среднее: -10.0
+Медиана: -10.0
+Минимальное: -19.0
+Максимальное: -1.0
+Стандартное отклонение: 6.0553007081949835
+```
+Проверка test_file
+```py
+Введите имя файла:test_file.txt
+Введите пороговое значение:5
+Данные из файла: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0]
+Среднее: 10.5
+Медиана: 10.5
+Минимальное: 1.0
+Максимальное: 20.0
+Стандартное отклонение: 5.916079783099616
+Среднее: 13.0
+Медиана: 13.0
+Минимальное: 6.0
+Максимальное: 20.0
+Стандартное отклонение: 4.47213595499958
+Среднее: 3.0
+Медиана: 3.0
+Минимальное: 1.0
+Максимальное: 5.0
+Стандартное отклонение: 1.5811388300841898
+```