python 字符串类型

字符串的定义

字符串是一个有序的字符集合，用来存储和表现基于文本的信息。
python 中字符串需要使用成对的单引号或双引号括起来，单引号和双引号的字符串是等效的；python 中还允许使用三引号(“”" 或者 ‘’’ )或双引号创建跨越多行的字符串，这种字符串中可以包含换行符、制表符及其他特殊字符。

# 例如，我们分别创建一个单引号字符串和双引号字符串，内容一样，通过函数 id()返回两个字符串常量的地址，会发现结果是相同的，即：结果会返回yes
a = 'python'
b = "python"
if id(a) == id(b):print("yes")
else:print("no")
>yes# 字符串输出时会去掉最外面一层引号，所以若想在输出的字符串中包含某个引号，则：# 输出语句包含单引号，最外层则使用双引号;其他情况则类似
print("我的名字叫'小明'吗")
> 我的名字叫'小明'吗print('我的名字叫"小明"吗')
> 我的名字叫"小明"吗print('''我的名字叫"""小明"""吗''')
> 我的名字叫"""小明"""吗# 如果一个三引号字符串没有被赋值给变量，则它会被python解释器默认为注释，否则，则会被当做字符串常量
a = '''
大家好：我是\n小明\t的大舅哥的姐姐\n的妹妹！
'''
print(a)
> 大家好：我是
小明  的大舅哥的姐姐
的妹妹！

在 python 中，不支持字符类型，单个字符也是字符串。
字符串是序列数据类型，可以为每个字符分配一个数字来指代这个元素的位置，即可以使用索引和切片。同样的也支持双向索引。

str = 'pyhon is a wonderful language!'# 正向索引(从0开始)、反向索引(从-1开始)
a, b, c = str[0], str[10], str[-1]
print(a, '-', b, '-', c)   # 此时意外发现b的位置是一个空格，别以为是bug# 切片[start:end:step]
str_1, str_2, str_3 = str[1:5], str[-5:-1], str[3:-9]
print(str_1, '-', str_2, '-', str_3)# 带有步长的切片(省略start意味着从0开始，省略end则到末尾结束，省略step则步长默认为1)
str_4 = str[1::-1]    # 步长为-1则默认倒着往前跳
str_5 = str[::-2]     # 步长的大小决定由哪些字符被切片
print(str_4, '-', str_5)

python 中的字符串支持以下几种类型：
- Unicode字符串：不以u/U、r/R、b/B 开头的字符串（看这句就行），或以 u 或 U 开头的字符串。
- 非转义的原始字符串：以 r 或 R 开头
- bytes 字符串：以 b 或 B 开头
  可以使用 encode() 和 decode() 函数进行编码和解码，同样也可以使用 str() 和 bytes() 函数进行相同的操作。

# 字符串编码和解码print("Are you happy?")     # 普通字符串，本质是 Unicode 字符串
print(u"yes,i am")          # Unicode 字符串
print(r"d:\friends.txt")    # 非转义字符串的原始字符串
print(b"rejoice")           # bytes 字节串str = '中国'
print(bytes(str, "GBK"))    # 编译成字节串，采用 GBK 编码形式
print(bytes(str, 'utf-8'))  # 编译成字节串，采用 utf-8 编码形式# str(以 b 开头的字节流， 该字节流的编码方式)    # 还原为 Unicode 编码

字符串的创建

使用赋值运算符(=)创建字符串

其一般格式为：变量 = 字符串

language = 'python'

使用 str() 或 repr() 函数创建字符串

str() 或 repr() 函数的功能是将一个给定对象转换为字符串，其一般格式为：

'''其一般格式为：str(obj)  或 repr(obj)obj:要转换为字符串的对象，可以是数字，列表等各种对象repr()函数的用途更广泛，可以将任何 Python 对象转换为字符串对象
'''
>>> str(8.42)
'8.42'
>>> str(True)
'True'
>>> str([4,9,1,8])
'[4, 9, 1, 8]'>>> repr((32,5,4000,('Geogle','Runoob')))
"(32, 5, 4000, ('Geogle', 'Runoob'))"

字符串访问

三种方式：

字符串名。访问字符串名就是访问整个字符串。
字符串名[ index ]。访问字符串索引为 index 的字符。
切片访问。访问指定索引范围的字符序列。

str = 'sophiscated'>>> str     # 整个字符串
'sophiscated'
>>> str[1]   # 字符串索引为 1 的字符
'o'
>>> str[:4]  # 索引为 4 之前的所有字符
'soph'

字符串运算

操作符	描述
+	字符串连接
*	重复输出字符串
关系运算符（<, >, =, <=, >=）	按两个字符串的索引位置依次比较
in	如果字符串中包含给定的字符，则返回 True，否则返回 False
not in	如果字符串中不包含给定的字符，则返回 True，否则返回 False

# 字符串运算
str_1 = "my name is : " + "mark"   # + 运算符两边必须都是字符串，否则报错
str_2 = "love " * 3
str_3 = 'c' in 'cat'
str_4 = 'quite' > 'quiet'
print(str_1, str_2, str_3, str_4)

在 Python 中，除了可以使用关系运算比较两个字符串外，也可以使用标准库模块 Operator 中的函数比较字符串的大小。

函数	相当于
lt(a, b)	a < b
le(a, b)	a <= b
eq(a, b)	a == b
ne(a, b)	a != b
gt(a, b)	a > b
ge(a, b)	a >= b

其中，a、b 为要比较的两个对象，可以是字符串类型，也可以是其他对象类型

import operator
str1 = 'superman'
str2 = 'monster'
print("'superman' < 'monster':", operator.lt(str1, str2))
print("'superman' <= 'monster':", operator.le(str1, str2))
print("'superman' == 'monster':", operator.eq(str1, str2))
print("'superman' != 'monster':", operator.ne(str1, str2))
print("'superman' > 'monster':", operator.ge(str1, str2))
print("'superman' >= 'monster':", operator.gt(str1, str2))'''
如果只是需要比较两个字符串是否相等，则也可以使用字符串的内置函数 __eq__(),注意是上下画线。
其一般形式为：  str1.__eq__(str)
如果字符串 str1 和 str2 相等，则返回True， 否则返回 False
'''
print(str1.__eq__(str2))

字符串函数

字符串查找函数

函数	功能说明
str.find(subStr[, beg[, end] ] )	查找字符串 str 中是否包含子字符串 subStr，如果包含则返回 subStr 在 str 中第一次出现的位置索引值，否则返回 -1。beg 为查找开始位置， end 为查找结束位置
str.rfind(subStr[,beg[,end ] ])	功能同 str.find()，不同的是从右边开始查找
str.index(subStr[,beg[,end ] ])	查找字符串 str 中是否包含子字符串 subStr，如果包含则返回 subStr 在 str 中第一次出现的索引值，否则返回 -1。但是如果 subStr 不在 str 中则会报错
str.startwith(subStr)	检查 str 是否以指定字符串 subStr 开头，如果是则返回 True，否则返回 False
str.endwith(subStr)	检查 str 是否以指定字符串 subStr 结尾，如果是则返回 True，否则返回 False

str = '时间是一切财富中最宝贵的财富'
print("子字符串的位置: ", str.find("财富"))    # 从字符串左边开始查找
print("子字符串的位置: ", str.find("财富", 6))    # 从字符串左边索引为 6 的字符开始查找
print("子字符串的位置: ", str.rfind("财富"))    # 从字符串右边开始查找
print("子字符串的位置: ", str.rfind("财富", 4, 10))    # 从右边索引4~10的字符开始查找
print("字符串位置： ", str.rfind("成功"))         # 从字符串左边开始查找
print(str.startswith("时间"))
print(str.endswith("财富"))

字符串替换函数

函数	功能	参数说明
str.replace(oldStr, newStr [, max ] )	把字符串中的旧字符串替换成新字符串	oldStr 为将被替换的子字符串， newStr 为新字符串， max为替换最大次数

str = "贝多芬是世界闻名的航海家"
print(str.replace("贝多芬", "哥伦布"))'''
哥伦布是世界闻名的航海家
'''

字符串拆分函数

函数	功能	参数说明
str.split(sep=" ", num=string.count(str))	通过指定分隔符对字符串进行切片，返回一个字符串列表	sep 为分隔符，默认为空字符，包含空格、换行(\n)、制表符(\t)等。num 为分割次数

str = "Every cloud has a silver lining"
print(str.split())       # 使用默认分隔符拆分字符串
print(str.split(" ", 3))     # 使用默认分隔符拆分字符串为 4 个子字符串'''
['Every', 'cloud', 'has', 'a', 'silver', 'lining']
['Every', 'cloud', 'has', 'a silver lining']
'''

字符串转换函数

函数	功能说明
ord ( c)	与 chr() 函数一对与编码相关而功能相反的函数。返回单个字符的 Unicode 编码
chr（u）	返回 Unicode 编码对应的字符。如果所给的 Unicode 字符超出了 Python 定义范围，则会引发一个 TypeError 的异常

两个字符串之间的比较一般遵循如下规则：

如果都是西文字符串，则按照字符串每个字符的 ASCLL 编码逐个进行比较
如果都是中文字符串，则按照汉字的 Unicode 编码逐个进行比较
如果分别是汉字字符串和英文字符串，则统一按照它们的 Unicode 编码逐个进行比较，汉字字符串大于英文字符串

>>> print(ord('c'))
99
>>> print(ord('金'))
37329
>>> print(ord('输')>ord('赢'))
True
>>> print(chr(2345))
ऩ        # 这里显示有问题，应该是一个正方形，即方框

字符串格式化函数

一般格式	说明
格式化字符串.format(参数列表)	格式化字符串：包括参数序号和格式控制信息的字符串。

格式化控制信息可以是数据类型等，参数序号和格式控制信息包含在 { } 中。

# 字符串format 格式化
print("{:.2f}".format(3.1415926))    # 2 位小数
print("{:+.2f}".format(3.1415926))   # 带符号
print("{:0>2d}".format(6))         # 填充0，右对齐# 字符串format方式的使用，字符串里使用 {} 作为占位符
x = '我的名字是{}，我今年{}岁了'.format('小明',29)
print(x)# 使用 {整数} 作为占位符
print('我的名字是{1}，我今年{0}岁了'.format(10,'jerry'))# 使用 {变量名} 作为占位符
print('我的名字是{name}，我今年{age}岁了'.format(89,'xiaoming',name='jerry',age=45))# 使用 {整数} 和 {变量名}混合使用，在传递参数时，变量名必须要放在最后
print('我的名字是{1}，我今年{age}岁了。他是{name}，他今年{0}岁了'.format(12,'merry',name='jerry',age=15))# 使用 {} 和 {变量名} 混合使用
print('我的名字是{}，我今年{age}岁了。他是{name}，他今年{}岁了'.format('chris',18,name='tony',age=20))

其他常用字符串函数

函数	描述	符号	返回结果
capitalize()	将字符串的第一个字符转换为大写	“python”.capitalize()	Python
count(str, beg=0,end=len(str))	返回子字符串在 str 中出现的次数	“This is an apple”.count(“is”)	2
len(string)	返回字符串长度	len(“python”)	6
isdecimal()	检查字符串是否值包含十进制字符，如果是则返回True，否则返回 False	“128”.isdecimal() “12.8”.isdecimal()	True False
isdigit()	如果字符串只包含数字则返回 True，否则返回 False	“32”.isdigit() “32.3”.isdigit()	True False
upper()	将字符串中的小写字母转换为大写	“hello”.upper()	HELLO
lower()	将字符串中的大写字母转为小写	“HELLO”.lower()	hello
swapcase()	将字符串中的大、小写字符互换（大写变小写，小写变大写）	“Hello”.swapcase()	hELLO
strip()	删除字符串两端的空格	" python ".strip()	python（前后无空格）
rstrip()	删除字符串末尾的空格	" python ".rstrip()	python（前有空格后无）
lstrip()	删除字符串开头的空格	" python ".lstrip()	python（后有空格前无）
title()	返回"标题化"字符串，即首字母大写	“python”.title()	Python
Islower()	如果所有字符都是小写则返回 True，否则返回 False	“Scientist”.islower() “科学家”.islower()	False False
isupper()	如果所有字符都是大写则返回 True，否则返回 False	“Scientist”.islower() “科学家”.islower()	False False

转义字符

当需要在字符串中使用特殊字符时，Python 使用反斜杠（\）转义字符。

转义字符	描述	转义字符	描述
\	续行符（在行尾时）	\n	换行
\| 反斜杠符号	\v	纵向制表符
\’	单引号	\t	横向制表符
\"	双引号	\r	回车
\a	响铃	\f	换页
\ (空格)	退格（BackSpace）	\oyy	八进制数，yy代表的字符
\e	转义	\xyy	十六进制数，yy代表的字符
\000	空	\other	其他字符以普通格式输出

# 转义双引号可以 使：在双引号字符串输出中包含双引号
print("很多观众喜欢\"汉武大帝\"这部电视剧。")print("a = \t108")
print("d:\\b.py")

常量和变量

常量

常量一般指不需要改变也不能改变的常数或常量，如一个数字 3、一个字符串"中国"，一个元组(3,4,5)等。
Python 中没有专门定义常量的方式，通常使用大写变量名表示。但是，这仅仅是一种提示和约定，并不是强制语法要求。

PI = 3.14
E = 2.7

变量

1. 变量概述
在 Python 中，变量的是可以变化的。不仅值可以变，其类型也会随着值的不同而变化。（Python 是一种强制型语言，也是一种动态类型语言。Python 解释器会根据赋值或运算来推断变量类型，变量类型是随着其值随时变化的。）
在使用变量时，不需要提前声明，只需要给这个变量赋值即可。当给一个变量赋值时即创建对应类型的变量。当用变量时，必须要给这个变量赋值。如果只声明一个变量而没有赋值，则Python 认为这个变量没有定义。

m = 120
print("m 的数据类型：", type(m))
m = "大数据"
print("m 的数据类型：", type(m))

2、变量命名
可以参考该文章中的 Python 编码规范之标识符规则。

3. 变量赋值

变量只有在赋值之后才能在内存中被创建。Python 使用赋值运算符（=）给变量赋值，一般格式为：
变量1，变量2，变量3，… = 表达式1，表达式2，表达式3，…

表达式可以是常量、已赋值的变量或表达式，也可以是一个序列对象。
如果多个变量的值相同，也可以使用如下格式：
变量1 = 变量2 = 变量3 = … = 变量n = 表达式

counter = 68       # 赋值常量
counter_1 = counter     # 赋值变量
counter_2 = lambda x:x[1]    # 赋值表达式
x = y = z = 120# 交换两个变量的值
a = 50; b = 60
print("交换前：a = %d, b = %d " % (a, b))
a, b = b, a
print("交换后：a = %d, b = %d " % (a, b))

4. Python 内存和变量管理

在 Python 中，采用的是基于值的内存管理方式，每个值在内存中只有一份存储。如果给多个变量赋相同的值，那么多个变量存储的都是指向这个值的内存地址，即 id，也就说，Python 中的变量并没有存储变量的值，而是存储指向这个值的地址或引用。

a = 16.8
b = 16.8
print("a的id为: ", id(a))      # 输出变量a 的引用
print("b的id为: ", id(b))      # 输出变量b 的引用a的id为:  2698593166416
b的id为:  2698593166416

在本例中，a 与 b 均相当于存储 16.8 数值地址的引用，指向同一地址。
但是，对于组合数据（如列表、元组等）而言，每次创建一个组合数据对象，都会重新给其分配内存。因此，给具有相同内容的组合数据类型分配的内存地址不同。

x = [1, 2, 3, 4]
y = [1, 2, 3, 4]
print("id(x) = ", id(x))
print("id(y) = ", id(y))id(x) =  2225831982528
id(y) =  2225831945792

在 Python 中，给变量赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，Python 并没有复制这个对象，而只是复制了这个对象的引用。这对于所有数据类型（包括组合数据类型）是一样的。

a = 100
b = a        # 本质是 a 把指向 100 的地址复制给变量b
print("id(a): ", id(a))
print("id(b): ", id(b))id(a):  2744494329168
id(b):  2744494329168

由上图可见，执行 b = a 语句时复制给变量 b 的其实是 a 的地址，而不是 100 这个值。
Python具有自动内存管理功能，会跟踪所有的值，自动删除不再有变量指向的值。因此，Python 程序员一般不考虑内存管理的问题。

写在最后：
首先，如果本篇文章有任何错误，烦请读者告知！不胜感激！
其次，本篇文章仅用于日常学习以及学业复习，如需转载等操作请告知作者（我）一声！
最后，本文会持续修改和更新，如果对本分栏的其他知识也感兴趣，可以移步目录导航专栏，查看本分栏的目录结构，也更方便对于知识的系统总结！
兄弟姐妹们，点个赞呗！
感谢！笔芯！