06-数据类型的常用操作-字符串常用操作

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace'
string.encode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()	格式化字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.splitlines([keepends])	按照行('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.lower()	转换 string 中所有大写字符为小写.
string.upper()	转换 string 中的小写字母为大写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.strip()	删除 string 字符串两边连续的空格.
string.lstrip()	删除 string 字符串左边开头的空格
string.rstrip()	删除 string 字符串右边末尾的空格.
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.replace(str1, str2, num=string.count(str1))	把 string 中的 str1 替换成 str2,如果指定 num，则替换不超过 num 次.

"""基于%号+占位符，实现格式化输出"""

# 格式化输出一个数字
num = 10
print("%04d" % num)     # 0010

# 格式化输出浮点数
num = 3.5
print("%.2f元" % num)   # 3.50元

"""字符串.capitalize()"""
s1 = "hello world"
ret = s1.capitalize()
print(ret)       # Hello world

"""字符串.count(字符子串) 统计字符子串在字符串中出现的次数"""
s1 = "hello world"
ret = s1.count("l")
print(ret)  # 3

"""
字符串.encode()  # 编码，把一个字符串转换二进制安全格式字符串（bytes类型）
字符串.decode()  # 解码，把一个二进制安全格式字符串转换成普通字符串

encode和decode() 默认都有个encoding参数选项用于设置当前字符串的编码类型，默认是utf-8
常见于：网络传输的数据，跨平台传输的数据，从内存、硬盘中读取的数据、加密解密都可能是bytes类型
"""
s1 = "中文"
data = s1.encode()
print(data)  # b'\xe4\xb8\xad\xe6\x96\x87'

s2 = b'\xe4\xb8\xad\xe6\x96\x87'  # 声明一个bytes字符串
data = s2.decode()
print(data)  # 中文

# encode也可以用于转换字符编码
s1 = "你好"
data = s1.encode(encoding="gbk")
print(data)  # b'\xc4\xe3\xba\xc3'

# 如果字符串在编码的时候，设置了非utf-8，则字符串在解码的时候，也要使用对应的非utf-8编码，否则python会报UnicodeDecodeError编码解码错误
s2 = b'\xc4\xe3\xba\xc3'
data = s2.decode(encoding="gbk")
print(data)  # 你好

"""
字符串.endswith(字符子串)     # 判断字符串是否以字符子串结尾 
字符串.startswith(字符子串)   # 判断字符串是否以字符子串开头

字符串.find(字符子串)         # 获取字符子串在字符串的下标位置，找不到结果为-1，找到则返回首次出现的下标位置，从0开始 [不报错]
字符串.index(字符子串)        # 获取字符子串在字符串的下标位置，找不到则报错，找到则返回首次出现的下标位置，从0开始 [报错]
"""

# 判断某个人是否姓王
name = "王晓明"
if name.startswith("王"):
    print("你好，王先生！！")

name = "王晓明"
ret = name.startswith("明")
print(ret)  # False


# 判断某个人的名字是否以"明"结尾
name = "王晓明"
ret = name.endswith("明")
print(ret)  # True

# 判断是否是QQ邮箱
mail = "1234@qq.com"
ret = mail.endswith("qq.com")
print(ret)  # True


# 判断某个人的名字里面是否有"明"
name = "王晓明"
ret = name.find("张")  # -1
print(ret)
ret = name.find("王")  # 0
print(ret)
ret = name.find("明")  # 2
print(ret)

# 判断是否是一个合法的邮箱
mail = "1234@qq.com"
ret1 = mail.index("@")
print(ret1)  # 4
ret2 = mail.index(".")
print(ret2)  # 7
if ret1 < ret2:
    print("邮箱合法!")  # 邮箱合法!   以后用正则判断更为准确！当然要最准确的话，就要通过发送邮件来证明。

"""注意：find默认从左往右查找子串出现的第一个位置，如果希望从右往左查，则使用rfind"""
s1 = "hello world"
index = s1.find("l")
print(index)  # 2

s1 = "hello world"
index = s1.rfind("l")
print(index)  # 9

"""
判断字符串的组成成分
字符串.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
"""
s1 = "hello100"
ret = s1.isalnum()
print(ret)  # True

s1 = "hello+100"
ret = s1.isalnum()
print(ret)  # False


"""
字符串.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
"""
s1 = "123kl5k23k34"
ret = s1.isdecimal()
print(ret)  # False

# s1 = "12352.334" # 这种也为False
s1 = "12352334"  # 这种才是True
ret = s1.isdecimal()
print(ret)

"""字符串.isspace()  判断是否是空白字符串False，空格字符串True"""
s1 = ""  # 空字符串，False
ret = s1.isspace()
print(ret)

s1 = "  "  # 空格组成的，True
ret = s1.isspace()
print(ret)

"""
字符串 分割与合并
子串.join(序列)     # 合并序列中每一个成员，使用指定子串进行拼接一个字符串
字符串.split(子串)   # 使用子串作为分隔符，把字符串按子串分割成多段，组成一个列表[列表至少有一个成员]

字符串 转 列表     ---> 分割
列表/元组 转 字符串 ---> 合并
"""

data = ["北京市", "昌平区", "白沙路"]
ret = "--".join(data)
print(ret)  # 北京市--昌平区--白沙路

s1 = "北京市-昌平区-白沙路"
ret = s1.split("-")
print(ret)  # ['北京市', '昌平区', '白沙路']

# 如果无法分割，也不会报错，会把整个字符串作为一个整体，保存到列表中作为一个成员
s1 = "北京市-昌平区-白沙路"
ret = s1.split(":")
print(ret)  # ['北京市-昌平区-白沙路']

"""字符串.splitlines() 按行分割"""

# 假设这个字符串是在一个文件中读取出来
content = """君不见黄河之水天上来，奔流到海不复回。
君不见高堂明镜悲白发，朝如青丝暮成雪。
人生得意须尽欢，莫使金樽空对月。
天生我材必有用，千金散尽还复来。
烹羊宰牛且为乐，会须一饮三百杯。
岑夫子，丹丘生，将进酒，杯莫停。
与君歌一曲，请君为我倾耳听。
钟鼓馔玉不足贵，但愿长醉不复醒。"""

for item in content.splitlines():
    print(">>> ", item)

# >>>  君不见黄河之水天上来，奔流到海不复回。
# >>>  君不见高堂明镜悲白发，朝如青丝暮成雪。
# >>>  人生得意须尽欢，莫使金樽空对月。
# >>>  天生我材必有用，千金散尽还复来。
# >>>  烹羊宰牛且为乐，会须一饮三百杯。
# >>>  岑夫子，丹丘生，将进酒，杯莫停。
# >>>  与君歌一曲，请君为我倾耳听。
# >>>  钟鼓馔玉不足贵，但愿长醉不复醒。

"""
字母转换大小写
字符串.lower()  # 把字符串中的所有英文字母转换成小写
字符串.upper()  # 把字符串中的所有英文字母转换成大写
字符串.title()  # 把字符串中所有单词的首字母转换成大写
"""

s1 = "get"
ret = s1.upper()
print(ret)  # GET

s2 = "POST"
ret = s2.lower()
print(ret)  # post

s3 = "hello world"
ret = s3.title()
print(ret)  # Hello World

"""
字符串.strip() # 去除字符串的两边空格，注意：字符串中间的空格不会被删除，只会删除两边连续的空格
字符串.lstrip() # 去除字符串的左边空格，注意：字符串中间的空格不会被删除，只会删除左边连续的空格
字符串.rstrip() # 去除字符串的右边空格，注意：字符串中间的空格不会被删除，只会删除右边连续的空格
"""
s1 = "hello world"
print(len(s1), s1)  # 11 hello world

s2 = "   hello wolrd   "
ret = s2.strip()
print(len(ret), ret)  # 11 hello wolrd

s2 = "   hello wolrd   "
ret = s2.lstrip()
print(len(ret), ret)  # 14 hello wolrd

s2 = "   hello wolrd   "
ret = s2.rstrip()
print(len(ret), ret)  # 14 hello wolrd

"""
字符串替换
字符串.replace(旧子串, 新子串, 替换次数)
"""
# 默认是全部替换
s1 = "python37  python37"
ret = s1.replace("python", "java")
print(ret)  # java37  java37

# 也可以指定替换次数
s1 = "python37  python37"
ret = s1.replace("python", "java", 1)
print(ret)  # java37  python37

字符串格式化输出

format格式化

通过 {} 和 : 来代替之前的 % 。

"""format格式化"""

# 不设置指定位置，按默认顺序输出，一个花括号对应一个变量/数据
name = "小名"
age = 23
print("姓名：{} 年龄：{}".format(name, age))
# 姓名：小名 年龄：23

# 按索引位置指定输出
print("大家好，我是{1}岁的{0}".format(name, age)) # name下标为0,age下标为1
# 大家好，我是23岁的小名

# 按命名进行指定变量输出
print("姓名：{name} 年龄：{age}".format(age=15, name="xiaoming"))
# 姓名：xiaoming 年龄：15

# 打散字典成员
# **{"name": "小明", "sex": "男"} ---》 name="小明", sex="男"
# 当然上面的写法只能用于小括号中

print("姓名：{name}, 性别：{sex}".format(**{"name": "小明", "sex": "男"}))  # 星星打散字典进行key指定值
print("姓名：{name}, 性别：{sex}".format(sex="男", name="小明")) # 等同意思

data = ["小红", "女"]
print("姓名：{0[0]}, 性别：{0[1]}".format(data)) 
# 基于列表索引指定参数，data的索引本身是0，所以中括号左边的"0"是必须的

# 数值在format格式化中使用
print("{:.2f}".format(3.1415926))  # 3.14

print("{num:.2f}".format(num=3.1415926))  # 3.14

num = 3.1415926
print("{0:.2f}".format(num))  # 3.14

print("{:.2%}".format(0.14))  # 14.00%，百分比格式化

# 因为使用format以后，{}号会在字符串代表占位符的特殊作用，如果要单纯输出一个普通字符{}就要些2层花括号
print("{} 对应的位置是 {{0}}".format("小明"))  # 小明 对应的位置是 {0}

f字符串

f字符串，也叫字面量格式化字符串，是python3.6版本以后推出的格式化方式。

以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，python会将变量或表达式计算后的值替换到字符串中。

"""
字面量: 所谓的字面量，代表的就是固定数值或者固定数据，是一种常量，从字面意思就可以理解它的值。
100           # 这就是一个字面量
True/False    # 特殊的关键字也是字面量
"0"           # 数据本身就是字面量，但是注意：变量不是字面量
1+2           # 不是字面量，是表达式
"""

name = "小名"
print(f"我叫{name}")  # 我叫小名

# 输出复核类型数据，直接在{}里面写上中括号即可
data = {"name": "小明", "sex": "男"}
print(f"姓名：{data['name']}, 性别：{data['sex']}")
# 姓名：小明, 性别：男

x = 1
y = 0.14
print(f"{x:.2f}    {y:.2%}")  # 1.00    14.00%

# python3.8以后，新增了一个表达式结果输出的省略写法
x = 10
y = 20
print(f"{x+y=}")  # x+y=30

# 整数补0
x = 8
print(f"{x:02d}")  # 08