本文主要是介绍day22面向对象编程思想，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

day22面向对象编程思想

1、面向过程

面向过程：
核心是“过程”二字
过程的终极奥义就是将程序流程化
过程是“流水线”，用来分步骤解决问题的
面向对象：
核心是“对象”二字
对象的终极奥义及时将程序“整合”  
对象是“容器”，用来盛放数据和功能的

1.1类的定义和对象的产生

'''
	驼峰体命名：大驼峰，小驼峰
		大驼峰：UserName ==> 类名推荐使用
		小驼峰：userName
		下划线的命名：user_name 除类名外推荐使用
		
		类名的命名：大驼峰
		class 类名（）
			pass
			
		是先有类还是先有对象？
			1.现实中:
				先有对象，在有类
			2.在程序中：
				必须要先定义类，在调用类得到的对象

'''
定义类：
class Student():
	school = "SH"
    
    def choose_course(sth_obj,course)
    	pass
    print(123)
    '''
    	定义类发生了几件事：
    		1.立即执行类体代码
    		2.产生一个类的名称空间，把类体中的属性名和函数名都扔到一个大字典中
    		3.把类的名称空间绑定给__dict__  类名：__dict__
    
    '''

2、类

代码1：
    class Student:
        stu_school = 'oldboy'
        def tell_stu_info(stu_obj):
            print('学生信息：姓名：%s 年龄：%s 性别：%s'%(
                stu_obj['stu_name'],
                stu_obj['stu_age'],
                stu_obj['stu_gender'],
            ))
        def set_info(stu_obj,x,y,z):
            stu_obj['stu_name'] = x
            stu_obj['stu_age'] = y
            stu_obj['stu_gender'] = z
# 属性访问的方法
print(Student.stu_school)  # 访问数据类型
print(Student.set_info)    # 访问函数属性
代码2：
    def init(obj,x,y,z):
        obj.stu_name = x
        obj.stu_age = y
        obj.stu_gentre = z

    class Student:
        stu_school = 'oldboy'
        count = 0

        def __init__(obj, x, y, z):
            Student.count+=1
            obj.stu_name = x
            obj.stu_age = y
            obj.stu_gentre = z

        def tell_stu_info(stu_obj):
            print('学生信息：姓名：%s 年龄：%s 性别：%s'%(
                stu_obj['stu_name'],
                stu_obj['stu_age'],
                stu_obj['stu_gender'],
            ))
        def set_info(stu_obj,x,y,z):
            stu_obj['stu_name'] = x
            stu_obj['stu_age'] = y
            stu_obj['stu_gender'] = z
    调用类的过程，又称为实例化，发生了三件事
    1、先产生一个空对象
    2、python会自动调用类中的__init__方法然后将空对象已经调用类时括号内传入的参数一同传给init
    3、返回初始化好的对象
    stu1_obj =Student('meng',18,'male')
    print(stu1_obj.__dict__)
    print(stu1_obj.count)
总结__init__方法
'''
    1、会在调用时自动触发执行，用来为对象初始化自己独有的数据
    2、__init__内应该存放是为对象初始化属性的功能，但是是可以存放任意其他代码，
    想要在类调用时就立刻执行的代码都可以放到该方法内
    3、__init__方法必须返回None
'''
代码3：
    # 1. 绑定给对象的
    class Student():
        school = 'SH'
        def __init__(self,name,age):
            self.name =name
            self.age = age

        # 在类中书写方法，默认绑定给对象使用的
        def tell_info(self):
            print('%s-%s'%(self.name,self.age))

        def func(self):
            print('func')
    obj = Student('meng',18)
    obj.tell_info()
    obj.func()

3、property

案例1：
class People:
    def __init__(self,name,weight,height):
        self.name = name
        self.weight = weight
        self.height = height
    @property #加上了就不用再调用了===》print(obj1.bmi（）)
    def bmi(self):
        return self.weight / (self.height ** 2)

obj1 = People('meng',60,1.75)
print(obj1.bmi)
定义函数的原因：
1.从bmi的公示上看，bmi应该是触发功能计算得到的
2、bmi是随着身高、体重而动态变化的，不是一个固定的值，每次需要重新计算得到

4、继承

1、什么是继承
    1）继承是一种创建新类的方式，新建的类可称为子类或者派生类，父类又可称为基类或超类，子类可以遗传父类的属性
    2）需要注意的是：python支持多继承
    3）在python中、新建的类可以继承一个或者多个父类
2、为什么要用继承
	类解决的是对象与对象之间的代码冗余问题
	用来解决类与类之间代码冗余问题

3、ps1：在python2中有经典类和新式类之分
新式类：继承了object类的子类，以及该子类的子子孙孙类
经典类：没有继承object类的子类，以及该子类的子子孙孙类
ps2：在python3中没有继承任何类，那么都会默认object类，所以python3中所有的类都是新式类
"""
学会子类如何使用父类的属性
1. 指名道姓：People.__init__(self, name, age, gender)
2. super():
"""
代码1：
    class People():
        school = 'SH'

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

    class Student(People):
        def __init__(self,name,age,genter,course=None):
            if course is None:
                course =[]
            self.course = course
            People.__init__(self,name,age,genter)

        def choose_course(self,course):
            self.course.append(course)
            print('%s选课成功%s'%(self.name,self.course))

    stu =Student('meng',19,'male')
    print(stu.school)
    print(stu.name)
    print(stu.age)
    print(stu.genter)
    
   # 补充：
    class Teacher(People):
        def __init__(self, name, age, genter, level):
            self.level = level
            People.__init__(self, name, age, genter)

        def score(self, stu_obj, score):
            stu_obj.score = score
            print('%s给%s打了%s分' % (self.name, stu_obj.name, score))


    tea = Teacher('meng', 18, 'male', 11)
    print(tea.name)
    print(tea.age)
    print(tea.genter)
    print(tea.level)

5、单继承下的属性查找

例子1：
    class Foo():
        def f1(self):
            print('Foo.f1')

        def f2(self):
            print('Foo.f2')  # 先输出
            self.f1()

    class Bar(Foo):
        def f1(self):       # 后输出
            print('Bar.f1')


    obj = Bar()
    obj.f2()
    结果：Foo.f2，Bar.f1

例子2：
    class Foo:
        def __f1(self):
            print('Foo.f1') # 后执行

        def f2(self):
            print('Foo.f2') # 先执行
            self.__f1()

    class Bar(Foo):
        def f1(self):
            print('Bar.f1')

    obj = Bar()
    obj.f2()
# 总结：找一个值先在对象里找，然后再去类找

6、多继承下的属性

# 新式类中属性查找按照   广度优先查询
# 经典类中属性查找按照   深度优先查询

class G(object):
    # def test(self):
    #     print('from G')
    pass

class F(G):
    # def test(self):
    #     print('from F')
    pass


class C(F):
    # def test(self):
    #     print('from C')
    pass


class D(G):
    # def test(self):
    #     print('from D')
    pass


class E(G):
    # def test(self):
    #     print('from E')
    pass


class H():
    def test(self):
        print('from H')
    pass


class B(E, H):
    # def test(self):
    #     print('from B')
    pass


class A(B, C, D):
    # def test(self):
    #     print('from A')

    pass


f1 = A()
f1.test()

7、super()和mro()

class A:
    def test(self):
        print('A---->test')
        super().aaa()


class B:
    def test(self):
        print('B---->test')

    def aaa(self):
        print('B---->aaa')


class C(A, B):
    def aaa(self):
        print('C----->aaa')


# c = C()
# c.test()  # 打印结果:
# print(C.__mro__)

a = A()
# a.test()
print(A.__mro__)

8、多态与多态性

# 多态：一种事物的多种形态
水：固态水，液态水， 气态水

动物：人，猪， 狗
# 继承， 子类使用父类的属性
多态类中的继承：不是让子类遗传父类的属性

多态带来的特性：在不考虑对象的数据类型的情况下，直接调用方法

9、绑定方法

一、绑定方法：特殊之处就在于将调用者本身当做第一个参数自动传入
1.绑定给对象的方法：调用者是对象，自动传入的是对象
2.绑定给类的方法：调用者类，自动传入的是类
3.应用场景：提供一种新的造对象的方式，来自于配置文件之类的
例子：
impore settings
class Mysql:
	def __init__(self,ip,port):
		self.ip = ip
    	self.port = port
    
    def func(self):
		print('%s:%s'%(selp.op,selp.port))
    @classmethod #将下面的函数装饰成绑定给类的方法
    def from_conf(cls):
		print(cls)
        return cls(settings.ip,settings.port)
obj1 = Mysql(111,3303)

10.非绑定方法

一、非绑定方法===># 静态方法
用途:不加入任何装饰器的情况下，默认绑定给对象的。
    不需要类和对象
class Mysql:
	def __init__(self,ip,port):
        self.nid = self.create_id()  # 自动生成一个id
        self.ip = ip
        self.port = port
    @staticmethod  # 将下述函数装饰成一个静态方法
    def create_id(x,y,z):
        print(x,y,z)
        import uuid
        return uuid.uuid4()
obj1 = Mysql(111,3303)
print(Mysql.create_id)
Mysql.create_id(1,2,3)
obj1.create_id(4,5,6)
        

这篇关于day22面向对象编程思想的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！