函数相关

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#笔记大纲
#1.函数对象(内存中的地址或映射),能够当作数据传递
#函数对象能够被调用
# def foo():
#     print("this is a test")
#
# foo1 = foo #把函数对象赋值给一个变量
# foo1() #---->foo()函数执行

#能够当作参数传递
# def foo1(args): #此处args的是foo2函数对象
#     print(args)
#     args()  #------>foo2()函数的调用
#
# def foo2():
#     print("this is foo2")
#
# foo1(foo2) #---->把foo2函数对象当作参数传递给foo1,最后实质是先print，而后args()--->foo2()


#返回值能够是函数
# def foo():
#     print('from foo')
#
# def bar(func):
#     return func #--->返回传入函数对象
#
# f=bar(foo) #---->把foo函数对象传入bar函数赋值给变量f,f实质仍是foo函数对象,f()调用函数执行的是foo()
#
# print(f)  #---->打印的是foo函数对象
#
# f() #---->foo()

#能够当作容器类型的元素
# def andy():
#     print("this is andy")
#
# def yang():
#     print("this is yang")
#
# test_l = {
#     "andy":andy,  #--->此处andy是函数对象
#     "yang":yang,  #--->此处yang是函数对象
# }
#
# while True:
#     chei = input(">> ").strip()
#     if chei in test_l:
#         test_l[chei]() #---->此处是经过字典的键取到对应的函数对象，而后加上()调用
#     else:
#         break

#2.函数的嵌套
# def foo5():
#     def foo6():
#         print("this is foo6")
#         def foo7():
#             print("this is foo7")
#         foo7()
#     foo6()
#
# foo5() #正常
#foo6() #此处报错，foo6()为内部函数只能在函数内部使用，当函数执行完成即销毁

#3.名称空间和做用域
#名称空间(定义名字的方法，名称到对象的映射，这就像是字典，键名是变量名，值是变量的值)
import time
# name = 'andy'
# def func():
#     pass
# class Foo():
#     pass

#名称空间的分类
#1.内置名称空间:随着python的解释器的启动而启动
# print(sum)
#
# import builtins
# for i in dir(builtins): #查看内置名称空间
#     print(i)

#2.全局名称空间：文件的执行会产生全局名称空间，指的是文件级别定义的名字都会放入该空间
# x=1 #全局名称空间
# def func():
#     money=2000  #---->局部名称空间
#     x=2  #---->局部名称空间
#     print('func')
#     print(locals())  #---->{'x': 2, 'money': 2000}局部名称空间名字
# print(x)
# print(func)
# # print(money)
#
# func()
# print(x)
#
# #print(globals()) === print(locals()) #由于全局名称空间对于它自己来讲也是一个局部，所以此处打印全局名称空间和局部名称空间是同样的


#局部名称空间：调用函数时会产生局部名称空间，只在函数调用时临时绑定，调用时结束
# x=10000
# def func():
#     x=1
#     def f1():
#         print("this is %d" %(x))
#     f1()
# func() #---->legb规则(locals -> enclosing function -> globals -> __builtins__)
#
# print(x) #---->输出10000，由于x=1是局部名称空间，因此在函数执行完成以后，就销毁

#做用域
    #全局做用域：内置名称空间，全局名称空间
    #局部做用域：局部名称空间
    #全局做用域：全局有效，在任何位置都能被访问到，除非del删掉，不然会一直存活到文件执行完毕
    #局部做用域的名字：局部有效，只能在局部范围调用，只在函数调用时才有效，调用结束就失效
    #查看全局做用域内的名字：gloabls()
    #查看局局做用域内的名字：locals()

# gx = 1000 #全局做用域的全局名称空间
# def gfoo():
#     gx = 2000 #局部做用域的局部名称空间，函数执行完则销毁
#     def lfoo():
#         print(gx)
#         print(locals()) #
#     lfoo()
#
# print(locals()) #---->等于print(globals())
# gfoo()
# print(gx)

#4.闭包函数(惰性计算)(定义在函数内部，包含对外部做用域而非全局做用域的引用)
# def bibao(x):
#     def relb():
#         z = x + 1
#         return z
#     return relb #将这个局部函数对象返回，以便在全局做用域调用
#
# ssg = bibao(4) #---->relb函数对象
# print(ssg())

# def bibao2():
#     x = 5
#     def bibao3():
#         return x + 3
#     return bibao3
#
# sp = bibao2()
# print(sp())

# from urllib.request import  urlopen
# def contr(url):
#     def wraper():
#         conts = urlopen(url).read()
#         return conts
#     return wraper
#
# sycont = contr("http://www.baidu.com")
# print(sycont().decode('utf-8'))

#5.装饰器函数(就是对闭包的一种实现，把装饰器下面的函数当成参数传递，对已有函数添加新的功能,装饰器自己能够是任何可调用对象(加()能够被执行)，被装饰的对象也能够是任意可调用对象)
import time
from urllib.request import urlopen

# def newb(func):
#     def newbi():
#         start_time = time.time()
#         func() #--->index()
#         stop_time = time.time()
#         print("spent times: %s" %(stop_time-start_time))
#     return newbi
#
# #@newb #--->index=newb(index)
# def index():
#     time.sleep(2)
#     print("welcome to my page")
#
# # index() #----->index=newbi
#
# f = newb(index) #---->f ==newbi函数对象,由于newb()执行返回的结果是newbi函数对象
# print(f) #----->f就是newbi函数对象
# f() #---->f()等于newbi()

#被装饰的函数有返回值
# def zhuangsq(func):
#     def fuck(*args,**kwargs):
#         stime = time.time()
#         news = func(*args,**kwargs) #----->yang()
#         etime = time.time()
#         print("spent times:%s" %(etime-stime))
#         return news
#     return fuck
#
# @zhuangsq
# def andy():
#     time.sleep(2)
#     print("this is andy")
#
# @zhuangsq  #--->yang=zhuangsq(yang)--->fuck函数对象
# def yang(name):
#     time.sleep(3)
#     print("this is yang")
#
# andy()
# yang("zhangyou") # ---->fuck('zhangyou')



#
# def zhuans(func):
#     def wrapper():
#         startime = time.time()
#         scont = func()
#         stoptime = time.time()
#         print("spent times: %s" %(stoptime-startime))
#         print(scont)
#     return wrapper
#
# @zhuans # ---->geturl=zhuans(geturl)
# def geturl():
#     time.sleep(10)
#     sp = urlopen("http://www.baidu.com").readline()
#     return sp.decode('utf-8')
#
# geturl()

#对已有函数添加用户名和密码认证功能
# userdb = {
#     "name":None,
#     "status":False
# }
#
#
# def auth(func):
#     def wrapper(*args,**kwargs):
#         if userdb["name"] and userdb["status"]:
#             res = func(*args,**kwargs)
#             return res
#         else:
#             name = input(">> ").strip()
#             password = input(">> ").strip()
#             if name == "andy" and password == "123":
#                 userdb["name"]="andy"
#                 userdb["status"]=True
#                 res = func(*args, **kwargs)
#                 return res
#             else:
#                 print("login failed!")
#     return wrapper
#
#
# @auth
# def mypage():
#     print("this is my homepage")
#
# @auth
# def mainpage(name):
#     print("this is my mainpage %s" %(name))
#
# mypage()
# mainpage("andy")


#有参装饰器叠加
# userdb = {
#     "name":None,
#     "status":False
# }
#
# def timer(func):
#     def newt(*args,**kwargs):
#         stime = time.time()
#         func(*args,**kwargs)
#         etime = time.time()
#         print("spent time:%s" %(etime-stime))
#     return newt
#
# def choi(driver):
#     def auth(func):
#         def wrapper(*args,**kwargs):
#             if driver=="file":
#                 if userdb["name"] and userdb["status"]:
#                     res = func(*args,**kwargs)
#                     return res
#                 else:
#                     name = input(">> ").strip()
#                     password = input(">> ").strip()
#                     if name == "andy" and password == "123":
#                         userdb["name"]="andy"
#                         userdb["status"]=True
#                         res = func(*args, **kwargs)
#                         return res
#                     else:
#                         print("login failed!")
#             elif driver=="mysql":
#                 print("this is mysql auth")
#             else:
#                 print("unkown auth")
#         return wrapper
#     return auth
#
# @timer
# @choi("mysql") #--->auth---mypage = wrapper(mypage)--->index=wrapper
# def mypage():
#     print("this is my homepage")
# @timer
# @choi("file")
# def mainpage(name):
#     print("this is my mainpage %s" %(name))
#
# mypage()
# mainpage("andy")

#6.迭代器(内置__iter__方法的，都是可迭代的对象，执行__iter__方法获得的结果就是迭代器，迭代器对象有__next__方法;对于没有索引的数据类型，必须提供一种不依赖索引的迭代方式)
# h = [1,2,3]
# m = h.__iter__()
# print(next(m))
# print(next(m))
# print(next(m))


# j = {"a":1,"b":2,"c":3}
# n = iter(j) #此处n是迭代器
# print(n)
# key = next(n)
# print(j[key],key)
# print(next(n))
# print(next(n))

#判断数据类型是不是能够被迭代或者是迭代器(文件是可迭代对象自己也是迭代器，对迭代器使用iter方法获得的仍是迭代器自己)
from collections import Iterable,Iterator

# f=open('a.txt','w')
# print(isinstance('abc',Iterable))
# print(isinstance([],Iterable))
# print(isinstance((),Iterable))
# print(isinstance({'a':1},Iterable))
# print(isinstance({1,2},Iterable))
# print(isinstance(f,Iterable))


# print(isinstance('abc',Iterator))
# print(isinstance([],Iterator))
# print(isinstance((),Iterator))
# print(isinstance({'a':1},Iterator))
# print(isinstance({1,2},Iterator))
# print(isinstance(f,Iterator))

#7.生成器函数(只要函数体包含yield关键字，该函数就是生成器函数，生成器也是迭代器,至关于yield为函数封装好了__iter__和__next__方法)
# def foo12():
#     print("first")
#     yield 1
#     print("second")
#     yield 2
#     print("third")
#     yield 3
#
# hk = foo12() #此处hk是生成器对象
# for i in hk:
#     print(i)
# print(next(hk))
# print(next(hk))
# print(next(hk))

#tail -f a.txt|grep "python" #定义2个生成器，一个用于输出最后一行的内容，一个用于查找关键字

# def readt(name):
#     with open(name,"r",encoding='utf-8') as f:
#         f.seek(0,2)
#         while True:
#             m = f.readline().strip()
#             if m:
#                 yield m
#             else:
#                 time.sleep(0.2)
#
# # t = readt("a.txt") #--->生成生成器对象
# # # print(t)
# #
# # for line in t:
# #     print(line)
#
# def grep(pattern,lines):
#     for line in lines:
#         if pattern in line:
#             yield line
#
#
# g=grep('python',readt('a.txt'))
# # print(g)
# for i in g:
#     print(i)



#8.内置函数
# print(dir(__builtins__))
#
# for h in dir(__builtins__): #查看内置函数的方法
#     print(h)
#
# help(sum) #查看具体函数的帮助

#查看一个对象下面的属性
# list_a = []
# print(dir(list_a))


#zip(将多个能够迭代对象中的元素一一对应并生成元组)
# s = "andy"
# b = "1234"
# t = "wesr"
# z = zip(s,b,t)
# for i in z:
#     print(i)

#eval将字符串中的命令转换出来执行
# dic="{'a':1,'b':2}"
# d=eval(dic)
# print(type(d),d['a'])