python字符串操作

Posted 2023-03-29

参考技术A

字符串操作在各个计算机语言中都是比较常见的操作，下面我们对python的字符串操作做下简单介绍。

一、索引操作

字符串是由一些连续的字符组成，支持索引操作，索引位置从0开始，比如以下代码会输出’P‘字符：

二、截取子串

字符串也可以像列表那样给定起始与终止索引生成一个新的子串，比如以下代码会输出“Py”：

三、连接操作

多个字符串相加会生成一个新串，比如以下代码输出”Love Python“：

四、大小写转换

调用字符串的upper与lower方法会分别生成新的大写和小写的字符串，比如以下代码第一个输出：”I LOVE PYTHON“，第二个输出：”i love python“：

五、前后缀判断

调用字符串的startswith与endswith方法可以判断字符串是否以某个子串开关或者结尾，比如以下会分别打印出 ” python startswith py “ 和 ” python endswith on “：

六、查找与替换子串

调用find方法可以判断是否包含某个子串，比如以下代码会输出" python contains th" 和 " python doesn\'t contain he"：

调用replace方法可以对字符串进行替换，比如要把"hello world"中的”hello“替换为”world“，以下代码会输出：”world world“

七、分隔字符串

如果我们要把一句话按空格分隔为一个一个的单词要怎么做呢，这时调用split方法即可，比如以下代码会把”hello world ni hao“转换为["hello","world","ni","hao"]：

八、清除前后字符

如果一个字符串前后有空白字符，我们需要去掉，你可以调用字符串的替换方法来做，但更简单的做法是调用strip方法，比如以下代码就会去掉两端的空白字符输出“hello python”：

九、大小写对换

如果我们需要把字符串中的小写转换为大写，大写转换为小写，那要怎么做呢，很简单，调用下swapcase就可以了，如以下代码会输出“ heLLO pYThON ”：

十、字符分类判断

有很多方法用来判断一个字符串是否属于某个分类，比如 isdigit判断是否是数字，isalpha判断是否是字母，isalnum判断是否是字母数字等，如下代码：

python基础10 字符串操作,字典操作,集合操作

本节内容：

1. 字符串操作
2. 字典操作
3. 集合操作

字符串操作

概述

字符串是以‘‘或""括起来的任意文本，比如‘abc‘，"xyz"等等。请注意，‘‘或""本身只是一种表示方式，不是字符串的一部分，因此，字符串‘abc‘只有a，b，c这3个字符。

如果字符串本身包含‘怎么办？比如我们要表示字符串 I‘m OK ，这时，可以用" "括起来表示：

"I‘m OK"

类似的，如果字符串包含"，我们就可以用‘ ‘括起来表示：

‘Start to learn "Python" ‘

如果字符串既包含‘又包含"怎么办？

这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\\进行转义。

要表示字符串 Bob said "I‘m OK". 由于 ‘ 和 " 会引起歧义，因此，我们在它前面插入一个\\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

‘Bob said \\"I\\‘m OK\\".‘

注意：转义字符 \\ 不计入字符串的内容中。

常用的转义字符还有：

• \\n 表示换行
• \\t 表示一个制表符
• \\ 表示 \\ 字符本身

常用操作

首字母大写capitalize()

name = "my name is cathy wu"
print(name.capitalize())
结果是：
My name is cathy wu

统计 count（）

name = "my name is cathy wu"
print(name.count("a"))
结果是：
2

center()

将打印的放中间，不够50字符的用-补充.

name = "my name is cathy wu"
print(name.center(50,"-"))
结果是：
---------------my name is cathy wu----------------

endswith()和startswith()

endswith()判断字符串以什么结果，比如判断邮件是否以.com结尾。startswith()判断字符串以什么开头。

name = "my name is cathy wu"
print(name.endswith("wu"))
print(name.startswith("name"))
结果是：
True
False

expandtabs（）

将tab键转换成多少个空格

name = "my name \\tis cathy wu"
print(name.expandtabs(tabsize=30))
结果是：
my name                       is cathy wu

find()

查找字符比如y的索引

name = "my name is cathy wu"
print(name.find("y"))
结果是：
1

name = "my name is cathy wu"
print(name.find("name"))
结果是：
3

name = "my name is cathy wu"
print(name[name.find("name"):])
结果是：
name is cathy wu

format

格式化输入：

name = "my name is {name} and I m {age}"
print(name.format(name="cathy",age=30))
结果是：
my name is cathy and I m 30

format_map

数据字典格式，很少用。

name = "my name is {name} and I m {age}"
print(name.format_map({"name":"cathywu","age":30}))
结果是：
my name is cathywu and I m 30

isalnum()

判断输入的所有字符都是字母数字，则返回true。 在输入的所有字符中至少有一个字符，否则为false。

print("ABC123".isalnum())
print("".isalnum())
print("[email protected]".isalnum())
结果是：
True
False
False

isdecimal()

判断是否10进制

print("1".isdecimal()) 
结果是：
True

isdigit()

print("1A".isdigit())  
结果是：
False

isidentifier()

判断是不是一个合法的标识符，是不是一个合法的变。

print("1A".isidentifier())
结果是：
False

islower()

判断是否小写

print("1A".islower())                       结果是：
False

print("abc".islower())
结果是：
True

isspace()

判断是否为空格。

print("abc".isspace())       
结果为
False

istitle()

判断字符串是不是一个titlecased字符串

print("My Name Is".istitle())   
 print("My name Is".istitle())   
 结果是
 True 
 False

isprintable()

判断是否可以打印

print("My name Is".isprintable())            结果是
True

join（）

将列表连接成字符串

print("+".join(["1","2","3","4"]))
结果是
1+2+3+4

ljust(）

保证长度如50，不够用*补上

name = "my name is cathy wu"  
print(name.ljust(50,‘*‘)) 
结果是
my name is cathy wu*******************************

rjust()

保证长度如50，不够用*补上

name = "my name is cathy wu" 
print(name.rjust(50,‘*‘))  
结果是
*******************************my name is cathy wu

lower()

将输入的变成小写。

print(‘CATHY‘.lower()) 
结果是
cathy

upper()

小写变大写

print(‘Cathy‘.upper())                       结果是
CATHY

lstrip()

从左边去掉空格

print(‘\\n  Cathy‘)         
print(‘\\nCathy‘.lstrip())    
结果是

  Cathy
Cathy

maketrans（）

用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。可以用于随机密码。 注：两个字符串的长度必须相同，为一一对应的关系 在Cathy里面按照abcdef对应找到123456。

p = str.maketrans(‘abcdef‘,‘123456‘)         print("cathy".translate(p))   
结果是
31thy

replace()

字符替换。 如：将小写的c换成大写的C。

print(‘cathy‘.replace(‘c‘,‘C‘,1)) 
结果是
Cathy

rfind()

找到对应值的下标最大值。

print(‘CathyCathy‘.rfind("a"))              print(‘CathyCathyCathy‘.rfind("a"))
结果为
6
11

split()

按照制定的分割成列表，如按空格分.

print(‘cahty wu 33 it‘.split())
print(‘1cahtywu2cahtywu3cahtywu‘.split(‘u‘))
结果为:
[‘cahty‘, ‘wu‘, ‘33‘, ‘it‘]
[‘1cahtyw‘, ‘2cahtyw‘, ‘3cahtyw‘, ‘‘]

print(‘1+2\\n+3+4‘.split(‘\\n‘))   
print(‘1+2\\n+3+4‘.splitlines())  
结果为:
[‘1+2‘, ‘+3+4‘]
[‘1+2‘, ‘+3+4‘]

swapcase()

将输入的值大写换成小写，小写换成大写拷贝作为一个副本。

print(‘CathyCathy‘.swapcase())
结果为：
cATHYcATHY

zfill()

从左边的零填充数字字符串，以填充到字段 指定宽度的。字符串不会被截断。

print(‘cathywu‘.zfill(50))
结果为：
0000000000000000000000000000000000000000000cathywu

字典操作

概述

字典dict也是集合，是无序的。花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

常用操作

增加

info = { ‘stu1701‘:‘jack‘, ‘stu1702‘:‘rose‘, ‘stu1703‘:‘lucy‘, }

修改

info[‘stu1701‘] = ‘mike‘

删除

1. 方法一 必须填写参数，如果key不存在，会报错。 如果key存在则删除。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
del info[‘stu1707‘]

显示结果：
del info[‘stu1707‘]
KeyError: ‘stu1707‘

2. 方法二 必须填写参数。 如果key存在则删除。 ```

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
del info[‘stu1701‘]
print(info)

显示结果：
{‘stu1702‘: ‘rose‘, ‘stu1703‘: ‘lucy‘}

3. 方法三 参数不用填写，随机删除一个。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
info.popitem()
print(info)
结果是：
{‘stu1702‘: ‘rose‘, ‘stu1703‘: ‘lucy‘}

4.方法四 pop()

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
info.pop(‘stu1701‘)
print(info)
结果是：
{‘stu1703‘: ‘lucy‘, ‘stu1702‘: ‘rose‘}

查找

1. 方法一

确定知道key才用这种法查找，如果查找的key 不存在，则会报错。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(info[‘stu1705‘])
结果是
    print(info[‘stu1705‘])
KeyError: ‘stu1705‘

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(info[‘stu1702‘])
结果是：
rose

2. 方法二 如果key不存在，返回none,如果存在返回这个key的value。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(info.get(‘stu1705‘))
print(info.get(‘stu1703‘))
结果是：
None
lucy

3. 返回是否存在于字典中。 如果存在 则返回true 如果不存在返回false。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(‘stu1704‘ in info)
print(‘stu1701‘ in info)
结果是
False
True

注意： 这种方法只在python3里面， pyhon2 里面是info.has_key(‘stu1704‘)

嵌套

多级字典嵌套及操作 future = { ‘商品期货‘:{ "农产品期货":[‘大豆‘,‘小麦‘,‘玉米‘], "金属期货":[‘铜‘,‘铝‘,‘铅‘], "能源期货":[‘原油‘,‘汽油‘,‘燃料油‘] }, ‘金融期货‘:{ "股指期货":[‘香港恒生指数‘,‘沪深300指数‘,‘英国FTSE指数‘], "利率期货":[‘长期利率期货‘,‘短期利率期货‘], "外汇期货":[‘是一种在最终交易日按照当时的汇率将一种货币兑换成另外一种货币的期货合约‘] }, ‘贵金属期货‘:{ "黄金期货":[‘au1706‘,‘au1709‘], "白银期货":[‘ag1703‘,‘ag1709‘] } } 修改 future["贵金属期货"]["白银期货"][0]="ag1706"

其他操作

1. values

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(info.values())
结果是：
dict_values([‘jack‘, ‘rose‘, ‘lucy‘])

2. keys

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(info.keys())
结果是：
dict_keys([‘stu1703‘, ‘stu1702‘, ‘stu1701‘])

3. items

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
print(info.items())
结果是：
dict_items([(‘stu1701‘, ‘jack‘), (‘stu1703‘, ‘lucy‘), (‘stu1702‘, ‘rose‘)])

4. setdefault 去字典里取key的值，如果取到就返回对应的value，如果取不到，就新增一项，并且赋予后面的值。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
info.setdefault(‘stu1706‘,‘lily‘)
print(info)
结果是：
{‘stu1702‘: ‘rose‘, ‘stu1701‘: ‘jack‘, ‘stu1706‘: ‘lily‘, ‘stu1703‘: ‘lucy‘}

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
info.setdefault(‘stu1706‘,‘lily‘)
print(info)
结果是：
{‘stu1702‘: ‘rose‘, ‘stu1703‘: ‘lucy‘, ‘stu1701‘: ‘jack‘}

5. update 两个dict之间的操作，如果有交叉的就更新，没有的就合并，合并两个字典。

info = {
    ‘stu1701‘:‘jack‘,
    ‘stu1702‘:‘rose‘,
    ‘stu1703‘:‘lucy‘,
}
b={‘stu1701‘:‘lily‘,
   1:3,
   2:5
   }
info.update(b)
print(info)
结果是：
{‘stu1701‘: ‘lily‘, 1: 3, 2: 5, ‘stu1702‘: ‘rose‘, ‘stu1703‘: ‘lucy‘}

6. 通过一个列表生成默认dict fromkeys（）通过一个列表生成默认dict，有两个参数，以一个值初始化这个字典。

c = dict.fromkeys([6,7,8],"test1")
结果是：
{8: ‘test1‘, 6: ‘test1‘, 7: ‘test1‘}

循环

1. 方法1 for i in info: print(i,info[i])

2. 方法2 for k,v in info.items(): print(k,v)

方法2会先把dict转成list,。如果数据量大的话，转换非常缓慢。

集合操作

概述

集合set 持有一系列元素，这一点和 列表list 很像，但是set的元素没有重复，而且是无序的，这点和字典 dict 的 key很像。 它的主要作用如下：

去重，把一个列表变成集合，就自动去重了 关系测试，测试两组数据之前的交集、差集、并集等关系。

常用操作

创建

list_1 = [1,2,3,4,5]
list_1 = set(list_1 )
list_2 = set([7,2,6,4,8])
print(list_1,list_2)
结果是：
{1, 2, 3, 4, 5} {8, 2, 4, 6, 7}

t = set("hello") #创建一个唯一字符的集合
结果是：
{‘o‘, ‘h‘, ‘e‘, ‘l‘}

常用操作

1. 交集 b = t & s # t 和 s的交集

list_1 =set([1,2,3,4,5])
list_2 = set([7,2,6,4,8])
print(list_1.intersection(list_2))
print(list_1 & list_2)
结果是：
{2, 4}
{2, 4}

2. 并集 a = t | s # t 和 s的并集

list_1 =set([1,2,3,4,5])
list_2 = set([7,2,6,4,8])
print(list_1.union(list_2))
print(list_1 | list_2)
结果是：
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}

3. 差集 c = t – s #求差集（项在t中，但不在s中）

list_1 =set([1,2,3,4,5])
list_2 = set([7,2,6,4,8])
print(list_1.difference(list_2))
print(list_1 - list_2)
结果是：
{1, 3, 5}
{1, 3, 5}

4. 对称差集

d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）

list_1 =set([1,2,3,4,5])
list_2 = set([7,2,6,4,8])
print(list_1.difference(list_2))
print(list_1 - list_2)
结果是：
{1, 3, 5, 6, 7, 8}
{1, 3, 5, 6, 7, 8}

5.子集，父集

list_1 =set([1,2,3,4,5])
list_3 = set([1,2])
print(list_3.issubset(list_1))
print(list_1.issuperset(list_3))
结果是：
True
True

6. 判断交集是否为空 如果交集为空返回true

list_1 =set([1,2,3,4,5])
list_2 = set([7,2,6,4,8])
list_4 = set([7.8])
list_5 = set([3.5])
print(list_1.isdisjoint(list_2))
print(list_4.isdisjoint(list_2))
print(list_5.isdisjoint(list_2))
结果是：
False
True
True

7. 增加

• add only one

list_1 =set([1,2,3,4,5])
list_1.add(11)
print(list_1)
结果是：
{1, 2, 3, 4, 5, 11}

• add many data

list_1 =set([1,2,3,4,5])
 list_1.update([22,33,55])
 print(list_1)
 结果是：
{1, 2, 3, 4, 5, 33, 22, 55}

8. 删除

• remove()

list_1 =set([1,2,3,4,5])
list_1.remove(1)
print(list_1)
 结果是：
{2, 3, 4, 5}

• pop()随机删除并把删除的元素返回

t = set("hello")
print(t.pop())
结果是：
l

• discard()

t = set("hello")
t.discard(‘e‘)
print(t)
结果是：
{‘l‘, ‘o‘, ‘h‘}

9. len() 返回长度

t = set("hello")
list_1 =set([1,2,3,4,5])
print(len(t))
print(len(list_1))
结果是：
4
5

列表，元组，集合，字典的区别和相互转换

列表是一组值，其中的值可以改变。

lst = [‘arwen‘,123]

元组也是一组值，其中的值不能改变。

tup = (‘arwen‘,123)

列表与元组可以相互转换。

集合是一组唯一的无顺序的值。

#定义一个集合
list1 = [6, 7, 7, 8, 8, 9]
set2 = set(list1)

字典是无固定顺序的键值对。

Dic={1:’monday’,2:’Tuesday’}

参考网页

http://www.imooc.com/code/3269 http://www.cnblogs.com/alex3714/articles/5717620.html