Python基础教程第4-6章笔记

第四章

• 创建字典：
  d={‘key1’:’value1’,’key2’:’value2’}
  lst=[(‘key1’,’value1’),(‘key2’,’value2’)]; d=dict(lst)
  d=dict(key1=’value1’, key2=’value2’)

• 字典基本操作：

  • d={‘key1’:’value1’,’key2’:’value2’}; len(d) ==> 2 #字典中的键值对数量
  • d={‘key1’:’value1’,’key2’:’value2’}; d[‘key1’] ==> ‘value1’ # 键为k的值
  • d={‘key1’:’value1’,’key2’:’value2’}; d[‘key1’]=’NewValue’ ==> ‘key1’: ‘NewValue’ # 赋值
  • d={‘key1’:’value1’,’key2’:’value2’}; del d[‘key2’] ==> d={‘key1’: ‘value1’} #删除键为k的项
  • d={‘key1’:’value1’,’key2’:’value2’}; ‘key1’ in d ==> True #检查字典中是否有键k

• 字典的格式化字符串：
  dirction_name={‘key1’:’value1’,’key2’:’value2’};
  “%(key1)” % d dirction_name

• 字典方法：

  • d={‘key1’:’value1’,’key2’:’value2’}; d.clear() ==> d={} # 清除全部项

  • d={‘key1’:’value1’,’key2’:’value2’}; d.copy() # 复制

  • from copy import deepcopy; d={‘key1’:’value1’,’key2’:’value2’}; deepcopy(d) # 深度复制

  • {}.fromkeys([‘key1’,’key2’]) ==> {‘key2’: None, ‘key1’: None}
    或
    dict.fromkeys([‘key1’,’key2’])#创建字典

  • d={‘key1’:’value1’,’key2’:’value2’}; d.get(‘key1’) ==> ‘value1’ #获得值

  • d={‘key1’:’value1’,’key2’:’value2’}; d.has_key(‘key1’) ==> True #是否有该键

  • d={‘key1’:’value1’,’key2’:’value2’}; d.items() ==> [(‘key2’, ‘value2’), (‘key1’, ‘value1’)] # 全部项
    d={‘key1’:’value1’,’key2’:’value2’}; d.iteritems() # 迭代全部项

  • d={‘key1’:’value1’,’key2’:’value2’}; d.keys() ==> [‘key2’, ‘key1’] #全部键
    d={‘key1’:’value1’,’key2’:’value2’}; d.iterkeys() #迭代全部键

  • d={‘key1’:’value1’,’key2’:’value2’}; d.pop(‘key1’) ==>’value1’, d={‘key2’: ‘value2’} #移除并pop key1
    d={‘key1’:’value1’,’key2’:’value2’}; d.popitem() ==> (‘key2’, ‘value2’), d={‘key1’: ‘value1’} #随机移除一项

  • d={‘key1’:’value1’,’key2’:’value2’}; d.setdefault(‘key1’,’defaultValue1’) ==> ‘value1’ #类似于get，如果没有则设置缺省值

  • d={‘key1’:’value1’,’key2’:’value2’}; x={‘key2’:’UPDATE’}; d.update(x) ==> d={‘key2’: ‘UPDATE’, ‘key1’: ‘value1’} #用一个字典更新另一个字典

  • d={‘key1’:’value1’,’key2’:’value2’}; d.values() ==> [‘value2’, ‘value1’] #以列表形式返回字典中的全部值
    d={‘key1’:’value1’,’key2’:’value2’}; d.itervalues() # 返回全部值的迭代器

• len(d) #字典元素个数/长度

• 遍历字典：

    #!/usr/bin/python 
    dict={"a":"apple","b":"banana","o":"orange"} 

    print "##########dict######################" 
    for i in dict: 
            print "dict[%s]=" % i,dict[i] 

    print "###########items#####################" 
    for (k,v) in  dict.items(): 
            print "dict[%s]=" % k,v 

    print "###########iteritems#################" 
    for k,v in dict.iteritems(): 
            print "dict[%s]=" % k,v 

    print "###########iterkeys,itervalues#######" 
    for k,v in zip(dict.iterkeys(),dict.itervalues()): 
            print "dict[%s]=" % k,v

第五章

• print ‘AB’, 123 ==> AB 123 # 插入了一个空格
  print ‘AB’, ‘CD’ ==> AB CD # 插入了一个空格
  print 1,2,3 ==> 1 2 3
  print (1,2,3) ==> (1, 2, 3)

• 在脚本中以下ABCD连在一起输出
  print ‘AB’,
  print ‘CD’

• import somemodule #导入模块
  from somemodule import somefunction #导入函数
  from somemodule import function1,function2… #导入函数
  from somemodule import *

• module1.open() #使用模块中函数
  module2.open()

• import math as foobar #为模块提供别名
  foobar.sqrt(4)
  from math import sqrt as foobar #为函数提供别名
  foobar(4)

• 序列解包
  x,y,z=1,2,3; print x,y,z ==> 1 2 3
  x,y,z=1,2,3; x,y=y,z; print x,y ==> 2 3
  x=1,2,3; a,b,c=x; print a,b,c ==> 1 2 3
  d={‘key1’:’value1’,’key2’:’value2’}; key,value=d.popitem(); print key,value ==> key2 value2

• 链式赋值
  x=y=z={‘key1’:’value1’}; x is y ==> True
  x=y=z={‘key1’:’value1’}; x==y ==> True

• 增量赋值
  x+=1; x*=1;

• 可以用tab或空格分层缩进代码；推荐用四个空格来缩进。用Tab缩进更方便，比空格更快。
  ： 表示语句块的开始

• 布尔值：True, False, bool()
  这些被看为False： False, None, 0, “”, (), [], {}
  True==1 ==> True
  False==0 ==> True
  True+False+4 ==> 5
  所有值都可以用作布尔值：
  bool(‘ABC’) ==> True
  bool(”) ==> False
  bool(3) ==> True
  bool(0) ==> False

• if语句：
  if expression:
  block1
  else子句：
  if expression:
  block1
  else:
  block2
  elif子句
  if expression1:
  block1
  elif expression2:
  block2
  else:
  block3

• 比较运算符
  x==y 相等运算符
  x!=y 不相等运算符
  x is y 同一性运算符
  x is not y
  x in y 成员资格运算符
  x not in y

• 0 < age < 100 # python可以这样用

• 相等运算符
  ‘ab’==’ab’ ==> True
  ‘ab’==’cd’ ==> False
  12==34 ==> False

• ==是判断相等性，is是判断同一性
  x=y=[1,2]; x==y ==> True
  x=y=[1,2]; x is y ==> True
  x=y=[1,2]; z=[1,2]; x is z ==> False
  x=y=[1,2]; z=[1,2]; x==z ==> True

• 字符串比较按字母顺序比较 ，序列也是
  ‘ABC’<’ABC’ ==> False
  [1,2]<[2,1] ==> True

• 布尔运算符：
  and, or, not

• 断言
  age=-1; assert 0 < age < 100, ‘NOTE’
  Traceback (most recent call last):
  File ” < pyshell#21 > “, line 1, in < module >
  age=-1; assert 0 < age < 100, ‘NOTE’
  AssertionError: NOTE

• while expression:
  block

• for item in itemset:
  block

• range函数包含下限，不包含上限；
  range(0,3) ==> [0, 1, 2]
  range(3) ==> [0, 1, 2]

• 遍历字典
  d={‘key1’:’value1’,’key2’:’value2’};
  for key in d:
  print key,d[key]
  或
  for key,value in d.items():
  print key,value

• 并行迭代
  a=[1,2,3]; b=[‘a’,’b’,’c’]; zip(a,b) ==> [(1, ‘a’), (2, ‘b’), (3, ‘c’)]

• 编号迭代
  for index, string in enumerate(strings):
  if ‘xxx’ in string:
  strings[index]=’NewValue’

• 反转和排序迭代
  sorted([3,1,2]) ==> [1, 2, 3]
  x=[1,2,3]; list(reversed(x)) ==> [3, 2, 1] # reversed返回可迭代对象

• break结束循环
  continue进行下一次循环

• while true和break:
  while True:
  block1
  if expression:
  break
  block2

• 循环中的else子句：
  for item in items:
  block1
  if expression:
  break
  block2
  else:
  block3 # 当for执行完毕，并且没有执行过其中的break，此时执行block3

• 列表推导式
  [x*x for x in range(3)] ==> [0, 1, 4]
  [x*x for x in range(3) if x%2==0] ==> [0, 4]
  [(x,y) for x in range(3) for y in range(3)] ==> [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

• pass # 占位符，类似于空语句
  del # 删除对象
  exec # 执行一个字符串
  exec “print ‘ABC’” ==> ABC
  from math import sqrt; scope={}; exec ‘sqrt=1’ in scope; sqrt(4); scope[‘sqrt’];

• eval 求值，类似于 exec
  eval(raw_input(“”))
  1+1
  2

• scope={}; scope[‘x’]=2; scope[‘y’]=3; eval(‘x*y’,scope) ==> 6

第六章

• 创建函数：
  def function_name(params):
  block
  return values

• 记录函数：
  def function_name(params):
  ‘NOTE’ #注释
  block
  return values

• function_name.doc
  help(function_name)

• return # 没有返回值

• 位置参数和关键字参数：
  关键字参数要提供参数的名字：
  def function_name(name1=value1, name2=value2): #给参数提供了默认值
  block
  return values

• 让用户提供任意数量的参数：
  def function_name(*params):
  block
  return values

• def print_params(*params): #定义函数
  print params

• print_params(1,2,3) #调用函数

• 处理关键字参数的收集：
  def function_name(**params):
  block
  return values

• def print_params(**params): #定义函数
  print params

• print_params(x=1,y=2,z=3) #调用函数

• def add(x,y): return x+y
  params=(1,2)
  add(*params)

• 使用全局变量
  globals()[‘param_name’]
  locals()[‘param_name’]
  global x

• map() 将序列中的元素全部传递给一个函数
  map(str, range(10))
  filter(func, seq)
  lambda表达式
  filter(lambda x: x.isalnum(), seq)
  reduce() 将序列的前两个元素与给定的函数联合使用，并且将它们的返回值和第3个元素继续联合使用，直到整个序列都处理完。