Python 编程基础 学习笔记

1/2
1//2
1.0/2.0
0.75%0.5
2**3
10000000000000000000000000L
0xAF
010
x=3
print 3*2
x=input("The meaning of life:")
x=5;y=6
pow(2,3)
round(1.0/2.0)
import math
math.floor(32.9)
int(math.floor(32.9))
from math import sqrt
sqrt(9)
foo=math.floor
foo(32.9)
32.0
import cmath
cmath.sqrt(-1)
print "Let's go"
print '"hello, world!" she said'
print 'Let\'s go!'
print "hello" "world"
x="Hello"
y="wold"
x+y
epr("Hello,world!")
repr(1000L)
print repr("Hello,world!")
print repr(1000L)
str("hello world")
print  str("hello world")
str(1000L)
print str(1000L)
print `10000L`
temp=42
print "the temperature is "+`temp`
name=input("What is your names?")
name=raw_input("What is your names?")
print "Hello .\
world!"
print """ My name
is your
names"""
print 'c:\\nwhere'
print r'c:\nwhere'
print r'c:\program files\foo\bar' '\\'
r'hello,world'
u'hello,world'
print u'hello,world'
edward=['Edward',42]
john=['John Smith',50]
database=[edward,john]
database[0]
database[-1]
'Hello'[1]
fourth=raw_input('year:')[3]


months=[
    'January',
    'February',
    'March',
    'April',
    'May',
    'June',
    'July',
    'August',
    'September',
    'October',
    'November',
    'December']
endings=['st','nd','rd']+17*['th']\
         +['st','nd','rd']+7*['th']\
         +['st']
year=raw_input('year:')
month=raw_input('Month (1-12')
day=raw_input('Day(1-31):')


month_number=int(month)
day_number=int(day)


month_name=months[month_number-1]
ordinal=day+endings[day_number-1]


print month_name+''+ordinal+'.'+year




tag='<a href="http://www.python.org">Python web site</a>'
tag[9:30]
tag[32:-4]
number=[1,2,3,4,5,6,7,8,9,10]
number[3:6]
number[-3:]
number[:3]
number[:]
number[0:10:1]
number[::2]
number[10:0:-2]
number[5::-2]
[1,2,3]+[4,5,6,7]
'python'*5
sequence=[None]*10


sentenct=raw_input("Sentence:")
screen_width=80
text_width=80
box_width=text_width+6
left_margin=(screen_width-box_width)//2


print ' '*left_magrin+'+'+'-'*(box_width-2)+'+'


permissions='rw'
'w' in permissions


database=[
    ['albert','1234'],
    ['dilbert','4242']
    ]
username=raw_input('User name')
pin=raw_input('PIN code:')
if [username,pin] in database: print 'Access granted'
numbers=[10,34,678]
len(numbers)
 max(numbers)


 f=list('Hello')
 ''.join(f)


x=[1,1,1]
x[1]=2


names=['Alice','Beth','Cecil']
del names[2]
name=list('Perl')
name[1:]=list('ython')
 name[1:4]=[]
 lst.append(4)
 ['to','be','or','not','to','be'].count('to')
 a=[1,2,3]
 b=[4,5,6]
 a.extend(b)
 a+b
 a[len(a):]=b
 kninghts=["we","are","the"]
 kninghts.index("are")
 number=[1,2,3,4,5]
 number.insert(3,'four')
 number.pop()
number.append(number.pop())
number.remove('four')
number.reverse()
list(reversed(number))
number.sort()
y=number[:]
y.sort()
y=sorted(number)
sorted('Python')
number.sort(cmp)
x=['aardvark','abalone','acme']
x.sort(key=len)
 1,2,3
 (1,2,3)
 ()
 42,
 (42,)
 3*(42+2)
3*(42+2,)
tuple([1,2,3])
tuple('abc')
tuple((1,2,3))
format="Hello,%s.%s enough for ya?"
values=('world','Hot')
print format % values
format="Pi with three decimals:%.3f"
from math import pi
print format % pi
'%s plus %s equals %s' % (1,1,2)
'Price of eggs:$%d' %42
'Using str:%s' % 42L
'Hexadecimal price of eggs:%x' % 42
'%10.2f' % pi
 '%.2f' % pi
 '%.10s' % 'Guido van Rossum'
 '%.*s' % (10,'Guido van Rossum')
 '%010.2f' % pi
 '%-10.2f' % pi
 print ('% 5d' % 10) + '\n' +('% 5d' % -10)
 print ('%+5d' % 10) + '\n' +('%+5d' % -10)
 title="Monty Python's Flying Circus"
 title.find('Monty')
 seq=['1','2','3','4','5']
 sep='+'
 sep.join(seq)
dis='','usr','bin','env'
print 'C'+'\\'.join(dis)
'This is a test'.replace('is','eez')
string.capwords("that's all, folks")
'1+2+3+4+5'.split('+')
'     internal whitespace is kept    '.strip()
'***SPAM*for*everyone!!!***'.strip('*!')
 from string import maketrans
table=maketrans('cs','kz')
'this is an incredible test'.translate(table)
'this is an incredible test'.translate(table,' ')
phonebook={'Alice':'2341','Beth':'9120'}
items=[('name','Gumby'),('age','42')]
d=dict(items)
d=dict(name='Gumby',age=42)
 d['age']
"Cecil's phone number is %(age)s." % d
d.clear()
x={'username':'admin','machines':['foo','bar','baz']}
y['machines'].remove('bar')
from copy import deepcopy
 d={}
 d['names']=['Alfred','Bertrand']
 c=d.copy()
 dc=deepcopy(d)
 d['names'].append('Clive')
  {}.fromkeys(['name','age'])
  dict.fromkeys(['name','age'],'(unknown)')
  print d.get('name')
  d.has_key('name')
  d.items()
  d.iteritems()
  d.pop('x')
  d.popitem()
  d.setdefalut('name','N/A')
  d.update(x)
  d.values()
  print 'Age:',42
  name='Gumby'
  salutation='Mr.'
  greeting='Hello.'
  print greeting+' ',salutation,name
   from string import *
   import string
   import math as foobar
   from math import sqrt as sqrt1
   from cmath import sqrt as sqrt2
   x,y,z =1,2,3
   x,y=y,x
   values=1,2,3
   x,y,z=values
   scoundrel={'name':'Robin','girlfriend':'Marion'}
   key,value=scoundrel.popitem()
   x=y=values
   x+=1
   x*=1
   fnord='foo'
 fnord+='bar'
 fnord*=2
False+True+43
bool('I think, therefore I am')
num=input('enter a number:')
if num>0:
    print 'the number is positive'
elif num<0:
    print 'the number is negative'
else:
    print 'the number is zero'

name=raw_input('Whtat is your name?')
if name.endswith('Gumby'):
    if name.startswith('Mr.'):
        print 'Hello,Mr.Gumby'
    elif name.startswith('Mrs.'):
        print 'Hello,Mrs.Gumby'
    else:
        print 'Hello, Gumby'
else:
    print 'Hello, stranger'
    
x=y=[1,2,3]
z=[1,2,3]
z==x
z is x
x is not z


name=raw_input('Whtat is your name?')
if 's' in name:
    print 'your name contains the letter s'
else:
    print 'your name doesno\'t contain the letter s'

[1,2]<[2,1]
 chr(97)
 ord('a')
 [2,[1,4]]<[2,[1,5]]
 
 number=input('Enter a number between 1 and 10')
if 1<number<10:
    print 'Great'
else:
    print 'Wrong'
    
name=raw_input('please enter your name:') or ('unknown')
age=10
assert 0<age<5, 'The age must be real'


name=''
while not name:
    name=raw_input('Please enter your name:')
    print 'Hello,%s!' % name
words=['this','is','an','ex','parrot']
for word in words:
    print word
for i in range(1,10):
    print i

d={'x':1,'y':2,'z':3}
for key in d:
    print key, 'correspinds to',d[key]
    


names=['anne','beth','george','damon']
age=[12,45,32,102]
for i in range(len(names)):
    print names[i],'is',age[i],'year old'

for name,age in zip(names,ages):
    print name,'is',age,'year old'

for string in strings:
    if 'xxx'in string:
        index=strings.index(string)
        strings[index]='[censored]'
index=0
for string in strings:
    if 'xxx'in string:
        strings[index]='[censored]'
    index+=1
for index.string in enumerate(strings)
if 'xxx' in string
strings[index]='[censored]'
sorted('Hello,world')   
''.join(reversed('Hello,world'))
list(reversed('Hello, world'))


from math import sqrt
for n in range(99,0,-1):
    root=sqrt(n)
    if root==int(root):
        print n
        break

range(0,10,2)
continue


from math import sqrt
for n in range(99,81,-1):
    root=sqrt(n)
    if root==int(root):
        print n
        break
else:
    print "Didn't find it"


while True:
    word=raw_input('Please enter a world:')
    if not word: break
[x*x for x in range(10)]
 [(x,y) for x in range(3) for y in range(3)]
 [x*x for x in range(10) if x%3==0]
 result=[]
for x in range(3):
    for y in range(3):
        result.append((x,y))
print result




girls=['alice','bernice','clarice']
boys=['chris','arnold','bob']
h=[b+'+'+g for b in boys for g in girls if b[0]==g[0]]
print h


name='Job'
if name=='James':
    print 'Welcome'
elif name=='William':
    pass
elif name=='Bill Gates':
    print 'Access Denced'


 x=["Hello","World"]
  y=x
  del x
  exec "print 'Hello,world'"
  exec 'print "Hello,world"'
  
   from math import sqrt
  scope={}
  exec 'sqrt=1'in scope
 sqrt(4)
scope['sqrt']
len(scope)
scope.keys()
eval(raw_input("enter an arithmetic:"))


scope={}
scope['x']=2
scope['y']=3
eval('x*y',scope)
scope={}
exec 'x=2' in scope
eval('x*x',scope)
 print 'Hello world'; print 'Hello'
 
 
 fibs=[0,1]
num=input('how many number do you want:')
for i in range(num-2):
    fibs.append(fibs[-2]+fibs[-1])
    print fibs
    import math
x=1
y=math.sqrt
callable(x)
callable(y)


def hello(name):
return 'Hello'+name


def fibs(num):
result=[0,1]
for i in range(num-2):
result.append(result[-2]+result[-1])
return result

def square(x):
'Calculate the square of the number x'
return x*x
 help(square)
 square.__doc__
 
 def test():
print 'This is printed'
return
        print 'This is not'
x=test()


def try_to_change(n):
n='Mr.Gumby'
  name='Mrs.Entity'
  try_to_change(name)
  
def change(n):
n[0]='Mr,Gumby'


n=names[:]
 
 n is names
 
  n==names
  
n[0]='Mr.Gumby'


storage={}
storage['First']={}
storage['Middle']={}
storage['Last']={}


def init(data):
    data['First']={}
    data['Middle']={}
    data['Last']={}


storage={}

def hello4(name,greeting='Hello',punctuation='!'):
    'print wellcome to wellcommer'
    print'%s,%s%s' % (greeting,name,punctuation)


 
 
 init(storage)
 
 def lookup(data,label,name):
    return data[label].get(name)


def store(data,full_name):
    names=full_name.split()
    if len(names)==2:names.insert(1,'')
    labels='first','middle','last'
    for label,name in zip(labels,names):
        people=lookup(data,label,names)
        if people:
            people.append(full_name)
        else:
            data[label][name]=[full_name]
 MyNames={}
 init(MyNames)
store(MyNames,'Magnus Lie Hetland')


lookup(MyNames,'Middle','Lie')
def inc(x):x[0]=x[0]+1


def hello1(greeting,name):
    print '%s,%s' % (greeting,name)
    
def hello3(greeting='Hello',name='world'):
    print '%s,%s' % (greeting,name)


hello3('OK','China')


hello4('James')
 hello4('James','OK')
 hello4('James','OK','...')
 hello4('James',greeting='Top scientices')






def print_param(*params):
    print params


print_param(1,2,3)


def print_param(title,*params):
    print title
    print params


print_param('Params:',1,2,3,4,)


def print_params4(x,y,z=3,*pospar,**keypar):
    print x,y,z
    print pospar
    print keypar
    
 print_params4(1,2,4,5,6,7,foo=1,bar=2)
 
def store(data,*full_names):
    for full_name in full_names:
        names=full_name.split()
        if len(names)==2: names.insert(1,'')
        labels='first','middle','last'
        for label,name in zip(labels,names):
            people=lookup(data,label,name)
            if people:
                people.append(full_name)
            else:
                data[label][name]=[full_name]
                
def add(x,y): return x+y            
params=(2,3)
add(*params)


def with_star(**kwds):
    print kwds['name'],'is',kwds['age'],'year old'
def without_star(kwds):
    print kwds['name'],'is',kwds['age'],'year old'

with_star(**args)
without_star(args)


def story(**kwds):
    return 'Once upon a time,there was a '\
           '%(job)s called %(name)s.' % kwds
def power(x,y,*other):
    if other:
        print 'Received redundant parameters:', other
    return power(x,y)
def interval(start,stop=None,step=1):
    'Imitates range() for step>0'
    if stop is None:
        start,stop=0,start
    result=[]
    i=start
    while i<stop:
        result.append(i)
        i+=step
    return result


print story(job='King',name='Gumby')
 param={'job':'language','name':'Python'}
 print story(**param)
  del param['job']
  print story(job='stroke of genius',**param) 
 x=1
 scope=vars()
 scope['x']
 def combine(parameter):print parameter +external
 external='berry'
 combine('Shrub')
 
 def combine(parameter):print parameter +globals()['external']
 
 x=1
def chang_global():
global x
x=x+1



def multiplier(factor):
    def multiplyByFactory(number):
        return number*factor
    return multiplyByFactory
double=multiplier(2)
double(5)
multiplier(5)(4)


def factorial(n):
    result=n
    for i in range(1,n):
        result*=i
    return result


def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n)


def power(x,n):
    if n==0:
        retun 1
    else:
        return x*power(x,n-1)
    
  
  
def search(sequence, number,lower=0,upper=None):
    if upper is None:upper=len(sequence)-1
    if lower==upper:
        assert number==sequence[upper]
        return upper
    else:
        middle=(lower+upper)//2
        if number>sequence[middle]:
            return search(sequence,number,middle+1,upper)
        else:
            return search(sequence,number,lower,middle)
        


seq=[12,23,34,51]
 search(seq,34)
 
 map(str,range(10))
 [str(i) for i in range(10)]
 
  def fun(x):
return x.isalnum()

 filter(fun,seq)
filter(lambda x:x.isalnum(),seq)
number=[72,101,108,111]
 reduce(lambda x,y:x+y, number)
 
 from random import choice
 x=choice(['Hello,World',[1,3,'e','e',2]])
 x.count("e")
 def add(x,y)
return x+y


def length_message(x):
    print "the length of",repr(x),"is",len(x)

length_message('Fnord')
length_message([1,2,3])


o=OpenObject()
o.setName('Sir Lancelot')
o.getName()


__metaclass__=type
class Person:
    def setName(self,name):
        self.name=name
    def getName(self):
        return self.name
    def greet(self):
        print "Hello,World! I'm %s" % self.name
        


foo=Person()
bar=Person()
foo.setName('Luke Skywalker')
bar.setName('Anakin Skywalker')
foo.greet()
bar.greet()
foo.name
 
foo.name='Yoda'
foo.greet()
Person.greet(foo)


class Class:
    def method(self):
        print 'I hva a self!'
def function():
    print "I don't..."
        
instance.method=function
instance.method()


class Bird:
    song='Squaawk'
    def sing(self):
        print self.song


birdsong=bird.sing
birdsong()


class Secretive:
    def __inaccessible(self):
        print "Bet you can't see me..."
    def accessible(self):
        print "The secret message is:"
        self.__inaccessible()

s.__inaccessible()
s.accessible()
Secretive._Secretive__inaccessible
s._Secretive__inaccessible()


def foo(x):return x*x
foo=lambda x:x*x


class C:
print 'Class C being defined...'

class MemberCounter:
    members=0
    def init(self):
        MemberCounter.members+=1


m1=MemberCounter()
m1.init()
 m2=MemberCounter()
 m2.init()
 MemberCounter.members


 class Filter:
    def init(self):
        self.blocked=[]
    def filter(self,sequence):
        return [x for x in sequence if x not in self.blocked]
class SPAMFilter(Filter):
    def init(self):
        self.blocked=['SPAM']


f=Filter()
f.init()
f.filter([1,2,3])
s=SPAMFilter()
s.init()
s.filter(['SPAM','bacon'])


issubclass(SPAMFilter,Filter)
issubclass(Filter,SPAMFilter)


SPAMFilter.__bases__
s=SPAMFilter()
isinstance(s,SPAMFilter)
isinstance(s,Filter)


 s.__class__
 type(s)
 
 class Calculator:
    def calculate(self,expression):
        self.value=eval(expression)


class Talker:
    def talk(self):
        print 'Hi, my value is',self.value


class TalkingCalculator(Calculator,Talker):
    pass

tc=TalkingCalculator()
tc.calculate('1+2*3')
tc.talk()


hasattr(tc,'talk')
callable(getattr(tc,'talk',None))
setattr(tc,'name','Mr.Gumby')
tc.name
tc.__dict__


raise Exception
raise Exception('hyperdrive orverload')
import exceptions
dir(exceptions)
raise ArithmeticError
class SomeCustomException(Exception):pass


try:
    x=input('Enter the first number:')
    y=input('Enter the second number:')
    print x/y
except ZeroDivisionError:
    print " the second number can't be zero!"


class MuffledCalculator:
    muffled=False
    def calc(self,expr):
        try:
            return eval(expr)
        except ZeroDivisionError:
            if self.muffled:
                print 'Divison by zero is illegal'
            else:
                raise
            
    
calculator=MuffledCalculator()
calculator.calc('10/2')
calculator.calc('10/0')
calculator.muffled=True
calculator.calc('10/0')




try:
    x=input('Enter the first number:')
    y=input('Enter the second number:')
    print x/y
except ZeroDivisionError:
    print " the second number can't be zero!"
except TypeError:
    print "That wasn't a number,was it?"
    


Enter the first number:12
Enter the second number:'Hello world'
That wasn't a number,was it?


try:
    x=input('Enter the first number:')
    y=input('Enter the second number:')
    print x/y
except ZeroDivisionError:
    print " the second number can't be zero!"
except TypeError:
    print "That wasn't a number,was it?"

try:
    x=input('Enter the first number:')
    y=input('Enter the second number:')
    print x/y
except (ZeroDivisionError,TypeError,NameError):
    print 'Your number were bogus...'


try:
    x=input('Enter the first number:')
    y=input('Enter the second number:')
    print x/y
except (ZeroDivisionError,TypeError,NameError),e:
    print 'Your number were bogus...'
    print e
    


try:
    x=input('Enter the first number:')
    y=input('Enter the second number:')
    print x/y
except :
    print 'Something happend'

while True:
    try:
        x=input('Enter the first number:')
        y=input('Enter the second number:')
        value=x/y
        print 'x/y is',value
    except:
        print 'Invalid input,Please try again.'
    else:
        break 


while True:
    try:
        x=input('Enter the first number:')
        y=input('Enter the second number:')
        value=x/y
        print 'x/y is',value
    except Exception,e:
        print 'Invalid input,Please try again.',e
    else:
        break 




try:
    1/0
except NameError:
    print "Unknown variable"
else:
    print "that went well"
finally:
    print "Cleaning up"
    
def faulty():
    raise Exception ('Something is wrong')


def ignore_exception():
    faulty()
def handle_exception():
    try:
        faulty()
    except:
        print "Exception handled"


ignore_exception()
handle_exception()


def describePerson(person):
    print 'Description of', person['name']
    print 'Age:', person['age']
    if 'occupation' in person:
        print 'Occupation:',person['occupation']


def describePersion(person):
    print 'Description of', person['name']
    print 'Age:', person['age']
    try:
        print 'Occupation:'+person['occupation']
    except KeyError: pass


try:
    obj.write
except AttibuteError:
    print 'The object is not writeable'
else:
    print 'The ojbect is writeable'

class FooBar:
    def __init__(self):
        self.somevar=42


f=FooBar()
f.somevar


class FooBar:
    def __init__(self,value=42):
        self.somevar=value
        
class A:
    def hello(self):
        print "Hello,I'm A"
class B(A):
    pass


class A:
    def hello(self):
        print "Hello,I'm A"
class B(A):
    def hello(self):
        print "Hello,I'm B"


b=B()
b.hello()


class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print 'Aaaah...'
            self.hungry=False
        else:
            print 'No,thinks!'
            
        
b=Bird()
b.eat()
b.eat()


__metaclass__=type
class Bird:
    def __init__(self):
        self.hungry=True
    def eat(self):
        if self.hungry:
            print 'Aaaah...'
            self.hungry=False
        else:
            print 'No,thinks!'


class SongBird(Bird):
    def __init__(self):
        super(SongBird,self).__init__()
        self.sound='Squawk'
    def sing(self):
        print self.sound


sb=SongBird()
sb.sing()
sb.eat()




def checkIndex(key):
    if not isinstance(key,(int,long)):raise TypeError
    if key<0:raise IndexError


class ArithmeticSequence:
    def __init__(self,start=0,step=1):
        self.start=start
        self.step=step
        self.changed={}


    def __getitem__(self,key):
        checkIndex(key)
        try: return self.changed[key]
        except KeyError:
            return self.start+key*self.step


    def __setitem__(self,key,value):
        checkIndex(key)
        self.changed[key]=value



class CounterList(list):
    def __init__(self,*args):
        super(CounterList,self).__init__(*args)
        self.counter=0
    def __getitem__(self,index):
        self.counter+=1
        return super(CounterList,self).__getitem__(index)

class CounterList(list):
    def __init__(self,*args):
        super(CounterList,self).__init__(*args)
        self.counter=0
    def __getitem__(self,index):
        self.counter+=1
        return super(CounterList,self).__getitem__(index)


 cl=CounterList(range(10))
 cl.reverse()
 del cl[3:6]
 
 __metaclass__=type
class Rectangle:
    def __init__(self):
        self.width=0
        self.height=0
    def setSize(self,size):
        self.width,self.height=size
    def getSize(self):
        return self.width,self.height
    size=property(getSize,setSize)


__metaclass__=type
class Myclass:
    def smeth():
        print 'This is a static method'
    smeth=staticmethod(smeth)
    def cmeth(cls):
        print 'This is a class method of',cls
    cmeth=classmethod(cmeth)
    
class Rectangle:
    def __init__(self):
        self.width=0
        self.height=0
    def __setattr__(self,name,value):
        if name=='size':
            self.width,self.height=value
        else:
            self.__dict__[name]=value
    def __getattr__(self,name):
        if name=='size':
            return self.width,self.height
        else:
            raise AttributeError
        
class Fibs:
    def __init__(self):
        self.a=0
        self.b=1
    def next(self):
        self.a,self.b=self.b,self.a+self.b
        return self.a
    def __iter__(self):
        return self


 fibs=Fibs()
for f in fibs:
if f>1000:
print f
break


it=iter([1,2,3])
it.next()




class TestIterator:
    value=0
    def next(self):
        self.value+=1
        if self.value>10: raise StopIteration
        return self.value
    def __iter__(self):
        return self



ti=TestIterator()
list(ti)




def flatten(nested):
    for sublist in nested:
        for element in sublist:
            yield element

nested=[[1,2],[3,4],[5]]
f= flatten(nested)


for num in flatten(nested):
print num


def flatten(nested):
    try:
        for sublist in nested:
            for element in flatten(sublist):
                yield element
    except TypeError:
        yield nested
        
list(flatten([[[1],2],3,4,[5,[6,7]],8]))


def flatten(nested):
    try:
        try: nested + ''
        except TypeError:pass
        else:raise TypeError
        for sublist in nested:
            for element in flatten(sublist):
                yield element
    except TypeError:
        yield nested


def repeater(value):
    while True:
        new=(yield value)
        if new is not None:value=new


 N = (i**2 for i in range(1,11))
 for i in N:
print i


def conflict(state,nextX):
    nextY=len(state)
    for i in range(nextY):
        if abs(state[i]-nextX) in (0,nextY-i):
            return True
    return False


def queens(num=8,state=()):
    for pos in range(num):
        if not conflict(state,pos):
            if len(state)==num-1:
                yield(pos,)
            else:
                for result in queens(num,state+(pos,)):
                    yield (pos,)+result
                    
list(queens(4))


def list_or_tuple(x):  # test#
    print 'type check'
    return isinstance(x, (list, tuple))  
def flatten(sequence, to_expand=list_or_tuple):
    print 'into first'
    for item in sequence:
        print 'into second'
        if to_expand(item):
            print 'into three'
            for subitem in flatten(item, to_expand):
                print 'into nest funciont',item
                print 'into nest paramer',to_expand
                print subitem
                yield subitem,'return'
        else:
            print 'into last'
            yield  'new',item 
  
  def prettyprint(solution):
def line(pos,length=len(solution)):
    return '.'*(pos)+'X'+'.'*(length-pos-1)
for pos in solution:
    print line(pos)
  import random
  prettyprint(random.choice(list(queens(8)))
  
  import sys
 sys.path.append('C:\Users\merit')
 
  Hello=reload(Hello)
  reload(Hello)
  Hello.hello2()
  
 print 'Hello,world'
print "I don't know"
def hello2():
    print 'I will be the great man'
hello2()




print 'Hello,world'
print "I don't know"
def hello2():


import email
 dir(email) 
 f=[n  for n in dir(email)]
 import copy
 copy.__all__
 from copy import *
 
 help(copy.copy)
 copy.__doc__
print copy.copy.__doc__
print copy.__doc__
print range.__doc__


sys.argv
sys.modules
sys.path
sys.platform
sys.stdin
sys.stderr


args=sys.argv[1:]
args.reverse()
print ' '.join(args)
 




    print 'I will be the great man'
def test():
    hello2()


import sys,pprint
pprint.pprint(sys.path)
 


~python/drawing/
~python/drawing/__init__.py
~python/drawing/colors.py
~python/drawing/shapes.py


import drawing
import drawing.colors
from drawing import shapes


 import os
 os.path
 os.environ
 os.system()
 os.popen
 os.sep
 os.system(r'c:\Program Files')
 os.startfile(r'c:\program Files')
 
 import fileinput
 fileinput.input()
 fileinput.filename()
 
 import fileinput
for line in fileinput.input(inplace=True):
    line=line.rstrip()
    num=fileinput.lineno()
    print '%-40s #%2i' % (line,num)
    
set(range(10))
set(['fee','fie','foe'])


a=set([1,2,3])
b=set([2,3,4])
a.union(b)
a|b
c=a&b
c.issubset(a)
c.issubset(b)
c.issuperset(a)
a.issuperset(c)
a.intersection(b)
a>=c
a.difference(b)
b.difference(a)
a-b
a.symmetric_difference(b)
 a^b
set([1, 4])
a.copy()


 a.copy()==a
a.copy() is a
 
  mySets=[]
 for i in range(10):
mySets.append(set(range(i,i+5)))


 reduce(set.union,mySets)
 
  a=set()
 b=set()
 a.add(frozenset(b))


from heapq import *
from random import shuffle
data=range(10)
shuffle(data)
 heap=[]
for n in data:
heappush(heap,n)


  heappush(heap,0.5)
 
 heappop(heap)


heap=[5,8,0,3,6,7,9,1,4,2]
heapify(heap)
heapreplace(heap,0.5)
 
from collections import deque


q=deque(range(5))
q.append(5)
q.appendleft(6)
q.pop()
q.popleft()
q.rotate(2)
q.rotate(-1)


from random import *
from time import *
date1=(2008,1,1,0,0,0,-1,-1,-1)
time1=mktime(date1)
date2=(2009,1,1,0,0,0,-1,-1,-1)
time2=mktime(date2)


 random_time=uniform(time1,time2)
 print asctime(localtime(random_time))
 
 from random import randrange
num=input('How many dice?')
sides=input('How many sides per die?')
sum=0
for i in range(num): sum=randrange(sides)+1
print'the result is.', sum


import fileinput,random
fortunes=list(fileinput.input())
print random.choice(fortunes)


values=range(1,11)+'Jack Queen King'.split()
suits='diamonds clubs hearts spades'.split()
deck=['%s of %s' % (v,s) for v in values for s in suits]


from pprint import pprint
pprint(deck[:12])


 from random import shuffle
 shuffle(deck)
 
 pprint(deck[:12])
 
 import shelve
s=shelve.open('test.dat')
s['x']=['a','b','c']
s['x'].append('d')
s['x']
temp=s['x']
temp.append('d')
s['x']




import sys,shelve
def store_person(db):
    pid=raw_input("Enter unique ID number:")
    person={}
    person['name']=raw_input('Enter name:')
    person['age']=raw_input('Enter age:')
    person['phone']=raw_input('Enter phone number:')
    db[pid]=person


def lookup_person(db):
    pid=raw_input('Enter ID number:')
    field=raw_input('What would you like to know?(name,age,phone)')
    field=field.strip().lower()
    print field.capitalize()+':',\
          db[pid][field]


def print_help():
    print 'The available commands are:'
    print 'store :Store information about a person'
    print 'lookup: Lools up a person from ID number'
    print 'quit:Save changes and exit'
    print '? :Print this message'


def enter_command():
    cmd=raw_input('Enter command(? for help):')
    cmd=cmd.strip().lower()
    return cmd


def main():
    database =shelve.open('test.dat')
    try:
        while True:
            cmd=enter_command()
            if cmd=='store':
                store_person(database)
            elif cmd=='lookup':
                lookup_person(database)
            elif cmd=='?':
                print_help()
            elif cmd=='quit':
                return
    finally:
        database.close()


if __name__=='__main__':main()
    
import re
  ome_text='alpha.beta......gamma delta'
  re.split('[ |.]+',some_text)
  
 re.split('[.]+',some_text,maxsplit=2)
 re.split('[.]+',some_text,maxsplit=1)
 
  pat='[a-zA-Z]+'
 text='"Hm...Err--are you sure?" He said, sounding'
 re.findall(pat,text)
 
 pat=r'[.?\-",]+'
 re.findall(pat,text)
 
 pat='{name}'
 text='Dear {name}...'
 re.sub(pat,'Mr.Gumby',text)
 
 re.escape('www.python.org')
 
 m=re.match(r'www\.(.*)\..{3}','www.python.org')
 m.group(1)
 m.start(1)
 m.end(1)
 m.span(1)
 emphasis+pattern=r'\*([^\*]+)\*'
 re.sub(emphasis_pattern,r'<em>\1</em>','Hello,*world*')
 
 emphasis_pattern=r'\*(.+)\*'
 re.sub(emphasis_pattern,r'<em>\1</em>','*This* is *it*!')
 emphasis_pattern=r'\*(.+?)\*'
 re.sub(emphasis_pattern,r'<em>\1</em>','*This* is *it*!')

import fileinput,re
pat=re.comple('From:(.*)<*?>$')
for line in fileinput.input():
    m=pat.match(line)
    if m:print m.group(1)
    
import fileinput,re
pat=re.compile(r'[a-z\-\.]+@[a-z\-\.]+',re.ignorecase)
addresses=set()
for line in fileinput.input():
    for address in pat.findall(line):
        addresses.add(address)
for address in sorted(addresses):
    print address





if re.search(pat,string):
print 'Found it'


import fileinput,re
field_pat=re.compile(r'\[(.+?)\]')
scope={}
def replacement(match):
    code=match.group(1)
    try:
        return str(eval(code,scope))
    except SyntaxError:
        exec code in scope
        return ''


lines=[]
for line in fileinput.input():
    lines.append(line)
text=''.join(lines)


print field_pat.sub(replacement,text)


text=''
for line in fileinput.input():
    text+=line
    
[x=2]
[y=3]
the sum of [x] and [y] is [x+y]


 '[name="Mr,Gumby"] Hello,[name]'
 
 f=open(r'C:\Users\merit\12.txt','U')
f=open(r'C:\Users\merit\12.txt','a')
 f.write('I don\'t know your mean')
 f.close()
f=open(r'C:\Users\merit\12.txt','r')
 f.read()


 f=open(r'C:\Users\merit\12.txt','r')
f.read(4)
f.read()


import sys
text=sys.stdin.read()
words=text.split()
wordcount=len(words)
print 'Wordcount:',wordcount


 f=open(r'C:\Users\merit\12.txt','w')
 f.write('1234567890123456789')
 f.seek(5)
 f.write('Hello,World')
 f.close()
 f=open(r'C:\Users\merit\12.txt')
 f.read()
 
f=open(r'C:\Users\merit\12.txt')
f.read(3)
f.tell()
f.readlines()


with open("somefile.txt") as somefile:
     do_something(somefile)
 
from __future__ import with_statement




f=open(r'C:\Users\merit\12.txt')
for i in range(3):
print str(i)+':'+f.readline()

import pprint
pprint.pprint(open(r'C:\Users\merit\12.txt').readlines())


 f.write('this\nis no \nhaiku')
 
f= open(r'C:\Users\merit\12.txt')
lines=f.readlines()
lines


f=open(filename)
while Ture:
    char=f.read(1)
    if not char:break
    process(char)
f.close


f=open(filename)
char=f.read(1)
while char:
    process(char)
    char=f.read(1)
f.close()


f=open(filename)
while Ture:
    line=f.readline()
    if not line:break
    process(line)
f.close()


f=open(filename)
for char in f.read():
    process(char)
f.close()


f=open(filename)
for line in f.readlines():
    process(line)
f.close()


import fileinput
for line in fileinput.input(filename):
    process(line)



f=open(filename)
for line in f:
    process(line)
f.close()


for line in open(filename):
    process(line)
    
import sys
for line in sys.stdin:
    process(line)

f=open(r'C:\Users\merit\study.txt','w')
f.write('First line\n')
f.write('Second line\n')
f.write('Thrid line\n')
f.close()
lines=list(open(r'C:\Users\merit\study.txt'))
first,second,third=open(r'C:\Users\merit\study.txt')


 import wx
app=wx.App()
app.MainLoop()
win=wx.Frame(None)
win.Show()


app.MainLoop()




import wx
app=wx.App()
win=wx.Frame(None)
btn=wx.Button(win)
win.Show()
app.MainLoop()


import wx
app=wx.App()
win=wx.Frame(None,title="Simple Editor")
loadButton=wx.Button(win,label='Open')
saveButton=wx.Button(win,label='Save')
win.Show()
app.MainLoop()


import wx
app=wx.App()
win=wx.Frame(None,title="Simple Editor",size=(410,335))
win.Show()
loadButton=wx.Button(win,label='Open',pos=(225,5),size=(80,25))
saveButton=wx.Button(win,label='Save',pos=(315,5),size=(80,25))
filename=wx.TextCtrl(win,pos=(5,5),size=(210,25))
contents=wx.TextCtrl(win,pos=(5,35),size=(390,260),style=wx.TE_MULTILINE|wx.HSCROLL)
app.MainLoop()


import wx
app=wx.App()
win=wx.Frame(None,title="Simple Editor",size=(410,335))
bkg=wx.Panel(win)


loadButton=wx.Button(bkg,label='Open')
saveButton=wx.Button(bkg,label='Save')
filename=wx.TextCtrl(bkg)
contents=wx.TextCtrl(bkg,style=wx.TE_MULTILINE|wx.HSCROLL)


hbox=wx.BoxSizer()
hbox.Add(filename,proportion=1,flag=wx.EXPAND)
hbox.Add(loadButton,proportion=0,flag=wx.LEFT,border=5)
hbox.Add(saveButton,proportion=0,flag=wx.LEFT,border=5)


vbox=wx.BoxSizer(wx.VERTICAL)
vbox.Add(hbox,proportion=0,flag=wx.EXPAND|wx.ALL,border=5)
vbox.Add(contents,proportion=1,flag=wx.EXPAND|wx.LEFT|wx.BOTTOM|wx.RIGHT,border=5)


bkg.SetSizer(vbox)
win.Show()


app.MainLoop()
loadButton.Bind(wx.EVT_BUTTON,load)


import wx


def load(event):
    file=open(filename.GetValue())
    contents.SetValue(file.read())
    file.close()


def save(event):
    file=open(filename.GetValue(),'w')
    file.write(contents.GetValue())
    file.close()


    
app=wx.App()
win=wx.Frame(None,title="Simple Editor",size=(410,335))
bkg=wx.Panel(win)


loadButton=wx.Button(bkg,label='Open')
loadButton.Bind(wx.EVT_BUTTON,load)




saveButton=wx.Button(bkg,label='Save')
saveButton.Bind(wx.EVT_BUTTON,save)




filename=wx.TextCtrl(bkg)
contents=wx.TextCtrl(bkg,style=wx.TE_MULTILINE|wx.HSCROLL)


hbox=wx.BoxSizer()
hbox.Add(filename,proportion=1,flag=wx.EXPAND)
hbox.Add(loadButton,proportion=0,flag=wx.LEFT,border=5)
hbox.Add(saveButton,proportion=0,flag=wx.LEFT,border=5)


vbox=wx.BoxSizer(wx.VERTICAL)
vbox.Add(hbox,proportion=0,flag=wx.EXPAND|wx.ALL,border=5)
vbox.Add(contents,proportion=1,flag=wx.EXPAND|wx.LEFT|wx.BOTTOM|wx.RIGHT,border=5)


bkg.SetSizer(vbox)
win.Show()


app.MainLoop()


import wx


def hello(event):
    print "Hello,world"


app=wx.App()
win=wx.Frame(None,title="Hello,wxPython!",size=(200,100))
button=wx.Button(win,label="Hello")
button.Bind(wx.EVT_BUTTON,hello)
win.Show()
app.MainLoop()


import sqlite3
  conn=sqlite3.connect('somedatabase.db')
  curs=conn.cursor()
  conn.commit()
  conn.close()
 


import sqlite3
def convert(value):
    if value.startswith('~'):
        return value.strip('~')
    if not value:
        value='0'
    return float(value)


conn=sqlite3.connect('food.db')
curs=conn.cursor()


curs.execute( ''' create table food(
    id   text primary key,
    desc text,
    water text,
    kcal float,
    protein float,
    fat float,
    ash float,
    carbs float,
    fiber float,
    sugar float) ''')
query='insert into food values(1,1,1,1,1,1,1,1,1,1)'
for line in open('ABBREV.txt'):
    fields=line.split('^')
    vals=[convert(f) for f in fields[:field_count]]
    curs.execute(query,vals)


conn.commit()
conn.close() 


import sqlite3, sys
conn=sqlite3.connect('food.db')
curs=conn.cursor()


import socket
s=socket.socket()
host=socket.gethostname()
port=1234
s.bind((host,port))


s.listen(5)
while True:
    c.addr=s.accept()
    print 'Got connection from',addr
    c.send('Think you for your connectin')
    c.close()


import socket


s=socket.socket()


host=socket.gethostname()
port=1234


s.connect((host,port))
print s.recv(1024)


from urllib import urlopen
webpage=urlopen('http://www.python.org')


query='select * from food where %s' % sys.argv[1]
print query
curs.execute(query)
names=[f[0] for f in curs.description]
for row in curs.fetchall():
    for pair in zip(names,row):
        print '%s:%s' % pair
    print



import re
  text=webpage.read()
  m=re.search('<a href="([^"]+)".*?>about</a>',text,re.IGNORECASE)
  m.group(1)


  urlretrieve('http://www.python.org','C:\\python_webpage.html')
  urlcleanup()
  
  
  from SocketServer import TCPServer,StreamRequestHandler
class Handler(StreamRequestHandler):
    def handle(self):
        addr=self.request.getpeername()
        print 'Got connnection from',addr
        self.wfile.write('Thank you for connecting')


server=TCPServer(('',1234),Handler)
server.serve_forever()






import SocketServer import TCPSercer,ForkingMixIn,StreamRequestHandler
class Server(ForkingMixIn,TCPServer):pass


class Handler(StreamRequestHandler):
    def handle(self):
        addr=self.request.getpeername()
        print='Got connnection from',addr
        self.wfile.write('Thank you for connecting')


server=Server(('',1234),Handler)
server.serve_forever()




import SocketServer import TCPSercer,ThreadingMixIn,StreamRequestHandler
class Server(ThreadingMixIn,TCPServer):pass


class Handler(StreamRequestHandler):
    def handle(self):
        addr=self.request.getpeername()
        print='Got connnection from',addr
        self.wfile.write('Thank you for connecting')


server=Server(('',1234),Handler)
server.serve_forever()




import socket,select
s=socket.socket()


host=socket.gethostname()
port=1234
s.bind((host,port))


s.listen(5)
inputs=[s]
while True:
    rs,ws,es=select.select(inputs,[],[])
    for r in rs:
        if r is s:
            c.addr=s.accept()
            print 'Got connection from ',addr
            inputs.append(c)
    else:
        try:
            data=r.recv(1024)
            disconnected=not data
        except socket.error:
            disconnected=True
        if disconnected:
            print r.getpeername(),'disconnected'
        else:
            print data
            


import socket,select
s=socket.socket()


host=socket.gethostname()
port=1234
s.bind((host,port))


s.listen(5)
p=select.poll()
p.register(s)
while True:
    events=p.poll()
    for fd,event in events:
        if fd in fdmap:
            c,addr=s.accept()
            print 'Got connection form' addr
            p.register(c)
            fdmap[c.fileno()'=c
        elif event & select.POLLIN:
            data=fdmap[fd].recv(1024)
            if not data:
                print fdmap[fd].getpeername(),'disconnected'
                p.unregister(fd)
                del fdmap[fd]        
        else:
            print data
            
import socket,select
s=socket.socket()


host=socket.gethostname()
port=1234
s.bind((host,port))


s.listen(5)
p=select.poll()
p.register(s)
while True:
    events=p.poll()
    for fd,event in events:
        if fd in fdmap:
            c,addr=s.accept()
            print 'Got connection form' addr
            p.register(c)
            fdmap[c.fileno()'=c
        elif event & select.POLLIN:
            data=fdmap[fd].recv(1024)
            if not data:
                print fdmap[fd].getpeername(),'disconnected'
                p.unregister(fd)
                del fdmap[fd]        
        else:
            print data
            

from twisted.internet import reactor
from twisted.internet.protocal import Protocal,Factory


class SimpleLogger(Protocal):
    def connectionMade(self):
        print 'Got connection from', self.transport.client
    def connectonLost(self,reason):
        print self.transport.client,'disconnected'
    def dataReceived(self,data):
        print data


    factory=Facotry()
    factory.protocal=SimpleLogger


    reactor.listenTCP(1234,factory)
    reactor.run()
    


from twisted.internet import reactor
from twisted.internet.protocal import Protocal,Factory
from twisted.protocols.basic import LineReceiver


class SimpleLogger(Protocal):
    def connectionMade(self):
        print 'Got connection from', self.transport.client
    def connectonLost(self,reason):
        print self.transport.client,'disconnected'
    def lineReceived(self,line):
        print line


    factory=Facotry()
    factory.protocal=SimpleLogger


    reactor.listenTCP(1234,factory)
    reactor.run()
    

from urllib import urlopen
  import re
p=re.compile('<h3><a.*?><a.*? href="(.*?)">(.*?)</a>')
text=urlopen('http://python.org/community/jobs').read()
 for url,name in p.findall(text):
print '%s (%s)' % (name,url)


from urllib import urlopen
from HTMLParser import HTMLParser


class Scraper(HTMLParser):
    in_h3=False
    in_link=False


    def handle_startag(self,tag,attrs):
        attrs=dict(attrs)
        if tag=='h3':
            self.in_h3=True
        if tag=='a' and 'href' in attrs:
            self.in_link=True
            self.chunks=[]
            self.url=attrs['href']


    def handle_data(self,data):
        if self.in_link:
            self.chunk.append(data)


    def handle_endtag(self,tag):
        if tag=='h3':
            self.in_h3=False
        if tag=='a':
            if self.in_h3 and self.in_link:
                print '%s (%s)' % (''.join(self.chunks),self.url)
                self.in_link=False


text=urlopen('http://python.org/community/jobs').read()
parser=Scraper()
parser.feed(text)
parser.close()


from urllib import urlopen
from BeautifulSoup import BeautifulSoup


text=urlopen('http://python.org/community/jobs').read()
soup=BeautifulSoup(text)


jobs=set()
for header in soup('h3'):
    links=header('a','reference')
    if not links:continue
    link=links[0]
    jobs.add('%s (%s)' % (link.string,link['href']))


print '\n'.join(sorted(jobs,key=lambda s: s.lower()))




#！ /usr/bin/env python


print 'Content-type: text/plain'
print 'Hello world'


#!/usr/bin/env python
import cgitb；cgitb.enable()
print 'Content-type:text/html'
print
print 1/0
print 'Hello world'


from =cgi.FieldStorage()
name=form['name'].value


from area import rect_area
height=3
width=4
correct_answer=12
answer=rect_area(height,width)
if answer==correct_answer:
    print'Test passed'
else:
    print 'Test failed'
    
import doctest


def square(x):
    '''
    Squares a number and returns the result.


    >>> square(2)
    4
    >>> square(3)
    9


    '''
    return x*x
if __name__=='__main__':
    import doctest,my_math
    doctest.testmod(my_math)

import unittest,my_math
class ProductTEstCase(unittest.TestCase):
    def testIntegers(self):
        for x in xrange(-10,10):
            for y in xrange(-10,10):
                p=my_math.product(x,y)
            self.failUnless(p==x*y,'Integer multiplication failed')
    def testFloats(self):
        for x in xrange(-10,10):
            for y in xrange(-10,10):
                x=x/10.0
                y=y/10.0
                p=my_math.product(x,y)
            self.failUnless(p==x*y,'Float multiplication failed')
if __name__=='__main__':unittest.main()






import pylint.lint


import unittest,my_math
from subprocess import Popen,PIPE
class ProductTestCase(unittest.TestCase):
    def testWithPyChecker(self):
        cmd='pychecker','-Q',my_math.__file__.rstrip('c')
        pycheck=Popen(cmd,stdout=PIPE,stderr=PIPE)
        self.assertEqual(pychecker.stdout.read(),'')


    def testWithPylint(self):
        cmd='pylint','-rn','my_math'
        pylint=Popen(cmd,stdout=PIPE,stderr=PIPE)
        self.assertEqual(pylint.stdout.read(),'')
if __name__=='__main__':unittest.main()




import profile
from my_math import product
profile.run('product(1,2)')


from distutils.core import setup
setup(name='Hello',
      version='1.0',
      description='A simple example',
      author='Magnus Lie Hetland',
      py_modules=['my_math'])


 
from distutils.core import setup
import py2exe
setup(console=['my_math'])


from ConfigParser import ConfigParser
CONFIGFILE="python.txt"
config=ConfigParser()
config.read(CONFIGFILE)
print config.get('messages','greetging')


# -*- coding: cp936 -*-
log=open('logfile.txt','w')
print>>log,('Downloading file from URL %s' % url)
text=urllib.urlopen(url).read()
print>>log,'FIle successfully downloaded'


import logging
logging.basicConfig(level=logging.INFO,filename='mylog.log')
logging.info('Starting program')
logging.info('Trying to divide 1 by 0')
print 1/0
logging.info('The division successed')
logging.info('Ending program')


def lines(file):
    for line in file:yield line
    yield '\n'


def blocks(file):
    block=[]
    for line in lines(y):
        if line.strip():
            block.append(line)
        elif block:
            yield ''.join(block).strip()
            block=[]
            

import sys,re
from util import *


print '<html><head><title>...</title><body>'


title=True
for block in blocks(sys.stdin):
    block=re.sub(r'\*(.+?)\*',r'<em>\1</em>',block)
    if title:
        print '<h1>'
        print block
        print '</h1>'
        title=False


    else:
        print '<p>'
        print block
        print '</p>'
print'</body></html>'


python simple_markup.py <test_input.txt> test_out.html




class Handler:
    def callback(self,prefix,name,*args):
        method=getattr(self,prefix+name,None)
        if callable(method):return method(*args)
    def start(self,name):
        self.callback('start_',name)
    def end(self,name):
        self.callback('end_',name)
    def sub(self,name):
        def substitution(match):
            result=self.callback('sub_',name,match)
            if result is None:match.group(0)
            return result
        return substitution
    
class HTMLRenderer(Handler):
    def start_paragraph(self):
        print '<p>'
    def end_paragraph(self):
        print '</p>'
    def sub_emphasis(self,match):
        return '<em>%s</em>' % match.group(1)
    def feed(self,data):
        print data


     re.sub(r'\*(.+?)\*',handler.sub('emphasis'),'This *is* a test')
 
class Rule:
    def action(self,block,handler):
        handler.start(self,type)
        handler.feed(block)
        handler.end(self.type)
        return True




class Parser:
    '''
    A parser reads a text file,applying rules and controlling a handler


    '''
    def __init__(self,handler):
        self.handler=handler
        self.rules=[]
        self.filters=[]
    def addRule(self,rule):
        self.rules.append(rule)
    def addFilter(self,pattern,name):
        def filter(block,handler):
            return re.sub(pattern,handler.sub(name),block)
        self.filters.append(filter)
    def parse(self,file):
        self.handler.start('document')
        for block in blocks(file):
            for filter in self.filters:
                for filter in self.filters:
                    block=filter(block,self.handler)
            for rule in self.rules:
                if rule,condition(block):
                    last=rule.action(block,self.handler)
                    if last:break
        self.handler.end('document')
        
class Rule:
    def action(self,block,handler):
        handler.start(self,type)
        handler.feed(block)
        handler.end(self.type)
        return True



import sys,re
from handlers import *
from util import *
from rules import *


class Parser:
    def __init__(self,handler):
        self.handler=handler
        self.rules=[]
        self.filters=[]
    def addRule(self,rule):
        self.rules.append(rule)
    def addFilter(self,pattern,name):
        def filter(block,handler):
            return re.sub(pattern,handler.sub(name),block)
        self.filters.append(filter)
    def parse(self,file):
        self.handler.start('document')
        for block in blocks(file):
            for filter in self.filters:
block=filter(block,self.handler)
            for rule in self.rules:
                if rule.condition(block):
                    last=rule.action(block,self.handler)
                    if last:break
        self.handler.end('document')


class BasicTextParser(Parser):
    def __init__(self,handler):
        Parser.__init__(self,handler)
        self.addRule(ListRule())
        self.addRule(ListItemRule())
        self.addRule(TitleRule())
        self.addRule(HeadingRule())
        self.addRule(ParagraphRule())
        self.addFilter(r'\*(.+?)\*','emphasis')
        self.addFilter(r'(http://[\.a-zA-Z]+)','url')
        self.addFilter(r'([\.a-zA-Z]+@[\.a-zA-Z]+[a-zA-Z]+)','mail')


handler=HTMLRenderer()
parser=BasicTextParser(handler)


parser.parse(sys.stdin)




class Handler:
    def callback(self,prefix,name,*args):
        method=getattr(self,prefix+name,None)
        if callable(method):return method(*args)
    def start(self,name):
        self.callback('start_',name)
    def end(self,name):
        self.callback('end_',name)
    def sub(self,name):
        def substitution(match):
            result=self.callback('sub_',name,match)
            if result is None:match.group(0)
            return result
        return substitution
class HTMLRenderer(Handler):
    def start_document(self):
        print '<html><head><title>...</title></head><body>'
    def end_document(self):
        print '</body><html>'
    def start_paragraph(self):
        print'<p>'
    def end_paragraph(self):
        print '</p>'
    def start_heading(self):
        print '<h2>'
    def end_heading(self):
        print '</h2>'
    def start_list(self):
        print '<url>'
    def end_list(self):
        print '</url>'
    def start_listitem(self):
        print '<li>'
    def end_listitem(self):
        print '</li>'
    def start_title(self):
        print '<h1>'
    def end_title(self):
        print '</h1>'
    def sub_emphasis(self,match):
        return '<em>%s</em>' % match.group(1)
    def sub_url(self,match):
        return '<a href="%s">%s</a>' % (match.group(1),match.group(1))
    def sub_mail(self,match):
        return '<a href="mailto:%s">%s</a>' % (match.group(1),match.group(1))
    def feed(self,data):
        print data







class Rule:
    def action(self,block,handler):
        handler.start(self,type)
        handler.feed(block)
        handler.end(self,type)
        return True


class HeadingRule(Rule):
    type='heading'
    def condition(self,block):
        return not '\n' in block and len(block)<=70 and not block[-1]==':'


class TitleRule(HeadingRule):
    type='title'
    first=True
    def condition(self,block):
        if not self.first:return False
        self.first=False
        return HeadingRule.condition(self,block)


class ListItemRule(Rule):
    type='listitem'
    def condition(self,block):
        return block[0]=='-'
    def action(self,block,handler):
        handler.start(self,type)
        handler.feed(block[1:].strip())
        handler.end(self.type)
        return True


class ListRule(ListItemRule):
    type='list'
    inside=False
    def condition(self,block):
        return True
    def action(self,block,handler):
        if not self.inside and ListItemRule.condition(self,block):
            handler.start(self,type)
            self.inside=True
        elif self.inside and not ListItemRule.condition(self.block):
            handler.end(self,type)
            self.inside=False
        return False
class ParagraphRule(Rule):
    type='paragraph'
    def condition(self,block):
        return True
    
   
 from reportlab.graphics.shapes import Drawing,String
from reportlab.graphics import renderPDF


d=Drawing(100,100)
s=String(50,50,'Hello, world', textAnchor='middle')


d.add(s)


renderPDF.drawToFile(d,'hello.pdf','A simple PDF file')


from reportlab.lib import colors
from reportlab.graphics.shapes import *
from reportlab.graphics import renderPDF


data=[
    (2007,8,113.2,114.2,112.2),
    (2007,9,112.8,115.8,109.8),
    (2007,10,111.0,116.0,106.0)]
drawing=Drawing(200,150)
pred=[row[2]-40 for row in data]
high=[row[3]-40 for row in data]
low=[row[4]-40 for row in data]
times=[200*((row[0]+row[1]/12.0)-2007)-100 for row in data]


drawing.add(PolyLine(zip(times,pred),strokeColor=colors.blue))
drawing.add(PolyLine(zip(times,high),strokeColor=colors.blue))
drawing.add(PolyLine(zip(times,low),strokeColor=colors.blue))
drawing.add(String(65,115,'Sunspots',fontSize=18,fillColor=colors.red))


renderPDF.drawToFile(drawing,'report1.pdf','Sunspots')


data=[]
for line in urlopen(URL).readlines():
    if not line.isspace() and not line[0] in COMMENT_CHARS:
        data.append([float(n) for n in line.split()])
        
from urllib import urlopen
from reportlab.graphics.shapes import *
from reportlab.graphics.charts.lineplots import LinePlot
from reportlab.graphics.charts.textlabels import Label
from reportlab.graphics import renderPDF




URL='http://services.swpc.noaa.gov/text/predicted-sunspot-radio-flux.txt'
COMMENT_CHARS='#:'


drawing=Drawing(400,200)
data=[]
for line in urlopen(URL).readlines():
    if not line.isspace() and not line[0] in COMMENT_CHARS:
        data.append([float(n) for n in line.split()])




pred=[row[2] for row in data]
high=[row[3] for row in data]
low=[row[4] for row in data]
times=[row[0] +row[1]/12.0 for row in data]


lp=LinePlot()
lp.x=50
lp.y=50
lp.height=125
lp.width=300
lp.data=[zip(times,pred),zip(times,high),zip(times,low)]
lp.lines[0].strokeColor=colors.blue
lp.lines[1].strokeColor=colors.red
lp.lines[2].strokeColor=colors.green




drawing.add(lp)
drawing.add(String(250,150,'Sunspots',fontSize=14,fillColor=colors.red))


renderPDF.drawToFile(drawing,'report2.pdf','Sunspots')




from xml.sax.handler import ContentHandler
from xml.sax import parse
import os


class Dispatcher:
    def dispatch(self,prefix,name,attrs=None):
        mname=prefix+name.capitalize()
        dname='default'+prefix.capitalize()
        method=getattr(self,mname,None)
        if callable(method):args=()
        else:
            method=getattr(self,dname,None)
            args=name
        if prefix=='start':args+=attrs
        if callable(method):method(*args)


    def startElement(self,name,attrs):
        self.dispatch('start',name,attrs)


    def endElement(self,name):
        self.dispatch('end',name)




class WebsiteConstructor(Dispatcher,ContentHandler):
    passthrough=False


    def __init__(self,directory):
        self.directory=[directory]
        self.ensureDirectory()


    def ensureDirectory(self):
        path=os.path.join(*self.directory)
        if not os.path.isdir(path):os.makedirs(path)


    def characters(self,chars):
        if self.passthrough:self.out.write(chars)


    def defaultStart(self,name,attrs):
        if self.passthrough:
            self.out.write('<'+name)
            for key,val in attrs.items():
                self.out.write('%s="%s"' % (key,val))
                self.out.write('>')


    def defaultEnd(self,name):
        if self.passthrough:
            self.out.write('</%s>' % name)


    def startDirectory(self,attrs):
        self.directory.append(attrs['name'])
        self.ensureDirectory()


    def endDirectory(self):
        self.directory.pop()


    def startPage(self,attrs):
        filename=os.path.join(*self.directory+[attrs['name']+'html'])
        self.out=open(filename,'w')
        self.writeHeader(attrs['title'])
        self.passthrough=True


    def endPage(self):
        self.passthrough=False
        self.writeFooter()
        self.out.close()


    def wirteHeader(self,title):
        self.out.write('<html>\n<head>\n <title>')
        self.out.write(title)
        self.out.write('</title>\n</head>\n <body>\n')


    def writeFooter(self):
        self.out.write('\n</body>\n</html>\n')


parse('website.xml',WebsiteConstructor('public_html'))


from nntplib import NNTP
from time import strftime,time,localtime


day=24*60*60


yesterday=localtime(time()-day)
date=strftime('%y%m%d',yesterday)
hour=strftime('%H%M%S',yesterday)


servername='news.food.bar'
group='comp.lang.python.announce'
server=NNTP(servername)


ids=server.newnews(group,date,hour)[1]


for id in ids:
    head=server.head(id)[3]
    for line in head:
        if line.lower().startswith('subject'):
            subject=line[9:]
            break
    body=server.body(id)[3]


    print subject
    print '-'*len(subject)
    print '\n'.join(body)

class NewsItem:
    def __init__(self,title,body):
        self.title=title
        self.body=body


class NewsAgent:
    def __init__(self):
        self.sources=[]
        self.destinations=[]


    def addSource(self,source):
        self.sources.append(source)


    def addDestination(self,dest):
        self.destinations.append(dest)


def distribute(self):
    items=[]
    for source in self.sources:
        items.extend(source.getItems())
    for dest in self.destinations:
        dest.receiveItems(items)


class PlainDestination:
    def receiveItem(self,items):
        for item in items:
            print item.title
            print '-'*len(item.title)
            print item.body
             


server.quit()


sys.getdefaultencoding()




from asyncore import dispatcher
from asynchat import async_chat
import socket,asyncore


PORT=5005


class ChatSession(async_chat):
    def __init__(self,server,sock):
        async_chat.__init__(self,sock)
        self.set_terminator("\r\n")
        self.server=server
        self.data=[]
        self.push('Welcome to %s\r\n' % self.server.name)
        


    def collect_incoming_data(self,data):
        self.data.append(data)


    def found_terminator(self):
        line=''.join(self.data)
        self.data=[]
        print line




class ChatServer(dispatcher):
    def __init__(self,port):
        dispatcher.__init__(self)
        self.create_socket(socket.AF_INET,socket.SOCK_STREAM)
        self.set_reuse_addr()
        self.bind(('',PORT))
        self.listen(5)
    
    def handle_accept(self):
        conn.addr=self.accept()
        print 'Connection attempt from', addr[0]


if __name__=='__main__':
    s=ChatServer(PORT)
    try:asyncore.loop()
    except KeyboardInterrupt:pass

from asyncore import dispatcher
from asynchat import async_chat
import socket,asyncore


PORT=5005


class ChatSession(async_chat):
    def __init__(self,server,sock):
        async_chat.__init__(self,sock)
        self.set_terminator("\r\n")
        self.server=server
        self.data=[]
        self.push('Welcome to %s\r\n' % self.server.name)
        


    def collect_incoming_data(self,data):
        self.data.append(data)


    def found_terminator(self):
        line=''.join(self.data)
        self.data=[]
        print line




class ChatServer(dispatcher):
    def __init__(self,port):
        dispatcher.__init__(self)
        self.create_socket(socket.AF_INET,socket.SOCK_STREAM)
        self.set_reuse_addr()
        self.bind(('',PORT))
        self.listen(5)
    
    def handle_accept(self):
        conn.addr=self.accept()
        print 'Connection attempt from', addr[0]






class CommandHandler:
    def unknown(self,session,cmd):
        session.push('Unknown command: %s\r\n' % cmd)


    def handle(self,session,line):
        if not line.strip(): return
        parts=line.split('',1)
        cmd=parts[0]
        try:line=parts[1].strip()
        except IndexError:line=''
        meth=getattr(self,'do_'+cmd,None)
        try:
            meth(session,line)
        except TypeError:
            self.unknown(session,cmd)
            
class EndSession(Exception):pass
class Room(CommandHandler):
    def __init__(self,server):
        self.server=server
        self.sessions=[]


    def add(self,session):
        self.sessions.append(session)


    def remove(self,session):
        self.sessions.remove(session)


    def broadcast(self,line):
        for session in self.sessions:
            session.push(line)


    def do_logout(self,session,line):
        raise EndSession
    










        


if __name__=='__main__':
    s=ChatServer(PORT)
    try:asyncore.loop()
    except KeyboardInterrupt:pass
    
import cgi
form =cgi.FieldStorage()


text=form.getvalue('text',open('simple_edit.dat').read())
f=open('simple_edit.dat','w')
f.write(text)
f.close()
print """ Content-type:text/html


    <html>
    <head>
    <title> A simple Editor</title>
    </head>
    <body>
    <form action ='simple_edit.cgi' method='POST'>
    <textarea rows='10' cols='20' name='text'>%x </textarea><br />
    <input type='submit'/>
    </form>
    <body>
    </html>
    """ % text

from os.path import join ,abspath
import cgi,sha,sys


BASE_DIR=abspath('data')
form=cgi.FieldStorage()


text=form.getvalue('text')
filename=form.getvalue('filename')
password=form.getvalue('password')


if not (filename and text and password):
    print 'Invalid parameters.'
    sys.exit()




if sha.sha(password).hexdigest()!='88888888888888dsfdasdsafasd':
    print 'Invalid password'




f=open(jopin(BASE_DIR.filename),'w')
f.write(text)
f.close()


print 'The file has been saved'




import psycopy
import cgitb;cgitb.enable()
conn=psycopg.connect('user=foo dbname=bar')
curs=conn.cursor()




reply_to=raw_input('Reply to:')
subject=raw_input('Subject:')
sender=raw_input('Sender:')
text=raw_input('TExt:')


if reply_to:
    query="""
    INSERT INTO messages(reply_to, sender, subject,text)
    Values(%s,'%s','%s','%s')""" % (reply_to,sender,subject,text)
else:
    query="""
    INSERT INTO message(sender,subject,text)
    VALUES('%s','%s','%s') """ % (sender,subject,text)


curs.execute(query)
conn.commit()




curs.execute('select * from messages')
rows=curs.dictfetchall()


toplevel=[]
children={}


for row in rows:
    parent_id =row['reply_to']
    if parent_id is None:
        toplevel.append(row)
    else:
        children.setdefault(parent_id,[]).append(row)
        def format(row):
            print row['subject']
            try:kids=children[row['id']]
            except Keyerror:pass
            else:
                print '<blockquote>'
                for kid in kids:
                    format(kid)
                print '</blockquote>'


        print '<p>'


        for row in toplevel:
            format(row)


        print """
            </p>
            </body>
            </html>
            """


from xmlrpclib import ServerProxy
from os.path import join,isfile
from SimpleXMLRPCServer import SimpleXMLRPCServer
from urlparse import urlparse


MAX_HISTORY_LENGTH=6


OK==1
FAIL=2
EMPTY=''


def getPort(url):
    name=urlparse(url)[1]
    parts=name.split(':')
    return int(parts[-1])




class Node:
    def __init__(self,url,dirname,secret):
        self.url=url
        self.dirname=dirname
        self.secret=secret
        self.known=set()


    def query(self,query,history=[]):
        code,data=self._handle(query)


    if code==OK:
        return code,data
    else:
        history=history+[self.url]
        if len(history)>=MAX_HISTORY_LENGTH:
            return FAIL,EMPTY
        return self._broadcast(query,history)


    def hello(self,other):
        self.known.add(other)
        return OK


    def fetch(self,query,secret):
        if secret!=self.secret:return FAIL
        code,data=self.query(query)
        if code==OK:
            f=oipen(join(self.dirname,query),'w')
            f.write(data)
            f.close()
            return OK
        else:
            return FAIL


    def _start(self):
        s=SimpleXMLRPCServer(("",getPort(self.url)),logRequests=false)
        s.register_instance(self)
        s.serve_forever()


    def _handle(self,query):
        dir=self.dirname
        name=join(dir,query)
        if not isfile(name):return FAIL,EMPRY
        return OK, open(name).read()
    def _broadcast(self,query,history):
        for other in self.known.copy():
            if other in histroy:continue
            try:
                s=ServerProxy(other)
                code,data=s.query(query,history)
                if code==OK:
                    return code,data
                except:
                    self.known.remove(other)
                return FAIL,EMPTY
    def main():
        url,directory,secret=sys.argv[1:]
        n=Node(url,directory,secret)
        n._start()


    if __name__=='__main__':main()
    


import sys,pygame
from pygame.locals import *
from random import randrange


class Weight(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image=weight_image
        self.rect=self.image.get_rect()
        self.reset()


    def reset(self):
        self.rect.top=-self.rect.height
        self.rect.centerx=randrange(screen_size[0])


    def update(self):
        self.rect.top+=1
        if self.rect.top>screen_size[1]:
            self.reset()


pygame.init()
screen_size=800,600
pygame.display.set_mode(screen_size,FULLSCREEN)
pygame.mouse.set_visible(0)


weight_image=pygame.image.load('weight.png')
weight_image=weight_image.covert()




sprites=pygame.sprite.RenderUpdates()
sprites.add(Weight())




screen=pygame.display.get_suface()
bg=(255,255,255)
screen.fill(bg)
pygame.display.filp()


def clear_callback(surf,rect):
    surf.fill(bg,rect)


while True:
    for event in pygame.event.get():
        if event.type==QUIT:
            sys.exit()
        if event.type==KEYDOWN and event.key==K_ESCAPE:
            sys.exit()


sprites.clear(screen,clear_callback)
sprites.update()
updates=sprites.draw(screen)
pygame.display.update(updates)