Python基本知识总结(二)

一、函数

1.高阶函数

• 变量可以指向函数

>>> x=abs
>>> x(-1)
1

 x变量指向了这个函数，并可以通过这个变量来调用这个函数了

• 函数名也是变量

>>> def sum(a,b):
...     return a+b
...
>>> sum=10
>>> sum(1,1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

把sum指向了10这个整数之后，不能通过sum(1,1)调用这个函数了。

• 传入函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

求绝对值之和：

>>> def add(x, y, f):
...     return f(x) + f(y)
...
>>> print(add(-5, 6, abs))
11

1.1  map函数

用法：map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

map()传入的第一个参数是f，即函数对象本身。由于结果z是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

>>> def f(x):
...     return -x
...
>>> z=map(f,[1,2,3,4,5])
>>> list(z)
[-1, -2, -3, -4, -5]

map()作为高阶函数，事实上它把运算规则抽象了,上面的代码对list中的每个值调用f函数，我们可以直接看出这是要计算相反数。

2.2  reduce函数

用法：reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

效果等价：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

例子：

>>> from functools import reduce
>>> def f(x,y):
...     return x*10+y
...
>>> reduce(f,[x for x in range(1,6)])
12345

2.3  filter函数

filter()函数用于过滤序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

>>> def is_odd(n):
...     return n%2==1
...
>>> list(filter(is_odd,[1,2,3,4,5,6,7,8,9]))
[1, 3, 5, 7, 9]

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

2.4 sorted函数

• 可以对直接对list进行排序

>>> sorted([3,2,4])
[2, 3, 4]

sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

• key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

>>> sorted([2,4,-3],key=abs)
[2, -3, 4]

• sorted函数还可以传入第三个参数

实现忽略大小写的排序，并进行反向排序：

>>> sorted(['abc','Cab','acb'],key=str.lower,reverse=True)
['Cab', 'acb', 'abc']

2.返回函数

2.1 函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

>>> def lazy_sum(*args):
...     def sum():
...             s=0
...             for n in args:
...                     s=s+n
...             return s
...     return sum
...
>>> f=lazy_sum(1,2,3,4,5)
>>> f
<function lazy_sum.<locals>.sum at 0x00000202F6F4A438>

调用函数f时，才真正计算求和的结果：

>>> f()
15

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种程序结构称为“闭包（Closure）”。

当调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1=lazy_sum(1,2,3,4,5)
>>> f2=lazy_sum(1,2,3,4,5)
>>> f1==f2
False

2.2 闭包

闭包中返回的函数并没有立刻执行，而是直到调用了f()才执行。

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

 全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

>>> f1()
9
>>> f2()
9
>>> f3()
9

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

3.匿名函数

用法：关键字lambda表示匿名函数，冒号前面的x表示函数参数。

举例：还是以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还可以直接传入匿名函数。

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

 用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

>>> f=lambda x:x*x
>>> f
<function <lambda> at 0x0000012B8E0DA0D8>
>>> f(2)
4

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y

4.装饰器

定义：在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

(我自己就没怎么看懂用法，然后电脑蓝屏导致我写的博客内容都没了，这部分不写了）

5.偏函数

functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

举例：将字符串转换为数值，以二进制方式转换，int方法本身就接受一个base参数的，默认值10，定义了int2这个偏函数之后，之后就直接调用这个int2方法，而不需要每次都将给int方法多传参数很麻烦。

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64

二、面向对象编程

1.类和实例

通过定义一个特殊的__init__方法，在创建实例的时候，就把自己需要的属性绑上去。而__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

class Student(object):
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender

    def print_gender(self):
        print('%s:%s'%(self.name,self.gender))

me=Student('zw','女')
me.print_gender()

2.访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

外部代码要实例中属性值通过定义的get方法获取，要修改属性值通过set方法修改，总之就是不能直接访问和修改属性的值。

class Student(object):
    def __init__(self,name,gender):
        self.__name=name
        self.__gender=gender
    
    def get_name(self):
        return self.__name

    def set_name(self,value):
        self.__name=value

3.继承和多态

• 继承

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类。

举例：

class Animal(object):
    def run(self):
        print('Animal')

class Cat(Animal):
    pass

class Dog(Animal):
    pass

• 多态

在子类中存在相同的run方法时，子类中的方法会覆盖父类中的run方法，而代码在运行的时候，总会调用子类的run方法，这就实现了多态。

class Animal(object):
    def run(self):
        print('Animal')

class Cat(Animal):
    def run(self):
        print('Cat')

class Dog(Animal):
    def run(self):
        print('Dog')

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat对象上，由运行时该对象的确切类型决定，这就是多态真正的好处。

4.获取对象信息

• 使用type()

基本类型都可以使用type()判断

>>> type(123)
<class 'int'>
>>> type('zw')
<class 'str'>

判断一个对象是否是函数：可以使用types模块中定义的常量

>>> import types
>>> def f():
...     pass
...
>>> type(f)==types.FunctionType
True

• 使用isinstance()

对于class的继承关系来说，使用type()就很不方便。要判断class的类型，可以使用isinstance()函数。

假设继承关系为：

object -> Animal -> Dog

isinstance()就可以判断一个对象是否是某种类型。 

>>> class Animal(object):
...     pass
...
>>> class Dog(Animal):
...     pass
...
>>> a=Animal()
>>> d=Dog()
>>> isinstance(d,Dog)
True

虽然d是Dog类型，但是Dog是从Animal上继承下来的，所以d还是Animal类型。换句话说，isinstance()判断的是一个对象是否是该类型本身，或者位于该类型的父继承链上。

>>> isinstance(d,Animal)
True

 并且还可以判断一个变量是否是某些类型中的一种，比如下面的代码就可以判断是否是list或者tuple：

>>> isinstance([1,2],(list,tuple))
True

• 使用dir()

如果要获得一个对象的所有属性和方法，可以使用dir()函数，如果要获得一个对象的所有属性和方法，可以使用dir()函数

5.实例属性和类属性

给实例绑定属性的方法是通过实例变量，或者通过self变量：

class Student(object):
    def __init__(self,name):
        self.name=name

s=Student('zw')
s.score=100

如果一个类需要绑定一个属性，可以直接在class中定义，这种属性为类属性，归这个class所有，这个类的所有实例都能访问到。

class Student(object):
    major='计算机科学与技术'

zw=Student()
print(zw.major)

zz=Student()
print(zz.major)