标签:ati compute 速度 rate att 特殊方法 汽车 raise usr
Python3 面向对象python是一门面向对象语言,在python中有一句话:一切都是对象
语法格式如下:
class ClassName:
<statement-1>
.
.
.
<statement-N>
类实例化后,可以使用其属性;实际上,创建一个类之后,可以通过类名访问其属性。
类对象支持两种操作:属性引用和实例化。
属性引用语法: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() 是类的初始化方法,用于初始化类中的属性和方法。
类地内部,使用 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
#!/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‘
‘xxx‘
‘China‘
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:
#!/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}‘
# 实例化
pc3 = Computer(‘admin‘, ‘8G‘,‘8核‘)
print(pc3) # 直接打印对象
输出:
admin:8G-8核
示例代码3:
#!/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
# 实例化
pc2 = Computer(‘admin‘,‘8G‘,‘8核‘)
pc3 = Computer(‘admin‘,‘4G‘,‘8核‘)
pc2 == pc3 # 调用__eq__方法,认为cpu相等即为两个对象相等
输出:
True
示例代码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):
<statement-1>
.
.
.
<statement-N>
要注意圆括号中基类的顺序,若是基类中有相同的方法名,而在子类使用时未指定,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 年级
#!/usr/bin/python3
class Parent: # 定义父类
def FatherMethod(self):
print (‘调用父类方法‘)
class Child(Parent): # 定义子类
def FatherMethod(self):
print (‘调用子类方法‘)
c = Child() # 子类实例
c.FatherMethod() # 子类调用重写方法
super(Child,c).FatherMethod() #用子类对象调用父类已被覆盖的方法
输出:
调用子类方法
调用父类方法
#!/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类的类型
输出:
<class ‘type‘>
<class ‘__main__.Yuhy‘>
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_methodhelp(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>
反射也叫内省,其实就是让对象自己告诉我们他有啥,能干啥
有三个方法
#!/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
<bound method People.eat of <__main__.People object at 0x0000024AF06F7668>>
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 汽车
标签:ati compute 速度 rate att 特殊方法 汽车 raise usr
原文地址:http://blog.51cto.com/445153/2133822