python学习记录

python学习

本文是关于python的学习记录文章。比较基本,比较潦草

python运行顺序

1. 当运行某个文件的时候，则该文件中内置变量 __name__ 就会等于__main__，所以很多文件都会有这样的代码：

if __name__ == "__main__":

2. 在一个文件中，函数（那些def定义的）只有被调用的时候才会执行。其余的没有缩进的代码会开始执行。换句话说整个py文件的运行是顺序执行的。当执行到定格写的if __name__ == “__main__”:则会再进行以后的函数调用。
3. __name__是python的内置变量，用来表示程序的名称。这个变量语法上可以被修改，修改之后注意不能通过判断是否为__main__来执行。类似的内置变量还有：

【暂未实验】
__file__ 表示文件路径
__package__ ：获取导入文件的路径，多层目录以点分割，注意：对当前文件返回None
__cached__ ：获取导入文件的缓存路径
__name__ ：获取导入文件的路径加文件名称，路径以点分割，注意:获取当前文件返回__main__ 
__name__  全局变量写在入口文件里，只有执行入口文件时的返回值才是__main__ ，如果入口文件被导入到别的文件里，此时入口文件的__name__返回值为模块名称
__builtins__ 【重点】内置函数在这里面

4. 所以那些全局变量，不管定义在哪个函数前面或者后面，按照顺序是有可能先于函数执行的。

类的使用

类与实例
总结如下：

1. 定义格式class 类名(继承类名)： 。当没有父类时则使用object。所有的类最终都会继承到这个object类上。
2. 其中有一个__init__函数相当于C++中的构造函数。当创建对象的时候则会直接调用__init__函数。

class Cat(object):
    def __init__(self):
        print("in construct Cat")
    def eat(self):
        print("in eat")
if __name__ == "__main__":
    print("in main.py")
    cat = Cat()
【输出】
in main.py
in construct Cat

3. 类中函数第一个参数必须为self表示实例本身，self指向对象本身。相当于C++中的this指针。在有了__init__之后创建实例的时候就需要依照函数的参数来创建实例。self不需要传，python会自动把实例传入。
4. 实例中的变量个数并不是固定的，也就是说，可以在类外面进行其他参数的赋值。但是注意函数的调用的问题

class Cat(object):
    def __init__(self, name):
        self.name = name
        print("in construct Cat")
    def eat(self):
        print("{} is eatting".format(self.name))
    def others(self):
        print("other arg is {}".format(self.test1)) 
if __name__ == "__main__":
    print("in main.py")
    cat1 = Cat("kite")
    cat1.test1="test1"   //给cat1加了一个test1的成员
    cat1.others()
    print("---------")
    cat2 = Cat("jhone")
    cat2.test2="test2"  //给cat2加了一个test2的成员
    #cat2.others()   //只要不执行这条语句就不会报错，因为cat2中并没有这个test1的成员。

5. 在python3.7之后对类的构造函数进行了简化：(暂未实验)

模块导入import

python中模块间可以相互导入

1. 使用import来导入模块。可以使用import <模块名>来导入整个模块，模块名就是那个文件*.py省略了后缀py。那么在后续使用整个导入模块中的函数的时候需要使用模块名.函数名的方式来调用。如下：

import test1   //同级目录下有一个test1.py的文件
def module1 ():
    test1.modl1_sub1()
    return "in test1.py module1"

2. import导入模块会导入所有的函数，为了简便，可以只导入某个函数，那么就可以直接使用：

from test1 import modl1_sub1
def module1 ():
    modl1_sub1()
    return "in test1.py module1"

3. 还可以重命名

from test1 import modl1_sub1 as sub1
def module1 ():
    sub1()
    return "in test1.py module1"

4. 使用import语句并不一定要在文件头部。在任何一个位置都是可以的。只要在调用之前即可。这里说的调用之前是执行之前，并不是代码的先后顺序：

def module2():
    print("in main.py module2")
    print(os.__file__)     //1. 正确使用os模块
#print(os.__file__)    //2. 会报错
import os    //模块导入
print(os.__file__)     //3. 正常使用
if __name__ == "__main__":
    print("in main.py")
    print(os.__file__)    //4.正常使用
    module2()
【注释】
5. 在其中导入了模块os。
6. 整个文件的有关os的执行顺序是：2,3,4,1。模块导入时间是在2与3之间，所以2会报错，341正常执行。

5. 模糊导入，可以通过通配*的方式导入多个包

from test1.test1 import *
if __name__ == "__main__":
   print("in main.py")
   test1_module1()   //是 test1.test1中的函数
   test1_module2()  //是test1.test1中的函数

不同级模块导入

当前目录结构如下：

.
├── main.py  
├── test1
│   └── test1.py
└── test1.py

1. 主目录下有一个main.py的文件，同级目录下有一个test1.py的文件。在本目录下有一个test1的文件夹，这个文件夹名为test1，test1文件夹下有有一个test1.py。
2. 那么在main.py中想要导入test1/test1.py下的模块可以这样使用：

1. 首先这个下级目录test1下创建一个空白的__init__.py文件（可以书写内容）。有了__init__文件那么整个文件夹会被看做一个整体的package。
2. 之后就可以通过from test1 import test1的方式表示从test1整个package（文件夹）中导入test1这个文件。也可以使用from test1.test1 import test1_module1来导入特定的函数。

模块导入的重名问题：

1. 在main中同时导入test1/test1.py 和test1.py，也就是文件与包重名了。这样是会出问题的，包会覆盖文件的名字：也就是/test1/这个目录会覆盖test1.py这个文件。无法再导入test1.py中的内容了。
2. 如果是多个文件中的函数重名，那么可以使用import … as 的方法。

注意的点

1. 当import的时候，也会顺序执行这个模块。此时模块中__init__就不再是main而是模块名。
2. 顺序执行的意思是如果这个模块有其他可以执行的语句那么也会执行：

[test1.py]内容如下：
def modl1_sub1():
        print("in test1.py ,modul1, sub1")
print("in test1.py, global print")
if __name__ =="test1":
    print("hit name test1")
那么当在另一个模块中使用 from test1 import modl1_sub1 as sub1 时
另一个模块中导入的位置会输出:
in test1.py, global print
hit name test1  //也说明了在调用的时候名字是test1，而不是main。 

修饰器

参考链接为：修饰器
修饰器的关键字就是@，其使用方法总结如下：

1. funcA使用funcB修饰，则相当于执行funcA= funcB(funcA)。这个时候funcA的功能已经改变了。举个例子：

def modultest(test_func):
    def test():
        start_time = time.clock()
        a = test_func()
        end_time = time.clock()
        print("start_time: ", start_time, "end_time:", end_time)
        return a
    return test

@modultest
def module1 ():
    print("in test1.py, module1")
    return "in test1.py module1"

if __name__ == "__main__":
    print("in main.py")
    print("--------")
    mdl1 = module1()  //相当于module1=modultest(module)     mdl1=modul1()
    print("--------")
    print(mdl1)
    print("--------")

运行结果为：

in main.py
--------
in test1.py, module1
start_time:  0.042103 end_time: 0.042109
--------
in test1.py module1

正则表达式