0%

在进行制作视差滚动效果时,需要获得每时每刻滚动条的位置以进行计算,因此会使用window.onscroll来监听滚动条的位置。在pc上可以顺利的连续获得滚动条的任意时刻的坐标,然而在手机上无法顺利获得连续的事件触发。原因是移动端为了获得流畅的滚动效果与弹性效果,对于系统原生的滚动事件进行了限制,因此无法获得连续的滚动事件。

为了在移动端上实现视差网页效果,需要手动模拟用户滚动的事件,这样才能连续获取事件触发。通常使用iscroll等帮助实现效果。

在寻找相关滚动库的时候发现了一款小巧又好用的滚动js库 Jroll,大小仅仅只有13KB,比iscroll的lite版本还要小一半,而且能够完整实现需求。

Git地址:https://git.oschina.net/chenjianlong/JRoll2

官网:http://www.chjtx.com/JRoll/

用法:

引用<script src='jroll.js'></script>后,在文档中定义好滚动对象与滚动容器,例如

1
2
3
4
<div id="wrapper">
<div id="scroller">
</div>
</div>

其中scroller为滚动对象,wrapper为滚动容器。需要注意的是滚动对象的高必须大于滚动容器的高才能顺利地进行滚动操作(废话)

接着创建jroll对象,如下所示

1
jroll = new JRoll("#wrapper", {option});

其中option为配置内容,具体使用方法见官网。

另外,当在页面(滚动对象)中存在类似于动态加载与文本展开等情况的时候,在加载完毕与文本展开动画播放完毕的时候必须要使用jroll.refresh()对jroll对象进行刷新,不然jroll的高度不会发生改变从而使页面显示不全。

在项目中,使用jroll完美地完成了视差滚动效果的实现,在ios设备上的webapp中滚动动画打到了40fps以上。

1
2
3
jroll.on('scroll', function() {
//视差滚动计算
});

原理:在canvas画布上捕捉鼠标(手指)动作,关注下笔、拖动、抬笔三个事件。

下笔使用onmousedown/ontouchstart,拖动使用onmousemove/ontouchmove,抬笔使用onmouseup/ontouchend,同时需要检测笔尖是否移动到画布外(onmouseout)。

在这三个事件被捕捉后,就能顺利的在画布上生成图像了。

在画布上自由画画:

Html:

1
<canvas id="canvas" width="1024" height="665"></canvas>

Javascript:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
var canvas = document.getElementById('canvas');
var can = canvas.getContext('2d');
//定义画布

/****使用自由画笔****/
function Brush(){
canvas.ontouchstart = function(e) {
e = window.event || e;
var sX = e.pageX - this.offsetLeft;
var sY = e.pageY - this.offsetTop;
//获取起始坐标
can.beginPath();
can.moveTo(sX, sY);
status = 1;
}
//画笔移动的时候
canvas.ontouchmove = function(e) {
e = window.event || e;
var eX = e.pageX - this.offsetLeft;
var eY = e.pageY - this.offsetTop;
if(status == 1) {
can.lineTo(eX, eY);
can.stroke();
} else {
return false;
}
}
//画笔抬起的时候
canvas.ontouchend = function() {
can.closePath();
}
}
Brush();

通过以上代码可以实现在画布上自由绘画。

用按钮触发以上函数可实现选择“自由画笔工具”绘画。

相似的,画直线、画圆形、画矩形也是如此:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/****画直线****/
function Line(){
canvas.ontouchstart = function(e) {
e = window.event || e;
sX = e.pageX - this.offsetLeft;
sY = e.pageY - this.offsetTop;
can.beginPath();
can.moveTo(sX, sY);
}
canvas.ontouchmove = function(e) {
}
//画笔抬起时,画笔位置为终点
canvas.ontouchend = function(e) {
e = window.event || e;
var eX = e.pageX - this.offsetLeft;
var eY = e.pageY - this.offsetTop;
can.lineTo(eX, eY);
can.closePath();
can.stroke();
}
}

/****画空心圆形****/
function Arc(){
canvas.ontouchstart = function(e) {
e = window.event || e;
sX = e.pageX - this.offsetLeft;
sY = e.pageY - this.offsetTop;
}
//画空心圆,鼠标抬起时,当前画笔位置为外圆结束点
canvas.ontouchend = function(e) {
e = window.event || e;
var eX = e.pageX - this.offsetLeft;
var eY = e.pageY - this.offsetTop;
var dX = eX - sX
var dY = eY - sY;
var r = Math.sqrt(Math.pow(dX, 2) + Math.pow(dY, 2));
//计算出半径
can.beginPath();
can.arc(sX, sY, r, 0, 360, false);
can.closePath();
can.stroke();
}
}

/****画矩形****/
function Rect(){
canvas.ontouchstart = function(e) {
e = window.event || e;
sX = e.pageX - this.offsetLeft;
sY = e.pageY - this.offsetTop;
}
//画空心矩形,画笔抬起时,当前画笔位置为矩形的右下角
canvas.ontouchend = function(e) {
e = window.event || e;
var eX = e.pageX - this.offsetLeft;
var eY = e.pageY - this.offsetTop;
var w = eX - sX; //矩形的宽
var h = eY - sY; //矩形的高
can.strokeRect(sX, sY, w, h);
}
}

通过以上代码可以实现简单的画图板。但是会产生一个问题:画矩形与圆形时 在画笔移动时,画布上不会产生相应的图形,只有在画笔抬起时才会产生图像,所以在画画的时候感知不到自己纠结画出的图形是怎样的,这样的体验非常差。因此,使用双画布来解决这个问题,即在本来的画布上放一个同样大小的画布,移动画笔的时候在临时画布上不断地清除、绘制图像就能使用户感知到画画的过程。

临时画布需要设置position:absolute与z-index来与主画布重叠。

1
2
3
4
/****清除临时画布的函数****/
function clearContext(){
can_bak.clearRect(0, 0, 1024, 665);
}

例如画圆形时,加上

1
2
3
4
5
6
7
8
9
10
11
12
13
canvas_bak.ontouchmove = function(e) {
e = window.event || e;
clearContext();
var eX = e.pageX - this.offsetLeft;
var eY = e.pageY - this.offsetTop;
var dX = eX - sX
var dY = eY - sY;
var r = Math.sqrt(Math.pow(dX, 2) + Math.pow(dY, 2));
can_bak.beginPath();
can_bak.arc(sX, sY, r, 0, 360, false);
can_bak.closePath();
can_bak.stroke();
}

在ontouchend中加上clearContext();即可。

最终效果:

upload successful

1
<div v-on:tap="getevent($event)">Hello</div>

vm中

1
2
3
4
5
6
methods:{
getevent: function(thisvmObject){
thisObject = thisvmObject.currentTarget;
console.log(thisObject.innerHTML);
}
}

output>>

Hello

使用Objective-C可以轻松实现判断应用是否安装:

1
BOOL result=[[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"weixin://"]];

转换为NativeJS写法为:

1
2
3
4
5
6
7
8
9
function test(){
var NSURL = plus.ios.import('NSURL');
var UIA = plus.ios.import('UIApplication');
var obj = new UIA.sharedApplication();
var result = obj.canOpenURL(NSURL.URLWithString('weixin://'));
//return result;
alert(result);
//[[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"weixin://"]];
}

返回值为1则安装了"weixin",返回0则没安装。

在微信浏览器中,如果页面内容到头或者到底,手指滑动时会拖动整个页面。如图所示

upload successful

在原生滑动过程中,页面中的所有动画(包括canvas动画、gif动图、css变幻、js计时器)会全部停止,在页面回弹到初始位置时才会继续运行,极大地影响了用户的体验。

因此,在用户有拖动操作时需要将页面的上下原生滑动停止,至少要在用户拖动区域禁止原生滚动事件。

例如我在项目中碰到需要用户左右滑动的操作,而如果用户向左下滑动,则会造成页面先向下滑动后回弹,然后定义的事件才会产生。

因此需要使用preventDefault()来禁止原生touchstart动作。但是如果直接使用event.preventDefault()会使整个页面的滚动事件全部失效,达不到想要的效果,因此对其进行有条件的处理。js代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
*
* 禁止微信原生上下滚动
*/
var overscroll = function(el) {
el.addEventListener('touchstart', function() {
var top = el.scrollTop,
totalScroll = el.scrollHeight,
currentScroll = top + el.offsetHeight;
if (top === 0) {
el.scrollTop = 1;
} else if (currentScroll === totalScroll) {
el.scrollTop = top - 1;
}
});
el.addEventListener('touchmove', function(evt) {
if (el.offsetHeight < el.scrollHeight)
evt._isScroller = true;
});
}
overscroll(document.querySelector('#scroll'));//此处的scroll为需要禁止原生滚动的Object
document.body.addEventListener('touchmove', function(evt) {
if (!evt._isScroller) {
evt.preventDefault();
}
});

gulp.js 是一个自动化构建工具,基于 Node.js。通过gulp可以省略前端开发中很多重复无意义的步骤,例如js/css的压缩、less/sass的编译等。

在公司的项目中,需要在测试环境中反复调试一些内容(需求要求),而我在js中使用了es6的let声明关键词与严格模式,在测试容器--微信浏览器下无法顺利运行。因此使用gulp重新构建项目,利用其特性实现自动化压缩js/css,编译less,替换js中的let为var等功能。

项目目录结构:

1
2
3
4
5
6
7
8
9
10
11
12
13
.
├─node_modules
├─dist
│ ├─css
│ ├─fonts
│ ├─images
│ └─js
└─src
├─css
├─fonts
├─images
├─js
└─less

dist目录为构建目录,src为工程目录;

首先下载nodejs,其中也包含了npm包管理工具。

切换到项目根目录下,输入:

1
npm install --global gulp

全局安装gulp。

输入:

1
npm install --save-dev gulp

使其作为项目的开发依赖安装。此时会自动创建目录node_modules;

输入:

1
npm install gulp-uglify gulp-minify-css gulp-sourcemaps gulp-less gulp-concat gulp-rename gulp-imagemin gulp-replace gulp-htmlmin --save-dev

安装项目所需要的插件。

使用到的插件有:

gulp-uglify:js混淆、压缩

gulp-minify-css:css压缩

gulp-sourcemaps:为less插件创建map

gulp-less:编译less文件

gulp-concat:文件合并

gulp-rename:文件重命名

gulp-imagemin:图片压缩

gulp-replace:文本替换(正则式)

gulp-htmlmin:html文件压缩(html中的css与js也会被压缩)

在根目录创建gulpfile.js。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
var gulp=require("gulp");//创建gulp模块
var uglify=require("gulp-uglify");//创建js混淆压缩模块
var minify_css=require("gulp-minify-css");//创建css混淆压缩模块
var less=require('gulp-less');
var gulp_concat=require('gulp-concat');//创建文件合并模块
var del=require('del');
var rename=require('gulp-rename');
var imagemin=require('gulp-imagemin');//压缩图片
var replace=require('gulp-replace');
var htmlmin=require('gulp-htmlmin');
var sourcemaps=require('gulp-sourcemaps');
function clean(path) {
console.log('Clean:' + path)
del(path);
}
gulp.task('less', function() {
gulp.src('./src/less/*.less')
.pipe(sourcemaps.init())
.pipe(less())
.pipe(sourcemaps.write())
.pipe(rename({ suffix: '.min' }))
.pipe(minify_css())
.pipe(gulp.dest('./dist/css'));
});
gulp.task('css', function() {
gulp.src('./src/css/*.css')
.pipe(rename({ suffix: '.min' }))
.pipe(minify_css())
.pipe(gulp.dest('./dist/css'));
});
gulp.task('javascripts', function() {
gulp.src('./src/js/*.js')
.pipe(replace('let ', 'var '))//微信不支持let用法因此换成var
.pipe(replace('"use strict";', ''))//微信不支持严格模式
.pipe(rename({ suffix: '.min' }))
.pipe(uglify())
.pipe(gulp.dest('./dist/js'));
});
gulp.task('html', function() {
var options = {
removeComments: true,//清除HTML注释
collapseWhitespace: true,//压缩HTML
collapseBooleanAttributes: true,//省略布尔属性的值 <input checked="true"/> ==> <input />
removeEmptyAttributes: true,//删除所有空格作属性值 <input id="" /> ==> <input />
removeScriptTypeAttributes: true,//删除<script>的type="text/javascript"
removeStyleLinkTypeAttributes: true,//删除<style>和<link>的type="text/css"
minifyJS: true,//压缩页面JS
minifyCSS: true//压缩页面CSS
};
gulp.src('./src/*.html')
.pipe(replace('let ', 'var '))//微信不支持let用法因此换成var
.pipe(replace('"use strict";', ''))//微信不支持严格模式
.pipe(replace('.css', '.min.css'))//将html引用的资源从css与js变成min.css与min.js
.pipe(replace('.js', '.min.js'))
.pipe(htmlmin(options))
.pipe(gulp.dest('./dist/'));
});
gulp.task('images', function() {
gulp.src(['./src/images/*.*','./src/images/**/*.*'])
.pipe(imagemin())
.pipe(gulp.dest('./dist/images/'));
});
gulp.task('fonts',function(){
gulp.src('./src/fonts/*.*')
.pipe(gulp.dest('./dist/fonts/'));
});
gulp.task('clean', function() {
clean('./dist/*');
});
gulp.task('build', function(){
gulp.run('less','css','javascripts','html','images','fonts');
console.log('Done!')
});
gulp.task('default', function(){
gulp.run('build');
console.log('Done!')
gulp.watch(['./src/less/*.less','./src/js/*.js','./src/css/*.css','./src/*.html','./src/images/*.*','./src/images/*/*.*'], function(){
gulp.run('build');
});
});

与gulp有关的方法主要有以下几种:

gulp.task 定义gulp任务

gulp.run 运行gulp任务

gulp.watch 监控文件变化

gulp.src 输入文件路径

gulp.dest 指定处理完后文件输出的路径

其中参数多是以数组形式输入,例如监控多个目录:

1
2
3
gulp.watch(['./src/less/*.less','./src/js/*.js','./src/css/*.css','./src/*.html','./src/images/*.*','./src/images/*/*.*'], function(){
//检测到文件变化时执行的操作
});

gulp.task定义了任务的名称与过程。

例如

1
2
3
4
gulp.task('default', function(){
gulp.run('build');
console.log('Done!')
});

即定义了default任务,在执行default任务时,执行build任务并返回“Done”

default任务是默认任务,执行时直接在项目目录执行命令

1
gulp

即为进行default任务。

同时也可以通过gulp + 任务名 来运行指定任务,例如

1
gulp clean

即为运行名称为clean的任务。

在任务中,文件以“流”的形式在任务中流转,使用pipe可对其进行操作;.pipe可对与流通至此管道中的文件流进行相关操作。

例如,输入src/images中的所有图片进行压缩后,输出到dist/images

1
2
3
4
5
gulp.task('images', function() {
gulp.src(['./src/images/*.*','./src/images/**/*.*'])
.pipe(imagemin())
.pipe(gulp.dest('./dist/images/'));
});

gulp.src获取images与images子目录下的所有文件,传入管道中;文件流通过imagemin()管道时,其中的图片被分别压缩,最终输出到dist/images目录中。

掌握gulp基本用法后就能够使用它进行一般的工程化构建了。当需要达到某种对文件流的处理效果时,可以在网上搜索相关插件,使用

1
npm install gulp-xxx --save-dev

下载与保存,在gulpfile.js中以var xxx=require('gulp-xxx')形式定义,即可在任务中使用这种插件了。

目的:将排列好的数据重新以随机的方式排列

原理:从数组中随机选出一个元素,放入目标数组中后从原数组中删除这个元素。反复进行这个过程,直到原数组中所有的元素都进入了新的数组。此时目标数组中的元素为随机排列,达到了“洗牌”的效果。

使用Python描述:

1
2
3
4
5
6
7
8
import random
def shuffle(list):
targetlist=[]
while list:
i=random.randrange(0,len(list))
targetlist.append(list[i])
list.pop(i)
return targetlist

random.randrange(0,len(list))为从0到list长度中随机生成一个整数。

targetlist.append(list[i])为将list[i]元素放入targetlist数组中。

list.pop(i)为从list中删除这个元素。

可以通过这个算法实现对训练集与测试集的分配。例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import random

def shuffle_split_data(X, y):
""" Shuffles and splits data into 70% training and 30% testing subsets,
then returns the training and testing subsets. """
# Shuffle and split the data
split_num = int(0.7 * len(X))
X_t = []
y_t = []
X = list(X)
while X:
p = random.randrange(0, len(X))
X_t.append(X[p])
y_t.append(y[p])
X.pop(p)

X_train = X_t[:split_num]
y_train = y_t[:split_num]
X_test = X_t[split_num:]
y_test = y_t[split_num:]

# Return the training and testing data subsets
return X_train, y_train, X_test, y_test

X为输入值,y为输出值,将70%的数据放入训练集,将30%的数据放入测试集

1
2
3
4
5
6
7
8
9
10
11
12
13
from pandas import DataFrame, Series
import numpy

countries = ['Russian Fed.', 'Norway', 'Canada', 'United States',
'Netherlands', 'Germany', 'Switzerland', 'Belarus',
'Austria', 'France', 'Poland', 'China', 'Korea',
'Sweden', 'Czech Republic', 'Slovenia', 'Japan',
'Finland', 'Great Britain', 'Ukraine', 'Slovakia',
'Italy', 'Latvia', 'Australia', 'Croatia', 'Kazakhstan']

gold = [13, 11, 10, 9, 8, 8, 6, 5, 4, 4, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
silver = [11, 5, 10, 7, 7, 6, 3, 0, 8, 4, 1, 4, 3, 7, 4, 2, 4, 3, 1, 0, 0, 2, 2, 2, 1, 0]
bronze = [9, 10, 5, 12, 9, 5, 2, 1, 5, 7, 1, 2, 2, 6, 2, 4, 3, 1, 2, 1, 0, 6, 2, 1, 0, 1]

显示奖牌数据:

1
2
3
4
5
6
7
8
olympic_medal_counts_df = DataFrame(
{'country_name': countries,
'gold': gold,
'silver': silver,
'bronze': bronze})
print olympic_medal_counts_df

df = olympic_medal_counts_df

output>>

upload successful

计算至少获得一枚金牌的国家所获得铜牌的平均数:

1
2
avg_bronze_at_least_one_gold = numpy.mean(df[df.gold &gt; 0].bronze)
print avg_bronze_at_least_one_gold

output>>4.2380952381

计算金牌、银牌与铜牌的平均数:

1
2
avg_medal_count=numpy.mean(df[['gold','silver','bronze']])
print avg_medal_count

output>>

upload successful

如果收获一枚金牌得4分,一枚银牌得2分,一枚铜牌得1分,计算所有国家的总分数

1
2
3
df['points'] = df[['gold','silver','bronze']].dot([4,2,1])
olympic_points_df = df[['country_name','points']]
print olympic_points_df

output>>

upload successful

Numpy为Python下的科学计算库,用于快速处理数据、科学计算等。

pandas 是基于 Numpy 构建的含有更高级数据结构和工具的数据分析包


Numpy 库文档:https://docs.scipy.org/doc/numpy-dev/user/quickstart.html

Pandas 库文档:http://pandas.pydata.org/pandas-docs/version/0.17.0/


1
import numpy as np

Numpy的基本使用

创建数组

1
2
array = np.array([1, 4, 5, 8], float)
print array

output>>[ 1. 4. 5. 8.]

np.array最后的参数表示数据类型为浮点。因此显示数组时整数后会有一个小数点。

重建的数组中所有数据必须为相同的数据类型

The array object class is the foundation of Numpy, and Numpy arrays are like lists in Python, except that every thing inside an array must be of the same type, like int or float.

创建二维数组

同理:

1
2
array = np.array([[1, 2, 3], [4, 5, 6]], float)  # a 2D array/Matrix
print array

output>>[[ 1. 2. 3.][ 4. 5. 6.]]

存取元素

与Python基本用法一致

1
2
array = np.array([1, 4, 5, 8], float)
print array

output>>[ 1. 4. 5. 8.]

1
print array[1]##显示数组中下标为1的数据

output>>4.0

1
print array[:2]##显示数组从下标0开始向后的2个数据

output>>[ 1. 4.]

1
2
array[1]=5.0##通过下标修改对应数据
print array[1]

output>>5.0


1
2
two_D_array=np.array([[1, 2, 3], [4, 5, 6]], float)##创建2d数组
print two_D_array

output>>[[ 1. 2. 3.][ 4. 5. 6.]]

1
print two_D_array[1][1]##显示下标为1的数据组中的下标为1的数据

output>>5.0

1
print two_D_array[1, :]##显示下标为1的数据组中所有数据

output>>[ 4. 5. 6.]

1
print two_D_array[:, 2]##显示所有数据组中的下标为2的数据

output>>[ 3. 6.]

数组运算

数组间的四则运算

1
2
array_1 = np.array([1, 2, 3], float)
array_2 = np.array([5, 2, 6], float)
1
2
3
4
print array_1 + array_2
print array_1 - array_2
print array_1 * array_2
print array_1 / array_2

output>>[ 6. 4. 9.]

output>>[-4. 0. -3.]

output>>[ 5. 4. 18.]

output>>[ 0.2 1. 0.5]

二维数组间的四则运算

1
2
array_1 = np.array([[1, 2], [3, 4]], float)
array_2 = np.array([[5, 6], [7, 8]], float)
1
2
3
4
print array_1 + array_2
print array_1 - array_2
print array_1 * array_2
print array_1 / array_2

output>>[[ 6. 8.][ 10. 12.]]

output>>[[-4. -4.][-4. -4.]]

output>>[[ 5. 12.][ 21. 32.]]

output>>[[ 0.2 0.33333333][ 0.42857143 0.5]]

数据快速处理

1
2
array_1 = np.array([1, 2, 3], float)
array_2 = np.array([[6], [7], [8]], float)

求和:

1
2
print np.sum(array_1)
print np.sum(array_2)

output>>6.0

output>>21.0

求均值:

1
2
print np.mean(array_1)
print np.mean(array_2)

output>>2.0

output>>7.0

求方差:

1
2
print np.var(array_1)
print np.var(array_2)

output>>0.666666666667

output>>0.666666666667

求标准差:

1
2
print np.std(array_1)
print np.std(array_2)

output>>0.816496580928

output>>0.816496580928

求内积:

1
print np.dot(array_1, array_2)

output>>[ 44.]


1
import pandas as pd

Pandas的基本使用

1
2
series = pd.Series(['Dave', 'Cheng-Han', 'Udacity', 42, -1789710578])
print series
index column
0 Dave
1 Cheng-Han
2 Udacity
3 42
4 -1789710578

dtype: object

1
2
3
4
5
##通过Python字典对象创建一个数据系列,自动使用递增整型作为索引。
series = pd.Series(['Dave', 'Cheng-Han', 359, 9001],
index=['Instructor', 'Curriculum Manager',
'Course Number', 'Power Level'])
print series
column0 column1
Instructor Dave
Curriculum Manager Cheng-Han
Course Number 359
Power Level 9001

dtype: object

1
2
##为数据添加了索引,此时可以通过索引来选择数据:
print series['Instructor']

output>>Dave

1
print series[['Instructor', 'Curriculum Manager', 'Course Number']]

column0 column1
Instructor Dave
Curriculum Manager Cheng-Han
Course Number 359

dtype: object

通过bool来显示数据是否满足筛选条件:

1
2
cuteness = pd.Series([1, 2, 3, 4, 5], index=['Cockroach', 'Fish', 'Mini Pig',
'Puppy', 'Kitten'])
1
print cuteness > 3

column0 column1
Cockroach False
Fish False
Mini Pig False
Puppy True
Kitten True

dtype: bool

只显示满足条件的数据:

1
print cuteness[cuteness > 3]

column0 column1
Puppy True
Kitten True

dtype: int64

使用数据框架:

1
2
3
4
5
6
7
data = {'year': [2010, 2011, 2012, 2011, 2012, 2010, 2011, 2012],
'team': ['Bears', 'Bears', 'Bears', 'Packers', 'Packers', 'Lions',
'Lions', 'Lions'],
'wins': [11, 8, 10, 15, 11, 6, 10, 4],
'losses': [5, 8, 6, 1, 5, 10, 6, 12]}
football = pd.DataFrame(data)
print football
output>>

upload successful

显示数据框架各列数据格式:

##to get the datatype for each column

1
print football.dtypes
output>>

losses int64

team object

wins int64

year int64

dtype: object

对数据列进行快速统计与汇总:

1
2
## useful for seeing basic statistics of the dataframe's numerical columns
print football.describe()

output>>

 losses        wins       year 

count 8.000000 8.000000 8.000000##总数

mean 6.625000 9.375000 2011.125000##均值

std 3.377975 3.377975 0.834523##标准差

min 1.000000 4.000000 2010.000000##最小值

25% 5.000000 7.500000 2010.750000

50% 6.000000 10.000000 2011.000000

75% 8.500000 11.000000 2012.000000

max 12.000000 15.000000 2012.000000##最大值

显示前5行

1
print football.head()

output>>

upload successful

显示后5行

1
print football.tail()

output>>

upload successful

通过索引来访问对应列

1
2
print football['year']##显示year这一列
##也可用print football.year

output>>

0 2010 1 2011 2 2012 3 2011 4 2012 5 2010 6 2011 7 2012 Name: year, dtype: int64

显示year wins losses三列

1
print football[['year', 'wins', 'losses']]

output>>

year wins losses 0 2010 11 5 1 2011 8 8 2 2012 10 6 3 2011 15 1 4 2012 11 5 5 2010 6 10 6 2011 10 6 7 2012 4 12

显示第[0]行数据

1
print football.loc[[0]]

output>> losses team wins year 0 5 Bears 11 2010

显示从第[3]行到第[5]行

1
print football[3:5]

output>>

losses team wins year 3 1 Packers 15 2011 4 5 Packers 11 2012

显示wins中大于10的行

1
print football[football.wins > 10]

output>>

upload successful

显示wins大于10且team为Packers的行

1
print football[(football.wins > 10) &amp; (football.team == "Packers")]

output>>

upload successful

传出值页面:

1
2
var todo_page= plus.webview.currentWebview().opener();//父页面,也可以是别的webviewObject
mui.fire(todo_page,"id",{id:1});

收到值/执行函数页面

1
2
3
window.addEventListener("price",function(event){
console.log(event.detail.price);
});

得到:1