34 KiB

Raw Permalink Blame History

Python 内置函数:简要概述

原文：https://www.askpython.com/python/built-in-methods/python-built-in-functions-brief-overview

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

alter_)

aiter(async iterable)

这个函数为异步迭代返回一个异步迭代器。这是 python 3.10 中的一个新函数。

此函数的示例实现。(更多示例请访问此处)

async def aitersync(iterable):
    results = []

    async for x in aiter(iterable):
        results.append(x)

    return iter(results)

all()

all(iterable)

该函数采用 iterable(iterable 是可以迭代方式使用的对象，或者在中用于循环。例如:列表、字符串、字典、集合、元组等)作为参数，并在两种情况下返回真值。

当 iterable 的所有元素都为真时
当 iterable 为空时

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

any(iterable)

该函数也将 iterable 作为参数，如果 iterable 的任何元素为 true，则返回 true。如果 iterable 为空，则返回 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()

bool(object)

该函数返回指定对象的布尔值(真或假)。如果对象为真，函数将返回真；如果对象为假，或无，或零(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()

bytearray(x, encoding, error)

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

x:源参数
- 如果它是一个整数，数组将具有该大小，并用空字节初始化。
- 如果是一个字符串，还必须给出编码(以及可选的错误)参数
编码:如果源是字符串，则为字符串的编码。
错误:如果源是字符串，编码转换失败时要采取的操作。

arr = bytearray(5)
print(arr)

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

输出:

bytearray(b ' \ x00 \ x00 \ x00 \ x00 \ x00 ')

字节数组(b'Ask 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) 类型错误:如果第一个参数是字符串，则 complex()不能接受第二个参数

delattr()

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 对象是 dictionary 类。class dict()返回一个新字典，它由一个可选的位置参数和一组可能为空的关键字参数初始化。

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

print(d1)

输出:

{ '姓名':'亚历克斯'，'薪金':15000，'城市':'孟买' }

['and '，' class '，' contains '，' delattr '，' dir '，' doc '，' format '，' ge '，' getattribute '，' gt '，' hash '，' iand '，' init '，' init_subclass '，'，' ior '，'，' __isub

时尚()

divmod(dividend, divisor)

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

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

print(nums)

输出: (27，2)

枚举()

enumerate(iterable, start)

此函数返回 iterable 的枚举对象( iterable 必须是序列 eg- tuple)。它向 iterable 添加一个计数器(从开始，默认为 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()

eval(expression, globals, locals)

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

表达式:要计算的字符串/表达式
globals(可选):必须是字典
局部变量(可选):可以是任何映射对象。

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

eval(c)

输出: 102

exec()

exec(object, globals, locals)

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

过滤器()

filter(function, iterable)

顾名思义，这个函数通过函数过滤 iterable，检查该项是否被接受。它返回经过筛选的 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()

float(value)

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

x_int = 25
y_float = float(x_int)

print(x_int)
print(y_float)

输出:

Twenty-five

格式()

format(value, format)

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

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

输出: 111

frozenset()

frozenset(iterable)

该函数返回一个新的 set 或 frozenset 对象，其元素取自 iterable 。一个集合的元素必须是可散列的(如果它有一个在其生命周期中从不改变的散列值)。要表示集合的集合，内部集合必须是 frozenset 对象。如果没有指定 iterable ，则返回一个新的空集。

getattr()

getattr(object, attribute, default)

这个函数返回指定的属性。第一个参数指定从哪个对象中找到属性，第二个属性指定必须找到什么(属性)。

class Employee:
  name = 'Alex'
  city = 'Mumbai'

Engineer = Employee()
name = getattr(Engineer, 'name')
print(name)

**输出:**亚历克斯

globals()

globals()

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

hasattr()

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 上尝试这个函数。

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

help() with no arguments

Help() with arguments

十六进制()

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

输出:

Nine million seven hundred and fifty-six thousand five hundred and twelve

Nine million seven hundred and fifty-six thousand five hundred and forty-four

输入()

input(prompt)

该函数用于接收用户的输入。该函数从 input 中读取一行，将其转换为一个字符串(去掉尾随换行符)，然后返回该字符串。

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

输出:

来自用户的输入:询问 Python

int()

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

输出:

Twenty-nine

One hundred and ninety-three

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

输出:

检查集合:真检查列表:假

issubclass()

issubclass(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()

iter(object, sentinel)

这个函数迭代器为给定的对象参数返回一个对象，直到取出标记为止。Sentinel 是可选的，它是用于表示序列结束的值。

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

print(next(list1))
print(next(list1))
print(next(list1))

输出:

北

东方

南方

len()

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)

输出:

four

seven

Ten

列表()

list(iterable)

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

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

print(string1)
print(string2)

输出:

求 Python ['A '，' s '，' k '，' '，' P '，' y '，' t '，' h '，' o '，' n']

本地人()

locals()

这个函数返回一个代表当前本地符号表的字典。它还在必要时更新局部符号表。这个函数没有任何参数。它在函数块中返回自由变量，但在类块中不返回。

print(locals())

输出:

{'In': ["，' locals()']，' Out': {}，' _ '::，' __ ':，' builtin ':，' _ _ builtin _ _ ':，' name': 'main '，' _dh': ['/home/repl']，' _i ':"，' _i1': 'locals()'，' _ih': ["，' locals()']，' _ii ':"，' _iii ':"，' _oh '::':':' '

地图()

map(function, iterables)

该函数将指定为参数的函数应用于作为参数传递的 iterable 的每一项，并返回结果迭代器。

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

输出:

[11, 22, 33]

max()

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

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

str1 = max("India","China", "Dubai")
print(str1)

nums = max(-2, -9, -12)
print(nums)

输出:

印度

-2

内存视图()

memoryview(object)

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

str = memoryview(b"Ask Python")

print(str)

#Unicode of the first character
print(str[0])

#Unicode of the second character
print(str[4])

输出:

Sixty-five

Eighty

min()

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

该函数返回一个可迭代参数中的最小项，或者两个或多个传递参数中的最小项(n1，n2…)。对于字符串参数，最小的项是按字母顺序排序的 iterable 的第一项。

str1 = min("India","China", "Dubai")
print(str1)

nums = min(-2, -9, -12)
print(nums)

输出:

中国

-12

下一个()

next(iterable, default)

该函数检索指定的 iterable 的下一项。默认值是可选的，并且返回默认的值，直到 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)

输出:

Ten

Twenty

object()

x = object()

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

abc = object()

当创建输出“abc”对象时

oct()

oct(x)

此函数将指定的数字转换为十八进制值。返回字符串总是以0 o 开始。

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)

这个函数打开文件并返回一个相应的 file 对象。如果找不到指定的文件，该函数将返回 OSError。这些参数是

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

| 'r' | 打开以供阅读(默认) | | 'w' | 打开进行写入，首先截断文件 | | 'x' | 以独占方式打开，如果文件已经存在，则失败 | | 'a' | 打开以供写入，追加到文件的末尾(如果存在) | | 'b' | 二进制 | | 't' | 文本模式(默认) | | '+' | 打开以进行更新(读取和写入) |

Modes and their description

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

ord()

ord(ch)

这个函数只是返回所传递参数的 Unicode 码位的整数表示。

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

输出:

84 49 64

pow()

pow(number, exponential, modulus)

该函数返回一个值，该值等于数的指数次方。modulus 参数是可选的，如果存在，则返回 mod of number。

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

输出:

1 0 2

print()

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 用于获取一个属性值。
偏移用于设置属性值。
fdel 用于删除属性值。
doc 为属性创建一个 docstring。

范围()

range(start, stop, step)

这个函数根据传递的参数返回一个不可变的数字序列。如果传递了一个参数，那么该函数会将其视为一个 stop 参数。

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()

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)

该函数返回一个四舍五入到小数点后位数的数字。 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(小数点后两位)- > 1.57

集合()

set(iterable)

这个函数为指定的 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 '，' Y '，' ' } {'t '，' S '，' A '，' N '，' P '，' Y '，' O '，' K '，' '，' h'}

setattr()

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)

该函数返回对象的一个切片，该切片是在开始和停止参数之间的一个对象的项目。这里步和开始是可选参数。如果未提及开始，则功能从第 1 项开始。步长参数用于指示增量，默认值设置为无。

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 中的项目返回一个新的排序列表。键是一个可选参数，用于指定返回列表的顺序。倒档也是一个可选参数。它是一个布尔值，如果降序，则返回 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()

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

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

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

输出:

AskPython

sum()

sum(iterable, start=0)

该函数返回所有项目的总和加上开始参数。start 参数是可选的，默认情况下被认为是 0。iterable 的项目只能是数字。

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()

输出:

亚历克斯为 AskPython 工作

元组()

tuple(iterable)

这个函数为指定的 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()

type(object)
type(name, bases, 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))

输出:

<class 'main.employee'>
<class 'type'>

乌鸦()

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 ':' contains ':，' new ':，' getnewargs ':，' index ':，' count ':' doc ':"内置不可变\ n \ n 如果没有给定参数，构造函数将返回一个空元组。\ n 如果指定了 iterable，则从 iterable 的项初始化元组。\ n \ n 如果参数是元组，则返回值是同一个对象。}

zip()

zip(*iterables)

基于作为参数传递的 iterable 的元组的这个函数迭代器。

如果没有指定参数，函数将返回一个空迭代器。
如果指定了单个 iterable 参数，该函数将返回一个元组迭代器，每个元组只有一个元素。
如果指定了多个 iterables 参数，该函数将返回一个元组迭代器，每个元组包含所有 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)

当语句调用此函数时，此函数用于更改导入语句的语义。反而用进口挂钩更好。该功能很少使用，我们不鼓励使用该功能。

结论

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

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

34 KiB Raw Permalink Blame History Unescape Escape

Python 内置函数:简要概述

alter_)

字典()

eval()

int()

len()

列表()

内存视图()

下一个()

repr()

集合()

str()

元组()

__ 导入 _ _()

结论

34 KiB

Raw Permalink Blame History