一 字符串

1） 字符串的索引可以是负数，比如str="hello", str[-1]=o,
2) 分片 str="hello world" str[1:]返回ello world str[:-1],返回除-1位置前的所有字符，即hello wor
str[:],返回所有字符


3）分片中的第3个限制值，步长 st="123456789" st[1:-1:2] 则只显示2，3，6，8

4） 字符串转换
字符串转数字，用int(raw_input("xxxxx"))

5) join函数
a1=['a','b','c']
print "-".join(a1);
则用-将a,b,c串起来，型成a-b-c
6)split函数
a1="a-b-c"
a1.split("-")
7)strip,去掉首个字符空格 ltrip(去除左空格） RTRIP（去除右空格）
8) startswith,endswith,比较字符串是否以一个字符串开始和结束
#-*-coding:UTF-8 -*-
#Python模板
print "========欢迎使用图片上传系统========";
filename=raw_input("请输入需要上传的图片路径地址:");
if filename.endswith(".gif") or filename.endswith(".jpg"):
print "%s图片格式正确，正在上传中....."%filename;
else:
print "图片格式不正确，请上传GIF或者JPG格式图片";
9) find 函数
substring.find("t"); //从左往右查
substring.rfind("t"); //从右往左查
10） translate函数
只处理单个字符的替换
先转为一个元组，再进行转换为日期
import time;
import datetime;
print time.strftime("%Y年 %m月 %d日 %X",time.localtime());
t=time.strptime("2011-3-8","%Y-%m-%d");
y,m,d=t[0:3]
print datetime.datetime(y,m,d);
输出：2012年 02月 14日 14:29:26
2011-03-08 00:00:00

二 正则表达式
1）正则表达导入 import re;
例子：
m = re.match(r"^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\.)+[a-zA-Z]{2,}$", text);
if m:
........................................
三 面向对象
1）self,相当于java的this,比如 def getage(self):
2) python中新建对象不用new
3） 如果函数方法及属性的名称有两个下划线开始，为私有，否则为公有属性
4）私有的属性不能被实例化对象访问，但可以用实例化对象名._类名_私有属性名访问
比如class Fly:
self.__abc='xxxx'
fly=Fly()
fly._Fly__abc
5)数据属性
class ABC:
pass
data=ABC()
data.ddddd //直接添加属性，不需要预先定义

6） 静态方法
使用staticmethod或者@staticmethod
比如abc=staticmethod(getmethod) //可以把普通方法或者私有方法转为静态方法

7） 类方法和类实例方法
比如class mysql(Object):
def abc //类实例方法
.....
@classmethod
def test
.............
mysql1=mysql();
mysql1.abc
mysql.test (OK)
mysql1.test (ok)

8)类的内置方法
A 构造函数 __init__
B 析构函数 __del__
C __new__ 跟__init__
new是在创建对象时被调用，__init__创建完对象后才调用
D 还有如__setitem__,__getitem__等方法，为字典方法，还有__delitem__
E 当调用==比较对象时，即调用__cmp__方法，比较两个实例

9)方法的动态性
比如class A:
pass
def today:
a.yesterday=today //将为类A新方法yesterday.


10) 继承 class class_name(要继承的父类)
在子类中使用父类的构造函数
class father:
def __init__
....................
class son(father)
father.__init__
或者使用
super(son,self).__init__

11) python中没抽象类，但可以使用notimplementederror类来模拟抽象类，让其在实例化时异常
def abstract()
raise NotImplementedError("abstract")
class abc:
def __init__(self):
if self.__class__ is abc:
abstract()
..............
abc1=abc(); //不能实例化

12） 多继承
class aaa(父类1，父类2，父类3）
13） 类的命名空间
class mynamespace:
..
def ttt(self):
mynamespace1=mynamespace()
mynamespace1.ttt()
14) 检查一个类是否另外一个类的子类

print issubclass(子类，父类）
15）检查是否某个类的实例
print isinstance(实例名，类名)

四 新式类，从object或其他内置类型衍生的类，都叫新式类。
1）_slots__属性
python新模式的class，即从object继承下来的类有一个变量是__slots__，slots的作用是阻止在实例化类时为实例分配dict，默认情况下每个类都会有一个dict,通过__dict__访问，这个dict维护了这个实例的所有属性，举例如下
class base(object):
v = 1
def __init__(self):
pass

b = base()
print b.__dict__
b.x = 2
print b.__dict__
运行：
{}
{'x':2}
可见：实例的dict只保持实例的变量，对于类的属性是不保存的，类的属性包括变量和函数。由于每次实例化一个类都要分配一个新的dict，因此存在空间的浪费，因此有了slots，当定义了slots后，slots中定义的变量变成了类的描述符，相当于java，c++中的成员变量声明，类的实例只能拥有这些个变量，而不在有dict，因此也就不能在增加新的变量
class base(object):
__slots__ = ('y')
v = 1
def __init__(self):
pass

b = base()
print b.__dict__
b.x = 2 //error,不能增加新的变量
print b.__dict__

注意，如果类的成员变量与slots中的变量同名，
class base(object):
__slots=('y',)
y = 2
v = 1
def __init__(self):
pass

b = base()
print b.__dict__
b.x = 2
b.y = 3 //read only
print b.__dict__

目前的实现是该变量被设置为readonly！！！
又如：
#!/usr/bin/env python
#_*_ coding:utf-8 _*_

class test_slot(object):
__slots__ = "width", "height"

def width(self):
print "width"


class test(object):
def amethod(self):
print "amethod"
t=tst_slot()
t.abc='123' //出错，因为abc不在slots中规定的属性！
t.width='123' //正确。

2）__getattribute__ 检查类实例的每个属性的访问，当实例的属性无论是否找到与否都执行。

class a
def __getattribute__(self,name):
if name=='test' ................

a1=a()
a1.member
a1.test //因为有test属性，所以执行

3） 描述符：包含的有__get__(),__set__()__ 和__delete()__，将某种特殊类型的类的实例指派给另外一个类的属性。
具体见：
​​​ http://caterpillar.onlyfun.net/Gossip/Python/Descriptor.html ​​​
4） __getattr__方法：
如果某个属性在类中不存在，则调用__getattr__方法。首先在__dict__中找属性名，然后在实例的属性中