一、《Python编程》的第一章综述
主要从数据（记录）的表示出发，讲述数据（记录）存储（内存、pickle、shelves），包括：格式化、持久化、图形化（GUI，tkinter）、控制台交互、OOP；最后还从Web界面引出CGI基础；
二、表示数据（记录）
1.List来表示数据记录（字符串基础）
#定义一个列表
bob = ['Bob Smith',42,30000,'software']
sue = ['Sue Jones',45,40000,'hardware']
#获取姓名、薪水
print(bob[0],sue[2])
#获取姓，split()分割，不传参数及是以空格分割；举例：bob[0].split("b")---->结果：['Bo',' Smith']，注意空格在第二个元素中；
print(bob[0].split())#结果：['Bob', 'Smith']
print(bob[0].split()[-1])
#给sue加薪25%
sue[2] *=1.25
print(sue)#['Sue Jones', 45, 50000.0, 'hardware']
#-----------------------------------------------------------------------------------------------------------
#创建一个新列表的将bob与sue存储在一起；
people = [bob, sue]
for person in people:
print(person)
#使用索引层层取值
print(people[1][0])
#打印姓氏，每个人涨工资25%
for person in people:
print(person[0].split()[0])
person[2] *=1.25
#检测薪资：
for person in people:print(person[2])
#收集薪资^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#列表解析：
pays =[ person[2] for person in people ]
print(pays)
#map:map(function, iterable, ...)；function -- 函数;iterable -- 一个或多个序列;
pays =map((lambda x: x[2]), people)#返回迭代器对象<map object at 0x007BB2E0>
print(list(pays))
#生成器表达式，sum为内建函数
#sum(__iterable)
print(sum(person[2] for person in people))
#为people列表中添加元素
people.append(['Tom',50,0,None])
print(len(people),people[-1][0],sep=",")2.Field标签
#使用关键字=索引号，将列表中的字段关联
NAME,AGE,PAY = range(3)
bob = ['Bob Smith',42,30000]
print(bob[NAME])
#但是上面的也不是长久之计，数据变了，这个字段名称就得维护；下面提供更优de方式：
bob = [['name','Bob Smith'],['age',42],['pay',10000]]
sue = [['name','Sue Jones'],['age',29],['pay',20000]]
people = [bob, sue]
#上面也没有从根本上解决问题，还是要通过索引来取值；只是知道其字段意思；
for person in people:
print(person[0][1],person[2][1],sep=":")#name:pay
#更优de方式，使用元组赋值来拆开名/值对：
for person in people:
for (name,value) in person :
if name =='name':print(value)#寻找特定字段，这里举例name；还可以age、pay
#将上面得元组赋值拆分名/值对de方式封装成函数：
def field(record,label):
for(fname,fvalue) in record:
if fname == label:
msg =label+":"+str(fvalue)
return msg
for person in people:
print(field(person,"age"))3.dict来表示数据记录
#使用字典:
bob = {'name':'Bob Smith', 'age':42, 'pay':30000, 'job': 'dev'}
sue = {'name':'Sue Jnoes', 'age':56, 'pay':50000, 'job': 'pre'}
print(bob['name'])
#其他建立字典的方法:dict(key=value,……)
bob = dict(name='Bob Smith',age=42,pay=30000,job='dev')
sue = dict(name='Sue Jnoes',age=35,pay=35000,job='pre')
print(bob)
print(sue)
#一次一个字段填写字典；
sue={}
sue['name']='Sue Jones'
sue['age']=45
sue['pay']=5600
sue['job']='pre'
print(sue)
#使用zip函数将key/value列表链在一起：
names=['name','age','pay','job']
values=['Sue Jones',45,56000,'pre']
sue=dict(zip(names,values))#{'name': 'Sue Jones', 'age': 45, 'pay': 56000, 'job': 'pre'}
print(list(zip(names,values)))#[('name', 'Sue Jones'), ('age', 45), ('pay', 56000), ('job', 'pre')]
print(sue)
#使用dict的fromkeys来初始化所有key的value，只不过这些value都是一个值（可用于初始化字典）：
data_keys=('name','age','job','pay')
record = dict.fromkeys(data_keys,'?')
print(record)#{'name': '?', 'age': '?', 'job': '?', 'pay': '?'}
#88888888888888888888888888888888888888888888888888888888888888888888888888888888
#同样列表与字典结合；
bob = {'name':'Bob Smith', 'age':42, 'pay':30000, 'job': 'dev'}
sue = {'name':'Sue Jnoes', 'age':56, 'pay':50000, 'job': 'pre'}
people = [bob,sue]
for person in people:
print(person['name'],person['age'],person['pay'],sep=":")
#列表解析
names=[person['name'] for person in people]
print(names)
#map
print(list(map((lambda x:x['name']),people)))
#sum
print(sum(person['pay'] for person in people))
#奇妙的是：列表解析和按需生成器表达式，可以达到sql的效果：
thing = [rec['name'] for rec in people if rec['age'] >=45]
print(thing)#['Sue Jnoes']
thing1=[(rec['pay']**2 if rec['age']>45 else rec['pay']) for rec in people]
print(thing1)
#字典在python中是常见的对象，使用一般的方式更新、访问：
for person in people:
print(person['name'].split()[0])
person['pay'] *=1.25
t=[person['pay'] for person in people]
print(t)
###################################################################################
#嵌套结构
bob2={
'name':{'first':'Bob','last':'Smith'},
'age':42,
'job':['software','writing'],
'pay':(40000,50000)
}
#上面的通过索引两层就可访问数据；
#全部的工作：
for job in bob2['job']:print(job)
bob2['job'].append('tester')#添加新工作
print(bob2)
#################################################################################
#字典的字典
bob = dict(name='Bob Smith',age=42,pay=30000,job='dev')
sue = dict(name='Sue Jnoes',age=35,pay=35000,job='pre')
db = {}
db["bob"] = bob
db["sue"] = sue
print(db)#{'bob': {'name': 'Bob Smith', 'age': 42, 'pay': 30000, 'job': 'dev'}, 'sue': {'name': 'Sue Jnoes', 'age': 35, 'pay': 35000, 'job': 'pre'}}
import pprint
pprint.pprint(db)#打印出更易于清晰的格式
#{'bob': {'age': 42, 'job': 'dev', 'name': 'Bob Smith', 'pay': 30000},
# 'sue': {'age': 35, 'job': 'pre', 'name': 'Sue Jnoes', 'pay': 35000}}
#访问字典的字典：
for key in db:
print(key,'=>',db[key]['name'])
#要么使用迭代字典的值集合来直接访问：
for record in db.values():print(record)
#使用迭代字典的值集合来直接访问记录：
x=[db[key]['name'] for key in db]
print(x)
#遇上等效：
x=[rec['name'] for rec in db.values()]
print(x)
#类似sql的查询：
tt=[rec['name'] for rec in db.values() if rec['age'] >=5]
print(tt)目前为止，上面所见到的对象都是暂时的；他们只是保存在内存当中；并会随着我们退出python或者创建他们的python程序而烟消云散；为了使其永久化，它们需要保存在某种类型的文件中；
三、持久化存储数据（记录）
1.使用格式化文件
在程序运行时保存数据的一种方法---》是把所有数据以格式化的方式写入一个简单的文本文件中，要用时，在取出来重构class WSave:
def __init__(self,db,dbfilename = 'people-file'):
self.db = db
self.dbfilename = dbfilename
self.ENDDB = 'enddb'
self.ENDREC = 'endrec'
self.RECSEP = '=>'
def storeDB(self):
'''
将数据库格式化保存为普通文件
:return:
'''
with open(self.dbfilename,'w') as dbfile:
for key in self.db:
print(key,file=dbfile)
for (key,value) in self.db[key].items():
#下面的方式==等效于==》》print(key+"=>"+repr(value),file=dbfile)
dbfile.write(key+"=>"+repr(value)+"\n")#repr() 函数将对象转化为供解释器读取的形式
# print(key + self.RECSEP + repr(value), file=dbfile)
print(self.ENDREC, file=dbfile)
print(self.ENDDB, file=dbfile)
def loadDbase(self):
'''
将文件中的数据解析，重构db
:return:
'''
dbfile = open(self.dbfilename)
import sys
sys.stdin = dbfile#sys.stdin:标准输入
db = {}
key = input()
while key != self.ENDDB:
rec = {}
field = input()
while field !=self.ENDREC:
name, value = field.split(self.RECSEP)
rec[name] = eval(value)#函数用来执行一个字符串表达式，并返回表达式的值:eval( '3 * 7' ),21
field = input()
db[key] = rec
key = input()
return db
if __name__ == '__main__':
from initdata import db
# dbpath=r'D:\pythonProject\project_hack\testDB'
writeDB = WSave(db)
# writeDB.storeDB()
db=writeDB.loadDbase()
import pprint
pprint.pprint(db)
for key in db:
print(key,"=>\n",db[key])
print(db['sue']['name'])2.使用pickle文件
#pickle包的初衷：可以将任意类型的python数据转化成可以保存在文件中的格式
#pickle模块将内存中的python对象转化成序列化的字节流；这是一种可以写入任何类似文件对象的字节串；；；
# pickle模块也可以根据序列化的字节流重新构建原来内存中的对象：转换成原来的对象；
# pickle模块取代了专有的数据格式；pickle感觉像XML的表达方式；但是，它是Python专用的方式并且比较容易编写代码
from initdata import db#最初创建的数据
import pickle
dbfile = open('people-file', 'wb')#二进制写
#已字节流写入文件，而非字符串
pickle.dump(db,dbfile)
dbfile.close()
dbfile1 = open('people-file', 'rb')#二进制读
#字节流重新构建原来内存中的对象
db=pickle.load(dbfile1)
dbfile1.close()
import pprint
pprint.pprint(db)
#上面的例子都有一个缺陷，每更新一条记录，就需要读出和重新写入整个数据库；
# 我们可以通过一条记录到一个普通文件的方式来改进；
from initdata import bob,sue,tom #最初创建的数据
import pickle
#每个文件一个名称记录一条数据；
for (key, record) in [('bob',bob),('tom',tom),('sue',sue)]:
recfile = open(key+'.pkl','wb')
pickle.dump(record,recfile)
recfile.close()
import glob#glob该方法返回所有匹配的文件路径列表
for filename in glob.glob('*.pkl'):
recfile = open(filename,'rb')
record = pickle.load(recfile)
print(filename,'=>\n',record)
#修改一条记录后，在写入
dbfile = open('sue.pkl','rb')
v = pickle.load(dbfile)
v['pay'] *= 1.10
dbfile.close()
new_dbf= open('sue.pkl','wb')
pickle.dump(v,new_dbf)
new_dbf.close()3.使用shelves
#更高级的库：shelves;用键来访问记录；shelve系统自动分隔存储记录，并且只获取和更新访问和修改的记录；
# shelve使用起来很像一堆只存储一条记录的pickle 文件；但更容易编辑；
from initdata import bob,sue
import shelve
db = shelve.open('people-shelve')
db['bob'] = bob
db['sue'] = sue
db.close()
#执行上面的代码后，出现了people-shelve.bak；people-shelve.dat;people-shelve.dir目录；
# 千万不要删除（它们就是你的数据库）
#shelve就像一个持久化的字典。
db = shelve.open('people-shelve')
for key in db:
print(key,'=>\n',db[key])
db.close()
#修改（在内存中修改，在重新对键进行赋值来更新shelve）、添加；
db = shelve.open('people-shelve')
sue = db['sue']
sue['pay'] *=1.50#内存中修改后
db['sue'] = sue#重新对键进行赋值
from initdata import tom
db['tom'] = tom#添加新记录
db.close()四、走进OOP
#OOP：python一切皆对象；这是一种程序设计的思路：Structure(结构)、Encapsulation(封装)、Customiztion(定制)
#Structure(结构)：类既提供了程序单元将逻辑与数据合并在单独的包中，又提供了一个层级结构；使得代码更容易组织从而防止代码冗余；
# Encapsulation(封装)：我们可以自由的更改方法的实现而不会破坏调用者的代码；
# Customiztion(定制)：通过编写新的子类就可以扩展和定制类，同时不会更改或破坏已工作的代码；
1.类表示数据
#1.类记录数据---》对象的属性取代了字典的key;
class Person:
def __init__(self,name,age,pay = 0, job = None):
self.name = name
self.age = age
self.pay = pay
self.job = job
if __name__ == '__main__':
bob = Person('Bob Smith',42,30000,'software')
sue = Person('Sue Jones',45,40000,'harware')
print(bob.name,sue.pay)2.类添加行为与继承
#2.类添加行为（函数）---》数据与行为的结合，函数（或者说方法）提供了解释和更新数据的逻辑（称之为面向对象，因为它们总是处理对象的数据/属性）
class Person:
def __init__(self,name,age,pay=0,job=None):
self.name=name
self.age=age
self.pay=pay
self.job=job
def lastName(self):
return self.name.split()[-1]
def giveRaise(self,percent):
self.pay *= (1.0+percent)
0000000000000000000000000000000000000000000000000000000000000
#3.类的继承--》继承后子类包含了父类所有的属性、和函数；子类可以重新覆盖父类中的函数
class Manager(Person):
def giveRaise(self,percent,bonus= 0.1):
self.pay *=(1.0+bonus+percent)3.类格式化显示、增强方法
#4.格式化显示：当对象需要整体的打印输出时，该方法可以返回对象的格式化字符串
class Person:
def __init__(self, name, age, pay=0, job=None):
self.name = name
self.age = age
self.pay = pay
self.job = job
def lastName(self):
return self.name.split()[-1]
def giveRaise(self, percent):
self.pay *= (1.0 + percent)
#格式化显示：当对象需要整体的打印输出时，该方法可以返回对象的格式化字符串；
def __str__(self):
return "<%s ==> %s>" % (self.__class__.__name__, [self.name, self.age, self.pay, self.job])
#增强方法：和上面重写函数相比，这种方式不但可以降低代码冗余，而且实践中尤其利于启动父类的构造函数
class Manager1(Person):
def giveRaise(self,percent,bonus= 0.1):
Person.giveRaise(self,percent+bonus)
tom = Manager1('Tom iThing',25,150000)
print(tom)#<Manager1 ==> ['Tom iThing', 25, 150000, None]>4.自定义构造函数
#5.#自定义构造函数
class Person:
def __init__(self, name, age, pay=0, job=None):
self.name = name
self.age = age
self.pay = pay
self.job = job
def lastName(self):
return self.name.split()[-1]
def giveRaise(self, percent):
self.pay *= (1.0 + percent)
def __str__(self):
return "<%s ==> %s>" % (self.__class__.__name__, [self.name, self.age, self.pay, self.job])
class Manger(Person):
# 自定义构造函数
def __init__(self, name, age, pay):
Person.__init__(self, name, age, pay,'manager')#这里使用的技巧就是明确调用父类的构造函数，job直接写死manager;
def giveRaise(self,percent,bonus=0.1):
Person.giveRaise(self,percent+bonus)
#下面看多态：
bob = Person('Bob Smith', 44)
sue = Person('Sue Joner',23,12000,'hardware')
tom = Manger('iThing Tom',29,150000)
for obj in (bob,sue,tom):
obj.giveRaise(.10)
print(obj)
#上面运行的结果是：
# <Person ==> ['Bob Smith', 44, 0.0, None]>
# <Person ==> ['Sue Joner', 23, 13200.000000000002, 'hardware']>
# <Manger ==> ['iThing Tom', 29, 180000.0, 'manager']>5.对类增加shelves持久化
#6#增添持久化
#为了更明了，我将上面的两个class分别写在两个py文件中
from Person import Person
from Manager import Manager
import shelve
bob = Person('Bob Smith', 44)
sue = Person('Sue Joner',23,12000,'hardware')
tom = Manager('iThing Tom',29,1500000)
db = shelve.open('class-shelve')
db['bob'] = bob
db['sue'] = sue
db['tom'] = tom
db.close()
#上面将对象存储在了shelve数据库中；下面取出来，看看可以使用对象的函数不？
db0 = shelve.open('class-shelve')
for person in db0:
print(db0[person])
bob=db0['bob']
print(bob.lastName())
tom=db0['tom']
tom.giveRaise(.20)
db0['tom']=tom
db0.close()
print(tom)五、控制台交互
#shelve的控制台界面
import shelve
fieldnames = ('name','age','job','pay')
maxfield = max(len(f) for f in fieldnames)
db = shelve.open('class-shelve')
while True:
key = input('\nKey? => ')
if not key:break
try:
record = db[key]
except:
print('没有找到对应的数据记录')
else:
for field in fieldnames:
print(field.ljust(maxfield),'=>',getattr(record,field))
六、GUI---->tkinter
tkinter包含超过20多种控件，多种获取用户的输入的方式，多行文本、画布、下拉菜单、单选和复选、滚动条等访问寻求更多：https://www.runoob.com/python/python-gui-tkinter.html
#Tk()：创建应用程序主窗口
#Frame()：创建控件容器，可依附在窗口中
#TopLevel()：创建弹出式窗口
#获取用户的输入：
from tkinter import *
from tkinter.messagebox import showinfo
def reply(msg):
showinfo(title='Reply',message='Hello %s' % msg)
top = Tk()
top.title('Echo')#改变窗口title
top.iconbitmap('expand.ico')#改变图标
Label(top,text='Enter your name:').pack(side=TOP)
#使用Entry控件获取用户输入并在弹出对话框中加以显示
ent = Entry(top)
ent.pack(side=TOP)
#这里使用lambda来延迟对reply函数的调用；使输入数据得以传入，这是tkinter常用的编程模式；
# 如果不使用lamdba,reply方法在按钮创建时就会被调用，而不是等到按钮单击时；
btn = Button(top,text='Submit',command=(lambda :reply(ent.get())))
btn.pack(side=LEFT)
top.mainloop()from tkinter import *
from tkinter.messagebox import showerror
import shelve
shelvename = 'class-shelve'
fieldnames = ('name','age','job','pay')
def makeWidgets():
global entries
window =Tk()
window.title('People Shelve')
form = Frame(window)
form.pack()
entries = {}
for (ix,label) in enumerate(('key',)+fieldnames):
lab = Label(form,text=label)
ent = Entry(form)
lab.grid(row=ix,column=0)#网格
ent.grid(row=ix,column=1)
entries[label] = ent
Button(window, text="Fetch",command=fetchRecord).pack(side=LEFT)
Button(window,text="Update",command=updateRecord).pack(side=LEFT)
Button(window,text="Quit",command=window.quit).pack(side=RIGHT)
return window
def fetchRecord():
key = entries['key'].get()
try:
record = db[key]#使用键获取数据，并在GUI中展示
except:
showerror(title='Error',message='No such key!')
else:
for field in fieldnames:
entries[field].delete(0,END)
entries[field].insert(0,repr(getattr(record,field)))
def updateRecord():
key = entries['key'].get()
if key in db:
record = db[key]
else:
from Person import Person
record = Person(name="?",age="?")
for field in fieldnames:
setattr(record,field,eval(entries[field].get()))
db[key] = record
if __name__ == '__main__':
import shelve
db =shelve.open(shelvename)
window = makeWidgets()
window.mainloop()
db.close()from tkinter import *
import random
fontsize = 30
colors = ['red','green','blue','yellow','orange','cyan','purple']
def onSpam():
popup = Toplevel()
color = random.choice(colors)
Label(popup,text='Popup',bg='black',fg=color).pack(fill=BOTH)
mainLabel.config(fg=color,bg=random.choice(colors))
def onFlip():
mainLabel.config(fg=random.choice(colors))
main.after(250, onFlip)
def onGrow():
global fontsize
fontsize +=2
mainLabel.config(font=('arial',fontsize,'italic'))
main.after(100,onGrow)
main = Tk()
mainLabel = Label(main,text='Fun Gui!',relief=RAISED)
mainLabel.config(font=('arial',fontsize,'italic'),fg='cyan',bg='navy')
mainLabel.pack(side=TOP,expand=YES,fill=BOTH)
Button(main,text='spam',command=onSpam).pack(fill=X)
Button(main,text='flip',command=onFlip).pack(fill=X)
Button(main,text='grow',command=onGrow).pack(fill=X)
Button(main,text='关闭',command=main.quit).pack(fill=X)
main.mainloop()
七、CGI基础
浏览器--服务器--后端逻辑；
特别注意：目录结构
1.服务器的简单代码
#-*-coding:utf-8-*-
import os,sys
from http.server import HTTPServer,CGIHTTPRequestHandler
webdir = "."#存放HTML和cgi脚本文件夹的所在
port = 80
os.chdir(webdir)#在HTML根目录中运行
srvraddr =('',port)#我的主机和端口
srvrobj = HTTPServer(srvraddr,CGIHTTPRequestHandler)
srvrobj.serve_forever()#永久守护进程运行2.html代码
运行：
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
