python学习总结

基于python2.7 的一些学习总结

你好，世界！

# coding=utf-8
print "你好，世界"

　　备注：需要声明编码格式为gbk或者utf-8才可以输出中文

乘方

 print 2**10

变量

1 var = 1
2 print var
3 
4 var  = "你好"
5 print var

获取用户输入

#获取用户输入
x = input("x:")
y = input("y:")

print x*y

注：input接受的是Python代码，输入中可以访问当前执行环境中的变量，如果想获取原始输入需要使用 raw_input。

函数定义

def say_b():
    print "b"

强类型

Javascript和Php是弱类型的，Python和Ruby是强类型的。弱类型允许不安全的类型转换，强类型则不允许。

#1 + “1” 这行代码在Python中会报错。
print 1 + int("1")
print str(1) + "1"

字符串

#字符串
print ''''    段
            光
            伟'''
print r'C:\log.txt'
print 'C:\\log.txt'

序列

这里先介绍三种序列：列表、元祖和字符串。

序列通用操作

seq = "0123456789"
print seq[0] #从0开始编码。
print seq[-1] #支持倒着数数，-1代表倒数第一。
print seq[1:5] #支持分片操作，seq[start:end]，start会包含在结果中，end不会包含在结果中。
print seq[7:] #seq[start:end]中的end可以省略。
print seq[-3:] #分片也支持负数。
print seq[:3] #seq[start:end]中的start也可以省略。
print seq[:] #全部省略会复制整个序列。
print seq[::2] #支持步长。
print seq[::-2] #支持负步长。
print seq[9:1:-1] #支持负步长。
print [1, 2, 3] + [4, 5, 6] # 序列支持相加，这解释了为啥字符串可以相加。
print [1, 2, 3] * 3 #序列支持相乘，这解释了为啥字符串可以相称。
print [None] * 10 #生成一个空序列。
print 1 in [1, 2, 3] #成员判断。

 可变的列表

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

data[0] = "a" #修改元素。
print data
data[0] = 0

del data[10] #删除元素。
print data

del data[8:] #分片删除。
print data

data[8:] = [8, 9, 10] #分片赋值
print data

不可变的元祖

print (1, 2) #元祖以小括号形式声明。
print (1,) #一个元素的元祖。

字符串格式化

print "% 10s" % "----"

print '''
%(title)s
%(body)s
''' % {"title": "标题", "body": "内容"}

字典

print {"title": "title", "body": "body"}
print dict(title = "title", body = "body")
print dict([("title", "title"), ("body", "body")])

dic = {"title": "title", "body": "body"};
print dic["title"]
del dic["title"]
print dic

print 语句

print 'a', 'b' #print可以接受多个参数，参数的输出之间以空格相隔。
print 'a', #如果逗号之后没有参数，则不会换行。
print 'b'

序列解包

x, y, z = 1, 2, 3
print x, y, z
(x, y, z) = (1, 2, 3)
print x, y, z
(x, y, z) = [1, 2, 3]
print x, y, z

bool值

#下面的输入全部返回False。
print(bool(None))
print(bool(()))
print(bool([]))
print(bool({}))
print(bool(""))
print(bool(0))

#虽然这些值在条件运算中会当做False，但是本身不等于False。
print(True and "")
print(not "")
print(False == "")
print(False == 0) #0除外，bool类型的内部表示就是int类型。

bool运算

print(0 < 1 < 10)
print(0 < 1 and 1 < 10)
print(not(0 > 1 > 10))
print(not(0 > 1 or 1 > 10))

语句块

if(10 > 1):
    print("10 > 1")
else:
    print("不可能发生")

三元运算符

print("10 > 1" if 10 > 1 else "不可能发生")

相等比较

#== 和 is的差别，==比较的是内容，is比较的是引用。
x = [1, 2, 3]
y = x
z = [1, 2, 3]
print(x == y)
print(x == z)
print(x is y)
print(x is z)

循环

#for循环类似C#的foreach，注意for后面是没有括号的，python真是能简洁就尽量简洁。
for x in range(1, 10):
    print(x)

for key in {"x":"xxx"}:
    print(key)

for key, value in {"x":"xxx"}.items():
    print(key, value)

for x, y, z in [["a", 1, "A"],["b", 2, "B"]]:
    print(x, y, z)

#带索引的遍历
for index, value in enumerate(range(0, 10)):
    print(index, value)

#好用的zip方法
for x, y in zip(range(1, 10), range(1, 10)):
    print(x, y)

#循环中的的else子句
from math import sqrt
for item in range(99, 1, -1):
    root = sqrt(item)
    if(root == int(root)):
        print(item)
        break
else:
    print("没有执行break语句。")

pass、exec和eval

#pass、exec、eval
if(1 == 1):
    pass

exec('print(x)', {"x": "abc"})
print(eval('x*2', {"x": 5}))

函数部分

形参和实参之间是按值传递的，当然有些类型的值是引用（对象、列表和字典等）。

# 基本函数定义。
def func():
    print("func")

func()

# 带返回值的函数。
def func_with_return():
    return ("func_with_return")

print(func_with_return())

# 带多个返回值的函数。
def func_with_muti_return():
    return ("func_with_muti_return", "func_with_muti_return")

print(func_with_muti_return())

# 位置参数
def func_with_parameters(x, y):
    print(x, y)

func_with_parameters(1, 2)

# 收集多余的位置参数
def func_with_collection_rest_parameters(x, y, *rest):
    print(x, y)
    print(rest)

func_with_collection_rest_parameters(1, 2, 3, 4, 5)

#命名参数
def func_with_named_parameters(x, y, z):
    print(x, y, z)

func_with_named_parameters(z = 1, y = 2, x = 3)

#默认值参数
def func_with_default_value_parameters(x, y, z = 3):
    print(x, y, z)

func_with_default_value_parameters(y = 2, x = 1)

#收集命名参数
def func_with_collection_rest_naned_parameters(*args, **named_agrs):
    print(args)
    print(named_agrs)

func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)

#集合扁平化
func_with_collection_rest_naned_parameters([1, 2, 3], {"x": 4, "y": 4, "z": 6}) #这会导致args[0]指向第一个实参，args[1]指向第二个实参。
func_with_collection_rest_naned_parameters(*[1, 2, 3], **{"x": 4, "y": 4, "z": 6}) #这里的执行相当于func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)。

作用域

# coding=utf-8

# 只有函数执行才会开启一个作用域。
if(2 > 1):
    x = 1

print(x) # 会输出1。


# 使用vars()函数可以访问当前作用域包含的变量。
x = 1
print(vars()["x"])

# 使用globals()函数可以访问全局作用域。
x = 1

def func():
    print(globals()["x"])

func()

# 使用locals()函数可以访问局部作用域。
def func():
    x = 2
    print(locals()["x"])

func()

# 每个函数定义时都会记住所在的作用域。
# 函数执行的时候会开启一个新的作用域，函数内变量访问的规则是：先访问当前作用域，如果没有就访问函数定义时的作用域，递归直到全局作用域。
x = 1

def func():
    y = 2
    print(x, y) # 输出1 2

func()


# 变量赋值始终访问的是当前作用域。
x = 1

def func():
    x = 2
    y = 2
    print(x, y) # 输出2 2

func()
print(x) #输出 1

# 局部变量会覆盖隐藏全局变量，想访问全局变量可以采用global关键字或globals()函数。
x = 1

def func():
    global x
    x = 2
    y = 2
    print(x, y) # 输出2 2

func()
print(x) #输出 2

# python支持闭包
def func(x):
    def inner_func(y):
        print(x + y)

    return inner_func

inner_func = func(10)
inner_func(1)
inner_func(2)

#函数作为对象
def func(fn, arg):
    fn(arg)

func(print, "hello")
func(lambda arg : print(arg), "hello")

模块

几个模块相关的规则：

• 一个文件代表一个模块。
•  可以用import module导入模块，也可以用form module import member导入模块的成员。
• 如果导入的是module，必须使用module.member进行访问；如果导入的member，可以直接访问member。
• 导入的module或member都会变成当前module的member。

b.py

# coding=utf-8

print __name__

def say_b():
    print "b"

a.py

# coding=utf-8

import b
from b import *

print __name__

def say_a():
    print "a"

test.py

# coding=utf-8

import a

print __name__

a.say_a();
a.say_b();
a.b.say_b()

输出

b
a
__main__
a
b
b

异常管理

# coding=utf-8

# 自定义异常
class HappyException(Exception):
    pass

# 引发和捕获异常
try:
    raise HappyException
except:
    print("HappyException")

try:
    raise HappyException()
except:
    print("HappyException")

# 捕获多种异常
try:
    raise HappyException
except (HappyException, TypeError):
    print("HappyException")

# 重新引发异常
try:
    try:
        raise HappyException
    except (HappyException, TypeError):
        raise
except:
    print("HappyException")

#访问异常实例
try:
    raise HappyException("都是我的错")
except (HappyException, TypeError), e:
    print(e)

#按类型捕获
try:
    raise HappyException
except HappyException:
    print("HappyException")
except TypeError:
    print("TypeError")

#全面捕获
try:
    raise HappyException
except:
    print("HappyException")

#没有异常的else
try:
    pass
except:
    print("HappyException")
else:
    print("没有异常")

#总会执行的final
try:
    pass
except:
    print("HappyException")
else:
    print("没有异常")
finally:
    print("总会执行")

操作MYSQL 数据库

需要导入MySQLdb模块

MySQL-python-1.2.3.win32-py2.7.exe 
MySQL-python-1.2.3.win-amd64-py2.7.exe

import MySQLdb 
try:
    conn=MySQLdb.connect(host='127.0.0.1',user='catxjd',passwd='catxjd',port=3306)
    cur=conn.cursor()
     
    cur.execute('create database if not exists python')
    conn.select_db('python')
    cur.execute('create table test(id int,info varchar(20))')
      
    value=[1,'hi rollen']
    cur.execute('insert into test values(%s,%s)',value)
      
    values=[]
    for i in range(20):
        values.append((i,'hi rollen'+str(i)))
          
    cur.executemany('insert into test values(%s,%s)',values)
  
    cur.execute('update test set info="I am rollen" where id=3')
 
    conn.commit()
    cur.close()
    conn.close()
 
except MySQLdb.Error,e:
     print "Mysql Error %d: %s" % (e.args[0], e.args[1])

实例 1、取得 MYSQL 的版本

# -*- coding: UTF-8 -*-
#安装 MYSQL DB for python
import MySQLdb as mdb
con = None
try:
  #连接 mysql 的方法： connect('ip','user','password','dbname')
  con = mdb.connect('localhost', 'root','root', 'test');
 
  #所有的查询，都在连接 con 的一个模块 cursor 上面运行的
  cur = con.cursor()
 
  #执行一个查询
  cur.execute("SELECT VERSION()")
  #取得上个查询的结果，是单个结果
 
  data = cur.fetchone()
  print "Database version : %s " % data
finally:
  if con:
    #无论如何，连接记得关闭
    con.close()

实例 2、创建一个表并且插入数据

import MySQLdb as mdb
import sys
 
#将 con 设定为全局连接
con = mdb.connect('localhost', 'root', 'root', 'test');
with con:
 
#获取连接的 cursor，只有获取了 cursor，我们才能进行各种操作
cur = con.cursor()
 
#创建一个数据表 writers(id,name)
cur.execute("CREATE TABLE IF NOT EXISTS \
Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))")
 
#以下插入了 5 条数据
cur.execute("INSERT INTO Writers(Name) VALUES('Jack London')")
cur.execute("INSERT INTO Writers(Name) VALUES('Honore de Balzac')")
cur.execute("INSERT INTO Writers(Name) VALUES('Lion Feuchtwanger')")
cur.execute("INSERT INTO Writers(Name) VALUES('Emile Zola')")
cur.execute("INSERT INTO Writers(Name) VALUES('Truman Capote')")

实例 3、 python 使用 slect 获取 mysql 的数据并遍历

import MySQLdb as mdb
import sys
 
#连接 mysql，获取连接的对象
con = mdb.connect('localhost', 'root', 'root', 'test');
with con:
 
#仍然是，第一步要获取连接的 cursor 对象，用于执行查询
cur = con.cursor()
 
#类似于其他语言的 query 函数， execute 是 python 中的执行查询函数
cur.execute("SELECT * FROM Writers")
 
#使用 fetchall 函数，将结果集（多维元组）存入 rows 里面
rows = cur.fetchall()
 
#依次遍历结果集，发现每个元素，就是表中的一条记录，用一个元组来显示
for row in rows:
print row

运行结果：

(1L, ‘Jack London')
(2L, ‘Honore de Balzac')
(3L, ‘Lion Feuchtwanger')
(4L, ‘Emile Zola')
(5L, ‘Truman Capote')
上面的代码，用来将所有的结果取出，不过打印的时候是每行一个元祖打印，现在我们使用方法，取出其中的单个数据：

import MySQLdb as mdb
import sys
 
#获取 mysql 的链接对象
con = mdb.connect('localhost', 'root', 'root', 'test');
with con:
#获取执行查询的对象
cur = con.cursor()
#执行那个查询，这里用的是 select 语句
cur.execute("SELECT * FROM Writers")
#使用 cur.rowcount 获取结果集的条数
numrows = int(cur.rowcount)
#循环 numrows 次，每次取出一行数据
for i in range(numrows):
#每次取出一行，放到 row 中，这是一个元组(id,name)
row = cur.fetchone()
#直接输出两个元素
print row[0], row[1]

运行结果：
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
4 Emile Zola
5 Truman Capote

实例 4、使用字典 cursor 取得结果集（可以使用表字段名字访问值）

import MySQLdb as mdb
import sys
#获得 mysql 查询的链接对象
con = mdb.connect('localhost', 'root', 'root', 'test')
with con:
#获取连接上的字典 cursor，注意获取的方法，
#每一个 cursor 其实都是 cursor 的子类
cur = con.cursor(mdb.cursors.DictCursor)
#执行语句不变
cur.execute("SELECT * FROM Writers")
#获取数据方法不变
rows = cur.fetchall()
#遍历数据也不变（比上一个更直接一点）
for row in rows:
#这里，可以使用键值对的方法，由键名字来获取数据
print "%s %s" % (row["Id"], row["Name"])

实例 5、获取单个表的字段名和信息的方法

import MySQLdb as mdb
import sys
#获取数据库的链接对象
con = mdb.connect('localhost', 'root', 'root', 'test')
with con:
#获取普通的查询 cursor
cur = con.cursor()
cur.execute("SELECT * FROM Writers")
rows = cur.fetchall()
#获取连接对象的描述信息
desc = cur.description
print 'cur.description:',desc
#打印表头，就是字段名字
print "%s %3s" % (desc[0][0], desc[1][0])
for row in rows:
#打印结果
print "%2s %3s" % row

运行结果：
cur.description: ((‘Id', 3, 1, 11, 11, 0, 0), (‘Name', 253, 17, 25, 25, 0, 1))
Id Name
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
4 Emile Zola
5 Truman Capote

实例 6、使用 Prepared statements 执行查询（更安全方便）

import MySQLdb as mdb
import sys
 
con = mdb.connect('localhost', 'root', 'root', 'test')
with con:
cur = con.cursor()
#我们看到，这里可以通过写一个可以组装的 sql 语句来进行
cur.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
("Guy de Maupasant", "4"))
#使用 cur.rowcount 获取影响了多少行
print "Number of rows updated: %d" % cur.rowcount

结果：
Number of rows updated: 1

实例 7、把图片用二进制存入 MYSQL

有人喜欢把图片存入 MYSQL（这种做法貌似很少吧），我看大部分的程序，图片都是存放在服务器上的文件，数据库中存的只是图片的地址而已，不过 MYSQL 是支持把图片存入数据库的，也相应的有一个专门的字段 BLOB (Binary Large Object)，即较大的二进制对象字段，请看如下程序，注意测试图片自己随便找一个，地址要正确： 
首先，在数据库中创建一个表，用于存放图片：

CREATE TABLE Images(Id INT PRIMARY KEY AUTO_INCREMENT, Data MEDIUMBLOB);

然后运行如下 PYTHON 代码进行：

import MySQLdb as mdb
import sys
 
try:
#用读文件模式打开图片
fin = open("../web.jpg")
#将文本读入 img 对象中
img = fin.read()
#关闭文件
fin.close()
except IOError, e:
#如果出错，打印错误信息
print "Error %d: %s" % (e.args[0],e.args[1])
sys.exit(1)
try:
#链接 mysql，获取对象
conn = mdb.connect(host='localhost',user='root',passwd='root',
db='test')
#获取执行 cursor
cursor = conn.cursor()
#直接将数据作为字符串，插入数据库
cursor.execute("INSERT INTO Images SET Data='%s'" %
mdb.escape_string(img))
#提交数据
conn.commit()
#提交之后，再关闭 cursor 和链接
cursor.close()
conn.close()
except mdb.Error, e:
#若出现异常，打印信息
print "Error %d: %s" % (e.args[0],e.args[1])
sys.exit(1)

实例 8、从数据库中把图片读出来

import MySQLdb as mdb
import sys
 
try:
#连接 mysql，获取连接的对象
conn = mdb.connect('localhost', 'root', 'root', 'test');
cursor = conn.cursor()
#执行查询该图片字段的 SQL
cursor.execute("SELECT Data FROM Images LIMIT 1")
#使用二进制写文件的方法，打开一个图片文件，若不存在则自动创建
fout = open('image.png','wb')
#直接将数据如文件
fout.write(cursor.fetchone()[0])
#关闭写入的文件
fout.close()
#释放查询数据的资源
cursor.close()
conn.close()
except IOError, e:
#捕获 IO 的异常 ，主要是文件写入会发生错误
print "Error %d: %s" % (e.args[0],e.args[1])
sys.exit(1)

实例 9、使用 Transaction 即事务（手动提交，自动回滚）

import MySQLdb as mdb
import sys
 
try:
#连接 mysql，获取连接的对象
conn = mdb.connect('localhost', 'root', 'root', 'test');
cursor = conn.cursor()
#如果某个数据库支持事务，会自动开启
#这里用的是 MYSQL，所以会自动开启事务（若是 MYISM 引擎则不会）
cursor.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
("Leo Tolstoy", "1"))
cursor.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
("Boris Pasternak", "2"))
cursor.execute("UPDATE Writer SET Name = %s WHERE Id = %s",
("Leonid Leonov", "3"))
#事务的特性 1、原子性的手动提交
conn.commit()
cursor.close()
conn.close()
except mdb.Error, e:
#如果出现了错误，那么可以回滚，就是上面的三条语句要么执行，要么都不执行
conn.rollback()
print "Error %d: %s" % (e.args[0],e.args[1])