面向对象与类

目录

• 一,面向对象
• 二,类与对象:
• 注意：
• 调用类，或称为实例化，得到对象
• 强调：

一,面向对象

面向对象核心二字是对象,对象是功能和数据的集合体,
基于该思想写程序就是在整合程序
优点:可扩展性强
缺点编程的复杂度高

二,类与对象:

类即类别,种类,是面向对象设计最重要的概念,对象是数据和功能的结合体,
累就是一系列对象共有的数据和功能
在程序中,先定义类后产生对象
这与函数的使用是类似的,先定义函数,后调用函数,类也是一样的,在程序中需要先定义类,
后调用类.不一样的是,调用函数会执行函数体代码返回的是函数体代码执行的结果,而调用类会产生对象,返回的是对象

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

PS:
1.
在程序中特征用变量标识，技能用函数标识
2.
因而类中最常见的无非是：变量和函数的定义

程序中的类

class OldboyStudent:
   school = 'oldboy'

   def learn(self):
      print('is learning')

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

   def sleep(self):
      print('is sleeping')

注意：

类中可以有任意python代码，这些代码在类定义阶段便会执行
2.
因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看
3.
对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
4.
点是访问属性的语法，类中定义的名字，都是类的属性

### 程序中类的用法

.:专门用来访问属性，本质操作的就是__dict__
OldboyStudent.school  # 等于经典类的操作OldboyStudent.__dict__['school']
OldboyStudent.school = 'Oldboy'  # 等于经典类的操作OldboyStudent.__dict__['school']='Oldboy'
OldboyStudent.x = 1  # 等于经典类的操作OldboyStudent.__dict__['x']=1
del OldboyStudent.x  # 等于经典类的操作OldboyStudent.__dict__.pop('x')

程序中的对象

调用类，或称为实例化，得到对象

s1 = OldboyStudent()
s2 = OldboyStudent()
s3 = OldboyStudent()

如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__

注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值

class OldboyStudent:
   ......

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

   ......

s1 = OldboyStudent('李坦克', '男', 18)  # 先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李坦克','男',18)
s2 = OldboyStudent('王大炮', '女', 38)
s3 = OldboyStudent('牛榴弹', '男', 78)

程序中对象的用法

执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间

s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}

s2.name  # s2.__dict__['name']
s2.name = '王三炮'  # s2.__dict__['name']='王三炮'
s2.course = 'python'  # s2.__dict__['course']='python'
del s2.course  # s2.__dict__.pop('course')

在程序中：先定义类，后产生对象

init__方法,初始化方法
#方式一、为对象初始化自己独有的特征
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

实例化出三个空对象

obj1=People()
obj2=People()
obj3=People()

为对象定制自己独有的特征

obj1.name='egon'
obj1.age=18
obj1.sex='male'

obj2.name='lxx'
obj2.age=38
obj2.sex='female'

obj3.name='alex'
obj3.age=38
obj3.sex='female'

# print(obj1.__dict__)

# print(obj2.__dict__)

# print(obj3.__dict__)

# print(People.__dict__)

#方式二、为对象初始化自己独有的特征
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 实例化出三个空对象

obj1=People()
obj2=People()
obj3=People()

# 为对象定制自己独有的特征

def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
    obj.name = x
    obj.age = y
    obj.sex = z

chu_shi_hua(obj1,'egon',18,'male')
chu_shi_hua(obj2,'lxx',38,'female')
chu_shi_hua(obj3,'alex',38,'female')

#方式三、为对象初始化自己独有的特征
class People:
    country='China'
    x=1

​    def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
​        obj.name = x
​        obj.age = y
​        obj.sex = z

​    def run(self):
​        print('----->', self)


obj1=People()

# print(People.chu_shi_hua)

People.chu_shi_hua(obj1,'egon',18,'male')

obj2=People()
People.chu_shi_hua(obj2,'lxx',38,'female')

obj3=People()
People.chu_shi_hua(obj3,'alex',38,'female')

# 方式四、为对象初始化自己独有的特征

class People:
    country='China'
    x=1

​    def __init__(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
​        obj.name = x
​        obj.age = y
​        obj.sex = z

​    def run(self):
​        print('----->', self)

obj1=People('egon',18,'male') #People.__init__(obj1,'egon',18,'male')
obj2=People('lxx',38,'female') #People.__init__(obj2,'lxx',38,'female')
obj3=People('alex',38,'female') #People.__init__(obj3,'alex',38,'female')

__init__方法

强调：

1、该方法内可以有任意的python代码

2、一定不能有返回值

class People:
    country='China'
    x=1

​    def __init__(obj, name, age, sex): #obj=obj1,x='egon',y=18,z='male'

        # if type(name) is not str:

        #     raise TypeError('名字必须是字符串类型')

​        obj.name = name
​        obj.age = age
​        obj.sex = sex


​    def run(self):
​        print('----->', self)


# obj1=People('egon',18,'male')

obj1=People(3537,18,'male')

# print(obj1.run)

# obj1.run() #People.run(obj1)

# print(People.run)

！！！__init__方法之为对象定制自己独有的特征
ps:

1. 站的角度不同，定义出的类是截然不同的，详见面向对象实战之需求分析

2. 现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类......

3. 有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类

三:属性查找
类有两种属性:数据属性和函数属性
1,类的数据属性是所有对象共享的
2,类的函数属性是绑定给对象用的
优先级:先从对象的字典里找,没有,再去类的字典中去找

Class Student:
   school = 'oldboy'

   def __init__(obj,x,y,z):
      obj.name = x
      obj.age = y
      obj.gender = z

   def choose(self):
      print('%s 正在选课' %self.name)

stu_obj1 = Student('冯疯子',18,'female')
stu_obj2 = Student('郭靖',19,'male')
stu_obj3 = Student('大雕',200,'male')

类中定义的数据是字节共享给所有对象使用的

# print(id(stu_obj1.school))

# print(id(stu_obj2.school))

# print(id(stu_obj3.school))

# print(id(Student.school))

# Student.school="xxx"

# print(stu_obj1.school)

# print(stu_obj2.school)

# print(stu_obj3.school)

# print(Student.choose)

# print(stu_obj1.choose)

# print(stu_obj2.choose)

# print(stu_obj3.choose)

2,类中定义的函数是绑定给所有对象用的,绑定给谁就应该由哪个对象来调用
对象.绑定方法()会把对象当做第一个参数传入
类.函数()就是一个函数的玩法,没有自动传参的效果

# Student.choose(123)

stu_obj1.choose()
stu_obj2.choose()
stu_obj3.choose()