Strings

> python myscript.py

    Beautiful is better than ugly.
    Explicit is better\fthan implicit.
    Simple is better than complex.
    
>

Tuples

• Ways to create tuple objects:
  • The built-in tuple() type object: tuple("OK")
  • A tuple literal.

Tuples

>>> tuple("OK")
('O', 'K')
>>> 42, 23, "OK"
(42, 23, 'OK')
>>>

• Tuples are heterogenous.
• That is, the elements in a tuple may be different types.

Tuples

>>> a = 42, 23, 'OK'
>>> a[1]
23
>>> a[-1]
'OK'
>>> a[1:]
(23, 'OK')
>>> len(a)
3
>>>

Tuples

• Tuples may (and should) be enclosed in parentheses: (42, 23, 'OK')
• Tuples often need to be enclosed in parentheses for disambiguation (e.g., as arguments to functions)
• Empty tuples must be enclosed with parentheses: ()
• Single element tuples must have a trailing comma: (42,)
• A trailing comman never hurts and is more maintainable: (42, 23, 'OK',)

Tuple Packing

>>> a = 42, 23, "OK"
>>> x, y, z = a
>>> x
42
>>> y
23
>>> z
'OK'
>>>

• Tuples may be unpacked by assignment.
• Unpacking is very useful when a callable object returns a tuple.

Tuple Packing

>>> a = 42, 23, "OK"
>>> x, y = a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack
>>> w, x, y, z = a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 3 values to unpack
>>>

There must be equal number of elements to unpack on both sides of the assignment.

Tuple Packing

>>> a = 1
>>> b = 2
>>> b, a = a, b
>>> a
2
>>> b
1
>>>

Cool Python trick!

String Formatting

>>> "%s depends a lot on %s." % ('Python', 'tuples')
'Python depends a lot on tuples.'
>>> 

• Tuples may format strings with the formatting operator ("%").
• The string in such an expression is called format specification.
• The format specification string contains conversion specifiers ("%s") in equal numbers to the elements in the tuple.

String Formatting

• Conversion specifiers contain a conversion type.
• Conversion types are borrowed from the C language's sprintf function.

String Formatting

>>> "The cost is %.2f dollars." % (100,)
'The cost is 100.00 dollars.'
>>> 

Conversion specifiers may have a precision modifier for floating point conversions.

String Formatting

>>> "The cost is %10.2f dollars." % (100,)
'The cost is     100.00 dollars.'
>>>

Conversion specifiers may have a minimum field width modifier.

String Formatting

>>> "The cost is %*.*f dollars." % (15, 4, 100,)
'The cost is        100.0000 dollars.'
>>>

Both minimum field width and precision may be read from the tuple object.

String Formatting

>>> "The cost is %0*.*f dollars." % (15, 4, 100,)
'The cost is 0000000100.0000 dollars.'
>>>

Numeric conversions may be zero padded on the left to the minimum field width with a "0" conversion flag.

String Formatting

>>> "The cost is %-*.*f dollars." % (15, 4, 100,)
'The cost is 100.0000        dollars.'
>>>

Conversions may be left justified in the minimum field width width with a "-" conversion flag.

String Formatting

>>> "The cost is %+.2f dollars." % (100,)
'The cost is +100.00 dollars.'
>>> "The cost is %+.2f dollars." % (-100,)
'The cost is -100.00 dollars.'
>>>

Conversions may force a sign character for numeric conversions of both positive and negative values with a "+" conversion flag.

Lists

• Ways to create list objects:
  • The built-in list() type object: list((42, 23, "OK"))
  • A list literal.

Lists

>>> list((42, 23, "OK"))
[42, 23, 'OK']
>>> [42,23,"OK"]
[42, 23, 'OK']
>>>

Lists

>>> a = [42, 23, 'OK']
>>> a[1]
23
>>> a[-1]
'OK'
>>> a[1:]
(23, 'OK')
>>> len(a)
3
>>>

Lists

• Lists are mutable sequences.
• You may modify the value of a list object.
  • You may add more elements to a list object.
  • You may remove elements from a list object.
  • You may replace elements in a list object.

List Operations

>>> a = [2.0, 'OK', 3+4j, (42, 23, 'OK'), [1,2,3]]
>>> a
[2.0, 'OK', (3+4j), (42, 23, 'OK'), [1, 2, 3]]
>>> a[1]
'OK'
>>> a[1] = 2**31
>>> a
[2.0, 2147483648L, (3+4j), (42, 23, 'OK'), [1, 2, 3]]
>>>

To replace an element in a list object, put the subscription operator on the left hand side of an assignment statement.

List Operations

>>> a
[2.0, 2147483648L, (3+4j), (42, 23, 'OK'), [1, 2, 3]]
>>> del a[2]
>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3]]
>>> 

To remove an element from a list object, use the del keyword with the subscription operator.

List Operations

>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3]]
>>> a.append("spam")
>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam']
>>> 

• To add an element to a list object, use the append() method which all list objects have.
• The append() method returns the special None object.

The None Object

>>> None
>>> type(None)
<type 'NoneType'>
>>> 

• The None object is a built-in object which denotes an object with no value.
• The None object is a Singleton.
• The None object has its own type: NoneType

The None Object

>>> None
>>> type(None)
<type 'NoneType'>
>>> dir(None)
['__class__', '__delattr__', '__doc__', '__getattribute__', '__hash__',
'__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__str__']
>>> a = None
>>> a
>>> 

• The None object has no regular methods.
• Like any object, the None object may be bound to identifiers.

List Operations

>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam']
>>> a.extend("OK")
>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'O', 'K']
>>> a.extend((1,2,3))
>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'O', 'K', 1, 2, 3]
>>> a.extend(['python','zope','plone','grok'])
>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'O', 'K', 1, 2, 3,
'python', 'zope', 'plone', 'grok']
>>>

Use the extend() method to add all the elements from another sequence to the end of a list object.

List Operations

>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'O', 'K', 1, 2, 3,
'python', 'zope', 'plone', 'grok']
>>> del a[5:10]
>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python', 'zope',
'plone', 'grok']
>>> 

slice objects as subsciptions may remove entire slices of a list object using the del keyword.

List Operations

>>> a
[2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python', 'zope',
'plone', 'grok']
>>> a.insert(0,3e6)
>>> a
[3000000.0, 2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python',
'zope', 'plone', 'grok']
>>>

The insert() method of list objects allows you to insert an arbitrary object before any index which already exists.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python',
'zope', 'plone', 'grok']
>>> a.insert(25,3e6)
>>> a
[3000000.0, 2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python',
'zope', 'plone', 'grok', 3000000.0]
>>> a.insert(50,3e6)
>>> a
[3000000.0, 2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python',
'zope', 'plone', 'grok', 3000000.0, 3000000.0]
>>> 

Or at the end of a list object if the index does not already exist.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, (42, 23, 'OK'), [1, 2, 3], 'spam', 'python',
'zope', 'plone', 'grok', 3000000.0, 3000000.0]
>>> a[3:-1] = 'sprint'
>>> a
[3000000.0, 2.0, 2147483648L, 's', 'p', 'r', 'i', 'n', 't', 3000000.0]
>>>

• To replace a slice of a list object:
  • Use a slice object subscription on the left hand side of an assignment,
  • And a sequence to replace the slice with on the right hand side of the assignment.
• The elements on the right hand sequence replace the elements of the left hand slice.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, 's', 'p', 'r', 'i', 'n', 't', 3000000.0]
>>> a[3:-1] = ('sprint',)
>>> a
[3000000.0, 2.0, 2147483648L, 'sprint', 3000000.0]
>>>

To replace a slice of a list object with a sequence instead of the elements of a sequence, wrap the replacement sequence in another sequence.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, 'sprint', 3000000.0]
>>> a[3:] = ('plone',)
>>> a
[3000000.0, 2.0, 2147483648L, 'plone']
>>> 

To replace a slice of a list object through to the end of the list, omit the stop index of the slice object.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, 'plone']
>>> b = a[:]
>>> b
[3000000.0, 2.0, 2147483648L, 'plone']
>>>

You may make a copy of a list object by using a slice object on the right hand side of an assigment statement where both the start and stop indices have been omitted.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, 'plone']
>>> b = a[:]
>>> b
[3000000.0, 2.0, 2147483648L, 'plone']
>>> a == b
True
>>>

The list object and its copy have equivalent value.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, 'plone']
>>> b = a[:]
>>> b
[3000000.0, 2.0, 2147483648L, 'plone']
>>> a == b
True
>>> a is b
False
>>>

But the original object and its copy are two distinctly different objects.

List Operations

>>> id(a)
2446960
>>> id(b)
2386320
>>>

The original object and its copy have different object id values.

List Operations

>>> a
[3000000.0, 2.0, 2147483648L, 'plone']
>>> b
[3000000.0, 2.0, 2147483648L, 'plone']
>>> a[0] = 'python'
>>> b
[3000000.0, 2.0, 2147483648L, 'plone']
>>> b[0] = 'zope'
>>> a
['python', 2.0, 2147483648L, 'plone']
>>>

The original object and its copy are independent of one another. A change to one does not affect the other.

List Methods

>>> dir([])
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
'__delslice__', '__doc__', '__eq__', '__ge__', '__getattribute__',
'__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__setslice__', '__str__', 'append', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']
>>> 

You have already seen the append, extend, and insert methods of list objects.

List Methods

>>> a = ['bacon','spam','eggs','spam','toast','spam']
>>> a.count('spam')
3
>>>

The count() method returns the number of occurrences of an object in a list object.

List Methods

>>> a              
['bacon', 'spam', 'eggs', 'spam', 'toast', 'spam']
>>> a.index('spam')
1
>>>

The index() method returns the index of the first occurrence of an object in a list object.

List Methods

>>> a
['bacon', 'spam', 'eggs', 'spam', 'toast', 'spam']
>>> a.pop()
'spam'
>>> a
['bacon', 'spam', 'eggs', 'spam', 'toast']
>>> a.pop(2)
'eggs'
>>> a
['bacon', 'spam', 'spam', 'toast']
>>>

• The pop() method returns and removes the last object in a list object.
• If an optional integer argument is given, return and remove the object at that index from the list object.

List Methods

>>> a
['bacon', 'spam', 'spam', 'toast']
>>> a.remove('spam')
>>> a
['bacon', 'spam', 'toast']
>>> a.remove('spam')
>>> a
['bacon', 'toast']
>>> 

• The remove() method removes the first object with an equivalent value to the argument from the list object.
• remove() returns None.

List Methods

>>> a = ['first', 2, 3.0, 4L, 5+0j]
>>> a.reverse()
>>> a
[(5+0j), 4L, 3.0, 2, 'first']
>>>

• The reverse() method reverses the order of all elements in a list object in place.
• A new list object is not created.
• The same list object is mutated.
• reverse() returns None.

List Methods

>>> a = ['one', 42, 'abc', 23, 'two']
>>> a.sort()
>>> a
[23, 42, 'abc', 'one', 'two']
>>>

• The sort() method attemps to sort all elements in a list object in place.
• A new list object is not created.
• The same list object is mutated.
• sort() returns None.

Tuple Methods?

>>> dir(())
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__',
'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__str__']
>>>

• Tuples have no regular methods.
• Because tuple objects are immutable.

String Methods

>>> dir("")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__',
'__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__',
'__str__', 'capitalize', 'center', 'count', 'decode', 'encode',
'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha',
'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'replace', 'rfind', 'rindex', 'rjust', 'rsplit',
'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase',
'title', 'translate', 'upper', 'zfill']
>>>

str objects are immutable, too.

String Methods

>>> dir("")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__',
'__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__',
'__str__', 'capitalize', 'center', 'count', 'decode', 'encode',
'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha',
'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'replace', 'rfind', 'rindex', 'rjust', 'rsplit',
'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase',
'title', 'translate', 'upper', 'zfill']
>>>

But str objects have lots of regular methods!

String Methods

>>> dir("")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__',
'__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__',
'__str__', 'capitalize', 'center', 'count', 'decode', 'encode',
'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha',
'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'replace', 'rfind', 'rindex', 'rjust', 'rsplit',
'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase',
'title', 'translate', 'upper', 'zfill']
>>>

Most of which return new str objects.

String Methods

>>> 'pYtHoN'.capitalize()
'Python'
>>>

Return a copy of the str object with only the first character capitalized.

String Methods

>>> 'python'.center(20)
'       python       '
>>> 'python'.center(20,'*')
'*******python*******'
>>>

• Return a copy of the str object centered in a str object of the specified width.
• Padding is done using the specified fill character.
• The default fill character is a space.

String Methods

>>> 'python python python'.count('python')
3
>>> 'python python python'.count('python',6)
2
>>> 'python python python'.count('python',6,15)
1
>>>

• Return the number of non-overlapping occurrences of a substring in the str object.
• Optional arguments are interpreted as the start and stop index as in a slice object.

String Methods

>>> 'Python loves strings.'.endswith('strings')
False
>>> 'Python loves strings.'.endswith('strings.')
True
>>>

Return True if the str object ends with the specified suffix str object, False otherwise.

String Methods

>>> 'Python loves strings.'.endswith(('strings.','tuples.','lists.'))
True
>>> 'Python loves strings.'.endswith('strings.',6)
True
>>> 'Python loves strings.'.endswith('strings.',6,10)
False
>>>

• The suffix may also be a tuple of str objects to try.
• Optional arguments are interpreted as the start and stop index as in a slice object.

String Methods

>>> 'Python loves strings.'.startswith('python')
False
>>> 'Python loves strings.'.startswith('Python')
True
>>>

Return True if the str object starts with the specified prefix str object, False otherwise.

String Methods

>>> 'I\tlove\tPython.'.expandtabs()
'I       love    Python.'
>>> 'I\tlove\tPython.'.expandtabs(6)
'I     love  Python.'
>>>

• Return a copy of the str object where all tab characters are expanded using spaces.
• If the tab size is not given, a tab size of 8 characters is assumed.

String Methods

>>> 'To python, or not to python'.find('python')
3
>>> 'To python, or not to python'.find('python',5)
21
>>> 'To python, or not to python'.find('python',5,21)
-1
>>>

• Return the lowest index in the str object where the substring sub is found.
• Optional arguments are interpreted as the start and stop index as in a slice object.
• Return -1 on failure.

String Methods

>>> 'To python, or not to python'.index('python')
3
>>> 'To python, or not to python'.index('python',5)
21
>>> 'To python, or not to python'.index('python',5,21)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>

• index() is like find().
• But raise a ValueError Exception when the substring is not found.

String Methods

>>> 'python123'.isalnum()
True
>>> 'python 123'.isalnum()
False
>>> ''.isalnum()
False
>>> 

Return True if all characters in the str object are alphanumeric and there is at least one character. False otherwise.

String Methods

>>> 'python1'.isalpha()
False
>>> '123'.isdigit()
True
>>> 'python'.islower()
True
>>> 'python'.isupper()
False
>>> '\t\n   \f'.isspace()
True
>>> 'Big Newspaper Headline'.istitle()
True
>>>

String Methods

>>> 'python in a nutshell'.title()
'Python In A Nutshell'
>>>

• Return a title-cased version of the str object,
• i.e. words start with uppercase characters, all remaining characters are lowercase.

Line Continuation

• Python allows code enclosed in parentheses, square brackets, or curly braces to be continued across one or more lines.
• Interleaving whitespace is ignored.
• The Python interpreter will change prompts to three dots until all nested punctuation is closed.

String Methods

>>> ' '.join(['A','day','without','Python','is','like',
...           'a','day','without','sunshine.'])
'A day without Python is like a day without sunshine.'
>>>

• Return a str object which is the concatenation of the str objects in a sequence.
• The separator between the sequence elements is the str object.

String Methods

>>> ''.join(['A','day','without','Python','is','like',
...           'a','day','without','sunshine.'])
'AdaywithoutPythonislikeadaywithoutsunshine.'
>>>

String Methods

>>> print '\n'.join(['A','day','without','Python','is','like',
...                  'a','day','without','sunshine.'])
A
day
without
Python
is
like
a
day
without
sunshine.
>>>

String Methods

>>> 'python'.ljust(20)
'python              '
>>> 'python'.ljust(20,'*')
'python**************'
>>>

• Return a copy of the str object left justified in a str object of the specified width.
• Padding is done using the specified fill character.
• The default fill character is a space.

String Methods

>>> 'pYtHoN'.lower()
'python'
>>> 'pYtHoN'.upper()
'PYTHON'
>>>

Return a copy of the str object converted to upper or lower rcase.

String Methods

>>> '   python   '.lstrip()
'python   '
>>> '\t\n\tpython\t\n\t'.lstrip()
'python\t\n\t'
>>> 'lalapythonlala'.lstrip('la')
'pythonlala'
>>> 

• Return a copy of the str object with leading whitespace removed.
• If a leading str object is specified, remove the leading str objects instead.

String Methods

>>> '   python   '.strip()
'python'
>>> '\t\n\tpython\t\n\t'.strip()
'python'
>>> 'lalapythonlala'.strip('la')
'python'
>>> 

• Return a copy of the str object with both leading and trailing whitespace removed.
• If a second str object is specified, remove the leading and trailing specified str objects instead.

String Methods

>>> 'python2.4 python2.4 python2.4'.replace('python2.4','python2.5')
'python2.5 python2.5 python2.5'
>>> 'python2.4 python2.4 python2.4'.replace('python2.4','python2.5',2)
'python2.5 python2.5 python2.4'
>>>

• Return a copy of the str object with all occurrences of the first specified substring replaced by the second specified substring.
• If an optional count argument is given, only the first count number of occurrences are replaced.

String Methods

• Equivalent right to left search methods of str objects:
  • rfind()
  • rindex()
  • rjust()
  • rsplit()
  • rstrip()

String Methods

>>> 'python\t\npython\t\npython'.split()
['python', 'python', 'python']
>>> 'python**python**python'.split('**')
['python', 'python', 'python']
>>> 'python**python**python'.split('*',1)
['python', '*python**python']
>>> 

• Return a list object of the str objects in the str object, using the optional separator str object as a delimiter.
• If no optional separator str object is specified, any whitespace is a separator.
• If a second optional count argument is given, at most count number of splits are performed.

String Methods

>>> """
... Beautiful is better than ugly.
... Explicit is better than implicit.
... Simple is better than complex.
... """.splitlines()
['', 'Beautiful is better than ugly.',
'Explicit is better than implicit.',
'Simple is better than complex.']
>>>

• Return a list object of the str objects in the str object, breaking at line boundaries.

String Methods

>>> """
... Beautiful is better than ugly.
... Explicit is better than implicit.
... Simple is better than complex.
... """.splitlines(True)
['\n', 'Beautiful is better than ugly.\n',
'Explicit is better than implicit.\n',
'Simple is better than complex.\n']
>>>

• Return a list object of the str objects in the str object, breaking at line boundaries.
• Line breaks are not included in the resulting elements unless a True object is specified as an optional argument.

String Methods

>>> 'pYtHoN'.swapcase()
'PyThOn'
>>>

Return a copy of the str object with uppercase characters converted to lowercase and vice versa.

Python Syntax

• A backslash at the end of a line is a continuation character.
• A continuation character allows a statement to be continuted on the next line.
• Continuation is a way of breaking up long statements into something more manageable.

String Methods

>>> a = '\xff\xfe\xfd\xfc\xfb\xfa\xf9\xf8\xf7\xf6\xf5\xf4\xf3\xf2\xf1\xf0\
... \xef\xee\xed\xec\xeb\xea\xe9\xe8\xe7\xe6\xe5\xe4\xe3\xe2\xe1\xe0\
... \xdf\xde\xdd\xdc\xdb\xda\xd9\xd8\xd7\xd6\xd5\xd4\xd3\xd2\xd1\xd0\
... \xcf\xce\xcd\xcc\xcb\xca\xc9\xc8\xc7\xc6\xc5\xc4\xc3\xc2\xc1\xc0\
... \xbf\xbe\xbd\xbc\xbb\xba\xb9\xb8\xb7\xb6\xb5\xb4\xb3\xb2\xb1\xb0\
... \xaf\xae\xad\xac\xab\xaa\xa9\xa8\xa7\xa6\xa5\xa4\xa3\xa2\xa1\xa0\
... \x9f\x9e\x9d\x9c\x9b\x9a\x99\x98\x97\x96\x95\x94\x93\x92\x91\x90\
... \x8f\x8e\x8d\x8c\x8b\x8a\x89\x88\x87\x86\x85\x84\x83\x82\x81\x80\
... \x7f~}|{zyxwvutsrqponmlkjihgfedcba`_^]\\[ZYXWVUTSRQPONMLKJIHGFED\
... CBA@?>=<;:9876543210/.-,+*)(\'&%$#"! \
... \x1f\x1e\x1d\x1c\x1b\x1a\x19\x18\x17\x16\x15\x14\x13\x12\x11\x10\
... \x0f\x0e\r\x0c\x0b\n\t\x08\x07\x06\x05\x04\x03\x02\x01\x00'
>>> 

String Methods

>>> '\x8f\x86\x8b\x97\x90\x91'.translate(a)
'python'
>>> '!+*\x8f\x86\x8b+*!\x97\x90\x91*+!'.translate(a,'+!*')
'python'
>>>

• Return a copy of the str object, where all characters occurring in the optional second str argument are removed,
• And the remaining characters have been mapped through the required first translation str argument.
• The specified translation str object have a length 256 characters.

String Methods

>>> 'python'.zfill(20)
'00000000000000python'
>>> 'python python python python'.zfill(20)
'python python python python'
>>>

• Pad the str object with zeros on the left, to fill a field of the specified width.
• The str object is never truncated.

Sequence Operations

Sequence Operations

>>> 'h' in 'python'
True
>>> 'yth' in 'python'
True
>>> 'x' in 'python'
False
>>> 

Sequence Operations

>>> 'python' in ['python','zope','plone']
True
>>> 'python' in ['perl','ruby','java']
False
>>> 'python' in ('python','zope','plone')
True
>>> 'python' in ('perl','ruby','java')
False
>>>

Sequence Operations

>>> 'h' not in 'python'
False
>>> 'yth' not in 'python'
False
>>> 'x' not in 'python'
True
>>>

Sequence Operations

>>> 'python' not in ['python','zope','plone']
False
>>> 'python' not in ['perl','ruby','java']
True
>>> 'python' not in ('python','zope','plone')
False
>>> 'python' not in ('perl','ruby','java')
True
>>>

Sequence Operations

>>> 'zope' + '/' + 'plone'
'zope/plone'
>>> ['python','zope','plone'] + ['perl','ruby','java']
['python', 'zope', 'plone', 'perl', 'ruby', 'java']
>>> ('python','zope','plone') + ('perl','ruby','java')
('python', 'zope', 'plone', 'perl', 'ruby', 'java')
>>>

Sequence Operations

>>> 'python' * 3
'pythonpythonpython'
>>> ['python','zope','plone'] * 3
['python', 'zope', 'plone', 'python', 'zope', 'plone',
 'python', 'zope', 'plone']
>>> ('python','zope','plone') * 3
('python', 'zope', 'plone', 'python', 'zope', 'plone',
 'python', 'zope', 'plone')
>>>

Sequence Operations

>>> min('python')
'h'
>>> max('python')
'y'
>>> min('PyThOn')
'O'
>>> max('pYtHoN')
't'
>>>

Sequence Operations

>>> min(['python','zope','plone'])
'plone'
>>> max(['python','zope','plone'])
'zope'
>>> min(['python','zope','plone',min])
<built-in function min>
>>> min(['python','zope','plone',min,3.0])
3.0
>>> min([3,13,23])                    
3
>>> max([3,13,23])
23
>>>

Mapping Types

• Python has one "mapping" type: dict
• A dictionary is a collection of key-value pairs (items).
• Dictionaries are mutable.
• Dictionaries are unordered.
• Keys are unique.
• Keys must be immutable.
• Keys and values are heterogenous.

Dictionaries

>>> dict(((1, 'January'), (2, 'February'), (3, 'March')))
{1: 'January', 2: 'February', 3: 'March'}
>>> a = {4:'April', 5:'May', 6:'June'}
>>> a
{4: 'April', 5: 'May', 6: 'June'}
>>>

• Ways to create dictionary objects objects:
  • The built-in dict() type object.
    • dict() takes a sequence of key-value pairs as its argument
  • A dictionary literal.

Dictionaries

>>> a[5]
'May'
>>> a[5] = 'Beltane'
>>> a
{4: 'April', 5: 'Beltane', 6: 'June'}
>>>

• Dictionary values are indexed by key.
• The subscription operator may appear on the right of an assignment to a dictionary item's value.

Dictionary Methods

>>> dir({})
['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__',
'__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__',
'__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__',
'__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__setitem__', '__str__', 'clear', 'copy',
'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys',
'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>

Dictionaries have some useful methods.

Dictionary Methods

>>> a
{4: 'April', 5: 'Beltane', 6: 'June'}
>>> a.clear()
>>> a
{}
>>>

Dictionary Methods

>>> a = {1: 'January', 2: 'February', 3: 'March'}
>>> b = a.copy()
>>> b
{1: 'January', 2: 'February', 3: 'March'}
>>> a is b
False
>>> a == b
True
>>>

b is a shallow copy of a.

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> b
{4: 'April', 5: 'May', 6: 'June'}
>>> a.fromkeys(b, 3.0)
{4: 3.0, 5: 3.0, 6: 3.0}
>>> dict.fromkeys(b, 5L)
{4: 5L, 5: 5L, 6: 5L}
>>>

fromkeys() sets all the values in a new dict object from the keys of another dict object.

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a[3]
'March'
>>> a.get(3)
'March'
>>>

get() works almost like the subscription operator.

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: 4
>>> a.get(4)
>>> a.get(4, 'April')
'April'
>>>

Except that get() avoid raising a KeyError Exception when the key is not found.

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a.has_key(3)
True
>>> a.has_key(4)
False
>>>

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a.items()
[(1, 'January'), (2, 'February'), (3, 'March')]
>>>

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a.keys()
[1, 2, 3]
>>> a.values()
['January', 'February', 'March']
>>> a.items()
[(1, 'January'), (2, 'February'), (3, 'March')]
>>>

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a.pop(2)
'February'
>>> a
{1: 'January', 3: 'March'}
>>> a.pop(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: 4
>>> a.pop(4,'April')
'April'
>>>

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a.popitem()
(1, 'January')
>>> a
{2: 'February', 3: 'March'}
>>> a.popitem()
(2, 'February')
>>> a.popitem()
(3, 'March')
>>> a.popitem()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: 'popitem(): dictionary is empty'
>>>

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> b
{4: 'April', 5: 'May', 6: 'June'}
>>> a.update(b)
>>> a
{1: 'January', 2: 'February', 3: 'March', 4: 'April', 5: 'May', 6: 'June'}
>>> b
{4: 'April', 5: 'May', 6: 'June'}
>>>

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> b
{2: 'Imbolc', 4: 'April'}
>>> a.update(b)
>>> a
{1: 'January', 2: 'Imbolc', 3: 'March', 4: 'April'}
>>>

update() overwrites the values of keys which already exist in the target dict object.

Dictionary Methods

>>> a
{1: 'January', 2: 'February', 3: 'March'}
>>> a.setdefault(3,'April')
'March'
>>> a.setdefault(4,'April')
'April'
>>> a
{1: 'January', 2: 'February', 3: 'March', 4: 'April'}
>>>

• setdefault() works almost like get()
• Except that setdefault() will add a key which doesn't already exist with a default value.

Dictionary Operations

>>> a
{1: 'January', 2: 'February', 3: 'March', 4: 'April'}
>>> 3 in a
True
>>> 'March' in a
False
>>> 5 in a
False
>>> 5 not in a
True
>>>

Dictionary Operations

>>> a
{1: 'January', 2: 'February', 3: 'March', 4: 'April'}
>>> len(a)
4
>>>

Dictionary Operations

>>> a  
{1: 'January', 2: 'February', 3: 'March', 4: 'April'}
>>> del a[3]
>>> a
{1: 'January', 2: 'February', 4: 'April'}
>>>

String Formatting

>>> format = """%(software)s depends a lot on %(datatype)s.
... I like %(software)s."""
>>> dictionary = {'software':'python', 'datatype':'dictionaries'}
>>> print format % dictionary
python depends a lot on dictionaries.
I like python.
>>>

• Dictionaries may format strings also.
• Dictionary keys make up the format specifiers.
• The format specification contains dictionary keys within parentheses.
• Dictionary values are substituted for the keys within the format specification.
• The dictionary must have str objects for both keys and values.

Set Types

• Python has two "set" types:
  • set - mutable, unordered collections of unique, immutable, heterogenous objects,
  • frozenset - immutable, unordered collections of unique, immutable, heterogenous objects.

Set Types

>>> set(((6,), 'five', 4+0j, 3.0, 2L, 1))
set([1, 2L, 3.0, (4+0j), 'five', (6,)])
>>> set('python')
set(['h', 'o', 'n', 'p', 't', 'y'])
>>>

• set objects are created with the built-in set() type object.
• There is no set literal.
• set() takes a sequence as its argument

Set Types

>>> set(([7], (6,), 'five', 4+0j, 3.0, 2L, 1))
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: list objects are unhashable
>>> set('pythonpython')
set(['h', 'o', 'n', 'p', 't', 'y'])
>>>

• Mutable objects like list objects may not belong to set objects.
• Object in a set are unique.

Set Types

>>> a = ['eggs','spam','bacon','spam','toast','spam']
>>> a = list(set(a))
>>> a
['toast', 'eggs', 'bacon', 'spam']
>>>

• Almost cool Python trick.
• Python tricks are often called idioms.

Set and Frozenset Methods

Set and Frozenset Operations

Mutable (Only) Set Methods

Mutable (Only) Set Operations

Truth Value

That which is not False is True.

What Is False (Equivalent To)?

• 0 (and thereby 0L, 0.0, and 0+0j)
• ""
• (,)
• []
• {}
• None

What Is False (Equivalent To)?

• Everything else is equivalent to True.
• x.__nonzero__() is True checked first,
• Then x.__len__() != 0,
• If __nonzero__ and __len__ are not methods of x,
• Then object is equivalent to True.

Boolean Logic Python-Style

>>> 123 and 456
456
>>> '' and 456
''
>>> 123 and ''
''
>>> 0 and {}
0
>>>

• The and operator evaluates operands left to right.
• The and operator evaluates to the first operand equivalent to False.
• The and operator evaluates to the last operand if none are equivalent to False.

Boolean Logic Python-Style

>>> 123 or 456
123
>>> '' or 456
456
>>> 123 or ''
123
>>> 0 or {}
{}
>>>

• The or operator evaluates operands left to right.
• The or operator evaluates to the first operand equivalent to True.
• The or operator evaluates to the last operand if none are equivalent to True.

Conditionals

>>> if raw_input() == '456':
...     print "OK"
... else:
...     print "Not OK"
... 
456
OK
>>>

• The built-in function raw_input() returns a str object from the standard input stream.
• The expression between if and : is evaluated for truth.

Conditionals

>>> if raw_input() == '456':
...     print "OK"
... else:
...     print "Not OK"
... 
456
OK
>>>

• The indented statements after the if conditional are executed if the expression is equivalent to True.
• And skipped otherwise up to the first unindented statement (the else conditional).

Conditionals

>>> if raw_input() == '456':
...     print "OK"
... else:
...     print "Not OK"
... 
789
Not OK
>>>

• The indented statements after the else: conditional are only executed if the expression was equivalent to False.
• And skipped otherwise up to the first unindented statement.

Conditionals

Contents of myscript.py:

a = raw_input("Show me the way: ")

if a == '123':
    print 'Up.'
elif a == '456':
    print 'Down.'
else:
    print 'Sorry!'

• Mutiple elif clauses may be chained between the if clause and the else clause.
• else and elif clauses are optional.

Conditionals

> python myscript.py
Show me the way: 123
Up.
> python myscript.py
Show me the way: 456
Down.
> python myscript.py
Show me the way: 789
Sorry!
>

Code Blocks

• Flow of execution in a Python program is controlled by indentation.
• Indentation must be consistent.
• Four spaces are recommended.
• Indentation instead of punctuation makes Python one of the most readable programming languages.

Indefinite Loops

>>> a = 2
>>> while True:
...     a = a**1.01
...     print a
... 

• The expression between while and : is evaluated for truth.
• The indented statements after the while conditional are executed if the expression is equivalent to True.
• The loop is repeated until the expression is equivalent to False.

Conditionals

2.01391110011
2.02805952908
   ...
2.31395916722e+303
2.50034103172e+306
Traceback (most recent call last):
  File "<stdin>", line 3, in ?
OverflowError: (34, 'Result too large')
>>>

Indefinite Loops

>>> a = 2
>>> while True:
...     a = a**1.01
...     if a > 100: break
...     print a
... 

• The break keyword causes the containing loop to terminate.
• An if clause with one-statement body may span a single line

Indefinite Loops

2.01391110011
2.02805952908
   ...
94.1911963444
98.5712845404
>>> 

Indefinite Loops

>>> a = 2
>>> while True:
...     a = a**1.01
...     if a > 100: break
...     if a < 50: continue
...     print a
... 

The continue keyword causes the containing loop to skip the remaining statements during the current repitition.

Indefinite Loops

50.1548281185
52.1573927713
   ...
94.1911963444
98.5712845404
>>> 

Indefinite Loops

Contents of myscript.py:

prompt = "Tell me when: "

a = raw_input(prompt)

while a.lower() != "stop":
    b = list(a)
    b.reverse()
    print ''.join(b)
    a = raw_input(prompt)

Indefinite Loops

Contents of myscript.py:

> python myscript.py
Tell me when: python
nohtyp
Tell me when: zope
epoz
Tell me when: Stop
>

The range() Function

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(10,20)
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> range(10,20,2)
[10, 12, 14, 16, 18]
>>> range(20,10,-2)
[20, 18, 16, 14, 12]
>>>

• The built-in range() returns a list of int objects.
• The range() function may take start, stop, and step arguments.
• The start value is inclusive.
• The stop value is exclusive.

Iterators

• An iterator is an object which has a next() method.
• The next() method returns the next element from an iterable object in order.
• When no more elements exist in the iterable object to iterate over, a StopIteration Exception is raised.
• The iter built-in function creates an iterator object from any iterable object.
• Sequences are iterable.
• Dictionaries provide the iteritems(), iterkeys(), and itervalues() methods which return special iterator objects.

Iterators

>>> a = iter('zope')
>>> a.next()
'z'
>>> a.next()
'o'
>>> a.next()
'p'
>>> a.next()
'e'
>>> a.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
StopIteration
>>>

Iterators

>>> a = iter(range(300,0,-100))
>>> a.next()
300
>>> a.next()
200
>>> a.next()
100
>>> a.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
StopIteration
>>>

Definite Loops

>>> for x in range(10):
...     print x**2,
... 
0 1 4 9 16 25 36 49 64 81
>>>

• The for keyword starts a definite loop.
• A for loop iterates over an iterable.
• The return value of each iteration is bound to a loop control identifier.
• A trailing comma on the print statement renders a space character instead of a new line.

Definite Loops

>>> for x in xrange(10):
...     print x**2,
... 
0 1 4 9 16 25 36 49 64 81
>>>

• The built-in xrange() function returns a special iterable object instead of a list object.
• Unlike list objects, xrange objects are optimized for iterating.

Definite Loops

>>> breakfast = ['eggs','spam','bacon','spam','toast','spam']
>>> for food in breakfast:
...     print "%s for breakfast!" % food.capitalize()
... 
Eggs for breakfast!
Spam for breakfast!
Bacon for breakfast!
Spam for breakfast!
Toast for breakfast!
Spam for breakfast!
>>>

Definite Loops

>>> dictionary = {'python':'fun','zope':'useful','plone':'teh awesome'}
>>> dictionary.items()
[('python', 'fun'), ('zope', 'useful'), ('plone', 'teh awesome')]
>>> for software, description in dictionary.items():
...     print "%s is %s." % (software.capitalize(), description)
... 
Python is fun.
Zope is useful.
Plone is teh awesome.
>>>

Tuples may unpack directly into a target list of multiple loop control identifiers.

Definite Loops

>>> dictionary = {'python':'fun','zope':'useful','plone':'teh awesome'}
>>> for software, description in dictionary.iteritems():
...     print "%s is %s." % (software.capitalize(), description)
... 
Python is fun.
Zope is useful.
Plone is teh awesome.
>>>

• The iteritems() method is optimized.
• Because no intermediate list of tuples is created.

List Comprehensions

>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>

Equivalent to:

>>> a = []
>>> for x in range(10):
...     a.append(x**2)
... 
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>

Except the list comprehension is an expression.

List Comprehensions

>>> [x**2 for x in range(10) if x%2]
[1, 9, 25, 49, 81]
>>>

Equivalent to:

>>> a = []
>>> for x in range(10):
...     if x%2:
...         a.append(x**2)
... 
>>> a
[1, 9, 25, 49, 81]
>>>

x**2 is called the mapping expression.

List Comprehensions

>>> [x**2 for x in range(10) if x%2]
[1, 9, 25, 49, 81]
>>>

Equivalent to:

>>> a = []
>>> for x in range(10):
...     if x%2:
...         a.append(x**2)
... 
>>> a
[1, 9, 25, 49, 81]
>>>

x%2 is called the filter expression (if present).

List Comprehensions

>>> [x*y for x in xrange(2,8,2) for y in xrange(3,9,3)]
[6, 12, 12, 24, 18, 36]
>>>

Equivalent to:

>>> a = []
>>> for x in xrange(2,8,2):
...     for y in xrange(3,9,3):
...         a.append(x*y)
... 
>>> a
[6, 12, 12, 24, 18, 36]
>>>

Iteration may be nested.

List Comprehensions

>>> [x**y for x in xrange(6) if x%2 for y in xrange(4)]
[1, 1, 1, 1, 1, 3, 9, 27, 1, 5, 25, 125]
>>>

Equivalent to:

>>> a = []
>>> for x in xrange(6):
...     if x%2:
...         for y in xrange(4):
...             a.append(x**y)
... 
>>> a
[1, 1, 1, 1, 1, 3, 9, 27, 1, 5, 25, 125]
>>>

Iteration and filter expressions may be interspersed.

List Comprehensions

>>> [x**y for x in xrange(6) if x%2 for y in xrange(4)]
[1, 1, 1, 1, 1, 3, 9, 27, 1, 5, 25, 125]
>>>

Equivalent to:

>>> a = []
>>> for x in xrange(6):
...     if x%2:
...         for y in xrange(4):
...             a.append(x**y)
... 
>>> a
[1, 1, 1, 1, 1, 3, 9, 27, 1, 5, 25, 125]
>>>

Iteration and filter expressions may be interspersed.

Functions

>>> def f():
...     pass
... 
>>>

• This is the simplest possible function definition.
• The first line is the function header.
• All the following indented lines are the function body.
• The pass statement does nothing.
• The pass statement is present here because all functions, and all code blocks, must have at least one statement.

Functions

>>> def f(x,a,b,c):
...     print "Executing f(%s,%s,%s,%s)" % (x,a,b,c)
...     return a*x**2 - b*x + c
... 
>>>

• The function header starts with the def keyword,
• Followed by the function's identifier, which will be bound to a function object,
• Followed by a parameter list in parentheses,
• Ending in a colon.

Functions

>>> def f(x,a,b,c):
...     print "Executing f(%s,%s,%s,%s)" % (x,a,b,c)
...     return a*x**2 - b*x + c
... 
>>> f(4,3,2,1)
Executing f(4,3,2,1)
41
>>> f(4.5,3.4,2.3,1.2)
Executing f(4.5,3.4,2.3,1.2)
59.699999999999996
>>> f(5+4j,4-3j,3+2j,2-1j)
Executing f((5+4j),(4-3j),(3+2j),(2-1j))
(151+110j)
>>>

Arguments are bound to the identifiers in the parameter list when the function is called.

Functions

>>> def f(x,a,b,c):
...     print "Executing f(%s,%s,%s,%s)" % (x,a,b,c)
...     return a*x**2 - b*x + c
... 
>>> p = f(4,3,2,1)
Executing f(4,3,2,1)
>>> q = f(4.5,3.4,2.3,1.2)
Executing f(4.5,3.4,2.3,1.2)
>>> r = f(5+4j,4-3j,3+2j,2-1j)
Executing f((5+4j),(4-3j),(3+2j),(2-1j))
>>> (p,q,r)
(41, 59.699999999999996, (151+110j))
>>>

• A return statement returns the value of the function call.
• So a function call is an expression.

Functions

>>> def f(x,a,b,c):
...     print "Executing f(%s,%s,%s,%s)" % (x,a,b,c)
...     return a*x**2 - b*x + c
... 
>>> type(f)
<type 'function'>
>>> g = f
>>> g(1,2,3,4)
Executing f(1,2,3,4)
3
>>>

• Just as a function is also an expression whose value is a function object.
• Which may be bound to multiple identifiers and called.

Functions

>>> def install(application, platform='Linux', clients=1):
...     format = "Installing %s on %s with %s client(s)."
...     print format % (application, platform, clients)
... 
>>>

Parameters may have default values.

Functions

>>> def install(application, platform='Linux', clients=1):
...     format = "Installing %s on %s with %s client(s)."
...     print format % (application, platform, clients)
... 
>>> install('Grok','BSD',3)
Installing Grok on BSD with 3 client(s).
>>> install('Zope',platform='OSX',clients=2)
Installing Zope on OSX with 2 client(s).
>>>

Parameters with default values may have arguments supplied by position or name.

Functions

>>> def install(application, platform='Linux', clients=1):
...     format = "Installing %s on %s with %s client(s)."
...     print format % (application, platform, clients)
... 
>>> install('Zope',platform='OSX')
Installing Zope on OSX with 1 client(s).
>>> install('Zope',clients=2)
Installing Zope on Linux with 2 client(s).
>>> install('Zope')
Installing Zope on Linux with 1 client(s).
>>>

Supplying an argument for a parameter with a default value is optional.

Functions

>>> def install(application, platform='Linux', clients=1):
...     format = "Installing %s on %s with %s client(s)."
...     print format % (application, platform, clients)
... 
>>> install('Plone',clients=4,platform='AIX')
Installing Plone on AIX with 4 client(s).
>>>

• Optional arguments are non-positional when supplied by name after the required arguments.
• return statements are also optional
• Functions without a return statement return the None object.

Functions

>>> def arglist(a,b,c,*args):
...     print a, b, c,
...     for x in args:
...         print x,
... 
>>> arglist('python','zope','plone','grok','repoze','bfg')
python zope plone grok repoze bfg
>>>

• An indefinite number of positional arguments after the required arguments may be collected into an argument list.
• An argument list a is a tuple object bound to an identifier with the * operator.

Functions

>>> def kwlist(a,b,c,*args,**kwargs):
...     print a, b, c,
...     for x in args: print x,
...     for k, v in kwargs.items(): print "%s=%s" % (k,v),
... 
>>> kwlist('python','zope','plone',
...        'grok','repoze','bfg',
...        hanno=2305,limi=737,runyaga=730)
python zope plone grok repoze bfg hanno=2305 limi=737 runyaga=730
>>>

• An indefinite number of arbitrarily named arguments after all the positional arguments may be collected into a keyword argument list.
• A keyword argument list a is a dict object bound to an identifier with the ** operator.

Functions

>>>