內置函數和裝飾器

內置函數補充

callable()   #檢測一個東西能否被調用

def f1():
    pass
f2 =123
print(callable(f1))
print(callable(f2))

# chr() 數字轉化成字母
# ord() 字母轉化成數字

r = chr(65)
print(r)
n = ord("a")
print(n)

#隨機碼  65到90

import random
li = []
for n in range(6):
    r = random.randrange(0,5)
    if r ==2 or r ==4:
        num = random.randrange(0,10)
        li.append(str(num))
    else:
        i = random.randrange(65,91)
        c = chr(i)
        li.append(c)
result = "".join(li)
print(result)

#Python join() 方法用于將序列中的元素以指定的字符連接生成一個新的字符串,不同數據類型拼接會失敗


# compile() #把字符串編譯成python代碼
# eval() #執行，接收：表達式，并且獲取結果  有返回值
# exec() #執行python代碼，接收：代碼或者字符串 沒有返回值
s = "print(123)"
#編譯
r = compile(s,"<string>","exec")
#執行
exec(r)

m = "8*8"
ret = eval(m)
print(ret)

#dir()用來快速獲取模塊，對象，類提供了哪些功能 不詳細
# print(dir(dict))
#help(list)查看幫助，詳細

divmod()

共97條，每頁顯示10條，需要多少頁

# r = divmod(97,10)
# print(r[0])
# print(r[1])
# n1,n2 = divmod(97,10)

isinstance()#用來判斷某個對象是否是某個類的實例

s = "alex"
r1 = isinstance(s,dict)
r2 = isinstance(s,str)
print(r1,r2)

#filter

# def f1(args):
#     result = []
#     for item in args:
#         if item > 22:
#             result.append(item)
#     return result
# li = [11,22,33,44,55]
# ret = f1(li)
# print(ret)
#filter(函數，可迭代的對象)
def f2(a):
    if a >22:
        return True
li = [11,22,33,44,55]
ret = filter(f2,li)
print(list(ret))
        # #filter內部，循環第二個參數
        # result = []
        # for item in 第二個參數:
        #     r = 第一個參數(item)
        #     if r:
        #         result(item)
        #return result
        #filter,循環第二個參數，讓每個循環元素執行函數，如果函數返回值True，表示元素合法
li2 = [11,22,33,44,55]
result = filter(lambda a: a > 33,li2)
print(list(result))

#map(函數，可迭代的對象）

li = [11,22,33,44,55]
def f1(args):
    result = []
    for i in args:
        result.append(100+i)
    return result
r = f1(li)
print(r)
def f2(a):
    return a + 100
#result = map(f2,li)
result = map(lambda a: a + 100,li)
print(list(result))

#區別
#filter 函數返回True，將元素添加到結果中
#map 將函數返回值添加到結果中

#globals,locals

NAME = "wangxin"
def show():
    a = 123
    c = 123
    print(locals())
    print(globals())
show()

#hash()  一般python內部使用，知道
s = "sadfsadfsadf"
print(hash(s))

#id()查看內存地址

#len()
s = "無馨"
print(len(s)) #python3默認按照字符、也可以轉化成字節查看，python2只能以字節方式查看
b = bytes(s.encoding='utf-8')
print(len(b))

#max,min,sum
r1 = max([11,22,33,44])
r2 = min([11,22,33,44])
r3 = sum([11,22,33,44])



#pow()
# 2**10
# r = pow(2,10)
# print(r)

#repr(),使用時會去調用這個對象的類里面的repr方法
#reversed,反轉，同列表的反轉
#round 四舍五入

#slice 和切片功能一樣
# s = "wangyuehan"
# print(s[0:2])

#sorted 排序，和列表排序一樣

#zip  將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。

l1 = ["likai",11,22]
l2 = ["is",11,22]
l3 =["sb",11,22,33]
r = zip(l1,l2,l3)
temp = list(r)[0]
ret = ' '.join(temp)
print(ret)

裝飾器

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import s2
ret = s2.f1("fafafa")
print("返回值",ret)
s2.f2(11,22)

#!/usr/bin/env python
#-*- coding:utf-8 -*-
def outer(func):
    def inner(*args,**kwargs):
        print('before')
        r = func(*args,**kwargs)
        print("after")
        return r
    return inner
# @ + 函數名
# 功能
#  1.自動執行outer函數并且將其下面的函數名f1當作參數傳遞
#  2.將outer函數的返回值，重新賦值給f1
@outer
def f1(arg):
    print(arg)
    return "哈哈"
@outer
def f2(a1,a2):
    print("F2")