python面向对象

最新推荐文章于 2023-12-28 21:16:43 发布

我辣翻天的火鸡面

最新推荐文章于 2023-12-28 21:16:43 发布

阅读量134

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/qq_41645342/article/details/103812536

版权

Python 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

一、类和对象

（一）、定义一个类

class 类名：
    方法列表

（二）、在python2中类叫做旧式类，又叫做经典类

class Person():
    def 方法名():
        pass

（三）、在python3中类叫做新式类，又叫做常用类

class Person(object):
    pass

（四）、命名：大驼峰命名(PersonMan)、小驼峰命名(personMan)、下划线命名(person_man)

（五）、创建对象

1、对象名 = 类名()

2、对象名.参数名 = 对应的值 #实例化对象的参数

class person(object):
    def run(self):
        print(self.name)
one = person()
one.name = "zz"
one.run()

3、def __init__(self,name,age): #创建有参数的对象用init这个方法

class person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run(self):
        print(self.name)
one = person(name="zz",age=18)
one.run()

（六）、所有对象公用一个类中定义实例方法

print(id(one.run))
print(id(two.run))  #两者输出的id相同

（七）、__str__(self)方法，必须有返回值，通常返回一个字符串，作为对象的描述信息

class person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return "{name}今年{age}岁".format(name=self.name,age=self.age)

#如果有__str__(self)方法，可以定义打印对象返回的数据
#如果不带方法，会输出对象的内存地址

zs = person("张三",18)
print(zs)

（八）、__del__方法，销毁建立的对象，一般当类创建的对象不再被使用的时候执行。销毁创建的变量和变量所对应的数据指数，一旦内存的引用为零的时候，解释器会回收当前资源。

（九）、引用计数法

1、当有变量保存了一个对象的引用时，此对象的引用计数加1

2、当使用del()方法或者death关键字时删除变量指向的对象时，这会减小对象的引用计数。

（十）、例：烧地瓜

lass cooked(object):
    def __init__(self):
        self.cookedLevel = 0
        self.cookedString = "生的"
        self.condiments = []

def cook(self, time=1):
    self.cookedLevel += time
        if self.cookedLevel < 3:
            self.cookedString = "生了"
        elif self.cookedLevel <5:
            self.cookedString = "半生不熟"
        elif self.cookedLevel < 8:
            self.cookedString = "熟了"
        else:
            self.cookedString = "碳了"

def addcondiments(self, peifang):
    self.condiments.append(peifang)

def __str__(self):
    if self.condiments:
        return "当前这个地瓜考了{}分钟,已经{},加了{}".format(self.cookedLevel, self.cookedString, self.condiments)
    return "当前这个地瓜考了{}分钟,已经{},{}".format(self.cookedLevel, self.cookedString, "啥都没加")

one = cooked()
one.cook(5)
one.cook()
one.addcondiments("盐")
print(one)

二、继承

（一）、在程序中继承描述的是多个类之间的所属关系

（二）、使用父类的方法传递的时候，方法中要传递实例对象

#父类名.属性或方法
class master():
    def __init__(self):
        self.way = "上海"
    def make_cake(self):
        print("我在[%s]" % self.way)


class prentice():
    def __init__(self):
        self.way = "山东"
    def make_cake(self):
        master.__init__(self)   # 或者  super().__init__，super(master, self).__init__()
        print("我在[%s]" % self.way)

one = prentice()
one.make_cake()  #输出：我在[上海]

（三）、如果继承了多个父类，且父类都含有同名属性或者方法，使用super()方法时，默认执行第一个父类同名属性或者方法。super()方法只支持新式类，python2.3之后才有的多层继承和super方法

（四）、私有权限：在属性或者方法前加上两个下划线__。

（五）、python时一个弱语言，没有绝对的访问权限，必须遵守python的定义，私有属性的原则，python没有访问控制符（public等），如果属性名和方法名没有两个下划线的话是公有属性（不太准确）

（六）、类的私有方法和私有属性，都不能通过对象直接访问，但是可以通过本类的内部进行访问

（七）、类的私有属性和私有方法，都不能被子类继承，也不能被子类访问

（八）、私有属性和私有方法，往往用来处理类内部的事情，不能通过对象处理，起到安全作用。

（九）、python中没有绝对的共有访问和私有访问

1、当使用import 模块名的时候，可以使用所有属性和方法，没有共有和私有的说法

2、使用from 模块名 import 方法或属性的使用，有私有和公有之说，并有且只有在该情况下，一个下划线也表示私有。

3、定义私有属性时，必须遵从使用两个下划线。

（十）、通常使用get_xxx()和set_xxx()方法获取和修改私有属性

class Master():
    def __init__(self):
        self.__money = 10000
self.kongfu = "什么都会"
    def get_money(self):
        print(self.__money)
    def set_money(self,count):
        self.__money += count

m = Master()
m.get_money()
m.set_money(100)
m.get_money()

（十一）、类属性就是类对象拥有的属性，他被所有类对象和实例对象公有

（十二）、类对象：实例化对象

（十三）、类属性：直接在类中创建，不能再方法中创建（类属性），可以被类对象还有实例化对象使用

（十四）、实例化属性：不能被类对象调用，能被实例化对象调用

（十五）、__dict__魔法方法

1、类属性调用此魔法方法时，返回当前类所含有的所有类属性和方法

2、实例化对象调用此魔法方法时，返回此对象具有所以属性

（十六）、python中的私有属性的假的私有属性：python的类通过加双下划线来设置“私有属性”，原理是python解释器将加了双下划线的“属性名”自动转换为“_类名+私有属性名”，所以外部通过属性名.私有属性名获取不到，会触发AttributeError，从而实现私有属性的特征，但是外界可以通过类名属性名访问到该私有属性。

class A():
    name = "A"
     __data = "2019"
    def __init__(self):
        self.age = 18
        self.__money = 20000

print(A.__dict__)
a = A()
print(a.__dict__)
print(a.__money)
“““报错{
    print(a.__money)
    AttributeError: 'A' object has no attribute '__money'
}”””
print(a._A__money)  #20000

（十七）、类方法是类对象拥有的方法，需要使用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般为cls作为第一个参数，能通过类对象和实例化对象来调用

（十八）、类方法的作用：用来访问和修改定义的类属性

class people():
    __country = "China"
    hp = 1001

    @classmethod
    def get_country(cls):
        return cls.__country

    @classmethod
    def set_country(cls,country):
        cls.__country = country

    @classmethod
    def get_hp(cls):
        return cls.hp

    def __init__(self,hp2):
        self.hp1 = hp2
        self.name ="ZZ"

people.set_country("JP")
print(people.get_country())

p = people(1)
print(p.hp1)

（十九）、没有访问控制符
（二十）、没有常量
（二一）、没有多态
（二二）、定义变量不需要指定数据类型
（二三）、没有绝对私有

（二四）、python中的常量
1、通过把变量名全部大写（可以被修改，规定不要修改）
2、NAME = 1

（二五）、python中没有静态方法，对于python中的类假写了一个静态方法
（二六）、需要通过装饰器@staticmethod来修饰，静态方法不需要定义参数，可以通过类对象和实例对象来访问
（二七）、作用：为了符合高级语言特意特性，没有实际意义

（二八）、区分类属性类方法和对象属性和方法

1、一个类中可以使用类属性，对象属性

类外面	类属性	类名.属性或实例化对象名.属性
类外面	对象属性	实例化对象名.属性
类里面	类属性	通过cls.属性或 self.属性
类里面	对象属性	只能self.属性

（二九）、类方法和对象方法的区别

1、类方法只能访问类属性

2、对象方法只能访问对象属性

（三十）、类方法、静态方法和对象方法

1、从类方法和实例方法以静态方法的定义形式可以看出，类方法的第一个参数类对象cls，通过cls引用的属性和方法一定属于类属性或者类方法；对象方法的第一个参数是实例化对象self，通过self引用的属性和方法，可能是类属性或者对象方法和类方法和对象方法；静态方法没有参数无法使用cls和self但为了使用类对象的属性和方法（类名.属性和方法），对象属性和方法(间接传递传输)

2、实例化对象的优先级最高

3、实例化对象能使用本身的属性和方法，类的属性和方法，静态方法

4、类对象能使用本身的属性和方法，静态方法

5、静态方法没有cls，self

6、静态方法不需要定义额外参数，如果需要可以另加，调用类对象属性和方法不要定义额外参数

（三一）、绝对不能这样使用

1、所有语言的bug：类的方法的功能必须在实例化之前完成

2、静态语言来说：实例化对象之后无法创建新的方法

3、动态语言来说：实例化对象之后可以添加额外的方法

三、封装与多态

（一）、封装的意义

1、将属性和方法放到一起作为一个整体（类），然后通过实例对象来处理。

2、隐藏内部的实现细节（私有属性），只需要对象及其属性和方法在内部交互

3、对于类属性和方法需要增加访问控制

（二）、多态（python中弱化了多态，因为python是一门弱语言，定义变量时不需要指定类型）

1、定义时的类型和运行时的类型不一样，即同一事物的不同表现

2、触发条件【继承，重写，父类引用指向子类对象 java中：（animal a = new cat();animal a = new dog();向上转型）】

四、异常

（一）、异常：当python解释器检查到一个错误，导致

（二）、怎么解决异常：try-except

（三）、怎么使用该语句：将程序可能发生的已知错误或未知错误放入try语句中

（四）、捕获一个异常

 try:
        num1 = 1
        num2 = 0
        print(num1/num2)
    except Exception:
        print("除数不能为零")

（五）、捕获多个异常：用多个except来处理，谁的错误谁处理，未知错误使用Exception（否则将会忽视后面的异常抛出），多个异常只会捕捉一个，后面的将不会在执行（程序停止了）

try:
    num1 = 1
    num2 = 1
    print(num1/num2)
    print(num3)
except ZeroDivisionError:
    print("除数不能为零")
except Exception:
    print("1")

（六）、as

1、可以在后期代码使用中给模块或者错误等重新命名（即模块重命名）

2、用来储存异常的基本信息（相当于取出当前这个错误的实例化对象）

try:
    print(a)
except NameError as result:
    print(result)
    print("1")

（七）、捕捉所有异常：不知道异常类型，直接使用Exception，如果当前错误是知道的，那么就直接使用对象的异常类来处理

（八）、else关键字

1、条件与if或elif条件相反执行

2、在循环语句中：不执行循环，跳到else

3、在异常中：如果没有捕获到异常，执行else

（九）、finally关键字：在程序中，如果一个代码必须要执行，即无论是否产生异常都要去执行某段代码时，就要使用当前的关键字

（十）、应用场景：文件的关闭，数据库连接，释放锁（悲观锁，乐观锁）

（十一）、自定义异常并抛出

（1）、继承Exception

（2）、重写__init__

class LongNameError(Exception):
#自定义错误类
    def __init__(self):
        self.len = 4

    def __str__(self):
        return "这是自定义的错误"

try:
    name = input()
    if len(name) > 4:
    #使用raise,引发一个异常
        raise LongNameError()
except LongNameError as e: #e相当于就是实例化对象
    print(e)  #输出“这是自定义的错误”
    print("1")
#抛出的时异常类的实例化对象