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

猜你喜欢