您的位置：首页 > 编程语言 > Python开发

Python 编程基础学习笔记

2017-05-11 10:34 453 查看

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)

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

Python 编程基础 学习笔记

Python 编程基础学习笔记