×

case

96
ygg
2015.10.17 22:35* 字数 25

001

#交换两个变量值    
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中的元素计算出
总共需要申请的内存空间的大小,一次申请完。

002

>>> 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中一般取消前者函数 

003

这是代码结构设计的问题,模块依赖和类依赖  
如果老是觉得碰到循环引用,很可能是模块的分界线划错地方了。可能是把应该在一起的东西硬拆开了,可能是某些职责放错地方了,可能是应该抽象的东西没抽象  
总之微观代码规范可能并不能帮到太多,重要的是更宏观的划分模块的经验技巧,推荐uml,脑图,白板等等图形化的工具先梳理清楚整个系统的总体结构和职责分工  
  
采取办法,从设计模式上来规避这个问题,比如:  
1. 使用 “__all__” 白名单开放接口  
2. 尽量避免 import  

004

#python 类型转换
函数                             描述  
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)                      将一个整数转换为一个八进制字符串 

#list和tuple如何转换
#两者可以直接相互转换
t = (1,2,3)
tt = list(t)
tt = tuple(tt)

005编码问题

#先来看个小例子:
print(u'中文')
print('中文')

2
6


006

#Python判断当前用户是否是root
import os  
if os.getuid() != 0:    # root账号的uid=0  
    print os.getuid()  
    print 'Should run as root account'  
else:  
    print 'Hello, Root!'  

#

007默写尽可能多的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中的所有字符 

008

# 现在有一个dict对象adict,里面包含了一百万个元素,查找其中的某个元素的平均需要多少次比较
O(1)  哈希字典,快速查找,键值映射,键唯一! 

#有一个list对象alist,里面的所有元素都是字符串,编写一个函数对它实现一个大小写无关的排序
words = ['This','is','a','dog','!']  
words.sort(key=lambda x:x.lower())  
print words  

#打乱一个排好序的list对象alist
# random模块中的shuffle(洗牌函数)  
import random  
alist = [1, 2, 3, 4]  
random.shuffle(alist)     
print alist  

# 有一个长度是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])  
interview
Web note ad 1