[Python知识库]Python-内置函数

按字母顺序

a…

abs(x)

#返回一个数的绝对值。 参数可以是整数、浮点数或任何实现了 __abs__() 的对象。 如果参数是一个复数，则返回它的模。
class Test:
    def __abs__(self):
        return f'{__class__}实现了__abs__'

print(
    f'整数-1的绝对值：{abs(-1)}','\n',
    f'浮点数-9.9的绝对值：{abs(-9.9)}','\n',
    f'复数：{complex(1,2)}的绝对值：{abs(complex(1,2))} = 复数的模','\n',
    f'Test的绝对值：{abs(Test())}',
)
"""
OUT:
 整数-1的绝对值：1 
 浮点数-9.9的绝对值：9.9 
 复数：(1+2j)的绝对值：2.23606797749979 = 复数的模 
 Test的绝对值：<class '__main__.Test'>实现了__abs__
"""

all(iterable)

# 参数必须是可迭代对象，如果可迭代对象的元素全为True，all()返回True,否则返回False
print(all([1,2,3,4,0,True])) # False
print(all([1,2,3,4,41,True])) # True
print(all(123)) # TypeError: 'int' object is not iterable

any(iterable)

# 可迭代对象中有一个就为True，否则为False，空的可迭代对象为False
print(any([])) # False
print(any([1,0,0,0,0,0,0,0])) # True
print(any([False,False,False])) # False

ascii(object)

# 与 repr() 类似，返回一个包含对象的可打印表示形式的字符串
class Test:
    def __repr__(self):
        return "Hello repr"

print(ascii(Test()))   
# Hello repr     
print(ascii('\n'))
# '\n'
print(ascii('a'))
# 'a'

b…

bin(x)

# 将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 __index__() 方法返回一个整数
class Test:
    def __index__(self):
        return 12
print(bin(1))           # 0b1
print(type(bin(1)))		# <class 'str'>
print(format(1,'b'))	# 1
print(format(1,'#b'))	# 0b1
print(f'{1:b}')			# 1
print(f'{1:#b}')		# 0b1
print(bin(Test()))		# 0b1100

bool(x)

# True Or False
print(bool(False))
print(bool(0))
print(bool([]))
print(bool(()))
print(bool({}))
print(bool(''))
print(bool(complex(0,0)))
# 以上对象在Python中都是False

breakpoint()

# 此函数会在调用时将你陷入调试器中 用的不多

bytearray()

# 输入整数，返回整数长度的字节数组
print(bytearray(4)) # bytearray(b'\x00\x00\x00\x00')

print(len(bytearray(4))) # 4

# 输入字符串，返回字符数组对象
res = bytearray('Hello world',encoding='utf8')
print(res)  # bytearray(b'Hello world')

# 输入字符串必须给定encoding参数
res = bytearray('Hello world')
print(res)
# TypeError: string argument without an encoding

bytes()

# 返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本

c…

callable()

def func1():
    return "func1"
print(callable(func1)) # True
"""
Python中函数是可调用对象这是不容置疑的，所有语言的函数都是可以调用的
"""
class Test:
    def func2(self):
        return "func2"
print(callable(Test.func2)) # True
"""
Python中对象的实例方法，类方法和静态方法都是可调用对象
"""
print(callable(Test)) # True
"""
Python中类是可调用对象，类() -> 实例化 -> 返回一个实例
"""
print(callable(Test())) # False
"""
一个没有__call__()的类的实例是不能被调用的
"""
class Test:

    def __call__(self, *args, **kwargs):
        return f'{__class__}实现了__call__()，所以Test类的实例是可调用的！！！'

print(callable(Test())) # True
test1 = Test() # 实例化一个Test类
res = test1()  # 调用实例
print(res)     # <class '__main__.Test'>实现了__call__()，所以Test类的实例是可调用的！！！神奇的Python

classmethod()

class Test:

    @classmethod # 类方法，第一个参数必须是cls，可以被类调用也可以被实例调用
    def classfunc(cls,name,age):
        return f"{name} is {age} old"

test1 = Test()
res = test1.classfunc('zhangsan',12) 
res_ = Test.classfunc('zhangsan',12)
print(res)
print(res_)
# zhangsan is 12 old
# zhangsan is 12 old

compile()

complex()

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

d…

delattr(object,name)

# 实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性
class Test:
    def __init__(self, name,age):
        self.name = name
        self.age = age
test1 = Test(name='zhangsan',age=30)
print(test1.name) #  zhangsan
delattr(test1,'name')
print(test1.name) #  AttributeError: 'Test' object has no attribute 'name'

d1 = dict(k1='v1',k2='v2')
print(d1['k1']) # v1
delattr(d1,'k1')
print(d1['k1']) # AttributeError: 'dict' object has no attribute 'k1'

dir()

"""
如果对象是模块对象，则列表包含模块的属性名称。

如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。

否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。

"""
class Shape:
    def __dir__(self):
        return ['area', 'perimeter', 'location']
s = Shape()
dir(s)
# ['area', 'location', 'perimeter']

dict()

d1 = dict(k1='v1',k2='v2')
print(d1)
# 	{'k1': 'v1', 'k2': 'v2'}

divmod()

"""
它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。
"""
print(divmod(3,5))   #(0, 3)

print(divmod(5,2))     #(2, 1)

print(divmod(-5.2,2))     # (-3.0, 0.7999999999999998)

e…

enumerate(iterable,start)

# 返回一个枚举对象
list1 = ['kobe','wade','james','paul']
print(list(enumerate(list1, start=0)))
print(list(enumerate(list1, start=10)))

# 等同于
list1 = ['kobe','wade','james','paul']
def enumerate(seq,start=0):
    for one in seq:
        yield start, one
        start += 1

res = enumerate(list1,start=0)

while True:
    try:
        print(next(res))
    except StopIteration:
        break


#(0, 'kobe')
#(1, 'wade')
#(2, 'james')
#(3, 'paul')

eval(expression[,gloabals][,locals])

rs = eval('1+8')
print(rs) # 9

rs = eval('a+c',{'a':5},{'c':9})
print(rs) # 14

exec()

f…

filter(function, iterable)

# filter接收一个函数和一个可迭代对象，筛选出函数返回值为True的值的列表
a = list(range(1,10))
list(filter(lambda i:i%2==0, a))
# [2, 4, 6, 8]
def get_oushu(i):
    if i % 2 == 0:
        return True
    else:
        return False
list(filter(get_oushu, a))
# [2, 4, 6, 8]

float()

float('+1.23')
# 1.23
float('   -12345\n')
# -12345.0
float('1e-003')
# 0.001
float('+1E6')
# 1000000.0
float('-Infinity')
# -inf

class Test:
    def __init__(self,num):
        self.num = num 
    def __float__(self):
        if isinstance(self.num,int):
            return float(self.num)
        else:
            return 1.0
        
t1 = Test('a')
t2 = Test(12)

float(t1),float(t2)
# (1.0, 12.0)

format(string[,spec])

# 第一个参数是一个字符串，第二个参数是格式字符串，如果格式字符串为空，等同于str(string)
format("hello world")
# "hello world"
format(12,'b')
# '1100'

frozenset([,iterable])

# 将可迭代对象转换成一个不可变的集合
frozenset([1,2,3,4])
# frozenset({1, 2, 3, 4})
type(frozenset([1,2,3,4]))
# frozenset

g…

getattr(obj,attr[,default])

# obj 是一个对象 attr是一个属性  default是一个默认值，如果这个对象没有属性就等于默认值
class Test:
    def __init__(self,name):
        self.name = name 

t1 = Test('张三')

getattr(t1,"name")
# '张三'
t1.name 
# '张三'
getattr(t1,"age",10)
# 10 

globals()

# 返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。

h…

hasattr()

#该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，
#否则返回 False。（此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。）
class Test:
    def __init__(self, name ):
        self.name = name 

t1 = Test("zhangsan")

def hasAttr(obj,attr):
    try:
        getattr(obj,attr)
        return True
    except AttributeError:
        return False

hasAttr(t1,'name'),hasAttr(t1,'age')
# (True, False)
# 使用内置函数hasattr()实现
hasattr(t1,'name'),hasattr(t1,'age')
# (True, False)

hash()

#返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
class Test:
    def __hash__(self):
        return 123456789
 
hash(Test()) #  123456789

hash(1.0) # 1 
hash('Hello world') # 8934192240567536842

help(obj)

# 帮助函数参数传入任意对象，可以是内部对象也可以是自建对象

hex(x)

# 返回x的十六进制字符串，字符串以‘0x’开头，x可以是python的int对象
if isinstance(x,int)：# 伪代码
hex(12) # '0xc'
else:
class Test:
	def __index__(self):
		return 12
hex(Test()) # '0xc'

i…

id(obj)

# 获取obj在存储空间上面的地址

input()

# 获取输入值
s = input('-->')
--> "Hello world"
s 
# "Hello world"

int()

#返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。 如果 x 定义了 __int__()，
#int(x) 将返回 x.__int__()。 如果 x 定义了 __index__()，它将返回 x.__index__()。 如果 x 定义了 
# __trunc__()，它将返回 x.__trunc__()。 对于浮点数，它将向零舍入。

isinstance(object, classinfo)

#如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或 虚拟) 子类则返回 True。 如果 
#object 不是给定类型的对象，函数将总是返回 False。 如果 classinfo 是类型对象元组（或由其他此类元组
#递归组成的元组），那么如果 object 是其中任何一个类型的实例就返回 True。 如果 classinfo 既不是类
#型，也不是类型元组或类型元组的元组，则将引发 TypeError 异常。

issubclass()

#如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True。 类会被视作其自身的子类。 
#classinfo 也以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。 在任何其他情况下，都将
#引发 TypeError 异常。

iter(obj)

# 返回一个迭代器

L…

len()

#返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 #dictionary、set 或 frozen set 等）。

list([iterable])

# 将一个可迭代对象转换成列表，不传参数初始化一个空列表

locals()

# 更新并返回表示当前本地符号表的字典。 在函数代码块但不是类代码块中调用 locals() 时将返回自由变量。 

m…

map(function,iterable)

# 将一个可迭代对象的每个元素都放到function函数中执行返回一个新的可迭代对象
map(lambda x:x**2, [1,2,3,4])
# <map at 0x281ddf729a0> 输出一个map对象，map对象是可迭代的
list(map(lambda x:x**2, [1,2,3,4]))
# 返回一个列表 [1, 4, 9, 16]

max()

# 返回一个可迭代对象的最大值
max([12,4,5,6,7]) # 12
# 返回两个或者多个实参的最大值
max(12,24) # 24

memoryview()

# 返回由给定实参创建的“内存视图”对象

min()

# 同max()

n…

next()

#通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。
iterator = iter([1,2,3,4])
type(iterator)
# list_iterator
while True:
    try:
        print(next(iterator))
    except StopIteration:
        print("end")
        break
"""
1
2
3
4
end
"""

o…

object()

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

oct()

# 与hex(),int(),bin()等相同，只是这个是8进制格式，返回‘0o’开头的字符串

open()

ord()

# 这是 chr() 的逆函数
ord('a') # 97
chr(97)  # 'a'

p…

pow(base, exp[, mod])

if mod不传参数:
	return base的exp次方
else：
	return base的exp次方对mod求余 
pow(2,4),pow(2,4,3)
# (16, 1)

print()

# 打印输出函数

property()

# 重要的函数

r…

range()

# 返回一个序列
range(start,stop.step)

repr()

# 调用类的__repr__()方法

reversed()

# 反转
list(reversed([1,2,3,4,5]))
# [5, 4, 3, 2, 1]

round()

# 返回一个四舍五入后的浮点数
round(5.342532534,2) # 四舍五入保留2位小数

s…

set()

# 返回一个集合

setattr(obj,attr[,default])

# 设置属性的方法

slice()

# 切片函数

sorted()

# 排序函数

staticmethod()

# 一个类的静态方法，静态方法与函数基本相同，只是静态方法一般会与某些类有关系，定义在类的内部
class Test:
	@staticmethod
	def func1():
		return "this is a static method!"

str()

# 返回字符串类型
# str(obj) 触发类的__str__()方法，如果没有实现这个方法触发__repe__()方法

sum()

# 实参必须是一个可迭代对象，输出相加的结果

super()

# 避免类的多继承问题

t…

tuple()

if 有实参：实参是一个可迭代对象：
		tuple([1,2,3]) # (1,2,3)
else 没有实参：
	return 一个空数组 tuple() # ()

type(obj)

# 返回obj所属的类名
type('hello'),type(12),type([1,2,3]),type((1,2,3)),type({1:2})
(str, int, list, tuple, dict)

v…

vars(obj)

# 返回obj的__dict__()方法

z…

zip(*iterables)

# 对n个可迭代对象就行打包
zip([1,2,3,4],['zhangsan','lisi','wangwu','maliu'])
# <zip at 0x2a006021d40> 返回一个zip可迭代对象
list(zip([1,2,3,4],['zhangsan','lisi','wangwu','maliu']))
# [(1, 'zhangsan'), (2, 'lisi'), (3, 'wangwu'), (4, 'maliu')]

…

__ import __()

重要的函数

结语

对于一些函数没有展开说，因为这些函数真的很重要，我准备在后面花时间用一个一个的专题好好整理出这些重要的内置函数
为什么这么说呢，因为我在很多优秀的框架的源码里面屡次看到它们的身影。