Explore
For Enterprise
Join for Free
Log In

艺术与人文
商务
计算机科学
数据科学
信息技术
健康
数学和逻辑
个人发展
物理科学与工程
社会科学
语言学习
学位
证书

浏览 Coursera 的全部课程

浏览
搜索
企业版
登录
免费加入

R S4 Methods

Loading...

使用Bioconductor分析基因组科学数据

约翰霍普金斯大学

4（186 个评分） | 10K 名学生已注册

课程 6（共 8 门，基因组数据科学专项课程）

Learn to use tools from the Bioconductor project to perform analysis of genomic data. This is the fifth course in the Genomic Big Data Specialization from Johns Hopkins University.

查看授课大纲

您将学习的技能

Bioinformatics, Bioconductor, Genomics, R Programming

审阅

4（186 个评分）

5 stars
87 ratings
4 stars
52 ratings
3 stars
23 ratings
2 stars
9 ratings
1 star
15 ratings

AB

Apr 12, 2018

Amazing course, motivated me to use bio conductor for descriptive seq studies of DNA.

CZ

Feb 10, 2016

I learned a lot from this class and the instructor is good.

从本节课中

Week Three

In this week we will cover Basic Data Types, ExpressionSet, biomaRt, and R S4.

Basic Data Types4:58

Annotation Overview4:33

ExpressionSet Overview4:19

ExpressionSet9:49

SummarizedExperiment7:44

R S4 Classes16:55

R S4 Methods10:14

教学方

Kasper Daniel Hansen, PhD
Assistant Professor, Biostatistics and Genetic Medicine

脚本

In this session we'll discuss S4 methods.

It's a continuation of the previous session on S4 classes.

Let's start by load the GenomicRanges library.

There's going to be a few examples we're going to pick from there.

So a method is a function that allows you to

run different sets of code based on different values of the argument.

That sounds very fancy, in reality it's pretty simple.

Over here in the R console I've written a small function called mimicMethod that

looks very much like you want to think about an S4 method or any kind of method.

So it's a function that takes a single argument x, and

it basically consists of a lump of if statements.

It says that if x is a matrix, run some code that's called method1.

If x is a data.frame, run some code that's called method2.

If x is an IRanges, run some code that is called method3.

In this case, mimicMethod is what is know as a generic function,

because this is where the kind of if statements happens.

x is the main argument.

We're doing dispatching on x.

It means that we examine x, and we use the class

of x to tell us which piece of code to run.

So that sounds a little fancy.

Let's take an example.

And let's look at as.data.frame.

So when we look at the printout for as.data.frame,

you can see that there's something with a standard generic and

something with a method, and this identifies it as a S4 method.

You can see that it was made into an S4 method in the packet called BiocGenerics.

And there's a version from base R that we can access with

base::as.data.frame that is not an s4 method.

It looks differently it is actually an S3 method as you can

see there's something called UseMethod inside the function definition.

But BiocGenerics redefines this method as an S4 method.

This is what happens when you get a lot of printout in the beginning.

Let me scrolled back up a little bit.

It says here the following objects are masked from package:base,

and in here we have as.data.frame.

So this printout we get when we load genomic ranges,

or it actually happens when we load BiocGenerics,

is just telling us that as.data.frame is being redefined as an S4 generic.

So as.data.frame is going to examine its argument and

decide which piece of code to run.

So let's see how many pieces of code we have to find.

We look at that by the showMethods function.

And we see that it's defined for

a number of different classes that are all Bioconductor classes.

So we are going to do dispatching on the argument called lowercase x and

it runs different types of code depending on which class x has.

It doesn't have strictly to be different kinds of code.

Some of these things might be the same code.

[COUGH] So how do we actually see the code?

We use the function getMethod and

now we have to say what method is it we are interested in.

It's as.data.frame, and what is the value of x.

So I can say GenomicRanges, and

out is the function definition or method definition.

Now note in the thing I said here with getMethod I didn't really tell it that

it was the argument x that was GenomicRanges.

The foolproof call to getMethod says I have to do something known as

signature and I say that x is x as GenomicRanges.

So how do we get help on methods?

That is a little irritating.

It's irritating because you have to type a lot to get to the right help page.

So let's go back here and look at the showMethods.

The problem with S4 methods is that each of these specific functions

that are listed here, or specific instances of methods

that are listed here, can have its own help page and its own package.

So you have write not only am I looking for help on as.data.frame but

also as.data.frame when run on a, let's say, capital DataFrame.

So there's two ways of doing it.

They are very similar to the way we get help for S4 classes.

We just say method, colon.

Now we have to have some quotes.

So we're learning for as.data.frame and a comma, and

then say we want to look for the DataFrame where x is a DataFrame.

And out comes a help page that really mostly talks about the capital DataFrame

class and perhaps somewhere says that there's an as.data.frame near here.

You can also, instead of having this ugly method?,

we can just say ?as.data.frame,

the class we want to examine, and then -method.

Not even method.

Method.

[COUGH] Or

we want something else, GenomicRanges.

So we have to type a lot, and

this becomes even worse if we are dispatching on multiple arguments.

So in as.data frame,

you can see that we just have functions that defined for different values of x.

So we are only dispatching on the argument x.

Let's look at something more complicated.

Let's show the methods for findOverlaps.

This is a function we love in this class.

[COUGH]

So findOverlaps have two main arguments.

It has a query and a subject.

[COUGH] And

it does dispatching on both query and subject.

And depending on different combinations of query and

subject, it's going to run different types of code.

[COUGH] So now we get into this problem where we, well,

not a problem, but now we have to use the signature.

We have to write a lot in order to see, so if we want to get the method,

We now use signature and now we have to say that the query,

Could be a Ranges and

the subject could be a RangesList.

[COUGH] Okay, you can see up in the showMethod output

that there wasn't a combination like this,

but there's a combination from Ranges and Ranges.

We see the code, and in a similar way if we want to get

some help on it, we say ?findOverlaps, and

now you have to know the order in which things are.

So now we have to set Ranges,

cover Ranges-method.

And we get to the right help page.

So S4 methods are really powerful if you are writing a package

where you want objects in the package to work like basic R functions.

That's the case for IRanges and GenomicRanges, and

we know when we like those classes and the functionality just works.

The drawbacks to S4 methods is that it's hard to use the help system.

It's hard to see the code.

They are hard to debug.

And so I think they can be a little bit of a pain.

For the use case that you have with GenomicRanges and IRanges,

it's hard to imagine doing what they're doing without using S4 methods.

But many packages that does analysis, it's not so

clear what people gain from using S4 methods.

In my own work, I use S4 classes extensively in my own methods development.

I use S4 methods quite sparingly.

探索我们的目录

免费加入并获得个性化推荐、更新和优惠。

Coursera 致力于普及全世界最好的教育，它与全球一流大学和机构合作提供在线课程。

© 2019 Coursera Inc. 保留所有权利。

通过 App Store 下载

通过 Google Play 获取

Coursera
关于
管理团队
工作机会
目录
证书
MasterTrack™ 证书
学位
企业版
政府版

社区
Learners
Partners
Developers
Beta Testers
Translators

连接
博客
Facebook
领英
Twitter
Instagram
YouTube
技术博客

更多
条款
隐私
帮助
内容访问
媒体
联系我们
目录
附属公司