六. python面向对象(内置函数)

一. 内置函数

1.@property

property 内置装饰器函数 只在面向对象中使用   函数的作用是在新式类中返回属性值。

from  math import pi
print(pi)

class Circle:
  def __init__(self,r):
      self.r=r

  def per(self):  # 周长
      return 2*pi*self.r

  def aer(self): # 面积
      return self.r**2*pi
aa=Circle(3)
print(aa.per())
print(aa.aer())

from  math import pi
# property() 函数的作用是在新式类中返回属性值。  把方法伪装成属性了
class Circle:
    def __init__(self, r):
        self.r = r

    @property                           # @property 把方法伪装成属性了
    def per(self):  # 周长               使用  @property  伪装成属性 不能单参数
        return 2 * pi * self.r

    @property
    def aer(self):  # 面积
        return self.r ** 2 * pi
aa = Circle(3)
print(aa.per)              # @property 把方法伪装成属性了  调用了  但是不能 传递任何参数
print(aa.aer)

class Person(object):
    def __init__(self,name,high,weight):
        self.name=name
        self.high=high
        self.weight=weight

    @property
    def bim(self):
        return  self.weight/self.high**2

cc=Person("李四",1.7,100)
# print(cc.bim())
print(cc.bim)                      #  @property 把方法变成了属性来调用

class Pers(object):
    def __init__(self,name):
         self.__name=name
    @property                      #  有了@property  里面的方法名可以一样
    def aa(self):
        return  self.__name+'----sb啊哈哈哈哈哈'

    @aa.setter             #       @aa.setter  修改
    def aa(self,new_name):
           self.__name = new_name

f=Pers("王五")

print(f.aa)     #  使用@property  修改里面的方
f.aa='爸爸'
print(f.aa)
# 王五----sb啊哈哈哈哈哈
# 爸爸----sb啊哈哈哈哈哈

print("*********************************************8")

class Persa(object):
    def __init__(self,name):
        self.__name=name
        
    @property
    def name(self):
        return  self.__name+'-------sb哈哈哈哈哈'
    
    @name.setter      #           @property把方法变成属性方法访问              对象的修改    @name.setter    注意这三个nane要相同
    def name(self,new_name):
        self.__name=new_name
d=Persa("李四")
print(d.name)
d.name='王五'
print(d.name)
# 李四-------sb哈哈哈哈哈
# 王五-------sb哈哈哈哈哈

案例


print("# 案例使用1")
class Goo(object):
    dazhe=0.5
    def __init__(self,name,price):
        self.name=name
        self.__price=price
    def pr(self):
        return self.__price*Goo.dazhe
a=Goo("西瓜",8)
print(a.pr())
# 案例使用1
# 4.0

print("***************************************************88")

print("# 案例使用2")
class Goo(object):
    dazhe=0.5
    def __init__(self,name,price):
        self.name=name
        self.__price=price
    @property
    def pr(self):
        return self.__price*Goo.dazhe
a=Goo("西瓜",8)
print(a.pr)

# # 案例使用2
# 4.0

class Pe(object):
    def __init__(self,name):
        self.__name=name

    @property
    def name(self):
        return  self.__name

    @name.deleter
    def name(self):
        print("执行了")
        # del self.__name
d=Pe("李四")

print(d.name)
del d.name
print(d.name)

# 李四
# 执行了
# 李四

2.@classmethod 

class Room(object):
    name1 = "张无忌来了哈哈"
    def __init__(self, name, owner, width, length, height):
        self.name = name
        self.owner = owner
        self.width = width
        self.length = length
        self.height = height

    def cal_self(self):
        # print('%s 住 的 面-%s总的面积是--------%s'%(self.owner,self.name,self.width*self.length))
        return self.width * self.length

    def test(self, name):
        print("来自", self.name)

    def test_call(self):
        print("我是------", self.name1)

print(Room.name1)  # 张无忌来了哈哈

# Room.test("中国")
# 这个表示类和实例化参数绑定到一块了
a2 = Room("别墅111", "哈哈哈哈哈", 2200, 100, 1000000000)
Room.test_call(a2)

# 张无忌来了哈哈
# 我是------ 张无忌来了哈哈

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

# func2
# 1
# foo

class Da(object):
    cc="188888"
    def __init__(self,name):
        self.name=name
    @classmethod
    def aa(cls,ll):
        print("反射!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11")
        print(cls.cc)
        print(ll)

f=Da("张三")
Da.aa(20)

# 反射!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11
# 188888
# 20

# 而@classmethod因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。
# @classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
class Goo(object):
    __dazhe=0.5
    def __init__(self,name,price):
        self.name=name
        self.__price=price

    @property
    def pr(self):
        return self.__price*Goo.__dazhe

    @classmethod   # 把一个方法变成一个类中的方法 这个方法直接可以被调用 不需要依托任何对象   意思就是不实例化对象 还可以操作
    def change_dazhe(cls,new_dazhe):      #  修改打折价钱
           cls.__dazhe=new_dazhe
           print(cls.__dazhe,"打折")
           print(new_dazhe)
a=Goo("西瓜",6)
print(a.pr)
Goo.change_dazhe(0.2)
print(a.pr)

# 3.0
# 0.2 打折
# 0.2
# 1.2000000000000002

# 当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法
# 类方法有一个默认参数 cls 代表这个类

# 只执行类的方法 不跟任何实例化捆邦    只跟类捆绑这个叫类方法     用@classmethod

""" 描述
       classmethod 修饰符对应的函数不需要实例化，不需要 self 参数
       ，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等    """     

       # @classmethod 这表示只供类使用的方法  
class Room(object):

       name1="张无忌来了哈哈"
    
       def __init__(self,name,owner,width,length,height):
             self.name=name
             self.owner=owner
             self.width=width
             self.length=length
             self.height=height 

       def cal_self(self):
              # print('%s 住 的 面-%s总的面积是--------%s'%(self.owner,self.name,self.width*self.length))

              return self.width*self.length

     
       def  test(self,name):
            print("来自",self.name)

  
       @classmethod
       def test_call(cls,aa,bb):     #  cls 这个参数表示接受的是一个类名
            print(cls)
            print("我是------",cls.name1,aa,bb)  #  用类调用类的属性     相当于: Room.name1


# 用类执行方法
print(Room.name1)

Room.test_call(10000000,66666666)


# <class '__main__.Room'>
# 我是------ 张无忌来了哈哈 10000000 66666666

3.@staticmethod 

python staticmethod 返回函数的静态方法。

class C(object):
    @staticmethod
    def f():
        print('runoob');

C.f();  # 静态方法无需实例化


cobj = C() # 也可以实例化后调用
cobj.f()

# runoob
# runoob

class Login(object):
    def __init__(self,name,pwd):
        self.name=name
        self.pwd=pwd

    def log(self):
          print("登陆了啊哈哈哈啊哈哈")


    @staticmethod
    def get_massage():
        user=input("用户:")
        pwd = input("密码:")
        Login(user,pwd)
        print("1111111111111")


Login.get_massage()# 如果一个函数 既和对象没有关系 也和类没有关系 那么就用   @staticmethod 将这个函数变成一个静态方法关联起来

aa=Login("aa",1)
aa.get_massage()
# 注意静态方法啊没有默认参

 @staticmethod   @ classmethod   @property

# 只执行类的方法 不跟任何实例化捆邦    只跟类捆绑这个叫类方法     用@classmethod

""" 描述
       classmethod 修饰符对应的函数不需要实例化，不需要 self 参数
       ，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等    """
# @classmethod 这表示只供类使用的方法
class Room(object):
    name1 = "张无忌来了哈哈"

    def __init__(self, name, owner, width):
        self.name = name
        self.owner = owner
        self.width = width
    @property
    def ger(self):
        print("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")

    def test(self, name):
        print("来自", self.name1,"11111111111-------",name)

    @classmethod
    def test_call(cls, aa, bb):  # cls 这个参数表示接受的是一个类名
        print(cls)
        print("我是------", cls.name1, aa, bb)  # 用类调用类的属性     相当于: Room.name1

    @staticmethod
    def call(a, b, c):
        print("正在吃饭-----------", a, b, c)

Room.call("张三", "年龄", "255")
print("*****************11********************")
Room.test_call(888,9999)
print("******************22*******************")

aa=Room("李四",88888,000000)
print("******************33*******************")
aa.test("哈哈哈")
print("******************44*******************")
# @property
aa.ger


# 正在吃饭----------- 张三 年龄 255
# *****************11********************
# <class '__main__.Room'>
# 我是------ 张无忌来了哈哈 888 9999
# ******************22*******************
# ******************33*******************
# 来自 张无忌来了哈哈 11111111111------- 哈哈哈
# ******************44*******************
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#



# @staticmethod 静态方法是名义上的归属管理，不能使用变量和实例化变量 是类工具包

# 一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。 
# 而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。 
# 这有利于组织代码，把某些应该属于某个类的函数给放到那个类里去，同时有利于命名空间的整洁。
# 既然@staticmethod和@classmethod都可以直接类名.方法名()来调用，那他们有什么区别呢