>Who are you to pass judgment on servants of anothers? It is before their own lord that they stand or fall. And they will be upheld, for the Lord is able to make them stand.
#å®å¶ç±»
ç±»æ¯å¯¹è±¡ï¼ç±»ä¹æ¯å¯¹è±¡ç±»åãå符串ãå表ãåå
¸çæ¯Pythonä¸å
ç½®ç对象类åï¼é¤æ¤ä¹å¤ï¼æä»¬å¯ä»¥ç¼åç±»ï¼èªå®ä¹å¯¹è±¡ç±»åã
##ç±»å对象类å
妿æ¶è³ä»æ¥ï¼ä½ è¿æ²¡æå
åç解类å对象类åçé®é¢ï¼å¯ä»¥åççå¦ä¸å
容ã
>>> class C1(object): pass #Python 3: class C1: pass
>>> class C2(object): pass #Python 3: class C2: pass
>>> a = C1()
>>> b = C2()
>>> type(a)
>>> type(b)
`type()`æ¯æä»¬å·²ç»ç¥æäºçå
å»ºå½æ°ï¼å®è¿åçæ¯å¯¹è±¡ç±»åã`a = C1()`ï¼æ¯å®ä¾åï¼å建äºä¸ä¸ªå®ä¾ï¼ä¹æ¯ä¸ä¸ªèµå¼è¯å¥ï¼å°åé`a`ä¸ç±»`C1()`建ç«äºå¼ç¨å
³ç³»ï¼è¿å°±å以å`a = 2`çæææ¯ä¸æ ·çãæä»¥ï¼æä»¬å¯ä»¥éè¿`type(a)`æ¥å¾å°å®ä¾æè
说æ¯è¿ä¸ªåéæå¼ç¨å¯¹è±¡çç±»åã
å¨Pythonä¸ï¼è¿æä¸ä¸ªå½æ°ï¼ä¸é¨æ¥å¤æä¸ä¸ªå¯¹è±¡æ¯ä¸æ¯å¦ä¸ä¸ªç»å®ç±»çå®ä¾ã
>>> help(isinstance)
Help on built-in function isinstance in module __builtin__:
isinstance(...)
isinstance(object, class-or-type-or-tuple) -> bool
Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object's type.
The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
isinstance(x, A) or isinstance(x, B) or ... (etc.).
è¿æ¯Python 2ä¸çå¸®å©ææ¡£ä¿¡æ¯ï¼Python 3ä¸çå
容ä¸ä¹ç±»ä¼¼ã
ä»`isinstance()`çååä¸å°±è½ç¥é宿¯å¹²ä»ä¹çã
ç¨å®å¯ä»¥å¤æä¸ä¸ªå¯¹è±¡æ¯å¦æ¯ä¸ä¸ªç±»æè
åç±»çå®ä¾ï¼å¦æç¬¬äºä¸ªåæ°æ¯ç±»åï¼ä¹å¯ä»¥å¤ææ¯å¦ä¸ºè¯¥ç±»åã
>>> isinstance(a, C1)
True
>>> isinstance(a, C2)
False
`a`æ¯ç±»`C1`çå®ä¾ï¼ä¸æ¯`C2` çå®ä¾ã类似æä½ï¼è¿å¯ä»¥è¿ä¹åï¼
>>> m = 1
>>> isinstance(m, int)
True
>>> isinstance(m, float)
False
ç¨ä»¥åçè¯è¯´ï¼`m`æå¼ç¨çå¯¹è±¡æ¯æ´æ°åï¼ç®è¯´æ`m`æ¯æ´æ°åã使¯ï¼å¦æä»`instance()`çæä½ä¸çï¼`m`å`a`æ¯çæçï¼ä½ å¯ä»¥è®¤ä¸º`a`æ¯C1ç±»åç对象ã
ç±æ¤ï¼æä»¬è¿ä¸æ¥çè§£äºç±»å°±æ¯ä¸ç§å¯¹è±¡ç±»åçã
##å®å¶ç±»
å¿
é¡»è¦å®å¶ç±»ï¼å 为è¿ä¸ªä¸çå¤ªå¤æã
å®å¶ç±»ï¼å°±è¦ç¨å°ç±»çç¹æ®æ¹æ³ï¼æ¯å¦åå§å彿°`__init__`ï¼è½ç¶ç¨éå¾ å¹¿æ³ï¼ä½ä»
ä»
ç¨å®è¿å«ä¸å¤ï¼è¿è¦ç¨å°å
¶å®çç¹æ®æ¹æ³ã
å¨Pythonç宿¹ç½ç«ä¸ï¼ä¸é¨æä»ç»[Special method names](https://docs.python.org/2/reference/datamodel.html#special-method-names)çç« èï¼è¯»è
å¯ä»¥å»ä»ç»é
è¯»ãææä¸ä¸ä¸ä»ç»ã
æ¬èä¸ï¼ä»
æ ¹æ®ä¾åä¸çé®é¢ï¼ä½¿ç¨æä¸ªç¹æ®æ¹æ³ã
#!/usr/bin/env python
class RoundFloat(object): #Python 3: class RoundFloat:
def __init__(self, val):
assert isinstance(val, float), "value must be a float."
self.value = round(val, 2)
def __str__(self):
return "{:.2f}".format(self.value)
__repr__ = __str__
if __name__ == "__main__":
r = RoundFloat(2.185)
print r #Python 3: print(r)
print type(r) #Python 3: print(type(r))
ä¸è¿°ç¨åºä¸çç±»`RoundFloat`çä½ç¨æ¯å®ä¹äºä¸ç§ä¸¤ä½å°æ°çæµ®ç¹æ°ç±»åï¼å©ç¨è¿ä¸ªç±»ï¼è½å¤å¾å°ä¸¤ä½å°æ°çæµ®ç¹æ°ã
å¨åå§å彿°ä¸`assert isinstance(val, float), "value must be a float."`æ¯å¯¹è¾å
¥çæ°æ®ç±»åè¿è¡å¤æï¼å¦æä¸æ¯æµ®ç¹æ°å°±ä¼æåºå¼å¸¸æç¤ºãå
³äº`assert`ï¼æè¨ï¼å¯ä»¥åçåç»å
容ã
æ¹æ³`__str__()`æ¯ä¸ä¸ªç¹æ®æ¹æ³ãå®ç°è¿ä¸ªæ¹æ³ï¼ç®çå°±æ¯è½å¤å¾å°æå°çå
容ãè¿éå°±æ¯å°åé¢åèäºå
¥ä¿çäºä¸¤ä½å°æ°çæµ®ç¹æ°ï¼ä»¥å°æ°ç¹åæä¸¤ä½å°æ°çå½¢å¼è¾åºã
`__repr__ = __str__` çå«ä¹æ¯å¨ç±»è¢«è°ç¨ï¼å³ååéæä¾`__str__()`éçå
容ã
æ§è¡ç¨åºï¼ç»ææ¯ï¼
2.19
妿æ¯`RoundFloat(2.185)`ï¼è¿åçç»ææ¯`2.00`ã
对æ¯çï¼`int(2.34)`å`RoundFloat(2.185)`å®å
¨çæï¼å³`int`æ¯å¯¹è±¡ç±»åï¼ä¹æ¯æ°æ®è½¬æ¢ç彿°ï¼`RoundFloat`å
·æåæ ·çåè½ã`RoundFloat`å°±æ¯æä»¬æ°å®ä¹ç对象类åã
仿ç
§ä¸é¢çåæ³ï¼æä»¬è¿å¯ä»¥å®å¶ä¸ä¸ªä¸é¨æ¾ç¤ºåæ°çç±»ã
å¦ä½ æç¥ï¼å¦æå¨Pythonä¸ç´æ¥è¾å
¥ç¶å¦3/2ï¼å®ä¸ä¼æ¯ä¸ä¸ªåæ°ï¼èæ¯æç
§é¤æ³è¿è¡å¤çãä½ï¼åæ°çæ¾ç¤ºå使ç¨ï¼æ¯æ¾èæè§çï¼Pythonçå
置对象类åä¸å没æåæ°ç±»åï¼ä¸ä»
Pythonï¼ç¸å½å¤çé«çº§è¯è¨é½æ²¡æï¼ãæä»¥ï¼æå¿
è¦èªå®ä¹ä¸ä¸ªç¸å
³çç±»åã
仿ç
§åé¢å®å¶ç±»çæ¹å¼ï¼ååºè¿æ ·ä¸æ®µä»£ç ã
#!/usr/bin/env python
#coding: utf-8
class Fraction(object): #Python 3: class Fraction:
def __init__(self, number, denom=1):
self.number = number
self.denom = denom
def __str__(self):
return str(self.number) + '/' + str(self.denom)
__repr__ = __str__
if __name__ == "__main__":
f = Fraction(2, 3)
print f #Python 3: print(f)
#output: 2/3
ç±»`Fraction`å°±æ¯èªå®ä¹çåæ°ç±»åãç±æ¤å¯è§ï¼èªå®ä¹ç±»æ¯ç¸å½éè¦åå¿
è¦çã
å¨è¿ä¸ªåºç¡ä¸ï¼ç»§ç»å°åæ°é®é¢æ·±å
¥ç ç©¶ââåæ°ç¸å ã`1/2 + 1/3 = 5/6`ï¼è®¡ç®è¿ç¨å¦ä¸ï¼
1. éåï¼å³åæ¯ä¸ºåæ¥ä¸¤ä¸ªåæ°ç忝çæå°å
¬åæ°ï¼å¾å°`3/6 + 2/6`ï¼
2. ååç¸å ï¼å¾å°ä¸è¿°ä¸¤ä¸ªåæ°çåã
è¿æ ·ï¼æä»¬å°é®é¢åè§£ï¼æ¾åºä¸ä¸ªå
³é®ï¼å°±æ¯âéåâï¼èéåçå
³é®æ¯æ¾åºä¸¤ä¸ªæ´æ°çæå°å
¬åæ°ã
å¦ä½æ¾æå°å
¬åæ°ï¼æ¥éª¤å¦ä¸ï¼
1. 计ç®ä¸¤ä¸ªæ°çæå¤§å
¬çº¦æ°ï¼å设aåbï¼æå¤§å
¬çº¦æ°ï¼greatest common divisorï¼ç¨gcd(a, b)表示ï¼
2. æå°å
¬åæ°åæå¤§å
¬çº¦æ°çå
³ç³»æ¯ï¼lcm(a, b) = |a * b| / gcd(a, b)ï¼lcm(a, b)表示è¿ä¸¤ä¸ªæ°çæå°å
¬åæ°ï¼lowest common multipleï¼ã
读è
ä¸å¦¨ä»æ°å®¡è§ä¸çªä¸è¿°é®é¢è§£å³çæè·¯ãåå§é®é¢æ¯è®¡ç®ä¸¤ä¸ªåæ°çå æ³ï¼ç¶åå°è¿ä¸ªé®é¢åè§£ï¼åå°åè§£ä¹åçé®é¢ååè§£ãæç»æä»¬è§£å³é®é¢çåºç³æ¯è®¡ç®æå¤§å
¬çº¦æ°ãåè¿æ ·è§£å³é®é¢çæ¹æ³ï¼æä»¬ç§°ä¹ä¸ºåæ²»æ³ï¼å³ä¸ä¸ªå¤æé®é¢ï¼å解为è¥å¹²ä¸ªç®åé®é¢ï¼ç¶åæç®åé®é¢ç»åèµ·æ¥ï¼å°±è§£å³äºé£ä¸ªå¤æé®é¢ââåèæ²»ä¹ã
åè§£å°æå°çé®é¢ï¼å°±å¯ä»¥ç¨ç¼å彿°çæ¹å¼è§£å³äºãæä»¥ï¼å
è®¡ç®æå¤§å
¬çº¦æ°åæå°å
¬åæ°ã
#!/usr/bin/env python
#coding: utf-8
def gcd(a, b): #æå¤§å
¬çº¦æ°
if not a > b:
a, b = b, a
while b != 0:
remainder = a % b
a, b = b, remainder
return a
def lcm(a, b): #æå°å
¬åæ°
return (a * b) / gcd(a,b)
if __name__ == "__main__":
print gcd(8, 20) #Python 3: print(gcd(8, 20))
print lcm(8, 20) #Python 3: print(lcm(8, 20))
#output:
#4
#40
妿¤ï¼å®æäºæå°å
¬åæ°ç计ç®ãç¶åï¼å¨åé¢å®å¶çåæ°ç±»çåºç¡ä¸ï¼å°±å¯ä»¥å¶ä½ä¸¤ä¸ªåæ°ç¸å ç计ç®äºã
#!/usr/bin/env python
#coding: utf-8
def gcd(a, b):
if not a > b:
a, b = b, a
while b != 0:
remainder = a % b
a, b = b, remainder
return a
def lcm(a, b):
return (a * b) / gcd(a,b)
class Fraction(object): #Python 3: class Frraction:
def __init__(self, number, denom=1):
self.number = number
self.denom = denom
def __str__(self):
return str(self.number) + '/' + str(self.denom)
__repr__ = __str__
def __add__(self, other):
lcm_num = lcm(self.denom, other.denom)
number_sum = (lcm_num / self.denom * self.number) + (lcm_num / other.denom * other.number)
return Fraction(number_sum, lcm_num)
if __name__ == "__main__":
m = Fraction(1, 3)
n = Fraction(1, 2)
s = m + n
print m,"+",n,"=",s
è¾ä¹ä»¥åï¼å¢å äºä¸ä¸ªç¹æ®æ¹æ³`__add__()`ï¼å®å°±æ¯å®ç°ç¸å çç¹æ®æ¹æ³ãå¨ç±»ä¸ï¼æè§å®äºå åä¹é¤çè¿ç®çç¹æ®æ¹æ³ã
å¨Pythonä¸ï¼å¦æè¦å®ç°æç§è¿ç®ï¼å¿
é¡»è¦æè¿ç®ç¬¦ï¼è¿æ¯æ¯«æ çé®å·²ç»å¾çæçäºã使¯ï¼è¿äºè¿ç®ç¬¦ä¹æä»¥è½å¤è¢«ä½¿ç¨ï¼é½æ¯å 为æä¸äºç¹æ®æ¹æ³æå¾ä»¥å®ç°çã以ä¸è¡¨æ ¼ä¸ååºå ç§å¸¸è§è¿ç®ç¬¦æå¯¹åºçç¹æ®æ¹æ³ï¼ä¾åèã
|äºå
è¿ç®ç¬¦ | ç¹æ®æ¹æ³|
|---------------------|-------------------|
| + | `__add__`, `__radd__` |
| - | `__sub__`, `__rsub__` |
| * | `__mul__` , `__rmul__` |
| / | `__div__` , `__rdiv__`, `__truediv__`, `__rtruediv__` |
| // | `__floordiv__`, `__rfloordiv__` |
| % | `__mod__`, `__rmod__` |
| ** | `__pow__`, `__rpow__` |
| << | `__lshift__`, `__rlshift__` |
| >> | ` __rshift__`, `__rrshift__` |
| & | `__and__`, `__rand__` |
| == | `__eq__` |
| !=,<> | `__ne__` |
| > | `__get__` |
| < | `__lt__` |
| >= | `__ge__` |
| <= | `__le__` |
以â+â为ä¾ï¼ä¸è®ºæ¯å®ç°`1 + 2`è¿æ¯`'abc' + 'xyz'`ï¼é½æ¯è¦æ§è¡`1.__add__(2)`æè
`'abc'.__add__('xyz')`æä½ãä¹å°±æ¯ä¸¤ä¸ªå¯¹è±¡æ¯å¦è½è¿è¡å æ³è¿ç®ï¼é¦å
å°±è¦çç¸åºç对象æ¯å¦æ`__add__()`æ¹æ³ï¼è¯»è
ä¸å¦¨å¨äº¤äºæ¨¡å¼ä¸ä½¿ç¨`dir()`ï¼çä¸çæ´æ°ãå符串æ¯å¦æ`__add__()`æ¹æ³ï¼ï¼ä¸æ¦ç¸åºç对象æ`__add__()`æ¹æ³ï¼å³ä½¿è¿ä¸ªå¯¹è±¡ä»æ°å¦ä¸ä¸å¯å ï¼æä»¬é½å¯ä»¥ç¨å æ³çå½¢å¼ï¼æ¥è¡¨è¾¾`obj.__add__()`æå®ä¹çæä½ãå¨Pythonä¸ï¼è¿ç®ç¬¦èµ·å°ç®å书åçåè½ï¼ä½å®ä¾é ç¹æ®æ¹æ³å®ç°ã
æä»¥ï¼å¨åæèªå®ä¹çç±»`Fraction`ä¸ï¼ä¸ºäºå®ç°åæ°å æ³ï¼æä»¬éåäº`__add__()`æ¹æ³ï¼ä¹å¯ä»¥ç§°ä¹ä¸ºè¿ç®ç¬¦éè½½ï¼å¯¹äºPythonæ¯å¦æ¯æéè½½ï¼ä¹æ¯ä¸ä¸ªäºè®ºè¯é¢ï¼ã
å°±è¿æ ·ï¼æä»¬è§£å³äºåæ°ç¸å çé®é¢ã
ä½ï¼ä¸è¿°å æ³è¿ä¸æ¯å¾å®ç¾ï¼è¿å¯ä»¥æå¾å¤ä¼åçå°æ¹ï¼æ¯å¦åæ°ç»æè¦åææç®åæ°ççãçæ£è¦å好ä¸ä¸ªåæ°è¿ç®çç±»ï¼è¿æå¾å¤å·¥ä½ã
ä¸è¿ï¼å¨Pythonä¸ï¼å
¶å®ä¸ç¨ä½ èªå·±åäºï¼èªç±é«æåå¥½ãæ ååºä¸å°±æç¸åºæ¨¡åè§£å³æ¤é®é¢ã
>>> from fractions import Fraction
>>> m, n = Fraction(1, 3), Fraction(1, 2)
>>> m + n
Fraction(5, 6)
>>> print m + n #Python 3: print(m + n)
5/6
>>> a, b = Fraction(1, 3), Fraction(1, 6)
>>> print a + b #Python 3: print(a + b)
1/2
Pythonçé
åä¹ä¸ï¼å°±æ¯å®å¼ºå¤§çæ ååºåç¬¬ä¸æ¹åºï¼è®©ä½ çå¿çåã
------
[æ»ç®å½](./index.md) | [ä¸èï¼å¤æåå°è£
](./211.md) | [ä¸èï¼é»éæ³](./240.md)
å¦æä½ è®¤ä¸ºæå¿
è¦æèµæï¼è¯·éè¿æ¯ä»å®ï¼**[email protected]**,ä¸èææ¿ã