标签: slice

在以下示例中:

foo = ['red', 'white', 'blue', 1, 2, 3]

其中:foo[0:6:1]将打印foo中的所有元素.但是,foo[6:0:-1]将省略第1或第0个元素.

>>> foo[6:0:-1]
[3, 2, 1, 'blue', 'white']

我知道我可以使用foo.reverse()或foo [:: - 1]反向打印列表,但我试图理解为什么foo [6:0:-1]不打印整个列表？

有没有办法只切片列表中的第一个和最后一个项目？

例如; 如果这是我的清单:

>>> some_list
['1', 'B', '3', 'D', '5', 'F']

我想这样做(显然[0,-1]是无效的语法):

>>> first_item, last_item = some_list[0,-1]
>>> print first_item
'1'
>>> print last_item
'F'

我试过的一些事情:

In [3]: some_list[::-1]
Out[3]: ['F', '5', 'D', '3', 'B', '1']

In [4]: some_list[-1:1:-1]
Out[4]: ['F', '5', 'D', '3']

In [5]: some_list[0:-1:-1]
Out[5]: []
...

有没有办法检查切片/贴图是否存在值？

我想仅在切片中不存在切片时才向切片添加值.

这有效,但似乎很冗长.有没有更好的方法来做到这一点？

orgSlice := []int{1, 2, 3}
newSlice := []int{}
newInt := 2

newSlice = append(newSlice, newInt)
for _, v := range orgSlice {
    if v != newInt {
        newSlice = append(newSlice, v)
    }
}

newSlice == [2 1 3]

我试图在某个字符之前打印字符串的最后一部分.

我不太确定是否使用字符串.split()方法或字符串切片或其他东西.

这是一些不起作用的代码,但我认为显示逻辑:

x = 'http://test.com/lalala-134'
print x['-':0] # beginning at the end of the string, return everything before '-'

请注意,末尾的数字会有所不同,因此我无法从字符串末尾设置精确计数.

代码示例:

In [171]: A = np.array([1.1, 1.1, 3.3, 3.3, 5.5, 6.6])

In [172]: B = np.array([111, 222, 222, 333, 333, 777])

In [173]: C = randint(10, 99, 6)

In [174]: df = pd.DataFrame(zip(A, B, C), columns=['A', 'B', 'C'])

In [175]: df.set_index(['A', 'B'], inplace=True)

In [176]: df
Out[176]: 
          C
A   B      
1.1 111  20
    222  31
3.3 222  24
    333  65
5.5 333  22
6.6 777  74 

现在,我想要检索A值:
Q1:在范围[3.3,6.6]中 - 预期返回值:[3.3,5.5,6.6]或[3.3,3.3,5.5,6.6],如果是最后一个,则[3.3,5.5 ]或[3.3,3.3,5.5],如果没有.
Q2:在[2.0,4.0]范围内 - 预期回报值:[3.3]或[3.3,3.3]

对于任何其他MultiIndex维度也是如此,例如B值:
Q3 …

我有一个包含一些图像数据的numpy数组.我想绘制在图像上绘制的横断面的"轮廓".最简单的情况是平行于图像边缘运行的轮廓,因此如果图像阵列是imdat,则所选点处的轮廓(r,c)简单地imdat[r](水平)或imdat[:,c](垂直).

现在,我要带作为输入两个点(r1,c1)和(r2,c2),卧都里面imdat.我想在连接这两点的线上绘制值的轮廓.

沿着这样一条线从numpy数组中获取值的最佳方法是什么？更一般地说,沿路径/多边形？

我之前使用过切片和索引,但是对于连续切片元素不在同一行或列中的情况,我似乎无法找到优雅的解决方案.谢谢你的帮助.

我经常使用切片结构.这是一个这样的结构的例子:

type MyStruct struct {
    val1, val2, val3    int
    text1, text2, text3 string
    list                []SomeType
}

所以我定义我的切片如下:

[]MyStruct

假设我在那里有大约一百万个元素,我正在努力研究切片:

• 我经常附加新元素.(元素总数未知.)
• 我时不时地对它进行排序.
• 我也删除元素(尽管没有添加新元素).
• 我经常读取元素并传递它们(作为函数参数).
• 元素本身的内容不会改变.

我的理解是,这导致了很多实际结构的混乱.另一种方法是创建一个指向结构的指针:

[]*MyStruct

现在结构保持原样,我们只处理指针,我认为这些指针占用的空间较小,因此可以使我的操作更快.但是现在我给垃圾收集器做了很多工作.

• 您是否可以提供何时直接使用结构以及何时使用结构指针的一般指导原则？
• 我应该担心我离开GC的工作量有多少？
• 复制结构与复制指针的性能开销是否可忽略不计？
• 也许一百万元素并不多.当切片变得更大时(但当然仍然适合RAM),所有这些都会如何变化？

我正在调用一个函数,如果没有值,则返回一个空数组.

当我这样做时,它不起作用:

if r == [] {
    fmt.Println("No return value")            
}

我正在使用的工作是:

var a [0]int
if r == a {
    fmt.Println("No return value")            
}

但是声明一个变量只是为了检查返回值似乎并不正确.有什么更好的方法呢？

p = [1,2,3]
print(p) # [1, 2, 3]

q=p[:]  # supposed to do a shallow copy
q[0]=11
print(q) #[11, 2, 3] 
print(p) #[1, 2, 3] 
# above confirms that q is not p, and is a distinct copy 

del p[:] # why is this not creating a copy and deleting that copy ?
print(p) # [] 

以上确认p[:]在这两种情况下工作方式不同。是不是

考虑到在以下代码中，我希望直接使用p而不是的副本p，

p[0] = 111
p[1:3] = [222, 333]
print(p) # [111, 222, 333]

我觉得

del p[:] 

与一致 …

正如我在评论这个答案后才注意到的那样,Python 3中的切片返回了他们正在切片而不是视图的浅层副本.为什么仍然如此？即使撇开观点numpy的的使用,而不是切片的副本,事实证明dict.keys,dict.values和dict.items在Python 3所有回报的意见,并有走向更大的使用迭代器面向Python 3中的其他许多方面,使它看起来将会有些切片变得相似的运动.itertools确实有一个islice函数可以进行迭代切片,但是它比普通切片更有限,并且不提供沿着dict.keys或者行的视图功能dict.values.

同样,你可以使用赋值给切片来修改原始列表,但切片本身就是副本而不是视图,这是语言的一个矛盾方面,似乎它违反了Python的Zen中所说明的几个原则.

也就是说,你可以做的事实

>>> a = [1, 2, 3, 4, 5]
>>> a[::2] = [0, 0, 0]
>>> a
[0, 2, 0, 4, 0]

但不是

>>> a = [1, 2, 3, 4, 5]
>>> a[::2][0] = 0
>>> a
[0, 2, 3, 4, 5]

或类似的东西

>>> a = [1, 2, 3, 4, 5]
>>> b = a[::2]
>>> b …