Python 官网：https://www.python.org/
Python官方中文文档：https://docs.python.org/zh-cn/3/tutorial/index.html
Python编程网文档：http://c.biancheng.net/python/
第一个Python3.x程序
代码：
#!/usr/bin/python3 print("Hello, World!")
运行：将以上代码保存在 hello.py 文件中并使用 python 命令执行该脚本文件
$ python3 hello.py
Python3简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
-
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
-
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
-
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
-
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
Python3环境搭建
1.下载安装 https://www.python.org/downloads/
unix/linux为例：
# tar -zxvf Python-3.6.1.tgz # cd Python-3.6.1 # ./configure # make && make install
2.环境变量配置
windows安装
Python包管理Anaconda
下载地址：https://www.anaconda.com/download/
什么是Anaconda？
Anaconda包括Conda、Python以及一大堆安装好的工具包，比如：numpy、pandas等等180多个科学包及其依赖项。
Miniconda包括Conda、Python (推荐使用Miniconda，下载地址：https://conda.io/en/latest/miniconda.html)。
Anaconda 的下载文件比较大（约 531 MB），如果只需要某些包，或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）
conda是一个开源的包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖，并能够在不同的环境之间切换
提高安装速度，添加镜像：
$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ $ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ $ conda config --set show_channel_urls yes
然后可在user/yangyongjie/.condarc中看到镜像配置
1 channels: 2 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ 3 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ 4 - defaults 5 show_channel_urls: true
conda安装包
conda install numpy
创建虚拟环境：
conda create -n myenv python
Conda、pip及virtualenv区别：
conda可同时管理python的包及环境；
pip只能管理包；
virtualenv只能管理环境
第一个Python3.x项目
注意：
1）每个项目创建一个虚拟环境
2）在项目的虚拟环境下安装requirement.txt的依赖包：pip install -r xxx/requirement.txt
3）安装whl：pip install xxx/xxx.whl
1、Python基础语法
命名规范
| 类型 | 公有/外部成员 | 私有/内部成员 |
| 模块（module,python文件） | my_naming_convention | __my_naming_convention |
| 包（package） | my_naming_convention | |
| 类（class） | MyNamingConvention | __MyNamingConvention |
| 异常（Exception） | MyNamingConvention | |
| 函数（function） | my_naming_convention() | __my_naming_convention() |
| 全局/类常量（constant） | MY_NAMING_CONVENTION | __MY_NAMING_CONVENTION |
| 全局/类变量（variable） | my_naming_convention | __my_naming_convention |
标识符
第一个字符必须是字母表中字母或下划线 _
标识符的其他的部分由字母、数字和下划线组成
标识符对大小写敏感
保留字（关键字）
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
注释
单行注释 #
多行注释：''' 或 """
行与缩进
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句
同一行显示多条语句
Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割
多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之为代码组。
像if、while、def和class这样的符合语句，首行以关键字开始，以冒号(:)结束，该行之后的一行或多行代码构成代码组。
数字（Number）类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
bool (布尔), 如 True、False
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j
类型转换：int(x) 将x转换为一个整数，与Java略有不同，Java是将类型放在括号里
字符串（String）
python中单引号和双引号使用完全相同。
使用三引号(''' 或 """)可以指定一个多行字符串。
转义符 \
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
Python中的字符串不能改变。
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
import 与 from...import
在 python 用 import 或者 from...import 来导入相应的模块
2、Python基本数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。Python 是属于“动态类型语言”的编程语言，所谓动态，是指变量的类型是根据情况自动决定的
等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值
Python中的type() 函数可以用来查看数据类型
1）标准数据类型
如：a = 111
Python3中有6个标准的数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元祖）、Set（集合）、Dictionary（字典）
不可变数据类型Number（数字）、String（字符串）、Tuple（元祖）
可变数据类型：List（列表）、Set（集合）、Dictionary（字典）
2）Number（数字）
Python3 支持 int、float、bool、complex（复数）
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型，isinstance()函数用来判断变量是不是某种类型
isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型
注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型
注意：
1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4、在混合计算时，Python会把整型转换成为浮点数
3）String（字符串）
如：str = 'Runoob'
Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
字符串的截取的语法格式如下：变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误
注意：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变
3）List（列表）
如：list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是列表连接运算符，星号 * 是重复操作
与Python字符串不一样的是，列表中的元素是可以改变的
注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的
4）Tuple（元祖，一组数）
如：tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。其实，可以把字符串看作一种特殊的元组
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
string、list 和 tuple 都属于 sequence（序列）。
注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接
5）Set（集合，类似于Java中Set）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
集合（set）是一个无序的不重复元素序列
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
语法：
parame = {value01,value02,...}
或者
set(value)
如：sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
6）Dictionary（字典，类似于Java中Map）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的
如：tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。
3、运算符
算术运算符、比较运算符、赋值运算符和Java类似。
需要注意：Python没有三目运算符，替换方案：
# if else 语句 if a>b: max = a; else: max = b; # python提供的类似三目运算符的简洁写法 exp1 if contion else exp2 #如：max = a if a>b else b #嵌套 a if a>b else ( c if c>d else d )
1）逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
2）成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
3）身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
注： id() 函数用于获取对象内存地址。
4、其他语法
1）条件控制
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
注意：
1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch – case语句
2）循环语句
Python 中的循环语句有 for 和 while
①：for循环
Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串
for <variable> in <sequence>:
<statements>
else:
<statements>
②：while循环
while 判断条件(condition)：
执行语句(statements)……
同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环
3）迭代器和生成器
①：迭代器
迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器
#!/usr/bin/python3 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 for x in it: print (x, end=" ")
②：生成器
在 Python 中，使用了 yield 的函数被称为生成器（generator）
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象
4）函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率
def 函数名（参数列表）: 函数体
函数定义时不必指定参数类型，加了一个星号 * 的参数会以元组(tuple)的形式导入，加了两个星号 ** 的参数会以字典的形式导入
默认情况下，函数值和参数名称是按函数声明中定义的顺序匹配起来的。
①：参数传递：
在python中，类型属于对象，变量是没有类型的
如： a=[1,2,3]; a="yang"
[1,2,3]是list类型，"yang"是String类型，而变量a是没有类型，它仅仅是一个对象的引用（一个指针），可以指向List类型对象，也可以指向String类型对象。
可更改与不可更改对象：
在python中，strings，tuples和numbers是不可更改的对象，而list，dict等则是可以修改的对象
不可变类型：变量赋值a=5后再赋值a=10，这里实际是新生成一个int值对象10，再让a指向它，而5被丢弃
可变类型：变量b=[1,2,3,4]后，再赋值b[2]=5，则是将list b的第三个元素值更改，本身b没有动，只是其内部的一部分值被修改了。
python的参数传递：
不可变类型：类似C++的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象
可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(b)，则是将 b 的引用传过去，修改后 fun 外部的 b 也会受影响
②：参数类型
（1）：必需参数
必需参数需以正确的顺序传入函数，调用时的数量必须和声明时的一样
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return # 调用 printme 函数，不加参数会报错 printme()
（2）：关键字参数
关键字参数和函数调用关系紧密，函数调用使用参数名称来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str) return #调用printme函数 printme( str = "123")
（3）：默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
#!/usr/bin/python3 #可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数 printinfo( age=50, name="123" ) print ("------------------------") printinfo( name="123" )
（4）：不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。在函数声明时参数不会命名，基本语法如下：
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量
还有一种就是参数带两个星号 **基本语法如下：
def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression]
加了两个星号 ** 的参数会以字典的形式导入
（5）：main函数
if __name__ == '__main__': print(123)
5）模块
python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。
为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。
模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
import语句
想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：
import module1[, module2[,... moduleN]
别名：import module as alias
from … import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中
如，导入模块fibo的fib函数：from fibo import fib
5、命名空间和作用域
命名空间：
命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。
命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响
一般有三种命名空间：
内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
命名空间查找顺序：假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。
命名空间的生命周期：命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束
作用域：
作用域就是一个 Python 程序可以直接访问命名空间的正文区域
全局变量和局部变量：
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内部声明的变量名称都将被加入到作用域中。
#!/usr/bin/python3 total = 0 # 这是一个全局变量 # 可写函数说明 def sum( arg1, arg2 ): #返回2个参数的和." total = arg1 + arg2 # total在这里是局部变量. print ("函数内是局部变量 : ", total) return total
global和nonlocal关键字：
当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了
#!/usr/bin/python3 num = 1 def fun1(): global num # 需要使用 global 关键字声明 num = 123 print(num)
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
#!/usr/bin/python3 def outer(): num = 10 def inner(): nonlocal num # nonlocal关键字声明 num = 100 print(num) inner() print(num)
6、python3多线程
Python3 线程中常用的两个模块为：
- _thread
- threading(推荐使用)
thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用"thread" 模块。为了兼容性，Python3 将 thread 重命名为 "_thread"
Python中使用线程有两种方式：函数或者用类来包装线程对象。
1）函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:
_thread.start_new_thread ( function, args[, kwargs] )
参数说明:
- function - 线程函数。
- args - 传递给线程函数的参数,他必须是个tuple类型。
- kwargs - 可选参数。
2）线程模块 threading
Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。
_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。
threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：
- threading.currentThread(): 返回当前的线程变量。
- threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
- threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
- run(): 用以表示线程活动的方法。
- start():启动线程活动。
- join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
- isAlive(): 返回线程是否活动的。
- getName(): 返回线程名。
- setName(): 设置线程名。
import threading class myThread(threading.Thread): def __init__(self, thread_name): threading.Thread.__init__(self) self.setName(thread_name) def run(self): print(self.getName()) t1 = myThread('thread-1') t2 = myThread('thread-2') t1.start() t2.start()
学习心得
import requests # post请求，Content-Type=application/x-www-form-urlencoded # msg为字典类型 res = requests.post(req_url, data=data) # post请求，Content-Type=application/json res = requests.post(req_url, json=data) # 添加headers headers = { "xxx": "xxx" } requests.post(req_url, json=data, headers=headers)
生成requirements.txt： pip freeze > requirements.txt
END.