Python笔记

此笔记大部分内容为慕课网中学习廖雪峰python课程记录而来，一部分从网上查找资料记录。

1、函数默认参数问题

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
# OK:
def fn1(a, b=1, c=2):
pass
# Error:
def fn2(a=1, b):
pass

2、集合是指包含一组元素的数据结构

1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict

3、map()函数

接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

4、reduce()函数

reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
reduce()还可以接收第3个可选参数，作为计算的初始值。

5、filter()函数

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

6、sorted()函数

接收一个比较函数来实现自定义排序。
比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

7、闭包

闭包的特点是返回的函数还引用了外层函数的局部变量,会引起数据的延迟。
[https://blog.csdn.net/m0_37693335/article/details/79568350]
闭包一定要有自由变量，这个自由变量产生有两个条件：一是内层函数去引用了外层函数的变量，二是内层函数被调用时，外层函数已经不见了，所以变量才会自由

8、匿名函数lambda

lambda x:x>1

9、函数装饰器

1.无参数decorator
定义一个@log

def log(f):
    def fn(x):
        print 'call ' + f.__name__ + '()...'
        return f(x)
    return fn

调用log

@log
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

2.带参数

import time

def log(unit):
    def fn(f):
        def mfn(*args,**kw):
            print unit+" call "+f.__name__+'()'
            return f(*args,**kw)
        return mfn
    return fn
@log('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

3.完善
使用decorator的函数后，函数名会发生改变，如果不希望其改变，还需要对其赋值。

def log(f):
	def mfn(*args,**kw)	
		print 'call..'
		return f
	mfn.__name__=f.__name__
	mfn.__doc__=f.__doc__
	return mfn

由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数：

10、*args,**kwargs

args表示任何多个无名参数，它是一个tuple；**kwargs表示关键字参数，它是一个dict。并且同时使用args和**kwargs时，必须*args参数列要在**kwargs前。

11、偏函数functools.partial

为减少一些已写好的函数的参数的输入次数。

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

12、__future__

要在Python 2.7中引入3.x的除法规则，导入__future__的division：

from __future__ import division
>>> print 10 / 3
3.3333333333333335 

13、类属性与实例属性

当实例属性和类属性重名时，实例属性优先级高

14、MethodType

MethodType可以把外部函数(方法)绑定到类或类的实例中：参考文章

python2用法
1.将方法绑定到类中

a1 = myClass()
#将方法绑定到a1实例中
a1.set_name = MethodType(set_name, a1, myClass)
#使用刚绑定的方法
a1.set_name('s2')
#输出
print(s1.name)#s1

2.把方法绑定到类中（无None参数）

myClass.set_name = MethodType(set_name,myClass)

通过该类创建的实例的该方法都会指向相同的区域，导致后面实例的值会覆盖前面实例的值。
3.把方法绑定到类中（有第二个参数None）

myClass.set_name = MethodType(set_name,None,myClass)

MethodType把方法绑定在类上且有第二个None参数时，相当于没指定给哪个实例绑定此方法，则默认为该类的全部实例都绑定上此方法。这种情况下和绑定到实例上效果一样，通过该类创建的实例会指向各自不同的区域，各个实例之间的方法和name属性互不干扰。
python3用法
anotherRef=types.MethodType(methodName,instance)
第一个参数为一个方法名称
第二个参数是一个实例对象，表示将 method 绑定到instance对象上，

1.绑定到实例中：

s1.set_name = MethodType(set_name, s1)

与python2相比MethodType()只接收两个参数，即去掉了所属类的参数。也就没有为全部实例绑定该方法的情况了

2.把方法绑定到类中（情况只有一种了，如上面python2的没有None参数）

Student.set_name = MethodType(set_name,Student)

15、多态

read()方法，就称为File-like Object，都可以传给json.load()。

import json
class Students(object):
    def __init__(self):
        pass
    def read(self):
        return r'["Tim", "Bob", "Alice"]'

s = Students()

print json.load(s)

16、特殊方法

1.__str__
__str__()用于显示给用户，而__repr__()用于显示给开发人员。

def __str__(self):
	 return '(Person: %s, %s)' % 
>>> p = Person('Bob', 'male')
>>> print p
(Person: Bob, male)
__repr__ = __str__
p #定义repr后，可直接使用P

2.__cmp__
Python的 sorted() 按照默认的比较函数 cmp 排序，但是，如果对一组 Student 类的实例排序时，就必须提供我们自己的特殊方法 __cmp__()：

def __cmp__(self, s):
        if self.score==s.score:
            return cmp(self.name,s.name)
        return -cmp(self.score,s.score)

3.__len__
就可以用len()函数返回实例的“长度”

def __len__(self):
	 return len(self.numbers)

4.数学运算

def __add__(self, r):
	return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
def __sub__(self, r):
	return Rational(self.p * r.q - self.q * r.p, self.q * r.q)
def __mul__(self, r):
	return Rational(self.p * r.p, self.q * r.q)
def __div__(self, r):
	return Rational(self.p * r.q, self.q * r.p)
def __str__(self):
	g = gcd(self.p, self.q)
	return '%s/%s' % (self.p / g, self.q / g)

5.类型转换

class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q
    def __int__(self):	#可转换为int
        return self.p // self.q
    def __float__(self):	#可转换为float
        return float(self.p)/self.q
print float(Rational(7, 2))
print float(Rational(1, 3))

6.@property
第一个score(self)是get方法，用@property装饰。
第二个score(self, score)是set方法，用@score.setter装饰；@score.setter是前一个@property装饰后的副产品。

    @property		#get方法
    def score(self):
        return self.__score
    @score.setter		#set方法
    def score(self, score):
        if score < 0 or score > 100:
            raise ValueError('invalid score')
        self.__score = score

7、__slots__
python可以动态地添加属性，可通过__slot__限制，__slots__的目的是限制当前类所能拥有的属性，如果不需要添加任意动态的属性，使用__slots__也能节省内存。

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

>>> s = Student('Bob', 'male', 59)
>>> s.name = 'Tim' # OK
>>> s.score = 99 # OK
>>> s.grade = 'A'
Traceback (most recent call last):
  ...
AttributeError: 'Student' object has no attribute 'grade'

8、__call__
一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

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