#!/usr/bin/env python

from read import main

import os

import sys

import itertools

rows, columns = os.popen('stty size', 'r').read().split()

source = main()

def next_():

if len(sys.argv) != 2:

raw_input()

print "%c[2J" % (27)

try:

print source.next()

except StopIteration:

return

print "\n%s\n" % ("-" * int(columns))

next_()

# START

import this

next_()

print """

how the language evolves:

# peps

PEP stands for Python Enhancement Proposal. A PEP is a design document providing

information to the Python community, or describing a new feature for Python or

its processes or environment. The PEP should provide a concise technical

specification of the feature and a rationale for the feature.

We intend PEPs to be the primary mechanisms for proposing major new features,

for collecting community input on an issue, and for documenting the design

decisions that have gone into Python. The PEP author is responsible for building

consensus within the community and documenting dissenting opinions.

Pep 20: The Zen of Python

Pep 8: style guide

Pep 0257: Docstring Conventions

"""

next_()

# getting help

help(set)

next_()

# built-ins

# sets

set1 = set([1, 2, 3, 3])

set2 = set([2, 3, 4])

print set1 == set2

print set1 - set2

print set1.union(set2)

print set1.symmetric_difference(set2)

next_()

# batteries included

import heapq, random

elements = range(10)

print elements

random.shuffle(elements)

print elements

heapq.heapify(elements)

print elements

next_()

# collections

import collections

# defaultdict

dd = collections.defaultdict(list)

dd['matt'].append('so cool')

dd['matt'].append('so smooth')

dd['matt'].append('so fresh')

print dd['matt']

print dd['tom']

next_()

# namedtuple

People = collections.namedtuple('People', ['fields', 'of', 'people'])

new_person = People('people', 'of', 'fields')

print new_person.fields

next_()

# deque (say 'deck')

# efficient, double-ended queue

d = collections.deque('ghi')

d.append('j')

d.appendleft('f')

print d

next_()

# TODO

# ABC - abstract base class

# Super

# MRO

next_()

elements = ['one', 'two', 'three']

idx = 0

for i in elements:

print "%s(%d)" % (i, idx)

idx += 1

next_()

for idx, i in enumerate(elements):

print "%s(%d)" % (i, idx)

next_()

# generator doesn't expand the list

print range(10)

print xrange(10)

next_()

# list comprehension

print ["%s(%d)" % (i, idx) for idx, i in enumerate(elements)]

next_()

# generator comprehension

gen = ("%s(%d)" % (i, idx) for idx, i in enumerate(elements))

print gen

print list(gen)

next_()

# generators

def mygenerator():

yield "before"

for i in xrange(3):

yield i

yield "after"

for i in mygenerator():

print i

print list(mygenerator())

next_()

# itertools

print list(itertools.islice(mygenerator(), 1, 4))

next_()

def myfilter(x):

try:

int(x)

return True

except ValueError:

return False

print list(itertools.ifilter(myfilter, mygenerator()))

print list(itertools.ifilterfalse(myfilter, mygenerator()))

# generators are a form of continuation. they facilitate coroutines.

next_()

# protocols

# iterator

# __dunder__ "magic methods"

class MyIterator(object):

def __init__(self, high):

self.current = 0

self.high = high

def __iter__(self):

return self

def next(self):

if self.current > self.high:

raise StopIteration

else:

self.current += 1

return self.current - 1

for i in MyIterator(3):

print i

next_()

# decorators

def mydecorator(f):

def inside():

print "before dec"

f()

print "after_dec"

return inside

@mydecorator

def test():

print "inside"

test()

next_()

# descriptors

# http://docs.python.org/2/reference/datamodel.html#descriptors

class ReadOnly(object):

def __init__(self, initval=None, name='var'):

self.val = initval

self.name = name

def __set__(self, obj, val):

raise AttributeError('%s is read only.' % self.name)

class MyClass(object):

x = ReadOnly(10, 'var "x"')

y = 5

test = MyClass()

test.y = "z"

try:

test.x = "y"

except AttributeError, e:

print "%s(%s)" % (e.__class__.__name__, e)

next_()

# context managers

class Ctx(object):

def __enter__(self):

print "entering"

def __exit__(self, type, value, traceback):

print "exiting"

with Ctx():

print "inside!"

next_()

# contextlib

from contextlib import contextmanager

@contextmanager

def ctx():

print "before"

yield

print "after"

with ctx():

print "also inside."

next_()

# attributes

class Attr1(object):

pass

x = Attr1()

x.y = 1

print x.y

next_()

class Attr2(object):

# caled only when attribute lookup fails

def __getattr__(self, attr):

return "%s not found" % attr

x = Attr2()

x.y = 1

print x.y

print x.z

# we'll come back to this

print x.__dict__

next_()

class DangerAttr(object):

# caled always to look up attribute.

def __getattribute__(self, attr):

return "%s not found" % attr

x = DangerAttr()

x.y = 1

print x.y

print x.z

next_()

# everything is an object.

def testf():

pass

testf.permavalue = 1

print testf.__dict__

class X(object):

y = 2

X.classattr = 1

print X.__dict__

x = X()

# __getattr__ has a lookup list. first the instance and then the class tree

print x.__dict__

print x.y

# functions, classes, instances, all objects, behaving alike

next_()

# crazyshit

# type()

print "signature -> type(name, bases, dict)"

NewClass = type('NewClass', (object,), {'val': [1, 2, 3]})

print type(NewClass)

newone = NewClass()

print newone.val

next_()

def printme(self):

print self.val

NewClass2 = type('NewClass2', (NewClass,), {'printme': printme})

newtwo = NewClass2()

newtwo.printme()

next_()

# metaclasses

class metacls(type):

def __new__(mcs, name, bases, d):

d['foo'] = 'metacls was here'

return type.__new__(mcs, name, bases, d)

class Meta(object):

__metaclass__ = metacls

x = Meta()

print x.foo

next_()

# metaclass pt 2

# good for creating DSLs

class Attribute(object):

def __init__(self, name):

self.name = name

def __str__(self):

return self.name

class printer(type):

def __new__(mcs, name, bases, d):

attrs = []

for i in d:

if isinstance(d[i], Attribute):

attrs.append(d[i])

for attr in attrs:

print "%s(%s)" % (d['implementation'], attr)

return type.__new__(mcs, name, bases, d)

class Meta2(object):

__metaclass__ = printer

implementation = "foobar"

attr1 = Attribute("sicknasty")

attr2 = Attribute("nastynasty")

x = Meta2()

next_()

print "DONE"

next_()