可变与不可变
- 大部分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