1. 词法分析
1.1 注释 （#）
注释使用 # 开头
1.2 编码声明
如果第1行或第2行的 注释 匹配 coding[=:]\s*([-\w.]+) ，则 认为是 编码声明 ，默许编码 为 UTF⑻
推荐编码声明方式 ：
# -*- coding: <encoding-name> -*-
1.3 显示的 行连接
当需要换行时 ， 可使用 反斜线 （
\）连接上下两行 ，且 反斜线后面不能添加注释
i.e
# -*- coding: UTF⑻ -*-
import sys
sys.stdout.write("hello 陈\
from Python %s\n" % (sys.version,))
1.4 隐式的行连接
特殊情况下 ， 如圆括号（( )），方括号（[ ]），或 大括号 （{ }）中的表达式可以分割成多个物理行而不需要反斜线。此种换行方式下可以添加注解
i.e
# -*- coding: UTF⑻ -*-
import sys
sys.stdout.write("hello 陈\
from Python %s\n" % (sys.version
,))
1.5 关键字
以下的标识符被用作保存字 ，或关键字 （注意大小写）：
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
2. 使用 python 解析器
打开 cmd ， 输入 py | python | python<version> ，便可打开 交互模式 。
i.e
$ python
Python 3.4.2 (v3.4.2:ab2c023a9432, Oct 6 2014, 22:15:05) [MSC v.1600 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> flag = True
>>> if flag:
... print("flag is true!") #注意缩进
...
flag is true!
>>>
交互式输入复合语句时，最后必须跟随1个空行来表示结束（由于解析器没法猜想你甚么时候已输入最后1行）
3. 简单介绍
3.1 作为计算器使用
3.1 数字
i.e
>>> 2+2
4
>>> 5/2
2.5
>>> 2**3
8
>>> 4+_ # 交互模式下，最后1个打印的表达式分配给变量_，即8分配给_
12
>>>
3.2 字符串
如果字符串中只有单引号而没有双引号，就用双引号援用，否则用单引号援用 。 print() 函数生成可读性更好的输出 。
i.e
>>> '"isn\'t",she said'
'"isn\'t",she said'
>>> print('"isn\'t",she said')
"isn't",she said
>>> print(r'"isn\'t",she said') # r 保持原始字符串输出
"isn\'t",she said
>>>
字符串拼接
i.e
>>> 'py' 'thon'
'python'
>>> prefix = 'py'
>>> prefix + 'thon'
'python'
>>>
字符串截取
i.e
>>> word = 'hello everyone'
>>> word[0]
'h'
>>> word[13]
'e'
>>> word[⑴] # 倒序从 ⑴ 开始
'e'
>>> word[⑵]
'n'
>>> word[0:4] # 包括头，不包括尾
'hell'
>>> word[0:5]
'hello'
>>> word[:5] #空代表从头开始
'hello'
>>> word[0:] #空代表1直到结尾
'hello everyone'
>>> word[:] # 显示所有字符
'hello everyone'
>>>
字符串（Python）切割示意图 ：
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
⑹ ⑸ ⑷ ⑶ ⑵ ⑴
Python 中的字符串是不能改变的 ，如果你尝试改变会报错 。
3.3 列表
中括号中的1列用逗号分隔的值。列表可以包括不同类型的元素，但是通常1个列表中的所有元素都具有相同的类型。
i.e
>>> words = [2,5,6,99]
>>> words
[2, 5, 6, 99]
>>> words[⑴]
99
>>> words + [111,222]
[2, 5, 6, 99, 111, 222]
>>> words.append(333) #添加新元素
>>> words
[2, 5, 6, 99, 333]
>>> words[2:3] = [555,666] # 给切片赋值
>>> words
[2, 5, 555, 666, 99, 333]
>>> len(words) # 列表长度
6
>>>
列表可嵌套，创建包括其他列表的列表
i.e
>>> a = [2,5,7]
>>> b = [3,6,8]
>>> c = [a,b]
>>> c
[[2, 5, 7], [3, 6, 8]]
>>> c[0]
[2, 5, 7]
>>> c[0][2]
7
>>>
输出斐波那契前几位
>>> #输出斐波那契前几位
... a,b = 0,1
>>> while b <10:
... print(b)
... a,b=b,a+b
...
1
1
2
3
5
8
>>>
调剂输出格式 ：
>>> #输出斐波那契前几位
... a,b = 0,1
>>> while b <10:
... print(b,end=',')
... a,b=b,a+b
...
1,1,2,3,5,8,>>>
4. 流程控制语句 ： if while for 等 属于 复合语句
4.1 if 语句用于条件履行 ：
if_stmt ::= "if" expression ":" suite
( "elif" expression ":" suite )*
["else" ":" suite]
i.e:
>>> x = int(input("enter an integer:"))
enter an integer:23
>>> if x <0:
... print('<0')
... elif x==0:
... print('=0')
... else:
... print('>0')
...
>0
>>>
4.2 while 语句用于重复履行只要表达式为 true
while_stmt ::= "while" expression ":" suite
["else" ":" suite]
4.3 for 语句用于循环集合
for_stmt ::= "for" target_list "in" expression_list ":" suite
["else" ":" suite]
i.e：
>>> animals = ['cat','bird','elephant']
>>> for animal in animals:
... print(animal,len(animal))
...
cat 3
bird 4
elephant 8
>>>
or
>>> for i in range(len(animals)):
... print(animals[i],len(animals[i]))
...
cat 3
bird 4
elephant 8
>>>
4.4 range() 函数用于遍历数字序列
生成数字序列：
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
>>>
从2 开始 ，到10 之前结束 ，步长为 2
>>> for i in range(2,10,2):
... print(i,end=',')
...
2,4,6,8,>>>
4.5
break continue
break : 跳出当前循环
i.e：
>>> for n in range(2,10):
... for m in range(2,n):
... if n%m == 0:
... print(n,'equals',m,'*',n//m)
... break
... else:
... print(n,'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
>>>
continue : 继续履行下1次循环
4.6 pass 甚么也不做
>>> while True:
... pass # 1直等待直得手动停止（ctrl+c）
...
创建最小的类
>>> class MyEmptyClass:
... pass
...
4.7 定义函数 （
def）
使用 def 定义1个函数，其后必须跟有函数名和以括号标明的情势参数列表。组成函数体的语句从下1行开始，且必须缩进
定义1个斐波那契函数：
>>> def fib(n):
... a,b=0,1
... while a<n:
... print(a,end=',')
... a,b=b,a+b
... print()
...
>>> fib(3000)
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,
>>>
函数名重命名
>>> fib
<function fib at 0x02E177C8>
>>> f = fib
>>> f(3000)
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,
>>>
不打印而保存在列表中返回
>>> def fibR(n):
... result = [] #用以保存数据
... a,b = 0,1
... while a<n:
... result.append(a)
... a,b=b,a+b
... return result
...
>>> f100 = fibR(100)
>>> f100
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>
4.7.1 默许参数值定义函数
在定义函数时，就已对参数进行了赋值
i.e:
>>> o = 5
>>> def aa(aa = o):
... print(aa)
...
>>> aa()
5
>>> o = 6
>>> aa()
5
>>>
但是这在默许值是列表、字典或大部份类的实例等易变的对象的时候又有所不同。例如，下面的函数在后续调用进程中会积累传给它的参数：
>>> def list(a,l=[]):
... l.append(a)
... return l
...
>>> print(list(1))
[1]
>>> print(list(2))
[1, 2]
>>> print(list(3))
[1, 2, 3]
>>>
如果不需要同享，可以以下写法：
>>> def f(a,l=None):
... if l is None:
... l=[]
... l.append(a)
... return l
...
>>> print(f(1))
[1]
>>> print(f(2))
[2]
>>>
4.7.2 关键字参数
参数：当调用函数时 ，1个值被传递给函数（或方法），这个值就叫做参数 。有两种类型的参数
★关键字参数（keyword argument） ：在函数调用中，通过标识符指定参数 ；或在 ** 后 通过字典传递参数
调用 complex() 函数：
complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})
★位置参数 （potional argument）： 以参数列表的情势出现 或 通过 * ，
complex(3, 5)
complex(*(3, 5))
在函数调用中，关键字参数必须跟随在位置参数的后面
5. 数据结构
5.1 更多关于 Lists
5.1.1 作为栈使用
5.1.2 作为队列使用
5.2 del 语句
移除 列表中某个元素 ，清空列表等。
5.3 Tuples(元组) 和序列
元组由逗号分割的若干值组成。元组是不可变的，元组是可嵌套的
>>> t = 12,43,'hello'
>>> t
(12, 43, 'hello')
>>> u = t,(2,5,'everyone')
>>> u
((12, 43, 'hello'), (2, 5, 'everyone'))
>>> t[0]
12
>>> t[0] = 666
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>
构造包括0个和1个元素的元组
>>> empty = () # 构造包括0个元素的元组
>>> len(empty)
0
>>> singleton = 'hello', #构造包括1个元素的元组
>>> len(singleton)
1
>>>
5.4 Sets( 集合) { }
特点 ：不会重复 ， 没有顺序 ，
可操作 ： 交集，并集 ，差
>>> basket = {'egg','apple','egg','orange'}
>>> basket
{'egg', 'orange', 'apple'}
>>> 'egg' in basket
True
>>> 'pear' in basket
False
>>> a = set('aabccd')
>>> b = set('bbcdde')
>>> a
{'a', 'b', 'c', 'd'}
>>> b
{'b', 'd', 'c', 'e'}
>>> a-b #在 a 中不在b 中
{'a'}
>>> a | b # 在 a中或在b中
{'b', 'a', 'e', 'd', 'c'}
>>> a & b # 既在a 中又在b 中
{'b', 'd', 'c'}
>>> a ^ b # 在 a中或 b中，去除同时包括的
{'a', 'e'}
>>>
5.5 字典
无序的键值对集合 ，键必须是唯1的
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
dict() 构造器根据键值对的序列创建字典
>>> dict([('liming',2343),('zhangsan',5632)])
{'zhangsan': 5632, 'liming': 2343}
>>>
还可以：
>>> dict(sape=4139, guido=4127, jack=4098)
{'jack': 4098, 'guido': 4127, 'sape': 4139}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>>
5.6 循环
循环 字典 的键 和 值 ，可使用 items() 方法
i.e
>>> tels = {'bob':4323,'jone':8732,'lili':1974}
>>> tels
{'jone': 8732, 'bob': 4323, 'lili': 1974}
>>> for k,v in tels.items():
... print(k,v)
...
jone 8732
bob 4323
lili 1974
>>>
循环序列 的 index 和 value，可使用 enumerate() 方法
i.e
>>> for i,v in enumerate([33,44,55]):
... print(i,v)
...
0 33
1 44
2 55
>>>
或 使用 range() 方法
>>> for i in range(len(ints)):
... print(i,ints[i])
...
0 33
1 44
2 55
>>>
循环序列的 value
i.e
>>> ints = [33,44,55]
>>> for v in ints:
... print(v)
...
33
44
55
>>>
循环 两个或两个以上的序列 ， 可使用 zip() 方法
i.e
>>> questions = ['name','color']
>>> answers = ['bob','blue']
>>> for q,a in zip(questions,answers):
... print('what is your {0}？ it is {1}'.format(q,a))
...
what is your name？ it is bob
what is your color？ it is blue
>>>
倒序循环序列 ，可使用 reversed() 方法
i.e
>>> for i in reversed([11,22,33]):
... print(i)
...
33
22
11
>>>
给序列排序后循环 ， 可使用 sorted() 方法
i.e
>>> for i in sorted([55,33,44]):
... print(i)
...
33
44
55
>>>
5.7 更多关于条件
in
not in
is
is not 仅仅针对可变对象，比如 lists ,比较运算符优先级低于数值运算符
a < b == c 级联比较 :a 小于 b 并且 b 等于c
and or 短路运算符
i.e 短路运算，并赋值
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance' # 分别给 3个变量赋值
>>> non_null = string1 or string2 or string3 # 短路运算， string1 or string2 不为空，不再继续运算，赋值给 non_n
ull
>>> non_null
'Trondheim'
>>>
Python 在表达式内部不能赋值