python3面向对象_Python3 面向对象

Python3 面向对象

python是一门面向对象语言，在python中有一句话：一切都是对象

面向对象简介类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

实例变量：定义在方法中的变量，只作用于当前实例的类。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化：创建一个类的实例，类的具体对象。

方法：类中定义的函数。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。类的定义

语法格式如下：class ClassName:

类实例化后，可以使用其属性；实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。

属性引用语法：obj.name

对象创建后，类命名空间中所有的命名都是有效属性名#!/usr/bin/python3

class People:

"""一个人类"""

def __init__(self, name, age): # 类的初始化方法，实例化的时候首先调用的方法，前后双下划线的方法都是特殊方法

self.name = name # 类的属性，也是特点、特征

self.age = age

def walk(self): # 普能方法

"""人类会走路"""

print(f'{self.name} is walking')

# 实例化

p = People('yhyang', 18)

# 访问类的属性和方法

print(f'我的名字是：{p.name}，我今年{p.age}岁')

p.walk()

输出：

我的名字是：yhyang，我今年18岁

yhyang is walking

注：上例中，init() 是类的初始化方法，用于初始化类中的属性和方法。self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。类的方法

类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

示例代码：#!/usr/bin/python3

class People:

"""一个人类"""

def __init__(self, name, age): # 类的初始化方法，实例化的时候首先调用的方法，前后双下划线的方法都是特殊方法

self.name = name # 类的属性，也是特点、特征

self.age = age

def walk(self): # 普能方法

"""人类会走路"""

print(f'{self.name} is walking')

# 实例化

p = People('yhyang', 18)

# 访问类的方法

p.walk()

输出：

yhyang is walking

类中的变量私有变量：__name，不能被继承

内部变量：_开头

通过方法修改私有数据，对数据进行保护

示例代码：#!/usr/bin/python3

class Car:

name = 'xxx' # 类的属性

def __init__(self, brand, price, wheels, power):

self._brand = brand

self.price = price

self.wheels = wheels

self.power = power

self.__speed = 0

def run(self, action):

print(f'{self.brand} is running')

if action == '1':

self.__speed += 1 * 10 # 修改私有变量

print('当前速度是：{} km/h'.format(self.__speed))

def start(self):

print(f'{self.brand} is on')

@property

def speed(self): # 只读，getter方法

return self.__speed

@property

def brand(self):

return self._brand

@brand.setter # 添加setter方法，可以被赋值

def brand(self, brand):

if not isinstance(brand, str):

raise TypeError('牌子是字符串类型') # raise 抛出异常

self._brand = brand # 可以对属性操作，提前判断

@property # 把下边的函数变成了属性，可以直接用实例名.info 这样调用

def info(self):

return f'{self.brand}: {self.price}'

# 实例化

auto = Car('auto', 30000, 4, 'oil')

auto.run('1') # 调用run()方法，修改私有变量

auto.info # 以访问属性的方式访问info()方法

auto.brand = 'audiA8' # 此处的brand不是属性，而是下边的@brand.setter处定义的brand方法

auto.brand

tesla = Car('Tesla', 100000, 4, 'electric')

tesla.run('1')

tesla.price = 999999 # 此处是类对象的属性

tesla.price

tesla.name

Car.name

auto.country = 'China' # 在类的对象中动态的新声明一个属性，原类之中不存在

auto.country

输出：

auto is running

当前速度是：10 km/h

'auto: 30000'

'audiA8'

Tesla is running

当前速度是：10 km/h

999999

'xxx'

'China'

特殊方法init: 把各种属性都绑定到self

slots:限制实例的动态属性，减少内存消耗，类型为tuple

str:对象的说明文字

eq: 比较对象是否相等

classmethod 与 staticmethod ；classmethod 会把类本身作为第一个参数传入

示例代码1：

#!/usr/bin/python3 class Computer: __slots__ =('__name', 'mem', 'cpu') # 为节省资源，不允许实例对象随意添加属性 def __init__(self, name, mem, cpu): self.__name = name self.mem = mem self.cpu = cpu def play(self, game='qq games'): print('play',game) # 实例化 pc2 = Computer('admin', '8G', '8核') pc2.mem pc2.ssd = 'ssd' # 此处会报错，类中用了__slots__所以不能随意添加输出： '8G' AttributeError: 'Computer' object has no attribute 'ssd'

示例代码2：

示例代码3：

示例代码4：

#!/usr/bin/python3 class Computer: __slots__ =('_name', 'mem', 'cpu') # 为节省资源，不允许实例对象随意添加属性 def __init__(self, name, mem, cpu): self._name = name self.mem = mem self.cpu = cpu def play(self, game='qq games'): print('play',game) def __str__(self): # 当print(对象)时，自动调用此方法 return f'{self._name}:{self.mem}-{self.cpu}' def __eq__(self,other): # 对象A == 对象B 时调用 return self.cpu == other.cpu @classmethod def new_pc(cls, info): #cls 相当于类本身，通过类名.new_pc（‘参数’）来直接生成实例，而不调用__init__ "从字符串直接产生新的实例" name, mem, cpu = info.split('-') # 传参时用-连接三个参数 return cls(name, mem, cpu) # 使用classmethod建立新对象 pc666 = Computer.new_pc('yhyang-16G-8eeeee核') print(pc666) 输出： yhyang:16G-8核

示例代码5：

#!/usr/bin/python3 class Computer: __slots__ =('_name', 'mem', 'cpu') # 为节省资源，不允许实例对象随意添加属性 def __init__(self, name, mem, cpu): self._name = name self.mem = mem self.cpu = cpu def play(self, game='qq games'): print('play',game) def __str__(self): # 当print(对象)时，自动调用此方法 return f'{self._name}:{self.mem}-{self.cpu}' def __eq__(self,other): # 对象A == 对象B 时调用 return self.cpu == other.cpu @classmethod def new_pc(cls, info): #cls 相当于类本身通过类名.new_pc（‘参数’）来直接生成实例，而不调用__init__ "从字符串直接产生新的实例" name, mem, cpu = info.split('-') # 传参时用-连接三个参数 return cls(name, mem, cpu) @staticmethod # 不需要生成类的实例，就可以使用的方法，直接用类名.calc来调用此方法 def calc(a,b,oper): # 不用第一个参数 "根据操作符+-*/来计算a 和b的结果" if oper == '+': return a + b Computer.calc(2,5,'+') 输出： 7

面向对象三大特征

封装

继承

多态

继承（多继承暂时不说）

python支持类的继承，如下格式：

class DerivedClassName(BaseClassName1): . . .

要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含方法。

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

示例代码：#!/usr/bin/python3

#类定义

class people:

#定义基本属性

name = ''

age = 0

#定义私有属性,私有属性在类外部无法直接进行访问

__weight = 0

#定义构造方法

def __init__(self,n,a,w):

self.name = n

self.age = a

self.__weight = w

def speak(self):

print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例

class student(people):

grade = ''

def __init__(self,n,a,w,g):

#调用父类的构函

people.__init__(self,n,a,w)

self.grade = g

#覆写父类的方法

def speak(self):

print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)

s.speak()

输出：

ken 说: 我 10 岁了，我在读 3 年级

方法重写（多态）如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

super() 函数是用于调用父类(超类)的一个方法。

示例代码：#!/usr/bin/python3

class Parent: # 定义父类

def FatherMethod(self):

print ('调用父类方法')

class Child(Parent): # 定义子类

def FatherMethod(self):

print ('调用子类方法')

c = Child() # 子类实例

c.FatherMethod() # 子类调用重写方法

super(Child,c).FatherMethod() #用子类对象调用父类已被覆盖的方法

输出：

调用子类方法

调用父类方法

元编程类的类型是type，type类型是元类型metaclass，对象的类型是类类型

顺序为 type---> class -----> object

类A继承于type,通过type的new方法返回一个对象，可以认为是类A的对象，所以

类实例化的方式为：a = A(),其实a是A调用type中new方法的返回值

示例代码1：#!/usr/bin/python3

# 运行时动态创建类和函数

# metaclass -> class ->obj

# __new__

class Game:

pass

Game.__class__

输出：

type

type(Game)

输出：

type

示例代码2：#!/usr/bin/python3

# type 是一个metaclass

# 通过type创建一个新的metaclass

class Yuhy(type):

pass

class Yhy(metaclass=Yuhy):

pass

print(type(Yuhy)) # 查看Yuhy类的类型

print(type(Yhy)) # 查看Yhy类的类型

输出：

isinstance(Yhy,Yuhy) # Yhy与Yuhy是否是同样的类型

输出：

True

用Yhy.__new__?查看此方法

Signature: Yhy.__new__(*args, **kwargs)

Docstring: Create and return a new object. See help(type) for accurate signature.

Type: builtin_function_or_method

help(type)

示例代码：class Yuhy(type):

def __new__(cls, name, bases, my_dict): # classmethod

print(f'{name} 使用__new__创建')

yhy = super().__new__(cls, name, bases, my_dict)

return yhy

class Ks(metaclass=Yuhy):

pass

输出：

Ks 使用__new__创建

a = Ks()

print(a)

输出：

<__main__.Ks object at 0x0000024AF06E9A20>

反射能用来干什么

反射也叫内省，其实就是让对象自己告诉我们他有啥，能干啥

有三个方法hasattr(obj,attr)

setattr(obj,attr,val )

getattr(obj,attr)

示例代码1：#!/usr/bin/python3

# hasattr(obj, attr) 检查obj是否有一个名为attr的值的属性，返回一个bool

# getattr(obj,attr) 检查obj中是否有attr属性或方法，并将其返回

# setattr(obj,attr,value) 向对象obj中添加一个属性，值为value

s = 'yhyang' # s是一个字符串对象

s.upper()

输出：

'YHYANG'

isinstance(s, str)

输出：

True

hasattr(s,'upper') # 查看s当中是否有一个叫upper的方法

输出：

True

示例代码2：#!/usr/bin/python3

class People:

def eat(self):

print('eate')

def drink(self):

print('drink')

p = People()

p.eat()

hasattr(p,'eat') # 找这个对象p中有没有eat这个方法

getattr(p,'eat') # 在p中找到eat方法并返回

aa = getattr(p,'eat')

aa()

setattr(p, 'sleep', 'sleep1234') # 添加一个新的属性，值为sleep1234

p.sleep

输出：

eate

True

eate

'sleep1234'

示例代码3：汽车工厂#!/usr/bin/python3

# 汽车类

class Car:

def info(self):

print('Car 父类 ')

class Audi(Car):

def info(self):

print('Audi 汽车')

class Tesla(Car):

def info(self):

print('Tesla 汽车')

# 工厂类

class Factory:

def create(self):

print('创建汽车，工厂基类')

class AudiFactory(Factory):

def creat(self):

print('创造Audi汽车')

return Audi()

class TeslaFactory(Factory):

def creat(self):

print('创造Tesla汽车')

return Tesla()

# 生产汽车

audi_F = AudiFactory()

audi = audi_F.creat()

audi.info()

#另一种写法

AudiFactory().creat().info()

TeslaFactory().creat().info()

输出：

创造Audi汽车

Audi 汽车

创造Audi汽车

Audi 汽车

创造Tesla汽车

Tesla 汽车

python3面向对象_Python3 面向对象

继续阅读

Python爬去百度音乐

python3.6面向对象的多继承与装饰器

7Python全栈之路系列之面向对象运算符重载Python全栈之路系列之面向对象运算符重载

【python】面向对象

python-面向对象之继承

python-面向对象入门

Python 面向对象

python 数据结构 list(3)

Python3入门（十三）面向对象

程序员福音？用Python数据分析教你做投资，巴菲特不会的你会

python 面向对象学校信息班级信息课程信息一、班级操作二、校区操作三、课程四、验证