判断空值
基本判断
print('在Python中，False,0,'',[],{},()都视为假，因此可以直接进行逻辑运算。此方法效率最高。')
if a:
print('调用len方法，查看元素个数是否为0。此方法效率较低。')
if len(a) == 0:
if x is None:
if not x:
if not x is None:
a = []
print(bool(a)) # False
print('让解释器再生成一个空列表，并将这个空列表与list_temp进行比较。此方法效率最低。')
if not list_temp == []:
if not x这种写法的前提是：必须清楚x等于None, False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()时对你的判断没有影响才行
foo is None 和 foo == None的区别:
如果比较相同的对象实例，is总是返回True，而 == 最终取决于 “eq()”
==只要相等，is表明要一样，同一个对象
None,空列表[],空元组(),空字典{},0都是被程序判断为False
使用any判断
eth = {"eth0″:"192.168.1.1″}
any(eth)
# True
eth = {}
any(eth)
# False
numpy
pandas 空值定义为numpy.nan
对整体的series或Dataframe判断是否未空，用pd.isnull(data)
对单独的某个值判断，可以用 np.isnan(data)
也可以用arrayName.length
np.nan不是空对象，np.nan的数据类型是float。
对列表中的nan进行操作时不能用"==np.nan"来判断。只能用np.isnan()来操作
np.isnan(data)
# array([False, False, False, True, False, True], dtype=bool)
# 这样可以获得nan的数量
np.isnan(data).sum()
aa[np.isnan(aa)] = 100 #对nan的值赋值为100
显示比较
# 都是用来创建空列表
a = []
b = list()
print(a == b) # True
if len(a) == 0:
print("The list is empty")
# 合并检查表达式之前
if isinstance(a, list) and len(a) > 0:
print("Processing list...")
# 之后
if a:
print("Processing list...")
隐式求值遵循的策略是：将空列表求值为布尔值的 False ，将有元素填充的列表求值为布尔值的 True 。
基本数组
list[]可变序列
a = []
a=[1]*n # 生成相同元素的数组
a_list = list(range(100)) # 很方便地创建一个0到99的列表
del list1[2] # 删除元素
len([1, 2, 3]) # 3 长度
type(a)
[1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6] 组合
a_list = a_list + [2.0,3] # 列表较长时，可能会消耗大量内存
concatenation添加。它添加的是另外一个列表，两个列表组合成一个新的列表：
append方法添加。它在原列表末尾添加一个item，item类型可以是任意的：
list.append('Google') ## 使用 append() 添加元素
extend方法添加。它类似于concatenation，只接受列表参数，并把列表中的item分解，然后添加到原有的列表：
a_list.extend('hello') //在原有列表末尾添加5个字符item，因为它把hello视为列表
a_list.extend(['hello']) //在原有列表末尾添加1个item
list.extend(seq) # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
insert方法添加。在原有列表中插入item：
list.insert(index, obj) # 将对象插入列表
删除item，三种方式：del、remove、pop，后两种方式都是列表的方法。
示例列表：a_list = ['a','b','c','hello']：
del删除。它按item的索引值或切片进行删除：
del a_list[0] //删除列表的第一个值
del a_list[:2] //删除列表的前两个值。（为什么不是前三个呢？因为Python的列表切片，包含前一个索引，但不包括后一个索引）
remove方法删除。它不按item索引，而是按照item的值进行删除：
a_list.remove('a') //把a在列表中的第一个匹配项从列表中删除
pop方法删除。它按item索引值进行删除，同时返回被删除的item值；若不指定索引，默认删除最后一个item：
a_list.pop(1) //删除列表的第二个值，并返回被删除的值
a_list.pop() //删除列表的最后一个值，并返回被删除的值
list.pop([index=-1]) # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
重新赋值item，对指定索引使用assignment符号进行赋值：
示例列表：a_list = ['a','b','c','hello']：
a_list[1] = 'bbb' //列表的第二个值b，将被替换为bbb
颠倒列表的item顺序，reverse方法：
示例列表：a_list = ['a','b','c','hello']：
a_list.reverse() //列表的item顺序将被从后到前重新排列，更改为['hello','c','b','a']
检索列表的值，四种方式：in、not in、count、index，后两种方式是列表的方法。
示例列表：a_list = ['a','b','c','hello']：
'a' in a_list //判断值a是否在列表中，并返回True或False
'a' not in a_list //判断a是否不在列表中，并返回True或False
a_list.count('a') //返回a在列表中的出现的次数
查看指定值在列表中的位置，index方法：
a_list.index('a') //返回a在列表中第一个匹配项的索引位置，默认搜索整个列表
a_list.index('a',0,3) //返回a在指定切片内第一次出现的位置
3 in [1, 2, 3] # True 元素是否存在于列表中
for x in [1, 2, 3]: print x, # 1 2 3 迭代
cmp(list1, list2) # 比较两个列表的元素
max(list) # 返回列表元素最大值
list(seq) # 将元组转换为列表
list.sort(cmp=None, key=None, reverse=False)# 对原列表进行排序
split方法。写一个字符串，字符之间以空格分隔，然后对该字符串使用split方法。
a_list = 'a b c d e f g'.spit() //创建列表['a','b','c','d','e','f','g']
[[0 for col in range(cols)] for row in range(rows)] # 创建一个有规律的二维列表
[x for x in arr if x>5 ] #筛选
[x if x>5 else x+100 for x in arr ]
[x if z else y for x,y,z in zip(arr1,arr2,condition)] #和np.where函数一样的功能；
tuple()不可变序列
tupl = ()
tup1 = (50,) #元组中只包含一个元素时，需要在元素后面添加逗号
tup1[0]
print "tup2[1:5]: ", tup2[1:5]
len(tupl) # 元素个数
type(图片里）
('Hi!',) * 4 # 复制
del list1[2] # 删除元素
tup3 = tup1 + tup2 # 可进行拼接
if x in (1, 2, 3): print x, #判断是否存在元素x
for x in (1, 2, 3): print x, #迭代
max(tupl)
min(tupl)
tulple(tupl)
cmp(tupl1, tupl2) #比较
tuple[0：10：3] #从0到9，步长为3.，取0,3,6，9
tuple01[：：3] #从头到为尾，步长为3
tuple01*2 #所有元素复制两倍
元组中的元素值是不允许修改的，禁止删除或添加元素，可以del删除整个元祖
任意无符号的对象，以逗号隔开，默认为元组
dict{}
字典的每个键值 key=>value对用冒号 : 分割，每个键值对之间用逗号，分割，整个字典包括在花括号 {} 中，键一般是唯一的，键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
a=[1]*n # 生成相同元素的数组
del list1[2] # 删除元素
# 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对，用[]和键进行修改或增加
str(dict) #输出字典可打印的字符串表示。
cmp(dict1, dict2)
len(dict)
type(variable) # 返回输入的变量类型，如果变量是字典就返回字典类型。
dict.clear() # 删除字典内所有元素
dict.copy() # 返回一个字典的浅复制
dict.fromkeys(seq[, val]) # 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None) # 返回指定键的值，如果值不在字典中返回default值
dict.has_key(key) # 如果键在字典dict里返回true，否则返回false
dict.items() # 以列表返回可遍历的(键, 值) 元组数组
dict.keys() # 以列表返回一个字典所有的键
dict.setdefault(key, default=None) # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2) # 把字典dict2的键/值对更新到dict里
dict.values() # 以列表返回字典中的所有值
pop(key[,default]) # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem() # 返回并删除字典中的最后一对键和值。
# 用 update 更新字典 a，会有两种情况：
# （1）有相同的键时：会使用最新的字典 b 中 该 key 对应的 value 值。
# （2）有新的键时：会直接把字典 b 中的 key、value 加入到 a 中。
dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2) ## 输出Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
dict.get(key, default=None)#（若没有值则返回默认值·· ）
dict = {'Name': 'Runoob', 'Age': 27}
print "Value : %s" % dict.get('Age') # Value : 27
print "Value : %s" % dict.get('Sex', "Never") # Value : Never
Numpy基础操作
基础
Numpy的主要数据类型是ndarray，即多维数组。它有以下几个属性：
ndarray.ndim：数组的维数
ndarray.shape：数组每一维的大小
ndarray.size：数组中全部元素的数量
ndarray.dtype：数组中元素的类型（numpy.int32, numpy.int16, and numpy.float64等）
ndarray.itemsize：每个元素占几个字节
import numpy as np
a = np.arange(15)
a = a.reshape(3, 5)
type(a) # <type 'numpy.ndarray'>
a.dtype.name # 'int64'
a.dtype # dtype('int64')
arr = arr.astype(np.int) #修改元素类型
b = np.array([(1.5,2,3), (4,5,6)]) # 由list生成ndarray
c = np.array( [ [1,2], [3,4] ], dtype=complex ) # 指定类型
np.zeros( (3,4) )
np.ones( (2,3,4), dtype=np.int16 )
np.empty( (2,3) ) # 随机数
np.arange( 10, 30, 5 ) # 最小值，最大值，步长（左闭右开）
np.linspace( 0, 2, 9 ) # 最小值，最大值，元素数量,等差数列
np.logspace(1,2,5,base=10) #从10**1到10**2的等比数列，5个数，不设base默认以e为底
# 维度变换
arr01 = np.random.randint(1,9,(3,4))
arr04.shape = (4,3) #先把3*4数组变成一维列表，再排成4*3数组
arr01 = np.random.randint(1,9,(3,4,5))
arr07.reshape(5,-1) #3*4*5维数组变成5*n
random
np.random.random( (2,3) ) #传入元祖，2*3数组，元素是0-1随机浮点数，返回类型是列表；
np.random.rand（2,3） #不传元祖,元素是0-1随机浮点数，2*3，
np.random.randn( 2,3 ) #不传元祖 ,元素是服从标准正态分布的随机样本，大部分在[-2,2]之间，2*3
np.random.randint(1,10,(2,3)) #1到9之间的随机整数，2*3
运算
两个二维使用*符号仍然是按位置一对一相乘，如果想表示矩阵乘法，使用dot
数组与标量运算，每个元素均与该标量进行运算
数组与数组运算，对应元素进行运算
当数组形状不一致时:要求就是B有一维是1，其他维和A一致,B和A低的维度形状相同
#A：2*3*4 与 B：2*1*4
a = np.array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]])
b = np.array([[[ 0, 1, 2, 3]],
[[ 8, 9, 10, 11]]])
print(a+b)
结果<<<
[[[ 0 2 4 6]
[ 4 6 8 10]
[ 8 10 12 14]]
[[ 8 10 12 14]
[12 14 16 18]
[16 18 20 22]]]
#A：2*3*4 与 B：3*4
c = [[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]
print(c+a)
结果<<<
[[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]]
[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]]]
print(b+c)
结果<<<
[[[ 0 2 4 6]
[ 4 6 8 10]
[ 8 10 12 14]]
[[ 8 10 12 14]
[12 14 16 18]
[16 18 20 22]]]
import numpy as np
# 内置函数（min,max,sum)，同时可以使用axis指定对哪一维进行操作：
b.sum(axis=0) # 按列计算和
b.min(axis=1) # 按行求最小值
b.cumsum(axis=1) # 按行迭代求和
<<<
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
结果：<<<
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
np.abs(b)
np.exp(b)
np.square(b)
np.sqrt(b)
np.add(a, b)
np.log(arr)
np.log2(arr)
np.log1p(arr) #分别计算自然对数、底数为2的log以及底数为e的log(1+x)
np.sign(arr) #计算各个元素的正负号: 1 正数，0：零，-1：负数
np.ceil(arr) #向上取整
np.floor(arr) #向下取整
np.rint(arr) #四舍五入
np.var( arr ) #求该arr方差 ，所有元素
np.arange(10)**3
结果：<<<array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
a[ : :-1] # 反顺序
def f(x,y):
return 10*x+y
b = np.fromfunction(f,(5,4),dtype=int)
结果<<<
c = np.array( [[[ 0, 1, 2], # a 3D array (two stacked 2D arrays)
[ 10, 12, 13]],
[[100,101,102],
[110,112,113]]])
c.shape #(2,2,3)
c[1, ...] # ...与c[1,:,:]与c[1]相同
for row in c: # 遍历各行
print(row)
for element in b.flat: # flat属性，这是一个遍历整个数组的迭代器
print(element)
索引
arr09 = np.random.randint(1,9,(3,3,4))
<<<
[[[7 1 2 2]
[4 3 6 6]
[7 2 2 2]]
[[1 6 4 8]
[2 1 5 8]
[4 1 8 8]]
[[4 6 6 8]
[7 2 3 7]
[1 3 4 1]]]
arr09[:,:,:] #全部，和arr09一样
arr09[1] #第二个3*4数组；
<<<
array([[1, 6, 4, 8],
[2, 1, 5, 8],
[4, 1, 8, 8]])
arr09[:,1] #3*4
<<<
array([[4, 3, 6, 6],
[2, 1, 5, 8],
[7, 2, 3, 7]])
arr09[:,:,1] #3*3
<<<
array([[1, 3, 2],
[6, 1, 1],
[6, 2, 3]])
arr10[:,:] = 100 #直接修改arr10数组元素的值
arr12[ [0,3,5] ] #返回第0，3,5行
arr12[[0,3,5],[0,1,2]] #返回第0行第0列，第3行第1列，第5行第2列的那个数组成的数组
arr12[np.ix_( [0,3,5] , [0,1,2] ) ] #有索引器，返回3*3，第0行第0列，第3行第1列，第5行第2列
arr12[arr12<5] # 输出符合条件的值，返回值为一维
arr12[ [True,False,False,False,False,True,False,False] ] # 返回的是二维度数组
<<<
array([[ 0, 1, 2, 3],
[20, 21, 22, 23]])
arr13.T #矩阵转置操作
arr = np.random.randint(1,9,(2,2))
np.tile(arr,3) #横向拉伸3次，同np.tile(arr, (1，3))
<<<
array([[4, 5, 1, 4, 5, 1, 4, 5, 1],
[1, 7, 6, 1, 7, 6, 1, 7, 6]])
np.tile(arr,(3,3)) #横向拉伸3次，纵向拉伸3次
<<<
array([[4, 5, 1, 4, 5, 1, 4, 5, 1],
[1, 7, 6, 1, 7, 6, 1, 7, 6],
[4, 5, 1, 4, 5, 1, 4, 5, 1],
[1, 7, 6, 1, 7, 6, 1, 7, 6],
[4, 5, 1, 4, 5, 1, 4, 5, 1],
[1, 7, 6, 1, 7, 6, 1, 7, 6]])
np.tile(arr, (3,1)) # 纵向拉伸3次 注意repeat和tile的区别
<<<
array([[4, 5, 1],
[1, 7, 6],
[4, 5, 1],
[1, 7, 6],
[4, 5, 1],
[1, 7, 6]])
np.repeat(arr,2, axis=1)
<<<
array([[4, 4, 5, 5, 1, 1],
[1, 1, 7, 7, 6, 6]])
arr = np.random.randint(1,9,(2,3))
arr.mean(axis = 0) #1*3
<<<array([6.5, 2.5, 3.5])
arr.mean(axis = 1) #2*1
<<<array([4.33333333, 4. ])
np.where([[True, False], [True, True]] , [[1, 2], [3, 4]] , [[9, 8], [7, 6]])
np.unique(arr) #去除重复元素，如果arr是多维的，返回一维的
pandas dataFrame
dataFrame是比ndarray多了行标，列标的数组
import pandas as pd
df = pd.DataFrame(index=[1,2,3],columns=[4,5,6])
数组转换
1.生成普通python数组(bytearray(),os.urandom())
randomByteArray = bytearray(os.urandom(120000))
2.转换成numpy数组(numpy.array())
flatNumpyArray = np.array(randomByteArray)
3.通过reshape将数组转换到所需的维数
grayImage = flatNumpyArray.reshape(300, 400)
PIL.Image，OpenCV，Numpy图像格式相互转换
扫一扫
746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
