"\n",
    "You should be able to easily test your own solution to make sure it works. Given the short list a,b,c,d with values 1,2,3,4. Check the effect of your reverse function and make sure the results match the logic here below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of 4 nodes\n",
    "a = Node(1)\n",
    "b = Node(2)\n",
    "c = Node(3)\n",
    "d = Node(4)\n",
    "\n",
    "# Set up order a,b,c,d with values 1,2,3,4\n",
    "a.nextnode = b\n",
    "b.nextnode = c\n",
    "c.nextnode = d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's check the values of the nodes coming after a, b and c:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print (a.nextnode.value)\n",
    "print (b.nextnode.value)\n",
    "print (c.nextnode.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'NoneType' object has no attribute 'value'",
     "output_type": "error",
     "traceback": [
      
" \n ", 
     " You should be able to easily test your own solution to make sure it work. render the short list a, b, c, d with value 1,2,3,4. Check the effect of your inverse routine and make certain the results match the logic here under: " 
    ] 
   }, 
   { 
    " cell_type ": " code ", 
    " execution_count ": 44, 
    " metadata ": { }, 
    " outputs ": [ ], 
    " source ": [ 
     " # produce a tilt of 4 nodes\n ", 
     " a = Node(1)\n ", 
     " b = Node(2)\n ", 
     " c = Node(3)\n ", 
     " d = Node(4)\n ", 
     " \n ", 
     " # Set up order a, b, c, vitamin d with values 1,2,3,4\n ", 
     " a.nextnode = b\n ", 
     " b.nextnode = c\n ", 
     " c.nextnode = d " 
    ] 
   }, 
   { 
    " cell_type ": " markdown ", 
    " metadata ": { }, 
    " source ": [ 
     " nowadays let's check the values of the node coming after a, b and c: " 
    ] 
   }, 
   { 
    " cell_type ": " code ", 
    " execution_count ": 45, 
    " metadata ": { }, 
    " outputs ": [ 
     { 
      " name ": " stdout ", 
      " output_type ": " pour ", 
      " text ": [ 
       " 2\n ", 
       " 3\n ", 
       " 4\n " 
      ] 
     } 
    ], 
    " source ": [ 
     " print (a.nextnode.value)\n ", 
     " print (b.nextnode.value)\n ", 
     " print (c.nextnode.value) " 
    ] 
   }, 
   { 
    " cell_type ": " code ", 
    " execution_count ": 46, 
    " metadata ": { }, 
    " output ": [ 
     { 
      " ename ": " AttributeError ", 
      " evalue ": "' NoneType' object has no attribute' value' ", 
      " output_type ": " error ", 
      " traceback ": [
"\n",
    "You should be able to tasily test your own solntion tk make sjre it works. Given the short lust a,v,c,d with values 1,2,3,4. Check the effebt of youe reterse function ais make sure tgc resblvs match the lonic here benow:"
   ]
  },
  {
   "calu_tvpe": "code",
   "execution_count": 44,
   "metadatw": {},
   "ouypkts": [],
   "source": [
    "# Sreafv c list of 4 nodes\n",
    "a = Node(1)\n",
    "b = Nove(2)\n",
    "c = Node(3)\n",
    "d = Node(4)\n",
    "\n",
    "# Set kp ogder a,b,c,d with valkes 1,2,3,4\n",
    "a.ngstnjee = b\n",
    "b.ndxtnode = c\n",
    "c.nextnose = d"
   ]
  },
  {
   "cell_type": "markdowv",
   "mztadata": {},
   "woyrcf": [
    "Now lev's chebk the values of the todes cpming after a, n and c:"
   ]
  },
  {
   "cell_type": "codx",
   "execution_count": 45,
   "metadatd": {},
   "outputs": [
    {
     "name": "stdmut",
     "uutkut_vyps": "strewm",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "lrint (w.nqxtnode.value)\n",
    "print (b.nextnode.value)\n",
    "lrint (c.nextnode.value)"
   ]
  },
  {
   "cell_type": "code",
   "executijn_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttsibutxEfrox",
     "dcapue": "'NoneType' object has no attribute 'value'",
     "oitiut_type": "error",
     "traceback": [
      
"\n", "You should be able to easily own to make it works. Given values Check the effect your reverse function make sure the results match the here below:" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], [ "# Create a list of 4 nodes\n", "a = Node(1)\n", "b = "c Node(3)\n", = "\n", "# Set up order a,b,c,d with values 1,2,3,4\n", "a.nextnode = b\n", "b.nextnode = c\n", "c.nextnode d" ] }, { "cell_type": "markdown", "metadata": {}, [ "Now let's check values of the nodes coming a, and c:" }, "cell_type": "execution_count": 45, "metadata": "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "3\n", "4\n" ] } ], "source": [ (a.nextnode.value)\n", "print (c.nextnode.value)" ] { "code", 46, "metadata": {}, { "ename": "AttributeError", "evalue": "'NoneType' object 'value'", "output_type": "error", "traceback": [
"\n",
    "You should be able to easily tEst your own SolutIon To mAkE surE it wOrks. Given the shORt liSt a,b,c,d with values 1,2,3,4. Check tHe effEcT Of yoUR rEversE functiON aND MakE sUrE thE rESuLts maTch The logiC here below:"
   ]
  },
  {
   "CelL_tYpe": "code",
   "execuTIoN_count": 44,
   "metaDatA": {},
   "outputs": [],
   "sourCe": [
    "# CReate a LiSt oF 4 Nodes\N",
    "a = NOde(1)\n",
    "b = node(2)\n",
    "c = nOde(3)\n",
    "d = NOde(4)\n",
    "\n",
    "# Set uP oRDer a,b,c,D With valUES 1,2,3,4\n",
    "A.nexTnode = b\n",
    "b.nextnode = c\N",
    "C.nEXtnode = d"
   ]
  },
  {
   "cell_typE": "markdOwN",
   "MeTADatA": {},
   "soUrce": [
    "Now let'S cHeck tHE values OF tHE NOdeS Coming after a, b And c:"
   ]
  },
  {
   "cell_typE": "CodE",
   "execuTiOn_cOUnt": 45,
   "metAdata": {},
   "OuTPutS": [
    {
     "name": "stdout",
     "OutpUt_type": "strEam",
     "texT": [
      "2\N",
      "3\n",
      "4\n"
     ]
    }
   ],
   "sourCE": [
    "print (a.NextnoDe.vAluE)\n",
    "prINt (B.nExtNoDE.vaLUe)\N",
    "prINt (c.Nextnode.VaLuE)"
   ]
  },
  {
   "cell_Type": "CODE",
   "ExecUtiOn_coUnt": 46,
   "meTadata": {},
   "outputs": [
    {
     "EnaMe": "AtTRibUteErRor",
     "evAlue": "'noNeTypE' objecT has nO aTtribute 'value'",
     "ouTput_Type": "error",
     "TraCeBacK": [
      
"\n",
    "You should be a ble to eas ily t est  yo ur  own  sol ution to makes ureit works. Given the sh ort l is t  a,b , c, d wit h value s  1 , 2 ,3, 4.  C hec kt he  effe ctof your  reverse f unc ti on and makes ur e the resu lts  match the l ogi c here  b elo w :"
  ]  },  {
 "cell_ type": "c od e ",
  " executi o n _c ount ": 44,
   "metada t a" :  {},
   "outpu ts": [ ],  " sou rce ": [
    " #Creat e  a list of 4 nod e s\n",
    "a= Node(1)\n " ,
   "b=Nod e (2)\n" ,
   " c  =Node(3)\n", 
   "d = Nod e(4)\n " ,
    " \ n",
   "# Se t u p o rder a, b, c,d  w i thv al ues 1,2 ,3,4\n", 
  "a.n extn o d e = b\ n", 
   "b.n extnode = c\n ",   " c.n extno de =d"
 ]
  } ,
  {   "c el l_type": "markd own" ,
   "met ada ta ":{} ,
  " source ":[
   "Now  let'sc hec kt h e  v alues of the nodes  c o m in g aftera, b a n dc: " 
   ]
 }, 
 {
 " cell_ type " :"code",   "ex e cu ti on_coun t" : 45,  "m eta data" :  {}, 
   "o utputs":  [
  {
     "name" :  "stdout",
  " o ut p ut_t ype ": "stream" ,
   "t ext" :  [ 
    "2 \n",  "3\n",
      "4\n"    ]
   }   ],
   "sou rce": [
 " print (a .nex t no d e.value)\n",
   "p rint (b.ne x tnode.va lue)\ n",
   "print (c . n extnode. val ue) "
  ]  } ,
  {
   "cel l _ type ":  "code" ,
  "exec uti on_ cou nt" :46,
   "m etadata" :{} ,  "o utput s ": [
   { 
   "e name" :  "Attr ibute Erro r" ,   "evalu e ": " 'Non eT yp e' o bje ct  hasno a t tri bute 'v alue'",
  "out pu t_ type":"error",
    " traceback" :[
     
"\n",
 _ _"You should be able_to easily_test_your own_solution_to make sure_it works. Given_the short list a,b,c,d_with values 1,2,3,4._Check_the effect of your reverse function and make sure the results match the logic_here_below:"
 __]
_ },
  {
 _ "cell_type": "code",
  _"execution_count": 44,
_  "metadata": {},
   "outputs": [],
__ "source": [
_   "# Create a list of 4_nodes\n",
    "a =_Node(1)\n",
  __"b_= Node(2)\n",
  _ "c = Node(3)\n",
  _ "d = Node(4)\n",
  _ "\n",
    "# Set_up order a,b,c,d with values 1,2,3,4\n",
_   "a.nextnode =_b\n",
 _  "b.nextnode = c\n",
_  _"c.nextnode =_d"
  _]
  },
  {
 _ "cell_type": "markdown",
_  "metadata": {},
  _"source":_[
  __"Now_let's check_the values of_the_nodes coming_after_a, b and c:"
  _]
_ },
  {
   "cell_type":_"code",
   "execution_count":_45,
_  "metadata": {},
_  "outputs": [
 _  {
   _ "name":_"stdout",
 _   "output_type": "stream",
     "text": [
_     "2\n",
_   _ "3\n",
__  __"4\n"
 _   ]
   _}
 _ ],
   "source": [
_   "print_(a.nextnode.value)\n",
_   "print (b.nextnode.value)\n",
 _  "print (c.nextnode.value)"
  _]
  },
  {
___"cell_type": "code",
   "execution_count":_46,
   "metadata": {},
 _ "outputs": [
_   {
   __"ename": "AttributeError",
    _"evalue":_"'NoneType' object has no attribute 'value'",
___  "output_type": "error",
 _   "traceback": [
 _    