python基础之Day8 python是面向对象的语言（1）

最新推荐文章于 2022-10-27 21:05:53 发布

Little Yueyue

最新推荐文章于 2022-10-27 21:05:53 发布

阅读量203

点赞数

分类专栏：菜鸟入门倒计时

本文链接：https://blog.csdn.net/little_yueyue/article/details/108408503

版权

菜鸟入门倒计时专栏收录该内容

40 篇文章 3 订阅

订阅专栏

Python 支持面向过程、面向对象、函数式编程等多种编程范式。
将不同类型的数据、方法（即函数）放到一起，就是对象。

一个 Python 对象包含如下部分：

id（identity 识别码）
type（对象类型）
value（对象的值）
(1) 属性（attribute）
(2) 方法（method）（实际也是属性）

面向对象和面向过程区别

思维	关注	程序规模	示例
面向过程(Procedure Oriented)思维	“程序的逻辑流程”，“执行者”思维	小，适合简单、不需要协作的事	如何开车： 1. 发动车 2. 挂挡 3.踩油门 4. 走你
面向对象(Object Oriented)思维	“软件中对象之间的关系”，设计者”思维	大，从整体上分析整个系统	如何造车 1. 轮胎 2. 发动机 3. 车壳 4. 座椅 5. 挡风玻璃

对于解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

类的定义

$\quad$	对象	类
类比	饼干	产生饼干的模具
本质	对象	产生对象的对象，称为“类对象”

在这里插入图片描述

语法结构

class 类名：
$\qquad$ 类体

note:

类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
类体中我们可以定义属性和方法。
属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。
类中方法第一个参数必须为 self， self 指的就是刚刚创建好的实例对象。

class Family:
    def __init__(self, name, job, age): #构造方法第一个参数必须为 self
        self.name = name  #实例属性
        self.job = job
        self.age = age
    def say_job(self):   #实例方法
        print('{} is {} in the family.'.format(self.name, self.job))

a = Family('sql boy', 'father', 18)   # a 是实例对象，自动调用__init__()方法
a.say_job()

init构造方法

a = Family('sql boy', 'father', 18)

上面的代码实际是调用了两个方法， init()方法和__new__()方法:
__new__()方法: 用于创建对象，但我们一般无需重定义该方法。
__init__()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”

note:

名称固定，必须为：__init__()
构造函数通常用来初始化实例对象的实例属性，无返回值
Python 中的 self 相当于 C++中的 self 指针， JAVA 和 C#中的 this 关键字。 Python 中，self 必须为构造函数的第一个参数，名字可以任意修改。但一般遵守惯例，都叫做 self。

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。

语法格式：

一般在__init__()方法中通过如下代码定义：
$\qquad$ self.实例属性名 = 初始值

创建实例对象后，通过实例对象读写：
$\qquad$ obj = 类名() $\quad$ #创建对象，调用__init__()初始化属性
$\qquad$ obj.实例属性名 = 值 $\quad$ #可以给已有属性赋值，也可以新加属性
在类中或者类的外面，我们可以通过：“实例名.实例变量名”来读写。

在这里插入图片描述

实例方法

实例方法是从属于实例对象的方法。

语法格式

定义格式如下：
def 方法名(self [, 形参列表])：
$\qquad$ 函数体
方法的调用格式如下：
$\qquad$ 对象.方法名([实参列表])
note：

定义实例方法时，第一个参数必须为 self。self 指当前的实例对象。定义函数是不需要。方法和函数本质都是实现一个功能的语句块。
调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。

实例对象的方法调用本质

class Family:
    def __init__(self, name, job):
        self.name = name
        self.job = job
    def say_age(self,age):
        self.age=age
        print('{} is {} years old.'.format(self.name, self.age))

a = Family('sql boy', 'father')   # a 是实例对象，自动调用__init__()方法
a.say_age(40)
Family.say_age(a,40)
#sql boy is 40 years old.
#sql boy is 40 years old.

在这里插入图片描述

其他方法

dir(obj)可以获得对象的所有属性、方法
obj.__dict__ 对象的属性字典
pass 空语句
isinstance（对象,类型）判断“对象”是不是“指定类型”

class Men():
    pass
print(isinstance(a,Family))
#True
print(isinstance(a,Men))
#False

类对象

class Men():
    pass
print(type(Men))
#<class 'type'>

type $\rightarrow$ 模具类
上述代码生成了一个变量名就是类名“Men”的对象。

peo=Men
John=peo()

我们通过赋值给新变量peo，也能实现相关的调用

类属性(区别实例属性)

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。

语法格式

定义方式：
class 类名：
$\qquad$ 类变量名= 初始值
在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。
而类的私有属性，则通过类名._类名__类变量名”来读写。

class Family:
    company = "programming"  # 类属性
    count=0   # 类属性
    
    def __init__(self, name, job):
        self.name = name
        self.job = job
        Family.count=Family.count+1
    def say_age(self,age):
        self.age=age
        print('{} is {} years old.'.format(self.name, self.age))

a = Family('sql boy', 'father')   
b = Family('python', 'mother')
print('the number of family is {}'.format(Family.count))
#the number of family is 2

在这里插入图片描述

类方法

类方法是从属于“类对象”的方法。主要用于改变类属性。（实例方法主要是对实例进行改变）

语法格式

类方法通过装饰器@classmethod 来定义，格式如下：
class 类名：
$\qquad$ @classmethod
$\qquad$ def 类方法名(cls [，形参列表]) ：
$\qquad$ $\qquad$ 函数体
note：

@classmethod 必须位于每个类方法上面一行
第一个 cls 必须有；cls 指的就是“类对象”本身，类似于self表示实例本身；
调用类方法格式：“类名.类方法名(参数列表)”。参数列表中，不需要也不能给 cls 传值。
类方法中用self访问实例属性和实例方法会导致错误
子类继承父类方法时，传入 cls 是子类对象，而非父类对象

在这里插入图片描述

静态方法

Python 中允许定义与“类对象”无关的方法，称为“静态方法”。
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。

语法格式

静态方法通过装饰器@staticmethod 来定义，格式如下：
class 类名：
$\qquad$ @staticmethod
$\qquad$ def 静态方法名([形参列表]) ：
$\qquad$ $\qquad$ 函数体
note：

@staticmethod 必须位于每个静态方法上面一行，没有cls,self
调用静态方法格式：“类名.静态方法名(参数列表)”。
静态方法中用self访问实例属性和实例方法会导致错误

del方法(析构函数)和垃圾回收机制

_del_方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用__del__方法。
系统会自动提供__del__方法，一般不需要自定义析构方法。

class People:
    def __init__(self, name):
        self.name = name
    def __del__(self):
        print("delete object {}".format(self.name))
p1 = People('Lily')
p2 = People('Lucy')
del p2
#delete object Lucy
#delete object Lily

如上述代码所示，是先Lucy,再Lily，__del__方法在代码结束后自动运行的。

call方法和可调用对象

定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。

class SalaryAccount:
    '''工资计算类'''
    def __call__(self, salary):
        yearSalary = salary * 12
        daySalary = salary // 22.5
        hourSalary = daySalary // 8
        return dict(monthSalary=salary, yearSalary=yearSalary, daySalary=daySalary, hourSalary=hourSalary)
s= SalaryAccount()
print(s(10000))

实际上，当调用定义了__call__方法的对象后面跟一括号，实际上调用的是__call__方法

方法没有重载

（在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含 3个部分：方法名、参数数量、参数类型。）

Python 中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python 中是没有方法的重载的。定义一个方法即可有多种调用方式，相当于实现了其他语言中的方法的重载。
如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。建议：不要使用重名的方法！

class Sayhello:

    def printhello(self, name):
        print('hello,{}'.format(name))

    def printhello(self,name):
        print('{},hello'.format(name))
h=Sayhello()
h.printhello('yueyue')

方法的动态性

Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。

添加新的方法

class Person:
    def life(self):
        print('不脱发！')
def work(s,name):    #添加到类中时，第一个参数就会表示self,必须要有
    print('{} 在加班'.format(name))

Person.work=work
p=Person()
p.work('yueyue')
#yueyue 在加班

新添加到类的函数，必须要有一个形参，当做self，因为实际传递的时候是，类名.方法名（实例名 [，形参]）(eg:Person.work(p,“yueyue”))

修改类的已有的方法

class Person:
    def life(self):
        print('不脱发！')
def goodlife(s,name): #第一个参数添加到类中，就会表示self,必须要有
    print('{} 每天早睡早起，好好上班'.format(name))

Person.life=goodlife
p=Person()
p.life('yueyue')
#yueyue 每天早睡早起，好好上班

用于修改类中函数的函数，必须要有一个形参，当做self，理由同上
方法是对象，函数是对象，一切皆对象！

私有属性和私有方法

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有
属性和私有方法，有如下要点：

通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
类内部可以访问私有属性(方法)，用self.__属性名即可
类外部不能直接访问私有属性(方法)
类外部可以通过“实例名._类名__私有属性(方法)名”访问私有属性(方法)

class Student:
    def __init__(self,name,age):
        self.name=name  #name 属性实际存的是'name'
        self.__age=age  #age属性实际存的是'_Student__age'
        print('内部调用私有属性age{}'.format(self.__age))
s=Student('yueyue','18')
#内部调用私有属性age18
print(s.name)
#yueyue
print(s._Student__age)
#18
#print(s.__age)  会报错，AttributeError: 'Student' object has no attribute 'age'

note:方法本质上也是属性！只不过是可以通过()执行而已。

class Student:
    __count=0  #实际上存的是'_Student__count'，外部调用需用Student._Student__count
    def __init__(self,name,age):
        self.name=name  #name 属性实际存的是'name'
        self.__age=age  #age属性在对象中存的是'_Student__age'
        Student.__count=+1
        print('内部调用私有属性age{}'.format(self.__age))

    def __learn(self):#实际上存的是'_Student__learn'
        print('good good study,day day up!')
s=Student('yueyue','18')
#内部调用私有属性age18
print(s._Student__age)
#18
s._Student__learn()
#good good study,day day up!
print(Student._Student__count)
#1

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。给属性增加getter和setter方法。对比如下面的代码

##普通操作
class Student:
    def __init__(self, name, score):
        self.name = name
        self.__score = score  # 私有属性

    def get_score(self):
        return self.__score

    def set_score(self, score):
        if 0 <= score <= 150:
            self.__score = score
        else:
            print('录入错误，分数在0到150之间')

s1 = Student('yueyue', '145')
print(s1.get_score())
# 145
s1.set_score(-10)
# 录入错误，分数在0到150之间

# 用 @property
class Student:
    def __init__(self, name, score):
        self.name = name
        self.__score = score  # 私有属性

    @property
    def score(self):   #相当于上面的get方法，这里把score方法变成属性，返回return的值
        return self.__score

    @score.setter  #这里score是和上面的def score()对应
    def score(self, score):
        if 0 <= score <= 150:
            self.__score = score
        else:
            print('录入错误，分数在0到150之间')

s1 = Student('yueyue', '145')
print(s1.score)  #由于@property方法，从而
# 145
s1.score = -10
# 录入错误，分数在0到150之间

@property把方法名，在调用时当属性来用，返回return里的值
@方法名.setter 将该方法以属性的方式修改

Little Yueyue

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础之Day8 python是面向对象的语言（1）

这里写目录标题面向对象和面向过程区别类的定义语法结构__init__构造方法Python 支持面向过程、面向对象、函数式编程等多种编程范式。将不同类型的数据、方法（即函数）放到一起，就是对象。一个 Python 对象包含如下部分：id（identity 识别码）type（对象类型）value（对象的值）(1) 属性（attribute）(2) 方法（method）面向对象和面向过程区别思维关注程序规模示例面向过程(Procedure Oriented)思维“
复制链接

扫一扫