Python 常用内置函数

abs 取绝对值

print(abs(-1))  #结果1

all(...)

all(iterable) -> bool

Return True if bool(x) is True for all values x in the iterable.

If the iterable is empty, return True.

如果iterable的所有元素不为0、‘‘、False或者iterable为空，all(iterable)返回True，否则返回False；函数等价于：

1 def all(iterable):
2
3     for element in iterable:
4         if not element:
5             return False
6     return True

示例：

 1 >>> all([‘a‘, ‘b‘, ‘c‘, ‘d‘])  #列表list，元素都不为空或0
 2 True
 3 >>> all([‘a‘, ‘b‘, ‘‘, ‘d‘])  #列表list，存在一个为空的元素
 4 False
 5 >>> all([0, 1，2, 3])  #列表list，存在一个为0的元素
 6 False
 7
 8 >>> all((‘a‘, ‘b‘, ‘c‘, ‘d‘))  #元组tuple，元素都不为空或0
 9 True
10 >>> all((‘a‘, ‘b‘, ‘‘, ‘d‘))  #元组tuple，存在一个为空的元素
11 False
12 >>> all((0, 1，2, 3))  #元组tuple，存在一个为0的元素
13 False
14
15 >>> all([]) # 空列表
16 True
17 >>> all(()) # 空元组
18 True

注意：空元组、空列表返回值为True，这里要特别注意。

any(...)

any(iterable) -> bool

Return True if bool(x) is True for any x in the iterable.

If the iterable is empty, return False.

any(iterable)说明：参数iterable：可迭代对象；

如果当iterable所有的值都是0、‘‘或False时，那么结果为False，如果所有元素中有一个值非0、‘‘或False，那么结果就为True

函数等价于：

1 def any(iterable):
2
3    for element in iterable:
4
5        if  element:
6
7            return False
8
9    return True

示例：

 1 >>> any([‘a‘, ‘b‘, ‘c‘, ‘d‘])  #列表list，元素都不为空或0
 2 True
 3
 4 >>> any([‘a‘, ‘b‘, ‘‘, ‘d‘])  #列表list，存在一个为空的元素
 5 True
 6
 7 >>> any([0, ‘‘, False])  #列表list,元素全为0,‘‘,false
 8 False
 9
10 >>> any((‘a‘, ‘b‘, ‘c‘, ‘d‘))  #元组tuple，元素都不为空或0
11 True
12
13 >>> any((‘a‘, ‘b‘, ‘‘, ‘d‘))  #元组tuple，存在一个为空的元素
14 True
15
16 >>> any((0, ‘‘, False))  #元组tuple，元素全为0,‘‘,false
17 False
18
19 >>> any([]) # 空列表
20 False
21
22 >>> any(()) # 空元组
23 False

ascii(object)

As repr(), return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by repr() using \x, \u or \U escapes. This generates a string similar to that returned by repr() in Python 2.

说明：

1. 返回一个可打印的对象字符串方式表示，如果是非ascii字符就会输出\x，\u或\U等字符来表示。与python2版本里的repr()是等效的函数。

>>> ascii(1)
‘1‘
>>> ascii(‘&‘)
"‘&‘"
>>> ascii(9000000)
‘9000000‘
>>> ascii(‘中文‘) #非ascii字符
"‘\\u4e2d\\u6587‘"

bin,oct,hex

print(bin(10)) #10进制转2进制
print(oct(10)) #10进制转8进制
print(hex(10)) #10进制转16进制

bytearray([source[, encoding[, errors]]])

返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。可以通过“字节与字节数组操作”章节来查看相关字节数组的内容。下面说明一下几种特别的使用方法：

1. 如果source是一个字符串，那么必须给出endcoding是什么样编码的，以便转换为合适的字节保存。

2. 如果source是一个整数，那么这个数组将初始化为空字节。

3. 如果source是一个有缓冲区接口的对象，那么只读的接口初始到数组里。

4. 如果source是一个迭代对象，那么这个迭代对象的元素都必须符合0 <= x < 256，以便可以初始化到数组里。

如果没有输入任何参数，默认就是初始化数组为0个元素。

例子：

#bytearray()函数  

a = bytearray(‘1234深圳‘, ‘utf-8‘)
print(a)  

b = bytearray()
print(b)  

c = [1,4,5,7,8]
print(bytearray(c)) 

输出结果如下：

bytearray(b‘1234\xe6\xb7\xb1\xe5\x9c\xb3‘)

bytearray(b‘‘)

bytearray(b‘\x01\x04\x05\x07\x08‘)

bytes

返回一个新的数组对象，这个数组对象不能对数组元素进行修改。每个元素值范围: 0 <= x < 256。bytes函数与bytearray函数主要区别是bytes函数产生的对象的元素不能修改，而bytearray函数产生的对象的元素可以修改。因此，除了可修改的对象函数跟bytearray函数不一样之外，其它使用方法全部是相同的。最后它的参数定义方式也与bytearray函数是一样的。

#bytes()函数  

a = bytes(‘abc‘, ‘utf-8‘)
print(a)  

b  = bytes(1)
print(b)  

c = bytes([2,3,6,8])
print(c)

输出结果如下：

b‘abc‘

b‘\x00‘

b‘\x02\x03\x06\x08‘

callable 是否是可被调用的，返回True或False

print(callable(bytes))
print(callable(abs))

打印结果：
True
True

chr() 函数用一个范围在range（256）内的（就是0～255）整数作参数，返回一个对应的字符

>>> chr(65)
‘A‘

ord() 函数是chr()函数（对于8位的ASCII字符串）或unichr()函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了你的Python定义范围，则会引发一个TypeError的异常。

>>>ord(‘a‘) 97

compile()--编译   执行字符串表示的函数，并为该函数提供全局变量

　　这个函数有什么用呢? 一个最简单的例子, 就是我们的代码, 会被解释器读取,解释器读取后的其实是字符串, 然后通过compile编译后, 又转换成python可识别的代码.这样python就能执行了.

　　这里就有一个例子, 是将一段str字符串, 通过compile编译为python代码. 具体如下:

　　参考自http://www.cnblogs.com/wupeiqi/p/4592637.html

本篇的内容从题目中就可以看出来，就是为之后剖析tornado模板做准备，也是由于该知识点使用的巧妙，所有就单独用一篇来介绍了。废话不多说，直接上代码：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

#!usr/bin/env python

#coding:utf-8

 

namespace = {‘name‘:‘wupeiqi‘,‘data‘:[18,73,84]}

 

code =  ‘‘‘def hellocute():return  "name %s ,age %d" %(name,data[0],) ‘‘‘

 

func = compile(code, ‘<string>‘, "exec")

 

exec func in namespace

 

result = namespace[‘hellocute‘]()

 

print result

此段代码的执行结果是：name wupeiqi,age 18

上述代码解析：

  • 第6行，code是一个字符串，该字符串的内容是一个函数体。
  • 第8行，将code字符串编译成函数 hello
  • 第10行，将函数 hello 添加到namespace字典中（key为hello），同时也将python的所有内置函数添加到namespace字段中（key为__builtins__），如此一来，namespace中的内容好比是一个个的全局变量，即

    1

    2

    3

    4

    5

    name ＝ wupeiqi

    data ＝ [18,73,84]

    def hellocute():

        return  "name %s ,age %d" %(name,data[0],)
  • 第12行，执行Hello函数并将返回值复制给result
  • 第14行，输入result

这段代码用的很是巧妙有木有，亮瞎狗眼有木有，居然把字符串变成了函数并且还为该函数提供了全局变量。对于该功能，它就是python的web框架中模板语言部分至关重要的部分，因为在模板处理过程中，首先会读取html文件，然后分割html文件，再然后讲分割的文件组成一个字符串表示的函数，再再然后就是利用上述方法执行字符串表示的函数。

complex([real[, imag]]) 

本函数可以使用参数real + imag*j方式创建一个复数。也可以转换一个字符串的数字为复数；或者转换一个数字为复数。如果第一个参数是字符串，第二个参数不用填写，会解释这个字符串且返回复数；不过，第二个参数不能输入字符串方式，否则会出错。real和imag参数可以输入数字，如果imag参数没有输入，默认它就是零值，这个函数就相当于int()或float()的功能。如果real和imag参数都输入零，这个函数就返回0j。有了这个函数，就可以很方便地把一个列表转换为复数的形式。

注意：当想从一个字符串的复数形式转换复数时，需要注意的是在字符串中间不能出现空格，比如写成complex(‘1+2j’)，而不是写成complex(1 +2j’)， 否则会返回ValueError异常。

#complex()  

print(complex(1))
print(complex(‘2+1j‘))
print(complex(2, 5))  

l = [1, 3, 4, 5]
for i in l:
    print(complex(i, 5))  

结果输出如下：

(1+0j)

(2+1j)

(2+5j)

(1+5j)

(3+5j)

(4+5j)

(5+5j)

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

语法：

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

参数说明：

  • **kwargs -- 关键字
  • mapping -- 元素的容器。
  • iterable -- 可迭代对象
>>>dict()                        # 创建空字典
{}
>>> dict(a=‘a‘, b=‘b‘, t=‘t‘)     # 传入关键字
{‘a‘: ‘a‘, ‘b‘: ‘b‘, ‘t‘: ‘t‘}
>>> dict(zip([‘one‘, ‘two‘, ‘three‘], [1, 2, 3]))   # 映射函数方式来构造字典
{‘three‘: 3, ‘two‘: 2, ‘one‘: 1}
>>> dict([(‘one‘, 1), (‘two‘, 2), (‘three‘, 3)])    # 可迭代对象方式来构造字典
{‘three‘: 3, ‘two‘: 2, ‘one‘: 1}
>>>

dir() 返回包含要查询对象的所有属性名称的列表

要查看python某个模块可以干什么，先要导入模块，之后用上面讲过的方式查看就可以。比如要查看sys模块都可以干什么，可以像下边这样操作：

>>> import sys  # 获得属性列表，在这里是sys模块的属性列表

>>> dir(sys)
[‘__displayhook__‘, ‘__doc__‘, ‘__excepthook__‘, ‘__name__‘, ‘__package__‘, ‘__stderr__‘, ‘__stdin__‘, ‘__stdout__‘, ‘_clear_type_cache‘, ‘_compact_freelists‘,‘_current_frames‘, ‘_getframe‘, ‘api_version‘, ‘argv‘, ‘builtin_module_names‘, ‘byteorder‘, ‘call_tracing‘, ‘callstats‘, ‘copyright‘, ‘displayhook‘, ‘dllhandle‘, ‘dont_write_bytecode‘, ‘exc_info‘, ‘excepthook‘, ‘exec_prefix‘, ‘executable‘,‘exit‘, ‘flags‘, ‘float_info‘, ‘getcheckinterval‘, ‘getdefaultencoding‘, ‘getfilesystemencoding‘, ‘getprofile‘, ‘getrecursionlimit‘, ‘getrefcount‘, ‘getsizeof‘,‘gettrace‘, ‘getwindowsversion‘, ‘hexversion‘, ‘intern‘, ‘maxsize‘, ‘maxunicode‘, ‘meta_path‘, ‘modules‘, ‘path‘, ‘path_hooks‘, ‘path_importer_cache‘, ‘platform‘, ‘prefix‘, ‘ps1‘, ‘ps2‘, ‘setcheckinterval‘, ‘setprofile‘, ‘setrecursionlimit‘, ‘settrace‘, ‘stderr‘, ‘stdin‘, ‘stdout‘, ‘subversion‘, ‘version‘, ‘version_info‘, ‘warnoptions‘, ‘winver‘]

divmod(a,b)  方法返回的是a//b（除法取整）以及a对b的余数，返回结果类型为tuple，参数：a,b可以为数字（包括复数）

>>> divmod(9,2)
(4, 1)
>>> divmod(11,3)
(3, 2)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

enumerate()

  • enumerate()是python的内置函数
  • enumerate在字典上是枚举、列举的意思
  • 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
  • enumerate多用于在for循环中得到计数
  • enumerate()返回的是一个enumerate对象，例如：

例：

  • 如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：
list1 = ["这", "是", "一个", "测试"]
for i in range (len(list1)):
    print i ,list1[i]
  • 上述方法有些累赘，利用enumerate()会更加直接和优美：
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print index, item
>>>
0 这
1 是
2 一个
3 测试
  • enumerate还可以接收第二个参数，用于指定索引起始值，如：
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
    print index, item
>>>
1 这
2 是
3 一个
4 测试

eval() 将字符串str当成有效的表达式来求值并返回计算结果

语法： eval(source[, globals[, locals]]) -> value

　　参数：

　　　　source：一个Python表达式或函数compile()返回的代码对象

　　　　globals：可选。必须是dictionary

　　　　locals：可选。任意map对象

可以把list,tuple,dict和string相互转化。
#################################################
字符串转换成列表
>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
>>>type(a)
<type ‘str‘>
>>> b = eval(a)
>>> print b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
>>> type(b)
<type ‘list‘>
#################################################
字符串转换成字典
>>> a = "{1: ‘a‘, 2: ‘b‘}"
>>> type(a)
<type ‘str‘>
>>> b = eval(a)
>>> print b
{1: ‘a‘, 2: ‘b‘}
>>> type(b)
<type ‘dict‘>
#################################################
字符串转换成元组
>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
>>> type(a)
<type ‘str‘>
>>> b = eval(a)
>>> print b
([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
>>> type(b)
<type ‘tuple‘>

exec() 是Python的built-in函数。其作用很好描述，就是执行以string类型存储的Python代码

>>> i = 2
>>> j = 3
>>> exec("ans = i + j")
>>> print("Answer is: ", ans)
Answer is:  5
>>>

在上个例子里面，ans变量并没有显式的定义，但仍然可以在print函数中调用。这是exec语句执行了"ans = i + j"中的代码，定义了ans变量。

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

def is_odd(x):
    return x % 2 == 1

然后，利用filter()过滤掉偶数：

>>>filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

结果：
[1, 7, 9, 17]

float() 函数功能将一个数值或者字符转换成浮点型数值

>>> float(3)
3.0
>>> float(‘3‘)
3.0

format() 函数

语法

它通过{}和:来代替%。

“映射”示例

通过位置

In [1]: ‘{0},{1}‘.format(‘kzc‘,18) Out[1]: ‘kzc,18‘ In [2]: ‘{},{}‘.format(‘kzc‘,18) Out[2]: ‘kzc,18‘ In [3]: ‘{1},{0},{1}‘.format(‘kzc‘,18) Out[3]: ‘18,kzc,18‘

字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。
通过关键字参数

In [5]: ‘{name},{age}‘.format(age=18,name=‘kzc‘) Out[5]: ‘kzc,18‘

通过对象属性

class Person: def __init__(self,name,age): self.name,self.age = name,age def __str__(self): return ‘This guy is {self.name},is {self.age} old‘.format(self=self)
In [2]: str(Person(‘kzc‘,18)) Out[2]: ‘This guy is kzc,is 18 old‘

通过下标

In [7]: p=[‘kzc‘,18] In [8]: ‘{0[0]},{0[1]}‘.format(p) Out[8]: ‘kzc,18‘

有了这些便捷的“映射”方式，我们就有了偷懒利器。基本的python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。

格式限定符

它有着丰富的的“格式限定符”（语法是{}中带:号），比如：

填充与对齐
填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
比如

In [15]: ‘{:>8}‘.format(‘189‘) Out[15]: ‘ 189‘ In [16]: ‘{:0>8}‘.format(‘189‘) Out[16]: ‘00000189‘ In [17]: ‘{:a>8}‘.format(‘189‘) Out[17]: ‘aaaaa189‘

精度与类型f
精度常跟类型f一起使用

In [44]: ‘{:.2f}‘.format(321.33345) Out[44]: ‘321.33‘

其中.2表示长度为2的精度，f表示float类型。

其他类型
主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。

In [54]: ‘{:b}‘.format(17) Out[54]: ‘10001‘ In [55]: ‘{:d}‘.format(17) Out[55]: ‘17‘ In [56]: ‘{:o}‘.format(17) Out[56]: ‘21‘ In [57]: ‘{:x}‘.format(17) Out[57]: ‘11‘

用，号还能用来做金额的千位分隔符。

In [47]: ‘{:,}‘.format(1234567890)
Out[47]: ‘1,234,567,890‘

frozenset（） 定义不可变集合，集合不能加也不能减

s1=frozenset({1,2,3,4})
print(type(s1))

globals（）查看全局作用域

print(globals())

hash() 返回对象的哈希值，用整数表示。哈希值在字典查找时，可用于快速比较键的值,相等的数值，即使类型不一致，计算的哈希值是一样的

>>> 1.0 == 1
True
>>> hash(1.0)
>>> hash(1)
>>> hash(1.0000)

help() 查看帮助文档

#给函数加文档解释，用到单引号，双引号，三引号
def func():
    # ‘‘‘
    # test function
    # :return:
    # ‘‘‘
    pass

print(help(func))

id() 是python解释器实现的功能，只是反映了变量在内存的地址,但并不是真实的内存地址

x=1
print(id(x))

input() 提供了promat参数，首先将参数值输出到标准的输出，并且不换行。函数读取用户输入的值，将其转换成字符串。

>>> s = input(‘please input your name:‘)
please input your name:Ain
>>> s
‘Ain‘

int() 将一个数字或base类型的字符串转换成整数

int(3.14)            # 3
int(2e2)             # 200
int(100, 2)          # 出错，base 被赋值后函数只接收字符串

int(‘23‘, 16)      # 35
int(‘Pythontab‘, 8)      # 出错，Pythontab不是个8进制数

isinstance()来判断一个对象是否是一个已知的类型

如果参数object是classinfo的实例，或者object是classinfo类的子类的一个实例， 返回True。如果object不是一个给定类型的的对象， 则返回结果总是False。

如果classinfo不表示一个类（类型对象）, 那么它要么是一个类的元组, 或者递归地包含这样的（由数据类型构成的）元组.其他的序列类型是不被允许的。

如果classinfo不是一种数据类型或者由数据类型构成的元组，将引发一个TypeError异常。

举例：
>>> isinstance(1, int)
True
>>> isinstance(1.0, float)
True
时间： 2024-10-24 14:06:05

Python 常用内置函数的相关文章

python常用内置函数学习（持续更新...）

python常用内置函数学习 一.python常用内置函数有哪些 dir() 二.每个内置函数的作用及具体使用 1.dir()不带参数时返回当前范围内(全局.局部)的变量.方法和定义的类型列表:   带参数A时返回参数的属性.方法的列表,如何该参数A对象有__dir__(),该方法被调用,如果不含有该方法,该方法不会报错,而是尽可能多的收集参数对象A的信息   实例: 不带参数,在分别在文件全局调用和在函数中局部调用dir()   带参数   原文地址:https://www.cnblogs.c

Python常用内置函数介绍

Python提供了一个内联模块buildin.内联模块定义了一些开发中经常使用的函数,利用这些函数可以实现数据类型的转换.数据的计算.序列的处理等功能.下面将介绍内联模块中的常用函数. Python内置函数的基本用法可以查看Python安装目录下的doc目录下的说明文档,本文仅介绍Python典型的内置函数使用方法. reduce(function, iterable[, initializer]) 对序列的值进行累计计算 reduce()可以实现对序列进行连续处理的功能.reduce()的声明

Python常用内置函数整理（lambda，reduce，zip，filter，map）

匿名函数lambda lambda argument1,argument2,...argumentN :expression using arguments 1.lambda是一个表达式,而不是一个语句. 因为这一点,lambda可以出现在python语法不允许def出现的地方---例如,在一个列表常量中或者函数调用的参数中. 2.lambda 的主体是一个单个的表达式,而不是一个代码块. lambda是一个为编写简单的函数设计的,而def用来处理更大的任务. 例如: lambda表示式写法:f

python常用内置函数总结

一.数学相关 1.绝对值:abs(-1)2.最大最小值:max([1,2,3]).min([1,2,3])3.序列长度:len('abc').len([1,2,3]).len((1,2,3))4.取模:divmod(5,2)5.乘方:pow(2,3)6.浮点数:round(1) 二.功能相关 1.函数是否可调用:callable(funcname),注意,funcname变量要定义过2.类型判断:isinstance(x,list/int)3.比较:cmp('hello','hello')4.快

Python常用内置函数

http://docs.python.org/3/library/functions.html#abs # 求任意个参数最小值 min() # 求任意个参数最大值 max() # 将整数转换为十六进制 hex() # 类型转换 int() float() bool() str() # 求绝对值 abs() len() type() isinstance(a,type) # 计算x的y次方 import math math.pow(x,y) # 开方 math.sqrt() 原文地址:https:

python常用内置函数1

1,abs 求绝对值 >>> abs( -1 ) 1 >>> abs( 1 ) 1 >>> 2,max, min求序列最大值与最小值 >>> l = [ 1, 10, -6, 2, 100 ] >>> max( l ) 100 >>> min( l ) -6 3,len求列表的长度 >>> s = 'ghostwu' >>> len( s ) 7 >>

python自定义函数、常用内置函数

1.python自定义函数 Python中用户自己编写的用于实现特定功能的函数代码块,就是自定义函数. 如: def是关键字,saa是自定义函数名,括号用于传参,可以不写参数,冒号后面是函数代码块,这里只写了一条print语句 注意:函数不调用不执行,只有调用函数才会执行 小练习1: 执行结果是: : 再来看一个小练2: 这是一个用来生成双色球的小程序,如蓝色球号码 01 红色球 22 12 23 14 05 26,蓝色球数字范围1-16,红色球数字范围1-33,最后一行调用produce()自

python第十八课——常用内置函数

常用内置函数:round(): print(round(3.14),round(3.99)) print(round(3145.926,-2),round(413.575,2)) abs(): print(abs(-2),abs(-1),abs(0),abs(1),abs(2)) max().min().sum() print(max([1,2,3,4,5])) print(min([1,2,3,4,5])) print(sum([1,2,3,4,5])) 以下比较的是字符串中每个字符的asci

Python 多态 对象常用内置函数 运算符重载 对象迭代器 上下文管理

一 多态 1.什么是多态:多态不是一个具体的技术或代码.指的时候多个不同类型对象可以响应同一个方法,产生不同的结果. 2.使用多多态的好处:提高了程序的灵活性,拓展性 3.如何实现:鸭子类型 就是典型的多态 多种不同类型 使用方法一样 4.案例 class Cat(): def bark(self): print("喵喵喵") def run(self): print("四条腿跑!") def sleep(self): print("趴着睡!")