数据管理
Python |
---|
文章目录
-
数据处理概述
数据处理的基本目的是从大量的、可能是杂乱无章的、难以理解的数据中抽取并推导出对于某些特定的人们来说是有价值、有意义的数据。当下数据处理贯穿于社会生产和社会生活的各个领域。数据处理技术的发展及其应用的广度和深度,极大地影响了人类社会发展的进程。数据处理也是大数据,数据分析等后续科学的基本环节。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f5189f1d-1630919085072)(./img/data.jpeg)]
-
基本概念
- 数据 : 能够输入到计算机中并被识别处理的信息集合。
-
数据存储阶段
-
人工管理阶段:人为管理,没有固定的格式和存储方法,容易混乱。
-
文件管理阶段 :数据可以长期保存,存储数据量大,使用简单。
-
数据库管理阶段:高效,可以存储更大量数据,便于管理,更加专业。
-
1. 文件处理
1.1 引入
-
什么是文件
文件是保存在持久化存储设备(硬盘、U盘、光盘…)上的一段数据,一个文本,一个py文件,一张图片,视频音频等这些都是文件。
-
文件分类
- 文本文件:打开后会自动解码为字符,如txt文件,word文件,py程序文件。
- 二进制文件:内部编码为二进制码,无法通过文字编码解析,如压缩包,音频,视频,图片等。
-
字节串类型
-
概念 : 在python3中引入了字节串的概念,与str不同,字节串以字节序列值表达数据,更方便用来处理二进程数据。
-
字符串与字节串相互转化方法
- 普通的英文字符字符串常量可以在前面加b转换为字节串,例如:b'hello' - 变量或者包含非英文字符的字符串转换为字节串方法 :str.encode() - 字节串转换为字符串方法 : bytes.decode() 注意:python字符串用来表达utf8字符,因为并不是所有二进制内容都可以转化为utf8字符,所以不是所有字节串都能转化为字符串,但是所有字符串都能转化成二进制,所以所有字符串都能转换为字节串。
-
1.2 文件读写操作
使用程序操作文件,无外乎对文件进行读或者写
- 读 :即从文件中获取内容
- 写 :即修改文件中的内容
对文件实现读写的基本操作步骤为:打开文件,读写文件,关闭文件。
1.2.1 打开文件
file_object = open(file_name, access_mode='r', buffering=-1,encoding=None)
功能:打开一个文件,返回一个文件对象。
参数:file_name 文件名;
access_mode 打开文件的方式,如果不写默认为‘r’
buffering 1表示有行缓冲,默认则表示使用系统默认提供的缓冲机制。
encoding='UTF-8' 设置打开文件的编码方式,一般Linux下不需要
返回值:成功返回文件操作对象。
打开模式 | 效果 |
---|---|
r | 以读方式打开,文件必须存在 |
w | 以写方式打开,文件不存在则创建,存在清空原有内容 |
a | 以追加模式打开,文件不存在则创建,存在则继续进行写操作 |
r+ | 以读写模式打开 文件必须存在 |
w+ | 以读写模式打开文件,不存在则创建,存在清空原有内容 |
a+ | 追加并可读模式,文件不存在则创建,存在则继续进行写操作 |
rb | 以二进制读模式打开 同r |
wb | 以二进制写模式打开 同w |
ab | 以二进制追加模式打开 同a |
rb+ | 以二进制读写模式打开 同r+ |
wb+ | 以二进制读写模式打开 同w+ |
ab+ | 以二进制读写模式打开 同a+ |
注意 :
- 以二进制方式打开文件,读取内容为字节串,写入也需要写入字节串
- 无论什么文件都可以使用二进制方式打开,但是二进制文件则不能以文本方式打开,否则后续读写会报错。
文件打开代码示例:open_file.py
# 读方式打开文件
# file = open("../day02/2.txt","r")
# 写方法打开
# file = open("file.txt","w") # 清除原来内容
file = open("file.txt","a") # 不会清除原来内容
# 操作文件
# 关闭
file.close()
1.2.2 读取文件
- 方法1
read([size])
功能: 来直接读取文件中字符。
参数: 如果没有给定size参数(默认值为-1)或者size值为负,文件将被读取直至末尾,给定size最多读取给定数目个字符(字节)。
返回值: 返回读取到的内容
注意:1. 文件过大时候不建议直接读取到文件结尾,占用内存较多,效率较低
2. 读到文件结尾如果继续进行读操作会返回空字符串。
- 方法2
readline([size])
功能: 用来读取文件中一行
参数: 如果没有给定size参数(默认值为-1)或者size值为负,表示读取一行,给定size表示最多读取制定的字符(字节)。
返回值: 返回读取到的内容
- 方法3
readlines([sizeint])
功能: 读取文件中的每一行作为列表中的一项
参数: 如果没有给定size参数(默认值为-1)或者size值为负,文件将被读取直至末尾,给定size表示读取到size字符所在行为止。
返回值: 返回读取到的内容列表
- 方法4
# 文件对象本身也是一个可迭代对象,在for循环中可以迭代文件的每一行。
for line in f:
print(line)
文件读操作代码示例:read_file.py
# 打开文件
# file = open("file.txt","r")
file = open("file.txt","rb")
# 读取内容
data = file.read()
print(data.decode())
# 每次读取一个字符,将文件内容原样打印出来
# while True:
# data = file.read(1)
# if data == "":
# break
# print(data,end="")
# 按行读取
# data = file.readline()
# print(data)
# 读取所有行内容
# data_list = file.readlines()
# print(data_list) # 内容列表
# 迭代每次获取一行
# for line in file:
# print(line)
file.close()
随堂练习:基于 dict.txt 完成
编写一个函数,参数是一个单词,查询这个单词的解释
提示 : 单词有可能查不到 None Not Found
字符串切片 split()
思路 : 使用 word 逐行比对
def find_word(word):
file = open("../day09/dict.txt", "r")
# 每次读取一行
for line in file:
tmp = line.split(' ')[0] # 提取单词
# 如果遍历的单词大于word就不用再找了
if tmp > word:
file.close()
return
elif word == tmp:
file.close()
return line
print(find_word("abc"))
1.2.3 写入文件
- 方法1
write(data)
功能: 把文本数据或二进制数据块的字符串写入到文件中去
参数:要写入的内容
返回值:写入的字符个数
注意: 如果需要换行要自己在写入内容中添加\n
- 方法2
writelines(str_list)
功能:接受一个字符串列表作为参数,将它们写入文件。
参数: 要写入的内容列表
文件写操作代码示例:
# 写打开
file = open("file.txt","w")
# file = open("file.txt","a") # 追加
# 写操作
# n = file.write("hello,死鬼\n".encode())
# file.write("哎呀,干啥\n".encode())
# print("写入字符数:",n)
# 将列表每一项写入到文件
data = [
"接着奏乐\n",
"接着舞\n"
]
file.writelines(data)
file.close()
随堂练习:编写一个函数,参数传入一个指定的文件,将这个文件
复制到程序运行目录下,注意不确定文件类型
思路 : 边读边写
def copy(filename):
"""
将指定文件复制到这个文件夹下
:param filename: 指定的要复制的文件
"""
new_file = filename.split('/')[-1] # 取出文件名
fr = open(filename,"rb") # 原文件
fw = open(new_file,"wb") # 新文件
# 边读边写
while True:
data = fr.read(1024)
if not data:
break
fw.write(data)
fr.close()
fw.close()
copy("/home/tarena/b.jpg")
1.2.4 关闭文件
打开一个文件后我们就可以通过文件对象对文件进行操作了,当操作结束后可以关闭文件操作
- 方法
file_object.close()
- 好处
- 可以销毁对象节省资源,(当然如果不关闭程序结束后对象也会被销毁)。
- 防止后面对这个对象的误操作。
1.2.5 with操作
python中的with语句也可以用于访问文件,在语句块结束后会自动释放资源。
- with语句格式
with context_expression [as obj]:
with-body
- with访问文件
with open('file','r+') as f:
f.read()
注意 : with语句块结束后会自动释放f所以不再需要close().
with 使用示例:
# 临时打开文件简单使用 file = open()
with open("file.txt") as file:
data = file.read()
print(data)
# 语句块结束 file 被销毁
1.2.6 读写缓冲区
-
定义
系统自动的在内存中为每一个正在使用的文件开辟一个空间,在对文件读写时都是先将文件内容加载到缓冲区,再进行读写。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lnTyCRPO-1630919085075)(./img/buffer.jpg)]
-
作用
- 减少和磁盘的交互次数,保护磁盘。
- 提高了对文件的读写效率。
-
缓冲区设置
类型 设置方法 注意事项 系统自定义 buffering=-1 行缓冲 buffering=1 当遇到\n时会刷新缓冲 指定缓冲区大小 buffering>1 必须以二进制方式打开 -
刷新缓冲区条件
- 缓冲区被写满
- 程序执行结束或者文件对象被关闭
- 程序中调用flush()函数
file_obj.flush()
文件读写缓冲示例:buffer.py
# buffering=1 行缓冲
# file = open("file.txt","w",buffering=1)
# buffering > 1 指定缓冲大小
file = open("file.txt","wb",buffering=10)
while True:
data = input(">>")
if not data:
break
file.write(data.encode())
# file.flush() # 刷新缓冲
file.close()
1.2.7 文件偏移量
-
定义
打开一个文件进行操作时系统会自动生成一个记录,记录每次读写操作时所处的文件位置,每次文件的读写操作都是从这个位置开始进行的。
注意:
- r或者w方式打开,文件偏移量在文件开始位置
- a方式打开,文件偏移量在文件结尾位置
-
文件偏移量控制
tell() 功能:获取文件偏移量大小 返回值:文件偏移量
seek(offset[,whence]) 功能: 移动文件偏移量位置 参数:offset 代表相对于某个位置移动的字节数。负数表示向前移动,正数表示向后移动。 whence是基准位置的默认值为 0,代表从文件开头算起,1代表从当前位置算起,2 代表从文件 末尾算起。
注意:必须以二进制方式打开文件时,基准位置才能是1或者2
文件偏移量示例:seek.py
# 可读可写
file = open("file.txt","wb+")
file.write("你好".encode())
file.flush()
# print("文件偏移位置:",file.tell())
# 移动偏移量
file.seek(-3,2)
# file.write("你好".encode())
data = file.read()
print("读取:",data.decode())
file.close()
随堂练习:
编写一个程序,循环不停的写入日志 (my.log)。每2秒写入一行,要求每写入一行都要显示出来。结束程序后(强行结束),重新运行要求继续往下写,序号衔接
1. 2020-12-28 18:18:20
2. 2020-12-28 18:18:22
3. 2020-12-28 18:20:25
4. 2020-12-28 18:20:27
提示: time.ctime() 获取当前时间
time.sleep() 间隔
from time import *
# 每行及时显示
file = open("my.log", 'a+', buffering=1)
# n = 行数 + 1
file.seek(0,0)
n = len(file.readlines()) + 1
while True:
tm = "%d. %s\n"%(n,ctime())
file.write(tm)
n += 1
sleep(2)
1.3 os模块
os模块是Python标准库模块,包含了大量的文件处理函数。
- 获取文件大小
os.path.getsize(file)
功能: 获取文件大小
参数: 指定文件
返回值: 文件大小
- 查看文件列表
os.listdir(dir)
功能: 查看文件列表
参数: 指定目录
返回值:目录中的文件名列表
- 判断文件是否存在
os.path.exists(file)
功能: 判断文件是否存在
参数: 指定文件
返回值: 布尔值
- 删除文件
os.remove(file)
功能: 删除文件
参数: 指定文件
os模块使用示例:file.py
import os
print("文件大小:",os.path.getsize("file.txt"))
print("文件列表:",os.listdir("."))
print("文件是否存在:",os.path.exists("file.txt"))
os.remove("file.txt")
2. 正则表达式
2.1 概述
- 学习动机
- 文本数据处理已经成为常见的编程工作之一
- 对文本内容的搜索,定位,提取是逻辑比较复杂的工作
- 为了快速方便的解决上述问题,产生了正则表达式技术
- 定义
即文本的高级匹配模式,其本质是由一系列字符和特殊符号构成的字串,这个字串即正则表达式。
- 原理
通过普通字符和有特定含义的字符,来组成字符串,用以描述一定的字符串规则,比如:重复,位置等,来表达某类特定的字符串,进而匹配。
- 学习目标
- 熟练掌握正则表达式元字符
- 能够读懂常用正则表达式,编辑简单的正则规则
- 能够熟练使用re模块操作正则表达式
2.2 元字符使用
- 普通字符
匹配规则:每个普通字符匹配其对应的字符
e.g.
In : re.findall('ab',"abcdefabcd")
Out: ['ab', 'ab']
注意:正则表达式在python中也可以匹配中文
- 或关系
元字符: |
匹配规则: 匹配 | 两侧任意的正则表达式即可
e.g.
In : re.findall('com|cn',"www.baidu.com/www.tmooc.cn")
Out: ['com', 'cn']
- 匹配单个字符
元字符:.
匹配规则:匹配除换行外的任意一个字符
e.g.
In : re.findall('张.丰',"张三丰,张四丰,张五丰")
Out: ['张三丰', '张四丰', '张五丰']
- 匹配字符集
元字符: [字符集]
匹配规则: 匹配字符集中的任意一个字符
表达形式:
[aeiou你我他] 表示 [] 中的任意一个字符
[0-9],[a-z],[A-Z] 表示区间内的任意一个字符
[_#?0-9a-z] 混合书写,一般区间表达写在后面
e.g.
In : re.findall('[aeiou]',"How are you!")
Out: ['o', 'a', 'e', 'o', 'u']
- 匹配字符集反集
元字符:[^字符集]
匹配规则:匹配除了字符集以外的任意一个字符
e.g.
In : re.findall('[^0-9]',"Use 007 port")
Out: ['U', 's', 'e', ' ', ' ', 'p', 'o', 'r', 't']
- 匹配字符重复
元字符: *
匹配规则:匹配前面的字符出现0次或多次
e.g.
In : re.findall('wo*',"wooooo~~w!")
Out: ['wooooo', 'w']
元字符:+
匹配规则: 匹配前面的字符出现1次或多次
e.g.
In : re.findall('[A-Z][a-z]+',"Hello World")
Out: ['Hello', 'World']
元字符:?
匹配规则: 匹配前面的字符出现0次或1次
e.g. 匹配整数
In [28]: re.findall('-?[0-9]+',"Jame,age:18, -26")
Out[28]: ['18', '-26']
元字符:{n}
匹配规则: 匹配前面的字符出现n次
e.g. 匹配手机号码
In : re.findall('1[0-9]{10}',"Jame:13886495728")
Out: ['13886495728']
元字符:{m,n}
匹配规则: 匹配前面的字符出现m-n次
e.g. 匹配qq号
In : re.findall('[1-9][0-9]{5,10}',"Baron:1259296994")
Out: ['1259296994']
- 匹配字符串开始位置
元字符: ^
匹配规则:匹配目标字符串的开头位置
e.g.
In : re.findall('^Jame',"Jame,hello")
Out: ['Jame']
- 匹配字符串的结束位置
元字符: $
匹配规则: 匹配目标字符串的结尾位置
e.g.
In : re.findall('Jame$',"Hi,Jame")
Out: ['Jame']
规则技巧:
^
和$
必然出现在正则表达式的开头和结尾处。如果两者同时出现,则中间的部分必须匹配整个目标字符串的全部内容。
- 匹配任意(非)数字字符
元字符: \d
\D
匹配规则:\d
匹配任意数字字符,\D
匹配任意非数字字符
e.g. 匹配端口
In : re.findall('\d{1,5}',"Mysql: 3306, http:80")
Out: ['3306', '80']
- 匹配任意(非)普通字符
元字符: \w
\W
匹配规则: \w
匹配普通字符,\W
匹配非普通字符
说明: 普通字符指数字,字母,下划线,汉字。
e.g.
In : re.findall('\w+',"server_port = 8888")
Out: ['server_port', '8888']
- 匹配任意(非)空字符
元字符: \s
\S
匹配规则:\s
匹配空字符,\S
匹配非空字符
说明:空字符指 空格\r \n \t \v \f
字符
e.g.
In : re.findall('\w+\s+\w+',"hello world")
Out: ['hello world']
- 匹配(非)单词的边界位置
元字符:\b
\B
匹配规则:\b
表示单词边界,\B
表示非单词边界
说明:单词边界指数字字母(汉字)下划线与其他字符的交界位置。
e.g.
In : re.findall(r'\bis\b',"This is a test.")
Out: ['is']
注意: 当元字符符号与Python字符串中转义字符冲突的情况则需要使用r将正则表达式字符串声明为原始字符串,如果不确定那些是Python字符串的转义字符,则可以在所有正则表达式前加r。
类别 | 元字符 |
---|---|
匹配字符 | . [...] [^...] \d \D \w \W \s \S |
匹配重复 | * + ? {n} {m,n} |
匹配位置 | ^ $ \b \B |
其他 | | () \ |
元字符使用示例:
import re
# 普通字符
# result = re.findall('你好',"abcdef你好cd")
# print(result)
# 或关系
# result = re.findall('ab|cd',"abcdefbcab")
# print(result)
# 匹配任意一个字符 除了 \n
# result = re.findall('张.丰',"张三丰,张四丰,张五丰")
# print(result)
# [] 匹配字符集中一个字符
# result = re.findall('[aeiou]', "How are you!")
# result = re.findall('[ !A-Z]', "How are you!")
# print(result)
# 字符集取反
# result = re.findall('[^a-z]', "How are you!")
# print(result)
# 匹配重复0次或多次
# result = re.findall('wo*', "wooooo~~w!")
# print(result)
# 匹配重复1次或多次
# result = re.findall('wo+', "wooooo~~w!")
# print(result)
# 匹配重复0次或1次
# result = re.findall('wo?', "wooooo~~w!")
# print(result)
# 重复指定次数
# result = re.findall('wo{3}', "wooooo~~w!")
# print(result)
# 匹配重复 m - n 次
# result = re.findall('wo{2,4}', "wooooo~~w!")
# print(result)
# 开头结尾位置
# result = re.findall('Jame$', "Hi,Jame")
# result = re.findall('^Jame', "Jame,hi")
# print(result)
# 匹配数字字符或者非数字
# result = re.findall('\d{1,5}',"Mysql: 3306, http:80")
# result = re.findall('\D+',"Mysql: 3306, http:80")
# print(result)
# \w 普通字符 和 \W非普通字符
# result = re.findall('\w+',"server_port = 你好")
# result = re.findall('\W+',"server_port = 8888")
# print(result)
# 空字符 和 非空字符
# result = re.findall('\w+\s+\w+',"Hello world")
# result = re.findall('\S+',"Hello world")
# print(result)
# 单词边界
# result = re.findall(r'\bis',"This is a test")
# print(result)
# 特殊符号匹配
# result = re.findall(r'-?\d+\.?\d*',"-5.4 3.28 45 76.3 -21")
# print(result)
# 贪婪
# result = re.findall("ab+","abbbbbbbbbc")
# print(result)
# 非贪婪 (懒惰模式) + --> +?
# result = re.findall("ab+?","abbbbbbbbbc")
# print(result)
# 子组
# result = re.search("(ab)+","abababab")
# result = re.search(r'(?P<xing>王|李)\w{1,3}', "王者荣耀")
# print(result.group()) # 获取匹配内容
随堂练习:
import re
# 匹配出其中大写字母开头的单词
result = re.findall('[A-Z][a-z]*', "How are you,Jame!,I am")
print(result)
# 匹配出年月日
result = re.findall('[0-9]+', "今天是:2021-4-30")
print(result)
# 匹配出数字
result = re.findall('-?[0-9]+', "-20°的天气,战士负重15Kg")
print(result)
# 匹配电话号码
result = re.findall(r'\b1[3578][0-9]{9}\b', "王总:13838384386,银行卡:693518345879556790")
print(result)
# 匹配qq号码 6-11
result = re.findall('[1-9][0-9]{5,10}', "王总:4268858")
print(result)
# 验证一个用户注册的用户名是否由6-12位数字字母下划线构成
name = input("User:")
result = re.findall("^[_0-9a-zA-Z]{6,12}$",name)
print(result)
2.3 匹配规则
2.3.1 特殊字符匹配
-
目的 : 如果匹配的目标字符串中包含正则表达式特殊字符,则在表达式中元字符就想表示其本身含义时就需要进行 \ 处理。
特殊字符: . * + ? ^ $ [] () {} | \
-
操作方法:在正则表达式元字符前加 \ 则元字符就是去其特殊含义,就表示字符本身
e.g. 匹配特殊字符 . 时使用 \. 表示本身含义
In : re.findall('-?\d+\.?\d*',"123,-123,1.23,-1.23")
Out: ['123', '-123', '1.23', '-1.23']
2.3.2 贪婪模式和非贪婪模式
- 定义
贪婪模式: 默认情况下,匹配重复的元字符总是尽可能多的向后匹配内容。比如: * + ? {m,n}
非贪婪模式(懒惰模式): 让匹配重复的元字符尽可能少的向后匹配内容。
- 贪婪模式转换为非贪婪模式
在对应的匹配重复的元字符后加 ‘?’ 号即可
* -> *?
+ -> +?
? -> ??
{
m,n} -> {
m,n}?
e.g.
In : re.findall(r'\(.+?\)',"(abcd)efgh(higk)")
Out: ['(abcd)', '(higk)']
2.3.3 正则表达式分组
- 定义
在正则表达式中,以()建立正则表达式的内部分组,子组是正则表达式的一部分,可以作为内部整体操作对象。
- 作用 : 可以被作为整体操作,改变元字符的操作对象
e.g. 改变 +号 重复的对象
In : re.search(r'(ab)+',"ababababab").group()
Out: 'ababababab'
e.g. 改变 |号 操作对象
In : re.search(r'(王|李)\w{1,3}',"王者荣耀").group()
Out: '王者荣耀'
- 捕获组
捕获组本质也是一个子组,只不过拥有一个名称用以表达该子组的意义,这种有名称的子组即为捕获组。
格式:
(?P<name>pattern)
e.g. 给子组命名为 "pig"
In : re.search(r'(?P<pig>ab)+',"ababababab").group('pig')
Out: 'ab'
-
注意事项
-
一个正则表达式中可以包含多个子组
-
子组可以嵌套但是不宜结构过于复杂
-
子组序列号一般从外到内,从左到右计数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VzkqHQRK-1630919085077)(./img/re.png)]
2.3.4 正则表达式匹配原则
- 正确性,能够正确的匹配出目标字符串.
- 排他性,除了目标字符串之外尽可能少的匹配其他内容.
- 全面性,尽可能考虑到目标字符串的所有情况,不遗漏.
随堂练习:
import re
# 匹配特殊符号
result = re.findall('\$\d+', "日薪:$150")
print(result)
# 匹配如下书名
result = re.findall('《.+?》', "《加油! @奥特曼》,《重生——美少女》,《biobio~ 奥利给》")
print(result)
# 只要李蛋分数
result = re.findall('(李蛋):(\d+)', "李逵:68,李蛋:75,李明:86")
print(result)
# 匹配一下IP地址 192.168.4.6 (\d{1,3}\.){3}\d{1,3}
result = re.search('(\d{1,3}\.?){4}', "IP:192.168.4.6")
print(result.group())
2.4 Python re模块使用
2.4.1 基础函数使用
re.findall(pattern,string)
功能: 根据正则表达式匹配目标字符串内容
参数: pattern 正则表达式
string 目标字符串
返回值: 匹配到的内容列表,如果正则表达式有子组则只能获取到子组对应的内容
re.split(pattern,string,max)
功能: 使用正则表达式匹配内容,切割目标字符串
参数: pattern 正则表达式
string 目标字符串
max 最多切割几部分
返回值: 切割后的内容列表
re.sub(pattern,replace,string,count)
功能: 使用一个字符串替换正则表达式匹配到的内容
参数: pattern 正则表达式
replace 替换的字符串
string 目标字符串
count 最多替换几处,默认替换全部
返回值: 替换后的字符串
正则函数使用示例:
import re
string = "Alex:1996,Sunny:1998"
# 使用## 替换正则表达式匹配到的内容
result = re.sub("\W+","##",string,2)
print(result)
# 使用匹配内容分割字符串
# result = re.split("\W+",string)
# print(result)
# 如果正则表达式有子组,那么只返回子组对应内容
# result = re.findall("(\w+):(\d+)",string)
# print(result)
2.4.2 生成match对象
re.finditer(pattern,string)
功能: 根据正则表达式匹配目标字符串内容
参数: pattern 正则表达式
string 目标字符串
返回值: 匹配结果的迭代器
re.match(pattern,string)
功能:匹配某个目标字符串开始位置
参数ÿ