python常见面试问题整理

　　1、python装饰器
　　定义：在不改变原函数的代码和调用方式的情况下，实现对函数的功能的增强。
　　（1）一般装饰器写法deftimer（func）：defdecorator（args，kwargs）：starttime。time（）func（args，kwargs）endtime。time（）print（f执行用时：｛endstart｝s）returndecoratortimerdefwantsleep（sleeptime）：time。sleep（sleeptime）wantsleep（10）输出如下执行用时：10。0073800086975098s
　　（2）带参数的装饰器defsayhello（contry）：defwrapper（func）：defdeco（args，kwargs）：ifcontrychina：print（你好！）elifcontryamerica：print（hello。）else：return真正执行函数的地方func（args，kwargs）returndecoreturnwrapper小明，中国人sayhello（china）defxiaoming（）：passjack，美国人sayhello（america）defjack（）：pass
　　（3）不带参数的类装饰器
　　基于类装饰器的实现，必须实现call和init两个内置函数。init：接收被装饰函数call：实现装饰逻辑。classlogger（object）：definit（self，func）：self。funcfuncdefcall（self，args，kwargs）：print（〔INFO〕：thefunction｛func｝（）isrunning。。。。format（funcself。func。name））returnself。func（args，kwargs）loggerdefsay（something）：print（say｛｝！。format（something））say（hello）执行一下，看看输出〔INFO〕：thefunctionsay（）isrunning。。。sayhello！
　　（4）带参数的类装饰器
　　上面不带参数的例子，你发现没有，只能打印INFO级别的日志，正常情况下，我们还需要打印DEBUGWARNING等级别的日志。这就需要给类装饰器传入参数，给这个函数指定级别了。
　　带参数和不带参数的类装饰器有很大的不同。
　　init：不再接收被装饰函数，而是接收传入参数。call：接收被装饰函数，实现装饰逻辑。classlogger（object）：definit（self，levelINFO）：self。levelleveldefcall（self，func）：接受函数defwrapper（args，kwargs）：print（〔｛level｝〕：thefunction｛func｝（）isrunning。。。。format（levelself。level，funcfunc。name））func（args，kwargs）returnwrapper返回函数logger（levelWARNING）defsay（something）：print（say｛｝！。format（something））say（hello）执行结果如下：〔WARNING〕：thefunctionsay（）isrunning。。。sayhello！
　　（5）。使用偏函数与类实现装饰器
　　绝大多数装饰器都是基于函数和闭包实现的，但这并非制造装饰器的唯一方式。
　　事实上，Python对某个对象是否能通过装饰器（decorator）形式使用只有一个要求：decorator必须是一个可被调用（callable）的对象。
　　对于这个callable对象，我们最熟悉的就是函数了。
　　除函数之外，类也可以是callable对象，只要实现了call函数（上面几个例子已经接触过了）。
　　还有容易被人忽略的偏函数其实也是callable对象。
　　接下来就来说说，如何使用类和偏函数结合实现一个与众不同的装饰器。
　　如下所示，DelayFunc是一个实现了call的类，delay返回一个偏函数，在这里delay就可以做为一个装饰器。（以下代码摘自Python工匠：使用装饰器的小技巧）importtimeimportfunctoolsclassDelayFunc：definit（self，duration，func）：self。durationdurationself。funcfuncdefcall（self，args，kwargs）：print（fWaitfor｛self。duration｝seconds。。。）time。sleep（self。duration）returnself。func（args，kwargs）defeagercall（self，args，kwargs）：print（Callwithoutdelay）returnself。func（args，kwargs）defdelay（duration）：装饰器：推迟某个函数的执行。同时提供。eagercall方法立即执行此处为了避免定义额外函数，直接使用functools。partial帮助构造DelayFunc实例returnfunctools。partial（DelayFunc，duration）
　　我们的业务函数很简单，就是相加delay（duration2）defadd（a，b）：returnab
　　来看一下执行过程add可见add变成了Delay的实例main。DelayFuncobjectat0x107bd0be0add（3，5）直接调用实例，进入callWaitfor2seconds。。。8add。func实现实例方法functionaddat0x107bef1e0
　　（6）如何写能装饰类的装饰器？
　　用Python写单例模式的时候，常用的有三种写法。其中一种，是用装饰器来实现的。
　　以下便是我自己写的装饰器版的单例写法。instances｛｝defsingleton（cls）：defgetinstance（args，kw）：clsnamecls。nameprint（1）ifnotclsnameininstances：print（2）instancecls（args，kw）instances〔clsname〕instancereturninstances〔clsname〕returngetinstancesingletonclassUser：instanceNonedefinit（self，name）：print（3）self。namename
　　可以看到我们用singleton这个装饰函数来装饰User这个类。装饰器用在类上，并不是很常见，但只要熟悉装饰器的实现过程，就不难以实现对类的装饰。在上面这个例子中，装饰器就只是实现对类实例的生成的控制而已。
　　其实例化的过程，你可以参考我这里的调试过程，加以理解。
　　（7）wraps装饰器有啥用？
　　在functools标准库中有提供一个wraps装饰器，你应该也经常见过，那他有啥用呢？
　　先来看一个例子defwrapper（func）：definnerfunction（）：passreturninnerfunctionwrapperdefwrapped（）：passprint（wrapped。name）innerfunction
　　为什么会这样子？不是应该返回func吗？
　　这也不难理解，因为上边执行func和下边decorator（func）是等价的，所以上面func。name是等价于下面decorator（func）。name的，那当然名字是innerfunctiondefwrapper（func）：definnerfunction（）：passreturninnerfunctiondefwrapped（）：passprint（wrapper（wrapped）。name）innerfunction
　　那如何避免这种情况的产生？方法是使用functools。wraps装饰器，它的作用就是将被修饰的函数（wrapped）的一些属性值赋值给修饰器函数（wrapper），最终让属性的显示更符合我们的直觉。fromfunctoolsimportwrapsdefwrapper（func）：wraps（func）definnerfunction（）：passreturninnerfunctionwrapperdefwrapped（）：passprint（wrapped。name）wrapped
　　准确点说，wraps其实是一个偏函数对象（partial），源码如下defwraps（wrapped，assignedWRAPPERASSIGNMENTS，updatedWRAPPERUPDATES）：returnpartial（updatewrapper，wrappedwrapped，assignedassigned，updatedupdated）
　　可以看到wraps其实就是调用了一个函数updatewrapper，知道原理后，我们改写上面的代码，在不使用wraps的情况下，也可以让wrapped。name打印出wrapped，代码如下：fromfunctoolsimportupdatewrapperWRAPPERASSIGNMENTS（module，name，qualname，doc，annotations）defwrapper（func）：definnerfunction（）：passupdatewrapper（innerfunction，func，assignedWRAPPERASSIGNMENTS）returninnerfunctionwrapperdefwrapped（）：passprint（wrapped。name）2、列表和元组的区别列表属于可变序列，它的元素可以随时修改或删除，元组是不可变序列，其中元素不可修改，只能整体替换。列表可以使用append（）、extend（）、insert（）、remove（）和pop（）等方法实现添加和修改，元组则没有这几个方法。列表可以使用切片访问和修改列表中的元素，元组也支持切片，但是它只能通过切片访问。元组比列表的访问和处理速度快，如果只需要访问不需要修改，建议使用元组。列表不能作为字典的键，而元组则可以。3、多进程与多线程
　　3。1线程与进程的区别
　　操作系统创建进程，要给进程分配资源，进程是操作系统分配资源的基本单位。
　　操作系统创建的线程，要是在CPU上调度执行，线程是操作调度执行的基本单位。
　　进程包含线程，一个进程离可以有一个线程，也可以有多个线程。
　　3。2python多线程
　　（1）普通方式创建线程fromrandomimportrandintfromthreadingimportThreadfromtimeimporttime，sleepdefdownload（filename）：print（开始下载｛｝。。。。format（filename））timetodownloadrandint（5，10）sleep（timetodownload）print（s下载完成！耗时。2f秒。（filename，timetodownload））defmain（）：starttime（）t1Thread（targetdownload，args（Python从入门到放弃，））t1。start（）t2Thread（targetdownload，args（三国义演。txt，））t2。start（）t1。join（）t2。join（）endtime（）print（总共耗费了。3f秒（endstart））ifnamemain：main（）output开始下载Python从入门到放弃。。。开始下载三国义演。txt。。。三国义演。txt下载完成！耗时10。00秒。Python从入门到放弃下载完成！耗时10。00秒。总共耗费了10。008秒
　　（2）继承方式创建线程fromrandomimportrandintfromthreadingimportThreadfromtimeimporttime，sleepclassDownloadTask（Thread）：definit（self，filename）：super（DownloadTask，self）。init（）self。filenamefilenamedefrun（self）：print（开始下载s。。。self。filename）timetodownloadrandint（5，10）sleep（timetodownload）print（s下载完成！耗费了d秒（self。filename，timetodownload））defmain（）：starttime（）t1DownloadTask（Python从入门到住院。pdf）t1。start（）t2DownloadTask（PekingHot。avi）t2。start（）t1。join（）t2。join（）endtime（）print（总共耗费了。2f秒。（endstart））ifnamemain：main（）output开始下载Python从入门到住院。pdf。。。开始下载PekingHot。avi。。。Python从入门到住院。pdf下载完成！耗费了6秒PekingHot。avi下载完成！耗费了9秒总共耗费了9。01秒。
　　3。2python多进程frommultiprocessingimportProcessfromosimportgetpidfromrandomimportrandintfromtimeimporttime，sleepdefdownloadtask（filename）：print（启动下载进程〔d〕，开始下载s。。。（getpid（），filename））timetodownloadrandint（5，10）sleep（timetodownload）print（s下载完成！耗费了d秒（filename，timetodownload））defmain（）：print（Parentprocesss。（getpid（）））starttime（）p1Process（targetdownloadtask，args（Python从入门到住院。pdf，））p2Process（targetdownloadtask，args（PekingHot。avi，））p1。start（）p2。start（）p1。join（）p2。join（）endtime（）print（总共耗费了。2f秒。（endstart））ifnamemain：main（）output启动下载进程〔14156〕，开始下载PekingHot。avi。。。启动下载进程〔1232〕，开始下载Python从入门到住院。pdf。。。PekingHot。avi下载完成！耗费了5秒Python从入门到住院。pdf下载完成！耗费了10秒总共耗费了10。26秒。4、re模块正则表达式
　　一、什么是正则表达式
　　正则表达式（Regularexpression）是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。
　　比如我们在网站中看到对用户名规则做出了如下限制：只能包含小写字母、数字、下划线和连字符，并且限制用户名长度在315个字符之间，如何验证一个用户名是否符合规则呢？我们使用以下正则表达式：
　　以上的正则表达式可以接受johndoe、johndoe、john12as，但不能匹配A1，因为它包含了大写字母而且长度不到3个字符
　　1。1re。compile
　　compile：re。compile是将正则表达式转换为模式对象，这样可以更有效率匹配。使用compile转换一次之后，以后每次使用模式时就不用进行转换pattern：写正则表达式flags：匹配模式
　　从compile（）函数的定义中，可以看出返回的是一个匹配对象，它单独使用就没有任何意义，需要和findall（），search（），match（）搭配使用。compile（）与findall（）一起使用，返回一个列表。compile配合findallimportrea035567796666bre。compile（rdd｛8｝）rre。findall（b，a）print（r）importrea035567796666bre。compile（rdd｛8｝）rb。findall（a）print（r）直接使用findallimportrea035567796666rre。findall（rdd｛8｝，a）print（r）compile配合searchimportrea035567796666正则re。compile（rdd｛8｝）rre。search（正则，a）print（r。group（））compile配合matchimportrea035567796666正则re。compile（rdd｛8｝）rre。match（正则，a）print（r。group（））
　　1。2re。match
　　match从字符串的第一个字符开始匹配，如果未匹配到返回None，匹配到则返回一个对象
　　match判断正则表达式是否从开始处（首字母）匹配一个字符串，例如第一个不是d（数字），返回NoneimportreaA83C72D1D8E67rre。match（d，a）print（r）返回对象所在位置print（r。group（））返回找到的结果，例如8print（r。span（））返回一个元组表示匹配位置（开始，结束）
　　1。3re。search
　　Search与match有些类似，只是搜索整个字符串然后第一个匹配到指定的字符则返回值，未匹配到则返回None。获取值得方法也需要通过group（）从字符串开始往后匹配，一匹配到则返回一个对象。需要通过group来获取匹配到的值。
　　search遍历字符串，找到正则表达式匹配的第一个位置importreaA83C72D1D8E67rre。search（d，a）print（r）print（r。group（））
　　1。4re。findall
　　Findall是匹配出字符串中所有跟指定值有关的值，并且以列表的形式返回。未匹配到则返回一个空的列表。匹配出指定字符的所有值，并以列表返回值。
　　二、简单的模式：字符匹配
　　元字符
　　描述
　　。
　　句号匹配任意单个字符除了换行符
　　〔〕
　　字符种类，匹配方括号内的任意字符，中括号内每个字符是或（or）的关系
　　〔〕
　　否定的字符种类，匹配除了方括号里的任意字符
　　匹配0次或无限次，重复在号之前的字符
　　匹配1次或无限次，重复在号之前的字符
　　？
　　匹配0次或1次，重复在？号之前的字符
　　｛n，m｝
　　匹配num个大括号之前的字符（nnumm）
　　（xyz）
　　字符集又称做组，匹配与xyz完全相等的字符串，每个字符是且（and）的关系
　　或运算符，匹配符号前或后的字符
　　转义字符，用于匹配一些保留字符〔〕、（）、｛｝、。、、、？、、、、
　　从字符串开始位置开始匹配
　　从字符串末端开始匹配
　　反斜杠后面跟普通字符实现特殊功能
　　特殊字符
　　描述
　　d
　　匹配数字，相当于〔09〕
　　D
　　不匹配数字，相当于〔09〕
　　s
　　匹配空白字符（包括空格、换行符、制表符等），相当于〔rfv〕
　　S
　　与s相反，相当于〔rfv〕
　　w
　　匹配中文，下划线，数字，英文，相当于〔azAz09〕
　　W
　　与w相反，匹配特殊字符，如、、空格、、等
　　b
　　匹配单词的开始或结束
　　B
　　与b相反
　　2。1元字符提取字符串a中所有的数字，返回结果：〔7，6，3，6〕importrea孙悟空7猪八戒6沙和尚3唐僧6白龙马rre。findall（〔09〕，a）print（r）提取字符串a中所有非数字，返回：〔孙，悟，空，猪，八，戒，沙，和，尚，唐，僧，白，龙，马〕importrea孙悟空7猪八戒6沙和尚3唐僧6白龙马rre。findall（〔09〕，a）print（r）找到字符串中间字母是d或e的单词，返回：〔xdz，xez〕importreaxyz，xcz，xfz，xdz，xaz，xezrre。findall（x〔de〕z，a）print（r）找到字符串中间字母不是d或e的单词，返回：〔xyz，xcz，xfz，xaz〕importreaxyz，xcz，xfz，xdz，xaz，xezrre。findall（x〔de〕z，a）print（r）找到字符串中间字母是d或e或f的单词，返回：〔xfz，xdz，xez〕importreaxyz，xcz，xfz，xdz，xaz，xezrre。findall（x〔df〕z，a）print（r）
　　2。2概括字符集提取字符串a中所有的数字importreaExcel12345Word23456PPT12lrrre。findall（d，a）print（r）提取字符串a中所有非数字importreaExcel12345Word23456PPT12lrrre。findall（D，a）print（r）w可以提取中文，英文，数字和下划线，不能提取特殊字符importreaExcel12345Word23456PPT12lrrre。findall（w，a）print（r）W提取特殊字符、空格、、等importreaExcel12345Word23456PPT12lrrre。findall（W，a）print（r）
　　2。3数量词提取大小写字母混合的单词importreaExcel12345Word23456PPT12Lrrre。findall（〔azAZ〕｛3，5｝，a）print（r）贪婪与非贪婪【Python默认使用贪婪模式】贪婪：〔azAZ〕｛3，5｝先找三个连续的字母，最多找到5个连续的字母后停止。在3个以后且5个以内发现了不是子母的也停止。非贪婪：〔azAZ〕｛3，5｝？或〔azAZ〕｛3｝建议使用后者，不要使用？号，否则你会与下面的？号混淆匹配0次或无限多次号，号前面的字符出现0次或无限次importreaexce0excell3excel3rre。findall（excel，a）print（r）匹配1次或者无限多次号，号前面的字符至少出现1次importreaexce0excell3excel3rre。findall（excel，a）print（r）匹配0次或1次？号，？号经常用来去重复importreaexce0excell3excel3rre。findall（excel？，a）print（r）
　　2。4边界匹配和
　　限制电话号码的位置必需是811位才能提取importretel13811115888rre。findall（d｛8，11｝39；，tel）print（r）
　　2。5组（）将abc打成一个组，｛2｝指的是重复几次，匹配abcabcimportreaabcabcabcxyzabcabcxyzabcrre。findall（（abc）｛2｝，a）print（r）
　　可以加入很多个组
　　2。6匹配模式参数findall第三参数re。I忽略大小写importreaabcFBIabcCIAabcrre。findall（fbi，a，re。I）print（r）多个模式之间用连接在一起importreaabcFBIabcCIAabcrre。findall（fbi。｛1｝，a，re。Ire。S）匹配fbi然后匹配任意一个字符包括print（r）
　　注：。句号，不匹配，但是使用re。S之后，匹配所有字符包括换行符1）。re。I（re。IGNORECASE）：忽略大小写2）。re。M（MULTILINE）：多行模式，改变’’和’’的行为3）。re。S（DOTALL）：点任意匹配模式，改变’。’的行为4）。re。L（LOCALE）：使预定字符类wWbBsS取决于当前区域设定5）。re。U（UNICODE）：使预定字符类wWbBsSdD取决于unicode定义的字符属性6）。re。X（VERBOSE）：详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释
　　2。7re。sub替换字符串把FBI替换成BBQimportreaabcFBIabcCIAabcrre。sub（FBI，BBQ，a）print（r）把FBI替换成BBQ，第4参数写1，证明只替换第一次，默认是0（无限替换）importreaabcFBIabcFBIaFBICIAabcrre。sub（FBI，BBQ，a，1）print（r）注意：虽然字符串的内置方法字符串。replace也可以进行替换，但是正则表达式更强大拓展知识importreaabcFBIabcFBIaFBICIAabcdef函数名（形参）：passrre。sub（FBI，函数名，a，1）print（r）
　　分析：如果找到了FBI这个子串，会将FBI当成参数传到形参中，pass是什么都没返回，所以FBI被空字符串代替了。把函数当参数传到sub的列表里，实现把业务交给函数去处理，例如将FBI替换成FBIimportreaabcFBIabcFBIaFBICIAabcdef函数名（形参）：分段获取形参。group（）group（）在正则表达式中用于获取分段截获的字符串，获取到FBIreturn39；分段获取39；rre。sub（FBI，函数名，a）print（r）
　　2。8把函数做为参数传递将字符串中大于等于5的替换成9，小于5的替换成0importreaC52730A52730D52730def函数名（形参）：分段获取形参。group（）ifint（分段获取）5：return9else：return0rre。sub（d，函数名，a）print（r）
　　2。9group分组importrea123abc456printre。search（（〔09〕）（〔az〕）（〔09〕），a）。group（0）123abc456，返回整体printre。search（（〔09〕）（〔az〕）（〔09〕），a）。group（1）123printre。search（（〔09〕）（〔az〕）（〔09〕），a）。group（2）abcprintre。search（（〔09〕）（〔az〕）（〔09〕），a）。group（3）456正则表达式中的三组括号把匹配结果分成三组group（）同group（0）就是匹配正则表达式整体结果group（1）列出第一个括号匹配部分，group（2）列出第二个括号匹配部分，group（3）列出第三个括号匹配部分。没有匹配成功的，re。search（）返回None当然正则表达式中没有括号，group（1）肯定不对了。importrealifeisshort，iusepythonrre。search（life（。）python，a）print（r。group（1））等同于importrealifeisshort，iusepythonrre。findall（life（。）python，a）print（r）拓展知识importrealifeisshort，iusepython，ilovepythonrre。search（life（。）python（。）python，a）print（r。group（0））完整正则匹配print（r。group（1））第1个分组之间的取值print（r。group（2））第2个分组之间的取值print（r。group（0，1，2））以元组形式返回3个结果取值print（r。groups（））返回就是group（1）和group（2）
　　三、正则表达式的一些建议
　　1、常用的正则表达式，不用自己写，在百度上搜索常用正则表达式，不要重复造轮子2、如果内置方法可以快速解决问题，建议不要化简为繁
　　附1：正则表达式基础语法
　　d
　　指出一个字符串的开始
　　指出一个字符串的结束
　　将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符
　　abc
　　匹配所有以abc开始的字符串（例如：abc，abccba）
　　abc
　　匹配所有以abc结尾的字符串（例如：gggabc，reddcba）
　　abc
　　匹配开始和结尾都为abc的字符串（例如：abc）
　　abc
　　没有任何字符，匹配任何包含abc的字符串（例如：aaaabccc，abc123）
　　n
　　匹配n：匹配换行符这里是he连在一起写，匹配字符
　　匹配前面的子表达式零次或多次
　　匹配前面的子表达式一次或多次
　　？
　　匹配前面的子表达式零次或一次
　　ac
　　匹配字符串其中一个a后面跟着零个或若干个c（例如：accc，abbb）
　　ac
　　匹配字符串其中一个a后面跟着至少一个c或者多个（例如：ac，acccccccc）
　　ac？
　　匹配字符串其中一个a后面跟着零个或者一个c（例如：a，ac）
　　a？c
　　匹配字符串的末尾有零个或一个a跟着一个或多个c（例如：ac，acccccc，c，ccccccc）
　　｛n｝
　　n为非负整数，匹配n次
　　｛n，｝
　　n为非负整数，匹配至少n次
　　｛n，m｝
　　n，m为非负整数，最少匹配n次最多匹配m次
　　ab｛3｝
　　表示一个字符串有一个a后面跟随2个b（例如：abb，abbbbb）
　　ab｛3，｝
　　表示一个字符串有一个a后面跟随至少2个b（例如：abb，abbb）
　　ab｛3，6｝
　　表示一个字符串有一个a后面跟随3到6个b（例如：abbb，abbbb，abbbb）
　　表示或
　　。
　　表示任何字符
　　ab
　　表示一个字符串里有a或者b（例如：a，b，ab，abc）
　　a。
　　表示一个字符串有一个a后面跟着一个任意字符（例如：a1，a456，avv）
　　附2：方括号里用表示不希望出现的字符
　　〔abc〕
　　表示字符集合，表示一个字符串有一个a或b或c等价于〔zbc〕
　　〔abc〕
　　表示一个字符串中不应该出现abc，即是匹配未包含改集合的任意字符
　　〔az〕
　　表示一个字符串中存在一个a和z之间的所有字母
　　〔09〕
　　表示一个字符串中存在一个0和9之间的所有数字
　　〔az〕
　　表示一个字符串中不应该出现a到z之间的任意一个字母
　　〔1〕
　　表示一个字符串中以字母开头
　　〔09〕
　　表示一个百分号前有一个的数字；
　　附3：由字符和另一个字符组成特殊含义
　　匹配一个数字字符，等价〔09〕
　　d
　　匹配一个非数字字符，等价09
　　D
　　匹配一个换页符，等价和cL
　　f
　　匹配一个换行符。等价于和cJ
　　匹配一个回车符。等价于和cM
　　r
　　匹配任何空白字符，包括空格、制表符、换页符等等。等价于〔frv〕
　　s
　　匹配任何非空白字符。等价于frv
　　S5、requests库
　　实例导入requests包importrequests发送请求xrequests。get（https：www。runoob。com）返回网页内容print（x。text）response响应属性或方法
　　属性或方法
　　说明
　　apparentencoding
　　编码方式
　　close（）
　　关闭与服务器的连接
　　content
　　返回响应的内容，以字节为单位
　　cookies
　　返回一个CookieJar对象，包含了从服务器发回的cookie
　　elapsed
　　返回一个timedelta对象，包含了从发送请求到响应到达之间经过的时间量，可以用于测试响应速度。比如r。elapsed。microseconds表示响应到达需要多少微秒。
　　encoding
　　解码r。text的编码方式
　　headers
　　返回响应头，字典格式
　　history
　　返回包含请求历史的响应对象列表（url）
　　ispermanentredirect
　　如果响应是永久重定向的url，则返回True，否则返回False
　　isredirect
　　如果响应被重定向，则返回True，否则返回False
　　itercontent（）
　　迭代响应
　　iterlines（）
　　迭代响应的行
　　json（）
　　返回结果的JSON对象（结果需要以JSON格式编写的，否则会引发错误）
　　links
　　返回响应的解析头链接
　　next
　　返回重定向链中下一个请求的PreparedRequest对象
　　ok
　　检查statuscode的值，如果小于400，则返回True，如果不小于400，则返回False
　　raiseforstatus（）
　　如果发生错误，方法返回一个HTTPError对象
　　reason
　　响应状态的描述，比如NotFound或OK
　　request
　　返回请求此响应的请求对象
　　statuscode
　　返回http的状态码，比如404和200（200是OK，404是NotFound）
　　text
　　返回响应的内容，unicode类型数据
　　url
　　返回响应的URL导入requests包importrequests发送请求xrequests。get（https：www。runoob。com）返回http的状态码print（x。statuscode）响应状态的描述print（x。reason）返回编码print（x。apparentencoding）
　　输出结果如下：200OKutf8
　　实例importrequests发送请求xrequests。get（https：www。runoob。comtryajaxjsondemo。json）返回json数据print（x。json（））输出：｛name：网站，num：3，sites：〔｛name：Google，info：〔Android，Google搜索，Google翻译〕｝，｛name：Runoob，info：〔菜鸟教程，菜鸟工具，菜鸟微信〕｝，｛name：Taobao，info：〔淘宝，网购〕｝〕｝requests方法
　　requests方法如下表：
　　方法
　　描述
　　delete（url，args）
　　发送DELETE请求到指定url
　　get（url，params，args）
　　发送GET请求到指定url
　　head（url，args）
　　发送HEAD请求到指定url
　　patch（url，data，args）
　　发送PATCH请求到指定url
　　post（url，data，json，args）
　　发送POST请求到指定url
　　put（url，data，args）
　　发送PUT请求到指定url
　　request（method，url，args）
　　向指定的url发送指定的请求方法
　　发送get请求：导入requests包importrequests发送请求xrequests。request（get，https：www。runoob。com）返回网页内容print（x。statuscode）输出结果如下：200
　　设置请求头：导入requests包importrequestskw｛s：python教程｝设置请求头headers｛UserAgent：Mozilla5。0（WindowsNT10。0；Win64；x64）AppleWebKit537。36（KHTML，likeGecko）Chrome54。0。2840。99Safari537。36｝params接收一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode（）responserequests。get（https：www。runoob。com，paramskw，headersheaders）查看响应状态码print（response。statuscode）查看响应头部字符编码print（response。encoding）查看完整url地址print（response。url）查看响应内容，response。text返回的是Unicode格式的数据print（response。text）
　　输出结果如下：200UTF8https：www。runoob。com？spythonE69599E7A88B。。。其他内容。。。
　　post（）方法可以发送POST请求到指定url，一般格式如下：requests。post（url，data｛key：value｝，json｛key：value｝，args）url请求url。data参数为要发送到指定url的字典、元组列表、字节或文件对象。json参数为要发送到指定url的JSON对象。args为其他参数，比如cookies、headers、verify等。
　　实例导入requests包importrequests发送请求xrequests。post（https：www。runoob。comtryajaxdemopost。php）返回网页内容print（x。text）
　　输出结果如下：pstylecolor：red；本内容是使用POST方法请求的。pstylecolor：red；请求时间：2022052617：30：47
　　post请求带参数：导入requests包importrequests表单参数，参数名为fname和lnamemyobj｛fname：RUNOOB，lname：Boy｝发送请求xrequests。post（https：www。runoob。comtryajaxdemopost2。php，datamyobj）返回网页内容print（x。text）
　　输出结果如下：pstylecolor：red；你好，RUNOOBBoy，今天过得怎么样？6、常见的排序算法
　　选择排序O（n）从当前元素后的无序元素数组中找到最小值如果找到了，将该元素与当前元素交换如果没找到，说明当前元素是后续无序数组中的最小值执行上述过程n1次defselectionsort（array）：最后一个元素无序比较，所以执行n1次foriinrange（len（array）1）：minindexi从当前index1的位置开始遍历forjinrange（i1，len（array））：ifarray〔j〕array〔minindex〕：minindexj如果找到最小值ifi！minindex：array〔i〕，array〔minindex〕array〔minindex〕，array〔i〕
　　冒泡排序O（n）本质就是将最大值移动到数组末端比较cur和next，如果curnext，则交换两者执行上述过程n次defbubblesort（array）：foriinrange（len（array））：每完成一次遍历，结尾就有一个最大元素，那么我们接下来的遍历过程可以1forjinrange（len（array）1i）：array〔j〕表示curifarray〔j〕array〔j1〕：array〔j〕，array〔j1〕array〔j1〕，array〔j〕
　　归并排序
　　归并排序适用于两个有序数组进行重新排序
　　合并两个有序数组声明一个新数组，该数组的长度左数组右数组比较两个左数组和右数组的头元素，小的值将添加到新数组的头部重复步骤2，直到某个数组没有元素为止将剩余元素的数组直接添加到新数组末端defmerge（left，right）：：paramleft：左数组：paramright：右数组：return：因为我们是python的list，所以不用考虑声明长度result〔〕whileleftandright：比较两个数组的头元素ifleft〔0〕right〔0〕：通过list。pop删除并返回指定位置的元素result。append（left。pop（0））else：result。append（right。pop（0））whileleft：result。append（left。pop（0））whileright：result。append（right。pop（0））returnresult对无序的数组进行重新排序无序数组〔a，b，c，d，e〕可以拆分成〔a，b〕，〔c，d，e〕〔a，b〕排序后得到〔b，a〕〔c，d，e〕可以拆分为〔c，d〕，〔e〕〔c，d〕排序后得到〔d，c〕得到了三组有序数组〔d，c〕，〔e〕归并后得到〔d，c，e〕〔d，c，e〕，〔b，a〕归并后得到〔d，b，c，a，e〕defmergesort（array）：使用递归实现分治思想：paramarray：：return：一旦使用递归，首先要考虑的是退出逻辑iflen（array）2：returnarraymiddlelen（array）2leftarrayarray〔：middle〕rightarrayarray〔middle：〕returnmerge（mergesort（leftarray），mergesort（rightarray））
　　快速排序从数组中选定一个基准（pivot）遍历基础之后的元素，将比它小的元素置于左边，比它大的元素置于右边声明i，j两个指针比较pivot和j的值，如果pivotj，交换i和j的值，i1不管比较的结果，j1j到达末端，pivot和i1交换值defpartition（array，left，right）：：paramarray：：paramleft：左端索引：paramright：右端索引：return：为了方便我们理解，这里选leftpivotleftijpivot1whilejright：ifarray〔pivot〕array〔j〕：array〔i〕，array〔j〕array〔j〕，array〔i〕i1j1array〔i1〕，array〔pivot〕array〔pivot〕，array〔i1〕返回原pivot值的新索引returni17、迭代器与生成器
　　迭代器迭代是Python最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter（）和next（）。字符串，列表或元组对象都可用于创建迭代器：
　　例子list〔1，2，3，4〕ititer（list）创建迭代器对象print（next（it））输出迭代器的下一个元素1print（next（it））2importsys引入sys模块list〔1，2，3，4〕ititer（list）创建迭代器对象whileTrue：try：print（next（it））exceptStopIteration：sys。exit（）
　　生成器
　　在Python中，使用了yield的函数被称为生成器（generator）。
　　跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
　　在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值，并在下一次执行next（）方法时从当前位置继续运行。
　　调用一个生成器函数，返回的是一个迭代器对象。
　　以下实例使用yield实现斐波那契数列：
　　实例！usrbinpython3importsysdeffibonacci（n）：生成器函数斐波那契a，b，counter0，1，0whileTrue：if（countern）：returnyieldaa，bb，abcounter1ffibonacci（10）f是一个迭代器，由生成器返回生成whileTrue：try：print（next（f），end）exceptStopIteration：sys。exit（）
　　执行以上程序，输出结果如下：0112358132134558、类的继承
　　Python同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示：
　　classDerivedClassName（BaseClassName）：
　　子类（派生类DerivedClassName）会继承父类（基类BaseClassName）的属性和方法。
　　BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：9、lambda匿名函数
　　Python使用lambda来创建匿名函数。
　　所谓匿名，意即不再使用def语句这样标准的形式定义一个函数。lambda只是一个表达式，函数体比def简单很多。lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。虽然lambda函数看起来只能写一行，却不等同于C或C的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
　　语法
　　lambda函数的语法只包含一个语句，如下：lambda〔arg1〔，arg2，。。。。。argn〕〕：expressionxlambdaa：a10print（x（5））输出15sumlambdalambdaa，b，c：abcprint（sumlambda（1，100，10000））输出10101
　　lambda高阶函数示范匿名函数与max（）函数配合使用list1〔｛a：10，b：20｝，｛a：13，b：2｝，｛a：23，b：13｝，｛a：32，b：17｝〕mmax（list1，keylambdax：x〔a〕）print（列表最大数：，m）map（）映射函数将列表中所有的值求平方后返回至列表list1〔1，3，5，7，9〕itmap（lambdax：x2，list1）foriinit：print（i，end）运行结果：19254981filter（）过滤函数将列表中的偶数取出来list2〔1，2，5，6，8，9〕itfilter（lambdax：x20，list2）foriinit：print（i，end）运行结果：268reduce（）累计函数，常用于叠加或叠乘求列表中所有数相乘的结果list3〔1，2，3，4，5，6〕resultreduce（lambdax，y：xy，list3）print（result）运行结果为：720sorted（）函数排序1ls〔｛a：1，b：2，c：4｝，｛a：11，b：4，c：16｝，｛a：11，b：4，c：16｝〕2lssortedsorted（ls，keylambdad：d〔b〕，reverseTrue）3print（lssorted）〔｛a：11，b：4，c：16｝，｛a：11，b：4，c：16｝，｛a：1，b：2，c：4｝〕10、深拷贝与浅拷贝
　　深浅拷贝都是对源对象的复制，占用不同的内存空间
　　如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象
　　如果源对象不止一级目录的话，源做任何改动，都要影响浅拷贝，但不影响深拷贝
　　序列对象的切片其实是浅拷贝，即只拷贝顶级的对象
　　直接赋值：其实就是对象的引用（别名）。浅拷贝（copy）：拷贝父对象，不会拷贝对象的内部的子对象。深拷贝（deepcopy）：copy模块的deepcopy方法，完全拷贝了父对象及其子对象。