“Python字符串类型及其操作”的版本间的差异

来自CloudWiki
跳转至： 导航， 搜索
（→‎基本的字符串操作符）
 
（未显示同一用户的5个中间版本）
第5行： 第5行：
 
  >>> print(name)
 
  >>> print(name)
 
   abc
 
   abc
−
  >>> name = "山东商职学院'云计算小组'"
+
  >>> print('这是“泉城”济南')
−
>>> print(name)
+
这是“泉城”济南
−
山东商职学院'云计算小组'
+
>>> print("这是'泉城'济南")
 +
这是'泉城'济南
 
*input( )函数将用户输入的内容当作一个字符串类型，这是获得用户输入的常用方式。
 
*input( )函数将用户输入的内容当作一个字符串类型，这是获得用户输入的常用方式。
 
*print( )函数可以直接打印字符串，这是输出字符串的常用方式。如:
 
*print( )函数可以直接打印字符串，这是输出字符串的常用方式。如:
第39行： 第40行：
 
==基本的字符串操作符==
 
==基本的字符串操作符==
 
*python提供了五个字符串的基本操作符,如：
 
*python提供了五个字符串的基本操作符,如：
−
===x+y ===
+
===x+y===
 
*Python字符串支持加法运算符，表示两个字符串连接，生成新字符串。
 
*Python字符串支持加法运算符，表示两个字符串连接，生成新字符串。
 
  >>> 'hello ' + 'world'
 
  >>> 'hello ' + 'world'
第53行： 第54行：
 
  >>> "j" in "abcde"
 
  >>> "j" in "abcde"
 
  False
 
  False
 +
*例子：
 +
NameList ="张明 王乐 刘全全 谭虎"
 +
name = "王乐"
 +
if "王乐" in NameList:
 +
    print(name+"没在名单之中")
 +
else:
 +
    print(name+"在名单之中")
 +
 
===x * n 或 n * x ===
 
===x * n 或 n * x ===
 
*Python字符串支持与整数的乘法运算，表示序列重复，也就是字符串内容的重复，得到新字符串。
 
*Python字符串支持与整数的乘法运算，表示序列重复，也就是字符串内容的重复，得到新字符串。
第82行： 第91行：
 
  >>> min(x)
 
  >>> min(x)
 
  ' '
 
  ' '
 +
*python3以Unicode为编码单位，因此中英文字符都是1个长度单位。
 +
*延伸阅读：https://baike.baidu.com/item/Unicode/750500?fr=aladdin
 +
*16进制、八进制等的相互转换：
 +
>>> x=7
 +
>>> bin(x) #返回整数x对应的二进制字符串型。
 +
'0b111'
 +
>>> x= 11
 +
>>> hex(x)#返回整数x对应的16进制字符串型。
 +
'0xb'
 +
>>> oct(x)#返回整数x对应的八进制字符串形式。
 +
'0o13'
 
  >>> x=3.1415
 
  >>> x=3.1415
 
  >>> str(x)  #返回x的字符串形式。
 
  >>> str(x)  #返回x的字符串形式。
 
  '3.1415'
 
  '3.1415'
−
>>> chr(x) 返回Unicode编码对应的单字符
 
 
  >>> ord('a')#返回某个字符所表示的Unicode编码。
 
  >>> ord('a')#返回某个字符所表示的Unicode编码。
 
  97
 
  97
−
  >>> x= 11
+
  >>> chr(97) 返回Unicode编码对应的单字符
−
>>> hex(x)#返回整数x对应的16进制字符串型。
+
*例题：打印英文26个字母的Unicode编码
−
  '0xb'
+
  <nowiki>str1='abcdefghijklmnopqrstuvwxyz'
−
>>> oct(x)#返回整数x对应的八进制字符串形式。
+
for i in range(0,26):
−
'0o13'
+
    print(ord(str1[i]))#打印26个字母对应的Unicode编码</nowiki>
 +
 
 
*例题：凯撒编码
 
*例题：凯撒编码
−
  plaincode = input("请输入明文: ")
+
*“恺撒密码”据传是古罗马恺撒大帝用来保护重要军情的加密系统。它是一种替代密码，通过将字母按顺序推后起3位起到加密作用，如将字母A换作字母D，将字母B换作字母E。据说恺撒是率先使用加密函的古代将领之一，因此这种加密方法被称为恺撒密码。
 +
 
 +
初始源码：能处理26个字母除xyz以外的字符的加密
 +
  <nowiki>plaincode = input("请输入明文: ")
 +
  for p in plaincode:
 +
    if ord("a") <= ord(p) <= ord("z"):
 +
        print(chr(ord("a") + (ord(p) - ord("a") + 3)),end='') #(ord(p) - ord("a") + 3)代表说a后面第几个字符
 +
    else:
 +
        print(p, end='')</nowiki>
 +
 
 +
改进源码：能处理所有26个字符的加密
 +
<nowiki>plaincode = input("请输入明文: ")
 
  for p in plaincode:
 
  for p in plaincode:
 
     if ord("a") <= ord(p) <= ord("z"):
 
     if ord("a") <= ord(p) <= ord("z"):
 
         print(chr(ord("a") + (ord(p) - ord("a") + 3)%26),end='')
 
         print(chr(ord("a") + (ord(p) - ord("a") + 3)%26),end='')
 
     else:
 
     else:
−
         print(p, end='')
+
         print(p, end='')</nowiki>
 
*练习：针对凯撒编码写一个解密程序
 
*练习：针对凯撒编码写一个解密程序
 
*拓展：http://blog.csdn.net/by4_Luminous/article/details/53343780
 
*拓展：http://blog.csdn.net/by4_Luminous/article/details/53343780
−
==字符串常用操作==
 
−
*Python字符串对象提供了大量方法用于字符串的切分、连接、替换和排版等操作，另外还有大量内置函数和运算符也支持对字符串的操作。
 
−
*字符串对象是不可变的，所以字符串对象提供的涉及到字符串“修改”的方法都是返回修改后的新字符串，并不对原始字符串做任何修改，无一例外。
 
−
*find()和rfind方法分别用来查找一个字符串在另一个字符串指定范围（默认是整个字符串）中首次和最后一次出现的位置，如果不存在则返回-1；
 
−
*index()和rindex()方法用来返回一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在则抛出异常；
 
−
count()方法用来返回一个字符串在当前字符串中出现的次数。
 
−
>>> s="apple,peach,banana,peach,pear"
 
−
>>> s.find("peach")
 
−
6
 
−
>>> s.find("peach",7)
 
−
19
 
−
>>> s.find("peach",7,20)
 
−
-1
 
−
>>> s.rfind('p')
 
−
25
 
−
>>> s.index('p')
 
−
1
 
−
>>> s.index('pe')
 
−
6
 
−
>>> s.index('pear')
 
−
25
 
−
>>> s.index('ppp')
 
−
Traceback (most recent call last):
 
−
  File "<pyshell#11>", line 1, in <module>
 
−
    s.index('ppp')
 
−
ValueError: substring not found
 
−
>>> s.count('p')
 
−
5
 
−
>>> s.count('pp')
 
−
1
 
−
>>> s.count('ppp')
 
−
===split()、rsplit()、partition()、rpartition()===
 
−
*split()和rsplit()方法分别用来以指定字符为分隔符，把当前字符串从左往右或从右往左分隔成多个字符串，并返回包含分隔结果的列表；
 
−
*partition()和rpartition()用来以指定字符串为分隔符将原字符串分隔为3部分，即分隔符前的字符串、分隔符字符串、分隔符后的字符串，如果指定的分隔符不在原字符串中，则返回原字符串和两个空字符串。
 
−
<nowiki>>>> s = "apple,peach,banana,pear"
 
−
>>> s.split(",")
 
−
["apple", "peach", "banana", "pear"]
 
−
>>> s.partition(',')
 
−
('apple', ',', 'peach,banana,pear')
 
−
>>> s.rpartition(',')
 
−
('apple,peach,banana', ',', 'pear')
 
−
>>> s.rpartition('banana')
 
−
('apple,peach,', 'banana', ',pear')
 
−
>>> s = "2017-10-31"
 
−
>>> t = s.split("-")
 
−
>>> print(t)
 
−
['2017', '10', '31']
 
−
>>> print(list(map(int, t)))
 
−
[2017, 10, 31]</nowiki>
 
−
*split()和rsplit()方法还允许指定最大分割次数。
 
−
>>> s = '\n\nhello\t\t world \n\n\n My name is Dong  '
 
−
>>> s.split(None, 1)
 
−
['hello', 'world \n\n\n My name is Dong  ']
 
−
>>> s.rsplit(None, 2)
 
−
['\n\nhello\t\t world \n\n\n My name', 'is', 'Dong']
 
−
>>> s.split(maxsplit=6)
 
−
['hello', 'world', 'My', 'name', 'is', 'Dong']
 
−
>>> s.split(maxsplit=100)    #最大分隔次数大于可分隔次数时无效
 
−
['hello', 'world', 'My', 'name', 'is', 'Dong']
 
−
*对于split()和rsplit()方法，如果不指定分隔符，则字符串中的任何空白符号（空格、换行符、制表符等）都将被认为是分隔符，把连续多个空白字符看作一个分隔符。
 
−
>>> s = 'hello world \n\n My name is Dong  '
 
−
>>> s.split()
 
−
['hello', 'world', 'My', 'name', 'is', 'Dong']
 
−
>>> s = '\n\nhello world \n\n\n My name is Dong  '
 
−
>>> s.split()
 
−
['hello', 'world', 'My', 'name', 'is', 'Dong']
 
−
>>> s = '\n\nhello\t\t world \n\n\n My name\t is Dong  '
 
−
>>> s.split()
 
−
['hello', 'world', 'My', 'name', 'is', 'Dong']
 
−
*然而，明确传递参数指定split()使用的分隔符时，情况是不一样的。
 
−
>>> 'a,,,bb,,ccc'.split(',')      #每个逗号都被作为独立的分隔符
 
−
['a', '', '', 'bb', '', 'ccc']
 
−
>>> 'a\t\t\tbb\t\tccc'.split('\t') #每个制表符都被作为独立的分隔符
 
−
['a', '', '', 'bb', '', 'ccc']
 
−
>>> 'a\t\t\tbb\t\tccc'.split()    #连续多个制表符被作为一个分隔符
 
−
['a', 'bb', 'ccc']
 
−
===join() ===
 
−
*字符串连接join()
 
−
>>> li = ["apple", "peach", "banana", "pear"]
 
−
>>> ','.join(li)
 
−
'apple,peach,banana,pear'
 
−
>>> '.'.join(li)
 
−
'apple.peach.banana.pear'
 
−
>>> '::'.join(li)
 
−
'apple::peach::banana::pear'
 
−
*问题解决：使用split()和join()方法删除字符串中多余的空白字符，连续多个空白字符只保留一个。
 
−
>>> x = 'aaa      bb      c d e  fff    '
 
−
>>> ' '.join(x.split())            #使用空格作为连接符
 
−
'aaa bb c d e fff'
 
−
>>> def equavilent(s1, s2):        #判断两个字符串在Python意义上是否等价
 
−
if s1 == s2:
 
−
return True
 
−
elif ' '.join(s1.split()) == ' '.join(s2.split()):
 
−
return True
 
−
elif ''.join(s1.split()) == ''.join(s2.split()):
 
−
return True
 
−
else:
 
−
return False
 
−
>>> equavilent('pip list', 'pip    list')
 
−
True
 
−
===lower()、upper()、capitalize()、title()、swapcase()===
 
−
*lower()、upper()、capitalize()、title()、swapcase()
 
−
>>> s = "What is Your Name?"
 
−
>>> s.lower()                  #返回小写字符串
 
−
'what is your name?'
 
−
>>> s.upper()                  #返回大写字符串
 
−
'WHAT IS YOUR NAME?'
 
−
>>> s.capitalize()              #字符串首字符大写
 
−
'What is your name?'
 
−
>>> s.title()                  #每个单词的首字母大写
 
−
'What Is Your Name?'
 
−
>>> s.swapcase()                #大小写互换
 
−
'wHAT IS yOUR nAME?'
 
−
===replace()、maketrans()、translate()===
 
−
*查找替换replace()，类似于Word中的“全部替换”功能。
 
−
>>> s = "中国，中国"
 
−
>>> print(s)
 
−
中国，中国
 
−
>>> s2 = s.replace("中国", "中华人民共和国")  #两个参数都作为一个整理
 
−
>>> print(s2)
 
−
中华人民共和国，中华人民共和国
 
−
*问题解决：测试用户输入中是否有敏感词，如果有的话就把敏感词替换为3个星号***。
 
−
>>> words = ('测试', '非法', '暴力', '话')
 
−
>>> text = '这句话里含有非法内容'
 
−
>>> for word in words:
 
−
    if word in text:
 
−
        text = text.replace(word, '***')
 
−
>>> text
 
−
'这句***里含有***内容'
 
−
*字符串对象的maketrans()方法用来生成字符映射表，而translate()方法用来根据映射表中定义的对应关系转换字符串并替换其中的字符，使用这两个方法的组合可以同时处理多个字符。
 
−
#创建映射表，将字符"abcdef123"一一对应地转换为"uvwxyz@#$"
 
−
>>> table = ''.maketrans('abcdef123', 'uvwxyz@#$')
 
−
>>> s = "Python is a greate programming language. I like it!"
 
−
#按映射表进行替换
 
−
>>> s.translate(table)
 
−
'Python is u gryuty progrumming lunguugy. I liky it!'
 
−
*问题解决：凯撒加密，每个字母替换为后面第k个。
 
−
>>> import string
 
−
>>> def kaisa(s, k):
 
−
    lower = string.ascii_lowercase          #小写字母
 
−
    upper = string.ascii_uppercase          #大写字母
 
−
    before = string.ascii_letters
 
−
    after = lower[k:] + lower[:k] + upper[k:] + upper[:k]
 
−
    table = ''.maketrans(before, after)    #创建映射表
 
−
    return s.translate(table)
 
  
−
>>> s = "Python is a greate programming language. I like it!"
+
下一节 [[Python字符串常用操作]]
−
>>> kaisa(s, 3)
 
−
'Sbwkrq lv d juhdwh surjudpplqj odqjxdjh. L olnh lw!'
 
−
===strip()、rstrip()、lstrip()===
 
−
*strip()、rstrip()、lstrip()
 
−
>>> s = " abc  "
 
−
>>> s.strip()                            #删除空白字符
 
−
'abc'
 
−
>>> '\n\nhello world  \n\n'.strip()      #删除空白字符
 
−
'hello world'
 
−
>>> "aaaassddf".strip("a")                #删除指定字符
 
−
'ssddf'
 
−
>>> "aaaassddf".strip("af")
 
−
'ssdd'
 
−
>>> "aaaassddfaaa".rstrip("a")            #删除字符串右端指定字符
 
−
'aaaassddf'
 
−
>>> "aaaassddfaaa".lstrip("a")            #删除字符串左端指定字符
 
−
'ssddfaaa'
 
−
*这三个函数的参数指定的字符串并不作为一个整体对待，而是在原字符串的两侧、右侧、左侧删除参数字符串中包含的所有字符，一层一层地从外往里扒。
 
−
>>> 'aabbccddeeeffg'.strip('af')  #字母f不在字符串两侧，所以不删除
 
−
'bbccddeeeffg'
 
−
>>> 'aabbccddeeeffg'.strip('gaf')
 
−
'bbccddeee'
 
−
>>> 'aabbccddeeeffg'.strip('gaef')
 
−
'bbccdd'
 
−
>>> 'aabbccddeeeffg'.strip('gbaef')
 
−
'ccdd'
 
−
>>> 'aabbccddeeeffg'.strip('gbaefcd')
 
−
''
 
−
===startswith()、endswith()===
 
−
*s.startswith(t)、s.endswith(t)，判断字符串是否以指定字符串开始或结束
 
−
>>> s = 'Beautiful is better than ugly.'
 
−
>>> s.startswith('Be')            #检测整个字符串
 
−
True
 
−
>>> s.startswith('Be', 5)        #指定检测范围起始位置
 
−
False
 
−
>>> s.startswith('Be', 0, 5)    #指定检测范围起始和结束位置
 
−
True
 
−
>>> import os
 
−
>>> [filename for filename in os.listdir(r'c:\\') if filename.endswith(('.bmp','.jpg','.gif'))]
 
−
===isalnum()、isalpha()、isdigit()、isdecimal()、isnumeric()、isspace()、isupper()、islower()===
 
−
*isalnum()、isalpha()、isdigit()、isdecimal()、isnumeric()、isspace()、isupper()、islower()，用来测试字符串是否为数字或字母、是否为字母、是否为数字字符、是否为空白字符、是否为大写字母以及是否为小写字母。
 
−
 
 
−
>>> '1234abcd'.isalnum()
 
−
True
 
−
>>> '1234abcd'.isalpha()        #全部为英文字母时返回True
 
−
False
 
−
>>> '1234abcd'.isdigit()        #全部为数字时返回True
 
−
False
 
−
>>> 'abcd'.isalpha()
 
−
True
 
−
>>> '1234.0'.isdigit()
 
−
False
 
−
>>> '1234'.isdigit()
 
−
True
 
−
>>> '九'.isnumeric()              #isnumeric()方法支持汉字数字
 
−
True
 
−
>>> '九'.isdigit()
 
−
False
 
−
>>> '九'.isdecimal()
 
−
False
 
−
>>> 'ⅣⅢⅩ'.isdecimal()
 
−
False
 
−
>>> 'ⅣⅢⅩ'.isdigit()
 
−
False
 
−
>>> 'ⅣⅢⅩ'.isnumeric()          #支持罗马数字
 
−
True
 
−
===center()、ljust()、rjust()、zfill()===
 
−
*center()、ljust()、rjust()，返回指定宽度的新字符串，原字符串居中、左对齐或右对齐出现在新字符串中，如果指定宽度大于字符串长度，则使用指定的字符（默认为空格）进行填充。zfill()返回指定宽度的字符串，在左侧以字符0进行填充。
 
−
>>> 'Hello world!'.center(20)        #居中对齐，以空格进行填充
 
−
'    Hello world!    '
 
−
>>> 'Hello world!'.center(20, '=')  #居中对齐，以字符=进行填充
 
−
'====Hello world!===='
 
−
>>> 'Hello world!'.ljust(20, '=')    #左对齐
 
−
'Hello world!========'
 
−
>>> 'Hello world!'.rjust(20, '=')    #右对齐
 
−
'========Hello world!'
 

2018年12月14日 (五) 07:09的最新版本

字符串类型的表示

  • 字符串是字符的序列，表示快有一对单引号，双引号或三引号构成。其中单引号和双引号都可以表示单行字符串，三引号可以表示单行或者多行字符串。
  • 打印字符串的python程序，运行结果如下，注意其中的引号部分。
>>> name = 'abc'
>>> print(name)
 abc
>>> print('这是“泉城”济南')

这是“泉城”济南 >>> print("这是'泉城'济南") 这是'泉城'济南

  • input( )函数将用户输入的内容当作一个字符串类型，这是获得用户输入的常用方式。
  • print( )函数可以直接打印字符串，这是输出字符串的常用方式。如:
>>> name = input("请输入名字： ")
请输入名字： Python语言
>>> print(name)
Python语言
>>>

字符串的序号体系

  • 字符串包括两种序号体系，正向递增序号和反向递减序号。
  • P1-105.jpg
  • 如果字符串长度为L，正向递增，序号以最左侧字符序号为零，向右依次递增，最右侧字符序号为L-1。反向递减虚号，以最右侧字符序号为-1，向左依次递减，最左侧字符序号为-L.
  • Python字符串也提供区间访问方式,采用[N:M]格式，表示字符串中从n到m不包含m的子字符串。如果表示中M或者N索引缺失，则表示字符串把开始或结束索引值设为默认值。
>>> name = "Python语言程序设计"
>>> print(name[0])
P
>>> print(name[0],name[7],name[-1])
P 言 计
>>> print(name[2:-2])
thon语言程序
>>> print(name[:6])
Python
>>> print(name[6:])
语言程序设计
>>> print(name[:])
Python语言程序设计
  • 反斜杠字符是一个特殊字符，在字符串中表示转义，即该字符与后面相邻的一个字符共同组成了新的含义。
>>> print("Python\n语言\t程序\t设计")
Python
语言	程序	设计

基本的字符串操作符

  • python提供了五个字符串的基本操作符,如：

x+y

  • Python字符串支持加法运算符，表示两个字符串连接，生成新字符串。
>>> 'hello ' + 'world'
'hello world'

x in s

  • 成员判断，关键字in
>>> "a" in "abcde"     #测试一个字符中是否存在于另一个字符串中
True
>>> 'ab' in 'abcde'
True
>>> 'ac' in 'abcde'    #关键字in左边的字符串作为一个整体对待
False
>>> "j" in "abcde"
False
  • 例子：
NameList ="张明 王乐 刘全全 谭虎"
name = "王乐"
if "王乐" in NameList:
    print(name+"没在名单之中")
else:
    print(name+"在名单之中")

x * n 或 n * x

  • Python字符串支持与整数的乘法运算，表示序列重复，也就是字符串内容的重复，得到新字符串。
>>> 'abcd' * 3
'abcdabcdabcd'

str[i]

  • str[i],索引，表示第i个字符
>>> name = input("请输入名称:")	
请输入姓名:山东商业职业技术学院
>>> name[0]	
'山'

str[N:M]

  • str[N:M]切片，返回索引第N到M的子串，其中不包含M
  • 例：截取身份证号第X位数字
>>> name = input("请输入名称:")	
请输入姓名:山东商业职业技术学院
>>> name[2:4]	
'商业'
>>> name[4:6]
'职业'

内置的字符串处理函数

  • python解释器提供了一些内置函数，处理字符串呢，非常方便。
>>> x = 'Hello world.'
>>> len(x)                       #字符串长度
12
>>> max(x)                       #最大字符
'w'
>>> min(x)
' '

>>> x=7	
>>> bin(x)	#返回整数x对应的二进制字符串型。
'0b111'
>>> x= 11
>>> hex(x)#返回整数x对应的16进制字符串型。
'0xb'
>>> oct(x)#返回整数x对应的八进制字符串形式。
'0o13'
>>> x=3.1415
>>> str(x)  #返回x的字符串形式。
'3.1415'
>>> ord('a')#返回某个字符所表示的Unicode编码。
97
>>> chr(97) 返回Unicode编码对应的单字符
  • 例题：打印英文26个字母的Unicode编码
str1='abcdefghijklmnopqrstuvwxyz'
for i in range(0,26):
    print(ord(str1[i]))#打印26个字母对应的Unicode编码
  • 例题：凯撒编码
  • “恺撒密码”据传是古罗马恺撒大帝用来保护重要军情的加密系统。它是一种替代密码，通过将字母按顺序推后起3位起到加密作用，如将字母A换作字母D，将字母B换作字母E。据说恺撒是率先使用加密函的古代将领之一，因此这种加密方法被称为恺撒密码。

初始源码：能处理26个字母除xyz以外的字符的加密 

 plaincode = input("请输入明文: ")
  for p in plaincode:
    if ord("a") <= ord(p) <= ord("z"):
        print(chr(ord("a") + (ord(p) - ord("a") + 3)),end='')  #(ord(p) - ord("a") + 3)代表说a后面第几个字符
    else:
        print(p, end='')

改进源码：能处理所有26个字符的加密 

plaincode = input("请输入明文: ")
 for p in plaincode:
    if ord("a") <= ord(p) <= ord("z"):
        print(chr(ord("a") + (ord(p) - ord("a") + 3)%26),end='')
    else:
        print(p, end='')

下一节 Python字符串常用操作

取自“http://www.openbrains.net/mediawiki/index.php?title=Python字符串类型及其操作&oldid=10653”