11_Python的69个内置函数详解

1.内置函数分类

思维导图: https://www.processon.com/view/link/5dcabc48e4b0bd68d813b24f

2.基础数据类型-和数字相关的函数(14)

数据类型-bool

bool()函数用于将给定参数转换为布尔类型,如果没有参数,返回 False
bool 是 int 的子类

print(bool(0))  # False

# bool 是 int 子类

issubclass(bool, int)  # True

数据类型-int

int()函数将给定的数据转换成int值,如果不给值则返回0

# 不传入参数时,得到结果0

int()  #

# 可以指定转换16进制

int('f', 16)  #

# 指定转换2进制

int('', 2)  #

# 指定转换8进制

int('', 8)  #

数据类型-float

float()函数用于将整数和字符串转换成浮点数

float(1)  # 1.0

float(112)  # 112.0

float(-123.6)  # -123.6

# 字符串

float('')  # 123.0

数据类型-complex

complex()函数用于创建一个值为real+imag*j的复数,或者转化一个字符串或数为复数

complex(1, 2)  # (1 + 2j)

complex(1)    # 数字(1 + 0j)

# 如果第一个参数为字符串,则不需要指定第二个参数

complex("")  # 当做字符串处理(1 + 0j)

# 注意: 这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错

complex("1+2j")  # (1 + 2j)

进制转换-bin

bin()十进制转二进制

print(bin(3))  # 0b11

进制转换-oct

oct()函数将一个整数转换成8进制字符串

print(oct(10))  # 0o12

进制转换-hex

hex()函数用于将10进制整数转换成16进制,以字符串形式表示

print(hex(10))  # 0xa

print(type(hex(12)))  # <class 'str'>

数学运算-abs

abs()函数返回数字的绝对值

print(abs(-1))  #

数学运算-divmod

divmod()函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组

print(divmod(10, 3))  # (3, 1)

数学运算-round

round()函数返回浮点数x的四舍五入值

print(round(3.5))  #

print(round(3.1415, 2))  # 3.14

数学运算-pow

pow(a, b)函数求a的b次幂,如果有三个参数则求完次幂后对第三个数取余

pow(2, 10)  #

# 2的10次方除以100取余数

pow(2, 10, 100)  #

# pow x**y%z

print(pow(2, 3))  # 2的3次方 ==>8

print(pow(2, 3, 7))  # 2**3%7 ==>1

数学运算-sum

sum()函数对序列进行求和计算

t1 = [1, 2, 3, 4]

print(sum(t1))  #

数学运算-min

min()函数处理的是可迭代对象相当于for循环取出每个元素进行比较,然后取最小值,不同类型不能进行比较
元素与元素比较是从元素的第一个位置开始,第一个位置分出大小,后面位置不需比较,实际比较的是Unicode值

list1 = [1, 10, -50, 100]

print(min(list1))  # -50

数学运算-max

max()函数处理的是可迭代对象相当于for循环取出每个元素进行比较,然后取最大值,不同类型不能进行比较
元素与元素比较是从元素的第一个位置开始,第一个位置分出大小,后面位置不需比较,实际比较的是Unicode值

list1 = [1, 10, -50, 100]

print(max(list1))  #

# 列表嵌套取字典中年龄最大的key和value

people = [

    {"name": "zhangsan", "age": 18},

    {"name": "lisi", "age": 15},

    {"name": "wangwu", "age": 22},

    {"name": "dingliu", "age": 30}

]

print(max(people, key=lambda dic: dic["age"]))  # {'name': 'dingliu', 'age': 30}

3.基础数据类型-和数据结构相关的函数(24)

序列-字符串(str)

str()函数将对象转化为字符串

str(10)  # '10'

str(list(x for x in range(5)))  # '[0, 1, 2, 3, 4]'

序列-字符串(format)

format()与具体数据相关,用于计算各种小数,精算等

# 字符串

print(format('test', '<20'))  # 左对齐

print(format('test', '>20'))  # 右对齐

print(format('test', '^20'))  # 居中

# 数值

print(format(3, 'b'))  # 二进制

print(format(97, 'c'))  # 转换成unicode字符

print(format(11, 'd'))  # 十进制

print(format(11, 'o'))  # 八进制

print(format(11, 'x'))  # 十六进制(小写字母)

print(format(11, 'X'))  # 十六进制(大写字母)

print(format(11, 'n'))  # 和d一样

print(format(11)) # 和d一样

# 浮点数

print(format(123456789, 'e'))  # 科学计数法默认保6位小数

print(format(123456789, '0.2e'))  # 科学计数法保留2位小数(小写)

print(format(123456789, '0.2E'))  # 科学计数法保留2位小数(大写)

print(format(1.23456789, 'f'))  # 小数点计数法保留6位小数

print(format(1.23456789, '0.2f'))  # 小数点计数法保留2位小数

print(format(1.23456789, '0.10f'))  # 小数点计数法保留10位小数

print(format(1.23456789e+10000, 'F'))  # 小数点计数法,很大的时候输出无穷大: INF

序列-字符串(ord)

ord()函数以一个字符长度为1的字符串作为参数,返回对应的 ASCII 数值,或者 Unicode 数值

print(ord("a"), ord("A"))  # 97 65

# 返回对应的Unicode值

ord('唐')  #

序列-字符串(chr)

chr()函数用一个范围在range(256)内也就是0～255的整数作参数,返回一个对应ASCII字符

# 十六进制

print (chr(0x30), chr(0x31), chr(0x61))  # 0 1 a

# 十进制

print (chr(48), chr(49), chr(97))  # 0 1 a

序列-字符串(ascii)

ascii()函数是ascii码中的返回该值不是就返回Unicode或对象的内存地址

print(ascii('a'))  # 'a'

print(ascii('好'))  # '\u597d'

序列-字符串(repr)

repr()函数返回一个对象的str形式供解释器读取

# repr 就是原封不动的输出, 引号和转义字符都不起作用

print(repr('大家好,\n \t我叫coco'))  # '大家好,\n \t我叫coco'

print('大家好我叫coco')  # 大家好我叫coco

# %r 原封不动的写出来

name = 'cat'

print('我叫%r' % name)  # 我叫'cat'

序列-字节(bytes)

bytes()函数可以将参数转换成字节,encoding指定编码,decode指定解码

name = "你好"

print(bytes(name, encoding='gbk'))  # b'\xc4\xe3\xba\xc3'

print(bytes(name, encoding='gbk').decode('gbk'))  # 你好

序列-字节(bytearray)

bytearray()函数返回一个新字节数组,这个数组里的元素是可变的,并且每个元素的值得范围是'[0,256)'

ret = bytearray('coco',encoding='utf-8')

print(ret[0])  #

print(ret)  # bytearray(b'coco')

print(bytearray([1,2,3]))  # bytearray(b'\x01\x02\x03')

序列-字节(memoryview)

memoryview()函数查看bytes在内存中的情况

s = memoryview("coco".encode("utf-8"))  # 查看bytes字节在内存中的情况

print(s)  # <memory at 0x00000000048DCAC8>

v = memoryview(bytearray("abcefg", 'utf-8'))

print(v[1])  #

print(v[-1])  #

print(v[1:4])  # <memory at 0x10f543a08>

print(v[1:4].tobytes())  # b'bce'

序列-列表(list)

list()函数将一个可迭代对象转换成列表

list({'name': 'coco', 'age': 18})  # ['name', 'age']

list('abcdee')  # ['a', 'b', 'c', 'd', 'e', 'e']

序列-元祖(tuple)

tuple()函数将一个可迭代对象转换成元组

# 针对字典会返回字典的key组成的tuple

tuple({1:2,3:4})  # (1, 3)

tuple([1,2,3,4])  # (1, 2, 3, 4)

序列-翻转(reversed)

reversed()函数将一个序列翻转,返回翻转序列的迭代器

list(reversed(range(10)))  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

序列-自定义切片(slice)

slice()函数自定义切片

myslice = slice(5)    # 设置截取5个元素的切片

myslice  # slice(None, 5, None)

arr = range(10)

arr  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 截取5个元素

arr[myslice]  # [0, 1, 2, 3, 4]

数据集合-字典(dict)

dict()函数创建一个字典

# 创建空字典

dict()  # {}

# 传入关键字

dict(a='a', b='b', t='t')  # {'a': 'a', 'b': 'b', 't': 't'}

# 映射函数方式来构造字典

dict(zip(['one', 'two', 'three'], [1, 2, 3]))  # {'three': 3, 'two': 2, 'one': 1}

# 可迭代对象方式来构造字典

dict([('one', 1), ('two', 2), ('three', 3)])  # {'three': 3, 'two': 2, 'one': 1}

数据集合-集合(set)

set()函数创建一个集合

x = set('runoob')

y = set('google')

x, y  # 重复的被删除 ({'b', 'n', 'o', 'r', 'u'}, {'e', 'g', 'l', 'o'})

x & y  # 交集 {'o'}

x | y  # 并集 {'b', 'e', 'g', 'l', 'n', 'o', 'r', 'u'}

x - y  # 差集 {'b', 'n', 'r', 'u'}

数据集合-固定集合(frozenset)

frozenset()函数返回一个冻结的集合,冻结后集合不能再添加或删除任何元素

a = frozenset(range(10))  # 生成一个新的不可变集合

a  # frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

b = frozenset('runoob')  # 创建不可变集合

b  # frozenset(['b', 'r', 'u', 'o', 'n'])

其他-len

len()函数返回对象(字符,列表,元组等)长度或项目个数

str = "runoob"

# 字符串长度

len(str)  #

l = [1,2,3,4,5]

# 列表元素个数

len(l)  #

其他-sorted

sorted()函数对所有可迭代的对象进行排序操作

list1 = [1, 3, 5, 2, 9]

print(sorted(list1))  # 排序本质就是比较Unicode值的大小,不同类型无法排序

# sorted列表嵌套排序

people1 = [

    {"name": "zhangsan", "age": 18},

    {"name": "lisi", "age": 15},

    {"name": "wangwu", "age": 22},

    {"name": "dingliu", "age": 30}

]

print(sorted(people1, key=lambda dic: dic["age"]))  # 按age从小到大排序

其他-enumerate

enumerate()函数用于将一个可遍历的数据对象(如列表,元组或字符串)

# 组合为一个索引序列同时列出数据和数据下标,一般用在 for 循环遍历当中

lst = ["coco", "angels", "cat"]

# enumerate(lst, 1) 可以指定开始下标

# for index, el in enumerate(lst, 1):

for index, el in enumerate(lst):

    print(str(index)+"==>"+el, end=' ')  # 0==>coco 1==>angels 2==>cat

其他-all

all()函数将可迭代对象中的所有元素做布尔运算,1个为 False 全都为 False

# all 如果可迭代对象为空,则返回True

all([])  # True

print(all([1, "ss", ()]))  # False

其他-any

any()函数判断给定的可迭代对象中有一个是 True, 结果就是 True, 全部为 False,则返回 False

any([0, 1, 2])  # True

any([None, (), {}])  # False

其他-zip

zip()函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表,
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同

l1 = [1,2,3,]

l2 = ['a','b','c',5]

l3 = ('*','**',(1,2,3))

for i in zip(l1,l2,l3):

    print(i, end= ' ')  # (1, 'a', '*') (2, 'b', '**') (3, 'c', (1, 2, 3))

其他-filter

filter()函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素的迭代器

def is_odd(n):

    return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

print(list(newlist))  # [1, 3, 5, 7, 9]

其他-map

map()函数会根据提供的函数对指定序列做映射

def square(x):

    """计算平方数"""

    return x ** 2

# 计算列表各个元素的平方

list(map(square, [1,2,3,4,5]))  #  [1, 4, 9, 16, 25]

# 使用 lambda 匿名函数

list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # [1, 4, 9, 16, 25]

# 提供了两个列表,对相同位置的列表数据进行相加

list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))  # [3, 7, 11, 15, 19]

4.作用域相关的函数(2)

全局变量-globals

globals()函数查看全局变量,包含系统提供的全局变量

a='coco'

print(globals()) # globals 函数返回一个全局变量的字典,包括所有导入的变量

"""

    {'__builtins__': <module '__builtin__' (built-in)>,

    '__name__': '__main__', '__doc__': None, 'a': 'coco', '__package__': None}

"""

局部变量-locals

locals()函数查看当前级别的局部变量,包含当前级别系统提供的局部变量

def runoob(arg):  # 两个局部变量: arg,z

    z = 1

    print (locals())

runoob(4)  # {'z': 1, 'arg': 4}返回一个'变量名:绑定值'对应的字典

5.反射相关的函数(4)

判断-hasattr

hasattr()函数用于判断对象是否包含对应的属性

class Coordinate:

    x = 10

    y = -5

    z = 0

point1 = Coordinate()

print(hasattr(point1, 'x'))  # True

print(hasattr(point1, 'y'))  # True

print(hasattr(point1, 'z'))  # True

print(hasattr(point1, 'no'))  # False没有该属性

获取-getattr

getattr()函数用于返回一个对象属性值

class A:

    bar = 1

a = A()

getattr(a, 'bar')  # 获取属性 bar 值1

getattr(a, 'bar2')  # 属性 bar2 不存在,触发异常

'''异常提示

    AttributeError                            Traceback (most recent call last)

    <ipython-input-1-51bf4194ae4f> in <module>

          5 a = A()

          6 getattr(a, 'bar')  # 获取属性 bar 值1

    ----> 7 getattr(a, 'bar2')

    AttributeError: 'A' object has no attribute 'bar2'

'''

getattr(a, 'bar2', 3)  # 属性 bar2 不存在,但设置了默认值3

设置-setattr

setattr()函数用于设置属性值,该属性不一定是存在的,如果属性不存在会创建一个新的对象属性,并对属性赋值

class A():

    name = "runoob"

a = A()

setattr(a, "age", 28)

print(a.age)  #

删除-delattr

delattr()函数用于删除属性

class Coordinate:

        x = 10

        y = -5

        z = 0

point1 = Coordinate()

print('x = ',point1.x)  # ('x = ', 10)

print('y = ',point1.y)  # ('y = ', -5)

print('z = ',point1.z)  # ('z = ', 0)

delattr(Coordinate, 'z')

print('--删除 z 属性后--')  # --删除 z 属性后--

print('x = ',point1.x)  # ('x = ', 10)

print('y = ',point1.y)  # ('y = ', -5)  

# 会触发错误

print('z = ',point1.z)  # AttributeError: Coordinate instance has no attribute 'z'

6.迭代器生成器相关的函数(3)

range

range()生成器函数可创建一个整数迭代器

list(x for x in range(10) if x % 2 == 0)  # [0, 2, 4, 6, 8]

next()函数让迭代器向下执行一次,内部实际使用了__next__()方法返回迭代器的下一个项目

# 首先获得Iterator对象

it = iter([1, 2, 3, 4, 5])

# 其次循环拿值

while True:

    try:

        # 获得下一个值

        x = next(it)

        print(x, end=' ')  # 1 2 3 4 5

    except StopIteration:

        # 遇到StopIteration就退出循环

        break

iter

iter()函数获取迭代器,内部实际使用的是__iter__()方法来获取迭代器

lst = [1, 2, 3]

for i in iter(lst):

     print(i, end=' ')  # 1 2 3

7.面向对象相关的函数(9)

isinstance

isinstance(obj,cls)函数检查obj是否是类 cls 的对象
isinstance() 与 type() 区别:

type()函数不会认为子类是一种父类类型,即不考虑继承关系

isinstance()函数会认为子类是一种父类类型,即考虑继承关系

print(isinstance(123, int))  # True

class A:

    pass

class B(A):

    pass

isinstance(A(), A)  # True

type(A()) == A  # True

isinstance(B(), A)  # True

type(B()) == A  # False

issubclass

issubclass(sub, super)函数检查sub类是否是 super 类的派生类

class A:

    pass

class B(A):

    pass

print(issubclass(B,A))  # 返回 True

object

object()函数返回一个没有特征的新对象,object是所有类的基类,它具有所有Python类实例的通用方法,object函数不接受任何实参
由于 object 没有 __dict__字典因此无法将任何属性赋给 object 的实例

class A:

    pass

a = A()

print("实例a的__dict__字典: %s" % a.__dict__)

obj = object()

print(obj.__dict__)  # 报错,object()实例化的对象没有__dict__属性

"""执行结果

实例a的__dict__字典: {}

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-22-e65e48d77a62> in <module>

      7

      8 obj = object()

----> 9 print(obj.__dict__)  # 报错,object()实例化的对象没有__dict__属性

AttributeError: 'object' object has no attribute '__dict__'

"""

staticmethod

staticmethod()函数修饰对应的方法变成静态方法,被装饰的方法不需要任何参数

class C:

    @staticmethod

    def run():

        print('静态方法运行了')

C.run()  # 静态方法无需实例化

cobj = C()

cobj.run()  # 也可以实例化后调用

classmethod

classmethod()函数修饰对应的方法变成类方法,不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数
classmethod()函数修饰对应的方法可以来调用类的属性,类的方法

class A:

    bar = 1

    def func1(self):

        self.b = 3

        print ('foo')

    @classmethod

    def func2(cls):

        print ('func2')  # func2

        print (cls.bar)  #

        cls().func1()   # foo

A.func2()  # 不需要实例化便可直接用类名调用

property

property()函数修饰对应的方法变成静态属性

class A:

    # property将类中的方法伪装成类属性来调用

    @property

    def test(self):

        print('test')

a = A()

a.test  # test

super

super()函数是用于调用父类(超类)的一个方法
super()函数常用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,

会涉及到查找顺序(MRO),重复调用(钻石继承)等种种问题,MRO就是类的方法解析顺序表,即继承父类方法的顺序表

class A:

    def add(self, x):

         y = x+1

         print(y)

class B(A):

    def add(self, x):

        super().add(x)

b = B()

b.add(2)  #

vars

vars()函数以字典的形式查看对象的内置方法,不加参数查看当前级别的局部变量,包含当前级别系统提供的局部变量

msg = "xcafsfa"

print(locals())  # {'msg': 'xcafsfa'}

print(vars())  # {'msg': 'xcafsfa'}

print(vars(int))  # {'__repr__': <slot wrapper '__repr__' of 'int' objects>, ...}

type

type()函数如果你只有第一个参数则返回对象的类型,三个参数时返回新的类型对象

# 一个参数

type(1)  # <type 'int'>

type('runoob')  # <type 'str'>

type([2])  # <type 'list'>

type({0:'zero'})  # <type 'dict'>

x = 1

# 判断类型是否相等

type( x ) == int  # True

# 三个参数

class X:

    a = 1

X = type('X', (object,), dict(a=1))  # 产生一个新的类型对象 X

X  # <class '__main__.X'>

8.其他函数(13)

字符串类型代码的执行-eval

eval()函数用来执行一个字符串表达式,把字符串中的数据结构提取出来,并返回表达式的值

# eval把字符串中的数据结构提取出来

str1 = "{'name':'coco'}"

d1 = eval(str1)

print(type(d1))  # <class 'dict'>

# eval把字符串中的表达式作计算

str2 = "(1+2)*3-3"

print(eval(str2))  #

字符串类型代码的执行-exec

exec()函数把字符串以代码的方式执行

exec("""

for i in range(10):print(i)

    """)

exec("""

def func():

    print("我是coco")

func()

    """)

字符串类型代码的执行-compile

compile()函数将字符串类型的代码变异,代码对象能够通过 exec() 语句来执行或者 eval() 进行求值
有返回值的字符串形式的代码用 eval(); 没有返回值的字符串形式的代码用 exec()

compile()函数参数说明

参数一: resource 要执行的代码,动态代码片段

参数二: 文件名,代码存放的文件名,当传入了第一个参数的时候,这个参数给空就可以了

参数三: 模式,取值有3个:

exec: 一般放一些流程语句的时候

eval: resource只存放一个求值表达式

single: resource存放的代码有交互的时候mode应为single

code1 = "for i in range(10): print(i, end=' ')"

c1 = compile(code1, "", mode="exec")  # compile并不会执行代码,只是编译

# 执行编译后的代码

exec(c1)  # 0 1 2 3 4 5 6 7 8 9

code2 = "1+2+3"

c2 = compile(code2, "", mode="eval")

a = eval(c2)

print(a)  #

code3 = "name = input('请输入你的名字:')"

c3 = compile(code3, "", mode="single")

exec(c3)

print(name)

输入-input

input()函数接受一个标准输入数据,返回为 str 类型

print(input('请输入:'))

print(input('请输入:') or "-1")  # 用户直接回车返回字符串 '-1'

输出-print

print()函数打印输出,end=设定以什么结尾,sep=设置间隔符

print("https:/","www.cnblogs.com","tangxuecheng",sep="/")  # https://www.cnblogs.com/tangxuecheng

内存相关-hash

hash()算法函数,可hash的数据类型即不可变数据类型,不可hash的数据类型即可变数据类型
hash特性1: hash无论传入的参数长短,hash得出的值长度固定

hash特性2: 不能根据hash结果值推算传入的具体数据

hash('test')  # -7108862475672989075

hash(1)  #

hash(str([1,2,3]))  # -4688137874008436223

hash(str(sorted({'':1})))  # -4466824049926549424

内存相关-id

id()函数获取到对象的内存地址

name = 'coco'

id(name)  #

文件操作相关-open

open()函数用于口打开一个文件,返回一个文件句柄file对象

f = open('a.xtx', 'w')

f.write('hello')

f.close()

模块相关-import

__import__()函数用于动态加载类和函数,如果一个模块经常变化就可以使用 __import__() 来动态载入

import os

print ('在 a.py 文件中 %s' % id(os))  # 在 a.py 文件中 30713320

import sys

__import__('a')  # 导入 a.py 模块

帮助-help

help()函数查看帮助

print(help(hash))  # 查看方法的具体解释

调用相关-callable

callable(obj)函数用于检查一个对象是否可调用,如果返回True,obj有可能调用失败,如果返回False那调用绝对不会成功

class A:

    def method(self):

        return 0

callable(A)  # 类返回True

a = A()

callable(a)  # 没有实现__call__返回False

class B:

    def __call__(self):

        return 0

callable(B)  # True

b = B()

callable(b)  # 实现__call__返回 True

查看内置属性-dir

dir()函数不带参数时,返回当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性和方法列表
如果参数包含方法__dir__(),该方法将被调用,如果参数不包含__dir__(),该方法将最大限度地收集参数信息

print(dir(all))  # ['__call__', '__class__', '__delattr__'...]

内建除错-breakpoint

breakpoint()函数在未设置 PYTHONBREAKPOINT 环境变量的情况下,会中断当前程序并进入 pdb 调试器

import time

print(time.ctime())

breakpoint()

print('Good morning')

"""执行结果

    Sun Jul 26 19:58:37 2020

    --Return--

    > <ipython-input-26-ba7b402eb64c>(4)<module>()->None

    -> breakpoint()

    (Pdb)

"""

# 原理剖析

# In builtins.

def breakpoint(*args, **kws):

    import sys

    missing = object()

    hook = getattr(sys, 'breakpointhook', missing)

    if hook is missing:

        raise RuntimeError('lost sys.breakpointhook')

    return hook(*args, **kws)

# In sys.

def breakpointhook(*args, **kws):

    import importlib, os, warnings

    hookname = os.getenv('PYTHONBREAKPOINT')

    if hookname is None or len(hookname) == 0:

        hookname = 'pdb.set_trace'

    elif hookname == '':

        return None

    modname, dot, funcname = hookname.rpartition('.')

    if dot == '':

        modname = 'builtins'

    try:

        module = importlib.import_module(modname)

        hook = getattr(module, funcname)

    except:

        warnings.warn(

            'Ignoring unimportable $PYTHONBREAKPOINT: {}'.format(

                hookname),

            RuntimeWarning)

    return hook(*args, **kws)

__breakpointhook__ = breakpointhook

巴特西