PageRenderTime 55ms CodeModel.GetById 13ms RepoModel.GetById 0ms app.codeStats 1ms

/Languages/IronPython/Public/Tutorial/Tutorial.htm

http://github.com/IronLanguages/main
HTML | 2821 lines | 2795 code | 26 blank | 0 comment | 0 complexity | f3649312a6d6a8ae14c1d3d28296cd5b MD5 | raw file
Possible License(s): CPL-1.0, BSD-3-Clause, ISC, GPL-2.0, MPL-2.0-no-copyleft-exception

Large files files are truncated, but you can click here to view the full file

    

  1. <html>
    2. 

  2. 

  3. <head>
    4. 

  4. <meta http-equiv="Content-Type" content="text/html; charset=windows-1252" />
    5. 

  5. <title>IronPython Tutorial</title>
    6. 

  6. <link rel="stylesheet" type="text/css" href="../Doc/IronPython.css" />
    7. 

  7. <style type="text/css">
    8. 

  8.     p.AntiVerify { display : none; }
    9. 

  9.     p.Code-Background { color : gray; }
    10. 

  10.     p.NoVerify-Background { color : gray; }
    11. 

  11.     p.Code-Highlighted { color : gray; }
    12. 

  12.     p.NoVerify-Highlighted { color : gray; }
    13. 

  13.     p.CodeSample { color:blue; }
    14. 

  14.     p.DOSCommand { color:green; }
    15. 

  15.     p.ExceptionExample { color:green; }
    16. 

  16.     p.ExceptionOutput {display : none; }
    17. 

  17.     p.HiddenCode { display : none; }
    18. 

  18.     p.HiddenOutput {display : none; }
    19. 

  19.     p.LooseVerify { display : none; }
    20. 

  20.     p.Stepnonumbering { text-indent: 2em; }
    21. 

  21.     p.TypedExample { color : green; }
    22. 

  22.     p.UserExample { color : green; }
    23. 

  23.     p.UserCode { color:green; }
    24. 

  24. </style>
    25. 

  25. 

  26. </head>
    27. 

  27. 

  28. <body lang="EN-US">
    29. 

  29. 

  30. <div class="Section1">
    31. 

  31.     <p class="Title1">IronPython Tutorial</p>
    32. 

  32.     <p class="Title2">A tour of Python on .NET</p>
    33. 

  33.     <p class="Title2">&nbsp;</p>
    34. 

  34.     <hr />
    35. 

  35.     <p class="CopyrightText">Information in this document is subject to change without
    36. 

  36.     notice. The example companies, organizations, products, people, and events depicted
    37. 

  37.     herein are fictitious. No association with any real company, organization, product,
    38. 

  38.     person or event is intended or should be inferred. Complying with all applicable
    39. 

  39.     copyright laws is the responsibility of the user. Without limiting the rights
    40. 

  40.     under copyright, no part of this document may be reproduced, stored in or introduced
    41. 

  41.     into a retrieval system, or transmitted in any form or by any means (electronic,
    42. 

  42.     mechanical, photocopying, recording, or otherwise), or for any purpose, without
    43. 

  43.     the express written permission of Microsoft Corporation.</p>
    44. 

  44.     <p class="CopyrightText">&nbsp;</p>
    45. 

  45.     <p class="CopyrightText">Microsoft may have patents, patent applications, trademarked,
    46. 

  46.     copyrights, or other intellectual property rights covering subject matter in
    47. 

  47.     this document. Except as expressly provided in any written license agreement
    48. 

  48.     from Microsoft, the furnishing of this document does not give you any license
    49. 

  49.     to these patents, trademarks, copyrights, or other intellectual property.</p>
    50. 

  50.     <p class="CopyrightText">&nbsp;</p>
    51. 

  51.     <p class="CopyrightText">© Microsoft Corporation. All rights reserved.</p>
    52. 

  52.     <p class="CopyrightText">&nbsp;</p>
    53. 

  53.     <p class="CopyrightText">Microsoft, MS-DOS, MS, Windows, Windows NT, MSDN, Active
    54. 

  54.     Directory, BizTalk, SQL Server, SharePoint, Outlook, PowerPoint, FrontPage,
    55. 

  55.     Visual Basic, Visual C++, Visual J++, Visual InterDev, Visual SourceSafe, Visual
    56. 

  56.     C#, Visual J#,&nbsp; and Visual Studio are either registered trademarks or trademarks
    57. 

  57.     of Microsoft Corporation in the U.S.A. and/or other countries.</p>
    58. 

  58.     <p class="CopyrightText">&nbsp;</p>
    59. 

  59.     <p class="CopyrightText">Other product and company names herein may be the trademarks of their respective owners.</p>
    60. 

  60.     <hr />
    61. 

  61.     <p class="ContentsHeading">Contents</p>
    62. 

  62.     <p class="Toc1"><a href="#Intro">Introduction</a></p>
    63. 

  63.     <p class="Toc1">Tutorial 1: <a href="#T1">Basic IronPython</a></p>
    64. 

  64.     <p class="Toc2">Exercise 1: <a href="#T1.1">The IronPython interactive console</a></p>
    65. 

  65.     <p class="Toc3">Task 1: <a href="#T1.1.1">IronPython console</a></p>
    66. 

  66.     <p class="Toc3">Task 2: <a href="#T1.1.2">Built-in modules and interactive exploration</a></p>
    67. 

  67.     <p class="Toc3">Task 3: <a href="#T1.1.3">External Python modules</a></p>
    68. 

  68.     <p class="Toc2">Exercise 2: <a href="#T1.2">Using the standard .NET libraries from IronPython</a></p>
    69. 

  69.     <p class="Toc3">Task 1: <a href="#T1.2.1">Basic .NET library use</a></p>
    70. 

  70.     <p class="Toc3">Task 2: <a href="#T1.2.2">Working with .NET classes</a></p>
    71. 

  71.     <p class="Toc3">Task 3: <a href="#T1.2.3">Generics</a></p>
    72. 

  72.     <p class="Toc2">Exercise 3: <a href="#T1.3">Loading additional .NET libraries</a></p>
    73. 

  73.     <p class="Toc3">Task 1: <a href="#T1.3.1">Using System.Xml - AddReference</a></p>
    74. 

  74.     <p class="Toc3">Task 2: <a href="#T1.3.2">Mapack - Loading the .NET libraries - AddReferenceToFile</a></p>
    75. 

  75.     <p class="Toc2">Exercise 4: <a href="#T1.4">Obtaining and Using the Python Standard Library</a></p>
    76. 

  76.     <p class="Toc3">Task 1: <a href="#T1.4.1">Configuring IronPython to use the Python standard library</a></p>
    77. 

  77.     <p class="Toc1">Tutorial 2: <a href="#T2">Advanced IronPython</a></p>
    78. 

  78.     <p class="Toc2">Exercise 1: <a href="#T2.1">Events and Delegates</a></p>
    79. 

  79.     <p class="Toc3">Task 1: <a href="#T2.1.1">File System Watcher</a></p>
    80. 

  80.     <p class="Toc3">Task 2: <a href="#T2.1.2">Improving the event handler</a></p>
    81. 

  81.     <p class="Toc3">Task 3: <a href="#T2.1.3">Defining events in Python</a></p>
    82. 

  82.     <p class="Toc2">Exercise 2: <a href="#T2.2">Windows Forms</a></p>
    83. 

  83.     <p class="Toc3">Task 1: <a href="#T2.2.1">Simple Windows Forms application</a></p>
    84. 

  84.     <p class="Toc2">Exercise 3: <a href="#T2.3">Windows Presentation Foundation (Avalon)</a></p>
    85. 

  85.     <p class="Toc3">Task 1: <a href="#T2.3.1">Simple Avalon Application</a></p>
    86. 

  86.     <p class="Toc3">Task 2: <a href="#T2.3.2">Avalon calculator</a></p>
    87. 

  87.     <p class="Toc1">Tutorial 3: <a href="#T3">IronPython and COM interoperability</a></p>
    88. 

  88.     <p class="Toc2">Exercise 1: <a href="#T3.1">Use Word for Spell Checking</a></p>
    89. 

  89.     <p class="Toc3">Task 1: <a href="#T3.1.1">Accessing Word and Checking
    90. 

  90.     Spelling</a></p>
    91. 

  91.     <p class="Toc3">Task 2: <a href="#T3.1.2">Use Windows Form Dialog to Correct
    92. 

  92.     Spelling</a></p>
    93. 

  93.     <p class="Toc1">Tutorial 4: <a href="#T4">Debugging IronPython programs</a></p>
    94. 

  94.     <p class="Toc2">Exercise 1: <a href="#T4.1">Debugging IronPython programs</a></p>
    95. 

  95.     <p class="Toc3">Task 1: <a href="#T4.1.1">Debugging IronPython programs using Microsoft CLR Debugger</a></p>
    96. 

  96.     <p class="Toc1">Tutorial 5: <a href="#T5">Extending IronPython</a></p>
    97. 

  97.     <p class="Toc2">Exercise 1: <a href="#T5.1">Extending using C#</a></p>
    98. 

  98.     <p class="Toc3">Task 1: <a href="#T5.1.1">Implementing a simple class - constructor and ToString</a></p>
    99. 

  99.     <p class="Toc3">Task 2: <a href="#T5.1.2">Making the object enumerable</a></p>
    100. 

  100.     <p class="Toc3">Task 3: <a href="#T5.1.3">Adding a custom operator</a></p>
    101. 

  101.     <p class="Toc3">Task 4: <a href="#T5.1.4">Adding a delegate</a></p>
    102. 

  102.     <p class="Toc2">Exercise 2: <a href="#T5.2">Extending using Visual Basic.NET</a></p>
    103. 

  103.     <p class="Toc3">Task 1: <a href="#T5.2.1">Implementing a simple class - constructor and ToString</a></p>
    104. 

  104.     <p class="Toc3">Task 2: <a href="#T5.2.2">Making the object enumerable</a></p>
    105. 

  105.     <p class="Toc3">Task 3: <a href="#T5.2.3">Adding a custom operator</a></p>
    106. 

  106.     <p class="Toc3">Task 4: <a href="#T5.2.4">Adding a delegate</a></p>
    107. 

  107.     <p class="Toc1">Tutorial 6: <a href="#T7">Using Visual Studio to Edit .py
    108. 

  108.     Files and Debug Them</a></p>
    109. 

  109.     <p class="Toc2">Exercise 1: <a href="#T6.1">Setting up Visual Studio for
    110. 

  110.     IronPython Debugging</a></p>
    111. 

  111.     <p class="Toc3">Task 1: <a href="#T6.1.1">Setting up Visual Studio for
    112. 

  112.     IronPython Debugging</a></p>
    113. 

  113. </div>
    114. 

  114. <div class="Section2">
    115. 

  115.     <h1><a name="Intro">Introduction</a></h1>
    116. 

  116.     <p class="Normal">IronPython is the .NET implementation of the Python programming language
    117. 

  117.         (<a href="http://www.python.org">www.python.org</a>).&nbsp; It's a dynamically typed language with support
    118. 

  118.         for many programming paradigms such as imperative, object-oriented, and functional programming, and also allows
    119. 

  119.         you to seamlessly use existing .NET code.</p>
    120. 

  120.     <p class="Normal">&nbsp;</p>
    121. 

  121.     <p class="Normal">The goal of this tutorial is to quickly familiarize you with the
    122. 

  122.     IronPython console and to show you how to make use of the extensive .NET libraries
    123. 

  123.     available.&nbsp; This tutorial also shows you how to get started in more specialized
    124. 

  124.     areas such as interoperating with <a href="http://www.microsoft.com/com/default.mspx">COM</a>
    125. 

  125.     and extending IronPython with C# and/or Visual Basic.&nbsp; While we do explain some
    126. 

  126.     finer points of Python's syntax, this tutorial is NOT meant to be an introduction to
    127. 

  127.     Python itself, and if you're looking for that, we recommend you start with the tutorial at
    128. 

  128.     <a href="http://docs.python.org/tut/tut.html">www.python.org</a>
    129. 

  129.     or the often recommended book
    130. 

  130.     <a href="http://oreilly.com/catalog/9780596513986/"><i>Learning Python</i></a>
    131. 

  131.     by Mark Lutz and David Ascher. In addition,
    132. 

  132.     <a href="http://www.ironpythoninaction.com/"><i>IronPython in Action</i></a>
    133. 

  133.     by Michael Foord and Christian Muirhead is a definitive guide that includes
    134. 

  134.     a wealth of IronPython-specific information.<br><br>
    135. 

  135.     Some of the exercises in this tutorial require specific software installations.&nbsp;
    136. 

  136.     The prerequisites to successfully complete the whole tutorial are:</p>
    137. 

  137.     <ul type="disc">
    138. 

  138.         <li class="Normal">Microsoft .NET Framework Version 4.0 
    139. 

  139.         <ul type="circle">
    140. 

  140.             <li class="Normal">Required to run IronPython.</li>
    141. 

  141.             <li class="Normal">Download from
    142. 

  142.             <a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=9cfb2d51-5ff4-4491-b0e5-b386f32c0992&amp;displaylang=en">here</a>.</li>
    143. 

  143.         </ul>
    144. 

  144.         </li>
    145. 

  145.     </ul>
    146. 

  146.     <ul>
    147. 

  147.         <li class="Normal">Visual Studio 2010
    148. 

  148. 		<ul type="circle">
    149. 

  149. 			<li class="Normal">Very useful for the C#/VB extending tutorials.</li>
    150. 

  150. 			<li class="Normal">Separate .NET 4.0 installation is not required if 
    151. 

  151. 			Visual Studio 2010 is installed.</li>
    152. 

  152. 			<li class="Normal">Download from
    153. 

  153.             <a href="http://www.microsoft.com/visualstudio">here</a>.</li>
    154. 

  154. 		</ul>
    155. 

  155. 		</li>
    156. 

  156. 		<li class="Normal"><a name="Mapack">Mapack</a> (example assembly found
    157. 

  157.         on the internet)<ul>
    158. 

  158. 			<li>Required for the turorial &quot;<a href="#T1">Basic IronPython</a>&quot;
    159. 

  159.             and exercise &quot;<a href="#T1.3">Loading additional .NET Libraries</a>&quot;.</li>
    160. 

  160. 			<li>Download Mapack from
    161. 

  161.             <a href="http://www.lutzroeder.com/dotnet/">here</a> (direct link
    162. 

  162.             to the Mapack.zip download is
    163. 

  163.             <a href="http://www.lutzroeder.com/dotnet/Download.aspx?File=Mapack">here</a>).</li>
    164. 

  164. 			<li>Extract Mapack.dll from the zip file directly into the Tutorial
    165. 

  165.             directory.</li>
    166. 

  166. 		</ul>
    167. 

  167. 		</li>
    168. 

  168.     </ul>
    169. 

  169.     <p class="Normal">&nbsp;</p>
    170. 

  170.     <p class="Body">This tutorial assumes that the IronPython distribution was uncompressed
    171. 

  171.     into the directory C:\IronPython.&nbsp; Please note that your individual setup may
    172. 

  172.     vary.</p>
    173. 

  173.     <p class="Body">This tutorial also assumes that you will launch the
    174. 

  174.     IronPython console (c:\ironpython\ipy.exe) from the tutorial directory.&nbsp;
    175. 

  175.     When the tutorials direct you to start the IronPython console from the tutorial directory,
    176. 

  176.     you should change to the tutorial directory (&gt;cd c:\ironpython\tutorial)
    177. 

  177.     and launch the console with the tutorial as your working directory (&gt;..\ipy.exe).</p>
    178. 

  178.     <a name="VS2005Note"></a>
    179. 

  179.     <p class="Body">&nbsp;</p>
    180. 

  180.     <h1><a name="T1">Tutorial 1: Basic IronPython</a></h1>
    181. 

  181.     <p class="Body">The emphasis of this tutorial is on the basic interaction with
    182. 

  182.     the IronPython interpreter and using the interactive environment to explore
    183. 

  183.     the .NET libraries.</p>
    184. 

  184.     <p class="Body">Estimated time to complete this tutorial: <b>30 minutes</b></p>
    185. 

  185.     <p class="Body">The objective of this tutorial is to launch the IronPython interpreter,
    186. 

  186.     explore the environment of the interactive console and use IronPython to interact
    187. 

  187.     with .NET libraries.</p>
    188. 

  188.     <p class="Body">The exercises in this tutorial are:</p>
    189. 

  189.     <ul>
    190. 

  190.         <li>
    191. 

  191.         <p class="ExerciseList"><a href="#T1.1">The IronPython interactive console</a></p>
    192. 

  192.         </li>
    193. 

  193.         <li>
    194. 

  194.         <p class="ExerciseList"><a href="#T1.2">Using the standard .NET libraries
    195. 

  195.         from IronPython</a></p>
    196. 

  196.         </li>
    197. 

  197.         <li>
    198. 

  198.         <p class="ExerciseList"><a href="#T1.3">Loading additional .NET libraries</a></p>
    199. 

  199.         </li>
    200. 

  200.     </ul>
    201. 

  201.     <h2><a name="T1.1">Exercise 1: The IronPython interactive console</a></h2>
    202. 

  202.     <p class="Body">In this exercise, you will start the IronPython interactive
    203. 

  203.     interpreter and perform simple tasks to become acquainted with the IronPython
    204. 

  204.     environment.</p>
    205. 

  205.     <p class="Normal">If you are familiar with using the Python interactive console,
    206. 

  206.     the import statement and exploring the Python interactive environment using
    207. 

  207.     dir() function and __doc__ attribute, you can <a href="#T1.2">skip this exercise</a>.</p>
    208. 

  208.     <h3><a name="T1.1.1">Task 1: IronPython console</a></h3>
    209. 

  209.     <ol>
    210. 

  210.         <li>
    211. 

  211.         <p class="Step">Start the IronPython console from the tutorial directory
    212. 

  212.         by changing to the tutorial directory (&gt;cd c:\ironpython\tutorial) and
    213. 

  213.         launching the console c:\ironpython\ipy.exe executable (&gt;..\ipy.exe).&nbsp;
    214. 

  214.         This is how you should always launch the console for the tutorials, but
    215. 

  215.         from now on, we'll just direct you to &quot;start the IronPython console from
    216. 

  216.         the tutorial directory&quot;.</p>
    217. 

  217.         </li>
    218. 

  218.     </ol>
    219. 

  219.     <p class="Code-Highlighted">IronPython 2.7 (2.7.10920.0) on .NET 4.0.30319.1<br />
    220. 

  220.     Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.</p>
    221. 

  221.     <p class="Code-Highlighted">&gt;&gt;&gt; _</p>
    222. 

  222.     <ol start="2">
    223. 

  223.         <li>
    224. 

  224.         <p class="Step">IronPython's console interfaces with the user in a standard
    225. 

  225.         Read-Eval-Print Loop, or REPL. This means that the console repeatedly reads
    226. 

  226.         user input, evaluates the statement, prints the result (if any), and awaits
    227. 

  227.         more input. Try it out by executing the simple statements listed below.
    228. 

  228.         <b>Note:</b> The input line starting with 'for' requires an extra press of
    229. 

  229.         the enter key afterwards as a signal to the interpreter that there are no
    230. 

  230.         more statements in the 'for' loop.</p>
    231. 

  231.         </li>
    232. 

  232.     </ol>
    233. 

  233.     <p class="TypedExample">2+2</p>
    234. 

  234.     <p class="TypedExample">print &quot;Hello World!&quot;</p>
    235. 

  235.     <p class="TypedExample">for i in range(3): print i</p>
    236. 

  236.     <p class="TypedExample">x = 10</p>
    237. 

  237.     <p class="TypedExample">print x</p>
    238. 

  238.     <p class="Stepnonumbering">&nbsp;</p>
    239. 

  239.     <p class="Stepnonumbering">After this step, the console window will contain
    240. 

  240.     the following text:</p>
    241. 

  241.     <p class="Code-Highlighted">&gt;&gt;&gt; 2+2</p>
    242. 

  242.     <p class="Code-Background">4</p>
    243. 

  243.     <p class="Code-Highlighted">&gt;&gt;&gt; print &quot;Hello World!&quot;</p>
    244. 

  244.     <p class="Code-Background">Hello World!</p>
    245. 

  245.     <p class="Code-Highlighted">&gt;&gt;&gt; for i in range(3): print i</p>
    246. 

  246.     <p class="Code-Highlighted">...</p>
    247. 

  247.     <p class="Code-Background">0<br />
    248. 

  248.     1<br />
    249. 

  249.     2</p>
    250. 

  250.     <p class="Code-Highlighted">&gt;&gt;&gt; x = 10<br />
    251. 

  251.     &gt;&gt;&gt; print x</p>
    252. 

  252.     <p class="Code-Background"></p>
    253. 

  253.     <p class="Code-Background">10</p>
    254. 

  254.     <p class="Code-Highlighted">&gt;&gt;&gt; </p>
    255. 

  255.     <ol start="3">
    256. 

  256.         <li>
    257. 

  257.         <p class="Step">The IronPython console supports multi-line statements, often
    258. 

  258.         used in function or class definitions.&nbsp; IronPython prompts for additional lines in a
    259. 

  259.         multi-line statement using:</p>
    260. 

  260.         </li>
    261. 

  261.     </ol>
    262. 

  262.     <p class="Code-Highlighted">...</p>
    263. 

  263.     <p class="Code-Background"></p>
    264. 

  264.     <p class="Body">&nbsp;</p>
    265. 

  265.     <p class="Stepnonumbering">One of the more unique aspects of Python is its sensitivity to whitespace at the
    266. 

  266.         beginning of a line. Unlike C, C# or Java, where blocks of code are grouped by curly brackets "{...}",
    267. 

  267.         blocks of code in Python are grouped based on their level of indentation.&nbsp; Every new block of code
    268. 

  268.         must be indented one more level than the previous block of code.&nbsp; Blocks of code are used for many
    269. 

  269.         constructs, including function and class definitions, the bodies of loops, 'if'...'elif'...'else' clauses,
    270. 

  270.         and 'try'...'except'...'finally' blocks. </p>
    271. 

  271.     <p class="Stepnonumbering">Define the 'add' function (note, you
    272. 

  272.     need to enter spaces before the 'return' statement):</p>
    273. 

  273.     <p class="TypedExample">def add(a, b):<br>
    274. 

  274. &nbsp;&nbsp;&nbsp; return a + b</p>
    275. 

  275.     <p class="Stepnonumbering">To complete the function definition, press Enter
    276. 

  276.     once more at this point</p>
    277. 

  277.     <p class="TypedExample">add(3, 2)</p>
    278. 

  278.     <p class="TypedExample">add('Iron', 'Python')</p>
    279. 

  279.     <p class="Stepnonumbering">&nbsp;</p>
    280. 

  280.     <p class="Stepnonumbering">After this step, the console contents will be:</p>
    281. 

  281.     <p class="Code-Highlighted">&gt;&gt;&gt; def add(a, b):<br />
    282. 

  282.     ...&nbsp;&nbsp;&nbsp;&nbsp; return a + b<br />
    283. 

  283.     ...<br />
    284. 

  284.     &gt;&gt;&gt; add(3, 2)</p>
    285. 

  285.     <p class="Code-Background">5</p>
    286. 

  286.     <p class="Code-Highlighted">&gt;&gt;&gt; add(&quot;Iron&quot;, &quot;Python&quot;)</p>
    287. 

  287.     <p class="Code-Background">&#39;IronPython&#39;</p>
    288. 

  288.     <p class="Code-Highlighted">&gt;&gt;&gt; </p>
    289. 

  289.     <p class="Step">&nbsp;</p>
    290. 

  290.     <ol start="4">
    291. 

  291.         <li>
    292. 

  292.         <p class="Step">To exit the IronPython interactive console, type Ctrl+Z and Enter (alternatively,
    293. 

  293.         press F6 followed by Enter).</p>
    294. 

  294.         </li>
    295. 

  295.     </ol>
    296. 

  296.     <p class="TypedExample">^Z</p>
    297. 

  297.     <h3><a name="T1.1.2">Task 2: Built-in modules and interactive exploration</a></h3>
    298. 

  298.     <ol>
    299. 

  299.         <li>
    300. 

  300.         <p class="Step">Start the IronPython console from the tutorial directory
    301. 

  301.         (see <a href="#Intro">Introduction</a> for details).</p>
    302. 

  302.         </li>
    303. 

  303.         <li>
    304. 

  304.         <p class="Step">Using the built-in function dir(), list the contents of
    305. 

  305.         the IronPython environment:</p>
    306. 

  306.         </li>
    307. 

  307.     </ol>
    308. 

  308.     <p class="TypedExample">dir()</p>
    309. 

  309.     <p class="Stepnonumbering">The output in the console window will be:</p>
    310. 

  310.     <p class="Code-Highlighted">&gt;&gt;&gt; dir()</p>
    311. 

  311.     <p class="Code-Background">['__builtins__', '__doc__', '__name__']<br />
    312. 

  312. </p>
    313. 

  313.     <ol start="3">
    314. 

  314.         <li>
    315. 

  315.         <p class="Step">IronPython comes with several built-in modules including 'sys', which is
    316. 

  316.         one of the most frequently used.&nbsp; Load the 'sys' module using the 'import' keyword:</p>
    317. 

  317.         </li>
    318. 

  318.     </ol>
    319. 

  319.     <p class="TypedExample">import sys</p>
    320. 

  320.     <ol start="4">
    321. 

  321.         <li>
    322. 

  322.         <p class="Step">The Python 'import' statement is similar to the 'using' statement
    323. 

  323.         of C# or 'Imports' statement of Visual Basic. The important difference is
    324. 

  324.         that the C# and VB statements bring the names from the imported namespace
    325. 

  325.         into the global namespace to be accessed directly. Python’s import doesn’t
    326. 

  326.         do that automatically, unless it is used in conjunction with the 'from'
    327. 

  327.         keyword (more on this later). To access the names or attributes in an imported
    328. 

  328.         module, prefix them with the module's name:</p>
    329. 

  329.         </li>
    330. 

  330.     </ol>
    331. 

  331.     <p class="UserExample">sys.version</p>
    332. 

  332.     <ol start="5">
    333. 

  333.         <li>
    334. 

  334.         <p class="Step">Use the dir() function to explore the environment:</p>
    335. 

  335.         </li>
    336. 

  336.     </ol>
    337. 

  337.     <p class="TypedExample">dir()</p>
    338. 

  338.     <p class="Stepnonumbering" style="margin-left: 0.5in">The environment (global namespace) has changed, now
    339. 

  339.     it contains the 'sys' module:</p>
    340. 

  340.     <p class="Code-Highlighted">&gt;&gt;&gt; dir()</p>
    341. 

  341.     <p class="Code-Background">['__builtins__', '__doc__', '__name__', 'sys']</p>
    342. 

  342.     <ol start="6">
    343. 

  343.         <li>
    344. 

  344.         <p class="Step">Use the dir() function to explore the contents of the 'sys'
    345. 

  345.         module:</p>
    346. 

  346.         </li>
    347. 

  347.     </ol>
    348. 

  348.     <p class="TypedExample">dir(sys)</p>
    349. 

  349.     <p class="HiddenOutput">['__doc__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_clear', 'exc_info', 'exc_traceback', 'exc_type', 'exc_value', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding', 'getrecursionlimit', 'getsizeof', 'gettrace', 'getwindowsversion', 'hexversion', 'maxint', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'py3kwarning', 'setcheckinterval', 'setdefaultencoding', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoptions', 'winver']</p>
    350. 

  350.     <ol start="7">
    351. 

  351.         <li>
    352. 

  352.         <p class="Step">Print the values of some of the 'sys' module attributes:</p>
    353. 

  353.         </li>
    354. 

  354.     </ol>
    355. 

  355.     <p class="TypedExample">sys.path</p>
    356. 

  356.     <p class="LooseVerify">['.', '%DLR_ROOT%\\Test', '%DLR_ROOT%\\Languages\\IronPython\\Public\\Tutorial', '%DLR_ROOT%\\Languages\\IronPython\\Tests', '%DLR_ROOT%\\Test\\IronPythonTutorial', '%DLR_ROOT%\\bin\\Debug\\Lib', '%DLR_ROOT%\\bin\\Debug\\DLLs', '%DLR_ROOT%\\bin\\Debug']</p>
    357. 

  357.     <p class="TypedExample">sys.executable</p>
    358. 

  358.     <p class="LooseVerify">'%DLR_ROOT%\\bin\\Debug\\ipy.exe'</p>
    359. 

  359.     <h3><a name="T1.1.3">Task 3: External Python modules</a></h3>
    360. 

  360.     <p class="Normal">This task uses the module 'first.py' located in the Tutorial
    361. 

  361.     folder.</p>
    362. 

  362.     <ol>
    363. 

  363.         <li>
    364. 

  364.         <p class="Step">Import the 'first.py' module located in the Tutorial directory:</p>
    365. 

  365.         </li>
    366. 

  366.     </ol>
    367. 

  367.     <p class="TypedExample">import first</p>
    368. 

  368.     <p class="Code-Background"></p>
    369. 

  369.     <p class="Stepnonumbering">Because you launched ipy.exe from there, the Tutorial directory appears
    370. 

  370.     in sys.path, telling IronPython to look there in its search for 'first.py'.</p>
    371. 

  371.     <ol start="2">
    372. 

  372.         <li>
    373. 

  373.         <p class="Step">Explore the 'first' module using dir():</p>
    374. 

  374.         </li>
    375. 

  375.     </ol>
    376. 

  376.     <p class="TypedExample">dir(first)</p>
    377. 

  377.     <p class="Code-Highlighted">&gt;&gt;&gt; dir(first)</p>
    378. 

  378.     <p class="Code-Background">['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'add', 'factorial', 'hi']</p>
    379. 

  379.     <ol start="3">
    380. 

  380.         <li>
    381. 

  381.         <p class="Step">Print the documentation for the 'add' and 'factorial' functions,
    382. 

  382.         using __doc__ attribute:</p>
    383. 

  383.         </li>
    384. 

  384.     </ol>
    385. 

  385.     <p class="TypedExample">first.add.__doc__</p>
    386. 

  386.     <p class="TypedExample">first.factorial.__doc__</p>
    387. 

  387.     <p class="Stepnonumbering">&nbsp;</p>
    388. 

  388.     <p class="Stepnonumbering">We will use the __doc__ attribute later to explore .NET
    389. 

  389.     methods and their parameter types.</p>
    390. 

  390.     <p class="Code-Highlighted">&gt;&gt;&gt; first.add.__doc__</p>
    391. 

  391.     <p class="Code-Background">&#39;add(a, b) -&gt; returns a + b&#39;</p>
    392. 

  392.     <p class="Code-Highlighted">&gt;&gt;&gt; first.factorial.__doc__</p>
    393. 

  393.     <p class="Code-Background">&#39;factorial(n) -&gt; returns factorial of n&#39;</p>
    394. 

  394.     <ol start="4">
    395. 

  395.         <li>
    396. 

  396.         <p class="Step">Call the methods in the 'first' module and print the contents
    397. 

  397.         of the 'hi' attribute</p>
    398. 

  398.         </li>
    399. 

  399.     </ol>
    400. 

  400.     <p class="TypedExample">first.add(1,2)</p>
    401. 

  401.     <p class="TypedExample">first.factorial(5)</p>
    402. 

  402.     <p class="TypedExample">first.hi</p>
    403. 

  403.     <p class="Stepnonumbering">The expected output is:</p>
    404. 

  404.     <p class="Code-Highlighted">&gt;&gt;&gt; first.add(1,2)</p>
    405. 

  405.     <p class="Code-Background">3</p>
    406. 

  406.     <p class="Code-Highlighted">&gt;&gt;&gt; first.factorial(5)</p>
    407. 

  407.     <p class="Code-Background">120</p>
    408. 

  408.     <p class="Code-Highlighted">&gt;&gt;&gt; first.hi</p>
    409. 

  409.     <p class="Code-Background">&#39;Hello from IronPython!&#39;</p>
    410. 

  410.     <ol start="5">
    411. 

  411.         <li>
    412. 

  412.         <p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed
    413. 

  413.         by Enter)</p>
    414. 

  414.         </li>
    415. 

  415.     </ol>
    416. 

  416.     <h2><a name="T1.2">Exercise 2: Using the standard .NET libraries from IronPython</a></h2>
    417. 

  417.     <p class="Body">Much of IronPython's power arises from its ability to seamlessly
    418. 

  418.     access the wealth of .NET libraries. This exercise will demonstrate how the
    419. 

  419.     .NET libraries can be used from IronPython.</p>
    420. 

  420.     <p class="Body">In this exercise, you will use the standard .NET libraries from
    421. 

  421.     IronPython. </p>
    422. 

  422.     <h3><a name="T1.2.1">Task 1: Basic .NET library use</a></h3>
    423. 

  423.     <ol>
    424. 

  424.         <li>
    425. 

  425.         <p class="Step">Start the IronPython console from the tutorial directory
    426. 

  426.         (see <a href="#Intro">Introduction</a> for details).</p>
    427. 

  427.         </li>
    428. 

  428.         <li>
    429. 

  429.         <p class="Step">Using the 'import' keyword, import the .NET System namespace:</p>
    430. 

  430.         </li>
    431. 

  431.     </ol>
    432. 

  432.     <p class="TypedExample">import System</p>
    433. 

  433.     <p class="Code-Background"></p>
    434. 

  434.     <ol start="3">
    435. 

  435.         <li>
    436. 

  436.         <p class="Step">Explore the System.Environment class and access some of
    437. 

  437.         its properties:</p>
    438. 

  438.         </li>
    439. 

  439.     </ol>
    440. 

  440.     <p class="TypedExample">dir(System.Environment)</p>
    441. 

  441.     <p class="UserCode">System.Environment.OSVersion</p>
    442. 

  442.     <p class="TypedExample">System.Environment.CommandLine</p>
    443. 

  443.     <p class="Stepnonumbering">&nbsp;</p>
    444. 

  444.     <p class="Stepnonumbering">The expected output of these commands is as follows
    445. 

  445.     (with ellipsis for convenience):</p>
    446. 

  446.     <p class="Code-Highlighted">&gt;&gt;&gt; dir(System.Environment)</p>
    447. 

  447.     <p class="HiddenOutput">['CommandLine','CurrentDirectory','Equals','Exit','ExitCode','ExpandEnvironmentVariables','FailFast','GetCommandLineArgs','GetEnvironmentVariable','GetEnvironmentVariables','GetFolderPath','GetHashCode','GetLogicalDrives','GetType','HasShutdownStarted','Is64BitOperatingSystem','Is64BitProcess','MachineName','MemberwiseClone','NewLine','OSVersion','ProcessorCount','ReferenceEquals','SetEnvironmentVariable','SpecialFolder','SpecialFolderOption','StackTrace','SystemDirectory','SystemPageSize','TickCount','ToString','UserDomainName','UserInteractive','UserName','Version','WorkingSet','__all__','__class__','__delattr__','__doc__','__format__','__getattribute__','__hash__','__init__','__new__','__reduce__','__reduce_ex__','__repr__','__setattr__','__sizeof__','__str__','__subclasshook__']</p>
    448. 

  448.     <p class="NoVerify-Background">['CommandLine', 'CurrentDirectory', ... '__subclasshook__']</p>
    449. 

  449.     <p class="Code-Highlighted">&gt;&gt;&gt; System.Environment.OSVersion</p>
    450. 

  450.     <p class="NoVerify-Background">&lt;System.OperatingSystem object at 0x000000000000002B [Microsoft Windows NT 6.0.6000.0]</p>
    451. 

  451.     <p class="Code-Highlighted">&gt;&gt;&gt; System.Environment.CommandLine</p>
    452. 

  452.     <p class="LooseVerify">'"%DLR_ROOT%\\Bin\\Debug\\ipy.exe"'</p>
    453. 

  453.     <p class="NoVerify-Background">'C:\\IronPython\\ipy.exe'</p>
    454. 

  454.     <ol start="4">
    455. 

  455.         <li>
    456. 

  456.         <p class="Step">The import statement can also be used to import contents of
    457. 

  457.         a class or module into the global namespace.&nbsp; Use the &quot;from ... import ...&quot;
    458. 

  458.         flavor of the import statement to do this, then use dir() to explore the contents of the
    459. 

  459.         global namespace.</p>
    460. 

  460.         </li>
    461. 

  461.     </ol>
    462. 

  462.     <p class="TypedExample">from System.Math import *</p>
    463. 

  463.     <p class="UserCode">dir()</p>
    464. 

  464.     <p class="HiddenCode">set1 = set(dir())
    465. 

  465. set2 = set(dir(object))
    466. 

  466. list(set1-set2)
    467. 

  467.     </p>
    468. 

  468. 	<p class="HiddenOutput">
    469. 

  469. 

  470. 

  471. 	['Tan','Sin','Ceiling','Sinh','Atan','Tanh','__name__','Pow','Cos','Cosh','Abs','Round','Atan2','BigMul','Acos','DivRem','Truncate','E','Max','__builtins__','Log','Asin','Floor','PI','Log10','System','Sign','Exp','Min','IEEERemainder','Sqrt']</p>
    472. 

  472.     <p class="Stepnonumbering">Now you can call Math methods without having to specify
    473. 

  473.     the namespace and class name prefix:</p>
    474. 

  474.     <p class="TypedExample">Sin(PI/2)</p>
    475. 

  475.     <p class="Stepnonumbering">&nbsp;</p>
    476. 

  476.     <p class="Stepnonumbering">The expected output is:</p>
    477. 

  477.     <p class="Code-Highlighted">&gt;&gt;&gt; from System.Math import *</p>
    478. 

  478.     <p class="Code-Highlighted">&gt;&gt;&gt; dir()</p>
    479. 

  479.     <p class="NoVerify-Background">
    480. 

  480.     ['Abs', 'Acos', 'Asin', 'Atan', 'Atan2', 'BigMul', 'Ceiling', 'Cos', 'Cosh', 'DivRem', 'E', 'Equals', 'Exp', 'Floor', 'GetHashCode', 'GetType', 'IEEERemainder', 'Log', 'Log10', 'Max', 'Min', 'PI', 'Pow', 'Round', 'Sign', 'Sin', 'Sinh', 'Sqrt', 'System', 'Tan', 'Tanh', 'ToString', 'Truncate', '__builtins__', '__doc__', '__name__']</p>
    481. 

  481.     <p class="Code-Highlighted">&gt;&gt;&gt; Sin(PI/2)</p>
    482. 

  482.     <p class="Code-Background">1.0</p>
    483. 

  483.     <h3><a name="T1.2.2">Task 2: Working with .NET classes</a></h3>
    484. 

  484.     <ol>
    485. 

  485.         <li>
    486. 

  486.         <p class="Step">Import the contents of the &quot;System.Collections&quot; namespace
    487. 

  487.         into the global namespace:</p>
    488. 

  488.         </li>
    489. 

  489.     </ol>
    490. 

  490.     <p class="TypedExample">from System.Collections import *</p>
    491. 

  491.     <p class="Code-Background"></p>
    492. 

  492.     <ol start="2">
    493. 

  493.         <li>
    494. 

  494.         <p class="Step">Create instance of the Hashtable class and explore the instance
    495. 

  495.         using dir():</p>
    496. 

  496.         </li>
    497. 

  497.     </ol>
    498. 

  498.     <p class="TypedExample">h = Hashtable()</p>
    499. 

  499.     <p class="Code-Background"></p>
    500. 

  500.     <p class="UserCode">dir(h)</p>
    501. 

  501.     <p class="HiddenCode">set1 = set(dir(h))
    502. 

  502. set2 = set(dir(object))
    503. 

  503. list(set1-set2)</p>
    504. 

  504.     <p class="HiddenOutput">
    505. 

  505.     
    506. 

  506.     ['Keys','GetObjectData','Count','Contains','__getitem__','KeyEquals','hcp','Clone','SyncRoot','__setitem__','Remove','Clear','comparer','__len__','ContainsValue','Add','__add__','EqualityComparer','GetHash','IsFixedSize','ContainsKey','CopyTo','GetEnumerator','Synchronized','__iter__','IsReadOnly','__contains__','Item','Values','IsSynchronized','OnDeserialization']</p>
    507. 

  507.     <ol start="3">
    508. 

  508.         <li>
    509. 

  509.         <p class="Step">Insert&nbsp;a few elements into the hash table:</p>
    510. 

  510.         </li>
    511. 

  511.     </ol>
    512. 

  512.     <p class="TypedExample">h['a'] = 'IronPython'</p>
    513. 

  513.     <p class="Code-Background"></p>
    514. 

  514.     <p class="TypedExample">h['b'] = 'Tutorial'</p>
    515. 

  515.     <p class="Code-Background"></p>
    516. 

  516.     <p class="Stepnonumbering">&nbsp;</p>
    517. 

  517.     <p class="Stepnonumbering">IronPython supports the C#-style syntax for accessing
    518. 

  518.     the hash table elements.&nbsp; The same syntax applies to any indexable object (Arrays,
    519. 

  519.     Array lists etc):</p>
    520. 

  520.     <p class="TypedExample">h['a']</p>
    521. 

  521.     <p class="Stepnonumbering" style="page-break-after:avoid">&nbsp;</p>
    522. 

  522.     <p class="Stepnonumbering" style="page-break-after:avoid">The output of this
    523. 

  523.     step will be:</p>
    524. 

  524.     <p class="NoVerify-Highlighted" style="page-break-after:avoid">&gt;&gt;&gt; h['a'] = 'IronPython'<br />
    525. 

  525.     &gt;&gt;&gt; h['b'] = 'Tutorial'</p>
    526. 

  526.     <p class="Code-Highlighted" style="page-break-after:avoid">&gt;&gt;&gt; h['a']</p>
    527. 

  527.     <p class="Code-Background">'IronPython'</p>
    528. 

  528.     <ol start="4">
    529. 

  529.         <li>
    530. 

  530.         <p class="Step">Enumerate the contents of the hash table using the &quot;for
    531. 

  531.         ... in ...&quot; statement. The hash table elements are instances of &quot;DictionaryEntry&quot;
    532. 

  532.         class. Print the &quot;Key&quot; and &quot;Value&quot; properties of each entry:</p>
    533. 

  533.         </li>
    534. 

  534.     </ol>
    535. 

  535.     <p class="TypedExample">for e in h: print e.Key, ':', e.Value</p>
    536. 

  536.     <p class="Stepnonumbering">&nbsp;</p>
    537. 

  537.     <p class="Stepnonumbering">The expected output in the console is as follows. Note that
    538. 

  538.     the input line starting with 'for' requires an extra return or enter key press because
    539. 

  539.     the interpreter prompts for more statements in the loop's body.</p>
    540. 

  540.     <p class="Code-Highlighted">&gt;&gt;&gt; for e in h: print e.Key, ':', e.Value<br>
    541. 

  541.     ...</p>
    542. 

  542.     <p class="Code-Background">a : IronPython<br />
    543. 

  543.     b : Tutorial</p>
    544. 

  544.     <ol start="5">
    545. 

  545.         <li>
    546. 

  546.         <p class="Step">You can initialize the collection classes using instances
    547. 

  547.         of the built-in list or tuple data types as arguments.&nbsp; You can
    548. 

  548.         create a Python list by specifying the list of elements in square brackets: [1,2,3].&nbsp;
    549. 

  549.         You create tuples by specifying elements in the parentheses: (1,2,3).</p>
    550. 

  550.         </li>
    551. 

  551.     </ol>
    552. 

  552.     <p class="TypedExample">l = ArrayList([1,2,3])</p>
    553. 

  553.     <p class="Code-Background"></p>
    554. 

  554.     <p class="TypedExample">for i in l: print i</p>
    555. 

  555.     <p class="TypedExample">s = Stack((1,2,3))</p>
    556. 

  556.     <p class="TypedExample">while s.Count: s.Pop()</p>
    557. 

  557.     <p class="Stepnonumbering">&nbsp;</p>
    558. 

  558.     <p class="Stepnonumbering">The expected output is:</p>
    559. 

  559.     <p class="Code-Highlighted">&gt;&gt;&gt; l = ArrayList([1,2,3])<br />
    560. 

  560.     &gt;&gt;&gt; for i in l: print i<br>
    561. 

  561.     ...</p>
    562. 

  562.     <p class="Code-Background">1<br />
    563. 

  563.     2<br />
    564. 

  564.     3</p>
    565. 

  565.     <p class="Code-Background"></p>
    566. 

  566.     <p class="Code-Highlighted">&gt;&gt;&gt; s = Stack((1,2,3))<br />
    567. 

  567.     &gt;&gt;&gt; while s.Count: s.Pop()<br>...</p>
    568. 

  568.     <p class="Code-Background">3<br />
    569. 

  569.     2<br />
    570. 

  570.     1</p>
    571. 

  571.     <h3><a name="T1.2.3">Task 3: Generics</a></h3>
    572. 

  572.     <ol>
    573. 

  573.         <li>
    574. 

  574.         <p class="Step">Import the Generic collections from the System.Collections.Generic
    575. 

  575.         namespace:</p>
    576. 

  576.         </li>
    577. 

  577.     </ol>
    578. 

  578.     <p class="TypedExample">from System.Collections.Generic import *</p>
    579. 

  579.     <p class="Code-Background"></p>
    580. 

  580.     <ol start="2">
    581. 

  581.         <li>
    582. 

  582.         <p class="Step">To instantiate a generic class, the generic type arguments
    583. 

  583.         must be specified.&nbsp; IronPython uses the following syntax to specify the type
    584. 

  584.         arguments: generic_type[type_argument, ...].&nbsp; Create an instance of generic
    585. 

  585.         list of string:</p>
    586. 

  586.         </li>
    587. 

  587.     </ol>
    588. 

  588.     <p class="TypedExample">l = List[str]()</p>
    589. 

  589.         <p class="Code-Background"></p>
    590. 

  590.     <ol start="3">
    591. 

  591.         <li>
    592. 

  592.         <p class="Step">Add string values into the list. Since we created a list of
    593. 

  593.         string, adding strings is possible:</p>
    594. 

  594.         </li>
    595. 

  595.     </ol>
    596. 

  596.     <p class="TypedExample">l.Add(&quot;Hello&quot;)</p>
    597. 

  597.         <p class="Code-Background"></p>
    598. 

  598.     <p class="TypedExample">l.Add(&quot;Hi&quot;)</p>
    599. 

  599.         <p class="Code-Background"></p>
    600. 

  600.     <ol start="4">
    601. 

  601.         <li>
    602. 

  602.         <p class="Step">Try adding objects of types other than string:</p>
    603. 

  603.         </li>
    604. 

  604.     </ol>
    605. 

  605.     <p class="ExceptionExample">l.Add(3)</p>
    606. 

  606.     <p class="Code-Background"></p>
    607. 

  607.     <p class="ExceptionExample">l.Add(2.5)</p>
    608. 

  608.     <p class="Code-Background"></p>
    609. 

  609.     <p class="ExceptionExample">l.Add([1,2,3])</p>
    610. 

  610.     <p class="Code-Background"></p>
    611. 

  611.     <p class="Stepnonumbering">&nbsp;</p>
    612. 

  612.     <p class="Stepnonumbering">Obviously, adding non-strings will result in a type error:</p>
    613. 

  613.     <p class="Code-Highlighted">&gt;&gt;&gt; l.Add(3)</p>
    614. 

  614.     <p class="NoVerify-Background">Traceback (most recent call last):<br />
    615. 

  615. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    616. 

  616. TypeError: expected str, got int<br /></p>
    617. 

  617.     <p class="Code-Highlighted">&gt;&gt;&gt; l.Add(2.5)</p>
    618. 

  618.     <p class="NoVerify-Background">Traceback (most recent call last):<br />
    619. 

  619. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    620. 

  620. TypeError: expected str, got float<br /></p>
    621. 

  621.     <p class="Code-Highlighted">&gt;&gt;&gt; l.Add([1,2,3])</p>
    622. 

  622.     <p class="NoVerify-Background">Traceback (most recent call last):<br />
    623. 

  623. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    624. 

  624. TypeError: expected str, got list<br /></p>
    625. 

  625.     <ol start="5">
    626. 

  626.         <li>
    627. 

  627.         <p class="Step">Enumerate the generic collection:</p>
    628. 

  628.         </li>
    629. 

  629.     </ol>
    630. 

  630.     <p class="TypedExample">for i in l: print i</p>
    631. 

  631.     <p class="Stepnonumbering">&nbsp;</p>
    632. 

  632.     <p class="Stepnonumbering">The output will be:</p>
    633. 

  633.     <p class="Code-Highlighted">&gt;&gt;&gt; for i in l: print i<br>...</p>
    634. 

  634.     <p class="Code-Background">Hello<br />
    635. 

  635. Hi</p>
    636. 

  636.     <p class="ExceptionOutput">TypeError: expected str, got int
    637. 

  637. TypeError: expected str, got float
    638. 

  638. TypeError: expected str, got list</p>
    639. 

  639.     <ol start="6">
    640. 

  640.         <li>
    641. 

  641.         <p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed
    642. 

  642.         by Enter)</p>
    643. 

  643.         </li>
    644. 

  644.     </ol>
    645. 

  645.     <h2><a name="T1.3">Exercise 3: Loading additional .NET libraries</a></h2>
    646. 

  646.     <p class="Body">IronPython can directly import only some of the .NET libraries
    647. 

  647.     - the most commonly used ones.&nbsp; To use additional .NET libraries, they must be
    648. 

  648.     explicitly referenced.&nbsp; IronPython maintains a list of all referenced
    649. 

  649.     assemblies (see clr.References in Task 1).&nbsp; To add a reference to a .NET assembly,
    650. 

  650.     use the functions available in the built-in 'clr' module:</p>
    651. 

  651.     <ul>
    652. 

  652.         <li>
    653. 

  653.         <p class="Body"><b>clr.AddReference</b> adds a reference to the .NET assembly
    654. 

  654.         either by passing the .NET assembly object directly, or specifying the file
    655. 

  655.         name or the assembly name (full or partial). This function is provided primarily
    656. 

  656.         for the kind of interactive exploration we see in this Tutorial. We recommend
    657. 

  657.         using the following functions in your code modules, since they provide more control
    658. 

  658.         over which assembly gets loaded.</p>
    659. 

  659.         </li>
    660. 

  660.         <li>
    661. 

  661.         <p class="Body"><b>clr.AddReferenceToFile</b> adds a reference to the assembly
    662. 

  662.         specified by its file name. This function will load the assembly from the
    663. 

  663.         file regardless of the assembly version. As a result, it doesn't guarantee
    664. 

  664.         that the correct assembly version is being loaded. To guarantee that correct
    665. 

  665.         assembly version is being loaded, use clr.AddReferenceByName. Moreover,
    666. 

  666.         AddReferenceToFile requires that the assembly be located in a
    667. 

  667.         directory listed in sys.path.</p>
    668. 

  668.         </li>
    669. 

  669.         <li>
    670. 

  670.         <p class="Body"><b>clr.AddReferenceToFileAndPath</b> provides similar
    671. 

  671.         functionality to AddReferenceToFile. The difference is that it accepts
    672. 

  672.         absolute path and before loading the assembly, AddReferenceToFileAndPath
    673. 

  673.         adds the file path into sys.path.</p>
    674. 

  674.         </li>
    675. 

  675.         <li>
    676. 

  676.         <p class="Body"><b>clr.AddReferenceByName</b> adds a reference to the assembly
    677. 

  677.         specified by its full assembly name, for example: &quot;System.Xml, Version=2.0.0.0,
    678. 

  678.         Culture=neutral, PublicKeyToken=b77a5c561934e089&quot;.</p>
    679. 

  679.         </li>
    680. 

  680.         <li>
    681. 

  681.         <p class="Body"><b>clr.AddReferenceByPartialName</b> adds reference to the
    682. 

  682.         assembly by specifying a partial assembly name. This function cannot guarantee
    683. 

  683.         that the correct version of the assembly is being loaded. Use clr.AddReferenceByName
    684. 

  684.         to reference a specific version of the assembly.</p>
    685. 

  685.         </li>
    686. 

  686.     </ul>
    687. 

  687.     <h3><a name="T1.3.1">Task 1: Using System.Xml - AddReference</a></h3>
    688. 

  688.     <ol>
    689. 

  689.         <li>
    690. 

  690.         <p class="Step">Start the IronPython console from the tutorial directory
    691. 

  691.         (see <a href="#Intro">Introduction</a> for details).</p>
    692. 

  692.         </li>
    693. 

  693.         <li>
    694. 

  694.         <p class="Step">To import System.Xml, the reference to the assembly containing
    695. 

  695.         the Xml components must be first added to IronPython.&nbsp; Reference System.Xml
    696. 

  696.         using the following code&nbsp; (you can enter &quot;clr.References&quot; before
    697. 

  697.         and after the call to &quot;clr.AddReference&quot; to see it change if you want):</p>
    698. 

  698.         </li>
    699. 

  699.     </ol>
    700. 

  700.     <p class="TypedExample">import clr</p>
    701. 

  701.     <p class="Code-Background"></p>
    702. 

  702.     <p class="TypedExample">clr.AddReference('System.Xml')</p>
    703. 

  703.     <p class="Code-Background"></p>
    704. 

  704.     <p class="TypedExample">from System.Xml import *</p>
    705. 

  705.     <p class="Code-Background"></p>
    706. 

  706.     <p class="TypedExample">dir()</p>
    707. 

  707.     <p class="HiddenOutput">['ConformanceLevel','DtdProcessing','EntityHandling','Formatting','IHasXmlNode','IXmlLineInfo','IXmlNamespaceResolver','NameTable','NamespaceHandling','NewLineHandling','ReadState','Resolvers','Schema','Serialization','ValidationType','WhitespaceHandling','WriteState','XPath','XmlAttribute','XmlAttributeCollection','XmlCDataSection','XmlCharacterData','XmlComment','XmlConvert','XmlDateTimeSerializationMode','XmlDeclaration','XmlDocument','XmlDocumentFragment','XmlDocumentType','XmlElement','XmlEntity','XmlEntityReference','XmlException','XmlImplementation','XmlLinkedNode','XmlNameTable','XmlNamedNodeMap','XmlNamespaceManager','XmlNamespaceScope','XmlNode','XmlNodeChangedAction','XmlNodeChangedEventArgs','XmlNodeChangedEventHandler','XmlNodeList','XmlNodeOrder','XmlNodeReader','XmlNodeType','XmlNotation','XmlOutputMethod','XmlParserContext','XmlProcessingInstruction','XmlQualifiedName','XmlReader','XmlReaderSettings','XmlResolver','XmlSecureResolver','XmlSignificantWhitespace','XmlSpace','XmlText','XmlTextReader','XmlTextWriter','XmlTokenizedType','XmlUrlResolver','XmlValidatingReader','XmlWhitespace','XmlWriter','XmlWriterSettings','Xsl','__builtins__','__doc__','__name__','clr']</p>
    708. 

  708.     <ol start="3">
    709. 

  709.         <li>
    710. 

  710.         <p class="Step">Note that the clr.AddReference function accepts either System.Reflection.Assembly object or string
    711. 

  711.         as a parameter. The string parameter can
    712. 

  712.         be a full assembly name, a partial assembly name, or a file name. For more control
    713. 

  713.         over the assembly references, use the appropriate functions described
    714. 

  714.         above. </p>
    715. 

  715.         <p class="Step">For example, consider the following alternatives for the statement clr.AddReference('System.Xml') above:</p>
    716. 

  716.         </li>
    717. 

  717.     </ol>
    718. 

  718.     <p class="TypedExample">clr.AddReferenceByName('System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089')</p>
    719. 

  719.     <p class="Code-Background"></p>
    720. 

  720.     <p class="TypedExample">clr.AddReferenceByPartialName('System.Xml')</p>
    721. 

  721.     <p class="Code-Background"></p>
    722. 

  722.     <ol start="4">
    723. 

  723.         <li>
    724. 

  724.         <p class="Step">Load the XML file 'load.xml' into the XmlDocument. The
    725. 

  725.         xml file contains sample savegame data from the IronPython sample 'Puzzle' .
    726. 

  726.         For direct viewing, the load.xml file is located in the Tutorial folder</p>
    727. 

  727.         </li>
    728. 

  728.     </ol>
    729. 

  729.     <p class="TypedExample">d = XmlDocument()</p>
    730. 

  730.     <p class="Code-Background"></p>
    731. 

  731.     <p class="TypedExample">d.Load('load.xml')</p>
    732. 

  732.     <p class="Code-Background"></p>
    733. 

  733.     <ol start="5">
    734. 

  734.         <li>
    735. 

  735.         <p class="Step">We can now query the document. Query for all the saved games using the query below:</p>
    736. 

  736.         </li>
    737. 

  737.     </ol>
    738. 

  738.     <p class="TypedExample">n = d.SelectNodes('//Puzzle/SavedGames/Game/@caption')</p>
    739. 

  739.     <p class="TypedExample">for e in n: print e.Value</p>
    740. 

  740.     <p class="Stepnonumbering">&nbsp;</p>
    741. 

  741.     <p class="Stepnonumbering">The output in the console window will be:</p>
    742. 

  742.     <p class="Code-Highlighted">&gt;&gt;&gt; n = d.SelectNodes('//Puzzle/SavedGames/Game/@caption')<br />
    743. 

  743.     &gt;&gt;&gt; for e in n: print e.Value<br>...</p>
    744. 

  744.     <p class="Code-Background">
    745. 

  745.     Seattle (default game)<br />
    746. 

  746.     New York<br />
    747. 

  747.     World<br />
    748. 

  748.     North America<br />
    749. 

  749.     </p>
    750. 

  750.     <ol start="6">
    751. 

  751.         <li>
    752. 

  752.         <p class="Step">(Optional) Import the 'xmlutil.py' module located in the
    753. 

  753.         Tutorial directory and use the function provided in the module to walk the
    754. 

  754.         contents of the Xml document:</p>
    755. 

  755.         </li>
    756. 

  756.     </ol>
    757. 

  757.     <p class="TypedExample">import xmlutil</p>
    758. 

  758.     <p class="TypedExample">for e in xmlutil.Walk(d): print e.Name, e.Value</p>
    759. 

  759.     <p class="HiddenOutput">#document None
    760. 

  760. #comment  *************************************************************************
    761. 

  761.  *
    762. 

  762.  * Copyright (c) Microsoft Corporation.&nbsp;
    763. 

  763.  *
    764. 

  764.  * This source code is subject to terms and conditions of the Apache License, Version 2.0. A&nbsp;
    765. 

  765.  * copy of the license can be found in the License.html file at the root of this distribution. If&nbsp;
    766. 

  766.  * you cannot locate the  Apache License, Version 2.0, please send an email to&nbsp;
    767. 

  767.  * ironpy@microsoft.com. By using this source code in any fashion, you are agreeing to be bound&nbsp;
    768. 

  768.  * by the terms of the Apache License, Version 2.0.
    769. 

  769.  *
    770. 

  770.  * You must not remove this notice, or any other, from this software.
    771. 

  771.  *
    772. 

  772.  *
    773. 

  773.  * ***************************************************************************&nbsp;
    774. 

  774. Puzzle None
    775. 

  775. SavedGames None
    776. 

  776. Game None
    777. 

  777. caption Seattle (default game)
    778. 

  778. type a
    779. 

  779. y 714
    780. 

  780. x 327
    781. 

  781. level 11
    782. 

  782. dimension 3
    783. 

  783. Game None
    784. 

  784. caption New York
    785. 

  785. type r
    786. 

  786. y 1538
    787. 

  787. x 1205
    788. 

  788. level 12
    789. 

  789. dimension 3
    790. 

  790. Game None
    791. 

  791. caption World
    792. 

  792. type h
    793. 

  793. y 0
    794. 

  794. x 0
    795. 

  795. level 2
    796. 

  796. dimension 4
    797. 

  797. Game None
    798. 

  798. caption North America
    799. 

  799. type a
    800. 

  800. x 2
    801. 

  801. y 5
    802. 

  802. level 4
    803. 

  803. dimension 3
    804. 

  804. TopLeftPreviewTile None
    805. 

  805. x -3
    806. 

  806. y -3
    807. 

  807. dimension 3
    808. 

  808. level 5
    809. 

  809. Cache None
    810. 

  810. allow true</p>
    811. 

  811.     <p class="Stepnonumbering">The Walk function is a generator (a Python function
    812. 

  812.     that contains a &quot;yield&quot; statement). As the Walk function executes, it returns
    813. 

  813.     (yields) the XML nodes one by one to the caller, who is iterating over the generator.
    814. 

  814.     The source for the Walk function is:</p>
    815. 

  815.     <p class="CodeSample">def Walk(xml):</br>
    816. 

  816.     &nbsp;&nbsp;&nbsp; yield xml</br><br>
    817. 

  817.     &nbsp;&nbsp;&nbsp; if hasattr(xml, &quot;Attributes&quot;):<br />
    818. 

  818. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; attrs = xml.Attributes<br />
    819. 

  819. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if attrs:<br />
    820. 

  820. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for attr in attrs:</br>
    821. 

  821.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    822. 

  822.     yield attr</br><br>
    823. 

  823.     &nbsp;&nbsp;&nbsp; for child in xml:<br />
    824. 

  824. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; for c in Walk(child):</br>
    825. 

  825.     &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    826. 

  826.     yield c</p>
    827. 

  827.     <ol start="7">
    828. 

  828.         <li>
    829. 

  829.         <p class="Step">Exit the IronPython Interactive console (Ctrl+Z or F6 followed
    830. 

  830.         by Enter)</p>
    831. 

  831.         </li>
    832. 

  832.     </ol>
    833. 

  833.     <h3><a name="T1.3.2">Task 2: Mapack - Loading the .NET libraries - AddReferenceToFile</a></h3>
    834. 

  834.     <p class="Normal">This task requires the Mapack.dll library for linear algebra computations.&nbsp;
    835. 

  835.     The library is not part of the IronPython distribution. See <a href="#Mapack">prerequisites</a>
    836. 

  836.     for download details.</p>
    837. 

  837.     <ol>
    838. 

  838.         <li>
    839. 

  839.         <p class="Step">Start the IronPython console from the tutorial directory
    840. 

  840.         (see <a href="#Intro">Introduction</a> for details).</p>
    841. 

  841.         </li>
    842. 

  842.         <li>
    843. 

  843.         <p class="Step">Use the clr.AddReferenceToFile function to load the Matrix
    844. 

  844.         library &quot;Mapack.dll&quot;:</p>
    845. 

  845.         </li>
    846. 

  846.     </ol>
    847. 

  847.     <p class="TypedExample">import clr</p>
    848. 

  848.     <p class="Code-Background"></p>
    849. 

  849.     <p class="TypedExample">clr.AddReferenceToFile(&quot;Mapack.dll&quot;)</p>
    850. 

  850.     <p class="Code-Background"></p>
    851. 

  851.     <p class="TypedExample">from Mapack import *</p>
    852. 

  852.     <p class="Code-Background"></p>
    853. 

  853.     <p class="TypedExample">dir()</p>
    854. 

  854.     <p class="Stepnonumbering">The expected output will be:</p>
    855. 

  855.     <p class="Code-Highlighted">&gt;&gt;&gt; import clr<br />
    856. 

  856.     &gt;&gt;&gt; clr.AddReferenceToFile(&quot;Mapack.dll&quot;)<br />
    857. 

  857.     &gt;&gt;&gt; from Mapack import *<br />
    858. 

  858.     &gt;&gt;&gt; dir()</p>
    859. 

  859.     <p class="Code-Background">['CholeskyDecomposition', 'EigenvalueDecomposition', 'LuDecomposition', 'Matrix', 'QrDecomposition', 'SingularValueDecomposition', '__builtins__', '__doc__', '__name__', 'clr']</p>
    860. 

  860.     <p class="StepNoNumbering"></p>
    861. 

  861.     <p class="StepNoNumbering">If you're having trouble getting this to work, make sure
    862. 

  862.     Mapack.dll is on the search path. One easy way to do this is to copy Mapack.dll into
    863. 

  863.     the Tutorial direcroty (or whichever directory you're running IronPython from).</p>
    864. 

  864.     <ol start="3">
    865. 

  865.         <li>
    866. 

  866.         <p class="Step">Instantiate the Matrix class:</p>
    867. 

  867.         </li>
    868. 

  868.     </ol>
    869. 

  869.     <p class="ExceptionExample">m = Matrix()</p>
    870. 

  870.     <p class="Code-Background"></p>
    871. 

  871.     <p class="Stepnonumbering">Oops, bad arguments for the constructor.&nbsp; In the next
    872. 

  872.     step, you'll learn how to discover which constructors are available.</p>
    873. 

  873.     <p class="Code-Highlighted">Traceback (most recent call last):<br />
    874. 

  874. &nbsp;&nbsp;File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;<br />
    875. 

  875. TypeError: Matrix() takes at least 1 argument (0 given)</p>
    876. 

  876.     <ol start="4">
    877. 

  877.         <li>
    878. 

  878.         <p class="Step">Using the __doc__ attribute, find out information about
    879. 

  879.         Matrix constructors:</p>
    880. 

  880.         </li>
    881. 

  881.     </ol>
    882. 

  882.     <p class="TypedExample">print Matrix.__new__.__doc__</p>
    883. 

  883.     <p class="Code-Highlighted">&gt;&gt;&gt; print Matrix.__new__.__doc__</p>
    884. 

  884.     <p class="Code-Background">__new__(cls: type, rows: int, columns: int)<br />
    885. 

  885.     __new__(cls:type, rows: int, columns: int, value: float)<br />
    886. 

  886.     __new__(cls:type, value: Array[Array[float]])
    887. 

  887.     </p>
    888. 

  888.     <ol start="5">
    889. 

  889.         <li>
    890. 

  890.         <p class="Step">Create instances of the Matrix class using the correct constructors
    891. 

  891.         and set some matrix elements manually.&nbsp; IronPython supports custom indexing
    892. 

  892.         on .NET classes. </p>
    893. 

  893.         </li>
    894. 

  894.     </ol>
    895. 

  895.     <p class="TypedExample">m = Matrix(2, 2, 1.2)</p>
    896. 

  896.     <p class="Code-Background"></p>
    897. 

  897.     <p class="TypedExample">n = Matrix(2,1)</p>
    898. 

  898.     <p class="Code-Background"></p>
    899. 

  899.     <p class="TypedExample">n[0,0] = 4</p>
    900. 

  900.     <p class="Code-Background"></p>
    901. 

  901.     <p class="TypedExample">print m</p>
    902. 

  902.     <p class="TypedExample">print n</p>
    903. 

  903.     <p class="Code-Highlighted">&gt;&gt;&gt; m = Matrix(2, 2, 1.2)<br />
    904. 

  904.     &gt;&gt;&gt; n = Matrix(2,1)<br />
    905. 

  905.     &gt;&gt;&gt; n[0,0] = 4<br />
    906. 

  906.     &gt;&gt;&gt; print m</p>
    907. 

  907.     <p class="Code-Background">1.2 0<br />
    908. 

  908. 0 1.2<br />
    909. 

  909. </p>
    910. 

  910.     <p class="Code-Highlighted">&gt;&gt;&gt; print n</p>
    911. 

  911.     <p class="Code-Background">4<br />
    912. 

  912. 0<br />
    913. 

  913. </p>
    914. 

  914.     <ol start="6">
    915. 

  915.         <li>
    916. 

  916.         <p class="Step">(Optional) IronPython also supports overloaded operators.
    917. 

  917.         Matrix provides implementations of operators +, - (binary and unary), *,
    918. 

  918.         and equality. You can see the Python representation of these operators
    919. 

  919.         (__eq__, __add__, __mul__, __sub__, ...) using dir():</p>
    920. 

  920.         </li>
    921. 

  921.     </ol>
    922. 

  922.     <p class="UserCode">dir(m)</p>
    923. 

  923.     <p class="HiddenCode">set1 = set(dir(m))
    924. 

  924. set2 = set(dir(object))
    925. 

  925. list(set1-set2)</p>
    926. 

  926.     <p class="HiddenOutput">
    927. 

  927.     
    928. 

  928.     ['FrobeniusNorm','InfinityNorm','Rows','__neg__','__radd__','Columns','__getitem__','Symmetric','__rmul__','Inverse','__rsub__','Solve','Clone','__setitem__','Multiply','Submatrix','Subtract','Random','__eq__','Diagonal','Trace','Negate','Add','Determinant','Norm1','__sub__','__add__','Transpose','Square','Item','__mul__','__ne__']</p>
    929. 

  929.     <ol start="7">
    930. 

  930.         <li>
    931. 

  931.         <p class="Step">Make simple calculations with the matrices:</p>
    932. 

  932.         </li>
    933. 

  933.     </ol>
    934. 

  934.     <p class="TypedExample">print m * n</p>
    935. 

  935.     <p class="TypedExample">print n.Transpose() * m</p>
    936. 

  936.     <p class="TypedExample">print m * 3</p>
    937. 

  937.     <p class="TypedExample">print n + -n</p>
    938. 

  938.     <p class="Stepnonumbering">The expected output of this step is:</p>
    939. 

  939.     <p class="Code-Highlighted">&gt;&gt;&gt; print m * n</p>
    940. 

  940.     <p class="Code-Background">4.8<br />
    941. 

  941. 0<br /><br />
    942. 

  942. </p>
    943. 

  943.     <p class="Code-Highlighted">&gt;&gt;&gt; print n.Transpose() * m</p>
    944. 

  944.     <p class="Code-Background">4.8 0…
    945.

Large files files are truncated, but you can click here to view the full file