Python基础篇-----字符串

        在Python语言中，字符串是一个有序字符的集合。一个字符串被创建之后，其中的字符的相对位置就固定了。字符串和元组一样都属于不可变的数据类型。

1 字符串的创建

        我们可以使用引号('或者")来创建字符串。创建字符串的方式很简单，只用给变量分配一个值即可。

# 单引号
str1 = 'hello world!'
# 双引号
str2 = "I love you!"

        当我们分配变量的值比较多时，我们可以采用三引号('''或""")。

str1 = '''
		离离原上草，一岁一枯荣
		野火烧不尽，春风吹又生
	   '''

2.字符串的输入和输出

2.1 格式化输出

占位符	含义
%d	转为整数类型
%f	转为浮点型
%s	转为字符串型
%x	转为十六进制整数

一般的我们可以对占位符进行一定的修饰，常用的占位符的修饰。

（1）-号表示左对齐。

（2）.号表示小数点后的位数。

（3）0表示补前导0。

print("%02d" %3)		# 03
print('%.2f' % 3.1415)	# 3.14

        需要注意的是当我们想要表示%号的时候，我们可以采用%%来表示，不然很容易会出现与预期不一样的结果。

2.2 format()格式化输出

# 输出语句{[占位符]}".format("传入的参数")
age = 18
print("{}".format(age))
name = '张三'
print("我的名字是{},我今年{}岁了".format(name, age))
print("我的名字是{1},我今年{0}".format(name, age))

         我们不难发现format传入参数时会带有一定的次序，默认是从左到右一个一个填入，但如果我们自身规定顺序的话，那结果就会截然不同。

2.3 使用转义字符f也可以进行格式化输出

age = 18
name = "张三"
print(f'我今年{age}岁了，我的姓名是{name}')

         我们可以在输出字符串前加上f，这样Python解释器就能明白我们正在进行格式化输出。

2.4 输入input():

# 使用格式 变量名 = input()
name = input("请输入您的名字:")
print(name)
print(type(name))

         我们可以观察到input函数传入的是一个字符串，所以我们在对具体问题分析时需要考虑到这一点，比如我们想要输入年龄，我们都知道年龄是一个整数类型，因此我们需要在赋值的过程中进行类型转化。

age = int(input("请输入您的年龄"))
print(type(age))

 

3. 索引:   

      索引又成为下标，相当于字符串内的元素在字符串中的编号。比如我们取快递的时候就有一个取件码，然后我们可以通过取件码快速找到我们的快递。

        索引是从0开始的，因此索引的结束应该为字符串元素个数-1。索引又分为正向索引和反向索引。

	a	b	c	d	e
正向索引	0	1	2	3	4
反向索引	-5	-4	-3	-2	-1

4. 切片:

​            切片是指对操作的对象截取其中一部分的操作。字符串，列表，元组都支持切片操作。**

​    切片我们通常是利用索引来完成的，其格式如下:

# 变量名[开始:结束:步长] 从当前索引开始，一直到索引结束，但是不包含最后的索引值，步长就是隔多少个数取值
name = "hellopython"

print(name[2:5])			 # 从索引2开始，到5结束(但是不打印索引5的值)  打印llo

print(name[: 5])			 # 从索引0开始，到5结束(但是不打印索引5的值)  打印hello

print(name[1:])     		 # 从1开始，一直到结束，打印ellopython

print(name[:])			     # 打印全部元素

print(name[2:7:2])			 # 从索引2开始，到7结束(但是不打印索引7的值)，步长为2，打印loy 

5. 字符串的基本操作:

5.1 查找:

· in 和 not in : 用于判断某个字符串是否为待判断字符串的子串，返回的是bool型(True,False)

print('i' in 'iphone')			# True
print('p' not in 'apple')		# Flase

· find()：检测某个字符串是否包含在这个字符串当中，如果存在则返回这个字符串第一个匹配值最开始的位置下标，否则则返回-1。什么意思勒？举个例子吧:

var1 = 'abcde'					
print(var1.find('c'))		  # 2 从左到右匹配到c停止返回c的下标
var2 = '红鲤鱼与绿鲤鱼与驴'
print(var2.find('鲤鱼'))		 # 1 从左往右匹配，匹配到第一个鲤鱼停止匹配并返回鲤的下标，因为鲤的下标								# 是第一个匹配最开始的位置下标
var3 = 'abcde'
print(var3.find('f'))		  # 这个字符串不存在当前字符串中返回-1 

· index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

# 字符串序列.index(⼦串, 开始位置下标, 结束位置下标)
var = "hello python and hello world!!!"
print(var.index('and'))			# 返回从左到右第一个匹配and的下标  13
print(var.index('java'))		# 字符串中没有java发生报错
print(var.index('hello',10,25)) # 从索引10开始查找直到查找索引为25(但不包含25这一索引，返回第一个匹配的字符串)  17

· count()：返回某个子串在字符串中的出现次数

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

# 字符串序列.count(子串,开始，结束)
var = "红鲤鱼与绿鲤鱼与驴"
print(var.count("鲤鱼"))		# 若未设置开始以及结束位置，则默认从左到右全部查找  2
print(var.count("鲤鱼",3,8))	# 从索引3开始查找，到索引为8结束(不包括8这一索引)  1

拓展：

var = "红鲤鱼与绿鲤鱼与驴"
# rfind()：与find()功能相同。但查找的方向从右侧开始
print(var.rfind("鲤鱼"))		# 5
# rindex()：与index()功能相同，但查找方向为右侧开始
print(var.rindex("鲤鱼"))		# 5

5.2 修改

· replace()：替换内容

注意：替换次数如果超出⼦串出现次数，则替换次数为该⼦串出现次数。

# 字符串序列.replace(旧⼦串, 新⼦串, 替换次数) 
var = '红鲤鱼与绿鲤鱼与驴'
print(var.replace("鲤鱼","金鱼"))
print(var.replace("鲤鱼","金鱼",1))

注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

· split()：按照指定的字符进行分割，返回的是一个列表。

注意：num表示的是分割字符出现的次数。

# 字符串序列.split(分割字符, num)
var = '红鲤鱼与绿鲤鱼与驴'
print(var.split('鲤鱼'))
print(var.split('鲤鱼', 1))

 
· join()：用一个字符或子串合并字符串，也就是将多个串合并。

# 字符或⼦串.join(多字符串组成的序列)
li1 = ["hello", "python", "i", "love", "you"]		# 将列表转化为字符串，并用,分隔
t1 = ("hello", "python", "i", "love", "you")		# 将元组转化为字符串，并用，分隔
se1 = {"hello", "python", "i", "love", "you"}		# 将集合转化为字符串，并用，分隔
print(','.join(li1))
print(','.join(t1))
print(','.join(se1))

 

5.3 大小写转化

· capitalize()：将字符串第一个字符转化为大写

var = "hello python and hello world"
print(var.capitalize())

· title(): 将字符串每个单词首字母转化为大写

var = "hello python and hello world"
print(var.title())

· upper(): 将字符串中的小写转为大写

var = "hello python and hello world"
print(var.upper())

· lower(): 将字符串中的小写转为大写

var = "HELLO PYTHON AND HELLO WORLD"
print(var.lower())

· lstrip(): 删除字符串左侧空白字符，无参数默认为空格。

var = "    hello python and hello world      "
print(var.lstrip())				# 删除左侧空格

· rstrip(): 删除字符串右侧的空白字符，无参数传递默认为空格。

var = "    hello and python and hello world      "
print(var.rstrip())				# 删除右侧空格

· strip(): 删除字符串两侧的空白字符，无参数传递默认为空格。

var = "    hello python and hello world      "
print(var.lstrip())				# 删除两侧空格

· ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串 。

· rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。

· center()：返回⼀个原字符串居中,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。

# 字符串序列.ljust(⻓度, 填充字符)
var = "hello"
print(var.ljust(10,"_"))	# 左对齐
print(var.rjust(10,"_"))	# 右对齐
print(var.center(10,"_"))	# 居中对齐

 

5.4 判断

· startswith(): 检查字符串是否以传入子串作为开头(返回的是一个bool型)

# 字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标) 
var = "hello and python and hello world"

print(var.startswith("hello"))			# 开头是hello，返回True
print(var.startswith("and"))			# 开头不是and，返回False
print(var.startswith("and",6,20))		# 在索引6-20，开头是and,返回True

· endswith(): 检查字符串是否以传入子串作为结尾(返回的是一个bool型)

# 字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)
var = "hello and python and hello world"

print(var.endswith("and"))				# 结尾不是and，返回False
print(var.endswith("world"))			# 结尾时world，返回True
print(var.endswith("and",0,9))			# 在0到9的索引范围，是and结尾，返回True

· isalpha()：如果字符串所有字符都是字⺟则返回 True, 否则返回 False。

mystr1 = 'hello'
mystr2 = 'hello12345'

print(mystr1.isalpha())		# 结果：True
print(mystr2.isalpha())		# 结果：False

· isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

mystr1 = 'aaa12345'
mystr2 = '12345'

print(mystr1.isdigit())		# 结果： False
print(mystr2.isdigit())		# 结果：True

· isalnum(): 如果字符串所有字符都是字⺟和数字则返 回 True,否则返回False。

mystr1 = 'aaa12345'
mystr2 = '12345-'

print(mystr1.isalnum())		# 结果：True
print(mystr2.isalnum())		# 结果：False

· isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。

mystr1 = '1 2 3 4 5'
mystr2 = ' '

print(mystr1.isspace())		# 结果：False
print(mystr2.isspace())		# 结果：True

6. 字符串的运算

a = 'Hello' b = 'World'

+	字符串连接操作	print(a+b)	HelloWorld
*	字符串倍增操作	print(a*3)	HelloHelloHello
[]	字符串索引获取字符串元素操作	print(a[1])	e
[ : ]	字符串切片操作	print(a[1:5])	ello
in	成员运算符-如果字符串包含给定字符则返回True,否则返回False	print('e' in a)	True
not in	成员运算符-如果字符串不包含给定运算符则返回True,否则返回Flase	print('c' not in a)	True
r	取消转义（如\n,\t等）	print(r"\n\n\n")	\n\n\n
%	格式化字符串

        以上是我对字符串基础学习的总结，字符串的一些操作和方法确实是要比其他序列类型要多哈哈，如果大家发现本文中出现的问题，希望大家能够指明，我们共同学习探讨！！！