Python

http://docs.python.org/tutorial/introduction.html

word ='help'+'A'
word ='help' 'A' # a bannir, utiliser + 

word[4] # 'A'

»> word[4]
'A'
»> word[0:2]
'He'
»> word[2:4]
'lp'
»> word[:2]    # The first two characters
'He'
»> word[2:]    # Everything except the first two characters
'lpA'
»> word[-1]     # The last character
'A'
»> word[-2]     # The last-but-one character
'p'
»> word[-2:]    # The last two characters
'pA'
»> word[:-2]    # Everything except the last two characters
'Hel'

 +—+—+—+—+—+
 | H | e | l | p | A |
 +—+—+—+—+—+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

»> s = 'supercalifragilisticexpialidocious'
»> len(s)
34

»> u'Hello\u0020World !'
u'Hello World !'
»> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

»> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

»> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

»> a = ['spam', 'eggs', 100, 1234]
»> a
['spam', 'eggs', 100, 1234]
»> a[0]
'spam'
»> a[3]
1234
»> a[-2]
100
»> a[1:-1]
['eggs', 100]
»> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
»> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']

# a shallow copy
»> a[:]

»> # Replace some items:
… a[0:2] = [1, 12]
»> a
[1, 12, 123, 1234]
»> # Remove some:
… a[0:2] = []
»> a
[123, 1234]
»> # Insert some:
… a[1:1] = ['bletch', 'xyzzy']
»> a
[123, 'bletch', 'xyzzy', 1234]
»> # Insert (a copy of) itself at the beginning
»> a[:0] = a
»> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
»> # Clear the list: replace all items with an empty list
»> a[:] = []
»> a
[]

»> a = ['a', 'b', 'c', 'd']
»> len(a)
4


»> q = [2, 3]
»> p = [1, q, 4]
»> len(p)
3
»> p[1]
[2, 3]
»> p[1][0]
2
»> p[1].append('xtra')     # See section 5.1
»> p
[1, [2, 3, 'xtra'], 4]
»> q
[2, 3, 'xtra']

»> # Fibonacci series:
… # the sum of two elements defines the next
… a, b = 0, 1
»> while b < 10:
…     print b
…     a, b = b, a+b
…
1
1
2
3
5
8

»> a, b = 0, 1
»> while b < 1000:
…     print b,
…     a, b = b, a+b
…
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

if

»> x = int(raw_input("Please enter an integer: "))
Please enter an integer: 42
»> if x < 0:
…      x = 0
…      print 'Negative changed to zero'
… elif x == 0:
…      print 'Zero'
… elif x == 1:
…      print 'Single'
… else:
…      print 'More'
…
More

for

»> # Measure some strings:
… a = ['cat', 'window', 'defenestrate']
»> for x in a:
…     print x, len(x)
…
cat 3
window 6
defenestrate 12

It is not safe to modify the sequence being iterated over in the loop (this can only happen for mutable sequence types, such as lists). If you need to modify the list you are iterating over (for example, to duplicate selected items) you must iterate over a copy. The slice notation makes this particularly convenient:

»>
»> for x in a[:]: # make a slice copy of the entire list
…    if len(x) > 6: a.insert(0, x)
…
»> a
['defenestrate', 'cat', 'window', 'defenestrate']

range

»> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

»> range(5, 10)
[5, 6, 7, 8, 9]
»> range(0, 10, 3)
[0, 3, 6, 9]
»> range(-10, -100, -30)
[-10, -40, -70]

»> a = ['Mary', 'had', 'a', 'little', 'lamb']
»> for i in range(len(a)):
…     print i, a[i]
…
0 Mary
1 had
2 a
3 little
4 lamb

»> for n in range(2, 10):
…     for x in range(2, n):
…         if n % x == 0:
…             print n, 'equals', x, '*', n/x
…             break
…     else:
…         # loop fell through without finding a factor
…         print n, 'is a prime number'
…
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

pass

»> while True:
…     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
…

»> class MyEmptyClass:
…     pass
…

»> def initlog(*args):
…     pass   # Remember to implement this!
…

»> def fib(n):    # write Fibonacci series up to n
…     """Print a Fibonacci series up to n."""
…     a, b = 0, 1
…     while a < n:
…         print a,
…         a, b = b, a+b
…
»> # Now call the function we just defined:
… fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597



»> fib
<function fib at 10042ed0>
»> f = fib
»> f(100)
0 1 1 2 3 5 8 13 21 34 55 89


»> def fib2(n): # return Fibonacci series up to n
…     """Return a list containing the Fibonacci series up to n."""
…     result = []
…     a, b = 0, 1
…     while a < n:
…         result.append(a)    # see below
…         a, b = b, a+b
…     return result
…
»> f100 = fib2(100)    # call it
»> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise IOError('refusenik user')
        print complaint

i = 5

def f(arg=i):
    print arg

i = 6
f()





def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)


[1]
[1, 2]
[1, 2, 3]

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "– This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "– Lovely plumage, the", type
    print "– It's", state, "!"
    
parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

#final formal parameter of the form **name 

def cheeseshop(kind, %*%arguments, **keywords):
    print "– Do you have any", kind, "?"
    print "– I'm sorry, we're all out of", kind
    for arg in arguments:
        print arg
    print "-" * 40
    keys = sorted(keywords.keys())
    for kw in keys:
        print kw, ":", keywords[kw]
        
# It could be called like this:

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper='Michael Palin',
           client="John Cleese",
           sketch="Cheese Shop Sketch")

 it would print:

– Do you have any Limburger ?
– I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
—————————————-
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

# documentation
»> def my_function():
…     """Do nothing, but document it.
…
…     No, really, it doesn't do anything.
…     """
…     pass
…
»> print my_function.doc
Do nothing, but document it.

    No, really, it doesn't do anything.

Data Structures
 list:
 a = [66.25, 333, 333, 1, 1234.5]
 list.append(x)
Add an item to the end of the list; equivalent to a[len(a):] = [x].

list.extend(L)
Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.

list.insert(i, x)
Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).

list.remove(x)
Remove the first item from the list whose value is x. It is an error if there is no such item.

list.pop([i])
Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.)

list.index(x)
Return the index in the list of the first item whose value is x. It is an error if there is no such item.

list.count(x)
Return the number of times x appears in the list.

list.sort()
Sort the items of the list, in place.

list.reverse()
Reverse the elements of the list, in place.


»> from collections import deque
»> queue = deque(["Eric", "John", "Michael"])
»> queue.append("Terry")           # Terry arrives
»> queue.append("Graham")          # Graham arrives
»> queue.popleft()                 # The first to arrive now leaves
'Eric'
»> queue.popleft()                 # The second to arrive now leaves
'John'
»> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])


Functional Programming Tools:

»> def f(x): return x % 2 != 0 and x % 3 != 0
…
»> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]


»> def cube(x): return x*x*x
…
»> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]


squares = [x2 for x in range(10)]

del:
»> a = [-1, 1, 66.25, 333, 333, 1234.5]
»> del a[0]
»> a
[1, 66.25, 333, 333, 1234.5]
»> del a[2:4]
»> a
[1, 66.25, 1234.5]
»> del a[:]
»> a
[]


Tuples and Sequences:

»> t = 12345, 54321, 'hello!'
»> t[0]
12345
»> t
(12345, 54321, 'hello!')

»> empty = ()
»> singleton = 'hello',    # ←- note trailing comma
»> len(empty)
0
»> len(singleton)
1
»> singleton
('hello',)


Sets:

»> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
»> fruit = set(basket)               # create a set without duplicates
»> fruit
set(['orange', 'pear', 'apple', 'banana'])
»> 'orange' in fruit                 # fast membership testing
True
»> 'crabgrass' in fruit
False

»> # Demonstrate set operations on unique letters from two words
…
»> a = set('abracadabra')
»> b = set('alacazam')
»> a                                  # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
»> a - b                              # letters in a but not in b
set(['r', 'd', 'b'])
»> a | b                              # letters in either a or b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
»> a & b                              # letters in both a and b
set(['a', 'c'])
»> a ^ b                              # letters in a or b but not both
set(['r', 'd', 'b', 'm', 'z', 'l'])


Dictionnaries:

»> tel = {'jack': 4098, 'sape': 4139}
»> tel['guido'] = 4127
»> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
»> tel['jack']
4098
»> del tel['sape']
»> tel['irv'] = 4127
»> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
»> tel.keys()
['guido', 'irv', 'jack']
»> 'guido' in tel
True



»> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
»> dict([(x, x2) for x in (2, 4, 6)])     # use a list comprehension
{2: 4, 4: 16, 6: 36}


»> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}


Looping Techniques:

»> for i, v in enumerate(['tic', 'tac', 'toe']):
…     print i, v
…
0 tic
1 tac
2 toe


»> questions = ['name', 'quest', 'favorite color']
»> answers = ['lancelot', 'the holy grail', 'blue']
»> for q, a in zip(questions, answers):
…     print 'What is your {0}?  It is {1}.'.format(q, a)
…
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.


»> for i in reversed(xrange(1,10,2)):
…     print i
…
9
7
5
3
1


»> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
»> for f in sorted(set(basket)):
…     print f
…
apple
banana
orange
pear


»> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
»> for k, v in knights.iteritems():
…     print k, v
…
gallahad the pure
robin the brave


(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

modules import

fibo.py in the current directory with the following contents:

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print b,
        a, b = b, a+b

def fib2(n): # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result
Now enter the Python interpreter and import this module with the following command:

»>
»> import fibo
This does not enter the names of the functions defined in fibo directly in the current symbol table; it only enters the module name fibo there. Using the module name you can access the functions:

»>
»> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
»> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
»> fibo.name
'fibo'


»> from fibo import fib, fib2
»> fib(500)


»> from fibo import *
»> fib(500)

Note For efficiency reasons, each module is only imported once per interpreter session. Therefore, if you change your modules, you must restart the interpreter – or, if it’s just one module you want to test interactively, use reload(), e.g. reload(modulename).

python fibo.py <arguments>

if name == "main":
    import sys
    fib(int(sys.argv[1]))

PYTHONPATH

. The Module Search Path
When a module named spam is imported, the interpreter first searches for a built-in module with that name. If not found, it then searches for a file named spam.py in a list of directories given by the variable sys.path. sys.path is initialized from these locations:

the directory containing the input script (or the current directory).
PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
the installation-dependent default.
After initialization, Python programs can modify sys.path. The directory containing the script being run is placed at the beginning of the search path, ahead of the standard library path. This means that scripts in that directory will be loaded instead of modules of the same name in the library directory. This is an error unless the replacement is intended. See section Standard Modules for more information.

compilation

The module compileall can create .pyc files (or .pyo files when -O is used) for all modules in a directory.

»> import sys
»> sys.ps1
'»> '
»> sys.ps2
'… '
»> sys.ps1 = 'C> '
C> print 'Yuck!'
Yuck!
C>

»> import sys
»> sys.path.append('/ufs/guido/lib/python')

»> import fibo, sys
»> dir(fibo)
['name', 'fib', 'fib2']
»> dir(sys)
['displayhook', 'doc', 'excepthook', 'name', 'stderr',
 'stdin', 'stdout', '_getframe', 'api_version', 'argv',
 'builtin_module_names', 'byteorder', 'callstats', 'copyright',
 'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'excepthook',
 'exec_prefix', 'executable', 'exit', 'getdefaultencoding', 'getdlopenflags',
 'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',
 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache',
 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags',
 'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',
 'version', 'version_info', 'warnoptions']

»> a = [1, 2, 3, 4, 5]
»> import fibo
»> fib = fibo.fib
»> dir()
['builtins', 'doc', 'file', 'name', 'a', 'fib', 'fibo', 'sys']


»> import builtin
»> dir(builtin)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',
 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
 'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',
 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
 'NotImplementedError', 'OSError', 'OverflowError',
 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError',
 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
 'UserWarning', 'ValueError', 'Warning', 'WindowsError',
 'ZeroDivisionError', '_', 'debug', 'doc', 'import',
 'name', 'abs', 'apply', 'basestring', 'bool', 'buffer',
 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile',
 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float',
 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter',
 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',
 'min', 'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set',
 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

packages

The init.py files are required to make Python treat the directories as containing packages; this is done to prevent directories with a common name, such as string, from unintentionally hiding valid modules that occur later on the module search path. In the simplest case, init.py can just be an empty file, but it can also execute initialization code for the package or set the all variable, described later.

from . import echo
from .. import formats
from ..filters import equalizer

»> f = open('/tmp/workfile', 'wb')
»> print f
<open file '/tmp/workfile', mode 'wb' at 80a0960>


»> f.read()
'This is the entire file.\n'
»> f.read()


»> f.readline()
'This is the first line of the file.\n'
»> f.readline()
'Second line of the file\n'
»> f.readline()



»> f.readlines()
['This is the first line of the file.\n', 'Second line of the file\n']





»> for line in f:
        print line,

This is the first line of the file.
Second line of the file


»> value = ('the answer', 42)
»> s = str(value)
»> f.write(s)


f.tell() returns an integer giving the file object’s current position in the file, measured in bytes from the beginning of the file. To change the file object’s position, use f.seek(offset, from_what). The position is computed from adding offset to a reference point; the reference point is selected by the from_what argument. A from_what value of 0 measures from the beginning of the file, 1 uses the current file position, and 2 uses the end of the file as the reference point. from_what can be omitted and defaults to 0, using the beginning of the file as the reference point.


»> f.close()



»> with open('/tmp/workfile', 'r') as f:
…     read_data = f.read()
»> f.closed
True


pickle.dump(x, f)
To unpickle the object again, if f is a file object which has been opened for reading:

x = pickle.load(f)

Exception

»> while True:
…     try:
…         x = int(raw_input("Please enter a number: "))
…         break
…     except ValueError:
…         print "Oops!  That was no valid number.  Try again…"
…


… except (RuntimeError, TypeError, NameError):
…     pass




import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except IOError as e:
    print "I/O error({0}): {1}".format(e.errno, e.strerror)
except ValueError:
    print "Could not convert data to an integer."
except:
    print "Unexpected error:", sys.exc_info()[0]
    raise




for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print 'cannot open', arg
    else:
        print arg, 'has', len(f.readlines()), 'lines'
        f.close()

padding

»> for x in range(1, 11):
…     print repr(x).rjust(2), repr(x*x).rjust(3),
…     # Note trailing comma on previous line
…     print repr(x*x*x).rjust(4)
…
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

»> for x in range(1,11):
…     print '{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x)
…
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

»> '12'.zfill(5)
'00012'
»> '-3.14'.zfill(7)
'-003.14'
»> '3.14159265359'.zfill(5)
'3.14159265359'

»> print 'We are the {} who say "{}!"'.format('knights', 'Ni')
We are the knights who say "Ni!"


»> print '{0} and {1}'.format('spam', 'eggs')
spam and eggs
»> print '{1} and {0}'.format('spam', 'eggs')
eggs and spam

»> print 'This {food} is {adjective}.'.format(
…       food='spam', adjective='absolutely horrible')
This spam is absolutely horrible.

'!s' (apply str()) and '!r' (apply repr()) can be used to convert the value before it is formatted.

»>
»> import math
»> print 'The value of PI is approximately {}.'.format(math.pi)
The value of PI is approximately 3.14159265359.
»> print 'The value of PI is approximately {!r}.'.format(math.pi)
The value of PI is approximately 3.141592653589793.

»> import math
»> print 'The value of PI is approximately {0:.3f}.'.format(math.pi)
The value of PI is approximately 3.142.

»> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
»> for name, phone in table.items():
…     print '{0:10} =⇒ {1:10d}'.format(name, phone)
…
Jack       =⇒       4098
Dcab       =⇒       7678
Sjoerd     =⇒       4127


»> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
»> print 'Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table)
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

File

# append read/write binary
f = open('/tmp/workfile', 'r+b')

# read text
f = open('/tmp/workfile', 'r')

# write text
f = open('/tmp/workfile', 'w')

print f

f.read(size)
f.readline()
f.readlines()

for line in f:
        print line,
        


value = ('the answer', 42)
»> s = str(value)
»> f.write(s)

f.seek(5)     # Go to the 6th byte in the file

f.close()


 with open('/tmp/workfile', 'r') as f:
…     read_data = f.read()
»> f.closed
True

# serialisation
pickle.dump(x, f)
To unpickle the object again, if f is a file object which has been opened for reading:

x = pickle.load(f)

Exceptions

»> while True:
…     try:
…         x = int(raw_input("Please enter a number: "))
…         break
…     except ValueError:
…         print "Oops!  That was no valid number.  Try again…"
…



… except (RuntimeError, TypeError, NameError):
…     pass


def f():
    try:
        1/0
    finally:
        return 42

»> f()
42

Python STL

http://docs.python.org/library/index.html