pycharm安装库失败怎么办
pycharm安装库失败的解决方法：1、首先打开pycharm，进入启动界面；2、点击“Create New Project”选项；3、勾选“Inherit global site-packages”选项即可。
解决方法：
（推荐教程：Python入门教程）
首先打开Pycharm，在启动界面中点击“Create New Project”选项；
然后勾选 inherit global site-package 和 make available to all project 选项即可。
python模块安装完成,但是在pycharm里面却导入失败
参考
github
将Inherit global site-packages这个选项勾选,应该可以解决大部分的问题了吧!
对于上面的问题，是python的虚拟环境引起的问题，如果安装了module，需要对虚拟环境进行配置，之后就可以进行使用了，不配置的话就需要点击Inherit global site-packages，或者existing interperter，这样就默认不适用虚拟环境，然后选择一个解释器即可。
选择“Create New Project”来创建新项目就会打一个创建项目的向导页。
在如上图所示的界面中，我们可以选择创建项目的模板，包括了纯Python项目、基于各种不同框架的Web项目、Web前端项目、跨平台项目等各种不同的项目模板。如果选择Python的项目，那么有一个非常重要的设定是选择“New environment…”（创建新的虚拟环境）还是使用“Existing Interpreter”（已经存在的解释器）。前者肯定是更好的选择，因为新的虚拟环境不会对系统环境变量中配置的Python环境造成影响，简单举个例子就是你在虚拟环境下安装或者更新了任何三方库，它并不会对系统原有的Python解释器造成任何的影响，但代价是需要额外的存储空间来建立这个虚拟环境。
最后发现是anaconda安装以后，interpreter没有设置成anaconda导致的
参考 https://blog.csdn.net/u011262253/article/details/88542836
pycharm关闭后需要重新安装
关于pycharm关闭后需要重新安装相关资料如下
pycharm每次新建项目都要重新安装一些有三个解决办法，也是亲测有用的：
第一个方法：因为之前有通过pycharm的project interpreter里的+号添加过一些库，但添加的库只是指定的项目用的，如果想要用，就必须用之前的项目的python解释器，举个例子：
这个是我之前的项目的解释器，这个项目解释器是继承的python的解释器，同时又安装了上面你看到的这些库，包含numpy和opencv-python等，然后我新建一个项目：
这个项目的解释器是这个，没有我之前安装的numpy以及opencv等库。只要 把它换成之前项目的解释器就自动会加载之前项目安装的第三方库了。效果如下（注意我的解释器的路径）
这样就可以用之前下载好的python第三方库了，不知道有没有说明白。
第二个方法：
添加项目所用的python的site-package的路径，这个同时也解决了，为什么在有的时候cmd可以导入一些库，而pycharm不导入会报no moudule的问题，实际上还是环境变量的问题
点击设置参数
在环境变量里面添加一个PYTHONPATH路径
这个路径可以通过cmd找到，因为都说了cmd可以找到这个全局安装的库，但是pycharm找不到
这个路径填：H:\library\python\lib\site-packages即可
实际上很多库安装之后都会把路径信息加到这里，这样就能找到安装的库。
第三个方法：
如果你安装的库都是通过pip安装到site-packages里面的话，其实可以继承一下就可以了
点开解释器，Add
把inherit global site-packages 打上勾就可以了
pycharm虚拟环境命名有有哪些
python中的虚拟环境（以pycharm为例）
1.什么是python虚拟环境？
python虚拟环境 = python第三方库 + python解释器
2.python虚拟环境的用处？
对python第三方库进行分开管理。例如：
（1）现在你有两个项目，项目A需要使用Django1.0，项目B需要使用Django1.1，在同一个环境中不能同时安装同一个包的不同版本，因而每次你想运行完项目A后想运行项目B了，就必须卸载Django1.0，重新安装Django1。
（2）python软件中安装了100个第三方库，但是项目C只需要10个库。从而每次进入pycharm都需要加载完python中的100个库，显然，这样没有必要。
虚拟环境可以帮助解决这两种情况。
3.下载到python软件的第三方库与下载到pycharm虚拟环境的第三方库的关系?
（1）pycharm虚拟环境可以使用下载到python软件中的第三方库
第一种方法：在新建虚拟环境的时候勾选inherit global site-packages(意思是导入python中下载的所有第三方库)，如下图
勾选inherit global site-packages(意思是导入python中下载的所有第三方库)
第二种方法，在pycharm中导入python第三方库的文件位置。依次点击settings-》project-》project structure-》右边的，选择python第三方库的文件位置。如下图，
顺便再说一下第一张图，如果勾选了Make available to all project，那么在虚拟环境中下载第三方库后，都会自动下载到python软件中。图如下，
4.如何更换虚拟环境？
每个项目创建成功后项目文件下都会有一个python.exe文件，（在项目名称下面的venv\Scripts\python.exe），在python interpret选择相应python.exe，即是选择了该项目使用的虚拟环境。
例如新建test2项目，选择使用我的Django项目所使用的环境
创建成功后，使用pycharm terminal查看第三方库
Django库也在里面。
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:
我已经用pip安装了statsmodels 但是pycharm中找不到它，pycharm也无法安装
这个是因为pycharm中设置问题，你要设置python的路径
在设置
这样 设置到你默认安装的就行
英语lnherit global site-packages怎么翻译
Inherit global site-packages
英文翻译如下
继承全局站点包
我已经用pip安装了statsmodels 但是pycharm中找不到它，pycharm也无法安装
【Python】解决：Pycharm无法识别Python已安装的模块，如cv2（OpenCV）模块
20200319我安装的是selenium，python已经安装OpenCV模块cv2，但是Pycharm无法识别导入的cv2模块，解决办法如下：
Pycharm的菜单 File | Settings | Settings窗口 | Project:XXXX | Project Interpreter项 | 窗口右侧 齿轮按钮点击 | Show All… | 然后依据上图提示打开“Interpreter Paths”窗口
将已安装的Python路径下的 Lib/site-packages 这个路径添加到“Interpreter Paths”窗口项中，最后保存，即可解决上述问题。
我的路径是E:\Users\simon\AppData\Local\Programs\Python\Python37\Lib\site-packages
但是还是不能显示selenium模块。我参考了一下方法，点击右边的齿轮，再点击弹出的“Add…“，弹出一个对话框，看到，把BaseProjectInterpreter下面的inheritglobalsite-packages和makeavailabletoallprojects同时勾选，确定，才会显示python所有已安装的模块。
或者选择已经确定的python3.7，点击下面的existing environment。我的路径是E:\Users\simon\AppData\Local\Programs\Python\Python37。
升级Python导致pycharm找不到模块问题
问题的来龙去脉是这样的：
1）在Win7下，原来就安装了python3.6和pycharm。
2）今天，安装了python3.7.2。
3）在系统PATH增加了C:\Users\我的用户名\AppData\Local\Programs\Python\Python37，这样，就能再命令行中直接使用python命令了。
4）在系统PATH增加了C:\Users\我的用户名\AppData\Local\Programs\Python\Python37\Scripts，这样，就能再命令行中直接使用pip命令了。
5）在命令行中用pip install pyshp安装了pyshp。这样，就可以在代码中，使用import shapefile语句了。在命令行中执行成功。
6）打开pycharm，运行同样的程序，崩在import shapefile这一句，反馈No Module Named shapefile。
在网上找了一些参考，例如
1）pycharm=》File=》Settings…=》Project XXX=》ProjectIntepreter。看右边的ProjectInterpreter下拉框中，当前值还是Python3.6。
2）点击右边的齿轮，再点击弹出的“Add…“，弹出一个对话框，看到，把Base ProjectInterpreter下拉框中的值，改为Python3.7，注意，有一个Python3.7(Code)，那是个虚拟版，不要选它。
3）选中后，确定。然后，在窗口主体上，会刷新当前这个Python版本所安装的所有模块，可以看到，pyshp被列出来。如果上一步选错了，pyshp这一步会看不到。
4）上述动作，是把Python3.7作为解释器，加到系统Pycharm中。接下来，需要将Python3.7选为当前项目的解释器。
5）在Pycharm窗口右上角的下拉框中，选择Edit Configurations…，在弹出对话框中，把Python Interpreter选为Python 3.7（注意，不要选错为Python 3.7(code)）。
6）然后就可以再Pycharm中运代码，通过import shapefile了。