python笔记进阶--面向对象（2）

1.设计一个类（类比生活中，设计一张登记表）
class Student:
    name = None   #记录学生姓名
    gender = None #记录学生性别
    nationality = None #记录学生国籍
    native_place = None #记录学生籍贯
    age = None    #记录学生年龄

个人登记表：

姓名
性别
国籍
籍贯
年龄

2.创建一个对象（类比生活中：打印一张登记表）
stu_1 = Student()

3.对象属性进行赋值（类比生活中：填写表单）
stu_1.name = "石蘑菇"
stu_1.gender = "女"
stu_1.nationality = "中国"
stu_1.native_place = "南沙群岛"
stu_1.age = 18

姓名	石蘑菇
性别	女
国籍	中国
籍贯	南沙群岛
年龄	18

4.获取对象中记录的信息
print(stu_1.name)
print(stu_1.native_place)

石蘑菇

南沙群岛

1.1.2类中增加属性

class Player(object):	定义对象
numbers = 0 max_damage = 10000 levels = ['青铜','白银','黄金','钻石','王者']
def __init__(self, name, age): # 初始化函数（构造函数） self.name = name # 实例属性 self.age = age self.level = level	初始化函数（构造函数）
weapon.numbers += 1 if damage>weapon.max_damage: raise Exception('最大的伤害值是10000，请重试！') #返回错误 if level not in weapon.levels: raise Exception('段位设置错误！') #返回错误
def show(self): # 实例的方法 print('第%d个玩家，名字是%s，来自%s，段位是%s' % (Player.numbers,self.name,self.city,self.level))	实例方法
@classmethod #装饰器 def get_players(cls): # 类方法 print('荣耀王者的用户数量已经达到了%d人'%cls.numbers)	类方法
@staticmethod def isvalid(kwargs): if kwargs['age']>18: return True else: return False infos = {'name':'mia','age':13,'city':'北京','level':'白银'} if Player.isvalid(infos): mia = Player('mia',24,'北京','白银') else: print('请检查')	静态方法：做验证、判断、计算
gun = weapon('magic_gun',1000,'青铜') mia.show()	调用实例方法

1.2成员方法（类）

1.2.1类的定义和使用语法

类：可以定义属性用来记录数据

可以定义函数，用来记录行为

类的使用

class 类名称:
类的属性
类的行为

class关键字，表示要定义的类

类的属性：定义在类中的变量（成员变量）

类的行为：定义在类中的函数（成员方法）

创建类对象

对象 = 类名称( )

1.2.2成员方法的使用

方法：定义在类内部的函数

例子

结果

类中定义成员方法

def 方法名(self, 形参1, …,形参N):
方法体

class Student:
   name = None
   def say_hi(self):
      print(f"我是{self.name}")

stu_1 = Student()
stu_1.name = "赵蘑菇"
stu_1.say_hi()

我是赵蘑菇

class Student:
   name = None
   def say_hi(self,msg):
      print(f"我是{self.name},{msg}")
stu_1 = Student()
stu_1.name = "赵蘑菇"
stu_1.say_hi("好")

我是赵蘑菇,好

1.2.3self关键字的作用

用来表示类对象自身的意思

当使用类对象调用方法的是，self会自动被python传入

在方法内部，想要访问类的成员变量，必须使用self

1.3类和对象

class Clock: id = None price = None	属性
def ring(self): import winsound winsound.Beep(20,30)	行为

1.3.1面向对象编程

使用对象进行编程。类只是一种程序内的“设计图纸”，要基于图纸生产实体（对象），才能正常工作。

创建对象	#创建1个闹钟对象并让工作 clock1 = Clock() clock1.id = "001" clock1.price = 199 clock1.ring()

2．构造方法

构造方法：__init__( )方法

可以实现：在创建类对象（构造类）的时候，会自动执行。

在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。

class Student:
    def __init__(self, name, age):
       self.name = name
       self.age = age
       print("Student类创建了一个类对象")
stu = Student("王蘑菇", 31)
print(stu.name, stu.age)

构建类时传入的参数会自动提供给__init__方法

构建类的时候__init__方法会自动执行

结果：

Student类创建了一个类对象

王蘑菇 31

3．其他内置方法

__init__ 构造方法，是Python类内置的方法之一。

这些内置的类方法，各自有各自特殊的功能，这些内置方法称为：魔术方法

魔术方法	__init__	构造方法
	__str__	字符串方法	控制类转换为字符串的行为
	__lt__	> 和 < 符号比较
	__le__	≥ 和 ≤ 符号比较
	__eq__	==符号比较

class Student: def __init__(self, name, age): self.name = name # 学生姓名 self.age = age # 学生年龄 def __str__(self): return f"Student类对象，name:{self.name}, age:{self.age}" def __lt__(self, other): return self.age < other.age def __le__(self, other): return self.age <= other.age def __eq__(self, other): return self.age == other.age stu1 = Student("周蘑菇", 31) stu2 = Student("林蘑菇", 36)
print(stu1 <= stu2)	结果：True
print(stu1 == stu2)	结果：False

4．封装

面向对象编程，是许多编程语言都支持的一种编程思想。

简单理解是：基于模板（类）去创建实体（对象），使用对象完成功能开发。

面向对象包含3大主要特性：封装、继承、多态

封装：将现实世界事物在类中描述为属性和方法。

4.1封装

封装将现实世界事物的：属性、行为。封装到类中，描述为：成员变量、成员方法

属性、行为：对用户开放的、隐藏的属性和行为

4.2私有成员

使用情况：现实事物有部分属性和行为是不公开对使用者开放的。

意义：在类中提供仅供内部使用的属性和方法，而不对外开放（类对象无法使用）

类中提供了私有成员的形式来支持。

私有成员变量

私有成员方法

定义私有成员的方式：

私有成员变量：变量名以__开头（2个下划线）

私有成员方法：方法名以__开头（2个下划线）

注：

报错

有方法无法直接被类对象使用

私有变量无法赋值，也无法获取值

正确

私有成员无法被类对象使用，

但可以被其它的成员使用。

5．继承

继承表示：将从父类那里继承（复制）来成员变量和成员方法（不含私有），继承以前的功能

继承分为：单继承和多继承

单继承	多继承
cLass 类名(父类1): 类内容体	cLass 类名(父类1,…,父类N ): 类内容体

继承→子类，被继承→父类

		继承
		cLass 类名(父类1,…,父类N ): 类内容体

5.1补全语法pass

继承后不需要修改内容时，用pass

class MyPhone(Phone, NFCReader):
pass

5.2复写

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。

即：在子类中重新定义同名的属性或方法即可。

5.3调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

如果需要使用被复写的父类的成员，需要特殊的调用方式:

方法一

调用父类成员

使用成员变量：父类名.成员变量

使用成员方法：父类名.成员方法(self)

方法二

使用super()调用父类成员

使用成员变量：super().成员变量

使用成员方法：super().成员方法()

6．类型注解【变量: 类型】

方便静态类型检查工具，IDE等第三方工具。

类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）。

主要功能：帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示

帮助开发者自身对变量进行类型注释

支持：函数（方法）形参列表和返回值的类型注解

变量的类型注解

无法直接看出变量类型之时会添加变量的类型注解

基础数据类型注解变量: 类型	var_1: int = 10 var_2 : float = 3.1415926 var_3: bool = True var_4: str = "mogu"
类对象类型注解变量: 类型	class student: pass stu : student = student()
基础容器类型注解变量: 类型	my_list: list = [1,2,3] my_tup1e: tuple = (1,2,3) my_set: set = {1,2,3} my_dict: dict = {"mogu": 666} my_str: str = "mogu"
容器类型详细注解变量: 类型	my_list: list[int] = [1,2,3] my_tuple: tuple[str,int,bool] = ("itheima",666,True) my_set: set[int] = {1,2,3} my_dict: dict[str, int] = {"itheima" : 666}
在注释中进行类型注解 # type: 类型	var_1 = random.randint(1,10) # type:int var_2 = json.loads(data) # type:dict[str,int] var_3 = func() # type:student

6.1函数（方法）类型注解

形参

注解

def 函数方法名(形参名:类型, ……):
pass

def add(x: int,y: int):
return x + y

返回值

注解

def 函数方法名(形参:类型, ……)->返回值类型:
pass

def add(x: int, y: int) -> int:
return x +y

def func(data: list[int]) -> list[int]:
pass

6.2 Union类型

Union[类型, ......,类型]

定义联合类型注解

from typing import Union
my_1ist: list[Union[str, int]] = [1, 2, "itheima", "itcast"]
my_dict: dict[str, Union[str, int]] = { "name": "周杰轮", "age": 31}

函数中定义

def func(data: Union[int,str]) -> Union[int,str]:
pass

Union联合类型注解，在变量注解、函数（方法）形参和返回值注解中，均可使用。

7．多态

多态：多种状态，完成某个行为时，使用不同的对象会得到不同的状态。

class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("汪汪汪")
class Cat(Animal):
    def speak(self):
        print("喵喵喵")

多态

→

def make_noise(animal: Animal):
"""制造点噪音，需要传入Animal对象"""
animal.speak()
# 演示多态，使用2个子类对象来调用函数
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)

多态常作用在继承关系上

比如：函数(方法)形参声明接收父类对象、实际传入父类的子类对象进行工作

即：以父类做定义声明、以子类做实际工作、用以获得同一行为, 不同状态

7.1抽象类（接口）

配合多态：完成抽象的父类设计（设计标准）

具体的子类实现（实现标准）

class Animal:
def speak(self):
pass

父类用来确定有哪些方法，具体的方法实现，由子类自行决定。

抽象类：含有抽象方法的类称之为抽象类

抽象方法：方法体是空实现的（pass）称之为抽象方法

double_自

关注

24
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
python笔记进阶--面向对象（2）

继承表示：将从父类那里继承（复制）来成员变量和成员方法（不含私有），继承以前的功能。在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。object：父类的名字，定义的类继承自父类，可不写，默认object。意义：在类中提供仅供内部使用的属性和方法，而不对外开放（类对象无法使用）一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员。多态：多种状态，完成某个行为时，使用不同的对象会得到不同的状态。在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）。
复制链接

扫一扫