第一章 Python 基础

1. 为什么学习 Python？

　　

  • 答题路线：a、python的优点，b、python的应用领域广
  • 具体：
    • 优点
      • 1、python语法非常优雅，简单易学
      • 2、免费开源
      • 3、跨平台，可以自由移植
      • 4、可扩展，可嵌入性强
      • 5、第三方库丰富
    • 应用领域
      • 1、在系统编程中应用广泛，比如说shell工具。
      • 2、在网络爬虫方面功能非常强大，常用的库如scrapy，request等
      • 3、在web开发中使用也很广泛，如很多大型网站都用python开发的，如ins，youtube等，常用的框架如django，flask等
      • 4、python在系统运维中应用广泛，尤其在linux运维方面，基本上都是自动化运维。
      • 5、在人工智能，云计算，金融等方面也应用非常广泛。

2. 通过什么途径学习的 Python？　

　　

  • 通过看官方文档
  • 通过哔哩哔哩上的视频教程
  • 通过百度查资料
  • 通过买python相关方面的书

3. 公司线上和开发环境使用的什么系统？　　

　　

  • 线上用的centos和Ubuntu系统
  • 开发环境用的windows，mac，还有Ubuntu。

4. Python 和 Java、PHP、C、C#、C++等其他语言的对比？

　　

  • Java C# PHP Python (开发效率高)，这些语言本身不需要你去管理内存了。它们都有自己的虚拟机，对于开辟内存、释放内存都由这个虚拟机处理。
  • C 和 Python、Java、C#等C语言： 代码编译得到 机器码 ，机器码在处理器上直接执行，每一条指令控制CPU工作其他语言： 代码编译得到 字节码 ，虚拟机执行字节码并转换成机器码再后在处理器上执行Python 和 C Python这门语言是由C开发而来　　
  • 对于使用：Python的类库齐全并且使用简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多.
  • 对于速度：Python的运行速度相较与C，绝逼是慢了Python 和 Java、C#等　　
  • 对于使用：Linux原装Python，其他语言没有；以上几门语言都有非常丰富的类库支持
  • 对于速度：Python在速度上可能稍显逊色所以，Python和其他语言没有什么本质区别，其他区别在于：擅长某领域、人才丰富、先入为主

5. 简述解释型和编译型编程语言？　　

　　

  • 解释型语言编写的程序不需要编译，在执行的时候，专门有一个解释器能够将VB语言翻译成机器语言，每个语句都是执行的时候才翻译。这样解释型语言每执行一次就要翻译一次，效率比较低。
  • 用编译型语言写的程序执行之前，需要一个专门的编译过程，通过编译系统，把源高级程序编译成为机器语言文件，翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高，但也不能一概而论，部分解释型语言的解释器通过在运行时动态优化代码，甚至能够使解释型语言的性能超过编译型语言。

6. Python 解释器种类以及特点？　　

　　

  • CPython
    • c语言开发的 使用最广的解释器
  • IPython
    • 基于cpython之上的一个交互式计时器 交互方式增强 功能和cpython一样
  • PyPy
    • 目标是执行效率 采用JIT技术 对python代码进行动态编译，提高执行效率
  • JPython
    • 运行在Java上的解释器 直接把python代码编译成Java字节码执行
  • IronPython
    • 运行在微软 .NET 平台上的解释器，把python编译成. NET 的字节码

7. 位和字节的关系？

　　1位=8字节

8. b、B、KB、MB、GB 的关系？

　　

1GB=1024MB

　　1MB=1024KB

　　1KB=1024B

　　1B=1024b

9. 请至少列举 5 个 PEP8 规范（越多越好）　　

　　

  • 每个缩进级别使用4个空格
  • 每行代码的最大长度限制为79个字符
  • 若是导入多个库函数，应该分开依次导入
    • 道路应按照以下顺序导入 a、标准库导入 b、相关的第三方库导入 c、本地应用程序的库导入
  • 在表达式中避免无关的空格，代码更改时，相应的注释也要随之更改
    • 在括号或者大括号内
    • 在尾随逗号和后面的右括号之间
    • 在逗号，分号或者冒号前面
    • 函数名的与后面的参数的括号之间
  • 命名要规范，通俗易懂

10. 求结果：or and

1. v1 = 1 or 3

2. v2 = 1 and 3

3. v3 = 0 and 2 and 1

4. v4 = 0 and 2 or 1

5. v5 = 0 and 2 or 1 or 4

6. v6 = 0 or Flase and 1

　　1.1　　2,。3　　3.0　　4.1　　5.1　　6.False

11. ascii、unicode、utf-8、gbk 区别？　　

　　

  • ascii 是最早美国用的标准信息交换码，把所有的字母的大小写，各种符号用 二进制来表示，共有256中，加入些拉丁文等字符，1bytes代表一个字符
  • Unicode是为了统一世界各国语言的不用，统一用2个bytes代表一个字符，可以表达2^16=65556个，称为万国语言，特点：速度快，但浪费空间
  • utf-8 为了改变Unicode的这种缺点，规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的
  • gbk 是中文的字符编码，用2个字节代表一个字符

12. 字节码和机器码的区别？　　

　　

  • 机器码是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂，也比较难编写，一般从业人员接触不到。
  • 字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

13. 三元运算编写格式。

　　　　

表达式1　　 if　　 布尔表达式  　　else　　表达式2

　　例如：a=b if c  else d

14. 列举你了解的所有 Python2 和 Python3 的区别？　　

　　

  1. python2没有nonlocal关键字，要修改临时变量只能将其改成可变数据类型，如数组。b=[a]
  2. print()函数代替print语句
  3. Python3加入 Unicode 字符串，用以编码存储字符串。比如用 utf-8可以用来输入中文
  4. Python3去掉long类型，新增了bytes。
  5. Python 3整数之间做除法可以得到浮点数的结果，不需要进行数据格式转换1/2=0.5 Python 2整数int间除法结果为把运算结果去尾的整数1/2=0，3/2.0=1.5
  6. Python3 中 range()，Python2 中 xrange()。
  7. python2中的不等于号可以是!=或者<>，python3只能是!=
  8. python2中raw_input()用来输入字符串，而python3中使用input()来输入字符串

15. Py2 项目如何迁移成 py3?　　

　　

  1. 先备份原文件，然后使用python3自带工具2to3.py将py2文件转换位py3文件
  2. 手动将不兼容的代码改写成兼容py3的代码

16. 用一行代码实现数值交换：

1. a = 1
2. b = 2

a,b=b,a

17. Python3 和 Python2 中 int 和 long 的区别？　　

  • 　　python2中有long类型，python3中没有long类型，只有int类型。python3中的int类型包括了long类型。

18. xrange 和 range 的区别？　　

　　

  • xrange和range用法相同，但是xrange是一个生成器，只在python2中有，range结果是一个列表，在python3中的。xrange做循环的时候性能比range好。

19. 如何实现字符串的反转？如： name = "wupeiqi" 请反转为 name ="iqiepuw" 。　　

1 #切片翻转
2 name="qwer"
3 name=name[::-1]
4 print(name)
5 
6 #转成列表翻转
7 name_list=name.split()
8 name_list.reverse()
9 print(name)
# 方法三：
    from functools import reduce
    name=reduce(lambda x, y: y+x, name)

20. 文件操作时：xreadlines 和 readlines 的区别？　　

　　

  • xreadlines返回的是一个生成器，python2中的，pyton3已经没有该方法
  • readlines返回的是一个列表

21. 列举布尔值为 False 的常见值？　　

　　

  • 0、''、[]、{}、tuple()、None、set()

22. 列举字符串、列表、元组、字典每个常用的 5 个方法？　　

　　

  • 字符串---字符串方法总结
    1. strip() ->去掉字符串两端的空白符
    2. split() ->对字符串进行分割，默认按照空格分割
    3. join() ->字符串连接
    4. startwith(),endwith() ->判断是否以啥开头或者结尾
    5. replace() -> 字符串替换
    6. find() -> 查找字符串，存在返回第一个索引，不存在返回-1
  • 列表---列表方法总结
    1. count() ->统计在列表中出现的个数
    2. apped() ->在列表末尾添加值
    3. pop() ->删除一个对象，默认最后一个
    4. remove() ->删除指定的第一个匹配项
    5. insert() ->插入对象
    6. index() ->获取索引
    7. extend()->迭代追加
  • 元组
    1. count() ->统计在元组中出现的个数
    2. index() ->获取索引
  • 字典---字典方法总结　　
    1. keys() ->获取所有的键
    2. pop() ->删除指定的键的键值对
    3. popitem() ->随机删除一个键值对
    4. update() ->更新字典，参数为一个字典，如果键已存在，则更改，不存在则添加
    5. setdefault() ->如果键存在则，返回该键对应的值，如果不存在，设置该键为设置的默认值，然后返回该键对应的值
    6. get() ->返回键对应的值
    7. fromkeys() ->创建字典，第一个参数为可迭代对象，每个值变成字典的键，第二个参数为每个键的默认值

23. is 和==的区别?　　

　　

  • is比较的是两个对象的id是否相同
  • ==比较的是两个对象的值是否相同

24. 1、2、3、4、5 能组成多少个互不相同且无重复的三位数

　　5x4x3=60

25. 什么是反射？以及应用场景？　　

　　

  • 反射就是通过字符串的形式，导入模块；通过字符串的形式，去模块寻找指定函数，并执行。利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！
  • 应用场景：当我们动态的输入一个模块名的时候就可以使用到反射。
  • 通过hasattr，getattr，delattr，setattr等四个函数来操作

26. 简述 Python 的深浅拷贝？

　　　

　深浅拷贝　　

  • 浅拷贝只是对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值，实际是对另外一个变量的引用。
    • 浅拷贝的特点：
      • 共用一个值（不同变量的地址指向同一个值）
      • 这两个变量指向值的内存地址一样
      • 可变数据类型：对其中一个变量的值改变，另外一个变量的值也会改变
      • 不可变数据类型：对其中一个的改变，另外一个不变
  • 深拷贝是一个变量对另外一个变量的值拷贝。如果是不可变类型，则深浅拷贝只拷贝引用，如果是可变类型，浅拷贝只拷贝第一层引用，深拷贝无论多少层引用都拷贝
    • 深拷贝的特点：
      • 两个变量的内存地址不同
      • 两个变量各有自己的值，且互不影响
      • 对其任意一个变量的值的改变不会影响另外一个

27. Python 垃圾回收机制？　　

　　

  • 概述：python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略
  • 引用计数：
    • 每当新的引用指向该对象时，引用计数加1，当对该对象的引用失效时，引用计数减1，当对象的引用计数为0时，对象被回收。缺点是，需要额外的空间来维护引用计数，并且无法解决对象的循环引用。 
  • 分代回收：
    • 以时间换空间的回收方式
    • 分代回收是一种以空间换时间的操作方式，Python将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代，Python将内存分为了3“代”，分别为年轻代（第0代）、中年代（第1代）、老年代（第2代），他们对应的是3个链表，它们的垃圾收集频率与对象的存活时间的增大而减小。
    • 新创建的对象都会分配在年轻代，年轻代链表的总数达到上限时，Python垃圾收集机制就会被触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去，依此类推，老年代中的对象是存活时间最久的对象，甚至是存活于整个系统的生命周期内。
    • 同时，分代回收是建立在标记清除技术基础之上。分代回收同样作为Python的辅助垃圾收集技术处理那些容器对象
  • 标记清除：
    • 活动对象会被打上标记，会把那些没有被打上标记的非活动对象进行回收。

28. Python 的可变类型和不可变类型的区别？　　

　　

  • 可变类型有：列表，字典等
  • 不可变类型有：数字，字符串，元组等
  • 这里的可变不可变是指内存中的那块内容是否可以被改变。

29. 求结果 

　　1. v = dict.fromkeys(['k1','k2'],[])
　　2. v['k1'].append(666)
　　3. print(v)
　　4. v['k1'] = 777
　　5. print(v)

 　　{'k1': [666], 'k2': [666]}　　{'k1': 777, 'k2': [666]}

30. 一行代码实现删除列表中重复的值 ?　

　　　lst=list(set(lst))

31. 如何实现 “1,2,3” 变成 [‘1’,’2’,’3’]　　　　

"1,2,3".split(',')　

32. 如何实现[‘1’,’2’,’3’]变成[1,2,3]

[int(i) for i in ['1','2','3']]

33. 比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别？

　　

  • a和b的结果相同，列表里面的值相同，类型也相同
  • c中的列表里面的值是元组类型的

34. 如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?

　　
[pow(i,2) for i in range(1,11)]
[(i**2) for i in range(1,11)]

35. 常用字符串格式化哪几种？　　

1 # 1.使用百分号
2 print('hello %s and %s'%('friend','another friend'))
3 # 2.使用format
4 print('hello {} and {}'.format('friend','another friend'))
5 print('hello {first} and {second}'.format(second='another friend',first='friend'))
6 print('hello {1} and {0}'.format('another friend','friend'))
7 # 3.使用f
8 a,b=1,23
9 print(f"a={a},b={b}")

36. 什么是断言（assert）？应用场景？

　　　　

断言的参考

  • assert是用来检查一个条件，如果它为真，就不做任何事。如果它为假，则会抛出AssertError并且包含错误信息。
  • 应用场景：
    1. 防御型编程
    2. 运行时检查程序逻辑
    3. 检查约定
    4. 程序常量
    5. 检查文档

37. 有两个字符串列表 a 和 b，每个字符串是由逗号分隔的一些字符：

1. a = [ 'a,1',
2. 'b,3,22',
3. 'c,3,4',
4. ]
5.
6. b = [
7. 'a,2',
8. 'b,1',
9. 'd,2',
10. ]
11. 按每个字符串的第一个值，合并 a和 b到 c
12.
13. c = [
14. 'a,1,2',
15. 'b,3,22,1',
16. 'c,3,4',
17. 'd,2'
18. ]

a_dic={}
for i in a:
    k,v=i.split(',',1)
    a_dic[k]=v
b_dic={}
for i in b:
    k,v=i.split(',',1)
    b_dic[k]=v
for ka,va in a_dic.items():
    if ka in b_dic.keys():
        a_dic[ka]=va+','+b_dic[ka]
for kb,vb in b_dic.items():
    if kb not in a_dic.keys():
        a_dic[kb]=vb
c=[k+','+v for k,v in a_dic.items()]
print(c)

38. 有一个多层嵌套的列表 A=[1,2,[3,4,["434",...]]], 请写一段代码遍历 A 中的每一个元素并打印出来　　

 1 #递归遍历(顺序)
 2 def func(A):
 3     for i in A:
 4         if type(i)==list:
 5             func(i)
 6         else:
 7             print(i)
 8 func(A)
 9 
10 #堆栈遍历（无序）
11 B=[]
12 B.append(A)
13 def func2(B):
14     if B:
15         C=B.pop()
16         for i in C:
17             if type(i)==list:
18                 B.append(i)
19             else:
20                 print(i)
21         func2(B)
22 func2(B)

39. a = range(10),a[::-3] 的结果是 ____　　

　　[9,6,3,0]或者range(9,-1,-3)

40. 下面那个命令可以从虚拟环境中退出

　　A. deactivate　　B. exit　　C. quit　　D. 以上均可

41. 将列表内的元素,根据位数合并成字典

1. lst = [1,2,4,8,16,32,64,128,256,512,1024,32769,65536,4294967296]
2.
3. # 输出
4. {
5. 1:[1,2,3,8],
6. 2:[16,32,64],
7. 3:[128,256,512],
8. 4:[1024,],
9. 5:[32769,65536],
10. 6:[4294967296]
11. }

#方法1
lst=[1,2,4,56,78,34,3,345,567,4567,456,4567,4566784]
from collections import defaultdict
dic=defaultdict(list)
for i in lst:
    dic[len(str(i))].append(i)
print(dict(dic))

#方法2
dic={}
for i in lst:
    len_i=len(str(i))
    dic.setdefault(len_i,[]).append(i)
print(dic)

42. 请尽量用简洁的方法将二维数组转换成一维数组

　　例: 转换前 lst=[[1,2,3],[4,5,6],[7,8,9]]

　　　  转换后 lst = [1,2,3,4,5,6,7,8,9]　　

 1 lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 2 #列表推导式
 3 lst=[j for i in lst for j in i]
 4 print(lst)

 5 #for循环
 6 a=[]
 7 for i in lst:
 8     a.extend(i)
 9 lst=a
10 print(lst)

 43. 将列表按下列规则排序, 补全代码

　　1.正数在前负数在后

　　2.正数从小到大

　　3.负数从大到小

　　例:

　　　　排序前[7,-8,5,4,0,-2,-5]

　　　　排序后[0,4,5,7,-2,-5,-8]

　　补全代码:

　　　　sorted(lst,key=lambda x:_____)

1 l=[7,-8,4,5,0,-2,-5]
2 a=sorted(l,key=lambda x:(x<0,abs(x)))
3 print(a)

44. 哈希冲突回避算法有哪几种, 分别有什么特点？

　

　哈希冲突参考

  1. 开放定址法
  2. 再哈希法
  3. 链地址法
  4. 建立公共溢出区

45. 简述 Python 的字符串驻留机制？

　　

python字符串驻留机制参考文档

  • 相同对象的引用都指向内存中的同一个位置，这个也叫python的字符串驻留机制
  • python的引用计数机制，并不是对所有的数字，字符串，他只对”[0-9][a-z][A-Z] 和"_"(下划线) ”有效“，当字符串中由其他字符比如“！ @ # ￥ % -”时字符驻留机制是不起作用的。

46. 以下代码输出是什么? list=['a','b','c','d','e'] print list[10:]

　　A. []

　　B. 程序异常

　　C. ['a','b','c','d','e']

　　D. 输出空

47. Python 语言什么那些类型的数据才能做为字典的 key?

　　A. 没有限制

　　B. 字母数字下划线

　　C. 字母

　　D. 可被 hash的类型

48. 以下两段代码的输出一样吗, 占用系统资源一样吗, 什么时候要用 xrange 代替 range

　　1. for i in range(1): print i

　　2. for i in xrange(1): print i

　　不一样，range是一个列表，而xrange是生成器，占用空间资源小，python3 中不存在xrange

49. 如下代码段(赋值与深浅拷贝)

1. a = [1,2,3,[4,5],6]
2. b = a
3. c = copy.copy(a)
4. d = copy.deepcopy(a)
5. b.append(10)
6. c[3].append(11)
7. d[3].append(12)
8. 请问 a,b,c,d的值为

　　a:[1, 2, 3, [4, 5, 11], 6, 10]　　b:[1, 2, 3, [4, 5, 11], 6, 10]　　

　　c:[1, 2, 3, [4, 5, 11], 6]　　d:[1, 2, 3, [4, 5, 12], 6]

50. 现有字典 d={"a":26,"g":20,"e":20,"c":24,"d":23,"f":21,"b":25} 请按照字段中的 value 字段进行排序。　　

　dict(sorted(d.items(),key=lambda x:x[1]))

51. 给定两个 list：A,B,请用 Python 找出 A,B 中相同的元素,A,B 中不同的元素

 1 A=[1,3,7,0,5,11]
 2 B=[11,4,6,8,0]
 3 # 方法一：列表操作
 4 s=[i  for i in A for j in B if j==i]
 5 print(s)
 6 d=[]
 7 for i in A:
 8     if i not in s:
 9         d.append(i)
10 for i in B:
11     if i not in s:
12         d.append(i)
13 print(d)
14 
15 #方法二：集合操作
16 s=set.intersection(set(A),set(B))
17 d=set.difference(set.union(set(A),set(B)),set(s))
18 print(s)
19 print(d)

52. 下列叙述中错误的是

　　A. 栈是线性结构

　　B. 队列是线性结构

　　C. 线性列表是线性结构

　　D. 二叉树是线性结构

53. 一个栈的输入序列为 1,2,3,4,5, 则下列序列中不可能是栈的输出序列的是

　　A. 1 5 4 3 2

　　B. 2 3 4 1 5

　　C. 1 5 4 2 3

　　D. 2 3 1 4 5

54. 下图那些 PEP 被认为涉及到了代码规范

　　1. PEP7

　　2. PEP8

　　3. PEP20

　　4. PEP257

55. 下面那些是 Python 合法的标识符？那些是 Python 的关键字？

1. int32　　　　　合法标识符
2. 40XL　　　　　 合法标识符
3. saving$　　　　不合法标识符
4. ptint　　　　　关键字
5. this 　　　　　合法标识符
6. self 　　　　  合法标识符
7. 0x40L　　　　　合法标识符
8. true　　　　　 合法标识符
9. big-daddy　　 不合法标识符
10. True　　　　　关键字
11. if　　　　　　关键字
12. do　　　　　　合法标识符
13. yield　　　　关键字

56. 从 0-99 这 100 个数中随机取出 10 个, 要求不能重复, 可以自己设计数据结构

　　
import random
print(random.sample(range(100),10))

57. python 判断一个字典中是否有这些 key: "AAA",'BB','C',"DD",'EEE'(不使用for while)　　

　　
k in dic.keys()

58. 有一个 list["This","is","a","Boy","!"], 所有元素都是字符串, 对他进行大小写无关的排序

1 l=["This","is","a","Boy","!"]
2 lst=sorted(l,key=lambda x:x.lower())
3 print(lst)

59. 描述下 dict 的 item()方法与 iteritems()的不同　　

　　

  • 字典的items方法作用：是可以将字典中的所有项，以列表方式返回。因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。
  • 字典的iteritems方法作用：与items方法相比作用大致相同，只是它的返回值不是列表，而是一个迭代器。iteritems()方法在需要迭代结果的时候使用最适合，而且它的工作效率非常的高。
  • 在Python 3.x 里面，iteritems()方法已经废除了。

60. 请列举你所知道的 Python 代码检测工具及他们间的区别？　　

　　

  • pylint --- 源代码分析器，可以分析python代码中的错误
  • pyflakes --- 检查源文件错误的简单程序，不会检查代码风格。
  • pep8 --- 检查代码规范的工具
  • pyhecker是一个python代码静态分析工具，它可以帮助python代码找bug会对代码的复杂度提出警告

61. 介绍一下 try except 的用法和作用?　　

　　

  • 主要用来处理异常 
    • Try except:是一个异常捕获,用法就是在一些容易出现逻辑错误的地方加装,然后进行处理.不让异常抛出.
          作用一般在程序上线使用的时候可以使用,如果程序出现错误问题的时候也不能让用户看见报错,我们就可以使用异常捕获
          然后对程序进行闪退
  • 完整用法如下：
try:
     Normal execution block
except A:
     Exception A handle
except B:
     Exception B handle
except:
     Other exception handle
else:
     if no exception,get here
finally:
     print("finally")

62. 输入一个字符串, 返回倒序排列的结果 如: abcdef, 返回 fedcba

　　如上19题三种方式：（1）切片（2）列表的reverse（3）reduce函数

63. 阅读以下代码, 并写出程序的输出结果

1. alist = [2,4,5,6,7]
2. for var in alist:
3.     if var %2 ==0:
4.         alist.remove(var)
5. alist的最终结果是---------[4,5,7]　
　　运算过程：　　#2,[4,5,6,7]　　#5,[4,5,6,7]　　#6,[4,5,7]

64. 现有列表 alist=[3,1,-4,-2],按期元素的绝对值大小进行排序?

sorted(alist,key=lambda x:abs(x))
alist.sort(key=lambda x:abs(x))

65. 填空题

　　1. 表达式 3<4<5 是哪一个表达式的缩写   3<4 and 4<5

　　2. 获取 Python解释器版本的方法是:_python -V

　　3. 如果模块是被导入的,__name__的值是 模块的名字, 如果模块是被直接执行的__name__的值是  main.

　　4. Python的内存管理中, 为了追踪内存中的对象, 使用了 引用计数 这一简单技术

　　5. Python的标准解释器是有 C语言实现的, 称为Cpyhton, 有 Java实现的被称为 Jpython.

　　6. Python中, del 语句能直接显示的释放内存资源

　　7. Python的乘方运算符是  **

66. 现有字典 mydict 和变量 onekey, 请写出从 mydict 中取出 onekey 值的方法(不止一种写法, 多写加分, 并请叙述不同写法的区别, mydict 中是否存在onekey 的键值, 不确定)　　

　　mydict['onekey']  这种获取方式如果键不存在就会报错
　　mydict.get('onekey')   这种获取方式如果键不存在就返回None 我们可以自定义返回值
　　mydict.setdefault('onekey') 这种方式也是查看键在字典中是否存在,不存在就返回None
　　if 'onekey' in mydict: 这种方式是利用字典的键来进行校验是否存在

67. 现有一列表 alist, 请写出两种去除 alist 中重复元素的方法, 其中：

　　– 要求保持原有列表中元素的排列顺序。

　　– 无需考虑原有列表中元素的排列顺序。　　

1 alist=[2,34,6,8,9,7,3,2]
2 # 　　– 要求保持原有列表中元素的排列顺序。
3 L=[]
4 for i in alist:
5     if i not in L:
6         L.append(i)
7 
8 # 　　– 无需考虑原有列表中元素的排列顺序。
9 list(set(alist))

68. 关于Python程序的运行方面，有什么手段能提升性能？

　　

  1. 使用多进程，充分利用机器的多核性能
  2. 对于性能影响较大的部分代码，可以使用C或C++编写
  3. 对于IO阻塞造成的性能影响，可以使用IO多路复用来解决
  4. 尽量使用Python的内建函数5、尽量使用局部变量　　

69. 那些情况下, y != x - (x-y)会成立?　　

  • 　　x，y是两个不相等的非空集合

70. 用 Python 实现 99 乘法表(用两种不同的方法实现)

 1 #方式一：for循环
 2 for i in range(1,10):
 3     for j in range(1,i+1):
 4         print(f"{i}x{j}={i*j}	",end='
' if j==i else '' )
 5 #方式二：while循环
 6 i=1
 7 while i <10:
 8     j=1
 9     while j<=i:
10         print(f"{i}x{j}={i*j}	",end='
' if j==i else '' )
11         j+=1
12     i+=1
13 #方式三：列表的推导式
14 print('
'.join(['	'.join([f"{i}x{j}={i*j}" for j in range(1,i+1)]) for i in range(1,10) ]))

71. 获取 list 中的元素个数,和向末尾追加元素所用的方法分别是什么？

　　len(list)/list.count()　　list.append()/list.insert(-1,i)

72. 判断 dict 中有没有某个 key 用的方法是什么？

  • key in dict
  • key in dict.keys() 判断

73. 填空

　　l=range(100)

　　1. 如何取第一到第三个元素用的是　　l[0:3]

　　2. 如何取倒数第二个元素　　　　　　l[-2]

　　3. 如何取后十个　　　　　　　　　　l[:-10:-1]

74. 如何判断一个变量是否是字符串？

type(s)==str

isinstance(s,str)

75. list 和 tuple 有什么不同？

list是一个可变的数据结构,能够进行增删改

tuple是一个不可变的数据结构,不能够进行增删改,可以存放一些重要的数据

76. a = dict(zip(("a","b","c","d","e"),(1,2,3,4,5))) 请问 a 是什么？

　　{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

77. 一行代码生成列表 [1,4,9,16,25,36,49,64,81,100]。

　　[pow(i,2) for i in range(1,11)]

78. 以下叙述正确的是

　　A. continue语句的作用是结束整个循环的执行

　　B. 只能在循环体和 switch语句体内使用 break语句

　　C. 在循环体内使用 break语句或者 continue语句的作用相同

　　D. 从多层循环嵌套中退出时, 只能使用 goto语句

79. 读代码

1. for i in range(5,0,-1):
2.　　print(i)

3. 请在下面写出打印结果
　　5
　　4
　　3
　　2
　　1

80. 写结果

1. x= "foo"
2. y = 2
3. print x+y　　

　　A. foo　　B. foo foo　　C. foo 2　　D. 2　　E. An exception is thrown

81. 求结果

1. kvps = {"1":1,"2":2}
2. theCopy = kvps
3. kvps["1"] = 5
4. sum = kvps["1"] + theCopy ["1"]
5. print sum

　　A. 1　　B. 2　　C. 7　　D. 10

82. python 里如何实现 tuple 和 list 的转化

　　list(t)　　tuple(l)

83. type(1+2L*3.14)的结果是

　　A. int 　　B. long　　C. float　　D. str

84. 若 k 为整型, 下列 while 循环执行的次数为

1. k = 1000
2. while k>1:
3.     print k
4.     k = k/2

python3中 循环执行次数是10次
python2中 循环执行次数是9次

85. 以下何者是不合法的布尔表达式

　　A. x in range(6)　　B. 3 = a　　C. e>5 and 4==f　　D. (x-6)>5

86. python 不支持的数据类型有

　　A. char　　B. int　　C. float　　D. list

87. 如何在 Python 中拷贝一个对象, 并说明他们之间的区别？

　 使用[:]这样就可以进行拷贝一个对象,这个是浅拷贝

使用copy模块 copy.copy这是浅拷贝
使用copy模块 copy.deepcopy 这是深拷贝
浅拷贝就是拷贝对象的一层元素.
深拷贝是拷贝对象里的多层元素

88. 99(10 进制)的八进制表示是什么？

　　print(oct(99))#0o143

89. 下列 Python 语句正确的是

1. min = x is x<y=y
2. max = x>y?x:y
3. if(x>y) print x
4. while True:pass 

90. list 对象 alist =[{'name':'a','age':20},{'name':'b','age':30},{'name':'v','age':25},]按 alist 中元素的 age 由大到小排序。　　

1 alist = [{'name': 'a', 'age': 20}, {'name': 'b', 'age': 30}, {'name': 'v', 'age': 25}, ]
2 print(sorted(alist,key=lambda x:x['age']))

91. 关于 Python 程序的运行性能方面, 有什么手段能提升性能？

　　

  1. 使用多进程，充分利用机器的多核性能
  2. 对于性能影响较大的部分代码，可以使用C或C++编写
  3. 对于IO阻塞造成的性能影响，可以使用IO多路复用来解决
  4. 尽量使用Python的内建函数5、尽量使用局部变量

92. Python 是如何进行内存管理的? Python 的程序会内存泄漏吗?说说有没有什么方面阻止或检测内存泄漏

　　　

　整体参考文章

  • python是如何进行内存管理的参考文章
    1. 引用计数
      • Python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，就是引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要的时候，这个对象的引用计数为0时，他被垃圾回收。
    2. 垃圾回收
      • 当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。他会去检查那些引用计数为0的对象，然后清除其在内存中的空间。当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉，当两个对象相互引用时，他们本身其他引用已经为0了。
    3. 内存池机制
      • Python提供了对内存的垃圾收集机制，但是他将不用的内存放到内存池而不是反回给操作系统。
  • python的程序会内存泄漏吗？
    • 会发生内存泄漏，在Python程序里，内存泄漏是由于一个长期持有的对象不断的往一个dict或者list对象里添加新的对象, 而又没有即时释放，就会导致这些对象占用的内存越来越多，从而造成内存泄漏。另外，对象的交叉引用也会造成内存无法释放的问题。
  • 说说有没有什么方面阻止或者检测内存泄漏？
    1. 程序员管理好每个python对象的引用，尽量在不需要使用对象的时候，断开所有引用
    2. 尽量少通过循环引用组织数据，可以改用weakref做弱引用或者用id之类的句柄访问对象
    3. 通过gc模块的接口可以检查出每次垃圾回收有哪些对象不能自动处理，再逐个逐个处理

93. 详细说说 tuple,list,dict 的用法, 他们的特点

   tuple 是用小括号()组成,没有增删改,是用于存放一些不修改的数据.里边存放的数据安全系数较高,特点是不可变

list  使用中括号[]组成,有增删改,是用于存放一些数据,经常修改的数据.特点是可变
dict  使用大括号{}组成,有增删改,是用于存放一些键值数据,特点是查找方便.能够准确的查找到

94. 一个大小为 100G 的文件 etl_log.txt, 要读取文件中的内容, 写出具体过程代码？

#方式一：一行一行读取
with open('etl_log.txt',encoding='utf-8')as f:
    for i in f:
        print(i,end='')
with open('etl_log.txt', encoding='utf-8')as f:
    for i in f.readlines():
        print(i, end='')
#方式二：按固定字节读取
import os
size=os.path.getsize('etl_log.txt')
n=1024
i=0
with open('etl_log.txt', encoding='utf-8')as f:
    while i<=size:
        print(f.read(n),end='')
        i+=n

95. 已知 Alist=[1,2,3,1,2,1,3],如何根据 Alist 得到[1,2,3]

1 Alist=[1,2,3,1,2,1,3]
2 #方式一：内置函数排序
3 print(sorted(list(set(Alist)),key=lambda x:x))
4 
5 #方式二：列表自带的排序方法
6 li=list(set(Alist))
7 li.sort()
8 print(li)

96. 已知 stra = 'wqedsfsdrfweedqwedqw'

　　1. 如何获取最后两个字符　　　　stra[:-3:-1]

　　2. 如何获取第二个和第三个字符　　stra[1:3]

97. 已知 Alist = ["a","b","'c'],将 Alist 转化为'a,b,c'的实现过程　　

1 Alist = ["a","b","c"]
2 print(",".join(Alist))

98. 已知 ip='192.168.0.100' 代码实现提取各部分并写入列表。　　

ip = '192.168.0.100'
print(ip.split('.'))

99. python 代码如何获取命令行参数？

import sys
print(sys.argv)

100. 写代码

1. tupleA = ("a","b","c","d","e")
2. tupleB = (1,2,3,4,5)
3. RES = {"a":1,"b":2,"c":3,"d":4,"e":5}

　　写出由 tupleA和 tupleB得到 res的及具体实现过程

tupleA = ("a","b","c","d","e")
tupleB = (1,2,3,4,5)

RES={i:j for i,j in zip(tupleA,tupleB)}
print(RES)

101. 选出一下表达式表述正确的选项

　　A. {1:0,2:0,3:0}　　B. {'1':0,'2':0,'3':0}　　C. {(1,2):0,(4,3):0}　　D. {[1,2]:0,[4,3]:0}　　E. {{1,2}:0,{4,3}:0}

102. what gets printde() ?

1. kvps = {"1":1,'2':2}
2. theCopy = kvps.copy()
3. kvps["1"] = 5
4. sum = kvps["1"] + theCopy["1"]
5. print sum

　　A. 1　　 B. 2　　 C. 6　　 D. 10 　　E. An execption is thrown

103. what gets printde() ?

1. numbers = [1,2,3,4]
2. numbers.append([5,6,7,8])
3. print len(numbers)

　　A. 4　　 B. 5 　　C. 8 　　D. 12　　E. An exception is thrown

104. what getsprintde() ?

1. names1 = ["Amir","Barry","Chaies","Dao"]
2. if "amir" in names1:
3.     print 1
4. else:
5.     print 2

　　A. 1 　　B. 2　　C. An exception is thrown

105.  print(type(1/2))

　　A. int　　B. float　　C. 0 　　D. 1　　E. 0.5

106. 以下用来管理 Python 库管理工具的是

　　A. APT　　B. PIP　　C. YUM　　D. MAVEN

107. which numbers are printed ()?

1. for i in range(2):
2.     print i
4. for i in range(4,6):
5.     print i

　　A. 2,4,6　　B. 0,1,2,4,5,6　　C. 0,1,4,5　　D. 0,1,4,5,6,7,8,9　　E. 1,2,4,5,6

108. 求结果

1. import math
2. print (math.floor(5.5))

　　A. 5　　B. 5.0　　C. 5.5　　D. 6　　E. 6.0

109. 关于 Python 的内存管理, 下列说法错误的是

　　A. 变量不必事先声明

　　B. 变量无需先创建和赋值而直接使用

　　C. 变量无需指定类型

　　D. 可以使用 del释放资源

110. 下面那个不是 Python 合法的标识符

　　A. int32　　B. 40xl　　C. self　　D. name

111. 下列哪种说法是错误的

　　A. 除字典类型外, 所有标准对象均可用于布尔测试　　B. 空字符串的布尔值是 False

　　C. 空列表对象的布尔值是 False　　　　　　　　　　D. 值为 0的任何数字对象的布尔值是 False

112. 下列表达是的值为 True 的是

　　A. 5+4j >2-3j　　B. 3>2>2　　C. (3,2)<("a","b")　　D. " abc" > 'xyz'

113. 关于 Python 的复数, 下列说法错误的是

　　A. 表示复数的语法是 real+imagej　　B. 实部和虚部都是浮点数

　　C. 虚部后缀必须是 j, 且必须小写　　D. 方法 conjugate返回复数的共轭复数

114. 关于字符串下列说法错误的是

　　A. 字符应视为长度为 1的字符串　　 B. 字符串以标志字符串的结束

　　C. 既可以用单引号, 也可以用双引号创建字符串　　D. 在三引号字符串中可以包含换行回车等特殊字符

115. 以下不能创建一个字典的语句是

　　A. dic1 = {}　　B. dic2 = {3:5}　　C. dic3 = {[1,2,3]:"usetc"}　　D. dic4 = {(1,2,3):"usetc"}

116. python 里面如何拷贝一个对象?(赋值,浅拷贝,深拷贝的区别)

赋值是两个对象使用的是一个内容
浅拷贝是将对象的第一层元素进行复制,开辟一个新的空间存放
深拷贝是将对象里多层元素进行复制,开辟一个新的空间存

117. 描述在 python 中的元祖,列表,字典的区别,并且分别写一段定义,添加,删除操作的代码片段。

　　

118. 选择结果

1. names1 = ["Amir","Barry","Chales","Dao"]
2. names2 = names1
3. names3 = names1[:]
4. name2[0] = "Alice"
5. names3[1] = "Bob"
6. sum = 0
7. for ls in (names1,names2,names3):
8.     if ls[0] == "Alice":
9.             sum+=1
10.     if ls[1]=="Bob":
11.         sum+=10
12. print sum

　　A. 11　　B. 12　　C. 21　　D. 22　　E. 23

119. 下面程序的输出结果是　　yes

1. x = True
2. y = False
3. z = False
4.if x or y and z:
5.     print 'yes'
6. else:
7.     print 'no'

120. 1 or 2 和 1 and 2 输出分别是什么? 为什么

1 or 2 输出 1
1 and 2 输出 2 
or 运算都为真的取or前面的(短路运算)
and 运算都为真的取and后面的

121. 1 <(2==2)和 1 <2==2 的结果分别是什么, 为什么　　

1<(2==2)这样的结果是False 是因为先算的括号里的内容
1<2==2 这样的结果是True 是因为这是一个简写 拆开来看是 1<2 and 2==2 所以结果是True

122. 如何打乱一个排好序的 list 对象 alist　　

    • 使用random.shuffle()

123. 如何查找一个字符串中特定的字符?find 和 index 的差异？　　

　　

  • 使用find和index方法查找
  1. find()方法：查找子字符串，若找到返回从0开始的下标值，若找不到返回-1
  2. index()方法：python 的index方法是在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过比find方法更好的是，如果查找不到子串，会抛出异常，而不是返回-1

124. 把 aaabbcccd 这种形式的字符串压缩成 a3b2c3d1 这种形式。

 1 s='aaabbcccd'
 2 #方法一：Counter计数
 3 from collections import Counter
 4 s1=''.join([i+str(j) for i,j in Counter(s).items()])
 5 print(s1)
 6 #方法二：集合去重
 7 print(''.join({i+str(s.count(i)) for i in s}))
 8 #方法三：for循环
 9 dic={}
10 for i in s:
11     if i in dic:
12         dic[i]+=1
13     else:
14         dic[i]=1
15 s1=''
16 for i,j in dic.items():
17     s1+=i
18     s1+=str(j)
19 print(s1)

125. Python 一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出 1000 以内的所有完数。

 1 num=[]
 2 for i in range(1001):
 3     lis = []
 4     for j in range(1, i//2+1):
 5         if i % j == 0:
 6             lis.append(j)
 7 
 8     if sum(lis)==i:
 9         num.append(i)
10 print(num)

126. 输入一个字符串, 输出该字符串中字符的所有组合.例如: 输入字符串"1,2,3", 则输出为 1,2,3,12,13,23,123(组合数, 不考虑顺序, 所以 12和 21是等价的)

　　

127. 执行以下代码后, i 和 n 的值为

1. int i=10;
2. int n=i++%5

　　A. 10, 0　　B. 10, 1　　C. 11, 0　　B. 11, 1

128. 执行以下代码段后,x 的值为

1. int x=10;
2. x+=x-=x-x;

　　A. 10　　B. 20　　C. 30　　D. 40

129. 对于一个非空字符串,判断其是否可以有一个子字符串重复多次组成,字符串只包含小写字母且长度不超过 10000

　　示例 1:

　　　　1. 输入"abab"　　2. 输出 True

　　　　3. 样例解释: 输入可由"ab"重复两次组成

　　示例 2:

　　　　1. 输入"abcabcabc"　　 2. 输出 True

　　　　3. 样例解释: 输入可由"abc"重复三次组成

　　示例 3:

　　　　1. 输入"aba"　　2. 输出 False

  • 不可变数据类型：对其中一个变量的值改变，另外一个变量的值也会改变 
1 def func(s):
2     for i in range(math.ceil(len(s)/2)):
3         s1=s[:i+1]
4         n,m= divmod(len(s),len(s1))
5         if m==0 and s1*n==s:
6             return True
7     return False
8 print(func('abababc'))

 


【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/open-yang/p/11240904.html