@classmethod
    def how_many(cls):
        return cls.__count

classmethod可以调用类自身的属性，不需要实例化

cmp函数的定义方式

vvv

因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数：

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数：

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

函数式编程

Python 函数

python基础

尝试修改string的值（导致“TypeError: 'str' object does not support item assignment”）

string是一种不可变的数据类型，

import math
class Rational(object):
    def __init__(self, p, q):
        self.p = p
        self.q = q

    def __add__(self, r):
        s=math.gcd(self.p * r.q + self.q * r.p, self.q * r.q)
        return Rational((self.p * r.q + self.q * r.p)/s, (self.q * r.q)/s)

    def __sub__(self, r):
        s=math.gcd(self.p * r.q - self.q * r.p, self.q * r.q)
        return Rational((self.p * r.q - self.q * r.p)/s, (self.q * r.q)/s)

    def __mul__(self, r):
        s=math.gcd(self.p * r.p , self.q * r.q)
        return Rational((self.p * r.p)/s , (self.q * r.q)/s)

    def __truediv__(self, r):
        s=math.gcd(self.p * r.q , self.q * r.p)
        return Rational((self.p * r.q)/s , (self.q * r.p)/s)

    def __str__(self):
        return str(self.p)+"/"+str(self.q)

    __repr__ = __str__

r1 = Rational(1, 2)
r2 = Rational(1, 4)
print (r1 + r2)
print (r1 - r2)
print (r1 * r2)
print (r1 / r2)

python3完美运行，python2就报错

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

class Person(object):

    __slots__ = ('name', 'gender')

    def __init__(self, name, gender):

        self.name = name

        self.gender = gender

class Student(Person):

    __slots__ = ('score')

    def __init__(self, name, gender, score):

        super(Student, self).__init__(name, gender)

        self.score = score

s = Student('Bob', 'male', 59)

s.name = 'Tim'

s.score = 99

print s.score

def gcs(a,b,c=1):

    if 0==a%2 and 0==b%2:

        return gcs(a/2,b/2,c*2);

    s = abs(a-b)

    m = min(a,b)

    if s == m:

        return m*c

    return gcs(s,m,c)

class Fib(object):

    def __init__(self, num):

        a, b, L = 0, 1, []

        for n in range(num):

            L.append(a)

            a, b = b, a + b

        self.nums = L

    def __str__(self):

        return str(self.nums)

    __repr__ = __str__

    def __len__(self):

        return len(self.nums)

f = Fib(10)

print f

print len(f)

def format_name(s):

    return s.title()

print map(format_name, ['adam', 'LISA', 'barT'])

加个负号作用就是从大到小排序。

class Person(object):

    __count = 0

    @classmethod

    def how_many(cls):

        return cls.__count

    def __init__(self, name):

        self.name =name

        Person.__count += 1

print Person.how_many()

p1 = Person('Bob')

print Person.how_many()

class Person(object):

    __count = 0

    def __init__(self, name):

        self.__name = name

        Person.__count += 1

        print Person.__count

p1 = Person('Bob')

p2 = Person('Alice')

try:

    print Person.__count

except Exception as e:

    print 'attributeerror'

不是很懂