Python 基础学习

def functionName( level ):if level < 1:raise "Invalid level!", level

你也可以使用以下函数的方式来访问属性：

• getattr(obj, name[, default]) : 访问对象的属性。
• hasattr(obj,name) : 检查是否存在一个属性。
• setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
• delattr(obj, name) : 删除属性。

hasattr(emp1, ‘age‘)    # 如果存在 ‘age‘ 属性返回 True。
getattr(emp1, ‘age‘)    # 返回 ‘age‘ 属性的值
setattr(emp1, ‘age‘, 8) # 添加属性 ‘age‘ 值为 8
delattr(empl, ‘age‘)    # 删除属性 ‘age‘

你可以使用issubclass()或者isinstance()方法来检测。

• issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
• isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写：

class JustCounter:
	__secretCount = 0  # 私有变量
	publicCount = 0    # 公开变量def count(self):self.__secretCount += 1self.publicCount += 1print self.__secretCount

re.match函数

re.match(pattern, string, flags=0)

import re
print(re.match(‘www‘, ‘www.runoob.com‘).span())  # 在起始位置匹配print(re.match(‘com‘, ‘www.runoob.com‘))         # 不在起始位置匹配

line = "Cats are smarter than dogs"

matchObj = re.match( r‘(.*) are (.*?) .*‘, line, re.M|re.I)if matchObj:print "matchObj.group() : ", matchObj.group()print "matchObj.group(1) : ", matchObj.group(1)print "matchObj.group(2) : ", matchObj.group(2)else:print "No match!!"

matchObj = re.search( r‘dogs‘, line, re.M|re.I)if matchObj:print "search --> matchObj.group() : ", matchObj.group()else:print "No match!!"

检索和替换

re.sub(pattern, repl, string, max=0)

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

$ gunzip MySQL-python-1.2.2.tar.gz
$ tar -xvf MySQL-python-1.2.2.tar
$ cd MySQL-python-1.2.2
$ python setup.py build
$ python setup.py install

#!/usr/bin/python# -*- coding: UTF-8 -*-import MySQLdb# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 
cursor = db.cursor()# 使用execute方法执行SQL语句
cursor.execute("SELECT VERSION()")# 使用 fetchone() 方法获取一条数据库。
data = cursor.fetchone()print "Database version : %s " % data

# 关闭数据库连接
db.close()

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 
cursor = db.cursor()# 如果数据表已经存在使用 execute() 方法删除表。
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")# 创建数据表SQL语句
sql = """CREATE TABLE EMPLOYEE (
         FIRST_NAME  CHAR(20) NOT NULL,
         LAST_NAME  CHAR(20),
         AGE INT,  
         SEX CHAR(1),
         INCOME FLOAT )"""

cursor.execute(sql)

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 
cursor = db.cursor()# SQL 插入语句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME)
         VALUES (‘Mac‘, ‘Mohan‘, 20, ‘M‘, 2000)"""try:# 执行sql语句
   cursor.execute(sql)# 提交到数据库执行
   db.commit()except:# Rollback in case there is any error
   db.rollback()

# SQL 插入语句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME,        LAST_NAME, AGE, SEX, INCOME)        VALUES (‘%s‘, ‘%s‘, ‘%d‘, ‘%c‘, ‘%d‘ )" %        (‘Mac‘, ‘Mohan‘, 20, ‘M‘, 2000)

Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。

• fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
• fetchall():接收全部的返回结果行.
• rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 
cursor = db.cursor()# SQL 查询语句
sql = "SELECT * FROM EMPLOYEE        WHERE INCOME > ‘%d‘" % (1000)try:# 执行SQL语句
   cursor.execute(sql)# 获取所有记录列表
   results = cursor.fetchall()for row in results:
      fname = row[0]
      lname = row[1]
      age = row[2]
      sex = row[3]
      income = row[4]# 打印结果print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" %              (fname, lname, age, sex, income )except:print "Error: unable to fecth data"

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )# 使用cursor()方法获取操作游标 
cursor = db.cursor()# SQL 更新语句
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
                          WHERE SEX = ‘%c‘" % (‘M‘)try:# 执行SQL语句
   cursor.execute(sql)# 提交到数据库执行
   db.commit()except:# 发生错误时回滚
   db.rollback()

执行事务

事务机制可以确保数据一致性。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

• 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
• 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
• 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
• 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
  

  # SQL删除记录语句
  sql = "DELETE FROM EMPLOYEE WHERE AGE > ‘%d‘" % (20)try:# 执行SQL语句
     cursor.execute(sql)# 向数据库提交
     db.commit()except:# 发生错误时回滚
     db.rollback()

DB API中定义了一些数据库操作的错误及异常，下表列出了这些错误和异常:

import smtplib

smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )

参数说明：

• host: SMTP 服务器主机。 你可以指定主机的ip地址或者域名如:w3cschool.cc，这个是可选参数。
• port: 如果你提供了 host 参数, 你需要指定 SMTP 服务使用的端口号，一般情况下SMTP端口号为25。
• local_hostname: 如果SMTP在你的本机上，你只需要指定服务器地址为 localhost 即可。
  
  

SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]

参数说明：

• from_addr: 邮件发送者地址。
• to_addrs: 字符串列表，邮件发送地址。
• msg: 发送消息

这里要注意一下第三个参数，msg是字符串，表示邮件。我们知道邮件一般由标题，发信人，收件人，邮件内容，附件等构成，发送邮件的时候，要注意msg的格式。这个格式就是smtp协议中定义的格式。

thread.start_new_thread ( function, args[, kwargs] )

#!/usr/bin/python# -*- coding: UTF-8 -*-import threading
import time

class myThread (threading.Thread):def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):print "Starting " + self.name
       # 获得锁，成功获得锁定后返回True# 可选的timeout参数不填时将一直阻塞直到获得锁定# 否则超时后将返回False
        threadLock.acquire()
        print_time(self.name, self.counter, 3)# 释放锁
        threadLock.release()def print_time(threadName, delay, counter):while counter:
        time.sleep(delay)print "%s: %s" % (threadName, time.ctime(time.time()))
        counter -= 1

threadLock = threading.Lock()
threads = []# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)# 开启新线程
thread1.start()
thread2.start()# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)# 等待所有线程完成for t in threads:
    t.join()print "Exiting Main Thread"

Queue模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作
  
  
  

#!/usr/bin/python# -*- coding: UTF-8 -*-import Queueimport threading
import time

exitFlag = 0

class myThread (threading.Thread):def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)

        self.threadID = threadID

        self.name = name
        self.q = q
    def run(self):print "Starting " + self.name
        process_data(self.name, self.q)print "Exiting " + self.name

def process_data(threadName, q):

    while not exitFlag:
        queueLock.acquire()

        if not workQueue.empty():

            data = q.get()
            queueLock.release()print "%s processing %s" % (threadName, data)

        else:

            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = Queue.Queue(10)
threads = []
threadID = 1

# 创建新线程

for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# 填充队列
queueLock.acquire()

for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空

while not workQueue.empty():

    pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成

for t in threads:
    t.join()

print "Exiting Main Thread"