python类（面向对象）基础概念

一、面向对象编程概述

1、对象的意义

在自然界一个对象具有属性特征以及每个对象具有的一些动作，而在程序中属性特征是由变量来进行定义，而动作则往往由函数实现，因此程序中的对象就是数据和函数动作的集合，每个对象拥有自己独有的数据。

2、类的意义

相对于一个对象如此具体的含义，类相当于是将同一类对象的相同的属性和动作进行提取的集合，是抽象的而非具体。如果是对象是每一个独立的个体，那类就是一群个体的逻辑集合。如自然人和人类的关系一样。

3、面向对象的三大特征

• 封装
  封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
  封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
• 继承
  面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
• 多态
  多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
  实现多态，有二种方式，覆盖，重载

二、面向对象的程序设计

在没有介绍类的如何定义之前，也可以设计出符合面向对象的程序。

def People(name,gender,fav): #如同定义了一个people类
    def hello(person): #定义了一个打招呼的函数
        print("hello,i am %s"%person['name'])
    def eat(person):#定义了一个吃的函数
        print("eat %s"%person['fav'])
    def init(name,gender,fav):#这是一个初始化的函数，传入个体独有的数据如姓名性别等
        person = {
            'name':name,
            'gender':gender,
            'fav':fav,
            'hello':hello,
            'eat':eat
        } 
        return person #定义一个动作和属性的字典并进行将其作为返回值返回
    return init(name,gender,fav) 


p1 = People('hyj','male','egg') #p1就是一个由people类产生的具体对象
print(p1['name'])
p1['hello'](p1)
#hyj
#hello,i am hyj

三、类的定义以及使用

1、定义一个基本的类

类是用来描述一类事物，类一般拥有数据属性（变量）和函数属性（方法），类名一般要用大写字母开头

class 类名:
	类结构体

2、类一些特殊的内置属性

• _dict_：类内部的属性字典,会返回类内部定义的各种函数和属性的对应值

class Cat:
    symbol = "tail"
    def eat():
        print("eat fish")

print(Cat.__dict__)
#{'__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Cat' objects>, '__doc__': None, 
#'eat': <function Cat.eat at 0x103afea60>, '__dict__': <attribute '__dict__' of 'Cat' objects>, 'symbol': 'tail'}

• _name_：输出类名
• _module_：显示该类属于哪个模块

3、类的实例化

class Cat:
    symbol = "tail"
    def __init__(self,name,age):
        print("实例化开始")
        self.name = name
        self.age = age
        print("实例化结束")
    def eat(self):
        print("%s eat fish"%self.name)

c1 = Cat('DD','2') #类似于运行了c1=Cat.__init__(c1,'DD','2')
print(c1.age)
print(c1.symbol)
c1.eat()
print(c1.__dict__)

#实例化开始
#实例化结束
#2
#tail
#DD eat fish
#{'name': 'DD', 'age': '2'}

__init__函数的作用

init函数是一个类的初始化函数，当对一个类进行实例化的过程中，会运行这个函数，会返回一个字典（类似于面向程序设计中的init函数思想）。但此函数返回值无法人为设定，class会自动返回None值

实例对象调用属性和方法

• 首先当定义一个类时，内存会开辟一个空间来存放所有类代码，并和类名进行引用
• 实例化的过程中，会重新开辟一个空间用来存放具体实例的字典变量，因此上例中此c1对象的内存空间中只有‘name’和‘age’两个key，而没有类属性的‘symbol’
• 而实例可以调用类属性的原因是和函数作用域有关，当在实例作用域中无法找到symbol变量时，就会往类作用域中寻找。
• 实例调用函数时，必须将自身传入函数中，函数中的self变量接收的就是实例对象。

因此，实例本身是只有数据属性的，并没有方法属性，方法属性都保存在类中。

4、类属性的增删改

实例属性可以用类似的方法修改

改

修改类的属性值会对后面生成的实例都产生影响，而对实例值进行修改则不会对其他实例或者类本身产生影响

class Cat:
    symbol = "tail"
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print("%s eat fish"%self.name)

c1 = Cat('DD',2)
Cat.symbol = 'hello' 
print(c1.symbol)
#hello

增

c1 = Cat('DD',2)
Cat.feature = 'spot' #增添一个属性值
print(c1.feature)
#spot

删

del Cat.symbol #删除symbol变量，并用__dict__函数查看
print(Cat.__dict__)
#{'__weakref__': <attribute '__weakref__' of 'Cat' objects>, '__dict__': <attribute '__dict__' of 'Cat' objects>, 'eat': <function Cat.eat at 0x10330dae8>, '__init__': <function Cat.__init__ at 0x10330da60>, '__doc__': None, '__module__': '__main__'}

5、静态属性、静态方法、类方法

静态属性

类的静态属性也可以叫特性，是将类中定义的方法封装成一个类属性来进行调用。这样我们可以通过方法来修改一些不便暴露的属性。
实现方法是在该函数前面使用@property装饰器函数

class Employee:
    def __init__(self,name,workdays,pay):
        self._name = name
        self._workdays = workdays
        self._pay = pay

    @property
    def pay(self):
        return self._pay
    
    @pay.setter
    def pay(self,pay):
    	self.pay = pay

e1=Employee('jack',22,300)
e1.pay=3000

静态方法

静态方法是定义在类中，但是无法调用类属性或者实例属性的函数，作用相当于类自己的工具包，实例无法调用，实现方法是在函数前面使用@staticmethod装饰器

class Employee:
    def __init__(self,name,workdays,pay):
        self.name = name
        self.workdays = workdays
        self.pay = pay

    @staticmethod
    def tools(*args,**kwargs):
        print("employess could have %s,%s"%(args[0],args[1]))

e1 = Employee('jack',22,300)
Employee.tools("pc","mobile")

#结果：employess could have pc,mobile

类方法

类方法指的是无需生成实例，直接可以用类直接调用的方法，实现方法是在函数前面使用@classmethod装饰器

class Employee:
    m_have = "card"
    def __init__(self,name,workdays,pay):
        self.name = name
        self.workdays = workdays
        self.pay = pay

    @classmethod
    def tell_info(cls):
        print(cls.m_have)

e1 = Employee('jack',22,300)
e1.tell_info() #实例也可以调用，这是和静态方法的不同之处
Employee.tell_info()

用这种方法也可以实现类方法调用

def tell_info():
        print(Employee.m_have)

6、类的组合

一个类实例化时可以传入其他的类的对象作为参数，以实现类的组合

class Company:
    def __init__(self,name,boss,employee):
        self.name = name
        self.boss = boss
        self.employee = employee

class Employee:
    def __init__(self,name,id,boss):
        self.name = name
        self.id = id
        self.boss = boss

class Boss:
    def __init__(self,name):
        self.name = name

boss1 = Boss('jack.ma')
e1 = Employee('dizhongdi','001',boss1) #传入boss1这个实例对象
c1 = Company('ali',boss1,e1) #传入boss1和e1两个实例对象

print("[%s]公司的大佬叫[%s],%s的id是%s"%(c1.name,c1.boss.name,c1.employee.name,c1.employee.id))
# 结果：[ali]公司的大佬叫[jack.ma],dizhongdi的id是001