多重继承

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def run(self):
        print(f'{self.name} is running')
        return "wrfrwedww"                             # 方法重写时，注意备覆盖的方法是否有 
                                                                   # 返回值等等,被其他方法使用

    def  dosome(self):
        r = self.run()
        print( r.upper())

class Teacher(Person):
    def talk(self):
        print(f"{self.name} is talking...")

    def  run(self):
        print(f"{self.name} 你是最棒的！")       
        return  "erfrew"                                           

s = Person('anan',29)
t = Teacher('shark',19)
s.dosome()
t.dosome()


class A():
    pass
class B(A):
    pass

print(B.__mro__)       ##继承顺序，所有类都会继承<class object>


class A :
    def __init__(self,name ,age):
         self.name = name
         self.age = age
class B(A):
    def __init__(self,name,age,level):
          A.__init__(self,name,age)       #继承方式一
          super().__init__(name ,age)     #继承方式二
          self.name = name                   #继承方式三
          self.age = age
          self.level = level

print(B.__mro__)                              #显示继承层级，万物继承于object

#继承中的返回值问题
class A:
    def __init__(self,name ,age):
        self.name = name
        self.age = age
    def run(self):
         return "222"

class B(A):
     def __init__(self,name,age,level):
        A.__init__(self,name,age)
        self.level = level
     def run(self):
        return "abc"            #如果父类的方法中有返回值，而子类继承覆写的时候没有返回值的话就会出错
                                        #所以覆写的时候应该注意返回值的问题   
obj=B('shark',18,1)  
obj.run()
print(obj.__dict__)             #输出字典格式

私有属性

class Person:
    def __init__(self,f_name,s_name):
        # 私有属性，只有在内部才能使用，使用时也要加__
        self.__f_name = f_name
        self.s_name = s_name

    # 特性
    @property
    def full_name(self):
        return f"{self.__f_name} {self.s_name}"

obj = Person("song","rou")
print(obj.full_name)

class A:
    def __run(self):         #只能在类里才能使用
        pass

class B(A) :
    pass

B().__run()    #无法被继承
obj = B()
obj._A__run()      #其实就是改名，使得私有方法无法被调用 ， 将名字改为_A__run


def tail_t(arg):
    if isinstance(arg,(list,tuple)):    #判断arg是否属于list或tuple
        n = arg
    else :
        n = [arg]

    for i in n :
        print(i)

tail_t("/root/")

模块和包

/testpy/test/day12/cmdb
├── bin
│   └── run.py
└── plugins
    ├── cpu.py
    ├── memory.py
    └── __pycache__

bin内写要执行的文件,在plugins内写被调用的模块,二者组成一个包

在run.py中的代码:
#!/usr/local/bin/python3
import sys,os
dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #得到run.py的目录路径
sys.path.insert(0,dir)      #将路径添加到python的PATH中,让python在查找时可以将自己的包被调用
from plugins import cpu,memory   从plugins包内调用cpu,memory模块

cpu = cpu.Cpu()
mem = memory.Mem()

for obj in [cpu,mem]:
    info = obj.cmd_handle()
    print(info)

cpu.py中代码:
class Cpu():
    def cmd_handle(self):
        return "cpu info"

mem.py中的代码:
class Mem():
    def cmd_handle(self):
        return "mem info"

当调用自己定义的包时,要定义_init_.py,因为在代码中使用import调用模块只会调用_init_.py中的
方法,因此,在代码中要将自己定义的包的路径加到python的环境变量中,这样就可以在代码中调用包内的方法

run.py的内容,与包pkg位于统一级目录里:
# import pkg
# print(y)   #使用import只能导入__init__.py内的东西
                      #因此，当__init__.py内没有导入mod1.py时，使用
                    #import mod1 报错

# from pkg import mod1,x
# print(x)                    #使用from,在__init__.py中可以不用有导入模块的语句

import sys 

sys.path.insert(0,"/testpy/test/day12/pkg")
# print(sys.path)
import mod1

print(mod1.y)

_init_.py和mod1.py在包pkg里.

__init__.py的内容:
x = 1
import mod1

mod1.py的内容:
y = 2

name 的作用

def foo():
    return 1
if __name__ is "__main__":
    a = foo()
    print(a) 

当导包时，name不等于main,因此不会在该模块内调用函数，当该文件被执行时，name就与main相等。