Python数据类型之元组,python中字符串操作

python中,对字符串的操作是最普遍的,python对字符串操作有协调非凡的处理格局。

目录

字符串的截取

python中对此字符串的目录是比较尤其的,来感受一下:

s = '123456789'
#截取中间的两个字符
s[1:3]
#输出为:'23'
#从某个位置到结尾
s[4:]
#输出为:'56789'
#字符串的顺序不仅仅可以顺着数,也可以逆着数
s[-8:7]
#输出为'234567',这个在截取文件名称时是比较有用的,比如用s[-3:],可以得到最后三位的字符串。
  • 1 元组概念
    • 1.1 元祖的性情
    • 1.2 元组的定义
    • 1.3 元组的造访
    • 1.4 元组的询问
  • 2 命名元组
  • 3 字符串
    • 3.1 字符串的基本操作
      • 3.1.1 字符串的走访
      • 3.1.2 字符串的拼凑
    • 3.2 字符串分割
    • 3.3 字符串大小写
    • 3.4 字符串排版
    • 3.5 字符串修改
    • 3.6 字符串查找
    • 3.7 字符串判断
    • 3.8 字符串格式化
      • 3.8.1 C语言格式化
      • 3.8.2 format格式化
      • 3.8.3 对齐
      • 3.8.9 小数点与进制
  • 4 切片
    • 4.1 切片赋值

字符串的探寻

搜寻当前字符串中,是不是带有其余的字符串。

咱俩得以运用
index,大概find来实行搜索,find和index的差距是,若是应用的是index的话,字符串查找中,借使找不到相应的字符串,会抛出1个ValueError的不得了。

s = '123456789'
s.index('23')
#输出:1
s.find('23')
#输出:1
s.index('s')
#输出
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

s.find('s')
#输出 -1

1 元组概念

        元组(类型为
tuple)和列表拾叁分相似,然而元组和字符串一样是不可变的。

分割字符串

接连有为数不少特殊字符,能够用来分割字符串。数据库中时时把一组相片放在一个字段中,比如
img1.jpg@@@img2.jpg@@@img3.jpg

亟需把不定长的肖像都取出来,就须要同特殊字符把字符串分开,得到不一样的照片。

分开的指令为split

s = 'img1.jpg@@@img2.jpg@@@img3.jpg'
s.split('@@@')
#结果为一个数值:['img1.jpg', 'img2.jpg', 'img3.jpg']

1.1 元祖的风味

  • 元组能够储存一文山会海的值,使用小括号来定义,是一个有序的成分的成团。
  • 元组内的要素是不可变
  • 当元组内嵌套列表那种引用类型时,元组的不可变表示的是履行那一个列表的内部存款和储蓄器地址不会变,当直接操作元组嵌套的列表时,是足以开始展览改动的

字符串格式化

Python 支持格式化字符串的输出
。尽管这样大概会用到万分复杂的表明式,但最焦点的用法是将3个值插入到2个有字符串格式符
%s 的字符串中。

在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。

#!/usr/bin/python
print "My name is %s and weight is %d kg!" % ('Zara', 21) 
#以上实例输出结果: My name is Zara and weight is 21 kg!

python字符串格式化符号:

符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写)
%f 格式化浮点数字,可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e,用科学计数法格式化浮点数
%g 根据值的大小决定使用%f活%e
%G 作用同%g,根据值的大小决定使用%f活%e
%p 用十六进制数格式化变量的地址

1.2 元组的定义

格式

tuple() -> 工厂函数,用于创建并返回一个空元组tuple -> 使用可迭代对象的元素,来初始化一个元组

例子

In [18]: t=    # 会认为()只是优先级In [19]: type Out[19]: intIn [20]: t=In [21]: typeOut[21]: tuple     # tuple表示元组类型 #引用其他元组In [22]: a=In [23]: t=('123',a)In [24]: tOut[24]: ('123',  #通过索引只引用某一个值In [27]: t=('123',a[1])In [28]: tOut[28]: ('123', 2)# tuple接受一个可迭代对象转换为元组In [35]: tuple(range                                                                                    Out[35]: 

字符串Template化

在python中Template能够将字符串的格式固定下来,重复利用。

Template属于string中的贰个类,要使用她的话能够用以下情势调用:

from string import Template

大家选拔以下代码:

>>> s = Template('There  ${moneyType} is  ${money}')
>>> print s.substitute(moneyType = 'Dollar',money=12)

运作结果突显“There Dollar is 12”

这么我们就足以替换当中的数码了。

越来越多入门教程能够参照:[http://www.bugingcode.com/python_start/]
(http://www.bugingcode.com/python_start/)

1.3 元组的拜访

        元组和列表在内部存款和储蓄器中的格式是千篇一律的,都以线性顺序结构,所以大家能够像列表一样,使用索引访问元组的因素,其6月组帮助正索引负索引,同样不协理索引超界,会提醒IndexError

In [49]: b =                                                                                                 In [50]: b[1]                                                                                                       Out[50]: 2In [51]: b[-1]                                                                                                        Out[51]: 3

        须要注意的是在对元组进行改动的时候,元组自己是力不从心进展改动的,但当元组内嵌套的是列表这种引用类型时,元组的不足修改指的是元组中蕴藏的嵌套列表的内部存款和储蓄器地址不可修改,但你可以对这快内部存款和储蓄器地址里的多少开始展览改动,因为那是列表的表征。

In [44]: a                                                                                                           Out[44]: (1, 2, [1, 2], 1, 2, [1, 2], 1, 2, [1, 2])In [45]: a[2][0] = 100         # 可以对嵌套的列表进行赋值操作                                                                                       In [46]: a                                                                                                           Out[46]: (1, 2, [100, 2], 1, 2, [100, 2], 1, 2, [100, 2])In [47]: a[3] = 100      # 修改指向是不被允许的                                                                                             ---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-47-2b62bbdeb061> in <module>----> 1 a[3] = 100TypeError: 'tuple' object does not support item assignment

1.4 元组的查询

        大家透过动用元组的index方法和count来获取和总括元组中的成分。

T.index(value, [start, [stop]]) --> integer -- 返回元组内匹配value的第一个元素的index,T.count --> integer -- 统计value在元组中出现的次数,不存在时,则返回0

小心:t.index和t.count因为要遍历列表全体,时间复杂度都以O,随着列表的要素增添,而效用降低

In [4]: a=('1','2','3')In [7]: a.count("4")     # 不存在,返回0Out[7]: 0In [8]: a.count("1")Out[8]: 1 # a.index 用来返回value在元组中的索引,如果value不在元组中,则会报错。如果有多个,默认返回第一个(可以指定从哪个索引开始查找到某个索引结束,指定范围区间)In [4]: a=('1','2','3')In [9]: a.index('1')Out[9]: 0In [10]: a.index('3')Out[10]: 2In [57]: a = ('1','2','3')                                                                                            In [58]: a.index('4')     # 不存在,就会报错                                                                                             ---------------------------------------------------------------------------ValueError                                Traceback (most recent call last)<ipython-input-58-dca64b8e9162> in <module>----> 1 a.index('4')ValueError: tuple.index: x not in tuple>>> t1('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')>>> t1.index('a',5,7)    # 在指定的区间内查找6

2 命名元组

        命名元组是元组的子类,所以它也是无能为力开始展览修改的,它的特点是足以针元组的对字段进行命名。
格式

namedtuple(typename, field_names, *, verbose=False, rename=False, module=None) --> 返回一个拥有命名字段的 新的元组的子类

常用参数含义

  • typename: 一般和命名元组的名称相同。
  • field_names:
    能够是空白字符或逗号分隔的字段的字符串,能够是字段的列表

    namedtuple 存放在 collections 包中,所以要求先举行导入

>>> from collections import namedtuple    >>> Point = namedtuple('Point', ['x', 'y'])  # 创建一个名为Point的命名元组类,其中含有两个字段>>> p = Point             # 创建一个实例,11会传递给x,22会传递给y。>>> p[0] + p[1]                     # 可以通过索引访问33>>> p.x + p.y                       # 也可以通过字段名访问33>>> p.x = 33            # 没有办法进行修改的                                                                                         ---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-63-dac7085722b7> in <module>----> 1 p.x = 33AttributeError: can't set attribute

3 字符串

        字符串是Python中比较首要的数据类型,是以单引号’或双引号”括起来的私下文本,比如’abc’,”xyz”等等。请留意,”或””本人只是一种表示方法,不是字符串的一部分,由此,字符串’abc’唯有a,b,c那3个字符。要是’自己也是四个字符,那就足以用””括起来,比如”I’m
OK”包罗的字符是I,’,m,空格,O,K那5个字符。有三种办法定义字符串:单引号双引号三引号,须要留意的是字符串是不可变对象,并且从Python3起,字符串正是Unicode类型。
概念情势

str1='this is string'str2="this is string"str3='''this is string'''   # 也可以是三个双引号,三个引号可以多行注释但是不能单双混合,三重引号除了能定义字符串以外,还可以表示注释。str4='hello\n world' # 在print打印字符串的时候\n会被当作换行符进行打印str5=r'hello\n world' # 前面使用了r对字符串进行整体转义,所见即所得str6='hellow\\nworld' # 当然使用\也可以对特殊符号进行脱义str7=R'hello\nworld' # 和r相同

3.1 字符串的基本操作

        Python的字符串是八个一如既往种类,所以她能够和列表一样选择下标来访问成分,不过出于它是不足变类型,所以不恐怕对字符串中的某些字符实行修改,下边介绍下字符串的基本操作。

Python中平素不字符的概念,严谨来讲,说字符是不可信的,字符串是由多个个字符串组成的,固然听起来很别扭,但着实就是那样

  • -!。

3.1.1 字符串的走访

        字符串和列表是一般,都以逐一的线性结构,所以它能够被索引,也能够被遍历。字符串的目录类似数组的下标:

In [3]: a='1234567'In [4]: a[0] --> # 下标从0开始,0表示第一个数Out[4]: '1'In [5]: a[3] --> # 表示第四个数Out[5]: '4'In [3]: a[1] = 100   # 字符串没有办法被修改                                                                                                  ---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-3-8554a2b011c3> in <module>----> 1 a[1] = 100TypeError: 'str' object does not support item assignmentIn [4]:In [6]: for i in a:       # 可以被for循环进行迭代   ...:     print    ...:                                                                                                             1234567In [7]: list        # 可以被当作一个可迭代对象传给list,转换为一个列表                                                                                               Out[7]: ['1', '2', '3', '4', '5', '6', '7']

3.1.2 字符串的拼凑

        当大家供给把多个字符串连接在联合,那么就需求对字符串进行拼接,python提供了join方法,+号,以及*号,使我们有益的成就需要。

S.join -> str  --> 使用s对可迭代对象进行拼接,返回拼接后的字符串。
  • join: S能够为私下字符,包含空。可迭代对象中的元素必须是字符串类型
  • +: 把八个字符串直接开始展览三番五次,重临一个新的字符串
  • *: 把字符串重复复制N次,再次来到多少个新的字符串

In [11]: str1                                                                                                         Out[11]: ['h', 'e', 'l', 'l', 'o']In [12]: ''.join                                                                                                Out[12]: 'hello'In [13]: str2 = ''.join                                                                                          In [14]: str2                                                                                                         Out[14]: 'hello'In [17]: '-'.join      # 使用-进行拼接                                                                                           Out[17]: 'h-e-l-l-o'In [15]: str2 * 2                                                                                                     Out[15]: 'hellohello'In [16]: str2 + str2                                                                                                  Out[16]: 'hellohello'In [18]: lst = ['1',['1','2'],'3']                                                                                    In [19]: ''.join                   # lst的第1个元素是列表,不是字符串,没办法进行拼接,会报错                                                                              ---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-19-58ac5d2512ec> in <module>----> 1 ''.joinTypeError: sequence item 1: expected str instance, list foundIn [20]

3.2 字符串分割

        字符串中有关于字符分割功用的要害有两类,split类和partition类,他们分别适用于不用的境况。但用的可比多的是split

  • split类:将字符串根据划分符分隔成多少字符串,并赶回列表
  • partition类:将字符串遵照划分符分割成2段,再次来到那2段和分隔符组成的长富组

S.split(sep=None, maxsplit=-1) -> list of strings -->  从左至右对字符串s进行切割,分割符为sep,默认为尽可能多的空字符,maxsplit表示分割几次,默认为-1,全部进行分割,返回一个切割后的列表。S.partition -> (head, sep, tail)  --> 从左至右对字符串s进行切割,必须指定一个切割符sep,返回一个三元组,其中中间的元素为分割符,第一个和最后一个元素为按照分隔符分开后的前后两个元素。当分隔符无法对字符串进行分割时,返回的是 字符串,空,空,组成的三元组。

例子

In [20]: s = "hello world I am Daxin"                                                                                 In [21]: s.split()       # 默认使用空格进行分割                                                                                              Out[21]: ['hello', 'world', 'I', 'am', 'Daxin']In [23]: s.split('o')         # 使用字母o进行分割                                                                                        Out[23]: ['hell', ' w', 'rld I am Daxin']   In [24]: s.split('o',1)                   # 使用字母o进行分割,并且只分割1次                                                                          Out[24]: ['hell', ' world I am Daxin']In [25]: s.split(sep='o',maxsplit=1)         # 也可以指定关键字进行传参                                                                         Out[25]: ['hell', ' world I am Daxin']In [26]: s.partition(' ')                  # 使用' '进行分割,返回三元组                                                                           Out[26]: ('hello', ' ', 'world I am Daxin')In [27]: s.partition('o')                                                                                             Out[27]: ('hell', 'o', ' world I am Daxin')# 当分割符不存在时In [29]: s = "helloworldIamDaxin"                                                                                     In [30]: s.split()     # 一定会返回一个列表,如果没有被切分,那么会发那会一个元素的列表                                                                                                   Out[30]: ['helloworldIamDaxin']In [31]: s.partition(' ')         # 一定会返回一个三元组,如果没有被切分,那么会从字符串的最右边切开,形成一个三元组,和 一个空字符组成的列表                               Out[31]: ('helloworldIamDaxin', '', '')In [32]: s.partition('12')                                                                                           Out[32]: ('helloworldIamDaxin', '', '')

当然split类还蕴藏了别的三个主意:

S.rsplit(sep=None, maxsplit=-1) -> list of strings --> 功能与split相同,只不过从右开始S.splitlines([keepends]) -> list of strings  --> 按照行来切分,keepends表示是否保留换行符,True表示保留,False表示不保留,默认为FalseIn [33]: s = 'I am Super Man'                                                                                         In [34]: s.rsplit('u')      # 不指定分割次数,一般和split是一样的效果                                                                                             Out[34]: ['I am S', 'per Man']In [35]: s.rsplit('a')                                                                                                Out[35]: ['I ', 'm Super M', 'n']In [37]: s.rsplit(sep='a',maxsplit=1)     #  当指分割1次时,会从右边开始切开                                                                             Out[37]: ['I am Super M', 'n']In [40]: s = 'hello\nworld\rI\nam\r\ndaxin'                                                                           In [41]: s.splitlines()                                                                                               Out[41]: ['hello', 'world', 'I', 'am', 'daxin']In [42]: s.splitlines             # 默认不保留分隔符,True表示保留分隔符                                                                             Out[42]: ['hello\n', 'world\r', 'I\n', 'am\r\n', 'daxin']   

partition类和split相似,还有个rpartition函数,也是从右初阶截取,需求注意的是,当分隔符不也许对字符切分时,再次回到的是字符串,组成的长富组。

3.3 字符串大小写

  • upper:将字符串转换为大写字母
  • lower:将字符串转换为
  • swapcase: 大小写对调
  • capitalize:转换成首字母大写的单词格式
  • title: 转换来每一种单词首字母大写的标题形式

In [51]: s = 'hElLo wORld i aM dAxin'                                                                                 In [52]: s.upper()                                                                                                    Out[52]: 'HELLO WORLD I AM DAXIN'In [53]: s.lower()                                                                                                    Out[53]: 'hello world i am daxin'In [54]: s.swapcase()                                                                                                 Out[54]: 'HeLlO WorLD I Am DaXIN'In [55]: s.capitalize()                                                                                               Out[55]: 'Hello world i am daxin'In [56]: s.title()                                                                                                    Out[56]: 'Hello World I Am Daxin'    

3.4 字符串排版

  • center(width [,fillchar]):
    居中体现,参数width表示完全小幅,fillchar表示填充字符,暗许填充字符为空
  • zfill:居右展现,参数width表示完全大幅度,使用0实行填空
  • ljust(width [, fillchar]):左对齐,width代表完全涨幅,fillchar表示填充字符
  • rjust(width [, fillchar]):右对齐,width表示完全大幅度,fillchar表示填充字符

In [61]: a                                                                                                            Out[61]: 'abc'In [62]: a.ljust(20,'-')                                                                                              Out[62]: 'abc-----------------'In [63]: a.rjust(20,'-')                                                                                              Out[63]: '-----------------abc'In [64]: a.center(10,'-')                                                                                             Out[64]: '---abc----' 

3.5 字符串修改

        what?你后边说字符串是不可变的吧,为啥那里又说字符串的改动?你在逗小编吗。呵呵哒。

S.replace(old, new[, count]) -> str  --> 对字符串S进行查找,将指定的old字符串转换为new字符串,count表示替换的次数,默认表示重复替换所有S.strip -> str --> 将字符串s进行处理,从字符串的两边删除掉匹配chars的字符串,chars可以是多个单字符,默认是所有空白字符(\n,\r\n,\r,\t等等都包含)

留意:replace的交替是生成一个新的字符串,而不是修改原字符串,那也是字符串修改的规律

In [3]: s                                                                                                             Out[3]: ' \n\t Hello World \n\r'In [4]: s.strip()     # '不指定chars,默认是任意多个空白字符                                                                                                Out[4]: 'Hello World'In [5]: s.strip(' \n\tHd')       # 如果指定了chars,那么就挨个使用char进行匹配去除                                                                                     Out[5]: 'ello World \n\r'In [6]: s.strip(' \n\rHd')                                                                                            Out[6]: '\t Hello Worl'In [7]: s.replace('World','Daxin')                                                                                    Out[7]: ' \n\t Hello Daxin \n\r' In [8]: s.replace('o','O')         # 默认从头到尾进行替换                                                                                     Out[8]: ' \n\t HellO WOrld \n\r'In [9]: s.replace('o','O',1)         # 指定替换1次                                                             Out[9]: ' \n\t HellO World \n\r'  

3.6 字符串查找

        我们有不少的时候要看清关键字是或不是留存一个字符串中,那么大家就必要在字符串中遍历探寻,是还是不是有协作的字符串。python提供了find,rfind,index,count等函数用于完毕需要。

S.find(sub[, start[, end]]) -> int  --> 从左开始在字符串S中查找sub字符串,其中起始位start,结束位end,默认为整个字符串,返回找到的字符串的开头索引位,如果没有找到,那么会返回-1S.rfind(sub[, start[, end]]) -> int  --> 从右开始在字符串S中查找sub字符串,其中起始位start,结束位end,默认为整个字符串,返回找到的字符串的开头索引位,如果没有找到,那么会返回-1S.index(sub[, start[, end]]) -> int  --> 从左开始在字符串S中查找sub字符串,其中起始位start,结束位end,默认为整个字符串,返回找到的字符串的开头索引位,如果没有找到,那么会报异常S.count(sub[, start[, end]]) -> int  --> 从左开始在字符串S中统计sub字符串出现的次数,其实起始位置为Start,结束位为end,默认为整个字符串。没有找到返回0

index和count方法由于是遍历查找,所以时间复杂度都是O,会趁机字符串连串的数据规模的叠加,而效用下落,假若没要在字符串中展开搜寻,照旧建议利用find函数。

In [15]: s = 'abc abc abc'                                                                                            In [16]: s.find('a')                                                                                                  Out[16]: 0In [17]: s.find('a',1,-1)      # 指定区间, 注意这里-1表示最后1位,但是不包含-1,类似于[1,-1)                                                                                      Out[17]: 4In [18]: s.find('a',-1,-15)                                                                                           Out[18]: -1In [19]: s.rfind('a')                                                                                                 Out[19]: 8In [20]: s.rfind('a',2,-1)                                                                                            Out[20]: 8In [21]: s.rfind('c',2,-1)                                                                                            Out[21]: 6In [22]: s.rfind('c',2,-100)    # end点超出范围,会无法找到,start,end表示起始和终止,最好不要使用负数表示区间                                                                                     Out[22]: -1In [23]: s.index('a')                                                                                                 Out[23]: 0In [24]: s.index('a',2)     # 从索引为2,开始向右查找                                                                                          Out[24]: 4In [25]: s.index('e')       # 没找到,直接报异常                                                                                     ---------------------------------------------------------------------------ValueError                                Traceback (most recent call last)<ipython-input-25-90b1c28da6f0> in <module>----> 1 s.index('e')ValueError: substring not foundIn [26]:    

3.7 字符串判断

        Python的字符串对象提供了八个函数,用于对字符串的开场位和末段位来展开匹配,它们是startswithendswith

S.startswith(prefix[, start[, end]]) -> bool  --> 判断字符串prefix是否是字符串S的起始字符串,start表示起始位置,end表示末尾,默认为0,即整个字符串S,返回bool类型。S.endswith(suffix[, start[, end]]) -> bool  --> 判断字符串prefix是否是字符串S的结束字符串,start表示起始位置,end表示末尾,默认为0,即整个字符串S,返回bool类型。

In [32]: s                                                                                                            Out[32]: 'abc abc abc'In [33]: s.startswith('bc',1,-1)    # 从s的[1,-1)开始判断'bc'是否是开头                                                                                     Out[33]: TrueIn [34]: s.endswith('bc',2,-1)      # 从s的[2,-1)开始匹配'bc'是否是结尾                                                                                 Out[34]: False                     # 这里-1不包含,所以返回FalseIn [35]: s.endswith('bc',3,7)                                                                                         Out[35]: TrueIn [36]: s.startswith('abc')                                                                                          Out[36]: TrueIn [37]: s.endswith('bc')                                                                                             Out[37]: True 

        除了判断早先和终极,Python的字符串还提供了一部分函数,用来判定字符串内的成分类型,比如判断字符串是还是不是是纯数字组合?是否是纯字母组成等,那么些函数的重回值统一都为bool型,能够看做if语句的条件表达式

str.isalpha() # 是否是字母吗str.isalnum() # 是数字和字母的组合吗str.isdigit() # 是否全是十进制数字,intstr.isdecimal() # 判断是否是数字类型,包含float,但不包含负数str.islower() # 判断字符串是否全是小写字母str.isupper() # 判断字符串是否全是大写字母str.isspace() # 是否是空白字符str.isnumberic() # 判断是否是正整数str.isidentifier() # 是否是一个合规的变量标识符

3.8 字符串格式化

        字符串格式化是大家需求注重控制的事物,在初期的Python中运用的是C语言风格的字符串替换,使用起来比较难看,不符合python的品格(当然是笔者的估摸,哈哈)。后来Python推荐使用内置的format函数来对字符串实行格式化。
        字符串格式化是一种拼接字符串输出样式的手腕,更灵敏方便,在此以前我们利用join和+来对字符串举行拼接。

  • join:只可以动用分隔符,且供给被拼接的是可迭代对象且元素必须是来字符串类型
  • +: 使用起来相比便宜,不过非字符串须求先转移为字符串才方可拓展拼接。

3.8.1 C语言格式化

        在Python 2.5版本此前,只可以选择printf
style风格的print输出,那种作风来自于C语言的printf函数,它有如下格式需求。(不提议利用,明白即可,Pythoner照旧驾驭format就好。)

  1. 占位符:使用%和格式字符串组成,例如%s,%d等。使用s时,内部其实会调用str()函数进行转换
  2. 占位符中仍是可以插入修饰字符,例如%03d意味着打印三个地方,不够的话,前边补0
  3. format % value 格式字符串和被格式字符串之间使用%分割
  4. values只可以是贰个对象,或是三个与格式字符串占位符数量相等的元组,或一个字典

In [38]: 'I am %03d' % 20        # 表示3为数字,不够的话高位补0                                                                                     Out[38]: 'I am 020'In [39]: 'I like %s' % 'Python'      # 字符串格式化In [50]: 'I am %s' % 20      # 20会被str作用后,传递给字符串                                                                                Out[50]: 'I am 20'Out[39]: 'I like Python'In [41]: '%3.2f%%,0x%x,0X%02X' % (89.7654,10,15)     # 3.2f表示最长3为,小数点后精度为2位,当数字大时整体长度会被撑开,x表示16进制,02X表示两位显示,高位补0                                                                 Out[41]: '89.77%,0xa,0X0F'In [45]: "I am %-5d" % 20                                                                                             Out[45]: 'I am 20   'In [46]: "I am %5d" % 20                                                                                              Out[46]: 'I am    20'  

3.8.2 format格式化

        Python中爱戴使用format函数来对字符串实行格式化。

'{}{XXX}'.format(*args, **kwargs)  -> str  --> 函数的一般格式,{}表示占位符,使用format中的参数进行传递

format分外灵活,上边是骨干选用办法求证:

  1. args是可变的职位参数,是3个元组
  2. kwargs是可变关键字参加会议苏,是一个字典
  3. 花括号表示占位符
  4. {}代表根据顺序匹配位置参数{n}表示取地点参数中索引为n的值
  5. {xxx}
    表示在关键字参数中搜寻名称一致的值,kwargs非得放在位置参数的后面
  6. {{}}表示打字与印刷花括号

In [52]: '{}:{}'.format('10.0.0.13','8888')       # 按照位置格式化,第一个元素给第一个括号,第二个元素给第二个括号                                                                    Out[52]: '10.0.0.13:8888'            # In [53]: '{host}:{}:{}'.format('10.0.0.13','8888',host='daxin')   # 命名格式化,host表示只获取关键字为host的值来填充,其他没有指定关键字的占位符,则按照位置参数进行传递,并格式化显示                                                    Out[53]: 'daxin:10.0.0.13:8888'In [54]: '{hostname} {}:{}'.format('10.0.0.13','8888',hostname='daxin')                                               Out[54]: 'daxin 10.0.0.13:8888'        # 访问元素的方式进行字符串格式化In [55]: '{0[0]}:{0[1]}'.format(['10.0.0.13','8888'])                                                                 Out[55]: '10.0.0.13:8888'In [57]: from collections import namedtuple                                                                           In [58]: Point = namedtuple('_Point',['x','y'])                                                                       In [59]: p = Point                                                                                               In [60]: "{{{0.x},{0.y}}}".format   # 两个花括号重叠表示打印一个花括号,由于p对象含有x和y属性,所以可以在字符串格式化时直接引用                                                                            Out[60]: '{4,5}'

3.8.3 对齐

理所当然字符串还提供了二种的对齐格局,便于大家对输出内容做三个简短的优化。

  • <:左对齐
  • >:右对齐
  • ^: 居中显得

    对齐方式须求在占位符内使用:号展开私分

In [61]: '{:5}'.format('2')     #   打印以讹字符串,这个字符串占5位,默认靠左对齐                                                                                                                Out[61]: '2    'In [62]: '{:>5}'.format('2')     # > 表示向右对齐                                                                                                                  Out[62]: '    2'In [65]: '{:0<5}'.format('2')     # 字符串站5位,向左对齐,其他为使用0填充(可以简写为'{:<05}')                                                                                                          Out[65]: '20000'In [66]: '{:>05}'.format('2')                                                                                                                       Out[66]: '00002'In [71]: '{:*>5}'.format('2')     # > 表示向右对齐,其他位用*填充                                                                                                           Out[71]: '****2'In [67]: '{:0^5}'.format('2')     # 居中显示,使用0进行填充                                                                                                                 Out[67]: '00200'In [69]: '{:*^5}'.format('2')                                                                                                                       Out[69]: '**2**'

当填充符为数字的时候,能够与幅度写在协同,比如
{:0<5} --> {:<05} , {:0^5} --> {:^05}

3.8.9 小数点与进制

虽说用的不多,依旧那里照旧举例说雅培(Abbott)下进制和小数的利用方法

In [74]: "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format                                                                                Out[74]: 'int: 42; hex: 2a; oct: 52; bin: 101010'In [75]: "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format                                                                             Out[75]: 'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'In [76]: octets = [10,0,0,13]                                                                                                                      In [78]: '{:02X}{:02X}{:02X}{:02X}'.format                                                                                                 Out[78]: '0A00000D'In [79]: '{:02X}-{:02X}-{:02X}-{:02X}'.format                                                                                              Out[79]: '0A-00-00-0D'  
  • d: 表示十进制
  • x: 表示十六进制
  • o: 表示八进制
  • b: 表示二进制
  • F: 表示浮点型
  • #: 表示添加进制前缀
  • *[1,2,3]: 表示把列表中的成分结构出来:*[1,2,3] –> 1,2,3

In [82]: "{}".format    # 默认按照字符串打印                                                                                                                        Out[82]: '1.5518455739153598'In [83]: "{:f}".format         # f表示填充位为小数,小数是有精度的                                                                                                              Out[83]: '1.551846'In [84]: "{:02f}".format         # 表示小数的长度为2,但是如果小数的位数超过2,会直接撑开                                                                                                           Out[84]: '1.551846'In [85]: "{:10f}".format       #  表示小数的长度为10,默认是右对齐                                                                                                            Out[85]: '  1.551846'In [86]: "{:<10f}".format          # 左对齐                                                                                                         Out[86]: '1.551846  'In [89]: "{:.2f}".format          # .2f表示 小数点后取两位的浮点型                                                                                                          Out[89]: '1.55'In [90]: "{:3.2f}".format          # 总长3为,小数点后保留2位,若长度超出,则撑开                                                                                                         Out[90]: '1.55'In [91]: "{:2.2f}".format                                                                                                                   Out[91]: '1.55'In [92]: "{:2.2%}".format          # 使用百分比显示                                                                                                         Out[92]: '155.18%'

4 切片

        说到切片那么只能提线性结构,为啥?因为线性结构都足以拓展切片操作,除了切片,线性结构其余的特色还有

  • 可迭代(for val i …)
  • len()能够拿走长度
  • 能够经过下标举行走访
  • 列表、元组、字符串、bytes、bytearray都属于线性结构,所以都足以被切除。
            那什么样是切片?我们说通过索引区间访问线性结构一段数据的章程就称为切片,要求小心的是切片操作会引起内存复制,当对一个过于庞大的线性结构进行切片的时候,请慎重考虑内存使用率的问题。切片的表达格局和骨干特征有:
  1. 格式:sequence[start:stop:[,step=1]] 返回[start, stop,
    step=1)的前闭后开子序列。
  2. 援救负索引。注意方向难点
  3. 当start为0或stop为0时,能够简单。[:]意味着复制原线性结构数据(注意当对象为list时,属于浅copy)
  4. 当先上届,则取到末尾;当先下届,则取到起首。
  5. start一定要在stop的左侧

In [72]: a = 'hello world , My name is daxin'                                                                                                       In [73]: a[2:-1]                                                                                                                                  Out[73]: 'llo world , My name is daxi'In [74]: a[2:]                                                                                                                                      Out[74]: 'llo world , My name is daxin'In [75]: a[-100:]                                                                                                                                   Out[75]: 'hello world , My name is daxin'In [76]: a[10:-100]     # stop位置在start左边,所以没办法取出,如果实在想要倒着取,那么需要使用步长                                                                                                                             Out[76]: '' In [77]: a[10:-100:-1]      # 负步长就可以形成开闭区间,注意是从起始位开始按照step取的(所以会倒序排列返回)                                                                                                                        Out[77]: 'dlrow olleh'

注意:

  • 切开并不会对原数据开始展览修改,会再次回到新的数据
  • 设若不是用变量接受,那么就会被标记为待回收
  • 鉴于是新生成的多少,所以内存地址和原数据内部存储器地址一定不相同葡萄娱乐场,。

4.1 切片赋值

        既然可以进行切开,那么就会引申出来,是还是不是足以开始展览切开赋值,什么是切片赋值?它该怎么表示?上边以列表例进行认证。

  • 切开操作写在等号的左手
  • 被插入的可迭代对象在等号左侧

In [79]: lst = list)                                                                                                                      In [80]: lst                                                                                                                                        Out[80]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]In [81]: lst[1:3]                                                                                                                                  Out[81]: [1, 2]In [82]: lst[1:3] = 1                                                                                                                               ---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-82-7fef59136c7e> in <module>----> 1 lst[1:3] = 1TypeError: can only assign an iterableIn [83]: lst[1:3] = [100,200]                                                                                                                       In [84]: lst                                                                                                                                        Out[84]: [0, 100, 200, 3, 4, 5, 6, 7, 8, 9]  

有心人看上面示例代码会发现多少个难题:

  1. lst[1:3] = 1 意味着切片赋值
  2. 切片赋值,赋的值必须是一个可迭代对象
  3. 切片赋值改变了原数据
  4. 字符串、元组那类不可变的成分,不能使用切片赋值

    当大家选取切片时,它会生出新的内部存款和储蓄器地址来存放生成的新列表,不过只要把切开操作放在赋值操作的左侧时,那么就约等于引用了原列表的[start:stop]的目录,这种操作是不会转移新的内部存款和储蓄器空间的,换句话来讲正是平昔对原列表实行了insert操作.

In [86]: lst                                                                                                                                        Out[86]: [0, 100, 200, 3, 4, 5, 6, 7, 8, 9]In [87]: lst[1:3] = []               # 这种操作相当于list.remove                                                                                                               In [88]: lst                                                                                                                                        Out[88]: [0, 3, 4, 5, 6, 7, 8, 9]In [89]: lst[1:3] = [100,200]        # 这种操作相当于在1:3的位置上进行了list.insert                                                                                                              In [90]: lst                                                                                                                                        Out[90]: [0, 100, 200, 5, 6, 7, 8, 9]   

咱俩清楚list在拓展insert和remove时的日子复杂度都以O,在举行切开赋值时也便于令人难以领悟,所以建议不用使用这种措施。