采菊东篱下，Python满乾坤！

在任何一个行业确保有最新的工作技能很重要，而在日新月异的IT界尤为重要，因为过去学到的技术和实践可能再也不是今天完成工作所需的技能和实践了。不管你何时或如何学得IT技能——无论通过正规的大学学位课程、强化培训班，还是完全通过自学并获得证书，对比一下你目前的技能与眼下IT工作所需的技能是个好主意。为此，不妨看一看你可能还没有掌握，但在未来十年事关IT工作成败的五大专长领域。1. IT安全...

1.import   搜索路径import   sys sys.path路径搜索从上⾯列出的⽬录⾥依次查找要导⼊的模块⽂件   '   '   表示当前路径程序执⾏时导⼊模块路径sys.path.append('/home/itcast/xxx')sys.

作⽤域test.py    num    =    200 def   print_num():print("----print_num    func,    num=%d----"%num)main.py    from    test    import    * num    =   

1.    浅拷贝  copy.copy浅拷贝是对于⼀个对象的顶层拷贝通俗的理解是：拷贝了引⽤，并没有拷贝内容浅拷贝只复制第一层数据，更深层的引用不管。 2.    深拷贝   copy.deepcopy深拷贝是对于⼀个对象所有层次的拷贝(递归) 、 3.   注意点

迭代是访问集合元素的⼀种⽅式。迭代器是⼀个可以记住遍历的位置的对象。迭代器对象从集合的第⼀个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。1.可迭代对象我们已经知道可以对list、tuple、str等类型的数据使⽤for...in...的循环语法从其中依次拿到数据进⾏使⽤，我们把这样的过程称为遍历，也叫迭代。但是，是否所有的数据类型都可以放到for..

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使⽤next()函数来获取下⼀条数据。iter()函数实际上就是调⽤了可迭代对象的   __iter__   ⽅法。>>>    li    =    [11,    22,    33,    44,    55]>>>

迭代器是⽤来帮助我们记录每次迭代访问到的位置，当我们对迭代器使⽤next()函数的时候，迭代器会向我们返回它所记录位置的下⼀个位置的数据。实际上，在使⽤next()函数的时候，调⽤的就是迭代器对象的    __next__   ⽅法（Python3中是对象的    __next__   ⽅法，Python2中是对象的next()⽅法）。所以，我们要想构造⼀个迭代器，就要实现它的   

for循环工作本质for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调⽤next()⽅法来获取下⼀个值并将其赋值给item，当遇到StopIteration的异常后循环结束。li = [100, 200, 300]# for num in li:#     p

classMyList(object):    """自定义的可迭代对象,迭代器容器"""    def __init__(self):        self.container = []        self.i = 0     def add(self, item):        """向对象中添加数据"""        self.container

1.迭代器的应用场景 1).  如果数列的数据规模巨大2).  数列有规律，但是依靠列表推导式描述不出来 2.数学中有个著名的斐波拉契数列（Fibonacci），数列中第⼀个数0，第⼆个数1，其后的每⼀个数都可由前两个数相加得到：0,    1,    1,   2,    3,    5,   8,    13,    21,   34,    ...现在我们

利⽤迭代器，可以在每次迭代读取数据（通过next()⽅法）时按照特定的规律进⾏⽣成。但是我们在实现⼀个迭代器时，关于当前迭代到的状态需要我们⾃⼰记录，进⽽才能根据当前状态⽣成下⼀个数据。为了达到记录当前状态，并配合next()函数进⾏迭代使⽤，我们可以采⽤更简便的语法，即⽣成器(generator)。⽣成器是⼀类特殊的迭代器。 创建⽣成器⽅法1要创建⼀个⽣成器，有很多种⽅法。第⼀种⽅法

定义一个函数，在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包。闭包具有提高代码可复用性的作用。1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存修改外部函数中的变量：

Python   使⽤    LEGB    的顺序来查找⼀个符号对应的对象locals    ->   enclosing    function    ->   globals    ->    builtins局部变量———闭包空间———全局变量———内建模块a    =   1       #   全局变量   globalsdef   fun(

def itcast1(fun):     def inner(*args, **kwargs):        print("itcast1 start")       # args ->元组数据()        #kwargs ->字典数据{}         #result用来接收被装饰函数的返回值        result = fun(*

使⽤装饰器时，有⼀些细节需要被注意。例如，被装饰后的函数其实已经是另外⼀个函数了（函数名等函数属性会发⽣改变）。添加后由于函数名和函数的doc发⽣了改变，对测试结果有一定影响！import functools def itcast1(fun):     #带参数的装饰器    #wraps是用来将inner函数的属性设置为fun的属性值   @functools

class Foo(object):    pass obj = Foo() # 添加对象属性(对象名追加对象属性）obj.a = 100# print(obj.a) # 添加类属性（类名称追加类属性）Foo.b = 200 # print(Foo.b)# print(obj.b) # 添加对象方法def obj_fun(self):

为了达到限制的⽬的，Python允许在定义class的时候，定义一个特殊的 __slots__变量，来限制该class实例能添加的属性：class Foo(object):    __slots__ = ("a", "b")   # 限制动态使用对象名添加东西（属性、方法）的名字 obj = Foo()obj.a = 100 # print(obj.a) 

1、xx:   公有变量2、_x:   单前置下划线,私有化属性或⽅法，from  somemodule import * 禁止导入,类对象和⼦类可以访问。3、__xx：双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到）4、__xx__:双前后下划线,用户名字空间的魔法对象或属性。例如:    __init__        ,

class Bank(object):    def__init__(self):       self.__money = 100     @property    defmoney(self):        returnself.__money        #raise AttributeError("该属性不支持读取操作")    # 如果只提

元类就是类的类，type就是Python中创建所有类的元类。type就是创建类对象的类。Python中所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，并且它们都是从一个类创建来，这个类就是type。# class Foo(object):#     a = 100# #对于上面声明类的代码，实际上是由type帮助我们创建了类，具体可以理解为下面的过程#

1.   小整数对象池Python   对⼩整数的定义是[-5,   256]   2.   大整数对象池每⼀个⼤整数，均创建⼀个新的对象。a = 100b = 100# print(a is b)True #代码块c = 1000d = 1000print(c is d) # True class Foo(object)

当引⽤计数为0时，该对象⽣命就结束了。引⽤计数机制的优点：1、简单2、实时性：⼀旦没有引⽤，内存就直接释放了。不⽤像其他机制等到特定时机。实时性还带来⼀个好处：处理回收内存的时间分摊到了平时。引⽤计数机制的缺点：1、维护引⽤计数2、消耗资源循环引⽤list1    =   [] list2    =   [] list1.ap

1.__getattribute__属性访问拦截器（内建属性 class Foo(object):    def __init__(self):        self.a = 100     def __getattribute__(self, name):        if name == "a":            # return self.a  #

集合与之前列表、元组类似，可以存储多个数据，但是这些数据是不重复的集合对象还⽀持union(联合),    intersection(交),    difference(差)和sysmmetric_difference(对称差集)等数学运算.>>>    x    =    set('abcd')>>>    x{'c',    'a',  

导入模块：import os 1.程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），复制父进程信息2.子进程从fork（）函数中得到返回值零3.父进程从fork（）函数中得到返回值子进程的id4.fork（）函数调用一次，返回两次5.一个父进程可以fork出很多子进程6.子进程调用自己id用函数getpid（）7.子进程调用父进程的id用函数

1.os.wait()回收资源   os.wait()方法用来回收子进程占用的资源： import osimport time ret = os.fork()  #创建新的进程 一次调用，两次返回 if ret == 0:    # 子进程执行    #子进程拿到的返回值是0    print("子进程：pid=%d, ppid=%d

1.子进程未运行完父进程就结束运行退出，留下来的子进程就是孤儿进程 2.父进程结束退出，子进程会被继父收回，通常是int进程（pid为1）无危害 import osimport time  ret = os.fork()  #创建新的进程 一次调用，两次返回 if ret == 0:    # 子进程执行    #子进程拿到的返回值是

⼦进程运⾏完成，但是⽗进程迟迟没有进⾏回收，此时⼦进程实际上并没有退出，其仍然占⽤着系统资源，这样的⼦进程称为僵⼫进程。因为僵⼫进程的资源⼀直未被回收，造成了系统资源的浪费，过多的僵⼫进程将造成系统性能下降，所以应避免出现僵⼫进程。 import osimport time ret = os.fork()  #创建新的进程 一次调用，两次返回 if ret

多进程中，每个进程中所有数据（包括全局变量）都各有拥有⼀份，互不影响    (读时共享，写时复制) import osimport time num = 100 ret = os.fork()  #创建新的进程 一次调用，两次返回 if ret == 0:    # 子进程执行    #子进程拿到的返回值是0    print("

multiprocessing模块就是跨平台版本的多进程模块，提供了⼀个Process类来代表一个进程对象 创建⼦进程时，只需要传⼊⼀个执⾏函数和函数的参数，创建⼀个Process实例，⽤start（）方法启动，join()⽅法可以等待子进程结束后再继续运行Process语法结构如下：Process([group   [,    target    [,   name 

from multiprocessing import Process（P必须大写import osimport time classSubProcess(Process):    """创建Process的子类"""    def __init__(self, num, a):        super(SubProcess, self).__init__() #

初始化Pool时，可以指定⼀个最大进程池，当有新进程提交时，如果池还没有满，那么就会创建新进程请求；但如果池中达到最大值，那么就会等待，待池中有进程结束，新进程来执行。非阻塞式：apply_async(func[,        args[,        kwds]])        ：一个程序结束运行新程序，几个任务同时进行 阻塞式：apply(func[,        ar

异步：多任务，多个任务之间执行没有先后顺序，可以同时运行，执行的先后顺序不会有什么影响，存在的多条运行主线 同步：多任务，多个任务之间执行的时候要求有先后顺序，必须一个先执行完成之后，另一个才能继续执行，只有一个主线 阻塞：从调用者的角度出发，如果在调用的时候，被卡住，不能再继续向下运行，需要等待，就说是阻塞 非阻塞：从调用者的角度出发，如果在调

Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。 multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序 初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；Queue.qsiz

进程是操作系统分配资源的最小单位 线程是操作系统调度执行的最小单位 定义的不同进程是系统进行资源分配的最小单位.线程是进程的一个实体,是CPU进行调度的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用 创建多线程：from threading import Threadimport time def sing():    for i in range(3):        print("唱歌")        time.sl

在一个进程内的所有线程共享全局变量，能够在不适用其他方式的前提下完成多线程之间的数据共享（这点要比多进程要好）缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全） 案例：from threading import Threadimport time num = 0  #资源竞争问题 deffun1():