Python Basics - Revision history

Scott: /* Operations on Strings */

2017-05-04T16:40:22Z

Operations on Strings

← Older revision		Revision as of 16:40, 4 May 2017
Line 86:		Line 86:

	== Operations on Strings ==		== Operations on Strings ==
	<~~source~~ lang="python">		<syntaxhighlight lang="python">
	# formatted positional variable interpolation		# formatted positional variable interpolation
	'My name is %s, my age is %d' % (name, age)		'My name is %s, my age is %d' % (name, age)
Line 131:		Line 131:
	S.translate(table [, delchars])		S.translate(table [, delchars])
	S.upper( ) # 'Abcdef'		S.upper( ) # 'Abcdef'
	</~~source~~>		</syntaxhighlight>

	== List-Specific Operations ==		== List-Specific Operations ==

Scott at 00:41, 10 January 2014

2014-01-10T00:41:42Z

← Older revision		Revision as of 00:41, 10 January 2014
Line 18:		Line 18:
	if __name__ == "__main__":		if __name__ == "__main__":
	test()		test()
	~~</source>~~
	* To add a docstring to a function or class, add a single string as the first expression:
	~~<source lang="python">~~
	~~def myfunction():~~
	~~"This is a very useful function"~~
	~~...~~
	~~print myfunction.__doc__ # "This is a very useful function"~~
	</source>		</source>

	== Object Types ==		== Object Types ==
	* ~~<code>~~None~~</code>~~		* Null: None
	* ~~<code>bool</code> (<code>~~True~~</code> or <code>~~False~~</code~~>)		* Boolean: True, False (Python >= 2.3)
	* ~~<code>~~int~~</code>~~, ~~<code>~~float~~</code> (int is arbitrarily large~~, ~~float is accurate to 15 decimal places)~~		* Numeric: int, long, float, complex
	* ~~<code>~~str~~</code> (sequence of Unicode characters)~~		* Sequence: str, tuple, list (lists are mutable, tuples aren't)
	* <code>bytes</code> (immutable), ~~<code>bytearray</code> (mutable)~~		* Mapping: dict
	* <code>tuple~~</code> (immutable)~~, ~~<code>~~list~~</code>~~ (mutable)
	* ~~<code>set</code>~~
	* <code>dict~~</code>~~
	* Others: type, function, classobj, instance		* Others: type, function, classobj, instance
			* Lists and dictionaries are mutable.
	<source lang="python">		<source lang="python">
	type(object) # returns the type of object		type(object) # returns the type of object
Line 43:		Line 34:

	== Implied Boolean ==		== Implied Boolean ==
	None, numeric 0, empty ~~collection~~ are all ~~<code>False</code>~~. Otherwise ~~<code>True</code>~~.		None, numeric 0, empty sequence or dict are all false. Otherwise true.

	== Literals ==		== Literals ==
Line 56:		Line 47:
	[ 42, 3.14, 'hello' ] # List		[ 42, 3.14, 'hello' ] # List
	( 100, 200, 300 ) # Tuple (parentheses optional)		( 100, 200, 300 ) # Tuple (parentheses optional)
	~~{ 'a', 'b', 'c' } # Set~~
	{ 'x':42, 'y':3.14 } # Dictionary		{ 'x':42, 'y':3.14 } # Dictionary
	</source>		</source>
Line 76:		Line 66:
	x and y # returns y if x is true, otherwise returns x		x and y # returns y if x is true, otherwise returns x
	x or y # returns x if x is true, otherwise returns y		x or y # returns x if x is true, otherwise returns y
	</source>		<source>

	== Operations on Sequences ==		== Operations on Sequences ==
Line 148:		Line 138:
	x.append(3) # x == [1, 2, 3]		x.append(3) # x == [1, 2, 3]
	x.extend([3, 4]) # x == [1, 2, 3, 4]		x.extend([3, 4]) # x == [1, 2, 3, 4]
	~~x += [3,4] # x == [1, 2, 3, 4]~~
	x.insert(1, 1.5) # x == [1, 1.5, 2]		x.insert(1, 1.5) # x == [1, 1.5, 2]
	x.remove(1) # x == [2]		x.remove(1) # x == [2]
	~~del x[0] # x == [2]~~
	y = x.pop() # x == [1] and y == 2		y = x.pop() # x == [1] and y == 2
	x.reverse() # x == [2, 1]		x.reverse() # x == [2, 1]
Line 164:		Line 152:
	return a-b		return a-b
	x.sort(numeric_compare)		x.sort(numeric_compare)
	~~</source>~~

	~~== Sets ==~~
	~~<source lang="ruby">~~
	~~x = {1, 2} # create literal set~~
	~~y = set() # create empty set, {} denotes empty dict~~
	~~x.add(5) # x == {1, 2, 5}~~
	~~x.add(2) # x == {1, 2, 5}, only unique values get added~~
	</source>		</source>

Scott: /* Custom Sort Example */

2013-10-09T23:47:11Z

Custom Sort Example

← Older revision		Revision as of 23:47, 9 October 2013
Line 164:		Line 164:
	return a-b		return a-b
	x.sort(numeric_compare)		x.sort(numeric_compare)
			</source>

			== Sets ==
			<source lang="ruby">
			x = {1, 2} # create literal set
			y = set() # create empty set, {} denotes empty dict
			x.add(5) # x == {1, 2, 5}
			x.add(2) # x == {1, 2, 5}, only unique values get added
	</source>		</source>

Scott: /* List-Specific Operations */

2013-10-09T23:36:02Z

List-Specific Operations

← Older revision		Revision as of 23:36, 9 October 2013
Line 148:		Line 148:
	x.append(3) # x == [1, 2, 3]		x.append(3) # x == [1, 2, 3]
	x.extend([3, 4]) # x == [1, 2, 3, 4]		x.extend([3, 4]) # x == [1, 2, 3, 4]
	x += [3,4] # x == [1, 2, 3, 4]		x += [3,4] # x == [1, 2, 3, 4]
	x.insert(1, 1.5) # x == [1, 1.5, 2]		x.insert(1, 1.5) # x == [1, 1.5, 2]
	x.remove(1) # x == [2]		x.remove(1) # x == [2]
			del x[0] # x == [2]
	y = x.pop() # x == [1] and y == 2		y = x.pop() # x == [1] and y == 2
	x.reverse() # x == [2, 1]		x.reverse() # x == [2, 1]

Scott: /* List-Specific Operations */

2013-10-09T23:34:03Z

List-Specific Operations

← Older revision		Revision as of 23:34, 9 October 2013
Line 148:		Line 148:
	x.append(3) # x == [1, 2, 3]		x.append(3) # x == [1, 2, 3]
	x.extend([3, 4]) # x == [1, 2, 3, 4]		x.extend([3, 4]) # x == [1, 2, 3, 4]
	x + [3,4] # x == [1, 2, 3, 4]		x += [3,4] # x == [1, 2, 3, 4]
	x.insert(1, 1.5) # x == [1, 1.5, 2]		x.insert(1, 1.5) # x == [1, 1.5, 2]
	x.remove(1) # x == [2]		x.remove(1) # x == [2]

Scott: /* List-Specific Operations */

2013-10-09T23:32:29Z

List-Specific Operations

← Older revision		Revision as of 23:32, 9 October 2013
Line 148:		Line 148:
	x.append(3) # x == [1, 2, 3]		x.append(3) # x == [1, 2, 3]
	x.extend([3, 4]) # x == [1, 2, 3, 4]		x.extend([3, 4]) # x == [1, 2, 3, 4]
			x + [3,4] # x == [1, 2, 3, 4]
	x.insert(1, 1.5) # x == [1, 1.5, 2]		x.insert(1, 1.5) # x == [1, 1.5, 2]
	x.remove(1) # x == [2]		x.remove(1) # x == [2]

Scott: /* Expressions */

2013-10-09T23:30:18Z

Expressions

← Older revision		Revision as of 23:30, 9 October 2013
Line 76:		Line 76:
	x and y # returns y if x is true, otherwise returns x		x and y # returns y if x is true, otherwise returns x
	x or y # returns x if x is true, otherwise returns y		x or y # returns x if x is true, otherwise returns y
	<source>		</source>

	== Operations on Sequences ==		== Operations on Sequences ==

Scott: /* Object Types */

2013-10-09T23:24:30Z

Object Types

← Older revision		Revision as of 23:24, 9 October 2013
Line 30:		Line 30:
	* <code>None</code>		* <code>None</code>
	* <code>bool</code> (<code>True</code> or <code>False</code>)		* <code>bool</code> (<code>True</code> or <code>False</code>)
	* <code>int</code>, <code>float</code>		* <code>int</code>, <code>float</code> (int is arbitrarily large, float is accurate to 15 decimal places)
	* <code>str</code> (sequence of Unicode characters)		* <code>str</code> (sequence of Unicode characters)
	* <code>bytes</code> (immutable), <code>bytearray</code> (mutable)		* <code>bytes</code> (immutable), <code>bytearray</code> (mutable)

Scott: /* Literals */

2013-10-09T23:22:25Z

Literals

← Older revision		Revision as of 23:22, 9 October 2013
Line 56:		Line 56:
	[ 42, 3.14, 'hello' ] # List		[ 42, 3.14, 'hello' ] # List
	( 100, 200, 300 ) # Tuple (parentheses optional)		( 100, 200, 300 ) # Tuple (parentheses optional)
			{ 'a', 'b', 'c' } # Set
	{ 'x':42, 'y':3.14 } # Dictionary		{ 'x':42, 'y':3.14 } # Dictionary
	</source>		</source>

Scott: /* Implied Boolean */

2013-10-09T23:21:19Z

Implied Boolean

← Older revision		Revision as of 23:21, 9 October 2013
Line 43:		Line 43:

	== Implied Boolean ==		== Implied Boolean ==
	None, numeric 0, empty ~~sequence or dict~~ are all ~~false~~. Otherwise ~~true~~.		None, numeric 0, empty collection are all <code>False</code>. Otherwise <code>True</code>.

	== Literals ==		== Literals ==