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

一. 内置函数

[email protected]

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)

# 李四
# 执行了
# 李四

[email protected] 

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

[email protected] 

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

原文地址：https://www.cnblogs.com/Sup-to/p/10884275.html

时间： 2024-11-08 02:56:46

六. python面向对象(内置函数)的相关文章

python D13 内置函数

# 1.内置函数# 什么是内置函数? 就是python给你提供的. 拿来直接?的函数, 比如print., input等等. 截?# 到python版本3.6.2 python?共提供了68个内置函数. 他们就是python直接提供给我们的. 有# ?些我们已经?过了. 有?些还没有?过. 还有?些需要学完了?向对象才能继续学习的. 今# 天我们就认识?下python的内置函数. # 不熟悉的函数:# eval() 执?字符串类型的代码. 并返回最终结果# print(eval("2+2&quo

Python 常用内置函数

abs 取绝对值 print(abs(-1)) #结果1 all(...) all(iterable) -> bool Return True if bool(x) is True for all values x in the iterable. If the iterable is empty, return True. 如果iterable的所有元素不为0.''.False或者iterable为空,all(iterable)返回True,否则返回False:函数等价于: 1 def all

Python 集合内置函数大全（非常全！）

Python集合内置函数操作大全 集合(s).方法名 等价符号 方法说明 s.issubset(t) s <= t 子集测试(允许不严格意义上的子集):s 中所有的元素都是 t 的成员   s < t 子集测试(严格意义上):s != t 而且 s 中所有的元素都是 t 的成员 s.issuperset(t) s >= t 超集测试(允许不严格意义上的超集):t 中所有的元素都是 s 的成员   s > t 超集测试(严格意义上):s != t 而且 t 中所有的元素都是 s 的成

python常用内置函数学习（持续更新...）

python常用内置函数学习 一.python常用内置函数有哪些 dir() 二.每个内置函数的作用及具体使用 1.dir()不带参数时返回当前范围内(全局.局部)的变量.方法和定义的类型列表:   带参数A时返回参数的属性.方法的列表,如何该参数A对象有__dir__(),该方法被调用,如果不含有该方法,该方法不会报错,而是尽可能多的收集参数对象A的信息   实例: 不带参数,在分别在文件全局调用和在函数中局部调用dir()   带参数   原文地址:https://www.cnblogs.c

Python小白学习之路（十六）—【内置函数一】

将68个内置函数按照其功能分为了10类,分别是: 数学运算(7个) abs()   divmod()  max()  min()  pow()  round()  sum() 类型转换(24个) bool()  int()  float()  complex()  str()  bytearray() bytes() memoryview() ord() chr() bin() oct() hex() tuple() list() dict() set() frozenset( ) enumer

Python入门-内置函数二

看到标题你也能猜到今天要说大概内容是什么了,没错,昨天没有说完的部分再给大家说说(有一些重合的部分),内置函数的内容比较多,并且工作中经常用到的却不太多,很多都是不太常用的,所以我就着重说一些比较常用的,今天再说两个函数:匿名函数和递归函数.还有就是二分法查找 首先来说一下匿名函数,因为几个比较重要的内置函数都要和匿名函数搭配来用 一.匿名函数 为了解决一些简单的需求而设计的一句话函数 # 计算n的n次方 def func(n): return n**n print(func(10)) f =

Python基础——内置函数

课前梗概 学到这里,大家是不是在想一个问题,我们之前一直用到的简单语法中会有,iut(),print(),len(),input()…………等等,你们是否想过,我们在使用之前没有做什么定义操作而是自然而然用到了,非常自然,这到底是什么情况?它们到底是什么东西呢? 其实,这些函数都是一个名为 builtins模块已经封装定义好的函数,而且这个模块在安装python环境的时候就默认导入了,所以我们可以直接使用. 这些函数,在python我们也称之为“内置函数”. 内置函数 在python的3.6.2

Python菜鸟之路一：Python基础-内置函数补充

常用内置函数及用法: 1. callable() def callable(i_e_, some_kind_of_function): # real signature unknown; restored from __doc__ """检查对象object是否可调用.如果返回True,object仍然可能调用失败:但如果返回False,调用对象ojbect绝对不会成功 Return whether the object is callable (i.e., some kin

【Python】内置函数清单

Python内置(built-in)函数随着python解释器的运行而创建.在Python的程序中,你可以随时调用这些函数,不需要定义.最常见的内置函数是: print("Hello World!") 在Python教程中,我们已经提到下面一些内置函数: 基本数据类型 type() 反过头来看看 dir() help() len() 词典 len() 文本文件的输入输出 open() 循环设计 range() enumerate() zip() 循环对象 iter() 函数对象 map