Python基础之字符串函数

Python基础之字符串函数

---

##1.字符串定义

(1)单引号

name = 'WXQ'
print(name)
# WXQ

(2)双引号

name = "WXQ"
print(name)
# WXQ

(3)三个双引号，保留格式

name = """
        这是我的名字
"""
print(name)
#
#         这是我的名字
#

---

2.字符串遍历

字符串可以看成是一个特别的字符列表，可以通过for-in直接遍历获取所有字符

name = "WXQ"
for item in name:
    print(item)
# W
# X
# Q

---

##3.字符串大小写转换

(1)str.capitalize():将首字母转换成大写，需要注意的是如果首字没有大写形式，则返回原字符串。

name = "wxq"
print(name.capitalize())
# Wxq
name = "王旭齐"
print(name.capitalize())
# 王旭齐

(2)str.lower():将字符串转换成小写，其仅对 ASCII 编码的字母有效。

name = "WXQ"
print(name.lower())
# wxq
name = "王旭齐"
print(name.lower())
# 王旭齐

(3)str.casefold()：将字符串转换成小写，Unicode 编码中凡是有对应的小写形式的，都会转换。

name = "wxq"
print(name.casefold())
# wxq
name = "ßwxq"
print(name.casefold())
# sswxq

(4)str.swapcase():大小写相互转换,注意：s.swapcase().swapcase() == s 不一定为真：

name = "WxQ"
print(name.swapcase())
# wXq

(5)str.title():将单词首字母大写，其判断“单词”的依据则是基于空格和标点，所以应对英文撇好所有格或一些英文大写的简写时，会出错。

name = "wxq is good"
print(name.title())
# Wxq Is Good
name = "wxq's computer is good"
print(name.title())
# Wxq'S Computer Is Good

(6)str.upper():将字符串转换成大写

name = "wxq"
print(name.upper())
# WXQ

---

##4.字符串格式输出

(1)str.center(width[, fillchar]):将字符串按照给定的宽度居中显示，可以给定特定的字符填充多余的长度，如果指定的长度小于字符串长度，则返回原字符串。

name = "WXQ"
print(name.center(100))
#                                                 WXQ
print(name.center(100, "-"))
# ------------------------------------------------WXQ-------------------------------------------------

(2)str.ljust(width[, fillchar]); str.rjust(width[, fillchar]):返回指定长度的字符串，字符串内容居左（右）如果长度小于字符串长度，则返回原始字符串，默认填充为 ASCII 空格，可指定填充的字符串。

name = "WXQ"
print(name.ljust(10))
# WXQ
print(name.ljust(10, "*"))
# WXQ*******
print(name.ljust(1))
# WXQ
print(name.rjust(10))
#        WXQ
print(name.rjust(10, "*"))
# *******WXQ
print(name.rjust(1))
# WXQ

(3)str.zfill(width):用 ‘0’ 填充字符串，并返回指定宽度的字符串。

name = "WXQ"
print(name.zfill(10))
# 0000000WXQ

(4)str.expandtabs(tabsize=8):用指定的空格替代横向制表符，使得相邻字符串之间的间距保持在指定的空格数以内。

name = "123\t456\t789"
print(name)
# 123	456	789
print(name.expandtabs())
# 123     456     789
print(name.expandtabs(6))
#123   456   789

(5)格式化字符串

(5-1) str.format(^args, ^^kwargs)

string = "我叫{0}，性别{1}，今年{2}岁".format("WXQ", "男", 22)
# 我叫WXQ，性别男，今年22岁
string = "我叫{name}，性别{sex}，今年{age}岁".format(name="WXQ", sex="男", age=22)
# 我叫WXQ，性别男，今年22岁
dic = {"name": "WXQ", "sex": "男", "age": 22}
string = "我叫{name}，性别{sex}，今年{age}岁".format(**dic)
# 我叫WXQ，性别男，今年22岁
print(string)

(5-2) str.format_map(mapping) 类似 str.format(*args, **kwargs) ，不同的是 mapping 是一个字典对象。

dic = {"name": "WXQ", "sex": "男", "age": 22}
string = "我叫{name}，性别{sex}，今年{age}岁".format_map(dic)
print(string)
# 我叫WXQ，性别男，今年22岁

---

##5.字符串搜索定位与替换

(1) str.count(sub[, start[, end]]):返回指定内容在字符串中出现的次数，起始位置和结束位置可选

string = "123abcdefgaaa--WXQ"
print(string.count("a"))
# 4
print(string.count("a", 6))
# 3
print(string.count("a", 0, 5))
# 1

(2) 字符串查找

(2-1) str.find(sub[, start[, end]]):返回从左到右字符串中查找内容第一次出现的索引，起始位置和结束位置可选

string = "123abcdefgaaa--WXQ"
print(string.find("a"))
# 3

(2-2) str.rfind(sub[, start[, end]]):返回从右到左字符串中查找内容第一次出现的索引，起始位置和结束位置可选

string = "123abcdefgaaa--WXQ"
print(string.rfind("a"))
# 12

(2-3)str.index(sub[, start[, end]]); str.rindex(sub[, start[, end]]):与 find() rfind() 类似，不同的是如果找不到，就会引发 ValueError。

string = "123abcdefgaaa--WXQ"
print(string.index("a"))
# 3
print(string.rindex("a"))
# 12
print(string.index("z"))
# ValueError: substring not found
print(string.rindex("z"))
# ValueError: substring not found

(3) 字符串替换 str.replace(old, new[, count])：将字符串中指定内容替换为新内容，替换个数可选，默认全部替换

string = "123abcdefgaaa--WXQ"
print(string.replace("a", "!"))
# 123!bcdefg!!!--WXQ
print(string.replace("a", "!", 1))
# 123!bcdefgaaa--WXQ

(4) 删除字符串中左右两端给定的字符

(4-1) str.lstrip([chars])：删除左端

string = "   !WXQ?***"
print(string.lstrip())
# !WXQ?***
print(string.lstrip(" !"))
# WXQ?***

(4-2) str.rstrip([chars]):删除右端

string = "   !WXQ?***"
print(string.rstrip("*"))
#    !WXQ?
print(string.rstrip("*?"))
#    !WXQ

(4-3) str.strip([chars]):删除两端

string = "   !WXQ?***"
print(string.strip())
# !WXQ?***
print(string.strip(" !?*"))
# WXQ

(5) static str.maketrans(x[, y[, z]]); str.translate(table):

maktrans 是一个静态方法，用于生成一个对照表，以供 translate 使用。
如果 maktrans 仅一个参数，则该参数必须是一个字典，字典的 key 要么是一个 Unicode 编码（一个整数），要么是一个长度为 1 的字符串，字典的 value 则可以是任意字符串、None或者 Unicode 编码。

a = 'dobi'
ord('o')
# 111
ord('a')
# 97
hex(ord('狗'))
# '0x72d7'
b = {'d':'dobi', 111:' is ', 'b':97, 'i':'\u72d7\u72d7'}
table = str.maketrans(b)
b.translate(table)
# 'dobi is a狗狗'

如果 maktrans 有两个参数，则两个参数形成映射，且两个字符串必须是长度相等；如果有第三个参数，则第三个参数也必须是字符串，该字符串将自动映射到 None：

a = 'dobi is a dog'
table = str.maketrans('dobi', 'alph')
a.translate(table)
# 'alph hs a alg'
table = str.maketrans('dobi', 'alph', 'o')
a.translate(table)
# 'aph hs a ag'

---

##6.字符串的联合与分割

(1)str.join(iterable):用指定的字符串，连接元素为字符串的可迭代对象。

print("-".join(["2018", "07", "23"]))
# 2018-07-23

(2)str.partition(sep); str.rpartition(sep):从左（右）查找第一个指定字符并分割，返回元组(不常用)

info = "http://www.baidu.com/av1.gif;http://www.baidu.com/av2.gif;http://www.baidu.com/av3.png"
print(info.partition(";"))
# ('http://www.baidu.com/av1.gif', ';', 'http://www.baidu.com/av2.gif;http://www.baidu.com/av3.png')
print(info.rpartition(";"))
# ('http://www.baidu.com/av1.gif', ';', 'http://www.baidu.com/av2.gif;http://www.baidu.com/av3.png')

(3)str.split(sep=None, maxsplit=-1); str.rsplit(sep=None, maxsplit=-1):从左（右）开始按照指定字符分割字符串，返回列表,最大分割次数可选，默认全部分割

info = "http://www.baidu.com/av1.gif;http://www.baidu.com/av2.gif;http://www.baidu.com/av3.png"
print(info.split(";"))
# ['http://www.baidu.com/av1.gif', 'http://www.baidu.com/av2.gif', 'http://www.baidu.com/av3.png']
print(info.rsplit(";"))
# ['http://www.baidu.com/av1.gif', 'http://www.baidu.com/av2.gif', 'http://www.baidu.com/av3.png']
print(info.split(";", 1))
# ['http://www.baidu.com/av1.gif', 'http://www.baidu.com/av2.gif;http://www.baidu.com/av3.png']
print(info.rsplit(";", 1))
# ['http://www.baidu.com/av1.gif;http://www.baidu.com/av2.gif', 'http://www.baidu.com/av3.png']

(4)str.splitlines([keepends]):字符串以行界符为分隔符拆分为列表；当 keepends 为True，拆分后保留行界符

info = "123\t456\r\n789"
print(info)
# 123	456
# 789
print(info.splitlines())
# ['123\t456', '789']
print(info.splitlines(keepends=True))
# ['123\t456\r\n', '789']

---

##7.字符串条件判断

(1)str.endswith(suffix[, start[, end]]):判断字符串是否以指定内容结束，起始位置和结束位置可选

string = "123aaa123"
print(string.endswith("123"))
# True
print(string.endswith("123", 3, 7))
# False

(2)str.startswith(prefix[, start[, end]]):判断字符串是否以指定内容开始，起始位置和结束位置可选

string = "123aaa123"
print(string.startswith("123"))
# True
print(string.startswith("123", 3, 7))
# False

(3)str.isalnum():判断字符串是否只有字符串和数字任意组合

string = "123abc"
print(string.isalnum())
# True
string = "$123abc"
print(string.isalnum())
# False

(4)str.isalpha():判断字符串是否只有字母或汉字等组成

string = "王旭齐"
print(string.isalpha())
# True
string = "123a"
print(string.isalpha())
# True

(5)str.isdigit():判断字符串是否由数字组成

string = "²" #平方符号
print(string.isdigit())
# True

(6)str.isdecimal():判断字符串是否由十进制数字组成

string = "10"
print(string.isdecimal())
# True
string = "²"
print(string.isdecimal())
# False

(7)str.isnumeric():判断字符串是否为数字或数字字符串

string = "⑩"
print(string.isnumeric())
# True

(8)str.isidentifier():判断字符串是否可为合法的标识符。

string = "class"
print(string.isidentifier())
# True
string = "1class"
print(string.isidentifier())
# False

(9)str.islower():判断字符串是否全为小写

string = "abc"
print(string.islower())
# True
string = "Ab"
print(string.islower())
# False

(10)str.isprintable():判断字符串的所有字符都是可打印字符或字符串为空。Unicode 字符集中 “Other” “Separator” 类别的字符为不可打印的字符（但不包括 ASCII 的空格（0x20））。

string = "123abc"
print(string.isprintable())
# True
string = "123\n"
print(string.isprintable())
# False

(11)str.isspace():判断字符串中是否至少有一个字符，并且所有字符都是空白字符。

string = ""
print(string.isspace())
# False
string = " "
print(string.isspace())
# True

(12)str.istitle():判断字符串中的字符是否是首字母大写，其会忽视非字母字符。

string = "Abc Def"
print(string.istitle())
# True
string = "Abc DEF"
print(string.istitle())
# False
string = "abc def"
print(string.istitle())
# False
string = "Abc def"
print(string.istitle())
# False

(13)str.isupper():判断字符串是否全为小写

string = "ABC"
print(string.isupper())
# True
string = "Ab"
print(string.isupper())
# False

---

##8.字符串编码解码

字符串编码

name = '静夜思'
# encode ：按照utf-8编码，将文本数据转换成二进制数据进行磁盘存储
name = name.encode('utf-8')
print(name)
# b'\xe9\x9d\x99\xe5\xa4\x9c\xe6\x80\x9d'

字符串解码

decode：将从磁盘中读取的数据按照utf-8进行解码显示数据

# 接上
print(name.decode('utf-8'))
# 静夜思