发表于 | Edited on | 分类于 | 评论数：

Python功能函数整理

系统函数

open()

1简单的文件读写

1
2
3
4
5
6
7
8
9
f = open("123.txt", "r");
content = f.read();
print(content);
f.close();

f = open("123.txt", "a+");
f.write("\n");
f.write("222222222222");
f.close();

2读取数据到矩阵

1
2
3
4
5
6
7
8
9
10
11
12
#读取txt二维数据到矩阵
def loadDataSet(fileName):    
    dataMat = np.mat([0,0])               
    f = open(fileName)
    for line in f.readlines():
        curLine = line.strip().split('\t')
        if len(curLine)==1 : 
            continue
        curLineMat = np.mat(curLine)
        dataMat = np.vstack((dataMat, curLineMat))  #拼接矩阵
    dataMat = dataMat[1:,:].astype(float)   #不要第一行；转为纯数字
    return dataMat

os.getcwd()

获得当前工作目录

1
2
import os
print os.getcwd()

set()

将一个字符串拆成 单个字符 组成的字符集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

1
2
3
4
5
6
7
>>> x = set('runoob') 
>>> y = set('google') 
>>> x, y (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除 
>>> x & y # 交集 set(['o']) 
>>> x | y # 并集 set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u']) 
>>> x - y # 差集 set(['r', 'b', 'u', 'n']) 
>>>

copy()

  1. = 赋值 传引用 =》内存不独立 =》 同步跟随变化
  2. copy 浅拷贝 只拷贝父对象 =》父对象内存独立 =》只有子对象跟随变化
  3. deepcopy 深拷贝 拷贝对象及其子对象 =》全部内存独立 =》 不跟随变化
    （深拷贝 和 浅拷贝——只对数组结构有用，int之类的没用）
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    a = [1, 2, 3, 4, ['a', 'b']] #原始对象
     
    b = a #赋值，传对象的引用
    c = copy.copy(a) #对象拷贝，浅拷贝
    d = copy.deepcopy(a) #对象拷贝，深拷贝
     
    a.append(5) #修改对象a
    a[4].append('c') #修改对象a中的['a', 'b']数组对象
     
    print 'a = ', a
    print 'b = ', b
    print 'c = ', c
    print 'd = ', d
    输出结果：
    a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
    b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
    c =  [1, 2, 3, 4, ['a', 'b', 'c']]
    d =  [1, 2, 3, 4, ['a', 'b']]

zip()

zip函数接受任意多个序列作为参数，返回一个tuple列表

1
2
3
4
5
6
7
8
9
10
11
12
print(zip(range(3),range(5)))
[(0, 0), (1, 1), (2, 2)]

for i,j in zip(range(3),range(5)):
    print(i)
    print(j)
0
0
1
1
2
2

运算符and和or

注意：and or 是python特有的短路运算符

  1. 表达式从左至右运算，若 or 的左侧逻辑值为 True ，则短路 or 后所有的表达式（不管是 and 还是 or），直接输出 or 左侧表达式 。
  2. 表达式从左至右运算，若 and 的左侧逻辑值为 False ，则短路其后所有 and 表达式，直到有 or 出现，输出 and 左侧表达式到 or 的左侧，参与接下来的逻辑运算。
  3. 若 or 的左侧为 False ，或者 and 的左侧为 True 则不能使用短路逻辑。

自定义功能函数

随机生成一组字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import random
seed = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

def function1():
    random_str_list = []
    for i in range(6):
        char = ramdom.choice(seed)
        random_str_list.appen(char)
    return ''.join(random_str_list)

def function2():
    random_str = ''.join([n for n in random.sample(seed,5)])
    return random_str

print(random_str)
꧁༺The༒End༻꧂