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

一. 内置函数

1.@property(用于场景方法不要传递参数 且有return可以使用 就是普通函数)

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)

# 李四
# 执行了
# 李四

 @方法名.setter：被 @方法名.setter 装饰的函数装饰函数名字必须和方法名字相同

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)

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

# 删除
# 借助公用的方法 删除私有的属性
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)

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

# @方法名.setter：被 @方法名.setter 装饰的函数装饰函数名字必须和方法名字相同，方法名修改，会执行这个装饰的函数,
#coding=utf-8
# ############### 定义 ###############
class Goods:
    """python3中默认继承object类
        以python2、3执行此程序的结果不同，因为只有在python3中才有@xxx.setter  @xxx.deleter
    """
    def __init__(self,num):
        self.__num=num

    @property    #方法必须先进行@property
    def price(self):
        print(self.__num,"哈哈哈哈哈哈哈哈哈")

    @price.setter
    def price(self, value):  #函数名必须和方法相同
        self.__num=value

    @price.deleter
    def price(self):
        print('@price.deleter')

# ############### 调用 ###############
obj = Goods(22)
obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123  # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
obj.price
# del obj.price  # 自动执行 @price.deleter 修饰的 price 方法

# 22 哈哈哈哈哈哈哈哈哈
# 123 哈哈哈哈哈哈哈哈哈

2.@classmethod 

# @classmethod     至少有一个参数 cls   类名.方法名   
# 使用 场景  如果方法会使用到当前类  那么就可以使用类方法
class Gn(object):
   bar=11111
   def __init__(self,name,age):
       self.name=name
       self.age=age
   def aa(self):
       print(f'我叫--{self.name}--今年{self.age}')
       pass

   def cc(self):
        print("卧槽11111111111111111111111111111111111111")

   @classmethod
   def bb(cls):
       print("哈哈哈哈哈哈哈")
       print(cls.bar)
       print(cls)
ss=Gn("李四",5555)
ss.aa()

Gn.bb()     # 通过类来调用的方法    推荐使用
# ss.bb()     # 也可通过对象类调用的方法

# 我叫--李四--今年5555
# 哈哈哈哈哈哈哈
# 11111
# <class '__main__.Gn'>

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

class Gn(object):
   bar=11111
   def __init__(self,name,age):
       self.name=name
       self.age=age
   def aa(self):
       print(f'我叫--{self.name}--今年{self.age}')

   def cc(self):
        print("卧槽11111111111111111111111111111111111111")
   @classmethod
   def bb(cls,aa,bb):
       print("哈哈哈哈哈哈哈")
       print(cls.bar)
       print(cls)
       print(aa,bb)

ss=Gn("王五",666)
ss.aa()
Gn.bb("大象","业绩")     # 通过类来调用的方法    推荐使用
# ss.bb()     # 也可通过对象类调用的方法

# 我叫--王五--今年666
# 哈哈哈哈哈哈哈
# 11111
# <class '__main__.Gn'>
# 大象 业绩

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 

@staticmethod   静态方法使用场景     如果无需使用对象中封装的值 那么就可以使用该方法

# @staticmethod   静态方法使用场景     如果无需使用对象中封装的值 那么就可以使用该方法
class Fa(object):
    def __init__(self,name):
        self.name=name
    def aa(self):             # 这是实例化的方法  一个参数必须是self
        print(self.name)
    @staticmethod           #@staticmethod  这是个静态方法      可以不用传参数   参数也可有可无
    def run():
        print("我是静态方法---")

v=Fa("张三")
v.aa()
v.run()           #  静态的方法也可以 对象调用
Fa.run()           #  静态的方法也可以 类来调用   推荐这样调用
# 张三
# 我是静态方法---
# 我是静态方法---


print("****************************************************************************")
class Fa(object):
    def __init__(self,name):
        self.name=name
    def aa(self):             # 这是实例化的方法  一个参数必须是self
        print(self.name)
    @staticmethod           #@staticmethod  这是个静态方法      可以不用传参数   参数也可有可无
    def run(aa):
        print("我是静态方法---",aa)

v=Fa("李四")
v.aa()
v.run("啦啦啦啦啦啦啦")           #  静态的方法也可以 对象调用
Fa.run("哈哈哈哈哈哈哈")           #  静态的方法也可以 类来调用   推荐这样调用
# 李四
# 我是静态方法--- 啦啦啦啦啦啦啦
# 我是静态方法--- 哈哈哈哈哈哈哈

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都可以直接类名.方法名()来调用，那他们有什么区别呢