diff --git a/TEMA4/Ris1.png b/TEMA4/Ris1.png new file mode 100644 index 0000000..79a2973 Binary files /dev/null and b/TEMA4/Ris1.png differ diff --git a/TEMA4/Ris2.png b/TEMA4/Ris2.png new file mode 100644 index 0000000..a975fc9 Binary files /dev/null and b/TEMA4/Ris2.png differ diff --git a/TEMA4/Ris3.png b/TEMA4/Ris3.png new file mode 100644 index 0000000..0654f48 Binary files /dev/null and b/TEMA4/Ris3.png differ diff --git a/TEMA4/Ris4.png b/TEMA4/Ris4.png new file mode 100644 index 0000000..b597978 Binary files /dev/null and b/TEMA4/Ris4.png differ diff --git a/TEMA4/Ris5.png b/TEMA4/Ris5.png new file mode 100644 index 0000000..bf80490 Binary files /dev/null and b/TEMA4/Ris5.png differ diff --git a/TEMA4/report.md b/TEMA4/report.md new file mode 100644 index 0000000..f4cc2e8 --- /dev/null +++ b/TEMA4/report.md @@ -0,0 +1,446 @@ +# Отчет по Теме 4 + +Турханов Артем, А-03-23 + +## 1 Стандартные функции +```py +>>> help(round) +Help on built-in function round in module builtins: + +round(number, ndigits=None) + Round a number to a given precision in decimal digits. + + The return value is an integer if ndigits is omitted or None. Otherwise + the return value has the same type as the number. ndigits may be negative. + +>>> round(123.456,1); round(123.456,0) +123.5 +123.0 +>>> round(123.456,-1) +120.0 +>>> type(round(123.456,1)) + +>>> type(round(123.456,0)) + +>>> round(123.456); type(round(123.456)) +123 + +``` +Если же в качестве второго аргумента функции round нияего не указывать, то округление будет происходить до целого. Поэтому результат - число целочисленного типа данных (int). В противном же случае результатом будет число вещественного типа. +```py +>>> gg=range(76,123,9); gg; type(gg) +range(76, 123, 9) + +>>> list(gg) +[76, 85, 94, 103, 112, 121] +>>> range(23) +range(0, 23) +>>> list(range(23)) +[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] +``` +Если в функцию range передать всего один аргумент, то результатом выполнения функции будет итерируемый объет класса range с целочисленными значениями от 0 до того числа, которое было указано в качестве аргумента, не включительно c шагом по умолчанию, равным единице. + +```py +>>> qq = ['Turkhanov', 'Ogarkov', 'Vasiliev', 'Semenov'] +>>> ff = zip(gg,qq); ff + +>>> type(ff) + +>>> tuple(ff) +((76, 'Turkhanov'), (85, 'Ogarkov'), (94, 'Vasiliev'), (103, 'Semenov')) +>>> ff[0]; ff[3] +Traceback (most recent call last): + File "", line 1, in + ff[0]; ff[3] +TypeError: 'zip' object is not subscriptable +``` +В получившемся кортеже мы видим 4 объекта-кортежа, что соответствует длине самого короткого списка из двух (len(gg) = 6, len(qq) = 4). Заметим также, что к объекту ff типа zip нельзя обращаться по индексам. +```py +>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156'); +коэффициент усиления=100 +>>> dan; type(dan) +344.0 + +>>> 5*100 - 156 +344 +>>> exec(input('введите инструкции:')) +введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3) +>>> gg +221.456 +>>> abs(-10.12) +10.12 +>>> pow(2,5) +32 +>>> pow(2,5.3) +39.396621227037315 +>>> pow(2.4,-5.3) +0.009657849177552984 +>>> max(1,-2) +1 +>>> min([1,3,-5,-122]) +-122 +>>> sum([1,3,5,3,7,4]) +23 +>>> help(divmod) +Help on built-in function divmod in module builtins: + +divmod(x, y, /) + Return the tuple (x//y, x%y). Invariant: div*y + mod == x. + +>>> divmod(9,5) +(1, 4) +>>> a = [1,2,3,4,5,6,7,8,9] +>>> len(a) +9 +>>> a = map(int, input().split()); a +1 2 3 4 5 6 + +>>> list(a) +[1, 2, 3, 4, 5, 6] +``` +## 2 Функции из стандартного модуля math +```py +>>> import math +>>> dir(math) +['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp'] +>>> help(math.factorial) +Help on built-in function factorial in module math: + +factorial(n, /) + Find n!. + + Raise a ValueError if x is negative or non-integral. + +>>> math.factorial(5) +120 +>>> math.sin(math.pi/2) +1.0 +>>> math.acos(-1) +3.141592653589793 +>>> help(math.degrees) +Help on built-in function degrees in module math: + +degrees(x, /) + Convert angle x from radians to degrees. + +>>> math.degrees(math.pi) +180.0 +>>> math.radians(270) +4.71238898038469 +>>> math.pi/2*3 +4.71238898038469 +>>> math.exp(1); math.exp(3) +2.718281828459045 +20.085536923187668 +>>> help(math.log) +Help on built-in function log in module math: + +log(...) + log(x, [base=math.e]) + Return the logarithm of x to the given base. + + If the base is not specified, returns the natural logarithm (base e) of x. + +>>> math.log(math.exp(1)) +1.0 +>>> math.log(math.exp(3)) +3.0 +>>> math.log10(pow(10,5)) +5.0 +>>> math.sqrt(121); math.sqrt(25) +11.0 +5.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.2); math.ceil(6.999) +4 +7 +>>> 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.2); math.floor(6.999) +3 +6 +>>> math.sin(2*math.pi/7 + pow(math.exp(1), 0.23)) +0.8334902641414562 +``` +## 3 Функции из модуля 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 +``` +## 4 Стандартный модуль random +```py +>>> import random +>>> dir(random) +['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate'] +>>> help(random.seed) +Help on method seed in module random: + +seed(a=None, version=2) method of random.Random instance + Initialize internal state from a seed. + + The only supported seed types are None, int, float, + str, bytes, and bytearray. + + None or no argument seeds from current time or from an operating + system specific randomness source if available. + + If *a* is an int, all bits are used. + + For version 2 (the default), all of the bits are used if *a* is a str, + bytes, or bytearray. For version 1 (provided for reproducing random + sequences from older versions of Python), the algorithm for str and + bytes generates a narrower range of seeds. + +>>> random.seed() + +>>> help(random.uniform) +Help on method uniform in module random: + +>>> uniform(a, b) method of random.Random instance + Get a random number in the range [a, b) or [a, b] depending on rounding. + + The mean (expected value) and variance of the random variable are: + + E[X] = (a + b) / 2 + Var[X] = (b - a) ** 2 / 12 + +>>> random.uniform(1,10) +7.820969962495622 +>>> 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.21580642037220688 +>>> 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(1,10) +1 +>>> help(random.gauss) +Help on method gauss in module random: + +gauss(mu=0.0, sigma=1.0) method of random.Random instance + Gaussian distribution. + + mu is the mean, and sigma is the standard deviation. This is + slightly faster than the normalvariate() function. + + Not thread-safe without a lock around calls. + +>>> random.gauss(10, 2) +6.560077457806456 +>>> help(random.choice) +Help on method choice in module random: + +choice(seq) method of random.Random instance + Choose a random element from a non-empty sequence. + +>>> random.choice([1,2,3,4,5,6,7,8,9]) +1 +>>> help(random.shuffle) +Help on method shuffle in module random: + +shuffle(x) method of random.Random instance + Shuffle list x in place, and return None. + +>>> x = [1,2,3,4,5,6,7,8,9] +>>> random.shuffle(x); x +[5, 7, 4, 3, 8, 1, 9, 2, 6] +>>> help(random.betavariate) +Help on method betavariate in module random: + +betavariate(alpha, beta) method of random.Random instance + Beta distribution. + + Conditions on the parameters are alpha > 0 and beta > 0. + Returned values range between 0 and 1. + + The mean (expected value) and variance of the random variable are: + + E[X] = alpha / (alpha + beta) + Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1)) +>>> random.betavariate(1,2) +0.31509637997467377 +>>> help(random.gammavariate) +Help on method gammavariate in module random: + +gammavariate(alpha, beta) method of random.Random instance + Gamma distribution. Not the gamma function! + + Conditions on the parameters are alpha > 0 and beta > 0. + + The probability distribution function is: + + x ** (alpha - 1) * math.exp(-x / beta) + pdf(x) = -------------------------------------- + math.gamma(alpha) * beta ** alpha + + The mean (expected value) and variance of the random variable are: + + E[X] = alpha * beta + Var[X] = alpha * beta ** 2 + +>>> random.gammavariate(1,2) +0.0676205462545973 +>>> ls = [random.uniform(0,10), random.gauss(0,3), random.betavariate(1,2), random.gammavariate(1,2)]; ls +[9.745005344582257, 2.16302978480045, 0.8426318147572717, 0.1932454384006428] +``` +## 5 Функции из модуля time +```py +>>> import time +>>> dir(time) +['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname'] +>>> c1 = time.time(); c1 +1759138103.1649246 +>>> c2=time.time()-c1; c2 +21.219618320465088 +>>> dat=time.gmtime(); dat +time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=9, tm_min=29, tm_sec=17, tm_wday=0, tm_yday=272, tm_isdst=0) +>>> dat.tm_mon +9 +>>> dat.tm_year; dat.tm_sec +2025 +17 +>>> time.localtime() +time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=12, tm_min=30, tm_sec=53, tm_wday=0, tm_yday=272, tm_isdst=0) +>>> 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(time.localtime()) +'Mon Sep 29 12:31:59 2025' +>>> time.ctime() +'Mon Sep 29 12:32:27 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(time.time()) +'Mon Sep 29 12:33:19 2025' +>>> help(time.sleep) +Help on built-in function sleep in module time: + +sleep(object, /) + sleep(seconds) + + Delay execution for a given number of seconds. The argument may be + a floating-point number for subsecond precision. + +>>> time.sleep(10) +>>> time.mktime(time.localtime()) +1759138661.0 +>>> time.time() +1759138670.3741279 +``` +## 6 Графические функции +```py +>>> import pylab +>>> x=list(range(-3,55,4)) +>>> t=list(range(15)) +>>> pylab.plot(t,x) +[] +>>> pylab.title('Первый график') +Text(0.5, 1.0, 'Первый график') +>>> pylab.xlabel('время') +Text(0.5, 0, 'время') +>>> pylab.ylabel('сигнал') +Text(0, 0.5, 'сигнал') +>>> pylab.show() +``` +![Рисунок 1. Первый линейный график](Ris1.png) + +На рис. 1 мы видим отображение линйной зависимости x(t) в виде графика функции, являющегося прямой. +```py +>>> X1=[12,6,8,10,7]; X2=[5,7,9,11,13] +>>> pylab.plot(X1) +[] +>>> pylab.plot(X2) +[] +>>> pylab.show() +``` +![Рисунок 2. Несколько графиков на однои рисунке](Ris2.png) +```py +>>> region=['Центр','Урал','Сибирь','Юг'] +>>> naselen=[65,12,23,17] +>>> pylab.pie(naselen,labels=region) +([, , , ], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')]) +>>> pylab.show() +``` +![Рисунок 3. Круговая диаграмма](Ris3.png) + +```py +>>> data = [random.gauss() for i in range(1000)] +>>> pylab.hist(data, bins = 30) +(array([ 1., 0., 0., 0., 0., 3., 4., 15., 10., 19., 35., 53., 53., + 60., 90., 82., 90., 99., 96., 67., 65., 52., 32., 34., 9., 14., + 9., 4., 3., 1.]), array([-3.99649362, -3.76019089, -3.52388816, -3.28758542, -3.05128269, + -2.81497996, -2.57867722, -2.34237449, -2.10607176, -1.86976903, + -1.63346629, -1.39716356, -1.16086083, -0.92455809, -0.68825536, + -0.45195263, -0.2156499 , 0.02065284, 0.25695557, 0.4932583 , + 0.72956103, 0.96586377, 1.2021665 , 1.43846923, 1.67477197, + 1.9110747 , 2.14737743, 2.38368016, 2.6199829 , 2.85628563, + 3.09258836]), ) +>>> pylab.show() +``` +![Рисунок 4. Гистограмма по выборке нормально распределенных значений](Ris4.png) + +```py +>>> cat = ['Сентябрь', 'Октябрь', 'Ноябрь'] +>>> values = [100, 200, 30] +>>> pylab.bar(cat, values) + +>>> pylab.title('Столбчатая диаграмма') +Text(0.5, 1.0, 'Столбчатая диаграмма') +>>> pylab.xlabel('Месяц') +Text(0.5, 0, 'Месяц') +>>> pylab.ylabel('Количество заявок, шт') +Text(0, 0.5, 'Количество заявок, шт') +>>> pylab.show() +``` +![Рисунок 5. Столбчатая диаграмма](Ris5.png) + +## 7 Статистические функции +```py +>>> import statistics +>>> data = [random.gauss(10,3) for i in range(1000)] +>>> statistics.mean(data) +10.13981944059001 +>>> statistics.stdev(data) +3.053185233060045 +>>> statistics.median(data) +10.073166882507437 +```