导读：

1.面向对象介绍

2.面向对象基本概念

3.创建类

4.类对象

5.实例对象

6.类属性、实例属性与实例方法

1. 面向对象介绍

Python是一种面向对象的脚本语言，所以它也提供了面向对象编程的所有基本特征：允许多继承的类继承机制、派生类可以重写它父类的任何方法、一个方法可以调用父类中同名的方法、对象可以包含任意数量和类型的数据成员。

面向对象(object-oriented ;简称: OO)是指按人们认识客观世界的系统思维方式,采用基于对象(实体)的概念建立模型,模拟客观世界分析、设计、实现软件的办法。

面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。

面向过程与面向对象：

面向过程：根据业务逻辑从上到下写代码。

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起，数据与函数分开考虑。

面向对象：将数据与函数绑定到一起，分类进行封装，每个程序员只要负责分配给自己的分类，这样能够更快速的开发程序，减少了重复代码。

l 用面向对象的思维解决问题的重点；

l 当遇到一个需求的时候不用自己去实现，如果自己一步步实现那就是面向过程；

l 应该找一个专门做这个事的人来做；

l 面向对象是基于面向过程的；

l 面向对象的核心——类、对象。

2. 面向对象基本概念

类：

具有相似特征和行为的实体的集合(或统称为抽象)。

对象object：

l 类的具体存在。

l 对象的数据彼此独立，互不干扰。

l 对象的引用可以传递。

l 如果一个对象与另外一个对象有一定的关系，那么一个对象可以是另外一个对象的属性。

类和对象的关系：

l 类就是创建对象的模板，一个类可以创建多个对象。

l 类描述了对象，对象是类的具体存在。

类的构成：

l 类的名称:类名

l 类的属性:一组数据

l 类的方法:允许对进行操作的方法 (行为)

3. 创建类

类的首字母大写，使用大驼峰命名法。

在python2.x中：

class Hero: # 经典类（旧式类）

class Hero(): # 经典类（旧式类）

class Hero(object): # 新式类

在python3.x中：

class Hero: # 新式类

class Hero(): # 新式类

class Hero(object): # 新式类

创建新式类的第1种方法：

我们通常使用新式类，所以会使用class Hero(object):创建类。

创建新式类的第2种方法：

在类的前面写上：__metaclass__==type，然后定义类的时候，就不需要在名字后面写(object)了。

__metaclass__==type

class Hero:

pass

类定义会创建一个新的命名空间，作为一个局部的作用域。在Python中，类本身就是对象，当一个类定义结束后, 一个Class Object就被创建。

示例：

# 创建一个Animal类
class Animal(object):  # 继承自object基类

    deff __init__(self,name):
        self.name = name
        self.age = 18

    def greet(self):
        print('hello, I am %s') % self.name


# 创建一个实例对象，传入参数'dog1'
animal = Animal('dog1')  

# 打印对象，则默认打印对象在内存的地址
print(animal)  #  <__main__. Animal at 0x1030a44d0>

# 打印对象的id，则是内存地址的十进制形式表示
print(id(animal))

# 访问对象的属性
print(animal.name)  # 'dog1'

# 调用greet方法
animal.greet()  # 'Hello, I am dog1'

我们在创建实例的时候，可以使用__init__ 方法初始化对象的属性。需要传入参数。

4. 类对象

类对象（Class Object）支持两种操作：属性引用和实例化。

属性引用

类对象的属性引用和 Python 中所有的属性引用一样，形式为： obj.name 。类对象创建后，类命名空间中所有的名字都是有效属性名，像下面这个类：

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

它有一个属性 i 和方法 f ，所以可以用 MyClass.i 和 MyClass.f 进行属性引用，分别返回一个整数和一个函数对象。__doc__ 也是一个合法的属性，返回属于这个类的文档字符串。

实例化

类的实例化形式为：

x = MyClass()

上述代码创建了一个新的实例，并且将其指定给局部变量 x 。

5. 实例对象

类对象实例化得到实例对象（Instance Object），实例对象只能进行属性引用这一种操作。合法的属性有两种：数据属性和方法。

数据属性

在Python中，数据属性不需要声明，当它们第一次指定时就会被引入：

class MyClass:
    i = 12345

    def f(self):
        return 'hello world'


x = MyClass()
x.f()
x.counter = 1
print(x.counter)  # 1

del x.counter  # 删除属性
print(x.counter)  # 报错，没有counter属性

方法

在类对象中定义的方法，第一个参数必须是 self，用以指定调用该方法的实例对象。 f 是一个实例方法，第一个参数self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量这个变量指向了实例对象。self接收了调用方法的对象。self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

注意：类的方法只有被绑定到实例对象上才能够被调用。比如上面的例子中，x 是 MyClass类的一个实例对象，所以它可以直接调用 f 方法：x.f()

为什么 f() 定义时是有一个参数的，而这里调用不需要参数呢？因为在调用时， x 对象作为参数传递给了函数的第一个参数（即 self）。也就是说， x.f() 是严格等价于 MyClass.f(x) 的。

所以在多数情况下，调用一个方法（有个 n 个参数），和调用相应的函数（也有那 n 个参数，但是再额外加入一个使用该方法的对象）是等价的。

另外，函数也可以在 class 外定义，指定该函数对象给类中的局部变量就可以了，例如：

# Function defined outside the class
def f1(self, x, y):
    return min(x, y)


class C:
    f = f1

    def g(self):
        return 'hello world'


c = C() # 实例化
c.f(1,3)
c.g()

6. 类属性、实例属性与实例方法

类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。

访问类属性

类对象.类属性（推荐使用）
实例对象.类属性访问

类外修改类属性

直接修改: 类名.类属性名 = 值
调用类方法：类名.类方法(值)

添加实例对象属性

创建对象后给对象添加属性：对象名.属性名 = 属性值
创建对象时给对象添加属性：

def __init__(self):

self.属性名 = 属性值

访问实例属性和实例方法

在类外面访问：对象名.属性名/实例方法
在类里面访问：self.属性名/实例方法

修改实例属性：

直接修改: 实例对象名.实例属性名 = 值
调用实例方法:实例对象名.实例方法(值)

一个对象的属性 可以是 另外一个类创建的对象。

注意点：

1> 尽量避免类属性和对象属性同名。如果有同名对象属性，实例对象会优先访问对象属性

class Dog(object):
    type = "狗"  # 类属性

    def __init__(self):
        self.type = "dog"  # 对象属性


dog1 = Dog()
print(Dog.type) # 结果为"狗" 使用类对象访问类属性
print(dog1.type) # 结果为“dog”

2> 类属性只能通过类对象修改，不能通过实例对象修改。

class Dog(object):
    type = "狗"  # 类属性


dog1 = Dog()
Dog.type = "Dog"  # 使用类对象修改类属性
print(Dog.type)   # 结果为 "狗"  访问类属性
dog1.type = "dog" # 使用实例对象创建了对象属性type
print(dog1.type)  # 结果为“dog” 类属性和对象属性同名，访问的是对象属性

3> 类属性也可以设置为私有，前边添加两个下划线。

class Dog(object):
    count = 0  # 公有的类属性
    __type = "狗"  # 私有的类属性


print(Dog.count)       # 正确
# print(Dog.__type)      # 错误

4> 类属性不会被实例属性左右。

当类中变量引用的是可变对象时，类属性和实例属性都能直接修改这个对象，从而影响另一方的值。

5> 在类外面不要随便访问属性。

6> 一般把类写在一个模块内，在另一个模块中进行类的实例化。

写给小白的Python之015：面向对象-类和对象

导读：