第一章 python基础
1,为什么学习python
自由发挥哈哈哈
2,通过甚途径学习的python
本专业毕业请忽略本题
自学、网教、购买课程、、、、
3,公司线上和开发环境用的什么系统
线上用的centos6,开发环境用的Ubuntu
4,简述python和java,php,c,c#,c++的对比
python简单易懂,代码工整美观,简单优雅，可读性强,有成熟的框架,丰富的第三方模块,开发效率非常高，最最关键的是超火，啥都可以做
5,简述解释性和编译型语言的优缺点，以及实例
计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。
编译型语言在程序执行之前，有一个单独的编译过程，将程序翻译成机器语言，以后执行这个程序的时候，就不用再进行翻译了。
解释型语言，是在运行的时候将程序翻译成机器语言，所以运行速度相对于编译型语言要慢。
编译型
优点：编译器⼀般会有预编译的过程对代码进⾏优化。因为编译只做⼀次，运⾏时不需要编
译，所以编译型语⾔的程序执⾏效率⾼。可以脱离语⾔环境独立运⾏。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运⾏环境⽣
成机器码，不同的操作系统之间移植就会有问题，需要根据运⾏的操作系统环境编译不同的
可执⾏⽂件。
解释型
优点：有良好的平台兼容性，在任何环境中都可以运⾏，前提是安装了解释器（虚拟机）。
灵活，修改代码的时候直接修改就可以，可以快速部署，不⽤停机维护。
缺点：每次运⾏的时候都要解释⼀遍，性能上不如编译型语⾔。
5,python是一门什么语言
python是一门编译型、动态强类型的高级脚本语言
6,强类型、弱类型，动态、静态语言的区别
强类型：不允许不同类型相加。例如：整形+字符串会报类型错误。
动态：不使用显示数据类型声明，且确定一个变量的类型是在第一次给它赋值的时候。
脚本语言：一般是解释性语言，运行代码只需要一个解释器，不需要编辑。
7,python解释器种类以及特点
CPython
当我们从Python官⽅⽹站下载并安装好Python 2.7后，我们就直接获得了⼀个官⽅版
本的解释器：CPython。这个解释器是⽤C语⾔开发的，所以叫CPython。在命令⾏下运
⾏python就是启动CPython解释器。
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的字节码。
8,计算机存储单位的换算
计算机存储单位一般用bit、B、KB、MB、GB、TB、PB、EB、ZB、YB、BB、NB、DB……来表示，它们之间的关系是：
位 bit (比特)(Binary Digits)：存放一位二进制数，即 0 或 1，最小的存储单位。[英文缩写：b(固定小写)]
字节byte：8个二进制位为一个字节(B)，最常用的单位。
1 Byte（B） = 8 bit
1 Kilo Byte（KB） = 1024B
1 Mega Byte（MB） = 1024 KB
1 Giga Byte （GB）= 1024 MB
1 Tera Byte（TB）= 1024 GB
1 Peta Byte（PB） = 1024 TB
1 Exa Byte（EB） = 1024 PB
1 Zetta Byte（ZB） = 1024 EB
1Yotta Byte（YB）= 1024 ZB
1 Bronto Byte（BB） = 1024 YB
1Nona Byte（NB）=1024 BB
1 Dogga Byte（DB）=1024 NB
1 Corydon Byte（CB）=1024DB
9,pep8规范
传送门 http://legacy.python.org/dev/peps/pep-0008/
ag:
对齐----换行对齐
行最大长度79
空行----类之间空两行,类里面的方法空一行
import导入----模块注释之后,顶部导入,分行导入,导入顺序(标准库,第三方库,本地库,每组库加空行)
注释----# 块注释(与同级代码对齐,#后面一个空格)
----# 行内注释(与代码至少两个空格,节制使用)
变量命名----类名(大写字母开头)
----函数名(小写,可下划线分割)
函数和方法参数
始终要将 self 作为实例方法的的第一个参数。
始终要将 cls 作为类静态方法的第一个参数。
如果函数的参数名和已有的关键词冲突,加下划线,例class_
10、ascii,unicode,utf8,gbk区别
ascii 是最早美国用的标准信息交换码，把所有的字母的大小写，各种符号用 二进制来表示，共有256中，加入些拉丁文等字符，1bytes代表一个字符
Unicode是为了统一世界各国语言的不用，统一用2个bytes代表一个字符，可以表达2**16=65556个，称为万国语言，特点：速度快，但浪费空间，可以用在内存处理中，兼容了utf-8，gbk，ASCII，
utf-8 为了改变Unicode的这种缺点，规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的
gbk 是中文的字符编码，用2个字节代表一个字符
11、字节码和机器码区别
机器码是电脑的CPU可直接解读的数据
字节码是二进制文件,一种中间码
12、三元运算编写格式
python2 python3
print ‘1’ print(‘1’)
range( 0, 4 ) 结果 是 列表 [0,1,2,3 ] list( range(0,4) )
xrange( 0, 4 ) 适用于 for 循环的变量控制 range(0,4)
原： file( … )或 open(…) open(…)
raw_input() input()
14、py2项目迁移py3
2to3 example.py
15、python2 python3 int long
python2有非浮点数准备的int和long类型
在python3里，只有一种整数类型int,
16、用一行代码实现数值交换：
a = 1 b = 2 a, b = b, a print(a, b)
17、Python3和Python2中 int 和 long的区别？
py3中没有long整型，统一使用int，大小和py2的long类似。 py2中int最大不能超过sys.maxint，
根据不同平台大小不同； 在int类型数字后加L定义成长整型，范围比int更大。
18、xrange和range的区别
range产生的是一个列表，xrange产生的是生成器。
数据较大时xrange比range好。
Range一下把数据都返回，xrange通过yield每次返回一个
19、文件操作时：xreadlines和readlines的区别
Readlines：读取文件的所有行，返回一个列表，包含所有行的结束符
Xreadlines：返回一个生成器，循环使用和readlines基本一致 。（py2有，py3没有）
20、列举布尔值为False的常见值？
[] 、{} 、None 、 ' '、 （）、 0、 False
21、列出字符串、列表、元组、字典每个常用的5个方法？
#Str：
Split：分割
Strip：去掉两边的空格
Startwith：以什么开头
Endwith：以什么结尾
Lower：小写
Upper：大写
#List：
Append：追加
Insert：插入
Reverse：反转
Index：索引
Copy：拷贝
Pop：删除指定索引处的值，不指定索引默认删除最后一个。
#Tuple：
Count：查看某个元素出现的次数
Index：索引
#Dict：
Get：根据key取value
Items：用于循环，取出所有key和value
Keys：取出所有key
Values：取出所有的value
Clear：清空字典
Pop：删除指定键对应的值，有返回值；
22、lambda表达式格式以及应用场景？
# 格式：
匿名函数：
add = lambda x, y : x+y
add(1,2)
# 结果为3
# 应用场景：
Filter(),map(),reduce(),sorted()函数中经常用到，它们都需要函数形参数；
一般定义调用一次。
（reduce()对参数序列中元素进行累积）
23、pass的作用？
Pass一般用于站位语句，保持代码的完整性，不会做任何操作。
24、*arg和**kwarg作用
# 他们是一种动态传参，一般不确定需要传入几个参数时，可以使用其定义参数，然后从中取参
'*args'：按照位置传参，将传入参数打包成一个‘元组’(打印参数为元组-- tuple)
'**kwargs'：按照关键字传参，将传入参数打包成一个‘字典’(打印参数为字典-- dict)
*args **args：在实参位置是打散、在形参是聚合
25、is和==的区别
==：判断某些值是否一样，比较的是值
is：比较的是内存地址（引用的内存地址不一样，唯一标识：id）
26、简述Python的深浅拷贝以及应用场景？
#浅拷贝： 不管多么复杂的数据结构，只copy对象最外层本身，该对象引用的其他对象不copy， 内存里两个变量的地址是一样的，一个改变另一个也改变。
#深拷贝： 完全复制原变量的所有数据，内存中生成一套完全一样的内容；只是值一样，内存地址不一样，一方修改另一方不受影响
27、Python垃圾回收机制？
# Python垃圾回收机制
Python垃圾回收机制,主要使用'引用计数'来跟踪和回收垃圾。
在'引用计数'的基础上，通过'标记-清除'（mark and sweep）解决容器对象可能产生的循环引用问题.
通过'分代回收'以空间换时间的方法提高垃圾回收效率。
'引用计数'
PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。
当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，
它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。
优点:1.简单 2.实时性
缺点:1.维护引用计数消耗资源 2.循环引用
'标记-清楚机制'
基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，
遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，
然后清扫一遍内存空间，把所有没标记的对象释放。
'分代技术'
分代回收的整体思想是：
将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，
垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。
28、Python的可变类型和不可变类型？
# 可变类型：列表、字典、集合
# 不可变类型：数字、字符串、元祖 （可变与否指内存中那块内容value）
29、求结果：
v = dict.fromkeys(['k1', 'k2'], [])
# 内存中k1和k2都指向同一个[](内存地址相同),只要指向的[]发生变化，k1和k2都要改变(保持一致)
v['k1'].append(666)
print(v) # {'k1': [666], 'k2': [666]}
v['k1'] = 777
print(v) # {'k1': 777, 'k2': [666]}
30、求结果：
def num():
return [lambda x: i * x for i in range(4)] #返回一个列表，里面是四个函数对象 i=3
print([m(2) for m in num()])
31、列举常见的内置函数
# map:遍历序列，为每一个序列进行操作，返回一个结果列表
l = [1, 2, 3, 4, 5, 6, 7]
def pow2(x):
return x * x
res = map(pow2, l)
print(list(res)) #[1, 4, 9, 16, 25, 36, 49]
--------------------------------------------------------------
# reduce：对于序列里面的所有内容进行累计操作
from functools import reduce
def add(x, y):
return x+y
print(reduce(add, [1,2,3,4])) #10
--------------------------------------------------------------
# filter：对序列里面的元素进行筛选，最终获取符合条件的序列。
l = [1, 2, 3, 4, 5]
def is_odd(x): # 求奇数
return x % 2 == 1
print(list(filter(is_odd, l))) #[1, 3, 5]
--------------------------------------------------------------
#zip用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
a = [1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]
ziped1 = zip(a,b)
print('ziped1>>>',list(ziped1)) #[(1, 4), (2, 5), (3, 6)]
ziped2 = zip(a,c)
print('ziped2>>>',list(ziped2)) #[(1, 4), (2, 5), (3, 6)],以短的为基准