学会这些Python美图技巧，就等着女朋友夸你吧

一、前言

Python中有许多用于图像处理的库，像是Pillow，或者是OpenCV。而很多时候感觉学完了这些图像处理模块没有什么用，其实只是你不知道怎么用罢了。今天就给大家带了一些美图技巧，让你的图美翻全场，朋友圈赞不绝口，女朋友也夸你，富贵你好厉害啊！

很多人学习python，不知道从何学起。

很多人学习python，掌握了基本语法过后，不知道在哪里寻找案例上手。

很多已经做案例的人，却不知道如何去学习更加高深的知识。

那么针对这三类人，我给大家提供一个好的学习平台，免费领取视频教程，电子书籍，以及课程的源代码！

QQ群：1097524789

二、模块安装

我们主要使用到OpenCV和Pillow，另外我们还会使用到wordcloud和paddlehub，我们先安装一下：

pip install opencv-python
pip install pillow
python -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple
pip install -i https://mirror.baidu.com/pypi/simple paddlehub
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple/ myqr

另外我使用的Python环境是3.7，知道这些我们就可以开始进行我们的美图之旅了。

三、图片美化

1、祛痘

还在为痘痘犯难，不敢拍照吗？有了这个你就不用怕了（虽然有p图软件，但是大家不要揭穿我）：

import cv2
level = 22    # 降噪等级
img = cv2.imread('girl.jpg')    # 读取原图
img = cv2.bilateralFilter(img, level, level*2, level/2)    # 美颜
cv2.imwrite('result.jpg', img)    

实际上，在光滑的脸蛋上，痘痘就可以视为一个噪点，而我们可以通过降噪的方式达到祛痘祛斑的效果，在OpenCV中就提供了相应的滤镜，我们只需要调用即可。原图和实现效果图对比如下：

可以看到脸上的斑明显是变少了。绅士们应该可以注意到，脖子下面的皮肤光滑了许多。不过头发细节被抹除了不少。我们可以通过调节level参数，调节效果。如果想效果更好，可以结合人脸识别，进行局部的祛痘处理。

2、词云——我不只是一张图

其实词云已经是老生常谈了，但是作美图中的姣姣者，还是有必要列出来的，因为一张词云所能包含的信息太多了：

from PIL import Image
import numpy as np
from wordcloud import WordCloud, ImageColorGenerator

# 读取背景图片
mask = np.array(Image.open('rose.png'))

# 定义词云对象
wc = WordCloud(
    # 设置词云背景为白色
    background_color='white',
    # 设置词云最大的字体
    max_font_size=30,
    # 设置词云轮廓
    mask=mask,
    # 字体路径，如果需要生成中文词云，需要设置该属性，设置的字体需要支持中文
    #font_path='msyh.ttc'
)
# 读取文本
text = open('article.txt', 'r', encoding='utf-8').read()
# 生成词云
wc.generate(text)
# 给词云上色
wc = wc.recolor(color_func=ImageColorGenerator(mask))
# 保存词云
wc.to_file('result.png')

其中article.txt为我们的词云的文本素材，而rose.png则是词云轮廓（该图片背景应该为严格的白色或者透明），原图和实现效果如下：

还是非常美的。更多详细内容可以参考https://blog.csdn.net/ZackSock/article/details/103517841。

3、风格迁移——努力变成你喜欢的样子

风格迁移，顾名思义就是将某一张图片的风格迁移到另一张图片上。比如我拍了一张白天的图片，但是我想要一张夜景的图片，那我们该怎么做呢？当然是等到晚上再拍了，不过除了这个方法，我们还可以下载一张夜景图片，将夜景效果迁移到我们的原图上。

风格迁移的实现需要使用深度学习才能实现，但是像我这样的菜鸡肯定是不会深度学习的啦，所以我们直接使用paddlehub中已经实现好的模型库：

import cv2
import paddlehub as hub
# 加载模型库
stylepro_artistic = hub.Module(name="stylepro_artistic")
# 进行风格迁移
im = stylepro_artistic.style_transfer(
    images=[{
            # 原图
            'content': cv2.imread("origin.jpg"),
            # 风格图
            'styles': [cv2.imread("style.jpg")]
        }],
    # 透明度
    alpha = 0.1
)
# 从返回的数据中获取图片的ndarray对象
im = im[0]['data']
# 保存结果图片
cv2.imwrite('result.jpg', im)

原图风格图和效果图如下：

左边是原图，中间是风格图，右边为效果图。上面的效果还算可以，但是不是每次都怎么成功，还是要多试试。

4、图中图——每一个像素都是你

这个相比上面的要复杂一些，我们需要准备图库，将这些图作素材，然后根据图片某个区域的主色调进行最适当的替换，代码如下：

import os
import cv2
import numpy as np

def getDominant(im):
    """获取主色调"""
    b = int(round(np.mean(im[:, :, 0])))
    g = int(round(np.mean(im[:, :, 1])))
    r = int(round(np.mean(im[:, :, 2])))
    return (b, g, r)

def getColors(path):
    """获取图片列表的色调表"""
    colors = []

    filelist = [path + i for i in os.listdir(path)]
    for file in filelist:
        im = cv2.imdecode(np.fromfile(file, dtype=np.uint8), -1)
        dominant = getDominant(im)
        colors.append(dominant)
    return colors

def fitColor(color1, color2):
    """返回两个颜色之间的差异大小"""
    b = color1[0] - color2[0]
    g = color1[1] - color2[1]
    r = color1[2] - color2[2]
    return abs(b) + abs(g) + abs(r)

def generate(im_path, imgs_path, box_size, multiple=1):
    """生成图片"""

    # 读取图片列表
    img_list = [imgs_path + i for i in os.listdir(imgs_path)]

    # 读取图片
    im = cv2.imread(im_path)
    im = cv2.resize(im, (im.shape[1]*multiple, im.shape[0]*multiple))

    # 获取图片宽高
    width, height = im.shape[1], im.shape[0]

    # 遍历图片像素
    for i in range(height // box_size+1):
        for j in range(width // box_size+1):

            # 图块起点坐标
            start_x, start_y = j * box_size, i * box_size

            # 初始化图片块的宽高
            box_w, box_h = box_size, box_size

            box_im = im[start_y:, start_x:]
            if i == height // box_size:
                box_h = box_im.shape[0]
            if j == width // box_size:
                box_w = box_im.shape[1]

            if box_h == 0 or box_w == 0:
                continue

            # 获取主色调
            dominant = getDominant(im[start_y:start_y+box_h, start_x:start_x+box_w])

            img_loc = 0
            # 差异，同主色调最大差异为255*3
            dif = 255 * 3

            # 遍历色调表，查找差异最小的图片
            for index in range(colors.__len__()):
                if fitColor(dominant, colors[index]) < dif:
                    dif = fitColor(dominant, colors[index])
                    img_loc = index

            # 读取差异最小的图片
            box_im = cv2.imdecode(np.fromfile(img_list[img_loc], dtype=np.uint8), -1)

            # 转换成合适的大小
            box_im = cv2.resize(box_im, (box_w, box_h))

            # 铺垫色块
            im[start_y:start_y+box_h, start_x:start_x+box_w] = box_im

            j += box_w
        i += box_h

    return im

if __name__ == '__main__':

    # 获取色调列表
    colors = getColors('表情包/')
    result_im = generate('main.jpg', '表情包/', 50, multiple=5)
    cv2.imwrite('C:/Users/zaxwz/Desktop/result.jpg', result_im)

关于实现，我后续会写文章详细分析。我们看看效果图：

图片我们还是可以看出人物的，但是某些地方颜色不太对，这就是根据我们图库来的了。我们放大图片就能看到上面几百张小图片。（当然你放大上面的图是看不到的，因为分辨率太低）

5、切换背景——带你去旅行

最近大家都宅家里，照片拍了不少，可惜背景全是沙发。遇到我就是你女朋友的福气，看我如何10行代码换图片背景：

from PIL import Image
import paddlehub as hub
# 加载模型
humanseg = hub.Module(name='deeplabv3p_xception65_humanseg')
# 抠图
results = humanseg.segmentation(data={'image':['xscn.jpeg']})
# 读取背景图片
bg = Image.open('bg.jpg')
# 读取原图
im = Image.open('humanseg_output/xscn.png').convert('RGBA')
im.thumbnail((bg.size[1], bg.size[1]))
# 分离通道
r, g, b, a = im.split()
# 将抠好的图片粘贴到背景上
bg.paste(im, (bg.size[0]-bg.size[1], 0), mask=a)
bg.save('xscn.jpg')

下面看看我们的效果：

6、九宫格——一张照片装不下你的美

很多人发照片都喜欢发九宫格，但是一般又没那么多照片，这个时候就需要用表情包占位了。对于技术宅，这种不合理的方式是绝不容许的，于是我们写下如下代码：

from PIL import Image
# 读取图片
im = Image.open('xscn.jpeg')
# 宽高各除 3，获取裁剪后的单张图片大小
width = im.size[0]//3
height = im.size[1]//3
# 裁剪图片的左上角坐标
start_x = 0
start_y = 0
# 用于给图片命名
im_name = 1
# 循环裁剪图片
for i in range(3):
    for j in range(3):
        # 裁剪图片并保存
        crop = im.crop((start_x, start_y, start_x+width, start_y+height))
        crop.save(str(im_name) + '.jpg')
        # 将左上角坐标的 x 轴向右移动
        start_x += width
        im_name += 1
    # 当第一行裁剪完后 x 继续从 0 开始裁剪
    start_x = 0
    # 裁剪第二行
    start_y += height

我们执行上面的代码后，就能生成名为1~9的图片，这些图片就是我们的九宫格图片，下面看看测试效果：

在这里插入图片描述

不得不说，小松菜奈是真的美。

7、图片二维码——冰冷的图里也饱含深情

有话想说又不敢说？来试试二维码吧，小小的图饱含深情：

from MyQR import myqr
myqr.run(
    words='http://www.baidu.com',    # 包含信息
    picture='lbxx.jpg',            # 背景图片
    colorized=True,            # 是否有颜色，如果为False则为黑白
    save_name='code.png'    # 输出文件名
)

效果图如下：

在这里插入图片描述

因为上面的二维码经过我的特殊处理，在你扫码的时候会发现上面是码中码中码，要扫很多遍才能获得最后结果，大家可以发挥自己的想象力，做出点有趣的东西。

本文列出53个Python面试问题，并且提供了答案，供数科学家和软件工程师们参考。              不久前，我作为“数据科学家”开始担任一个新的角色，实际上就是一位“Python工程师”。
如果我在面试前提前了解一下Python的线程生命周期，而不是它的Recommender System（推荐系统）的话，我可能会在面试中表现得更好。
为了帮助大家通过面试，下面我整理了我为Python面试/工作准备的问题，并提供了答案。大多数数据科学家都会编写大量的代码，所以这些问题/答案对科学家和工程师都同样适用。
无论你是一位面试官、还是准备应聘一份工作、或者只是想提高你的Python技能，这份清单对你来说都将是无价之宝。
问题是无序的。我们开始吧。

经典面试题与答案
1. 列表（list）和元组（tuple）有什么区别？

在我每一次应聘Python数据科学家的面试中，这个问题都会被问到。所以对这个问题的答案，我可以说是了如指掌。

• 列表是可变的。创建后可以对其进行修改。
• 元组是不可变的。元组一旦创建，就不能对其进行更改。
• 列表表示的是顺序。它们是有序序列，通常是同一类型的对象。比如说按创建日期排序的所有用户名，如["Seth", "Ema", "Eli"]。
• 元组表示的是结构。可以用来存储不同数据类型的元素。比如内存中的数据库记录，如(2, "Ema", "2020–04–16")（#id, 名称,创建日期）。

2. 如何进行字符串插值？
在不导入Template类的情况下，有3种方法进行字符串插值。

name =  Chris # 1. f stringsprint(f Hello {name} )# 2. % operatorprint( Hey %s %s  % (name, name))# 3. formatprint( "My name is {}".format((name)))

3. “is”和“==”有什么区别？
在我的Python职业生涯的早期，我认为它们是相同的，因而制造了一些bug。所以请大家听好了，“is”用来检查对象的标识(id)，而“==”用来检查两个对象是否相等。我们将通过一个例子说明。创建一些列表并将其分配给不同的名字。请注意，下面的b指向与a相同的对象。

a = [1,2,3]b = ac = [1,2,3]

下面来检查是否相等，你会注意到结果显示它们都是相等的。

print(a == b)print(a == c)#=> True#=> True

但是它们具有相同的标识（id）吗？答案是不。

print(a is b)print(a is c)#=> True#=> False

我们可以通过打印他们的对象标识（id）来验证这一点。

print(id(a))print(id(b))print(id(c))#=> 4369567560#=> 4369567560#=> 4369567624

你可以看到：c和a和b具有不同的标识（id）。
4. 什么是装饰器（decorator）？
这是每次面试我都会被问到的另一个问题。它本身就值得写一篇文章。如果你能自己用它编写一个例子，那么说明你已经做好了准备。
装饰器允许通过将现有函数传递给装饰器，从而向现有函数添加一些额外的功能，该装饰器将执行现有函数的功能和添加的额外功能。
我们将编写一个装饰器，该装饰器会在调用另一个函数时记录日志。
编写装饰器函数logging。它接受一个函数func作为参数。它还定义了一个名为log_function_called的函数，它先执行打印出一些“函数func被调用”的信息（print(f {func} called. )），然后调用函数func()。最后返回定义的函数。

def logging(func):  def log_function_called():    print(f {func} called. )    func()  return log_function_called

让我们编写其他两个函数，我们最终会将装饰器添加到其中（但还没有）。

def my_name():  print( chris )def friends_name():  print( naruto )my_name()friends_name()#=> chris#=> naruto

现在将装饰器添加到上面编写的两个函数之中。

@loggingdef my_name(): print( chris )@loggingdef friends_name(): print( naruto )my_name()friends_name()#=> <function my_name at 0x10fca5a60> called.#=> chris#=> <function friends_name at 0x10fca5f28> called.#=> naruto

现在，你了解了如何仅仅通过在其上面添加@logging（装饰器），就能够轻松地将日志添加到我们编写的任何函数中。
5. 解释Range函数
Range函数可以用来创建一个整数列表，一般用在for循环中。它有3种使用方法。
Range函数可以接受1到3个参数，参数必须是整数。
请注意：我已经将range的每种用法包装在一个递推式构造列表（list comprehension）中，以便我们可以看到生成的值。
用法1 - range(stop)：生成从0到参数“stop”之间的整数。

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

用法2 - range(start, stop) : 生成从参数“start”到“stop”之间的整数

[i for i in range(2,10)]#=> [2, 3, 4, 5, 6, 7, 8, 9]

用法3 - range(start, stop, step)：以参数“step”为步长，生成从“start”到“stop”之间的整数。

[i for i in range(2,10,2)]#=> [2, 4, 6, 8]

6. 定义一个名为car的类，它有两个属性：“color”和“speed”。然后创建一个实例并返回“speed”。

class Car :    def __init__(self, color, speed):        self.color = color        self.speed = speedcar = Car( red , 100mph )car.speed#=>  100mph

7. Python中的实例方法、静态方法和类方法有什么区别？
实例方法：接受self参数，并且与类的特定实例相关。
静态方法：使用装饰器 @staticmethod，与特定实例无关，并且是自包含的（不能修改类或实例的属性）。
类方法：接受cls参数，并且可以修改类本身。我们将通过一个虚构的CoffeeShop类来说明它们之间的区别。

class CoffeeShop:    specialty =  espresso 
    def __init__(self, coffee_price):        self.coffee_price = coffee_price
    # instance method    def make_coffee(self):        print(f Making {self.specialty} for ${self.coffee_price} )
    # static method        @staticmethod    def check_weather():        print( Its sunny )    # class method    @classmethod    def change_specialty(cls, specialty):        cls.specialty = specialty        print(f Specialty changed to {specialty} )

CoffeeShop类有一个属性specialty，默认值设为“espresso”。CoffeeShop类的每个实例初始化时都使用了coffee_price这个属性。同时，它还有3个方法，一个实例方法，一个静态方法和一个类方法。
让我们将coffee_price的值设为5，来初始化CoffeeShop的一个实例。然后调用实例方法make_coffee。

coffee_shop = CoffeeShop( 5 )coffee_shop.make_coffee()#=> Making espresso for $5

现在我们来调用静态方法。静态方法无法修改类或实例状态，因此通常用于工具函数，例如，把2个数字相加。我们这里用它来检查天气。天气晴朗。太好了！

coffee_shop.check_weather()#=> Its sunny

现在让我们使用类方法修改CoffeeShop的属性specialty，然后调用make_coffee()方法来制作咖啡。

coffee_shop.change_specialty( drip coffee )#=> Specialty changed to drip coffeecoffee_shop.make_coffee()#=> Making drip coffee for $5

注意，make_coffee过去是用来做意式浓缩咖啡（espresso）的，但现在用来做滴滤咖啡（drip coffee）了！
8. “func”和“ func()”有什么区别？
这个问题的目的是想看看你是否理解所有函数也是Python中的对象。

def func():    print( Im a function )
func#=> function __main__.func>func()    #=> Im a function

func是表示函数的对象，它可以被分配给变量或传递给另一个函数。带圆括号的func()调用该函数并返回其输出。
9. 解释map函数的工作原理。
Map函数返回一个列表，该列表由对序列中的每个元素应用一个函数时返回的值组成。

def add_three(x):    return x + 3li = [1,2,3][i for i in map(add_three, li)]#=> [4, 5, 6]

上面，我对列表中的每个元素的值加了3。
10. 解释reduce函数的工作原理。
这个问题很棘手，在你使用过它几次之前，你得努力尝试自己能够理解它。reduce接受一个函数和一个序列，然后对序列进行迭代。在每次迭代中，当前元素和前一个元素的输出都传递给函数。最后，返回一个值。

from functools import reducedef add_three(x,y):    return x + y    li = [1,2,3,5]    reduce(add_three, li)#=> 11

返回11，它是1 + 2 + 3 + 5的总和。

11.解释filter函数的工作原理
Filter函数顾名思义，是用来按顺序过滤元素。
每个元素都被传递给一个函数，如果函数返回True，则在输出序列中返回该元素；如果函数返回False，则将其丢弃。

def add_three(x):    if x % 2 == 0:        return True            else:        return Falseli = [1,2,3,4,5,6,7,8][i for i in filter(add_three, li)]#=> [2, 4, 6, 8]

注意上面所有不能被2整除的元素如何被删除的。
12. Python是按引用调用还是按值调用？
如果你在谷歌上搜索这个问题并阅读前几页，你就要准备好进入语义的迷宫了。你最好只是了解它的工作原理。
不可变对象（如字符串、数字和元组等）是按值调用的。请注意下面的例子，当在函数内部修改时，name的值在函数外部不会发生变化。name的值已分配给内存中该函数作用域的新块。

name =  chr def add_chars(s):   s +=  is    print(s)add_chars(name)    print(name)#=> chris#=> chr

可变对象（如列表等）是通过引用调用的。注意下面的例子中，函数外部定义的列表在函数内部的修改是如何影响到函数外部的。函数中的参数指向内存中存储li值的原始块。

li = [1,2]def add_element(seq):   seq.append(3)   print(seq)add_element(li)    print(li)#=> [1, 2, 3]#=> [1, 2, 3]

13. 如何使用reverse函数反转一个列表？
下面的代码对一个列表调用reverse()函数，对其进行修改。该方法没有返回值，但是会对列表的元素进行反向排序。

li = [ a , b , c ]print(li)li.reverse()print(li)#=> [ a ,  b ,  c ]#=> [ c ,  b ,  a ]

14. 字符串乘法是如何工作的？

让我们看看将字符串" cat"乘以3的结果。

 cat  * 3#=>  catcatcat

该字符串将自身连接3次。
15. 列表乘法是如何工作的?
我们来看看将列表[1,2,3]乘以2的结果。

[1,2,3] * 2#=> [1, 2, 3, 1, 2, 3]

输出的列表包含了重复两次的列表[1,2,3]的内容。
16. 类中的“self”指的是什么？
“self”引用类本身的实例。这就是我们赋予方法访问权限并且能够更新方法所属对象的能力。
下面，将self传递给__init__()，使我们能够在初始化时设置实例的颜色。

class Shirt:    def __init__(self, color):        self.color = color
s = Shirt( yellow )s.color#=>  yellow

17. 如何在Python中连接列表？
将2个列表相加，就是将它们连接在一起。但请注意，数组的工作方式不是这样的。

a = [1,2]b = [3,4,5]
a + b#=> [1, 2, 3, 4, 5]

18. 浅拷贝和深拷贝之间有什么区别？
我们将在一个可变对象（列表）的上下文中讨论这个问题，对于不可变的对象，浅拷贝和深拷贝的区别并不重要。
我们将介绍三种情况。
1. 引用原始对象。这将新对象li2指向li1所指向的内存中的同一位置。因此，我们对li1所做的任何更改也会在li2中发生。

li1 = [[ a ],[ b ],[ c ]]li2 = li1li1.append([ d ])print(li2)#=> [[ a ], [ b ], [ c ], [ d ]]

2. 创建原始对象的浅拷贝副本。我们可以使用list()构造函数来实现这一点。浅拷贝创建一个新对象，但是用对原始对象的引用填充它。因此，向原始列表li3中添加新对象不会传播到li4中，但是修改li3中的一个对象将传播到li4中。

li3 = [[ a ],[ b ],[ c ]]li4 = list(li3)li3.append([4])print(li4)#=> [[ a ], [ b ], [ c ]]li3[0][0] = [ X ]print(li4)#=> [[[ X ]], [ b ], [ c ]]

3. 创建一个深拷贝副本。这是用copy.deepcopy()完成的。现在，这两个对象是完全独立的，并且对其中一个对象所做的更改不会对另外一个对象产生影响。

import copyli5 = [[ a ],[ b ],[ c ]]li6 = copy.deepcopy(li5)li5.append([4])li5[0][0] = [ X ]print(li6)#=> [[ a ], [ b ], [ c ]]

19. 列表和数组有什么区别？
注意：Python的标准库有一个array（数组）对象，但在这里，我特指常用的Numpy数组。

• 列表存在于python的标准库中。数组由Numpy定义。
• 列表可以在每个索引处填充不同类型的数据。数组需要同构元素。
• 列表上的算术运算可从列表中添加或删除元素。数组上的算术运算按照线性代数方式工作。
• 列表还使用更少的内存，并显著具有更多的功能。

20. 如何连接两个数组？
记住，数组不是列表。数组来自Numpy和算术函数，例如线性代数。我们需要使用Numpy的连接函数concatenate()来实现。

import numpy as npa = np.array([1,2,3])b = np.array([4,5,6])np.concatenate((a,b))#=> array([1, 2, 3, 4, 5, 6])

21. 你喜欢Python的什么？
Python可读性很强，并且有一种Python方式可以处理几乎所有事情，这意味着它有一种简洁明了的首选方法。
我将Python与Ruby进行对比，Ruby通常有很多种方法来做某事，但是没有指南说哪种方法是首选。
22. 你最喜欢Python的哪个库？
在处理大量数据时，没有什么比Pandas（熊猫）更有帮助了，因为Pandas让操作和可视化数据变得轻而易举。
23. 举出几个可变和不可变对象的例子？
不可变意味着创建后不能修改状态。例如：int、float、bool、string和tuple。
可变意味着可以在创建后修改状态。例如列表（list）、字典（dict）和集合（set）。
24. 如何将一个数字四舍五入到小数点后三位？

使用round(value, decimal_places)函数。

a = 5.12345round(a,3)#=> 5.123

25. 如何分割一个列表？
分割语法使用3个参数，list[start:stop:step]，其中step是返回元素的间隔。

a = [0,1,2,3,4,5,6,7,8,9]print(a[:2])#=> [0, 1]print(a[8:])#=> [8, 9]print(a[2:8])#=> [2, 3, 4, 5, 6, 7]print(a[2:8:2])#=> [2, 4, 6]

26. 什么是pickling?
Pickling是Python中序列化和反序列化对象的常用方法。在下面的示例中，我们对一个字典列表进行序列化和反序列化。

import pickleobj = [   { id :1,  name : Stuffy },   { id :2,  name :  Fluffy }]with open( file.p ,  wb ) as f:   pickle.dump(obj, f)with open( file.p ,  rb ) as f:   loaded_obj = pickle.load(f)print(loaded_obj)#=> [{ id : 1,  name :  Stuffy }, { id : 2,  name :  Fluffy }]

27. 字典和JSON有什么区别？
Dict是Python的一种数据类型，是经过索引但无序的键和值的集合。
JSON只是一个遵循指定格式的字符串，用于传输数据。
28. 你在Python中使用了哪些ORM？
ORM（对象关系映射）将数据模型（通常在应用程序中）映射到数据库表，并简化了数据库事务。
SQLAlchemy通常用于Flask的上下文中，而Django拥有自己的ORM。
29. any()和all()如何工作?
Any接受一个序列，如果序列中的任何元素为true，则返回true。All只有当序列中的所有元素都为true时，才返回true。

a = [False, False, False]b = [True, False, False]c = [True, True, True]print( any(a) )print( any(b) )print( any(c) )#=> False#=> True#=> Trueprint( all(a) )print( all(b) )print( all(c) )#=> False#=> False#=> True

30. 字典和列表的查找速度哪个更快？
在列表中查找一个值需要O（n）时间，因为需要遍历整个列表，直到找到值为止。
在字典中查找一个值只需要O（1）时间，因为它是一个哈希表。
如果有很多值，这会造成很大的时间差异，因此通常建议使用字典来提高速度。但字典也有其他限制，比如需要唯一键。
 31. 模块（module）和包（package）有什么区别？
模块是可以一起导入的文件（或文件集合）。

import sklearn

包是模块的目录。

from sklearn import cross_validation

因此，包是模块，但并非所有模块都是包。
 32. 如何在Python中递增和递减一个整数？
可以使用“+=”和“-=”对整数进行递增和递减。

value = 5value += 1print(value)#=> 6value -= 1value -= 1print(value)#=> 4

33. 如何返回一个整数的二进制值？
使用bin()函数。

bin(5)#=>  0b101

34. 如何从列表中删除重复的元素？

可以通过将一个列表先转化为集合，然后再转化回列表来完成。

a = [1,1,1,2,3]a = list(set(a))print(a)#=> [1, 2, 3]

35. 如何检查一个值是不是在列表中存在？

使用“in”。

 a  in [ a , b , c ]
#=> True a  in [1,2,3]#=> False

36. append和extend有什么区别?

Append将一个值添加到一个列表中，而extend将另一个列表的值添加到一个列表中。

a = [1,2,3]b = [1,2,3]a.append(6)print(a)#=> [1, 2, 3, 6]b.extend([4,5])print(b)#=> [1, 2, 3, 4, 5]

37. 如何取一个整数的绝对值？
这可以通过abs()函数来实现。

abs(2#=> 2
abs(-2)#=> 2

38. 如何将两个列表组合成一个元组列表？

可以使用zip函数将列表组合成一个元组列表。这不仅仅限于使用两个列表。也适合3个或更多列表的情况。

a = [ a , b , c ]b = [1,2,3]
[(k,v) for k,v in zip(a,b)]#=> [( a , 1), ( b , 2), ( c , 3)]

39. 如何按字母顺序对字典进行排序？

你不能对字典进行排序，因为字典没有顺序，但是你可以返回一个已排序的元组列表，其中包含字典中的键和值。

d = { c :3,  d :4,  b :2,  a :1}
sorted(d.items())#=> [( a , 1), ( b , 2), ( c , 3), ( d , 4)]

40. 一个类如何继承Python的另一个类？

在下面的示例中，Audi继承自Car。继承带来了父类的实例方法。

class Car():    def drive(self):        print( vroom )class Audi(Car):    passaudi = Audi()audi.drive()

41. 如何删除字符串中的所有空白？

最简单的方法是使用空白拆分字符串，然后将拆分成的字符串重新连接在一起。

s =  A string with     white space   .join(s.split())#=>  Astringwithwhitespace

42. 在迭代序列时，为什么要使用enumerate()？
enumerate()允许在序列上迭代时跟踪索引。它比定义和递增一个表示索引的整数更具Python感。

li = [ a , b , c , d , e ]for idx,val in enumerate(li):   print(idx, val)#=> 0 a#=> 1 b#=> 2 c#=> 3 d#=> 4 e

43. pass、continue和break之间有什么区别?
pass意味着什么都不做。我们之所以通常使用它，是因为Python不允许在没有代码的情况下创建类、函数或if语句。
在下面的例子中，如果在i>3中没有代码的话，就会抛出一个错误，因此我们使用pass。

a = [1,2,3,4,5]for i in a:   if i > 3:       pass   print(i)#=> 1#=> 2#=> 3#=> 4#=> 5

Continue会继续到下一个元素并停止当前元素的执行。所以当i<3时，永远不会达到print(i)。

for i in a:   if i < 3:       continue   print(i)#=> 3#=> 4#=> 5

break会中断循环，序列不再重复下去。所以不会被打印3以后的元素。

for i in a:   if i == 3:       break   print(i)    #=> 1#=> 2

44. 如何将for循环转换为使用递推式构造列表（list comprehension）？
For循环如下：

a = [1,2,3,4,5]
a2 = []for i in a:    a2.append(i + 1)print(a2)#=> [2, 3, 4, 5, 6]

用递推式构造列表来修改这个for循环，代码如下：a

a3 = [i+1 for i in a]
print(a3)#=> [2, 3, 4, 5, 6]

递推式构造列表通常被认为更具Python风格，同时仍易于阅读。
45. 举一个使用三元运算符的例子。
三元运算符是一个单行的if/else语句。语法看起来像“if 条件 else b”。

x = 5y = 10 greater  if x > 6 else  less #=>  less  greater  if y > 6 else  less #=>  greater

46. 检查一个字符串是否仅仅包含数字？
可以使用isnumeric()方法。

 123abc... .isalnum()#=> False 
123abc .isalnum()#=> True

47. 检查一个字符串是否仅仅包含字母？
你可以使用isalpha()。

 123a .isalpha()#=> False a .isalpha()#=> True

48. 检查字符串是否只包含数字和字母？
你可以使用isalnum()。

 123abc... .isalnum()#=> False 123abc .isalnum()#=> True

49. 从字典返回键列表

这可以通过将字典传递给Python的list()构造函数list()来完成。

d = { id :7,  name : Shiba ,  color : brown ,  speed : very slow }list(d)#=> [ id ,  name ,  color ,  speed ]

50. 如何将一个字符串转化为全大写和全小写？
你可以使用upper()和lower()字符串方法。

small_word =  potatocake big_word =  FISHCAKE small_word.upper()#=>  POTATOCAKE big_word.lower()#=>  fishcake

51. remove、del和pop有什么区别?
remove() 删除第一个匹配的值。

li = [ a , b , c , d ]
li.remove( b )li#=> [ a ,  c ,  d ]

del按索引删除元素。

li = [ a , b , c , d ]
del li[0]li#=> [ b ,  c ,  d ]

pop() 按索引删除一个元素并返回该元素。

li = [ a , b , c , d ]
li.pop(2)#=>  c 
li#=> [ a ,  b ,  d ]

52. 举一个递推式构造字典（dictionary comprehension）的例子

下面我们将创建一个字典，其中字母表中的字母作为键，并以字母索引作为值。

# creating a list of lettersimport stringlist(string.ascii_lowercase)alphabet = list(string.ascii_lowercase)# list comprehensiond = {val:idx for idx,val in enumerate(alphabet)}d#=> { a : 0,#=>   b : 1,#=>   c : 2,#=> ...#=>   x : 23,#=>   y : 24,#=>   z : 25}

53. Python中的异常处理是如何进行的？
Python提供了3个关键字来处理异常，try、except和finally。语法如下：

try:        # try to do thisexcept:        # if try block fails then do thisfinally:        # always do this

在下面的简单示例中，try块失败，因为我们不能将字符串添加到整数中。except块设置val=10，然后finally块打印出“complete”。

try:    val = 1 +  A except:    val = 10finally:    print( complete )
print(val)#=> complete#=> 10

结束语
你永远不知道面试中会出现什么问题，最好的准备方法是拥有很多编写代码的经验。
也就是说，这个列表应该涵盖Python所要求的数据科学家或初级/中级Python开发人员角色的大部分内容。
我希望这对你一样有帮助。