[关闭]
@king 2015-10-10T19:03:32.000000Z 字数 4774 阅读 2664

Python常用方法

Python

输入输出

  1. # 输出实例，Python3 必须加括号
  2. print ('hello','world')
  4. # 输入实例  
  5. name = input(); 
  8. #输入时提示  
  9. name = input('please enter your name:'); 
  11. #格式转换,如果输入字母等非数字字符会报错  
  12. birth = int(input('birth:'))

字符表示

  1. #转义  
  2. print '\\\n\\'  
  4. #防止转义  
  5. print r'\\\n\\'  
  7. #多行内容表示，用三引号包括  
  8. print ('''line1 
  9. line2 
  10. ling2''')
  12. #布尔值  
  13. print (3 > 2)
  15. #转化成UTF-8编码  
  16. str = '中文'.encode('utf-8'))
  17. #将上述字符串解码并输出
  18. print(str.decode('utf-8'))

文本文件编码

  1. #!/usr/bin/env python  
  2. # -*- coding: utf-8 -*-

格式化

  2. #格式化输出实例  
  3. print('Hello,%s' % 'world')
  4. print('%s, %s' % ('Hello', 'world'))
  6. #格式化整数和小数  
  7. print('%2d-%02d' %(3,1))
  8. print('%.2f' %3.1415926)
  10. #万能格式化%s,可以替代所有格式化  
  11. print('%s-0%s' %(3,1))
  12. print('%s' %3.1415926)
  14. #对于Unicode字符串，用法完全一样，但最好确保替换的字符串也是Unicode字符串  
  15. print(u'Hi,%s' % u'Jason0539')
  17. #有占位符的情况下输出百分号%，用双%即可  
  18. print('growth rate:%d%%' % 7)

列表list

  1. #列表list，可变的有序列表  
  2. classmates = ['Jack','Bob','Tracy']
  4. #len函数获取它的长度  
  5. len(classmates)  
  7. #获取某个元素，用中括号索引  
  8. classmates[2]  
  10. #倒数索引，可以倒序获取数组元素  
  11. classmates[-1]  
  13. #append追加元素到末尾  
  14. classmates.append('Adam')
  16. #insert插入到指定位置  
  17. classmates.insert(0,'Jason0539') 
  19. #pop 删除并返回末尾元素  
  20. classmates.pop()  
  22. #pop 删除并返回指定位置元素  
  23. classmates.pop(0)
  25. #元素改变，直接赋值即可  
  26. classmates[0]='Jason0539' 
  28. #list可以嵌套，可用二维索引  
  29. s = ['python','java',['asp','jsp'],'scheme']  
  30. print(s[2][1])
  32. #空列表  
  33. l=[]

元组tuple

  1. #不可变有序的数组  
  2. #定义元组  
  3. classmates = ('Michael','Bob','Tracy') 
  4. classmates = () # 空tuple
  5. t = (1,) # 单元素tuple
  7. #注意不能用 t = (1) 来定义， 因为它定义的不是tuple，是 1 这个数，这是因为括号既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。  
  9. #表面上可变的tuple  
  10. t = ('a','b',['A','B']) 
  11. t[2][0]='X'  
  12. t[2][1]='Y' 
  13. #表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向 ‘a’，就不能改成指向 ‘b’ ，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的

字典dict 

  1. #字典 dict 即键值对组，dict的key必须是不可变对象。  
  2. d = {'Michael':95,'Bob':75,'Tracy':85} 
  4. #把数据放入dict的方法，除了初始化时指定外，还可以通过key放入，在这之前，d 必须被声明，否则会报错  
  5. d['Jason']=5390  
  7. #判断key是否在字典中,区分大小写  
  8. #1.in判断  
  9. 'Jason' in d
  11. #2.通过dict提供的get方法判断，如果key不存在，可以返回None，或者返回自己指定的默认value  
  12. d.get('Thomas')  
  13. d.get('Thomas',-1)  
  15. #3.要删除一个key，用pop(key)方法，对应的value也会从dict中删除  
  16. d.pop('Jason')

集合set

  1. #set和dict类似，也是一组key的集合，但不存储value，没有重复的key  
  2. #要创建一个set，需要提供一个list作为输入集合  
  3. s = set([1,2,3])  
  5. #重复元素在set中自动被过滤  
  6. s = set([1,2,3,2,3,2,4])  
  7. print(s)
  9. #通过add(key)方法可以添加元素到set中，可以重复添加，但没有效果  
  10. s.add(4)
  12. #通过remove(key)方法可以删除元素  
  13. s.remove(4)
  15. #判断元素是否在set中  
  16. 5 in s 
  18. #set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作  
  19. s1 = set([1,2,3])  
  20. s2 = set([2,3,4])  
  21. print(s1 & s2)
  22. print(s1 |s2 )

字符串处理

常用代码片

  1. # 复制字符串，利用切片
  2. s1 = 'king'
  3. s2 = s1[::]
  5. # 扫描字符串是否包含指定字符（串）
  6. s1 = '12345678' # 待检查
  7. s2 = '456' # 指定字符串
  8. print(bool(sStr1.find(sStr2))) # 方法1
  9. print(bool(len(s1 and s2)) # 方法2
  11. # 将字符串前n个字符替换为指定的字符
  12. s = '12345'
  13. ch = 'r'
  14. n = 3
  15. s = n * ch + s[3:]
  17. # 翻转字符串
  18. s1 = '12345'
  19. s2 = s1[::-1]
  21. # 连接字符串
  22. delimiter = ','
  23. mylist = ['Brazil', 'Russia', 'India', 'China']
  24. print(delimiter.join(mylist)) # Brazil,Russia,India,China
  26. # 只显示字母与数字
  27. def OnlyCharNum(s):
  28.     s2 = s.lower();
  29.     fomart = 'abcdefghijklmnopqrstuvwxyz0123456789'
  30.     for c in s2:
  31.         if not c in fomart:
  32.             s = s.replace(c, '');
  33.     return s;

判断

  1. s.startwith(prefix[,start[,end]]) # 是否以prefix开头 
  2. s.endwith(suffix[,start[,end]]) # 以suffix结尾 
  3. s.isalnum() # 是否全是字母和数字，并至少有一个字符 
  4. s.isalpha() # 是否全是字母，并至少有一个字符 
  5. s.isdigit() # 是否全是数字，并至少有一个字符 
  6. s.isspace() # 是否全是空白字符、\t、\n，并至少有一个字符 
  7. s.islower() # s中的字母是否全是小写 
  8. s.isupper() # s中的字母是否便是大写 
  9. s.istitle() # s是否是首字母大写的

大小写转换

  1. s.upper() #转大写  
  2. s.lower() #转小写  
  3. s.capitalize() #首字母大写，其余小写  
  4. s.title() #把每个单词第一个字母大写，其余小写  
  5. s.swapcase() #大小写互换

输出时对齐

  1. s.ljust(width,[fillchar]) # 输出width个字符，左对齐，不足部分用fillchar填充，默认的为空格。 
  2. s.rjust(width,[fillchar]) # 右对齐 
  3. s.center(width, [fillchar]) #中间对齐 
  4. s.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足

搜索和替换

  1. s.find(substr, [start, [end]]) # 返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。
  2. s.index(substr, [start, [end]]) #  与find()相同，只是在s中没有substr时，会返回一个运行时错误 
  3. s.rfind(substr, [start, [end]]) 
  4. #从右边算起的第一次出现的substr的首字母标号，没有则返回-1
  5. s.rindex(substr, [start, [end]]) # 与index类似，从右数
  6. s.count(substr, [start, [end]]) #计算substr在s中出现的次数 
  7. s.replace(oldstr, newstr, [count]) 
  8. #把s中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换 
  9. s.strip([chars]) 
  10. # 把s首尾的chars中的字符全去掉
  11. s.lstrip([chars]) # 同上，仅查左首
  12. s.rstrip([chars]) 
  13. s.expandtabs([tabsize]) # 把s中的tab字符替换为空格，每个tab替换为tabsize个空格，默认是8个

分割和组合

  1. s.split([sep, [maxsplit]]) # 以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 
  2. s.rsplit([sep, [maxsplit]]) # 同上，从右开始
  3. s.splitlines([keepends]) # 把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。 
  4. s.join(seq) # 把seq代表的序列──字符串序列，用S连接起来

映射

  1. s.maketrans(from, to) # 返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。 
  2. s.translate(table[,deletechars]) # 使用上面的函数产生的翻译表，把s进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果s为unicode字符串，那么就不支持。 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。

编码和解码

  1. s.encode([encoding,[errors]]) # 其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。
  2. s.decode([encoding,[errors]])

类型转换

这几个函数只在string模块中有： 

  1. string.atoi(s[,base]) # base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串 
  2. string.atol(s[,base]) #转成long 
  3. string.atof(s[,base]) #转成float

这里再强调一次，字符串对象是不可改变的，也就是说在python创建一个字符串后，你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后，都会返回一个新的字符串，原字串并没有变。其实这也是有变通的办法的，可以用sS=list(s)这个函数把S变为由单个字符为成员的list，这样的话就可以使用s[3]='a'的方式改变值，然后再使用s="".join(s)还原成字符串

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注