知识点 —— Python进阶-2

Posted 2021-09-08 海绵小青年

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了知识点 —— Python进阶-2相关的知识，希望对你有一定的参考价值。

Python进阶–2

面向对象–基础

引入理解

https://blog.csdn.net/shenzixincaiji/article/details/83576687

类、对象、属性、方法

基础

class student:					# 类
    age = 18					# 类的属性
    tall = 175
    phone = 'huawei'

    def sleep(self):			# 类的方法
        print('正在睡觉')

# basic												# 对象lily和对象Tom继承student类，两者的数据id一致
lily = student()
print(lily.age, lily.tall, lily.phone)		
print('lily.age的id:', id(lily.age))			  
lily.sleep()								   

Tom = student()
print(Tom.age, Tom.tall, Tom.phone)
print('Tom.age的id:', id(Tom.age))
Tom.sleep()

print('----------------------------------------')
# change 类
student.age = 20									# 第一次改变类属性，两个对象的属性也一起改变
print(lily.age, Tom.age)							# 即对两个对象都有影响
print(id(lily.age), id(Tom.age))
print('----------------------------------------')

# change 对象lily
lily.age = 19										# 改变对象lily的属性（对象属性），创建了动态的对象属性与起绑定
print(lily.age, Tom.age)							# 改变的结果不影响另一个对象的属性
print(id(lily.age), id(Tom.age))
print('----------------------------------------')
# change 类		
student.age = 21								# 再次改变类属性，lily的属性已经不受影响，Tom的属性仍会受到影响
print(lily.age, Tom.age)
print(id(lily.age), id(Tom.age))

高级一点

class student:
    tall = 'None'                           # 类属性，其变化同于基础部分的讲解
    def __init__(self):                     # 魔术方法
        self.name = 'None'                  # 对象属性，应用到具体对象都会给定一个初始值，可根据具体需要再做修改
        self.age = 'None'
        self.phone = 'None'

    def sleep(self):
        print('{}正在睡觉'.format(self.name))	# self就相当于具体的对象

# basic
lily = student()
print(lily.age, lily.name, lily.phone)
print('lily.age的id:', id(lily.age))
lily.sleep()									# self.name == lily.name

Tom = student()
print(Tom.age, Tom.name, Tom.phone)
print('Tom.age的id:', id(Tom.age))
Tom.sleep()										# self.name == Tom.name

print('----------------------------------')
# 初始化后的具体赋值
lily.name = 'lily'
lily.age = '15'
lily.phone = 'huawei'
print(lily.age, lily.name, lily.phone)
print('lily.age的id:', id(lily.age))
lily.sleep()

print('----------------------------------')
Tom.name = 'Tom'
Tom.age = '15'
Tom.phone = 'iphone'
print(Tom.age, Tom.name, Tom.phone)
print('Tom.age的id:', id(Tom.age))
Tom.sleep()

总结

类属性

使用同一类创建不同的对象

若没有改变过类属性，可以通过类属性改变，来改变对象中对应类属性的值。一起改变
若某一对象更改了类属性的值，则建立动态对象绑定，此对象中类属性变为修改后的数值；其他对象的类属性不变
再次改变类属性，已经动态绑定的对象，其对象的类属性不会受到影响；对于没有“私自”更改类属性的对象，其对应的类属性仍然会受到影响

对象属性

对象属性是依据类创建对象的时候，每个对象都具有的公共属性

其数值的更改需要通过调用对象属性赋值来修改，不能通过类属性更改

总结

类属性，不允许对象私自修改，有类统一修改，影响所有对象

对象属性，依据对象的特点，可以自己做出特定的修改。类没有权限去修改对象属性

对象方法

理解

class student(object):
    tall = 'tom'                           # 类属性，其变化同于基础部分的讲解
    def __init__(self, nickname):                     # 魔术方法
        self.name = nickname                 # 对象属性，应用到具体对象都会给定一个初始值，可根据具体需要再做修改
        self.age = 'None'
        self.phone = 'None'

    def run(self):
        print("{}在跑步".format(self.name))	# 调用对象属性
        print("{}在跑步".format(self.tall))	# 调用类属性
        self.sleep()					 # 调用其他对象方法

    def sleep(self):
        print('在睡觉')


# basic
lily = student('dahuang')
lily.sleep()
lily.run()

在睡觉
dahuang在跑步
tom在跑步
在睡觉

对象方法

可以调用类属性，也可以调用对象属性

对象方法中的参数是对象self

对象方法之间可以相互调用

类方法

理解

class student(object):
    tall = 'tom'                           # 类属性，其变化同于基础部分的讲解
    def __init__(self, nickname):                     # 魔术方法
        self.name = nickname                 # 对象属性，应用到具体对象都会给定一个初始值，可根据具体需要再做修改
        self.age = 'None'
        self.phone = 'None'

    def sleep(self):
        print('在睡觉')

    @classmethod
    def test(cls):
        print('只能调用类属性：',cls.tall)

# basic
student.test()

只能调用类属性： tom

类方法

依赖装饰器，且只能调用类属性，不能调用对象属性（会报错）

类方法中的参数是类，不依赖对象，可以独立于对象做一些处理

类方法中不能调用对象方法

类方法和对象方法的理解

类属性是公共属性，对象属性是私有属性

类方法只能调用类属性；而对象方法既能调用对象属性，也能调用类属性

静态方法

class student(object):
    __tall = 'tom'                              # 对类属性进行私有化
    high = 12
    def __init__(self, nickname):
        self.name = nickname
        self.age = 'None'
        self.phone = 'None'

    def sleep(self):
        print('在睡觉')

    @staticmethod
    def casual():
        print('只能调用类属性tall：', student.__tall)
        print('只能调用类属性high：', student.high)


# basic
student.casual()

只能调用类属性tall： tom
只能调用类属性high： 12

也是只能访问公共类属性

静态方法和类方法区别

不同

装饰器不同
参数不同，一个有cls，一个无cls

相同

都只能访问类属性和方法，对象属性和对象方法无法访问
都可以通过类名调用访问
都可以在对象创建之前调用，不依赖于对象

总结–↑

几种方法都可以接受外部参数

class student(object):
    __tall = 'tom'                              # 对类属性进行私有化
    high = 12
    def __init__(self, nickname):
        self.name = nickname
        self.age = 'None'
        self.phone = 'None'

    def sleep(self, outer1):
        print('outer1:', outer1, self.__tall, self.high)

    @classmethod
    def casual(cls, outer2):
        print('outer2:', outer2, cls.__tall, cls.high)

    @staticmethod
    def casual(outer3):
        print('outer3:', outer3, student.__tall, student.high)

# basic
student('dahuang').sleep(1)
student.casual(2)
student.casual(3)

outer1: 1 tom 12
outer3: 2 tom 12
outer3: 3 tom 12

各自特点

对象方法

可以调用对象属性，也可以调用类属性（私有和非私有的）
依赖对象，没有对象就不能调用对象方法
没有装饰器
必须有self对象参数，也可以有外部参数

类方法

只能调用类属性（私有的和非私有的）
不依赖对象，没有对象也可以调用类方法
需要装饰器，classmethod
必须有cls参数，也可以有其他外部参数

静态方法

只能调用类属性（私有和非私有的）
不依赖对象，没有对象也可以调用静态方法
需要装饰器，staticmethod
不需要任何参数，但是也可以添加外部参数

面向对象–魔术方法

魔术方法

http://c.biancheng.net/view/7817.html
https://www.cnblogs.com/zhangboblogs/p/7860929.html
https://www.cnblogs.com/nmb-musen/p/10861536.html

常用魔术方法

# __str__(self)
# __new__(self)

面向对象–私有化

类属性的私有化

目的

为了防止外部任意修改公共类属性

私有化的类属性只能够被类方法修改

class student(object):
    __tall = 'tom'                              # 对类属性进行私有化
    high = 12
    def __init__(self, nickname):
        self.name = nickname
        self.age = 'None'
        self.phone = 'None'

    def sleep(self):
        print('在睡觉')

    @classmethod
    def test(cls):
        print('只能调用类属性tall：',cls.__tall)
        print('只能调用类属性high：', cls.high)

    @classmethod
    def update(cls):
        cls.__tall = '把tom改为tttom'
# basic
student.test()
student.high = '修改后'
student.tall = '修改后'    # 私有属性，不可外界修改
student.test()

student.update()         # 使用类方法修改私有属性
student.test()

只能调用类属性tall： tom
只能调用类属性high： 12
只能调用类属性tall： tom
只能调用类属性high：修改后
只能调用类属性tall：把tom改为tttom
只能调用类属性high：修改后

对象属性的私有化

目的

为了防止对象属性被不合理的修改

可以通过对象方法来修改私有的对象属性

class PositiveInteger():
    def __init__(self):
        self.__name = 'Tom'
        self.__age = 15

    def setName(self, newname):
        self.__name = newname

    def setAge(self, newage):
        if 0 < newage < 100:
            self.__age = newage
        else:
            print('年龄不符合要求')

    def __str__(self):
        return '学生的年龄：{}，学生的名字：{}'.format(self.__age, self.__name)

i = PositiveInteger()

print(i)
# i.__name    这是无法修改的
i.setName('TTTTom')
i.setAge(150)
print(i)

学生的年龄：15，学生的名字：Tom
年龄不符合要求
学生的年龄：15，学生的名字：TTTTom

私有化的本质–↑

本质是通过修改内部的名字，让你无法通过原名字访问
可以找到真实的名字进行访问，但是不建议这样用

class PositiveInteger():
    __name1 = 'lily'

    def __init__(self):
        self.__name = 'Tom'
        self.__age = 15

    def setName(self, newname):
        self.__name = newname

    def setAge(self, newage):
        if 0 < newage < 100:
            self.__age = newage
        else:
            print('年龄不符合要求')

    def __str__(self):
        return '学生的年龄：{}，学生的名字：{}'.format(self.__age, self.__name)


i = PositiveInteger()

print(dir(PositiveInteger))
print(dir(i))		# 等价于 i.__dir__()

print(i)
i._PositiveInteger__age = 99	# 不过不建议这样修改
print(i)

学生的年龄：15，学生的名字：Tom
学生的年龄：99，学生的名字：Tom

@property

目的

即想达到对象属性私有化的目的

又想通过对象.属性的方法来调用和修改私有化后的属性

class PositiveInteger():

    def __init__(self):
        self.name = 'Tom'
        self.__age = 15

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, newage):
        if 0 < newage < 100:
            self.__age = newage
        else:
            print('年龄不符合要求')

    def __str__(self):
        return '学生的年龄：{}，学生的名字：{}'.format(self.__age, self.name)


i = PositiveInteger()

print(i, i.age)
i.age = 99
print(i, i.age)

学生的年龄：15，学生的名字：Tom 15
学生的年龄：99，学生的名字：Tom 99

面向对象–关联关系

概念辨析

is a

是一种继承关系

A is a B B是A的基类（父类）

可以产生代码上的重用性

比如：兔子 is a 动物

就是说兔子继承了动物的一些特点：有腿、有耳朵

具体到代码层面就是说：它可以继承动物（父）类的一些属性，如果有需要增加的可以再写

兔子爱吃的素食有哪些，就是兔子类不能从动物类继承的属性，因为有些动物不吃素的

就可以在动物类的基础上，添加喜欢吃的食物这一属性

has a

是一种包含关系

A has a B A包含B

比如：汽车 has a 轮胎，但是不能说汽车 is a 轮胎

包含关系具体到代码层面就是调用

汽车有很多属性：轮胎类型、车座类型、价格…

轮胎也有很多属性：价格、材质、防滑等级…

汽车对象就可以调用轮胎对象里面的一些属性

宝马牌汽车的轮胎是米其林材质的，价格是…。防滑等级是…

实例理解

讲的是 has a的包含关系

is a的继承关系在后续有介绍

class Compter:
    def __init__(self,brand,type,color):
        self.brand=brand
        self.type=type
        self.color=color

    def online(self):
        print("正在使用电脑上网")

    def __str__(self):
        return self.brand + '-------'+self.type+'------'+self.color

class Book:
    def __init__(self,bname,number,author):
        self.bname=bname
        self.number=number
        self.author=author

    def __str__(self):
        return self.bname+self.author+self.number

class sudent:
    def __init__(self,name,compter,book):
        self.name=name
        self.compter=compter
        self.Book=[]
        self.Book.append(book)
    def __str__(self):
        return self.name+'------->'+str(self.compter)+'-----'+str(self.Book)

C=Compter('mac','pro','深灰色')
print(C)
print(type(C))

s = sudent('lilu', C, '盗墓笔记')
print(s)

mac-------pro------深灰色
<class ‘main.Compter’>
lilu------->mac-------pro------深灰色-----[‘盗墓笔记’]

面向对象–继承关系

基本继承

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

    def run(self):
        print('{}岁的{}在跑步'.format(self.age, self.name))


class sudent(person):
    def __init__(self, name, age, classes):
        super().__init__(name, age )
        self.classes = classes

    def run(self, food):
        super().run()
        print('他是{}的，喜欢吃{}'.format(self.classes, food))


s = person('lilu', 13)
s.run()

s = sudent('lilu', 14, '15班')
s.run('汉堡')

13岁的lilu在跑步
14岁的lilu在跑步
他是15班的，喜欢吃汉堡

init问题

子类不定义init，则从父类继承

子类继承父类，但是也需要自己定义
def __init__(self, name, age, classes):
    super().__init__(name, age)
    self.classes = classes

对象方法

父类定义eat()对象方法，子类无定义
	参数结果均同于父类
    默认搜索原则：先搜索当前类，没有的话，再搜索父类

父类定义eat()方法，子类也定义
	父类提供的方法无法满足子类需求，在子类中定义一个同名的方法，就叫做：重写
    子类定义的同名方法，可以借助父类中定义的部分
    def run(self, food):
        super().run()
        print('他是{}的，喜欢吃{}'.format(self.classes, food))

注意

父类中私有的属性，子类是无法继承的

多重继承

https://www.cnblogs.com/xpc51/p/11764975.html

class Base()以上是关于知识点 —— Python进阶-2的主要内容，如果未能解决你的问题，请参考以下文章 
 知识点 —— Python进阶-2
 知识点 —— Python进阶-2
 Python 实现邮件发送功能（进阶）
 python进阶第1篇 函数入门
 1.26 Python知识进阶 - 继承
 知识点 —— Python进阶-1