背景：最近分析日志，且日志较多，涉及从日志中提取关键字、计算、然后再进行相关的识别，排查是否存在业务bug 导致的问题；
目的：预期使用python 脚本，过滤关键日志，然后自动计算，将计算的结果以图标的形式展现出来，或者输出计算的结果到 目标文件中；
计划：先初步学习python 基础，语法，应用；然后使用 python 语言处理实际问题；
结论：
1、python 语言简单易用，整个脚本中可以没有 ;
python
# 【day1: 关于Python 20141226】
#
# Python 是一种极少数能声言兼具 简单 与 功能强大 的编程语言。 你将惊异于发现你正在使用
# 的这门编程语言是如此简单， 它专注于如何解决问题， 而非拘泥于语法与结构。
# 官方对 Python 的介绍如下：
# Python 是一款易于学习且功能强大的编程语言。 它具有高效率的数据结构， 能够简单又
# 有效地实现面向对象编程。 Python 简洁的语法与动态输入之特性， 加之其解释性语言的
# 本质， 使得它成为一种在多种领域与绝大多数平台都能进行脚本编写与应用快速开发工
# 作的理想语言。
# 我将会在下一节详细讨论这些特性。
# Python 的特色
# 简单
# Python 是一门简单且简约的语言。 阅读一份优秀的 Python 程序代码就如同在阅读英语文章
# 一样， 尽管这门英语要求十分严格！ Python 这种伪代码式的特质正是它的一大优势。 它能够
# 让你专注于解决问题的方案， 而不是语言本身。
# 易于学习
# 正如你接下来将看到的， Python 是一门非常容易入门的语言。 正如前面所提到的， Python 有
# 一套极其简单的语法体系。
# 【如何在python运行一个传统的"Hello world" 程序】
# 接下来我们将看见如何在 Python 中运行一个传统的"Hello World"程序。 本章将会教你如何编
# 写、 保存与运行 Python 程序。
# 通过 Python 来运行的你的程序有两种方法------使用交互式解释器提示符或直接运行一个源代
# 码文件。 我们将了解如何使用他们二者的功能。
# 1、解释器提示符号
# 当你启动 Python 后， 你会看见在你能开始输入内容的地方出现了 >>> 。 这个被称作 Python
# 解释器提示符（ Python Interpreter Prompt） 。
# 2、直接运行一个源代码文件
print(u"test01: 运行一个传统的"Hello World"程序")
# 要注意 Python 是区分大小写的， 如 print 和 Print 是不同的------注意前者的 p 是
# 小写的， 而后者的 P 是大写的。
# 此外， 你需要确保每一行的第一个字符前面都没有任何空格或制表格------我们会在后面了解 为什么这件事如此重要。
print()
print(u"test02: 基础------001注释")
# 注释
# 注释 是任何存在于 # 号右侧的文字， 其主要用作写给程序读者看的笔记。
# 举个例子：
print('hello world') #注意到 print 是一个函数
# 或者：
# 注意到 print 是一个函数
print('hello world')
print()
print("test02: 基础------002字面常量、数字、字符串、单引号、双引号、三引号")
# 字面常量
# 一个字面常量（ Literal Constants） 的例子是诸如 5 、 1.23 这样的数字， 或者是如 这是一
# 串文本 或 This is a string 这样的文本。
# 用这样的称呼是因为它们是 字面上的 ------你用的就是它字面意义上的值或是内容。
# 数字 2总是表示它本身而非其他含义------它是一个 常量， 因为它的值不能被改变。 因此， 所有的这
# 些都被称作字面常量。
# 数字
# 数字主要分为两种类型------整数（ Integers） 与浮点数（ Floats） 。
# 有关整数的例子即 2 ， 它只是一个整数。
# 有关浮点数（ Floating Point Numbers， 在英文中也会简写为 floats ） 的例子是 3.23 或
# 52.3E-4 。 其中， E 表示 10 的幂。 在这里， 52.3E-4 表示 52.3 * 10^-4 。
# 针对有经验的程序员的提示
# 没有单独的 long 类型。 int 类型可以指任何大小的整数。
# 字符串
# 一串字符串（ String） 是 字符（ Characters） 的 序列（ Sequence） 。 基本上， 字符串就是一
# 串词汇。
# 单引号
# 你可以使用单引号来指定字符串， 例如 '将我这样框进来' 或 'Quote me on this' 。
# 所有引号内的空间， 诸如空格与制表符， 都将按原样保留。
# 双引号
# 被双引号包括的字符串和被单引号括起的字符串其工作机制完全相同。 例如 "你的名字是？ " 或
# "What's your name?" 。
# 三引号
# 你可以通过使用三个引号------ """ 或 ''' 来指定多行字符串。 你可以在三引号之间自由地
# 使用单引号与双引号。 来看看这个例子：输出的内容如下格式原样保留：
# '''这是一段多行字符串。 这是它的第一行：
# This is the second line.
# "What's your name?," I asked.
# He said "Bond, James Bond."
# '''
# 字符串是不可变的
# 这意味着一旦你创造了一串字符串， 你就不能再改变它。
# 针对 C/C++ 程序员的提示
# Python 中没有单独的 char 数据类型。
# 格式化方法
# 有时候我们会想要从其他信息中构建字符串。 这正是 format() 方法大有用武之地的地方。
# 将以下内容保存为文件 str_format.py ：
age = 20
name = 'xiaozhang'
print('{0} was {1} years old when he wrote this book' .format(name, age))
print('why is {0} playing with that python?'.format(name))
# format 方法将被调用， 使用这一方法中与之相应的参数替换这些格式。
# 可以通过联立字符串来达到相同的效果：/// 问题：如何输出呢？？？
# print("'name' + 'is' + str(age) + 'years old'") # 注意： 双引号括起来的都当做字符串原样输出了
print(name + ' is ' + str(age) + ' years old') # print OK
# 如上写法不推荐：因这样实现是很丑陋的， 而且也容易出错。 其次， 转换至字符串的工作将由 format 方法自
# 动完成， 而不是如这般需要明确转换至字符串。 再次， 当使用 format 方法时， 我们可以直
# 接改动文字而不必与变量打交道， 反之亦然。
print('{0:.3f}' .format(1.0/3)) # 对于浮点数 '0.333' 保留小数点(.)后三位
print('{0:_^11}' .format('hello')) # 使用下划线填充文本， 并保持文字处于中间位置：使用 (^) 定义 '___hello___'字符串长度为 11
# 基于关键词输出 'Swaroop wrote A Byte of Python'
print('{name} wrote {book}' .format(name='xiaozhang', book='a Byte of python'))
# 为防止打印过程中出现这一换行符， 可以通过 end 指定其应以空白结尾：
print('a', end='')
print('b', end='')
print()
print('a', end=' ')
print('b', end=' ')
print()
# 转义序列 \ 来指定单引号 ' 在字符串中的输出
# 类似地， 必须在使用双引号括起的字符串中对字符串内的双引号使用转义序列。
print('what\'s your name')
print("what's your name")
# 使用一个表示新一行的转义序列------ \n 来表示新一行的开始
# 转义序列是制表符： \t
# 在一个字符串中， 一个放置在末尾的反斜杠表示字符串将在下一行继续， 但不会添加新的一行。
# 如果你需要指定一些未经过特殊处理的字符串， 比如转义序列， 那么你需要在字符串前增加r 或 R 来指定一个 原始（ Raw） 字符串
print('01 This is the first line\nThis is the second line')
print('02 This is the first line\tThis is the second line')
print("03 This is the first line \
This is the second line")
print(r'04 This is the first line\nThis is the second line')
print()
print("test02: 基础------003变量")
# 标识符命名
# 数据类型
# 对象
# Python 将程序中的任何内容统称为 对象(Object)。 这是一般意义上的说法。 我们以"某某对象（ object） "相称
# 如何编写 Python 程序
# 案例： 使用变量与字面常量：变量只需被赋予某一值，不需要声明或定义数据类型。
i = 5
print(i)
i = i + 1
print('i is', i)
s = '''This is a multi-line string.
This is the second line.'''
print(s)
# 逻辑行与物理行
# 所谓物理行（ Physical Line） 是你在编写程序时 你所看到 的内容。 所谓逻辑行（ Logical
# Line） 是 Python 所看到 的单个语句。 Python 会假定每一 物理行 会对应一个 逻辑行。
# 有关逻辑行的一个例子是诸如 print('hello world') 这样一句语句------如果其本身是一行
# （ 正如你在编辑器里所看到的那样） ， 那么它也对应着一行物理行。
# Python 之中暗含这样一种期望： Python 鼓励每一行使用一句独立语句从而使得代码更加可读。
# 如果你希望在一行物理行中指定多行逻辑行， 那么你必须通过使用分号( ; )来明确表明逻辑行或语句的结束。
# 强烈建议你对于每一行物理行最多只写入一行逻辑行：不应该使用分号。
# 【实际上， 我从未在 Python 程序中使用、 甚至是见过一个分号】
i = 5; print(i);
i = 5; print(i)
# 缩进
# 空白区 在 Python 中十分重要；使用四个空格来缩进。 这是来自 Python 语言官方的建议。
# 实际上， 空白区在各行的开头非常重要。 这被称作 缩进(Indentation)。
# 在逻辑行的开头留下空白区（ 使用空格或制表符） 用以确定各逻辑行的缩进级别， 而后者又可用于确定语句的分组。
# 放置在一起的语句必须拥有相同的缩进。 每一组这样的语句被称为 块（ block）
print()
print("test03: 运算符与表达式")
print("test03: 运算符与表达式 ------ 001运算符")
# 运算符：加+ 减- 乘* 乘方** 除/ 整除// 取模% 左移<< 右移>> 按位与& 按位或| 按位异或^ 按位取反~
# < > <= >= == != 布尔非not 布尔与and 布尔或 or
# 数值运算与赋值的快捷方式
# 求值顺序
# 下面将给出 Python 中从最低优先级（ 最少绑定） 到最高优先级（ 最多绑定） 的优先级表。 这
# 意味着， 在给定的表达式中， Python 将优先计算表中位列于后的较高优先级的运算符与表达式。
# lambda ： Lambda 表达式
# if - else ： 条件表达式
# or ： 布尔"或"
# and ： 布尔"与"
# not x ： 布尔"非"
# in, not in, is, is not, <, <=, >, >=, !=, == ： 比较， 包括成员资格测试(Membership Tests)和身份测试(Identity Tests)。
# | ： 按位或
# ^ ： 按位异或
# & ： 按位与
# <<, >> ： 移动
# +, - ： 加与减
# *, /, //, % ：乘、 除、 整除、 取余
# +x, -x, ~x ： 正、 负、 按位取反
# ** ： 求幂
# x[index], x[index:index], x(arguments...), x.attribute ： 下标、 切片、 调用、 属性引用
# (expressions...), [expressions...], {key: value...}, {expressions...} ： 表示绑定或元组、 表示列表、 表示字典、 表示集合
# 改变运算顺序
# 表达式
lenth = 5
breadth = 2
area = lenth * breadth
print('Area is', area)
print('perimeter is', 2 * (lenth * breadth))
print()
print("test04: 控制流")
print("test04: 控制流------001 if语句")
# 在 Python 中有三种控制流语句------ if for 和 while
# 通过 input() 函数来获取用户的猜测数。
# int 是一个类（ Class） ， 但你现在你所需要知道的就是你可以使用它将一串字符串转换成一个整数（ 假设这个字符串的文本中含有一个有效的整数）
number = 23
# inputData = int(intput('Enter an integer: ')) # input 函数写成了 intput了 【】
# inputData = int(raw_intput('Enter an integer: '))
# inputData = int(input('Enter an integer : '))
inputData = 23
if inputData == number: # if 语句在结尾处包含一个冒号------我们借此向 Python 指定接下来会有一块语句在后头。
print('it is equal for {inputData} and {number}', format(str(inputData), str(number)))
elif inputData < number:
print('No, it is {inputData} is lower than {number}', format(str(inputData), str(number)))
else:
print('No, it is {inputData} is higer than {number}', format(str(inputData), str(number)))
print('intputData is', inputData)
print('intputData is', str(inputData))
print('Dnoe\n')
# 通过如上案例，有2点注意：
# 1）format函数的参数必须是字符串；2）str()转换 inputData 之后传入format() 函数没有生效; ？？？
print("test04: 控制流------002 while语句")
# 注意：while 语句同样可以拥有 else 子句作为可选选项。
# 如果 while 循环中存在一个 else 代码块， 它将总是被执行，除非你通过 break 语句来中断这一循环。
number = 23
running = True
while running:
# guess = int(input('Enter an integer:'))
guess = 23
if guess == number:
print('{0} is equll {1}' .format(guess, number))
running = False
elif guess < number:
print('{0} is lower than {1}' .format(guess, number))
else:
print('{0} is higer than {1}' .format(guess, number))
else:
print('The while loop is over.')
print('Done')
print("test04: 控制流------003 for语句")
# for...in 语句是另一种循环语句， 其特点是会在一系列对象上进行迭代（ Iterates） ， 意即它会遍历序列中的每一个项目。
# range 将会返回一个数字序列， 从第一个数字开始， 至第二个数字结束。 举个例子， range(1,5) 将输出序列 [1, 2, 3, 4] 。
# 如果我们向 range 提供第三个数字， 则这个数字将成为逐步递增的加数。 同样举个例子来说明， range(1,5,2) 将会输出 [1, 3] 。
# 要记住这一序列扩展直到第二个数字， 也就是说， 它不会包括第二个数字在内。
# 注意的是， range() 每次只会生成一个数字， 如果你希望获得完整的数字列表， 要在使用 range() 时调用 list() 。
# 例如下面这样： list(range(5)) ， 它将会返回 [0, 1, 2, 3, 4]
# else 部分是可选的。 当循环中包含他时， 它总会在 for 循环结束后开始执行， 除非程序遇到了 break 语句。
for i in range(1, 5):
print(i)
else:
print('The for loop is over')
print('Done')
for i in list(range(1, 5)):
print(i)
else:
print('The for loop is over, list test OK')
print('Done')
print("test04: 控制流------003 break语句")
# break 语句用以中断（ Break） 循环语句， 也就是中止循环语句的执行， 即使循环条件没有
# 变更为 False ， 或队列中的项目尚未完全迭代依旧如此。
# 注意， 如果你 中断 了一个 for 或 while 循环， 任何相应循环中的 else块都将不会被执行。
s = 'hello'
while True:
# s = input('Enter something : ')
if s == 'quit':
break
print('Length of the string is', len(s))
s = 'quit'
print('Done')
print()
print("test04: 控制流------004 continue语句")
# continue 语句用以告诉 Python 跳过当前循环块中的剩余语句， 并继续该循环的下一次迭代。
s = 'hello'
while True:
# s = input('Enter something : ')
if s == 'quit':
break
if len(s) < 5:
print('Too small')
continue
print('Input: {0} is of sufficient length' .format(s))
s = 'quit'
# 自此处起继续进行其它任何处理
print('Done')
print()
print("test05: 函数")
# 函数（ Functions） 是指可重复使用的程序片段。我们之前学习了许多内置的函数， 例如 len 和 range 。
# 函数可以通过关键字 def 来定义。 这一关键字后跟一个函数的标识符名称， 再跟一对圆括
# 号， 其中可以包括一些变量的名称， 再以冒号结尾， 结束这一行。 随后而来的语句块是函数
# 的一部分。 下面的案例将会展示出这其实非常简单：
def say_hello():
print('hello world')
say_hello()
say_hello()
print()
print("test05: 函数------ 001 函数参数")
# 函数中的参数通过将其放置在用以定义函数的一对圆括号中指定， 并通过逗号予以分隔。 当
# 我们调用函数时， 我们以同样的形式提供需要的值。
def print_max(a, b):
print('intput data:', a, b)
if a > b:
print(a, 'is maximum')
elif a == b:
print(a, 'is equal to ', b)
else:
print(b, 'is maximum')
print_max(3, 4)
x = 5
y = 7
print_max(x, y)
print('Done')
print()
print("test05: 函数------ 002 局部变量")
# 当你在一个函数的定义中声明变量时， 它们不会以任何方式与身处函数之外但具有相同名称的变量产生关系，
# 也就是说， 这些变量名只存在于函数这一局部（ Local） 。 这被称为变量的作用域（ Scope）。
# 所有变量的作用域是它们被定义的块， 从定义它们的名字的定义点开始。
x = 50
def func(x):
print('x is:', x)
x = 2
print('Changed local param x to:', x)
func(x)
print('x is still', x)
print('Done')
print()
print("test05: 函数------ 003 global 语句")
# 如果你想给一个在程序顶层的变量赋值（ 也就是说它不存在于任何作用域中，无论是函数还是类），
# 那么你必须告诉 Python 这一变量并非局部的， 而是全局（ Global） 的。 我们需要通过 global 语句来完成这件事。
# 因为在不使用 global 语句的情况下， 不可能为一个定义于函数之外的变量赋值。
# 通过使用 global 语句便可清楚看出这一变量是在最外边的代码块中定义的
# 在同一句 global 语句中指定不止一个的全局变量， 例如 global x, y, z 。
x = 50
def func():
global x # global 语句用以声明 x 是一个全局变量
print('x is', x)
x = 2
print('Changed global x to', x)
func()
print('Value of x is', x)
print('Done')
print()
print("test05: 函数------ 004 默认参数值")
# 注意：默认参数值应该是常数。 更确切地说， 默认参数值应该是不可变的
# 注意：只有那些位于参数列表末尾的参数才能被赋予默认参数值， 意即在函数的参数列表中拥
# 有默认参数值的参数不能位于没有默认参数值的参数之前。
# 这是因为值是按参数所处的位置依次分配的。 举例来说，def func(a, b=5) 是有效的，但 def func(a=5, b) 是无效的。
def say(message, times=1):
print(message * times)
say('Hello ')
say('World ', 5)
print('Done')
print()
print("test05: 函数------ 005 关键字参数")
# 如果你有一些具有许多参数的函数， 而你又希望只对其中的一些进行指定， 那么你可以通过
# 命名它们来给这些参数赋值------这就是关键字参数（ Keyword Arguments） ------我们使用命
# 名（关键字） 而非位置（ 一直以来我们所使用的方式） 来指定函数中的参数。
# 两大优点：
# 其一， 我们不再需要考虑参数的顺序， 函数的使用将更加容易。
# 其二， 我们可以只对那些我们希望赋予的参数以赋值， 只要其它的参数都具有默认参数值。
def func(a, b = 5, c = 10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7)
func(25, c = 24) # 实参传递时，可以指定某几个参数的值，这样未指定的参数值就使用默认的值
func(c = 50, a = 100)
print('Done')
print()
print("test05: 函数------ 006 可变参数【】【】")
# 定义的函数里面能够有任意数量的变量， 也就是参数数量是可变的， 这可以通过使用星号来实现
# 当我们声明一个诸如 *param 的星号参数时， 从此处开始直到结束的所有位置参数
# （ Positional Arguments） 都将被收集并汇集成一个称为"param"的元组（ Tuple） 。
# 当我们声明一个诸如 **param 的双星号参数时， 从此处开始直至结束的所有关键字
# 参数都将被收集并汇集成一个名为 param 的字典（ Dictionary） 。
def total(a = 5, *numbers, **phonebook):
print('a', a)
#遍历 元组中的所有项目 【】元祖：
for single_item in numbers:
print('single_item', single_item)
#遍历 字典中的所有项目 【】字典：key = value
for first_part, second_part in phonebook.items():
print(first_part, second_part)
# print(total(10, 1, 2, 3, Jack = 1123, John = 2231, Inge = 1560))
total(10, 1, 2, 3, Jack = 1123, John = 2231, Inge = 1560)
print('Done')
print()
print("test05: 函数------ 007 return语句")
# return 语句用于从函数中返回， 也就是中断函数。 我们也可以选择在中断函数时从函数中返回一个值。
def maximum(x, y):
if x > y:
return x
elif x == y:
return 'The numbers are equal'
else:
return y
print(maximum(2, 3))
print('Done')
# 注意：如果 return 语句没有搭配任何一个值则代表着 返回 None 。
# None 在 Python 中一个特殊的类型， 代表着虚无。
# 举个例子， 它用于指示一个变量没有值， 如果有值则它的值便是 None（ 虚无） 。
# 【】【】每一个函数都在其末尾隐含了一句 return None ， 除非你写了你自己的 return 语句。
# Python 中的 pass 语句用于指示一个没有内容的语句块。
def some_function():
pass
some_function()
print('Done')
print()
print("test05: 函数------ 008 DocStrings")
# 文档字符串（ Documentation Strings） ， 在称呼它时通常
# 会使用另一个短一些的名字docstrings。 DocStrings 是一款你应当使用的重要工具， 它能够帮
# 助你更好地记录程序并让其更加易于理解。 令人惊叹的是， 当程序实际运行时， 我们甚至可
# 以通过一个函数来获取文档！
def print_max(x, y): # 如下 ''' 括起来的字符串，属于文档字符串
# 该文档字符串所约定的是一串多行字符串， 其中：
# 第一行以某一大写字母开始， 以句号结束。
# 第二行为空行，
# 第三行开始是任何详细的解释说明。 在此强烈建议你在你所有重要功能的所有文档字符串中都遵循这一约定。
'''打印两个数值中的最大数。
这两个数都应该是整数'''
# 如果可能， 将其转换至整数类型
x = int(x)
y = int(y)
if x > y:
print(x, 'is maximum')
else:
print(y, 'is maximum')
print_max(3, 5)
print(print_max.__doc__) # 使用函数的 __doc__属性来获取函数 print_max 的文档字符串属性。
print('Done')
# 【】【】我们可以通过使用函数的 __doc__属性来获取函数 print_max 的文档字符串属性。
# 只要记住 Python 将所有东西都视为一个对象， 这其中自然包括函数。
# 我们将在后面的类（ Class） 章节讨论有关对象的更多细节。
# 文档字符串的用途：它所做的便是获取函数的 __doc__ 属性并以一种整洁的方式将其呈现给你。
# 自动化工具可以以这种方式检索你的程序中的文档。 因此， 我强烈推荐你为你编写的所有重
# 要的函数配以文档字符串。 你的 Python 发行版中附带的 pydoc 命令与 help() 使用文档字
# 符串的方式类似。
# print("test06: 模块")
# print("test07: 数据结构")
# print("test08: 解决问题")
# print("test09: 面向对象编程")
# print("test010: 输入输出")
print("end")