Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python标识符、字符串或串(String)是由数字、字母、下划线组成的一串字符。第一个字符必须是字母表中字母或下划线_。标识符对大小写敏感。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句。
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。如 r"this is a line with \n" 则\n会显示，并不是换行。
字符串的截取的语法格式如下：变量[头下标:尾下标:步长]。
与C字符串不同的是，Python字符串不能被改变。向一个索引位置赋值，比如word[0]='m'会导致错误。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
比如:
>>> s = 'abcdef'
>>> s[1:5]
'bcde'列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
元组不允许更新，而列表允许更新。
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号string、list 和 tuple 都属于sequence（序列）。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
可以使用大括号{ }或者set()函数创建集合,创建一个空集合必须用set()而不是{ }，因为{ }是用来创建一个空字典。
同时遍历两个或更多的序列，可以使用 zip() 组合。
is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， ==用于判断引用变量的值是否相等。
Python 提供了 for 循环和 while 循环（在 Python 中没有 do..while 循环）。
break语句：在语句块执行过程中终止循环，并且跳出整个循环
continue语句：在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass语句：pass是空语句，是为了保持程序结构的完整性。
在 python 中，while … else 在循环条件为 false 时执行 else 语句块：
#!/usr/bin/python
count = 0
while count < 2:
print count, " is less than 2"
count = count + 1
else:
print count, " is not less than 2"
'''
结果:
0 is less than 2
1 is less than 2
2 is not less than 2
'''pass是空语句，是为了保持程序结构的完整性。
pass不做任何事情，一般用做占位语句。
Python2中：pass一般用于占位置。
在Python中有时候会看到一个def函数:
def sample(n_samples):
pass该处的 pass 便是占据一个位置，因为如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。
在 Python3.x 的时候 pass 可以写或不写。
#python2.x：
def function():
# 空函数在Python2.x版本中pass是必须的
pass
#python3.x
def function():
# 在Python3.x的时候pass可以写或不写
Pass创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可，列表的数据项不需要具有相同的类型。
元组中只包含一个元素时，需要在元素后面添加逗号。
tup1 = (50,)元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割。
dict = {'a': 1, 'b': 2, 'b': '3'}不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住；键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。
在 python 中，类型属于对象，变量是没有类型的：
a=[1,2,3]
a="Runoob"以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
string, tuple,和number是不可更改的对象，而list,dict,set则是可以修改的对象。
不可变类型：变量赋值a=5后再赋值a=10，这里实际是新生成一个int值对象10，再让a指向它，而5被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值la=[1,2,3,4]后再赋值la[2]=5则是将list la的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。
可变类型：类似 c++ 的引用传递，如 列表，字典。
函数不定长参数：
(1).一种就是参数带一个星号*
def functionname([formal_args,] *var_args_tuple ):加了星号*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
(2).还有一种就是参数带两个星号**
def functionname([formal_args,] **var_args_dict ):加了两个星号**的参数会以字典的形式导入。
声明函数时，参数中星号*可以单独出现，如果单独出现星号*后的参数必须用关键字传入。例如：
def f(a,b,*,c):
return a+b+c
#f(1,2,c=3)python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。每个函数都有自己的命名空间。
Python open()方法用于打开一个文件，默认为文本模式，如果要以二进制模式打开，加上b。
使用except而不带任何异常类型：
try:
#正常的操作
#......................
except:
#发生异常，执行这块代码
#......................
else:
#如果没有异常执行这块代码
#使用except而带多种异常类型：
try:
#正常的操作
#......................
except(Exception1[, Exception2[,...ExceptionN]]]):
#发生以上多个异常中的一个，执行这块代码
#......................
else:
#如果没有异常执行这块代码
#try-finally语句（try-finally 语句无论是否发生异常都将执行最后的代码）：
try:
#<语句>
finally:
#<语句> #退出try时总会执行
raise__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。
self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
Python 使用了引用计数这一简单技术来跟踪和回收垃圾。在 Python 内部记录着所有使用中的对象各有多少引用。一个内部跟踪变量，称为一个引用计数器。当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（即未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。
类的继承：class 派生类名(基类名)，可以继承多个类。
class DerivedClassName(Base1, Base2, Base3):需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。
类的方法：在类的内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数。
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用self.__private_methods。
Python不允许实例化的类访问私有数据，但你可以使用object._className__attrName（对象名._类名__私有属性名）访问属性。
class Runoob:
__site = "www.runoob.com"
runoob = Runoob()
print runoob._Runoob__site单下划线、双下划线、头尾双下划线说明：
__foo__:定义的是特殊方法，一般是系统定义名字，类似__init__()之类。
_foo:以单下划线开头的表示的是protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于from module import *。
__foo:双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问。
事务机制可以确保数据一致性。事务4个属性：原子性、一致性、隔离性、持久性。
将整个模块(modulename)导入，格式为:
import modulename从某个模块中导入某个函数,格式为:
from modulename import functionname从某个模块中导入多个函数,格式为:
from modulename import func1, fun2, func3将某个模块中的全部函数导入，格式为:
from modulename import *在Python中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
在Python中，使用了yield的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
pickle.dump(obj, file, [,protocol])
x = pickle.load(file) #从file中读取一个字符串，并将它重构为原来的python对象。关键词with语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:
with open("myfile.txt") as f:
for line in f:
print(line, end="")以上这段代码执行完毕后，就算在处理过程中出问题了，文件f总是会关闭。
一般有三种命名空间：
- 内置名称（built-in names），Python语言内置的名称，比如函数名abs、char和异常名称BaseException、Exception等等。
- 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
- 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
四种作用域：
- L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
- E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A里面又包含了一个函数B，那么对于B中的名称来说A中的作用域就为nonlocal。
- G（Global）：当前脚本的最外层，比如当前模块的全局变量。
- B（Built-in）：包含了内建的变量/关键字等，最后被搜索。
规则顺序：L–> E–> G–> B。
在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
