chaoz的杂货铺

生命有息、学无止境、折腾不止

0%

python-复习笔记

1、一行代码实现 1–100 之和

sum(range(0, 101))

2、如何在一个函数内部修改全局变量

1
2
3
4
5
6
num = 5
def func():
global num
num = 4
func()
print(num) # 4

3、列出 5 个常用 Python 标准库?

1
2
3
4
5
os:提供了不少与操作系统相关联的函数
sys:通常用于命令行参数
re:正则匹配
math:数学运算
datetime:处理日期时间

4、你常用哪些 Python 标准库

5、如何合并两个字典?

1
2
3
4
name = {'name': 'Gage'}
age = {'age': 25}
name.update(age)
print(name) # {'name': 'Gage', 'age': 25}

6、谈下 Python 的 GIL?

7、Python 实现列表去重的方法?

1
2
num_list = [1, 3, 1, 5, 3, 6, 1]
print([num for num in set(num_list)]) # [1, 3, 5, 6]

8、fun(args,kwargs)中的args, kwargs 什么意思?

9、Python2 和 Python3 的 range(100)的区别?

Python2 返回列表,Python3 返回迭代器,节约内存。

10、生成一个 16 位的随机字符串?

1
2
3
4
import random
import string
print(''.join((random.choice(string.printable)) for i in range(16)))
有问题,需要优化

11、一句话解释什么样的语言能够用装饰器?

函数可以作为参数传递

12、Python 内建数据类型有哪些?

1
2
3
4
5
6
整型--int
布尔型--bool
字符串--str
列表--list
元组--tuple
字典--dict

13、列表[1,2,3,4,5],请使用 map() 函数输出[1,4,9,16,25],并使用列表推导式提取出大于 10 的数,最终输出 [16,25]?

1
2
num_list = [1, 2, 3, 4, 5]
print([x for x in list(map(lambda x: x * x, num_list)) if x > 10])

14、什么是匿名函数 lambda

1
2
3
4
5
6
7
python 使用 lambda 来创建匿名函数。

lambda只是一个表达式,函数体比def简单很多。
lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法

lambda函数的语法只包含一个语句,如下:

lambda [arg1 [,arg2,.....argn]]:expression

1
2
3
4
5
6
7
lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的匿名函数

好处:
1、lambda 函数比较轻便,即用即删除,很适合需要完成一项功能,但是此功能只在此一处使用,
连名字都很随意的情况下;
2、匿名函数,一般用来给 filter, map 这样的函数式编程服务;
3、作为回调函数,传递给某些应用,比如消息处理

15、map 函数的用法

map() 会根据提供的函数对指定序列做映射。
map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。

1
2
3
4
5
6
a = map(ord,'abcd')
a
<map object at 0x03994E50>
list(a)
[97, 98, 99, 100]
next:返回可迭代对象中的下一个元素值

16、list 函数作用

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。

1
2
3
4
5
6
7
8
9
10
11
12
访问
更新:append
删除:del
脚本操作符:长度、组合、重复、元素是否存在于列表中、截取(第n个元素、倒数第n个元素、从第n个开始)
函数:cmp(list1, list2)、len(list)、max(list)、min(list)、list(seq)

list.append(obj)、list.count(obj)、list.extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj)、list.insert(index, obj):将对象插入列表
list.pop([index=-1]):移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj):移除列表中某个值的第一个匹配项
list.reverse():反向列表中元素
list.sort(cmp=None, key=None, reverse=False):对原列表进行排序

17、python 中生成随机整数、随机小数、0–1 之间小数方法?

1
2
3
4
import random
print(random.randint(1, 10)) # 随机整数
print(random.random()) # 0-1随机小数
print(random.uniform(2, 6)) # 指定范围[2-6]随机小数

18、避免转义给字符串加哪个字母表示原始字符串?

1
2
3
4
5
6
7
8
9
10
11
b'input\n' # bytes字节符,打印以b开头。
输出:
b'input\n'
--------------------------------------
r'input\n' # 非转义原生字符,经处理'\n'变成了'\\'和'n'。也就是\n表示的是两个字符,而不是换行。
输出:
'input\\n'
--------------------------------------
u'input\n' # unicode编码字符,python3默认字符串编码方式。
输出:
'input\n'

19、<div class="nam">Python</div>,用正则匹配出标签里面的内容(“Python”),其中 class 的类名是不确定的。

1
2
3
import re
s = '<div class="nam">Python</div>'
print(re.findall(r'<div class=".*">(.*?)</div>', s)) #['Python']

20、Python 中断言方法举例?

Python assert(断言)用于判断一个表达式,在表达式条件为 false 的时候触发异常。

语法格式如下:

1
2
3
4
5
assert 后面也可以紧跟参数也可不加:
assert expression [, arguments]
等价于:
if not expression:
raise AssertionError(arguments)

21、dict

字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中 。

在 Python 中,字典是通过哈希表实现的。也就是说,字典是一个数组,而数组的索引是键经过哈希函数处理后得到的。哈希函数的目的是使键均匀地分布在数组中。由于不同的键可能具有相同的哈希值,即可能出现冲突,高级的哈希函数能够使冲突数目最小化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
访问
修改
删除:del、clear

内置函数:cmp(dict1, dict2)、len(dict)、str(dict):输出字典可打印的字符串表示。
type(variable):返回输入的变量类型,如果变量是字典就返回字典类型。

dict.clear()
dict.has_key(key)
dict.copy():返回一个字典的浅复制
dict.fromkeys(seq[, val]):创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
dict.get(key, default=None):返回指定键的值,如果值不在字典中返回default值
dict.setdefault(key, default=None):和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
dict.items():**以列表**返回可遍历的(键, 值) 元组数组
dict.keys():**以列表**返回一个字典所有的键
dict.update(dict2):把字典dict2的键/值对更新到dict里
dict.values():**以列表**返回字典中的所有值
pop(key[,default]):删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
popitem():返回并删除字典中的最后一对键和值。

22、什么是浅拷贝、深拷贝

浅拷贝:也就是拷贝A对象里面的数据,但是不拷贝A对象里面的子对象
深拷贝:会克隆出一个对象,数据相同,但是引用地址不同(就是拷贝A对象里面的数据,而且拷贝它里面的子对象)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# copy
l1 = [1, 2, [3, 4]]
l2 = copy.copy(l1)
l1.append(5)
l1[2].append(5) # 子对象 改变
print(l1)
print(l2)
--------------
[1, 2, [3, 4, 5], 5]
[1, 2, [3, 4, 5]]
# deepcopy
l1 = [1, 2, [3, 4]]
l2 = copy.deepcopy(l1)
l1.append(5)
l1[2].append(5)
print(l1)
print(l2)
--------------
[1, 2, [3, 4, 5], 5]
[1, 2, [3, 4]]

23、列出 Python 中可变数据类型和不可变数据类型,为什么?

1
2
3
1、可变数据类型:list、dict、set
2、不可变数据类型:int/float、str、tuple
3、原理:可变数据类型即公用一个内存空间地址,不可变数据类型即每产生一个对象就会产生一个内存地址

24、s = “ajldjlajfdljfddd”,去重并从小到大排序输出”adfjl”?

1
2
s1 = "ajldjlajfdljfddd"
print(''.join(sorted(set(s1)))) # adfjl

25、set

set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
class set([iterable])

26、join

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
str.join(sequence) 注意: str 是来链接符号;sequence 是列表

27、用 lambda 函数实现两个数相乘?

1
2
mul = lambda x, y: x*y
print(mul(2, 4)) # 8

28、sort

sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数。

1
2
3
4
5
list.sort(cmp=None, key=None, reverse=False)
参数
cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则,reverse = True 降序, reverse = False 升序(默认)。

29、字典根据键从小到大排序?

注意:key=lambda x: x[0]) 删了的话结果也对。

1
2
3
info = {'name': 'Gage', 'age': 25, 'sex': 'man'}
print(sorted(info.items(), key=lambda x: x[0]))
# [('age', 25), ('name', 'Gage'), ('sex', 'man')]

30、Python 获取当前日期?

1
2
3
4
import time
import datetime
print(datetime.datetime.now())
print(time.strftime('%Y-%m-%d %H:%M:%S'))

参考链接

31、Python format 格式化函数

它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数,位置可以不按顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>>"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
print("网站名:{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))

通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名:{name}, 地址 {url}".format(**site))

通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的

参考链接

32、偏函数是个啥

偏函数是从Python2.5引入的一个概念,通过functools模块被用户调用。

偏函数是将所要承载的函数作为partial()函数的第一个参数,原函数的各个参数依次作为partial()函数后续的参数,除非使用关键字参数。
参考资料

33、例举五条 PEP8 规范

1
2
3
4
5
不要在行尾加分号, 也不要用分号将两条命令放在同一行
不要使用反斜杠连接行
不要在返回语句或条件语句中使用括号
顶级定义之间空2行, 方法定义之间空1行,顶级定义之间空两行
如果一个类不继承自其它类, 就显式的从object继承

34、装饰器和继承有什么区别

继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

Python 面向对象
Python 子类继承父类构造函数说明

Python 函数装饰器:

装饰器(Decorators)是 Python 的一个重要部分。简单地说:他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短,也更Pythonic(Python范儿)。

Python 函数装饰器

参考资料:Python——装饰器和继承

35、Python 语言的运行机制

36、实现 Fibonacci 数列

1
2
3
4
5
6
def fab(n):
a, b = 0, 1
while n:
yield b
a, b = b, a+b
n -= 1

### 37、Python 三目运算

1
2
# 若果 a>b 成立  就输出  a-b  否则 a+b
h = a-b if a>b else a+b

38、 递归

1
2
3
4
5
def digui(n):
if n == 1:
return 1
else:
return (n * digui(n-1)

38、统计字符串每个单词出现的次数

1
2
3
from collections import Counter
s3 = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
print(Counter(s3))

39、filter() 函数

filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。

filter(function, iterable)

function – 判断函数。
iterable – 可迭代对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
过滤出列表中的所有奇数:
#!/usr/bin/python
# -*- coding: UTF-8 -*-

def is_odd(n):
return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

过滤出1~100中平方根是整数的数:
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0

newlist = filter(is_sqr, range(1, 101))
print(newlist)

40、用 python 删除文件和用 linux 命令删除文件方法

1
2
python:os.remove(文件名)
linux: rm 文件名

41、写一段自定义异常代码

1
2
3
4
5
6
7
8
9
#自定义异常用raise抛出异常
def fn():
try:
for i in range(5):
if i>2:
raise Exception("数字大于2了")
except Exception as ret:
print(ret)
fn() # 数字大于2了

42、[[1,2],[3,4],[5,6]]一行代码展开该列表,得出[1,2,3,4,5,6]

1
2
a=[[1,2],[3,4],[5,6]]
print([j for i in a for j in i])

43、举例说明异常模块中 try except else finally 的相关意义

1
2
try..except..else没有捕获到异常,执行else语句
try..except..finally不管是否捕获到异常,都执行finally语句

44、Zip

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

1
2
3
4
5
6
7
8
9
10
11
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 相反,*zipped 可理解为解压,返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]

list1 = [1, 2, 3, 5]
list2 = [4, 5, 6]
zipped = zip(list1, list2)
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]

45、提高 python 运行效率的方法

1
2
3
4
5
1、使用生成器,因为可以节约大量内存
2、循环代码优化,避免过多重复代码的执行
3、核心模块用Cython PyPy等,提高效率
4、多进程、多线程、协程
5、多个if elif条件判断,可以把最有可能先发生的条件放到前面写,这样可以减少程序判断的次数,提高效率

56、遇到 bug 如何处理

1
2
3
4
1、细节上的错误,通过print()打印,能执行到print()说明一般上面的代码没有问题,分段检测程序是否有问题,如果是js的话可以alert或console.log
2、如果涉及一些第三方框架,会去查官方文档或者一些技术博客。
3、对于bug的管理与归类总结,一般测试将测试出的bug用teambin等bug管理工具进行记录,然后我们会一条一条进行修改,修改的过程也是理解业务逻辑和提高自己编程逻辑缜密性的方法,我也都会收藏做一些笔记记录。
4、导包问题、城市定位多音字造成的显示错误问题

57、简述多线程、多进程

1
2
3
4
进程是资源(CPU、内存等)分配的基本单位,它是程序执行时的一个实例。
线程是程序执行时的最小单位,它是进程的一个执行流。
进程有自己的独立地址空间,每启动一个进程,系统就会为它分配地址空间,建立数据表来维护代码段、堆栈段和数据段,这种操作非常昂贵
线程是共享进程中的数据的,使用相同的地址空间,因此CPU切换一个线程的花费远比进程要小很多,同时创建一个线程的开销也比进程要小很多

48、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError 分别代表什么异常

1
2
3
4
5
6
7
8
IOError:输入输出异常
AttributeError:试图访问一个对象没有的属性
ImportError:无法引入模块或包,基本是路径问题
IndentationError:语法错误,代码没有正确的对齐
IndexError:下标索引超出序列边界
KeyError:试图访问你字典里不存在的键
SyntaxError:Python代码逻辑语法出错,不能执行
NameError:使用一个还未赋予对象的变量

49、列出几种魔法方法并简要介绍用途

1
2
3
4
__init__:对象初始化方法
__new__:创建对象时候执行的方法,单列模式会用到
__str__:当使用print输出对象的时候,只要自己定义了__str__(self)方法,那么就会打印从在这个方法中return的数据
__del__:删除对象执行的方法

50、上下文管理器 with…as 的实现

1
2
3
4
5
6
7
8
9
10
11
12
class Close():
def __init__(self, obj):
self.obj = obj

def __enter__(self):
return self.obj # 返回作为as目标

def __exit__(self, exc_type, exc_val, exc_tb):
try:
self.obj.close()
except AttributeError:
print(exc_type)

51、细说上下文管理器

ContextManager ,上下文是 context 直译的叫法,在程序中用来表示代码执行过程中所处的前后环境。上下文管理器中有 enterexit 两个方法,以with为例子,enter 方法会在执行 with 后面的语句时执行,一般用来处理操作前的内容。比如一些创建对象,初始化等;exit 方法会在 with 内的代码执行完毕后执行,一般用来处理一些善后收尾工作,比如文件的关闭,数据库的关闭等。

with及上下文管理器的原理和应用

52、迭代器与生成器

迭代是Python最强大的功能之一,是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法:iter() 和 next()。
字符串,列表或元组对象都可用于创建迭代器:

在 Python 中,使用了 yield 的函数被称为生成器(generator)。
跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数,返回的是一个迭代器对象。

Python3 迭代器与生成器

53、请将[i for i in range(3)]改成生成器

1
2
3
4
5
6
7
8
9
10
11
class iter():
def __init__(self, data):
self.data = data
self.loop = -1
def __iter__(self):
return self
def __next__(self):
if self.loop >= self.data:
raise StopIteration
self.loop += 1
return self.loop

54、请说明 sort 和 sorted 对列表排序的区别

1
2
3
1.sort()与sorted()的不同在于,sort是在原位重新排列列表,而sorted()是产生一个新的列表。sorted(L)返回一个排序后的L,不改变原始的L;L.sort()是对原始的L进行操作,调用后原始的L会改变,没有返回值;所以a = a.sort()是错的啦!a = sorted(a)才对。
2.sorted()适用于任何可迭代容器,list.sort()仅支持list(本身就是list的一个方法)
3.基于以上两点,sorted使用频率比list.sort()更高些,所以Python中更高级的排

55、对 foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4] 进行排序

使用 lambda 函数从小到大排序

1
2
3
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
res=sorted(foo,key=lambda x:x)
print(res)

正数从小到大,负数从大到小

1
2
3
foo = [-5,8,0,4,9,-4,-20,-2,8,2,-4]
res=sorted(foo,key=lambda x:(x<0,abs(x)))
print(res)

56、Python 传参数是传值还是传址?

Python 中函数参数是引用传递(注意不是值传递)。对于不可变类型(数值型、字符串、元组),因变量不能修改,所以运算不会影响到变量自身;而对于可变类型(列表字典)来说,函数体运算可能会更改传入的参数变量。

57、Python 垃圾回收机制?

1
2
3
4
5
6
7
8
9
10
1.引用计数
import sys
# 请在Python解释器下运行 为 2 创建一次 调用一次
str1 = 'hello world'
print(sys.getrefcount(str1))
2.分代技术
Python默认定义了三代对象集合,索引数越大,对象存活时间越长
Python中使用了某些启发式算法(heuristics)来加速垃圾回收。例如,越晚创建的对象更有可能被回收。对象被创建之后,垃圾回收器会分配它们所属的代(generation)。每个对象都会被分配一个代,而被分配更年轻代的对象是优先被处理的。
3.引用循环
垃圾回收器会定时寻找这个循环,并将其回收。举个例子,假设有两个对象o1和o2,而且符合o1.x == o2和o2.x == o1这两个条件。如果o1和o2没有其他代码引

58、字典和 json 字符串相互转化方法

1
2
3
4
5
6
import json
dic = {"name":"zs"}
res = json.dumps(dic)
print(res,type(res))
ret = json.loads(res)
print(ret,type(ret))

59、Python 中读取 Excel 文件的方法?

1
2
3
import pandas
read_excel = pandas.read_excel("test.xlsx")
print(read_excel)

60、输入日期, 判断这一天是这一年的第几天?

1
2
3
4
5
6
7
8
import datetime
def dayofyear():
year = input("请输入年份: ")
month = input("请输入月份: ")
day = input("请输入天: ")
date1 = datetime.date(year=int(year),month=int(month),day=int(day))
date2 = datetime.date(year=int(year),month=1,day=1)
return (date1-date2).days+1

61、yield 用法

yield 就是保存当前程序执行状态。你用 for 循环的时候,每次取一个元素的时候就会计算一次。用 yield 的函数叫 generator,和 iterator 一样,它的好处是不用一次计算所有元素,而是用一次算一次,可以节省很多空间,generator 每次计算需要上一次计算结果,所以用 yield,否则一 return,上次计算结果就没了。

62、is 和 == 的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# is 比较的是内存地址   == 比较内容和数据类型

a = [1, 2, 3]
b = a
print(a is b)
print(a == b)

c = copy.deepcopy(a)
print(a is c)
print(a == c)
-------------
True
True
False
True

63、python 的 bug 和进行静态的代码分析工具

PyChecker 是一个 python 代码的静态分析工具,它可以帮助查找 python 代码的 bug,会对代码的复杂度和格式提出警告 Pylint 是另外一个工具可以进行 codingstandard 检查。

64、Python 如何 copy 一个文件?

shutil 模块有一个 copyfile 函数可以实现文件拷贝

65、Python 中单下划线和双下划线使用

1
2
3
4
5
__foo__:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突,就是例如__init__(),__del__(),__call__()这些特殊方法

_foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.不能用from module import * 导入,其他方面和公有一样访问;

__foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名,它无法直接像公有成员一样随便访问,通过对象名._类名__xxx这样的方式可以访问.

66、代码描述静态方法 (staticmethod),类方法(classmethod) 和实例方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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()

67、新式类和旧式类的区别?

1
2
3
4
a. 在python里凡是继承了object的类,都是新式类
b. Python3里只有新式类
c. Python2里面继承object的是新式类,没有写父类的是经典类
d. 经典类目前在Python里基本没有应用

68、请写出一个在函数执行后输出日志的装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def do_log(func):
@wraps(func)
def wrapper(*args, **kw):
if func.__name__ == "debug":
msg = "debug {}".format(args[0])
elif func.__name__ == "info":
msg = "info {}".format(args[0])
else:
msg = "unknown {}".format(args[0])
return func(msg, **kw)
return wrapper

@do_log
def debug(msg):
print(msg)

@do_log
def info(msg):
print(msg)

if __name__ == "__main__":
debug("123")
info("abc")

69、请解释一下协程的优点

1
2
3
子程序切换不是线程切换,而是由程序自身控制
没有线程切换的开销,和多线程比,线程数量越多,协程的性能优势就越明显
不需要多线程的锁机制,因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不加锁

70、闭包必须满足那几点

1
2
3
1.必须有一个内嵌函数
2.内嵌函数必须引用外部函数中的变量
3.外部函数的返回值必须是内嵌函数

71、什么是迭代、什么是切片、什么是列表生成式、什么是生成器、迭代器

切片丫的就是截取,取地什么鬼名字。迭代,循环的升级版本;列表生成器,emmm 懵了,配合迭代循环的玩意…。

生成器:通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。
就是 yield

迭代器:迭代英文名 Iterator。迭代器是用来帮助我们记录每次迭代访问到的位置,当我们对迭代器使用next()函数的时候,迭代器会向我们返回它所记录位置的下一个位置的数据。实际上,在使用next()函数的时候,调用的就是迭代器对象的next方法(Python3中是对象的next方法,Python2中是对象的next()方法)。所以,我们要想构造一个迭代器,就要实现它的next方法。但这还不够,python要求迭代器本身也是可迭代的,所以我们还要为迭代器实现iter方法,而iter方法要返回一个迭代器,迭代器自身正是一个迭代器,所以迭代器的iter方法返回自身即可。

一个实现了iter方法和next方法的对象,就是迭代器。

参考资料
廖雪峰python

13、简述面向对象中new和init区别?

14、简述 with 方法打开处理文件帮我我们做了什么?

反转一个整数

对 s=”hello”进行反转

打乱一个排好序的 list 对象 alist?

文件递归

字符串 “123” 转换成 123,不使用内置 API,例如 int()

阅读一下代码他们的输出结果是什么?

根据键对字典排序,不可使用zip?

代码描述列表推导式、字典推导式、生成器?

a = “ hehheh “,去除收尾空格?

s=”info:xiaoZhang 33 shandong”,用正则切分字符串输出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’]

用两种方法去空格?

w、w+、r、r+、rb、rb+ 文件打开模式区别

Python 正则中 search 和 match 的区别

请用正则表达式输出汉字

Python2 和 Python3 区别?列举 5 个

字符串转化大小写?

获取请求头的参数?

单例模式

正则表达式匹配 URL

正则匹配以 163.com 结尾的邮箱?

正则匹配优先级

正则 re.complie 作用

logging 模块的使用?

正则表达式匹配中,(.)和(.?)匹配区别?

a=”张明 98分”,用 re.sub,将 98 替换为 100

正则匹配,匹配日期 2018-03-20

python arg.py 1 2 命令行启动程序并传参,print(sys.argv) 会输出什么数据?

正则匹配不是以4和7结尾的手机号?

喜欢这篇文章?打赏一下作者吧!

欢迎关注我的其它发布渠道