python--内置函数

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　python内置函数

　　　　python有很多默认的函数，有的经常用，有的不怎么常用，接下来我把经常用的给大家贴出来，让大家参考一下.

一：必须要掌握的函数

1、min：计算最小值

　　描述

Python min() 方法返回字符串中最小的字母。

　　语法

min()方法语法：

min(str)
　　
　参数

str -- 字符串。

　　返回值

返回字符串中最小的字母。

　　实例

以下实例展示了min()函数的使用方法：

#!/usr/bin/python

str = "this-is-real-string-example....wow!!!";
print "Min character: " + min(str);

str = "this-is-a-string-example....wow!!!";
print "Min character: " + min(str);

以上实例输出结果如下：

Min character: !
Min character: !

2、max：计算最大值，可以是序列，可以是散列

描述

Python max() 方法返回字符串中最大的字母。

语法

max()方法语法：

max(str)

参数

• str -- 字符串。

返回值

返回字符串中最大的字母。

实例

以下实例展示了max()函数的使用方法：

#!/usr/bin/python

str = "this is really a string example....wow!!!";
print "Max character: " + max(str);

str = "this is a string example....wow!!!";
print "Max character: " + max(str);

以上实例输出结果如下：

Max character: y
Max character: x

3、sum:求和，参数必须是一个序列类型

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

以下是 sum() 方法的语法:

sum(iterable[, start])

• iterable -- 可迭代对象，如列表。
• start -- 指定相加的参数，如果没有设置这个值，默认为0。

返回计算结果。

实例

以下展示了使用 sum 函数的实例：

>>>sum([0,1,2]) 3

>>> sum((2, 3, 4), 1) # 元组计算总和后再加 1 10

>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2 12

4、bytes：字符 bytes（s，encoding=‘utf-8’）

 

5、len：计算传入字符串的长度（可以计算列表，字典，元祖）

描述

Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。

语法

len()方法语法：

len( s )

参数

• s -- 对象。

返回值

返回对象长度。

实例

以下实例展示了 len() 的使用方法：

>>>str = "runoob"

>>> len(str) # 字符串长度 6

>>> l = [1,2,3,4,5]

>>> len(l) # 列表元素个数

>>>5

6、input：输入，与用户界面进行交互的

python input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。

raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）。

注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。

除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

注意：python3 里 input() 默认接收到的事 str 类型。

函数语法

input([prompt])

参数说明：

• 无

实例

 

input() 需要输入 python 表达式

>>>a = input("input:") input:123 # 输入整数

>>> type(a) <type 'int'> # 整型

>>> a = input("input:") input:"runoob" # 正确，字符串表达式

>>> type(a) <type 'str'> # 字符串

>>> a = input("input:") input:runoob

# 报错，不是表达式 Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<string>", line 1, in <module> NameError: name 'runoob' is not defined <type 'str'>

raw_input() 将所有输入作为字符串看待

>>>a = raw_input("input:") input:123

>>> type(a) <type 'str'> # 字符串

>>> a = raw_input("input:") input:runoob

>>> type(a) <type 'str'> # 字符串

>>>

7、print：输出

描述

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

print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

语法

以下是 print() 方法的语法:

print(*objects, sep=' ', end='\n', file=sys.stdout)

参数

• objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

• sep -- 用来间隔多个对象，默认值是一个空格。

• end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

• file -- 要写入的文件对象。

返回值

无。

实例

以下展示了使用 print 函数的实例：

Python3 下测试

>>>print(1) 1

>>> print("Hello World") Hello World

>>> a = 1

>>> b = 'runoob'

>>> print(a,b) 1 runoob

>>> print("aaa""bbb") aaabbb

>>> print("aaa","bbb") aaa bbb

>>>

>>> print("www","runoob","com",sep=".") # 设置间隔符 www.runoob.com

8、type：类型，查看参数类型

描述

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

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。

• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法

以下是 type() 方法的语法:

class type(name, bases, dict)

参数

• name -- 类的名称。

• bases -- 基类的元组。

• dict -- 字典，类内定义的命名空间变量。

返回值

一个参数返回对象类型, 三个参数，返回新的类型对象。

实例

以下展示了使用 type 函数的实例：

# 一个参数实例 >>> type(1) <type 'int'> >>> type('runoob') <type 'str'> >>> type([2]) <type 'list'> >>> type({0:'zero'}) <type 'dict'> >>> x = 1 >>> type( x ) == int # 判断类型是否相等 True # 三个参数 >>> class X(object): ... a = 1 ... >>> X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X >>> X <class '__main__.X'>

type() 与 isinstance()区别：

class A: pass class B(A): pass isinstance(A(), A) # returns True type(A()) == A # returns True isinstance(B(), A) # returns True type(B()) == A # returns False

9、hash：哈希，计算在内存中的存储位置

描述

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

语法

hash 语法：

hash(object)

参数说明：

• object -- 对象；

返回值

返回对象的哈希值。

实例

以下实例展示了 hash 的使用方法：

>>>hash('test') # 字符串 2314058222102390712

>>> hash(1) # 数字 1

>>> hash(str([1,2,3])) # 集合 1335416675971793195

>>> hash(str(sorted({'1':1}))) # 字典 7666464346782421378

>>>

10、import：调用函数。

描述

__import__() 函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入。

语法

__import__ 语法：

__import__(name[, globals[, locals[, fromlist[, level]]]])

参数说明：

• name -- 模块名

返回值

返回元组列表。

实例

以下实例展示了 __import__ 的使用方法：

 

a.py 文件代码：

#!/usr/bin/env python

#encoding: utf-8

import os

print '在 a.py 文件中',id(os)

 

test.py 文件代码：

#!/usr/bin/env python

#encoding: utf-8

import sys

__import__('a') # 导入 a.py 模块

执行 test.py 文件，输出结果为：

在 a.py 文件中 4394716136

二、要掌握的函数

1、dir：查看所有内置函数

描述

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

语法

dir 语法：

dir([object])

参数说明：

• object -- 对象、变量、类型。

返回值

返回模块的属性列表。

实例

以下实例展示了 dir 的使用方法：

>>>dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']

>>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

>>>

2、eval：

描述

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

语法

以下是 eval() 方法的语法:

eval(expression[, globals[, locals]])

参数

• expression -- 表达式。

• globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

• locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值

返回表达式计算结果。

实例

以下展示了使用 eval() 方法的实例：

>>>x = 7

>>> eval( '3 * x' )

21

>>> eval('pow(2,2)')

4

>>> eval('2 + 2')

4

>>> eval("n + 4")

85

3、exec

描述

exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。

需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。

语法

以下是 exec 的语法:

exec obj

参数

• obj -- 要执行的表达式。

返回值

exec 返回值永远为 None。

以下展示了使用 exec 的实例：

 >>>exec 'print "Hello World"' Hello World # 单行语句字符串

>>> exec "print 'runoob.com'" runoob.com # 多行语句字符串

>>> exec """for i in range(5): ... print "iter time: %d" % i ... """ iter time: 0 iter time: 1 iter time: 2 iter time: 3 iter time: 4

 x = 10

expr = """ z = 30 sum = x + y + z print(sum) """

def func():

　　y = 20

　　exec(expr)

　　exec(expr, {'x': 1, 'y': 2})

　　exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})

func()

输出结果：

60 33 34

4、bool

描述

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

bool 是 int 的子类。

语法

以下是 bool() 方法的语法:

class bool([x])

参数

• x -- 要进行转换的参数。

返回值

返回 Ture 或 False。

实例

以下展示了使用 bool 函数的实例：

>>>bool() False

>>> bool(0) False

>>> bool(1) True

>>> bool(2) True

>>> issubclass(bool, int) # bool 是 int 子类 True

5、int

描述

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

语法

以下是 int() 方法的语法:

class int(x, base=10)

参数

• x -- 字符串或数字。

• base -- 进制数，默认十进制。

返回值

返回整型数据。

实例

以下展示了使用 int() 方法的实例：

>>>int() # 不传入参数时，得到结果0 0

>>> int(3) 3

>>> int(3.6) 3

>>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18

>>> int('0xa',16) 10

>>> int('10',8) 8

6、float

描述

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

语法

float()方法语法：

class float([x])

参数

• x -- 整数或字符串

返回值

返回浮点数。

实例

以下实例展示了 float() 的使用方法：

>>>float(1) 1.0

>>> float(112) 112.0

>>> float(-123.6) -123.6

>>> float('123') # 字符串 123.0

7、abs

描述

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

语法

以下是 abs() 方法的语法:

abs( x )

参数

• x -- 数值表达式。

返回值

函数返回x（数字）的绝对值。

实例

以下展示了使用 abs() 方法的实例：

#!/usr/bin/python

print "abs(-45) : ", abs(-45) print "abs(100.12) : ", abs(100.12) print "abs(119L) : ", abs(119L)

以上实例运行后输出结果为：

abs(-45) : 45 abs(100.12) : 100.12 abs(119L) : 119

8、divmod

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

在 python 2.3 版本之前不允许处理复数。

函数语法

divmod(a, b)

参数说明：

• a: 数字

• b: 数字

实例

>>>divmod(7, 2) (3, 1)

>>> divmod(8, 2) (4, 0)

>>> divmod(1+2j,1+0.5j) ((1+0j), 1.5j)

9、round

描述

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

语法

以下是 round() 方法的语法:

round( x [, n] )

参数

• x -- 数值表达式。

• n -- 数值表达式。

返回值

返回浮点数x的四舍五入值。

实例

以下展示了使用 round() 方法的实例：

#!/usr/bin/python

print "round(80.23456, 2) : ", round(80.23456, 2) print "round(100.000056, 3) : ", round(100.000056, 3) print "round(-100.000056, 3) : ", round(-100.000056, 3)

以上实例运行后输出结果为：

round(80.23456, 2) : 80.23 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0

10、pow

描述

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

语法

以下是 math 模块 pow() 方法的语法:

import math math.pow( x, y )

内置的 pow() 方法

pow(x, y[, z])

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

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

参数

• x -- 数值表达式。

• y -- 数值表达式。

• z -- 数值表达式。

返回值

返回 x^y（x的y次方） 的值。

实例

以下展示了使用 pow() 方法的实例：

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

import math # 导入 math 模块

print "math.pow(100, 2) : ",

math.pow(100, 2) # 使用内置，查看输出结果区别

print "pow(100, 2) : ", pow(100, 2)

print "math.pow(100, -2) : ", math.pow(100, -2) print "

math.pow(2, 4) : ", math.pow(2, 4)

print "math.pow(3, 0) : ", math.pow(3, 0)

以上实例运行后输出结果为：

math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0

11、list

描述

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

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

语法

list()方法语法：

list( seq )

参数

• list -- 要转换为列表的元组。

返回值

返回列表。

实例

以下实例展示了 list()函数的使用方法：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

aTuple = (123, 'xyz', 'zara', 'abc'); aList = list(aTuple)

print "列表元素 : ", aList

以上实例输出结果如下：

列表元素 : [123, 'xyz', 'zara', 'abc']

12、tuple

描述

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

语法

tuple()方法语法：

tuple( seq )

参数

• seq -- 要转换为元组的序列。

返回值

返回元组。

实例

以下实例展示了 tuple()函数的使用方法：

实例 1

>>>tuple([1,2,3,4]) (1, 2, 3, 4)

>>> tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple (1, 3)

>>> tuple((1,2,3,4)) #元组会返回元组自身 (1, 2, 3, 4)

实例 2

#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc']; aTuple = tuple(aList) print "Tuple elements : ", aTuple

以上实例输出结果为：

Tuple elements : (123, 'xyz', 'zara', 'abc')

13、str

描述

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

语法

以下是 str() 方法的语法:

class str(object='')

参数

• object -- 对象。

返回值

返回一个对象的string格式。

实例

以下展示了使用 str() 方法的实例：

>>>s = 'RUNOOB'

>>> str(s) 'RUNOOB'

>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};

>>> str(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}"

>>>

14、repr

描述

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

语法

以下是 repr() 方法的语法:

repr(object)

参数

• object -- 对象。

返回值

返回一个对象的 string 格式。

实例

以下展示了使用 repr() 方法的实例：

>>>s = 'RUNOOB'

>>> repr(s) "'RUNOOB'"

>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};

>>> repr(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}"

>>>

15、enumerate

描述

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

Python 2.3. 以上版本可用，2.6 添加 start 参数。

语法

以下是 enumerate() 方法的语法:

enumerate(sequence, [start=0])

参数

• sequence -- 一个序列、迭代器或其他支持迭代对象。

• start -- 下标起始位置。

返回值

返回 enumerate(枚举) 对象。

实例

以下展示了使用 enumerate() 方法的实例：

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>> list(enumerate(seasons, start=1)) # 小标从 1 开始 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

普通的 for 循环

>>>i = 0

>>> seq = ['one', 'two', 'three']

>>> for element in seq: ... print i, seq[i] ... i +=1 ... 0 one 1 two 2 three

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']

>>> for i, element in enumerate(seq): ... print i, seq[i] ... 0 one 1 two 2 three

>>>

16、filter

描述

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

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法

以下是 filter() 方法的语法:

filter(function, iterable)

参数

• function -- 判断函数。

• iterable -- 可迭代对象。

返回值

返回列表。

实例

以下展示了使用 filter 函数的实例：

在python3中，filter的用法和map一样都需要加list之后print输出结果

例：

 

num = [1,3,5,6,7,8]
def aa(x):
    return x % 2 ==1
print(list(filter(aa,num)))

 

>>>[1,3,5,7]

过滤出列表中的所有奇数：

#!/usr/bin/python # -*- coding: UTF-8 -*- def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(newlist)

输出结果 ：

[1, 3, 5, 7, 9]

过滤出1~100中平方根是整数的数：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

import math

def is_sqr(x):

　　return

　　math.sqrt(x) % 1 == 0

　　newlist = filter(is_sqr, range(1, 101))

print(newlist)

输出结果 ：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

17、map

描述

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

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法

map() 函数语法：

map(function, iterable, ...)

参数

• function -- 函数，有两个参数

• iterable -- 一个或多个序列

返回值

返回列表。

在python3中map的用法有所改变，

例：

name=['a','w','y','n']
def a(x):
return x+"_SB"
print(list(map(a,name)))

>>>['a_SB','w_SB','y_SB','n_SB']

输出必须用list定义，在用print输出。

 

实例

以下实例展示了 reduce() 的使用方法：

>>>def square(x) : # 计算平方数 ... return x ** 2 ...

>>> map(square, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 [1, 4, 9, 16, 25]

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加

>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]

18、sorted

描述

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

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：

• iterable -- 可迭代对象。

• cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

• reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。

实例

以下实例展示了 sorted 的使用方法：

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

>>> b = sorted(a) # 保留原列表

>>> a [5, 7, 6, 3, 4, 1, 2]

>>> b [1, 2, 3, 4, 5, 6, 7]

>>> L=[('b',2),('a',1),('c',3),('d',4)]

>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数 [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> sorted(L, key=lambda x:x[1]) # 利用key [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>> sorted(students, key=lambda s: s[2]) # 按年龄排序 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>>