字符串格式化及函数

字符串格式化及函数
(1)字符串格式化

python的字符串格式化有两种方式: 百分号方式, format方式

1.百分号格式
```
%[(name)][flags][width].[precision]typecode
```
(name) 可选,用于选择指定的key

flags 可选,可供选择的值有:

　　+ 右对齐;正数前加正号,负数前加负号;

　　- 左对齐;正数前无符号,负数前加负号;

　　空格右对齐; 正数前加空格,负数前加负号;

　　0 右对齐;正数前无符号,负数前加负号;用0填充空白处

width 可选,占有宽度

precision 可选,小数点后保留的位数

typecode 必选

　　s, 获取传入对象的__str__方式的返回值,并将其格式化到指定位置

　　r,获取传入对象的__repr__方法的返回值,并将其格式化到指定位置

　　c,整数:将数字转换成其unicode对应的值,10进制范围为 0 <= i <= 1114111(py27则支持　　 0-255);字符:将字符添加到指定位置

　　o,将整数转换成八进制表示,并将其格式化到指定位置

　　x,将整数转换成十六进制表示,并将其格式化到指定位置

　　d,将整数,浮点数转换成十进制表示,并将其格式化到指定位置

　　e,将整数,浮点数转换成科学计数法,并将其格式到指定位置(小写e)
- E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
- f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
- F，同上
- g，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
- G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
- %，当字符串中存在格式化标志时，需要用 %%表示一个百分号
```
注:python中百分号格式化是不存在自动将整数转换成二进制表示的方式
常用: %s>>>>>>>>输入为字符串
        %d>>>>>>>>输入格式为数字
        %f>>>>>>>>输入格式为浮点型,即小数,在%后加.数字表示保留小数点后几位,在f后加%%输入百分数
```
2.Format方式
```
[[fill]align][sign][#][0][width][,][.precision][type]
```
注意，在字符串中引用format，默认替换变量下标由0开始

(2)函数>>>>>def

特点:一次创建可多次调用,增强代码的重用性和可读性, 调用函数过程中, 函数的代码块中变量会被赋值,但在调用结束后, 变量对应的值会被清空, 不会占用内存空间
```
1 def   函数名(参数):
2 
3 
4         ' ' '
5         函数体
6         ' ' ' 
7         返回值
```
函数的定义主要有如下要点:

　　def : 标识符, 表示函数的关键字

　　函数名 : 函数的名称, 日后根据函数名调用函数, 函数名实质也是一个变量

　　函数体 : 函数中进行一系列的逻辑计算, 如: 发送邮件, 计算出 [11,22,38,888,2]中的最大数等

　　参数: 为函数体提供数据

　　返回值 : 当函数执行完毕后, 可以给调用者返回数据.结束函数, 可以一个return返回多个值以元组形式呈现, 若没设置返回值, 则会隐式返回一个none.

1.参数

函数参数分为形式参数跟实际参数

形式参数 : 在函数名后面括号里作为函数体逻辑判断的变量名

实际参数 : 在调用函数时,赋值给函数变量的值

位置参数和关键字(标准调用: 实参与形参位置-------对应; 关键字调用: 位置无需固定)

默认参数, 在定义形式参数的时候给参数赋值

参数组 (*args >>> 传列表元素,**kwargs传字典元素)

　　*arg若不传参数不会报错, 会输出一个空元组, 列表前不加*号默认将整个列表作为一个元素传给*arg

　　**kwargs若不传参不会报错,会输出一个空字典,传值方式有键值对(类似于关键字传值) 传值跟 *+字典传值

2.局部变量与全局变量

全局变量: 顶头无缩进定义的变量, 对全局有效的变量

局部变量: 在函数中定义的变量, 只有在调用该函数的时候对函数体起作用

global:声明修改全局变量

nonlocal:在函数内声明修改上一层变量, 只能修改函数内变量, 可以隔层往上寻找该变量,若最外层函数不存在该变量, 会报错
```
name = "tom"#定义全局变量无缩进
```
```
def con():
    name1 = "aric"#在函数中定义的变量为局部变量
    print(name1)
```
```
name = "tom"#定义全局变量无缩进
def con():
    name1 = "aric"#在函数中定义的变量为局部变量
    print(name1)#》》》》aric
con()#调用函数时候，局部变量只在函数内有效
print(name)#》》》》tom
```
```
n1 = "tom"
def n2():
    n1 = 123
    print(n1)#》》》》123
    def n3():
        nonlocal n1#》》》》声明修改上一层变量
        n1 = "aric"
    n3()
    print(n1)#》》》》aric
print(n1)#》》》》tom
n2()
print(n1)#》》》》》tom
```
```
n1 = "aric"

def  coin():

       global  n1#global声明修改全局变量

       n1 = "aric"

       print(n1)#>>>aric

coin()

print(n1)#>>>aric
```
(3)函数的引用

由于python执行代码的顺序是由前到后, 所以若要引用某函数, 需先在引用之前定义好该函数, 若在定义之前引用函数则会报错
```
def u():
    
    pass
    
    q()

u()#报错,q() 未定义
```
```
def u():

    pass
    
    q()

def q():

    pass
u()
q()#可以执行
```
(4)嵌套函数

在函数内层继续定义函数，调用函数的时候只能调用最外层函数，不能直接调用内层函数

作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变
```
n1 = "tom"
def n2():
    n1 = 123
    print(n1)#》》》》123
    def n3():#嵌套函数
        nonlocal n1
        n1 = "aric"
    n3()
    print(n1)#》》》》aric
print(n1)#》》》》tom
n2()
print(n1)#》》》》》tom
```
(5)递归函数

在函数内部, 可以调用其他函数. 如果一个函数在内部调用自身本身, 这个函数就是递归函数

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时, 问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)
```
def cl(n):
    print(n)
    if (int(n/2)) == 0:
        return n
    return cl(int(n/2))#调用函数本身
cl(10)
```
(6)匿名函数>>>>lambda

　　匿名函数就是不需要显示的指定函数,直接可以调用,不需要先定义,形式为lambda x:x的逻辑体,其中x为变量,处理结果为输出经过x的逻辑体处理过的x的值,即函数中的return,使用匿名函数可以简化很多简单函数
```
v = lambda  x,y,z:(x+1,y+1,z+1)#表示x,y,z分别+1并以列表输出
print(v(1,2,3))#>>>>(2,3,4)
```
(7)函数式编程

当下主流的编程方法有三种：函数式，面向过程，面向对象

高阶函数

1.map函数用法:

map(a,b),a为处理逻辑, b为要处理的可迭代对象, 处理过程(处理逻辑依次处理b中的元素),在Python2中直接生成列表,在python3中需要list转换
```
1 l1 = [1,2,3,4,5,6,7]
2 def redu(x):
3     return x-1
4 print(list(map(redu,l1)))#map(a,b),a为处理逻辑，b为要处理的可迭代对象，处理过程（处理逻辑依次处理b中的元素），在python2中直接生成列表，在python3中需用list转换
5 print(list(map(lambda x:x-1,l1)))#运用匿名函数可以简化很多过程
```
```
a = "tomp"
print(list(map(lambda x:x.upper(),a)))#>>>>>>['T', 'O', 'M', 'P']map可以处理很多可迭代对象
```
2.reduce函数用法：遍历对象，运用逻辑将可迭代对象合并
```
1 s = [1,2,3,4,5]
 2 def reduce_test(func,array,init=None):
 3     l=list(array)
 4     if init is None:
 5         res=l.pop(0)
 6     else:
 7         res=init
 8     for i in l:
 9         res=func(res,i)
10     return res
11 print(reduce_test(lambda x,y:x+y,s,50))#>>>>65
```
3.filter函数用法：相当于一个过滤器，filter(a,b)a相当于处理逻辑以布尔值方式作判断处理可迭代对象b，符合逻辑的保留，不符合的删除，生成迭代器，用list转换为列表
```
li = [11,222,333,44,55,66]
```
```
print(list(filter(lambda x:x>22,li)))#[33, 44, 55, 66, 77, 88, 99, 200]
```
相关阅读:
NGINX 代理以及 HTTPS (一)
HTTP 各种特性应用（二）
HTTP 各种特性应用（一）
HTTP 协议基础及发展历史
 添加表格
 C# 利用反射和特性来做一些事情
 HTTP 与 HTTPS
系统登录详解
 js表单提交到后台对象接收
 idea插件
原文地址：https://www.cnblogs.com/lovezwfjc/p/9268751.html

字符串格式化及函数

(1)字符串格式化

1.百分号格式

2.Format方式

(2)函数>>>>>def

1.参数

2.局部变量与全局变量

(3)函数的引用

(4)嵌套函数

(5)递归函数

(6)匿名函数>>>>lambda

(7)函数式编程

高阶函数