1、一行代码实现1-100之间和
In [1]: sum(range(0,101)) Out[1]: 5050
2、如何在一个函数内部修改全局变量
利用global修改全局变量
In [2]: a = 10 In [3]: def fn(): ...: global a ...: a=4 ...: In [4]: fn() In [5]: print(a) 4
os：提供了不少与操作系统相关联的函数 sys：通常用于命令行参数 re：正则表达式 math：数学运算 datetime：处理日期时间
4、字典如何删除和合并字典
使用字典的方法del和update
In [6]: dict1 = {1:'one',2:'two',3:'three'}
In [7]: del dict1[1] #删除字典的键值
In [8]: dict1
Out[8]: {2: 'two', 3: 'three'}
In [9]: dict2 = {4:'four',5:'five'}
In [10]: dict1.update(dict2) #update合并字典
In [11]: dict1
Out[11]: {2: 'two', 3: 'three', 4: 'four', 5: 'five'}
5、谈下python的GIL
GIL是python的全局解释器锁，同一进程中假如有多个线程运行，一个线程在运行python程序的时候会霸占python解释器（加一把锁即GIL），使该进程内的其他线程无法运行，等该线程运行完后其他线程才能运行。如果线程运行过程中遇到耗时操作，则解释器锁解开，使其他线程进行。所以在多线程中，线程的运行仍是有先后顺序的，并不是同时进行。
多进程中因为每个进程都能被系统分配资源，相当于每个有一个python解释器，所以多进程可以实现多个进程的同时运行，缺点是进程系统资源开销大。
6、python实现列表去重的方法
先通过集合去重，后再转换为列表
In [20]: list1 = [4,6,3,4,12,7,5,8]
In [21]: a = set(list1) #转换为集合
In [22]: a
Out[22]: {3, 4, 5, 6, 7, 8, 12}
In [23]: [x for x in a]
Out[23]: [3, 4, 5, 6, 7, 8, 12]
7、fun(*args,**kwargs)中的*args,**kwarg什么意思？
*args,**kwargs主要用于函数定义，可以将不定数量的参数传递给一个函数，这里的不定意思是：预先并不知道函数使用者会传递多少个参数，所以在这个场景下使用这两个关键字。*args是用来发送一个非键值对的可变数量的参数列表给函数，来看个例子
In [24]: def dome(arg,*args):
...: print(arg)
...: for i in args:
...: print(i)
...:
In [25]: dome(1,5,7,3,8)
1
5
7
3
8
**kwargs允许将不定长度的键值对作为参数传递给一个函数，如想要在一个函数里处理带名字的参数，这时就要使用**kwargs,上个例子
In [28]: def demo(**kwargs):
...: for k,v in kwargs.items():
...: print(k,v)
...:
In [29]: demo(name='marry',age='女')
name marry
age 女
8、python2和python3的range(100)区别
python2返回列表
python3返回迭代器，节约内存
9、一句话解释什么样的语言能够使用装饰器？
函数可以作为参数传递语言，可以使用装饰器
10、python内建数据类型那些
整型--int 布尔型--bool 字符串--str 列表--list 元组--tuple 字典--dict
11、简述面向对象中__new__和__init__区别
__init__是初始化方法，创建对象后，就立刻被默认调用了，可以接收参数，如所示
In [41]: class demo_new:
...: def __init__(self,newnum,newcolor): #__init__方法自动被调用，可以接收参数
...: self.newnum = newnum
...: self.newcolor = newcolor
...: def move(self):
...: print('飞起来')
...:
In [42]: demo1 = demo_new(2,'green') #创建对象
In [43]: print(demo1.newcolor)
green
In [44]: print(demo1.newnum)
2
（1）__new__至少要有一个参数cls，当前类，此参数在实例化时由python解释器自动识别
（2）__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super（当前类名，cls））__new__出来的实例，或者直接是object的__new__出来的实例
（3）__init__有一个参数self,就是__new__返回的实例，__init__在__new__的基础上可以完成一些其他初始化动作，__init__不需要返回值
（4）如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用__new__函数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，那么实际创建返沪的就是其他类的实例，其实就不会调用其他类__init__函数
In [46]: class A(object):
...: def __init__(self):
...: print('__init__方法',self)
...: def __new__(cls):
...: print('这是cls的ID',id(cls))
...: print('这是__new__方法',object.__new__(cls))
...: return object.__new__(cls)
...:
In [47]: A()
这是cls的ID 2069068533960
这是__new__方法 <__main__.A object at 0x000001E1BEE0BE48>
__init__方法 <__main__.A object at 0x000001E1BEE0BE48>
Out[47]: <__main__.A at 0x1e1bee0be48>
In [48]: print('这是类A的ID',id(A))
这是类A的ID 2069068533960
12、简述with方法打开处理文件帮我们做了什么
In [50]: f = open('./1.txt','wb')
In [51]: try:
...: f.write('hello world')
...: except:
...: pass
...: finally:
...: f.close()
打开文件在进行读写的时候可能会出现一些异常状况，如果汉族常规的f.open写，我们需要try,excpet,finally做异常判断，并且文件最终不管遇到什么情况，都要执行finally f.close()关闭文件，with方法帮我们实现了finally中的f.close()
13、列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25],并使用列表推导式提取出大于10的数，最终输出[16,25]
map()函数第一个参数是fun,第二个参数一般是list,第三个参数可以写list,也可不写
In [52]: list1 = [1,2,3,4,5]
In [53]: def fn(x):
...: return x**2
...:
In [54]: res = map(fn,list1)
In [55]: res = [i for i in res if i >10]
In [56]: print(res)
[16, 25]
14、python中生成随机整数、随机销售，0-1之间的小数方法
随机整数：random.randint(a,b) 区间整数 随机小数：用numpy库，利用np.random.randn(5) 生成5个随机小数 0-1随机小数：random.random(),注：括号内不传参
15、避免转义给字符串加那个字母表示原始字符串：
r,表示需要原始字符串，不转义特殊字符
16、<div class=’nam’>中国</div>,用正则匹配出标签里面的内容（‘中国’），其中class的类名不确定
In [67]: import re In [68]: str1 = '<div class="nam">中国</div>' In [69]: res = re.findall(r'<div class=".*">(.*?)</div>',str1) In [70]: print(res) ['中国']
17、python中断言方法举例
assert()方法，断言成功，则程序继续执行，断言失败，则程序报错
In [71]: a = 3
In [72]: assert(a>1)
In [73]: print("断言成功，程序继续向下执行")
断言成功，程序继续向下执行
In [74]: b = 5
In [75]: assert(b>9)
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-75-e543486a620d> in <module>
----> 1 assert(b>9)
AssertionError:
18、数据表student有id,name,score,city字段，其中name中有名字可能重复，需要消除重复行，请写sql语句
select distinct name from student
19、10个Linux常用命令
ls pwd cd touch rm mkdir tree cp mv cat more grep echo
20、python2和python3区别？
（1）python3使用print必须用小括号包裹打印内容
（2）python2 range(10)返回列表，python3返回迭代器，节约内存
（3）python2使用ascii编码，python3使用uft-8编码
（4）python2中unicode表示字符串序列，str表示字节序列；python3中str表示字符串学历，byte表示字节序列
（5）python2中正常显示中文，引入coding声明，python3不需要
（6）python2中raw_input()函数，python3中是input()函数
21、列出python中可变数据类型和不可变数据类型，简述原理
不可变数据类型：数值型、字符串型string和远祖tuple
不可变数据类型：不允许变量的值发生变化，如果改变了变量的值，相当于新建了一个对象，而对于相同的值的对象，内存中则只有一个对象地址，可用id()方法查看
可变数据类型：列表list和字典dict
允许变量的值发生变化，即如果对变量进行了append、+=等操作后，只是改变了变量的值，而新建对象，变量引用的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即，每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
In [76]: a = 3 In [77]: b = 3 In [78]: id(a) Out[78]: 1608819872 In [79]: id(b) Out[79]: 1608819872 In [80]: a = [1,2] In [81]: b = [1,2] In [82]: id(a) Out[82]: 2069075295752 In [83]: id(b) Out[83]: 2069084580424
22、s=’abcadbdx’,去重并从小到大排序‘abcdx’
In [85]: s = 'abcadbdx' In [86]: s = set(s) In [87]: s = list(s) In [88]: s.sort(reverse=False) In [89]: res = ''.join(s) In [90]: print(res) abcdx
23、用lambda函数实现两个数相乘
In [91]: sum1 = lambda a,b:a*b In [92]: print(sum1(4,5)) 20
24、字典根据键从小到大排序dict1=
{'name':'sx','age':5000,'city':'西安','tel':'132xxxxxxxxx'}
In [93]: dict1 = {'name':'sx','age':5000,'city':'西安','tel':'132xxxxxxxxx'}
In [94]: list1 = sorted(dict1.items(),key=lambda i :i[0],reverse=False)
In [95]: print('sorted根据字典键排序',list1)
sorted根据字典键排序 [('age', 5000), ('city', '西安'), ('name', 'sx'), ('tel', '132xxxxxxxxx')]
In [96]: new_dict = {}
In [97]: for i in list1:
...: new_dict[i[0]]=i[1]
...:
In [98]: print('新字典',new_dict)
新字典 {'age': 5000, 'city': '西安', 'name': 'sx', 'tel': '132xxxxxxxxx'}
25、字符串a =’not 404 found 张三 99 西安’，每个词中间都有空格，用正则过滤掉英文和数字，最终输出；张三 深圳
In [106]: import re
In [107]: a = 'not 404 found 张三 99 西安'
In [108]: list1 = a.split(" ")
In [109]: print(list1)
['not', '404', 'found', '张三', '99', '西安']
In [110]: res = re.findall('\d+|[a-zA-Z]+',a)
In [111]: for i in res:
...: if i in list1:
...: list1.remove(i)
...:
In [112]: new_str = " ".join(list1)
In [113]: print(res)
['not', '404', 'found', '99']
In [114]: print(new_str)
张三 西安
26、用filter方法求出列表所有奇数，并构造新列表，a = [1,2,3,4,5,6,7,8,9,10]
filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素构成的新列表。该接收两个参数，第一个为函数，第二个位序列，序列的每个元素作为参数传递给函数进行判断，返回True或False，最后将返回为True的放到中
In [115]: a = [1,2,3,4,5,6,7,8,9,10]
In [116]: def fn(a):
...: return a%2==1
...:
In [117]: newlist = filter(fn,a)
In [118]: newlist = [i for i in newlist]
In [119]: print(newlist)
[1, 3, 5, 7, 9]
27、列表推导式求列表所有奇数，并构造新列表,a=[1,2,3,4,5,6,7,8,9,10]
In [120]: a = [1,2,3,4,5,6,7,8,9,10] In [121]: res = [i for i in a if i%2==1] In [122]: print(res) [1, 3, 5, 7, 9]
28、正则re.complie作用
re.complie是将正则表达式编译成一个对象，加快速度，并重复使用
29、a=(1,),b=(1),c=(‘1’)分别表示什么类型数据
In [123]: type((1,))
Out[123]: tuple
In [124]: type((1))
Out[124]: int
In [125]: type(('1'))
Out[125]: str
30、利用collections库的Counter方法统计字符串每个单词出现的次数
In [130]: from collections import Counter
In [131]: a = 'aksfnwoefjaonfakfasojf;sfhwnafsn;sfhowsjfaoemsm,'
In [132]: res = Counter(a)
In [133]: print(res)
Counter({'f': 9, 's': 7, 'a': 6, 'o': 5, 'n': 4, 'w': 3, 'j': 3, 'k': 2, 'e': 2, ';': 2, 'h': 2, 'm': 2, ',': 1})