python内置函数

1.数学相关

• abs(x) 取x绝对值
• divmode(x,y) 取x除以y的商和余数，常用做分页，返回商和余数组成一个元组
• pow(x,y[,z]) 取x的y次方 ，等同于x ** y，如果给出z值，该函数就计算x的y次幂值被z取模的值
• round(x,[,n]) 四舍五入取x的值，n表示取小数点几位
• min(X) 取X中最小的值
• max(X) 取X中最大值

练习举例：

>>> abs(-10)     ＃取－10的绝对值

10

>>> abs(10)

10

>>> divmod(10,3)   ＃取10除以3的余数和商

(3, 1)                  ＃返回结果为元组

>>> pow(2,3)            ＃取2的3次方

8

>>> pow(2,10)

1024

>>> round(4.5)     ＃取4.5的四舍五入值

4

>>> round(4.6)

5

>>> round(4.6454545,4)   ＃取4.6454545四舍五入值，保留小数点后四位

4.6455

>>> li = [1,3,4,5,4,5,6]

>>> dic = {“a”:1,“b”:2,“c”:3}

>>> min(li)   ＃取li列表元素最小值

1

>>> min(dic)    ＃取dic字典中value最小的key

‘a’

>>> max(li)    ＃取li列表元素最大值

6

>>> max(dic)    ＃取dic字典中value最大的key

‘c’

2.序列相关

• range(x,y[,z]) 取x到y－1以内所有整数的列表,z为步长，返回的是一个实例
• len(x) 返回x字符串或序列的长度 py3里默认计算的字符数量, py2里是计算的字节数量
• xrange(x,y[,z])和range()类似，但是返回的是一个对象

3.内置类型转换函数

• chr(x) 将ascii码表中的数字x转换为对应的字符
• ord(x) 将ascii码表中的字符转换为对应的数字
• str(x) 将x转换为字符类型
• int(x) 将x转换为整型
• float(x) 把一个数字或字符串转换成浮点数
• hex(x) 把十进制x转换为十六进制
• bin(x) 把十进制x转换为二进制
• oct(x) 把十进制x转换为八进制
• dict(x) 将x转换为字典，元素需要有字典的相关属性
• list(x) 将x转换为列表 ，元素需要有列表的相关属性
• tuple(x) 将x转换为元组，元素需要有元组的相关属性
• set(x) 将x转换为集合，元素需要有集合的相关属性
• bytes(x) 将x转换为二进制字节码

练习举例：

import random
＃方法一

def suiji(args):


rs = &#34;&#34;  #定义一个空字符串变量<br/>
for i in range(args):<br/>
    r = random.randrange(0,args-1)  ＃产生随机数<br/>
    if r == 2 or i ==4:           ＃判断随机数，用于生成随机验证码中的数字<br/>
        temp = random.randrange(48,58)     ＃随机生成ascii码表中数字字符对应的数字<br/>
    elif r == 1 or r == 3:<br/>
        temp = random.randrange(97, 122)   ＃随机生成aascii表中小写字母对应的数字<br/>
    else:<br/>
        temp = random.randrange(65,91)  ＃随机生成aascii表中大写字母对应的数字


li = chr(temp)    ＃使用chr 转换


    rs += li<br/>
return rs<br/>


＃方法二

def suiji1(args):


rs = []<br/>
for i in range(args):<br/>
    r = random.randrange(0,args-1)<br/>
    if r == 2 or i ==4:<br/>
        temp = random.randrange(48,58)<br/>
    elif r == 1 or r == 3:<br/>
        temp = random.randrange(97, 122)<br/>
    else:<br/>
        temp = random.randrange(65,91)<br/>
    li = chr(temp)<br/>
    rs.append(li)


return “”.join(rs)
d = suiji(6)

f = suiji1(6)

print(d)

print(f)

4.序列处理函数

• filter(x,y) x为条件函数，y为可迭代的对象 循环可迭代的对象,让每个循环元素执行函数,如果返回True,则说明元素合法
• map(x,y) x为条件函数，y为可迭代的对象,循环可迭代的对象,让每个循环元素执行函数,如果返回执行结果
• sorted(x) 对x进行排序
• reversed(x) 反转x的排序
• enumerate() 一般用于便利序列的索引和元素

练习举例：

＃需求 取出li列表中的大于5的值

li = [1,3,4,4,5,6,5,7,8,9,234,7,8,89,]
#使用自定义函数实现

def panduan1(args):


ret = []<br/>
for i in args:<br/>
    if i &gt; 5:<br/>
        ret.append(i)<br/>
return ret


print(panduan1(li))
#使用filter函数实现

def panduan(args):


if args &gt; 5:<br/>
    return True


ret = filter(panduan,li)    ＃filter只判断li当前循环的元素在panduan函数中返回的值，True的话就取出，False的话略过
print(list(ret))
#使用filter加lambda表达式来实现
ret = filter(lambda a: a &gt; 5 , li )

print(list(ret))
＃新需求，将li列表中大于5的元素取出并加2

ret  = map(lambda a: a+ 2,li)    ＃map判断li当前循环的元素死否符合函数判断，如果符合将返回当前元素，否则略过

print(list(ret))

5.对象及类型

• callable(object) 用于测试对象是否可调用，如果可以则返回1(真)；否则返回0(假)。可调用对象包括函数、方法、代码对象、类和已经定义了 调用 方法的类实例
• isinstance() 判断对象是否是某个类的实例

6.逻辑判断

• all(iterable) 集合中的元素都为真的时候为真;若为空串返回为True
• any(iterable) 集合中的元素有一个为真的时候为真;若为空串返回为False
• cmp(x, y) 如果x < y ,返回负数；x == y, 返回0；x > y,返回正数

举例：

>>> li = [1,3,4,5]   ＃li中元素都为真

>>> all(li)         ＃只要全部为真时才为真

True

>>> any(li)      ＃任意元素为真时 为真

True

>>> li = [1,3,4,5,“”]   ＃li中存在空元素

>>> all(li)

>>>

False

>>> any(li)

True
>>> cmp(1,2)    ＃1<2 结果返回－1

-1

>>> cmp(4,2)        ＃4>2  结果返回1

1

>>> cmp(4,4)     ＃4=4 结果返回0

0

7.其他

• compile() 把字符串编译为python代码,模式:single,eval,exec,
• exec()执行代码或编译后的字符串,无返回值 ,
• eval() 将字符串中表达式转换为python表达式,有返回值

举例：

>>> s = “print(123)”

>>> t = compile(s,‘<string>’,‘exec’)

>>> exec(t)

123

>>> s = “8+8”

>>> t1 = compile(s,‘<string>’,‘exec’)

>>> t2 = compile(s,‘<string>’,‘eval’)

>>> exec(t1)

>>> a = exec(t1)

  File “<stdin>”, line 1


a = exec(t1)<br/>
       ^<br/>


SyntaxError: invalid syntax

&gt;&gt;&gt; exec(t2)   ＃exec 将执行compile编译后的代码，无返回值

&gt;&gt;&gt; eval(t2)    ＃exec 将执行compile编译后的代码，如果代码中有表达式，将按表达式执行，有返回值

16

• dir() 快速一个对象提供的功能
• help()查看详细帮助信息
• id() 查看内存地址
• globals() 打印所有全局变量
• locals()打印所有局部变量
• vars() 返回对象的变量及值
• zip() 将两个序列中相同索引的元素按元组组合到一起形成一个列表，如果其中一个序列的索引不存在，将忽略

举例：

>>> a = [1,3,4,5,3,4]

>>> b = [1,3,6,74]

>>> zip(a,b)

[(1, 1), (3, 3), (4, 6), (5, 74)]

• 介绍

python装饰器是在不改变原函数体的基础上，在函数外边进行封装了一层新函数，在原函数的基础上实现了新的功能，简称：Decorator

• 功能

  • 自动执行装饰器函数,并将下面的函数体作为参数传递
  • 将装饰器的返回值重新赋值给下面的函数

• 形式

  定义装饰器，然后在被应用的函数前加 @装饰器函数名

• 具体说明

  原脚本：

#!/usr/bin/env python


-- coding: UTF-8 --


#pyversion:python3.5

#owner:fuzj
def f1(arg):


print(arg)   ＃打印参数


def f2(*args):


print(args)  ＃打印参数


print(f1(‘’))

print(f2(1,3,4,5))

输出结果：
123123
1,3,4,5

现在需求：在每个函数执行前后都输出一个welcome和end。
分析：首先可以在每个函数里使用print语句打印出来，这需要加入两次，但是如果脚本中有几百个函数的话，加起来成本太高。所以，如果使用装饰器，只需要定义好装饰器之后，在每个函数前应用即可
代码：

#!/usr/bin/env python


-- coding: UTF-8 --


#pyversion:python3.5

#owner:fuzj
def zhuangshi(func):      ＃定义装饰器的名称，参数为被应用的函数体


def inner(*args, **kwargs):       ＃装饰器的包装函数，此处使用万能参数，可以适用于各种传参<br/>
    print(&#39;welcome&#39;)<br/>
    r = func(*args, **kwargs)   ＃被应用的函数体<br/>
    print(&#39;end&#39;)<br/>
    return r      ＃返回函数体执行的结果


return inner   ＃返回整个装饰器的结果
@zhuangshi

def f1(arg):


print(arg)


def f2(*args):


print(args)


print(f1(‘’))

print(f2(1,3,4,5))

执行结果：
welcome
123123
end
1,3,4,5

具体说明：
1.python 解释器会从上到下依次编译代码，而函数不被调用时，是不执行的，所以定义好的装饰器已经放在内存中
2.当遇到@加函数名是，解释器会把其当作装饰器，此时@zhuangshi 加下面的函数，就等同于 f1= zhuangshi(f1) 参数f1是f1()函数的函数体
3.inner()函数的作用是将被应用的函数进行封装，所以，其参数为func的参数，保证封装之后，参数能正常传递下去
4.最后装饰器返回inner函数的函数体inner
5.此时由于f1= zhuangshi(f1) ，所以，f1的函数体变为inner的函数体，即

        print(&#39;welcome&#39;)<br/>
    print(arg)<br/>
    print(&#39;end&#39;)<br/>
    return r <br/>6.最后执行f1函数，输出结果<br/>

以上描述，具体步骤如下图：


• 带参数的装饰器

  装饰器本身也可以带参数，进行应用到装饰器中，如下例子

#!/usr/bin/env python


-- coding: UTF-8 --


#pyversion:python3.5

#owner:fuzj
def makeHtmlTag(tag, *args, **kwds):


def real_decorator(fn):<br/>
    css_class = &#34; class=&#39;{0}&#39;&#34;.format(kwds[&#34;css_class&#34;]) if &#34;css_class&#34; in kwds else &#34;&#34;<br/>
    def wrapped(*args, **kwds):<br/>
        return &#34;&lt;&#34;+tag+css_class+&#34;&gt;&#34; + fn(*args, **kwds) + &#34;&lt;/&#34;+tag+&#34;&gt;&#34;<br/>
    return wrapped<br/>
return real_decorator


@makeHtmlTag(tag=“b”, css_class=“bold_css”)   #此装饰器会把下面的装饰器和函数重新封装

@makeHtmlTag(tag=“i”, css_class=“italic_css”)  ＃此装饰器会封装下面的函数

def hello(arg):


return arg


@makeHtmlTag(tag=“i”, css_class=“italic_css”)

def hello1(arg):


return arg


print(hello1(“hell fuzj”))
print(hello(“hell fuzj”))

输出结果

<i class=‘italic_css’>hell fuzj</i>

<b class=‘bold_css’><i class=‘italic_css’>hell fuzj</i></b>

此例中真正的装饰器是real_decorator，而makeHtmlTag是在装饰器外边加的一层函数，可以自定义参数传递至装饰器中，这样装饰器更加灵活。而运用两次装饰器的话，第一个装饰器会把第二个装饰器的结果重新封装。所以结果中

<i class=‘italic_css’>hell fuzj</i>是@makeHtmlTag＋hello()函数的结果

，<b class=‘bold_css’><i class=‘italic_css’>hell fuzj</i></b>是@makeHtmlTag装饰器将@makeHtmlTag＋hello()重新封装的结果