本文共 13669 字，大约阅读时间需要 45 分钟。

转自：https://piao.blog.ustc.edu.cn/?p=164

• 函数
  • 常规参数，如果给某个函数指定了默认函数值，则那些没有默认值的参数就必须放在最前面：例如
    • def total(values,start=0,end=None):
      • if end is None:
        • end=len(values)
      • result=0
      • for i in range(start,end):
        • result+=values[i]
      • return result
  • 可变参数列表,使用指针：例如
    • def our_max(*values):
      • if not values:
        • return None
      • m=values[0]
      • for v in values[1:]:
        • if v>m:
          • m=v
      • return m
    • >>>our_max(3,2,3,6)
  • Python不允许单个函数中出现两个或者两个以上的星号参数；也不允许常规参数被定义在星号参数之后：例如
    • def append_all(old,*new):
      • for n in new:
        • old.append(n)
      • return old
    • >>>values=[]
    • >>>append_all(values,1,2,3)
    • 得到结果为
    • [1,2,3]
  • 命名参数——只需将参数名及其值成对传入，而不需要按照特定顺序将参数传入；例如：
    • def describe_creature(name,species,age,weight):
      • return ……
    • >>>print describe_creature(weight=70,species=’Homo sapiens’,age=24,name=’Charles Darwin’)
• 异常
  • try和except——如果没有发生错误，则Python就会执行完try块中的代码，并完全跳过except块；如果try中出现错误，则python会立即跳转到except块（异常处理器）的开始并执行其中的代码，这样异常就捕获到了。例如：
    • def invert(x):
      • try:
        • i=1.0/x
      • except:
        • print (‘caught exception for ‘,x)
      • else:#习惯性用法：让别人在阅读代码时能够清楚地知道这些代码应该在try块顺利完成之后执行
        • print(‘reciprocal of ‘,x,’is’,i)
  • 异常对象——python会维护一个异常处理栈，有NameError,SyntaxError:Python（编辑器语法错误）,IndexError（超出索引）,KeyError（请求一个不存在的字典索引）,IOError,ArithmeticError（尝试访问未知的属性）,ZeroDivisionError,ValueError（传给函数的参数类型不正确）等；例如
    • def first:
      • ……
    • def second:
      • ……
    • if __name__==’__main__':
      • try:
        • first()
        • second()
      • except Exception as e: #Python3.0使用，以前是except Exception,e:
        • print(‘Error occured’,e)
  • 术语：
    • 功能测试：检查系统整体的行为
    • 单元测试：仅检查程序中的某个独立的组成部分
    • 黑盒测试：仅考虑代码的输入和输出
    • 玻璃盒测试：可以深入了解程序的内部构造
    • 回归测试：在对代码做出修改后重新进行测试，保证这些修改不会破坏其原有的正确行为；只有当测试工作是自动化的，且程序的行为很少被修改时，回归测试才具备可行性
    • 一般测试：
      • 边界情况：比如空列表，仅含有一个元素的列表
      • 最简有效情况：比如对含有两个元素的列表排序（一个已知，一个未知）
      • 正常情况：比如对一个较长一点的列表排序
      • 错误分类表：
        • 数字方面：0，最大和最小的合法数字，比最大和最小小1或大1的数字
        • 数据结构方面：空的，仅含一个元素的，含有最大合法数量的元素，含有重复元素的，含有别名的
        • 搜索方面：找不到匹配项，找到一个匹配项，找到多个匹配项，所有内容均匹配
    • 模式：
      • 固定值：一般大写
      • 计步器和计数器
      • 最符合值存储器：依次检查每一个值，并将当前看到的最符合要求的值的引用保存起来；例如：
        • def largest_below_threshold(values,threshold):
          • result=None
          • for v in values:
            • if v<threshole:
              • result=v
              • break
          • if resule is None:
            • return None
          • for v in values:
            • if result<v<threshold:
              • result=v
          • return result
      • 最近值存储器：保存在一个值序列中刚刚看到的那个值，例如
        • while True:
          • input=input(‘Enter a number:’)
          • try:
            • val=int(input)
          • except ValueError:
            • print(‘I said, a *number*’)
          • if val==7:
            • print(‘You guessed it!’)
            • break
          • else:
            • print(‘Try again!’)
      • 临时变量
      • 单项标志：指示事情已经发生的变量，其值只改变一次；例如
        • def after_date(input_file,date):
          • keep_it=False
          • result=[]
          • for line in input_file:
            • if keep_it:
              • result.append(line)
            • elif get_date(line)>=date:
              • keep_it=True
          • return result

• • 例如Color类：
    • class Color(object):
      • ”’An RGB color, with red, green and blue components.”’
      • pass
    • class表示定义了一个新类，object表示类Color是一种对象；pass说明该对象是空白的
  • 定义方法：
    • class Color(object):
      • ”’An RGB color, with red, green and blue components.”’
      • def lightness(self):
        • strongest=max(self.red,self.green,self.blue)
        • weakest=min(self.red,self.green,self.blue)
        • return 0.5*(strongest+weakest)/255
  • 构造函数__init__
    • class Color(object):
      • ”’An RGB color, with red, green and blue components.”’
      • def __init__(self,r,g,b):
        • self.red=r
        • self.green=g
        • self.blue=b
  • 析构函数__del__
    • class Color(object):
      • ”’An RGB color, with red, green and blue components.”’
      • name=’uname’ #成员变量
      • def __init__(self,r,g,b): #r,g,b为需要初始化的变量
        • self.red=r
        • self.green=g
        • self.blue=b
      • def __del__(self):
        • pass #空操作
  • __str__——当对类使用print时，就会调用该方法；例如print(purple)
  • __add__——当对对象做加法
  • __sub__——当对对象做减法
  • __eq__——当对对象做“==”比较时
• dir()——列出模块定义的标识符（函数、类、变量）
• help()
• OO的一点理论知识
  • 封装——
  • 多态——某个含有变量的表达式可以根据该变量所引用的对象的实际类型得到不同的结果
  • 继承——子类继承父类的实例变量跟方法；只要在子类的某一个函数被重写，则在该类外部就无法调用到其父类版本了；

•     tkinter模块：
  • 引入：from tkinter import * /   import tkinter as tk
  • 创建一个跟窗口：window=Tk()
  • 插件
    • Button——按钮
    • Canvas——绘制或者显示图像的区域（画布）
    • Checkbutton——复选框
    • Entry——单行文本框（编辑框）
    • Frame——承载其他小插件的容器(组织插件)
    • Label——显示文本的单行（静态文本）
    • Listbox——下拉列表框
    • Menu——下拉菜单
    • Message——显示文本的多个行
    • Menubutton——下拉菜单的菜单项
    • Text——课可供用户输入的多行文本框
    • TopLevel——额外窗口
  • 构建简单的GUI：
    • from tkinter import *  #python 3.0是小写的t；以前的是Tkinter
    • window=Tk()
    • label=Label(window,text=”This is our label.”)
    • label.pack() #将插件置入父插件中，并根据实际情况改变大小
    • window.mainloop()  #这样才能在Wing IDE中显示出GUI窗口
  • tkinter中的可变类型
    • 不可变类型	说明
      int	IntVar
      string	StringVar
      bool	BooleanVar
      double	DoubleVar

    • 可变类型的值可以通过get和set方法设置和获取；例如
      • from tkinter import *  #python 3.0是小写的t；以前的是Tkinter
      • window=Tk()
      • data=StringVar()
      • data.set(“Data to display”)
      • label=Label(window,textvariable=data)
      • label.pack() #将插件置入父插件中，并根据实际情况改变大小
      • window.mainloop()  #这样才能在Wing IDE中显示出GUI窗口
  • Frame
    • from tkinter import *  #python 3.0是小写的t；以前的是Tkinter
    • window=Tk()
    • frame=Frame(window)
    • frame.pack()
    • frame2=Frame(window,borderwidth=4,relief=GROOVE) #relief设置边框的样式
    • frame2.pack()
    • first=Label(frame,text=”first label.”)
    • first.pack() #将插件置入父插件中，并根据实际情况改变大小
    • second=Label(frame2,text=”second label.”)
    • second.pack() #将插件置入父插件中，并根据实际情况改变大小
    • third=Label(frame2,text=”third label.”)
    • third.pack() #将插件置入父插件中，并根据实际情况改变大小
    • window.mainloop()  #这样才能在Wing IDE中显示出GUI窗口
  • Entry
    • #关联Entry和Label
    • 
    • from tkinter import *
    • window=Tk()
    • frame=Frame(window)
    • frame.pack()
    • var=StringVar()
    • label=Label(frame,textvariable=var)
    • label.pack()
    • entry=Entry(frame,textvariable=var)
    • entry.pack()
    • window.mainloop()
  • Text（多行文本:嵌入图像、置入标记、选中特定行）
    • 
    • from tkinter import *
    • def cross(text):
      • text.insert(INSERT,’X’)
    • window=Tk()
    • frame=Frame(window)
    • frame.pack()
    • text=Text(frame,height=3,width=10)
    • text.pack()
    • button=Button(frame,text=”Add”,command=lambda:cross(text))
    • button.pack()
    • window.mainloop()
  • checkbutton（复选框）：一般用VarInt跟踪用户的选择
    • 
    • from tkinter import *
    • window=Tk()
    • frame=Frame(window)
    • frame.pack()
    • red=IntVar()
    • green=IntVar()
    • blue=IntVar()
    • for (name,var) in ((‘R’,red),(‘G’,green),(‘B’,blue)):
      • check=Checkbutton(frame,text=name,variable=var)
      • check.pack(side=’left’)
    • def recolor(widget,r,g,b):
      • color=’#’
      • for var in (r,g,b):
        • if var.get():
          • color+=’FF’
        • else:
          • color+=’00’
      • widget.config(bg=color)
    • label=Label(frame,text='[   ]’)
    • button=Button(frame,text=’update’,command=lambda:recolor(label,red,green,blue))
    • button.pack(side=’left’)
    • label.pack(side=’left’)
    • window.mainloop()
  • menu
    • 
    • from tkinter import *
    • import tkinter.filedialog as dialog #python 3，以前用import tkFileDialog as dialog
    • def save(root,text):
      • data=text.get(‘0.0′,END)
      • filename=dialog.asksaveasfilename(parent=root,filetypes=[(‘Text’,’*.txt’)],title=’Save as……’)
      • writer=open(filename,’w’)
      • writer.write(data)
      • writer.close()
    • def quit(root):
      • root.destroy()
    • window=Tk()
    • text=Text(window)
    • text.pack()
    • menubar=Menu(window)
    • filemenu=Menu(menubar)
    • filemenu.add_command(label=’Save’,command=lambda:save(window,text))  #子菜单
    • filemenu.add_command(label=’Quit’,command=lambda:quit(window))
    • menubar.add_cascade(label=’File’,menu=filemenu)  #母菜单
    • window.config(menu=menubar)
    • window.mainloop()
  • 面向对象的GUI
    • 
    • from tkinter import *
    • class Counter:
      • def __init__(self,parent):
        • self.parent=parent
        • self.frame=Frame(parent)
        • self.frame.pack()
        • self.state=IntVar()
        • sefl.state.set(1)
        • self.label=Label(self.frame,textvariable=self.state)
        • self.label.pack()
        • self.up=Button(self.frame,text=’up’,command=self.upClick)
        • self.up.pack(side=’left’)
        • self.right=Button(self.frame,text=’exit’,command=self.quitClick)
        • self.right.pack(side=’left’)
      • def upClick(self):
        • self.state.set(self.state.get()+1)
      • def quitClick(self):
        • self.parent.destroy()
    • if __name__==’__main__':
      • window=Tk()
      • myapp=Counter(window)
      • window.mainloop()
• 模型（Model）、视图（View）、控制器（Controller）
  • 模型：存储数据
  • 视图：显示
  • 控制器：响应（tkinter要求控制器函数不能还有参数）
  • 实例：
    • 
    • from tkinter import *
    • if __name__==’__main__':
      • window=Tk()
      • #The model
      • counter=IntVar()
      • counter.set(0)
      • #The controller
      • def click_up():
        • counter.set(counter.get()+1)  #counter为全局变量
      • def click_down():
        • counter.set(counter.get()-1)  #counter为全局变量
      • #The view
      • frame=Frame(window)
      • frame.pack()
      • button=Button(frame,text=”Up”,command=click_up)
      • button.pack()
      • button=Button(frame,text=”Down”,command=click_down)
      • button.pack()
      • label=Label(frame,textvariable=counter)
      • label.pack()
      • window.mainloop()
  • 使用Lambda:能够在任何地方创建一个没有名字的单行函数
    • ；第一行中的表达式lambda:3创建了一个匿名函数，该函数的功能就是返回3；第二个表达式创建并立即执行了同样的函数；
    • lambda函数可以有参数：
    • 例如：
      • 
      • from tkinter import *
      • window=Tk()
        #The model
        counter=IntVar()
        counter.set(0)
        #The controller
        def click(var,value):
            var.set(var.get()+value)  #counter为全局变量
        #The view
        frame=Frame(window)
        frame.pack()
        button=Button(frame,text=”Up”,command=

        lambda:click(counter,1))
        button.pack()
        button=Button(frame,text=”Down”,command=

        lambda:click(counter,-1))
      • button.pack()
        label=Label(frame,textvariable=counter)
        label.pack()
        window.mainloop()
  • 样式：
    • 字体font：系列family、大小（point）、粗细bold/normal、倾斜性italic/roman
      • 例如;
      • button=Button(window,text=”Hello”,font=(“Courier”,14,”bold italic”))
    • 颜色color：背景色bg、前景色fg（颜色名称:white、black、green、red、blue、cyan、yellow、magenta等；RGB：#FF00FF等）
      • 例如：
      • button=Button(window,text=”Hello”,bg=”green”,fg=’#FF0000′)
      • 拾色器：
        • 
        • from tkinter import *
          def change(widget,colors):
              new_val=’#’
              for name in (‘red’,’green’,’blue’):
                  

          new_val+=colors[name].get()
              

          widget[‘bg’]=new_val   #通过属性改变相应的数据
          window=Tk()
          frame=Frame(window)
          frame.pack()
          colors={}
          for (name,col) in ((‘red’,’#FF0000′),(‘green’,’#00FF00′),(‘blue’,’#0000FF’)):
              

          colors[name]=StringVar()  #字典
              colors[name].set(’00’)
              entry=Entry(frame,

          textvariable=colors[name],bg=col,fg=’white’)
              entry.pack()
          current=Label(frame,text=’    ‘,bg=’#FFFFFF’)
          current.pack()
          update=Button(frame,text=’Update’,command=

          lambda:change(current,colors))
          update.pack()
          window.mainloop()
  • 布局
    • 给pack方法一个side的参数；例如label.pack(side=”left”)
    • grid;用grid取代pack；例如label.grid(row=0,column=1)
      • grid参数说明
      • 参数	说明
        row	需要置入插件的行的序号，从0开始
        column	需要置入插件的列的序号，从0开始
        rowspan	插件所占据的行数，默认为1
        columnspan	插件所占据的列数，默认为1
    • 例如：
      • 
      • from tkinter import *
        window=Tk()
        frame=Frame(window)
        frame.pack()
        label=Label(frame,text=”Name:”)
        label.grid(row=0,column=0)
        entry=Entry(frame)
        entry.grid(row=1,column=1)
        window.mainloop()

• Python使用sqlite3
  • 例如import sqlite3 as dbapi
  • SQL结构化查询语言
• 第一步：创建一个数据库，并做基本操作
  • import sqlite3 as dbapi  #引入数据库API
  • con=dbapi.connect(‘population.db’)  #创建一个数据库
  • cur=con.cursor()   #获取一个游标
• 第二步：操作数据库
  • 创建一个用来存放数据的表：格式CREATE TABLE TableName(ColumnName Type,ColumnName Type,……)
    • TableName和ColumnName跟变量的名字一样，Type则来自数据库支持的类型
    • 例如：
    • cur.execute(‘CREATE TABLE PopByRegion(Region TEXT,Population INTEGER)’)
    • SQLite的数据类型：
      • 类型	对应Python类型	用途
        NULL	NoneType
        INTEGER	int 或 long
        REAL	float	8位浮点数
        TEXT	unicode 或 str	字符串
        BLOB	buffer	二进制数据（图片、MP3音频等）
• 第三步：插入数据
  • 格式：INSERT INTO TableName VALUES（value1,value2,……）
  • 例如：cur.execute(‘INSERT INTO PopByRegion VALUES(“Centrial Africa”,330933)’)
• 第四步：关闭表：cur.close()
• 其他操作：
  • 保存修改：commit() ；例如con.commit()
  • 获取数据：格式SELECT ColumnName,ColumnName,…FROM Table
    • 例如：cur.execute(‘SELECT Region,Population FROM PopByRegion’) ;cur.execute(‘SELECT * From PopByRegion’)
    • 完成查询后，可以通过fetchone方法来访问结果（每次一条记录,以元组形式返回;fetchall——一次性获取所有行）：例如print(cur.fetchone())；默认TEXT是以Unicode字符串的形式返回，如果想改为以str字符串返回的话，可以讲游标的属性text_factory设置为str；例如con.text_factory=str
  • 数据库排序：（ORDER BY ColumnName ASC/DESC）（ASC——升序；DESC——降序）
    • 例如：cur.execute(‘SELECT Region,Population FROM PopByRegion ORDER BY Region’)
  • 查询条件（WHERE）
    • 例如cur.execute(‘SELECT Region,Population FROM PopByRegionWHERE Population>1000 AND/OR/NOT Region<“L”‘)
  • 更新（UPDATE）和删除（DELETE 、DROP）
    • 例如：
      • cur.execute(‘SELECT Region,Population FROM PopByRegion WHERE Region=”Japan”‘)
      • cur.execute(‘UPDATE PopByRegion SET Population=100600WHERE Region=”Japan”‘) #更新
      • cur.execute(‘DELETE From PopByRegion WHERERegion<“Japan”‘) #删除
      • cur.execute(INSERT INTO PopByRegion VALUES(“Japan”,100562)’)   #插入
      • cur.execute(‘DROP TABLE PoopByRegion’)  #删除整个表
  • 通过连接将表合并起来
    • 首先添加一个表：
      • cur.execute(‘CREATE TABLE PopByCountry(Region TEXT,Country TEXT,Population INTEGER)’)
      • cur.execute(‘INSERT INTO PopByCountry VALUES(“Eastern Aisa”,”China”,1238546)’)  #插入一条数据
      • 如果插入多条，可以通过将插入的表做成一个元组列表，然后循环插入；例如
        • countries=[(“Eastern Aisa”,”DPR Korea”,2456),(“Eastern Aisa”,”China”,1238546)]
        • for c in countries:
          • cur.execute(‘INSERT INTO PopByCouontry VALUES(?,?,?),(c[0],c[1],c[2])’)
        • con.commit()
    • 连接类型：
      • 内连接
        • 涉及内容
          • 创建各个表的矢量积
          • 丢弃不满足查询条件的行
          • 从剩下的行中选取列
        • 步骤：
          • 得到各表的所有行的所有组合，即得到矢量积
          • 应用有WHERE字句删除所有不满足条件的行
          • 选定的列会保留，其余删除
        • 例如：
          • cur.execute(”’
          • SELECT PopByRegion.Region,PopByCountry.Country
          • FROM PopByRegion INNER JOIN PopByCountry
          • WHERE(PopByRegion.Region==PopByCountry.Region)
          • AND (PopByRegion.Population>100000)
          • ”’)
  • 键和约束
    • 理想情况下，键的值应该唯一;主键可以由多个列组成！！！在创建表的时候，加上PRIMARY KEY指定主键；
      • 例如：cur.execute(‘CREATE TABLE PopByRegion(Region TEXT NOT NULL,Population INTEGER NOT NULL,PRIMARY KEY(Region))’)
    • 用CONSTRAINT指定：现在所创建的这个表中，永远不能有地区和国家都相同的两条记录；
      • cur.execute(‘CREATE TABLE PopByRegion(Region TEXT NOT NULL,Population INTEGER NOT NULL,CONSTRAINTCountry_Key PRIMARY KEY(Region,Country))’)
  • 高级功能：
    • 聚合（求取总计SUM、平均值AVG、MIN、MAX、非空值的数量COUNT）：cur.execute(‘SELECT SUM(Population) FROM PopByRegion’)
    • 分组（GROUP）：例如cur.execute(‘SELECT SUM(Population) FROM PopByCountry GROUP BY Region’)
    • 自连接：
      • 例如想查找人口总数很接近的两个国家：
        • cur.execute(”’
        • SELECT A.Country,B.Country
        • FROM PopByCountry A INNER JOIN PopByCountry B
        • WHERE (ABS(A.Population-B.Population)<=1000)
        • AND (A.Country!=B.Country)”’)
    • 嵌套查询：多个SELECT
      • 例如：
        • cur.execute(”’
        • SELECT DISTINCT Region
        • FROM PopByCountry
        • WHERE Region NOT IN
        • (SELECT DISTINCT Region
        • FROM PopByCountry
        • WHERE (PopByCountry.Population=4564))
        • ”’)
  • 注意：
    • 可以用NULL表示缺失的值，但是使用它应该注意，其跟真实的”真值表“不太一样
    • 一个实例：
      • #-*- coding: utf-8 -*-
        import sqlite3 as dbapi
        con=dbapi.connect(‘D:\\population.db’)#l连接数据库
        cur=con.cursor()#获取游标
        cur.execute(‘CREATE TABLE PopByRegion(Region TEXT,Population INTEGER)’) #如果已经存在该表，则这条语句可以不用了
        cur.execute(‘INSERT INTO PopByRegion VALUES(“Centrial Aisa”,223312)’)#插入数据
        cur.execute(‘INSERT INTO PopByRegion VALUES(“Southeastern Africa”,300312)’)
        cur.execute(‘INSERT INTO PopByRegion VALUES(“Japan”,600312)’)
        #cur.execute(‘create table PopByRegion(Region TEXT,Population INTEGER)’)
        con.commit()
        con.text_factory=str #设置TEXT值以字符串返回
        cur.execute(‘select * from PopByRegion’) #获取数据
        print(cur.fetchall())
        cur.execute(‘select Region from PopByRegion where Population>200000′)#查询数据
        print(cur.fetchall())
        cur.execute(‘update PopByRegion set Population=100060 where Region=”Japan”‘) #更新数据
        cur.execute(‘select * from PopByRegion’) #获取数据
        print(cur.fetchall())
        cur.execute(‘delete from PopByRegion  where Region<“Japan”‘) #删除数据
        cur.execute(‘select * from PopByRegion’) #获取数据
        print(cur.fetchall())
        cur.close()

转载地址：http://zgmbi.baihongyu.com/