整数：

浮点数，复数： 

#归根到底，字符串是一个序列，是像元组那样不可变的序列。
#所以我们可以用切片的方式，将字符串反转。

#字符串的诸多方法
#调用字符串内部方法的好处：更快，更安全（官方的东西，出岔子，肯定会被喷成马蜂窝）

#一、大小写字母转换的方法
#注意以下方法都不是修改原字符串（字符串不能被修改），而是生成了一个新的字符串。
    #1.capitalize() (创建一个新字符串，内容为：原字符串的第一个字母变成大写，其它变为小写)
s = "I love Python!"
print(s.capitalize()) #I love python!

    #2.casefold() (创建一个新字符串，内容为：原字符串的所有字母变为小写)
print(s.casefold()) #i love python!
    
    #3.title() (创建一个新字符串，内容为：原字符串中 所有单词的第一个字母 变成大写，其它变为小写)
print(s.title()) #I Love Python!
    
    #4.swapcase() (创建一个新字符串，内容为：原字符串中所有单词的大小写翻转)
print(s.swapcase()) #i LOVE pYTHON!

    #5.upper() (创建一个新字符串，内容为：原字符串所有字母都变成大写)
print(s.upper()) #I LOVE PYTHON!

    #6.lower()（创建一个新字符串，内容为：原字符串所有字母变成小写）
    #（不同于casefold()能处理德语等其它语言的字符，lower只能处理英文字母）
print(s.lower()) #I LOVE PYTHON!




#二、字符串的左中右对齐
#以下方法都需要一个 width参数 来指定整个字符串的宽度。(很显然一个中文汉字的长度，为一个字符)
#如果指定宽度小于等于原字符串，直接输出原字符串。
x = "我们中出了一个叛徒！"
    #1.center() （居中对齐）
print(x.center(5)) # '我们中出了一个叛徒！'
print(x.center(15)) # '   我们中出了一个叛徒！  '

    #2.ljust() （左对齐）
print(x.ljust(15)) #'我们中出了一个叛徒！     '

    #3.rjust() （右对齐）
print(x.rjust(15)) #'     我们中出了一个叛徒！'

    #4.zfill() (用零填充左侧) (会保持正负数)
s1 = '520'
print(s1.zfill(7)) # 0000520
s1 = '-520'
print(s1.zfill(7)) # -000520 (负号占了一个位置)

    #以上方法还支持一个叫 fillchar 的参数， 可以利用这个参数来 修改 填充空位的字符。
print(x.center(16,'淦'))  #淦淦淦我们中出了一个叛徒！淦淦淦
print(x.ljust(15,'淦'))  #我们中出了一个叛徒！淦淦淦淦淦
print(x.rjust(15,'淦'))  #淦淦淦淦淦我们中出了一个叛徒！




#三、实现字符串的查找功能
    #1.count() （查找指定子字符串在字符串中出现的次数）
x = "上海自来水来自海上"
print(x.count("上")) # 2
print(x.count("上", 0, 4)) # 3 (指定查找范围)

    #2.find() （查找指定子字符串在字符串中出现的下标，从左往右找）（下标索引从0开始，找不到返回-1）
print(x.find("上")) # 0  #(下标索引从0开始)（找不到返回-1）

    #3.rfind() （查找指定子字符串在字符串中出现的下标，从右往左找）
print(x.rfind("上")) # 8 （找不到返回-1）

    #4.index() （查找指定子字符串在字符串中出现的下标，从左往右找）（下标索引从0开始，找不到会抛出异常）
print(x.index("上")) # 0 #(下标索引从0开始) （找不到会报错）

    #5.rindex() （查找指定子字符串在字符串中出现的下标，从右往左找）（下标索引从0开始，找不到会抛出异常）
print(x.rindex("上")) # 8

#四、有关字符串替换的方法
    #1.expandtabs() (用指定数量的空格 替换字符串中的制表符，返回一个新的字符串)
s2 = """    I love maths
    I love Python"""
print(s2.expandtabs(4))
"""
    I love maths
    I love Python"""

    #2.replace(old,new,count = -1) （将字符串中的old,替换为new , 用count设置替换次数）
print(s2.replace("maths","Math"))
"""
    I love Math
    I love Python"""

    #3.translate(table) （根据table表格转换规则来替换字符串内容，生成一个新字符串）
        #table : 一个用于指定转换规则的表格，使用str.maketrans()方法获取这个表格
        #str.maketrans(str1, str2, str3) :属于字符串的静态方法,str2的内容和str1的内容一一对应,str3表示要省略的内容。
table = str.maketrans("Math","1234")
print("I love abc".translate(table)) #I love 2bc
        # maketrans()方法还支持第三个参数，将指定字符串里的字符忽略
print("I love abc".translate(str.maketrans("Math","1234","lv"))) #I oe 2bc




#五、字符串的判断
    #1.startswith() (用于判断指定的子字符串是否出现在字符串的起始位置)
s = "I love C and Pyhton"
print(s.startswith("I")) #True
print(s.startswith("me")) #False
    #2.endswith() (用于判断指定的子字符串是否出现在字符串的结束位置)
s = "I love C and Pyhton"
print(s.endswith("Pyhton")) #True
print(s.startswith("C")) #False
    #1,2 拓：
    #可以加入两个参数，引入判断的开始和结束位置。
print(s.startswith("C",7,8)) #True   
print(s.endswith("C",7,8)) #True
    #以上两个函数支持以元组的形式传入多个字符串：
print(s.endswith(("C","Pyhton","Java","C++"))) #True

    #3.istitle() (用于判断 字符串否为 第一个字母是大写，其它全为为小写)
print(s.istitle()) #False
    #4.isupper() (用于判断字符串 是否全为大写)
print(s.istitle()) #False
print(s.upper().isupper()) #True
    #5.islower() (用于判断字符串 是否全为小写)
print(s.islower()) #False    
print(s.lower().islower()) #True
    #拓：
    #在一个语句中同时调用多个方法，Python是从左往右依次调用的。

    #6.isalpha() (判断字符串是否只由字母构成，注意包括空格，空格不是字母)
print(s.isalpha()) #False
print("IlovePython".isalpha()) #True
    #7.isspace() (判断字符串是否为空白字符串，注意 空格、Tab、换行 都是空白字符串)
print("".isspace()) #False(空字符串不是空白字符串！)
print("     \n".isspace()) #True
    #8.isprintable() (判断字符串中的所有字符是否都为可打印字符)
print("".isprintable()) #True(空字符串是可打印字符串)
print(" ".isprintable()) #True
print("   ".isprintable()) #True
print("\n".isprintable()) #False（转义字符不是可打印字符）

    #9.isdecimal() (判断字符串是否为数字，纯数字)
print()
print("12345".isdecimal()) #True
print("1e10".isdecimal()) #False
print("2²".isdecimal()) #False
print("ⅠⅡⅢⅣⅤ".isdecimal()) #False
print("一二三四五".isdecimal()) #False
print("壹贰叁肆伍".isdecimal()) #False
    #10.isdigit() (判断字符串是否为数字，纯数字，数字带次方)
print()
print("12345".isdigit()) #True
print("1**10".isdecimal()) #False
print("2²".isdigit()) #True
print("ⅠⅡⅢⅣⅤ".isdigit()) #False
print("一二三四五".isdigit()) #False
print("壹贰叁肆伍".isdigit()) #False
    #11.isnumeric() (判断字符串是否为数字，都可以判断)
print()
print("12345".isnumeric()) #True
print("2²".isnumeric()) #True
print("ⅠⅡⅢⅣⅤ".isnumeric()) #True
print("一二三四五".isnumeric()) #True
print("壹贰叁肆伍".isnumeric()) #True
    #12.isalnum() (判断字符串是否为数字,集合了上面三个方法的判断)

    #13.isidentifier() (判断字符串是否为合法的标识符（变量名）)
print("I am a good gay".isidentifier()) #False (有空格不是合法标识符)
print("I_am_a_good_gay".isidentifier()) #True

    #14.iskeyword() (判断字符串是否是的Python的关键字) （要导入keyword模块）
import keyword
print(keyword.iskeyword("if")) #True
print(keyword.iskeyword("python")) #True



#五、字符串的截取
    #1.lstrip() (去除字符串左侧的空白)
print("     去除字符串左侧的空白".lstrip()) #去除字符串左侧的空白
    #2.rstrip() (去除字符串右侧的空白)
print("去除字符串右侧的空白     ".rstrip()) #去除字符串右侧的空白
    #3.strip() (去除字符串两侧的空白)
print("  (  去除字符串两侧的空白   )    ".strip()) #(  去除字符串两侧的空白   )
    #上面三个方法可以传入一个参数，指定要消除的一些字符，不指定默认为消除空白
print("www.python.com".lstrip("wcom.")) # python.com
print("www.python.com".rstrip("wcom.")) # www.python
print("www.python.com".strip("wcom."))  # python
    #以下两个方法是python3.9以后才有的
    #4.removeprefix() (消除指定的前缀)
#print("www.python.com".removeprefix("www."))
#print("012345".removeprefix("02"))
    #5.removesuffix() (消除指定的后缀)
#print("www.python.com".removesuffix(".com"))


#六、字符串的拆分和拼接
    #1.partition() (从左往右，把字符串按指定字符串拆分，返回一个含有三个元素的元组)
print("www.python.com".partition("."))  #('www', '.', 'python.com')

    #2.rpartition() (从右往左，把字符串按指定字符串拆分，返回一个含有三个元素的元组)
print("www.python.com".rpartition("."))  #('www.python', '.', 'com')

    #3.split() (从左往右，把字符串，按指定字符串切分,返回一个列表)
print("www.python.com".split(".")) #['www', 'python', 'com']

    #4.rsplit() (从右往左，把字符串，按指定字符串切分,返回一个列表)
print("www.python.com".rsplit(".")) #['www', 'python', 'com']
    #split(rsplit)还可以添加一个参数，指定切分的次数
print("www.python.com".split(".",1)) #['www', 'python.com']
print("www.python.com".rsplit(".",1)) #['www.python', 'com'] （由此可看出split和rsplit的区别）
    #按换行符切分
print("www\npython\ncom".split("\n")) #['www', 'python', 'com']
    #但要知道Linix下的换行是\n, Mac下的换是\r, windows下的是\r\n，这要一个一个区分太麻烦了

    #5.splitlines() (将字符串按行分割,将结果以列表形式返回)
print("\rwww\npython\r\n\rcom".splitlines()) #['', 'www', 'python', '', 'com']
    #该方法可添加一个参数，True表示要带上换行符，默认的False不带
print("\rwww\npython\r\n\rcom".splitlines(True)) #['\r', 'www\n', 'python\r\n', '\r', 'com']

    #6.join() (非常重要，用于字符串的拼接)
print(" ".join(["I","love","Python"])) #I love Python
print(" ".join(("I","love","Python"))) # ""是分隔符，()里面必须是一个可迭代对象，元组也可以
#print(" ".join([1,2,3,4,5])) #只能链接字符串
    #为什么大神喜欢使用join而不使用 + 来拼接字符串
print("I love" + " Python") #I love Python
    #join的速度远超 + （一亿组数据 + 要差不多4个小时，join只要8.88秒）
    #所以join适合大数据


#七、格式化输出字符串（format()方法）
    #1.用花括号代替要输出的参数
print("{}爱{}".format("我","Python"))  #我爱Python
    #2.花括号里可加一个数字对应要输出的括号里参数的索引值。（索引值从0开始）
print("{1}爱{0}".format("我","Python")) #Python爱我
    #同一个索引值可以引用多次
print("{0}{1}{0}{1}".format("A","B")) #ABAB
    #3.使用关键字参数
print("{name}爱{name1}".format(name = "我",name1 = "Python")) #我爱Python
print("{name}爱{name1}".format(name1 = "我",name = "Python")) #Python爱我
    #关键字和索引可混合使用
print("{name}爱{0}".format("Python",name = "我")) #我爱Python
#print("{name}爱{0}".format(name = "我","Python")) #错误，关键字必须写在前面
    #4.如何输出花括号？
print("{{}}") #{{}}
print("{}") #{}
print("{}".format("1")) #1
print("{{}}".format("1")) #{}
        #有format时，用两个嵌套的花括号{{}}，输出花括号，没有format时一个花括号就可以了

    #5.字符串的对齐(^:居中 ，<:左对齐 ，>:右对齐 ，=:强制填充在正负号之后（如果有的话）)
    #6.指定字符串的宽度（数字写在在:的右侧）（:的左边是关键字索引，右边才是格式化选项）
print("{:10}".format("Python")) #Python    #(默认为左对齐)
print("{:^10}".format("Python")) #  Python  #
print("{:<10}".format("Python")) #Python    #
print("{:>10}".format("Python")) #    Python
print("{1:>10}{0:<10}".format("Python","C++")) #       C++Python    #
print("{left:>10}{right:<10}".format(left = "Python",right = "C++")) #    PythonC++       #

    #7.在指定宽度前还可以加一个0 ，表示用0填充
    # 0写在对齐的符号右边，不感知正负号
print("{:>010}".format(-1)) #00000000-1
    # 0写在对齐的符号左边 或 不写对齐符号，感知正负号
print("{:0>10}".format(-1)) #-000000001
print("{:010}".format(-1)) #-000000001
print("{:￥=10}".format(-1)) #-￥￥￥￥￥￥￥￥1 （=:强制填充在正负号之后）

print("{:￥>10}".format(-1)) #￥￥￥￥￥￥￥￥-1
#print("{:>@10}".format(-1)) #错，不能这样写

print("{:>010}".format("Python")) #0000Python
print("{:#>10}".format("Python")) #####Python
#print("{:010}".format("Python")) #错，为字符串时不能这样写
# print("{:>#10}".format("Python"))#错，为字符串时不能这样写
# print("{:#10}".format("Python")) #错，为字符串时不能这样写
# print("{:010}".format("Python")) #错，为字符串时不能这样写

    #8.符号选项，仅对数字有效 (注意正负号是写在冒号后面)
        # + :正数在前面添加正号(+)，负数在前面添加负号(-)
        # - ：只有负数在前面添加负号(-)，默认行为
        #空格: 正数在前面添加空格，负数在前面添加负号(-)
print("{:+}".format(1)) # +1 (注意正负号是写在冒号后面)
print("{: }".format(1)) #  1

    #9.设置千分位的分隔符，仅对数字有效 (位数不足，千分位分隔符不显示)
print("{:,}".format(10000)) #10,000
print("{:_}".format(10000)) #10_000
#print("{:@}".format(10000)) #报错，已知能用作千分位的分隔符有 , _

    #10.精度选项，我们只需要填入一个十进制整数，对于不同类型参数的效果是不一样的
        # 对于设置为 f 或 F 的浮点数来说，是限定小数点后显示多少个数位
        # 对于设置为 g 或 G 的浮点数来说，是限定小数点前后显示多少个数位
        # 对于非数字类型来说，限定的是最大字段的大小
        # 对于整数类型来说，不允许使用精度选项
print("{:.2f}".format(3.141592)) #3.14
print("{:.2g}".format(3.141592)) #3.1
print("{:.2}".format("3.141592")) #3.
#print("{:.2}".format(3141592)) #报错, 整数类型不允许使用精度选项

    #11.类型选项，决定类型如何呈现
        #对于数字型的类型选项：（插入图片）
        # b : 以 二进制 的形式输出
print("{:b}".format(44)) # 101100
print("{:#b}".format(44)) # 0b101100 (加一个# 会以0b作为前缀)
        # c : 以 Unicode字符 的形式输出
print("{:c}".format(44)) # ,
# print("{:#c}".format(44)) # 错误，对于c类型不能这样写
        # d : 以 十进制 的形式输出
print("{:d}".format(44)) # 44
print("{:#d}".format(44)) # 44  (加一个# 没有变化)
        # o : 以 八进制 的形式输出
print("{:o}".format(44)) # 54
print("{:#o}".format(44)) # 0o54  (加一个# 会以0o作为前缀)
        # x : 以 十六进制 的形式输出，小写abcdef
        # X : 以 十六进制 的形式输出，大写ABCDEF
print("{:x}".format(43)) # 2b
print("{:#x}".format(43)) # 0x2b  (加一个# 会以0x作为前缀)
print("{:X}".format(43)) # 2B
print("{:#X}".format(43)) # 0X2B  (加一个# 会以0X作为前缀)
        # n : 以十进制的形式输出，但它会使用当前语言环境设置的分隔符插入到恰当的位置
print("{:n}".format(44444)) # 44444
print("{:#n}".format(44444)) # 44444 (加一个# 没有变化)
        # None : 默认（什么都不加）以 十进制 的形式输出，和d一样
print("{:}".format(44)) # 44
print("{:#}".format(44)) # 44
 
        #对于浮点数和复数的类型选项：（插入图片）
        # e : 以 科学计数法 的形式输出, 输出的e是小写
        # E : 以 科学计数法 的形式输出, 输出的E是大写
print("{:e}".format(4.4)) # 4.400000e+00
print("{:E}".format(4.4)) # 4.400000E+00       
        # f : 以 定点表示法 的形式输出（默认精度为6，不是数用nan表示，无穷用inf表示）
        # F : 以 定点表示法 的形式输出（默认精度为6，不是数用nan表示，无穷用inf表示）
print("{:f}".format(4.4)) # 4.400000
print("{:F}".format(4.4)) # 4.400000
        # g : 通用格式，浮点数以'f'的形式输出，大数用'e'的形式输出
        # G : 通用格式，浮点数以'F'的形式输出，大数用'E'的形式输出
print("{:g}".format(4.4)) # 4.400000
print("{:G}".format(4.4)) # 4.400000
print("{:g}".format(4000000000000000)) # 4e+15
print("{:G}".format(4000000000000000)) # 4E+15
        # n : 通用格式，和g类似，但它会使用当前语言环境设置的分隔符插入到恰当的位置
print("{:n}".format(4000000000000000)) # 4000000000000000
        # % :以百分比的形式输出（将数字乘以100，并以定点表示法(f)显示，后面附带一个百分号）
print("{:%}".format(3.14)) # 314.000000% (默认精度为6个小数)
        #设置精度
print("{:.2%}".format(3.14)) # 314.00%
        #通过关键字选项设置精度
print("{:.{prec}%}".format(3.1415,prec = 2)) # 314.15%

    #12.通过多个关键字设定格式
print("{:{fill}{align}{width}.{prec}{ty}}".format(3.1415,fill = '+', align = '^', width = 10,
                                                  prec = 3, ty = 'g')) #+++3.14+++
print("{:+^10.3g}".format(3.1415)) #+++3.14+++

    #13. f字符串(在 Python3.6 后引入了f字符串，它相比于format方法更便捷，更高效)
print(f"{3.1415:+^10.3g}") # +++3.14+++（要格式化的数字放右边）
print(f"1 + 2 = {1+2}, 2的平方是{2*2}, 3的立方是{3*3*3}") #1 + 2 = 3, 2的平方是4, 3的立方是27
year = 2022
print(f"今年是{year}年") #今年是2022年