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'\xe4\xbd\xa0\xe5\xa5\xbd' 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)。

1 # 语法
3 def sayhi():# sayhi即函数名
4     print("hello everyone")
5 
6 def calc(x, y): # 可带参数
7     res = x**y   # 函数体
8     return rex #返回值

函数的参数

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

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

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

1 def stu_register(name,age,course,country="CN"):# country即有默认值
2     pass
3 
4 stu_register(Bruce,25,Python) # 可不予默认参数赋值
5 stu_register(Bruce, 25, Python, US) # 可赋值替代默认参数

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

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

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

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

非固定参数-位置参数

1 def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
2     print(name,age,args)
3 
4 stu_register("Jack",32,"CN","Python")

非固定参数-关键字参数

1 def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
2     print(name,age,args,kwargs)
3 
4 stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")

全局变量与局部变量

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

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

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

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

返回值

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

return语句还代表函数的结束

1 # 返回值
2 def return1():
3     name1 = "Bruce"
4     return name1 #单个返回值
5     print("after return") # return后不会执行
6 def return2():
7     name1, name2 = "Bruce", "Amadeus"
8     return name1, name2 # 多个返回值时，返回元组
9 print(return1(), return2())

嵌套函数

特性一:

 1 name = "Bruce"
 2  
 3 def change_name():
 4     name = "Bruce1"
 5  
 6     def change_name2():
 7         name = "Bruce2"
 8         print("第3层打印",name)
 9  
10     change_name2() #调用内层函数
11     print("第2层打印",name)
12  
13  
14 change_name()
15 print("最外层打印",name)

函数的递归

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

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

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

 1 # 二分查找
 2 list1 = list(range(1, 1000, 2))
 3 def half_search(data_list, ser_num):
 4     mid = int(len(data_list)/2)
 5     if mid > 0:
 6         if data_list[mid] == ser_num:
 7             print("找到[{}]".format(data_list[mid]))
 8         elif data_list[mid] > ser_num:
 9             print("在[{}]的左边".format(data_list[mid]))
10             half_search(data_list[:mid+1], ser_num)
11         elif data_list[mid] < ser_num:
12             print("在[{}]的右边".format(data_list[mid]))
13             half_search(data_list[mid:], ser_num)
14     elif data_list[0] == ser_num:
15         print("找到[{}]".format(data_list[0]))
16     else:
17         print("没有[{}]".format(ser_num))
18 
19 half_search(list1, 55)

高阶函数

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

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

 1 import time
 2 # 参数为一个函数
 3 def fuc1():
 4     time.sleep(3)
 5     print("bar")
 6 
 7 def fuc2(fuc): # 装饰器要求一:不修改fuc1代码，添加功能
 8     print(fuc) # 此为fuc1的内存地址
 9     start_time = time.time() 
10     fuc()
11     stop_time = time.time()
12     print("Tht Fuc spend time is %s" %(stop_time-start_time))
13 
14 fuc2(fuc1) # 第二点未满足，原因改变了调用方式
 1 import time
 2 # 返回值为一个函数
 3 def fuc1():
 4     time.sleep(3)
 5     print("bar")
 6 
 7 def fuc2(fuc):
 8     print(fuc)
 9     return fuc
10 
11 t = fuc2(fuc1) # 返回的是fuc的内存地址，so加"()"即可运行
12 print(t)
13 t() # 加"()"即可运行，so既然可以赋值那么我可以赋值给fuc1这个门牌号么?
14 fuc1 = fuc2(fuc1)
15 fuc1() # 装饰器要求二:不修改函数的调用方式

 

 

 

 

 

 

 

 

 end

posted @ 2019-12-12 16:58  FcBlogs  阅读(292)  评论(0)  编辑  收藏  举报