MatPlotLib вывод графика

def temp(x,h,l,k,To):
     #Variables pg18
     a11 = 7 + (4*h*(l*l))/(5*k)
     a12 = (2*h*(l*l))/(5*k) - 8
     a13 = 1 - (h*(l*l))/(5*k)
     a21 = 1 + (3*h*(l*l)/(20*k))
     a22 = (2 + 6*h*(l*l)/(5*k))
     b1 = (h*(l*l)*To)/(k)
     TemK = (2*b1*(a11*a22-a12*a21)-b1*(3*a11-2*a21)*a12)/2*((a11+a13)*(a11*a22-a12*a21)-a12*a21*(a11-a13))
     Tj = ((a13*a21-a11*a21)/(a11*a22-a12*a21))*TemK + b1*(3*a11-2*a21)/2*(a11*a22-a12*a21)
     Ti = -4*Tj + 15*TemK - 400
     b = (29.62963 - ((a13*a21-a11*a21)/(a11*a22-a12*a21))*37.037)*((2*(a11*a22-a12*a21))/(3*a11-2*a21))
     T=b*k/h*l*l
     return (1/100)*(((2*x*x)-3*x*l+(l*l))*Ti + (4*x*l-4*x)*Tj + ((2*x*x)-x*l)*TemK)

return  0.2962948*x*x-2.962948*x+37.037

0.2962948*x*x-2.962948*x+37.037

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
 
from Tkinter import *
 
 
 
 
 
def gcd():
     n1,h1,l1,k1,To1 = correct()
     lag1=0.01
     lag2=0.01
     x1 = np.arange(0.0, 10+n1, n1)
 
 
     
 
 
     
     
     v = var.get()
     if v == 0:
          fig = plt.figure()
          #plt.plot(x1, func1(x1),x2,func2(x2),color="k")
          plt.plot(x1, temp(x1,h1,l1,k1,To1),color="k")
          plt.title(u"Изменение температуры по длине стержня", {'fontname':'Arial','fontsize':16})
          plt.ylabel(u"Температура Т",{'fontname':'Arial','fontsize':16})
          plt.xlabel(u" х ",{'fontname':'Arial','fontsize':16})
          plt.grid(True)
          plt.show()
 
     elif v == 1:
          fig = plt.figure()
          plt.plot(x1, deform1(x1), 'k', x1,deform2(x1),'b', x1,deform3(x1),'r')
          plt.title(u"Деформация",{'fontname':'Arial','fontsize':16})
          plt.ylabel(u"Eps",{'fontname':'Arial','fontsize':16})
          plt.xlabel(u" х ",{'fontname':'Arial','fontsize':16})
          plt.grid(True)
          plt.show()    
 
     elif v == 2:
          fig = plt.figure()
          plt.plot(x1, voltage1(x1),'k', x1, voltage2(x1),'b', x1, voltage3(x1),'r')
          plt.title(u"Напряжение",{'fontname':'Arial','fontsize':16})
          plt.ylabel(u"Sigma",{'fontname':'Arial','fontsize':16})
          plt.xlabel(u"х",{'fontname':'Arial','fontsize':16})
          plt.grid(True)
          plt.show()
     
     elif v == 3:
          fig = plt.figure()
          plt.plot(x1, movement1(x1),'k')
          plt.title(u"Перемещение",{'fontname':'Arial','fontsize':16})
          plt.ylabel(u"u",{'fontname':'Arial','fontsize':16})
          plt.xlabel(u"х",{'fontname':'Arial','fontsize':16})
          plt.grid(True)
          plt.show()
          
 
def correct():
     a = ent_n1.get()
     b = ent_h.get()
     c = ent_l.get()
     d = ent_k.get()
     e = ent_T.get()
     
 
     try:
          a = float(a)
     except ValueError:
          a = 0
          ent_n1.delete(0,END)
          ent_n1.insert(0,0)
     try:
          b = float(b)
     except ValueError:
          b = 0
          ent_n2.delete(0,END)
          ent_n2.insert(0,0)
     try:
          c = float(c)
     except ValueError:
          c = 0
          ent_n1.delete(0,END)
          ent_n1.insert(0,0)
     try:
          d = float(d)
     except ValueError:
          d = 0
          ent_n1.delete(0,END)
          ent_n1.insert(0,0)
     try:
          e = float(e)
     except ValueError:
          e = 0
          ent_n1.delete(0,END)
          ent_n1.insert(0,0)
 
     
     return a, b, c, d, e
 
def temp(x,h,l,k,To):
     #Variables pg18
     a11 = 7 + (4*h*(l*l))/(5*k)
     a12 = (2*h*(l*l))/(5*k) - 8
     a13 = 1 - (h*(l*l))/(5*k)
     a21 = 1 + (3*h*(l*l)/(20*k))
     a22 = (2 + 6*h*(l*l)/(5*k))
     b1 = (h*(l*l)*To)/(k)
     TemK = (2*b1*(a11*a22-a12*a21)-b1*(3*a11-2*a21)*a12)/2*((a11+a13)*(a11*a22-a12*a21)-a12*a21*(a11-a13))
     Tj = ((a13*a21-a11*a21)/(a11*a22-a12*a21))*TemK + b1*(3*a11-2*a21)/2*(a11*a22-a12*a21)
     Ti = -4*Tj + 15*TemK - 400
     b = (29.62963 - ((a13*a21-a11*a21)/(a11*a22-a12*a21))*37.037)*((2*(a11*a22-a12*a21))/(3*a11-2*a21))
     T=b*k/h*l*l
     print "a11", a11
     print "a12", a12
     print "a13", a13
     print "a21", a21
     print "a22", a22
     print "b1", b1
     print "Ti", Ti
     print "Tj", Tj
     print "TemK", TemK
     print "Func ", (1/100)*(((2*x*x)-3*x*l+(l*l))*37 + (4*x*l-4*x)*29 + ((2*x*x)-x*l)*37)
     return (1/100)*(((2*x*x)-3*x*l+(l*l))*37 + (4*x*l-4*x)*29 + ((2*x*x)-x*l)*37)
 
def deform1(x):
      return -0.0000037037*x*x+0.000037037*x-0.0004629625 
 
def deform2(x):
      return 0.0000037037*x*x-0.000037037*x+0.0000629625
 
def deform3(x):
      return -0.00004*(x-x+1)
 
def voltage1(x):
      return  -7.4074*x*x+74.07*x-925.925
def voltage2(x):
      return 7.4074*x*x-74.07*x-125.925
def voltage3(x):
      return -800*(x-x+1)
 
def movement1(x):
      return  0.00000123456*x*x*x-0.0000185185*x*x+0.0000629625*x
 
 
 
 
win = Tk()
win.title('Изменение температуры по длине стержня')
lab_n1 = Label(text="X1")
lab_n1.grid(row=2,column=0)
 
lab_h = Label(text="h")
lab_h.grid(row=3,column=0)
 
lab_l = Label(text="l")
lab_l.grid(row=4,column=0)
 
lab_k = Label(text="k")
lab_k.grid(row=5,column=0)
 
lab_T = Label(text="T")
lab_T.grid(row=6,column=0)
 
ent_n1 = Entry(width=10,bg="white")
ent_n1.grid(row=2,column=1)
 
ent_h = Entry(width=10,bg="white")
ent_h.grid(row=3,column=1)
 
ent_l = Entry(width=10,bg="white")
ent_l.grid(row=4,column=1)
 
ent_k = Entry(width=10,bg="white")
ent_k.grid(row=5,column=1)
 
ent_T = Entry(width=10,bg="white")
ent_T.grid(row=6,column=1)
 
var=IntVar()
var.set(0)
rad0 = Radiobutton(win,text="Первая",variable=var,value=0)
rad1 = Radiobutton(win,text="Вторая",variable=var,value=1)
rad2 = Radiobutton(win,text="Третья",variable=var,value=2)
rad3 = Radiobutton(win,text="Четвертая",variable=var,value=3)
rad0.grid(row=2,column=2)
rad1.grid(row=3,column=2)
rad2.grid(row=4,column=2)
rad3.grid(row=5,column=2)
 
but = Button(text="Вычислить",command=gcd,pady=10)
but.grid(row=7,column=0,rowspan=2,columnspan=2,sticky=W+N+S+E)
 
win.mainloop()

# python 2: 
1/2 = 0
1.0/2.0 = 0.5
 
# python 3
1/2 = 0.5
1//2 = 0

a = float(ent_n1.get())

import matplotlib.pyplot as plt
 
def Plt(arr1x, arr2Y):
        graf1() # ГОТОВИТ ДАННЫЕ ДЛЯ ОТРИСОВКИ ГРАФИКА 1
        graf2(arr1x, arr2Y) #ГОТОВИТ ДАННЫЕ ДЛЯ ОТРИСОВКИ ГРАФИКА 2
        plt.show()
 
 
"""Сначала я добавляю  эти объекты экрана, в каждом из которых рисуется свой график:"""
 
fig = plt.figure(1)
fig_G = plt.figure(2)
 
 
"""Потом в цикле вычисляются данные x, y и запускается функция Plt:"""
 
for i in range(100):
            Plt(x, y)

import matplotlib.pyplot as plt
 
"""Сначала я добавляю  эти объекты экрана, в каждом из которых рисуется свой график:"""
 
fig = plt.figure(1)
fig_G = plt.figure(2)
G = nx.Graph()  # переменная для создания графа
 
 
 
"""Первая работает с этим модулем:"""
 
import networkx as nx
 
def graf1():
        global G
        #НУ КАКАЯ-ТО РАБОТА С networkx
       
 
"""А вторая делает примерно вот что:"""
 
 
def graf2(X, double_arr_Y):
        global fig
        ax = fig.add_subplot(111)
        ax.clear() #НУЖНО ОЧИСТИТЬ ГРАФИК НА КАЖДОЙ ИТЕРАЦИИ
        ax.plot(X, double_arr_Y[0], marker='o',color = 'blue')
        ax.plot(X, double_arr_Y[1], marker='+',)
 
 
"""update нужна для очистки второго экрана:"""
 
def update(X, double_arr_Y):
        global G
        plt.pause(0.9)
        G.clear()
        plt.clf()
 
def Plt(arr1x, arr2Y):
        graf1() # ГОТОВИТ ДАННЫЕ ДЛЯ ОТРИСОВКИ ГРАФИКА 1
        graf2(arr1x, arr2Y) #ГОТОВИТ ДАННЫЕ ДЛЯ ОТРИСОВКИ ГРАФИКА 2
        plt.show()
        update()
 
 
for i in range(100):
            Plt(x, y)

global pos # заданы какие-то координаты расположения вершин
edges, colors = zip(*nx.get_edge_attributes(self.G,'weight').items()) # здесь я раскрашиваю ребра в зависимости от веса
 
nx.draw(G, pos, edgelist=edges, edge_color=colors, with_labels=True)
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)

>>> G = nx.petersen_graph()
>>> plt.subplot(121)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw(G, with_labels=True, font_weight='bold')
>>> plt.subplot(122)
<matplotlib.axes._subplots.AxesSubplot object at ...>
>>> nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')

>>> plt.show()

import matplotlib.pyplot as plt
import networkx as nx
 
""" Сначала идет инициализация  объектов экрана, в каждом из которых рисуется свой график:"""
 
fig = plt.figure(1)
fig_G = plt.figure(2)
G = nx.Graph()  # переменная для создания графа
 
"""Предположим, данные уже сразу есть и на каждой итерации цикла у меня строится один  и тот  же граф и график 
(хотя данные данные вычисляются на каждой итерации цикла и все они меняются. Я приведу массив Х длиной 100, 
может это слишком много дляnetworxk --- не знаю:"""
 
import numpy as np
 
X = np.array(sorted([np.random.uniform(0, 2*np.pi) for i in range(100)]))
 
"""Допустим, есть функции вычисляющие массив Y, на вход каждой из них подается массив X"""
 
def our_Y_sin(X):
        return np.sin(X)
 
def our_Y_cos(X):
        return np.cos(X)
 
 
"""Есть функции , рендерящие графики"""
 
"""Первая graf1 работает с этим модулем networkx ([url]https://networkx.github.io/documentation/stable/index.html[/url]) и строит граф G:"""
 
 
def graf1():
        global G, fig_G
        fig_G.add_subplot(111)
        pos = nx.spring_layout(G)  # пусть так заданы координаты расположения вершин
        edges, colors = zip(*nx.get_edge_attributes(G,'weight').items()) # здесь я раскрашиваю ребра в зависимости от веса
        nx.draw(G, pos, edgelist=edges, edge_color=colors, with_labels=True)
        labels = nx.get_edge_attributes(G, 'weight')
        nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
 
"""А вторая graf2, предположим, строит каких-то 2 графика функции:"""
 
 
def graf2(X, double_arr_Y):
        global fig
        ax = fig.add_subplot(111)
        ax.clear() #НУЖНО ОЧИСТИТЬ ГРАФИК НА КАЖДОЙ ИТЕРАЦИИ, потому что предполагается, что он меняется на каждой итерации в цикле (строка 79)
        ax.plot(X, double_arr_Y[0], marker='o',color = 'blue')
        ax.plot(X, double_arr_Y[1], marker='+',)
 
 
"""update нужна для очистки второго экрана:"""
 
def update():
        global G
        plt.pause(0.9)
        G.clear() # удаляю из графа все объекты связности --- вершины, ребра, потому предполагается, что граф меняется на каждой итерации цикла (строка 80)
        plt.clf()
 
def Plt(arr1x, arr2Y):
        graf1() # ГОТОВИТ ДАННЫЕ ДЛЯ ОТРИСОВКИ ГРАФИКА 1
        graf2(arr1x, arr2Y) #ГОТОВИТ ДАННЫЕ ДЛЯ ОТРИСОВКИ ГРАФИКА 2
        plt.show()
        update()
 
"""Функция по созданию  простенького графа (не важно) --- переменная G:"""
 
def path(G):
        G.add_edge("Омск", "Уфа", weight=100)
        G.add_edge("Томск", "Омск", weight=50)
        G.add_edge("Томск", "Владивосток", weight=0)
        return G
 
 
Y = [our_Y_sin(X), our_Y_cos(X)]# тут данные для отрисовки второго графика
 
"""Дальше идёт цикл, рендерящий оба графика и опаньки, второй график не рисуется на экране, но вылазят 2 экрана:"""
 
for i in range(100):
        G = path(G) # граф G рисуется заново после каждого сброса в инструкции G.clear() (строка 57 процедуры update, которая вызывается в Plt)
        noise = np.array([np.random.uniform(-5,5) for i in range(100)])
        Y[0] = Y[0] + noise
        Plt(X, Y)