Python进阶

**

Python进阶(一)-初识Python数据元素:列表&元组

**
  IDE：IntelJ。
  有关IntelJ的安装与注册详见博文《IntelliJ IDEA 2016注册方法和注册码》。
  下面介绍一下Python中几种不熟悉的数据元素：列表、元组、字典、时间。
1列表
1.1初始化列表
list=[‘physics’, ‘chemistry’, 1997, 2000];
1.2访问列表中的值
list[0]
1.3更新列表
nums[0]=“ljq”;
1.4删除列表元素
del nums[0];
1.5列表脚本操作符
  列表对+和的操作符与字符串相似。+号用于组合列表，号用于重复列表，例如：
print len([1, 2, 3]); #3
print [1, 2, 3] + [4, 5, 6]; #[1, 2, 3, 4, 5, 6]
print [‘Hi!’] * 4; #[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]
print 3 in [1, 2, 3] #True
for x in [1, 2, 3]: print x, #1 2 3
1.6列表截取
L=[‘spam’, ‘Spam’, ‘SPAM!’];
print L[2]; #‘SPAM!’
print L[-2]; #‘Spam’
print L[1:]; #[‘Spam’, ‘SPAM!’]
1.7列表函数&方法
list.append(obj) #在列表末尾添加新的对象
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) #从列表中找出某个值第一个匹配项的索引位置，索引从0开始
list.insert(index, obj) #将对象插入列表
list.pop(obj=list[-1]) #移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.remove(obj) #移除列表中某个值的第一个匹配项
list.reverse() #反向列表中元素，倒转
list.sort([func]) #对原列表进行排序
2元组(tuple)
  Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，
tup1 = (‘physics’, ‘chemistry’, 1997, 2000);
 创建空元组，例如：
tup = ();
  元组中只有一个元素时，需要在元素后面添加逗号，例如：
tup1 = (50,);
  元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
2.1访问元组
tup1 = (‘physics’, ‘chemistry’, 1997, 2000);
tup1[0]#physics
2.2修改元组
  元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:
tup1 = (12, 34.56);
tup2 = (‘abc’, ‘xyz’);
#以下修改元组元素操作是非法的。
tup1[0] = 100;
#创建一个新的元组
tup3 = tup1 + tup2;
print tup3; #(12, 34.56, ‘abc’, ‘xyz’)
2.3删除元组
  元组中的元素值是不允许删除的，可以使用del语句来删除整个元组，例如:
tup = (‘physics’, ‘chemistry’, 1997, 2000);
print tup;
del tup;
2.4元组运算符
  与字符串一样，元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

2.5元组索引&截取
L = (‘spam’, ‘Spam’, ‘SPAM!’);
print L[2]; #‘SPAM!’
print L[-2]; #‘Spam’
print L[1:]; #[‘Spam’, ‘SPAM!’]
2.6元组内置函数
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。
Python进阶(二)-初识Python数据元素:字典&时间
3字典
3.1字典简介
  字典(dic dictionary)是除列表之外python中最灵活的内置数据结构类型。 列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
  字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：
dict = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’};
  也可如此创建字典：
dict1 = { ‘abc’: 456 };
dict2 = { ‘abc’: 123, 98.6: 37 };
  每个键与值必须用冒号隔开(?，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
3.2访问字典里的值
dict = {‘name’: ‘Zara’, ‘age’: 7, ‘class’: ‘First’};
print "dict[‘name’]: ", dict[‘name’];
print "dict[‘age’]: ", dict[‘age’];
3.3修改字典
  向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。
如下实例:
dict = {‘name’: ‘Zara’, ‘age’: 7, ‘class’: ‘First’};
dict[“age”]=27; #修改已有键的值
dict[“school”]=“wutong”; #增加新的键/值对
print "dict[‘age’]: ", dict[‘age’];
print "dict[‘school’]: ", dict[‘school’];
del dict[‘name’]; # 删除键是’name’的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
• 注意：字典不存在，del会引发一个异常
3.5字典内置函数&方法
cmp(dict1, dict2) #比较两个字典元素。
len(dict) #计算字典元素个数，即键的总数。
str(dict) #输出字典可打印的字符串表示。
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。
clear() #删除字典内所有元素
copy() #返回一个字典的浅复制
fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
get(key, default=None) #返回指定键的值，如果值不在字典中返回default值
has_key(key) #如果键在字典dict里返回true，否则返回false
items() #以列表返回可遍历的(键, 值) 元组数组
keys() #以列表返回一个字典所有的键
setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
update(dict2) #把字典dict2的键/值对更新到dict里
values() #以列表返回字典中的所有值
4日期和时间
4.1获取当前时间
import time, datetime;
localtime = time.localtime(time.time())
print “Local current time :”, localtime
  说明：time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)属于struct_time元组，struct_time元组具有如下属性：

4.2获取格式化的时间
  可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
4.2.1日期转换为字符串
  首选：print time.strftime(‘%Y-%m-%d %H:%M:%S’);
  其次：print datetime.datetime.strftime(datetime.datetime.now(), ‘%Y-%m-%d %H:%M:%S’)
  最后：print str(datetime.datetime.now())[:19]
4.2.2字符串转换为日期
expire_time = “2013-05-21 09:50:35”
d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
print d;
4.2.3获取日期差
oneday = datetime.timedelta(days=1)
#今天，2014-03-21
today = datetime.date.today()
#昨天，2014-03-20
yesterday = datetime.date.today() - oneday
#明天，2014-03-22
tomorrow = datetime.date.today() + oneday
#获取今天零点的时间，2014-03-21 00:00:00
today_zero_time=datetime.datetime.strftime(today, ‘%Y-%m-%d %H:%M:%S’)
#0:00:00.001000
print datetime.timedelta(milliseconds=1), #1毫秒
#0:00:01
print datetime.timedelta(seconds=1), #1秒
#0:01:00
print datetime.timedelta(minutes=1), #1分钟
#1:00:00
print datetime.timedelta(hours=1), #1小时
#1 day, 0:00:00
print datetime.timedelta(days=1), #1天
#7 days, 0:00:00
print datetime.timedelta(weeks=1)
4.2.4获取时间差
#1 day, 0:00:00
oneday = datetime.timedelta(days=1)
#今天，2014-03-21 16:07:23.943000
today_time = datetime.datetime.now()
#昨天，2014-03-20 16:07:23.943000
yesterday_time = datetime.datetime.now() - oneday
#明天，2014-03-22 16:07:23.943000
tomorrow_time = datetime.datetime.now() + oneday
  注意时间是浮点数，带毫秒。
  那么要获取当前时间，需要格式化一下：
print datetime.datetime.strftime(today_time, ‘%Y-%m-%d %H:%M:%S’)
print datetime.datetime.strftime(yesterday_time, ‘%Y-%m-%d %H:%M:%S’)
print datetime.datetime.strftime(tomorrow_time, ‘%Y-%m-%d %H:%M:%S’)
4.2.5获取上个月最后一天
last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)
4.2.6字符串日期格式化为秒数
  返回浮点类型
expire_time = “2013-05-21 09:50:35”
d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
time_sec_float = time.mktime(d.timetuple())
print time_sec_float
4.2.7日期格式化为秒数
  返回浮点类型
d = datetime.date.today()
time_sec_float = time.mktime(d.timetuple())
print time_sec_float
4.2.8秒数转字符串
time_sec = time.time()
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))
Python进阶(三)-函数式编程之reduce()
  官方解释如下：
  Apply function of two arguments cumulatively to the items of sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the sequence. If the optional initializer is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty. If initializer is not given and sequence contains only one item, the first item is returned.
  格式： reduce (func, seq[, init()])
  reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果（注：第一次为init元素，如果没有指定init则为seq的第一个元素）与下一个元素一同传入二元func函数中去执行。在reduce()函数中，init是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取seq中的第一个元素。
举例
  有一个序列集合，例如[1,1,2,3,2,3,3,5,6,7,7,6,5,5,5],统计这个集合所有键的重复个数，例如1出现了两次，2出现了两次等。大致的思路就是用字典存储，元素就是字典的key,出现的次数就是字典的value。方法依然很多
第一种：for循环判断
def statistics(lst):
dic = {}
for k in lst:
if not k in dic:
dic[k] = 1
else:
dic[k] +=1
return dic
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]
print(statistics(lst))
第二种：比较取巧的，先把列表用set方式去重，然后用列表的count方法
def statistics2(lst):
m = set(lst)
dic = {}
for x in m:
dic[x] = lst.count(x)
return dic
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]
print statistics2(lst)
第三种：用reduce方式
def statistics(dic,k):
if not k in dic:
dic[k] = 1
else:
dic[k] +=1
return dic
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]
print reduce(statistics,lst,{})
#提供第三个参数，第一次，初始字典为空，作为statistics的第一个参数，然后遍历lst,作为第二个参数，然后将返回的字典集合作为下一次的第一个参数
或者
d = {}
d.extend(lst)
print reduce(statistics,d)
#不提供第三个参数，但是要在保证集合的第一个元素是一个字典对象，作为statistics的第一个参数，遍历集合依次作为第二个参数
  通过上面的例子发现,凡是要对一个集合进行操作的，并且要有一个统计结果的，能够用循环或者递归方式解决的问题，一般情况下都可以用reduce方式实现。

Python进阶(四)-浅谈Python闭包

在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：
def g():
print ‘g()…’
def f():
print ‘f()…’
return g
  将 g 的定义移入函数 f 内部，防止其他代码调用 g：
def f():
print ‘f()…’
def g():
print ‘g()…’
return g
  但是，考察定义的 calc_sum 函数：
def calc_sum(lst):
def lazy_sum():
return sum(lst)
return lazy_sum
  注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。
• 像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
  闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：

希望一次返回3个函数，分别计算1x1,2x2,3x3:

def count():
fs = [ ]
for i in range(1, 4):
def f():
return ii
fs.append(f)
return fs
f1, f2, f3 = count()
  你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。
  原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 ii，当 f1 被调用时：

f1()
9 # 因为f1现在才计算ii，但现在i的值已经变为3
  因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。
举例
  返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。
  考察下面的函数 f:
def f(j):
def g():
return jj
return g
  它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。
  在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。
  参考代码:
def count():
fs = []
for i in range(1, 4):
def f(j):
def g():
return j*j
return g
r = f(i)
fs.append®
return fs
f1, f2, f3 = count()
print f1(), f2(), f3()
程序实例

Python进阶(五)-浅谈python匿名函数
  高阶函数可以接收函数做参数，有些时候，我们不需要显式地定义函数，直接传入匿名函数更方便。
  在Python中，对匿名函数提供了有限支持。还是以map()函数为例，计算 f(x)=x2 时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]
  通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：
def f(x):
return x * x
• 关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
  匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。
  使用匿名函数，可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码：

sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y))
[9, 5, 3, 1, 0]
  返回函数的时候，也可以返回匿名函数：

myabs = lambda x: -x if x < 0 else x
myabs(-1)
1

myabs(1)
1
举例
  利用匿名函数简化以下代码：
def is_not_empty(s):
return s and len(s.strip()) > 0
filter(is_not_empty, [‘test’, None, ‘’, ‘str’, ’ ', ‘END’])
  定义匿名函数时，没有return关键字，且表达式的值就是函数返回值。
参考代码:
print filter(lambda s: s and len(s.strip())>0, [‘test’, None, ‘’, ‘str’, ’ ', ‘END’])

Python进阶(六)-python编写无参数decorator

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
  使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。
  考察一个@log的定义：
def log(f):
def fn(x):
print 'call ’ + f.name + ‘()…’
return f(x)
return fn
  对于阶乘函数，@log工作得很好：
@log
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)
  结果：
  call factorial()…
  3628800
  但是，对于参数不是一个的函数，调用将报错：
@log
def add(x, y):
return x + y
print add(1, 2)
  结果：
  Traceback (most recent call last):
   File “test.py”, line 15, in
   print add(1,2)
  TypeError: fn() takes exactly 1 argument (2 given)
  因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。
  要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：
def log(f):
def fn(*args, **kw):
print 'call ’ + f.name + ‘()…’
return f(*args, **kw)
return fn
  现在，对于任意函数，@log 都能正常工作。
举例
  请编写一个@performance，它可以打印出函数调用的时间。
  计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。
  参考代码:
import time
def performance(f):
def fn(*args, **kw):
t1 = time.time()
r = f(*args, **kw)
t2 = time.time()
print ‘call %s() in %fs’ % (f.name, (t2 - t1))
return r
return fn

@performance
def factorial(n):
return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)