1.动态创建类

使用 type 动态创建类, 语法

1
type(类名, (父类名称,), {属性})
  • 定义一个 Test 类
1
2
3
4
5
6
#定义一个Test类
class Test():
    pass
#使用type
Test = type('Test', (), {})

  • 创建一个带有属性的类
1
2
3
4
5
Test = type('Test', (), {'name':'peiqi'})

#翻译为
class Test(object):
    name='peiqi'
  • 创建带有方法的类
1
2
3
4
5
6
#首先定义一个方法
def say():
    print('hello python')

#然后跟定义属性一样的方式
Test = type('Test', (), {'say':say})

2.’_ slots _‘

限制动态给类添加属性。仅对当前实例起作用，对继承的子类不起作用

1
2
class person(object):
    __slots__ = ('name', 'age') #只允许对person实例添加name, age属性。

3.生成器-generator

一边循环一遍计算的机制.
特点： 01.节约内存 02.迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的

  • 创建方法 1
1
2
3
4
5
6
7
g1 = (x for x in range(100)) #注意与列表的区别。列表是使用[],而这是使用()
#使用next或者for循环输出
next(g1) #next() 函数获得生成器的下一个返回值。当生成器没有更多的元素时,会抛出StopIteration异常

for x in g1:
    print(x)

  • 创建方法 2–函数
1
2
3
4
5
6
7
8
9
10
11
12
#以斐波拉契数列（Fibonacci）为例。除第一个和第二个数外，任意一个数都可由前两个数相加得到
#1, 1, 2, 3, 5, 8, 13, 21, 34, ...

#要把函数变成生成器。只需要把print(b) 改为 yield b 即可
def fib(times):
    s = 0,
    a,b = 0, 1
    while s < times:
        print(b)    #yield b
        a, b = b, a+b
        s = s+1
    return 'None'

生成器都是 Iterator 对象，但 list\ dict\ str 虽然是 Iterable，却不是 Iterator.
把 list、dict、str 等 Iterable 变成 Iterator 可以使用 iter() 函数

4.迭代器

可以被 next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)。

可迭代对象

1
2
#一类是集合数据类型，如 list\tuple\dict\set\str
#一类是generator，包括生成器和带yield的generator function

可以使用 isinstance()判断一个对象是否是 Iterable 对象

1
2
3
4
5
6
7
from collections import Iterable

isinstance([], Iterable)
True

isinstance('abc', Iterable)
True

凡是可作用于 for 循环的对象都是 Iterable 类型
凡是可作用于 next()函数的对象都是 Iterator 类型
集合数据类型如 list、dict、str 等都是 Iterable 但不是 Iterator, 可以通过 iter()函数获得一个 Iterator 对象

5.闭包

函数内部函数对外部函数变量的引用(非全局变量)，则称内部函数和这个变量为闭包。

1
2
3
4
5
6
7
8
def sum(number1):
    def sum2(number2):
        return number1 + number2
    return sum2

res = sum(100) #100 传递给number1
print(res(10)) #10  传递给number2

6.装饰器

可以在不改变原函数的基础上对函数进行扩展。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#（闭包）
def log(func):
    def wapper():
        print('heiheihei')
        func()
    return wapper

@log
def cat():
    print("猫吃鱼")

#打印结果：
#heiheihei
#猫吃鱼
  • 无参数
1
2
3
4
5
6
7
8
9
def log(func):
    def wapper():
        print('...')
        func()
    return wapper

@log
def say():
    print('hello python')
  • 有参数
1
2
3
4
5
6
7
8
9
10

def log(func):
    def wapper(text):
        print('do something ...')
        func(text)
    return wapper

@log
def say(text):
    print(text)
  • 不定长参数
1
2
3
4
5
6
7
8
9
def log(func):
    def wapper(*args, **kwargs):
        print('do something...')
        func(args, kwargs)
    return wapper

@log
def say(*args, **kwargs):
    print('do something..')
  • 装饰器带参数
1
2
3
4
5
6
7
8
9
10
11
def log_args(name='log'):
    def log(func):
        def wapper(*args, **kwargs):
            print('do something...')
            func(args, kwargs)
        return wapper

@log('say')
def say(*args, **kwargs):
    print('do something..')