python 基础语法之面向对象

348 阅读10分钟

python 基础语法-面向对象

一、面向对象

1、面向对象概念

面向对象是一种编程思想,是对现实世界中的事物进行抽象的方式。应用到代码编程设计中,是一种建立实物模型的方式。

2、面向和面向过程的区别

面向过程关注的是完成工作的步骤,面向对象关注的是谁能完成工作。面向对象是在完成工作的时候关注哪些个体能够完成对应的工作,找到对应的个体即可完成对应任务。

二、类

1、类的概念

类是一系列事物的统称,同类事物必定具有的特征。日常事物的特征根据特性分为状态和行为,对应到类中就是变量和方法。

特征分类: 状态

变量 -->(成员变量)
行为 --> 方法(成员方法)
			 统称:类的成员

2、类定义语法格式

class 类名:
    pass
class Cat:
    pass

3、类名的命名规范

类名命名规范:满足大驼峰命名规范。

三、对象

1、对象的概念

对象是类的具体表现形式,是实际存在的个体。(类是一系列事物的统称)

2、创建对象的语法格式

对象名 = 类名()
class Cat: # 创建了一个类
    pass
    
cat1 = Cat() # 创建了一个对象

四、成员变量

1、成员变量的概念

成员变量用于描述对象的固有状态或属性。

2、定义成员变量语法格式(共有属性/共有变量)

class 类名:		 
    def __init__(self):
        self.变量名1 = 值1
        self.变量名2 = None
class Dog:
    def __init__(self):
    """定义在  __init__ 里面的是共有变量"""
        self.type = "牧羊犬"
        self.name = None

3、成员变量定义语法格式(独有属性/私有属性)

对象名.变量名 = 值
class Dog:
    def __init__(self):
        self.type = "牧羊犬"
        self.name = None
dog1 = Dog()
dog1.name = "tom"
dog1.colth = "red" # 对象创建了一个自己的独有变量

4、共有变量与独有变量的区别

  • 公有变量在__init__方法中声明,每个对象都具有该变量
  • 独有变量在创建对象后声明,只有当前对象具有此变量
  • 定义对象的独有变量时,如果独有变量名与公有变量名相同,视为修改公有变量的值;如果独有变量名与公有变量名不相同,视为定义新的独有属性
  • None含义是为空,表示没有具体的数据

5、变量的调用格式

取值:对象名.变量名
赋值:对象名.变量名 = 值

五、成员方法

1、成员方法概念

成员方法用于描述对象的固有行为。

2、定义成员方法语法格式

格式一(无参方法):

class 类名:		 
	def 方法名(self):
		方法体
class Dog:
    def __init__(self):
        self.type = "牧羊犬"
        self.name = None
    def eat(self): # 成员方法
        print("狗吃骨头")

格式二(有参方法):

class 类名:		 
	def 方法名(self,形参1,形参2,…):
		方法体
class Dog:
    def __init__(self):
        self.type = "牧羊犬"
        self.name = None
    def eat(self): 
        print("狗吃骨头")
    def run(self,meter): # 成员方法带参 meter
        print("狗会跑步,跑了%d米"% meter)

3、调用成员方法语法格式

格式一(调用无参方法):

对象名.方法名()

格式二(调用有参方法):

对象名.方法名(实参1,实参2,…)

class Dog:
	def __init__(self):
		self.type = "牧羊犬"
		self.name = None
	def eat(self): 
		print("狗吃骨头")
	def run(self,meter): # 成员方法带参 meter
		print("狗会跑步,跑了%d米"% meter)
dog1 = Dog()
dog1.eat()  # 无参调用方法
dog1.run(340) # 有参调用方法

六、__init __ 方法

1、__ init__ 方法的作用

  • __init__方法,也称为构造方法,创建对象时为对象初始化成员变量

2、定义__init__ 方法格式

格式一:

def __init__(self):
	self.变量名1 = 值1
class Dog:
	def __init__(self):
		self.type = "牧羊犬"
		self.name = None

格式二:

def __init__(self,形参1,形参2,…):
	self.__属性名1 = 形参1
	self.__属性名2 = 形参2
class Dog:
	def __init__(self,name):
		self.type = "牧羊犬"
		self.name = name

3、__init __ 方法的调用和执行

__init__方法在创建对象时被运行,无需手工调用即可执行。
__init__方法中如果有形参,在创建对象时需要传递对应的实参。

4、魔术方法

魔术方法是在类中声明、定义的方法,执行时无需手工调用,自动执行。

七、__ str__ 方法

1、__ str__ 方法的作用

__str__方法是在使用print函数打印输出对象到屏幕时被调用的方法,用于返回对象的规范化字符串表现形式.

2、定义__str__ 方法的语法格式
def __str__(self):
	return 打印对象是显示的信息
class Dog:
	def __init__(self):
		self.type = "牧羊犬"
		self.name = None
	def eat(self): 
		print("狗吃骨头")
	def run(self,meter):
		print("狗会跑步,跑了%d米"% meter)
	def __str__(self):
	    print("打印了一只dog")
dog1 = Dog()
print(dog1) # 打印对象时调用 __str__ 函数

八、成员方法调用类成员

1、成员方法中调用成员变量语法格式

self.变量名
class Dog:
	def __init__(self):
		self.type = "牧羊犬"
		self.name = None
	def introduce(self):
	    print("我是一只%s,我叫%s"% (self.type,self.name)) # 此处调用成员变量
dog1 = Dog()
dog1.name = "大黄"
dog1.introduce()

2、成员方法中调用成员方法语法格式

self.方法名(实参1,实参2,…)
class Dog:
	def catch(self):
		self.jump()
		self.grasp()
		self.bite()
	def jump(self):
		print("狗跳起来了")
	def grasp(self):
		print("狗抓住了兔子")
	def bite(self):
		print("狗咬死了兔子")
dog1 = Dog()
dog1.catch()

3、self

self 仅出现在成员方法中,指代执行该方法的对象

九、封装

1、封装的作用

封装操作可以对受访问保护的成员进行功能开放的控制,达到保护数据不被非法访问的目的。

2、定义私有变量的语法格式

self.__属性名 = 值
class Card:
    def __init__(self):
        self.card_id = None
        self.__pwd = None

3、定义私有方法语法格式

def __方法名(self,形参1,形参2,...):
    方法体

4、标准封装语法格式

变量私有化格式:

self.__属性名 = 值

提供公共的访问器格式:

def get_属性名(self):
	return self.__属性名

提供公共的修改器格式:

def set_属性名(self,属性名):
	self.__属性名 = 属性名
class Card:
    def __init__(self):
        self.card = None
        self.__pwd = None
    
    def __get_pwd(self):
        """可以用 __get 这个函数去访问私有变量"""
        return self.__pwd
        
    def __set_pwd(self,pwd):
        """可以用 __set 这个函数去修改私有变量"""
        self.__pwd = pwd

十、类变量

1、类变量的概念

类变量是定义在类中,不属于某个具体对象的特征,被所有对象共同使用的特征

2、定义类变量的语法格式

class 类名:
    变量名 = 值

3、调用类变量的语法格式

赋值格式:

类名.类变量名 = 值

取值格式:

类名.类变量名(推荐)
对象名.类变量名(不推荐)

4、注意事项

  • 类变量推荐使用类名取值访问,也可以使用对象名取值访问
  • 类变量只能通过类名修改;使用对象名调用类变量修改类变量的值时会创建新的对象独有变量;如果此时对象具有同名对象变量,则修改对应的变量值
  • 类变量可以私有化

十一、类方法

1、类方法的概念

类方法是定义在类中,不属于某个具体对象的行为,被所有对象共同使用的行为

2、定义类方法的基本语法

class 类名:
	@classmethod
	def 方法名(cls,形参1,形参2,…):
			方法体
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    @classmethod
    # 定义一个类方法
    def eat(cls,foods):
        print("这个%s真好吃"% foods)

3、调用类方法语法格式

类名.类方法名(实参1,实参2,…)	 (推荐)
对象名.类方法名(实参1,实参2,…) (不推荐)

4、注意事项

  • 类方法中不允许使用实例变量和实例方法
  • 类方法中允许使用类变量和类方法,通过第一个参数cls进行
  • 实例方法中允许使用类变量和类方法

十二、静态方法

1、定义静态方法语法格式

class 类名:
    @staticmethod
    def 方法名(形参1,形参2,…):
        方法体
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    @statimethod
    def show():
        print("今天是一个好日子")

2、调用静态方法语法格式

类名.静态方法名(实参1,实参2,…)	 (推荐)
对象名.静态方法名(实参1,实参2,…) (不推荐)

3、各种方法定义规则

  • 只访问成员变量的方法,定义成实例方法
  • 只访问类变量的方法,定义类方法
  • 既访问成员变量,也访问类变量的方法,定义成实例方法
  • 既不访问成员变量,也不访问类变量,定义成静态方法

案例:手机

"""
演示手机案例
要求:
    手机电量默认是100
	打游戏每次消耗电量10
	听歌每次消耗电量5
	打电话每次消耗电量4
	接电话每次消耗电量3
	充电可以为手机补充电量
"""
# 程序分析:
#     1、需要定义一个类
#     2、需要定义一个变量用来记录,手机电池电量的变化.
#     3、需要定义5个行为来描述充电和耗电的操作
#


# 首先定义一个类,类名为 phone。
class Phone:

    def __init__(self):
        self.power = 100
        self.type = None

    # project = a  num = b

    def use_power(self, project, num):
        if self.power >= num:
            self.power -= num
            print("%s手机当前正在%s,手机电量减少%d%%,当前手机剩余电量为%d%%" % (self.type, project, num, self.power))
        else:
            print("%s手机当前电量过低,仅剩余%d%%无法完成%s,请充电后再进行操作" % (self.type, self.power, project))

    def game(self):
        self.use_power("打游戏",10)

    def music(self):
        self.use_power("听音乐", 5)

    def call(self):
        self.use_power("打电话", 4)

    def answer(self):
        self.use_power("接电话", 3)

    def electricize(self,num):
        """定义一个充电行为,num 用于接受一次充电的电量"""
        self.power += num
        if self.power >= 100:
            print("%s手机当前电量已经充满,"% self.type)
            self.power = 100
        else:
            print("已经对%s手机充电%d%%,当前手机电量为:%d%%"% (self.type,num,self.power))

    def __str__(self):
        return "%s手机,当前的手机电量为:%d%%" % (self.type,self.power)
# 创建一部手机,huawei,对他进行操作

huawei = Phone()
huawei.type = "华为"
huawei.game()
huawei.call()
huawei.call()
huawei.call()
huawei.call()
huawei.call()
huawei.call()
huawei.electricize(20)
print(huawei)


lianxiang = Phone()
lianxiang.type = "联想"
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
lianxiang.game()
print(lianxiang)
lianxiang.electricize(80)
lianxiang.electricize(80)
print(lianxiang)

运行结果:

华为手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为90%
华为手机当前正在打电话,手机电量减少4%,当前手机剩余电量为86%
华为手机当前正在打电话,手机电量减少4%,当前手机剩余电量为82%
华为手机当前正在打电话,手机电量减少4%,当前手机剩余电量为78%
华为手机当前正在打电话,手机电量减少4%,当前手机剩余电量为74%
华为手机当前正在打电话,手机电量减少4%,当前手机剩余电量为70%
华为手机当前正在打电话,手机电量减少4%,当前手机剩余电量为66%
已经对华为手机充电20%,当前手机电量为:86%
华为手机,当前的手机电量为:86%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为90%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为80%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为70%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为60%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为50%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为40%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为30%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为20%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为10%
联想手机当前正在打游戏,手机电量减少10%,当前手机剩余电量为0%
联想手机当前电量过低,仅剩余0%无法完成打游戏,请充电后再进行操作
联想手机当前电量过低,仅剩余0%无法完成打游戏,请充电后再进行操作
联想手机,当前的手机电量为:0%
已经对联想手机充电80%,当前手机电量为:80%
联想手机当前电量已经充满,
联想手机,当前的手机电量为:100%