面向对象编程

1.面向过程编程
面向过程：核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式
优点：复杂的问题流程化，进而简单化
缺点：可扩展性差
示例

View Code

2.面向对象编程

面向对象：核心就是对象二字，对象就是特征和技能的结合体
优点：可拓展性强
缺点：编程复杂度高
应用场景：用户需求经常变化，互联网应用、游戏、企业内部的应用

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

现实生活：一定现有对象，后有类
编程：一定先定义类，后调用类来产生对象
示例

在现实生活当中
    对象1：杨学伟
         特征：
              学校='luffycity'
              名字='杨学伟'
              性别='男'
              年龄='18'
         技能：
              睡觉
              吃饭
              学习

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

    对象1：李赫
         特征：
              学校='luffycity'
              名字='李赫'
              性别='男'
              年龄='12'
         技能：
              睡觉
              吃饭
              学习
    总结现实生活中路飞学院的学生类
         相似的特征
              学校='luffycity'
         相似的技能
              睡觉
              吃饭
              学习
"""

#先定义类
class Luffycity:
    school="luffycity"

    def learn(self):
        print("is learning")
    def eat(self):
        print("is eating")
    def sleep(self):
        print("is sleeping")

#后产生对象
stu1 = Luffycity()
stu2 = Luffycity()
stu3 = Luffycity()
print(stu1)
print(stu2)
print(stu3)

View Code

3.类的使用

在程序中，务必保证：先定义（类），后使用类（用来产生对象）

#先定义类
class Luffycity:
    school="luffycity" #数据属性

    def learn(self): #函数属性
        print("is learning")
    def eat(self): #函数属性
        print("is eating")


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

#查
# print(Luffycity.__dict__['school'])

#增
# Luffycity.country = "china"
# print(Luffycity.__dict__)

#删
# del Luffycity.country

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

View Code

4.__init__方法的使用

#先定义类
class LuffyStudent:
    school="luffycity"
    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")

#后产生对象
stu1 = LuffyStudent('杨学伟','男',18) #LuffyStudent.__init__(stu1,'杨学伟','男',18)

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

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

#改
stu1.Age=19
print(stu1.__dict__)
print(stu1.Age)

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

#增
stu1.class_name = "python开发"
print(stu1.__dict__)

stu2 = LuffyStudent('林书行','女',98)#LuffyStudent.__init__(stu1,'林书行','女',98)
print(stu2.__dict__)
print(stu2.Name)
print(stu2.Age)
print(stu2.Sex)

View Code

5.属性查找

#先定义类
x = "123"
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 is learning %s"%(self.Name,x))

    def eat(self):
        print("is eating")

#后产生对象
stu1 = LuffyStudent('杨学伟','男',18) #LuffyStudent.__init__(stu1,'杨学伟','男',18)
stu2 = LuffyStudent('林书行','女',38)
stu3 = LuffyStudent('李赫','男',98)
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)



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

#类中的数据属性：是所有对象共有的
# print(LuffyStudent.school,id(LuffyStudent.school))
#
# print(stu1.school,id(stu1.school))
# print(stu2.school,id(stu2.school))
# print(stu3.school,id(stu3.school))

#类中的函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象在调用绑定方法时，会把对象本身当作第一个参数，传给self

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


# print(stu1.learn)
# stu1.learn(1) #learn (stu1,1)
# stu2.learn(2) #learn (stu1,2)
# stu2.learn(3) #learn (stu1,3)

#对象在访问属性的时候，没有的话回去类中寻找，类中没有的话，不回去全局中寻找

# stu1.x = "form stu1"
LuffyStudent.x = "form luffycity"
print(stu1.x)

View Code

6.补充

#python中一切皆对象，在python3里同意类与类型的概念

print(type([1,2]))

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 is learning %s"%(self.Name,x))

    def eat(self):
        print("is eating")

print(LuffyStudent)

#l1 就是对象，而[1,2,3]是参数
l1 = [1,2,3] #l1=list([1,2,3])
l1.append(4) #list.append(l1,4)

print(l1)

View Code

7.总结

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

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

p1 = Chinese('yang',18,'male')
p2 = Chinese('zhan',19,'female')
p3 = Chinese('huan',20,'female')

p1.eat()
print(p1.county)

View Code

面向对象编程

推荐阅读