14010808/14010808.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2a337479",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4, 9)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = 2\n",
    "n = 3\n",
    "o = 4\n",
    "min(m,n,o), max(m,n,o), m+n+o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1af9e684",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "080d7069",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'turtle' from '/usr/lib/python3.10/turtle.py'>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import turtle\n",
    "turtle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c798289f",
   "metadata": {},
   "outputs": [],
   "source": [
    "bob = turtle.Turtle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8bd71d53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Turtle in module turtle object:\n",
      "\n",
      "class Turtle(RawTurtle)\n",
      " |  Turtle(shape='classic', undobuffersize=1000, visible=True)\n",
      " |  \n",
      " |  RawTurtle auto-creating (scrolled) canvas.\n",
      " |  \n",
      " |  When a Turtle object is created or a function derived from some\n",
      " |  Turtle method is called a TurtleScreen object is automatically created.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Turtle\n",
      " |      RawTurtle\n",
      " |      TPen\n",
      " |      TNavigator\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, shape='classic', undobuffersize=1000, visible=True)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from RawTurtle:\n",
      " |  \n",
      " |  begin_fill(self)\n",
      " |      Called just before drawing a shape to be filled.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.color(\"black\", \"red\")\n",
      " |      >>> turtle.begin_fill()\n",
      " |      >>> turtle.circle(60)\n",
      " |      >>> turtle.end_fill()\n",
      " |  \n",
      " |  begin_poly(self)\n",
      " |      Start recording the vertices of a polygon.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Start recording the vertices of a polygon. Current turtle position\n",
      " |      is first point of polygon.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.begin_poly()\n",
      " |  \n",
      " |  clear(self)\n",
      " |      Delete the turtle's drawings from the screen. Do not move turtle.\n",
      " |      \n",
      " |      No arguments.\n",
      " |      \n",
      " |      Delete the turtle's drawings from the screen. Do not move turtle.\n",
      " |      State and position of the turtle as well as drawings of other\n",
      " |      turtles are not affected.\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.clear()\n",
      " |  \n",
      " |  clearstamp(self, stampid)\n",
      " |      Delete stamp with given stampid\n",
      " |      \n",
      " |      Argument:\n",
      " |      stampid - an integer, must be return value of previous stamp() call.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.color(\"blue\")\n",
      " |      >>> astamp = turtle.stamp()\n",
      " |      >>> turtle.fd(50)\n",
      " |      >>> turtle.clearstamp(astamp)\n",
      " |  \n",
      " |  clearstamps(self, n=None)\n",
      " |      Delete all or first/last n of turtle's stamps.\n",
      " |      \n",
      " |      Optional argument:\n",
      " |      n -- an integer\n",
      " |      \n",
      " |      If n is None, delete all of pen's stamps,\n",
      " |      else if n > 0 delete first n stamps\n",
      " |      else if n < 0 delete last n stamps.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> for i in range(8):\n",
      " |      ...     turtle.stamp(); turtle.fd(30)\n",
      " |      ...\n",
      " |      >>> turtle.clearstamps(2)\n",
      " |      >>> turtle.clearstamps(-2)\n",
      " |      >>> turtle.clearstamps()\n",
      " |  \n",
      " |  clone(self)\n",
      " |      Create and return a clone of the turtle.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Create and return a clone of the turtle with same position, heading\n",
      " |      and turtle properties.\n",
      " |      \n",
      " |      Example (for a Turtle instance named mick):\n",
      " |      mick = Turtle()\n",
      " |      joe = mick.clone()\n",
      " |  \n",
      " |  dot(self, size=None, *color)\n",
      " |      Draw a dot with diameter size, using color.\n",
      " |      \n",
      " |      Optional arguments:\n",
      " |      size -- an integer >= 1 (if given)\n",
      " |      color -- a colorstring or a numeric color tuple\n",
      " |      \n",
      " |      Draw a circular dot with diameter size, using color.\n",
      " |      If size is not given, the maximum of pensize+4 and 2*pensize is used.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.dot()\n",
      " |      >>> turtle.fd(50); turtle.dot(20, \"blue\"); turtle.fd(50)\n",
      " |  \n",
      " |  end_fill(self)\n",
      " |      Fill the shape drawn after the call begin_fill().\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.color(\"black\", \"red\")\n",
      " |      >>> turtle.begin_fill()\n",
      " |      >>> turtle.circle(60)\n",
      " |      >>> turtle.end_fill()\n",
      " |  \n",
      " |  end_poly(self)\n",
      " |      Stop recording the vertices of a polygon.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Stop recording the vertices of a polygon. Current turtle position is\n",
      " |      last point of polygon. This will be connected with the first point.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.end_poly()\n",
      " |  \n",
      " |  filling(self)\n",
      " |      Return fillstate (True if filling, False else).\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.begin_fill()\n",
      " |      >>> if turtle.filling():\n",
      " |      ...     turtle.pensize(5)\n",
      " |      ... else:\n",
      " |      ...     turtle.pensize(3)\n",
      " |  \n",
      " |  get_poly(self)\n",
      " |      Return the lastly recorded polygon.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> p = turtle.get_poly()\n",
      " |      >>> turtle.register_shape(\"myFavouriteShape\", p)\n",
      " |  \n",
      " |  get_shapepoly(self)\n",
      " |      Return the current shape polygon as tuple of coordinate pairs.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape(\"square\")\n",
      " |      >>> turtle.shapetransform(4, -1, 0, 2)\n",
      " |      >>> turtle.get_shapepoly()\n",
      " |      ((50, -20), (30, 20), (-50, 20), (-30, -20))\n",
      " |  \n",
      " |  getpen = getturtle(self)\n",
      " |  \n",
      " |  getscreen(self)\n",
      " |      Return the TurtleScreen object, the turtle is drawing  on.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Return the TurtleScreen object, the turtle is drawing  on.\n",
      " |      So TurtleScreen-methods can be called for that object.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> ts = turtle.getscreen()\n",
      " |      >>> ts\n",
      " |      <turtle.TurtleScreen object at 0x0106B770>\n",
      " |      >>> ts.bgcolor(\"pink\")\n",
      " |  \n",
      " |  getturtle(self)\n",
      " |      Return the Turtleobject itself.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Only reasonable use: as a function to return the 'anonymous turtle':\n",
      " |      \n",
      " |      Example:\n",
      " |      >>> pet = getturtle()\n",
      " |      >>> pet.fd(50)\n",
      " |      >>> pet\n",
      " |      <turtle.Turtle object at 0x0187D810>\n",
      " |      >>> turtles()\n",
      " |      [<turtle.Turtle object at 0x0187D810>]\n",
      " |  \n",
      " |  onclick(self, fun, btn=1, add=None)\n",
      " |      Bind fun to mouse-click event on this turtle on canvas.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      fun --  a function with two arguments, to which will be assigned\n",
      " |              the coordinates of the clicked point on the canvas.\n",
      " |      btn --  number of the mouse-button defaults to 1 (left mouse button).\n",
      " |      add --  True or False. If True, new binding will be added, otherwise\n",
      " |              it will replace a former binding.\n",
      " |      \n",
      " |      Example for the anonymous turtle, i. e. the procedural way:\n",
      " |      \n",
      " |      >>> def turn(x, y):\n",
      " |      ...     left(360)\n",
      " |      ...\n",
      " |      >>> onclick(turn)  # Now clicking into the turtle will turn it.\n",
      " |      >>> onclick(None)  # event-binding will be removed\n",
      " |  \n",
      " |  ondrag(self, fun, btn=1, add=None)\n",
      " |      Bind fun to mouse-move event on this turtle on canvas.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      fun -- a function with two arguments, to which will be assigned\n",
      " |             the coordinates of the clicked point on the canvas.\n",
      " |      btn -- number of the mouse-button defaults to 1 (left mouse button).\n",
      " |      \n",
      " |      Every sequence of mouse-move-events on a turtle is preceded by a\n",
      " |      mouse-click event on that turtle.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.ondrag(turtle.goto)\n",
      " |      \n",
      " |      Subsequently clicking and dragging a Turtle will move it\n",
      " |      across the screen thereby producing handdrawings (if pen is\n",
      " |      down).\n",
      " |  \n",
      " |  onrelease(self, fun, btn=1, add=None)\n",
      " |      Bind fun to mouse-button-release event on this turtle on canvas.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      fun -- a function with two arguments, to which will be assigned\n",
      " |              the coordinates of the clicked point on the canvas.\n",
      " |      btn --  number of the mouse-button defaults to 1 (left mouse button).\n",
      " |      \n",
      " |      Example (for a MyTurtle instance named joe):\n",
      " |      >>> class MyTurtle(Turtle):\n",
      " |      ...     def glow(self,x,y):\n",
      " |      ...             self.fillcolor(\"red\")\n",
      " |      ...     def unglow(self,x,y):\n",
      " |      ...             self.fillcolor(\"\")\n",
      " |      ...\n",
      " |      >>> joe = MyTurtle()\n",
      " |      >>> joe.onclick(joe.glow)\n",
      " |      >>> joe.onrelease(joe.unglow)\n",
      " |      \n",
      " |      Clicking on joe turns fillcolor red, unclicking turns it to\n",
      " |      transparent.\n",
      " |  \n",
      " |  reset(self)\n",
      " |      Delete the turtle's drawings and restore its default values.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Delete the turtle's drawings from the screen, re-center the turtle\n",
      " |      and set variables to the default values.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.position()\n",
      " |      (0.00,-22.00)\n",
      " |      >>> turtle.heading()\n",
      " |      100.0\n",
      " |      >>> turtle.reset()\n",
      " |      >>> turtle.position()\n",
      " |      (0.00,0.00)\n",
      " |      >>> turtle.heading()\n",
      " |      0.0\n",
      " |  \n",
      " |  settiltangle(self, angle)\n",
      " |      Rotate the turtleshape to point in the specified direction\n",
      " |      \n",
      " |      Argument: angle -- number\n",
      " |      \n",
      " |      Rotate the turtleshape to point in the direction specified by angle,\n",
      " |      regardless of its current tilt-angle. DO NOT change the turtle's\n",
      " |      heading (direction of movement).\n",
      " |      \n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape(\"circle\")\n",
      " |      >>> turtle.shapesize(5,2)\n",
      " |      >>> turtle.settiltangle(45)\n",
      " |      >>> stamp()\n",
      " |      >>> turtle.fd(50)\n",
      " |      >>> turtle.settiltangle(-45)\n",
      " |      >>> stamp()\n",
      " |      >>> turtle.fd(50)\n",
      " |  \n",
      " |  setundobuffer(self, size)\n",
      " |      Set or disable undobuffer.\n",
      " |      \n",
      " |      Argument:\n",
      " |      size -- an integer or None\n",
      " |      \n",
      " |      If size is an integer an empty undobuffer of given size is installed.\n",
      " |      Size gives the maximum number of turtle-actions that can be undone\n",
      " |      by the undo() function.\n",
      " |      If size is None, no undobuffer is present.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.setundobuffer(42)\n",
      " |  \n",
      " |  shape(self, name=None)\n",
      " |      Set turtle shape to shape with given name / return current shapename.\n",
      " |      \n",
      " |      Optional argument:\n",
      " |      name -- a string, which is a valid shapename\n",
      " |      \n",
      " |      Set turtle shape to shape with given name or, if name is not given,\n",
      " |      return name of current shape.\n",
      " |      Shape with name must exist in the TurtleScreen's shape dictionary.\n",
      " |      Initially there are the following polygon shapes:\n",
      " |      'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.\n",
      " |      To learn about how to deal with shapes see Screen-method register_shape.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape()\n",
      " |      'arrow'\n",
      " |      >>> turtle.shape(\"turtle\")\n",
      " |      >>> turtle.shape()\n",
      " |      'turtle'\n",
      " |  \n",
      " |  shapesize(self, stretch_wid=None, stretch_len=None, outline=None)\n",
      " |      Set/return turtle's stretchfactors/outline. Set resizemode to \"user\".\n",
      " |      \n",
      " |      Optional arguments:\n",
      " |         stretch_wid : positive number\n",
      " |         stretch_len : positive number\n",
      " |         outline  : positive number\n",
      " |      \n",
      " |      Return or set the pen's attributes x/y-stretchfactors and/or outline.\n",
      " |      Set resizemode to \"user\".\n",
      " |      If and only if resizemode is set to \"user\", the turtle will be displayed\n",
      " |      stretched according to its stretchfactors:\n",
      " |      stretch_wid is stretchfactor perpendicular to orientation\n",
      " |      stretch_len is stretchfactor in direction of turtles orientation.\n",
      " |      outline determines the width of the shapes's outline.\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.resizemode(\"user\")\n",
      " |      >>> turtle.shapesize(5, 5, 12)\n",
      " |      >>> turtle.shapesize(outline=8)\n",
      " |  \n",
      " |  shapetransform(self, t11=None, t12=None, t21=None, t22=None)\n",
      " |      Set or return the current transformation matrix of the turtle shape.\n",
      " |      \n",
      " |      Optional arguments: t11, t12, t21, t22 -- numbers.\n",
      " |      \n",
      " |      If none of the matrix elements are given, return the transformation\n",
      " |      matrix.\n",
      " |      Otherwise set the given elements and transform the turtleshape\n",
      " |      according to the matrix consisting of first row t11, t12 and\n",
      " |      second row t21, 22.\n",
      " |      Modify stretchfactor, shearfactor and tiltangle according to the\n",
      " |      given matrix.\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape(\"square\")\n",
      " |      >>> turtle.shapesize(4,2)\n",
      " |      >>> turtle.shearfactor(-0.5)\n",
      " |      >>> turtle.shapetransform()\n",
      " |      (4.0, -1.0, -0.0, 2.0)\n",
      " |  \n",
      " |  shearfactor(self, shear=None)\n",
      " |      Set or return the current shearfactor.\n",
      " |      \n",
      " |      Optional argument: shear -- number, tangent of the shear angle\n",
      " |      \n",
      " |      Shear the turtleshape according to the given shearfactor shear,\n",
      " |      which is the tangent of the shear angle. DO NOT change the\n",
      " |      turtle's heading (direction of movement).\n",
      " |      If shear is not given: return the current shearfactor, i. e. the\n",
      " |      tangent of the shear angle, by which lines parallel to the\n",
      " |      heading of the turtle are sheared.\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape(\"circle\")\n",
      " |      >>> turtle.shapesize(5,2)\n",
      " |      >>> turtle.shearfactor(0.5)\n",
      " |      >>> turtle.shearfactor()\n",
      " |      >>> 0.5\n",
      " |  \n",
      " |  stamp(self)\n",
      " |      Stamp a copy of the turtleshape onto the canvas and return its id.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Stamp a copy of the turtle shape onto the canvas at the current\n",
      " |      turtle position. Return a stamp_id for that stamp, which can be\n",
      " |      used to delete it by calling clearstamp(stamp_id).\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.color(\"blue\")\n",
      " |      >>> turtle.stamp()\n",
      " |      13\n",
      " |      >>> turtle.fd(50)\n",
      " |  \n",
      " |  tilt(self, angle)\n",
      " |      Rotate the turtleshape by angle.\n",
      " |      \n",
      " |      Argument:\n",
      " |      angle - a number\n",
      " |      \n",
      " |      Rotate the turtleshape by angle from its current tilt-angle,\n",
      " |      but do NOT change the turtle's heading (direction of movement).\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape(\"circle\")\n",
      " |      >>> turtle.shapesize(5,2)\n",
      " |      >>> turtle.tilt(30)\n",
      " |      >>> turtle.fd(50)\n",
      " |      >>> turtle.tilt(30)\n",
      " |      >>> turtle.fd(50)\n",
      " |  \n",
      " |  tiltangle(self, angle=None)\n",
      " |      Set or return the current tilt-angle.\n",
      " |      \n",
      " |      Optional argument: angle -- number\n",
      " |      \n",
      " |      Rotate the turtleshape to point in the direction specified by angle,\n",
      " |      regardless of its current tilt-angle. DO NOT change the turtle's\n",
      " |      heading (direction of movement).\n",
      " |      If angle is not given: return the current tilt-angle, i. e. the angle\n",
      " |      between the orientation of the turtleshape and the heading of the\n",
      " |      turtle (its direction of movement).\n",
      " |      \n",
      " |      (Incorrectly marked as deprecated since Python 3.1, it is really\n",
      " |      settiltangle that is deprecated.)\n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.shape(\"circle\")\n",
      " |      >>> turtle.shapesize(5,2)\n",
      " |      >>> turtle.tilt(45)\n",
      " |      >>> turtle.tiltangle()\n",
      " |  \n",
      " |  turtlesize = shapesize(self, stretch_wid=None, stretch_len=None, outline=None)\n",
      " |  \n",
      " |  undo(self)\n",
      " |      undo (repeatedly) the last turtle action.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      undo (repeatedly) the last turtle action.\n",
      " |      Number of available undo actions is determined by the size of\n",
      " |      the undobuffer.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> for i in range(4):\n",
      " |      ...     turtle.fd(50); turtle.lt(80)\n",
      " |      ...\n",
      " |      >>> for i in range(8):\n",
      " |      ...     turtle.undo()\n",
      " |      ...\n",
      " |  \n",
      " |  undobufferentries(self)\n",
      " |      Return count of entries in the undobuffer.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> while undobufferentries():\n",
      " |      ...     undo()\n",
      " |  \n",
      " |  write(self, arg, move=False, align='left', font=('Arial', 8, 'normal'))\n",
      " |      Write text at the current turtle position.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      arg -- info, which is to be written to the TurtleScreen\n",
      " |      move (optional) -- True/False\n",
      " |      align (optional) -- one of the strings \"left\", \"center\" or right\"\n",
      " |      font (optional) -- a triple (fontname, fontsize, fonttype)\n",
      " |      \n",
      " |      Write text - the string representation of arg - at the current\n",
      " |      turtle position according to align (\"left\", \"center\" or right\")\n",
      " |      and with the given font.\n",
      " |      If move is True, the pen is moved to the bottom-right corner\n",
      " |      of the text. By default, move is False.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.write('Home = ', True, align=\"center\")\n",
      " |      >>> turtle.write((0,0), True)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from RawTurtle:\n",
      " |  \n",
      " |  screens = []\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from TPen:\n",
      " |  \n",
      " |  color(self, *args)\n",
      " |      Return or set the pencolor and fillcolor.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      Several input formats are allowed.\n",
      " |      They use 0, 1, 2, or 3 arguments as follows:\n",
      " |      \n",
      " |      color()\n",
      " |          Return the current pencolor and the current fillcolor\n",
      " |          as a pair of color specification strings as are returned\n",
      " |          by pencolor and fillcolor.\n",
      " |      color(colorstring), color((r,g,b)), color(r,g,b)\n",
      " |          inputs as in pencolor, set both, fillcolor and pencolor,\n",
      " |          to the given value.\n",
      " |      color(colorstring1, colorstring2),\n",
      " |      color((r1,g1,b1), (r2,g2,b2))\n",
      " |          equivalent to pencolor(colorstring1) and fillcolor(colorstring2)\n",
      " |          and analogously, if the other input format is used.\n",
      " |      \n",
      " |      If turtleshape is a polygon, outline and interior of that polygon\n",
      " |      is drawn with the newly set colors.\n",
      " |      For more info see: pencolor, fillcolor\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.color('red', 'green')\n",
      " |      >>> turtle.color()\n",
      " |      ('red', 'green')\n",
      " |      >>> colormode(255)\n",
      " |      >>> color((40, 80, 120), (160, 200, 240))\n",
      " |      >>> color()\n",
      " |      ('#285078', '#a0c8f0')\n",
      " |  \n",
      " |  down = pendown(self)\n",
      " |  \n",
      " |  fillcolor(self, *args)\n",
      " |      Return or set the fillcolor.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      Four input formats are allowed:\n",
      " |        - fillcolor()\n",
      " |          Return the current fillcolor as color specification string,\n",
      " |          possibly in hex-number format (see example).\n",
      " |          May be used as input to another color/pencolor/fillcolor call.\n",
      " |        - fillcolor(colorstring)\n",
      " |          s is a Tk color specification string, such as \"red\" or \"yellow\"\n",
      " |        - fillcolor((r, g, b))\n",
      " |          *a tuple* of r, g, and b, which represent, an RGB color,\n",
      " |          and each of r, g, and b are in the range 0..colormode,\n",
      " |          where colormode is either 1.0 or 255\n",
      " |        - fillcolor(r, g, b)\n",
      " |          r, g, and b represent an RGB color, and each of r, g, and b\n",
      " |          are in the range 0..colormode\n",
      " |      \n",
      " |      If turtleshape is a polygon, the interior of that polygon is drawn\n",
      " |      with the newly set fillcolor.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.fillcolor('violet')\n",
      " |      >>> col = turtle.pencolor()\n",
      " |      >>> turtle.fillcolor(col)\n",
      " |      >>> turtle.fillcolor(0, .5, 0)\n",
      " |  \n",
      " |  hideturtle(self)\n",
      " |      Makes the turtle invisible.\n",
      " |      \n",
      " |      Aliases: hideturtle | ht\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      It's a good idea to do this while you're in the\n",
      " |      middle of a complicated drawing, because hiding\n",
      " |      the turtle speeds up the drawing observably.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.hideturtle()\n",
      " |  \n",
      " |  ht = hideturtle(self)\n",
      " |  \n",
      " |  isdown(self)\n",
      " |      Return True if pen is down, False if it's up.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.penup()\n",
      " |      >>> turtle.isdown()\n",
      " |      False\n",
      " |      >>> turtle.pendown()\n",
      " |      >>> turtle.isdown()\n",
      " |      True\n",
      " |  \n",
      " |  isvisible(self)\n",
      " |      Return True if the Turtle is shown, False if it's hidden.\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.hideturtle()\n",
      " |      >>> print turtle.isvisible():\n",
      " |      False\n",
      " |  \n",
      " |  pd = pendown(self)\n",
      " |  \n",
      " |  pen(self, pen=None, **pendict)\n",
      " |      Return or set the pen's attributes.\n",
      " |      \n",
      " |      Arguments:\n",
      " |          pen -- a dictionary with some or all of the below listed keys.\n",
      " |          **pendict -- one or more keyword-arguments with the below\n",
      " |                       listed keys as keywords.\n",
      " |      \n",
      " |      Return or set the pen's attributes in a 'pen-dictionary'\n",
      " |      with the following key/value pairs:\n",
      " |         \"shown\"      :   True/False\n",
      " |         \"pendown\"    :   True/False\n",
      " |         \"pencolor\"   :   color-string or color-tuple\n",
      " |         \"fillcolor\"  :   color-string or color-tuple\n",
      " |         \"pensize\"    :   positive number\n",
      " |         \"speed\"      :   number in range 0..10\n",
      " |         \"resizemode\" :   \"auto\" or \"user\" or \"noresize\"\n",
      " |         \"stretchfactor\": (positive number, positive number)\n",
      " |         \"shearfactor\":   number\n",
      " |         \"outline\"    :   positive number\n",
      " |         \"tilt\"       :   number\n",
      " |      \n",
      " |      This dictionary can be used as argument for a subsequent\n",
      " |      pen()-call to restore the former pen-state. Moreover one\n",
      " |      or more of these attributes can be provided as keyword-arguments.\n",
      " |      This can be used to set several pen attributes in one statement.\n",
      " |      \n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pen(fillcolor=\"black\", pencolor=\"red\", pensize=10)\n",
      " |      >>> turtle.pen()\n",
      " |      {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,\n",
      " |      'pencolor': 'red', 'pendown': True, 'fillcolor': 'black',\n",
      " |      'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}\n",
      " |      >>> penstate=turtle.pen()\n",
      " |      >>> turtle.color(\"yellow\",\"\")\n",
      " |      >>> turtle.penup()\n",
      " |      >>> turtle.pen()\n",
      " |      {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,\n",
      " |      'pencolor': 'yellow', 'pendown': False, 'fillcolor': '',\n",
      " |      'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}\n",
      " |      >>> p.pen(penstate, fillcolor=\"green\")\n",
      " |      >>> p.pen()\n",
      " |      {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,\n",
      " |      'pencolor': 'red', 'pendown': True, 'fillcolor': 'green',\n",
      " |      'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0}\n",
      " |  \n",
      " |  pencolor(self, *args)\n",
      " |      Return or set the pencolor.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      Four input formats are allowed:\n",
      " |        - pencolor()\n",
      " |          Return the current pencolor as color specification string,\n",
      " |          possibly in hex-number format (see example).\n",
      " |          May be used as input to another color/pencolor/fillcolor call.\n",
      " |        - pencolor(colorstring)\n",
      " |          s is a Tk color specification string, such as \"red\" or \"yellow\"\n",
      " |        - pencolor((r, g, b))\n",
      " |          *a tuple* of r, g, and b, which represent, an RGB color,\n",
      " |          and each of r, g, and b are in the range 0..colormode,\n",
      " |          where colormode is either 1.0 or 255\n",
      " |        - pencolor(r, g, b)\n",
      " |          r, g, and b represent an RGB color, and each of r, g, and b\n",
      " |          are in the range 0..colormode\n",
      " |      \n",
      " |      If turtleshape is a polygon, the outline of that polygon is drawn\n",
      " |      with the newly set pencolor.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pencolor('brown')\n",
      " |      >>> tup = (0.2, 0.8, 0.55)\n",
      " |      >>> turtle.pencolor(tup)\n",
      " |      >>> turtle.pencolor()\n",
      " |      '#33cc8c'\n",
      " |  \n",
      " |  pendown(self)\n",
      " |      Pull the pen down -- drawing when moving.\n",
      " |      \n",
      " |      Aliases: pendown | pd | down\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pendown()\n",
      " |  \n",
      " |  pensize(self, width=None)\n",
      " |      Set or return the line thickness.\n",
      " |      \n",
      " |      Aliases:  pensize | width\n",
      " |      \n",
      " |      Argument:\n",
      " |      width -- positive number\n",
      " |      \n",
      " |      Set the line thickness to width or return it. If resizemode is set\n",
      " |      to \"auto\" and turtleshape is a polygon, that polygon is drawn with\n",
      " |      the same line thickness. If no argument is given, current pensize\n",
      " |      is returned.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pensize()\n",
      " |      1\n",
      " |      >>> turtle.pensize(10)   # from here on lines of width 10 are drawn\n",
      " |  \n",
      " |  penup(self)\n",
      " |      Pull the pen up -- no drawing when moving.\n",
      " |      \n",
      " |      Aliases: penup | pu | up\n",
      " |      \n",
      " |      No argument\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.penup()\n",
      " |  \n",
      " |  pu = penup(self)\n",
      " |  \n",
      " |  resizemode(self, rmode=None)\n",
      " |      Set resizemode to one of the values: \"auto\", \"user\", \"noresize\".\n",
      " |      \n",
      " |      (Optional) Argument:\n",
      " |      rmode -- one of the strings \"auto\", \"user\", \"noresize\"\n",
      " |      \n",
      " |      Different resizemodes have the following effects:\n",
      " |        - \"auto\" adapts the appearance of the turtle\n",
      " |                 corresponding to the value of pensize.\n",
      " |        - \"user\" adapts the appearance of the turtle according to the\n",
      " |                 values of stretchfactor and outlinewidth (outline),\n",
      " |                 which are set by shapesize()\n",
      " |        - \"noresize\" no adaption of the turtle's appearance takes place.\n",
      " |      If no argument is given, return current resizemode.\n",
      " |      resizemode(\"user\") is called by a call of shapesize with arguments.\n",
      " |      \n",
      " |      \n",
      " |      Examples (for a Turtle instance named turtle):\n",
      " |      >>> turtle.resizemode(\"noresize\")\n",
      " |      >>> turtle.resizemode()\n",
      " |      'noresize'\n",
      " |  \n",
      " |  showturtle(self)\n",
      " |      Makes the turtle visible.\n",
      " |      \n",
      " |      Aliases: showturtle | st\n",
      " |      \n",
      " |      No argument.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.hideturtle()\n",
      " |      >>> turtle.showturtle()\n",
      " |  \n",
      " |  speed(self, speed=None)\n",
      " |      Return or set the turtle's speed.\n",
      " |      \n",
      " |      Optional argument:\n",
      " |      speed -- an integer in the range 0..10 or a speedstring (see below)\n",
      " |      \n",
      " |      Set the turtle's speed to an integer value in the range 0 .. 10.\n",
      " |      If no argument is given: return current speed.\n",
      " |      \n",
      " |      If input is a number greater than 10 or smaller than 0.5,\n",
      " |      speed is set to 0.\n",
      " |      Speedstrings  are mapped to speedvalues in the following way:\n",
      " |          'fastest' :  0\n",
      " |          'fast'    :  10\n",
      " |          'normal'  :  6\n",
      " |          'slow'    :  3\n",
      " |          'slowest' :  1\n",
      " |      speeds from 1 to 10 enforce increasingly faster animation of\n",
      " |      line drawing and turtle turning.\n",
      " |      \n",
      " |      Attention:\n",
      " |      speed = 0 : *no* animation takes place. forward/back makes turtle jump\n",
      " |      and likewise left/right make the turtle turn instantly.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.speed(3)\n",
      " |  \n",
      " |  st = showturtle(self)\n",
      " |  \n",
      " |  up = penup(self)\n",
      " |  \n",
      " |  width = pensize(self, width=None)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from TPen:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from TNavigator:\n",
      " |  \n",
      " |  back(self, distance)\n",
      " |      Move the turtle backward by distance.\n",
      " |      \n",
      " |      Aliases: back | backward | bk\n",
      " |      \n",
      " |      Argument:\n",
      " |      distance -- a number\n",
      " |      \n",
      " |      Move the turtle backward by distance, opposite to the direction the\n",
      " |      turtle is headed. Do not change the turtle's heading.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.position()\n",
      " |      (0.00, 0.00)\n",
      " |      >>> turtle.backward(30)\n",
      " |      >>> turtle.position()\n",
      " |      (-30.00, 0.00)\n",
      " |  \n",
      " |  backward = back(self, distance)\n",
      " |  \n",
      " |  bk = back(self, distance)\n",
      " |  \n",
      " |  circle(self, radius, extent=None, steps=None)\n",
      " |      Draw a circle with given radius.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      radius -- a number\n",
      " |      extent (optional) -- a number\n",
      " |      steps (optional) -- an integer\n",
      " |      \n",
      " |      Draw a circle with given radius. The center is radius units left\n",
      " |      of the turtle; extent - an angle - determines which part of the\n",
      " |      circle is drawn. If extent is not given, draw the entire circle.\n",
      " |      If extent is not a full circle, one endpoint of the arc is the\n",
      " |      current pen position. Draw the arc in counterclockwise direction\n",
      " |      if radius is positive, otherwise in clockwise direction. Finally\n",
      " |      the direction of the turtle is changed by the amount of extent.\n",
      " |      \n",
      " |      As the circle is approximated by an inscribed regular polygon,\n",
      " |      steps determines the number of steps to use. If not given,\n",
      " |      it will be calculated automatically. Maybe used to draw regular\n",
      " |      polygons.\n",
      " |      \n",
      " |      call: circle(radius)                  # full circle\n",
      " |      --or: circle(radius, extent)          # arc\n",
      " |      --or: circle(radius, extent, steps)\n",
      " |      --or: circle(radius, steps=6)         # 6-sided polygon\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.circle(50)\n",
      " |      >>> turtle.circle(120, 180)  # semicircle\n",
      " |  \n",
      " |  degrees(self, fullcircle=360.0)\n",
      " |      Set angle measurement units to degrees.\n",
      " |      \n",
      " |      Optional argument:\n",
      " |      fullcircle -  a number\n",
      " |      \n",
      " |      Set angle measurement units, i. e. set number\n",
      " |      of 'degrees' for a full circle. Default value is\n",
      " |      360 degrees.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.left(90)\n",
      " |      >>> turtle.heading()\n",
      " |      90\n",
      " |      \n",
      " |      Change angle measurement unit to grad (also known as gon,\n",
      " |      grade, or gradian and equals 1/100-th of the right angle.)\n",
      " |      >>> turtle.degrees(400.0)\n",
      " |      >>> turtle.heading()\n",
      " |      100\n",
      " |  \n",
      " |  distance(self, x, y=None)\n",
      " |      Return the distance from the turtle to (x,y) in turtle step units.\n",
      " |      \n",
      " |      Arguments:\n",
      " |      x -- a number   or  a pair/vector of numbers   or   a turtle instance\n",
      " |      y -- a number       None                            None\n",
      " |      \n",
      " |      call: distance(x, y)         # two coordinates\n",
      " |      --or: distance((x, y))       # a pair (tuple) of coordinates\n",
      " |      --or: distance(vec)          # e.g. as returned by pos()\n",
      " |      --or: distance(mypen)        # where mypen is another turtle\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pos()\n",
      " |      (0.00, 0.00)\n",
      " |      >>> turtle.distance(30,40)\n",
      " |      50.0\n",
      " |      >>> pen = Turtle()\n",
      " |      >>> pen.forward(77)\n",
      " |      >>> turtle.distance(pen)\n",
      " |      77.0\n",
      " |  \n",
      " |  fd = forward(self, distance)\n",
      " |  \n",
      " |  forward(self, distance)\n",
      " |      Move the turtle forward by the specified distance.\n",
      " |      \n",
      " |      Aliases: forward | fd\n",
      " |      \n",
      " |      Argument:\n",
      " |      distance -- a number (integer or float)\n",
      " |      \n",
      " |      Move the turtle forward by the specified distance, in the direction\n",
      " |      the turtle is headed.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.position()\n",
      " |      (0.00, 0.00)\n",
      " |      >>> turtle.forward(25)\n",
      " |      >>> turtle.position()\n",
      " |      (25.00,0.00)\n",
      " |      >>> turtle.forward(-75)\n",
      " |      >>> turtle.position()\n",
      " |      (-50.00,0.00)\n",
      " |  \n",
      " |  goto(self, x, y=None)\n",
      " |      Move turtle to an absolute position.\n",
      " |      \n",
      " |      Aliases: setpos | setposition | goto:\n",
      " |      \n",
      " |      Arguments:\n",
      " |      x -- a number      or     a pair/vector of numbers\n",
      " |      y -- a number             None\n",
      " |      \n",
      " |      call: goto(x, y)         # two coordinates\n",
      " |      --or: goto((x, y))       # a pair (tuple) of coordinates\n",
      " |      --or: goto(vec)          # e.g. as returned by pos()\n",
      " |      \n",
      " |      Move turtle to an absolute position. If the pen is down,\n",
      " |      a line will be drawn. The turtle's orientation does not change.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> tp = turtle.pos()\n",
      " |      >>> tp\n",
      " |      (0.00, 0.00)\n",
      " |      >>> turtle.setpos(60,30)\n",
      " |      >>> turtle.pos()\n",
      " |      (60.00,30.00)\n",
      " |      >>> turtle.setpos((20,80))\n",
      " |      >>> turtle.pos()\n",
      " |      (20.00,80.00)\n",
      " |      >>> turtle.setpos(tp)\n",
      " |      >>> turtle.pos()\n",
      " |      (0.00,0.00)\n",
      " |  \n",
      " |  heading(self)\n",
      " |      Return the turtle's current heading.\n",
      " |      \n",
      " |      No arguments.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.left(67)\n",
      " |      >>> turtle.heading()\n",
      " |      67.0\n",
      " |  \n",
      " |  home(self)\n",
      " |      Move turtle to the origin - coordinates (0,0).\n",
      " |      \n",
      " |      No arguments.\n",
      " |      \n",
      " |      Move turtle to the origin - coordinates (0,0) and set its\n",
      " |      heading to its start-orientation (which depends on mode).\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.home()\n",
      " |  \n",
      " |  left(self, angle)\n",
      " |      Turn turtle left by angle units.\n",
      " |      \n",
      " |      Aliases: left | lt\n",
      " |      \n",
      " |      Argument:\n",
      " |      angle -- a number (integer or float)\n",
      " |      \n",
      " |      Turn turtle left by angle units. (Units are by default degrees,\n",
      " |      but can be set via the degrees() and radians() functions.)\n",
      " |      Angle orientation depends on mode. (See this.)\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.heading()\n",
      " |      22.0\n",
      " |      >>> turtle.left(45)\n",
      " |      >>> turtle.heading()\n",
      " |      67.0\n",
      " |  \n",
      " |  lt = left(self, angle)\n",
      " |  \n",
      " |  pos(self)\n",
      " |      Return the turtle's current location (x,y), as a Vec2D-vector.\n",
      " |      \n",
      " |      Aliases: pos | position\n",
      " |      \n",
      " |      No arguments.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pos()\n",
      " |      (0.00, 240.00)\n",
      " |  \n",
      " |  position = pos(self)\n",
      " |  \n",
      " |  radians(self)\n",
      " |      Set the angle measurement units to radians.\n",
      " |      \n",
      " |      No arguments.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.heading()\n",
      " |      90\n",
      " |      >>> turtle.radians()\n",
      " |      >>> turtle.heading()\n",
      " |      1.5707963267948966\n",
      " |  \n",
      " |  right(self, angle)\n",
      " |      Turn turtle right by angle units.\n",
      " |      \n",
      " |      Aliases: right | rt\n",
      " |      \n",
      " |      Argument:\n",
      " |      angle -- a number (integer or float)\n",
      " |      \n",
      " |      Turn turtle right by angle units. (Units are by default degrees,\n",
      " |      but can be set via the degrees() and radians() functions.)\n",
      " |      Angle orientation depends on mode. (See this.)\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.heading()\n",
      " |      22.0\n",
      " |      >>> turtle.right(45)\n",
      " |      >>> turtle.heading()\n",
      " |      337.0\n",
      " |  \n",
      " |  rt = right(self, angle)\n",
      " |  \n",
      " |  seth = setheading(self, to_angle)\n",
      " |  \n",
      " |  setheading(self, to_angle)\n",
      " |      Set the orientation of the turtle to to_angle.\n",
      " |      \n",
      " |      Aliases:  setheading | seth\n",
      " |      \n",
      " |      Argument:\n",
      " |      to_angle -- a number (integer or float)\n",
      " |      \n",
      " |      Set the orientation of the turtle to to_angle.\n",
      " |      Here are some common directions in degrees:\n",
      " |      \n",
      " |       standard - mode:          logo-mode:\n",
      " |      -------------------|--------------------\n",
      " |         0 - east                0 - north\n",
      " |        90 - north              90 - east\n",
      " |       180 - west              180 - south\n",
      " |       270 - south             270 - west\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.setheading(90)\n",
      " |      >>> turtle.heading()\n",
      " |      90\n",
      " |  \n",
      " |  setpos = goto(self, x, y=None)\n",
      " |  \n",
      " |  setposition = goto(self, x, y=None)\n",
      " |  \n",
      " |  setx(self, x)\n",
      " |      Set the turtle's first coordinate to x\n",
      " |      \n",
      " |      Argument:\n",
      " |      x -- a number (integer or float)\n",
      " |      \n",
      " |      Set the turtle's first coordinate to x, leave second coordinate\n",
      " |      unchanged.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.position()\n",
      " |      (0.00, 240.00)\n",
      " |      >>> turtle.setx(10)\n",
      " |      >>> turtle.position()\n",
      " |      (10.00, 240.00)\n",
      " |  \n",
      " |  sety(self, y)\n",
      " |      Set the turtle's second coordinate to y\n",
      " |      \n",
      " |      Argument:\n",
      " |      y -- a number (integer or float)\n",
      " |      \n",
      " |      Set the turtle's first coordinate to x, second coordinate remains\n",
      " |      unchanged.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.position()\n",
      " |      (0.00, 40.00)\n",
      " |      >>> turtle.sety(-10)\n",
      " |      >>> turtle.position()\n",
      " |      (0.00, -10.00)\n",
      " |  \n",
      " |  towards(self, x, y=None)\n",
      " |      Return the angle of the line from the turtle's position to (x, y).\n",
      " |      \n",
      " |      Arguments:\n",
      " |      x -- a number   or  a pair/vector of numbers   or   a turtle instance\n",
      " |      y -- a number       None                            None\n",
      " |      \n",
      " |      call: distance(x, y)         # two coordinates\n",
      " |      --or: distance((x, y))       # a pair (tuple) of coordinates\n",
      " |      --or: distance(vec)          # e.g. as returned by pos()\n",
      " |      --or: distance(mypen)        # where mypen is another turtle\n",
      " |      \n",
      " |      Return the angle, between the line from turtle-position to position\n",
      " |      specified by x, y and the turtle's start orientation. (Depends on\n",
      " |      modes - \"standard\" or \"logo\")\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> turtle.pos()\n",
      " |      (10.00, 10.00)\n",
      " |      >>> turtle.towards(0,0)\n",
      " |      225.0\n",
      " |  \n",
      " |  xcor(self)\n",
      " |      Return the turtle's x coordinate.\n",
      " |      \n",
      " |      No arguments.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> reset()\n",
      " |      >>> turtle.left(60)\n",
      " |      >>> turtle.forward(100)\n",
      " |      >>> print turtle.xcor()\n",
      " |      50.0\n",
      " |  \n",
      " |  ycor(self)\n",
      " |      Return the turtle's y coordinate\n",
      " |      ---\n",
      " |      No arguments.\n",
      " |      \n",
      " |      Example (for a Turtle instance named turtle):\n",
      " |      >>> reset()\n",
      " |      >>> turtle.left(60)\n",
      " |      >>> turtle.forward(100)\n",
      " |      >>> print turtle.ycor()\n",
      " |      86.6025403784\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from TNavigator:\n",
      " |  \n",
      " |  DEFAULT_ANGLEOFFSET = 0\n",
      " |  \n",
      " |  DEFAULT_ANGLEORIENT = 1\n",
      " |  \n",
      " |  DEFAULT_MODE = 'standard'\n",
      " |  \n",
      " |  START_ORIENTATION = {'logo': (0.00,1.00), 'standard': (1.00,0.00), 'wo...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(bob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "171530ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "# bob.speed(0)\n",
    "\n",
    "bob.fd(100) # bob.forward(100)\n",
    "bob.rt(60)\n",
    "bob.fd(100) # bob.forward(100)\n",
    "bob.rt(60)\n",
    "bob.fd(100) # bob.forward(100)\n",
    "bob.rt(60)\n",
    "bob.fd(100) # bob.forward(100)\n",
    "bob.rt(60)\n",
    "bob.fd(100) # bob.forward(100)\n",
    "bob.rt(60)\n",
    "bob.fd(100) # bob.forward(100)\n",
    "bob.rt(60)\n",
    " \n",
    "turtle.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "662f6d36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi students!\n",
      "hi students!\n",
      "hi students!\n",
      "hi students!\n"
     ]
    }
   ],
   "source": [
    "for booq in range(4):\n",
    "    print('hi students!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39ded618",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "# bob.speed(0)\n",
    "\n",
    "for i in range(6):\n",
    "    bob.fd(100) # bob.forward(100)\n",
    "    bob.rt(60)\n",
    " \n",
    "turtle.mainloop()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eff0a059",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def n_angle(n):\n",
    "    for i in range(n):\n",
    "        r = 180 - (n-2)*180/n\n",
    "        bob.fd(100) # bob.forward(100)\n",
    "        bob.rt(r)\n",
    "\n",
    "n_angle(10)\n",
    "\n",
    "turtle.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fbc6457",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def n_angle(t, n, length):\n",
    "    for i in range(n):\n",
    "        r = 180 - (n-2)*180/n\n",
    "        t.fd(length) # bob.forward(100)\n",
    "        t.rt(r)\n",
    "\n",
    "def square(t, length):\n",
    "    for i in range(4):\n",
    "        t.fd(length)\n",
    "        t.lt(90)\n",
    "\n",
    "n_angle(bob, 10, 100)\n",
    "square(bob, 100)\n",
    "\n",
    "turtle.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecd9ac2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def n_angle(t, n, length=200):\n",
    "    for i in range(n):\n",
    "        r = 180 - (n-2)*180/n\n",
    "        t.fd(length) # bob.forward(100)\n",
    "        t.rt(r)\n",
    "\n",
    "def square(t, length):\n",
    "    for i in range(4):\n",
    "        t.fd(length)\n",
    "        t.lt(90)\n",
    "\n",
    "n_angle(bob, 10)\n",
    "\n",
    "square(bob, 100)\n",
    "\n",
    "turtle.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75f8ebdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "import math\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def polygon(t, n, length):\n",
    "    angle = 360 / n\n",
    "    for i in range(n):\n",
    "        t.fd(length)\n",
    "        t.lt(angle)\n",
    "\n",
    "def circle(t, r):\n",
    "    circumference = 2 * math.pi * r\n",
    "    n = 50\n",
    "    length = circumference / n\n",
    "    polygon(t, n, length)\n",
    "\n",
    "circle(bob, 200)\n",
    "\n",
    "turtle.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ac92a92",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "import math\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def polygon(t, n, length):\n",
    "    angle = 360 / n\n",
    "    for i in range(n):\n",
    "        t.fd(length)\n",
    "        t.lt(angle)\n",
    "\n",
    "def circle(t, r, x=0, y=0):\n",
    "    t.penup()\n",
    "    t.fd(x)\n",
    "    t.lt(90)\n",
    "    t.fd(y-r)\n",
    "    t.pendown()\n",
    "    t.rt(90)\n",
    "    circumference = 2 * math.pi * r\n",
    "    n = 50\n",
    "    length = circumference / n\n",
    "    polygon(t, n, length)\n",
    "\n",
    "circle(bob, 100, 200, -100)\n",
    "\n",
    "turtle.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47b1f74a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "import math\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def arc(t, r, angle):\n",
    "    arc_length = 2 * math.pi * r * angle / 360\n",
    "    n = int(arc_length / 3) + 1\n",
    "    step_length = arc_length / n\n",
    "    step_angle = angle / n\n",
    "    for i in range(n):\n",
    "        t.fd(step_length)\n",
    "        t.lt(step_angle)\n",
    "\n",
    "arc(bob, 100, 40)\n",
    "\n",
    "turtle.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b0502056",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function doc_test in module __main__:\n",
      "\n",
      "doc_test()\n",
      "    Hi, This is my \n",
      "    first docstring in Python.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def doc_test():\n",
    "    \"\"\"\n",
    "    Hi, This is my \n",
    "    first docstring in Python.\n",
    "    \"\"\"\n",
    "    print()\n",
    "    \n",
    "    \n",
    "help(doc_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "96156e60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sin in module math:\n",
      "\n",
      "sin(x, /)\n",
      "    Return the sine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "help(math.sin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26010fe6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(r):\n",
    "    \"\"\"\n",
    "    Return the area of given circle\n",
    "    r is the radius of a cricle \n",
    "    \"\"\"\n",
    "    return math.pi * r*r \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae7ff366",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "import math\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "\n",
    "def rectangle(t, w, h):\n",
    "    for i in range(2):\n",
    "        t.fd(w)\n",
    "        t.lt(90)\n",
    "        t.fd(h)\n",
    "        t.lt(90)\n",
    "\n",
    "for i in range(100):\n",
    "    rectangle(bob, 70, 50)\n",
    "    bob.fd(10)\n",
    "    bob.lt(5)\n",
    "    \n",
    "\n",
    "turtle.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f86c242",
   "metadata": {},
   "outputs": [],
   "source": [
    "import turtle\n",
    "import math\n",
    "\n",
    "bob = turtle.Turtle()\n",
    "bob.speed(0)\n",
    "bob.shape('turtle')\n",
    "\n",
    "def rectangle(t, w, h):\n",
    "    for i in range(2):\n",
    "        t.fd(w)\n",
    "        t.lt(90)\n",
    "        t.fd(h)\n",
    "        t.lt(90)\n",
    "\n",
    "n = 20\n",
    "for i in range(40):\n",
    "    bob.circle(n)\n",
    "    n = n + 3\n",
    "    #bob.fd(10)\n",
    "    #bob.lt(5)\n",
    "n = 20\n",
    "bob.lt(180)\n",
    "for i in range(40):\n",
    "    bob.circle(n)\n",
    "    n = n + 3\n",
    "    \n",
    "\n",
    "turtle.mainloop()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": ".venv"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}