REFLECTIES

Using the Hypothesis LMS App with Assignments in Canvas

A Gentle Tutorial of Recurrent Neural Network with ErrorBackpropagation

Open-Domain Neural Dialogue Systems

Fitting A Mixture Distribution to Data: Tutorial

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

// 声明变量，默认 map 是 nil
var map_variable map[key_data_type]value_data_type

// 使用make 函数
map_variable := make(map[key_data_type]value_data_type)

/* 打印子切片从索引 0(包含) 到索引 2(不包含) */ number2 := numbers[:2] printSlice(number2) /* 打印子切片从索引 2(包含) 到索引 5(不包含) */ number3 := numbers[2:5] printSlice(number3)

numbers := []int{0,1,2,3,4,5,6,7,8}

通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片

s := make([]int, len, cap)

初始化切片s,是数组arr的引用

s := arr[:]

/* 未定义长度的数组只能传给不限制数组长度的函数 */ setArray(array) /* 定义了长度的数组只能传给限制了相同数组长度的函数 */ var array2 = [5]int{1, 2, 3, 4, 5}

func setArray(params []int) {
    fmt.Println("params array length of setArray is : ", len(params))
}

func setArray2(params [5]int) {
    fmt.Println("params array length of setArray2 is : ", len(params))
}

注意：以上代码中倒数第二行的 } 必须要有逗号，因为最后一行的 } 不能单独一行，也可以写成这样：

a = [3][4]int {
    {0, 1, 2, 3} ,
    {4, 5, 6, 7} ,
    {8, 9, 10, 11} ,    // 此处的逗号是必须要有的
}

a = [3][4]int {
    {0, 1, 2, 3} ,
    {4, 5, 6, 7} ,
    {8, 9, 10, 11}}

func getSequence() func() int { i:=0 return func() int { i+=1 return i } }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。

for key, value := range oldMap {
     newMap[key] = value
}

以下描述了 select 语句的语法

1. 如果有default子句，则执行该语句。
2. 如果没有default字句，**select将阻塞，直到某个通信可以运行**；Go不会重新对channel或值进行求值。

iota 表示从 0 开始自动加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，这没问题，关键在 k 和 l，从输出结果看 k=3<<2，l=3<<3。

package main
import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)
func main() {
    fmt.Println("i=", i)
    fmt.Println("j=", j)
    fmt.Println("k=", k)
    fmt.Println("l=", l)
}

i=1
j=6
k=12
l=24

这种因式分解关键字的写法一般用于声明全局变量

var (
    vname1 v_type1
    vname2 v_type2
)

以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）

main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）

The evidence strongly suggests that the Canadiens adopted a casual attitude toward the clergy, which could (and did) sometimes express itself as contempt

Student Tutorials

GNUCASH – Gerenciador Financeiro-Contábil

Self-Publishing Guide

Other Java Tutorials and Learning Sites

Gopro Hero5 Session - Comparative shooting mode

The do's and don'ts of gathering ambient background, or harvesting 'wild sound'

Tinkering With Sound Design

How to sound map a city, part two

How to sound map a city: part one

How to reimagine a sound in ten easy steps

GoPro HERO 5 SESSION Tutorial: How To Get Started

Shoot Aerial Video Like a Pro – Mastering Drone Footage – PART 1

Welcome to OLOT - the Online Learning Orientation Tool

Tutorial: Animation Nodes - Solar system

Free #OER Mobile Course Is Available Online Now

slack-invite-script

in getMyHost() fill in your slack domain

fill in your slack api token

fill in the channel you want to send updates to

R Grouping functions: sapply vs. lapply vs. apply. vs. tapply vs. by vs. aggregate var ados = ados || {}; ados.run = ados.run || []; ados.run.push(function () { ados_add_placement(22,8277,"adzerk794974851",4).setZone(43); }); up vote 463 down vote favorite 606 Whenever I want to do something "map"py in R, I usually try to use a function in the apply family. (Side question: I still haven't learned plyr or reshape -- would plyr or reshape replace all of these entirely?) However, I've never quite understood the differences between them [how {sapply, lapply, etc.} apply the function to the input/grouped input, what the output will look like, or even what the input can be], so I often just go through them all until I get what I want. Can someone explain how to use which one when? [My current (probably incorrect/incomplete) understanding is... sapply(vec, f): input is a vector. output is a vector/matrix, where element i is f(vec[i]) [giving you a matrix if f has a multi-element output] lapply(vec, f): same as sapply, but output is a list? apply(matrix, 1/2, f): input is a matrix. output is a vector, where element i is f(row/col i of the matrix) tapply(vector, grouping, f): output is a matrix/array, where an element in the matrix/array is the value of f at a grouping g of the vector, and g gets pushed to the row/col names by(dataframe, grouping, f): let g be a grouping. apply f to each column of the group/dataframe. pretty print the grouping and the value of f at each column. aggregate(matrix, grouping, f): similar to by, but instead of pretty printing the output, aggregate sticks everything into a dataframe.] r sapply tapply r-faq

Hypothes.is says its mission is to bring a new layer to the web, allowing you to annotate and share anything on the Internet. You can also see and respond to other people’s public or shared comments, creating online conversation and a system of peer review for online content. I created a quick video tutorial in Quicktime, shared above.

Outside the triple, information is lost and a literal is just data without any meaning.

hey can not be subjects in RDF triples – they are always the objects used to describe a resource.

Literals are nodes in an RDF graph, used to identify values such as numbers and dates by means of a lexical representation.

Edit, Compile, Execute and Share your C, C++, Java, Python, Perl, PHP, Node.js, Javascript, HTML-5 or any project in your social networks using simple links.