创建实例
 
1、首先创建和实例名一样的用户及该用户所属的组
 (注意实例名不能超过8个字符)
 groupadd db2icomm
 groupadd db2fcomm
 useradd -g db2icomm -m -d /home/db2icomm db2icomm
 useradd -g db2fcomm -m -d /home/db2fcomm db2fcomm
 passwd db2icomm 
 密码跟帐号一样
 passwd db2fcomm 
 密码跟帐号一样
 
 
 2、
 /opt/ibm/db2/V9.7/instance/db2icrt -a server -u db2fcomm db2icomm 
 
 
 可以通过db2_ps或ps -ef|grep -i INSTANCE查看DB2进程的状态
 3、
 当配置DB2的运行环境：成功创建实例后，检查实例目录下的.profile是否调用db2profile
 .profile中是否有：
 # The following three lines have been added by IBM DB2 instance utilities.
 if [ -f /home/db2icomm/sqllib/db2profile ]; then
     . /home/db2icomm/sqllib/db2profile
 fi
 
 
 4、
 db2icrt 创建的实例设置为手动启动
 允许实例在每次系统重新启动后自动启动 
 db2icomm@emal:~> db2iauto -on db2icomm
 阻止实例在每次系统重新启动后自动启动
 db2iauto -off db2icomm
 
 
 5、
 启动实例
 db2icomm@emal:~> db2start
 09/10/2014 20:14:44     0   0   SQL1063N  DB2START processing was successful.
 SQL1063N  DB2START processing was successful.
 
 
 停止实例
 db2stop
 
 
 6、
 查看当前在哪个实例下
 db2icomm@emal:~/Desktop> echo $DB2INSTANCE
 db2icomm
 或者
 db2icomm@emal:~/Desktop> db2 get instance
  The current database manager instance is:  db2icomm
 
 
 7、
 为了对实例变量提供tcp/ip协议的支持，输入如下命令设置DB2COMM变量
 db2set DB2COMM=TCPIP -i db2icomm
 
 
 db2 get dbm cfg | grep SVCENAME 检查配置 SVCENAME 的值，如果 SVCENAME为空值，则需要用下面的步骤设定该值，如果是一个端口号 ( 端口号应小于 65536)，则不用读取/etc/services文件中的端口定义，如果该值是一个字符串（如：db2c_db2inst1），则在实例启动时会自动读取/etc/services 中的该字符串对应的端口号来监听。
 # db2  update database manager configuration using svcename db2c_db2inst1（或者为端口号如：50001） --我们也可以通过这种方式修改DB2监听的端口号.
  db2  update database manager configuration using svcename 50002
 
 
 
 
 
 
 DBI1001I  Usage:
 
 
  db2icrt [-h|-?]
          [-d]
          [-a AuthType]
          [-p PortName]
          [-s InstType]
          -u FencedID InstName
 
 
 Explanation: 
 
 
 An invalid argument was entered for the db2icrt command. Valid arguments
 for this command are: 
 
 
 -h|-?    display the usage information.
 
 
 -d       turn debug mode on.
 
 
 -a AuthType
          is the authentication type (SERVER, CLIENT, or SERVER_ENCRYPT)
          for the instance.
 
 
 -p PortName
          is the port name or port number to be used by this instance.
 
 
 -s       InstType is the type of instance to be created (ese,wse,
          standalone, or client). 
 
 
          ese      used to create an instance for a DB2 database server
                   with local and remote clients with DPF support. This
                   type is the default instance type for DB2 Enterprise
                   Server Edition.
 
 
          wse      used to create an instance for a DB2 database server
                   with local and remote clients. This type is the
                   default instance type for DB2 Workgroup Edition, DB2
                   Express or Express-C Edition, and DB2 Connect
                   Enterprise Edition.
 
 
          standalone
                   used to create an instance for a DB2 database server
                   with local clients. This type is the default instance
                   type for DB2 Personal Edition.
 
 
          client   used to create an instance for a IBM Data Server
                   Client. This type is the default instance type for IBM
                   Data Server Client products and DB2 Connect Personal
                   Edition.
 
 
           
 
 
          DB2 products support their default instance types and the
          instance types lower than their default ones. For instance, DB2
          Enterprise Edition supports the instance types of 'ese', 'wse',
          'standalone' and 'client'.
 
 
 
 
 -u FencedID
          is the name of the user under which fenced UDFs and fenced
          stored procedures will be run. This flag is not required if
          only a IBM Data Server Client is installed.
 
 
 InstName is the name of the instance.
 
 
 User response: 
 
 
 Confirm that user IDs and group names used to create the DB2 instance
 are valid. For information about naming rules, see the topic called
 "User, user ID and group naming rules" in the DB2 Information Center.
 
 
 Refer to the DB2 Information Center for a detailed description of the
 command. Correct the syntax and reissue the command.
 
 
========================================================================================================
 
创建数据库
 
创建数据库
 
 
 数据库是从 DB2 命令界面创建的。在启动命令界面之前，必须符合以下条件：
 
 
 DB2 必须是活动的。
 对于 AIX、Linux 和 Solaris, DB2 实例拥有者标识（例如 db2icomm）必须是 db2iadm 组的一部分。db2iadm 组是在 DB2 通用数据库安装过程中创建的。
 在 DB2 命令界面，输入以下命令来创建数据库：
 
 
 db2 create database db_name alias alias_name using codeset UTF-8 territory US
 
 
 db_name
 指定给数据库的名称。
 alias_name
 数据库别名。如没有提供别名，则将使用指定的数据库名称。
 注:
 别名不是必需要的；然而，如果使用了别名，则它必须与数据库名称相同。
 
 
 从 DB2 命令行处理器输入下列命令来创建 DB2 数据库：
 db2icomm@emal:~> db2 create database db_shop using codeset UTF-8 territory CN
 DB20000I  The CREATE DATABASE command completed successfully.
 
 
 
 
 从 DB2 命令行处理器输入下列命令来创建其它数据库结构
 db2 connect to db_shop user db2icomm using db2icomm
 db2 create bufferpool <BufferPoolName> size 250 pagesize 32K
 db2 create bufferpool bp_8k size 250 pagesize 8K
 db2 connect reset
 db2 terminate
 db2 force application all
 db2 terminate
 db2stop
 db2start
 
 
 从 DB2 命令行处理器输入下列命令，创建其它数据库结构：
 db2 connect to <DataBaseName> user <DB2UserID> using <DB2Password>
 db2 connect to db_shop user db2icomm using db2icomm
 db2 create regular tablespace uddits pagesize 32K managed by system using ('<TableSpaceName>') extentsize 64 prefetchsize 32 bufferpool <BufferPoolName>
 db2 "CREATE REGULAR TABLESPACE TS_SMS_8K  PAGESIZE 8 K MANAGED BY SYSTEM USING ('TS_SMS_8K')  BUFFERPOOL BP_8K"
 db2 create system temporary tablespace <TempTableSpacename> pagesize 32 K managed by system using ('<TempTableSpacename>') extentsize 32 overhead 14.06 prefetchsize 32 transferrate 0.33 bufferpool <BufferPoolName>
 db2 "create system temporary tablespace TTS_SMS_8K pagesize 8 K managed by system using  ('TTS_SMS_8K')   bufferpool BP_8K"
 
 
 db2 "CREATE REGULAR TABLESPACE TS_DMS_8K  PAGESIZE 8 K MANAGED BY DATABASE USING (FILE 'TS_DMS_8K' 200000)  BUFFERPOOL BP_8K"
 db2 "create regular tablespace IDX_DMS_8K pagesize 8 K managed by DATABASE using  (FILE 'IDX_DMS_8K' 10000)   bufferpool BP_8K"
 
 
 如果要删表空间
 db2 drop tablespace TS_DMS_8K,IDX_DMS_8K
 
 
 db2 "DISCONNECT db_shop"
 db2 "TERMINATE"
 
 
 db2 connection service port 
  /etc/services
 
 
创建表
 
db2 "create table tb_superType(id int not null generated always as identity(start with 1,increment by 1),TypeName varchar(50),primary key(id)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_subType(id int not null generated always as identity(start with 1,increment by 1),superType int,TypeName varchar(50),primary key(id))  in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_rebate(grade varchar(20) not null,Amount decimal(10,2),rebate float,primary key(grade)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_order_detail(id bigint not null generated always as identity(start with 1,increment by 1),orderID bigint,goodsID bigint,price decimal(10,2),number int,primary key(id)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_order(OrderID bigint not null generated always as identity(start with 1,increment by 1),bnumber smallint,username varchar(15),Truename varchar(15),address varchar(100),postcode varchar(10),tel varchar(10),pay varchar(20),carry varchar(20),rebate float,OrderDate date,enforce int,bz varchar(200),primary key(OrderID)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_member(id int not null generated always as identity(start with 1,increment by 1),userName varchar(20),trueName varchar(20),passWord varchar(20),city varchar(20),address varchar(100),postcode varchar(6),cardNO varchar(24),cardType varchar(20),grade int,Amount decimal(10,2),tel varchar(20),email varchar(100),freeze int,primary key(id))in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_manager(id int not null generated always as identity(start with 1,increment by 1),manager varchar(30),PWD varchar(30),primary key(id)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_goods(id bigint not null generated always as identity(start with 1,increment by 1),typeID int,goodsName varchar(200),introduce CLOB(2097152),price decimal(10,2),nowPrice decimal(10,2),picture varchar(100),INTime timestamp,newGoods int,sale int,hit int,primary key(id)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 db2 "create table tb_BBS(id int not null generated always as identity(start with 1,increment by 1),title varchar(100),content varchar(4000),TNTime timestamp ,primary key(id)) in TS_DMS_8K index in IDX_DMS_8K"
 
 
 
 
 
 
 

1、打开命令窗口：
 
 
 
 
db2ilist  ---列出主机所有实例

db2icrt  instanceName   ---创建实例名为instanceName的实例

db2idrop  instanceName   ---删除实例名为instanceName的实例
 
 

db2ilist  ---列出主机所有实例
 
db2icrt  instanceName   ---创建实例名为instanceName的实例
 
db2idrop  instanceName   ---删除实例名为instanceName的实例
 
 

 
 
一、       Python面向对象编程
 
 
二、       python之定义类并创建实例
 
 
三、 在Python中，类通过 class 关键字定义。以 Person 为例，定义一个Person类如下：
 
 
 
四、 class Person(object):
 
 
五、     pass
 
 
六、 按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的。类的继承将在后面的章节讲解，现在我们只需要简单地从object类继承。
 
七、 有了Person类的定义，就可以创建出具体的xiaoming、xiaohong等实例。创建实例使用 类名+()，类似函数调用的形式创建：
 
 
 
八、 xiaoming = Person()
 
 
九、 xiaohong = Person()
 
 
十、       任务
 
十一、       请练习定义Person类，并创建出两个实例，打印实例，再比较两个实例是否相等。
 
class Person(object):
 
   pass
 
 
 
xiaoming = Person()
 
xiaohong = Person()
 
 
 
print xiaoming
 
print xiaohong
 
print xiaoming==xiaohong
 
 
 
 
 
 
 
三、python中创建实例属性
 
 
虽然可以通过Person类创建出xiaoming、xiaohong等实例，但是这些实例看上除了地址不同外，没有什么其他不同。在现实世界中，区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。
 
如何让每个实例拥有各自不同的属性？由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值，例如，给xiaoming这个实例加上name、gender和birth属性：
 
 
 
xiaoming = Person()
 
 
xiaoming.name = 'Xiao Ming'
 
 
xiaoming.gender = 'Male'
 
 
xiaoming.birth = '1990-1-1'
 
 
给xiaohong加上的属性不一定要和xiaoming相同：
 
 
 
xiaohong = Person()
 
 
xiaohong.name = 'Xiao Hong'
 
 
xiaohong.school = 'No. 1 High School'
 
 
xiaohong.grade = 2
 
 
实例的属性可以像普通变量一样进行操作：
 
 
 
xiaohong.grade = xiaohong.grade + 1
 
 
任务
 
请创建包含两个 Person 类的实例的 list，并给两个实例的 name 赋值，然后按照 name 进行排序。
 
class Person(object):
 
   pass
 
p1 = Person()
 
p1.name = 'Bart'
 
 
 
p2 = Person()
 
p2.name = 'Adam'
 
 
 
p3 = Person()
 
p3.name = 'Lisa'
 
 
 
L1 = [p1, p2, p3]
 
L2 = sorted(L1, lambda p1, p2: cmp(p1.name,p2.name))
 
 
 
print L2[0].name
 
print L2[1].name
 
print L2[2].name
 
 
 
 
 
 
 
四、python中初始化实例属性
 
 
虽然我们可以自由地给一个实例绑定各种属性，但是，现实世界中，一种类型的实例应该拥有相同名字的属性。例如，Person类应该在创建的时候就拥有 name、gender 和 birth 属性，怎么办？
 
在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：
 
 
 
class Person(object):
 
 
    def __init__(self, name, gender, birth):
 
 
        self.name = name
 
 
        self.gender = gender
 
 
        self.birth = birth
 
 
__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。
 
相应地，创建实例时，就必须要提供除 self 以外的参数：
 
 
 
xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
 
 
xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')
 
 
有了__init__()方法，每个Person实例在创建时，都会有 name、gender 和 birth 这3个属性，并且，被赋予不同的属性值，访问属性使用.操作符：
 
 
 
print xiaoming.name
 
 
# 输出 'Xiao Ming'
 
 
print xiaohong.birth
 
 
# 输出 '1992-2-2'
 
 
要特别注意的是，初学者定义__init__()方法常常忘记了 self 参数：
 
 
 
>>> class Person(object):
 
 
...     def __init__(name, gender, birth):
 
 
...         pass
 
 
... 
 
 
>>> xiaoming = Person('Xiao Ming', 'Male', '1990-1-1')
 
 
Traceback (most recent call last):
 
 
  File "<stdin>", line 1, in <module>
 
 
TypeError: __init__() takes exactly 3 arguments (4 given)
 
 
这会导致创建失败或运行不正常，因为第一个参数name被Python解释器传入了实例的引用，从而导致整个方法的调用参数位置全部没有对上。
 
任务
 
请定义Person类的__init__方法，除了接受 name、gender 和 birth 外，还可接受任意关键字参数，并把他们都作为属性赋值给实例。
 
 
 
class Person(object):
 
   def __init__(self, name, gender, birth, **kw):
 
       self.name = name
 
       self.gender = gender
 
       self.birth = birth
 
       for k, v in kw.iteritems():
 
           setattr(self, k, v)
 
xiaoming = Person('Xiao Ming', 'Male','1990-1-1', job='Student')
 
print xiaoming.name
 
print xiaoming.job
 
 
 
 
 
五、python中访问限制
 
 
我们可以给一个实例绑定很多属性，如果有些属性不希望被外部访问到怎么办？
 
Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：
 
 
 
class Person(object):
 
 
    def __init__(self, name):
 
 
        self.name = name
 
 
        self._title = 'Mr'
 
 
        self.__job = 'Student'
 
 
p = Person('Bob')
 
 
print p.name
 
 
# => Bob
 
 
print p._title
 
 
# => Mr
 
 
print p.__job
 
 
# => Error
 
 
Traceback (most recent call last):
 
 
  File "<stdin>", line 1, in <module>
 
 
AttributeError: 'Person' object has no attribute '__job'
 
 
可见，只有以双下划线开头的"__job"不能直接被外部访问。
 
但是，如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"__xxx__"定义。
 
以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。
 
任务
 
请给Person类的__init__方法中添加name和score参数，并把score绑定到__score属性上，看看外部是否能访问到。
 
 
 
class Person(object):
 
 
    def __init__(self, name, score):
 
 
        self.name = name
 
 
        self.__score = score
 
 
 
 
 
p = Person('Bob', 59)
 
 
 
 
 
print p.name
 
 
print p.__score
 
 
 
 
 
 
 
 
六、python中创建类属性
 
 
类是模板，而实例则是根据类创建的对象。
 
绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。
 
定义类属性可以直接在 class 中定义：
 
 
 
class Person(object):
 
 
    address = 'Earth'
 
 
    def __init__(self, name):
 
 
        self.name = name
 
 
因为类属性是直接绑定在类上的，所以，访问类属性不需要创建实例，就可以直接访问：
 
 
 
print Person.address
 
 
# => Earth
 
 
对一个实例调用类的属性也是可以访问的，所有实例都可以访问到它所属的类的属性：
 
 
 
p1 = Person('Bob')
 
 
p2 = Person('Alice')
 
 
print p1.address
 
 
# => Earth
 
 
print p2.address
 
 
# => Earth
 
 
由于Python是动态语言，类属性也是可以动态添加和修改的：
 
 
 
Person.address = 'China'
 
 
print p1.address
 
 
# => 'China'
 
 
print p2.address
 
 
# => 'China'
 
 
因为类属性只有一份，所以，当Person类的address改变时，所有实例访问到的类属性都改变了。
 
任务
 
请给 Person 类添加一个类属性 count，每创建一个实例，count 属性就加 1，这样就可以统计出一共创建了多少个 Person 的实例。
 
class Person(object):
 
   count = 0
 
   def __init__(self,name):
 
       self.name = name
 
       Person.count += 1#注意不能直接使用count
 
 
 
p1 = Person('Bob')
 
print Person.count
 
 
 
p2 = Person('Alice')
 
print Person.count
 
 
 
p3 = Person('Tim')
 
print Person.count
 
 
 
 
 
七、python中类属性和实例属性名字冲突怎么办
 
 
修改类属性会导致所有实例访问到的类属性全部都受影响，但是，如果在实例变量上修改类属性会发生什么问题呢？
 
 
 
class Person(object):
 
 
    address = 'Earth'
 
 
    def __init__(self, name):
 
 
        self.name = name
 
 
 
 
 
p1 = Person('Bob')
 
 
p2 = Person('Alice')
 
 
 
 
 
print 'Person.address = ' + Person.address
 
 
 
 
 
p1.address = 'China'
 
 
print 'p1.address = ' + p1.address
 
 
 
 
 
print 'Person.address = ' + Person.address
 
 
print 'p2.address = ' + p2.address
 
 
结果如下：
 
 
 
Person.address = Earth
 
 
p1.address = China
 
 
Person.address = Earth
 
 
p2.address = Earth
 
 
我们发现，在设置了 p1.address = 'China' 后，p1访问 address 确实变成了'China'，但是，Person.address和p2.address仍然是'Earch'，怎么回事？
 
原因是 p1.address = 'China'并没有改变 Person 的 address，而是给 p1这个实例绑定了实例属性address ，对p1来说，它有一个实例属性address（值是'China'），而它所属的类Person也有一个类属性address，所以:
 
访问 p1.address 时，优先查找实例属性，返回'China'。
 
访问 p2.address 时，p2没有实例属性address，但是有类属性address，因此返回'Earth'。
 
可见，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。
 
当我们把 p1 的 address 实例属性删除后，访问 p1.address 就又返回类属性的值 'Earth'了：
 
 
 
del p1.address
 
 
print p1.address
 
 
# => Earth
 
 
可见，千万不要在实例上修改类属性，它实际上并没有修改类属性，而是给实例绑定了一个实例属性。
 
任务
 
请把上节的 Person 类属性 count 改为 __count，再试试能否从实例和类访问该属性。
 
class Person(object):
 
   __count = 0
 
   def __init__(self, name):
 
       Person.__count = Person.__count + 1
 
       self.name = name
 
       print Person.__count
 
 
 
p1 = Person('Bob')
 
p2 = Person('Alice')
 
 
 
print Person.__count
 
 
 
 
 
 
 
八、python中定义实例方法
 
 
一个实例的私有属性就是以__开头的属性，无法被外部访问，那这些属性定义有什么用？
 
虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。
 
实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的：
 
 
 
class Person(object):
 
 
 
 
 
    def __init__(self, name):
 
 
        self.__name = name
 
 
 
 
 
    def get_name(self):
 
 
        return self.__name
 
 
get_name(self) 就是一个实例方法，它的第一个参数是self。__init__(self, name)其实也可看做是一个特殊的实例方法。
 
调用实例方法必须在实例上调用：
 
 
 
p1 = Person('Bob')
 
 
print p1.get_name()  # self不需要显式传入
 
 
# => Bob
 
 
在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。
 
任务
 
请给 Person 类增加一个私有属性 __score，表示分数，再增加一个实例方法 get_grade()，能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。
 
class Person(object):
 
 
 
   def __init__(self, name, score):
 
       self.name = name
 
       self.__score = score
 
 
 
   def get_grade(self):
 
       if self.__score>=90 :
 
           return 'A'
 
       elif self.__score>=60 :
 
           return 'B'
 
       else :
 
           return 'C'
 
           
 
p1 = Person('Bob', 90)
 
p2 = Person('Alice', 65)
 
p3 = Person('Tim', 48)
 
 
 
print p1.get_grade()
 
print p2.get_grade()
 
print p3.get_grade()
 
 
 
 
 
 
 
九、python中方法也是属性
 
 
我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象：
 
 
 
class Person(object):
 
 
    def __init__(self, name, score):
 
 
        self.name = name
 
 
        self.score = score
 
 
    def get_grade(self):
 
 
        return 'A'
 
 
 
 
 
p1 = Person('Bob', 90)
 
 
print p1.get_grade
 
 
# => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
 
 
print p1.get_grade()
 
 
# => A
 
 
也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，p1.get_grade() 才是方法调用。
 
因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：
 
 
 
import types
 
 
def fn_get_grade(self):
 
 
    if self.score >= 80:
 
 
        return 'A'
 
 
    if self.score >= 60:
 
 
        return 'B'
 
 
    return 'C'
 
 
 
 
 
class Person(object):
 
 
    def __init__(self, name, score):
 
 
        self.name = name
 
 
        self.score = score
 
 
 
 
 
p1 = Person('Bob', 90)
 
 
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
 
 
print p1.get_grade()
 
 
# => A
 
 
p2 = Person('Alice', 65)
 
 
print p2.get_grade()
 
 
# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
 
 
# 因为p2实例并没有绑定get_grade
 
 
给一个实例动态添加方法并不常见，直接在class中定义要更直观。
 
任务
 
由于属性可以是普通的值对象，如 str，int 等，也可以是方法，还可以是函数，大家看看下面代码的运行结果，请想一想 p1.get_grade 为什么是函数而不是方法：
 
 
 
class Person(object):
 
 
    def __init__(self, name, score):
 
 
        self.name = name
 
 
        self.score = score
 
 
        self.get_grade = lambda: 'A'
 
 
 
 
 
p1 = Person('Bob', 90)
 
 
print p1.get_grade
 
 
print p1.get_grade()
 
 
 
 
 
 
 
 
十、python中定义类方法
 
 
和属性类似，方法也分实例方法和类方法。
 
在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。
 
要在class中定义类方法，需要这么写：
 
 
 
class Person(object):
 
 
    count = 0
 
 
    @classmethod
 
 
    def how_many(cls):
 
 
        return cls.count
 
 
    def __init__(self, name):
 
 
        self.name = name
 
 
        Person.count = Person.count + 1
 
 
 
 
 
print Person.how_many()
 
 
p1 = Person('Bob')
 
 
print Person.how_many()
 
 
通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。
 
因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。
 
任务
 
如果将类属性 count 改为私有属性__count，则外部无法读取__score，但可以通过一个类方法获取，请编写类方法获得__count值。
 
class Person(object):
 
 
 
   __count = 0
 
 
 
   @classmethod
 
   def how_many(cls):
 
       return cls.__count
 
       
 
   def __init__(self,name):
 
       self.name = name
 
       Person.__count += 1
 
    
 
 
 
print Person.how_many()
 
 
 
p1 = Person('Bob')
 
 
 
print Person.how_many()