数据分析：Python之进阶篇

最新推荐文章于 2024-06-30 22:46:22 发布
最新推荐文章于 2024-06-30 22:46:22 发布
阅读量381 收藏 1
点赞数 5
分类专栏： python 数据分析 文章标签： 数据分析 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56181660/article/details/133319433
版权

文章目录

第四章 常见的数据结构

4.1 列表

  1. 列表（list）

    • 列表的元素都是有序的

    • 列表中每个元素都是可变的

    • 列表可以容纳Python中任何对象

    • ["a","b",1,2]

  2. 列表的创建

    • a = [1,2,3,4]  ##推荐这种方法
print(a)

      #b = []
b = list()  ##创建一个空列表

      b.append(1)  ## append是列表的方法，表示在后面追加元素
b.append(2)
b.append(3)
b.append(4)
print(b)

  3. 列表的索引和切片

    • ## 索引
a = [1,2,3,4]
print(a[0])  ##下标是0开始
print(a[-1]) ##-1下标表示最后一个

      ## 切片[start:end]
a = [1,2,3,4]
print(a[0:3]) ##1,2,3
print(a[:3])  ##start如果为0可以省略
print(a[1:4]) ##2,3,4
print(a[:])   ##end如果为最后一个，也可以省略

  4. 列表修改、删除、拼接、遍历

    • ## 修改
a = [1,2,3,4]
a[1] = 5  ##把值赋给索引就可以
print(a)  ##[1, 5, 3, 4]
a[-1] = 10
print(a)  ##[1, 5, 3, 10]

    • ## 删除
a = [1,5,3,10]
del a[1] ##del加索引就可以，delete
del a[-1]
print(a)  ##[1, 3]

    • ## 拼接
a = [1,3]
b = [2,4]
print(a + b)  ##[1, 3, 2, 4]
print(a + b + [5,6])  ##[1, 3, 2, 4, 5, 6]

    • ## 是否在列表中，遍历
a = [1,3]
if 1 in a:
    print("存在")
else:
    print("不存在")
    
for i in a:
    print(i)
列表的进阶用法

  1. 多维列表

    • a = [1,2,3,4]  ##看成一排数字

      b = [[1,2],[3,4]]  ##二维列表
print(b)  ##[[1, 2], [3, 4]]

      c = [[[1], [2]], [[3], [4]], [[5], [6]]]  ##三维列表

      print(a[0])     ##1
print(b[0][0])  ##1
print(b[0][1])  ##2

print(c[0][0][0])##1
print(c[0][1][0])##2
print(c[1][0][0])##3
print(c[2][1][0])##6  ##多少维度，对应多少个方括号

  2. 求列表的长度

    • ## 求列表长度
a = [1,2,3,4]
b = [[1,2],[3,4]]
c = [[[1], [2]], [[3], [4]], [[5], [6]]]
print(len(a))  ##4
print(len(b))  ##2
print(len(c[0][0])) ##1

  3. 列表的方法调用（append，count，extend，sort…）

    • a = [1,2,3,4]
      • append
      ## append 表示追加
a.append(5)
print(a)  ##[1, 2, 3, 4, 5]
      • count
      ## count 统计有多少个
print(a.count(6))  ##0
print(a.count(4))  ##1
      • extend
      ## extend 实时更新a中元素，没有返回值
a.extend([6,7,8])
print(a)  ##[1, 2, 3, 4, 5, 6, 7, 8]执行一遍
      • index
      ## index  ##返回下标，没有就会报错
print(a.index(6)) ##5
      • insert
      ## insert
a.insert(0,8)

      print(a)  ##[8, 1, 2, 3, 4, 5, 6, 7, 8]
print(len(a))  ##9

      a.insert(2,10)

      print(a)  ##[8, 1, 10, 2, 3, 4, 5, 6, 7, 8]
print(len(a))  ##10
      • pop
      ## pop 弹出最后的元素，列表会更新
d = a.pop()

      print(len(a))  ##9
print(d)   ##8
      • remove
      a = [8, 1, 10, 2, 3, 4, 5, 6, 7,8]

      a.remove(8)  ##remove只删除匹配到的第一个

      print(a)  ##[1, 10, 2, 3, 4, 5, 6, 7, 8]
      • reverse、sort
      #逆序
a.reverse()
print(a)  ##[8, 7, 6, 5, 4, 3, 2, 10, 1]

      #排序 ##默认从小到大排序
a.sort()  ##a.sort(reverse=False)
print(a)  ##[1, 2, 3, 4, 5, 6, 7, 8, 10]
##从大到小排序
a.sort(reverse=True)
print(a)  ##[10, 8, 7, 6, 5, 4, 3, 2, 1]
      • clear
      a.clear()
print(a)  ##[]
      • extend
      a.extend([1,2,3,4])

      print(a)
      • copy
      a = [1,2,3,4] 
e = a.copy  ##copy跟赋值的区别,copy赋值得到新的列表

      f = a

      id(e)  ##2313461048480

      id(f)  ##2313460995328

      g = a

      id(g) ##2313460995328

4.2 元组

  1. 元组（tuple）

    • 元组与列表类似，但元组中的元素不能修改

      ("lisi",24,1.75)

  2. 元组的创建

    • a = ("abc",1)
type(a) ##查看数据类型，即tuple

      b = ["abc",1]
type(b)  ##list
b = tuple(b)  ##把列表转换为元组
type(b)  ##tuple

  3. 元组的索引和切片

    • ## 索引和切片
a = ("abc",1) 
print(a[0])  ##索引下标也是从0开始  abc
print(a[:2]) ##('abc', 1)

  4. 元组的求长度、删除、拼接、遍历

    • ## 求长度
a = ("abc",1) 
c = (1,2,3)
print(len(a))  ##2
print(len(c))  ##3

      ## 删除。元组使用del只能删掉整个元素，不能删掉单个元素
a = ("abc",1) 
print(a)
del a
print(a)  ##name 'a' is not defined

      ## 拼接
a = ("abc",1) 
b = ("bcd",2)
print(id(a))  ##2313443422720
print(id(b))  ##2313444252544
print(a + b)  ##('abc', 1, 'bcd', 2)
print(id(a+b))  ##2313461069760

      ## 判断元素是否在列表中
a = ("abc",1) 
"bcd" in a  ##False

##遍历
for i in a:
    print(i)  ##abc 1

4.3 字典

  1. 字典（dict）

    • 简单地说，字典就是存储键值对的数据结构

    • 字典中的数据必须是以键值对的形式存在的

    • 字典中键（key）是不能重复，也不能修改；而值（value）是可重复，可修改的，可以是任何对象

    • {"a":1,"b":2,1:2}

  2. 字典的创建

    • info = {"age":26,"heght":167,"BWH":(89,62,92),"interest":["看书","美食"]}

      type(info) ##dict
infos = {"小美":{"age":26,"heght":167,"BWH":(89,62,92),"interest":["看书","美食"]}}

      infos["小花"] = {"age":25,"heght":163,"BWH":(85,60,90),"interest":["唱歌","健身"]}

      infos["小红"] = {"age":24,"heght":160,"BWH":(80,59,84),"interest":["旅行"]}
infos["小甜甜"] = {"age":24,"heght":161,"BWH":(84,60,89),"interest":["看电影","健身"]}

  3. 字典的索引和查询

    ## 查询
infos["小甜甜"]["BWH"]  ##通过[key]来索引查找    (84, 60, 89)

    infos.get("小鱼",{})  ##get的第二个参数是查看key不存在的时候返回的值  {}

  4. 字典的修改、添加、删除元素

    • ## 修改
infos["小花"]["height"] = 165  ##索引再加附加操作进行修改
infos["小花"]["height"] ##165

      ## 添加元素
infos["小花"] = {"age":25,"heght":163,"BWH":(85,60,90),"interest":["唱歌","健身"]}
print(infos)  ##{'小美': {'age': 26, 'heght': 167, 'BWH': (89, 62, 92), 'interest': ['看书', '美食']}, '小花': {'age': 25, 'heght': 163, 'BWH': (85, 60, 90), 'interest': ['唱歌', '健身']}}

infos["小红"] = {"age":24,"heght":160,"BWH":(80,59,84),"interest":["旅行"]}
infos["小甜甜"] = {"age":24,"heght":161,"BWH":(84,60,89),"interest":["看电影","健身"]}

      ##删除
del infos["小甜甜"]

  5. 求字典的长度

    • ## len求长度
print(len(infos))

  6. 字典的遍历

    • ## 字典的遍历。keys返回字典所有的键/key
infos.keys() ##dict_keys(['小美', '小花', '小红', '小甜甜'])
#type(infos.keys())  ##dict_keys
list(infos.keys())  ##['小美', '小花', '小红', '小甜甜']  先转换为列表

      a = list(infos.keys()) ##keys返回字典所有的键/key
for i in a:
    print("key={},value={}".format(i,infos[i]))

      ##结果
key=小美,value={'age': 26, 'heght': 167, 'BWH': (89, 62, 92), 'interest': ['看书', '美食']}
key=小花,value={'age': 25, 'heght': 163, 'BWH': (85, 60, 90), 'interest': ['唱歌', '健身'], 'height': 165}
key=小红,value={'age': 24, 'heght': 160, 'BWH': (80, 59, 84), 'interest': ['旅行']}
key=小甜甜,value={'age': 24, 'heght': 161, 'BWH': (84, 60, 89), 'interest': ['看电影', '健身']}

      for i in list(infos.items()):  ##items返回所有由key和value所构成的元组
    print("key={},value={}".format(i[0],i[1]))

4.4 集合

  1. 集合（set）

    • 简单地说，集合就是无序的不重复元素序列
    • 集合中的元素不可重复
    • 集合中的元素是无序的，所以没有索引
    • basket = {‘apple’,‘orange’,‘pear’,‘banana’}

  2. 集合的创建

    • a = {1,2,3}
type(a) ##set就是Python中集合的数据类型

      b = {}  ##表示空集合不能用空的花括号
type(b) ##dict

      b = set() ##表示空的集合
type(b)  ##set

      ## 转换
a = [1, 2, 3]
type(a)  ##list

      a = set(a) ## 通过set把列表转换为集合
type(a)  ##set

    • 实践（去重，交集、并集）

      user_id_list = [1, 2, 3, 4, 4, 5, 5]
len(user_id_list)  ##7

      ## 去重
user_id_set = set(user_id_list)
## len求集合长度
len(user_id_set)  ##5

      ## 求交集
user_id_list = [1, 2, 3, 4, 4, 5, 5]
user_id_list2 = [2, 3, 7, 8, 9]

user_id_set = set(user_id_list)
user_id_set2 = set(user_id_list2)

print(user_id_set)  ##{1, 2, 3, 4, 5}
print(user_id_set2) ##{2, 3, 7, 8, 9}

      user_id_set & user_id_set2 ## &可以求交集 
##即{2, 3}

      user_id_set.intersection(user_id_set2) ## intersection表示求交集的方法，传入需要运算的另外一个集合 
##即{2, 3}

      ## 求并集
user_id_set | user_id_set2 ## |可以求并集

      user_id_set.union(user_id_set2) ## union表示求并集的方法

    • 添加、删除、遍历

      a = {1, 2, 3}
## 添加元素
a.add(4)
print(a)  ##{1, 2, 3, 4}

      ## 删除
a.remove(4)
print(a)  ##{1, 2, 3}

      5 in a ## in表示是否在集合中
## False

      ## 遍历
for i in a:
    print(i) 
##
1
2
3

第五章 函数与python库的使用

5.1 函数

  1. 函数的定义

    • 函数定义：

      • def(关键字) func(函数名)(arg1，arg2)(参数，可没参数，不可没括号):（冒号）

        ​ (缩进)do something

        ​ (缩进)return value

    • 函数是组织好的，可重复使用的，用来实现单一的，或相关联功能的代码段。

    • print()：Print是一个放入对象就能将结果打印的函数

    • input()：Input是一个可以让用户输入信息的函数

    • len()：Len是一个可以测量对象长度的函数

    • int()：Int是一个可以将字符串类型转为整数的函数

  2. 函数的定义（实战）

    • ## 求最大值
def get_max_value(a,b):
    res = a
    if b > a:
        res = b
    return res
get_max_value(2,3)

##结果
3

    • ## 不带参数无返回值
def print_hello():
    print("hello wrold")

print_hello()

##结果
hello wrold

    • ## 计算1~100的整数和
def get_max(n):
    res = 0
    for i in range(1, n+1):
        res += i
    return res

## 结果
get_max(100)

def get_sum(n, is_old):
    ## 计算1~n之间的整数和,is_old表示是否只计算偶数
    res = 0
    for i in range(1, n+1):
        if is_old:
            if i % 2 == 0:
                res += i
        else:
            res += i
    return res

get_sum(100, True)
##结果
2550

get_sum(100, False)
##结果
5050

    • 参数是可变的

      def add_to_list(array, x):
    ##向array列表里面加入x
    array.append(x)
    return array

a = [1,2,3]  ##增加4
add_to_list(a,4)
## 结果
[1, 2, 3, 4]

  3. 默认参数和可变参数

    • 默认参数

      • ## 1~n之间的整数和,还需要判断是否只求偶数
def get_sum(n, is_even=False): ## 函数参数带有赋值的写法就是默认参数
    res = 0
    for x in range(1, n + 1):
        if is_even:
            if x % 2 == 0:
                res += x
        else:
            res += x
    return res

get_sum(3, is_even=True) ## 如果有默认值

## 结果
2

get_sum(n=3)
## 结果
6

        def add_two_num(a=0, b=0):
    print("a={}, b={}".format(a,b))
    return a + b

add_two_num(4, 5)
## 结果
a=4, b=5
9

### 函数调用的写法
add_two_num(a=3, b=4) ##调用时候带上名字

    • 可变参数

      • ### 很多整数相加，个数不确定
def add_nums(*args): ## 参数前面加*号表示个数不确定
    print(type(args))
    print(len(args))
    res = 0
    for x in args:
        res += x
    return res

add_nums(1, 2, 3, 4, 5)
## 结果
<class 'tuple'>
5
15

  4. 关键字参数

    • def print_info(**kw): #kw = key word
    #print(kw)
    #print(type(kw))
    #print("name={}, age={}".format(name,age))
    print(kw['age'])
    for key in list(kw.keys()):
        print("key={},value={}".format(key,kw[key]))
print_info(name="zhangsan",age=23,height=180) ##把参数跟对应的值都包装成一个字典

##
23
key=name,value=zhangsan
key=age,value=23
key=height,value=180

print_info(name="zhangsan",age=23)

##
{'name': 'zhangsan', 'age': 23}
<class 'dict'>{'name': 'zhangsan', 'age': 23}
<class 'dict'>

  5. 全局变量和局部变量

    • value = 10 #全局变量

print(value)
print(id(value))
## 
10
2171826039376

def change_value():
    #global value ##利用global关键字定义全局变量
    value = 12   ##局部变量，只限于函数体里面的
    print(value)
    print(id(value))

change_value()

##
12
21718260393762171826039376

  6. map映射函数

    • def squre(x):
    return x * x

squre(3)
## 9


nums = [1,2,3,4]
nums2 = [3,4,5]

def add(a,b):
    return a + b

res = []
for x in nums:
    res.append(squre(x))
    #print(suqre(x))
print(res)

## [1, 4, 9, 16]

list(map(squre,nums))  ##map第一个参数是处理的函数，第二个是处理的序列,map可以看成一个批处理接口

## [1, 4, 9, 16]

result = map(add,nums,nums2,[1,2])

for x in result:  ##map返回的是可迭代对象
    print(x)

##
5
8

result = map(squre,nums)
hasattr(result,"__iter__") ##返回True则是可迭代对象

## True

def add(*nums):
    res = 0
    for x in nums:
        res += x
    return res

  7. lambda表达式

    • nums2 = [3,4,5]

tmp = lambda x: x * x ## lambda关键字表示定义lambda表达式
type(tmp)

## function 函数

(lambda x: x * x)(5)

## 25

(lambda a,b: a+b)(3,4)

## 7

nums = [1,2,3,4]
nums2 = [3,4,5]

result = map(lambda x: x*x,nums)result = map(lambda x: x*x,nums)

result1 = map(lambda x,y: x + y,nums,nums2)

for x in result1:
    print(x)

## 
4
6
8

(lambda *x: res = 0, for i in x:res +=1, res)(1,2,3)
## 
SyntaxError: invalid syntax
    ## 注意，一般不用lambda语句执行多条逻辑语句

5.2 Python中的库

  1. Python中的库

    ## 调用模块的东西
## 在jupyter notebook中新建txt文件，分别命名为test_module.py和test_module2.py，再新建一个package包，将两个新建的txt文件放入进去，再在package里新建一个__int__.py文件
## test_module.py输入以下内容
NAMEA = 'zhangsan'


def print_hello():
    print("hello wrold")
## test_module2.py输入以下内容
def print_hello():
    print("hello world 2")
    

import test_module ## import后面的模块名

test_module.print_hello()

## hello wrold

print(test_module.NAME)

## zhangsan

test_module.NAME = "李四"
print(test_module.NAME)

## 李四




##调用方法二
from test_module import print_hello ##from模块导入函数，变量，类
print_hello()
from test_module import NAME
NAME

##
hello wrold
'李四'

import package.test_module

package.test_module.print_hello()

## hello wrold

from package.test_module2 import print_hello

print_hello()

## hello world 2

  • import math
dir(math)

math.pi
## 3.141592653589793
math.sqrt(4)math.sqrt(4)
## 2.0


from package import test_module2
dir(test_module2)

##
['__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'print_hello']



import matplotlib.pyplot as plt ## as是设置别名，起个小名，Python不自带的就是第三方库
plt.plot([4,2,3,1])

第六章 文件操作、序列化与反序列化

6.1 文件操作

  1. 文件操作

    • ## 打开
def open(file(文件名字), mode(模式)='r', buffering=None, errors=None, newline=None, closefd=True):
## open打开文件需要返回对象    

file.close() ##关闭文件
    模式参数说明
    r只读形式打开文件，默认模式
    w打开文件并写入，没有就创建文件，文件由内容则先清空
    a打开文件，并在文件已有内容后面追加
    • ##读文件
file.read()	##读整个文件内容
file.readline() ##读取一行内容
file.readlines() ##读取所有行并返回列表形式

    • ##写文件
file.write(str)	##写入字符串
file.writelines(seq) ##传入字符串序列

  2. 实际操作

    • 读文件

      ## 新建data.txt文件，输入以下内容
zhangsan
hello world

file = open("data.txt",mode='r') ##读取文件

print(file)
type(file)

##
<_io.TextIOWrapper name='data.txt' mode='r' encoding='cp936'>
_io.TextIOWrapper

## 不需要用，则必须关闭文件
file.close()

##判断打开的文件是否关闭，True表示已经关闭，就不能操作了，False表示打开的文件没有关闭，可以操作
file.closed

## True

    • ## with打开写法
with open("data.txt", mode='r') as file:
    ##操作文件
    ##读取数据（file.read()，file.readline()，file.readlines()）
    ##读取所有的行
    #a = file.read()
    b = file.readline()
    #print(a) ##read是读取全部的文件内容
    print(b)
    #print(type(a))
    print(type(file))
print(file.closed) ##用with写法执行，运行之后自动关闭了

##
zhangsan
#zhangsan
#hello world
#<class 'str'>
<class '_io.TextIOWrapper'>
True 



    • with open("data.txt", mode="r") as file: ## file指定全路径或者文件名(必须要文件和程序是同一级目录)
    ## 读取数据，file.read()，file.readline()，file.readlines()
    ## readline读取所有行
    array = [] ## 存放所有的行
    line = file.readline()
    while line:
        #print(line)
        line = line.strip() ## strip可以去掉字符串的换行符
        array.append(line)
        line = file.readline()
    """
    a = file.readline()
    print(a) ## readline是每次读取一行
    print(type(a))
    b = file.readline()
    print(b)
    print(type(file))
    """
    print(array)
    
print(file.closed) ## 自动关闭了

## 
['zhangsan', 'hello world']
True

    • with open("data.txt",mode='r') as file:
    a = file.readlines() ##readlines返回所有行的是个列表
    a = list(map(lambda x: x.strip(), a)) ##调用map函数进行去掉换行符(\n)
    print(a)
print(file.closed) ## 自动关闭了

## 
['zhangsan', 'hello world']
True

    • 计算求值案例

      ## 新建scores.txt文件，输入以下内容
## stu_id是人员1编号，score是1分数
stu_id,score
u0,25
u1,4
u2,75
u3,65
u4,95
u5,59
u6,36
u7,24
u8,46
u9,3
u10,23
u11,94
u12,86
u13,96
u14,10
u15,3
u16,64
u17,24
u18,54
u19,61
u20,49
u21,28
u22,36
u23,84
u24,28
u25,80
u26,78
u27,90
u28,51
u29,84
u30,83
u31,30
u32,10
u33,60
u34,31
u35,37
u36,15
u37,72
u38,68
u39,3
u40,45
u41,31
u42,28
u43,36
u44,20
u45,61
u46,11
u47,31
u48,29
u49,0
u50,44
u51,85
u52,73
u53,63
u54,44
u55,42
u56,26
u57,21
u58,21
u59,28
u60,57
u61,18
u62,55
u63,51
u64,12
u65,70
u66,40
u67,90
u68,62
u69,24
u70,51
u71,27
u72,32
u73,92
u74,19
u75,53
u76,65
u77,48
u78,76
u79,26
u80,96
u81,40
u82,26
u83,25
u84,93
u85,96
u86,36
u87,86
u88,59
u89,23
u90,63
u91,98
u92,40
u93,77
u94,93
u95,39
u96,78
u97,63
u98,14
u99,38

      ## 读取所有的行
with open("scores.txt",mode="r") as file:
    lines = file.readlines()
    #lines = list(map(lambda x: x.strip(),lines))
#print(lines)
scores = []
for x in lines[1:]:
    x = x.strip() ##去除空行
    scores.append(x.split(",")[1]) ## 跳过表头，从第二行开始，获取逗号后面的数据
#
#print(scores)
mean_value = 0 ##定义平均值
max_value = 0 ##判断最大值，定义一个最小值
min_value = 100 ##判断最小值，定义一个最大值
#因为从文本拿出来的scores分数是字符串，所以需要转换为整数
for x in scores:
    x = int(x) ##转为整数
    mean_value += x
    if x > max_value:
        max_value = x
    if x < min_value:
        min_value = x
mean_value /= len(scores)



print(mean_value)
print(max_value)
print(min_value)

## 
48.54
98
0

    • 写文件

      ## 写入文件
## 文件写入数据，新建一个result.txt文件。file.write(str), file.writelines(seq)

with open("result.txt", mode="w") as file: ##模式如果没有文件，则会自动新建该文件
    #print(file)
    file.write(str(mean_value)+'\n') ##必须转为字符串类型才可以写入,如果要换行就加"\n"
    file.write(str(max_value)+"\n")
    file.write(str(min_value)+"\n")
    
    
with open("result1.txt", mode="w") as file: ##模式如果没有文件，则会自动新建该文件
    ## writelines是字符串的列表，如果需要换行则字符串本身需要包含"\n"
    file.writelines([str(mean_value)+"\n",str(max_value)+"\n",str(min_value)+"\n"])
    
    
    
##reslut.txt和result1.txt有数据
48.54
98
0

#注意，w是覆盖文件内容

      ## 追加模式
with open("result.txt", mode="a") as file: # w模式如果没有文件，就新建一个
    print(file) ## write是把参入的字符串写入在一行
    file.write("\n") ## 追加模式可以先进行换行操作
    file.write(str(mean_value)+"\n") ## 如果要换行就加"\n"
    file.write(str(max_value)+"\n")
    file.write(str(min_value))
    
## a为追加模式，即追加文件内容

6.2 序列化和反序列化

  1. 序列化：

    • 概念：简单地说，将对象转化为“串行化”数据形式，存储在硬盘或者通过网络传输到其他地方。

    • import pickle   #导入序列化的库

pickle.dump(obj,file)  #序列化接口

    • #序列化
import pickle   #导入序列化的库

data = {"name":"zhangsan","age":30}

with open("data.pkl",mode="wb")as file:  ## wb文件模式表示写二进制模式
    #往文件里面序列化
    pickle.dump(data, file)  ###pickle.dump(obj,file) ,obj就是序列化的对象，file就是序列化的文件
## 注意，生成的文件用记事本打开是乱码

    • ## 封装成一个函数
## 目的，可以直接调用，更加简便
def save_object(obj,file):
    with open(file, mode="wb") as fp:
        pickle.dump(obj, fp)
        

save_object(data, "data.pkl")


## 保存列表
save_object([1,2,3,4], "data.pkl")

load_object("data.pkl")

##
[1, 2, 3, 4]

  2. 反序列化：

    • 概念：简单地说，读取“串行化”数据形式，并转化为对象。

    • import pickle   #导入序列化的库

pickle.load(file)  #反序列化接口

    • #反序列化
with open("data.pkl",mode="rb") as file:
    # pickle.load(file)  file就是反序列化的文件
    a = pickle.load(file)
    print(a)

##
{'name': 'zhangsan', 'age': 30}


    • ## 封装成一个函数
## 目的，可以直接调用，更加简便
def load_object(file):
    with open(file, mode="rb") as fp:
        result = pickle.load(fp)
    return result

load_object("data.pkl")

##
{'name': 'zhangsan', 'age': 30}

第七章 面向对象和异常处理

7.1 面向对象

  1. 面向对象的定义和使用：

    • 定义

      • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
      • **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
      • **数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
      • **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
      • **局部变量：**定义在方法中的变量，只作用于当前实例的类。
      • **实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
      • **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待
      • **实例化：**创建一个类的实例，类的具体对象。
      • **方法：**类中定义的函数。
      • **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

    • 使用：

      • #类
## 一:
class GrilFriend:
    ## 类的方法，函数
    def say_hello(self): ##self 参数是必须的，并且占在第一个位置
        print("你好，张三！")
        

xiao_hua = GrilFriend()
type(xiao_hua)

## __main__.GrilFriend

## 调用类的方法
xiao_hua.say_hello()

## 你好，张三！

xiao_tiantian = GrilFriend()
xiao_tiantian.say_hello()

## 你好，张三！




## 二:
class GrilFriend:
    ## 类的方法，函数
    def say_hello(self, num): ##self 参数是必须的，并且占在第一个位置
        for i in range(num):
        	print("你好，张三！")
            
            
xiao_hua = GrilFriend()
xiao_hua.say_hello(3)

## 
你好，张三！
你好，张三！
你好，张三！



## 三:
class GrilFriend:  ## 女朋友肯定是女性
    gender = '女的'  ## gender表示性别，这种声明的属性，表示类的公共属性
    ## 类的方法，函数
    def say_hello(self, num): ##self 参数是必须的，并且占在第一个位置
        for i in range(num):
            print("你好，张三！")
            
            
xiao_hua = GrilFriend()
xiao_hua.gender

## 女的



## 四:
class GrilFriend:  ## 女朋友肯定是女性
    gender = '女的'  ## gender表示性别，这种声明的属性，表示类的公共属性
    ## 私有属性
    def __init__(self, name, look):  ## __init__是构造方法，Python中独有的方法
        self.name = name   ## self表示我们定义的实际对象
        self.look = look
    ## 类的方法，函数
    def say_hello(self, num): ##self 参数是必须的，并且占在第一个位置
        print("来自{}的问候.".format(self.name))
        for i in range(num):
            print("你好，张三！")
            

            
xiao_hua = GrilFriend("小花", "90")
                     
print(xiao_hua.look)
xiao_hua.name
                      
##
90
'小花'

xiao_hua.say_hello(3)

##
来自小花的问候.
你好，张三！
你好，张三！
你好，张三！

  2. 面向对象的三大特性：

    • 封装

      • ## 封装
## 流程式的编写代码——>到函数式的编写代码——>再到面向对象
## 例如：
# 流程式：
sum = 0
for i in range(1, 100):
    sum += i
print(sum)

# 函数式：
def get_sum(n):
    sum = 0
    for i in range(1, n):
        sum += i
    print(sum)

get_sum(100)

# 面向对象：
class Operator:
    name = "计算器类"
    def get_sums(self, n):
        sum = 0
        for i in range(1, n):
            sum += i
        print(sum)
    def mupltiply(self, n):
        res = 1
        for i in range(1, n):
            res *= i
        print(res)
        
a = Operator()
a.get_sums(100)
a.mupltiply(5)


##
4950
4950
4950
24

    • 继承

      • #类
class GrilFriend:  ## 女朋友肯定是女性
    gender = '女的'  ## gender表示性别，这种声明的属性，表示类的公共属性
    ## 私有属性
    def __init__(self, name, look):  ## __init__是构造方法，Python中独有的方法
        self.name = name   ## self表示我们定义的实际对象
        self.look = look
    ## 类的方法，函数
    def say_hello(self, num): ##self 参数是必须的，并且占在第一个位置
        print("来自{}的问候.".format(self.name))
        for i in range(num):
            print("你好，张三！")
            

## 陪打游戏女朋友、陪编程女朋友、陪唱歌女朋友、陪学习女朋友
## 继承GrilFriend
class GameGrilFirend(GrilFriend):  ## 类的名字后面的括号里面写需要继承的类，类所包含的属性和方法就是自己的和继承的总和
    def game(self):
        print("打游戏 ing...")
class CodeGrilFriend(GrilFriend):
    def code(self):
        print("写代码 ing...")
class SingGrilFriend(GrilFriend):
    def sing(self):
        print("唱歌 ing...")
class StudyGrilFriend(GrilFriend):
    def study(self):
        print("学习 ing...")
        

### 继承单个
gf1 = GameGrilFirend("小美", 7)

gf1.game()
## 打游戏 ing...

gf1.game()
## 小美

gf1.gender
## 女

gf1.look
## 7

gf1.say_hello(3)
##
来自小美的问候.
你好，张三！
你好，张三！
你好，张三！

gf3 = SingGrilFriend("小花", 9)

gf3.sing()
## 唱歌 ing...



### 继承多个
class FullGrilFriend(GameGrilFirend, CodeGrilFriend, SingGrilFriend, StudyGrilFriend):
    pass  ## pass意味着没有逻辑，略过这里，不写代码


gf4.code()

gf4.sing()

gf4.game()

gf4.study()

gf4.name

##
写代码 ing...
唱歌 ing...
打游戏 ing...
学习 ing...
'小三'

    • 多态

      • #类
class GrilFriend:  ## 女朋友肯定是女性
    gender = '女的'  ## gender表示性别，这种声明的属性，表示类的公共属性
    def like(self):
        return "爱好"
    ## 私有属性
    def __init__(self, name, look):  ## __init__是构造方法，Python中独有的方法
        self.name = name   ## self表示我们定义的实际对象
        self.look = look
    ## 类的方法，函数
    def say_hello(self, num): ##self 参数是必须的，并且占在第一个位置
        print("来自{}的问候.".format(self.name))
        for i in range(num):
            print("你好，张三！")
            
            

## 陪打游戏女朋友、陪编程女朋友、陪唱歌女朋友、陪学习女朋友            
## 继承GrilFriend
class GameGrilFirend(GrilFriend):  ## 类的名字后面的括号里面写需要继承的类，类所包含的属性和方法就是自己的和继承的总和
    def like(self):
        return "打游戏"
    def game(self):
        print("打游戏 ing...")
class CodeGrilFriend(GrilFriend):
    def like(self):
        return "写代码"
    def code(self):
        print("写代码 ing...")
class SingGrilFriend(GrilFriend):
    def like(self):
        return "唱歌"
    def sing(self):
        print("唱歌 ing...")
class StudyGrilFriend(GrilFriend):
    def like(self):
        return "学习"
    def study(self):
        print("学习 ing...")
        
        
def get_like(gf):
    print("张三女朋友的爱好是:{}".format(gf.like()))  ## 约定张三女朋友都有like方法返回对应的爱好

gf5 = GameGrilFirend("小小", 7)

get_like(gf5)
## 张三女朋友的爱好是:打游戏

gf6 = CodeGrilFriend("小美",6)

get_like(gf6)
## 张三女朋友的爱好是:写代码


class RunGrilFriend(GrilFriend):
    def like(self):
        return "跑步"
    
gf7 = RunGrilFriend("小红", 9)

get_like(gf7)
## 张三女朋友的爱好是:跑步

7.2 异常处理

  1. 异常处理

    • try:
		{执行代码
except:
		{发生异常时执行代码
else:
		{没有异常时执行代码
finally:
		{不过有没有异常时都要执行代码

    • 案例：

      • ## 张三想结婚了
## 处理流程
try:
		{张三相亲
except:
		{性别、年龄、身高
else:
		{和对方在一起
finally:
		{二狗子总要结婚

      • # a / b
a = int(input("请输入一个整数："))  ## 将字符串强转为整型
b = int(input("请输入二个整数：")) 
print("{}除以{}等于:{}".format(a, b, a/b)) ##除数不能为0

##
请输入一个整数：4
请输入二个整数：2
4除以2等于:2.0

## 改进
# a / b
try:
    a = int(input("请输入一个整数："))  ## 将字符串强转为整型
    b = int(input("请输入二个整数：")) 
    print("{}除以{}等于:{}".format(a, b, a/b)) 
except ZeroDivisionError:
    print("除数不能为0")

##
请输入一个整数：4
请输入二个整数：0
除数不能为0

## 继续改进
# a / b
while True:
    try:
        a = int(input("请输入一个整数："))  ## 将字符串强转为整型
        b = int(input("请输入二个整数：")) 
        print("{}除以{}等于:{}".format(a, b, a/b)) 
        if a == 0:
            break
    except ZeroDivisionError:
        print("除数不能为0")
    except ValueError:
        print("输入格式错误!")
    except: ### except:这种最好是放到其他错误里面
        print("有问题")
    else:
        print("没有错误")
    finally:
        print("计算结束")
        
##
请输入一个整数：4
请输入二个整数：2
4除以2等于:2.0
没有错误
计算结束
请输入一个整数：4
请输入二个整数：q
输入格式错误!
计算结束
请输入一个整数：4
请输入二个整数：0
除数不能为0
计算结束



### 注意，如果运行卡死就重启

  2. 断言-assert关键字和抛异常-raise关键字：

    • assert示例：

      ## 示例

### [x1, x2, x3], [y1, y2, y3] -> x1*y1+x2*y2+x3*y3
def get_list_sum(list1, list2):
    result = 0
    for i in range(len(list1)):
        result += list1[i] * list2[i]
    return result

get_list_sum([1,2], [2])

## IndexError: list index out of range

      ### assert关键字

def get_list_sum(list1, list2):
    assert len(list1) == len(list2), "两个列表长度必须一致"  ## assert断言是假设的意思
    result = 0
    for i in range(len(list1)):
        result += list1[i] * list2[i]
    return result

get_list_sum([1,2], [2])

## AssertionError: 两个列表长度必须一致


try:
    get_list_sum([1,2], [2])
except AssertionError as e:
    print(e)

##
发生错误:
两个列表长度必须一致

    • 抛异常raise示例：

      ### ##
def get_list_sum(list1, list2):
    if len(list1) != len(list2):
        raise Exception("两个列表长度必须一致")
    result = 0
    for i in range(len(list1)):
        result += list1[i] * list2[i]
    return result

try:
    get_list_sum([1,2], [2])
except Exception as e:
    print(e)
    
## 两个列表长度必须一致


      ## 自定义错误类  # 注意，任何错误必须继承Exception
class MyError(Exception):
    def _int__(self,message):
        self.message = message
        
def get_list_sum(list1, list2):
#     assert len(list1) == len(list2), "两个列表长度必须一致" ##assert断言是假设的意思
    if len(list1) != len(list2):
#         raise Exception("两个列表长度必须一致")
        raise MyError("两个列表长度必须一致!")
    result = 0
    for i in range(len(list1)):
        result += list1[i] * list2[i]
    return result

try:
    get_list_sum([1,2], [2])
except Exception as e:
    print(e)

## 两个列表长度必须一致!

get_list_sum([1,2], [2])

## MyError: 两个列表长度必须一致!




# 改进
class MyError(Exception):
    def __init__(self, message, len1, len2):
        self.message = message
        self.len1 = len1
        self.len2 = len2
        
def get_list_sum(list1, list2):
    if len(list1) != len(list2):
        raise MyError("两个列表长度必须一致!",len(list1), len(list2))
    result = 0
    for i in range(len(list1)):
        result += list1[i] * list2[i]
    return result


try:
    get_list_sum([1,2], [2])
except MyError as e:
    print(type(e))
    print(e.len1)
    print(e.len2)
    
## 
<class '__main__.MyError'>
2
1
我像影子一样
关注
专栏目录
从Excel到Python数据分析进阶指南1
08-04
在数据分析领域，从Excel过渡到Python可以提供更强大的工具和灵活性。以下是一些关键的知识点，涵盖了从导入数据到数据清洗、预处理、提取、筛选以及汇总的全过程。 首先，生成数据表是数据分析的第一步。在Python...
Python数据分析：从入门到进阶，一篇文章带你飞！
CSDN_224022的博客
12-18 888
随着大数据时代的来临，数据分析已经成为了各行各业不可或缺的一环。而Python作为数据分析的利器，更是备受推崇。今天，我将为大家带来一篇关于Python数据分析的介绍，让我们一起走进数据的世界，探索Python的魅力！
8个Python高效数据分析的技巧
wly55690的博客
06-08 487
这篇文章介绍了8个使用Python进行数据分析的方法，不仅能够提升运行效率，还能够使代码更加“优美”。
Python数据分析（进阶篇）
最新发布
jxl20040418的博客
06-30 496
Python数据分析在各行各业都有广泛的应用前景。通过掌握Python数据分析的相关知识和技术，我们可以更加深入地了解业务和市场情况，发现潜在的机会和挑战，为企业的决策和发展提供有力支持。希望本文能够帮助您更好地了解Python数据分析的内容和应用场景，激发您对数据分析领域的兴趣和热情！
Python数据分析与挖掘进阶篇1——异常值分析、一致性分析、数据特征分析等（附实例！）
别看我只是一只羊
11-25 5421
初探Python数据分析day2    自我介绍一下，我是一名大四应届毕业生对数据挖掘方面很感兴趣，最近开始着手系统学习，在这里与大家分享我的学习笔记与心得，如果不足或错误请大家指出，感谢。 一、数据探索 ​    根据观测、调查收集到初步的样本数据集后，接下来要考虑的问题是:样本数据集的数量和质量是否满足模型构建的要求?是否出现从未设想...
史上最全 Python 数据分析学习路线
xiangxueerfei的博客
05-23 668
近年来，数据分析师的需求非常大，90%的岗位技能需要掌握Python作为数据分析工具。今天，小编整理了2022年，从，一篇文章帮你搞定，奥利给！话不多说，新手自学Python数据分析的4大阶段，直接开始。数据分析的第一步就是先玩明白Python语言。Python语言简洁，入门容易，包括。掌握Python语言作为数据分析工具，从而有能力驾驭不同领域的数据分析实践。对于目前就业市场上的技术岗位，除了开发、测试、运维等常见职位之外，数据类岗位也越来越成为热门的求职方向。
Python数据分析 Pandas进阶（中） 这篇就够了
制定持续可量化的目标，不断坚持。
02-02 1091
入门篇：Python数据分析 Pandas快速入门至进阶这篇就够了_python pandas-CSDN博客进阶篇上：Python数据分析 Pandas进阶（上） 这篇就够了-CSDN博客。
Python数据挖掘：入门、进阶与实用案例分析.pptx
10-12
Python数据挖掘：入门、进阶与实用案例分析是一本全面介绍Python数据挖掘的书籍，主要内容涵盖了数据挖掘的基本概念、Python环境下的数据挖掘工具和库的使用，以及多个实用的数据挖掘案例分析。本书首先介绍了数据...
Python数据分析实战与运用之数据分析篇
03-10
Python数据分析实战与运用之数据分析篇 Python数据分析实战与运用之数据分析篇是基于真实场景的数据Peter Li课程，课程定位三大方面：零基础学员或者有一定基础学员、大中院校学生、在职从事数据分析相关工作以及...
advancedpython:python进阶程序学习
07-04
Python作为一种高级编程语言，因其简洁明了的语法和强大的功能，深受程序员喜爱，尤其在数据分析、机器学习、网络爬虫等领域广泛应用。本资源"advancedpython:python进阶程序学习"旨在帮助已经掌握Python基础的...
013 《数据分析从入门到进阶》读书笔记
01-07
看过的道、术有一些积累了，但真正存入脑海...《数据分析从入门到进阶》作者：陈红波，刘顺祥等 摘记 一、数据分析之道、术及工具（excel,sql,tableau） 二、python数据分析回归模型常用技术 作者：积跬步，慕至千里
数据分析 NO.9 python进阶深入
TeddyBob的博客
05-23 441
python进阶深入 1.生成器：创建生成器最简单的方法就是用圆括号()代替方括号 [] 把列表生成式的 [ ] 变成（） 生成器只能调用一次，不占用资源。用完就释放出来。 for i in g: print(i) 也可以调用Next函数直到计算出最后一个元素位置,但是这种方法很明显不适用，并且最后会抛出StopIteration的错误。 斐波那契数列：除第一个和第二个数外，任意...
python数据分析进阶
m0_65592124的博客
12-19 217
python
从入门到进阶的Python数据分析手册，真香
Python_MY的博客
02-11 340
“数据分析”爆了，近些年随着大数据产业的快速发展，场景化业务需求越来越重要了，作为能使得大数据价值化的重要手段工具的数据分析师，也成为了行业“香饽饽”。 数据分析为什么如此重要，是因为它能带给企业价值。未来商业世界里，任何一家公司，都应该拥有驾驭数据的能力，要学会精细化运营来提升业绩，利用数据驱动来对业务增长负责。 01数据分析每天急需10000+人才 据数据统计，北京地区每天需要大概10000+数据分析人才，需求大，人才少！所以这就决定了数据人才在市场上拥有令人眼红的薪资水平！一年工作.
Python数据分析神器——pandas（进阶教程）
King
03-25 891
pandas和Python标准库提供了一组高级的、灵活的、高效的核心函数和算法，它们使你能够轻松地将数据规整化为正确的形式。
数据分析的能力体系和进阶路线
cinaizi7494的博客
03-07 494
数据分析是一个被广泛使用的技能标签。在真实工作环境下，至少有三个类型的职位可以算作和数据分析师相关，分别是：BI (Business Intelligence), QA (Quantitative Analyst / Da...
python进阶数据分析_python数据分析进阶之pandas
weixin_39702483的博客
12-20 118
摘要Pandas是基于numpy来构建的，让numpy为中心的应用变得更加简单。Pandas主要包括两个数据结构，Series和DataFrame。既能处理时间序列的数据也能处理非时间序列的数据，同时在处理缺省值上面非常灵活。一.主要数据结构Series可以把series理解为一维数组或者向量，由value以及index组成。1.创建series>>> import pandas...
带大家读python数据分析一书（一）
Don的博客
09-08 8281
写在开头   这一次就让我来带读这本《利用Python进行数据分析》一书，这本书我也是第一次看，所以我在写的时候既是一边和你们分享也是在一边学习，当然，在我的博客中我在带读本书的时候也会加上一些自己的理解，因为本人的水平有限，也许有些不是非常正确的地方希望各位读者能够帮忙指点出来，实在是感激不尽！ 《利用Python进行数据分析》一书   也许有人不知道这本书是怎么样的，我在这里就放一下它的...
Python攻防秘籍：运用Python进阶黑客技术
法庭调查取证章节则侧重于利用Python进行数字证据的收集和分析，包括定位个人位置、数据恢复、提取Windows注册表信息、文档元数据以及从镜像中获取线索，同时涵盖对应用程序和移动设备痕迹的调查。 网络流量分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值