类和对象

一. 类和对象的概念

概念：

面向对象的两个最重要的概念：类和对象

类：共性事物的抽象，是对某一类具有共性事物的描述，是概念上的定义

对象：对象是共性事物的一个体现，是这类事物的每个个体，或者说是类的一个实例(instance)

总结：

类是对象的模板，对象是类的实例

类结构：

里面包含属性与函数

数据是对象的状态-->成员变量(属性)

方法是对象的行为-->函数(方法)

二. 语法

#创造类的语法
class Math:
    a = 4                #属性
    b = 5

    def add(self):       #方法
        c = self.a + self.b
        return c

注意：1) 类名一般首字母大写，比如 class User    #class是关键字

　　   2) 类里面包含属性和方法

　　　3) 类函数自带self关键字(指向类的实例)。不能少!

　　　4) 如果类函数里面要调用属性，方法: self.属性名， self.方法名

实例：

class Friend:

    height = None
    weight = None
    age = None
    money = None

    #定义功能——会做饭
    def canCook(self, can=True):
        if can == True:
            print("我会做饭。。。")
        else:
            print("我不会做饭。。。")

    def canGetMoney(self):
        print("我会挣钱。。。")

    def setAge(self, age):
        self.age = age
        print("年龄为：", self.age)

    def setHeight(self, height):
        self.height = height
        print("身高为：", self.height)

    def setWeight(self, weight):
        self.weight = weight
        print("体重为：", self.weight)

    def setMoney(self, money):
        self.money = money
        print("资产为：", self.money)

#对象一：身高180，会做饭，做挣钱，有200万的资产，而且才29岁
#实例化：类名()
danqing = Friend()
danqing.setAge(29)
print(danqing.age)
danqing.setMoney(2000000)
print(danqing.money)
danqing.canCook()

print("===========================")
#对象二：身高175，不会做饭，年龄只有25岁，资产5万
dancf = Friend()
#改变对象的属性
dancf.setAge(25)
print(dancf.age)
dancf.setMoney(50000)
print(dancf.money)
dancf.setHeight(175)
print(dancf.height)
dancf.canCook(False)

运行结果：

年龄为： 29
29
资产为： 2000000
2000000
我会做饭。。。
===========================
年龄为： 25
25
资产为： 50000
50000
身高为： 175
175
我不会做饭。。。

三. 初始化函数的调用

初始化函数：def __init__(self, 参数1, 参数2, 参数3)

__init__函数，是两个下划线！经常会写错，写成单下划线，这样会报错！

用法：

def __init__(self, a, b):
    self.a = a 
    self.b = b
    self.c =  10

注意：

1) 初始化里面做的是初始化操作，可以带参数也可以不带参数

2) 跟普通函数一样，可以带默认参数

3) 初始化里面可以有赋值好了的属性值

4) 每次创造一个实例，需要传递跟初始化函数参数个数一致的值

5) 每个实例都会自动调用初始化函数

6) 初始化参数的写法要注意，怎么把参数赋值给self.参数名，参数名字不一定要一致，但是赋值要正确

实例1：

class Friend:

    def __init__(self, age, sex, height):
        self.age = age
        self.sex = sex
        self.height = height


    #定义功能——会做饭
    def canCook(self, can=True):
        if can == True:
            print("我会做饭。。。")
        else:
            print("我不会做饭。。。")

    def canGetMoney(self):
        print("我会挣钱。。。")


xiaozhai = Friend(26, "男", 178)
jian = Friend(18, "女", 155)

实例2：类也可以没有初始化

class Friend:

    #定义功能——会做饭
    def canCook(self, can=True):
        if can == True:
            print("我会做饭。。。")
        else:
            print("我不会做饭。。。")

    def canGetMoney(self):
        print("我会挣钱。。。")

    def setAge(self, age):
        self.age = age
        print("年龄为：", self.age)

    def setHeight(self, height):
        self.height = height
        print("身高为：", self.height)

    def setWeight(self, weight):
        self.weight = weight
        print("体重为：", self.weight)

    def setMoney(self, money):
        self.money = money
        print("资产为：", self.money)

jian = Friend()
print(jian.age)


运行结果：
Traceback (most recent call last):
  File "D:/python_workshop/python6/revise/类和对象(一).py", line 63, in <module>
    print(jian.age)
AttributeError: 'Friend' object has no attribute 'age'

当直接调用函数后，再打印属性发现有age了，因为函数setAge里生成了一个全局属性age

jian = Friend()
jian.setAge(25)
print(jian.age)


运行结果：
年龄为： 25
25

四. 类的继承

1. 子类拥有父类的所有属性和行为

2. 子类可以扩展自己的属性和行为

3. 父类的行为不够用，子类要升级和优化，子类可重写父类的方法——多态

4. 子类和父类都有的行为：子类实例优先使用自己的，没有再去用父类的

支持多继承

多继承语法：用逗号隔开父类

　　　　　　class 子类类名(父类1, 父类2):

class Son(Father, Mother):

　　def __init__():

　　　　XXXX

实例

class Father:

    def __init__(self, id, name, sex, age):
        self.id = id
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self, food):
        print("eat：", food)

    def earnMoney(self, money):
        print("Father earn money：", money)


class Mother:

    def sing(self):
        print("xxxxxx")

    def earnMoney(self, money):
        print("Mother earn money：", money)



#子类继承了两个类的所有属性和方法
class Son(Father, Mother):

    #方法重写，调用该方法时会调用自己的方法
    def eat(self, food):
        print("eat：", food)
        print("我吃的更快，比father更快！！！")

    def dance(self):
        print("xxxxxx")


#子类没有定义的初始化方法，但是父类定义了初始化方法
#则子类实例化时会调用父类的初始化方法
jian = Son(123, "jian", "male", 22)
jian.eat("apple")
#当子类继承了多个类中同样的方法时，子类会优先使用第一个继承类的方法(从左向右)
jian.earnMoney(2000)

#父类实例化
jianBB = Father(111, "li", "male", 56)
jianBB.eat("orange")

运行结果

eat： apple
我吃的更快，比father更快！！！
Father earn money： 2000
eat： orange

继承—super用法

在子类的行为中，想调用父类的行为，然后再做额外扩展，可以使用super类

语法：super().行为(参数)

class Son(Friend):

　　def __init__(self, age, sex, name):

　　　　super().__init__(age, sex)

　　　　#Friend.__init__(age, sex)  这样也可以 

　　　　self.name = name

五. 封装数据

实现方式：遵循一定的属性和方法命名规约

不希望这些变量或者方法被外部使用

• 任何以单下划线_开头的名字都应该是内部实现

即不希望通过实例名字，变量名/方法名来调用，但是python并不会真的阻止别人访问内部名称，子类也可以继承并重写父类的方法，只是一种约定

• 以双下划线__开头的名字，仅类自己可访问

继承——这种方法通过继承是无法被覆盖(重写)的。其实也是可以访问的，只不过换成了_类名__变量名/函数名

class MyClass:

    def __init__(self):
        self._private_data1 = "私有方式一"
        self.__private_data1 = "私有方式二"
        pass

    def _pri_func(self):
        print("私有方法一")

    def __pri_func(self):
        print("私有方法二")

    def public_func(self ):
        print("公开方法")
        #类内部调用自己的私有方法一
        self._pri_func()

mc = MyClass()
#仍然可以调用单下划线的属性和方法，只不过作为一种约定，告诉别人请不要这样调用
mc._pri_func()
mc._private_data1
#mc.__private_data2  双下划线的方法无法调用

class SonClass(MyClass):

    #子类继承父类的单下划线私有方法并重写，也是可以的
    def _pri_func(self):
        print("我是子类的私有方法")
    
    
    #子类无法继承父类的双下划线私有方法并重写，运行时报错
    def __pri_func(self):
        print("我是子类的私有方法二")

son = SonClass()
son.__pri_func()

运行结果

Traceback (most recent call last):
  File "D:/python_workshop/python6/revise/私有属性和方法.py", line 37, in <module>
    son.__pri_func()
AttributeError: 'SonClass' object has no attribute '__pri_func'
私有方法一

哪种方式好

两种不同的编码约定(单下划线和双下划线)来命名私有属性，问题就来了：到底哪种方式好呢？

大多数而言，你应该让你的非公共名称以单下划线开头，但是，如果你清楚你的代码会涉及到子类，并且有些内部属性应该在子类中隐藏起来，那么才考虑使用双下划线方案

六. @property和@属性名.setter

实例属性，除了访问和修改之后，增加其他逻辑处理，如合法性等

@property      #获取属性值：实例.属性名
def age(self):
    return self._age

@age,setter    #给属性赋值时添加了逻辑处理
def age(self.age):
    if age in range(0, 121 ):
        self._age = age
    else:
        print("输入的年龄不符合要求哦！！")

实例

class People:

    #age是people类的属性名
    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        if age in range(0, 121):
            self._age = age
            print(self._age)
        else:
            print("年龄不符合要求")

p = People()
p.age = 134

运行结果：

年龄不符合要求

注意：

不能写成return self.age和self.age = age，原因如下

class People:
    '''
    ==========================================
     @property和@属性名.setter可以用来对属性的值进行一定的逻辑处理。
     但是：
    @property和@属性名.setter的小坑
    ===========================================
    在以下代码中，setter函数表示：当你使用self.age时就会自动的去调用setter
    所以在@age.setter对应的函数中，else操作中，有使用self.age。
    所以，这里的self.age相当于又去调用了setter，即又去调用了自己。就进入了一直在调用自己的状态。
    于是，就会报错：递归次数超限制。
    这个是个坑！！！
    如何解决这个问题呢？如果设置可以爬出这个坑呢？？

    @property
    def age(self):
        return self.age
    @age.setter
    def age(self,age):
        if age not in range(0,121):
            print("age is not valid data")
        else:
            self.age = age
    ============================================
    ================以下是爬坑策略====================
    为了不要重复的来调用自己，也就是在@age.setter对应的函数当中，不要使用self.age
    所以用了另外一个变量名：self._age。这样子就不会一直调用。
    ====代码不同之处 一：@property对应的函数中，return self._age =======
    ====代码不同之处 二：@age.setter对应的函数中，else:self._age = age =======

    对外部使用者而言，还是age属性，即可以通过实例名.age来设置值。
    对类内部而言，就是_age属性了。
    以下是代码部分
    '''

    def __init__(self,name,sex):
        self.name = name
        self.sex = sex


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

    @age.setter
    def age(self,age):
        if age not in range(0,121):
            print("age is not valid data")
        else:
            self._age = age



p = People("jian","female")
p.age = 100
print(p.age)
p.age = 122
print(p.age)