自从改用Python做数据挖掘以来，我就很少用面向对象的内容了，那啥是面向对象呢？

可以这么理解，如果我们能把代码组合成一个一个可以重复使用的类别，那么这能使程序的可复用性更高，以后只要用这个类别的东西就好，不用再重复实现这样的内容了。

Class 类

以下是类的构建，跟函数一样，前面需要用class声明

class MyFirstClass:

def __init__(self, name):

self.name = name

def greet(self):

print('Hello {}!'.format(self.name))

现在来实例化一个类

my_instance = MyFirstClass('John Doe')

print('my_instance: {}'.format(my_instance))

print('type: {}'.format(type(my_instance)))

print('my_instance.name: {}'.format(my_instance.name))

做完以上的两个，你就实现了类的构建，并成功实例化了一个类。

Methods 函数

类中的函数称为方法，使用方式和一般的函数一样

alice = MyFirstClass(name='Alice')

alice.greet()

以上的输出，当然是Hello Alice！

__init__() 此方法曾困扰了我好久

__init__()是一种特殊的方法，用于初始化类的实例，在创建类的时候调用它

class Example:

def __init__(self):

print('Now we are inside __init__')

print('creating instance of Example')

example = Example()

print('instance created')

__init__()通常用于初始化类的实例变量。这些可以作为参数列出self。为了能够在实例的生命周期中稍后访问这些实例变量，你必须将它们保存到self。self是类的方法的第一个参数，它是ni对实例变量和其他方法的访问方式。

class Example:

def __init__(self, var1, var2):

self.first_var = var1

self.second_var = var2

def print_variables(self):

print('{} {}'.format(self.first_var, self.second_var))

e = Example('abc', 123)

e.print_variables()

做数据分析的时候，或许可以将很多语句拼凑起来完成数据的分析，但当涉及到更长远的考量，如果无法提高代码的复用率，那你就得每次都重新写一遍代码 for a life long time。

__str__()

__str__()是一个特殊的方法，当类的实例转换为字符串时调用(例如，当你想要打印实例时)。换句话说，通过__str__为你的类定义方法，你可以决定类的实例的可打印版本。该方法应返回一个字符串。

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __str__(self):

return 'Person: {}'.format(self.name)

jack = Person('Jack', 82)

print('This is the string presentation of jack: {}'.format(jack))

类的变量与实例变量

类变量在该类的所有实例之间共享，而实例变量可以在该类的不同实例之间保存不同的值。

class Example:

# These are class variables

name = 'Example class'

description = 'Just an example of a simple class'

def __init__(self, var1):

# This is an instance variable

self.instance_variable = var1

def show_info(self):

info = 'instance_variable: {}, name: {}, description: {}'.format(

self.instance_variable, Example.name, Example.description)

print(info)

inst1 = Example('foo')

inst2 = Example('bar')

# name and description have identical values between instances

assert inst1.name == inst2.name == Example.name

assert inst1.description == inst2.description == Example.description

# If you change the value of a class variable, it's changed across all instances

Example.name = 'Modified name'

inst1.show_info()

inst2.show_info()

Public 与 Private变量

在python中，现在严格分离私有/公共方法或实例变量。如果一个变量是私有变量的话，惯例是使用下划线开始方法或实例变量的名称。私有意味着不应该从类外访问它。

例如，让我们考虑一下我们有一个Person具有age实例变量的类。我们希望age在创建实例后不直接访问(例如更改)。在Python中，这将是：

class Person:

def __init__(self, age):

self._age = age

example_person = Person(age=15)

# You can't do this:

# print(example_person.age)

# Nor this:

# example_person.age = 16

如果你想要age可读但不可写，那可以使用property：

class Person:

def __init__(self, age):

self._age = age

@property

def age(self):

return self._age

example_person = Person(age=15)

# Now you can do this:

print(example_person.age)

# But not this:

#example_person.age = 16

这样，你就可以对类的实例变量进行受控访问：

class Person:

def __init__(self, age):

self._age = age

@property

def age(self):

return self._age

def celebrate_birthday(self):

self._age += 1

print('Happy bday for {} years old!'.format(self._age))

example_person = Person(age=15)

example_person.celebrate_birthday()

类的继承

如果你不知道类的继承是什么，你就类比生物中的继承关系，而面向对象编程的思想，你也该去了解一下，非常简单。

class Animal:

def greet(self):

print('Hello, I am an animal')

@property

def favorite_food(self):

return 'beef'

class Dog(Animal):

def greet(self):

print('wof wof')

class Cat(Animal):

@property

def favorite_food(self):

return 'fish'

现在实例一下以上的类

dog = Dog()

dog.greet()

print("Dog's favorite food is {}".format(dog.favorite_food))

cat = Cat()

cat.greet()

print("Cat's favorite food is {}".format(cat.favorite_food))