class A(object):
   def __init__(self, a):
       print ('init A...')
       self.a = a

class B(A):
   def __init__(self, a):
       super(B, self).__init__(a)
       print ('init B...')

class C(A):
   def __init__(self, a):
       super(C, self).__init__(a)
       print ('init C...')

class D(C, B):
   def __init__(self, a):
       super(D, self).__init__(a)
       print ('init D...')

d=D('d')

结果（class D(C,B) ==> 先执行B再执行C）：

          init A...

          init B...

          init C...

          init D...

在类属性和实例属性同名的情况下，实例属性的优先级是要高于类属性的，在操作实例的时候，优先是操作实例的属性。

import time

def performance(unit):

    def perf_decorator(f):

        def wrapper(*args, **kwargs):

            t1 = time.time()

            r = f(*args, **kwargs)

            t2 = time.time()

            t = (t2 - t1) * 1000

            if unit == 'ms':

                t = (t2 - t1) * 1000 * 1000

            print('call {}() in {}{}'.format(f.__name__,t,unit))

            return r

        return wrapper

    return perf_decorator

@performance('ms')

def factorial(n):

    return reduce(lambda x,y:x + y,range(1, n+1))

factorial(10)

import time

def performance(f):

    def fn(*args, **kw):

        t1 = time.time()

        r = f(*args, **kw)

        t2 = time.time()

        print('call %s() in %fs' %(f.__name__,(t2 - t1)))

        return r

    return fn

@performance

def ffa(n):

    return reduce(lambda x,y: x + y, range(1,n+1))

print(ffa(10))

# Enter a code

import socket

server = socket.socket() # 1.新建 socket

server.bind(('127.0.0.1', 8999)) # 2.绑定IP和端口(其中127.0.0.1为本机回环IP)

server.listen(5) # 3.监听连接

s, addr = server.accept() #4. 接受连接

print('connect addr :{}'.format(addr))

content = s.recv(1024)

print(str(content, encoding = 'utf-8')) #接受来自客户端的消息，并编码打印出来\

s.close()

import socket

client = socket.socket() #1.新建socket

client.connect(('127.0.0.1', 8999)) #2.连接服务端(注意，IP和端口要和服务端一致)

client.send(bytes('hello world, hello socket', encoding = 'utf-8')) #发送内容，注意发送的是字节字符串

client.close()

注意应该是self 不是类名

  在上面的代码中，localtion就是属于Animal这个类的类属性，此后，通过Animal()实例化的所有对象，都可以访问到localtion，并且得到唯一的结果。

  类属性也是可以动态添加和修改的，需要注意的是，因为类属性只有一份，所以改变了，所有实例可以访问到的类属性都会变更：

注意应该是Animal（类名） 不是self

# Enter a code

class Fib(object):

    def __init__(self, num):

        self.num = num

        self.res = []

        a = 0

        b = 1 

        for x in range(num):

            self.res.append(a)

            a,b = b, a + b

    def __str__(self):

        return str(self.res)

    def __len__(self):

        return self.num

fib = Fib(10)

print(fib)

print(len(fib))

# Enter a code

class Person(object):

    def __init__(self, name, gender, **kw):

        self.name = name

        self.gender = gender

        for k, v in kw.items():

            setattr(self, k, v)

p = Person('Bob', 'Male', age=18, course='Python')

print(p.age)

print(p.course)

重点

1.类的私有属性以__开头，无法通过外部访问，只能通过内部方法访问，为了保护类或实例属性不被外部污染而设计的。

4-4  Python类的数学运算

1. 如何理解def __add__(self, r):
          return Rational(self.p * r.q + self.q * r.p, self.q * r.q)

   >>> r1 = Rational(1, 2)
   >>> r2 = Rational(2, 3)
   >>> print(r1 + r2)
   

思路过程：

不理解r是什么，后面经过查找，代码存在r1+r2时才会调用__add__()函数，此时self.p和self.q指的是r1的p和q，而r.p和r.q指的是r2.p和r2.q

也就是 (1*3+2*2)/2*3 有理数的答案

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __add__(self, r):
        return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
    def __str__(self):
        return '{}/{}'.format(self.p, self.q)
        
    
r1 = Rational(1, 2)
r2 = Rational(2, 3)
r3 = Rational(1, 6)
print(r1+r2)
print(r1.__add__(r2))

重载运算符：

r1+r2 和

r1.__add__(r2) 相同

class Fib(object):
    def __init__(self,num):
        self.num=num
    
    def __len__(self):
        return len(self.num)

f = [0,1,1,2,3,5,8,13,21,34]
f_ = Fib(f)

print(f)
print(len(Fib(f)))

Fib是一个类

f_ 是这个类的一个实例，等同于Fib(f)

f 是一个列表，也是f_ 的属性