周末回顾
作者：互联网
数据类型及内置方法
1、整型
1.关键字：int
整型就是纯整数，本质是用来存储整数并且能够获取。
变量名 = 整数（右边是数据值，左边是绑定的名字）
a = 22
2.补充
1.类型转换
变量名 = int(变量名或数据值)
只能转换纯数字且为整数的数据值。
2.进制转换
整数是默认的十进制数，十进制可转化为二进制、八进制、十六进制
bin(数据值) # 十进制转化为二进制
oct(数据值) # 十进制转化为八进制
hex(数据值) # 十进制转化为十六进制
print(bin(100)) # 0b1100100 0b是二进制的标识
print(oct(100)) # 0o144 0o是八进制的标识
print(hex(100)) # 0x64 0x是十六进制的标识
将其它进制数转换成十进制有两种方式，一种是不用提醒它要转几进制，另一种是需要提醒转换成几进制，但是第一种比较简单快捷
print(int(0b1100100)) # 100
print(int(0o144)) # 100
print(int(0x64)) # 100
print(int('0b1100100', 2)) # 100
print(int('0o144', 8)) # 100
print(int('0x64', 16)) # 100
2、浮点型
1.关键字：float
浮点型是带有一个小数点的数字，本质是存储数据。
变量名 = 小数（右边是数据值，左边是绑定的名字）
a = 2022.06
2.补充
1.类型转换
变量名 = float(变量名或数据值)
输入的字符型为整数和带有一个小数点的数据值可转化为浮点型，若将整数转化为浮点型即数据值后面加上.0
2.针对布尔值
将布尔值转换为浮点型时，对应的数值后面加.0
1.类型转换
可转换为为浮点型，后面加了.0；只能转换含有一个小数点的数值。
print(float('222')) # 222.0
print(float('-222')) # -222.0
print(float('22.2')) # 22.2
print(float('222w')) # 报错
print(float('222.222.222')) # 报错
2.针对布尔值
可将布尔值转换为对应的数值后面加.0
print(float(True)) # 1.0
print(float(False)) # 0.0
3.补充说明
python对数字的敏感度不高，有些数值进行计算时会出错。
print(23.0 * 3.2) # 73.60000000000001
3、字符型
1.关键字：str
字符型就是用引号引起来的部分，本质是用来存储文本
变量名 = '数据'（右边是引号引起来的部分，左边是绑定的名字）
a = '橘子'
b = "苹果"
c = '''西瓜'''
d = """甘蔗"""
2.补充
1.类型转换
任何数据类型都可以转换为字符型，如整型、浮点型、列表、字典等。
2.引号
引号有：' '，" "，''' '''，""" """。由于定义字符串时内部可能同样需要使用引号，而字符串会在第一个引号后找到相同的引号会自动闭合，若单一引号则会报错。
3.内置方法
1.索引取值
变量名[ ]
s1 = 'hello word'
print(s1[3]) # l
print(s1[-3]) # o
字符串的索引取值是按从左向右的顺序，且第一个字符的索引值为0。[ ]中只有一个数值，取出的是单个字符，且空格也算一个字符，若[ ]中的数值为负数代表反向索引，顺序是从右向左。
2.切片取值
变量名[ 左 : 右 ]
s1 = 'hello word'
print(s1[2:6]) # llo
print(s1[-2:-6]) # 无
print(s1[-6:-2]) # o wo
左右都为数字中间用 : 隔开。左边的数值代表第一个索引对应的数据值，右边的数值代表最后一个索引对应的数据值，这样取到的是一段数据值，顺序是从左向右。若两个数据值都为负数，则代表反向索引，但是顺序还是从左往右，且负数小的在左负数大的在左。
变量名[ 左 : 中 : 右 ]
s1 = 'hello word'
print(s1[1:10:2]) # el od
'''[::]，若想反向取值必须要三个数值都为负数，且从右往左取值'''
s1 = 'hello word'
print(s1[1:3:-1]) # 无
print(s1[-1:-3:1]) # 无
print(s1[-1:-3:-1]) # dr
左右中都为数字中间都用 : 隔开。左边的数值代表第一个索引对应的数据值，中间的数值代表最后一个索引对应的数据值，右边的数值代表间隔(差)几个字符。顺序是从左往右
3.间隔方向
变量名[ 左 : 右 ]
当左右数值都为负数时代表反向索引，但是顺序还是从左往右。[:]代表取字符串内所有的值。
s1 = 'hello word'
print(s1[:]) # hello word
print(s1[::3]) # hlwd
print(s1[-2:-6]) # 无
print(s1[-6:-2]) # o wo
变量名[ 左 : 中 : 右 ]
当所有数值都为负数时代表是反向索引，顺序为从右往左，且负数大的在左负数小的在右。
s1 = 'hello word'
print(s1[1:8:1]) # ello wo
print(s1[1:8:2]) # el o
print(s1[1:8:-1]) # 无
print(s1[-1:-8:-1]) # drow ol
print(s1[-8:-1:-1]) # 无
4.统计字符串的个数
len(要统计的变量名或字符串)
字符串(引号)内的空格、标点符号、特殊符号等都算一个字符
s1 = 'In the future, you will thank you for your efforts'
print(len(s1)) # 50
5.移除字符串首尾字符的个数
字符串或变量名.strip(要移除的字符) # 移除首尾的字符
字符串或变量名.lstrip(要移除的字符) # 移除左边的字符
字符串或变量名.rstrip(要移除的字符) # 移除右边的字符
'''注意的是只能移除首尾，中间不可移除'''
s1 = ' hello word '
print(s1, len(s1)) # hello word 16
print(s1.strip(), len(s1.strip())) # hello word 10
s2 = '$$$hahahha$wowowo$$$'
print(s2.lstrip('$')) # hahahha$wowowo$$$
print(s2.rstrip('$')) # $$$hahahha$wowowo
'''字符串调用内置方法，不是改变原数据值，而是产生了新的数据值'''
s2 = '$$$hahahha$wowowo$$$'
s2.strip('$')
print(s2) # $$$hahahha$wowowo$$$
print(s2.strip('$')) # hahahha$wowowo
6.按照指定的字符切割字符串
按照指定的字符将字符串切割成几个字符串，以列表的方式输出。
字符串或变量名.split(要切割的字符) # 要切割所有的字符
字符串或变量名.split(要切割的字符， maxsplit=整数) # 要切割从左到右的第几个的字符
字符串或变量名.rsplit(要切割的字符， maxsplit=整数) # 要切割从右到左的第几个的字符
s1 = '今天下雨了*我不喜欢下雨*但是我又讨厌热'
print(s1.split('*')) # ['今天下雨了', '我不喜欢下雨', '但是我又讨厌热']
print(type(s1.split('*'))) # <class 'list'>
info1, info2, info3 = s1.split('*') # info1, info2, info3 = ['今天下雨了', '我不喜欢下雨', '但是我又讨厌热']
print(info1, info2, info3) # 今天下雨了 我不喜欢下雨 但是我又讨厌热
print(s1.split('*', maxsplit=1)) # ['今天下雨了', '我不喜欢下雨*但是我又讨厌热']
print(s1.rsplit('*', maxsplit=1)) # ['今天下雨了*我不喜欢下雨', '但是我又讨厌热']
7.字符串的大小写
用于将字符串的英文设置为全部大写或者全部小写，可判断字符串中的英文是否是大小写，但是只是针对字母。
字符串或变量名.lower() # 将字母都转换成小写
字符串或变量名.upper() # 将字母都转换成大写
字符串或变量名.islowwer() # 判断字母是否小写
字符串或变量名.isupper() # 判断字母是否大写
s1 = 'HELLO WORD 8888'
s2 = 'hello word 8888'
s3 = 'Hello word 8888'
print(s1.lower()) # hello word 8888
print(s2.upper()) # HELLO WORD 8888
print(s3.lower()) # hello word 8888
print(s3.upper()) # HELLO WORD 8888
print(s1.isupper()) # True
print(s1.islower()) # False
print(s2.isupper()) # False
print(s2.islower()) # True
print(s3.islower()) # False
print(s3.isupper()) # False
8.格式化输出
格式化输出就是先占位然后再输出
方式1：%s占位，支持所有数据类型
# info1 = "亲爱的%s你好！你%s月的话费是%s，余额是%s"
# print(info1 % ('橘女士', 5, 19, 5))
# print("亲爱的%s你好！你%s月的话费是%s，余额是%s" % ('小橘', 5, 39, -15))
方式2：%d占位，只给数字站位
# info2 = "亲爱的%s你好！你%s月的话费是%s，余额是%s"
# print(info2 % ('橘女士', 5, 19, 5))
# print("亲爱的%s你好！你%s月的话费是%s，余额是%s" % ('小橘', 5, 39, -15))
# 可产生固定位数的数据
# print('%06d' % 222)
方式3：等价于%s，利用{}，format()
s1 = 'my name is {}, my age is {}'
print(s1.format('orange', 22)) # my name is orange, my age is 22
方式4：支持索引取值，并可重复使用，利用{索引值}，format()
s2 = '{0} {1} my name is {0}, my age is {1} {0} {1}'
print(s2.format('orange', 22)) # orange 22 my name is orange, my age is 22 orange 22
方式5：支持关键字取值，相当于按K取值，并且支持重复使用，利用{变量名}，用赋值的方式给值，format()
s3 = '{name} {age} my name is {name}, my age is {age} {name} {age}'
print(s3.format(name='orange', age=22)) # orange 22 my name is orange, my age is 22 orange 22
方式6：先定义好变量然后用{变量名}占位(必记，重点！！！)。字符串的外面要加上'f'，首先要定义好变量，利用{变量名}，format()
name = 'orange'
age = 18
print(f'{name} {age} my name is {name}, my age is {age} {name} {age}') # orange 22 my name is orange, my age is 22 orange 22
9.统计字符串指定字符出现的次数
统计指定字符在字符串中出现的次数，相当于利用循环查询指定字符的次数
字符串或变量名.count(指定的字符)
s1 = 'I want to See Sea'
print(s1.count('e')) # 3
10.判断字符串的开头或者结尾
判断字符串的开头或者结尾是否是某个字符
字符串或变量名.startswith(指定的字符) # 判断指定字符是否在开头
字符串或变量名.endswith(指定的字符) # 判断指定字符是否在结尾
s1 = 'I want to See Sea'
print(s1.startswith('I')) # True
print(s1.startswith('a')) # False
print(s1.endswith('I')) # False
print(s1.endswith('a')) # True
11.字符串的替换
将某个字符替换成指定的字符，即旧的字符替换成新的字符。并且可以指定替换的个数，只能从左向右替换不能从右向左替换。
字符串或变量名.replace(原来的字符(老字符)，指定的字符(新字符)，数值) # 将原来的字符替换成指定的字符，数值代表替换的个数。
s1 = 'I want to see sea sea sea'
print(s1.replace('sea', '大海', 2)) # I want to see 大海 大海 sea
12.字符串的拼接
将指定的字符拼接到字符串中，将要拼接的内容放入列表中，但是列表中的数据必须是字符串。拼接可使用某些符号如+、*、|、$、@...
加号也可以拼接字符串，但是注意的是只能在字符串数量较少的情况下拼接，否则会消耗内存，若字符串的数量较大推荐使用join
拼接的字符.join(要被拼接的字符)
print('girl' + 'friend') # girlfriend
print('go' * 6) # gogogogogogo
print(''.join(['girl', 'friend', 'you'])) # girlfriendyou
print('@'.join(['girl', 'friend', 'you'])) # girl@friend@you
print('$'.join(['girl', 'friend', 'you'])) # girl$friend$you
print('$'.join(['girl', 'friend', 'you', 8888])) # 报错
13.判断字符串中是否是纯数字
判断字符串中的数据是否都为纯数字，对应输出的布尔值是True和False
字符串或变量名.isdigit()
print('123'.isdigit()) # True
print('123a'.isdigit()) # False
print(''.isdigit()) # False
14.查找某个字符对应的索引值
通过指定的字符找到索引的位置，指定的字符可以是单个字节也可以是多个字节，但是是按当字节的索引去查找。当出现多个时取第一个索引值。若指定索引的位置查找时注意find和index在没有找到对应的索引值出现的情况。
index(查找字符，首索引，尾索引)
find(查找字符，首索引，尾索引)
# index在进行索引查找时，从左向右找，如果没有查找到对应的索引值则会报错
# find在进行索引查找时，从左向右找，如果没有查找到对应的索引值则会返回数值-1
s1 = 'I want to See'
print(s1.index('s')) # 10
print(s1.find('s')) # 10
print(s1.index('s', 0, 6)) # 报错 从索引0找到索引6
print(s1.find('s', 0, 6)) # -1
15.正文相关操作
将字符串中的首字母大写，只针对英文单词，对中文无效。
字符串或变量名.title()
s1 = 'i want to see'
print(s1.title()) # I Want To See
s2 = '我想要回家'
print(s2.title()) # 我想要回家
4、列表
1.关键字：list
能够存储多个数据，并且能够方便地获取整体或全部的数据。
中括号括起来，内部可以存放多个不同数据类型的数据值，数据值之间用逗号隔开。
a = [111,222,333,444,555,666]
b = ['橘子', 22, 1.57, '安徽池州']
2.补充
列表是可以进行索引取值的，索引是按照0开始从左往右数。在索引取值过程中若超出索引的范围会报错。
在类型转换过程中，能够被for循环的数据类型都可以转换成列表，记住整型和浮点型是不可以的，因为整型和浮点型是一个数而不是一个集合，不是可迭代对象。
fruit_list = ['甘蔗', '西瓜', '提子', '葡萄']
'''索引取值：通常是从0开始往后数值，与一般生活数值从1数有所不同'''
# print(fruit_list[2]) # 提子
# print(fruit_list[5]) # 报错，索引超出范围会直接报错
l1 = ['你好', '我是橘子', [111, 222, ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]]]
'''遇到较为复杂构造的数据，先明确整体有几个数据值，然后进行拆分'''
# print(l1[2]) # [111, 222, ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]]
# l2 = l1[2]
# print(l2) # [111, 222, ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]]
# print(l2[2]) # ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]
# l3 = l2[2]
# print(l3) # ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]
# print(l3[2]) # ['hehe', 'haha', 'eeee']
# l4 = l3[2]
# print(l4) # ['hehe', 'haha', 'eeee']
# print(l4[2]) # eeee
# l5 = l4[2]
# print(l5) # eeee
3.内置方法
1.索引取值
变量名[ ]
若索引中[ ]的值为正整数则代表从左往右，按照索引0到数值减一取值。若[ ]的值为负数则代表从右往左。
s1 = ['name', 'age', 22, 33]
print(s1[1]) # age
print(s1[-2]) # 22
2.切片操作
变量名[ 左 : 右]
左右都为数字中间用 : 隔开。左边的数值代表第一个索引对应的数据值，右边的数值代表最后一个索引对应的数据值，这样取到的是一段数据值，顺序是从左向右。若两个数据值都为负数，则代表反向索引，但是顺序还是从左往右，且负数小的在左负数大的在左。
s1 = ['name', 'age', 22, 33]
print(s1[1:3]) # ['age', 22]
print(s1[:]) # ['name', 'age', 22, 33]
print(s1[-1:-2]) # [] 取不到
print(s1[-2:-1]) # [22]
3.间隔/方向
变量名[ 左 : 中 : 右]
左右中都为数字中间都用 : 隔开。左边的数值代表第一个索引对应的数据值，中间的数值代表最后一个索引对应的数据值，右边的数值代表间隔(差)几个字符。顺序是从左往右。若都为负数时，表示反向取值，且负数小的在左负数大的在右，但是是从左向右取值。
s1 = ['name', 'age', 22, 33]
print(s1[0:3:2]) # ['name', 22]
print(s1[-1:-3:1]) # [] 无
print(s1[-3:-1:1]) # ['age', 22]
4.统计列表的个数
len(要统计的变量名或列表)
统计列表的个数是以列表中逗号隔开的数据值为单位进行的统计
s1 = ['name', 'age', 22, 33]
print(len(s1)) # 4
5、字典
1.关键字：dict
能够存储多个数据，能够方便获取整体或局部的数据，且对数据有解释
大括号括起来，内部存放到多个数据值，且数据的组织形式是按K:V键值对
K：对V描述性性质的信息，一般是字符串
V：是真实的数据值，可以是任意类型的数据类型
a = {'name': '橘子', 'age': 18, 'hobby': '看电影吃吃吃'}
2.补充
字典进行取值的方法时都是取K值，无法使用索引取值，因为字典是无序的
info_dict = {'name': '橘子', 'age': 18, 'hobby': '看电影吃吃吃'}
'''字典取值是使用按K取值，字典无法使用索引是因为字典是无序的'''
# print(info_dict['name']) # 橘子
# print(info_dict['hobby']) # 看电影吃吃吃
# print(info_dict['height']) # 报错，K不存在
data = {
'name': 'jason',
'others': [
111,
222,
{
'a1': '嘿嘿',
'a2': '哈哈',
'a3': [
123,
{
'name': 'jason1',
'age': 18
}]}]}
# 1.先获取大列表
l1 = data['others']
# print(l1) # [111, 222, {'a1': '嘿嘿', 'a2': '哈哈', 'a3': [123, {'name': 'jason1', 'age': 18}]}]
# 2.获取大列表中的字典
d1 = l1[2]
# print(d1) # {'a1': '嘿嘿', 'a2': '哈哈', 'a3': [123, {'name': 'jason1', 'age': 18}]}
# 3.获取字典的值
l2 = d1['a3']
# print(l2) # [123, {'name': 'jason1', 'age': 18}]
# 4.获取列表的数据
l3 = l2[1]
# print(l3) # {'name': 'jason1', 'age': 18}
# 5.按k取值
# print(l3['age'])
"""上述可以简写成一步"""
print(data['others'][2]['a3'][1]['age'])
6、布尔型
1.关键字：bool
用于描述事物是否正确是否可行是否合理，True和False。
布尔值是最简单的数据类型，但是使用频率高，一般定义布尔值以is开头。
is_right = True # 真 可以 正确
is_delete = False # 假 不可以 错误
2.补充
所有的数据类型都可以转换成布尔型，为False的数据类型有：0、None、空字符串、空列表、空字典、空集合...除了这些都是True.
所有的编程语言都有布尔值，但是关键字和值可能有所不同，如JavaScript中的关键字是Boolean。
7、元组
1.关键字：tuple
小括号括起内部能够存放任意数据类型的数据。能够存储多个数据并且能够方便获取整体或全部。
a = (1, 2, 3)
2.补充
与列表的区别是，元组内的数据值时不能直接修该的（不可修改的列表），作用是只能存储不能修改，而列表内的数据值是可以修改的。
a = [1, 2, 3]
b = (1, 2, 3)
# print(a[0])
# print(b[0])
# a[0] = 'hahaha' # 将列表索引0重新绑定新的数据值
# print(a) # ['hahaha', 2, 3]
# b[0] = 'hahaha' # 将元组索引0重新绑定新的数据值，报错
# print(b)
8、集合
1.关键字：set
集合只能用去去重和关系运算，去重是自动去重复的数据，关系运算时判断两个集合之间的数据值关系。
a = {1, 2, 3}
2.补充
在定义空集合时注意的是，不能直接以变量名 = {}定义，因为这是默认字典的空集合，必须使用关键字set().
a = {} # 大括号默认是看成字典的
b = {}
print(type(a)) # dict
print(type(b)) # dict
c = set() # 必须使用关键字才能定义空集合
print(type(c))
用户交互
1.输入
向计算机传递数据 input()
1.先获取用户输入的数据
2.再赋值给左边的名字name
3.之后就可以通过名字name使用用户输入的数据
4.input获取到的用户输入都会转成字符串类型
name = input('请输入您的用户名:')
print(name)
2.输出
向计算机输出信息 print()
print() # 打印数据值
print(123) # 括号内可以直接放数据值
name = '橘子'
print(name) # 括号内可放名字
print(123,321,323) # 括号内也可以一次性打印多个数据值
3.补充
换行符：\n \r \r\n
最早起的换行是：\r\n
后面简化成了：\n \r(不同的操作系统可能会有变化)
基本运算符
1.算术运算
加 + +=
减 - -=
乘 * *=
除 / /=
取整 // //=
取模 % %=
幂指数 **(次方) **=
2.比较运算符
等于 ==
不等于 !=
大于 >
小于 <
小于或等于 <=
大于或等于 >=
多种赋值运算
1.链式赋值
同一个值同时赋值给多个变量名
x = y = z = 10
2.交叉赋值
将m与n的数据值交换
m = 6
n = 8
m,n=n,m
3.解压赋值
将列表中的多个值取出来依次赋值给多个变量名。赋值符号左边的至少有两个及以上的名字才能够称为解压赋值。等号左边的变量名个数必须与右边包含值的个数必须相同。
若只想取开头和结尾的几个值可以用*_匹配，适合解压数据非常多的时候。
nums = [1,2,3,4]
a = nums[0]
b = nums[1]
c = nums[2]
d = nums[3]
运算符
1、逻辑运算符
and 是（条件都要成立或满足）
or 或（只需要一个条件成立或满足）
not 非（与原本意义的相反）
and链接的多个条件必须都满足时，结果才会成立，输出的布尔值为True
or链接的多个条件满足任意一个时，结果才会成立，输出的布尔值为True
not链接的多个条件只要与原本意思相反便可成立，即对就是错错就是对
三者混合使用时时具有优先级的：() > not > and > or
2、成员运算符
in 是否包含某条件，输出正确为True
not in 是否不包含某条件，输出正确为True
列表在做成员运算时，是以两个逗号之间的数据值为最小单位的，不能进行拆分和整合。
字符在做成员运算时，是以单个字节为最小单位的。
字典在做成员运算时，是以K值为最小单位的，不能使用K:V键值对也不能使用V值。
3、身份运算符
is 判断两个变量之间的内存地址是否是相同的
== 判断两个变量对应的数据值是否是相等的
id() # 用于查看变量的内存地址
'''值相等的内存地址可能不相等，内存地址相等的值肯定相等'''
流程控制
1、顺序结构
从第一天学习python起我们所用的就是顺序结构，代码是自上而下执行的。
2、分支结构
分支结构是先判断条件是否成立满足然后再执行不同流程的代码。
if...
if...else...
if...elif...else...
1.if单分支
if 条件：
条件成立执行的子代码块
2.if..else..
if 条件：
条件成立执行的子代码
else:
条件不成立执行的子代码
3.if...elif..else...
if 条件1：
条件1成立执行的子代码
elif 条件2：
条件1不成立条件2成立执行的子代码
else:
条件1和条件2都不成立执行的子代码
4.if嵌套
if 条件1：
条件1成立执行的子代码
if 条件2：
条件2成立执行的子代码 # 条件2执行的条件是条件1成立
3、while循环结构
1.while循环
while 条件：
条件成立后循环执行的子代码
# while后面的条件成立后执行子代码，回到while处再进行条件是否成立，若成立继续执行，不成立则结束
2.while + break
while 条件：
条件执行循环的子代码
break # 强制结束，退出循环，不会再回到while条件处进行判断
3.while + continue
while 条件：
条件成立执行的子代码
continue # 结束本次循环回到while条件处进行判断，条件成立则进行下次循环
4.while + else
while 条件：
条件成立执行的子代码
else：
条件不成立执行的子代码
5.补充（死循环与全局标示位）
死循环是指在循环程序中不断计算的情况，会占用内存，不允许使用。
全局标志位，先定义全局标志位为某个值，然后后面调佣全局标志位，可改变全局标志位的值相当于条件不成立。用于循环语句中，节省代码的编写。
4、for循环结构
1.for循环
for 变量名 in 可迭代对象： # 可以是字符串、字典、列表等，不可以是整型和浮点型
for循环的循环体代码
2.for + break
for 变量名 in 可迭代对象：
for循环的循环体代码
break # 强制结束for循环语句
3.for + continue
for 变量名 in 可迭代对象：
for循环的循环体代码
continue # 结束本次循环，回到for条件判断处，若条件成立则继续执行，若不成立结束
4.for + else
for 变量名 in 可迭代对象：
for循环的循环体代码
else:
for循环处条件不成立执行的子代码 # 只有当for循环条件不成立时才会执行
5.range方法
for i in range()
条件成立执行的子代码
range():
range的()里只有一个数值时，代表从0开始到数字减一（顾头不顾尾）
range(,)
range的()里面有两个数值时，左边的数值代表起始的数据值，右边的数值代表最终的数据值减一
range(,,)
range的()里面有三个数值时，左边的数值代表其实的数据值，中间的数值代表最终的数据值减一，右边的数据值代表差值，相当于等差数列，首项是左边的数值，中间的值代表末项的数据值减一，右边的值代表公差。
标签：字符,name,回顾,索引,s1,周末,print,变量名 来源： https://www.cnblogs.com/xiaojudeboke/p/16414240.html