• 投稿

period() 函数每天都会被调用

4.1万
0
2023-08-13 20:28:35
未经作者授权，禁止转载
4
投币
收藏
1
聚宽
Python
Ada-Xue 发消息
主要发布：数学思维与文化、少儿编程、发明创造、《新概念英语》背诵相关视频
《聚宽 Python 量化编程 - 第一季》
（250/923）
3619.3万播放
简介
开启一个新的聚宽 Python 量化编程系列
00:54
帮助下面有很多个不同板块
00:15
打开 新手指引 板块
00:21
关注聚宽微信公众号
00:15
零基础量化交易入门教程
00:12
从零开始教编程
00:26
量化与编程相结合 效果更好
00:22
简易精炼，快速入门
00:15
如果你想要更深入的了解与学习
00:15
量化课堂
00:14
聚宽社区
00:12
聚宽数据，详细介绍聚宽平台提供的多种数据服务
00:07
本地数据JQData，提供本地数据接口
00:09
如果你想实盘交易
00:14
接入实盘
00:11
股票实盘说明
00:15
如果你想了解聚宽投资
00:08
如果你还有疑问，可以看常见问题
00:09
聚宽新手指南 - 提供了多种学习路线和方法
00:11
零基础量化交易入门教程 - 我的的课程资源是这个
00:15
零基础量化交易入门教程 - 打开教程
00:26
这是一个面向零编程基础的量化交易新手入门教程
00:24
该教程的三大特点，不再赘述
00:09
读前说明
00:11
文后会有自测与自学，包括一些额外的延伸自学内容以及稍有难度的自测题目
00:18
最最最基础的股票知识不会讲
00:21
内容是前后连贯一体的
00:22
为了简易精炼难免不全面完备严谨
00:31
为了保证精炼可能不完备和严谨
00:16
目前，教程只规划做新手入门内容
00:20
目前，教程只规划做新手入门内容 很棒
00:22
希望能多多分享与推荐给更多的量化爱好者
00:14
教程 目录 介绍
00:18
点击蓝色标题可直接跳转阅读
00:15
初识量化交易
00:11
为什么需要量化交易？
00:10
何为量化交易？
00:08
量化交易的价值何在？
00:06
做量化交易需要准备什么？
00:07
聚宽是什么？
00:09
量化策略的基本框架
00:09
策略编写的基本框架及其实现
00:08
回测的含义及其实现
00:12
初步学习解决代码错误
00:09
周期循环的开始时间
00:07
Python 基本语法与变量
00:09
python是什么
00:08
python的基础语法
00:08
变量与赋值
00:06
Python 保留字符
00:06
打印 print
00:10
全局变量
00:20
基本数据类型-数字与字符串
00:18
算术运算
00:10
查看数据类型 type
00:06
数据类型-列表与字典
00:20
这一章介绍 Python 编程的基础知识
00:17
下单、函数、API
00:13
函数与API
00:07
函数使用方法
00:06
如何看API文档
00:07
可能没有图书和资料。官方文档就是最好的学习资料
00:15
自定义函数方法
00:14
常用的下单函数
00:12
获取context数据、条件判断
00:09
前期算法代码中多次遇到这个函数
00:19
沟通不同代码模块、函数的核心变量
00:12
context的含义
00:06
context的结构
00:06
context的读取方法
00:06
条件判断语句
00:17
就是之前说的 分支结构
00:07
止损的含义及其实现方法
00:06
止损是非常重要的理念和方法
00:11
循环、多股票策略
00:10
学习用list存储多个股票
00:12
学习使用for循环
00:06
学习写一个简单的多股票策略
00:09
不是一次把 Python 说的非常全面
00:19
不使用则不介绍。需要使用时详细介绍
00:10
分散知识点，避免一次介绍太多内容
00:18
获取典型常用数据
00:09
聚宽数据
00:07
获取指数成分股
00:05
获取指数对应的成分股信息
00:26
获取股票行情数据
00:05
只有获取了历史数据才能进行数据回测
00:13
获取股票财务数据
00:13
不同时期，股票的名称不同
00:29
某些时期可能是ST股票
00:22
除权除息后股价会发生变化
00:19
综合之前所学写一个策略
00:15
灵感细化-基础
00:14
灵感细化-案例介绍
00:28
逐步实现策略
00:07
调整与改进策略
00:08
策略评价与建立模拟
00:10
评价策略回测的指标
00:08
建立模拟交易
00:11
历史数据回测与模拟交易不同
00:25
模拟交易是实战之前最后一个关键性步骤
00:09
未来函数
00:09
未来函数举例
00:29
未来数据案例-全天最低价买入，最高价卖出
00:52
运行过慢
00:11
什么是 运行过慢 问题？
00:24
过拟合
00:06
什么是过拟合现象？
00:27
策略失效
00:07
什么是策略失效问题
00:14
投资研究功能
00:09
投资研究功能简介
00:07
新建notebook
00:09
单元格及其类型
00:09
命令模式与编辑模式
00:07
应用举例
00:10
成长指路
00:11
自学意识
00:07
之后去学什么
00:06
灵感来源
00:07
关于职业化
00:11
初识量化交易 - 打开看看
00:18
初识量化交易 - 摘要内容
00:35
量化交易比传统交易强多少？
00:12
它能让你的交易效率提高百倍
00:18
也就是是说，传统交易方法是这样的
00:16
我们认为作者的观点是错误的
00:26
金融市场充满不确定性，不是固定的庄稼等着人去收割
00:47
巴菲特就是基本面的交易的成功案例
00:44
在金融最为发达的美国，量化交易已大行其道，占据了70%以上的股市成交量
00:12
可以说量化交易是未来的趋势
00:22
量化交易是做什么？- 抛出问题
00:08
量化交易是指借助现代统计学和数学的方法，利用计算机技术来进行交易的证券投资方式
00:15
从一个灵感开始
00:07
灵感就是指那些你想验证的可能会盈利的方法
00:14
比如银行股可能是良好的投资品种、一旦跨过20日均线后股价会继续涨、流传许久的羊驼交易法等等
00:20
这里我们以一个简单的情况为例进行讲解
00:21
现在，你想知道这样操作究竟会不会赚钱？
00:15
把灵感细化成明确的可执行的交易策略
00:13
一般灵感都很模糊，需要将其细化成明确的可执行的策略
00:19
明确交易规则，方便变成代码
00:25
继续以之前那个关于平均价的灵感为例
00:14
显然它是不够明确的
00:18
我们把它细化
00:26
还有一点不明确的地方，买卖哪个股票呢？
00:29
所以我们进一步细化
00:23
现在我们基本已经把之前的灵感细化成明确的可执行的交易策略
00:20
把策略转成程序 - 才能回测历史数据和交易
00:07
就是把明确后的策略通过编程转成程序
00:18
简言之，就是把刚刚的策略翻译成计算机可识别的代码语言
00:13
写成类似这样的代码（下面的代码并不完全符合，只是展示下大概的样子）
00:10
def initialize(context)
00:09
g.security = ['002043.XSHE','002582.XSHE']
00:14
def handle_data(context, data)
00:09
def handle_data(context, data) 函数参数分析
00:10
for i in g.security
00:08
for i in g.security 遍历股票
00:10
last_price = data[i].close
00:16
average_price = data[i].mavg(20, 'close')
00:25
cash = context.portfolio.cash
00:10
if last_price 大于 average_price
00:14
order_value(i, cash)
00:16
elif last_price 小于 average_price
00:13
order_target(i, 0)
00:10
这样一来，就把刚才细化好策略转成了代码程序，计算机就能运行了
00:11
编码过程的意义是什么？
00:12
检验策略效果 - 新的小节
00:07
现在计算机理解了你的策略
00:14
基本的检验策略方法有回测和模拟交易两种方法
00:12
回测是让计算机能根据一段时间的历史数据模拟执行该策略，根据结果评价并改进策略
00:12
设定初始的虚拟资产比如500000元、一个时期比如20060101到20160101
00:17
把这一时期的各种数据如估计股价行情等发给计算机
00:24
计算机会利用这些数据模仿真实的市场，执行你刚才告诉它的策略程序
00:13
一般包括盈亏情况，下单情况，持仓变化，以及一些统计指标等
00:14
如果结果不好，则需要分析原因并改进
00:08
如果结果不错，则可以考虑用模拟交易进一步验证
00:07
模拟交易是让计算机能根据实际行情模拟执行该策略一段时间，根据结果评价并改进策略
00:16
模拟交易与回测不同的地方在哪里
00:19
设定初始的虚拟资产比如500000元，选择开始执行模拟交易的时间点，比如明天
00:23
你会得到一份实时更新的报告
00:14
可见，回测是用历史数据模拟执行策略，模拟交易是用未来的实际行情模拟执行策略
00:12
如果策略在回测与模拟交易的表现都非常好
00:17
进行实盘交易并不断维护修正
00:08
实盘交易就是让计算机能自动根据实际行情，用真金白银自动执行策略
00:12
这时不再是用虚拟资产模拟交易，亏损和盈利都是真钱
00:24
量化交易的价值何在？
00:11
可以利用大量历史数据检验策略，效率提升百倍
00:25
可以利用大量历史数据检验策略，效率提升百倍 - 很好
00:07
比如一个关于某技术指标的策略，人工的进行了10个交易日的验证
00:35
量化交易还可以利用数学与统计学自动给出客观的结果
00:28
R 语言也有类似的扩展包
00:16
全市场实时捕捉交易机会
00:08
量化交易可以利用计算机全市场实时盯盘
00:30
买到不一定赚到。不确定性永远存在
00:31
更多的盈利机会
00:08
量化交易可以利用计算机对海量数据分析得到常人难以发现的盈利机会
00:16
其特点是盈亏的额度相等，但盈利的概率是55%
00:28
盈利的概率是55%已经是很不错的系统了
00:20
做量化交易需要什么？
00:06
要有各种数据
00:12
这要考虑到各种数据的收集、存储、清洗、更新，以及数据取用时的便捷、速度、稳定
00:12
还要有一套量化交易的系统，要有能编写策略、执行策略、评测策略的系统
00:14
系统对各种策略编写的支持、系统进行回测与模拟的高仿真、系统执行策略的高速、系统评测策略的科学可靠全方面
00:16
这要考虑到系统对各种策略编写的支持、系统进行回测与模拟的高仿真、系统执行策略的高速、系统评测策略的科学可靠全方面
00:12
聚宽是什么？
00:08
聚宽是一家量化投研平台，为投资者提供做量化交易的工具与服务
00:13
在聚宽量化投研平台，“大型收割机”已经为你准备好了
00:11
应该说是大型收割机的组件已经准备好了
00:27
聚宽让做量化交易的成本极大降低
00:07
提供多种优质的便于取用的数据
00:07
提供投资研究功能，便于自由地统计、研究、学习等
00:13
提供多种的策略评价指标与评价维度
00:11
支持多种策略的编写、回测、模拟、实盘
00:07
聚宽让量化交易的成长之路更为平坦
00:09
在社区可以分享交流量化交易的心得与疑惑
00:11
在量化课堂可学习量化交易相关的各种知识
00:07
在策略擂台可以策略pk展现风采证明自己
00:09
在大赛专区可以获取社会量化比赛资讯
00:08
在策略商城可以上架策略供他人付费订阅
00:07
在基金经理孵化训练营则助力快速成长为一名职业基金经理
00:09
第一章简单总结
00:42
量化策略的基本框架 - 详解
00:24
量化策略的基本框架 - 打开相关页面
00:20
通过前文对量化交易有了一个基本认识之后
00:16
由于本教程是基于聚宽量化投研平台（www.joinquant.com）
00:16
从一个非常简单的交易策略开始
00:08
先看一个非常简单的交易策略
00:10
为了让这个策略能让计算机执行，首先，要使策略符合“初始化+周期循环”框架
00:13
初始化：选定要交易的股票为平安银行
00:15
什么是“初始化+周期循环”框架？
00:08
为了将投资灵感高效地转化成计算机可执行的量化策略，必须基于一种模式来写，框架就是指这种模式
00:22
初始化即指策略最开始运行前要做的事
00:11
周期循环即指策略开始后，随着时间一周期一周期地流逝时，每个周期要做的事
00:20
其实人本身日常做交易就是符合“初始化+周期循环”框架的
00:22
如何把策略变成计算机可执行的程序
00:07
通过编程将策略写成计算机可识别的代码
00:09
另外可以用聚宽的向导式策略生成器
00:18
那么如何将策略写成代码？
00:08
这并非三言两语就能说清，尤其是对于没有编程基础的人
00:19
def initialize(context) 写法一
00:10
这里是用来写初始化代码的地方,例子中就是选定要交易的股票为平安银行
00:11
def handle_data(context,data) 代码一的写法
00:09
def handle_data(context,data) 写法一
00:08
这里是用来写周期循环代码的地方,例子中就是买100股的平安银行
00:11
def initialize(context) - 写法二
00:07
run_daily(period,time='every_bar') 每日运行
00:11
这里是用来写初始化代码的地方,例子中就是 选定要交易的股票为 平安银行
00:12
def period(context)
00:11
这里是用来写 周期 循环代码的地方,例子中就是买 100股的 平安银行
00:10
period() 函数每天都会被调用
00:12
两种写法作对比。优选第二种写法
00:51
代码应该往哪里写？
00:19
来到聚宽网站后，通过导航栏-我的策略-我的策略进入策略列表，点击新建策略
00:23
进入策略编辑页，左侧就是策略代码编辑区域
00:20
初始会默认给你提供代码模板，全删除后写入我们的代码就好了
00:33
两种写法用哪个好？
00:16
写法一是从前的老写法，将逐步弃用，写法二是聚宽系统改进后的新写法，推荐使用写法二
00:13
前期案例分析用的也是第二种写法
00:23
def、context等都是什么意思？
00:11
其实是在调用聚宽提供好的函数
00:18
def
00:12
context 的含义
00:21
框架写成代码了，那例子的完整的代码该怎么写呢？
00:21
剩下的两行代码这么写。完全理解需要学习后续的内容，此处不要求理解
00:15
选定要交易的股票为平安银行
00:07
g.security = '000001.XSHE'
00:13
买100股的平安银行（市价单写法）
00:10
order(g.security, 100)
00:07
order(g.security, 100) 下单命令
00:09
def initialize(context)
00:08
run_daily(period,time='every_bar')
00:16
g.security = '000001.XSHE' 设置股票代码
00:12
def period(context) 定义每日执行函数
00:11
order(g.security, 100) 市价单买入
00:18
那么现在这些代码就可以运行了吗？
00:10
是的。以写法二为例，如图把代码写到策略编辑区
00:13
设置好初始资金 与 起止时间
00:16
频率设置成天。点击编译运行，运行结束后就可以看到结果了
00:10
可以看到，若你20160601有初始资金100000元
00:23
图中红线是基准收益（默认是沪深300指数，代表整个市场增长水平）
00:10
接下来，点击运行回测
00:12
策略出错不能运行？
00:10
策略不能运行时，日志中会报错并给出一定的提示信息，像这样
00:12
错误信息会显示在界面上
00:22
首先注意，右上角的箭头按钮能展开运行日志
00:15
语法错误：不合法的语法
00:14
最后一行之前的是错误的位置信息，一般只看后面就行
00:11
最后一行之前的是 错误的位置信息， 一般只看 后面就行
00:13
def initialize(context) 错误代码在这里
00:12
意思是文件user_code.py（就是你的策略代码）的第一行
00:18
为了顺利运行策略，需要耐心解决错误，但错误的原因极度的复杂多样
00:13
符号要用英文输入法
00:10
拼写不要错。下图，security拼写错了
00:16
缩进要对齐。下图，缩进没对齐
00:07
缩进的时候可以按键盘tab键或四个空格
00:21
编程界往往把错误叫bug，而不断调试去除错误的过程叫debug
00:14
而且debug通常就是要耗费不低于写bug写代码的时间的，所以会debug是很重要的能力
00:13
回测、编译运行、运行回测都是什么意思？
00:18
用一段时间内的历史的真实行情数据，来验证一个确定的交易策略在这段时间表现如何
00:13
运行回测就是是字面意思，让计算机运行这次回测
00:13
比如收益率、年化收益率、最大回撤、夏普比率等指标，而且一般也会包括下单记录、持仓记录等
00:14
编译运行其实也是让计算机运行这次回测，不过相比于点击运行回测，编译运行的结果比运行回测要简单
00:18
只有收益率等指标，因此也速度更快
00:19
运行回测 和 编译运行之间的区别
00:29
周期循环具体是什么时候开始的呢？
00:08
如果策略频率为天，是每个交易日开始生效，从9 30直到15 00（从股市开市到收市）
00:23
如果策略频率为分钟，是每个分钟开始时执行
00:25
虽然频率只有为分钟和每天可选，但通过不同的代码可以实现按周按月周期循环
00:15
而且分钟级别里下单时间也是可以自己选的，不过代码的写法则与写法一和写法二那样略有不同，后面会讲到
00:18
量化交易策略基本框架 总结
00:43
进入下一篇继续学习
00:24
量化交易策略基本框架
00:06
前文讲解了量化交易中策略运行的基本框架以及实现方法
00:23
一般常见的python教程都是针对程序员的，所以很多内容在做量化写策略时都往往用不到
00:11
而本教程则是以量化的情景从零讲解python编程，所以将更适合想学做量化策略的人
00:16
如果想更完备而全面的学习python语言的人，不妨看下这个文章
00:13
我们将以前文策略代码为例进行讲解
00:13
python是与计算机交流的一种语言
00:18
Python2与Python3
00:08
Python语言本身也是如同自然语言般在不断变化的
00:19
目前主要使用 Python 3 来写量化代码
00:23
python的基础语法
00:09
大小写敏感
00:09
比较容易理解，就是字母的大写与小写是区分的
00:14
要用英文符号
00:09
之前讲过，冒号、逗号、分号、括号、引号等各种符号必须用英文的，中文的会不识别而报错
00:12
注释
00:08
为了让代码的便于交流理解，通常都会在代码中写入注释用以说明代码
00:11
注释是给人看的，所以计算机会忽略（顺便提下，空行也会被忽略）
00:12
强烈建议养成写注释的好习惯
00:18
(#)会把所在行的其后的所有内容设定为注释
00:09
单行注释。示例代码
00:15
三个单引号(''')或三个双引号()会把之间的内容设定为注释
00:11
多行注释 - 示例代码
00:19
行与缩进
00:06
之前讲过，代码缩进的时候要对齐，缩进方法是四个空格或一个tab键(推荐用tab)
00:11
不要混着用。比如例子中周期循环部分除第一句都是要缩进的
00:11
缩进的含义是这样的，有些语句是要包含其他连续若干条语句才成立的
00:18
缩进部分是完整的代码块
00:16
一行写多条语句
00:08
一般习惯是一行只写一条语句，如果要一行写多条语句要用分号隔开
00:10
不常用但要认识
00:21
多行代码写在一行中。用分号分开
00:17
一条语句写在多行
00:08
有时一条语句可能就会很长，为了便于阅读会用斜杠
00:13
一行代码写在多行
00:19
变量与赋值
00:08
g.security = '000001.XSHE' 典型的赋值语句
00:12
把'000001.XSHE'这个字符串赋值给名为g.security的变量(security是英文证券的意思)
00:15
变量通俗的理解是，计算机中存放数据的有名字的盒子
00:11
另外变量名字是在赋值语句中定义的
00:08
赋值，即赋予变量数据
00:17
写法是等号，含义是把等号右边的数据（或变量里的数据）放入左边的变量中去
00:11
用法： 变量名 = 数据或变量
00:10
Python 保留字符
00:19
打印 print()
00:17
print是非常常用而重要的语句
00:17
能把变量里的内容在日志中打印输出出来
00:31
print() 示例代码
00:17
把代码放到周期循环里后，点编译运行执行代码
00:25
后面的例子都可以这个方法来执行
00:15
后面的例子 都可以这个方法 来执行
00:26
print() 语句的第二个示例代码
00:28
print也可以直接打印数据
00:14
经常用于记录策略的运行情况
00:17
对输出的数据有一定的解释说明
00:46
在日志中输出语句、变量值非常有价值
00:23
小市值原始模型中可以用 print() 输出市值究竟是多少
00:36
全局变量
00:09
你可能会发现初始化里的变量与周期循环里的变量是不通的
00:11
你运行如下的代码会报错
00:22
报错信息如下，含义是a没有被定义
00:07
global name 'a' is not defined
00:20
为了让变量能在全局被使用，需要在变量前加'g.'，使之成为全局变量
00:11
把刚刚的代码中的a改为全局变量就能正确运行了
00:11
def initialize(context) 定义全局变量
00:19
def period(context) 输出全局变量
00:13
一般 Python 编程中定义全局变量需要使用 global
00:24
聚宽中使用 g.变量名 标记全局变量
00:15
基本数据类型-数字与字符串
00:20
不同的数据往往需要不同的操作与存储要求
00:18
在赋值时python会自动为数据分类
00:18
数字可以数学运算，但文本就不可以
00:28
文本有加法、乘法运算
00:23
字母可以转换大小写，数字不行
00:12
数字（Number）
00:08
数字就是数字，可以做诸如加减乘除的计算操作
00:11
具体可分为多种类型，比如股价一般就是浮点数型
00:15
因为在赋值变量的时候，python会自动调整变量类型
00:15
数字具体分为int（整数）
00:13
float（浮点数，即 包含小数位）
00:15
bool（布尔值，即True和False，True是1，False是0）等
00:12
三种数字类型数据举例
00:13
字符串（String）
00:14
字符串 （ String ）
00:20
股票代码、股票名称一般都是字符串
00:11
股票 代码、股票 名称一般都是 字符串
00:37
Python 可使用引号( ' )
00:14
Python 可使用 引号( ' )
00:08
不同类型的引号配对使用
00:15
不妨用刚讲的print打印下看看
00:09
其中三引号可以由多行组成来编写多行文本
00:11
算术运算
00:09
数字变量之间是可以进行算术运算
00:22
算术运算的示例代码
00:31
如果两个整数类型进行计算，结果默认还是整数
00:09
整数运算示例代码
00:29
一般 Python 中的除法运算是浮点数运算
00:26
查看数据类型 type
00:09
type语句可以，告诉我们变量里存放的是什么类型的数据
00:12
为了看到结果需要用print把结果在日志中打印
00:18
数据类型-列表与字典
00:30
为了更方便的取用数据，在最基本的数据类型-数字与字符串基础上，还有其他的数据类型
00:13
他们往往具有更复杂的结构更便捷的功能
00:11
接下来要介绍的列表（List）、字典（Dictionary）
00:17
列表（list）
00:08
列表数据类型能方便我们操作一组数据。比如一组股价、一组股票名等
00:11
建立一个list： 变量名=[数据或变量名，数据或变量名，......]
00:15
a=[1,1,2,3,5,8,13,21]
00:13
b=['000001.XSHE','002043.XSHE','002582.XSHE','600000.XSHG']
00:24
c=[1,2,'good',[1,2,'luck'],a,b]
00:23
值得注意的是例子中的c，c是一个list
00:19
list中可混合的存放多种数据类型，list中放一个list也行
00:15
选取list中的某个元素的用法如下
00:10
方法： list类型的变量[位置（或称下标或索引）]
00:11
索引从0开始
00:08
可以用负数代表倒数第几
00:20
为了看到结果我们用print打印
00:08
c=[1,2,3,4]
00:14
print(c[0])
00:09
print(c[1])
00:09
print(c[2])
00:08
print(c[-1])
00:10
print (c[-1] )
00:11
方法： list类型的变量[起点索引 终点索引]
00:11
起点索引省略则默认为0
00:09
终点索引省略则默认为最后的索引
00:07
注意此时的结果仍是一个list
00:10
c=[1,2,3,4] 取一段数据
00:11
为了看到结果我们用print打印 - 一段数据
00:08
print(c[2 3])
00:21
print(c[ -1])
00:16
左闭右开区间
00:18
print(c[3 ])
00:16
print(c[冒号])
00:10
字典（dictionary）
00:08
字典数据类型同样能方便我们操作一组数据
00:13
与list不同的是我们可以为这组数据自定义地建立索引
00:10
list 是系统自定义索引。字典数据是用户定义索引
00:16
建立方法：变量名={索引名 数据,索引名 数据,....}
00:22
字典数据外部是一个大括号
00:15
索引与数据值之间有冒号
00:15
字典数据中每组数据用逗号分开
00:13
dict中的索引也叫键(key)，数据也叫值(value)
00:11
a={'平安银行'-'000001.XSHE','浦发银行' - '600000.XSHG'}
00:19
股票名称 和 股票代码对应
00:11
b={'开盘价'-10.0,'收盘价'-11.0,'涨跌幅'-0.10}
00:16
价格字符串和实际价格数据
00:25
选取dict中的某个key的值方法如下
00:08
选取方法 dict类型的变量[key]
00:10
a={'平安银行'--'000001.XSHE','浦发银行'--'600000.XSHG'}
00:13
为了看到结果我们用print打印 - 字典数据
00:09
print(a['平安银行']) - 字符串索引
00:11
执行后结果如下 - 股票代码
00:16
字典是键和数据值的配对结果。成对出现
00:21
选取dict中的所有key与所有value
00:15
选取dict中的所有key-dict类型变量.keys()
00:14
选取dict中的所有value - dict类型变量.values()
00:11
注意返回的结果是list类型的
00:08
a={'平安银行' - '000001.XSHE','浦发银行' - '600000.XSHG'}
00:18
b=a.keys() 获取键值
00:13
c=a.values() 获取数据值
00:06
print('a.keys()=%s' % (a.keys()))
00:10
print('b=%s' % (b))
00:10
print('c=%s' % (c))
00:08
list中的中文难以正常显示，需如下这样单独打印
00:10
print('b[0]=%s' % (b[0]))
00:06
python基本语法与变量 总结上
00:14
打印 print 感兴趣的数据输出
00:19
全局变量 g. 开头的变量
00:09
基本数据类型-数字与字符串 种类多样
00:16
算术运算 - 四则运算 等等
00:10
查看数据类型 type - 数值数据、字符串数据都有
00:12
数据类型-列表与字典 - 都是可变数据类型
00:13
Python 编程基础完成之后，进入新的一节
00:17
下单、函数、API
00:22
函数与API
00:12
函数使用方法
00:15
如何看API文档
00:16
自定义函数方法
00:22
常用的下单函数
00:23
继续以前文策略代码为例进行讲解
00:26
order(g.security, 100) 购买100股
00:18
函数与API - 介绍两者的联系与区别
00:12
函数是封装好的，可重复使用的 ，用来实现专一功能的代码段
00:11
函数能使代码易于维护与交流，提高编写策略的效率
00:10
函数 能使代码易于 维护与交流，提高 编写 策略的效率
00:15
之后用这个函数名，就知道这个名字指代那被包起来的一系列代码指令了
00:12
之后用这个 函数名，就知道这个名字 指代那被包起来 的一系列代码 指令了
00:14
你也可以自己创建函数自己用，这被叫做自定义函数
00:11
你也可以自己 创建函数 自己用，这被叫做 自定义函数
00:14
该函数内包了一个聚宽系统自带的函数order()
00:08
def period(context) - 自定义函数
00:22
def period(context)
00:13
API的含义与函数有所不同，解释起来略复杂
00:12
不过实际使用中跟函数几乎没有差别，可以理解成聚宽平台基于python封装而成的函数
00:15
在聚宽的API文档中你可以看到除order()外其他API
00:11
使用一个函数
00:26
在使用函数的时候，通常需要提供一些参数(也有可能不需要)
00:16
函数根据提供的参数，执行一系列的函数作者设计好的操作
00:17
往往也会根据提供的参数返回结果（也可能返回为空，即不返回）
00:26
用法：函数名(参数,参数,......)
00:10
提供了两个参数g.security和100，执行了买入g.security中数据对应的股票100股的操作
00:17
order(g.security, 100) - 调用函数买入股票
00:16
提供了一个参数 你好，执行了打印 你好 的操作
00:17
print( 你好 ) 输出字符串，你好
00:09
提供了一个参数 1 给type()函数，type函数执行了识别 1 数据类型的操作，并返回了 1 数据类型为结果
00:18
type返回的结果被当做参数提供给了print(),print执行了打印type返回的结果的操作
00:14
type与print的嵌套使用，实现了打印 1 数据类型的操作
00:11
print(type( 1 ))
00:19
函数的功能多种多样，需要参数、返回的结果亦不尽相同
00:17
具体怎么用需要看函数作者提供的说明文档，或者看函数内的设计代码自己推断
00:14
函数内的代码不见得看得到，看到不一定看得懂，想看懂也可能很辛苦
00:21
所以一般函数的用法要看函数作者提供的说明文档
00:13
聚宽设计的函数(如前文所说准确叫法是API)的用法都写在API文档里
00:12
位置在聚宽网站导航栏-帮助-API文档
00:12
API 文档的位置
00:11
接下来以order为例讲下文档怎么看
00:11
在API文档中找到 order - 按股数下单的说明
00:14
在API文档中找到 order - 按股数下单的说明
00:22
打开帮助界面，查看API文档
00:38
order() 函数帮助界面信息
00:18
order可接受的参数有5个,分别是security，amount，style，side，pindex
00:16
这五个参数的名字与含义是函数作者设计的
00:11
意思是你使用order提供参数的时候，被提供参数将按提供的顺序依次对应这5个参数
00:20
比如下面的写法就是错误的
00:10
函数会按顺序把100对应为security，即股票代码，把 000001.XSHE 对应为amount，即要交易的数量。所以就会错
00:20
order(100, 000001.XSHE ) 错误的调用方法
00:16
不按顺序提供参数的正确写法如下
00:17
用等号表示对应关系，参数名写前，要当做参数的变量或数据写在后
00:13
如下是把100当做amount参数，把 000001.XSHE 当做security参数
00:19
order(amount=100,security= 000001.XSHE ) 正确写法
00:15
可以发现有些参数后面有等号，如style=None，含义style参数不提供的话，会被默认是None
00:24
其他的side='long', pindex=0也是一样的道理，如果不提供会被默认是等号后面的内容
00:16
所以前文order()只写了两个参数也不会错
00:15
注意，security和amount后面没有等号，即没有默认值，则必须提供参数不能省略
00:14
以下两句含义相同
00:07
order( 000001.XSHE ,100) - 含义相同
00:09
order('000001.XSHE',100,None,'long',0) 本质上相同
00:14
细说下order的各个参数
00:12
security 标的代码，数据类型要求是字符串
00:17
想知道 基金、期货、指数的代码都是什么，可以在这里看聚宽数据,
00:12
比如聚宽数据-向下滚动页面-点击指数数据，可以看到各指数的代码
00:15
特别的是股票代码目前没有页面，但只需在平时使用的股票代码后面加后缀就好了
00:15
深交所（深交所股票0开头） 股票代码 后缀为.XSHE
00:17
如000001.XSHE
00:12
上交所股票代码（上交所股票6开头）后缀为.XSHG
00:14
600000.XSHG
00:11
amount 交易数量, 正数表示买入, 负数表示卖出
00:11
正数表示买入, 负数表示卖出
00:19
style参数决定下的订单是市价单还是限价单
00:13
默认是None代表市价单
00:23
目前就用默认吧，限价单以后讲
00:09
市价单和限价单的区别
00:23
side参数决定是开空单还是多单
00:13
默认为多单，股票只能多单，股指期货等其他品类可以开空单
00:10
pindex参数是在多资金仓位时选择资金仓位的，股票一般用不到
00:15
order()可以做多个不同类型的品种
00:35
根据说明文档，order函数是有返回值的
00:12
如果创建订单成功, 则返回Order对象, 失败则返回None
00:10
Python 中各种数据类型本质上都是对象
00:24
有返回值不一定要用，比如前文的例子都没用到这个返回值
00:17
策略做的相当完备的时候才可能用到
00:25
一般用法是，根据返回值是否是None，判断是否下单成功
00:11
成功时，根据返回值可以查询订单或取消订单等
00:11
不过具体实现方法、以及Order对象是什么，还需要学习很多的知识
00:15
自定义函数
00:25
Python 定义函数使用 def 关键字，一般格式如下
00:09
def 函数名(参数列表) - 自定义函数头部
00:10
函数名即为该函数起的名字
00:11
函数体即包在函数中的一系列操作的代码
00:12
参数列表即使用函数需要提供的参数，比如一个根据圆半径求周长的函数如下
00:17
根据圆半径r求周长l
00:08
def yuan(r)
00:20
p=3.14
00:11
l=2 星 p 星 r
00:10
return l 返回圆周长
00:06
return的含义是结束函数的运行并返回一个值
00:15
如上例子中就是返回了算好的周长l
00:10
如果return后什么也不写就是返回None即空
00:13
实际情况还是有返回值。返回的结果是 None
00:12
如果不写return，函数体运行完后，自动return None
00:13
函数内部是相对独立的
00:07
数据想进来要通过参数传进来，想出去要通过返回值传出去
00:13
函数从获得参数到返回值的过程中所产生的数据与变量中没通过返回值传出去的
00:15
在函数运行结束后（即返回值后）都将被计算机释放不再存储
00:11
函数内部的变量是临时变量
00:15
如果想函数间通用某变量可以考虑用之前讲的全局变量
00:10
就是 g.变量名 形式的全局变量
00:15
可以用等号给参数附加默认值
00:14
而且可以用逗号分隔多个参数
00:12
根据圆半径r求周长l的k分之一
00:09
def yuan(r,k=1)
00:09
p=3.14 - 新程序
00:07
l=2 星 p 星 r 除以 k
00:08
返回周长的 K 分之一
00:12
在返回值的时候可以返回多个变量
00:12
根据圆半径r求周长l与面积s的k分之一
00:11
l=2星p星r除k 周长的K分之一
00:09
圆面积的 K 分之一
00:09
使用自定义函数的方法跟前文讲的使用函数的方法一致
00:12
需要说明的是定义函数的代码放的位置
00:10
函数也放在程序中，可以由其他函数调用
00:45
自定义函数非常常见
00:23
常用的下单函数
00:09
常用的下单函数有四个，使用方法和order()差不多
00:15
可能有人自己看API文档就能学会了
00:11
接下来我们分别介绍下基本用法
00:08
同样的不讲style，side，pindex这三个参数
00:19
order(security,amount)，刚刚细讲过
00:12
含义是买卖一定数量的（单位：股）股票
00:09
security是股票代码，amount是数量
00:09
security 是股票代码，amount 是数量
00:08
买入100股平安银行 - 下单
00:09
需要知道的是，国内股票买入最小单位是1手即100股
00:11
股票交易手数规则正在进行调整
00:31
order('000001.XSHE',100) 下单买入股票
00:08
卖出100股平安银行 - 下单
00:07
order('000001.XSHE',-100) 卖出平安银行股票
00:09
order_target(security,amount)
00:12
含义是通过买卖，将股票仓位调整至一定数量（单位：股）
00:11
security是股票代码，amount是数量 - 达到目标数量
00:10
调整平安银行的持股数量至1000股
00:10
即，如果目前平安银行的持股数量低于1000股就买入，高于就是卖出，不高不低就不动
00:12
order_target('000001.XSHE',1000) 目标是持仓达到 1000 股即可
00:13
order_value(security,value)
00:11
order_target(security,amount) 清空持仓
00:19
含义是买卖一定价值量（单位：元）股票
00:12
security是股票代码，value是价值量 - 按交易金额来下单
00:09
value为负数时就是代表卖出了
00:07
买入10000元的平安银行
00:07
如果当前股票市价是10元，则代表买入1000股
00:10
如果除不开系统会自动调整成相近的合理数量。卖出时也会
00:10
order_value('000001.XSHE',10000) - 买入10000元股票
00:10
卖出10000元的平安银行
00:08
如果当前股票市价是100元，则代表卖出100股
00:09
order_value('000001.XSHE',-10000)
00:10
order_target_value(security,value)
00:10
通过买卖，将股票仓位调整至一定价值量（单位：元）
00:11
security 是股票代码，value 是价值量
00:07
调整平安银行的持股价值量至10000元
00:08
如果目前平安银行的持股价值量（按股票市价算）低于10000元就买入，高于就是卖出，不高不低就不动
00:12
order_target_value('000001.XSHE',10000)
00:10
读者在尝试练习使用这些语句的时候，可以点击运行回测
00:14
通过查看回测结果页中的交易详情来看语句的执行效果，同时也可以看下日志
00:12
买入价值10000元的股票
00:13
需要按照 100 股的整数倍操作。不满足条件无法交易
00:18
股票拆分合并和分红，交易的税费，下单导致成交价向不利的方向波动
00:15
这些因素系统都是默认考虑并仿真处理的了
00:18
具体的详情以及下的订单系统是如何模拟真实情况撮合成交的，可以看下API文档订单处理
00:13
其实新手不用太关注 这些订单处理的细节，不核心，目前也不容易理解，可以等以后自己比较熟悉了再看
00:14
函数与API 复习
00:27
函数使用方法 - 复习
00:17
如何看API文档
00:12
自定义函数方法 - 复习
00:16
常用的下单函数 - 复习
00:45
读取context中的数据与条件判断
00:27
context的含义
00:38
context的结构
00:14
context的读取方法
00:20
条件判断语句
00:19
分支结构案例分析
00:31
分散Python编程知识，减轻压力
00:25
止损的含义及其实现方法
00:15
自测与自学
00:23
下单、函数、API - 自测自学
00:20
实践下本文中的例子
00:17
搜索了解下移动平均线（MA，均线）的计算方法
00:22
搜索了解下市价单、限价单的含义
00:09
市价单
00:18
限价单
00:25
自定义一个可计算包含若干数list中数的平均值的函数
00:15
即如果你定义的函数为pjs()
00:13
提示：len()可用来计算list的长度，用法如len([1,2,3,4])
00:10
通过前文的讲解，我们已经能理解最开始的那个简单的策略例子
00:14
def initialize(context)
00:11
run_daily(period,time='every_bar')
00:15
g.security = '000001.XSHE' - 赋值
00:19
def period(context)
00:15
order(g.security, 100)
00:29
两个函数都有 context 参数
00:21
context的结构
00:17
context 上下文的意思
00:33
context是一个回测系统建立的Context类型的对象
00:10
回测系统建立
00:15
其中存储了如当前策略运行的时间点、所持有的股票、数量、持仓成本等数据
00:14
Context类型的对象
00:11
对象可以理解为特殊类型的变量
00:24
对象的结构往往比我们之前见过的list与dict更复杂
00:19
被定义好的对象是有名字的，比如context是一个变量
00:13
它的变量类型是一个Context类型的对象
00:10
就像dict包括key与value，Context类型的对象也包括很多属性
00:13
而且可以嵌套另一个种类型的对象，结构见下图
00:14
图中只包括了主要与常用的内容，详细介绍可以看API文档：Context对象
00:14
context 对象是主体部分
00:11
账户信息 子对象
00:10
当前时间 子对象
00:09
前一个交易日 子对象
00:08
运行参数 子对象
00:11
股票池 子对象
00:08
仓位信息 对象
00:09
仓位信息 字典类型数据
00:09
字典键 是标的代码
00:16
字典值 包含 标的代码
00:10
最新行情价格
00:06
开仓均价
00:05
一只股票多次被买入，均价需要单独计算
00:18
建立仓位的时间
00:07
最后交易时间
00:06
最后一次买入卖出股票的时间
00:14
这支股票的总仓位
00:11
可卖出仓位
00:08
总的持仓数量
00:15
当日买入当日无法卖出，不是可卖出仓位
00:29
当前持仓的价值
00:08
可用资金是多少
00:16
当前证券价值和可用资金的总权益
00:09
累计收益率是多少
00:08
初始资金
00:07
初始设置的可用资金比如1000万元
00:15
当前持仓的总价值
00:10
开始日期
00:11
结束日期
00:19
程序运行的方式
00:10
程序运行的频率
00:08
关于对象的知识非常复杂繁多
00:12
目前我们只需学习如何取用context中的数据就好
00:10
context中的数据取用方法
00:09
获取对象类型变量内包含的数据方法是用英文句号隔开
00:17
而当包含的是另一个对象时，只需在应用英文句号隔开即可
00:14
打印可用资金
00:08
print(context.portfolio.available_cash)
00:15
通过英文句点，层层调用对象
00:15
打印运行频率
00:10
print(context.run_params.frequency)
00:11
print( context.run_params.frequency )
00:13
打印当前单位时间的开始时间
00:18
print(context.current_dt)
00:10
执行后日志内容如下
00:09
1000000.0 启动资金就这么多
00:18
day 使用日线数据作分析
00:07
2016-06-01 09-30-00 算法启动时间
00:09
通过点操作符访问对象
00:24
当要获取的对象内的数据是另一种有结构的变量类型时，比如dict或list
00:21
正常按照该变量类型进一步取用数据即可
00:10
例如context.portfolio.positions是一个dict
00:11
我们就可以应用之前讲过的dict 的用法来使用它
00:10
context.portfolio.positions的含义是仓位信息
00:12
所以为了让它有数据，需要在取之前买入并持有股票
00:10
def initialize(context)
00:13
run_daily(period,time='every_bar')
00:14
g.security = '000001.XSHE'
00:07
def period(context)
00:09
order(g.security, 100)
00:15
order(g.security, 100) 解释
00:31
打印所有键
00:13
print(context.portfolio.positions.keys())
00:10
打印所有值
00:09
print(context.portfolio.positions.values())
00:10
打印g.security的开仓均价
00:08
print(context.portfolio.positions[g.security].avg_cost)
00:26
执行后 日志内容 如下
00:11
['000001.XSHE'] 键 就是股票代码
00:12
UserPosition 一串数据是 字典的 值数据
00:13
常用的context数据写法如下，推荐自己动手试下
00:10
当前时间 context.current_dt
00:08
当前时间的“年-月-日”的字符串格式 context.current_dt.strftime('%Y-%m-%d')
00:06
strftime() 日期时间类型格式转换
00:36
前一个交易日 context.previous_date
00:09
当前可用资金 context.portfolio.available_cash
00:10
持仓价值 context.portfolio.positions_value
00:10
累计收益 context.portfolio.returns
00:08
当前持有股票 context.portfolio.positions.keys()
00:14
当前持有的某股票的开仓均价 context.portfolio.positions['xxxxxx.xxxx'].avg_cost
00:15
['xxxxxx.xxxx'].avg_cost 每只股票不同
00:14
当前持有的某股票的可卖持仓量
00:14
可卖持仓量 context.portfolio.positions['xxxxxx.xxxx'].closeable_amount
00:16
可以获得持仓股票的有价值信息
00:12
可以计算股票盈亏情况等等
00:16
知道可以卖出的仓位量
00:13
context 结构至关重要
00:12
条件判断
00:15
能够获取context的数据后，我们会考虑利用这些数据丰富策略的逻辑
00:16
但在此之前我们还要学习if条件判断语句
00:09
条件语句的一般样式
00:20
如果 条件1成立为 True 将执行代码块1
00:10
如果 条件1不成立为False，将判断条件2
00:12
如果 条件2成立为 True 将执行代码块2
00:09
如果 条件2还不成立为False，将执行代码块3
00:11
elif 可以有多个连续写
00:10
且elif和else都可以省略
00:10
条件判断语句中可以嵌套条件判断语句
00:13
if,elif,else 后面必须有冒号，否则出错
00:13
举几个分支结构的例子
00:07
打印a、b中最大值
00:09
if a 大于等于 b
00:15
print(a) 如果 a 大于等于 b
00:07
否则输出 print(b)
00:11
判断a的正负性
00:13
if a 大于 0 输出 正数
00:10
elif a 小于 0
00:08
elif a==0
00:21
如果当前是2018-05-04，则下单买入100股平安银行
00:12
date=context.current_dt.strftime('%Y-%m-%d')
00:18
if date=='2018-05-04'
00:09
order('000001.XSHE',100) 满足日期条件，买股票
00:10
判断a大小情况
00:11
if a 大于 0
00:11
if 内部又嵌套 if...else...结构
00:24
print('a小于等于0')
00:11
条件判断语句比较简单，但还需说明的是条件的写法中用到的运算符
00:14
写条件常用运算符
00:11
注意常见的条件运算符的写法
00:13
and 与，即and两边条件同为真，则真
00:08
or 或，即or两边条件任意一个为真，则真
00:08
not 非，即not右侧条件为真，则假，not右侧条件为假，则真
00:12
以判断a是否为0的几个写法为例
00:12
写法一
00:12
写法2
00:15
写法3
00:16
写法4
00:16
止损 - 详细介绍
00:09
狭义的止损是指当亏损达到一定幅度后下单卖出该股票的操作
00:11
目的是减少进一步的亏损
00:07
44、广义则指在狭义的思路上衍生的复杂的减少亏损的方法
00:20
更多的情况下指狭义的止损
00:09
综合运用前文的讲过的内容我们已经可以实现这个功能
00:15
当亏损达到一定幅度后下单卖出该股票的止损
00:14
不妨先自己思考下再继续学习
00:18
通过context的数据可以得到持有股票的成本和现价
00:13
通过 context 的数据可以得到持有股票的 成本和现价
00:33
可以算出该股票的盈亏情况
00:09
运用条件判断语句根据盈亏情况从而决定是否卖出股票，从而实现止损操作
00:12
def initialize(context)
00:12
run_daily(period,time='every_bar')
00:14
g.security = '000001.XSHE'
00:13
def period(context)
00:23
买入股票
00:10
order(g.security, 100)
00:13
每日都要买入100股
00:19
获得股票持仓成本
00:08
cost=context.portfolio.positions['000001.XSHE'].avg_cost
00:20
每日买入股票，所以均价不断变化
00:14
获得股票现价信息
00:08
price=context.portfolio.positions['000001.XSHE'].price
00:21
获取股票价格的实时信息
00:27
计算收益率
00:07
ret=price 除以 cost - 1
00:18
计算收益率判断盈亏情况
00:33
打印日志
00:07
print('成本价：%s' % cost)
00:17
print('现价：%s' % price)
00:09
print('收益率：%s' % ret)
00:09
如果收益率小于-0.01，即亏损达到1%则卖出股票
00:18
幅度可以自己调，一般10%
00:09
if ret 小于 -0.01
00:11
order_target('000001.XSHE',0)
00:21
print('触发止损')
00:09
非常适合用来做清仓操作
00:15
设置回测时间为从2017-03-01到2017-03-31
00:10
初始资金为100000，频率为天
00:07
回测发现会在2017-03-20触发止损
00:08
自测与自学
00:06
实践下文中的例子
00:29
阅读API文档中Context对象，了解下其中的结构与内容
00:10
context 是聚宽量化编程的重要基础
00:13
Context对象，了解下其中的结构与内容
00:22
写一个策略，内容为在20180301买入一个股票，在20180321卖出一个股票
00:15
股票可以自己定
00:06
20180301买入一个股票，在20180321卖出一个股票
00:26
内容为在20180301买入一个股票，在20180321卖出一个股票
00:13
试着根据止损的例子实现止盈
00:08
即指当盈利达到一定幅度后下单卖出股票
00:09
试着根据止损的例子实现止盈，即指当盈利达到一定幅度后下单卖出股票
00:18
如2004年就是闰年,1999年不是闰年
00:11
世纪年（能被100整除的年份）
00:12
世纪年（能被100整除的年份）能被400整除的是闰年
00:09
如2000年是闰年，1900年不是闰年
00:22
利用取余运算（%）判断是否整除
00:21
循环、多股票策略
00:14
学习用list存储多个股票
00:14
学习使用for循环
00:08
for 循环进行 遍历操作
00:13
学习写一个简单的多股票策略
00:07
自测与自学
00:11
学习用list存储多个股票 - 多股票
00:30
list存储多个股票
00:23
使用for循环
00:17
我们继续以如下这个简单的策略为例进行学习在策略中操作多个股票
00:13
def initialize(context)
00:12
run_daily(period,time='every_bar')
00:12
g.security = '000001.XSHE'
00:06
def period(context)
00:09
用list数据类型存储多个股票
00:09
事实上，根据前面的所学我们是可以写多个股票的策略
00:11
无非是把原来单个股票的操作类似地再写几遍
00:09
比如下面这个策略就在操作两个股票
00:08
g.security1 = '000001.XSHE'
00:09
g.security2 = '000002.XSHE'
00:06
两个变量保存两只股票代码信息
00:09
order(g.security1, 100)
00:11
order(g.security2, 100)
00:11
有多少个交易日就买入多少次
00:21
显然的问题是，当股票比较多的时候，就要写很多遍
00:10
这样的写法就会很麻烦，看着也会比较乱
00:12
首先我们先学习用list数据类型存储多个股票
00:14
把两个股票代码作为list存入g.security中
00:12
g.security = ['000001.XSHE','000002.XSHE']
00:17
list数据类型用法前文有讲过，特点是各个元素用逗号隔开后
00:14
用中括号把所以元素包起来，比较简单，有疑问不妨去回顾下
00:16
接下来是重点内容--循环语句，用它可以方便的批量操作多个股票
00:12
多生成几个变量存放股票，肯定没问题
00:22
把待处理的股票代码放在一个列表中处理
00:12

六大交易指令
Ada-Xue
6.8万 1

048、分数式拆分问题
Ada-Xue
212 0

049、分数式拆分规律总结
Ada-Xue
216 0

11、侦测模块编程积木介绍
Ada-Xue
6.9万 96

046、数轴折叠问题
Ada-Xue
257 0

木槌打妖怪 - Scratch 游戏编程
Ada-Xue
7.1万 42

047、数轴折叠问题分析
Ada-Xue
246 0

050、分数式拆分求解复杂问题
Ada-Xue
208 0

0041、分析图形算式填空
Ada-Xue
7.1万 2

039、等比数列，两式相减
Ada-Xue
426 0

038、单项拆解，前后抵消
Ada-Xue
419 0

035、错位相消求解
Ada-Xue
219 0

037、单项拆解，错位相消
Ada-Xue
431 0

040、等比数列，凑出大量相同项
Ada-Xue
427 0

036、设未知数，错位相消
Ada-Xue
221 0

12、运算模块编程积木介绍
Ada-Xue
6.8万 15
缘缘庄的饭，吃了不烧心
客服
顶部
赛事库 课堂 2021拜年纪