看廖雪峰python学习笔记和自己查的关于python的笔记

这次学习python是在学过用过python很久之后二刷学习教程，看的是廖雪峰2.7，确实重复的学习还是不断的有收获，接下来记录一些新学到的知识点

• list中有insert函数，可以直接在指定位置插入

  >>> classmates
  ['Michael', 'Bob', 'Tracy', 'Adam']
  >>> classmates.insert(1, 'Jack')
  >>> classmates
  ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

   

• 函数-函数的参数：可变参数、关键字参数

  def func(a, b, c=0, *args, **kw):
      print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

  *args是可变参数

  **kw是关键字参数

• 递归、栈溢出

• 字符串也可以使用切片操作

  >>> 'ABCDEFG'[:3]
  'ABC'
  >>> 'ABCDEFG'[::2]
  'ACEG'

  如上

• 迭代：字典的迭代

  >>> d = {'a': 1, 'b': 2, 'c': 3}
  >>> for key in d:
  ...     print key
  ...
  a
  c
  b
  
  for value in d.itervalues()
  #迭代value
  
  for k, v in d.iteritems()
  #同时迭代key和value

   

• 列表生成式：这个用得少所以记一下

  >>> [x * x for x in range(1, 11)]
  [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  
  >>> [x * x for x in range(1, 11) if x % 2 == 0]
  [4, 16, 36, 64, 100]
  
  >>> [m + n for m in 'ABC' for n in 'XYZ']
  ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

   

• 函数也可以作为另一个函数的参数：

  def add(x, y, f):
      return f(x) + f(y)
  
  >>> add(-5, 6, abs)
  11

   

• map/reduce：

  >>> def f(x):
  ...     return x * x
  ...
  >>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
  [1, 4, 9, 16, 25, 36, 49, 64, 81]
  
  >>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
  ['1', '2', '3', '4', '5', '6', '7', '8', '9']
  ########################################################
  reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
  
  >>> def add(x, y):
  ...     return x + y
  ...
  >>> reduce(add, [1, 3, 5, 7, 9])
  25
  
  >>> def fn(x, y):
  ...     return x * 10 + y
  ...
  >>> reduce(fn, [1, 3, 5, 7, 9])
  13579

   

• filter：

  def is_odd(n):
      return n % 2 == 1
  
  filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
  # 结果: [1, 5, 9, 15]

  用来实现一个筛选函数

• sorted这个高阶函数可以自定义排序规则

  def cmp_ignore_case(s1, s2):
      u1 = s1.upper()
      u2 = s2.upper()
      if u1 < u2:
          return -1
      if u1 > u2:
          return 1
      return 0
  
  >>> sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)
  ['about', 'bob', 'Credit', 'Zoo']
  以上是忽略大小写排序
  ############################
  def reversed_cmp(x, y):
      if x > y:
          return -1
      if x < y:
          return 1
      return 0
  >>> sorted([36, 5, 12, 9, 21], reversed_cmp)
  [36, 21, 12, 9, 5]

   

• 匿名函数：

  >>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
  [1, 4, 9, 16, 25, 36, 49, 64, 81]

  其实就是lambda

• 装饰器：

  def log(func):
      def wrapper(*args, **kw):
          print 'call %s():' % func.__name__
          return func(*args, **kw)
      return wrapper
  #这里log函数就是一个装饰器
  #下面是在使用这个装饰器
  @log
  def now():
      print '2013-12-25'
  
  >>> now()
  call now():
  2013-12-25
  

  本质上，decorator就是一个返回函数的高阶函数。

  now = log(now)
  

  把@log放到now()函数的定义处，相当于执行了以上语句：（其实我还是没太懂装饰器，遇到了再说吧）

• 偏函数：作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

  >> import functools
  >>> int2 = functools.partial(int, base=2)
  >>> int2('1000000')
  64
  >>> int2('1010101')
  85

   

• 模块：请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是mycompany。

  #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  
  ' a test module '
  
  __author__ = 'Michael Liao'
  
  import sys
  
  def test():
      args = sys.argv
      if len(args)==1:
          print 'Hello, world!'
      elif len(args)==2:
          print 'Hello, %s!' % args[1]
      else:
          print 'Too many arguments!'
  
  if __name__=='__main__':
      test()

  第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码；

  第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；

  第6行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；

  以上就是Python模块的标准文件模板，当然也可以全部删掉不写，但是，按标准办事肯定没错。

• 面向对象如何实现C++中的private：如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问

  class Student(object):
  
      def __init__(self, name, score):
          self.__name = name
          self.__score = score
  
      def print_score(self):
          print '%s: %s' % (self.__name, self.__score)
  
  >>> bart = Student('Bart Simpson', 98)
  >>> bart.__name
  Traceback (most recent call last):
    File "", line 1, in 
  AttributeError: 'Student' object has no attribute '__name'

   

• 继承：

  class Animal(object):
      def run(self):
          print 'Animal is running...'
  
  class Dog(Animal):
      pass
  
  class Cat(Animal):
      pass
  
  dog = Dog()
  dog.run()
  
  cat = Cat()
  cat.run()
  
  Animal is running...
  Animal is running...

   

• dir()：如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

  >>> dir('ABC')
  ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

   

• __slots__：但是，如果我们想要限制class的属性怎么办？比如，只允许对Student实例添加name和age属性

  >>> class Student(object):
  ...     __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
  ...
  
  >>> s = Student() # 创建新的实例
  >>> s.name = 'Michael' # 绑定属性'name'
  >>> s.age = 25 # 绑定属性'age'
  >>> s.score = 99 # 绑定属性'score'
  Traceback (most recent call last):
    File "", line 1, in 
  AttributeError: 'Student' object has no attribute 'score'

   

• 面向对象高级编程这一章看得有点蒙蔽，跳过了很多

• 程序的调试：

  • print：这就是我常用的，很麻烦，到时候还得删除

  • assert：assert的意思是，表达式n != 0应该是True，否则，后面的代码就会出错。

    # err.py
    def foo(s):
        n = int(s)
        assert n != 0, 'n is zero!'
        return 10 / n
    
    def main():
        foo('0')
    
    $ python err.py
    Traceback (most recent call last):
      ...
    AssertionError: n is zero!

    程序中如果到处充斥着assert，和print相比也好不到哪去

  • logging：不懂

  • pdb：让程序以单步方式运行，可以随时查看运行状态。

    # err.py
    s = '0'
    n = int(s)
    print 10 / n
    
    $ python -m pdb err.py
    > /Users/michael/Github/sicp/err.py(2)()
    -> s = '0'
    
    (Pdb) l
      1     # err.py
      2  -> s = '0'
      3     n = int(s)
      4     print 10 / n
    [EOF]
    
    (Pdb) n
    > /Users/michael/Github/sicp/err.py(3)()
    -> n = int(s)
    (Pdb) n
    > /Users/michael/Github/sicp/err.py(4)()
    -> print 10 / n
    
    (Pdb) n
    ZeroDivisionError: 'integer division or modulo by zero'
    > /Users/michael/Github/sicp/err.py(4)()
    -> print 10 / n
    (Pdb) q

    任何时候都可以输入命令p 变量名来查看变量：

  • pdb.set_trace()：这个方法也是用pdb，但是不需要单步执行，我们只需要import pdb，然后，在可能出错的地方放一个pdb.set_trace()，就可以设置一个断点：

    # err.py
    import pdb
    
    s = '0'
    n = int(s)
    pdb.set_trace() # 运行到这里会自动暂停
    print 10 / n
    
    #运行代码，程序会自动在pdb.set_trace()暂停并进入pdb调试环境，可以用命令p查看变量，或者用命令c继续运行：
    $ python err.py 
    > /Users/michael/Github/sicp/err.py(7)()
    -> print 10 / n
    (Pdb) p n
    0
    (Pdb) c
    Traceback (most recent call last):
      File "err.py", line 7, in 
        print 10 / n
    ZeroDivisionError: integer division or modulo by zero

     

• 单元测试：单元测试可以有效地测试某个程序模块的行为，是未来重构代码的信心保证

• 文档测试：就是把测试用例用注释的方式写在代码里了，可以直接进行测试。

• 文件读写：

• 调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示

  >>> f.read()
  'Hello, world!'
  
  with open('/path/to/file', 'r') as f:
      print f.read()

  要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容

• 调用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list

• 二进制文件：视频、图片

• json:如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

  • 把dict编程json：

    >>> import json
    >>> d = dict(name='Bob', age=20, score=88)
    >>> json.dumps(d)
    '{"age": 20, "score": 88, "name": "Bob"}'

    dumps()方法返回一个str，内容就是标准的JSON

  • 对象也可以转化为json

• 多进程

  • fork：

    Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。

    子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

    # multiprocessing.py
    import os
    
    print 'Process (%s) start...' % os.getpid()
    pid = os.fork()
    if pid==0:
        print 'I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())
    else:
        print 'I (%s) just created a child process (%s).' % (os.getpid(), pid)
    
    Process (876) start...
    I (876) just created a child process (877).
    I am child process (877) and my parent is 876.

    返回两次

  • multiprocessing：

    由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。

    multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：

    from multiprocessing import Process
    import os
    
    # 子进程要执行的代码
    def run_proc(name):
        print 'Run child process %s (%s)...' % (name, os.getpid())
    
    if __name__=='__main__':
        print 'Parent process %s.' % os.getpid()
        p = Process(target=run_proc, args=('test',))
        print 'Process will start.'
        p.start()
        p.join()
        print 'Process end.'
    
    #结果如下
    Parent process 928.
    Process will start.
    Run child process test (929)...
    Process end.

    创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。

    join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

  • Pool：

    如果要启动大量的子进程，可以用进程池的方式批量创建子进程：

    from multiprocessing import Pool
    import os, time, random
    
    def long_time_task(name):
        print 'Run task %s (%s)...' % (name, os.getpid())
        start = time.time()
        time.sleep(random.random() * 3)
        end = time.time()
        print 'Task %s runs %0.2f seconds.' % (name, (end - start))
    
    if __name__=='__main__':
        print 'Parent process %s.' % os.getpid()
        p = Pool()
        for i in range(5):
            p.apply_async(long_time_task, args=(i,))
        print 'Waiting for all subprocesses done...'
        p.close()
        p.join()
        print 'All subprocesses done.'
    
    #结果如下
    Parent process 669.
    Waiting for all subprocesses done...
    Run task 0 (671)...
    Run task 1 (672)...
    Run task 2 (673)...
    Run task 3 (674)...
    Task 2 runs 0.14 seconds.
    Run task 4 (673)...
    Task 1 runs 0.27 seconds.
    Task 3 runs 0.86 seconds.
    Task 0 runs 1.41 seconds.
    Task 4 runs 1.91 seconds.
    All subprocesses done.

    请注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在我的电脑上是4，因此，最多同时执行4个进程(这个4是电脑的核数)。这是Pool有意设计的限制，并不是操作系统的限制。

  • 进程间通信：Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

    from multiprocessing import Process, Queue
    import os, time, random
    
    # 写数据进程执行的代码:
    def write(q):
        for value in ['A', 'B', 'C']:
            print 'Put %s to queue...' % value
            q.put(value)
            time.sleep(random.random())
    
    # 读数据进程执行的代码:
    def read(q):
        while True:
            value = q.get(True)
            print 'Get %s from queue.' % value
    
    if __name__=='__main__':
        # 父进程创建Queue，并传给各个子进程：
        q = Queue()
        pw = Process(target=write, args=(q,))
        pr = Process(target=read, args=(q,))
        # 启动子进程pw，写入:
        pw.start()
        # 启动子进程pr，读取:
        pr.start()
        # 等待pw结束:
        pw.join()
        # pr进程里是死循环，无法等待其结束，只能强行终止:
        pr.terminate()
    #结果
    Put A to queue...
    Get A from queue.
    Put B to queue...
    Get B from queue.
    Put C to queue...
    Get C from queue.

    有点蒙

• 多线程：

  • threading：

    import time, threading
    
    # 新线程执行的代码:
    def loop():
        print 'thread %s is running...' % threading.current_thread().name
        n = 0
        while n < 5:
            n = n + 1
            print 'thread %s >>> %s' % (threading.current_thread().name, n)
            time.sleep(1)
        print 'thread %s ended.' % threading.current_thread().name
    
    print 'thread %s is running...' % threading.current_thread().name
    t = threading.Thread(target=loop, name='LoopThread')
    t.start()
    t.join()
    print 'thread %s ended.' % threading.current_thread().name
    #结果
    thread MainThread is running...
    thread LoopThread is running...
    thread LoopThread >>> 1
    thread LoopThread >>> 2
    thread LoopThread >>> 3
    thread LoopThread >>> 4
    thread LoopThread >>> 5
    thread LoopThread ended.
    thread MainThread ended.

    Python的threading模块有个current_thread()函数，它永远返回当前线程的实例。主线程实例的名字叫MainThread，子线程的名字在创建时指定，我们用LoopThread命名子线程。名字仅仅在打印时用来显示，完全没有其他意义，如果不起名字Python就自动给线程命名为Thread-1，Thread-2

  • Lock:多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。Lock是用来确保某段程序某一段时间内只能被一个线程使用（还是不太懂）

  • python 的问题：

    因为Python的线程虽然是真正的线程，但解释器执行代码时，有一个GIL锁：Global Interpreter Lock，任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。

    GIL是Python解释器设计的历史遗留问题，通常我们用的解释器是官方实现的CPython，要真正利用多核，除非重写一个不带GIL的解释器。

    所以，在Python中，可以使用多线程，但不要指望能有效利用多核。如果一定要通过多线程利用多核，那只能通过C扩展来实现，不过这样就失去了Python简单易用的特点。

    不过，也不用过于担心，Python虽然不能利用多线程实现多核任务，但可以通过多进程实现多核任务。多个Python进程有各自独立的GIL锁，互不影响。

• ThreadLocal：不知道在干嘛

• 进程 vs. 线程：

  • 多进程模式最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。著名的Apache最早就是采用多进程模式。

  • 多线程模式通常比多进程快一点，但是也快不到哪去，而且，多线程模式致命的缺点就是任何一个线程挂掉都可能直接造成整个进程崩溃，因为所有线程共享进程的内存。在Windows上，如果一个线程执行的代码出了问题，你经常可以看到这样的提示：“该程序执行了非法操作，即将关闭”，其实往往是某个线程出了问题，但是操作系统会强制结束整个进程。

  • 我们打个比方，假设你不幸正在准备中考，每天晚上需要做语文、数学、英语、物理、化学这5科的作业，每项作业耗时1小时。如果你先花1小时做语文作业，做完了，再花1小时做数学作业，这样，依次全部做完，一共花5小时，这种方式称为单任务模型，或者批处理任务模型。

  • 假设你打算切换到多任务模型，可以先做1分钟语文，再切换到数学作业，做1分钟，再切换到英语，以此类推，只要切换速度足够快，这种方式就和单核CPU执行多任务是一样的了，以幼儿园小朋友的眼光来看，你就正在同时写5科作业。但是，切换作业是有代价的，比如从语文切到数学，要先收拾桌子上的语文书本、钢笔（这叫保存现场），然后，打开数学课本、找出圆规直尺（这叫准备新环境），才能开始做数学作业。操作系统在切换进程或者线程时也是一样的，它需要先保存当前执行的现场环境（CPU寄存器状态、内存页等），然后，把新任务的执行环境准备好（恢复上次的寄存器状态，切换内存页等），才能开始执行。这个切换过程虽然很快，但是也需要耗费时间。如果有几千个任务同时进行，操作系统可能就主要忙着切换任务，根本没有多少时间去执行任务了，这种情况最常见的就是硬盘狂响，点窗口无反应，系统处于假死状态。

  • 我们可以把任务分为计算密集型和IO密集型：

    算密集型任务的特点是要进行大量的计算，消耗CPU资源，比如计算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种计算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的时间就越多，CPU执行任务的效率就越低，所以，要最高效地利用CPU，计算密集型任务同时进行的数量应当等于CPU的核心数。

    计算密集型任务由于主要消耗CPU资源，因此，代码运行效率至关重要。Python这样的脚本语言运行效率很低，完全不适合计算密集型任务。对于计算密集型任务，最好用C语言编写。

    第二种任务的类型是IO密集型，涉及到网络、磁盘IO的任务都是IO密集型任务，这类任务的特点是CPU消耗很少，任务的大部分时间都在等待IO操作完成（因为IO的速度远远低于CPU和内存的速度）。对于IO密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是IO密集型任务，比如Web应用。

    IO密集型任务执行期间，99%的时间都花在IO上，花在CPU上的时间很少，因此，用运行速度极快的C语言替换用Python这样运行速度极低的脚本语言，完全无法提升运行效率。对于IO密集型任务，最合适的语言就是开发效率最高（代码量最少）的语言，脚本语言是首选，C语言最差。

  • 异步IO：

    如果充分利用操作系统提供的异步IO支持，就可以用单进程单线程模型来执行多任务，这种全新的模型称为事件驱动模型，Nginx就是支持异步IO的Web服务器，它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上，可以运行多个进程（数量与CPU核心数相同），充分利用多核CPU。由于系统总的进程数量十分有限，因此操作系统调度非常高效。用异步IO编程模型来实现多任务是一个主要的趋势。对应到Python语言，单进程的异步编程模型称为协程，有了协程的支持，就可以基于事件驱动编写高效的多任务程序

• 分布式进程：Python的multiprocessing模块不但支持多进程，其中managers子模块还支持把多进程分布到多台机器上。一个服务进程可以作为调度者，将任务分布到其他多个进程中，依靠网络通信。（没用过不懂）

• 正则表达式：

  • 字符串转义问题

    s = 'ABC\\-001' # Python的字符串
    # 对应的正则表达式字符串变成：
    # 'ABC\-001'
    
    #上下这两个是一样的
    
    s = r'ABC\-001' # Python的字符串
    # 对应的正则表达式字符串不变：
    # 'ABC\-001'

     

  • 分组

    >>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
    >>> m
    <_sre.SRE_Match object at 0x1026fb3e8>
    >>> m.group(0)
    '010-12345'
    >>> m.group(1)
    '010'
    >>> m.group(2)
    '12345'

    ()在正则中就是用来分组的

  • 贪婪匹配

    >>> re.match(r'^(\d+)(0*)$', '102300').groups()
    ('102300', '')

    这里就是贪婪

    >>> re.match(r'^(\d+?)(0*)$', '102300').groups()
    ('1023', '00')

    必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配

• TCP编程：

  • 客户端

    # 导入socket库:
    import socket
    # 创建一个socket:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 建立连接:
    s.connect(('www.sina.com.cn', 80))
    # 发送数据:
    s.send('GET / HTTP/1.1\r\nHost: www.sina.com.cn\r\nConnection: close\r\n\r\n')
    # 接收数据:
    buffer = []
    while True:
        # 每次最多接收1k字节:
        d = s.recv(1024)
        if d:
            buffer.append(d)
        else:
            break
    data = ''.join(buffer)
    # 关闭连接:
    s.close()
    header, html = data.split('\r\n\r\n', 1)
    print header
    # 把接收的数据写入文件:
    with open('sina.html', 'wb') as f:
        f.write(html)

    这是整个TCP建立连接然后请求数据的过程

  • 服务端：

    服务器会打开固定端口（比如80）监听，每来一个客户端连接，就创建该Socket连接。由于服务器会有大量来自客户端的连接，所以，服务器要能够区分一个Socket连接是和哪个客户端绑定的。一个Socket依赖4项：服务器地址、服务器端口、客户端地址、客户端端口来唯一确定一个Socket。

    但是服务器还需要同时响应多个客户端的请求，所以，每个连接都需要一个新的进程或者新的线程来处理，否则，服务器一次就只能服务一个客户端了。

    #连接建立后，服务器首先发一条欢迎消息，然后等待客户端数据，并加上Hello再发送给客户端。如果客户端发送了exit字符串，就直接关闭连接
    def tcplink(sock, addr):
        print 'Accept new connection from %s:%s...' % addr
        sock.send('Welcome!')
        while True:
            data = sock.recv(1024)
            time.sleep(1)
            if data == 'exit' or not data:
                break
            sock.send('Hello, %s!' % data)
        sock.close()
        print 'Connection from %s:%s closed.' % addr
    
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 监听端口:请注意，小于1024的端口号必须要有管理员权限才能绑定
    s.bind(('127.0.0.1', 9999))
    s.listen(5)   #传入的参数指定等待连接的最大数量
    print 'Waiting for connection...'
    while True:
        # 接受一个新连接:
        sock, addr = s.accept()
        # 创建新线程来处理TCP连接:
        t = threading.Thread(target=tcplink, args=(sock, addr))
        t.start()

     

• UDP编程：

  • 服务端

    #SOCK_DGRAM指定了这个Socket的类型是UDP
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    # 绑定端口:
    s.bind(('127.0.0.1', 9999))
    print 'Bind UDP on 9999...'
    while True:
        # 接收数据:
        data, addr = s.recvfrom(1024)
        print 'Received from %s:%s.' % addr
        s.sendto('Hello, %s!' % data, addr)

     

  • 客户端

    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    for data in ['Michael', 'Tracy', 'Sarah']:
        # 发送数据:
        s.sendto(data, ('127.0.0.1', 9999))
        # 接收数据:
        print s.recv(1024)#接受套接字的数据。数据以字符串形式返回，1024指定要接收的最大数据量
    s.close()

    UDP的使用与TCP类似，但是不需要建立连接。此外，服务器绑定UDP端口和TCP端口互不冲突，也就是说，UDP的9999端口与TCP的9999端口可以各自绑定

• 用python法邮件，贼猛

• 用python访问数据库：

• WEB开发：

  • 历史：

    Web开发也经历了好几个阶段：

    • 静态Web页面：由文本编辑器直接编辑并生成静态的HTML页面，如果要修改Web页面的内容，就需要再次编辑HTML源文件，早期的互联网Web页面就是静态的；

    • CGI：由于静态Web页面无法与用户交互，比如用户填写了一个注册表单，静态Web页面就无法处理。要处理用户发送的动态数据，出现了Common Gateway Interface，简称CGI，用C/C++编写。

    • ASP/JSP/PHP：由于Web应用特点是修改频繁，用C/C++这样的低级语言非常不适合Web开发，而脚本语言由于开发效率高，与HTML结合紧密，因此，迅速取代了CGI模式。ASP是微软推出的用VBScript脚本编程的Web开发技术，而JSP用Java来编写脚本，PHP本身则是开源的脚本语言。

    • MVC：为了解决直接用脚本语言嵌入HTML导致的可维护性差的问题，Web应用也引入了Model-View-Controller的模式，来简化Web开发。ASP发展为ASP.Net，JSP和PHP也有一大堆MVC框架。

  • HTTP：HTTP是在网络上传输HTML的协议，用于浏览器和服务器的通信。

    • 格式：每个Header一行一个，换行符是\r\n，当遇到连续两个\r\n时，Header部分结束，后面的数据全部是Body。

    • Body的数据类型由Content-Type头来确定，如果是网页，Body就是文本，如果是图片，Body就是图片的二进制数据

  • 前端基础：HTML定义了页面的内容，CSS来控制页面元素的样式，而JavaScript负责页面的交互逻辑

  • WSGI接口：

    因为我们不希望接触到TCP连接、HTTP原始请求和响应格式，所以，需要一个统一的接口，让我们专心用Python编写Web业务。这个接口就是WSGI：Web Server Gateway Interface。

    # hello.py
    
    def application(environ, start_response):
        start_response('200 OK', [('Content-Type', 'text/html')])
        return '
    Hello, web!
    '
    
    #######模块分割线#######
    
    # server.py
    # 从wsgiref模块导入:
    from wsgiref.simple_server import make_server
    # 导入我们自己编写的application函数:
    from hello import application
    
    # 创建一个服务器，IP地址为空，端口是8000，处理函数是application:
    httpd = make_server('', 8000, application)
    print "Serving HTTP on port 8000..."
    # 开始监听HTTP请求:
    httpd.serve_forever()

    然后在命令行输入python server.py来启动WSGI服务器，启动成功后，打开浏览器，输入http://localhost:8000/，就可以看到结果了。复杂的Web应用程序，光靠一个WSGI函数来处理还是太底层了，我们需要在WSGI之上再抽象出Web框架，进一步简化Web开发

  • flask框架：

    • 除了Flask，常见的Python Web框架还有：

    • Django：全能型Web框架；

    • web.py：一个小巧的Web框架；

    • Bottle：和Flask类似的Web框架；

    •  Tornado：Facebook的开源异步Web框架。

  • 使用模板：由于在Python代码里拼字符串是不现实的，所以，模板技术出现了。使用模板，我们需要预先准备一个HTML文档，这个HTML文档不是普通的HTML，而是嵌入了一些变量和指令，然后，根据我们传入的数据，替换后，得到最终的HTML，发送给用户

• 协程：

  • yield：

    import time
    
    def consumer():
        r = ''
        while True:
            n = yield r
            if not n:
                return
            print('[CONSUMER] Consuming %s...' % n)
            time.sleep(1)
            r = '200 OK'
    
    def produce(c):
        c.next()
        n = 0
        while n < 5:
            n = n + 1
            print('[PRODUCER] Producing %s...' % n)
            r = c.send(n)
            print('[PRODUCER] Consumer return: %s' % r)
        c.close()
    
    if __name__=='__main__':
        c = consumer()
        produce(c)
    
    ############结果如下
    [PRODUCER] Producing 1...
    [CONSUMER] Consuming 1...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 2...
    [CONSUMER] Consuming 2...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 3...
    [CONSUMER] Consuming 3...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 4...
    [CONSUMER] Consuming 4...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 5...
    [CONSUMER] Consuming 5...
    [PRODUCER] Consumer return: 200 OK

    整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。(用yield来实现协程)

  • gevent：

    gevent是第三方库，通过greenlet实现协程，其基本思想是：

    当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

#######################自己对python底层探究的分割线##############################

• list tuple dict set的底层实现这篇文章说的挺好的
  • list：
    • Python中的列表是由对其它对象的引用组成的连续数组，这个数组一开始就分配了很长所以可以尽情的用。指向这个数组的指针及其长度被保存在一个列表头结构中底层细节
  • dict:

    • CPython使用伪随机探测(pseudo-random probing)的散列表(hash table)作为字典的底层数据结构。由于这个实现细节，只有可哈希的对象才能作为字典的键。

      Python中所有不可变的内置类型都是可哈希的。可变类型（如列表，字典和集合）就是不可哈希的，因此不能作为字典的键。

    • 哈希函数的实现方式决定了哈希表的搜索效率。具体操作过程是：

      • 数据添加：把key通过哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
      • 数据查询：再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value。

  • set:

    • CPython中集合和字典非常相似。事实上，集合被实现为带有空值的字典，只有键才是实际的集合元素。

    • 由于这一点，可以快速的向集合中添加元素、删除元素、检查元素是否存在。平均时间复杂度为O(1),最坏的事件复杂度是O(n)。

• for的底层实现
  • 自己试了一下这个例子

    if __name__ == '__main__':
        list1 = [1,2,3,4]
        for i in list1:
            i = 2
        print list1
        str1 = 'abc'
        for i in str1:
            i=1
        print str1
        dict1 = {1:2,3:4}
        for key in dict1:
            key = 12
        print dict1
        for key in dict1:
            dict1[key]=90
        print dict1
    
    [1, 2, 3, 4]
    abc
    {1: 2, 3: 4}
    {1: 90, 3: 90}

     

• for的一个陷阱

  d = [1,2,3,4,5]
  for i in d:
      d.remove(i)
  print d
  
  [2, 4]
  
  ######解决方法#########
  d = [1, 2, 3, 4, 5]
      for i in d[:]:
          d.remove(i)
      print d
  
  []

  list1 = [1,1,3,4,5,6,7,7,7]
  for index1,num1 in enumerate(list1):
      for index2,num2 in enumerate(list1):
          if index2 <= index1:
              continue
          if num1==num2:
              del list1[index1]
  print list1
  
  #[1, 3, 4, 5, 6, 7, 7]