Script Programming(스크립트 프로그래밍)

from mpl_toolkits.mplot3d.axes3d import Axes3D
import matplotlib.pyplot as plt

# imports specific to the plots in this example
import numpy as np
from matplotlib import cm

# Twice as wide as it is tall.
fig = plt.figure(figsize=plt.figaspect(0.7))

#---- First subplot
ax = fig.add_subplot(111, projection='3d')
X = np.arange(-2*np.pi, 2*np.pi, 0.05)
Y = np.arange(-2*np.pi, 2*np.pi, 0.05)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R) / R
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet,
        linewidth=0, antialiased=False)
ax.set_zlim3d(-1.01, 1.01)

fig.colorbar(surf, shrink=0.5, aspect=10)

plt.show()

import matplotlib
import numpy as np
from matplotlib.pyplot import figure, show, rc, grid

# radar green, solid grid lines
rc('grid', color='#316931', linewidth=1, linestyle='-')
rc('xtick', labelsize=15)
rc('ytick', labelsize=15)

# force square figure and square axes looks better for polar, IMO
width, height = matplotlib.rcParams['figure.figsize']
size = min(width, height)
# make a square figure
fig = figure(figsize=(size, size))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True, axisbg='#d5de9c')
# ax = fig.add_axes([-2, -2, 2, 2], polar=True, axisbg='#d5de9c')

delta = 0.01
startAngle = 0.0
lastAngle = 2*np.pi
theta = np.arange(startAngle, lastAngle, 0.01)
a = 1
b = 1
r = a - b*np.cos(theta)
ax.plot(theta, r, color='#ee8d18', lw=3)
ax.set_rmax(2.1)
grid(True)

ax.set_title("Cardioid", fontsize=20)
show()

#!/usr/bin/env python

"""
An example which plots the graph of an implicit function.
         Plot the lemniscate.
"""

import matplotlib
import numpy as np
import matplotlib.pyplot as plt

delta = 0.01
x = np.arange(-1.1, 1.1, delta)
y = np.arange(-1.1, 1.1, delta)
X, Y = np.meshgrid(x, y)
Z = (X**2 + Y**2)**2 - X**2 + Y**2

# Set negative contours to be solid iine.
matplotlib.rcParams['contour.negative_linestyle'] = 'solid'
plt.figure()
CS = plt.contour(X, Y, Z, 1, colors='k')
plt.title("Lemniscate")

plt.show()

#!/usr/bin/env python

"""
An example which plots the graph of an implicit function.
         Plot the lemniscate.
"""

import matplotlib
import numpy as np
import matplotlib.pyplot as plt

delta = 0.01
x = np.arange(-1.1, 1.1, delta)
y = np.arange(-1.1, 1.1, delta)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)
T = np.arctan(Y/X)
Z = R**2 - np.cos(2*T)

# Set negative contours to be solid iine.
matplotlib.rcParams['contour.negative_linestyle'] = 'solid'
plt.figure()
CS = plt.contour(X, Y, Z, 1, colors='k')
plt.title("Lemniscate")

plt.show()

#!/usr/bin/env python

import math
from pylab import *
import matplotlib.pyplot as plt
import matplotlib.lines as lines

def make_xaxis(ax, yloc, offset=0.05, **props):
    xmin, xmax = ax.get_xlim()
    locs = [loc for loc in ax.xaxis.get_majorticklocs()
            if loc>=xmin and loc<=xmax]
    tickline, = ax.plot(locs, [yloc]*len(locs),linestyle='',
            marker=lines.TICKDOWN, **props)
    axline, = ax.plot([xmin, xmax], [yloc, yloc], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)
    for loc in locs:
        ax.text(loc, yloc-offset, '%1.1f'%loc,
                horizontalalignment='center',
                verticalalignment='top')

def make_yaxis(ax, xloc=0, offset=0.05, **props):
    ymin, ymax = ax.get_ylim()
    locs = [loc for loc in ax.yaxis.get_majorticklocs()
            if loc>=ymin and loc<=ymax]
    tickline, = ax.plot([xloc]*len(locs), locs, linestyle='',
            marker=lines.TICKLEFT, **props)
    axline, = ax.plot([xloc, xloc], [ymin, ymax], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)

    for loc in locs:
        ax.text(xloc-offset, loc, '%1.1f'%loc,
                verticalalignment='center',
                horizontalalignment='right')

fig = plt.figure(facecolor='white')
ax = fig.add_subplot(111, frame_on=False)

props = dict(color='black', linewidth=2, markeredgewidth=2)
ax.axison = False
ax.set_xlim(-4, 4)
ax.set_ylim(-1, 2)
make_xaxis(ax, 0, offset=0.2, **props)
make_yaxis(ax, 0, offset=0.5, **props)

x = arange(-4.0, -0.01, 0.01)
a = x * sin(1 / x)
a1 = x
a2 = -x
ax.plot(x, a,'b-',  x, a1,'k--',  x, a2,'k--')

t = arange(0.01, 4.0, 0.01)
b = t * sin(1 / t)
b1 = t
b2 = -t
ax.plot(t, b,'b-',  t, b1,'k--',  t, b2,'k--')

grid(True)
xlabel('----> x')
ylabel('----> y')

title('The graph of y = x sin(1/x)')

# plot the colored markers on the graph
# ax.plot(t, b, 'd', markersize=3, markerfacecolor='blue')
# ax.plot(x, a, 'd', markersize=3, markerfacecolor='red')

# set the rectangular range to be viewed.
plt.axis([-4, 4, -1.0, 1.5])

plt.show()

import math
from pylab import *
import matplotlib.pyplot as plt
import matplotlib.lines as lines

def make_xaxis(ax, yloc, offset=0.05, **props):
    xmin, xmax = ax.get_xlim()
    locs = [loc for loc in ax.xaxis.get_majorticklocs()
            if loc>=xmin and loc<=xmax]
    tickline, = ax.plot(locs, [yloc]*len(locs),linestyle='',
            marker=lines.TICKDOWN, **props)
    axline, = ax.plot([xmin, xmax], [yloc, yloc], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)
    for loc in locs:
        ax.text(loc, yloc-offset, '%1.1f'%loc,
                horizontalalignment='center',
                verticalalignment='top')

def make_yaxis(ax, xloc=0, offset=0.05, **props):
    ymin, ymax = ax.get_ylim()
    locs = [loc for loc in ax.yaxis.get_majorticklocs()
            if loc>=ymin and loc<=ymax]
    tickline, = ax.plot([xloc]*len(locs), locs, linestyle='',
            marker=lines.TICKLEFT, **props)
    axline, = ax.plot([xloc, xloc], [ymin, ymax], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)

    for loc in locs:
        ax.text(xloc-offset, loc, '%1.1f'%loc,
                verticalalignment='center',
                horizontalalignment='right')

fig = plt.figure(facecolor='white')
ax = fig.add_subplot(111, frame_on=False)

props = dict(color='black', linewidth=2, markeredgewidth=2)
ax.axison = False
ax.set_xlim(-20, 20)
ax.set_ylim(-1, 2)
make_xaxis(ax, 0, offset=0.2, **props)
make_yaxis(ax, 0, offset=0.5, **props)

x = arange(-20.0, -0.01, 0.01)
a = sin(x) / x
a1 = - 1 / x
ax.plot(x, a,'b-',  x, a1,'k--')

t = arange(0.01, 20.0, 0.01)
b = sin(t) / t
b1 = 1 / t
ax.plot(x, a,'b-',  x, a1,'k--', t, b,'b-',  t, b1,'k--')

grid(True)
xlabel('----> x')
ylabel('----> y')

title('The graph of y = sin(x) / x')

# plot the colored markers on the graph
# ax.plot(t, b, 'd', markersize=3, markerfacecolor='blue')
# ax.plot(x, a, 'd', markersize=3, markerfacecolor='red')

# set the rectangular range to be viewed.
plt.axis([-20, 20, -1.0, 2.0])

plt.show()

set term aqua
set xrange[-1:9] 
set yrange[-1:4]
set isosamples 250
set view map
unset surface
set hidden3d
set key outside
set contour base
set title "cycloid by plotting contour"
splot x - acos(1 - y) + sqrt(2*y - y**2) 

import math
from pylab import *
import matplotlib.pyplot as plt
import matplotlib.lines as lines

def make_xaxis(ax, yloc, offset=0.05, **props):
    xmin, xmax = ax.get_xlim()
    locs = [loc for loc in ax.xaxis.get_majorticklocs()
            if loc>=xmin and loc<=xmax]
    tickline, = ax.plot(locs, [yloc]*len(locs),linestyle='',
            marker=lines.TICKDOWN, **props)
    axline, = ax.plot([xmin, xmax], [yloc, yloc], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)
    for loc in locs:
        ax.text(loc, yloc-offset, '%1.1f'%loc,
                horizontalalignment='center',
                verticalalignment='top')

def make_yaxis(ax, xloc=0, offset=0.05, **props):
    ymin, ymax = ax.get_ylim()
    locs = [loc for loc in ax.yaxis.get_majorticklocs()
            if loc>=ymin and loc<=ymax]
    tickline, = ax.plot([xloc]*len(locs), locs, linestyle='',
            marker=lines.TICKLEFT, **props)
    axline, = ax.plot([xloc, xloc], [ymin, ymax], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)

    for loc in locs:
        ax.text(xloc-offset, loc, '%1.1f'%loc,
                verticalalignment='center',
                horizontalalignment='right')

fig = plt.figure(facecolor='white')
ax = fig.add_subplot(111, frame_on=False)

props = dict(color='black', linewidth=2, markeredgewidth=2)
ax.axison = False
ax.set_xlim(-2, 3*pi)
ax.set_ylim(-1, 5)
make_xaxis(ax, 0, offset=0.2, **props)
make_yaxis(ax, 0, offset=0.5, **props)

y = arange(0.0, 2., 0.01)
x = arccos(1 - y) - sqrt(2*y - y**2)
ax.plot(x, y, 'b-')

grid(True)
xlabel('----> x')
ylabel('----> y')

title('A cycloid : the graph of x = arccos(1 - y) - sqrt(2y -y^2)')

# plot the colored markers on the graph
# ax.plot(t, b, 'd', markersize=3, markerfacecolor='blue')
# ax.plot(x, a, 'd', markersize=3, markerfacecolor='red')

# set the rectangular range to be viewed.
plt.axis([-2, 3*pi, -1.0, 5.0])

plt.show()

#!/usr/bin/env python

"""
An example which plots the parametirized curve.
         Plot a cycloid..
"""

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure, show, rc, title
import matplotlib.lines as mlines

# radar green, solid grid lines
rc('grid', color='#316931', linewidth=1, linestyle='-')
rc('xtick', labelsize=15)
rc('ytick', labelsize=15)

# force square figure and square axes looks better for polar, IMO
fig = figure(figsize=(8,8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=False, axisbg='#d5de9c')

plt.axvline(x=0, color='black')
plt.axhline(y=0, color='black')
plt.axvline(x=np.pi, color='silver')
plt.axvline(x=2*np.pi, color='silver')
plt.axvline(x=3*np.pi, color='silver')
plt.axvline(x=4*np.pi, color='silver')
plt.axhline(y=2, color='silver')

t = np.arange(0.0, 3.5*np.pi, 0.05)

a = 1
x = a*(t - np.sin(t))
y = a*(1 - np.cos(t))

ax.set_xlim(-0.5, 4*np.pi)
ax.set_ylim(-1, 4)
ax.plot(x, y, color='#ee8d18', lw=3, label='cycloid')
ax.legend()

title("cycloid")
show()

#!/usr/bin/env python

"""
An example which plots the parametirized curve.
         Plot the Descartes' folium.
"""

import numpy as np
from matplotlib.pyplot import figure, show, rc, title

# radar green, solid grid lines
rc('grid', color='#316931', linewidth=1, linestyle='-')
rc('xtick', labelsize=15)
rc('ytick', labelsize=15)

# force square figure and square axes looks better for polar, IMO
fig = figure(figsize=(8,8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=False, axisbg='#d5de9c')

t = np.arange(0.0, 27.0, 0.05)
x =3*t/(1 + t**3)
y =3*t**2/(1 + t**3)
ax.plot(x, y, color='#ee8d18', lw=3, label='a line')
ax.legend()

t = np.arange(-18, -1.15, 0.05)
x =3*t/(1 + t**3)
y =3*t**2/(1 + t**3)
ax.plot(x, y, color='#ee8d18', lw=3, label='a line')

t = np.arange(-0.82, 0.01, 0.05)
x =3*t/(1 + t**3)
y =3*t**2/(1 + t**3)
ax.plot(x, y, color='#ee8d18', lw=3, label='a line')
# ax.legend()

title("Descartes' folium")
show()

#!/usr/bin/env python

import math
from pylab import *
import matplotlib.pyplot as plt
import matplotlib.lines as lines

def make_xaxis(ax, yloc, offset=0.05, **props):
    xmin, xmax = ax.get_xlim()
    locs = [loc for loc in ax.xaxis.get_majorticklocs()
            if loc>=xmin and loc<=xmax]
    tickline, = ax.plot(locs, [yloc]*len(locs),linestyle='',
            marker=lines.TICKDOWN, **props)
    axline, = ax.plot([xmin, xmax], [yloc, yloc], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)
    for loc in locs:
        ax.text(loc, yloc-offset, '%1.1f'%loc,
                horizontalalignment='center',
                verticalalignment='top')

def make_yaxis(ax, xloc=0, offset=0.05, **props):
    ymin, ymax = ax.get_ylim()
    locs = [loc for loc in ax.yaxis.get_majorticklocs()
            if loc>=ymin and loc<=ymax]
    tickline, = ax.plot([xloc]*len(locs), locs, linestyle='',
            marker=lines.TICKLEFT, **props)
    axline, = ax.plot([xloc, xloc], [ymin, ymax], **props)
    tickline.set_clip_on(False)
    axline.set_clip_on(False)

    for loc in locs:
        ax.text(xloc-offset, loc, '%1.1f'%loc,
                verticalalignment='center',
                horizontalalignment='right')

fig = plt.figure(facecolor='white')
ax = fig.add_subplot(111, frame_on=False)

props = dict(color='black', linewidth=2, markeredgewidth=2)
ax.axison = False
ax.set_xlim(-10, 10)
ax.set_ylim(-1, 10)
make_xaxis(ax, 0, offset=0.2, **props)
make_yaxis(ax, 0, offset=0.5, **props)

x = arange(-10.0, -0.01, 0.01)
a = exp(1/x)
a1 = 0*x + 1

t = arange(0.01, 10.0, 0.01)
b = exp(1/t)
b1 = 0*x + 1
ax.plot(x, a,'b-',  x, a1,'k--',  t, b, 'b-',  t, b1, 'k--')

grid(True)
xlabel('----> x')
ylabel('----> y')

title('The graph of y = exp(1/x)')

# plot the colored markers on the graph
# ax.plot(t, b, 'd', markersize=3, markerfacecolor='blue')
# ax.plot(x, a, 'd', markersize=3, markerfacecolor='red')

# set the rectangular range to be viewed.
plt.axis([-10, 10, -1.0, 10.0])

plt.show()

#! /usr/local/bin/python    <- The UNIX she-bang
# coding: MS949

#  Filename: seventhGraph.py
#
#  2011/09/10 Sat.    Modified by PHKim
#
# See: http://www.schockwellenreiter.de/pythonmania/pybutt.html

import Tkinter
import Canvas
import math    # for the exp function
import sys           # for sys.exit(0)   
from Tkconstants import *

class SeventhExponentialGraph:
   def __init__(self, master = None):
   self.canvas = Tkinter.Canvas(master, relief = RIDGE, bd = 2, bg = "white",
         width = 400, height = 400)
   self.canvas.pack()
  
   self.button = Tkinter.Button(master, text = " Draw ", command = self.draw)
   self.button.pack(side = BOTTOM, pady = 4)

   def make_xaxis(self, startx, endx, yloc, initx, deltax, offset=1, gap=20):
           i = initx
           px =startx
           while px < endx:
          self.canvas.create_line(px, yloc-3, px, yloc + 3, fill='black', width=1)
          if i != 0:
                   self.canvas.create_text(px, yloc-3 + offset + 12, text="%d" % i, fill='magenta')
          else:
                   self.canvas.create_text(px - 6, yloc-3 + offset + 12, text="%d" % i, fill='magenta')
               i = i + deltax
               px = px + gap

   def make_yaxis(self, starty, endy, xloc, inity, deltay, offset=-1, gap=20):
           i = inity
           py =starty
           while py < endy:
          self.canvas.create_line(xloc-3, py, xloc+3, py, fill='black', width=1)
          if i != 0:
              self.canvas.create_text(xloc-3 + offset + 2, py, text="%d" % i, fill='darkgreen')
               i = i + deltay
               py = py + gap

   def draw(self):
   self.canvas.create_line(0, 200, 440, 200, fill='black', width=2)
   self.canvas.create_line(200, 0, 200, 440, fill='black', width=2)
   self.canvas.create_line(0, 200-20, 440, 200-20, fill='gray', width=1)

   self.make_xaxis(0, 400, 200, -10, 1, 0.05, 20)
   self.make_yaxis(0, 400, 200, -10, 1, -10, 20)

   delta = 0.01
   t  = -10.0
   while t <= 0.01:
       # Draw the left part in the second quadrant
       x = t
       y = math.exp(1/x)
       xx = (x*20) + 200  # 20 pixel is the unit 1
       yy =  200 -  (y*20)              # 400 x 400 is the size of the drawing region
       if (t== -10.0):
       Canvas.Line(self.canvas, xx, yy, xx, yy, fill="blue", width=2)
       else:
       Canvas.Line(self.canvas, xOld, yOld, xx, yy, fill="blue", width=2)
       self.canvas.update_idletasks()
       xOld = xx
       yOld = yy
       t = t + delta

   delta = 0.01
   t  = 0.01
   while t <= 10+0.1:
       # Draw the right part in the first quadrant
       x = t
       y = math.exp(1/x)
       xx = (x*20) + 200  # 20 pixel is the unit 1
       yy =  200 -  (y*20)              # 400 x 400 is the size of the drawing region
       if (t== -10.0):
       Canvas.Line(self.canvas, xx, yy, xx, yy, fill="blue", width=2)
       else:
       Canvas.Line(self.canvas, xOld, yOld, xx, yy, fill="blue", width=2)
       self.canvas.update_idletasks()
       xOld = xx
       yOld = yy
       t = t + delta

   self.button.config(text = " Quit ", command = self.exit)
   self.canvas.update_idletasks()

   def exit(self):
   sys.exit(0)

if __name__ == "__main__":
   root = Tkinter.Tk()
   root.title("The curve of y = exp(1/x)")
 
   SeventhExponentialGraph(root)
   root.mainloop()

import matplotlib.pyplot as plt
import numpy as np

theta = np.arange(0., 48., 1./360.)*np.pi
r = np.exp(np.cos(theta)) - 2*np.cos(4*theta) + np.sin(theta/12)**5
plt.polar(theta + np.pi/2, r);

plt.thetagrids(range(45, 360, 90));
plt.rgrids(np.arange(1.0, 6.1, 1), angle=0);

plt.show()

#! /usr/local/bin/python    <- The UNIX "pound bang hack" (auch she-bang).
# coding: MS949

#                              auf dem Mac bedeutunglos :-)
#  Filename: butterfly.py
#  ⓒ 1999 by Jorg Kantel
#
#  2011 Modified by PH Kim
#
# See: http://www.schockwellenreiter.de/pythonmania/pybutt.html

import Tkinter
import Canvas
import math    # fur die Sinus- und Kosinus-Funktionen
import sys           # fur sys.exit(0)   
from Tkconstants import *

class Butterfly:
   def __init__(self, master = None):
   self.canvas = Tkinter.Canvas(master, relief = RIDGE, bd = 2, bg = "white",
         width = 400, height = 400)
   self.canvas.pack()
  
   self.button = Tkinter.Button(master, text = " Draw ", command = self.draw)
   # Der Button soll nicht am unteren Rand "kleben", daher werden oben und
   # unten vier Pixel Rand angefugt.
   self.button.pack(side = BOTTOM, pady = 4)

   def draw(self):
   self.canvas.create_oval(160, 160, 240, 240, outline="black", width=1)
   self.canvas.create_oval(120, 120, 280, 280, outline="black", width=1)
   self.canvas.create_oval(80, 80, 320, 320, outline="black", width=1)
   self.canvas.create_oval(40, 40, 360, 360, outline="black", width=1)
   self.canvas.create_oval(0, 0, 400, 400, outline="black", width=1)
   theta  = 0.0
   while theta < 75.39:
       r = math.exp(math.sin(theta)) - 2*math.cos(4*theta) + (math.sin((2*theta - math.pi)/24))**5
       # aus Polarkoordinaten konvertieren:
       x = r*math.cos(theta)
       y =r*math.sin(theta)
       xx = (x*40) + 200  # auf Canvas-Große skalieren
       yy =  400 -  ((y*40) + 200)     # 400 is height of the region (Modified)
       if (theta == 0.0):
       Canvas.Line(self.canvas, xx, yy, xx, yy, fill="blue")
       else:
       Canvas.Line(self.canvas, xOld, yOld, xx, yy, fill="blue")
       self.canvas.update_idletasks()
       xOld = xx
       yOld = yy
       theta = theta + 0.01

   self.button.config(text = " Quit ", command = self.exit)
   self.canvas.update_idletasks()
   self.button.config(text = " Quit ", command = self.exit)

   def exit(self):
   sys.exit(0)

if __name__ == "__main__":
   # Dies ist nur, damit der Titel angezeigt wird ;-)
   root = Tkinter.Tk()
   # root.title("Butterfly Curve")
   root.title("Fay's Butterfly Curve")
 
   # Erzeuge eine neue Instanz unserer Schmetterlingsklasse ...
   butterfly = Butterfly(root)
   # ... und bringe sie zum Laufen.
   root.mainloop()