-
通过代码实现如下转换：
二进制转换成十进制：v = “0b1111011”
十进制转换成二进制：v = 18
八进制转换成十进制：v = “011”
十进制转换成八进制：v = 30
十六进制转换成十进制：v = “0x12”
十进制转换成十六进制：v = 87
print(int("0b1111011", 2))
print(bin(v))
print(int('011', 8))
print(hex(87))
print(int("0x12", 16))
print(hex(87))
-
请编写一个函数实现将IP地址转换成一个整数。
如 10.3.9.12 转换规则为：
10 00001010
3 00000011
9 00001001
12 00001100
再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？
def v(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(v("127.0.0.1"))
-
python递归的最大层数？
image.png
得到的最大数字在3925-3929之间浮动，
这个是和计算机有关系的，不然也不会是一个浮动的数字了（数学逻辑讲求严谨）。
- 求结果：
v1 = 1 or 3
v2 = 1 and 3
v3 = 0 and 2 and 1
v4 = 0 and 2 or 1
v5 = 0 and 2 or 1 or 4
v6 = 0 or Flase and 1
print(1 or 3) #1
print(1 and 3) # 3
print(0 and 2 and 1) # 0
print(0 and 2 or 1) #1
print(0 and 2 or 1 or 4) # 1
print(0 or False and 1) # False
print(None or 0) #0
print(True or 0) #Ture
print(None and 0) # None
print(True and 0) # 0
- ascii、unicode、utf-8、gbk 区别？
ascii：
A：00000010 8位 一个字节
unicode：
A：00000000 00000001 00000010 00000100 32位 四个字节
中：00000000 00000001 00000010 00000100 32位 四个字节
utf-8：
A：00000110 8位 一个字节
中：00000010 00000110 16位 两个字节
gbk：
A：00000110 8位 一个字节
中：00000010 00000110 16位 两个字节
1，各个编码之间的二进制，是不能互相识别的，会产生乱码。
2，文件的存储，传输，不能是unicode （只能是utf-8 utf-16 gbk gbk2312 ascii等）
python3：
str 在内存中是Unicode编码。
bytes类型
对于英文：
str：表现形式：s = 'alex'
编码方式：010101010 unicode
bytes：表现形式：s = b'alex'
编码方式：000101010 utf-8 gbk。。。。
对于中文：
str：表现形式：s = '中国'
编码方式：010101010 unicode
bytes： 表现形式：s = b' x\e91\e91\e01\e21\e31\e32'
编码方式：000101010 utf-8 gbk。。。。
encode 编码，如何将 str ——> bytes
使用方法： str.encode('utf-8')
decode 解码，如何将 bytes——> str
使用方法： bytes.decode('utf-8')
- 字节码和机器码的区别？
机器码
机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。
通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。
字节码
字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。
- 三元运算规则以及应用场景？
三元运算符就是在赋值变量的时候，可以直接加判断，然后赋值
格式：[on_true] if [expression] else [on_false]
res = 值1 if 条件 else 值2
1.举例说明：
a =1
b = 2
c= a if a>1 else b #如果a大于1的话，c=a，否则c=b
- 列举 Python2和Python3的区别？
1：print语句
python2中print是一个语句，不论想输出什么，直接放到print关键字后面即可。python3里，print()是一个函数，像其他函数一样，print()需要你将要输出的东西作为参数传给它。
2：UNICODE字符串
python2中有两种字符串类型：Unicode字符串和非Unicode字符串。Python3中只有一种类型：Unicode字符串
Python2中使用 ASCII 码作为默认编码方式导致string有两种类型str和unicode，Python3只支持unicode的
3 全局函数UNICODE()
python２有两个全局函数可以把对象强制转换成字符串:unicode()把对象转换成unicode字符串，还有str()把对象转换为非Unicode字符串。Python3只有一种字符串类型，unicode字符串，所以str()函数即可完成所有的功能。
4：LONG长整型
python2有非浮点数准备的int和long类型。int类型最大值不能超过sys.maxint，而且这个最大值是平台相关的。可以通过在数字的末尾附上一个Ｌ来定义长整型，显然，它比int类型表示的数字范围更大。在python3里，只有一种整数类型int,大多数情况下，和python２中的长整型类似。
5：<>比较运算符
Python2支持<>作为!=的同义词， python3只支持!=, 不再支持<>
6：字典类方法HAS_KEY()
Python2中，字典对象has_key()方法测试字典是否包含指定的键。python3不再支持这个方法，需要使用in.
7：重命名或重新组织的模块
从python2到python3，标准库里的一些模块已经被重命名。还有一些相互关联的模块也被组合或则重新组织，使得这种关联更有逻辑性。
8：全局函数FILTER()
在python2里，filter()方法返回一个列表，这个列表是通过一个返回值为True或False的函数来检测序列里的每一项的道德。在python3中，filter()函数返回一个迭代器，不再是列表。
9：MAP()
跟filter()的改变一样，map()函数现在返回一个迭代器,python2中返回一个列表。
10：APPLY()
python2有一个叫做apply()的全局函数，它使用一个函数f和一个列表[a,b,c]作为参数，返回值是f(a,b,c).可以直接调用这个函数，在列表前添加一个星号作为参数传递给它来完成同样的事情。在python3里记，apply()函数不再存在；必须使用星号标。
11：EXEC
就像print语句在python3里变成了一个函数一样，exec语句也是这样的。exec()函数使用一个包含任意python代码的字符串作为参数，然后像执行语句或表达式一样执行它。exec()跟eval()是相似，但exec()更加强大并具有挑战性。eval()函数只能执行单独一条表达式，但是exec()能够执行多条语句，导入(import),函数声明－实际上整个python程序的字符串表示也可以
12：execfile
python２中的execfile语句可以像执行python代码那样使用字符串。不同的是exec使用字符串，而execfile使用文件。在python3，execfile语句被去掉了
13：TRYEXCEPT语句
python２到python3，捕获异常的语法有些变化
14：RAISE
python3里，抛出自定义异常的语法有细微的变化。
15：生成器THROW
在python2里，生成器有一个throw()方法。调用a_generator.throw()会在生成器被暂停的时候抛出异常，然后返回由生成器函数获取的下一个值。python3中，这一功能仍然可用，但语法有一点不同。
16：XRANGE()
python２里，有两种方法获得一定范围内的数字：range(),返回一个列表，还有xrange(),返回一个迭代器。python3 里，range()返回迭代器，xrange()不再存在。
17：RAW_INPUT()和INPUT()
python2有两个全局函数，用在命令行请求用户输入。第一个叫input()，它等待用户输入一个python表达式(然后返回结果)。第二个叫做raw_input(),用户输入什么他就返回什么。python3 通过input替代了他们。
18：函数属性FUNC_*
python2,函数的代码可用访问到函数本身的特殊属性。python3为了一致性，这些特殊属性被重命名了。
例子：
a_function.func_name a_function.__name__ __name__属性包含了函数的名字
19：I/O方法XREADLINES()
python2中，文件对象有一个xreadlines()方法，返回一个迭代器，一次读取文件的一行。这在for循环中尤其实用。python3中，xreadlines()方法不再可用。
20：lambda函数
在python2中，可以定义匿名函数lambda函数，通过指定作为参数的元组的元素个数，使这个函数实际上能够接收多个参数。python2的解释器把这个元组"解开“成命名参数，然后可以在lambda函数里引用它们。在python3中仍然可以传递一个元组为lambda函数的参数。但是python解释器不会把它当成解析成命名参数。需要通过位置索引来引用每个参数。
例子 ：
# b为函数名 a，v都是形参 a+v为返回值
b = lambda a,v: a+v
print(b(1,10))
21：STANDARDERROR异常
python2中，StandardError是除了StopIteration,GeneratorExit,KeyboardInterrupt, SystemExit之外所有其他内置异常的基类。python3中StandardError已经被取消了，使用Exception取代。
22：TYPES模块中的常量
types模块里各种各样的常量能够帮助你决定一个对象的类型。在python2里，它包含了代表所有基本数据类型的常量，如dict和int。在python3里，这些常量被取消了，只需使用基础类型的名字来替代。
例子：
python2 python3
types.UnicodeType str
23：全局函数ISINSTANCE()
isinstance()函数检查一个对象是否是一个特定类(class)或类型(type)的实例。在python2，可以传递一个由类型构成的元组给isinstance(),如果该对象是元组里的任意一种类型，函数返回True. 在python3,依然可以这样做。
24：ITERTOOLS模块
python2.3引入itertools模块，定义了zip(),map(),filter()的变体，这个变体返回的是迭代器，而非列表。在python3,这些函数返回的本身就是迭代器，所有这些变体函数就取消了。
24：对元组的列表解析
python2，如果需要编写一个遍历元组的列表解析，不需要在元组值周围加上括号。在python3里，这些括号是必需的。
python2 python3
[ i for i in 1, 2] [i for i in (1,2)]
25：元类
在python2里，可以通过在类的声明中定义metaclass参数，或者定义一个特殊的类级别(class-level)__metaclass__属性，来创建元类。python3中，__metaclass__属性被取消了。
- 用一行代码实现数值交换：
a = 1
b = 2
a,b=b,a
print(a,b)
- Python3和Python2中 int 和 long的区别？
python2有非浮点数准备的int和long类型。
int类型最大值不能超过sys.maxint，而且这个最大值是平台相关的。
可以通过在数字的末尾附上一个Ｌ来定义长整型，显然，它比int类型表示的数字范围更大。
在python3里，只有一种整数类型int,大多数情况下，和python２中的长整型类似。
- xrange和range的区别？
python２里，有两种方法获得一定范围内的数字：range(),返回一个列表，还有xrange(),返回一个迭代器。
python3 里，range()返回迭代器，xrange()不再存在。
- 文件操作时：xreadlines和readlines的区别？
python2中，文件对象有一个xreadlines()方法，返回一个迭代器，一次读取文件的一行。这在for循环中尤其实用。
python3中，xreadlines()方法不再可用。python3中readlines是返回整个文档的内容 并且是一个列表的形式 且每一行的对应着列表中的下标索引
- 列举布尔值为False的常见值？
1：数字0
2：None
3：空对象
4：空字符串
- 字符串、列表、元组、字典每个常用的5个方法？
字符串的方法：
<1>find
检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))
<2>index
跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
mystr.index(str, start=0, end=len(mystr))
<3>count
返回 str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))
<4>replace
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
mystr.replace(str1, str2, mystr.count(str1))
<5>split
以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
mystr.split(str=" ", 2)
<6>capitalize
把字符串的第一个字符大写
mystr.capitalize()
<7>title
把字符串的每个单词首字母大写
>>> a = "hello itcast"
>>> a.title()
'Hello Itcast'
<8>startswith
检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False
mystr.startswith(obj)
<9>endswith
检查字符串是否以obj结束，如果是返回True,否则返回 False.
mystr.endswith(obj)
<10>lower
转换 mystr 中所有大写字符为小写
mystr.lower()
<11>upper
转换 mystr 中的小写字母为大写
mystr.upper()
列表的方法：
chars = ['a', 'b', 'c', 'd']
for i, chr in enumerate(chars):
print(i, chr)
0 a
1 b
2 c
3 d
chars1=['c','d','k']
for i in zip(chars,chars1):
print(i)
('a', 'c')
('b', 'd')
('c', 'k')
<1>添加元素(“增”append, extend, insert)
通过append可以向列表添加元素
#定义列表A，有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
for tempName in A:
print(tempName)
temp = input('请输入要添加的学生姓名:')
A.append(temp)
for tempName in A:
print(tempName)
通过extend可以将另一个集合中的元素逐一添加到列表中
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]
insert(index, object) 在指定位置index前插入元素object
>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]
<2>修改元素(“改”)
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
#定义列表A，有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
for tempName in A:
print(tempName)
#修改元素
A[1] = 'xiaoLu'
for tempName in A:
print(tempName)
<3>查找元素(“查”in, not in, index, count)
所谓的查找，就是看看指定的元素是否存在。python中查找的常用方法为：
in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false
#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in nameList:
print('在字典中找到了相同的名字')
else:
print('没有找到')
index和count与字符串中的用法相同
index是索引到下标是给机器看的从0开始 count是给人看的计数 从1开始的 a.index（'a',1,3）后面接的两个1,3参数是从1到3不包括3 （左闭右开，所谓包头不包尾）
>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
<4>删除元素(“删”del, pop, remove)
类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。列表元素的常用删除方法有：
del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除
demo:(del) ：对原列表进行操作 没有返回值 会报错 del movieName[2] (根据下表进行删除)
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
for tempName in movieName:
print(tempName)
del movieName[2]
for tempName in movieName:
print(tempName)
demo:(pop)
a = ['a', 'b', 'c', 'd']
print(a.pop()) 返回的是删除的值
print(a) ['a', 'b', 'c'] 删除最后一个元素
demo:(remove) a.remove('a') 根据选中的元素删除
a = ['a', 'b', 'c', 'd']
print(a.remove('a')) #返回值为None
print(a) #['b', 'c', 'd']
<5>排序(sort, reverse)
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。reverse方法是将list逆置。
list1 = [1, 3, 5, 8, 1, 8]
a=sorted(list1, reverse=False) #为False是升序，为Ture是降序（默认升序）接受到的是返回值和sort不同
print(list1) # 顺序没改变
print(a) # 顺序为升序
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]
元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
说明： python中不允许修改元组的数据，包括不能删除其中的元素。
<3>元组的内置函数count, index
index和count与字符串和列表中的用法相同
>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
字典
<1>软件开发中的字典
变量info为字典类型：
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
1
2
说明：
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、’id’、’sex’）
字典的每个元素由2部分组成，键:值。例如 ‘name’:’班长’ ,’name’为键，’班长’为值
注意：根据键访问若不存在则会报错
在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None >>> type(age) <type 'NoneType'
> >>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18 >>> age 18
字典的常见操作1（方法）
<1>修改元素 ：
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
（修改值得话直接键赋值）
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
newId = input('请输入新的学号')
info['id'] = int(newId)
print('修改之后的id为%d:'%info['id'])
<2>添加元素
a = {'name': 'xm', 'age': 10}
a['sex'] = '女' {'name': 'xm', 'sex': '女', 'age': 10}
a['name'] = 'xjw' {'name': 'xjw', 'sex': '女', 'age': 10}
总结：如果键存在的话就直接修改了， 不存在的话就直接增加了
<3>删除元素
对字典进行删除操作，有一下几种：
del
clear()
1：demo:del删除指定的元素
a = {'name': 'xm', 'age': 10}
del a['name']
print(a) #{'age': 10}
de1 a #删除了怎么字典此时字典a已经找不到了
2：demo:clear清空整个字典
a = {'name': 'xm', 'age': 10}
a.clear()
print(a) #{} 字典还存在只是为空字典了
字典的常见操作2（方法）
<1>len() 测量字典中，键值对的个数
a = {'name': 'xm', 'age': 10}
print(len(a)) # 测量字典中元素的长度
<2>keys 返回一个包含字典所有KEY的列表
a = {'name': 'xm', 'age': 10}
print(a.keys()) # dict_keys(['name', 'age']) 返回的是键
print(type(a.keys())) # <class 'dict_keys'>
<3>values 返回一个包含字典所有value的列表
a = {'name': 'xm', 'age': 10}
print(a.values()) # dict_values([10, 'xm']) 返回的是值
print(type(a.values())) ＃ <class 'dict_values'>
<4>items 返回一个包含所有（键，值）元祖的列表
print(type(a.values()))
a = {'name': 'xm', 'age': 10}
print(a.items()) ＃ dict_items([('age', 10), ('name', 'xm')])
- lambda表达式格式以及应用场景？
#lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
f = lambda x: pow(x, 4)
print(f(2)) # 16
map()函数第一个参数是lambda
- pass的作用？
空语句 do nothing
保证格式完整
保证语义完整
注：当你在编写一个程序时，执行语句部分思路还没有完成，这时你可以用pass语句来占位
- arg和*kwarg作用
'''
定义函数时，使用*arg和**kwarg
*arg和**kwarg 可以帮助我们处理上面这种情况，允许我们在调用函数的时候传入多个实参
'''
def exmaple2(required_arg, *arg, **kwarg):
if arg:
print "arg: ", arg
if kwarg:
print "kwarg: ", kwarg
exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo")
>> arg: (1, 2, 3)
>> kwarg: {'keyword2': 'foo', 'keyword1': 'bar'}
'''从上面的例子可以看到，当我传入了更多实参的时候
*arg会把多出来的位置参数转化为tuple
**kwarg会把关键字参数转化为dict
区别：*args是位置传参数，**kwarg是关键字传参数
'''
# 解包列表a
def sum(a, b, c):
return a + b + c
a = [1, 2, 3]
# the * unpack list a
print sum(*a)
>> 6
- is和==的区别
is比较的是对象的内存地址 ==比较对象的是值（内容）
1：==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等
2：is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同
- 简述Python的深浅拷贝以及应用场景？
深浅拷贝用法来自copy模块。
导入模块：import copy
浅拷贝：copy.copy
深拷贝：copy.deepcopy
字面理解：浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字，还有仅仅一层的字典、列表、元祖等.
-
Python垃圾回收机制？
-
Python的可变类型和不可变类型？
Python的每个对象都分为可变和不可变，主要的核心类型中，数字、字符串、元组是不可变的，列表、字典，集合是可变的
- 求结果：
v = dict.fromkeys(['k1','k2'],[])
v[‘k1’].append(666)
print(v)
v[‘k1’] = 777
print(v)
{'k2': [66, 666], 'k1': [66, 666]}
{'k2': [66, 666], 'k1': 777}
-
求结果：
1
答案：[6, 6, 6, 6]
- 列举常见的内置函数？
最常见的内置函数是:
print("Hello World!")
数学运算
abs(-5) # 取绝对值，也就是5
round(2.6) # 四舍五入取整，也就是3.0
pow(2, 3) # 相当于2**3，如果是pow(2, 3, 5)，相当于2**3 % 5
cmp(2.3, 3.2) # 比较两个数的大小
divmod(9,2) # 返回除法结果和余数
max([1,5,2,9]) # 求最大值
min([9,2,-4,2]) # 求最小值
sum([2,-1,9,12]) # 求和
类型转换
int("5") # 转换为整数 integer
float(2) # 转换为浮点数 float
str(2.3) # 转换为字符串 string
complex(3, 9) # 返回复数 3 + 9i
ord("A") # "A"字符对应的数值
chr(65) # 数值65对应的字符
bool(0) # 转换为相应的真假值，在Python中，0相当于False
在Python中，下列对象都相当于False：[], (),{},0, None,0.0,''
bin(56) # 返回一个字符串，表示56的二进制数
hex(56) # 返回一个字符串，表示56的十六进制数
oct(56) # 返回一个字符串，表示56的八进制数
list((1,2,3)) # 转换为表 list
tuple([2,3,4]) # 转换为定值表 tuple
slice(5,2,-1) # 构建下标对象 slice
dict(a=1,b="hello",c=[1,2,3]) # 构建词典 dictionary（{'c': [1, 2, 3], 'b': 'xx', 'a': 1}）
序列操作
all([True, 1, "hello!"]) # 是否所有的元素都相当于True值
any(["", 0, False, [], None]) # 是否有任意一个元素相当于True值
sorted([1,5,3]) # 返回正序的序列，也就是[1,3,5]
类，对象，属性
# define class
class Me(object):
def test(self):
print "Hello!"
def new_test():
print "New Hello!"
me = Me()
hasattr(me, "test") # 检查me对象是否有test属性和方法
getattr(me, "test") # 返回test属性
setattr(me, "test", new_test) # 将test属性设置为new_test
delattr(me, "test") # 删除test属性
isinstance(me, Me) # me对象是否为Me类生成的对象 (一个instance)
issubclass(Me, object) # Me类是否为object类的子类
- filter、map、reduce的作用？
filter(lambda n : n>5,range(10)
filter，迭代器，把符合要求的值列出来（此处要求为n>5）
map(lambda n : n*n，range(10)
map，把对参数的操作就过列出来（此处操作为n*n）
functools.reduce(lambda x ,y : x*y,range(1,10))
reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
比方说对一个序列求和，就可以用reduce实现：
>>> def add(x, y):
return x + y
>>> reduce(add, [1, 3, 5, 7, 9]
- 一行代码实现9*9乘法表
print("\n".join("\t".join(["%s*%s=%s" % (x, y, x * y) for y in range(1, x + 1)]) for x in range(1, 10)))
- 如何安装第三方模块？以及用过哪些第三方模块？
在Python中，安装第三方模块，是通过setuptools这个工具完成的。Python有两个封装了setuptools的包管理工具：easy_install和pip。目前官方推荐使用pip
- 至少列举8个常用模块都有那些？
os模块#用作系统级别的工作
sys模块#提供解释器相关操作
hashlib模块# 用于加密相关的操作
json和pickle模块 #用于序列化数据
subprocess模块
shuit模块 #文件的复制移动
logging模块#格式化记录日志
random模块 用于取随机数
time datetime模块时间模块
re模块 正则匹配
- re的match和search区别？
注意：re正则模块match函数第一个参数是匹配规则，第二个参数是要匹配的数据
match（）函数只检测RE是不是在string的开始位置匹配，
search()会扫描整个string查找匹配；
也就是说match（）只有在0位置匹配成功的话才有返回，
如果不是开始位置匹配成功的话，match()就返回none。
例如：
print(re.match(‘super’, ‘superstition’).span()) 会返回(0, 5)
而print(re.match(‘super’, ‘insuperable’)) 则返回None
search()会扫描整个字符串并返回第一个成功的匹配
例如：print(re.search(‘super’, ‘superstition’).span())返回(0, 5)
print(re.search(‘super’, ‘insuperable’).span())返回(2, 7)
- 什么是正则的贪婪匹配？
a = re.match('\d+', '111sss55dfsdfsdf5')
print(a) <_sre.SRE_Match object; span=(0, 1), match='111'>
非贪婪模式:
b = re.match('\d{5,20}?', '111111111sss55dfsdfsdf5')
print(b) <_sre.SRE_Match object; span=(0, 5), match='11111'>
贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。
非贪婪匹配：就是匹配到结果就好，就少的匹配字符。
-
求结果： a. [ i % 2 for i in range(10) ] b. ( i % 2 for i in range(10) )
-
求结果： a. 1 or 2 b. 1 and 2 c. 1 < (2==2) d. 1 < 2 == 2
-
def func(a,b=[]) 这种写法有什么坑？
函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，第二次执行还是用第一次执行的时候实例化的地址存储，所以三次执行的结果就是 [1, 1, 1] ，想每次执行只输出[1] ，默认参数应该设置为None。
- 如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?
str1 = "1,2,3"
str1 = str1.split(',')
print(str1)
- 如何实现[‘1’,’2’,’3’]变成[1,2,3] ?
a = ['1', '2', '3']
第一种：a = [int(i) for i in a]
print(a)
第二种：b = map(int, a)
print(list(b))
- 比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？
print([1, 2, 3]) [1, 2, 3]
print([(1), (2), (3)]) [1, 2, 3]
print((1,), (2,), (3,)) (1,) (2,) (3,)
a 列表里面的的每个元素都是数字类型，
b 列表里面的元素也是数字，这里面的小括号代表的优先运算符，
c 列表里面的每个元素都是元组。
- 如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
num = [i*i for i in range(1,11)]
print(num)
- 一行代码实现删除列表中重复的值 ?
list2 = [1, 2, 3, 2, 5, 6, 4, 4]
print(list(set(list2)))
- 如何在函数中设置一个全局变量 ?
**用global声明一个变量，在函数外是可以调用的，**
a = 1
def xm():
global a
a = a + 3
print(id(a))
return a + 1
print(xm())
print(id(a)) # 这个时候id是一样的
print(a)
- logging模块的作用？以及应用场景？
DEBUG < INFO < WARNING < ERROR < CRITICAL
- 请用代码简答实现stack 。
class Stack(object):
def __init__(self):
self.stack = []
def push(self, value): # 进栈
self.stack.append(value)
def pop(self): # 出栈
if self.stack:
self.stack.pop()
else:
try:
raise LookupError
except Exception:
print('stack is empty!')
def is_empty(self): # 如果栈为空
return bool(self.stack)
def top(self):
# 取出目前stack中最新的元素
return self.stack[-1]
s = Stack()
s.push(1)
s.push(2)
s.push(3)
s.push(4)
print(s.stack)
s.pop()
s.pop()
print(s.stack)
print(s.is_empty())
print(s.top())
- 常用字符串格式化哪几种？
print('hello %s and %s'%('df','another df'))
print('hello %(first)s and %(second)s'%{'first':'df' , 'second':'another df'})
print('hello {first} and {second}'.format(first='df',second='another df'))
-
简述 生成器、迭代器、可迭代对象 以及应用场景？
-
用Python实现一个二分查找的函数。
-
谈谈你对闭包的理解？
-
os和sys模块的作用？
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。
- 如何生成一个随机数？
import random
print(random.random())
- 如何使用python删除一个文件？
import os
print(os.remove(path))
remove是删除文件的，rmdir是删除文件夹的
-
谈谈你对面向对象的理解？
-
Python面向对象中的继承有什么特点？
面向对象中的继承 子类继承了父类拥有的属性和方法，父类的私有属性不会被继承
- 面向对象深度优先和广度优先是什么？
深度优先的模型，像是一条道走到黑，不撞南墙不回头的模式。但是基于的模型，类似于堆栈模型。再撞到南墙的时候，回溯到上一次撞墙前的位置。这样的的操作相当于stack的pop出最新入栈的那条数据。然后继续找一个之前没有走过的结点尝试。
深度优先：不全部保留节点，占用空间小，有回溯操作（即有入栈/出栈操作），运行速度慢。
广度优先：保留全部节点，占用空间大；无回溯操作（既无入栈、出栈操作）、运行速度快。
- 面向对象中super的作用？
super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
class A(object): # python3版本的
pass
class B(A):
def add(self, x):
super().add(x)
- 是否使用过functools中的函数？其作用是什么？
functools，用于高阶函数：指那些作用于函数或者返回其它函数的函数。
通常只要是可以被当做函数调用的对象就是这个模块的目标。
里面包含如偏函数 partial 等。
from functools import reduce
def add(x, y):
return x + y
print(reduce(add, [1, 3, 5, 7, 9])) #25
- 列举面向对象中带爽下划线的特殊方法，如：new、init
1、构造方法，析构方法
__init__(self,...) 构造方法，这个方法在创建对象时就会访问。也即：类后面加()调用执行init方法
2
__del__(self) 析构方法，恰好在对象要被删除之前调用。不用专门写，系统会自动调用
当删除一个对象时，python解释器会默认调用__del__()方法
3、__call__(self, *args)
对象后面+()直接调用call方法，此方法python独有
*注意：类后面加()调用执行init方法，对象后面()直接调用call方法
4、__add__(self, other)
对象相加直接执行
5，__sub__(self,other)
对象相减直接执行
6、__dict__
获取对象中封装的所有字段，用__dict__可以取到，并存放在字段中
- 如何判断是函数还是方法？
我们的函数只有跟我们的实例化出来的对象有绑定关系才能称之为方法,否则都是函数,
即便它是写到类里面的方法,没有跟我们的类实例化出来的对象进行绑定,它依然是函数,而不是类里面的方法.
- 静态方法和类方法区别？
class A(object):
def run(self):
print('xm正在跑')
@classmethod #类方法
def lei(cls):
print('xm正在调用类方法')
@staticmethod # 静态方法
def fun():
print('xm正在调用静态方法')
a = A()
a.run()
a.lei()
a.fun()
# 类名点实例方法的时候必须传一个参数进去
A.run(1)
A.lei()
A.fun()
总结：类方法和静态方法唯一不同的就是类方法需要传入一个参数而这个参数cls指的是类的本身，而静态方法不需要传参数
实例对象可以调用直接调用实例方法，类方法，静态方法。
类名字可以调用类方法和静态方法，也可以传入一个参数调用实例方法
-
列举面向对象中的特殊成员以及应用场景
-
1、2、3、4、5 能组成多少个互不相同且无重复的三位数
count = 0
for i in range(1, 6):
for j in range(1, 6):
for k in range(1, 6):
if (i != j) and (j != k) and (k != i):
count += 1
print('{}{}{}'.format(i, j, k), end='\n')
print(count) # 60
- 什么是反射？以及应用场景？
python的四个重要内置函数：getattr、hasattr、delattr和setattr较为全面的实现了基于字符串的反射机制。他们都是对内存内的模块进行操作，并不会对源文件进行修改。
反射的定义
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究
1：首先建立一个这样的文件
def login():
print("这是一个登陆页面！")
def logout():
print("这是一个退出页面！")
def home():
print("这是网站主页面！")
------------------------------------------------------------------------------------------------------------------
2：再创建一个这样的文件
def run1():
inp = input("请输入您想访问页面的url： ").strip()
modules, func = inp.split("/")
obj = __import__(modules)
if hasattr(obj, func):
func = getattr(obj, func)
func()
else:
print('404')
if __name__ == '__main__':
try:
run1()
except Exception as e:
print(repr(e))
- metaclass作用？以及应用场景？
metaclass
除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass。
metaclass，直译为元类，简单的解释就是：
当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。
但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。
连接起来就是：先定义metaclass，就可以创建类，最后创建实例。
所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
'''
要创建一个class对象，type()函数依次传入3个参数：
1 class的名称；
2 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
3 class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
'''
# 通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，
# 仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。
def fn(name='world'):
print('hello{}'.format(name))
Hello = type('Hello', (object,), dict(hello=fn))
h = Hello
h.hello()
-
用尽量多的方法实现单例模式。
-
装饰器的写法以及应用场景。
-
异常处理写法以及如何主动跑出异常（应用场景）
-
什么是面向对象的mro
-
isinstance作用以及应用场景？
-
写代码并实现：
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] -
json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？
-
json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？
-
什么是断言？应用场景？
-
有用过with statement吗？它的好处是什么？
-
使用代码实现查看列举目录下的所有文件。
-
简述 yield和yield from关键字。
网友评论