Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Cómo programar funciones algebraicas

6/30
Recursos

Aportes 58

Preguntas 22

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Para poder limitar el plano debes incluir las funciones xlim y ylim de MathPlotLib:

import matplotlib.pyplot as plt
import numpy as np

def f(x):
  return 2 * x**7 - x**4 + 3 * x**2 + 4

x = np.linspace(-100.0, 100.0, num=N)
y = f(x)

fig, ax = plt.subplots()
plt.xlim(-25, 25)
plt.ylim(-15, 15)
ax.plot(x, y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')

Aqui les dejo mis apuntes que hice en colab, siempre le trato de dar sentido con ejemplos.
https://colab.research.google.com/drive/1K4Yt1PTogXyKJ0zKiH9SPlObN_sZIt8m?usp=sharing

Tambien use una libreria muy parecida matplotlib, pero esta nos deja hacer zoom que se llama bokeh. 😉

A partir de hoy ¿Quien necesita geogebra? (?

🤓 De esta forma se ve más como parabola la última gráfica:

def f(x):
  return 2*x**8 - x**4 + 3*x**2 + 4

res = 100 #resolución de puntos para nuestra gráfica

x = np.linspace(-10.0, 10.0, num=res)

y = f(x)

fig, ax = plt.subplots()
plt.xlim(-5, 5)
plt.ylim(0, 15) 
ax.plot(x, y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')

RESUMEN FAST:
Una función es m*x+b donde:
m = será quien multiplique la X y será quien controle el sentido de la recta(dependiendo si es positivo o negativo)
x = el límite recta por eso irá desde -infinito hasta +infinito
b = es básicamente el punto de corte y al igual que m dependerá si pones un número R negativo o positivo

Una función polinómica es a[n]*X^n + … + a[2]x^2 + a[1]x + a[1] donde:
n = grado del polinomio, si n vale 7 entonces es un polinomio de grado 7, si es 3 es un polinomio grado 3 y así.
nota de n = si le asignas un número, este irá decreciendo conforme escribas el polinomio, osea si empiezas en 7, el siguiente será 6, 5, 4, 3, 2, 1, puedes omitir un número, pero siempre será decreciente(es más por orden que una regla)
a = un coeficiente que puede variar y ser cualquier número ∈ R.

Nota del reto:
usa lim para limitar el plano
plt.ylim(-n, n)
plt.xlim(-n, n)

Para conocer rápidamente cual es la tendencia de la función
Cuando
m>0 la función es creciente
m=0 la función es constante
m<0 la función es decreciente

Cuando el profesor dice: todo número elevado a la 0 es igual a 1, hay que hacer la aclaración que esto no es del todo correcto, pues 0^0 es diferente de 1. Lo que debe decir: todo número diferente de 0 elevado a la 0 es igual a 1 👍

Explicación del código de la clase

  • Funciones lineales
def f(m, x, b):
  """funcion algebraica
  param m es pendiente
  param x es variable dependiente
  param b es punto de corte del eje y
  retorna formula de funcion lineal
  """
  return m*x + b

resolucion = 100 # serie finita de puntos

m = -2 # valor de la pendiente
b = 5 # valor del corte de y
x = np.linspace(-5.0, 10.0, num=resolucion) # valor de la variable dependiente
# linspace() nos genera una serie de puntos en un rango establecido

y = f(m, x, b) # y = f(x)

figura, ejes = plt.subplots() # genera una gráfica con la figura y los ejes

ejes.plot(x, y) #graficamos el dominio y el rango
ejes.grid()

# eje de coordenadas
ejes.axhline(y=0, color='r') # eje x
ejes.axvline(x=0, color='r') # eje y
  • Funciones polinómicas
def f(x):
  """funcion polinomica
  param x es una variable que estará en algunos término del polinomio
  retorna polinomio
  """
  return 2 * x**7 - x**4 + 3 * x**2 + 4 # polinomio

resolucion = 100

x = np.linspace(-10.0, 10.0, num=resolucion)

y = f(x)

figura, ejes = plt.subplots()

plt.xlim(-15, 15) # hacer zoom en el eje x
plt.ylim(-15, 15) # hacer zoom en el eje y

ejes.plot(x, y)
ejes.grid()

# eje de coordenadas
ejes.axhline(y=0, color='r')
ejes.axvline(x=0, color='r')

La variable res se refiere a la discretización de tu función. Es decir, cuántos puntos vas a tener en tu linspace.
Recuerda que mientras más puntos tengas, mayor será la aproximación de tu función, pero consumirá más recursos de tu computadora.

plt.xlim(-5,5) #Mediante plt.xlim() puedes cambiar el rango que se muestra en el eje x.
plt.ylim(0,20)```

Otra vez bienvenidAS, que platzi es solo para mujeres? Que sexistas!

Les dejo el que realice, hice pequeños cambios para que pueda graficar funciones con exponencial n ingresado por el usuario, también el zoom cambia dependiendo del n ingresado

les dejo el link al colab:
https://colab.research.google.com/drive/1wQi4aaN_Ki2c7unAvobc5v08slasLZIo?usp=sharing

# funcion a la n
def f(x, coeficientes, exponentes):
  n = len(coeficientes)
  res = 0
  for i in range(n):
    res += coeficientes[i] * (x ** exponentes[i])
  return res

def imprimir_funcion(coeficientes, exponentes):
  n = len(coeficientes)
  for i in range(n):
    if coeficientes[i] > 0:
      print(f'+{coeficientes[i]}x^{exponentes[i]} ', end='')
    elif coeficientes[i] < 0:
      print(f'{coeficientes[i]}x^{exponentes[i]} ', end='')

# Series de puntos para que pueda graficar la computadora
n = int(input('De que grado quieres que sea la grafica: '))
n += 1
res = 100
x = np.linspace(-10.0, 10.0, num = res)

coeficientes = np.random.randint(-10.0, 10.0, n)
exponentes = np.arange(n)

y = f(x, coeficientes, exponentes)

fig, ax = plt.subplots()

imprimir_funcion(coeficientes, exponentes)

ax.plot(x, y)
ax.grid()
ax.axhline(y = 0, color = 'r')
ax.axvline(x = 0, color = 'r')
lim = n #* abs(coeficientes.max())
plt.ylim(-lim, lim)
plt.xlim(-20, 20)
plt.show()

si alguien no le funcionó en Vs o en python les dejo el código con el que logré visualizar la gráfica ya que directamente con ese código no pude, espero les sirva

<from matplotlib import pyplot as plt
import numpy as np

def f(m,x,b):
return m*x + b

res= 100
m = -2

x = np.linspace(-10.0, 10.0, num=res)

b = 10

y = f(m,x,b)

fig, ax = plt.subplots()
ax.plot(x, y)
ax.grid()
ax.axhline(y=0, color=‘r’)
ax.axvline(x=0, color=‘r’)
plt.show()>

Para quien quiera usar VS, el código es el siguiente:

import matplotlib.pyplot as plt
import numpy as np
N = 100 # número de puntos


def f(x):
    #return 2 * x**7 - x**4 + 3 * x**2 + 4
    #return 2*x**8 - x**4 + 3*x**2 + 4
    return x**2
#datos a graficar
x = np.linspace(-100.0, 100.0, num=N)
y = f(x)

fig, ax = plt.subplots()


ax.plot(x, y)

# genera un malla
ax.grid()


#coloca ejes en la vertical y horizontal de color rojo
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')

#Pone la etiqueta del eje 'X'
plt.xlabel('X')

#Pone la etiqueta del eje 'Y'
plt.ylabel(r'$Y=X^2$')

#Pone un título a la gráfica
plt.title('F(X)')
# Mustra la Gráfica
plt.show()

Para aquellos que prefieren algo mas classic como tu IDE y tu terminal, les puede dar un error de que matplotlib no tiene subplots esto es por que hay que importarlo de la siguiente manera

import matplotlib.pyplot as plt

y para que no se cierre la ventana inmediatamente deben poner al final

plt.show()

Este es un ejemplo que hice

def f(x):
  return 3*x**4 + 2*x **2 + 2*x **1
res = 10000
x= np.linspace(-10.0,10.0,num=res)
y = f(x)
fig, ax = plt.subplots()
plt.xlim(-1, 1)
plt.ylim(-1, 1)
ax.plot(x, y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')
m = -0.75 #Pendiente 
b = 5 #punto de corte con el eje y
x = np.linspace(-10.0,10.0, num=100)
y = funcion_polinomicas(x)
y2 = funcion_polinomicas2(x)

fig ,ax = plt.subplots(figsize=(9.5,5)) 
ax.grid()
ax.axhline(y=0,color='r')
ax.axvline(x=0,color='r')
ax.plot(x,y)

fig ,ax2 = plt.subplots(1,2,figsize=(10,5)) 
ax2[0].grid()
ax2[0].axhline(y=0,color='r')
ax2[0].axvline(x=0,color='r')
ax2[0].plot(x,y2,color='g')

plt.xlim(-25, 25)
plt.ylim(-15, 15)
ax2[1].grid()
ax2[1].axhline(y=0,color='r')
ax2[1].axvline(x=0,color='r')
ax2[1].plot(x,y2,color='g')
plt.show()
Me acorde cuando usaba matlab para hacer estas cosas, se ve sencillo, no he terminado de ver y hacer los ejemplos del curso de google colab, pero veo que me complementaria muy bien para conocer mejor de antemano los comandos utilozados

Mi aporte:

#xlim para limitar la visualización eje x
plt.xlim([0, 25])

Mi aporte

def f(x):
  return 2*x**8 - x**4 + 3*x**2 + 4

res = 100

x = np.linspace(-10.0, 10.0, num=res)

y = f(x)

fig, ax = plt.subplots()

ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')

plt.xlim([4, 7])
plt.show()

Hay que correr cada parte del programa por ejemplo para que funcione las graficas hay que correr la primera parte que importa las librerías

Para instalar matplolib en nuestras máquinas
python -m pip install -U pip
python -m pip install -U matplotlib

Para ajustar el plano de nuestro gráfico sólo tenemos que agregar estos dos elementos:

plt.xlim(-1.5, 1.5)
plt.ylim(4, 10)

De esta forma podemos ajustar los ejes x e y entre los puntos que definamos.

Respondo al reto de hacer zoom, las pequeñas variaciones son en la escala de las Y así:
1- Al inicio nos da una escala de 2 x 10 ^8 con una imagen suave.
2- Al reducir la escala en Y, la grafica se parece más a un pico muy cerrado.
3- Al reducir la escala en X, se parece más a la parábola y se ve mas geométrica.
4- Al aumentar la resolución hasta 1000 vuelve a ser una curva suave (no geométrica).

Para ‘hacerle zoom’ a la grafica, usaremos las funciones:
xlim()
ylim()

Sus nombres provienen de la abreviación de “Límite en el eje X” y “Límite en el eje Y”, respectivamente

Estas funciones nos permiten escoger en dónde enfocaremos la gráfica a presentar.
Si colocamos que el límite izquierdo es -1 y el límite izquierdo es 1, se mostrará la gráfica tomando como** límites del eje X -1 a 1** y por lo tanto, hará una especie de “zoom” a esa área, ignorando todo lo que pudiera observarse de 1 en adelante)

Ambas funciones tienen por parámetros:
left: Límite izquierdo del eje X de mi función (en caso de xlim)
right: Límite derecho del eje X de mi función

Su sintaxis será la siguiente:

plt.xlim(-10, 10)

En el ejemplo de la clase, se utilizarían de la siguiente manera:

#Inserte el resto del codigo de la clase
y=f(x)

fig, ax=plt.subplots()          	#Se graficaran la figura y los ejes con plt.subplots
plt.xlim(-1.2, 1.2)		  	#Se establecera el limite de la grafica a mostrar entre -1.2 y 1.2 en el eje X)
plt.ylim(3.9, 10)			#Se establecera el limite de la grafica a mostrar entre -3.9 y 10 en el eje Y)

plt.title('Funcion polinomica') #Le coloca un titulo a la grafica
plt.xlabel('Eje de las X') 		#Le coloca un titulo al eje de las X
plt.ylabel('Eje de las Y') 		#Le coloca un titulo al eje de las Y
ax.plot(x,y)                          #Grafica la funcion establecida
ax.grid()                               #Le pone lineas de guia a la grafica
ax.axhline(y=0, color='r')  #Coloca una linea de guia que representara al eje Y (se pintara de color rojo)
ax.axvline(x=0, color='r')  #Coloca una linea de guia que representara al eje X (se pintara de color rojo)

Tambien les comparto el código comentado de la segunda parte de la clase (Funcion polinomica) explicando que es cada cosa por si a alguien le sirve 😄.

import matplotlib.pyplot as plt    # Se importa la librería para graficar
import numpy as np                      # Se importa la librería para manejo de vectores y utilidades matemáticas

def f(x):       #Se establece la funcion, a la que le pasaremos como parametros la variable 'x'.
  return 2*x**8 - x**4 + 3*x**2 + 4 #La funcion al llamarla retornara la operacion indicada con los valores que se le den a los parametros en cada caso 

res =100        #Resolucion con la que vamos a graficar (cuantos puntos distintos se utilizaran para realizar la grafica)
x=np.linspace(-10.0, 10.0, num=res)   #Como la X varia, utilizamos un vector para generar una serie de puntos en un rango.
# Se generan 100 numeros en el rango de -10 a 10

y=f(x)  #Le pasamos los valores a la funcion y asignamos el resultado obtenido a la variable Y

fig, ax=plt.subplots()          #Se graficaran la figura y los ejes con plt.subplots

ax.plot(x,y)                          #Grafica la funcion establecida
ax.grid()                               #Le pone lineas de guia a la grafica
ax.axhline(y=0, color='r')  #Coloca una linea de guia que representara al eje Y (se pintara de color rojo)
ax.axvline(x=0, color='r')  #Coloca una linea de guia que representara al eje X (se pintara de color rojo)

Les comparto el código comentado de la primera parte de la clase explicando que es cada cosa por si a alguien le sirve 😄.

import matplotlib.pyplot as plt    # Se importa la librería para graficar
import numpy as np                      # Se importa la librería para manejo de vectores y utilidades matemáticas

def f(m, x, b):       #Se establece la funcion, a la que le pasaremos como parametros las variables 'm', 'x' y 'b'.
  return m*x + b #La funcion al llamarla retornara la operacion indicada con los valores que se le den a los parametros en cada caso 

res =100        #Resolucion con la que vamos a graficar (cuantos puntos distintos se utilizaran para realizar la grafica)
m=2              #Pendiente de la recta
b=5               #Valor que desplaza a la recta lejos del origen. Es una propiedad de las rectas que no tienen su centro en el origen (0,0)
x=np.linspace(-10.0, 10.0, num=res)   #Como la X varia, utilizamos un vector para generar una serie de puntos en un rango.
# Se generan 100 numeros en el rango de -10 a 10

y=f(m, x, b)  #Le pasamos los valores a la funcion y asignados el resultado obtenido a la variable Y

fig, ax=plt.subplots()          #Se graficaran la figura y los ejes con plt.subplots

ax.plot(x,y)                          #Grafica la funcion establecida
ax.grid()                               #Le pone lineas de guia a la grafica
ax.axhline(y=0, color='r')  #Coloca una linea de guia que representara al eje Y (se pintara de color rojo)
ax.axvline(x=0, color='r')  #Coloca una linea de guia que representara al eje X (se pintara de color rojo)

plt.xlim(, )
plt.ylim(, )

Para hacer zoom

                                Números reales

Los números reales son cualquier número que corresponda a un punto en la recta real y pueden clasificarse en números naturales, enteros, racionales e irracionales. En otras palabras, cualquier número real está comprendido entre menos infinito y más infinito y podemos representarlo en la recta real.

  • Números naturales: Los números naturales es el primer conjunto de números que aprendemos de pequeños. Este conjunto no tiene en cuenta el número cero (0) excepto que se especifique lo contrario (cero neutral). Se representa los números naturales con la letra “N”, ejemplo: 1,2,3,4…

  • Números enteros: Los números enteros son todos los números naturales e incluyen el cero (0) y todos los números negativos. Se representan los números enteros con la letra “Z”, ejemplo: -3,-2,-1,0,1,2,3…

  • Números Racionales: Los números racionales son las fracciones que pueden formarse a partir de los números enteros y naturales. Entendemos las fracciones como cocientes de números enteros. Se representan los números racionales con la letra “Q”, ejemplo 8/2, -7/5, 2/3, 17/-1…

  • Números irracionales: Los números irracionales son números decimales que no pueden expresarse ni de manera exacta ni de manera periódica. Se representan los números irracionales con la letra “I”, ejemplo π, Φ, є…

Un pequeño resumen de la lectura recomendada, espero les sirva compañeros. Saludos

Google colab + python excelentes herramientas para poder entender mejor el tema y poder ver gráficamente los comportamientos

a mi me gusta utilizar funciones anonimas para graficar funciones.

el codigo quedaria algo asi

_y = lambda m, x, b: m*x + b
_x = np.linspace(-10, 10, 1000)
plt.plot(_x, _y(1, _x, 0))
  • xlim es el límite en el eje x que VEREMOS del plano cartesiano en la gráfica. Por eso parece que hace zoom.
  • Y lo mismo para ylim, solo que para su propio eje.
    .

Aquí les dejo mi código explicando que hace cada cosa.

def f(x):
  return 2*x**8 - x**4 + 3*x**2 + 4

puntos_de_grafica = 100

# Ahora si entiendo que hace linspace.
# Primero, los dos primeros argumentos te dicen el límite del eje x en el que se dibujará tu gráfica, Y el xlim te dice el límite que veremos del plano cartesiano. ¿Lo captas verdad?
# Segundo, al 3er argumento tu le dices cuantas minilineas formará tu gráfica para que se vea mucho más claro. Es como los pixeles, a más pixeles una imagen más nítida, aquí a más minilíneas un gráfico mejor representado y, por ende más exacto.  
x = np.linspace(-10.0, 10.0, num=puntos_de_grafica) 

y = f(x)

# Fig, ax realmente no se que hacen
fig, ax = plt.subplots()

# xlim es el límite en el eje x que VEREMOS del plano cartesiano en la gráfica. Por eso parece que hace zoom. 
# Y lo mismo para ylim, solo que para su propio eje.
plt.xlim(-20, 20)
# Plot hace el gráfico
ax.plot(x,y)
# Grid dibuja los cuadraditos para poder reconocer más fácilmente cada punto de la gráfica
ax.grid()
# axhline dibuja el eje "x" y axvline el eje "y" del plano cartesiano
ax.axhline(y=0, color="k")
ax.axvline(x=0, color="k")

Normal:

With Zoom (+):

With Zoom (-):

import matplotlib.pyplot as plt   # librería para graficar
import numpy as np                # librería para manejo de vectores y utilidades matemáticas

def f(m,x,b):
  return m*x + b 

res = 100

m = 10

b = 5

x = np.linspace(-10.0,10.0, num = res)

y = f(m,x,b)

fig,ax = plt.subplots()
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color="r")
ax.axvline(x=0, color="r")

Para hacer zoom en la grafica solo debemos poner

ax.margins()

y dentro de los parentesis poner los parametros que deseemos

ax.margins(x=0.10, y=1)

👾

Comportamiento de las funciones cuadradas

para poder hacer “zoom” en matlplotlib se deben cambiar los margenes de los axis ax.margins(x=-0.1, y=1)

def f(x):
    return 2*x**8 - x**4 + 3*x**2 + 4

res = 100

x = np.linspace(-10.0, 10.0, num=res)

y = f(x)

fig, ax = plt.subplots()

ax.margins(x=-0.1, y=1)
ax.plot(x, y)
ax.grid()
# ax.axhline(y=0, color='r')
ax.axvline(x=0, color='r')
plt.show()
plt.xlim()
plt.ylim()

Acepta una tupla como parámetro y dependiendo de lo que le pases es lo que te mostrará al gráfico.

Por si no les quedó bien claro que es lo que hace linspace, pueden ver este video que explica super bien
https://www.youtube.com/watch?v=9bHtS2tTLjI&ab_channel=PyPros

Les paso este video. A mí me ayudó mucho a entender QUE ES UNA PENDIENTE y la utilidad de la ecuación para sacar m y como esta ayuda a calcular la pendiente.

https://www.youtube.com/watch?v=44z-uD5lR-0

Para hacer el zoom se usa:
plt.xlim([0,25]) # Aquí van los límites donde quieres hacer le zoom
plt.ylim([-.1,.1]) # Aquí van los límites donde quieres hacer le zoom
plt.show()

Saludos

De que sirve la variable res?
estuve cambiando sus datos y hasta la elimine, pero no veo cambio alguno en la grafica?

Hola compañeros, les comparto mi código utilizando los métodos plt.xlim y plt.ylim

import matplotlib.pyplot as plt
import numpy as np


def funcion(m,x,b):
  return 2*x**8 - x**4 + 3*x**2 + 4

res = 100

x = np.linspace (-10.0, 10.0, num=res)

y= funcion(m,x,b)

fig, ax = plt.subplots()

ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color ='r')
ax.axvline(x=0, color = 'r')
plt.xlim(0, 20)
plt.ylim(0, 20)```

Solo un pequeño detalle, la a final debería tener un subindice 0, en vez del 1

También es interesante ver como se comporta la función de grado 7 haciendo zoom entre -6 < x < 6 y -6 < y < 6

Use las funciones plt.xlim() y plt.ylim(). En la función lineal funcionó perfecto pero en el polinomio no me función ylim, simplemente desaparece la linea de la función.

def f(x):
  return 2*x**8 - x**4 + 3*x**2 + 4

res = 100 #Resolution

x = np.linspace(-10.0,10.0,num=res)

y = f(x)

fig, ax = plt.subplots()
plt.xlim(-7.5,-5)
#plt.ylim(0,0.25)
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color = 'r')
ax.axvline(x=0, color = 'r')

En la grafica de polinomios le agregue algunos parametros a la funcion como el numero de coeficiente y el grado del polinomio y dentro de la misma funcion ploteo la grafica:

Código:

def polinomio(coeficiente:int, x, grado_polinomio:int):
  if coeficiente == 0:
    coeficiente = 1
  x = np.arange(-10, 10, 2)
  y = ((coeficiente) * (x) ** (grado_polinomio))
  plt.plot(x, y, 'r--', label=f"y = {coeficiente}x^{grado_polinomio}")
  plt.grid()
  plt.axhline(x.all(), color="green")
  plt.axvline(y.all(), color="green")
  plt.ylim(-100, 100)
  plt.xlim(-100, 100)
  plt.legend()
  plt.title(f"Grafica del polinomio de grado {grado_polinomio}")
  return plt.show()
polinomio(2, x, 3)

Resultado:

Comparto mi gráfica lineal le puse un legend con un label que indica la ecuación de la linea trazada sobre el plot

Código:

import matplotlib.pyplot as plt   # librería para graficar
import numpy as np                # librería para manejo de vectores y utilidades matemáticas

# vamos  a crear una funcion que retorna la formula de la funcion lineal
def lineal(m, x, b):
  return  m * x + b

m = 2
b = 0
x = np.arange(-10, 10, 2)
y = lineal(m, x, b)
plt.plot(x, y, 'mo--', label=f'y={m}x+{b}')
plt.grid()
plt.title(f"Grafica de la ecuación lineal y = {m}x + {b}")
plt.xlabel('eje x', color='#1C2833')
plt.ylabel('eje y', color='#1C2833')
plt.legend(loc='upper left') # esto nos mostrara el label que le mandamos como param al plot()
# ahora trazaremos las lineas del eje (y) y eje (x) con axhline() y axvline()
plt.axhline(x.all())
plt.axvline(y.all())
plt.xlim(-25, 25)
plt.ylim(-25, 25)

Resultado o Plot:

Para que tus formulas matematicas se vean geniales usa LaTex

Interesante clase, maravillosos conceptos y una gran herramienta.

Hola, en el documento adjunto simbolos-matematicos.pdf en las descripciones del alfabeto griego, la descripción de pi considero que debe ser revisado debido a que aparentemente esta fuera de contexto parte de la descripción, cito:
“pi, que habitualmente representa el numero irracional que mujer la relación…”
Intente encontrar la forma de enviarle un mensaje privado para resolver esto de forma mas interna debido a que debe ser un error de tipeo, pero no encontré la forma.

`def f(x):
return 2x8 - x4 + 3x**2 + 4

res = 100

x = np.linspace(-10.0, 10.0, num=res)
y = f(x)

fig, ax = plt.subplots()
plt.xlim(-2.5,2.5)
plt.ylim(0,25)
ax.plot(x,y)
ax.grid()
ax.axhline(y=0, color=‘r’)
ax.axvline(x=0, color=‘r’)`

Punto de corte de en el polinomio de grado 7 en (0,4)

plt.xlim(-5,5)
plt.ylim(3.5,4.5)```