python学习笔记

★零、常用方法：
多语言脚本需要加utf编码加以识别：
#-*-coding:utf-8-*-

系统方法：
type(s)#查看变量类型
id(s) #查看内存存储ID
dir(s) #查看对象有方法
help(s)#查看s类的完整方法列表。

变量类型转换：
int()
str()
float()
bool()
将字符串False转成bool的False:
a='False'
eval(a)
★一、python转义符
>>> s = 'I\'m Python.'
>>> s
"I'm Python."

>>> print 'Python\t2.5'
Python 2.5

>>> print 'Python\n2.5'
Python
2.5

>>> print 'Python\\string'
Python\string
如不想发生转义，输出前加一个r字符：
>>> print r'Python\n2.5'
Python\n2.5

★二、字符串分隔，表列转字符串
分隔符不指定，默认是空格
import string
s='sdf@f87@9845@4578'
s1=string.split(s,'@')
['sdf','f87','9845','457']

s=string.join(s1,'-')
sdf-f87-9845-457

★三、文档字符串，定义复杂多行字符串，无需考虑其格式；
doc = """(开始)
[内容]
"""(结束)

★四、字符串切割
s='abcdefghijklmnopqrstuvwxyz'
print r's[0:2]',s[0:2]
ab
格式：字符串变量[开始位置(0开始),结束位置(实际位置-1),[步长]]

★五、unicode字符串及定义
跟普通字符串变量一样，只是在定义前面加'u'。
cn = u'中文'
len(cn)结果为2

en = '中文'
len(en)结果为4

★六、字符串编解码——str与unicode的互相转换
>>> us = u'中文'
>>> s = us.encode('mbcs')
>>> s
'\xd6\xd0\xce\xc4'
>>> print s
中文
>>> us = s.decode('mbcs')
>>> us
u'\u4e2d\u6587'
>>> print us
中文

★七、list对象
>>> l = ['a', 2, [6, 7, 8]]
>>> l
['a', 2, [6, 7, 8]]
>>> l[2][0]
6

★八、LIST对象定义
>>> l = []
>>> l
[]
>>> l = [1]
>>> l
[1]
>>> l = [1, 2, 3]
>>> l
[1, 2, 3]
>>> l = list() #这会不会让您想起C++语法？
>>> l
[]

★九、等差数列range(x)，就可以生成一个0到x的前闭后开的自然数列list，经常用到for中，很有用。
a=range(0,10,1)
print a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a=range(2,10,1)
print a
[2, 3, 4, 5, 6, 7, 8, 9]
★十、对象引用，str跟list的区别；
str引用：
>>> s = 'abcdefghijklmnopqrstuvwxyz'
>>> a = s
>>> id(s)
12502984
>>> id(a)
12502984
>>> a += 'abc'
>>> a
'abcdefghijklmnopqrstuvwxyzabc'
>>> s
'abcdefghijklmnopqrstuvwxyz'
>>> id(s)
12502984
>>> id(a)
11783488
因为其中一个对象值发生变化，内存空间将开辟新空间存放。因为str具有只读的的特证；

list引用：
>>> l = ['a', 'b', 'c']
>>> x = l
>>> x += ['a', 'b', 'c']
>>> x
['a', 'b', 'c', 'a', 'b', 'c']
>>> l
['a', 'b', 'c', 'a', 'b', 'c']

list对象可写，l,x的值都共享同一内存块；当一个值发生变化时，两个值都发生变化；
那如何复制list对象呢？通过[:]方法：

>>>l = ['a', 'b', 'c']
>>>x=l[:]
>>>x+=['e','d','f']
>>>print l,'\n\n',x
['a', 'b', 'c']
['a', 'b', 'c', 'e', 'd', 'f']

★十一、list对象常用方法(链表)：
l = ['a', 'b', 'c','d','e']
print dir(l) #显示当前对象的方法
print l.count('a') #输出list中字符'a'的个数
l.append('liu') #在list最后添加一个'liu'元素
l.insert(3,'3') #在索引3位置插入一个字符'3'
l.__len__() #显示list的大小，元素数
l.remove('a') #显示list中第一个字符'a'
l.sort() #对list进行排序
print l.index('c') #显示list中第一个'c'字符的索引位置

★十二、list对象常用方法(堆栈)：
l = ['a', 'b', 'c','d','e']
l.append('8') #相当于进栈
运行结果：['a', 'b', 'c','d','e','8']
l.pop() #相当于出栈
运行结果：['a', 'b', 'c','d','e']

★十三、list对象常用方法(对列)：
l = ['a', 'b', 'c','d','e']
l.append('8') #入队
运行结果：['a', 'b', 'c','d','e','8']
l.pop(0) #前面元素出队
运行结果：['b', 'c','d','e','8']

★十四、list对象常用方法(列表推导式,列表推导式是一种通过函数化的编程方式简洁的构造list的方法。这是一种强有力的表达方式。)：
l = [c for c in range(10)]
print l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

★十五、tuple，元组
实际上可以把我看做是一个只读的list。构造tuple实例很简单，可以用()标示的序列就
是一个tuple：
>>> tu = (1, 2, 3, 4, 5)
>>> tu
(1, 2, 3, 4, 5)
>>> type(tu)
<type 'tuple'="">

也可以直接使用tuple构造函数，通常使用这种方法自list中构造我的对象，当然，也可
以直接使用生成器推导式：
>>> x = tuple([235, 224, 120])
>>> x
(235, 224, 120)
>>> x = tuple(x**2 for x in range(1, 4))
>>> x
(1, 4, 9)

因为我也是COW(copy on write)的，就像str那样，所以修改一个tuple变量不会影响其它引用：
>>> x = tuple(x**2 for x in range(1, 4))
>>> x
(1, 4, 9)
>>> y = x
>>> id(x)
12665560
>>> id(y)
12665560
>>> x += (6,) #注意这个单元素tuple的定义
>>> x
(1, 4, 9, 6)
>>> id(x)
11371888
>>> y
(1, 4, 9)
>>> id(y)
12665560

注意上例中，为x添加一个单元素tuple时，在元素后面加了一个逗号，这样解释器就
可以正确区分出这是一个tuple。
像x, y = a, b这样的形式，解释器会将其转为tuple进行计算，然后再分解为单独的元素，
这称为tuple封装和解封。由于这种语句广泛应用于交换变量、函数返回值和传值等应用，
Python的解释器不断对其进行优化，现在的封装和拆封操作已经效率很高了。例如，在
Python2.5中使用a, b = b, a 交换变量值，比tmp = a; a = b; b = tmp更快。

*字符串转元组方法：
1、tuple(int(s) for s in '(1,2,3,4)'[1:-1].split(','))
2、eval('(1,2,3,4)', dict(__builtins__=None))
(1, 2, 3, 4)

★十六、SET是一个不重复的元素集合。可以通过调用set(...)构造函数来生成set对象。传入的重复元素会自动合并。我还支持交、并、差、补等操作
s=[1,2,3,4,5,6,2,5]
s1=[1,2,8]
n=set(s)
m=set(s1)
print type(n)
print "n:",n
print "m:",m
print "差n-m:",n-m
print "差m-n:",m-n
print "交n&m:",n&m
print "交m&n:",m&n
print "并n|m:",n|m
print "并m|n:",m|n
print "补n^m:",n^m
print "补m^n:",m^n

运行结果：
<type 'set'="">
n: set([1, 2, 3, 4, 5, 6])
m: set([8, 1, 2])
差n-m: set([3, 4, 5, 6])
差m-n: set([8])
交n&m: set([1, 2])
交m&n: set([1, 2])
并n|m: set([1, 2, 3, 4, 5, 6, 8])
并m|n: set([1, 2, 3, 4, 5, 6, 8])
补n^m: set([3, 4, 5, 6, 8])
补m^n: set([3, 4, 5, 6, 8])

★十七、dict，字典
字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
注意，你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
例子：
dt={ 'a':'1',
'b':'2',
'c':'3',
'd':'4',
'e':'5',
'f':'6'
}

dt["g"]='7' 添加/修改元素

del dt["f"] 删除f元素

for name,key in dt.items(): #遍历字典
print "user name:%s,user key:%s" %(name,key)

if 'd' in dt: #以两种判断字典元素
print dt['d']
if dt.has_key('d'):
print dt['d']

运行结果：
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'g': '7', 'f': '6'}
user name:a,user key:1
user name:c,user key:3
user name:b,user key:2
user name:e,user key:5
user name:d,user key:4
user name:g,user key:7
4
4

★十八、异常捕获与处理
try:#(定义捕获异常块)
x = int(raw_input('请输入一个整数:'))
if x%2==0:
print "%d是一个偶数" %(x)
elif x%3==0:
print "%d是一个奇数，可以被3整除" %(x)
else:
print "%d是一个奇数" %(x)
except:#(所有捕获异常信息)
print "异常错误信息:", sys.exc_info()[0], sys.exc_info()[1]
else: #(如果无异常则被执行)
print "程序运行没问题"
finally:#(不管有无异常都会被执行)
print "程序运行完毕！"

★十九、类

view plainprint?

class myClass:

count=0

m=0

def __init__(self,x,y):

self.x=x

self.y=y

self.z=x*y

myClass.count+=1

self.m+=1

def getV(self):

return self.z

def getCV(self):

print myClass.count

print self.m

print myClass(8,8).getV()

print myClass(5,8).getV()

p=myClass(20,20)

p.getCV()

运行结果：
64
40
3
3
注意类变量与对象属性(对象变量)的区别，对象属性只对当前对象起作用，类变量为全局；

★继承
一个简单的例子：

view plainprint?

class SchoolMember:

'''Represents any school member.'''

def __init__(self, name, age):

self.name = name

self.age = age

print '(Initialized SchoolMember: %s)' % self.name

def tell(self):

'''Tell my details.'''

print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember):

'''Represents a teacher.'''

def __init__(self, name, age, salary):

SchoolMember.__init__(self, name, age)

self.salary = salary

print '(Initialized Teacher: %s)' % self.name

def tell(self):

SchoolMember.tell(self)

print 'Salary: "%d"' % self.salary

class Student(SchoolMember):

'''Represents a student.'''

def __init__(self, name, age, marks):

SchoolMember.__init__(self, name, age)

self.marks = marks

print '(Initialized Student: %s)' % self.name

def tell(self):

SchoolMember.tell(self)

print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40, 30000)

s = Student('Swaroop', 22, 75)

print # prints a blank line

members = [t, s] #原来列表的成员也可以是一个对象，呵呵；

for member in members:

member.tell() # works for both Teachers and Students

运行结果：
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)

Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"