字符串格式化及函数

时间 2019-12-11

标签字符串格式化函数繁體版

原文原文链接

(1)字符串格式化

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

1.百分号格式

%[(name)][flags][width].[precision]typecode

(name) 可选,用于选择指定的key编程

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

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

　　- 左对齐;正数前无符号,负数前加负号;函数式编程

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

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

width 可选,占有宽度code

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

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]

fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）

<，内容左对齐
>，内容右对齐(默认)
＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即便：符号+填充物+数字
^，内容居中

sign 【可选】有无符号数字
- +，正号加正，负号加负；
- -，正号不变，负号加负；
- 空格，正号空格，负号加负；
# 【可选】对于二进制、八进制、十六进制，若是加上#，会显示 0b/0o/0x，不然不显示
，【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型

传入” 字符串类型 “的参数
- s，格式化字符串类型数据
- 空白，未指定类型，则默认是None，同s
传入“ 整数类型 ”的参数
- b，将10进制整数自动转换成2进制表示而后格式化
- c，将10进制整数自动转换为其对应的unicode字符
- d，十进制整数
- o，将10进制整数自动转换成8进制表示而后格式化；
- x，将10进制整数自动转换成16进制表示而后格式化（小写x）
- X，将10进制整数自动转换成16进制表示而后格式化（大写X）
传入“ 浮点型或小数类型 ”的参数

e，转换为科学计数法（小写e）表示，而后格式化；
E，转换为科学计数法（大写E）表示，而后格式化;
f ，转换为浮点型（默认小数点后保留6位）表示，而后格式化；
F，转换为浮点型（默认小数点后保留6位）表示，而后格式化；
g，自动在e和f中切换
G，自动在E和F中切换
%，显示百分比（默认显示小数点后6位）

注意，在字符串中引用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]