Python 进阶语法

一.函数式编程

1 高阶函数
1.1 map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
def f(x):
return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

#:[1, 4, 9, 10, 25, 36, 49, 64, 81]
map()函数不改变原有的 list，而是返回一个新的 list。

1.2 reduce()函数是Python内置的高阶函数。reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
例如，编写一个f函数，接收x和y，返回x和y的和：

def f(x, y):
return x + y


调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：
先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。

1.3 filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：


def is_odd(x):
return x % 2 == 1

然后，利用filter()过滤掉偶数：
filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

#：[1, 7, 9, 17]

1.4 s orted()是内置的高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。
#实现倒序排序

def reversed_cmp(x, y):
if x > y:
return -1
if x < y:
return 1
return 0
sorted([36, 5, 12, 9, 21], reversed_cmp)

#:[36, 21, 12, 9, 5]

2 匿名函数
lambda x: x * x
#等价于
def f(x):
return x * x

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。


3 装饰器


二.模块和包


避免名字冲突


包与目录的区别：包内必有__init__.py文件, 目录则没有


三.面向对象


1.类和实例
类是对现实世界某种类型物体的抽象，是一种模型
实例是类的对象，是具体的事物
class Person(): #类
pass
kk = Person() #实例
jj = Person() #实例


2.属性和方法
如果一个属性以__开头，则外部无法访问该属性(私有)
如果一个属性以_开头，则外部可以访问该属性，但是按照习惯最好不要访问该属性(保护)

3.类属性和实例属性
class Person():
count = 0 #类属性
def __init__(self,name):
self.name = name #self.name是实例属性
Person.count += 1 #调用类属性


4.继承
4.1 单继承
4.2 多重继承
4.3 多态
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def whoAmI(self):
return 'I am a Person, my name is %s' % self.name


class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
def whoAmI(self):
return 'I am a Student, my name is %s' % self.name


class Teacher(Person):
def __init__(self, name, gender, course):
super(Teacher, self).__init__(name, gender)
self.course = course
def whoAmI(self):
return 'I am a Teacher, my name is %s' % self.name

在一个函数中，如果我们接收一个变量 x，则无论该 x 是 Person、Student还是 Teacher，都可以正确打印出结果：


def who_am_i(x):
print x.whoAmI()


p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')


who_am_i(p)
who_am_i(s)
who_am_i(t)

运行结果：
I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice


这种行为称为 多态。也就是说， 方法调用将作用在 x 的实际类型上。s 是Student类型，它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法，
但调用 s.whoAmI()总是先查找它自身的定义，如果没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。


由于Python是动态语言，所以，传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。
任何数据类型的实例都可以，只要它有一个whoAmI()的方法即可

5.定制类
类的特殊方法：
__str__()
将一个类的实例变成字符串

__repr__()
将一个类的实例变成字符串

__cmp__()
类的实例之间的比较

__len__()
类的长度

__slots__()
指定类的元素个数

__call__()
类的实例调用

__add__()
类的+

__sub__()
类的-

__mul__()
类的*

__div__()
类的/