python-元组，字符串各种方法上

创建元组
元组元素不可改变

x = (1, 2, 'hao')  # ()可以带括号
print(x)
y = 3, 4, 'bu', 5, 6, 7  # 也可以不带括号
print(y)
print(y[0])  # 3,用下标获取元组元素
print(y[3:])  # (5, 6, 7),可以使用切片，下标为3（包括3）以后的元素
print(y[:3])  # (3, 4, 'bu'),下标为3（不包括3）以前的元素
print(y[::-1])  #(7, 6, 5, 'bu', 4, 3),逆反

元组的查找

x = (3, 1, 9, 6, 8, 3, 7, 9)
print(x.count(3))  # 2,两个3
print(x.index(3))  # 0,第一个3的下标为0
print(x.index(3, 1))  # 5,从下标1开始查找3，包括下标1

元组的拼接

s = (1, 2, 3)
t = (4, 5, 6)
print(s + t)  # (1, 2, 3, 4, 5, 6)
print(s * 3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

元组的嵌套

s = (1, 2, 3)
t = (4, 5, 6)
w = s, t  #嵌套
print(w)  # ((1, 2, 3), (4, 5, 6))
for i in w:
    for j in i:
        print(j, end=' ')

列表推导式用于元组

s = (1, 2, 3)
print([i * 2 for i in s])  # [2, 4, 6],得到的是列表

生成只有一个元素的元组

x = (6)
y = (6,)  # 只有一个元素的元组
print(x)  # 6 
print(y) #  (6,)

打包和解包
适用于任何序列
赋值号左边的变量个数要和元素的个数相等

t = (1, 2, 3)  # 把1,2,3打包在一起
x, y, z = t  # 解包
print(x)  # 1
print(y)  # 2
print(z)  # 3
a, b, c, d, e = 'Funny'  # 解包
print(a, b, c, d, e)

除非
将多余的会变成列表赋值给带*的变量

a, b, *c = 'Funny'  # 解包
print(a, b, c)  # F u ['n', 'n', 'y']
a, *b, c = 'Funny'  # 解包
print(a, b, c)  # F ['u', 'n', 'n'] y

元组怎么修改？
当元组中含有可修改的序列时，元组就可以被修改

s = [1, 2, 3]
t = [4, 5, 6]
w = s, t  # 元组嵌套
print(w)  # ([1, 2, 3], [4, 5, 6])
w[1][1] = 10
print(w)  # ([1, 2, 3], [4, 10, 6])

字符串不能发生改变，所以不论哪种方法都是生成新的字符串，并未改变旧的字符串

字符串回文数判断
x[::-1]将字符串x进行逆转

x = input("请输入您要判断的数字：")
if x == x[::-1]:
    print("是回文数")
else:
    print("不是回文数")

字符串大小写各种方法

x = 'hello World'
print(x.capitalize())  # Hello world,首字母大写,其他字母小写,这是生成的新的字符串
print(x)  # hello World,原字符串并未发生改变
print(x.title())  # Hello World,每个单词的首字母都大写，其它字母小写
print(x.swapcase())  # HELLO wORLD,大写变小写，小写变大写
print(x.upper())  # HELLO WORLD,所有字母都大写
print(x.lower())  # hello world,所有字母都小写,只能处理英文字符
print(x.casefold())  # hello world,所有字符都小写,还可以处理其它的语言

字符串左中右对齐各种方法

x = "有内鬼，停止交易！"  # 9个字符
print(x.center(5))  # 宽度<=9,原字符串输出
print(x.center(15))  # 共15个字符，在15个字符的中间,空格填充
print(x.center(15, '哈'))  # 在15个字符的中间，用哈填充，哈哈哈有内鬼，停止交易！哈哈哈
print(x.ljust(15))  # 左对齐
print(x.ljust(15, '不'))  # 左对齐，用不填充，有内鬼，停止交易！不不不不不不
print(x.rjust(15))  # 右对齐
print(x.zfill(15))  # 用0填充左侧，000000有内鬼，停止交易！

字符串查找
x.count(字符串, 开始下标, 结束下标))，包括开始下标，不包括结束下标
x.find(字符串, 开始下标, 结束下标)),从左往右找字符串出现的第一个下标
x.rfind(字符串, 开始下标, 结束下标)),从右往左找字符串出现的第一个下标
x.index(字符串, 开始下标, 结束下标)),从左往右找字符串出现的第一个下标
x.rindex(字符串, 开始下标, 结束下标)),从右往左找字符串出现的第一个下标
find和rfind找不到时输出-1
index和rindex找不到直接出现异常

x = '12321'
print(x.count('1'))  # 2,字符串‘1’出现的次数
print(x.count('1', 1, 5))  # 1
print(x.find('1'))  # 0
print(x.rfind('1'))  # 4
print(x.index('1'))  # 0
print(x.rindex('1'))  # 4
print(x.find('6'))  # -1
print(x.index('6'))  # 出现异常

字符串替换
x.expandtabs() 使用n空格替换1个\t，并返回新的字符串

x ='''\thhhhh
        hhhhhh'''
print(x)  # \t在我的电脑里是4个空格
nx = x.expandtabs(8)  # 使用8个空格替换1个\t，并返回新的字符串
print(nx)  

x.replace('旧', '新')用新字符串代替旧字符串

x = '在吗，今天天气很好！在吗在吗'
print(x.replace('在吗', '想你'))  
# 想你，今天天气很好！想你想你，用’想你‘替换所有的’在吗‘

x.translate(str.maketrans('旧', '新'，'忽略')),用新的字符依次的替换旧的字符，'忽略'是指生成的新的字符串里没有’忽略’的这个字符串
新、旧字符是一一对应的，并不要求是整体的字符串。
如：'abu', '123'，就是a变成1，b变成2，u变成3

x = 'a jing yu'
y = 'a jing yu'
table = str.maketrans('abudefg', '1234567')
print(x.translate(table))  # 1 jin7 y3
print(y.translate(str.maketrans('abudefg', '1234567')))  # 1 jin7 y3
print(y.translate(str.maketrans('abudefg', '1234567', 'jing')))  # 1 y3