Python pip 简介

本文地址

Python pip 简介

Python是荷兰计算机程序员Guido van Rossum(吉多·范罗苏姆，龟叔，1956年生)于1989年创立的一门解释型脚本语言，1991年初公布了第一个公开发行版。

Python 是大蟒蛇的意思。

特点、适合场景

特点

独特的语法：Python用缩进(而非常用的大括号或小括号)来区分语句关系，这给很多初学者带来了极其严重的困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中
简单：Python是一种代表简单主义思想的语言，它使你能够专注于解决问题而不是去搞明白语言本身
解释性
跨平台：可以运行在Windows、Mac和各种Linux/Unix系统上
丰富的库：Python有庞大的标准库以及许多其他高质量的库
脚本语言、胶水语言

适合场景

网络应用：包括网站、后台服务、网络爬虫等
人工智能、机器学习
科学计算和统计：MATLAB的大部分常用功能都可以在Python中找到相应的扩展库
日常需要的小工具：脚本任务、Python通常被称为胶水语言

缺点

运行速度慢：因为Python是解释型语言
- 假如运行 C 程序只需1秒，Java 需要2秒，则 Python 可能需要10秒
- 但是 Python 代码量少很多，假如 C 语言要写1000行，Java 只需100行，而 Python 可能只要20行
不能加密：编译型的语言不用发布源代码，只需要把编译后的机器码.exe或字节码.class发布出去，反推出C代码是不可能的(反推Java代码也没那么简单)；而解释型的语言，必须把源码发布出去

常用命令

参考

python 命令

python            # 进入 python 环境，进入后通过 exit() 命令退出
python --version  # 版本信息【-V】
python --help     # 帮助信息【-h】
python -m ensurepip # 安装 pip
python -m pip install --upgrade pip # 升级 pip【-U】
python -m pip uninstall pip # 卸载 pip

pip 命令

pip --version   # 版本信息【-V】
pip --help      # 帮助信息【-h】
pip install -h  # 显示指定命令的使用说明
pip list        # 列出已安装的包
pip list -o     # 查看可升级的包

pip search SomePackage             # 搜索包
pip show SomePackage               # 显示安装包信息
pip install SomePackage            # 最新版本
pip install SomePackage==1.0.4     # 指定版本
pip install 'SomePackage>=1.0.4'   # 最小版本
pip install --upgrade SomePackage  # 升级包，可通过使用== >= <= > < 指定版本
pip uninstall SomePackage          # 卸载包

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple SomePackage  # 临时使用镜像站
pip config get global.index-url    # 查看当前设置的镜像站，没设置时会报错
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple # 设置镜像站
pip config list --user  # 查看用户当前的设置

更改 pip install 默认安装路径

参考

查看配置文件 site.py 文件的位置：

python -m site -help
C:\soft\_dev\Python\Python310\lib\site.py [--user-base] [--user-site]

打开 site.py 文件，更改里面 USER_BASE (自定义的启用 Python 脚本) 和 USER_SITE (依赖安装包的基础路径)即可

# 默认值是 None
USER_SITE = None
USER_BASE = None

可以通过指令 python -m site 查看

# 默认值
USER_BASE: 'C:\\Users\\baiqi\\AppData\\Roaming\\Python' (doesn't exist)
USER_SITE: 'C:\\Users\\baiqi\\AppData\\Roaming\\Python\\Python310\\site-packages' (doesn't exist)

同时配置两个 python 版本

目前，Python 有两个版本，一个是2.x版，一个是3.x版，要注意这两个版本是 不兼容 的。

安装时注意手动勾上Add Python 3.8 to PATH

对于 Windows 环境，不论python2还是python3，python 可执行文件都叫python.exe，在 cmd 下输入python得到的版本号取决于环境变量 Path 里哪个版本的 Python 路径更靠前，因为 Windows 是按照顺序查找的。

方案一

1、将 Python2 和 Python3 都加入环境变量 Path 中

注意也要包括 \Python\Scripts\ 目录，因为pip.exe等命令在这个目录下

2、把原先的 python.exe 和 pythonw.exe 改名，比如 Python2 目录下的改成python2.exe和pythonw2.exe

个人建议不需要更改 python3，这样使用 python 时默认就是 python3

3、我们按照上述改名后如果使用 pip 会报错，解决方法是：分别在 python2 和/或 python3 下重新安装(升级)一下 pip

python2 -m pip install --upgrade pip
pip2 -V
pip3 -V

用哪个版本的 Python 运行安装脚本，pip 就被关联到哪个版本

方案二

借用py命令的一个参数来调用不同版本的Python：py -2调用python2，py -3调用的是python3

py -2 test.py
py -3 test.py

py -2 -m pip install xxx
py -3 -m pip install xxx

两个版本的区别

Python 2 和 Python 3 的区别非常多，这里仅仅选2个代表性的做一下记录。

1、编码的区别

Python2 的默认编码是ascii，有中文时必须在文件顶部写# coding=utf-8，Python 3 默认为 utf-8

import sys
print(sys.getdefaultencoding())

2、True 和 False 的区别

在 Python2 中，True 和 False 是两个全局变量的名字，在数值上分别对应 1 和 0，既然是变量，那么他们就可以指向其它对象，例如：

True = False
print(True) # False

而 Python3 上 True 和 False 变为两个关键字，永远指向两个固定的对象，不允许再被重新赋值，所以以上代码在 Python3 上会报错：SyntaxError: cannot assign to True

解决 pip 编码报错问题

如果执行 pip 命令时报UnicodeDecodeError: 'ascii' codec can't decode byte 0xb0 in position 7: ordinal not in range(128)，解决方法如下。

打开python2.7\Lib\目录下的mimetypes.py文件，在import下面添加如下几行代码：

if sys.getdefaultencoding() != 'gbk':
 reload(sys)
 sys.setdefaultencoding('gbk')

添加完成并保存，重新执行以上命令即可。

--------------------------- 最新解决方案 ---------------------------

python2 -m pip uninstall pip # 先卸载掉 pip
python2 -m ensurepip # 再重新安装
python2 -m pip install --upgrade pip # 或者升级
pip2 install six # 然后就可以愉快的使用了

--------------------------- 最新解决方案 ---------------------------

在自己电脑上使用 Systrace 时又遇到了这个问题
百度谷歌了一个晚上
始终没有解决
后来突然想到，有没有可能是本机账户有中文的问题？
于是创建了一个新的Window账户
果然可以了！

两种运行模式

Python 交互式模式

在命令行模式下，可以执行python命令进入 Python 交互式环境

在 Python 交互式模式下，可以直接输入代码，然后执行，并立刻得到结果
Python 交互式环境会把每一行 Python 代码的结果自动打印出来

命令行模式

在命令行模式下，可以直接运行一个.py文件

Python 杂谈

人生苦短，我用 Python

在 Python 开发领域流传着这样一句话：人生苦短，我用Python，这句话出自Bruce Eckel，原文是：Life is short，you need Python。使用过Python语言的程序员，或者从别的语言转换到Python开发的程序员或许对这句话的理解更加深刻。

但是人生苦短，我用 Python这句话是Python之父Guido van Rossum穿的t恤上印的话。

Python 的设计哲学

Python 的设计哲学是:Beautiful优雅、Explicit明确、Simple简单

The Zen of Python, by Tim Peters
Python 的设计哲学，作者：Tim Peters

Beautiful is better than ugly.
优雅胜于丑陋。
Explicit is better than implicit.
明确胜于含糊。
Simple is better than complex.
简单胜于复杂。
Complex is better than complicated.
复杂胜于繁琐。
Flat is better than nested.
扁平胜于嵌套。
Sparse is better than dense.
间隔胜于紧凑。

Readability counts.
可读性很重要。
Special cases aren’t special enough to break the rules.
即使假借特殊之名，也不应打破这些原则。
Although practicality beats purity.
尽管实践大于理论。
Errors should never pass silently.
错误不可置之不理。
Unless explicitly silenced.
除非另有明确要求。

In the face of ambiguity, refuse the temptation to guess.
面对模棱两可，拒绝猜测。
There should be one– and preferably only one –obvious way to do it.
用一种方法，最好是只有一种方法来做一件事。
Although that way may not be obvious at first unless you’re Dutch.
虽然这种方式开始时并不容易，除非你是 Python 之父。
Now is better than never.
但从现在就开始这么做，总比永远都不做好。
Although never is often better than right now.
尽管经常有时 “没有做” 反倒比 “现在立马做“ 结果要好。

If the implementation is hard to explain, it’s a bad idea.
如果一个实现不容易解释，那么它肯定是个坏主意。
If the implementation is easy to explain, it may be a good idea.
如果一个实现很容易解释，那么它也许是个好主意。
Namespaces are one honking great idea – let’s do more of those!
就像命名空间就是一个绝妙的想法，应当多加利用。

可变对象与不可变对象

我们知道，str是不变对象，而list是可变对象。

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

a = ['c', 'b', 'a']
a.sort()
print(a)  # ['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

a = 'abc'
a.replace('a', 'A')
print(a)  # abc

虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'，应该怎么理解呢？

我们先把代码改成下面这样：

a = 'abc'
b = a.replace('a', 'A')
print(a, b)  # abc Abc

要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指：a本身是一个变量，它指向的对象的内容才是'abc'：

┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：

┌───┐                  ┌───────┐
│ a │─────────────────>│ 'abc' │
└───┘                  └───────┘
┌───┐                  ┌───────┐
│ b │─────────────────>│ 'Abc' │
└───┘                  └───────┘

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

变量在内存中的表示

当我们写：

a = 'ABC'

时，Python解释器干了两件事情：

在内存中创建了一个'ABC'的字符串
在内存中创建了一个名为a的变量，并把它指向'ABC'

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：

a = 'ABC'
b = a
a = 'XYZ'
print(b)

最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'？

让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行a = 'ABC'：解释器创建了字符串ABC和变量a，并把a指向ABC

执行b = a：解释器创建了变量b，并把b指向a指向的字符串ABC

执行a = 'XYZ'：解释器创建了字符串'XYZ'，并把a的指向改为XYZ，但b并没有更改，所以，最后打印变量b的结果自然是ABC了

核心逻辑：代码b = a 不是将 b 指向了 a，而是 a 指向的内容(内存地址，堆内存地址)

如果是 Java，上述解释也是适用的，但是 Java 也有一些特殊之处

String a = "ABC";
String b = a;
a = "XYZ";
System.out.println(b); //ABC

int a2 = 1;
int b2 = a2;
a2 = 2;
System.out.println(b2); //1

Date a3 = new Date(1);
Date b3 = a3;
a3 = new Date(a3.getTime());
a3.setTime(2);
System.out.println(a3.getTime() + "," + b3.getTime()); //2,1

Date a4 = new Date(1);
Date b4 = a4;
a4.setTime(2);
System.out.println(a4.getTime() + "," + b4.getTime()); //2,2

字典 dict 的实现原理

Python内置了字典dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值存储，具有极快的查找速度。

举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]

给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。

如果用dict实现，只需要一个name-score的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael']

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢
需要占用大量的内存，内存浪费多

而list相反：

查找和插入的时间随着元素的增加而增加
占用空间小，浪费内存很少

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是 dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。

2020-05-13

posted @ 2020-05-13 00:23 白乾涛阅读(420) 评论(1) 编辑收藏举报

刷新页面返回顶部

白乾涛

个人站点(baiqiantao.github.io) 我的GitHub(github.com/baiqiantao)

Python pip 简介

目录

Python pip 简介

特点、适合场景

常用命令

python 命令

pip 命令

更改 pip install 默认安装路径

同时配置两个 python 版本

方案一

方案二

两个版本的区别

解决 pip 编码报错问题

两种运行模式

Python 杂谈

人生苦短，我用 Python

Python 的设计哲学

可变对象与不可变对象

变量在内存中的表示

字典 dict 的实现原理

公告