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来做循环

whilelen(listA):#默认是删除并提取最后一个元素

k=listA.pop(0)#也可以利用len来遍历结果

for i inrange(len(listA)):print listA[i]

8. 字符串的拼接

s=1m=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__ importprint_function

a='abcd'

print ("%s" %a, end='')

14. List求和求均值

#求和很简单

sumA=sum(listA)#均值利用sum和len即可

meanA=sum(listA)/len(listA)

15. 生成组合结果

importitertools

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 initertools.permutations(strA,len(strA))]returnlistA#其应用实质就是不断的插入，选择一个点插入，在遍历下一个点找位置插入即可

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来处理

importitertools#使用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. 取整方法

importmath#四舍五入 使用0.5 或者 直接使用round()

numA=2.5

print int(numA+0.5)printround(numA)#向下取整 直接使用int 或者 使用math的地板数

printint(numA)printmath.floor(numA)#向上取整 使用math的ceil函数

printmath.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=1b=3c=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)[目标位置下标]]importoperator

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处理数据并不会出现重复问题的哟

importnumpy 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删除某键

delcounterA[某个键]#类似字典keys获取全部键

printcounterA.keys()#elements获取全部值，但是因为生成的是itertools，所以转换list显示

printlist(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 importdefaultdict#创建一个字典，并将默认值设置为type类

dictB=defaultdict(type，目标)#添加数据和list类似，使用append

dictB['键'].append('值')#删除也是和list类似，使用pop即可(访问有效才可以删除，没东西你删啥子)

print dictB.get('键')#已经和list类似了，以前用的是has_key()

print '键' indictB#当然你有特殊的默认值没毛病，只需要一个没有参数，有返回值的可调用函数即可

defzero():return0

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'

printord(chA)#chr负责将0~256范围内的整数作为参数，返回对应值

numA=65

printchr(numA)#unichr()不常用，你只要知道他也可以就行了

33. strip()和split() 格式处理和分割处理

#strip用于处理字符串的前后情况，默认为空格

strA='asdf asdf adsf'

printstrA.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的使用

classSolution(object):#别忘了self就行

deffunction1(self, 参数):defmain():

solveClass=Solution()printsolveClass.function1(参数)if __name__ == '__main__':

main()

36. and运算符和or运算符

#and or 短路运算符

a=1b=2c=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. 正则表达式替换文本

importre#确定规范

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

defgcd(a,b):if a%b==0:returnbelse: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结构体的排序问题

#初始化一个类 用于存储结构体

classInterval(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 ina:

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]printa>>>[1, 2, 3]

b=a.append(4)printa>>> [1, 2, 3, 4]printb>>> 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 inlist:print ("序号：%s 值：%s" % (list.index(i) + 1, i))#方法2

for i inrange(len(list)):print ("序号：%s 值：%s" % (i + 1, list[i]))#方法3

for i, val inenumerate(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: valfor i, row inenumerate(matrix)for j, val in enumerate(row)}

57. 遍历字典信息

print '-----------dict-------------'

for d inmydic: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 inmydic.iterkeys():print '%s:%s' %(key, mydic[key])print '------------iterkeys, itervalues----------'

for key,value inzip(mydic.iterkeys(), mydic.itervalues()):print '%s:%s' % (key, value)

58. 二分搜索模块

importbisect

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

>>>a12

>>> '{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

importmathdefis_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]

deff(x):return True if x == 1 elseFalse

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.