python语法--字符串（11）

1.字符串的介绍

1.1字符串的格式

    a = "I'm Tom"  # 一对双引号 
    b = 'Tom said:"I am Tom"'  # 一对单引号
    c = 'Tom said:"I\'m Tom"'  # 转义字符
    d = '''Tom said:"I'm Tom"'''  # 三个单引号
    e = """Tom said:"I'm Tom" """  # 三个双引号

小总结：
双引号或者单引号中的数据，就是字符串
如果使用一对引号来定义字符串，当出现符号冲突时可以使用转义字符
使用三个单引号、双引号定义的字符串可以包裹任意文本

2 字符串常见操作

2.1字符串的切片

2.1.1字符串的索引（下标）

所谓索引其实就是编号，相当于门牌号，通过这个门牌号能找到相应的房间，通常都是一个门牌号对应一个房间
需要注意的是，字符串的下标是从0开始计算的，一般都是从0向后递增，但是也可以是将最后一个元素标为-1，倒数第二个元素为-2，依次向前递减，两种索引方法可以混合使用

a = 'hello'
print(a[2])  # l
print(a[4])  # o
print(a[-1]) # o
print(a[-4]) # e
print(a[0:-3]) # he

2.1.2 字符串的切片
所谓切片就是从字符串中截取一部分元素

切片的语法：[起始:结束:步长]，也可以简化使用 [起始:结束]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，‘起始’和‘结束’不区别大小，只表示开始位置和结束位置，步长表示选取间隔。

# 索引是通过下标取某一个元素
# 切片是通过下标去某一段元素
a = 'helloworld'
print(s[4])  # o 字符串里的第4个元素
print(s[3:7])  # lo W 包含下标 3，不含下标 7
print(s[:]) # Hello World! 取出所有元素（没有起始位和结束位之分），默认步长为1
print(s[1:]) # ello World! 从下标为1开始，取出 后面所有的元素（没有结束位）
print(s[:4])  # Hell 从起始位置开始，取到 下标为4的前一个元素（不包括结束位本身）
print(s[:-1]) # Hello World 从起始位置开始，取到 倒数第一个元素（不包括结束位本身）
print(s[-4:-1]) # rld 从倒数第4个元素开始，取到 倒数第1个元素（不包括结束位本身）
print(s[1:5:2]) # el 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）
print(s[7:2:-1]) # ow ol 从下标为7的元素开始(包含下标为7的元素)，倒着取到下标为2的元素(不包括下标为2的元素) 
print(s[5:3])   #  正序需要‘起始’位置在‘结束’位置的左边，否则无输出
print(s[-3:-1]) #  倒序需要‘起始’位置在‘结束’位置的右边，否则无输出
# python 字符串快速逆置
print(s[::-1])  # !dlroW olleH 从后向前，按步长为1进行取值

2.2字符串长度的获取：len（）函数

a = 'hello'
print(len(a)) # 5， 即 ‘hello’的长度

2.3 查找

2.3.1 find方法
查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1.

语法格式： S.find(sub[, start[, end]]) -> int

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.find('好风光'))  # 10 '好风光'第一次出现时，'好'所在的位置
print(mystr.find('你好'))  # -1  '你好'不存在，返回 -1
print(mystr.find('风', 12))  # 15 从下标12开始查找'风',找到风所在的位置试15
print(mystr.find('风光',1,10)) # -1 从下标1开始到12查找"风光",未找到，返回 -1

2.3.2 index方法
跟find()方法一样，只不过，find方法未找到时，返回-1,而str未找到时，会报一个异常

2.3.3 rfind方法
类似于 find()函数，不过是从右边开始查找。

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rfind('好')) # 14

2.3.4 rindex方法
类似于 index()，不过是从右边开始。

2.4 统计 （count方法）

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.count('好'))  # 3. '好'字出现三次

2.5 判断

2.5.1 startswith方法：
判断字符串是否以指定内容开始。

2.5.2 endswith方法：
判断字符串是否以指定内容结束。

2.5.3 isalpha方法：
判断字符串是否是纯字母。

2.5.4 isdigit方法
判断一个字符串是否是纯数字，只要出现非0~9的数字，结果就是False.

2.5.5 isalnum方法
判断是否由数字和字母组成。只要出现了非数字和字母，就返回False.

2.5.6 isspace方法
如果 字符串 中只包含空格，则返回 True，否则返回 False.

2.5.7 islower方法
判断字符串里的所有字母是否都为小写，

a = '2'         # False
b = 'ssssss'    # Ture
c = 'sssAs'     # False
d = 'ssssss22'  # True

2.5.8 isupper方法
判断字符串里所有字母是否都为大写

a = '2'        # False
b = 'SSSSS'    # Ture
c = 'sssAs'    # False
d = 'AAAAAA22' # Ture

2.6 替换（replace（）函数）

替换字符串中指定的内容，如果指定次数count，则替换不会超过count次。替换后原字符串不会改变。

mystr = '今天天气好晴朗，处处好风光呀好风光'
newstr = mystr.replace('好', '坏')
print(mystr)  # 今天天气好晴朗，处处好风光呀好风光  原字符串未改变！
print(newstr)  # 今天天气坏晴朗，处处坏风光呀坏风光 得到的新字符串里，'好'被修改成了'坏'
newstr = mystr.replace('好','坏',2)  # 指定了替换的次数
print(newstr) # 今天天气坏晴朗，处处坏风光呀好风光 只有两处的'好'被替换成了'坏'

2.7 内容分隔

2.7.1 split方法
以指定字符串为分隔符切片，如果 maxsplit有指定值，则仅分隔 maxsplit+1 个子字符串。返回的结果是一个列表。

mystr = '今天天气好晴朗，处处好风光呀好风光'
result = mystr.split() # 没有指定分隔符，默认使用空格，换行等空白字符进行分隔
print(result) #['今天天气好晴朗，处处好风光呀好风光'] 没有空白字符，所以，字符串未被分隔
result = mystr.split('好')  # 以 '好' 为分隔符
print(result) # ['今天天气', '晴朗，处处','风光呀,'风光']
result = mystr.split("好",2) # 以 '好' 为分隔符，最多切割成3份
print(result) # ['今天天气', '晴朗，处处', '风光呀好风光']

2.7.2 rsplit方法
用法和split基本一致，只不过是从右往左分隔。

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rsplit('好',1))  #['今天天气好晴朗，处处好风光呀', '风光']

2.7.3 splitlines方法
按照行分隔，返回一个包含各行作为元素的列表。

mystr = 'hello \nworld'
print(mystr.splitlines()) # ['hello ', 'world']

2.7.4 partition方法
把mystr以str分割成三部分,str前，str和str后，三部分组成一个元组

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.partition('好'))  # ('今天天气', '好', '晴朗，处处好风光呀好风光')

2.7.5 rpartition方法
类似于 partition()函数,不过是从右边开始.

mystr = '今天天气好晴朗，处处好风光呀好风光'
print(mystr.rpartition('好'))   # ('今天天气好晴朗，处处好风光呀', '好', '风光')

2.8 修改大小写

修改大小写的功能只对英文有效，主要包括，首字母大写capitalize,每个单词的首字母大写title,全小写lower,全大写upper.

2.8.1 capitalize方法
第一个单词的首字母大写。

mystr = 'hello world'
print(mystr.capitalize()) # Hello world

2.8.2 upper方法：所有字母都变成大写。

2.8.3 lower方法：所有字母都变成小写。

2.8.4 title方法：每个单词的首字母大写

mystr = 'hello world'
print(mystr.title()) # Hello World

2.9 空格处理

2.9.1 strip方法：删除两端的空白字符，也可删除两端指定字符

str = '    he   llo      '
print(str.strip())  #he   llo
s = 'asdfdsfds'
print(s.strip('a'))  #sdfdsfds

2.9.2 rstrip方法：删除右边的空白字符或者指定字符

2.9.3 lstrip方法： 删除左边的空白字符或者指定字符

2.9.4 ljust方法（左对齐）
返回指定长度的字符串，并在右侧使用空白字符补全(左对齐)。

str = 'hello'
print(str.ljust(10))  # hello     在右边补了五个空格

2.9.5 rjust方法（右对齐）
返回指定长度的字符串，并在左侧使用空白字符补全(右对齐)。

str = 'hello'
print(str.rjust(10))  #      hello在左边补了五个空格

2.9.6 center方法（居中对齐）
返回指定长度的字符串，并在两端使用空白字符补全(居中对齐)

str = 'hello'
print(str.center(10))  #  hello   两端加空格，让内容居中

2.10 字符串的格式化输出：

str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field，从而完成字符串的格式化。

form的完整格式是{字段名!转换字符:格式说明符}。其中字段名师必须的，而且可以分为简单字段名和复合字段名。
2.10.1 简单字段名由三种写法:

省略字段名:{}：

print('我叫{}，今年{}岁。'.format('小明', 18)) # 我叫小明，今年18岁
# 大括号个数可以少于位置参数的个数
print('我爱吃{}和{}。'.format('香蕉', '苹果', '大鸭梨'))
# 大括号个数多于位置参数的个数则会报错
print('我还吃{}和{}。'.format('西红柿')) # IndexError: tuple index out of range 

使用非负十进制整数{0}：

print('身高{0}，家住{1}。'.format(1.8, '铜锣湾'))
# 数字形式的简单字段名可以重复使用。
print('我爱{0}。\n她今年{1}。\n我也爱{0}。'.format('阿香', 17))
# 体会把所有位置参数整体当成元组来取值
print('阿香爱吃{1}、{3}和{0}。'.format(
    '榴莲', '臭豆腐', '皮蛋', '鲱鱼罐头', '螺狮粉'))
    # 尝试一下越界错误
# print('{1}'.format('错误用法')) # IndexError: tuple index out of range

数字必须是大于等于 0 的整数。
带数字的替换字段可以重复使用。
数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组，通过字段名中的数字进行取值。即 {0} 等价于 tuple[0]，所以大括号内的数字不能越界。
变量名{name}：

# 使用变量名形式的简单字段名传递关键字参数
print('我大哥是{name}，今年{age}岁。'.format(name='阿飞', age=20))
# 关键字参数的顺序可以随意调换
print('我大哥是{name}，今年{age}岁。'.format(age=20, name='阿飞'))

关键字参数的位置可以随意调换

2.10.2 简单字段名的混合使用

# 可以同时传递位置参数和关键字参数
print('这是一个关于{0}、{1}和{girl}的故事。'.format(
    '小明', '阿飞', girl='阿香'))
 # 但是关键字参数必须位于位置参数之后
# print('这是一个关于{0}、{1}和{girl}的故事。'.format(
    # '小明', girl='阿香' , '阿飞')) # SyntaxError: positional argument follows keyword argument
 # 数字也可以省略
print('这是一个关于{}、{}和{girl}的故事。'.format(
    '小明', '阿飞', girl='阿香'))
 # 但是省略字段名不能和数字形式的字段名同时出现
# print('这是一个关于{}、{1}和{girl}的故事。'.format(
#     '小明', '阿飞', girl='阿香')) # ValueError: cannot switch from automatic field numbering to manual field specification 

2.10.3 使用元组和字典传参

# 使用元组传参
infos = '钢铁侠', 66, '小辣椒'
print('我是{}，身价{}亿。'.format(*infos)) # 我是钢铁侠，身家66亿。
print('我是{2}，身价{1}亿。'.format(*infos)) # 我是小辣椒，身家66亿。
# 使用字典传参
venom = {'name': '毒液', 'weakness': '火'}
print('我是{name}，我怕{weakness}。'.format(**venom)) # 我是毒液，我怕火。
# 同时使用元组和字典传参
hulk = '绿巨人', '拳头'
captain = {'name': '美国队长', 'weapon': '盾'}
print('我是{}, 我怕{weapon}。'.format(*hulk, **captain)) # 我是绿巨人, 我怕盾。
print('我是{name}, 我怕{1}。'.format(*hulk, **captain)) # 我是美国队长, 我怕拳头。
# 同时使用位置参数、元组、关键字参数、字典传参
# 注意：
# 位置参数要在关键字参数前面
# *元组要在**字典前面
tup = '鹰眼',
dic = {'weapon': '箭'}
text = '我是{1}，我怕{weakness}。我是{0}，我用{weapon}。'
text = text.format(
    *tup, '黑寡妇', weakness='男人', **dic)
print(text)  # 我是黑寡妇，我怕男人。我是鹰眼，我用箭。

2.10.4 使用. 点号

class Person(object):
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender
p = Person('zhangsan',18,'female')
print('姓名是{0.name},年龄是{0.age},性别是{0.gender}'.format(p))
print('姓名是{.name}'.format(p))  # 只有一个替换字段时，可以省略数字

2.10.5 使用[]中括号

# 中括号用法：用列表传递位置参数
infos = ['阿星', 9527]
food = ['霸王花', '爆米花']
print('我叫{0[0]}，警号{0[1]}，爱吃{1[0]}。'.format(
    infos, food))
    # 中括号用法：用元组传递位置参数
food = ('僵尸', '脑子')
print('我叫{0[0]}，年龄{1}，爱吃{0[1]}。'.format(
    food, 66))
 # 中括号用法：用字典传递位置参数
dic = dict(name='阿星', pid=9527)
print('我是{[name]}！'.format(
    dic))
# 多个替换字段，不能省略数字
print('我是{0[name]}，警号{0[pid]}。'.format(
    dic))

字符串类型是不可变类型，所有关于字符串的方法不会改变原来的字符串，都是返回一个结果，在这个新的返回值里保存了改变后的结果

2.11字符串的拼接

语法格式：

 S.join(iterable)

mystr = 'a'
print(mystr.join('hxmdq'))  #haxamadaq  把hxmd一个个取出，并在后面添加字符a. 最后的 q 保留，没有加 a
print(mystr.join(['hi','hello','good']))  #hiahelloagood

作用：可以把列表或者元组快速的转变成为字符串，并且以指定的字符分隔。

txt = '_'
print(txt.join(['hi','hello','good'])) #hi_hello_good
print(txt.join(('good','hi','hello'))) #good_hi_hello

2.12 eval函数解析字符串

脱去字符串的引号，并计算结果

3.练习

3.1 验证码问题

题目描述：模拟用户登录，输入用户名，密码和实现随机产生5位验证码，用户输入验证码，验证输入是否正确，如果错误则重新开始验证，产生新的验证码(验证码忽略大小写)

import random
username = input('输入您的用户名：')
password = input('输入您的密码：')
while True:
    s1 = '0123456789abcdefghijklmnopqrstuvwxyz'
    s2 = ''
    for i in range(5):
        a = s1[random.randint(0, len(s1) - 1)]
        s2 += a
    print('验证码为：%s' % s2)
    yanzheng_code = input('请输入正确的验证码：')
    if yanzheng_code == s2 or yanzheng_code == s2.upper():   # 验证码中的字母要不全大写或者全小写
        print('验证码输入正确，登录成功')
        break
    else:
        print('请重新输入验证码')

本题也可使用random。choice（字符串）来随机选取一个元素

3.2 输入字符串，获取字符串的中间字符

思路：要考虑字符串⻓度是奇数和偶数的情况
字符串长度为奇数，中间元素的下标是：字符串长度//2
字符串长度为偶数, 中间元素的下标是：字符串长度//2 - 1 和 字符串长度//2

s1 = input('请输入一个字符串：')
if len(s1) % 2 == 0:
    print(s1[len(s1) // 2 - 1:len(s1) // 2 + 1])
else:
    print(s1[len(s1)//2])

3.3 输入字符串，将字符串的开头和结尾变成’+’，产生一个新的字符串 （提示：去头尾，使用+进行字符串拼接）

s1 = input('请输入一个字符串：')
s2 = s1.lstrip(s1[0])
s3 = s2.rstrip(s2[-1])
print(s3)

3.4输入两个字符串 打印第二个字符串在第一个字符串中第一次出现的位置（使用正索引）

s1 = input('输入第一个字符串：')
s2 = input('输入第二个字符串：')
if len(s1) < len(s2) or len(s2) == 0:
    print('不存在')
else:
    for i in range(len(s1) - len(s2) + 1):
        if s1[i:i + len(s2)] == s2:
            print(i)
            break

3.5 输入两个字符串，打印两个字符串的公共字符，没有则打印公共字符不存在

s1 = input('输入第一个字符串：')
s2 = input('输入第二个字符串：')
s3 = ''
for i in s1:
    if i in s2 and i not in s3:
        s3 += i
if s3:
    print(s3)
else:
    print('不存在')

3.6用代码实现，利用下划线将列表的每一个元素拼接成字符串,li = [‘jack’,‘tom’,‘lucy’]

l = ['jack','tom','lucy']
s = '_'
s1 = s.join(l)
print(s1)