python之面向对象基础一

假设我们要处理学生的成绩表，为了表示一个学生的成绩：
面向过程的方法：用一个dict表示，在进行函数调用

std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }
#而处理学生成绩可以通过函数实现，比如打印学生的成绩：
def print_score(std):
    print('%s: %s' % (std['name'], std['score']))
print_score(std2)
print_score(std1)

Bob: 81
Michael: 98

面向对象的方法：创建出这个学生对应的对象，给对象发一个print_score消息，让对象自己把自己的数据打印出来。

class Student(object):
    # 定义初始化方法,创建实例对象自动调用,对属性赋值
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))
hongenjie = Student('洪恩节',100)
lisa = Student('Lisa Simpson', 87)
hongenjie.print_score()
lisa.print_score()

洪恩节: 100
Lisa Simpson: 87

面向对象和面向程序的区别:

如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，
而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性。
如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，
给对象发一个print_score消息，让对象自己把自己的数据打印出来,给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法

面向对象的设计思想是抽象出Class，根据类创建实例，面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法

创建对象和定义类：

经典类：class Cat:

# 定义一个猫类
class Cat:
    # 定义猫的属性（color，legs）
    color = '黄色'
    legs = 4
    # 定义猫的方法(eat,sleep)
    def eat(self):
        print('猫吃鱼')
    def sleep(self):
        print('猫睡觉')
my_cat=Cat()#创建实例my_cat
my_cat.eat()#访问方法
my_cat.sleep()#访问方法
print(Cat.color)#访问属性
print(Cat.legs)#访问属性

猫吃鱼
猫睡觉
黄色
4

新式类：class Car(object):

# 定义一个车类
class Car(object):
    # 属性:颜色,四个轮子
    color = '白色'
    wheel = 4
    # 行为:跑,鸣笛
    def move(self):
        print('车子在移动')
    def whistle(self):
        print('车子在鸣笛')
my_car=Car()
my_car.move()
my_car.whistle()
print(Car.color)
print(Car.wheel)

车子在移动
车子在鸣笛
白色
4

实例的作用：

当创建实例对象的时候,对象自动拥有方法,对象就可以直接调用方法(属性也一样)。

对象属性的添加和获取：

属性的添加语法格式:对象名.属性名 = 新的值
属性的获取语法格式：print(对象名.属性名)
对象调用的方法语法格式：对象名.方法名（）

#定义一个关于person的类
class Person(object):#属性:身高,体重,年龄#行为:吃饭 睡觉 喝水
	#定义普通的方法
    def eat(self):
        print('人都要吃饭')
    def sleep(self):
        print('人都要休息')
    def drink(self):
        print('水是生命之源')
#通过Person创建一个实例对象p
p = Person()
#直接添加属性
p.name = '张三'
p.age = 20
p.height=180
p.weight=60
#获取属性
print(p.name)
print(p.age)
print(p.height)
print(p.weight)
#对象调用方法
p.eat()
p.sleep()
p.drink()

张三
20
180
60
人都要吃饭
人都要休息
水是生命之源

不仅如此，我们还可以创建新的对象p2,它可以和p有不同的属性，但他们含有相同的方法。

#通过Person创建一个对象p2
p2 = Person()
#直接添加属性
p2.name = '李四'
p2.age = 30
p2.sex = '男'
#获取属性
print(p2.name,p2.age,p2.sex)
#对象调用方法
p2.eat()
p2.sleep()
p2.drink()

李四 30 男
人都要吃饭
人都要休息
水是生命之源

类中的函数称为方法，我们在python前面的基础学习中，学到的任何函数都适用于方法，唯一的区别在于调用方法的方式不同。

init()方法的使用：

init（self,属性1，属性2）是一个特殊的方法，每当我们所创建的类产生新的示例的时候，python都会自动运行它，在这个运行方法的名称中，开头和末尾均有两个下划线，这是避免与普通方法名称产生矛盾，因此必须确保__init__(self,属性1，属性2)的两边都有两个下划线，否则当你使用类来创建示例时，将不会自动调用这个方法，进而引发难以发现的错误。

举例：

#定义一个汽车类
class Car(object):
    def __init__(self,color,wheelNum):
        self.color = color
        self.wheelNum = wheelNum
    # 定义一个普通方法
    def move(self):
        print('车子在移动')
    # 定义一个普通方法
    def whistle(self):
        print('车子在鸣笛')
#创建一个对象bmw
bmw = Car('红色',4)
#调用类里面普通方法
bmw.move()
bmw.whistle()
print(bmw.color)
print(bmw.wheelNum)

细心的小伙伴可能都发现了为什么__init_()属性里面包含了self.
为何必须在方法定义中包含形参self呢？
因为python调用这个方法创建示例时，将自动传入实参self，每个与示例相关联的方法调用都自动传递实参self,它是一个指向示例本身的引用，让示例能够访问类中的属性和方法。
属性我们可以在编写__init__()的时候将属性的值指定，也可以是通过实参来传递属性的值。

指定属性的值：

 def __init__(self,color,wheelNum):
        self.color = '黑色'
        self.wheelNum = 4

不指定属性的值：

 def __init__(self,color,wheelNum):
        self.color = color
        self.wheelNum = wheelNum

那么这两种有什么区别？
区别在于如果指定了属性的值，那么在调用属性的时候，即使实参传递了和指定值不相同的，输出结果依然为指定值。
举例：

def __init__(self,color,wheelNum):
    self.color = '黑色'
    self.wheelNum = 4
bmw = Car('红色',4)
print(bmw.color)
print(bmw.wheelNum)

黑色
4

难道属性的值就不能被改变吗？当然不是
下面我们对上面例子中的属性进行修改：

bmw.color="yellow"
bmw.wheelNum=10

直接修改 对象名.属性名 = 新值
完整代码：

class Car(object):
    def __init__(self,color,wheelNum):
        self.color = '黑色'
        self.wheelNum = 4
    def move(self):
        print('车子在移动')
    def whistle(self):
        print('车子在鸣笛'）
bmw = Car('红色',4)
bmw.move()
bmw.whistle()
bmw.color="yellow"
bmw.wheelNum=10
print(bmw.color)
print(bmw.wheelNum)

这次的颜色和车轮数很好的被修改了

车子在移动
车子在鸣笛
yellow
10

当实例化类得到具体对象的时候,会自动调用__init__()方法,对类的属性进行初始化赋值，创建对象的时候,自动拥有类里面属性

__del__析构方法：

import time
#定义一个动物类
class Animal(object):
    #定义初始化方法  创建对象时候自动调用
    def __init__(self,name):
        print('__init__方法被调用')
        self.name = name
    #定义普通方法
    def walk(self):
        print('动物会跑')
    #定义一个析构方法  删除对象的时候自动调用
    def __del__(self):
        print('__del__方法被调用')
        print('%s对象被干掉'%(self.name))
#创建一个dog对象
dog = Animal('哈皮狗')
dog.walk()

__init__方法被调用
动物会跑
__del__方法被调用
哈皮狗对象被干掉

通过输出结果我们发现，为什么__del__()也被调用了呢？
原因是：析构函数__del__(),使用del删除实例时才触发，否则等到文件执行完毕进行回收时才触发。
修改之后：

import time
# 定义一个动物类
class Animal(object):
    #定义初始化方法  创建对象时候自动调用
    def __init__(self,name):
        print('__init__方法被调用')
        self.name = name
    #定义普通方法
    def walk(self):
        print('动物会跑')
    #定义一个析构方法  删除对象的时候自动调用
    def __del__(self):
        print('__del__方法被调用')
        print('%s对象被干掉'%(self.name))
#创建一个dog对象
dog = Animal('哈皮狗')
dog.walk()
# 手动销毁对象,再测试对象调用类中方法报错
del dog
dog.walk()

此时编译器告诉我们dog没有被定义，事实上是因为使用del将其删除了

上面代码中，dog只被引用了一次，因此使用一次del,该对象就被真正的删除了，那么如果是下面这种情况呢？
cat被引用了3次，如果我们去用和面一样的方法，会成功实现对象的删除吗？

cat=Animal("波斯猫")
cat2=cat
cat3=cat

删除cat,去调用cat2和cat3

class Animal(object):
    def __init__(self,name):
        print('__init__方法被调用')
        self.name = name
    def walk(self):
        print('动物会跑')
    def __del__(self):
        print('__del__方法被调用')
        print('%s对象被干掉'%(self.name))
cat=Animal("波斯猫")
cat2=cat
cat3=cat
del cat
cat3.walk()
cat2.walk()

__init__方法被调用
动物会跑
动物会跑
__del__方法被调用
波斯猫对象被干掉

cat2和cat3成功被调用了，难道是对象没被删除？下面我们调用一下cat.

class Animal(object):
    def __init__(self,name):
        print('__init__方法被调用')
        self.name = name
    def walk(self):
        print('动物会跑')
    def __del__(self):
        print('__del__方法被调用')
        print('%s对象被干掉'%(self.name))
cat=Animal("波斯猫")
cat2=cat
cat3=cat
del cat
cat.walk()

Traceback (most recent call last):
  File "C:/Users/Lenovo/PycharmProjects/pythonProject4/main.py", line 295, in <module>
    cat.walk()
NameError: name 'cat' is not defined
__init__方法被调用
__del__方法被调用
波斯猫对象被干掉

通过结果我们可得出如下结论：
在本例中，cat被删除，但不影响cat2/cat3的调用，其他情况亦是如此。

变量保存了对象的引用,对象的引用计数加1,使用__del__()删除对象的时候,对象的引用计数-1,对象被删除，如果对象的引用计数不是1,每删除一次对象的引用计数减1,直到引用计数为0时候，该对象才被真正的删除