python第三话之格式化输出和深浅复制

[TOC]

格式化输出和深浅拷贝

前面我熟悉了列表、字符串、元组的常用操作以及对应的增删改查，今天我们来深入了解格式化输出和深浅复制相关的知识点。

格式化输出

传统方法

`%s`

%字符串

演示：

In [1]: a = 'hello'                                                    

In [2]: b = 'python '                                                  

In [3]: "%s %s" %(a, b)                                                
Out[3]: 'hello python '

In [4]: c = 123                                                        

In [5]: "%s %s" %(a, c)                                                
Out[5]: 'hello 123'

`%d`

%数字
注意：只能传入数字

演示：

In [6]: a = 'hello'                                                    

In [7]: b = 'python '                                                  

In [8]: c = 123                                                        

In [9]: "%d %d" %(a, c)                                                
-----------------------------------------------------------------------
TypeError                             Traceback (most recent call last)
<ipython-input-9-2d6d5e198328> in <module>
----> 1 "%d %d" %(a, c)

TypeError: %d format: a number is required, not str

In [10]: "%d %d" %(c, c)                                               
Out[10]: '123 123'

In [11]: "%d"%123.34                                                   
Out[11]: '123'

In [12]: "%d %d" %(123, 123.34)                                        
Out[12]: '123 123'

`%f`

%浮点数

演示：

In [14]: '%f'%2.3                                                      
Out[14]: '2.300000'

In [15]: '%.2f'%2.3                                                    
Out[15]: '2.30'

In [16]: '%.2f'%2.333434                                               
Out[16]: '2.33'

In [17]: '%.2f'%2.35                                                   
Out[17]: '2.35'

In [18]: '%.2f'%2.36                                                   
Out[18]: '2.36'

In [19]: '%.3f'%2.36                                                   
Out[19]: '2.360'

In [20]: '%.4f'%2.36                                                   
Out[20]: '2.3600'

`%c`

%ASCII字符

演示：

In [21]: '%c'%97                                                       
Out[21]: 'a'

In [22]: '%c'%65                                                       
Out[22]: 'A'

In [23]: '%c'%61                                                       
Out[23]: '='

In [24]: '%c'%60                                                       
Out[24]: '<'

`%o`

%8进制

演示：

In [25]: '%o'%9                               
Out[25]: '11'

In [26]: '%o'%10                              
Out[26]: '12'

In [27]: '%o'%107                             
Out[27]: '153'

In [28]: '%o'%17                              
Out[28]: '21'

`%x`

%16进制

演示：

In [29]: '%x'%16                              
Out[29]: '10'

In [30]: '%x'%15                              
Out[30]: 'f'

In [31]: '%x'%14                              
Out[31]: 'e'

In [32]: '%x'%10                              
Out[32]: 'a'

`%e`

%科学计数法

演示：

In [33]: '%e'%0.01                            
Out[33]: '1.000000e-02'

In [34]: '%e'%0.001                           
Out[34]: '1.000000e-03'

In [35]: '%e'%10                              
Out[35]: '1.000000e+01'

In [36]: '%e'%100                             
Out[36]: '1.000000e+02'

`扩展`

原始化

演示：

In [43]: print('%s'%'123')                    
123

In [44]: print('%r'%'123')                    
'123'

%+6.5f

规定输出的字符串的个数和输出小数的位数
注意：%6.5f 指的是一个输出6个字符，其中5个小数
如果：前面带+就是表示输出符号
前面带-号表示左对齐

演示：

In [46]: '%5.3f'%1.2                          
Out[46]: '1.200'

In [47]: '%6.3f'%1.2                          
Out[47]: ' 1.200'

In [48]: '%6.3f'%12.34567                     
Out[48]: '12.346'
    
In [49]: '%+6.3f'%12.34567                    
Out[49]: '+12.346'

In [50]: '%+6.3f'%-12.34567                   
Out[50]: '-12.346'
    
In [60]: '%8.2f'%13.3333                      
Out[60]: '   13.33'

In [61]: '%-8.2f'%13.3333                     
Out[61]: '13.33   '

In [62]: '%08.2f'%13.3333                     
Out[62]: '00013.33'

Python方法

在Python中我们一般使用format来进行格式化输出

`format`

In [67]: '{:.2f}'.format(12.333)              
Out[67]: '12.33'

In [68]: '{a:.2f}'.format(a=12.333)           
Out[68]: '12.33'

保留两位小数

In [70]: '{:.2%}'.format(0.001)               
Out[70]: '0.10%'

In [71]: '{:.2%}'.format(0.61)                
Out[71]: '61.00%'

百分比格式

In [72]: '{0:x}'.format(20)                   
Out[72]: '14'

In [73]: '{0:x}'.format(10)                   
Out[73]: 'a'

转换成十六进制

In [74]: '{0:o}'.format(20)                   
Out[74]: '24'

In [75]: '{0:o}'.format(10)                   
Out[75]: '12'

转换成8进制

注意：进制转换时使用{0:进制}这个格式

1 2	In [76]: '{a:<10}'.format(a=12.3,b=13.44) Out[76]: '12.3 '

左对齐，长度为10

1
2
3

In [77]: '{a:0<10}'.format(a=12.3,b=13.44)    
    ...:                                      
Out[77]: '12.3000000'

数字补x(填充右边，宽度为4)

1 2	In [78]: '{a:0>10}'.format(a=12.3,b=13.44) Out[78]: '00000012.3'

右对齐，长度为10

1 2	In [79]: '{a:0^10}'.format(a=12.3,b=13.44) Out[79]: '00012.3000'

两边对齐，长度为10

字符串转义

字符前面加上 \ ，字符就不再表示字符本身的意思，表示ASCII码中不能显示字符，常见有下：

`\n`

换行

演示：

1
2
3

In [83]: print('abc\nabc')                    
abc
abc

`\t`

水平制表符

演示：

1 2	In [84]: print('abc\tabc') abc abc

`\b`

退格

演示：

1 2	In [85]: print('abc\babc') ababc

`\r`

回车，当前位置移到本行开头

演示：

1 2	In [87]: print('abc\rbc') bcc

`\`

代表反斜杠 \

演示：

1 2	In [88]: print('abc\\bc') abc\bc

`\’`

代表一个单引号，同样的 “ ？等符号也可以这么输出

演示：

1 2	In [95]: print('abc\' \"b c') abc' "b c

`\0`

代表一个空字符

演示：

In [96]: print('abc\0abc')                    
abcabc

In [97]: print('abc\0\0abc')                  
abcabc

`\a`

系统提示音(交互环境需使用print)

`取消转义`

在python中如果要去掉字符串的转义，只需要在字符串前面加上 r

演示：

1 2	In [104]: print(r'abc\b\t\nabc') abc\b\t\nabc

格式化和转义的应用

格式化得到的结果都是字符串，通过把位置预先留出来，后期再往其中填入内容可以让输出内容更加整洁美观，而又具有良好的可读性，同时让代码更简洁精练。

字符串的转义可以方便我们表示我们不太方便表示的字符，同时转义有些情况下又会带来麻烦，特别是在表示路径的时候，这种情况下可以在字符串前面加上 r 来去掉字符串的转义。

字符串编码

对于编码这部分，我们先举个栗子来看看：

In [105]: '你好'.encode('utf-8')                  
Out[105]: b'\xe4\xbd\xa0\xe5\xa5\xbd'

In [106]: '你好'.encode('gbk')                    
Out[106]: b'\xc4\xe3\xba\xc3'

我们可以通过不同的编码方式来进行编码以便我们在不同情况下使用，接下来我们来看看编码相关的知识点

Python对于字符集的处理

字符编码的作用

Python统一了编码，这样Python在内部处理的时候不会因编码不同而出现程序不能正常执行的问题。

Python会自动根据系统环境选择编码，但是经常在文件传输的过程中，会遇到各种不同的编码，这个时候就需要我们去处理编码问题。

深浅复制

举个栗子看看

In [107]: s = [1, 2, 3]                           

In [108]: s2 = ['a', s]                           

In [109]: s2                                      
Out[109]: ['a', [1, 2, 3]]

In [111]: id(s), id(s2), id(s2[1])                                     
Out[111]: (139956880001800, 139956880021256, 139956880001800)

我们可以看出来，s2只是引用了s的值，s2[1]的值会随着s的变化而变化。

浅复制

举个栗子：

In [136]: s = [1, 2, 3]                                                

In [137]: s2 = ['a', s]                                                

In [138]: s3 = s2.copy()                                               

In [139]: s[0]='w'                                                     

In [140]: s2                                                           
Out[140]: ['a', ['w', 2, 3]]

In [141]: s3                                                           
Out[141]: ['a', ['w', 2, 3]]

In [149]: id(s2[1]), id(s3[1]),id(s)                                   
Out[149]: (139956883394376, 139956883394376, 139956883394376)

由上面的栗子可以看出来，虽然s3是copy的，但是s3还是会随着s的变化来变化的。那我们有什么办法让s3的值不变呢?那就是深拷贝。

深复制

举个栗子：

In [150]: s = [1, 2, 3]                                                

In [151]: s2 = ['a', s]                                                

In [152]: import copy                                                  

In [153]: s3 = copy.deepcopy(s2)                                       

In [154]: s2                                                           
Out[154]: ['a', [1, 2, 3]]

In [155]: s3                                                           
Out[155]: ['a', [1, 2, 3]]

In [156]: s[0]='r'                                                     

In [157]: s2                                                           
Out[157]: ['a', ['r', 2, 3]]

In [158]: s3                                                           
Out[158]: ['a', [1, 2, 3]]

In [159]: id(s),id(s2[1]),id(s3[1])                                    
Out[159]: (139956879794952, 139956879794952, 139956879278408)

通过深拷贝，我们就实现了，原数据改变的时候，复制的数据不会随着改变。

深浅复制的应用

深浅复制只有在列表嵌套列表的情况下讨论。

如果想保留修改之前的数据，就可以使用列表的复制，但要注意列表嵌套情况下的问题。

bytes和bytearray

bytes二进制序列类型

In [169]: a= bytes(3)                                                  

In [170]: a[0]                                                         
Out[170]: 0

In [171]: a[1]                                                         
Out[171]: 0

使用bytes(number)指定长度的零填充字节生成一个二进制的序列类型

1 2	In [172]: bytes(b'abc') Out[172]: b'abc'

二进制字符串

bytearray二进制数组

In [173]: a = bytearray(3)                                             

In [174]: a                                                            
Out[174]: bytearray(b'\x00\x00\x00')

In [175]: a[1]                                                         
Out[175]: 0

使用bytearray(number)指定长度的零填充字节生成一个二进制的数组

1 2	In [176]: bytearray(b'abc') Out[176]: bytearray(b'abc')

二进制字符串

二进制序列类型的应用

二进制序列类型的用法比较少见，是python中少用的一种序列类型。

对于二进制序列类型，大家基本了解即可。

转载请注明：Seven的博客