zoukankan      html  css  js  c++  java
  • Python ~~~ 面向对象的利器

     1 class Rectangle(): # 有没有括号都行 .
     2     def __init__(self,x,y):
     3         self.x=x
     4         self.y=y
     5 
     6     def getPeri(self):
     7         return (self.x+self.y)*2
     8 
     9     def getArea(self):
    10         return self.x*self.y
    11 
    12 rect=Rectangle(3,4)
    13 
    14 print('这个长方形的周长是'+str(rect.getPeri()))
    15 
    16 print('这个长方形的面积是'+str(rect.getArea()))
    17 
    18 class A:
    19     def __init__(self):
    20         return 'A of A-Cup'
    21 
    22 a=A()
    23 
    24 # __init__ should return NONE not 'str'
    1 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
    2 这个长方形的周长是14
    3 这个长方形的面积是12
    4 Traceback (most recent call last):
    5   File "C:/Users/Administrator/Desktop/new.py", line 22, in <module>
    6     a=A()
    7 TypeError: __init__() should return None, not 'str'
    8 >>> 

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

     1 class CapStr(str):
     2     def __new__(cls,string):        # 在 一个对象实例化的时候 第一个被调用的方法 . 
     3         string=string.upper()   #   她的第一个参数就是 , cls 也就是这个类.# new 需要返回一个实例对象 
     4         return str.__new__(cls,string)
     5         #return super().__new__(cls,string) # 在将 传入的string 变为大写之后 让 str开始处理 . 并返回 这是一个很聪明的处理方法.
     6 
     7 a=CapStr('I Love FishC.Com')
     8 print(a)
     9 # 将  new重写  ,  将string 处理完毕之后 再调用原来的str的new
    10 #   在子类中重写某一方法的时候 希望父类的该方法不消失 , 那么就要使用 第四行或者第五行的方法了.

     

     

    .

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

    补充 . 

    1 str1='jack'
    2 print(id(str1))
    3 str1='JACK'
    4 print(id(str1))
    5 print('------------不是一个地址的-----很明显不是同一个变量.---------')
    6 num=3
    7 print(id(num))
    8 num+=5
    9 print(id(num))
    1 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
    2 48404992
    3 48405152
    4 ------------不是一个地址的-----很明显不是同一个变量.---------
    5 1522030896
    6 1522030976
    7 >>> 

    析构函数 . 

     1 >>> class C:
     2     def __init__(self):
     3         print('我是__init__方法,我被调用了 ...')
     4     def __del__(self):
     5         print('我是__del__方法 ,我被调用了 ...')
     6 
     7 >>> a=
     8 SyntaxError: invalid syntax
     9 >>> 
    10 >>> 
    11 >>> a=C()
    12 我是__init__方法,我被调用了 ...
    13 >>> b=a
    14 >>> def a
    15 SyntaxError: invalid syntax
    16 >>> del a
    17 >>> del b
    18 我是__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)
    
    
    #   上面的是一个小小的恶作剧 . 把加法和减法的名称进行了互换.
    
     1 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
     2 >>> 5+6
     3 11
     4 >>> a=5
     5 >>> b=6
     6 >>> a+b
     7 11
     8 >>> c=New_int(7)
     9 >>> d=New_int(10)
    10 >>> c+d
    11 -3
    12 >>> a=New_int(a)
    13 >>> b=New_int(b)
    14 >>> a+b
    15 -1
    16 >>> # 由于没有初始化 int 类型的 等于运算符 所以只好  用 a=New_int()了 .

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

     1 #   下面这个程序 是用来 看看思维如何的 . 看你能不能找出问题 .
     2 
     3 
     4 class Try_int(int):
     5     def __add__(self,other):
     6         return self+other
     7 
     8     def __sub__(self,other):
     9         return self+other
    10 
    11 # 这里重载了 int类 的加法和减法 . 但是重载的时候 出了问题 . 没有给加法赋予正确的意义 .
    12 # 在这里只是说 +法 到时候调用加法 . 这样就形成了无穷的递归/
     1 =============== RESTART: C:/Users/Administrator/Desktop/new.py ===============
     2 >>> a=5
     3 >>> b=6
     4 >>> a+b
     5 11
     6 >>> 5+6
     7 11
     8 >>> a=Try_int(5)
     9 >>> b=Try_int(6)
    10 >>> a+b
    11 Traceback (most recent call last):
    12   File "<pyshell#6>", line 1, in <module>
    13     a+b
    14   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
    15     return self+other
    16   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
    17     return self+other
    18   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
    19     return self+other
    20 
    21 .
    22 .
    23 .
    24 .
    25   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
    26     return self+other
    27   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
    28     return self+other
    29   File "C:/Users/Administrator/Desktop/new.py", line 16, in __add__
    30     return self+other
    31 RecursionError: maximum recursion depth exceeded
    32 >>> 

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

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

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

  • 相关阅读:
    浏览器渲染机制
    isEmpty 和 isBlank 的用法区别
    Mybatis-plus
    Java8的JVM内存结构
    【面试题】关于线程交替的面试题
    java中的final的作用
    线程池
    六种实现单例模式的方法
    SQL优化常用方法
    HTML学习笔记
  • 原文地址:https://www.cnblogs.com/A-FM/p/5677288.html
Copyright © 2011-2022 走看看