python学习经验总结

python 语言数组表示
  []列表符    ()元组符     {}字典符

1.多元赋值
x,y,z = 1,2,' a string'
也可以:
(x,y,z) = (1,2,' a string')

2.x,y值交换
x,y=1,2
x,y=y,x
结果:x=2,y=1

3.销毁一个变量
del x

4.销毁一个对像的值
abc=[1,2,3]
abc.remove(abc[0])

二.运算

①.除法:

.真除法要导入:from __future__ import division

from __future__ import division
1/2
0.5

没导入函数库就会成整除(//整除符号)

②.地板除法(//):其实就是整除
1//2
0
-1//2
-1
1.0//2/0
0.0

③幂运算(两个乘号**)

3*3(2个3相乘)
9
3**2 =3*3
9=9

3**3(3个3相乘)
27

(-3)**2 (负负得正)
9

三数学运算函数

①复数:complex()
complex(2.3e-10,45.3e4)
(2.3000000000000001e-010+453000j)

②绝对值:abs()
abs(-1)
1

③数据类型转换:coerce()
coerce(1,2)
(1,2)
coerce(1.3,22L)
(1.3,22.0)
coerce(2,3L)
(2L,3L)
coerce(2j,3L)
(2j,(3+0j))
coerce(2-4j,3L)
((2-4j),(3+0j))

④内建函数取出运算的整除结果和余数:divmod(int,int)
divmod(10,5)
(2, 0)(int结果,int余数)
divmod(10,2.5)
(4.0,0.0)

⑤幂运算函数:pow(底数,幂数)
pow(3,2)
9

 

⑥四舍五入函数:round()
round(3)
3.0
round(3.45)
3.0
round(-3.45)
-3
round(-3.45,1)
-3.5
round(0.5)
1
round(-0.5)
-1

⑦int():直接截去小数部分
  floor()还原浮点数
 
⑧进制转换:16进制hex(),8进制oct()
hex(255)
'0xff'

⑨ASCII码转函数:chr(int),ord(string),unichr(int)
chr(97)
a
ord('a')
97

 

四.字符操作:元组和列表
str="abcdef"
①翻转操作
str[::-1]
"fedcba"
②隔一个取一个
str[::2]
'ace'
③如何删除字符串中一个字符
aString = 'Hello World!'
aString = aString[:3] + aString[4:]
aString
'Helo World!'

④字符列表[]运算 (元素都是从0开始的.)
   0   1   2   3   4   5   6
s="a   b   c   d   e   f   g"
  -7  -6  -5  -4  -3  -2  -1
 
 
 
s[1] b  s[1:]     bcdefg   s[:1]      a

s[1:-1]   bcdef    s[:-1]     abcdef

s[-3:-1] ef

讲解:-3对应为e,-1根椐-2=-1-1,-2对应的为f,结果为ef

s[-3:] efg

讲解:-3对应的为e,":"号后为空视为-1,取值到最后,结果为efg

字符模块

import string

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>> string.digits
'0123456789'

五.调试工具

repr()函数,'' 或str()函数

六.字符串模板: 更简单的替代品
由于新式的字符串Template 对象的引进使得string 模块又重新活了过来，Template 对象
有两个方法,substitute()和safe_substitute().前者更为严谨,在key 缺少的情况下它会报一
个KeyError 的异常出来，而后者在缺少key 时，直接原封不动的把字符串显示出来.

from string import Template
s = Template('There are ${howmany} ${lang} Quotation Symbols')
print s.substitute(lang='Python', howmany=3)

print s.safe_substitute(lang='Python')

七.原始字符串操作符( r/R )
①这个'r'可以是小写也可以是大写，唯一的要求是必须紧靠在第一个引号前.
>>> '\n'
'\n'
>>> print '\n'
>>> r'\n'
'\\n'
>>> print r'\n'
\n

②文件路径中有\t'和'\r'打不开文件
f = open('C:\windows\temp\readme.txt', 'r')
则
f = open(r'C:\windows\temp\readme.txt', 'r')
>>> f.readline()
'Table of Contents (please check timestamps for last update!)\n'
>>> f.close()
内容处理中有\n的则
import re
>>> m = re.search('\\[rtfvn]', r'Hello World!\n')
>>> if m is not None: m.group()
...
>>> m = re.search(r'\\[rtfvn]', r'Hello World!\n')
>>> if m is not None: m.group()

八.内建函数
①cmp()函数也根据字符串的ASCII 码值进行比较
②en()计算长度
③max(),min()取最大值和最小值.
④enumerate()
>>> s = 'foobar'
>>> for i, t in enumerate(s):
... print i, t
...
0 f
1 o
2 o
3 b
4 a
5 r
⑤zip()
>>> s, t = 'foa', 'obr'
>>> zip(s, t)
[('f', 'o'), ('o', 'b'), ('a', 'r')]

⑥raw_input()字符串提示用户输入并将这个输入返回
⑦str() and unicode()
>>> isinstance(u'\0xAB', str)
False
>>> not isinstance('foo', unicode)
True
>>> isinstance(u'', basestring)
True
>>> not isinstance('foo', basestring)
False

九.字符串内建函数

方法                          描述

方法 描述
string.capitalize() 把字符串的第一个字符大写
string.center(width) 返回一个原字符串居中,并使用空格填充至长度width 的新字符
串
string.count(str, beg=0,
end=len(string)) 返回str 在string 里面出现的次数，如果beg 或者end 指定则
返回指定范围内str 出现的次数
string.decode(encoding='UTF-8',
errors='strict') 以encoding 指定的编码格式解码string，如果出错默认报一个
ValueError 的异常， 除非errors 指定的是'ignore' 或者
'replace'
string.encode(encoding='UTF-8',
errors='strict')a 以encoding 指定的编码格式编码string，如果出错默认报一个
ValueError 的异常，除非errors 指定的是'ignore'或者'replace'
string.endswith(obj, beg=0,
end=len(string))b,e 检查字符串是否以obj 结束，如果beg 或者end 指定则检查指
定的范围内是否以obj 结束，如果是，返回True,否则返回False.
string.expandtabs(tabsize=8)把字符串string 中的tab 符号转为空格，默认的空
格数tabsize 是8.
string.find(str, beg=0,
end=len(string)) 检测str 是否包含在string 中，如果beg 和end 指定范围，
则检查是否包含在指定范围内，如果是返回开始的索引值，否则
返回-1
string.index(str, beg=0,
end=len(string)) 跟find()方法一样，只不过如果str 不在string 中会报一个异常.
string.isalnum()a, b, c R 如果string 至少有一个字符并且所有字符都是字母或数字则返
回True,否则返回False
string.isalpha()a, b, c 如果string 至少有一个字符并且所有字符都是字母则返回True,
否则返回False
string.isdecimal()b, c, d 如果string 只包含十进制数字则返回True 否则返回False.
string.isdigit()b, c 如果string 只包含数字则返回True 否则返回False.
string.islower()b, c 如果string 中包含至少一个区分大小写的字符，并且所有这些(区分
大小写的)字符都是小写，则返回True，否则返回False
Edit By Vheavens
Edit By Vheavens
string.isnumeric()b, c, d 如果string 中只包含数字字符，则返回True，否则返回False
string.isspace()b, c 如果string 中只包含空格，则返回True，否则返回False.
string.istitle()b, c 如果string 是标题化的(见title())则返回True，否则返回False
string.isupper()b, c 如果string 中包含至少一个区分大小写的字符，并且所有这些(区分
大小写的)字符都是大写，则返回True，否则返回False
string.join(seq) Merges (concatenates)以string 作为分隔符，将seq 中所有的元素
(的字符串表示)合并为一个新的字符串
string.ljust(width)返回一个原字符串左对齐,并使用空格填充至长度width 的新字符串
string.lower() 转换string 中所有大写字符为小写.
string.lstrip() 截掉string 左边的空格
string.partition(str)e 有点像find()和split()的结合体,从str 出现的第一个位置起,
把字符串string 分成一个3 元素的元组
(string_pre_str,str,string_post_str),如果string 中不包含
str 则string_pre_str == string.
string.replace(str1, str2,
num=string.count(str1))把string 中的str1 替换成str2,如果num 指定，
则替换不超过num 次.
string.rfind(str, beg=0,end=len(string))类似于find()函数，不过是从右边开始查
找.
string.rindex( str, beg=0,end=len(string)) 类似于index()，不过是从右边开始.
string.rjust(width)返回一个原字符串右对齐,并使用空格填充至长度width 的新字符串
string.rpartition(str)e 类似于partition()函数,不过是从右边开始查找.
string.rstrip() 删除string 字符串末尾的空格.
string.split(str="", num=string.count(str)) 以str 为分隔符切片string，如果num
有指定值，则仅分隔num 个子字符串
string.splitlines(num=string.count('\n'))b, c 按照行分隔，返回一个包含各行作为元素
的列表，如果num 指定则仅切片num 个
行.
string.startswith(obj, beg=0,end=len(string))b, e 检查字符串是否是以obj 开头，是则
返回True，否则返回False。如果
beg 和end 指定值，则在指定范围内
Edit By Vheavens

几个使用字符串方法的例子:
>>> quest = 'what is your favorite color?'
>>> quest.capitalize()
'What is your favorite color?'
>>>
>>> quest.center(40)
' what is your favorite color? '
>>>
>>> quest.count('or')
2
>>>
>>> quest.endswith('blue') False
>>>
>>> quest.endswith('color?') True
>>>
>>> quest.find('or', 30)
-1
Edit By Vheavens
Edit By Vheavens
>>>
>>> quest.find('or', 22)
25
>>
>>> quest.index('or', 10)
16
>>>
>>> ':'.join(quest.split())
'what:is:your:favorite:color?'
>>> quest.replace('favorite color', 'quest')
>>>
'what is your quest?'
>>>
>>> quest.upper()
'WHAT IS YOUR FAVORITE COLOR?'
>>> 'leanna, silly girl!'.upper()
'LEANNA, SILLY GIRL!'

反斜杠开头的转义字符
/X 八进制 十进制 十六进制 字符 说明
\0 000 0 0x00 NUL 空字符Nul
\a 007 7 0x07 BEL 响铃字符
\b 010 8 0x08 BS 退格
\t 011 9 0x09 HT 横向制表符
\n 012 10 0x0A LF 换行
\v 013 11 0x0B VT 纵向制表符
\f 014 12 0x0C FF 换页
\r 015 13 0x0D CR 回车
\e 033 27 0x1B ESC 转义
\" 042 34 0x22 " 双引号
\' 047 39 0x27 ' 单引号
\\ 134 92 0x5C \ 反斜杠
\OOO 八进制值(范围是000 到0177)
\xXX x 打头的十六进制值(范围是0x00 到0xFF)
\ 连字符，将本行和下一行的内容连接起来.

十.id()函数:来更明显的显示出来到底发生了什么
>> s = 'abc'
>>> id(s)
135060856

unicode()的工厂方法，同Unicode 字符串操作符(u / U)的工作方式很类似，它接受一个
string 做参数，返回一个Unicode 字符串
decode()和encode()内建函数接受一个字符串做参数返回该字符串对应的解码后/编码后
的字符串

与字符串类型有关的模块
模块 描述
string 字符串操作相关函数和工具，比如Template 类.
re 正则表达式:强大的字符串模式匹配模块
struct 字符串和二进制之间的转换
c/StringIO 字符串缓冲对象，操作方法类似于file 对象.
base64 Base 16,32,64 数据编解码
codecs 解码器注册和基类
crypt 进行单方面加密
diffliba 找出序列间的不同
hashlibb 多种不同安全哈希算法和信息摘要算法的API
hmac HMAC 信息鉴权算法的Python 实现
md5d RSA 的MD5 信息摘要鉴权
rotor 提供多平台的加解密服务
shad NIAT 的安全哈希算法SHA
stringprepe 提供用于IP 协议的Unicode 字符串
textwrape 文本打包和填充
unicodedata Unicode 数据库
a. Python2.1 新加
b.Python2.5 新加
c. Python2.2 新加
d. Python2.5 的hashlib 中废除
e. Python2.3 新加

十一.list() 和 tuple()迭代对象,两种类型之间进行转换

>>> aList = ['tao', 93, 99, 'time']
>>> aTuple = tuple(aList)
>>> aList, aTuple
(['tao', 93, 99, 'time'], ('tao', 93, 99, 'time'))

List Method Operation
list.append(obj) 向列表中添加一个对象obj
list.count(obj) 返回一个对象obj 在列表中出现的次数
list.extend(seq)a 把序列seq 的内容添加到列表中
list.index(obj, i=0,
j=len(list)) 返回list[k] == obj 的k 值,并且k 的范围在 i<=k<j;否则
引发ValueError 异常.
list.insert(index, obj) 在索引量为index 的位置插入对象obj.
list.pop(index=-1)a 删除并返回指定位置的对象,默认是最后一个对象
list.remove(obj) 从列表中删除对象obj
list.reverse() 原地翻转列表
list.sort(func=None,key=None,reverse=False)b 以指定的方式排序列表中的成员,如果func 和key 参数指定,
则按照指定的方式比较各个元素,如果reverse 标志被置为
True,则列表以反序排列.

music_media.insert(0, 'compact disc')
>>> music_media
['compact disc', 45]
>>>
>>> music_media.append('long playing record')
>>> music_media
['compact disc', 45, 'long playing record']
>>>
>>> music_media.insert(2, '8-track tape')
>>> music_media
['compact disc', 45, '8-track tape', 'long playing record']

我们用in 操作符和index()方法实现这两个需求
>>> 'cassette' in music_media
False
>>> 'compact disc' in music_media
True
>>> music_media.index(45)
1
>>> music_media.index('8-track tape')
2
>>> music_media.index('cassette') Traceback (innermost last):
File "<interactive input>", line 0, in ? ValueError: list.index(x): x not in list

for eachMediaType in (45, '8-track tape', 'cassette'):
if eachMediaType in music_media:
print music_media.index(eachMediaType)

接下来我们测试sort()和reverse()方法,它们会把列表中的元素排序,然后翻转
>>> music_media
['compact disc', 45, '8-track tape', 'long playing record']
>>> music_media.sort()
>>> music_media
[45, '8-track tape', 'compact disc', 'long playing record']
>>> music_media.reverse()
>>> music_media
['long playing record', 'compact disc', '8-track tape', 45]

十二.浅拷贝和深拷贝

浅拷贝实例1.
>>> hubby[0] = 'joe'
>>> wifey[0] = 'jane'
>>> hubby, wifey
(['joe', ['savings', 100.0]], ['jane', ['savings', 100.0]])
>>> hubby[1][1] = 50.00
>>> hubby, wifey
(['joe', ['savings', 50.0]], ['jane', ['savings', 50.0]]

浅拷贝实例2.
>>> person = ['name', ['savings', 100.00]]
>>> hubby = person[:] # slice copy
>>> wifey = list(person) # fac func copy
>>> [id(x) for x in person, hubby, wifey]
[11826320, 12223552, 11850936]

深拷贝 -- copy.deepcopy()函数和copy模块 import copy

>>> person = ['name', ['savings', 100.00]]
>>> hubby = person
>>> import copy
>>> wifey = copy.deepcopy(person)
>>> [id(x) for x in person, hubby, wifey]
[12242056, 12242056, 12224232]
>>> hubby[0] = 'joe'
>>> wifey[0] = 'jane'
>>> hubby, wifey
(['joe', ['savings', 100.0]], ['jane', ['savings', 100.0]])
>>> hubby[1][1] = 50.00
>>> hubby, wifey
(['joe', ['savings', 50.0]], ['jane', ['savings', 100.0]])

 

int(x [,base ])         将x转换为一个整数  
3.long(x [,base ])        将x转换为一个长整数  
4.float(x )               将x转换到一个浮点数  
5.complex(real [,imag ])  创建一个复数  
6.str(x )                 将对象 x 转换为字符串  
7.repr(x )                将对象 x 转换为表达式字符串  
8.eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
9.tuple(s )               将序列 s 转换为一个元组  
10.list(s )                将序列 s 转换为一个列表  
11.chr(x )                 将一个整数转换为一个字符  
12.unichr(x )              将一个整数转换为Unicode字符  
13.ord(x )                 将一个字符转换为它的整数值  
14.hex(x )                 将一个整数转换为一个十六进制字符串  
15.oct(x )                 将一个整数转换为一个八进制字符串 

1.操作                      描述  
2.s + r                   序列连接  
3.s * n , n * s           s的 n 次拷贝,n为整数  
4.s % d                   字符串格式化(仅字符串)  
5.s[i]                    索引  
6.s[i :j ]                切片  
7.x in s , x not in s     从属关系  
8.for x in s :            迭代  
9.len(s)                  长度  
10.min(s)                  最小元素  
11.max(s)                  最大元素  
12.s[i ] = x               为s[i]重新赋值  
13.s[i :j ] = r            将列表片段重新赋值  
14.del s[i ]               删除列表中一个元素  
15.del s[i :j ]            删除列表中一个片段

1.x << y                  左移  
2.x >> y                  右移  
3.x & y                   按位与  
4.x | y                   按位或  
5.x ^ y                   按位异或 (exclusive or)  
6.~x                      按位翻转  
7.x + y                   加  
8.x - y                   减  
9.x * y                   乘  
10.x / y                   常规除  
11.x // y                  地板除  
12.x ** y                  乘方 (xy )  
13.x % y                   取模 (x mod y )  
14.-x                      改变操作数的符号位  
15.+x                      什么也不做  
16.~x                      ~x=-(x+1)  
17.abs(x )                 绝对值  
18.divmod(x ,y )           返回 (int(x / y ), x % y )  
19.pow(x ,y [,modulo ])    返回 (x ** y ) x % modulo  
20.round(x ,[n])           四舍五入，n为小数点位数  
21.x < y                   小于  
22.x > y                   大于  
23.x == y                  等于  
24.x != y                  不等于(与<>相同)  
25.x >= y                  大于等于  
26.x <= y                  小于等于