1.如何实现对python列表去重并保持原先顺序？
l = ['cc', 'bbbb', 'afa', 'sss', 'bbbb', 'cc', 'shafa']
addr_to = list(set(l))
addr_to.sort(key = l.index)
print(addr_to)
# ['cc', 'bbbb', 'afa', 'sss', 'shafa']
l = ['cc', 'bbbb', 'afa', 'sss', 'bbbb', 'cc', 'shafa']
addr_to = list(set(l))
print(addr_to)
# ['shafa', 'cc', 'afa', 'bbbb', 'sss']
2.现有两元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
t1 = (('a'),('b'))
t2 = (('c'),('d'))
list(zip(t1,t2))
print(list(zip(t1,t2)))
# [('a', 'c'), ('b', 'd')]
print(list(map(lambda t:{t[0]:t[1]},zip(t1,t2))))
# [{'a': 'c'}, {'b': 'd'}]
3.在python字符串格式化中,%和.format的主要区别是什么？
`%`:
Python中内置的%操作符可用于格式化字符串操作,
控制字符串的呈现格式,%操作符的使用是最方便的.
`.format`:
字符串的format()函数,该方法收集位置参数和关键字参数的任意集合,
并使用它们的值来替换字符串中的占位符.
4.*args和kwargs在什么情况下会使用到?请给出使用kwargs的示例代码
*args:表示将实参中按照位置传参,把多出来的值给args,且以元组的方式呈现
def foo(x,*args):
print(x)
print(args)
foo(1,2,3,4,5,6)
打印结果为：
1, (2,3,4,5,6)
**kwargs：表示形参中按照关键字传参，把多余的传值以字典的方式呈现
def soo(y,**kwargs):
print(y)
print(kwargs)
soo(1,a=2,b=3,c=4)
打印结果为：
1, {'a':2,'b':3,'c':4}
5.字符串x = "foo",整数y = 2, 那么x*y = foofoo
6.赋值
kvps = {'1':1,'2':2}
theCopy = kvps
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print(sum)
# 10
7.添加一个新的python模块的搜素路径
sys.path.append('/root/mods')
8.列表
country_counter = {}
def addone(country):
if country in country_counter:
country_counter[country] += 1
else:
country_counter[country] = 1
addone('China')
addone('Japan')
addone('china')
print(len(country_counter))
# 3
9.赋值和[:]不是一回事
names1 = ['Amir','Barry','Chales','Dao']
names2 = names1
names3 = names1[:]
names2[0] = 'Alice'
names3[1] = 'Bob'
sum = 0
for ls in (names1,names2,names3):
if ls[0] == 'Alice':
sum += 1
if ls[1] == 'Bob':
sum += 10
print(sum)
10.变量
d = lambda p : p * 2
t = lambda p : p * 3
x = 2
x = d(x)
x = t(x)
x = d(x)
print(x)
11.优先级not>and>or
x = True
y = False
z = False
if x or y and z:
print('yes')
else:
print('no')
12.Python里面如何实现tuple和list的转换
temp_list = [1,2,4,3,5]
s=tuple(temp_list)
print(type(s)) #<class 'tuple'>
temp_tupe = (1,2,3)
l = list(temp_tupe)
print(type(l)) #<class 'list'>
13.请写出一段Python代码实现删除一个list里面的重复元素
li = [22,3,4,5,6,77,4,6,8]
print(set(li))
14.如何得到列表list的交集与差集
a = [2,3,4,5]
b = [2,5,8]
#交集 [2, 5]
print(list(set(a).intersection(set(b))))
#并集 [2, 3, 4, 5, 8]
print(list(set(a).union(set(b))))
#差集[8] b中有而a中没有的元素
print(list(set(b).difference(set(a))))
15.Python中定义函数时如何书写可变参数和关键字参数？
*args是可变参数,args接收的是一个tuple,
**kwargs是关键字参数,kw接收的是一个dict.
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入:func(1, 2, 3),
又可以先组装list或tuple,再通过*args传入:func(*(1, 2, 3)).
关键字参数既可以直接传入:func(a=1, b=2),
又可以先组装dict,再通过**kw传入:func(**{'a': 1, 'b': 2}).
16.什么是lambda表达式？
匿名函数,也就是lambda函数,通常用在函数体比较简单的函数上.
匿名函数顾名思义就是函数没有名字,因此不用担心函数名冲突.
不过Python对匿名函数的支持有限,<br>只有一些简单的情况下可以使用匿名函数.
17.re的match()和search()有什么区别？
match()函数只检测re是不是在string的开始位置匹配,
search()会扫描整个string查找匹配,
也就是说match()只有在0位置匹配成功的话才有返回,
如果不是开始位置匹配成功的话,match()就返回None.
18.1 or 2 和 1 and 2输出分别是什么？为什么？
1 or 2 --> 1
1 and 2 --> 2
19.1<(2==2) 和 1<2 == 2结果分别是什么？为什么？
1<(2==2) False
1<2 == 2 True
20. [i%2 for i in range(10)] 和 (i % 2 for i in range(10)) 输出结果分别是什么？
[i%2 for i in range(10)]
# [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
(i % 2 for i in range(10))
# <generator object <genexpr> at 0x0000000004DA8F10>
21.请描述unicode,utf-8,gbk等编码之间的关系
unicode --> encode --> utf-8
utf-8 --> decode(gbk) --> unicode
中间人关系,Unicode是中间人(原始编码),utf-8和gbk是客户.
例如:gbk转换为utf8,就需要先将gbk转换为Unicode,然后再编码为utf8编码.
22.python中如果判断一个对象是否可调用对象?那些对象可以是可调用对象?
通过类型去判断python对象是否可调用,
需要同时判断的是函数还是方法,或者类是否实现__call__方法.
23.如何定义一个类,使其对象本身就是可调用对象?
如果一个类实现了__call__方法,那么其实例也会成为一个可调用对象.
24.什么是装饰器?写一个装饰器,可以打印输出方法执行时长的信息.
装饰器本身是一个python函数,它可以让其他函数在不需要做任何变动的前提下增加额外功能.
import time
def timer(func):
def decor(*args):
start_time = time.time()
func(*args)
end_time = time.time()
d_time = end_time - start_time
print("run the func use : ", d_time)
return decor
@timer
def func(str, count):
for i in range(count):
print("%d hello,%s!"%(i,str))
func("world", 100)
25.哪些情况下，y! = x - (x-y)会成立？
x,y是两个不相等的非空集合
26.用python实现"九九乘法表"，用两种不同的方式实现
print('\n'.join(' '.join( ['{}*{}={}'.format(i,j,i*j) for i in range(1,j+1)] ) for j in range(1,10) ))
27.如何在Python中拷贝一个对象?并说明它们之间的区别
-深拷贝：完全拷贝一个副本，容器内部的元素地址都不一样
-浅拷贝：仅仅复制了容器中元素的地址
28.谈谈你对Python装饰器的理解
装饰器本身是一个python函数,它可以让其他函数在不需要做任何变动的前提下增加额外功能.
29.获取list的元素个数,和向末尾追加元素所用的方法分别是?
count() 和 append()
30.如何判断一个变量是不是字符串?
-用type查看它的类型
-用isinstance函数，来判断该对象是不是已知类型，这样将返回True或False
31.xrange和range有什么不同?
python2:
xrange用法与range完全相同,所不同的是生成的不是一个list对象,而是一个生成器.
python3:
xrange已经取消,直接用range,range生成的是一个生成器,一般与for结合使用.
32.is 和 == 的区别?
==是判断两者内容是否相同
is是判断两者是不是同一个对象
33.如何生成[1,4,9,16,25,36,49,64,81,100]?尽量用一行实现
[x * x for x in range(1, 11)]
34.生成器是什么?有什么作用?请写一个生成器.
本质:迭代器(所以自带了__iter__方法和__next__方法,不需要我们去实现)
特点:惰性运算,开发者自定义
Python中提供的生成器
- 生成器函数:
一个包含yield关键字的函数就是一个生成器函数.
yield可以为我们从函数中返回值,但是yield又不同于return,return的执行意味着程序的结束,
调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象.
每一次获取这个可迭代对象的值,就能推动函数的执行,获取新的返回值.直到函数执行结束.
def genrator_fun1():
a = 1
print('现在定义了a变量')
yield a
b = 2
print('现在又定义了b变量')
yield b
g1 = genrator_fun1()
#打印g1可以发现g1就是一个生成器
print('g1 : ',g1)
print(next(g1))
print(next(g1))
"""
g1 : <generator object genrator_fun1 at 0x0000000004DCA2B0>
现在定义了a变量
1
现在又定义了b变量
2
"""
- 生成器表达式:类似于列表推导.但是,生成器返回按需产生结果的一个对象,而不是一次构建一个结果列表.
#生成器表达式(几乎不占内存)
sum(i for i in range(100))
35.map(str,[1,2,3,4,5,6,7,8,9])输出什么?
<map object at 0x000000CD5ADC9390>
36.请写出一段Python代码实现删除一个list里面的重复元素
list1 = [11,3,4,5,2,3,4]
list2 = []
for i in list1:
if i not in list2:
list2.append(i)
else:
continue
print(list2)
37.如何用Python删除一个文件
# 直接从系统里面删除文件,不经过回收站
os.remove('文件')
# 直接从系统里面删除空文件夹,不经过回收站
os.rmdir('文件夹')
38.Python里面如何生成随机数
import random
print(random.random())
# 0.44142579456844966
print(random.uniform(10,20))
# 11.171021064685485
print(random.randint(12, 20))
# 16
39.介绍一下except的用法和作用
Python的except用来捕获所有异常,
因为Python里面的每次错误都会抛出一个异常,
所以每个程序的错误都被当作一个运行时错误.
try:
pass
except BaseException as e:
print(e)
finally:
pass
40.输入一个字符串,返回倒序排列的结果:
如:'abcdef',返回'fedcba'
l='abcdef'
print(l[::-1])
41.请用自己的算法,按升序合并如下两个list,并去除重复的元素.
list1 = [2,3,8,4,9,5,6]
list2 = [5,6,10,17,11,2]
def bubble_sort(li):
# i表示第i趟,共n-1趟
for i in range(len(li) - 1):
# 第i趟,无序区范围0 --- (n-i-1)
for j in range(len(li) - i - 1):
if li[j] > li[j + 1]:
li[j], li[j + 1] = li[j + 1], li[j]
return li
def merge_two_list(li1, li2):
i = 0
j = 0
ans = []
while i < len(li1) and j < len(li2):
if li1[i] < li2[j]:
ans.append(li1[i])
i += 1
else:
ans.append(li2[j])
j += 1
while i < len(li1):
ans.append(li1[i])
i += 1
while j < len(li2):
ans.append(li2[j])
j += 1
return ans
bubble_sort(list1)
bubble_sort(list2)
merge_two_list(list1,list2)
42.Python中元组和列表的主要区别是？
- 元组是不可变的,列表是可变的
- 元组是可以嵌套的
- 元组---(),列表---[]
43.有一个数组[3,4,1,2,5,6,6,5,4,3,3]请写一个函数,找出该数组中没有重复的数的总和.
44.从0-99这100个数中随机取出10个,要求不能重复,可以自己设计数据结构.
45.Cookie和Session有什么区别?
cookie数据存放在客户端的,而session则是存放在服务端的.
46.HTTP协议是有状态协议还是无状态协议,如何从两次请求中判断是同一用户.
HTTP是无状态协议.
-比如用登录淘宝来举例,客户端访问淘宝,淘宝的服务端会返回给客户端一个“随机字符串”类型的键值对.
当下一次再访问的时候,客户端会带着上次的“随机字符串”来和服务器进行验证,如果匹配,则登录成功.
47.一行print出1-100偶数的列表
[n for n in range(1,101) if n%2 == 0]
48.1,2,3,4,5能组成多少个互不相同且无重复数字的三位数(程序实现)
list = [1, 2, 3, 4, 5]
def getnum(num, li, length):
num1 = num
for i in range(len(li)):
num = num1 * 10 + li[i]
if length == 3:
yield num
elif length < 3:
for j in getnum(num, li[:i] + li[i + 1:], length + 1):
yield j
li = list(getnum(0, list, 1))
print("%r 共可以组成%d个三位数字 " % (d, len(li)))
print("它们是:%r" % li)
49.写出五中HTTP请求的方法
GET\POST\HEAD\PUT\DELETE\CONNECT\OPTIONS\TRACE
GET:请求指定的页面信息，并返回实体主体
HEAD:类似于get请求，只不过返回的响应中没有具体的内容，用于获取报头
POST：向指定资源提交数据进行处理请求(例如提交表单或者上传文件)，数据被包含在请求体中。
PUT:从客户端向服务器传送的数据取代指定的文档的内容
DELETE:请求服务器删除指定的页面
CONNECT:HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器
OPTIONS:允许客户端查看服务器的性能
TRACE:回显服务器收到的请求，主要用于测试或诊断
50.描述多进程开发中join与daemon的区别?
p.join([timeout]):
主线程等待p终止
强调:是主线程处于等的状态,而p是处于运行的状态.
timeout是可选的超时时间,需要强调的是,
p.join只能join住start开启的进程,而不能join住run开启的进程 .
p.daemon:默认值为False,
如果设为True,代表p为后台运行的守护进程,
当p的父进程终止时,p也随之终止,并且设定为True后,
p不能创建自己的新进程,必须在p.start()之前设置.
51.斐波契纳数列 1,2,3,5,8,13,21......根据这样的规律,编程求出400万以内最大的斐波契纳数,并求出他是第几个斐波契纳数.
li = [1,2]
while li[-1] < 4000000:
li.append(li[-1] + li[-2])
del li[-1]
print(li[-1])
print(len(li))
52.编程实现以下功能
dicta = {'a':1,'b':2,'c':3,'d':4,'f':'hello'}
dictb = {'b':3,'d':5,'e':7,'m':9,'k':'world'}
要求写一段代码,实现两个字典的相加,不同的key对应的值保留,相同的key对应的值相加后保留,如果是字符串就拼接,最终得到如下结果：
dictc = {'a':1,'b':5,'c':3,'d':9,'e':7,'m':9,'f':'hello','k':'world'}
dicta = {'a':1,'b':2,'c':3,'d':4,'f':'hello'}
dictb = {'b':3,'d':5,'e':7,'m':9,'k':'world'}
dic = {}
for key1 in dicta:
for key2 in dictb:
if key1 == key2:
dic[key1] = dicta[key1] + dictb[key2]
for a in dicta:
if a not in dic:
dic[a] = dicta[a]
for b in dictb:
if b not in dic:
dic[b] = dictb[b]
print(dic)
# dictc = {'a':1,'b':5,'c':3,'d':9,'e':7,'m':9,'f':'hello','k':'world'}
dicta = {'a':1,'b':2,'c':3,'d':4,'f':'hello'}
dictb = {'b':3,'d':5,'e':7,'m':9,'f':'world'}
dic = {}
for key1 in dicta:
for key2 in dictb:
if key1 == key2:
dic[key1] = dicta[key1] + dictb[key2]
for a in dicta:
if a not in dic:
dic[a] = dicta[a]
for b in dictb:
if b not in dic:
dic[b] = dictb[b]
print(dic)
# {'b': 5, 'd': 9, 'f': 'helloworld', 'a': 1, 'c': 3, 'e': 7, 'm': 9}
53.Python主要的内置数据类型都有哪些?哪些是可变的?哪些是不可变的?可变类型与不可变类型有什么区别？
数字,字符串,列表,字典,布尔型
可变:列表,字典
不可变:数字,字符串，布尔
可变数据类型:在id不变的情况下,数据类型的内部可以改变
不可变数据类型:value值改变,id也跟着改变
54.python是如何进行内存管理的?python的程序会内存泄漏吗?说说有没有什么方面防止或检测内存泄漏?
语言的内存管理是语言设计的一个重要方面.
它是决定语言性能的重要因素.
无论是C语言的手工管理,还是Java的垃圾回收,都成为语言最重要的特征.
这里以Python语言为例子,说明一门动态类型的面向对象的语言的内存管理方式.
项目中两种情况导致对象没有被正确回收:
- 被退出才回收的对象引用
- 交叉引用
55.关于python程序的运行性能方面,有什么手段能提升性能?
-让关键代码依赖外部包
-排序时使用键(key)
-优化代码中的循环
-使用较新版本的python
56.判断python对象是否为可调用的函数?
-方法1:
使用内置的callable函数,用于检查对象是否可调用.
如果返回True也可能调用失败,但是返回False一定不可调用.
callable(func)
-方法2:判断对象类型是否是FunctionType
type(func) is FunctionType
# 或者
isinstance(func, FunctionType)
-方法3:判断对象是否实现__call__方法,
如果定义一个类的话,里面只要定义了__call__方法,对象就可以被调用了.
hasattr(func, '__call__')
