python 基础

python 基础


//==================================变量类型
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串


//-----------多个变量赋值
a = b = c = 1
a, b, c = 1, 2, "john"


//-----------删除单个或多个对象的引用
del var
del var_a, var_b

//-----------标准数据类型
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）


//-----------数字
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）


//-----------字符串
s = 'abcdef'

//-----------字符串访问
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串


//-----------连接运算符“+”
print str + "TEST"  # 输出连接的字符串


//-----------重复操作符“*”
print str * 2       # 输出字符串两次



//-----------列表
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]


//-----------列表访问
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素
print list[2:]           # 输出从第三个开始至列表末尾的所有元素



//-----------列表连接运算符“+”
print list + tinylist    # 打印组合的列表


//-----------重复操作
print tinylist * 2       # 输出列表两次



//-----------元组，元组不能二次赋值，相当于只读列表。
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )


//-----------元组访问与列表访问一样


//-----------字典(相当于MAP)，通过键来存取
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}


//-----------字典访问，通过键来存取
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值


//-----------数据类型转换
int(x [,base])将x转换为一个整数
long(x [,base] )将x转换为一个长整数
float(x)将x转换到一个浮点数
complex(real [,imag])创建一个复数
str(x)将对象 x 转换为字符串
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)将序列 s 转换为一个元组，#针对字典 会返回字典的key组成的tuple
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合，无序不重复元素集
dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符，在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
unichr(x)将一个整数转换为Unicode字符，chr()函数功能基本一样， 只不过是返回 unicode 的字符。
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串


(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
x & y         # 交集
x | y         # 并集
x - y         # 差集


dict(a='a', b='b', t='t')     # 传入关键字
dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典


unichr(97)
u'a'


//==================================运算符
//-----------算术运算符
+ 加 - 两个对象相加
- 减 - 得到负数或是一个数减去另一个数
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y
% 取模 - 返回除法的余数
** 幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果
//      取整除 - 返回商的整数部分（向下取整）

//-----------比较运算符
== 等于 - 比较对象是否相等
!= 不等于 - 比较两个对象是否不相等
<> 不等于 - 比较两个对象是否不相等这个运算符类似 != 。
> 大于 - 返回x是否大于y
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。
>= 大于等于 - 返回x是否大于等于y。
<= 小于等于 -返回x是否小于等于y。


//-----------赋值运算符
= 简单的赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符


//-----------位运算符
& 按位与运算符
| 按位或运算符
^ 按位异或运算符
~ 按位取反运算符
<< 左移动运算符
>> 右移动运算符



//-----------逻辑运算符
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。


//-----------成员运算符
in 如果在指定的序列中找到值返回 True，否则返回 False。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。

if ( a in list ):
if ( b not in list ):


//-----------身份运算符
is is 是判断两个标识符是不是引用自一个对象
is not is not 是判断两个标识符是不是引用自不同对象

if ( a is b ):
if ( a is not b ):




//==================================条件语句
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
else:
    执行语句4……


num = 5
if num == 3:            # 判断num的值
    print 'boss'       
elif num == 2:
    print 'user'
else:
    print 'roadman'     # 条件均不成立时输出


//==================================循环语句
//-----------While 循环语句
while (count < 9):
   print 'The count is:', count
   count = count + 1

//-----------循环使用 else 语句
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"


//-----------for 循环语句
for letter in 'Python':     # 第一个实例
   print '当前字母 :', letter

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print '当前水果 :', fruit

//-----------通过序列索引迭代
for index in range(len(fruits)):
   print '当前水果 :', fruits[index]


//-----------break 语句，continue 语句，与C，java一样


//-----------pass 语句
for letter in 'Python':
   if letter == 'h':
      pass
      print '这是 pass 块'
   print '当前字母 :', letter


//==================================数字
//-----------数学函数
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)x**y 运算后的值。
round(x [,n])返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根


//-----------随机数函数
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。



//-----------三角函数
acos(x) 返回x的反余弦弧度值。
asin(x) 返回x的反正弦弧度值。
atan(x) 返回x的反正切弧度值。
atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值。
cos(x) 返回x的弧度的余弦值。
hypot(x, y)返回欧几里德范数 sqrt(x*x + y*y)。
sin(x) 返回的x弧度的正弦值。
tan(x) 返回x弧度的正切值。
degrees(x)将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)将角度转换为弧度


//-----------数学常量
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。



//==================================字符串
//-----------字符串运算符
r/R 原始字符串 - 原始字符串：
>>>print r'\n'
\n


//-----------字符串格式化
与 C 中 sprintf 函数一样的语法
print "My name is %s and weight is %d kg!" % ('Zara', 21)

str.format()，它增强了字符串格式化的功能。



//-----------Unicode 字符串
>>> u'Hello\u0020World !'
u'Hello World !'


//-----------字符串内建函数
string.upper()转换 string 中的小写字母为大写
string.zfill(width)返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0


//==================================列表
//-----------内置函数

cmp(list1, list2)比较两个列表的元素

len(list)列表元素个数
max(list)返回列表元素最大值
min(list)返回列表元素最小值
list(seq)将元组转换为列表


list.append(obj)在列表末尾添加新的对象
list.count(obj)统计某个元素在列表中出现的次数
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)将对象插入列表、
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)移除列表中某个值的第一个匹配项
list.reverse()反向列表中元素
list.sort(cmp=None, key=None, reverse=False)对原列表进行排序


//==================================元组
//-----------元组内置函数
cmp(tuple1, tuple2)比较两个元组元素。
len(tuple)计算元组元素个数。
max(tuple)返回元组中元素最大值。
min(tuple)返回元组中元素最小值。
tuple(seq)将列表转换为元组。


//==================================字典
//-----------字典内置函数
cmp(dict1, dict2)比较两个字典元素。
len(dict)计算字典元素个数，即键的总数。
str(dict)输出字典可打印的字符串表示。
type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。



dict.clear()删除字典内所有元素
dict.copy()返回一个字典的浅复制
dict.fromkeys(seq[, val])创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
dict.has_key(key)如果键在字典dict里返回true，否则返回false
dict.items()以列表返回可遍历的(键, 值) 元组数组
dict.keys()以列表返回一个字典所有的键
dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)把字典dict2的键/值对更新到dict里，相当于加入(合并)
dict.values()以列表返回字典中的所有值
pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()随机返回并删除字典中的一对键和值。



//==================================日期和时间
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

//-----------获取当前时间戳
ticks = time.time()

当前时间戳为: 1459994552.51

//-----------struct_time元组
只要将浮点数传递给如localtime之类的函数
localtime = time.localtime(time.time())

 
time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

//-----------获取格式化的时间
获取可读的时间模式的函数是asctime()
localtime = time.asctime( time.localtime(time.time()) )

Thu Apr  7 10:05:21 2016

//-----------格式化日期
strftime 方法来格式化日期

# 格式化成2016-03-20 11:45:39形式
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

# 格式化成Sat Mar 28 22:24:24 2016形式
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())

# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))

//-----------获取某月日历
cal = calendar.month(2016, 1)

January 2016
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

time.sleep(secs) #推迟调用线程的运行，secs指秒数。


//==================================函数
# 语法
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]


# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print(str);
   return str;

# 调用函数
printme("我要调用用户自定义函数!");


//-----------参数传递
不可变对象:整数、字符串、元组
可变对象:列表，字典


//-----------必备参数

//-----------关键字参数
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print(str);
   return str;

#调用printme函数
printme( str = "My string");

关键字参数顺序不重要(即顺序不用对应)
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;

#调用printinfo函数
printinfo( age=50, name="miki" );


//-----------默认参数
def printinfo( name, age = 35 ):



//-----------不定长参数
加了星号（*）的变量名会存放所有未命名的变量参数

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return;

# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );

输出:
10
输出:
70
60
50

//-----------匿名函数
使用 lambda 来创建匿名函数

语法
lambda [arg1 [,arg2,.....argn]]:expression


# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )

相加后的值为 :  30

//==================================模块
模块(Module)，是一个 Python 文件，以 .py 结尾

//-----------模块的引入
import module1[, module2[,... moduleN]]

必须这样引用
模块名.函数名


//-----------from…import 语句
让你从模块中导入一个指定的部分到当前命名空间中

例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
from fib import fibonacci

//-----------把一个模块的所有内容全都导入到当前的命名空间也是可行的
from math import *


//-----------搜索路径
1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。


//-----------PYTHONPATH 变量
set PYTHONPATH=c:\python27\lib;

set PYTHONPATH=/usr/local/lib/python

//-----------dir()函数
一个排好序的字符串列表，内容是一个模块里定义过的名字。

在一个模块里定义的所有模块，变量和函数


//-----------globals() 和 locals() 函数
globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字

两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。


//-----------reload() 函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。

//-----------Python中的包
简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。

package_runoob/runoob1.py

def runoob1():
   print "I'm in runoob1"

package_runoob/runoob2.py

def runoob2():
   print "I'm in runoob2"

package_runoob/__init__.py

if __name__ == '__main__':
    print '作为主程序运行'
else:
    print 'package_runoob 初始化'

from package_runoob.runoob1 import runoob1
from package_runoob.runoob2 import runoob2
 
runoob1()
runoob2()

package_runoob 初始化
I'm in runoob1
I'm in runoob2

//==================================文件I/O
//-----------读取键盘输入
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：
str = raw_input("请输入：")


input 可以接收一个Python表达式作为输入，并将运算结果返回。

str = input("请输入：")

请输入：[x*5 for x in range(2,10,2)]
你输入的内容是:  [10, 20, 30, 40]

//-----------打开和关闭文件
//-----------open 函数
file object = open(file_name [, access_mode][, buffering])

file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。(+是可写，a指针到未尾，a、w有创建)
buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

//-----------close()方法
fileObject.close()

//-----------write()方法
write()方法不会在字符串的结尾添加换行符('\n')：
fileObject.write(string)

fo.write( "www.runoob.com!\nVery good site!\n")


//-----------File对象的属性
file.closed 返回true如果文件已被关闭，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

//-----------read()方法
fileObject.read([count])
被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

str = fo.read(10)

fileObject.readline(); #从文件读取整行

file.readlines([sizeint])
读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。

file.next()
返回文件下一行。

file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。


//-----------flush()方法
将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
fileObject.flush();


//-----------文件定位
tell()方法告诉你文件内的当前位置

position = fo.tell()

seek（offset [,from]）方法改变当前文件的位置。
Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

position = fo.seek(0, 0)
str = fo.read(10)


//-----------重命名和删除文件
os.rename(current_file_name, new_file_name)

os.rename( "test1.txt", "test2.txt" ) #重命名
os.remove(file_name) #删除文件


//-----------创建目录
mkdir()方法在当前目录下创建新的目录们
os.mkdir("newdir")

//-----------改变当前的目录
chdir()方法需要的一个参数是你想设成当前目录的目录名称。

os.chdir("/home/newdir")

//-----------删除目录
在删除这个目录之前，它的所有内容应该先被清除。

os.rmdir( "/tmp/test"  )


还有一些可以修改权限、拥有者等文件的属性修改和获取功能


//==================================异常处理
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
捕捉异常可以使用try/except语句。

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()


BaseException 所有异常的基类


使用except而不带任何异常类型,捕获所有发生的异常
try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码



//-----------try-finally 语句
无论是否发生异常都将执行最后的代码
try:
<语句>
finally:
<语句>    #退出try时总会执行

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

try:
    fh = open("testfile", "w")
    try:
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "关闭文件"
        fh.close()
except IOError:
    print "Error: 没有找到文件或读取文件失败"

//-----------触发异常
使用raise语句自己触发异常
raise [Exception [, args [, traceback]]]

def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行


try:
    正常逻辑
except Exception,err:
    触发自定义异常    
else:
    其余代码

//-----------用户自定义异常
基类为RuntimeError

class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg


try:
    raise Networkerror("Bad hostname")
except Networkerror,e:
    print e.args

//==================================内置函数
divmod() 返回一个包含商和余数的元组(a // b, a % b)
staticmethod 返回函数的静态方法。
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、FALSE 外都算 TRUE。
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。


//==================================面向对象
类(Class)
方法重写
继承
方法

//-----------创建类

class Employee:
   '所有员工的基类'
   empCount = 0 #类变量,所有实例之间共享
 
   def __init__(self, name, salary): #构造函数或初始化方法
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

self代表类的实例，而非类

//-----------创建实例对象
emp1 = Employee("Zara", 2000)

//-----------访问属性
emp1.displayEmployee()


//-----------添加，删除，修改类的属性
emp1.age = 7  # 添加一个 'age' 属性
emp1.age = 8  # 修改 'age' 属性
del emp1.age  # 删除 'age' 属性


//-----------可以使用以下函数的方式来访问属性
hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', # 添加属性 'age' 值为 8
delattr(emp1, 'age')    # 删除属性 'age'


//-----------内置类属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）


//-----------对象销毁(垃圾回收)
析构函数 __del__

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "销毁"

//-----------类的继承
class SubClassName (ParentClass1[, ParentClass2, ...]):


class Child(Parent): # 定义子类



//-----------重载方法
__init__ ( self [,args...] )
__cmp__ ( self, x )
__str__( self )
__del__( self )
__repr__( self )



//-----------运算符重载,使用（+-*/）的处理
def __add__(self,other):

__getitem__ 索引运算
__len__ 长度
__bool__ 布尔测试


//-----------类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。

__secretCount = 0  # 私有变量

//-----------类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。


//-----------单下划线、双下划线、头尾双下划线说明：
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。



//==================================正则表达式
//-----------match函数
从字符串的起始位置匹配一个模式(起始位置开始)

re.match(pattern, string, flags=0) #返回匹配对象
匹配成功re.match方法返回一个匹配的对象，否则返回None。

<_sre.SRE_Match object; span=(0, 3), match='www'>

re.match('www', 'www.runoob.com').span()#返回匹配对象中的索引元组

//-----------search函数
re.search 扫描整个字符串并返回第一个成功的匹配。

re.search(pattern, string, flags=0)


//-----------检索和替换
re.sub用于替换字符串中的匹配项。

re.sub(pattern, repl, string, count=0, flags=0)
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

//-----------re.compile 函数
编译正则表达式

re.compile(pattern[, flags])


//-----------findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

findall(string[, pos[, endpos]])
string : 待匹配的字符串。
pos : 可选参数，指定字符串的起始位置，默认为 0。
endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)

['123', '456']
['88', '12']

//-----------re.finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

it = re.finditer(r"\d+","12a32bc43jf3")
for match in it:
    print (match.group() )

12 
32 
43 
3

//-----------re.split
按照能够匹配的子串将字符串分割后返回列表
re.split(pattern, string[, maxsplit=0, flags=0])
pattern 匹配的正则表达式
string 要匹配的字符串。
maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

re.split('\W+', 'runoob, runoob, runoob.')


//-----------正则表达式修饰符 - 可选标志
re.I 使匹配对大小写不敏感
re.L 做本地化识别（locale-aware）匹配
re.M 多行匹配，影响 ^ 和 $
re.S 使 . 匹配包括换行在内的所有字符
re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。


//==================================多线程
使用线程有两种方式：函数或者用类来包装线程对象。

//-----------调用thread模块中的start_new_thread()函数来产生新线程
thread.start_new_thread ( function, args[, kwargs] )
function - 线程函数。
args - 传递给线程函数的参数,他必须是个tuple类型。
kwargs - 可选参数。


//-----------线程模块
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。


//-----------Thread类提供了以下方法:
run(): 用以表示线程活动的方法。
start():启动线程活动。
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。

class myThread (threading.Thread):   #继承父类threading.Thread
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数 
        print "Starting " + self.name
        print_time(self.name, self.counter, 5)
        print "Exiting " + self.name

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
 
# 开启线程
thread1.start()
thread2.start()

//==================================队列（ Queue）
队列都实现了锁原语，能够在多线程中直接使用。

Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空，返回True,反之False
Queue.full() 如果队列满了，返回True,反之False
Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列，timeout等待时间
Queue.get_nowait() 相当Queue.get(False)
Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item) 相当Queue.put(item, False)
Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join() 实际上意味着等到队列为空，再执行别的操作



//==================================JSON
json.dumps 将 Python 对象编码成 JSON 字符串
json.loads 将已编码的 JSON 字符串解码为 Python 对象

data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]
json = json.dumps(data)
print json
以上代码执行结果为：
[{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]

jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

text = json.loads(jsonData)
print text
以上代码执行结果为：
{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

//-----------Demjson
encode 将 Python 对象编码成 JSON 字符串
decode 将已编码的 JSON 字符串解码为 Python 对象

json = demjson.encode(data)
print json
以上代码执行结果为：
[{"a":1,"b":2,"c":3,"d":4,"e":5}]

json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
text = demjson.decode(json)
print  text
以上代码执行结果为：
{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

//==================================Python3 集合
//-----------集合
集合（set）是一个无序的不重复元素序列
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}
或者
set(value)

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

//-----------添加元素
s.add( x )

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )


//-----------移除元素
s.remove( x ) #如果元素不存在，则会发生错误。

还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )

随机删除集合中的一个元素
s.pop()

//-----------
len(s) #集合元素个数
s.clear() #清空集合
x in s #判断元素是否在集合中存在

//==================================Python3 列表推导式
提供了从序列创建列表的简单途径。

>>> [3*x for x in vec]
[6, 12, 18]

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']

>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

//-----------嵌套列表解析

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]