归一

关于搭建数据分析师能力模型的思考置顶

2023-11-30

自2019年从事数据分析工作以来，已快有5个年头，在这个节点上，有必要重新对职业进行一次深度的思考，来解决当下职业发展的瓶颈期、迷茫期。
基于以往对数据分析的学习和在工作中实践理解，让我发现数据分析不仅仅是工具、技能，它更是一种思维方式和解决问题的能力——一种将现实问题转换为数据问题的思维方式，用数据方法解决现实问题的能力。

我们姑且将这种“能力”定义为：在特定业务背景下，将业务问题转换为数据问题，并合理利用数据工具帮助解决业务问题的能力。

Python常用数据对象

2024-06-18

数据处理能力 / Python

在Python中，有多种常用的数据对象（或称为数据类型）。这些数据类型用于存储和操作不同类型的数据。以下是一些常用的Python数据对象：

数字（Numbers）
整数（Integer）：没有小数部分的数，如 1, 2, 3 等。
浮点数（Float）：有小数部分的数，如 1.2, 3.14 等。
复数（Complex）：包含实部和虚部的数，如 3+4j。
字符串（String）
字符串是由一系列字符（包括字母、数字、标点符号和特殊字符）组成的序列，如 ‘Hello, World!’。
列表（List）
列表是包含有序元素的集合，元素之间用逗号分隔，整个列表用方括号括起来。列表的元素可以是任何数据类型，且可以混合使用。例如：[1, ‘a’, 3.14, [1, 2, 3]]。
元组（Tuple）
元组与列表类似，也是包含有序元素的集合，但元组是不可变的（即一旦创建，就不能修改）。元组用圆括号括起来，例如：(1, ‘a’, 3.14)。
集合（Set）
集合是一个无序且不包含重复元素的序列。集合用大括号或 set() 函数创建，例如：{1, 2, 3} 或 set([1, 2, 2, 3])（结果仍然是 {1, 2, 3}）。
字典（Dictionary）
字典是一个无序的键值对集合。字典用花括号或 dict() 函数创建，例如：{‘name’: ‘Alice’, ‘age’: 30}。字典中的键是唯一的，但值可以重复。
布尔值（Boolean）
布尔值只有两个可能的值：True 和 False。它们常用于条件判断或逻辑运算。
None
None 是Python中的一个特殊常量，表示空值或没有值。它不等于0、空字符串或空列表等。
字节串（Bytes）和字节数组（Bytearray）
字节串和字节数组用于处理二进制数据。字节串是不可变的，而字节数组是可变的。它们通常用于文件操作和网络通信等场景。
范围（Range）
range() 函数返回一个不可变的数字序列，通常用于在循环中迭代一系列整数。例如：range(5) 会生成一个从 0 到 4（不包含 5）的整数序列。
自定义对象（Custom Objects）
在Python中，你可以通过定义类（class）来创建自定义对象。这些对象可以包含属性（attributes）和方法（methods），用于存储和操作数据。

这些数据类型在Python编程中非常常用，它们为数据的存储、处理和操作提供了丰富的可能性。

当然，当我们谈论Python中的数据对象时，特别是在数据分析领域，numpy的数组（array）、pandas的Series和DataFrame是非常重要的。以下是这些对象的简要描述：

array数组
NumPy数组是一个多维数组对象，用于存储相同类型的数据。它提供了大量的数学函数来操作数组中的数据，包括统计、线性代数、傅里叶变换等。
Series字段
Series是一个一维数组对象，可以存储任何数据类型（整数、字符串、浮点数、Python对象等）。它有一个标签轴（即索引），使得可以通过标签来访问数据。
DataFrame表
DataFrame是一个二维的、大小可变的、具有潜在异构类型列的表格数据结构。它可以被看作是一个Series对象的字典（共享相同的索引）。

1、数值型

不可变、不可迭代
包含int（整型）、float（浮点型）、complex（复数型）

1.1、数值型数据的定义

# 整型、浮点型、复数型
a = 101
b = 3.14
c = 2 + 3j
print("输出结果：", type(a))
print("输出结果：", type(b))
print("输出结果：", type(c))

输出结果： <class 'int'>
输出结果： <class 'float'>
输出结果： <class 'complex'>

# int()函数将其他数据类型转化为int
a = '3'
b = int(a)
print("输出结果：", type(a))
print("输出结果：", type(b))

输出结果： <class 'str'>
输出结果： <class 'int'>

# int() 没法对小数字符直接转为整数
a = '11.2'
# int(a) 会报错
# x = int(input('请输入一个数:')) 输入小数会报错

# float()函数将其他数据类型转化为int
a = '11.2'
b = float(a)
c = int(b)  # 作为取整函数使用
print("输出结果：", type(a))
print("输出结果：", type(b))
print("输出结果：", type(c))

输出结果： <class 'str'>
输出结果： <class 'float'>
输出结果： <class 'int'>

# 复数的实数部分和虚数部分都是浮点数
a = 6 + 7j
print("输出结果：", a.real)  # 返回对象的real属性
print("输出结果：", a.imag)  # 返回复数的imag属性

输出结果： 6.0
输出结果： 7.0

1
2
3

# 返回共轭复数的方法
a = 6 + 7j
print("输出结果：", a.conjugate())

输出结果： (6-7j)

1.2、数值型数据的算术运算

下面以a=10 ,b=20为例进行计算

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	x除以y b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余	返回除法的余数 b % a 输出结果 0
**	幂	返回x的y次幂 a**b 为10的20次方，输出结果 100000000000000000000

1.3、数值型数据的比较运算

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a <= b) 为 true.

1.4、复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c * = a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

1.5、常用数值运算函数

常用内置函数	返回值
abs(x)	返回x的绝对值，类型随x
max(n1, n2, …)	返回最大值
min(n1, n2, …)	返回最小值
round(x [,n])	默认返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的n位。例如round(1.23456, 3)返回1.235
pow(x,y)	返回x的y次幂，即x**y

math库常用函数	返回值
math.ceil(x)	返回大于或等于x的最小整数，即向上取整
math.floor(x)	返回小于或等于x的最大整数，即向下取整
math.prod(x)	函数接受一个可迭代对象（如列表、元组或集合）作为输入，并返回这些元素的乘积
math.sqrt(x)	返回x的平方根
math.isnan(x)	如果x是“非数字”（NaN），则返回True

2、字符串

不可变、可迭代对象

2.1、字符串的定义

单引号’’
双引号””
三引号””” “””, ‘’’ ‘’’
str()

1	print("输出结果：", type("ABC"))

输出结果： <class 'str'>

# 通过str()函数将其他数据类型转化为字符串
a = 10
b = str(a)
print("输出结果：", type(a))
print("输出结果：", type(b))

输出结果： <class 'int'>
输出结果： <class 'str'>

2.2、字符串的常用运算

# +号运算
a = 'abc'
b = 'CDA'
c = a + b
print("输出结果：", a, b, c, sep='\n')

输出结果：
abc
CDA
abcCDA

# *号运算
a = '-'
b = a * 10
print("输出结果：", a, b, sep='\n')

输出结果：
-
----------

1
2
3

 # 查看字符串长度
a = "abcdef"
print("输出结果：", len(a))

输出结果： 6

1
2
3

# in 包含运算
s = 'ABACBBC'
print("输出结果：", 'A' in s)

输出结果： True

2.3、字符串的索引和切片

s[开始位置:终止位置:步长]

切片的开始位置能够取到，终止位置取不到
第三个参数：步长和方向。如果为正数，则从左往右取；如果为负数，则从右往左取，绝对值代表步长

# 索引
s = "人生苦短,我用python"
print("输出结果：", s[0])  # 取出字符'人'
print("输出结果：", s[-1])  # 取出字符'n'

输出结果： 人
输出结果： n

s = "人生苦短,我用python"
print("输出结果：", s[0:4])  # 取出字符串'人生苦短'
print("输出结果：", s[0:4:2])  # 取出字符串'人苦'
print("输出结果：", s[-10::-2])  # 取出字符串'短生'
print("输出结果：", s[s.find("短") - len(s)::-2])  # 取出字符串'短生'

输出结果： 人生苦短
输出结果： 人苦
输出结果： 短生
输出结果： 短生

1
2
3

# 反转字符串  
s = "abcdefg"
print("输出结果：", s[-1::-1])

输出结果： gfedcba

2.4、字符串对象的方法

2.41、3个检索的方法

计数str.count()
查找str.find()
索引str.index()

# 字符串计数
s = 'asdasdasascadscfdasd'
print("输出结果：", s.count("a"))  # "a"出现的次数
print("输出结果：", s.count("as"))  # "as"出现的次数

输出结果： 6
输出结果： 5

# 查找字符串位置
s = 'AASSDmAmS'
print("输出结果：", s.find('m'))  # 返回第一次出现的索引
print("输出结果：", s.find('M'))  # 找不到返回-1

输出结果： 5
输出结果： -1

# 查找字符串索引
s = 'AASSDmAmS'
print("输出结果：", s.index('m'))
# print("输出结果：", s.index('M'))  # 会直接报错

输出结果： 5

2.42、3个分割的方法

split()
splitlines()
partition()

# 默认是以 空格 \n \t等特殊字符进行分割
s = 'hello wo\trl\nd'
print("输出结果：", s.split())
print("输出结果：", s.split('o'))
print("输出结果：", s.split('o', 1))  # 指定分割次数， 默认全部分割

输出结果： ['hello', 'wo', 'rl', 'd']
输出结果： ['hell', ' w', '\trl\nd']
输出结果： ['hell', ' wo\trl\nd']

# 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
a = "关于你\r我有太多东西关于你\r\n清醒的时候放不下矜持\n不敢说我喜欢你\n只有在某个夜晚多愁善感又萦绕在心头\n或是朋友聚会上的大醉\n才敢借着情绪说\n我喜欢你\n喜欢了好久好久"
print("输出结果：", a.splitlines())  # 括号里面默认填False，效果一样，不显示换行符
print("输出结果：", a.splitlines(keepends=True))  # 为True就是显示分隔符为True就是显示分隔符

输出结果： ['关于你', '我有太多东西关于你', '清醒的时候放不下矜持', '不敢说我喜欢你', '只有在某个夜晚多愁善感又萦绕在心头', '或是朋友聚会上的大醉', '才敢借着情绪说', '我喜欢你', '喜欢了好久好久']
输出结果： ['关于你\r', '我有太多东西关于你\r\n', '清醒的时候放不下矜持\n', '不敢说我喜欢你\n', '只有在某个夜晚多愁善感又萦绕在心头\n', '或是朋友聚会上的大醉\n', '才敢借着情绪说\n', '我喜欢你\n', '喜欢了好久好久']

1
2
3

 # 只会分割成三个部分， 分隔符左边一个部分， 分隔符自己一个部分， 分隔符右边一个部分
s = '阿萨德哈asda哈阿萨德'
print("输出结果：", s.partition("哈"))

输出结果： ('阿萨德', '哈', 'asda哈阿萨德')

2.43、一个合并的方法

join()

1 2	# 使用 "-->" 连接字符 print("输出结果：", '-->'.join('Hello'))

输出结果： H-->e-->l-->l-->o

2.44、一个替换方法

replace()

1
2
3

# 将 "/"替换成 ","
a = '我爱北京天安门/天安门上太阳升/天安门很大!'
print("输出结果：", a.replace("/", ","))

输出结果： 我爱北京天安门,天安门上太阳升,天安门很大!

2.45、一个中心化的方法

center()

1 2	s = '标题' print("输出结果：", s.center(41, '-'))

输出结果： --------------------标题-------------------

2.46、2个大小写转换的方法

upper()
lower()

1
2
3

s = 'asdASDAAadc'
print("输出结果：", s.upper())  #  小写转大写
print("输出结果：", s.lower())  #  大写转小写

输出结果： ASDASDAAADC
输出结果： asdasdaaadc

2.47、3个去除两端特殊字符的方法

strip()
lstrip()
rstrip()

1
2
3

s = '  a  s  \n  \t '
print("输出结果：", s.strip())  #  删除两段特殊字符
print("输出结果：", s.strip(" a"))  # 删除两段特殊字符和指定字符

输出结果： a  s
输出结果： s

2.48、一个格式化输出的方法

format()

name = "王五"
age = 18
s = '欢迎你， {}，你的年龄是 {} 岁！'
print("输出结果：", s.format(name, age))
print("输出结果", '{}的年龄是{}岁{}'.format('小哥哥', 20, '!'))  # {}什么都不填写就依次传入
print("输出结果", '{2}的年龄是{0}岁{1}'.format('小哥哥', 20, '!'))  # 也在{}里面填入索引值
print("输出结果", '{name}的年龄是{age}'.format(age=20, name='小哥哥'))  # 参数位置可以不按顺序显示。

输出结果： 欢迎你， 王五，你的年龄是 18 岁！
输出结果 小哥哥的年龄是20岁!
输出结果 !的年龄是小哥哥岁20
输出结果 小哥哥的年龄是20

3、列表

可变、可迭代
列表里面的元素可以是python里面的一切数据类型

3.1、列表的定义

[]
list()

1	print("输出结果：", type([1, 2, 3]))

输出结果： <class 'list'>

1
2
3

# 通过list()将其他数据类型转换为列表
a = list('mysql')
print("输出结果：", a, type(a), sep='\n')

输出结果：
['m', 'y', 's', 'q', 'l']
<class 'list'>

3.2、列表的运算

+号运算

1 2	# 返回的是新列表，把两个列表的元素放到一个列表当中 print("输出结果：", [1, 2, 3] + [1, 2, 3])

输出结果： [1, 2, 3, 1, 2, 3]

*号运算

1
2
3

# 重复列表的元素
a = [1, 2, 3]
print("输出结果：", a * 3)

输出结果： [1, 2, 3, 1, 2, 3, 1, 2, 3]

in包含运算

# 判断是不是列表里面的元素
a = [1, 2, 3, 4, [1, 2, 'BI'], 'mysql', 'excel']
print("输出结果：", 2 in a)
print("输出结果：", "BI" in a)
print("输出结果：", [1, 2, 'BI'] in a)

输出结果： True
输出结果： False
输出结果： True

3.3、列表的索引和切片

一维列表的索引和切片

1 2	list1 = ['life', 'is', 'short', 'I', 'use', 'python'] print("输出结果：", list1[0]) # 取出 'life'

输出结果： life

多维列表的索引和切片

1
2
3

a = [1, 2, 3, 'Hello', [1, 2, [1, [1, 'RNG', 3], 3], 4, 5]]
print("输出结果：", a[4][2][1][1])  # 取出 'RNG'
print("输出结果：", a[-1][2][1][1])  # 取出 'RNG'

输出结果： RNG
输出结果： RNG

列表元素的修改

1
2
3

a = [1, 2, 3, 'a', [1, 2, 'python']]
a[2] = 10
print("输出结果：", a)  # 把3修改成10

输出结果： [1, 2, 10, 'a', [1, 2, 'python']]

3.4、列表对象的方法

3.41、3种增加元素的方法

追加list.append()
扩展list.extend()
插入list.insert()

# a.append(b) 将对象b作为元素追加到列表a的元素后面
a = [1, 2, 3]
b = ['a', 'b', 'c']
c = {'a': 2, 'b': 3}
a.append(10)  # 直接覆盖原列表，无返回值
print("输出结果：", a)
a.append(b)
print("输出结果：", a)
a.append(c)
print("输出结果：", a)

输出结果： [1, 2, 3, 10]
输出结果： [1, 2, 3, 10, ['a', 'b', 'c']]
输出结果： [1, 2, 3, 10, ['a', 'b', 'c'], {'a': 2, 'b': 3}]

# a.extend(b) 将列表b的元素追加到列表a的元素后面，b对象必须是可迭代（有索引切片）类型
a = [1, 2, 3]
b = ['a', 'b', 'c']
c = {'a': 2, 'b': 3}
a.extend(b)  # 直接覆盖原列表，无返回值
print("输出结果：", a)
a.extend(c)
print("输出结果：", a)

输出结果： [1, 2, 3, 'a', 'b', 'c']
输出结果： [1, 2, 3, 'a', 'b', 'c', 'a', 'b']

# a.append(b) 将对象b作为元素插到列表a的某个元素后面
a = [1, 2, 3]
b = ['a', 'b', 'c']
c = {'a': 2, 'b': 3}
a.insert(2, 10)  # 直接覆盖原列表，无返回值
print("输出结果：", a)
a.insert(2, b)
print("输出结果：", a)
a.insert(2, c)
print("输出结果：", a)

输出结果： [1, 2, 10, 3]
输出结果： [1, 2, ['a', 'b', 'c'], 10, 3]
输出结果： [1, 2, {'a': 2, 'b': 3}, ['a', 'b', 'c'], 10, 3]

3.42、4种删除元素的方法

del list[index]
清空list.clear()
list.pop()
移除list.remove()

# 删除列表的某些元素
a = [1, 2, 3, 'mysql', 5, 6, 'python']
del a[3]  # 直接覆盖原列表，无返回值
print("输出结果：", a)

输出结果： [1, 2, 3, 5, 6, 'python']

# 清空列表， 剩下一个空列表  
a = [1, 2, 3, 'mysql', 5, 6, 'python']
a.clear()  # 直接覆盖原列表，无返回值
print("输出结果：", a)

输出结果： []

a = [1, 2, 3, 'mysql', 5, 6, 'python']
a.pop()  # 删除并返回删除的元素， 默认是最后一个
print("输出结果：", a)
print("输出结果：", a.pop())

输出结果： [1, 2, 3, 'mysql', 5, 6]
输出结果： 6

# 移除第一次出现的匹配项
a = [1, 2, 3, 'a', 'c', 4, 's', 'c']
a.remove('c')  # 直接覆盖原列表，无返回值
print("输出结果：", a)

输出结果： [1, 2, 3, 'a', 4, 's', 'c']

3.43、2个检索的方法

计数list.counts()
索引ist.index()

1
2
3

# 对列表的某个元素计数
a = [1, 2, 3, 3, 4, 3, 2, 4, 3]
print("输出结果：", a.count(3))

输出结果： 4

1
2
3

# 默认返回第一次出现的索引，列表没有find方法
a = [1, 2, 3, 3, 4, 3, 2, 4, 3]
print("输出结果：", a.index(3))

输出结果： 2

3.44、2个排序的方法

list.sort()
list.reverse()

# 默认是进行升序排序
a = [1, 2, 3, 1, 2, 3, 7, 8, 4, 3, 0]
a.sort()  # 直接覆盖原列表，无返回值
print("输出结果：", a)
a.sort(reverse=True)  # reverse变成True为降序
print("输出结果：", a)

输出结果： [0, 1, 1, 2, 2, 3, 3, 3, 4, 7, 8]
输出结果： [8, 7, 4, 3, 3, 3, 2, 2, 1, 1, 0]

# 反转列表元素
a = [1, 2, 3, 1, 2, 3, 7, 8, 4, 3, 0]
a.reverse()  # 直接覆盖原列表，无返回值
print("输出结果：", a)

输出结果： [0, 3, 4, 8, 7, 3, 2, 1, 3, 2, 1]

4、元组

不可变、可迭代
元组的里面的元素可以是一切数据类型
元组又常常被称为只读列表

4.1、元组的定义

(,)
tuple()

1 2	a = (1, 2, 3) print("输出结果：", type(a))

输出结果： <class 'tuple'>

1
2
3

# 使用tuple()函数其他数据类型转化为元组
a = tuple('python')
print("输出结果：", type(a))

输出结果： <class 'tuple'>

易错点，单个元素的元组的定义，必须在元素后面加上一个逗号

a = (3)
b = ([1, 2])
c = (3,)
print("输出结果：", type(a))
print("输出结果：", type(b))
print("输出结果：", type(c))

输出结果： <class 'int'>
输出结果： <class 'list'>
输出结果： <class 'tuple'>

4.2、元组的运算

# +运算
a = (1, 2, 3)
b = (4, 5, 6)
print("输出结果：", a + b)

输出结果： (1, 2, 3, 4, 5, 6)

1 2	# 运算 print("输出结果：", (1, 2, 3) 3)

输出结果： (1, 2, 3, 1, 2, 3, 1, 2, 3)

1 2	# in 运算 print("输出结果：", 3 in (1, 2, 3))

输出结果： True

4.3、索引和切片

同列表数据类型

4.4、元组对象的方法

tuple.count()
tuple.index()

1
2
3

# 对元组的某个元素计数
a = (1, 2, 3, 3, 4, 3, 2, 4, 3)
print("输出结果：", a.count(3))

输出结果： 4

1
2
3

# 默认返回第一次出现的索引，列表没有find方法
a = (1, 2, 3, 3, 4, 3, 2, 4, 3)
print("输出结果：", a.index(3))

输出结果： 2

# 元组里面的二级对象（非元组）中的元素是可以改变的
a = (1, 2, 3, 4, [1, 2, 3, 'mysql'])
a[-1][-1] = 'python'
print("输出结果：", a)

输出结果： (1, 2, 3, 4, [1, 2, 3, 'python'])

a[-1] = 1

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

TypeError                                 Traceback (most recent call last)

Cell In[56], line 1
----> 1 a[-1] = 1


TypeError: 'tuple' object does not support item assignment

5、集合

可变、可迭代、无序不重复
关系测试，测试两组数据之前的交集、差集、并集等关系

5.1、集合的定义

{}
set()

1 2	st = {1, 2, 3, (1, 2, (1, 2))} print("输出结果：", st)

1 2	st = set('hello world') #创建一个唯一字符的集合 print("输出结果：", st)

1 2	b = {1, 2, 3, [1, 2]} # 集合里面的元素必须是不可变数据类型 print(b)

5.2、集合的运算

in包含运算，判断元素是否是集合中的元素
求交集set1 & set2 <==> set1.intersection(set2)
求并集set1 | set2 <==> set1.union(set2)
求补集set1 - set2 <==> set1.difference(set2):

1 2	a = {1, 2, 3} print("输出结果：", 1 in a)

set1 = set([1, 2, 3, 4, 5, 6])
set2 = set([1, 4, 6, 9, 10, 11, 12, 23])
print("输出结果：", set1)
print("输出结果：", set2)
print("交集：", set1 & set2)
print("并集：", set1 | set2)
print("补集：", set1 - set2)
print("补集：", set1.difference(set2))

5.3 集合的常用方法

在Python中，集合（set）类型提供了许多有用的方法来进行集合操作。以下是一些常用的集合方法，按照功能分类进行归纳：

5.31、添加元素

add(element): 向集合中添加一个元素。
update(iterable): 向集合中添加可迭代对象中的所有元素。

5.32、移除元素

remove(element): 从集合中移除一个指定的元素。如果元素不存在，则抛出KeyError异常。
discard(element): 从集合中移除一个指定的元素。如果元素不存在，则不执行任何操作，也不抛出异常。
pop(): 随机移除并返回一个元素。如果集合为空，则抛出KeyError异常。
clear(): 移除集合中的所有元素。

5.33、集合运算

union(set1, set2, ...) 或 set1.union(set2, ...): 返回多个集合的并集。
intersection(set1, set2, ...) 或 set1.intersection(set2, ...): 返回多个集合的交集。
difference(set1, set2) 或 set1.difference(set2): 返回一个集合中存在，但另一个集合中不存在的元素。
symmetric_difference(set1, set2) 或 set1.symmetric_difference(set2): 返回两个集合中互相不存在的元素。

5.34、判断关系

isdisjoint(set): 判断两个集合是否没有交集。
issubset(set) 或 set1.issubset(set2): 判断一个集合是否是另一个集合的子集。
issuperset(set) 或 set1.issuperset(set2): 判断一个集合是否是另一个集合的超集。

5.35、其他常用方法

len(set): 返回集合中元素的个数。
copy(): 返回集合的一个副本。

这些方法是Python中集合类型提供的一些常用功能，它们允许你执行各种集合运算和元素操作。

6、字典

6.1 字典的定义

可变、可迭代对象
点典的元素存储方式是键值对的形式，键值对之间用逗号隔开
键值对的形式形如：key:value
最外层用{}括起来
d = {key1 : value1, key2 : value2 }

由于字典是键值对的形式，所以字典是无序的，自然不能切片和索引，而是通过键来取值
键：一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
值：可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

1 2	a = {'a': 1, 'b': 2, 'c': 3} print("输出结果：", type(a))

1
2
3

# 使用dict()来创建字典
a = dict([('a', 1), ('b', 2), ('c', 3)])
print("输出结果：", a, type(a), sep='\n')

# 加减乘不可用，in运算可用
a = {'a': 1, 'b': 1, 'c': 2}
print("输出结果：", 1 in a)  # 这里判断的是是不是字典的键
print("输出结果：", 'a' in a)  # 这里判断的是是不是字典的键

1
2
3

a = {'a': 1, 'b': 1, 'c': 2}
print("输出结果：", a.keys())  # 查看字典的所有键
print("输出结果：", a.values())  # 查看字典的所有值

1
2
3

# 获取某个键的值
a = {'a': 1, 'b': 1, 'c': 2}
print("输出结果：", a.get('a'))

6.2、字典的运算

# in 运算，判断是否存在某个key
a = {'a': 1, 'b': 1, 'c': 2}
print("输出结果：", 1 in a)
print("输出结果：", 'a' in a)
print("输出结果：", 1 in a.values())

6.3、字典的常用方法

当对字典的常用方法进行归类时，我们可以将它们分为几个主要的类别：

6.31、字典的创建和初始化

dict()：用于创建新的空字典或从一个可迭代对象（如元组的列表）初始化字典。

6.32、字典的访问和查询

get(key[, default])：返回指定键的值，如果键不存在则返回默认值。
keys()：返回字典中所有键的视图对象。
values()：返回字典中所有值的视图对象。
items()：返回字典中所有键值对的视图对象。
contains(key)（通过in操作符使用）：检查字典中是否包含指定的键。

6.33、字典的修改

update([other])：使用来自另一个字典或键值对的项来更新字典。
setdefault(key[, default])：如果键不存在于字典中，则将其插入并设置其值，然后返回该值。
pop(key[, default])：如果键存在于字典中，则将其删除并返回其值；否则返回默认值。
popitem()：随机删除并返回一个键值对（在某些Python版本中，返回并删除最后插入的键值对）。

6.34、字典的删除和清空

clear()：删除字典中的所有项。
del dict[key]：通过键删除字典中的项。

6.35、字典的复制

copy()：返回字典的浅拷贝。

6.36、字典的视图和迭代

字典的keys()、values()和items()方法返回的都是视图对象，它们支持迭代，但不是列表。这些视图对象提供了字典的动态视图，它们会随着字典的更改而更改。

6.37、字典的大小

len()（通过len(dict)使用）：返回字典中的项数（键-值对的数量）。

6.38、字典的排序

字典本身是无序的，但可以使用sorted()函数和items()、keys()或values()方法一起对字典进行排序。

7、布尔值

运算符	逻辑表达式	描述	实例
and	x and y	布尔”与” - 如果 x 为 False，x and y 返回 x，否则它返回 y 。	(10 and 20) 返回 20。
or	x or y	布尔”或” - 如果 x 是 True，它返回 x ，否则它返回 y 。	(10 or 20) 返回 10。
not	not x	布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(10 and 20) 返回 False

1
2
3

# 布尔对象
T = True
F = False

# 布尔运算
print(T == 1)
print(F == 0)
print(T + F)
print(T * 2)
print(F * 2)

# 逻辑运算
print(T and F)
print(T or F)
print(not T)

1
2
3

# 逻辑运算优先级：not>and>or
print(T and F or T)
print(T or F and not F)

8、数据类型的转化

## 数值 <--------> 字符串
print(float(1))
print(str(1234).split('2'))
print(int('123'))

# print(int('1.23'))   ## 无法直接转化为int类型
print(float('1.23'))

1
2
3

## 字符串 <----> 列表
print(list('abcd'))
print(''.join(['a', 'b', 'c']))  # 列表中元素必须全部都是字符串才行！

## 列表(集合或元组) <-----> 字典
key = ['a', 'b', 'c']
value = [1, 2, 3]
dic = dict(zip(key, value))
print(dic)
print(list(dic))
print(set(dic.keys()))
print(list(dic.values()))

## 数组 <--------> 列表
import numpy as np

arr = np.ones((3, 3))
lt = arr.tolist()
print(lt)
print(np.array(lt))

## 字段  <------> 字典/列表
import pandas as pd

dic = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(dic)  ## 字典的key作为了字段的索引
print(ser)
print(ser.to_dict())
print(ser.to_list())

## 表  <------> 字典/列表import pandas as pd
dic = {'a': [1], 'b': [2], 'c': [3]}  # value必须是可迭代的二维数据
tab = pd.DataFrame(dic)  ## 字典的key作为了字段的索引
print(tab)
print(tab.to_dict())  ## DataFrame没有to_list()
print(tab.values.tolist())  ## tab.values 为数组对象

9、列表生成式

Python中的列表生成式（List Comprehension）是一种简洁、高效的方式来创建列表。它允许你在一行代码中创建列表，而不需要使用显式的循环语句（如for循环）。

列表生成式的基本语法如下：

[expression for item in iterable if condition]

expression：对于iterable中的每一个item，你都要对其执行的表达式，并把这个表达式的值作为新列表的元素。
item：iterable中的每一个元素。
iterable：一个可迭代对象，如列表、元组、字符串、集合或字典等。
condition（可选）：一个条件表达式，用于过滤iterable中的元素。只有满足这个条件的元素才会被包含在新列表中。

# 创建一个平方列表：
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]
print(squares)  # 输出: [1, 4, 9, 16, 25]


# 创建一个偶数列表（从1到10）：
even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers)  # 输出: [2, 4, 6, 8, 10]


# 使用嵌套列表生成式：
# 假设我们有一个二维列表，我们想将其转换为一个一维列表：
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [x for row in matrix for x in row]
print(flattened)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 从字典中提取键和值：
dict_items = {'a': 1, 'b': 2, 'c': 3}
keys = [key for key in dict_items]
values = [value for value in dict_items.values()]
print(keys)  # 输出: ['a', 'b', 'c']  
print(values)  # 输出: [1, 2, 3]  
# 或者直接提取键值对  
key_value_pairs = [(key, value) for key, value in dict_items.items()]
print(key_value_pairs)  # 输出: [('a', 1), ('b', 2), ('c', 3)]