python面向对象

• 面向对象思想介绍

C语言：面向过程--将整个过程放到代码中完成
Java：面向对象--将某一模块交给一个类，使用的时候直接调用类就可以
Python：面向对象

面向对象需要注意：物体 类 对象
面向对象三大特性：封装，继承，多态

• 类和对象

• 类

对象—是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念 -- 类

人以类聚，物以群分
具有相似内部状态和运动规律的实体的集合，或统称为抽象。
具有相同属性和作用事务的统称。

类是抽象的，在使用的使用通常会找到这个类的一个具体的存在也就是对象，使用这个具体的存在。一个类可以找到多个对象。

object 为 python 中所有类的父类
类名的命名方法为"大驼峰命名法"，首字母大写

• 对象

某一个具体事务的存在，在现实世界中可以是看得见摸得着的，直接可以使用的。

• 类的构成

类(Class)由三部分构成
类的名称: 类名 【首字母需要大写】
类的属性:一组数据
类的方法:操作的方法

• 定义类

定义一个类，格式如下。
class 类名:
方法列表

# self 自己
# 所有类中直接定义函数，默认携带self
class Car:
    def run(self):
        print('小汽车开始动了')

    def toot(self):
        print('小汽车鸣笛')


# 定义一个变量名称Car()定义一个实体对象
# 编程的面向对象中，万物皆对象，没有就new一个
liuCar = Car()  # 在Car类中创建一个liucar的实例对象。Car后必须加()才被识别为类

# 调用
liuCar.run()
liuCar.toot()


liuCar.money = 10000  # 定义属性
print('价格：%d' % liuCar.money)  # 调用属性

• 初始化函数

python可以给对象随意添加属性
弊端：每个人定义同一个属性可能设置不同的名字，容易混乱。
所以有了初始化函数 __init__方法（initialize）

class Person:  # 创建一个Person的类
    # 定义每个实例的属性。定义以后创建对象必须具备这些属性，少传会报错
    # self代表为对象本身，谁调用就是谁，不需要填
    def __init__(self, name, age):  # 定义每个实例要传的参数。初始化参数
        print('-----创建了一个对象-----')
        self.userName = name  # 将传入的参数name赋值给username属性，属性名称可以自己定义，一般情况下属性名称我们就命名为参数名称
        self.age = age  # =右侧为传入的参数，=左侧为我们定义的属性名称

    # 行为
    def eat(self):
        print('%s在吃饭' % self.userName)  # 格式化参数的时候，指定为self的某项参数

    def run(self):
        print(f'{self.userName}开始跑步')  # 输出的另一种写法


p1 = Person('张三', 18)  # 创建一个名为p1的实例，name参数是张三，age参数是18
print(p1.userName, p1.age)  # 张三 18。输出时要指定好是哪个实例的什么属性
p1.eat()  # 调用
p1.run()

p2 = Person('李四', 19)
print(p2.userName, p2.age)  # 李四 19

• 清除内容

清除内存，清空内容，也可以在实例中手动调用 del 删除实例
关键词：def __del__(self):
del self

def __del__(self):
         print(f"{self.name}，原地去世")


del self    # 销毁对象

• 对象的引用

# 基本数据类型：修改的时候并未修改原来的值，而是得到一个新的值
# 数据存储在同一空间。不需要地址连接
str = 'hello word'
print(str.replace('word', 'python'))  # hello python.将word换成python，生成一个新的字符串，并未修改str本身
print(str)  # hello word

# 引用型数据类型：修改的时候，修改了原来的值
# 变量和数据存储在不同空间，通过地址进行连接
list = ['a', 'b']
list[0] = 'c'  # 通过地址改变list中的数据，修改数据本身
print(list)  # ['c', 'b']。

list1 = ['张三', '李四', '王五']
list2 = ['赵六', '周七']
list2 = list1  # 因为数据通过地址连接，当list2=list1的时候，list2、list1的地址也就相同了
list2[0] = '林青霞'  # 所以此时不管修改谁的地址，修改的都是同一组数据
print(list1, list2)  # ['林青霞', '李四', '王五'] ['林青霞', '李四', '王五']

我们创建的对象，也属于引用类型

class Name:  # 声明类Name
    def __init__(self, name, age):  # 设置实例属性
        self.name = name
        self.age = age


p1 = Name('老刘', 30)  # 创建对象p1
p2 = Name('老张', 20)  # 创建对象p2
print(p1, p2)  # 存储地址<__main__.Name object at 0x00000292FCCDB6A0> <__main__.Name object at 0x00000292FCCDB640>
print(p1.name, p2.name)  # 老刘 老张
p1 = p2  # 让p1引用p2的地址
print(p1.name, p2.name)  # 老张 老张
p2.name = '老李'  # 将地址里的name更换
p1.age = 40  # 将地址里的age更换
# 所有引用都指向p2
print(p1.name, p2.name, p1.age, p2.age)  # 老李 老李 40 40

• 对象字符串形式表示

class Name:  # 声明类Name
    def __init__(self, name, age):  # 设置实例属性
        self.name = name
        self.age = age

    def __str__(self):
        # 返回值---返回啥，打印啥
        return '名字：%s，年龄：%d' % (self.name, self.age)  # 名字：老刘，年龄：30 名字：老张，年龄：20


p1 = Name('老刘', 30)  # 创建对象p1
p2 = Name('老张', 20)  # 创建对象p2
print(p1, p2)  # 存储地址<__main__.Name object at 0x00000292FCCDB6A0> <__main__.Name object at 0x00000292FCCDB640>
print(p1.name, p2.name)  # 老刘 老张

• 案例：办事员办证应用

class BanShiYuan:  # 声明类
    def __init__(self, name):  # 设置实例的属性
        self.name = name

    def banzheng(self, money):  # 声明函数
        if money >= 3000:
            print('没有问题，过两天来拿')
        else:
            print('我们都是守法公民，没有灰色方案')


zs = BanShiYuan('张三')
zs.banzheng(2500)  # 我们都是守法公民，没有灰色方案
zs.banzheng(3100)  # 没有问题，过两天来拿

• 面向对象三大特性

• 属性和函数的封装

如果有一个对象，当需要对其进行属性修改的时候，有两种方法

对象名.属性名=数据----->直接修改
对象名.方法名()----->间接修改

为了更好的保存属性安全，即不能随意修改，一般的处理方法为

将属性定义为 私有属性
添加一套可以调用的方法，供调用。
需要调用私有属性时，需要设置一个共有函数调用这个私有属性，传递参数

私有的属性：
不能通过对象直接调用，但是可以通过方法间接访问
一套get和set函数
私有的方法：
不能通过对象直接调用,只能内部调用。如果我们想要调用私有化函数 。
那么就需要调用普通函数在普通函数中去间接性的调用私有函数

class Teacher:
    def __init__(self, name, age):
        self.name = name
        # 在属性前加__，将属性封装起来，变成私有属性
        self.__age = age

    def teach(self):
        print('年龄为：%d的老师教学...' % self.__age)

    # 修改私有属性：先获取私有属性的值，再传参数进行赋值
    def getAge(self):  # 声明函数：获取__age的值
        return self.__age  # 返回__age的值

    def setAge(self, age):  # 声明函数：设置age的值
        self.__age = age  # 将传入的参数赋值给__age


t1 = Teacher('张三', 18)
t1.teach()  # 年龄为：18的老师教学...
t1.setAge(19)  # 传入要修改的参数
t1.teach()  # 年龄为：19的老师教学...

• 多态

• 继承.

• 继承的特点

继承的特点

class Animal(object):  # object默认是所有类的父类,也叫基类、超类
    color = 'red'

    def run(self):
        print('跑')

    def eat(self):
        print('吃')


class Dog(Animal):  # 继承Animal，父类为Animal
    pass


class Cat(Animal):
    pass


d1 = Dog()
print(d1.color)  # red
d1.run()  # 跑

• 继承函数的重写

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def study(self):
        print(f'姓名是：{self.name},年龄是：{self.age}')


class Teacher(Person):  # 继承Person中的函数
    def __init__(self, name, age, gender, address):  # 子类可以比父类的属性更多一些
        super().__init__(name, age)  # 父类已经有的函数可以直接调用父类的函数进行初始化
        self.gender = gender
        self.address = address

    # 函数的重写
    def study(self):
        super().study()  # 调用父类的study函数。关键词：study()
        print('老师有老师的学习方法')


t1 = Teacher('张三', 18, '男', '北京')
t1.study()  # 如果重写则调用自己所在类中的函数
print(t1.gender)
print(t1.address)

• 多继承

class Ma:
    def meat(self):
        print('马吃草')


class Lv:
    def leat(self):
        print('驴吃草')


class Luo(Ma, Lv):  # 创建继承多个父类为Ma, Lv的子类Luo。可以获得多个父类中的属性
    pass


l = Luo()
l.meat()
l.leat()

• 类属性和对象属性

类属性：可以通过类名或者对象调用，对象可以修改自己的类属性，但是不能改全局，想要修改整体的属性，通过类名修改

对象属性：不能通过类名调用

class Person:
    country = '中国'  # 类属性：在类的内部直接定义，类属性，所有的对象默认都拥有类属性

    def __init__(self, name, age):  #
        self.name = name
        self.age = age

    def printInfo(self):
        print(f'国家是：{self.country},姓名是：{self.name},年龄是：{self.age}')


# 查看类属性是否每个对象都拥有：有的
p1 = Person('张三', 18)
p1.printInfo()  # 国家是：中国,姓名是：张三,年龄是：18

• 类方法和静态方法

类方法意义：方便调用
关键词：@classmethod

静态方法
关键词：@staticmethod

class Person:
    country = '中国'  # 类函数

    def run(self):  # 对象函数，只能由对象调用
        print('跑。。。')

    # 定义类函数--可以通过类名直接调用，也可以通过对象调用
    @classmethod  # 声明函数是类函数
    def printA(cls):
        print('A......')

    @staticmethod  # 定义静态函数:可以通过类名直接调用，也可以通过对象调用,不需要写任何参数
    def printB():
        print('B.........')


Person.printA()  # 类名直接调用
p1 = Person()
p1.printA()  # 对象直接调用
# Person.run() 报错。对象函数只能由对象调用
Person.printB()  # 类名直接调用
p1.printB()  # 对象直接调用

• 案例-工具类

# 验证手机号长度时11位  并且要求 13，15，18开头的手机号才可以
# 判断邮箱是否合法，
# def checkEmail(self,email):
# 验证邮箱中是否包含 @   in  再判断是否是以.com  .cn结尾
#
# 判断用户名不能为空的方法
class Utils:
    # 检查手机号
    def checkPhoneNumber(self, num):
        if len(num) == 11:
            if num.startswith("13") or num.startswith("15") or num.startswith("18"):
                # 合格
                return True
        # 默认返回值为False
        return False

    # 检查邮箱
    def checkEmail(self, email):
        if "@" in email:
            if email.endswith(".com") or email.endswith(".cn"):
                return True
        # 默认返回值为False
        return False

    # 判断用户名不能为空的方法,如果为空，返回True，否则返回False
    def isEmpty(self, str):
        if str == None:
            return True
        if str == "":
            return True
        if str.strip() == "":
            return True
        return False


if __name__ == '__main__':
    utils = Utils()
    print(utils.checkEmail("111@qqqqq.com"))
    print(utils.checkEmail("111.com"))
    print(utils.checkPhoneNumber("15330276178"))
    print(utils.checkPhoneNumber("1533026178"))
    print(utils.isEmpty("    "))#True
    print(utils.isEmpty(None))#True