Python基础(2)数据类型、运算符、字符串

变量声明与赋值

Python 是强类型语言，每个对象都有数据类型，只支持该类型支持的操作。python中的变量声明不需要写出变量的类型，直接给出赋值语句即可。如a=85，在程序运行时，解释器先对"="右边的表达式进行运算，生成一个代表表达式运算结果的对象，然后，将这个对象的地址赋值给左边的变量。需要注意的是，虽然无需申明变量类型，但是赋值之后变量的类型就由“=”右边的对象确定了，后续操作时仍要遵守各种类型的运算规则。并且变量在使用前必须先被初始化（先被赋值）。

>>> aa
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    aa
NameError: name 'aa' is not defined
#变量未赋值而报错
>>> aa=85
>>> bb='hi'
>>> cc=aa+bb
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    cc=aa+bb
TypeError: unsupported operand type(s) for +: 'int' and 'str'
#整型和字符串类型不可以直接相加

链式赋值

用于同一个对象赋值给多个变量
a=b=85等价于a=85;b=85

系列解包赋值

系列数据赋值给对应相同个数的变量（个数必须保持一致）
a,b,c=4,5,6 相当于：a=4;b=5;c=6
利用系列解包赋值直接实现变量互换

>>> a,b=8,5
>>> a,b=b,a
>>> print(a,b)
5 8
#交换成功
>>> a=1
>>> b=2
>>> a,b=b,a
>>> print(a,b)
2 1
#交换成功
>>> a=8
>>> b=5
>>> b=a
>>> a=b
>>> print(a,b)
8 8
#交换失败。这样写需要第三个变量才可成功
>>> a=8
>>> b=5
>>> a=b
>>> b=a
>>> a
5
>>> b
5
#交换失败。这样写需要第三个变量才可成功

常量

常量的值不变，如a=85，则a的值一直是85。但是在python中不支持常量，没有语法规则限制改变一个常量的值。我们只能约定常量的命名规则（全使用大写字母，多个单词用下划线隔开，如MIN_SPEED），以及在程序的逻辑上不对常量的值作出修改（不主动修改）。

内置数据类型、运算符

每个对象都有id、type，value。type可以用户进行自定义，这里先介绍最基本的内置数据类型：

1. 整型整数，2345,10,50
2. 浮点型 小数，3.14 或者科学计数法 314e-2
3. 布尔型 表示真假，仅包含：True、False
4. 字符串型 由字符组成的序列。 “abc”，“天天向上“，”yi“

普通运算符

divmod()函数同时得到商和余数： divmod(10，5) 返回的(2, 0)是一个元组

1. 比较运算符可以连用，并且含义和我们日常使用完全一致。

>>> a = 4 
>>> 3<a<10 #关系运算符可以连用 
True

2. 位操作
   tips：左移 1 位相当于乘以 2，左移 2 位，相当于乘以 4，左移 3 位，相当于乘以 8；右移 1 位相当于除以 2。用左移来实现乘法是速度最快的！

>>> a = 0b11001 
>>> b = 0b01000 
>>> c = a|b #按位或，有1为1，否则为0
>>> bin(c) #bin()可以将数字转成二进制表示 
'0b11001' 
>>> bin(c&b)#按位与，两位同时为1才为1，否则为0
'0b1000' #本是0b01000，0b是指二进制，真正的第一位是0，所以省略了变成0b1000
>>> bin(c^b) #按位异或，相异为1
'0b10001'
>>> a = 3 
>>> a<<2 #左移 1 位相当于乘以 2.左移 2 位，相当于乘以 4
12
>>> a = 8 
>>> a>>1 #右移 1 位相当于除以 2

3. 加法操作
   (1) 数字相加 3+2 = => 5
   (2) 字符串拼接 “3”+“2”= => “32”
   (3) 列表、元组等合并 [10,20,30]+[5,10,100] = =>[10,20,30,5,10,100]
4. 乘法操作
   (1) 数字相乘 3*2 = => 6
   (2) 字符串复制 “sxt”*3 = => ”sxtsxtsxt”
   (3) 列表、元组等复制 [10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]

增强型赋值运算符

>>> a=8
>>> a+=5
>>> a
13
>>> a+ =1 #注意：+=之间不可以有空格
SyntaxError: invalid syntax
>>> a += 1 #+=外面可以有空格
>>> a
14

复合赋值运算符

Python 不支持自增(++)和自减(–)

比较运算符

所有比较运算符返回 1 表示True，返回 False表示假。 以下假设变量 a 为 5，变量 b 为 8：

逻辑运算符

与：只要有一个为假，结果就是假
或：至少有一个为真结果就为真
非：取反，e.g。not 85 得到False

>>> a=True
>>> b=False
>>> a or b
True
>>> a or 85/0
True
#任何数除0都是不可以的，但是在or运算中，前面是True就不计算后面的值，因此这里输出为True
>>> 85/0 or a
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    85/0 or a
ZeroDivisionError: division by zero
#or运算是先运算前面的值，才运算后面的值，85/0放在前面就会报错
>>> c=97
>>> d=85
>>> c or d
97
>>> d or c
85
#数字都可以看作是“True“，所以当or前面为真时，就输出前面的值
>>> c and d
85
>>> d and c
97
#and运算：前面为真，则输出后面的值
>>> b or 85/0
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    b or 85/0
ZeroDivisionError: division by zero
>>> b or 85
85
>>> 85 or a
85
>>> 85 or b
85
>>> b and 85
False
>>> a and 85
85
>>>  not 85
False

同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

is 与 = = 的区别
is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。
== 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq()方法。

整数缓存问题

Python 仅仅对比较小的整数对象进行缓存（范围为**[-5, 256]，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])**。
总结
1、is 比较两个对象的 id 是否相等，是否指向同一个内存地址；
2、= = 比较的是两个对象的value是否相等；
3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用，在 Pycharm 或者保存为文件执行时会不同。
4、is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。

>>> a=85
>>> b=85
>>> id(a)
140713660492816
>>> id(b)
140713660492816
>>> a is b
True
>>> a == b
True
#这是在IDLE中执行的结果，因为85在-5~256之间，因此被缓存了，使用过程中没有增加新的对象，没有开辟新的地址。

>>> a=999
>>> b=999
>>> id(a)
2201709567760
>>> id(b)
2201709567952
>>> a is b
False
>>> a==b
True
#这是在IDLE中执行的结果，999不在-5~256之间，使用过程中增加了新的对象，开辟了新的地址。不同的地址防止相同的值。

运算符优先级问题

如下优先级，从高到低。

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

整数进制

python中有二进制（0b 或 0B)(0,1)、八进制（0o 或 0O）(0-7)、十进制(0-9)、十六进制（0x 或 0X）(0-9,a-f）

>>> 0b101
5
>>> 0b111
7
>>> 0o10
8
>>> 0xfa
250

Python2 中，int 是 32 位，可以存储从-2147483648 到 2147483647 的整数（约± 21 亿）。Long 类型是 64 位，可以存储：-263—— 263-1 之间的数值。 Python3 中，int 可以存储任意大小的整数，long 被取消。Python3 中可以做超大数的计算，而不会造成“整数溢出”，这也是 Python 特别适合科学运算的特点

浮点数

float就是浮点数，浮点数用 a*b^10 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。 这些数字在内存中也是按照科学计数法存储。

类型转换

整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：8.0+5 的结果是 13.0。

int（）的类型转换（不可四舍五入）

1. 浮点数直接舍去小数部分。
2. 布尔值 True 转为 1，False 转为 0。
3. 字符串符合整数格式（浮点数格式以及含有字母不行）则直接转成对应整数，否则报错。

a=5.9
>>> int(a)
5
>>> b=int(a)
>>> id(a)
2201708969904
>>> id(b)
140713660490256
>>> id(5.9)
2201707475248
>>> id(5)
140713660490256
#**说明int()后是新增加了一个对象（5），有单独的id地址，而不是修改原来对象（5.9)的值，原来的对象没有任何改变**

>>> int(True)
1
>>> int(False)
0
#布尔型

>>> int("9785")
9785
>>> int("97.85")
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    int("97.85")
ValueError: invalid literal for int() with base 10: '97.85'
>>> int("85yibo")
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    int("85yibo")
ValueError: invalid literal for int() with base 10: '85yibo'
#**对于字符串而言只可转换整数格式的字符串**

float（）的类型转换

1. 与int（）一样，<<<float（85）是新建了一个对象（85.0），将新对象的地址给了变量a，原对象（85）并未做任何改变。
2. 布尔值 True 转为 1.0，False 转为 0.0。
3. 可对整数和小数格式的字符串进行转换，含有字母的字符串不可以转换。

>>> a=float(85)
>>> a
85.0
>>> id(a)
2201707475248
>>> id(85)
140713660492816
>>> id(85.0)
2201707475696
#与int（）一样，是新建了一个对象（85.0），将新对象的地址给了变量a，原对象（85）并未做任何改变

>>> float(True)
1.0
>>> float(False)
0.0
#布尔型

>> float("85")
85.0
>>> float("97.85")
97.85
>>> float("85yibo")
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    float("85yibo")
ValueError: could not convert string to float: '85yibo'
#可对整数和小数格式的字符串进行转换

round（）四舍五入

round(value)可以返回四舍五入的值，但不会改变原有值，而是产生新的值（与int（）和float（）一样）

>>> round(9.7)
10
>>> round(9.1)
9

str（）的类型转换

str()可以将数字（整数、小数直接转为整数、小数；科学计数法转为对应小数）和布尔值转换成字符串。注意，布尔值转换成字符串后不是“0”或“1”，而是“False”或"True"

>>> str(True)
'True'
>>> str(False)
'False'
>>> str(3.534)
'3.534'
>>> str(3142-2)#先进行运算再转换
'3140'
>>> str(314e-2)
'3.14'
>>> str(314e10)
'3140000000000.0'
>>> str(5)
'5'

unix时间点、 当前时间

计算机中时间是“1970 年 1 月 1 日 00:00:00”为原点，以毫秒（1/1000 秒） 进行计算。原点时刻也称为“unix 时间点”。

python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位，带微秒 （1/1000 毫秒）精度的浮点值。

>>> import time
>>> a=time.time()
>>> a
1614951391.4470026

布尔值

Python2 中没有布尔值，直接用数字 0 表示 False,用数字 1 表示 True。 Python3 中，把 True 和 False 定义成了关键字，可以和数字相加。

>>> a=True
>>> b=a+85
>>> c=True+85
>>> print(b,c)
86 86

字符串

Python 的字符串是不可变的，不可直接修改原字符串。但可以新建字符串，达到“看起来修改”的效果（原字符串没有变化）。 Python 不支持单字符类型，单字符也是作为一个字符串使用的。

Python3 直接支持 Unicode，可以表示世界上任何书面语言的字符。Python3 的字符 默认是 16 位 Unicode 编码（可以表示2的16次方个字符），而ASCII 码（8位）是 Unicode 编码的子集。 使用内置函数 ord()可以把一个字符转换成对应的 Unicode 码； 使用内置函数 chr()可以把十进制数字转换成对应的字符。

>>> a ="asd"
>>>> a[1]="y"
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    a[1]="y"
TypeError: 'str' object does not support item assignment
#无法直接修改字符串

>>> ord("8")
56
>>> ord("9785")
Traceback (most recent call last):
  File "<pyshell#78>", line 1, in <module>
    ord("9785")
TypeError: ord() expected a character, but string of length 4 found
>>> ord("yi")
Traceback (most recent call last):
  File "<pyshell#79>", line 1, in <module>
    ord("yi")
TypeError: ord() expected a character, but string of length 2 found
>>> ord("博")
21338
#ord仅支持一个字符
>>> ch
Traceback (most recent call last):
  File "<pyshell#81>", line 1, in <module>
    ch
NameError: name 'ch' is not defined
>>> chr(100)
'd'

引号创建字符串

可以通过单引号或双引号创建字符串。例如：a=’yi’; b=”yi”
使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。

>>> a="I'm a cat"
>>> a
"I'm a cat"
>>> b='my dog is "cat"'
>>> b
'my dog is "cat"'

连续三个单引号或三个双引号，可以创建多行字符串。

aa='''nihao  zuijinhaoma
yaojiayouo
xixixi'''
>>> aa
'nihao  zuijinhaoma\nyaojiayouo\nxixixi'

空字符串和 len()函数

Python 允许空字符串的存在，不包含任何字符且长度为 0.(也不包含空格)。
len()用于计算字符串含有多少字符

>>> a=''
>>> len(a)
0
>>> b='adafvss e'
>>> len(b)
9

转义字符

我们可以使用“\+特殊字符”，实现某些难以用字符表示的效果。比如：换行等。常见的 转义字符有这些：

>>> a='I\'m a cat'
>>> a
"I'm a cat"
>>> a='q\nw\ne\n'
>>> a
'q\nw\ne\n'
>>> print(a)
q
w
e

字符串拼接与复制

可以使用+将多个字符串拼接起来。例如：’aa’+ ’bb’ ==>’aabb’。
(1) 如果+两边都是字符串，则拼接。
(2) 如果+两边都是数字，则加法运算。
(3) 如果+两边类型不同，则抛出异常。

可以将多个字面字符串直接放到一起实现拼接。字符串中间可以用空格隔开，也可以不加空格。

拼接出来的是一个新对象，原对象不发生变化

字符串的复制用*实现

>>> a='tian'+'kong'
>>> a
'tiankong'
>>> b='bai' 'yun'
>>> b
'baiyun'
>>> c='ni''hao'
>>> c
'nihao'
>>> a="xi"*3
>>> a
'xixixi'

print的不换行打印

print默认以换行符为结尾，打印时自动换行，如果想要不换行打印可以通过<<<print(“str”,end=‘任意字符串’)来实现，实例如下

print('a')
print('b')
print('c')
#结果：
a
b
c

print('a',end='\t')
print('b',end='\t')
print('c')
#结果：       
a	b	c

print('a',end='%')
print('b',end='%')
print('c')
#结果：
a%b%c

input（“提示语”）从控制台读取字符串

一点小提示：双引号和单引号用在字符串上是没有任何区别的，因此这里也可以是input(‘提示语’)

>>> start=input('请输入起始时间：')
请输入起始时间：85
>>> start
'85'

字符串的索引与提取[]

字符串本质就是字符序列，每一个字符都有对应的索引号（偏移量），在[]里面指定偏移量， 可以提取该位置的单个字符。 正向索引： 最左侧第一个字符，索引号为 0，第二个索引号为 1，以此类推。直到 len(str)-1 为止。
反向索引： 最右侧第一个字符，索引号为-1，倒数第二个索引号为-2，以此类推，直到-len(str) 为止。

>>> aa="1234567890"
>>> aa[0]
'1'
>>> aa[1]
'2'
>>> aa[9]
'0'
>>> aa[-1]
'0'
>>> aa[-2]
'9'
>>> aa[10]
Traceback (most recent call last):
  File "<pyshell#50>", line 1, in <module>
    aa[10]
IndexError: string index out of range

replace（）新建对象实现字符串“替换”

前面提到过字符串不可变的，如果想要“改变某”个字符串的内容，可以使用str.replace(“某字符"，”新字符（个数不限）”)或者str.replace(str[i]，”新字符(个数不限)“)来创建一个新的字符串对象（有新的id），原字符串的id，type，value并没有改变。

>>> a='1234567890'
>>> a[2]="yi"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
#不可以直接改变某字符
>>> a.replace("6","yi")
'12345yi7890'
>>> print(a)
1234567890
>>> id(a)
1491648010736
#使用replace后原字符串属性（id，type,value）不变
>>> b=a.replace("6",'yi')
>>> print(b)
12345yi7890
>>> id(b)
1491648129392
>>> print(a)
1234567890
>>> id(a)
1491648010736
#使用replace后原字符串属性（id，type,value）不变,而是创建了一个新的对象，有新的属性、
 c= a.replace(a[3],"djshaid")
>>> c
'123djshaid567890'
#replace的另一种格式   
>>> a='97859785'
>>> a.replace('5','yi')
'978yi978yi'  
#替换时会替换所有的’5‘  

字符串切片 slice

切片就是用来截取子字符串的。格式：[起始索引号start：终止索引号end：步长step]
注意当start和end有值时，取值是这样的：[start，end），即取值包括start不包括end，若start无值则包含最开头，若end无值则包含最结尾。
当三个量都是正数时：

当三个量都是负数时：

切片操作时，起始偏移量(索引号)和终止偏移量（索引号）不在[0,字符串长度-1]这个范围，也不会报错。起始 偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成-1。

>>> a="0123456789"
>>> a[2:85]
'23456789'
#并不报错

split()分割和 join()合并

split()可以基于指定分隔符将字符串分隔成多个子字符串存储到列表中。如果不指定分隔符，则默认使用空白字符(换行符/空格/制表符)。

>>> b="I am a cute cat"
>>> b.split()
['I', 'am', 'a', 'cute', 'cat']
>>> b.split("a")
['I ', 'm ', ' cute c', 't']

ioin（）常与列表一起使用，之前讲过用字符串的拼接，用“+”或者空格或者直接将两个字符串放在一起都可以实现拼接。当有性能要求的时候，推荐使用ioin（），不要用“+“的方式，因为每使用一次”+“就会创建一个新的字符串对象，而join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝， 仅新建一次对象。

>>> aaa=["I","am","a","cat"]
>>> "".join(aaa)
'Iamacat'
>>> "@".join(aaa)
'I@am@a@cat'

join与”+“连接字符串的效率对比

import time

time01=time.time()#起始时间
a=""#定义一个空字符串
for i in range(1000000):
    a+="cat"
time02=time.time()#终止时间
print("用时："+str(time02-time01))

time03=time.time()#起始时间
li=[]#定义一个列表
for i in range(1000000):
    li.append("cat")
a="".join(li)
time04=time.time()#终止时间
print("join用时："+str(time04-time03))

运行结果：

join()连接字符串更加高效！

字符串驻留机制

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。
通俗来说就是，当字符串本身仅包含下划线（_）、字母和数字时（与标识符命名规则稍有不同，数字也可以作为开头）python会启用标识符驻留机制，就是当再次出现这个字符串时，不新建字符串对象，而是直接引用已有的对象id。

>>> a="12fwe"
>>> b="12fwe"
>>> a is b
True
#没有新建对象，都引用的是同一个对象
>>> c="sdm_ns1%@"
>>> d="sdm_ns1%@"
>>> c is d
False
#新建了对象，虽然值是相同的，但是有不同的id，是两个对象

字符串的比较和同一性

和数字一样：
使用==和!=来比较字符串中的字符（value）是否相同
用is和is not 来比较两个id是否相同

成员操作符

in /not in 关键字，判断某个字符(子字符串)是否存在于字符串中。

>>> a="sacfwhvn243nsdo0"
>>> "b"in a
False
>>> "3"in a
True
>>> "yi"not in a
True

字符串的一些查找、记数和常用函数

>>> a='''CSDN是全球知名中文IT技术交流平台,创建于1999年,包含原创博客、精品问答、职业培训、技术论坛、资源下载等产品服务,提供原创、优质、完整内容的专业IT技术开发社区'''
>>> len(a)	#获取字符串长度
84
>>> a.startswith("CSDN")	#判断字符串是否以CSDN为开头
True
>>> a.endswith("社区")	#判断是否以社区为结尾
True
>>> a.find("、")	#查找第一个出现、的索引号
35
>>> a.rfind("、")	#查找最后一次出现、的索引号
68
>>> a.count("技术")	#计算“技术”出现的次数
3
>>> a.isalnum()	#判断a中是否全是由字母或数字组成的
False
>>> "fhfsdgw".isalnum()	#判断 "fhfsdgw"中是否全是由字母或数字组成的
True

其他常用函数

1. isalnum() 是否为字母或数字
2. isalpha() 检测字符串是否只由字母组成(含汉字)。
3. isdigit() 检测字符串是否只由数字组成。
4. isspace() 检测是否为空白符
5. isupper() 是否为大写字母
6. islower() 是否为小写字母

strip（）去除字符串首尾信息

strip（）去除字符串首尾信息，只要头尾包含有指定字符序列中的字符就删除。或者用lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息。但是无法去除字符串中间的字符，“ tiantian”则t已经是属于字符串中间的字符了。

>>> 'www.example.com'.strip('cmowz.') #只要首尾包含c、m、o、w、.、z就删除
'example'
>>> '  tiantian'.strip("tn")
'  tiantia'
>>> '  tiantian'.strip("tna")
'  tianti'
>>> '  tian   tian   '.strip() #默认删除空格
'tian   tian'
>>> '  tian   tian   '.rstrip() #去除右侧
'  tian   tian'
>>> '  tian   tian   '.lstrip()  #去除左侧
'tian   tian   '

大小写转化

>>> a="aaa BBB ccc"
>>> a.capitalize() #创建新的字符串对象，只有首字母大写，其他全小写
'Aaa bbb ccc'
>>> a.title() #创建新的字符串对象，每个单词的首字母都大写，其他全小写
'Aaa Bbb Ccc'
>>> a.upper() #创建新的字符串对象，所有字符都大写
'AAA BBB CCC'
>>> a.lower() #创建新的字符串对象，所有字符都小写
'aaa bbb ccc'
>>> a.swapcase() #创建新的字符串对象，所有字符大小写都改变
'AAA bbb CCC'

center()、ljust()、rjust()、format（）格式排版

居中center()、左对齐ljust()、右对齐rjust()

format()中^、<、>分别是居中、左对齐、右对齐，后面带宽度 :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充。

>>> a="cat"
>>> a.center(10)	#把字符串填充成10个字符，使得cat居中排列，默认用空格填充。
'   cat    '
>>> a.center(10,"@")	#把字符串填充成10个字符，使得cat居中排列，用@填充。
'@@@cat@@@@'
>>> a.ljust(8,"@")	#把字符串填充成8个字符，使得cat靠左排列，用@填充。
'cat@@@@@'
>>> a.rjust(8,"@")	#把字符串填充成8个字符，使得cat靠右排列，用@填充。
'@@@@@cat'
>>> "{:@<10}".format("cat")
'cat@@@@@@@'
>>> "{0}喜欢吃{1:#>5}".format("猫","鱼")
'猫喜欢吃####鱼'
>>> 

format（）相关用法

对字符串格式化

str.format()通过 {} 和 :来对字符串格式化，该函数参不限数。

>>> a="名字是:{0},年龄是：{1},{0}喜欢小动物"
>>> a.format("YUAN",1)
'名字是:YUAN,年龄是：1,YUAN喜欢小动物'
>>> b="名字是:{name},年龄是:{age}"
>>>> b.format(age=1,name="YUAN")
'名字是:YUAN,年龄是:1'

填充和对齐

format（）的填充和对齐：^、<、>分别是居中、左对齐、右对齐，后面带宽度 :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> "{:@<10}".format("cat")
'cat@@@@@@@'
>>> "{0}喜欢吃{1:#>5}".format("猫","鱼")
'猫喜欢吃####鱼'

数字格式化

浮点数通过 f，整数通过 d 进行需要的格式化。

>>> a="{0}有{1:.3f}米高"
>>> a.format("楼",379.584916)
'楼有379.585米高'
>>> "{:.1f}".format(97.85)
'97.8'
>>> "{:.1f}".format(97.86)
'97.9' #注意，并不是直接截断，而是有进位的
>>> "{:.2f}".format(97.857789)
'97.86'

可变字符串

之前说过python中字符串是不可以改变的，只能通过建立新的字符串对象来实现“改变”，原字符串不变。
如果需要原地直接修改字符串，可以使用io.StringIO对象或array模块来创建一个可变字符串对象。对可变字符串进行修改的时候就不再创建新对象了

>>> a="qwe,,asd"
>>> b=io.StringIO(a)
>>> b
<_io.StringIO object at 0x00000129BF6985E8>
>>> type(b)
<class '_io.StringIO'>
>>> id(b)
1278816650728
>>> print(b)   
<_io.StringIO object at 0x00000129BF6985E8>
#print不能打印b的值了  

>>> b.getvalue()
'qwe,,asd'
#用此法打印b的值
>>> b.seek(5)
5
#seek（5）意思是让指针指向想要修改的索引位置，索引号为5
>>> b.write("A")
1
#将指针所指位置的字符修改为A
>>> b.getvalue()
'qwe,,Asd'
>>> id(b)
1278816650728
#修改的时候不创建新的对象而是直接修改原对象