Python语法

1、Python基本类型

1.1数值

解释器的行为就像是一个计算器。你可以向他输入一个表达式，它会返回结果。

>>>2+2

4

等号（“=”）用于给变量赋值，被分配的值是只读的。

>>>width = 20

>>>height = 5*9

>>>width*height

900

同一个值可以同时赋给几个变量：

>>>x=y=z=0

>>>x

0

1.2字符串

字符串用单引号或双引号标识：

>>>'hello'

hello

>>>'"Yes",he said.'

"Yes",he said.

1.3None类型

None类型是一个特殊的类型，表示出错。

逻辑表达式：Python中没有Boolean类型，除了0以外，其他都是真。但是Python中‘假’有很多种，包括None，0，0.0，“”（空字符串），[]（空list），()（空元组），{}（空字典）。

Python中的逻辑运算符有：and，or，not

1.4链表（列表list）

python中最通用的是链表，他写为中括号之间用逗号分隔的一列值（子项），链表的子项不一定是同一类型的值。

>>>a = ['me','she',100,200]

>>>a

['me','she',100,200]

   0      1     -1     0

链表也以零开始，可以被切片、连接等等：

>>>a = ['me','she',100,200]

>>>a[0]

'me'

>>>a[3]

100

>>>a[-2]

100

>>>a[1:-1]

['she',100]

>>>a[:2]+['he',2*2]

['me','she','he',4]

1.5元组（Tuples）

一个元组由数个逗号分隔的值组成，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有都可以，不过经常括号都是必须的（如果元组是一个更大的表达式的一部分）。

>>>t=12345,54321,'hello'

>>>t[0]

12345

>>>t

(12345,54321,'hello')

>>>u=t,(1,2,3,4,5)

>>>u

((12345,54321,'hello'),(1,2,3,4,5))

1.6字典（Dictionary）

字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。理解字典的最佳方式是把他看作无序的关键字：值（key:value pairs）对集合，关键字必须是互不相同的（在同一个字典之内）。一对大括号创建一个空的字典：{}。

>>>tel = {'Jack':123456,'Tom',654321}

>>>tel['Cherry']=666666

>>>tel

{'Jack':123456,'Tom',654321,'Cherry',666666}

2、Python程序流程

2.1if语句-语法格式

if<expr1>:<one_line_statement>

 

if<expr1>:

  <statement_block>

 

if<expr1>:

  <statement_block>

else:

  <statement_block>

 

if<expr1>:

  <statement_block>

elif<expr2>:

  <statement_block>

elif<expr3>:

  <statement_block>

...

else:

  <statement_block>

if语句-----使用说明

1. if后面的表达式可以是任何表达式，除了None，0，“”（空字符串），[]（空list），()（空元组），{}（空字典）以外，其他都是真的。
2. 表达式以冒号分隔
3. 若是一行的简单表达式，可以直接跟在冒号后面
4. 若是多行的表达式，就要使用缩进的方式，表示一组语句。python认为同样缩进长度的语句是一组
5. python中没有switch语句，使用elif来完成这个功能
6. else表示条件不满足时应该执行的语句，比忘了后面的冒号

2.2 for循环语句----语法格式

for x in <sequence>:#它的for语句竟然有else

  <statement_block>

else:

  <else_block>

for循环语句-----使用说明

1. sequence表示任何string，tuple，dictionary
2. break语句可以强制退出循环
3. continue语句可以继续执行下一次循环
4. else语句是可有可无的。若有，则表示如果每个序列中的元素都循环到了，那么就执行else-block
5. else语句可以理解为，如果循环没有被break语句强行中断，或者说循环正常结束后，就会执行else中的语句

2.3 while循环语句----语法格式

while <exprl>:#for和while竟然都有else

    <block>

else:

    <else-block>

while循环语句-----使用说明

1. 只要exprl是真，那么就一直执行block中的语句
2. 如果没有break跳出循环，也就是exprl为假的时候，执行else-block中的语句

2.4 break和continue语句，以及循环中的else子句

1. break语句和C中的类似，以及循环中的else子句
2. continue语句是从C中借鉴来的，它表示循环继续执行下一次迭代
3. 循环可以有一个else子句；它在循环迭代完整个列表（对于for）或执行条件为false（对于while）时执行，但循环会被break中止的情况下不会执行。

2.5 pass语句

pass语句什么也不做。它用于那些语法上必须要有什么语句，但程序上什么也不要做的场合，例如：

>>>while True:

...   pass      #Busy-wait for keyboard interrupt...

3、python函数

3.1 函数定义

def <function_name>(<parameters_list>):

      <code block>

说明：

1. function_name是函数名称，冒号用来分隔函数的内容
2. Parameters_list是列表参数。参数也没有类型，可以传递任何类型的值给函数，由函数的内容定义函数的接口。如果传递的参数类型不是函数想要的，那么函数可以抛出异常。
3. code block是和if，while一样的代码，应该有相同的缩进。
4. 函数没有返回值类型，return可以返回任意类型

3.2 函数参数默认值

最有用的形式是给一个或多个参数指定默认值。这样创建的函数可以在调用时使用更少的参数。默认参数: retries=4 这种形式：

def ask_ok(prompt,retries=4,complaint='Yes or no,please!'):

    while True:

    ok = input(prompt)#在 Python3.x 中 raw_input( ) 和 input( ) 进行了整合，去除了 raw_input( )，仅保留了 input( ) 函数，其                                   #接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

    if ok in ('y','ye','yes'):return 1

    if ok in ('n','no','nop','nope'):return 0

    retries = retries - 1

     if retries < 0:

         raise IOError('refusenik user')

     print complaint

    调用的时候:
    只给出必要的参数: ask_ok('Do you really want to quit?')
    给出一个可选的参数: ask_ok('OK to overwrite the file?', 2)
    或者给出所有的参数: ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')
  （运行的时候compliant出不来）
    默认参数的特点:
    重要警告: 默认值只被赋值一次。这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例。
    例如，下面的函数在后续调用过程中会累积（前面）传给它的参数:

    def f(a, L=[]):
        L.append(a)
        return L

    print f(1)
    print f(2)
    print f(3)
    这将会打印:

    [1]
    [1, 2]
    [1, 2, 3]
    如果你不想在随后的调用中共享默认值，可以像这样写函数:

    def f(a, L=None):
        if L is None:
            L = []
        L.append(a)
        return L

3.3 函数参数关键字

函数可以通过参数关键字的形式来调用，形如“keyword = value”，例如以下的函数：

def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):

    print("--This parrot wouldn't",acition)

    print("if you put",voltage,"Volts through it.")

    print("--Lovely plumage,the",type,"--It's",state,"!")

可以用以下的任一方法调用：

parrot(1000)

parrot(action = 'VOOOM',voltage = 100000)

parrot(voltage = 100000,state = 'pushing up the daisies') 

函数参数关键字

1. 参数列表中的每一个关键字都必须来自于形式参数，每个参数都有对应的关键字
2. 形式参数有没有默认值并不重要
3. 实际参数不能一次赋多个值
4. 形式参数不能再同一次调用中同时使用位置和关键字绑定值

3.4 函数可变参数列表

一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装进一个拓扑。在这些可变个数的参数之前，可以有领导多个普通的参数：(这个没有懂具体怎应用)

def fprintf(file,format,*args):

    file.write(format%args)

3.5 嵌套函数

这种机制提供了一个函数范围的概念，某些函数只在某些函数的内部才能看到。如果需要公开的话，可以 通过返回值返回内部函数。

>>> def outfun(a,b):

...        def innerfun(x,y):

...        return x+y

...        return innerfun(a,b)

3.6 lambda关键字

通过lambda关键字，可以创建很小的匿名函数。这里有一个函数返回它的两个参数的和：“lambda a,b:a+b”。Lambda形式可以用于任何需要的函数对象。出于语法限制，它们只能有一个单独的表达式。语义上讲，它们只是普通函数定义中的一个语法技巧。类似于嵌套函数定义，lambda形式可以从包含范围内引用变量：

>>> def make_invrementor(n):

       return lambda x:x+n...

>>>f = make_invrementor(42)#默认初始值x = 0

>>>f(0)

42

>>>f = lambda a,b:a+b

>>>f(1,2)

3

>>>f("abc","def")

'abcdef'

3.7 DocString函数描述

>>> 文档字符串（DocString函数描述）

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')
printMax(3, 5)
print(printMax.__doc__)

输出：5 is maximum
Prints the maximum of two numbers.#最后才输出文档字符串

The two values must be integers.

4、python类

4.1 类定义

定义一个类的时候，会创建一个新的命名空间，将其作为局部作用域使用----因此，所有对局部变量的赋值都引入新的命名空间。特别是函数定义将新函数的命名绑定与此。

class ClassName:

<statement-1>

...

<statement-N>

4.2 类对象引用

类对象支持两种操作：属性引用和实例化。

属性引用使用和python中多有的属性引用一样的标准语法：obj.name。类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义使这样：

class Myclass:

    "A simple example class"

    i = 12345

    def f(self):

        return 'hello world'

那么 Myclass.i和Myclass.f是有效的属性引用，分别返回一个整数和一个方法对象。

4.3 类的实例化

类的实例化使用函数符号。只要将类对象看作是一个返回新的类实例的无参数函数即可。例如：

>>>x = Myclass()

以上创建了一个新的类实例并将该对象赋给局部变量x。这个实例化操作创建了一个空的对象。创建为有初始状态的类可以通过定义一个名为_init_()的特殊方法来实现，像下面这样：

def _init_(self):

    self.data = []

类定义了_init_(）方法的话，类的实例化操作会自动为新建的类实例调用_init_()方法。

4.4 类的继承

如果一种语言不支持继承，“类”就没有意义。派生类的定义如下所示：

class DerivedClassName(BaseClassName);

<statement-1>

...

<statement-N>

命名BaseClassName(实例中的基类名)必须与派生类定义在一个作用域内。

4.5 类的多继承

python同样有限的支持多继承形式。多继承的类定义如下例：

class DerivedClassName(Base1,Base2,Base3);

<statement-1>

...

<statement-N>

这里唯一需要解释的语义是解析类属性的规则。顺序是深度优先，从左到右。

5、python模块和包

5.1 模块（Module）

一个module不过是一些函数，class放在一个*.py文件中，例如test.py:

"""

this is only a very simple module

"""

age = 0#a sample attribute

def sayHello():#a sample function in a module

print "Hello"

if _name_=="_main_"

sayHello()

5.2 包（Package）

Package是一组module的集合，用以下方法创建一个package。

1. 在当前目录下创建一个目录testpackage；
2. 在testpackage目录中创建一个空文件_init_.py;
3. 在testpackage目录中创建一个testpackage.py文件，里面含有一些代码。

             >>>import testpackage.testmodule

             >>>testpackage.testmodule.sayHello()

                   Hello

Package是一种组织module的方法，提供了一个name space，防止发生名称冲突。

5.3 命名空间（name space）

命名空间是从命名到对象的映射。以下有一些命名空间的例子：内置命名（想abs()这样的函数，以及内置异常名）集，模块中的全局命名，函数调用中的局部命名。某种意义上讲对象的属性集也是一个命名空间。关于命名空间需要了解的一件很重要的事就是不同命名空间中的命名没有任何联系，例如两个不同的模块可能都会定义一个名为“maximize”的函数而不会发生混淆----用户必须以模块名为前缀来引用它们。

不同的命名空间在不同的时刻创建，有不同的生存期。包含内置命名的命名空间在python解释器启动时创建，会一直保留，不会删除。

5.6一些常用的语法

一定要理解这句话（包括数字、字符串与函数、变量(叫对象变量)）

java中的构造函数的名字是与类名相同的，这点与python不同，python默认把__init__看作构造函数。