改了之后就无法通过类去访问了，只能通过实例去访问。

通过urllib包获取向http服务器发起请求，并获取返回信息。

Python

pass表示什么也不做，直接跳过，避免程序报错

# Enter a code

class Animal(object):

    localtion = 'Asia'

    count = 0

    def __init__(self,name,age):

        self.name=name

        self.age=age

        Animal.count+=1

dog = Animal('wangwang',1)

print(Animal.count)

cat = Animal('xiaomao',2)

print(Animal.count)

print(Animal.localtion)

Animal.localtion = 'Africa'

print(dog.localtion,Animal.localtion)

# Enter a code

class Animal(object):

    def __init__(self,name,age,sex):

        self.name = name

        self.age = age

        self.sex = sex

dog = Animal('xiaogou',1,'boy')

cat = Animal('xiaomao',2,'girl')

print(dog.name)

print(cat.age)

print(dog.xx)

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

pass要和class同行

dog要和class同列，并不需要缩进

-类属性和实例属性同时存在的情况下，实例属性的优先级是要高于类属性,在操作实例的时候，优先是操作实例的属性。

这是一段Python代码，它定义了几个类和它们的方法。以下是对每个类和函数的详细解释：

person类：这是一个基础类，用于表示一个人。它有一个初始化方法__init__，该方法接受一个参数name，并将其赋值给类的name属性。

python

复制

class person():

    def __init__(self, name):

        self.name = name

skillMixin类：这是一个混合类（Mixin），用于添加技能相关的功能。它也有一个初始化方法__init__，接受一个参数skil，并将其赋值给类的skill属性。

python

复制

class skillMixin():

    def __init__(self, skil):

        self.skill = skil

basketballMixin类：这是一个继承自skillMixin的类，专门用于表示篮球技能。它重写了父类的skill方法，打印出字符串'basketball'。

python

复制

class basketballMixin(skillMixin):

    def skill(self):

        print('basketball')

student类：这是一个继承自person的类，用于表示学生。它重写了父类的初始化方法__init__，以确保调用父类的初始化方法。

python

复制

class student(person):

    def __init__(self, name):

        super(student, self).__init__(name)

Bstudent类：这是一个同时继承自basketballMixin和student的类，用于表示会打篮球的学生。它没有定义额外的方法或属性，因此它继承了其父类的所有功能。

python

复制

class Bstudent(basketballMixin, student):

    pass

在代码的末尾，注释掉的部分创建了一个Bstudent类的实例s，并尝试调用它的skil()方法（应该是skill()方法）。如果取消注释，这段代码会创建一个学生实例，并打印出'basketball'，因为Bstudent类继承了basketballMixin类的skill方法。

总结来说，这段代码展示了Python中类和混合类的定义，以及如何通过继承来组合不同的类和功能。

代码定义了一个名为Person的类，它使用__slots__属性来限制可以动态添加的实例属性。在这个例子中，Person类只有两个属性：name和gender。__init__方法是构造方法，用于初始化这些属性。

接着，代码定义了一个名为Student的类，它继承自Person类。Student类同样使用__slots__来限制实例属性，这里添加了一个额外的属性score。Student类的__init__方法不仅初始化了从Person类继承来的name和gender属性，还初始化了score属性。

在代码的最后，创建了一个Student类的实例s，并给它的name属性赋值为'Tim'，score属性赋值为99。然后，通过s.score打印出实例s的score属性值。

这是一个面向对象编程的例子，展示了类的继承和实例化，以及如何通过实例来访问类中定义的属性。

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换；int()函数还提供额外的base参数，如果传入base参数，就可以做 N 进制的转换。

>>> int('12345', base=8)
5349

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

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

@log('DEBUG')
def my_func():
    pass

my_func = log('DEBUG')(my_func)

log_decorator = log('DEBUG')
my_func = log_decorator(my_func)

log_decorator = log('DEBUG')
@log_decorator
def my_func():
    pass

带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数，相当于是在原有的二层嵌套里面，增加了一层嵌套.

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print('[{}] {}()...'.format(prefix, f.__name__))
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')
def test():
    pass
test()

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。

要让 @log 自适应任何参数定义的函数，可以利用Python的 args 和 *kwargs，保证任意个数的参数总是能正常调用.

def log(f):
    def fn(*args, **kwargs):
        print('call ' + f.__name__ + '()...')
        return f(*args, **kwargs)
    return fn

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

print(factorial(10))

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

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

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