您的位置:澳门皇家赌场真人在线 > 皇家赌场游戏 > 设计方式,调用腾讯云API的实例

设计方式,调用腾讯云API的实例

发布时间:2019-11-15 12:37编辑:皇家赌场游戏浏览(124)

    EventHandler定义如下

    supervisor

    supervisor 是基于 python 的任务管理工具,用来机关运营各样后台职责,当然你也能一向利用 nohup 命令使职责自动后台运维,但倘诺要重启职责,每回都友好手动 kill 掉任务过程,这样很麻烦,何况风流倜傥旦程序不当变成进程退出的话,系统也无从自动重载任务。

    此地邓超先生要配置基于virtualenv的supervisor

    是因为supervisor在python3下不能够使用,由此不能不用python2去下载!!!!!!

    #注意此时已经退出虚拟环境了!!!!!
    yum install python-setuptools
    easy_install supervisor
    

    由此命令生成supervisor的配支文件

    echo_supervisord_conf > /etc/supervisord.conf
    

    然后再/etc/supervisord.conf末尾增多上如下代码!!!!!!

    [program:my]
    #command=/opt/venv/bin/uwsgi --ini  /etc/uwsgi_nginx.ini  #这里是结合virtualenv的命令 和supervisor的精髓!!!!
    command= /home/venv/bin/uwsgi --uwsgi 0.0.0.0:8000 --chdir /opt/mysite --home=/home/venv --module mysite.wsgi
    #--home指的是虚拟环境目录  --module找到 mysite/wsgi.py
    
    directory=/opt/mysite
    startsecs=0
    stopwaitsecs=0
    autostart=true
    autorestart=true
    

    聊到底运转supervisor,达成uWSGI运行django,nginx反向代理

    supervisord -c /etc/supervisord.conf #启动supervisor
    supervisorctl -c /etxc/supervisord.conf restart my  #重启my项目
    supervisorctl -c /etc/supervisord.conf [start|stop|restart] [program-name|all]
    

     重新加载supervisor

    一、添加好配置文件后
    
    二、更新新的配置到supervisord    
    
    supervisorctl update
    三、重新启动配置中的所有程序
    
    supervisorctl reload
    四、启动某个进程(program_name=你配置中写的程序名称)
    
    supervisorctl start program_name
    五、查看正在守候的进程
    
    supervisorctl
    六、停止某一进程 (program_name=你配置中写的程序名称)
    
    pervisorctl stop program_name
    七、重启某一进程 (program_name=你配置中写的程序名称)
    
    supervisorctl restart program_name
    八、停止全部进程
    
    supervisorctl stop all
    注意:显示用stop停止掉的进程,用reload或者update都不会自动重启。
    

    网络

    生龙活虎、 贰次握手

    1. 客户端通过向劳动器端发送八个SYN来创设四个积极性张开,作为三回握手的风流罗曼蒂克有个别。顾客端把这段连接的序号设定为随机数 A。
    2. 劳动器端应当为三个法定的SYN回送贰个SYN/ACK。ACK 的确认码应为A+1,SYN/ACK 包本人又有八个专断序号 B。
    3. 末尾,客商端再发送叁个ACK。当服务端受到那么些ACK的时候,就完事了三路握手,并踏向了延续创立状态。当时包序号被设定为选拔的确认号 A+1,而响应则为 B+1。

    二、七遍挥手

    留意: 中断连接端能够是顾客端,也能够是服务器端. 上边仅以客商端断开连接举个例子, 反之亦然.

    1. 客商端发送一个数额分段, 在那之中的 FIN 标识设置为1. 客商端步向 FIN-WAIT 状态. 这场所下顾客端只接受数据, 不再发送数据.
    2. 服务器收到到含有 FIN = 1 的数额分段, 发送带有 ACK = 1 的盈余数量分段, 确认收到客商端发来的 FIN 音信.
    3. 服务器等到持有数据传输甘休, 向顾客端发送叁个分包 FIN = 1 的多少分段, 并步入 CLOSE-WAIT 状态, 等待顾客端发来含有 ACK = 1 的承认报文.
    4. 客商端收到服务器发来含有 FIN = 1 的报文, 再次回到 ACK = 1 的报文确认, 为了防卫服务器端未接收须求重发, 走入 TIME-WAIT 状态. 服务器收到到报文后关门连接. 客户端等待 2MSL 后未接到回复, 则以为服务器成功关闭, 顾客端关闭连接.

    三、ARP协议

    地方深入解析左券(Address Resolution Protocol),其基本成效为经过指标设备的IP地址,查询目的的MAC地址,以管教通讯的顺遂实行。它是IPv4网络层必不可缺的协商,但是在IPv6中已不再适用,并被街坊开掘契约(NDP卡塔 尔(阿拉伯语:قطر‎所取代。

    四、urllib和urllib2的区别

    本条面试官确实问过,那时候答的urllib2能够Post而urllib无法.

    1. urllib提供urlencode方法用来GET查询字符串的发出,而urllib2未有。那是为什么urllib常和urllib2一齐使用的来头。
    2. urllib2能够担当五个Request类的实例来安装U哈弗L必要的headers,urllib仅能够承担URubiconL。那意味着,你不得以伪装你的User Agent字符串等。

    五、Post和Get

    GET和POST有哪些界别?及为啥网络的大部答案都是错的 今日头条回答

    get: RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1 post: RFC 2616 - Hypertext Transfer Protocol -- HTTP/1.1

    六、Cookie和Session

    CookieSession储存地点客户端服务器端指标追踪会话,也得以保留客户偏爱设置只怕封存客户名密码等跟踪会话安全性不安全无恙

    session技巧是要利用到cookie的,之所以现身session本事,首尽管为着安全。

    七、apache和nginx的区别

    nginx 相对 apache 的优点:

    • 轻量级,相像起web 服务,比apache 占用更加少的内部存款和储蓄器及财富
    • 抗并发,nginx 管理央求是异步非堵塞的,支持更加多的产出连接,而apache 则是拥塞型的,在高并发下nginx 能保持低财富低消耗高质量
    • 配置简洁
    • 可观模块化的宏图,编写模块相对简单
    • 社区活泼

    apache 相对nginx 的优点:

    • rewrite ,比nginx 的rewrite 强大
    • 模块超多,基本想到的都得以找到
    • 少bug ,nginx 的bug 相对很多
    • 超稳定

    八、 网址顾客密码保存

    1. 通晓保存
    2. 明文hash后保存,如md5
    3. MD5+Salt格局,那一个salt能够恣意
    4. 今日头条使用了Bcrypy(好像)加密

    九、 HTTP和HTTPS

    动静码定义1xx 报告吸收接纳到央求,继续进度2xx 打响步骤成功接到,被驾驭,并被接收3xx 重定向为了形成诉求,必需使用更为措施4xx 客商端出错诉求满含错的依次或无法到位5xx 服务器出错服务器不能到位显明有效的呼吁

    403: Forbidden 404: Not Found

    HTTPS握手,对称加密,非对称加密,TLS/SSL,中华VSA

    十、 XSRF和XSS

    • CSKugaF(Cross-site request forgery)跨站须要伪造
    • XSS(Cross Site Scripting)跨站脚本攻击

    CS奥迪Q7F注重在呼吁,XSS着重在剧本

    十一、幂等 Idempotence

    HTTP方法的幂等性是指贰次和频仍恳求某一个财富应该有着相通的副功效。(注意是副作用)

    不会转移财富的景色,无论调用一次如故N次都未曾副功能。请小心,这里重申的是叁回和N次具备同等的副功用,并非历次GET的结果相仿。

    本条HTTP诉求只怕会每一回取得不一样的结果,但它自身并未发生其余副功效,因此是满意幂等性的。

    DELETE方法用于删除财富,有副效能,但它应有知足幂等性。

    调用一回和N次对系统暴发的副成效是平等的,即删掉id为4231的帖子;因而,调用者能够频仍调用或刷新页面而不必缅想引起错误。

    POST所对应的U福睿斯I并不是成立的能源自己,而是财富的收信人。

    HTTP响应中应满含帖子的成立状态以致帖子的U哈弗I。五遍相同的POST央浼会在劳务器端创造两份财富,它们具备分歧的U库罗德I;所以,POST方法不享有幂等性。

    PUT所对应的U奇骏I是要成立或更新的财富本身。比如:PUT

    十二、RESTful架构(SOAP,RPC)

    详见教程能够在互连网搜索一下

    十三、 SOAP

    SOAP(原为Simple Object Access Protocol的首字母缩写,即简单对象访问公约卡塔尔国是换来数据的朝气蓬勃种契约正式,使用在计算机互连网Web服务(web service卡塔尔中,交流带结构消息。SOAP为了简化网页服务器(Web Server卡塔 尔(阿拉伯语:قطر‎从XML数据库中领取数额时,节省去格式化页面时间,以致差异应用程序之间遵照HTTP通讯左券,据守XML格式施行资料交流,使其抽象于言语完结、平台和硬件。

    十四、RPC

    RPC(Remote Procedure Call Protocol卡塔尔国——远程进程调用合同,它是生龙活虎种通过互联网从远程Computer程序上呼吁服务,而没有须要通晓底层互联网本事的情商。RPC切磋若是有些传输公约的存在,如TCP或UDP,为通讯程序之间辅导新闻数量。在OSI网络通讯模型中,RPC凌驾了传输层和应用层。RPC使得开采包含互连网布满式多程序在内的应用程序尤其轻易。

    总计:服务提供的两大流派.古板意义以艺术调用为导向通称RPC。为了集团SOA,若干厂商联合推出webservice,制定了wsdl接口定义,传输soap.当网络时期,肥胖SOA被简化为http+xml/json.可是简化出现各个混乱。以财富为导向,任何操作无非是对财富的增加和删除改查,于是统豆蔻梢头的REST现身了.

    开采进取的逐一: RPC -> SOAP -> RESTful

    十五、CGI和WSGI

    CGI是通用网关接口,是连连web服务器和应用程序的接口,客商通过CGI来拿到动态数据或文件等。 CGI程序是二个独门的前后相继,它能够用大致全数语言来写,包蕴perl,c,lua,python等等。

    WSGI, Web Server Gateway Interface,是Python应用程序或框架和Web服务器之间的大器晚成种接口,WSGI的中间贰个目标正是让顾客能够用联合的言语(Python)编写前后端。

    法定表明:PEP-3333

    十七、中间人攻击

    在GFW里何足为奇的,呵呵.

    中档人抨击(Man-in-the-middle attack,通常缩写为MITM卡塔 尔(英语:State of Qatar)是指攻击者与电视发表的两岸分别创造独立的沟通,并互换其所选取的数据,使通信的双边认为他俩正在通过三个私密的一而再延续与对方直接对话,但实际上整个会话都被攻击者完全调整。

    十七、 c10k问题

    所谓c10k难点,指的是服务器同一时间扶植广大个客商端的标题,也正是concurrent 10 000 connection(那也是c10k以此名字的由来卡塔 尔(英语:State of Qatar)。

    十八、socket

    详细教程小编就不意气风发一列举了,大家能够活动物检疫索一下。

    十六、浏览器缓存

    详细教程笔者就不后生可畏一列举了,大家能够活动物检疫索一下。

    304 Not Modified

    二十、 HTTP1.0和HTTP1.1

    1. 乞求头Host字段,四个服务器多个网址
    2. 长链接
    3. 文件断点续传
    4. 地点注解,状态管理,Cache缓存

    HTTP需要8种格局介绍 HTTP/1.1共谋中国共产党定义了8种HTTP央浼方法,HTTP须求方法也被称得上“央浼动作”,差别的法子规定了差别的操作钦命的能源形式。服务端也会依据分裂的诉求方法做分裂的响应。

    GET

    GET须要会展现央浼内定的能源。平日的话GET方法应该只用于数据的读取,而不应有用于会发出副成效的非幂等的操作中。

    GET会办法乞求钦赐的页面新闻,并回到响应大旨,GET被以为是不安全的议程,因为GET方法会被互连网蜘蛛等随便的访问。

    HEAD

    HEAD方法与GET方法黄金时代致,都以向服务器发出钦定能源的乞请。可是,服务器在响应HEAD央浼时不会回传能源的内容部分,即:响应中央。那样,我们得以不传输全体内容的境况下,就足以拿到服务器的响应头音讯。HEAD方法常被用来客商端查看服务器的天性。

    POST

    POST诉求会 向内定能源提交数据,央浼服务器进行管理,如:表单数据交由、文件上传等,央求数据会被含有在诉求体中。POST方法是非幂等的章程,因为这么些央求大概会创立新的财富或/和修正现成能源。

    PUT

    PUT诉求会身向钦点能源职责上传其最新内容,PUT方法是幂等的点子。通过该办法客户端能够将内定财富的风行数据传送给服务器替代钦命的财富的内容。

    DELETE

    DELETE央浼用于诉求服务器删除所央求U昂科雷I(统一能源标志符,Uniform Resource Identifier卡塔尔所标志的能源。DELETE要求后钦命能源会被去除,DELETE方法也是幂等的。

    CONNECT

    CONNECT方法是HTTP/1.1商量预先留下的,能够将接连改为管道格局的代理服务器。经常用于SSL加密服务器的链接与非加密的HTTP代理服务器的通讯。

    OPTIONS

    OPTIONS央浼与HEAD相同,日常也是用于顾客端查看服务器的习性。 这么些方法会央求服务器重返该财富所支撑的兼具HTTP央求方法,该方法会用’*’来代替财富名称,向服务器发送OPTIONS央求,能够测量试验服务器效用是还是不是符合规律。JavaScript的XMLHttpRequest对象开展CO途乐S跨域财富分享时,就是利用OPTIONS方法发送嗅探央浼,以剖断是否有对点名能源的拜谒权限。 允许

    TRACE

    TRACE央求服务器回显其收受的恳求新闻,该措施首要用于HTTP央求的测验或确诊。

    HTTP/1.1今后扩张的法子

    在HTTP/1.1正经制订之后,又陆陆续续扩展了部分艺术。在那之中使用中超级多的是 PATCH 方法:

    PATCH

    PATCH方法现身的较晚,它在二零一零年的瑞虎FC 5789正经中被定义。PATCH央求与PUT央求相像,同样用于财富的立异。二者有以下两点不相同:

    但PATCH日常用来能源的部分更新,而PUT平时用于财富的总体制改进进。 当财富不设有的时候,PATCH会创设三个新的能源,而PUT只会对已在能源举行更新。

    二十一、Ajax

    AJAX,Asynchronous JavaScript and XML(异步的 JavaScript 和 XML卡塔尔国, 是与在不重复加载整个页面的景况下,与服务器沟通数据并更新部分网页的本事。

    接下来再次创下造加减乘除类,以便工厂进行调用

           //获取时间戳 .net framework
                /*
                DateTime dt = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1)); 
                int time = (int)(DateTime.Now - dt).TotalSeconds;
                String Timestamp = time.ToString();
                */
                // .net core 获取时间戳
                DateTime dt = new DateTime(1970, 1, 1,0, 0, 0, DateTimeKind.Utc);
                int time = (int)(DateTime.Now.AddHours(-8) - dt).TotalSeconds;
                String Timestamp = time.ToString();
                //随机正整数,用于防止重放攻击
                Random rd = new Random();
                int rd_i = rd.Next();
                String nonce = Convert.ToString(rd_i);
                //SecretId
                String SecretId = "";
                //参数(用于编码)
                String PostStr = string.Format("Action=DescribeLVBChannelList&Nonce={0}&Region=bj&SecretId={1}&Timestamp={2}", nonce, SecretId, Timestamp);
                //地址
                String url = "https://live.api.qcloud.com/v2/index.php";
                //编码
                UTF8Encoding enc = new UTF8Encoding();
                String qm = "POSTlive.api.qcloud.com/v2/index.php"  + "?" + PostStr;
                byte[] dataToHash = enc.GetBytes(qm);
                /*
                var sha1 = SHA1.Create();
                var result = sha1.ComputeHash(dataToHash);
                */  
                HMACSHA1 hmac = new HMACSHA1()
                {
                    Key = enc.GetBytes("")
                };
                var result = hmac.ComputeHash(dataToHash);
                string Signature = Convert.ToBase64String(result);
                //完整参数
                var completeUrl = string.Format("Action=DescribeLVBChannelList&Nonce={0}&Region=bj&SecretId={1}&Signature={2}&Timestamp={3}", nonce, SecretId, Signature, Timestamp);
    
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Method = "POST";
                request.ContentType = "application/x-www-form-urlencoded";
                request.ProtocolVersion = HttpVersion.Version10;
                byte[] data = Encoding.UTF8.GetBytes(completeUrl);
                request.ContentLength = data.Length;
                Stream newStream = request.GetRequestStream();
                newStream.Write(data, 0, data.Length);
                newStream.Close();
                HttpWebResponse response = null;
                int httpStatus = 200;
                string content;
                try
                {
                    response = (HttpWebResponse)request.GetResponse();
                    httpStatus = (int)response.StatusCode;
                    StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
                    content = reader.ReadToEnd();
                }
                catch (WebException e)
                {
                    response = (HttpWebResponse)e.Response;
                    httpStatus = (int)response.StatusCode;
                    using (Stream errData = response.GetResponseStream())
                    {
                        using (StreamReader reader = new StreamReader(errData))
                        {
                            content = reader.ReadToEnd();
                        }
                    }
                }
    
    public delegate void RoutedEventHandler(
     Object sender,
     RoutedEventArgs e
    )
    

    我们都精晓django是多少个web框架,方便大家飞速支付web程序,http央求的动态数据正是由web框架来提供管理的。

    *NIX

    unix进度间通讯格局(IPC)

    1. 管道(Pipe卡塔 尔(英语:State of Qatar):管道可用于拥有赤子情关系进度间的通讯,允许一个历程和另三个与它有一起达内先的历程之间打开通讯。
    2. 命名管道(named pipe卡塔 尔(阿拉伯语:قطر‎:命名管道制伏了管道没有名字的界定,由此,除具备管道所具备的职能外,它还同意无赤子情关系进度间的通讯。命名管道在文件系统中有对应的公文名。命名管道通过命令mkfifo或体系调用mkfifo来创造。
    3. 功率信号(Signal卡塔尔国:实信号是比较复杂的通讯形式,用于通告接受进度有某种事件产生,除了用于进度间通讯外,进程还足以发送实信号给进程自己;linux除了支持Unix开始的意气风发段时代实信号语义函数sigal外,还扶助语义切合Posix.1标准的非确定性信号函数sigaction(实际上,该函数是依靠BSD的,BSD为了落到实处可相信复信号机制,又能够合併对外接口,用sigaction函数重新完结了signal函数卡塔尔国。
    4. 新闻(Message卡塔 尔(英语:State of Qatar)队列:音讯队列是消息的链接表,满含Posix音讯队列system V音信队列。有丰硕权限的经过可以向队列中增加新闻,被付与读权限的长河则足以读走队列中的新闻。音讯队列克服了非实信号承载音信量少,管道只好承载无格式字节流甚至缓冲区大大小小受限等缺
    5. 共享内存:使得七个经过可以访谈同一块内部存款和储蓄器空间,是最快的可用IPC格局。是指向任何通讯机制运作作用极低而规划的。往往与别的通信机制,如时域信号量结合使用,来到达进程间的一路及互斥。
    6. 内部存款和储蓄器映射(mapped memory卡塔 尔(阿拉伯语:قطر‎:内部存款和储蓄器映射允许任何八个进程间通信,每八个行使该机制的长河经过把二个分享的文书映射到协调的进度地址空间来兑现它。
    7. 时限信号量(semaphore卡塔 尔(阿拉伯语:قطر‎:首要用作进程间甚至雷同进程分化线程之间的多头手段。
    8. 套接口(Socket卡塔 尔(英语:State of Qatar):更为相通的经过间通讯机制,可用于差异机器之间的长河间通讯。早先是由Unix系统的BSD分支开垦出来的,但近年来貌似能够移植到任何类Unix系统上:Linux和System V的变种都帮助套接字。

    看了牛皮设计格局之后感触很深,挖掘自身还会有超多读书的事物,设计软件并非大器晚成两句代码把职能写完了就能够,须求思谋的内容有广大

     

    public delegate void TestDelegate(string message);                                                  
    public event TestDelegate testEvent;
    

    逻辑图

    图片 1

    web服务器

    传统的c/s架构,请求的过程是
    客户端 > 服务器 
    服务器 > 客户端
    服务器就是:1.接收请求 2.处理请求 3.返回响应
    

    web框架层

    HTTP的动态数据交给web框架,例如django遵循MTV模式处理请求。
    HTTp协议使用url定位资源,urls.py将路由请求交给views视图处理,然后返回一个结果,完成一次请求。
    web框架使用者只需要处理业务的逻辑即可。
    

    尽管将一次通讯转变为“对话”的经过

    Nginx:hello wsgi,小编刚接到一个伸手,你筹划下然后让django来管理呢

    WSGI:好的nginx,作者立即安装情形变量,然后把诉求提交django

    Django:多谢WSGI,笔者处理完诉求立时给你响应结果

    WSGI:好的,作者在等着

    Django:解决啦,麻烦wsgi吧响应结果传递给nginx

    WSGI:太棒了,nginx,响应结果请收好,已经依照须要传递给您了

    nginx:好滴。小编把响应交给客商。同盟欢欣

    图片 2

    代码来源仿效大话设计方式那本书,这里在博客里记录一下,不容许每一趟都去翻书,可是在博客里面是极度好找的。

    事件是散落,以自己的博客为宗旨,向具备订阅者发送音讯。大家把这种分散称之为[多播]。

    wsgi    全称web server gateway interface,wsgi不是服务器,也不是python模块,只是一种协议,描述web server如何和web application通信的规则。
    运行在wsgi上的web框架有bottle,flask,django
    
    uwsgi    和wsgi一样是通信协议,是uWSGI服务器的单独协议,用于定义传输信息的类型
    
    uWSGI    是一个web服务器,实现了WSGI协议,uwsgi协议。a
    
    nginx    web服务器,更加安全,更好的处理处理静态资源,缓存功能,负载均衡,因此nginx的强劲性能,配合uWSGI服务器会更加安全,性能有保障。
    
    django 高级的python web框架,用于快速开发,解决web开发的大部分麻烦,程序员可以更专注业务逻辑,无须重新造轮子
    

    编程题

    风姿罗曼蒂克、台阶难点/斐波那契

    二只青蛙三次能够跳上1级台阶,也可以跳上2级。求该立卧撑上三个n级的台阶总共有稍许种跳法。

    fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)

    第三种纪念方法

    def memo(func):

    cache = {}

    def wrap(*args):

    if args not in cache:

    cache[args] = func(*args)

    return cache[args]

    return wrap

    @memo

    def fib(i):

    if i < 2:

    return 1

    return fib(i-1) + fib(i-2)

    其二种办法

    def fib(n):

    a, b = 0, 1

    for _ in xrange(n):

    a, b = b, a + b

    return b

    二、反常台阶难题

    三只青蛙三遍能够跳上1级台阶,也得以跳上2级……它也得以跳上n级。求该立卧撑上二个n级的阶梯总共有微微种跳法。

    fib = lambda n: n if n < 2 else 2 * fib(n - 1)

    三、矩形覆盖

    大家能够用2*1的小矩形横着大概竖着去覆盖越来越大的矩形。请问用n个2*1的小矩形无重叠地覆盖叁个2*n的大矩形,总共有多少种方法?

    第2*n个矩形的覆盖措施等于第2*(n-1)加上第2*(n-2)的方法。

    f = lambda n: 1 if n < 2 else f(n - 1) + f(n - 2)

    四、杨氏矩阵查找

    在多个m行n列二维数组中,每生机勃勃行都服从从左到右递增的次第排序,每一列都依据从上到下依次增加的顺序排序。请达成二个函数,输入那样的三个二维数组和一个整数,推断数组中是不是带有该整数。

    使用Step-wise线性搜索。

    def get_value(l, r, c):

    return l[r][c]

    def find(l, x):

    m = len(l) - 1

    n = len(l[0]) - 1

    r = 0

    c = n

    while c >= 0 and r <= m:

    value = get_value(l, r, c)

    if value == x:

    return True

    elif value > x:

    c = c - 1

    elif value < x:

    r = r + 1

    return False

    五、去除列表中的重复元素

    用集合

    list(set(l))

    用字典

    l1 = ['b','c','d','b','c','a','a']

    l2 = {}.fromkeys(l1).keys()

    print l2

    用字典并保持顺序

    l1 = ['b','c','d','b','c','a','a']

    l2 = list(set(l1))

    l2.sort(key=l1.index)

    print l2

    列表推导式

    l1 = ['b','c','d','b','c','a','a']

    l2 = []

    [l2.append(i) for i in l1 if not i in l2]

    sorted排序何况用列表推导式.

    l = ['b','c','d','b','c','a','a'] [single.append(i) for i in sorted(l) if i not in single] print single

    七、链表成对交换

    1->2->3->4转换成2->1->4->3.

    class ListNode:

    def __init__(self, x):

    self.val = x

    self.next = None

    class Solution:

    # @param a ListNode

    # @return a ListNode

    def swapPairs(self, head):

    if head != None and head.next != None:

    next = head.next

    head.next = self.swapPairs(next.next)

    next.next = head

    return next

    return head

    七、创制字典的格局

    1 直接创制

    dict = {'name':'earth', 'port':'80'}

    2 工厂方法

    items=[('name','earth'),('port','80')]

    dict2=dict(items)

    dict1=dict((['name','earth'],['port','80']))

    3 fromkeys()方法

    dict1={}.fromkeys(('x','y'),-1)

    dict={'x':-1,'y':-1}

    dict2={}.fromkeys(('x','y'))

    dict2={'x':None, 'y':None}

    八、合併三个不改变列表

    今日头条远程面试要求编制程序

    尾递归

    def _recursion_merge_sort2(l1, l2, tmp):

    if len(l1) == 0 or len(l2) == 0:

    tmp.extend(l1)

    tmp.extend(l2)

    return tmp

    else:

    if l1[0] < l2[0]:

    tmp.append(l1[0])

    del l1[0]

    else:

    tmp.append(l2[0])

    del l2[0]

    return _recursion_merge_sort2(l1, l2, tmp)

    def recursion_merge_sort2(l1, l2):

    return _recursion_merge_sort2(l1, l2, [])

    循环算法

    思路:

    概念三个新的空驶列车表

    正如五个列表的第多个成分

    小的就插入到新列表里

    把曾经插入新列表的要素从旧列表删除

    甘休多少个旧列表有二个为空

    再把旧列表加到新列表后边

    def loop_merge_sort(l1, l2):

    tmp = []

    while len(l1) > 0 and len(l2) > 0:

    if l1[0] < l2[0]:

    tmp.append(l1[0])

    del l1[0]

    else:

    tmp.append(l2[0])

    del l2[0]

    tmp.extend(l1)

    tmp.extend(l2)

    return tmp

    pop弹出

    a = [1,2,3,7]

    b = [3,4,5]

    def merge_sortedlist(a,b):

    c = []

    while a and b:

    if a[0] >= b[0]:

    c.append(b.pop(0))

    else:

    c.append(a.pop(0))

    while a:

    c.append(a.pop(0))

    while b:

    c.append(b.pop(0))

    return c

    print merge_sortedlist(a,b)

    九、交叉链表求交点

    实际上用脑筋想能够依据从尾最早相比很多个链表,假若相交,则从尾开端必然后生可畏致,只要从尾起始比较,直至不均等的地点即为交叉点,如图所示

    图片 3

     

    # 使用a,b多少个list来模拟链表,能够看来交叉点是 7那几个节点

    a = [1,2,3,7,9,1,5]

    b = [4,5,7,9,1,5]

    for i in range(1,min(len(a),len(b))):

    if i==1 and (a[-1] != b[-1]):

    print "No"

    break

    else:

    if a[-i] != b[-i]:

    print "交叉节点:",a[-i+1]

    break

    else:

    pass

    其余风姿罗曼蒂克种相比正规的方式,构造链表类

    class ListNode:

    def __init__(self, x):

    self.val = x

    self.next = None

    def node(l1, l2):

    length1, lenth2 = 0, 0

    # 求多少个链表长度

    while l1.next:

    l1 = l1.next

    length1 += 1

    while l2.next:

    l2 = l2.next

    length2 += 1

    # 长的链表先走

    if length1 > lenth2:

    for _ in range(length1 - length2):

    l1 = l1.next

    else:

    for _ in range(length2 - length1):

    l2 = l2.next

    while l1 and l2:

    if l1.next == l2.next:

    return l1.next

    else:

    l1 = l1.next

    l2 = l2.next

    修正了生龙活虎晃:

    #coding:utf-8

    class ListNode:

    def __init__(self, x):

    self.val = x

    self.next = None

    def node(l1, l2):

    length1, length2 = 0, 0

    # 求八个链表长度

    while l1.next:

    l1 = l1.next#尾节点

    length1 += 1

    while l2.next:

    l2 = l2.next#尾节点

    length2 += 1

    #假定相交

    if l1.next == l2.next:

    #设计方式,调用腾讯云API的实例。 长的链表先走

    if length1 > length2:

    for _ in range(length1 - length2):

    l1 = l1.next

    return l1#回到交点

    else:

    for _ in range(length2 - length1):

    l2 = l2.next

    return l2#重回交点

    # 借使不相交

    else:

    return

    十、二分查找

    #coding:utf-8

    def binary_search(list,item):

    low = 0

    high = len(list)-1

    while low<=high:

    mid = (low+high)/2

    guess = list[mid]

    if guess>item:

    high = mid-1

    elif guess<item:

    low = mid+1

    else:

    return mid

    return None

    mylist = [1,3,5,7,9]

    print binary_search(mylist,3)

    十一、快排

    #coding:utf-8

    def quicksort(list):

    if len(list)<2:

    return list

    else:

    midpivot = list[0]

    lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]

    biggerafterpivot = [i for i in list[1:] if i > midpivot]

    finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)

    return finallylist

    print quicksort([2,4,6,7,1,2,5])

    更加多排序难点凸现:数据结构与算法-排序篇-Python描述

    十四、找零难点

    #coding:utf-8

    #values是硬币的面值values = [ 25, 21, 10, 5, 1]

    #valuesCounts 钱币对应的连串数

    #money 寻觅来的总钱数

    #coinsUsed 对应于最近货币总的数量i所使用的硬币数目

    def coinChange(values,valuesCounts,money,coinsUsed):

    #遍历出从1到money全部的钱数可能

    for cents in range(1,money+1):

    minCoins = cents

    #把全体的硬币面值遍历出来和钱数做相比较

    for kind in range(0,valuesCounts):

    if (values[kind] <= cents):

    temp = coinsUsed[cents - values[kind]] +1

    if (temp < minCoins):

    minCoins = temp

    coinsUsed[cents] = minCoins

    print ('面值:{0}的起码硬币使用数为:{1}'.format(cents, coinsUsed[cents]))

    十四、广度遍历和纵深遍历二叉树

    给定一个数组,塑造二叉树,况兼按档案的次序打字与印刷这么些二叉树

    十六、二叉树节点

    class Node(object):

    def __init__(self, data, left=None, right=None):

    self.data = data

    self.left = left

    self.right = right

    tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))

    十四、 档期的顺序遍历

    def lookup(root):

    row = [root]

    while row:

    print(row)

    row = [kid for item in row for kid in (item.left, item.right) if kid]

    十一、深度遍历

    def deep(root):

    if not root:

    return

    print root.data

    deep(root.left)

    deep(root.right)

    if __name__ == '__main__':

    lookup(tree)

    deep(tree)

    十一、 前中后序遍历

    纵深遍历改变各类就OK了

    #coding:utf-8

    #二叉树的遍历

    #大约的二叉树节点类

    class Node(object):

    def __init__(self,value,left,right):

    self.value = value

    self.left = left

    self.right = right

    #中序遍历:遍历左子树,访谈当前节点,遍历右子树

    def mid_travelsal(root):

    if root.left is None:

    mid_travelsal(root.left)

    #访问当前节点

    print(root.value)

    if root.right is not None:

    mid_travelsal(root.right)

    #前序遍历:访谈当前节点,遍历左子树,遍历右子树

    def pre_travelsal(root):

    print (root.value)

    if root.left is not None:

    pre_travelsal(root.left)

    if root.right is not None:

    pre_travelsal(root.right)

    #持续遍历:遍历左子树,遍历右子树,访谈当前节点

    def post_trvelsal(root):

    if root.left is not None:

    post_trvelsal(root.left)

    if root.right is not None:

    post_trvelsal(root.right)

    print (root.value)

    十三、求最大树深

    def maxDepth(root):

    if not root:

    return 0

    return max(maxDepth(root.left), maxDepth(root.right)) + 1

    十六、求两棵树是或不是生龙活虎致

    def isSameTree(p, q):

    if p == None and q == None:

    return True

    elif p and q :

    return p.val == q.val and isSameTree(p.left,q.left) and isSameTree(p.right,q.right)

    else :

    return False

    三十、前序中序求后序

    def rebuild(pre, center):

    if not pre:

    return

    cur = Node(pre[0])

    index = center.index(pre[0])

    cur.left = rebuild(pre[1:index + 1], center[:index])

    cur.right = rebuild(pre[index + 1:], center[index + 1:])

    return cur

    def deep(root):

    if not root:

    return

    deep(root.left)

    deep(root.right)

    print root.data

    八十生机勃勃、单链表逆置

    class Node(object):

    def __init__(self, data=None, next=None):

    self.data = data

    self.next = next

    link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))

    def rev(link):

    pre = link

    cur = link.next

    pre.next = None

    while cur:

    tmp = cur.next

    cur.next = pre

    pre = cur

    cur = tmp

    return pre

    root = rev(link)

    while root:

    print root.data

    root = root.next

    七十一、 三个字符串是还是不是是变位词

    class Anagram:

    """

    @:param s1: The first string

    @:param s2: The second string

    @:return true or false

    """

    def Solution1(s1,s2):

    alist = list(s2)

    pos1 = 0

    stillOK = True

    while pos1 < len(s1) and stillOK:

    pos2 = 0

    found = False

    while pos2 < len(alist) and not found:

    if s1[pos1] == alist[pos2]:

    found = True

    else:

    pos2 = pos2 + 1

    if found:

    alist[pos2] = None

    else:

    stillOK = False

    pos1 = pos1 + 1

    return stillOK

    print(Solution1('abcd','dcba'))

    def Solution2(s1,s2):

    alist1 = list(s1)

    alist2 = list(s2)

    alist1.sort()

    alist2.sort()

    pos = 0

    matches = True

    while pos < len(s1) and matches:

    if alist1[pos] == alist2[pos]:

    pos = pos + 1

    else:

    matches = False

    return matches

    print(Solution2('abcde','edcbg'))

    def Solution3(s1,s2):

    c1 = [0]*26

    c2 = [0]*26

    for i in range(len(s1)):

    pos = ord(s1[i])-ord('a')

    c1[pos] = c1[pos] + 1

    for i in range(len(s2)):

    pos = ord(s2[i])-ord('a')

    c2[pos] = c2[pos] + 1

    j = 0

    stillOK = True

    while j<26 and stillOK:

    if c1[j] == c2[j]:

    j = j + 1

    else:

    stillOK = False

    return stillOK

    print(Solution3('apple','pleap'))

    七十五、动态规划问题

    可参照:动态规划(DP)的重新整建-Python描述

     

    然则轻易工厂方式会存在四个标题,后续假诺新添方法的话那么还亟需一连创设运算类,然后实例化对象,那么这样会追加代码结构的复杂度,当然依旧有艺术化解的,可是此间就只做轻易工厂情势的牵线了,

    事件最广大的比如正是订阅,即,若是你订阅了自己的博客,那么,当小编发布新博客的时候,你就能获得照应。

    安装django1.11

    pip3 install django==1.11
    #创建django项目mysite
    django-admin startproject mysite
    #创建app01
    python3 manage.py startapp app01
    

    mysite/settings.py

    #settings.py设置
    ALLOWED_HOSTS = ['*']
    install app01
    

    mysite/urls.py

    from app01 import views
    urlpatterns = [
        url(r'^admin/', admin.site.urls),
        url(r'^hello_django/', views.hello),
    ]
    

    app01/views.py

    from django.shortcuts import render,HttpResponse
    
    # Create your views here.
    def hello(request):
        print('request is :',request)
        return HttpResponse('django is ok ')
    

     

    static void Main(string[] args)
            {
                Operation oper;
                oper = OperationFactory.CreateOperate("+");
                oper.NumberA = 1;
                oper.NumberB = 2;
                double result = oper.GetResult();
                Console.WriteLine(result);
                Console.ReadLine();
            }
    

    官方对事件的表达是这么的:类或对象足以经过事件向此外类或对象文告发出的有关业务。

    virtualenv

    请确保你的虚拟环境正常工作
    https://www.cnblogs.com/pyyu/p/9015317.html
    

    数据库

    一、事务

    数据库事务(Database Transaction) ,是指作为单个逻辑专业单元推行的一花样大多操作,要么完全地实施,要么完全地不执行。

    到底通晓数据库事务详细教程生龙活虎搜一大把,能够活动物检疫索一下。

    二、数据库索引

    MySQL索引背后的数据结构及算法原理

    聚焦索引,非聚焦索引,B-Tree,B+Tree,最左前缀原理

    三、Redis原理

    Redis是什么?

    1. 是多少个通通开源免费的key-value内部存款和储蓄器数据库
    2. 日常来说被以为是三个数据结构服务器,首倘若因为其兼具丰富的数据结构 strings、map、 list、sets、 sorted sets

    Redis数据库

    ​平时局限点来讲,Redis也以新闻队列的款型存在,作为内嵌的List存在,满意实时的高并发要求。在应用缓存的时候,redis比memcached具备更加多的优势,并且协理越多的数据类型,把redis当作二个个中存储系统,用来管理高并发的数据库操作

    • 速度快:使用标准C写,全体数据都在内部存款和储蓄器中做到,读写速度分别到达10万/20万
    • 持久化:对数码的改善选择Copy-on-write手艺,能够异步地保留到磁盘上,首要有二种政策,一是依附时间,更新次数的快速照相(save 300 10 卡塔尔二是基于语句追加情势(Append-only file,aof)
    • 自动操作:对两样数据类型的操作都以全自动的,很安全
    • 立刻的主--从复制,官方提供了三个数量,Slave在21秒即实现了对亚马逊(Amazon卡塔 尔(阿拉伯语:قطر‎网址10G key set的复制。
    • Sharding工夫: 相当轻便将数据遍布到多少个Redis实例中,数据库的强盛是个稳固的话题,在关系型数据库中,首就算以拉长硬件、以分区为尤为重要本领方式的纵向扩张消除了重重的使用处景,但随着web2.0、移动网络、云计算等利用的勃兴,这种扩大方式已经不太切合了,所以近来,像选取主从配置、数据库复制方式的,Sharding这种手艺把负载布满到三个特理节点上去的横向扩展形式用途越来越多。

    Redis缺点

    • 是数据库容积受到物理内部存款和储蓄器的范围,不能够用作海量数据的高性能读写,因而Redis相符的光景首要局限在一点都不大数据量的高质量操作和平运动算上。
    • Redis较难支撑在线扩大体量,在集群体积高达上有效期在线扩大体积会变得很复杂。为制止那黄金时代标题,启摄人心魄士在系统上线时必需保险有充足的半空中,那对能源产生了比异常的大的荒芜。

    四、乐观锁和消极锁

    悲观锁:假定会产生并发冲突,屏蔽一切大概违反数据完整性的操作

    乐天锁:假如不会发生并发冲突,只在提交操作时检查是不是违反数据完整性。

    五、MVCC

    ​全称是Multi-Version Concurrent Control,即多版本现身调节,在MVCC公约下,每种读操作会见到三个生机勃勃致性的snapshot,而且能够兑现非窒碍的读。MVCC允许数据具有多少个版本,那一个版本能够是光阴戳或许是大局依次增加的业务ID,在同三个时间点,不一致的事务看到的多少是见仁见智的。

    MySQL的innodb引擎是什么样贯彻MVCC的

    innodb会为每风姿洒脱行增添八个字段,分别表示该行创制的版本和删除的本子,填入的是事情的版本号,那么些版本号随着工作的始建不断依次增加。在repeated read的隔绝等级(事务的隔绝品级请看那篇小说)下,具体各样数据库操作的落实:

    • select:满意以下三个规范innodb会再次来到该行数据:
    • 该行的始建版本号小于等于当前版本号,用于保障在select操作在此之前全体的操作已经实施名落孙山。
    • 该行的去除版本号大于当前版本恐怕为空。删除版本号大于当前版本意味着有二个面世事务将该行删除了。
    • insert:将新插入的行的开创版本号设置为当下系统的版本号。
    • delete:将在删除的行的删减版本号设置为当前系统的版本号。
    • update:不施行原地update,而是转换来insert + delete。将旧行的去除版本号设置为方今版本号,并将新行insert同一时间设置制造版本号为近些日子版本号。

    其间,写操作(insert、delete和update卡塔 尔(英语:State of Qatar)试行时,必要将系统版本号依次增加。

    ​由于旧数据并不真正的去除,所以必须对那些多少开展清理,innodb会开启多个后台线程实践清理专门的学问,具体的准则是将去除版本号小于当前系统版本的行删除,那几个历程叫做purge。

    由此MVCC很好的贯彻了作业的隔开性,能够达到规定的标准repeated read品级,要落实serializable还非得加锁。

    参考:MVCC浅析

    六、MyISAM和InnoDB

    MyISAM 切合于部分亟待多量查询的行使,但其对于有恢宏写操作并非很好。以致你只是必要update叁个字段,整个表都会被锁起来,而其他进度,就算是读进度都力不可能及操作直到读操作完毕。此外,MyISAM 对于 SELECT COUNT(*) 那类的精兵简政是相当慢无比的。

    InnoDB 的矛头会是二个非常复杂的囤积引擎,对于部分小的运用,它会比 MyISAM 还慢。他是它扶助“行锁” ,于是在写操作很多的时候,会更非凡。并且,他还扶植更加多的高等应用,比方:事务。

     public static Operation CreateOperate(string operate)
            {
                Operation oper = null;
                switch (operate)
                {
                    case "+":
                        oper = new OperationAdd();
                        break;
                    case "-":
                        oper = new OperationSub();
                        break;
                    case "*":
                        oper = new OperationMul();
                        break;
                    case "/":
                        oper = new OperationDiv();
                        break;
    
                }
                return oper;
            }
    

    下边我们来为这几个事件赋值。

    安装uWSGI

    进入虚拟环境venv,安装uwsgi
    (venv) [root@slave 192.168.11.64 /opt]$pip3 install uwsgi
    检查uwsgi版本
    (venv) [root@slave 192.168.11.64 /opt]$uwsgi --version
    2.0.17.1
    #检查uwsgi python版本
    uwsgi --python-version
    

    运作轻便的uWSGI

    #启动一个python
    uwsgi --http :8000 --wsgi-file test.py
    
    • http :8000: 使用http协议,端口8000
    • wsgi-file test.py: 加载钦赐的文书,test.py
    #test.py
    def application(env, start_response):
        start_response('200 OK', [('Content-Type','text/html')])
        return [b"Hello World"] # python3
    

    uWsgi热加载python程序

    在启动命令后面加上参数
    uwsgi --http :8088 --module mysite.wsgi --py-autoreload=1 
    #发布命令
    command= /home/venv/bin/uwsgi --uwsgi 0.0.0.0:8000 --chdir /opt/mysite --home=/home/venv --module mysite.wsgi
    
    #此时修改django代码,uWSGI会自动加载django程序,页面生效
    

    运行django程序

    #mysite/wsgi.py  确保找到这个文件
    uwsgi --http :8000 --module mysite.wsgi
    
    • module mysite.wsgi: 加载内定的wsgi模块

    uwsgi配置文件

    图片 4图片 5

    uwsgi支持ini、xml等多种配置方式,本文以 ini 为例, 在/etc/目录下新建uwsgi_nginx.ini,添加如下配置:
    
    # mysite_uwsgi.ini file
    [uwsgi]
    
    # Django-related settings
    # the base directory (full path)
    chdir           = /opt/mysite
    # Django's wsgi file
    module          = mysite.wsgi
    # the virtualenv (full path)
    home            = /opt/venv
    # process-related settings
    # master
    master          = true
    # maximum number of worker processes
    processes       = 1
    # the socket (use the full path to be safe
    socket          = 0.0.0.0:8000
    # ... with appropriate permissions - may be needed
    # chmod-socket    = 664
    # clear environment on exit
    vacuum          = true
    

    uwsgi.ini

    以c语言为例:

    一、预处理

    预编写翻译进程首要管理那贰个源文件中的以“#”开始的预编写翻译指令,主要管理法则有:

    1. 将有着的“#define”删除,并展开所用的宏定义
    2. 拍卖全部标准预编写翻译指令,比方“#if”、“#ifdef”、 “#elif”、“#endif”
    3. 处理“#include”预编译指令,将被含有的文书插入到该编写翻译指令之处,注:此进度是递归进行的
    4. 去除全体注释
    5. 增添行号和文书名标记,以便于编写翻译时编写翻译器产生调试用的行号音讯以至用于编写翻译时产生编译错误或警告时可体现行号
    6. 封存全数的#pragma编写翻译器指令。

    二、编译

    编写翻译进度正是把预管理完的公文举办生机勃勃层层的词法解析、语法分析、语义解析及优化后变卦对应的汇编代码文件。这些进程是漫天程序营造的主导部分。

    三、汇编

    汇编器是将汇编代码转造成机器能够实施的授命,每一条汇编语句差相当的少都以一条机器指令。经过编写翻译、链接、汇编输出的文本成为目的文件(Object File)

    四、链接

    链接的基本点内容就是把各种模块之间相互引用的片段管理好,使种种模块能够正确的拼凑。 链接的重要进度包块 地址和空间的分配(Address and Storage Allocation卡塔尔、符号决议(Symbol Resolution)和重定位(Relocation)等步骤。

    五、静态链接和动态链接

    静态链接方法:静态链接的时候,载入代码就能够把程序会用到的动态代码或动态代码的地址鲜明下来 静态库的链接能够利用静态链接,动态链接库也能够接纳这种方法链接导入库

    动态链接方法:使用这种方法的顺序并不在一方始就完事动态链接,而是直到真正调用动态库代码时,载入程序才总结(被调用的那部分)动态代码的逻辑地址,然后等到某些时候,程序又需求调用此外某块动态代码时,载入程序又去总计那部分代码的逻辑地址,所以,这种艺术使程序初步化时间十分的短,但运转时期的性能比不上静态链接的次第

    六、设想内部存款和储蓄器手艺

    虚构存款和储蓄器是指具有乞请调入功能和调换来效,能从逻辑上对内部存款和储蓄器容积加以扩充的风流潇洒种存款和储蓄系统.

    七、分页和分支

    分页: 顾客程序的地址空间被分开成几何稳住大小的区域,称为“页”,相应地,内部存款和储蓄器空间分成若干个物理块,页和块的大小相当于。可将顾客程序的任黄金时代页放在内部存储器的任一块中,达成了离散分配。

    分层: 将客户程序地址空间分成若干个大小不等的段,每段能够定义风度翩翩组相对完好的逻辑信息。存储分配时,以段为单位,段与段在内部存款和储蓄器中能够不相邻接,也完结了离散分配。

    分页与分支的最主要差距

    1. 页是音信的大意单位,分页是为了落到实处非一而再三番五次分配,以便解决内部存款和储蓄器碎片难题,恐怕说分页是由于系统处理的内需.段是音讯的逻辑单位,它含有豆蔻年华组意义相对完整的音信,分段的指标是为了更加好地落实分享,知足客商的供给.
    2. 页的轻重固定,由系统鲜明,将逻辑地址划分为页号和页外市址是由机械硬件实现的.而段的尺寸却不稳固,决计于客户所编写的主次,经常由编写翻译程序在对源程序举办编写翻译时依据音信的品质来划分.
    3. 分页的课业地址空间是黄金年代维的.分段之处空间是二维的.

    八、页面置换算法

    1. 最棒置换算法OPT:不恐怕完成
    2. 先进先出FIFO
    3. 前段时间最久未使用算法LRU:近期黄金年代段时间里最久没有使用过的页面予以置换.
    4. clock算法

    九、边沿触发和程度触发

    边缘触发是指每当状态变化时发出一个 io 事件,条件触发是如若满意条件就发出四个 io 事件

    class OperationAdd : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA + NumberB;
                return result;
            }
        }
    
        class OperationSub : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA - NumberB;
                return result;
            }
        }
    
        class OperationMul : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA * NumberB;
                return result;
            }
        }
    
        class OperationDiv : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA / NumberB;
                return result;
            }
        }
    

    诸如WPF即使接济事件驱动,但MVVM在WPF下的表现称得上完美,所以WPF下的平地风波大概从未人用了。

    Django Nginx+uwsgi 安装配备

    在眼下的章节中大家采用 python manage.py runserver 来运作服务器。那只适用测量试验碰着中采用。

    行业内部揭露的劳务,需求三个足以稳固而不断的服务器。

    操作系统

    一、select,poll和epoll

    骨子里有着的I/O都以轮询的措施,只可是达成的范围分歧罢了.

    本条主题素材恐怕有一点点浓厚了,但相信能回答出那个难点是对I/O多路复用有很好的摸底了.当中tornado使用的就是epoll的.

    selec,poll和epoll差别总计

    基本上select有3个缺点:

    1. 连接数受限
    2. 检索配成对进度慢
    3. 数据由底蕴拷贝到顾客态

    poll改正了第壹个缺欠

    epoll改了多少个缺点.

    二、调节算法

    1. 先来先服务(FCFS, First Come First Serve)
    2. 短作业优先(SJF, Shortest Job First)
    3. 参天优先权调治(Priority Scheduling)
    4. 时刻片轮转(Odyssey汉兰达, Round 罗布in)
    • 类别反馈队列调整(multilevel feedback queue scheduling)

    实时调治算法:

    1. 最早甘休时间优先 EDF
    2. 低于松弛度优先 LLF

    三、死锁

    原因:

    1. 角逐能源
    2. 前后相继推动各种不当

    必要条件:

    1. 互斥条件
    2. 号召和维持规范
    3. 不剥夺条件
    4. 环路等待条件

    管理死锁基本方法:

    1. 防护死锁(甩掉除1以外的口径)
    2. 防止死锁(银行家算法)
    3. 检查评定死锁(能源分配图)
    4. 撤消死锁
    5. 剥夺财富
    6. 撤回进度

    死锁概念管理政策详细介绍的话,能够参见一下英特网的。

    四、程序编写翻译与链接

    Bulid进度能够解释为4个步骤:预管理(Prepressing), 编译(Compilation)、汇编(Assembly)、链接(Linking)

    表率为二个轻巧工厂方式的总结器,首先先创制三个计算器运算所要求接收的数据模型,在java之中也叫bean,正是四个空洞的类,这里大家先创立二个Operation类

    C#的框架都很优异,而种种杰出框架都为大家提供了一些优异事件。

    世家都学过了django,用django写了种种成效,写了bbs项目,写了路飞学城。

    Python语言特色

    风流洒脱、Python的函数参数字传送递

    看八个例子:

    a = 1

    def fun(a):

    a = 2

    fun(a)

    print a # 1

    a = []

    def fun(a):

    a.append(1)

    fun(a)

    print a # [1]

    怀有的变量都得以精通是内部存款和储蓄器中三个指标的“引用”,或然,也足以看似c中void*的感觉。

    经过id来看引用a的内存地址可以相比明白:

    a = 1

    def fun(a):

    print "func_in",id(a) # func_in 41322472

    a = 2

    print "re-point",id(a), id(2) # re-point 41322448 41322448

    print "func_out",id(a), id(1) # func_out 41322472 41322472

    fun(a)

    print a # 1

    注:具体的值在差异计算机上运转时只怕差异。

    能够见见,在施行完a = 2之后,a援引中保存的值,即内部存款和储蓄器地址发生变化,由原本1指标的所在的地址产生了2以此实体对象的内部存款和储蓄器地址。

    而第4个例子a引用保存的内部存款和储蓄器值就不会爆发变化:

    a = []

    def fun(a):

    print "func_in",id(a) # func_in 53629256

    a.append(1)

    print "func_out",id(a) # func_out 53629256

    fun(a)

    print a # [1]

    这里记住的是类别是归属对象的,实际不是变量。而目标有三种,“可更正”(mutable卡塔尔与“不可改换”(immutable卡塔尔对象。在python中,strings, tuples, 和numbers是不可改动的对象,而 list, dict, set 等则是足以修正的靶子。(那正是以此难题的要紧)

    当叁个援用传递给函数的时候,函数自动复制生机勃勃份援用,这些函数里的援用和异乡的援用未有半毛关系了.所以第二个例子里函数把援引指向了叁个不可变对象,当函数再次来到的时候,外面包车型客车引用没半毛认为.而第三个例子就不相符了,函数内的援用指向的是可变对象,对它的操作就和一定了指针地址一样,在内存里进行修改.

    二、Python中的元类(metaclass)

    以此可怜的一时用,然则像ORM这种复杂的结构依然会必要的,教程就不详细介绍了。

    三、 @staticmethod和@classmethod

    Python其实有3个方法,即静态方法(staticmethod),类方式(classmethod)和实例方法,如下:

    def foo(x):

    print "executing foo(%s)"%(x)

    class A(object):

    def foo(self,x):

    print "executing foo(%s,%s)"%(self,x)

    @classmethod

    def class_foo(cls,x):

    print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod

    def static_foo(x):

    print "executing static_foo(%s)"%x

    a=A()

    此间先知道下函数参数里面包车型大巴self和cls.那些self和cls是对类大概实例的绑定,对于平时的函数来说大家得以那样调用foo(x),这几个函数就是最常用的,它的做事跟其他东西(类,实例)无关.对于实例方法,我们领略在类里每回定义方法的时候都亟待绑定那些实例,正是foo(self, x),为啥要如此做呢?因为实例方法的调用离不开实例,大家需求把实例本人传给函数,调用的时候是那般的a.foo(x)(其实是foo(a, x)).类方法相像,只然而它传递的是类并不是实例,A.class_foo(x).注意这里的self和cls能够替换其他参数,不过python的预定是这俩,还是不要改的好.

    对此静态方法其实和普通的方式相通,无需对何人实行绑定,唯生机勃勃的分别是调用的时候要求动用a.static_foo(x)或者A.static_foo(x)来调用.

    实例方法类情势静态方法a = A()a.foo(x)a.class_foo(x)a.static_foo(x)A不可用A.class_foo(x)A.static_foo(x)

    四、类变量和实例变量

    类变量:

    ​是可在类的持有实例之间共享的值(约等于说,它们不是独自分配给每个实例的卡塔尔国。比方下例中,num_of_instance 便是类变量,用于追踪存在着稍加个Test 的实例。

    实例变量:

    实例化之后,各类实例单独具备的变量。

    class Test(object):

    num_of_instance = 0

    def __init__(self, name):

    self.name = name

    Test.num_of_instance += 1

    if __name__ == '__main__':

    print Test.num_of_instance # 0

    t1 = Test('jack')

    print Test.num_of_instance # 1

    t2 = Test('lucy')

    print t1.name , t1.num_of_instance # jack 2

    print t2.name , t2.num_of_instance # lucy 2

    抵补的事例

    class Person:

    name="aaa"

    p1=Person()

    p2=Person()

    p1.name="bbb"

    print p1.name # bbb

    print p2.name # aaa

    print Person.name # aaa

    这里p1.name="bbb"是实例调用了类变量,那实际和方面第叁个难题同样,正是函数字传送参的标题,p1.name生机勃勃最初是指向的类变量name="aaa",然则在实例的效能域里把类变量的引用改变了,就改为了三个实例变量,self.name不再引用Person的类变量name了.

    能够看看下边包车型客车事例:

    class Person:

    name=[]

    p1=Person()

    p2=Person()

    p1.name.append(1)

    print p1.name # [1]

    print p2.name # [1]

    print Person.name # [1]

    五、Python自省

    以此也是python彪悍的性子.

    抚心自问正是面向对象的语言研商所写的次第在运转时,所能知道对象的类型.轻便一句正是运维时能够拿到对象的类型.例如type(),dir(),getattr(),hasattr(),isinstance().

    a = [1,2,3]

    b = {'a':1,'b':2,'c':3}

    c = True

    print type(a),type(b),type(c) # <type 'list'> <type 'dict'> <type 'bool'>

    print isinstance(a,list) # True

    六、字典推导式

    可能你见过列表推导时,却不曾见过字典推导式,在2.7中才参加的:

    d = {key: value for (key, value) in iterable}

    7 Python中单下划线和双下划线

    >>> class MyClass():

    ... def __init__(self):

    ... self.__superprivate = "Hello"

    ... self._semiprivate = ", world!"

    ...

    >>> mc = MyClass()

    >>> print mc.__superprivate

    Traceback (most recent call last):

    File "<stdin>", line 1, in <module>

    AttributeError: myClass instance has no attribute '__superprivate'

    >>> print mc._semiprivate

    , world!

    >>> print mc.__dict__

    {'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

    __foo__:大器晚成种约定,Python内部的名字,用来区分其余客商自定义的命名,防止冲突,便是例如说__init__(),__del__(),__call__()那些特殊措施

    _foo:大器晚成种约定,用来钦赐变量私有.技士用来钦命个人变量的风姿罗曼蒂克种情势.不能用from module import * 导入,其他方面和国有相近访谈;

    __foo:这些有实在的意义:解析器用_classname__foo来顶替这一个名字,以界别和任何类相仿的命名,它不能间接像公有成员平等随意访问,通过对象名._类名__xxx那样的情势得以访问.

    七、字符串格式化:%和.format

    .format在许多下面看起来更便利.对于%最烦人的是它无法同不经常候传递八个变量和元组.你也许会想下边包车型大巴代码不会有哪些难点:

    "hi there %s" % name

    不过,假使name适逢其时是(1,2,3),它将会抛出三个TypeError至极.为了保障它连接不错的,你必须那样做:

    "hi there %s" % (name,) # 提供三个单成分的数组实际不是多个参数

    但是多少丑..format就平昔不这个难题.你给的第叁个问题也是这么,.format赏心悦目多了.

    您干吗不用它?

    • 不亮堂它(在读这几个以前)
    • 为了和Python2.5合作(举个例子logging库建议使用%(issue #4))

    八、迭代器和生成器

    stackoverflow里python排行第后生可畏的主题素材,能够参见一下,有斯洛伐克(Slovak卡塔尔国语版也许有汉语版的。

    此地有个有关生成器的开创难点面试官有考: 问: 将列表生成式中[]更动() 之后数据结构是还是不是改动? 答案:是,从列表变为生成器

    >>> L = [x*x for x in range(10)]

    >>> L

    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    >>> g = (x*x for x in range(10))

    >>> g

    <generator object <genexpr> at 0x0000028F8B774200>

    因此列表生成式,能够直接创制一个列表。不过,受到内部存款和储蓄器约束,列表体积料定是零星的。而且,创立叁个暗含百万成分的列表,不仅是挤占十分大的内部存款和储蓄器空间,如:我们只须要拜会前面包车型客车多少个要素,前面大部分要素所占的空间都以浪费的。因而,不要求创造完整的列表(节省大批量内存空间卡塔 尔(阿拉伯语:قطر‎。在Python中,我们能够应用生成器:边循环,边计算的建制—>generator

    九、*args and **kwargs

    用*args和**kwargs只是为着便于并从未强制行使它们.

    当您不明确你的函数里将在传递多少参数时您能够用*args.比如,它能够传递放肆数量的参数:

    >>> def print_everything(*args):

    for count, thing in enumerate(args):

    ... print '{0}. {1}'.format(count, thing)

    ...

    >>> print_everything('apple', 'banana', 'cabbage')

    1. apple

    2. banana

    3. cabbage

    相似的,**kwargs允许你使用未有事先定义的参数名:

    >>> def table_things(**kwargs):

    ... for name, value in kwargs.items():

    ... print '{0} = {1}'.format(name, value)

    ...

    >>> table_things(apple = 'fruit', cabbage = 'vegetable')

    cabbage = vegetable

    apple = fruit

    您也得以混着用.命名参数首先拿到参数值然后具有的别的参数都传送给*args和**kwargs.命名参数在列表的最前端.举例:

    def table_things(titlestring, **kwargs)

    *args和**kwargs能够况且在函数的定义中,然则*args必须在**kwargs前面.

    当调用函数时您也足以用*和**语法.例如:

    >>> def print_three_things(a, b, c):

    ... print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)

    ...

    >>> mylist = ['aardvark', 'baboon', 'cat']

    >>> print_three_things(*mylist)

    a = aardvark, b = baboon, c = cat

    就如你看看的一样,它能够传递列表(可能元组)的每意气风发项并把它们解包.注意必需与它们在函数里的参数相适合.当然,你也能够在函数定义只怕函数调用时用*.

    十、面向切面编制程序AOP和装饰器

    那个AOP生龙活虎听上去有个别懵,同学面Ali的时候就被问懵了...

    装饰器是一个很知名的设计形式,日常被用来有切面须要的气象,较为杰出的有插入日志、品质测量试验、事务管理等。装饰器是不留余地那类难题的绝佳设计,有了装饰器,大家就足以分离出大气函数中与函数作用本人非亲非故的相仿代码并继续起用。总结的讲,装饰器的功能就是为早就存在的靶子增加额外的作用。

    十生机勃勃、海番鸭类型

    “当看见叁只鸟走起来像绿头鸭、游泳起来像海番鸭、叫起来也像海番鸭,那么那只鸟就可以被叫做绒鸭。”

    咱俩并不关心对象是何许项目,到底是否海番鸭,只关注行为。

    举例在python中,有众多file-like的东西,比如StringIO,GzipFile,socket。它们有那多少个风流罗曼蒂克致的不二诀窍,我们把它们作为文件使用。

    又比方list.extend()方法中,大家并不关心它的参数是否list,只要它是可迭代的,所以它的参数能够是list/tuple/dict/字符串/生成器等.

    潜水鸭类型在动态语言中时时利用,非常灵活,使得python不想java那样特地去弄一大堆的设计格局。

    十二、Python中重载

    函数重载首要是为了解决八个难点。

    1. 可变参数类型。
    2. 可变参数个数。

    除此以外,叁个核心的宏Logo准是,仅仅当三个函数除了参数类型和参数个数不一致以外,其成效是完全雷同的,那时候才使用函数重载,要是三个函数的职能实在不及,那么不应有利用重载,而相应利用二个名字不相同的函数。

    行吗,那么对于情形 1 ,函数效能相近,然则参数类型差别,python 如哪个地方理?答案是常有不要求管理,因为 python 能够采取别的类型的参数,假使函数的功效相近,那么不一样的参数类型在 python 中很恐怕是同等的代码,没有必要做成多个不等函数。

    那正是说对于景况 2 ,函数效用相似,但参数个数不相同,python 如哪个地点理?大家领悟,答案就是缺省参数。对那多少个缺少的参数设定为缺省参数就能够缓和难题。因为你假若函数作用适合,那么那多个相当不够的参数终究是须要用的。

    好了,鉴于意况 1 跟 情形 2 都有理解决方案,python 自然就无需函数重载了。

    十九、新式类和旧式类

    本条面试官问了,作者说了老半天,不亮堂她问的的确意图是什么.

    stackoverflow

    风行类很早在2.2就应际而生了,所以旧式类完全部都是相配的主题材料,Python3里的类全是新式类.这里有三个MRO问题能够了然下(新式类是广度优先,旧式类是深度优先),<Python核心编制程序>里讲的也比比较多.

    叁个旧式类的深浅优先的例证

    class A():

    def foo1(self):

    print "A"

    class B(A):

    def foo2(self):

    pass

    class C(A):

    def foo1(self):

    print "C"

    class D(B, C):

    pass

    d = D()

    d.foo1()

    # A

    依据精粹类的搜索顺序从左到右深度优先的平整,在拜访d.foo1()的时候,D那个类是未曾的..那么往上查究,先找到B,里面未有,深度优先,访谈A,找到了foo1(),所以这时调用的是A的foo1(),进而招致C重写的foo1()被绕过

    十四、__new__和__init__的区别

    这个__new__确实超级少见到,先做摸底吧.

    1. __new__是三个静态方法,而__init__是三个实例方法.
    2. __new__方法会再次回到一个创办的实例,而__init__怎么样都不重回.
    3. 只有在__new__归来多少个cls的实例时前面包车型地铁__init__手艺被调用.
    4. 当成立一个新实例时调用__new__,初始化三个实例时用__init__.

    stackoverflow

    ps: __metaclass__是创立类时起成效.所以大家能够独家选拔__metaclass__,__new__和__init__来分别在类成立,实例创设和实例初叶化的时候做一些小手脚.

    十一、单例形式

    ​单例形式是风度翩翩种常用的软件设计格局。在它的着力结构中只含有二个被喻为单例类的新鲜类。通过单例格局能够保障系统中一个类独有三个实例何况该实例易于外部访谈,从而方便对实例个数的主宰并节约系统能源。尽管期望在系统中某些类的指标只好存在二个,单例方式是最棒的缓和方案。

    __new__()在__init__()以前被调用,用于转移实例对象。利用这些方法和类的性子的性状能够兑现设计形式的单例情势。单例情势是指创设独一目的,单例方式设计的类只好实例 那几个相对常考啊.必需求切记1~2个法子,这个时候面试官是让手写的.

    1 使用__new__方法

    class Singleton(object):

    def __new__(cls, *args, **kw):

    if not hasattr(cls, '_instance'):

    orig = super(Singleton, cls)

    cls._instance = orig.__new__(cls, *args, **kw)

    return cls._instance

    class MyClass(Singleton):

    a = 1

    2 分享属性

    创办实例时把具有实例的__dict__本着同三个字典,那样它们具备同样的质量和方法.

    class Borg(object):

    _state = {}

    def __new__(cls, *args, **kw):

    ob = super(Borg, cls).__new__(cls, *args, **kw)

    ob.__dict__ = cls._state

    return ob

    class MyClass2(Borg):

    a = 1

    3 装饰器版本

    def singleton(cls):

    instances = {}

    def getinstance(*args, **kw):

    if cls not in instances:

    instances[cls] = cls(*args, **kw)

    return instances[cls]

    return getinstance

    @singleton

    class MyClass:

    ...

    4 import方法

    作为python的模块是自然的单例格局

    # mysingleton.py

    class My_Singleton(object):

    def foo(self):

    pass

    my_singleton = My_Singleton()

    # to use

    from mysingleton import my_singleton

    my_singleton.foo()

    十三、 Python中的功用域

    Python 中,贰个变量的成效域总是由在代码中被赋值的地点所调节的。

    当 Python 遭受一个变量的话他会依照那样的顺序进行查找:

    地面成效域(Local卡塔尔→当前作用域被平放的本土功能域(Enclosing locals卡塔 尔(阿拉伯语:قطر‎→全局/模块功能域(Global卡塔尔→内置功能域(Built-in卡塔 尔(阿拉伯语:قطر‎

    十三、 GIL线程全局锁

    线程全局锁(Global Interpreter Lock),即Python为了确认保障线程安全而利用的独立线程运维的范围,说白了正是七个核只好在同时运维三个线程.对于io密集型职责,python的八十二线程起到效果,但对于cpu密集型职务,python的四线程差不离占不到任何优势,还应该有望因为争夺能源而变慢。

    见Python 最难的难题

    解除办法正是多进度和底下的协程(协程也只是单CPU,但是能减小切换代价进步质量).

    十八、协程

    微博被问到了,呵呵哒,跪了

    简短点说协程是进程和线程的进步版,进度和线程都面前遭逢着内核态和客户态的切换难点而消耗数不尽切换时间,而协程正是客户本人主宰切换的机会,不再须求陷入系统的基业态.

    Python里最布满的yield正是协程的考虑!能够查看第八个难点.

    十九、闭包

    闭包(closure)是函数式编制程序的基本点的语法结构。闭包也是大器晚成种集体代码的构造,它同样进步了代码的可另行使用性。

    当二个内嵌函数援用其外界作效用域的变量,我们就能拿走二个闭包. 总结一下,创立四个闭包必得满足以下几点:

    1. 不得不有二个内嵌函数
    2. 内嵌函数必须援引外界函数中的变量
    3. 表面函数的重返值必需是内嵌函数

    以为闭包依然有难度的,几句话是说不亮堂的,依然印证相关资料.

    第一是函数运维后并不会被废除,就如16题的instance字典一样,当函数运转完后,instance并不被销毁,而是继续留在内部存款和储蓄器空间里.那一个职能周围类里的类变量,只然而迁移到了函数上.

    闭包好似个空心球相通,你知道外面和中间,但您不知情中间是什么样.

    二十、lambda函数

    实际正是叁个无名氏函数,为啥叫lambda?因为和前边的函数式编制程序有关.

    推荐: 知乎

    三十大器晚成、 Python函数式编程

    以此须要拾叁分的刺探一下吗,究竟函数式编制程序在Python中也做了援用.

    推荐: 酷壳

    python中等高校函授数式编制程序帮助:

    filter 函数的功能也等于过滤器。调用三个布尔函数bool_func来迭代遍历每种seq中的成分;再次来到三个使bool_seq重回值为true的要素的类别。

    >>>a = [1,2,3,4,5,6,7]

    >>>b = filter(lambda x: x > 5, a)

    >>>print b

    >>>[6,7]

    map函数是对三个队列的各样项依次实践函数,下边是对多个行列种种项都乘以2:

    >>> a = map(lambda x:x*2,[1,2,3])

    >>> list(a)

    [2, 4, 6]

    reduce函数是对贰个行列的种种项迭代调用函数,上边是求3的阶乘:

    >>> reduce(lambda x,y:x*y,range(1,4))

    6

    三十五、Python里的正片

    引用和copy(),deepcopy()的区别

    import copy

    a = [1, 2, 3, 4, ['a', 'b']] #固有对象

    b = a #赋值,传对象的援用

    c = copy.copy(a) #目的拷贝,浅拷贝

    d = copy.deepcopy(a) #对象拷贝,深拷贝

    a.append(5) #改革对象a

    a[4].append('c') #校勘对象a中的['a', 'b']数组对象

    print 'a = ', a

    print 'b = ', b

    print 'c = ', c

    print 'd = ', d

    出口结果:

    a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]

    b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]

    c = [1, 2, 3, 4, ['a', 'b', 'c']]

    d = [1, 2, 3, 4, ['a', 'b']]

    三十六、Python垃圾回笼机制

    Python GC主要利用援用计数(reference counting卡塔 尔(阿拉伯语:قطر‎来追踪和回笼垃圾。在援引计数的底蕴上,通过“标识-消释”(mark and sweep卡塔 尔(英语:State of Qatar)解决容器对象只怕产生的大循环援用难点,通过“分代回笼”(generation collection卡塔尔国以空间换时间的方法提升垃圾回净利润。

    1 引用计数

    PyObject是各样对象必有的内容,个中ob_refcnt正是做为援引计数。当三个指标有新的援引时,它的ob_refcnt就能够加多,当援引它的指标被去除,它的ob_refcnt就能够收缩.引用计数为0时,该对象生命就归西了。

    优点:

    1. 简单
    2. 实时性

    缺点:

    1. 保卫安全援用计数消耗财富
    2. 循环援用

    2 标志-裁撤机制

    基本思路是先按需分配,等到未有空余内部存款和储蓄器的时候从贮存器和次序栈上的援用出发,遍历以指标为节点、以援引为边构成的图,把富有能够访谈到的靶子打上标志,然后清扫一次内部存款和储蓄器空间,把持有没标识的指标释放。

    3 分代技能

    分代回笼的欧洲经济共同体思想是:将系统中的全数内部存款和储蓄器块依照其现成时间分开为不相同的聚众,每个集结就成为三个“代”,垃圾收罗频率随着“代”的现存时间的附加而减小,存活时间平日采用经过四次垃圾回收来度量。

    Python默肯定义了三代对象集合,索引数越大,对象共处时间越长。

    比方来讲: 当有个别内部存款和储蓄器块M经过了3次垃圾搜聚的涤荡之后还存世时,大家就将内部存款和储蓄器块M划到一个集合A中去,而新分配的内部存款和储蓄器都划分到集结B中去。当废品采摘起来职业时,大超级多状态都只对集结B实行垃圾回笼,而对会集A进行垃圾回笼要隔相当的短黄金年代段时间后才开展,那就使得垃圾搜罗体制亟待管理的内部存款和储蓄器少了,功能自然就增进了。在此个历程中,集合B中的有些内部存款和储蓄器块由于现成时间长而会被撤换成集结A中,当然,集合A中实际上也存在部分朽木粪土,这么些杂质的回笼会因为这种分代的编写制定而被推移。

    二十四、Python的List

    详细教程英特网海人民广播电视台湾大学的,内容有一点点多,作者就不豆蔻梢头一列出来了。

    二十五、Python的is

    is是相比较地址,==是相比较值

    二十六、 read,readline和readlines

    • read 读取整个文件
    • readline 读取下生龙活虎行,使用生成器方法
    • readlines 读取整个文件到八个迭代器以供大家遍历

    二十七、 Python2和3的区别

    推荐介绍:Python 2.7.x 与 Python 3.x 的基本点分裂

    二十八、super init

    super() lets you avoid referring to the base class explicitly, which can be nice. But the main advantage comes with multiple inheritance, where all sorts of fun stuff can happen. See the standard docs on super if you haven't already.

    Note that the syntax changed in Python 3.0: you can just say super().__init__() instead of super(ChildB, self).__init__() which IMO is quite a bit nicer.

    Python2.7中的super方法浅见

    二十九、range and xrange

    都在循环时接纳,xrange内存性能更加好。 for i in range(0, 20): for i in xrange(0, 20): What is the difference between range and xrange functions in Python 2.X? range creates a list, so if you do range(1, 10000000) it creates a list in memory with 9999999 elements. xrange is a sequence object that evaluates lazily.

    渐渐的做记录,做最有力的和谐

    案由很简短,学习的长河中尽量裁减概念混淆。并且,在C#开荒中,好的架构者也数见不鲜会将事件和嘱托分离,所以,就认为事件和寄托未有涉及就能够。

    提早安装好python3遇到

    https://www.cnblogs.com/pyyu/p/7402145.html
    

     

    public class Operation
        {
            private double _numberA = 0;
            private double _numberB = 0;
    
            public double NumberA
            {
                get { return _numberA; }
                set { _numberA = value; }
            }
    
            public double NumberB
            {
                get { return _numberB; }
                set { _numberB = value; }
            }
    
            public virtual double GetResult()
            {
                double results = 0;
                return results;
            }
    
    
    
        }
    

    运维起来,大家点击开关,通过断点我们能够看来,大家点击的按键触发了btnClild_Click和btnParent_Click事件

    基础开拓意况安插

    yum groupinstall "Development tools"
    yum install zlib-devel bzip2-devel pcre-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel
    

    数据结构

    红黑树

    红黑树与AVL的相比:

    AVL是从严平衡树,因而在大增还是去除节点的时候,依照不一致景况,旋转的次数比红黑树要多;

    红黑是用非严加的平衡来换取增加和删除节点时候转动次数的下挫;

    由此轻松说,如若你的利用中,寻觅的次数远远不独有插入和删除,那么选拔AVL,倘诺搜索,插入删除次数大致大致,应该选用RB。

    三层模型基本上只要不是用了极度的秘籍那么基本都是依附简单工厂情势来管理办法的

    由此那多少个单词,大家会清楚的垂询路由事件。简单描述一下sender和source,它们八个是发送者,一个是源。

    配置nginx结合uWSGI

    配置nginx.conf

    worker_processes  1;
    error_log  logs/error.log;
    pid        logs/nginx.pid;
    events {
        worker_connections  1024;
    }
    http {
        include       mime.types;
        default_type  application/octet-stream;
        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                          '$status $body_bytes_sent "$http_referer" '
                          '"$http_user_agent" "$http_x_forwarded_for"';
        access_log  logs/access.log  main;
        sendfile        on;
        keepalive_timeout  65;
       #nginx反向代理uwsgi
        server {
            listen       80;
            server_name  192.168.11.64;
            location / {
             include  /opt/nginx1-12/conf/uwsgi_params;
             uwsgi_pass 0.0.0.0:8000;
                root   html;
                index  index.html index.htm;
            }
          #nginx处理静态页面资源
          location /static{
            alias /opt/nginx1-12/static;   
             }
         #nginx处理媒体资源
         location /media{
            alias /opt/nginx1-12/media;   
    
             }
            error_page   500 502 503 504  /50x.html;
    
            location = /50x.html {
                root   html;
            }
        }
    }
    

    布局完运营nginx

     

    是因为事件必得[标志响应措施的寄托],所以这一个事件所接纳的嘱托皆有多个联合的性状,命名中包蕴Event。

    前面邓超(英文名:dèng chāo卡塔尔国也对nginx轻易的牵线了,本文将nginx、WSGI、uwsgi、uWSGI、django那多少个关系梳理一下。

    始建筑工程厂类,实例化出契合的目的

    但委托中也会有多播,那为啥要单独弄出来一个平地风波呢?

      django的静态文件与nginx配置

    mysite/settings.py

    STATIC_ROOT='/opt/nginx1-12/static'
    STATIC_URL = '/static/'
    STATICFILES_DIRS=[
        os.path.join(BASE_DIR,"static"),
    ]
    

    上述的参数STATIC_ROOT用在哪?

    通过python3 manage.py collectstatic 采摘全体你使用的静态文件保留到STATIC_ROOT!

    STATIC_ROOT 文件夹 是用来将所有STATICFILES_DIRS中所有文件夹中的文件,以及各app中static中的文件都复制过来
    # 把这些文件放到一起是为了用nginx等部署的时候更方便
    

     

     

    参照文书档案:

     uwsgi热加载:

    经过多态,重临父类的点子,然后达成总计结果

    我对C#的认知。

    指虞诩排文件运行命令

    uwsgi --ini  /etc/uwsgi_nginx.ini
    

     

    他满含了五个参数,即当我们为事件增添EventHandler委托后,再去触发该事件;被触发的嘱托将赢得object sender和伊芙ntArgs e多少个参数。

    本文由澳门皇家赌场真人在线发布于皇家赌场游戏,转载请注明出处:设计方式,调用腾讯云API的实例

    关键词:

上一篇:python之常用模块,操作下拉菜单

下一篇:没有了