码迷，mamicode.com
首页 > 编程语言 > 详细

python18-day7

时间：2017-08-18 11:16:13      阅读：228      评论：0      收藏：0      [点我收藏+]

标签：attr   活性   同名   sel   uuid   read   返回   index   host   

什么时候使用面向对象? 当某些函数具有相同参数时,可以使用面向对象的方式,讲参数值一次的封装到对象,以后去对象中取值即可
 

面向对象的特点: 

封装,继承,多态   #多态(意义不大,java等强类型,应用多)
 

类和对象

一 创建类
class 类名:
    def 方法名(self,***):
        pass
二 创建对象
    对象=类名()
 
三 通过对象执行方法
对象.方法名(123)
 
 
self是python会自动传值的参数
构造方法:   __init__()   #自动被执行,   ()中可填参数
 

 

类定义

  1. #类通过函数改变
  2. class Person:
  3. def __init__(self,name,age,money):
  4. self.name=name
  5. self.age=age
  6. self.money=money
  7. def shopping(self):
  8. self.money=self.money -200
  9. print(self.money)
  10. long=Person("龙",18,400)
  11. hu=Person("虎",18,300)
  13. long.shopping()
  14. hu.shopping()
  15. # 200
  16. # 100

计数器

  1. class Foo:
  2. count=0
  3. def __init__(self,name):
  4. Foo.count+=1            #写Foo.count Foo代表类
  5. self.name=name
  7. obj1=Foo("egon1")
  8. obj2=Foo("egon2")
  9. # print(Foo.count)
  10. # print(obj2.count)
  12. class Student:
  13. tag = "tag值" #灵活性,可增加参数
  14. def __init__(self,ID,name,age):
  15. self.id=ID
  16. self.name=name
  17. self.age=age
  18. def walk(self):
  19. print("%s is waokking"%self.name)
  21. s1=Student(1,"egon",18)
  22. s2=Student(2,"alex",1000)
  23. s1.walk()
  24. s2.walk()
  25. print(s1.id,s1.name,s1.age,s1.tag)
  27. print("用户数量",Foo.count)
  28. # egon is waokking
  29. # alex is waokking
  30. # 1 egon 18 tag值
  31. # 用户数量 2
 
 
技术分享
 

   类的传参可以是另一个类

  1. class c1:
  2. def __init__(self,name,obj):
  3. self.name = name
  4. self.obj=obj
  6. class c2:
  7. def __init__(self,name,age):
  8. self.name = name
  9. self.age=age
  10. def show(self):
  11. print(self.age)
  13. c2_obj=c2("aa",11) #c2("aa", 11).show() 这样也行
  14. c2_obj.show() #显示show函数值
  15. #11
  16. print(c2_obj.name) #也可以调用变量,显示变量要加print
  17. #aa
  19. c1_obj=c1("alex",c2_obj) #c1_obj的参数可以是c2_obj函数
  20. print(c1_obj.obj.name) #c1_obj.obj.name =c2_obj.name
  21. #aa
 
 

继承

继承是一种创建类的方式
 
F2继承F1所有数据
  1. class F1:
  2. def show(self):
  3. print("show")
  5. class F2(F1):
  6. def bar(self):
  7. print("bar your right")
  8. obj = F2()
  9. obj.bar()
  10. #bar your right
 
 

F2继承F1

F2继承了F1的函数 如果F2和F1中有同名函数执行F2函数(子类优先)
  1. class F1: #父类,基类
  2. def show(self):
  3. print("show")
  5. def foo(self):
  6. print(self.name)
  9. class F2(F1): #子类,派生类
  10. def __init__(self,name):
  11. self.name = name
  13. def bar(self):
  14. print("bar your right")
  16. def show(self):
  17. print("F2,show")
  18. obj = F2("alex")
  19. obj.foo()

父类不变,子类改变

 
  1. class Animal:
  2. def __init__(self,name,age,sex):
  3. self.name=name
  4. self.age=age
  5. self.sex=sex
  6. def eat(self):
  7. print("%s eat"%self.name)
  9. def takl(self):
  10. print("%s say"%self.name)
  11. class People(Animal):
  12. def __init__(self,name,age,sex,education):
  13. Animal.__init__(self,name,age,sex) #这是调用父类初始化
  14. self.education=education
  16. peo1=People("alex",18,"male","小学")
  17. print(peo1.__dict__) #不加__dict__是内存地址
 
 
  1. class Animal:
  2. def __init__(self,name,age,sex):
  3. self.name=name
  4. self.age=age
  5. self.sex=sex
  7. def eat(self):
  8. print("eating")
  10. def talk(self):
  11. print("="*8)
  12. print("%s 在干嘛" %self.name)
  14. class People(Animal):
  15. def __init__(self,name,age,sex,education):
  16. Animal.__init__(self,name,age,sex)
  17. self.education=education
  19. def talk(self):
  20. Animal.talk(self)
  21. print("%s say hello %s"%(self.name,self.education))
  23. class Pig(Animal):
  24. def __init__(self,name,age,sex):
  25. Animal.__init__(self,name,age,sex)
  27. def talk(self):
  28. Animal.talk(self) #执行Peple中的tailk子类优先
  29. print("%s 哼哼哼"%self.name)
  31. class dig(Animal):
  32. def __init__(self,name,age,sex):
  33. Animal.__init__(self,name,age,sex)
  35. def talk(self):
  36. Animal.talk(self) #执行Peple中的tailk子类优先
  37. print("%s 汪汪汪汪"%self.name)
  39. peo1=People("alex",18,"male","小学文凭")
  40. pig=Pig("wupeiqi",20,"female")
  41. dig=dig("haha",20,"male")
  42. #print(peo1.education)
  43. peo1.talk()
  44. pig.talk()
  45. dig.talk()

继承组合调用

  1. #组合也可以解决代码冗余问题，但是组合反映是一种什么有什么的关系
  3. class People:
  4. def __init__(self,name,age,sex):
  5. self.name=name
  6. self.age=age
  7. self.sex=sex
  9. # class Teacher(People):
  10. # def __init__(self,name,age,sex,salary):
  11. # People.__init__(self,name,age,sex)
  12. # self.salary=salary
  13. #
  14. # class Student(People):
  15. # pass
  17. class Date:
  18. def __init__(self,year,mon,day):
  19. self.year=year
  20. self.mon=mon
  21. self.day=day
  23. def tell(self):
  24. print(‘%s-%s-%s‘ %(self.year,self.mon,self.day))
  26. class Teacher(People):
  27. def __init__(self,name,age,sex,salary,year,mon,day):
  28. self.name=name
  29. self.age=age
  30. self.sex=sex
  31. self.salary=salary
  32. self.birth=Date(year,mon,day) #组合调用
  34. class Student(People):
  35. def __init__(self,name,age,sex,year,mon,day):
  36. self.name=name
  37. self.age=age
  38. self.sex=sex
  39. self.birth=Date(year,mon,day)
  41. t=Teacher(‘egon‘,18,‘male‘,3000,1995,12,31)
  42. t.birth.tell()
 
 
 

类查询对象顺序

  1. #先查C1的所有父类,有f2,匹配退出,如果没有,再查C1,有f2,匹配退出,都没有报错
  2. class C1:
  3. def f2(self):
  4. print("C1中的f2")
  6. class C2:
  7. def f2(self):
  8. print("C2中的f2")
  10. class C3(C1,C2):
  11. def f3(self):
  12. print("C3中的f3")
  14. obj=C3()
  15. obj.f2()
 

2种类

经典类:     
深度优先 (python2 ,特定是N条父类连接相同父父类, 第一条生效)
 
新式类:     
广度优先 (python2+python3 特定是N条父类连接相同父父类, 最后一条生效)
#python2中用新式类父父类要加object    例如class C0(object):

多继承

  1. #新式类, 特定是N条父类连接相同父父类, 最后一条生效
  2. #查询顺序 C3(自己)-C2-C1-C5-C4-C0
  3.  
  4. class C0:
  5. def test(self):
  6. print("C0")
  8. class C1(C0):
  9. # def test(self):
  10. # print("C1")
  11. pass
  13. class C2(C1):
  14. # def test(self):
  15. # print("C2")
  16. pass
  17. class C4(C0):
  18. # def test(self):
  19. # print("C4")
  20. pass
  22. class C5(C4):
  23. # def test(self):
  24. # print("C5")
  25. pass
  27. class C3(C2,C5):
  28. # def test(self):
  29. # print("C3")
  30. pass
  32. obj=C3()
  33. obj.test()
  34. print(C3.mro())     

  35. #mro显示执行过程(最后一位提供返回值) 执行C3的test函数,看执行过程

  36. #[<class ‘__main__.C3‘>, <class ‘__main__.C2‘>, <class ‘__main__.C1‘>, <class ‘__main__.C5‘>, <class ‘__main__.C4‘>, <class ‘__main__.C0‘>, <class ‘object‘>]
  37.  
 
super调用方法
  1.  
  2. class Animal:
  3. home="oldboy"
  4. def __init__(self,name,age,sex):
  5. self.name=name
  6. self.age=age
  7. self.sex=sex
  8. def eat(self):
  9. print("%s eat"%self.name)
  11. def takl(self):
  12. print("%s say"%self.name)
  13. class People(Animal):
  14. def __init__(self,name,age,sex,education):
  15. #Animal.__init__(self,name,age,sex) #这是调用父类初始化
  16. super().__init__(name,age,sex,) #这是调用父类初始化的另一种方法
  17. #super(People,self).__init__(name,age,sex,) #python2写法
  18. #print(super().home) #使用super.可直接调用父类的(对象,函数,变量) = print(Animal.home)
  19. self.education=education
  22. peo1=People("alex",18,"male","小学")
  23. print(peo1.__dict__) #不加__dict__是内存地址
  24. #{‘name‘: ‘alex‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘education‘: ‘小学‘}
  25. peo1.eat()
  26. #alex eat
  27. print(People.mro()) #查新式类最后调用
  28. #[<class ‘__main__.People‘>, <class ‘__main__.Animal‘>, <class ‘object‘>]
  30. #super的另一种含义是直接调用最后一个父类
  31. class A:
  32. def test(self):
  33. super().test() #此时的super是从<class ‘__main__.A‘>后 继续调用mro继续查看,继续则是C(B),得到B父类的test
  35. class B:
  36. def test(self):
  37. print(‘B‘)
  39. class C(A,B):
  40. pass
  42. # a=A()
  43. # a.test()
  45. print(C.mro())
  46. c=C()
  47. c.test()
  48. #[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
  49. #B
  51.  
  52.  
 

抽象类

#一个抽象类有多个子类，因而多态的概念依赖于继承
  1. #主要作用:函数规范 , 只要是调用这个父级的read函数 子级也必须用read
  2. import abc #利用abc模块实现抽象类
  4. class All_file(metaclass=abc.ABCMeta):
  5. all_type=‘file‘
  6. @abc.abstractmethod #定义抽象方法，无需实现功能
  7. def read(self):
  8. ‘子类必须定义读功能‘
  9. pass
  10. #定义其他抽象类就继续仿照read写
  12. class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
  13. def read(self):
  14. print(‘文本数据的读取方法‘)
  17. class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
  18. def read(self):
  19. print(‘进程数据的读取方法‘)
  21. guolm=Txt()
  22. qiqi=Process()
  24. #规范了必须用read函数, 如果把guolm的类中read函数名改变,就会报错
  25. #Can‘t instantiate abstract class Txt with abstract methods read
  27. guolm.read()
  28. qiqi.read()
  30. print(guolm.all_type)
  31. print(qiqi.all_type)
  33. # 文本数据的读取方法
  34. # 进程数据的读取方法
  35. # file
  36. # file
 
 

多态和多态性

多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承
#多态:调用父类有共同的参数,返回子类又增加各自子类的变化

多态性

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同功能的函数。
  1. import abc
  2. class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
  3. @abc.abstractmethod #抽象
  4. def talk(self):
  5. pass
  7. class People(Animal): #动物的形态之一:人
  8. def talk(self):
  9. print(‘say hello‘)
  11. class Dog(Animal): #动物的形态之二:狗
  12. def talk(self):
  13. print(‘say wangwang‘)
  15. class Pig(Animal): #动物的形态之三:猪
  16. def talk(self):
  17. print(‘say aoao‘)
  19. People=People()
  20. People.talk()
  22. Dog=Dog()
  23. Dog.talk()
  25. Pig=Pig()
  26. Pig.talk()
  27. # say hello
  28. # say wangwang
  29. # say aoao
 

 

 
 

封装

 
1 类把某些属性和方法隐藏起来(或者说定义成私有的,)只在类的内部使用,外部无法访问,或者留下少量接口(函数)供外部访问
隐藏封装
在内部使用__ 会调用值 在外部不成立
  1. #类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
  2. #这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
  3. #这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
  4.  
  5. #在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
  6. class People:
  7. def __init__(self,name,age,sex):
  8. self.__name=name
  9. self.__age=age
  10. self.__sex=sex
  11. def tell_info(self):
  12. #print("人的名字是:%s,\n人的性别是:%s,\n人的年龄是:%s "%(self.__name,self.__age,self.__sex))
  13. return "人的名字是:%s,人的性别是:%s,人的年龄是:%s "%(self.__name,self.__age,self.__sex)
  14. p=People("alex",18,"male")
  15. print(p.tell_info()) #显示结果
  16. #人的名字是:alex,人的性别是:18,人的年龄是:male
  18. print(p.__dict__) #显示p的字典状态
  19. #{‘_People__name‘: ‘alex‘, ‘_People__age‘: 18, ‘_People__sex‘: ‘male‘}

父子类函数同名,调用父类函数

  1.  
  2. class Parent:
  3.    __x=1
  4. def foo(self):
  5. print("from parent.foo")
  6. self.__bar() #值是完整文件名_parent__foo__bar, 相当于指定调用
  7. def __bar(self):
  8. print("from parent.bar")
  10. class Sub(Parent):
  11. def bar(self):
  12. print("from Sub.bar")
  13. s=Sub()
  14. s.foo()
  15. #from parent.foo #from parent.bar
  16. print(Parent.__dict__)      #看Parent的所以含义
    #{‘__module__‘: ‘__main__‘, ‘_Parent__x‘: 1, ‘foo‘: <function Parent.foo at 0x101448598>, ‘_Parent__bar‘: <function Parent.__bar at 0x1014486a8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Parent‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Parent‘ objects>, ‘__doc__‘: None}
 

super

根据mro查找
父类改变 子类只需要改变类调用 不需要改子类函数
  1. class Foo1: #父类名改变
  2. def test(self):
  3. print("from foo.test")
  4. class Bar(Foo1): #子类名改变,不需要改子类的test函数
  5. def test(self):
  6. #Foo.test(self) 相对于如下
  7. super(Bar,self).test() #使用super,父类改变 子类只需要改变类调用 不需要子类改函数
  8. print("bar222")
  9. a=Bar()
  10. a.test()
  11. #from foo.test #bar222
 

内置装饰器

内置的装饰器有三个：staticmethod(静态类方法) classmethod, 类方法  property
 
staticmethod,(静态类方法)
基本上跟一个全局函数相同，一般来说用的很少
 
classmethod
  • classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。 
  • 普通对象方法至少需要一个self参数，代表类对象实例
  • 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量
  1. staticmethod+classmethod实例
  2. setting.py文件
    1. host="192.168.1.1"
    2. port=3004
     
  5. import setting
  6. import uuid
  8. class Mysql:
  9. def __init__(self,host,port):
  10. self.host=host
  11. self.port=port
  12. self.id=self.create_id()
  14. @classmethod      #绑定方法,绑定给class类
  15. def from_conf(cls): #cls=Mysql()
  16. return cls(setting.host)
  17.                              #setting是模块,setting.host中host是模块变量
  19. def func(self): #绑定给object对象
  20. pass
  22. @staticmethod         #非绑定方法,变成普通函数,不绑定给类或对象
  23. def create_id():
  25. return str(uuid.uuid1())
  27. conn_one=Mysql("1.1.1.1",3306)
  28. conn_tow=Mysql.from_conf()
  29. print(conn_one.host)
  30. print(conn_tow.host)
  31. #1.1.1.1
  32. #192.168.1.1
  33. print(Mysql.from_conf) #这是显示绑定类
  34. #<bound method Mysql.from_conf of <class ‘__main__.Mysql‘>>
  35. print(Mysql.func) #这是显示绑定对象
  36. #<function Mysql.func at 0x101c287b8>
  37. print(conn_one.id) #这是显示非绑定方法
  38. #5da84770-81dc-11e7-9569-48bf6be5ec1a
 

property

计算bmi(健康状态)
  1. #定义好数值,外部传参 可修改数值
  2. class People:
  3. def __init__(self,name,weight,height):
  4. self.name=name
  5. self.weight=weight
  6. self.height=height
  7. @property #类似装饰器,装饰下边
  8. def bmi(self):
  9. return self.weight / (self.height ** 2)
  10. p=People("egon",75,1.80)
  11. p.height=1.84        #外部可改传参
  12. print(p.bmi)
  13. #22.152646502835537
 

封装之更改和删除

  1. class People:
  2. def __init__(self,name,permmission=False):      #permmission=False 定义默认值 用于增加权限  
  3. self.name=name
  4. self.permmission=permmission
  5. @property                                        #继承
  6. def name(self):
  7. return self.__name
  9. @name.setter    #装饰器增加增加功能
  10. def name(self,value):
  11. if not isinstance(value,str):
  12. raise TypeError("名字必须是字符串类型")
  13. self.__name=value
  15. @name.deleter    #装饰器增加删除功能
  16. def name(self):
  17. if not self.permmission:     #permminsion值为False   
  18. #这样写permmission值必须为True 加not为False, 而设置是permminsion值就是False
  19. raise PermissionError("不允许的操作")
  20. del self.__name
  21. p=People("egon")
  22. p.permmission=True
  23. del p.name
  25. 另一种方法 效果相同
    1. class People:
    2. def __init__(self,name,permmission=False):
    3. self.name=name
    4. self.permmission=permmission
    6. def get_name(self):
    7. return self.__name
    9. def set_name(self,value):
    10. if not isinstance(value,str):
    11. raise TypeError("名字必须是字符串类型")
    12. self.__name=value
    14. def del_name(self):
    15. if not self.permmission:
    16. raise PermissionError("不允许的操作")
    17. del self.__name
    18. name=property(get_name,set_name,del_name)
    19. p=People("egon")
     
  27.  
 
 
设计模式之单例模式(23,goF设计模式)
单例模式
    用来创建单个实例
 
技术分享
技术分享
 
练习:
1 对象调用class 显示调用次数
  1. #Foo是类
  2. #self是对象自己
  3. class Foo:
  4. count=0
  5. def __init__(self,x,y,z):
  6. self.x=x
  7. self.y=y
  8. self.z=z
  9. def aa(self):
  10. Foo.count+=1
  11. return Foo.count
  13. obj1=Foo("guolm",18,"linux")
  14. obj2=Foo("wy",28,"linux")
  15. obj3=Foo("haha",38,"yw")
  16. print(obj1.aa())
  17. print(obj2.aa())
  18. print(obj3.aa())
  19. print(obj3.aa())
  20. # 1
  21. # 2
  22. # 3
  23. # 4

python18-day7

标签：attr   活性   同名   sel   uuid   read   返回   index   host   

原文地址：http://www.cnblogs.com/Gavinkwok/p/7387998.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！