python基础笔记--构造函数的基础

最新推荐文章于 2023-06-25 02:28:31 发布

从没觉得自己胖z

最新推荐文章于 2023-06-25 02:28:31 发布

阅读量1k

点赞数

文章标签： python 构造函数

本文链接：https://blog.csdn.net/weixin_55435895/article/details/123807504

版权

自定义函数lambda

def clae(opt):
    if opt == '+':
        return lambda a, b :(a + b) 
    elif opt == '-':
        return lambda a ,b : (a - b)
    elif opt == '/':
        return lambda a , b :(a / b)
    elif  opt == '*':
        return lambda a ,b :(a * b)
    else:
        return 'nofund function model selection true again'
f1 = clae('+')
f2 = clae('-')
print(format(f2(2,3)))

这是一个计算器的简单设置

#face to object
#用面对对象的思想去做这个函数的思想方式，如何用类的对象进行函数分析
class Car:
    #类是对象的模板，创建出很多的模板出
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('这是init的函数区域')
        pass
    def __str__(self):
        return '%s 就是 %s'%(self.name,self.age)  #这个是当你创建一个实例对象之后，会生成的一范例
        pass
    def __new__(cls,*args,**kwargs):  #在这里真正创建对象实例的
        print('这是new的函数区域')
        return object.__new__(cls)
        pass
    pass
car = Car("faf",2)
print(car)    
#__new__ AND __init__区别，new是类的实例化方法，有return返回该实例，否则对象就创建不成功
#__init__用来做数据属性的初始化工作，也可以认为是实例的构造方法，接受类的实例，通过self对其进行构造  
#__new__函数执行要早于init函数

__init__这些都是魔术方法,__str__ 就是创建实例变量就会现实这个内容。

结果是，先从调用new的内容，然后再初始化属性。但是不加new也是可以的。

这是new的函数区域
这是init的函数区域
faf 就是 2

初始化内容，init里面存在有多种信息，可以直接存在列表里面，列表里面的每一个框都是一个实例。

class Dogs:
    def __init__(self,name,age,sex='male'):
        self.name = name
        self.age = age
        self.sex = sex
d1 = Dogs('qiu',1)
d2 = Dogs('fag',2)
d3 = Dogs(name='hfsdh',sex='female',age=2)
dog_number  =[d1,d2,d3]

还有可以创建cat 的类。创建内容不用传入所有的属性，比如，我创建cat，还可以设置一个speak的方法，加入属性noise，不过可以加入信息。

class Cat:
    def __init__(self,name,age,sex='female'):
        self.name = name
        self.age = age
        self.sex = sex
    def run(self):
        print('{0} is running '.format(self.name))
    def speak(self,noise):
        print('{0} is make noise {1}'.format(self.name,noise))
    def clas(self):
        print('{0} is a {1} cat'.format(self.name,self.sex))
cat = Cat('fafa',2)
cat.run()
cat.speak('jweguiwyeuhtgwhg')

经过使用del方法，def __del__可以直接删除当前内存里面的内容。

class Animal:
    def __init__(self,name):
        self.name  = name 
        pass
    def __str__(self):
        return ("这是构造初始化的方法")
    def __del__(self):
        print('这是一个构造方法')
        print('当程序后面没有调用该类的时候，自动调用该函数，释放空间')
        print('对象呗手动删除也会调用这个函数,释放完毕对象将不能再使用')
        pass
cat = Animal('小花猫')
print(cat)
del cat  #手动清理删除对象，会执行del函数
print(cat)

下面的print（cat)就无法显示实例。

私有属性：

#通过property的属性调用私有化的方法
class Person(object):
    def __init__(self):  
        self.__age = "34"   #定义一个私有化属性 
    def get_age(self):
        return self.__age
    def set_age(self,age):
        if age < 0:
            print('年龄不能小于0 ')
        else:
            self.__age = age
            pass
        pass
    age = property(get_age,set_age)
    age1 = property(get_age,set_age) #
    pass
p1 = Person()
print(p1.age)
p1.age = 25
print(p1.age)
print(p1.age1)

装饰器classmethod

class Account:
    interest_rate = 0.0568  #类变量
    def __init__(self,owner,amount):
        self.owner = owner
        self.amount = amount
        #类方法
    @classmethod 
    def interest_by(cls,amt):
        return cls.interest_rate * amt
    
account = Account('Tony ',80000.0)
Account.interest_rate
print('{0}'.format(Account.interest_rate))  #调用类变量要直接调用类名才可以，这样调用个体实例的方法来调用

interest = Account.interest_by(120000.0)
#print('account :{0:.4f}'.format(interest))

#使用属性
class Dog:
    def __init__(self,name,age,sex='female'):
        self.name = name
        self.__age = age  #私有变量
        #实例方法
    def run(self):
        print('{0}  is running '.format(self.name))
    #get 方法
    @property  #用装饰器添加属性装饰。提供一个getter的方法
    def age(self):  #替代 get_age  只读类型的
        return self.__age
    @age.setter  #s提供一个set的方法
    def age(self,age):  #替代set_age(self,age)  ,这是给私有程序变量赋值
        self.__age = age
dog = Dog('qiuqiu',2)
print('gougou nianling \n{0}'.format(dog.age))
dog.age = 3   #dog.set_age(3)
print('gougou nianling \n{0}'.format(dog.age))

class DataBaseClass(object):
    def __new__(cls, *args, **kwargs):
        #cls._instance = cls.__new__(cls)  不能使用自身的new方法，容易造成深度递归
        if not hasattr(cls,'_instance'):
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance
    pass

class DBoptSingle(DataBaseClass):
    pass
db1 = DBoptSingle()
print(id(db1))
db2 = DBoptSingle()
print(id(db2))
db3 = DBoptSingle()
print(id(db3))

class People:
    
    country = 'China'
    @classmethod
    def get_country(cls):
        return cls.country
        pass
    @classmethod
    def change_country(cls,data):
        cls.country = data
    pass
print(People.get_country())  #累对象可以调用类属性,在静态方法中不会涉及到
p = People()
print(p.get_country())  #实例对象也可以修改
People.change_country('Indian')
print(People.get_country())

#dewmo 返回当前的时间
class Time:
    def __init__(self,hour,miniter,second):
        self.hour = hour
        self.miniter = miniter
        self.second = second
    @staticmethod
    def showtime():
        return time.strftime('%H:%M:%S',time.localtime())
    pass
print(Time.showtime())
T = Time(4,52,6)
print(T.showtime())

#继承的方法
class Animal:  #这是可以定义为一个父类
    def __init__(self,name):
        self.name = name 
    def show_info(self):
        return 'anmial  name is {0}'.format(self.name)
    def move(self):
        print('dongyidong')
class Cat(Animal):  #在类的后面加上括号
    def __init__(self,name,age):
        super().__init__(name)  #super()调用父类的方法
        self.age = age  #实例变量age
cat = Cat("Tom",2)
cat.move()   #可以调用父类的行为，继承父类的感觉 
print(cat.show_info())
#子类独有的实现，互不干扰

class Baseline(object):
    def test(self):
        print('___________base line___________')
        pass
class Base(object):
    def test(self):
        print('-------base ---------------')
class A(Baseline):
    def test(self):
        print("a in")
        pass
class B(Baseline):
    def test(self):
        print("b in")
        pass
class A1(Base):
    def test(self):
        print("a in base")
        pass
class B1(Base):
    def test(self):
        print("b in base")
        pass
class C(A1,B1):
  #  def test(self):
     #   print("c in")
        pass
class D(A,B):
    def test(self):
        print("d in")
        pass
class E(C,D):
   # def test(self):
        #print("e in")
        pass
class F(C,D):
    def test(self):
        print("f in")
        pass

e = E()
print(e.test())
print(E.__mro__)

多继承的顺序

#多继承的规则
class Hours:
    def __init__(self,name):
        self.name  = name
    def show_info(self):
        return "the name {0} of hours".format(self.name)
    def run(self):
        print('the hourse is running again')
class Donkey:
    def __init__(self,name):
        self.name = name 
      #  self.age = age
    def roll(self):
        print('驴打滚')
    def show_info(self):
        return 'donkey name {0} is '.format(self.name)
    def run(self):
        print('donkey is running{0}'.format(self.name))
#class Mule(Hours,Donkey):
class Mule(Hours, Donkey):  #z这里的左右就是优先级，都存在相同方法的时候
#查找方法顺序的问题，顺序应该是查找方法的顺序应该是在a中查找，如果a中没有， 再去b类中查找A（b，c），然后再去同级的c类中查找
    def __init__(self,name,age1):
        self.age1 = age1
        super().__init__(name) #这个是自动找父类，然后调用方法
        #Hourse.__init__(self,name )
   #如果父类有的要继承，没有的需要自己加上
    def age(self):
        print('{0}faagagagag'.format(self.age1))
    def run(self):  #因为父类中已经存在这类的方法，相当于方法覆盖啦已经
        print('paode kuai ')
m = Mule('faagag',23)
m.run()
m.roll()
m.age()
print(m.show_info())  #如果是都有优先从上往下
#这里还有是有一些问题需要解答，关于如何将自己的数据选好，用更多的堕属性去赋值

class eat:
    def eatway(self):
        print('eat')
        pass
class GrandFather(eat):
    def eat1(self):
        print('chi de fangfa')
        pass
    pass
class Father(GrandFather):
    print("fag")
    pass
class Son(Father):
    print('son eat')
    pass
son = Son()
print(son.eatway())

#多态，有多种形式的表达方法,可以增加程序的灵活性，增加程序的扩展性两个特性，duck typing you'qi'lai
class Animal:
    def speak(obj):
        print('动物叫')
    def running(self):
        print("running animal")
class Dog(Animal):
    def speak(self):
        print('小狗开始叫啦')
    def running(self):
        print('dog is running ')
class Cat(Animal):
    def speak(self):
        print('小猫开始叫啦')
    def running(self):
        print('cat is running ')    
class Car:
    def speak(self):
        print("小汽车开始叫啦")
    def running(self):
        print('car is running ')
def star(obj):
    obj.speak()
def Invoke(objket):
    objket.running()
star(Car())
star(Dog())
star(Cat()) #意思是不调用父类也能调用这个方法
#循环 调用是speak函数
listObj = [Cat(),Dog(),Car()]
for item in listObj:
    Invoke(item)

#多种异常的处理方法
#将多种值的异常现象进行改变， 吧某些异常合并到一个except的字符串
#自定义异常
#codintg= utf -8
class ZhijieketangException(Exception):  #首先寻找错误需要先在这里填入Exception
    def __init__(self,message):
        super().__init__(message)
    def __str__(self):
        return 'the string about you print is too long pass by'
        pass
i= input('请输入数字：')
num = 8888
try:
    i2 = int(i)
    try:
        result = num / i2
        print('{0}除以{1}等于{2}'.format(num,i2,result))
    except ZeroDivisionError as e1:
        print('不能除以0，异常 \n{}'.format(e1))
        # raise ZhijieketangException('不能除以0')
except ValueError as e2:
    print('输入的数字无效，异常 \n{}'.format(e2))
   # raise ZhijieketangException('输入的值有误')

#对于变量再说，怎么进行动态绑定，这个需要好好学一下
class Student:
    def __init__(self,name,age):
        self.name = name 
        self.age = age
        pass
    def __str__(self):
        return '%s 今年 %s 岁啦'%(self.name,self.age)
    pass

zlh= Student('张刘华',23)
zlh.weight = 80  #等于我这里给zlh实例赋值一个体重变量是80
print(zlh.weight)
zm = Student('张敏',22)
Student.school = '北京理工大学'  #直接给类添加一个属性值，其他的调用变量就都可以使用这个属性 zm.school = 


#以下可以动态添加方法
import types #添加方法的库
def dymicMethod(self):
    print('{} 体重是{} 在{} 读书'.format(self.name,self.weight,Student.school))  #这就是在外部添加一个方法
zlh.printInfo= types.MethodType(dymicMethod,zlh)
zlh.printInfo()