Python面试题汇总
原文:http://blog.csdn.net/jerry_1126/article/details/44023949
拿网络上关于Python的面试题汇总了,给出了自认为合理的答案,有些题目不错,可以从中学到点什么,答案如不妥,请指正......
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
【题目:001】| 说说你对zen of python的理解,你有什么办法看到它?
Python之禅,Python秉承一种独特的简洁和可读行高的语法,以及高度一致的编程模式,符合“大脑思维习惯”,使Python易于学习、理解和记忆。Python同时采用了一条极简主义的设计理念,了解完整的Python哲学理念,可以在任何一个Python交互解释器中键入import this命令,这是Python隐藏的一个彩蛋:描绘了一系列Python设计原则。如今已是Python社区内流行的行话"EIBTI",明了胜于晦涩这条规则的简称. 在Python的思维方式中,明了胜于晦涩,简洁胜于复杂。
- >>> import this
- The Zen of Python, by Tim Peters
- Beautiful is better than ugly.
- Explicit is better than implicit.
- Simple is better than complex.
- Complex is better than complicated.
- Flat is better than nested.
- Sparse is better than dense.
- Readability counts.
- Special cases aren't special enough to break the rules.
- Although practicality beats purity.
- Errors should never pass silently.
- Unless explicitly silenced.
- In the face of ambiguity, refuse the temptation to guess.
- There should be one-- and preferably only one --obvious way to do it.
- Although that way may not be obvious at first unless you're Dutch.
- Now is better than never.
- Although never is often better than *right* now.
- If the implementation is hard to explain, it's a bad idea.
- If the implementation is easy to explain, it may be a good idea.
- Namespaces are one honking great idea -- let's do more of those!
【题目:002】| 说说你对pythonic的看法,尝试解决下面的小问题
#简洁,明了,严谨,灵活
- #交换两个变量值
- a,b = b,a
- #去掉list中的重复元素
- old_list = [1,1,1,3,4]
- new_list = list(set(old_list))
- #翻转一个字符串
- s = 'abcde'
- ss = s[::-1]
- #用两个元素之间有对应关系的list构造一个dict
- names = ['jianpx', 'yue']
- ages = [23, 40]
- m = dict(zip(names,ages))
- #将数量较多的字符串相连,如何效率较高,为什么
- fruits = ['apple', 'banana']
- result = ''.join(fruits)
- #python字符串效率问题之一就是在连接字符串的时候使用‘+’号,例如 s = ‘s1’ + ‘s2’ + ‘s3’ + ...+’sN’,总共将N个字符串连接起来, 但是使用+号的话,python需要申请N-1次内存空间, 然后进行字符串拷贝。原因是字符串对象PyStringObject在python当中是不可变 对象,所以每当需要合并两个字符串的时候,就要重新申请一个新的内存空间 (大小为两个字符串长度之和)来给这个合并之后的新字符串,然后进行拷贝。 所以用+号效率非常低。建议在连接字符串的时候使用字符串本身的方法 join(list),这个方法能提高效率,原因是它只是申请了一次内存空间, 因为它可以遍历list中的元素计算出总共需要申请的内存空间的大小,一次申请完。
【题目:003】| 你调试python代码的方法有哪些?
- 具体IDE都有调试,比如:IDLE, Eclipse+Pydev都可以设置断点调试。
- pdb模块也可以做调试。
- 还有PyChecker和Pylint
- PyChecker是一个python代码的静态分析工具,它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告
- Pylint 是另外一个工具可以进行coding standard检查。
【题目:004】| 你在github上都fork过哪些python库,列举一下你经常使用的,每个库用一句话描述下其功能
- http://rogerdudler.github.io/git-guide/index.zh.html #关于git简明指南
- http://www.zhihu.com/question/20070065 #关于git的BBS
- http://www.techug.com/githug-for-designer #关于github的
【题目:005】| 什么是GIL?
- 什么是GIL(Global Interpreter Lock)全局解释器锁? 简单地说就是:
- 每一个interpreter进程,只能同时仅有一个线程来执行, 获得相关的锁, 存取相关的资源.
- 那么很容易就会发现,如果一个interpreter进程只能有一个线程来执行,
- 多线程的并发则成为不可能, 即使这几个线程之间不存在资源的竞争.
- 从理论上讲,我们要尽可能地使程序更加并行, 能够充分利用多核的功能.
【题目:006】| 什么是元类(meta_class)?
- 元类就是用来创建类的“东西”
- 详情操作: http://blog.jobbole.com/21351/
【题目:007】| 对比一下dict中items与iteritems?
- >>> D = {'a':1,'b':2,'c':3,'d':4}
- >>> D.items() #一次性取出所有
- [('a', 1), ('c', 3), ('b', 2), ('d', 4)]
- >>> D.iteritems() #迭代对象,每次取出一个。用for循环遍历出来;
- <dictionary-itemiterator object at 0x00000000026243B8>
- >>> for i in D.iteritems():
- ... print i,
- ...
- ('a', 1) ('c', 3) ('b', 2) ('d', 4)
- >>> for k,v in D.iteritems():
- ... print k,
- ...
- a c b d
- 总结:
- 1. 一般iteritems()迭代的办法比items()要快,特别是数据库比较大时。
- 2. 在Python3中一般取消前者函数
【题目:008】| 是否遇到过python的模块间循环引用的问题,如何避免它?
- 这是代码结构设计的问题,模块依赖和类依赖
- 如果老是觉得碰到循环引用,很可能是模块的分界线划错地方了。可能是把应该在一起的东西硬拆开了,可能是某些职责放错地方了,可能是应该抽象的东西没抽象
- 总之微观代码规范可能并不能帮到太多,重要的是更宏观的划分模块的经验技巧,推荐uml,脑图,白板等等图形化的工具先梳理清楚整个系统的总体结构和职责分工
- 采取办法,从设计模式上来规避这个问题,比如:
- 1. 使用 “__all__” 白名单开放接口
- 2. 尽量避免 import
【题目:009】| 有用过with statement吗?它的好处是什么?
- >>> with open('text.txt') as myfile:
- ... while True:
- ... line = myfile.readline()
- ... if not line:
- ... break
- ... print line,
- # with语句使用所谓的上下文管理器对代码块进行包装,允许上下文管理器实现一些设置和清理操作。
- # 例如:文件可以作为上下文管理器使用,它们可以关闭自身作为清理的一部分。
- # NOTE:在PYTHON2.5中,需要使用from __future__ import with_statement进行with语句的导入
【题目:010】|用Python生成指定长度的斐波那契数列
- def fibs(x):
- result = [0, 1]
- for index in range(x-2):
- result.append(result[-2]+result[-1])
- return result
- if __name__=='__main__':
- num = input('Enter one number: ')
- print fibs(num)
【题目:011】| Python里如何生产随机数
- >>> import random
- >>> random.random()
- 0.29495314937268713
- >>> random.randint(1,11)
- 8
- >>> random.choice(range(11))
- 3
【题目:012】| Python里如何反序的迭代一个序列
- 如果是一个list, 最快的解决方案是:
- list.reverse()
- try:
- for x in list:
- “do something with x”
- finally:
- list.reverse()
- 如果不是list, 最通用但是稍慢的解决方案是:
- for i in range(len(sequence)-1, -1, -1):
- x = sequence[i]
【题目:013】| Python中如何定义一个函数
- def func(arg, *args, **kwagrs): #普通函数
- func_body
- return
- lambda x: x **2 #匿名函数
【题目:014】| Python匹配HTML tag的时候,<.*>和<.*?>有什么区别
- import re
- s = ‘<html><head><title>Title</title>’
- print(re.match(‘<.*>’, s).group())
- 会返回一个匹配<html><head><title>Title</title>而不是<html>
- 而
- import re
- s = ‘<html><head><title>Title</title>’
- print(re.match(‘<.*?>’, s).group())
- 则会返回<html>
- <.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配
【题目:015】| Python里面search()和match()的区别
- >>> import re
- >>> re.match(r'python','Programing Python, should be pythonic')
- >>> obj1 = re.match(r'python','Programing Python, should be pythonic') #返回None
- >>> obj2 = re.search(r'python','Programing Python, should be pythonic') #找到pythonic
- >>> obj2.group()
- 'python'
- #re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None;
- #re.search匹配整个字符串,直到找到一个匹配。
【题目:016】| Python程序中文输出问题怎么解决
- 在Python3中,对中文进行了全面的支持,但在Python2.x中需要进行相关的设置才能使用中文。否则会出现乱码。
- Python默认采取的ASCII编码,字母、标点和其他字符只使用一个字节来表示,但对于中文字符来说,一个字节满足不了需求。
- 为了能在计算机中表示所有的中文字符,中文编码采用两个字节表示。如果中文编码和ASCII混合使用的话,就会导致解码错误,从而才生乱码。
- 解决办法:
- 交互式命令中:一般不会出现乱码,无需做处理
- py脚本文件中:跨字符集必须做设置,否则乱码
- 1. 首先在开头一句添加:
- # coding = utf-8
- # 或
- # coding = UTF-8
- # 或
- # -*- coding: utf-8 -*-
- 2. 其次需将文件保存为UTF-8的格式!
- 3. 最后: s.decode('utf-8').encode('gbk')
【题目:017】| 什么是lambda函数
- 函数使用:
- 1. 代码块重复,这时候必须考虑到函数,降低程序的冗余度
- 2. 代码块复杂,这时候必须考虑到函数,降低程序的复杂度
- Python有两种函数,一种是def定义,一种是lambda函数()
- 当程序代码很短,且该函数只使用一次,为了程序的简洁,及节省变量内存占用空间,引入了匿名函数这个概念
- >>> nums = range(2,20)
- >>> for i in nums:
- nums = filter(lambda x:x==i or x % i,nums)
- >>> nums
- [2, 3, 5, 7, 11, 13, 17, 19]
【题目:018】| 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]
【题目:019】| 请写出一段Python代码实现删除一个list里面的重复元素
- >>> L1 = [4,1,3,2,3,5,1]
- >>> L2 = []
- >>> [L2.append(i) for i in L1 if i not in L2]
- >>> print L2
- [4, 1, 3, 2, 5]
【题目:020】| Python是如何进行类型转换的
- >>> int('1234') # 将数字型字符串转为整形
- 1234
- >>> float(12) # 将整形或数字字符转为浮点型
- 12.0
- >>> str(98) # 将其他类型转为字符串型
- '98'
- >>> list('abcd') # 将其他类型转为列表类型
- ['a', 'b', 'c', 'd']
- >>> dict.fromkeys(['name','age']) # 将其他类型转为字典类型
- {'age': None, 'name': None}
- >>> tuple([1, 2, 3, 4]) # 将其他类型转为元祖类型
- (1, 2, 3, 4)
详细转换总结如下:
- 函数 描述
- int(x [,base]) 将x转换为一个整数
- long(x [,base] ) 将x转换为一个长整数
- float(x) 将x转换到一个浮点数
- complex(real [,imag]) 创建一个复数
- str(x) 将对象 x 转换为字符串
- repr(x) 将对象 x 转换为表达式字符串
- eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
- tuple(s) 将序列 s 转换为一个元组
- list(s) 将序列 s 转换为一个列表
- set(s) 转换为可变集合
- dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
- frozenset(s) 转换为不可变集合
- chr(x) 将一个整数转换为一个字符
- unichr(x) 将一个整数转换为Unicode字符
- ord(x) 将一个字符转换为它的整数值
- hex(x) 将一个整数转换为一个十六进制字符串
- oct(x) 将一个整数转换为一个八进制字符串
【题目:021】| 如何知道一个Python对象的类型
- >>> type([]);type('');type(0);type({});type(0.0);type((1,))
- <type 'list'>
- <type 'str'>
- <type 'int'>
- <type 'dict'>
- <type 'float'>
- <type 'tuple'>
【题目:022】| Python里面如何拷贝一个对象
- 切片S[:] # 注不能应用于字典
- 深浅宝贝 # 能应用于所有序列和字典
- 1. 浅拷贝D.copy()方法
- 2. 深拷贝deepcopy(D)方法
【题目:023】| Python中pass语句的作用是什么
- pass语句什么也不做,一般作为占位符或者创建占位程序
【题目:024】| 写一段程序逐行读入一个文本文件,并在屏幕上打印出来
- f = open(filename)
- while True:
- line = f.readline()
- if not line: break
- print(line)
- f.close()
【题目:025】| 如何用Python删除一个文件
- import os
- os.remove(filename)
【题目:026】| Python代码得到列表list的交集与差集
- >>> list1 = [1, 3, 4, 6]
- >>> list2 = [1, 2, 3, 4]
- >>> [i for i in list1 if i not in list2]
- [6]
- >>> [i for i in list1 if i in list2]
- [1, 3, 4]
【题目:027】| Python是如何进行内存管理的
- python内部使用引用计数,来保持追踪内存中的对象,Python内部记录了对象有多少个引用,即引用计数,当对象被创建时就创建了一个引用计数,当对象不再需要时,这个对象的引用计数为0时,它被垃圾回收。所有这些都是自动完成,不需要像C一样,人工干预,从而提高了程序员的效率和程序的健壮性。
【题目:028】| 介绍一下Python下range()函数的用法
- >>> range(10)
- [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- >>> range(1, 10)
- [1, 2, 3, 4, 5, 6, 7, 8, 9]
- >>> range(0, 9, 2)
- [0, 2, 4, 6, 8]
- >>> range(99,0,-10)
- [99, 89, 79, 69, 59, 49, 39, 29, 19, 9]
- 相区别的是xrange(),每次只取出一个迭代对象,如果是数据量比较大时,效率较高
- 在Python3中,没有xrange()函数,其功能放在了range()函数上
【题目:029】| Python异常处理介绍一下
- 程序中出现异常情况时就需要异常处理。比如当你打开一个不存在的文件时。当你的程序中有
- 一些无效的语句时,Python会提示你有错误存在。下面是一个拼写错误的例子,print写成了Print
- 下面是异常最常见的几种角色
- 1. 错误处理
- >>>可以在程序代码中捕捉和相应错误,或者忽略已发生的异常。
- >>>如果忽略错误,PYTHON默认的异常处理行为将启动:停止程序,打印错误信息。
- >>>如果不想启动这种默认行为,就用try语句来捕捉异常并从异常中恢复。
- 2. 事件通知
- >>>异常也可用于发出有效状态的信号,而不需在程序间传递结果标志位。或者刻意对其进行测试
- 3. 特殊情况处理
- >>>有时,发生了某种很罕见的情况,很难调整代码区处理。通常会在异常处理中处理,从而省去应对特殊情况的代码
- 4. 终止行为
- >>>try/finally语句可确保一定会进行需要的结束运算,无论程序是否有异常
- 5. 非常规控制流程
【题目:030】| 介绍一下Python中的filter方法
- filter就像map,reduce,apply,zip等都是内置函数,用C语言实现,具有速度快,功能强大等
- 优点。
- 用于过滤与函数func()不匹配的值, 类似于SQL中select value != 'a'
- 相当于一个迭代器,调用一个布尔函数func来迭代seq中的每个元素,返回一个是bool_seq返
- 回为True的序列
- >>>第一个参数: function or None, 函数或None
- >>>第二个参数: sequence,序列
【题目:031】| 介绍一下except的用法和作用
- try/except: 捕捉由PYTHON自身或写程序过程中引发的异常并恢复
- except: 捕捉所有其他异常
- except name: 只捕捉特定的异常
- except name, value: 捕捉异常及格外的数据(实例)
- except (name1,name2) 捕捉列出来的异常
- except (name1,name2),value: 捕捉任何列出的异常,并取得额外数据
- else: 如果没有引发异常就运行
- finally: 总是会运行此处代码
【题目:032】| 如何用Python来进行查询和替换一个文本字符串
- >>> words = 'Python is a very funny language!'
- >>> words.find('Python') # 返回的为0或正数时,为其索引号
- 0
- >>> words.find('is')
- 7
- >>> words.find('dafa') # 返回-1表示查找失败
- -1
- >>> words.replace('Python', 'Perl') # replace()替换
- 'Perl is a very funny language!'
【题目:033】| Python如何copy一个文件
- import shutil
- shutil.copyfile('a.py', 'copy_a.py')
【题目:034】| Python判断当前用户是否是root
- import os
- if os.getuid() != 0: # root账号的uid=0
- print os.getuid()
- print 'Should run as root account'
- else:
- print 'Hello, Root!'
【题目:035】| 用Python写一个for循环的例子
- for循环可以遍历序列(列表,字符串,元祖),range()及迭代对象,如xrange()
- names = ['Alice', 'Betty', 'Fred', 'Tom']
- for index, name in enumerate(names):
- print 'index:',index,'=>', name
- # 输出结果
- index: 0 => Alice
- index: 1 => Betty
- index: 2 => Fred
- index: 3 => Tom
【题目:036】| 介绍一下Python中webbrowser的用法
- webbrowser模块提供了一个高级接口来显示基于Web的文档,大部分情况下只需要简单的调用open()方法。
- webbrowser定义了如下的异常:exception webbrowser.Error, 当浏览器控件发生错误是会抛出这个异常
- webbrowser有以下方法:
- webbrowser.open(url[, new=0[, autoraise=1]])
- 这个方法是在默认的浏览器中显示url, 如果new = 0, 那么url会在同一个浏览器窗口下打开,如果new = 1, 会打开一个新的窗口,如果new = 2, 会打开一个新的tab, 如果autoraise = true, 窗口会自动增长。
- webbrowser.open_new(url)
- 在默认浏览器中打开一个新的窗口来显示url, 否则,在仅有的浏览器窗口中打开url
- webbrowser.open_new_tab(url)
- 在默认浏览器中当开一个新的tab来显示url, 否则跟open_new()一样
- webbrowser.get([name]) 根据name返回一个浏览器对象,如果name为空,则返回默认的浏览器
- webbrowser.register(name, construtor[, instance])
- 注册一个名字为name的浏览器,如果这个浏览器类型被注册就可以用get()方法来获取。
【题目:037】| 默写尽可能多的str对象的方法
- #方法 #描述
- -------------------------------------------------------------------------------------------------
- S.capitalize() #返回首字母大写的字符串的副本
- S.center(width[,fillchar]) #返回一个长度为max(len(S),width),S居中,两侧fillchar填充
- S.count(sub[,start[,end]]) #计算子字符串sub的出现次数,可将搜索范围限制为S[start:end]
- S.decode([encoding[,error]]) #返回使用给定编码方式的字符串的解码版本,由error指定错误处理方式
- S.endswith(suffix[start[,end]]) #检查S是否以suffix结尾,可给定[start:end]来选择匹配的范围
- S.expandtabs([tabsize]) #返回字符串的副本,其中tab字符会使用空格进行扩展,可选择tabsize
- S.find(sun[,start[,end]]) #返回子字符串sub的第一个索引,不存在则为-1,可选择搜索范围
- S.index(sub[,start[,end]]) #返回子字符串sub的第一个索引,不存在则引发ValueError异常.
- S.isalnum() #检查字符串是否由字母或数字字符组成
- S.isalpha() #检查字符串是否由字母字符组成
- S.isdigit() #检查字符串是否由数字字符组成
- S.islower() #检查字符串是否由小写字母组成
- S.isspace() #检查字符串是否由空格组成
- S.istitle() #检查字符串时候首字母大写
- S.isupper() #检查字符串是否由大写字母组成
- S.join(sequence) #返回其中sequence的字符串元素由S连接的字符串
- S.ljust(width[,fillchar]) #返回S副本左对齐的字符串,长度max(len(S),W),右侧fillchar填充
- S.lower() #返回所有字符串都为小写的副本
- S.lstrip([char]) #向左移除所有char,默认移除(空格,tab,\n)
- S.partition(seq) #在字符串中搜索seq并返回
- S.replace(old,new[,max]) #将new替换olad,最多可替换max次
- S.rfind(sub[,start[,end]]) #返回sub所在的最后一个索引,不存在则为-1,可定搜索范围S[start:end]
- S.rindex(sub[,start[,end]]) #返回sub所在的最后一个索引,不存在则会引发ValueError异常。
- S.rjust(width[,fillchar]) #返回S副本右对齐的字符串,长度max(len(S),W),左侧fillchar填充
- S.rpartition(seq) #同Partition,但从右侧开始查找
- S.rstip([char]) #向右移除所有char,默认移除(空格,tab,\n)
- S.rsplit(sep[,maxsplit]) #同split,但是使用maxsplit时是从右往左进行计数
- S.split(sep[,maxsplit]) #使用sep做为分割符,可使用maxsplit指定最大切分数
- S.zfill(width) #在S的左侧以0填充width个字符
- S.upper() #返回S的副本,所有字符大写
- S.splitlines([keepends]) #返回S中所有行的列表,可选择是否包括换行符
- S.startswith(prefix[,start[,end]]) #检查S是否以prefix开始,可用[start,end]来定义范围
- S.strip([chars]) #移除所有字符串中含chars的字符,默认移除(空格,tab,\n)
- S.swapcase() #返回S的副本,所有大小写交换
- S.title() #返回S的副本,所有单词以大写字母开头
- S.translate(table[,deletechars]) #返回S的副本,所有字符都使用table进行的转换,可选择删除出现在deletechars中的所有字符
【题目:038】| 现在有一个dict对象adict,里面包含了一百万个元素,查找其中的某个元素的平均需要多少次比较
- O(1) 哈希字典,快速查找,键值映射,键唯一!
【题目:039】| 有一个list对象alist,里面的所有元素都是字符串,编写一个函数对它实现一个大小写无关的排序
- words = ['This','is','a','dog','!']
- words.sort(key=lambda x:x.lower())
- print words
- #输出结果
- >>>
- ['!', 'a', 'dog', 'is', 'This']
【题目:040】| 有一个排好序地list对象alist,查找其中是否有某元素a
- alist = ['a','s','d','f']
- try:
- alist.index('a')
- print 'Find it.'
- except ValueError:
- print 'Not Found.'
【题目:041】| 请用Python写一个获取用户输入数字,并根据数字大小输出不同信息的脚本
- num = input('Enter number: ')
- if num > 100:
- print 'The number is over 100'
- elif 0 < num <= 100:
- print 'The number is between 0~100'
- elif num < 0:
- print 'The number is negative.'
- else:
- print 'Not a number'
【题目:042】| 打乱一个排好序的list对象alist
- # random模块中的shuffle(洗牌函数)
- import random
- alist = [1, 2, 3, 4]
- random.shuffle(alist)
- print alist
【题目:043】| 有二维的list对象alist,假定其中的所有元素都具有相同的长度,写一段程序根据元素的第二个元素排序
- def sort_lists(lists, sord, idx):
- if sord == 'desc':
- lists.sort(key=lambda x:x[idx], reverse=True)
- else:
- lists.sort(key=lambda x:x[idx])
- return lists
- lists = [['cd','ab'],['ef','ac']]
- sort_lists(lists,'desc',1)
- print lists
- # 输出结果
- >>>
- [['ef', 'ac'], ['cd', 'ab']]
【题目:044】| inspect模块有什么用
- inspect模块提供了一系列函数用于帮助使用自省。
- 检查对象类型
- is{module|class|function|method|builtin}(obj): 检查对象是否为模块、类、函数、方法、内建函数或方法。
- isroutine(obj): 用于检查对象是否为函数、方法、内建函数或方法等等可调用类型。
- 获取对象信息
- getmembers(object[, predicate]): 这个方法是dir()的扩展版,它会将dir()找到的名字对应的属性一并返回。
- getmodule(object): 它返回object的定义所在的模块对象。
- get{file|sourcefile}(object): 获取object的定义所在的模块的文件名|源代码文件名(如果没有则返回None)。
- get{source|sourcelines}(object): 获取object的定义的源代码,以字符串|字符串列表返回。
- getargspec(func): 仅用于方法,获取方法声明的参数,返回元组,分别是(普通参数名的列表, *参数名, **参数名, 默认值元组)。
【题目:045】| Python处理命令行参数示例代码
- # 最简单、最原始的方法就是手动解析了
- import sys
- for arg in sys.argv[1:]:
- print(arg)
【题目:046】| 介绍一下Python getopt模块
- # getopt模块是原来的命令行选项解析器,支持UNIX函数getopt()建立的约定。
- # 它会解析一个参数序列,如sys.argv,并返回一个元祖序列和一个非选项参数序列。
- # 目前支持的选项语法包括短格式和长格式选项:-a, -bval, -b val, --noarg, --witharg=val, --witharg val。
- # 如果只是简单的命令行解析,getopt还是不错的选择。一个例子如下
- import sys
- import getopt
- try:
- options, remainder = getopt.getopt(sys.argv[1:], 'o:v', ['output=', 'verbose', 'version=',])
- except getopt.GetoptError as err:
- print 'ERROR:', err
- sys.exit(1)
- 总结下getopt的特点:1. getopt是从前到后解析 2. getopt不检查额外参数的合法性,需要自行检查 3. 短命令行和长命令行是分开解析的</span>
【题目:047】| Python列表与元组的区别是什么?分别在什么情况下使用?
- Python中列表和元祖都是序列,因此都能进行添加,删除,更新,切片等操作。但列表是可变对象,元祖是不可变对象。
- 元祖主要用于函数赋值,字符串格式化等。但列表中的方法更多些,也是PYTHON中更常用的数据结构。
【题目:048】| 有一个长度是101的数组,存在1~100的数字,有一个是重复的,拿重复的找出来
- # Python中,主要是拿count(i) ==2的找出来即可,再利用列表推导式
- >>> l = [1, 2, 3, 4, 2]
- >>> tmp = []
- >>> [tmp.append(i) for i in l if l.count(i) == 2]
- [None, None]
- >>> tmp
- [2, 2]
- >>> set(tmp)
- set([2])
【题目:049】| set是在哪个版本成为build-in types的?举例说明,并说明为什么当时选择了set这种数据结构
- python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.
- sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合,sets不记录元素位置或者插入点。因此,sets不支持 indexing, slicing, 或其它类序列(sequence-like)的操作。
- 下面来点简单的小例子说明。
- >>> x = set('spam')
- >>> y = set(['h','a','m'])
- >>> x, y
- (set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))
- 再来些小应用。
- >>> x & y # 交集
- set(['a', 'm'])
- >>> x | y # 并集
- set(['a', 'p', 's', 'h', 'm'])
- >>> x - y # 差集
- set(['p', 's'])
- 去除海量列表里重复元素,用hash来解决也行,只不过感觉在性能上不是很高,用set解决还是很不错的,示例如下:
- >>> a = [11,22,33,44,11,22]
- >>> b = set(a)
- >>> b
- set([33, 11, 44, 22])
- >>> c = [i for i in b]
- >>> c
- [33, 11, 44, 22]
- 很酷把,几行就可以搞定。
- 1.8 集合
- 集合用于包含一组无序的对象。要创建集合,可使用set()函数并像下面这样提供一系列的项:
- s = set([3,5,9,10]) #创建一个数值集合
- t = set("Hello") #创建一个唯一字符的集合
- 与列表和元组不同,集合是无序的,也无法通过数字进行索引。此外,集合中的元素不能重复。例如,如果检查前面代码中t集合的值,结果会是:
- >>> t
- set(['H', 'e', 'l', 'o'])
- 注意只出现了一个'l'。
- 集合支持一系列标准操作,包括并集、交集、差集和对称差集,例如:
- a = t | s # t 和 s的并集
- b = t & s # t 和 s的交集
- c = t – s # 求差集(项在t中,但不在s中)
- d = t ^ s # 对称差集(项在t或s中,但不会同时出现在二者中)
- 基本操作:
- t.add('x') # 添加一项
- s.update([10,37,42]) # 在s中添加多项
- 使用remove()可以删除一项:
- t.remove('H')
- len(s)
- set 的长度
- x in s
- 测试 x 是否是 s 的成员
- x not in s
- 测试 x 是否不是 s 的成员
- s.issubset(t)
- s <= t
- 测试是否 s 中的每一个元素都在 t 中
- s.issuperset(t)
- s >= t
- 测试是否 t 中的每一个元素都在 s 中
- s.union(t)
- s | t
- 返回一个新的 set 包含 s 和 t 中的每一个元素
- s.intersection(t)
- s & t
- 返回一个新的 set 包含 s 和 t 中的公共元素
- s.difference(t)
- s - t
- 返回一个新的 set 包含 s 中有但是 t 中没有的元素
- s.symmetric_difference(t)
- s ^ t
- 返回一个新的 set 包含 s 和 t 中不重复的元素
- s.copy()
- 返回 set “s”的一个浅复制
- 请注意:union(), intersection(), difference() 和 symmetric_difference() 的非运算符(non-operator,就是形如 s.union()这样的)版本将会接受任何 iterable 作为参数。相反,它们的运算符版本(operator based counterparts)要求参数必须是 sets。这样可以避免潜在的错误,如:为了更可读而使用 set('abc') & 'cbs' 来替代 set('abc').intersection('cbs')。从 2.3.1 版本中做的更改:以前所有参数都必须是 sets。
- 另外,Set 和 ImmutableSet 两者都支持 set 与 set 之间的比较。两个 sets 在也只有在这种情况下是相等的:每一个 set 中的元素都是另一个中的元素(二者互为subset)。一个 set 比另一个 set 小,只有在第一个 set 是第二个 set 的 subset 时(是一个 subset,但是并不相等)。一个 set 比另一个 set 打,只有在第一个 set 是第二个 set 的 superset 时(是一个 superset,但是并不相等)。
- 子 set 和相等比较并不产生完整的排序功能。例如:任意两个 sets 都不相等也不互为子 set,因此以下的运算都会返回 False:a<b, a==b, 或者a>b。因此,sets 不提供 __cmp__ 方法。
- 因为 sets 只定义了部分排序功能(subset 关系),list.sort() 方法的输出对于 sets 的列表没有定义。
- 运算符
- 运算结果
- hash(s)
- 返回 s 的 hash 值
- 下面这个表列出了对于 Set 可用二对于 ImmutableSet 不可用的运算:
- 运算符(voperator)
- 等价于
- 运算结果
- s.update(t)
- s |= t
- 返回增加了 set “t”中元素后的 set “s”
- s.intersection_update(t)
- s &= t
- 返回只保留含有 set “t”中元素的 set “s”
- s.difference_update(t)
- s -= t
- 返回删除了 set “t”中含有的元素后的 set “s”
- s.symmetric_difference_update(t)
- s ^= t
- 返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”
- s.add(x)
- 向 set “s”中增加元素 x
- s.remove(x)
- 从 set “s”中删除元素 x, 如果不存在则引发 KeyError
- s.discard(x)
- 如果在 set “s”中存在元素 x, 则删除
- s.pop()
- 删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError
- s.clear()
- 删除 set “s”中的所有元素
- 请注意:非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改:以前所有参数都必须是 sets。
- 还请注意:这个模块还包含一个 union_update() 方法,它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法,因为这个方法也被内置的 set() 和 frozenset() 类型支持。
【题目:050】| 说说decorator的用法和它的应用场景,如果可以的话,写一个decorator
- 所谓装饰器就是把函数包装一下,为函数添加一些附加功能,装饰器就是一个函数,参数为被包装的函数,返回包装后的函数:
- def d(fp):
- def _d(*arg, **karg):
- print "do sth before fp.."
- r= fp(*arg, **karg)
- print "do sth after fp.."
- return r
- return _d
- @d
- def f():
- print "call f"
- #上面使用@d来表示装饰器和下面是一个意思
- #f = d(f)
- f()#调用f
【题目:051】| 写一个类,并让它尽可能多的支持操作符
- class Array:
- __list = []
- def __init__(self):
- print "constructor"
- def __del__(self):
- print "destructor"
- def __str__(self):
- return "this self-defined array class"
- def __getitem__(self, key):
- return self.__list[key]
- def __len__(self):
- return len(self.__list)
- def Add(self, value):
- self.__list.append(value)
- def Remove(self, index):
- del self.__list[index]
- def DisplayItems(self):
- print "show all items----"
- for item in self.__list:
- print item
- arr = Array() #constructor
- print arr #this self-defined array class
- print len(arr) #0
- arr.Add(1)
- arr.Add(2)
- arr.Add(3)
- print len(arr) #3
- print arr[0] #1
- arr.DisplayItems()
- #show all items----
- #1
- #2
- #3
- arr.Remove(1)
- arr.DisplayItems()
- #show all items----
- #1
- #3
- #destructor
【题目:052】| 说一说你见过比较cool的python实现
- cool的概念,角度不同,看法可能也就不同,个人觉得更Pythonic的代码就是最酷的代码。
【题目:053】| Python如何实现单例模式
- #-*- encoding=utf-8 -*-
- print '----------------------方法1--------------------------'
- #方法1,实现__new__方法
- #并在将一个类的实例绑定到类变量_instance上,
- #如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
- #如果cls._instance不为None,直接返回cls._instance
- class Singleton(object):
- def __new__(cls, *args, **kw):
- if not hasattr(cls, '_instance'):
- orig = super(Singleton, cls)
- cls._instance = orig.__new__(cls, *args, **kw)
- return cls._instance
- class MyClass(Singleton):
- a = 1
- one = MyClass()
- two = MyClass()
- two.a = 3
- print one.a
- #3
- #one和two完全相同,可以用id(), ==, is检测
- print id(one)
- #29097904
- print id(two)
- #29097904
- print one == two
- #True
- print one is two
- #True
- print '----------------------方法2--------------------------'
- #方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)
- #同一个类的所有实例天然拥有相同的行为(方法),
- #只需要保证同一个类的所有实例具有相同的状态(属性)即可
- #所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)
- #可参看:http://code.activestate.com/recipes/66531/
- class Borg(object):
- _state = {}
- def __new__(cls, *args, **kw):
- ob = super(Borg, cls).__new__(cls, *args, **kw)
- ob.__dict__ = cls._state
- return ob
- class MyClass2(Borg):
- a = 1
- one = MyClass2()
- two = MyClass2()
- #one和two是两个不同的对象,id, ==, is对比结果可看出
- two.a = 3
- print one.a
- #3
- print id(one)
- #28873680
- print id(two)
- #28873712
- print one == two
- #False
- print one is two
- #False
- #但是one和two具有相同的(同一个__dict__属性),见:
- print id(one.__dict__)
- #30104000
- print id(two.__dict__)
- #30104000
- print '----------------------方法3--------------------------'
- #方法3:本质上是方法1的升级(或者说高级)版
- #使用__metaclass__(元类)的高级python用法
- class Singleton2(type):
- def __init__(cls, name, bases, dict):
- super(Singleton2, cls).__init__(name, bases, dict)
- cls._instance = None
- def __call__(cls, *args, **kw):
- if cls._instance is None:
- cls._instance = super(Singleton2, cls).__call__(*args, **kw)
- return cls._instance
- class MyClass3(object):
- __metaclass__ = Singleton2
- one = MyClass3()
- two = MyClass3()
- two.a = 3
- print one.a
- #3
- print id(one)
- #31495472
- print id(two)
- #31495472
- print one == two
- #True
- print one is two
- #True
- print '----------------------方法4--------------------------'
- #方法4:也是方法1的升级(高级)版本,
- #使用装饰器(decorator),
- #这是一种更pythonic,更elegant的方法,
- #单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的
- def singleton(cls, *args, **kw):
- instances = {}
- def _singleton():
- if cls not in instances:
- instances[cls] = cls(*args, **kw)
- return instances[cls]
- return _singleton
- @singleton
- class MyClass4(object):
- a = 1
- def __init__(self, x=0):
- self.x = x
- one = MyClass4()
- two = MyClass4()
- two.a = 3
- print one.a
- #3
- print id(one)
- #29660784
- print id(two)
- #29660784
- print one == two
- #True
- print one is two
- #True
- one.x = 1
- print one.x
- #1
- print two.x
- #1
【题目:054】| 如何用Python来发送邮件
- # 可以使用smtplib标准库。
- # 以下代码可以在支持SMTP监听器的服务器上执行。
- import sys, smtplib
- fromaddr = raw_input("From: ")
- toaddrs = raw_input("To: ").split(',')
- print("Enter message, end with ^D:")
- msg = ''
- while 1:
- line = sys.stdin.readline()
- if not line:
- break
- msg += line
- # 发送邮件部分
- server = smtplib.SMTP('localhost')
- server.sendmail(fromaddr, toaddrs, msg)
- server.quit()
【题目:055】| Python自动连接ssh的代码
- #!/usr/bin/env python
- #import the need library.
- import pxssh
- #machine details
- hostname = ''
- username = ''
- password = ''
- #command we want to send
- command = 'ls -lart'
- #function to connect
- def connect(hostname, username, password, release):
- try:
- s = pxssh.pxssh()
- s.login(hostname, username, password, release)
- print s
- return s
- except Exception, e:
- print "[-] Error Connecting: " + str(e)
- #func to send a command
- def send_command(ssh_session, command):
- ssh_session.sendline(command)
- ssh_session.prompt()
- print ssh_session.before
- #main()
- if __name__ == "__main__":
- session = connect(hostname, username, password)
- send_command(session, command)
或者用pexpect模块
- #!/usr/bin/env python
- import pexpect
- def ssh_cmd(ip, passwd, cmd):
- ret = -1
- ssh = pexpect.spawn('ssh root@%s "%s"' % (ip, cmd))
- try:
- i = ssh.expect(['password:', 'continue connecting (yes/no)?'], timeout=5)
- if i == 0 :
- ssh.sendline(passwd)
- elif i == 1:
- ssh.sendline('yes\n')
- ssh.expect('password: ')
- ssh.sendline(passwd)
- ssh.sendline(cmd)
- res = ssh.read()
- print res
- ret = 0
- except pexpect.EOF:
- print "EOF"
- ssh.close()
- ret = -1
- except pexpect.TIMEOUT:
- print "TIMEOUT"
- ssh.close()
- ret = -2
- return ret
- #main()
- if __name__ == "__main__":
- ssh_cmd('127.0.0.1', 'password', 'ls -lart')
【题目:056】| 介绍一下Python Date Time方面的类
- 一.time模块
- time模块提供各种操作时间的函数
- 一般有两种表示时间的方式:
- 第一种: 是时间戳的方式(相对于1970.1.1 00:00:00以秒计算的偏移量),时间戳是惟一的
- 第二种: 以数组的形式表示即(struct_time),共有九个元素,分别表示,同一个时间戳的struct_time会因为时区不同而不同
- 二.datetime模块
- Python提供了多个内置模块用于操作日期时间,像calendar,time,datetime。time模块。
- 相比于time模块,datetime模块的接口则更直观、更容易调用。
- datetime模块定义了下面这几个类:
- datetime.date:表示日期的类。常用的属性有year, month, day;
- datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond;
- datetime.datetime:表示日期时间。
- datetime.timedelta:表示时间间隔,即两个时间点之间的长度。
- datetime.tzinfo:与时区有关的相关信息。
- datetime中,表示日期时间的是一个datetime对象
- datetime中提供了strftime方法,可以将一个datetime型日期转换成字符串:
【题目:057】| 写一个简单的Python socket编程
服务器端程序:
- # FileName: server.py
- import socket
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- sock.bind(('localhost', 8001))
- sock.listen(5)
- while True:
- conn, addr = sock.accept()
- try:
- conn.settimeout(5)
- buff = conn.recv(1024)
- if buff == '1':
- conn.send('Hello, Client...')
- else:
- conn.send('Please, Go Out...')
- except socket.timeout:
- print 'Socket Time Out...'
- finally:
- conn.close()
客户端程序:
- # FileName: client.py
- import socket
- import time
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- sock.connect(('localhost', 8001))
- time.sleep(2)
- sock.send('1')
- print sock.recv(1024)
- sock.close()
在终端运行server.py,然后运行clien.py,会在终端打印“Hello, Client..."。
如果更改client.py的sock.send('1')为其它值在终端会打印“Please, Go Out...”。
更改time.sleep(2)为大于5的数值, 服务器将会超时。
【题目:058】| Tkinter的ToolTip控件
- Tooltip控件是一个简单,但非常有用的控件。它能够为我们的软件提供非常漂亮的提示信息,提高软件的可用性,给用户比较好的体验。
- 假设现在有两个按钮,一个用来预览吊线世系图,一个用来预览行转。为了保持按钮文本的简洁,以及为按钮尺寸所限。
- 我们不能可能把这个按钮的主要功能通过text属性表述清楚,这个时候我们就可以用到tooltip控件了.
【题目:059】| 解释一下python的and-or语法
- 0 and * 不需要再考虑*是0还是1,结果是0
- 1 and * 需要考虑*是0还是1来决定结果。
- 1 or * 不需要考虑后面的*,结果为1
- 0 or * 需要考虑后面的*来决定结果
- 这个语法看起来类似于 C 语言中的 bool ? a : b 表达式。整个表达式从左到右进行演算,所以先进行 and 表达式的演算。 1 and 'first' 演算值为 'first',然后 'first' or 'second' 的演算值为 'first'。
- 0 and 'first' 演算值为 False,然后 0 or 'second' 演算值为 'second'。
- and-or主要是用来模仿 三目运算符 bool?a:b的,即当表达式bool为真,则取a否则取b。
- and-or 技巧,bool and a or b 表达式,当 a 在布尔上下文中的值为假时,不会像 C 语言表达式 bool ? a : b 那样工作。
【题目:060】| Python里关于“堆”这种数据结构的模块是哪个?“堆”有什么优点和缺点
这个真没有!
【题目:061】| 实现一个stack
- class Stack :
- def __init__( self ):
- ''''' Creates an empty stack. '''
- self._items = list()
- def isEmpty(self):
- ''''' Returns True if the stack is empty or False otherwise. '''
- return len(self) == 0
- def __len__(self):
- ''''' Returns the number of items in the stack. '''
- return len(self._items)
- def peek(self):
- ''''' Returns the top item on the stack without removing it. '''
- assert not self.isEmpty(), "Cannot peek at an empty stack"
- return self._items[-1]
- def pop(self):
- ''''' Removes and returns the top item on the stack. '''
- assert not self.isEmpty(), "Cannot pop from an empty stack"
- return self._items.pop()
- def push(self,item):
- ''''' Push an item onto the top of the stack. '''
- self._items.append( item )
【题目:062】| 编写一个简单的ini文件解释器
db_config.ini
[baseconf]
host=127.0.0.1
port=3306
user=root
password=root
db_name=evaluting_sys
[concurrent]
processor=20
示例代码
import sys,os
import ConfigParser
def test(config_file_path):
cf = ConfigParser.ConfigParser()
cf.read(config_file_path) s = cf.sections()
print 'section:', s o = cf.options("baseconf")
print 'options:', o v = cf.items("baseconf")
print 'db:', v db_host = cf.get("baseconf", "host")
db_port = cf.getint("baseconf", "port")
db_user = cf.get("baseconf", "user")
db_pwd = cf.get("baseconf", "password") print db_host, db_port, db_user, db_pwd cf.set("baseconf", "db_pass", "123456")
cf.write(open("config_file_path", "w"))
if __name__ == "__main__":
test("../conf/db_config.ini")
【题目:063】| 现有N个纯文本格式的英文文件,实现一种检索方案,即做一个小搜索引擎
【题目:064】| src = "security/afafsff/?ip=123.4.56.78&id=45",请写一段代码用正则匹配出IP
- import re
- src = "security/afafsff/?ip=123.4.56.78&id=45"
- m = re.search('ip=(\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3})', src, re.S) # re.S 改变'.'的行为
- print m.group(1)
- # 输出结果
- >>>
- 123.4.56.78
【题目:064】| 已知仓库中有若干商品,以及相应库存,类似:
袜子,10
鞋子,20
拖鞋,30
项链,40
要求随机返回一种商品,要求商品被返回的概率与其库存成正比。请描述实现的思路或者直接写一个实现的函数
- # -*- coding: utf-8 -*-
- import random
- Wa_Zhi = ['WZ'] * 100
- Xie_Zi = ['XZ'] * 200
- Tuo_Xie = ['TX'] * 300
- Xiang_Lian = ['XL'] * 400
- All_Before = Wa_Zhi + Xie_Zi + Tuo_Xie + Xiang_Lian
- All_After = random.sample(All_Before, 100)
- print All_After.count('WZ')
- print All_After.count('XZ')
- print All_After.count('TX')
- print All_After.count('XL')
- #输出结果,大致满足需求1: 2: 3: 4的比例
- >>>
- 9
- 19
- 32
- 40
Python面试题汇总的更多相关文章
- Python面试题之Python面试题汇总
在这篇文章中: Python基础篇 1:为什么学习Python 2:通过什么途径学习Python 3:谈谈对Python和其他语言的区别 Python的优势: 4:简述解释型和编译型编程语言 5:Py ...
- python 面试题汇总
1丶元组(list)和列表(tuple)的区别: 一:共同点: ①: 可以放置任意数据类型的有序集合,都是可以存放数字,字符串,对象等. ②:都支持 负索引,切片,随意嵌套等操作 二:不同点: ①: ...
- python面试笔试题汇总
Python面试攻略(嗨谈篇) 110道python面试笔试题汇总,你能答对几道? Python 面试问答 Top 25 2018 年最常见的 Python 面试题 & 答案
- 110道python面试笔试题汇总,你能答对几道?
数据分析系列教程插播一篇面试题教程,最近公众号新来了不少朋友,这几天不少粉丝留言说问我有没有python面试题,其实之前分享过一些面试题,今天统一再给大家分享一遍,也希望能帮助此时仍在找工作的同学,尽 ...
- Python面试题及答案汇总整理(2019版)
发现网上很多Python面试题都没有答案,所以博主花了很长时间搜集整理了这套Python面试题及答案,由于网上的Python相关面试题大多数都是2019年的,所以我这个也是2019版的,哈哈~ (文末 ...
- iOS常见面试题汇总
iOS常见面试题汇总 1. 什么是 ARC? (ARC 是为了解决什么问题而诞生的?) ARC 是 Automatic Reference Counting 的缩写, 即自动引用计数. 这是苹果在 i ...
- Redis 面试题汇总
Redis 面试题汇总 1.Redis 使用场景有哪些? 答:Redis 使用场景如下: 记录帖子点赞数.点击数.评论数 缓存近期热帖 缓存文章详情信息 记录用户会话信息 2.Redis 有哪些功能? ...
- 一份超全的Python学习资料汇总
一.学习Python必备技能图谱二.0基础如何系统学习Python?一.Python的普及入门1.1 Python入门学习须知和书本配套学习建议1.2 Python简史1.3 Python的市场需求及 ...
- AJAX笔试面试题汇总
AJAX笔试面试题汇总 Javascript 1. 什么是ajax,为什么要使用Ajax(请谈一下你对Ajax的认识) 什么是ajax: AJAX是“Asynchronous JavaScript a ...
随机推荐
- Numpy矩阵取列向量
>>> A=matrix("1 2;3 4") >>> A matrix([[1, 2], [3, 4]]) >>> A[:, ...
- HW7.12
import java.util.Scanner; public class Solution { public static void main(String[] args) { double[] ...
- poj 2196 Specialized Four-Digit Numbers
如果一个数字 十进制的各位数的和 == 十六进制的各位数的和 == 十二进制的各位数的和,则输出,从2992到9999 #include <cstdio> int toDD(int n) ...
- 《Java数据结构与算法》笔记-CH5-链表-4用链表实现堆栈
//用链表实现堆栈 /** * 节点类 */ class LinkS { private long data; public LinkS next; public LinkS(long d) { th ...
- 怎么监视跟踪一个进程(Process)中的MS Unit Test DLL的详细性能(performance)【asp.net C#】
Sample This tutorial will show how to instrument a unit test DLL for performance profiling. Visual S ...
- c++builder XE8 线程 Thread
thread Thread c++builder XE8 / RAD 10 Settle delphi TThread.CreateAnonymousThread(MyMethod).Start; ...
- 删除Ngnix 日志
删除Ngnix日志的脚本 #!/bin/bash #初始化 LOGS_PATH=$(pwd)/logs YESTERDAY=$(date -d "yesterday" +%Y-%m ...
- oracle max()函数和min()函数
当需要了解一列中的最大值时,可以使用MAX()函数:同样,当需要了解一列中的最小值时,可以使用MIN()函数.语法如下. SELECT MAX (column_name) / MIN ...
- apiCode/1/1.1/1.1.1
public abstract class myClass { private string id = ""; private string name = "" ...
- non-manifold Mesh(非流形网格)
三角网格曲面中,大多的算法基于流形网格manifold mesh,其定义如下: 1)Each edge is incident to only one or two faces: 一条网格边为一个或两 ...