标签：字符 name 回顾 索引 s1 周末 print 变量名
数据类型及内置方法
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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。