广州做网站专业公司,本地云主机搭建wordpress,高埗镇网站建设,wordpress 权限说明1#xff1a;为什么学习Python 家里有在这个IT圈子里面#xff0c;也想让我接触这个圈子#xff0c;然后给我建议学的Python#xff0c;然后自己通过百度和向有学过Python的同学了解了Python#xff0c;Python这门语言#xff0c;入门比较简单#xff0c;它简单易学为什么学习Python 家里有在这个IT圈子里面也想让我接触这个圈子然后给我建议学的Python然后自己通过百度和向有学过Python的同学了解了PythonPython这门语言入门比较简单它简单易学生态圈比较强大涉及的地方比较多特别是在人工智能和数据分析这方面。在未来我觉得是往自动化人工智能这方面发展的所以学习了Python 2通过什么途径学习Python 刚开始接触Python的时候到网上里面跟着视频学基础再后来网上到看技术贴然后看到有人推荐廖雪峰的Python教程练项目到GitHub上面找一些小项目学习。 3谈谈对Python和其他语言的区别 优点 Python属于解释型语言当程序运行时是一行一行的解释并运行所以调式代码很方便开发效率高Python 语法简洁优美功能强大标准库与第三方库都非常强大而且应用领域也非常广 还有龟叔给Python定位是任其自由发展、优雅、明确、简单 Python 易于学习; 用少量的代码构建出很多功能;高效的高级数据结构 Python完全支持面向对象; Python 是跨平台且开源的。可移植性可扩展性可嵌入性都很强 动态类型: 缺点 运行速度慢Python的运行速度相较与C肯定是慢了 Python弱类型强类型是指不允许隐式变量类型转换弱类型则允许隐式类型转换 与其他语言相比 与java相比在很多方面Python比Java要简单比如java中所有变量必须声明才能使用而Python不需要声明,用少量的代码构建出很多功能;高效的高级数据结构与php相比python标准包直接提供了工具并且相对于PHP代码更易于维护;Python与c相比Python 和 C Python这门语言是由C开发而来4简述解释型和编译型编程语言 解释型就是边解释边执行Pythonphp 编译型编译后再执行c、java、c# 5Python的解释器种类以及相关特点 CPython 官方版本的解释器。使用C语言开发的所以叫CPython。在命令行下运行python就是启动CPython解释器。CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。 IPython IPython是基于CPython之上的一个交互式解释器也就是说IPython只是在交互方式上有所增强但是执行Python代码的功能和CPython是完全一样的。CPython用作为提示符而IPython用In [序号]:作为提示符。 PyPy 由Python写的解释器它的执行速度是最快。PyPy采用JIT技术对Python代码进行动态编译注意不是解释绝大部分Python代码都可以在PyPy下运行但是PyPy和CPython有一些是不同的这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。 Jython Jython是运行在Java平台上的Python解释器可以直接把Python代码编译成Java字节码执行。 IronPython IronPython和Jython类似只不过IronPython是运行在.Net平台上的Python解释器可以直接把Python代码编译成.Net的字节码。 小结 Python的解释器很多但使用最广泛的还是CPython。 如果要和Java或.Net平台交互最好的办法不是用Jython或IronPython而是通过网络调用来交互确保各程序之间的独立性。 6位和字节的关系 1字节 8 位 位bit又名“比特”简写为b数据传输是以大多是以“位”bit为单位 字节Byte简写为B数据存储是以“字节”Byte为单位字节是最小一级的信息单位 一个位就代表一个0或1即一个二进制二进制是构成存储器的最小单位每8个位bit组成一个字节Byte 7b、B、KB、MB、GB的关系 b ---位(bit) B ---字节 一个字节等于8位 1B 8 bit 1kb 1024 B 1 MB 1024 KB 1 GB 1024 MB 8PE8规范 1、使用4个空格而不是tab键进行缩进。 2、每行长度不能超过79 3、使用空行来间隔函数和类以及函数内部的大块代码 4、必要时候在每一行下写注释 5、使用文档注释写出函数注释 6、在操作符和逗号之后使用空格但是不要在括号内部使用 7、命名类和函数的时候使用一致的方式比如使用CamelCase来命名类 使用lower_case_with_underscores来命名函数和方法 8、在类中总是使用self来作为默认 9、尽量不要使用魔法方法 10、默认使用UTF-8甚至ASCII作为编码方式 11、换行可以使用反斜杠最好使用圆括号。 12、不要在一句import中多个库 13、空格的使用 各种右括号前不要加空格。 逗号、冒号、分号前不要加空格。 函数的左括号前不要加空格。如Func(1) 序列的左括号前不要加空格。如list[2] 操作符左右各加一个空格不要为了对齐增加空格 函数默认参数使用的赋值符左右省略空格 不要将多句语句写在同一行尽管使用‘’允许 14、if/for/while语句中即使执行语句只有一句也必须另起一行 15、函数命名使用全部小写的方式常量命名使用大写类属性方法和变量使用小写 16、类的命名首字母大写 9通过代码实现如下转换(进制之间转换 # 二进制转换成十进制--int v 0b1111011 b int(v,2) print(b) # 123 # 十进制转换成二进制---bin v2 18 print(bin(int(v2))) # 0b10010 # 八进制转换成十进制 v3 011 print(int(v3, 8)) # 11 # 十进制转换成八进制--- oct v4 30 print(oct(int(v4))) # 0o36 # 十六进制转换成十进制 v5 0x12 print(int(v5,16)) # 18 # 十进制转换成十六进制--- hex v6 87 print(hex(int(v6))) # 0x57 10:请编写一个函数实现将IP地址转换成一个整数 如 10.3.9.12 转换规则为 10 00001010
3 00000011
9 00001001
12 00001100
再将以上二进制拼接起来计算十进制结果00001010 00000011 00001001 00001100
# 第一种
ip_addr 192.168.2.10
# transfer ip to int
def ip2long(ip):ip_list ip.split(.)result 0for i in range(4): # 0,1,2,3result result int(ip_list[i]) * 256 ** (3 - i)return result
long 3232236042# transfer int to ip
def long2ip(long):floor_list []yushu longfor i in reversed(range(4)): # 3,2,1,0res divmod(yushu, 256 ** i)floor_list.append(str(res[0]))yushu res[1]return ..join(floor_list)a long2ip(long)
print(a)# 第二种
def v1(addr):# 取每个数id [int(x) for x in addr.split(.)]print(id)return sum(id[i] [24, 16, 8, 0][i] for i in range(4))print(v1(127.0.0.1))# [127, 0, 0, 1]
# 2130706433
11、python递归的最大层数 Python中默认的递归层数约为998左右(会报错) 和计算机性能有关系 12求结果(and or or) v1 1 or 3 -- 1 v2 1 and 3 -- 3 v3 0 and 2 and 1 -- 0 v4 0 and 2 or 1 -- 1 v5 0 and 2 or 1 or 4 -- 1 v6 0 or Flase and 1 -- False 总结 # x or y 如果 x 为真则值为 x否则为 y # x and y 如果 x 为真则值为 y否则为 x # 优先级()notandor # 同等优先级下从左向右 1. 求结果2 5 print(2 5) # 10 101 000 0 2. 求结果2 ^ 5 print(2 ^ 5) # 10 ^ 101 111 1*2**01*2**11*2**21247 13 ascii、unicode、utf-8、gbk 区别 python2 内容进行编码默认ascii,而python3对内容进行编码的默认为utf-8。 ascii 最多只能用8位来表示一个字节即2**8 256所以ASCII码最多只能表示 256 个符号。 unicode 万国码 任何一个字符两个字节 utf-8 万国码的升级版 一个中文字符三个字节 英文是一个字节 欧洲的是 2个字节 gbk 国内版本 一个中文字符2个字节 英文是一个字节 gbk 转 utf-8 需通过媒介 unicode 14:字节码和机器码的区别 什么是机器码 机器码(machine code)学名机器语言指令有时也被称为原生码Native Code是电脑的CPU可直接解读的数据。 通常意义上来理解的话机器码就是计算机可以直接执行并且执行速度最快的代码。 总结机器码是电脑CPU直接读取运行的机器指令运行速度最快但是非常晦涩难懂也比较难编写 什么是字节码 字节码Bytecode是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。 字节码是一种中间码它比机器码更抽象需要直译器转译后才能成为机器码的中间代码。 总结字节码是一种中间状态中间码的二进制代码文件。需要直译器转译后才能成为机器码。 简述变量命名规范 #1、以字母数字下划线任由结合 #2、不能以命名太长不使用拼音中文 #3、不能以数字开头 #4、不能用关键词 15:三元运算写法和应用场景 应用场景简化if语句 # 条件成立时的结果 if 条件 else 条件不成立时的结果例 result gt if 13 else lt print(result) # lt # 理解如果条件为真把if前面的值赋值给变量否则把else后面的值赋值给变量。 16:Python3和Python2的区别
链接Python2 和 Python3 的区别 1打印时py2需要可以不需要加括号python3 必须加括号 python 2 print (lili) 或 print lili python 3 print (lili) exec语句被python3废弃统一使用exec函数 2内涵 Python2 1臃肿源码的重复量很多。 2语法不清晰掺杂着CphpJava的一些陋习。 Python3 几乎是重构后的源码规范清晰优美。 3、输出中文的区别 python2 要输出中文 需加 # -*- encoding:utf-8 -*- Python3 直接搞 4input不同 python2 raw_input python3 input 统一使用input函数 5指定字节 python2在编译安装时可以通过参数-----enable-unicodeucs2 或-----enable-unicodeucs4分别用于指定使用2个字节、4个字节表示一个unicode python3无法进行选择默认使用 ucs4 查看当前python中表示unicode字符串时占用的空间 impor sys printsys.maxunicode #如果值是65535则表示使用usc2标准即2个字节表示 #如果值是1114111则表示使用usc4标准即4个字节表示 6 py2xrange range py3range 统一使用rangePython3中range的机制也进行修改并提高了大数据集生成效率 7在包的知识点里 包一群模块文件的集合 __init__ 区别py2 必须有__init__ py3不是必须的了 8不相等操作符被Python3废弃统一使用! 9long整数类型被Python3废弃统一使用int 10迭代器iterator的next()函数被Python3废弃统一使用next(iterator) 11异常StandardError 被Python3废弃统一使用Exception 12字典变量的has_key函数被Python废弃统一使用in关键词 13file函数被Python3废弃统一使用open来处理文件可以通过io.IOBase检查文件类型 17用一行代码实现数值交换 a 1 b 2 a, b b, a 20文件操作时xreadlines和readlines的区别 readlines 返回一个列表 xreadlines 返回一个生成器 python3 中只有readlines 21 列举布尔值为False的常见值 0“”{}[],set False 负数 不成立的表达式 None 等 22. 字符串、列表、元组、字典每个常用的5个方法
参考链接Python 之数据类型 字符串字符串用单引号()或双引号()括起来不可变 1find通过元素找索引可切片找不到返回-1 2index找不到报错。 3split 由字符串分割成列表默认按空格。 4captalize 首字母大写其他字母小写。 5upper 全大写。 6lower 全小写。 7title每个单词的首字母大写。 8startswith 判断以什么为开头可以切片整体概念。 9endswith 判断以什么为结尾可以切片整体概念。 10format格式化输出三种玩法 res{} {} {}.format(egon,18,male) egon 18 male res{1} {0} {1}.format(egon,18,male) 18 egon 18 res{name} {age} {sex}.format(sexmale,nameegon,age18) 11strip 默认去掉两侧空格有条件 12lstrip,rstrip 14center 居中默认空格。 15count查找元素的个数可以切片若没有返回0 16expandtabs 将一个tab键变成8个空格如果tab前面的字符长度不足8个则补全8个 17replaceoldnew,次数 18isdigit 字符串由字母或数字组成 isalpha, 字符串只由字母组成 isalnum 字符串只由数字组成 19swapcase 大小写翻转 20for i in 可迭代对象。 字典1无序不能索引2数据关联性强3:键值对键值对。唯一一个映射数据类型。 # 字典的键必须是可哈希的 不可变类型。 # 在同一个字典中键(key)必须是唯一的。 # 列表是有序的对象集合字典是无序的对象集合。两者之间的区别在于字典当中的元素是通过键来存取的而不是通过偏移存取 key 输出所有的键 clear清空 dic删除的键如果没有则报错 pop键值对删有返回没有原来的键会报错自行设置返回键就不会报错 popitem随机删键值对 del删除的键如果没有则报错 update改 查 用get时不会报错没有可以返回设定的返回值 注意 1、字典是一种映射类型它的元素是键值对。 2、字典的关键字必须为不可变类型且不能重复。 3、创建空字典使用 { }。 列表 索引切片加乘检查成员。 增加有三种 append在后面添加。 insert按照索引添加 expend迭代着添加。 list.extend(seq) - 在列表末尾一次性追加另一个序列中的多个值用新列表扩展原来的列表 pop 删除 (pop 有返回值) remove 可以按照元素去删 clear 清空列表 del 1、可以按照索引去删除 2、切片 3、步长隔着删 改 1、索引 2、切片先删除再迭代着添加 list.count(obj) - 统计某个元素在列表中出现的次数 list.index(obj) - 从列表中找出某个值第一个匹配项的索引位置 list.reverse() - 反向列表中元素 list.sort([func]) - 对原列表进行排序 注意 1、List写在方括号之间元素用逗号隔开。 2、和字符串一样list可以被索引和切片。 3、List可以使用操作符进行拼接。 4、List中的元素是可以改变的。 元组 元组的元素不能修改 1、cmp(tuple1, tuple2)比较两个元组元素。 2、len(tuple)计算元组元素个数。 3、max(tuple)返回元组中元素最大值。 4、min(tuple)返回元组中元素最小值。 5、tuple(seq)将列表转换为元组。 注意 1、与字符串一样元组的元素不能修改。 2、元组也可以被索引和切片方法一样。 3、注意构造包含0或1个元素的元组的特殊语法规则。 4、元组也可以使用操作符进行拼接。 Set集合 集合set是一个无序不重复元素的序列。 可以使用大括号 { } 或者 set() 函数创建集合 注意创建一个空集合必须用 set() 而不是 { }因为 { } 是用来创建一个空字典。 23、 lambda表达式格式以及应用场景 匿名函数为了解决那些功能很简单的需求而设计的一句话函数 函数名 lambda 参数 返回值 # 参数可以有多个用逗号隔开 # 匿名函数不管逻辑多复杂只能写一行且逻辑执行结束后的内容就是返回值 # 返回值和正常的函数一样可以是任意数据类型 temp lambda x,y:xy print(temp(4,10)) # 14 可替代 def foo(x,y): return xy print(foo(4,10)) # 14 24. pass的作用 pass是空语句是为了保持程序结构的完整性。pass 不做任何事情一般用做占位语句。 25. *arg和**kwarg作用 *args代表位置参数它会接收任意多个参数并把这些参数作为元祖传递给函数。 **kwargs代表的关键字参数返回的是字典位置参数一定要放在关键字前面 26. is和的区别 a lishi str1 li str2 shi str3 str1 str2 print(a str3,a str3) # a str3 True --- 只需要内容相等 print(a is str3,a is str3) # a is str3 False is --- 只需要内存地址相等 print(id(a),id(a)) # id(a) 38565848 print(id(str3),id(str3)) # id(str3) 39110280 is 比较的是两个实例对象是不是完全相同它们是不是同一个对象占用的内存地址是否相同。 比较的是两个对象的内容是否相等即内存地址可以不一样内容一样就可以了。默认会调用对象的 __eq__()方法。 # 对于int 小数据池 范围-5 到 256 创建的相间的数字都指向同一个内存地址 # 对于字符串 面试 1、小数据池 如果有空格那指向两个内存地址 2、长度不能超过 20 3、不能用特殊字符 i a*20 j a*20 print(i is j) # True i a*21 j a*21 print(i is j) # False 27谈谈Python的深浅拷贝以及实现方法和应用场景。 浅拷贝只是增加了一个指针指向一个存在的地址 而深拷贝是增加一个指针并且开辟了新的内存这个增加的指针指向这个新的内存 采用浅拷贝的情况释放内存会释放同一内存深拷贝就不会出现释放同一内存的错误 # 一层的情况
import copy# 浅拷贝
li1 [1, 2, 3]
li2 li1.copy()
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]
# 深拷贝
li1 [1, 2, 3]
li2 copy.deepcopy(li1)
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]# 多层的情况
import copy# 浅拷贝 指向共有的地址
li1 [1, 2, 3,[4,5],6]
li2 li1.copy()
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]
# 深拷贝 重指向
li1 [1, 2, 3,[4,5],6]
li2 copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]
28. Python垃圾回收机制
参考Python内存管理以及垃圾回收机制 Python垃圾回收机制,主要使用引用计数来跟踪和回收垃圾。 在引用计数的基础上通过标记-清除mark and sweep解决容器对象可能产生的循环引用问题. 通过分代回收以空间换时间的方法提高垃圾回收效率。 引用计数 PyObject是每个对象必有的内容其中ob_refcnt就是做为引用计数。 当一个对象有新的引用时它的ob_refcnt就会增加当引用它的对象被删除 它的ob_refcnt就会减少.引用计数为0时该对象生命就结束了。 优点:1.简单 2.实时性 缺点:1.维护引用计数消耗资源 2.存在循环引用的话不能删除 标记-清楚机制 基本思路是先按需分配等到没有空闲内存的时候从寄存器和程序栈上的引用出发 遍历以对象为节点、以引用为边构成的图把所有可以访问到的对象打上标记 然后清扫一遍内存空间把所有没标记的对象释放。 分代技术 分代回收的整体思想是 将系统中的所有内存块根据其存活时间划分为不同的集合每个集合就成为一个“代” 垃圾收集频率随着“代”的存活时间的增大而减小存活时间通常利用经过几次垃圾回收来度量。 29. Python的可变类型和不可变类型 可变数据类型列表、字典、可变集合 不可变数据类型数字、字符串、元组、不可变集合 30、求结果 print([i*i for i in [1,2,3]]) # [1, 4, 9] def multipliers(): return [lambda x:i*x for i in range(4)] print([m(2) for m in multipliers()]) # 解释 # 函数返回值为一个列表表达式经过4次循环结果为包含四个lambda函数的列表 # 由于函数未被调用循环中的i值未被写入函数经过多次替代循环结束后i值为3 # 故结果为6,6,6,6 # 请修改multipliers的定义来产生期望的结果0,2,4,6。 def multipliers(): return lambda x:i*x for i in range(4) # 返回一个生成器表达式 print([m(2) for m in multipliers()]) 现有两个元组((a),(b)),((c),(d))请使用python中匿名函数生成列表[{a:c},{b:d}] # 匿名函数形式 l1((a),(b)) l2((c),(d)) retmap(lambda n:{n[0]:n[1]},zip(l1,l2)) print(list(ret)) # 列表表达式形式 l1((a),(b)) l2((c),(d)) print([{n[0]:n[1]} for n in zip(l1,l2)]) v dict.fromkeys([k1, k2], []) v[k1].append(666) print(v) v[k1] 777 print(v) 结果 {k1: [666], k2: [666]} {k1: 777, k2: [666]} 解释 dict.fromkeys(seq[, value]) 函数用于创建一个新字典 以序列seq中元素做字典的键value为字典所有键对应的初始值默认为None。 v1 dict.fromkeys([k1, k2]) print(v1) # {k1: None, k2: None} v2 dict.fromkeys([k1, k2], []) print(v2) # {k1: [], k2: []} 32、列举常见的内置函数 abs() # 返回数字的绝对值 map() # 根据函数对指定序列做映射函数接收两个参数一个是函数一个是可迭代对象map将传入的函数依次作用到序列的每个元素并把结果作为新的list返回。 # 返回值 Python2 返回列表 Python3 返回迭代器 # 例子1 def mul(x): return x*x n [1,2,3,4,5] res list(map(mul,n)) print(res) # [1, 4, 9, 16, 25] # 例子2abs() 返回数字的绝对值 ret map(abs,[-1,-5,6,-7]) print(list(ret)) # [1, 5, 6, 7] filter() # 函数接收一个函数 f(函数)和一个list可迭代对象这个函数 f的作用是对每个元素进行判断 返回 True或 False根据判断结果自动过滤掉不符合条件的元素返回由符合条件元素组成的新list。 def is_odd(x): return x % 2 1 vlist(filter(is_odd, [1, 4, 6, 7, 9, 12, 17])) print(v) # [1, 7, 9, 17] map与filter总结 # 相同点 # 参数: 都是一个函数名 可迭代对象 # 返回值: 都是返回可迭代对象 # 区别: # filter 是做筛选的结果还是原来就在可迭代对象中的项 # map 是对可迭代对象中每一项做操作的结果不一定是原来就在可迭代对象中的项 isinstance\type isinstance() 函数来判断一个对象是否是一个已知的类型类似 type()。 isinstance() 与 type() 区别 type() 不会认为子类是一种父类类型不考虑继承关系。 isinstance() 会认为子类是一种父类类型考虑继承关系。 如果要判断两个类型是否相同推荐使用 isinstance()。 # 例一 a 2 print(isinstance(a,int)) # True print(isinstance(a,str)) # False # type() 与 isinstance() 区别 class A: pass class B(A): pass print(isinstance,isinstance(A(),A)) # isinstance True print(type,type(A()) A) # type True print(isinstance,isinstance(B(),A) ) # isinstance True print(type,type(B()) A) # type False zip 拉链函数用于将可迭代的对象作为参数将对象中对应的元素打包成一个个元组然后返回由这些元组组成的列表。 将对象中对应的元素打包成一个个元组然后返回由这些元组组成的列表迭代器。 如果各个迭代器的元素个数不一致则返回列表长度与最短的对象相同。 print(list(zip([0,1,3],[5,6,7],[a,b]))) # [(0, 5, a), (1, 6, b)] a [1,2,3] b [4,5,6] c [4,5,6,7,8] zipped zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)] zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)] zip(*zipped) # 与 zip 相反可理解为解压返回二维矩阵式 [(1, 2, 3), (4, 5, 6)] reduce # 函数会对参数序列中元素进行累积函数将一个数据集合(链表、元组等)中的所有数据进行下列操作 注意Python3已经将reduce() 函数从全局名字空间里移除了它现在被放置在 fucntools 模块里如果想要使用它则需要通过引入 functools 模块来调用 reduce() 函数 from functools import reduce def add(x,y): return x y print(reduce(add,[1,2,3,4,5])) # 15 print(reduce(lambda x, y: xy, [1,2,3,4,5])) # 15 print(reduce(add,range(1,101))) # 5050 33. filter、map、reduce的作用 见上题 34、 一行代码实现9*9乘法表 print(\n.join([ .join([%s*%s%-2s % (j, i, i * j) for j in range(1, i 1)]) for i in range(1, 10)])) 35. 如何安装第三方模块以及用过哪些第三方模块 1pip包管理器 2源码下载 -下载 -解压 -python setup.py build -python setup.py install 用过的第三方模块requests,pymysql,DbUtils,SQLAlchemy等 36、 常用模块都有那些 re正则 os提供了一种方便的使用操作系统函数的方法。 sys可供访问由解释器使用或维护的变量和与解释器进行交互的函数。 random随机数 json序列化 time时间 datatime logging hlib math 爬虫里面的requests/beautifulsoup4bs4 37. re的match和search区别 re.match 尝试从字符串的起始位置匹配一个模式如果不是起始位置匹配成功的话match()就返回none。 re.search 扫描整个字符串并返回第一个成功的匹配。 38. 什么是正则的贪婪匹配 匹配一个字符串没有节制能匹配多少就去匹配多少直到没有匹配的为止 39. 求结果 print([ i % 2 for i in range(10) ]) # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] print([ i for i in range(10) ]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print([ 10 % 2]) # [0] # %是个运算符。 print(( i % 2 for i in range(10) )) # generator object genexpr at 0x00000000020CEEB8 生成器 # 在Python中有一种自定义迭代器的方式称为生成器Generator。 # 定义生成器的两种方式 # 1.创建一个generator只要把一个列表生成式的[]改成()就创建了一个generator # generator保存的是算法每次调用next()就计算出下一个元素的值直到计算到最后一个元素 没有更多的元素时抛出StopIteration的错误。 # 2.定义generator的另一种方法。如果一个函数定义中包含yield关键字那么这个函数就不再是一个普通函数 而是一个generator 40. 求结果 1 or 2 # 1 1 and 2 # 2 1 (22) # False 1 2 2 # True 41、def func(a,b[]) 这种写法有什什么坑 # 函数传参为列表陷阱列表是可变数据类型可能会在过程中修改里面的值 def func(a,b []): b.append(1) print(a,b) func(a2) func(2) func(2) 2 [1] 2 [1, 1] 2 [1, 1, 1] 函数的默认参数是一个list 当第一次执行的时候实例化了一个list 第二次执行还是用第一次执行的时候实例化的地址存储 所以三次执行的结果就是 [1, 1, 1] 想每次执行只输出[1] 默认参数应该设置为None 42、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] list(1,2,3.split(,)) 43. 如何实现[‘1’,’2’,’3’]变成[1,2,3] [int(x) for x in [1,2,3]] 44. a [1,2,3] 和 b [(1),(2),(3) ] 以及 c [(1,),(2,),(3,) ] 的区别 一个是数字类型一个是元祖类型 补充1 a[1,2,3,4,5]ba和ba[:]有区别么 a [1,2,3,4,5] b a b1 a[:] print(b) # [1, 2, 3, 4, 5] # print(b1) # [1, 2, 3, 4, 5] b.append(6) print(a,a) # a [1, 2, 3, 4, 5, 6] print(b,b) # b [1, 2, 3, 4, 5, 6] 传递引用 print(b1,b1) # b1 [1, 2, 3, 4, 5] 拷贝 # 补充2 一个列表A[234]Python如何将其转换成B[(2,3),(3,4),(4,2)] B zip(A, A[1:]A[:1]) 45. 如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] [i*i for i in range(1,11)] 46. 一行代码实现删除列表中重复的值 list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2])) 47. 如何在函数中设置一个全局变量 python中的global语句是被用来声明全局变量的。 x 2 def func(): global x x 1 return x func() print(x) # 1 48. logging模块的作用以及应用场景 logging 模块定义的函数和类为应用程序和库的开发实现了一个灵活的事件日志系统 作用可以了解程序运行情况是否正常 在程序的出现故障快速定位出错地方及故障分析 DEBUG详细的信息,通常只出现在诊断问题上 INFO确认一切按预期运行 WARNING一个迹象表明,一些意想不到的事情发生了,或表明一些问题在不久的将来(例如。磁盘空间低”)。这个软件还能按预期工作。 ERROR更严重的问题,软件没能执行一些功能 CRITICAL一个严重的错误,这表明程序本身可能无法继续运行 49. 请用代码简答实现stack
Stack() 创建一个新的空栈push(item) 添加一个新的元素item到栈顶pop() 弹出栈顶元素peek() 返回栈顶元素is_empty() 判断栈是否为空size() 返回栈的元素个数
# 实现一个栈stack,后进先出
class Stack:def __init__(self):self.items []def is_empty(self):# 判断是否为空return self.items []def push(self,item):# 加入元素self.items.append(item)def pop(self):# 弹出元素return self.items.pop()def peek(self):# 返回栈顶元素return self.items[len(self.items)-1]def size(self):# 返回栈的大小return len(self.items)if __name__ __main__:stack Stack()stack.push(H)stack.push(E)stack.push(L)print(stack.size()) # 3print(stack.peek()) # L print(stack.pop()) # Lprint(stack.pop()) # Eprint(stack.pop()) # H50. 常用字符串格式化哪几种 1.占位符% %d 表示那个位置是整数%f 表示浮点数%s 表示字符串。 print(Hello,%s % Python) print(Hello,%d%s%.2f % (666, Python, 9.99)) # 打印Hello,666Python10.00 2.format print({k} is {v}.format(kpython, veasy)) # 通过关键字 print({0} is {1}.format(python, easy)) # 通过关键字 51. 简述 生成器、迭代器、可迭代对象 以及应用场景 迭代器含有__iter__和__next__方法 (包含__next__方法的可迭代对象就是迭代器) 生成器包括含有yield这个关键字生成器也是迭代器调动next把函数变成迭代器。 应用场景 1、range/xrange - py2 range(1000000) 会立即创建xrange(1000000)生成器 - py3range10000000生成器 2、 redis获取值hscan_iter用到了 conn Redis(...) def hscan_iter(self, name, matchNone, countNone): cursor 0 while cursor ! 0: # 去redis中获取数据12 # cursor下一次取的位置 # data本地获取的12条数数据 cursor, data self.hscan(name, cursorcursor,matchmatch, countcount) for item in data.items(): yield item 3、stark组件 def index(request): data [ {k1:1,name:alex}, {k1:2,name:老男孩}, {k1:3,name:小男孩}, ] new_data [] for item in data: item[email] xxxqq.com new_data.append(item) return render(request,xx.html,{data:new_data}) 可迭代对象一个类内部实现__iter__方法且返回一个迭代器。 应用场景 - wtforms中对form对象进行循环时候显示form中包含的所有字段。 class LoginForm(Form): name simple.StringField( label用户名, validators[ validators.DataRequired(message用户名不能为空.), validators.Length(min6, max18, message用户名长度必须大于%(min)d且小于%(max)d) ], widgetwidgets.TextInput(), render_kw{class: form-control} ) pwd simple.PasswordField( label密码, validators[ validators.DataRequired(message密码不能为空.), validators.Length(min8, message用户名长度必须大于%(min)d), validators.Regexp(regex^(?.*[a-z])(?.*[A-Z])(?.*\d)(?.*[$$!%*?])[A-Za-z\d$$!%*?]{8,}, message密码至少8个字符至少1个大写字母1个小写字母1个数字和1个特殊字符) ], widgetwidgets.PasswordInput(), render_kw{class: form-control} ) form LoginForm() for item in form: print(item) - 列表、字典、元组 装饰器 能够在不修改原函数代码的基础上在执行前后进行定制操作闭包函数的一种应用 场景 - flask路由系统 - flask before_request - csrf - django内置认证 - django缓存 # 手写装饰器 import functools def wrapper(func): functools.wraps(func) #不改变原函数属性 def inner(*args, **kwargs): 执行函数前 return func(*args, **kwargs) 执行函数后 return inner 1. 执行wapper函数并将被装饰的函数当做参数。 wapper(index) 2. 将第一步的返回值重新赋值给 新index wapper(老index) wrapper #indexwrapper(index) def index(x): return x100 调用装饰器其实是一个闭包函数为其他函数添加附加功能不修改被修改的源代码和不修改被修饰的方式装饰器的返回值也是一个函数对象。 比如插入日志、性能测试、事物处理、缓存、权限验证等有了装饰器就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。 52. 用Python实现一个二分查找的函数。 二分查找算法简单的说就是将一个列表先排序好比如按照从小到大的顺序排列好当给定一个数据比如3查找3在列表中的位置时可以先找到列表中间的数li[middle]和3进行比较当它比3小时那么3一定是在列表的右边反之则3在列表的左边比如它比3小则下次就可以只比较[middle1, end]的数继续使用二分法将它一分为二直到找到3这个数返回或者列表全部遍历完成3不在列表中 优点效率高时间复杂度为O(logN) 缺点数据要是有序的顺序存储。 li [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]def search(someone, li):l -1h len(li)while l 1 ! h:m int((l h) / 2)if li[m] someone:l melse:h mp hif p len(li) or li[p] ! someone:print(元素不存在)else:str 元素索引为%d % pprint(str)search(3, li) # 元素索引为2
53. 谈谈你对闭包的理解 判断闭包函数的方法__closure__输出的__closure__有cell元素说明是闭包函数 闭包的意义与应用延迟计算 bar在foo函数的代码块中定义。我们称bar是foo的内部函数。 在bar的局部作用域中可以直接访问foo局部作用域中定义的m、n变量。 简单的说这种内部函数可以使用外部函数变量的行为就叫闭包。 def foo(): m3 n5 def bar(): a4 return mna return bar bar foo() bar() # 12 54. os和sys模块的作用 os模块负责程序与操作系统的交互提供了访问操作系统底层的接口; sys模块负责程序与python解释器的交互提供了一系列的函数和变量用于操控python的运行时环境。 os与sys模块的官方解释如下 os: This module provides a portable way of using operating system dependent functionality. 这个模块提供了一种方便的使用操作系统函数的方法。 sys: This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter. 这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数。 os 常用方法 os.remove() 删除文件 os.rename() 重命名文件 os.walk() 生成目录树下的所有文件名 os.chdir() 改变目录 os.mkdir/makedirs 创建目录/多层目录 os.rmdir/removedirs 删除目录/多层目录 os.listdir() 列出指定目录的文件 os.getcwd() 取得当前工作目录 os.chmod() 改变目录权限 os.path.basename() 去掉目录路径返回文件名 os.path.dirname() 去掉文件名返回目录路径 os.path.join() 将分离的各部分组合成一个路径名 os.path.split() 返回( dirname(), basename())元组 os.path.splitext() 返回 (filename, extension) 元组 os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间 os.path.getsize() 返回文件大小 os.path.exists() 是否存在 os.path.isabs() 是否为绝对路径 os.path.isdir() 是否为目录 os.path.isfile() 是否为文件 sys 常用方法 sys.argv 命令行参数List第一个元素是程序本身路径 sys.modules.keys() 返回所有已经导入的模块列表 sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息 sys.exit(n) 退出程序正常退出时exit(0) sys.hexversion 获取Python解释程序的版本值16进制格式如0x020403F0 sys.version 获取Python解释程序的版本信息 sys.maxint 最大的Int值 sys.maxunicode 最大的Unicode值 sys.modules 返回系统导入的模块字段key是模块名value是模块 sys.path 返回模块的搜索路径初始化时使用PYTHONPATH环境变量的值 sys.platform 返回操作系统平台名称 sys.stdout 标准输出 sys.stdin 标准输入 sys.stderr 错误输出 sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息 sys.exec_prefix 返回平台独立的python文件安装的位置 sys.byteorder 本地字节规则的指示器big-endian平台的值是big,little-endian平台的值是little sys.copyright 记录python版权相关的东西 sys.api_version 解释器的C的API版本 总结 os模块负责程序与操作系统的交互提供了访问操作系统底层的接口; sys模块负责程序与python解释器的交互提供了一系列的函数和变量用于操控python的运行时环境。 55. 如何生成一个随机数
import randomprint(random.random()) # 用于生成一个0到1的随机符点数: 0 n 1.0
print(random.randint(1, 1000)) # 用于生成一个指定范围内的整数
56. 如何使用python删除一个文件
import os
os.remove(文件名以及路径)
57. 谈谈你对面向对象的理解 三大特性以及解释 面对对象是一种编程思想以类的眼光来来看待事物的一种方式。将有共同的属性和方法的事物封装到同一个类下面。 继承将多个类的共同属性和方法封装到一个父类下面然后在用这些类来继承这个类的属性和方法 封装将有共同的属性和方法封装到同一个类下面 第一层面创建类和对象会分别创建二者的名称空间我们只能用类名.或者obj.的方式去访问里面的名字这本身就是一种封装 第二层面类中把某些属性和方法隐藏起来(或者说定义成私有的)只在类的内部使用、外部无法访问或者留下少量接口函数供外部访问。 多态Python天生是支持多态的。指的是基类的同一个方法在不同的派生类中有着不同的功能 58. Python面向对象中的继承有什么特点 继承概念的实现方式主要有2类实现继承、接口继承。 实现继承是指使用基类的属性和方法而无需额外编码的能力 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法) python 两种类经典类 新式类 python3 新式类 —— 都默认继承object class Animal(object): class Animal: python2 经典类和新式类 并存 class Animal: 经典类 —— 继承顺序 个别使用方法 class Animal(object): 新式类 继承分为单继承和多继承Python是支持多继承的 如果没有指定基类python的类会默认继承object类object是所有python类的基类它提供了一些常见方法如__str__的实现。 补充继承的应用面试题 1、对象可以调用自己本类和父类的所有方法和属性 先调用自己的 自己没有才调父类的。谁对象调用方法方法中的self就指向谁 class Foo: def __init__(self): self.func() def func(self): print(Foo.func) class Son(Foo): def func(self): print(Son.func) s Son() # Son.func class A: def get(self): self.say() def say(self): print(AAAAA) class B(A): def say(self): print(BBBBB) b B() b.get() #输出结果为BBBBB 59. 面向对象深度优先和广度优先是什么 Python的类可以继承多个类Python的类如果继承了多个类那么其寻找方法的方式有两种 当类是经典类时多继承情况下会按照深度优先方式查找 当类是新式类时多继承情况下会按照广度优先方式查找 简单点说就是经典类是纵向查找新式类是横向查找 经典类和新式类的区别就是在声明类的时候新式类需要加上object关键字。在python3中默认全是新式类 60. 面向对象中super的作用
# 用于子类继承基类的方法
class FooParent(object):def __init__(self):self.parent I\m the parent.print(Parent)print(1111)def bar(self, message):print(%s from Parent % message)class FooChild(FooParent):def __init__(self):# super(FooChild,self) 首先找到 FooChild 的父类就是类 FooParent然后把类FooChild的对象转换为类 FooParent 的对象super(FooChild, self).__init__()print(Child)# def bar(self, message):# # super(FooChild, self).bar(message)# print(Child bar fuction)# print(self.parent)if __name__ __main__:fooChild FooChild()fooChild.bar(HelloWorld)
61. 是否使用过functools中的函数其作用是什么
# 用于修复装饰器import functoolsdef deco(func):functools.wraps(func) # 加在最内层函数正上方def wrapper(*args, **kwargs):return func(*args, **kwargs)return wrapperdeco
def index():哈哈哈哈x 10print(from index)print(index.__name__)
print(index.__doc__)# 加functools.wraps
# index
# 哈哈哈哈# 不加functools.wraps
# wrapper
# None
62. 列举面向对象中带双下划线的特殊方法如__new__、__init__
__iter__用于迭代器之所以列表、字典、元组可以进行for循环是因为类型内部定义了 __iter__。
__doc__表示类的描述信息。
__new__生成实例
__init__生成实例的属性构造方法通过类创建对象时自动触发执行。
__call__实例对象加( )会执行def __call__:... 方法里边的内容。
__del__析构方法当对象在内存中被释放时自动触发执行。如当 del obj 或者应用程序运行完毕时执行该方法里边的内容。
__enter__和__exit__出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量with中代码块执行完毕时执行__exit__里边的内容。
__module__表示当前操作的对象在那个模块 obj.__module__
__class__ 表示当前操作的对象的类是什么 obj.__class____doc__类的描述信息该描述信息无法被继承
__str__改变对象的字符串显示 print函数 ---obj.__str__()如果一个类中定义了__str__方法那么在打印对象时默认输出该方法的返回值。
__repr__改变对象的字符串显示 交互式解释器 ---obj.__repr__()
__format__自定制格式化字符串__slots__:一个类变量 用来限制实例可以添加的属性的数量和类型
__dict__类或对象中的所有成员。
__setitem__,__getitem,__delitem__:用于索引操作如字典。以上分别表示获取、设置、删除数据。
class Foo:def __init__(self,name):self.namenamedef __getitem__(self, item):print(self.__dict__[item])def __setitem__(self, key, value):self.__dict__[key]valuedef __delitem__(self, key):print(del obj[key]时,我执行)self.__dict__.pop(key)def __delattr__(self, item):print(del obj.key时,我执行)self.__dict__.pop(item)f1Foo(sb)
f1[age]18
f1[age1]19
del f1.age1
del f1[age]
f1[name]alex
print(f1.__dict__)
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发
63. 如何判断是函数还是方法
# 看他的调用者是谁如果是类就需要传入一个参数self的值这时他就是一个函数
# 如果调用者是对象就不需要给self传入参数值这时他就是一个方法class Foo(object):def __init__(self):self.name lcgdef func(self):print(self.name)obj Foo()
print(obj.func) # bound method Foo.func of __main__.Foo object at 0x000001ABC0F15F98
print(Foo.func) # function Foo.func at 0x000001ABC1F45BF8from types import FunctionType, MethodType
print(isinstance(obj.func, FunctionType)) # False
print(isinstance(obj.func, MethodType)) # Trueprint(isinstance(Foo.func, FunctionType)) # True
print(isinstance(Foo.func, MethodType)) # False
注意方法无需传入self参数函数必须手动传入self参数64. 静态方法和类方法区别
尽管 classmethod 和 staticmethod 非常相似但在用法上依然有一些明显的区别。classmethod 必须有一个指向类对象的引用作为第一个参数而 staticmethod 可以没有任何参数。举个栗子:
class Num:# 普通方法能用Num调用而不能用实例化对象调用 def one(): print (1)# 实例方法能用实例化对象调用而不能用Num调用def two(self):print (2)# 静态方法能用Num和实例化对象调用staticmethod def three(): print (3)# 类方法第一个参数cls长什么样不重要都是指Num类本身调用时将Num类作为对象隐式地传入方法 classmethod def go(cls): cls.three() Num.one() # 1
#Num.two() # TypeError: two() missing 1 required positional argument: self
Num.three() # 3
Num.go() # 3iNum()
#i.one() # TypeError: one() takes 0 positional arguments but 1 was given
i.two() # 2
i.three() # 3
i.go() # 3
65. 列举面向对象中的特殊成员以及应用场景 见上题。 66. 1、2、3、4、5 能组成多少个互不相同且无重复的三位数
import itertools
print(len(list(itertools.permutations(12345,3))))
# 60个 题意理解组成后的数值不相同且组合的三个位数之间数字不重复。 使用python内置的排列组合函数不放回抽样排列 product 笛卡尔积 有放回抽样排列 permutations 排列 不放回抽样排列 combinations 组合,没有重复 不放回抽样组合 combinations_with_replacement 组合,有重复 有放回抽样组合 67. 什么是反射以及应⽤用场景 反射的核心本质就是以字符串的形式去导入个模块利用字符串的形式去执行函数。 Django中的 CBV就是基于反射实现的。 68. metaclass作用以及应用场景 metaclass用来指定类是由谁创建的。 类的metaclass 默认是type。我们也可以指定类的metaclass值。在python3中 class MyType(type): def __call__(self, *args, **kwargs): return MyType class Foo(object, metaclassMyType): def __init__(self): return init def __new__(cls, *args, **kwargs): return cls.__init__(cls) def __call__(self, *args, **kwargs): return call obj Foo() print(obj) # MyType 69. 用尽量多的方法实现单例模式。 一个类可以有多个位置参数和多个命名参数而在实例化开始之后在调用 init()方法之前Python首先调用new()方法 def __new__(cls, *args, **kwargs): 第一个参数cls是当前正在实例化的类。 如果要得到当前类的实例应当在当前类中的new()方法语句中调用当前类的父类 的new()方法。 例如如果当前类是直接继承自object那当前类的new()方法返回的对象应该为 def __new__(cls, *args, **kwargs): ... return object.__new__(cls) 事实上如果新式类中没有重写new()方法即在定义新式类时没有重新定义new()时 Python默认是调用该类的直接父类的new()方法来构造该类的实例如果该类的父类也没有重写 new() 那么将一直按此规矩追溯至object的new()方法因为object是所有新式类的基类。 而如果新式类中重写了new()方法那么你可以自由选择任意一个的其他的新式类必定要是 新式类只有新式类必定都有new() 因为所有新式类都是object的后代而经典类则没有new() 方法的new()方法来制造实例 包括这个新式类的所有前代类和后代类只要它们不会造成递归死 循环 # 单例模式
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。
通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问从而方便对实例个数的控制并节约系统资源。
如果希望在系统中某个类的对象只能存在一个单例模式是最好的解决方案。
# 1、使用__new__方法class Singleton(object):def __new__(cls, *args, **kw):if not hasattr(cls, _instance):orig super(Singleton, cls) # 其实就是objectcls._instance orig.__new__(cls, *args, **kw)return cls._instanceclass 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._statereturn obclass MyClass2(Borg):a 1
# 3、装饰器版本def singleton(cls, *args, **kw):instances {}def getinstance():if cls not in instances:instances[cls] cls(*args, **kw)return instances[cls]return getinstancesingletonclass MyClass:...
# 4、import方法
# 作为python的模块是天然的单例模式# mysingleton.pyclass My_Singleton(object):def foo(self):passmy_singleton My_Singleton()# to usefrom mysingleton import my_singletonmy_singleton.foo()
70. 装饰器的写法以及应用场景。 含义装饰器本质就是函数为其他函数添加附加功能 原则不修改被修饰函数的代码不修改被修饰函数的调用方式 应用场景无参装饰器在用户登录 认证中常见有参装饰器在flask的路由系统中见到过 import functools def wrapper(func): functools.wraps(func) def inner(*args, **kwargs): print(我是装饰器) return func return inner wrapper def index(): print(我是被装饰函数) return None index() # 应用场景 - 高阶函数 - 闭包 - 装饰器 - functools.wraps(func) 71. 异常处理写法以及如何主动抛出异常应用场景
# 触发异常
def temp_convert(var):try:return int(var)except ValueError as Argument:print (参数没有包含数字%s%Argument)# 调用函数
temp_convert(xyz)
# 以10为基数的int()的无效文字:“xyz”----------------------------------------------------------------------------
# raise语法
# raise [Exception [, args [, traceback]]]
# 语句中 Exception 是异常的类型args 是自已提供的异常参数。class Networkerror(RuntimeError):def __init__(self, arg):self.args arg
try:raise Networkerror(Bad hostname)
except Networkerror as e:print(e.args)
72、什么是面向对象的mro mro就是方法解析顺序 73. isinstance作用以及应用场景 isinstance(对象类) 判断这个对象是不是这个类或者这个类的子类的实例化 # # 判断a 属不属于A这个类可以判断到祖宗类 class A: pass class B(A): pass a A() b B() print(isinstance(b,A)) # True 判断到祖宗类 # 任何与object都是True,内部都继承object class A:pass a A() # 实例化 print(isinstance(a,object)) # True 应用场景rest framework 认证的流程 scrapy-redis 74. 写代码并实现 Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would have exactly one solution, and you may not use the same element twice. Example: Given nums [2, 7, 11, 15], target 9, Because nums[0] nums[1] 2 7 9, return [0, 1] class Solution:def twoSum(self, nums, target): :type nums: List[int] :type target: int :rtype: List[int] # 用len()方法取得nums列表长度 n len(nums)# x从0到n取值不包括n for x in range(n):a target - nums[x]# 用in关键字查询nums列表中是否有a if a in nums:# 用index函数取得a的值在nums列表中的索引 y nums.index(a)# 假如xy,那么就跳过,否则返回x,y if x y:continueelse:return x, ybreakelse:continue
75. json序列化时可以处理的数据类型有哪些如何定制支持datetime类型
# 可序列化数据类型
字典、列表、数字、字符串、元组如果是元组自动转成列表再转回去的话也是列表
# 自定义时间序列化转换器
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):def default(self, obj):if isinstance(obj, datetime):return obj.strftime(%Y-%m-%d %H:%M:%S)else:return super(ComplexEncoder,self).default(obj)
d { name:alex,data:datetime.now()}
print(json.dumps(d,clsComplexEncoder))
# {name: alex, data: 2018-05-18 19:52:05}76. json序列化时默认遇到中文会转换成unicode如果想要保留中文怎么办
import json
ajson.dumps({xxx:你好},ensure_asciiFalse)
print(a) #{xxx: 你好}
77. 什么是断言应用场景
assert 的作用断言
条件成立布尔值为True则继续往下否则抛出异常一般用于满足某个条件之后才能执行否则抛出异常。写API的时候继承GenericAPIViewclass GenericAPIView(views.APIView):Base class for all other generic views.# Youll need to either set these attributes,# or override get_queryset()/get_serializer_class().# If you are overriding a view method, it is important that you call# get_queryset() instead of accessing the queryset property directly,# as queryset will get evaluated only once, and those results are cached# for all subsequent requests.queryset Noneserializer_class None# If you want to use object lookups other than pk, set lookup_field.# For more complex lookup requirements override get_object().lookup_field pklookup_url_kwarg None# The filter backend classes to use for queryset filteringfilter_backends api_settings.DEFAULT_FILTER_BACKENDS# The style to use for queryset pagination.pagination_class api_settings.DEFAULT_PAGINATION_CLASSdef get_queryset(self):assert self.queryset is not None, (%s should either include a queryset attribute, or override the get_queryset() method.% self.__class__.__name__)queryset self.querysetif isinstance(queryset, QuerySet):# Ensure queryset is re-evaluated on each request.queryset queryset.all()return queryset
78. 有用过with statement吗它的好处是什么 with语句适用于对资源进行访问的场合确保不管使用过程中是否发生异常都会执行必要的“清理”操作 释放资源比如文件使用后自动关闭、线程中锁的自动获取和释放等。 79. 使用代码实现查看列举目录下的所有文件。
import os
path os.listdir(.) #查看列举目录下的所有文件。
# path os.listdir(os.getcwd())
print(path)
80. 简述 yield和yield from关键字 1、yield使用 1函数中使用yield可以使函数变成生成器。一个函数如果是生成一个数组就必须把数据存储在内存中如果使用生成器则在调用的时候才生成数据可以节省内存。 2生成器方法调用时不会立即执行。需要调用next()或者使用for循环来执行。 2、yield from的使用 1为了让生成器带yield函数能简易的在其他函数中直接调用就产生了yield from。 python是传值还是传引用 python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象比如字典或者列表的引用就能修改对象的原始值相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象比如数字、字符或者元组的引用就不能直接修改原始对象相当于通过“传值来传递对象
