疯狂的Python
2015-01-05 10:12:32 1 举报AI智能生成
Python学习笔记
作者其他创作
大纲/内容
1，导论
高级动态编程语言
预编译
import py_compile
py_compile.compile("hello.py")
生成hello.pyc字节码
优化代码
python -O -m py_compile hello.py
生成hello.pyo
变量
id函数返回变量内存地址
a="123"
b="123"
id(a)
4416957416
id(b)
4416957416
可以看到变量a、变量b指向同一个内存空间
运算符和表达式
//
整除运算符
3.0/2
1.5
3.0//2
1.0
and
逻辑与
or
逻辑或
not
逻辑否
成员测试
in
not in
同一性测试
is
is not
2，数据类型
数字
int
范围：-2147483648~2147483647
long
任意大的整数均可存储
序列
字符串
a="abcde"
a[1:4]
"bcd"
a[-2:-5:-1]
"dcb"
切片结果默认从左往右，如果步长为负数，则结果从右往左
元组()
不可变
t=(1,2,3)
a,b,c=t
a,b,c=(1,2,3)
列表[]
添加
list.append()
删除
list.remove()
基本操作
len()
+
连接2个序列
*
重复序列元素
a="ab"
a*3
"ababab"
in
判断元素是否出现在序列中
a="abcde"
'c' in a
True
max()
返回最大值
min()
返回最小值
cmp(tuple1, tuple2)
比较2个序列的值是否相同
字典
key不可变
key可以是str, int, tuple,,,,不可以是list，因为list可变
dict.pop()
dict.clear()
深拷贝、浅拷贝
copy.copy
copy.deepcopy
3，流程控制
if-elif-else
for iterating_var in sequence
for k,v in dict.items()
4，函数
元组参数
def f(x,y):
print("%s : %s" % (x,y))
a=("name", "jane")
f(*a)
"name : jane"
如果元组元素个数与函数参数个数一致，
则可以在传递参数时在元组变量前加*，
这样元组元素的值就会按顺序赋值给函数参数
字典参数
def f(name,age):
print("name=%s,age=%s" % (name,age))
a={"age":20, "name":"jane"}
f(**a)
"name=jane,age=20"
如果字典元素的key值与函数的形参名是一一对应，
则可以在传递参数时在字典变量前加**，
这样字典元素的值就会按key的值赋值给对应函数的形参
冗余参数
def f(x, *tuple_args, **dict_args):
print(x)
print(tuple_args)
print(dict_args)
f(1)
1
()
{}
f(1,2,3)
1
(2,3)
{}
f(x=1,y=2,z=3)
1
()
{'y':2, 'z':3}
f(1,2,3,y=4,z=5)
1
(2,3)
{'y':4, 'z':5}
lambda
快速定义单行最小函数
从lisp借鉴而来
雏形
def f1(x,y):
return x*y
f2 = lambda x,y : x*y
def f(*args, **kwargs):
pass;
可以接收任意的参数
内置函数
id(变量名)
返回变量的内存地址
int(object)
把字符串或数字转换成整数
type(变量名)
返回变量的类型
zip
a=["name", "age"]
b=["jane", 20]
zip(a, b)
[("name", "jane"), ("age", 20)]
divmod(a,b)
得到a除b的商、余
divmod(5,2)
(2, 1)
callable(f)
返回True or False
用来判断参数是否是个函数
isinstance(var, type)
返回True or False
判断变量是否是某个类型的对象
序列处理函数
序列分类
list
tuple
string
filter
对序列元素进行过滤
filter(function or None, sequence) -> list, tuple, or string
把序列中的元素依次传到function中，
如果function返回True，则保留元素的值，否则丢弃
f = lambda x : x>5
a = range(10)
filter(f, a)
[6, 7, 8, 9]
zip
zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
name=["koma","jane"]
age=[30,20]
addr=["chengdu","wuhan"]
tel=[110]
zip(name,age,addr)
[('koma', 30, 'chengdu'), ('jane', 20, 'wuhan')]
zip(name,age,addr,tel)
[('koma', 30, 'chengdu', 110)]
zip，以长度最短的序列为准
map(None,name,age,addr)
[('koma', 30, 'chengdu'), ('jane', 20, 'wuhan')]
map(None,name,age,addr,tel)
[('koma', 30, 'chengdu', 110), ('jane', 20, 'wuhan', None)]
map，以长度最长的序列为准
长度不够的以None补齐
map
map(function, sequence[, sequence, ...]) -> list
先把多个sequence组成一个sequence，长度不够的以None补齐
如果function为None，则返回新的sequence
否则把新的sequence中的每个元素传递给function
这样function返回的结果组成一个新的list作为最终结果
a=[1,3,5]
b=[2,4,6]
map(None, a, b)
[(1,2), (3,4), (5,6)]
map(lambda x,y : x*y, a, b)
[2, 12, 30]
reduce
reduce(function, sequence[, initial]) -> value
从sequence中依次取2个值传递到function中计算
把计算结果与sequence中下一个元素传递到function中计算
只到sequence中只剩下1个值
reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
((((1+2)+3)+4)+5)
可以用来计算级数，阶乘...
级数
计算1+2+...+100
a=range(101)
reduce(lambda x,y : x+y, a)
5050
阶乘
计算5!
a=range(1,6)
reduce(lambda x,y : x*y, a)
120
模块
所有的.py文件都可称之为模块
__name__
模块名
当模块被直接执行，则__name__为__main__
当模块被其它模块调用，则__name__为模块文件名
包
python的模块可以按目录组织成包
步骤
创建一个名字为包名的文件夹
在该文件夹下创建一个__init__.py文件
根据需要在文件夹下存放脚本文件、已编译扩展及子包
import 包名.模块1 包名.模块2 包名.模块3
import as
from import
5，正则表达式
元字符
[]
常用来指定一个字符集
[abc]
[a-z]
[^ab]
import re
res=r"t[oc]p"
s="tbp tcp tip top tvp tsp"
re.findall(res, s)
['tcp', 'top']
r"..."表示是一个正则表达式规则字符串
^
行首
$
行尾
常用函数
compile编译
p_r=re.compile("t[oc]p",re.IGNORECASE)
s="tbp tcp tip top tvp tsp"
p_r.findall(s)
['tcp', 'top']
如果某个正则表达式要匹配很多次
则最好先进行编译，这样速度更快
re.IGNORECASE
忽略大小写匹配
match()
从字符串最开始的位置匹配
如果匹配到，则返回SRE_Match对象
否则返回空
p_r=re.compile("jane")
s="jane koma troy"
p_r.match(s)
<_sre.SRE_Match object at 0x107bf4b28>
s="koma jane troy"
p_r.match(s)
None
search()
扫描字符串
如果匹配到，则返回SRE_Match对象
否则返回空
p_r=re.compile("jane")
s="koma jane troy"
p_r.search(s)
<_sre.SRE_Match object at 0x107bf4b90>
findall()
找到匹配的所有字符串，并把它们作为列表返回
p_r=re.compile("jane")
s="jane koma jane troy"
p_r.findall(s)
['jane', 'jane']
finditer()
找到匹配的所有字符串，并把它们作为迭代器返回
sub()
字符串的正则表达式替换
str.replace()
不支持正则表达式
s="jane koma"
s.replace(r"j..e", "hello")
"jane koma"
sub(pattern, repl, string, count=0, flags=0)
s="jane koma"
p_r=re.compile("j..e")
re.sub(p_r, "helo", s)
或者写成：
re.sub(r"j..e","hello",s)
"hello koma"
split()
字符串的正则表达式分割
str.split()
不支持正则表达式
s="jane+koma-troy"
re.split(r"[\+\-]", s)
['jane', 'koma', 'troy']
编译标志
DOTALL, S
使 . 能匹配包括换行符等在内的所有字符
默认情况下 . 不能匹配换行符
p_r=re.compile("baidu.com")
p_r.findall("baidu\ncom")
[]
p_r=re.compile("baidu.com", re.S)
p_r.findall("baidu\ncom")
['baidu\ncom']
IGNORECASE, I
使匹配对大小写不敏感
MULTILINE, M
多行匹配，影响 ^ 和 $
找出字符串中所有以 jane 开头的行
注：默认情况下 . 不能匹配换行符
s="""
hello jane
jane hello
hello jene hello
jane hello hehe
"""
p_r=re.compile("^jane.+")
p_r.findall(s)
[]
p_r=re.compile("^jane.+", re.M)
p_r.findall(s)
['jane hello', 'jane hello hehe']
VERBOSE, X
正则表达式也可以换行，使用res的verbose状态，使正则表达式看起来更清晰
匹配电话号码
r="""
\d{3,4}
-?
\d{6,}
"""
p_r=re.compile(r, re.X)
s="abcd028-3546728abc"
p_r.findall(s)
['028-3546728']
分组"(" ")"
当正则表达式中有分组时
findall()会优先返回分组数据
正则表达式得到邮箱前缀
email="abc123@qq.com"
默认情况下
re.findall(r".+@.+", email)
['abc123@qq.com']
有分组时
re.findall(r"(.+)@.+", email)
['abc123']
小爬虫
拿到百度贴吧页面中的大图
关键点
urllib.urlopen(url).read()
得到html网页内容
大图都以
http://imgsrc.baidu.com/forum/
开头，利用re.findall()有分组时返回分组的数据
即可拿到大图的url
urllib.urlretrieve()可以下载图片文件到本地
code
import urllib
import re
def getHtml(url):
page = urllib.urlopen(url)
html = page.read()
return html
def getImageList(html):
r = r'src="(http://imgsrc.baidu.com/forum/.+?)"'
p_r = re.compile(r)
return p_r.findall(html)
def downloadImage(imgUrl, filename):
urllib.urlretrieve(imgUrl, filename)
url = "http://tieba.baidu.com/p/2579724416"
html = getHtml(url)
imgList = getImageList(html)
count = 0
for imgUrl in imgList:
downloadImage(imgUrl, "%s.jpg" % count)
count += 1
6，高级功能
文件与目录
文件读写
open()
fo=open(filepath)
fo.read()
fo.close()
file()
fo=file(filepath)
fo.read()
fo.close()
mode
r
只读
r+
读写
w
写入
先删除原文件，再重新写入
如果文件不存在则创建
w+
读写
先删除原文件，再重新写入
如果文件不存在则创建
a
写入
在文件末尾追加新的内容
如果文件不存在则创建
a+
读写
在文件末尾追加新的内容
如果文件不存在则创建
b
打开二进制文件
可以与r, w, a, + 结合使用
U
支持所有的换行符号
\r, \n, \r\n
文件对象方法
dir(file)
read()
读取所有数据
write()
writelines()
writelines(sequence_of_strings) -> None
Write the strings to the file.
close()
readline()
读取一行内容
readlines()
返回一个列表
列表中每个元素代表文件中的一行
next()
表明文件对象可被迭代
seek()
seek(offset[, whence]) -> None
Move to new file position.
offset表示偏移量
whence
0
相对文件开始位置偏移
1
相对文件当前位置偏移偏移
2
相对文件末尾位置偏移
seek(0, 0)
移动到文件开始位置
seek(0, 2)
移动到文件末尾
flush()
提交更新
os模块
dir(os)
os.mkdir("test")
os.mkdirs("a/b/c")
os.listdir(".")
os.getcwd()
ow.chdir("/")
os.path.isdir("")
os.path.isfile("")
os.path.join(a, *p)
把目录的绝对路径与文件名拼成文件的绝对路径
目录遍历
os.walk(path)
返回一个iterator
每个元素由3部分组成：
目录
子目录
文件名
[('/Users/jane/software', ['python'], ['.DS_Store']),
('/Users/jane/software/python', [], ['hello.py', 'hello.pyo', 'tieba_image.py'])]
异常处理
try:
...
except IOError, e:
pass
except NameError, e:
pass
finally:
pass
抛出异常
raise NameError("...")
MySQL
rpm -q MySQL-python
import MySQLdb
面向对象
定义
class Person(object):
age = 1
def __init__(self, name):
self.name = name
def sayHello(self):
print("Hello %s" % self.name)
p = Person("jane")
p.sayHello()
Hello jane
继承
class Student(Person):
def __init__(self, name):
Person.__init__(self, name)
def study(self):
print("%s is studing" % self.name)
s = Student("jane")
s.sayHello()
s.study()
Hello jane
jane is studing
0 条评论
下一页
