面试题之python基础

基础语法

输入和输出

• 代码中要修改不可变的数据会出现什么问题，抛出什么异常？

　　　　代码不会征程运行，抛出TypeError异常

• a = 1,b = 2，不用中间变量交换a和b的值？

　　　　

 # 方法1
 a = a + b
 b = a - b
 a = a -b

 #方法2：
  a = a^b
 b = b^a
 a = a^b

 #方法3
 a,b = b, a

• print调用python中底层的什么方法？

　　　　print方法默认调用sys.stdount.write方法,即往控制台打印字符串

• 下面这段代码的输出结果是什么？请解释

class Parent(object):
    x =1
class Child1(Parent):
    pass
class Child2(Parent):
    pass
print(Parent.x, Child1.x, Child2.x)
Child1.x =2
print(Parent.x, Child1.x, Child2.x)
parent.x = 3
print(Parent.x, Child1.x, Child2.x)

# 结果为 1 1 1 继承父类的类属性，所以都一样，只想同一块内存地址　　　　　
# 结果为1 2 1 更改child1，child1的x指向新的内存地址
# 结果为3 2 3 更改parent, parent的x指向新的内存地址

• 简述你对input()函数的理解？

　　　　在python3中, input()获取用户输入，无论用户输入什么，获取到的都是字符串的类型
　　　　在python2中， raw_input()和input(), raw_input()和python3的作用是一样的，input()是输入什么类型，获取到的就是什么数据类型的。

条件与循环　　

• 阅读下面的代码，写出A0，A1 至An 的最终值

1. A0 = dict(zip(('a'，'b'，'c'，'d'，'e')，(1，2，3，4，5)))
2. A1 = range(10)
3. A2 = [i for i in A1 if i in A0]
4. A3 = [A0[s] for s in A0]
5. A4 = [i for i in A1 if i in A3]
6. A5 = {i:i*i for i in A1}
7. A6 = [[i，i*i] for i in A1]

#1. A0 = {'a': 1， 'c': 3， 'b': 2， 'e': 5， 'd': 4}
#2. A1 = [0， 1， 2， 3， 4， 5， 6， 7， 8， 9]
#3. A2 = []
#4. A3 = [1， 3， 2， 5， 4]
#1. A4 = [1， 2， 3， 4， 5]
#2. A5 = {0: 0， 1: 1， 2: 4， 3: 9， 4: 16， 5: 25， 6: 36， 7: 49， 8: 64， 9: 81}
#3. A6 = [[0， 0]， [1， 1]， [2， 4]， [3， 9]， [4， 16]， [5， 25]， [6， 36]，[7， 49]，[8， 64] [9，81]]

• range 和xrange 的区别？

　　　　两者用法相同，不同的是range 返回的结果是一个列表，而xrange 的结果是一个生成器，前者是
　　　　直接开辟一块内存空间来保存列表，后者是边循环边使用，只有使用时才会开辟内存空间，所以当列表
　　　　很长时，使用xrange 性能要比range 好。

• 考虑以下Python 代码，如果运行结束，命令行中的运行结果是什么

　　

1. l = []
2. for i in xrange(10):
3. l.append({‘num’:i})
4. print l
# 在考虑以下代码，运行结束后的结果是什么？
1. l = []
2. a = {‘num’:0}
3. for i in xrange(10):
4. a[‘num’] = i
5. l.append(a)
6. print

#上方代码的结果：
1. [{‘num’:0}，{‘num’:1}，{‘num’:2}，{‘num’:3}，{‘num’:4}，{‘num’:5}，{‘num’:6}，{‘num’:7}，{‘num’:8}，
{‘num’:9}]
#下方代码结果：
1. [{‘num’:9}，{‘num’:9}，{‘num’:9}，{‘num’:9}，{‘num’:9}，{‘num’:9}，{‘num’:9}，{‘num’:9}，{‘num’:9}，
{‘num’:9}]

#原因是：字典是可变对象，在下方的l.append(a)的操作中是把字典a 的引用传到列表l 中，当后
续操作修改a[‘num’]的值的时候，l 中的值也会跟着改变，相当于浅拷贝。

文件操作　　

• 4G 内存怎么读取一个5G 的数据？

　　方法一：可以通过生成器，分多次读取，每次读取数量相对少的数据（比如500MB）进行处理，处理结束后在读取后面的500MB 的数据。       
 　　方法二：可以通过linux 命令split 切割成小文件，然后再对数据进行处理，此方法效率比较高。可以按照行数切割，可以按照文件大小切割。

• 现在考虑有一个jsonline 格式的文件file.txt 大小约为10K，之前处理文件的

　　代码如下所示：

1. def get_lines():
2. l = []
3. with open(‘file.txt’，‘rb’) as f:
4. for eachline in f:
5. l.append(eachline)
6. return l
7. if __name__ == ‘__main__’:
8. for e in get_lines():
9. process(e) #处理每一行数据

　　现在要处理一个大小为10G 的文件，但是内存只有4G，如果在只修改get_lines 函数而其他代
　　码保持不变的情况下，应该如何实现？需要考虑的问题都有哪些？

1. def get_lines():
2. l = []
3. with open(‘file.txt’，’rb’) as f:
4. data = f.readlines(60000)
5. l.append(data)
6. yield l

#要考虑到的问题有：
#内存只有4G 无法一次性读入10G 的文件，需要分批读入。分批读入数据要记录每次读入数据#的位
#置。分批每次读入数据的大小，太小就会在读取操作上花费过多时间。

• read、readline 和readlines 的区别?

　　　　read:读取整个文件。
　　　　readline：读取下一行，使用生成器方法。
　　　　readlines：读取整个文件到一个迭代器以供我们遍历。

• 补充缺失的代码？

1．def print_directory_contents(sPath):
2． """
3． 这个函数接收文件夹的名称作为输入参数
4． 返回该文件夹中文件的路径
5． 以及其包含文件夹中文件的路径
6． """
7． # 补充代码
8． ------------代码如下--------------------
9． import os
10． for sChild in os.listdir(sPath):
11． sChildPath = os.path.join(sPath, sChild)
12． if os.path.isdir(sChildPath):
13． print_directory_contents(sChildPath)
14． else:
15． print(sChildPath)

异常

• 在except 中return 后还会不会执行finally 中的代码？怎么抛出自定义异常？
  #会继续处理finally 中的代码；用raise 方法可以抛出自定义异常
• 介绍一下except 的作用和用法？

  xcept: #捕获所有异常
  except: <异常名>: #捕获指定异常
  except:<异常名1, 异常名2> : 捕获异常1 或者异常2
  except:<异常名>,<数据>:捕获指定异常及其附加的数据
  except:<异常名1,异常名2>:<数据>:捕获异常名1 或者异常名2,及附加的数据

模块与包

• 常用的Python 标准库都有哪些？

  os 操作系统，time 时间，random 随机，pymysql 连接数据库，threading 线程，multiprocessing进程，query队列

  os 操作系统，time 时间，random 随机，pymysql 连接数据库，threading 线程，multiprocessing
  进程，queue 队列。
  第三方库：
  django 和flask 也是第三方库，requests，virtualenv，selenium，scrapy，xadmin，celery，
  re，hashlib，md5。
  常用的科学计算库（如Numpy，Scipy，Pandas)。

• 赋值、浅拷贝和深拷贝的区别？

  一、赋值
  在Python 中，对象的赋值就是简单的对象引用，这点和C++不同，如下所示：
  16．a = [1,2,"hello",['python', 'C++']]
  17．b = a
  在上述情况下，a 和b 是一样的，他们指向同一片内存，b 不过是a 的别名，是引用。
  我们可以使用b is a 去判断，返回True，表明他们地址相同，内容相同，也可以使用id()函数来查
  看两个列表的地址是否相同。
  赋值操作(包括对象作为参数、返回值)不会开辟新的内存空间，它只是复制了对象的引用。也就是
  说除了b 这个名字之外，没有其他的内存开销。修改了a，也就影响了b，同理，修改了b，也就影响
  了a。
  二、浅拷贝(shallow copy)
  浅拷贝会创建新对象，其内容非原对象本身的引用，而是原对象内第一层对象的引用。
  浅拷贝有三种形式:切片操作、工厂函数、copy 模块中的copy 函数。
  比如上述的列表a；
  切片操作：b = a[:] 或者b = [x for x in a]；
  工厂函数：b = list(a)；
  copy 函数：b = copy.copy(a)；
  浅拷贝产生的列表b 不再是列表a 了，使用is 判断可以发现他们不是同一个对象，使用id 查看，
  他们也不指向同一片内存空间。但是当我们使用id(x) for x in a 和id(x) for x in b 来查看a 和b 中元
  素的地址时，可以看到二者包含的元素的地址是相同的。
  在这种情况下，列表a 和b 是不同的对象，修改列表b 理论上不会影响到列表a。
  但是要注意的是，浅拷贝之所以称之为浅拷贝，是它仅仅只拷贝了一层，在列表a 中有一个嵌套的
  list，如果我们修改了它，情况就不一样了。
  比如：a[3].append('java')。查看列表b，会发现列表b 也发生了变化，这是因为，我们修改了嵌
  套的list，修改外层元素，会修改它的引用，让它们指向别的位置，修改嵌套列表中的元素，列表的地
  址并未发生变化，指向的都是用一个位置。
  三、深拷贝(deep copy)
  深拷贝只有一种形式，copy 模块中的deepcopy()函数。
  深拷贝和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。因此，它的时间和空
  间开销要高。
  同样的对列表a，如果使用b = copy.deepcopy(a)，再修改列表b 将不会影响到列表a，即使嵌
  套的列表具有更深的层次，也不会产生任何影响，因为深拷贝拷贝出来的对象根本就是一个全新的对象，
  不再与原来的对象有任何的关联。
  四、拷贝的注意点？
  对于非容器类型，如数字、字符，以及其他的“原子”类型，没有拷贝一说，产生的都是原对象的
  引用。
  如果元组变量值包含原子类型对象，即使采用了深拷贝，也只能得到浅拷贝。

• __init__ 和__new__的区别？

  init 在对象创建后，对对象进行初始化。
  new 是在对象创建之前创建一个对象，并将该对象返回给init。

• Python 里面如何生成随机数？

  在Python 中用于生成随机数的模块是random，在使用前需要import. 如下例子可以酌情列
  举：
  random.random()：生成一个0-1 之间的随机浮点数；
  random.uniform(a, b)：生成[a,b]之间的浮点数；
  random.randint(a, b)：生成[a,b]之间的整数；
  random.randrange(a, b, step)：在指定的集合[a,b)中，以step 为基数随机取一个数；

  random.choice(sequence)：从特定序列中随机取一个元素，这里的序列可以是字符串，列表，
  元组等。

• 输入某年某月某日，判断这一天是这一年的第几天？(可以用Python 标准
  库)

  1. import datetime
  2. def dayofyear():
  3. year = input("请输入年份：")
  4. month = input("请输入月份：")
  5. day = input("请输入天：")
  6. date1 = datetime.date(year=int(year)，month=int(month)，day=int(day))
  7. date2 = datetime.date(year=int(year)，month=1，day=1)
  8. return (date1 - date2 + 1).days

• 打乱一个排好序的list 对象alist？

  1. import random
  2. random.shuffle(alist)

• 说明一下os.path 和sys.path 分别代表什么？

  os.path 主要是用于对系统路径文件的操作。
  sys.path 主要是对Python 解释器的系统环境参数的操作（动态的改变Python 解释器搜索路径）。

• Python 中的os 模块常见方法？

  os.remove()删除文件
  os.rename()重命名文件
  os.walk()生成目录树下的所有文件名
  os.chdir()改变目录
  os.mkdir/makedirs 创建目录/多层目录
  os.rmdir/removedirs 删除目录/多层目录
  os.listdir()列出指定目录的文件
  os.getcwd()取得当前工作目录
  os.chmod()改变目录权限
  os.path.basename()去掉目录路径，返回文件名
  os.path.dirname()去掉文件名，返回目录路径
  os.path.join()将分离的各部分组合成一个路径名
  os.path.split()返回（dirname(),basename())元组
  os.path.splitext()(返回filename,extension)元组
  os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间
  os.path.getsize()返回文件大小
  os.path.exists()是否存在
  os.path.isabs()是否为绝对路径
  os.path.isdir()是否为目录
  os.path.isfile()是否为文件

• Python 的sys 模块常用方法？

  sys.argv 命令行参数List，第一个元素是程序本身路径
  sys.modules.keys() 返回所有已经导入的模块列表
  sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback 当前处理的异常详细信息
  sys.exit(n) 退出程序，正常退出时exit(0)
  sys.hexversion 获取Python 解释程序的版本值，16 进制格式如：0x020403F0
  sys.version 获取Python 解释程序的版本信息
  sys.maxint 最大的Int 值
  sys.maxunicode 最大的Unicode 值
  sys.modules 返回系统导入的模块字段，key 是模块名，value 是模块
  sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH 环境变量的值
  sys.platform 返回操作系统平台名称
  sys.stdout 标准输出
  sys.stdin 标准输入
  sys.stderr 错误输出
  sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
  sys.exec_prefix 返回平台独立的python 文件安装的位置
  sys.byteorder 本地字节规则的指示器，big-endian 平台的值是'big',little-endian 平台的值是'little'
  sys.copyright 记录python 版权相关的东西
  sys.api_version 解释器的C 的API 版本
   sys.version_info 元组则提供一个更简单的方法来使你的程序具备Python 版本要求功能

• unittest 是什么？

  在Python 中，unittest 是Python 中的单元测试框架。它拥有支持共享搭建、自动测试、在测试中暂停代码，将不同测试迭代成一组的功能

• 模块和包是什么？

  在Python 中，模块是搭建程序的一种方式。每一个Python 代码文件都是一个模块，并可以引用其他的的模块，比如对象和属性
  一个包含许多Python 代码的文件夹是一个包。一个包可以包含模块和子文件夹。

Python 特性

• Python 是强语言类型还是弱语言类型？

  Python 是强类型的动态脚本语言。
  强类型：不允许不同类型相加。
  动态：不使用显示数据类型声明，且确定一个变量的类型是在第一次给它赋值的时候。
  脚本语言：一般也是解释型语言，运行代码只需要一个解释器，不需要编译。

• 谈一下什么是解释性语言，什么是编译性语言?

  计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。

  解释性语言在运行程序的时候才会进行翻译。
  编译型语言写的程序在执行之前，需要一个专门的编译过程，把程序编译成机器语言（可执行文件

• Python 中有日志吗?怎么使用?

  Python 自带logging 模块，调用logging.basicConfig()方法，配置需要的日志等级和相应的参数，
  Python 解释器会按照配置的参数生成相应的日志。

• Python 是如何进行类型转换的？

  内建函数封装了各种转换函数，可以使用目标类型关键字强制类型转换，进制之间的转换可以用
  int(‘str’，base=’n’)将特定进制的字符串转换为十进制，再用相应的进制转换函数将十进制转换
  为目标进制。
  可以使用内置函数直接转换的有：
  list---->tuple tuple(list)
  tuple---->list list(tuple)

• Python2 与Python3 的区别？

  1. Python3 对Unicode 字符的原生支持。
  Python2 中使用ASCII 码作为默认编码方式导致string 有两种类型str 和unicode，Python3 只
  支持unicode 的string。
  2. Python3 采用的是绝对路径的方式进行import。
  Python2 中相对路径的import 会导致标准库导入变得困难（想象一下，同一目录下有file.py，如
  何同时导入这个文件和标准库file）。Python3 中这一点将被修改，如果还需要导入同一目录的文件必
  须使用绝对路径，否则只能使用相关导入的方式来进行导入。
  3. Python2 中存在老式类和新式类的区别，Python3 统一采用新式类。新式类声明要求继承object，
  必须用新式类应用多重继承。
  4. Python3 使用更加严格的缩进。Python2 的缩进机制中，1 个tab 和8 个space 是等价的，所
  以在缩进中可以同时允许tab 和space 在代码中共存。这种等价机制会导致部分IDE 使用存在问题。
  Python3 中1 个tab 只能找另外一个tab 替代，因此tab 和space 共存会导致报错：TabError:
  inconsistent use of tabs and spaces in indentation.

  2) 废弃类差异
  1. print 语句被Python3 废弃，统一使用print 函数
  2. exec 语句被python3 废弃，统一使用exec 函数
  3. execfile 语句被Python3 废弃，推荐使用exec(open("./filename").read())
  4. 不相等操作符"<>"被Python3 废弃，统一使用"!="
  5. long 整数类型被Python3 废弃，统一使用int
  6. xrange 函数被Python3 废弃，统一使用range，Python3 中range 的机制也进行修改并提高
  了大数据集生成效率
  7. Python3 中这些方法再不再返回list 对象：dictionary 关联的keys()、values()、items()，zip()，
  map()，filter()，但是可以通过list 强行转换：
  1. mydict={"a":1,"b":2,"c":3}
  2. mydict.keys() #<built-in method keys of dict object at 0x000000000040B4C8>
  3. list(mydict.keys()) #['a', 'c', 'b']
  8. 迭代器iterator 的next()函数被Python3 废弃，统一使用next(iterator)
  9. raw_input 函数被Python3 废弃，统一使用input 函数
  10. 字典变量的has_key 函数被Python 废弃，统一使用in 关键词
  11. file 函数被Python3 废弃，统一使用open 来处理文件，可以通过io.IOBase 检查文件类型
  12. apply 函数被Python3 废弃
  13. 异常StandardError 被Python3 废弃，统一使用Exception

  3) 修改类差异
  1. 浮点数除法操作符“/”和“//”的区别
  “ / ”：
  Python2：若为两个整形数进行运算，结果为整形，但若两个数中有一个为浮点数，则结果为
  浮点数；
  Python3:为真除法，运算结果不再根据参加运算的数的类型。
  “//”：
  Python2：返回小于除法运算结果的最大整数；从类型上讲，与"/"运算符返回类型逻辑一致。
  Python3：和Python2 运算结果一样。
  2. 异常抛出和捕捉机制区别
  Python2
  1. raise IOError, "file error" #抛出异常
  2. except NameError, err: #捕捉异常
  Python3
  1. raise IOError("file error") #抛出异常
  2. except NameError as err: #捕捉异常
  Python2，for 循环会修改外部相同名称变量的值
  1. i = 1
  2. print （'comprehension: ', [i for i in range(5)]）
  3. print （'after: i =', i ） #i=4
  Python3，for 循环不会修改外部相同名称变量的值
  1. i = 1
  2. print （'comprehension: ', [i for i in range(5)]）
  3. print （'after: i =', i ） #i=1
  4. round 函数返回值区别
  Python2，round 函数返回float 类型值
  1. isinstance(round(15.5),int) #True
  Python3，round 函数返回int 类型值
  1. isinstance(round(15.5),float) #True
  5. 比较操作符区别
  Python2 中任意两个对象都可以比较
  1. 11 < 'test' #True
  Python3 中只有同一数据类型的对象可以比较
  1. 11 < 'test' # TypeError: unorderable types: int() < str()

  第三方工具包差异
  我们在pip 官方下载源pypi 搜索Python2.7 和Python3.5 的第三方工具包数可以发现，Python2.7
  版本对应的第三方工具类目数量是28523,Python3.5 版本的数量是12457，这两个版本在第三方工具
  包支持数量差距相当大。
  我们从数据分析的应用角度列举了常见实用的第三方工具包（如下表），并分析这些工具包在
  Python2.7 和Python3.5 的支持情况：
  分类工具名用途
  数据收集scrapy 网页采集，爬虫
  数据收集scrapy-redis 分布式爬虫
  数据收集selenium web 测试，仿真浏览器
  数据处理beautifulsoup 网页解释库，提供lxml 的支持
  数据处理lxml xml 解释库
  数据处理xlrd excel 文件读取
  数据处理xlwt excel 文件写入
  数据处理xlutils excel 文件简单格式修改
  数据处理pywin32 excel 文件的读取写入及复杂格式定制
  数据处理Python-docx Word 文件的读取写入
  数据分析numpy 基于矩阵的数学计算库
  数据分析pandas 基于表格的统计分析库
  数据分析scipy 科学计算库，支持高阶抽象和复杂模型
  数据分析statsmodels 统计建模和计量经济学工具包
  数据分析scikit-learn 机器学习工具库
  数据分析gensim 自然语言处理工具库
  数据分析jieba 中文分词工具库
  数据存储MySQL-python mysql 的读写接口库
  数据存储mysqlclient mysql 的读写接口库
  数据存储SQLAlchemy 数据库的ORM 封装
  数据存储pymssql sql server 读写接口库
  数据存储redis redis 的读写接口
  数据存储PyMongo mongodb 的读写接口
  数据呈现matplotlib 流行的数据可视化库
  数据呈现seaborn 美观的数据可是湖库，基于matplotlib
  工具辅助jupyter 基于web 的python IDE，常用于数据分析
  工具辅助chardet 字符检查工具
  工具辅助ConfigParser 配置文件读写支持
  工具辅助requests HTTP 库，用于网络访问

  5) 工具安装问题
  windows 环境
  Python2 无法安装mysqlclient。Python3 无法安装MySQL-python、flup、functools32、
  Gooey、Pywin32、webencodings。
  matplotlib 在python3 环境中安装报错：The following required packages can not be
  built:freetype, png。需要手动下载安装源码包安装解决。
  scipy 在Python3 环境中安装报错，numpy.distutils.system_info.NotFoundError，需要自己手
  工下载对应的安装包，依赖numpy,pandas 必须严格根据python 版本、操作系统、64 位与否。运行
  matplotlib 后发现基础包numpy+mkl 安装失败，需要自己下载，国内暂无下载源
  centos 环境下
  Python2 无法安装mysql-python 和mysqlclient 包，报错：EnvironmentError: mysql_config not
  found，解决方案是安装mysql-devel 包解决。使用matplotlib 报错：no module named _tkinter，
  安装Tkinter、tk-devel、tc-devel 解决。
  pywin32 也无法在centos 环境下安装。

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

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

• Python 中的作用域？

  Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定。当Python 遇到一个变量的话它会按照这的顺序进行搜索：

  本地作用域(Local)--->当前作用域被嵌入的本地作用域(Enclosing locals)--->全局/模块作用域
  (Global)--->内置作用域(Built-in)。

• 什么是Python？

   Python 是一种编程语言，它有对象、模块、线程、异常处理和自动内存管理，可以加入其他语
  言的对比。
   Python 是一种解释型语言，Python 在代码运行之前不需要解释。
   Python 是动态类型语言，在声明变量时，不需要说明变量的类型。
   Python 适合面向对象的编程，因为它支持通过组合与继承的方式定义类。
   在Python 语言中，函数是第一类对象。
   Python 代码编写快，但是运行速度比编译型语言通常要慢。
   Python 用途广泛，常被用走"胶水语言"，可帮助其他语言和组件改善运行状况。
   使用Python，程序员可以专注于算法和数据结构的设计，而不用处理底层的细节。

• 什么是python自省？

  Python 自省是Python 具有的一种能力，使程序员面向对象的语言所写的程序在运行时,能够获得
  对象的类Python 型。Python 是一种解释型语言，为程序员提供了极大的灵活性和控制力。

• 什么是Python 的命名空间？

  在Python 中，所有的名字都存在于一个空间中，它们在该空间中存在和被操作——这就是命名空
  间。它就好像一个盒子，每一个变量名字都对应装着一个对象。当查询变量的时候，会从该盒子里面寻
  找相应的对象。

• 你所遵循的代码规范是什么？请举例说明其要求？

  PEP8 规范。
  1. 变量
  常量：大写加下划线USER_CONSTANT。
  私有变量: 小写和一个前导下划线_private_value。
  Python 中不存在私有变量一说，若是遇到需要保护的变量，使用小写和一个前导下划线。但这只是
  程序员之间的一个约定，用于警告说明这是一个私有变量，外部类不要去访问它。但实际上，外部类还
  是可以访问到这个变量。
  内置变量: 小写，两个前导下划线和两个后置下划线__class__
  两个前导下划线会导致变量在解释期间被更名。这是为了避免内置变量和其他变量产生冲突。用户
  定义的变量要严格避免这种风格。以免导致混乱。
  2. 函数和方法
  总体而言应该使用，小写和下划线。但有些比较老的库使用的是混合大小写，即首单词小写，之后
  每个单词第一个字母大写，其余小写。但现在，小写和下划线已成为规范。
  私有方法：小写和一个前导下划线
  这里和私有变量一样，并不是真正的私有访问权限。同时也应该注意一般函数不要使用两个前导下
  划线(当遇到两个前导下划线时，Python 的名称改编特性将发挥作用)。
  特殊方法：小写和两个前导下划线，两个后置下划线
  这种风格只应用于特殊函数，比如操作符重载等。
  函数参数: 小写和下划线，缺省值等号两边无空格
  3. 类
  类总是使用驼峰格式命名，即所有单词首字母大写其余字母小写。类名应该简明，精确，并足以从
  中理解类所完成的工作。常见的一个方法是使用表示其类型或者特性的后缀，例如:
  SQLEngine，MimeTypes 对于基类而言，可以使用一个Base 或者Abstract 前缀BaseCookie，
  AbstractGroup
  4. 模块和包
  除特殊模块__init__ 之外，模块名称都使用不带下划线的小写字母。
  若是它们实现一个协议，那么通常使用lib 为后缀，例如:
  import smtplib
  import os
  import sys
  5. 关于参数
  5.1 不要用断言来实现静态类型检测。断言可以用于检查参数，但不应仅仅是进行静态类型检测。
  Python 是动态类型语言，静态类型检测违背了其设计思想。断言应该用于避免函数不被毫无意义的调
  用。
  5.2 不要滥用*args 和**kwargs。*args 和**kwargs 参数可能会破坏函数的健壮性。它们使签
  名变得模糊，而且代码常常开始在不应该的地方构建小的参数解析器。
  6. 其他
  6.1 使用has 或is 前缀命名布尔元素
  is_connect = True
  has_member = False
  6.2 用复数形式命名序列
  members = ['user_1', 'user_2']
  6.3 用显式名称命名字典
  person_address = {'user_1':'10 road WD', 'user_2' : '20 street huafu'}
  6.4 避免通用名称
  诸如list, dict, sequence 或者element 这样的名称应该避免。
  6.5 避免现有名称
  诸如os, sys 这种系统已经存在的名称应该避免。
  7. 一些数字
  一行列数: PEP 8 规定为79 列。根据自己的情况，比如不要超过满屏时编辑器的显示列数。
  一个函数: 不要超过30 行代码, 即可显示在一个屏幕类，可以不使用垂直游标即可看到整个函数。
  一个类: 不要超过200 行代码，不要有超过10 个方法。一个模块不要超过500 行。
  8. 验证脚本
  可以安装一个pep8 脚本用于验证你的代码风格是否符合PEP8。