20230409-Python-字符串-day6

Posted 阴阳怪气

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了20230409-Python-字符串-day6相关的知识，希望对你有一定的参考价值。

字符串

4月9

字符串是python中最常见的数据类型，我们可以使用单引号 \' \' 、 双引号 " " 、三引号 """ """ 来创建字符串，只要为变量分配一个值即可

#单引号
var1 = \'hello word\'

#双引号
var2 = "hello Python"

#三引号，可以换行，如果没有变量名，这就是一个多行注释
var3 = """ this is Python,
I lova Python"""

print(var1)
print(var2)
print(var3)

字符的输入输出

格式化输出

name = "yuwen"
age = 20
height = 175

print("我叫%s" % name)
print("今年 %d 岁" % age)
print("身高 %.2f cm" % height)
print("大家好，我叫，身高，年龄".format(name, age, height))
print(f"大家好，我叫name，今年age,身高height")

输入input()

>>> name =  input("请输入你的名字：")
请输入你的名字：yuwem
>>> print(name)
yuwem

>>> age = input("请输入你的年龄：")
请输入你的年龄：20
>>> print(age)
20

下标（索引）

下标 又叫 索引 就是编号。比如说火车座位号，座位号的作用：按照编号找到对应的座位

var = "hello word"
print(var[0])
print(var[1])
print(var[2])

#输出结果
>>>h
>>>e
>>>l

切片

切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作

  • 不包含结束位置下标对应的数据， 正负整数均可；
  • 步⻓是选取间隔，正负整数均可，默认步⻓为1。
name = "hello word"
print(name[2:5])        #从索引2开始，到5结束，不会拿到本身
print(name[2:5:1])      #从索引2开始，到5结束，步长为1，不会拿到本身
print(name[:5])         #从索引0开始一直到5，不会拿到本身
print(name[1:])         #从索引1开始一直到结束
print(name[:])          #取所有
print(name[::2])        #从索引0开始，取所有，步长为2
print(name[:-1])        #从索引0开始，到最后一个数结束，-1代表最后一个数，不包含-1本身
print(name[-4:-1])      #从倒数第四个开始，到倒数第一个结束，不包含-1本身
print(name[::-1])       #从-1开始，倒着打印字符串，步长为1
print(name[::-2])       #从-2开始，倒着打印字符串，步长为2
print(name[:-4:-1])     #从-1开始，倒着打印字符串，一直到-4，不包含-4本身，步长为1，

常用操作方法

字符串的常用方法有 查询 , 修改 ， 判断 三大类

查找

所谓字符串查找方法即是查找字符串的位子和出现的次数。

  • find()：检测某个字符串是否包含这个字符串中，如果在，返回字符在字符串中的下标位子，否则返回-1。

语法：

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

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

print(var.find("and"))           # 找到and，首字母的下标
print(var.find("and", 8, 20))    # 查找下标8-20中，以and首字母开始的
print(var.find("yuwen"))         # 查找"yuwen"，没有返回-1

#输出结果
6
17
-1
  • index()：检测某个字符串是否包含这个字符串中，如果在，返回字符在字符串中的下标位子，否则报异常

语法

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

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

print(var.index("and"))
print(var.index("and", 8, 20))
print(var.index("yuwen"))		# 查找ors，如果没有，则报错


#输出结果
   print(var.index("yuwen"))
ValueError: substring not found
6
17
  • count()：返回某个字符串在，字符串序列中出现的次数。

语法

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

# 字符串序列.count(⼦串, 开始位置下标, 结束位置下标) 

var = "hello and python and hello world"
print(var.count("and"))       #查找and在字符串序列中，出现的次数
print(var.count("ands"))      #如果没有，则返回0次
print(var.count("and",8,20))  #指定区间中，查找and字符出现的次数


#输出结果
2
0
1
  • **rfind(): ** find()功能相同，但查找⽅向为右侧开始。
  • rindex()：index()功能相同，但查找⽅向为右侧开始。
var = "hello and python and hello world"

# rfind()： 和find()功能相同，但查找⽅向为右侧开始。
print(var.rfind("and"))
print(var.rfind("ands"))

# rindex()：和index()功能相同，但查找⽅向为右侧开始。
print(var.rindex("and"))
print(var.rindex("ands"))

修改

对字符串当中的内容进行修改

  • repalec()： 替换内容

语法

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

var = "hello and python and hello world"

print(var.replace("and","abc"))     #默认替换所有配置的字符
print(var.replace("and","abc",1))   #将and替换为和，只替换一次


#输出结果
hello abc python abc hello world
hello abc python and hello world

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

修改后内存地址没有发生变化 :

可变类型 --没有变化

不可变类型 --地址变量

  • split()：按照指定的字符分割字符串

语法

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

var = "hello and python and hello world"

print(var.split("and"))     #以and为界，分隔开其他字符串，并且返回一个数组
print(var.split("a",1))       #以a为界，分隔开其他字符串，只分割一次，返回一个数组


#输出结果
[\'hello \', \' python \', \' hello world\']
[\'hello \', \'nd python and hello world\']
  • join()：用一个字符或者字符串合并，即将多个字符串合并为一个新的字符串

语法：

list1 = [\'hello\', \'and\', \'python\', \'and\', \'hello\', \'world\']
tuple1 = (\'hello\', \'and\', \'python\', \'and\', \'hello\', \'world\')
set1 = \'hello\', \'and\', \'python\', \'and\', \'hello\', \'world\'

print("_".join(list1))
print(",".join(tuple1))
print("|".join(set1))


#输出结果
hello_and_python_and_hello_world		 # 将列表转化为字符串，并且使用指定符号隔开	
hello,and,python,and,hello,world		 # 将元组转化为字符串，并且使用指定符号隔开
and|world|hello|python					 # 将集合转化为字符串，并且使用指定符号隔开

大小写转换

  • capitalize()：将字符串第⼀个字符转换成⼤写。
  • title()：将字符串每个单词⾸字⺟转换成⼤写。
  • upper()：将字符串中⼩写转⼤写。
  • lower()：将字符串中⼤写转⼩写。
  • lstrip()：删除字符串左侧空⽩字符。 了解即可
  • rstrip()：删除字符串右侧空⽩字符。 了解即可
  • strip()：删除字符串两侧空⽩字符。
var = "  hello And pyThon aNd hello world  "


print(var.capitalize())         #将字符串第一个字大写
print(var.title())              #将字符串单词首字母大写
print(var.upper())              #将字符串全部大写
print(var.lower())              #将字符串全部小写
print(var.lstrip())             #删除字符串左侧空白
print(var.rstrip())             #删除字符串右侧空白
print(var.strip())              #删除字符串量测空白


#输出结果
  hello and python and hello world  
  Hello And Python And Hello World  
  HELLO AND PYTHON AND HELLO WORLD  
  hello and python and hello world  
hello And pyThon aNd hello world  
  hello And pyThon aNd hello world
hello And pyThon aNd hello world
  • ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
  • rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
  • center()：返回⼀个原字符串居中,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串
var = "hello"

print(var.ljust(10,"_"))		#左对齐
print(var.rjust(10,"_"))		#右对齐
print(var.center(10,"_"))		#居中对齐


#输出结果
hello_____
_____hello
__hello___

判断

  • startswith()：检查字符串是否是以指定⼦串开头

语法

# 字符串序列.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()：检查字符串是否是以指定⼦串结尾

语法

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())		# 结果：False
  • 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

字符串运算

a = "Hello",b = "Python"

+ 字符串连接 >>>a + b \'HelloPython\'
[] 通过索引获取字符串中字符 >>>a[1] \'e\'
[ : ] 截取字符串中的一部分 >>>a[1:4] \'ell\'
in 成员运算符 - 如果字符串中包含给定的字符返回 True >>>"H" in a True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True >>>"M" not in a True
r 取消转义 >>>r“你\\n好” 你\\n好
% 格式字符串

Python基础day02：字符串

在Python中字符串本身有带很多操作，字符串的特性，不可以被修改

1、字符串的定义

1
2
3
4
5
6
7
8
9
10
11
12
#定义空字符串
name = ‘‘
#定义非空字符串
>>> name = "zhangqigao"
#通过下标访问
>>> name[1]
‘h‘
#不能修改字符串的值，否则会报错
>>> name[2] = ‘3‘
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: ‘str‘ object does not support item assignment

注：字符串如果修改的话，字符串所在的内存地址也跟着变化，所以不可被修改，但是对于列表来说，可以修改是因为列表的内存是不变的，可以直接在上面修改

2、切片

字符串其实和列表，元组一样，也是可以切片的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> name = "qigao zhang"
>>> name[1:4] #取1到4之间的字符，包括1，不包括4
‘iga‘
>>> name[1:-1] #取1到-1之间的字符，包括1，不包括-1
‘igao zhan‘
>>> name[0:3]
‘qig‘
>>> name[:3] #从头开始取，0可以省略，效果等同于name[0:3]
‘qig‘
>>> name[3:] #想取到最后一个值，必须不能写-1，只能这么写
‘ao zhang‘
>>> name[0::2] #后面的2表示：每隔一个字符就取一个
‘qgozag‘
>>> name[::2] #从头开始0可以省略，效果跟上一句一样
‘qgozag‘

3、首字母大写(capitalize())

1
2
3
>>> name = "qigao zhang"
>>> name.capitalize()
‘Qigao zhang‘

 4、统计(count(sub,start=None,end=None))

sub:统计的字符，start:开始位，end：结束位，start和end默认为空时,则表示全部字符中去统计

1
2
3
4
5
6
7
>>> name = "qigao zhangz"
#有开始和结束符
>>> name.count("z",1,5)
0
#从整个字符串中统计字符
>>> name.count("z")
2

 5、center(width,fillchar)

如果width（字符宽度）小于等于(<=)字符串的长度，则返回原字符串，如果大于(>)字符串的，则用fillchar（填满字符）填满，处理结果等于width，字符串位于fillchar的中间

1
2
3
4
5
6
7
8
9
10
11
>>> name = "qigao zhangz"
>>> len(name)
12
#10小于等于字符串宽度
>>> name.center(10,‘-‘)
‘qigao zhangz‘
#51大于字符串长度，并且字符串位于填充字符的中间
>>> name.center(51,‘-‘)
‘--------------------qigao zhangz-------------------‘
>>> len(name.center(51,‘-‘))
51

6、ljust(width,fillchar)

如果字符串的长度大于width（字符宽度），则返回原字符串，如果小于width，则用fillchar（填满字符）填满，处理结果等于width，fillchar位于字符串的最右边

1
2
3
4
5
6
7
8
9
10
11
>>> name = "qigao zhang"
>>> len(name)
11
#小于等于字符串的长度
>>> name.ljust(11,‘-‘)
‘qigao zhang‘
#大于字符串的长度
>>> name.ljust(50,‘-‘)
‘qigao zhang---------------------------------------‘
>>> len(name.ljust(50,‘-‘))
50

 注：ljust中的l表示left的意思，表示从右向左

7.rjust(width,fillchar)

如果字符串的长度大于width（字符宽度），则返回原字符串，如果小于width，则用fillchar（填满字符）填满，处理结果等于width，fillchar位于字符串的最左边

1
2
3
4
5
6
7
8
9
>>> name = "qigao zhang"
>>> len(name)
11
>>> name.rjust(11,‘-‘)
‘qigao zhang‘
>>> name.rjust(50,‘-‘)
‘---------------------------------------qigao zhang‘
>>> len(name.rjust(50,‘-‘))
50

 注：ljust中的l表示left的意思，表示从左向右

8、编码(encode)

字符串的编码和解码，在这边不用说了，我专门写了一篇博客，详细地址：猛击这里

9、endwith(suffix,start=None,end=None)

判断是否已suffix结尾，是返回True，否返回Fales

suffix：表示字符，start:开始位，end:结束位,start和end默认为空是，表示从整个字符串的结尾去判断

1
2
3
4
5
6
7
>>> name = "qigao zhang"
#start和end不为空
>>> name.endswith(‘g‘,1,5)
False
#默认为空
>>> name.endswith(‘g‘)
True

 10、find(sub,start=None,end=None)

全文查找sub中第一个字符所在整个字符串中的索引值,没有找到则返回-1

sub：字符或者字符串，start：开始位，end：结束位，start和end默认为空时，则在整个字符串中查找

1
2
3
4
5
6
7
8
9
10
>>> name = "qigao zhang"
#没找到，则返回-1
>>> name.find(‘zh‘,1,5)
-1
>>> name.find(‘q‘,2)
-1
>>> name.find(‘zh‘)
6
>>> name.find(‘zh‘,1,8)
6

11、rfind(sub,start=None,end=None)

从左向右查找sub中第一个字符所在整个字符串中的索引值,没有找到则返回-1

1
2
3
4
5
6
7
>>> name = "qigao zhang"
#找到
>>> name.rfind(‘q‘)
0
#未找到
>>> name.rfind(‘q‘,2)
-1

12、format()

这个函数就不用多少了，这个小主也专门写了一篇博客，更多用法，请：猛击这里

13、format_map()

数据格式，以字典形式传入

1
2
3
4
>>> name = "name:{name},age:{age}"
>>> name.format_map({‘name‘:‘zhangqigao‘,‘age‘:23})
#输出结果
‘name:zhangqigao,age:23‘

14、isalnum()

是否是一个阿拉伯数字和字母，它包含因为英文字符+(1-9)数字，中间不能有特殊字符

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> age = ‘23‘
>>> age.isalnum()
True
#有特殊字符的
>>> age = ‘2.3‘
>>> age.isalnum()
False
>>> age = ‘ab23‘
>>> age.isalnum()
True
>>> age = ‘ab‘
>>> age.isalnum()
True

 15、isalpha()

是否是一个纯的英文字符，包含大写

1
2
3
4
5
6
7
8
9
10
11
>>> age = ‘ab‘
>>> age.isalpha()
True
#夹着数字
>>> age = ‘ab23‘
>>> age.isalpha()
False
#大写
>>> age = ‘Ab‘
>>> age.isalpha()
True

 16、isdigit()

判断是否是一个整数，详情请见：猛击这里

17、isspace()

判断是否是一个空格

1
2
3
4
5
6
7
8
#不是空格
>>> age = ‘ age‘
>>> age.isspace()
False
#是空格
>>> age = ‘ ‘
>>> age.isspace()
True

 18、istitle()

 是否是一个标题(字符串中的每个单子首字母大写)

1
2
3
4
5
6
7
8
#每个单词的首字母是大写
>>> name = "Zhang Qi Gao"
>>> name.istitle()
True
#每个单词的首字母是小写
>>> name = "zhang qi gao"
>>> name.istitle()
False

 19、isupper()

是否是大写，注意字符串必须全部是大写才会返回True，否则返回False

1
2
3
4
5
6
7
8
#全部大写
>>> name="ZHANG"
>>> name.isupper()
True
#小写
>>> name="Zhang"
>>> name.isupper()
False

 20、join()

序列用某个字符拼接成一个字符串，注意的是，序列的元素必须是str类型

1
2
3
>>> a = [‘1‘,‘2‘,‘3‘]
>>> ‘+‘.join(a)
‘1+2+3‘

 21、lower()

字符串中的大写字母转换为小写字母

1
2
3
>>> name = "ZhangQiGao"
>>> name.lower()
‘zhangqigao‘

 22、upper()

字符串中的小写字母转换为大写字母

1
2
3
>>> name = "ZhangQiGao"
>>> name.upper()
‘ZHANGQIGAO‘

 23、strip()

去掉左右两边的空格（space）和回车（\\n）

1
2
3
>>> name = "   \\n zhangqigao    \\n"
>>> name.strip()
‘zhangqigao‘

 24、lstrip()

删掉左边到右的空格（space）和回车（\\n）

1
2
3
>>> name = "   \\n zhangqigao    \\n"
>>> name.lstrip()
‘zhangqigao    \\n‘

 25、rstrip()

删掉右边到左边的空格（space）和回车（\\n）

1
2
3
>>> name = "   \\n zhangqigao    \\n"
>>> name.rstrip()
‘   \\n zhangqigao‘

至此，方法前有l(left)和r(right)的函数，都是对之前函数的一个扩展，带l的表示至始至终从右到左操作，记住左边才是最终目的地，而带r的至始至终都是从左到右，因为右边才是它的终极目标

26、split()

分割函数，默认是以空格分割（space）生成一个列表,如果其他字符分割，输入其他字符参数

1
2
3
4
5
6
7
8
9
10
11
12
>>> name = "qigao zhang"
#默认为空，按空格分割
>>> name.split()
[‘qigao‘, ‘zhang‘]
>>> name = "qigao+zhang"
#以‘+‘字符分割
>>> name.split("+")
[‘qigao‘, ‘zhang‘]
#以‘\\n‘分割
>>> name = "qigao\\nzhang"
>>> name.split("\\n")
[‘qigao‘, ‘zhang‘]

 27、splitlines()

以换行符分割，这个一般在windows上开发，移到Linux上执行，或者在Linux上开发，移到Windows上执行，因为换行在windows上是"\\r\\n",linux上是‘\\n‘

1
2
3
>>> name = "qigao\\nzhang"
>>> name.splitlines()
[‘qigao‘, ‘zhang‘]

 28、swapcase()

把大写换成小写，把小写换成大写

1
2
3
>>> name = "ZHang"
>>> name.swapcase()
‘zhANG‘

29、startswith(prefix, start=None,end=None)

判断是否已prefix结尾，是返回True，否返回Fales

prefix：表示字符或者字符或者字符串，start:开始位，end:结束位,start和end默认为空是，表示从整个字符串的结尾去判断

1
2
3
4
5
>>> name = "zhang qigao"
>>> name.startswith("zhang") #开头找到"zhang" 字符串
True
>>> name.startswith("h",3,5)  #在索引3到5之间没有找到以字符‘h‘开头
False

30、replace(old,new[, max])

old:将被替换的子字符串; new:新字符串，用于替换old子字符串;max:可选字符串, 替换不超过 max 次

1
2
3
4
5
6
7
8
9
10
>>> name = "zhang is shuai ge"
>>> name.replace(‘is‘,‘was‘)
‘zhang was shuai ge‘
#原字符串没有改变
>>> name
‘zhang is shuai ge‘
>>> name.replace(‘is‘,‘was‘,0)
‘zhang is shuai ge‘
>>> name.replace(‘is‘,‘was‘,1)
‘zhang was shuai ge‘

31、zfill(width)

字符的长度是否大于等于（>=）with,如果比width小，则在字符串钱用0填充，如果>=width，则返回原字符串

1
2
3
4
5
6
7
8
9
>>> name = "zhangqigao"
>>> len(name)
10
#width大于字符串长度
>>> name.zfill(11)
‘0zhangqigao‘
#width小于等于字符串长度
>>> name.zfill(10)
‘zhangqigao‘

以上是关于20230409-Python-字符串-day6的主要内容，如果未能解决你的问题，请参考以下文章

day6,笔记内容

day6 数组元组字典

day6 字符编码和文件操作

Python学习记录day6

day6 bytes类型用法

python之路--day6--字符编码