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()  # 0
# 可以指定转换16进制
int('f', 16)  # 15
# 指定转换2进制
int('11', 2)  # 3
# 指定转换8进制
int('11', 8)  # 9

数据类型-float

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

float(1)  # 1.0
float(112)  # 112.0
float(-123.6)  # -123.6
# 字符串
float('123')  # 123.0

数据类型-complex

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

complex(1, 2)  # (1 + 2j)
complex(1)    # 数字(1 + 0j)
# 如果第一个参数为字符串,则不需要指定第二个参数
complex("1")  # 当做字符串处理(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))  # 1

数学运算-divmod

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

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

数学运算-round

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

print(round(3.5))  # 4
print(round(3.1415, 2))  # 3.14

数学运算-pow

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

pow(2, 10)  # 1024
# 2的10次方除以100取余数
pow(2, 10, 100)  # 24
# 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))  # 10

数学运算-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))  # 100
# 列表嵌套取字典中年龄最大的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('唐')  # 21776

序列-字符串(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('大家好,
 	我叫coco'))  # '大家好,
 	我叫coco'
print('大家好我叫coco')  # 大家好我叫coco
# %r 原封不动的写出来
name = 'cat'
print('我叫%r' % name)  # 我叫'cat'

序列-字节(bytes)

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

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

序列-字节(bytearray)

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

ret = bytearray('coco',encoding='utf-8')
print(ret[0])  # 99
print(ret)  # bytearray(b'coco')
print(bytearray([1,2,3]))  # bytearray(b'x01x02x03')

序列-字节(memoryview)

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

s = memoryview("coco".encode("utf-8"))  # 查看bytes字节在内存中的情况
print(s)  # <memory at 0x00000000048DCAC8>
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])  # 98
print(v[-1])  # 103
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)  # 6
l = [1,2,3,4,5]
# 列表元素个数
len(l)  # 5

其他-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)  # 28

删除-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()函数让迭代器向下执行一次,内部实际使用了__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)  # 1
        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)  # 3

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))  # 6

字符串类型代码的执行-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)  # 6

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)  # 1
hash(str([1,2,3]))  # -4688137874008436223
hash(str(sorted({'1':1})))  # -4466824049926549424

内存相关-id

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

name = 'coco'
id(name)  # 78357592

文件操作相关-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 == '0':
        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