python面向对象简介:
Python是一个面向对象的编程语言,但是很多人就要问了,到底什么叫做面向对象呢?面向对象编程又是什么呢?
Python的类就像一个模具,是始终不变的,但是如果往里面倒的东西不一样,那么出来的东西虽然形状一样,但是说到底还是有区别的。
- 一个类占有一个独立的空间,类中的属性叫做类变量,类中的函数,叫做类的方法。
- 类(Class):也可以成为类对象。类对象中包含了一批实例对象共有的属性和方法。
- 类变量:定义在类中且在函数体之外的变量。类变量在所有的实例变量中是共享的,类变量修改了,所有实例对象读取到的值都会修改。
- 实例变量:定义在类的实例方法中的变量,只作为当前实例的属性。
- 数据成员:类变量或者实例变量,以及用于处理类及其实例对象的相关的数据的统称。
- 方法:类中定义的函数。包含普通方法,类方法,静态方法,魔术方法。
- 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。其实只是在派生类中添加了同名方法,以至于查询方法时不会再向基类查询。
1、类和对象
面向对象是更大的封装,在一个类中封装多个方法,这样通过这个类创建出来的对象,就可以直接调用这些方法了!
- 定义简单的类
class 类名:
def 方法1(self, 参数列表):
pass
def 方法2(self, 参数列表):
pass
- 创建对象
对象变量 = 类名()
例1:
class Cat:
def eat(self):
print("小猫爱吃鱼")
def drink(self):
print("小猫要喝水")
# 创建猫对象
tom = Cat()
tom.eat()
tom.drink()
print(tom)
addr = id(tom)
print("%x" % addr)
2、方法中的self参数
在 Python 中,要 给对象设置属性,非常的容易,但是不推荐使用 因为:对象属性的封装应该封装在类的内部 只需要在 类的外部的代码
中直接通过 “ . ” 设置一个属性即可 注意:这种方式虽然简单,但是不推荐使用!
给对象增加属性:
由哪一个对象调用的方法,方法内的 self 就是哪一个对象的引用在类封装的方法内部,self
就表示当前调用方法的对象自己调用方法时,程序员不需要传递 self 参数。在方法内部可以通过 self. 访问对象的属性,也可以通过
self. 调用其他的对象方法。
例2:
class Cat:
def eat(self):
# 哪一个对象调用的方法,self就是哪一个对象的引用
print("%s 爱吃鱼" % self.name)
def drink(self):
print("%s 要喝水" % self.name)
# 创建猫对象
tom = Cat()
# 可以使用 .属性名 利用赋值语句就可以了
tom.name = "Tom"
tom.eat()
tom.drink()
3、类中方法
类中方法:动作
方法:普通方法 静态方法 类方法 魔术方法
1. 普通方法:
普通方法格式:
def 方法名(self[,参数,参数,参数,参数]):
pass
例3:
class Phone:
brand = 'xiaomi'
price = 2999
type = 'mix3'
# Phone里面的类方法:call
def call(self):
print('self-------------->', self)
print('正在打电话。。。。。')
print('请留言......', self.note)
phone1 = Phone()
print(phone1)
print(phone1.brand)
phone1.note = '134524787678'
phone1.call()
phone2 = Phone()
print(phone2)
print(phone2.brand)
phone2.note = '178524577999'
phone2.call()
运行结果:
<__main__.Phone object at 0x000001710CF42940>
xiaomi
self--------------> <__main__.Phone object at 0x000001710CF42940>
正在打电话。。。。。
请留言...... 134524787678
<__main__.Phone object at 0x000001710CF42748>
xiaomi
self--------------> <__main__.Phone object at 0x000001710CF42748>
正在打电话。。。。。
请留言...... 178524577999
2. 类方法:
类方法 :在定义的普通方法上加一个 @classmethod
# 类方法 :在定义的普通方法上加一个 @classmethod
"""
特点:
1、定义需要依赖装饰器 @classmethod
2、类方法中参数不是一个对象,而是类
print(cls) <class '__main__.Dog'>
3、类方法中只可以使用类属性
4、类方法中可否使用普通方法? 不能
5、普通方法可以调用类方法吗? 可以,通过 self.类方法名()
类方法作用:
因为只能访问类方法和类属性,所以可以在对象创建之前,如果需要完成一些动作(功能)
"""
class Dog:
def __init__(self, nickname):
self.nickname = nickname
def run(self):
print('{}在院子里走来走去!'.format(self.nickname))
self.test()
def eat(self):
print('正在吃饭。。。。')
self.run() # 类中方法的调用,需要通过self.方法名()
@classmethod
def test(cls):
print('--------------------')
print(cls)
print('********************')
# print(cls.nickname) 报错
# print(self.nickname) 报错
d = Dog('aasd')
d.run()
d.eat()
d.test()
Dog.test()
运行结果:
aasd在院子里走来走去!
--------------------
<class '__main__.Dog'>
********************
正在吃饭。。。。
aasd在院子里走来走去!
--------------------
<class '__main__.Dog'>
********************
--------------------
<class '__main__.Dog'>
********************
--------------------
<class '__main__.Dog'>
********************
3. 静态方法:
静态方法: 很类似 类方法,需要装饰器@staticmethod
# 补充类方法
"""
静态方法: 很类似 类方法
1、需要装饰器@staticmethod
2、静态方法是无需传递参数(cls,self)
3、也只能访问类的属性和方法,对象是无法访问的
4、加载时机同类方法
总结:
类方法 静态方法
不同:
1、装饰器不同
2、类方法有参数,静态方法没有参数
相同:
1、只能访问类的属性和方法,对象的属性和 方法是无法访问的
2、都可以通过类名调用访问
3、都可以在创建对象之前使用,因为不依赖于对象
普通方法与两者的区别:
1、没有装饰器
2、普通方法永远要依赖对象,因为每个普通方法都有一个self
3、只有创建了对象才可以调用普通方法,否则无法调用
"""
class Person:
__age = 18
name='lly'
def show(self):
self.salary=1900
print('---------->NAME:',Person.name)
print('-------------->', Person.__age)
print('---------->salary------->',self.salary)
@classmethod
def test(cls):
cls.__age = 19
print('--------------->类方法')
print('多少岁了:', cls.__age)
@staticmethod
def test1():
print('静态方法----------->')
# print(self.salary) 报错
p1 = Person()
p1.test()
p1.show()
p1.test1()
运行结果:
--------------->类方法
多少岁了: 19
---------->NAME: lly
--------------> 19
---------->salary-------> 1900
静态方法----------->
4. 魔术方法、初始化:
在 Python 中 对象几乎是无所不在的,我们之前学习的 变量、数据、函数 都是对象
在 Python 中可以使用以下两个方法验证:
在 标识符 / 数据 后输入一个 .,然后按下 TAB 键,iPython 会提示该对象能够调用的 方法列表
使用内置函数 dir 传入 标识符 / 数据,可以查看对象内的 所有属性及方法
提示 mingzhi__格式的方法是 Python 提供的 内置方法 / 属性,稍后会给大家介绍一些常用的 内置方法 / 属性
初始化:
使用类名()创建对象的时候,会自动调用初始化方法 init__
例4:
class Phone:
# 魔术方法之一:称作魔术方法 __名字__()
def __init__(self):
self.brand = 'xiaomi'
self.price = 4999
print('------------>init')
def call(self):
print('---------->call')
print('价格:', self.price)
p = Phone()
p.call()
p1 = Phone()
p1.price = 5999
p1.call()
运行结果:
------------>init
---------->call
价格: 4999
------------>init
---------->call
价格: 5999
del方法:
class Cat:
def __init__(self, new_name):
self.name = new_name
print("%s 来了" % self.name)
def __del__(self):
print("%s 我去了" % self.name)
# tom 是一个全局变量
tom = Cat("Tom")
print(tom.name)
# del 关键字可以删除一个对象
del tom
print("-" * 50)
运行结果:
Tom 来了
Tom
Tom 我去了
--------------------------------------------------
str方法:
在 Python 中,使用 print 输出 对象变量,默认情况下,会输出这个变量 引用的对象 是 由哪一个类创建的对象,以及 在内存中的地址(十六进制表示)
如果在开发中,希望使用 print 输出 对象变量 时,能够打印 自定义的内容,就可以利用 str 这个内置方法了
注意:__ str __方法必须返回一个字符串
class Cat:
def __init__(self, new_name):
self.name = new_name
print("%s 来了" % self.name)
def __del__(self):
print("%s 我去了" % self.name)
def __str__(self):
# 必须返回一个字符串
return "我是小猫[%s]" % self.name
# tom 是一个全局变量
tom = Cat("Tom")
print(tom)
运行结果:
Tom 来了
我是小猫[Tom]
Tom 我去了