Python组合数据框 python组合数据类型题

转载

编程小天才 2024-06-18 20:21:49

文章标签 Python组合数据框 python Python Java 元组 文章分类 Python 后端开发

文章目录

第一部分列表 list

1.1 列表的表达 []

另一种生成方式：list(可迭代对象)
range()

1.2 列表的性质

列表的长度——len(列表)
列表的索引——与同为序列类型的字符串完全相同
列表的切片——与字符串完全相同

1.3 列表的操作符

用 list1+lis2 的形式实现列表的拼接
用 n * list 或 list * n 实现列表的成倍复制

1.4 列表的操作方法

1.4.1 增加元素

在末尾增加元素——列表.append(待增元素)
在任意位置插入元素——列表.insert(位置编号，待增元素)
在末尾整体并入另一列表——列表1.extend(列表2)

1.4.2 删除元素

删除列表i位置的元素列表.pop(位置)
删除列表中的第一次出现的待删元素列表.remove(待删元素)

1.4.3 查找元素列表.index(待查元素)
1.4.4 修改元素列表名[位置]=新值
1.4.5 列表的复制

方法1：列表.copy()
方法2：列表[ : ]
方法3：list(列表)

1.4.6 列表的排序

使用列表.sort() 对列表进行永久排序
使用 sorted(列表) 对列表进行临时排序

1.4.7 列表的翻转

反向切片临时翻转
使用列表.reverse() 对列表进行永久翻转

1.4.8 使用for循环对列表进行遍历
1.4.9 列表.count(元素) 返回元素在列表中出现的次数

第二部分元组 tuple

2.1 元组的表达 ()
2.2 元组的操作——不支持元素增加、删除、修改操作，其他操作与列表完全一致
2.3 元组的常见用处——打包与解包

zip(列表1, 列表2)

第三部分字典 dict

3.1 字典的表达 {}

另一种生成方式：dict(可迭代键值对)

3.2 字典的性质

字典的长度——键值对的个数 len()
字典的索引

3.3 字典的操作方法

3.3.1 增加键值对——变量名[新键] = 新值
3.3.2 删除键值对

通过 del 变量名[待删除键]
通过变量名.pop(待删除键)
变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

3.3.3 修改值

通过先索引后赋值的方式对相应的值进行修改
dict1.update(dict2) 方法

3.3.4 d.get(key,default)方法
3.3.5 d.keys( ) d.values( )方法
3.3.6 d.items( )方法及字典的遍历

第四部分集合 set

4.1 集合的表达 {}
4.2 集合的运算 & | ^ -
4.3 集合的操作方法

增加元素——S.add(x)
移除元素——S.remove(x)
集合的长度——len(S)
集合的遍历——for循环

第五部分如果方法太多记不住，通过 dir() 获取类中所有方法

第一部分列表 list

1.1 列表的表达 []

序列类型：内部元素有位置关系，能通过位置序号访问其中元素
列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型

ls = ["Python", 1989, True, {"version": 3.7}]
print(ls)

['Python', 1989, True, {'version': 3.7}]

另一种生成方式：list(可迭代对象)

可迭代对象包括：字符串、元组、集合、range()等
字符串转列表

print(list("人工智能是未来的趋势"))

['人', '工', '智', '能', '是', '未', '来', '的', '趋', '势']

range()

range(起始数字,终止数字,数字间隔)
如果起始数字缺省，默认为0
必须包含终止数字
数字间隔缺省，默认为1

for i in range(1, 11, 2):
    print(i)

range()转列表

print(list(range(1, 11, 2)))

[1, 3, 5, 7, 9]

1.2 列表的性质

列表的长度——len(列表)

ls = [1, 2, 3, 4, 5]
print(len(ls))

列表的索引——与同为序列类型的字符串完全相同

变量名[位置编号]
正向索引从0开始
反向索引从-1开始

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[0])
print(cars[-1])

BYD
TOYOTA

列表的切片——与字符串完全相同

变量名[开始位置：结束位置：切片间隔]
正向切片

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[:3])     # 前三个元素，开始位置缺省，默认为0；切片间隔缺省，默认为1
print(cars[1:4:2])  # 第二个到第四个元素 前后索引差为2
print(cars[:])      # 获取整个列表，结束位置缺省，默认取值到最后
print(cars[-4:-2])  # 获取前两个元素

['BYD', 'BMW', 'AUDI']
['BMW', 'TOYOTA']
['BYD', 'BMW', 'AUDI', 'TOYOTA']
['BYD', 'BMW']

反向切片

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
print(cars[:-4:-1])      # 开始位置缺省，默认为-1
print(cars[::-1])        # 获得反向列表

['TOYOTA', 'AUDI', 'BMW']
['TOYOTA', 'AUDI', 'BMW', 'BYD']

1.3 列表的操作符

用 list1+lis2 的形式实现列表的拼接

a = [1, 2]
b = [3, 4]
a+b            # 该用法用的不多

[1, 2, 3, 4]

用 n * list 或 list * n 实现列表的成倍复制

初始化列表的一种方式

print([0]*10)

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

1.4 列表的操作方法

1.4.1 增加元素

在末尾增加元素——列表.append(待增元素)

languages = ["Python", "C++", "R"]
languages.append("Java")
print(languages)

['Python', 'C++', 'R', 'Java']

在任意位置插入元素——列表.insert(位置编号，待增元素)

在位置编号相应元素前插入待增元素

languages = ["Python", "C++", "R"]
languages.insert(1, "C")
print(languages)

['Python', 'C', 'C++', 'R']

在末尾整体并入另一列表——列表1.extend(列表2)

append 将列表2整体作为一个元素添加到列表1中

languages = ["Python", "C++", "R"]
languages.append(["Ruby", "PHP"])
print(languages)

['Python', 'C++', 'R', ['Ruby', 'PHP']]

extend 将列表2内的元素逐个添加到列表1中

languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.extend(["Ruby", "PHP"])
print(languages)

['Python', 'C', 'C++', 'R', 'Java', 'Ruby', 'PHP']

1.4.2 删除元素

删除列表i位置的元素列表.pop(位置)

不写位置信息，默认删除最后一个元素

languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.pop(1)
print(languages)
languages.pop()
print(languages)

['Python', 'C++', 'R', 'Java']
['Python', 'C++', 'R']

删除列表中的第一次出现的待删元素列表.remove(待删元素)

languages = ['Python', 'C', 'R', 'C', 'Java']
languages.remove("C")    
print(languages)

['Python', 'R', 'C', 'Java']

要想全部删除，可以用循环

languages = ['Python', 'C', 'R', 'C', 'Java']
while "C" in languages:
    languages.remove("C")
    
print(languages)

['Python', 'R', 'Java']

1.4.3 查找元素列表.index(待查元素)

返回列表中第一次出现待查元素的位置

languages = ['Python', 'C', 'R','Java']
idx = languages.index("R") 
print(idx)

1.4.4 修改元素列表名[位置]=新值

通过"先索引后赋值"的方式，对元素进行修改

languages = ['Python', 'C', 'R','Java']
languages[1] = "C++"
print(languages)

['Python', 'C++', 'R', 'Java']

1.4.5 列表的复制

错误的方式——取别名

languages = ['Python', 'C', 'R','Java']
languages_2 = languages
print(languages_2)
languages.pop()
print(languages)
print(languages_2)

['Python', 'C', 'R', 'Java']
['Python', 'C', 'R']
['Python', 'C', 'R']

正确的方式——浅拷贝
如果元素中含有可变类型，如列表，浅拷贝可能会出现问题，需要进行深拷贝。

方法1：列表.copy()

languages = ['Python', 'C', 'R','Java']
languages_2 = languages.copy()
languages.pop()
print(languages)
print(languages_2)

['Python', 'C', 'R']
['Python', 'C', 'R', 'Java']

方法2：列表[ : ]

languages = ['Python', 'C', 'R','Java']
languages_3 = languages[:]
languages.pop()
print(languages)
print(languages_3)

['Python', 'C', 'R']
['Python', 'C', 'R', 'Java']

方法3：list(列表)

languages = ['Python', 'C', 'R','Java']
languages_3 = list(languages)
languages.pop()
print(languages)
print(languages_3)

['Python', 'C', 'R']
['Python', 'C', 'R', 'Java']

1.4.6 列表的排序

使用列表.sort() 对列表进行永久排序

直接在列表上进行操作，无返回值

ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort()
print(ls)

[2, 2, 3, 5, 7, 8, 19]

递减排列

ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort(reverse = True)
print(ls)

[19, 8, 7, 5, 3, 2, 2]

使用 sorted(列表) 对列表进行临时排序

原列表保持不变，返回排序后的列表

ls = [2, 5, 2, 8, 19, 3, 7]
ls_2 = sorted(ls)
print(ls)
print(ls_2)
sorted(ls, reverse = True)

[2, 5, 2, 8, 19, 3, 7]
[2, 2, 3, 5, 7, 8, 19]
[19, 8, 7, 5, 3, 2, 2]

1.4.7 列表的翻转

反向切片临时翻转

使用列表.reverse() 对列表进行永久翻转

直接在列表上进行操作，无返回值

ls = [1, 2, 3, 4, 5]
ls.reverse()
print(ls)

[5, 4, 3, 2, 1]

1.4.8 使用for循环对列表进行遍历

ls = [1, 2, 3, 4, 5]
for i in ls:
    print(i)

1.4.9 列表.count(元素) 返回元素在列表中出现的次数

aList = [123, 'xyz', 'zara', 'abc', 123]
print("Count for 123 : ", aList.count(123))

Count for 123 :  2

第二部分元组 tuple

2.1 元组的表达 ()

元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型
通俗的讲，可以将元组视作“不可变的列表”

names = ("Peter", "Pual", "Mary")

2.2 元组的操作——不支持元素增加、删除、修改操作，其他操作与列表完全一致

2.3 元组的常见用处——打包与解包

def f1(x):              # 返回x的平方和立方
    return x**2, x**3   # 实现打包返回

print(f1(3))
print(type(f1(3)))      # 元组类型

a, b = f1(3)            # 实现解包赋值 
print(a)
print(b)

(9, 27)
<class 'tuple'>
9
27

zip(列表1, 列表2)

numbers = [201901, 201902, 201903]
name = ["小明", "小红", "小强"]
print(list(zip(numbers,name)))

for number,name in zip(numbers,name):   # 每次取到一个元组，立刻进行解包赋值
    print(number, name)

[(201901, '小明'), (201902, '小红'), (201903, '小强')]
201901 小明
201902 小红
201903 小强

第三部分字典 dict

3.1 字典的表达 {}

映射类型：通过“键”-“值”的映射实现数据存储和查找
常规的字典是无序的

students = {201901: '小明', 201902: '小红', 201903: '小强'}

另一种生成方式：dict(可迭代键值对)

可迭代键值对：dict，dict.items()，zip

numbers = [201901, 201902, 201903]
name = ["小明", "小红", "小强"]
print(dict(zip(numbers, name)))

{201901: '小明', 201902: '小红', 201903: '小强'}

注意：

字典的键不能重复

students = {201901: '小明', 201901: '小红', 201903: '小强'}
print(students)

{201901: '小红', 201903: '小强'}

字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了。

不可变类型：数字、字符串、元组。一旦确定，它自己就是它自己，变了就不是它了。
可变类型：列表、字典、集合。一旦确定，还可以随意增删改。

d1 = {1: 3}
d2 = {"s": 3}
d3 = {(1,2,3): 3}
#d = {[1, 2]: 3} 会报错

3.2 字典的性质

字典的长度——键值对的个数 len()

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(len(students))

字典的索引

通过字典[键] 的形式来获取对应的值

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(students[201902])

小红

3.3 字典的操作方法

3.3.1 增加键值对——变量名[新键] = 新值

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201904] = "小雪"
print(students)

{201901: '小明', 201902: '小红', 201903: '小强', 201904: '小雪'}

3.3.2 删除键值对

通过 del 变量名[待删除键]

students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
print(students)

{201901: '小明', 201902: '小红'}

通过变量名.pop(待删除键)

students = {201901: '小明', 201902: '小红', 201903: '小强'}
value = students.pop(201903)   # 删除键值对，同时获得删除键值对的值
print(value)
print(students)

小强
{201901: '小明', 201902: '小红'}

变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

students = {201901: '小明', 201902: '小红', 201903: '小强'}
key, value = students.popitem()
print(key, value)
print(students)

201903 小强
{201901: '小明', 201902: '小红'}

3.3.3 修改值

通过先索引后赋值的方式对相应的值进行修改

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902] = "小雪"
print(students)

{201901: '小明', 201902: '小雪', 201903: '小强'}

dict1.update(dict2) 方法

把字典 dict2 的键值对更新到 dict1 里
有相同的键会直接替换成 dict2 的值

>>> a = {1: 2, 2: 2}
>>> b = {1: 1, 3: 3}
>>> b.update(a)
>>> print b
{1: 2, 2: 2, 3: 3}

{1: 2, 2: 2, 3: 3}

3.3.4 d.get(key,default)方法

从字典d中获取键key对应的值，如果没有这个键，则返回default。
小例子：统计"牛奶奶找刘奶奶买牛奶"中字符的出现频率。

s = "牛奶奶找刘奶奶买牛奶"
d = {}
for i in s:
    d[i] = d.get(i, 0)+1
    print(d)

{'牛': 1}
{'牛': 1, '奶': 1}
{'牛': 1, '奶': 2}
{'牛': 1, '奶': 2, '找': 1}
{'牛': 1, '奶': 2, '找': 1, '刘': 1}
{'牛': 1, '奶': 3, '找': 1, '刘': 1}
{'牛': 1, '奶': 4, '找': 1, '刘': 1}
{'牛': 1, '奶': 4, '找': 1, '刘': 1, '买': 1}
{'牛': 2, '奶': 4, '找': 1, '刘': 1, '买': 1}
{'牛': 2, '奶': 5, '找': 1, '刘': 1, '买': 1}

3.3.5 d.keys( ) d.values( )方法

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(list(students.keys()))
print(list(students.values()))

[201901, 201902, 201903]
['小明', '小红', '小强']

3.3.6 d.items( )方法及字典的遍历

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(list(students.items()))
for k, v in students.items():
    print(k, v)

[(201901, '小明'), (201902, '小红'), (201903, '小强')]
201901 小明
201902 小红
201903 小强

第四部分集合 set

4.1 集合的表达 {}

一系列互不相等元素的无序集合
元素必须是不可变类型：数字，字符串或元组，可视作字典的键
可以看做是没有值，或者值为None的字典
可用于去重

students = {"小明", "小红", "小强", "小明"}   
print(students)

{'小强', '小明', '小红'}

4.2 集合的运算 & | ^ -

S & T 返回一个新集合，包括同时在集合S和T中的元素
S | T 返回一个新集合，包括集合S和T中的所有元素
S ^ T 返回一个新集合，包括集合S和T中的非共同元素
S - T 返回一个新集合，包括在集合S但不在集合T中的元素

Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"} # 语文为A的学员
Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"} # 数学为A的学员
print(Chinese_A & Math_A)	# 语文和数学两门均为A的学员
print(Chinese_A | Math_A)	# 语文或数学至少一门为A的学员
print(Chinese_A ^ Math_A)	# 语文数学只有一门为A的学员
print(Chinese_A - Math_A)	# 语文为A，数学不为A的学员

{'刘德华', '张曼玉', '林青霞'}
{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '王祖贤', '郭富城', '钟楚红', '黎明'}
{'古天乐', '张学友', '王祖贤', '郭富城', '钟楚红', '黎明'}
{'古天乐', '张学友', '钟楚红'}

4.3 集合的操作方法

增加元素——S.add(x)

stars = {"刘德华", "张学友", "张曼玉"}
stars.add("王祖贤")
print(stars)

{'刘德华', '张学友', '张曼玉', '王祖贤'}

移除元素——S.remove(x)

stars.remove("王祖贤")
print(stars)

{'刘德华', '张学友', '张曼玉'}

集合的长度——len(S)

stars = {"刘德华", "张学友", "张曼玉"}
print(len(stars))

集合的遍历——for循环

stars = {"刘德华", "张学友", "张曼玉"}
for star in stars:
    print(star)

张学友
张曼玉
刘德华

第五部分如果方法太多记不住，通过 dir() 获取类中所有方法

print(dir(dict))	# 获取字典中的所有方法

['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：ios 影响提审 ios提审流程

下一篇：java stream findany和findfirst有什么区别 ifstream和ofstream的区别

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

Python组合数据框 python组合数据类型题

Python组合数据框 python组合数据类型题

文章目录

第一部分 列表 list

1.1 列表的表达 []

另一种生成方式：list(可迭代对象)

range()

1.2 列表的性质

列表的长度——len(列表)

列表的索引——与同为序列类型的字符串完全相同

列表的切片——与字符串完全相同

1.3 列表的操作符

用 list1+lis2 的形式实现列表的拼接

用 n * list 或 list * n 实现列表的成倍复制

1.4 列表的操作方法

1.4.1 增加元素

在末尾增加元素——列表.append(待增元素)

在任意位置插入元素——列表.insert(位置编号，待增元素)

在末尾整体并入另一列表——列表1.extend(列表2)

1.4.2 删除元素

删除列表i位置的元素 列表.pop(位置)

删除列表中的第一次出现的待删元素 列表.remove(待删元素)

1.4.3 查找元素 列表.index(待查元素)

1.4.4 修改元素 列表名[位置]=新值

1.4.5 列表的复制

方法1：列表.copy()

方法2：列表[ : ]

方法3：list(列表)

1.4.6 列表的排序

使用 列表.sort() 对列表进行永久排序

使用 sorted(列表) 对列表进行临时排序

1.4.7 列表的翻转

反向切片临时翻转

使用 列表.reverse() 对列表进行永久翻转

1.4.8 使用for循环对列表进行遍历

1.4.9 列表.count(元素) 返回元素在列表中出现的次数

第二部分 元组 tuple

2.1 元组的表达 ()

2.2 元组的操作——不支持元素增加、删除、修改操作，其他操作与列表完全一致

2.3 元组的常见用处——打包与解包

zip(列表1, 列表2)

第三部分 字典 dict

3.1 字典的表达 {}

另一种生成方式：dict(可迭代键值对)

3.2 字典的性质

字典的长度——键值对的个数 len()

字典的索引

3.3 字典的操作方法

3.3.1 增加键值对——变量名[新键] = 新值

3.3.2 删除键值对

通过 del 变量名[待删除键]

通过 变量名.pop(待删除键)

变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对

3.3.3 修改值

通过先索引后赋值的方式对相应的值进行修改

dict1.update(dict2) 方法

3.3.4 d.get(key,default)方法

3.3.5 d.keys( ) d.values( )方法

3.3.6 d.items( )方法及字典的遍历

第四部分 集合 set

4.1 集合的表达 {}

4.2 集合的运算 & | ^ -

4.3 集合的操作方法

增加元素——S.add(x)

移除元素——S.remove(x)

集合的长度——len(S)

集合的遍历——for循环

第五部分 如果方法太多记不住，通过 dir() 获取类中所有方法

51CTO博客

第一部分列表 list

删除列表i位置的元素列表.pop(位置)

删除列表中的第一次出现的待删元素列表.remove(待删元素)

1.4.3 查找元素列表.index(待查元素)

1.4.4 修改元素列表名[位置]=新值

使用列表.sort() 对列表进行永久排序

使用列表.reverse() 对列表进行永久翻转

第二部分元组 tuple

第三部分字典 dict

通过变量名.pop(待删除键)

第四部分集合 set

第五部分如果方法太多记不住，通过 dir() 获取类中所有方法