学python的第四天啦！

今天是2019.08.19，已经是第四天再学python了，学习依然挺累，不过还是有点收获的，做起码一些基础的东西还是能听懂的，突然觉得自己咋这么笨，以前学数学没发现呀，估计还是编程基础太差吧。Less interests,more interest.

面向对象编程基础

类和对象：

简单的说，类是对象的蓝图和模板，而对象是类的实例。

定义类：

在python中，可以使用class关键字来定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来。
class class_name (object):
def init(self):
__init__是一个特殊方法用于在创建对象时进行初始化操作
写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接受的消息。

创建和使用对象：

当我们定义好一个类之后，可以通过下面的方式来创建对象并给对象发消息。
def main():
# 创建学生对象并指定姓名和年龄
stu1 = Student(‘骆昊’, 38)
# 给对象发study消息
stu1.study(‘Python程序设计’)
# 给对象发watch_av消息
stu1.watch_movie()
stu2 = Student(‘王大锤’, 15)
stu2.study(‘思想品德’)
stu2.watch_movie()
if name == ‘main’:
main()
在python中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头。
典型例子：
打印进度条：
import time
class zsc(object):
def__init__(self):
pass
def jindutiao (self):
for i in range(1,101):
time.sleep(0.5）
print(’#’*（i）.’%d%%’%i)
if name=" main":
zsc=zsc()
zsc.jindutiao()

面向对象进阶：

@property装饰器

我们之前的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便
class Person(object):

def __init__(self, name, age):
    self._name = name
    self._age = age

# 访问器 - getter方法
@property
def name(self):
    return self._name

# 访问器 - getter方法
@property
def age(self):
    return self._age

# 修改器 - setter方法
@age.setter
def age(self, age):
    self._age = age

def play(self):
    if self._age <= 16:
        print('%s正在玩飞行棋.' % self._name)
    else:
        print('%s正在玩斗地主.' % self._name)

def main():
person = Person(‘王大锤’, 12)
person.play()
person.age = 22
person.play()
# person.name = ‘白元芳’ # AttributeError: can’t set attribute
if name == ‘main’:
main()

静态方法和类方法

方法属于这个类，而并不属于这个对象。使用静态方法。

from math import sqrt

class Triangle(object):

def __init__(self, a, b, c):
    self._a = a
    self._b = b
    self._c = c

@staticmethod
def is_valid(a, b, c):
    return a + b > c and b + c > a and a + c > b

def perimeter(self):
    return self._a + self._b + self._c

def area(self):
    half = self.perimeter() / 2
    return sqrt(half * (half - self._a) *
                (half - self._b) * (half - self._c))

def main():
a, b, c = 3, 4, 5
# 静态方法和类方法都是通过给类发消息来调用的
if Triangle.is_valid(a, b, c):
t = Triangle(a, b, c)
print(t.perimeter())
# 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
# print(Triangle.perimeter(t))
print(t.area())
# print(Triangle.area(t))
else:
print(‘无法构成三角形.’)

if name == ‘main’:
main()

类之间的关系

类和类之间的关系有三种：继承，关联，依赖。
在类的基础上创建新类，这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来，从而减少重复代码的编写。提供继承信息的我们称之为父类，也叫超类或基类；得到继承信息的我们称之为子类，也叫派生类或衍生类。子类除了继承父类提供的属性和方法，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力，在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为。
class Person(object):
“”“人”""

def __init__(self, name, age):
    self._name = name
    self._age = age

@property
def name(self):
    return self._name

@property
def age(self):
    return self._age

@age.setter
def age(self, age):
    self._age = age

def play(self):
    print('%s正在愉快的玩耍.' % self._name)

def watch_av(self):
    if self._age >= 18:
        print('%s正在观看爱情动作片.' % self._name)
    else:
        print('%s只能观看《熊出没》.' % self._name)

class Student(Person):
“”“学生”""

def __init__(self, name, age, grade):
    super().__init__(name, age)
    self._grade = grade

@property
def grade(self):
    return self._grade

@grade.setter
def grade(self, grade):
    self._grade = grade

def study(self, course):
    print('%s的%s正在学习%s.' % (self._grade, self._name, course))

class Teacher(Person):
“”“老师”""

def __init__(self, name, age, title):
    super().__init__(name, age)
    self._title = title

@property
def title(self):
    return self._title

@title.setter
def title(self, title):
    self._title = title

def teach(self, course):
    print('%s%s正在讲%s.' % (self._name, self._title, course))

def main():
stu = Student(‘王大锤’, 15, ‘初三’)
stu.study(‘数学’)
stu.watch_av()
t = Teacher(‘骆昊’, 38, ‘砖家’)
t.teach(‘Python程序设计’)
t.watch_av()

if name == ‘main’:
main()
子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这个就是多态（poly-morphism）。
from abc import ABCMeta, abstractmethod

class Pet(object, metaclass=ABCMeta):
“”“宠物”""

def __init__(self, nickname):
    self._nickname = nickname

@abstractmethod
def make_voice(self):
    """发出声音"""
    pass

class Dog(Pet):
“”“狗”""

def make_voice(self):
    print('%s: 汪汪汪...' % self._nickname)

class Cat(Pet):
“”“猫”""

def make_voice(self):
    print('%s: 喵...喵...' % self._nickname)

def main():
pets = [Dog(‘旺财’), Cat(‘凯蒂’), Dog(‘大黄’)]
for pet in pets:
pet.make_voice()

if name == ‘main’:
main()
开心一刻！