python语言第八天笔记

最新推荐文章于 2024-06-14 11:20:52 发布

weixin_44457930

最新推荐文章于 2024-06-14 11:20:52 发布

阅读量146

点赞数

分类专栏： python基础文章标签： python

本文链接：https://blog.csdn.net/weixin_44457930/article/details/109701537

版权

python基础专栏收录该内容

14 篇文章 1 订阅

订阅专栏

面向对象（上）

1 面向对象简介

和java、C++一样，这里略

2 实例对象

（1）类的定义

如果把对象比作饼干，那么类就是造饼干的模板。
可以通过类，定义数据类型的属性（数据）和方法（行为）,也就是说，“类将行为和状态打包在一起”。
从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但会有自己的属性值（不共享状态）。更具体一点：“方法代码是共享的，属性数据不共享”。
在这里插入图片描述

（2）类对象与实例对象

python中，一切皆对象，类也称为“类对象”，类的实例也称为“实例对象”
定义类的格式：

class 类名：
	类体

类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
例：一个典型的类的定义

class Student:
    def __init__(self,name,score):  # 构造方法第一个参数必须为 self
        self.name = name            # 实例属性
        self.score = score

    def say_score(self): #实例方法
        print(self.name,'的分数是：',self.score)


s1 = Student('张三',80)               # s1 是实例对象，自动调用__init__()方法
s1.say_score()
print(type(s1))
print(type(Student))

输出

张三 的分数是： 80
<class '__main__.Student'>
<class 'type'>

既然类是对象，那么类对象的模板是什么？类对象的模板是type，也就是说，Student是type的一个实例，当执行 class 语句时，就创建了一个类对象，Student是它的引用。

（3）init方法和new方法

继续用上面的程序段举例，当执行“s1 = Student(‘张三’,80)”时，就创建了一个实例对象，s1是其引用。
在此过程中，现实调用__new__方法创建对象，然后再调用__init__方法实现初始化，在传参的时候，是把实例对象的地址传给 self，或者说，self 是自身对象的引用。

class Student:
    def __init__(self,name,score):  # 构造方法第一个参数必须为 self
        self.name = name            # 实例属性
        self.score = score
        print(id(self))             # 打印本对象的地址

    def say_score(self): #实例方法
        print(self.name,'的分数是：',self.score)


s1 = Student('张三',80)               # s1 是实例对象，自动调用__init__()方法
print(id(s1))

输出

39662304
39662304

注意，__init__方法不是创建对象，而是初始化对象，从这个角度上说，可以称其为“初始化方法”。与C++不同的是，一个类可以没有__init__方法。

（4）实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：
1.实例属性一般在__init__()方法中通过如下代码定义：
self.实例属性名 = 初始值
2. 在本类的其他实例方法中，也是通过 self 进行访问：
self.实例属性名
3. 创建实例对象后，通过实例对象访问：
obj01 = 类名() #创建对象，调用__init__()初始化属性
obj01.实例属性名 = 值 # 可以给已有属性赋值，也可以新加属性

（5）实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def 方法名(self [, 形参列表])：
	函数体

方法的调用格式如下：
对象.方法名([实参列表])
要点：
1.定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。
2.调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。
实例方法调用的示意图
在这里插入图片描述

（6）私有属性和私有方法(实现封装)

关于私有属性和私有方法，有如下要点：
1.通常我们约定，两个下划线开头的属性是私有的(private)，其他为公共的(public)。
2.类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)
方法本质上也是属性！只不过是可以通过()执行而已。所以，此处讲的私有属性和公有属性，也同时讲解了私有方法和公有方法的用法。

#测试私有属性、私有方法

class Employee:

    __company = "百战程序员"	# 私有类属性（类属性后面会介绍）

    def __init__(self,name,age):
        self.name = name
        self.__age = age        #私有属性

    def __work(self):           #私有方法
        print("好好工作，赚钱娶媳妇！")
        print("年龄：{0}".format(self.__age))
        print(Employee.__company)


e = Employee("高淇",18)

print(e.name)
# print(e.__age)            # 报错，因为__age 是私有属性
print(e._Employee__age)     # 使用私有属性需要加“_类名”，类名前一个下划线，类名后两个下划线
print(dir(e))               # 查看e的所有属性和方法
e._Employee__work()         # 调用私有方法，格式与使用私有属性类似，需要在方法名前加“_类名__”
print(Employee._Employee__company)  # 类方法和类属性如果也是私有，那么类外访问方式与使用私有实例属性一样

输出

高淇
18
['_Employee__age', '_Employee__company', '_Employee__work', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
好好工作，赚钱娶媳妇！
年龄：18
百战程序员
百战程序员

前后各有两条下划线的属性或方法，不是私有的，例如__dict__（后面会介绍）、__call__等，这些方法和属性用于特殊用途。自己定义的时候，一般不会把属性和方法写成前后各有两条下划线的的形式，因为这样无法让人知道这是自己定义的还是官方的。

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

__del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用__del__方法。
析构方法可以由程序自动调用，当某个对象没有引用时，或者当对象的生存期结束时，都会自动调用析构方法。当某个对象只有一个变量区引用时，也可以用 del 语句删除变量，实现间接调用。
系统会自动提供__del__方法，一般不需要自定义析构方法。

class Person:
    def __del__(self):		# 在类内重写了析构方法，可以对原析构方法进行覆盖，这里重写是为了演示调用方式
        print("销毁对象：{0}".format(self))


p1 = Person()
p2 = Person()
p3 = Person()
print('1')
del p2			# 注意，这里并非删除对象，而是删除变量 p2，使得相应的对象没有变量去引用，间接调用析构方法
print('2')
p3 = 5
print('3')
print("程序结束")

输出

1
销毁对象：<__main__.Person object at 0x00000000025D3CD0>
2
销毁对象：<__main__.Person object at 0x00000000026044F0>
3
程序结束
销毁对象：<__main__.Person object at 0x00000000025D32E0>

从程序的执行结果来看，第一次调用析构方法是因为 p2 被手动删除，第二次调用是因为 p3 改变了指向，原来的对象没有引用去指向，第三次调用，是因为 p3 的生存期结束。

（8）call方法和可调用对象

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

class SalaryAccount:
    '''工资计算类'''
    def __call__(self, salary):
        yearSalary = salary*12
        daySalary = salary//30
        d = dict(monthSalary=salary,yearSalary=yearSalary,daySalary=daySalary)
        return d

    
s = SalaryAccount()
print(s(5000))

输出

{'monthSalary': 5000, 'yearSalary': 60000, 'daySalary': 166}

（9）其他操作

1.查看对象的所有属性 dir(obj)
2.获取对象的属性字典 obj.__dict__回的是由自己定义的属性构成的字典
2.判断“对象”是不是“指定类型 isinstance（对象,类型）

3 类对象

（1）类属性

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

class 类名：
	类变量名= 初始值

在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。
类属性测试：

class Student:
    company = "SXT" # 类属性
    count = 0 # 类属性

    def __init__(self,name,score):
        self.name = name # 实例属性
        self.score = score
        Student.count = Student.count+1		        # 类属性即使在类内，也必须通过类名调用

    def say_score(self): # 实例方法
        print("我的公司是：",Student.company)
        print(self.name,'的分数是：',self.score)
        
        
s1 = Student('张三',80) # s1 是实例对象，自动调用__init__()方法
s1.say_score()
print('一共创建{0}个 Student 对象'.format(Student.count))

输出

我的公司是： SXT
张三 的分数是： 80
一共创建1个 Student 对象

（2）类方法

类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod
def 类方法名(cls [，形参列表]) ：
	函数体

要点：
1.@classmethod 必须位于方法上面一行
2.第一个 cls 必须有；cls 指的就是“类对象”本身；
3.可以通过类名调用，也可以通过实例对象调用，“类名.类方法名(参数列表)”，或者“实例对象.类方法名”。参数列表中，不需要也不能给 cls 传值。
4.类方法中访问实例属性和实例方法会导致错误
5.子类继承父类方法时，传入 cls 是子类对象，而非父类对象

class Student:
    company = "SXT" #类属性

    @classmethod
    def printCompany(cls):
        print(cls.company)


Student.printCompany()
s = Student()           # 定义了一个Student对象
s.printCompany()        # 可以通过对象调用类方法

输出

SXT
SXT

（3）静态方法

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

@staticmethod
def 静态方法名([形参列表]) ：
	函数体

要点如下：
1.@staticmethod 必须位于方法上面一行
2.调用静态方法格式：“类名.静态方法名(参数列表)”。
3.静态方法中访问实例属性和实例方法会导致错误，但可以访问类属性和类方法
4.静态方法与类方法的边界不是很清晰，可以认为静态方法是没有cls的类方法

class Student:
    company = "SXT" # 类属性

    @staticmethod
    def add(a, b): # 静态方法
        print("{0}+{1}={2}".format(a,b,(a+b)))
        return a+b


Student.add(20,30)

输出

20+30=50

（4）实例对象与类对象的内存分析

以下面的程序为例，分析内存的创建过程

class Student:
    company = "SXT"  # 类属性
    count = 0  # 类属性

    def __init__(self, name, score):
        self.name = name  # 实例属性
        self.score = score
        Student.count = Student.count + 1

    def say_score(self):  # 实例方法
        print("我的公司是：", Student.company)
        print(self.name, '的分数是：', self.score)


s1 = Student('张三', 80)  # s1是实例对象，自动调用__init__()方法
s1.say_score()

s2 = Student("高淇",60)
s3 = Student("高小希",100)

print('一共创建{0}个Student对象'.format(Student.count))

输出

我的公司是： SXT
张三 的分数是： 80
一共创建3个Student对象

在这里插入图片描述

4 与C++、java的区别

（1）方法没有重载

与C++，java语言不同的是，python语言，没有方法重载，如果类体中定义了多个重名的方法，只有最后一个方法有效。
由于在定义函数的时候，不需要声明形参类型，结合默认参数，完全不需要重载这项功能。

（2）方法与属性的动态性

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

class Person:
    def work(self):
        print("努力上班！")


def play_game(self):
        print("{0}玩游戏".format(self))


def work2(s):
    print("好好工作，努力上班！")


Person.play = play_game     # 在类外增添新的方法
Person.work = work2         # 在类外修改已有的方法
p = Person()
p.play()                    
p.work()
p2 = Person()
p2.play()

输出

<__main__.Person object at 0x00000000026132E0>玩游戏
好好工作，努力上班！
<__main__.Person object at 0x00000000025F4220>玩游戏

我们可以看到，Person 动态的新增了 play_game 方法，以及用 work2 替换了 work 方法，由于方法是共享的，所以对 p2 也有效。

与方法的动态性类似，属性也有动态性。

class Student:
    def __init__(self,name,score):  # 构造方法第一个参数必须为 self
        self.name = name            # 实例属性
        self.score = score


s1 = Student('Jim', 90)
s1.number = 13201070101
print(s1.number)

s2 = Student('Win', 91)
print(s2.__dict__)

输出

40060048
13201070101
40097344
{'name': 'Win', 'score': 91}

可以看到，s1在类外也定义了一个属性，但是这个属性只有s1有，s2没有，因为属性不是共享的。

（3）property装饰器

@property 可以将一个方法的调用方式变成“属性调用”，某个方法一旦被@property装饰，就不能像之前那样被调用

class Employee:

    @property
    def salary(self):
        print("salary run...")
        return 10000


emp1 = Employee()
# emp1.salary()
print(emp1.salary)

输出

salary run...
10000

在java中，如果某个属性是私有属性，通常是写两个函数 getter 和 setter 来实现对这个属性的读取和修改，这里可以通过装饰器来实现同样的功能。

class Employee:

    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary      # 私有属性

    @property
    def salary(self):
        return self.__salary

    @salary.setter					# 把salary方法变成setter
    def salary(self,wage):
        if 1000<wage<50000:
            self.__salary = wage
        else:
            print("录入错误！薪水在1000--50000这个范围")


emp1 = Employee("高淇",30000)
print(emp1.salary)			# emp1.salary相当于emp1.salary()
emp1.salary = 2000			# 相当于emp1.salary(2000)
print(emp1.salary)

输出

30000
2000

weixin_44457930

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python语言第八天笔记

面向对象（上）文章目录面向对象（上）1 面向对象简介2 实例对象（1）类的定义（2）类对象与实例对象（3）__init__方法和__new__方法（4）实例属性（5）实例方法（6）私有属性和私有方法(实现封装)（7）__del__方法(析构函数)和垃圾回收机制（8）__call__方法和可调用对象（9）其他操作3 类对象（1）类属性（2）类方法（3）静态方法（4）实例对象与类对象的内存分析4 与C++、java的区别（1）方法没有重载（2）方法与属性的动态性（3）property装饰器1 面向对象简介
复制链接

扫一扫