函数编程

函数编程

bytes类型

• s = b”Hello World”
• “小猿圈”.encode(“utf-8”)

深浅copy

• d2 = data.copy() #浅copy
• import copy #深copy
  d3 = copy.deepcopy(data)

编码转换

• s.encode(“utf-8”) #编码成为bytes类型
• b’\xe5\xb0\x8f\xe7\x8c\xbf\xe5\x9c\x88’.decode(“utf-8”) #解码

函数

• def register(name,age,major,country) : #三个引号填写函数注释
  “”"
  学籍注册程序
  :param name:str,Eg:Alex
  :param age:int,Eg:20
  :param major:str,Eg:Chinese
  :param country:str,Eg:USA
  :return:
  “”"
• 形参、实参
  
• 默认参数
  def stu_register(name,age,course,country=“CN”):
• 关键参数
  stu_register(“王山炮”,course=‘PY’, age=22,country=‘JP’ )
• 非固定参数
  def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
  def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的关键参数变成一个dict形式

函数返回值与作用域

• 函数返回值
  def return_more(name,age) :
  return name,age #以元组的形式返回
  print(return_more(“alex”,22))
  #结果：
  (‘alex’, 22)
• 函数作用域
  即有效范围，global name声明全局变量

嵌套&匿名&高阶函数

• 嵌套函数
  def f1():
   def f2():
   print(“Hello”)
   f2()
  f1()
• 匿名函数
  res = map(lambda x:x**2,[1,5,7,4,8]) #map和filter函数需要for循环输出结果
• def add(x,y,f): #插入一个函数作为参数
  return f(x) + f(y) #用插入的函数来计算前两个参数并且返回计算后的值

函数的递归

• 函数递归
  def calc(n):
   n = int(n/2)
   print(n)
   if n > 0:
  calc(n) #递归函数就是不断地调用自己

内置函数

• abs # 求绝对值abs（-1）
• bytes#将字符转成二进制，bytes(“中国”,”gbk”)等同于”中国”.encode(“gbk”)
• enumerate #返回列表的索引和元素，比如 d = [“alex”,”jack”]，enumerate(d)后，得到(0, ‘alex’) (1, ‘jack’)
• eval #可以把字符串形式的list,dict,set,tuple,再转换成其原有的数据类型，eval("[1,2,3]")
• exec #把字符串格式的代码，进行解义并执行，exec(“print(‘hellworld’)”)
• filter #对list、dict、set、tuple等可迭代对象进行过滤， filter(lambda x:x>10,[0,1,23,3,4,4,5,6,67,7])过滤出所有大于10的值
• isinstance #判断一个数据结构的类型，isinstance(“abc”,str)
• sorted(iterable, cmp=None, key=None, reverse=False)
  sorted(data_device.items(), key= lambda item:item[1], reverse= True)
• zip #（像拉链）可以把2个或多个列表拼成一个
  a=[1, 4, 9, 1849, 2025, 25, 36]，b = [“a”,”b”,”c”,”d”]
  list(zip(a,b)) #得结果 [(1, ‘a’), (4, ‘b’), (9, ‘c’), (1849, ‘d’)]

名称空间

• locals:函数内部的名字空间
• enclosing function:（最近的）
• globals
• builtins内置模块空间

闭包现象

• def outer() :
   name = “Alex”
   def inner() :
     print(name)
   return inner  #这里只是返回inner的函数名称（也是内存地址）
  fun = outer()   #这里fun就等于inner，也指向inner的内存地址
  fun()   #这里相当于inner(),将inner函数执行了

装饰器

account = {
    "is_authenticated":False,# 用户登录了就把这个改成True
    "username":"alex", # 假装这是DB里存的用户信息
    "password":"abc123" # 假装这是DB里存的用户信息
}
def login(func):	#这里要插入一个函数
    def inner(): # 再定义一层函数
        if account["is_authenticated"] is False:
            username = input("user:")
            password = input("pasword:")
            if username == account["username"] and password == account["password"]:
                print("welcome login....")
                account["is_authenticated"] = True
            else:
                print("wrong username or password!")
        if account["is_authenticated"] is True:
            func()
    return inner  # 注意这里只返回inner的内存地址，不执行
def home():
    print("---首页----")
def america():
    print("----欧美专区----")
def japan():
    print("----日韩专区----")
def henan():
    print("----河南专区----")
home()
america = login(america) # 这次执行login返回的是inner的内存地址 .inner at 0x101762840>
henan = login(henan)  # .inner at 0x102562840>
america()  # 相当于执行inner()
henan()

列表生成式

• 列表生成式
  a = [i+1 for i in range(10)] #for前面是输出结果，后面是循环
• 集合生成式

d = {"salary":100,"age":20}
d = {k:v+1 for k,v in d.items()}
print(d)
{'salary': 101, 'age': 21}
dict0 = {"英语":66, "数学":78, "政治":42, "语文":59}
    #去除掉字典中value < 60的数据
dict1 = {k:v for k, v in dict0.items() if v >= 60}
print(dict1)
{'英语': 66, '数学': 78}

生成器generator

一边循环一边计算后面元素的机制，称为生成器，保存算法，一步步推导，不用事先循环出所有数据

• 列表生成式改为生成器，直接将[]改为（）

>>> [x * x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> (x * x for x in range(10))	#只是保存了算法，并没有实际执行
 at 0x101ebc3b8>
(x*x for x in range(10)）生成的就是一个生成器
g = (x * x for x in range(10))
next(g)	#next函数导出，也可以用for循环导出数据

• 函数生成器
  斐波那契函数

def fib(max):
    a,b = 0,1
    n = 0  # 斐波那契数
    while n < max:
        n = a + b
        a = b # 把b的旧值给到a
        b = n # 新的b = a + b(旧b的值)
        #print(n)
        yield n		 #类似return，但是return会结束程序，yield只会暂停并且返回当前值，使用next（）语法就继续下一步
f = fib(100) 		# 注意这句调用时，函数并不会执行，只有下一次调用next时，函数才会真正执行，必须用f替代fib()函数，否则next()每次调用只会返回函数头开始执行，永远不会执行yield以后的部分
print(f)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
输出
1
2
3
5

• 并发编程
  从外部给生成器内输入值

def g_test() :
    while True :
        n = yield
        print("recieve",n)
g = g_test()
next(g)	#生成器的第一个输入必须为空值None，在输入前必须调用一次生成器到yield等候下次next命令，next(g)就是第一次调用并且返回None输入给yield
for i in range(3):
    g.send(i)
输出结果：
recieve 0
recieve 1
recieve 2

迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator