python 笔记

第一节 Python 简历 （蟒蛇）
是一种使你在编程时能够保持自己风格的程序设计语言，你不用费什么劲就可以实现你想要的功能，并且编写的程序清洗易懂。
一种解释型的、面向对象的、带有动态语义的高级程序设计语言
作者：Guido van Rossum
Python的发展，可以分成几个重要的阶段：
-CNRI时期：CNRI是资助Python发展初期的重要单位Python1.5版之前的成果大部分都在此时期内完成。
-BeOpen时期：Guido van Rossum与BeOpen公司合作，此一期间将Python2.0推出，甚至Python1.6也同时问世，但原则上已经分别维护了。
-DC时期：目前Guido已经离开BeOpen公司，将开发团队带到Digital Creations（DC）公司，该公司以发展Zope系统闻名，因此这项合作也颇受注目。
里程碑
Python获年度Tiobe编程语言大奖
-Python在2010年获得了较大的市场份额增长，2010年1月以来Python的市场份额增长了1.81%，是增长速度最开的。


第二节Python特征
Python编程语言中的定位
---脚本语言(scripting language)
---高级动态编程语言


简单易学
Python是一种代表简单主义思想的语言。Python的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。Python有极其简单的语法，极易上手。
解释性&编译性
-Python语言写的程序不需要编译成二进制代码。可以直接从源代码运行程序，但是需要解释器。这点类似于Java，或是Matlab。其实我更偏重于认为是后者。
-Python中亦有编译执行的特性


面向对象
-Python即支持面向过程的编程也支持面向对象的编程。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。让我很迷惑的是，Python中类的属性似乎不是那么重要，至少我现在还不是很明白。
高级语言
-使用Python语言编写程序，无需考虑诸如管理内存一类的底层。
可扩展性及可嵌入性
-可以把部分程序用C或C++编写，然后在Python程序中使用它们。与此相反，可以把Python嵌入c/c++程序，提供脚本功能。
免费、开源
-自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。现阶段，我们好像不太在意这一点。


可移植性
-由于他的开源性质，Python已经被移植在许多平台上。如果能避免使用依赖于系统的特性，那么所有Ptyon程序无需修改就可在Solars、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、PLayStation、Sharp Zaurus、Windows CE甚至还有PocketPC！


丰富的库
-丰富的库，似乎已成为判断一门编程语言是否强大的重要指标。Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统
GUI(图形用户界面)、Tk和其他与系统有关的操作。只要安装了Python，所有这些功能都是可用的。这被称为Python的功能齐全理念。除了标准库以外，还有许多其他高质量的库（似乎可以称为第三方）,
如wxPython、Twisted和Python图像库等等。


经典特征：
易用与速度的完美结合
把精力放在要解决的问题上
跨平台又易扩展
自动化的内存管理
内建许多高阶而实用的资料型态
轻易结合网路程序模块
万能钥匙 no-》胶水语言




第三节 Python的应用
实现Web爬虫和搜索引擎中的很多组件
Yahoo使用它（包括其他技术）管理讨论组
NASA在它的几个系统中即用了Python开发，又将其作为脚本语言
视频分享服务大部分是由Python编写的


豆瓣在python和ruby之间为何选择前者？
Ruby名气很大，但在国内真正用的人不多
Python的“可用性”要好的多，Java本来就在传统的大型应用中占有重要地位
虽然Python没有Perl的库强大，但是很多库还是在大型商业中应用的比较广泛，比之Ruby还是要稳的多
Python的简洁性
还有，据说Ruby是小日本创造的
其他：都根于Unix体系，Google使用Python




第四节 Python安装
交互模式
文件模式


Python文件类型
源代码
-Python源代码的文件以“py”为扩展名，由Python程序解释，不需要编译；
字节代码
-Python源文件经编译后生成的扩展名为“pyc”的文件；
-编译方法
import py_compile
py_compile.compile("hello.py")
优化代码
-经过优化的源文件，扩展名为“.pyo”
-python -O -m py_compile hello.py
以上三中均可直接运行


第二节 Python变量
变量是计算机内存中的一块区域，变量可以存储规定范围内的值，而且值可以改变。


变量的命名
-变量名由字母、数字、下划线组成。
-数字不能开头
-不可以使用关键字
-a a1 a_ a_1


变量的赋值
-是变量声明和定义的过程
a = 1
ld(a)


SyntaxError: 语法异常


小结：掌握变量命名规则及赋值方法；


练习
1、创建一个变量，并给它赋一个数值（任何数值都行）。然后使用print显示这个变量。
2、改变这个变量。可以用一个新值替换原来的值，或者将原来的值增加某个量。使用print显示这个新值。
3、创建另一个变量，并赋给它一个字符串（某个文本）。然后使用print显示这个变量。
4、像上一章一样，在交互模式中让Python计算一周有多少分钟。不过，这一次要使用变量。以DaysPerWeek（每周天数）、HoursPerDay(每天小时数)和MinutesPerHour（每小时分钟数）为名分别创建变量（或者也可以用自己取的变量名），然后将它们相乘。
5、人们总是说没有足够的时间做到尽善尽美。如果一天有26个小时，那么一周会有多少分钟呢？(提示：改变HoursPerDay变量)


第三节 运算符与表达式
写一个自己的四则运算器
#!/usr/bin/python
import sys
running  = True
while running:
try:
t = int(raw_input())
p = int(raw_input())
except EOFError:
break
print 'operator + result\n',t + p
print 'operator - result\n',t - p
print 'operator * result\n',t * p
print 'operator / result\n',t / p


Python运算符包括
-赋值运算符
-算术运算符
-关系运算符
-逻辑运算符


表达式是将不同数据（包括变量、函数）用运算符号按一定规则连接起来的一种式子
赋值运算符
‘=’等于：x=3,y="abcde"
'+='加等于：x+=2
‘-=’减等于：x-=2
‘*=’乘等于: x *= 2
'/='除等于：x/=2
'%='求余等于：x%=2


算术运算符
‘+’加法：x+y
'-'减法：x-y
‘*’乘法: x*y
'/'实数除法：3/2,3.0/2
'//'整数除法:5.6/2,5.6//2
'%'求余数：除法求余运算，比如17除6余数5
'**'求幂运算：2**3=8


关系运算符
‘<’小于：1<2
'>'大于：2>3
'<='小于等于：1<=1
'>='大于等于：2>=2
'!='不等于：1!=2
'=='完全等于:2==2


逻辑运算符
'and'逻辑与: True and False
'or'逻辑或: True or False
'not'逻辑非: not True


运算符的优先级
在常规表达式中，存在着多个运算符，比如：1+2*3-1/2*、3/2，那么就存在着计算优先度的问题
一般的，运算符存在高低级别，在同一个表达式中，高优先级的先运算：
比如：1*2+3*3=11而不是15
对于同级别的运算符，按从左到右处理
例如：8*4/2*3 = 48
运算符优先级由低到高是：
运算符
Lambda
逻辑运算：or
逻辑运算: and
逻辑运算：not
成员测试：in，not in
同一性测试：is，is not
比较：<,<=,>,>=,!=,==
按位或:|
按位异或：^
按位与：&
移位：<<,>>
加法与减法：+，-
乘法、除法与取余：*,/,%
正负号：+X，-X
按位翻转：~X
指数：**


练习
写一个四则运算器
使用交互模式或写一个小程序完成下面问题
-3人吃法，分摊35,27美元饭费，他们还想留15美分的小费，怎么分
-计算12.5mX16.7m的房间面积和周长
-写一个程序，把华氏温度 转化为摄氏温蒂。转换公式C=5/9*（F-32）
-写一个小程序运算以80km/h的速度行驶200km需要的时间，并显示答案。






小结
掌握
-赋值运算符
-算术运算符
-关系运算符
-逻辑运算符




第四节 Python数据类型
案例
123和“123”一样吗
()[]{}


计算机是用来辅助人们的，在程序设计中也映射了现实世界的分类，以便于抽象的分析。
数字
字符串
列表
元组
字典


数字类型
-整数
-长整型
-浮点型
-负数型
数字类型-整数int
整数int表示的范围-2.147,483,648到2,147,483,647
例如：0,1000，-100
Int的范围示例：
>>> num = 2147483647
>>> type(num)
<type 'int'>


数字类型-长整型long
long的范围很大很大，几乎可以说任意大的整数均可以存储。
为了区分普通整数和长整数，需要在整数后加L或小写l。
例如：51856678L，-0x22345L
示例：
>>> num = 1l
>>> type(num)
<type 'long'>
>>> num = 99999999999999
>>> type(num)
<type 'long'>






数字类型-浮点float
例如：0.0,12.0，-18.8,3e+7等
示例：
>>> num=0.0
>>> type(num)
>>> <type 'float'>
>>> num=12
>>> <type 'int'>
>>> num=12.0
>>> type(num)
<type 'float'>


数字类型-复数类型complex
Python对复数提供内嵌支持，这是其他大部分软件所没有的；
复数举例：3.14j,8.32e-36j
示例：
>>>num = 3.14j
>>>type(num)
<type 'complex'>
>>>num
3.1400000001j
>>>print num
3.14j


字符串String
使用引号定义的一组可以包含数字，字母，符号（非特殊系统符号）的集合。
Strval = 'This is a test!'
Strval = "This is a test!"
Strval = """ This is a test! """


三重引号（docstring）通常用来制作字符串，在面向对象时详解
“abcde”
>>>a[1:4]
'bcd'
>>>a[:4]
'abcd'
>>>a[4:]
'e'
>>>a[::1]
'abcde'
>>>a[::2]
'ace'
>>>a[-1]
'e'
>>>a[-4:-1]
'bcd'


第五节 Python数据类型 序列
案例
()[]
序列
列表、元组和字符串都是序列。
序列的两个主要特点是索引操作符和切片操作符。
-索引操作符让我们可以从序列中抓取一个特定项目。
-切片操作符让我们能够获取序列的一个切片，即一部分序列。


索引同样可以是负数，位置是从序列尾开始计算的。
-因此，shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目
切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。
-注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。
-切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片刀哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。
注意：返回的序列从开始位置开始，刚好在结束位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。
shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一个含有两个项目的切片。shoplist[:]返回整个序列的拷贝。你可以用负数做切片。负数用在从序列尾开始计算的位置。例如
，shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。


序列的基本操作
1、len(): 求序列长度
2、+；连接2个序列
3、*：重复序列元素
4、in：判断元素是否在序列中
5、max()：返回最大值
6、min()：返回最小值
7、cmp(tuple1,tuple2)比较2个的序列值是否相同


元组()
元组和列表十分类似，只不过元组和字符串一样是不可变的即你不能修改元组。
-元组通过圆括号中用逗号分割的项目定义。
-元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
创建元组
-一个空的元组由一对空的圆括号组成
如myempty=（）
-含有单个元素的元组
singleton=（2，）
-一般的元组
zoo=（‘wolf’,'elephant','penguin'）
new_zoo=('monkey','dolpoi',zoo)


第六节 Python数据类型 序列-列表
案例
()[]
列表[]
list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。
列表是可变类型的数据
列表的组成：用[]表示列表，包含了多个以逗号分隔开的数字，或者字串。
-List1=['Simon','David','Clotho','张三']
-List2=[1,2,3,4,5]
-List3=["str1","str2","str3","str4","str5"]


列表[]
列表操作
-取值
切片和索引
list[]
-添加
list.append()
-删除
del(list[])
list.remove(list[])
-修改
list[]=x
-查找
var in list


对象与类快速入门
对象和类，更好的理解列表
对象=属性+方法
列表是使用对象和类的一个例子。
-当你使用变量i并给它赋值的时候，比如赋整数5，你可以认为你创建了一个类（类型）int的对象（实例）i.
-help(int)


类也有方法，即仅仅为类而定义地函数。
-仅在该类的对象可以使用这些功能。
-例如：Python为list类提供了append方法，这个方法让你在列表尾添加一个项目。
mylist.append('an item')列表mylist中增加字符串。注意，使用点号来使用对象的方法。
类也有变量，仅为类而定义的变量
-仅在该类的对象可以使用这些变量/名称。
-通过点号使用，例如mylist.field.




第七节 Python数据类型-字典
案例
()[]{}
字典{}
字典是python中唯一的映射类型(哈希表)
字典对象是可变的，但是字典的键必须使用不可变对象，并且一个字典中可以使用不同类型的键值。
keys()或者values()返回键列表或者值列表
items()返回包含键值对的元组。


创建字典：
={}
-使用工厂方法dict()
例：fdict=dict(['x',1],['y',2])
-内建方法：fromkeys(),字典中的元素具有相同的值，默认为None
例：ddict={}.fromkeys(('x','y'),-1)
>>>dic={0:0,1:1,2:2}
>>>dic[0]
0
>>>dic[2]
2 
访问字典中的值：
-直接使用key访问：key不存在会报错，可以使用had_key()或者in和not in判断，但是has_key()方法即将废弃。
-循环遍历：
例：for key in dict1.keys():
-使用迭代器：for key in dict1


更新和删除:
-直接用键值访问更新；内建的updata()方法可以将整个字典的内容拷贝到另一个字典中。
-del dict1['a'] 删除字典中键值为a的元素
dict1.pop('a') 删除并且返回键为‘a’的元素
dict1.clear() 删除字典所有元素
del dict1 删除整个字典


字典相关的内建函数：
-type(),str(),cmp(),(cmp很少用于字典的比较，比较依次是字典的大小、键、值).
工厂函数dict():
-例如：dict(zip('x','y'),(1,2))或者dict(x=1,y=2)
-{'y':2,'x':1}
-使用字典生成字典比用copy慢，因此这种情况下推荐使用copy().


len(),hash()（用于判断某个对象是否可以做一个字典的键，非哈希类型报TypeError错误）
dict.clear()：删除字典中的所有元素
dict.fromkeys(seq.val=None):以seq中的元素为键创建并返回一个字典，val为制定的默认值。
dict.get(key,defatult=None):返回key的value，如果该键不存在返回default指定的值。
dict.has_key(key)：判断字典中是否存在key，建议使用in和not in代替
dict.items()：返回键值对元组的列表
dict.keys()：返回字典中键的列表。
dict.iter*()：iteritems(),iterkeys(),itervalues()返回迭代子而不是列表。
dict.pop(key[,default]):同get(),区别是若key存在，删除并返回dict[key],若不存在切default未指定值，抛出KeyError异常。
dict.setdefault（key，default=None）:同set（），若key存在则返回其value，若key不存在，则dict[key] = default.
dict.update(dict2):将dict2中的键值对添加到字典dict中，如果有重复覆盖，原字典不存在的条目添加进。
dict.values():返回字典中所有值得列表。


Python流程控制


案例
判断再判断
猜数字
玩个文字小游戏


if else
if语句：
-Python的if语句类似其他语言。if语句包含一个逻辑表达式，使用表达式比较，在比较的结果的基础上作出决定。
-if expression：
statement(s)
注：python使用缩进作为其语句分组的方法，建议使用4个空格代替缩进。


#!/usr/bin/python
if 1<2:
    print "ok"
print "mian ok"


逻辑值（bool）用来表示诸如：对与错、真与假、空与非空等概念
逻辑值包含了两个值：
-True：表示非空的量(比如：string、tuple、list、set、dictonary等),所有非零数，
-False：表示0，None，空的量等
作用：主要用于判读语句中，用来判断
-一个字符串是否是空的
-一个运算符结果是否为零
-一个表达式是否可用


if else
elif语句：
-if expression：
statement(s)
elif expression2:
statement(s)
elif expression3:
statement(s)
else:
statement(s)
-elif语句可以让你检查多个表达式为真值，并执行一个代码块，elif语句是可选的。可以有任意数量的elif。
例子：
#!/usr/bin/python
def fun():
    return 0
x = int(raw_input("please input x:"))
y = int(raw_input("please input y:"))


if x>=90 and y>=90:
    if y >= 90:
        print "A"
    print "x>=90"
elif x>=80:
    print "B"
elif x>=70:
    print "C"
else:
    print "bad"


逻辑运算符
and
or 
not


Python-for循环
循环是一个结构，导致一个程序要重复一定次数。
条件循环也是如此。当条件变为假，循环结束。
for循环：
-在Python for循环遍历序列，如一个列表或一个字符。
for循环语法：
-for iteratiing_var in sequence:
statements(s)
注：如果一个序列包含一个表达式列表，它是第一个执行。
然后，该序列中的第一项赋值给迭代变量iterating_var.接下来，执行语句块。列表中的每个项目分配到iterating_var,代码块被执行，直到整个序列被耗尽。
注：格式遵循代码块缩进原则


#!/usr/bin/python
for x in "abcd":
    print x + " hello"


for 循环
迭代序列指数（索引）：
-遍历每个项目的另一种方法是由序列本身的偏移指数（索引）：
例子：
#!/usr/bin/python
fruits = ['banana','apple','mango']
for index in range(len(fruits)):
    print 'Current fruit:',fruits[index]
print "Good bye!"
注：“迭代”，指重复执行一个指令


range
循环结构是用于迭代多个项的for语句，迭代形式可以循环序列的所有成员。
range(i,j,[,步进值])
-如果所创建的对象为整数，可以用range，
-i为初始数值，
-j为终止数值，但不包括在范围内，步进值为可选参数，不选的话默认为1，
-i不选的话默认为0.
#!/usr/bin/python
for x in range(100)
    print x,"hello world"


#!/usr/bin/python
num = 0
for x in range(1,100):
    num += x
print num


遍历
迭代遍历
遍历序列
#!/usr/bin/python
for x in range(len("hello")):
    print x


#!/usr/bin/python
s = "hello"
l = [1,2,3,4,5,'a','b']
t = (7,8,9,'x','y')
d = {1:111,2:222,3:333}


for x in d:
    print x


print d.items()


for k,v in d.items():
    print k
    print v
else:
    print "ending"


for x in l:
    print x
for x in range(len(s)):
    print s[x]




循环控制


#!/usr/bin/python
import time


s = "hello"
l = [1,2,3,4,5,'a','b']
t = (7,8,9,'x','y')
d = {1:111,2:222,3:333,5:555}


for x in range(1,11):
    print x
    if x == 3:
        pass #代码桩 起到占位的作用
    if x == 2:
        print "hello 222222"
continue
    if x == 5:
        exit() #跳出整个程序
    if x == 6:
        break
    print "#"*50
else:
    print "ending"
for x in range(1,11):
    print "---------------->"X
for x in range(300):
    print x
    time.sleep(1)
else:
    print "ending"


while


while循环，直到表达式变为假。表达的是一个逻辑表达式，必须返回一个true或false值
语法：
while expression：
    statement(s)
注：遵循代码块缩进原则


#!/usr/bin/python


while x != "q":
    print "hello"
    x = raw_input("pleasure input something,q for quit:")
    if not x:
        break
    if x == "c"
        continue
    print "one more time~~~~"
else:
    print "ending......"


函数
函数就是完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且给它取一个名字。
可以通过函数名在程序的不同地方多次执行（这通常叫做函数调用），却不需要在所有地方都重复编写这些语句。
自定义函数
-用户自己编写的
预定义的Python函数
-系统自带的一些函数，还有一些第三方编写的函数，如其他程序员编写的一些函数，对于这些现成的函数用户可以直接拿来使用。


为什么使用函数
降低编程难度
-通常将一个复杂的大问题分解成一系列更简单的小问题，然后将小问题继续划分成更小的问题，当问题细化为足够简单时，我们就可以分而治之。
这时，我们可以使用函数来处理特定的问题，各个小问题解决了，大问题也就迎刃而解了。
代码重用
-我们定义的函数可以在一个程序的多个位置使用，也可以用于多个程序。此外，我们还可以把函数放到一个模块中供其他程序员使用，同时，我们也可以
使用其他程序员定义的函数。这就避免了重复劳动，提供了工作效率。


函数的定义和调用
当我们自己定义一个函数时，通常使用def语句，其语法形式如下所示：
def 函数名（参数列表）：#可以没有参数函数体


调用函数的一般形式是：
-函数名（参数表）


#!/usr/bin/python
def fun():
    if True:
        print "good"
print a


if fun():
    print "ok"


形式参数和实际参数
-在定义函数时函数名后面圆括号中的变量名称叫做“形式参数”，或简称为“形参”；
-在调用函数时，函数名后面圆括号中的变量名称叫做“实际参数”，或简称为“实参”。
#!/usr/bin/pythod
def fun(x):
    print "i get a :", x
s = raw_input("input someting:")
fun(s)


def fun(x,y)
    if x == y :
        print x,'=',y
    else:
        print x,'!=',y
s1 = raw_input("input something:")
s1 = raw_input("input something:")
fun(s1,s2)


函数
调用函数的一般形式是：
-函数名（参数表）
def machine(x,y):
    print "制作出一个",x,"元",y,"口味冰激凌"
mashine(5,"巧克力")


#!/usr/bin/python
#coding:utf8


def fun(x,y):
    if x == y :
         print x,'=',y
    else:
        print x,'!=',y
def mashine(x,y):
    print "生成一个",x,'元',y,'口味的冰激凌！'


s1 = raw_input("input something:")
s2 = raw_input("input something:")
machine(s1,s2)


缺省参数（默认参数）
def machine(x,y="奶油"):
    print "制作出一个",x,"元",y,"口味冰激凌"


mashine(5,“巧克力”)
mashine(5)
mashine(y='巧克力')


局部变量和全局变量
-Python中的任何变量都有其特定的作用域
-在函数中定义的变量一般只能在该函数内部使用，这些只能在程序的特定部分使用的变量我们称之为局部变量；
-在一个文件顶部定义的变量可以供该文件中的任何函数调用，这些可以为整个程序所使用的变量称为全局变量






#!/usr/bin/pythod
a = 100
def fun():
    print a
fun()
print "-"*40
print a




#!/usr/bin/pythod
x = 'i am global ar'
def fun():
    a = 100
    print a
    print x
fun()
print x


函数
局部变量和全局变量
#-*-coding:cp936 -*-
#定义全局变量
globalint = 9


#定义一个函数
def myAdd():
    localint = 3 #定义局部变量
    print globalint
    print localint


#测试变量的局部性和全局性
myAdd()
print globallnt
print localInt


#-*-coding:cp936 -*-
#定义全局变量
g = 9
#定义一个函数
def myf():
    g = 3 #定义局部变量，并且与全局变量重名
    print ‘g=’,g
#测试变量g的局部性和全局性
myf()


global语句
global变量名
强制声明为全局变量
#!/usr/bin/python
x = 'i am global var'
def fun():
    global y
    y = 200


    global x
    x = 100
print x
fun()
print y


案例
返回数字绝对值
计算数据


函数返回值
-函数被调用后会返回一个指定的值
-函数调用后默认返回None
-return 返回值
-返回值可以是任意类型
-return执行后，函数终止
-区分返回值和打印


def f(x,y):
    if x>y:
        return 1
    if x<y:
        return 0
    if x==y:
        return -1




案例
多类型传值
传值冗余
向函数传元组和字典
处理多余实参


def f(x,y):
    print "%s : %s" % x,y


print "%s : %s" % ('name','milo')




def f(name="name",age=0):
print "name: %s" % name
print "age : %s" % age


向函数传元组和字典
处理多余实参
fun(*args)
fun(**kwords)
处理多余实参
def fun(*args,**kw)


def f(x):
    print x


def f(x,*args):
    print x
    print args


def f(x,*args,**kwargs):
    print x
    print args
    print kwargs


lambda表达式
匿名函数
-lambda函数是一种快速定义单行的最小函数，是从Lisp借用来，可以用在任何需要函数的地方。
def(x,y)
    return x*y
    g = lambda x,y:x*y


1、使用python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。
2、对于一些抽象的，不会别的地方再复用的函数，有时候给函数起个名字也是个难题，使用lambda不需要考虑命名的问题。
3、使用lambda在某些时候让代码更容易理解。


lambda基础
lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。
lambda语句构建的其实是一个函数对象：


g = lambda x:x ** 2
print g
<function<lambda>>at 0x00AFAAF0


lambda应用实例
reduce为逐次操作list里的每项，接受的参数为2个，最后返回的为一个结果
def myadd(x,y):
    return x+y
sum = reduce(myadd,(1,2,3))




>>>l=range(1,6)
l
>>>def f(x,y):
    return x*y
>>>reduce(f,l)
reduce(lambda x,y:x*y,l)


第七节 switch
switch语句用于编写多分支结构的程序，类似与if...elif...else语句
switch语句表达的分支结构比if...elif...else语句表达的更清晰，代码的可读性更高。


但是python并没有提供switch语句


python可以通过字典实现switch语句的功能。
实现方法分为两步。
-首相，定义一个字典
-其次，调用字典的get()获取相应的表达式


通过字典调用函数
{1:case1,2:case2}.get(x,lambda * arg,**key:)()
---------------------------------------------------------------------------------------------------------
#!/usr/bin/python
#coding:utf-8


from _future_ import division
def jia(x,y):
    return x+y
def jian(x,y):
    return x-y
def cheng(x,y):
    return x*y
def chu(x,y):
    return x/y


def operator(x,o,y):
    if o == "+":
        jia(x,y)
    elif o == "-"
        jian(x,y)
    elif o == "*"
        cheng(x,y)
    elif o == "/"
        chu(x,y)
    else:
        pass
print _name_
if _name_ == "_main_": #直接调用导入包 判断名称
    operator(2,"*",3)


print operator(2,'+',4)
--------------------------------------------------------------------------------------------------------
operator={"+":jia,"-":jian,"*":cheng,"/":chu}
print operator["+"]
print jia(3,2)


def f(x,o,y):
    print operator.get(o)(x,y,*args,*kwargs)


f(3,"+",2)


#-*-coding:UTF-8-*-
#使用字典实现switch语句
from_future_import division
x=1
x=2
operator="/"
result={
    "+":x+y,
    "-":x-y,
    "*":x*y,
    "/":x/y
}
print result.get(operator)


第一节 内置函数
案例
返回数字绝对值
取列表最大最小值


def a(x):
    if x < 0:
        return -x
    return x
n = a(-10)
print n


常用函数
绝对值，最大最小值
abs()
max()
min()
len()
divmod()
pow()
round()
callable() #返回true false
isinstance()
cmp() #字符串对比
range() #快速生成序列
xrange() #生成的是一个对象


类型转化函数
type()
int()
long()
float()
complex()
str()
list()
tuple()
hex()
oct()
chr()
ord()


ex:
type(l)
type([])


if type(l) == type([]):
    print 'ok'


isinstance




>>>divmod(5,2)
(2,1)
divmod(2,5)
(0,2)
>>>help(divmod)


string函数
str.capitalize() #首字母大写
str.replace()    #替换
str.split() #切割


>>>help(str.replace)
>>>import string
>>>string.replace(s,'hello','good')


序列处理函数
len()
max()
min()
filter()
zip()
map()
reduce()
其他:


>>>def f(x):
    if x>5:
        return True
>>>f(10)
>>>f(3)
>>>l = range(10)
[0,1,2,3,4,5,6,7,8,9]
>>>filter(f,l)
[6,7,8,9]




>>>name=['milo','zou','tom']
>>>age=[20,30,40]
>>>tel=['133','156','189']
>>>zip(name,age,tel)
[('milo',20,'133'),('zou',30,'156'),('tom',40,'189')]
>>>map(None,name,age,tel)
[('milo',20,'133'),('zou',30,'156'),('tom',40,'189')]
>>>test=[1,2]
>>>zip(name,age,tel)
[('milo',20,'133'),('zou',30,'156'),('tom',40,'189')]
>>>zip(name,age,tel,test)
[('milo',20,'133',1),('zou',30,'156',2)]
>>>map(None,name,age,tel,test)
[('milo',20,'133',1),('zou',30,'156',2),('tom',40,'189',None)]
>>>a[1,3,5]
>>>b[2,4,6]
>>>def mf(x,y):
    return x * y
>>>map(None,a,b)
[(1,2),(3,4),(5,6)]


>>>def rf(x,y):
    return x+y
>>>reduce(rf,l)
>>>reduce(lambda x,y:x+y,l)
lambda
>>>foo=[2,18,9,22,17,24,8,12,27]
>>>print filter(lambda x:x % 3 == 0,foo)
[18,9,24,12,27]
>>>print map(lambda x: x * 2 = 10,foo)
[14,46,28,54,44,58,26,34,64]
>>>print reduce(lambda x,y: x + y,foo)
139


lambda->列表表达式
map的例子，可以写成:
print[x*2 + 10 for x in foo]
非常的简洁，易懂。filter的例子可以写成：
print[x for x in foo if x%3 == 0]


模块
案例
代码封装
模块是python组织代码的基本方式。
Python的脚本都是用扩展名为py的文本文件保存的，一个脚本可以单独运行，也可以导入另一个脚本中运行。当脚本被导入运行时，我们将其称为模块(module).


模块名与脚本的文件名相同
-例如我们编写了一个名为items.py的脚步，则可在另外一个脚本中用import items语句老导入它


包
Python的模块可以按目录组织为包
创建一个包的步骤是：
-建立一个名字为包名字的文件夹，
-在该文件夹下创建一个_init_.py文件，
-根据需求要在该文件夹下存放脚本文件、已编译扩展及子包。
-import pack.m1,pack.m2,pack.m3


def add(x,y):
    print x+y
add(1,2)


import cal
add(1,2)


import string
s = "hello"
print string.capitalize(s)


模块
模块名与脚本的文件名相同
-例如我们编写了一个名为Items.py的脚本，则可在另外一个脚本中用import items语句来导入它


正则表达式
目标
掌握正则表达式的规则
案例
一个小爬虫
正则表达式（或RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过re模块实现。
-可以为想要匹配的相应字符串集指定规则
-该字符串集可能包含英文语句、e-mail地址。命令或任何你想搞定的东西
-可以问诸如“这个字符串匹配该模式吗?”
-"在这个字符串中是否有部分匹配该模式呢？"
-你也可以使用RE以各种方式来修改或分割字符串。
正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行
正则表达式语言相对小型和受限（功能有限）
-并非所有字符串处理都能用正则表达式完成
字符匹配
-普通字符
大多数字母和字符一般都会和自身匹配
如正则表达式test会和字符串“test”完全匹配
-元字符
. ^ $ * + ? {} [] \ | ()
[]
-常用来指定一个字符集：
-元字符在字符集中不起作用：
-补集匹配不在区间范围内的字符：


^
-匹配行首。除非设置MULTILINE标志，它只是匹配字符串的开始。在MULTILINE模式里，它也可以直接匹配字符串中的每个换行。


$
-匹配行尾，行尾被定义为要么是字符串尾，要么是一个换行字符后面的任何位置。
ex：
>>>import re
>>>s = 'abc'
>>>re.findall(s,"aaaaaa")
[]
>>>re.findall(s,"abcaaaaa")
['abc']
>>>re.findall(s,"abcaaaaaaaaabcaaaaaaaaaa")
['abc','abc']
>>>st="top tip tqp twp tep"
>>>res = r"top"
>>>re.findall(res,st)
['top']
>>>res=r"tip"
>>>re.findall(res,st)
['tip']
>>>res = r"t[io]p"
>>>re.findall(res,st)
['top','tip']
>>>res = r"t[^io]p"
>>>re.findall(res,st)
['tqp','twp','tep']




>>>s="hello world,hello boy"
>>>r=r"hello"
>>>re.findall(r,s)
['hello','hello']
>>>r = r"^hello"
>>>re.findall(r,s)
['hello']
>>>s="world,hello boy"
>>>re.findall(r,s)
[]
>>>r=r"boy$"
>>>re.findall(r,s)
['boy']


>>>r="t[abc$]"
>>>re.findall(r,'ta')
['ta']
>>>re.findall(r,'tb')
['tb']
>>>re.findall(r,'tax')
['ta']
>>>re.findall(r,"t$")
['t$']
>>>r = "t[abc^]"
>>>re.findall(r,'r^')
['t^']
>>>r = r"x[0123456789]x"
>>>re.findall(r,"xlx")
['xlx']
>>>re.findall(r,'x1x x2x')
['x1x','x2x','x9x']
>>>r = r"x[0-9]x"
>>>re.findall(r,'x1x x2x x9x')
['x1x','x2x','x9x']
>>>r = r"x[a-zA-Z0-9]x"


第二节正则表达式
>>>r = r"^abc"
>>>import re
>>>re.findall(r,'abc')
['abc']
>>>re.findall(r,'aa abc')
[]
>>>r=r"^abc"
>>>import re
>>>re.findall(r,"abc")
>>>re.findall(r,'aa abc')
>>>re.findall(r,'^abc')
>>>re.findall(r,'^abc ^abc ^abc')
>>>
正则表达式-元字符
\
-反斜杠后面可以加不同的字符以表示不同特殊意义
-也可以用于取消所有的元字符：\[或\\
\d 匹配任何十进制数;它相当于类[0-9]
\D 匹配任何非数字字符；它相当于类[^0-9]
\s 匹配任何空白字符；它相当于类[\t\n\r\f\v]
\S 匹配任何非空白字符；它相当于类[^\t\n\r\f\v]
\w 匹配任何字母数字字符；它相当于类[a-zA-Z0-9]
\W 匹配任何非字母数字字符；它相当于类[^a-zA-Z0-9]


>>>r = r"[0-9]"
>>>re.findall(r,'1234567')


重复
-正则表达式第一功能是能够匹配不定长的字符集，另一个功能就是你可以指定正则表达式的一部分的重复次数
*
-指定前一个字符可以被匹配零次或更多次，而不是只有一次。匹配引擎会试着重复尽可能多的次数（不超过整数界定范围，20亿）
-a[bcd]*b--"abcd"
84翻中华


010-12345678
>>>r=r"^010-\d\d\d\d\d\d\d\d"
>>>re.findall(r,'010-87654321')
['010-87654321']
>>>re.findall(r,'010-87654322')
>>>r=r"^010-\d{8}"
>>>r = r"ab*"
>>>re.findall(r,'ab')
>>>re.findall(r,)
>>>r=r"ab+"
>>>re.findall(r,'a')
[]
>>>re.findall(r,'ab')
['ab']
>>>re.findall(r,"abb")
['abb']
+
-表示匹配一或更多次。
-注意*和+之间的不同；*匹配零或更多次，所以可以根本就不出现，而+则要求至少出现一次
？
-匹配一次或零次；你可以认为它用于标识某事物是可选的。


>>>r= r"^010-*\d{8}$"
>>>re.findall(r,'010-12345678')
['01012345678']
>>>re.findall(r,'010-123456789')
[]
>>>re.findall(r,'010-123456789')
>>>r= r"^010-?\d{8}$"
>>>re.findall(r,'010--12345678')
[]
>>>re.findall(r,'010-12345678')
[010-12345678]
>>>re.findall(r,'01012345678')
['01012345678']
>>>
{m,n}
-其中m和n是十进制整数。该限定符的意思是至少有m个重复，至多到n个重复。a/{1,3}b
-忽略m会认为下边界是0，而忽略n的结果将是上边界为无穷大（实际上是20亿）
-{0,}等用于*，{1,}等同于+,而{0,1}则与？相同。如果可以的话，最好使用*，+，或？


使用正则表达式
-re 模块提供了一个正则表达式引擎的接口，可以让你将REstring编译成对象并用它们来进行匹配。
-编译正则表达式
#!python
>>>import re
>>>p = re.compile('ab*')
>>>print p
<re.RegexObject instance at 80b4150>




>>>import re
>>>r1 = r"\d{3,4}-?\d{8}"
>>>re.findall(r1,"010-12345678")
['010-12345678']
>>>re.findall(r1,"010-1234567")
[]


-re.compile()也接受可选的标志参数，常用来实现不同的特殊功能和语法变更
#!python
>>>p = re.compile('ab*',re.IGNORECASE)
-反斜杠的麻烦
字符串前加"r"反斜杠就不会被任何特殊方式处理


字符               阶段
\section          要匹配的字符串
\\section         为re.compile取消反斜杠的特殊意义
"\\\section"      为"\\section"的字符串实值(string iterals)取消反斜杠的特殊意义


>>>csvt_re = re.compile(r'csvt',re.I) #不区分大小写
>>>csvt_re.findall('CsVt')


执行匹配
-‘RegexObject’实例有一些方法和属性，完整的列表可查阅Python Library Reference
方法/属性     作用
match()  决定RE是否在字符串刚开始的位置匹配  #判断匹配的数据是否成功
search()  扫描字符串，找到这个RE匹配的位置
findall()  找到RE匹配的所有子串，并把他们作为一个列表返回
finditer()  找到RE匹配的所有子串，并把他们作为一个迭代器返回


如果没有匹配到的话，match()和search()将返回None。
如果成功的话，就会返回一个‘MatchObject’实例，


>>>csvt_re.search('hello csvt')
>>>csvt_re.findall('hello csvt hello')
>>>x = csvt_re.finditer('hello csvt hello csvt csvt')
>>>x.next()


-MatchObject实例方法
方法、属性 作用
group() 返回被RE匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配（开始，结束）的位置


实际程序中，最常见的作法是将‘MatchObject’保存在一个变量里，然后检查它是否为None
#!python
p=re.compile(...)
m=p.match('string goes here')
if m:
print 'Match found:',m.group()
else:
print 'No match'


模块级函数
-re模块也提供了顶级函数调用如
match()、
search()、
sub（）、
subn（）、#一共替换了多少次
split（）、#切割 
findall（）等
>>>help(re.sub)
>>>s.replace('csvt python')
>>>s.replace('csvt','python')
>>>rs = r'c..t'
>>>re.sub(rs,'python','csvt caat cvvt cccc ')


>>>ip="1.2.3.4"
>>>ip.split('.')
['1','2','3','4']
>>>s = "123+456-789*000"
>>>re.split(r'[\+\-\*]',s)


第四节正则表达式
编译标志-flags
标志          含义
DOTALL,S      使.匹配包括换行在内的所有字符
IGNORECASE,I  使匹配对大小写不敏感
LOCALE,L      做本地化识别(local-aware)匹配。法语等"e"或“c”
MULTILINE,M   多行匹配，影响^和$
VERBOSE,X     能够使用REs的verbose状态，使之被组织得更清晰易懂
#!python
charref = re.compile(r""""
(
[0-9]+[^0-9] #Decimal form
|0[0-7]+[^0-7] #Octal form
|x[0-9a-fA-F]+[^0-9a-fA-F] #Hexadecimal form
)
"""",re.VERBOSE)


>>>s = """
hello csvt
csvt hello
hello csvt hello
csvt hehe
"""
>>>r = r"^csvt"
>>>re.findall(r,s)
>>>re.findall(r,s,re.M)
>>>tel = r"""
\d{3,4}
-?
\d{8}
"""
>>>re.findall(tel,'010-12345678')
>>>re.findall(tel,'010-12345678',re.X)
分组
-“（”和“）”
>>>email=r"\w{3}@\w+(\.com|\.cn)"
>>>re.match(email,'zzz@csvt.com')
>>>re.match(email,'zzz@csvt.org')
>>>re.findall(email,'zzz@csvt.cn')
>>>r1=r"hello src=.+ yes"
>>>s="""
hhsdj dskj hello src=csvt yes jdjsds
djhsjk src=123 yes jdsa
src=234 yes
hello src=python yes ksa


>>>re.findall(r1,s)
>>>r1=r"hello src=(.+) yes"
>>>r1 = r"hello src=(.+) yes"
>>>re.findall(r1,s)
>>>


一个小爬虫-milo
#!/usr/bin/python
import re
import urllib
def getHtml(url):
    page = urllib.urlopen(url)
    html = page.read()
    return html
def getImg(html)
    reg = r'src="(.*\.jpg)" width'
    imgre = re.compile(reg)
    imglist = re.findall(imgre,html)
    x = 0
    for imgurl in imglist:
        urllib.urlretrieve(imgurl,'%s.jpg' %x)
x+=1
    return imglist


html = getHtml("http://tiebai")
print getImg(html)


Python 对内存的使用
浅拷贝和深拷贝
所谓浅拷贝就是针对引用的拷贝（只拷贝父对象）
所谓深拷贝就是对对象的资源的拷贝
解释一个例子：
>>>a=[1,2,3,'a','b','c']
>>>b=a
>>>a.append('d')


>>>import copy
>>>a=[1,2,3,['a','b','c']]
>>>a
[1,2,3,['a','b','c']]
>>>b=a
>>>c=copy.copy(a)
>>>b
[1,2,3,['a','b','c']]
>>>c
[1,2,3,['a','b','c']]
>>>id(a)
>>>id(b)
>>>id(c)
>>>d=copy.deepcopy(a)


文件与目录
目标
文件的打开和创建
文件读取
文件写入
内容查找和替换
文件删除，复制，重命名
目录操作


案例
目录分析器
杀毒软件
系统垃圾清理工具


Python读写
python进行文件读写的函数是open或file


file_handler = open(filename,,mode)
fo = open('/root/test.txt')
fo.read()
fo.close()


mode
模式 说明
r 只读
r+ 读写
w 写入，先删除原文件，在重新写入，如果文件没有则创建
w+ 读写，先删除原文件，在重新写入，如果文件没有则创建（可以写入输入）


模式 说明
a 写入：在文件末尾追加新的内容，文件不存在，创建之
a+ 读写：在文件末尾追加新的内容，文件不存在，创建之
b 打开二进制的文件。可以与r，w，a，+结合使用
u 支持所有的换行符号。“\r”,"\n","\r\n"


>>>fnew = open('/root/new.txt,'w'')
>>>fnew.write('hello \ni am new')
fnew.close
fnew = open('/root/new.txt','r+')
fnew.read()
fnew.write("new contents")
fnew.close()


fnew = open('/root/new.txt','r+')
fnew.write('ooo')
fnew.close()


文件对象方法
文件对象方法
-FileObject.close()
-String=FileObject.readline([size])
-List=FileObject.readlines([size])
-String = FileObject.read([size])
-FileObject.next()
-FileObject.write(string)
-FileObject.writelines(List)
-FileObject.seek(偏移量，选项)
-FileObject.flush()


f1=open('test.txt')
s1=f1.read()
f1.close()
for i in open('test.txt'):
    print i


readline:
-格式
String = FileObject.readline([size])
-说明：
    每次读取文件一行
    size：是指每行每次读取size个字节，直到行的末尾
f1=open('test.txt')
f1.readline()


read:
-格式：
String=FileObject.read([size])
-说明：
读出文件的所用内容，并复制给一个字符串
size：读出文件的前[size]个字符，并输出给字符串，此时文件的指针指向size出


readlines：
-格式：
List=FileObject.readlines([size])
-说明：
多行读，返回一个列表
size：每次读入size个字符，然后继续按size读，而不是每次读入行的size个字符


f1=open('test.txt')
f1.readlines()


next:
-格式：
FileObject.next()
-说明：
返回当前行，并将文件指针到下一行


write:
-格式：
FileObject.write(string)
-说明:
write和后面的writelines在写入前会是否清除文件中原来所有的数据，在重新写入新的内容，取决于打开文件的模式


writelines:
-格式:
FileObject.writelines(List)
-说明：
多行写
效率比write高，速度更快，少量写入可以使用write


l=['one\n','two\n','three\n']
f1=open('/test.txt','a')
f1.writelines(l)
f1.close


f1=open('test.txt','a')
f1.writelines(l)
f1.close()


f1=open('test.txt','r+')
f1.read()
f1.seek(0,0) #控制指针
f1.writeline(l)
f1.writelines(l)
f1.flush()
f1.close()


FileObject.seek(偏移量，选项)
-选项=0时，表示将文件指针指向从文件头部到“偏移量”字节处
-选项=1时，表示将文件指针指向从文件的当前位置，向后移动‘偏移量’字节
-选项=2时，表示将文件指针指向从文件的尾部，向前移动“偏移量”字节。


FileObject.flush()
-提交更新


文件查找和替换
文件查找
cat a.txt
hello world
hello hello world


统计文件中hello的个数


python读写
示例一：
-fp1 = file("a.t","r")
-fp2 = file("a2.t","w")
-for s in f1.readlines():
- fp2.write(s.replace("hello","csvt"))
-fp1.close()
-fp2.close()


示例二：
-fp1=file("a.t","r+")
-s=f1.read():
-f1.seek(0,0)
-f1.write(s.replace("hello","csvt"))
-fp1.close()


OS模块
第一节 milo
import os
os.mkdir('test')


常用函数
函数                                  说明
mkdir(path[,mode=0777])
makedirs(name,mode=511)
rmdir(path)
removedirs(path)
listdir(path)
getcwd() #查看目录
chdir(path)
walk(top,topdown=True,οnerrοr=None)


os.listdir('.')


目录遍历-milo
案例
-系统垃圾清除小工具


方式
-递归函数
-Os.walk()函数


#!/usr/bin/python
#coding:utf8
import os
def dirList(path):
    filelist = os.listdir(path)
    filepath = os.getcwd()
    allfile = []
    for filename in filelist:
        #allfile.append(fpath+filename)
filepath = os.path.join(fpath,filename)

if os..path.isdir(filepath):


allfile.appendos.path.join(fpath,filename)
    return allfile


allfile = dirList('testdir')
print allfile


目录遍历
os.walk()
-函数声明：os.walk(path)
该函数返回一个元组，该元组有3个元素，这3个元素分别表示每次遍历的路径名，目录列表和文件列表。


import os
g = os.walk('/root/csvt/testdir')
g.next()


for path,d,filelist in os.walk('/root/csvt/testdir')
    for filename in filelist:
        os.path.join(path,filename)




异常处理
01 异常以及异常抛出
异常抛出机制，为程序开发人员提供了一种在运行时发现错误，进行恢复处理，然后继续执行的能力。
下面是一个异常处理实例：
try:
    f = open('unfile.py','r')
    except IOError,e:
        print False,str(e)


#coding:utf8
filename = raw_input('请输入你要操作的文件')
try:
    open('bac.txt')
    print hello
except IOError,msg:
    pass '文件找不到'
except NameError,msg:
    pass 'the file'
finally:
    f.close()


02 抛出机制
1、如果在运行时发生异常的话，解释器会查找相应的处理语句(称为handler)
2、要是在当前函数里没有找到的话，它会将异常传递给上层的调用函数，看看哪里能不能处理。
3、如果在最外层(全局"main")还是没有找到的话，解释器就会退出，同时打印出traceback以便让用户找出错误产生的原因
注意：虽然大多数错误会导致异常，但一个异常不一定代表错误。有时候它们只是一个警告，有时候它们可能是一个终止信号，比如退出循环等


03 finally子句
Python提供try-finally子句用来表述这样的情况：我们不关心捕抓到是什么错误，无论错误是不是发生，这些代码"必须"运行，比如文件关闭，释放锁，
把数据库链接返还给连接池等，比如：
>>>try:
f = open('unfile.py','r')
except Exception,e:
    print False,str(e)
finally:
    print "exec finally"
if filename == "hello":
    raise TypeError("nothing!!!!")
    raise OtherError("nothing!!!")
   


注意：当没有异常发生的时候，finally中的代码会在try完成之后立即运行。如果发生任何错误，那么finally的代码还是会被执行，但是它不会消除异常，异常
依然还是会在调用机制中寻找上一级的异常抛出中寻找处理语句


04 raise抛出异常
到目前为止，我们只讨论了如何捕获异常，那么如何抛出异常呢？
使用raise来抛出一个异常：
>>> if 'a' > 5 :
raise TypeError("Error:'a' must be integer.")


常见的Python异常
异常                  描述
AssertionError   assert语句失败
AttributeError   试图访问一个对象没有的属性
IOError          输入输出异常，基本是无法打开文件
ImportError      无法引入模块或者包，基本是路径问题
IndentationError 语法错误，代码没有正确的对齐
IndexError       下标索引超出序列边界
KeyError         试图访问你字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError         使用一个还未赋予对象的变量
SyntaxError       Python代码逻辑语法出错，不能执行
TypeError         传入的对象类型与要求不符
UnboundLocalError  试图访问一个还未设置的全局变量，基本上是由于另有一个同名的全局变量，导致你以为在访问
ValueError        传入一个不被期望的值，即使类型正确


MysqlLdb
连接
操作
关闭


rpm -q MySql-python
import MySQLdb
conn = MySQLdb.connect(user='',passwd='',host='')
cur = conn.cursor()
conn.select_db('week')
cur.execute("insert into (name,age,gender) value ('milo',20,'m')")
sqli = "insert into (name,age,gender) value (%s,%s,%s)"
cur.execute(sqli,('csvt',5,'s'))
cur.executemany(sqli,[('vt',5,'s'),('vt1',5,'s'),('vt2',5,'s')])
cur.execute('delete from userinfo where id = 16')
cur.execute('update userinfo set name='boy' where id = 16')
cur.fetchone()
cur.scroll(0,'absolute')
cur.fetchmeny(15)
cur.fetchmeny(cur.execute("select * from userinfo"))
cur.close()
conn.close()


Python面向对象
邹琪鲜
01类和对象
面向过程和面向对象的编程
面向过程的编程：函数式编程、C程序等
面向对象的编程：C++、Java、Python等
类和对象：是面向对象中的两个概念
类：是对事物的抽象、比如：汽车模型
对象：是类的一个实例，比如：QQ轿车、大客车
范例说明：
汽车模型可以对汽车的特征和行为进行抽象，然后可以实例化为一台真实的汽车实体出来。


02Python类定义
Python类的定义：
使用class关键字定义一个类，并且类名的首字母要大写；
当程序员需要创建的类型不能用简单类型表示时就需要创建类；
类把需要的变量和函数组合在一起，这种包含也称为“封装”。
Python类的结构
class类名：
成员变量
成员函数


class Test:
    first = 123
    second = 456
    def f(self):
        return 'test'


类的创建：
class MyClass():
    def fun(self): #包含self类本身
        print "l am function"


类的方法中至少有一个参数self
对象的创建：
    创建对象的过程称之为实例化；当一个对象被创建后，包含三个方面的特性：对象的句柄、属性和方法。
    句柄用于区分不同的对象(对象的句柄也就是对象的名字 )不同对象的名字
    
03类的属性
类中定义的变量
 
04类的方法
方法也就是定义类的时候的函数
对象的属性和方法与类中的成员变量和成员函数对应
    if _name_ == "_main_":
        myClass1 = MyClass() #创建类的一个实例(对象)
milo = Test() #从类中实例化一个对象
milo.f()
'test'
milo.first


l=[1,2,3,4,5]
l.append(5)
help(append)