抽空总结的一篇笔记，顺便复习一下python语法，通俗易懂 ~
第1章 变量和数据类型
- 数据类型
①整数
计算机由于使用二进制，所以有时候用十六进制表示整数比较方便，用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3等等
②浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的
③字符串
字符串是以' '或" "括起来的任意文本，例如：'abc'，"xyz"等等
④布尔值
布尔值只有True、False两种值，它可以用and、or和not运算
⑤空值
空值是Python里一个特殊的值，用None表示
None不能理解为0，因为0是有意义的，而None是一个特殊的空值
- print语句
print 'hello, world'
- 注释
注释是用来说明代码的，给自己或别人看，不影响结果
# 这是我写的代码
print 'hello, world'
- 变量
变量不仅可以是数字，还可以是任意数据类型
变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头
比如：a = 1，变量a是一个整数。t_007 = 'T007'，变量t_007是一个字符串。
- 整数和浮点数
整数运算结果是整数
浮点数运算结果是浮点数
整数和浮点数混合运算结果是浮点数
- 字符串
如果字符串既包含 ' 又包含 " ，这个时候对某些特殊字符可以用 \ 进行转义
s = 'Python was started in 1989 by \"Guido\".'
print s
①如果一个字符串包含多个需要转义的字符，转义会很麻烦。我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了
②要表示多行字符串，可以用 '''...''' 表示
print r'\(~_~)/ \(~_~)/'
print '''Line 1
Line 2
Line 3'''
中国制定了GB2312编码，用来把中文编进去。类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode编码把所有语言都统一起来，这样就不会再有乱码问题了。
print u'''
床前明月光
疑是地上霜
举头望明月
低头思故乡'''
- 布尔类型
与运算：只有两个布尔值都为 True 时，计算结果才为 True
True and True # ==> True
True and False # ==> False
False and True # ==> False
False and False # ==> False
或运算：只要有一个布尔值为 True，计算结果就是 True
True or True # ==> True
True or False # ==> True
False or True # ==> True
False or False # ==> False
非运算：把True变为False，或者把False变为True
not True # ==> False
not False # ==> True
print 100 < 99 or 0xff == 255
Python把0、空字符串和None看成 False，其他数值和非空字符串都看成 True
短路计算法则：
1.在计算 a and b 时，如果 a 是 False，返回 a；如果 a 是 True，返回 b。
2.在计算 a or b 时，如果 a 是 True，返回 a；如果 a 是 False，返回 b。
a = 'python'
print 'hello,', a or 'world'
b = ''
print 'hello,', b or 'world'
第2章 List和Tuple类型
- 创建list
list是数学意义上的有序集合，元素是按照顺序排列的，可以随时添加和删除其中的元素
构造list非常简单，直接用 [ ] 把list的所有元素都括起来，就是一个list对象
L = ['Adam', 95, 'Lisa', 85, 'Bart', 59]
print L
- 索引访问list
①索引从 0 开始，第一个元素的索引是0，第二个元素的索引是1，以此类推
②使用索引时，千万注意不要越界
L = ['Adam', 'Lisa', 'Bart']
print L[0]
print L[1]
print L[2]
- 倒序访问list
L = [95, 85, 59]
print L[-1]
print L[-2]
print L[-3]
- 添加元素
①list 的 append() 方法，可以把新的元素添加到尾部
②list 的 insert() 方法，第一个参数是索引号，第二个参数是待添加的新元素
L = ['A', 'B', 'C']
L.insert(2, 'YYDL')
L.append('SSY')
print L
- 删除元素
list 的 pop()方法，可以删掉最后一个元素，也可以添加索引删除指定元素
L = ['Adam', 'Lisa', 'Paul', 'Bart']
L.pop(2)
print L
L.pop()
print L
- 替换元素
L = ['Adam', 'Lisa', 'Bart']
L[0] = 'Bart'
L[2] = 'Adam'
print L
- 创建tuple
①tuple是另一种有序的列表，和 list 类似，但是tuple一旦创建完毕就不能修改了
用 ( ) 把tuple的所有元素都括起来，就是一个tuple对象
②用 ( ) 定义单元素的tuple有歧义，所以要多加一个逗号，更明确地告诉你这是一个tuple
t = (0 ,1, 2, 3, 4, 5, 6, 7, 8, 9)
print t
t = ('Adam',)
print t
- “可变”的tuple
tuple所谓的不变是说每个元素指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象。但指向的这个list本身是可变的
t = ('a', 'b', ['A', 'B'])
L = t[2]
print L
L[0] = 1
L[1] = 2
print t
第3章 条件判断和循环
- if 语句
score = 75
if score >= 60:
print 'passed'
- if-else 语句
score = 55
if score >= 60:
print 'passed'
else:
print 'failed'
- if-elif-else 语句
score = 85
if score >= 90:
print 'excellent'
elif score >= 80:
print 'good'
elif score >= 60:
print 'passed'
else:
print 'failed'
- for 循环
for 循环可以依次把 list 或 tuple 的每个元素迭代出来
# 计算平均成绩
L = [75, 92, 59, 68]
sum = 0.0
for x in L:
sum += x
print sum / 4
- while 循环
while 循环不会迭代元素，而是根据表达式判断循环是否结束
# 计算100以内奇数的和
sum , x = 0 , 1
while x < 100:
sum += x
x += 2
print sum
- break语句
break语句可以直接退出循环
t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
for x in t:
if x ==7:
break
print x
- continue语句
continue语句可以跳过后续代码，继续下次循环
t = (0, 1, 2, 3)
for x in t:
if x ==2:
continue
print x
- 多重循环
for x in ['A', 'B', 'C']:
for y in ['1', '2', '3']:
print x + y
第4章 Dict和Set类型
- 什么是dict
①list 和 tuple 可以用来表示顺序集合，例如班里同学的名字和考试成绩，但是要根据名字找到对应的成绩，用两个 list 表示就不方便，而 dict 就是专门干这件事的
②我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 { } 表示这是一个dict，然后按照 key: value 写出来即可
③由于dict也是集合，len() 函数可以计算大小，一个 key-value 算一个
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
print len(d)
- 访问dict
①list 使用索引返回对应的元素，而 dict 使用 key 返回对应的 value
②使用dict本身提供的一个 get 方法，在 key 不存在的时候，返回 None
③用 in 操作符可以判断 key 是否存在
d = {
'Adam': 90,
'Lisa': 80,
'Bart': 70
}
print d['Adam']
print d.get('Lisa')
if 'Bart' in d:
print d['Bart']
- dict的特点
①查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。
而list的查找速度随着元素增加而逐渐下降，缺点是占用内存大
②存储的key-value序对是没有顺序的，这和list不一样
③key不能重复，且作为 key 的元素不可变
d = {
90: 'Adam',
80: 'Lisa',
70: 'Bart'
}
print d
- 更新dict
d = {
95: 'Adam',
85: 'Lisa'
}
d[72] = 'Paul'
print d
- 遍历dict
d= {
'A':1,
'B':2,
'C':3
}
for i in d:
print i,d[i]
- 什么是set
set 有一系列元素，这点和 list 很像，但是元素没有重复且无序，这点和 dict 的 key很像
s = set(['A', 'B', 'C', 'C'])
print len(s)
print s
- 访问set
由于 set 存储的是无序集合，所以我们没法通过索引来访问。
访问 set 中的某个元素实际上就是判断一个元素是否在 set 中
s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
print 'Adam' in s
print 'bart' in s
- set的特点
set的内部结构和dict很像，唯一区别是不存储value，因此判断元素是否在set中速度很快
set存储的元素和dict的key类似，必须是不变对象，因此任何可变对象是不能放入set中的
months = set(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
x1 = 'Feb'
x2 = 'Sun'
if x1 not in months:
print 'x1: error'
if x2 not in months:
print 'x2: error'
- 遍历set
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
print x[0] , x[1]
- 更新set
由于set存储的是一组不重复的无序元素，因此更新set要做两件事：
一是 add() 把新的元素添加到set中，二是 remove() 把已有元素从set中删除
s = set(['A', 'B', 'C'])
L = ['C', 'D', 'E', 'F']
for x in L:
if x in s:
s.remove(x)
else:
s.add(x)
print s
第5章 函数
- 什么是函数
当我们知道半径r的值时，就可以根据公式计算出面积
假设我们需要计算10个不同大小的圆的面积，每次写s = 3.1415926535 * r * r很麻烦
有了函数，我们就写成函数调用 s = S(r)，而函数本身只需要写一次，而且可以多次调用
- 内置函数
Python内置了很多有用的函数，要调用一个函数，需要知道函数名和参数，例如：
①求绝对值的函数 abs， abs(-20) = 20
②比较函数 cmp(x, y) 需要两个参数，x<y，返回 -1；x==y，返回 0 ；x>y，返回 1
③把其他数据类型转换为整数的函数 int()，int('123') = 123
④把其他类型转换成字符串的函数 str()，str(123) = '123'
- 编写函数
定义一个函数要使用 def 语句，依次写出函数名、括号、参数和冒号，然后编写函数体，函数返回值用 return 语句返回。如果没有返回值，可以简写为return
# 定义一个函数，它返回 list 的元素平方和
def f(L):
sum = 0
for x in L:
sum += x * x
return sum
print f([1, 2, 3, 4, 5])
print f([-5, 0, 5, 15, 25])
- 函数之返回多值
Python的函数返回多值其实就是返回一个tuple，但写起来更方便
'''
请编写一个函数，返回一元二次方程 ax² + bx + c = 0 的两个解。
注意：Python的math包提供了sqrt()函数用于计算平方根
'''
import math
def f(a, b, c):
t = math.sqrt(b * b - 4 * a * c)
return (-b + t) / (2 * a),( -b - t )/ (2 * a)
print f(1, -6, 5)
- 递归函数
如果一个函数在内部调用了自己，这个函数就是递归函数
# 计算阶乘 50! = 1 * 2 * 3 * ... * 50
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
print fact(50)
- 默认参数
def greet(name='world'):
print 'Hello ' + name
greet()
greet('ABC')
- 可变参数
def average( *p ):
sum = 0.0
if len(p) == 0:
return sum
for x in p:
sum += x
return sum / len(p)
print average()
print average(1, 2, 2, 4.3)
第6章 切片
- 正序切片
L[1:4] 表示从索引1开始，到4为止，但不包括4。即索引1，2，3正好是3个元素
L[a:b:N] 表示从a开始，到b为止，每N个取一个元素。索引为第一个或最后一个可以省略
L[:] 表示从头到尾全部元素
# L = [0,1,2...,99]
L = range(100)
print L[1:4]
print L[3:8:2]
print L[1: :3]
print L[:]
- 倒序切片
L[-a:-b:N] 表示从倒数第a个开始，到倒数第b个为止，每隔N个取一个元素
L = range(1, 101)
print L[-10:-1]
print L[-46: :5]
- 字符串切片
字符串也可以看成是一种 list，每个元素就是一个字符。用切片操作结果仍是字符串
'''
实现将首字母大写
注意：函数upper()可以把字符变成大写字母
'''
def UP(s):
return s[0].upper() + s[1: ]
print UP('hello')
print UP('sunday')
第7章 迭代
- 什么是迭代
迭代是通过 for ... in 来完成的
# 循环迭代数列 1-100，打印出7的倍数
for i in range(1, 101):
if i % 7 == 0:
print i
- 索引迭代
①迭代是取出元素本身，而非元素的索引
②enumerate() 函数可以在 for 循环中同时绑定索引和元素
['Adam', 'Lisa', 'Bart', 'Paul'] --> [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
③zip()函数可以把两个 list 变成一个 list
zip([10, 20, 30], ['A', 'B', 'C']) -- > [(10, 'A'), (20, 'B'), (30, 'C')]
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for i, name in zip(range(1,5), L):
print i, '-', name
- 迭代dict的value
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for v in d.values():
sum += v
print sum / len(d)
- 迭代dict的key和value
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for i, j in d.items():
sum += j
print i, ':', j
print sum / len(d)
第8章 列表生成式
- 生成列表
把要生成的元素放到前面，后面跟 for 循环,就可以把 list 创建出来
print [x*x for x in range(1, 100, 2)]
- 复杂表达式
字符串可以用指定的参数替代 %s。join() 方法可以把一个 list 拼接成一个字符串
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def M(name, score):
return '<tr><td> %s </td><td> %s </td></tr>' % (name, score)
tds = [M(name, score) for name, score in d.items()]
print '<table border="1">'
print '<tr><th> name </th><th> score </th><tr>'
print '\n'.join(tds)
print '</table>'
- 条件过滤
在列表生成式中，for 循环后面还可以加上 if 判断
①isinstance(x, str) 可以判断变量 x 是否是字符串
②upper() 可以返回大写字母
def f(L):
return [x.upper() for x in L if isinstance(x, str)]
print f(['hello', 'world', 101])
- 多层表达式
在列表生成式中，也可以用多层 for 循环来生成列表
print [ 100 * n1 + 10 * n2 + n3
for n1 in range(1, 10) for n2 in range(10) for n3 in range(10)
if n1 == n3 ]
第9章 函数式编程
- 把函数作为参数
import math
def add(x, y, f):
return f(x) + f(y)
print add(25, 9, math.sqrt)
- map()函数
map() 函数是 python 内置的高阶函数，它接收一个函数 f 和一个 list，
f 依次作用在 list 的每个元素上，得到一个新的 list 并返回
def F(s):
return s[0].upper() + s[1:].lower()
print map(F, ['adam', 'LISA', 'barT'])
- reduce()函数
reduce() 函数也是 python 内置的高阶函数，它接收一个函数 f 和一个 list，
f 必须接收两个参数，reduce() 对 list 的每个元素反复调用 f 并返回
def p(x, y):
return x * y
print reduce(p, [1, 2, 3, 4])
- filter()函数
filter() 函数也是 python 内置的高阶函数，它接收一个函数 f 和一个 list，
f 对 list 每个元素进行判断，filter() 根据判断返回符合条件元素组成的新 list
import math
# 能否开方返回True，不能开方返回False
def f(x):
r = int(math.sqrt(x))
return r*r==x
print filter(f, range(1, 101))
- 自定义排序函数
①python内置的 sorted() 函数可对 list 进行排序
sorted( [36, 5, 12, 9, 21] ) --> [5, 9, 12, 21, 36]
②它可以接收一个比较函数来实现自定义，传入两个元素x，y，
如果x排在y的前面返回 -1，如果x排在y的后面返回 1，如果x和y相等，返回 0
# 自定义倒序排列
def f(s1, s2):
if s1 > s2:
return -1
if s1 < s2:
return 1
return 0
print sorted(['bob', 'about', 'zoo', 'credit'], f)
- 返回函数
函数不但可以返回int、str、list、dict等数据类型，还可以返回函数
def p1(l):
def p2():
def f(x, y):
return x * y
return reduce(f, l)
return p2
f = p1([1, 2, 3, 4])
print f()
- 闭包
闭包：内层函数引用了外层函数的变量，然后返回内层函数的情况
特点：返回的函数引用了外层函数的局部变量，所以要确保变量在函数返回后不能变
def count():
fs = []
for i in range(1, 4):
# 返回一个闭包g，g所引用的m不是循环变量
def f(m):
def g():
return m*m
return g
fs.append(f(i))
return fs
f1, f2, f3 = count()
print f1(), f2(), f3()
- 匿名函数
①关键字 lambda 表示匿名函数，冒号前面的 x 表示函数参数
匿名函数只能有一个表达式，不写return，返回值就是表达式的结果
②匿名函数不定义函数名，直接创建一个函数对象，很多时候可以简化代码
print map(lambda x: x * x, [1, 2, 3, 4])
- decorator装饰器
- 无参数decorator
①decorator 本质上是高阶函数，它接收一个函数作为参数，然后返回一个新函数
使用 decorator 用@语法，这样可以避免手动编写 f = decorate(f) 这样的代码
②可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用
import time
# 编写一个@Performance，打印出函数ABC()调用的时间
def Performance(f):
def P(*args, **kw):
t1 = time.time()
x = f(*args, **kw)
t2 = time.time()
print 'call %s () in %f s' % (f.__name__, (t2 - t1))
return x
return P
@ Performance
def ABC(x,y,z):
return x+y+z
print ABC(10,11,12)
- 带参数decorator
import time
def Performance(s):
def P1(f):
def P2(*args, **kw):
t1 = time.time()
x = f(*args, **kw)
t2 = time.time()
print 'call %s () in %f %s' % (f.__name__, (t2 - t1) * 1000, s)
return x
return P2
return P1
@ Performance('ms')
def ABC(x,y,z):
return x+y+z
print ABC(10,11,12)
- 偏函数
functools.partial 就是帮助我们创建一个偏函数的,
它可以把一个参数多的函数变成一个参数少的新函数，这样函数调用的难度就降低了
# 二进制转换十进制
def f(x, base=2):
return int(x, base)
print f('1000000')
第10章 模块
- 模块和包
①包 --> 文件夹
模块 --> xxx.py 文件
包里必须有 _init _.py 文件，以此来区分普通文件夹
②因为模块名也可能相同，把模块放入不同包即可避免冲突
- 导入模块
① math是Python自带的模块，导入后可以使用其中所有公开的函数、变量和类
② os.path是Python自带的模块，它的isdir() 和 isfile()函数可以判断目录和文件是否存在
③ from ... import * 这样导入，后面使用就可以省略模块名
import math
print math.pow(2, 0.5) # pow是函数
print math.pi # pi是变量
from os.path import *
print isdir(r'C:\Program Files')
print isfile(r'C:\123.txt')
- 动态导入模块
① 利用 import ... as ... 可以动态导入不同名称的模块
② try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句
③ Python2.7 提供了 json 模块，但 Python 2.5 以及更早版本没有 json 模块
只有 simplejson 模块，这两个模块功能一模一样
# 先尝试导入json，如果失败再 import simplejson as json
try:
import json
except ImportError:
import simplejson as json
print json.dumps({'python':2.7})
- 使用__future __
①Python 2 的整数除法结果仍是整数
Python 3 改进了整数除法运算，“ / ” 除将得到浮点数，“ // ” 除才是整数
②要在Python 2 中引入Python 3的除法规则，可以导入__future __的division
from __future__ import division
print 10 / 3
- 第三方模块
使用 Python 内置模块管理工具 pip 可以安装第三方模块
例如安装 web 模块，命令行输入 pip install web.py 即可
网友评论