python切片函数参数,Python切片规则

python中slice数据类型是什么样子的，可否举例说明。

python 的切片语法传入 __getitem__ 的参数有两种, 第一种是普通整数或对象, 也就是直接写 t[0], t['abc'] 这样, 第二种是切片, 即 t[0: 1], t[:: -1] 这种. 对于后者, 实际参数 i 的类型将是一个 slice 对象.

创新互联建站成立于2013年，是专业互联网技术服务公司，拥有项目网站设计、成都网站设计网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元阿克塞哈萨克族自治做网站,已为上家服务,为阿克塞哈萨克族自治各地企业和个人服务,联系电话:18980820575

代码示例

class Test(object):

def __init__(self):

self.tokens = []

def __getitem__(self, i):

if isinstance(i, slice):

print 'Slice object:', i

return self.tokens[i.start: i.stop]

else:

print 'Integer:', i

return self.tokens[i]

t = Test()

t.tokens = range(10)

t[0]

t[1: 2]

Python的函数参数总结

import math

a = abs

print(a(-1))

n1 = 255

print(str(hex(n1)))

def my_abs(x):

# 增加了参数的检查

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x = 0:

return x

else:

return -x

print(my_abs(-3))

def nop():

pass

if n1 = 255:

pass

def move(x, y, step, angle=0):

nx = x + step * math.cos(angle)

ny = y - step * math.sin(angle)

return nx, ny

x, y = move(100, 100, 60, math.pi / 6)

print(x, y)

tup = move(100, 100, 60, math.pi / 6)

print(tup)

print(isinstance(tup, tuple))

def quadratic(a, b, c):

k = b * b - 4 * a * c

# print(k)

# print(math.sqrt(k))

if k 0:

print('This is no result!')

return None

elif k == 0:

x1 = -(b / 2 * a)

x2 = x1

return x1, x2

else:

x1 = (-b + math.sqrt(k)) / (2 * a)

x2 = (-b - math.sqrt(k)) / (2 * a)

return x1, x2

print(quadratic(2, 3, 1))

def power(x, n=2):

s = 1

while n 0:

n = n - 1

s = s * x

return s

print(power(2))

print(power(2, 3))

def enroll(name, gender, age=8, city='BeiJing'):

print('name:', name)

print('gender:', gender)

print('age:', age)

print('city:', city)

enroll('elder', 'F')

enroll('android', 'B', 9)

enroll('pythone', '6', city='AnShan')

def add_end(L=[]):

L.append('end')

return L

print(add_end())

print(add_end())

print(add_end())

def add_end_none(L=None):

if L is None:

L = []

L.append('END')

return L

print(add_end_none())

print(add_end_none())

print(add_end_none())

def calc(*nums):

sum = 0

for n in nums:

sum = sum + n * n

return sum

print(calc(1, 2, 3))

print(calc())

l = [1, 2, 3, 4]

print(calc(*l))

def foo(x, y):

print('x is %s' % x)

print('y is %s' % y)

foo(1, 2)

foo(y=1, x=2)

def person(name, age, **kv):

print('name:', name, 'age:', age, 'other:', kv)

person('Elder', '8')

person('Android', '9', city='BeiJing', Edu='人民大学')

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)

def person2(name, age, *, city, job):

print(name, age, city, job)

person2('Pthon', 8, city='BeiJing', job='Android Engineer')

def person3(name, age, *other, city='BeiJing', job='Android Engineer'):

print(name, age, other, city, job)

person3('Php', 18, 'test', 1, 2, 3)

person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')

def test2(a, b, c=0, *args, key=None, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)

test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')

args = (1, 2, 3, 4)

kw = {'d': 99, 'x': '#'}

test2(*args, **kw)

python中line.split()的用法及实际使用示例

Python中split()函数，通常用于将字符串切片并转换为列表。

split()：语法：

拆分字符串。通过制定分隔符将字符串进行切片，并返回分割后的字符串列表[list]

参数：str：分隔符，默认为空格，但不能为空("")

num: 表示分割次数。如果指定num，则分割成n+1个子字符串，并可将每个字符串赋给新的变量

line.strip().split(’,’)

strip()表示删除掉数据中的换行符，split（‘，’）则是数据中遇到‘,’ 就隔开。

Python spit用法

Python split()方法

Python 字符串

描述

Python split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

语法

split()方法语法：

str.split(str="", num=string.count(str)).

参数

str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

num -- 分割次数。

返回值

返回分割后的字符串列表。

实例

以下实例展示了split()函数的使用方法：

#!/usr/bin/python

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";

print str.split( );

print str.split(' ', 1 );

以上实例输出结果如下：

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']

['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

【python】魔法方法 ：__getitem__ 、 __len__、__setitem__等的使用

在Python中，如果我们想实现创建类似于序列和映射的类（可以迭代以及通过[下标]返回元素），可以通过重写魔法方法 __getitem__、__setitem__、__delitem__、__len__ 方法去模拟。

__getitem__(self,key): 返回键对应的值。

__setitem__(self,key,value)： 设置给定键的值

__delitem__(self,key): 删除给定键对应的元素。

__len__(): 返回元素的数量

【注释】只要实现了 __getitem__ 和 __len__ 方法，就会被认为是序列。

这些魔术方法的原理就是：当我们对类的属性item进行下标的操作时，首先会被 __getitem__()、__setitem__()、__delitem__() 拦截，从而执行我们在方法中设定的操作，如赋值，修改内容，删除内容等等。

这个方法应该以与键相关联的方式存储值，以便之后能够使用 __setitem__ 来获取。当然，这个对象可变时才需要实现这个方法。

举个栗子：

定义一副扑克牌（不包括大小王），对牌进行洗牌，然后发牌。

Output：

【注意】 :我们会发现output中，输出了： slice(1, 3, None) ，下面给出解释。

语法：

参数说明：

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

举两个栗子来看看：

Output:

切片原理

output

(程序员必会的 hhhhh.....)

看看slice在python3.7中是怎么描述的:

求助帖，关于Python的切片

取一个list的部分元素是非常常见的操作。比如，一个list如下：

L = ['Adam', 'Lisa', 'Bart', 'Paul']

取前3个元素，应该怎么做？

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

对应上面的问题，取前3个元素，用一行代码就可以完成切片：

L[0:3]

['Adam', 'Lisa', 'Bart']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

只用一个 : ，表示从头到尾：

L[:]

['Adam', 'Lisa', 'Bart', 'Paul']

因此，L[:]实际上复制出了一个新list。

切片操作还可以指定第三个参数：

L[::2]

['Adam', 'Bart']

第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。

把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。