python基础⑩-面向对象

系列文章目录

---

python基础①-基础环境搭建和工具使用
python基础②-常用的各种数据类型初认知
python基础③-数据类型常用的操作和方法字符串、数值、bool
python基础④-数据类型常用的操作和方法列表、元组、字典、集合
python基础⑤-控制流程
python基础⑥-函数
python基础⑦-字符编码与文件操作
python基础⑧-异常
python基础⑨-迭代器和生成器
python基础⑩-面向对象
python基础⑪-继承与派生
python基础⑫-多进程
python基础⑬-多线程
python基础⑭-进程池、线程池、协程
python基础⑮-网络编程socket
python基础⑯-网络编程socket进阶

何为面向对象

参考百度百科https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/2262089?fr=aladdin

python类的使用

1. 类本质是一个用来存放变量与函数的容器
2. 类的用途之一就是当做容器从其内部取出名字来使用
3. 类的用途之二是调用类来产生对象 接下来讲对象

定义类以及 __dict__方法

'''
类
老师
属性
    name='小王'
    age=18
    sex='男'
技能
    吹牛逼
# class 定义类的关键字    类名首字母大写（约定俗成的）
class 类名:
    pass
复杂的类名和变量一样
# 驼峰体
AgeOfDahai = 18
定义示例：
class Person:
    pass
'''
#1. 先定义类
class Teacher:
    # 相同的特征/属性
    name = '小王'
    age = 18
    sex = '男'
    #
    # 函数/方法/技能
    def chuiniubi(self):
        # self到底是什么？
        # self当做一个位置形参
        print('chuiniubi')
    # 测试
    print('类的定义我运行了')
#类是一系列对象相同的属性(变量)与技能(函数)的结合体,
# 即类体中最常见的就是变量与函数的定义
# 类体代码会在类定义阶段立即执行,会产生一个类的名称空间,
print(Teacher.__dict__)

类的属性

# 调用类的属性
print(Teacher.name)
print(Teacher.age)

# 类的方法其实就是函数
print(Teacher.chuiniubi)

# 函数加括号调用
# ？？？？？
# self我们现在把它当作一个位置形参，但是为什么定义成self呢？
Teacher.chuiniubi(111)

# # 不存在的属型或者方法会报错
# print(Teacher.xxx)

# 修改类属性的值
Teacher.name = '小戴'
print(Teacher.name)

# 添加类的属性
Teacher.play = 'LOL'
print(Teacher.__dict__)

# 删除属性
del Teacher.play
print(Teacher.__dict__)

对象的使用

通过类创建对象

#1. 先定义类
class Teacher:
    # 相同的特征/属性
    name = '小王'
    age = 18
    sex = '男'
    #
    # 函数/方法/技能
    def chuiniubi(self):
        # self到底是什么？
        # self当做一个位置形参
        print('chuiniubi')
        return 'aaaa'
#2. 后调用类来产生对象:
# 调用类的过程称之为类的实例的初始化,调用类的返回值称之为类的一个对象/实例
# 调用类发生了?
# 类是抽象  对象/实例是具象

# 产生3个老师对象
t1=Teacher()
t2=Teacher()
t3=Teacher()

# 生成的对象拥有类的属性和方法
print(t1.name)
print(t2.name)
print(t3.name)

# 对象的方法
print(t1.chuiniubi)
print(t2.chuiniubi)
print(t3.chuiniubi)

对象的属性

## 这些对象没有独立的属性，用的是类的属性和方法
print(Teacher.__dict__)
print(t1.__dict__)
print(t2.__dict__)
print(t3.__dict__)

# ?????
#对象的方法执行，没有传入参数，self到达是什么？
t1.chuiniubi()

# 对比类方法执行,需要传入参数
Teacher.chuiniubi(111)

# 一样有return
print(Teacher.chuiniubi(111))

print(t1.chuiniubi())

# 对象属性的修改
# t1.name = '夏洛'
print(t1.name)

# 这个属性是对象独立的
print(t1.__dict__)

# 删除对象的属性
del t1.name

# print(t1.name)

对象生成的__init__方法

以双下划线开头且以双下划线结尾的固定方法，他们会在特定的时机被触发执行，
__init__就是其中之一，它会在实例化之后自动被调用，以完成实例的初始化。

#1. 先定义类
class Teacher:
    school = '家里蹲'
    # 相同的特征/属性
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    #
    # 函数/方法/技能
    def chuiniubi(self,name):
        # self到底是什么？
        # self当做一个位置形参
        print('%s在吹牛逼'%name)
# 实例初始化的时候必须传入参数，生成了对象的属性
xiaowang=Teacher('小王',18,'男')
xiaodai=Teacher('小戴',18,'女')

print(xiaowang.name)
print(xiaodai.name)

# __init__方法传入的属性类是没有的
# print(Teacher.name)

# 只是初始化的时候传入了参数，对象还是可以改属性值
xiaowang.name = '小周'
print(xiaowang.name)

# 对象方法传入参数有其他参数
xiaowang.chuiniubi('小付')

类的属性与对象属性的关系

class Teacher:
    school = '家里蹲'
    # 相同的特征/属性
    xxx = '我是类的属性,也可能是对象的属性'
    yyy = 11111
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    #
    # 函数/方法/技能
    def chuiniubi(self):
        # self到底是什么？
        # self当做一个位置形参
        print('%s在吹牛逼'%self.name)

xiaowang=Teacher('小王',18,'男')
xiaodai=Teacher('小戴',18,'女')
xiaoyang=Teacher('小杨',17,'女')

对象属性查找优先级

属性优先找对象，对象没有才去类里面找

# 对象属性的查找
# 添加一个对象属性
xiaowang.xxx = '我是对象的属性'
# 属性优先找对象，对象没有才去类里面找
print(xiaowang.xxx)

类的属性变更与对象属性变更

# 类中定义的属性和方法是所有对象共享的,类可以用，对象也可以用
# 类的属性给对象调用
print(id(xiaowang.yyy),xiaowang.yyy)
print(id(xiaodai.yyy),xiaodai.yyy)
print(id(xiaoyang.yyy),xiaoyang.yyy)
# 类自己用
print(id(Teacher.yyy),Teacher.yyy)

# 类的属性变
Teacher.yyy = 33333
xiaowang.yyy = 22222
# 类的属性给对象调用
# 对象已经有了yyy属性的会优先考虑自己的
print(id(xiaowang.yyy),xiaowang.yyy)
# 其他没有对象yyy属性的都会跟随类yyy属性的改变而改变
print(id(xiaodai.yyy),xiaodai.yyy)
print(id(xiaoyang.yyy),xiaoyang.yyy)
# 类自己用
print(id(Teacher.yyy),Teacher.yyy)

类的方法与对象的方法

# ？？？？？？
# 对象调用类的方法,不需要传入参数？
print(id(xiaowang.chuiniubi))
xiaowang.chuiniubi()

print(id(xiaodai.chuiniubi))
xiaodai.chuiniubi()

print(id(xiaoyang.chuiniubi))
xiaoyang.chuiniubi()


# 类调用方法必须传入self参数对应的对象,因为方法里面需要使用这个self对象
Teacher.chuiniubi(xiaowang)
Teacher.chuiniubi(xiaodai)
Teacher.chuiniubi(xiaoyang)

绑定方法与非绑定方法

1、绑定方法（精髓在于自动传值）
特性：绑定给谁就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入
绑定方法分为两类:
1.1 绑定给对象方法
在类内部定义的函数（没有被任何装饰器修饰的），默认就是绑定给对象用的
1.2 绑定给类的方法：
在类内部定义的函数如果被装饰器 @classmethod 装饰，
那么则是绑定给类的，应该由类来调用，类来调用就自动将类当作第一个参数自动传入
2、非绑定方法（不会自动传值，就是一个 普通函数）
类中定义的函数如果被装饰器 @staticmethod 装饰，那么该函数就变成非绑定方法
优点
既不与类绑定，又不与对象绑定，意味着类与对象都可以来调用
缺点
但是无论谁来调用，都没有任何自动传值的效果，就是一个普通函数
3 作用
如果函数体代码需要用外部传入的类，则应该将该函数定义成绑定给类的方法
如果函数体代码需要用外部传入的对象，则应该将该函数定义成绑定给对象的方法
如果函数体代码既不需要外部传入的类也不需要外部传入的对象，则应该将该函数定义成非绑定方法/普通函数

# 类和对象的方法到底是怎样的
# 我们一起来探究一下真相
# self绑定给对象方法
# 简单来说就是对象在调用方法的时候会自动把该对象传入
# 该方法的参数一般这个参数我们用self表示
class A:
    # 作者@selfmethed省略了
    # 因为类里面的方法大部分情况下是给实例化后的对象用
    def f(self, n):
        print(self, n)
        print('我是self的方法')


a = A()
print(a)
print('==========')
# 是哪个对象调用的self参数的方法，那么传入的self就是那个对象
a.f(2)
# 类调用必须传入对象
A.f(a, 2)


# 绑定给类的方法
class B:
    @classmethod
    def f(cls, n):
        print(cls, n)
        print('我是绑定类的方法')


print(B)
print('========')
B.f(1)



# 非绑定方法/静态方法
class C:

    @staticmethod
    def f(n):
        print(n)
        print('我是非绑定方法/静态方法')


# 纯粹的函数，不会自动传入对象或者类
C.f(1)

c = C()

# 纯粹的函数，不会自动传入对象或者类
c.f(2)

一切皆对象

# 在python中统一了类与类型的概念
class Foo():
    pass
# <class '__main__.Foo'>
print(Foo)
obj = Foo()
# print(obj)
# <class '__main__.Foo'>
print(type(obj))

print(str)
# ctrl 按住不动 点击鼠标左键
name = str('dahai')
# 其实python在'dahai'的前面自动加了一个str类
print(type(name))