python基础语法

python基础语法-容器类型之字符串

常见的容器类型:

字符窜: str

列表: list

元祖: tuple

字典: dict

集合: set

字符串

• 概述:python容器的一种,其值可用引号包裹起来.单引,双引都可.

• 格式:

  • 方式1:单引号

  • 方式2:双引号

  • 方式3:三引号,可以格式化代码,支持代码的换行,缩进等…

# 方式1: 单引号.
s1 = 'hello world'
print(f's1: {s1}')

# 方式2: 双引号.
s2 = 'hello python'
print(f's2: {s2}')

# 方式3: 3引号.
s3 = """
关关雎鸠,
在河之洲.
窈窕淑女,
君子好逑.
"""
print(s3)

字符串的下标

• 概述:下标也叫编号,脚标,索引(index),字符串的每个字符都是有标号的.

  • 从左往右叫:正向索引,默认从:0 开始.

  • 从右往左叫:逆向索引,默认从:-1开始.

• 解释:

  • 1.通过字符串变量名[索引值]的方式,可以获取到指定的字符.

  • 2.可以通过索引的方式遍历字符串.

  • 3.通过len()函数获取字符串的长度.

# 需求1: 演示 字符串的索引.
s1 = 'itheima'

# 根据索引获取字符.
print(s1[0])    # i
print(s1[1])    # t
print(s1[2])    # h


# 扩展: len(字符串变量名) 可以获取字符串的长度.
print(f'字符串的长度为: {len(s1)}')


# 需求2: 遍历字符串, 逐个获取每个字符, 并打印.
# 方式1: 直接遍历.
for i in s1:
    print(i)
for i in range( len(s1) ):  # i的值的范围: 0 ~ 7, 包左不包右.
    print(s1[i])
    # 根据索引, 获取到每个字符.

字符串的切片

• 概述:切片可以从指定字符串中截取指定的内容.

• 格式:字符串变量名[起始索引:结束索引:步长]

• 解释:

  • 1.起始索引表示从哪里开始截取,正向索引时默认是:0,逆向索引时是:-1 包括:起始索引

  • 2.结束索引表示到哪里结束, 默认是: 字符串长度 - 1 (正向索引时), 逆向索引时: 字符串长度的负数形式 不包括: 结束索引(处的字符).

  • 3.步长表示每次截取字符的间隔, 默认是: 1

• 细节:

  • 1.如果起始索引与结束索引的方向和步长方向不一致.则获取不到数据.

  • 2.切片手法:字符串变量名[::-1],表示字符串的反转.

'''字符串值:   a   b   c   d   e   f   g
正向索引:   0   1   2   3   4   5   6
逆向索引:   -7  -6  -5  -4  -3  -2  -1
'''
# 1. 自定义变量, 记录字符串值.
s1 = 'abcdefg'

# 2. 演示字符串切片: 正向索引.
print(s1[1:5])  # bcde
print(s1[1:5:1])  # 效果同上, 即: 默认的步长就是 1
print(s1[1:5:2])  # bd
print(s1[::])  # 获取字符串本身, 它等价于: s1[0:(6 + 1):1]
print(s1[0:(6 + 1):1])  # 效果同上.

print(s1[:3])     # 不写起始索引, 正向步长时, 默认是: 0,  等价于: s1[0:3:1]
print(s1[2:])     # 不写结束索引, 正向步长时, 默认是: 长度 + 1,  等价于: s1[2:7:1]
print(s1[2::2])   # ceg
print('-' * 30)

# 3. 演示字符串切片: 逆向索引.
print(s1[::-1])     # 逆向时, 起始索引: 默认是: -1, 结束索引: 默认是: 长度+1的负数形式.  gfedcba
print(s1[-1:-8:-1]) # 效果同上
print(s1[-2:-6:-2]) # fd

print(s1[0:3:-1])   # 获取不到数据, 但是不报错, 因为: 起始索引 -> 结束索引的方向 和 步长的方向不一致.
print(s1[:-3:-1])   # gf
print(s1[:2:-1])    # gfed, 很重要.
print(s1[1:-1:2])   # bdf
print(s1[4:-6])     # 无数据, 顺序不一致.
print('-' * 30)

字符串函数

• 概述:python 提供的可以直接操作的字符串变量或字符串指的一些函数

• 常见查找类函数有:

字符串变量名.find(要查找的子串, 起始索引, 结束索引)      找子串在字符串中第一次出现的位置, 找到就返回子串的起始索引, 找不到就返回-1
字符串变量名.index(要查找的子串, 起始索引, 结束索引)     找子串在字符串中第一次出现的位置, 找到就返回子串的起始索引, 找不到就报错.
字符串变量名.rfind(要查找的子串, 起始索引, 结束索引)      找子串在字符串中最后一次出现的位置, 找到就返回子串的起始索引, 找不到就返回-1
字符串变量名.rindex(要查找的子串, 起始索引, 结束索引)     找子串在字符串中最后一次出现的位置, 找到就返回子串的起始索引, 找不到就报错.
"""

# 1. 定义变量, 记录字符串值.
#     0            13          25
s1 = 'hello python hello world hello sql'
print(len(s1))

# 2. 查找 hello 字符串在 s1中出现的索引.
# find()函数
print(s1.find('hello'))         # 0, 不写起始和结束索引, 默认是在 整个字符串中 查找的.
print(s1.find('hello', 2))       # 从索引2的位置处, 开始查找.
print(s1.find('hello', 2, 17))  # -1, 因为是在 索引 2 ~ 17位置查找, 包左不包右.
print('-' * 30)

# index()函数
print(s1.index('hello'))                     # 0, 效果同上
print(s1.index('hello', 2))     # 13, 效果同上.
# print(s1.index('hello', 2, 17))  # 找不到就: 报错.
print('-' * 30)


# rfind()函数, 最后一次出现的位置, 找不到返回 -1
print(s1.rfind('hello'))                    # 25
print(s1.rfind('hello', 2))    # 25
print(s1.rfind('hello', 2, 17))  # -1
print('-' * 30)


# rindex()函数, 最后一次出现的位置, 找不到: 报错
print(s1.rindex('hello'))                    # 25
print(s1.rindex('hello', 2))    # 25
# print(s1.rindex('hello', 2, 17))  # 报错.

字符串替换与分割

• 概述:python中用于直接操作字符窜变量或者支付串值的一些函数.

• 常用函数如下:

  • 字符串变量名.replace(旧子串,新子窜,替换次数) 用新的替换旧的,且可以设计替换几个.

  • 字符串变量名.split(分隔符,切割次数) 按分隔符切割,且可以设置切割次数

• 注意:因为字符串属于不可变量,所以会返回一个新的结果

# 1. 定义变量, 记录字符串内容.
s1 = 'hello python hello sql hello pandas'

# 2. 用 heima 来替换上述的 hello.
s2 = s1.replace('hello', 'heima')            # 如果不写个数, 则会一次性替换所有.
s3 = s1.replace('hello', 'heima', 2) # 只会替换2次(前2个)
s4 = s1.replace('hello', 'heima', 5) # 超出真实个数, 则以实际为准.

# 3. 打印结果.
print(f's1: {s1}')      # hello python hello sql hello pandas
print(f's2: {s2}')      # heima python heima sql heima pandas
print(f's3: {s3}')      # heima python heima sql hello pandas
print(f's4: {s4}')      # heima python heima sql heima pandas
print('-' * 30)

# 4. 测试split()函数.
s5 = 'hello python hello sql hello pandas'
list1 = s5.split(' ')                   # 切割后, 获取的是一个 字符串形式的列表, 即: ['hello', 'python', 'hello'...]
list2 = s5.split(' ', 2)   # 按空格切割, 只会切割2次(前2个), 即: 获取的元素个数为: 2 + 1 = 3个.
list3 = s5.split(' ', 9)   # 如果切割的个数超过真实个数, 则以实际为准.

# 5. 打印结果.
print(f's5: {s5}')          # hello python hello sql hello pandas
print(f'list1: {list1}')    # ['hello', 'python', 'hello', 'sql', 'hello', 'pandas']
print(f'list2: {list2}')    # ['hello', 'python', 'hello sql hello pandas']
print(f'list3: {list3}')    # ['hello', 'python', 'hello', 'sql', 'hello', 'pandas']

总结

持续更新中~~~