section1= "%s不必说碧绿的菜畦，%s光滑的石井栏，%s高大的皂荚树，%s紫红的桑椹" %(1,2,3,4)
print(section1)

section2= "{:d}也不必说鸣蝉在树叶里长吟，{:d}肥胖的黄蜂伏在菜花上，{:d}轻捷的叫天子（云雀）忽然从草间直窜向云霄里去了".format(1,2,3)
print(section2)

serial_no1=1
serial_no2=2
section3 =f"{serial_no1:d}油蛉在这里低唱，{serial_no2:d}蟋蟀们在这里弹琴。"
print(section3)

# 1. 填充形式和顺序，只支持固定顺序依次填充
string1= "%s，%s，%s，%s" %("不必说碧绿的菜畦","光滑的石井栏","高大的皂荚树","紫红的桑椹")
print(string1)

# 2. 固定长度填充，在字符串左侧填充
# 不指定长度
string2 = "%s" %("不必说")
print(string2,len(string2))
# 指定填充长度为10，字符长度低于指定长度，在左侧填充
string3 = "%10s" %("不必说碧绿的菜畦")
print(string3,len(string3))
#指定填充长度为10，字符长度长于指定长度，填充无效
string4 = "%10s" %("不必说碧绿的菜畦，光滑的石井栏")
print(string4,len(string4))

# 3. 对齐，实现对齐功能，只有左对齐和右对齐
# 左填充
string5 = '%20s' % ('不必说碧绿的菜畦')
print(string5,len(string5))
# 右填充
string6 = '%-20s' % ('不必说碧绿的菜畦')
print(string6,len(string6))

# 1. 位置匹配三种方式
# 不带编号，即“{}”
string7= "{}，{}，{}，{}".format("不必说碧绿的菜畦","光滑的石井栏","高大的皂荚树","紫红的桑椹")
print(string7)
# 带数字编号，可调换顺序，即“{1}”、“{2}”
# 注意：索引从 0 开始编号
string8= "{2}，{3}，{0}，{1}".format("不必说碧绿的菜畦","光滑的石井栏","高大的皂荚树","紫红的桑椹")
print(string8)
# 带关键字，即“{a}”、“{tom}”
string9= "{first}，{second}，{third}，{fourth}".format(third="不必说碧绿的菜畦",fourth="光滑的石井栏",first="高大的皂荚树",second="紫红的桑椹")
print(string9)

# 2. 固定长度填充，在字符串右侧填充
# 不指定长度
string10 = "{}".format("不必说")
print(string10,len(string10))
# 指定填充长度为10，字符长度低于指定长度，在右侧填充
string11 = "{:10s}".format("不必说碧绿的菜畦")
print(string11,len(string11))
#指定填充长度为10，字符长度长于指定长度，填充无效
string12 = "{:10s}".format("不必说碧绿的菜畦，光滑的石井栏")
print(string12,len(string12))

# 3. 对齐，实现对齐功能，不仅有左填充、右填充，还有居中填充
# 左填充
string13 = '{:_>20}'.format('不必说碧绿的菜畦')
print(string13,len(string13))
# 右填充
string14 = '{:_<20}'.format('不必说碧绿的菜畦')
print(string14,len(string14))
# 居中填充
string15 = '{:_^20}'.format('不必说碧绿的菜畦')
print(string14,len(string15))

# 1. 位置匹配 ，在{}中输入变量即可
str1 = "不必说碧绿的菜畦"
str2 = "光滑的石井栏"
str3 = "高大的皂荚树"
str4 = "紫红的桑椹"
string16 = f"{str1}，{str2}，{str3}，{str4}"
print(string16)

# 2. 固定长度填充，在字符串右侧填充
# 指定填充长度为10，字符长度低于指定长度，在右侧填充
str5 = "不必说碧绿的菜畦"
str6 = "不必说碧绿的菜畦，光滑的石井栏"
string17 = f"{str5:10}"
print(string17,len(string17))
# 指定填充长度为10，字符长度长于指定长度，填充无效
string18 = f"{str6:10}"
print(string18,len(string18))

# 3. 对齐，实现对齐功能，不仅有左填充、右填充，还有居中填充
# 左填充
string19 = f'{str5:_>20}'
print(string19,len(string19))
# 右填充
string20 = f'{str5:_<20}'
print(string20,len(string20))
# 居中填充
string21 = f'{str5:_^20}'
print(string21,len(string21))

# 补位对齐、正负号显示、百分数、分割号“,”、科学计数法
pi = 3.1415926
Five = 5
Ten = 10
Num = 10000000
Fraction = 0.25
print(f"{pi:.2f}")
print(f"{pi:+.2f}")
print(f"{pi:.3f}")
print(f"{Five:0>2d}")
print(f"{Five:x<4d}")
print(f"{Ten:x<4d}")
print(f"{Num:,}")
print(f"{Num:.2e}")
print(f"{Num:.2E}")
print(f"{Fraction:.2%}")
print(f"{Five:>10d}")
print(f"{Five:<10d}")
print(f"{Five:^10d}")

# c 字符。在打印之前将整数转换为相应的unicode字符。
A_char = 0x41
a_char = 0x61
v0_char = 0x30
print(f"{A_char:c}")
print(f"{a_char:c}")
print(f"{v0_char:c}")

# 进制转化
Ele = 11
print( "f'{var:d}'格式测试")
print(f'11 二进制{Ele:b}') 
print(f'11 十进制{Ele:d}') 
print(f'11 八进制{Ele:o}')
print(f'11 16进制{Ele:x}')
print(f'11 带0x的小写16进制{Ele:#x}')
print(f'11 带0X的大写16进制{Ele:#X}\n')
print( "str.format()格式测试")
print('11 二进制{:b}'.format(11)) 
print('11 十进制{:d}'.format(11)) 
print('11 八进制{:o}'.format(11))
print('11 16进制{:x}'.format(11))
print('11 带0x的小写16进制{:#x}'.format(11))
print('11 带0X的大写16进制{:#X}'.format(11))

for x in range(1, 11):
    print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
    # Note use of 'end' on previous line
    print(repr(x*x*x).rjust(4))

# 字符串对象的 str.rjust() 方法通过在左侧填充空格，对给定宽度字段中的字符串进行右对齐。同类方法还有 str.ljust() 和 str.center() 。这些方法不写入任何内容，只返回一个新字符串，如果输入的字符串太长，它们不会截断字符串，而是原样返回；虽然这种方式会弄乱列布局，但也比另一种方法好，后者在显示值时可能不准确（如果真的想截断字符串，可以使用 x.ljust(n)[:n] 这样的切片操作 。）
print('12'.zfill(5))
print('-3.14'.zfill(7))
print('3.14159265359'.zfill(5))

# 字符串和整型符号添加注意圣西昂 
int = 3000
str_3000 = "3000" 
# 不添加类型，整数和字符串都可以
print(f"{int:}")
print(f"{str_3000:}")
print(f"{int:d}")
# 添加整型，字符串变量会出错
print(f"{str_3000:d}")