python类的介绍_Python 类的介绍

如何创建类：

class 类名:

pass

eg:

class Bar: # 定义一个类

def foo(self, arg): # self 永远是调用方法的对象，即中间人

print(self, self.name, self.age, arg)

obj = Bar() # 使用 Bar 类,创建一个对象 obj

print(obj)

obj.name = 'klvchen'

obj.age = 28

obj.foo(666)

运行结果:

<__main__.bar object at> klvchen 28 666

创建方法

构造方法: __init__(self, arg)

obj = 类(参数)

普通方法：obj = 类(参数)

obj.普通方法名()

调用类中的方法

class Foo:

def bar(self):

print('bar')

obj = Foo() # 方法一，常用

obj.bar()

obj = Foo() # 方法二

Foo.bar(obj)

运行结果：

bar

bar

类中的字段

在类中分为普通字段和静态字段：

普通字段：保存在对象中，执行只能通过对象访问

静态字段：保存在类中，执行可以通过对象访问，也可以通过类访问

eg:

class Province:

country = 'China' # 静态字段

def __init__(self, name):

self.name = name # 普通字段

print(Province.country)

运行结果:

China

类中的三种方法：

1.普通方法：保存在类中，由对象来调用，self 是对象

2.静态方法：保存在类中，由类直接调用

3.类方法 ： 保存在类中，由类直接调用， cls 是当前类

应用场景：

如果对象需要保持一些值，执行某功能时，需要使用对象中的值，选择 普通方法

不需要任何对象中的值选择 静态方法

注:类在内存中只保存一份，可节省系统的内存

eg:

class Foo:

def bar(self):

print('bar')

@staticmethod # 静态方法

def sta():

print('static method')

@staticmethod # 静态方法，带参数

def sta2(n):

print(n)

Foo.sta()

Foo.sta2(666)

运行结果:

static method

666

class Foo:

@classmethod

def classmod(cls): # 类方法, cls 是当前类 Foo

print(cls)

print('classmethod')

Foo.classmod()

运行结果:

classmethod

面向对象三大特性之一: 封装

eg:

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def show(self):

print('%s %d' %(self.name, self.age))

klvchen = Person('陈', 28) # 生成对象时会自动执行 __init__() 方法

klvchen.show()

运行结果:

陈 28

面向对象三大特性之二: 继承

将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

class Father:

pass

class Son(Father):

pass

eg:

class F:

def f1(self):

print('F.f1')

def f2(self):

print('F.f2')

class S(F):

def s1(self):

print('S.s1')

def f2(self):

super(S, self).f2() # 执行父类的 f2 方法

F.f2(self) # 执行父类的 f2 方法

obj = S()

obj.f1()

obj.s1()

obj.f2()

运行结果:

F.f1

S.s1

F.f2

F.f2

Python 支持多继承，规则如下：

1.左侧优先

2.一条道做到最后

3.同一根时，根最后执行

eg:

class F1:

def f(self):

print('F1.f')

class F2:

def f(self):

print('F2.f')

class S(F1, F2):

pass

obj = S()

obj.f()

运行结果:

F1.f

面向对象三大特性之三: 多态

python 原生就支持多态

添加 @property 后，访问属性时可以制造出和访问字段完全相同的假象

class Foo:

def bar(self):

print('bar')

@property

def per(self):

print('123')

return 1

@per.setter

def per(self, val):

print(val)

@per.deleter

def per(self):

print(888)

obj = Foo()

r = obj.per

#print(r)

obj.per = 666

del obj.per

运行结果:

123

class Foo:

def f1(self):

return 123

def f2(self, val):

print(val)

def f3(self):

print('del')

per = property(fget=f1, fset=f2, fdel=f3)

obj = Foo()

ret = obj.per

print(ret)

obj.per = 6666

del obj.per

运行结果:

123

6666

del

对象后面加 () 直接调用__call__方法

class Foo:

def __init__(self):

print('init')

def __call__(self, *args, **kwargs):

print('call')

obj = Foo()

obj()

运行结果:

init

call

__dict__获取对象所有的成员，以字典返回

class Foo:

def __init__(self, name, age):

self.name = name

self.age = age

obj = Foo('klvchen', 28)

d = obj.__dict__

print(d)

运行结果:

{'name': 'klvchen', 'age': 28}