python学习之路-4 内置函数和装饰器

时间：2016-05-30 06:19:30 阅读：240 评论：0 收藏：0 [点我收藏+]

本篇涉及内容

内置函数

装饰器

内置函数

callable() 判断对象是否可以被调用,返回一个布尔值

num = 10
print(callable(num))   # num不能够被调用，返回False
   
def f1():
    print("name")
   
print(callable(f1))     # f1可以被调用,返回True
   
# 输出
False
True

?chr() 将十进制整数转换为ascii编码中对应的字符

num = chr(69)  # 整数69在ascii编码表中对应的是字母E
print(num)
    
# 输出
E
   
   
# 练习 
# 利用ascii编码随机生成6位验证码
import random
li = []
for i in range(6):
    r = random.randrange(0, 3)   # 生成随机数用来选择数字，小写字母或大写字母
   
    if r == 0:  # 随机数字
        num = random.randrange(0, 10)
        li.append(str(num))
    elif r == 1:    # 随机大写字母
        temp = random.randrange(65, 91)    # 65-91在ascii表中对应的字符是A-Z
        c = chr(temp)       # 将十进制整数转换成为ascii表中对应的字符
        li.append(str(c))
    elif r == 2:    # 随机小写字母
        temp = random.randrange(97, 123)   # 97-123在ascii表中对应的字符是a-z
        c = chr(temp)   # 将十进制整数转换成为ascii表中对应的字符
        li.append(str(c))
   
result = "".join(li)
print(result)
   
# 输出
814P8i

ord()   将字符转换成ascii编码表中对应的十进制整数
1
2
3
4
5
st = ord("E")   # 字符E在ascii编码表中对应的十进制整数是69
print(st)

# 输出
69

dir() # 查看一个对象有哪些功能

print(dir(dict))
   
# 输出
[‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘items‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘]

help() 查看对象的使用方法
1
2
3
4
print(help(list))

# 输出
输出内容太长，自己去试
divmod() # 通过除数和被除数返回一个元组(商, 余数) 做分页比较有用
1
2
3
4
5
n = divmod(100, 9)
print(n)

# 输出
(11, 1)
isinstance() 判断对象是否是一个类的实例, 返回一个布尔值
1
2
3
4
5
6
7
8
r = isinstance("abc", str)
print(r)
r = isinstance("abc", dict)
print(r)

# 输出
True
False
enumerate()   用于遍历序列中的元素以及它们的下标
1
2
3
4
5
6
7
for i,j in enumerate((‘a‘,‘b‘,‘c‘)):
    print(i,j)

# 输出
0 a
1 b
2 c

filter(函数名, 可迭代对象) 调用函数，将可迭代对象中的每一个元素传给函数去执行，返回的结果为True则保留该元素，将保留的元素组成一个列表，将该列表作为返回值

def f2(a):
    if a > 22:
        return True
li = [11, 22, 33, 44, 55, 66]
ret = filter(f2, li)
print(list(ret))
   
# 输出
[33, 44, 55, 66]
   
   
   
## 使用lambda表达式
f1 = lambda a: a > 30
li = [11, 22, 33, 44, 55, 66]
ret = filter(f1, li)
print(list(ret))
   
# 输出
[33, 44, 55, 66]

map(函数，可迭代对象) 调用函数，将可迭代对象中的每一个元素传给函数去执行，返回的结果组成一个列表，将该列表作为返回值

def f2(a):
    return a + 100
li = [11, 22, 33, 44, 55, 66]
ret = map(f2, li)
print(list(ret))
   
# 输出
[111, 122, 133, 144, 155, 166]
   
   
## 使用lambda表达式
f2 = lambda a: a + 100
li = [11, 22, 33, 44, 55, 66]
ret = map(f2, li)
print(list(ret))
# 输出
[111, 122, 133, 144, 155, 166]

globals() # 全局变量 locals() # 局部变量

NAME = "aaa"
def show():
    a = 123
    print(globals())
    print(locals())
show()
   
# 输出
{‘__file__‘: ‘D:/SVN/learning/s13/day4/class_code/2、内置函数.py‘, ‘show‘: <function show at 0x00000000004BCBF8>, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__spec__‘: None, ‘NAME‘: ‘aaa‘, ‘__cached__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib.SourceFileLoader object at 0x000000000276E7B8>, ‘__doc__‘: None, ‘__name__‘: ‘__main__‘}
{‘a‘: 123}

hash()   通过hash计算出一个全数字的值
1
2
3
4
5
6
s = "123"
ret = hash(s)
print(ret)

# 输出   pycharm执行有问题,这个值会变,在python命令提示符下执行没问题
-5981999319787686991
len() python2.7 字节长度 python3 字符长度
1
2
3
4
5
name = "张三"
print(len(name))

# 输出
2
bytes() 将字符转成字节
1
2
3
4
5
6
name = "张聪"
ret = bytes(name, encoding="utf-8")
print(ret)

# 输出
b‘\xe5\xbc\xa0\xe8\x81\xaa‘
max() 求最大值
1
2
3
4
5
r = max([11, 22, 33, 1])
print(r)

# 输出
33
min() 求最小值
1
2
3
4
5
r = min([11, 22, 33, 1])
print(r)

# 输出
1
sum() 求和
1
2
3
4
5
r = sum([11, 22, 33, 1])
print(r)

# 输出
67
pow() 求幂次方
1
2
3
4
5
r = pow(2, 10) # 2的10次方
print(r)

# 输出
1024
reversed() 反转和list的reversed()方法一样
1
2
3
4
5
6
li = [1, 3, 4, 1, 53, 3, 5]
ret = reversed(li)
print(list(ret))

# 输出
[5, 3, 53, 1, 4, 3, 1]
round() 四舍五入
1
2
3
4
5
6
7
8
ret = round(1.8)
ret2 = round(3.3)
print(ret)
print(ret2)

# 输出
2
3
slice()   跟切片的方法一样没什么卵用，比切片还麻烦
1
2
3
4
5
6
7
8
9
myslice = slice(0,5,2)
print(myslice)

l = list(range(10))
print(l[myslice])

# 输出
slice(0, 5, 2)
[0, 2, 4]
sorted() 排序
1
2
3
4
5
6
li = [1, 3, 4, 1, 53, 3, 5]
ret = sorted(li)
print(ret)

# 输出
[1, 1, 3, 3, 4, 5, 53]
type() 查看对象类型
1
2
3
4
5
6
7
8
9
10
11
a = "abc"
b = [1, 2, 3]
c = {1: "a", 2: "b"}
print(type(a))
print(type(b))
print(type(c))

# 输出
<class ‘str‘>
<class ‘list‘>
<class ‘dict‘>
zip()  将多个列表的相对应的位置进行组合成一个元组，元组作为元素产生新的列表
1
2
3
4
5
6
7
8
9
10
l1 = [11, 12, 13, 14]
l2 = [21, 22, 23, 24]
l3 = [31, 32, 33, 34]

ret = zip(l1, l2, l3)
print(list(ret))


# 输出
[(11, 21, 31), (12, 22, 32), (13, 23, 33), (14, 24, 34)]

来自为知笔记(Wiz)

python学习之路-4 内置函数和装饰器

原文：http://www.cnblogs.com/CongZhang/p/5540926.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)