Numpy

最新推荐文章于 2022-11-16 19:35:12 发布

置顶 Arbitrary_Wei

最新推荐文章于 2022-11-16 19:35:12 发布

阅读量879

点赞数 1

本文链接：https://blog.csdn.net/NEW_old_WEI/article/details/104152451

版权

NO.1

File ：文件             
New Notebook       创建新的Notebook。
Open...          打开新的界面。
Make a Copy..      拷贝当前Notebook。
Save as...        另存为。将弹出一个对话框，手动输入保存地址。PS:现有路径如果有中文的，对话框中将有乱码。
Rename..         重命名Notebook。
Save and Checkpoint  保存并作为检查点。类似游戏的存档点。
Revert to Checkpoint 将本文件转到某检查点。当前的文件如果不存档，将直接消失。
Print Preview      打印预览。在新选项卡中打开当前页面的打印版，类似网页，不可修改。
Download as       转为其他格式下载。在二级菜单中可以选择，包括.py文件。
Close and Halt     关闭并关停。如果你只是关闭了笔记的页面，不会关停笔记本的运行，而这个可以同时关停运行。

Edit：编辑
Cut Cells           剪切单元格。
Copy Cells          复制单元格。
Paste Cells Above      粘贴在选中单元格以上。
Paste Cells Below      粘贴在选中单元格以下。
Paste Cells & Replace   粘贴并替换选中单元格。
Delete Cells         删除单元格。
Undo Delete Cells      撤销删除单元格。
Split Cell          拆分单元格。
Merge Cell Above      将选中单元格与上方单元格合并。
Merge Cell Below      将选中单元格与下方单元格合并。
Move Cell Up         上移选中单元格。
Move Cell Down       下移选中单元格。
Edit Notebook Metadata  编辑界面元数据。
Find and Replace      查找并替换。
Cut Cell Attachments   切割单元格附件。
Copy Cell Attachments   复制单元格附件。
Paste Cell Attachments  粘贴单元格附件。
Insert Image         插入图片。

View：视图
Toggle Header        切换显示/隐藏标题栏。
Toggle Toolbar       切换显示/隐藏工具栏。
Toggle Line Numbers    切换显示/隐藏行号。
Cell Toolbar         单元格工具栏。

Insert
Insert Cell Above     当前位置之上插入一个新的cell（单元格）
Insert Cell Below     当前位置之下插入一个新的cell（单元格）

Cell：单元格
Run Cells             运行所有单元格
Run Cells and Select Below  运行单元格并选择下方Shift+Enter
Run Cells and Insert Below  运行单元格并在下面插入Alt+Enter
Run All               全部运行下方
Run All Above           全部运行
Run All Below           全部运行上方
Cell Type              单元格类型。分别为Code(代码模式)/Markdown(Markdown文本模式)/Raw NBConvert。前两者可用快捷键Y/M代替。
Current Outputs          当前输出
All Output             所有输出。
Toggle                切换隐藏/展示。
Toggle Scrolling         切换滑动/不滑动。
Clear                清除输出。

Kernel：核心
Interrupt             中断。将中断与服务器的连接。
Restart               重启。重启服务将丢失所有变量。
Restart & Clear Output     重启并清除输出
Restart & Run All         重启并运行全部单元格
Reconnect              重新连接。
Shutdown               关闭。关闭连接后需要使用Restart重连。
Change kernel            改变核心。即改变语言核心。

在这里插入图片描述

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)

#查看赋值的变量的值
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')

# 反转字符串
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

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)

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']

d1.get('b')     # 也可用取键b的对应值

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()

#添加新元素
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)

l
i
k
e

t
o

s
t
a
y

i
n

C
h
i
n
a

[‘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

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)

# 定义一个函数,返回列表元素的和
def accumulate(a):
    sum = 0
    for i in a:
       sum=sum+i
    return sum


li = list(range(5))
accumulate(li)

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的部分功能如下：

ndarray，一个具有矢量算术运算和复杂广播能力的多维数组。
用于对整组数据进行快速运算的标准数学函数（无需编写循环）。
1.1 初识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])

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"])')

在这里插入图片描述

python pd.read_excel

pd.read_excel(
    io,
    sheet_name=0,
    header=0,
    names=None,
    index_col=None,
    parse_cols=None,
    nrows=None,
    usecols=None,
    skiprows=None,
    skipfooter=0,
    skip_footer=0,
    squeeze=False,
    dtype=None,
    engine=None,
    converters=None,
    true_values=None,
    false_values=None,
    na_values=None,
    keep_default_na=True,
    verbose=False,
    parse_dates=False,
    date_parser=None,
    thousands=None,
    comment=None,
    

    convert_float=True,
    mangle_dupe_cols=True,
    **kwds,
)
'io ：excel路径
'sheetname=’sheet2’ 返回指定名字的表；返回多表使用sheet_name=[0,1,2] 代表返回第几张，0默认第一张，0，1，2代表返回第一张、第二张、第三张；若sheet_name=None是返回全表。
'header ：指定作为列名的行，默认header=0，即取第一行，数据为默认从这一行下面开始读取；若数据想不含列名，则设定header=None；
'names要使用的列名列表，默认names=None；匹配header进行使用，会覆盖原因的表头文字。指定的名字出现重复的话，会出现.1，.2
'index_col指定列为索引列，默认index_col=None，index_col=0，选择第一列为索引
'parse_cols，默认parse_cols=None，相关于usecols，显示多少列，None是显示全部列，parse_cols=1，显示2列
'Nrows，usecols需要展示的行列数进行指定，默认Nrows=None,usecols=None,这里意思就是展示全部的有数据的行和列，nrows=2,usecols=2，意思就是需求2行，3列
'skiprows省略指定行数的数据，默认skiprows=0，从表头开始省略的行数，表头也算是数据。
'skipfooter省略从尾部数的行数据，默认skipfooter=0,设置0就是省略0行。
'skip_footer是一样的
'Squeeze，如果文件值包含一列，则返回一个Series，默认Squeeze=False；这里及哪怕只有一列也是按照默认的输出为dataframe，Squeeze=True，在只有一列的时候就是为Series；
'Dtype，每列数据的数据类型。例如 {‘a’: np.float64, ‘b’: np.int32}，默认Dtype=None；也就是按照初始的数据类型进行输出；这里需要匹配np，需要额外定意思import numpy as np
'Engine，使用的分析引擎。可以选择C或者是python。C引擎快但是Python引擎功能更加完备。默认Engine=None；就是使用python。
'Converters，在某些列中转换值的函数的命令默认Converters=None；也就是不进行转化。这个可以是公式转换，也可以是字符类型转化，默认的数字是int格式，案例改为tsr。
'true_values，指定字符变为true，默认true_values=None，默认没有字符转化为true
'false_values，指定字符变为false，默认false_values=None，默认没有字符转化为true
'na_values，指定字符变为NaN，默认false_values=None，默认没有字符转化为NaN
'keep_default_na，如果指定na_values参数，并且keep_default_na=False，那么默认的NaN将被覆盖，否则添加。默认keep_default_na=True；默认不会被新定义的NaN影响默认的NaN规则
'Verbose，是否显示各种解析器的输出信息，例如：“在非数字列中显示插入的na值的数目”等。默认Verbose=False；默认不显示，python默认使用紧凑的正则表达式(即普通的正则表达式),但为了提高正则表达式的可读性,我们可以使用松散的。
'parse_dates，分析日期，默认=False；也就是不分析日期，适用于表格里面没有日期的。如果为true，需要指定将哪一列解析为时间索引。如果列或索引包含不可分析的日期，则整个列或索引将作为对象数据类型原封不动地返回。对于非标准的日期时间分析，请在pd.read_excel之后使用pd.to_datetime。
'date_parser，日期分析器，默认=None；也就是不开启，适用于表格里面没有日期的。用于解析日期的函数，默认使用dateutil.parser来做转换。dateutil.parser 顾名思意 就是与日期相关库里的一个日期解析器，能够将字符串转换为日期格式，我们来看看具体的用法。需要在线安装 pip install python-dateutil；一般要分析的情况下，就开启就可以了。
'Thousands，设置默认的数字千分符号，默认thousands =None；默认不设置。此参数仅对Excel中存储为文本的列是必需的，无论显示格式如何，都将自动分析任何数值列，这里读取excel的时候，不管excel有没有千分符，都会默认无。
'Comment，标识着多余的行不被解析。如果该字符出现在行首，这一行将被全部忽略。这个参数只能是一个字符，空行；默认Comment=None。表示不按照这个方式忽略
'convert_float，转换浮点数，默认convert_float=True ；将整数浮点转换为int（即1.0–>1）将整数浮点转换为int（即1.0–>1）。如果为False，则所有数值数据都将作为浮点数读取：Excel将所有数字作为浮点数存储在内部。
'mangle_dupe_cols，默认mangle_dupe_cols=True；则重复列将指定为“x.0”…“x.n”，如果设定为false则会将所有重名列覆盖，但是实际测试会报错！