python调用函数时r的简单介绍

python中如何调用自己写的函数

在python中，除了调用下载的扩展库之外，还可以自定义函数，方便自己。把基础模块放在固定文件夹（或相对固定文件夹），使用sys.append(r’自定义的模块路径’)实例如下：

创新互联公司于2013年创立，是专业互联网技术服务公司，拥有项目网站设计、成都网站设计网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元东昌做网站,已为上家服务,为东昌各地企业和个人服务,联系电话:18980820575

1、在E:pycharm新建hello.py实现基础功能函数（定义一个hello()函数）

2、调用自定义的函数

3、运行结果为：

更多Python相关技术文章，请访问Python教程栏目进行学习！以上就是小编分享的关于python中如何调用自己写的函数的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

python如何定义和调用函数

1、函数定义

①使用def关键字定义函数

②

def 函数名(参数1.参数2.参数3...):

"""文档字符串，docstring，用来说明函数的作用"""

#函数体

return 表达式

注释的作用：说明函数是做什么的，函数有什么功能。

③遇到冒号要缩进，冒号后面所有的缩进的代码块构成了函数体，描述了函数是做什么的，即函数的功能是什么。Python函数的本质与数学中的函数的本质是一致的。

2、函数调用

①函数必须先定义，才能调用，否则会报错。

②无参数时函数的调用：函数名()，有参数时函数的调用：函数名(参数1.参数2.……)

③不要在定义函数的时候在函数体里面调用本身，否则会出不来，陷入循环调用。

④函数需要调用函数体才会被执行，单纯的只是定义函数是不会被执行的。

⑤Debug工具中Step into进入到调用的函数里，Step Into My Code进入到调用的模块里函数。

python中r'什么意思

Python与R的区别和联系

1、区别

Python与R的区别是显而易见的，因为R是针对统计的，python是给程序员设计的。2012年R是学术界的主流，但是现在Python正在慢慢取代R在学术界的地位。

Python与R相比速度要快。Python可以直接处理上G的数据；R不行，R分析数据时需要先通过数据库把大数据转化为小数据（通过groupby）才能交给R做分析，因此R不可能直接分析行为详单，只能分析统计结果。所以有人说：Python=R+SQL/Hive，并不是没有道理的。

Python的一个最明显的优势在于其胶水语言的特性，很多书里也都会提到这一点，一些底层用C写的算法封装在Python包里后性能非常高效(Python的数据挖掘包Orange canve 中的决策树分析50万用户10秒出结果，用R几个小时也出不来，8G内存全部占满)。但是，凡事都不绝对，如果R矢量化编程做得好的话（有点小难度），会使R的速度和程序的长度都有显著性提升。

R的优势在于有包罗万象的统计函数可以调用，特别是在时间序列分析方面，无论是经典还是前沿的方法都有相应的包直接使用。相比之下，Python之前在这方面贫乏不少。但是，现在Python有了pandas。pandas提供了一组标准的时间序列处理工具和数据算法。因此，可以高效处理非常大的时间序列，轻松地进行切片/切块、聚合、对定期/不定期的时间序列进行重采样等。近年来，由于Python有不断改良的库（主要是pandas），使其成为数据处理任务的一大替代方案。

2、联系

通过R和Python只共享文件，Python把源数据处理干净，生成格式化的文件放在预定的目录下，做个定时器让R去读文件，最终输出统计结果和图表。

让Python直接调用R的函数，R是开源项目，有rpy2之类的模块，可以实现使用python读取R的对象、调用R的方法以及Python与R数据结构转换等。

python函数调用

inname = r"C:\Python27\esri.shp"

outname = "outname.cst"

# 在此处调用该函数。函数体定义必须放在调用以前。可以通过import

read_ESRT_……(file = inname, fileOut = outname)

# 这两个参数只是字符串而已，指明你的文件路径。注意在python中，若有 \ 号，则最好使用 \\ 双斜杠，或者如上例，加上前缀 r

Python调用R编程——rpy2

在Python调用R，最常见的方式是使用rpy2模块。

The package is made of several sub-packages or modules:

Importing R packages is often the first step when running R code, and rpy2 is providing a function rpy2.robjects.packages.importr() that makes that step very similar to importing Python packages.

We mentioned earlier that rpy2 is running an embedded R. This is may be a little abstract, so there is an object rpy2.robjects.r to make it tangible.

The __getitem__() method of rpy2.robjects.r, gets the R object associated with a given symbol

The object r is also callable , and the string passed in a call is evaluated as R code.

An R object has a string representation that can be used directly into R code to be evaluated.

In R, data are mostly represented by vectors, even when looking like scalars. When looking closely at the R object pi used previously, we can observe that this is in fact a vector of length 1.

Creating R vectors can be achieved simply.

The easiest way to create such objects is to do it through R functions.

Calling R functions is disappointingly similar to calling Python functions.

By default, calling R functions return R objects.

Linear models

Creating an R vector or matrix, and filling its cells using Python code

This module should be the right pick for casual and general use. Its aim is to abstract some of the details and provide an intuitive interface to both Python and R programmers.

The instance can be seen as the entry point to an embedded R process. The elements that would be accessible from an equivalent R environment are accessible as attributes of the instance.

When safety matters most, we recommend using __getitem__() to get a given R object.

Storing the object in a python variable will protect it from garbage collection, even if deleted from the objects visible to an R user.

Just like it is the case with RPy-1.x, on-the-fly evaluation of R code contained in a string can be performed by calling the r instance.

The astute reader will quickly realize that R objects named by python variables can be plugged into code through their R representation.

R environments can be described to the Python user as an hybrid of a dictionary and a scope.

The first of all environments is called the Global Environment, that can also be referred to as the R workspace.

Assigning a value to a symbol in an environment has been made as simple as assigning a value to a key in a Python dictionary.

An environment is also iter-able, returning all the symbols (keys) it contains.

R functions exposed by rpy2's high-level interface can be used:

This is all looking fine and simple until R arguments with names such as na.rm are encountered. By default, this is addressed by having a translation of ‘.’ (dot) in the R argument name into a ‘_’ in the Python argument name.

In Python one can write:

R is capable of introspection, and can return the arguments accepted by a function through the function formals().

The method Function.rcall() is an alternative way to call an underlying R function.

For tasks such as modelling and plotting, an R formula can be a terse, yet readable, way of expressing what is wanted.

The class robjects.Formula is representing an R formula.

Other options are:

This is achieved by the R functions library() and require() (attaching the namespace of the package to the R search path).

Beside functions and environments, most of the objects an R user is interacting with are vector-like. For example, this means that any scalar is in fact a vector of length one.

The class Vector has a constructor:

Creating vectors can be achieved either from R or from Python.

When the vectors are created from R, one should not worry much as they will be exposed as they should by rpy2.robjects.

When one wants to create a vector from Python, either the class Vector or the convenience classes IntVector, FloatVector, BoolVector, StrVector can be used.

Extracting, Python-style

The python __getitem__() method behaves like a Python user would expect it for a vector (and indexing starts at zero).

Extracting, R-style

Access to R-style extracting/subsetting is granted though the two delegators rx and rx2, representing the R functions [ and [[ respectively.

Assigning, Python-style

Since vectors are exposed as Python mutable sequences, the assignment works as for regular Python lists.

In R vectors can be named, that is elements of the vector have a name.

Assigning, R-style

The attributes rx and rx2 used previously can again be used:

For the sake of complete compatibility with R, arguments can be named (and passed as a dict or rpy2.rlike.container.TaggedList).

In S/Splus/R special NA values can be used in a data vector to indicate that fact, and rpy2.robjects makes aliases for those available as data objects NA_Logical, NA_Real, NA_Integer, NA_Character, NA_Complex .

To expose that to Python, a delegating attribute ro is provided for vector-like objects.

R vectors can have a name given to all or some of the elements. The property names can be used to get, or set, those names.

Array

In R, arrays are simply vectors with a dimension attribute. That fact was reflected in the class hierarchy with robjects.Array inheriting from robjects.Vector.

Matrix

A Matrix is a special case of Array. As with arrays, one must remember that this is just a vector with dimension attributes (number of rows, number of columns).

DataFrame

In rpy2.robjects, DataFrame represents the R class data.frame.

Creating a DataFrame can be done by:

The DataFrame constructor accepts either an rinterface.SexpVector (with typeof equal to VECSXP, that is, an R list) or any Python object implementing the method items() (for example dict or rpy2.rlike.container.OrdDict).

To create a DataFrame and be certain of the clumn order order, an ordered dictionary can be used:

Here again, Python’s __getitem__() will work as a Python programmer will expect it to:

The DataFrame is composed of columns, with each column being possibly of a different type:

The approach followed in rpy2 has 2 levels (rinterface and robjects), and conversion functions help moving between them.

R vectors are mapped to Python objects implementing the methods __getitem__() / __setitem__() in the sequence protocol so elements can be accessed easily.

R functions are mapped to Python objects implementing the __call__() so they can be called just as if they were functions.

R environments are mapped to Python objects implementing __getitem__() / __setitem__() in the mapping protocol so elements can be accessed similarly to in a Python dict.

In its high-level interface rpy2 is using a conversion system that has the task of convertion objects between the following 3 representations: - lower-level interface to R (rpy2.rinterface level), - higher-level interface to R (rpy2.robjects level) - other (no rpy2) representations

R vectors or arrays can be converted to numpy arrays using numpy.array() or numpy.asarray().

The activation (and deactivation) of the automatic conversion of numpy objects into rpy2 objects can be made with: