Python语言一

最近天气转冷，又到了靠一身正气过冬的日子，同时这段时间开始了Python语言的学习。下面是Python的基本语法和说明，包含数据类型、运算符、条件语句、循环、函数、模块、时间、日历、IO、File、异常、封装、继承、正则表达式、多线程等，希望对正在Python学习路上的小伙伴有帮助，也欢迎留言一起探讨。

• 数据类型:

counter = 100   # 整型
miles = 100.0   # 浮点型
str1 = "hello"  # 字符串
print counter   # 打印100
print miles     # 打印100.0
print str1      # 打印hello

• 字符串:
  从左到右索引默认 0 开始，从右到左索引默认 -1 开始.

str2 = "hello"
str3 = "world"
print str2 + " " + str3     # 字符串拼接
print str2[0]               # 打印h
print str2[0:5]             # 打印hello, 从左到右索引截取, 最大范围是字符串长度少1, 索引从0开始, 截取范围包含头索引, 不包含尾索引

• List(列表):
  用[]标识.

strList1 = ["aa", "bb", "cc", "dd"]
strList2 = ["ee", "ff"]
print strList1 + strList2               # 打印['aa', 'bb', 'cc', 'dd', 'ee', 'ff']
print strList1[0]                       # 打印aa
print strList1[0:2]                     # 打印['aa', 'bb']
print strList1[-2]                      # 获取列表倒数第二个索引的元素

strList2.append("gg")                   # 在列表末尾添加元素
print strList2                          # 打印['ee', 'ff', 'gg']

del strList2[len(strList2) -1]          # 删除列表最后一个元素
print strList2                          # 打印['ee', 'ff']

strlistTemp = strList1[1:]              # 从索引1开始到末尾的索引截取列表, 返回新的列表
print strlistTemp                       # 打印['bb', 'cc', 'dd']

print strList1.count("aa")              # 统计某个元素在列表中出现的次数, 打印1
print strList1.index("cc")              # 获取元素在列表中第一次出现的索引, 打印2

strList1.insert(1, "aaa")               # 在指定的索引位置插入元素,
print strList1                          # 打印['aa', 'aaa', 'bb', 'cc', 'dd']

strList1.remove("aaa")                  # 删除列表中指定的元素
print strList1                          # 打印['aa', 'bb', 'cc', 'dd']

print strList1.pop(len(strList1) -2)    # 移除列表中指定索引的元素, 返回这个移出的元素值

intList = [0, -2, 10, 5]
intList.sort()                          # 对列表排序, 默认是升序排序
print intList
intList.sort(reverse=True)              # 对列表降序排序
print intList
intList.sort(reverse=False)             # 对列表升序排序
print intList

strTupleList = tuple(strList1)          # 将列表转换为元组, 返回转换的元组
print strTupleList                      # 打印('aa', 'bb', 'dd')

• 元组:
  与列表类似，不同之处在于元组的元素不能修改.

strTuple1 = ("aa", "bb", "cc", "dd")
strTuple2 = ("ee", "ff")
print strTuple1 + strTuple2     # 打印['aa', 'bb', 'cc', 'dd', 'ee', 'ff']
print strTuple1[0]              # 打印aa
print strTuple1[0:2]            # 打印['aa', 'bb']
print list(strTuple1)           # 将元组转换成列表

• 字典:
  可存储任意类型对象, 但键必须是不可变的, 整个字典元素包括在{}括号,以键值对的形式存储, 元素的键与值用:号隔开, 每个元素之间用,号隔开,不允许同一个键出现两, 如果同一个键被赋值两次，前面的值会被覆盖.

dict = {"name": "zhangsan", "age": 18, "isMan": True}
print len(dict)         # 获取字典键的长度, 打印3
print dict              # 打印{'isMan': True, 'age': 18, 'name': 'zhangsan'}
print dict["name"]      # 通过键获取值, 打印zhangsan

dict["name"] = "lisi"   # 修改键的值
print dict              # 打印{'isMan': True, 'age': 18, 'name': 'lisi'}

del dict["isMan"]       # 删除元素
print dict              # 打印{'age': 18, 'name': 'lisi'}
print type(dict)        # 获取对象的类型, 字典返回, 元组返回, list返回

• 数据类型转换:

str4 = "105"
i = 10
print str4 + str(i)     # 将整型转换成字符串类型, 打印10510
print int(str4) + i     # 将字符串转换成整型, 打印115
print list(str4)        # 将字符串转换成list. ['1', '0', '5']
print chr(49)           # 将整型转换成字符, 返回值是当前整数对应的ascii字符, 打印1
print unichr(97)        # 将一个整数转换为Unicode字符, 打印a

• 运算符:

print 20 + 5    # 打印25
print 20 - 5    # 打印15
print 20 * 5    # 打印100
print 20 / 4    # 打印5
print 21 % 5    # 取模, 返回除法的余数, 打印1
print 16 // 5   # 取整除 - 返回商的整数部分（向下取整）, 打印3

• 比较运算符:

i = 10
x = 100
print i == x    # 等于 - 比较对象是否相等, 打印False
print i != x    # 不等于 - 比较两个对象是否不相等, 打印True
print i <> x    # 不等于 - 比较两个对象是否不相等符类似 !=, 打印True
print x > i     # 大于, 打印True
print x >= i    # 大于, 打印True
print x <= i    # 大于, , 打印False

• 赋值运算符:

a = 10
a += 1
print a # 打印11
b = 20
b -= 1
print b # 打印19
c = 2
c *= 5
print c # 打印10
d = 10
d /= 5
print d # 打印2

• 成员运算符:

# in, not in
a = 1
b = 10
list = [1, 2, 3, 4, 5]
print a in list         # 序列中是否包含指定的元素, list中是否包含a, 打印True
print a not in list     # 序列中是否不包含指定的元素, list中是否不包含a, 打印False

# is, is not, is与==的区别,类似equals与==
s1 = "s"
s2 = "s"
print s1 is s2      # 判断两个标识符是不是引用自一个对象, 类似x.equals(y), 打印True
print s1 is not s2  # 判断两个标识符是不是引用自不同的对象, 类似!x.equals(y), 打印False

# and, or, not
b1 = False
b2 = True
print b1 or b2      # 布尔"或", 左右条件有一个为True, 就返回True, 否则返回False
print b1 and b2     # 布尔"与", 左右条件有一个为False, 就返回False, 否则返回true
print not b1        # 布尔"非", 取反
print b1 is False   # 打印True
print b1 is True    # 打印Flase

• 条件语句:

b3 = False
s3 = "hello"
if b3 is not True:  # 判断是否为False
    print b3
else:
    print s3

# 多条件判断
num = 3
print num < 0 or num > 1        # 打印True
print num >= 0 and num <= 5     # 打印True

# if条件语句
i = 5
s = ""
if i >= 0 and i <= 5:
    s = "i >= 0 and i <= 5"
elif  i < 0 or i > 5:
    s = "i < 0 or i > 5"
else:
    s = str(i)
print s

# 一个条件的, 可以写在一行
if (i >= 0 and i <= 5) : print "i:" + str(i)

• for循环:

for letter in "python":             # 遍历字符串, 给letter赋值, 依次把p,y,t,h,o,n赋值给letter变量
    print "当前字母:" + letter

for letter in ["aa", "bb", "cc"]:   # 遍历list, 给letter赋值, 依次把list的元素赋值给letter变量
    print "当前字母:" + letter

fruitList = ["aa", "bb", "cc"]
length = len(fruitList)             # 获取list的长度
print "listLength:" + str(length)
for index in range(length):         # 通过索引遍历集合,range()是判断条件
    print fruitList[index]

# for循环嵌套
for x in range(1, 10):                  # 遍历0~10之间的数据(123456789),依次将1,2,3,4,5,6,7,8,9赋值给x变量
    for y in range(1, x + 1):           # 遍历0~x+1之间的数据,依次将x+1的数据赋值给y变量
        if x % 2 == 0 or y % 2 == 0:    # 过滤偶数结果
            continue                    # 结束当前内层循环, 进行下一轮外层循环
        elif x == 9:                    # 跳出整个内外循环体
            break                       # 过滤x为9的结果
        else:
            print str(y) + "x" + str(x) + "=" + str(y * x) + "\t",  # \t是制表符类似Tab键
    print ""

• while循环与嵌套:

x = 1
while(x < 10):
    y = 1
    while(y <= x):
        print str(y) + "x" + str(x) + "=" + str(y * x) + "\t",  # \t是制表符类似Tab键
        y += 1
    x += 1
    print ""

• 运算函数:

print abs(-5)              # 返回数字的绝对值，打印5
print cmp(0, 1)            # 比较2个对象, 如果xy返回1, 0<1, 打印-1
print max(-5, 10, 0, 3)    # 返回给定参数的最大值, 打印10
print min(-5, 10, 0, 3)    # 返回给定参数的最小值, 打印-5
print round(-80.23456, 3)  # 返回浮点数x的四舍五入值, 参数2是小数点后面保留的位数, 打印-80.235
print round(80.23456, 3)   # 返回浮点数x的四舍五入值, 参数2是小数点后面保留的位数, 打印80.235

• math模块:
  浮点数的运算函数.

import math	# 需要导入的模块
print math.floor(-45.17)   # 返回数字的下舍整数, 打印-46.0
print math.floor(0)        # 返回数字的下舍整数, 打印0.0
print math.floor(0.3)      # 返回数字的下舍整数, 打印0.0
print math.floor(0.5)      # 返回数字的下舍整数, 打印0.0
print math.floor(10)       # 返回数字的下舍整数, 打印10.0
print math.floor(100.12)   # 返回数字的下舍整数, 打印100.0
print math.floor(100.92)   # 返回数字的下舍整数, 打印100.0
print math.floor(119L)     # 返回数字的下舍整数, 打印119.0
print math.ceil(-45.17)    # 返回数字的上入整数, 打印-45.0
print math.ceil(0)         # 返回数字的上入整数, 打印0.0
print math.ceil(0.3)       # 返回数字的上入整数, 打印1.0
print math.ceil(0.5)       # 返回数字的上入整数, 打印1.0
print math.ceil(10)        # 返回数字的上入整数, 打印10.0
print math.ceil(100.12)    # 返回数字的上入整数, 打印101.0
print math.ceil(100.92)    # 返回数字的上入整数, 打印101.0
print math.ceil(119L)      # 返回数字的上入整数, 打印119.0
print math.log(10)         # 返回x的自然对数, 10的自然对数, 打印2.30258509299
print math.log10(10)       # 返回底数为10的对数, 10底数为10的自然是, 打印1.0
print math.modf(100.72)    # 返回x的整数部分与小数部分, 打印(0.7199999999999989, 100.0)
print math.modf(100)       # 返回x的整数部分与小数部分, 打印(0.0, 100.0)
print math.pow(2, 3)       # 返回x的y次方的值, 2的3次方, 打印8.0
print math.sqrt(100)       # 返回x的平方根, 打印10.0
print math.sqrt(4)         # 返回x的平方根, 打印2.0

print str(math.asin(-1))        # 返回x的正余弦弧度值, 范围是-1 <= x <= 1, 超过会报错, 打印-1.57079632679
print str(math.asin(0))         # 返回x的正余弦弧度值, 打印0.0
print str(math.asin(0.5))       # 返回x的正余弦弧度值, 打印0.523598775598
print str(math.asin(1))         # 返回x的正余弦弧度值, 打印1.57079632679
print str(math.acos(-1))        # 返回x的反余弦弧度值, 范围是-1 <= x <= 1, 超过会报错, 打印3.14159265359
print str(math.acos(0))         # 返回x的反余弦弧度值, 打印1.57079632679
print str(math.acos(0.5))       # 返回x的反余弦弧度值, 打印1.0471975512
print str(math.acos(1))         # 返回x的反余弦弧度值, 打印0.0

• 随机数函数:

import random
print random.random()                  # 在0~1范围, 随机生成一个数, 小数点后面最多保留12位
print random.uniform(5, 10)            # 在x,y范围类,包含x, 不包含y, 随机生成一个数, 小数点后面最多保留11位
print random.choice([1, 2, 3, 5, 9])   # 从列表中返回一个随机数
print random.choice((1, 2, 3, 5, 9))   # 从元组中返回一个随机数
print random.choice("helloworld")      # 从字符串中返回一个随机数
print random.randrange(100, 105)       # 返回指定范围集合中的一个随机数, 返回100 <= number < 105随机数
print random.randrange(100, 110, 2)    # 返回指定递增基数集合中的一个随机数, 返回100 <= number < 110的偶数
print random.randrange(100, 110, 3)    # 返回指定递增基数集合中的一个随机数, 递增基数为3, 打印100, 103, 106, 109这几个数

isSeed = False
if isSeed:
    random.seed(10)         # 生成同一个随机数, 调用了这个函数, 随机数后面生成的都是同一个函数
print random.random()

list = [1, 2, 3, 5, 9]
random.shuffle(list)    # 随机排列列表
print list

• 日期和时间:
  自从1970年1月1日午夜（历元）开始经过了多长时间来表示.

import time
print time.time()                                           # 获取当前时间戳的毫秒数
print time.asctime(time.localtime())                        # 获取当前时间, 默认格式星期 月份 日期 时间 年份,如:Tue Dec 11 18:39:19 2018
# 格式化当前时间,
# %y 两位数的年份表示（00-99）
# %Y 四位数的年份表示（000-9999）
# %m 月份（01-12）
# %d 月内中的一天（0-31）
# %H 24小时制小时数（0-23）
# %I 12小时制小时数（01-12）
# %M 分钟数（00=59）
# %S 秒（00-59）
# %a 本地简化星期名称
# %A 本地完整星期名称
# %b 本地简化的月份名称
# %B 本地完整的月份名称
# %c 本地相应的日期表示和时间表示
# %j 年内的一天（001-366）
# %p 本地A.M.或P.M.的等价符
# %U 一年中的星期数（00-53）星期天为星期的开始
# %w 星期（0-6），星期天为星期的开始
# %W 一年中的星期数（00-53）星期一为星期的开始
# %x 本地相应的日期表示
# %X 本地相应的时间表示
# %Z 当前时区的名称
print time.strftime("%Y-%m-%d %A %H:%M:%S", time.localtime())  # 打印年-月-日 时:分:秒, 如:2018-12-11 18:44:36
# 将当前时间转换成时间戳, 参数2的格式需要与获取的默认格式一致,
print time.mktime(time.strptime(time.asctime(time.localtime()), "%a %b %d %H:%M:%S %Y"))

• 日历:

import calendar
print calendar.month(2018, 12)  # 获取2018年12月的日历

import datetime
print datetime.datetime.now()   # 获取当前日期和时间,格式年-月-日 时:分:秒, 如:2018-12-12 10:15:36.871000

• 自定义函数:
  格式def 函数名称(参数)冒号, 以def关键字开头 后接函数函数名称 圆括号 冒号, 参数放在圆括号中,函数内容以冒号开始, 并且缩进.
  return用于结束函数, 并返回一个值给调用者, 不带reture的函数相当于返回了None给调用者.
  参数分两种:
  不可变参数(函数内对参数做修改, 函数外的对象无变化):整数/字符串/元组;
  可变参数:列表/字典(函数内对参数做修改, 函数外的对象同步修改);

def function1():                            # 定义一个名称为function1 无参数 无返回值的函数
    print "function1"
    return
def function2(name):                        # 定义一个名称为function2 有参数 有返回值的函数
    print "function2"
    return name
def function3(strList):
    print "function3"
    strList.append("python")
    return
def function4(name, age):                   # 定义一个有多个参数的函数, 传参顺序无约束, 参数对象赋值就行
    print "function4, name:" + name \
          + ", age:" + str(age)
    return
def function5(name, age, gender="male"):    # 定义一个有默认参数的函数, 调用时没传默认的参数, 则使用默认的值
    print "function5, name:" + name \
          + ", age:" + str(age) \
          + ", gender:" + gender
    return
def function6(*ages):                       # 定义一个有不定长参数的函数(参数用*修饰), 调用时可根据需求, 不定长度传递参数的个数
    for age in ages:
        print "function6, age:" + str(age)
    return

function1()                         # 调用名称为function1的

print function2(name="zhangsan")    # 调用名称为function2的函数, 并打印返回值

strList = ["hello", "world"]        # 函数传参的可变参数
print strList                       # 调用可变参数的函数前的列表, 打印['hello', 'world']
function3(strList)                  # 调用名称为function3的可变参数函数
print strList                       # 调用可变参数的函数后的列表, 打印['hello', 'world', 'python']

function4(age=18, name="zhangsan")

function5("lisi", 19)

function6(10)
function6(11, 12)

• 变量, 全局变量(定义在函数外的变量, 可以在整个程序范围内访问)和局部变量(定义在函数内的变量, 只能在函数内部访问),如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

total = 1   # 全局变量
def calcFunction(age1, age2):
    sum = age1 + age2
    print "calcFunction, sum:" + str(sum)
    global total   # global, 在函数内给全局变量赋值，必须使用global语句修饰全局变量,否则会报错,
                   # 因为python会在局部命名空间找这个变量, 而局部并没有定义这个变量, 所以会报错
                   # 用global修饰, 是明确声明, 变量是全局变量, 这样就不会在局部命名空间内去找这个变量了
    total += sum   # 函数内给全局变量赋值
    return

calcFunction(2, 3)
print total   # 打印6

• 模块(Module):
  是一个Python文件，以.py结尾，包含了Python对象定义和Python语句, 类似java的class类

# 导入同级包下的其他模块
import SupportModule1  # import导入模块, 导入同级包下的SupportModule1模块
SupportModule1.supportFunction1()   # 通过模块名调用其他模块里的函数, 调用SupportModule1模块的函数supportFunction1函数

from SupportModule1 import *        # 通过from ModuleName import *导入一个模块中所以的部分, 导入同级包下SupportModule1模块的所有内容
supportFunction1()                  # 调用SupportModule1模块中的supportFunction1函数

# 导入其他包中的模块, 创建一个新包,包里面必须包含__init__.py文件(用于标识文件夹是一个包),文件内容可以为空
from modulepackage.SupportModule2 import *  # 导入modulepackage包下SupportModule2模块的所有类容
supportFunction2()                          # 调用SupportModule2模块的supportFunction2函数

def getLocals():
    print locals()  # 在函数内部调用locals()，返回的是所有能在该函数里访问的命名
    return
def getGlobals():
    print globals() # 在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。
    return
getLocals()
getGlobals()

# os模块, os模块提供了执行文件处理操作的方法,如重命名和删除文件等
import os
try:
    os.rename("foo.txt", "newFoo.txt")  # os.rename重命名文件, 需要导入os模块,
                                        # 将文件foo.txt重命名为newFoo.txt
    os.remove("newFoo.txt")             # 删除文件
except:
    print "except"

path = os.getcwd()                  # 获取当前的工作目录
print "path:" + path
os.mkdir("file")                    # 在当前目录创建一个新目录file
os.rmdir("file")                    # 删除file目录

• IO, 读取键盘输入内容:

# 输入字符串
print "你输入的内容是:" + raw_input("请输入内容,并按Enter键结束:")   # raw_input函数,从标准输入读取一个行,
                                                                   # 并返回输入的字符串(去掉结尾的换行符),如:输入10/2,返回10/2
# 输入表达式
print "你输入的内容是:" + str(input("请输入内容,并按Enter键结束:"))  # input函数,从标准输入读取一个行,不可以接收中英文字符,
                                                                   # 可以接收表达式,并将运算结果返回,如:输入10/2,返回结果5,输入adfasf会运行报错

• IO, File文件操作:
  打开文件, file object = open(file_name, access_mode, buffering)
  参数1:文件名称;
  参数2:文件的模式:只读/写入/追加等;
  参数3:寄存区的缓冲大小, -1:默认缓冲大小, 0:没有缓冲; 1:缓冲行; 大于1的整数:缓冲的实际大小;

fo1 = open("foo.txt", "w")      # 打开foo.txt文件, 并设为写入模式, 如果找不到文件,就在当前模块的同级包下生成文件
print "文件名:", fo1.name                       # 打印foo.txt
print "文件的访问模式:", fo1.mode               # 打印w
print "文件是否已关闭:", fo1.closed             # 打印True
print "文件末尾是否强制加空格:", fo1.softspace  # 打印0

# file方法
fo1.write("helloworld\nhelloworldhelloworld")         # 向文件写入字符串,\n表示换行
fo1.flush()                     # 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件
fo1.close()                     # 刷新缓冲区任何还没写入的信息,并关闭该文件

fo2 = open("foo.txt", "r+")     # 打开foo.txt文件,并设为只读模式
readStr1 = fo2.read()           # 读取文件
print "readStr1:" + readStr1

position = fo2.tell()           # 查找当前读取文件的指针位置
print "position:" + str(position)

if fo2.tell() > 0:
    fo2.seek(0, 0)              # 将读取的指针定位到文件开头
readStr2 = fo2.read()
print "readStr2:" + readStr2

if fo2.tell() > 0:
    fo2.seek(0, 0)
readStr3 = fo2.read(5)          # 从文件读取指定的字节数,读取5个字节
print "readStr3:" + readStr3

if fo2.tell() > 0:
    fo2.seek(0, 0)
readStr4 = fo2.readline()       # 读取整行,包括\n字符
print "readStr4:" + readStr4

fo2.close()

• 异常:

try:
    fo3 = open("foo.txt", "r")
    fo3.write("this is test file for testing exceptions")
except IOError:     # except可以带异常类型, 也可以不带异常类型,
    print "IOError"
# except:			# 不建议使用不带异常类型的except
#     print "Error"
else:               # 只有没发生异常才执行
    print "write complete"
    if fo3.closed is False:
        fo3.flush()
        fo3.close()
finally:            # 无论是否发生异常都将执行
    print "finally"
    if fo3.closed is False:
        print "close"
        fo3.flush()
        fo3.close()

• 类的封装:
  用class创建一个类, class后为类的名称并以冒号结尾

class NameClass:
    mName = ""
    mAge = 0
    # 类的构造函数/或者类的初始化方法, 当创建了这个类就会调用这里函数
    # self表示类的实例,类中所有方法必须有self,调用方法时不必传入
    def __init__(self, name, age):
        self.mName = name
        self.mAge = age
    def getName(self):
        return self.mName
    def getAge(self):
        return self.mAge

# 创建类的实例
nameClass = NameClass("zhangsan", 18)
# 通过类对象调用类中的方法
name = nameClass.getName()
age = nameClass.getAge()
print name
print age

• 对象销毁(垃圾回收):
  Python使用了引用计数技术来跟踪和回收垃圾(用计数器记录对象有多少引用).
  当对象被创建了, 就创建了一个引用计数器,
  当对象不再需要时(对象的引用计数变为0时),由解释器在适当的时机,将垃圾对象进行回收

print id(nameClass)     # 打印对象的id
del nameClass           # 删除nameClass对象

• 继承, private, protected:
  如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法;
  在调用父类的方法时，需要加上父类的类名前缀，且需要带上self参数变量调用顺序,先在子类中找, 然后在父类中找.

class ParentClassA:  # 创建父类A
    parentName = "zhangsan"                 # 公开的全局变量
    def __init__(self):                 # 函数名前后都用两个下划线修饰, 表示系统定义的函数
        print "ParentClassA, __init__"
    def _getName(self):                 # 函数名前面用一个下划线修饰, 表示protected类型
        print "ParentClassA, getName"
        return ParentClassA.parentName
    def setName(self, name):
        print "ParentClassA, setName"
        ParentClassA.parentName = name
    def myAgeMethod(self):
        return 20

class ParentClassB:  # 创建父类B
    __parentAge = 10    # private类型的全局变量, 名称前面用两个下划线修饰
    def __init__(self):
        print "ParentClassB, __init__"
    def _getAge(self):
        print "ParentClassB, getAge"
        return ParentClassB.__parentAge     # 调用类中私有的全局变量
    def setAge(self, age):
        print "ParentClassB, setAge"
        ParentClassB.__parentAge = age

class ChildClass(ParentClassA, ParentClassB):  # 创建子类, ()括号内是继承的父类类名, 可以多继承
    def __init__(self):
        print "ChildClass, __init__"
    def callMethodGetName(self):
        print "ChildClass, callMethodGetName"
        return ParentClassA._getName(self)       # 通过父类的类名调用父类中的方法, 需要传递self参数
    def callMethodGetAge(self):
        print "ChildClass, callMethodGetAge"
        return ParentClassB._getAge(self)        # 通过父类的类名调用父类中的方法, 需要传递self参数
    def myAgeMethod(self):                         # 重写父类中的方法
        return 21

    def myPublicMethod(self):
        return self.__myPrivateMethod()         # 调用类中私有的函数
    def __myPrivateMethod(self):                # private类型的函数, 函数名称前面用两个下划线表示, 直接通过类名调用会报错
        return "is PrivateMethod"

chileClass = ChildClass()                       # 创建子类对象
print chileClass.callMethodGetName()            # 调用子类中的方法
chileClass.setName("lisi")                    # 通过子类对象, 调用父类中的方法
print chileClass.callMethodGetName()

print chileClass.callMethodGetAge()             # 调用子类中的方法
chileClass.setAge(11)                           # 通过子类对象, 调用父类中的方法
print chileClass.callMethodGetAge()

print chileClass.myAgeMethod()                     # 调用子类重写的方法
print chileClass.myPublicMethod()

• 正则表达式:

import re   # re模块提供正则表达式功能
# 从字符串的起始位置匹配一个模式
# 参数1:匹配的正则表达式
# 参数2:要匹配的字符串
# 参数3:标志位,匹配方式,如:是否区分大小写, 多行匹配等
# 匹配成功:返回一个Match对象
# 匹配失败:返回None
matchResult = re.match("aa", "AABBCC", re.I)        # 从字符串AABBCC中匹配bb,不区分大小写
if matchResult:
    print "match, 有匹配结果:", matchResult.span()     # span, 从匹配对象中获取匹配结果起始索引位置的元组, 打印(0, 2)
    print "match, 有匹配结果:", matchResult.group()    # group, 从匹配对象中获取匹配结果的所有子字符串, 打印AA
else:
    print "match, 没有匹配结果"


# 扫描整个字符串并返回第一个成功的匹配
# 参数1:匹配的正则表达式
# 参数2:要匹配的字符串
# 参数3:标志位,匹配方式,如:是否区分大小写, 多行匹配等
# 匹配成功:返回一个Match对象
# 匹配失败:返回None
matchResult1 = re.search("aa", "AABBCC", re.I)   # 从字符串中搜索aa, 不区分大小写
if matchResult1:
    print "search, 有匹配结果:", matchResult1.group()    # group, 获取匹配的字符串, 打印AA
else:
    print "search, 没有匹配结果"

# re.match与re.search的区别:
# re.match只匹配字符串的起始位置，如果字符串开始不符合正则表达式，则匹配失败，函数返回None;
# e.search匹配整个字符串，直到找到一个匹配


# 搜索并替换
# 参数1:匹配的正则表达式
# 参数2:替换的字符串，可以是一个函数
# 参数3:要匹配的字符串
# 参数3:模式匹配后替换的最大次数，默认0表示替换所有的匹配
# 没有匹配结果,返回原始字符串, 有匹配结果, 返回替换后的新字符串
matchResult2 = re.sub("-", "", "400-1111-222", 0)
print "sub:", matchResult2     # 打印4001111222


# 参数2是一个函数, 匹配字符串里面的所有数字, 依次将每个数字乘以2并替换原来的数,
def doubleMethod(research):
    match = research.group()    # 获取每次匹配正确的单个数字
    print match                 # 打印三次, 分别是2, 4, 3
    return str(int(match) * 2)
matchResult3 = re.sub("\d+", doubleMethod, "A2G4HF3D", 0) # \d+匹配至少一个数字
print matchResult3


# 以列表格式返回匹配结果
regexObject = re.compile("\d+")                 # 编译正则表达式, 返回正则表达式对象
matchResult4 = regexObject.findall("A2G4HF3D")  # 以列表格式返回匹配的所有字符, 如果没匹配结果, 返回空列表
print "matchResult4:", matchResult4         # 打印['2', '4', '3']


# 以列表格式返回匹配结果,并遍历
regexObject = re.compile("\d+")                 # 编译正则表达式
matchResult5 = re.finditer(regexObject, "A2G4HF3D")
for match in matchResult5:
    print "match:", match.group()           # 打印2, 4, 3


# 将匹配结果分割后列表返回
matchResult6 = re.split("\W+", "runoob,* runoob# runoob")   # \W+匹配至少一个特殊字符，即非字母、非数字、非汉字、非_
print "matchResult6:", matchResult6                         # 打印['runoob', 'runoob', 'runoob']

• 正则表达式修饰符(可选标志):

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

• 正则表达式模式:

^           匹配字符串的开头
$           匹配字符串的末尾。
.           匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]       用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]      不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*         匹配0个或多个的表达式。
re+         匹配1个或多个的表达式。
re?         匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}      精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
re{ n,}     匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
re{ n, m}   匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b        匹配a或b
(re)        匹配括号内的表达式，也表示一个组
(?imx)      正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)     正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)     类似 (...), 但是不表示一个组
(?imx: re)  在括号中使用i, m, 或 x 可选标志
(?-imx: re) 在括号中不使用i, m, 或 x 可选标志
(?#...)     注释.
(?= re)     前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)     前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)     匹配的独立模式，省去回溯。
\w          匹配字母数字及下划线
\W          匹配非字母数字及下划线
\s          匹配任意空白字符，等价于 [\t\n\r\f].
\S          匹配任意非空字符
\d          匹配任意数字，等价于 [0-9].
\D          匹配任意非数字
\A          匹配字符串开始
\Z          匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z          匹配字符串结束
\G          匹配最后匹配完成的位置。
\b          匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B          匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t,     匹配一个换行符。匹配一个制表符
\1...\9     匹配第n个分组的内容。
\10         匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

• 正则表达式实例:

python      匹配 "python".
[Pp]ython   匹配 "Python" 或 "python"
rub[ye]     匹配 "ruby" 或 "rube"
[aeiou]     匹配中括号内的任意一个字母
[0-9]       匹配任何数字。类似于 [0123456789]
[a-z]       匹配任何小写字母
[A-Z]       匹配任何大写字母
[a-zA-Z0-9] 匹配任何字母及数字
[^aeiou]    匹配除了aeiou字母以外的所有字符
[^0-9]      匹配除了数字外的字符
.           匹配除"\n"之外的任何单个字符。要匹配包括'\n'在内的任何字符，请使用象'[.\n]'的模式。
\d          匹配一个数字字符。等价于 [0-9]。
\D          匹配一个非数字字符。等价于 [^0-9]。
\s          匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S          匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w          匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W          匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。

• 多线程
  创建线程的方式:
  Python通过两个标准库thread和threading提供对线程的支持。
  thread提供了低级别的、原始的线程以及一个简单的锁。
  threading提供其他线程相关的函数,建议用threading

import threading   # 导入线程模块
import time
class MyThread(threading.Thread):           # 创建一个类, 继承threading.Thread线程类
    _threadName = ""
    _delay = 0
    _threadLock = ""
    def __init__(self, threadName, delay, threadLock):
        threading.Thread.__init__(self)     # 需要先初始化Thread, 要不然运行会报错
        self._threadName = threadName
        self._delay = delay
        self._threadLock = threadLock
    def run(self):                          # 重写run函数, 要线程要执行的内容放到这个函数里面
        self._threadLock.acquire()                # 获得锁
        printTimeFunction(self._threadName, self._delay)    # 调用函数执行线程要执行的内容
        self._threadLock.release()                # 释放锁

# 线程需要执行的内容函数
def printTimeFunction(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print threadName, count

threadLock = threading.Lock()               # 获取锁对象,要保证多个线程是用的同一个锁对象
myThread1 = MyThread("Thread-1", 1, threadLock)         # 创建线程, 休眠时间1秒
myThread2 = MyThread("Thread-2", 2, threadLock)
myThreads = []                              # 线程列表
myThreads.append(myThread1)                 #将线程对象添加到列表
myThreads.append(myThread2)
myThread1.start()                           # 启动线程2, 休眠时间2秒
myThread2.start()
for t in myThreads:
    t.join()                                # 等线程队列为空，再执行别的操作

• 线程优先级队列（ Queue）

Python的Queue模块提供了同步的、线程安全的队列类，
包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，
和优先级队列PriorityQueue，这些队列都实现了锁原语，能
够在多线程中直接使用，可以使用队列来实现线程间的同步。

• 线程同步

使用Thread对象的Lock和Rlock可以实现简单的线程同步，
这两个对象都有acquire方法和release方法，
对于那些需要每次只允许一个线程操作的数据，
可以将其操作放到acquire和release方法之间