C++博客-fenglin-文章分类-Python

django框架安装与配置

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

django是一个开源框架项目，详情请见官网http://www.djangoproject.com

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

学python两天半时间写的成果

风林 — 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函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。注
意，在大多数时候有eval(repr(object)) == object。
>>> i = []
>>> i.append('item')
>>> `i`
"['item']"
>>> repr(i)
"['item']"

基本上，repr函数和反引号用来获取对象的可打印的表示形式。你可以通过定义类的__repr__
方法来控制你的对象在被repr函数调用的时候返回的内容。

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

assert语句

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

assert语句用来声明某个条件是真的。
例如，如果你非常确信某个你使用的列表中至少有一个
元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert语句是应用在这
种情形下的理想语句。当assert语句失败的时候，会引发一个AssertionError。
>>> 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语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包
含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子。
>>> exec 'print "Hello World"'
Hello World

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

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

lambda形式

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

lambda语句被用来创建新的函数对象，并且在运行时返回它们。

#!/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

它如何工作
这里，我们使用了make_repeater函数在运行时创建新的函数对象，并且返回它。lambda语句用
来创建函数对象。本质上，lambda需要一个参数，后面仅跟单个表达式作为函数体，而表达式
的值被这个新建的函数返回。注意，即便是print语句也不能用在lambda形式中，只能使用表达
式。

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

在函数中接收元组和列表

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

当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。
这种方法在函数需要获取可变数量的参数的时候特别有用。
>>> 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变量前有*前缀，所有多余的函数参数都会作为一个元组存储在args中。如果使用的
是**前缀，多余的参数则会被认为是一个字典的键/值对。

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

使用列表综合

风林 — 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]

它如何工作
这里我们为满足条件（if i > 2）的数指定了一个操作（2*i），从而导出一个新的列表。注意原
来的列表并没有发生变化。在很多时候，我们都是使用循环来处理列表中的每一个元素，而使
用列表综合可以用一种更加精确、简洁、清楚的方法完成相同的工作。

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

vim快捷键总图

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

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

特殊的方法

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

表15.1 一些特殊的方法
名称说明
__init__(self,...) 这个方法在新建对象恰好要被返回使用之前被调用。
__del__(self) 恰好在对象要被删除之前调用。
__str__(self) 在我们对对象使用print语句或是使用str()的时候调用。
__lt__(self,other)当使用小于运算符（<）的时候调用。类似地，对于所有的运算符
（+，>等等）都有特殊的方法。
__getitem__(self,key)使用x[key]索引操作符的时候调用。
__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

这个模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话，这个模块是尤
为重要的。即它允许一个程序在编写后不需要任何改动，也不会发生任何问题，就可以在
Linux和Windows下运行。一个例子就是使用os.sep可以取代操作系统特定的路径分割符。
下面列出了一些在os模块中比较有用的部分。它们中的大多数都简单明了。
●     os.name字符串指示你正在使用的平台。比如对于Windows，它是'nt'，而对于Linux/Unix
用户，它是'posix'。
●     os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径。
●     os.getenv()和os.putenv()函数分别用来读取和设置环境变量。
●     os.listdir()返回指定目录下的所有文件和目录名。
●     os.remove()函数用来删除一个文件。
●     os.system()函数用来运行shell命令。
●     os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使
用'\n'而Mac使用'\r'。
●     os.path.split()函数返回一个路径的目录名和文件名。
>>> os.path.split('/home/swaroop/byte/code/poem.txt')
('/home/swaroop/byte/code', 'poem.txt')
●     os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。类似地，os.
path.exists()函数用来检验给出的路径是否真地存在。

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

try..finally

风林 — Tue, 31 Aug 2010 09:19:00 GMT

假如你在读一个文件的时候，希望在无论异常发生与否的情况下都关闭文件，该怎么做呢？这
可以使用finally块来完成。注意，在一个try块下，你可以同时使用except从句和finally块。如果
你要同时使用它们的话，需要把一个嵌入另外一个。

#!/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

它如何工作
我们进行通常的读文件工作，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样
做的原因是让程序运行得慢一些（Python由于其本质通常运行得很快）。在程序运行的时候，
按Ctrl-c中断/取消程序。
我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍
然被执行，把文件关闭

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

raise 引发异常

风林 — Tue, 31 Aug 2010 09:12:00 GMT

你可以使用raise语句引发异常。你还得指明错误/异常的名称和伴随异常触发的异常对象。你
可以引发的错误或异常应该分别是一个Error或Exception类的直接或间接导出类。

#!/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.

它如何工作
这里，我们创建了我们自己的异常类型，其实我们可以使用任何预定义的异常/错误。这个新
的异常类型是ShortInputException类。它有两个域——length是给定输入的长度，atleast则是程序
期望的最小长度。
在except从句中，我们提供了错误类和用来表示错误/异常对象的变量。这与函数调用中的形参
和实参概念类似。在这个特别的except从句中，我们使用异常对象的length和atleast域来为用户
打印一个恰当的消息。

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

处理异常

风林 — Tue, 31 Aug 2010 09:03:00 GMT

我们可以使用try..except语句来处理异常。我们把通常的语句放在try-块中，而把我们的错误处
理语句放在except-块中。

#!/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

它如何工作
我们把所有可能引发错误的语句放在try块中，然后在except从句/块中处理所有的错误和异常。
except从句可以专门处理单一的错误或异常，或者一组包括在圆括号内的错误/异常。如果没有
给出错误或异常的名称，它会处理所有的错误和异常。对于每个try从句，至少都有一个相关
联的except从句。
如果某个错误或异常没有被处理，默认的Python处理器就会被调用。它会终止程序的运行，并
且打印一个消息，我们已经看到了这样的处理。

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

储存器

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

Python提供一个标准的模块，称为pickle。使用它你可以在一个文件中储存任何Python对象，之
后你又可以把它完整无缺地取出来。这被称为持久地储存对象。
还有另一个模块称为cPickle，它的功能和pickle模块完全相同，只不过它是用C语言编写的，因
此要快得多（比pickle快1000倍）。你可以使用它们中的任一个，而我们在这里将使用cPickle模
块。记住，我们把这两个模块都简称为pickle模块。

#!/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']

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

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

文件

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

你可以通过创建一个file类的对象来打开一个文件，分别使用file类的read、readline或write方法来
恰当地读写文件。对文件的读写能力依赖于你在打开文件时指定的模式。最后，当你完成对文
件的操作的时候，你调用close方法来告诉Python我们完成了对文件的使用。

#!/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!

它如何工作
首先，我们通过指明我们希望打开的文件和模式来创建一个file类的实例。模式可以为读模式
（'r'）、写模式（'w'）或追加模式（'a'）。事实上还有多得多的模式可以使用，你可以使用
help(file)来了解它们的详情。
我们首先用写模式打开文件，然后使用file类的write方法来写文件，最后我们用close关闭这个文
件。

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

使用继承

风林 — 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.

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

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

init方法

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

__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希
望的初始化。注意，这个名称的开始和结尾都是双下划线。

#!/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

它如何工作
这里，我们把__init__方法定义为取一个参数name（以及普通的参数self）。在这个__init__里，
我们只是创建一个新的域，也称为name。注意它们是两个不同的变量，尽管它们有相同的名
字。点号使我们能够区分它们。
最重要的是，我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包
括在圆括号内跟在类名后面，从而传递给__init__方法。这是这种方法的重要之处。
现在，我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。

风林 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语句后跟类名，创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在
这个例子中，我们使用了一个空白块，它由pass语句表示。
接下来，我们使用类名后跟一对圆括号来创建一个对象/实例。为了验证，我们简单地打印了这
个变量的类型。它告诉我们我们已经在__main__模块中有了一个Person类的实例。
可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个
值，因为Python可以在任何空位存储对象。

风林 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

它如何工作
这里，我们看到使用了许多字符串方法。startwith方法是用来测试字符串是否以给定字符串开
始。in操作符用来检验一个给定字符串是否为另一个字符串的一部分。
find方法用来找出给定字符串在另一个字符串中的位置，或者返回-1以表示找不到子字符串。
str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法，它返回一个生成的大字符
串。

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

引用

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

当你创建一个对象并给它赋一个变量的时候，这个变量仅仅引用那个对象，而不是表示这个
对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑
定。

#!/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']

你需要记住的只是如果你想要复制一个列表或者类似的序
列或者其他复杂的对象（不是如整数那样的简单对象），那么你必须使用切片操作符来取得
拷贝。如果你只是想要使用另一个变量名，两个名称都引用同一个对象，那么如果你不小心
的话，可能会引来各种麻烦。

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

序列

风林 — Tue, 31 Aug 2010 03:41:00 GMT

列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特
点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作
符让我们能够获取序列的一个切片，即一部分序列。

#!/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

它如何工作
首先，我们来学习如何使用索引来取得序列中的单个项目。这也被称作是下标操作。每当你用
方括号中的一个数来指定一个序列的时候，Python会为你抓取序列中对应位置的项目。记住，
Python从0开始计数。因此，shoplist[0]抓取第一个项目，shoplist[3]抓取shoplist序列中的第四个
元素。
索引同样可以是负数，在那样的情况下，位置是从序列尾开始计算的。因此，shoplist[-1]表示
序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。
切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。注意这与
你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。
切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片
到哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则
Python会停止在序列尾。注意，返回的序列从开始位置开始，刚好在结束位置之前结束。即
开始位置是包含在序列切片中的，而结束位置被排斥在切片外。
这样，shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返
回一个含有两个项目的切片。类似地，shoplist[:]返回整个序列的拷贝。
你可以用负数做切片。负数用在从序列尾开始计算的位置。例如，shoplist[:-1]会返回除了最后
一个项目外包含所有项目的序列切片。
使用Python解释器交互地尝试不同切片指定组合，即在提示符下你能够马上看到结果。序列的
神奇之处在于你可以用相同的方法访问元组、列表和字符串。

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

字典

风林 — Tue, 31 Aug 2010 03:26:00 GMT

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和
值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无
法找到正确的信息。
注意，你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变
的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒
号分割，而各个对用逗号分割，所有这些都包括在花括号中。
记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己
对它们排序。
字典是dict类的实例/对象。

#!/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

元组和列表十分类似，只不过元组和字符串一样是不可变的即你不能修改元组。元组通过圆
括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值
的时候，即被使用的元组的值不会改变。

#!/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个项目的元组。一个空的元组由一对空的圆括号组成，如myempty = ()。然而，含
有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样
Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元
组的时候，你应该指明singleton = (2 , )。

元组与打印语句

#!/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是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。假想你有
一个购物列表，上面记载着你要买的东西，你就容易理解列表了。只不过在你的购物表上，可
能每样东西都独自占有一行，而在Python中，你在每个项目之间用逗号分割。
列表中的项目应该包括在方括号中，这样Python就知道你是在指明一个列表。一旦你创建了一
个列表，你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目，我们说列表
是可变的数据类型，即这种类型是可以被改变的。

#!/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']

注意，我们在print语句的结尾使用了一个逗号来消除每个print语句自动打印的换行符。这样
做有点难看，不过确实简单有效。

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

数据结构

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

数据结构基本上就是——它们是可以处理一些数据的结构。或者说，它们是用来存储一组相关数据的。
在Python中有三种内建的数据结构——列表、元组和字典。

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

dir()函数

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

你可以使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当
前模块中定义的名称列表。

$ 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

记住这个模块应该被放置在我们输入它的程序的同一个目录中，或者在sys.path所列目录之一。

#!/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语法的版本。

#!/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 发表评论