嵌入式 python之str操作

原创 2013年12月02日 14:40:55

#Python中的字符串处理——2009-12-5

1.字符串的对齐方式:
①:center(int[,str])
>>> string = 'Fishhat'
>>> string.center(55)
'   Fishhat   '
>>> string.center(55,'*')
'************************Fishhat************************'

②:ljust(int[,str])
>>> string.ljust(55)
'Fishhat   '
>>> string.ljust(55,'*')
'Fishhat************************************************'

③:rjust(int[,str])
>>> string.ljust(55)
'   Fishhat'
>>> string.ljust(55,'*')
'************************************************Fishhat'

④:%(int)s
>>> print '% 55s' % string
Fishhat


2.字符串中的转义字符:
\\ 斜杠
\' 单引号
\" 双引号
\a 系统喇叭
\b 退格符
\n 换行符
\t 横向制表符
\v 纵向制表符
\r 回车符
\f 换页符
\o 八进制数代表的字符
#还搞不懂...
\x 十六进制数代表的字符
#还搞不懂...
\000 终止符,忽略\000后的全部字符

3.字符串中的转义符过滤函数:
①:strip()--过滤字符串中所有的转义符
②:lstrip()--过滤字符串中第一个转义符
③:rstrip()--过滤字符串中最后的转义符
后记:在使用的时候返回的结果不是预想中的正确结果.还待查询相关具体资料

4.字符串的连接
①:Python中可以使用'+'、'+='、连接若干个字符串,如果是以下情况,Python则自动连接:
>>> str = 'fish' 'hat' #若干个字符串之间如果只有空格,Python会自动连接
>>> print str
fishhat
>>> str += ' learning Python!' #使用运算符追加字符串
>>> print str
fishhat learning Python

②:使用str2.join(str)函数进行连接,其中str为需要连接的字符串序列或者一个字符串,str2为连接中填补的字符:
>>> string = ('apple','banana','china')
>>> print '-'.join(string) #向string这个元组中的多个字符串元素之间加上'-'然后输出
apple-banana-china
>>> print ''.join(string) #加入的字符也可以是空的
applebananachina
>>> print '-'.join('fishhat') #直接使用
f-i-s-h-h-a-t #自动在每个子字符中加入'-'

5.用split(str[,int])函数截取字符串
>>> string = 'f-i-s-h-h-a-t'
>>> string.split('-') #按'-'作为截取子字符串的符号,也就是说遇到一个'-'则截取一个子字符
['f','i','s','h','h','a','t'] #最后返回一个截取得到的子字符列表
>>> string.split('-',2)   #在按'-'截取子字符的时候,当截取到第2个'-'的时候就停止截取,后面的字符全部按一个子字符返回(也就是说不管有没有'-'Python都不会理了,它认为你只指定了2个'-'有效)
['f','i','s-h-h-a-t'] #实际上返回了三个子字符,因为在Python找到第一个'-'之前已经有一个'f'就把'f'做子字符


后记:这里很容易混淆,后面的整数参数(不提供系统默认截取所有的)其实就相当于你要在字符串中画多少条界,相当于切一条蛋糕,你切两刀是不是得三块?至于每块蛋糕的长短,就取决于你在蛋糕上做好的标记,也就相当于刚才的'-'

6.startswith()函数和endswith()函数
①:startswith(substring[,start[,end]])--用于判断字符串是否以substring字符开始的,start和 end需要对比的字符区间,默认是整个字符串,成功返回True失败返回False
>>> str = 'fishhat'
>>> str.startswith('fi')
True
>>> str.startswith('sh',2,4)
True
>>> str.startswith('sh',)

②:endswith(substring[,start[,end]])--用于判断字符串是否以substring字符结束的,start和end是需要对比的字符区间,默认是整个字符串,成功返回True失败返回False
>>> str.endswith('hat')
True
>>> str.endswith('ha',4,6)
True

#Python中的字符串处理(2)——2009-12-8
前记:前两天的笔记没有坚持写.现在继续.COME ON!今后争取每天都要写一篇笔记(就算没有东西写了也要扯出来)

1.实现字符串的反转,由于Python目前没有专门用于字符串反转的函数所以自定义一个,实现方法是通过从字符串的尾部开始取得子字符,然后逐个连接起来后返回一个完整的反转字符串:

>>> def reverse(str):
>>> ... rstr = '' #定义一个用于连接字符串后返回的变量
>>> ... lstr = list(str)   #将字符串分解成一个列表,即一个子字符为列表的一个元素
>>> ... for i in range(len(str),0,-1): #反向遍历索引,起始值为字符串的长度(就是以尾部到首部的顺序生成索引)
>>> ... rstr += ''.join(lstr[i-1]) #注意这里的索引得减去1,否则原字符串的第一个字符就不能返回(因为是0)
>>> ... return rstr   #返回经过反向遍历字符串重新连接起来的反向字符串
>>> ...
>>> string = 'Fishhat'

>>> list(string)   #这里先补上刚才接触到list()函数的用法与功能
>>> ['F','i','s','h','h','a','t'] #返回一个子字符集合的列表
>>> print reverse(string) #试试刚才自定义的字符串反转函数怎么样
tahhsiF #好样的,我们成功的把字符反过来了

后记:不知道是不是Python'蓄意'跟我搞了个乌龙(汗死了~~囧!!!):

>>> def reverse(str): #这个函数比上面那个精简了一些
>>> ... lstr = list(str) #解包--把字符串分解成子字符组成的列表
>>> ... lstr.reverse() #使用列表的reverse()方法对列表内的元素倒序排列
>>> ... rstr = ''.join(lstr) #打包--把列表内的子字符重新连接起来
>>> ... return rstr #返回连接后的结果
>>> string = 'ABCDE'
>>> print reverse(string)
EDCBA


让我更囧的东西还在下面....Python这小子竟然再次耍我:

>>> def reverse(str): #比上面的都精简.看到这里我就无语了~~
>>> ... return str[::-1]   #直接返回通过索引倒序排序的结果
>>> ...
>>> string = 'ABCDE'
>>> print reverse(string)
EDCBA

2.字符串的查找与替换--可以用两个函数实现:find()、rfind(),这两个函数的不同之处只是查找的顺序不同
①find(substring[,start[,end]])--在字符串中查找子字符substring,后面的两个可选参数是进行切片查找
如果在字符串中找到substring则返回索引(如果字符串中有多个结果则返回第一次出现的索引),没找到返回-1


>>> string = 'I am Fishhat'
>>> print string.find('F')
#记住.在查找的时候是区分大小写的
5
>>> print string.find('f')   #试试看小写
-1   #找不到,所以是区分大小写的
>>> print string.find('h',2,5)
-1 #索引2至5之间没找到'h'
>>> print string.find('h',5,-1) # 索引5到字符串的最后一个索引
8   #找到了,在第8个索引

②rfind(substring[,start[,end]])--跟上面的没什么两样,只是在查找子字符串的时候是从字符串的尾部开始找的,下面例子很好:


>>> string = 'I am Fishhat'
>>> print string.find('h')
#先看看find()方法的结果
8 #找到了,在第八个索引
>>> print string.rfind('h')   #然后试试rfind()方法看看跟上面有什么不一样的
9   #注意到了没?'I am Fishhat'中是不是有两个'h'呢?
#因为find()从左至右(顺序)开始查找的,找到的第一个'h'是在第8个索引,索引find()就返回咯
#而rfind()不一样,它是从右至左(倒序)进行查找的,找到的第一个'h'是在第9个索引.那就返回倒序查找先发现的咯,当然是9了

1.替换字符串--replace(old,new[,max]):替换字符串中找到的old为new,如果字符串中找到了多个old字串,则可使用max指定替换多少个old(默认是替换所有),再有的就是.如果在字符串没有找到old字串.则返回原字符串

>>> str = 'AAAAABBBBBDDDDD'
>>> str.replace('D','C') #把字符串中所有的D替换为C
'AAAAABBBBBCCCCC'
>>> str.replace('A','a',3)
#替换字符串中的3个A为a
'aaaAABBBBCCCCC' #replace()函数的操作不会影响原字符串.只是拷贝原字符串然后进行操作而已

2.字符串与时间格式的转换

首先看看格式化日期的时候常用到的标记
%a 英文星期的简写
%A 英文星期的完整拼写
%b 英文月份的简写
%B 英文月份的完整拼写
%c 本地当前的日期与时间
%d 日期数,1-31之间
%H 小时数,00-23之间
%I 小时数,01-12之间
%m 月份,01-12之间
%M 分钟数,01-59之间
%j 本年从第1天开始计数到当天的天数
%w 星期数,0-6之间(0是周日)
%W 当天属于本年的第几周,周一作为一周的第一天进行计算
%x 本地的当天日期
%X 本地的当前时间
%y 年份,0-99之间
%Y 年份的完整拼写

①时间转为字符串--strftime(format[,tuple]),其中format为转换格式类型tuple为一个时间元组

>>> import time #由于获取时间和使用转换函数需用到time模块.所以必须导入
>>> str = time.strftime('%Y-%m-%d %X',time.localtime()) #time,localtime()返回以本地时间的所有参数为元素的元组
>>> print str
2009-12-09 21:36:35

②字符串转为时间--需要用到time模块strptime()函数和datetime模块datetime()函数
strptime(string,format)--把字符串string以format的格式返回一个时间的元组(元组内有齐全的时间元素,但是如果字符串中只有几个有用的时间信息,其他的元素默认或取本地时间的一些信息)
>>> str = '2009/12/09'
>>> str = time.strptime(str,'%Y/%m/%d')
#注意后面的获取字符串中的时间的格式.对应原字符串中年月日之间的间隔符号
>>> print str
time.struct_time(tm_year=2009, tm_mon=12, tm_mday=9, tm_hour=0, tm_min=0, tm_sec
=0, tm_wday=2, tm_yday=343, tm_isdst=-1)
#可以注意到元组中前三个元素都是刚才字符串中得到的值,后面的信息都没没获取到

datetime(year,month,day[,hour[,minute[,second[,microsecend[,tzinfo]]]]]) 函数返回一个datetime类型的变量,这是一种特殊的变量,也就是说,时间型的

>>> str = datetime.datetime(2009,12,9) #定义一个datetime变量,注意后面参数中的月或日,只能单写也就是说,9月或9日不能写成09月或09日,必须单写
>>> print str
2009-12-09 00:00:00
#但显示却会显示完整的,比如其中的9日显示为了09日,还有,默认时分秒为0
>>> type(str)
<type 'datetime.datetime'>
#这里可以看到刚才定义的str为这种类型的变量

最后再把上面这两个函数结合起来完整的完成字符串到时间的转换:

>>> import time,datetime #首先导入两个使用到的模块
>>> string = '2009-12-09'
>>> string = time.strptime(string,'%Y-%m-%d')
#首先把字符串使用strptime()返回一个时间元素构成的元组
>>> y, m, d = string[0:3] #把得到的时间元组前三个元素赋值给三个变量(也就是年月日)
>>> string = datetime.datetime(y, m, d) #最后使用datetime把刚才得到的时间变量转为正式的时间格式变量
>>> print string
2009-12-09 00:00:00
#至此,可以说完成了字符串到时间的转换(注意是变量类型转换的过程)法

str='python String function'

  1. 生成字符串变量str='python String function'
  2. 字符串长度获取:len(str)
    例:print '%s length=%d' % (str,len(str))
  3. 字母处理
    全部大写:str.upper()
    全部小写:str.lower()
    大小写互换:str.swapcase()
    首字母大写,其余小写:str.capitalize()
    首字母大写:str.title()
    print '%s lower=%s' % (str,str.lower())
    print '%s upper=%s' % (str,str.upper())
    print '%s swapcase=%s' % (str,str.swapcase())
    print '%s capitalize=%s' % (str,str.capitalize())
    print '%s title=%s' % (str,str.title())
  4. 格式化相关
    获取固定长度,右对齐,左边不够用空格补齐:str.ljust(width)
    获取固定长度,左对齐,右边不够用空格补齐:str.ljust(width)
    获取固定长度,中间对齐,两边不够用空格补齐:str.ljust(width)
    获取固定长度,右对齐,左边不足用0补齐
    print '%s ljust=%s' % (str,str.ljust(20))
    print '%s rjust=%s' % (str,str.rjust(20))
    print '%s center=%s' % (str,str.center(20))
    print '%s zfill=%s' % (str,str.zfill(20))

  5. 字符串搜索相关
    搜索指定字符串,没有返回-1:str.find('t')
    指定起始位置搜索:str.find('t',start)
    指定起始及结束位置搜索:str.find('t',start,end)
    从右边开始查找:str.rfind('t')
    搜索到多少个指定字符串:str.count('t')
    上面所有方法都可用index代替,不同的是使用index查找不到会抛异常,而find返回-1
    print '%s find nono=%d' % (str,str.find('nono'))
    print '%s find t=%d' % (str,str.find('t'))
    print '%s find t from %d=%d' % (str,1,str.find('t',1))
    print '%s find t from %d to %d=%d' % (str,1,2,str.find('t',1,2))
    #print '%s index nono ' % (str,str.index('nono',1,2))
    print '%s rfind t=%d' % (str,str.rfind('t'))
    print '%s count t=%d' % (str,str.count('t'))

  6. 字符串替换相关
    替换old为new:str.replace('old','new')
    替换指定次数的old为new:str.replace('old','new',maxReplaceTimes)
    print '%s replace t to *=%s' % (str,str.replace('t', '*'))
    print '%s replace t to *=%s' % (str,str.replace('t', '*',1))

  7. 字符串去空格及去指定字符
    去两边空格:str.strip()
    去左空格:str.lstrip()
    去右空格:str.rstrip()
    去两边字符串:str.strip('d'),相应的也有lstrip,rstrip
    str=' python String function '
    print '%s strip=%s' % (str,str.strip())
    str='python String function'
    print '%s strip=%s' % (str,str.strip('d'))

  8. 按指定字符分割字符串为数组:str.split(' ')
    默认按空格分隔
    str='a b c de'
    print '%s strip=%s' % (str,str.split())
    str='a-b-c-de'
    print '%s strip=%s' % (str,str.split('-'))

  9. 字符串判断相关
    是否以start开头:str.startswith('start')
    是否以end结尾:str.endswith('end')
    是否全为字母或数字:str.isalnum()
    是否全字母:str.isalpha()
    是否全数字:str.isdigit()
    是否全小写:str.islower()
    是否全大写:str.isupper()
    str='python String function'
    print '%s startwith t=%s' % (str,str.startswith('t'))
    print '%s endwith d=%s' % (str,str.endswith('d'))
    print '%s isalnum=%s' % (str,str.isalnum())
    str='pythonStringfunction'
    print '%s isalnum=%s' % (str,str.isalnum())
    print '%s isalpha=%s' % (str,str.isalpha())
    print '%s isupper=%s' % (str,str.isupper())
    print '%s islower=%s' % (str,str.islower())
    print '%s isdigit=%s' % (str,str.isdigit())
    str='3423'
    print '%s isdigit=%s' % (str,str.isdigit())

Python笔记——字符串处理

1.定义... 1

A.字符串... 1

B.原始字符串(rawstring) 1

C.转义符... 2

D.特性... 2

2.基本操作:... 2

A.base op. 2

B.字符串转换:... 2

C. 修改字符串:... 3

D. 索引和分片... 3

3.字符串内建函数... 4

4.格式化输出字符串... 5

5.字符串相关模块:... 6

6.其他... 6

1.定义

A.字符串

Python字符串:一个有序的字符集合,用来存储和表现基于文本的信息

用于表示和存储文本,是单个字符的序列, 符合序列操作

python中字符串是不可变的,一旦声明,不能改变

通常由单引号(' ),双引号(" ),三引号(''' """)包围,其中单引号和双引号可互换,三引号可以由多行组成

三引号,多行字符串块,编写多行文本的快捷语法,常用语文档字符串,在文件的特定地点,被当做注释。便捷的多行注释。

B.原始字符串(raw string)

原始字符串常量,r”abcd”,即去掉了反斜线转义机制。关闭转义机制,常见于正则表达式

特殊字符串,以大写R 或小写r开始,为正则表达式设计的,其中\不再表示转义

【用于处理正则表达式,减少反斜杠】

path = r'e:\book'

可以方便地表示系统路径

C.转义符

\n换行,\\反斜杠

\t制表 \'单引号

\r回车 \"双引号

D.特性

不可变性:在创建之后就不能就地改变(同java),不能通过对其某一位置进行赋值而改变字符

划分为不可变序列,这些字符串所包含的字符存在从左到右的顺序,不可在原处修改。

python中字符串相当于一个不可变序列的列表,一旦声明,每个字符位置固定

>>>s=’spam’

>>>s[0]=’k’ #TypeError

修改字符串类似java,重新赋值

s = ‘k’ + s[1:]

2.基本操作:

A.base op

长度len(s)

连接‘s ’ + ‘pam’ ‘s’’pam’ [建议使用前者,可读性

重复: ‘HI’*4

Python不允许在+表达式中出现其他类型,需要手工转【这点不同于java】

‘abc’+str(9)

B.字符串转换:

int(‘42’)

str(42)

float(’42.0’)

字符串与数字相互转换

string.atoi(s[,base]) 字符串-》数字

s:进行转换的字符串

base:可选,目标进制

str() 数字-》字符串

str(4)

ord(‘s’) #转ASCII

chr(115) #转字符

字符串和列表的转换

s=’spam’

l = list(s)

k = ‘’.join(l)

C. 修改字符串:

s = s+’a’

s = s[3:] + ‘b’

s = s.replace(‘pl’,’pa’)

D. 索引和分片

正序获取:str[0]

倒序获取:str[-i] 其中最后一个字符序号为-1

str[a:b] a到b-1区间内的字符串

str[0:-2]与str[:-2]一样

索引s[i]

s[0]首个

s[-1] = s[len(s)-1] 倒数第一个

分片s[i:j]

不含上边界,s[1:3] 取[1-2]

s[1:]取1到结束 s[:3] 取开始到2

s[:-1]开始到倒数第二个

s[:]开始到结尾,相当于一个复制

s[1:10:2] 取1-9,步长=2

s[a:b:-2] 步长为负数,两个边界意义反转了,表示从b+1到a,步长-2

s=’abcdefg’ s[5:1:-1] 得到 fedc

s[1:3] == s[slice(1,3)] 内置函数

3.字符串内建函数

【字符串方法是python文本处理头号工具】

 

string.capitalize()

字符串第一个字符大写

string.center(width,[,fill])

原字符居中,空格填充至width长度

string.count(str,beg=0,end=len(string))

获得字符串中某一个子串的数目,计算出现次数,可指定范围

string.decode(encoding=’UTF-8’,errors=’strict’)

解码字符串,出错默认报ValueError,除非errors是ignore或replace

string.encode(encoding=’UTF-8’,errors=’strict’)

string.endswith(suffix,beg=0,end=len(string))

是否以**结尾

string.expandtabs(tabsize=8)

把字符串中tab转为空格,默认8个

string.find(str,beg=0,end=len(stirng))

检测是否包含str,存在返回开始索引,否则返回-1

string.index(str,begin=0,end=len(string))

同find,不存在报异常

string.isalnum()

至少一个字符,且所有字符均为字母或数字,True. 检测字符串是否只包含0-9A-Za-z

string.isalpha()

至少一个字符,所有字符都是字母,True. 检测字符串是否只包含字母

string.isdecimal()

只包含十进制数,True

stirng.isdigit()

只包含数字,True. 检测字符串是否仅包含数字

string.islower()

至少一个区分大小写字符且所有字符小写,True. 检测字符串是否均为小写字母

string.isnumeric()

只含数字字符,True

string.isspace()

只包含空格,True. 检测字符串是否均为空白字符

string.istitle()

标题化字符,True. 检测字符串中的单词是否为首字母大写

string.isupper()

至少一个区分大小写字符且所有字符大写,True. 检测字符串是否均为大写字母

string.join(seq)

以string作为分隔符,seq中所有元素合并为新的字符串. 将原字符串插入参数字符串中的每两个字符之间

string.ljust(width)

返回一个原字符串左对齐,空格补充至长度width

string.lower()

转小写. 将字符串全部转为小写

string.lstrip()

截掉左侧的空格

string.partition(str)

= find+split,从str出现第一个位置,截断为pre_str,str,after_str元组,不含str则pre_str=str

string.replace(str1,str2,num=string.count(str1))

替换,指定不超过num次,可作为模板实现

string.rfind(str,beg=0,end=len(string))

同find,右边开始

string.rindex(str,beg=0,end=len(string))

同index,右边开始

string.rjust(width)

右对齐,空格补齐

string.rpartition(str)

同partition,右边开始

string.rstrip([chars])

清理右侧空白,包括换行符,返回处理后字符串

string.split(str=””, maxsplit =string.count(str))

以str切片,可指定分割次数, 分割字符串,返回列表,默认分隔符空格

string.splitlines(num=string.count(‘\n’))

s.splitlines([keepends])

按行分隔,可指定分割次数

string.startswith(obj,beg=0,end=len(string))

以str开头,True. 检测字符串是否以某一子串开头

string.strip([obj])

在string上执行lstrip和rstrip

string.swapcase

反转string中大小写. 字符串中小写转大写,大写转小写

string.title()

标题花,单词首字母大写,其余小写

string.translate(str,del=””)

s.translate(table)

根据str给出表转换string字符,要过滤的字符放在del参数中

string.upper()

转大写. 将字符串全部转为大写

string.zfill(width)

返回长度width的字符串,原字符串右对齐,前面填充0

len(string)

获取字符串的长度

 

4.格式化输出字符串

%c 单个字符

%d 十进制整数

%o 八进制整数

%s 字符串

%x 十六进制整数,其中字母小写

%X 十六进制整数,其中字母大写

str = "so %s a day!"

str % 'beautiful'

“%s,a,b” %”TOM” 格式化

‘{0} is {1}’.format(‘a’,’b’)

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

-左对齐 +正负号 0补0

%-6d六位左对齐

d六位补零

基于字典的格式化

“%(n)d %(x)x” % {“n”:1 , “x”:spam}

python2.6之后格式化新方法:

可以通过位置或关键字进行填充

template = “{0}, {1} and {2}”

template.format(‘spam’,’ham’,’eggs’)

template = “{motto},{pork} and food”

template.format (motto=”a”,port = ‘ham’,food=’eggs’)

template = “{motto}, {0} and {food}”

template.format(‘ham’,motto=”a”,food=”b”)

存在其他更强大的用法,参见p198

格式化字符串:

pattern = “%s -----%s”

c = parttern %(a,b) #格式化后总返回新的字符串

5.字符串相关模块:

 

string 字符串相关类和函数,例如Template

re正则表达式模块

struct字符串和二进制转换

c/StringIO字符串缓冲对象,操作方法类似file

base64 Base16,32,64数据编解码

codecs解码器注册和基类

crypt进行单方面加密

difflib找出序列不同

hashlib多种不同安全哈希算法和信息摘要算法的API

hma HMAC信息鉴权算法python实现

md5 RSA的MD5信息摘要鉴权

rotor提供多平台加密解密服务

sha NIAT的安全哈希算法SHA

stringprep提供用于IP协议的Unicode字符串

textwrap 文本包装和填充

unicodedata Unicode数据库

 

6.其他

A.获得帮助

>>>help(str)

>>> dir(str)

>>> help(str.replace)

大家还是直接看代码比较直接,以下是代码及其运行结果:

  1. #string.py 字符串操作函数
  2. #字符串声明方式
  3. stra = 'a python string'
  4. strb = "b python /n string" #带转义的
  5. strc = '''''two lines python
  6. string'''
  7. strd = """two lines python
  8. string"""
  9. print(stra)
  10. print(strb)
  11. print(strc)
  12. print(strd)
  13. #字符串相当于一个不可变序列列表
  14. #正序获取
  15. print( stra[0:6] ) #序号0-5
  16. #倒序获取 str[-i] 最后一个字符序号为 -1
  17. print( stra[-6:-1] ) #序号-6 -2
  18. print('-------string operations --------')
  19. #获取字符串长度
  20. print( len(stra) )
  21. #首字母大写
  22. print( stra.capitalize() )
  23. #计算子串出现次数
  24. print( stra.count('python') )
  25. #获得某一子串的起始位置
  26. print( stra.find('python') )
  27. #将字符串全部小写
  28. print( stra.lower() )
  29. #将字符串全部大写
  30. print( stra.upper() )
  31. #将字符串中小写转大写,大写转小写
  32. print( stra.swapcase() )
  33. #将字符串中所有单词首字母大写
  34. print( stra.title() )
  35. #将原字符串插入到参数字符串红的每两个字符之间
  36. print( stra.join('*#!') )
  37. #切分字符串,若不指定分隔符,默认空格
  38. print( stra.split() )
  39. #检测是否只包含0-9A-Za-z
  40. print( stra.isalnum() )
  41. #检测是否只包含字母
  42. print( stra.isalpha() )
  43. #检测是否只包含数字
  44. print( stra.isdigit() )
  45. #检测字符串是否均为小写
  46. print( stra.islower() )
  47. #检测字符串是否均为大写
  48. print( stra.isupper() )
  49. #检测字符串是否均为空白
  50. print( stra.isspace() )
  51. #检测字符串中的单词是否全部为首字母大写
  52. print( stra.istitle() )
  53. #检测是否以某一字符串开头
  54. print( stra.startswith('a') )
  55. #检测字符串是否以某一字符串结尾
  56. print( stra.endswith('b') )
  57. #格式化输出字符串
  58. str = "so %s a day!"
  59. print( str % 'beautiful' )
#string.py 字符串操作函数 #字符串声明方式 stra = 'a python string' strb = "b python /n string" #带转义的 strc = '''two lines python string''' strd = """two lines python string""" print(stra) print(strb) print(strc) print(strd) #字符串相当于一个不可变序列列表 #正序获取 print( stra[0:6] ) #序号0-5 #倒序获取 str[-i] 最后一个字符序号为 -1 print( stra[-6:-1] ) #序号-6 到 -2 print('-------string operations --------') #获取字符串长度 print( len(stra) ) #首字母大写 print( stra.capitalize() ) #计算子串出现次数 print( stra.count('python') ) #获得某一子串的起始位置 print( stra.find('python') ) #将字符串全部小写 print( stra.lower() ) #将字符串全部大写 print( stra.upper() ) #将字符串中小写转大写,大写转小写 print( stra.swapcase() ) #将字符串中所有单词首字母大写 print( stra.title() ) #将原字符串插入到参数字符串红的每两个字符之间 print( stra.join('*#!') ) #切分字符串,若不指定分隔符,默认空格 print( stra.split() ) #检测是否只包含0-9A-Za-z print( stra.isalnum() ) #检测是否只包含字母 print( stra.isalpha() ) #检测是否只包含数字 print( stra.isdigit() ) #检测字符串是否均为小写 print( stra.islower() ) #检测字符串是否均为大写 print( stra.isupper() ) #检测字符串是否均为空白 print( stra.isspace() ) #检测字符串中的单词是否全部为首字母大写 print( stra.istitle() ) #检测是否以某一字符串开头 print( stra.startswith('a') ) #检测字符串是否以某一字符串结尾 print( stra.endswith('b') ) #格式化输出字符串 str = "so %s a day!" print( str % 'beautiful' )

 


结果

 

相关文章推荐

Python:操作嵌入式数据库SQLite

去年写过一篇通过C语言操作SQLite数据库的文章《SQLITE学习笔记一(打开、操作及关闭数据库,C程序实现)》,最近在学习python,所以使用ptyhon实现了一下,实现不多描述了,代码中的注释...
  • dyx1024
  • dyx1024
  • 2012年02月12日 12:15
  • 3617

<Python初学>基本数据str的操作

Python版本:Python 3.5.3rc1

str()和repr()(及''操作符)以及python对json的简单操作

str(),epr()和''运算在特性和功能方面相似,事实上repr()和''做的是完全一样的事情(函数和操作符做同样一件事,是因为在有的场合函数会比操作符更合适),它们返回的是一个对象的“官方”字符...

python字符串内建函数操作实例(cmp、str、enumerate、zip等)

#coding=utf8 ''' cmp(str1,str2):根据字符串的ASCII码值进比较,返回一个整数。 如果返回值大于零,str1大于str2; 如果返回值小于零,str1小于str2; 如...

python(0)-对《python中str操作的学习》的补充

对《python中str操作的学习》的补充str=’python String function’生成字符串变量str=’python String function’字符串长度获取:len(str)...

嵌入式 sqlite3中事务操作小结

在对 sqlite3 insert into 等操作时速度比较慢。 原因:它以文件的形式存在磁盘中,每次访问时都要打开一次文件,如果对数据库进行大量的操作,就很慢。 解决办法:用事物的形式提交,因...
  • skdkjxy
  • skdkjxy
  • 2014年09月17日 17:32
  • 846

linux 下对 flash 设备操作的应用程序(嵌入式参考用)

linux下对dataflash设备操作(擦除、写入文件)的应用程序,注意,所有的操作必须要使用mtdx的字符设备。     放出这个程序,帮助大家理解一些mtdchar的字符设备驱动! ...

嵌入式硬件寄存器操作层次

嵌入式硬件寄存器操作层次 寄存器操作—>基于CMSIS-CORE操作—>基于硬件抽象层hal操作—>基于API操作(针对hal api再次作了面向对象的封装)...

嵌入式操作体统体系结构

嵌入式定义: 应用领域: 系统组成:
  • theowl
  • theowl
  • 2014年11月24日 14:30
  • 637

嵌入式C语言专题三:屏幕操作篇

屏幕乃嵌入式系统生存之重要辅助,面目可憎之显示将另用户逃之夭夭。屏幕编程若处理不好,将是软件中最不系统、最混乱的部分,笔者曾深受其害。   内容要点: ·汉字处理 ·系统时间显示 ·动...
  • jeffade
  • jeffade
  • 2012年06月05日 20:48
  • 301
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:嵌入式 python之str操作
举报原因:
原因补充:

(最多只允许输入30个字)