NO.1
Python语法基础
Part_0 python的6大基本数据类型
- 数字
int
float
long
complex - 字符串
- 列表
- 元组
- 字典
- 集合
Part_1 变量
在Python中，变量指向一个值(内存地址)
1、变量命名规则：
1.变量名的长度不受限制，但其中的字符必须是字母、数字、或者下划线（_），而不能使用空格、连字符、标点符号、引号。
2.变量名的第一个字符不能是数字，而必须是字母或下划线。
3.Python区分大小写。
4.不能将Python关键字用作变量名。
5.一般地，函数命名用小写字母，类命名用驼峰命名法。
#可以同时给多个变量赋值
x,y,z=1,'China',"中国"
x,y,z
print(x)
1
#查看赋值的变量的值
print(y)
China
# id()查看内存位置
print(id(y))
2064701648656
#多重赋值的一个很实用的用途是交换两个变量的值
y,z = z,y
y
‘中国’
# 中文可以做变量吗?
中文变量 = '我是中文变量'
中文变量
‘我是中文变量’
# 查看变量的类型
type(y)
str
二、输入
input()
print(xx)与print(‘xx’)的区别。
# input函数接收来自键盘的输入
mobile=input('请输入你的手机号码：')
# print()函数用来输出
print('您输入的手机号码是:',mobile)
请输入你的手机号码：13240916919
您输入的手机号码是: 13240916919
type(mobile)
str
# 将接收到的手机号码转化为数值型
mob = int(input('请输入你的手机号码：'))
请输入你的手机号码：18945792714
type(mob)
int
三、运算符
运算符 意义
x = y 将y赋值给x
x + y 返回x + y的值
x - y 返回x - y的值
x * y 返回x * y的值
x / y 返回x / y的值
x // y 返回x除y的整数部分
x % y 返回x除以y的余数
abs(x) 返回x的绝对值
int(x) 返回x的整数值
float(x) 返回x的浮点数
divmod(x, y) 相当于(x//y, x%y)
pow(x, y) 返回x的y次方
x ** y 相当于pow()
x < y 判断x是否小于y，是返回真否则返回假
x <= y 判断x是否小于等于y，是返回真否则返回假
x > y 判断x是否大于y，是返回真否则返回假
x >= y 判断x是否大于等于y，是返回真否则返回假
x == y 判断x是否等于y，是返回真否则返回假
x != y 判断x是否不等于y，是返回真否则返回假
x is y 判断x的地址（id）是否等于y，是返回真否则返回假
x is not y 判断x的地址（id）是否不等于y，是返回真否则返回假
x = 5
y = 3
print(x+y)
print(x-y)
print(x*y)
print(x/y)
8
2
15
1.6666666666666667
print(x//y)
print(x%y)
1
2
print(abs(x))
print(int(y))
print(float(x))
5
3
5.0
print(divmod(x,y))
print(pow(x,y))
print(x**y)
(1, 2)
125
125
print(x<y)
print(x>y)
print(x==y)
print(x!=y)
print(x is y)
print(x is not y)
False
True
False
True
False
True
四、字符串索引切片
s = "我是河北人!"
# 访问字符串中的某个字符。Python索引从0开始，访问指定的n位置用:[n],适用于列表、元组
s[2]
‘河’
#切片均为左闭右开，[start:stop:step]，即取不到stop的值。
s[2:5]
‘河北人’
s[1:6:2] #从索引1到5中每隔1个取值
‘是北!’
# 从身份证上提取出生地
id ='110824199008088088'
s_1 = id[0:6]
s_1
‘110824’
# 提取出生年月
s_2 = id[6:14]
s_2
‘19900808’
# 字符串的加法即是将两个字符串连接
s_1 + s_2
‘11082419900808’
#字符串的乘法即是对字符串进行多次复制
s_1*3
‘110824110824110824’
字符串格式化
格式化的3种方式:
1. %格式化
2. .format()格式化
# %格式化，这里的y是变量
print('中国的中文是 %s'%y)
# format格式化
print('中国的英文是{}'.format(z))
# 多个变量的输出用索引更方便自由
zg='中国'
print('{0}的英文是{1}'.format(zg,z))
中国的中文是 中国
中国的英文是China
中国的英文是China
s = 'mqES3Dj4bY89XAllm9eQPo'
s
‘mqES3Dj4bY89XAllm9eQPo’
# 反转大小写
s.swapcase()
‘MQes3dJ4By89xaLLM9EqpO’
# 判断数字
str_1 = '1234'
print(str_1.isdigit())
str_2 = 'nsv5'
print(str_2.isdigit())
True
False
# 统计某个字符出现的次数
s.count('m')
2
# 反转字符串
s[::-1]
‘oPQe9mllAX98Yb4jD3SEqm’
# 字符串搜索与替换
str_3 = "我爱我的祖国"
# find找到子串,并返回最小索引值
print(str_3.find('爱'))
# 替换所有的内师大为nsd
print(str_3.replace('祖国','家乡'))
1
我爱我的家乡爱
# strip:删除字符串左边和右边的空格;
str_4 = " \t \n hello python \nhello "
str_4
’ \t \n hello python \nhello ’
print(str_4.strip())
hello python
hello
print(str_4.lstrip())
print('--------------------')
print(str_4.rstrip())
hello python
hello
hello python
hello
print(str_4.replace(' ',''))
hellopython
hello
# 字符串的分离和连接
str_5 = '192.168.0.100'
s = str_5.split('.')
s
[‘192’, ‘168’, ‘0’, ‘100’]
date = '2019-09-02'
date1 = date.split('-')
date1[0]
‘2019’
print(''.join(date1))
20190902
print('/'.join(date1))
2019/09/02
a = "hello world i want a iPhone \tcowjcw\tovbub \t covxoq jcocn"
b = a.split()
' '.join(b)
‘hello world i want a iPhone cowjcw ovbub covxoq jcocn’
五、列表（List）
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字索引，第一个索引是0，第二个索引是1，依此类推。
- 注意: 列表的元素不需要类型相同。
# list的创建,方法1
l1 = list('abcd')
l1
[‘a’, ‘b’, ‘c’, ‘d’]
#方法二
l2 = [1,2,3,4,5]
l2
[1, 2, 3, 4, 5]
# 方法三
# print(range(10))
type(range(10))
range(10)
range(0, 10)
l3 = list(range(5))
l3
[0, 1, 2, 3, 4]
print(l1)
print(l2)
print(l3)
[‘a’, ‘b’, ‘c’, ‘d’]
[1, 2, 3, 4, 5]
[0, 1, 2, 3, 4]
#list的元素类型不拘一格
list1 = [7,'中国','China',[3,'美国','America']]
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’]]
列表索引
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’]]
print('list1[2]:',list1[2])
list1[2]: China
list1[3]
[3, ‘美国’, ‘America’]
#二维索引
list1[3][2]
‘America’
list1[3][:2]
[3, ‘美国’]
#列表反转
list1[::-1]
[[3, ‘美国’, ‘America’], ‘China’, ‘中国’, 7]
type(list1.reverse())
NoneType
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’]]
list1.reverse()
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’]]
list填加元素：append()、extend()、insert()
# 末尾添加元素
list1.append('abc')
list1
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’], ‘abc’]
#指定的位置上添加呢？——insert(n,str)
list1.insert(4,'xyz')
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’], ‘xyz’, ‘abc’]
list2 = ['xx','yy']
list1.extend(list2)
list1
[7, ‘中国’, ‘China’, [3, ‘美国’, ‘America’], ‘xyz’, ‘xyz’, ‘abc’, ‘xx’, ‘yy’]
注意： 复制列表中的坑
list_0 = [2,4,6]
list_1 = list_0 #复制一份
list_1
[2, 4, 6]
list_1.append(0) #给lis_2添加一个元素0，观察变量lis_0的变化
list_1
[2, 4, 6, 0]
list_0
[2, 4, 6, 0]
print(id(list_0),id(list_1)) #观察lis_0和lis_2的存储地址是否相同
81404488 81404488
删除列表元素 list.pop(n)、list.remove(xx) 、list.remove()、del list[n]
list_0
[2, 4, 6, 0]
#删除指定的索引位置元素，默认删除最后一个元素，并将删除的元素显示
list_0.pop()
# list_0
0
list_0
[2, 4, 6]
list_0.remove(2)
list_0
[4, 6]
del list_0[:2]
list_0
[]
del list_0
报错
NameError Traceback (most recent call last)
in
----> 1 list_0
NameError: name ‘list_0’ is not defined
list_0 = [1,2,3,4]
list_1 = list_0
print(id(list_0))
print(id(list_1))
84208008
84208008
#重新复制：将list_0中的每一个元素赋值给list_3，再观察list_3和list_0的存储地址变化
list_3 = list_0[:]
list_3
[1, 2, 3, 4]
#拷贝时宜使用这种方法，或者使用.copy()
print('list_0和list_3的存储地址分别为：',id(list_0),id(list_3))
list_0和list_3的存储地址分别为： 84208008 81406152
list_4 = list_0.copy()
print('list_0和list_4的存储地址分别为：',id(list_0),id(list_4))
list_0和list_4的存储地址分别为： 84208008 84207880
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值
c = copy.copy(a) #浅拷贝
d = copy.deepcopy(a) #深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
print( 'a = ', a )
print(id(a))
print( 'b = ', b )
print(id(b))
print( 'c = ', c )
print(id(c))
print( 'd = ', d )
print(id(d))
a = [1, 2, 3, 4, [‘a’, ‘b’, ‘c’], 5]
81762312
b = [1, 2, 3, 4, [‘a’, ‘b’, ‘c’], 5]
81762312
c = [1, 2, 3, 4, [‘a’, ‘b’, ‘c’]]
81763336
d = [1, 2, 3, 4, [‘a’, ‘b’]]
81763656
del list1[2:4] #删除一个索引片段，也可以彻底删除整个列表
list1
修改list元素的值
list1[0] = 9 #直接赋值修改
list1
[9, ‘中国’, ‘China’, [3, ‘美国’, ‘America’], ‘xyz’, ‘xyz’, ‘abc’, ‘xx’, ‘yy’]
# 枚举
list1 = list('abcd')
for i,v in enumerate(list1):
print(i,v)
0 a
1 b
2 c
3 d
Python list 常用方法总结
一）添加新的元素
list.append(s) 在list 末尾增加一个元素s
list.insert（n,s） 在指定位置n添加元素s，如果指定的下标不存在则在末尾添加
list1.extend(list2) 合并list1、list2，把list2中元素追加在list1元素后面
二）查看列表中的值
遍历列表
for i in list:
print(i)
list[n] 使用索引来访问列表中的值，同样也可以使用方括号的形式截取字符
list.count(x) 查看某个元素在这个列表里的个数，如果元素不存在，那么返回0
list.index(x) 找到这个元素的索引，返回第一个，若不存在会报错
三）删除list 中的元素
list.pop(n) 删除指定索引的元素，默认删除最后一个元素，若不存在会报错
list.remove(x) 删除list 里面的一个元素，有多个相同的元素，删除第一个
del list[n] 删除指定索引的元素或切片del list[n:m]
del list 删除整个列表， list删除后无法访问
删除其中指定的某个元素的所有元素，如list0 = [1,2,1,3,1,2,4]，删除所有的1.
while i in list0:
…list0.remove(i)
print(list0)
四）排序和反转
list.reverse() 将列表反转
list.sort() 排序，默认升序
list.sort(reverse=True) 降序排列
注：list 中同时包含字符串和数字时,不能排序，排序针对同类型
五）列表操作的函数
len(list)：列表元素个数
max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
enumerate 枚举（打印元素对应的下标）
lis = [‘a’,‘b’,‘c’]
for a,b in enumerate(lis):
print(‘index=%s; value=%s’%(i,v))
六）list切片
list[n:m] 切片是不包含后面那个元素的值（顾头不顾尾,左开右闭）
list[:m] 如果切片前面一个值缺省的话，表示从开头开始取
list[n:] 如果切片后面的值缺省的话，表示取到末尾
list[:] 如果全部缺省，表示取全部元素
list[n:m:s] s：步长,表示隔多少个元素取一次。步长是正数，从左往右取；步长是负数，从右往左取
注：切片同样适用于字符串。
len()
list1 = ['life','is','short']
list2 = ['you','need','python']
# 输出python的下标
# 在short后增加逗号,在python后面增加叹号
# 合并list1 list2
# 把python改成python3
六、元组（tuple）
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
元组与字符串类似，下标索引从0开始，可以进行截取，组合等
tup1 = ('Google', 3.14, 97, [1,3]) #元素类可以多样化
tup2 = (1,) #只有一元素的元组需要在元素后添加逗号
tup3 = "a", "b", "c", "d"
tup4 = tuple([1,2,3,4])
# 不需要括号也可以
print(tup1,tup2,tup3,tup4)
(‘Google’, 3.14, 97, [1, 3]) (1,) (‘a’, ‘b’, ‘c’, ‘d’) (1, 2, 3, 4)
tup1[3] #访问元组中的元素
[1, 3]
tuple(tup1[3]) #将列表转化为元组
(1, 3)
len(tup1)
4
max(tup3) # 取tuple中最大的值,比较方法 ASCII码。
‘d’
tup2*3 #数乘表示复制
(1, 1, 1)
t = tup1 + tup2
t
#元组的加法
(‘Google’, 3.14, 97, [1, 3], 1)
print(id(t),id(tup1),id(tup2))
81847312 81577448 131531664
七、字典（dict）
字典，又叫键值对，是一种通过关键字引用的数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。
键必须独一无二，但值则不必。
值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
字典基本的操作包括如下：
(1)len()：返回字典中键—值对的数量；
(2)d[k]:返回关键字对应的值，k表示键；
(3)d[k]=v:将值关联到键k上；
(4)del d[k]:删除键为k的项；
(5)key in d:键key是否在字典d中，是返回True，否则返回False。
#定义一个字典,方法一
d={'a':10,'b':20,"c":12,'d':53}
d
{‘a’: 10, ‘b’: 20, ‘c’: 12, ‘d’: 53}
d['a']
#方法二
d1=dict(a=1,b=2,c=3) #也可以如此定义
d1
{‘a’: 1, ‘b’: 2, ‘c’: 3}
# 方法三
d2=dict([['a',12],[5,'a4'],('zhangsan',20)]) #可以将二元列表/元组作为元素的列表/元组转化为字典d3=dict((['a',12],(5,'a4'),['hel','rt']))
d2
{‘a’: 12, 5: ‘a4’, ‘zhangsan’: 20}
# 方法四
list1 = list('abcd')
list2 = range(4)
d3 = dict(zip(list1,list2))
d3
{‘a’: 0, ‘b’: 1, ‘c’: 2, ‘d’: 3}
d1['b']
2
d1.get('b') # 也可用取键b的对应值
2
d3.items() #items方法获取字典的项列表，是一个二元元组构成的列表
dict_items([(‘a’, 0), (‘b’, 1), (‘c’, 2), (‘d’, 3)])
d3.keys() #获取字典的所有key的列表。d2.values()表示获取字典的所有value的列表
dict_keys([‘a’, ‘b’, ‘c’, ‘d’])
d3.values()
dict_values([0, 1, 2, 3])
for i,v in d3.items():
print(i,v)
a 0
b 1
c 2
d 3
d3['c'] = 100 #【修改】字典hel键对应的值
d3
{‘a’: 0, ‘b’: 1, ‘c’: 100, ‘d’: 3}
d3['e'] = 5 #【增/追加】新的键值对
d3
{‘a’: 0, ‘b’: 1, ‘c’: 100, ‘d’: 3, ‘e’: 5}
d1
{‘a’: 12, ‘b’: 2, ‘c’: 3, 5: ‘a4’, ‘zhangsan’: 20}
d2
{‘a’: 12, 5: ‘a4’, ‘zhangsan’: 20}
#【合并】两个字典用update()
d1.update(d2) #将字典d2中的键值对追加进d1
d1
{‘a’: 12, ‘b’: 2, ‘c’: 3, 5: ‘a4’, ‘zhangsan’: 20}
d2.pop(5) #【删除】key='y'的项
d2
{‘a’: 12, ‘zhangsan’: 20}
del d2['a'] # 删除键值对'a'
d1.clear() # 清空字典，让字典变成一个空字典
del d # 删除字典
print(d2)
len(d1)
print(d) #由于d已经被删除，所以已经不存在这个变量了
#键是不可变的，可以是数字、字符串、元组，但不能是列表
dict1 = {['Name']: 'Runoob', 'Age': 7}
#坑点2：键必须是唯一的，只显示最后一次赋值的
dict2 = {'Name': 'tim', 'Age': 7, 'Name': 'tom'}
dict2
八、集合（set）
- set是一个无序且不重复的元素集合
- 集合支持用in和not in操作符检查成员
- 由len()内建函数得到集合的基数(大小)
- 用 for 循环迭代集合的成员。但是因为集合本身是无序的，遍历出来的成员是无序的。
- set和dict一样，只是没有value，相当于dict的key集合
#创建集合
s = {11,'a',(4,1)}
s
{(4, 1), 11, ‘a’}
#set()的一个主要功能就是过滤重复值
a = [1,2,3,1,4,2]
b = set(a)
b
{1, 2, 3, 4}
# pop()方法随机删除一个值,但是实现细节为删除hashmap中的第一个条目,因为hash散列的特性看起来是从小的开始
b.pop()
3
#添加新元素
b.add(3)
b
{1, 2, 3, 4}
#删除指定元素
b.remove(3)
b
{1, 2, 4}
#删除指定的元素
b.discard(2)
b
{1, 4}
# 删除不存在的值会报错
b.remove(2)
KeyError Traceback (most recent call last)
in
1 # 删除不存在的值会报错
----> 2 b.remove(2)
KeyError: 2
#删除不存在的值不会报错
b.discard(2)
#取交集
see = {11, 22, 33}
bee = {22, 55}
#取交集，赋给新变量
inter = see.intersection(bee)
print(inter)
{22}
#取并集
see = {11, 22, 33}
bee = {22, 44, 55}
inter2 = see.union(bee) #取并集，并赋给新变量
print(inter2)
{33, 22, 55, 11, 44}
#判断子、父集
se = {11, 22, 33}
be = {22}
print('se是be的子集吗?',se.issubset(be)) #判断se是否是be的子集合
print('se是be的父集吗?',se.issuperset(be)) #判断se是否是be的父集合
se是be的子集吗? False
se是be的父集吗? True
#取差集
see = {11, 22, 33}
bee = {22}
see - bee
{11, 33}
十、模块与包
模块，在Python可理解为对应于一个文件。在创建了一个脚本文件后，定义了某些函数和变量。你在其他需要这些功能的文件中，导入这模块，就可重用这些函数和变量。
包通常总是一个目录，可以使用import导入包，或者from + import来导入包中的部分模块。包目录下为首的一个文件便是 __init__.py。然后是一些模块文件和子目录，假如子目录中也有 __init__.py 那么它就是这个包的子包了。
nums = [1.23e+18, 1, -1.23e+18]
sum(nums)
0.0
import math
nums = [1.23e+18, 1, -1.23e+18]
math.fsum(nums) #在math模块下有一个求和函数fsum()
1.0
import math as m #导入模块math，并给它取个别名m替代math，省去了后面的代码中经常输入math
nums = [1.23e+18, 1, -1.23e+18]
m.fsum(nums) #直接简用m替代了math
1.0
十一、流程控制
编程语言中的流程控制语句分为以下几类：
>顺序语句
>分支语句
>循环语句
分支：
if 判断条件1:
…代码块1
elif 判断条件2:
…代码块2
else:
…代码块3
循环：
- while循环。当判断条件值为True时执行代码块，否则退出循环。
while循环语句的基本形式如下：while 判断条件:
…代码块
- for循环。for循环通常用于遍历序列(如list、tuple、range、str)、集合(如 set)和映射对象(如dict)。
for循环的基本格式：for 临时变量 in 可迭代对象:
…代码块
- 循环控制语句。循环控制语句可以更改循环体中程序的执行过程，如中断循环、跳过本次循环。
break -> 终止整个循环
continue -> 跳过本次循环，执行下一次循环
pass -> pass语句是个空语句，只是为了保持程序结构的完整性，没有什么特殊含义。pass语句并不是只能用于循环语句中，也可以用于分支语句中。
#判断输入的成绩是属于哪个档次：
grade = ['优','良','中','可','差'] #成绩层次分类
s = int(input('请输入分数：')) #接收键盘输入
if s < 60:
print(grade[4])
elif s >= 60 and s<70: #else if
print(grade[3])
elif s >= 70 and s<80:
print(grade[2])
elif s >= 80 and s<90:
print(grade[1])
else:
print(grade[0])
#for循环遍历
a = 'I like to stay in China'
b = list(a)
for i in b:
print(i)
I
l
i
k
e
t
o
s
t
a
y
i
n
C
h
i
n
a
b
[‘I’,
’ ',
‘l’,
‘i’,
‘k’,
‘e’,
’ ',
‘t’,
‘o’,
’ ',
‘s’,
‘t’,
‘a’,
‘y’,
’ ',
‘i’,
‘n’,
’ ',
‘C’,
‘h’,
‘i’,
‘n’,
‘a’]
i = 0
while i < 5:
print(b[i])
i=i+1
I
l
i
k
e
t
o
s
t
a
y
i
n
C
h
i
n
a
十二、函数
函数的定义：在 Python 中，函数的定义基本形式如下。
def function(params):
…"""
… 这里的文字是函数文档注释，便于help()函数调用查阅。
…"""
…block
…return value
def add(a,b):
return a+b
add(2,3)
5
# 定义一个函数,返回列表元素的和
def accumulate(a):
sum = 0
for i in a:
sum=sum+i
return sum
li = list(range(5))
accumulate(li)
10
li
[0, 1, 2, 3, 4]
Lambda 匿名函数，也叫行内函数
lambda 它只是一个表达式，函数体比 def 简单很多。
lambda 函数的用途：
1 对于单行函数，使用 lambda 可以省去定义函数的过程，让代码更加精简。
2 在非多次调用函数的情况下，lambda 表达式即用即得，提高性能。
格式：
lambda 参数:表达式`
lambda1 = lambda x : x+2
lambda2 = lambda x,y : x+y
print(lambda1(10))
print(lambda2(3,4))
12
7
#映射函数map(func，S) 将传入的函数 func 依次作用到序列 S 的每个元素，并把结果作为新的序列返回。
m = map(lambda x: x+1, (1,2,3))
list(m)
[2, 3, 4]
t = tuple(m)
t
()
# filter()过滤函数：指在给定的条件上（参数1）对某域（参数2）进行过滤
fl = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(fl)
[3, 6, 9]
tuple(fl)
()
# reduce()累计计算函数:
# 需要引入functools包
from functools import reduce
a_1 = reduce(lambda a,b: a * b, [1, 2, 3, 4, 5, 6, 7, 8, 9]) #计算9！
a_2 = reduce(lambda a,b: a + b, list(range(1,10))) #计算1+2+...+9的和
print("9!:",a_1)
print("求和：",a_2)
9!: 362880
求和： 45
NO.2
NumPy基础：数组和矢量计算
NumPy的部分功能如下：
# 要使用numpy首先要导入numpy对应的包
import numpy as np
# 创建一个100w维的ndarray
my_arr = np.arange(1000000)
# 创建一个100w维的list
my_list = list(range(1000000))
示例1，numpy的速度
魔法函数
- 魔法函数使我们能够以简单的代码实现复杂功能
%%timeit -n 50
my_arr2 = my_arr * 2
2.1 ms ± 437 µs per loop (mean ± std. dev. of 7 runs, 50 loops each)
%%timeit -n 50
my_list2 = [x * 2 for x in my_list] #列表推导式
96.1 ms ± 1.34 ms per loop (mean ± std. dev. of 7 runs, 50 loops each)
96.1/2.1
45.76190476190476
练习
- 创建一个200w维的列表,并计算执行每个元素平方的总执行时间
- 用列表创建一个200w维的ndarray,并计算执行每个元素平方的总执行时间
- 用列表创建不同类型数据的ndarray,看看结果有什么特点
1.2 创建ndarray
import numpy as np
# 列表创建array
data_test = [1,2,3,4,5] # 创建一个列表
arr_test = np.array(data_test) # 把列表转化成数组
arr_test # 显示这个数组
array([1, 2, 3, 4, 5])
data_test = list('abcd')
data_test
[‘a’, ‘b’, ‘c’, ‘d’]
np.array(data_test)
array([‘a’, ‘b’, ‘c’, ‘d’], dtype=’<U1’)
# 列表创建array
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)
print('多维数组的大小是：',arr2.shape)
arr2
多维数组的大小是： (2, 4)
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
data2
[[1, 2, 3, 4], [5, 6, 7, 8]]
# 使用元组创建ndarray
data3 = (1,2,3,4,5) # 创建一个元组
arr3 = np.array(data3) # 用元组创建多维数组
arr3
array([1, 2, 3, 4, 5])
arr3 * 2
array([ 2, 4, 6, 8, 10])
# 字典可以吗？
data4 = [{'a':1,'b':2,'c':3},{'d':1,'e':2,'f':3}]
arr4 = np.array(data4)
arr4
array([{‘a’: 1, ‘b’: 2, ‘c’: 3}, {‘d’: 1, ‘e’: 2, ‘f’: 3}], dtype=object)
# 集合可以吗
data5 = [set([1,2,2,3,4,4]),set([14,5,6,35])]
arr5 = np.array(data5)
arr5
array([{1, 2, 3, 4}, {35, 5, 14, 6}], dtype=object)
array() 将输入的列表，元组，或者其他类型的数据转换成ndarray
还有其他的ndarray创建方法吗？
# np.array((1,2))
arr6 = np.zeros((3,2))
arr6_1 = np.zeros_like(arr2)
print(arr6)
print(arr6_1)
[[0. 0.]
[0. 0.]
[0. 0.]]
[[0 0 0 0]
[0 0 0 0]]
arr7 = np.ones((2,3))
arr7
array([[1., 1., 1.],
[1., 1., 1.]])
arr7_1 = np.ones_like(arr7)
arr7_1
array([[1., 1., 1.],
[1., 1., 1.]])
arr9 = np.empty(10)
arr9
array([2.41907520e-312, 1.18831764e-312, 1.29441743e-312, 2.33419537e-312,
9.76118064e-313, 2.20687562e-312, 2.14321575e-312, 2.44029516e-312,
1.12465777e-312, 8.70018274e-313])
arr10 = np.array(range(10))
arr10
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr11 = np.arange(1,10,0.1)
arr11
array([1. , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2,
2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5,
3.6, 3.7, 3.8, 3.9, 4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8,
4.9, 5. , 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1,
6.2, 6.3, 6.4, 6.5, 6.6, 6.7, 6.8, 6.9, 7. , 7.1, 7.2, 7.3, 7.4,
7.5, 7.6, 7.7, 7.8, 7.9, 8. , 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7,
8.8, 8.9, 9. , 9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9])
# 创建随机数组
arr12 = np.random.randn(100000)
arr12.mean()
-0.002664828475653622
arr12.std()
0.9999598107387702
arr13 = np.random.randint(1,100,20).reshape(5,4)
arr13
array([[49, 49, 88, 15],
[49, 30, 62, 24],
[98, 6, 50, 86],
[22, 22, 46, 4],
[40, 31, 27, 3]])
np.random.rand(10)
array([0.5381553 , 0.80077871, 0.10882643, 0.88687383, 0.71374913,
0.48756588, 0.10824332, 0.32053562, 0.22284768, 0.67629097])
# 创建线性数组 Linear
arr14 = np.linspace(11,21,20,endpoint=False)
arr14
array([11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. , 15.5, 16. ,
16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. , 20.5])
# 创建单位矩阵
arr15 = np.eye(5)
arr15
array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
1.3 numpy数据类型
# numpy 的常用属性和方法
import numpy as np
data1 = [[6, 7.5, 8, 0, 1],[1,2,3,4,5]]
arr1 = np.array(data1)
# print(data1)
# print(arr1) # 输出数组，注意和列表的区分
print(arr1.ndim) # 输出数组维度的个数
print(arr1.shape) # 输出数组的维度，即数组是几行几列组成的
print(arr1.size) # 输出数组的元素总数，对于m行n列的数组，元素总数为m*n
print(arr1.dtype) # 输出数组元素的类型
print(arr1.itemsize) # 输出元素占用字节的大小
arr1
2
(2, 5)
10
float64
8
array([[6. , 7.5, 8. , 0. , 1. ],
[1. , 2. , 3. , 4. , 5. ]])
# Python的属性和方法
class Employee:
# 构造函数
def __init__(self, name, salary):
self.name = name
self.salary = salary
# "学习"函数
def study(self):
print ("{} can study by himself/herself".format(self.name))
# "工作"函数
def work(self):
print ("{} have to work hardly".format(self.name))
# 创建 Employee 类的第一个对象
emp1 = Employee("Zara", 2000)
# 创建 Employee 类的第二个对象
emp2 = Employee("Manni", 5000)
print(emp1.name)
print(emp2.salary)
emp1.study()
emp2.work()
Zara
Zara can study by himself/herself
Manni have to work hardly
type(arr1)
numpy.ndarray
Python的对象类型怎么看？
l = [1,2,3]
type(l)
list
type(arr1)
numpy.ndarray
arr1.dtype
dtype(‘float64’)
- type() 和 dtype 有什么区别？
创建数组时指定元素类型
arr1 = np.array([1, 2, 3], dtype=np.float64)
arr2 = np.array([1, 2, 3], dtype=np.int64)
arr3 = np.array([1,2,3.0])
print(arr1.dtype)
print(arr2.dtype)
print(arr3.dtype)
float64
int64
float64
# 转换数据类型
arr = np.array([1.0,2.0,3,4,5],dtype=np.float32)
print(arr.dtype)
arr1 = arr.astype(np.int32)
print(arr1.dtype)
float32
int32
arr.dtype
dtype(‘float32’)
arr1.dtype
dtype(‘int32’)
arr1_1 = arr.astype(np.int64)
arr1_1.dtype
dtype(‘int64’)
arr3.astype(np.float)
array([1., 2., 3.])
1.4 NumPy数组的运算
arr = np.array([[1., 2., 3.], [4., 5., 6.]])
arr
array([[1., 2., 3.],
[4., 5., 6.]])
print(arr + arr)
print('---------')
print(arr - arr)
print('---------')
print(5 * arr)
print('---------')
print(1/arr)
print('---------')
print(arr * arr)# 矩阵的数乘
print(arr.dot(arr.T))
[[ 2. 4. 6.]
[ 8. 10. 12.]]
[[0. 0. 0.]
[0. 0. 0.]]
[[ 5. 10. 15.]
[20. 25. 30.]]
[[1. 0.5 0.33333333]
[0.25 0.2 0.16666667]]
[[ 1. 4. 9.]
[16. 25. 36.]]
[[14. 32.]
[32. 77.]]
1.5 索引和切片
1.5.1 常规索引
arr = np.arange(10)
print(arr)
print(arr[0])
print(arr[5])
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d)
print(arr2d[2])
print(arr2d[0][0])
print(arr2d[2][2])
print(arr2d[1][1])
[0 1 2 3 4 5 6 7 8 9]
0
5
[[1 2 3]
[4 5 6]
[7 8 9]]
[7 8 9]
1
9
5
1.5.2 切片
arr
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 切片
print(arr[5:8])
arr[5:8] = 0 # 切片赋值
print(arr)
[5 6 7]
[0 1 2 3 4 0 0 0 8 9]
arr
array([0, 1, 2, 3, 4, 0, 0, 0, 8, 9])
print(arr)
print(arr[:2])
print(arr[2:-2])
[0 1 2 3 4 0 0 0 8 9]
[0 1]
[2 3 4 0 0 0]
arr2d
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print(arr2d[0,:])
print(arr2d[:1,:])
print(arr2d[0,1:])
[1 2 3]
[[1 2 3]]
[2 3]
print(arr2d[1:2,0:1])
[[4]]
arr2d[:2,1:]
array([[2, 3],
[5, 6]])
arr2d[2,:]
array([7, 8, 9])
arr2d[:,0:2]
array([[1, 2],
[4, 5],
[7, 8]])
arr2d[1,:2]
array([4, 5])
arr = np.arange(1,10).reshape(3,3)
arr
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
arr[:2,1:]
array([[2, 3],
[5, 6]])
arr[:,:2]
array([[1, 2],
[4, 5],
[7, 8]])
arr[2]
array([7, 8, 9])
arr[2,:]
array([7, 8, 9])
arr[1,:2]
1.5.3 布尔型索引
import numpy as np
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
data = np.random.randn(7,4)
print(data)
[[ 0.4733154 -0.5396483 0.34149651 1.71639964]
[ 1.02295293 -0.29283055 0.35375449 0.19456771]
[-1.6554857 0.63357375 -1.60618687 0.44385828]
[-0.55929983 2.64292831 -1.12576338 -0.43466796]
[ 1.56597291 1.1967688 -1.74729927 0.42564747]
[ 0.77430541 0.94777755 -1.31730001 1.38350889]
[-0.81380047 0.30642454 -1.1629011 -0.15472287]]
data[:]
a = np.array([True,True,True,True,True,True,False])
print(data[a])
# print(data[True, False, False, True, False, False, False])
[[ 0.4733154 -0.5396483 0.34149651 1.71639964]
[ 1.02295293 -0.29283055 0.35375449 0.19456771]
[-1.6554857 0.63357375 -1.60618687 0.44385828]
[-0.55929983 2.64292831 -1.12576338 -0.43466796]
[ 1.56597291 1.1967688 -1.74729927 0.42564747]
[ 0.77430541 0.94777755 -1.31730001 1.38350889]]
names == 'Bob'
array([ True, False, False, True, False, False, False])
data[names != 'Bob']
data[(names == 'Bob') | (names == 'Will')]
data[(names == 'Bob') & (names == 'will')]
复习 Python 运算符
- Python算术运算符
- Python比较运算符
- Python赋值运算符
- Python位运算符 | & ^ ~ << >>
- Python逻辑运算符 and or
- Python成员运算符 is not
1.5.4 花式索引
import numpy as np
arr = np.empty((8,4))
for i in range(8):
arr[i] = i
arr
arr[[4,1]]
arr[[4, 3, 0, 6]]
arr[[-3, -6, -8]]
arr = np.arange(32).reshape((8, 4))
arr
arr[[1, 5, 7, 2], [0, 3, 1, 2]]
arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]
# 4,5,6,7
# 20,21,22,23
# 28,29,30,31
# 8,9,10,11
# ---------------
# 4,7,5,6,
# 20,23,21,22
# 28,31,29,30
# 8,11,9,10
1.6 数组转置和轴对换
import numpy as np
arr = np.arange(15).reshape((3, 5))
print(arr)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
print(arr.T)
[[ 0 5 10]
[ 1 6 11]
[ 2 7 12]
[ 3 8 13]
[ 4 9 14]]
arr.transpose()
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
2.1 函数
arr = np.array([1, np.e, np.e**2, 0])
# arr1 = np.arange(10)
# print(arr)
print('数组的最大值是:{}'.format(np.max(arr)))
print('数组的最小值是:%s'%np.min(arr))
print('e的数组次方分别是%s'%np.exp(arr))
print('以e为底数组各数的对数%s'%np.log(arr))
print('数组各数的平方根是:%s'%np.sqrt(arr))
print('数组各数的均值是:%s'%np.mean(arr))
print('数组各数的标准差是:%s'%np.std(arr))
print('数组的最小值对应的索引是:%s'%np.argmin(arr))
print('数组的最大值对应的索引是:%s'%np.argmax(arr))
print('数组的非重复值是:%s'%np.unique(arr))
print('数组的各值是否为极限值%s'%np.isinf(arr))
数组的最大值是:7.3890560989306495
数组的最小值是:0.0
e的数组次方分别是[2.71828183e+00 1.51542622e+01 1.61817799e+03 1.00000000e+00]
以e为底数组各数的对数[ 0. 1. 2. -inf]
数组各数的平方根是:[1. 1.64872127 2.71828183 0. ]
数组各数的均值是:2.7768344818474238
数组各数的标准差是:2.8347824949088896
数组的最小值对应的索引是:3
数组的最大值对应的索引是:2
数组的非重复值是:[0. 1. 2.71828183 7.3890561 ]
数组的各值是否为极限值[False False False False]
# where
xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
np.where(cond, xarr, yarr)
array([1.1, 2.2, 1.3, 1.4, 2.5])
arr = np.random.randn(4, 4)
print(arr)
[[-0.59390741 0.4906733 1.5024845 -0.37891294]
[ 0.08131013 -0.44434959 1.52589387 0.72524524]
[ 1.17602525 0.91713693 -0.30531531 2.35744268]
[ 1.07329511 0.3671536 -0.72813476 1.73963631]]
print(np.where(arr > 0, 2, -2))
print(np.where(arr > 0, 2, arr))
[[-2 2 2 -2]
[ 2 -2 2 2]
[ 2 2 -2 2]
[ 2 2 -2 2]]
arr = np.random.randn(6)
print(arr)
[-0.78547989 -1.14387589 0.07657074 0.19838422 -0.62953824 0.52048324]
# sort,排序
print(np.sort(arr))
[-1.14387589 -0.78547989 -0.62953824 0.07657074 0.19838422 0.52048324]
arr = np.random.randn(5, 3)
print(arr)
[[-0.17071808 1.52764603 1.8531767 ]
[ 1.17754274 0.64322346 -2.81951686]
[ 0.76771819 1.58652535 0.84897769]
[ 0.27961133 -0.48130065 1.47068723]
[-0.98774216 0.3737696 0.56541959]]
# 不同方向上的排序之行方向
print(np.sort(arr,axis=0))
[[-0.98774216 -0.48130065 -2.81951686]
[-0.17071808 0.3737696 0.56541959]
[ 0.27961133 0.64322346 0.84897769]
[ 0.76771819 1.52764603 1.47068723]
[ 1.17754274 1.58652535 1.8531767 ]]
# 不同方向上的排序之列方向
print(np.sort(arr,axis=1))
[[-0.17071808 1.52764603 1.8531767 ]
[-2.81951686 0.64322346 1.17754274]
[ 0.76771819 0.84897769 1.58652535]
[-0.48130065 0.27961133 1.47068723]
[-0.98774216 0.3737696 0.56541959]]
np.sort(arr)
np.sort(arr)
np.sort(arr)
array([[-0.09719744, -0.02379284, 0.97521373],
[-1.8989297 , 0.20309192, 0.5224426 ],
[-0.45803847, -0.36023242, 1.04094405],
[ 0.41167892, 0.48268148, 0.7830147 ],
[-1.13012024, 0.85685608, 1.40883581]])
# 数组的堆叠
a = np.arange(5)
b = np.array(range(5))
c = np.hstack((a,b))
d = np.vstack((a,b))
print(a)
print(b)
print(c)
print(d)
[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4 0 1 2 3 4]
[[0 1 2 3 4]
[0 1 2 3 4]]
# arr1 = np.arange(10).reshape(5,2)
# arr1
arr3 = np.random.randint(1,10,10).reshape(5,2)
arr3
array([[7, 6],
[4, 1],
[3, 3],
[2, 9],
[2, 9]])
arr2 = np.arange(10).reshape(2,5)
arr2
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
np.hstack((arr1,arr2.T))
array([[0, 1, 0, 5],
[2, 3, 1, 6],
[4, 5, 2, 7],
[6, 7, 3, 8],
[8, 9, 4, 9]])
np.vstack((arr1.T,arr2))
array([[0, 2, 4, 6, 8],
[1, 3, 5, 7, 9],
[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
- 概念
数据类型自动向上转型
# 创建一个数据类型为float32的数组
a = np.arange(5,dtype='float32')
# 创建一个数据类型为float64的数组
b = np.arange(5,dtype='float64')
# 纵向连接两个数组
c = np.vstack((a,b))
print(c)
print(c.dtype)
[[0. 1. 2. 3. 4.]
[0. 1. 2. 3. 4.]]
float64
3 广播机制
Series
1.1 Series 的创建
import numpy as np
import pandas as pd
ser0 = pd.Series([4,7,-5,3])
ser1 = pd.Series([4,7,-5,3,2147483649],dtype=np.float32)
print(ser0)
print(ser1)
2**32/2
2147483648.0
print("Series的索引为：{}".format(ser1.index))
print("Series的数据为：{}".format(ser1.values))
Series的索引为：RangeIndex(start=0, stop=5, step=1)
Series的数据为：[ 4.0000000e+00 7.0000000e+00 -5.0000000e+00 3.0000000e+00
2.1474836e+09]
1.2 索引
ser2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
print(ser2)
print("---------华丽的分隔符---------")
print(ser2.index)
# 单索引
ser2['a']
-5
# 索引
ser2[['a','b','d']]
是否可以用字典创建Series呢
sdata = {'北京': 35000,
'上海': 71000,
'广州': 16000,
'深圳': 50000}
ser3 = pd.Series(sdata)
ser3
city = ['北京', '上海', '广州', '深圳','杭州']
ser4 = pd.Series(sdata, index=city)
ser4
pd.isnull(ser4)
ser4.isnull()
for i,v in ser4.items():
print(i,v)
for i in ser4.index:
print(i,ser4[i])
数据的读取和处理
import pandas as pd
import numpy as np
e1 = pd.read_csv('data_test01.txt')
e1
e1 = pd.read_csv('data_test01.txt',sep=',')
e1
e1 = pd.read_csv('data_test01.txt',sep=',',
encoding='utf8')
e1
e1 = pd.read_csv('data_test01.txt',sep=',')
e1
e1=pd.read_csv('data_test01.txt',sep=',',
skiprows=1,skipfooter=2,encoding='utf8')
e1
e1=pd.read_csv('data_test01.txt',sep=',',
skiprows=1,skipfooter=2,
comment='$',thousands='&',
encoding='utf8',engine='python')
e1
e1=pd.read_csv('data_test01.txt',sep=',',
parse_dates={'birthday':[0,1,2]},
skiprows=1,skipfooter=2,
comment='$',thousands='&',
encoding='utf8')
e1
e3=pd.read_excel('data_test02.xlsx',skiprows=1,skipfooter=0)
e3
child_cloth=pd.read_excel('data_test02.xlsx',skiprows=1,
names=['Prod_Id','Prod_Name','Prod_Color',
'Prod_Size','Prod_Price'],converters={0:str})
child_cloth
e3=pd.read_excel('data_test03.xlsx')
e3
e3.info()
#将birthday变量转换为日期型
e3['birthday']=pd.to_datetime(e3['birthday'])
e3['birthday']
#将手机号变成字符串
e3['tel']=e3['tel'].astype('str')
print(e3['tel'].dtype)
object
pd.datetime.today().year
2020
### 新增年龄和工龄两列pd.datetime.today().year现在的年份
e3['age']=pd.datetime.today().year-e3['birthday'].dt.year
e3['workage']=pd.datetime.today().year-e3['start_work'].dt.year
e3
e3.info()
#将手机号中间四位隐藏起来
e3['tel']=e3['tel'].apply(lambda x:x.replace(x[3:8],'****'))
e3['tel']
#取出邮箱的域名
e3['email_domain']=e3['email'].apply(lambda x:x.split('@')[1])
e3['email_domain']
#取出用户的专业信息
e3['profession']=e3.other.str.findall('专业：(.*)，')
e3
e3['profession'] = e3['profession'].str[0]
e3
#去除birthday.start_work和other变量
del e3['birthday']
e3
e3.drop(['start_work'],axis=1,inplace=True)
e3
del e3['other']
e3
e4=pd.read_excel('data_test03.xlsx')
e4
#将birthday变量转换为日期型
e4['birthday']=pd.to_datetime(e4['birthday'])
e4['birthday']
#将手机号变成字符串
e4['tel']=e4['tel'].astype('str')
print(e4['tel'].dtype)
object
#将手机号中间四位隐藏起来
e4['tel']=e4['tel'].apply(lambda x:x.replace(x[3:8],'****'))
e4['tel']
### 新增年龄和工龄两列pd.datetime.today().year现在的年份
e4['age']=pd.datetime.today().year-e4['birthday'].dt.year
e4['workage']=pd.datetime.today().year-e4['start_work'].dt.year
e4
#取出邮箱的域名
e4['email_domain']=e4['email'].apply(lambda x:x.split('@')[1])
e4['email_domain']
#取出用户的专业信息
e4['profession']=e4['other'].str.findall('专业：(.*)，')
e4
merge
import pandas as pd
import numpy as np
class display(object):
template = """<div style="float: left; padding: 10px;">
<p style='font-family:"Courier New", Courier, monospace'>{0}</p>{1}
</div>"""
def __init__(self, *args):
self.args = args
def _repr_html_(self):
return '\n'.join(self.template.format(a, eval(a)._repr_html_())
for a in self.args)
def __repr__(self):
return '\n\n'.join(a + '\n' + repr(eval(a))
for a in self.args)
one-vs-one
df1 = pd.DataFrame({'employee': ['Bob', 'Jake', 'Lisa', 'Sue'],
'group': ['Accounting', 'Engineering', 'Engineering', 'HR']})
df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'],
'hire_date': [2004, 2008, 2012, 2014]})
df3 = pd.merge(df1,df2)
display('df1', 'df2','pd.merge(df1,df2)')
many-vs-one
df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'HR'],
'supervisor': ['Carly', 'Guido', 'Steve']})
display('df3', 'df4', 'pd.merge(df3, df4)')
many-vs-many
df5 = pd.DataFrame({'group': ['Accounting', 'Accounting',
'Engineering', 'Engineering', 'HR', 'HR'],
'skills': ['math', 'spreadsheets', 'coding', 'linux',
'spreadsheets', 'organization']})
display('df1', 'df5', "pd.merge(df1, df5)")
df6 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],
'salary': [70000, 80000, 120000, 90000]})
display('df1', 'df6', 'pd.merge(df1, df6, left_on="employee", right_on="name")')
df1a = df1.set_index('employee')
df2a = df2.set_index('employee')
display('df1a', 'df2a',"pd.merge(df1a, df2a, left_index=True, right_index=True)")
指定融合方法
df7 = pd.DataFrame({'name': ['Peter', 'Paul', 'Mary'],
'food': ['fish', 'beans', 'bread']},
columns=['name', 'food'])
df8 = pd.DataFrame({'name': ['Mary', 'Joseph'],
'drink': ['wine', 'beer']},
columns=['name', 'drink'])
display('df7', 'df8', 'pd.merge(df7, df8)')
pd.merge(df7, df8, how='inner')
display('df7', 'df8', "pd.merge(df7, df8, how='outer')")
display('df7', 'df8', "pd.merge(df7, df8, how='left')")
列重叠
df9 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],
'rank': [1, 2, 3, 4]})
df10 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],
'rank': [3, 1, 4, 2]})
display('df9', 'df10', 'pd.merge(df9, df10, on="name")')
display('df9', 'df10', 'pd.merge(df9, df10, on="name", suffixes=["_yuwen", "_shuxue"])')
来源：CSDN
作者：Arbitrary_Wei
链接：https://blog.csdn.net/NEW_old_WEI/article/details/104152451