객체 지향 프로그래밍에서 객체라는 용어는 기본적으로 데이터(속성)의 집합과 이러한 데이터에 액세스하고 조작할 수 있는 일련의 메서드로 간주할 수 있습니다. 전통적인 의미에서 "프로그램 = 데이터 구조 + 알고리즘"은 캡슐화되고 "은폐"되며 "프로그램 = 객체 + 메시지"로 단순화됩니다. 객체는 클래스의 인스턴스이며 클래스의 추상화는 캡슐화되어야 합니다. 캡슐화를 사용하면 호출자가 개체 구성 방식에 신경 쓰지 않고 개체를 직접 사용할 수 있습니다.
먼저 Python 프로그래밍 사양을 설명하세요.
#!/usr/bin/env python
#coding=utf-8
#编程规范，示例如下：
class ClassName(object):
'''testdoc #这里面是一些说明文档，该类的说明信息是可以被help看到的
example:
'''
#注释的写法，可以在后面，也可以在上一行，单行注释以#号开头
a= 100 #this is a number for a
#thisis a number for b
b= 200
c= ['a','b'] #or 分行写
d= { #列表、字典等可以分行写，这样更加直观
'key1':'v1',
'key2':'v2',
'key3':'v3'
}
def__init__(self,num,m): #初始化方法。如果不写，则是从基类继承
self.age= num
self.__money= m
deftest(self):
return100
def__eq__(self,other): #魔术方法
returnself.age == other.age
def__del__(self): #析构函数，在整个类调用执行完后会执行
print'world'
d = Hello(2,200)
d2 = Hello(3,100)
print d == d2 #会自动调用__eq__方法，返回比较结果
print d
print d2
작성 사양에는 일반적으로 설명 텍스트, 초기화 방법, 한 줄 또는 다중이 포함됩니다. -라인 주석 등
1. 구성 방법:
다음 예는 구성 방법과 초기화 방법의 실행 순서를 보여줍니다.
#!/usr/bin/env python
class Of(object):
def __new__(cls,*args,**kwargs): #构造方法
print 'new'
return super(Of,cls).__new__(cls,*args,**kwargs)
#returnobject.__new__(cls,*args,**kwargs)
def __init__(self): #初始化方法
print "init"
def test(self):
print 'hello'
f = Of()실행 결과는 다음과 같습니다.
new init
는 클래스가 인스턴스화될 때 먼저 생성자 메서드를 실행한 다음 초기화 메서드를 실행하는 것을 보여줍니다
다음 예는 생성자 메서드와 초기화 메서드의 차이점을 보여줍니다.
#!/usr/bin/env python
class Resource(object): #父类的定义
def __init__(self): #初始化方法，为了说明这里直接输出名字
print 'call me resource init'
def __new__(cls,*args,**kwargs): #构造方法，这里使用这种传参可以接受任何类型的参数
print "resource new"
returnobject.__new__(cls,*args,**kwargs) #返回值为object基类的构造方法的返回值
class DockerResource(Resource): #子类的定义，继承了Resource类
def __new__(cls,*args,**kwargs): #重新构造自己的构造方法
print "call me dockerresource new"
returnResource.__new__(cls,*args,**kwargs) #返回值为Resource父类的构造方法的返回值
def __init__(self): #定义自己的初始化方法
print 'call docker resourceinit'
def test(self): #定义test方法
print 'dosker resource test'
r = DockerResource() #实例化DockerResource，并将返回值传递给r
print r #打印r,查看返回值是什么
print type(r) #查看r的类型
r.test()출력 결과는 다음과 같습니다.
call me docker resource new #首先调用了DockerResource的构造方法 resource new #构造方法返回的是Resource的构造方法，所以会执行Resource父类构造方法的print "resource new" call docker resource init #然后会执行自己的初始化方法 <__main__.DockerResource object at0x7fa1a3edcf90> #r现在接受的是Resource父类的构造方法的返回值，所以会有object出现 <class '__main__.DockerResource'> #类型为自己DockerResource dosker resource test #调用自己的test方法
클래스에서는 먼저 해당 클래스를 실행합니다. 그렇지 않은 경우 상위 클래스에서 상속한 다음 자체 초기화 메서드를 실행합니다. 그렇지 않은 경우에도 여전히 상위 클래스에서 상속되며 자체 인스턴스 메서드를 정상적으로 호출할 수 있습니다.
2. 상속:
다음 예는 하위 클래스 상속을 보여줍니다. 상위 클래스
#!/usr/bin/env python
class Resource(object): #定义一个父类，继承于object基类
def __new__(cls,*args,**kwargs): #构造方法
print 'class resource __new__'
obj =super(Resource,cls).__new__(cls,*args,**kwargs) #利用super函数找到自己的父类，并将它的构造方法传递给obj
print obj.__class__ #打印obj的类型
return obj #返回值为obj
def __init__(self): #初始化方法
print "call me init forResource"
def test(self):
print "call me test forResource"
def create(self):
print "call me create forResource"
class subResource(Resource): #定义子类，继承Resource父类
def __init__(self): #定义自己的初始化方法
print 'sub resource init'
def test(self):
print 'sub resource test'
class Heat(object): #定义一个Heat类，继承于基类object，是个新式类
def __new__(cls,*args,**kwargs): #定义自己的构造方法
print "class __new__%s" % cls
returnobject.__new__(cls,*args,**kwargs) #返回值为object基类的构造方法的返回值
def __init__(self): #定义初始化方法
print 'heat init'
r = Heat() #实例化
print r
h = Resource() #实例化
print h
f = subResource() #实例化
print f의 실행 결과는 다음과 같습니다.
class __new__ <class '__main__.Heat'> #实例化Heat类，首先执行自己的构造方法和初始化方法，所以先输出构造方法的print语句 heat init #执行了自己的初始化方法 <__main__.Heat object at0x7f43349ac050> #r实例化后继承的是object基类，打印返回值 class resource __new__ #实例化Resource类，首先执行自己的构造方法和初始化方法，所以先输出构造方法的print语句 <class '__main__.Resource'> #打印父类构造方法的返回值的类名 call me init for Resource #执行自己的初始化方法 <__main__.Resource object at0x7f43349ac090> # h实例化后继承的是object基类，打印返回值 class resource __new__ #实例化subResource类，首先执行父类的构造方法，所以先输出父类构造方法的print语句 <class '__main__.subResource'> #父类构造方法里面打印自己的类名 sub resource init #执行自己的初始化方法 <__main__.subResource object at0x7f43349ac0d0> #f实例化后是执行了父类Resource类的构造方法，返回的依旧是object基类
3. 다중 상속:
#!/usr/bin/env python
class A(object):
def __init__(self):
pass
def ma(self):
print 'a.ma'
def m(self):
print 'it is A'
class B(object):
def mb(self):
print 'b.mb'
def m(self):
print 'it is B'
class C(A,B):
pass
c = C()
c.ma()
c.mb()
c.m()실행 결과는 다음과 같습니다.
a.ma b.mb it is A
를 통해 실행 결과를 보면 C가 A와 B를 상속하므로 A 또는 B의 ma() 메서드를 호출할 수 있지만 A와 B에 동일한 메서드가 있는 경우 우선 순위를 부여한다는 것을 알 수 있습니다. 처음으로 상속받은 슈퍼클래스.
4. 상속 및 오버로딩:
#!/usr/bin/env python
class Phone(object):
def __init__(self,size,color,memory):
self.size = size
self.color = color
self.memory = memory
def call(self):
s = 'I can call'
return s
def sms(self):
s = 'Are you gua le mei?'
#!/usr/bin/env python
class Phone(object):
def __init__(self,size,color,memory):
self.size = size
self.color = color
self.memory = memory
def call(self):
s = 'I can call'
return s
def sms(self):
s = 'Are you gua le mei?'
return s
class Phones(Phone): #继承了Phone类，重载了自己的初始化方法，又增加了自己的方法，既拥有超类的方法，又有自己特有的方法
def __init__(self,size,color,memory,pix):
self.pix = pix
super(Phones,self).__init__(size,color,memory)
def install_app(self,app):
s = 'install %s' % app
return s
class Huwei(Phone): #继承了Phone类，又增加了自己的方法，既拥有超类的方法，又有自己特有的方法
def weixin(self,msg):
if msg.find('gcd') == -1:
return 'sending....'
else:
return 'You can\'t sendthe msg'
p = Phone(1.2,'black','4M') #实例化
iphone =Phones(4.7,'white','4G','1280*766') #实例化
h = Huwei(4.7,'yellow','4G') #实例化
print iphone.install_app('weixin') #执行特有的install_app方法
print h.sms()
print h.call()
print h.weixin('wansui')
sms = p.sms()
call = p.call()
print sms,call실행 결과는 다음과 같습니다.
install weixin Are you gua le mei? I can call sending.... Are you gua le mei? I can call
메서드의 오버로딩 실제로는 클래스에서 def 키워드를 사용하여 부모 클래스의 메서드를 오버로드합니다. 상위 클래스의 메소드를 오버로드했지만
클래스에서 상위 클래스의 메소드를 사용해야 하는 경우 상위 클래스 이름에 '.'를 더하고 메소드 이름을 사용하여
<을 호출할 수 있습니다. 🎜>5 , 매직 메소드:
#!/usr/bin/env python
class Information(object):
'''This is a doc #说明文档
example for test,please don'tchange it.
'''
def __init__(self,sch,cla,m,n): #定义初始化方法
print "welecome to schoolsystem."
self.school = sch #实例变量
self.classroom = cla #实例变量
self.num = 100 #实例变量
self.__money = m #私有变量
self.num = n #实例变量
def school_name(self): #返回实例变量，即将实例变量传递出去
return self.school
def class_name(self): #返回实例变量，即将实例变量传递出去
return self.classroom
def class_money(self): #返回私有变量，即将私有变量传递出去
return self.__money
#魔术方法：以双下划线开头，以双下划线结尾的方法是魔术方法
def __eq__(self,another): #当外部出现'=='比较的时候，调用此魔术方法
return self.__money ==another.__money #返回两个私有变量的比较结果（布尔值），这里self是'=='左边的参数值，another是右边的参数值
def __gt__(self,another): #当外部出现'>'比较的时候，调用此魔术方法
return self.__money >another.__money #返回两个私有变量的比较结果（布尔值），这里self是'>'左边的参数值，another是右边的参数值
def __ne__(self,another): #当外部出现'!='比较的时候，调用此魔术方法
return self.__money !=another.__money #返回两个私有变量的比较结果（布尔值），这里self是'!='左边的参数值，another是右边的参数值
def __add__(self,another): #当外部出现'+'运算符的时候，调用此魔术方法
return self.__money +another.__money #返回两个私有变量的相加结果，这里self是'!='左边的参数值，another是右边的参数值
#returnInformation('jiaoda','dz1302',self.__money + another.__money)
#return Information('jiaoda','dz1302',1024,self.num+ another.num)
def __str__(self):
return 'money = %d' %self.__money
def __hash__(self): #获取hash值
return 1314521
def __getattr__(self,name): #当调用不存在的方法时，执行此方法进行输出
print "get attr %s" %name
return name
def __del__(self): #析构方法，当不再使用此类时，会自动执行
print "Goodbye,welecomhere again."
f = Information('youdian','tg1312',9999,6) #实例化
l = Information('ligong','jk1213',6666,4) #实例化
print f == l #调用魔术方法__eq__()
print f + l #调用魔术方法__add__()
print f > l #调用魔术方法__gt__()
s = f + l #
print s
print f.ccc #名字不存在，调用__getatter__()方法
__str__은 인쇄 기능에 의해 호출되며 일반적으로 무언가를 반환합니다. 이는 문자열 형태로 표현되어야 합니다. 그렇지 않은 경우 str() 함수를 사용하여 변환하십시오. 클래스를 인쇄할 때 가장 먼저 인쇄가 호출하는 것은 클래스에 정의된 __str__
입니다. 실행 결과는 다음과 같습니다:
welecome to school system. #首先会在实例化的时候执行初始化方法 welecome to school system. #第二次实例化调用初始化方法 False #打印__eq__()的返回值为False 16665 #打印__add__()的返回值为两数相加 True #打印__gt__()的返回值为True 16665 get attr ccc #执行__getattr__()方法 ccc Goodbye,welecom here again. #执行完会自动执行析构函数 Goodbye,welecom here again.
> 6. 모듈:
파이썬에는 200개 이상의 모듈이 포함되어 있습니다. 모두의 지속적인 개선과 개선 끝에 이제 공식 웹사이트에서는 원하는 거의 모든 기능을 달성할 수 있는 2,000개 이상의 라이브러리 모듈을 수집했습니다. .
직접 사용할 때는 자체 모듈을 사용할 수도 있습니다. 모든 .py를 별도의 모듈로 가져올 수 있습니다.
이제 먼저 자체 모듈인 py를 정의합니다.
#!/usr/bin/env python
#coding=utf-8
def test():
print'This is a test'
def test2():
print'test2'
class DB(object):
def__init__(self):
self.a= 101
deftest(self):
returnself.a#!/usr/bin/env python import module module.test()
This is a test
#!/usr/bin/env python import module h = module.DB() print h.test()
101
디렉터리는 다음과 같아야 합니다. __init__.py만 모듈로 가져올 수 있습니다. 
heat 디렉터리에 있는 docker.py의 내용은 다음과 같습니다.
#!/usr/bin/env python
def docker():
return'This is a docker in heat'
class Docker(object):
defcreate_c(self):
return'1314521aaa'
defstop_c(self):
return'it is stop'
print __name__
if __name__ == '__main__':
print__name__
d= Docker()heat 디렉토리에 있는 nova.py의 내용은 다음과 같습니다:
#!/usr/bin/env python
def nova():
return'This is a nova'
class Nova(object):
deftest(self):
return'This is a test in nova'이제 __init__ 파일만 있습니다. heat 디렉토리이고, 파일에 내용이 없습니다
호출 스크립트 파일 작성:
#!/usr/bin/env python #coding=utf-8 import heat.docker #目录下__init__.py里面没有__all__ printheat.docker.docker()
heat.docker This is a docker in heat This is a docker in heat
디렉터리의 모든 모듈 파일을 가져오려면 디렉터리의 __init__.py에 다음 내용을 추가할 수 있습니다.
__all__ = ['docker','nova'] #将所有模块名字写入
#!/usr/bin/env python #coding=utf-8 import heat.docker #目录下__init__.py里面没有__all__ print heat.docker.docker() from heat import * #heat目录下__init__里面内容是:__all__ = ['docker',nova'] print docker.docker() print nova.nova() n = nova.Nova() print n.test()
heat.docker This is a docker in heat This is a docker in heat This is a nova This is a test in nova
다음은 mod.py 파일 내용의 예입니다.
#!/usr/bin/env python
#coding=utf-8
def hello():
return'hello everyone'
class Hello(object):
def__init__(self):
self.a= 103
deftest(self):
return'This is a test in Hello'#!/usr/bin/env python #coding=utf-8 from heat.common import mod print mod.hello() h = mod.Hello() print h.test()
hello everyone This is a test in Hello
모든 모듈 파일이 필요하면 __init__.py 파일에 계속해서 작성하면 됩니다.
파일을 모듈로 가져올 때 .pyc 파일이 생성된다는 점에 유의해야 합니다. 모듈이 변경되면 .pyc 파일을 새로 고쳐야 하며, 그렇지 않으면 이전 정보를 계속 읽습니다. .
파일이 모듈로 사용되는 것을 방지하려면 파일에
을 추가해야 합니다.
if __name__ == '__main__'：
pass #这里是要执行的语句
这样就可以防止当文件是被用作模块使用时，不会被执行if下面的语句，如果是当做程序来执行时，则会执行下面的语句，一般用作测试。
本文出自 “ptallrights” 博客，请务必保留此出处http://ptallrights.blog.51cto.com/11151122/1793746
위 내용은 Python 학습 객체지향 프로그래밍 특성 (2)의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
