귀도 반 로섬 (Guido van Rossum) (귀도 반 로섬 (Guido van Rossum))의 파이썬 설립자. 1989 년 크리스마스 동안, 암스테르담의 귀도 반 로섬 (Guido van Rossum) 시간을 통과하기 위하여는, ABC와 같은 언어를 새 스크립트 인터프리터를 개발하기로 결정 상속하는 .Python 중 하나는 순수한 무료 소프트웨어, 소스 코드와 인터프리터 CPython과는 GPL에 따라입니다 (GNU 일반 공중 라이선스) 파이썬 :. 파이썬 옹호의 프로토콜 철학은 "우아한"는 "클리어", "단순", 파이썬은 가장 간단하고 우아하고 가장 확실한 방법은 문제를 해결합니다.
객체 지향 프로그래밍이 생각하는 새로운 방법을 제공, 소프트웨어 설계의 초점은 프로그램의 논리적 흐름하지만, 객체 지향 프로그래밍의 생각을 사용하여 소프트웨어 또는 프로그램 객체와 객체 사이의 관계, 더 이상, 소프트웨어 아키텍처, 소프트웨어 유지 보수 모듈 및 프레임 워크 및 구성 요소를 쉽게 재사용을 설계 할 수 잘.
파이썬 지원 객체 지향, 함수형 프로그래밍과 다른 프로그래밍 패러다임, 프로세스 중심의, 그리고 모든 프로그래밍 패러다임을 사용하는 우리에게 강요하지 않는, 우리는 작은 프로그램의 준비에 사용되는 절차 적 프로그래밍 절차, 기본적으로 문제가되지 않습니다 쓸 수 있습니다 하지만 중형 및 대형 프로젝트에 대한 객체 지향은 우리에게 많은 이점을 제공 할 것입니다. 다음은 객체 지향 기능 파이썬 구문 및 설명하는 객체 지향 프로그래밍의 기본 개념과 결합 될 것입니다.
객체 지향 프로그래밍 소개
객체 지향이 OOP英文全称(Object-Oriented Programming)있는 프로그래밍 아이디어, 객체 지향 기술은 소프트웨어 설계 및 객체 지향 프로그래밍 분야에서 기술 개발의 주류가되었다 고효율 프로그래밍 모드가되면, "클래스"와 "목적"달성하기 위해, 그래서 객체 지향 프로그래밍을 사용하여 사실, "클래스"및 "대상"클래스의 사용 템플릿은 템플릿이 복수의 방법 (함수)를 포함 할 수있는 방법의 다양한 기능을 달성 할 수있다, 객체는 예에 의해 생성 된 템플릿의 예 상기 방법은 각각의 오브젝트는 동일한 방법을 보유하고, 객체 클래스에서 수행 될 수 있지만, 각각의 데이터가 상이 할 수있다.
객체 지향 설계에있어서, 프로그래머가 설명 될 수있는 새로운 형태를 만들 수 있으며, 각 객체 데이터는 상기 클래스에 포함되는 상기 내부 구조의 복잡성을 숨기는 일부 객체 추상적이고 객체 클래스 변수를 달성 두 부분의 기능은 클래스 변수라는 数据成员함수가 클래스라고, 成员函数이 추상 클래스 목적 일이며, 객체가 엔티티 클래스의 인스턴스입니다.
간단하게, 속담, 모든 도로가 로마로 이어질 "객체 지향"는 프로그래밍 패러다임이며, 프로그래밍 패러다임 프로그래밍의 다른 프로그래밍 기능으로 요약된다 넣어 또한 우리가 마지막에 도달하기 위해 다른 방법을 사용할 수 있다고 말했다 목적으로하지만, 빠르고, 안전하고 효과적인 비교하는 몇 가지 방법은 몇 가지 방법은 비효율적이고 만족스럽지 못한 결과이다. 마찬가지로, 프로그래밍뿐만 아니라 문제를 해결하기 위해,하지만 전자를 서로 다른 관점과 다양한 아이디어를 가질 수있는 문제를 해결하기 위해 은 "패러다임"에 기인 일부가 보편적이고 효과적으로 프로그래밍 모드, 일반적인 프로그래밍 패러다임은 다음과 같습니다 :
● 프로세스 지향 프로그래밍 : OPP (는 프로그래밍 절차 지향)
● 객체 지향 프로그래밍 : OOP (객체는 프로그래밍 지향)의
● 기능 지향 프로그래밍 : FP (기능는 프로그래밍)
객체 지향 프로그래밍은 세 가지 목표를 가지고 : 재사용 성, 유연성, 확장 성, 그리고 몇 가지 주요 목표를 제공합니다 :
● 포장 닫기 구현 세부 사항 때문에, 코드 모듈의 코드 마스크 구현 정보만을 외부 인터페이스
● 상속 : 동일한 코드 기록의 복제 방지하기 위해 기존의 클래스 코드 재사용을 연장
● 다형성 : 다형성 인터페이스의 재사용을 달성하기 위해 이러한 상이한하다 클래스 간의 플렉시블 호출 복수
여기에, 우리는 당신이 이해하고 싶다면, 자신의 일부를 배울 수있는 설명서를 참조하십시오, 모든 것을 할 수 있고, 여기에 개인적으로는 위에 소개 된 기본 객체 지향 역할, 특성, 응용 프로그램 시나리오를 가지고에서 위의 발췌 대부분의 책에 초점을, 우리는에 초점을 封装,继承,多态핵심 객체 지향 개념을 설명한다 등.
객체 지향 -> 패키지
포장. 간단히 말해서 객체 지향하고, 객체 클래스의 개념의 주요 특징의 주요 특징 중 하나는 외부로 노출되는 논리 엔티티 데이터와 상기 데이터를 동작시키는 방법에있어서, 일부 데이터 및 방법을 캡슐화 클래스 블록 개별 인 구현 세부 사항은,뿐만 아니라, 내부 객체에서 데이터 나 방법은 개인이 될 수 있고, 이러한 개인 데이터 또는 방법은 외부 세계에 액세스 할 수 없습니다.이 방법으로, 내부 데이터의 목적은 서로 다른 수준을 제공 보호.
추상 클래스로 패키지 목적 일이며, 클래스가 데이터 및 방법은 클래스를 신뢰하거나 신뢰할 수없는 정보를 은폐 조작 개체 허용 넣을 수 있습니다 패키지, 캡슐화, 일반적으로 클래스에서 캡슐화 된 데이터를 통해 그리고 객체 또는 자체 수집, 그리고 다른 객체 지향 언어가 유사하지만 생성자에 의해 캡슐화 된 데이터에 대해, 그것은 의미, 우리는 몇 가지 기능을 함께 유사한 기능, 우리의 부르심과 유지 보수의 편리 성을 작성합니다.
◆ 간단한 클래스 패키지 ◆
파이썬에서, 클래스에 의해 정의 된 class关键字클래스 이름 뒤에 클래스 다음으로, 클래스 이름, 다음에 대문자로 단어의 시작 일반적으로 ()小括号, 당신은 괄호로 쓸 수는 (要继承的类名称)표시 아래 클래스에서, 방법이 있습니다 상속 클래스 두 사람은 父类(基类)일반적으로 클래스, 사용을 상속 할 수있는 권리없이 object类,이 모든 클래스가 클래스를 상속 최고입니다, 당신은 그 기본이로드, 쓰지 않는다, 쓸 수 없습니다.
>>> import sys
>>> import os
>>>
>>> class lyshark(object):
... def __init__(self,name,age,sex):
... self.name = name
... self.age = age
... self.sex = sex
...
>>>
>>> temp=lyshark("lyshark","22","Man")
>>> print("姓名:%s 年龄:%s 性别:%s"%(temp.name,temp.age,temp.sex))
姓名:lyshark 年龄:22 性别:Man이들은 a로 만든 lyshark위 클래스 __init__()는 클래스의 인스턴스가 초기화 처리라고 (또는 공법), 프로세스는 (이 형태의 함수이지만, 그러나 함수라는 클래스의 메소드 호출) 자동 실행 일부 초기화 작업은, 그래서 우리는 여기에 쓰기 __init__(self,name,age,sex)일부 초기화 작업을 수행하기 위해 할당 된 역할을 만들 때 이러한 속성을 설정 제공하는 것입니다.
매개 변수 간다
self흐름이있다.● 메모리의 함수 포인터에 해당 변수 이름 lyshark 향하는 개방 공간
이 먼저 수행되는 클래스를 인스턴스화 ●는__init__()자동으로 내부 변수로 매개 변수를 전송 한 후에 실행된다
자동 실행 ●__init__()시공 방법 메모리를 공간, 다음self.* = *같은 두 변수 데이터
실체화라고, 이상 코드가 표시하는 것을 목적으로 작성 temp=lyshark()이 문장한다 lyshark类취급 구별하기위한 핸들로 속성 및 객체의 메소드 : 오브젝트가 생성 될 때 세 특징 영역을 포함하고, 인스턴스화 다른 목적은, 오브젝트가 생성 될 때, 객체, 즉, 클래스 속성 및 개체에 대응하는 방법의 물체 식별 어드레스 저장 공간 멤버 변수와 멤버 함수를 저장 공간을 취득한다.
◆ 공용 속성 패키지 ◆
클래스 속성 및 메소드 조성물 클래스에게 데이터 패키지 특성 및 클래스 객체의 메소드 동작, 상기 한 기능 (예 법)에 의해 일반적으로 클래스 다음 사용 Public 속성 패키지 변수 (클래스 변수) 데이터 멤버는, 우리가 사용할 수있는 클래스 외부에서 볼 수있는 temp.name="xxoo"그 데이터가 변경되었다는 것을 발견, 인쇄 기능을 다시 호출 다음이 데이터 멤버의 값을 수정하는 방법과이 충분히 명확하게 안전하지 않습니다.
>>> import sys
>>> import os
# =====================以下内容是类的定义====================
>>> class lyshark():
... def __init__(self,name,age): #构造函数,初始化数据
... self.name = name #封装的数据成员
... self.age = age
...
... def my_print(self): #封装的成员函数
... print("我的名字是:%s 我的年龄是:%s"%(self.name,self.age))
...
# =========================================================
>>>
>>> temp=lyshark("wangrui","22") #类的实例化,将参数传入类中
>>> temp.my_print() #调用类中的指定方法,打印数据
我的名字是:wangrui 我的年龄是:22
>>>
>>> print(temp.name) #直接调用类中的数据成员
wangrui
# ===============改变数据成员,再次调用看看===================
>>> temp.name="xxoo"
>>> temp.my_print()
我的名字是:xxoo 我的年龄是:22
# =========================================================작은 요약 : 인스턴스가 실제로 및 추가 된 1. 공용 속성 또는 정적 특성은, 또한, 0.2 클래스의 인스턴스를 통해 공용 속성을 수정 예로서 클래스 직접 직접 액세스를 통해 직접 액세스 할 수 있습니다. 이 검색 0.3 다른 인스턴스의 공용 속성 값에 영향을주지 않도록 동일한 속성의 클래스 멤버의 공용 속성 이름, 실제 공공 재산은 영향을받지 않습니다. 카테고리 별 공용 속성을 수정, 확실히 대중의 변화 될 것입니다 속성의 원래 값, 그는 모든 인스턴스의 클래스가 영향을받는 것입니다.
◆ ◆ 개인 재산 패키지의 사용
위의 작은 예를 들어, 우리는 또한 몇 가지 결함이, 다음되는 기술 사유 재산, 개인 속성과 같은 속성의 구성원의 패키지를 살펴 걸릴 발견 __init__방법 선언을하지만, 속성 이름은 이중 밑줄해야 __开头, 사유 재산을 특별한 부재 속성만을 서브 (방법 부재 또는 개인 방법)에 의해 내부 상속 허용되지 않으며, 직접 외부 객체 인스턴스에 짧은 인스턴스 객체 또는 객체 클래스의 인스턴스를 통해 액세스하지 못하게하거나 문장 : 私有属性只有类的内部可以调用.
>>> import os
>>> import sys
# =====================以下内容是类的定义====================
class lyshark():
name = "lyshark" #定义公有属性(类变量,可共享数据)
__age = 22 #定义私有属性(类变量)
def __init__(self): #定义构造函数,初始化数据
self.__like = "soccer" #定义私有实例属性(实例变量)
self.hobby = "xxoo" #定义公有实例属性
def my_print(self): #定义公有函数,外部可以调用
print("我的名字: %s"%self.name)
print("我的年龄: %s"%self.__age)
print("我的爱好: %s"%self.__like)
print("其他: %s"%self.hobby)
def __new_test(self): #定义私有函数,只能内部类调用
print("hello world")
def __del__(self): #定义析构函数,清理数据
self.__nobody = "end"
#print("函数执行结束,销毁无用的数据. %s"%self.__nobody)
# =================(公有/私有)方法的调用====================
>>> temp=lyshark() #实例化对象
>>> temp.my_print() #调用类中方法(公有方法)
我的名字: lyshark
我的年龄: 22
我的爱好: soccer
其他: xxoo
>>> temp.__new_test() #调用私有方法,则会报错
# =================(公有/私有)属性的调用====================
>>> print(lyshark.name) #调用公有属性则成功
lyshark
>>> print(lyshark.__age) #调用私有属性,则会报错
>>> print(lyshark.__like)
# =========================================================작은 요약 : 함으로써 公有属性및 私有属性데이터의 비교, 우리는 분명히 그들 사이의 차이를 볼 수 있습니다, 그것은이 아래로 비등, 개인 변수가 클래스를 통해 직접 액세스 할 수 없습니다,이 개 private 변수는 개체 인스턴스, 3 직접 액세스 할 수 없습니다. 전용 변수는 방법 .4 클래스의 멤버 변수가 액세스 할 수는 일반적으로 두 인스턴스 사이에 공유하는 데이터를 위해 사용될 수 있고, 인스턴스 변수는 현재 인스턴스에 적용된다.
◆ 객체 클래스를 캡슐화 ◆
일부는 자주 위의 패키지에 추가로 사용하고, 더 어려운 패키지 형식을 이해하기 위해,이 다음은, 그것은 객체가 다른 클래스에 매개 변수로 클래스의 인스턴스을 의미한다 다른 클래스에서, 우리는 데이터 멤버와 멤버 함수는 클래스 친구 전달됩니다 액세스 할 수 호출 할 수 있습니다.
import os
import sys
class main(object):
def __init__(self,name,obj): #OBJ参数用来接收对象
self.name=name
self.obj=obj
class uuid(object):
def __init__(self,uid,age,sex):
self.uid=uid
self.age=age
self.sex=sex
temp=uuid(1001,22,"Man") #首先给UUID类初始化
lyshark=main("lyshark",temp) #将生成的TEMP对象传递给main
# =========================================================
>>> lyshark.name
'lyshark'
>>> lyshark.obj.uid #最后通过多级指针的方式访问数据
1001
>>> lyshark.obj.sex
'Man'
>>> lyshark.obj.age
22객체 지향 -> 상속
객체 지향 프로그래밍 (OOP) 언어의 주요 기능은 "상속", 상속은 기존의 클래스의 모든 기능을 사용하고 원래 클래스의 경우 이러한 기능을 확장 할 필요없이 다시 쓸 수있는 능력을 의미입니다 .
상속을 사용하거나 기존 클래스의 동작을 수정하는 것을 목표로 상속을 통해 새로운 클래스를 만들 수 있습니다, 중요한 객체 지향 기능 중 하나입니다, 원래의 클래스는 부모 클래스 또는 수퍼 클래스라고하며 새 클래스는 서브 클래스를 호출하거나 클래스를 파생 상속기구 코드를 재사용 할 때, 방법의 본질은 서브 모든 복사본의 상위 클래스로, 파이썬 상속을 통해, 다중 상속 내부 상속 할 수있다 상속 상위 클래스 함수 경우, 상속을 얻을 수있다 자신의 (하위 범주)를 찾기 위해 우선 순위를주고, 부모 클래스의 방법을 중복.
◆ ◆ 기본 클래스 일반 기능을 상속
다음은 기본적인 작은 예이며, 관계 상속 될 수 있으며, 첫 번째 base()기본 클래스이고, expand()유래의 파생 클래스 인 base()유도 열이 어떤 기능이없는 것처럼하지만 여전히 들어오는 인쇄하기의 printf () 함수를 호출 할 수있다 데이터, 그것은 기본 클래스의 기능이 내부 상속 설명 할 수있다.
import os
import sys
class base(): #这个类是基类
def __init__(self,name,age):
self.name = name
self.age = age
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
class expand(base): #新建类expand继承base基类的方法
pass
# =========================================================
>>> temp=expand("lyshark","22")
>>> temp.printf()
姓名:lyshark 年龄:22◆ ◆ 상속 된 기본 클래스 생성자
물론, 우리는 또한 부모의 생성자를 상속하고 해당 하위 카테고리에 새로운 속성 필드를 추가 할 수 있습니다, 당신은 또한 직접 할 수 super()라는 내부 서브 클래스의 부모 클래스에있는 몸의 직접적인 기능에 접근하고에 결과를 반환 호출자.
: 직접 생성자 확장 의 새로운 expand()서브 클래스, 상속 base()기본 클래스 생성자와 서브 클래스 속성 부모 클래스의 데이터를 인쇄 할 수 있습니다.
import os
import sys
class base():
def __init__(self,name,age):
self.name = name
self.age = age
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
class expand(base):
def __init__(self,name,age):
super(expand,self).__init__(name,age) #推荐使用本功能实现继承
#base.__init__(self,name,age) #此处和上面实现的功能相等
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
# =========================================================
>>> temp=base("lyshark","22")
>>> temp.printf()
姓名:lyshark 年龄:22
>>> temp=expand("lyshark","22")
>>> temp.printf()
姓名:lyshark 年龄:22새 필드 추가 : 부모 클래스 base()원래 필드의 재 작성에 기반을, 서브 클래스는 expand()새로운 필드를 추가 sex하고, 매개 변수를 전달 할 수 있습니다.
import os
import sys
class base(): #定义的父类
def __init__(self,name,age):
self.name = name
self.age = age
def printf(self):
print("姓名:%s 年龄:%s"%(self.name,self.age))
class expand(base): #定义的子类
def __init__(self,name,age,sex):
super(expand,self).__init__(name,age) #继承父类的属性
self.sex = sex #新添加的一个属性
def printf(self):
print("姓名:%s 年龄:%s 性别:%s "%(self.name,self.age,self.sex))
# =========================================================
>>> temp=base("lyshark","22") #原始基类,没有第三个字段
>>> temp.printf()
姓名:lyshark 年龄:22
>>> temp=expand("lyshark","22","Man") #在不影响父类情况下,重写新的字段
>>> temp.printf()
姓名:lyshark 年龄:22 性别:Man (필수) 부모 클래스의 함수에서 상속 : 당신이 하위 클래스에서 상위 클래스는, 다음과 같은 방법을 사용하여 구현 될 수있다시키는 방법을 사용합니다.
import os
import sys
class base(object):
def printf(self):
print("================================")
print("执行函数....")
print("================================")
return 0
class expand(base):
def fun(self):
ret=super(expand,self).printf() #强制调用父类中的printf方法
return ret #将结果返回给调用者
# =========================================================
>>> temp=base()
>>> temp.printf() #调用基类的方法
================================
执行函数....
================================
>>> obj=expand() #在子类中调用基类方法
>>> ret=obj.fun() #将返回值付给ret并打印
>>> print(ret)
================================
执行函数....
================================
0◆ 멀티 클래스 상속과 다중 상속 ◆
간단한 다중 상속 : 여기에서 우리는 우리가 실행, 고뇌의 순서의 코드를 설명하는 간단한 다중 상속을 구현, 아래 그림을 참조하십시오.
import os
import sys
class A:
def fun(self):
print("我是A类里面的函数")
class B:
def fun1(self):
print("我是B类里面的函数1")
def fun2(self):
print("我是B类里面的函数2")
class C(A,B):
def fun(self):
print("我是C类里面的函数")
# =========================================================
>>> temp=C()
>>> temp.fun() #默认调用C类,如果C里面有fun()函数则默认执行自身
我是C类里面的函数 #如果自身没有,才会去基类里面去找fun()函数的存在
>>> temp.fun1() #由于C类中没有这个方法,它会去B或A类里面去找
我是B类里面的函数1 #这也为我们重写函数提供了可能性,我们只需修改C类且名称相同即可实现重写복잡한 다중 상속 : 다음은, 다른 소스에서 너무 건조, 중요하고 어렵다은 그것을하지 않는 것이 좋습니다, 그리고 힘의 마지막 심지어 자신이 무지의 새로운 프로그램을 개발하고 중첩 된 경우 상속에 속한다.
import os
import sys
class A:
def bar(self):
print('bar')
self.f1()
class B(A):
def f1(self):
print('b')
class C():
def f1(self):
print('c')
class D(B):
def f1(self):
print('d')
class E(C,D):
pass
temp=D()
temp.bar()멀티 클래스 상속 (예) : 다중 상속, 우리는, 예로써 현재 다중 상속 시나리오, 우리는 다음과 같은 세 가지 범주가 있습니다 추가 할 것을 증명하는 것이 문제를 해결하는 방법입니다 Person(人类)부모 클래스로 사용, 두 개의 유도 만들 클래스, 하나가 Teacher(老师)다른 Student(学生)두 개의 클래스, 파생 된 두 클래스는 Person(人类), 모든 인간이 공통 속성을 가지고있다.
1. 우리는 먼저 기본 클래스를 만드는 Person()우리의 범위의 역사를 설명하기를, 물론 인간은 교사가 학생들이 있는지, 이름, 나이 등의 몇 가지 일반적인 속성이 있습니다.
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def walk(self):
print('%s is walking...' % self.name)
def talk(self):
print('%s is talking...' % self.name )2. 위의 기재에 기초하여 파생 클래스 Teacher, 서브 클래스, 속성 및 상위 클래스의 방법 중 몇몇을 사용한다.
class Teacher(Person):
def __init__(self, name, age, level, salary):
super(Teacher, self).__init__(name, age)
self.level = level
self.salary = salary
def teach(self):
print('%s is teaching...' % self.name)3. 마지막으로, 학생들의 클래스를 생성 Student, 공공 몇 가지 기본적인 속성과 메서드는 동등하게 부모입니다.
class Student(Person):
def __init__(self, name, age, class_):
Person.__init__(self, name, age)
self.class_ = class_
def study(self):
print('%s is studying...' % self.name)4. 최종적 개의 파라미터, 인쇄 결과를 확인 전달 직접 인스턴스화 것은 잘 이해된다.
>>> t1 = Teacher('张老师', 33, '高级教师', 20000)
>>> s1 = Student('小明', 13, '初一3班')
>>> t1.talk()
>>> t1.walk()
>>> t1.teach()
>>> s1.talk()
>>> s1.walk()
>>> s1.study()
张老师 is talking...
张老师 is walking...
张老师 is teaching...
小明 is talking...
小明 is walking...
小明 is studying...객체 지향 -> 다형성
다형성 (polymorphisn)는 서브 - 객체, 할당 한 후, 부모 개체가 현재 하위 개체의 특성에 따라 자신의 기술과 동일 할당 할 수있는 부모와 하나 이상이 될 수 있도록 설정 다른 방식으로 운영됩니다 다형성의 역할 : 우리는 코드가 상속이 코드 모듈을 기존, 자신의 목적을 달성하는 것입니다 확장 할 수있는 모듈 형 있도록 그 포장, 구현 세부 사항을 숨길 수 있습니다 알고 代码的重用다형성이 다른 목적을 달성하기 위해서이며, 그 동안, 接口的重用, 다형성의 역할은 클래스 상속에이고 어떤 한 문장에서 클래스의 인스턴스는, 인터페이스를 재사용 할 때 속성의 "가계도"의 사용 권리라는 것을 확인하는 시간을 산출했다.
import os
import sys
class Animal(object):
def __init__(self, name):
self.name = name
class Cat(Animal):
def talk(self):
print('%s: 喵喵喵!' %self.name)
class Dog(Animal):
def talk(self):
print('%s: 汪！汪！汪！' %self.name)
def func(obj): #这里制定一个接口,后期直接调用它
obj.talk()
# =========================================================
>>> c1 = Cat("catcat")
>>> d1 = Dog("dogdog")
>>> func(c1) #这里调用相同的方法,传入的数据不同
catcat: 喵喵喵!
>>> func(d1) #这里调用相同的方法,传入的数据不同
dogdog: 汪！汪！汪！객체 지향 -> 포장
위에서 언급 한, 너무, 일반적으로 클래스에 포장되어 있습니다 객체 지향 개념 数据(数据成员)의 운전 数据的方法(成员函数)이 두 가지가, 데이터 속성, 즉 카테고리의 프로토 타입으로 구성하고, 상술 한 속성은 여러 가지 분류를 통해보다 작은 아무것도 형성된다 公有属性/类变量, 成员属性/实例变量그리고 私有属性, 이러한 속성에 더하여, 방법은 이제 클래스가 다음과 같은 범주로 나누어 져, 수업 시간에 우리에게 말한다 :
● 구성원 방법 : 일반적으로, 예로서 그와 유사한 특성을 가진 회원이 객체 클래스에 액세스하는 프로세스의 첫 번째 구성원은 일반적으로 인수를 기록
self멤버 방법이다 나타 내기 위해,
이중 밑줄 : ● 개인 방법(__)부터 회원 방법은 개인 방법이며, 객체의 개인 인스턴스는 내부적으로 만 액세스 할 수 있으며, 서브 클래스에 의해 상속 될 수 없습니다 사유 재산과 유사
방법 ● 클래스 : 사용@classmethod클래스 메소드로 정의, 호출되는 클래스 메소드 방법의 회원을 장식하는 클래스 수있는 전용 액세스 변수가 아니라 인스턴스 변수는
정적 메소드를 ● : 사용하여@staticmethod정적 메소드를 호출하는 방법을 장식 회원, 정적 메서드는 클래스와 어떤 연관을 가지고 있고, 일반적으로 키트를 작성하는 데 사용하지 않는
● 등록 방법 : 방법이 될 수 있습니다 정적 속성, 그래서 당신은 멤버 속성으로이 액세스 방법을 방문 갈 수 있고, 할 수 없습니다에 의한()매개 변수 전달, 괄호
◆ ◆ 클래스 메소드
우리는 추가 할 경우 상기도 간단히 통상 멤버 함수 위에 설명한 @classmethod제 현재 클래스이어야 인수 및 요구 클래스 메소드 호출 멤버 메소드, 장식 公有属性/静态属性오브젝트가 될 수있다 예로서 제외하고 유사한 액세스에도 클래스 이름을 통해 직접적으로 액세스 할 수있는, 제 1 파라미터는 일반적 CLS로 기록 현재 클래스를 나타내고, 또이 클래스 메소드 만 공용 속성을 액세스 할 수 있고, 부재의 특성에 접근 할 수 없기 때문에 제, 주목해야한다 CLS 오히려 자기 인스턴스 오브젝트를 표시하지 않고, 현재 클래스의 전송 파라미터를 나타낸다.
import os
import sys
class lyshark(object):
name="wangrui" #赋值等待被调用
age="22"
sex="Man"
def __init__(self,x,y,z):
self.x=x
self.y=y
self.z=z
@classmethod #声明下方的函数为类方法
def printf(cls): #此函数只能调用类变量,而不能调用成员属性
print("姓名:%s 年龄:%s 性别:%s"%(cls.name,cls.age,cls.sex))
# =========================================================
>>> temp=lyshark("100","100")
>>> temp.printf()
姓名:wangrui 年龄:22 性别:Man우리는 인쇄 기능 호출 인스턴스 변수 이상의 변수를 수정하는 경우, 오류가 장식이 때문에 발생하지 classmethod존재 장식 코드를 마스크하는 경우, 당신은 성공을 호출 할 수 있지만, 전화는 더 이상 클래스 변수 데이터뿐만 인스턴스 변수의 데이터.
def __init__(self,x,y,z):
self.x=x
self.y=y
self.z=z
#@classmethod #此装饰器存在,不允许调用实例变量
def printf(self):
print("姓名:%s 年龄:%s 性别:%s"%(self.x,self.y,self.z))
# =========================================================
>>> temp=lyshark("lyshark","33","Man")
>>> temp.printf()
姓名:lyshark 年龄:22 性别:Man◆ ◆ 정적 메서드
상기 간략도 우리는 상기 부재의 기능에 추가하면, 일반적인 상황에서 것을 보여준다 @staticmethod장식하는 방법 부재 정적 메소드 호출 정적 메소드는 클래스의 함수이고, 고정 방법의 어떤 예는 주로 저장 로직에 사용되지 코드, 로직이 클래스에 속해 있지만, 고정 방법에서는 클래스 자체와 전혀 관계, 즉, 동작은 클래스의 특성 및 방법을 포함하지 않는다.이 이해 될 것이며, 고정 방법에 대해 독립적이며, 간단한 함수 그것은 단지 우리가 독점적 인 툴킷을 구현하는 데 사용할 수 있습니다 정상적인 상황에서 사용 및 유지 관리가 용이 클래스의 네임 스페이스를, 접대했다.
import os
import sys
class lyshark(object):
@staticmethod
def sum(x,y):
return x+y
@staticmethod
def sub(x,y):
return x-y
# =========================================================
>>> #temp=lyshark() #这里无需实例化
>>> text=lyshark.sum(10,20)
>>> print("两数之和:%s"%text)
两数之和:30
>>> text=lyshark.sub(100,50)
>>> print("两数之差:%s"%text)
两数之差:50다른 데이터를 우리가 Zenmo을 사용하지 않은 지금까지 개발이 기능을 클래스를 호출하므로 도구 상자는 그것의 가장 적절한 사용은 물론, 그것을 직접 할 수 없기 때문에 위, 작은 패키지의 전형적인 예입니다 너무.
◆ ◆ 등록 방법
속성은, 그가이 방법을 액세스 할 수 원하는대로 멤버 속성에 액세스 할 수 있습니다, 방법 정적 속성이 될 수 있으며, 수 없습니다로, 액세스 일부 기능 (기능)을 수행하는 특별한 재산이며 값을 반환 ()괄호, 전송 첫번째 파라미터이어야 파라미터는, 오브젝트의 현재의 예이고,이 방법은 리턴 값을 가져야한다.
import os
import sys
class lyshark(object):
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def foo(self):
return self.weight + self.height
# =========================================================
>>> temp=lyshark("wangrui",75,1.88)
>>> print(temp.foo) #此处我们直接调用这个属性,并没有传递参数
76.88위의 작은 예를 내부 함수 foo를 호출 할 때, 우리는 나중에 클래스의 예를 볼 수 있습니다, 그리고 성공 호출 보편적 접근의 원칙에 따라이 기능을 사용하여 여전히 괄호를 추가 할 수 있지만, 그 밖에 세부 사항을 차폐, 사용자에게 느낌을주고 그것을 사용하는 변수를 호출처럼 같은 클래스 변수라고합니다.
다음 코드를 보면, 삭제, 수정, 액세스 : 새 클래스는 세 가지 접근 방법을 가지고 있기 때문에, 우리는 동일한 속성에 정의 된 세 가지 방법에 대해 각각 그 특성의 여러 기능에 액세스 할 수 있습니다 :
import os
import sys
class lyshark(object):
@property
def get(self):
print("get 函数运行了我...")
@get.setter
def get(self,value):
print("set 设置参数运行了我,传递的参数是: %s"%value)
@get.deleter
def get(self):
print("工作结束了,可以删除数据了")
# =========================================================
>>> temp = lyshark() #实例化
>>> temp.get #调用get属性,则会执行get()函数
get 函数运行了我...
>>> temp.get = 'hello' #设置属性则会执行get.setter函数
set 设置参数运行了我,传递的参数是: hello
>>> del temp.get #删除工作,则会走get.deleter函数
工作结束了,可以删除数据了의 특정 예를 살펴 보자, 우리는 직접 호출 할 수있는 obj.price상품의 가격도 할당 문의 및 기타 상품 가격에 의해 수정 될 수 있습니다 얻을.
class Goods(object):
def __init__(self):
# 原价
self.original_price = 100
# 折扣
self.discount = 0.8
@property
def price(self):
# 实际价格 = 原价 * 折扣
new_price = self.original_price * self.discount
return new_price
@price.setter
def price(self, value):
self.original_price = value
@price.deltter
def price(self, value):
del self.original_price
# =========================================================
>>> obj = Goods()
>>> obj.price # 获取商品价格
>>> obj.price = 200 # 修改商品原价
>>> del obj.price # 删除商品原价