python进阶(1)--常用语法糖

最新推荐文章于 2024-04-24 09:40:00 发布

Aurora-zjx

最新推荐文章于 2024-04-24 09:40:00 发布

阅读量690

点赞数

分类专栏： torch python进阶文章标签： python numpy 开发语言

本文链接：https://blog.csdn.net/zyczjx/article/details/127047614

版权

torch python进阶专栏收录该内容

4 篇文章 0 订阅

订阅专栏

python常用函数

axis

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1LUIKe8D-1664155805928)(https://xfmtfq43fp.feishu.cn/space/api/box/stream/download/asynccode/?code=NTM1ZTM5YTczYzQ1MjRiMWNlMzgxNGMwNWJlYzFlYjVfaHBvcHBBb3JMb2ZjRTF5VjAyeTh4OEt4Ujd6S1FjWnJfVG9rZW46Ym94Y25UYUtXcWhtc09Ta0lwZWxnSHg1UmhnXzE2NjQxNTU2Mjg6MTY2NDE1OTIyOF9WNA)]

axis=0为跨行处理 axis=1为跨列处理

>>>x = np.arange(6)
>>>x = x.reshape(2,3)
>>>print(x)
max = np.max(x, axis=1)
[[0 1 2]
 [3 4 5]]
>>>max
array([2, 5])

filter

筛选list中满足条件的元素

## 返回的是迭代器对象，需要通过list将迭代器对象转换为列表
ret = filter(lambda x: x%2 == 0,range(10))   
print(list(ret))

[0,2,4,6,8]

Map

## 接收一个func和一个list，并将func依次作用在list的每个元素上，得到一个新的list并返回
##seq只有一个
map(lambda x: x*x , [1, 2, 3, 4, 5])
#[1, 4, 9, 10, 25]


##seq有多个(也就是func有多个参数，可以接收相应序列中的每个元素）
t=map(lambda x,y:(x**y,x+y),[1,2,3],[1,2,4])
for i in t:
     print(i)
#(1, 2)
#(4, 4)
#(81, 7)

all和any

>>> nl=list(range(2,5))
>>> print(all(n>=2 for n in nl))
True
>>> print(all(n>=3 for n in nl))
False
>>> print(any(n>=3 for n in nl))
True

Sorted

##对列表本身进行了更改
sorted(iterable, key=None, reverse=False)

##参数
#reverse：排序规则，reverse = True 表示降序，reverse = False 表示升序，默认值是按照升序排序
#key：key参数接受一个函数，该函数只有一个参数，参数是列表项，也就是说，key参数用于在进行比较之前指定在每个列表元素上要调用的函数

list = [('d',3),('a',5),('d',1),('c',2),('d',2)]
>>> sorted(list,key=lambda x:x[1])   ##按照第二列元素排序
[('d', 1), ('c', 2), ('d', 2), ('d', 3), ('a', 5)]

>>> sorted(list, key = lambda x:(x[0],x[1]))
[('a', 5), ('c', 2), ('d', 1), ('d', 2), ('d', 3)]

Zip

##把对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
##利用*，可以将元组解压为列表
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

####
zipped = zip(a,b)  #压缩
*zipped #解压
*zip() #变为压缩前

Reduce

reduce(function, iterable[, initializer])
##用于迭代运算，func（有两个参数） iterable（可迭代对象） initializer（初始参数）（可选）
>>> reduce(lambda x,y:x+y,[1,2,3,4],1)
11
>>> reduce(lambda x,y:x+y,[1,2,3,4])
10

random.sample

import random
my_list = ['a', 'b', 'c', 'd', 'e']
num_samples = 2
samples = random.sample(my_list,num_samples)

print

print('The value of PI is approximately {0:.3f}.'.format(math.pi))
## 格式
%c 字符及其ASCII码
%s 字符串
%d 有符号整数(十进制)
%u 无符号整数(十进制)
%o 无符号整数(八进制)
%x 无符号整数(十六进制)
%X 无符号整数(十六进制大写字符)
%e 浮点数字(科学计数法)
%E 浮点数字(科学计数法，用E代替e)
%f 浮点数字(用小数点符号)
%g 浮点数字(根据值的大小采用%e或%f)
%G 浮点数字(类似于%g)
%p 指针(用十六进制打印值的内存地址)
%n 存储输出字符的数量放进参数列表的下一个变量中

Type、isinstance

#type（输出类型）
#isinstance（返回布尔值）

transpose

>>>A = np.arange(48)
>>>A = A.reshape(2, 4, 6)
>>>print(A.shape)
(2, 4, 6)
>>>B = A.transpose(2, 1, 0)
>>>print(B.shape)
(6, 4, 2)

[::-1]

import numpy as np
a=np.random.rand(5)
print(a)
[ 0.64061262  0.8451399   0.965673    0.89256687  0.48518743]
 
print(a[-1]) ###取最后一个元素
[0.48518743]
 
print(a[:-1])  ### 除了最后一个取全部
[ 0.64061262  0.8451399   0.965673    0.89256687]
 
print(a[::-1]) ### 取从后向前（相反）的元素
[ 0.48518743  0.89256687  0.965673    0.8451399   0.64061262]
 
print(a[2::-1]) ### 取从下标为2的元素翻转读取
[ 0.965673  0.8451399   0.64061262]

转置二维数组

transpose = zip(*original)
print(list(transpose))

实现二维矩阵的翻转

plt.imshow(Image) # 原始图像, 第三个维度是RGB通道
Image2 = Image[::-1, :, :]  # 垂直方向翻转
Image3 = Image[:, ::-1, :]  # 水平方向翻转

寻找最大值最小值索引

#最大值索引
minIndex(list)
#最小值索引
maxIndex(list)

遍历

#遍历列表
y = [x for x in range(10)] 
#遍历字典
y = [value for key, value in d.items()]

匿名函数lambda

add = lambda x, y: x + y
print(add(3, 5))

推导式

#列表推导式
[x if x % 2 == 0 else -x for x in range(1, 11)]
#字典推导式
{k:v for k,v in mcase.items()}
#集合推导式
{x**2 for x in [1, 1, 2]}

##生成器推导式
array = (i for i in in_list if i % 2 != 0)

迭代器

#只要有方法__iter__和__getitem__就是可迭代对象(iterable)
#迭代器(iterator)被定义了__next__的python对象
isinstance([1, 2, 3], Iterable)
isinstance(iter([1, 2, 3]), Iterator)

生成器

生成器与迭代器不同的是并没有把所有值存储在内存中，是边循环边生成值

g = (x * x for x in range(10))#只迭代一次，只存储算法，不会生成所有元素存储于内存。
for i in g:#for循环打印每个生成器中元素，在执行输出nothing（只迭代一次，只存储算法）
    print(i)
 
 ##带yield的为一个生成器

装饰器

https://zhuanlan.zhihu.com/p/534579040

随机打乱某一维度所有数据

# 比如打乱数据的第一个维度
import random
import numpy as np
feat = np.arange(24).reshape(2, 4, 3)
index = random.sample(range(0, feat.size(1)), img_feat.size(1))
feat_x = feat[:, index, :]
print(feat)
print(feat_x)

可更改(mutable)与不可更改(immutable)对象

不可更改对象：strings、tuples、numbers（类似于C++的值传递）
可更改对象：list、dict（类似于C++的引用传递）
python中的一切都是对象，严格意义上不能说是值传递or引用传递，只能说是不可变对象or可变对象
le(range(0, feat.size(1)), img_feat.size(1))
feat_x = feat[:, index, :]
print(feat)
print(feat_x)


### 可更改(mutable)与不可更改(immutable)对象

- 不可更改对象：strings、tuples、numbers（类似于C++的值传递）

- 可更改对象：list、dict（类似于C++的引用传递）

- python中的一切都是对象，严格意义上不能说是值传递or引用传递，只能说是不可变对象or可变对象