<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<?xml-stylesheet type="text/xsl" href="./gus_langs.xsl"?>
<langs
  xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="http://65.194.248.73/XML/gus_langs.xsd">
	<head>
	  <navigation ToC="yes" section="yes" topic="yes" subtopic="yes" subsubtopic="yes" links="yes"/>
	  <pdfmarks body="no" section="no" topic="no" subtopic="no" subsubtopic="no"/>
	  <title>Program Operator Summary</title>
		<description>Crib sheet for programming languages</description>
		<keywords>Python</keywords>
		<author>Gan Uesli Starling</author>
		<copyright>2003, Gan Uesli Starling</copyright>
	</head>
	<body>
	<!--
		<lang>
			<name>PostScript</name>
			<type>
			  <name>stack</name>
				<clue>
					<syn>
				  	<in>x</in>
						<in>y</in> 
						<op>exch</op>
						<out>y</out>
						<out>x</out>
					</syn>
					<does>Exchange top two elements</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
				  	<in>x</in> 
						<op>dup</op>
						<in>x</in>
						<out>x</out>
					</syn>
					<does>Duplicate top element</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
				  	<in>x</in> 
						<in>y</in>
						<arg>2</arg>
						<op>copy</op>
						<in>x</in>
						<in>y</in>
						<out>x</out>
						<out>y</out>
					</syn>
					<does>Duplicate top n elements</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
				  	<in>x</in> 
						<in>y</in>
						<in>z</in>
						<arg>3</arg>
						<arg>-1</arg>
						<op>roll</op>
						<out>y</out>
						<out>z</out>
						<out>x</out>
					</syn>
					<does>Roll 3 elements up -1 times</does>
					<see></see>	
				</clue>
			</type>
			<type>
			  <name>arithmetic and math</name>
				<clue>
					<syn>
					  <in>2</in>
						<in>2</in>
						<op>add</op>
						<out>4</out>
					</syn>
					<does>Addition.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
						<in>5</in>
						<in>2</in>
						<op>div</op>
						<out>2</out>
					</syn>
					<does>Integer division</does>
					<see></see>	
				</clue>
			</type>
		</lang>
		<lang>
		  <name>Perl</name>
			<type>
			  <name>file</name>
				<clue>
					<syn><op>open(<out>VAR</out>,<in>str</in>)</op></syn>
					<does>Open a file.
					  <br />Create handle 'VAR' for path 'str'. 
					</does>
					<see>close, closedir, die, opendir, sysopen</see>	
				</clue>	
			</type>			
		</lang>
		-->
		
		<lang>
		  <name>Python</name>
			<type>
			  <name>Expressions &amp; statments</name>
				<clue>
					<syn>import <op>os</op></syn>
					<does>Import os module</does>
					<see></see>	
				</clue>
				<clue>
					<syn><out>dir</out> = <op>os.getcwd()</op></syn>
					<does>Get cwd</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>del </op><in>x</in>
						<br />
					  <op>del </op><in>x, y, z</in>
					</syn>
					<does>Delete variables</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
						<out>x </out><op>= </op><in>5 </in>
						<br />
						<out>lst </out><op>= </op><in>[1,2,3] </in>
						<br />
						<out>str </out><op>= </op><in>"foobar" </in>
						<br />
					  <out>tup </out><op>= </op><in>("one", 2, 3.0)</in>
					</syn>
					<does>Assign a value.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>x, y, z </out><op>= </op><in>1, 2, 3</in>
						<br />
						<out>(x, y, z) </out><op>= </op><in>(1, 2, 3)</in>
						<br />
						<out>x, y, z </out><op>= </op><in>[1, 2, 3]</in>
						<br />
						<out>str, lst </out><op>= </op><in>"foo", [1, 2, 3]</in>
					</syn>
					<does>Assign multiple values.</does>
					<see></see>	
				</clue>
			</type>
			
			<type>
			  <name>Boolean</name>
				<clue>
					<syn>
					  <in>x </in><op>in </op><in>(x, y, z) </in>
						<br />
					  <in>"\n" </in><op>in </op><in>"ABC\n" </in>
						<br />
					  <in>"" </in><op>in </op><in>[1, "two", 3.0, ""] </in>
					</syn>
					<does>Test membership. All true.</does>
					<see></see>	
				</clue>
				<clue>
					<syn><in>x </in><op>is </op><in> y</in></syn>
					<does>Test obj identity</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>0</out>,
					  <out>0.0</out>,
					  <out>0L</out>,
					  <out>0+0</out>,
					  <out>()</out>,
					  <out>[]</out>,
					  <out>{}</out>
					</syn>
					<does>False values.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>3 </in><op>== </op><in>3.0</in>
					</syn>
					<does>Tests as true.</does>
					<see></see>	
				</clue>
			</type>
				
			<type>
			  <name>Numeric</name>
				<clue>
					<syn>
					  <in>x </in><op>** </op><in>y </in>
						<br/>
					  <op>pow(<in>2.0, -3</in>)</op>
						<br/>
					  <op>pow(<in>x, y, z</in>)</op>
				  </syn>
					<does>Raise to a power.
					  <br/>Negative powers require float.
						<br/>Returns (x ** z) % z.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>q </out>= <in>1 </in><op>/ </op><in>2 </in>
						<br/>
					  <out>r </out>= <in>x </in><op>% </op><in>y </in>
						<br/>
					  <out>q, r </out>= <op>divmod(<in>20, 6</in>)</op>
				  </syn>
					<does>Integer divide.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>int(<in>x</in>)</op>
						<br/>
					  <op>long(<in>x</in>)</op>
						<br/>
					  <op>float(<in>x</in>)</op>
						<br/>
					  <op>complex(<in>x</in>)</op>
				  </syn>
					<does>Convert number type.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>x </in><op>&lt; </op><in>y </in><op>!= </op><in>z </in>
				  </syn>
					<does>Chained comparison.
						<br/>Example: (0 &lt; 1) + ( 1 &gt;= 1) retuns 2
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>abs(<in>1.1, 2.2</in>)</op>
				  </syn>
					<does>Returns value.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>round(<in>1.1</in>)</op>
						<br/>
					  <op>round(<in>1.1, 3</in>)</op>
						<br/>
					  <op>round(<in>1111, -3</in>)</op>
				  </syn>
					<does>Round to, below or above whole number.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>cmp(<in>x, y</in>)</op>
				  </syn>
					<does>Comparison returns: -1, 0 or 1.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>import <op>math</op>
				  </syn>
					<does>Import module.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.ceil(<in>x</in>)</op>
				  </syn>
					<does>Return rightward integer.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.floor(<in>x</in>)</op>
				  </syn>
					<does>Return leftward integer.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.exp(<in>x</in>)</op>
				  </syn>
					<does>Exponentiate.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.log(<in>x</in>)</op>
				  </syn>
					<does>Return logarithm.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.cos(<in>x</in>)</op>
				  </syn>
					<does>Cosine.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.pi(<in>x</in>)</op>
				  </syn>
					<does>Return Pi</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.modf(<in>4.5</in>)</op>
				  </syn>
					<does>Return (0.5, 4.0)</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>math.sqrt(<in>x</in>)</op>
				  </syn>
					<does>Square root.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>import <op>random</op>
				  </syn>
					<does>Import module.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>random.seed()</op>
						<br/>
					  <op>random.seed(<in>x</in>)</op>
				  </syn>
					<does>Set the seed for random.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>random.random()</op>
				  </syn>
					<does>Return rand between 0 and 1.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>random.uniform(<in>2, 3</in>)</op>
				  </syn>
					<does>Return rand like 2.8199509152488034</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>random.shuffle(<out>lst</out>)</op>
				  </syn>
					<does>Shuffle contents within object.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>random.choice(<in>"abcd"</in>)</op>
				  </syn>
					<does>Return random element.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>random.randrange(<in>6, 9</in>)</op>
				  </syn>
					<does>Return integer like 7.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>+</op><in>x</in>
				  </syn>
					<does>Return value as same polarity.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>-</op><in>x</in>
				  </syn>
					<does>Return value as opposite polarity.</does>
					<see></see>	
				</clue>
			</type>		
			
			<type>
			  <name>Types &amp; Objects</name>
				<clue>
					<syn><op>id(<in>x</in>)</op></syn>
					<does>Get id of obj</does>
					<see></see>	
				</clue>
				<clue>
					<syn><out>y </out><op>= </op><in>x </in></syn>
					<does>New var points to same obj. Same id.</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>type(<in>x</in>)</op></syn>
					<does>Get obj type.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>import <op>types </op>
						<br/>
					  <op>dir(<in>types</in>)</op>
					</syn>
					<does>List all types.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>if type(x)<op>types.ListType</op>:
				  </syn>
					<does>Compare types</does>
					<see></see>	
				</clue>
			</type>		
			
			<type>
			  <name>Bitwise</name>
				<clue>
					<syn>
					  <in>x </in><op>&lt;&lt; </op><in>y </in>
				  </syn>
					<does>Return x left-shifted by y.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>x </in><op>&gt;&gt; </op><in>y </in>
				  </syn>
					<does>Return x right-shifted by y.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>x </in><op>&amp; </op><in>y </in>
				  </syn>
					<does>Return x anded with y.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>x </in><op>| </op><in>y </in>
				  </syn>
					<does>Return x ored with y.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>x </in><op>^ </op><in>y </in>
				  </syn>
					<does>Return x xored with y.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>~</op><in>x </in>
				  </syn>
					<does>Return negation of x.</does>
					<see></see>	
				</clue>
			</type>
			
			<type>
			  <name>Sequences</name>
				<clue>
					<syn><op>range(<in><option>i, </option>j<option>, k</option></in>)</op>
				  </syn>
					<does>Return a list per: [from,] to, [step].
					</does>
					<see>Control flow: while.</see>	
				</clue>
				<clue>
					<syn><op>bisect.insort(<in>l,x</in>)</op> # lists only
						<br/>
						<br/><op>bisect.bisect(<in>l,x</in>)</op> # lists only
				  </syn>
					<does>Insert x into sorted list.
					  <br/>Return bisection index for not-yet-inserted x.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l </out>= <op>[</op><in>x, y, z</in><op>]</op>
						<br/>
					  <out>t </out>= <op>(</op><in>x, y, z</in><op>)</op>
				  </syn>
					<does>Assign list or tuple.
					  <br/>Lists are mutable, tuples immutable.
						<br/>Multi-dimensional is okay. Not always flat like in Perl.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out><op>[<in>i</in>]</op> = x
						<br/>
					  <out>l</out><op>[<in>i:j</in>]</op> = s
				  </syn>
					<does>Assign to a member or slice. Lists only, not tuples.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>import copy
					  <br/>t2 = <op>copy.deepcopy(<in>t1</in>)</op>
				  </syn>
					<does>Clone whole contents, not just references.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>list(<in>t</in>)</op> # or s 
						<br/>
					  <op>tuple(<in>l</in>)</op> # or s 
				  </syn>
					<does>Return sequence as list or tuple.</does>
					<see>Strings: str(), repr().</see>	
				</clue>
				<clue>
					<syn>
					  <in>l</in>.<op>count(<in>x</in>)</op> # not tuples
						<br/>
					  <in>s</in>.<op>count(<in>s</in>)</op> # not tuples
				  </syn>
					<does>Return count of member.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>l</in>.<op>index(<in>x</in>)</op> # not tuples
						<br/>
					  <in>s</in>.<op>index(<in>s</in>)</op> # not tuples
				  </syn>
					<does>Return lowest index of member.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>append(<in>x</in>)</op> # lists only
				  </syn>
					<does>Append new member to list.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>del </op><out>l</out><in>[i]</in> # lists only
						<br/>
					  <op>del </op><out>l</out><in>[i:j]</in> # lists only
				  </syn>
					<does>Delete member or slice.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>sort()</op> # lists only
				  </syn>
					<does>Sort list in place.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>reverse()</op> # lists only
				  </syn>
					<does>Reverse list in place.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>pop(<in>i</in>)</op> # lists only
				  </syn>
					<does>Remove &amp; return member at index (last item by default).</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>remove(<in>x</in>)</op> # lists only
				  </syn>
					<does>Remove first member 'x' from list.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>insert(<in>i, x</in>)</op> # lists only
				  </syn>
					<does>Insert new member to list at index i.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>l</out>.<op>extend(<in>l</in>)</op> # lists only
				  </syn>
					<does>Extend one list with members from another.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>seq </in><op>+ </op><in>seq </in>
				  </syn>
					<does>Return concatenation.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>seq </in><op>* </op><in>i </in>
						<br/>
					  <in>i </in><op>* </op><in>seq </in>
				  </syn>
					<does>Return i copies of s.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>seq</in><op>[<in>i</in>]</op>
						<br/>
					  <in>seq</in><op>[<in>:</in>]</op>
						<br/>
					  <in>seq</in><op>[<in>i:j</in>]</op>
						<br/>
					  <in>seq</in><op>[<in>i:</in>]</op>
						<br/>
					  <in>seq</in><op>[<in>:i</in>]</op>
				  </syn>
					<does>Return index or slice. 
					  <br/>Negative i and/or j count back from end.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>x </in><op>in </op><in>seq </in>
						<br/>
					  <in>x </in>not <op>in </op><in>seq </in>
				  </syn>
					<does>Test membership.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>for </op>x in seq:
				  </syn>
					<does>Iterate over seq.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>len(<in>seq</in>)</op>
				  </syn>
					<does>Return length of sequence.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>max(<in>seq</in>)</op>
						<br/>
					  <op>min(<in>seq</in>)</op>
				  </syn>
					<does>Return max or min member.</does>
					<see></see>	
				</clue>
			</type>
			
			<type>
			  <name>Strings</name>
				<clue>
					<syn>See also "Sequences"
				  </syn>
					<does></does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>'foo <op>%d</op> bar' <op>% </op>x </in> # decimal
						<br/>
					  <in>'foo <op>%e</op> bar' <op>% </op>x </in> # float as exponent.
						<br/>
					  <in>'foo <op>%f</op> bar' <op>% </op>x </in> # float
						<br/>
					  <in>'foo <op>%o</op> bar' <op>% </op>x </in> # octal
						<br/>
					  <in>'foo <op>%r</op> bar' <op>% </op>x </in> # same as for repr()
						<br/>
					  <in>'foo <op>%u</op> bar' <op>% </op>x </in> # unsigned
						<br/>
					  <in>'foo <op>%x</op> bar' <op>% </op>x </in> # hex
				  </syn>
					<does>Return formatted string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>uppper()</op>
						<br/>
					  <in>s</in>.<op>lower()</op>
						<br/>
					  <in>s</in>.<op>swapcase()</op>
						<br/>
					  <in>s</in>.<op>capitalize()</op>
						<br/>
					  <in>s</in>.<op>title()</op>
				  </syn>
					<does>Return modified string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>isalpha()</op>
						<br/>
					  <in>s</in>.<op>isdigit()</op>
						<br/>
					  <in>s</in>.<op>isalnum()</op>
						<br/>
					  <in>s</in>.<op>isspace()</op>
						<br/>
					  <in>s</in>.<op>islower()</op>
						<br/>
					  <in>s</in>.<op>isupper()</op>
						<br/>
					  <in>s</in>.<op>istitle()</op>
				  </syn>
					<does>Test contents of string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>lstrip()</op>
						<br/>
					  <in>s</in>.<op>rstrip()</op>
				  </syn>
					<does>Return string sans LH or RH whitespace.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>ljust(<in>i</in>)</op>
						<br/>
					  <in>s</in>.<op>rjust(<in>i</in>)</op>
						<br/>
					  <in>s</in>.<op>center(<in>i</in>)</op>
				  </syn>
					<does>Return justified string.
					  <br/>Args: i=width.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>s </out><op>*= </op><in>i</in>
						<br/>
					  <out>s </out><op>+= </op><in>s</in>
						<br/>
					  <out>s </out><op>= </op><in>'st' 'ri' 'ng'</in>
				  </syn>
					<does>(Re)assign string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>index(<in>s<option>, i<option>, j</option></option></in>)</op>
						<br/>
					  <in>s</in>.<op>rindex(<in>s<option>, i<option>, j</option></option></in>)</op>
				  </syn>
					<does>Return lowest or highest index of sub-string. Raise ValueError if not found.
					  <br/>Optional: i=start, j=end.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>find(<in>s<option>, i<option>, j</option></option></in>)</op>
						<br/>
					  <in>s</in>.<op>rfind(<in>s<option>, i<option>, j</option></option></in>)</op>
				  </syn>
					<does>Return lowest or highest index of sub-string, or -1 if not found.
					  <br/>Optional: i=start, j=end.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>startswith(<in>s<option>, i<option>, j</option></option></in>)</op>
						<br/>
					  <in>s</in>.<op>endswith(<in>s<option>, i<option>, j</option></option></in>)</op>
				  </syn>
					<does>Test content of string.
					  <br/>Optional: i=start, j=end.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>expandtabs(<in><option>i</option></in>)</op>
				  </syn>
					<does>Return string with spaces for tabs.
					  <br/>Optional: i=size (default is 8).
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <in>s</in>.<op>replace(<in>s, s<option>, i</option></in>)</op>
				  </syn>
					<does>Return string with substitutions.
					  <br/>Optional: i=max.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>string.zfill(<in>s, i</in>)</op>
						<br/>
					  <op>string.zfill(<in>-11, 5</in>)</op>
				  </syn>
					<does>Return string zero-filled.<br/>If s='3' and i=4, then '0003'.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>import string
						<br/>foo = "aeiou"; bar = "AEIOU"
						<br/>table = string.maketrans(foo,bar)
						<br/>s = "euphoria"
						<br/><in>s</in>.<op>translate(<in>table</in>)</op>
						<br/>'EUphOrIA'
						<br/><in>s</in>.<op>translate(<in>table<option>, "ph"</option></in>)</op>
						<br/>'EUOrIA'
				  </syn>
					<does>Return string with translated chars.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
						<out>l </out>= <in>s</in>.<op>split(<in><option>s<option>, i</option></option></in>)</op>
				  </syn>
					<does>Return list of substrings.
					  <br/>Optional: s=delim, i=max.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
						<out>l </out>= <in>s</in>.<op>splitlines(<in><option>0 <i>or</i> 1</option></in>)</op>
				  </syn>
					<does>Return list of lines w/ or w/o delims.
					  <br/>Optional: if bool=1 keep line ends.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
						<in>s</in>.<op>join(<in>l</in>)</op>
						<br/>
						<in>" "</in>.<op>join(<in>l</in>)</op>
						<br/>
						<in>""</in>.<op>join(<in>l</in>)</op>
				  </syn>
					<does>Return string joined by delim from list of substrings.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
						<op>str(<in>expr</in>)</op> # 'foo'
						<br/>
						<op>repr(<in>expr</in>)</op> # "'foo'"
						<br/>
						<op>`<in>expr</in>`</op> # "'bar'"
				  </syn>
					<does>Convert to a string.</does>
					<see>Lists &amp; Tuples: list(), tuple().</see>	
				</clue>
				<clue>
					<syn>
						<op>ord(<in>c</in>)</op>
						<br/>
						<op>chr(<in>i</in>)</op> 
						<br/>
						<op>unichr(<in>i</in>)</op> 
				  </syn>
					<does>Return converted char or ordinal.</does>
					<see></see>	
				</clue>
			</type>	
			
			<type>
			  <name>Dictionaries</name>
				<clue>
					<syn>
					  <op>d(<in>k</in>)</op>
				  </syn>
					<does>Return value.</does>
					<see></see>	
				</clue>
				
				<clue>
					<syn>
					  <op>d(<in>k</in>)</op> = x
				  </syn>
					<does>Assogm value.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>del</op> <in>d[k]</in>
				  </syn>
					<does>Remove key and its value.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>len(<in>d</in>)</op>
				  </syn>
					<does>Return dict length.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.clear()</op>
				  </syn>
					<does>Empty out dict.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.copy()</op>
				  </syn>
					<does>Return shallow copy of dict.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.get(<in>k<option>, x</option></in>)</op>
				  </syn>
					<does>Return value or else a default.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.has_key(<in>k</in>)</op>
				  </syn>
					<does>Test for key.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.items()</op>
				  </syn>
					<does>Return list of items.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.keys()</op>
				  </syn>
					<does>Return list of keys.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.popitem()</op>
				  </syn>
					<does>Pop random item.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.setdefault(<in>k<option>, x</option></in>)</op>
				  </syn>
					<does>Returns value or else sets &amp; returns default value.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d.update(<in>d</in>)</op>
				  </syn>
					<does>Merge another dict into this dict.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>values()</op>
				  </syn>
					<does>Return list of values.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <out>d</out> = <op>{}</op>
						<br/>
					  <out>d</out> = <op>{'foo':'bar'}</op>
				  </syn>
					<does>Assign new dict.
					  <br/>Key may be any immutable obj: string, tupple, number</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>d[<out>foo</out>]</op> = <in>'bar'</in>
						<br/>
					  <op>d[<out>1,2,3</out>]</op> = <in>'foo'</in>
						<br/>
				  </syn>
					<does>Assign new value to key in dict.</does>
					<see></see>	
				</clue>
			</type>
			
			<type>
			  <name>Control Flow</name>
				<clue>
					<syn>[ x * 3 <op>for <in>x</in> in <in>range(1,5)</in></op> ]
					  <br/># Returns: [3, 6, 9, 12].
				  </syn>
					<does>A comprehension: returns a list.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>if 1: # '1' as test-return.
						<br/>&#160;&#160;<op>pass</op>
						<br/>else:
						<br/>&#160;&#160;<op>pass</op>
				  </syn>
					<does>Do nothing. Place-holder for block.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>if 1: # '1' as test-return.
						<br/>&#160;&#160;block
						<br/>&#160;&#160;<op>break</op>
				  </syn>
					<does>Break out of loop.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>if 1: # '1' as test-return.
						<br/>&#160;&#160;block
						<br/>&#160;&#160;<op>continue</op>
				  </syn>
					<does>Skip one loop iteration.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>if <out>1</out>: </op># '1' as test-return.
						<br/>&#160;&#160;block
						<br/><op>elif <out>1</out>: </op>
						<br/>&#160;&#160;block
						<br/><op>else:</op>
						<br/>&#160;&#160;block
				  </syn>
					<does>Branch per 1 or 0 returned from test.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>while <out>1</out>: </op># '1' as test-return.
						<br/>&#160;&#160;block
						<br/><op>else:</op>
						<br/>&#160;&#160;block
				  </syn>
					<does>Loop per 1 or 0 returned from test.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>for <out>x </out>in <in>seq</in>: </op>
						<br/>&#160;&#160;block 
						<br/><op>else:</op>
						<br/>&#160;&#160;block
				  </syn>
					<does>Loop per each x in sequence. 
					  <br/>Use x in block.
					</does>
					<see>May use range() as seq.</see>	
				</clue>
			</type>
			
			<type>
			  <name>Functions</name>
				<clue>
					<syn><op>filter(<in>lambda x: x % 2, range(10)</in>)</op>
					  <br/># Filters even, returns odd: 1,3,5,7 and&#160;9.
						<br/>
						<br/>def primes(n):
						<br/>&#160;&#160;ints = range(2, n)
						<br/>&#160;&#160;i = 0
						<br/>&#160;&#160;while i &lt; len(ints):
						<br/>&#160;&#160;&#160;&#160;ints = <op>filter(<in> \
						<br/>&#160;&#160;&#160;&#160;&#160;&#160;lambda x, y = ints[i]: \
						<br/>&#160;&#160;&#160;&#160;&#160;&#160;x % y or x &lt;= y, ints</in>)</op> 
						<br/>&#160;&#160;&#160;&#160;i += 1
						<br/>&#160;&#160;return ints
				  </syn>
					<does>Return sequence sans filtered members.</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>apply(<in>foo, t</in>)</op>
				  </syn>
					<does>Call function indirectly.
					</does>
					<see>apply(func, args, kwargs)
					  <br/>equates to
						<br/>func(*args, **kwargs)
					</see>	
				</clue>
				<clue>
					<syn><op>callable(<in>foo</in>)</op>
				  </syn>
					<does>Test if callable function.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(bar)
					  <br/>&#160;&#160;<op>global </op>bar
						<br/>&#160;&#160;block
				  </syn>
					<does>Declare global argument.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>execfile(<in>foo.py<option>, globals<option>, locals</option></option></in>)</op>
				  </syn>
					<does>Execute contents from file.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>zip(<in>seq, seq <option>, seq ...</option></in>)</op>
				  </syn>
					<does>Return list of tuples. Tuples hold like-index members from each sequence.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>reduce(<in>func, x</in>)</op>
				  </syn>
					<does>Apply function to each member of sequence.
					  <br/>Returns single value: sum, procuct, etc.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>map(<in>func, seq</in>)</op>
				  </syn>
					<does>Apply function to each member of sequence.
					  <br/>May return multiple value: tuple, etc.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo = <op>lambda <in>x,y</in>: </op><out>x+y</out> # sample expr
					  <br/># Calling foo(2,4) would return 6.
				  </syn>
					<does>Return annonymous function. Lambda is an expression, and so may be nested within a def statement.
					  <br/>Disallowed within: print, for, while.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn><out>foo </out><op>= </op><in>bar</in>)
				  </syn>
					<does>Duplicate a function.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(x, y, <op>*</op><in>bar</in>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Specify arbitrary number of positional args.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(x, *y, <op>**</op><in>bar</in>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Specify arbitrary number of keyword args.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(<in>w, x = 2, *y, **z</in>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Order for combined argument-passing methods.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(<op>s, t, l</op>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Immutable args (s &amp; t) enter as local copy.
					  <br/>Mutable args (l) enter as references.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def factorial(x):
						<br/>&#160;&#160;if n == 0
						<br/>&#160;&#160;&#160;&#160;return 1
						<br/>&#160;&#160;else:
						<br/>&#160;&#160;&#160;&#160;return x * <op>factorial(<in>x - 1</in>)</op>
				  </syn>
					<does>Recursive function.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo<op>.__doc__</op>
				  </syn>
					<does>Show function's doc string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo():
					  <br/><op>"Description of foo"</op>
						<br/>&#160;&#160;block 
				  </syn>
					<does>Include doc as a string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>
					  <op>def <in>foo()</in>:</op>
						<br/>&#160;&#160;block 
				  </syn>
					<does>Define function.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(<op>x, y, z</op>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Name params in positional order.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(x, y, z):
						<br/>&#160;&#160;<op>return <in>foo(x), "bar", z</in></op>
				  </syn>
					<does>Return result (as tuple).</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(x, y, z):
						<br/>&#160;&#160;<op>pass</op> # Define later.
				  </syn>
					<does>Do nothing.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>def foo(x, y, <op><out>z </out>= <in>"bar"</in></op>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Specify default arg for param.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo(<op>"a", "b", "c"</op>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Call function with args in positional order.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo(<op><out>bar</out> = <in>1</in></op>):
						<br/>&#160;&#160;block 
				  </syn>
					<does>Call function with args in any order using keywords.</does>
					<see></see>	
				</clue>
			</type>
			
			<type>
			  <name>Files</name>
				<clue>
					<syn>sys.stdin = <op>sys.__stdin__</op>
					  <br/>sys.stdout = <op>sys.__stdout__</op>
					  <br/>sys.stderr = <op>sys.__stderr__</op>
				  </syn>
					<does>Return normal file pointers, as when restoring after redirection.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>s = <op>raw_input(<in>s</in>)</op>
				  </syn>
					<does>Prompt user, wait for input, return as string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>&lt;</op>
					  <br/><op>&gt;</op>
					  <br/><op>|</op>
				  </syn>
					<does>File redirection operators: read, write, pipe</does>
					<see></see>	
				</clue>
				<clue>
					<syn>import <op>sys</op>
					  <br/><op>sys.stdin</op>
					  <br/><op>sys.stdout</op>
					  <br/><op>sys.stderr</op>
				  </syn>
					<does>Return standard input, output, error file.</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>sys.argv</op>
					  <br/><op>sys.argv</op><in>[i]</in>
				  </syn>
					<does>Return argument values as list.</does>
					<see></see>	
				</clue>
				<clue>
					<syn><op>print &gt;&gt; </op><in>foo, x<option>, y, z</option></in>
				  </syn>
					<does>Print expression-return(s) to file.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>write(<in>l</in>)</op>
				  </syn>
					<does>Write strings from list to file.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>write(<in>s</in>)</op>
				  </syn>
					<does>Write a string to file.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>fileno()</op>
				  </syn>
					<does>Return file descriptor used by OS and other modules.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>isatty()</op>
				  </syn>
					<does>Test whether file connected to a terminal.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>softspace()</op>
				  </syn>
					<does>Test whether Python adds whitespace between print commands.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>name()</op>
				  </syn>
					<does>Return name string if opened with open().</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>closed()</op>
				  </syn>
					<does>Test if file closed.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>mode()</op>
				  </syn>
					<does>Return mode string if opened with open().</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>truncate(<in><option>i</option></in>)</op>
				  </syn>
					<does>Truncate file to i bytes max, or from current position.
					  <br/>(Not available in in some flavors of Unix)
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>tell()</op>
				  </syn>
					<does>Return file position as int.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>seek(<in>i<option>, j</option></in>)</op>
				  </syn>
					<does>Seek abs file position i, or relative i according to j.
					  <br/>Flag j: 0&#160;= from start, 1&#160;= from current pos, 2&#160;= from end.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>flush()</op>
				  </syn>
					<does>Flush file.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>close()</op>
				  </syn>
					<does>Close file.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo = <op>open(<in>"../path/foo.txt"<option>, "r"</option></in>)</op>
						<br/>
				  </syn>
					<does>Return file handle. 
					  <br/>Mode flag: r, w, a, r+, w+, a+.
					</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>read(<in><option>i</option></in>)</op>
				  </syn>
					<does>Return bytes remaining, or i bytes, as a string.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>readlines(<in><option>i</option></in>)</op>
						<br/>
				  </syn>
					<does>Return lines remaining, or i lines, as a list of strings.</does>
					<see></see>	
				</clue>
				<clue>
					<syn>foo.<op>xreadlines()</op>
						<br/>
				  </syn>
					<does>Return lines remaining from very big file.</does>
					<see></see>	
				</clue>
			</type>
				
		</lang>
	</body>

<!--
				<clue>
					<syn>
					  <op>(<in></in>)</op>
						<br/>
					  <out></out><op>(<in></in>)</op>
						<br/>
					  <out></out><op></op><in></in>
						<br/>
					  <in> </in><op> </op><in> </in>
						<br/>
						<br/>
						<br/>
						<br/>
						<br/>
				  </syn>
					<does></does>
					<see></see>	
				</clue>
			
			<type>
			  <name></name>
			</type>
-->

</langs>
