python类(面向对象)基础概念

文章目录

  • 一、面向对象编程概述
    • 1、对象的意义
    • 2、类的意义
    • 3、面向对象的三大特征
  • 二、面向对象的程序设计
  • 三、类的定义以及使用
    • 1、定义一个基本的类
    • 2、类一些特殊的内置属性
    • 3、类的实例化
      • __init__函数的作用
      • 实例对象调用属性和方法
    • 4、类属性的增删改
    • 5、静态属性、静态方法、类方法
      • 静态属性
      • 静态方法
      • 类方法
    • 6、类的组合

一、面向对象编程概述

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__': , '__doc__': None, 
#'eat': , '__dict__': , '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__': , '__dict__': , 'eat': , '__init__': , '__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 month_salary(self):
        return self.workdays * self.pay

e1=Employee('jack',22,300)
print(e1.month_salary)
#结果:6600

静态方法

静态方法是定义在类中,但是无法调用类属性或者实例属性的函数,作用相当于类自己的工具包,实例无法调用,实现方法是在函数前面使用@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

你可能感兴趣的:(#,python类基础)