python常见面试题 基础篇 (一)

Python基础篇

1：为什么学习Python
家里有在这个IT圈子里面，也想让我接触这个圈子，然后给我建议学的Python，
然后自己通过百度和向有学过Python的同学了解了Python，Python这门语言，入门比较简单，
它简单易学，生态圈比较强大，涉及的地方比较多，特别是在人工智能，和数据分析这方面。在未来我觉得是往自动化，
人工智能这方面发展的，所以学习了Python

2：通过什么途径学习Python
刚开始接触Python的时候，到网上里面跟着视频学基础，再后来网上到看技术贴，然后看到有人推荐廖雪峰的Python教程，
练项目到GitHub上面找一些小项目学习。

3：谈谈对Python和其他语言的区别

Python属于解释型语言，当程序运行时，是一行一行的解释，并运行，所以调式代码很方便，开发效率高，
还有龟叔给Python定位是任其自由发展、优雅、明确、简单，所以在每个领域都有建树，所有它有着非常强大的第三方库，
特点：
语法简洁优美，功能强大，标准库与第三方库都非常强大，而且应用领域也非常广
可移植性，可扩展性，可嵌入性
缺点：
　　运行速度慢，

• 解释型

  • python/php

• 编译型

  • c/java/c#

• Python弱类型
  （1）与java相比：在很多方面，Python比Java要简单，比如java中所有变量必须声明才能使用，而Python不需要声明,用少量的代码构建出很多功能;（高效的高级数据结构）

（2）与php相比：python标准包直接提供了工具，并且相对于PHP代码更易于维护;

（3）Python与c相比：

Python 和 C Python这门语言是由C开发而来

对于使用：Python的类库齐全并且使用简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多.
　　对于速度：Python的运行速度相较与C，绝逼是慢了

Python的优势：
1、Python 易于学习;

2、用少量的代码构建出很多功能;（高效的高级数据结构）

3、Python 拥有最成熟的程序包资源库之一;

4、Python完全支持面向对象;

5、Python 是跨平台且开源的。

6、动态类型:

4：简述解释型和编译型编程语言
解释型：就是边解释边执行（Python，php）
编译型：编译后再执行（c、java、c#）

5：Python的解释器种类以及相关特点？
CPython

是官方版本的解释器：CPython。是使用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。
CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
PyPy

由Python写的解释器，它的执行速度是最快。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），
绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。

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

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

小结：
　　Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

6：位和字节的关系
1字节 = 8 位
位（bit），数据存储是以“字节”（Byte）为单位，数据传输是以大多是以“位”（bit，又名“比特”）为单位，
一个位就代表一个0或1（即一个二进制），二进制是构成存储器的最小单位，每8个位（bit，简写为b）组成一个字节（Byte，简写为B），
字节是最小一级的信息单位

7：b、B、KB、MB、GB的关系
b —>位(bit)

B —>字节 一个字节等于8位

1B = 8 bit

1kb = 1024 B

1 MB = 1024 KB

1 GB = 1024 MB

8:PE8规范
1、使用4个空格而不是tab键进行缩进。
2、每行长度不能超过79
3、使用空行来间隔函数和类，以及函数内部的大块代码
4、必要时候，在每一行下写注释
5、使用文档注释，写出函数注释
6、在操作符和逗号之后使用空格，但是不要在括号内部使用
7、命名类和函数的时候使用一致的方式，比如使用CamelCase来命名类，
使用lower_case_with_underscores来命名函数和方法
8、在类中总是使用self来作为默认
9、尽量不要使用魔法方法
10、默认使用UTF-8，甚至ASCII作为编码方式
11、换行可以使用反斜杠，最好使用圆括号。
12、不要在一句import中多个库，
空格的使用
各种右括号前不要加空格。
逗号、冒号、分号前不要加空格。
函数的左括号前不要加空格。如Func(1)
序列的左括号前不要加空格。如list[2]
操作符左右各加一个空格，不要为了对齐增加空格
函数默认参数使用的赋值符左右省略空格
不要将多句语句写在同一行，尽管使用‘；’允许
if/for/while语句中，即使执行语句只有一句，也必须另起一行
函数命名使用全部小写的方式，常量命名使用大写，类属性（方法和变量）使用小写
类的命名首字母大写

9：通过代码实现如下转换(进制之间转换）

二进制转换成十进制–>int

v = “0b1111011”
b = int(v,2)
print(b) # 123

十进制转换成二进制—>bin

v2 = 18
print(bin(int(v2)))

0b10010

八进制转换成十进制

v3 = “011”
print(int(v3))

11

十进制转换成八进制：—> oct

v4 = 30
print(oct(int(v4)))

0o36

十六进制转换成十进制：

v5 = “0x12”
print(int(v5,16))

18

十进制转换成十六进制：—> hex

v6 = 87
print(hex(int(v6)))

0x57

10:请编写一个函数实现将IP地址转换成一个整数
请编写一个函数实现将IP地址转换成一个整数。
如 10.3.9.12 转换规则为：
10 00001010

     3            00000011

     9            00001001

    12            00001100

再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

def v1(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(v1(“127.0.0.1”))

[127, 0, 0, 1]

2130706433

---

11、python递归的最大层数？998

12：求结果(and or or)

1. 求结果：1 or 3
   print(1 or 3) # 1

2. 求结果：1 and 3
   print(1 and 3) # 3

3. 求结果：0 and 2 and 1
   print(0 and 2 and 1) # 0

4. 求结果：0 and 2 or 1
   print(0 and 2 or 1) # 1

5. 求结果：0 and 2 or 1 or 4
   print(0 and 2 or 1 or 4) # 1

6. 求结果：0 or Flase and 1
   print(0 or False and 1) # Flase

总结：
　　# x or y 如果 x为真，则值为x， 否则为y
　　# x and y 如果 x 为真，则值为 y，否则为 x

运算符

1. 求结果：2 & 5

print(2 & 5) # 10 & 101 => 000 => 0
2. 求结果：2 ^ 5

print(2 ^ 5) # 10 ^ 101 => 111 => 12**0+121+1*22=1+2+4=7

13 ：ascii、unicode、utf-8、gbk 区别

python2内容进行编码（默认ascii）,而python3对内容进行编码的默认为utf-8。
ascii 最多只能用8位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。
unicode 万国码，任何一个字符两个字节
utf-8 万国码的升级版 一个中文字符三个字节 英文是一个字节 欧洲的是 2个字节
gbk 国内版本 一个中文字符==2个字节 英文是一个字节
gbk 转 utf-8 需通过媒介 unicode

14:字节码和机器码的区别
机器码，学名机器语言指令，有时也被称为原生码，是电脑的CPU可直接解读的数据。

字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

什么是机器码

机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。
通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。

总结：机器码是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂，也比较难编写

什么是字节码
字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。
字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。

总结：字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

#is 比较的是内存地址
#== 比较的是值

int 具有范围：-5—256

#对于int 小数据池
范围：-5----256 创建的相间的数字，都指向同一个内存地址

#对于字符串 （面试）
1、小数据池 如果有空格，那指向两个内存地址，
2、长度不能超过 20
3、不能用特殊字符

i = ‘a’*20
j = ‘a’*20
print(i is j) # True

i = “a”*21
j = “a”*21
print(i is j) # False

关于编码所占字节
unicode： 所有字符（无论英文、中文等） 1个字符：2个字节
gbk：一个字符，英文1个字节，中文两个字节
utf-8：英文1个字节、 欧洲：2个字节， 亚洲：3个字节

在utf-8中，一个中文字符占用3个字节
在gbk中一个汉字占用2个字节
黎诗 = utf-8(6字节)=48
黎诗 = gbk(4字节)=32

字节和位的关系。
　　#一个字节(byte) = 8 位(bit)
　　# 位为最小的单位

简述变量命名规范
　　#1、以字母，数字，下划线任由结合
　　#2、不能以命名太长，不使用拼音，中文
　　#3、不能以数字开头
　　#4、不能用关键词

15:三元运算写法和应用场景？
应用场景：简化if语句

关于三元运算

结果+　if + 条件 + else + 结果

result=‘gt’ if 1>3 else ‘lt’
print(result) # lt

理解：如果条件为真，把if前面的值赋值给变量，否则把else后面的值赋值给变量。

lambda 表达式
temp = lambda x,y:x+y
print(temp(4,10)) # 14

可替代：
def foo(x,y):
return x+y
print(foo(4,10)) # 14

16:Python3和Python2的区别？
1：打印时，py2需要可以不需要加括号，py3 需要
python 2 ：print (‘lili’) , print ‘lili’
python 3 : print (‘lili’)
python3 必须加括号

exec语句被python3废弃，统一使用exec函数

2：内涵
Python2：1，臃肿，源码的重复量很多。
　 2，语法不清晰，掺杂着C，php，Java，的一些陋习。
Python3：几乎是重构后的源码，规范，清晰，优美。

3、输出中文的区别
python2：要输出中文 需加 # -- encoding:utf-8 --
Python3 ： 直接搞

4：input不同
python2 ：raw_input
python3 ：input 统一使用input函数

5：指定字节
python2在编译安装时，可以通过参数-----enable-unicode=ucs2 或-----enable-unicode=ucs4分别用于指定使用2个字节、4个字节表示一个unicode；
python3无法进行选择，默认使用 ucs4
查看当前python中表示unicode字符串时占用的空间：

impor sys
print（sys.maxunicode）
#如果值是65535，则表示使用usc2标准，即：2个字节表示
#如果值是1114111，则表示使用usc4标准，即：4个字节表示

6：
py2：xrange
　　　　range
py3：range 统一使用range，Python3中range的机制也进行修改并提高了大数据集生成效率

7：在包的知识点里
包：一群模块文件的集合 + init
区别：py2 ： 必须有__init__
　　　py3：不是必须的了

8：不相等操作符"<>“被Python3废弃，统一使用”!="

9：long整数类型被Python3废弃，统一使用int

10：迭代器iterator的next()函数被Python3废弃，统一使用next(iterator)

11：异常StandardError 被Python3废弃，统一使用Exception

12：字典变量的has_key函数被Python废弃，统一使用in关键词

13：file函数被Python3废弃，统一使用open来处理文件，可以通过io.IOBase检查文件类型

17：用一行代码实现数值交换
a = 1
b = 2

a, b = b, a

18：Python3和Python2中int和long区别
在python3里，只有一种整数类型int,大多数情况下，和python２中的长整型类似。

19：xrange和range的区别
都在循环时使用，xrange内存性能更好，xrange用法与range完全相同，range一个生成list对象，xrange是生成器

要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间。

在python2中：

range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列

例子
xrange用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。

例子
由上面的示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间，这两个基本上都是在循环的时候用。

在 Python 3 中，range() 是像 xrange() 那样实现，xrange()被抛弃。

20：文件操作时：xreadlines和readlines的区别？
readlines 返回一个列表

xreadlines 返回一个生成器

21： 列列举布尔值为False的常见值？
0，“”，{}，[],（），set（）
0 Flask 负数 不成立的表达式 None 等

22. 字符串、列表、元组、字典每个常用的5个方法？
    字符串：
    字符串用单引号(’)或双引号(")括起来，不可变
    1，find通过元素找索引，可切片，找不到返回-1
    2，index，找不到报错。
    3，split 由字符串分割成列表，默认按空格。
    4，captalize 首字母大写，其他字母小写。
    5，upper 全大写。
    6，lower 全小写。
    7，title，每个单词的首字母大写。
    8，startswith 判断以什么为开头，可以切片，整体概念。
    9，endswith 判断以什么为结尾，可以切片，整体概念。
    10，format格式化输出
    #format的三种玩法 格式化输出
    res=’{} {} {}’.format(‘egon’,18,‘male’) ==> egon 18 male
    res=’{1} {0} {1}’.format(‘egon’,18,‘male’) ==> 18 egon 18
    res=’{name} {age} {sex}’.format(sex=‘male’,name=‘egon’,age=18)
    11,strip 默认去掉两侧空格，有条件， 12，lstrip,rstrip 14,center 居中，默认空格。
    15，count查找元素的个数，可以切片，若没有返回0
    16，expandtabs 将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，
    17，replace（old，new,次数）
    18，isdigit 字符串由字母或数字组成 isalpha, 字符串只由字母组成 isalnum 字符串只由数字组成
    19,swapcase 大小写翻转
    20，for i in 可迭代对象。
    字典：
    1无序（不能索引）2：数据关联性强3:键值对，键值对。唯一一个映射数据类型。
    #字典的键必须是可哈希的 不可变类型。
    在同一个字典中，键(key)必须是唯一的。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
key： 输出所有的键
clear：清空
dic：删除的键如果没有则报错
pop：键值对删，有返回，没有原来的键会报错（自行设置返回键就不会报错）
popitem：随机删键值对
del：删除的键如果没有则报错
改 update
查 用get时。不会报错# 没有可以返回设定的返回值
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

列表：
索引，切片，加，乘，检查成员。
增加：有三种，
append：在后面添加。
Insert按照索引添加，
expend：迭代着添加。
list.extend(seq) - 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
pop 删除 (pop 有返回值)
remove 可以按照元素去删
clear 清空列表
del 1、可以按照索引去删除 2、切片 3、步长（隔着删）
改 1、索引 2、切片：先删除，再迭代着添加
list.count(obj) - 统计某个元素在列表中出现的次数
list.index(obj) - 从列表中找出某个值第一个匹配项的索引位置
list.reverse() - 反向列表中元素
list.sort([func]) - 对原列表进行排序
注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

元组：
（）元组的元素不能修改
1、cmp(tuple1, tuple2)：比较两个元组元素。
2、len(tuple)：计算元组元素个数。
3、max(tuple)：返回元组中元素最大值。
4、min(tuple)：返回元组中元素最小值。
5、tuple(seq)：将列表转换为元组。
注意
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

Set（集合）
：集合（set）是一个无序不重复元素的序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

23、 lambda表达式格式以及应用场景？
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数
函数名 = lambda 参数 ：返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

lambda 表达式
temp = lambda x,y:x+y
print(temp(4,10)) # 14

可替代：
def foo(x,y):
return x+y
print(foo(4,10)) # 14

24. pass的作用
    pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

25. *arg和**kwarg作用
    *args代表位置参数，它会接收任意多个参数并把这些参数作为元祖传递给函数。
    **kwargs代表的关键字参数，返回的是字典，位置参数一定要放在关键字前面

26. is和==的区别
    a = ‘lishi’
    str1 = “li”
    str2 = “shi”
    str3 = str1 + str2
    print(“a == str3”,a == str3)
    print(“a is str3”,a is str3)
    print(“id(a)”,id(a))
    print(“id(str3)”,id(str3))

a == str3 True == —> 只需要内容相等

a is str3 False is —> 只需要内存地址相等

id(a) 38565848

id(str3) 39110280

is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。

== 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了。默认会调用对象的 eq()方法。

27：谈谈Python的深浅拷贝？以及实现方法和应用场景。
浅拷贝只是增加了一个指针指向一个存在的地址，

而深拷贝是增加一个指针并且开辟了新的内存，这个增加的指针指向这个新的内存，
采用浅拷贝的情况，释放内存，会释放同一内存，深拷贝就不会出现释放同一内存的错误

一层的情况：

import copy

浅拷贝

li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]

深拷贝

li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]

多层的情况：

import copy

浅拷贝 指向共有的地址

li1 = [1, 2, 3,[4,5],6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]

深拷贝 重指向

li1 = [1, 2, 3,[4,5],6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6]

28. Python垃圾回收机制？
    引用计数

标记清除

分代回收

29. Python的可变类型和不可变类型？
    可变数据类型：列表、字典、可变集合

不可变数据类型：数字、字符串、元组、不可变集合

30、求结果
def multipliers():
return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])

def a():
return [lambda x:i*x for i in range(4)]
b=a() #返回个列表函数

b2

print(b1)

print(type(b),b)

print([m(1) for m in a()])
print([i*i for i in [1,2,3]])
[3, 3, 3, 3]
[1, 4, 9]

‘’’
def multipliers():
return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
#解释：
　　函数返回值为一个列表表达式，经过4次循环结果为包含四个lambda函数的列表，
由于函数未被调用，循环中的i值未被写入函数，经过多次替代，循环结束后i值为3，
故结果为：6,6,6,6

func=lambda x:x+1
print(func(1))
#2
print(func(2))
#3

#以上lambda等同于以下函数
def func(x):
return(x+1)
‘’’

请修改multipliers的定义来产生期望的结果（0,2,4,6）。
def multipliers():
return （lambda x:i*x for i in range(4)） #返回一个生成器表达式
print([m(2) for m in multipliers()])

-面试题2：
现有两个元组((‘a’),(‘b’)),((‘c’),(‘d’))，请使用python中匿名函数生成列表[{‘a’:‘c’},{‘b’:‘d’}]

#匿名函数形式：
l1=((‘a’),(‘b’))
l2=((‘c’),(‘d’))
ret=map(lambda n:{n[0]:n[1]},zip(l1,l2))
print(list(ret))
#列表表达式形式：
l1=((‘a’),(‘b’))
l2=((‘c’),(‘d’))
print([{n[0]:n[1]} for n in zip(l1,l2)])

31、求结果

v = dict.fromkeys([‘k1’, ‘k2’], [])
v[‘k1’].append(666)
print(v)
v[‘k1’] = 777
print(v)

结果：
{‘k1’: [666], ‘k2’: [666]}
{‘k1’: 777, ‘k2’: [666]}

解释：
Python 字典(Dictionary) fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值，默认为None。

v1 = dict.fromkeys([‘k1’, ‘k2’])
print(v1) # {‘k1’: None, ‘k2’: None}

v2 = dict.fromkeys([‘k1’, ‘k2’], [])
print(v2) # {‘k1’: [], ‘k2’: []}

32、列举常见的内置函数

abs（）
返回数字的绝对值

map
根据函数对指定序列做映射
map()函数接收两个参数，一个是函数，一个是可迭代对象，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

返回值：
　　Python2 返回列表
　　Python3 返回迭代器

例子1：
def mul(x):
return x*x
n=[1,2,3,4,5]
res=list(map(mul,n))
print(res) #[1, 4, 9, 16, 25]

例子2：abs() 返回数字的绝对值
ret = map(abs,[-1,-5,6,-7])
print(list(ret))

[1, 5, 6, 7]

filter
filter()函数接收一个函数 f(函数)和一个list（可迭代对象），这个函数 f的作用是对每个元素进行判断，返回 True或 False，
filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
def is_odd(x):
return x % 2 == 1

v=list(filter(is_odd, [1, 4, 6, 7, 9, 12, 17]))
print(v) #[1, 7, 9, 17]

map与filter总结

filter 与 map 总结

参数: 都是一个函数名 + 可迭代对象

返回值: 都是返回可迭代对象

区别:

filter 是做筛选的，结果还是原来就在可迭代对象中的项

map 是对可迭代对象中每一项做操作的，结果不一定是原来就在可迭代对象中的项

isinstance\type
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

例一

a = 2
print(isinstance(a,int)) # True
print(isinstance(a,str)) # False

type() 与 isinstance() 区别

class A:
pass

class B(A):
pass

print(“isinstance”,isinstance(A(),A)) # isinstance True
print(“type”,type(A()) == A) # type True

print(‘isinstance’,isinstance(B(),A) ) # isinstance True
print(‘type’,type(B()) == A) # type False
zip 拉链函数

zip 拉链函数，

将对象中对应的元素打包成一个个元组，

然后返回由这些元组组成的列表迭代器。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

print(list(zip([0,1,3],[5,6,7],[‘a’,‘b’])))

[(0, 5, ‘a’), (1, 6, ‘b’)]

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]

zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
reduce

‘’’
reduce() 函数
reduce() 函数会对参数序列中元素进行累积
函数将一个数据集合(链表、元组等)中的所有数据进行下列操作
‘’’

注意：
Python3已经将reduce() 函数从全局名字空间里移除了，它现在被放置在 fucntools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数：

from functools import reduce
def add(x,y):
return x + y

print(reduce(add,[1,2,3,4,5]))

15

print(reduce(lambda x, y: x+y, [1,2,3,4,5])) # 15

print(reduce(add,range(1,101)))

5050

33. filter、map、reduce的作用？

内置函数：map、reduce、filter的用法和区别
map:根据函数对指定序列做映射
map
参数
接收两个参数：一个是函数，一个是序列（可迭代对象）
返回值
Python2 返回列表
Python3 返回迭代器

例子：

abs() 函数返回数字的绝对值

新的内容的个数等于原内容的个数

ret = map(abs,[-1,-5,6,-7])

print(list(ret))

[1, 5, 6, 7]

filter:过滤函数 新的内容少于等于原内容的时候。才能使用filter
filter() 函数用于过滤序列，过滤不符合条件的元素，返回由符合条件元素组成的心列表

参数：
function 函数
iterable 可迭代对象
返回值:
返回列表

筛选大于10的数

def is_odd(x):
if x>10:
return True

ret = filter(is_odd,[1,4,5,7,8,9,76]) # 为迭代器
print(list(ret))

[76]

reduce:对于序列内所有元素进行累计操作
‘’’
reduce() 函数
reduce() 函数会对参数序列中元素进行累积
函数将一个数据集合(链表、元组等)中的所有数据进行下列操作
‘’’

from functools import reduce
def add(x,y):
return x + y

print(reduce(add,[1,2,3,4,5]))

15

print(reduce(lambda x, y: x+y, [1,2,3,4,5])) # 15

print(reduce(add,range(1,101)))

5050

34、 一行代码实现99乘法表
print(’\n’.join([’ ‘.join([’%s%s=%-2s’ % (j, i, i * j) for j in range(1, i + 1)]) for i in range(1, 10)]))

35. 如何安装第三方模块？以及用过哪些第三方模块？
    1：pip包管理器
    2：源码下载
    -下载
    -解压
    -python setup.py build
    -python setup.py install
    用过的第三方模块：requests,pymysql,DbUtils,SQLAlchemy等

36、 常用模块都有那些？
re模块，os模块，json模块，time模块，

爬虫里面的requests/beautifulsoup4（bs4）

37. re的match和search区别？
    re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.search 扫描整个字符串并返回第一个成功的匹配。

38. 什么是正则的贪婪匹配？
    匹配一个字符串没有节制，能匹配多少就去匹配多少，知道没有匹配的为止

39. 求结果：
    a. [ i % 2 for i in range(10) ]

print([ i % 2 for i in range(10) ]) # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
print([ i for i in range(10) ]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([ 10 % 2]) # [0]

%是个运算符。

b. ( i % 2 for i in range(10) )

print(( i % 2 for i in range(10) ))

<generator object at 0x00000000020CEEB8> 生成器

在Python中，有一种自定义迭代器的方式，称为生成器（Generator）。

定义生成器的两种方式：

1.创建一个generator，只要把一个列表生成式的[]改成()，就创建了一个generator：

generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，

没有更多的元素时，抛出StopIteration的错误。

2.定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，

而是一个generator

40. 求结果：
    a. 1 or 2
    b. 1 and 2
    c. 1 < (2==2)
    d. 1 < 2 == 2

1 or 2
1

1 and 2
2

1 < (2==2)
False

1 < 2 == 2
True