python笔记 ---蛋疼的 动态类型+强类型语言

基础篇

1. List tuple（元素不能改变的list，但是指针指向可以变）
2. Dict（就是map） ；set：s = set([‘A’, ‘B’, ‘C’]) （特点：去重，无序）
3. 切片 ： L[0:3]， 包头不包尾， 切了3个元素的列表出来

```
L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L[-2:]
['Bart', 'Paul']

>>> L[:-2]
['Adam', 'Lisa']

注意倒序切片的写法

 4 列表生成式 特色功能

[x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
**range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]**

5.raw     ：多行字符串 （好东西）
6.u'中文'  ：直接转Unicode 也是好东西

函数篇

1.map（）函数 ：

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]

2.reuduce（）

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。

其实就是 list求和 ，跟sum一样

3.filter( )

def is_odd(x)
    return x % 2 == 1
然后，利用filter()过滤掉偶数：

filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
结果：[1, 7, 9, 17]

4.sort 排序 可自定义comparator函数

sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]

4.1 int() 函数可以把字符串转换为整数 ，默认十进制

5.闭包 （即私有化函数）

def f():
    print 'f()...'
    def g():
        print 'g()...'
    return g

6.装饰器 可以在new_f(n)里对f(n)进行修饰

@new_f(n)
def f(n): 
    return n*n;

一般用于：
打印日志 @log
检测性能@perfomance
数据库加事务 @trasaction

装饰器理解 ： python中 一切皆对象！
函数的返回值还是 一个函数，而且 函数还是第一类对象！
所谓第一类对象，就是可以用标识符给对象命名，或者赋值，传递，返回等等。

注意混淆点：

def func():
    return "hello,world"
ref1 = func      #将函数对象赋值给ref1
ref2 = func()       #调用函数，将函数的返回值("hello,world"字符串)赋值给ref2

1. 偏函数： 就是自己定义一个偏好函数

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

python的面向对象

_ _ f(n) 私有方法

init(self) 构造方法
因为第一个参数name被Python解释器传入了实例的引用,,所以必须是self

实例方法 ： 实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身 （就是非静态方法 ， self可不显示调用）

类方法 （就是静态方法） ，通过标记一个 @classmethod，该方法将绑定到 Person 类上

class Person(object):
    count = 0
    @classmethod
    def how_many(cls):
        return cls.count

Python的类

继承 class Student(Person)：
麻烦点：一定要用 super(Student, self).init(name, gender)
去初始化父类，
多态 ：其中有一个重要区别 ：动态语言和静态语言（例如Java）最大的差别之一。动态语言调用实例方法，不检查类型，只要方法存在，参数正确，就可以调用。

抛异常 raise ValueError(‘invalid score’)

装饰器写法的 set/get ：

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

，slots是指一个类允许的属性列表：

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

所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法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

对Person的实例调用就能写成：

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

ps :其实只看p（） 无法确定是函数还是对象呐 不严谨的语言!