面向对象编程

一 面向对象介绍

1.什么是面向对象

面向对象是一门编程思想！
面向对象之前我们先来说下面向过程。

面向过程编程思想：

核心是“过程”二字，过程指的是解决问题的步骤，即先干什么再干什么！
基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。
优点：
    将复杂的问题流程化，进而简单化
缺点：
    牵一发而动全身，程序的可扩展性差。

注意：编程思想仅仅是一门思想，与任何的技术无关。

面向对象编程思想：

注意：要将自己当做一个上帝！无所不能！
核心是“对象二字，对象指的是“特征与技能”的结合体。
基于该编程思想编写程序，就好比在创造世界，一种“上帝式”的思维方式。
优点：
    可扩展性高。
缺点：
    编写程序的复杂程度比面向过程高

2.如何产生对象：

1）什么是类？
    类指的是类型、类别。
    在两种角度去看待：
        现实世界中：
            现有一个个的对象，进过社会的文明发展，随之总结出类。
            对象是实际存在的，而类是抽象产生的。
        
        在程序中：
            必须先有类，再通过“调用类，产生对象”。
    对象指的是“特征与技能”的结合体，类指的是一系列“对象之间相同的特征与技能”的结合体。
    
2）如何定义类：
    如何写类并产生对象：
        先从现实世界中通过一个个对象总结出类。
        然后再定义类，后调用类产生对象。
        
    比如：选课系统：
        选课系统学生类：
            学生对象1：
                特征：
                    姓名：xxx1
                    性别：femal
                    年龄：95
                    学校：oldboy
                技能：
                    技术：python
                    学习：learn
                    选课：course
                
            学生对象2：
                特征：
                    姓名：xxx2
                    性别：femal
                    年龄：73
                    学校：oldboy
                技能：
                    技术：python
                    学习：learn
                    选课：course
3）定义语法类：
    class 关键字：帮你产生类的。
    
    class 类的名字：
            对象之间相同的特征
                学校
                school = 'oldboy'
                
            对象之间相同的技能
                python
                    def python():
                        pass
                
                learn
                    def learn():
                        pass
                
                course
                    def course():
                        pass

3.类

class 类名：
    特征
    技能
    
定义类名的规范：
    驼峰命名法

def foo(): # 函数名指向的是函数的内存地址
    pass

print（foo)  # <function foo at 0x000001CDFF119048>

# 定义清华大学学生类
class QinghuaStudent:  # 类名指向的是类的内存地址
    # 学生相同的特征
    # 在类中的特征 也称之为“属性”attribute
    school = 'qinghua'
    
    # 学生相同的技能
    # 注意：在类内部定义函数，会默认有一个参数self
    def learn(self):  # self此时当做一个形参
        print('learning...')
        
print(QinghuaStudent) # <class '__main__.OldboyStudent'>

# 查看类的名称空间
print(QinghuaStudent.__dict__)
print(QinghuaStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)

# 类提供一种特殊获取名字的方式“类名.名字”的方式
# 查
print(QinghuaStudent.school)
QinghuaStudent.learn('tank')

# 改
QinghuaStudent.school = 'Beida'
print(QinghuaStudent.school)


# 删
del QinghuaStudent.school


# 增
QinghuaStudent.school = 'Qinghua'
print(QinghuaStudent.school)
QinghuaStudent.old_student = 'HXC'
print(QinghuaStudent.old_student)


'''
函数的名称空间：
    在调用函数时产生，函数调用结束后销毁。
    
类的名称空间：
    在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。

'''

4.对象

对象的产生：
调用类产生对象
类名 + () 调用类产生对象

类的名称空间在定义时产生，对象的名称空间在调用类时产生。

调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。

class Student:
    # 学校
    school = 'qinghua'
    
    # 学习技能 ----> method ----> 方法
    def learn(self):
        print(self)
        print('learning')
        
        
        
stu1 = Student()
stu2 = Student()
stu3 = Student()
print(Student)
print(Student.school, 'Student...')
print(Student.learn, 'Student...')
Student.learn(123)
print('=' * 100)

print(stu1)  # <__main__.Student object at 0x0000017BFF8A5898>
print(stu1.school, 'stu1...')
print(stu1.learn, 'stu1...')
print(stu1)
# 对象调用方法时:会将对象当做第一个参数传入方法中。
stu1.learn()  

print('=' * 100)
print(stu2)  # <__main__.Student object at 0x0000017BFF8A5898>
print(stu2.school, 'stu2...')
print(stu2.learn, 'stu2...')
stu2.learn()

print('=' * 100)
print(stu3)  # <__main__.Student object at 0x0000017BFF8A5898>
print(stu3.school, 'stu3...')
print(stu3.learn, 'stu3...')
stu3.learn()

'''
由对象来调用类内部的函数，称之为对象的绑定方法。
    对象的绑定方法特殊之处：会将对象当做第一个参数传给该方法。
'''

class Student:
    # 学校
    school = 'qinghua'

    def __init__(self, name, sex, age):  # stu1, 'tank', 'male', 17
        print(self.__dict__)

        # 给对象添加新的属性
        self.name = name  # stu1.x = 'tank'
        self.sex = sex  # stu1.y = 'male'
        self.age = age  # stu1.z = 17

        # 查看当前对象的名称空间
        print(self.__dict__)

    # 学习技能   ----> method ---》 方法
    def learn(self):
        print(self)  #
        print('learning...')


# 查看类的名称空间
print(Student.__dict__)

# stu1 = Student()  # Student(stu1)  ---> __init__(self)  ----> self == stu1
# stu2 = Student()  # Student(stu2)  ---> __init__(self)  ----> self == stu2
# stu3 = Student()  # Student(stu3)  ---> __init__(self)  ----> self == stu3

# stu1.name = '江鹏'
# stu1.sex = 'female'
# stu1.age = 84
# print(stu1.name, stu1.sex, stu1.age)
#
# print(stu1)
# print(stu2)
# print(stu3)

'''
**** 想要在调用类时，为对象传入对象独有特征
***** __init__(self, name, sex, sge): # name --->tank , sex ---> male , age ---> 17
调用类时：会将对象当做第一个参数，与括号内所有的参数一并传给__init__()
stu1 = Student('tank', 'male', 17)

注意：凡是在内部定义的，__开头或者__结尾的方法都有特殊的意义。
在类内部定义的方法，在调用类时触发，会自动将对象本身当做第一个参数自动传入，与括号内所有的参数一并传给__init__()。
__init__(self):

'''

5.对象名字的查找顺序 ******

1）对象.属性，会先找对象自己的。
2）若对象没有，会去找类的。
3）若类没有，则会报错。

calss People:
    country = 'China'
    name = 'jason'
    
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        
    def run(self):
        print('running...')
        
obj1 = People('tank', 17, 'male')
print(obj1.name)  # tank  找对象自己的name属性
print(obj1.country)  # China  对象没有，找类中的属性
# AttributeError: 'People' object has no attribute 'jason'
# print(obj1.jason)  # 对象没有，类也没有，就会报错!
print(obj1.__dict__)
# 给对象的名称空间添加 country='中国' 属性
obj1.country = '中国'
print(obj1.__dict__)
print(People.__dict__)
print(obj1.country)
     

6.一切皆对象

在python中的一切皆对象

class Foo:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z


# 产生对象
# 调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
foo_obj = Foo(10, 20, 30)
print(foo_obj)


# number = 10   # int(10)  ----> __init__(number, 10)
# int(10)
# l1 ---> list对象
# l1 = list([1, 2, 3])
# dict()
# tuple((1, 2, 3))
# float
# str
# set
# bool
# enumerate
# bytes
# filter