#!/usr/bin/env python
print 'hello world!'
$ python hello_world.py
hello world!
$
$ python
Python 2.7.5 (default, May 12 2013, 12:00:47)
[GCC 4.8.0 20130502 (prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'hello world!'
hello world!
>>>
fifa/
__init__.py
match.py
teams/
__init__.py
players.py
managers.py
trophies.py
>>> from fifa.teams.players import Zidane
>>> zizou = Zidane()
>>> from fifa import teams
>>> zizou = teams.players.Zidane()
>>> from fifa.teams.trophies import *
>>> la_decima = UefaChampionsLeague()
$ mkvirtualenv -p /usr/bin/python2.7 intro-python
Running virtualenv with interpreter /usr/bin/python2.7
New python executable in intro-python/bin/python2.7
Also creating executable in intro-python/bin/python
Installing setuptools...............................done.
Installing pip...............done.
(intro-python)$
(intro-python)$ exit
$
$ workon intro-python
(intro-python)$
(intro-python)$ pip install requests
(intro-python)$ pip install -r requirements.txt
>>> import this
>>> import this
...
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Readability counts.
Special cases aren't special enough to break the rules.
Errors should never pass silently.
Unless explicitly silenced.
There should be one -- and preferably only one -- obvious way to do it.
Now is better than never.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
>>> from __future__ import braces
File "< stdin >", line 1
SyntaxError: not a chance
>>> type(1)
< type 'int' >
>>> type(10000000000000000000)
< type 'long' >
>>> type(1L)
< type 'long' >
>>> type(1.5)
< type 'float' >
>>> 3/2
1
>>> 3/2.
1.5
>>> type(True)
< type 'bool' >
>>> type(False)
< type 'bool' >
>>> True == 1
True
>>> False == 0
>>> issubclass(bool, int)
True
>>> type('foo')
< type 'str' >
>>> type("Foo's bar")
< type 'str' >
>>> multiline_string = """This is a
... multiline string"""
>>> print multiline_string
This is a
multiline string
>>> print '%s is a str and %i is a int' % ('foo', 1)
foo is a str and 1 is a int
>>> '{0}{1}{0}'.format('abra', 'cad')
'abracadabra'
>>> 'Python rocks'.find('rocks')
7
>>> 'Python rocks'.find('PHP')
-1
>>> 'Python rocks'.split()
['Python', 'rocks']
>>> 'Python rocks'.split('o')
['Pyth', 'n r', 'cks']
>>> 'Python rocks'.replace('Python', "Java doesn't")
"Java doesn't rocks"
>>> ','.join(['a', 'b', 'c'])
'a,b,c'
>>> str(2)
'2'
>>> int('2')
2
>>> int('foo')
Traceback (most recent call last):
File "< stdin >", line 1, in < module >
ValueError: invalid literal for int() with base 10: 'foo'
>>> 2 + '2'
Traceback (most recent call last):
File "< stdin >", line 1, in < module >
TypeError: unsupported operand type(s) for +: 'int' and 'str'
a + b a - b a * b a / b
a % b a ** b
a == b a != b a > b a < b
a >= b a <= b a is True a is not False
not a a and b a or b
>>> even_nums = [2, 4, 6, 8]
>>> even_nums[0]
2
>>> 6 in even_nums
True
>>> even_nums.append(10)
>>> even_nums
[2, 4, 6, 8, 10]
>>> other_list = [1, ['2', 3], 'foo']
>>> even_nums + other_list
[2, 4, 6, 8, 10, 1, ['2', 3], 'foo']
>>> user = {'name': 'javimb', 'is_staff': True}
>>> user['name']
'javimb'
>>> user['password']
Traceback (most recent call last):
File "< stdin >", line 1, in < module >
KeyError: 'password'
>>> user.get('password')
>>> user.get('password', 'foobar')
'foobar'
>>> user['is_authenticated'] = True
>>> user
{'is_staff': True, 'is_authenticated': True, 'name': 'javimb'}
>>> even_nums = (2, 4, 6, 8)
>>> type(even_nums)
< type 'tuple' >
>>> even_nums[2]
6
>>> 8 in even_nums
True
>>> other_tuple = 2, 'foo', [2, True, 0]
>>> other_tuple
(2, 'foo', [2, True, 0])
>>> x = 0
>>> x += 3
>>> x
3
>>> x -= 2
>>> a = 'foo'
>>> b = 'bar'
>>> a, b = b, a
>>> a
'bar'
>>> b
'foo'
>>> a, b, c = 1, 2, 3
>>> a < b and b < c
True
>>> a < b < c
True
>>> even_nums = [2, 4, 6, 8]
>>> even_nums[1:3]
[4, 6]
>>> even_nums[:3]
[2, 4, 6]
>>> even_nums[::-1]
even_nums = [2, 4, 6, 8]
>>> 'Python rocks'[::2]
'Pto ok'
>>> len('Python rocks')
12
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(2, 5)
[2, 3, 4]
>>> sum(range(10))
45
>>> round(3,141595, 4)
3.1416
>>> map(str, range(10))
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> zip([1, 2, 3], [4, 5, 6])
[(1, 4), (2, 5), (3, 6)]
>>> sorted(range(10)[::-1])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> user = {'name': 'javimb', 'is_staf': True}
>>> if user['is_staff']:
... print 'Hello boss!'
... else:
... print 'Hello {name}'.format(name=user['name'])
...
Hello boss!
>>> if user['name'] == 'Raul':
... print 'Hello Raul!'
... elif user['name'] == 'javimb':
... print 'Hello Javi!'
... else:
... print 'Hello!'
...
Hello Javi!
>>> num = 0
>>> while True:
... if num == 2:
... num = 3
... continue
... if num == 5:
... break
... num += 1
... print num
...
1
2
4
5
>>> users = [{'name': 'javimb', 'is_staf': True}, {'name': 'Raul', 'is_staff': False}]
>>> for user in users:
... print user['name']
...
javimb
Raul
>>> for num in range(3):
... print num
...
0
1
2
>>> try:
... 2 / 0
... except:
... print 'Error: division by zero'
...
Error: division by zero
>>> try:
... 2 / range(5)[10]
... except ZeroDivisionError:
... print 'Error: division by zero'
... except IndexError:
... print 'Error: out of range'
... raise
...
Error: out of range
Traceback (most recent call last):
File "< stdin >", line 2, in < module >
IndexError: list index out of range
>>> def first_function(a, b):
... return a + b
...
>>> def second_function(x, y):
... return x ** 2, y ** 2
...
>>> a, b = second_function(2, 4)
>>> def third_function(x=0, y=2):
... return x ** 2, y ** 2
...
>>> third_function()
(0, 4)
>>> second_function(x=4, y=4)
(16, 16)
>>> def sample_funtion(*args, **kwargs):
... return args[0] * kwargs.get('mul', 0)
...
>>> sample_function(1)
0
>>> sample_function(2, mul=5)
10
>>> def last_function(x, *args):
... return None
...
>>> last_function()
Traceback (most recent call last):
File "< stdin >", line 1, in < module >
TypeError: last_function() takes at least 1 argument (0 given)
>>> f = lambda x: x ** 2
>>> f(2)
4
>>> filter(lambda x: not x % 2, range(10))
[0, 2, 4, 6, 8]
class Car():
def __init__(self, fuel):
self.fuel = fuel
def move(self):
if not self.fuel:
print 'No fuel'
else:
self.fuel -= 1
print 'Fuel: %i' % self.fuel
>>> car = Car(5)
>>> car.move()
Fuel: 4
class Car(object):
@property
def fuel(self):
return self._fuel
@fuel.setter
def fuel(self, value):
self._fuel = value + 5
...
>>> car = Car(5)
>>> car.move()
Fuel: 4
class Car(object):
...
@staticmethod
def kmh_to_mph(kmh):
return kmh * 0.621371192
>>> print Car.kmh_to_mph(100)
62.1371192
class Car(object):
wheels = 4
axis = 2
...
@classmethod
def wheels_per_axis(cls):
return cls.wheels / cls.axis
>>> car = Car(5)
>>> car.wheels = 6
>>> print car.wheels / car.axis
3
>>> print car.wheels_per_axis()
2
class Vehicle(object):
...
class FuelVehicle(object):
...
class Car(FuelVehicle, Vehicle):
...
def triple(x):
return x * 3
def is_even(x):
return not x % 2
>>> some_even_nums = map(triple, filter(is_even, range(10)))
>>> some_even_nums
[0, 6, 12, 18, 24]
>>> some_even_nums = [x * 3 for x in range(10) if not x % 2]
>>> some_even_nums
[0, 6, 12, 18, 24]
>>> [x * 3 for x in range(10)]
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
def first_generator(limit):
i = 0
while i < limit:
yield i
i += 1
>>> gen = first_generator(3)
>>> gen.next()
0
>>> gen.next()
1
>>> gen.next()
2
>>> gen.next()
Traceback (most recent call last):
File "< stdin >", line 1, in < module >
StopIteration
>>> gen = [x for x in range(1000000)] #0.1085 s
>>> gen = (x for x in range(1000000)) #0.0219 s
def admin_dashboard(name):
print "%s's admin dashboard" % name
>>> admin_dashboard('javimb')
javimb's admin dashboard
def admin_dashboard(name):
if name != 'javimb':
print '404'
else:
print "%s's admin dashboard" % name
>>> admin_dashboard('Raul')
404
def staff_required(original_func):
def new_func(name):
if name != 'javimb':
print '404'
return
return original_func(name)
return new_func
@staff_required
def admin_dashboard(name):
print "%s's admin dashboard" % name
>>> admin_dashboard
< function new_func at 0x7f8bf1b6c5f0 >
from functools import wraps
def staff_required(original_func):
@wraps(original_func)
def new_func(name):
if name != 'javimb':
print '404'
return
return original_func(name)
return new_func
>>> admin_dashboard
< function admin_dashboard at 0x7f1f06a427d0 >
def fibonacci(x):
if x < 2:
return x
return fibonacci(x-1) + fibonacci(x-2)
>>> fibonacci(40) # 49.80 s
CACHE = {}
def fibonacci(x):
if x < 2:
return x
value = CACHE.get(str(x))
if not value:
value = fibonacci(x-1) + fibonacci(x-2)
CACHE[str(x)] = value
return value
>>> fibonacci(40) # 0.000169 s
CACHE = {}
def fibonacci(x):
if x < 2:
return x
return fibonacci(x-1) + fibonacci(x-2)
original_fibonacci = fibonacci
def fibonacci(x):
value = CACHE.get(str(x))
if not value:
value = original_fibonacci(x)
CACHE[str(x)] = value
return value
CACHE = {}
def fibonacci(x):
if x < 2:
return x
return fibonacci(x-1) + fibonacci(x-2)
def cache(func):
def cached_func(x):
value = CACHE.get(str(x))
if not value:
value = func(x)
CACHE[str(x)] = value
return value
return cached_func
fibonacci = cache(fibonacci)
CACHE = {}
def cache(func):
def cached_func(x):
value = CACHE.get(str(x))
if not value:
value = func(x)
CACHE[str(x)] = value
return value
return cached_func
@cache
def fibonacci(x):
if x < 2:
return x
return fibonacci(x-1) + fibonacci(x-2)
>>> a = 'foo' if True else 'bar'
>>> dic = {'a': True, 'b': False, 'c': true}
>>> def func(a, b, c):
...
...
>>> func(**dic)
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> _ # only shell mode
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> pow(2, 3)
8
>>> from functools import partial
>>> pow_base_2 = partial(pow, 2)
>>> pow_base_2(10)
1024