- 为什么学习Python?
- 语言本身简洁,优美,功能超级强大,跨平台,从桌面应用,web开发,自动化测试运维,爬虫,人工智能,大数据处理都能做
- Python和Java、PHP、C、C#、C++等其他语言的对比?
- C语言由于其底层操作特性和历史的积累,在嵌入式领域是当之无愧的王者
- . PHP跨平台,性能优越,跟Linux/Unix结合比跟Windows结合性能强45%,开发成本低,PHP 5已经有成熟的面向对象体系,适合开发大型项目淘宝网、Yahoo、163、Sina等等大型门户,很多选用PHP来作为他们的开发语言
- JAVA的优点:1.简单性2.面向对象性(面向对象的程度可以达到95%)3.健壮性4.跨平台性5.高性能(自动垃圾回收机制)6.多线程7.动态性8.安全性
- C++的优点:1.可扩展性强3.可移植性4.面向对象的特性5.强大而灵活的表达能力和不输于C的效率6.支持硬件开发
- 简述解释型和编译型编程语言
- 1.编译型语言在程序执行之前,有一个单独的编译过程,将程序翻译成机器语言,以后执行这个程序的时候,就不用再进行翻译了。
- 2.解释型语言,是在运行的时候将程序翻译成机器语言,所以运行速度相对于编译型语言要慢。
- 3.C/C++ 等都是编译型语言,而Java,C#等都是解释型语言。
- 5.脚本语言一般都有相应的脚本引擎来解释执行。 他们一般需要解释器才能运行。JAVASCRIPT,ASP,PHP,PERL,Nuva都是脚本语言。C/C++编译、链接后,可形成独立执行的exe文件。
- Python解释器种类以及特点?
- CPython:这个解释器是用C语言开发的,所以叫CPython,在命名行下运行python,就是启动CPython解释器,CPython是使用最广的Python解释器。
- Jython:Jython是运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行。
- IPython:IPython是基于CPython之上的一个交互式解释器,也就是说,IPython只是在交互方式上有所增强,但是执行Python代码的功能和CPython是完全一样的,好比很多国产浏览器虽然外观不同,但内核其实是调用了IE。
位和字节的关系?
- 1 计算机存储信息的最小单位,称之为位(bit),音译比特,二进制的一个“0”或一个“1”叫一位。
- 2、计算机存储容量基本单位是字节(Byte),音译为拜特,8个二进制位组成1个字节,一个标准英文字母占一个字节位置,一个标准汉字占二个字节位置。
b、B、KB、MB、GB 的关系?
1024B=1K(千)B
1024KB=1M(兆)B
1024MB=1G(吉)B
1024GB=1T(太)B
什么是PEP8?
PEP8是一个编程规范,内容是一些关于如何让你的程序更具可读性的建议。
其主要内容包括代码编排、文档编排、空格的使用、注释、文档描述、命名规范、编码建议等。
- 缩进。4个空格的缩进(编辑器都可以完成此功能),不使用Tap,更不能混合使用Tap和空格。
- 每行最大长度79,换行可以使用反斜杠,最好使用圆括号。换行点要在操作符的后边敲回车。
- 类和top-level函数定义之间空两行;类中的方法定义之间空一行;函数内逻辑无关段落之间空一行;其他地方尽量不要再空行。
- 块注释,在一段代码前增加的注释。在‘#’后加一空格。段落之间以只有‘#’的行间隔
- 各种右括号前不要加空格。
- 逗号、冒号、分号前不要加空格。
- 函数的左括号前不要加空格。如Func(1)。
- 序列的左括号前不要加空格。如list[2]。
- 操作符左右各加一个空格,不要为了对齐增加空格。
- 函数默认参数使用的赋值符左右省略空格。
- 不要将多句语句写在同一行,尽管使用‘;’允许。
- if/for/while语句中,即使执行语句只有一句,也必须另起一行。
- 类的方法第一个参数必须是self,而静态方法第一个参数必须是cls。
Pickle模块读入任何Python对象,将它们转换成字符串,然后使用dump函数将其转储到一个文件中——这个过程叫做pickling。
反之从存储的字符串文件中提取原始Python对象的过程,叫做unpickling。
- 通过代码实现如下转换:二进制转换成十进制:v = “0b1111011”
十进制转换成二进制:v = 18
八进制转换成十进制:v = “011”
十进制转换成八进制:v = 30
十六进制转换成十进制:v = “0x12”
十进制转换成十六进制:v = 87
(1)二进制转换成十进制:v = “0b1111011”
#先将其转换为字符串,再使用int函数,指定进制转换为十进制。 print(int("0b1111011",2)) 值为123
(2)十进制转换成二进制:v = 18
print("转换为二进制为:", bin(18)) #转换为二进制为: 0b10010
(3)八进制转换成十进制:v = “011”
print(int("011",8)) #9
(4)十进制转换成八进制:v = 30
print("转换为八进制为:", oct(30)) #转换为八进制为: 0o36
(5)十六进制转换成十进制:v = “0x12”
print(int("0x12",16)) #18
(6)十进制转换成十六进制:v = 87
print("转换为十六进制为:", hex(87)) 转换为十六进制为: 0x57
a=['1','2','3'] b=[int(i) for i in a] print(b)
输出为:[1, 2, 3]
- 请编写一个函数实现将IP地址转换成一个整数。 如 10.3.9.12 转换规则为: 10 00001010 3 00000011 9 00001001 12 00001100 再将以上二进制拼接起来计算十进制结果:00001010 00000011 00001001 00001100 = ?
- python递归的最大层数?
def fab(n): if n == 1: return 1 else: return fab(n-1)+ n print (fab(998)) #得到的最大数为998,以后就是报错了,998这个数值莫名想起广告词····
import sys sys.setrecursionlimit(100000) def foo(n): print(n) n += 1 foo(n) if __name__ == '__main__': foo(1) #得到的最大数字在3922-3929之间浮动,这个是和计算机有关系的,将数字调到足够大了,已经大于系统堆栈,python已经无法支撑到太大的递归崩了。
- 计算题
1、求结果
v=dict.fromkeys(['k1','k2'],[])
v['k1'].append(666)
print(v)
v['k1'] = 777
print(v)v=dict.fromkeys(['k1','k2'],[]) v['k1'].append(666) print(v) #{'k2': [666], 'k1': [666]} v['k1'] = 777 print(v) #{'k2': [666], 'k1': 777}
2、求结果
def num():
return [lambda x:i*x for i in range(4)]
print(m(2) for m in num())def num(): return [lambda x:i*x for i in range(4)] print(m(2) for m in num())# <generator object <genexpr> at 0x0000000000B2FA40> 为元祖 print(list(m(2) for m in num())) # [6, 6, 6, 6]
3、求结果
a、[i%2 for i in range(10)]
b、( i % 2 for i in range(10) )
a=[i%2 for i in range(10) ] print(a) # 因为 [] 为列表 所以会有结果为[0, 1, 0, 1, 0, 1, 0, 1, 0, 1] b=(i%2 for i in range(10)) print(b) # 因为()为元祖 所以会有结果为 <generator object <genexpr> at 0x0000000000645D00> c=list(b) # 将元祖转换格式为列表 print(c) # 打印c,结果为 [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
4、求结果:
a. 1 or 2
b. 1 and 2
c. 1 < (2==2)
d. 1 < 2 == 2
print(1 or 2) # 1 print(1 and 2) # 2 print(1<(2==2)) # False 因为2==2为True,而True表示为1,False表示为0,所以1<1,结果为False print(1<2==2) # True python是允许连续比较1<2==2意思是1<2且2==2
- 9;求结果: 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
v2 = 1 and 3 #3 v3 = 0 and 2 and 1 #0 v4 = 0 and 2 or 1 #1 v5 = 0 and 2 or 1 or 4 #1 v6 = 0 or False and 1 #False
- ascii、unicode、utf-8、gbk 区别?
ASCII码使用一个字节编码,所以它的范围基本是只有英文字母、数字和一些特殊符号 ,只有256个字符。
在表示一个Unicode的字符时,通常会用“U+”然后紧接着一组十六进制的数字来表示这一个字符。在基本多文种平面(英文为 Basic Multilingual Plane,简写 BMP。它又简称为“零号平面”, plane 0)里的所有字符,要用四位十六进制数(例如U+4AE0,共支持六万多个字符);在零号平面以外的字符则需要使用五位或六位十六进制数了。旧版的Unicode标准使用相近的标记方法,但却有些微的差异:在Unicode 3.0里使用“U-”然后紧接着八位数,而“U+”则必须随后紧接着四位数。
Unicode能够表示全世界所有的字节
GBK是只用来编码汉字的,GBK全称《汉字内码扩展规范》,使用双字节编码。
UTF-8(8-bit Unicode Transformation Format)是一种针对Unicode的可变长度字符编码,又称万国码。由Ken Thompson于1992年创建。现在已经标准化为RFC 3629。UTF-8用1到6个字节编码UNICODE字符。用在网页上可以同一页面显示中文简体繁体及其它语言(如英文,日文,韩文)。
- 字节码和机器码的区别?
字节码
字节码是一种中间码
字节码通常指的是已经经过编译,但与特定机器码无关,需要直译器转译后才能成为机器码的中间代码。字节码通常不像源码一样可以让人阅读,而是编码后的数值常量、引用、指令等构成的序列。
字节码主要为了实现特定软件运行和软件环境、硬件环境无关。字节码的实现方式是通过编译器和虚拟机器。编译器将源码编译成字节码,特定平台上的虚拟机器将字节码转译为可以直接执行的指令。字节码的典型应用为Java语言。
总结:字节码是一种中间状态(中间码)的二进制代码(文件)。需要直译器转译后才能成为机器码。
机器码
机器码就是计算机可以直接执行,并且执行速度最快的代码。
用机器语言编写程序,编程人员要首先熟记所用计算机的全部指令代码和代码的涵义。手编程序时,程序员得自己处理每条指令和每一数据的存储分配和输入输出,还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作,编写程序花费的时间往往是实际运行时间的几十倍或几百倍。而且,编出的程序全是些0和1的指令代码。
机器语言是微处理器理解和使用的,用于控制它的操作二进制代码。
8086到Pentium的机器语言指令长度可以从1字节到13字节。
尽管机器语言好像是很复杂的,然而它是有规律的。
存在着多至100000种机器语言的指令。这意味着不能把这些种类全部列出来。
总结:机器码是电脑CPU直接读取运行的机器指令,运行速度最快
- 三元运算规则以及应用场景?
三元运算符的功能与“if...else”流程语句一致,它在一行中书写,代码非常精练、执行效率更高。在PHP程序中恰当地使用三元运算符能够令脚本更为简洁、高效。代码格式如下:
(expr1) ? (expr2) : (expr3);
解释:如果条件“expr1”成立,则执行语句“expr2”,否则执行“expr3”。
实现同样的功能,若使用条件流程语句,就需要书写多行代码:
if(expr1) { expr2; } else { expr3; }
可见,前面所说的三元运算符之好并非夸张。可是,多数情况下我们只在代码较为简单的时候使用三元运算符,即执行语句只为单句的时候。如:
$a>$b ? print "a大于b" : print "a小于b";
事实上,三元运算符可以扩展使用,当设置的条件成立或不成立,执行语句都可以不止一句,试看以下格式:
(expr1) ? (expr2).(expr3) : (expr4).(expr5);
我们非常明显地看到,多个执行语句可以使用用字符串运算符号(“.”)连接起来,各执行语句用小角括号包围起来以表明它是一个独立而完整的执行语句。这样扩展后它的功能更为逼近“if...else”流程语句。
同时三元运算符还可以嵌套使用。例如,a大于b成立时:如果a小于c,那么x=c-a否则x=a-c;否则a小于b成立时:如果b小于c,那么x=c-b否则x=b-c:
$a>$b ? $x=($a<$c ? $c-$a : $a-$c) : $x=($b<$c ? $c-$b : $b-$c);
嵌套使用的三元运算符可读性不太好,日后对代码的维护极可能存在问题,但比起“if...else”之类的流程语句,在上述情形之下,它的确太简练了,这是它的诱人之处。
对于喜欢偷懒和追求代码简洁的人来说,用三元运算符取代if流程语句应该是绝佳的选择。即使不用考虑“三元”中条件句以外的任意某一“元”,使用三元运算符仍然比if语句简练。以下语句的语法是正确的,它们以小解引号的方式忽略了第二或第三“元”:
$a>$b ? print "Yes" : ""; $a>$b ? '': print 'No';
应该注意的是:在使用三元运算符时,建议使用print语句替代echo语句。
Python自省
这个也是python彪悍的特性.
自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如type(),dir(),getattr(),hasattr(),isinstance().
- 列举 Python2和Python3的区别?
(1)Print
在 Python 2 中, print 被视为一个语句而不是一个函数,这是一个典型的容易弄混的地方,因为在 Python 中的许多操作都需要括号内的参数来执行。如果在 Python 2 中你想要你的控制台输出 ”Sammy the Shark is my favorite sea creature”,你应该写下这样的 print 语句:
print "Sammy the Shark is my favorite sea creature"
在使用 Python 3 时,print()会被显式地视为一个函数,因此要输出上面相同的字符串,你可以使用这种非常简单且易于使用的函数语法:
print("Sammy the Shark is my favorite sea creature")
这种改变使得 Python 的语法更加一致,并且在不同的 print 函数之间进行切换更加容易。就方便性而言,print()语法也与 Python 2.7 向后兼容,因此您的 Python 3 print()函数可以在任一版本中运行。
(2)整数的除法
在 Python 2 中,您键入的任何不带小数的数字,将被视为整数的编程类型。虽然乍看起来这似乎是一个简单的处理编程类型的方法,但有时候当你试图除以整数以期望获得一个带小数位的答案(称为浮点数),如:
5 / 2 = 2.5
然而,在 Python 2 中,整数是强类型的,并且不会变成带小数位的浮点数,即使这样做具有直观上的意义。
当除法/符号的任一侧的两个数字是整数时,Python 2进行底除法,使得对于商x,返回的数字是小于或等于x的最大整数。这意味着当你写下 5 / 2 来对这两个数字相除时,Python 2.7 将返回最大的小于或等于 2.5 的整数,在这种情形下:
a = 5 / 2 print a #a=2
为解决这个问题,你可以在 5.0 / 2.0 中添加小数位,以得到预期的答案 2.5。
在 Python 3 中,整数除法变得更直观,如
a = 5 / 2 print(a) #a=2.5
你也可以使用 5.0 / 2.0 返回 2.5,但是如果你想做底层划分,你应该使用 “//” 这样的 Python 3 语法,像这样:
b = 5 // 2 print(b) #b=2
在 Python 3 中的这种修改使得整数除法更为直观,并且它的特点是不能向后兼容 Python 2.7。
(3)支持 Unicode
当编程语言处理字符串类型时,也就是一个字符序列,它们可以用几种不同的方式来做,以便计算机将数字转换为字母和其他符号。
Python 2 默认使用 ASCII 字母表,因此当您输入“Hello,Sammy!”时, Python 2 将以 ASCII 格式处理字符串。被限定为在多种扩展形式上的数百个字符,用ASCII 进行字符编码并不是一种非常灵活的方法,特别是使用非英语字符时。
要使用更通用和更强大的Unicode字符编码,这种编码支持超过128,000个跨越现今和历史的脚本和符号集的字符,你必须输入
u“Hello,Sammy!”
, 前缀 u 代表 Unicode。
Python 3 默认使用 Unicode,这节省了程序员多余的开发时间,并且您可以轻松地在程序中直接键入和显示更多的字符。因为 Unicode 支持更强大的语言字符多样性以及 emoji 的显示,所以将它作为默认字符编码来使用,能确保全球的移动设备在您的开发项目中都能得到支持。
如果你希望你的 Python 3 代码向后兼容 Python 2,你可以通过在你的字符串的前面保留 “u” 来实现。
(4)后续发展
Python 3 和 Python 2 之间的最大区别不是语法上的,而是事实上 Python 2.7 将在 2020 年失去后续的支持,Python 3 将继续开发更多的功能和修复更多的错误。
最近的发展包括格式化的字符串,类创建的简单定制,和用一种更干净的句法方式来处理矩阵乘法。
Python 3 的后续开发意味着,开发人员可以对问题被及时解决抱有信心,并且随着时间的推移更多的功能将被添加进来,程序也会变得更加有效。
- 用一行代码实现数值交换:
a = 1
b = 2
a,b=b,a print(a,b) #a=2,b=1
- Python3和Python2中 int 和 long的区别?
long整数类型被Python3废弃,统一使用int
python2和python3区别?列举5个1、Python3 使用 print 必须要以小括号包裹打印内容,比如 print('hi')
Python2 既可以使用带小括号的方式,也可以使用一个空格来分隔打印内容,比如 print 'hi'
2、python2 range(1,10)返回列表,python3中返回迭代器,节约内存
3、python2中使用ascii编码,python中使用utf-8编码
4、python2中unicode表示字符串序列,str表示字节序列
python3中str表示字符串序列,byte表示字节序列
5、python2中为正常显示中文,引入coding声明,python3中不需要
6、python2中是raw_input()函数,python3中是input()函数
- xrange和range的区别?
range 函数说明:range([start,] stop[, step]),根据start与stop指定的范围以及step设定的步长,生成一个序列。
range示例:
xrange 函数说明:用法与range完全相同,所不同的是生成的不是一个数组,而是一个生成器。
xrange示例:
>>> xrange(5) xrange(5) >>> list(xrange(5)) [0, 1, 2, 3, 4] >>> xrange(1,5) xrange(1, 5) >>> list(xrange(1,5)) [1, 2, 3, 4] >>> xrange(0,6,2) xrange(0, 6, 2) >>> list(xrange(0,6,2)) [0, 2, 4]
由上面的示例可以知道:要生成很大的数字序列的时候,用xrange会比range性能优很多,因为不需要一上来就开辟一块很大的内存空间,这两个基本上都是在循环的时候用:
for i in range(0, 100): print i for i in xrange(0, 100): print i
这两个输出的结果都是一样的,实际上有很多不同,range会直接生成一个list对象:
a = range(0,100) print type(a) print a print a[0], a[1]
输出结果:
<type 'list'> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] 0 1
而xrange则不会直接生成一个list,而是每次调用返回其中的一个值:
a = xrange(0,100) print type(a) print a print a[0], a[1]
结果如下:
<type 'xrange'> xrange(100) 0
总结:
1.range和xrange都是在循环中使用,输出结果一样。
2.range返回的是一个list对象,而xrange返回的是一个生成器对象(xrange object)。
3.xrange则不会直接生成一个list,而是每次调用返回其中的一个值,内存空间使用极少,因而性能非常好。
注意:Python 3.x已经去掉xrange,全部用range代替。
- 文件操作时:xreadlines和readlines的区别?
二者使用时相同,但返回类型不同,xreadlines返回的是一个生成器,readlines返回的是list
- 列举布尔值为False的常见值?
- 字符串、列表、元组、字典每个常用的5个方法?
字符串
words = 'today is a wonderfulday' print(words.strip('today'))#如果strip方法指定一个值的话,那么会去掉这两个值 print(words.count('a'))#统计字符串出现的次数 print(words.index('is'))#找下标 print(words.index('z'))#找下标如果元素不找不到的话,会报错 print(words.find('z'))#找下标,如果元素找不到的话,返回-1 print(words.replace('day','DAY'))#字符串替换 print(words.isdigit())#判断字符串是否为纯数字 print(words.islower())#判断字符串是否为小写字母 print(words.isupper())#判断字符串是否为大写字母 print(words.startswith('http'))#判断是否以某个字符串开头 print(words.endswith('.jpg'))#判断是否以某个字符串结尾 print(words.upper())#将字符串变成大写 print(words.lower())#将字符串变成小写
- 移除空白
- 分割
- 长度
- 索引
- 切片
列表
sample_list = ['a',1,('a','b')] #创建列表 sample_list = ['a','b',0,1,3] # Python 列表操作 value_start = sample_list[0] #得到列表中的某一个值 end_value = sample_list[-1] #得到列表中的某一个值 del sample_list[0] #删除列表的第一个值 sample_list[0:0] = ['sample value'] #在列表中插入一个值 list_length = len(sample_list) #得到列表的长度 for element in sample_list: #列表遍历 print(element)
基本操作:
- 索引
- 切片
- 追加
- 删除
- 长度
- 切片
- 循环
- 包含
元祖
#元组也是一个list,他和list的区别是元组的元素无法修改 tuple1 = (2,3,4,5,6,4,7) print(type(tuple1)) print(tuple1[:7]) print(tuple1[:5:-1]) for i in range(6): print(tuple1[i]) for i in tuple1: print(i)
- 索引
- 切片
- 循环
- 长度
- 包含
字典
dict = {'ob1':'computer', 'ob2':'mouse', 'ob3':'printer'} 每一个元素是pair,包含key、value两部分。key是Integer或string类型,value 是任意类型。 键是唯一的,字典只认最后一个赋的键值。 dictionary的方法 D.get(key, 0) #同dict[key],多了个没有则返回缺省值,0。[]没有则抛异常 D.has_key(key) #有该键返回TRUE,否则FALSE D.keys() #返回字典键的列表 D.values() D.items() D.update(dict2) #增加合并字典 D.popitem() #得到一个pair,并从字典中删除它。已空则抛异常 D.clear() #清空字典,同del dict D.copy() #拷贝字典 D.cmp(dict1,dict2) #比较字典,(优先级为元素个数、键大小、键值大小) #第一个大返回1,小返回-1,一样返回0 dictionary的复制 dict1 = dict #别名 dict2=dict.copy() #克隆,即另一个拷贝。
常用操作:
- 索引
- 新增
- 删除
- 键、值、键值对
- 循环
- 长度
匿名函数:为了解决那些功能很简单的需求而设计的一句话函数
上面是我们对calc这个匿名函数的分析,下面给出了一个关于匿名函数格式的说明
函数名 = lambda 参数 :返回值 #参数可以有多个,用逗号隔开 #匿名函数不管逻辑多复杂,只能写一行,且逻辑执行结束后的内容就是返回值 #返回值和正常的函数一样可以是任意数据类型
我们可以看出,匿名函数并不是真的不能有名字。
匿名函数的调用和正常的调用也没有什么分别。 就是 函数名(参数) 就可以了~~~
- lambda表达式格式以及应用场景?
lambda表达式,通常是在需要一个函数,但是又不想费神去命名一个函数的场合下使用,也就是指匿名函数。
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
sum = lambda arg1, arg2: arg1 + arg2
#调用sum函数
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )
以上实例输出结果:
Value of total : 30
Value of total : 40
Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print,因为lambda需要一个表达式
- pass的作用?
1、空语句 do nothing
if true: pass #do nothing else: pass #do something
2、保证格式完整
def iplaypython(): pass
3、保证语义完整
while True: pass
- *arg和**kwarg作用
要想理解*arg和**kwarg的作用,先别着急,通过下面的示例,慢慢思考体会下他们的作用是什么?
*arg
比如现在我有一个最简单的加法(Jiafa)函数:
def Jiafa(x, y): z = x + y return z print(Jiafa(1,2))
这个很简单,一看就知道输出等于3。
那下一个问题是,如果我要算不固定个数的数字相加,那怎么来计算呢?
这时,就使用args和*kwarg,就可以帮助我们解决这种问题。
*args:可以理解为只有一列的表格,长度不固定。
**kwargs:可以理解为字典,长度也不固定。
先说args的作用,还是开篇的案例,我们要算不定长的加法,就可以用args来定义了,当然也可以叫x,y。
def Jiafa(*args): sum = 0 for i in args: sum = sum + i print(sum) Jiafa(1, 3, 5) Jiafa(2, 4, 6, 8, )
输出结果,9和20。这个案例很简单,用*args定义就可以引入,相当于定义了不定长度的函数,然后在程序中就可以多次使用。
**kwargs
**kwargs的字典呢?先看一下普通的字典,用一对大括号{}就可以创建字典,比如下面3行程序,就可以编一个字典的程序:
dict = {"system": "系统", "China": "中国", "link": "联接"} x = input("请输入一个英文单词:") print(dict.get(x, "本字典里没找到!"))
如果输入正确,会得到答案,否则会显示没找到。
在这个程序里,dict = {"system": "系统", "China": "中国", "link": "联接"}创建了三对“键和值”(key和value),比如“system”是key,“系统”是key对应的值,也叫键值。
还可以写一个测试单词的小软件。
dict = {"system": "系统", "China": "中国", "link": "联接"}
通过Key找value的语句:y = input("请输入China的中文意思:") if dict['China'] == y: print("恭喜你,答对了!")
通过value找Key的语句:
z = input("请输入“系统”的英文单词:") if list(dict.keys())[list(dict.values()).index("系统")] == z: print("恭喜你,答对了!")
现在问题来了,如果开始不知道字典里都有哪些内容,需要在程序运程中才知道怎么办?这个时候就可以用kwargs来定义了。我们先用kwargs来定义一个函数,函数内容先都不用写,再看看下面的小程序:
def dict(**kwargs): return kwargs mydict = dict(system="系统", China="中国", link="联接") x = input("请输入单词:") if x in mydict.keys(): print("中文意思:", mydict[x]) else: print("抱歉,没找到。")
用字典也可以达成这样的功能,使用in……keys(),就是判断这个key是不是存在,如果存在就返回它的值。 同样,用**kwargs传递数据的功能,还可以设计一个用户登录的程序:
def dict(**kwargs): return kwargs userdict = dict(user1="1234", user2="5678") x = input("请输入用户名:") if x in userdict.keys(): y = input("请输入密码:") if userdict[x] == y: print("完全正确") else: print("密码错误!") else: print("用户不存在!")
所以从以上的示例可以看到*arg和**kwarg的作用为:
1、函数调用里的*arg和**kwarg:
(1)*arg:元组或列表“出现”
**kwarg:字典“出没”
(2)分割参数
2、函数定义时传的*arg /**kwarg:
(1)接收参数
- is和==的区别
>>> a = 'cheesezh' >>> b = 'cheesezh' >>> a == b True
is也被叫做同一性运算符,这个运算符比较判断的是对象间的唯一身份标识,也就是id是否相同。通过对下面几个list间的比较,你就会明白is同一性运算符的工作原理:
例2:
>>> x = y = [4,5,6] >>> z = [4,5,6] >>> x == y True >>> x == z True >>> x is y True >>> x is z False >>> >>> print id(x) 3075326572 >>> print id(y) 3075326572 >>> print id(z) 3075328140
前三个例子都是True,这什么最后一个是False呢?x、y和z的值是相同的,所以前两个是True没有问题。至于最后一个为什么是False,看看三个对象的id分别是什么就会明白了。
下面再来看一个例子,例3中同一类型下的a和b的(a==b)都是为True,而(a is b)则不然。
>>> a = 1 #a和b为数值类型 >>> b = 1 >>> a is b True >>> id(a) 14318944 >>> id(b) 14318944 >>> a = 'cheesezh' #a和b为字符串类型 >>> b = 'cheesezh' >>> a is b True >>> id(a) 42111872 >>> id(b) 42111872 >>> a = (1,2,3) #a和b为元组类型 >>> b = (1,2,3) >>> a is b False >>> id(a) 15001280 >>> id(b) 14790408 >>> a = [1,2,3] #a和b为list类型 >>> b = [1,2,3] >>> a is b False >>> id(a) 42091624 >>> id(b) 42082016 >>> a = {'cheese':1,'zh':2} #a和b为dict类型 >>> b = {'cheese':1,'zh':2} >>> a is b False >>> id(a) 42101616 >>> id(b) 42098736 >>> a = set([1,2,3])#a和b为set类型 >>> b = set([1,2,3]) >>> a is b False >>> id(a) 14819976 >>> id(b) 14822256
通过例3可看出,is同一性运算符只有数值型和字符串型的情况下,a is b才为True,当a和b是tuple(元祖),list,dict或set型时,a is b为False。
- 简述Python的深浅拷贝以及应用场景?
深浅拷贝用法来自copy模块。
导入模块:import copy
浅拷贝:copy.copy
深拷贝:copy.deepcopy
字面理解:浅拷贝指仅仅拷贝数据集合的第一层数据,深拷贝指拷贝数据集合的所有层。所以对于只有一层的数据集合来说深浅拷贝的意义是一样的,比如字符串,数字,还有仅仅一层的字典、列表、元祖等.
对于以下数据深浅拷贝的意义是一样的(因为数据类型中只有一层):
name = 'beijing' #字符串 age = 12 #数字 list1 = [1,2,3,4] #列表 dic1 = {'name':'beijing','age':20} #字典
从内存地址来理解深浅拷贝:
深浅拷贝: 字符串,数字的深浅拷贝>>> import copy >>> name="hahah" #字符串 >>> name1=copy.copy(name) >>> >>> name2=copy.deepcopy(name) >>> print(id(name),id(name1),id(name2)) 11577192 11577192 11577192 >>> sum=111 #数字 >>> sum1=copy.copy(sum) >>> >>> sum2=copy.deepcopy(sum) >>> print(id(sum),id(sum1),id(sum2)) 503865568 503865568 503865568
如上图,对于数字和字符串的深浅拷贝都只是将变量的索引指向了原来的内存地址,例如在sum,sum1,sum2三个变量中,无论修改任意其中一个变量,只是将其指向了另一个内存地址,其他两个变量不会变,字符串同理。因此,对于 数字 和 字符串 而言,赋值、浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址。
字典(列表)的深浅拷贝
赋值:
import copy n1 = {'k1':'wu','k2':123,'k3':['alex',678]} n2 = n1
浅拷贝:
import copy n1 = {'k1':'wu','k2':123,'k3':['alex',678]} n3 = copy.copy(n1)
深拷贝:
import copy n1 = {'k1':'wu','k2':123,'k3':['alex',678]} n4 = copy.deepcopy(n1)
深浅拷贝的应用场景
比如在CMDB系统中,我们定义了一个报警模版call给所有的服务器使用,此时有一批特殊应用的服务器需要不通的报警参数,我们既不想单独新建模版来一个一个添加报警参数,又不想修改默认模版而影响其他机器的报警阈值。此时我们就需要用深拷贝来完成。示例如下:
默认模版:
call = { 'cpu':80, 'mem':80, 'disk':80 }
此时的特殊模版需求是cpu报警阀值要改成75,而不影响默认模版使用
代码如下:
import copy #默认模版 call = { 'cpu':[80,], 'mem':[80,], 'disk':[80,] } #新模板 new_call = copy.deepcopy(call) #修改新模版 new_call['cpu'] = 75 #查看新旧模版的值 print('新的模版为:%s' %(new_call)) print('默认模版为:%s' %(call)) #打印结果: #新的模版为:{'mem': 80, 'disk': 80, 'cpu': 75} #默认模版为:{'mem': 80, 'disk': 80, 'cpu': 80} #上面的代码显示我们只改了新的模版,而默认模版并没有修改,并且我们用了copy而不是单独新建模版。
假设我们用浅copy来做结果是这样的:
import copy #默认模版 call = { 'cpu':[80,], 'mem':[80,], 'disk':[80,] } #新模板 new_call = copy.copy(call) #修改新模版 new_call['cpu'] = 75 #查看新旧模版的值 print('新的模版为:%s' %(new_call)) print('默认模版为:%s' %(call)) #打印的结果: #新的模版为:{'mem': [80], 'disk': [80], 'cpu': [75]} #默认模版为:{'mem': [80], 'disk': [80], 'cpu': [75]} #默认模版和新模版都被修改了,显然这不是我们要的结果
分析原因:深拷贝的时候python将字典的所有数据在内存中新建了一份,所以如果你修改新的模版的时候老模版不会变。相反,在浅copy 的时候,python仅仅将最外层的内容在内存中新建了一份出来,字典第二层的列表并没有在内存中新建,所以你修改了新模版,默认模版也被修改了。
- Python垃圾回收机制?
Python中的垃圾回收是以引用计数为主,标记-清除和分代收集为辅。
引用计数:Python在内存中存储每个对象的引用计数,如果计数变成0,该对象就会消失,分配给该对象的内存就会释放出来。
标记-清除:一些容器对象,比如list、dict、tuple,instance等可能会出现引用循环,对于这些循环,垃圾回收器会定时回收这些循环(对象之间通过引用(指针)
连在一起,构成一个有向图,对象构成这个有向图的节点,而引用关系构成这个有向图的边)。
分代收集:Python把内存根据对象存活时间划分为三代,对象创建之后,垃圾回收器会分配它们所属的代。每个对象都会被分配一个代,而被分配更年轻的代是被优先处理的,因此越晚创建的对象越容易被回收。
- Python的可变类型和不可变类型?
Python的每个对象都分为可变和不可变
可变:列表、字典
不可变:数字、字符串、元祖
对不可变类型的变量重新赋值,实际上是重新创建一个不可变类型的对象,并将原来的变量重新指向新创建的对象(如果没有其他变量引用原有对象的话(即引用计数为0),原有对象就会被回收)。
不可变类型
以int类型为例:实际上 i += 1 并不是真的在原有的int对象上+1,而是重新创建一个value为6的int对象,i引用自这个新的对象。
>>> i = 5 >>> i += 1 >>> i 6 >>> id(i) 140243713967984 # 通过id函数查看变量i的内存地址进行验证(使用hex(id(i)) 可以查看16进制的内存地址) >>> i += 1 >>> i 7 >>> id(i) 140243713967960
可以看到执行 i += 1 时,内存地址都会变化,因为int 类型是不可变的。
再改改代码,但多个int类型的变量值相同时,看看它们内存地址是否相同。
>>> i = 5 >>> j = 5 >>> id(i) 140656970352216 >>> id(j) 140656970352216 >>> k = 5 >>> id(k) 140656970352216 >>> x = 6 >>> id(x) 140656970352192 >>> y = 6 >>> id(y) 140656970352192 >>> z = 6 >>> id(z) 140656970352192
对于不可变类型int,无论创建多少个不可变类型,只要值相同,都指向同个内存地址。同样情况的还有比较短的字符串。
对于其他类型则不同,以浮点类型为例,从代码运行结果可以看出它是个不可变类型:对i的值进行修改后,指向新的内存地址。
修改代码声明两个相同值的浮点型变量,查看它们的id,发现它们并不是指向同个内存地址,这点和int类型不同(这方面涉及Python内存管理机制,Python对int类型和较短的字符串进行了缓存,无论声明多少个值相同的变量,实际上都指向同个内存地址。)
可变类型
可变类型的话,以list为例。list在append之后,还是指向同个内存地址,因为list是可变类型,可以在原处修改。
改改代码,当存在多个值相同的不可变类型变量时,看看它们是不是跟可变类型一样指向同个内存地址
从运行结果可以看出,虽然a、b的值相同,但是指向的内存地址不同。我们也可以通过b = a 的赋值语句,让他们指向同个内存地址:
>>> a = [1, 2, 3] >>> id(a) 4435060856 >>> b = [1, 2, 3] >>> id(b) 4435102392 >>> b = a >>> id(b) 4435060856
这个时候需要注意,因为a、b指向同个内存地址,而a、b的类型都是List,可变类型,对a、b任意一个List进行修改,都会影响另外一个List的值。
>>> a = [1, 2, 3] >>> id(a) #4435060856 >>> b = [1, 2, 3] >>> id(b) #4435102392 >>> b = a >>> id(b) #4435060856 >>> b.append(4) >>> a [1, 2, 3, 4] >>> b [1, 2, 3, 4] >>> id(a) #4435060856 >>> id(b) #4435060856
代码中,b变量append(4),对a变量也是影响的。输出他们的内存地址,还是指向同个内存地址。
总结:
1、对于不可变类型,无论创建多少个不可变类型,只要值相同,都指向同个内存地址(若值不同,那么一定指向不同的内存地址)。
2、对于可变类型,无论创建多少个可变类型,只要值相同,都不指向同个内存地址(除非进行复制操作,那么他们将会指向同一个地址)。
Python是如何进行类型转换的?- 列举常见的内置函数?
作用域相关
基于字典的形式获取局部变量和全局变量
globals()——获取全局变量的字典
locals()——获取执行本方法所在命名空间内的局部变量的字典
其他
字符串类型代码的执行
http://www.cnblogs.com/Eva-J/articles/7266087.html
输入输出相关:
input() 输入
s = input("请输入内容 : ") #输入的内容赋值给s变量 print(s) #输入什么打印什么。数据类型是str
print() 输出
f = open('tmp_file','w') print(123,456,sep=',',file = f,flush=True)
import time for i in range(0,101,2): time.sleep(0.1) char_num = i//2 #打印多少个'*' per_str = ' %s%% : %s ' % (i, '*' * char_num) if i == 100 else ' %s%% : %s'%(i,'*'*char_num) print(per_str,end='', flush=True) #小越越 : 可以把光标移动到行首但不换行
数据类型相关:
type(o) 返回变量o的数据类型
内存相关:
id(o) o是参数,返回一个变量的内存地址
hash(o) o是参数,返回一个可hash变量的哈希值,不可hash的变量被hash之后会报错。
t = (1,2,3) l = [1,2,3] print(hash(t)) #可hash print(hash(l)) #会报错 ''' 结果: TypeError: unhashable type: 'list' '''
*每一次执行程序,内容相同的变量hash值在这一次执行过程中不会发生改变。
文件操作相关
open() 打开一个文件,返回一个文件操作符(文件句柄)
操作文件的模式有r,w,a,r+,w+,a+ 共6种,每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
可以用encoding指定编码.
模块操作相关
__import__导入一个模块
import time
os = __import__('os') print(os.path.abspath('.'))
帮助方法
在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出
或者直接执行help(o),o是参数,查看和变量o有关的操作。。。
和调用相关
callable(o),o是参数,看这个变量是不是可调用。
如果o是一个函数名,就会返回True
def func():pass print(callable(func)) #参数是函数名,可调用,返回True print(callable(123)) #参数是数字,不可调用,返回False
查看参数所属类型的所有内置方法
dir() 默认查看全局空间内的属性,也接受一个参数,查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法 print(dir(int)) #查看整数的内置方法
和数字相关
数字——数据类型相关:bool,int,float,complex
数字——进制转换相关:bin,oct,hex
数字——数学运算:abs,divmod,min,max,sum,round,pow
和数据结构相关
序列——列表和元组相关的:list和tuple
序列——字符串相关的:str,format,bytes,bytearry,memoryview,ord,chr,ascii,repr
ret = bytearray('alex',encoding='utf-8') print(id(ret)) print(ret[0]) ret[0] = 65 print(ret) print(id(ret))
ret = memoryview(bytes('你好',encoding='utf-8')) print(len(ret)) print(bytes(ret[:3]).decode('utf-8')) print(bytes(ret[3:]).decode('utf-8'))
序列:reversed,slice
l = (1,2,23,213,5612,342,43) print(l) print(list(reversed(l)))
l = (1,2,23,213,5612,342,43) sli = slice(1,5,2) print(l[sli])
数据集合——字典和集合:dict,set,frozenset
数据集合:len,sorted,enumerate,all,any,zip,filter,map
filter
filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。
例如,要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数,保留奇数,首先,要编写一个判断奇数的函数:
def is_odd(x): return x % 2 == 1
然后,利用filter()过滤掉偶数:
>>>filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
结果:
[1, 7, 9, 17]
利用filter(),可以完成很多有用的功能,例如,删除 None 或者空字符串:
def is_not_empty(s): return s and len(s.strip()) > 0 >>>filter(is_not_empty, ['test', None, '', 'str', ' ', 'END'])
结果:
['test', 'str', 'END']
注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
当rm为空时,默认删除空白符(包括' ', ' ', ' ', ' '),如下:
>>> a = ' 123'
>>> a.strip()
'123'
>>> a = ' 123 '
>>> a.strip()
'123'
map
Python中的map函数应用于每一个可迭代的项,返回的是一个结果list。如果有其他的可迭代参数传进来,map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序列的每个元素,并把结果作为新的list返回。
有一个list, L = [1,2,3,4,5,6,7,8],我们要将f(x)=x^2作用于这个list上,那么我们可以使用map函数处理。
>>> L = [1,2,3,4,] >>> def pow2(x): ... return x*x ... >>> map(pow2,L) [1, 4, 9, 16]
sorted方法:
对给定的List L进行排序,
方法1.用List的成员函数sort进行排序,在本地进行排序,不返回副本
方法2.用built-in函数sorted进行排序(从2.4开始),返回副本,原始输入不变
--------------------------------sorted---------------------------------------
sorted(iterable, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customise the sort order, and the
reverse flag can be set to request the result in descending order.
-----------------------------------------------------------------------------
参数说明:
iterable:是可迭代类型;
key:传入一个函数名,函数的参数是可迭代类型中的每一项,根据函数的返回值大小排序;
reverse:排序规则. reverse = True 降序 或者 reverse = False 升序,有默认值。
返回值:有序列表
l1 = [1,3,5,-2,-4,-6] l2 = sorted(l1,key=abs) print(l1) print(l2)
列表按照每一个元素的len排序
l = [[1,2],[3,4,5,6],(7,),'123'] print(sorted(l,key=len))
请务必重点掌握:
其他:input,print,type,hash,open,import,dir
str类型代码执行:eval,exec
数字:bool,int,float,abs,divmod,min,max,sum,round,pow
序列——列表和元组相关的:list和tuple
序列——字符串相关的:str,bytes,repr
序列:reversed,slice
数据集合——字典和集合:dict,set,frozenset
数据集合:len,sorted,enumerate,zip,filter,map
- filter、map、reduce的作用?
通俗的说..都是用在一堆数据(比如一个列表)上..
map是用同样方法把所有数据都改成别的..字面意思是映射..比如把列表的每个数都换成其平方..
reduce是用某种方法依次把所有数据丢进去最后得到一个结果..字面意思是化简..比如计算一个列表所有数的和的过程,就是维持一个部分和然后依次把每个数加进去..
filter是筛选出其中满足某个条件的那些数据..字面意思是过滤..比如挑出列表中所有奇数..
>>> map(lambda x:x*x,[0,1,2,3,4,5,6]) [0, 1, 4, 9, 16, 25, 36] >>> reduce(lambda x,y:x+y,[0,1,2,3,4,5,6]) 21 >>> filter(lambda x:x&1,[0,1,2,3,4,5,6]) [1, 3, 5]
-
- 一行代码实现9*9乘法表
print (' '.join([' '.join(['%s*%s=%-2s' % (y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)]))
- 如何安装第三方模块?以及用过哪些第三方模块?
在Python中,安装第三方模块,是通过setuptools这个工具完成的。Python有两个封装了setuptools的包管理工具:easy_install和pip。目前官方推荐使用pip
如果你正在使用Mac或Linux,安装pip本身这个步骤就可以跳过了。
如果你正在使用Windows,确保安装时勾选了pip和Add python.exe to Path。
在命令提示符窗口下尝试运行pip,如果Windows提示未找到命令,可以重新运行安装程序添加pip。
现在,让我们来安装一个第三方库——Python Imaging Library,这是Python下非常强大的处理图像的工具库。一般来说,第三方库都会在Python官方的pypi.python.org网站注册,要安装一个第三方库,必须先知道该库的名称,可以在官网或者pypi上搜索,比如Python Imaging Library的名称叫PIL,因此,安装Python Imaging Library的命令就是:
pip install PIL
耐心等待下载并安装后,就可以使用PIL了。
有了PIL,处理图片易如反掌。随便找个图片生成缩略图:
>>> import Image >>> im = Image.open('test.png') >>> print im.format, im.size, im.mode PNG (400, 300) RGB >>> im.thumbnail((200, 100)) >>> im.save('thumb.jpg', 'JPEG')
其他常用的第三方库还有MySQL的驱动:MySQL-python,用于科学计算的NumPy库:numpy,用于生成文本的模板工具Jinja2,等等。
模块搜索路径
当我们试图加载一个模块时,Python会在指定的路径下搜索对应的.py文件,如果找不到,就会报错:
>>> import mymodule Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: No module named mymodule
默认情况下,Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块,搜索路径存放在sys模块的path变量中:
>>> import sys >>> sys.path ['', '/Library/Python/2.7/site-packages/pycrypto-2.6.1-py2.7-macosx-10.9-intel.egg', '/Library/Python/2.7/site-packages/PIL-1.1.7-py2.7-macosx-10.9-intel.egg', ...]
如果我们要添加自己的搜索目录,有两种方法:
一是直接修改sys.path,添加要搜索的目录:
这种方法是在运行时修改,运行结束后失效。
第二种方法是设置环境变量PYTHONPATH,该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path环境变量类似。注意只需要添加你自己的搜索路径,Python自己本身的搜索路径不受影响。
- 至少列举8个常用模块都有那些?
1、Django
2、pip
3、pillow-python
4、pygame
5、pyMysql
6、pytz
7、opencv-python
8、numpy
- re的match和search区别?
1、match()函数只检测RE是不是在string的开始位置匹配,search()会扫描整个string查找匹配;
2、也就是说match()只有在0位置匹配成功的话才有返回,如果不是开始位置匹配成功的话,match()就返回none。
3、例如:import re print(re.match('super', 'superstition').span()) # (0,5) print(re.match('super', 'insuperable')) # None
4、search()会扫描整个字符串并返回第一个成功的匹配:
例如:import re print(re.search('super', 'superstition').span()) #(0,5) print(re.search('super', 'insuperable')) # <_sre.SRE_Match object; span=(2, 7), match='super'>
5、其中span函数定义如下,返回位置信息:
span([group]):
返回(start(group), end(group))。
- 什么是正则的贪婪匹配?
1、贪婪匹配
总是尝试匹配尽可能多的字符
2、非贪婪匹配
是尝试匹配尽可能少的字符
import re secret_code = 'hadkfalifexxIxxfasdjifja134xxlovexx23345sdfxxyouxx8dfse' b = re.findall('xx.*xx',secret_code) # 贪婪匹配 print (b) # ['xxIxxfasdjifja134xxlovexx23345sdfxxyouxx'] c = re.findall('xx.*?xx',secret_code) # 非贪婪匹配 print(c) # ['xxIxx', 'xxlovexx', 'xxyouxx']
贪婪格式:xx.*xx
非贪婪格式:xx.*?xx
区别重点在:.* 和 .*?
Python里面如何实现tuple和list的转换- #From list to Tuple
- tuple(a_list)
- #From Tuple to List
- def to_list(t):
- return [i if not isinstance(i,tuple) else to_list(i) for i in t]
- def func(a,b=[]) 这种写法有什么坑?
那我们先通过程序看看这个函数有什么坑吧!
看下结果
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
函数的第二个默认参数是一个list,当第一次执行的时候实例化了一个list,第二次执行还是用第一次执行的时候实例化的地址存储,所以三次执行的结果就是 [1, 1, 1] ,想每次执行只输出[1] ,默认参数应该设置为None。
- 如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?
"1,2,3".split(',')
"1,2,3".split(',')
- 如何实现[‘1’,’2’,’3’]变成[1,2,3] ?
a=['1','2','3'] b=[int(i) for i in a] print(b)
输出为:[1, 2, 3]
- 比较: a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别?
- 如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
y = [x*x for x in range (1,11)]
print(y)
输出为:[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
方法二:
[i*i for i in range(11)]
输出为:[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
- 一行代码实现删除列表中重复的值 ?
使用set()方法!
list0=['b','c', 'd','b','c','a','a'] print(sorted(set(list0),key=list0.index)) # sorted output
- 如何在函数中设置一个全局变量 ?
在函数的内部,通过global声明,使在函数内部中设置一个全局变量,这个全局变量可以在任意的函数中进行调用!
SOLR_URL='http://solr.org' def tt(): global SOLR_URL SOLR_URL=SOLR_URL+'#aa' def aa(): if __name__=='__main__': tt() print(SOLR_URL) aa() # http://solr.org#aa
- logging模块的作用?以及应用场景?
通过log的分析,可以方便用户了解系统或软件、应用的运行情况;如果你的应用log足够丰富,也可以分析以往用户的操作行为、类型喜好、地域分布或其他更多信息;如果一个应用的log同时也分了多个级别,那么可以很轻易地分析得到该应用的健康状况,及时发现问题并快速定位、解决问题,补救损失。
简单来讲就是,我们通过记录和分析日志可以了解一个系统或软件程序运行情况是否正常,也可以在应用程序出现故障时快速定位问题。比如,做运维的同学,在接收到报警或各种问题反馈后,进行问题排查时通常都会先去看各种日志,大部分问题都可以在日志中找到答案。再比如,做开发的同学,可以通过IDE控制台上输出的各种日志进行程序调试。对于运维老司机或者有经验的开发人员,可以快速的通过日志定位到问题的根源。可见,日志的重要性不可小觑。日志的作用可以简单总结为以下3点:
- 程序调试
- 了解软件程序运行情况,是否正常
- 软件程序运行故障分析与问题定位
如果应用的日志信息足够详细和丰富,还可以用来做用户行为分析,如:分析用户的操作行为、类型洗好、地域分布以及其它更多的信息,由此可以实现改进业务、提高商业利益。
logging模块默认定义了以下几个日志等级,它允许开发人员自定义其他日志级别,但是这是不被推荐的,尤其是在开发供别人使用的库时,因为这会导致日志级别的混乱。
日志等级(level) | 描述 |
---|---|
DEBUG | 最详细的日志信息,典型应用场景是 问题诊断 |
INFO | 信息详细程度仅次于DEBUG,通常只记录关键节点信息,用于确认一切都是按照我们预期的那样进行工作 |
WARNING | 当某些不期望的事情发生时记录的信息(如,磁盘可用空间较低),但是此时应用程序还是正常运行的 |
ERROR | 由于一个更严重的问题导致某些功能不能正常运行时记录的信息 |
CRITICAL | 当发生严重错误,导致应用程序不能继续运行时记录的信息 |
开发应用程序或部署开发环境时,可以使用DEBUG或INFO级别的日志获取尽可能详细的日志信息来进行开发或部署调试;应用上线或部署生产环境时,应该使用WARNING或ERROR或CRITICAL级别的日志来降低机器的I/O压力和提高获取错误日志信息的效率。日志级别的指定通常都是在应用程序的配置文件中进行指定的。
说明:
- 上面列表中的日志等级是从上到下依次升高的,即:DEBUG < INFO < WARNING < ERROR < CRITICAL,而日志的信息量是依次减少的;
- 当为某个应用程序指定一个日志级别后,应用程序会记录所有日志级别大于或等于指定日志级别的日志信息,而不是仅仅记录指定级别的日志信息,nginx、php等应用程序以及这里要提高的python的logging模块都是这样的。同样,logging模块也可以指定日志记录器的日志级别,只有级别大于或等于该指定日志级别的日志记录才会被输出,小于该等级的日志记录将会被丢弃。
- 可以参考该人的博客:https://www.cnblogs.com/yyds/p/6901864.html
- 请用代码简答实现stack 。
栈和队列是两种基本的数据结构,同为容器类型。两者根本的区别在于:
stack:后进先出
queue:先进先出
PS:stack和queue是不能通过查询具体某一个位置的元素而进行操作的。但是他们的排列是按顺序的
对于stack我们可以使用python内置的list实现,因为list是属于线性数组,在末尾插入和删除一个元素所使用的时间都是O(1),这非常符合stack的要求。当然,我们也可以使用链表来实现。
stack的实现代码(使用python内置的list),实现起来是非常的简单,就是list的一些常用操作
class Stack(object): def __init__(self): self.stack = [] def push(self, value): # 进栈 self.stack.append(value) def pop(self): #出栈 if self.stack: self.stack.pop() else: raise LookupError('stack is empty!') def is_empty(self): # 如果栈为空 return bool(self.stack) def top(self): #取出目前stack中最新的元素 return self.stack[-1]
我们定义如下的链表来实现队列数据结构:
定义一个头结点,左边指向队列的开头,右边指向队列的末尾,这样就可以保证我们插入一个元素和取出一个元素都是O(1)的操作,使用这种链表实现stack也是非常的方便。实现代码如下:
class Head(object): def __init__(self): self.left = None self.right = None class Node(object): def __init__(self, value): self.value = value self.next = None class Queue(object): def __init__(self): #初始化节点 self.head = Head() def enqueue(self, value): #插入一个元素 newnode = Node(value) p = self.head if p.right: #如果head节点的右边不为None #说明队列中已经有元素了 #就执行下列的操作 temp = p.right p.right = newnode temp.next = newnode else: #这说明队列为空,插入第一个元素 p.right = newnode p.left = newnode def dequeue(self): #取出一个元素 p = self.head if p.left and (p.left == p.right): #说明队列中已经有元素 #但是这是最后一个元素 temp = p.left p.left = p.right = None return temp.value elif p.left and (p.left != p.right): #说明队列中有元素,而且不止一个 temp = p.left p.left = temp.next return temp.value else: #说明队列为空 #抛出查询错误 raise LookupError('queue is empty!') def is_empty(self): if self.head.left: return False else: return True def top(self): #查询目前队列中最早入队的元素 if self.head.left: return self.head.left.value else: raise LookupError('queue is empty!')
- 常用字符串格式化哪几种?
Python的字符串格式化常用的有三种!-
第一种:最方便的
缺点:需一个个的格式化
print('hello %s and %s'%('df','another df'))
第二种:最好用的
优点:不需要一个个的格式化,可以利用字典的方式,缩短时间
print('hello %(first)s and %(second)s'%{'first':'df' , 'second':'another df'})
第三种:最先进的
优点:可读性强
print('hello {first} and {second}'.format(first='df',second='another df'))
- 简述 生成器、迭代器、可迭代对象 以及应用场景?
迭代器:是访问集合元素的一种方式,从集合的第一个元素开始访问,直到所有元素被访问结束。其优点是不需要事先准备好整个迭代过程中的所有元素,仅在迭代到某个元素时才开始计算该元素。适合遍历比较巨大的集合。__iter__():方法返回迭代器本身, __next__():方法用于返回容器中下一个元素或数据。
生成器:带有yield的函数不再是一个普通函数,而是一个生成器。当函数被调用时,返回一个生成器对象。不像一般函数在生成值后退出,生成器函数在生成值后会自动挂起并暂停他们的执行状态。
'''迭代器'''
print('for x in iter([1, 2, 3, 4, 5]):')
for x in iter([1, 2, 3, 4, 5]):
print(x)
'''生成器'''
def myyield(n):
while n>0:
print("开始生成...:")
yield n
print("完成一次...:")
n -= 1
for i in myyield(4):
print("遍历得到的值:",i)
- 用Python实现一个二分查找的函数