python基础篇【第四篇】内置函数、装饰器：

一、内置函数：

 

对于一些python中常用的函数，python自身就已经定义了一些函数用于调用，我们就叫它内置函数！如以下都是python中内置的函数！

 

一些常用的内置函数具体用法：

 

 

一些常用的内置函数具体用法：

1.abs()；取绝对值

1 n=abs(-2)
2 print(n)
3 
4 结果：
5 2

 

2.all();传入可迭代的对象中，都为真才为真;

Fasle： 0,None,"",[],{} ,()都为假
True: 1,-1,True,有值返回真。

n=all([1,2,3," ",1,-1,True])
print(n)
#结果
True

 

3.any();传入可迭代的对象中，有一个为真就为真;

n=any([0,None,"",[],{} ,()]) #都为假
print(n)

#结果
False

 

4.bin();传入的十进制，转换成二进制；

n=bin(10)
print(n)

#执行结果
0b1010

 

5.oct();传入的十进制，转换成八进制；

1 n=oct(10)
2 print(n)
3 
4 执行结果
5 0o12

 

6.hex();传入的十进制，转换成十六进制；

1 n=hex(10)
2 print(n)
3 
4 执行结果
5 0xa

 

7.bytes() 把字符串转换成字节类型，需要指定编码  

其中： gbk编码：一个汉字占2个字节；

　　　 utf8编码：一个汉字占3个字节；

1 n=bytes("hello",encoding="utf-8")
2 print(n)
3 
4 执行结果：
5 b'hello'

 

8.chr();把输入的数字，转换成Ascii码表中对应的字母；

n=chr(78)
print(n)
#执行结果

N

 

9.ord();把输入的字母，转换成Ascii码表中对应的数字；

n=ord("K")
print(n)
#执行结果
75

用chr和ord，可以写一个验证码如下：

#随机生成一个6位验证码
import random
li=[]
for i in range(6):
    r=random.randrange(0,5)
    if r ==2 or r==4:
        num=random.randrange(0,10)
        li.append(str(num))
    else:
        n=random.randrange(65,91)  #从65到90 之间随机取出一个数字
        c=chr(n)   #把数字转换成字母
        li.append(c)
j="".join(li)   #字符串拼接,只能拼接字符

print(j)

 

 

10.globals();获取所有的全局变量；

m=123

n=ord("K")
# print(n)
s=globals()
print(s)

#执行结果
{'__file__': 'D:/学习功课/s13/day4/内置函数.py', 

'__doc__': None, '__name__': '__main__', 

'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000404B70>,
 '__spec__': None, '__package__': None, 'li': [11, 22, 33, 44, 55], 

'm': 123, '__cached__': None, 's': {...}, 

'n': 75, 'random': <module 'random' from 'C:\\Python\\Python35\\lib\\random.py'>, 

'__builtins__': <module 'builtins' (built-in)>}

 

11.locals（）：获取所有局部变量

def show(args,a):
    k=12
    v="wewe"
    for i in range(3):
        n=i
    print(locals())
show("sss","2b")

#执行结果
{'args': 'sss', 'a': '2b', 'k': 12, 'v': 'wewe', 'n': 2, 'i': 2}

 

12.hash值：

#hash值
dic = {"sadfasdfasdfasdfasdfasdf":1}
i = hash("sadfasdfasdfasdfasdfasdf")        #把一般字符串转成hash值
print(i)

 

13.compile():将字符串编译成python代码

　　eval();可以把括号里面的字符串当成python执行，但只支持表达式且有返回值；

　　exec()     执行，比eval要牛逼，因为exec可以执行任何Python代码，但eval只能执行表达式；但有个缺陷是eval有返回值，而exec没有。　　　

　　exec可以执行compile编译过的，也可以接受代码执行。

　　eval()      执行，把接受的字符串当做一个表达式，把代码编译成一行的表达式；

name='print("hello world")'
test=compile(name,'<string>','exec')
print(test)

#执行结果
<code object <module> at 0x00000000006A1DB0, file "<string>", line 1>
#可以用exec()来调用test
exec(test)
hello world
#也可以用eval()
eval(test)
hello world
#用eval()执行表达式是有返回值的

k=eval("2*8")
print(k)
#执行结果
16

 

14. callable():能否调用，能调用返回True，不能返回False；

def show():
    k=12
    v="wewe"
    for i in range(3):
        n=i
print(callable(show))

#执行结果
True

 

15. isinstance（s，类型）用来判断对象是否是类的实例；

print(isinstance("s",str))
#执行结果
True

 

16.filter()  筛选，内部循环第二个参数，让每一个元素执行，如果值返回为True，表示元素合法，将元素添加到结果中，否则不做操作；

def f2(a):
    if a>22:
        return True
li=[11,22,33,44,55]
ret=filter(f2,li)  #循环第二个参数，让每个循环元素执行 函数，如果函数值返回值True，表示元素合法，加到ret中
print(list(ret))
#执行结果：
[33, 44, 55]

#也可以用lambda表达式来运行
ret=filter(lambda a: a>22,li)
print(list(ret))

 

17.map(函数，可迭代的对象 ):  内部循环第二个参数，让每个元素执行，不加判断，返回值是什么就操作什么

li=[11,22,33,44,55]

mret=map(lambda a: a+200,li)
print(list(mret))
#执行结果
[211, 222, 233, 244, 255]

 

18.len()查看长度；

#在python3中文，默认是按字符查看
s="田杰"
print(len(s))
s="田杰"
b=bytes(s,encoding="utf-8")
print(len(b))
#执行结果
2
6
#也可以查看列表长度
li=[11,22,33,44,55]
#结果
5

 

19. max（）：最大值

li=[11,22,33,44,55]
n=max(li)
print(n)
#结果
55

 

20.min（）：最小值

li=[11,22,33,44,55]
m=min(li)
print(m)
#结果
11

 

21. sum（）：求和

num=[99,22,33]
k=sum(num)
#结果
154

 

22.pow() 求幂

>>> i1
18
>>> pow(i1,2)
324
>>> pow(i1,3)
5832

 

23.range()  范围，一般for循环用的比较多，for i in range(5)，指循环5次；

for i  in range(5):
    print(i)
#结果
0
1
2
3
4

 

24.memoryview():python3中新添，查看内存地址相关的类

>>> name = b'daniel'
>>> name
b'daniel'
>>> id(name)
>>> memoryview(name)
<memory at 0x1019ee108>
>>> type(name)
<class 'bytes'>

 

25. reversed()：反转，与列表中的反转一样

li=[11,22,33,44,55]
k=reversed(li)
print(list(k))
#执行结果
[55, 44, 33, 22, 11]

 

26. round（）：四舍五入

k=round(3.6)
print(k)

#结果
4

 

27.divmod():取商和余数

k=divmod(10,3)
print(k)
#结果
(3, 1)

 

28.sorted()  排序, 和列表、元组中的排序一样

>>> l2 = [5,22,4,2,55,23,]
>>> sorted(l2)
[2, 4, 5, 22, 23, 55]

 

29.slice()  切片，和字符串、列表中的切片一样

>>> l1
[1, 2, 3, 4, 5]
>>> l1[1:5]  #这个效果和下面实现的是一样的
[2, 3, 4, 5]
>>> l1.__getitem__(slice(1,5,None))
[2, 3, 4, 5]
#还可以调整步长
>>> l1.__getitem__(slice(1,5,2))
[2, 4]
>>> l1.__getitem__(slice(1,5,1))
[2, 3, 4, 5]
>>> l1.__getitem__(slice(0,5,1))
[1, 2, 3, 4, 5]
>>> l1.__getitem__(slice(0,5,1))

 

30.zip（）：合并，如把多个列表中的每个元素合并成一个元组：

li=[1,2,3,7,8]
a=["w","e","r","t","y",]
print(list(zip(li,a)))
#结果
[(1, 'w'), (2, 'e'), (3, 'r'), (7, 't'), (8, 'y')]
##如果元素长度不一样，会忽略
>>> c = [5,4,3,2]
>>> print(tuple(zip(a,c)))
((1, 5), (2, 4), (3, 3), (4, 2))

 

二、装饰器

　　在python中一切皆对象，对于函数也是一样的，也可以把一个函数赋值给某个变量，因此函数可以像变量一样被指向和传递；

下面用实例可以更加形象的描述：

装饰器就是为了在调用一个函数之前或之后，再调用另一个程序

注意：是在不能修改原程序的情况下，因为要遵循“开放封闭原则”

 

装饰器：
def outer(func):
    def inter(arg):
        print("before")
        func(arg)
    return inter

@outer
def f1(name):
    print("F1 %s" %name)
     调用装饰器：@+函数名
     功能：
             1.自动执行outer函数并且将其下面的函数名f1当做参数传递
             2.将outer函数的返回值，重新赋值f1   （outer返回值就是inter，现在f1就重新赋值给了inter整个函数）

 

给函数传递参数，并函数有返回值的情况；

def outer(func):
    def inter(*args,**kwargs):
        print("before")
        r=func(*args,**kwargs)
        print("hello")
        return r
    return inter
@outer
def f1(a):
    print(a)
    return "屌丝！"

@outer
def f2(a1,a2):
    print("F2",a1,a2)
    return "臭屌丝！！！"

test=f1(1111)
print(test)

test2=f2(222,333)
print(test2)

#结果
before
1111
hello
屌丝！

before
F2 222 333
hello
臭屌丝！！！