1. 循环遍历
if __name__ == '__main__': while True:
2. 录入数据
str1=raw_input() # 通过split()将数据分割，并用map(int,list)将其存储 n,k=map(int,str1.split()) str2=raw_input() # 分割后利用map将全部数据进行转换 listA=map(int,str2.split())
3. list的去重
# 因为set是去重的东西，所以转化成set再转化成list即可
newA = list(set(a))
# 但是二维列表的去重就不一样了，他需要先转化成tuple然后在进行set
reList = list(set([tuple(t) for t in reList]))
reList = [list(v) for v in reList]
4. list的排序
# 注意，虽然a.sort()也能进行排序，但是只是针对a排序，要是想存储到另一个list中，还是要使用sorted的 newA=sorted(a) # 想要反顺序，那就加一个reverse newA=sorted(a,reverse=True)
5. 统计数据
# count用来判断这个list里面有多少个该数据 result+=listA.count(0)
6. 二维链表的使用
listA=[] # 有时候我们需要二维链表，即一行保存两组数据 # 利用append来添加数据 listA.append([1,1]) # 利用pop来删除并获取删除节点数据 s,m=listA.pop(0)
7. 判断链表中是否有元素
# 利用len配合pop来做循环 while len(listA): # 默认是删除并提取最后一个元素 k=listA.pop(0) # 也可以利用len来遍历结果 for i in range(len(listA)): print listA[i]
8. 字符串的拼接
s=1 m=2 # 利用str转化成String listA=[str(s), ',', str(m)] # 利用join(list)将所有数据整合到一起变成字符串 strA="".join(listA)
9. 判断字典是否存在key值数据
# 注意只能得到True和False，不要使用! if dictionaryA.has_key(strA)==False: print "没有这个数据，可以将其加入进去" # 加入方法直接赋值即可 dictionaryA[strA]="value"
10. 字符串边List
# 其实并不难，直接list套上去就行 listStr=list(strA)
11. 将字符串转化成算术式子
# 写个函数也不是不可以，但是有就直接用嘛（直接计算完毕的哟） resultA=eval(strA)
12. 三元运算符
# c中的是 式子？A：B # python中有些不一样 正结果 if 式子 else 负结果 print "\n" if k==len(listA)-1 else ".."
13. python不换行
# 使用逗号可以有效解决python2中的换行，使用end=''可以解决python3的换行 # 但是还是建议import，在python2也能用 from __future__ import print_function a='abcd' print ("%s" %a, end='')
14. List求和求均值
# 求和很简单 sumA=sum(listA) # 均值利用sum和len即可 meanA=sum(listA)/len(listA)
15. 生成组合结果
import itertools a=['a','b','a'] b=3 # 使用itertools中的product方法 *[a]*b相当于列表a复制b次 listA=[''.join(x) for x in itertools.product(*[a]*b)] # 转化成set生成不重复的结果 setA=set(listA) listNewA=list(setA) # 使用 product("abc",repeat=3)这样也可以
# 使用permutions能够很快的得到所有的排列组合 strA=map(str,nums) # 返回所有的可能值，使用set+随机排列即可 listA=[map(int,list(x)) for x in itertools.permutations(strA,len(strA))] return listA # 其应用实质就是不断的插入，选择一个点插入，在遍历下一个点找位置插入即可
16. 将所有的list中数值数据进行加减操作
from numpy import * listA=[1,2,3,4] # 将a转化成array来进行处理 arrayA=array(listA) arrayNewA=arrayA+4 # 再将array转化成list listNewA=list(arrayNewA)
17. list中的奇数项和偶数项
#奇数的语句 print x[::2] #偶数的语句 print x[1::2]
这里涉及到【a:b:c】格式 a和b表示范围，缺省的话分别表示，头结点和尾结点位置，最后表示步长，缺省为1，所以就有了奇数项和偶数项的定义。
当把步长设定为负数的时候，a的缺省值为-1，b的缺省值为-len(listA)-1，换句话讲，就是从倒数第1个接到到倒数第len(listA)个，因为正常来讲[0:1]表示0一个值，所以[-1:-len(listA)-1]表示了倒着看的全部值。综上所述，使用[::-1]即可完成列表倒序，相当于使用[-1:-len(listA):-1]，恩恩，这样就可完全理解了
18. 快速拼接（嵌套的list转换成一维list）
a=[[1,2],[3,4]] # 利用sum来就去掉[] sum(a,[]) # 或者使用itertools来处理 import itertools # 使用itertools.chain.from_iterable来进行并转换成list out = list(itertools.chain.from_iterable(a))
19. 利用type来判断一个结构
# 利用type来判断--主要掌握list、dict即可 listA=[1,2,3,4] if type(listA)==list: print "我是list" # 当然遇到不知道的打印一下就好了 print type(listA)
20. 合并两个list
from numpy import * # 水平进行叠加 a=[1,2,3] b=[4,5,6] hstack((a,b)) # array([1,2,3,4,5,6]) # 竖直进行叠加 vstack((a,b)) # array([[1,2,3],[4,5,6]])
21. 取整方法
import math # 四舍五入 使用0.5 或者 直接使用round() numA=2.5 print int(numA+0.5) print round(numA) # 向下取整 直接使用int 或者 使用math的地板数 print int(numA) print math.floor(numA) # 向上取整 使用math的ceil函数 print math.ceil(numA) # 分割整数和小数 个人感觉没什么用处 毕竟因为存储小数问题上 近似值存在偏差 print math.modf(numA)
22. 列表替换
''' 列表的直接替换 对于[[1,2,3]]*3这个赋值列表 因为python中的对象都是引用形式存在 导致，修改某一项，其余项全部会跟着修改 简单来说，就是一条狗绑了三根绳子，你砍了狗一刀，三根绳子的狗都被砍了 我们可以通过id()来判断，你搞得狗(对象)是不是同一条(个) ''' # 想要创建多维列表，首先考虑一维列表的复制 a=[1,2,3] # 使用list转换可以防止对象引用 b=list(a) # 或者使用a[:]重新创建列表,当然前者更优 b=a[:] #一维列表搞定之后，二维只需要遍历赋值即可 b=[list(a) for i in range(3)] b=[a[:] for i in range(3)]
23. 有理数比较(python的保存机制不一样，c的话就不需要四舍五入)
#使用保留数字进行比较 a=1 b=3 c=round(float(a)/b,10) # 使用c*b和a进行比较 print c*b==a
24. 多维列表的排序问题(转化成字典排序即可)
# 针对某一个字段排序，我们使用字典就好了，这样子排序后的结果依旧保留着哟 # 命名方式，我觉得这样很舒服，啧啧 dictList1={} dictList1[1.5]=[1,2,3] dictList1[0.5]=[4,5,6] # sorted(dictList1)打印出来的结果是keys的排序结果 dictList1[sorted(dictList1)[目标位置下标]] import operator a={'a':2,'c':1,'b':3} b=sorted(a.iteritems(),key=operator.itemgetter(1),reverse=False) # 利用key形参也可以做到二维列表的排序，不需要考虑数组 c=[['b',4],['e',2],['a',5],['d',1],['c',3]] # 使用lambda来进行，啧啧，但是sort会影响原结构，一般使用sorted # 按照列表的第二个元素排序——使用x:x[1] c.sort(key=lambda x:x[1]) d=sorted(k,key=lambda x:x[1])
25. numpy中的lexsort排序
# lexsort排序后的结果是下标，所以打印或者复制需要简单处理一下哈 此外numpy处理数据并不会出现重复问题的哟 import numpy as np data = np.array([[1,2,3,4,5], [1,2,3,6,7], [2,3,4,5,7], [3,4,5,6,7], [4,5,6,7,8]] k=np.lexsort([data[:,3]]) print data[k,:]
26. 统计Counter(字典的子类) Counter简介
# 直接统计字符串，也可以直接统计列表情况 listA=[1,2,3,1,2] listB="1234123" counterA=Counter(listA) counterB=Counter(listB) # 因为是字典，直接调用即可的哟 print counterA[1] # Counter之间的加减法 update和subtract 直接针对Counter/针对某一个对象 counterA.update(counterB) counterA.updata('123111') # Counter删除某键 del counterA[某个键] # 类似字典keys获取全部键 print counterA.keys() # elements获取全部值，但是因为生成的是itertools，所以转换list显示 print list(counterA.elements()) # 统计最多的元素，写多少就是前几名，排序随机，无固定 print counterA.most_common(1) # 获取最少的元素，首选想到的就是倒叙，然后取值，示例是取第一个值 print counterA.most_common()[::-1][0:1] # 转换 list(counterA) set(counterA) dict(counterA) # 简单初始化 counterTemp=collections.Counter() # 获取最大值 maxValue=max(counterTemp.values())
27. 有默认值的字典
# 字典如果直接访问没有默认值的结点会报错的哟 # 方法1 直接使用setdefault dictA.setdefault('abc',0)+1 # 方法2 使用collections中的defalutdict from collections import defaultdict # 创建一个字典，并将默认值设置为type类 dictB=defaultdict(type，目标) # 添加数据和list类似，使用append dictB['键'].append('值') # 删除也是和list类似，使用pop即可(访问有效才可以删除，没东西你删啥子) print dictB.get('键') # 已经和list类似了，以前用的是has_key() print '键' in dictB # 当然你有特殊的默认值没毛病，只需要一个没有参数，有返回值的可调用函数即可 def zero(): return 0 dictC=defaultdict(zero) # 使用lambda也是没毛病的，这个更简单 dictD=defaultdict(lambda: 0)
28. dict的增删改查
# 增 dictA['键']='值' ## 改和删之前要先查一下 # 删 del dictA['键'] # 永久性删除 k=dictA.pop('键') # 弹出，有返回值--不是键+值 k=dictA.popitem() # 随机弹出，有返回值 # 改 dictA['键']='值' # 保证其值存在 # 查 get() has_key() in都可以 后两者都是返回的boolean值哟 print(dictA["键"]) print(dictA.get("键")) print("键" in dictA)
29. 二进制优化策略bit map
# 使用bit map可以节省空间，典型的空间换区的例子 # 我们可以使用numA存储1和4的位置，表示1和3存在，因为5的二进制是101的关系 numA=1+2**2 print("转换为二进制为（前缀是0b）：", bin(numA)) print("转换为八进制为（前缀是0o）：", oct(numA)) print("转换为十六进制为（前缀是0x）：", hex(numA)) # 转化后的结果是一个字符串 提取信息可以通过-k来提取 print(bin(numA)[-1])
30. 找到字符串中的某个元素(使用字典效果更好呕)
# 使用find就可以找到 find("目标值",start,end) stringA="abcdefg" # 打印的是下标位置 1 print stringA.find('b') # 如果没有打印-1 print stringA.find("K") # string也可以进行翻转来倒叙查找 print string[::-1]
31. 判断字符串回文
# 对于回文问题不用来回搞，只需要倒叙对比就行了，呕 s='abcba' print s==s[::-1]
32. 字符，ASCII码的转换
# ord负责字符转换成数字 chA='a' print ord(chA) # chr负责将0~256范围内的整数作为参数，返回对应值 numA=65 print chr(numA) # unichr()不常用，你只要知道他也可以就行了
33. strip()和split() 格式处理和分割处理
# strip用于处理字符串的前后情况，默认为空格 strA=' asdf asdf adsf ' print strA.strip() # split用于字符串的分割 print str.strip().split(" ") # 注意一下 对于两个空格的时候会分割出一个空格 三个空格分割出两个空格 以此类推 # ['a', '', 'a'] a='a a' # ['b', '', '', 'b'] b='b b'
34. 初始化多维列表
# 利用for循环即可 ListA=[[0]*3 for _ in range(10)] # 这里[0]*3直接生成一维List，for中的_表示只需要遍历即可，不需要i进行调用
35. class的使用
class Solution(object): # 别忘了self就行 def function1(self, 参数): def main(): solveClass = Solution() print solveClass.function1(参数) if __name__ == '__main__': main()
36. and运算符和or运算符
# and or 短路运算符 a=1 b=2 c=0 # and 遇到不满足条件就跳出，后续不执行 print a and b #2 print b and a #1 print c and a #0 # or 遇到满足条件就跳出，后续不执行 print a and b #1 print b and a #2 print c and c #0
37. 通过条件获取list中的前项or后项
# 利用True和False即可，True表示1，False表示0 listA=[1,2,3] print listA[True] # 2 print listA[False] # 1 # 自然True可以换成表达式 print listA[1>2] # 1不可能大于2 结果是False--1
38. 利用is和boolean值进行异或操作
# 异或操作只针对于1和0，所以我们通过表达式构成boolean值就可以获得1,0值 print (1>2) is (1>4) # 转变过来是，False is Fasle 没毛病，结果是True，或者用等号也可以 print (1>2) == (1>4)
39. 正则表达式替换文本
import re # 确定规范 ruleA=re.compile('blue|white|red') # 替换成，替换目标，最大替换个数 print (ruleA.sub('替换成？','替换目标字符串 blue and red'， count=2))
40. 正则表达式中的match和search
# match匹配开头信息，search搜索第一个匹配值 # group() 返回被 RE 匹配的字符串 # start() 返回匹配开始的位置 # end() 返回匹配结束的位置 # span() 返回一个元组包含匹配 (开始,结束) 的位置 print (re.match(‘super’, ‘superstition’).span()) print (re.search(‘super’, ‘superstition’).span())
41. 正则表达式贪婪匹配和非贪婪匹配
# 问号的使用，可以让贪婪变成非贪婪 # 贪婪越多越好，非贪婪越少越好，匹配到就滚犊子 re.match(r"aa(\d+)","aa2343ddd").group() # 'aa2343' re.match(r"aa(\d+?)","aa2343ddd").group() # 'aa2'
42. 字符串的单双引号
# 字符串的单双引号只要穿插使用就没问题了 # 如果包含使用，麻烦老板请用\转义字符 strA = 'ab\'cd' strB = "ab\'cd"
43. 递归和while
# 递归的使用必须搭配return # 在调用函数的时候，如果没有执行return，那么就返回None def gcd(a,b): if a%b==0: return b else: return (gcd(b,a%b))
能用while就不要用递归，递归看着太乱了
44. 读取List矩阵内容并提取内容
# 使用sum配合 for迭代构建列表元素 方便观看 就这么写了 martixList=sum( ([(进行存储)] for 遍历 遍历结束 判断条件--回执到前面进行存储), [] )
为了保证其不一样，我们不要使用1和0，而是使用超出范围外的字符就可以
45. 元组和数组，元组--不可更改，数组--可更改
a=[1,2,3] a[0]=3 # a--[3,2,3] b=(1,2,3) # b[0]=3 报错
46. 列表的快速删除使用del
>>>a=range(10) >>> a [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> del(a[3::3]) >>> a [0, 1, 2, 4, 5, 7, 8]
47. 针对class结构体的排序问题
# 初始化一个类 用于存储结构体 class Interval(object): def __init__(self, s=0, e=0): self.start = s self.end = e # 使用sorted进行排序(排序目标，key值=lambda表达式) intervals = sorted(intervals, key=lambda x:x.start)
48. format来显示信息+阶乘，记得引入math包
print('{1}今天{0}'.format('拍视频','陈某某')) print('{0}今天{1}'.format('陈某某','拍视频')) # 配合得到阶乘信息 print("{0} 的阶乘为 {1}".format(num, math.factorial(num)))
49. 将list中的所有数字转化成str，并转化成一整个str
a=range(1,4) # 1 使用map b=map(str,a) # 2 使用for循环 b=[] for tmp in a: b.append(str(tmp))
''.join(b)
50. 打包为元组 zip
a = [1,2,3] b = [4,5,6] c = [4,5,6,7,8] # 打包为元组的列表 zipped = zip(a,b) >>>[(1, 4), (2, 5), (3, 6)] # 元素个数与最短的列表一致 zip(a,c) >>>[(1, 4), (2, 5), (3, 6)]
51. 双重合并 组合结果
# 利用两个for循环来解决二维元祖的字符串合并 注意join仅仅只能操作字符串列表，所以可能需要map转换 result.append(''.join([s for newZip in zip(a, b) for s in newZip]))
52. append函数
# append是不能够直接赋值的，修改是在原列表或者原字典中修改 a=[1,2,3] print a >>>[1, 2, 3] b=a.append(4) print a >>> [1, 2, 3, 4] print b >>> None
53. set的减法
# set是允许做减法的，如果想要查找set1中去除掉set2的结果，使用减法哟 a >>> [1, 2, 3, 4] b >>> [1, 2, 3, 5] newA=set(a) newB=set(b) newA-newB >>> set([4])
54. operator的除法问题
# 众所周知，整数的除法可以正常运行，但是在python中涉及到负数并不尽如人意 # 所以引入了operator中的truediv方法 >>> 10/3 3 >>> -10/3 -4 >>> operator.truediv(-10,3) -3.3333333333333335 >>> int(operator.truediv(-10,3)) -3
55. 遍历获取List的下标和值
# 方法1 for i in list: print ("序号：%s 值：%s" % (list.index(i) + 1, i)) # 方法2 for i in range(len(list)): print ("序号：%s 值：%s" % (i + 1, list[i])) # 方法3 for i, val in enumerate(list): print ("序号：%s 值：%s" % (i + 1, val)) # 方法4 print '设置遍历开始初始位置，只改变了起始序号：' for i, val in enumerate(list, 2): print ("序号：%s 值：%s" % (i - 1, val))
56. 矩阵DP
# 使用这种方式能同时处理两个元素，并放在一个元素中应用 # 找到相邻点只需要+1 -1 +1j -1j即可 matrix = {i + j*1j: val for i, row in enumerate(matrix) for j, val in enumerate(row)}
57. 遍历字典信息
print '-----------dict-------------' for d in mydic: print "%s:%s" %(d, mydic[d]) print '-----------item-------------' for (key,value) in mydic.items(): #返回字典列表 print '%s:%s' %(key, value) print '------------iteritems---------' for (key,value) in mydic.iteritems(): #返回一个迭代器对象 print '%s:%s' % (key, value) #很古老的方式：不推荐使用 print '---------iterkeys---------------' for key in mydic.iterkeys(): print '%s:%s' % (key, mydic[key]) print '------------iterkeys, itervalues----------' for key,value in zip(mydic.iterkeys(), mydic.itervalues()): print '%s:%s' % (key, value)
58. 二分搜索模块
import bisect L = [1,3,3,6,8,12,15] x = 3 # 在L中查找x，x存在时返回x左侧的位置，x不存在返回应该插入的位置 # 这是3存在于列表中，返回左侧位置１ x_insert_point = bisect.bisect_left(L,x) # 在L中查找x，x存在时返回x右侧的位置，x不存在返回应该插入的位置 # 这是3存在于列表中，返回右侧位置３ x_insert_point = bisect.bisect_right(L,x) # 将x插入到列表L中，x存在时插入在左侧 x_insort_left = bisect.insort_left(L,x) # 将x插入到列表L中，x存在时插入在右侧 x_insort_rigth = bisect.insort_right(L,x)
59. python的format格式化
# ’{0:032b}’.format(n)将n转化为32位无符号数 >>> a=12 >>> a 12 >>> '{0:032b}'.format(a) '00000000000000000000000000001100' # 这里{}就是典型的替换关键符号，类似c中的%d # 1. 不设置指定位置，按默认顺序 'hello world' >>>"{} {}".format("hello", "world") # 2. # 设置指定位置 'hello world'和'world hello world' >>> "{0} {1}".format("hello", "world") >>> "{1} {0} {1}".format("hello", "world")
60. zip和zip(*)
>>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] # 打包为元组的列表 >>> zipped = zip(a,b) [(1, 4), (2, 5), (3, 6)] # 元素个数与最短的列表一致 >>> zip(a,c) [(1, 4), (2, 5), (3, 6)] # 与 zip 相反，可理解为解压，返回二维矩阵式，换句话讲，对拆分数组再次进行合并 >>> zip(*zipped) [(1, 2, 3), (4, 5, 6)]
>>> k=['123','555'] >>> k ['123', '555'] >>> zip(*k) [('1', '5'), ('2', '5'), ('3', '5')] # 对于单独的项可以直接进行相关处理 不论是这个，还是二重列表都可以 >>> zip(*k) [('1', '5'), ('2', '5'), ('3', '5')] >>> k=[[1,2,3],[3,4,5]] >>> k [[1, 2, 3], [3, 4, 5]] >>> zip(*k) [(1, 3), (2, 4), (3, 5)]
61. filter使用
# 第一个参数是None 简单来说就是接受非零、非空、非False值 filter(None, (True, 1, 0, -1, False)) #(True, 1, -1) # 第一个参数是Function 就是依次带入函数中，判断返回值是否为True import math def is_sqr(x): return math.sqrt(x) % 1 == 0 newlist = filter(is_sqr, range(1, 101)) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] # 结合lambda有奇效 filter(lambda x: x, [-1, 0, 1]) #[-1, 1] filter(lambda x: not x, [-1, 0, 1]) #[0] def f(x): return True if x == 1 else False filter(lambda x: f(x), [-1, 0, 1]) #[1]
62. 获取32位的最大数值
>>> a=1<<31 >>> bin(a) '0b10000000000000000000000000000000' >>> bin(a-1) '0b1111111111111111111111111111111'
63. 转化
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 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
64. dict的修改问题
>>> a=dict() >>> a {} >>> a[0]=1 >>> a[2]=2 >>> a {0: 1, 2: 2} >>> b=a>>> b[0]=4 >>> a {0: 4, 2: 2} >>> b {0: 4, 2: 2} >>> b=dict(a) >>> b[0]=6 >>> b {0: 6, 2: 2} >>> a {0: 4, 2: 2}
65. 双次排序
# 列表的双次排序 >>> c=[['b',4,5],['e',2,4],['a',2,2],['d',2,3],['c',3,1]] >>> sorted(c,key=lambda x:x[1]) [['e', 2, 4], ['a', 2, 2], ['d', 2, 3], ['c', 3, 1], ['b', 4, 5]] >>> sorted(c,key=lambda x:(x[1],x[2])) [['a', 2, 2], ['d', 2, 3], ['e', 2, 4], ['c', 3, 1], ['b', 4, 5]] # 字典的双次排序，因为有时候需要用in来判断是否在字典中 # 直接进行sorted(c)的话相当于对c.keys()排序 >>> c {'a': [2, 2], 'c': [3, 1], 'b': [4, 5], 'e': [2, 4], 'd': [2, 3]} >>> sorted(c) ['a', 'b', 'c', 'd', 'e'] >>> sorted(c.keys()) ['a', 'b', 'c', 'd', 'e'] >>> sorted(c.items()) [('a', [2, 2]), ('b', [4, 5]), ('c', [3, 1]), ('d', [2, 3]), ('e', [2, 4])] # 但是记得将结果转化成dict格式哟 # 实质上就是将dict转化成可迭代对象，按照第一个元素进行排序--也就是keys值 >>> sorted(c.items()) [('a', [2, 2]), ('b', [4, 5]), ('c', [3, 1]), ('d', [2, 3]), ('e', [2, 4])] # 想要排序后续内容，就需要lambda了，值的项属于第二项也就是x[1]，针对内部的第一项排序，也就是x[1][0] >>> sorted(c.items(),key=lambda x:x[1][0]) [('a', [2, 2]), ('e', [2, 4]), ('d', [2, 3]), ('c', [3, 1]), ('b', [4, 5])] # 排序两项，用括号，然后进行对比排序哟 >>> sorted(c.items(),key=lambda x:(x[1][0],x[1][1])) [('a', [2, 2]), ('d', [2, 3]), ('e', [2, 4]), ('c', [3, 1]), ('b', [4, 5])]
66.
67.
68.
69.
70.
71.
浙公网安备 33010602011771号