提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
提示：本文主要介绍包和模块的概念
提示：以下是本篇文章正文内容，下面案例可供参考
一、多继承和多继承的顺序
class Person:
def __init__(self,name):
self.name=name
def eat(self):
print('------>eatl')
def eat(self,food):
print('---------------->eat',food)
p=Person('jack')
p.eat('狮子头')
'''
以上代码为举例说明:
怎么进行覆盖
'''
class Base:
def test(self):
print('----->BASE-------')
class A(Base):
def test(self):
print('--->AAAAAAAA')
class B(Base):
def test(self):
print('------->BBBBBBB')
class C(Base):
def test(self):
print('--------->CCCCC')
class D(A,B,C):
pass
d=D()
d.test()
import inspect
print(inspect.getmro(D))
print(D.__mro__)
# 结果操作顺序: (<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.Base'>, <class 'object'>)
# c=C()
# c.test1()
# c.test()
# c.test2()
#多继承的搜索顺序，经典类，新式类
#从左至右 深度优先
#广度优先
class P1:
def foo(self):
print('p1--->foo')
def bar(self):
print('p1--->bar')
class P2:
def foo(self):
print('p2---->foo')
class C1(P1,P2):
pass
class C2(P1,P2):
def bar(self):
print('C2--->bar')
class D(C1,C2):
pass
d=D()
d.foo()
d.bar()
print(D.__mro__)
二、多态的概念
'''
私有化：
__age
def __show(self):
pass
---> _类名_属性
私有化： 封装 将属性私有化，定义公有set和get方法
def setAge(self,age):
判断
def getAge(self):
return self.__age
s.setAge(20)
s.getAge()
class Student:
def __init__(self,age):
self.__age=age
@property
def age(self):
return ...
@age.setter
def age(self,age):
self.__age=age
s= Student()
s.age=10
print(s.age)
继承：
has a
class Student:
def __init__(self,name,book):
pass
is a
父类 子类
class Person:
def run(self):
....
class Student(Person):
....
def study(self):
....
def run(self):
super().run()
.....
s= Student()
s.study()
s.run()
1. __init__
2. 重写方法
多继承：（了解）
class A:
pass
class B:
pass
class C(A,B):
pass
现在执行环境python3
新式类: 广度优先
D.__mro__ --->查看搜索顺序
import inspect
print(inspect.getmro(D))
'''
# 封装 继承 多态 ----》 面向对象
class Person:
def __init__(self, name):
self.name = name
def feed_pet(self, pet): # pet既可以接收cat，也可以接收dog，还可以接收tiger
# isinstance(obj,类) ---》 判断obj是不是类的对象或者判断obj是不是该类子类的对象
if isinstance(pet, Pet):
print('{}喜欢养宠物:{}，昵称是:{}'.format(self.name, pet.role, pet.nickname))
else:
print('不是宠物类型的。。。。')
class Pet:
role = 'Pet'
def __init__(self, nickname, age):
self.nickname = nickname
self.age = age
def show(self):
print('昵称:{},年龄:{}'.format(self.nickname, self.age))
class Cat(Pet):
role = '猫'
def catch_mouse(self):
print('抓老鼠....')
class Dog(Pet):
role = '狗'
def watch_house(self):
print('看家高手....')
class Tiger:
def eat(self):
print('太可怕了，可以吃人...')
# 创建对象
cat = Cat('花花', 2)
dog = Dog('大黄', 4)
tiger = Tiger()
person = Person('家伟')
person.feed_pet(cat)
person.feed_pet(dog)
print('----------------------------')
person = Person('pengpeng')
person.feed_pet(tiger)
# Pet
# pet 父类 cat dog 子类
# pet 大类型 cat dog 小类型
# 封装 继承 多态
class Person:
def __init__(self,name):
self.name=name
def feed_pet(self,pet): # pet既可以接收cat，也可以接收dog，还可以接收tiger
#判断对象是不是这个类或者这个类的子类
if isinstance(pet,Pet):
print('{}喜欢养宠物{},昵称是{}'.format(self.name,pet.role,pet.nickname))
else:
print('不是宠物类型的')
class Pet:
role='pet'
def __init__(self,nickname,age):
self.nickname=nickname
self.age=age
def show(self):
print('昵称:{},年龄:{}'.format(self.nickname,self.age))
class Cat(Pet):
role='猫'
def catch_mouse(self):
print('捉老鼠')
class Dog(Pet):
role='狗'
def watch_house(self):
print('看家高手')
class Tiger:
def eat(self):
print('太可怕了，可以吃人')
#创建对象
cat=Cat('花花',2)
dog =Dog('大黄',4)
tiger=Tiger()
person=Person('佳明')
person.feed_pet(cat)
person=Person('阿奇')
person.feed_pet(tiger)
三 什么是单例？
#单例模式:
#开发模式:单例模式,对内存进行优化.
class Student:
pass
s=Student()
s1=Student()
#每创建一个实例都需要去开辟一块内存空间
# print(s)
# print(s1)
# print(s2)
class Singleton:
#私有化 单例的地址就存在于__instance
__instance= None
name='jack'
#重写__new__
def __new__(cls):
print('------->__new__')
if cls.__instance is None:
print('---->1')
cls.__instance=object.__new__(cls) #__new__产生一个内存空间
print(cls.__instance)
return cls.__instance
else:
print('-------->2')
return cls.__instance
def show(self,n):
print('----->show',Singleton.name,n)
s=Singleton()
s1=Singleton()
print(s)
print(dir(Singleton))
print(s1)
s1.show(5)
s.show(7)
四 模块的使用?
'''
在python中，模块是代码组织的一种方式，把功能接近的函数放到一个文件，一个文件(.py)就是一个模块(module).
模块名就是文件名去掉后缀py,这样做的好处是
-提高代码的可复用，可维护性，一个模块编写完毕后，可以很方便的在其他项目中导入
-解决了命名冲突，不同模块和相同命名不会冲突
常用标准库：
| 标准库 | 说明 |
| --------------- | -------------------- |
| builtins | 内建函数默认加载 |
| math | 数学库 |
| random | 生成随机数 |
| time | 时间 |
| datetime | 日期和时间 |
| calendar | 日历 |
| hashlib | 加密算法 |
| copy | 拷贝 |
| functools | 常用的工具 |
| os | 操作系统接口 |
| re | 字符串正则匹配 |
| sys | Python自身的运行环境 |
| multiprocessing | 多进程 |
| threading | 多线程 |
| json | 编码和解码 JSON 对象 |
| logging | 记录日志，调试 |
1. 自定义模块
2. 使用系统一些模块
导入模块:
1. import 模块名
模块名.变量 模块名.函数 模块名.类
2. from 模块名 import 变量 | 函数 | 类
在代码中可以直接使用变量，函数，类
3. from 模块名 import *
该模块中所有的内容
但是如果想限制获取的内容，可以在模块中使用__all__=[使用*可以访问到内容]
4. 无论是import还是from的形式，都会将模块内容进行加载
如果不希望其进行调用。就会用到__name__
在自己的模块里面__name__叫： __main__
如果在其他模块中通过导入的方式调用的话：__name__: 模块名
'''
list1=[4,2,7,8,9]
# 导入模块
import calculate
#使用模块中的函数,模块名.变量 模块名.类 模块名.函数
result=calculate.add(*list1)
print(result)
# 使用模块的变量
print(calculate.number)
#使用模块中的类
cal=calculate.Calculate(88)
cal.test()
cal.test1()
from calculate import Calculate,add,number
result =add(*list1)
print(result)
sum=result+number
print(sum)
c=Calculate(80)
c.test()
自定义的模块
__all__=['add','number']
#变量
number=100
name='calculation'
def add(*args):
if len(args)>1:
sum =0
for i in args:
sum+=1
return sum
else:
print('至少传入两个参数')
return 0
def minus(*args):
if len(args)>1:
m=0
for i in args:
m-=1
return m
else:
print('至少传入两个参数')
def multiply(*args):
pass
def divide(*args):
pass
#类
class Calculate:
def __init__(self,num):
self.num=num
def test(self):
print('正在使用Calculate进行运算')
@classmethod
def test1(cls):
print('-------->类中的方法')
def test():
print('我是测试.....')
print('__name__:',__name__)
if __name__=='__main__':
print(__name__) # __name__ ---->__main__
test()
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
