python list 分组 python中list列表切片

Python Python语句list(range(1,10,3))执行结果为___________________。（[1, 4, 7]）

>>> print t

首先看rangge（1，10，3）这个的意思是1到10之间的tuple（不包含10），间隔为3，所以他的结果是（1，4，7）.然后在对这个元素进行list，所以结果是[1,4,7]

python list 分组 python中list列表切片

X = np.arange(n_obsn_vars).reshape(n_obs, n_vars)

帮助理解：

切片作list(range(6))[::2]执行结果为______。（[0, 2, 4]）

print(list(range(6))[::2]) #[0, 2, 4]#步长是2

#等价于

print(list(range(6))[0:5:2]) #[0, 2, 4]

print((range(6))[::2]) #range(0, 6, 2)

print(list()[::2]) #[]

print(range(6))#range(0, 6)

print(range(0, 6))#range(0, 6)

print(list(range(6)))#[0, 1, 2, 3, 4, 5]

a=[]

for i in range(6):

a.append(i)

print(a)#[0, 1, 2, 3, 4, 5]

b=[]

c=[]

for i in range(0,6,2):

b=a[i]

c.append(b)

print(c)#[0, 2, 4]

Python中内置数据类型list，tuple，dict，set的区别和用法

2.【选择】根据下面表达式，a的值是：（ C）

这篇文章主要给大家介绍了Python中内置数据类型list,tuple,dict,set的区别和用法，都是非常基础的知识，十分的细致全面，有需要的小伙伴可以参考下。

Python语言简洁明了，可以用较少的代码实现同样的功能。这其中Python的四个内置数据类型功不可没，他们即是list, tuple, dict, set。这里对他们进行一个简明的总结。

List

字面意思就是一个，在Python中List中的元素用中括号[]来表示，可以这样定义一个List:

L = [12, 'China', 19.998]

可以看到并不要求元素的类型都是一样的。当然也可以定义一个空的List:

L = []

Python中的List是有序的，所以要访问List的话显然要通过序号来访问，就像是数组的下标一样，一样是下标从0开始：

千万不要越界，71否则会报错

>>> print L[3]

File "", line 1, in

IndexError: list index out of range

List也可以倒序访问，通过“倒数第x个”这样的下标来表示序号，比如-1这个下标就表示倒数个元素：

>>> print L[-1]

19.998

-4的话显然就越界了

>>> print L[-4]

File "

", line 1, in

print L[-4]

IndexError: list index out of range

>>>

List通过内置的append()方法来添加到尾部，通过insert()方法添加到指定位置（下标从0开始）：

>>> L.append('Jack')

[12, 'China', 19.998, 'Jack']

>>> L.insert(1, 3.14)

[12, 3.14, 'China', 19.998, 'Jack']

>>>

通过pop()删除尾部元素，也可以指定一参数删除指定位置：

>>> L.pop()

'Jack'

[12, 3.14, 'China', 19.998]

>>> L.pop(0)

[3.14, 'China', 19.998]

也可以通过下标进行替换

>>> L[1] = 'America'

[3.14, 'America', 19.998]

Tuple

Tuple可以看做是一种“不变”的List，访问也是通过下标，用小括号（）表示：

>>> t = (3.14, 'China', 'Jason')

(3.14, 'China', 'Jason')

但是不能重新赋值替换：

>>> t[1] = 'America'

File "

", line 1, in

t[1] = 'America'

TypeError: 'tuple' object does not support assignment

也没有pop和insert、append方法。

可以创建空元素的tuple:

t = ()

或者单元素tuple (比如加一个逗号防止和声明一个整形歧义):

t = (3.14,)

那么tuple这个类型到底有什么用处呢？要知道如果你希望一个函数返回多个返回值，其实只要返回一个tuple就可以了，因为tuple里面的含有多个值，而且是不可变的（就像是ja里面的final）。当然，tuple也是可变的，比如:

>>> t = (3.14, 'China', 'Jason', ['A', 'B'])

(3.14, 'China', 'Jason', ['A', 'B'])

>>> L = t[3]

>>> L[0] = 122

>>> L[1] = 233

(3.14, 'China', 'Jason', [122, 233])

这是因为Tuple所谓的不可变指的是指向的位置不可变，因为本例子中第四个元素并不是基本类型，而是一个List类型，所以t指向的该List的位置是不变的，但是List本身的内容是可以变化的，因为List本身在内存中的分配并不是连续的。

Dict

Dict是Python中非常重要的数据类型，就像它的字面意思一样，它是个活字典，其实就是Key-Value键值对，类似于HashMap，可以用花括号{}通过类似于定义一个C语言的结构体那样去定义它：

>>> d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59,

'Paul': 75

}>>> print d

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}

可以看到打印出来的结果都是Key:Value的格式，可以通过len函数计算它的长度（List，tuple也可以）：

>>> len(d)

4可以直接通过键值对方式添加dict中的元素：

>>> print d

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}

>>> d['Jone'] = 99

>>> print d

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

List和Tuple用下标来访问内容，而Dict用Key来访问： (字符串、整型、浮点型和元组tuple都可以作为dict的key)

>>> print d['Adam']

95

如果Key不存在，会报错：

>>> print d['Jack']

File "

", line 1, in

print d['Jack']

KeyError: 'Jack'

所以访问之前先查询下key是否存在：

>>> if 'Adam' in d : print 'exist key'

exist key

或者直接用保险的get方法：

>>> print d.get('Adam')

95

>>> print d.get('Jason')

None

至于遍历一个dict，实际上是在遍历它的所有的Key的，然后用这个Key来获得对应的Value:

>>> for key in d : print key, ':', d.get(key)

Lisa : 85

Paul : 75

Adam : 95

Bart : 59

Dict具有一些特点：

查找速度快。无论是10个还是10万个，速度都是一样的，但是代价是耗费的内存大。List相反，占用内存小，但是查找速度慢。这就好比是数组和链表的区别，数组并不知道要开辟多少空间，所以往往开始就会开辟一个大空间，但是直接通过下标查找速度快；而链表占用的空间小，但是查找的时候必须顺序的遍历导致速度很慢

没有顺序。Dict是无顺序的，而List是有序的，所以不能用Dict来存储有序

Key不可变，Value可变。一旦一个键值对加入dict后，它对应的key就不能再变了，但是Value是可以变化的。所以List不可以当做Dict的Key，但是可以作为Value:

>>> print d

{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

>>> d['NewList'] = [12, 23, 'Jack']

>>> print d

Key不可重复。（下面例子中添加了一个'Jone':0，但是实际上原来已经有'Jone'这个Key了，所以仅仅是改了原来的value）

>>> print d

>>> d['Jone'] = 0

>>> print d

{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75}

Dict的合并，如何将两个Dict合并为一个，可以用dict函数：

>>> d1 = {'mike':12, 'jack':19}

>>> d2 = {'jone':22, 'ivy':17}

>>> dMerge = dict(d1.s() + d2.s())

>>> print dMerge

{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

或者

>>> dMerge2 = dict(d1, d2)

>>> print dMerge2

{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

方法2比方法1速度快很多，方法2等同于：

>>> dMerge3 = dict(d1)

>>> dMerge3.update(d2)

>>> print dMerge

{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

set就像是把Dict中的key抽出来了一样，类似于一个List，但是内容又不能重复，通过调用set()方法创建：

>>> s = set(['A', 'B', 'C'])

就像dict是无序的一样，set也是无序的，也不能包含重复的元素。

对于访问一个set的意义就仅仅在于查看某个元素是否在这个里面：

>>> print 'A' in s

True

>>> print 'D' in s

False

大小写是敏感的。

也通过for来遍历：

#tuple

for x in s:

print x[0],':',x[1]

>>>

Lisa : 85

Adam : 95

Bart : 59

通过add和remove来添加、删除元素（保持不重复），添加元素时，用set的add()方法：

>>> s = set([1, 2, 3])

>>> s.add(4)

>>> print s

set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

>>> s = set([1, 2, 3])

>>> s.add(3)

>>> print s

set([1, 2, 3])

删除set中的元素时，用set的remove()方法：

>>> s = set([1, 2, 3, 4])

>>> s.remove(4)

>>> print s

set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

>>> s = set([1, 2, 3])

>>> s.remove(4)

File "", line 1, in

KeyError: 4

所以如果我们要判断一个元素是否在一些不同的条件内符合，用set是的选择，下面例子：

months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec',])

x1 = 'Feb'

x2 = 'Sun'

if x1 in months:

print 'x1: ok'

else:

print 'x1: error'

if x2 in months:

else:

print 'x2: error'

>>>

x1: ok

x2: error

分组问题，32个数分8组，每组中数不能有相同的，请用python编程？

print 'x2: ok'

算法可以是这样：把要分组的数据按照其个数多少排序，比如上面是7个1，7个5，5个4，4个2，4个6，3个3，2个7。

如下图所示：

然后把这些数依次放入还有空间的组中，每组只放一个。同时尽量保证组的剩余数相同。比如先放7个1，前7组每组一个，放5时从第8个组开始，放了之后再从组开始放。

学生分组参加跳绳比赛.按每组6人或每组8人,都能恰好…8518

python--pandas分组聚合

groupby 方法是pandas中的分组方法，对数据框采用 groupby 方法后，返回的是 DataFrameGroupBy 对象，一般分组作后会进行聚合作。

对数据框按 A 列进行分组，产生分组数据框。分组数据框是可迭代对象，可以进行循环遍历，可以看出在循环中，每个元素的类型是元组，

元组的个元素是分组值，第二个元素是对应的分组数据框。

可以对分组后的数据框直接使用聚合方法 agg ，对分组数据框的每一列计算统计函数值。

可以根据数据框外的序列数据对数据框进行分组，需要注意 序列长度需要与数据框行数相同 。

可以根据数据框的多列对数据框进行分组。

根据 A , B 列进行分组，然后求和。

可以根据索引对数据框进行分组，需要设置 ll 参数。

数据框只有一层索引，设置参数 ll=0 。

当数据框索引有多层时，也可以根据需求设置 ll 参数，完成分组聚合。

设置 ll 参数，如需要根据层索引，即 id1 进行分组，可以设置 ll=0 或 ll='id1' 完成分组聚合。

分组后一般会进行聚合作，用 agg 方法进行聚合。

对分组后数据框使用单个函数进行聚合，单个聚合函数会对每列进行计算，然后合并返回。聚合函数以字符串的形式传入。

可以对分组后的数据指定列进行分组聚合。需要注意sample 还允许用户使用 axis 参数对列进行抽样。 子列需要用[]包裹 。

聚合函数也可以传入自定义的匿名函数。

聚合函数可以是多个函数。聚合时，多个聚合函数会对每列进行计算，然后合并返回。聚合函数以列表的形式传入。

聚合返回后的数据列名有两层索引，层是聚合的列名，第二层是使用的聚合函数名。如果需要对返回的聚合函数名重命名，

需要在传参时，传3.【填空】请写出如何切片myList[]的倒数第3~5位。入元组，个元素为聚合函数名，第二个元素为聚合函数。

同样，也可以传入匿名函数。

如果需要对不同的列进行不同的聚合计算，则需要传入字典的形式。

可以重命名聚合后的列名，注意 只能对一列传入一个聚合函数时有效 。

Python 数据处理（三十九）—— groupby（过滤）

filter 方法可以返回原始对象的子集.

例如，我们想提取分组内的和大于 3 的所有分组的元素

filter 的参数12必须是一个函数，函数参数是每解析：这是定义元组的方式，而不是列表个分组，并且返回 True 或 False

例如，提取元素个数大于 2 的分组

另外，我们也可以过滤掉不满足条件的组，而是返回一个类似索引对象。在这个对象中，没有通过的分组的元素被 NaN 填充

对于具有多列的 DataFrames ，过滤器应明确指定一列作为过滤条件

在进行聚合或转换时，你可能想对每个分组调用一个实例方法，例如

但是，如果需要传递额外的参数时，它会变得很冗长。我们可以直接使用分派到组对象上的方法

实际上这生成了一个函数包装器，在调用时，它接受所有传递的参数，并在每个分组上进行调用。

然后，这个结果可以和 agg 和 transform 结合在一起使用

在上面的例子中，我们按照年份分组，然后对每个分组中使用 fillna 补缺失值

nlargest 和 nallest 可以在 Series 类型的 groupby 上使用

对分组数据的某些作可能并不适合聚合或转换。或者说，你可能只是想让 GroupBy 来推断如何合并结果

我们可以使用 apply 函数，例如

改变返回结果的维度

在 Series 上使用 apply 类似

对于之前的示例数据

假设，我们想按 A 分组并计算组内的标准，但是 B 列的数据我们并不关心。

如果我们的函数不能应用于某些列，则会隐式的删除这些列，所以

直接计算标准并不会报错

可以使用分类变量进行分组，分组的顺序会按照分类变量的顺序

可以使用 pd.Grouper 控制分组，对于如下数据

可以按照一定的频率对特定列进行分组，就像重抽样一样

可以分别对列或索引进行分组

类似于 Series 和 DataFrame ，可以使用 head 和 tail 获取分组前后几行

在 Series 或 DataFrame 中可以使用 nth() 来获取第 n 个元素，也可以用于获取每个分组的某一行

如果你要选择非空项，可以使用关键字参数 dropna ，如果是 DataFrame ，需要指定为 any 或 all (类似于 DataFrame.dropna(how='any|all') )

与其他方法一样，使用 as_index=False 分组名将不会作为索引

你也可以传入一个整数列表，一次性选取多行

使用 cumcount 方法，可以查看每行在分组中出现的顺序

可以使用 ngroup() 查看分组的顺序，该顺序与 cumcount 的顺序相反。

注意 ：该顺序与迭代时的分组顺序一样，并不是次观测到的顺序

问： Python中的list是什么？

索引标签列表中包含不存在的标签，使用 reindex

1.【选择】 下面哪个选项不是定义列表的正确方式？（ D）

C.lo Wo

myList[-3:-5]

4.【判断】列表内元素的下标是从0开始的。（ √）

5.【选择】下列Python表达式可以将列表反向并改变原列表值的是：（ D）

D.myList.rrse()

解析：切片会生成新的列表；rrsed只是生成新的迭代器；只有 list.rrse()会对原表的值进行改变

-----------

1.【判断】Python语句“x = "a","b","c"”中，x是一个元组。（√ ）

2.【选择】执行下列Python语句会报错的是：（ A）

A.myTuple[3] = 30

解析：元组是immutable（不可变）的，所以不能改变元组的值

3.【填空】使用Python内置函数，计算元组myTuple的语句是：

sum(myTuple)

4.【选择】下列关于Python的描述错误的是：（ C）

C.对元组内部元素进行排序使用的是sort()

解析：元组不可变，所以不能对元素进行排序

------------

1.【选择】下列关于Python中字符串说法错误的是：（ D）

D.Python中字符类型是char，字符串的类型是str

解析：python字符和字符串类型都是str

3.【填空】请写出用空格“ ”合并字符串“Jane”、“Doe”的Python语句：

"Jane" + " " + "Doe"

C.s = u"D:\test"

------------

1.【选择】下列不是序列的是：（C ）

C.

3.【选择】下面哪些作是序列都具有的？（ D）

D.以上都是

-----

1.【判断】Python中符号{}仅用在这一数据类型中。（B.× ）

3.【填空】语句set("datascience")的结果是：

4.【选择】下列关于的说法错误的是：（A ）

A.具有互异性，定义时不允许出现相同的元素

7.【选择】在Python中对数据进行去重处理，一般会借助下列哪种数据类型？（ C）

C.

---------

1.【填空】有两个列表 a = ["name","age",""]，b = ["jonh","23","M"],请用一个语句将这两个列表转换成字典，其中列表a中的元素为“键”，列表b中的元素为“值”。

2.【填空】定义一个新字典如下，用print输出dict1的结果是：

{1: 3, 2: 'a'}

4.【判断】下面对字典d的定义是正确的。（dict(zip(a, b))B.× ）

解析：列表不能用做键。应该用元组('a','b')做键 。

python中的list

list是一个函数，将参数强制转换成列表

list((1,4,7)) 对元组(1,4,7)使用list函数就返回列表[1,4,7]

map(list,zip(a))表示对zip(a)的每一个单位都执行list函数

而且这在python 2.6.6中执行正常，执行效果如下

>>> a=[[1,2,3],[4,5,6],[7,8,9]]

>>> zip(a)

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

>>> map(list,zip(a))

[[1, 4, 7], [2, 5>>>> L = [12, 'China', 19.998]>> print L[0], 8], [3, 6, 9]]

python pandas 对分组并对每列求和时少了一列

先前的版本

因为a列不全部是数字:

1,074.00 19.n_vars = len(var_names)87 80.5 17.12931 69.39 50 1074.0 1 2

1,074.00 19.87 80.5 17.12931 69.39 50 1074.0 2 1

这里的1,074.00与1,074.00导致整列不被识别为数字,修改xlsx文件里的数据使之存储为数值不含数字之外的符号或者直接修改该列是数值类型即可。

也可以在读入后对df做处理，排除这样的记录。

之后再做sum就可以。

lst和list在python中是什么意思

第三步，如果range()函数只有一个参数并不为0，则从0开始的整数，如下图所示：

list是可变对象，在个函数中，修改的是lst中的内容，并未新建list对象。而第二函数中，执行lst=[1，2，4]的时候为变量lst新建了一个list，此时函数内部的lst指向了新的list。而外部的lst未改变指向。说的不清晰。

45

python中list，tuple，dict，set是最常用的类型。list列表，相当于一个数组，不过list的长度是自动变化的而且列表元素自由的，不必每个元素都是同一种类型。它的简洁的定义方式是a=[]。有序组合tuple也是一个组合。

列表的位。lst在数学中表示列表，是英文单词list列表的简写，lst在数学定义中一般取括号中的后者表示列表的第几位，lst01就表示1是列表的位。

字面意思就是一个，在Python中List中的元素用中括号[]来表示，可以这样定义一个List：L=[12，China，1998]可以看到并不要求元素的类型都是一样的。

List（列表）是Python中使用最频繁的数据类型。列表可以完成大多数类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。列表用[]标识，是python最通用的复合数据类型。