Python复习

1.pandas.DataFrame相关操作

重新指定列名

全部重命名:

1
2
3
4
5
6
7
8
9
10
# 直接指定df.columns为一个新的列表
	data = {
		'商品名称': ['手机', '电视', '电脑', '耳机', '平板'],
		'商品编号': ['P001', 'T002', 'C003', 'E004', 'T005'],
		'单价': [5000, 3000, 4500, 500, 2000],
		'销量': [10, 10, 6, 30, 8]
	}
	df = pd.DataFrame(data)
    
    df.columns = ['a','b','c','d']

部分重命名:

1
2
3
4
df.rename(
	columns = {'old0':'new0'...}, # 新旧列名的映射字典
    inplace = # True: 在原DataFrame修改而非创建副本 False:
)

对列名进行字符串操作:

1
2
3
4
# 去除多余空格
df.columns = df.columns.str.strip()
# 进行替换
df.columns = df.columns.str.replace('old', 'new')

调整列数

1
2
3
4
5
6
7
8
9
10
11
if __name__ == '__main__':
	data = {
		'商品名称': ['手机', '电视', '电脑', '耳机', '平板'],
		'商品编号': ['P001', 'T002', 'C003', 'E004', 'T005'],
		'单价': [5000, 3000, 4500, 500, 2000],
		'销量': [10, 10, 6, 30, 8]
	}
	df = pd.DataFrame(data)
    # 让df只有'商品名称'和'单价'这两列
    # 注意:这里一定要传列表进去
    df = df[['商品名称','单价']]

根据某个字段排序df.value_sorted()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
df.sort_values(
	by='排序依据的字段',
    ascending=False # False:降序 True:升序
)->DataFrame

#=============例子=================

import pandas as pd

if __name__ == '__main__':
	data = {
		'商品名称': ['手机', '电视', '电脑', '耳机', '平板'],
		'商品编号': ['P001', 'T002', 'C003', 'E004', 'T005'],
		'单价': [5000, 3000, 4500, 500, 2000],
		'销量': [10, 10, 6, 30, 8]
	}
	df = pd.DataFrame(data)
	print(df)
	"""
	  商品名称  商品编号    单价  销量
    0   手机  P001  5000  10
    1   电视  T002  3000  10
    2   电脑  C003  4500   6
    3   耳机  E004   500  30
    4   平板  T005  2000   8
	"""
	df = df.sort_values(
		by='单价',
		ascending=False
	)
	print(df)
	"""
	  商品名称  商品编号    单价  销量
    0   手机  P001  5000  10
    2   电脑  C003  4500   6
    1   电视  T002  3000  10
    4   平板  T005  2000   8
    3   耳机  E004   500  30
	"""

df.pivot()

1
2
3
4
5
df = df.pivot(
	index='商品编号', # 每行的索引字段
	columns='商品名称', # 每列的索引字段
	values='单价' # 填充值字段
)

原df:

image-20251111195511915

pivot后的df:

image-20251111195529421

replace()

用于对DataFrame的列进行替换

函数用法:

1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd
data = {
    'a':[...]
	'b':[...]
    ...
}
df = pd.DataFrame(data)
df['a'] = df['a'].replace(
	{
        # 对应替换的字典
    }
)

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pandas as pd

if __name__ == '__main__':
	data = {
		'商品名称': ['手机', '电视', '电脑', '耳机', '平板'],
		'商品编号': ['P001', 'T002', 'C003', 'E004', 'T005'],
		'单价': [5000, 3000, 4500, 500, 2000],
		'销量': [10, 10, 6, 30, 8]
	}
	df = pd.DataFrame(data)
    
    df['商品名称'] = df['商品名称'].replace(
        {
            "手机": "Phone",
            "电视": "TV",
            "电脑": "computer",
            "耳机": "earphone",
            "平板": "Pad",
        }
    )

image-20251111200306579

df.iloc[]

基于位置的索引

例子:

1
2
3
4
5
6
7
8
if __name__ == '__main__':
	data = {
		'商品名称': ['手机', '电视', '电脑', '耳机', '平板'],
		'商品编号': ['P001', 'T002', 'C003', 'E004', 'T005'],
		'单价': [5000, 3000, 4500, 500, 2000],
		'销量': [10, 10, 6, 30, 8]
	}
	df = pd.DataFrame(data)

选择单行:

1
2
# 选择第一行
df.iloc[0]

image-20251111202118946

选择单列:

1
2
# 选择第一列
df.iloc[:,0]

image-20251111202235678

选择多行

1
2
# 选择第1、第3行
df.iloc[[0,2]]

image-20251111202418348

选择多列

1
2
# 选择第1，3列
df.iloc[:, [0, 2]]

image-20251111202615448

同时选择多行多列

1
df.iloc[[1, 3], [0, 2]]

image-20251111202628813

切片操作

1
2
# 0-1行的3-4列
df.iloc[:2, 2:]

image-20251111202824850

df.loc[]

基于标签的索引

例子:

1
2
3
4
5
6
7
8
if __name__ == '__main__':
	data = {
		'商品名称': ['手机', '电视', '电脑', '耳机', '平板'],
		'商品编号': ['P001', 'T002', 'C003', 'E004', 'T005'],
		'单价': [5000, 3000, 4500, 500, 2000],
		'销量': [10, 10, 6, 30, 8]
	}
	df = pd.DataFrame(data)

选择单行:

1
2
# 创建DataFrame的时候没有指定索引，索引默认是1,2,...,n-1
df.loc[0]

image-20251111203310824

选择单列:

1
2
# 选择单价这一列
df.loc[:, '单价']

image-20251111203408192

选择多行多列:

1
2
# 选择第2 3 4行的商品名称和单价
df.loc[[1, 2, 3], ['商品名称', '单价']]

image-20251111203539402

切片操作:

1
2
# 第1 2 3 4行的'商品名称'到'单价'列
df.loc[:4, :'单价']

image-20251111203747093

布尔索引

1
2
# 单价大于1000的行
df.loc[df['单价'] > 1000]

image-20251111203844272

2.对字典的操作

增加新的键值对

1
2
3
4
5
6
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }

可以直接添加:

1
d['d'] = 4

也可以使用update方法

1
d.update({'d': 4})

也可以使用setdefault方法

1
d.setdefault('d', 4)

get()

从键获取值

获取存在的键的值

1
2
3
4
5
6
7
8
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }
    # v = 1
    d.get('a')

获取不存在键的值

1
2
3
4
5
6
7
8
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }

    d.get(__key='d')

image-20251111205447519

此时需要指定一个填充值

1
2
3
4
5
6
7
8
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }
    # 会获取到Unknown
    d.get('d', 'Unknown')

遍历字典

只遍历键

1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
	d = {
		'a': 1,
		'b': 2,
		'c': 3,
	}
	# 仅遍历键
	for x in d:
		print(x)

image-20251111205934301

使用items()获取(k,v)元组

  • 获取整个元组
1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }
    # 获取到(k,v)
    for x in d.items():
       print(x)

image-20251111210236074

  • 把元组解包
1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }
    # 获取到k:v
    for k, v in d.items():
       print(f"{k}:{v}")

image-20251111210329272

字典推导式

1
2
3
4
5
6
7
8
if __name__ == '__main__':
    d = {
       'a': 1,
       'b': 2,
       'c': 3,
    }
    d = {k: v for k, v in d.items() if v < 3}
    print(d)

image-20251111211320092

对字典进行排序

使用内置的sorted()函数进行排序

1
2
# reverse=False 升序 reverse=True 降序
sorted(要排序的对象,key=lambda x:...,reverse=)

根据键排序

1
2
3
4
5
6
7
8
if __name__ == '__main__':
	d = {
		'a': 1,
		'b': 2,
		'c': 3,
	}
    # sorted(d)返回的是键,需要重新获取值
	d = {k: d.get(k) for k in sorted(d, reverse=True)}

根据值排序

注意：要先用items()转换成列表

排序后要再使用dict()转换回列表

1
2
3
4
5
6
7
8
if __name__ == '__main__':
	d = {
		'a': 1,
		'b': 2,
		'c': 3,
	}
	d = dict(sorted(d.items(), key=lambda x: x[1], reverse=True))
	print(d)

image-20251111212710357

3.列表推导式

获取特定元素的索引列表

比如获取奇数元素的索引

1
2
3
if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5, 6]
    odd_idx = [i for i in range(len(arr)) if arr[i] % 2]

比如获取每个位置是否是奇数

1
2
3
if __name__ == '__main__':
	arr = [1, 2, 3, 4, 5, 6]
	odd_idx = [arr[i] % 2 for i in range(len(arr))]

image-20251111213417772

根据这个布尔数组获取到对应的元素

1
odd_list = [v for v, i in zip(arr, odd_idx) if i]

image-20251111213526883

4.lambda表达式

形式:

1
lambda 参数:返回值

5.map方法

1
map(函数,可迭代对象,...) -> 迭代器

比如常见的把输入分割后转成int的列表

1
int_list = list(map(int,input().split()))

或者输入两个整数,直接用map转换成两个int

1
a,b = map(int,input().split())

6.字符串内部按ascii排序

直接使用sorted()函数

1
2
3
if __name__ == '__main__':
    str = "sucnsimcsop"
    str = ''.join(sorted(str))

image-20251111214646388

7.字符串拆解成字符列表

直接用list()进行转换

1
2
3
if __name__ == '__main__':
    str = "sucnsimcsop"
    str = list(str)

image-20251111214849124

8.python中char和ascii之间的转换

使用ord()函数

1
2
# 返回97
ord('a')

9.日期计算

主要使用datetime这个库

主要用这三个工具:

1
from datetime import datetime, date, timedelta

获取当前年-月-日 时间

1
2
3
now = datetime.now()
# now:2025-11-11 21:55:13.309243
print(f"now:{now}")

获取当前日期

1
2
# 2025-11-11 yyyy-mm-dd
today = date.today()

建立特定年月日的日期对象

1
2
3
4
5
6
7
8
9
10
11
12
if __name__ == '__main__':
	year = 1991
	month = 1
	day = 1
	
	# 具体到时间 yyyy-mm-dd 时间
	daytime = datetime(year, month, day)
	print(daytime)
	
	# yyyy-mm-dd
	day = date(year, month, day)
	print(day)

计算日期差值

需要用到timedelta

1
timedelta(days=)

只能是date对象跟timedelta对象进行运算

计算直接+或者-

1
2
3
4
5
6
7
8
9
10
11
12
if __name__ == '__main__':
    year = 1991
    month = 1
    day = 1
    
    # yyyy-mm-dd
    day = date(year, month, day)
    print(day)
    
    delta = timedelta(days=2)
    print(day - delta)
    print(day + delta)

image-20251111220159570

获取星期几:

用.weekday()

10.输出格式控制

对齐

使用f-string的形式:

左对齐

1
2
text = "Hello World!"
print(f"{text:<10}")

居中

1
2
3
4
5
6
7
8
text = "Hello World!"
print(f"{text:^10}")

# 也可以使用str.center()方法
text.center(
		__width=, # 所占宽度
		__fillchar= # 填充字符
)

右对齐

1
2
text = "Hello World!"
print(f"{text:>10}")

填充

可以在上面的基础上设置填充字符

1
2
3
4
5
if __name__ == '__main__':
	text = "Hello World!"
	print(f"{text:*<100}")
	print(f"{text:=^100}")
	print(f"{text:->100}")

image-20251112080948141

数字格式化

保留几位小数

1
2
3
4
if __name__ == '__main__':
	num: float = 1.14514
    # 1.15
	print(f"{num:.2f}")

转换为百分数,并保留小数

1
2
3
4
if __name__ == '__main__':
	num: float = 1.14514
	# 114.51%
	print(f"{num:.2%}")

转化为16进制

1
2
3
4
5
6
if __name__ == '__main__':
	num: int = 114514
	# #表示展示前缀0x
	# 16:输出宽度为16
	# x:hex
	print(f"{num:#016x}")

转换为2进制

1
2
3
4
5
6
if __name__ == '__main__':
	num: int = 114514
	# #表示展示前缀0b
	# 16:输出宽度为16
	# b:binary
	print(f"{num:#016b}")

11.列表内多字段降升序，list.sort的使用

对元组数组进行排序:

重点是list.sort()方法的使用

key字段可以传入一个多个返回值的lambda表达式，以达到特定的效果，比如当我们预想的某个字段值相等时，可以根据别的字段进行排序

1
2
3
4
5
6
7
8
if __name__ == '__main__':
    arr = [
       ("Alice", 111),
       ("Bob", 222),
       ("Cam", 333),
    ]
    # 根据(a,b)的b进行降序排序,当b相等时根据a升序排序
    arr.sort(key=lambda x: (-x[1], x[0]))