Python ~~~ 面向对象的利器

 class Rectangle(): # 有没有括号都行 .
     def __init__(self,x,y):
         self.x=x
         self.y=y

     def getPeri(self):
         return (self.x+self.y)*

     def getArea(self):
         return self.x*self.y

 rect=Rectangle(,)

 print('这个长方形的周长是'+str(rect.getPeri()))

 print('这个长方形的面积是'+str(rect.getArea()))

 class A:
     def __init__(self):
         return 'A of A-Cup'

 a=A()

 # __init__ should return NONE not 'str'

 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
 这个长方形的周长是14
 这个长方形的面积是12
 Traceback (most recent call last):
   File "C:/Users/Administrator/Desktop/new.py", line , in <module>
     a=A()
 TypeError: __init__() should return None, not 'str'
 >>> 

尴尬的是  就看不懂下面的啥东西 ....(更加尴尬的是 , 看了看又会了 .)

 class CapStr(str):
     def __new__(cls,string):        # 在 一个对象实例化的时候 第一个被调用的方法 .
         string=string.upper()   #   她的第一个参数就是 , cls 也就是这个类.# new 需要返回一个实例对象
         return str.__new__(cls,string)
         #return super().__new__(cls,string) # 在将 传入的string 变为大写之后 让 str开始处理 . 并返回 这是一个很聪明的处理方法.

 a=CapStr('I Love FishC.Com')
 print(a)
 # 将  new重写  ,  将string 处理完毕之后 再调用原来的str的new
 #   在子类中重写某一方法的时候 希望父类的该方法不消失 , 那么就要使用 第四行或者第五行的方法了.

.

 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
 I LOVE FISHC.COM!
 >>> 

补充 .

 str1='jack'
 print(id(str1))
 str1='JACK'
 print(id(str1))
 print('------------不是一个地址的-----很明显不是同一个变量.---------')
 num=
 print(id(num))
 num+=
 print(id(num))

 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============

 ------------不是一个地址的-----很明显不是同一个变量.---------

 >>> 

析构函数 .

 >>> class C:
     def __init__(self):
         print('我是__init__方法,我被调用了 ...')
     def __del__(self):
         print('我是__del__方法 ,我被调用了 ...')

 >>> a=
 SyntaxError: invalid syntax
 >>>
 >>>
 >>> a=C()
 我是__init__方法,我被调用了 ...
 >>> b=a
 >>> def a
 SyntaxError: invalid syntax
 >>> del a
 >>> del b
 我是__del__方法 ,我被调用了 ...

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

class New_int(int):   # 定义一个新的类  继承 int 类
    def __add__(self,other):   # 重写 + 运算符 # __add__ 就是 int 中 +  的行为
        return int.__sub__(self,other)    # 重写的 加法运算符 调用 int类 里面的 减法运算运算符

    def __sub__(self,other):
        return int.__add__(self,other)

#   上面的是一个小小的恶作剧 . 把加法和减法的名称进行了互换.

 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
 >>> 5+6
 11
 >>> a=5
 >>> b=6
 >>> a+b
 11
 >>> c=New_int(7)
 >>> d=New_int(10)
 >>> c+d
 -3
 >>> a=New_int(a)
 >>> b=New_int(b)
 >>> a+b
 -1
 >>> # 由于没有初始化 int 类型的 等于运算符 所以只好  用 a=New_int()了 .

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

 #   下面这个程序 是用来 看看思维如何的 . 看你能不能找出问题 .

 class Try_int(int):
     def __add__(self,other):
         return self+other

     def __sub__(self,other):
         return self+other

 # 这里重载了 int类 的加法和减法 . 但是重载的时候 出了问题 . 没有给加法赋予正确的意义 .
 # 在这里只是说 +法 到时候调用加法 . 这样就形成了无穷的递归/

 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
 >>> a=5
 >>> b=6
 >>> a+b
 11
 >>> 5+6
 11
 >>> a=Try_int(5)
 >>> b=Try_int(6)
 >>> a+b
 Traceback (most recent call last):
   File "<pyshell#6>", line 1, in <module>
     a+b
   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
     return self+other
   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
     return self+other
   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
     return self+other

 .
 .
 .
 .
   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
     return self+other
   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
     return self+other
   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
     return self+other
 RecursionError: maximum recursion depth exceeded
 >>> 

至于上述 为什么 必须先将 一个变量用 自己定义个类先声明(a=New_int(5).....)一下呢?

这是因为在这里 + 有不同的意思 有的是int类的+,有的是你自己定义的类的 + . 当开始相加的时候 系统会根据变量的数据类型去掉用相应的加法 ,

这就是为什么要 这样做了(a=New_int(5).....)