面向对象之封装

今日内容详细

面向过程编程

#在编程中，面向过程和面向对象是编程的两大编程思维

什么是面向过程？
	面向过程就是在我们编写功能的时候，把每一步需要做的事情逐一写出来
    ps:
        比如：我们要去接一杯水
        1.拿起杯子,下一步就要想去哪接水
        2.比如厨房，比如饮水机
        3.接完水之后干什么
 生活中很多的例子都是面向过程的

优点：复杂的问题简单化，进而流程化
缺点：扩展性差，牵一发而动全身
应用场景：一般用在对扩展性要求比较差的情况

使用面向过程写一个注册的案例来体会面向过程的优缺点：
1.先让用户输入用户名和密码
2.验证参数
3.直接把数据写入文件中

#比如验证账号和密码长度是否是我设定的长度
#length=5
def register():
    username=input(':').strip()
    password=input(':').strip()
    email=input(':').strip() #如果后续加上email那么后面很多地方都要逐一修改
    return {
        'name':username,
        'pwd':password,
        'email':email,
    }

def verify_len6(userinfo):
    flag=True
    if len(userinfo['name']) != 5:
        print('err')
        flag=False
    if len(userinfo['pwd']) !=5:
        print('err')
        flag=False
    if len(userinfo['email']) !=5: #这里就要加功能就很不方便
        print('err')
        flag=False
    return {
        'flag':flag,
        'userinfo':userinfo,
    }

def write_date(data):
    if data['flag']:
        with open('userinfo.txt','w',encoding='utf-8') as w1:
            import json
            json.dump(data['userinfo'],w1)

userinfo=register()
data=verify_len6(userinfo)
data=write_date(data)

面向对象编程

#什么是面向对象呢？
	一种认识世界，分析世界的方法论，将万事万物抽象为各种对象

面向对象它是一种编程的思想，不是一门新得技术栈
面向对象中对象是核心，必须搞明白什么是对象
'''在Python中一切皆对象'''

对象是什么？
	在生活中：
    	对象就是'特征'与'技能'的结合体
	在程序中：
    	对象就是盛放'数据属性'和'功能'的容器
优点：扩展性强
缺点：简单的问题复杂化了

举例：
系统中有哪些角色：
	学生，老师，管理员，选课功能...

版本一：

'''
学生选课系统，有哪些内容比如
学生姓名，学生年龄，学生性别，选的什么课
'''
# stu_name = 'zhangsan'
# stu_age = 20
# stu_gender = 'male'
# stu_course = []  # 课程列表
#
#
# def choice_courses(stu_name, stu_course, cources):
#     stu_course.append(cources)
#     print('%s选择了%s' % (stu_name, stu_course))
#
#
# choice_courses(stu_name, stu_course, 'ptyhon')
# choice_courses(stu_name, stu_course, 'c++')

# 版本二：
# 版本一如果需要多个用户选择，那么代码会非常乱
# 下面就可以把每个用户的信息或者属性封装起来成一个单独的字典，每个学生互相隔离开

# stu_dict = {
#     'name': 'jerry',
#     'age': 30,
#     'gender': 'female',
#     'course': [],
# }
#
# stu1_dict={
#     'name':'Wangwu',
#     'age':25,
#     'gender':'male',
#     'course':[],
# }
#
# def choice_course(stu_dict, courses):
#     stu_dict['course'].append(courses)
#     print(stu_dict)
#
#
# choice_course(stu_dict, 'python')
# #实现用户与用户之间隔离
# choice_course(stu1_dict,'c++')


#版本三：
    #在属性中调用函数，然后把自己传进去当参数
    #这个函数一定要在属性之前定义，否则在属性中调用函数，会找不到
    #这个就是面向对象编程，对象中有自己的属性和功能
def choice_course(stu_name,courses):
    stu_name['course'].append(courses)
    print(stu_name['course'])

stu_name={
    'name':'matu',  #属性
    'age':18,       #属性
    'course':[],    #属性
    'func':choice_course,  #功能
}
stu1_dict={
    'name':'matu',
    'age':18,
    'course':[],
    'func':choice_course,
}

stu_name.get('func')(stu_name,'python')
stu1_dict['func'](stu1_dict,'linux')
    
'''必须先定义类，然后调用类，再产生对象'''
'''谁调用函数，就把谁当作参数传进去'''

类的定义和对象的产生

对象：是特征与功能的结合体

'''站在不同的角度，分出来的类不一样'''

类：一系列相似的特征和相似的技能的结合体

到底是先有对象还是先有类？
1.生活中
	先有人，在有人类，那就是先有对象，在有类
2.程序中
	'''一定是先有类，然后调用类，产生对象'''

定义类语法：
Class 变量名(): #这个括号可加可不加
    pass

1.关键字是否Class来声明
2.Class后面写的是类名，类名的命名：一般情况下遵循变量的命名规范即可，类名一般首字母都要大写，(小写也行，但是不推荐)
3.如果你的类名比较长，推荐使用驼峰法，并且是大驼峰
4.类名后面的小括号不能省略

class func():
    country='china'  #类属性，其实就是变量
    position='sh'

    #函数如果在类中，称为方法
    def test_func(self):
        print(func.country)
'''
#定义类发生了哪些事情？
    1.类一旦定义完成，会立马执行类体代码
    2.会产生类的名称空间，其实就是一个大字典，然后把类中的名字都丢到类的名称空间去
    3.把类的名称空间绑定给类名__dict__中
'''

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

#如何产生对象？
#调用类产生对象
s1=func()
print(s1) #<__main__.func object at 0x000001AA6B014A30>  这个是一个类对象

#如何查看对象的名称空间
print(s1.__dict__)

#调用类的过程也是实例化的过程，得到的对象也称为一个实例

定制对象自己独有的属性

默认情况下，调用一个类产生一个对象，它是一个空对象，没有任何的数据


class Student():

    '''它有特殊的含义，在类里面必须叫__init__,然后调用类的时候自动触发执行
        类里面不一定有__init__方法，如果需要提前定制对象的属性，就写这个init方法
    '''
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    ##函数如果写在类中，我们称为方法
    def choice_course(self):
        print(self.name)


stu1 = Student()    #对象与对象之间是相互隔离的
'''我们需要给空对象定制自己独有的属性
    一般情况下，双下划线开头的属性，方法等都不推荐使用
'''
stu1.__dict__['name']='kevin' #这种的方法不推荐使用

'''我们推荐下面的点语法'''
stu1.name='kevin'
stu1.age=20
stu1.gender='male'
print(stu1.choice_course())
print(stu1.__dict__)

stu2=Student()
print(stu2.__dict__)


class Person():
    school = 'sh'

    ##它有特殊的含义，在类里面必须叫__init__,然后调用类的时候自动触发执行
    ##类里面不一定有__init__方法，如果需要提前定制对象的属性，就写这个init方法

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

    ##函数如果写在类中，我们称为方法
    def choice_course(self):
        print(self.name)


stu = Person('kevin',19, 'male')
stu.choice_course()

属性的查找顺序

有类属性，对象自己的属性

1.显示类属性的增删改查
	class Person():
    school = 'sh'

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

    def choice_course(self):
        print(self.name)


stu = Person('kevin',19, 'male')
print(Person.__dict__['school']) #类名+属性__dict__+属性名
Person.x=666 #在类中，如果没有这个属性就是增加
Person.school='China' #如果有这个属性就是改
del Person.school #删除
print(Person.school)


2.对象属性的增删改查
	class Person():
    school = 'sh'

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

    def choice_course(self):
        print(self.name)


stu = Person('kevin',19, 'male')
#1.查看对象属性
print(stu.name)
print(stu.age)
print(stu.gender)

#增加
stu.x=666
print(stu.x)

#改
stu.x=888
print(stu.x)

#删除
del stu.x
print(stu.x)

课堂练习

定义一个类，产生一堆对象，然后定义一个计数器，记录产生了多少个对象

class Person():
    count=0

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        Person.count+=1   
        #这里不能写自己，因为每次把自己传进去，自己调自己每次还是1，要写类的count


stu = Person('kevin',19, 'male')
stu1=Person('jerry',10,'male')
stu2=Person('mali',30,'female')
stu3=Person('tanl',25,'male')

print(stu.count)