No.005-Python-学习之路-Day3-编码|函数

编码

在Python2中:

默认编码是ASCII

文件开头的编码声明，是告诉python解释器，用哪种码去decode代码文件(.py),代码是以二进制格式存在内存中，但是也可以按照不同的编码格式转换成二进制流

在有 # -*- coding:utf-8 -*- 情况下， name = u"大保健" 则字符为unicode格式，不加u，则为utf-8的格式

utf-8 to gbk ，utf-8先decode成unicode，再encode成gbk

在Python3中:

默认即为utf-8，所以可以直接写中文，无需声明

声明的变量默认是unicode编码,非utf-8

数据格式都是 010101二进制到-->b'xe4xbdxa0xe5xa5xbd' bytes类型－－>按照指定编码转成你能看懂的文字

编码应用比较多的场景是爬虫

code is a piece of fucking shit, nobody likes it.

 编码的详细过程参考--->https://blog.csdn.net/qq_36761831/article/details/82291166

unicode与utf-8的不同与联系:

unicode是一种规定，只规定了每个字符的数字编号是多少，但是并没有规定这个编号如何存储。

比如“马”的Unicode是:U+9A6C，二进制即为:1001 1010 0110 1100，可以直接使用二进制存储，也有其他的方案比如UTF-8等

即，UTF-8是Unicode编码的一种实现

UTF-8使用边长字节来表示并存储unicode编号，存储字节数与unicode的编码大小有关，小的占用字节少，大的占用字节就多。

比如“马”-(U+9A6C)，整数编号39532，对应第三个范围，则其格式为1110XXXX 10XXXXXX 10XXXXXX，

将“马”-二进制1001 1010 0110 1100填入，即为11101001 10101001 10101100

函数式编程介绍

函数(实际为Subroutine)是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层层的函数调用，就可以把复杂的任务分解成简单的任务，这种分解可称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程中的函数指的是数学函数，即自变量的映射(一个函数的值仅决定于函数参数的值，不依赖其他状态)。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，多少次调用，值都不变。

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。如想要深入了解函数式编程，可以使用Erlang,Hashell这两门函数式编程语言。

函数式编程是没有变量的，无副作用的(传入固定，传出固定)。

函数

函数是什么?　　逻辑机构化和过程化的一种编程方法，与数学的函数区别很大，其在BASIC中叫subroutine、在Pascla叫procedure和function、在C中叫function、在Java中叫method。

编程中函数的定义?　　函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

为什么用函数?　　代码的重复利用、一致性、易扩展。

编程的方法有哪些?　　面向对象(类 class) 、面向过程(def)、函数式编程(def)。

# 语法
def sayhi():# sayhi即函数名
    print("hello everyone")

def calc(x, y): # 可带参数
    res = x**y   # 函数体
    return rex #返回值

函数的参数

形参:只有所在函数被调用时才分配内存单元，调用结束即可释放；

实参:可以是常量、变量、表达式、函数等，但必须有确定的值；

默认参数:在定义函数时，预先赋予一个形参某个值，即为默认参数；

def stu_register(name,age,course,country="CN"):# country即有默认值
    pass

stu_register(Bruce,25,Python) # 可不予默认参数赋值
stu_register(Bruce, 25, Python, US) # 可赋值替代默认参数

位置参数:按照顺序向形参传递实参即为位置参数

关键字参数:以“形参=实参”的方式传递的即为关键字参数

注意:位置参数必须在关键字参数之前，否则报错

stu_register(22,name='alex',course="python") #位置参数，关键字参数，关键字参数，默认值

非固定参数-位置参数

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)

stu_register("Jack",32,"CN","Python")

非固定参数-关键字参数

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)

stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")

全局变量与局部变量

全局变量:在程序主代码块定义的变量

局部变量:在程序子代码块定义的变量

注:当局部变量与全局变量同名时，子代码块内部局部变量生效，其他位置全局变量生效

# 全局变量，与局部变量
name1, name2, name3  = "Global-1",  "Global-2", "Global-3"# 全局变量
def name():
    global name2 # 在子代码块内强制为全局变量
    name1 = "Inside-1" # 在子代码块内，全局变量生效
    name2 = "Inside-2" # 已强制为全局变量，出代码块，仍然有效，不建议
    print(name1, name2, name3) # 子代码块可以直接调用全局变量name3
name()
print(name1, name2, name3)

返回值

要想获得函数的执行结果，可以使用return将结果反馈，如果未定义则返回None

return语句还代表函数的结束

# 返回值
def return1():
    name1 = "Bruce"
    return name1 #单个返回值
    print("after return") # return后不会执行
def return2():
    name1, name2 = "Bruce", "Amadeus"
    return name1, name2 # 多个返回值时，返回元组
print(return1(), return2())

嵌套函数

特性一:

name = "Bruce"
 
def change_name():
    name = "Bruce1"
 
    def change_name2():
        name = "Bruce2"
        print("第3层打印",name)
 
    change_name2() #调用内层函数
    print("第2层打印",name)
 
 
change_name()
print("最外层打印",name)

函数的递归

特性一:必须有一个明确的结束条件

特性二:每次进入更深层的递归时，问题规模相比上一次应有所减少

特性三:递归效率不高，递归层次过多会导致栈溢出，Python为防止这种情况，定义最大定义次数为999次

# 二分查找
list1 = list(range(1, 1000, 2))
def half_search(data_list, ser_num):
    mid = int(len(data_list)/2)
    if mid > 0:
        if data_list[mid] == ser_num:
            print("找到[{}]".format(data_list[mid]))
        elif data_list[mid] > ser_num:
            print("在[{}]的左边".format(data_list[mid]))
            half_search(data_list[:mid+1], ser_num)
        elif data_list[mid] < ser_num:
            print("在[{}]的右边".format(data_list[mid]))
            half_search(data_list[mid:], ser_num)
    elif data_list[0] == ser_num:
        print("找到[{}]".format(data_list[0]))
    else:
        print("没有[{}]".format(ser_num))

half_search(list1, 55)

高阶函数

函数接收的参数为一个函数，即为高阶函数，作用:在不修改被装饰函数源代码的前提下，附加功能；

函数的返回值是一个函数，即为高阶参数，

import time
# 参数为一个函数
def fuc1():
    time.sleep(3)
    print("bar")

def fuc2(fuc): # 装饰器要求一:不修改fuc1代码，添加功能
    print(fuc) # 此为fuc1的内存地址
    start_time = time.time() 
    fuc()
    stop_time = time.time()
    print("Tht Fuc spend time is %s" %(stop_time-start_time))

fuc2(fuc1) # 第二点未满足，原因改变了调用方式

import time
# 返回值为一个函数
def fuc1():
    time.sleep(3)
    print("bar")

def fuc2(fuc):
    print(fuc)
    return fuc

t = fuc2(fuc1) # 返回的是fuc的内存地址，so加"()"即可运行
print(t)
t() # 加"()"即可运行，so既然可以赋值那么我可以赋值给fuc1这个门牌号么?
fuc1 = fuc2(fuc1)
fuc1() # 装饰器要求二:不修改函数的调用方式

 end