py学习笔记（2）

可变与不可变

• 大部分Python对象是可变的

a = 5
a = 6
print a

输出：
6

• 字符串和元组是不可变的

str = 'Hello ChinaHadoop'
str[-1] = '!'

输出：

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-2-fadf611d2a1a> in <module>()
      1 str = 'Hello ChinaHadoop'
----> 2 str[-1] = '!'


TypeError: 'str' object does not support item assignment

tup = (1,2,3)
tup[0] = 2

---------------------------------------------------------------------------

输出：

TypeError                                 Traceback (most recent call last)

<ipython-input-4-e71030bca61d> in <module>()
      1 tup = (1,2,3)
----> 2 tup[0] = 2


TypeError: 'tuple' object does not support item assignment

字符串

• 三重引号 (“”” “”“)

def print_info():
    """
        This is a function for information print
    """
    print 'Hello ChinaHadoop'

print_info?

• 字符串格式化 (%)

print '%d %s cost me $%.2f.' %(2, 'books', 21.227)

输出：
2 books cost me $21.23.

类型转换

s_val = '3.1415926'
print 'string value: %s' %s_val
f_val = float(s_val)
print 'float value: %f' %f_val
i_val = int(f_val)
print 'int value: %i' %i_val

输出：
string value: 3.1415926
float value: 3.141593
int value: 3

常用序列函数

• enumerate ， for循环时记录索引，逐个返回元组（i, item）
• sorted 返回新的有序列表，区别：list中的sort（）是就地排序 sorted 返回一个序列(列表)对象
• zip “压缩”将多个无需的对应位置的元素组成元组
• zip（*元组列表） “解压缩”，zip的逆操作
  关于zip的相关知识可以参考这里
• reversed 逆序迭代， 可配合list返回逆序列表

a = [5,2,1,9,6]        

>>> sorted(a)                  #将a从小到大排序,不影响a本身结构 
[1, 2, 5, 6, 9] 

>>> sorted(a,reverse = True)   #将a从大到小排序,不影响a本身结构 
[9, 6, 5, 2, 1] 

>>> a.sort()                   #将a从小到大排序,影响a本身结构 
>>> a 
[1, 2, 5, 6, 9] 

>>> a.sort(reverse = True)     #将a从大到小排序,影响a本身结构 
>>> a 
[9, 6, 5, 2, 1] 

注意，a.sort() 已改变其结构，b = a.sort() 是错误的写法! 

>>> b = ['aa','BB','bb','zz','CC'] 
>>> sorted(b) 
['BB', 'CC', 'aa', 'bb', 'zz']    #按列表中元素每个字母的ascii码从小到大排序,如果要从大到小,请用sorted(b,reverse=True)下同 

>>> c =['CCC', 'bb', 'ffff', 'z']  
>>> sorted(c,key=len)             #按列表的元素的长度排序 
['z', 'bb', 'CCC', 'ffff'] 

>>> d =['CCC', 'bb', 'ffff', 'z'] 
>>> sorted(d,key = str.lower )    #将列表中的每个元素变为小写，再按每个元素中的每个字母的ascii码从小到大排序 
['bb', 'CCC', 'ffff', 'z'] 

>>> def lastchar(s): 
       return s[-1] 
>>> e = ['abc','b','AAz','ef'] 
>>> sorted(e,key = lastchar)      #自定义函数排序,lastchar为函数名，这个函数返回列表e中每个元素的最后一个字母 
['b', 'abc', 'ef', 'AAz']         #sorted(e,key=lastchar)作用就是 按列表e中每个元素的最后一个字母的ascii码从小到大排序 

>>> f = [{'name':'abc','age':20},{'name':'def','age':30},{'name':'ghi','age':25}]     #列表中的元素为字典 
>>> def age(s): 
       return s['age'] 
>>> ff = sorted(f,key = age)      #自定义函数按列表f中字典的age从小到大排序  

[{'age': 20, 'name': 'abc'}, {'age': 25, 'name': 'ghi'}, {'age': 30, 'name': 'def'}] 

>>> f2 = sorted(f,key = lambda x:x['age'])    #如果觉得上面定义一个函数代码不美观，可以用lambda的形式来定义函数,效果同上 

此段摘自 http://wangwei007.blog.51cto.com/68019/1100742

时间和日期

• datatime模块

from datetime import datetime
dt = datetime(2016, 12, 3, 15, 0, 0)
print dt.month, dt.day

输出： 12 3

• strftime将datetime类型格式化为字符串

dt.strftime('%Y/%m/%d %H:%M')

输出： ‘2016/12/03 15:00’

dt.strftime('%d/%m/%Y %H:%M')

输出： ‘03/12/2016 15:00’

• strptime将字符串解析为datetime类型

datetime.strptime('20161203', '%Y%m%d')

输出： datetime.datetime(2016, 12, 3, 0, 0) #如果这里有时分， 会显示出来

for循环 continue, break

l = range(20) # [0, 1, 2, ..., 19]
for i in l:
    if i%2 == 0:
        continue
    if i == 15:
        break
    print i

输出：
1
3
5
7
9
11
13

while循环

i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print sum

输出：  5050

pass

def f():
    #TODO: test pass
    pass

处理异常

def divide(x, y):
    """
        do division
    """
    try:
        return x/y
    except:
        return 'error happens'

print divide(8,2)
print divide('8', 2)

输出：
4
error happens

range 和 xrange

range(1, 20, 2)

输出： [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

xrange(1, 20, 2)

输出： xrange(1, 21, 2)

注意： xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。

关于Python中的引用

• 变量传递

a = 5
b = a
a = 3
print a
print b

输出：
3
5

def fun1(a):
    a = 2
    print a

b = 3

fun1(b)
print b

输出：
2
3

• 列表传递

l_1 = [1, 2, 3]
l_2 = l_1
l_1.append(4)
print l_1
print l_2

输出：
[1, 2, 3, 4]
[1, 2, 3, 4]

def fun2(lst):
    lst[0] = 5
    print lst

lst1 = range(5)
print lst1

fun2(lst1)
print lst1

输出：
[0, 1, 2, 3, 4]
[5, 1, 2, 3, 4]
[5, 1, 2, 3, 4]

• 浅拷贝 和 深拷贝

import copy

a = [[1, 2, 3], [4, 5, 6]]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)

print 'a-id:', id(a)
print 'b-id:',id(b)
print 'c-id:',id(c)
print 'd-id:',id(d)

a.append(15)
a[1][2] = 10

print 'processed...'
print a
print b
print c
print d

输出：
a-id: 66053768
b-id: 66053768
c-id: 66621832
d-id: 66112456
processed…
[[1, 2, 3], [4, 5, 10], 15]
[[1, 2, 3], [4, 5, 10], 15]
[[1, 2, 3], [4, 5, 10]]
[[1, 2, 3], [4, 5, 6]]
关于深浅拷贝比较深入的理解可以看这边文章
↓↓↓↓↓↓
http://blog.csdn.net/bestallen/article/details/53573807