3.28

python基础笔记

一.对象和类

1.对象：拥有属性和行为的个体 python中的一切都是对象

2.面向对象：以对象为中心，去思考和组织代码的方式

3.类：用来描述一类事物的模板，他规定了这一类事物所具有的属性和方法

4.实例：根据类创建出来的具体的对象

5.实例化：根据类创造实例的过程

6.方法:被定义在类里面的函数

class Person:
    #当一个函数定义在类里时，他被称为方法
    #__init__:初始化方法,给当前的实例对象添加属性
    #__init__接受的参数就是当前创建的实例对象
    def __init__(self,name,age):
        #给实例添加属性（self.属性名 = 值）
        self.name = name
        self.age =age
​
p1 = Person('w',19)
p2 = Person('a',19)
#如果直接打印实例对象，返回是内存地址
print(p1)
#如果想要查看实例身上的属性（实例，属性）
print(p1.name)
#查看实例身上所有的属性(实例.__dict__)
print(p2.__dict__)
#可以给实例追加新的属性(实例.属性名 = 值)
p2.gender = '男'
print(p2.__dict__)
#通过type可以查看实例是由哪个类创建的
print(type(p1))
​
  运行结果：
<__main__.Person object at 0x000002C8FEF44C20>
w
{'name': 'a', 'age': 19}
{'name': 'a', 'age': 19, 'gender': '男'}
<class '__main__.Person'> 
​

二.自定义方法

1.定义：定义在类里面的函数

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    #自定义方法
    #speak方法收到的参数是调用speak方法的实例对象
    def speak(self,msg):
        print(f'我是{self.name},我今年{self.age},{msg}')
p1 = Person('a',18,'男')
#可以验证speak在Person类身上
print(Person.__dict__)
​
#通过Person类创建的实例对象都可以调用speak方法
p1.speak('我想打游戏')  #查找顺序：1.实例对象自身，2.实例的创造者 类
​
def speak():
    print('我是外层函数')
p1.speak = speak  #前一个speak是属性 后一个speak是函数
p1.speak() #相当于是speak() 
#给p1赋值一个新的属性
p1.hobby= '打球'
print(Person.__dict__)
​
​

三.实例属性和类属性

1.实例属性：属于某一个具体对象，自己独有，别人改也不影响你

2.类属性：属于类本身，所有对象共享同一份

3.区别：类属性归Person类所有，全类共享，只有一份

实例属性归每个实例自己所有，每个实例各存一份，互不干扰

4.访问方式：类属性通过类.属性去访问，实例对象.类属性也可以访问

实例属性只能实例对象.类属性去访问，类.实例属性会报错

5.修改方式：类.类属性 = 新值

如果用实例去改类属性 实例.类属性 = 新值

✖ 不是修改类属性！

✔ 是给 p1 新增了一个同名实例属性，把类属性遮住了。

6.查找顺序

先看 p1 自己的实例属性（p1.__dict__）

找不到 → 去所属类里找类属性

再找不到 → 去父类找

都没有 → 报错

	实例属性	类属性
定义位置	__init__ 里 self.xxx	类内、方法外
归属	单个实例	整个类
共享	独立，互不影响	所有实例共享
修改	只影响自己	影响全部实例
访问	只能 实例.属性	类.属性 / 实例.属性

class Person:
    max_age = 150
    plant = '地球'
    def __init__(self,name,age,gender):
        self.name = name
        self.gender =gender
        if age <= Person.max_age:
            self.age = age
        else:
            print('年龄很大')
            self.age = 120
​
p1 = Person('a',160,'nan')
print(p1.name)
p1.name = 'b'
print(p1.name)
#验证实例身上没有类属性
print(p1.__dict__) #答案是没有
#验证所有实例都可以访问类属性
print(p1.max_age) #先查找自身属性 在查找类属性
# print(p2.plant)
p1.age = 160
#__init__ 里的判断只在创建实例时生效
#后期你直接 p1.age = 160，是直接赋值覆盖实例属性，不会再走 __init__ 的校验逻辑
#所以最终输出 160，而不是 120。
print(p1.age)

四.类方法 静态方法 实例方法

1.实例方法

写法：无装饰器，第一个参数必须是 self

给谁用：实例对象

能干啥：访问 / 修改 实例属性

调用：只能通过 实例 调用

class Person:
    def __init__(self, name):
        self.name = name  # 实例属性
​
    # 实例方法
    def say_hi(self):
        print(f"我是 {self.name}")
​
p = Person("张三")
p.say_hi()    # ✅ 正确
# Person.say_hi()  # ❌ 报错，必须传实例

2.类方法

写法：加 @classmethod，第一个参数是 cls

给谁用：类本身

能干啥：访问 / 修改 类属性

调用：类、实例都能调用

class Person:
    species = "人类"  # 类属性
​
    @classmethod
    def show_species(cls):
        print(f"人类：{cls.species}")
​
Person.show_species()  # ✅ 类直接调用
p = Person("张三")
p.show_species()       # ✅ 实例也能调用

3.静态方法

写法：加 @staticmethod

特点：没有 self、没有 cls，和普通函数一样

能干啥：只做逻辑处理，不访问实例、不访问类

调用：类、实例都能调用

class Person:
    @staticmethod
    def is_adult(age):
        return age >= 18
​
print(Person.is_adult(20))  # ✅
p = Person("张三")
print(p.is_adult(17))       # ✅

类型	装饰器	第一个参数	访问对象	调用者
实例方法	无	self	实例属性	实例
类方法	@classmethod	cls	类属性	类 / 实例
静态方法	@staticmethod	无	都不访问	类 / 实例

五.继承

1.定义：一个类继承另外一个类的属性和方法

父类 / 基类：被继承的类（如 Person、Work）

子类 / 派生类：继承别人的类（如 Student）

2.单继承

class 子类(父类):
    pass

3.多继承

class Student(父类1, 父类2):
    pass

class Student(Person, Work):
    def __init__(self, name, company, age):
        # 手动调用父类构造，初始化父类属性
        Person.__init__(self, name)
        Work.__init__(self, company)
        # 自己的属性
        self.age = age

4.方法查找顺序，

子类 → 左父类 → 右父类 → object

#用于记录类的查找顺序
print(Student.__mro__)

六.方法重写

1.定义：如果子类定义了与父类相同的方法，则子类覆盖了父类的方法

方法运行顺序：子类 → 左父类 → 右父类 → object

class A:
    def test(self):
        print('A')
​
class B:
    def test(self):
        print('B')
​
class C(A, B):
    # 重写 test
    def test(self):
        print('C')
​
c = C()
c.test()  # 输出 C

七.两个常用方法

1.isinstance(obj ,Class):判断对象是否为指定的类或其子类的实例

2.issubclass(sub,Supper):判断一个类是否为另外一个类的子类

class Person:
    pass
​
class Student(Person):
    pass
​
# 创建对象
p = Person()
s = Student()
​
print(isinstance(s, Student))   # True  自己类的实例
print(isinstance(s, Person))    # True  子类也是父类的实例
print(isinstance(p, Student))   # False 父类实例不是子类实例

2.issubclass(sub,Supper):判断一个类是否为另外一个类的子类

class Person:
    pass
​
class Student(Person):
    pass
​
print(issubclass(Student, Person))  # True
print(issubclass(Person, Student))  # False
print(issubclass(Person, object))   # True 所有类默认继承 object

type() 只看精确类型，不会认子类；

isinstance 会认子类，更常用。