Python语法速查: 1. 数据类型与内置函数

 

 (1)常用内置数据类型

分类类型名称描述
数字int整数
float浮点数
complex复数
bool布尔值
序列str字符串(不可变序列)
list列表
tuple元组(不可变序列)
range整数范围(不可变序列)
bytes字节数组(不可变序列)
bytearray可变字节数组
映射dict字典
集合set可变集合
frozenset不可变集合
NoneNoneType空对象,它没有任何属性

 

 

  (2)类型检查常用方法

用法类型描述举例
id(实例)内置函数返回一个对象的身份(整数)

id(a)

type(实例)内置函数返回一个对象实例的类型type(a)
is运算符比较2个对象是否同一身份

a is b

type(a) is str

type(a) is type(b)   # a与b是否同一类型

isinstance(实例, 类名)内置函数入参对象是否是入参类的实例

isinstance(s, list) # s是否为列表

isinstance(f, Foo)  # f是否为Foo类的实例

 

 

  (3)常用内置函数

名称简述用法举例或说明
数学运算
abs()返回一个数的绝对值abs(x)abs(a)
pow()x的y次方运算,将结果对z取模pow(x, y[,z])

pow(2,3,3) # 结果为2

round()将x按10的负n次取四舍五入round(x[, n=0]) 舍入规则见下详述
divmod()将a除以b的商和余数作为元组返回divmod(a, b)

divmod(10,3) # 结果为(3,1)

内置数据类型实例生成
int()根据入参数字或字符串,生成整数实例int(x[, base=10])base默认为10, 详见下例
float()根据入参数字或字符串,生成浮点数实例float(x)

float(3) # 结果为3.0

complex()生成复数实例complex(r[, i])较少用到
bool()生成布尔值实例bool([x])不带入参时默认返回False
list()生成列表实例list([item])item须是可迭代对象
dict()生成字典实例dict([m])详见下述
tuple()生成元组实例tuple([items])item须是可迭代对象
str()生成字符串实例str([object])入参object的__str__方法
range()创建range实例

range(stop)

range(start, stop [,step])

range对象可以用迭代、也可用切片访问
set()生成集合实例set([items])item须是可迭代对象
frozenset()生成不可变集合实例frozenset([items])item须是可迭代对象
slice()生成切片对象

slice(stop)

slice(start, stop [,step])

较少直接使用

bytes()生成不可变字节数组实例bytes([source [,encoding [,errors]]])详见下述
bytearray()生成可变字节数组实例bytearray([source [,encoding [,errors]]])用法同上,内容可变
memoryview()生成memoryview实例memoryview(obj)较少用到
object()生成一个基类实例object()较少用到
编码与解码
hex()将数值x用16进制字符串表示hex(x)

hex(16) # 结果为’0x10′

oct()将数值x用8进制字符串表示oct(x)

oct(16) # 结果为’0o20′

bin()将数值x用2进制字符串表示bin(x)

bin(8) # 结果为’0b1000′

ord()将单字符转换成utf-8数值ord(c)

ord(‘a’) # 结果为97

ord(‘数’) # 结果为25968

chr()将数值x转换成单字符字符串chr(x)

chr(97) # 结果为’a’

chr(25968) # 结果为’数’

ascii()像repr()那样显示对象,非ASCII字符显示为转义序列ascii(object)较少用到
序列操作
len()返回s中包含的项数len(s)s可以是:列表、元组、字符串、集合、字典
min()如果只有1个参数s,返回s中各项的最小值。如果有多个参数,返回各个参数中的最小值。min(s[, args, …])

s可以是可迭代对象

min([1,3,5]) # 结果为1

min(1,3,5,7) # 结果为1

max()如果只有1个参数s,返回s中各项的最大值。如果有多个参数,返回各个参数中的最大值。max(s[, args, …])

s可以是可迭代对象

min([1,3,5]) # 结果为5

min(1,3,5,7) # 结果为7

sum()计算可迭代对象iter中所有项的和,initial为累加初始值,默认为0。只能用于数值计算。sum(iter[ ,initial])

sum([1,2,3]) # 结果为6

sum([1,2,3], 10) # 结果为16

迭代操作
all()若可迭代对象iterable中的所有值都为True,则返回True。all(iter)

all([0,1,2,3]) # 结果为False

any()若可迭代对象iterable中的任意值为True,则返回True。any(iter)

any([0,1,2,3]) # 结果为True

enumerate()根据入参迭代器,产生一个新迭代器,其中每个元素为一个元组:内含一个计数值和原迭代出的值。enumerate(iter[ ,start=0])

for i,x in enumerate([‘a’,’b’])

    pass

    # 结果迭代出(0,’a’), (1,’b’)

zip()产生一个新迭代器,第n个元素为一个(s1[n], s2[n], …)的元组,其长度为最短的一个迭代器长度。zip([s1 [, s2 [, …]]])

a = [1,2,3]

b = [‘x’,’y’]

for t in zip(a, b)

    pass

    # 迭代结果为(1,’x’), (2,’y’)

sorted()根据入参迭代器的内容排序,创建有序列表sorted(iter, *, key=None, reverse=False)详见下述
reversed()产生一个迭代器,将入参序列的所有元素位置颠倒(注意:跟sorted()完全不同)reversed(seq)

for x in reversed([1,2,’a’]):

    pass

    # 迭代结果为 ‘a’, 2, 1

filter()产生一个迭代器,其内容是对入参iter中的每个元素使用func函数进行过滤,只有func返回True的才被加入新迭代器。filter(func, iter)

a = [1,2,3,4,5,6,7,8]

filter(lambda x:x%2==1, a)

# 迭代器中内容为 1,3,5,7

map()产生一个迭代器,其每一项是将函数func应用到iter中的每一项返回的结果。若入参有多个iter迭代器,则相应的函数func应有多个入参。map(func, iter, …)

map(lambda x:x*2, [1,3,5,7])

# 迭代器中内容为 2,6,10,14

iter()返回一个可生成object中各项的迭代器。iter(object[ ,sentinel])

较少直接使用

next()返回迭代器iter中的下一项。next(iter[ ,default])

较少直接使用

对象实例操作
id()返回object的唯一整数标识符(这是一个内存位置)。id(object)

结果为一个整数,较少直接使用

type()当单参数调用时,返回入参object的类型。当三参数调用时,创建一个新type对象(一般用于元类)。

type(object)

type(name, bases, dict)

type(1) # 结果为<class ‘int’>

type(‘a’) # 结果为<class ‘str’>

isinstance()如果object是clsinfo类的一个实例,则返回True。clsinfo可以是一个含多个类的元组。isinstance(object, clsinfo)

# 设有一个名为Foo的自定义类

f = Foo()

isinstance(f, Foo) # True

isinstance(f, (Foo,list)) # True

isinstance([1,2], (Foo,list)) # True

isinstance(f, (list,tuple) # False

repr()返回object的字符串表示形式。repr(object)一般在类内部的__repr__()方法会定义本对象的字符串表示形式。
dir()返回object对象的属性名(含方法名)列表,若object是一个模块,则返回其内部定义的符号列表。dir(object)如果类内部定义了__dir__属性,则返回此值。
hasattr()若name是object的属性名,则返回Truehasattr(object, name)

入参name是一个字符串

getattr()返回对象的name属性的值,若无此属性,则default是可选的返回值,否则引起AttributeError。getattr(object, name [,default])

a = getattr(obj, ‘p1’)

# 效果同 a = obj.p1

setattr()设置对象的属性setattr(object, name, value)

setattr(obj, ‘p1’, a)

# 效果同 obj.p1 = a

delattr()删除对象的属性delattr(object, name)

del(obj, ‘p1’)

# 效果同 del obj.p1

hash()返回对象的整数散列值。一般可变对象不会定义散列值,除非类内部定义了__hash__()方法。hash()

hash(‘abc’) # 结果为526986374

hash(3.14)  # 结果为1846836513

callable()检查一个对象是否是可调用的。但有时即便返回 True,object 仍然可能调用失败。callable(object)对于函数、方法、lamdba表达式、类、实现了__call__()方法的类实例,它都返回True。
类操作
staticmethod()创建在类中使用的静态方法。staticmethod(func)一般通过@staticmethod装饰器隐式调用该函数
classmethod()创建在类方法。classmethod(func)一般通过@classmethod装饰器隐式调用该函数
issubclass()如果class是clsinfo的子类,或class是基于抽象基类clsinfo注册的,则返回True。clsinfo可以是一个含多个类的元组。issubclass(class, clsinfo)

issubclass(Foo, BaseFoo) # 结果为 True

issubclass(Foo, (BaseFoo,list) # 结果为 True

super()

返回一个代理对象,提供可以调用基类中的方法的手段。type是当前子类名,object一般是self。

在Python3中,在子类方法中可以省略type和object参数,直接简写成:super()

super(type [,object])

class B(A):

  def foo(self):

    # 调用基类A的foo方法

    super(B,self).foo()

    # 在Python3中可简写成:

    # super().foo()

property()创建一个虚拟属性。fget, fset, fdel分别为自定义的属性读取、设置、删除方法,doc为文档字符串。property(fget=None, fset=None, fdel=None, doc=None)

class C:

  def __init__(self):

    self._x = ‘c’

  def gx(self):

    return self._x

  x=property(fget=gx, doc=’a’)

  # 定义了一个只读的属性x

域操作
globals()返回代表当前全局作用域的所有符号的字典。globals()

globals()

locals()返回代表当前局部作用域的所有符号的字典。locals()

locals()

var()返回object的所有属性和属性值的字典对象,如果没有入参,则相当于调用locals()var([object])

vars(obj)

输入输出与文件操作
input()显示prompt提示信息,并读取一行输入,将读入内容不作任何修改作为字符串返回。(Python3中取消了原raw_input()函数)input([prompt])

>>> input(‘pls ipt:’)

pls ipt:123

# 返回结果为:’123′

print()打印一系列值到屏幕上。入参中可设置:多个显示对象之间的分隔符、换行符、输出设备、强制刷新等,一般不用修改。print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

一般用于调试用

open()打开文件并返回一个新文件对象。open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

在文件操作章节详细描述

杂项
eval()计算入参表达式expr的值,expr是一个字符串或代码对象。globals和locals参数可指定操作时的全局和局部命名空间映射对象。eval(expr, globals=None, locals=None)

x = 1

eval(‘x+1’) # 结果为2

exec()执行Python语句,入参code可以是字符串、文件或代码对象。globals和locals参数可指定操作时的全局和局部命名空间映射对象。exec(code[, globals[, locals]])

x = 1

code = “””s = x + 1

print(s)”””

exec(code) # 结果为2

exec(code, {‘x’:10}) # 结果为11

format()按照format_spec中的格式将value转换为有格式的字符串,该操作调用value.__format__()方法。format(value[, format_spec])

一般在格式化字符串时被隐式调用

help()调用内置的帮助系统。object可以是字符串(表示模块名、类名、函数名、方法名、关键字、文档主题名称),如果是其他类型的对象,则会出现与该对象有关的帮助界面。help([object])

help(‘math’)

compile()将source对象编译为代码对象,结果可被用于eval()和exec()函数。compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

若不是开发框架的话,一般用不到

breakpoint()Python3.7中新增的内置函数,用来设置程序运行时的断点,程序运行到该函数时自动进入调试器。这是个方便函数,可以让你很方便地进入Pdb调试器(不用再显式导入调试模块等)。breakpoint(*args, **kws)在需要设置断点的地方直接调用breakpoint()即可

 

 

 

● round(x[, n])

说明:

在Python3中,当被舍入数字为5且为第1位小数时,舍入规则如下:若被舍入数字的前一个数为偶数,则朝0方向进行四舍五入;否则远离0,正负数都遵循这个规则。其它位的四舍五入不适用此规则,依旧按照普通数学规则进行。

举例:

>>> round(2.5)  # 结果为2
>>> round(-2.5) # 结果为2
>>> round(3.5)  # 结果为4
>>> round(-3.5) # 结果为4

返回索引

 

 

 

● int(x[, base])

说明:

x可以是数字或字符串,base是入参的转换进制基数,可以是2、8、16、16等,转换结果总是10进制整数。

举例:

>>>  int('100') # 结果为100
>>>  int('100', 10) # 结果为100
>>>  int('100', 16) # 结果为256
>>>  int('100', 2) # 结果为4

返回索引

 

 

 

● dict([m])

说明:

入参m若是字典,则dict(m)就创建一个m浅复制。若m不是字典,则必须能够产生(key, value)形式的迭代值。也可用关键字创建字典,见下例。

举例:

>>>  dict('a'=1, 'b'=2) # 结果为{'a':1, 'b':2}
>>>  dict() # 结果为空字典{}

返回索引

 

 

 

● bytes([source [,encoding [,errors]]])

说明:

生成不变字节数组,入参source为原始输入字符串,入参encoding指定要使用的字符编码方式。

举例:

>>> x = bytes()   # 结果为空字节数组 b''
>>> x = b''   # 结果同上
>>> x = bytes('abc')   # 结果为 b'abc'
>>> x = bytes('ab数字', 'utf-8')  # 结果为 b'ab\xe6\x95\xb0\xe5\xad\x97' 

返回索引

 

 

 

● sorted(iter, *, key=None, reverse=False)

说明:

根据iter迭代器中的各项值的内容进行排序(从小到大),创建有序列表,一般只能对数字或字符串进行排序。key是个单参数函数,可以对元素在被排序前进行预处理,将一些常规来说不能排序的元素预处理成可排序的数字或字符串。reverse是个标志位,用以指出是否逆序(从大到小)排序。(注意:Python3最新版本中已废除了cmp参数)

举例:

>>>  sorted([1,7,3,5])  # 结果为[1,3,5,7]
>>>  sorted([1,7,3,5], reverse=True)  # 结果为[7,5,3,1]
>>>  sorted(['c','b','a']) # 结果为['a','b','c']
>>>  sorted([('b',2),('a',1)], key=lambda x:x[1]) # 结果为[('a',1),('b',2)]
>>>  # 上例说明:入参列表中的元素为元组,一般不能排序。但这里用lambda生成了一个匿名函数,对元素进行预处理,取出每个元素元组中的数字,然后用这个数字作为排序依据,给sorted()函数进行排序

返回索引

 

 

 

 

 

 

返回标题

 

    原文作者:初级电路与软件研究
    原文地址: https://www.cnblogs.com/initcircuit/p/11488026.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞