Python 内置函数：简要概述

内置函数是编程语言中已经可用的函数。在本文中，让我们通过示例来了解这些函数。

艾特()

aiter(async iterable)

此函数返回异步 iterable的异步迭代器。这是 python 3.10 中提供的新函数。

该函数的示例实现。（更多示例请访问此处）

async def aitersync(iterable):
    results = []
 
    async for x in aiter(iterable):
        results.append(x)
 
    return iter(results)

全部（）

all(iterable)

该函数接受 iterable（Iterable 是可以迭代方式或在for循环中使用的对象。例如：列表、字符串、字典、集合、元组等）作为参数，并在两种情况下返回 true 值。

当 iterable 的所有元素都为 true 时
当可迭代对象为空时

#Below list wil return false as all the elements are not true.
list1 = [10, 20, 30, 40, 50, false] 
print(all(list1)    
 
#Below set will return true as the set is empty
set1 = {}
print(all(set1))
 
#Below dictionary wil return true as all elements of the dictonary are true.
dict1 = {1: "Ask", 2: "Python"}
print(all(dict1))

任何（）

any(iterable)

该函数还接受可迭代对象作为参数，如果可迭代对象的任何元素为 true，则返回 true。如果迭代器为空，则返回 false。

#Below list wil return True even when some the elements are not true.
list1 = [10, 20, 30, 40, 50, false] 
print(all(list1)    
 
#Below set will return False as the set is empty
set1 = {}
print(all(set1))

布尔（）

bool(object)

此函数返回指定对象的布尔值（True 或 False）。如果对象为 true，则该函数将返回 true；如果对象为 false，则该函数将返回 false、无、零 (0) 或空。

#below object will return False, as it is empty
list1 = bool()
print(list1)
 
#below object will return False, as it is 0
list2 = bool(0)
print(list2)
 
#below object will return True, as it is non-empty
nums = bool({1,2,3,4,5})
orint(nums)

字节数组()

bytearray(x, encoding, error)

该函数返回一个新的字节数组。它将对象转换为字节数组对象或创建特定所需大小的空字节数组对象。它有3个参数

x：源参数
- 如果它是一个整数，数组将具有该大小，并将使用空字节进行初始化。
- 如果它是一个 string，您还必须提供编码（以及可选的错误）参数
编码：如果源是字符串，则字符串的编码。
错误：如果源是字符串，则编码转换失败时要采取的操作。

arr = bytearray(5)
print(arr)
 
str = "Ask Python"
arr1 = bytearray(str, 'utf-8')
print(arr1)

输出：

字节数组(b’\x00\x00\x00\x00\x00′)

bytearray(b’问 Python’)

编译（）

compile(source, filename, mode, flag, dont_inherit, optimize)

该函数将源代码转换为代码或 AST 对象。SyntaxError 如果编译的源无效并且 ValueError 源包含空字节，则该函数返回。传递的参数有：

source：（强制）要编译的源可以是任何 AST 对象、字符串等
filename：（强制）从中读取源的文件的名称，如果没有这样的文件存在，请自行命名。
mode：（强制）指定必须编译什么样的代码
- eval – 如果源包含单个表达式
- exec – 如果源包含语句块
- single – 如果源包含单个交互式语句
flag 和 dont_inherit：（可选）控制应激活哪些编译器选项以及应允许哪些未来功能。默认值分别为 0 和 false。
Optimize：（可选）指定编译器的优化级别；默认值 -1

复杂的（）

complex(real, imaginary)

该函数返回给定的实部和虚部值。它将字符串或数字转换为复数。如果第一个参数是字符串，它将被解释为复数，并且必须在没有第二个参数的情况下调用该函数。第二个参数永远不能是字符串。如果省略任何参数（实数或虚数），则默认值仍为 0，并且构造函数将充当像 int 和 float 一样的数字转换。如果两个参数都被省略，则返回 0j。

z0 = complex(9,-8)
print(z0)
 
z1 = complex()
print(z1)
 
z2 = complex(10)
print(z2)
 
z3 = complex('10-4j')
print(z3)
 
z4 = complex('5-7j','7')
print(z4)

输出：

(9-8j)
0j
(10+0j)
(10-4j)
TypeError: 如果第一个参数是字符串，complex() 则无法获取第二个参数

德拉特()

delattr(object, attribute)

如果对象允许，此函数将删除指定的属性。第一个参数指定要从哪个对象删除属性，第二个参数指定要删除的内容

class Employee:
  Name= "Alex"
  Dept = "HR"
  Salary = 15000
  City = "Mumbai"
 
delattr(Employee, 'Salary')
#Salary attribute gets deleted from the Employee

字典（）

dict(keyword arguments)
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

这个功能

该函数创建一个新字典。dict 对象是字典类。class dict() 返回一个由可选位置参数和可能为空的关键字参数集初始化的新字典。

d1 = dict(Name ="Alex", Salary =15000, City ="Mumbai")
 
print(d1)

输出：

{‘姓名’: ‘亚历克斯’, ‘工资’: 15000, ‘城市’: ‘孟买’}

[‘__and__’、’__class__’、’__contains__’、’__delattr__’、’__dir__’、’__doc__’、’__eq__’、’__format__’、’__ge__’、’__getattribute__’、’__gt__’、’__hash__’、’ __iand__’、’__init__’、’__init_subclass__’、’__ior__’、’__isub__’、’__iter__’、’__ixor__’、’__le__’、’__len__’、’__lt__’、’__ne__’、’__new__’、’__or__’ , ‘__rand__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__ror__’, ‘__rsub__’, ‘__rxor__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__sub__’, ‘__subclasshook__’, ‘ __xor__’、’添加’、’清除’、’复制’、’差异’、’差异_更新’、’丢弃’、’交集’、’交集_更新’、’isdisjoint’、’issubset’、’issuperset’、’pop’ ，“删除”，“对称差异”，“对称差异更新”，“联合”，“更新”]

divmod()

divmod(dividend, divisor)

此函数返回由作为参数传递的数字的商和余数组成的数字对。它将返回非数字参数的 TypeError。

dividend = 110
divisor = 4
nums = divmod(dividend, divisor)
 
print(nums)

输出： (27, 2)

枚举（）

enumerate(iterable, start)

该函数返回可迭代的枚举对象（可迭代 必须是一个序列，例如元组）。它将一个计数器（从一开始默认为 0）添加到可迭代对象中。

a = ('Monday', 'Tuesday', 'Wednesday','Thursday')
b = enumerate(a)
 
#notice the difference in output
print(list(a))
print(list(b))

输出：

[‘周一，周二，周三，周四’]

[(0, ‘星期一’), (1, ‘星期二’), (2, ‘星期三’), (3, ‘星期四’)]

评估（）

eval(expression, globals, locals)

该函数计算作为参数传递的表达式，如果该表达式是有效的Python语句，它将被执行。参数为：

表达式：要计算的字符串/表达式
全局（可选）：必须是字典
locals（可选）：可以是任何映射对象。

a = 10
b = 2
c = 'print(a * a + b)'
 
eval(c)

输出： 102

执行（）

exec(object, globals, locals)

该函数不返回任何值，它返回 None。它是一个支持Python代码动态执行的函数。该对象必须是字符串或代码对象。如果它是一个代码对象，那么它会被简单地执行，但如果是一个字符串，它首先被解析为一组Python语句，然后再执行。参数与 eval() 相同，只是 eval() 中的表达式被 exec() 中的对象更改

筛选（）

filter(function, iterable)

顾名思义，该函数通过函数过滤可迭代对象，以检查该项目是否被接受。它返回过滤后的可迭代对象。

def Result(x):
  if x < 30:
    return False
  else:
    return True
 
marks = [60, 91, 12, 29, 30, 41]
pass_or_not = filter(Result, marks)
 
for x in pass_or_not:
  print(x)

输出： 60 91 30 41

漂浮（）

float(value)

该函数返回一个由值构造的浮点数。值可以是数字或字符串。

x_int = 25
y_float = float(x_int)
 
print(x_int)
print(y_float)

输出：

25.0

格式（）

format(value, format)

该函数根据作为参数传递的指定格式返回格式化值。默认格式是空字符串，但是，大多数内置类型都使用标准格式化语法：格式规范迷你语言。

# binary format  - b
x = 7
print(format(x, "b"))

输出： 111

冻结集（）

frozenset(iterable)

此函数返回一个新的 set 或 freezeset 对象，其元素取自 iterable。集合的元素必须是可散列的（如果它的散列值在其生命周期内永不改变）。要表示集合的集合，内部集合必须是 freezeset 对象。如果未指定iterable ，则返回一个新的空集。

获取属性（）

getattr(object, attribute, default)

该函数返回指定的属性。第一个参数指定要从哪个对象中查找属性，第二个参数指定必须查找什么（属性）。

class Employee:
  name = 'Alex'
  city = 'Mumbai'
 
Engineer = Employee()
name = getattr(Engineer, 'name')
print(name)

输出：亚历克斯

全局变量()

globals()

该函数返回实现当前模块命名空间的字典。global() 的输出将显示当前程序的所有全局变量和其他符号。

哈萨特（）

hasattr(object, attribute)

如果指定对象中存在指定属性，则该函数返回 true；如果该属性不存在，则返回 false。

class Employee:
  name = 'Alex'
  city = 'Mumbai'
 
Engineer = Employee()
x = hasattr(Engineer, 'name')
print(x)
 
y = hasattr(Engineer,'salary')
print(y)

输出：

真的

错误的

散列()

hash(object)

该函数返回对象的哈希值（如果有的话）。哈希值是用于在字典查找期间快速比较字典键的整数。

x1 = 'Ask Python'
print('Ask Python: ', hash(x1))
 
x2 = 3.147
print('3.147: ',hash(x2))
 
x3 = 71
print('71:', hash(x3))

输出：

问Python：-1041620088632976012
3.147：338958922354412547
71：71

帮助（）

help(object)

该函数调用内置帮助系统。它旨在用于交互式使用。在 python shell 上尝试这个函数。

如果未给出参数，交互式帮助系统将在解释器控制台上启动。
如果参数是string，则将该字符串查找为模块、函数、类、方法、关键字或文档主题的名称，并在控制台上打印帮助页面。
如果参数是任何其他类型的对象，则会生成该对象的帮助页面。

help() 不带参数

带参数的 Help()

十六进制（）

hex(number)

该函数将指定的数字转换为十六进制值。返回字符串始终以开头0x。

x1 = hex(-44)
print(x1)
 
x2 = hex(321)
print(x2)

输出：

-0x2c

0x141

ID（）

id(object)

此函数返回对象的“身份”（唯一 id – 这是一个整数，保证该对象在其生命周期内是唯一且恒定的。）。

x0 = 10
print(id(x0))
 
x1 = 11
print(id(x1))
 
x2 = x1
print(id(x2))

输出：

9756512

9756544

输入（）

input(prompt)

该函数用于获取用户的输入。该函数从输入中读取一行，将其转换为字符串（去除尾随换行符），然后返回该字符串。

String1 = input('Input from the user: ')
print('The input:', String1)

输出：

用户输入：Ask Python
输入：Ask Python

整数（）

int(value)
int (value, base)

该函数返回一个由数字或字符串值构造的整数对象。如果未给出参数，则该函数将返回 0。基数是可选的，表示值的数字系统。它可以是 0、2、8、10 或 16。

#base 2 -> binary number
print(int('0b11101',2))
 
#base 16 -> hexadecimal number
x2 = 0xC1
print(int('0xC1',16))

输出：

193

isinstance()

isinstance(object, classinfo)

该函数返回一个布尔值。如果对象参数是指定的classinfo参数或其子类的实例，则返回 true 。否则返回 false。如果classinfo参数不是类型或类型元组，则该函数返回 TypeError 。

numset = {1, 2, 3}
print('Checking for set: ', isinstance(numset, set))
print('Checking for list: ', isinstance(numset, list))

输出：

检查集合：True
检查列表：False

是子类()

issubclass(class, classinfo)

该函数返回一个布尔值，如果class参数是classinfo参数的子类，则返回true，否则返回false

class company:
  Office= 'AskPython'
  
class employee(company):
  name = 'Alex'
  Office = company
   
print(issubclass(employee, company))
print(issubclass(employee, employee))    #every class is its own subclass
print(issubclass(company, employee))

输出：

真的

错误的

迭代器（）

iter(object, sentinel)

此函数迭代器返回给定对象参数的对象，直到获取哨兵为止。Sentinel 是可选的，它是用于表示序列结束的值。

list1 = iter(["North", "East", "South", "West"])
 
print(next(list1))
print(next(list1))
print(next(list1))

输出：

北

东方

南

长度（）

len(object)

该函数返回长度，即对象的项目数。对象参数可以是字符串、字节、元组、列表或范围等序列，甚至可以是字典、集合等集合。

l1 = len([10,20,30,40])
print(l1)
 
set1 = len({1,2,3,4,5,6,7})
print(set1)
 
sent = len("Ask Python")
print(sent)

输出：

列表（）

list(iterable)

该函数创建一个作为参数传递的可迭代列表。在没有参数的情况下，该函数将创建一个空列表。

string1 = 'Ask Python'
string2 = list(string1)
 
print(string1)
print(string2)

输出：

询问 Python
[‘A’, ‘s’, ‘k’, ‘ ‘, ‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]

当地人（）

locals()

该函数返回一个表示当前本地符号表的字典。必要时它还会更新本地符号表。该函数没有任何参数。它返回功能块中的自由变量，但不返回类块中的自由变量。

print(locals())

输出：

{‘输入’: [”, ‘locals()’], ‘输出’: {}, ‘_’: ”, ‘__’: ”, ‘___’: ”, ‘__builtin__’: , ‘__builtins__’: , ‘__name__’: ‘__main__’, ‘_dh’: [‘/home/repl’], ‘_i’: ”, ‘_i1’: ‘locals()’, ‘_ih’: [”, ‘locals()’] , ‘_ii’: ”, ‘_iii’: ”, ‘_oh’: {}, ‘_sh’: , ‘退出’: , ‘get_ipython’: >, ‘退出’: }

地图（）

map(function, iterables)

此函数将指定为参数的函数应用于作为参数传递的可迭代对象的每个项目，并返回结果迭代器。

def solve_nums(n,m,k):
    return n*m+k
 
numbers = (1, 2, 3, 4)
result = map(solve_nums,(1,2,3),(10,10,10),(1,2,3))
print(result)
print(list(result))

输出：

<映射对象位于 0x7f96078a50a0>

[11,22,33]

最大限度（）

max(n1, n2, n3, ...)
max(iterable)

此函数返回可迭代参数中最大的项或传递的两个或多个参数中最大的项（n1，n2 …）。对于字符串参数，最大的项是按字母顺序排序的可迭代对象的最后一项。

str1 = max("India","China", "Dubai")
print(str1)
 
nums = max(-2, -9, -12)
print(nums)

输出：

印度

-2

内存视图()

memoryview(object)

顾名思义，该函数返回对象的“内存视图”；MemoryView 允许您通过创建内存视图对象来访问对象的内部缓冲区。

str = memoryview(b"Ask Python")
 
print(str)
 
#Unicode of the first character
print(str[0])
 
#Unicode of the second character
print(str[4])

输出：

<0x2ac829f42a00处的内存>

分钟（）

min(n1, n2, n3, ...)
min(iterable)

此函数返回可迭代参数中的最小项或传递的两个或多个参数中最小的项（n1，n2 …）。对于字符串参数，最小的项目是按字母顺序排序的可迭代对象的第一项。

str1 = min("India","China", "Dubai")
print(str1)
 
nums = min(-2, -9, -12)
print(nums)

输出：

中国

-12

下一个（）

next(iterable, default)

此函数检索指定iterable的下一项。默认值是可选的，默认值将被返回，直到可迭代对象到达其结束项。

nums = iter([10,20,30])
 
#the next element -> 1st
nums_1 = next(nums)
print(nums_1)
 
#the next element -> 2nd
nums_2 = next(nums)
print(nums_2)

输出：

目的（）

x = object()

该函数不接受任何参数。它返回一个新的无特征的对象。对象具有 Python 类的所有实例所共有的方法。它是所有班级的基础

abc = object()

创建输出“abc”对象时

十月（）

oct(x)

该函数将指定的数字转换为八进制值。返回字符串始终以0o 开头。

x1 = oct(-44)
print(x1)
 
x2 = oct(321)
print(x2)

输出：

-0o54
0o501

打开（）

open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

该函数打开文件并返回相应的文件对象。如果未找到指定的文件，该函数将返回 OSError。参数是

文件 – 提供路径名，它是一个类似路径的对象
mode – 它是一个可选字符串，指定打开文件的模式。以下是一些常用的模式

`'r'`	打开以供阅读（默认）
`'w'`	打开写入，首先截断文件
`'x'`	打开以独占创建，如果文件已存在则失败
`'a'`	打开进行写入，如果存在则追加到文件末尾
`'b'`	二进制模式
`'t'`	文本模式（默认）
`'+'`	开放更新（读和写）

模式及其描述

buffering – 这是一个可选字符串，用于设置缓冲策略
编码 – 它是一个可选字符串，用于说明编码格式
错误 – 这是一个可选字符串，用于解决编码/解码错误
newline – 它是一个可选字符串，用于说明换行模式如何工作
closefd – 这是一个可选字符串，默认情况下必须为 true；如果给定，否则会发生异常。
opener – 它是一个可选字符串，返回打开的文件描述符

订单（）

ord(ch)

此函数仅返回所传递参数的 Unicode 代码点的整数表示形式。

print(ord('T'))    
print(ord('1'))    
print(ord('@'))

输出：

84
49
64

战俘（）

pow(number, exponential, modulus)

此函数返回一个等于指数的值。模参数是可选的，如果存在，则返回数字的模。

print(pow(2,0))  
print(pow(0, 2))       
print(pow(2,3,3))     #(2*2*2)/3

输出：

1
0
2

打印（）

print(object(s), sep=separator, end=end, file=file, flush=flush)

顾名思义，该函数将对象打印到文本流文件中，以 sep分隔，后跟 end。除对象之外的所有其他参数都是可选的。

nums = [1,2,3,4]
 
print("Numbers are: ", nums, sep='0', end='\n')
print("Ask Python")

输出：

数字是： 0[1, 2, 3, 4]
询问 Python

财产（）

property(fget=None, fset=None, fdel=None, doc=None)

该函数采用四个可选参数并返回 property 属性。

fget 用于获取属性值。
fset 用于设置属性值。
fdel 用于删除属性值。
doc 为属性创建文档字符串。

范围（）

range(start, stop, step)

该函数根据传递的参数返回不可变的数字序列。如果传递单个参数，则该函数将其视为停止参数。

nums = [1,2,3,4,5,6,7,8,9,10]
 
nums = range(5)   
print(list(nums))   
 
#2, and 10 are considered start and stop respectively
nums = range(2,10)    
print(list(nums))    
 
#increament step 2
nums = range(2,10,2) 
print(list(nums))

输出：

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

代表（）

repr(object)

此函数返回一个包含对象的可打印表示形式的字符串。在大多数情况下，它返回相同的对象。

string1 = 'Ask Python'
print(repr(string1))
 
nums1 = [1,2,3,4]
print(repr(nums1))

输出：

“询问 Python”
[1,2,3,4]

反转（）

reversed(sequence)

该函数返回指定序列参数的相反顺序。这里的序列可以是任何可索引的迭代，例如列表、元组、集合等。

list1 = [1, 2, 4, 3, 5]
print(list(reversed(list1)))
 
tuple1 = ('A','S','K',' ','P','Y','T','H','O','N')
print(list(reversed(tuple1)))

输出：

[5, 3, 4, 2, 1]
[‘N’, ‘O’, ‘H’, ‘T’, ‘Y’, ‘P’, ‘ ‘, ‘K’, ‘S’, ‘A’ ]

圆形的（）

round(number, ndigits)

此函数返回一个四舍五入到小数点后n 位的数字。ndigits参数是可选的，如果没有提供，函数将返回最接近的整数。

print('1.8 -> ',round(1.8))
print('1.2 -> ',round(1.2))
print('1.5678 (2 decimal points)-> ',round(1.5678,2))

输出：

1 -> 1
1.8 -> 2
1.2 -> 1
1.5678（2 位小数）-> 1.57

放（）

set(iterable)

该函数为指定的可迭代参数构造一个集合。如果未指定参数，则该函数将构造一个空集。

print(set())   #empty set will be constructed
print(set(('A','S','K',' ','P','Y','T','H','O','N')))
print(set(('Ask Python')))

输出：

set()
{‘S’, ‘O’, ‘K’, ‘A’, ‘H’, ‘N’, ‘P’, ‘T’, ‘Y’, ‘ ‘} {‘t’, ‘
s ‘、’A’、’n’、’P’、’y’、’o’、’k’、’ ‘、’h’}

设置属性()

setattr(object, name, value)

此函数用于设置或修改指定对象参数中的名称及其值。

class Employee:
    name = 'Atlas'
     
emp = Employee()
print('Before:', emp.name)
 
#modifying the name using setattr()
setattr(emp, 'name', 'Ryle')
print('After:', emp.name)

输出：

之前：阿特拉斯
之后：莱尔

片（）

slice(stop)
slice(start, stop, step)

此函数返回对象的切片，该切片是对象在start和stop参数之间的项目。这里的step和start是可选参数。如果未提及start，则函数从第一项开始。step参数用于表示增量，默认值设置为none。

string1 = 'Ask Python'
slice_object1 = slice(6) 
print(string1[slice_object1])  
 
nums1 = [1,2,3,4,5,6,7,8,9,10,11]
slice_object2 = slice(1, 6, 2)
print(nums1[slice_object2])   #increament by 2

输出：

询问 Py
[2,4,6]

排序（）

sorted(iterable, key=key, reverse=reverse)

此函数从iterable中的项目返回一个新的排序列表。key是一个可选参数，用于指定要返回的列表的顺序。反向也是一个可选参数。它是一个布尔值，如果按降序排列则返回 true，如果按升序排列则返回 false。

nums = [50,20,40,10,30]
print(sorted(nums))
print(sorted(nums,reverse = True))    
 
string1 = 'AskPython'
print(sorted(string1))

输出：

[10, 20, 30, 40, 50]
[50, 40, 30, 20, 10]
[‘A’, ‘P’, ‘h’, ‘k’, ‘n’, ‘o’, ‘s’ ，’t’，’y’]

字符串()

str(object=b'', encoding='utf-8', errors='strict')

该函数返回一个对象str 的版本。编码参数指定编码格式，默认值设置为utf-8。error参数指定解码失败时如何响应。它可以是严格的、忽略的或替换的。

s1 = bytes('AskPython', encoding='utf-8',errors='strict')
print(str(s1, encoding='ascii', errors='ignore'))

输出：

问Python

和（）

sum(iterable, start=0)

该函数返回所有 item 的总和加上start参数。start 参数是可选的，默认为 0。可迭代的项只能是数字。

nums = [10,20,30,40,50]
 
print(sum(nums))
print(sum(nums,3))

输出：

150
153

极好的（）

super(object)

该函数返回对象的父类或兄弟类。这对于访问类中已重写的继承方法很有用。

class Employee(object):
  def __init__(self, emp):
    print(emp, 'works for AskPython')
     
class emp(Employee):
  def __init__(self):
    super().__init__('Alex')
     
emp1 = emp()

输出：

Alex 为 AskPython 工作

元组()

tuple(iterable)

该函数为指定的可迭代参数构造一个元组。如果未指定参数，则该函数将构造一个空元组。

print(tuple())   #empty tuple will be constructed
print(tuple([10,20,30,40]))
print(tuple(('Ask Python')))

输出：

()
(10, 20, 30, 40)
(‘A’, ‘s’, ‘k’, ‘ ‘, ‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’ ）

类型（）

type(object)
type(name, bases, dict)

该函数以两种不同的方式工作。

如果传递参数对象，那么它将返回该对象的类型。
如果传递三个参数，则返回一个新类型的对象。名称字符串是类名。基元组包含基类。如果为空，则添加一个对象，即所有类的最终基础。dict字典包含类主体的属性和方法定义。

nums= {10,20,30,40}
print(type(nums))
 
class Employee:
    name: 'Atlas'
emp = Employee()
print(type(emp))
 
sample1 = type('AskPython',(Employee,) ,dict(x1='a', x2='b'))
print(type(sample1))

输出：

变量()

vars(object)

此函数返回指定对象参数的字典映射属性 (__dict__)。如果没有提到参数，则该函数返回本地范围内的方法。

print (vars())
print(vars(tuple))

输出：

{‘name’: ‘main’, ‘doc’: None, ‘package’: None, ‘loader’: , ‘spec’: None, ‘annotations’: {}, ‘builtins’: } {‘repr’:
, ‘hash’: , ‘getattribute’: , ‘lt’: , ‘le’: , ‘eq’: , ‘ne’: , ‘gt’: , ‘ge’: , ‘iter’: , ‘len’: , ‘getitem’: , ‘add’: , ‘mul’: , ‘rmul’: , ‘包含’: , ‘new’: , ‘getnewargs’: , ‘index’: , ‘count’: , ‘doc’: “内置不可变序列。\n\n如果未给出参数，则构造函数返回一个空元组。\n如果指定了 iterable，则元组将从 iterable 的项初始化。\n\n如果参数是元组，则返回值为同一个物体。”}

压缩（）

zip(*iterables)

该函数的元组迭代器基于作为参数传递的可迭代对象。

如果未指定参数，则该函数返回一个空迭代器。
如果指定了单个可迭代参数，则该函数返回一个元组迭代器，其中每个元组仅包含一个元素。
如果指定了多个可迭代参数，则该函数返回一个元组迭代器，每个元组都具有来自所有可迭代的元素。

nums = [1, 2, 3, 4]
string1 = ['North', 'East', 'West','South']
 
# Two iterables are passed
x = zip(nums, string1)
list1 = list(x)
print(list1)

输出：

[(1，’北’)，(2，’东’)，(3，’西’)，(4，’南’)]

进口（）

__import__(name, globals=None, locals=None, fromlist=(), level=0)

该函数用于在 import 语句调用该函数时更改该语句的语义。相反，最好使用导入钩子。该功能很少使用，我们不鼓励使用该功能。

结论

Python 是解释性最好的语言之一。内置功能使其更容易有效地使用。在本文中，我们介绍了 Python 中可用的所有内置函数、它们的使用以及示例。

如需更多参考，请点击此处。

艾特()

字典（）

整数（）

长度（）

列表（）

内存视图()

下一个（）

代表（）

放（）

字符串()

元组()

__进口__（）

结论

进口（）