python的语法特点有哪些 python的语法基础

一、基础语法

1.1、Python

Python 程序通过解释器执行。Python 是一种动态语言,在程序运行过程中，同一变量名可以（在程序运行的不同阶段）代表不同形式的值(整型,浮点,列表,元组...)。

1.2、变量和表达式

Python中每个语句以换行结束,当然你也可以在一行中写多个语句，这时语句之间必须使用用分号分隔，就象下面这样:

principal = 1000; rate = 0.05; numyears =5;

（建议这样的写法仅仅用于调试语句，因为可以很方便的只删一行就删掉全部调试语句)

Python并未指定缩进的空白(空格和制表符)数目，唯一的要求是同一层次的语句必须有相同的缩进空白。（注意，要么都是空格，要是么都制表符，千万别混用)

1.3、条件语句

if/else/elif

通过使用 or,and 和 not 关键字你可以建立任意的条件表达式:

if b>= a and b <= c:
    print("b is between a and c")
if not(b < a or b > c):
    print("b is still between a and c")

1.4、文件输入/输出

下面的程序打开一个文件,然后一行行地读出并显示文件内容:

f =open("foo.txt") #Returns a file object
line =f.readline() #Invokes readline() method on file
while line:
    print(line)     #trailing',' omits newline character
    line = f.readline()
f.close()

open()函数返回一个新文件对象(file object)。通过调用此对象的不同方法可以对文件进行不同的操作。readline()方法读取文件的一行(包括换行符'\n')。如果读到文件末尾，就返回一个空字符串。要将程序的输出内容由屏幕重定向到文件中，可

以使用'>>'运算符，如下例:

print>>f,"%3d %0.2f" %% (year,principal) #将格式文本输出到文件对象f

当然,文件对象也拥有write()方法，通过它可以向文件对象写入新的数据。例如上边例子中的print的语句也可以写成这样:

f.write("%3d%0.2f\n" % (year,principal))

1.5、字符串

要创建一个字符串，你使用单引号,双引号或三引号将其引起来，如下例:

a ='Hello World'
b ="Python is groovy"
c ="""What is footnote 5?"""

字符串是一个以0开始，整数索引的字符序列,要获得字符串 s 中的第 i+1 个字符(别忘了0是第一个),使用索引操作符 s[i]

a ="Hello World"
 b =a[4]    #b = 'o'

要获得一个子串,使用切片运算符s[i:j]，它返回字符串s中从索引i(包括i)到j(不包括 j)之间的子串。若i被省略，python就认为 i=0，若j被省略，python就认为j=len(s)-1:

c =a[0:5]    #c = "Hello"
 d =a[6:]     #d = "World"
 e =a[3:8]    #e = "lo Wo"

1.6、列表和元组(Lists & Tuples)

就如同字符串是字符的序列,列表和元组则是任意对象的序列。象下面这样就可以创建一个列表:

names= [ "Dave", "Mark", "Ann", "Phil" ]

列表和元组都是以整数0来开始索引的序列,你可以用索引操作符来读取或者修改列表中特定元素的值。

元组(tuple)类型和列表关系很密切,通过用圆括号中将一系列逗号分割的值括起来可以得到一个元组:

a =(1,4,5,-9,10)

b =(7,)          #一个元素的元组 (注意一定要加一个额外的逗号！)

person= (first_name, last_name, phone)

在某些时候，即使没有圆括号, Python仍然可以根据上下文认出这是一个元组,(为了写出更清晰可读的程序，建议你不要依赖 Python 的智能)

元组支持大多数列表的操作,比如索引,切片和连结。一个关键的不同是你不能在一个tuple创建之后修改它的内容。也就是说,你不能修改其中的元素,也不能给tuple添加新的元素。

1.7. 循环

通过使用while语句，我们在前面已经简单介绍了 while 循环。在Python中另一种循环结构是 for 循环，它通过迭代 一个序列(例如字符串,列表,或者tuple等)中的每个元素来建立循环。下边是一个例子:

for iin range(1,10):
    print("2 to the %d power is %d" % (i, 2**i))

range(i,j)函数建立一个整数序列,这个序列从第i数开始(包括i)到第j数为止(不包括j)。若第一个数被省略，它将被认为是0。该函数还可以有第三个参数，步进值，见下面的例子:

a =range(5)    #a = [0,1,2,3,4]
 b =range(1,8)  #b = [1,2,3,4,5,6,7]
 c =range(0,14,3) #c = [0,3,6,9,12]
 d =range(8,1,-1) #d = [8,7,6,5,4,3,2]

for语句可以迭代任何类型的序列:

a ="Hello World"   # Print out thecharacters in a
for c in a:
    print c
b =["Dave","Mark","Ann","Phil"]  # Print out the members of a list
for name in b:
    print name

range()函数根据起始值，终止值及步进值三个参数在内存中建立一个列表，当需要一个很大的列表时,这个既占内存又费时间。为了克服它的缺点,Python提供了xrange()函数:

for i in xrange(1,10):
    print("2 to the %d power is %d" % (i, 2**i))
a =xrange(100000000)  #a = [0,1,2, ...,99999999]
b =xrange(0,100000000,5)  #b = [0,5,10,...,99999995]

xrange()函数只有在需要值时才临时通过计算提供值，这大大节省了内存。

1.8. 字典

字典就是一个关联数组(或称为哈希表)。它是一个通过关键字索引的对象的集合。

使用大括号{}来创建一个字典，如下例:

a = {
    "username" : "beazley",
    "home" : "/home/beazley",
    "uid" : 500
}

用关键字索引操作符可以访问字典的某个特定值:

u =a["username"]
d =a["home"]

用下面的方式插入或者修改对象:

a["username"]= "pxl"
a["home"]= "/home/pxl"
a["shell"]= "/usr/bin/tcsh"

尽管字符串是最常见的关键字(key) 类型，你还是可以使用很多其它的 python 对象做为字典的关键字，比如数字 和 tuple，只要是不可修改对象，都可以用来做字典的key。有些对象,例如列表和字典,不可以用来做字典的key,因为他们的内容是允许更改的。

我们可以使用has_key() 方法来检验一个键/值对是否存在(或者in操作符):

if a.has_key("username"):
    username = a["username"]
else:
    username = "unknown user"

上边的操作还可以用更简单的方法完成:

username= a.get("username", "unknown user")

字典的keys()方法返回由所有关键字组成的列表:

k =a.keys()   #k =["username","home","uid","shell"]

del语句可以删除字典中的特定元素:

dela["username"]

1.9. 函数

在Python中，使用def语句来创建函数，如下例:

def remainder(a,b):
    q = a/b
    r = a - q*b
    return r

要调用一个函数，只要使用函数名加上用括号括起来的参数就可以了。比如result =remainder(37,15),如果你打算让函数返回多个值，就让它返回一个元组好了。（当然，只要你愿意，让它返回一个列表我们也不会介意)

def divide(a,b):
    q = a/b
    r = a - q*b
    return (q,r)

当返回一个tuple时，你会发现象下面这样调用函数会很有用:

quotient,remainder = divide(1456,33)

你也可以象下面这样给函数的参数指定一个默认值:

def connect(hostname,port,timeout=300):    #Function body

若在函数定义的时候提供了默认参数，那么在调用函数时就允许省略这个参数：

connect('www.python.org',80)

你也可以使用关键字参数来调用函数,这样你的参数就可以使用任意顺序:

connect(port=80,hostname="www.python.org")

函数内部定义的变量为局部变量，要想在一个函数内部改变一个全局变量的值，在函数中使用global语句:

a =4.5
def foo():
    global a
    a = 8.8 # 改变全局变量a

1.10. 类

Python支持面向对象编程，在面向对象编程中，class语句用于定义新类型的对象。

例如，下面这个类定义了一个简单的堆栈：

class Stack(object):
    def __init__(self): # 初始化栈
        self.stack = [ ]
    def push(self,object):
        self.stack.append(object)
    def pop(self):
        return self.stack.pop()
    def length(self):
        return len(self.stack)

在类定义中,方法用def语句定义。类中每个方法的第一个参数总是引用类实例对象本身，大家习惯上使用self这个名字代表这个参数。不过这仅仅是个习惯而已，如果你愿意也可以用任意的别的名字。不过为了别人容易看懂你的程序，最好还是跟随大家的习惯。类的方法中若需要调用实例对象的属性则必须显式使用self变量(如上所示)。方法名中若前后均有两个下划线，则表示这是一个特殊方法，比如init方法被用来初始化一个对象(实例)。

象下面这样来使用一个类:

s =Stack()    # Create a stack (创建)
s.push("Dave")# Push some things onto it (写入)
s.push(42)
s.push([3,4,5])
x =s.pop()    # x gets [3,4,5] (读取)
y =s.pop()    # y gets 42
del s          # Destroy s (删除)

1.11. 异常

如果在你的程序发生了一个错误，就会引发异常(exception),你会看到类似下面的错误信息:

Traceback(most recent call last):
File"<interactive input>", line 42, in foo.py
NameError:a

错误信息指出了发生的错误类型及出错位置，通常情况下，错误会导致程序终止。不过你可以使用 try 和 except 语句来捕获并处理异常:

try:
    f = open("file.txt","r")
exceptIOError, e:
    print e

上面的语句表示：如果有IOError 发生，造成错误的详细原因将会被放置在对象 e中，然后运行 except 代码块。 若发生其他类型的异常，系统就会将控制权转到处理该异常的except 代码块，如果没有找到该代码块，程序将运行终止。若没有异常发生，except代码块就被忽略掉。

raise语句用来有意引发异常，,你可以使用内建异常来引发异常，如下例:

raise RuntimeError, "Unrecoverable error"

当然，你也可以建立你自己的异常。

1.12. 模块

当你的程序变得越来越大，为了便于修改和维护，你可能需要把它们分割成多个相关文件。 Python允许你把函数定义或公共部分放入一个文件，然后在其他程序或者脚本中将该文件作为一个模块导入。要创建一个模块，把相应的语句和定义放入一个文件，这个文件名就是模块名。(注意:该文件必须有.py后缀)：

# file: div.py
def divide(a,b):
    q = a/b
    r = a - q*b
    return (q,r)

要在其它的程序中使用这个模块，使用import语句:

import div
a, b =div.divide(2305, 29)

import语句创建一个新的名字空间，该空间包含模块中所有定义对象的名称。要访问这个名字空间，把模块名作为一个前缀来使用这个模块内的对象，就像上边例子中那样:div.divide()

如果你希望使用一个不同的模块名字访问这个模块，给import语句加上一个 as 模块名 部分就可以了:

importdiv as foo
a,b =foo.divide(2305,29)

如果你只想导入指定的对象到当前的名称空间,使用 from语句:

from div import divide
a,b =divide(2305,29)     #不再需要div前缀

导入一个模块中的所有内容到当前的名称空间:

fromdiv import *

最后，内建函数dir()可以列出一个模块中的所有可访问内容。当你在python交互环境中测试一个模块的功能时，这会是一个很有用的工具，因为它可以提供一个包含可用函数及变量的列表:

>>>import string
>>>dir(string)
['__builtins_ _', '_ _doc_ _', '_ _file_ _', '_ _name_ _', '_idmap',
'_idmapL','_lower', '_swapcase', '_upper', 'atof', 'atof_error',
'atoi','atoi_error', 'atol', 'atol_error', 'capitalize',
'capwords','center', 'count', 'digits', 'expandtabs', 'find',]