字符串入门详解（超级详细）

字符串:
    概述:
        它属于容器类型的一种, 属于 不可变类型.  它由多个字符组成.
    例如:
        'abc',  'hello world', '张三'...
    定义格式:
        方式1: 一对引号, 单双引号均可.
        方式2: 三引号, 可以保留字符串的格式.

创建字符串

可以使用单引号（'）、双引号（"）、三重引号（''' 或 """）来创建字符串：

# 使用单引号
str1 = 'Hello, World!'

# 使用双引号
str2 = "Hello, World!"

# 使用三重引号（多行字符串）
str3 = '''This is a 
multiline string.'''

str4 = """This is also a 
multiline string."""

字符串-索引详解

概述:
        Python中, 为了更好, 更方便的从字符串中获取到指定的内容, 给字符串的每个元素 提供的有索引.
        索引也叫: 下标, 角标, 编号等...
细节:
        1. Python中, 字符串的索引 有正向索引 和 逆向索引之分.
        2. 正向索引: 从左往右(从前往后)编号, 且 编号从 0 开始.
        3. 逆向索引: 从右往左(从后往前)编号, 且 编号从 -1 开始.                                                                  4. 可以通过  字符串变量名[索引] 的形式, 从字符串中 获取到 指定的内容.

# 1. 定义字符串.
s1 = 'atheimn'

# 2. 从字符串中获取指定内容, 并打印.
print(s1[2])        # 'h'
print(s1[-5])       # 'h'


print(s1[5])         # 'm'
print(s1[-2])        # 'm'


print(s1[3])        # 'e'
print(s1[-2])       # 'm'

字符串-切片

概述:
        从字符串中 截取出 指定的内容 就称之为: 字符串切片.
格式:
        字符串变量名[起始索引:结束索引:步长]            包左不包右.
细节:
        1. 正向索引是从前往后(从左往右), 从 0 开始.
        2. 逆向索引是从后往前(从右往左), 从 -1 开始.
        3. 如果不写起始索引, 默认从: 0开始,
           如果不写结束默认, 默认到字符串末尾.
           如果不写步长, 默认是: 1
        4. 如果 索引 和 步长的方向相反, 获取不到数据.
        5. 特殊写法,  字符串[::-1] 表示反转字符串, 这个是面试题.

# 1. 定义变量s1, 记录字符串内容.
s1 = 'abcdefgh'

# 2. 演示字符串的切片.
print(s1[1:3])      # bc        不写步长, 默认是: 1
print(s1[:5])       # abcde     不写起始索引, 默认是: 0
print(s1[3:])       # defgh     不写结束索引, 默认到: 字符串最后
print(s1[1:5:2])    # bd        起始索引是1, 结束索引是5, 步长是2, 包左不包右.
print('-' * 28)

print(s1[-6:-2])        # cdef, 不写步长, 默认是: 1
print(s1[-6:-2:1])      # 效果同上.

print(s1[-6:-2:-1])     # 不报错, 但是啥都没有.  因为查找的顺序是 -6到-2 从前往后(->), 而步长是-1, 顺序是 从后往前(<-)   查找和步长顺序相反, 无数据.
print(s1[-1:-5:-1])     # hgfe

print(s1[:-3])          # abcde
print(s1[-5:])          # defgh

print(s1[2:-3])         # cde
print(s1[-2:1])         # 不报错, 但是啥都没有.  查找方向 和 方向顺序不一致.
print(s1[-2:1:-1])      # gfedc

# 面试题
print(s1[:])            # abcdefgh, 即: 字符串本身.
print(s1[::-1])         # hgfedcba, 即: 反转字符串

print(s1[::-3])         # heb

字符串函数-index-find

概述:
        你可以简单的把函数先理解为就是 别人写好的"工具", 我们直接调用就可以了, 传入 参数(原材料), 经过函数加工, 可以获取指定的 结果(返回值).

常用函数:
        字符串变量名.find(子串, 起始索引, 结束索引)
        找子串在字符串中 第1次 出现的位置, 如果写开始和结束索引(包左不包右), 就在指定区间查找, 找不到就返回 -1

        字符串变量名.index(子串, 起始索引, 结束索引)
        效果同上, 只不过是, 找不到就 报错.

        字符串变量名.rfind(子串, 起始索引, 结束索引)
            效果类似于 find(), 只不过是找 子串在字符串中 最后1次出现的位置, 找不到就返回 -1.
        字符串变量名.rindex(子串, 起始索引, 结束索引)
            类似于 rfind(), 找不到就 报错.
 

# 1. 定义字符串.
s1 = "hello and python and java and sql and scala"


# 2. 演示上述的函数.
print(s1.find('and'))                               # 6, 因为字符串由多个字符组成, 默认会返回 字符串第1个字符的 索引.
print(s1.find('and', 7, 30))      # 17
print(s1.find('and', 7, 19))      # -1, 包左不包右, 取不到索引19
print('-' * 28)

print(s1.index('and'))                               # 6, 因为字符串由多个字符组成, 默认会返回 字符串第1个字符的 索引.
print(s1.index('and', 7, 30))      # 17
# print(s1.index('and', 7, 19))      # 报错
print('-' * 28)


# 演示 rfind() 和 rindex(), 效果都一样, 区别就是 找不到的时候报不报错.
print(s1.rfind('and'))      # 34
print(s1.rfind('and', 10, 30))      # 26
print(s1.rfind('and', 10, 19))      # -1
print('-' * 28)

print(s1.rindex('and'))      # 34
print(s1.rindex('and', 10, 30))      # 26
# print(s1.rindex('and', 10, 19))      # 找不到, 就报错

字符串函数-replace-split

概述:
        你可以简单的把函数先理解为就是 别人写好的"工具", 我们直接调用就可以了, 传入 参数(原材料), 经过函数加工, 可以获取指定的 结果(返回值).
常用函数:
    字符串变量名.replace(旧子串, 新子串, 替换次数):

        用新串 来 替换 旧串, 可以设置替换几个(不写,   默认就替换所有)    返回新串.
    字符串变量名.split(切割符, 切割个数) :              

        按照切割符切割字符串, 切割个数表示切几个.   返回: 列表.

# 1. 定义字符串变量s1, 记录要操作的数据.
s1 = 'hello and python and sql and linux'


# 2. 演示 replace()函数.
s2 = s1.replace('and', 'or')            # 不写个数, 替换所有
s3 = s1.replace('and', 'or', 2) # 写了个数, 写几个替换几个.

# 3. 打印结果:
print(f's1: {s1}')      # s1是不可变类型, 内容不变.
print(f's2: {s2}')
print(f's3: {s3}')
print('-' * 28)


# 4. 演示 split()函数.
list1 = s1.split('and')
print(type(list1))      # <class 'list'> 列表, 也是容器类型的一种.
print(list1)            # ['hello ', ' python ', ' sql ', ' linux']


list2 = s1.split('and', 2)
print(type(list2))      # <class 'list'> 列表, 也是容器类型的一种.
print(list2)            # ['hello ', ' python ', ' sql and linux']
print('-' * 28)


# 扩展: len()函数, 获取字符串的长度的, 即: 字符串有几个字符.
print(len(s1))          # 34
print('-' * 28)


# 分隔符.join(字符串)  用分隔符隔开 字符串中的每个字符.
s4 = 'hello'
s5 = ','.join(s4)
print(s5)       # h,e,l,l,o


# 需求: 把 'hello' => ['h', 'e', 'l', 'l', 'o']
list3 = ','.join(s4).split(',')
print(list3)        # ['h', 'e', 'l', 'l', 'o']