斐波那契数列

数学函数

有必要注意的是，返回函数和返回函数值的语句是非常类似的，返回函数时，不能带小括号，而返回函数值时，则需要带上小括号以调用函数。

# 返回函数
def myabs():
   return abs

# 返回函数值
def myabs(x):
   return abs(x)

math 就相当于一个工具箱，import math，相当于把工具箱搬到家中了，但是你工具箱不打开是用不了工具的。或者说家里还有别的工具箱，你要用工具的话，必须先找到对工具箱math，然后再用工具sin，所以用 math.sin().

sin（）相当于一件具体的工具，from math import sin，相当于你直接从工具箱中拿出了工具，所以可以直接用。如：sin（100）

而 from math import * ,相当于把工具箱工具一股脑倒在了地上，你可以直接用，想用哪一个就用哪一个。

a=0

b=1

注意

a=b

b=a+b                与 a,b = b,a+b 两个句式的区别。

Python判断类型

随着我们学习步伐的前进，我们的程序会出现越来越多的类型，有我们自己定义的类，也有Python自有的str、list、dict等，他们的本质都是都是Python中的一种数据类型，这时有必要去判断数据的类型，通过函数isinstance()可以判断一个变量的类型。

class Person(object):     def __init__(self, name, gender):         self.name = name         self.gender = gender class Student(Person):     def __init__(self, name, gender, score):         super(Student, self).__init__(name, gender)         self.score = score class Teacher(Person):     def __init__(self, name, gender, course):         super(Teacher, self).__init__(name, gender)         self.course = course p = Person('Tim', 'Male') s = Student('Bob', 'Male', 88) t = Teacher('Alice', 'Female', 'English')

当我们拿到变量 p、s、t 时，可以使用 isinstance 判断类型：

>>> isinstance(p, Person) True # p是Person类型 >>> isinstance(p, Student) False # p不是Student类型 >>> isinstance(p, Teacher) False # p不是Teacher类型

这说明在继承链上，一个父类的实例不能是子类类型，因为子类比父类多了一些属性和方法。
我们再考察 s：

>>> isinstance(s, Person) True # s是Person类型 >>> isinstance(s, Student) True # s是Student类型 >>> isinstance(s, Teacher) False # s不是Teacher类型

s 是Student类型，不是Teacher类型，这很容易理解。但是，s 也是Person类型，因为Student继承自Person，虽然它比Person多了一些属性和方法，但是，把 s 看成Person的实例也是可以的。

这说明在一条继承链上，一个实例可以看成它本身的类型，也可以看成它父类的类型。

isinstance也可以用于Python自有数据类型的判断。

s = 'this is a string.' n = 10 isinstance(s, int) # ==> False isinstance(n, str) # ==> False

通过函数isinstance()可以判断一个变量的类型。

lass Student(Person):
   def __init__(self, name, gender, score):
       super(Student, self).__init__(name, gender)
       self.score = score

student = Student('Alice', 'girl', 100)
print(student.name) # ==> Alice
print(student.gender) # ==> girl
print(student.score) # ==> 100

在定义继承类的时候，有几点是需要注意的：

class Student()定义的时候，需要在括号内写明继承的类Person

在__init__()方法，需要调用super(Student, self).__init__(name, gender)，来初始化从父类继承过来的属性

Python定义类方法

在上一节课，为了操作实例对象的私有属性，我们定义了实例方法；同样的，如果需要需要操作类的私有属性，则应该定义类的方法。
默认的，在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。
要在class中定义类方法，需要这么写：

class Animal(object):     __localtion = 'Asia'     def __init__(self, name, age):         self.name = name         self.age = age     @classmethod     def set_localtion(cls, localtion):         cls.__localtion = localtion     @classmethod     def get_localtion(cls):         return cls.__localtion print(Animal.get_localtion()) # ==> Asia Animal.set_localtion('Afica') print(Animal.get_localtion()) # ==> Africa

和实例方法不同的是，这里有两点需要特别注意：

类方法需要使用@classmethod来标记为类方法，否则定义的还是实例方法

类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.__localtion 实际上相当于Animal.__localtion。

Python定义实例方法

上一节课提到，私有属性没有办法从外部访问，只能在类的内部操作；那如果外部需要操作私有属性怎么办？这个时候可以通过定义类或者实例的方法来操作私有属性，本节课先来介绍实例方法。
实例的方法指的就是在类中定义的函数，实例方法的第一个参数永远都是self，self是一个引用，指向调用该方法的实例对象本身，除此以外，其他参数和普通函数是完全一样的。

class Person(object):     def __init__(self, name):         self.__name = name     def get_name(self):         return self.__name

在上面的定义，name是实例的私有属性，从外部是无法访问的，而get_name(self) 就是一个实例方法，在实例方法里面是可以操作私有属性的，注意，它的第一个参数是self。
另外，__init__(self, name)其实也可看做是一个特殊的实例方法。
通过定义get_name(self)方法，在外部就可以通过这个方法访问私有属性了。

p = Person('Alice') print(p.get_name()) # ==> Alice

注意，在外部调用实例方法时，是不需要显式传递self参数的。

在类属性和实例属性同时存在的情况下，实例属性的优先级是要高于类属性的，

__init__ 这里是双下划线

Python类的定义与实例化

class Person:  pass
class Person(): pass
class Person(object):  pass

定义了类之后，就可以对类进行实例化了，实例化是指，把抽象的类，赋予实物的过程。比如，定义好Person这个类后，就可以实例化多个Person出来了。
创建实例使用类名+()，类似函数调用的形式创建：

class Person(object):  pass xiaohong = Person() xiaoming = Person()

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)

重点