[TOC]
# Python 简介
---
* **Python 是一种解释型语言：** 这意味着开发过程中没有了编译这个环节。
* **Python 是交互式语言：** 这意味着，您可以在一个 Python 提示符 \>>> 后直接执行代码。
* **Python 是面向对象语言：** 这意味着 Python 支持面向对象的风格或代码封装在对象的编程技术。
# 基础语法
---
## 保留字
保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
```
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', '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 最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：
```
if True:
print('True')
else:
print('False')
```
## 多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\\)来实现多行语句，例如：
```
total = item_one + \
item_two + \
item_three
```
在 \[\], {}, 或 () 中的多行语句，不需要使用反斜杠(\\)，例如：
~~~
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
~~~
## 数字（Number）类型
python 中数字有四种类型：整数、布尔型、浮点数和复数。
* **int**(整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
* **bool**(布尔), 如 True。
* **float**(浮点数), 如 1.23、3E-2
* **complex**(复数), 如 1 + 2j、 1.1 + 2.2j
## 字符串（String）
* Python 中单引号和双引号使用完全相同。
* 使用三引号('''或""")可以指定一个多行字符串。
* 转义符 '\\'
* 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。。 如 r"this is a line with \\n" 则 \\n 会显示，并不是换行。
* 按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string。
* 字符串可以用 + 运算符连接在一起，用 \* 运算符重复。
* Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
* Python中的字符串不能改变。
* Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
* 字符串的截取的语法格式如下：变量\[头下标:尾下标:步长\]
~~~
str = 'Runoob'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出第一个字符
print(str[2:5]) # 输出第三个开始到第五个的字符
print(str[2:]) # 输出第三个开始后的所有字符
print(str * 2) # 输出字符串两次
print(str + 'hello') # 连接字符
print('--------------------------')
print('hello\nrunoob') # 特殊字符 \n
print(r'hello\nrunoob') # 在字符串前添加一个 r，表示原始字符串，不会发生转义
Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoobhello
--------------------------
hello
runoob
hello\nrunoob
~~~
## import 与 from...import
- 在 python 用`import`或者`from...import`来导入相应的模块。
- 将整个模块(somemodule)导入，格式为：`import somemodule`
- 从某个模块中导入某个函数,格式为：`from somemodule import somefunction`
- 从某个模块中导入多个函数,格式为：`from somemodule import firstfunc, secondfunc, thirdfunc`
- 将某个模块中的全部函数导入，格式为：`from somemodule import *`
~~~
# 导入 sys 模块
import sys
print('========Python import mode==========')
print('命令行参数为：')
for i in sys.argv:
print(i)
print('\n python 路径为', sys.path)
~~~
~~~
# 导入 sys 模块的 argv，path 成员
from sys import argv,path
print('path:', path) # 因为已经导入 path 成员，所以此处引用时不需要加 sys.path
~~~
# ？？？？
## Python 基础
### 数据类型和变量
**变量的声明与赋值**
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
Python 允许你同时为多个变量赋值。例如：
~~~
a = b = c = 1
~~~
以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
你也可以为多个对象指定多个变量。例如：
~~~
a, b, c = 1, 2, "runoob"
~~~
以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。
**标准数据类型**
Python3 中有六个标准的数据类型：
* Number（数字）
* String（字符串）
* List（列表）
* Tuple（元组）
* Set（集合）
* Dictionary（字典）
内置的 type() 函数和 instance() 函数可以用来查询变量所指的对象类型。
~~~
a, b, c, d = 20, 5.5, True, 4 + 3j
print(type(a), type(b), type(c), type(d))
print(isinstance(a, int))
// output
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
True
~~~
下面依次对这其进行介绍。
#### Number（数字）
*****
Python3 支持 **int、float、bool、complex（复数）**
在Python3 里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
~~~
a, b, c, d = 20, 5.5, True, 4 + 3j
print(type(a), type(b), type(c), type(d))
// output
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
~~~
数值运算：
~~~
>>>5 + 4 # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32
~~~
#### 字符串（String）
*****
* Python 中单引号和双引号使用完全相同。
* 使用三引号('''或""")可以指定一个多行字符串。
* 转义符 '\\'
* 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。。 如 r"this is a line with \\n" 则 \\n 会显示，并不是换行。
* 按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is string。
* 字符串可以用 + 运算符连接在一起，用 \* 运算符重复。
* Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
* Python中的字符串不能改变。
* Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
* 字符串的截取的语法格式如下：变量\[头下标:尾下标:步长\]
~~~
str = 'Runoob'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出第一个字符
print(str[2:5]) # 输出第三个开始到第五个的字符
print(str[2:]) # 输出第三个开始后的所有字符
print(str * 2) # 输出字符串两次
print(str + 'hello') # 连接字符
print('--------------------------')
print('hello\nrunoob') # 特殊字符 \n
print(r'hello\nrunoob') # 在字符串前添加一个 r，表示原始字符串，不会发生转义
Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoobhello
--------------------------
hello
runoob
hello\nrunoob
~~~
#### List（列表）
- List（列表） 是 Python 中使用最频繁的数据类型。
- 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
- 列表是写在方括号 \[\] 之间、用逗号分隔开的元素列表。
- 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
~~~
变量[头下标:尾下标]
~~~
加号`+`是列表连接运算符，星号`*`是重复操作。如下实例：
~~~
list = ['abcd', 786, 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']
print(list) # 输出完整列表
print(list[0]) # 输出列表第一个元素
print(list[1:3]) # 从第二个开始输出到第三个元素
print(list[2:]) # 输出从第三个元素开始的所有元素
print(tinylist * 2) # 输出两次列表
print(list + tinylist) # 连接列表
~~~
以上实例输出结果为：
~~~
'abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
~~~
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
#### Tuple（元组）
*****
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：
~~~
tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')
print(tuple) # 输出完整元组
print(tuple[0]) # 输出元组的第一个元素
print(tuple[1:3]) # 输出从第二个元素开始到第三个元素
print(tuple[2:]) # 输出从第三个元素开始的所有元素
print(tinytuple * 2) # 输出两次元组
print(tuple + tinytuple) # 连接元组
~~~
以上实例输出结果如下：
~~~
('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
~~~
#### Set（集合）
集合的基本功能是进行成员关系测试和删除重复元素。
可以使用大括号`{ }`或者`set()`函数创建集合，注意：创建一个空集合必须用`set()`而不是`{ }`，因为`{ }`是用来创建一个空字典。
~~~
# 成员测试
if 'Rose' in student:
print('Rose 在集合中')
else:
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
~~~
以上实例输出结果如下：
~~~
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
~~~
#### Dictionary（字典）
*****
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用{ }标识，它是一个无序的 **键(key) : 值(value)** 的集合。
键(key) 必须使用不可变类型，Python3 的六个标准数据类型中：
* 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
* 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
在同一个字典中，键(key)必须是唯一的。
~~~
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print(dict['one']) # 输出键为 'one' 的值： 1 - 菜鸟教程
print(dict[2]) # 输出键为 2 的 值： 2 - 菜鸟工具
print(tinydict) # 输出完整的字典： {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print(tinydict.keys()) # 输出所有的键： dict_keys(['name', 'code', 'site'])
print(tinydict.values()) # 输出所有的值： dict_values(['runoob', 1, 'www.runoob.com'])
~~~
## 条件语句和循环语句
### 条件语句
Python 中条件语句的一般格式如下：
~~~
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
~~~
注意：
* 1、每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块。
* 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
* 3、在Python中没有switch – case语句。
### 循环语句
Python 中的循环语句有 for 和 while。
以下实例使用了 while 来计算 1 到 100 的总和：
~~~
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n, sum))
~~~
在 while … else 在条件语句为 false 时执行 else 的语句块。
实例如下：
~~~
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
~~~
**for 语句**
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
实例如下：
~~~
languages = ['C', 'C++', 'Perl', 'Python']
for x in languages:
print(x)
C
C++
Perl
Python
~~~
**range() 函数**
如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:
~~~
for i in range(5):
print(i)
'''
0
1
2
3
4
'''
~~~
也可以使用 range 指定区间的值
~~~
for i in range(5, 9):
print(i)
'''
5
6
7
8
~~~
也可以使 range 以指定数字开始并指定不同的增量
~~~
for i in range(0, 10, 3):
print(i)
'''
0
3
6
9
'''
~~~
负数
~~~
for i in range(-10, -100, -30):
print(i)
'''
-10
-40
-70
'''
~~~
结合 range() 和 len() 函数以遍历一个序列的索引,如下所示:
~~~
a = ['Google', 'Baidu', 'Taobao', 'QQ']
for i in range(len(a)):
print(i, a[i])
'''
0 Google
1 Baidu
2 Taobao
3 QQ
'''
~~~
## 迭代器和生成器
## 函数
1、定义函数
使用`def`语句定义函数：
~~~
def my_abs(x):
if x >= 0:
return x
else:
return -x
print(my_abs(-99))
~~~
如果没有`return`语句，函数执行完毕后也会返回结果，只是结果为`None`。`return None`可以简写为`return`。
<span style="font-size: 18px;">返回多个值<span>
~~~
import math
def move (x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print(x, y)
151.96152422706632 70.0
# 返回多个值只是一种假象，返回值是一个 tuple
r = move(100, 100, 60, math.pi / 6)
print(r)
(151.96152422706632, 70.0)
~~~
2、调用函数
3、函数的参数
4、递归函数
