Python 基本数据类型(二): 字符串类型

版权声明：转载请注明来源及作者，谢谢！ https://blog.csdn.net/qq_42442369/article/details/84322707

content

• 字符串的创建
• 转义序列
• 字符串的操作
• 字符串的相关方法

字符串类型

1. 字符串的创建

# 单引号、双引号、三引号
# python2习惯使用单引号，python3之后习惯使用双引号
#单引号、双引号来定义字符串作用几乎一样
a="hello"
b='hello'
print(a,b)
print(id(a),id(b))
# hello hello
# 2133525250488 2133525250488

# 单双引号交替使用可以达到输出对方的目的
# print("i am "ok"")
# invalid syntax

print('i am "ok"')
# 没问题 i am "ok"
print("i am 'ok''")
# 注意：没问题 i am 'ok''

a="ddd" \
  "dd"
print(a)
# ddddd
# 注意：\ 代表续行符，当字符串定义的时候内容太多 ，需要换行，可以使用续行符连接

# 三引号，在定义的时候，直接包含换行
# 被使用当做多行注释

a="锄禾日当午，\n汗滴禾下土"
print(a)
# 锄禾日当午，
# 汗滴禾下土
# 注意：\n 代表换行符

b="""
锄禾日当午，
汗滴禾下土
"""
print(b)
# 锄禾日当午，
# 汗滴禾下土

2. 转义序列

# 当在定义字符串的时候，希望输出一些特殊的符号
# \ 转义
print("i am \"ok\"")
# i am "ok"
# 如果不加\就会报错

# \r 重启一行(在linux使用)
print("aaaaa\rbbbb")
# bbbb

# \t制表符
print("aaaa\tbbbb")
# aaaa	bbbb

3. 字符串的操作

（1）运算符

# 支持的运算符 +  *   in   not in    is   is not   ==   >   <
# + 两个字符串的拼接，新创建字符串进行拼接
a="abc"
b="def"
print(a+b)
print(a,b)
print("abc"+"def")
# abcdef
# abc def
# abcdef

# * 字符串的重复，新创建字符串进行重复
a="abc"
b="def"
print(a*3)
print(a*2+b*3)
print(a,b)
a=a*3
print(a)
# abcabcabc
# abcabcdefdefdef
# abc def
# abcabcabc

# in not in 判断元素是否在字符串对象中
# in not in 判断元素是否在字符串对象中
a="abc"
b="def"
print("ac" in  a)

# is is not 判断是否是同一个内存（是否是一个人？）
a="abc"
b="def"
print(a is b)
print(id(a),id(b))
# False
# 1644523122112 1644553432064
# 注意： 如果都是'abc'，就是true

a = [1,2,3]
b = [1,2,3]
print(a is b)
print(id(a),id(b))
# False
# 2787243656136 2787243768648

# 总结：可变数据类型python不同id，不可变数据类型python 一样的id(py聪明)

# ==判断的是内容是否相等（长的是否一样？）
# print(a ==b)

# 总结：is 和== : 如果is返回True，==一定返回True

#>  < 按照元素逐个比较，按照元素的ascii码比较
print("abc"<"z")
# ord()
print(ord("a"))
print(ord("b"))
print(ord("c"))
print(ord("Z"))
# True
# 97
# 98
# 99
# 90

# len()函数 显示object对象的长度
a="hello"
# print(len(a))

ascii码图：

（2）索引

# 访问字符串中单个元素
# 语法：字符串名[index]
# index 是索引值，正数、负数、0
a="abcdefg"
# print(a[0])
# print(a[2])
# print(a[-1])
# print(a[100]) # string index out of range

b=""
print(len(b)) # 0
print(b[0]) # string index out of range

索引有界限，越界报错
# a="hello"
#索引的界限  -len(object),len(object)-1   -6, 5

# 字符串的元素不能修改
重要！ 字符串、数值、布尔、字节是不可变的数据类型
a="hello"
print(a[1])
a[1]="i"
print(a[1])
# 'str' object does not support item assignment

（3）切片

# 访问字符串中一定区域的多个元素
# 语法：字符串名[start:end:step]
# start: 起始位置，正数（从左到右），负数（从右到左），默认值0
# end: 终止位置，默认值len(object)
# step:步长，默认1 ，正数（从左到右），负数（从右到左）
# 切片：从start位置开始，到end位置结束（不包含end），按照步长获取字符串中的元素
# start end  step都可以 正数、负数，但是要注意方向保持一致，否则无法截取到数据

a="abcdefg"
print(a[0:len(a)])
print(a[0:7])
# abcdefg
# abcdefg

# a[2:5] 截取元素的个数end-start
print(a[0:3])
print(a[0:3:2])

print(a[0:3:-2]) # 空，无结果，无报错，因为start必须小于end

print(a[4:0:-2]) # ec，按照顺序取，因为方向反了，start必须大于end
# print(a[:5])
# print(a[2:])
# print(a[2:7])
# print(a[-100:100]) # 切片的start和end是可以越界的，而索引不行

a="abcdefg"
# 整切片，字符串、字节的整切片是就原来对象的本身，不会重新创建。
# print(a[:])
# 逆序输出
# print(a[::-1])
b=a[:]
print(a ==b) # True
print(a is b) # True
print(id(a),id(b),id(a[0:2])) # 第三个不是整切片
# 1879645995448 1879645995448 1879645995616

# 练习：
# 2018-10-10使用切片获取年月日
d="2018-10-10"
print("年",d[:4])
print("月",d[5:7])
print("日",d[8:])

a="hello"
print(a,type(a))
# 字符串对象中的方法带有self，self代表当前对象自己，当调用方法的时候，不需要考虑self

4. 字符串的相关方法

a="hello"
print(a,type(a))
# 字符串对象中的方法带有self，self代表当前对象自己，当调用方法的时候，不需要考虑self

（1）count()

# a.count(x,start,end)
# x是要统计的字符串
# start：起始位置 ，0
# end：终止位置，len(str)
# 包含起始位置，不包含结束
a = 'hello'
print(a.count("l",1,5)) # 2
print(a.count("l",1,15)) # 2
print(a.count("0",0,1)) # 0

（2）index()

# 关于索引的方法找不到都会报错。
# a.index(sub,start,end)
# sub：要查找的子串
# start 、end：起始和终止
# 返回值：位置
a="hellohellohello"
# print(a.index("l"))
# print(a.index("l",5))
# # print(a.index("l",50))

（3）find()

# 同index，找不到不会报错（脾气好），返回-1
# 从左到右检索查找
# a="hellohellohello"
# print(a.find("p"))
# print(a.find("e"))
# # rfind和rindex都是从右向左查找
# print(a.rfind("e"))

# 还可后面加索引的start和end

（4）join()

# 拼接 a.join(迭代对象)：使用a将迭代对象中的每一个元素进行拼接
# print("-".join("abc"))

# 应用场合
li=["1","2","3"]
print("".join(li))
li=["1","2","3"]
print("".join(li))
# 123

（5）replace()

# a.replace(old,new,count)
# old 要替换的字符串
#new 要替换成的字符串
# count 替换的最大次数，默认全部替换
# a="hellohellohello"
print(a.replace("e","x",1))
print(a.replace("e","x",10))
# 注意：替换后的字符串是新创建的。

（6）strip()

从两端去掉、剪切，参数字符串
# 会将两端符合参数的字符串去掉，直到遇到不符合的字符串为止
a="hellohellohellohoh"
print(a.strip("h"))
# ellohellohelloho

print(a.strip("ho"))
# ellohellohell 会将两端符合参数的字符串去掉，直到遇到不符合的字符串为止
print(a.strip("e"))
# hellohellohellohoh
print(a.strip("heo"))
# llohellohell
print(a.strip("hoe"))
# llohellohell 和上面结果一致，所以是不管顺序的

# 左剪切和右剪切
print(a.lstrip("h"))
print(a.rstrip("h"))

（7）split()

# 切割，切割字符，被切割之后，就没有了
# 重要：返回值是列表

# a="ab cd ef gh"
# print(a.split(" ")) ## ['ab', 'cd', 'ef', 'gh']

# b="abdcaabcabcddabddd" 
# print(b.split("a")) ## ['', 'bdc', '', 'bc', 'bcdd', 'bddd'] # 边上的元素拆完了，前面就为空了

# b.split(sep,maxsplit) # maxsplit最大切割次数
b="abdcaabcabcddabddd"
print(b.split("a",2)) 
# ['', 'bdc', 'abcabcddabddd'] 只切了两次a 第一次 第二次
print(b.split("a",20))
# ['', 'bdc', '', 'bc', 'bcdd', 'bddd']

# 注意：切割空白，不传入参数，默认将所有空白都切除
# a="ab cd  ef   gh"
# print(a.split())
# ['ab', 'cd', 'ef', 'gh']

（8）splitlines()

# 按换行符切割
b="abdc\naa\nbca\nbcddabddd"
# 给多行切割
print(b.splitlines())
# ['abdc', 'aa', 'bca', 'bcddabddd']

b="abdc\naa\nbca\nbcddabddd"
# b.splitlines(keepends=) 是否保留换行符，默认不保留 = False，
print(b.splitlines(True))
# 保留换行符 ['abdc\n', 'aa\n', 'bca\n', 'bcddabddd']

（9）startswith()

# 判断当前字符串是否以指定字符开头
# b="hello"
# print(b.startswith("h"))
# # print(b.startswith("ho"))
# start end：起始点、终止点

（10）endwith()

# 判断当前字符串是否以指定字符结束
# print(b.endswith("o"))

（11）upper() & lower()

# 将字符串中的所有元素都转换成大写或者小写
# a="heOlo"
# print(a.upper(),a)
# print(a.lower())

（12）isupper() & islower() & isspace()

# 判断字符串是否是大写？小写？空白？
# a="Hello"
# print(a.isupper())
# print(a.islower())
# b="\t"
# print(b.isspace())   #  空格 \r \t \n

（13）判断字符和数值

# isalpha是否是字符（大写小写汉字）
print('a'.isalpha())
# True

# 是否是数字
print("123".isdigit())
# True

#判断是否是数值
# 范围：数值 > 数字 > 十进制
# print("123".isnumeric())
# print("123".isdecimal())

（14）判断字符串是否是合法的标识符

# 不能判断关键字
print("1a1".isidentifier())
print("if".isidentifier())
# False
# True

（15）partition()

# 返回一个元组，第一个元素参数之前的，第二个元素是参数，第三个元素是参数之后
print("abcdefg".partition("de"))
# ('abc', 'de', 'fg')

（16）center()

# a.center(width,char)
# width:给定的长度
# char:填充的字符串
# a="hell"
# print(a.center(6,"*")) #6 是给点的长度

#如果原来字符串长度是奇数，填充的时候，从右侧开始填充
a="hello"
print(a.center(6,"*"))
# hello*
#如果原来字符串长度是偶数，填充的时候，从左侧开始填充