第五章---面向对象---1.面向过程/2.面向对象/3.如何使用类/4.__init__方法/5.属性查找与绑定方法/6.补充知识/7.可扩展性高

编程范式（流派）：
   面向对象编程，面向过程编程 各有用处！！
   编程：语法+数据结构(list dict)+算法(逻辑)

1.面向过程编程：核心是过程二字，过程指得是解决问题的步骤，相当于设计一条流水线，机械式的思维方式

       优点：复杂的问题流程化，进而简单化
       缺点：可扩展性差
       运用场景：系统监控脚本，自动部署脚本之类的，eg:软件包解压安装（不再需要扩展了）就可以使用面向过程的思维编写代码

'''
面向过程实例：用户登录注册
第一步：用户输入用户名密码
第二步：检查输入的合法性
第三步：注册
'''

import json
def interaction(): # 用户交互函数，用户用户输入用户名密码
    name = input('name:').strip()
    pwd = input('pwd:').strip()

    return {'name':name,
             'pwd':pwd
            }

def check(user_info): # 用户校验函数，用户校验用户名密码的合法性
    is_legal = True

    if len(user_info['name']) == 0:
        print('用户姓名不能为空！')
        is_legal = False

    if len(user_info['pwd']) < 6:
        print('用户密码不能少于6位！')
        is_legal = False
    return {'is_legal':is_legal,
             'user_info':user_info
            }

def register(check_info): # 注册
    if check_info['is_legal']:
        with open('db.json','w',encoding='utf-8') as f:
            json.dump(check_info['user_info'],f)

def main():
    user_info = interaction()
    check_info = check(user_info)
    register(check_info)

if __name__ == '__main__':
    main()

2.面向对象：核心就是对象二字，对象就是特征与技能的结合体

  优点：可扩展性强
  缺点：编程复杂度高
  应用场景：用户需求经常变化，互联网应用，游戏，企业内部应用

类就是一系列对象相似的特征与技能的结合体
强调：站在不同的角度，得到的分类是不一样的

在现实世界中：一定是先有对象，后又类
在程序中：一定先定义类，后调用类产生对象

站在路飞学院的角度，大家都是学生

在现实世界中：
    对象1：mm
        特征：
            学校='luffycity'
            名字='mm'
            性别='女'
            年龄=18
        技能：
            学习
            吃饭
            睡觉

    对象2：mumu
        特征：
            学校='luffycity'
            名字='mumu'
            性别='男'
            年龄=1
        技能：
            学习
            吃饭
            睡觉

    对象3：zz
        特征：
            学校='luffycity'
            名字='zz'
            性别='男'
            年龄=20
        技能：
            学习
            吃饭
            睡觉

总结现实中路飞学院的学生类：
        相似的特征
            学校='luffycity'

        相似的技能
            学习
            吃饭
            睡觉

 1 # 先定义类：
 2 class LuffyStudengt:
 3     school = 'luffycity'
 4     def learn(self):
 5         print('is learning')
 6     def eat(self):
 7         print('is eating')
 8     def sleep(self):
 9         print('is sleepping')
10 
11 # 后产生对象
12 stu1 = LuffyStudengt()  # 实例化

3.如何使用类：

   先定义类：
   特征：变量 school
   技能：函数

类和函数的区别：
定义函数只有调用函数名加（）才执行
定义类的时候类的内部代码都会执行

类的用途：
1.操作它的属性 增删改查
2.实例化 产生对象

class LuffyStudengt:
    school = 'luffycity'  # 数据属性
    
    def learn(self):      # 函数属性
        print('is learning')
    def eat(self):     # 函数属性
        print('is eating')
    def sleep(self):    # 函数属性
        print('is sleepping')

# 查看类的名称空间
print(LuffyStudengt.__dict__)
print(LuffyStudengt.__dict__['school'])

# 查:
print(LuffyStudengt.school) # == print(LuffyStudengt.__dict__['school'])

# 增：
LuffyStudengt.country = 'China'
print(LuffyStudengt.__dict__)

# 删
del LuffyStudengt.country
print(LuffyStudengt.__dict__)

# 改
LuffyStudengt.school = 'Luffycity'
print(LuffyStudengt.__dict__)

4.__init__方法：

__init__方法用来为对象定制对象自己独有的特征

__init__实例化对象时会自动调

class LuffyStudengt:
    school = 'luffycity'

    # stu1,'mm','女',18
    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self):
        print('is learning')
    def eat(self):
        print('is eating')
    def sleep(self):
        print('is sleepping')

# 后产生对象
stu1 = LuffyStudengt('mm','女',18)  # 实例化

# 加上__init__方法后实例化的步骤
# 1.先产生一个空对象stu1
# 2.LuffyStudent.__init__(stu1,'mm','女',18)

# 查
print(stu1.__dict__)
print(stu1.Name)

# 改：
stu1.Name = '梦梦'
print(stu1.__dict__)
print(stu1.Name)

# 删除：
del stu1.Name
print(stu1.__dict__)

# 增：
stu1.classname = 'python全站开发'
print(stu1.__dict__)

stu2=LuffyStudent('mumu','男',1) #Luffycity.__init__(stu2,'mumu','男'，1)
print(stu2.__dict__)
print(stu2.Name)

5.属性查找与绑定方法：

class LuffyStudengt:
    school = 'luffycity'

    # stu1,'mm','女',18
    def __init__(self,name,sex,age):
        self.Name = name
        self.Sex = sex
        self.Age = age

    def learn(self):
        print('%s is learning'% self.Name)
    def eat(self):
        print('%s is eating'% self.Name)
    def sleep(self):
        print('%s is sleepping'% self.Name)

# 后产生对象
stu1 = LuffyStudengt('mm','女',18)  # 实例化
stu2 = LuffyStudengt('mumu','男',1)
stu3 = LuffyStudengt('zz','男',20)

# 对象：特征和技能的结合体
# 类：类是一系列对象相似的特征与相似的技能的结合体

# 类中的数据属性:是所有对象共有的
# print(stu1.school,id(stu1.school))
# print(stu2.school,id(stu2.school))
# print(stu3.school,id(stu3.school))
#
# # luffycity 6854800
# # luffycity 6854800
# # luffycity 6854800
# 类中的函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法
# 对象调用绑定方法时，会把对象本身当做第一个参数传入，传给self
# print(LuffyStudengt.learn)
# LuffyStudengt.learn(stu1)

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

# 变量查找顺序：首先会在对象的名称空间中找，找不到在去类的名称空间找，然后去父类的名称空间找，还找不到就不会去全局找了
stu1.x = 'from stu1'
LuffyStudengt.x = 'from LuffyStudent'

print(stu1.x)
# from stu1

6.补充知识

1.站的角度不同，定义出的类是截然不同的；
2.现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类等；
3.有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类。

4.python 一切皆对象，在python3里统一了类与类型（list dict）的概念

# print(type([1,2]))
# print(list)
class LuffyStudent:
    school = 'luffycity'

    def __init__(self,name,sex,age):
        self.Name=name
        self.Sex=sex
        self.Age=age

    def learn(self,x):
        print('%s,%s is learning' % (self.Name,x))

    def eat(self):
        print('%s is eatting' % self.Name)
# print(LuffyStudent)

li1 = [1,2,3] # li = list(1,2,3) # list 对象
li1.append(4) # 对象在调自己的绑定方法 # list.append(li1,4)
# list.append(li1,4) # 类中的方法 是给 对象用的
print(li1)

7.可扩展性高

class Chinese:
    country = 'China'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print('%s is eating' % self.name)

p1 = Chinese('alice',19,'女')
p2 = Chinese('alex',22,'男')

print(p1.name,p1.country)
print(p2.name,p2.country)
p1.eat()
p2.eat()