• 面向过程概念
• 面向对象概念
• 类的定义和对象的产生
• 对象独有的数据
• 属性的查找顺序

面向过程概念

面向过程(Procedure Oriented)是一种以过程为中心的编程思想。 这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。 与面向对象明显的不同就是封装、继承、类。

优点：把复杂的问题简单化，进而流程化
缺点：扩展性差
使用场景：对扩展性要求不高的地方

eg：
# 注册功能保存用户信息
def get_info():
    username = input('username:')
    password = input('password:')
    email = input('email:')
    return {'username': username,
            'password': password,
            'email': email, }


def check_info(userinfo):
    flag = False
    if len(userinfo['username']) == 0:
        print('username必输')
        flag = True
    if len(userinfo['password']) == 0:
        print('password必输')
        flag = True
    if len(userinfo['email']) == 0:
        print('email必输')
        flag = True
    return {'userinfo': userinfo,
            'flag': flag, }


def save_info(param):
    if not param['flag']:
        import json
        with open('userinfo.txt', 'w', encoding='utf8') as f:
            json.dump(param['userinfo'], f)


def main():
    userinfo = get_info()
    param = check_info(userinfo)
    save_info(param)


if __name__ == '__main__':
    main()

面向对象概念

面向对象 ( Object Oriented ) 是将现实问题构建关系，然后抽象成 类 ( class)，给类定义属性和方法后，再将类实例化成 实例 ( instance ) ，通过访问实例的属性和调用方法来进行使用。

# 在python中，一切皆对象
1. 在程序中：	
    对象就是盛放数据'属性'和'功能'的容器
        #属性：简单理解就是变量
        #功能：简单理解就是函数，或者叫方法
2. 在生活中:
    对象就是'特征'与'技能'的结合体
            
	优点：扩展性强    
	缺点：编程复杂度高
    使用场景：对扩展性要求高的地方

eg：
# 以学生选课系统为例
def choose_course(stu_dict, course):
    stu_dict['courses'].append(course)
    print('%s选课%s成功，选课信息：%s' % (stu_dict['name'], course, stu_dict['courses']))


stu = {
    'name': 'kevin',
    'age': 18,
    'gender': 'male',
    'courses': [],
    'choose_course': choose_course, }

stu1 = {
    'name': 'muhammad',
    'age': 28,
    'gender': 'male',
    'courses': [],
    'choose_course': choose_course, }

print(stu['choose_course'])  # <function choose_course at 0x0000017744016160>
stu['choose_course'](stu, 'python')  # kevin选课python成功，选课信息：['python']
stu1['choose_course'](stu1, 'linux')  # muhammad选课linux成功，选课信息：['linux']

类的定义和对象的产生

对象：'特征'与'功能'的结合体
类：多个相似特征与相似功能的结合体

'''站在不同的角度，分的种类不一样
一个人          对象（有着自己的属性）
一群人         类（人类）有着人都有的相同的属性
'''

• 先有类还是先有对象

1. python中
        	一定是先定义类，调用类产生对象
2. 生活中
			先有对象，在有类

• 类的语法结构

        class 类名():
             pass

    # 1. 类名的命名遵循变量的命名规范
    # 2. 类名的首字母一般大写
    # 3. 如果类名存在多个单词，一般是大驼峰格式

• 类的定义与调用

#类在定义阶段就会执行类体代码，产生一个类的 名称空间
    class Student():
        # 定义一个特征
        school = 'SH'  # 属性
        country = 'China'
 
    # 函数写到类里面叫方法
    def choose_course(stu_dict, course):
        stu_dict['courses'].append(course)
        print('%s选课成功%s' % (stu_dict['name'], stu_dict['courses']))

"""
    定义类发生的几件事情？
        1. 定义类，会立马执行类体代码
        2. 产生类的名称空间，并且把类中的属性和方法名字丢在类的名称空间中，其实就是丢在大字典里
        3. 把类的名称空间绑定给__dict__
"""

• 如何产生对象（实例化对象）

'''调用类产生对象，得到的对象就是一个空对象，空字典'''
stu1 = Student()  # 类名()就会产生一个对象
stu2 = Student()  # 类名()每执行一次都会产生一个全新的对象
print(stu1.__dict__) # {} 查看对象的名称空间 对象空的名称空间
print(stu2.__dict__) # {} 对象空的名称空间
print(stu1.school)#SH 对象有资格访问类里面所有的东西
print(stu2.school)#SH

• 如何查看类、对象的名称空间

'''查看方式：类名\对象名.__dict__'''
print(Student.__dict__)
print(Student.__dict__.get('choose_course'))#在面向对象中类和对象访问数据可以使用句点符的方式
print(Student.choose_course)#简写上面代码
print(stu1.__dict__)

对象独有的数据

class Student():
    school ='SH'

    def __init__(self,name,age,gender):
        self.name=name#等价于stu.__dict__['name'] = 'kevin'
        self.age=age
        self.gender=gender

    def choose_course(self, course, ):
        print("%s选择了%s" % (self.name, course))

stu=Student('kevin',18,'male')
stu1=Student('cathy',27,'female')
print(stu.__dict__)#{'name': 'kevin', 'age': 18, 'gender': 'male'}
print(stu1.__dict__)#{'name': 'cathy', 'age': 27, 'gender': 'female'}
print(stu.choose_course('python'))#kevin选择了python

"""
    调用类会自动的触发类里面的__init__方法，然后会把得到的对象本身当成第一个参数自动传递
"""

属性的查找顺序

与字典增删改查用法类似

• 类属性的查找

顺序：直接在类中查找，找不到直接报错

class Student():
    school = 'SH'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age 
        self.gender = gender 
        
print(Student.school)#SH

# 增加属性
Student.country ='CHINA'
print(Student.__dict__)
#{'__module__': '__main__', 'school': 'SH', '__init__': <function Student.__init__ at 0x000001E78A7A3040>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'country': 'CHINA'}


# 修改
Student.school = 'beijing'
print(Student.__dict__)

# 删除
del Student.school
print(Student.__dict__)

• 对象属性

顺序：先从对象自己的名称空间中找属性，再从产生这个对象的类中查找，找不到就报错

class Student():
    school = 'SH'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age 
        self.gender = gender 
        
stu = Student('kevin', 20, 'male')
print(stu.__dict__)#{'name': 'kevin', 'age': 20, 'gender': 'male'}

# 查看
print(stu.school)# SH 对象本身没有school属性 到类属性中查找返回结果
print(stu.__dict__['name'])#kevin
print(stu.name)#kevin
print(stu.name1)# Error  先从对象自己的属性里面去查找，再到类属性查找，没有则直接报错


# 增加
stu.school='BJ'
print(stu.__dict__)#{'name': 'kevin', 'age': 20, 'gender': 'male', 'school': 'BJ'}
print(stu.school)# BJ

# 修改
stu.name = 'xxxx'
print(stu.__dict__)

# 删除
del stu.name
print(stu.__dict__)

• 例

# 题：定义一个类出来，产生一堆对象，定义一个计数器，记录一共产生了多少个对象？
class Student():
    school = 'SH'
    count = 0
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Student.count+=1## 每初始化一个实例，就让count加1

stu=Student('kevin',18)
stu1=Student('jack',17)
stu2=Student('tony',19

print(Student.count)# 3