python学习笔记

查看内置函数
 import builtins
 print(dir(builtins))
zip()拉链函数 将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的内容
 #每个变量元素个数不一致时
 a=[1,2,3]
 b=['a','b','c','d']
 c=(6,5,4,3,2,1)
 for i in zip(a,b,c):
     print(i)
map()函数 映射函数
作用：可对可迭代对象中的每一个元素进行映射，分别执行function
计算列表中每个元素的平方，返回新列表
这里使用匿名函数
 li=[1,2,3,4]
 print(list(map(lambda x:x*x,li)))
reduce()函数 可迭代中通过计算使元素不断减少，最终得到一个计算值
reduce(函数名，可迭代对象)
 from functools import reduce
 print(reduce(lambda x,y:x+y,[1,2,3,4]))
enumerate枚举，用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中
 enumerate(可迭代对象,[start=0])
 li=['a','b','c','d']
 for i,j in enumerate(li):
     print(i,j)
 print(list(enumerate(li)))
 print(dict(enumerate(li)))
拆包
 def test():
     a=10
     b=20
     c=30
     return a,b,c
 print(test())   #return返回多个值，以元组形式返回到函数的调用处

 a1,b1,c1=test()
 print(a1,b1,c1)
元组拆包升级版
 tu=(1,2,3,4)
 a,*c,b=tu   #拆包 多变量的赋值
 print(f'a={a}')
 print(f"b={b}")
 print(f'c={c}')
字典拆包
 dic={'name':'Wilia','age':'18','gender':'女'}
 print(dic)
 a,b,c=dic
 print(a,b,c)
注意：对字典拆包获取的使字典的key，没有value
异常模块包
print(a)
异常处理最终目的：让程序在有异常时，仍能够正常运行
格式一
try与except
法一
 try:
     print(a)
 except: #基类异常
     print('出现错误')
 b=10
 print(b)
 法二
 try:
     print(a)
 except NameError as e:
     print(e)
 b=10
 print(b)
法三
 try:
     print(a)
 except Exception as e:
     print(e)
法四：多分支异常
 try:
     print(a)
 except IndexError as e:
     print(e)
 except KeyError as e:
     print(e)
 except NameError as e:
     print(e)
格式二
 try except else
 dic={'name':'zs'}
 try:
     print(dic['age'])
 except Exception:
     print('出现错误')
 else:
     print('没有捕获到异常')
格式三
try except finally
 try:
     print(a)
 except NameError:
     print('出现错误')
 finally:
     print('哈哈哈哈')
格式四---完整捕获
try except else finally
 try:
     n=int(input('请输入一个整数：'))
     print(10/n)
 except ValueError:
     print('请输入正确的数据')
 except Exception as e:
     print('未知错误 %s' %e)
 else:
     print('没有异常时才会执行的代码')
 finally:
     print('无论有无异常，都会执行')
异常的传递：在主函数中设置“异常捕获机制”，调用子函数
1.
 def funa():
     return int(input('请输入整数'))
 def funb(): #主函数
     return funa()
 try:
     print(funb())
 except Exception as e:
     print('错误：%s' %e)
2.
 def test1():
     num=int(input('请输入：'))
     return 10/num
 def test2():
     print(test1())
 try:
     test2()
 except ValueError:
     print('错误，输入不正确')
 except ZeroDivisionError:
     print('非零')
 else:
     print('运行成功')
 finally:
     print('最后执行')
主动抛出异常
1.创建一个Exception('...')的对象
2.raise抛出这个对象
例1.
 def funa():
     raise Exception('抛出一个异常')
     print('哈哈哈')
 funa()
例2.
 def user():
     pwd=input('请输入密码：')
     if len(pwd)>=6:
         return pwd
     #创建异常对象
     ex=Exception('密码长度不够')
     raise ex
 try:
     upwd=user()  #函数的返回值会返回到函数的调用处
     print(upwd)
 except Exception as e:
     print('错误：%s'%e)
1.内置模块：标准库
 import builtins
 print(dir(builtins))
2.库 第三方模块
pip install
3.自定义模块
 import 模块名
from import与import的区别
 import random
 print(random.randint(1,5))  #randint(1,5)取1-5的随机整数

 from random import randint
 print(randint(1,5))
py文件的两种功能
 1.脚本：一个文件就是整个程序，直接运行
 __name__=='__main__'
 2.模块：作为模块导入其他文件执行
作为模块导入时，__name__==模块名（没有后缀）
if __name__=='__main__':
包：文件夹/目录，用于对不同模块进行分类管理，方便维护
多了一个文件：__init__.py
当包被作为模块导入时，包目录下会生成一个__pycache__文件夹缓存
__init__.py文件并不用来定义程序单元，而是用于导入包内模块的成员
from a import b.c会有语法错误
from a.b import c可行
在init.py中使用__all__=['','']可定义 *
闭包
 递归函数的特性：
 1）必须有一个明确的结束条件
 2）每次进入更深一层递归时，问题规模相比上次递归都应有所减少
 3）相邻两次重复之间有紧密的联系，前一次要为后一次做准备
 4）递归效率不高，递归层次过多会导致栈溢出
 5）优点：定义简单，逻辑清晰
递推：给递归实现拆解，递归每一次都是基于上一次进行下一次的执行
回溯：在遇到终止条件之前，从最后往回返，一级一级的把值返回来
累计和
求1-100的和
 def funa(n):
     sum=0
     for i in range(1,n+1):
         sum += i
     print(sum)
 funa(3)
递归函数   sum=0  sum=0+1 sum=1+2 sum=sum+3
求n项的和
 def funb(n):
     if n>0:
         return funb(n-1)+n
     else:#递归结束的条件必须设置，否则会导致栈溢出
         return 0
 print(funb(3))
斐波那契数列求和
 list1=[]
 def funa(n):
     if n<=1:
         return n
     else:
         return funa(n-2)+funa(n-1)
 for i in range(1,11):
     list1.append(funa(i))   #添加第i项，调用
 print(list1)
引用
id()查看变量的地址
 a=3
 print(a,id(a))
 b=a
 print(b,id(b))
函数名的引用
 def test1():
     print('---in test1 func----')
 test1()
 res=test1 #可理解为变量的赋值
 print(id(res))
 print(id(test1))
闭包的定义：闭包是函数内部定义的函数
 1）闭包是嵌套在函数中的函数
 # 2）闭包必须是内层函数对外层函数变量（非全局变量）的引用
 # #构成条件
 # 1）函数中嵌套一个函数
 # 2）内层嵌套函数，对外部作用域有一个非全局变量的引用
 # 3）外层函数的返回值是内层函数的函数名
例  闭包模板
 def outF():
     sum = n
     def inF(n):
         return sum+1
     return inF  #外层函数返回值是内层函数的函数名
 闭包的作用：
 保存局部信息不被销毁，保证数据的案例性
应用：
 1）可以保存一些非全局变量但是不易被销毁 改变的数据
 2）装饰器
 3）实现数据锁定
示例：将如下代码改成闭包形式
 def outer():
     n=10    #n为非全局变量
     def inner():
         n=20
         print('inner函数',n)
     print('outer函数',n)
     inner()
 outer()
 def outer(m):
     n=10    #n为非全局变量
     def inner():
         print('inner函数',n+m)
     return inner
 ot = outer(2)
 ot()
修改外布函数中的变量 nonlocal
 def outer(a):
     def inner():
         nonlocal a  #给外层函数变量声明
         a += 1
         print(a)
     return inner
 ot = outer(1)
 ot()    #函数调用
 print(type(ot))
装饰器
功能：函数执行时间统计；用在框架的路由传参；插入日志；事务处理；权限校验；缓存
1.先定义一个装饰函数（帽子）2.再定义业务函数3.最后把帽子戴上
模板
 def wrapper(func):
     def inner(*args,**kwargs):
         res=func(*args,**kwargs):
         return res
     return inner
日志打印器
 def logger(func):
     def wrapper(*args):
         print('我准备开始计算：{}函数了'.format(func.__name__))
         #真正执行的业务函数
         func(*args)
         print('啊哈，我计算完啦')
     return wrapper

 #第一种方法
 def add(x,y):
     print('{}+{}={}'.format(x,y,x+y))

 #使用装饰器来装饰函数
 #把函数名add作为参数传入到装饰函数
 te=logger(add)
 te(200,50)    #实现wrapper的调用
 def logger(func):
      def wrapper(*args):
          print('我准备开始计算：{}函数了'.format(func.__name__))
          #真正执行的业务函数
          func(*args)
          print('啊哈，我计算完啦')
      return wrapper

  #
 @logger
 def add(x,y):
     print('{}+{}={}'.format(x,y,x+y))

 add(200,50)    #和普通调用业务函数的调用和传参方式一致
为什么不使用函数的封装给他添加额外功能，而使用装饰器
因为装饰器可以实现代码的复用
 @logger
 def foo():
     print('welcome to sixstar')

 foo()
 无参数的函数（被装饰的函数（业务函数）无参数）
 装饰器函数本质：通过业务作为参数传入到装饰器函数里面
 def test(fn):
     def inner():
         print('这是inner')
         fn()
     return inner
法一
 def t1():
     print('哈哈哈')
 t=test(t1)    #t1作为参数传入到装饰器函数里面去
 t()
法二
 @test
 def t1():
     print('哈哈哈')
 t1()
被装饰的函数有参数
 def exam(fn):
     def inner(a,b):
         print('inner函数中值：%s,%s'%(a,b))
         fn(a,b) #真正的业务函数
     return inner

 @exam
 def test(a,b):#真正的业务函数定义
     print('结果是：',a+b)

 test(1,2)
 def exam(fn):
     def funa(x,y):
         print('hello',x,y)
         def inner(a,b):
             print('inner函数中值：%s,%s' % (a, b))
             fn(a, b)  # 真正的业务函数
         return inner
     return funa

 @exam
 def test(a,b):
     print('结果是：',a+b)
 test(1,2)(3,4)
被装饰的函数有不定长参数
函数参数定义顺序：必选参数 默认参数 可变参数 命名关键字参数和关键字参数
 def funa(fn):
     def inner(*args,**kwargs):
         print(f'我开始计算：{fn.__name__}函数了')
         fn(*args,**kwargs)
         print('执行完成')
     return inner

 @funa
 def add(*a,**b):
     print(a)
     print(b)

 add(2,3,4,5,6,a=1,b=3)  #关键字传参方式 key=value
回调函数
 def test3(m,n):
     if m==2:
         n()
     else:
         print('不可调用')

 def one():
     print('函数一')

 def two():
     print('函数二')

 test3(2,one)
面向过程：需要实现一个功能时，着重的是开发的步骤和过程，每个步骤都需要自己亲力亲为，需要编写代码
面向对象：需要实现一个功能时，不注重的是开发的步骤和过程，而是谁来帮我做这个事
 class Hero(object):     #object是python里所有类的最顶级父类
     def info(self):     #info是实例方法，第一个参数一般是self，表示的是实例本身。也可取其他名字，其作用是这个变量指向了实例对象
         print('hero')
属性：对象的特征描述（实际上为类中定义变量，该变量为属性）
方法：对象具有的行为（本质是函数），类中定义的函数即方法
 class Student():
     name='lucy'     #属性
     def info(self):     #方法
         print('123')
 对象的创建
 创建对象的格式：对象名=类名（）    实例化一个对象
类的定义
lass Hero(object):
   def info(self):
       print(self)
       print('self各不同，对象是出处')
创建对象，实例化一个对象
 hero1=Hero()     #创建的对象不限制数量
 hero2=Hero()
 hero3=Hero()
 hero1.info()     #调用实例方法
 print(hero1)    #打印的是内存地址
 class Student():
     name='lucy'     #属性
     def info(self):     #方法
         print('123')
 print(Student.__dict__)     #查看类的属性
 print(Student.__dict__['name'])     #查看单个属性
 print(Student.name) #作用改用
 Student.name='哈哈'
 print(Student.name)
 del Student.name
 class Hero(object):
     #定义一个方法
     def move(self):
         print('正在前往事发地点……')
 #创建对象，实例化对象
 hero=Hero()

 #给对象添加属性
 hero.name   ='lucy'    #添加对象的name属性
 hero.hp     =2500
 print('英雄%s的生命值:%d'%(hero.name,hero.hp))
 hero.move()     #调用实例方法
在方法内通过self获取对象属性
 class A:
     def test(self):
         print('%s的年龄是%d'%(self.name,self.age))

 a=A()   #实例化一个对象
 a.name  ='张三'     #定义对象的属性
 a.age   =20
 a.test()
 print(a.__dict__)
 a.job   ='IT'
 print(a.job)
类属性与实例属性的区别
 class B:
     num=0   #类属性
     def __init__(self,name):
         self.name = name    #实例属性
     def test(self):
         print(f'我的名字是{self.name}')
 #实例对象
 b=B('zs')
 print(b.name)   #对象可以访问实例属性
 # print(B.name)   #类不能访问实例属性
 print(b.num)
 print(B.num)
 b.test()
 class B:
     num=0   #类属性
     def __init__(self,name):
         self.name = name    #实例属性
     def test(self,age):
         self.age    = age
         print(f'我的名字是{self.name}')
 #实例对象
 b=B('zs')
 b.test(20)
 print(b.age)
 构造函数
创建对象的时候就已经拥有的属性
 class Hero:
     def __init__(self):
         self.name   =   '泰坦'
         self.hp     =   200
         self.at     =   450
     def move(self):
         print(f'{self.name}正在移动')
     def attack(self):
         print(f'{self.name}的生命值{self.hp},发出了一招攻击{self.at}')

 #创建对象
 hero=Hero()
 hero.move()     #调用方法
 hero.attack()
实例每个对象，让每个对象拥有不同属性
 class Hero:
     def __init__(self,name,hp,at):
         self.name   =   name
         self.hp     =   hp
         self.at     =   at
     def move(self):
         print(f'{self.name}正在移动')
     def attack(self):
         print(f'{self.name}的生命值{self.hp},发出了一招攻击{self.at}')

 #创建对象
 hero1=Hero('大乔',400,300)
 hero2=Hero('小乔',300,200)
 hero1.move()     #调用方法
 hero1.attack()
析构函数
 __init__()  构造函数，创建对象时默认调用
 __del__()   析构函数，删除对象时默认调用
用于对象被清除后清除他所占用的内存空间
注意事项：
 1.构造函数与析构函数都不能有返回值
 2.析构函数不能有参数
 3.一个类只有一个析构函数
 4.析构函数在对象销毁时被调用
 class Person:
     def __init__(self):
         print('我是init方法')
     def __del__(self):
         print('被销毁了')
 #创建对象
 xm = Person()
 del xm  #手动删除对象
 print('最后一句')
 def funa():
     print(123)
 funa()
 1.__str__()必须返回一个字符串
 2.定义了__str__()方法，在打印对象，默认输出该方法的返回值
 class A:
     def __str__(self):
         return 'hello'
 obj = A()
 print(obj)
 class Human:
     mind    =   '哈哈'
     def __init__(self,name,age):
         self.name   =   name
         self.age    =   age
     def work(self):
         print(f'你的名字是{name}')
     def __str__(self):
         return  '你的名字是%s，年龄是%d岁'%(self.name,self.age)

 obj=Human('ls',20)
 print(obj)
封装 将复杂的信息、流程给抱起来，内部处理，让使用者只需要通过简单的操作步骤就能实现
 将属性和方法放到一起作为一个整体
 class Student:
     def __init__(self,name,age):
         self.name   =   name
         self.age    =   age

     def add(self):
         print('姓名是：%s，年龄是：%d'%(self.name,self.age))
 #创建对象
 s1=Student('lily',20)
 s2=Student('lucy',25)

 #法一：通过实例.方法调用
 # s1.add()
 # s2.add()

 #法二：通过对象直接调用
 print(s1.name)
 print(s2.age)
例：士兵射击
 class Soldier:
     def __init__(self,model,name,count):
         # 1.枪的型号
         self.model  =   model
         self.name   =   name
         # 2.子弹的数量
         self.count  =   count

     def shoot(self):
         # 1.判断子弹的数量
         if self.count<=0:
             print('没有子弹了')
         # 2.提示发射信息
         else:
             self.count -= 1
             print(f'{self.name}使用{self.model}发射了,剩余{self.count}子弹')
         # 3.计数count

 #创建对象
 s=Soldier('AK47','许三多',2)
 s.shoot()
 s.shoot()
 s.shoot()
 1.私有属性和方法，都不能通过对象直接访问，但是可以在本类内部访问
 2.类的私有属性和私有方法，不能被子类继承，子类也无法访问
 3.类的私有属性和私有方法，往往用来处理类内部的事情，不通过对象来处理，起到安全作用
定义私有属性和方法
 _x 也代表私有属性或方法，但实际上类对象和子类可以访问
 __x 私有成员
 __x__:用户名字空间的魔法对象或属性
 x__ 用于避免与python关键词的冲突
 class Classmate:
     name='lucy'
     _age=20
     __sex='F'

 pr=Classmate()
 print(Classmate.name)
 print(Classmate._age)
 # print(Classmate.__sex)
 #强行获取私有属性,语法：对象._类名__属性名
 print(pr._Classmate__sex)
 #通过对象访问属性
 print(pr.name)
 print(pr._age)
 print(pr.__sex)
通过正规手段访问私有属性
 class   Classmate:
     def __init__(self):
         #定义私有属性     name
         self.__name='哈哈'
     def funa(self):
         #在类方法中使用私有属性
         print(self.__name)

 pr=Classmate()
 # print(pr.__name)
 pr.funa()
私有方法
 class Classmate:
     #定义私有方法__sing()
     def __sing(self):
         print('唱歌')
     def dance(self):
         print('跳舞')
         self.__sing()

 pr=Classmate()
 pr.dance()
修改私有属性的值
 1.对象名.属性名=数据    --直接修改
 2.对象名.方法名()     --间接修改
 class Classmate():
     def __init__(self):
         self.name = 'lucy'
         self.__age = 30
     #获取私有属性的值
     def get_age(self):
         return self.__age
     #设置私有属性的值
     def set_age(self,new_age):
         self.__age = new_age

 p=Classmate()
 # print(p._Classmate__age)
 #类的外面获取对象的属性
 res=p.get_age()
 print(res)
 #想在类的外面修改对象私有属性的值
 p.set_age(35)
 print(p.get_age())
继承：类间的关系，描述一个类从另一个类获取成员信息的类间关系
 继承的优点：
 1.减少了重复的代码
 2.增加了类的耦合性（模块间的关联程度）
 3.使得代码更加的规范化，合理化
 class 类名（父类名）：
     pass
不适用继承
 class Person:
     def sing(self):
         print('唱')
     def dance(self):
         print('跳')
 p=Person()
 p.sing()
 p.dance()
使用继承
 class God:
     def sing(self):
         print('唱')
     def dance(self):
         print('跳')

 class Person(God):#Person类继承父类God
     pass
 #创建对象
 p=Person()
 p.sing()
新式类与旧式类
 python3中
 法一
 class Person(object):
     pass
 法二
 class Person():
     pass
 法三
 class Person:
     pass
 在python2中,默认都是经典类,只有显式继承了object才是新式类
 object是python为所有对象提供的基类
单继承
 class Person:
     Sname='动物类'
     def __init__(self,name,sex,age):
         self.name   =   name
         self.sex    =   sex
         self.age    =   age
     def eat(self):
         print(f'{self.name}在吃东西,性别是{self.sex},年龄是{self.age}')
 #定义子类
 class Lucy(Person):
     pass
 p1=Lucy('lucy','F',18)
 p1.eat()
继承的传递性
 class Animal:
     def __init__(self,name):
         self.name = name
     def eat(self):
         print('--吃--')
     def shui(self):
         print('--睡--')

 class Dog(Animal):
     def bark(self):
         print(f'{self.name}在汪汪叫!')

 class Black(Dog):
     def fly(self):
         print(f'{self.name}说:我会飞')

 b=Black('小黑')
 b.bark()
继承重写
 应用场景:当父类的方法不能满足子类的需求时,可以对方法进行重写
1.覆盖父类的方法:在子类中定义一个和父类同名的方法来实现
2.对父类方法进行扩展:在子类中重写父类方法,super().父类方法
 class Human(object):
     def __init__(self,name):
         self.name   =   name
     def eat(self):
         print('%s在%s吃饭'%(self.name))

 class zs(Human):
     def eat(self):#重写
         print('%s在慢慢地吃饭'%(self.name))

 p1=zs('张三')
 p1.eat()
扩展父类的方法
 1.父类名.方法(self)
 class Animal(object):
     def eat(self):
         print('吃东西')

 class Dog(Animal):
     def eat(self):
         Animal.eat(self)    #本质上是用父类名调用方法
         print('啃骨头')

 black = Dog()
 black.eat()
2.super().父类方法
 class Animal(object):
     def __init__(self,name):
         self.name   =   name
     def bark(self):
         print('%s在叫'%self.name)
         print('哈哈')
 #子类
 class Dog(Animal):
     def bark(self):
         super().bark()  #表示调用父类方法
         print('%s在汪汪叫'%self.name)

 white = Dog('小白')
 white.bark()
继承父类构造方法,并进行改写
 class A:
     def __init__(self,name):
         self.name   =   name
         print('父类中的名字是:',self.name)
     def test(self):
         print('父类中的%s在哈哈笑'%self,name)

 class A2(A):
     def __init__(self,name):
         super().__init__(name)
         print('子类中的名字是:',self.name)
     def test(self):
         print('子类中的%s在嘻嘻笑'%self.name)

 obj=A2('李四')
 obj.test()
父类私有属性和方法
 不对外公开的,外界以及子类都不能直接访问
私有属性,方法常用于做一些内部的事情
 class A:
     def __init__(self):
         self.num1   =   100
         self.__num2 =   200
     def __test(self):
         print(f'私有方法{self.num1},{self.__num2}')
     def test(self):
         print(f'私有方法{self.num1},{self.__num2}')

 class B(A):
     def demo(self):
         print('哈哈哈')
         # print('访问父类的私有属性%d'%self.__num2)
         # self.__test()

 #创建子类对象
 b=B()
 b.demo()
 print(b.num1)   #子类不能直接访问父类的私有属性与方法
 b.test()
子类对象可以通过父类的公有方法间接访问私有属性或方法
多继承
 多继承:子类可以拥有多个父类,并且具有所有父类的属性和方法
 class A:
     def test(self):
         print('这是test方法')
 class B:
     def demo(self):
         print('这是demo方法')

 class C(A,B):
     pass

 c=C()
 c.test()
 c.demo()
如果不同的父类中存在同名的方法,子类对象在调用方法时,会调用哪一个类中的方法呢?
 class A:
     def play(self):
         print('这是女儿')
 class B:
     def play(self):
         print('这是儿子')
 class C(A,B):   #谁先继承就用谁,就近原则
     pass

 c=C()
 c.play()
 #查看C类调用方法的顺序
 print(C.__mro__)
 class A:
     def play(self):
         print('这是儿子')
 class B:
     def play(self):
         print('这是女儿')
 class C(B,A):
     def play(self):
         # A.play(self)    #对父类的扩展
         super().play()  #对父类的扩展二,默认使用第一个(继承的)父类的属性和方法
         print('就是这样')

 c=C()
 c.play()
 print(C.__mro__)
机器人一代
 class Robot(object):
     def __init__(self,year,name):
         self.year   =   year
         self.name   =   name
     def walk(self):
         print('%s只能平地行走,遇到障碍物会摔倒'%self.name)
     def produce(self):
         print('{}年生产的机器人,名字是{}'.format(self.year,self.name))

 rot=Robot(2000,'罗马一代')
 rot.walk()
 rot.produce()
 #机器人二代
 class Robot2(Robot):
     def walk(self):
         print('%s可以避开障碍物'%self.name)
 rot=Robot2(2002,'罗马二代')
 rot.walk()
 rot.produce()

 #机器人三代
 class Robot3(Robot2):
     def run(self):
         print('%s可以跑步'%self.name)
 rot=Robot3(2004,'罗马三代')
 rot.run()
 rot.produce()
 print(Robot3.__mro__)
多态:同一种事物的多种形态
多态性:一种调用方式,不同的执行效果
多态性的好处
 1)可以代码的灵活性
 2)以继承和重写父类方法为前提
 3)是调用方法的技巧,不会影响到类的内部设计
容器类型有多种形态:字符串,列表,元组,字典......
1.+号的多态性
 print(1+2)
 print('hello'+'python')

 #2.len()传不同的参数,也体现多态
 print('world',len('world'))
 print('[1,2,3]\',len('[1,2,3]'))
3.动物的多态性
 class Animal:
     def run(self):
         print('动物在走')
 class People(Animal):
     def run(self):
         print('人在走')
 class Pig(Animal):
     def run(self):
         print('猪在走')
 peo1=People()
 pig1=Pig()
 pig1.run()
实现多态的两个前提:
 1.继承:多态必须发生在父类与子类之间
 2.重写:子类重写父类方法
 class A:
     def show(self):
         print('A.show')
 class S1(A):
     def show(self):
         print('S1.show')
 class S2(A):
     def show(self):
         print('S2.show')

 def func(obj):
     obj.show()
 #为S1类创建对象s1
 s1=S1()
 func(s1)
 s2=S2()
 func(s2)
 #现在像增加S3类
 class S3(A):
     def show(self):
         print('S3.show')
 s3=S3()
 func(s3)
 class Tool(object):
     self.age    =   20
     def funa(self):
         print(123)
 t=Tool()
类方法:需要使用装饰器@classmethod来表示其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数
类方法一般和类属性配合使用
类方法本质:将类本身作为对象进行操作的方法
 class Person:
     age =   20
     @classmethod
     def human(cls):
         return cls.age
 #实例化对象p
 p=Person()
 print(p.human())    #实例对象可以访问类方法
 print(Person.human())   #可以通过类本身调用类方法
 class Person:
     age=20
     @classmethod
     def get_age(cls):
         print(cls.age)

     @classmethod
     def set_age(cls,age):
         cls.age =   age
 p=Person()
 p.get_age()
 Person.get_age()
 p.set_age(18)
 p.get_age()
 Person.get_age()

 p.name='lucy'
 print(p.name)
静态方法:@staticmethod
静态方法是类中函数,它不需要实例,可以理解为是独立,单纯的函数
 class Dog(object):
     @staticmethod
     def bark():
         print('汪汪叫')
 dog=Dog()
 dog.bark()
 class A:
     age =   10
     @staticmethod
     def get_age():
         return A.age
 a=A()
 print(a.get_age())
 print(A.get_age())
 class Test(object):
     def instancefun(self):
         print('这是instancefun')
     @classmethod
     def classfun(cls):
         print('这是classfun')
         print(cls)
     @staticmethod
     def staticfun():
         print('这是staticfun')
     def function():
         print('这是func')
调用实例方法
 t=Test()
 t.instancefun()
 Test.instancefun(Test)
 #调用类方法
 Test.function()
 t.classfun()
 Test.classfun()
 #调用静态方法
 t.staticfun()
 Test.staticfun()
 #调用函数
 # t.function()    #对象不能直接调用函数