国产一区二区三区高清,久久亚裔精品欧美,亚洲一区三区视频在线观看

风林 — Tue, 07 Sep 2010 04:16:00 GMT

django是一个开源框枉��目，详情误��官网http://www.djangoproject.com

风林 2010-09-07 12:16 发表评论

风林 — Wed, 01 Sep 2010 05:11:00 GMT

#!/usr/bin/python
#Filename:myAddressBook.py

import os
#used cPlickle store
import cPickle as p

########class Person##############
class Person:
  def __init__(self,name,email):
    self.name = name
    self.email = email

  def __del__(self):
    pass
################################

#######class AddressBook#######
class AddressBook:
  #the long name of data file
  addressFile = 'Address.data'

  #dictionary
  addressList ={}


  def __init__(self):
    #If the data file of addressbook is not exists,then create it.
    if not os.path.isfile(AddressBook.addressFile):
      f = file(AddressBook.addressFile,'w')
      p.dump(AddressBook.addressList,f)
      f.close()
      print 'Created file successfull!'
    else:
      #If the data file of addressbook is exists,then list all.
      f = file(AddressBook.addressFile)
      AddressBook.addressList = p.load(f)
      print 'Current address list:'
      f.close()
      self.List()#call List function

  #When destroy object,save data to file.
  def __del__(self):
    try:
      try:
        f = file(AddressBook.addressFile,'w')
        p.dump(AddressBook.addressList,f)
        print 'Save data successfull!'
      except:
        print 'Save data fail!'
    finally:
      f.close()

  #purpose:Add new record
  def Add(self,pepole):
    if len(pepole.name)==0:
      print 'The length of name must longer than zero.'
    elif len(pepole.email)==0:
      print 'The length of emial must longer than zero.'
    else:
      pr = Person(pepole.name,pepole.email)
      AddressBook.addressList[pepole.name] = pr
      print 'Add new person successfull!'

  #purpose:Delete a record by name
  def Del(self,name):
    if AddressBook.addressList.has_key(name):
      del AddressBook.addressList[name]
      print 'Deleted %s successfull!' % name
    else:
      print 'The name is not exists.'

  #purpose:Modify a record by name
  def Edit(self,name,people):
    if AddressBook.addressList.has_key(name):
      AddressBook.addressList[name] = people
      print 'Edit %s\'s information successfull!' % name
    else:
      print 'The name is not exists.'

  #purpose:Find a record by name
  def Find(self,name):
    if AddressBook.addressList.has_key(name):
      print '%s\'s information is :\nName:%s\nEmail:%s'\
       % (name,\
       AddressBook.addressList[name].name,\
       AddressBook.addressList[name].email)
    else:
      print 'The name is not exists.'

  #purpose:List all record
  def List(self):
    print '\n' + '*'*10  + 'Address List' + '*'*10  + '\n'
    for name,people in AddressBook.addressList.items():
      print '%s\'s information is :\nName:%s\nEmail:%s' % (name,people.name,people.email)
      print '-'*30

################main####################################
os.system('clear')
ad = AddressBook()
while True:
  print '\n' + '*'*10 + 'Main menu' + '*'*10 +'''
           1.Add new address
           2.Delete an address by name
           3.Edit an address by name
           4.Find an address by name
           5.List all record
           6.Exit'''+\
   '\n' + '*'*30
  try:
    choice = int(raw_input('Please choice:'))
  except:
    os.system('clear')
    print 'Error:Please enter a number from 1 to 6,enter again.'
    continue

  if choice == 1:
    name = raw_input('Please input name:')
    email = raw_input('Please input email:')
    people = Person(name,email)
    ad.Add(people)
  elif choice == 2:
    name = raw_input('Please input name:')
    ad.Del(name)
  elif choice == 3:
    name = raw_input('Please input name:')
    newemail = raw_input('Please input new email:')
    people = Person(name,newemail)
    ad.Edit(name,people)
  elif choice == 4:
    name = raw_input('Please input name:')
    ad.Find(name)
  elif choice == 5:
    ad.List()
  elif choice == 6:
    break
  else:
    os.system('clear')

风林 2010-09-01 13:11 发表评论

repr函数

风林 — Wed, 01 Sep 2010 00:44:00 GMT

repr函数用来取得对象的规范字�W�串表示�?/span>反引��P��也称转换�W�）可以完成相同的功能�?/span>�?br>意，在大多数时候有eval(repr(object)) == object�?br>>>> i = []
>>> i.append('item')
>>> `i`
"['item']"
>>> repr(i)
"['item']"

基本上，repr函数和反引号用来获取对象的可打印的表�C��Ş式。你可以通过定义�cȝ��__repr__
�Ҏ��来控制你的对象在被repr函数调用的时候返回的内容�?

风林 2010-09-01 08:44 发表评论

assert语句

风林 — Wed, 01 Sep 2010 00:39:00 GMT

assert语句用来声明某个条�g是真的�?br>例如�Q�如果你非常��信某个你��用的列表中至��有一�?br>元素�Q�而你惌��验这一点，�q�且在它非真的时候引发一个错误，那么assert语句是应用在�q?br>�U�情形下的理惌��句。当assert语句��p�|的时候，会引发一个AssertionError�?br>>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> assert len(mylist) >= 1
Traceback (most recent call last):
File "", line 1, in ?
AssertionError

风林 2010-09-01 08:39 发表评论

exec和eval语句

风林 — Wed, 01 Sep 2010 00:36:00 GMT

exec语句用来执行储存在字�W�串或文件中的Python语句�?/u>例如�Q�我们可以在�q�行时生成一个包
含Python代码的字�W�串�Q�然后��用exec语句执行�q�些语句。下面是一个简单的例子�?br>>>> exec 'print "Hello World"'
Hello World

eval语句用来计算存储在字�W�串中的有效Python表达式�?/strong>下面是一个简单的例子�?br>>>> eval('2*3')

风林 2010-09-01 08:36 发表评论

lambda形式

风林 — Wed, 01 Sep 2010 00:33:00 GMT
lambda语句被用来创建新的函数对象，�q�且在运行时�q�回它们�?br>
#!/usr/bin/python
# Filename: lambda.py
def make_repeater(n):
    return lambda s: s*n
twice = make_repeater(2)
print twice('word')
print twice(5)
输出
$ python lambda.py
wordword
10

它如何工�?/strong>
�q�里�Q�我们��用了make_repeater函数在运行时创徏新的函数对象�Q��ƈ且返回它。lambda语句�?br>来创建函数对象。本质上�Q�lambda需要一个参敎ͼ�后面仅跟单个表达式作为函��C��Q�而表辑ּ�
的��D��q�个新徏的函数返回�?span style="COLOR: red">注意�Q�即便是print语句也不能用在lambda形式中，只能使用表达
式�?/span>

风林 2010-09-01 08:33 发表评论

风林 — Wed, 01 Sep 2010 00:28:00 GMT
当要使函数接收元�l�或字典形式的参数的时候，有一�U�特�D�的�Ҏ��Q�它分别使用*�?*前缀�?br>�q�种�Ҏ��在函数需要获取可变数量的参数的时候特别有用�?br>>>> def powersum(power, *args):
...     '''Return the sum of each argument raised to specified power.'''
...     total = 0
...     for i in args:
...          total += pow(i, power)
...     return total
...
>>> powersum(2, 3, 4)
25
>>> powersum(2, 10)
100
�׃��在args变量前有*前缀�Q�所有多余的函数参数都会作�ؓ一个元�l�存储在args中。如果��用的
�?*前缀�Q�多余的参数则会被认为是一个字典的�?值对�?/span>

风林 2010-09-01 08:28 发表评论

使用列表�l�合

风林 — Wed, 01 Sep 2010 00:24:00 GMT

#!/usr/bin/python
# Filename: list_comprehension.py
listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2]
print listtwo
输出
$ python list_comprehension.py
[6, 8]

它如何工�?/strong>
�q�里我们为满��x��Ӟ��if i > 2�Q�的数指定了一个操作（2*i�Q�，从而导��Z��个新的列表。注意原
来的列表�q�没有发生变化。在很多时候，我们都是使用循环来处理列表中的每一个元素，而��
用列表综合可以用一�U�更加精��、简�z�、清楚的�Ҏ��完成相同的工作�?

风林 2010-09-01 08:24 发表评论

vim快捷键��d��

风林 — Tue, 31 Aug 2010 10:21:00 GMT

风林 2010-08-31 18:21 发表评论

风林 — Tue, 31 Aug 2010 10:09:00 GMT
�?5.1 一些特�D�的�Ҏ��
名称说明
__init__(self,...) �q�个�Ҏ��在新建对象恰好要被返回��用之前被调用�?br>__del__(self) 恰好在对象要被删除之前调用�?br>__str__(self) 在我们对对象使用print语句或是使用str()的时候调用�?br>__lt__(self,other)当��?��于 �q�算�W�（<�Q�的时候调用。类似地�Q�对于所有的�q�算�W?br>�Q?�Q?gt;�{�等�Q�都有特�D�的�Ҏ��?br>__getitem__(self,key)使用x[key]索引操作�W�的时候调用�?br>__len__(self) 对序列对象��用内建的len()函数的时候调用�?

风林 2010-08-31 18:09 发表评论

sys模块

风林 — Tue, 31 Aug 2010 10:06:00 GMT

#!/usr/bin/python
# Filename: cat.py
import sys
def readfile(filename):
    '''Print a file to the standard output.'''
    f = file(filename)
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print line, # notice comma
    f.close()
# Script starts from here
if len(sys.argv) < 2:
    print 'No action specified.'
    sys.exit()
if sys.argv[1].startswith('--'):
    option = sys.argv[1][2:]
    # fetch sys.argv[1] but without the first two characters
    if option == 'version':
        print 'Version 1.2'
    elif option == 'help':
        print '''\
This program prints files to the standard output.
Any number of files can be specified.
Options include:
  --version : Prints the version number
  --help    : Display this help'''
    else:
        print 'Unknown option.'
    sys.exit()
else:
    for filename in sys.argv[1:]:
        readfile(filename)
输出
$ python cat.py
No action specified.
$ python cat.py --help
This program prints files to the standard output.
Any number of files can be specified.
Options include:
--version : Prints the version number
--help    : Display this help
$ python cat.py --version
Version 1.2
$ python cat.py --nonsense
Unknown option.
$ python cat.py poem.txt
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Python!

风林 2010-08-31 18:06 发表评论

os模块

风林 — Tue, 31 Aug 2010 10:04:00 GMT
�q�个模块包含普遍的操作系�l�功能。如果你希望你的�E�序能够与��^台无关的话，�q�个模块是尤
为重要的。即它允�怸�个程序在�~�写后不需要�Q何改动，也不会发生�Q何问题，��可以在
Linux和Windows下运行。一个例子就是��用os.sep可以取代操作�pȝ��特定的�\径分割符�?br>下面列出了一些在os模块中比较有用的部分。它们中的大多数都简单明了�?br>�?nbsp;    os.name字符串指�C�Z��正在使用的��^台。比如对于Windows�Q�它�?nt'�Q�而对于Linux/Unix
用户�Q�它�?posix'�?br>�?nbsp;    os.getcwd()函数得到当前工作目录�Q�即当前Python脚本工作的目录�\径�?br>�?nbsp;    os.getenv()和os.putenv()函数分别用来��d��和设�|�环境变量�?br>�?nbsp;    os.listdir()�q�回指定目录下的所有文件和目录名�?br>�?nbsp;    os.remove()函数用来删除一个文件�?br>�?nbsp;    os.system()函数用来�q�行shell命��o�?br>�?nbsp;    os.linesep字符串给出当前��^��C��用的行终止符。例如，Windows使用'\r\n'�Q�Linux�?br>�?\n'而Mac使用'\r'�?br>�?nbsp;    os.path.split()函数�q�回一个�\径的目录名和文�g名�?br>>>> os.path.split('/home/swaroop/byte/code/poem.txt')
('/home/swaroop/byte/code', 'poem.txt')
�?nbsp;    os.path.isfile()和os.path.isdir()函数分别��验给出的路径是一个文件还是目录。类似地�Q�os.
path.exists()函数用来��验给出的路径是否真地存在�?

风林 2010-08-31 18:04 发表评论

try..finally

风林 — Tue, 31 Aug 2010 09:19:00 GMT
假如你在��M��个文件的时候，希望在无论异常发生与否的情况下都关闭文�g�Q�该怎么做呢�Q�这
可以使用finally块来完成。注意，在一个try块下�Q�你可以同时使用except从句和finally块。如�?br>你要同时使用它们的话�Q�需要把一个嵌入另外一个�?br>
#!/usr/bin/python
# Filename: finally.py
import time
try:
    f = file('poem.txt')
    while True: # our usual file-reading idiom
        line = f.readline()
        if len(line) == 0:
            break
        time.sleep(2)
        print line,
finally:
    f.close()
    print 'Cleaning upclosed the file'
输出
$ python finally.py
Programming is fun
When the work is done
Cleaning up...closed the file
Traceback (most recent call last):
File "finally.py", line 12, in ?
    time.sleep(2)
KeyboardInterrupt

它如何工�?/strong>
我们�q�行通常的读文�g工作�Q�但是我有意在每打印一行之前用time.sleep�Ҏ��暂停2�U�钟。这�?br>做的原因是让�E�序�q�行得慢一些（Python�׃��其本质通常�q�行得很快）。在�E�序�q�行的时候，
按Ctrl-c中断/取消�E�序�?br>我们可以观察到KeyboardInterrupt异常被触发，�E�序退出。但是在�E�序退��Z��前，finally从句�?br>然被执行�Q�把文�g关闭

风林 2010-08-31 17:19 发表评论

raise 引发异常

风林 — Tue, 31 Aug 2010 09:12:00 GMT
你可以��用raise语句引发异常。你�q�得指明错误/异常的名�U�和伴随异常触发�?异常对象。你
可以引发的错误或异常应该分别是一个Error或Exception�cȝ��直接或间接导出类�?br>
#!/usr/bin/python
# Filename: raising.py
class ShortInputException(Exception):
    '''A user-defined exception class.'''
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast
try:
    s = raw_input('Enter something --> ')
    if len(s) < 3:
        raise ShortInputException(len(s), 3)
    # Other work can continue as usual here
except EOFError:
    print '\nWhy did you do an EOF on me?'
except ShortInputException, x:
    print 'ShortInputException: The input was of length %d, \
          was expecting at least %d' % (x.length, x.atleast)
else:
    print 'No exception was raised.'
输出
$ python raising.py
Enter something -->
Why did you do an EOF on me?
$ python raising.py
Enter something --> ab
ShortInputException: The input was of length 2, was expecting at least 3
$ python raising.py
Enter something --> abc
No exception was raised.

它如何工�?/strong>
�q�里�Q�我们创��Z��我们自己的异常类型，其实我们可以使用��M��预定义的异常/错误。这个新
的异常类型是ShortInputException�c�R��它有两个域——length是给定输入的长度�Q�atleast则是�E�序
期望的最��长度�?br>在except从句中，我们提供了错误类和用来表�C�错�?异常对象的变量。这与函数调用中的�Ş�?br>和实参概�늱�伹{��在�q�个特别的except从句中，我们使用异常对象的length和atleast域来为用�?br>打印一个恰当的消息�?

风林 2010-08-31 17:12 发表评论

处理异常

风林 — Tue, 31 Aug 2010 09:03:00 GMT
我们可以使用try..except语句来处理异常。我们把通常的语句放在try-块中�Q�而把我们的错误处
理语句放在except-块中�?br>
#!/usr/bin/python
# Filename: try_except.py
import sys
try:
    s = raw_input('Enter something --> ')
except EOFError:
    print '\nWhy did you do an EOF on me?'
    sys.exit() # exit the program
except:
    print '\nSome error/exception occurred.'
    # here, we are not exiting the program
print 'Done'
输出
$ python try_except.py
Enter something -->
Why did you do an EOF on me?
$ python try_except.py
Enter something --> Python is exceptional!
Done

它如何工�?br>我们把所有可能引发错误的语句攑֜�try块中�Q�然后在except从句/块中处理所有的错误和异常�?br>except从句可以专门处理单一的错误或异常�Q�或者一�l�包括在圆括号内的错�?异常。如果没�?br>�l�出错误或异常的名称�Q�它会处�?所有的错误和异常。对于每个try从句�Q�至��都有一个相�?br>联的except从句�?br>如果某个错误或异常没有被处理�Q�默认的Python处理器就会被调用。它会终止程序的�q�行�Q��ƈ
且打��C��个消息，我们已经看到了这��L��处理�?br>

风林 2010-08-31 17:03 发表评论

风林 — Tue, 31 Aug 2010 08:54:00 GMT
Python提供一个标准的模块�Q�称为pickle。��用它你可以在一个文件中储存��M��Python对象�Q�之
后你又可以把它完整无�~�地取出来。这被称�?持久�?储存对象�?br>�q�有另一个模块称�?span style="COLOR: red">cPickle�Q�它的功能和pickle模块完全相同�Q�只不过它是用C语言�~�写的，�?br>此要快得多（比pickle�?000�?/span>�Q�。你可以使用它们中的��M��个，而我们在�q�里��用cPickle�?br>块。记住，我们把这两个模块都简�U�Cؓpickle模块�?br>
#!/usr/bin/python
# Filename: pickling.py
import cPickle as p
#import pickle as p
shoplistfile = 'shoplist.data'
# the name of the file where we will store the object
shoplist = ['apple', 'mango', 'carrot']
# Write to the file
f = file(shoplistfile, 'w')
p.dump(shoplist, f) # dump the object to a file
f.close()
del shoplist # remove the shoplist
# Read back from the storage
f = file(shoplistfile)
storedlist = p.load(f)
print storedlist
输出
$ python pickling.py
['apple', 'mango', 'carrot']

它如何工�?/strong>
首先�Q�请注意我们使用了import..as语法。这是一�U�便利方法，以便于我们可以��用更短的模块
名称。在�q�个例子中，它还让我们能够通过��单地改变一行就切换到另一个模块（cPickle或�?br>pickle�Q�！在程序的其余部分的时候，我们��单地把这个模块称为p�?br>��Z��在文仉��储存一个对象，首先以写模式打开一个file对象�Q�然后调用储存器模块的dump�?br>敎ͼ�把对象储存到打开的文件中。这个过�E�称�?储存 �?br>接下来，我们使用pickle模块的load函数的返回来取回对象。这个过�E�称�?取储�?�?

风林 2010-08-31 16:54 发表评论

文�g

风林 — Tue, 31 Aug 2010 08:33:00 GMT
你可以通过创徏一个file�cȝ��对象来打开一个文�Ӟ��分别使用file�cȝ��read、readline或write�Ҏ��?br>恰当地读写文件。对文�g的读写能力依赖于你在打开文�g时指定的模式。最后，当你完成�Ҏ��
件的操作的时候，你调用close�Ҏ��来告诉Python我们完成了对文�g的��用�?br>
#!/usr/bin/python
# Filename: using_file.py
poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Python!
'''
f = file('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file
f = file('poem.txt')
# if no mode is specified, 'r'ead mode is assumed by default
while True:
    line = f.readline()
    if len(line) == 0: # Zero length indicates EOF
        break
    print line,
    # Notice comma to avoid automatic newline added by Python
f.close() # close the file
输出
$ python using_file.py
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Python!

它如何工�?br>首先�Q�我们通过指明我们希望打开的文件和模式来创��Z��个file�cȝ��实例。模式可以�ؓ��L��?br>�Q?r'�Q�、写模式�Q?w'�Q�或�q�加模式�Q?a'�Q�。事实上�q�有多得多的模式可以使用�Q�你可以使用
help(file)来了解它们的详情�?br>我们首先用写模式打开文�g�Q�然后��用file�cȝ��write�Ҏ��来写文�g�Q�最后我们用close关闭�q�个�?br>件�?

风林 2010-08-31 16:33 发表评论

使用�l�承

风林 — Tue, 31 Aug 2010 08:23:00 GMT

#!/usr/bin/python
# Filename: inherit.py
class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print '(Initialized SchoolMember: %s)' % self.name
    def tell(self):
        '''Tell my details.'''
        print 'Name:"%s" Age:"%s"' % (self.name, self.age),
class Teacher(SchoolMember):
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print '(Initialized Teacher: %s)' % self.name
    def tell(self):
        SchoolMember.tell(self)
        print 'Salary: "%d"' % self.salary
class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print '(Initialized Student: %s)' % self.name
    def tell(self):
        SchoolMember.tell(self)
        print 'Marks: "%d"' % self.marks
t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)
print # prints a blank line
members = [t, s]
for member in members:
    member.tell() # works for both Teachers and Students
输出
$ python inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)
Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"

风林 2010-08-31 16:23 发表评论

风林 — Tue, 31 Aug 2010 08:04:00 GMT

#!/usr/bin/python
# Filename: objvar.py
class Person:
    '''Represents a person.'''
    population = 0
    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print '(Initializing %s)' % self.name
        # When this person is created, he/she
        # adds to the population
        Person.population += 1
    def __del__(self):
        '''I am dying.'''
        print '%s says bye.' % self.name
        Person.population -= 1
        if Person.population == 0:
            print 'I am the last one.'
        else:
            print 'There are still %d people left.' % Person.population
    def sayHi(self):
        '''Greeting by the person.
        Really, that's all it does.'''
        print 'Hi, my name is %s.' % self.name
    def howMany(self):
        '''Prints the current population.'''
        if Person.population == 1:
            print 'I am the only person here.'
        else:
            print 'We have %d persons here.' % Person.population
swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()
kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()
swaroop.sayHi()
swaroop.howMany()
输出
$ python objvar.py
(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.

它如何工�?/strong>
�q�是一个很长的例子�Q�但是它有助于说明类与对象的变量的本质。这里，population属于Person
�c�，因此是一个类的变量。name变量属于对象�Q�它使用self赋��|��因此是对象的变量�?br>观察可以发现__init__�Ҏ��用一个名字来初始化Person实例。在�q�个�Ҏ��中，我们让population
增加1�Q�这是因为我们增加了一个�h。同样可以发玎ͼ�self.name的值根据每个对象指定，�q�表
明了它作为对象的变量的本质�?br>��C��Q�你只能使用self变量来参考同一个对象的变量和方法。这被称�?属性参�?�?br>在这个程序中�Q�我们还看到docstring对于�c�d��Ҏ��同样有用。我们可以在�q�行时��用Person.
__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符丌Ӏ?br>��如同__init__�Ҏ��一��P��q�有一个特�D�的�Ҏ��__del__�Q�它在对象消逝的时候被调用。对象消
逝即对象不再被��用，它所占用的内存将�q�回�l�系�l�作它用。在�q�个�Ҏ��里面�Q�我们只是简�?br>地把Person.population�?�?br>当对象不再被使用�Ӟ��__del__�Ҏ��q�行�Q�但是很难保证这个方法究竟在什么时�?�q�行。如�?br>你想要指明它的运行，你就得��用del语句�Q�就如同我们在以前的例子中��用的那样�?br>�l�C++/Java/C#�E�序员的注释
Python中所有的�c�L��员（包括数据成员�Q�都�?公共�?�Q�所有的�Ҏ��都是有效�?�?br>只有一个例外：如果你��用的数据成员名称�?双下划线前缀比如__privatevar�Q�Python的名�U?br>��理体系会有效地把它作�ؓ�U�有变量�?br>�q�样��有一个惯例，如果某个变量只想在类或对象中使用�Q�就应该以单下划�U�前�~�。而其他的
名称都将作�ؓ公共的，可以被其他类/对象使用。记住这只是一个惯例，�q�不是Python所要求
的（与双下划�U�前�~�不同�Q��?br>同样�Q�注意__del__�Ҏ��?destructor 的概�늱�伹{�?

风林 2010-08-31 16:04 发表评论

__init__�Ҏ��

风林 — Tue, 31 Aug 2010 07:39:00 GMT
__init__�Ҏ��在类的一个对象被建立�Ӟ��马上�q�行。这个方法可以用来对你的对象做一些你�?br>望的初始�?。注意，�q�个名称的开始和�l�尾都是双下划线�?br>
#!/usr/bin/python
# Filename: class_init.py
class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print 'Hello, my name is', self.name
p = Person('Swaroop')
p.sayHi()
# This short example can also be written as Person('Swaroop').sayHi()
输出
$ python class_init.py
Hello, my name is Swaroop

它如何工�?br>�q�里�Q�我们把__init__�Ҏ��定义为取一个参数name�Q�以及普通的参数self�Q�。在�q�个__init__里，
我们只是创徏一个新的域�Q�也�U�Cؓname。注意它们是两个不同的变量，��管它们有相同的�?br>字。点号��我们能够区分它们�?br>最重要的是�Q�我们没有专门调用__init__�Ҏ��Q�只是在创徏一个类的新实例的时候，把参数包
括在圆括号内跟在�c�d��后面�Q�从而传递给__init__�Ҏ��。这是这�U�方法的重要之处�?br>现在�Q�我们能够在我们的方法中使用self.name域。这在sayHi�Ҏ��中得��C��验证�?

风林 2010-08-31 15:39 发表评论

风林 — Tue, 31 Aug 2010 07:33:00 GMT

#!/usr/bin/python
# Filename: simplestclass.py
class Person:
    pass # An empty block
p = Person()
print p
输出
$ python simplestclass.py
<__main__.Person instance at 0xf6fcb18c>

我们使用class语句后跟�c�d��Q�创��Z��一个新的类。这后面跟着一个羃�q�的语句块�Ş成类体。在
�q�个例子中，我们使用了一个空白块�Q�它由pass语句表示�?br>接下来，我们使用�c�d��后跟一对圆括号来创��Z��个对�?实例。�ؓ了验证，我们��单地打印了这
个变量的�c�d��。它告诉我们我们已经在__main__模块中有了一个Person�cȝ��实例�?br>可以注意到存储对象的计算机内存地址也打��C��出来。这个地址在你的计��机上会是另外一�?br>��|��因�ؓPython可以在�Q何空位存储对象�?

风林 2010-08-31 15:33 发表评论

字符串的�Ҏ��

风林 — Tue, 31 Aug 2010 06:22:00 GMT

#!/usr/bin/python
# Filename: str_methods.py
name = 'Swaroop' # This is a string object
if name.startswith('Swa'):
    print 'Yes, the string starts with "Swa"'
if 'a' in name:
    print 'Yes, it contains the string "a"'
if name.find('war') != -1:
    print 'Yes, it contains the string "war"'
delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)
输出
$ python str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

它如何工�?/strong>
�q�里�Q�我们看��C��用了许多字符串方法�?span style="COLOR: red">startwith�Ҏ��是用来测试字�W�串是否以给定字�W�串开
始�?span style="COLOR: red">in操作�W�用来检验一个给定字�W�串是否为另一个字�W�串的一部分�?br>find�Ҏ��用来扑և��l�定字符串在另一个字�W�串中的位置�Q�或者返�?1以表�C�找不到子字�W�串�?br>str�c�M��有以一个作为分隔符的字�W�串join序列的项目的整洁的方法，它返回一个生成的大字�W?br>丌Ӏ?

风林 2010-08-31 14:22 发表评论

引用

风林 — Tue, 31 Aug 2010 06:14:00 GMT
当你创徏一个对象�ƈ�l�它赋一个变量的时候，�q�个变量仅仅引用那个对象�Q�而不是表�C��?br>对象本��n�Q�也��是��_��变量名指向你计算��Z��存储那个对象的内存。这被称作名�U�到对象的绑
定�?br>
#!/usr/bin/python
# Filename: reference.py
print 'Simple Assignment'
shoplist = ['apple', 'mango', 'carrot', 'banana']
mylist = shoplist # mylist is just another name pointing to the same object!
del shoplist[0]
print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that both shoplist and mylist both print the same list without
# the 'apple' confirming that they point to the same object
print 'Copy by making a full slice'
mylist = shoplist[:] # make a copy by doing a full slice
del mylist[0] # remove first item
print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that now the two lists are different
输出
$ python reference.py
Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana']

你需要记住的只是如果你想要复制一个列表或者类似的�?br>列或者其他复杂的对象�Q�不是如整数那样的简�?对象 �Q�，那么你必��M��用切片操作符来取�?br>拯��。如果你只是惌��使用另一个变量名�Q�两个名�U�都引用同一个对象，那么如果你不��心
的话�Q�可能会引来各种�ȝ��?

风林 2010-08-31 14:14 发表评论

序列

风林 — Tue, 31 Aug 2010 03:41:00 GMT
列表、元�l�和字符串都是序列，但是序列是什么，它们��Z��么如此特别呢�Q�序列的两个主要�?br>�Ҏ��索引操作�W�和切片操作�W�。烦引操作符让我们可以从序列中抓取一个特定项目。切片操�?br>�W�让我们能够获取序列的一个切片，即一部分序列�?br>
#!/usr/bin/python
# Filename: seq.py
shoplist = ['apple', 'mango', 'carrot', 'banana']
# Indexing or 'Subscription' operation
print 'Item 0 is', shoplist[0]
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1]
print 'Item -2 is', shoplist[-2]
# Slicing on a list
print 'Item 1 to 3 is', shoplist[1:3]
print 'Item 2 to end is', shoplist[2:]
print 'Item 1 to -1 is', shoplist[1:-1]
print 'Item start to end is', shoplist[:]
# Slicing on a string
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]
输出
$ python seq.py
Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop

它如何工�?/strong>
首先�Q�我们来学习如何使用索引来取得序列中的单个项目。这也被�U�C��是下标操作。每当你�?br>�Ҏ��号中的一个数来指定一个序列的时候，Python会�ؓ你抓取序列中对应位置的项目。记住，
Python�?开始计数。因此，shoplist[0]抓取�W�一个项目，shoplist[3]抓取shoplist序列中的�W�四�?br>元素�?br>索引同样可以是负敎ͼ�在那��L��情况下，位置是从序列��ּ�始计��的�?/span>因此�Q�shoplist[-1]表示
序列的最后一个元素而shoplist[-2]抓取序列的倒数�W�二个项目�?br>切片操作�W�是序列名后跟一个方括号�Q�方括号中有一对可选的数字�Q��ƈ用冒号分剌Ӏ�注意这�?br>你��用的索引操作�W�十分相伹{�?span style="COLOR: red">��C��数是可选的�Q�而冒��h��必须的�?/span>
切片操作�W�中的第一个数�Q�冒号之前）表示切片开始的位置�Q�第二个敎ͼ�冒号之后�Q�表�C�切�?br>到哪里结束。如果不指定�W�一个数�Q�Python��׃��序列首开始。如果没有指定第二个敎ͼ��?br>Python会停止在序列��。注意，�q�回的序列从开始位�|?开�?�Q�刚好在 �l�束位置之前�l�束。即
开始位�|�是包含在序列切片中的，而结束位�|�被排斥在切片外�?br>�q�样�Q�shoplist[1:3]�q�回从位�|?开始，包括位置2�Q�但是停止在位置3的一个序列切片，因此�q?br>回一个含有两个项目的切片。类似地�Q�shoplist[:]�q�回整个序列的拷贝�?br>你可以用负数做切片。负数用在从序列��ּ�始计��的位置。例如，shoplist[:-1]会返回除了最�?br>一个项目外包含所有项目的序列切片�?br>使用Python解释器交互地��试不同切片指定�l�合�Q�即在提�C�符下你能够马上看到�l�果。序列的
��奇之处在于你可以用相同的方法访问元�l�、列表和字符丌Ӏ?

风林 2010-08-31 11:41 发表评论

字典

风林 — Tue, 31 Aug 2010 03:26:00 GMT
字典�c�M��于你通过联系人名字查扑֜�址和联�p�M�h详细情况的地址��，卻I��我们把键�Q�名字）�?br>��|��详细情况�Q�联�p�d��一赗��注意，键必��L��唯一的，��像如果有两个�h恰��y同名的话�Q�你�?br>法找到正��的信息�?br>注意�Q�你只能使用不可变的对象�Q�比如字�W�串�Q�来作�ؓ字典的键�Q�但是你可以把不可变或可�?br>的对象作为字典的倹{��基本说来就是，你应该只使用��单的对象作�ؓ键�?br>键值对在字�怸�以这��L��方式标记�Q�d = {key1 : value1, key2 : value2 }。注意它们的�?值对用冒
号分�Ԍ��而各个对用逗号分割�Q�所有这些都包括在花括号中�?br>��C��字典中的�?值对是没有顺序的。如果你惌��一个特定的��序�Q�那么你应该在��用前自己
对它们排序�?br>字典是dict�cȝ��实例/对象�?br>

#!/usr/bin/python
# Filename: using_dict.py
# 'ab' is short for 'a'ddress'b'ook
ab = {       'Swaroop'   : 'swaroopch@byteofpython.info',
             'Larry'     : 'larry@wall.org',
             'Matsumoto' : 'matz@ruby-lang.org',
             'Spammer'   : 'spammer@hotmail.com'
     }
print "Swaroop's address is %s" % ab['Swaroop']
# Adding a key/value pair
ab['Guido'] = 'guido@python.org'
# Deleting a key/value pair
del ab['Spammer']
print '\nThere are %d contacts in the address-book\n' % len(ab)
for name, address in ab.items():
    print 'Contact %s at %s' % (name, address)
if 'Guido' in ab: # OR ab.has_key('Guido')
    print "\nGuido's address is %s" % ab['Guido']
输出
$ python using_dict.py
Swaroop's address is swaroopch@byteofpython.info
There are 4 contacts in the address-book
Contact Swaroop at swaroopch@byteofpython.info
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org
Contact Guido at guido@python.org
Guido's address is guido@python.org

风林 2010-08-31 11:26 发表评论

元组

风林 — Tue, 31 Aug 2010 03:09:00 GMT
元组和列表十分类��|��只不�q�元�l�和字符串一��h�� 不可变的即你不能修改元组。元�l�通过�?br>括号中用逗号分割的项目定义。元�l�通常用在使语句或用户定义的函数能够安全地采用一�l��?br>的时候，卌��使用的元�l�的��g��会改变�?br>

#!/usr/bin/python
# Filename: using_tuple.py
zoo = ('wolf', 'elephant', 'penguin')
print 'Number of animals in the zoo is', len(zoo)
new_zoo = ('monkey', 'dolphin', zoo)
print 'Number of animals in the new zoo is', len(new_zoo)
print 'All animals in new zoo are', new_zoo
print 'Animals brought from old zoo are', new_zoo[2]
print 'Last animal brought from old zoo is', new_zoo[2][2]
输出
$ python using_tuple.py
Number of animals in the zoo is 3
Number of animals in the new zoo is 3
All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))
Animals brought from old zoo are ('wolf', 'elephant', 'penguin')
Last animal brought from old zoo is penguin

含有0个或1个项目的元组。一个空的元�l�由一对空的圆括号�l�成�Q�如myempty = ()。然而，�?br>有单个元素的元组��׃��那么��单了。你必须在第一个（唯一一个）��目后跟一个逗号�Q�这�?br>Python才能区分元组和表辑ּ�中一个带圆括��L��对象。即如果你想要的是一个包含项�?的元
�l�的时候，你应该指明singleton = (2 , )�?br>
元组与打印语�?br>
#!/usr/bin/python
# Filename: print_tuple.py
age = 22
name = 'Swaroop'
print '%s is %d years old' % (name, age)
print 'Why is %s playing with that python?' % name

输出
$ python print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?

风林 2010-08-31 11:09 发表评论

列表

风林 — Tue, 31 Aug 2010 02:54:00 GMT
list是处理一�l�有序项目的数据�l�构�Q�即你可以在一个列表中存储一�?序列的项目。假想你�?br>一个购物列表，上面记蝲着你要买的东西�Q�你��容易理解列表了。只不过在你的购物表上，�?br>能每样东襉K��独自占有一行，而在Python中，你在每个��目之间用逗号分割�?br>列表中的��目应该包括在方括号中，�q�样Python��q��道你是在指明一个列表。一旦你创徏了一
个列表，你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目，我们说列�?br>�?可变�?数据�c�d��Q�即�q�种�c�d��是可以被改变的�?br>

#!/usr/bin/python
# Filename: using_list.py
# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']
print 'I have', len(shoplist),'items to purchase.'
print 'These items are:', # Notice the comma at end of the line
for item in shoplist:
    print item,
print '\nI also have to buy rice.'
shoplist.append('rice')
print 'My shopping list is now', shoplist
print 'I will sort my list now'
shoplist.sort()
print 'Sorted shopping list is', shoplist

print 'The first item I will buy is', shoplist[0]
olditem = shoplist[0]
del shoplist[0]
print 'I bought the', olditem
print 'My shopping list is now', shoplist
输出
$ python using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

注意�Q�我们在print语句的结��用了一�?逗号来消除每个print语句自动打印的换行符。这�?br>做有炚w��看，不过��实��单有效�?/span>

风林 2010-08-31 10:54 发表评论

数据�l�构

风林 — Tue, 31 Aug 2010 02:38:00 GMT
数据�l�构基本上就是——它们是可以处理一�?数据 �?�l�构。或者说�Q�它们是用来存储一�l�相��x��据的�?br>在Python中有三种内徏的数据结构——列表、元�l�和字典�?

风林 2010-08-31 10:38 发表评论

dir()函数

风林 — Tue, 31 Aug 2010 02:36:00 GMT
你可以��用内建的dir函数来列出模块定义的标识�W�。标识符有函数、类和变量�?br>当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数�Q�它�q�回�?br>前模块中定义的名�U�列表�?br>
$ python
>>> import sys
>>> dir(sys) # get list of attributes for sys module
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',
'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',
'copyright', 'displayhook', 'exc_clear', 'exc_info', 'exc_type',
'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval',
'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding',
'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',
'meta_path','modules', 'path', 'path_hooks', 'path_importer_cache',
'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags',
'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',
'version', 'version_info', 'warnoptions']
>>> dir() # get list of attributes for current module
['__builtins__', '__doc__', '__name__', 'sys']
>>>
>>> a = 5 # create a new variable 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # delete/remove a name
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']

风林 2010-08-31 10:36 发表评论

create module and call module

风林 — Tue, 31 Aug 2010 02:31:00 GMT

#!/usr/bin/python
# Filename: mymodule.py
def sayhi():
    print 'Hi, this is mymodule speaking.'
version = '0.1'
# End of mymodule.py
��C��q�个模块应该被放�|�在我们输入它的�E�序的同一个目录中�Q�或者在sys.path所列目录之一�?br>
#!/usr/bin/python
# Filename: mymodule_demo.py
import mymodule
mymodule.sayhi()
print 'Version', mymodule.version
输出
$ python mymodule_demo.py
Hi, this is mymodule speaking.
Version 0.1

下面是一个��用from..import语法的版本�?/strong>

#!/usr/bin/python
# Filename: mymodule_demo2.py
from mymodule import sayhi, version
# Alternative:
# from mymodule import *
sayhi()
print 'Version', version

风林 2010-08-31 10:31 发表评论