python 基础语法之面向对象

python 基础语法-面向对象

1、面向对象

一、面向对象概念

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

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

面向过程关注的是完成工做的步骤，面向对象关注的是谁能完成工做。面向对象是在完成工做的时候关注哪些个体可以完成对应的工做，找到对应的个体便可完成对应任务。

2、类

一、类的概念

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

特征分类： 状态

变量 -->（成员变量）
行为 --> 方法（成员方法）
			 统称：类的成员
复制代码

二、类定义语法格式

class 类名:
    pass
复制代码

class Cat:
    pass
复制代码

三、类名的命名规范

类名命名规范：知足大驼峰命名规范。

3、对象

一、对象的概念

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

二、建立对象的语法格式

对象名 = 类名()
复制代码

class Cat: # 建立了一个类
    pass
    
cat1 = Cat() # 建立了一个对象
复制代码

4、成员变量

一、成员变量的概念

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

二、定义成员变量语法格式（共有属性/共有变量）

class 类名：		 
    def __init__(self):
        self.变量名1 = 值1
        self.变量名2 = None
复制代码

class Dog:
    def __init__(self):
    """定义在 __init__ 里面的是共有变量"""
        self.type = "牧羊犬"
        self.name = None
复制代码

三、成员变量定义语法格式（独有属性/私有属性）

对象名.变量名 = 值
复制代码

class Dog:
    def __init__(self):
        self.type = "牧羊犬"
        self.name = None
dog1 = Dog()
dog1.name = "tom"
dog1.colth = "red" # 对象建立了一个本身的独有变量
复制代码

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

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

五、变量的调用格式

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

5、成员方法

一、成员方法概念

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

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

格式一（无参方法）：

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)
复制代码

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

格式一（调用无参方法）：

对象名.方法名（）

格式二（调用有参方法）：

对象名.方法名（实参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) # 有参调用方法
复制代码

6、__init __ 方法

一、__ init__ 方法的做用

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

二、定义__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
复制代码

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

__init__方法在建立对象时被运行，无需手工调用便可执行。
__init__方法中若是有形参，在建立对象时须要传递对应的实参。

四、魔术方法

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

7、__ str__ 方法

一、__ str__ 方法的做用

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

二、定义__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__ 函数
复制代码

8、成员方法调用类成员

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

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()
复制代码

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

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()
复制代码

三、self

self 仅出如今成员方法中，指代执行该方法的对象

9、封装

一、封装的做用

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

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

self.__属性名 = 值
复制代码

class Card:
    def __init__(self):
        self.card_id = None
        self.__pwd = None
复制代码

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

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

四、标准封装语法格式

变量私有化格式：

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
复制代码

10、类变量

一、类变量的概念

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

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

class 类名:
    变量名 = 值
复制代码

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

赋值格式：

类名.类变量名 = 值
复制代码

取值格式：

类名.类变量名（推荐）
对象名.类变量名（不推荐）
复制代码

四、注意事项

• 类变量推荐使用类名取值访问，也可使用对象名取值访问
• 类变量只能经过类名修改；使用对象名调用类变量修改类变量的值时会建立新的对象独有变量；若是此时对象具备同名对象变量，则修改对应的变量值
• 类变量能够私有化

11、类方法

一、类方法的概念

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

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

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)
复制代码

三、调用类方法语法格式

类名.类方法名(实参1，实参2，…)	 （推荐）
对象名.类方法名(实参1，实参2，…) （不推荐）
复制代码

四、注意事项

• 类方法中不容许使用实例变量和实例方法
• 类方法中容许使用类变量和类方法，经过第一个参数cls进行
• 实例方法中容许使用类变量和类方法

12、静态方法

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

class 类名：
    @staticmethod
    def 方法名(形参1,形参2，…):
        方法体
复制代码

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
 @statimethod
    def show():
        print("今天是一个好日子")
复制代码

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

类名.静态方法名(实参1，实参2，…)	 （推荐）
对象名.静态方法名(实参1，实参2，…) （不推荐）
复制代码

三、各类方法定义规则

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

案例：手机

""" 演示手机案例 要求： 手机电量默认是100 打游戏每次消耗电量10 听歌每次消耗电量5 打电话每次消耗电量4 接电话每次消耗电量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%
复制代码