Python是一门动态语言
        与Java,C等相对,Python不用编译,像脚本一样直接运行,这就导致了所有错误都是运行时的!即使有语法错误,或者异常,如果程序逻辑没有执行到,就不会有错误。比如一个if分支中有语法错误,使用了未定义的函数,但如果未执行到此分支,就可以正常运行.。
动态的另外一层意思就是它的类型是动态的,也就是说无需指定变量的类型,在运行时根据它的内容来决定的类型。
       如何运行Python

       通常来讲有二种方式:一种方式是交互式的,就像Shell命令行提示符那样,交互式的输入和输出,在终端输入python命令,就进入了Python的命令提示符中:>>>输入Python语句,解释器就会执行并输出结果,如:


Python 3.3.3 (v3.3.3:c3896275c0f6, Nov 18 2013, 21:18:40) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> print("Hello World")
Hello World
>>>

另一种,就像Shell的脚本的一样,把一组命令集合到一起执行。

       Python以缩进来区分语句块
      不像Java、C/C++以花括号{ }来区分语句块。Python是以缩进来表示语句块,同一缩进级别为同一级别的语句块。一个脚本文件中的0级缩进是文件加载的时候就会被执行的语句,开启一个新的缩进需要使用:(冒号),代表下一级别的语句块,如条件、循环或者函数定义。
      缩进最好使用四个空格,而且要注意缩进要一致,使用空格就全都用空格,使用Tab就都使用Tab,混用就可能得到缩进错误:
IndentationError: unindent does not match any outer indentation level
       操作符
       与Java和C中十分类似, +(加)、 -(减)、*(乘)、 /(除)、 %(求余)、 **(指数运算),、= (赋值)、以及减便运算,如 +=, -=, *=和/= 等.
赋值运算与其他语言一致。
       逻辑操作
        > < <= >= != ==与其他语言一样,不一样的有not逻辑非、and逻辑与和or逻辑或。
      注释与文档

       一行当中,从#开始地方就是注释,不会影响下一行。""引号放在文件的开头,函数的开头或者一个类的开头,就是文档注释,与Java中的/** ... */作用和目的是一样的。

      折行
      如果一行太长了,写不下了,就需要在下一行接着写,这时可以使用“、”来告诉Python,下一行继续。一行写多个语句。Python是一个语句放在一行,行尾可以选择性的加上;但如果想在一行放多个语句,就需要用;来分隔语句。如:

a = 1; b = 2; c = 3;

虽然这在语法上可行,但不是一个好习惯,绝大多数的编程规范都是要一行写一个语句。


     

基本数据类型


     int 、long、bool、float,与Java中非常接近。可以近似认为一致,bool的值是True和False,或者0(False),非0就是True。

      List和Tuple
     这就是Java或C中的数组,它是一个容器,能用来顺序的、以整数索引方式检索。存储一组对象List用[ ]来表示,如[1, 2, 3]就是一个List;而Tuple用( )来表示,如(3, 4, 5)就是一个Tuple。它们的区别在于List是可变的;而Tuple是不可变的,也就是说不可以增、删和改。
      索引方式除了与Java一样的以一个整数下标方式外,还可以指定开始、结束和步长,和使用负索引来分割List:。通用语法格式是:

list[start:end:step]
 list[index] --- 返回第(index+1)个元素,受C语言影响,下标亦是从0开始
 list[start:end] --- 返回从start开始,到end-1,也就是list[start], list[start+1].....list[end-1]
 list[start:end:step] --- 与上面类似,只不过每隔step取一个
 list[:end]  ---- 缺省的开端是0
 list[start:] ---- 缺省的结尾是len(list),或者-1
 负数索引更是方便,它与正数的对应关系为:
 正数索引   0    1      2      3
 数组元素  [1]   [3]    [5]    [7]
 负数索引  -4    -3      -2    -1


实例:


>>> a = [1, 3, 5, 7];  
>>> a[0]  
1  
>>> a[3]  
7  
>>> a[-1]  
7  
>>> a[-2]  
5  
>>> a[0:3]  
[1, 3, 5]  
>>> a[1:3:2]  
[3]  
>>> a[0:3:2]  
[1, 5]  
>>> a[0:-1:2]  
[1, 5]  
>>>

       List是一个对象,它有一此内置的方法,如:

       1)包含关系::in, not in


>>> 3 in a  
True  
>>> 8 in a  
False  
>>> 8 not in a  
True  
>>>

       2)连接符::+


>>> a + [9, 11]  
[1, 3, 5, 7, 9, 11]

       3)重复::*


>>> a * 2  
[1, 3, 5, 7, 1, 3, 5, 7]  
>>>

         

字符串String


         字符串就是一个字符的数组,List的操作都可以对String直接使用。


>>> str = 'hello, world'  
>>> str[0:3]  
'hel'  
>>> str[0:3:2]  
'hl'  
>>> str[-1]  
'd'  
>>> str * 2  
'hello, worldhello, world'  
>>> '3' in str  
False  
>>> 'le' in str  
False  
>>> 'el' in str  
True  
>>> 'ell' not in str  
False  
>>>

       

字串格式化符%


       这是一个类似C语言printf和Java中的String.format()的操作符,它能格式化字串、整数、浮点等类型。语句是:


formats % (var1, var2,....)

它返回的是一个String。


       

Dictionary字典


       相当于Java中的HashMap,用于以Key/Value方式存储的容器。创建方式为{key1::value1, key2: value2, ....};更改方式为dict[key] = new_value;索引方式为dict[key]、dict.keys()方法以List形式返回容器中所有的Key;dict.values()以List方式返回容器中的所有的Value,实例如:


>>> box = {'fruits': ['apple','orange'], 'money': 1993, 'name': 'obama'}  
>>> box['fruits']  
['apple', 'orange']  
>>> box['money']  
1993  
>>> box['money'] = 29393  
>>> box['money']  
29393  
>>> box['nation'] = 'USA'  
>>> box  
{'money': 29393, 'nation': 'USA', 'name': 'obama', 'fruits': ['apple', 'orange']}  
>>> box.keys()  
['money', 'nation', 'name', 'fruits']  
>>> box.values()  
[29393, 'USA', 'obama', ['apple', 'orange']]  
>>>

      

分支语句


      格式为:  

if expression:  
      blocks; 
elif expression2:  
      blocks
else:  
      blocks

其中逻辑表达式可以加上括号( ),也可以不加。但如果表达式里面比较混乱,还是要加上括号,以提高清晰,但整体的逻辑表达式是可以不加的。

       while循环
       与Java中类似:


while expression:
      blocks

     

for语句


      与Java中的foreach语法一样,遍历List:


for var in list:
     blocks
>>> msg = "Hello";  
>>> for c in msg:  
... print (c);  
...   
H  
e  
l  
l  
o  
>>>

       

数组推导


这是Python最强大、也是最性感的功能:


list = [expression for var in list condition]

它相当于这样的逻辑:


lst = []
for var in list:
    if condition:
         execute expression
         add result of expression to lst
return lst

一句话,相当于这么多逻辑,可见数组推导是一个十分强大的功能,示例:


>>> a = range(4);  
>>> a  
[0, 1, 2, 3]  
>>> [x*x for x in a if x % 2 == 0]  
[0, 4]  
>>>

       

函数


       如何定义函数


def function_name(args):
      function_body

调用函数的方式function_name(formal_args)


>>> def power(x):  
... return x*x;  
...   
>>> power(4)  
16  
>>>

Python中函数也是一个对象,可以赋值,可以拷贝,可以像普通变量那样使用,其实可以理解为C语言中的指针,如:


>>> d = power;  
>>> d(2)  
4

      另外就是

匿名函数,或者叫做lambda函数,它没有名字,只有参数和表达式:


lambda  args: expression
>>> d = lambda x: x*x;  
>>> d(2)  
4

       

一些常用的内置函数


       所谓内置函数,就是不用任何导入,语言本身就支持的函数:


        1)print --- 打印输出

print (var1, var2, var3)


>>> a = [1,2,3]
>>> d = ['hello', 11,12]
>>> print(a,d)
[1, 2, 3] ['hello', 11, 12]
>>>

print与%结合更为强大:


print formats % (var1, var2, ...),


>>> print "today is %d, welcome %s" % (2013, 'alex');  
today is 2013, welcome alex

其实这没什么神秘的,前面提到过%格式化返回是一个字串,所以print仅是输出字串而已,格式化工作是由%来做的。

       2)len()---返回列表,字串的长度
       3)range([start], stop, [step]) --- 生成一个整数列表,从,start开始,到stop结束,以step为步长。
       4)help(func)---获取某个函数的帮助文档。

       正则表达式
      Python也是支持正则表达式的,至于正则表达式,跟其他的语言如Java、C没什么差别,这里说说如何使用正则表达式来进行匹配:


import re;  
p = re.compile(expression);  
m = p.search(target);  
if m != None:  
    # got match  
else:  
    # no match

如:


>>> message = 'Welcome to the year of 2013';  
>>> import re;  
>>> p = re.compile('(\d+)');  
>>> m = p.search(message);  
>>> m  
<_sre.SRE_Match object at 0x7f668c015300>  
>>> print m.group(1)  
2013  
>>>

      这些就是Python的入门基础知识,了解了这些内容,我相信就可以使用Python来完成你的需要,比如写一些小工具之类的。