python基础4

最新推荐文章于 2024-08-12 21:55:40 发布

数据新生活

最新推荐文章于 2024-08-12 21:55:40 发布

阅读量528

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.youkuaiyun.com/weixin_42814602/article/details/102615334

版权

python 专栏收录该内容

9 篇文章

订阅专栏

文章目录

- - 目标：理解对象和类的概念；调用的规则(对象名调用/类名调用=>属性+方法)；理解继承
1.面向对象(Object Oriented Programming=OOP)和面向过程的异同
2. 类和对象的概念：
3.`class`的使用【特征--属性，行为--方法】
4.属性和方法
5.类的三大特征：继承，多态，封装
6.类属性+实例属性/对象属性
7.类方法+对象方法+静态方法
8.私有方法+私有属性（了解）

目标：理解对象和类的概念；调用的规则(对象名调用/类名调用=>属性+方法)；理解继承

1.面向对象(Object Oriented Programming=OOP)和面向过程的异同

同：都是一种开发模式(思维模式)
异：通过做一道菜进行阐述
- 面向过程：摘菜=》洗菜=》切菜=》炒菜=》出菜
- 面向对象：*找一个厨师(对象)=>【摘菜=》洗菜=》切菜=》炒菜=》出菜】
程序员而言：只负责调度对象，对象做那些事
- 面向过程：你=》功能方法（做事情）
- 面向对象：你=》功能对象.功能方法

2. 类和对象的概念：

类(抽象): 事和物的一个分类，只是概念【类比–制造飞机的图纸】；
对象(具体): 具体的某个事或物【类比–根据图纸创建的飞机】；
总结：类是创建对象的模板。也可以说由类创建的实例，我们称之为对象

3.`class`的使用【特征–属性，行为–方法】

class Hero(object): # 尽量使用大写字母开头
    # 属性
    country = "蜀汉" # "曹魏" "东吴"
    # 方法
    def fight(self):
        print(self)
        print('官渡之战，袁绍惨败')
# 创建对象(由类创建的实例) 
# 内存中开辟空间->存储对象(利用内存地址找到对象)
CaoCao = Hero() 
YuanShao = Hero()
print(CaoCao,YuanShao)

# 查看对象属性
print(CaoCao.country)
# 利用对象调用方法
CaoCao.fight()
YuanShao.fight()

*******************************output*******************************
<__main__.Hero object at 0x000001FF7697E828> <__main__.Hero object at 0x000001FF7697E0F0>
蜀汉
<__main__.Hero object at 0x000001FF7697E828>
官渡之战，袁绍惨败
<__main__.Hero object at 0x000001FF7697E0F0>
官渡之战，袁绍惨败

4.属性和方法

4.1 添加属性的方法：动态添加属性，`init`

class Hero(object):
    def show(self):
        print('我是第一个方法')
    def show2(self):
        print('我是第二个方法')
    def info(self):
        print('2.调用方法打印:',self.name,self.weapon)
# 创建对象
hero = Hero()
# 动态添加属性
hero.name = '刘备'
hero.weapon = '双股剑'

# 获取对象属性
# 1.直接打印：
print('1.直接打印:',hero.name,hero.weapon)
# 2.调用方法打印：
hero.info()

*******************************output*******************************
1.直接打印: 刘备 双股剑
2.调用方法打印: 刘备 双股剑

4.2 init魔法方法：当前需要完成某个功能操作,python自动调用的方法 `init`

当前对象初始化的时候自动调用
常用来变量初始化/赋值操作
魔法方法:以__开头以__结尾

4.2.1 `init`不带参数

class Hero(object):
    def __init__(self): # 【谁调用此方法谁就是self(很多的对象)】
    	print("在创建对象时，__init__方法会被自动调用")
    	self.name = "刘备"
    	self.weapon = "双股剑"
    def move(self):
    	print("%s正在移动"%self.name)
# 实例化一个对象
hero = Hero()
print('*'*100)
hero.move()

*******************************output*******************************
在创建对象时，__init__方法会被自动调用
****************************************************************************************************
刘备正在移动

4.2.2 `init`带参数

class Hero(object):
    def __init__(self,name,weapon): # 谁调用此方法谁就是self(很多的对象,)
        print("在创建对象时，__init__方法会被自动调用")
        self.name = name
        self.weapon = weapon
    def move(self): # 通过self(对象)进行传参
        print("%s拿着%s正在移动"%(self.name,self.weapon))
# 实例化一个对象
hero = Hero("张飞","青龙偃月刀")
print('*'*100)
hero.move()

*******************************output*******************************
在创建对象时，__init__方法会被自动调用
****************************************************************************************************
张飞拿着青龙偃月刀正在移动

总结：
- 类内部获取”属性“or”实例方法“：通过self获取
- 类外部获取"属性"or"实例方法"：通过对象名获取

5.类的三大特征：继承，多态，封装

5.1 继承（子类可以复用父类的方法）：

单继承：子类（派生类）只继承一个父类（基类）
多继承：子类继承多个父类
- 同名属性or方法：先查找奔类，再查找第一个父类…
- 不同名：不会有任何影响
- 魔法属性__mro__决定属性or方法的查找顺序

单继承

class Person(object):
    def __init__(self):
    	# 固定属性
    	self.name = "关羽"
    	self.horse = "赤兔马"
    # 方法(对象方法/实例方法）
    def show(self):
    	print(self.name,self.horse)
class Student(Person): # 继承
    pass
class Teacher(Person): # 继承
    def __init__(self,name,horse):
    	self.name = name
    	self.horse = horse
    def show_new(self): # 父类方法满足不了子类需求，对其重写
    	print(self.name,'骑着',self.horse)

# 利用Student子类创建对象
student = Student()
# 子类调用父类方法
student.show()
# 子类调用父类属性
print(student.horse)

# 利用Teacher子类创建对象
teacher = Teacher("张飞","乌云踏雪")
teacher.show()
teacher.show_new()
print(teacher.name)

关羽 赤兔马
赤兔马
张飞 乌云踏雪
张飞 骑着 乌云踏雪
张飞

多继承

class A(object):
    def show(self):
        print("我是A类")
class B(object):
    def show(self):
    	print("我是B类")
class C(B,A): # 多继承
    def show(self):
    	print("我是C类")
    	# pass
c = C() 
c.show()
print(C.mro()) # print(C.__mro__)
print(type(c))

我是C类
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
<class '__main__.C'>

重写父类

父类的方法满足不了子类的需求:
特点：①继承关系; ②方法名相同

class Person(object):    
    def __init__(self):
        self.name = "小红"
        #对象方法
    def show(self,name):
        #名字
        print(name)
       
class Student(Person): # 继承1    
    def __init__(self):
        self.name = "小红"
    #对象方法(为什么要重写父类的方法)
    #父类的方法满足不了子类的需求:打印名字和年龄
    def show(self,name,age):  #子类继承父类的方法(子类的方法和父类的方法同名)
    	print("我的名字：%s, 我的年龄：%d"%(name,age))

#一个父类可以有多个子类
class Teacher(Person): # 继承2    
    def __init__(self):
        self.name = "小红"
    #对象方法(为什么要重写父类的方法)
    #父类的方法满足子类的需求：只打印名字 [和父类的方法应用一致]    

s = Student()
s.show("Jsir",24) # ==> 我的名字：Jsir, 我的年龄：24
t = Teacher()
t.show("张飞") # ==> 张飞

5.2 多态：python中不是真正的多态,关注的是同一个方法,但会有不同的表现形式

class Text(object):
    def show(self):
    	print("显示文字")
class Image(object):
    def show(self):
    	print("显示图片")
class Video(object):
    def show(self):
    	print("显示视频") 
# 定义一个函数
def show_data(data): # data将对象作为一个参数(新手不易理解)，常见参数类型:inf,float,Bool,list,dict...
    data.show()     	
text = Text()
image = Image()
video = Video()
show_data(text)
show_data(image)
show_data(video)

# 多态的意义： 
# 三个类有相同的方法，定义一个函数来更方便调用方法
# 否则：
# text = Text()
# text.show()

6.类属性+实例属性/对象属性

类属性：方法外和类内定义的属性
实例属性/对象属性：init方法定义的属性

class Person(object):
    address = "SH" # 【类属性】
    def __init__(self):
    	self.name = "Jsir" # 【实例属性/对象属性】
    	self.age = "24" 
p = Person()
###############    访问    #####################
# 对象访问
print(p.address) # right       ==> SH 【实例对象 访问 类属性】
print(p.age, p.name)  # right  ==> Jsir 24 【实例对象 访问 对象属性】
# 类访问
print(Person.address) # right  ==> SH 【类对象 访问 类属性】
# print(Person.age)  # 【wrong】      【类对象 访问 对象属性XXXX】
# print(Person.name) # 【wrong】

################ 修改类属性 but failed #####################
# 1.实例对象 修改 类属性 wrong
p.address = "HZ" # 新增了address对象属性
print(p.address)  # ==> **HZ  【实例对象 访问 类属性】
print(Person.address)  # ==> SH 【类 访问 类属性】
del p.address
print(Person.address)  # ==> SH
# print(p.address)     # ==> **SH

# 2.类对象 修改 类属性 ok
Person.address = "HZ"
print(Person.address) # ==>HZ
print(p.address) # ==>HZ

总结：类属性的操作由类完成，实例属性的操作由实例对象完成
注意：类不可以访问【对象属性】，实例对象可以访问【类属性】，但不能修改

7.类方法+对象方法+静态方法

类方法由类调用（不用创建对象），对象方法由对象调用
静态方法：不需要当前类，也不需要当前对象；调用–类.静态方法()，对象名.静态方法()
注意：
- 类可以调用对象方法（需要传递对象参数，即需要先创建对象）
- 对象可以调用类方法（对象名.类方法）
理解cls参数和self参数
类属性的修改：类方法 + 对象方法

class Person(object):
    address = "SH"

    # 7.1 类方法，用classmethod来修饰
    @classmethod # cls代表 类参数
    def get_address(cls):
    	return cls.address
    
    # 7.2 对象方法
    def show(self): # self代表 对象参数
        print("我是一个对象方法")
    
    # 7.3 静态方法,用staticmethod修饰 【无参】 感觉就是一个函数放在类内，完全可以拿到外面
    @staticmethod
    def get_address2():
    	return Person.address

p1 = Person()
print(p1.get_address()) # ==> SH        【实例对象 访问类方法】
print(Person.get_address()) # ==> SH    【类对象 访问类方法】

p2 = Person()
print(p2.show()) 
# ==> 我是一个对象方法        【实例对象 访问对象方法】
# ==> None  因为没有return
print(Person.show(p2))  
# ==> 我是一个对象方法    【类对象 访问对象方法】需要传递对象参数 (待看,没啥意义)
# ==> None  因为没有return

p3 = Person()
print(p3.get_address2()) # ==> SH        【实例对象 访问静态方法】
print(Person.get_address2()) # ==> SH    【类对象 访问静态方法】

利用类方法修改类属性

class Person(object):
    __address = "SH"

    @classmethod # cls代表 类参数
    def get_address(cls):
        return cls.__address

    @classmethod
    def set_address(cls,address):
    	cls.__address = address
 
 p = Person()
 print(p.get_address()) # ==> SH
 p.set_address("HZ") # Person.set_address("HZ")
 print(p.get_address()) # ==> HZ
 print(Person.get_address()) # ==> HZ

利用对象方法修改类属性

class Person(object):
    __address = "SH" # 私有类属性
    #-----对象方法修改类属性(对象方法是最常用)----
    #可以修改对象属性,也可以修改类属性 
    
    def instance_set_address(self,address):
    	#获取类属性(修改)
	self.__class__.__address = address

    def instance_get_address(self):
        #self.__class__ 获取当前类名 == cls
        return self.__class__.__address


p = Person()
print(p.instance_get_address()) # ==> SH

# 修改1
p.instance_set_address("HZ")
print(p.instance_get_address()) # ==> HZ

# 修改2
Person.instance_set_address(p,"SZ")
print(p.instance_get_address()) # ==> SZ
print(Person.instance_get_address(p)) # ==>SZ

8.私有方法+私有属性（了解）

私有只要在方法/属性前添加 __
查看私有实例属性 对象名.__dict__
查看私有方法 类.__dict__

class Person(object):

    def __init__(self,name,age):
    	self.name = name # 共有属性
    	self.__age = age # 私有实例属性
    
    # 共有方法
    def show(self):
    	print("我是共有方法")
    
    # 私有方法
    def __newshow(self):
    	print("我是私有方法")

##################### 1.私有属性 #
person = Person("Jsir",24)
print(person.name) # ==> Jsir
# print(person.__age) # 【wrong】
print(person.__dict__) # 魔法方法 __dict__ 查看对象中的属性信息
# ==>{'name': 'Jsir', '_Person__age': 24}
print(person._Person__age) # ==>24  "非法操作" 破解使用
################################ 私有属性修改
person.__age = 110 # 相对于增加了一个【共有属性】（动态添加了一个属性） 并没有修改【私有属性】
person.__Person__age = 120 # 修改【私有属性】成功 【没必要，了解即可】
print(person.__dict__)
# ==>{'name': 'Jsir', '_Person__age': 24, '__age': 110, '__Person__age': 120}

#################### 2.	私有方法 #
print(Person.__dict__) 
#==>{'__module__': '__main__', '__init__': <function Person.__init__ at 0x000001C6236962F0>, 'show': <function Person.show at 0x000001C623696400>, '_Person__newshow': <function Person.__newshow at 0x000001C6236960D0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None} 
print(person._Person__newshow()) # 破解使用 私有方法
# ==> 我是私有方法
# ==> None

print(object.__dict__) # 查看object的所有方法
# ==>{'__repr__': <slot wrapper '__repr__' of 'object' objects>, '__hash__': <slot wrapper '__hash__' of 'object' objects>, '__str__': <slot wrapper '__str__' of 'object' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'object' objects>, '__setattr__': <slot wrapper '__setattr__' of 'object' objects>, '__delattr__': <slot wrapper '__delattr__' of 'object' objects>, '__lt__': <slot wrapper '__lt__' of 'object' objects>, '__le__': <slot wrapper '__le__' of 'object' objects>, '__eq__': <slot wrapper '__eq__' of 'object' objects>, '__ne__': <slot wrapper '__ne__' of 'object' objects>, '__gt__': <slot wrapper '__gt__' of 'object' objects>, '__ge__': <slot wrapper '__ge__' of 'object' objects>, '__init__': <slot wrapper '__init__' of 'object' objects>, '__new__': <built-in method __new__ of type object at 0x00007FFC36D1FA20>, '__reduce_ex__': <method '__reduce_ex__' of 'object' objects>, '__reduce__': <method '__reduce__' of 'object' objects>, '__subclasshook__': <method '__subclasshook__' of 'object' objects>, '__init_subclass__': <method '__init_subclass__' of 'object' objects>, '__format__': <method '__format__' of 'object' objects>, '__sizeof__': <method '__sizeof__' of 'object' objects>, '__dir__': <method '__dir__' of 'object' objects>, '__class__': <attribute '__class__' of 'object' objects>, '__doc__': 'The most base type'}