【直通BAT面试试题库集锦】python基础题

不少同学在就业的时候都非常的迷茫，生怕面试的时候面试题自己答不上来，下面上海老男孩IT教育一起【直通BAT面试试题库集锦】吧。

一 Python基础

1、入门

1.为什么学习 Python?

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

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

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

1.C语言，它既有高级语言的特点，又具有汇编语言的特点，它是结构式语言。C语言应用指针：可以直接进行靠近硬件的操作，但是C的指针操作不做保护，也给它带来了很多不安全的因素。C++在这方面做了改进，在保留了指针操作的同时又增强了安全性，受到了一些用户的支持，但是，由于这些改进增加语言的复杂度，也为另一部分所诟病。Java则吸取了C++的教训，取消了指针操作，也取消了C++改进中一些备受争议的地方，在安全性和适合性方面均取得良好的效果，但其本身解释在虚拟机中运行，运行效率低于C++/C。一般而言，C，C++，java被视为同一系的语言，它们长期占据着程序使用榜的前三名。
      C语言的优点：简洁紧凑、灵活方便；运算符丰富；数据类型丰富；表达方式灵活实用；允许直接访问物理地址，对硬件进行操作；生成目标代码质量高，程序执行效率高；可移植性好；表达力强；
      C语言的缺点：C语言的缺点主要表现在数据的封装性上，这一点使得C在数据的安全性上有很大缺陷，这也是C和C++的一大区别。 C语言的语法限制不太严格，对变量的类型约束不严格，影响程序的安全性，对数组下标越界不作检查等。从应用的角度，C语言比其他高级语言较难掌握。也就是说，对用C语言的人，要求对程序设计更熟练一些。

2.C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。 
C++不仅拥有计算机高效运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。
C++语言的程序因为要体现高性能，所以都是编译型的。但其开发环境，为了方便测试，将调试环境做成解释型的。即开发过程中，以解释型的逐条语句执行方式来进行调试，以编译型的脱离开发环境而启动运行的方式来生成程序最终的执行代码。
生成程序是指将源码（C++语句）转换成一个可以运行的应用程序的过程。如果程序的编写是正确的，那么通常只需按一个功能键，即可搞定这个过程。该过程实际上分成两个步骤。
第一步是对程序进行编译，这需要用到编译器（compiler）。编译器将C++语句转换成机器码(也称为目标码)；如果这个步骤成功，下一步就是对程序进行链接，这需要用到链接器（linker）。链接器将编译获得机器码与C++库中的代码进行合并。C++库包含了执行某些常见任务的函数（“函数”是子程序的另一种称呼）。例如，一个C++库中包含标准的平方根函数sqrt，所以不必亲自计算平方根。C++库中还包含一些子程序，它们把数据发送到显示器，并知道如何读写硬盘上的数据文件。 
 
 3. C#语言，C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。C#看起来与Java有着惊人的相似；它包括了诸如单一继承、接口、与Java几乎同样的语法和编译成中间代码再运行的过程。但是C#与Java有着明显的不同，它借鉴了Delphi的一个特点，与COM（组件对象模型）是直接集成的，而且它是微软公司 .NET windows网络框架的主角。首先，C# 和JAVA一样，简直就是照搬了C++的部分语法，因此，对于数量众多的C++程序员学习起来很容易上手，另外，对于新手来说，比C++要简单一些。其次，Windows是占垄断地位的平台，而开发Windows应用，当然微软的声音是不能忽略的。最重要的是，相对于C++，用C# 开发应用软件可以大大缩短开发周期，同时可以利用原来除用户界面代码之外的C++代码。

4. Java语言，Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台（即JavaSE, JavaEE, JavaME）的总称。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。
Java的优势，与传统程序不同，Sun 公司在推出 Java 之际就将其作为一种开放的技术。全球数以万计的 Java 开发公司被要求所设计的 Java软件必须相互兼容。“Java 语言靠群体的力量而非公司的力量”是Sun公司的口号之一，并获得了广大软件开发商的认同。这与微软公司所倡导的注重精英和封闭式的模式完全不同。Sun 公司对 Java 编程语言的解释是：Java 编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言。

5.php语言，PHP（PHP: Hypertext Preprocessor的缩写，中文名：“PHP：超文本预处理器”）是一种通用开源脚本语言。语法吸收了C语言、Java和Perl的特点，入门门槛较低，易于学习，使用广泛，主要适用于Web开发领域。
     特性：PHP 独特的语法混合了 C、Java、Perl 以及 PHP 自创新的语法；PHP可以比CGI或者Perl更快速的执行动态网页——动态页面方面，与其他的编程语言相比，PHP是将程序嵌入到HTML文档中去执行，执行效率比完全生成htmL标记的CGI要高许多，PHP具有非常强大的功能，所有的CGI的功能PHP都能实现； PHP支持几乎所有流行的数据库以及操作系统；最重要的是PHP可以用C、C++进行程序的扩展。

6.python语言，是一种面向对象、直译式计算机程序设计语言，Python语法简洁而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，它能够很轻松的把用其他语言制作的各种模块（尤其是C/C++）轻松地联结在一起。常见的一种应用情形是，使用python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中有特别要求的部分，用更合适的语言改写。
Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此，很多人还把Python作为一种“胶水语言”（glue language）使用。使用Python将其他语言编写的程序进行集成和封装。
5 简述解释型和编译型编程语言?

编译型（需要编译器，相当于用谷歌翻译）：编译型语言执行速度快，不依赖语言环境运行，跨平台差，如C，C++执行速度快，调试麻烦

解释型（需要解释器，相当于同声传译）：解释型跨平台好，一份代码，到处使用，缺点是执行速度慢，依赖解释器运行，如python，JAVA执行速度慢，调试方便 
6 Python 解释器种类以及特点?

## CPython

CPython是使用最广且被的Python解释器。本教程以CPython为准。当我们从Python官方网站下载并安装好Python 2.7后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。

## IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

## PyPy

PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

## Jython

Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

## IronPython

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
7 位和字节的关系?

8 bit = 1bytes
8 b、B、KB、MB、GB 的关系?

8bit = 1B
1024B = 1KB
1024KB = 1MB
1024MB = 1GB
9 请至少列举 5 个 PEP8 规范(越多越好)

- 使用space（空格）来表示缩进，而不要用tab（制表符）
- 和语法相关的每一层缩进都要用4个空格来表示
- 每行的字符数不应超过79
- 对于占据多行的长表达式来说，除了首行之外的其余各行都应该在通常的缩进级别之上再加上4个空格
- 文件中函数与类之间应该用两个空行隔开
- 在同一个类中，各方法之间应该用一个空行隔开
- 函数、变量及属性应该用小写字母来拼写，各单词之间以下划线相连，例如：`lowercase_underscore`
- 类中的实例方法（instance method），应该把首个参数命名为self，以表示该对象自身
- 类方法（class method）的首个参数，应该命名为cls，以表示该类自身
- 不要通过检测长度的方法（如if len(somelist) == 0）来判断somelist是否为[]或“”等空值，而是应该采用if not somelist,它会假定：空值会自动评估为False    
10 求结果:or and

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
---------------------------------
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 False and 1
>>>1 3 0 1 1 False
11.ascii、unicode、utf-8、gbk 区别?

ascii：
在计算机内部，所有信息最终都是一个二进制值。每一个二进制位（bit），有0和1两种状态，因此，8个二进制位可以组合出256种状态，这被称为字节（byte)。上个世纪60年代，美国制定了一套字符编码，对英文字符与二进制之间做了联系，这被称为ASCII码，一直沿用至今。
ASCII码一共规定了128个字符，比如SPACE是32，A是65，这128个符号只咱用了一个字节的后面七位，最前面的一位统一规定为0。

unicode：
世界上有多种编码方法，同一个二进制数字可以被解释称不同的符号。因此，在打开一个文本文件时候，就必须知道它的编码方式，用错误的编码方式打开，就会出现乱码。
Unicode编码，这是一种所有符号的编码。
Unicode显然是一个巨大的集合，现在的规模可以容纳100多万个符号。每个符号的编码都不一样，比如U+0041表示英语的大写字母A，U+4e25表示汉字严。
在Unicode庞大的字符集的优势下，还存在一个问题，比如一个汉字，“严”的Unicode是十六进制4e25，转成二进制足足有15位，也就是，这个符号需要2个字节，表示其他字符还存在3个字节或者更多。计算机怎么区别三个字节表示的是同一个符号而不是分开表示三个呢？如果Unicode统一规定，每个符号用3个字节表示，但是某些字母显然不需要3个，那么就浪费了空间，文本文件大小超出了很多，这显然是不合理的。直到UTF8字符编码出现了。

utf-8：
UTF8的最大特点是，它是一种变长编码，可以使用1-4个字节表示一个符号，根据不同的符号来变化字节长度。
UTF8编码规则只有两条：
1）对于单字节的符号，字节的第一位设为0，后面的7位为这个符号的Unicode码。因此，对于英文字母，UTF8编码和ASCII编码是相同的。
2）对于非单字节（假设字节长度为N）的符号，第一个字节的前N位都设为1，第N+1设为0，后面字节的前两位一律设为10，剩下的没有提及的二进制，全部为这个符号的Unicode码。

gbk：
GBK编码是对GB2312的扩展，完全兼容GB2312。采用双字节编码方案，剔出xx7F码位，共23940个码位，共收录汉字和图形符号21886个，GBK编码方案于1995年12月15日发布。它几乎完美支持汉字，因此经常会遇见GBK与Unicode的转换。

1，各个编码之间的二进制，是不能互相识别的，会产生乱码。

2，文件的存储，传输，不能是unicode （只能是utf-8 utf-16 gbk gbk2312 ascii等）
12.字节码和机器码的区别?

字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。
13.三元运算编写格式。

条件成立 if 条件 else 条件不成立
14.列举你了解的所有Python2和Python3的区别?

# py2
>>> print("hello", "world")
('hello', 'world')
# py3
>>> print("hello", "world")
hello world

py2：input_raw()
py3：input()

1/2的结果
py2：返回0
py3：返回0.5

py2：默认编码ascii
py3：默认编码utf-8

字符串
py2：unicode类型表示字符串序列，str类型表示字节序列
py3:：str类型表示字符串序列，byte类型表示字节序列

py2中函数用关键字global声明某个变量为全局变量，但是在嵌套函数中，想要给一个变量声明为非局部变量是没法实现的。
py3中，新增了关键字nonlocal,使得非局部变量成为可能
15.Py2 项目如何迁移成 py3?

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

a = 1
b = 2
------------------
a,b = b,a
17.Python3 和 Python2 中 int 和 long 的区别?

python2:
  int() # 整型
  long() # 长整型
python3中没有long类型，只有int类型
18.xrange 和 range 的区别?

xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。
注意：现在的python3中将以前的range取消了，而将xrange重新命名成了range！所以我们现在看到的range其实本质还是xrange~。
19.如何实现字符串的反转?如:name="wupeiqi"请反转为name= "iqiepuw" 。

name="wupeiqi"
name[::-1]
> 'iqiepuw'
20.文件操作时:xreadlines和readlines的区别?

readlines()是把文件的全部内容读到内存，并解析成一个list，当文件的体积很大的时候，需要占用很多内存

xreadlines()则直接返回一个iter(file)迭代器，在Python 2.3之后已经不推荐这种表示方法了.直接使用for循环迭代文件对象
21.列举布尔值为False的常见值?

0, [] , () , {} , '' , False , None
22.is 和==的区别?

is比较的是id
== 比较的是值
23.哪些情况下，y! = x - (x-y)会成立？

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

2、数据类型：

字典:

1.1 现有字典 dict={‘a’:24，‘g’:52，‘i’:12，‘k’:33}请按字典中的 value 值进行排序？

1. sorted(dict.items()，key = lambda x:x[1])
1.2 说一下字典和json的区别？

字典是一种数据结构，json是一种数据的表现形式，字典的key值只要是能hash的就行，json的必须是字符串

1.3 什么是可变、不可变类型？

可变不可变指的是内存中的值是否可以被改变，不可变类型指的是对象所在内存块里面的值不可以改变，有数值、字符串、元组；可变类型则是可以改变，主要有列表、字典。

1.4 存入字典里的数据有没有先后排序？

存入的数据不会自动排序，可以使用sort函数对字典进行排序。

1.5 字典推导式？

1. dict = {key: value for (key, value) in iterable}
1.6 现有字典 d={‘a’:24，’g’:52，’l’:12，’k’:33}请按字 典中的 value 值进行排序？

1. sorted(d.items()，key = lambda x:x[1])
1.7 描述下dict的item()方法与iteritems()的不同

字典的items方法作用：是可以将字典中的所有项，以列表方式返回。因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。

字典的iteritems方法作用：与items方法相比作用大致相同，只是它的返回值不是列表，而是一个迭代器。

"""
在Python2.x中，iteritems() 用于返回本身字典列表操作后的迭代器【Returns an iterator on all items(key/value pairs) 】，不占用额外的内存。

在Python 3.x 里面，iteritems()方法已经废除了。在3.x里用 items()替换iteritems() ，可以用于 for 来循环遍历。
"""

字符串

2.1 请反转字符串“aStr”?

1. print("aStr"[::-1])
2.2 将字符串"k:1|k1:2|k2:3|k3:4"，处理成Python字典：{k:1， k1:2， ... } # 字 典里的K作为字符串处理

1. str1 = "k:1|k1:2|k2:3|k3:4"
2. def str2dict(str1):
3.   dict1 = {}
4.   for iterms in str1.split('|'):
5.   key，value = iterms.split(':')
6.   dict1[key] = value
7.   return dict1
2.3 请按alist中元素的age由大到小排序

alist [{'name':'a'，'age':20}，{'name':'b'，'age':30}，{'name':'c'，'age':25}]

sorted(alist，key=lambda x:x['age']，reverse=True)
2.4 常用的字符串格式化哪几种？

name = '张三'
1）、占位符
s1 = "%s DSB 你好"%name
2）、format
s2 = '{} DSB 你好'.format(name)
3）、f-string（python3.6之后才有的特性）
s3 = f'{name} DSB 你好'
2.5 简述字符串驻留机制

对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副 
本。长字符串不遵守驻留机制。

驻留适用范围: 由数字，字符和下划线（_）组成的python标识符以及整数[-5,256]。 

列表

3.1 下面代码的输出结果将是什么？

list = ['a'， 'b'， 'c'， 'd'， 'e']
print(list[10:])
下面的代码将输出[]，不会产生IndexError错误。就像所期望的那样，尝试用超出成员的个数的index

来获取某个列表的成员。例如，尝试获取list[10]和之后的成员，会导致IndexError。

3.2 写一个列表生成式，产生一个公差为11的等差数列

1.print([x*11 for x in range(10)])
3.3 给定两个列表，怎么找出他们相同的元素和不同的元素?

1. list1 = [1，2，3]
2. list2 = [3，4，5]
3. set1 = set(list1)
4. set2 = set(list2)
5. print(set1&set2)
6. print(set1^set2)
3.4 请写出一段Python代码实现删除一个list里面的重复元素?

比较容易记忆的是用内置的set：

1. l1 = ['b'，'c'，'d'，'b'，'c'，'a'，'a']
2. l2 = list(set(l1))
如果想要保持他们原来的排序： 用list类的sort方法：

1. l1 = ['b'，'c'，'d'，'b'，'c'，'a'，'a']
2. l2 = list(set(l1))
3. l2.sort(key=l1.index)
4. print(l2)
也可以这样写：

1. l1 = ['b'，'c'，'d'，'b'，'c'，'a'，'a']
2. l2 = sorted(set(l1)，key=l1.index)
3. print(l2)
也可以用遍历：

1. l1 = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
2. l2 = []
3. for i in l1:
4.  if not i in l2:
5.   l2.append(i)
6. print(l2)
3.5 下面这段代码的输出结果是什么？请解释？

1. def extendlist(val, list=[]):
2.  list.append(val)
3.  return list
4. list1 = extendlist(10)
5. list2 = extendlist(123, []
6. list3 = extendlist('a')
7. print("list1 = %s" %list1)
8. print("list2 = %s" %list2)
9. print("list3 = %s" %list3)
10. 输出结果：
11. list1 = [10, 'a']
12. list2 = [123]
13. list3 = [10, 'a']
新的默认列表只在函数被定义的那一刻创建一次。当extendList被没有指定特定参数list调用时，这组list的值 随后将被使用。这是因为带有默认参数的表达式在函数被定义的时候被计算，不是在调用的时候被计算。

3.6 将以下3 个函数按照执行效率高低排序

1. def f1(lIn):
2.   l1 = sorted(lIn)
3.   l2 = [i for i in l1 if i<0.5]
4.   return [i*i for i in l2]
5. def f2(lIn):
6.   l1 = [i for i in l1 if i<0.5]
7.   l2 = sorted(l1)
8.   return [i*i for i in l2]
9. def f3(lIn):
10.  l1 = [i*i for i in lIn]
11.  l2 = sorted(l1)
12.  return [i for i in l1 if i<(0.5*0.5)]
按执行效率从高到低排列：f2、f1和f3。 要证明这个答案是正确的，你应该知道如何分析自己代码的性能。 Python中有一个很好的程序分析包，可以满足这个需求。

1. import random
2. import cProfile
3. lIn = [random.random() for i in range(100000)]
4. cProfile.run('f1(lIn)')
5. cProfile.run('f2(lIn)')
6. cProfile.run('f3(lIn)')
3. 7 有一个list["This","is","a","Boy","!"],所有元素都是字符串,对他进行大小写 无关的排序

l1 = ['This','is','a','Boy','!']
print(sorted(l1))

元组

tuple:元组，元组将多样的对象集合到一起，不能修改，通过索引进行查找，使用括号”()”;
应用场景：把一些数据当做一个整体去使用，不能修改；
集合

set:set集合，在Python中的书写方式为{}，集合与之前列表、元组类似，可以存储多个数据，但

是这些数据是不重复的。集合对象还支持union(联合), intersection(交), difference(差)和

sysmmetric_difference(对称差集)等数学运算.

快速去除列表中的重复元素

1. a = [11,22,33,33,44,22,55]
2. set(a)
3. {11, 22, 33, 44, 55}
交集：共有的部分

1.  a = {71,72,73,74,75}
2.  b = {72,74,75,76,77}
3.  a&b
4.  {72, 74, 75}
并集：总共的部分

1.  a = {21,22,23,24,25}
2.  b = {22,24,25,26,27}
3.  a | b
4.  {21, 22, 23, 24, 25, 26, 27}
差集：另一个集合中没有的部分

1.  a = {51,52,53,54,55}
2.  b = {52,54,55,56,57}
3.  b - a
4.  {66, 77}
对称差集(在a或b中，但不会同时出现在二者中)

1.  a = {91,92,93,94,95}
2.  b = {92,94,95,96,97}
3.  a ^ b
4.  {11, 33, 66, 77}
综合

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

字符串：repleace,strip,split,reverse,upper,lower,join.....

列表：append,pop,insert,remove,sort,count,index.....

元组：index,count,len(),dir()

字典：get,keys,values,pop,popitems,clear,update,items.....
2.is 和==的区别?

is比较的是id
== 比较的是值
3.什么是反射?以及应用场景?

在绝大多数语言当中都有反射机制的存在， 可以用字符串的方式去访问对象的属性，调用对象的方法（但是不能去访问方法），Python中一切皆对象，都可以使用反射

1）、反射机制是很多框架的基石。
2）、
4.简述Python的深浅拷贝?

copy()：浅copy，浅拷贝指仅仅拷贝数据集合的第一层数据

deepcopy():深copy,深拷贝指拷贝数据集合的所有层
5.Python 垃圾回收机制?

垃圾回收机制是自动帮助我们管理内存，清理垃圾的一种工具

1）、引用计数
当一个对象的引用被创建或者复制时，对象的引用计数加1；
当一个对象的引用被销毁时，对象的引用计数减1；
当对象的引用计数减少为0时，就意味着对象已经没有被任何人使用了，可以将其所占用的内存释放了。

优点：

简单、直观
实时性，只要没有了引用就释放资源。
缺点：

维护引用计数需要消耗一定的资源
循环应用时，无法回收。也正是因为这个原因，才需要通过标记-清理和分代收集机制来辅助引用计数机制。

2）、标记-清除
“标记-清除”不改动真实的引用计数，而是将
集合中对象的引用计数复制一份副本，改动该对象引用的副本。对于副
本做任何的改动，都不会影响到对象生命走起的维护。

3）、分代回收
将系统中的所有内存块根据其存活时间划分为不同的集合，
每一个集合就成为一个“代”，垃圾收集的频率随着“代”的存活时间的增大而减小。
也就是说，活得越长的对象，就越不可能是垃圾，就应该减少对它的垃圾收集频率。
那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量，
如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。
6.Python 的可变类型和不可变类型的区别?

值变ID不变为可变类型
值变ID变为不可变类型
7.填空题

1.获取 Python 解释器版本的方法是

import sys
print(sys.version)
2.如果模块是被导入的,__name__的值是.    文件名            , 如果模块是被直接执行的__name__的值是     __main__

3.Python 的内存管理中, 为了追踪内存中的对象, 使用了 id() 这一简单技术

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

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

import gc

gc.collect()
6.Python 的乘方运算符是.  **

8. lambda表达式格式以及应用场景？

匿名就是没有名字
def func(x,y,z=1):
    return x+y+z

匿名
lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
func=lambda x,y,z=1:x+y+z 
func(1,2,3)
#让其有名字就没有意义

与内置函数配合一起使用
9. *arg和**kwarg作用

*args用来接收溢出的位置参数，将接收的参数组织成元祖 **kwargs用来接收溢出的关键字参数，将接受的参数组织成字典

10.求结果

v = dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v) #{'k1': [666], 'k2': [666]}
v['k1'] = 777
print(v)#{'k1': 777, 'k2': [666]}
#第一次字典的两个k指向的是同一块内存地址，所以k1的内存地址追加666，
k2的值也同样会是666，
而当给k1赋值时，改变了k1指向的内存地址，所以这个时候，k2不会随之发生变化
11.一行代码实现9*9乘法表

print("\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) 
                
# 递归
def f(i):
     if i>=1:
        f(i-1)
        print(['%dx%d=%d'%(j,i,i*j) for j in range(1,i+1)])
        
if __name__=='__main__':
    f(9)
12.比较 a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别？

a与b两者值相等，而c中列表的每个元素是一个个的元祖形式 a,b元素均为数字，b中括号内没加逗号，所以仍然是数字

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

print(1 < (2 == 2))  --> False
print(1 < 2 == 2)  --> True
14.如何打乱一个排好序的 list 对象 alist

import random
random.shuffle(alist)
15.如何查找一个字符串中特定的字符?find 和 index 的差异?

1）、find()方法：查找子字符串，若找到返回从0开始的下标值，若找不到返回-1
2）、index()方法：在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过比find方法更好的是，如果查找不到子串，会抛出异常，而不是返回-1
3）、rfind和rindex方法用法和上面一样，只是从字符串的末尾开始查找
16.把 aaabbcccd 这种形式的字符串压缩成 a3b2c3d1 这种形式。

b={}
c=""
a="aaabbcccd"
for i in a:
    b[i]=b.get(i,0)+1
for i,t in b.items():
    c+=str(i)
    c+=str(t)
print(c)
17.Python 一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1+2+3.编程找出 1000 以内的所有完数。

from functools import reduce

def sum(a, b):
    return a + b

for i in range(2, 1001):
    l = [1]
    for j in range(2, int(i / 2 + 1)):
        if i % j == 0:
            l.append(j)
    if i == reduce(sum, l):
        print(i)
        print(l)
18.给你一个字符串，比如‘abc’，请打印出该字符串的所有排列组合：

以‘abc’为例，输出的结果应该是：'abc', 'acb', 'bac', 'bca', 'cab', 'cba'

def perm(s=''):
    if len(s) <= 1:
        return [s]
    sl = []  
    for i in range(len(s)):  
        for j in perm(s[0:i] + s[i + 1:]):  
            sl.append(s[i] + j)  
    return sl

def main():
    perm_nums = perm('abb')  
    no_repeat_nums = list(set(perm_nums))  # 去重
    print('perm_nums', len(perm_nums), perm_nums)
    print('no_repeat_nums', len(no_repeat_nums), no_repeat_nums)
    pass

if __name__ == '__main__':
    main()
19.执行以下代码段后,x 的值为

x = 10
x += x
x -= x - x
print(x)

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

示例 1:

\1. 输入"abab"  \2. 输出True  \3. 样例解释: 输入可由"ab"重复两次组成

示例 2:

\1. 输入"abcabcabc"  \2. 输出True  \3. 样例解释: 输入可由"abc"重复三次组成

示例 3:  \1. 输入"aba"

\2. 输出False

class Solution(object):
    def repeatedSubstringPattern(self, s):
        """
        :type s: str
        :rtype: bool
        """
        n = len(s)
        for i in range(1, n // 2 + 1):
            if n % i == 0:
                a = s[:i]
                j = i
                while j < n and s[j:j + i] == a:
                    j += i
                if j == n: return True

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

print([x * x for x in range(1, 11)])

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

Python的except用来捕获所有异常， 因为Python里面的每次错误都会抛出 一个异常，所以每个程序的错误都被当作一个运行时错误。
 
try:
    pass
except BaseException as e:
 
    print(e)
 
finally:
 
    pass
在python中如何抛出，捕获，处理异常？

raise Exception 触发抛出异常
用try和except语句来捕获异常
处理异常的方法有：
try ... except...else语句
finally子句，
with语句