面向对象，MySQL数据库基础知识

python

第一章面相对象

第一节初识对象

1. 使用对象数据

 #1、在程序中设计表格，我们称之为：设计类（class）
 class student:
   name=None    #记录学生姓名
# 2、在程序中打印生产表格，我们称之为：创建对象
   stu_1=student()
   stu_2=student()
 #3、在程序中填写表格，我们称之为：对象属性赋值
  stu_1=“周杰伦”
  stu_2="林俊杰"

2.案例

# 设计一个类（类比生活中:设计一张登记表）
class Student:
    name=None         #记录学生姓名
    gender=None       # 记录学生性别
    nationality=None   # 记录学生国籍
    native_place=None  # 记录学生籍贯
    age=None            # 记录学生年龄
# 创建一个对象（类比生活中:打印一张登记表
stu_1=Student()
# 对象属性进行赋值（类比生活中:填写表单）
stu_1.name="林俊杰"
stu_1.gender="男"
stu_1.nationality="中国"
stu_1.native_place="山东省"
stu_1.age=31
# 获取对象中记录的信息
print(stu_1.name )
print(stu_1.gender )
print(stu_1.nationality )
print(stu_1.native_place )
print(stu_1.age )

3.总结：

1、在程序中设计表格，我们称之为：设计类（class）
2、在程序中打印生产表格，我们称之为：创建对象
3、在程序中填写表格，我们称之为：对象属性赋值

第二节类

1.类的使用语法

1. class 类名称： class关键子，表示要定义类
   类的属性 类的属性，既定义在类中的变量（成员变量）
   类的行为 类的行为，既定义在类中的函数（成员方法）
2. 创建类对象的语法：
   对象=类名称（）
   类里包含两部分：1属性（数据） 2行为（函数）
   成员变量和成员方法
3. 成员方法的定义函数
   def 方法名（self ,形参1…形参N）
   方法体
4. self关键字是成员方法定义的时候必须填写的，它用来表示类对象自身的意思，
   当我们使用类对象调用方法时，self会自动被python传入
   在方法内部，想要访问类的成员变量，必须使用self
   只有通过self，成员方法才能访问类的成员变量
   self出现在形参类表中，但是不占用参数位置，无需理会
5. 注意 函数是写在类的外的，定义在类内部，我们称之为方法

2.定义一个带有成员方法的类

class Student:
    name=None
    def say_hi(self):
        print(f"大家好呀，我是{self.name},欢迎大家多多关照")

    def say_hi2(self,msg):
        print(f"大家好，我是{self.name},{msg}")
stu=Student()
stu.name="周杰伦"
stu.say_hi2("哎呦不错啊")

stu2=Student()
stu2.name="林俊杰"
stu2.say_hi2("小伙子看好你啊")

3.设计一个闹钟

class Clock:
    id=None
    price=None

    def ring(self):
         import winsound
         winsound.Beep(2000,3000)


#构建两个闹钟对象并进行工作
clock1=Clock()
clock1.id="003032"
clock1.price=19.99
print(f"闹钟ID：{clock1.id },价格{clock1.price }")
clock1.ring()

clock2=Clock()
clock2.id="003033"
clock2.price=21.99
print(f"闹钟ID：{clock2.id },价格{clock2.price }")
clock2.ring()

4.总结

1、现实中的世界由属性和行为组成，类也包括属性和行为

2、类和对象的关系是什么？
类是程序中的“设计图纸”，对象是基于图纸生产的具体实物

3、什么是面向对象编程

第三节 “init”构造方法（两个下划线）

python 类可以使用：init(),称之为构造方法
在创建类对象的时候，会自动执行
在创建类对象的时候，将传入参数自动传递给__init__方法使用

构建方法的名称__init__
class Student:
    name=None
    age=None
    tel=None

    def __init__(self,name,age,tel):
        self.name=name
        self.age=age
        self.tel=tel
        print("Student创建了一个类对象")
stu=Student("周杰伦",31,"185000006666")
print(stu.name )
print(stu.age )
print(stu.tel )


class Student:

    def __init__(self,name,age,tel):
        self.name=name
        self.age=age
        self.tel=tel
        print("Student创建了一个类对象")
stu=Student("周杰伦",31,"185000006666")
print(stu.name )
print(stu.age )
print(stu.tel )

总结：

1、构建方法的名称__init__两个下划线
2、构造方法的作用
 构建对象的时候会自动运行
 构建类对象传参会传递构造方法，借此特性可以给成员变量赋值
3、注意事项
 构建方法不要忘了self关键字
 在方法内部使用成员变量需要使用self

第四节 魔术方法

1. _str_字符串方法，通过这个方法，控制类转换为字符串的行为
2. _lt_小于符号比较方法
   直接对两个对象进行比较是不可能的，但是在类实现_lt_方法，可以同时完成大小比较
3. __le__小于等于符号和大于等于符号
4. __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}"
    def __lt__(self,other):
        return self.age<other.age
    def __le__(self,other):
        return self.age<=other.age
    def __eq__(self,other):
        return self.age==other.age
stu1=Student("周杰伦",31)
stu2=Student("林俊杰",36)
print(stu1)
print(str(stu2))
print(stu1<stu2)
print(stu1>stu2)
print(stu1>=stu2)
print(stu1<=stu2)
print(stu1==stu2

第五节 封装

1.面向对象包含三大主要特性 封装，继承，多态

2.如何定义私有成员
私有成员变量：变量名以_开头（两个下划线）
私有成员方法：变量名以_开头（两个下划线）

3.私有成员的访问限制
私有方法无法直接被类对象使用
私有变量无法直接赋值，也无法获取赋值
私有成员无法被类对象使用，但是可以被其他成员使用

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

 定义一个类内涵私有成员变量和私有成员方
class Phone:
    __current_voltage=0.5

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


#案例
class Phone:
    __is_5g_enable=True

    def __check_5g(self):
        if self.__is_5g_enable:
            print("5g开启")
        else:
            print("5g关闭，使用4g网络")
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")
phone=Phone()
phone.call_by_5g()

第六节 继承

1.继承 分为单继承和多继承

2.继承的语法单继承
class 类名（父亲名）
类内容体

3.多继承语法
class 类名（父亲1，父亲2，，，，，，父亲n）
类内容体

6.1单继承

class Phone:
    TMEI=None
    producer="HM"

    def call_by_4g(self):
        print("4g通话")
class Phone2022(Phone):
    face_id="10010"
    def call_by_5g(self):
        print("2022年新功能：5g通话")
phone=Phone2022()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()

6.2多继承

class Phone:
    TMEI=None
    producer="HM"

    def call_by_4g(self):
        print("4g通话")

class NFCReader:
    nfc_type="第五代"
    producer="HM"
    def read_card(self):
        print("NFC读卡")
    def write_card(self):
        print("NFC写卡")

class TemoteControl:
    re_type="红外遥控"
    def control(self):
        print("红外遥感开启")

class MyPhone(Phone,NFCReader,TemoteControl):
    pass
phone=MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

6.4总结：

 1、什么是继承？ 继承就是一个类，继承另外一个类的成员变量和成员方法
 2、单继承和多继承
 单继承：一个类继承一个类
 多继承：一个类继承多个类，按照顺序从左向右一次继承
 多继承中，如果父类有同名方法或成员，先继承的优先级高于后继承
 3、pass关键字的作用
 pass是站位语句，用来保证函数（方法）或类定义的完整性，表示无内容，空的意思

第七节 复写

1. 子类在继承父亲的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写 调用父类同名成员， 一但复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员
2. 如果需要使用被复写的父亲的成员，需要特殊的调用方式
   方式一
   使用成员变量：父类名.成员名
   使用成员方法：父类名.成员方法（self）
   方式二
   使用super（）调用父类成员
   使用成员变量：super（）.成员变量
   使用成员方法：super（）.成员方法

class Phone:
    IMEI=None
    producer="hm"
    def call_by_5g(self):
        print("使用5g网络进行通话")

class MyPhone(Phone):
    producer="itheima"

    def call_by_5g(self):
        print("开启CPU单核模式，确保通话时候省电")
        # 方式一
        # print(f"父类的生产商是：{phone.producer}")
        # phone.call_by_5g(self)
        # 方式二
        print(f"父类的生产商是：{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核模式，确保性能")
phone=MyPhone()
phone.call_by_5g()
print(phone.producer)

第八节 注解

8.1各类型注解

import json
 import random
 var_1: int=10
 var_2: str="itheima"
 var_3: bool=True
 \# 类对象类型注解
 class Student:
   pass
 stu: Student=Student()
 \# 基础容器类型注解
 my_list: list=[1,2,3]
 my_tuple: tuple=(1,2,3)
 my_dict: dict={"itheima":666}
 \# 容器类型详细注解
 my_list: list[int]=[1,2,3]
 my_tuple: tuple[int,str,bool]=(1,"itheima",True)
 my_dict: dict[str,int]={"itheima":666}
 \# 在注释中进行类型注解
 var_4= random.randint(1,10) # type:int
 var_5=json.loads('{"name":"zhangsan"}')  #type:dict[str,str]
 def func():
   return 10
 var_6=func()  #type:int
 \#类型注解的限制
 var_1: str=10
 var_2: int="itheima"

# 函数方法的类型注解
def add(x:int,y:int):
    return x+y
# 对返回值进行类型注解
def dunc(data:list) -> list:
    return data

8.2 总结

 1、什么是类型注解，有什么作用？
 在代码中涉及数据交互时，对数据类型进行显示的说明
 2、类型注解支持：
 变量类型的注解
 函数的形参和返回值的类型注解
3、变量的类型注解语法
 语法1： 变量：类型
 语法2： 在注释中注解，#type：类型
4、注意事项
 类型注解只是提示性的，并非决定性的，数据类型和注解类型无法对应也不会导致错误
5、函数可以为那里添加注解
 形参的类型注解
 返回值的类型注解
6、函数的类型注解的方法
 def 函数方法名（形参：类型，形参：类型）->返回值类型：
    pass
 注意，返回值类型注释的符号是->

第九节 Union 类型

1、什么是Union类型
使用Union可以定义联合类型注释

2、Union的使用方式
导包： from typing import Union
使用： Union[类型，…，类型]

# 使用Union类型必须先导包
from typing import Union
my_list:[Union[int,str]]=[1,2,"itheima"]
def func(date:Union[int,str]) ->Union[int,str]:
    pass
func()

第十节 多态

1、什么是多态
多态是指，同一个行为，使用不同的对象获取不同的状态

2、什么是抽象类（接口）
包含抽象方法的类，称之为抽象类。抽象方法是指：没有具体实现的方法（pass）称之为抽象方法

3、抽象类的作用
多用于做顶层设计（设计标准），以便子类做具体实现
也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法并配合多态去使用，就可以获得不同的工作状态了

# 演示面向对象的多态特性
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 Midle_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()
mide_ac = Midle_AC()
gree_ac= GREE_AC()

make_cool(mide_ac)
make_cool(gree_ac)

第二章MYSQL数据库

第一节MySQL数据库的入门使用

总结：
1、数据库是什么？有什么作用？
数据库就是指数据存储的库，作用就是组织数据并存储数据
2、数据库如何组织数据
按照：库，表，数据三个层级进行组织
4、数据库和SQL的关系
数据库提供数据组织存储的能力，SQL语言则是操作数据，数据库的工具语言
MYSQL数据库的安装

第二节SQL-DDL

use world;

show tables;

create table student(
id int,
name varchar(10),
age int
);

drop table student;

总结
1、sql语言是什么，有什么作用
sql：结构化查询语言，用于操作数据库，通用于绝大多数的数据库软件
2、sql的特征
大小写不敏感
需要以；结尾
支持单行多行注释
3、sql语言的分类
DDL数据定义
DML数据操作
DCL数据控制
DQL数据查询

第三节SQL-DML

1、insert 数据插入

create table student(
id int,
name varchar(10),
age int
);
show tables;
-- 添加数据
insert into student(id) values(1),(2),(3);
insert into student(id,name,age) values(4,'zhoujielun',30),(5,'linjunjie',33);
insert into student values(6,'zhangxue',30),(7,'zahngliang',33);

2、delete数据删除

-- 删除数据
delete from student where id=1;
delete from student where id<4;
delete from student where id>6;
delete from student where age=33;
delete from student;

3、update更新数据

update student set name='zhangxue' where id=4;
update student set name='laing';

总结：

第四节 SQL-DQL

1、基础查询

insert into student values(1,'张杰',30),(2,'芍药',39),(3,'丽丽',41),(4,'菲菲',21),(5,'敦伦',46),(6,'嘻嘻',15),(7,'影子',52);

-- select 字段列表|*from 表
select id, name,age from student 
select * from student 

-- select 过滤查询语法 select 字段列表|* from 表where 条件判断
select * from student where age>30;

2、分组聚合

create table student1(
id int,
name varchar(10),
age int,
gender varchar(2)
);

show tables;

insert into student1 values(1,'张杰',30,'男'),(2,'芍药',39,'女'),(3,'丽丽',41,'女')
,(4,'菲菲',21,'女'),(5,'敦伦',46,'男'),(6,'嘻嘻',15,'男'),(7,'影子',52,'男');
insert into student1 values(8,'小路',38,'男'),(9,'符合',39,'女'),(10,'贝贝',45,'女')
,(11,'邢飞',24,'女'),(12,'梅梅',44,'男'),(13,'库迪',16,'男'),(14,'宇飞',50,'男');
insert into student1 values(15,'嬴政',40,'男'),(16,'春桃',20,'女'),(17,'颖儿',16,'女')
,(18,'霜花',19,'女'),(19,'敖丙',54,'男'),(20,'哪吒',53,'男');

-- 分组
select gender,avg(age),sum(age),max(age),min(age),count(*)  from student1 group by gender;

总结

1、分组聚合的语法是？

select 字段|聚合函数 from 表【where条件】group by 列

聚合函数有：

sum(列) 求和

avg(列) 求平均值

min(列) 求最小值

max(列) 求最大值

count(列|*) 求数量

2、分组聚合的注意事项？

group by 中出现哪个列，哪个列才能出现在select中的非聚合中

3、排序分页

-- 排序分页
select * from student1 where age>20 order by age asc;
select * from student1 where age>20 order by age desc;

select * from student1 limit 5;
select * from student1 limit 10,5;

select  age, count(*) from student1 where age>20 group by age
order by age 
limit 3;

总结：

1、排序和分页限制的语法是？

2、截止目前学习的关键字，需要注意？

where , group by, order by, limit 均可按需求省略

select和from必须写

执行顺序

from>where >group by 和聚合函数>select > order by > limit

第五节 python的MySQL执行

1、基础使用

from pymysql import Connection
# 构建MySQL数据库的链接对象
conn=Connection(
    host="localhost",   # 主机名（IP）
    port=3306,          # 端口
    user="root",        # 账户
    password="123456"   #密码
)
# print(conn.get_server_info())
#  执行非查询性质SQL
cursor=conn.cursor()   # 获取到游标对象
# 选择数据库
conn.select_db("world")
# 使用游标对象，执行SQL
cursor.execute("select * from student1")
# 获取查询结果
results= cursor.fetchall()
for r in results:
    print(r)
# 关闭数据库的链接
conn.close()

总结：

1、如何获取链接对象？

from pymysql import Connection 导包

Connection(主机，端口，账户，密码)即可或得链接对象

链接对象.close()关闭MySQL数据库的链接

2、如何执行MySQL查询

通过链接对象调用cursor()方法，获得游标对象

游标对象.execute()执行SQL语句

游标对象.fetcahll()得到全部的查询结果封装如元组内

2、数据插入

from pymysql import Connection
# 构建MySQL数据库的链接
conn=Connection(
    host="localhost",
    port =3306,
    user="root",
    password="123456",
    autocommit=True       # 自动确认
)
cursor=conn.cursor()
conn.select_db("world")
#cursor.execute("insert into student1 values(100010,'周杰伦',31,'男')")
cursor.execute("insert into student1 values(100012,'林俊杰',36,'男')")
conn.close()

总结：

1、什么是commit提交？

pymysql库在执行对数据库有修改操作的行为时，是需要通过链接对象的commit成员方法来进行确认的

2、如何自动提交？

conn=Connection(
    host="localhost",      # 主机名
    port =3306,            # 端口
    user="root",           # 账户
    password="123456",     #密码
    autocommit=True        # 自动提交（确认）

对象调用cursor()方法，获得游标对象

游标对象.execute()执行SQL语句

游标对象.fetcahll()得到全部的查询结果封装如元组内

2、数据插入

from pymysql import Connection
# 构建MySQL数据库的链接
conn=Connection(
    host="localhost",
    port =3306,
    user="root",
    password="123456",
    autocommit=True       # 自动确认
)
cursor=conn.cursor()
conn.select_db("world")
#cursor.execute("insert into student1 values(100010,'周杰伦',31,'男')")
cursor.execute("insert into student1 values(100012,'林俊杰',36,'男')")
conn.close()

总结：

1、什么是commit提交？

pymysql库在执行对数据库有修改操作的行为时，是需要通过链接对象的commit成员方法来进行确认的

2、如何自动提交？

conn=Connection(
    host="localhost",      # 主机名
    port =3306,            # 端口
    user="root",           # 账户
    password="123456",     #密码
    autocommit=True        # 自动提交（确认）