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 = ""  #定义一个空字符串变量

    for i in range(args):

        r = random.randrange(0,args-1)  ＃产生随机数

        if r == 2 or i ==4:           ＃判断随机数，用于生成随机验证码中的数字

            temp = random.randrange(48,58)     ＃随机生成ascii码表中数字字符对应的数字

        elif r == 1 or r == 3:

            temp = random.randrange(97, 122)   ＃随机生成aascii表中小写字母对应的数字

        else:

            temp = random.randrange(65,91)  ＃随机生成aascii表中大写字母对应的数字

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

        rs += li

    return rs

＃方法二

def suiji1(args):

    rs = []

    for i in range(args):

        r = random.randrange(0,args-1)

        if r == 2 or i ==4:

            temp = random.randrange(48,58)

        elif r == 1 or r == 3:

            temp = random.randrange(97, 122)

        else:

            temp = random.randrange(65,91)

        li = chr(temp)

        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 = []

    for i in args:

        if i > 5:

            ret.append(i)

    return ret

print(panduan1(li))

#使用filter函数实现

def panduan(args):

    if args > 5:

        return True

ret = filter(panduan,li)    ＃filter只判断li当前循环的元素在panduan函数中返回的值，True的话就取出，False的话略过

print(list(ret))

#使用filter加lambda表达式来实现

ret = filter(lambda a: a > 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)

           ^

SyntaxError: invalid syntax

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

>>> 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装饰器

介绍

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):       ＃装饰器的包装函数，此处使用万能参数，可以适用于各种传参

        print('welcome')

        r = func(*args, **kwargs)   ＃被应用的函数体

        print('end')

        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('welcome')
print(arg)
print('end')
return r
6.最后执行f1函数，输出结果
以上描述，具体步骤如下图：

带参数的装饰器

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

#!/usr/bin/env python

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

#pyversion:python3.5

#owner:fuzj

def makeHtmlTag(tag, *args, **kwds):

    def real_decorator(fn):

        css_class = " class='{0}'".format(kwds["css_class"]) if "css_class" in kwds else ""

        def wrapped(*args, **kwds):

            return "<"+tag+css_class+">" + fn(*args, **kwds) + "</"+tag+">"

        return wrapped

    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()重新封装的结果