🐚作者简介：苏凉（专注于网络爬虫，数据分析）
🐳博客主页：苏凉.py的博客
🌐系列专栏：Python基础语法专栏
👑名言警句：海阔凭鱼跃，天高任鸟飞。
📰要是觉得博主文章写的不错的话，还望大家三连支持一下呀！！！
👉关注✨点赞👍收藏📂

查阅指南

• A
• • abs()
  • all()
  • any()
• B
• • basestring()
  • bin()
  • bool()
  • bytearray()
• C
• • callable()
  • chr()
  • classmethod()
  • cmp()
  • compile()
  • complex()
• D
• • delattr()
  • dict()
  • dir()
  • divmod()
• E
• • enumerate()
  • eval()
  • execfile()
• F
• • file()
  • filter()
  • float()
  • format()
  • frozenset()
• G
• • getattr()
  • globals()
• H
• • hasattr()
  • hash()
  • help()
  • hex()
• I
• • id()
  • input()
  • int()
  • isinstance()
  • issubclass()
  • iter()
• L
• • len()
  • list()
  • locals()
  • long()
• M
• • map()
  • max()
  • memoryview()
  • min()
• N
• • next()
• O
• • oct()
  • open()
  • ord()
• P
• • pow()
  • print()
• R
• • range()
  • repr()
  • reverse()
  • round()
• S
• • set()
  • slice()
  • sorted()
  • str()
  • sum()
  • super()
• T
• • tuple()
  • type()
• V
• • vars()
• Z
• • zip()
• 结语

A

abs()

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

语法：abs( x )
x – 数值表达式。

i= -12print(abs(i)) #12print(abs(-10.5)) #10.5

all()

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。

语法：all(iterable)
iterable – 元组或列表。

x = all((0,1,2,4))  y = all([True,False,True])  z = all(()) k = all([]) print(x, y,z,k) #结果False False True True

any()

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。

语法：any(iterable)
iterable – 元组或列表。

x = any((0,1,2,3)) #123都为Truey = any((True,False,False)) #含有一个Truez = any((0,False ,'',))# 0和False以及空值都是Falseprint(x,y,z) #结果：True True False

B

basestring()

注意：Python3 不支持 basestring() 函数，改用 str() 函数。

bin()

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

语法：bin(x)
x – int 或者 long int 数字

a = 10 #a的值为整形或长整型print(bin(a)) #结果：0b1010

bool()

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

语法：bool([x])
x – 要进行转换的参数。

x = bool(0)y = bool(1)z = bool('')print(x,y,z)  #结果：False True False

bytearray()

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

语法：class bytearray([source[, encoding[, errors]]])
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

print(bytearray()) # bytearray(b'')print(bytearray(1))# bytearray(b'\x00')print(bytearray('suliang',encoding='utf-8'))# bytearray(b'suliang')

C

callable()

callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

语法：callable(object)
object – 对象

print(callable(0)) #Falsex = callable(print)print(x) #Truedef name(x):    return x+1y = name(5)print(y) #6print(callable(name)) #True

chr()

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，可以是10进制也可以是16进制的形式的数字。返回值是当前整数对应的 ASCII 字符。

语法： chr(i)
i – 可以是10进制也可以是16进制的形式的数字。

print(chr(97),chr(65),chr(0x30))#结果：a A 0

classmethod()

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A(object):    bar = 1 def func1(self): print('foo')     @classmethod    def func2(cls): print('func2') print(cls.bar) cls().func1()  # 调用 foo 方法A.func2()  #结果func2,1,foo

cmp()

cmp(x,y) 函数用于比较2个对象，如果 x y 返回 1。
Python 3 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象

import operatorx = int(input("输入第一个数："))y = int(input("输入第二个数："))z = operator.ge(x,y)print(z)

结果：

compile()

compile() 函数将一个字符串编译为字节代码。

语法：compile(source, filename, mode[, flags[, dont_inherit]])
source – 字符串或者AST（Abstract Syntax Trees）对象。。
filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志

a  =  'sliang'b = compile(a ,'0','exec')print(b)# 结果：<code object  at 0x000001E206B1D0E0, file "0", line 1>

complex()

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

语法：class complex([real[, imag]])
real – int, long, float或字符串；
imag – int, long, float；

a = complex(5,6)b = complex('15')c = complex(15)d = complex('15+2j')print(a,b,c,d)  #结果：(5+6j) (15+0j) (15+0j) (15+2j)

D

delattr()

delattr 函数用于删除属性。

语法：delattr(object, name)
object – 对象。
name – 必须是对象的属性。

class list:    a = 10    b = 20    c = 30obj = list()print(obj.b) #结果：20# 删除属性bdelattr(list,b)print(obj.b) #结果：NameError: name 'b' is not defined

dict()

dict() 函数用于创建一个字典。

语法：dict(iterable)
iterable – 可迭代对象。

dic = dict(name='苏凉',age = 21,num = '787991021')print(dic) # 结果：{'name': '苏凉', 'age': 21, 'num': '787991021'}

dir()

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表。
带参数时，返回参数的属性、方法列表。

语法：dir([object])
object – 对象、变量、类型。

dic = dict(name='苏凉',age = 21,num = '787991021')print(dic)# 结果：{'name': '苏凉', 'age': 21, 'num': '787991021'}a = dir(dic)b =dir()print(a)print(b)

结果：

divmod()

python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

语法：divmod(a, b)
a: 数字
b: 数字

print(divmod(11,3)) #除数为3，余数为2，返回（3，2）#结果：（2，0）

E

enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for循环当中。

语法：enumerate(sequence, [start=0])
sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置的值。

a = ('name','age','sex')b = list(enumerate(a,start=1))print(b)for i,j in enumerate(a,start=1):   print(i,j)

结果：

eval()

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

语法：eval(expression)
expression – 表达式。

x = eval('4*4')print(x)  #结果：16

execfile()

execfile() 函数可以用来执行一个文件。
python3 删去了 execfile(),用with open的方法来取代。

with open('./1.函数.py','r',encoding='utf-8') as fp:    exec(fp.read())

F

file()

file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。在python3中file函数已经被删除了。

f = open('test.txt','r',encoding='utf-8')print(f.read())

filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

语法：filter(function, iterable)
function – 判断函数。
iterable – 可迭代对象。

def fuc(x):    return x%2 == 0a = [1,2,3,4,5,6,7,8,9]b = filter(fuc,a)print(list(b))# 结果：[2, 4, 6, 8]

float()

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

语法：float(x)
x – 整数或字符串

print(float(5)) #结果：5.0print(float('15'))#结果：15.0

format()

format函数增强了字符串格式化的功能。

语法：是通过 {} 和 : 来代替以前的 % 。

print('name:{}，age:{}'.format('苏凉','21')) #结果：name:苏凉, age:21

frozenset()

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

语法：frozenset(iterable)
iterable – 可迭代的对象，比如列表、字典、元组等等。

list = [0,1,2,3]print(list)# 结果：[0, 1, 2, 3]ice_list = frozenset(list)print(ice_list)# 结果：frozenset({0, 1, 2, 3})

G

getattr()

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

语法:getattr(object, name[, default])
object – 对象。
name – 字符串，对象属性。
default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

class list(object):    name = '苏凉'a = list()print(getattr(a,'name'))#结果：苏凉

globals()

globals() 函数会以字典类型返回当前位置的全部全局变量。

语法：globals()

name = '苏凉'age = 21QQ_num = '787991021'def list():    a = 5    b = 10a = globals()print(a)

结果：

H

hasattr()

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

语法：hasattr(object, name)
object – 对象。
name – 字符串，属性名。

class list(object):    name = 'suliang'    age = 21    QQ_num = '787991021'a = list()print(hasattr(a,'name')) #结果：Trueprint(hasattr(a,'wechat')) #结果：False

hash()

hash() 用于获取取一个对象（字符串或者数值等）的哈希值。

语法：hash(object)
object – 对象；

list1 = [1,2,3]dict1 = {'a':1,'b':2,'c':3}print(hash('test'))print(hash(10))print(hash(str(list1)))print(hash(str(dict1)))

结果：

help()

help() 函数用于查看函数或模块用途的详细说明。

语法：help([object])
object – 对象；

help(print)a = [1,2,3]# help(a)help(a.append)

hex()

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

语法：hex(x)
x – 10进制整数

a = [15,16,170]for i in a :    b = hex(i)    print(b)

I

id()

id() 函数返回对象的唯一标识符，标识符是一个整数。
Python 中 id() 函数用于获取对象的内存地址。

语法：id([object])
object – 对象。

a = 5print(id(a))name = 'suliang'print(id(name))

结果：

input()

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

语法：input([prompt])
prompt: 提示信息

a = input('请输入：')print(type(a))

结果：

int()

int() 函数用于将一个字符串或数字转换为整型。

语法：int(x)
x – 字符串或数字。

x = '787991021'print(type(x)) #结果：a = int(x)print(type(a)) #结果：b = int(10.52)print(b,type(b)) #结果：10 

isinstance()

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

语法：isinstance(object, classinfo)
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。

a = 5print(isinstance(a,int)) #结果：Trueprint(isinstance(a,str)) #结果：Falseprint(isinstance(a,(int,float,str))) #结果：True

issubclass()

issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

语法：issubclass(class, classinfo)
class – 类。
classinfo – 类。

class list1():    num1 = 1class list2():    num2 =2class list3(list1):    passprint(issubclass(list1,list2)) #结果：Falseprint(issubclass(list3,list1)) #结果：True

iter()

iter() 函数用来生成迭代器。

语法：iter(object)
object – 支持迭代的集合对象。

x = [1,2,3,4]for i in iter(x):    print(i)

结果：

L

len()

返回对象（字符、列表、元组等）长度或项目个数。

语法：len( s )
s – 对象。

name ='suliang'print(len(name)) #结果：7list = [0,1,2,3,4,5]print(len(list)) #结果：6tup = (12,3,4,5,6)print(len(tup)) #结果：5

list()

list() 方法用于将元组转换为列表。

语法：list( tup )
tup – 要转换为列表的元组。

tup = (0,1,2,3,4)print(list(tup)) #结果：[0, 1, 2, 3, 4]

locals()

locals() 函数会以字典类型返回当前位置的全部局部变量。
语法：locals()

x = 5def list():    global x    x = 6    name = 'suliang'    age = 21    qq_num = '787991021'    print(locals())list()

long()

Python3以后的版本已删除 long() 函数。（将数字或字符串转换为一个长整型。）

M

map()

map() 会根据提供的函数对指定序列做映射。返回迭代器。

语法：map(function, iterable)
function – 函数
iterable – 一个或多个序列

def fc(x):    return x*5i = map(fc,[1,2,3,4,5])print(list(i))#结果：[5, 10, 15, 20, 25]

max()

max() 方法返回给定参数的最大值，参数可以为序列。

语法：max(x,y,z…)
x ,y,z-- 数值表达式。

list = [28,32,65,48,45,21,41]print(max(list)) #结果：65

memoryview()

memoryview() 函数返回给定参数的内存查看对象(memory view)。

语法：memoryview(obj)
obj – 对象

x =memoryview(bytearray('abcdefg',encoding='utf-8'))print(x[2]) #结果：99 返回c对应的ascii码值。

min()

min() 方法返回给定参数的最小值，参数可以为序列。

语法：min( x, y, z, … )
x,y,z-- 数值表达式。

list = [28,32,65,48,45,21,41]print(min(list)) #结果：21

N

next()

next() 返回迭代器的下一个项目。next() 函数要和生成迭代器的 iter() 函数一起使用。

语法：next(iterable)
iterable – 可迭代对象

y =[1,2,3,4,5]x = iter(y)count = 0while True:    count = count+1    if count<=5: y =next(x) print(y)    else: break

O

oct()

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

语法：oct(x)
x – 整数。

print(oct(10))print(oct(5))print(oct(100))# 结果：0o12  0o5  0o144

open()

python open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

语法：open(name, mode）
name : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式：只读，写入，追加等。

f = open('test.txt','r',encoding='utf-8')print(f.read())

ord()

ord() 函数它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值。

语法：ord( c )
c – 字符。

print(ord('A')) #结果：65print(ord('a')) #结果：97

P

pow()

pow() 方法返回 xy（x 的 y 次方） 的值。

语法：pow( x, y ，z)
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。

print(pow(2,3)) #结果：8print(pow(2,3,5))  #结果：3

print()

print() 方法用于打印输出，最常见的一个函数。

语法：*print(objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file – 要写入的文件对象。
flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

print('www','baidu','com',sep='.',end=' ',)print('百度一下')#结果：www.baidu.com 百度一下

R

range()

range() 返回的是一个可迭代对象（类型是对象）

语法：range(start, stop, step)
start: 计数从 start 开始。默认是从 0 开始。
stop: 计数到 stop 结束，但不包括 stop。
step：步长，默认为1。

print(list(range(1, 11)))print(list(range(1,11,2))) #取步长为2name = '苏凉'for i in range(len(name)):    print(name[i])

结果：

repr()

repr() 函数将对象转化为供解释器读取的形式。

语法：repr(object)
object – 对象。

list = 'name \t苏凉 \n age \t21 'print(list)print(repr(list))

结果：

reverse()

reverse() 函数用于反向列表中元素。

语法：list.reverse()

list = [1,2,3,4,5,6]list.reverse()print(list)#结果：[6, 5, 4, 3, 2, 1]

round()

round() 方法返回浮点数x的四舍五入值。

语法：round( x ，n )
x – 数值表达式。
n – 数值表达式，表示从小数点位数，保留n位数。

print(round(100.531,2)) #结果：100.53print(round(100.1149,3)) #结果：100.115print(round(3.1415926*25,2)) #结果：78.54

S

set()

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法：set([iterable])
iterable – 可迭代对象对象；

x = set('youtoo')y = set('you')print(x,y)print(x&y) #交集print(x|y) #并集print(x-y) #差集

结果：

slice()

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

语法：slice(start, stop,[ step])
start – 起始位置
stop – 结束位置
step – 间距

set_slice = slice(6) #设置切片为6x = list(range(1,11))print(x[set_slice]) #截取前6个数# 结果：[1, 2, 3, 4, 5, 6]

sorted()

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

语法：sorted(iterable)
iterable – 可迭代对象。

list = [5,2,4,6,7,2,8,9]print(sorted(list))#结果：[2, 2, 4, 5, 6, 7, 8, 9]name = 'suliang'print(sorted(name))#结果：['a', 'g', 'i', 'l', 'n', 's', 'u']

str()

str() 函数将对象转化为适于人阅读的形式。

语法：str(object)
object – 对象。

name = 'suliang'print(str(name))list = 'name \t苏凉 \n age \t21 'print(str(list))

结果：

sum()

sum() 方法对序列进行求和计算。

语法：sum(iterable）, start)
iterable – 可迭代对象，如：列表、元组、集合。
start – 指定相加的参数，如果没有设置这个值，默认为0。

print(sum((1, 2, 3), 4)) #结果：10print(sum((1,2),5)) #结果：8

super()

super() 函数是用于调用父类(超类)的一个方法。

语法：super().xxx

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

T

tuple()

tuple() 函数将列表转换为元组。

语法：tuple( iterable )
iterable – 要转换为元组的可迭代序列。

list = [1,2,3,4,5]print(tuple(list)) #结果：(1, 2, 3, 4, 5)dic = {'name':'suliang','age':21}print(tuple(dic.values())) #结果：('suliang', 21)

type()

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

语法：type(object)
object – 对象

a = 5b = [1,2,3]c = 'suliang'print(type(a),type(b),type(c))# 结果：  print(type(a)==int)#结果：True

V

vars()

vars() 函数返回对象object的属性和属性值的字典对象。

语法：vars([object])
object – 对象

class list:    a = 5print(vars(list))#结果：{'__module__': '__main__', 'a': 5, '__dict__': , '__weakref__': , '__doc__': None}

Z

zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

语法：zip([iterable, …])
iterabl – 一个或多个迭代器;

x = (1,2,3)y = (4,5,6)z = (7,8,9)print(list(zip(x)))#结果：[(1,), (2,), (3,)]n = zip(x,y,z)print(list(n))#结果：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]# 解压缩o,p = zip(*zip(x,y))print(list(o),list(p))# 结果：[1, 2, 3] [4, 5, 6]

结语

这里包含了python所有的内置函数的用法供大家参考以及学习，有不足或是补充的可以在评论区讨论说着私信我一起讨论啊！关注我，咱们下期再见！！

全民K歌电脑版