python面向对象学习

于 2021-09-04 17:58:30 发布
阅读量257 收藏 1
点赞数 1
分类专栏： 运维python脚本基础学习 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44014460/article/details/120103249
版权

1. 定义一个类

class Student:#定义类首字母大写，若有多个单词则用驼峰原则，如GoodSteduent
    def __init__(self,name,score):#定义属性，若有多个参数，则self必须在第一个参数位置
        self.name = name#self.name其中name就是实例属性名,self就是实例对象因为一个
                        # 类可以又多个实例对象，所以用self来区别实例对象的方法和属性。
        self.score = score
    def say_score(self):#定义普通方法,数据的处理
        print('{0}的分数是{1}'.format(self.name,self.score))

print('Studebt的类型是',type(Student))#<class 'type'>Student是类型对象

s1 = Student('万泉河',89)#通过类名()调用类里边的构造函数__init__()并创建一个对象，该对像含有name和score两个属性
                        #self存储的是构造函数__init__()创造的对象的地址。故参数就不用添加self的了
s1.say_score()#调用实例方法(方法)
print(s1.name)#调用实例属性(状态)

2. 实例的属型

#实例属性是不可共享的，只是按类创建但保存自身的值
class Student:
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))
s1 = Student('赵雪',97)#创建实例对对象s1
s1.say_score()

#实例属性可以通过以下方法添加属性
s1.age = 19
s1.salary = 3000
print('姓名:{0},年龄{1},分数{2},薪资{3}'.format(s1.name,s1.age,s1.score,s1.salary))

#注意，若我再通过定以s2来添加，s2不会含有age和salary这两个属性。s2的属性按照类student(模型)创建
'''s2 = Student()
print(s2.name)会报错TypeError: __init__() missing 2 required positional arguments: 'name' and 'score'
这说明s1和s2是两个对象'''

#创建实例对象s2
s2 = Student('赵雪',77)
s2.say_score()
#print(s2.salary),s2并不指向s1
print('s1地址{0}，s2地址是{1}'.format(id(s1),id(s2)))#s1地址2051865515008，s2地址是2051865515176

3 实例方法

#类的方法是可以共享的。故代码在类里边，实例对象只是通过指针调用类的方法，并不保存方法
class Student:
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))
s1 = Student('赵雪',97)

#下面两种调用实例方法是等价的
s1.say_score()#程序员写法
Student.say_score(s1)#解释器翻译法

4.实例属性和方法的其他操作

#主要介绍dir(),的用法
#dir(obj)可以获得对象的所有属性和方法
class Student:
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))
s1 = Student('wan',89)
# print(dir(Student))
print(dir(s1))

# #obj.__dict__获得属性字典
# print(Student.__dict__)
print(s1.__dict__)

#pass定义一个空对象,什么都不干
class Man:
    pass
#isinstance判断对象是否是某个类
print('s1是不是Student类的对象',isinstance(s1,Student))
print('s1是不是Man类的对象',isinstance(s1,Man))

5.特殊属型测试

# 测试特殊属性
class A:
    pass


class B:
    pass


class C(B, A):
    def __init__(self, name):
        self.name = name

s = C(3)
print('s的所有属性', dir(s))               # 打印类s的所有属性
print('s的属性字典', s.__dict__)
print('s所属的类', C.__class__)
print('s的直接父类', C.__bases__)
print('s的父类层次', C.__mro__)
print('A的子类', A.__subclasses__())

6.类对象

#当程序执行到class时解释器就会创造一个student类对象
class Student:                                  #创建类对象
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))
stu2 = Student                                  #将类对象赋值给stu2
s1=Student('wan',100)
s2 = stu2('zhao',89)
s1.say_score()
s2.say_score()

7.定义类属型

#定义类属性，在初始实例对象（属性和方法）外定义的变量就是类属性
#引用格式为类名.类属性
class Student:
    company = '九州迪飞'#这是一个类属性
    count = 0#这也是一个类属性
    def __init__(self,name,score):
        self.name = name
        self.score = score
        Student.count += 1
    def say_score(self):
        print('我们的公司是',Student.company)
        print('{0}的分数是{1}'.format(self.name,self.score))
        print(Student.count)
s1 = Student('wan',100)
s2 = Student('赵雪',30)
s3 = Student('liu',40)#生成了3个实例对象，则调用了三次__init__函数。则计数为3
s1.say_score()

8.类方法的定义

#测试类方法和静态方法
#定义类方法,以@classmethod开头，调用以类名.类方法
class Student:
    count = 0
    @classmethod                        #定义类方法
    def company(cls):
        print('这是一个类方法')
        print(cls.count)                #cls就代表Student
    def __init__(self,name,score):      #__init__也是方法，故里边可以像普通函数一样写。
        self.name = name
        self.score = score
        Student.count += 1
    def say_score(self):
        print(self.name,self.score)
        Student.company()

s1 = Student('zhao',78)
s2 = Student('wan',88)
s1.say_score()
'''类方法可以调用类属性的数据，但不能调用实例对象的数据。
但是实例对象可以调用类属性和类方法
实例属性和实例方法，是依附实例对象的。只有创建了实例对象
才可调用实例属性和实例方法，这就是为什么类对象不能操做实例对象而实例对象可以操作类对对象
'''

9.类方法写向量坐标

# 通过类方法写向量坐标
# 可以看出，类方法还可以直接调用类自身。
import math
class Vector2:
    # 初始化坐标
    def __init__(self, x=0.0, y=0.0):
        self.x = x
        self.y = y

    def __str__(self):
        return "向量(%s,%s)" % (self.x, self.y)

    # 计算两点之间的向量,为什么要定义类变量？
    @classmethod
    def from_point(cls, p1, p2):  # 以元组形式传入两个坐标
        return cls(p2[0]-p1[0], p2[1]-p1[1])

    # 计算向量的模长方法
    def norm_vector(self):
        norm = math.sqrt(self.x**2 + self.y**2)
        return norm

    # 计算单位向量
    def unit_vector(self):
        norm = self.norm_vector()
        x = self.x / norm
        y = self.y / norm
        return x, y

    # 重构向量的运算方法
    def __add__(self, other):
        if isinstance(other, Vector2):
            return Vector2(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        if isinstance(other, Vector2):
            return Vector2(self.x - other.x, self.y - other.y)

    def __mul__(self, other):
            return Vector2(self.x*other, self.y*other)

A = (20, 30)
B= (2, 54)
C = (0, 0)
D = (13, 53)
# 打印实例对象，就是打印__str__中的字符串信息
print(Vector2.from_point(A, B))
# 查看实例对象的类型
print(type(Vector2.from_point(A, B)))
# 创建向量对象，实例方可以创建对象
v1 = Vector2.from_point(A, B)
v2 = Vector2.from_point(C, D)
v3 = Vector2(40,30)
# 充分说明实例方法可以直接创建一个实例对象，因为类方法和类属性是依赖于类的，而初始化
# 了类属性和类方法，可将类属性的值传给实例属性，这样就可以初始化实例属性了。
print("查看两个打出什么", v3, v1)
print("向量v1", v1)
print("向量v2", v2)
# 打印向量之间的加法和数乘
print(v1 + v2)
print(v1*4)

print("单位向量长",v2.unit_vector())
print('我要的想',v2.x,v2.y)

10.静态方法

#静态方法的测试
#静态方法定义中不能调用实例对象
class Student:
    @staticmethod
    def add(a,b):
        print(a+b)                              #打印也是对象，打印是方法，故属于对象
    def __init__(self,a,b,c):
        self.a = a
        self.b = b
        self.c = c
    def add_print(self):
        Student.add(self.a,self.b)              #可以在实例方法中调用静态方法，此时才可以给静态方法传输实例属性
s1 = Student(10,20,Student.add(77,9))
s1.add_print()
s1.add(10,3)                                    #实例对象也可以调用。
Student.add(10,10)                              #只要说明来源，静态方法可以直接外部调用
 # 思考，静态方法的定义有什么用处喃？

11.析构方法_删除对象

#析构测试
class Person:

    def __del__(self):

        print("删除对象是{0}".format(self))          #这段代码相当于特殊操作的重构
p1 =Person()
p2 = Person()
#p1.__del__()
print('程序结束,自动删除对象')        #在这句代码结束后，才会执行__del_()析构方法。
#从运行结果来分析：
#结果展示：
# 程序结束,自动删除对象
#删除对象是<__main__.Person object at 0x0000020274DF5400>
#删除对象是<__main__.Person object at 0x0000020274DFB518>

#每一个实例对象都继承了析构方法，只有当调用的时候才不会被消灭。

12.__call__可调用对象

#主要测试__call__生成可调用对象，是对象可以像函数一样调用
class SalaryAcount:
    '''薪资计算'''
    def __call__(self, salary):
        year_salary = 12*salary
        day_salary = salary//22.5
        hour_salary = day_salary//8
        return  dict(year_salary=year_salary,           #可以直接换行编程代码
                     moth_salary=salary,
                     day_salary=day_salary,
                     hour_salary=hour_salary)
s = SalaryAcount()                                      #不用传参数,创建实例对象
print(s(30000))                                         #实力对象可以像函数一样调用

13.方法的动态性

#方法是类，函数也是类，一切皆是类

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

                                         #在类的外边定义属性(但形式是函数，不传self参数,参数按函数形式来)
def play_game(s):                       #注意这里必须要有一个形参，若想添加成为方法属性，则要有形参传输self参数。
    print('{0}在打游戏'.format(s))

                                        #直到此时play_game()与类Person没关系
p = Person()
p.work()                                #这个方法在类中可以调用。并打印出字符串'努力上班’
                                        #p.play_game()#这个还只是独立于类的一个函数，还不能用类来调用。
print('********分界线****上方函数和类还是独立的***********')

print('********分界线****下方函数添加成类的实例方法***********')
Person.play = play_game                 #将函数当成对象，赋值给变量（新增类属性）play
                                        #此时将这个函数添加为类方法了,相当于现在Person中有两个平行的方法work(self)，play_game(s)
p.play()                                #调用方法play()
print('********分界线****下方修改类的实例方法的***********')
def work2(w):
    print("好好学习，努力上班")
Person.work = work2
p.work()

14.私有属型和私有方法

# 测试私有属性和私有方法，调用私有属性格式：e._Emploree__age
# 方法也是属性


class Employee:
    __name = "百战程序员"                   # 定义私有类属性

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

    def __work(self):
        print('努力工作，赚钱养媳妇！')     # 定义私有方法
        print(self.__name)                  # 内部调用私有类属性
e = Employee('万泉河', 22)
print(e.name, e._Employee__age)              # 调用私有属性，要用实例对象名开头
e._Employee__work()                         # 调用私有方法
print(dir(e))                               # 查看类的属性和方法
print(Employee._Employee__name)             # 外部直接调用私有类属性，要用类名。

# 总结：_类名__私有属性名 中的_类名是私有调用的标志。
##

15.继承父类属型

# 继承父类属性的测试。注意私有属性的继承方法。私有属性虽然继承了，但是子类不能直接调用。
class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def say_age(self):
        print('年龄，年龄')


class Student(Person):
    def __init__(self, name, age, score):              # 申明要继承的属性和自己增加的属性
        Person.__init__(self, name, age)              # 调用父类的属性，def __init__(self,name,age):必须显示的调用父类的初始方法
        self.score = score                          # 另一种写法super(Student,self).__init__(name,age)

s = Student('万权和', 33, 30000)
print(s.name)
print(s._Person__age)                               # 私有属性不能直接调用，需要指明父类路径。
print(dir(s))                                       # 查看Student的所有属性
print(Student.mro())                                # 查看字类继承的父类关系是Student-->Person-->Object
'''
代码格式：
        1.井号注解后隔开一个空格
        2.整个代码最后要空一行
        3.逗号后要隔开一个空格
        4.类体与类体之间隔开两行 
        5.方法名下不空格
        6.解决：say_age()有波浪线，file - invaluedate cache/restart
'''

16.继承父类方法

#子承父类，注意父类方法的继承，方法的继承不需要再在子类说明和定义。
class Person:

    '''def __init__(self,name,age):
        self.name = name
        self.__age = age'''

    def say_age(self):
        print('年龄，年龄')


class Student(Person):                  # 定义Student继承Person的方法
    pass

s = Student()
s.say_age()

17.父类方法的重写

# 在子类中重新定义一个与父类同名的方法可以实现对父类方法的重写，在子类中就覆盖了父类的方法
# 总结：在任何一个类中，在类自身内部引用是属性格式是 self.属性名
# 在类的外部引用，就有多种形式，但大体是 类名.变量名


class Person:

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def say_age(self):
        print('年龄，年龄')

    def introduction(self):
        print('我的名字是{0}'.format(self.name))


class Student(Person):

    def __init__(self, name, age, score):
        Person.__init__(self, name, age)

    def introduction(self):                     # 父类方法的重写
        print('报告老师，父类重写后我的名字是{0}'.format(self.name))

s = Student('万泉河', 23, 66)
s.introduction()
# 小灯泡，还有拼写检测。用typo - rename to - 点下三角选择一个单词
五指山西
关注
专栏目录
py代码-python面向对象学习
07-16
在"py代码-python面向对象学习"这个主题中，我们将深入探讨Python中的类、对象、继承、封装和多态等核心面向对象概念。 1. **类与对象** - **类**：在Python中，类是创建对象的蓝图，它定义了一组属性（数据成员）...
Python面向对象学习思维脑图
11-30
Python面向对象学习思维脑图
Python成功解决TypeError: __init__() missing 1 required positional argument: ‘comment‘
weixin_44991673的博客
11-24 7万+
文章目录源代码报错类型解决方法 源代码 class Book: def __init__(self, name, author, comment, state = 0): self.name = name self.author = author self.comment = comment self.state = state # 创建一个Book类的子类 FictionBook class FictionBook(Book)
TypeError系列之：TypeError: __init__() missing 2 required positional arguments
qq_41368074的博客
04-24 1万+
Python中TypeError: __init__() missing 2 required positional arguments， 这往往说明调用某函数时缺少必须的参数赋值！
TypeError: forward() missing 4 required positional arguments: 'label', 'inst', 'image', and 'feat'
u014546828的博客
07-07 1万+
运行pytorch代码 train.py，特别是在用多个GPU并行运行的情况下，有时会出现这种警报： TypeError: forward() missing 4 required positional arguments: 'label', 'inst', 'image', and 'feat' 产生错误的原因是读取数据时丢失了其中几项。为什么会丢失输入项呢，是因为 batchsize 的...
TypeError: __init__() missing 2 required positional arguments
菜鸟学识的博客
09-16 6万+
TypeError: __init__() missing 2 required positional arguments 原因：调用的类有初始化值，调用的时候没有传值导致的 解决：调用的类后加上传值 如
记录Python使用Django框架操作数据库遇到的问题与流程
weixin_42123081的博客
10-23 569
** python学习使用Django框架连接mysql数据库的步骤和遇到的一些问题 ** 配置数据库： 项目的settings.py文件的77行修改如下： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'myproject', 'USER': 'root', 'PASSWORD': 'root', 'HOST': '1
python面向对象
09-13
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”的概念，将数据和...在视频课程“Python面向对象精彩讲解”中，会详细阐述这些概念，并通过实例演示如何在实际开发中应用它们。
python面向对象练习题.pdf
09-04
### Python面向对象编程知识点解析 #### 一、面向对象三大特性及作用 **1. 封装** 封装是面向对象编程中的一个重要概念，它通过隐藏类的内部细节并对外提供公共接口来保护数据的安全性和完整性。封装使得类的使用...
【报错】missing required positional argument: self
mine-Programmer
06-29 3762
先放这一会更新详细的解决方案
Python中TypeError: __init__() missing 2 required positional arguments
人人为我，我为人人
10-15 3万+
Python中TypeError: __init__() missing 2 required positional arguments[问题点数：50分] hhu_luqi 结帖率 0% 我想运行下GitHub上tensorflow关于Mnist数据集的训练代码，运行在Python3.5.2的环境下，在Spyder上。 代码文件见于 https://github.com/ten...
报错1【TypeError: __init__() missing 3 required positional arguments: 'name', 'author', and 'comment'】
ye_zi_guo的博客
02-19 2万+
#第22行报错【TypeError: init() missing 3 required positional arguments: ‘name’, ‘author’, and ‘comment’】
Django报错：__init__() missing 1 required positional argument: 'on_delete'
yjk13703623757的博客
03-06 1万+
1. 问题 在根据models生成数据库表时，Django报__init__() missing 1 required positional argument: 'on_delete' 源代码如下： # -*- coding: utf-8 -*- from django.db import models # Create your models here. class BookInf...
TypeError: __init__() missing 1 required positional argument: 'on_delete' 解决办法
KreaWu的博客
04-19 4万+
Django 中创建Model时报以下错误： TypeError: init() missing 1 required positional argument: ‘on_delete’ 代码如下： from django.db import models # Create your models here. class Contract(models.Model): nid = mo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值