| Hosted by CoCalc | Download
Kernel: Python 3 (Anaconda)
import numpy as np
vt = [np.random.randint(-4,4) for x in range(20)];vt
[1, -2, -1, 1, -2, -1, -2, -1, -1, -3, 1, -2, 3, -3, 0, -3, 3, 2, 3, 0]
vo = [x for x in vt if x != 0 and (x%2 != 0)];vo
[1, -1, 1, -1, -1, -1, -3, 1, 3, -3, -3, 3, 3]
####################
import string print(chr(128522))
😊
matriza_vvoda
[['inefwised', 'inef'], ['inefisefn', 'ekn'], ['jbef']]
index = 0 matriza_vvoda = [] while index == 0: matriza_vvoda += [input().split(' ')] last = matriza_vvoda.pop() if last == ['end']: index = 1 else: matriza_vvoda += [last] mt = [] mt += [matriza_vvoda[i][0] for i in range(len(matriza_vvoda))] m = [' '.join(matriza_vvoda[i]) for i in range(len(matriza_vvoda))]
res = [] for i in range(len(m)): space = len([c for c in m[i] if c in ' ']) A = len([c for c in m[i] if c in string.ascii_uppercase]) a = len([c for c in m[i] if c in string.ascii_lowercase]) res += ['пробелов = {0}, прописных = {1}, строчных = {2}'.format(space,A,a)]
res
['пробелов = 1, прописных = 0, строчных = 13', 'пробелов = 1, прописных = 0, строчных = 12', 'пробелов = 0, прописных = 0, строчных = 4']
###############################
import numpy.linalg as li N = 4; M = 5
eyn = lambda i, j: (-1)**(i + j) ma = np.fromfunction(eyn,(N,M));ma
array([[ 1., -1., 1., -1., 1.], [-1., 1., -1., 1., -1.], [ 1., -1., 1., -1., 1.], [-1., 1., -1., 1., -1.]])
hor = []; hor += [sum(ma[i] < 0) for i in range(len(ma))];hor = (np.array(hor)).reshape((4,1)) mu = ma.transpose() ver = []; ver += [sum(mu[i] < 0) for i in range(len(mu))]
hor
array([[2], [3], [2], [3]])
ver
[2, 2, 2, 2, 2]
np.vstack((np.hstack((ma,hor)),ver+[0]))
array([[ 1., -1., 1., -1., 1., 2.], [-1., 1., -1., 1., -1., 3.], [ 1., -1., 1., -1., 1., 2.], [-1., 1., -1., 1., -1., 3.], [ 2., 2., 2., 2., 2., 0.]])
###############################
A = np.reshape([np.random.randint(2,6) for x in range(60)],(4,15));A = np.array(A);A
array([[2, 2, 4, 4, 2, 5, 5, 4, 4, 3, 3, 5, 4, 2, 4], [4, 5, 2, 5, 4, 5, 5, 5, 3, 4, 5, 4, 3, 3, 3], [4, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 5], [2, 4, 3, 4, 4, 3, 4, 4, 5, 3, 5, 4, 2, 3, 2]])
fiv = []; fiv += [sum(A[i] == 5) for i in range(len(A))];fiv = (np.array(fiv)).reshape((4,1));fiv
array([[3], [6], [1], [2]])
np.hstack((A,fiv))
array([[2, 2, 4, 4, 2, 5, 5, 4, 4, 3, 3, 5, 4, 2, 4, 3], [4, 5, 2, 5, 4, 5, 5, 5, 3, 4, 5, 4, 3, 3, 3, 6], [4, 2, 2, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 5, 1], [2, 4, 3, 4, 4, 3, 4, 4, 5, 3, 5, 4, 2, 3, 2, 2]])
################################
import matplotlib.pyplot as pl
func = lambda x: 2*np.log(x) - 1/x #1.4
x = np.linspace(0.2,5,100) pl.plot(x,func(x)) pl.annotate('root', xy=(1.418, 0), xytext=(2, 3), arrowprops=dict(facecolor='black', shrink=0.05),) pl.grid(1) pl.show()
Image in a Jupyter notebook
def search(f, stP, finP, ind): ind += 1 mP=average(stP, finP) if nearcl(stP, finP): return (mP, ind) test = f(mP) if test>0: return search(f, stP, mP, ind) elif test < 0: return search(f, mP, finP, ind) return (mP, ind)
def average(x, y): return (x+y)/2 def nearcl(x, y): if abs(x-y)<0.00001: return 1 return 0
def halfInterval(f, a ,b): ind = 0 aVal=f(a) bVal=f(b) if aVal>0 and bVal<0: return search(f, b, a, ind) elif aVal<0 and bVal>0: return search(f, a, b, ind) else: return 0
halfInterval(func, 0.1, 10)
(1.4215329647064208, 21)
print(ind) ###########################
0
######################################################################пора вторые очки надевать
func = lambda x: 2*np.log(x) - 1/x
def chord(sp, fp, ep): ind = 0 while(abs(fp - sp) > ep): ind += 1 sp = fp - (fp - sp)*func(fp)/(func(fp) - func(sp)) fp = sp + (sp - fp)*func(sp)/(func(sp) - func(fp)) return (fp, ind)
chord(1, 2, 0.001)########################
(1.4212949093366554, 3)
func = lambda x: 2*np.log(x) - 1/x dif = lambda x: 2/x + 1/x**2
def kas(x0, func, dif, e): ind = 0 while 1: ind += 1 x1 = x0 - (func(x0) / dif(x0)) if abs(x1 - x0) < e: return (x1, ind) x0 = x1
kas(1, func, dif, 0.001)#######################
(1.421529935869652, 4)
func = lambda x: 2*np.log(x) - 1/x dif = lambda x: 2/x + 1/x**2
def iter(sp, fp, ep): ind = 0 fp = sp - func(sp)/dif(sp) while(abs(fp - sp) > ep): ind += 1 sp = fp - func(fp)/dif(fp) fp = sp - func(sp)/dif(sp) return (fp, ind)
iter(1,2,0.001)##################
(1.4215299358831166, 2)
##############################################################
import numpy as np import numpy.linalg as li
A = [[2,-1,1], [3,5,-2], [1,-4,10]];A b = np.array([-3,1,0]);b
array([-3, 1, 0])
C = np.reshape([-A[i][j]/A[i][i] for i in range(len(A[0])) for j in range(len(A))],(3,3)) + np.eye(3);print(C) d = [b[i]/A[i][i] for i in range(len(b))];d
[[ 0. 0.5 -0.5] [-0.6 0. 0.4] [-0.1 0.4 0. ]]
[-1.5, 0.20000000000000001, 0.0]
li.solve(A,b)
array([-1.21212121, 1.16161616, 0.58585859])
def lighiter(q1, q2, q3, ep=0.001): q = np.array([q1,q2,q3]) x = C.dot(q) + d while(abs(x[0] - q[0]) > ep and abs(x[1] - q[1]) > ep and abs(x[2] - q[2]) > ep ): q = C.dot(x) + d x = C.dot(q) + d return x
q = li.solve(A,b) x = C.dot(q) + d;x
array([-1.21212121, 1.16161616, 0.58585859])
lighiter(-1.2, 1, 0.5, 0.0001) ###########################
array([-1.212134 , 1.1616362 , 0.58584048])
def zeid(q1, q2, q3, ep=0.001): q = np.array([q1,q2,q3]) x1 = C[0][0]*q1 + C[0][1]*q2 + C[0][2]*q3 + d[0] x2 = C[1][0]*x1 + C[1][1]*q2 + C[1][2]*q3 + d[1] x3 = C[2][0]*x1 + C[2][1]*x2 + C[2][2]*q3 + d[2] while(abs(x1 - q1) > ep and abs(x2 - q2) > ep and abs(x3 - q3) > ep): x1 = C[0][0]*q1 + C[0][1]*q2 + C[0][2]*q3 + d[0] x2 = C[1][0]*x1 + C[1][1]*q2 + C[1][2]*q3 + d[1] x3 = C[2][0]*x1 + C[2][1]*x2 + C[2][2]*q3 + d[2] q1 = C[0][0]*x1 + C[0][1]*x2 + C[0][2]*x3 + d[0] q2 = C[1][0]*q1 + C[1][1]*x2 + C[1][2]*x3 + d[1] q3 = C[2][0]*q1 + C[2][1]*q2 + C[2][2]*x3 + d[2] return [x1, x2, x3]
zeid(-1.2, 1, 0.5, 0.0001) ################################
[-1.211525, 1.1619349999999999, 0.58592650000000002]
#num8
fn = lambda x: np.log(x/2) dif = lambda x: 1/x dif2 = lambda x: -1/x**2 a = 4.5; b = 10; m = 5.03
rdif = lambda x, d: (fn(x + d) - fn(x))/d ldif = lambda x, d: (fn(x) - fn(x - d))/d ddif = lambda x, d: (fn(x - 2*d) - 8*fn(x - d) + 8*fn(x + d) - fn(x + 2*d))/(12*d) diff = lambda x, d: (fn(x + d) - fn(x - d))/(2*d)
print(dif(m), '=', rdif(m,5.029), '=', ldif(m, 5.0), '=', ddif(m, 5.029), '=', diff(m, 5.029))
0.19880715705765406 = 0.13781025493 = 1.02439557629 = nan = 0.916307718745
/ext/anaconda3/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in log if __name__ == '__main__':
ddiff = lambda x, d: (fn(x - d) - 2*fn(x) + fn(x + d))/d**2;ddiff(m,5.029)
-0.30960328646457025
x = np.linspace(a, b, 50); xn = np.hstack((x[1:],[10.1])) f = fn(x); d = dif(x); dd = dif2(x) dn = rdif(x,xn) ddn = -ddiff(x,xn)
/ext/anaconda3/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: invalid value encountered in log if __name__ == '__main__':
print(x)
[ 4.5 4.6122449 4.7244898 4.83673469 4.94897959 5.06122449 5.17346939 5.28571429 5.39795918 5.51020408 5.62244898 5.73469388 5.84693878 5.95918367 6.07142857 6.18367347 6.29591837 6.40816327 6.52040816 6.63265306 6.74489796 6.85714286 6.96938776 7.08163265 7.19387755 7.30612245 7.41836735 7.53061224 7.64285714 7.75510204 7.86734694 7.97959184 8.09183673 8.20408163 8.31632653 8.42857143 8.54081633 8.65306122 8.76530612 8.87755102 8.98979592 9.10204082 9.21428571 9.32653061 9.43877551 9.55102041 9.66326531 9.7755102 9.8877551 10. ]
print(xn)
[ 4.6122449 4.7244898 4.83673469 4.94897959 5.06122449 5.17346939 5.28571429 5.39795918 5.51020408 5.62244898 5.73469388 5.84693878 5.95918367 6.07142857 6.18367347 6.29591837 6.40816327 6.52040816 6.63265306 6.74489796 6.85714286 6.96938776 7.08163265 7.19387755 7.30612245 7.41836735 7.53061224 7.64285714 7.75510204 7.86734694 7.97959184 8.09183673 8.20408163 8.31632653 8.42857143 8.54081633 8.65306122 8.76530612 8.87755102 8.98979592 9.10204082 9.21428571 9.32653061 9.43877551 9.55102041 9.66326531 9.7755102 9.8877551 10. 10.1 ]
import matplotlib.pyplot as plt
plt.figure(figsize=(10,20)) plt.plot(x,f,'ro-',x,d,'bD-',x,dd,'gs-',x,d,'y',x,dd, 'r*') plt.grid(1) plt.show()
Image in a Jupyter notebook
plt.plot(x,dd,'gs-',x,ddn, 'ro-') plt.show()
Image in a Jupyter notebook
#######################################
fn = lambda x, u: np.cos(u)/(1.25 + x) - 0.1*u**3 lin = np.linspace(0,1,1000) x0 = 0;u0 = 0;du0 = fn(0,0) h = 0.001
def eulr(x, u): y = [] for i in range(len(lin)): u += h*fn(x, u) x += h y += [u] return yyu = eulr(0,0)
len(lin), len(yu)
(1000, 1000)
plt.plot(lin,yu)
[<matplotlib.lines.Line2D at 0x7fef9f626588>]
Image in a Jupyter notebook
import numpy as np from scipy.integrate import odeint import matplotlib.pyplot as plt def fun(y, t, a): """Define the right-hand side of equation dy/dt = a*y""" f = np.cos(y)/(1.25 + t) - 0.1*y**3 return f # Initial condition y0 = 0 # Times at which the solution is to be computed. t = np.linspace(0, 1, 51) # Parameter value to use in `fun`. a = -2.5 # Solve the equation. y = odeint(fun, y0, t, args=(a,)) # Plot the solution. `odeint` is generally used to solve a system # of equations, so it returns an array with shape (len(t), len(y0)). # In this case, len(y0) is 1, so y[:,0] gives us the solution. plt.plot(t, y[:,0]) plt.xlabel('t') plt.ylabel('y') plt.show()
Image in a Jupyter notebook
fn = lambda x, u: np.cos(u)/(1.25 + x) - 0.1*u**3 lin = np.linspace(0,1,10000) x0 = 0; u0 = 0; du0 = fn(0,0) h = 1/len(lin)
def RulkaKutka(f, x0, y0, x1, n): vx = [0] * (n) vy = [0] * (n) h = (x1 - x0) / float(n) vx[0] = x = x0 vy[0] = y = y0 for i in range(1, n): k1 = h * f(x, y) k2 = h * f(x + 0.5 * h, y + 0.5 * k1) k3 = h * f(x + 0.5 * h, y + 0.5 * k2) k4 = h * f(x + h, y + k3) vx[i] = x = x0 + i * h vy[i] = y = y + (k1 + k2 + k2 + k3 + k3 + k4) / 6 return vy
ty = RulkaKutka(fn,0,0,1,1000)
plt.plot(lin,ty)
[<matplotlib.lines.Line2D at 0x7fef947a1390>]
Image in a Jupyter notebook