Python虚拟环境有什么用,conda创建python虚拟环境

这篇文章主要介绍了Python虚拟环境未解析的引用，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下。

Python语言特点及环境变量配置

Python语言特点：

1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单快码论文。

2.易于阅读：Python代码定义的更清晰。

3.易于维护：Python的成功在于它的源代码是相当容易维护的。

4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。

5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。

6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。

7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。

8.数据库：Python提供所有主要的商业数据库的接口。

9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。

10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

下载地址：

懒人模式，安装提示里勾选上自动配置环境变量，pip等，安装完成后，你连环境变量都不用配置了。

但是学习的人还是要谦虚一点，配环境变量也是基本功。

“” 所在的文件夹C:\Python\Python36-32加入的环境变量的Path下面就好了

配置完成后cmd终端里检查一下，如下图没有保错，说明配置正确。

对缩进要求严格，四个空格，不建议用Tab，不同平台上缩进不一样

要输出中文在开头写上 # -\*- coding: utf-8 -\*-  

我使用的IDE为Pycharm，注释为ctrl + /

官方文档

中文文档

一张图概况Python学习（转自W3Cschool）

目录：

Python基础语法：

（1）打印出hello world

（2）注释

（3）数据类型

（4）运算

（5）输入

（6）输出

（7）序列

（8）相等比较

（9）选择

（10）循环

（11）字典(dict)

（12）集合(set)（不常用）

（14）pass,del,exec,eval

（15）内建函数

Python进阶语法：

（1）文件

（2）错误和异常

（3）模块和包

（4）作用域

（5）高阶函数

（6）装饰器

（7）参数

（8）面向对象

（9）定制类（魔术方法）

（10）日期和时间

（11）数学与随机数

（12）正则表达式

Python基础语法：

（1）打印出hello world

\# -\*- coding: utf-8 -\*-  
print "hello world"  
print "你好 世界"  

（2）注释

1、（单行注释）以 # 开头，后面的文字直到行尾都算注释

2、（多行注释）多行注释是用三引号’‘’ ‘’'包含的（单引号和双引号均可）

3、（中文注释）要注释中文必须程序开头先写上# -*- coding: utf-8 -*-，不然会报错

（3）数据类型

1、变量不需要声明，可以直接输入，大小写敏感

2、这里的var = xxxx不叫变量赋值，而叫变量绑定，一个符号可以绑定任意类型的值。

3、内置函数type(), 用以查询变量的类型

var = 1  
print var #1  
print type(var) #整数类型 # <type 'int'>  
var = 1.1  
print var # 1.1  
print type(var) #浮点数类型 # <type 'float'>  
var = 'hello'  
print var # hello  
print type(var) #字符串 # <type 'str'>  
var = (1==1)   
print var # True  
print type(var) #布尔型 # <type 'bool'>  
var = None  
print var # None  
print type(var) #空值 # <type 'NoneType'>  
var = 1+1j 或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型  
print var # (1+1j)  
print type(var) #复数类型 # <type 'complex'>  

4、字符串以’'或" "括起来的任意文本

5、布尔型（True, False，可以用and, or, not运算，而不是C语言的&&和||）

6、多变量赋值

a = b = c = 1  
a, b, c = 1, 2, "john" #等号两边都是元组，建议加上括号，增加可读性  
x,y = y,x #两值交换，不需要temp,更加简洁  

7、赋值语句不可以返回值，对象是通过引用传递的

y = (x = x + 1) #这是非法的  

（4）运算

1、加、减、乘、除、求余、乘方

2、乘方 ** 右结合

2\*\*3=8   
2\*\*2\*\*3=256  
（2\*\*2）\*\*3=64  

3、整数运算结果仍然是整数，浮点数运算结果仍然是浮点数。

但是整数和浮点数混合运算的结果就变成浮点数了。

4、字符串与整数相乘

print 'abc' \* 3 结果 abcabcabc  

5、因为Python把0、空字符串’'和None看成 False，其他数值和非空字符串都看成 True

True and ‘a=T’ 计算结果是 ‘a=T’

继续计算 ‘a=T’ or ‘a=F’ 计算结果还是 ‘a=T’

要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

①在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

②在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

6、不支持自加(i++)和自减(i–)

7、地板除（//）除法不管操作数何种数值类型，总是舍去小数部分，返回数字序列中比真正的商小的最接近的数字。

print 5//3 #1  
print 1.0//2.0 #0.0  
print -1/2 #-1  

（5）输入

x = input() #1+2  
print type(x) #<type 'int'>  
y = raw\_input() #1+2  
print type(y) # <type 'str'>  

1、由此可见, input() 在对待纯数字输入返回所输入的数字的类型（int，float）

而raw_input() 将所有输入作为字符串看待，返回字符串类型。

为了避免类型发生错误，一般情况下使用 raw_input() 来与用户交互。

（6）输出

1、Python2 里面print可以直接接字符串或者运算。

2、Python3 里面print变成了一个函数，上面的写法不支持了，必须用一个括号括起来，否则会报告语法错误。

3、>>>是Python解释器的提示符，不是代码的一部分。

4、print语句也可以跟上多个字符串，用逗号“,”隔开，遇到逗号“,”会输出一个空格：

print '1+2=',1+2 #1+2= 3  

5、多行输出使用三个引号和使用换行符\n一致

print '''哈  
哈  
哈'''  
print "哈\\n哈\\n哈"  
\# 输出结果  
\# 哈  
\# 哈  
\# 哈  
\# 哈  
\# 哈  
\# 哈  

6、转义

print r'C:\\'  
print 'C:\\\\'  
\# C:\\  
\# C:\\  

7、print 语句与字符串格式运算符( % )结合使用，可实现字符串替换功能

print "%s is number %d!" % ("Python", 1)  

%s表示由一个字符串来替换，%d表示由一个整数来替换，%f表示由一个浮点数来替换。

Python 非常灵活，即使将数字传递给 %s，也不会像其他要求严格的语言一样引发严重后果。

（7）序列

1、序列有两种：list (可变列表) 和tuple（不可变元组）

2、定义:序列是一组有顺序的元素的集合,可以包含一个或多个元素，也可以没有任何元素。

list = \[0,1,2,3,4,5\] #列表用中括号，可改变，理解为数组  
tuple = (0,1,2,3,4,5) #元祖用小括号，不可改变  

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型

2、序列的通用操作

seq = "0123456789"  
print seq\[0\] #序列元素的下标从0开始。注意不要越界  
print seq\[-1\] #倒序索引，-1代表倒数第一。  
print seq\[1:5\] #支持切片操作，seq\[start:end\]，start包含在结果中，end不包含在结果中。  
print range(1,101)\[0:10\]#从第1个数元素开始取，到第11元素结束  
print seq\[7:\] #seq\[start:end\]中的end可以省略。  
print seq\[-3:\] #分片也支持负数。  
print seq\[:3\] #seq\[start:end\]中的start也可以省略。  
print seq\[:\] #全部省略会复制整个序列。  
print seq\[::2\] #支持步长。  
print seq\[::-1\] #逆序输出。  
print seq\[9:1:-1\] #支持负步长。  
print range(1,101)\[2::3\]#从第三元素开始取，每隔2个取一个元素，即3的倍数  
print range(1,101)\[4:50:5\]#从第五个取，每隔4个取一个，50以内5的倍数   
print \[1, 2, 3\] + \[4, 5, 6\] # 序列支持相加，这解释了为啥字符串可以相加。  
print \[1, 2, 3\] \* 3 #序列支持相乘，这解释了为啥字符串可以相称。  
print \[None\] \* 10 #生成一个空序列。  
print 1 in \[1, 2, 3\] #成员判断。  
print range(1,101)\[4::5\]\[-10:\] #切片可以嵌套，最后10个5的倍数，先获得5的倍数再取后10个  

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

3、可变的列表(list)

list = \[0,1,2,3,4,5\]  
list.append(7) #append()总是把新元素添加到list的尾部  
print list # \[0, 1, 2, 3, 4, 5, 7\]  
list.insert(0,-1) #insert()接受两个参数，第一个是索引，第二个是元素  
print list # \[-1, 0, 1, 2, 3, 4, 5, 7\]  
list.insert(-1,6) #insert(-1)是最后一个元素之前，即倒数第二个元素，因为insert()前插  
print list # \[-1, 0, 1, 2, 3, 4, 5, 6, 7\]  
() #pop()方法总是删掉最后一个元素  
print list # \[-1, 0, 1, 2, 3, 4, 5, 6\]  
(0) #参数为索引  
print list # \[0, 1, 2, 3, 4, 5, 6\]  
list\[6\]=7 #对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素  
print list # \[0, 1, 2, 3, 4, 5, 7\]  
list\[0\],list\[-1\]=list\[-1\],list\[0\] #第一与最后位置调换  
print list # \[7, 1, 2, 3, 4, 5, 0\]  

在使用可变对象的方法如 sort(),extend()和 reverse()的时候要注意,这些操作会在列表

中原地执行操作,也就是说现有的列表内容会被改变,但是没有返回值!

4、不可变的元组（tuple）

字符串是一种特殊的元组

没有 append()方法，也没有insert()和pop()方法，也不能赋值

Tuple 比 list 操作速度快.如果您定义了一个值的常量集,并且唯一要用它做的是不断地遍历它,请使用 tuple 代替 list.如月份，星期。

print (1,) #一个元素的元祖。

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义。

可变的元组：tuple的元素指向list，而list内的值可变

5、序列解包

x, y, z = 1, 2, 3  
print x, y, z  
(x, y, z) = (1, 2, 3)  
print x, y, z  
(x, y, z) = \[1, 2, 3\]  
print x, y, z  

（8）相等比较

#== 和 is的差别，==比较的是值，is比较的是引用。  
x = \[1, 2, 3\]  
y = x  
z = \[1, 2, 3\]  
print(x == y) #True  
print(x == z) #True  
print(x is y) #True  
print(x is z) #False  

（9）选择

1、Python代码的缩进规则。具有相同缩进的代码被视为代码块

2、缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格

3、格式

if 条件1:  
 statement  
elif 条件2:  
 statement  
elif 条件3：  
 statement  
else:  
 statement  

If后面不需要括号，但是条件后面需要冒号

elif 即 else if

4、三元运算符

x, y = 4, 3  
if x < y:  
 result = x  
else:  
 result = y  
print result  
#等价于  
result = x if x < y else y  
print result  

（10）循环

1、for循环依次把list或tuple的每个元素迭代出来

格式

for 元素 in 序列:   
 statement  

name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）

L = \['Adam', 'Lisa', 'Bart'\]  
for name in L:  
 print name  

这样一来，遍历一个list或tuple就非常容易了。

2、while循环，不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。

while 条件:  
 statement  

3、中断循环 break和continue

4、range()的用法

range(1,5) #代表从1到5(不包含5) \[1, 2, 3, 4\]  
range(1,5,2) #代表从1到5，间隔2(不包含5) \[1, 3\]  
range(5) #代表从0到5(不包含5) \[0, 1, 2, 3, 4\]  

5、Python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。使用enumerate() 函数拿到索引

L = \['Adam', 'Lisa', 'Bart', 'Paul'\]  
for index, name in enumerate(L):  
 print index, '-', name  
#结果  
\# 0 - Adam  
\# 1 - Lisa  
\# 2 - Bart  
\# 3 - Paul  

使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是，这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把：

[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]

变成了类似：

[(0, ‘Adam’), (1, ‘Lisa’), (2, ‘Bart’), (3, ‘Paul’)]

因此，迭代的每一个元素实际上是一个tuple：

6、好用的zip()方法

for x, y in zip(range(1, 10), range(1, 10)):  
 print(x, y)  
\# 结果  
\# (1, 1)  
\# (2, 2)  
\# (3, 3)  
\# (4, 4)  
\# (5, 5)  
\# (6, 6)  
\# (7, 7)  
\# (8, 8)  
\# (9, 9)  

7、列表生成式，非常简洁

要生成[1x1, 2x2, 3x3, …, 10x10]

print \[x \* x for x in range(1, 11)\]  
#\[1, 4, 9, 16, 25, 36, 49, 64, 81, 100\]  

列表生成式的 for 循环后面还可以加上 if 判断。例如：

print \[x \* x for x in range(1, 11) if x % 2 == 0\]  
\# \[4, 16, 36, 64, 100\]  

8、迭代器

它为类序列对象提供了一个类序列的接口。

迭代非序列集合(例如映射和文件)时, 可以创建更简洁可读的代码。

myTuple = (123, 'xyz', 45.67)  
i = iter(myTuple)  
print i.next() #123  
print i.next() #xyz  
print i.next() #45.67  
i.next() #报错  

（11）字典(dict)

1、字典的元素没有顺序。你不能通过下标引用元素。字典是通过键来引用，用大括号

查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

dict的缺点是占用内存大，还会浪费很多内容

dict是按 key 查找，所以，在一个dict中，key不能重复

作为 key 的元素必须不可变

2、已知两个列表，一个是名字，一个是成绩，要根据名字找到对应的成绩用两个list不方便，如果把名字和分数关联起来，组成类似的查找表，即 Python中的dict

用 dict 表示“名字”-“成绩”的查找表如下：

dic = {'tom':11, 'sam':57,'lily':100}  
print type(dic) #<type 'dict'>  
d = {  
 'Adam': 95,  
 'Lisa': 85,  
 'Bart': 59  
}  
print d #{'Lisa': 85, 'Adam': 95, 'Bart': 59}  

3、我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。

4、花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

5、由于dict也是集合，len()函数可以计算任意集合的大小：

print len(d) #运算结果为3

一个 key-value 算一个，因此，dict大小为3。

6、可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

print d\['Adam'\] #95  

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

print d.get('Bart') #59  
print d.get('Paul') #None  

7、在字典中增添一个新元素的方法：

d = {  
 'Adam': 95,  
 'Lisa': 85,  
 'Bart': 59  
}  
print d #{'Lisa': 85, 'Adam': 95, 'Bart': 59}  
d\['lilei'\] = 99  
print d #{'lilei': 99, 'Lisa': 85, 'Adam': 95, 'Bart': 59}  

8、循环调用

for key in d: #或for key in d.keys()  
 print d\[key\]  
\# 结果  
\# 99  
\# 85  
\# 95  
\# 59