Python_object_oriented

“”"
语法：
class 类名：
def init(self,参数):
self.数据 =参数

“”"
面向对象 ----> 的函数叫做方法
面向过程-----> 的函数叫做函数

变量 = 类名(参数) #标准#构造函数

---

习题
1.定义函数，将列表中奇数设置为1
2. 定义函数，将列表中奇数删除
测试数据：[3,4,5,6,7,8,9,13]
结论; 在 列表中删除多个元素，倒序删除

解答
1.

def change_all_by_odd(list01):
                for i in range(len(list_target)):
                       if list_target[i] %2:
                           list_target[i] =1    

 2. 

def delete_all_by_odd(list01):
                for i in range(len(list_target)-1,-1,-1):   #range(start:int ,stop:int, set:int)  开始，结束，步长
                       if list_target[i] %2:
                            del list_target[i]    

   list01 = [3,4,5,6,7,8,9,13] 
   change_all_by_odd(list01)
   list01 = [3,4,5,6,7,8,9,13] 
   delete_all_by_odd(list01)       

 错误解答. def delete_all_by_odd(list01):
                     for i in range(len(list_target)):
                          if list_target[i] %2:
                            del list_target[i]    
     **问题1.**：出现漏删--后面的元素向前挤，
           **2.  越界** --删除元素列表长度减少  

根据条件在容器中删除多个元素。。倒序删 如果删除一个可以随便删

---

实例变量 (实例方法)
1.语法
(1)定义：对象.变量名
(2)调用: 对象.变量名

    **例：**

```python
 a= 11                   #全局变量，存储在文件中----------------------
 class Wife：
         total_account = 10   #类变量 存储在类中---------------------
         
         @classmethod   #有类变量是可以使用类方法
         def print_total_account(cls):
               print(...)   
         def __init__(self,name):
                a=1          
                self.name = name       #实例变量:存储在对象中------------
                Wife.total_account -=a
         def work(self):
                b= 1          #局部变量  存储在栈帧中 ---------------------
                print(self.name +"工作")  #可以使用自身实例的对象


w01 = Wife("双儿")  # 首次是创建实例  再次是修改实例
w01.__dict__    #存储了对象所有的实例变量   显示为{"name":"双儿"}
w01.work()     #自动传递对象地址work(w01) 
 Wife.work(w01)  #手动传递对象地址 类名.方法名(对象地址)

             
生成代码的快捷键   ---alt+enter
----------------------------------------------------------------------------------------
**类 (方法) 操作类变量**
      类成员 
              类变量
                    创建：在类中
                    使用：类名.类变量
               
              有类变量一般使用类方法 
                   例：
                        @classmethod               #类变量方法
                        def print_total_account(cls):
                                  print(...)  

 
------------------------------------------------------------------------------------------
**封装行为**  
             对外限制行为  
             需求：类的定义者
                      **property**属性 
                                  价值：保护实例变量
                                        1. 属性名与实例变量名称相同(拦截)
                                        2.属性中操作私有变量(需要被保护)
                                  核心：拦截
             例 ： 
                    #age = property(读取函数)
                    （1）创建属性对象property()  #属性
                      (2)将下面的函数作为参数property(读取函数)
                    （3）将属性对象交给变量名关联age
                

class Wife：
                          def __init__(self,name,age)
                                 self.name =name
                                 self.age=age
                          @property
                           def age(self):                    #读取函数
                                  return self.__age
                          @age.setter                    #age.setter是设置函数或说修改函数，调用属性的setter函数，将下面的函数作为参数setter(设置函数)
                           def age(self,value):
                                  if 25<=value<=30:
                                        self.__age=value
                                  else:
                                        raise Exception("报错")
               mywife = Wife("xier",25)  --->如果年龄不在25-30之间就会报错
               mywifi.name
             **例2** 
              

```python
    class mouse:
    def __init__(self, name=None, price=None, weight=None, color=None):
        self.name =name
        self.price =price
        self.weight = weight
        self.color = color

    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self,value):
        if len(value)<6:
            self.__name = value
        else:
            raise Exception("字符太长")
    @property
    def price(self):
        return self.__price
    @price.setter
    def price(self,value):
        if 0<value<10000:
            self.__price = value
        else:
            raise Exception("价格太贵")

    @property
    def weight(self):
        return self.__weight
    @weight.setter
    def weight(self,value):
        if 100<value<1000:
            self.__weight = value
        else:
            raise Exception("超重")

if __name__ == '__main__':
    buying_thing =mouse("雷神雷蛇",100,200,"红色")
    print("商品:"+buying_thing.name,"价格:"+str(buying_thing.price))

---

“”"
属性各种写法
“”"
(1)写法1 .读写(能够对外提供读取和设置修改)
例：

class Wife:
def init(self, age=None):
self.age=age ————为私有变量赋值

                            @property      #---------------------->  快捷键  props 按TAB键  格式出来了
                           def age(self):       #读取函数
                                   return self.__age        
                          @age.setter        #设置函数
                          def age(self, value):
                                   self.__age=value

         **（2）写法2: 只读(只对外提供读取功能，类外不能修改)**

class Wife:
def init(self, age=0):
self.__age=age ————为私有变量赋值

                            @property      #---------------------->  快捷键 property +回车   格式出来了
                           def age(self):       #读取函数
                                   return self.__age        


           **(3) 写法3 :只写(只能够对外提供设置功能)**
                #快捷键: 无 

class Wfie:
def init(self, age=None):
self.age=age #执行设置函数

                           age = property()       
                          @age.setter              #设置函数
                          def age(self, value):
                                   self.__age=value

---

封装设计思想：
分而治之，变则疏之，高内聚，低耦合

类与类调用语法
1写法.直接创建对象调用
例 ：

 class A :
                             def func01(self):
                                     b = B()
                                     b.func02()
                      class B:
                             def fun02(self):
                                     print("func02")
                      if __name__ == '__main__':
                             g01= A()
                             g01.func01()

        ****2.写法：构造函数创建对象调****

  class A :
                              def __init__(self):
                                      self.b = B()
                             def func01(self):
                                     self.b.func02()
                      class B:
                             def fun02(self):
                                     print("func02")           
                      if __name__ == '__main__':
                             g01= A()
                             g01.func01()     

         **3写法.  通过传递参数调用**         

 class A :
                         def func01(self,c):
                                 c.func02()
                  class B:
                         def fun02(self):
                                 print("func02")           
                  if __name__ == '__main__':
                         g01= A()
                         g02 = B()
                         g01.func01(g02)          

---

继承
代码不用子类写，但是子类能使用

         例： 

class Person：
                    def say(self):
                            print("说话")
           
           class Student(Person):  
                    def study(self):
                            print("学习")

           class Teacher(Person):
                    def teach(self):
                            print("教学")

    #创建子类对象，可用调用父类方法和子类方法
            if __name__ == '__main__':
                 s01 = Student(）
                 s01.study()
    #创建父类对象,只能调用父类对象
            if __name__ == '__main__':
                 p01 = Person()
                 p01.say()


    instance(对象,类型)       -----------------------------------------     判断关系
#  学生对象  是一种   学生类型  

 print(isinstance(s01,Student)）)  ---->True
 print(isinstance(s01,Person)）)  ---->True
 print(isinstance(s01,Teacher)）)  ---->False

  
    issubclass(类型,类型)  -----------------------------         判断关系                             
#  学生对象  是一种  学生类型

    print(issubclass(Student,Person)）)  ---->True


    Type(对象)==类型   ------------------- 相等/相同/一模一样
# 学生对象的类型     是    人类型 
    print(type(s01) == Person）)  ---->False
     print(type(s01) == Student）)  ---->True

---

继承数据
例：

class Person:
def init(self,name=0,age=0):
self.name =name
self.age=age
class Student:
pass

#子类没有构造函数，可以直接使用父类
s01 =Student() ----子类没有数据可以正常调用父类

     例2：

class Person:
def init(self,name=0,age=0):
self.name =name
self.age=age
class Student:
def init(self,score=0):
super().init(name,age) #---------------- 通过super()调用父类实例成员,才能直接是使用
self.score = score

#子类有构造函数，会覆盖父类构造函数(好像他不存在)，所以子类需要通过super() 调用父类构造函数

            s01 = Student("小明",24,100)


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

       def __str__(self): 
             return f""
              
        def __repr__(self): 
             return 

---

运算符重载
定义：让自定义的类生成的对象

             # +无论可变还是不可变对象,都创建新对象
             #  +=对于可变对象，在原有的基础上进行修改,对于不可变对象，创建新对象

--------------------- 算数运算符:

                   方法                                  运算符和表达式                 说明
               __add__(self,rhs)                       self+  rhs                         加法 
               __sub__(self,rhs)                       self-rhs                             减法
               __mul__(self,rhs)                       self*rhs                             乘法
              __truediv__(self,rhs)                    self/rhs                            除法
              __floordiv__(self,rhs)                    self//rhs                          地板
              __mod__(self,rhs)                        self%=rhs
              __ipow__(self,rhs)                        self**=rhs
   
   例：
 

class Vector:
            def __init__(self,x,y)
                  self.x = x
                  self.x = y

       pos01 = Vector(1,2)
      pos02 = Vector(3,4)
      pos03 = pos01+pos2  ---> 报错不可相加 但是加速函数__add__ 可以相加
       改为：
  class Vector:
        def __init__(self,x,y)
              self.x = x
              self.x = y
         def __add__(self,other)
              return Vector(self.x+other.x,self.y+other.y)

如果:写成
pos01 = Vector(1,2)
post01+=Vector(3.4) -->报错需要加__iadd__
改成：
class Vector:
def init(self,x,y)
self.x = x
self.x = y
def iadd(self,other)
#因为自定义类是可变对象,所以返回原有对象self不是可创对象
self.x+=other.x
self.y+=other.y
return self

    # +无论可变还是不可变对象,都创建新对象
     #  +=对于可变对象，在原有的基础上进行修改,对于不可变对象，创建新对象
      list01 = [1]
       print(id(list01))    
        list01+=[2]
         print(id(list01))            #两个一样
 
             tuple01=(1,)
             print(id(tuple01))
           tuple+=(2,)
           print(id(tuple02))       #两个不一样，

---------------比较运算符
重写比较运算符

== #比较内容是否相同
is #比较地址是否相同

                           方法名                        运算符合符合赋值                 说明
                       __lt__(self,rhs)                 self<rhs                               小于
                       __le__(self,rhs)                 self<=rhs                           小于等于
                       __gt__(self,rhs)                 self>rhs                              大于
                       __ge__(self,rhs)                 self>=rhs                           大于等于
                       __eq__(self,rhs)                 self==rhs                           等于
                       __ne__(self,rhs)                 self！=rhs                           不等于

       常见 __eq__ 定义相同依据
              __lt__定义大小依据

       例：

class Employee:
                  def __init__(self,eid=0,did=0,name="",money=0)
                            self.eid = eid
                             self.did = did
                              self.name = name
                              self.money = money

                  def __eq__(self,other):
                            return self.eid ==other.eid

                  def __lt__(self,other):
                            return self.money<other.money
      list_employees =[Employee(1001,9001,"小老虎",2000),
                                Employee(1002,9001,"小白兔",1000), 
                                Employee(1002,9001,"师傅",1000), 
                                Employee(1003,9001,"小白",1000), 
                               ]
          print(list_employees.count(Employee(1001)))
          print(list_employees.index(Employee(1005)))