面向对象16

1. 面向对象编程思想介绍
2. 类与对象的基本使用
3. 属性查找
4. 绑定方法

面向过程的编程思想

1 面向过程的编程思想

核心是'过程'二字，过程即解决问题的步骤，即先干什么，再干什么。。。。

基于面向过程编写程序就好比在设计一条流水线，是一种机械式的思维方式。



2、总结优缺点：

优点：复杂的问题流程化，进而简单化

缺点：修改一个阶段，其他阶段都有可能需要做出修改，牵一发而动全身，即扩展性极差

应用：用于扩展性要求低的场景

#1、步骤一：拿到用户输入的合法的信息：用户名、密码、余额、年龄
db_path='db.txt'
def get_uname():
　　while True:
　　　　uname=input('用户名>>：').strip()
　　　　if not uname.isalpha():
　　　　print('\033[45m用户名必须为英文字母...\033[0m')
　　　　continue
　　with open(r'%s' %db_path,'r',encoding='utf-8') as f:
　　　　for line in f:
　　　　uinfo=line.strip('\n').split(',')
　　　　if uname == uinfo[0]:
　　　　print('\033[45m用户名已存在...\033[0m')
　　　　break
　　else:
　　　　return uname

def get_pwd():
　　while True:
　　　　pwd1=input('请输入密码>>: ').strip()
　　　　pwd2=input('再次输入密码>>: ').strip()
　　　　if pwd1 == pwd2:
　　　　　　return pwd1
　　　　else:
　　　　　　print('\033[45m两次输入的密码不一致，请重新输入...\033[0m')

def get_bal():
　　while True:
　　　　bal=input('请输入余额: ').strip()
　　　　if bal.isdigit():
　　　　# bal=int(bal)
　　　　　　return bal
　　　　else:
　　　　print('\033[45m钱必须是数字，傻叉...\033[0m')

def get_age():
　　pass

#2、步骤二：写入文件
def file_hanle(uname,pwd,bal,age):
　　with open(r'%s' %db_path,'a',encoding='utf-8') as f:
　　　　f.write('%s,%s,%s,%s\n' %(uname,pwd,bal,age))

# 注册功能
def register():
#步骤1：
　　uname=get_uname() #拿到合法的用户名
　　pwd=get_pwd() #拿到合法的密码
　　bal=get_bal() #拿到合法的余额
#步骤2：
　　file_hanle(uname,pwd,bal) #写入文件

1. 面向对象编程思想介绍

面向过程的编程思想:

    核心过程二字,过程指的是解决问题的步骤,即先干什么\再干什么\后干什么
    基于该思想编写程序就好比在设计一条流水线,是一种机械式的思维方式

    优点:复杂的问题流程化\进而简单化
    缺点:可扩展性差

面向对象的编程思想:

    核心是对象二字,对象是特征与技能的结合体
    基于该思想编写程序(脑子始终想的是对象二字)就好比在创造一个世界,世界
    是由一个个对象组成,在上帝眼里任何存在的事物都是对象,任何不存在的事物
    也都可以造出来,是一种上帝式的思维方式

    优点: 可扩展性强
    缺点: 编程的复杂度要高与面向过程


类:
    对象是特征与技能的结合体,而类则是一系列对象相同的特征与技能的结合体
    强调:
        1.对象是具体存在的事物,而类则一个抽象的概念
        2.站在不同的角度总结出的类与对象是不同的


    在现实世界中:先有一个个具体存在的对象,然后随着人类文明的发展才总结
               出类的概念

    在程序中: 先定义类,后调用类来产生对象


站在老男孩选课系统的角度
总结出现实世界中的老男孩学生对象:
    学生对象1
        特征
            school='oldboy'      
            name='李铁蛋'            
            age=18            
            sex='male'
        技能
            选课

    学生对象2
        特征
            school='oldboy'            
            name='赵钢弹'            
            age=38            
            sex='female'
        技能
            选课

    学生对象3
        特征
            school='oldboy'            
            name='刘银弹'            
            age=28            
            sex='male'
        技能
            选课

    老师对象1
        特征
            school='oldboy'            
            name='Egon'            
            age=18            
            sex='male'            
            level=10
        技能
            打分

总结现实世界中的老男孩学生类
    相同的特征
        school='oldboy'
    相同的技能
        选课

#在程序中
#1. 先定义类
class OldboyStudent:
    #相同的特征
    school = 'oldboy'

    #相同的技能
    def choose_course(self):
        print('choosing course')

    # print('===>>>')
#类是一系列对象相同的特征(变量)与技能(函数)的结合体,即类体中最常见的就是变量与函数的定义
# 但其实类体中是可以存在任意python代码的
# 类体代码会在类定义阶段立即执行,会产生一个类名称空间,用来将类体代码执行过程中产生的名字都丢进去,
查看方式如下:
# print(OldboyStudent.__dict__) # 查看类的名称空间
# print(OldboyStudent.school) #print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.choose_course)
# OldboyStudent.school='OLDBOY' #OldboyStudent.__dict__['school']='OLDBOY'
# OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China'
# del OldboyStudent.country # del OldboyStudent.__dict__['country']
# print(OldboyStudent.__dict__)

OldboyStudent.choose_course(123123)
# 总结:
#1. 类本质就是一个名称空间,或者说是一个用来存放变量与函数的容器
#2. 类的用途之一就是当做名称空间从其内部取出名字来使用
#3. 类的用途之二是调用类来产生对象



'''
学生对象1
        特征
            school='oldboy'
            name='李铁蛋'
            age=18
            sex='male'
        技能
            选课

    学生对象2
        特征
            school='oldboy'
            name='赵钢弹'
            age=38
            sex='female'
        技能
            选课

    学生对象3
        特征
            school='oldboy'
            name='刘银弹'
            age=28
            sex='male'
        技能
            选课
'''

class OldboyStudent:
    #相同的特征
    school = 'oldboy'

    #相同的技能
    def choose_course(self):
        print('choosing course')

#2. 后调用类来产生对象:
# 调用类的过程称之为类的实例化,调用类的返回值称之为类的一个对象/实例


# 调用类发生了?
# 1. 会产生一个对象,然后返回

stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()

# print(stu1.__dict__)   {}
# print(stu2.__dict__)   {}
# print(stu3.__dict__)   {}


# 为对象定制自己独有的特征
'''
# name='李铁蛋'
# age=18
# sex='male'
stu1.name='李铁蛋'
stu1.age=18
stu1.sex='male'

print(stu1.__dict__)   {'name': '李铁蛋', 'age': 18, 'sex': 'male'}

# name='赵钢弹'
# age=38
# sex='female'
stu2.name='赵钢弹'
stu2.age=38
stu2.sex='female'

print(stu2.__dict__)

# name='刘银弹'
# age=28
# sex='male'
stu3.name='刘银弹'
stu3.age=28
stu3.sex='male'

print(stu3.__dict__)
'''

# 为对象定制自己独有的特征,简化方案一:
'''
def init(obj,name,age,sex):
    obj.name = name
    obj.age = age
    obj.sex = sex

# stu1.name='李铁蛋'
# stu1.age=18
# stu1.sex='male'
init(stu1,'李铁蛋',18,'male')  

# stu2.name='赵钢弹'
# stu2.age=38
# stu2.sex='female'
init(stu2,'赵钢弹',38,'female')

# stu3.name='刘银弹'
# stu3.age=28
# stu3.sex='male'
init(stu3,'刘银弹',28,'male')

print(stu1.__dict__)     {'name': '李铁蛋', 'age': 18, 'sex': 'male'}
print(stu2.__dict__)
print(stu3.__dict__)    
'''


# 为对象定制自己独有的特征,简化方案二:
class OldboyStudent:
    #相同的特征
    school = 'oldboy'

    #           stu1,'李铁蛋',18,'male'
    def __init__(obj, name, age, sex):
        obj.name = name #stu1.name='李铁蛋'
        obj.age = age   #stu1.age=18
        obj.sex = sex   #stu1.sex='male'

    #相同的技能
    def choose_course(self):
        print('choosing course')

# 调用类发生了
# 1. 先产生一个空对象stu1,然后返回
# 2. 触发类中函数__init__的执行,将对象连同调用类括号内指定的参数一同传入__init__(stu1,'李铁蛋',18,'male')

stu1=OldboyStudent('李铁蛋',18,'male') #__init__(stu1,'李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female') #__init__(stu2,'赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male') #__init__(stu3,'刘银弹',28,'male')


# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)

# 总结__init__的功能: 是在实例化时就为对象初始自己独有的特征
# 注意:不能有返回值
# 在调用变量时,先从对象自己的名称空间找,没有则去所属的类中找
# 类中定义的变量是所有对象共享的,对象可以来用,类也可以来使用,类一旦改变自己的数据属性的值,
  所有的对象都能感知到
#类中定义的变量是类的数据属性,类可以用,对象也可以用,大家都指向同一个内存地址,
 类变量值一旦改变所有对象都跟着变
#类中定义的函数是类的函数属性,类可以用,类来调用就是一个普通的函数,但其实类中定义的函数是给对象用的,
而且是绑定给对象用的
# 绑定???
class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name #stu1.name='李铁蛋'
        self.age = age   #stu1.age=18
        self.sex = sex   #stu1.sex='male'

    def choose_course(self,x): #self=stu1
        print('%s choosing course' %self.name)



stu1=OldboyStudent('李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male')

# 1. 类的函数: 该传几个参数就传几个
# print(OldboyStudent.__init__)  <function OldboyStudent.__init__ at 0x000002143B9519D8>
# print(OldboyStudent.choose_course)  <function OldboyStudent.choose_course at 0x000002143B951A60>
# OldboyStudent.choose_course(stu1)  李铁蛋 choosing course

# 2. 绑定方法,指向类的函数: 特殊之处是绑定给谁就应该由谁来调用,谁来调用就会将谁当做第一个参数
自动传入
# print(stu1.choose_course)  <bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x000002582EFE2668>>
# print(stu2.choose_course)  <bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x000002582EFE2668>>
# print(stu3.choose_course)  <bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x000002582EFE2668>>

# stu1.choose_course(123) 相当于#OldboyStudent.choose_course(stu1,123)
# stu2.choose_course(123)
# stu3.choose_course(123)

# 在python3中统一了类与类型的概念