M3截止阶段小结

python知识点总结
1、copy模块中深浅拷贝copy() deepcopy()
2、__new__ 方法参数
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)
3、元类示例：
    class Mymetaclass(type): # 继承type类型
        def __new__(cls,name,bases,attrs):
            update_attrs={}
            for k,v in attrs.items():  # 字典遍历方法
                if not callable(v) and not k.startswith('__'):
                    update_attrs[k.upper()]=v
                else:
                    update_attrs[k]=v
            return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):  # 继承定义的元类
        country='China'
        tag='Legend of the Dragon'
        def walk(self):
            print('%s is walking' %self.name)

print(Chinese.__dict__)
    '''
    {'__module__': '__main__',
     'COUNTRY': 'China',
     'TAG': 'Legend of the Dragon',
     'walk': <function Chinese.walk at 0x0000000001E7B950>,
     '__dict__': <attribute '__dict__' of 'Chinese' objects>,                                         
     '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
     '__doc__': None}
    '''
4、__str__ 类属性（作用类似于java中的 toString方法）
    示例：
    @property
    def detail(self):
        '''tostring'''
        tmp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s" % (self.name, self.gender, self.age, self.fight_value)
        print(tmp)

def __str__(self):
        '''tostring'''
        tmp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s" % (self.name, self.gender, self.age, self.fight_value)
        return tmp
    
    # wenhong.detail
    print(cangjinjin)
5、.ini 文件操作
    settings.py
    import os
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    ACCOUNT_FILE = "%s/conf/accounts.ini" % BASE_DIR
    
    config_obj = configparser.ConfigParser()
    config_obj.read(settings.ACCOUNT_FILE)
    return config_obj
    
6、socket：
    server端：
        在类构造方法中：
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.bind((settings.HOST, settings.PORT))
        self.sock.listen(settings.MAX_SOCKET_LISTEN)
        self.accounts = self.load_accounts()
        
        def run_forever(self):
            """启动socket server"""
            print('starting LuffyFTP server on %s:%s' % (settings.HOST, settings.PORT))
            while True:
                self.request, self.addr = self.sock.accept() # 赋值成全局变量
                print("got a new connection from %s" % (self.addr,))
                self.handle()

def handle(self):
            """处理与用户的所有指令交互"""
            while True:  # 一直循环运行
                raw_data = self.request.recv(1024)  # 指定大小
                # print('raw_data------------------>', raw_data)
                if not raw_data:  # 判断是否为空语句
                    print("connection %s is lost...." % (self.addr, ))
                    del self.request, self.addr  # 断开连接
                    break
                data = json.loads(raw_data.decode('utf-8'))  # 接受客户端数据，必须解码
                action_type = data.get("action_type")
                # print('data, action_type-------------->', data, action_type)
                if action_type:
                    if hasattr(self, "_%s" % action_type):  # _表示和客户端交互的方法
                        func = getattr(self, "_%s" % action_type)   # 反射拿到方法名称
                        func(data)
                else:
                    print("invalid command, ")
                    
7、上传下载示例整理
    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
    # @Time    : 2018/6/7 8:41
    # @File    : 服务端.py

import socket
    import os
    import json
    import struct

shar_dir = r'D:\pytharm\jichuyufa\model3\practice2\上传下载\server\share'

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    phone.bind(('127.0.0.1', 9909))
    phone.listen(5)  #
    print('starting...')
    while True:
        conn,client_addr = phone.accept()
        print(client_addr)

while True:
            try:
                # 1收命令
                res = conn.recv(8096)  # b'get a.txt'
                if not res:break

# 2,解析命令，提取相应命令参数
                cmds = res.decode('utf-8').split()  # ['get',filename]
                filename = cmds[1]

# 3,易读的方式打开文件，读取文件内容发送给客户端

header_dic = {
                    'filename': filename,
                    'md5':'xxxdxxx',
                    'file_size': os.path.getsize(r'%s/%s' % (shar_dir, filename))
                }

header_json = json.dumps(header_dic)

header_bytes = header_json.encode('utf-8')

# 2,先发送报头的长度
                conn.send(struct.pack('i', len(header_bytes)))
                # 3,再发报头
                conn.send(header_bytes)

# 4,再发送真实的数据
                with open('%s/%s' % (shar_dir, filename), 'rb') as f:
                    # conn.send(f.read())
                    for line in f:
                        conn.send(line)
            except ConnectionResetError:
                break
        conn.close()
    phone.close()

client-------------------------------------

#!/usr/bin/python3
    # -*- coding: utf-8 -*-
    # @Time    : 2018/6/7 8:41
    # @File    : 客户端.py

import socket
    import struct
    import json

dow_dir = r'D:\pytharm\jichuyufa\model3\practice2\上传下载\client\download'

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    phone.connect(('127.0.0.1', 9909))

while True:
        # 1,发命令
        cmd = input('>>:').strip()
        if not cmd:continue
        phone.send(cmd.encode('utf-8'))

# 2,以写的方式打开一个新文件
        # 2.1收报头长度
        obj = phone.recv(4)
        header_size = struct.unpack('i', obj)[0]
        # 2.2收报头
        header_bytes = phone.recv(header_size)
        # 从报头中解析出对真实数据的描述信息
        header_json = header_bytes.decode('utf-8')
        header_dic = json.loads(header_json)
        print(header_dic)

total_size = header_dic['file_size']
        filename = header_dic['filename']
        # 2.4,接收真实的数据
        with open('%s/%s' % (dow_dir, filename), 'wb') as f:  #  服务端打开读方式，这里这种wb方式容易卡主
            recv_size = 0
            while recv_size < total_size:
                line = phone.recv(1024)
                f.write(line)
                recv_size += len(line)
                print('总大小:%s 已下载大小： %s' % (total_size, recv_size))

phone.close()
8、列表中数字拼接示例：
    import re
    li = [1, 2, 3, 4, 5, 66, 7, 3, 54, 34, 34]

# s = ''.join(str(li).split(',')).replace(' ', '').replace('[','').replace(']','')
    s = re.sub('[\s\[\]]', '', ''.join(str(li).split(',')))
    print(s)
    
9、单例示例：
    http://www.cnblogs.com/fmgao-technology/p/9127869.html
10、list，tuple，dict和set的主要区别

1 .list

list 方括号括起来的有序元素集合;

List 可以作为以 0 下标开始的数组,任何一个非空 list 的第一个元素总是 L[0],负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 L[-1];

有分片功能，两个list可以相加；

append 向 list 的末尾追加单个元素；

insert 将单个元素插入到 list 中；

extend 用来连接 list，使用一个 list 参数进行调用；（俩个list合并，不去重）

append 接受一个参数, 这个参数可以是任何数据类型, 并且简单地追加到 list 的尾部；

index 在 list 中查找一个值的首次出现并返回索引值；

要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False ；

remove 从 list 中删除一个值的首次出现；

pop 可以删除 list 的最后一个元素, 然后返回删除元素的值，用索引删除制定位置的值；

2.tuple

tuple是不可变的list，创建了一个tuple就不能以任何方式改变它；

定义tuple是将整个元素集是用小括号括起来，是有序集合；

tuple的索引与list一样从0开始,所以一个非空的tuple的第一个元素总是t[0]；

负数索引与 list 一样从 tuple 的尾部开始计数；

与 list 一样分片 (slice) 也可以使用。分割一个 tuple 时, 会得到一个新的 tuple；

没有 append、extend、remove或pop方法以及index方法；

可以使用in来查看一个元素是否存在于tuple 中。

3.dict

dict定义了键和值之间的一一对应关系，每个元素都是一个key-value对；

整个元素集合用大括号括起来，有序集合；

可以通过 key 得到value, 但不能通过vaule获取 key；

在一个 dict中不能有重复的 key, 并且 key 是大小写敏感的；

键可以是数字、字符串或者是元组等不可变类型；

用del使用key可以删除dict中的独立元素；

用clear可以清除dict中的所有元素。

4.set

set是建立一系列无序的，不重复的元素；

创建set的方式是调用set()并传入一个list，list的元素将作为set的元素；

set和dict的唯一区别仅在于没有存储对应的value
        
11、json和pickle
    dumps 和 loads 用于python对象和字符串间的序列化和反序列化
        dumps:将python 基本数据类型转化为json格式数据类型
        loads:将json格式数据类型转化为python数据类型
    
    dump 和load 用于对文件进行序列化和反序列化
        dump：主要用于json文件的读写，json.dump(x,f)，x是对象，f是一个文件对象，这个方法可以将json字符串写入到文本文件中
        load：加载json文件
    
12、logger
    # 创建一个logger
    # 创建一个handler，用于写入日志文件
    # 再创建一个handler，用于输出到控制台
    # 定义handler的输出格式
    # 给logger添加handler
    http://www.cnblogs.com/fmgao-technology/p/9108620.html
    http://www.cnblogs.com/fmgao-technology/p/9100788.html
13、格式化日期：
    time.strftime("%H:%M:%S")
    http://www.cnblogs.com/fmgao-technology/p/9108610.html
    http://www.cnblogs.com/fmgao-technology/p/9069820.html
14、file
    fp.read([size]) #size为读取的长度，以byte为单位
    fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分
    fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
    fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符
    fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西
    fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点
    fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾
    http://www.cnblogs.com/fmgao-technology/p/9108506.html
15、MD5
    def md5(arg):  # 这是加密函数，将传进来的函数加密
        md5_pwd = hashlib.md5(bytes('admin'.encode('utf-8')))
        md5_pwd.update(bytes(arg.encode('utf-8')))
        return md5_pwd.hexdigest()
16、join
    Python中有join()和os.path.join()两个函数，具体作用如下：
    join()：    连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
    os.path.join()：  将多个路径组合后返回
    http://www.cnblogs.com/fmgao-technology/p/9101195.html
17、user-add组合成键值对
    13,Alex Li,25,1344353443,IT,2015‐10‐29
    14,Alex Li,25,1344353424,IT,2015‐10‐29
    方法一：
    staff_table = {}
    field_list = ["num", "name", "age", "phone", "dept", "enroll_date"]
    def openfile():
        staff_file = open("test.txt", 'r+', encoding='utf-8')
        for line in staff_file:
            line = line.strip().split(',')
            staff_table[line[1]] = dict(zip(field_list, line[:6]))    
18、装饰器
    def logging(level):
        @wrapt.decorator
        def wrapper(wrapped, instance, args, kwargs):
            print "[{}]: enter {}()".format(level, wrapped.__name__)
            return wrapped(*args, **kwargs)
        return wrapper

@logging(level="INFO")
    def do(work): pass    
    http://www.cnblogs.com/fmgao-technology/p/9100217.html
    http://www.cnblogs.com/fmgao-technology/p/9072258.html
    http://www.cnblogs.com/fmgao-technology/p/9062639.html
19、re
    s3 = 'alex22jack23rain31jinxin50#mack-oldboy'
    s31 = re.split('\d+|#|-',s3)
    print(s31) # ['alex', 'jack', 'rain', 'jinxin', '', 'mack', 'oldboy']
    http://www.cnblogs.com/fmgao-technology/p/9091243.html
    http://www.cnblogs.com/fmgao-technology/p/9090983.html
20、xml
    ElementTree(tag)，其中tag表示根节点，初始化一个ElementTree对象。
    Element(tag, attrib={}, **extra)函数用来构造XML的一个根节点，其中tag表示根节点的名称，attrib是一个可选项，表示节点的属性
    http://www.cnblogs.com/fmgao-technology/p/9087584.html
    
21、subprocess
    subprocess.Popen()：    在一些复杂场景中，我们需要将一个进程的执行输出作为另一个进程的输入。在另一些场景中，我们需要先进入到某个输入环境，然后再执行一系列的指令等。这个时候我们就需要使用到suprocess的Popen()方法。该方法有以下参数：
    args：shell命令，可以是字符串，或者序列类型，如list,tuple。
    bufsize：缓冲区大小，可不用关心
    stdin,stdout,stderr：分别表示程序的标准输入，标准输出及标准错误
    shell：与上面方法中用法相同
    cwd：用于设置子进程的当前目录
    env：用于指定子进程的环境变量。如果env=None，则默认从父进程继承环境变量
    universal_newlines：不同系统的的换行符不同，当该参数设定为true时，则表示使用\n作为换行符    
    http://www.cnblogs.com/fmgao-technology/p/9085761.html
    
22、hashlib
    hexdigest()：返回摘要，作为十六进制数据字符串值    
    http://www.cnblogs.com/fmgao-technology/p/9085617.html
23、__name__
    1. 如果模块是被导入，__name__的值为模块名字
    2. 如果模块是被直接执行，__name__的值为’__main__’
    http://www.cnblogs.com/fmgao-technology/p/9080482.html

24、sys
    sys.argv: 实现从程序外部向程序传递参数
    http://www.cnblogs.com/fmgao-technology/p/9074282.html
    
25、os
    os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径
    os.path.abspath(name):获得绝对路径
    http://www.cnblogs.com/fmgao-technology/p/9073582.html
    http://www.cnblogs.com/fmgao-technology/p/9056425.html
    http://www.cnblogs.com/fmgao-technology/p/9056280.html
26、str
    str.find(s)     返回字符串s在字符串str中的位置索引，没有则返回-1
    str.splitlines() 按照行分隔，返回一个包含各行作为元素的列表
    str.isspace() 如果str中只包含空格，则返回 True，否则返回 False
    string.letters 字符串’abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ’
    http://www.cnblogs.com/fmgao-technology/p/9073564.html
    http://www.cnblogs.com/fmgao-technology/p/9056517.html
27、random
    list_number = [1, 2, 3, 4, 5]
    random.shuffle(list_number)  # 打乱列表
    http://www.cnblogs.com/fmgao-technology/p/9073554.html
    
28、range
    函数原型：range（start， end， scan):
        参数含义：
        start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;
        end:技术到end结束，但不包括end.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
        scan：每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
    http://www.cnblogs.com/fmgao-technology/p/9071681.html
    
29、print
    print(value, …, sep=' ', end=’\n’, file=sys.stdout, flush=False)
    参数解析
        value：需要输出的值，可以是多个，用”,”分隔。
        sep：多个输出值之间的间隔，默认为一个空格。
        end：输出语句结束以后附加的字符串，默认是换行（’\n’）。
        file：输出的目标对象，可以是文件也可以是数据流，默认是“sys.stdout”。
        flush：flush值为True或者False，默认为Flase,表示是否立刻将输出语句输出到目标对象。
    http://www.cnblogs.com/fmgao-technology/p/9071156.html
    
30、可迭代对象|迭代器
    Python中可迭代对象和迭代器对象的理解
    我们在用for ... in ...语句循环时，in后面跟随的对象要求是可迭代对象，即可以直接作用于for循环的对象统称为可迭代对象（Iterable），如list、tuple、dict、set、str等
    可迭代对象是实现了__iter__()方法的对象，而迭代器（Iterator）则是实现了__iter__()和__next__()方法的对象
    http://www.cnblogs.com/fmgao-technology/p/9064301.html
    http://www.cnblogs.com/fmgao-technology/p/9049768.html
    
31、闭包
    Python中创建一个闭包可以归结为以下三点：
        闭包函数必须有内嵌函数
        内嵌函数需要引用该嵌套函数上一级namespace中的变量
        闭包函数必须返回内嵌函数
    http://www.cnblogs.com/fmgao-technology/p/9062419.html
    
32、enumerate
    list1 = ["这", "是", "一个", "测试"]
    for index, item in enumerate(list1):
        print index, item    
    http://www.cnblogs.com/fmgao-technology/p/9060625.html
    
33、
    eval 将字符串str当成有效的表达式来求值并返回计算结果。它要执行的python代码只能是单个运算表达式（不支持任意形式的赋值操作），而不能是复杂的代码逻辑
    exec 动态执行python代码，可以执行复杂的python代码
    http://www.cnblogs.com/fmgao-technology/p/9060702.html
    
34、reduce
    from functools import reduce
    result = reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
    http://www.cnblogs.com/fmgao-technology/p/9056076.html
    
35、map
    map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
    [3, 7, 11, 15, 19]
    http://www.cnblogs.com/fmgao-technology/p/9049669.html
    
36、类中方法    
    https://www.cnblogs.com/fmgao-technology/p/9173202.html