python面向对象基础_python面向对象基础

python是面向对象语言的集大成者这一点毋庸置疑,处处皆对象,这也就使得python语言能够用最简短的代码来做复杂的事情,程序的可读性也很高.因此用面向对象的程序思想来编写 python程序是很有必要的.

类是有属性和方法构成的,对象实例化也就意味着给类注入了灵魂即(数据),面向对象程序设计有了思想之后主要需要解决的就是如何去操作数据与如何去使用方法来操作数据,以及如何去操作类中的数据方法和对象中的数据方法

在操作数据的前提就是如何去访问数据,既然这样为了确保数据的完整性以及封装性也就有了属性和方法的访问权限设置

当一个类创建了之后或者是类实例化成为对象之后如何在保留原有类或者是对象的基础上增加其他的属性或者是方法嘞？对于这个问题python也解决了也就产生绑定和继承的扩展语法

总而言之面向对象的思想是核心,语法只是形式所有的语法都是为了更好的操作数据以及更好的使用方法

Python Object Oriented Programming Knowlege Tree.png

1.类的定义

class name(object):

'''注释'''

sentence

.....

'''

c以下三个类的定义方式是等同的,所有类都默认继承了一个object类这是所有类的父类,

这个父类有很多的类方法可供子类使用

'''

class clas_a():

pass

class clas_b(object):

pass

class clas_c:

pass

print('clas_a：',dir(clas_a))

print('clas_b:',dir(clas_b))

clas_a： ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

clas_b: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

# 通过类字典来查看类中的方法和属性

print('clas_a')

pirint(clas_a.__dict__)

print('clas_b')

tprint(clas_b.__dict__)

clas_a

{'__module__': '__main__', '__dict__': , '__weakref__': , '__doc__': None}

clas_b

{'__module__': '__main__', '__dict__': , '__weakref__': , '__doc__': None}

可以看到不管是用dir查看属性方法还是用dict方法查看属性和方法,对于两个空类来说都是一样的其属性和方法就是继承至共同父类object的属性和方法

python中为了操作数据方便根据类没有实例化与实例化对象其变量和方法的使用方式也分为两种

|-1.staticvariable,classvariable

|-2.staticmethod,classmethod

staticvariable 和 staticmethod是只能通过实例化对象访问和使用

而classmethod只能通过类调用不能通过对象调用,classvariable即能通过类调用又能通过对象访问

static和class类型可以通过装饰器@staticmethod和@classmethod转换

具体形式见下例:

class class_method_vari(object):

static = 6

def static_method():

print('我是静态方法')

obj_a = class_method_vari()

print('通过对象调用静态变量')

print(obj_a.static)

print('通过类名使用访问静态变量')

print(class_method_vari.static)

print('通过类名调用静态方法')

class_method_vari.static_method()

print("通过对象名调用静态方法")

obj_a.static_method() #调用不了TypeError出错

通过对象调用静态变量

6

通过类名使用访问静态变量

6

通过类名调用静态方法

我是静态方法

通过对象名调用静态方法

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in

11 class_method_vari.static_method()

12 print("通过对象名调用静态方法")

---> 13 obj_a.static_method() #调用不了TypeError出错

TypeError: static_method() takes 0 positional arguments but 1 was given

对于类变量和类函数来说当程序执行的时候会加载进去类变量会分配储存空间,

这时候类变量就相当于是全局变量,在任何地方都可以使用,这个是不依赖与对

象所存在的只不过在使用的时候要用加上了类名的前缀而类函数则会加载当通

过类名调用的时候才会给其数据分配存储空间,类函数也相当于是全局函数只

不过在使用的时候也加上前缀罢了

# 函数加了self或者变量加了self就变成了静态变量和静态函数只能由对象调用

class tatic_cls:

#self.c = 3 #在方法外面定义静态变量都是错误的

def __init__(self,a,b):

self.a = a

self.b = b

def sumcount(self):

return self.a + self.b

#self.c = 2 #在方法外面定义静态变量都是错误的

obj_stctic = tatic_cls(1,2)

print('对象访问self变量a,b')

print(obj_stctic.a,obj_stctic.b)

print('对象访问self函数')

print(obj_stctic.sumcount())

#下面两种方式都是错误的

#print(tactic_cls.a,tactic_cls.b)

#print(tactic_cls.sumcount())

对象访问self变量a,b

1 2

对象访问self函数

3

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in

15 #下面两种方式都是错误的

16 #print(tactic_cls.a,tactic_cls.b)

---> 17 print(tactic_cls.sumcount())

NameError: name 'tactic_cls' is not defined

|-self 的意义:

self是代表一个对象的应用,一个类在理论上来说可以创建无数个对象,但是类中有类属性和对象属性,而类属性是这个类

的实例化对象所共有的,但是通过这个类创建的无数个对象不同的对象可能就有不同的对象属性那么在使用属性的时候如何

去区分不同对象的不同属性嘞？这就要靠这个self参数,self参数是对象属性对象方法的标志,依赖self的属性和方法都是

依赖对象的存在,同一个类不同的多态对象也就产生了不同的self,也就是说self是与对象一一对应的,不同的self传递给

类就可以使用不同的属性,self的意义也就在于为了让类区分不同的对象属性.

|-静态属性和方法说明:

静态属性和方法就是使用了前缀self的变量和使用了参数self的方法,self是依赖与对象的因此静态变量和静态方法即对象成员变量

和成员方法也是依赖于对象的存在,在对象实例化的时候才会分配内存储存数据,且与对象同生共死

|-__init__方法的说明:

__init__方法也叫作构造方法,其作用是用来给self变量赋值的,可以自己手动构造self方法当定义类的时候没有定义self方法

的时候解释器会自动给类加上一个空的__init__方法,因此创建类的时候不定义__init__方法也是行得通的,__init__方法当类

实例化成为对象的时候会自动调用,因为__init__方法的调用是依赖与对象的所以其参数必须要带上self.

class cls_a:

def __init__(self,a,b):

self.a = a

self.b = b

def function(self):

return self.a + self.b

obj_a = cls_a(1,2) #在实例化对象的时候传递参数给self.a,self.b

print('通过对象调用成员函数')

print(obj_a.function())

#print(cls_a.function()) #这个是错误的因为静态变量和方法是依赖于对象的没有对象类必然不能调用

print('给成员函数传递一个对象后用过类名直接调用')

print(cls_a.function(obj_a)) #这个是正确的

通过对象调用成员函数

3

给成员函数传递一个对象后用过类名直接调用

3

#静态方法与动态方法用装饰器相互转化

class cls_b:

def __init__(self,a,b):

self.a = a

self.b = b

'''

@staticmethod

def class_fun1():

return self.a*self.b

注意这种方式是错误的,因为类方法是全局函数其内不能使用成员变量

最关键的是他没有self参数不解释器不能够给他传递对象,而self变量

即成员变量的使用是依赖于对象的

'''

@staticmethod #将类方法变换成静态方法

def class_fun(p1:int,p2:int)->int:

return p1*p2

'''

@classmethod #将静态方法变换成类方法

def static_fun(self):

return self.a+self.b

这种方式也是错误的这个函数虽然有self参数但是装饰之后解释器会

不断的给self传递类本身,因此也不能使用成员变量

'''

@classmethod

def static_fun(self,a,b):

return a+b

obj_a = cls_b(2,4)

print('通过对象调用原类方法')

print(obj_a.class_fun(2,4))

print('通过类使用通过静态装饰了的类方法')

print(cls_b.class_fun(2,4))

#print(obj_a.class_fun1(obj_a))

print('通过类名调用类装饰器装饰了的静态方法')

print(cls_b.static_fun(2,4))

print('通过对象调用类装饰器装饰了的静态方法')

print(obj_a.static_fun(2,4))

通过对象调用原类方法

8

通过类使用通过静态装饰了的类方法

8

通过类名调用类装饰器装饰了的静态方法

6

通过对象调用类装饰器装饰了的静态方法

6

|-总结:

由上例可知当静态方法和类方法用装饰器装饰了之后,既可以通过类调用又可以通过对象调用

而且不可以在使用了方法装饰器之后的函数中使用self变量和函数

class clas_a:

def __init__(self,a,b):

self.a = a

self.b = b

print(self,a,b) #输出self的值

obj_a = clas_a(1,2)

obj_b = clas_a(1,2)

<__main__.clas_a object at> 1 2

<__main__.clas_a object at> 1 2

|-再论self含义:

由上例可知obj_a与obj_b是两个不同的对象他们的self值是不同的因此再次说明self与对象是一一对应的

变量的访问权限设置

Python提供了一种约定(下划线)来限制对成员(成员变量，成员函数)的访问：

_xxx 不能用’from module import *’导入

__xxx__ 系统定义名字

__xxx 类中的私有变量名、

这里仅仅演示__xxx私有变量的使用

|-私有变量仅仅只能够在类内部使用,即不能用类名使用也不能用对象名使用

class clas_a:

a = 1

def __init__(self,a,b):

self.a = a #如果类变量名与成员变量名冲突则成员变量覆盖类变量

self.b = b

print(self.a,self.b)

obj_a = clas_a(3,4)

print(clas_a.a)

print(obj_a.a)

print(obj_a.b)

'''

print(clas_a.__a)

print(obj_a.__a)

print(obj_a.__a)

'''

3 4

1

3

4

'\nprint(clas_a.__a)\nprint(obj_a.__a)\nprint(obj_a.__a)\n'

class clas_a:

__c = 1

def __init__(self,a,b):

self.__a = a #如果类变量名与成员变量名冲突则成员变量覆盖类变量

self.__b = b

print(self.__a,self.__b)

@classmethod

def __func_a(self,e,f):

return e+f

obj_a = clas_a(3,4)

'''

#下面语句都是错误的私有变量和私有函数只能够在类内部使用

#print(obj_a.__func_a(1,2))

#print(clas_a.__func_a(1,2))

#print(clas_a.__a)

#print(obj_a.__a)

#print(obj_a.__b)

#print(obj_a.__c)

'''

3 4

---------------------------------------------------------------------------

AttributeError Traceback (most recent call last)

in

16 #print(obj_a.__a)

17 #print(obj_a.__b)

---> 18 print(obj_a.__c)

AttributeError: 'clas_a' object has no attribute '__c'

|-私有变量操作说明:

私有变量和方法只能够在类内部使用是不能够在类外部使用的,其目的是为了实现对象的封装性,确保数据不外漏.

要想对私有变量进行操作只能够利用方法,在类内部或者是对象内部的方法去进行操作,如下面的操作

class clas_a:

__c = 1

def __init__(self,a,b):

self.__a = a

self.__b = b

print(self.__a,self.__b)

@classmethod

def __func_a(self,e,f):

return e+f

def get_func(self):

print(self.__a,self.__b,clas_a.__c) #获取private variable value也可以用return返回

def set_func(self,a,b,c): #设置private variable value

self.__a = a

self.__b = b

__c = c

obj_a = clas_a(3,4)

print('输出初始值')

obj_a.get_func()

obj_a.set_func(7,8,9)

print('输出修改后的私有变量值:')

obj_a.get_func()

3 4

输出初始值

3 4 1

输出修改后的私有变量值:

7 8 1

＃未完待续，过年还是得玩会