【Python】一、最新版Python基础知识总结、综合案例实战

第二章 走进Python的世界—初识Python

第2集 千里之行始于足下—编程语言概览

简介：编程语言概览

• 机器语言

  • 计算机能够直接理解和执行的语言

  • 一系列由二进制代码（0和1）组成的指令每条指令都对应着计算机硬件上的一条具体操作

  • 机器语言是计算机最底层的语言

    10011101001100101
    

• 汇编语言：用于电子计算机、微处理器、微控制器或其他可编程器件的低级语言（符号语言）

  • 短助记符如 ADD、MOV、SUB 和 CALL 书写的语句

• 现代高级语言

  • 更易于人类理解和编写的编程语言
  • 它们通常具有更丰富的语法结构和更强大的功能
  • 能够支持面向对象编程、泛型编程、函数式编程等多种编程范式

• 编译型语言：程序运行前，通过编译器将源代码一次性转换为机器代码再执行程序

  • Java
  • C#
  • Go

• 解释型语言：程序运行时，通过解释器将源代码逐行转换为机器代码并执行

  • Python
  • Javascript

第3集 Python运行前置条件—环境安装

简介：环境安装

• Python安装环境

  • https://www.python.org/downloads/

• windows版本安装流程

• mac版安装流程

  • 直接访问官网下载

第4集 Python运行前置条件—Pycharm的安装

简介：IDE（开发工具）Pycharm的安装

• IDEA、VSCODE

• Pycharm安装使用

  • https://www.jetbrains.com/zh-cn/pycharm/download

• 注意

  • 下载的pycharm只有30天的免费试用，需要在官网购买使用套餐
    -可以 pojie

第5集 Python运行前置条件—Pycharm的使用

简介：IDE（开发工具）Pycharm的使用

• 汉化
  
  

• 新建项目
  

第三章 Python启航—基础入门知识点

第1集 基础入门知识点—Python代码规范

简介：Python代码规范

• 语句分隔符

  ; 或者换行
  

• 格式化

  • 对于Windows和Linux操作系统，格式化代码的快捷键是Ctrl + Alt + L。
  • 对于macOS操作系统，格式化代码的快捷键是Cmd + Option + L。

• 注释语句

  # 这是一行注释
  

  """
  这是一段注释
  """
  

• pep8规范

  • 官方文档：https://peps.python.org/pep-0008/

第2集 基础入门知识点—变量

简介：变量

• 打印关键字print

  print('输出的内容')
  

• 变量

  • 含义
    • 变量是一个存储数据值的容器
    • 数据值可以是数字、字符串、列表、元组、字典、集合、布尔值等
    • 变量名可以是任意的，但要遵循约定

• 变量名规范

  • 数字字母下划线_组合，不允许出现其他特殊符号，不允许数字开头

  • 不允许使用python的关键字if、else、print或内置函数等等

  • 小驼峰或者下划线分隔

第3集 基础入门知识点—变量值的修改

简介：变量值的修改

• 变量修改

  • 变量是个容器，数据是可以修改的

• 变量取名要顾名思义

第4集 基本数据类型—数字类型

简介：数字类型

• 数字类型

  • 整型

    x=10
    print(type(x))
    

  • 浮点型

    y=0.1
    print(type(y))
    

第5集 基本数据类型—数字类型实战案例

简介：数字类型实战案例

• 计算圆形的面积和周长

  import math
  
  # 输入圆的半径  
  radius = 3
  
  # 计算面积
  area = math.pi * radius ** 2
  
  # 计算周长  
  length = 2 * math.pi * radius
  
  # 输出结果  
  print(f"圆的面积为：{area}")
  print(f"圆的周长为：{length}")
  

第6集 基本数据类型—布尔类型

简介：布尔类型

• 布尔类型

  • 用于表示逻辑值：真（True）或假（False）

• 应用场景

  • 布尔值经常用于条件语句（如if语句）中，以控制程序的流程
  • 在逻辑运算（如and、or、not）中，布尔值也是必需的

• 运算

  # and 运算  
  print(True and True)  # 输出 True  
  print(True and False)  # 输出 False  
  
  # or 运算  
  print(True or False)  # 输出 True  
  print(False or False)  # 输出 False  
  
  # not 运算  
  print(not True)  # 输出 False  
  print(not False)  # 输出 True
  

• 其他数据类型与布尔值的转换

  • 某些其他数据类型（如整数、浮点数、字符串等）在特定上下文中会被解释为布尔值
  • 空值（如空列表、空字典、空字符串、0、None等）通常被视为False，而非空值和非零值通常被视为True

第7集 基本数据类型—字符串类型

简介：字符串类型

• 字符串类型

  • 字符串（String）是一种数据类型，用于存储文本信息
  • 字符串可以用单引号（’ '）、双引号（" “）或三引号（”“” “”"）来定义

• 创建字符串

  # 字符串单引号
  name = '小白课堂老王'
  
  # 字符串双引号
  age = "48"
  
  # 字符串三引号
  hobby = """
      1.洗脚
      2.按摩
      3.看美女
  """
  

• 转义符

  • 转义符在字符串中插入那些无法直接表示或具有特殊含义的字符

• 常见的转义符

  • \\：反斜杠，用于在字符串中插入反斜杠
  • \'：单引号，用于在单引号字符串中插入单引号
  • \"：双引号，用于在双引号字符串中插入双引号
  • \n：换行符，用于在字符串中插入一个新行
  • \t：制表符，用于在字符串中插入一个制表符（通常相当于几个空格）

  # 单引号字符串插入单引号
  single_string = '老王：\'在吗？\''
  print(single_string)
  
  # 双引号字符串插入双引号
  double_string = "老王：\"吃饭了吗？\""
  print(double_string)
  
  # 换行和制表
  other_string = "冰冰：\n\t我很想念你"
  print(other_string)
  

• 注意

  在mac版系统的路径分隔为/，在windows版系统中为\
  在windows中当路径为 \Users\niu\Document 时，会有换行的问题，需要在前面加多一个\
  

第8集 基本数据类型—字符串格式化输出+序列操作

简介：字符串格式化输出+序列操作

• 格式化输出

  • 将变量或表达式的结果嵌入到字符串中，以生成有意义的输出

  • 旧版本字符串的%运算符格式化(%s,%d,%f)

    name = "老王"  
    age = 48  
    print("他的名字是 %s ，今年 %d 岁" % (name, age))
    

  • 新版本字符串格式化（str.format() 方法）

    name = "老王"  
    age = 48  
    print("他的名字是 {} 今年 {} 岁".format(name, age))
    

  • 新版本字符串格式化（f-string）

    name = "老王"  
    age = 48 
    print(f"他的名字是 {name} 今年 {age} 岁")
    

• 字符串序列操作

  • 字符串的创建、修改、查找和格式化

  • 索引获取某个字符

    s = "Hello, World!"  
    print(s[0])  # 输出 'H'  
    print(s[-1])  # 输出 '!' 
    

  • 切片获取字符

    s = "Hello,World!"    
    # 顾头不顾尾
    print(s[6:11])  # 输出 'World'
    
    # 缺省取到尾
    
    print(s[6:])  # 输出 'World!'
    
    # 缺省取到头
    print(s[:6])  # 输出 'Hello,'
    
    # 默认从左向右
    print(s[6:11:1])  # 输出 'World!'
    
    # 隔1取
    print(s[6:11:2]) # 输出 'Wld'
    
    # 从右向左
    print(s[11:5:-1])  # 输出 '!dlroW'
    

  • 拼接字符串

    xd='小白课堂'
    name='老王'
    
    print(xd+name)
    

  • 计算长度 len()

    a1='Hello,World!'
    
    print(len(a1))
    

  • 判断是否存在 in()

    a2='Hello,World!'
    
    print('lo' in a2)
    

第9集 基本数据类型—字符串内置方法+运算符

简介：字符串内置方法+数字运算符

• 字符串内置方法

  方法	含义
  upper	大写
  lower	小写
  startswith()	是否以某个字符开头
  endswith()	是否以某个字符结尾
  isdigit()	是否全数字
  strip()	去两边空格
  join()	字符串连接
  split()	字符串分割
  find()	搜索指定字符串，无返回-1
  index()	搜索指定字符串，无报错
  count()	统计指定字符串出现次数
  replace()	替换

• 常用运算符

  运算符类别	运算符	示例
  计算运算符	+ - * / %	1+1 5%2
  比较运算符	> < >= <= == !=	2>=1 2!=1
  赋值运算符	= += -+ *= /= %=	a=10 a+=2 a-=3
  逻辑运算符	and or not	2>=1 and 5>2
  成员运算符	in	1 in [1,2,3]

• 输入输出函数

  • input() 阻塞程序，等待输入
  • int() 将输入数据转成数字类型

第四章 Python启航—复杂数据类型

第1集 复杂数据类型—列表类型

简介：列表类型

• 数组

  • 在Python中，实际上并没有一个专门的“数组”数据类型

  • 通常是指NumPy库中的ndarray（N维数组）对象

  • 而Python的标准数据类型中，有一个“列表”（list），它可以用来存储一系列有序的元素

    import numpy as np
    
    int_array = np.array([1, 2, 3, 4, 5])  # 整数数组
    str_array = np.array(['1', '2', '3', '4', '5'])  # 字符串数组
    

• 列表

  • 定义：
    • 列表（List）是Python中非常常用的一种数据结构
    • 它可以包含任意类型的数据项，如整数、浮点数、字符串、其他列表等，并且列表中的数据项之间是有序的
  • 特性：
    • 有序：列表中的元素具有明确的位置
    • 可变：列表创建后，可以修改其中的元素
    • 可重复：同一个元素可以在列表中出现多次

• 创建列表

  • 使用 [] 创建

    # 创建一个包含整数的列表  
    list1 = [1, 2, 3, 4, 5]  
    
    # 创建一个包含不同类型元素的列表  
    list2 = [1, 'two', 3.0, [4, 5, 6]]
    

  • 使用list()函数创建

    # 从range对象创建列表  
    numbers_list = list(range(1, 6))  # [1, 2, 3, 4, 5]  
    
    # 从字符串创建列表  
    string_list = list("hello")  # ['h', 'e', 'l', 'l', 'o']
    

• 索引和切片

  # 获取列表中的第2到第4个元素（不包括第4个）  
  list = numbers[1:4]  # [2, 3, 4]  
  
  # 每隔一个元素取一个（步长为2）  
  other = numbers[::2]  # [1, 3, 5]
  

第2集 复杂数据类型—列表类型的常用方法

简介：列表类型的常用方法

• 列表常用方法

  方法	含义
  append	在列表末尾添加元素（参数为值，改变原列表）
  insert	在指定索引前插入元素（参数为索引和值，改变原列表）
  remove	删除列表中首次出现的指定元素（参数为值，改变原列表）
  pop	删除并返回列表中指定索引的元素，如果不指定位置则默认删除最后一个元素（改变原列表）
  extend	将一个列表的所有元素添加到另一个列表的末尾（参数为要添加的列表，改变原列表）
  index	返回指定元素在列表中的第一个出现的索引位置
  count	返回指定元素在列表中出现的次数
  sort	对列表中的元素进行排序（改变原列表）
  sorted（内置函数）	对列表中的元素进行排序（不改变原列表）

第3集 复杂数据类型—字典类型

简介：字典类型

• 含义

  • 字典是一种可变、无序且键值对(key-value)的数据结构

• 创建

  • 字典是通过大括号 {} 创建的，键值对之间用逗号 , 分隔

  • 键（Key）是唯一的，通常是不可变类型（如整数、浮点数、字符串、元组），值（Value）可以是任意类型

    # 创建一个字典   
    person = {  
        'name': '老王',  
        'age': 48,  
        'city': 'guangzhou'  
    }  
    print(person)  # 输出: {'name': '老王', 'age': 48, 'city': 'guangzhou'}
    

• 访问字典值

  • 通过键来访问字典中的值

    person = {'name': '老王', 'age': 48}
    # 访问字典元素
    print(person['name'])  # 输出: 老王
    print(person.get('age', 'Not Found'))  # 输出:48
    print(person.get('hobby', 'Not Found'))  # 输出: Not Found
    
    # 尝试访问不存在的键会抛出异常 KeyError: 'sex'
    print(person['sex']) 
    

• 修改字典的值

  • 可以直接通过键来修改字典中的值

    # 修改字典元素  
    person['age'] = 18  
    print(person)  # 输出: {'name': '老王', 'age': 18}
    

• 添加字典的元素

  • 如果键不存在，可以直接添加键值对

    # 添加字典元素  
    person['sex'] = '男'  
    print(person)  # 输出: {'name': '老王', 'age': 18, 'sex': '男'}
    

• 删除字典元素

  • 使用 del 或者 pop() 删除字典元素

  • popitem() 按照插入顺序删除，旧版本3.7以前是随机删除并返回一个元素（键值对）

  • clear() 清空字典

    # 删除字典元素  
    del person['sex']  
    print(person)  # 输出: {'name': '老王', 'age': 18}
      
    # 使用pop方法删除并返回元素的值  
    sex = person.pop('sex')  
    print(person)  # 输出: {'name': '老王', 'age': 18}
    print(sex)  # 输出: '男'  
      
    # 清空字典  
    person.clear()  
    print(person)  # 输出: {}
    

第4集 复杂数据类型—字典类型的常用方法

简介：字典类型的常用方法

• 常用方法

  • keys()：返回字典中所有的键（输出的是视图对象，并不是列表）

  • values()：返回字典中所有的值（输出的是视图对象，并不是列表）

  • items()：返回字典中所有的键值对（输出的是视图对象，并不是列表）

  • update()：使用另一个字典的键值对更新当前字典

    
    # 字典的方法  
    print(person.keys())  # 输出: dict_keys(['name', 'age'])  
    print(person.values())  # 输出: dict_values(['男', 48])  
    print(person.items())  # 输出: dict_items([('name', '男'), ('age', 48)])  
      
    # 使用update方法更新字典  
    person.update({'age': 18, 'hobby': 'xijiao'})  
    print(person)  # 输出: {'name': '男', 'age': 32, 'hobby': 'xijiao'}
    

• 字典推导式

  • 类似于列表推导式，可以快速生成字典

    # 字典推导式  
    keys = ['a', 'b', 'c']  
    values = [1, 2, 3]  
    dict_comp = {k: v for k, v in zip(keys, values)}  
    print(dict_comp)  # 输出: {'a': 1, 'b': 2, 'c': 3}
    

    dict_comp = {k: v for k, v in zip(keys, values)} 
    
    for k, v in zip(keys, values)：这是一个for循环，它解包遍历zip(keys, values)产生的迭代器 [('a', 1), ('b', 2), ('c', 3)]
    在每次迭代中，k取元组的第一个元素（即来自keys），v取元组的第二个元素（即来自values）
    
    {k: v...}：对于每次迭代，这表示一个新的键值对，其中k是键，v是值，包裹在大括号中，表示正在生成一个新的字典
    

第5集 复杂数据类型—元组类型

简介：元组类型

• 定义

  • 元组是一个不可变的序列类型，用于存储一系列按特定顺序排列的元素
  • 一旦元组被创建，它的内容就不能被修改，也就是说，你不能添加、删除或更改元组中的元素

• 创建

  • 使用圆括号()将元素括起来，元素之间用逗号,分隔

    # 创建一个包含不同类型元素的元组  
    tuple1 = (1, 'hello', 3.14, True)  
    print(tuple1)  # 输出: (1, 'hello', 3.14, True)
    
    # 只有一个元素的元组
    tuple2 = (1,)
    print(tuple2)
    

• 特性

  • 不可变性：元组一旦创建，其元素就不能被修改

  • 有序性：元组中的元素按照定义的顺序进行排列

  • 可索引：和列表一样，元组也可以通过索引访问元素

  • 可切片：可以使用切片操作获取元组中的一部分元素

    # 访问元组中的元素  
    print(tuple1[0])  # 输出: 1  
      
    # 切片操作  
    sub_tuple = tuple1[1:3]  # 获取索引1到2元素  
    print(sub_tuple)  # 输出: ('hello', 3.14)
    

  • 元组可以包括列表（可变的），外部改变了列表，但是元组的结构不变

    # 创建一个包含不同类型元素的元组
    tuple1 = (1, 'hello', 3.14, [1, 2, 3])
    
    tuple1[3].pop(1)
    
    print(tuple1)
    

第6集 复杂数据类型—元组类型常用方法和操作

简介：元组类型常用方法操作

• 常用方法

  • count(value)：返回元组中指定值出现的次数

  • index(value)：返回指定值在元组中第一次出现的索引，如果未找到则抛出异常

    # 使用count方法  
    print(tuple1.count('hello'))  # 输出: 1  
      
    # 使用index方法  
    print(tuple1.index(0.3))  # 输出: 2
    

• 操作

  • 拼接

    tuple1 = (1, 2, 3)
    tuple2 = ("a", b", "c")
     
    sum_tuple = tuple1 + tuple2
    print(sum)   # 输出：(1, 2, 3, 'a', 'b', 'c')
    

  • 重复

    tuple1 = (1, 2, 3)
     
    repeated_tuple = tuple1 * 3
    print(sum)   # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3,)
    

  • 判断存在

    tuple1 = (1, 2, 3)
    
    print(3 in tuple1)  # True
    print(6 in tuple1)  # False  
    

  • 元组长度

    tuple1 = (1, 2, 3)
    
    print(len(tuple1))  # 3 
    

  • 解包

    tuple1 = (1, 2, 3)
     
    a, b, c = tuple1
     
    print(a)  # 1
    print(b)  # 2
    print(c)  # 3
    

  • 比较

    tuple1 = (1, 2, 3)
    tuple2 = (1, 2, 3)
    tuple3 = (3, 2, 1)
     
    print(tuple1 == tuple2)  # True
    print(tuple1 == tuple3)  # False 
    

  • 通过重新赋值创建新的元组

    tuple1 = (1, 2, 3)
    tuple1 = tuple1 + (4,)  # 创建新的元组并赋值给原变量
    print(tuple1)  # (1, 2, 3, 4)
    

  • 元组作为字典键（由于元组不可变性，可以作为字典的键，而列表等可变类型则不能）

    dict1 = {(1, 2): "a", (3, 4): "b"}
    print(dict1[(1, 2)])  # a 
    

第7集 复杂数据类型—集合类型

简介：集合类型

• 定义

  • 集合是一个无序且不包含重复元素的数据类型

• 特性

  • 无序性：集合中的元素没有特定的顺序

  • 互异性：集合中的元素是唯一的，不重复

• 创建

  • 使用大括号 {} （不能创建空集合）或 set() 函数来创建集合

    # 使用大括号创建集合  
    set1 = {1, 2, 3, 4}  
      
    # 使用 set() 函数创建集合  
    set2 = set([1, 2, 2, 3, 4])  # 注意，重复的2只会被存储一次  
      
    print(set1)  # 输出：{1, 2, 3, 4}  
    print(set2)  # 输出：{1, 2, 3, 4}
    

  • 利用集合去重

    # 利用集合去重
    list1 = [1, 2, 3, 4, 2]
    set1 = set(list1)
    list1 = list(set1)
    print(list1)
    

• 基本操作

  • 添加元素：使用 add() 方法或更新操作符 |=

  • 删除元素：使用 remove() 或 discard() 方法，或使用 pop() 移除并返回随机元素（如果集合非空）

  • 判断元素是否存在：使用 in 关键字

  • 集合的长度：使用 len() 函数re

    set1 = {1, 2, 3}  
      
    # 添加元素  
    set1.add(4)  
    print(set1)  # 输出：{1, 2, 3, 4}  
      
    # 删除元素  
    set1.remove(2)  
    print(set1)  # 输出：{1, 3}  
      
    # 判断元素是否存在  
    print(3 in set1) # 输出 True 
      
    # 集合的长度 
    print(len(set1))  # 输出：3
    

第8集 复杂数据类型—集合类型运算和方法

简介：集合类型运算和方法

• 运算

  • 交集：使用 & 运算符方法

    

  • 并集：使用 | 运算符方法
    

  • 差集：使用 - 运算方法
    

  • 对称差集：使用 ^ 运算符方法

  

  set1 = {1, 2, 3, 4}  
  set2 = {3, 4, 5, 6}  
    
  # 交集  
  print(set1 & set2)  # 输出：{3, 4}  
    
  # 并集  
  print(set1 | set2)  # 输出：{1, 2, 3, 4, 5, 6}  
    
  # 差集  
  print(set1 - set2)  # 输出：{1, 2}  
    
  # 对称差集  
  print(set1 ^ set2)  # 输出：{1, 2, 5, 6}
  

• 方法

  • clear()：清空集合

  • copy()：返回集合的浅拷贝

    # 创建一个集合  
    set1 = {1, 2, 3, 4} 
      
    # 清空集合  
    set1.clear()  
    print(set1)  
    
    # 浅拷贝
    set2 = set1.copy() 
    print(set2)  
    

第五章 Python进阶—进阶逻辑语句

第1集 进阶逻辑语句—程序流程控制语句

简介：程序流程控制语句

• 程序流程控制语句分类

  • 顺序结构语句

    

  • 分支结构语句

    • 双分支语句

    

    • 分支嵌套语句
      

  • 循环结构

  

第2集 程序流程控制语句—顺序结构语句

简介：顺序结构语句

• 顺序结构语句

  length = int(input('请输入长方形的长:'))
  width = int(input('请输入长方形的宽:'))
  area = length * width
  print(area)
  

第3集 程序流程控制语句—分支结构语句

简介：分支结构语句

• 双分支语句

  if 表达式:
  	语句1
  	语句2
  else:
  	语句3
  	语句4
  

  score = int(input('请输入分数:'))
  if score >= 60:
      print('及格')
  else:
      print('不及格')
  

• 多分支语句

  if 条件1:
  	语句1
  elif 条件2:
  	语句2
  elif 条件3:
  	语句3
  else:
  	语句4 # 所有条件为假执行当前语句
  

  score = int(input('请输入分数:'))
  if score >= 90:
      print('优秀')
  elif score >= 80:
      print('良好')
  elif score >= 70:
      print('中等')
  elif score >= 60:
      print('及格')
  else:
      print('不及格')
  

第4集 程序流程控制语句—分支嵌套语句

简介：分支嵌套语句

• 分支嵌套语句

if 表达式1:
	语句1
	if 表达式2:
		语句2
	else:
		语句3
else:
	语句4

iphone = input("输入电话号码:")
origin = ''
if iphone[0:3] == '188':
    origin = '移动'
    if iphone[3:7] == '1111':
        origin = '广东移动'
    else:
        origin = '北京移动'
else:
    origin = '联通'
print(origin)

第5集 程序流程控制语句—分支循环语句

简介：分支循环语句

• 循环语句—while循环

  while 判断表达式:
  		语句1
  

  count = 0
  while count < 10:
      print(count)
      count += 1
  

第6集 程序流程控制语句—循环语句for循环

简介：分支循环语句

• 分支循环语句

  • 语法结构

    for 变量名 in 可迭代对象:
    		# 循环体，每次代码执行的代码块
    		# 可以通过变量名引用迭代对象的元素
    

  • 代码

    for item in '小白课堂老王':
    		print(item)
    

    for item in [1,2,3,4]:
    		print(item)
    

第7集 程序流程控制语句—随机生成验证码的案例

简介：随机生成验证码的案例

• 随机生成验证码

  import random  # 生成随机数
  import string	 # 生成字母/数字字符串
  
  str1 = ''
  for i in range(4):
      random_char = random.choice(string.ascii_uppercase)
      str1 += random_char
  print(str1)
  
  
  range # 内置函数生成数字序列
  

第8集 程序流程控制语句—循环的退出break

简介：循环的退出break

• 循环退出break

  • 立即退出当前循环（无论是for循环还是while循环）

  • 当遇到break语句时，程序将不会执行循环体中的剩余语句，而是直接跳转到循环之后的语句

    for i in range(10):
        print(i)
        if i == 8:
            break
    print('程序结束了')
    

第9集 程序流程控制语句—循环的退出continue

简介：循环的退出continue

• 循环退出continue

  • 跳过当前循环的剩余部分，并立即开始下一次迭代

  • 当遇到continue语句时，程序将不会执行循环体中的continue之后的语句，而是直接跳转到下一次循环的开始

    for i in range(10):  
        if i == 3:  
            continue  
        print(i)  
    # 输出: 1  
    #      2  
    #      4  
    #      5  
    # 当i为3时，循环遇到continue，因此不会输出3，而是直接开始下一次迭代
    

第六章 Python进阶—函数编程

第1集 函数编程—函数的定义和创建

简介：函数的定义和创建

• 函数的定义

  • 函数指将一组语句的集合通过一个变量名封装起来，调用这个函数变量名，就可以执行函数

• 函数的特性

  • 减少重复逻辑代码的编写
  • 将程序中的逻辑可以进行扩展
  • 维护项目程序的代码更简单

• 函数的创建

  def say_hello(): # 函数名
  	# 要执行的逻辑代码
  	
  say_hello() # 调用函数
  

  def sum(a,b): # 函数名
  	res = a + b
  	print(res)
  	
  sum() # 调用函数
  
  
  def sum(a,b): # 函数名
  	# return a + b
  	res = a + b
  	return res # 返回结构并且停止运行 
  	
  print(sum(1,2)) # 调用函数
  

第2集 函数编程—函数的参数

简介：函数的参数

• 参数

  • 形参

    # l、w是形参
    def oblong_area(l, w):
        area = l * w
        return area
    print(oblong_area(10, 20))
    

  • 实参

    # 10、20是实参
    def oblong_area(l, w):
        area = l * w
        return area
    print(oblong_area(10, 20))
    

  • 默认参数

    • 默认参数需要放在参数的最后位置

    # l是默认参数
    def oblong_area(w, l=10):
        area = l * w
        return area
    
    
    print(oblong_area(20))
    

  • 关键参数

    • 一般函数传参要按照顺序，但是可以通过关键参数（指定参数名字）可以不按照顺序
    • 关键参数必须放在位置参数后面

    # l是默认参数
    def oblong_area(w, h, l=10):
        area = l * w * h
        return area
    
    
    print(oblong_area(10, l=20, h=3))
    

  • 非固定参数

    def get_info(name, age, *args):
        print(name, age, args)
    
    
    get_info('老王', '48', 'xijiao', 'anmo')
    # *args把传入的参数编程元组形式
    

    def get_info(name, age, **kwargs):
        print(name, age, kwargs)
    
    
    get_info('老王', '48', hobby1='xijiao', hobby2='anmo')
    # **kwargs把传入的参数编程元组形式
    

第3集 函数编程—全局变量和局部变量

简介：全局变量和局部变量

• 全局变量

  • 全局变量是在函数外部定义的变量，它们在程序的整个生命周期内都是可用的

    # 这是一个全局变量  
    global_var = "全局的变量"  
      
    def print_global_var():  
        print(global_var)  
      
    global_var()  # 输出: 全局的变量
    

• 局部变量

  • 局部变量是在函数内部定义的变量，它们只在函数被调用时存在，并在函数执行完毕后被销毁

  • 局部变量只在它们被定义的作用域内有效，即只能在函数内部访问和修改

    def print_local_var():
        local_var = '局部变量'
        print(local_var)
    
    print_local_var() 
    
    # 这里不能访问local_var，因为它只在local_var函数内部存在  
    # print(local_var)  # 这会抛出一个NameError异常
    

• 注意

  • 在函数内部修改或者使用全局变量时应该声明

    global_var = "全局变量"  
      
    def change_global_var():  
        global global_var  # 声明我们要修改的是全局变量  
        global_var = "全局变量被修改了"  
      
    change_global_var()  
    print(global_var)  # 输出: 全局变量被修改了
    

第4集 函数编程—内置函数上

简介：内置函数

• 内置函数
  

  • 官方文档地址：https://docs.python.org/3/library/functions.html

• abs()

  返回数字的绝对值

  x = -10  
  print(abs(x))  # 输出：10
  

• all()

  如果可迭代对象中的所有元素都为True（或可迭代对象为空），则返回True

  numbers = [1, 2, 3]  
  print(all(numbers))  # 输出：True  
  numbers.append(0)  
  print(all(numbers))  # 输出：False
  

• any()

  如果可迭代对象中的任何元素为True，则返回True

  numbers = [0, 0, 0, False]  
  print(any(numbers))  # 输出：False  
  numbers.append(1)  
  print(any(i for i in numbers))  # 输出：True
  

• chr()

  返回整数对应的ASCII字符（全称为美国信息交换标准代码，128个字符，在处理文件I/O或网络通信时需要使用，实际上更通用的Unicode字符集）

  i = 65  
  print(chr(i))  # 输出：'A'
  

• dict()

  创建一个字典

  d = dict(a=1, b=2, c=3)  
  print(d)  # 输出：{'a': 1, 'b': 2, 'c': 3}
  
  items = [('a', 1), ('b', 2), ('c', 3)]  
  d = dict(items)  
  print(d)  # 输出：{'a': 1, 'b': 2, 'c': 3}
  

• dir()
  返回对象的属性列表。如果未指定对象，则返回当前范围内的变量、方法和定义的类型列表。

  print(dir())  # 列出当前作用域内的变量等  
  print(dir(str))  # 列出str类型的所有属性和方法
  

• help()
  提供有关模块、关键字、属性等的帮助信息。

  help(print)  # 显示print函数的帮助信息
  

• id()
  返回对象的“身份”（一个整数，通常是其在内存中的地址）。

  x = 10  
  print(id(x))  # 输出：x的内存地址（每次运行可能不同）
  

• input()
  从用户获取输入。

  user_input = input("请输入一个数字: ")  
  print("你输入的是:", user_input)  # user_input是一个字符串
  

• int()
  将数字或字符串转换为整数。

  s = "123"  
  num = int(s)  
  print(num)  # 输出：123
  

• len()
  返回对象（如字符串、列表、元组等）的长度或项目数。

  s = "hello"  
  print(len(s))  # 输出：5
  

• list()
  将可迭代对象转换为列表。

  tuple_example = (1, 2, 3)  
  list_example = list(tuple_example)  
  print(list_example)  # 输出：[1, 2, 3]
  

第5集 函数编程— 内置函数下

简介：内置函数

1. locals()

   • 功能：返回当前局部符号表的字典。如果在一个函数内部调用它，返回的字典将包括函数的局部变量名及其值。
   • 示例：

   def test():  
       x = 10  
       print(locals())  # 输出类似于：{'x': 10}  
   test()
   

2. map()

   • 功能：将一个函数应用于一个或多个可迭代对象的项，并返回一个新的迭代器，其中包含函数的结果。
   • 示例：

   numbers = [1, 2, 3, 4]  
   squared = map(lambda x: x**2, numbers)  
   print(list(squared))  # 输出：[1, 4, 9, 16]
   

3. max()

   • 功能：返回给定参数中的最大值。如果有多个参数，则返回最大的那个；如果只有一个可迭代对象，则返回该对象中的最大值。
   • 示例：

   print(max(1, 2, 3))  # 输出：3  
   print(max([1, 4, 2, 9]))  # 输出：9
   

4. min()

   • 功能：与max()相反，返回给定参数中的最小值。
   • 示例：

   print(min(1, 2, 3))  # 输出：1  
   print(min([1, 4, 2, 9]))  # 输出：1
   

5. open()

   • 功能：用于打开一个文件，返回一个文件对象（通常是一个_io.TextIOWrapper实例），该对象可以用于读取或写入文件。
   • 示例：

   with open('file.txt', 'w') as f:  
       f.write('Hello, World!')
   

6. ord()

   • 功能：返回单个字符（Unicode码点）的整数值。
   • 示例：

   print(ord('A'))  # 输出：65
   

7. print()

   • 功能：将指定对象打印到标准输出（通常是屏幕）。
   • 示例：

   print("Hello, World!")
   

8. range()

   • 功能：返回一个不可变的序列类型，通常用于在循环中生成一个数字序列。
   • 示例：

   for i in range(5):  
       print(i)  # 输出：0 1 2 3 4
   

9. round()

   • 功能：将浮点数四舍五入到指定的小数位数。
   • 示例：

   print(round(3.14159, 2))  # 输出：3.14
   

10. str()

    • 功能：将对象转换为字符串形式。
    • 示例：

    print(str(123))  # 输出：'123'
    

11. sum()

    • 功能：返回可迭代对象（如列表、元组或集合）中所有项的总和。
    • 示例：

    print(sum([1, 2, 3, 4]))  # 输出：10
    

12. type()

    • 功能：返回对象的类型。
    • 示例：

    print(type(123))  # 输出：<class 'int'>
    

13. zip()

    • 功能：将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。
    • 示例：

    a = [1, 2, 3]  
    b = ['a', 'b', 'c']  
    zipped = zip(a, b)  
    print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]
    

14.enumerate()

• 功能：将可迭代的对象（列表、元组、集合）组合为一个缩影序列，同时可以输出数据和下标，for循环
• 示例：

list1 = ['a', 'b', 'c']

for index, item in enumerate(list1):
    print(index, item)

第6集 综合小案例—斗牛扑克发牌流程开发

简介：斗牛扑克洗牌流程开发

• 斗牛扑克发牌流程开发

  • 定义好52张扑克牌（花色、大小）
  • 生成扑克牌
  • 洗牌（打乱顺序）
  • 发牌（玩家个数、玩家5张手牌）

  import random
  
  # 定义好牌的花色和大小
  ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
  suits = ['♥', '♦', '♠', '♣']
  
  
  # 生成扑克牌
  def create_poker_list():
      return [f"{suit}{rank}" for rank in ranks for suit in suits]
  
  
  # 洗牌
  def shuffle_poker(poker_list):
      random.shuffle(poker_list)
      return poker_list
  
  
  # 发牌  玩家个数 扑克的牌数 玩家手牌数
  def deal_poker(new_poker_list, player_num, player_hand_num):
      # 所有玩家手牌列表
      hand_list = []
      for i in range(player_num):
          # 给玩家发5张牌
          players_poker = new_poker_list[:player_hand_num]
          # 剩余的扑克牌
          new_poker_list = new_poker_list[player_hand_num:]
          # 每次玩家5张手牌插入到列表中
          hand_list.append(players_poker)
  
      return hand_list
  
  
  # 斗牛扑克游戏发牌函数
  def douniu_game(player_num, player_hand_num):
      poker_list = create_poker_list()
      new_poker_list = shuffle_poker(poker_list)
      all_player_hand_poker = deal_poker(new_poker_list, player_num, player_hand_num)
      return all_player_hand_poker
  
  
  print(douniu_game(2, 5))
  
  for player, player_hand_poker in enumerate(douniu_game(2, 5)):
      print(f"{player}: {player_hand_poker}")
  
  

第7集 综合小案例—斗牛扑克发牌流程开发

简介：斗牛扑克洗牌流程开发

• 斗牛扑克发牌流程开发

  • 定义好52张扑克牌（花色、大小）
  • 生成扑克牌
  • 洗牌（打乱顺序）
  • 发牌（玩家个数、玩家5张手牌）

  import random
  
  # 定义好牌的花色和大小
  ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
  suits = ['♥', '♦', '♠', '♣']
  
  
  # 生成扑克牌
  def create_poker_list():
      return [f"{suit}{rank}" for rank in ranks for suit in suits]
  
  
  # 洗牌
  def shuffle_poker(poker_list):
      random.shuffle(poker_list)
      return poker_list
  
  
  # 发牌  玩家个数 扑克的牌数 玩家手牌数
  def deal_poker(new_poker_list, player_num, player_hand_num):
      # 所有玩家手牌列表
      hand_list = []
      for i in range(player_num):
          # 给玩家发5张牌
          players_poker = new_poker_list[:player_hand_num]
          # 剩余的扑克牌
          new_poker_list = new_poker_list[player_hand_num:]
          # 每次玩家5张手牌插入到列表中
          hand_list.append(players_poker)
  
      return hand_list
  
  
  # 斗牛扑克游戏发牌函数
  def douniu_game(player_num, player_hand_num):
      poker_list = create_poker_list()
      new_poker_list = shuffle_poker(poker_list)
      all_player_hand_poker = deal_poker(new_poker_list, player_num, player_hand_num)
      return all_player_hand_poker
  
  
  print(douniu_game(2, 5))
  
  for player, player_hand_poker in enumerate(douniu_game(2, 5)):
      print(f"{player}: {player_hand_poker}")
  
  

第七章 Python进阶—标准库模块和包

第1集 Python标准库模块—定义

简介：定义和使用

• Python标准库模块

  • Python标准库是Python内置的一些模块，可以直接导入和使用

  • 提供了许多基本的功能和工具，如数学运算、文件操作、日期时间处理等

• 自定义模块

  • 将一些相关的函数和变量组织到一个Python文件中，然后在其他Python脚本中导入和使用

• 第三方模块

  • 通常是由Python社区开发的，提供了各种扩展功能和工具
  • 例如：
    • requests模块发送HTTP请求
    • numpy模块进行科学计算
    • pandas模块进行数据分析

第2集 Python标准库模块—常用的模块

简介：常用的模块

• 常用模块

  • sys模块

    • 提供了一系列与Python解释器交互的函数和变量，用于操控Python的运行时环境。

      - 获取命令行参数：
      	import sys; print(sys.argv)
      - 退出程序：
      	import sys; sys.exit("程序已退出")
      

  • os模块

    • 提供了与操作系统交互的功能，如文件和目录管理。

      - 获取当前工作目录：
      	import os; 
      	print(os.getcwd())
      	
      - 列出当前目录下的文件和子目录：
      	import os; 
      	print(os.listdir('.'))
      	
      - 更改当前工作目录：
      	import os; 
      	os.chdir('/path/to/directory')
      

  • random模块

    • 用于生成随机数。

      - 生成一个0到1之间的随机浮点数：
      	import random; 
      	print(random.random())
      	
      - 生成一个指定范围内的随机整数：
      	import random; 
      	print(random.randint(1, 10))
      

  • datetime模块

    • 提供了日期和时间操作类。

      - 获取当前日期和时间：
      	from datetime import datetime;
        now = datetime.now(); 
        print(now)
        
      - 格式化日期和时间：
      	from datetime import datetime; 
      	dt = datetime(2024, 6, 16, 23, 33, 23);
        print(dt.strftime("%Y-%m-%d %H:%M:%S"))
      

  • json模块

    • 提供了解析JSON数据的方法。

      - 将Python对象转换为JSON字符串：
      	import json; 
      	data = {'name': 'John', 'age': 30}; 
      	json_data = json.dumps(data); 
      	print(json_data)
      - 将JSON字符串转换为Python对象：
        import json; 
        json_data = '{"name": "John", "age": 30}';
        parsed_data = json.loads(json_data); print(parsed_data['name'])
      

  • math模块

    • 提供了数学相关的函数和常量。

      - 计算平方根：
      	import math; 
      	print(math.sqrt(16))
      - 获取圆周率π的值：
      	import math; print(math.pi)
      

  • re模块

    • 提供了正则表达式操作功能。

      - 查找字符串中的数字：
      	import re; 
      	pattern = r'\d+'; 
      	match = re.search(pattern, 'abc123def456'); 
      	print(match.group())
      

第3集 Python模块—自定义模块

简介：自定义模块

• 自定义模块

  # 定义模块 math_utils.py
  
  # 定义一个函数来计算两个数的和
  def add_numbers(a, b):
      return a + b
  
  
  # 定义一个函数来计算两个数的差
  def subtract_numbers(a, b):
      return a - b
  
  
  # 定义一个函数来计算一个数的平方
  def square_number(n):
      return n ** 2
  

• 使用自定义模块

  import math_utils
  
  # 使用模块中的函数  
  print(math_utils.add_numbers(4, 6))
  print(math_utils.square_number(7))
  

  • 更简洁地使用模块中的函数，可以使用from…import…语句

  from math_utils import add_numbers, square_number
  
  print(add_numbers(10, 20))
  print(square_number(10))
  

第4集 Python模块—自定义模块不同目录应用

简介：自定义模块不同目录应用

• 同一目录下

  import math_utils
  

• 不同目录

  from tools import math_utils
  from tools.math_tools import math_utils
  

第5集 Python模块—第三方模块requests使用

简介：第三方模块requests使用

• requests

  • 定义

    • HTTP客户端库，用于发送HTTP请求

  • 安装

    pip install requests
    

  • 使用

    import requests  
      
    response = requests.get('https://api-v2.xdclass.net/api/card/v1/list')  
      
    # 检查请求是否成功  
    if response.status_code == 200:  
        # 打印返回的内容  
        print(response.text)  
    else:  
        print(f"请求失败，状态码: {response.status_code}")
    

第6集 Python模块—第三方模块numpy使用

简介：第三方模块numpy使用

• numpy

  • 定义

    • 用于数值计算的库，它提供了高性能的多维数组对象，以及用于处理这些数组的工具

  • 安装

    pip install numpy
    

  • 使用

    import numpy as np
    

• 分析学生成绩的需求

  • 计算三名学生的语文和数学成绩平均分

    # 学生成绩数据，每行代表一个学生，每列分别代表数学和英语成绩  
    scores = np.array([  
        [85, 90],  # 学生1的成绩  
        [78, 82],  # 学生2的成绩  
        [92, 88],  # 学生3的成绩  
    ])
    
    # 计算所有学生的数学和英语平均分
    math_avg = np.mean(scores[:, 0])  # 沿着第一列（数学成绩）计算平均值
    english_avg = np.mean(scores[:, 1])  # 沿着第二列（英语成绩）计算平均值
    print(f"数学平均分：{math_avg}, 英语平均分：{english_avg}")
    

  • 计算三名学生每位的语文和数学成绩总分

    # 计算每个学生的总分
    total_scores = np.sum(scores, axis=1)  # axis=1表示沿着行的方向求和
    print(f"每个学生的总分：{total_scores}")
    

第7集 Python包—包的理解和创建

简介：包的理解和创建

• 包

  • 是一种保存Python模块的文件夹结构（目录），里面需要创建__init__.py的文件，可为空

  • 将相关的模块组织在一起，形成一个逻辑上的单元

  • 不同包可以有相同的模块名

    

第八章 Python项目实战—仿淘宝下单的用户数据分析

第1集 Python常用的数据分析库和选择

简介： Python常用的数据分析库和选择

• NumPy
  

  • 官网
    • https://numpy.org/
  • 定义
    • NumPy是Python中用于科学计算的库，提供了高性能的多维数组对象和工具
    • 它提供了高性能的多维数组对象以及这些数组的操作工具
    • NumPy数组比Python自带的列表更加高效，它们在进行大规模数据操作时速度更快，占用内存更少
    • 此外，NumPy还提供了广泛的数学函数库，支持线性代数、傅里叶变换和随机数生成等操作
    • 它是大量机器学习框架的基础库，为Python带来了真正的多维数组功能，并将常用的数学函数都进行数组化，使得这些数学函数能够直接对数组进行操作

• Pandas

  

  • 官网
    • https://pandas.pydata.org/
  • 定义
    • 开源的Python数据分析库
    • 它提供了快速、灵活且富有表现力的数据结构，使“关系”或“标记”数据的工作既简单又直观
    • Pandas的核心数据结构是Series（一维数组）和DataFrame（二维表格型数据结构），它们可以包含多种类型的数据，包括整数、字符串、浮点数、Python对象等
    • Pandas还提供了丰富的数据清洗、转换、合并、重塑、数据聚合以及数据可视化等功能

• SciPy
  

  • 官网
    • https://scipy.org/
  • 定义
    • 是一个基于NumPy的开源Python库，用于数学、科学和工程计算
    • 它提供了许多用户友好和高效的数值实践，如数值积分、优化算法、信号处理、图像处理、常微分方程求解
    • SciPy是专为科学和工程设计的，封装了一些高阶抽象和物理模型，扩展了NumPy的功能

• Pyspark

• 官网

  • https://spark.apache.org/docs/latest/api/python/index.html#

• 定义

  • 底层基于Java和Scala实现

  • PySpark是Apache Spark的Python API，允许Python开发者使用Spark进行大规模数据处理

  • Spark是一个基于内存计算的大数据并行计算框架，提高了在大数据环境下数据处理的实时性，同时保证了高容错性和高可伸缩性

  • PySpark提供了与Spark相同的API和功能，但允许使用Python语言进行编程

• 总结

  • Pandas和NumPy是数据分析的基础工具，Pandas更侧重于数据预处理和分析，而NumPy更侧重于数值计算和数组操作。
  • SciPy则提供了高级数学和统计分析功能
  • PySpark则专注于大数据处理，提供了分布式计算的能力，适用于处理大规模数据集

第2集 Python常用的数据可视化库和选择

简介： Python常用的数据可视化库和选择

• Matplotlib

  

  • 官网
    • https://matplotlib.org/
  • 功能特点
    • Matplotlib是Python中最流行的数据可视化库之一，提供了丰富的绘图功能和高度可定制化的选项。
    • 支持绘制各种静态、动态、交互式的图表，包括折线图、散点图、柱状图、饼图等。
    • 通常与NumPy和SciPy等科学计算库一起使用，适用于数据分析和科学计算领域的可视化。
  • 优缺点
    • 优点
      • 强大的绘图功能和灵活性。
      • 高度可定制化的图形设置，可以自定义颜色、线型、标签等。
      • 丰富的图形美化和注释功能，如坐标轴设置、图表标题等。
    • 缺点
      • 对于初学者来说，API和配置选项可能较为复杂。
      • 主要侧重于静态图表，交互性相对较弱。

• Pyecharts

  

  • 官网
    • https://pyecharts.org/#/
  • 功能特点
    • pyecharts是一个基于Python的开源数据可视化库，用于创建各种交互式的图表和可视化效果。
    • 它是基于Echarts的Python封装，继承了Echarts的丰富功能和优雅外观。
    • 提供了简洁的API设计和高度灵活的配置项，支持链式调用，易于上手和使用。
  • 优缺点
    • 优点
      • 易于使用，提供了用户友好且易于理解的Python API。
      • 丰富的图表类型，包括折线图、柱状图、散点图、饼图、雷达图、地图等。
      • 强大的交互性，支持各种插件、视觉效果、事件、可视化组件等操作。
      • 详细的文档和示例，帮助开发者快速上手项目。
    • 缺点
      • 相对于Matplotlib，可能在某些特定领域的绘图功能上稍显不足
      • 主要生成的是HTML格式的交互式图表，不适用于所有场景

• 总结

  • 如果需要绘制高度定制化的静态图表，并且注重细节控制和功能完整性，选Matplotlib

  • 如果需要快速创建交互式的图表，并且希望图表具有丰富的视觉效果和易于使用的API，选pyecharts

第3集 仿淘宝下单的用户数据分析—需求分析

简介：需求分析

• 需求

  • 将2024年用户每月的购买金额统计绘制成图表展示，方便直观查看每月的销售额对比情况

  • 全年的总销售额和用户平均下单金额

• 分析

  • 用户每个月下单的金额需要统计求和
    • 每个用户购买金额（个数*商品价格）之和
  • 2024年每月份作为x轴，每月购买金额为Y轴
  • 时间顺序是乱的，需要排序
  • 价格有脏数据，需要清洗

• 数据处理使用pandas+numpy库

• 数据可视化使用Matplotlib库

第4集 仿淘宝下单的用户数据分析—准备数据

简介：准备数据

• 需要有大量的用户下单的数据

  • 用户id
  • 商品id
  • 购买个数
  • 购买时间
  • 商品价格

• 通过pandas+numpy实现模拟数据

  import pandas as pd
  import numpy as np
  from datetime import datetime, timedelta
  
  # 生成随机用户ID
  user_ids = np.random.randint(1000, 10000, size=100)
  # 生成随机商品ID
  product_ids = np.random.randint(100, 1000, size=100)
  # 生成购买数量
  buy_num = np.random.randint(1, 10, size=100)
  # 生成随机购买时间
  start_date = datetime(2024, 1, 1)
  end_date = datetime(2024, 12, 31)
  buy_dates = pd.date_range(start=start_date, end=end_date, periods=100).tolist()
  
  
  np.random.shuffle(buy_dates)  # 打乱日期顺序
  # 生成随机商品价格 去除小数点astype(int)
  product_prices = np.random.uniform(50, 200, size=100).astype(int)  # 假设商品价格在50到200之间
  
  # 创建DataFrame
  data = {
      'user_id': user_ids,
      'product_id': product_ids,
      'buy_num': buy_num,
      'buy_date': buy_dates,
      'product_price': product_prices
  }
  df = pd.DataFrame(data)
  

第5集 仿淘宝下单的用户数据分析—插入一些脏数据

简介：插入一些脏数据

• 插入一些脏数据

  # 从 df 中随机选择 5% 的行，并将这些行的 'buy_price' 列的值更改为一个在 -5 到 0（不包括 0）之间的随机整数
  bad_data = np.random.randint(-5, 0, size=int(0.05 * len(df)))
  
  
  取出列为product_price的数，为总数的5%，修改为脏数据
  df.loc[df.sample(frac=0.05).index, 'product_price'] = bad_data
  

第6集 仿淘宝下单的用户数据分析—清洗+处理数据

简介：清理+处理数据

• 清理+处理数据

  # 移除商品价格为负数的情况
  df_cleaned = df[df['product_price'] > 0]
  
  # 计算总销售额和平均购买价格
  total_sales = (df_cleaned['buy_num'] * df_cleaned['product_price']).sum()
  average_price = df_cleaned['product_price'].mean()
  
  print(f"总销售额：{total_sales}")
  print(f"平均购买价格：{average_price:.2f}")
  

第7集 仿淘宝下单的用户数据分析—生成数据可视化图表上

简介：生成数据可视化图表上

• 生成数据可视化图表上

  
  # 数据可视化：绘制销售额随时间变化的折线图
  df_cleaned['buy_date'] = pd.to_datetime(df_cleaned['buy_date'])
  # 将buy_date列设置为DataFrame的索引
  df_cleaned.set_index('buy_date', inplace=True)
  
  # 计算每月销售额
  # df_cleaned.resample('ME') 采样为每月的最后一个日期
  # apply(lambda x: (x['buy_num'] * x['product_price'].sum()) 计算每个月的购买金额
  # reset_index()将数据索引重置为整数索引
  monthly_sales = df_cleaned.resample('ME').apply(lambda x: (x['buy_num'] * x['product_price']).sum()).reset_index()
  # 修改第三列月销售额的名称
  monthly_sales = monthly_sales.rename(columns={0: 'total_sales'})
  
  

第8集 仿淘宝下单的用户数据分析—生成数据可视化图表下

简介：生成数据可视化图表下

• 生成数据可视化图表下

  # 将时间转成每个月的第一天
  monthly_sales['buy_date'] = monthly_sales['buy_date'].dt.to_period('M').dt.start_time
  # 绘制折线图
  monthly_sales.set_index('buy_date', inplace=True)
  # 直接绘制DataFrame中的数据，kind='line'绘制的图形类型，figsize=(12, 6)宽度是12英寸，高度是6英寸
  monthly_sales.plot(kind='line', figsize=(12, 6), title='month')
  
  # 设置x和y轴的意义
  plt.xlabel('date')
  plt.ylabel('sales volume')
  
  # 保存成图片
  plt.savefig('sine_curve.png')
  
  # 运行成图表
  plt.show()