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

定义

class ClassName(object):
    <statement - 1>
    ……
    <statement - N>

class：表明这是一个类

ClassName：类的名字

()：父类集合的开始和结束

object：父类的名字，定义的类继承自父类，可不写，默认object。

object：所有类的直接或间接父类

class Player(object): #object基类
    pass

tom = Player() #类的实例化（创建对象）
print(type(tom))

1. 在程序中设计表格：设计类（class）

class Student:
    name = None #记录学生姓名

2. 在程序中打印生产表格：创建对象

stu_1 = Student() #基于类创建对象
stu_2 = Student()

3. 在程序中填写表格：对象属性赋值

为学生1、学生2对象赋予名称属性值：

stu_1.name = "张蘑菇" 

stu_2.name = "李蘑菇"

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

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

石蘑菇

南沙群岛

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()

调用实例方法

类的使用

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

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

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

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

创建类对象

对象 = 类名称( )

例子

结果

类中定义成员方法

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("好")

我是赵蘑菇,好

class Clock:
    id = None
    price = None

属性

def ring(self):
        import winsound
        winsound.Beep(20,30)

行为

创建对象

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

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

魔术方法

__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

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

私有成员变量

私有成员方法

定义私有成员的方式：

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

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

报错

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

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

正确

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

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

单继承

多继承

cLass 类名(父类1):
    类内容体

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

继承

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

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

class MyPhone(Phone, NFCReader):
    pass

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

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

方法一

调用父类成员

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

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

方法二

使用super()调用父类成员

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

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

基础数据类型注解

变量: 类型

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

形参

注解

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

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

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)

class Animal:
    def speak(self):
        pass

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

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

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