Python 第2阶段编程笔记

已于 2023-11-24 17:02:32 修改
阅读量111 收藏
点赞数 1
分类专栏： Python 文章标签： python
于 2023-11-24 16:42:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52492309/article/details/134602095
版权

python 第2阶段

第一章 面向对象

初始对象

使用对象组织数据

  • 在程序中设计表格，我们称之为：设计类（class）

    • class Student:
    name = None	# 记录学生姓名

  • 在程序中打印生产表格，我们称之为：创建对象

    • # 基于类创建对象
stu_1 = Student()
stu_2 = Student()

  • 在程序中填写表格，我们称之为：对象属性赋值

    • stu_1.name = "Lee"	# 为学生1对象赋予名称属性值
stu_2.name = "Wang"	# 为学生2对象赋予名称属性值

# 设计一个类
class Student:
    name = None         # 记录学生姓名
    gender = None       # 记录学生性别
    nationality = None  # 记录学生国籍
    native_place = None # 记录学生籍贯
    age = None          # 记录学生年龄
# 创建一个对象
stu_1 = Student()
# 对象属性进行赋值
stu_1.name = "Lee"
stu_1.gender = "男"
stu_1.nationality = "china"
stu_1.native_place = "山东省"
stu_1.age = 18
# 获取对象中记录的信息
print(stu_1.name)
print(stu_1.gender)
print(stu_1.nationality)
print(stu_1.native_place)
print(stu_1.age)

成员方法

类的定义和使用

class 类名称:
    类的属性
    类的行为
  • class是关键字，表示要定义类了
  • 类的属性，即定义在类中的变量（成员变量）
  • 类的行为，即定义在类中的函数（成员方法）
  • 创建类对象的语法：对象 = 类名称()
  • **注意：**函数是写在类外的，定义在类内部，我们都称之为方法

成员方法的定义语法

在类中定义成员方法和定义函数基本一致，但仍有细微区别：

class 类名称:
 成员变量
 
	def 方法名(self,形参1,......,形参N):
		方法体
对象 = 类名称()

在方法定义的参数列表中，有一个：self关键字。

self关键字是成员方法定义的时候，必须填写的。

  • 它用来表示类对象自身的意思
  • 当我们使用类对象调用方法的时候，self会自动被python传入，self出现在形参列表中，但是不占用参数位置，无需理会
  • 在方法内部，想要访问类的成员变量，必须使用self

注意事项

self关键字，尽管在参数列表中，但传参的时候可以忽略它。

# 成员方法定义和使用
# 定义一个带有成员方法的类
class student:
    name = None
    def say_hi(self):
        print(f"大家好！我是{self.name}") # 在方法内部，想要访问类的成员变量，必须使用self
    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")

stu_1 = student()
stu_1.name = "Lee"
stu_1.say_hi()

stu_2 = student()
stu_2.name = "Ling"
stu_2.say_hi2("很荣幸见到大家！")

类和对象

基于类创建对象的语法：对象名 = 类名称()

类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作，这种套路，称之为：面向对象编程

# 类和对象的关系，即面向对象的编程套路（思想）
# 设计一个闹钟类
class Clock:
    id = None       # 序列号
    price = None    # 价格
    def ring(self):
        import winsound # 使电脑响铃的模块
        winsound.Beep(2000,3000)
# 构建2个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "01235"
clock1.price = 19.99
print(f"闹钟id是：{clock1.id},价格是：{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "23546"
clock2.price = 29.99
print(f"闹钟id是：{clock2.id},价格是：{clock2.price}")
clock2.ring()

总结

  • 现实世界的事物由属性和行为组成
    • 类也可以包含属性和行为，所以使用描述现实世界事物是非常合适的
  • 类和对象的关系
    • 类是程序中的“设计图纸”
    • 对象是基于图纸生产的具体实体
  • 面向对象编程就是使用对象进行编程
    • 即设计类，基于类创建对象，并使用对象完成具体的工作

构造方法

属性（成员变量）的赋值

构造方法

可以使用：__init__()方法，称之为构造方法

可以实现：

  • 在创建类对象（构造类）的时候，会自动执行

  • 在创建类对象（构造类）的时候，将传入参数自动传递给__init__()方法使用

  • # 类的构造方法
class Student:
    name = None # 可以省略
    age = None  # 可以省略
    tel = None  # 可以省略
    # 使用构造方法对成员变量进行赋值
    # 构造方法的使用名称__init__
    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个对象")
stu = Student("Lee",18,"135555666")
print(stu.name)
print(stu.age)
print(stu.tel)

构造方法注意事项

  • 构造方法名称：__init__，前后都有2个下划线

  • 构造方法也是成员方法，需要在参数列表中提供：self

  • 在构造方法内定义成员变量，需要使用self关键字

    • def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel

    • PS：变量是定义在构造方法内部，如果要成为成员变量，需要用self来表示

**练习案例：**学生信息录入

# 学生信息录入
# 设计一个类，记录学生的：姓名、年龄、地址，这三类信息
# 实现：
# 通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘输入
# 输入完成后，使用print语句，完成信息的输出
class Student:
    def __init__(self,name,age,address):
        self.name = name
        self.age = age
        self.address = address
for i in range(10):
    print(f"请输入{i+1}位学生信息，总共需录入10位学生信息")
    name = input("请输入学生姓名：")
    age = int(input("请输入学生年龄："))
    address = input("请输入学生地址：")
    stu = Student(name,age,address)
    print(f"学生{i+1}信息录入完成，信息为【学生姓名：{stu.name},年龄：{stu.age},地址：{stu.address}】")

其他内置方法

魔术方法

  • __init__：构造方法

  • __str__：字符串方法

    • class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
stu = Student("Lee",18)
print(stu)
print(str(stu))
# 当类对象需要被转换成字符串时，会输出内存地址

    • 可以通过__str__方法，控制类转换为字符串的行为

    • 方法名：__str__

    • 返回值：字符串

    • 内容：自行定义

  • __lt__：小于、大于符号比较

    • 直接对2个对象进行比较是不可以的，但是在类中实现__lt__方法，即可同时完成：小于符合和大于符号2中比较
    • 方法名：__lt__
    • 传入参数：other，另一个类对象
    • 返回值：True或False
    • 内容：自行定义

  • __le__：小于等于、大于等于符号比较

    • 方法名：__le__
    • 传入参数：other，另一个类对象
    • 返回值：True或False
    • 内容：自行定义

  • __eq__：==符号比较

    • 方法名：__eq__
    • 传入参数：other，另一个类对象
    • 返回值：True或False
    • 内容：自行定义
    • 不实现__eq__方法，对象之间可以比较，但是比较内存地址，即是：不同对象==比较一定是False结果
    • 实现了__eq__方法，就可以按照自己要求比较两个对象是否相等
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # __str__魔术方法
    def __str__(self):
        return f"Student类对象，name={self.name}，age={self.age}"
    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age
    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age
    # __eq__魔术方法
    def __eq__(self, other):
        return self.age == other.age
# stu = Student("Lee",18)
# print(stu)
# print(str(stu))

stu1 = Student("Lee",25)
stu2 = Student("wang",25)
print(stu1 > stu2)
print(stu1 <= stu2)
print(stu1 == stu2)

封装

面向对象的三大特性

面向对象编程，是许多编程语言都支持的一种编程思想

简单理解就是：基于模板（类）去创建实体（对象），使用对象完成功能开发

面向对象包含3大主要特性：封装、继承、多态

封装

封装表示的是：将现实世界事物的：属性、行为

封装到类中，描述为：成员变量、成员方法

从而完成程序对现实世界事物的描述

私有成员：

  • 类中提供了私有成员的形式来支持
    • 私有成员变量
    • 私有成员方法
  • 定义私有成员的方式
    • 私有成员变量：变量名以__开头（2个下划线）
    • 私有成员方法：方法名以__开头（2个下划线）
  • 私有成员的使用
    • 私有方法无法直接被类对象使用
    • 私有变量无法赋值，也无法获取值
    • 类中的其它成员可以访问私有成员
# 封装，私有成员使用
# 定义一个类，内含私有成员变量和私有成员方法
class Phone:
    __current_voltage = 1    # 当前手机运行电压
    def __keep_single_core(self):
        print("让CPU以单核模式运行")
    def call_by_5G(self):
        if self.__current_voltage >= 1:
            print("5G通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用5G，并设置为单核模式")
phone = Phone()
# phone.__keep_single_core()
# print(phone.__current_voltage)
phone.call_by_5G()

**私有成员的实际意义：**在类中提供仅供内部使用的属性和方法，而不对外开放（类对象无法使用）

**练习案例：**设计带有私有成员的手机

# 练习：
# 设计一个手机类，内容包括：
class phone:
    # 私有成员变量：__is_5g_enable,类型bool，True表示开启5G，False表示关闭5G
    __is_5g_enable = True
    # 私有成员方法：__check_5g(),会判断私有成员__is_5g_enable的值
    def __check_5g(self):
        # 若为True，打印输出：5g开启
        if self.__is_5g_enable:
            print("5g开启")
        # 若为False，打印输出：5g关闭，使用4g网络
        else:
            print("5g关闭，使用4g网络")
    # 公开成员方法：call_by_5g()，调用它会执行
    def call_by_5g(self):
        # 调用私有成员方法：__check_5g()，判断5g网络状态
        self.__check_5g()
        # 打印输出：正在通话
        print("正在通话")
ph = phone()
ph.call_by_5g()

继承

继承就是一个类，继承另外一个类的成员变量和成员方法

子类构建的类对象，可以

  • 有自己的成员变量和成员方法
  • 使用父类的成员变量和成员方法
继承的基础语法

继承分为：单继承和多继承

继承表示：将从父类那里继承（复制）来成员变量和成员方法（不含私有）

**单继承：**一个类继承另一个类

class 类名(父类名):
 类内容体

**多继承：**一个类继承多个类，按照顺序从左向右依次继承

class 类名(父类1,父类2,......,父类N):
 类内容体

**多继承注意事项：**多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。即：先继承的保留，后继承的被覆盖

# 面向对象：继承的基础语法
# 单继承
class Phone:
    IMEI = None         # 序列号
    producer = "ITCAST"     # 厂商
    def call_by_4g(self):
        print("4g通话")
class Phone2022(Phone):
    face_id = "10001"    # 面部识别ID
    def call_by_5g(self):
        print("2022年新功能：5g通话")
phone = Phone2022()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()
print()
# 多继承
class NFCReader:
    nfc_type = "第五代"
    producer = "HM"
    def read_card(self):
        print("NFC读卡")
    def write_card(self):
        print("NFC写卡")
class RemoteControl:
    rc_type = "红外遥控"
    def control(self):
        print("红外遥控开启")
class Myphone(Phone,NFCReader,RemoteControl):
    pass        # pass的作用是保证代码不报错
phone = Myphone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()
# 多继承下，父类成员名一致的场景
print(phone.producer)  # 先继承的优先级会高于后继承的。（先继承的保留，后继承的覆盖）

**PASS关键字的作用：**pass是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容，空的意思

复写和使用父类成员

**复写：**子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。即：在子类中重新定义同名的属性或方法即可。

调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

如果需要使用被复写的父类成员，需要用特殊的调用方式：

  • 方式1：调用父类成员
    • 使用成员变量：父类名.成员变量
    • 使用成员方法：父类名.成员方法(self)
  • 方式2：使用super()调用父类成员
    • 使用成员变量：super().成员变量
    • 使用成员方法：super().成员方法()
  • PS：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的
# 复写和使用父类成员
class Phone:
    IMEI = None
    producer = "ITCAST"
    def cal_by_5g(self):
        print("使用5g网络进行通话")
# 定义子类，复写父类成员
class MyPhone(Phone):
    producer = "HM"     # 复写父类的成员属性
    def cal_by_5g(self):
        print("开启单核模式，确保省电")
        
        # 方式1
        # print(f"父类的厂商是：{Phone.producer}")
        # Phone.cal_by_5g(self)   # 调用父类成员函数时，需要加self
        
        # 方式2
        print(f"父类的厂商是：{super().producer}")
        super().cal_by_5g()
        
        print("关闭单核模式")
phone = MyPhone()
phone.cal_by_5g()
print(phone.producer)

类型注解

变量的类型注解

类型注解

类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显示的说明）

主要功能：

  • 帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
  • 帮助开发者自身对变量进行类型注释（备注）

支持：

  • 变量的类型注解
  • 函数（方法）形参列表和返回值的类型注解

类型注解的语法

为变量设置类型注解

语法1：变量:类型

除了使用变量:类型，这种语法做注解外，也可以在注释中进行类型注解。语法2：# type:类型

# 变量的类型注解
import json
import random
# 基础数据类型注解
var_1:int = 10
var_2:float = 3.1415926
var_3:bool = True
var_4:str = "HM"

# 类对象类型注解
class Student:
 pass
stu:Student = Student()

# 基础容器类型注解
my_list:list = [1,2,3]
my_tuple:tuple = (1,2,3)
my_set:set = {1,2,3}
my_dict:dict = {"ID":666}
my_str:str = "hello"

# 容器类型详细注解
my_list1:list[int] = [1,2,3]
my_tuple1:tuple[str,int,bool] = ("hello",2,True)
my_set1:set[int] = {1,2,3}
my_dict1:dict[str:int] = {"ID":666}

# 在注释中进行类型注解
class Student:
 pass
var_11 = random.randint(1,10)   # type:int
# 通过json.loads将字符串转为字典类型
var_22 = json.loads('{"name":"Lee"}')   # type:dict[str,str]
def func():
 return 10
var_33 = func() # type:int

# 类型注解的限制
# 会提示，但是运行不会报错
var_44:int = "hm"
var_5:str = 22

注意：

  • 元组类型设置类型详细注解，需要将每一个元素都标记出来
  • 字典类型设置类型详细注解，需要2个类型，第一个是key第二个是value
  • 为变量设置注解，显示的变量定义，一般无需注解；无法直接看出变量类型时，需要添加变量的类型注解

类型注解的限制

并不会真正的对类型做验证和判断。即，类型注解仅仅是提示性的，不是决定性的。

函数（方法）的类型注解

形参注解

# 形参类型注解语法：
def 函数方法名(形参名:类型,形参名:类型，...):
 pass

返回值注解

# 返回值注解语法：
def 函数方法名(形参:类型,......,形参:类型)->返回值类型:
 pass

# 对函数（方法）进行类型注解
# 对形参进行类型注解
def add(x:int,y:int):
    return x+y
add()

# 对返回值进行类型注解
def func(data:list)->list:
    return data
Union类型

使用Union[类型,…,类型]，可以定义联合类型注解

Union联合类型注解，在变量注解、函数（方法）形参和返回值注解中，均可使用。

# Union联合类型注解
# 使用Union类型，必须先导包
from typing import Union
my_list:list[Union[int,str]] = [1,2,"itcast","hm"]
def func(data:Union[int,str])->Union[int,str]:
    pass
func()

多态

**多态：**指的是多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。同样的行为（函数），传入不同的对象，得到不同的状态

多态常作用在继承关系上，比如：

  • 函数（方法）形参声明接收父类对象
  • 实际传入父类的子类对象进行工作

即：

  • 以父类做定义声明
  • 以子类做实际工作
  • 用以获得同一行为，不同状态

抽象类（接口）

父类中Animal的speak方法是空实现，这种设计的含义是：

  • 父类用来确定有哪些方法
  • 具体的方法实现，由子类自行决定

这种写法，就叫抽象类（也可以称之为接口）

抽象类：含有抽象方法的类称之为抽象类

抽象方法：方法体是空实现的（pass）称之为抽象方法

配合多态，完成

  • 抽象的父类设计（设计标准）
  • 具体的子类实现（实现标准）
# 多态特效以及抽象类（接口）的使用
class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("汪汪汪")
class Cat(Animal):
    def speak(self):
        print("喵喵喵")
def make_noise(animal:Animal):
    animal.speak()

# 演示多态，使用2个子类对象来调用函数
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)

# 演示抽象类
class AC:
    def cool_wind(self):
        """制冷"""
        pass
    def hot_wind(self):
        """制热"""
        pass
    def swing_l_r(self):
        """左右摆风"""
        pass
class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")
    def hot_wind(self):
        print("美的空调制热")
    def swing_l_r(self):
        print("美的空调左右摆风")
class Gree_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")
    def hot_wind(self):
        print("格力空调制热")
    def swing_l_r(self):
        print("格力空调左右摆风")
def make_cool(ac:AC):
    ac.cool_wind()
midea_ac = Midea_AC()
gree_ac = Gree_AC()
make_cool(midea_ac)
make_cool(gree_ac)

总结：

  • 多态指的是，同一个行为，使用不同的对象获得不同的状态
  • 包含抽象方法的类，称为抽象类。抽象方法是指：没有具体实现的方法（pass）称之为抽象方法
  • 抽象类的作用
    • 多用于做顶层设计（设计标准），以便子类做具体实现
    • 也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法
    • 并配合多态使用，获得不同的工作状态

综合案例

主文件

# 数据分析案例
# 某公司，有两份数据文件，现需对其进行分析处理，计算每日的销售额并以柱状图的形式进行展示。
# 1月份数据是普通文本，使用逗号分割数据记录，从前到后分别是：日期、订单id、销售额、销售省份
# 2月份数据是json数据，同样包含：日期、订单id、销售额、销售省份
# 需求分析：读取数据——封装数据对象——计算数据对象——pyecharts绘图
# 实现步骤
# 设计一个类，可以完成数据的封装
# 在date_define文件中
# 设计一个抽象类，定义文件读取的相关功能，并使用子类实现具体功能
# 读取文件，生产数据对象
# 进行数据需求的逻辑计算（计算每一天的销售额）
# 通过pyecharts进行图形绘制
from file_define import FileReader,JsonFileReader,TextFileReader
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import ThemeType

text_file_reader = TextFileReader("D:/python 代码/python 第2阶段/第一章 面向对象/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/python 代码/python 第2阶段/第一章 面向对象/2011年2月销售数据JSON.txt")
jan_data:list[Record] = text_file_reader.read_data()
feb_data:list[Record] = json_file_reader.read_data()
# 将2个月份的数据合并为1个list来存储
all_data:list[Record] = jan_data + feb_data
# 开始进行数据计算
data_dict = {}
for record in all_data:
    if record.date in data_dict.keys():
        # 当前日期已经有记录了，所以和老记录做累加即可
        data_dict[record.date] += record.money
    else:
        data_dict[record.date] = record.money
print(data_dict)

# 可视化图表开发
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))
bar.add_xaxis(list(data_dict.keys()))   # 添加x轴数据
bar.add_yaxis("销售额",list(data_dict.values()),label_opts=LabelOpts(is_show=False))   # 添加y轴数据
bar.set_global_opts(
    title_opts=TitleOpts(title="每日销售额")
)
bar.render("每日销售额柱状图.html")

文件相关的类定义

# 和文件相关的类定义
import json

from data_define import Record
# 先定义一个抽象类用来做顶层设计，确定有哪些功能需要实现
class FileReader:
    def read_data(self)->list[Record]:
        # 读取文件的数据，读到的每一条数据都转换为Record对象，将他们都封装到list内返回即可
        pass
class TextFileReader(FileReader):
    def __init__(self,path):
        self.path = path    # 定义成员变量，记录文件的路径
    # 复写（实现抽象方法）
    def read_data(self) ->list[Record]:
        f = open(self.path,"r",encoding="UTF-8")
        record_list:list[Record] = []
        for line in f.readlines():
            line = line.strip()     # 消除读取到的每一行数据中的换行符
            data_list = line.split(",")
            record = Record(data_list[0],data_list[1],int(data_list[2]),data_list[3])
            record_list.append(record)
        f.close()
        return record_list

class JsonFileReader(FileReader):
    def __init__(self,path):
        self.path = path    # 定义成员变量，记录文件的路径
    def read_data(self) ->list[Record]:
        f = open(self.path,"r",encoding="UTF-8")
        record_list:list[Record] = []
        for line in f.readlines():
            data_dict = json.loads(line)
            record = Record(data_dict["date"],data_dict["order_id"],int(data_dict["money"]),data_dict["province"])
            record_list.append(record)
        f.close()
        return record_list

if __name__ == '__main__':
    text_file_reader = TextFileReader("D:/python 代码/python 第2阶段/第一章 面向对象/2011年1月销售数据.txt")
    json_file_reader = JsonFileReader("D:/python 代码/python 第2阶段/第一章 面向对象/2011年2月销售数据JSON.txt")
    text_list = text_file_reader.read_data()
    json_list = json_file_reader.read_data()
    for l in text_list:
        print(l)
    for l in json_list:
        print(l)

数据定义的类

"""数据定义的类"""
class Record:
    def __init__(self,date,order_id,money,province):
        self.date = date            # 订单日期
        self.order_id = order_id    # 订单ID
        self.money = money          # 订单金额
        self.province = province    # 销售省份
    def __str__(self):
        return f"{self.date},{self.order_id},{self.money},{self.province}"

第二章 SQL入门和实战

无处不在的SQL

不管是何种开发语言，亦或是何种开发方向，SQL都是开发人员无法绕开的话题

除了一门趁手的编程语言外，SQL语言也是开发人员人人必备的开发技能

数据库介绍

**数据库：**数据库就是指数据存储的库，作用就是组织数据并存储数据

无处不在的数据库

信息化社会，无处不在的就是数据

数据：数据的存储（TXT、EXCEL、数据库） 和 数据的计算

**数据库管理系统（数据库软件）：**ORACLE、MySQL、SQLServer、PostgreSQL、SQLite

这些软件都能实现：管理库、管理表、基于表来管理数据

数据库和SQL的关系

数据库是用来存储数据的，会涉及到：

  • 数据的新增
  • 数据的删除
  • 数据的修改
  • 数据的查询
  • 数据库、数据表的管理

而SQL语言，就是一种对数据库、数据进行操作、管理、查询的工具。

数据库按照：库->表->数据 三个层级进行组织，数据库软件提供组织存储的能力。

并借助SQL语言，完成对数据的增删改查等操作，SQL语句则是操作数据、数据库的工具语言。

MySQL的安装

MySQL网址：www.mysql.com

下载地址：http://downloads.mysql.com/archives/installer

MySQL的入门使用

在命令提示符内使用MySQL

打开：命令提示符程序，输入：mysql -uroot -p，然后回车后输入密码：20000307，即可进入命令行环境

在MySQL的命令行环境下，可以通过：

  • show databases; ：查看有哪些数据库
  • use 数据库名; ：使用某个数据库
  • show tables; ：查看数据库内有哪些表
  • exit ：退出MySQL的命令行环境

等基础命令。

使用图形化工具操作MySQL

使用命令提示符进行MySQL的操作很不便，一般使用第三方的图形化工具进行使用

可用于MySQL的图形化工具非常多，此处使用：DBeaver

下载地址：http://dbeaver.io/download

SQL基础与DDL

SQL概述

SQL全称：Structured Query Language，结构化查询语言，用于访问和处理数据库的标准的计算机语言，即操作数据库，通用大多数数据库软件。

SQL语言的分类

数据库管理系统（数据库软件），不仅是存储数据，还有：数据的管理、表的管理、库的管理、账户管理、权限管理等。

操作数据库的SQL语言，也基于功能，可以划分为4类：

  • 数据定义：DDL（Data Definition Language）
    • 库的创建删除、表的创建删除等
  • 数据操纵：DML（Data Manipulation Language）
    • 新增数据、删除数据、修改数据等
  • 数据控制：DCL（Data Control Language）
    • 新增用户、删除用户、密码修改、权限管理等
  • 数据查询：DQL（Data Query Language）
    • 基于需求查询和计算数据

SQL语法特征

  • SQL语言，大小写不敏感
  • SQL可以单行或多行书写，最后以;号结束
  • SQL支持注释：
    • 单行注释：-- 注释内容（–后面一定要有一个空格）
    • 单行注释：# 注释内容（# 后面可以不加空格，推荐加上）
    • 多行注释：/* 注释内容 */

DDL - 库管理

-- 单行注释
# 单行注释
/*
多
行
注释
*/
# 查看数据库
show databases;

# 使用数据库
use 数据库名称;

# 创建数据库
create database 数据库名称 [charset UTF8];	# 中括号内容为选择性输入

# 删除数据库
drop database 数据库名称;

# 查看当前使用的数据库
select database();

DDL - 表管理

# 查看有哪些表
show tables;	# 注意：需要先选择数据库

# 创建表
create table 表名称(
	列名称 列类型,
 列名称 列类型,
 ......
);
-- 列类型有
/*
int					-- 整数
float				-- 浮点数
varchar(长度)		   -- 文本，长度为数字，做最大长度限制
date				-- 日期类型
timestamp			-- 时间戳类型
*/

# 删除表
drop table 表名称;
drop table if exists 表名称;

SQL - DML

DML

DML是指数据操作语言，用来对数据库中表的数据记录进行更新。

关键字：

  • 插入：insert
    • 基础语法：insert into 表[(列1,列2,...,列N)] values(值1,值2,...,值N)[,(值1,值2,...,值N),...,(值1,值2,...,值N)]; # 中括号里的内容可以忽略不写，但是内容一定要和建表顺序一致，value中也可以一次性添加多行数据
  • 删除：delete
    • 基础语法：delete from 表名称 [where 条件判断]; # 不带中括号，会删除全部数据
    • 条件判断：列 操作符 值
    • 操作符：= < > <= >= != 等等
  • 更新：update
    • 基础语法：update 表名称 set 列=值 [where 条件判断]; # 不带中括号的内容，会修改全部对应数据，中括号内表示可选择性带入

SQL - DQL

基础查询

基础数据查询

在SQL中，通过select关键字开头的SQL语句，来进行数据的查询

基础语法：select 字段列表|* from 表 # *表示的是查看所有列

含义就是：从 from 表中，选择 select 某些列进行展示

基础数据查询 - 过滤

查询也可以带有指定条件，语法：select 字段列表|* from 表 where 条件判断

分组聚合

分组聚合应用场景非常多，如：统计班级中，男生和女生的人数

这种需求就需要：

  • 按性别分组
  • 统计每个组的人数

这就称之为：分组聚合

基础语法：select 字段|聚合函数 from 表 [where 条件] group by 列;

聚合函数有：

- SUM(列) 求和

- AVG(列) 求平均值

- MIN(列) 求最小值

- MAX(列) 求最大值

- COUNT(列|*) 求数量

**注意事项：**group by 中出现了哪个列，哪个列才能出现在select中的非聚合中。

排序分页

结果排序

可以对查询的结果，使用 order by 关键字，指定某个列进行排序，语法：

select 列|聚合函数|* from 表
where ...
group by ...
order by ...[ASC|DESC]	# ASC表示升序排序，DESC表示降序排序

结果分页限制

可以使用 limit 关键字，对查询结果进行数量限制或分页显示，语法：

select 列|聚合函数|* from 表
where ...
group by ...
order by ...[ASC|DESC]
limit n[,m]		# 从n的下一位开始取m条数据，只写n表示从n的下一位开始取全部数据

注意：

  • where、group by、order by、limit 均可按需求省略
  • select 和 from 是必须写的
  • 执行顺序：from -> where -> group by 和聚合函数 -> select -> order by -> limit

Python & MySQL

基础使用

pymysql

除使用图形化工具以外，也可以使用编程语言来执行SQL从而操作数据库。

在python中，使用第三方库：pymysql来完成对MySQL数据库的操作。

安装：pip install pymysql

创建MySQL的数据库链接

代码如下：

from pymysql import Connection
# 构建到MySQL数据库的链接
conn = Connection(
 host="localhost",   	# 主机名（或IP地址）
 port=3306,         		# 端口，默认3306
 user="root",        	# 账户
 password="20000307"   	# 密码
)

# 打印MySQL数据库软件信息
print(coon.get_server_info())

# 关闭链接
conn.close()

# python pymysql库的基础操作
from pymysql import Connection
# 构建到MySQL数据库的链接
conn = Connection(
    host="localhost",   # 主机名（IP）
    port=3306,          # 端口
    user="root",        # 账户
    password="20000307"   # 密码
)
# print(coon.get_server_info())

# 执行非查询性质SQL
cursor = conn.cursor()      # 获取到游标对象
# 选择数据库
conn.select_db("world")
# 执行SQL
# cursor.execute("create table test_pymysql2(id int)")    # 在python中写不写;都可以
cursor.execute("select * from student")
results = cursor.fetchall()     # results为元组类型
for r in results:
    print(r)

# 关闭链接
conn.close()

总结

  • 如何获取链接对象
    • from pymysql import Connection 导包
    • Connection(主机,端口,账户,密码)即可得到链接对象
    • 链接对象.close() 关闭和MySQL数据库的连接
  • 如何执行SQL查询：通过链接对象调用cursor()方法，得到游标对象
    • 游标对象.execute()执行SQL语句
    • 游标对象.fetchall()得到全部的查询结果封装入元组内
数据插入

commit提交

在未加commit前，经过执行是无法将数据插入到数据表student中的，原因是：pymysql在执行数据插入或其他产生数据更改的SQL语句时，默认是需要提交更改的，即需要通过代码”确认“这种更改行为，即需要通过链接对象的commit成员方法来进行确认的。

通过：链接对象.commit()即可确认此行为

只有确认的修改，才能生效。

自动commit

如果不想手动commit确认，可以在构建链接对象的时候，设置自动commit的属性。

conn = Connection(
 host="localhost",   # 主机名（IP）
 port=3306,          # 端口
 user="root",        # 账户
 password="20000307",   # 密码
 autocommit= True     # 设置自动提交		# 在此处添加后，即可自动提交
)

# 使用pymysql库进行数据插入的操作
from pymysql import Connection
# 构建到MySQL数据库的链接
conn = Connection(
    host="localhost",   # 主机名（IP）
    port=3306,          # 端口
    user="root",        # 账户
    password="20000307",   # 密码
    autocommit= True     # 设置自动提交
)
# print(coon.get_server_info())

# 执行非查询性质SQL
cursor = conn.cursor()      # 获取到游标对象
# 选择数据库
conn.select_db("world")
# 执行SQL
cursor.execute("insert into student values(10001,'周杰伦',31)")    # 在python中写不写;都可以

# # 通过commit确认
# conn.commit()

# 关闭链接
conn.close()

综合案例

DDL定义

需要新建一个数据库来使用，数据库名称：py_sql

基于数据结构，可以得到建表语：

# 创建库
create database py_sql charset utf8;
# 使用库
use py_sql;
# 创建表
create table orders(
	order_date date,
	order_id varchar(255),
	money int,
	province varchar(10)
)
# 显示表
show tables;

实现步骤：读取数据——封装数据对象——构建数据库链接——写入数据库

# 案例需求
# 某公司，有两份数据文件，完成使用python语言，读取数据，并将数据写入MySQL的功能
# 1月份数据是普通文本，使用逗号分割数据记录，从前到后分别是：日期、订单id、销售额、销售省份
# 2月份数据是json数据，同样包含：日期、订单id、销售额、销售省份
import json
"""数据定义的类"""
class Record:
    def __init__(self,date,order_id,money,province):
        self.date = date            # 订单日期
        self.order_id = order_id    # 订单ID
        self.money = money          # 订单金额
        self.province = province    # 销售省份
    def __str__(self):
        return f"{self.date},{self.order_id},{self.money},{self.province}"

# 和文件相关的类定义
# 先定义一个抽象类用来做顶层设计，确定有哪些功能需要实现
class FileReader:
    def read_data(self)->list[Record]:
        # 读取文件的数据，读到的每一条数据都转换为Record对象，将他们都封装到list内返回即可
        pass
class TextFileReader(FileReader):
    def __init__(self,path):
        self.path = path    # 定义成员变量，记录文件的路径
    # 复写（实现抽象方法）
    def read_data(self) ->list[Record]:
        f = open(self.path,"r",encoding="UTF-8")
        record_list:list[Record] = []
        for line in f.readlines():
            line = line.strip()     # 消除读取到的每一行数据中的换行符
            data_list = line.split(",")
            record = Record(data_list[0],data_list[1],int(data_list[2]),data_list[3])
            record_list.append(record)
        f.close()
        return record_list
class JsonFileReader(FileReader):
    def __init__(self,path):
        self.path = path    # 定义成员变量，记录文件的路径
    def read_data(self) ->list[Record]:
        f = open(self.path,"r",encoding="UTF-8")
        record_list:list[Record] = []
        for line in f.readlines():
            data_dict = json.loads(line)
            record = Record(data_dict["date"],data_dict["order_id"],int(data_dict["money"]),data_dict["province"])
            record_list.append(record)
        f.close()
        return record_list

text_file_reader = TextFileReader("D:/python 代码/python 第2阶段/第一章 面向对象/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/python 代码/python 第2阶段/第一章 面向对象/2011年2月销售数据JSON.txt")
jan_data:list[Record] = text_file_reader.read_data()
feb_data:list[Record] = json_file_reader.read_data()
# 将2个月份的数据合并为1个list来存储
all_data:list[Record] = jan_data + feb_data

# 构建MySQL链接对象
from pymysql import Connection
conn = Connection(
    host="localhost",
    port=3306,
    user="root",
    password="20000307",
    autocommit=True
)
# 获得游标对象
cursor = conn.cursor()
# 选择数据库
conn.select_db("py_sql")
# 组织SQL语句
for record in all_data:
    sql = f"insert into orders(order_date,order_id,money,province) " \
          f"values('{record.date}','{record.order_id}',{record.money},'{record.province}')"
    # 执行SQL语句
    cursor.execute(sql)
# 关闭MySQL链接对象
conn.close()

**练习案例：**将写入到MySQL的数据，通过python代码读取出来，一行为一个数据，格式为字典类型

# 将写入到MySQL的数据，通过python代码读取出来，一行为一个数据，格式为字典类型
from pymysql import Connection
f = open("D:/python 代码/python 第2阶段/第二章 SQL入门和实战/12的课后习题.txt","w",encoding="UTF-8")
conn = Connection(
    host="localhost",
    port=3306,
    user="root",
    password="20000307"
)
cursor = conn.cursor()
conn.select_db("py_sql")
cursor.execute("select * from orders")
records = cursor.fetchall() # 元组嵌套元组
for record in records:
    record = str(record)    # 元组转字符串
    f.write("{"+record+"}\n")
f.close()
conn.close()
# 此代码没有达到要求的字典类型

博主声明：
本文知识点与代码皆出自黑马程序员课程
欢迎有兴趣的同学进行视频学习
链接：黑马程序员python教程

彷徨迷离
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Xrafece-面向对象实现时钟（时：分：秒）-JAVA
SDCL-静默花开
03-30 715
时钟-时：分：秒（面向对象） Problem Description 定义时钟类Clock。 定义时钟类Clock的私有属性小时hour，分钟minute， 秒钟second。 定义时钟类Clock的（无参）构造方法，以及属性的set方法setHour，setMinute，setMinute。 定义时钟类Clock的私有方法小时自增addHour，分钟自增addMinute和秒钟自增ad...
python核心编程第二版笔记.rar
04-14
《Python核心编程第二版》是Python编程领域里一本广受欢迎的经典教材，这本书深入浅出地介绍了Python语言的基础知识和高级特性。笔记作者通过细致的整理，将书中的关键概念、语法和实例进行了详尽的记录，旨在帮助...
python转义字符/a---响铃
m0_62865498的博客
04-13 661
C++实用的闹钟程序
小天狼星_布莱克 的博客
08-29 1560
最近搞了个闹钟程序，代码如下： #include<stdio.h> #include<cstdlib> #include<iostream> #include<windows.h> #include<conio.h> #include<time.h> #include<ctime> using namespace std; int d,e,f,sss=1; string things; void gotoxy(int y
面向对象（小闹钟）
BruceWang的专栏
05-29 940
************************后台代码********************************  Block1 myblock = new Block1();         public Form1()         {             InitializeComponent();             txttime.Text = DateTim
Python核心编程笔记
memcpy0的博客
04-22 1304
简明Python教程 Python核心编程笔记
python基础知识笔记
热门推荐
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
Python 编程笔记（本人出品，必属精品）
一些笔记
12-06 1830
有关python 的下载安装，以及一些基础知识。对网络资源的一个小小整理~ 笔者根据自己的使用经验，又进行了扩充，一直在用，所以会一直更新！！
Python学习笔记 - Python编程规范
yunfan
05-08 1534
主要描述Python语言的编程规范，包括命名规范、注释规范、导入规范和代码排版等内容。
Python3 笔记：Python3 在线工具、Python在线编程
Catherine_CSDN_的博客
05-03 2229
在没有安装Python的情况下，想试试在线编程的，推荐以下三款工具： 1、W3Cschool Python 3 在线工具 www.w3cschool.cn/tryrun/runcode?lang=python3 2、Python3 在线工具www.jyshare.com/compile/9/ 3、Python在线编程www.sciclass.cn/python
python核心编程第二版pdf_Python Book电子书pdf版合集 Python核心高级编程第二版
weixin_39517902的博客
11-24 485
1小时学会Python.doc51CTO下载-[Python系列].BeginningPythonFromNovicetoProfessionalSecondEdition.pdf8.Python_GUI程序设计.pptApress.Python.Algorithms.2010.pdfBeginning Game Development with Python and Pygame.pdfBegi...
python核心编程第二版笔记.doc
03-31
"Python核心编程第二版笔记.doc"这份文档详细记录了Python语言的基础知识，涵盖了从解释器选项到高级概念，对于初学者和进阶者都是很好的参考资料。 1. 解释器选项： Python解释器提供了一些命令行选项来改变其...
Python非常详细编程笔记.zip_python 详细笔记_python编程
09-19
这份“Python非常详细编程笔记”涵盖了Python的基础到进阶知识，是学习Python编程的理想资源。以下将详细介绍其中可能涵盖的一些核心知识点： 1. **Python基础知识**：这包括Python的安装、环境配置以及开发工具的...
《Python数学编程》学习笔记源代码1-5.7z
04-27
学习笔记源代码1-5.7z这个压缩包包含了作者在阅读和实践这本书籍内容时所编写的代码示例，覆盖了从第一天到第五天的学习内容。这些源代码是读者深入理解和掌握Python在数学应用中的强大功能的宝贵资源。 1. **...
python核心编程第二版笔记
04-28
1.3 –S 不导入site模块以在启动时查找python路径 1.4 –v 冗余输出(导入语句详细追踪) 1.5 –m mod 将一个模块以脚本形式运行 1.6 –Q opt 除法选项(参阅文档) 1.7 –c cmd 运行以命令行字符串心事提交的python脚本...
【python学习】深入解析 `jq` 库：JSON 处理的利器
最新发布
m0_54007171的博客
08-13 230
jq库是 Python 对流行的命令行工具jq的封装。它允许你直接在 Python 中使用jq的查询语言来处理 JSON 数据。借助jq，你可以轻松地对 JSON 数据进行过滤、选择、转换、聚合等操作，极大地简化了代码复杂度。
Python 算法交易实验80 QTV200日常推进-目标估算
yukai08008的博客
08-10 463
业务目标在先，月利3%是第一个目标。虽然日常有在常规推进，但目标是什么？现在做的是什么？与目标的关联是什么？业务上讲，如果月利能够达到3%(几何平均)，上下波动不超过1%，就算达标了(2%~4%)。考虑到金融领域有不可测风险，所以资金还会分摊到3个月。例如，假如总投资资金是30万，那么每个月的最大投资金额是10万。这样即使遇到大跳水，问题也不大。目标达到的话，10万本金每月的盈利是3000， 按复利计,24个月就会double，我觉得已经足够理想。假设投资90万，则可以按30万计算复利效果。
Falsk测试与部署（第九阶段）
蜡笔小新星的博客
08-09 656
在本章节中，我们学习了如何使用unittest和pytest进行单元和集成测试，以及如何配置Flask应用，使用WSGI服务器部署，容器化Flask应用并将其部署到各种云服务平台。通过这些步骤，你可以确保你的Flask应用在生产环境中的稳定性和可靠性。希望这些知识能够帮助你在实际项目中更好地实现测试和部署。
【Python写一段代码读取word文件内容】
qq_36253366的博客
08-09 212
类，然后加载了一个Word文档。接着，它遍历文档中的每一个段落，并打印出每个段落的文本内容。此外，它还展示了如何遍历文档中的所有表格，并打印出每个表格中的单元格内容。库主要关注于文档中文本和表格内容的提取和修改，对于文档中的图片、复杂格式（如页眉页脚）等内容的处理可能需要其他方法或库。这个库允许你创建、修改以及提取Microsoft Word文件（.docx）的内容。在Python中读取Word文件（.docx格式）的内容，你通常需要借助第三方库，如。替换为你的Word文件的实际路径。
Python编程学习笔记：从入门到实践（第二版）
"这是一份关于《Python编程从入门到实践》第二版的学习笔记，涵盖了Python的基础知识，包括安装、变量、简单数据类型等。笔记详细介绍了Python环境的搭建，如如何从官网下载安装Python，安装pip以及如何通过pip安装...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值