python语法笔记（一）

1. python中多个函数或者类定义可以放在一个.py 文件中，视为一个模块。模块的.py文件中，一般要写 if __name__ == '__mian__' 用来单独执行该模块内的某些函数。

2. python多个模块放在同一个文件夹中，并在文件夹中新建一个 __init__.py 文件，则该文件夹就可以形成一个包。__init__.py 文件就是告诉python解释器该文件夹为一个包，__init__.py 中内容可以为空。

3. 在python文件中可以import某个包，某个包中得某个模块，某个模块，某个模块中的某个类或者函数，比如;

import pack1  
#这样在使用pack1中的模块或者其他东西，需要在模块名前写明 pack1

import pack1.module1
#在使用module1时，需要写pack1.module1.xxx

import module1 from pack1
#这样，在使用module1时，可以不用写pack1，只写 module1.xxx

import module1.classA
#在使用classA的时候，需要写明 module1.classA

import classA from module1
#使用classA的时候，只需要 classA

import module1.func1
#使用func1的时候，需要写 module1.func1

import func1 from module1
#使用func1的时候，只需要写 func1


####注意，以上都是默认命名空间不会发生冲突，即不会出现这种情况：
# module1和module2中都有classA，且同时 import classA from module1， import classA from #module2，因为这样会出现冲突

 4. python程序执行的时候，包和模块的搜索路径为：

（1）当前文件夹

（2）系统变量PYTHONPAHTH 定义的路径

（3）python标准库的安装路径

5. python函数传递参数的方式可以有如下几种方式：

（1）位置传递参数

即传递进去的参数顺序和函数定义的顺序一致，如果有默认参数，则默认参数要放在最后的位置

（2）关键字传递参数

即调用函数的时候，写明 func（arg1 = real_arg1, arg2 = real_arg2..），即形参和实参明确对应，此时，实际参数的顺序就不必按照函数定义时的参数顺序来写。

位置传递参数和关键字传递参数可以混用，但是位置传递的参数需要放在关键字传递的参数之前，比如 func(real_arg1, arg2 = real_args, arg3 = real_arg3....)

（3）包裹传递

类似c语言的非定项参数，有两种传递方式，

（1）通过元组来传递，函数的定义为：

def func(*args):

　　xxxx

实际调用的时候：

func(1,2,3,4) #1，2，3，4自动包装成了一个元组

（2）通过字典来传递，函数定义为：

def func(**args):

　　xxxx

实际调用的时候：

func(a='hello' , b = 'world', c = 123) #参数自动封装成了一个字典 {'a':'hello', 'b':'world', 'c':123}

（4）解包裹传递

若函数定义的时候的参数为多个，而我们想要将一个元组或者一个字典的各个元素分别作为函数的多个参数，则将元组或者字典作为参数传给函数的时候，可以：

def func(a, b, c):

　　xxx

调用的时候：

t = (1,2,3)

func(t)

t2 = {'a':1, 'b':23, 'c':'hello world'}

func(t2)  #将字典的键值对分别作为各个参数

 

在定义或者调用参数时，参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是，先位置，再关键字，再包裹位置，再包裹关键字，并且根据上面所说的原理细细分辨。

注意：请注意定义时和调用时的区分。包裹和解包裹并不是相反操作，是两个相对独立的过程。

 6. 数组、列表、元组的遍历

（1）range(start, end, step) 自动生成一个列表，范围为 [start, end), 间隔为step， 注意区间为左闭右开。

（2）enumerate(x) #x为列表或者元组，对于每次迭代，返回 index， value 元组，index为下标，而value为x内的下标为index的对应的数值

for (index, value) in enumerate(x):

　　print index, value

（3）zip(x1, x2...)

如果有多个列表x1,x2.... 每个序列的元素个数相同，可以通过zip来迭代取出所有序列的相同位置的元素。

ta = [1,2,3]
tb = [9,8,7]
tc = ['a','b','c']
for (a,b,c) in zip(ta,tb,tc):
    print(a,b,c)

7. python的函数修饰符

函数修饰符是一种类型的函数，它以一个函数为参数，并返回一个可调用的对象，该可调用对象对参数的函数进行封装。常常在函数定义前 写明 @ 修饰符，比如

先定义一个修饰符 decorator1,

def decorator1(f):
　　def _real_exe_func_():
　　　　print '..........'　　
　　　　f() #调用参数中的函数f
　　return _real_exe_func_ #返回一个可调用对象，而不是 _real_exe_func_() 执行函数

@decorator1  #使用修饰符修饰func1，实际效果等同于 func1 = decorator1(func1)
def func1():
　　print 'in func1'

func1() #调用func1的结果为，
.......
in func1

如果被修饰的各个函数有不同的参数，则可以这样做：

#func1 和 func2 函数的参数不同，现在要用同一个装饰器来修饰他们
def func1( lst1, lst2 ):
    # 合并两个list，并打印各项
     for item in lst1+lst2:
        print item

def func2( dic ):
    # 循环dict，打印各key-value
     for k, v in dic.items():
         print k, v


    import sys
    import traceback
    def de( f ):
        def _call( *args, **kwargs ):
            try:
                return f( *args , **kwargs )
            except:
                print 'param type error'
        return _call
    @de
    def func1( lst1, lst2 ):
        for item in lst1+lst2:
            print item
    @de
    def func2( dic ):
        for k, v in dic.items():
            print k, v
    if name = '__main__':
        func1( [1,2], [3,4] )
        func2( [1,2] )

 8.python的类中变量、函数的特殊命名--意义

（1） _xx 以单下划线开头的表示的是protected类型的变量。即保护类型只能允许其本身与子类进行访问。若内部变量标示，如： 当使用“from M import”时，不会将以一个下划线开头的对象引入。

（2） __xx 双下划线的表示的是私有类型的变量。只能允许这个类本身进行访问了，连子类也不可以用于命名一个类属性（类变量），调用时名字被改变（在类FooBar内部，__boo变成_FooBar__boo,如self._FooBar__boo）

（3） __xx__定义的是特列方法。用户控制的命名空间内的变量或是属性，如__init__ , __import__

或是__file__ 。只有当文档有说明时使用，不要自己定义这类变量。 （就是说这些是python内部定义的变量名）

 

9. python 使用@property

面向对象的语言几乎都会注重类的封装，比如get和set一个类中的成员变量，为了保证封装性，都会在类中定义针对该变量的get和set方法，这样在外部必须调用get和set方法才可以对变量进行获取和设置。而无法直接使用 对象名.变量名 的形式来对变量进行获取和赋值。在python中可以通过@property 和 @变量名.setter 装饰器来修饰 变量的get和set方法，这样在外部获取和设置对象中的变量的时候，就可以直接使用对象名.变量名的形式。

class Student(object):

    def get_score(self):
        return self._score  #_score, protected variable

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

s = Student()
s.get_score()
s.set_score(10)

通过@property和 @score.setter的修饰如下：
class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

s = Student()
s.score
s.score = 100