Python详细学习笔记+总结 第三天

面向对象

class Student(object):
    def __int__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))



类和实例
类名 首字母大写
(object) 继承

stu = Student()



数据封装

访问限制
__ 私有private

class Student(Object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')



__xxx__ 特殊变量

继承和多态
父类、基类、超类
子类

class Animal(object):
    def run(self):
        print('An animal is running')
class Dog(Animal):
    def run(self):
        print('A dog is running')
class Cat(Animal):
    def run(self):
        print('A cat is running')



覆盖

多态
调用方只管调用,不管细节

开闭原则
对扩展开放 允许新增子类,新增实现
对修改封闭 不需要修改依赖基类的各方

鸭子类型
静态语言 Java
不一定需要传入Animal类型,只需要传入对象拥有run()方法

获取对象信息
type() 判断对象类型,基本类型、函数

import types
def fn():
    pass
type(fn) == types.FunctionType
True
type(abs) == types.BuiltinFunctionType
True
type(lambda x: x) == types.LambdaType
True
type((x for x in range(10))) == types.GeneratorType
True
isinstance()
isinstance([1, 2, 3], (list, tuple))
True
isinstance((1, 2, 3), (list, tuple))
True

dir()
获得一个对象的所有属性和方法

s = ''
dir(s)



实例属性和类属性
名称相同,实例属性将屏蔽掉类属性

class Person(object):
    name = 'Tom'
p = Person()
p.age = 12
print(Person.name, p.age)
Tom 12



封装、继承、多态
动态增加属性和方法

class Student(object):
    def __init__(self):
        print('Instance Created')
Tracy = Student()
Tracy.age = 22
def set_age(self, age):
    self.age = age
from types import MethodType
s = Student()
s.set_age = MethodType(set_age, s)
s.set_age(22)
print(s.age)
22
Student.set_age = set_age
Ceaser = Student()
Ceaser.set_age(22)



__slots__
对子类对象无效

class Student(object):
    __slots__ = ('name', 'age') #允许绑定的属性名称



@property
方法变属性

class Student(object):
    @property
    def score(self):
        return self._score
    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0~100!')
        self._score = value
s = Student()
s.score = 60
s.score
60



只读属性
只定义getter方法

class Student(object):
    @property
    def birth(self):
        return self._birth
    @birth.setter
    def birth(self, value):
        self._birth = value
    @property
    def age(self):
        return 2017 - self._birth



多重继承
一个子类,获得多个父类的所有功能

class Animal(object):
    pass



#大类

class Mammal(Animal):
    pass
class Bird(Animal):
    pass



#动物

class Dog(Mammal):
    pass
class Ostrich(Bird):
    pass
class Runnable(object):
    def run(self):
        print('running')
class Flyable(object):
    def fly(self):
        print('flying')
class Dog(Mammal, Runnable):
    pass
class Bat(Mammal, Flyable):
    pass
d = Dog()
d.run()
running



网络服务
TCPServer、UDPServer
多进程模型、多线程模型
ForkingMixIn、ThreadingMixIn

定制类
__slots__

__str__
相当于Java的toString()

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object(name: %s)' % self.name
m = Student('Michael')
Student object(name: Michael)
__repr__
class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object(name: %s)' % self.name
    __repr__ = __str__
__getitem__
class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int):
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice):
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L
f = Fib()
print(f.__getitem__(1))
1
print(f[0:10])
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]



__getattr__
动态返回属性

class Student(object):
    def __init__(self):
        self.name = 'Kobe'
    def __getattr__(self, attr):
        if attr == 'score':
            return 99
s = Student()
print(s.score)
99

__call__
对象变函数

class Student(object):
    def __init__(self, name):
        self.name = name
    def __call__(self):
        print('My name is %s.' % self.name)
s = Student('James')
s()
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __call__(self, friend):
        print(self.name, self.gender, ', my friend:', friend)
p = Person('Bob', 'male')
p('Jack')
Bob male , my friend: Jack

枚举类
常量

from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
Jan => Month.Jan , 1
Feb => Month.Feb , 2
Mar => Month.Mar , 3
Apr => Month.Apr , 4
May => Month.May , 5
Jun => Month.Jun , 6
Jul => Month.Jul , 7
Aug => Month.Aug , 8
Sep => Month.Sep , 9
Oct => Month.Oct , 10
Nov => Month.Nov , 11
Dec => Month.Dec , 12
print(Month.Jan)
Month.Jan
print(Month.Jan.name)
Jan
print(Month.Jan.value)
1
for enum import Enum, unique
@unique
class Weekday(Enum):
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
print(Weekday.Sun)
Weekday.Sun
print(Weekday.Sun.name)
Sun
print(Weekday.Sun.value)
0



元类
type()
创建类型
Hello是一个class,类型为type,h是一个实例,类型为Hello

def fn(self, name='world'):
    print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=fn))
h = Hello()
h.hello()
Hello, world.
print(type(Hello))
<class 'type'>
print(type(h))
<class '__main__.Hello'>



3个参数
类名
父类集合,多重继承,tuple单元素写法,与小括号运算符区分
绑定属性

metaclass 元类
拦截类的创建、修改类
先定义类,然后创建实例
先定义元类,然后创建类

MyClass = MetaClass()
obj = MyClass()
MyClass = type('MyClass', (), {})
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)
ListMeta = type('ListMetaclass', (), {})
print(ListMeta)
<class '__main__.ListMetaclass'>
l = ListMeta()
l.age = 12
print(l.age)
12

上一篇:Python详细学习笔记+总结 第四天

下一篇:Python详细学习笔记+总结 第二天