43.QQ聊天软件GUI窗口编写

Wesley13
• 阅读 659

QQ聊天软件代码功能编写


一,Tkinter聊天界面编写

1,聊天软件客户端界面开发-1

  • Tkinter的模块(“TK接口”)是标准的Python接口从Tk的GUI工具包

  • https://i.cnblogs.com/EditPosts.aspx?opt=1   ###Tkinter官方文档:关于相关函数具体看文档介绍

  • Tkinter模块:自带的,跨平台

    • 做GUI:界面软件

    • 不难,但是复杂,东西多,窗口控件多,设计,美感,抠图

  • 界面开发设计

    • 设置窗口:像素大小

    • 拜访控件:按钮,复选框,文本框

  • root控件流程:

    • 1:导入模块   import tkinter
    • 2:创建主窗口root = tkinter.Tk()
    • 3:创建其他窗口以及控件(按钮,文本框,等等)
    • 4:摆放到root上
    • 5:开启root的事件循环:root.mainloop()
    • 6:如果不需要该窗口,可以使用root.destory()

  • 组件:

  • 文本框

    • tkinter.Text()
      • insert():插入数据
        • tkinter.END,从末尾插入
      • delete(‘0.0’,tkinter.END):删除全部文本框数据
      • tag_config('标签名',foreground='颜色',):标签配置,设置字体颜色, 第一个字符串参数是标签名,第二个是颜色
      • get('0.0',thinter.END):阅读拿出文本框的内容
  • 按钮

    • tkinter.Button()
      • text:按钮名字
      • command:回调函数,按钮点击时的工作任务列表框
  • 列表框

  • tkinter.Listbox()

  • insert(tkinter.END, 追加的数据)

  • 事件绑定

    • 双击事件:

    • 事件绑定的函数必须有一个参数,这个参数就是事件

    • self.right_listbox.curselection()

      • 返回当前选择的列表框索引位置值,返回结果为单个数据的元组

      • index = self.listbox_user.curselection()[0]

    • self.talk_user_name = self.listbox_user.get(index)

      • index   #获取的当前列表框中的索引位置的值

  • root.title('**')

    • 设置上标字符
  • grid()

    • x,y轴的摆放方式

    • row:行

    • column:列

    • rowspan:行宽,跨行数

    • pady:表格间距,x轴

    • padx:y轴的表格间距

  • sticky

    • 对其方向,上北下南左西右东N,S,W,E
  • grid_propagate(0)

    • 0代表禁止容器窗口缩放
  • root.resizable(width=False,height=Flase)

    • 禁止窗口缩放
  • root.winfo_screenwidth()

    • 自动获取用户的屏幕宽度
  • root.winfo_screenheight()

    • 自动获取用户的屏幕高度
  • root.geometry("%dx%d%+d%+d" % (width, height, xoffset, yoffset))

    • 设置控件所处的屏幕位置
  • tkinter.Label(所属的主窗口,text='名字',font=("黑体",9, "bold"))

    • 添加标签lable
  • tkinter.Entry()

    • 单行文本框

    • 获取数据直接使用get() 函数即可,不需要传参。

  • from tkinter import messagebox   ##展示报错信息

    • 'showerror', 'showinfo', 'showwarning'

      • title=None, message=None
    • messagebox.showerror(title='登录失败',message='登录失败')

    • 43.QQ聊天软件GUI窗口编写


  • 客户端登录及聊天窗口代码编写整合如下:

    from tkinter import Tk
    import tkinter
    import time
    from multiprocessing.pool import ThreadPool
    import socket
    from tkinter import messagebox
    import pickle
    import _pickle
    #scroolbar
    class TalkRoot:
        '''
            实现用户聊天的主要界面
        '''
        def __init__(self,user_name,client,user_id):
            self.root = Tk()
            self.root.title('欢迎你:%s' % user_name)
            self.client = client
            self.user_id = user_id
            #-----------------创建进程池----------------------
            self.thread_pool = ThreadPool(5) #5个线程的线程池
            #-------功能变量----------------------
            self.talk_user_name = '' #你要聊天的人
            self.client = client    #套接字
            #------------------设置窗口所处的用户界面位置及窗口大小在屏幕中间------------
            self.root_width=550
            self.root_height=420
            self.user_screen_width = self.root.winfo_screenwidth()#自动获取用户的屏幕宽度
            self.user_screen_height = self.root.winfo_screenheight()#用户的屏幕高
            self.root.geometry("%dx%d%+d%+d" %
                (self.root_width,
                self.root_height,
                (self.user_screen_width - self.root_width) / 2,
                (self.user_screen_height - self.root_height) / 2,)
                )         
            #-------容器--------
            #上: 输出
            self.frame_top = tkinter.Frame(width=380,height=270)
            #中: 输入
            self.frame_center = tkinter.Frame(width=380,height=100)
            #下: 按钮
            self.frame_bottom = tkinter.Frame(width=380,height=30)
            #右: 列表
            self.frame_right = tkinter.Frame(width=170,height=400)
    
            #--------控件--------
            #上: 输出
            self.text_output = tkinter.Text(self.frame_top,height=260)
            self.text_output.tag_config('time_stamp',foreground='green')  #标签配置颜色
            self.text_output.tag_config('self_msg',foreground='blue')#标签配置颜色
            self.text_output.tag_config('other_msg',foreground='red')#标签配置颜色
            #中: 输入
            self.text_input = tkinter.Text(self.frame_center)
            self.text_input.bind('<Return>',self.button_send_msg)
            #下: 按钮
            self.button_send = tkinter.Button(self.frame_bottom,text='发送',command=self.button_send_msg) #发送按钮
            self.button_cancle = tkinter.Button(self.frame_bottom,text='取消',command=self.fc_button_cancle) #取消按钮
            #右: 列表
            self.listbox_user = tkinter.Listbox(self.frame_right,width=150,height=25)
            self.listbox_user.bind('<Double-Button-1>',self.get_talk_user)#绑定双击事件
            #--------摆放生效容器---------
            self.frame_top.grid(row=0,column=0,padx=2,pady=5)
            self.frame_center.grid(row=1,column=0,padx=2,pady=5)
            self.frame_bottom.grid(row=2,column=0,sticky=tkinter.E)
            self.frame_right.grid(row=0,column=1,rowspan=3,padx=5,pady=5)
    
            #--------摆放生效控件---------
            self.text_output.grid()
            self.text_input.grid()
            self.button_send.grid(row=0,column=1,padx=300)
            self.button_cancle.grid(row=0,column=0)
            self.listbox_user.grid()
    
            #--------禁止容器窗口缩放grid_--------------------
            self.frame_top.grid_propagate(0)
            self.frame_center.grid_propagate(0)
            self.frame_bottom.grid_propagate(0)
            self.frame_right.grid_propagate(0)
            #------------专门开一个接受消息聊天的线程------------
            self.thread_pool.apply_async(func=self.check_recv_msg) #非阻塞线程
            #------------窗口循环---------------------------------------
            self.root.mainloop()
    
        def check_recv_msg(self):
            while True:    #循环窗口聊天
                try:
                    data = pickle.loads(self.client.recv(1024))
                except _pickle.UnpicklingError:
                    messagebox.showinfo(title='服务端消息错误',message='服务端发来无法解析的错误')
                    self.root.destroy()
                    exit()
                except Exception as e:
                    messagebox.showinfo(title='服务端断开',message='服务端断开')
                    self.root.destroy()
                    exit()
                if data.get('flag') == 'flush':
                    #服务端返回最新在线用户
                    self.thread_pool.apply_async(func=self.flush_onlien_user,args=(data,))
                elif data.get('flag') == 'forward':
                    #服务端返回别人发来的消息
                    self.thread_pool.apply_async(func=self.show_other_msg,args=(data,))
                elif not data:
                    #服务端发来空消息,断开连接
                    exit()
    
        def show_other_msg(self,data):
            '''
                展示别人发来的消息
            '''
            send_name = data.get('data')['send_name']
            other_msg = data.get('data')['message']
            print('别人发来了消息:',other_msg)
            time_stamp = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime() )  + '\n'
            self.text_output.insert(tkinter.END,time_stamp,'green')
            self.text_output.insert(tkinter.END,'%s:%s' % (send_name,other_msg),'red')
    
        def flush_onlien_user(self,data):
            self.listbox_user.delete(0,tkinter.END) #清空在线用户列表
            for user in data.get('data'):
                #user : {id:name}
                id_ = list(user.keys())[0]
                name = list(user.values())[0]
                self.listbox_user.insert(tkinter.END, '%s:%s' % (name,id_))
    
        def button_send_msg(self,events=None):
            self_msg = self.text_input.get('0.0',tkinter.END)
            self.text_input.delete('0.0',tkinter.END)
            if not self_msg.isspace():
                time_stamp = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime() )  + '\n'
                self.text_output.insert(tkinter.END,time_stamp,'time_stamp')
                self.text_output.insert(tkinter.END,' ' + self_msg,'self_msg')
            self.thread_pool.apply_async(func=self.clear_input_text)
            #id:name
            if self.talk_user_name:
                print('捕捉到在线用户,准备发送消息')
                recv_id = self.talk_user_name.split(':')[0] 
                print(recv_id)
                send_data = {
                    'flag': 'send',
                    'data': {
                        'send_id': self.user_id,
                        'recv_id': recv_id,
                        'message': self_msg,
                    }
                }
                self.client.send(pickle.dumps(send_data))
            else:
                '''
                    群发功能
                '''
                send_data = {
                    'flag': 'part',
                    'data': {
                        'send_id': self.user_id,
                        'message': self_msg,
                    }
                }
    
        def clear_input_text(self):
            time.sleep(0.1)
            self.text_input.delete('0.0',tkinter.END)
            
        def get_talk_user(self,events):
            '''
                获取当前聊天用户
            '''
            if self.listbox_user.size() != 0:
                index = self.listbox_user.curselection()[0]
                self.talk_user_name = self.listbox_user.get(index)
                print(self.talk_user_name)
    
        def fc_button_cancle(self):
            '''
                聊天界面的销毁
                    销毁窗口
                    客户端套接字释放
            '''
            exit()
    
        def __del__(self):
            self.client.close() #套接字释放
            self.root.destroy() #销毁窗口
    
    class LoginRoot():
        def __init__(self):
            self.root = tkinter.Tk()
            self.root.title('登陆')
            self.root.resizable(width=False,height=False) #禁止窗口缩放调整
    
            self.root_width = 197
            self.root_height = 75
    
            #自适应,首先要获取到用户的屏幕分辨率
            self.user_screen_width = self.root.winfo_screenwidth() #用户的屏幕也宽度
            self.user_screen_height = self.root.winfo_screenheight() #用户的屏幕高度
    
            self.root.geometry("%dx%d%+d%+d" % #设置窗口所处的用户界面位置及窗口大小
                (self.root_width,
                self.root_height,
                (self.user_screen_width - self.root_width) / 2,
                (self.user_screen_height - self.root_height) / 2,)
                )
    
            #创建提示label
            self.label_id = tkinter.Label(self.root,text='I D:',font=("黑体",10, "bold")) # font设置字体样式
            self.label_name = tkinter.Label(self.root,text='昵称:',font=("黑体",10, "bold"))
            #摆放提示label
            self.label_id.grid(row=0,column=0,sticky=tkinter.W)
            self.label_name.grid(row=1,column=0,)
            #创建输入单行文本框
            self.entry_id = tkinter.Entry(self.root)
            self.entry_name = tkinter.Entry(self.root)
            #摆放文本框
            self.entry_id.grid(row=0,column=1)
            self.entry_name.grid(row=1,column=1)
            #创建功能按钮
            self.button_login = tkinter.Button(self.root,text='登陆',command=self.user_login)
            self.button_cancle = tkinter.Button(self.root,text='取消',command=self.user_cancle)
            #摆放功能按钮
            self.button_login.grid(row=2,column=1,sticky=tkinter.E)
            self.button_cancle.grid(row=2,column=0,sticky=tkinter.W)
            self.root.mainloop()
    
        def user_login(self):
            '''
                要确定用户提供的ID是唯一的
                把昵称传递给TalkRoot
            '''
            user_id = self.entry_id.get()
            user_name = self.entry_name.get()
    
            send_login_msg = {
                'flag': 'login',
                'data':{
                    'id': user_id,
                    'name': user_name
                }
            }
            ip = '192.168.1.101'
            port = 8000
            try:
                self.client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                self.client.connect( (ip,port) )
            except Exception as e:
                print('登陆连接时的错误:',e)
                messagebox.showerror(title='登陆失败',message='登陆失败')
            else:
                self.client.send(pickle.dumps(send_login_msg))
                data = pickle.loads(self.client.recv(1024))
                if data.get('flag') == 'login':
                    if data.get('data')['state']:
                        #登陆成功
                        self.root.destroy()
                        tkr = TalkRoot(user_name,self.client,user_id)
                    else:
                        self.client.close()
                        messagebox.showwarning(title='登陆失败',message='%s' % (data.get('data')['message']))
    
        def user_cancle(self):
            self.root.destroy()
    
    def main():
        lgr = LoginRoot()
    
    
    if __name__ == '__main__':
        main()
    

二,聊天类软件后台架构及请求数据设计

一,服务端功能

  • 1:接收用户登陆

    • 主线程,消息收集
    • 服务端套接字,唯一ID的校验
  • 2:告知在线用户

    • 另开线程,遍历访问服务端保存的客户端序列数据
  • 3:处理在线用户的消息发送

    • 主线程,消息收集 一旦捕获到了一个消息是要发送给别人的
    • 另开线程,处理消息转发,发给另外一个在线的套接字

二,客户端功能

  • 1:登陆

    • 套接字,发送ID和昵称即可
  • 2:接收处理服务端发来的在线用户列表

  • 3:发送消息,展示消息

三,请求数据结构体 / 客户端

  • 1:pickle.dumps() #打包二进制数据体

    •   { #客户端登陆发送的数据体
            'flag': 'login', #数据标志位
            'data': {
                'id': '123456', #用户ID
                'name: 'xxxxx', #用户昵称
            }
        }
          
        { #客户端发送数据体
            'flag': 'send' #数据标志位
            'data': {
            'send_id': '123455', #发送者的ID
                'recv_id': '123456', #接收人的ID号
                'message: 'xxxxx', #发给别人的数据
            }
        }
        
        { #客户端注册数据体
            'flag': 'register', #数据标志位
            'data': {
                'id': '123456', #用户ID
                'name: 'xxxxx', #用户昵称
                'password': 'xxxxx', #
            }
        }
      

四,服务端保存在线用户数据体

  • 1:直接连进来的,不进入这个数据体,不算有效用户

  • 2:某个线程,捕捉这个套接字发来的第一个login的数据体

  • 3:判断ID:

    • ID不重复:登陆保存
    • ID重复:当用户发送重复id的时,返回的数据
      •   

        {
            'flag':'login',
            'data': {
                'state':True,/False
                'message':'登陆成功'
            }
        }
        

      

  • 4:成功登陆的用户保存在字典中的数据结构体

    •   #字典:
        dict_onlien_user = {
            xxxx:{
                'name':'666',
                'socket':client,
            },
            xxxx:{,
                name:'666',
                socket:client,
            },
        }
          
      
    • onlien_user.get(recv_id)['socket'].send(message)  #如果再转发消息的时候,准确快速的找到接收者

     

  • 5:成功的用户发来的数据,要给别人发消息,服务端怎么保存这个数据?

    •   

      { #客户端发送数据体
          'flag': 'send' #数据标志位
          'data': {
              'send_id': '123455', #发送者的ID
              'recv_id': '123456', #接收人的ID号
              'message: 'xxxxx', #发给别人的数据
          }
      }
      
  • 6:客户端接收服务端发来的在线用户数据结构体

    •   list_onlien_user = [
            {'id1':'name1'},
            {'id2':'name2'},
        }
      
  • 7: 刷新的用户列表数据是一个列表,现在要更改

    •   { #服务端发给客户端的数据体
            'flag': 'flush' #数据标志位
            'data': [在线用户列表]
        }
      
  • 8: 发给其他用户的数据,怎么发过去?

    •   { #服务端发给客户端的数据体
            'flag': 'forward' #数据标志位
            'data': {
                'send_name': '123455', #发送者的ID
                'message': '123456', #接收人的ID号
            }
        }
      

五,代码编写如下:

#服务端
import socket
from multiprocessing.pool import ThreadPool
import pickle
import copy
import time

class TalkServer:
    def __init__(self,ip,port):
        self.ip = ip
        self.port = port
        self.socket_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket_server.setblocking(0) #服务端套接字设置为非阻塞
        self.socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #设置端口复用
        self.socket_server.bind( (self.ip, self.port) )

        self.dict_online_user = {} #保存未来的在线用户字典
        self.list_online_user = [] #保存即将发送给别人在现在用户列表
        self.thread_pool = ThreadPool(10)

        self.is_flush = False #用来判断是否需要刷新在线用户的

    def run(self, num_=5):
        self.socket_server.listen(num_)
        #2:用户发送给别人的消息处理
        self.thread_pool.apply_async(func=self.inform_online_user_list)
        self.thread_pool.apply_async(func=self.check_send_data)
        while True:
            '''
                接收用户来访
            '''
            try:
                client,client_addr = self.socket_server.accept()
            except BlockingIOError:
                pass
            else:
                print('有人来了:[%s|%s]' % client_addr)
                #没报错,那么就是用户真正的连接到了,accept捕捉到了返回值
                #1:用户登陆发来的消息处理,开一个线程去等待他发来对应的数据,或者说判断这个ID是否是重复的
                self.thread_pool.apply_async(func=self.check_login_data,args=(client,))
                #login数据

    def inform_online_user_list(self):
        '''
            告知客户端现在的在线用户,就是直接发送一个在线用户的列表
        '''
        while True:
            if self.is_flush:
                time.sleep(1)
                print('刷新在线用户')
                send_online_user_msg = {
                    'flag': 'flush',
                    'data': self.list_online_user,
                }

                for id in self.dict_online_user:
                    client = self.dict_online_user[id]['socket']
                    client.send(pickle.dumps(send_online_user_msg))
                self.is_flush = False

    def check_send_data(self):
        '''
            处理用户的发送数据,要发给别人拉
            还会碰到用户发来的断开连接的数据
        '''
        while True:
            list_onlien_user_bak = copy.copy(self.list_online_user)
            for data in list_onlien_user_bak: #[{'id1':'name1'},{'id1':'name1'}...]
                id = list(data.keys())[0]
                client = self.dict_online_user[id]['socket'] #套接字拿到
                name = self.dict_online_user[id]['name']
                #print('当前遍历到的在线用户,%s:%s' % (id,name))
                try:
                    recv_msg = client.recv(1024) #非阻塞形式获取客户端发来的数据
                except BlockingIOError as e:
                    pass #当前该在线用户并没有发送任何消息
                except ConnectionResetError as e:
                    '''
                        客户端断开连接
                    '''
                    pass
                else:
                    #1:判断是否是断开的数据
                    if not recv_msg:
                        print('离开了:%s,%s' % (id,name))
                        client.close()
                        del self.dict_online_user[id]
                        self.list_online_user.remove(data)
                        self.is_flush = True
                    else:
                        '''
                            { #发送数据体
                                'flag': 'send' #数据标志位
                                'data': {
                                    'send_id': '123455', #发送者的ID
                                    'recv_id': '123456', #接收人的ID号
                                    'message: 'xxxxx', #发给别人的数据
                                }
                            }
                        '''
                        clear_recv_msg = pickle.loads(recv_msg)
                        if clear_recv_msg.get('flag') == 'send': #确实是要给别人发送消息
                            clear_recv_data = clear_recv_msg.get('data')
                            if clear_recv_data: #发来的数据中确实有data
                                send_id = clear_recv_data.get('send_id')
                                recv_id = clear_recv_data.get('recv_id')
                                message = clear_recv_data.get('message')

                                if self.dict_online_user.get(recv_id):
                                    recv_socket = self.dict_online_user.get(recv_id)['socket'] #接收者的套接字
                                else:
                                    continue
                                send_name = self.dict_online_user[send_id]['name']#发送者的名字
                                '''
                                { #服务端发给客户端的数据体
                                    'flag': 'forward' #数据标志位
                                    'data': {
                                        'send_name': '123455', #发送者的ID
                                        'message': '123456', #接收人的ID号
                                    }
                                }
                                '''
                                forward_data = {
                                    'flag': 'forward',
                                    'data': {
                                        'send_name': send_name,
                                        'message': message,
                                    }
                                }
                                recv_socket.send(pickle.dumps(forward_data))
                                print('消息转发完毕:\n',forward_data)

    def check_login_data(self,client):
        '''
            { #登陆数据体
                'flag': 'login', #数据标志位
                'data': {
                    'id': '123456', #用户ID
                    'name: 'xxxxx', #用户昵称
                }
            }
        '''
        recv_msg = client.recv(1024) #接收用户发来的login数据体
        if recv_msg: #发来的数据是有效的
            clear_recv_msg = pickle.loads(recv_msg)
            if clear_recv_msg.get('flag') == 'login': #发来的确实是login的数据
                clear_recv_data = clear_recv_msg.get('data')
                if clear_recv_data: #发来的数据中确实有data
                    id = clear_recv_data.get('id')
                    name = clear_recv_data.get('name')
                    #判断ID是否重复
                    if id in self.dict_online_user:
                        print('[%s:%s]该用户出现重复ID' % (id, name))
                        send_login_msg = {
                            'flag': 'login',
                            'data': {
                                'state': False,
                                'message': 'ID使用重复',
                            }
                        }
                        client.send(pickle.dumps(send_login_msg)) #给客户端返回错误信息
                    elif not id or not name:
                        print('[%s:%s]该用户所需数据为空' % (id, name))
                        send_login_msg = {
                            'flag': 'login',
                            'data': {
                                'state': False,
                                'message': 'ID或名字为空',
                            }
                        }
                        client.send(pickle.dumps(send_login_msg)) #给客户端返回错误信息
                    else:
                        '''
                        dict_onlien_user = {
                            xxxx:{
                                'name':'666',
                                'socket':client,
                            ...
                            },
                        '''
                        client.setblocking(0) #真正存储在在线字典里的用户套接字是个非阻塞的
                        self.dict_online_user[id] = {
                            'name': name,
                            'socket': client,
                        }
                        self.list_online_user.append( {id:name} )
                        #刷新在线用户
                        print('在线用户已添加')
                        self.is_flush = True
                        send_login_msg = {
                            'flag': 'login',
                            'data': {
                                'state': True,
                                'message': '登陆成功',
                            }
                        }
                        client.send(pickle.dumps(send_login_msg))
                        return
        client.close() #用户数据无效,关闭连接

def main():
    ip = ''
    port = 8000
    tks = TalkServer(ip, port)
    tks.run()

if __name__ == '__main__':
    main() 

  运行结果:

点赞
收藏
评论区
推荐文章
blmius blmius
2年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
Karen110 Karen110
2年前
一篇文章带你了解JavaScript日期
日期对象允许您使用日期(年、月、日、小时、分钟、秒和毫秒)。一、JavaScript的日期格式一个JavaScript日期可以写为一个字符串:ThuFeb02201909:59:51GMT0800(中国标准时间)或者是一个数字:1486000791164写数字的日期,指定的毫秒数自1970年1月1日00:00:00到现在。1\.显示日期使用
Jacquelyn38 Jacquelyn38
2年前
2020年前端实用代码段,为你的工作保驾护航
有空的时候,自己总结了几个代码段,在开发中也经常使用,谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
皕杰报表之UUID
​在我们用皕杰报表工具设计填报报表时,如何在新增行里自动增加id呢?能新增整数排序id吗?目前可以在新增行里自动增加id,但只能用uuid函数增加UUID编码,不能新增整数排序id。uuid函数说明:获取一个UUID,可以在填报表中用来创建数据ID语法:uuid()或uuid(sep)参数说明:sep布尔值,生成的uuid中是否包含分隔符'',缺省为
Stella981 Stella981
2年前
Python之time模块的时间戳、时间字符串格式化与转换
Python处理时间和时间戳的内置模块就有time,和datetime两个,本文先说time模块。关于时间戳的几个概念时间戳,根据1970年1月1日00:00:00开始按秒计算的偏移量。时间元组(struct_time),包含9个元素。 time.struct_time(tm_y
Wesley13 Wesley13
2年前
mysql设置时区
mysql设置时区mysql\_query("SETtime\_zone'8:00'")ordie('时区设置失败,请联系管理员!');中国在东8区所以加8方法二:selectcount(user\_id)asdevice,CONVERT\_TZ(FROM\_UNIXTIME(reg\_time),'08:00','0
Wesley13 Wesley13
2年前
00:Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork),斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。Java是简单易学,完全面向对象,安全可靠,与平台无关的编程语言。
Stella981 Stella981
2年前
Django中Admin中的一些参数配置
设置在列表中显示的字段,id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
Wesley13 Wesley13
2年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
Python进阶者 Python进阶者
4个月前
Excel中这日期老是出来00:00:00,怎么用Pandas把这个去除
大家好,我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下:这日期老是出来00:00:00,怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下:pd.toexcel之前把这