一.面向对象

1.类和对象

类(class)是面向对象编程的一个概念，它类似模板或者蓝图，拥有某一类事物共性的特征，比如cat类，那么一定有尾巴，眼睛，四肢等等，至于某一个属性的状态，比如存在或者不存在则是特性的东西。

事物可以从两方面来进行描述，属性和行为。相似地，类(class)中也有属性和行为，分别通过定义成员变量和成员方法来描述。

既然类是模板或者蓝图，那么想要依据共性的模板创建一个特性的实例就需要创建对象，这个根据类创建对象的过程叫做实例化。

面向对象三大特性：封装，继承，多态。

面向对象编程就是：设计类，基于类创建对象，让对象干活做具体的工作。

以下是python中面向对象编程的一个具体过程：

#设计类，以Dog类为例
class Dog:
    #定义基本属性
    name = None
    age = None
    #定义基本行为
    def bark(self):
        import winsound
        winsound.Beep(2000,3000)
    #self是必须的形参，事实上，self只是一个特征，表明这是一个类中的方法，在实际调用方法是并不需要我们真的进行self的传参，IDE会自动传递实参self。
#创建对象
xiaohua = Dog()
xiaohua.name = "xiaohua"
xiaohua.age = 6
#让对象工作
xiaohua.bark()

这是一种创建类的手段，基于这种类创建对象时需要对属性一个个赋值，无法一次性赋值。

__init__构造方法：

#设计类，以Dog类为例
class Dog:
    #定义基本属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #__init__是python中的内置方法，用于初始化类的实例
    #定义基本行为
    def bark(self):
        import winsound
        winsound.Beep(2000,3000)
#创建对象
xiaohua = Dog("xiaohua",6)
#让对象工作
xiaohua.bark()
print(xiaohua.age)

__init__本身的作用是，在构建类时传入的参数会自动提供给__init__方法，并且__init__方法会自动执行

2.python内置方法

类似上文中的__init__方法，python中有许多内置方法，称为魔术方法。

常见的内置方法：

1.str字符串方法

__str__ 方法是 Python 中一个特殊的方法，它用于定义一个对象的“字符串表示”。当你使用 print() 函数或 str() 函数来输出一个对象时，Python 会调用该对象的 __str__ 方法。

通过实现 __str__ 方法，你可以提供一个更友好的、可读性更强的输出格式，方便调试和日志记录。

当没有对__str__进行人为定义时，默认会返回类的地址，比如：

class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def bark(self):
        import winsound
        winsound.Beep(2000,3000)
xiaohua = Dog("xiaohua",6)
print(xiaohua)
#<__main__.Dog object at 0x000001BD22E85DF0>
class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def bark(self):
        import winsound
        winsound.Beep(2000,3000)
    def __str__(self):
        return f"{self.name}"
xiaohua = Dog("xiaohua",6)
print(xiaohua)
#"xiaohua"

2.`lt`方法

__it__方法用于比较两个类特定属性进行“<”比较，返回bool值，比如：

class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def bark(self):
        import winsound
        winsound.Beep(2000,3000)
xiaohua = Dog("xiaohua",6)
dahuang = Dog("dahuang",5)
print(xiaohua<dahuang)
#报错，因为在定义类时并没有赋予它可以比较这个属性
class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def bark(self):
        import winsound
        winsound.Beep(2000,3000)
    def __lt__(self,another_class):
        return self.age<another_class.age
xiaohua = Dog("xiaohua",6)
sangbiao = Dog("sangbiao",7)
dahuang = Dog("dahuang",5)
print(xiaohua<dahuang)
#False
print(xiaohua<sangbiao)
#True

注意：这里的__lt__方法仅限于“<”的比较，也就是说print(xiaohua>sangbiao)会报错。

其他比较魔术方法：
__eq__(self, other): 实现相等运算符 ==。
__ne__(self, other): 实现不等运算符 !=。
__lt__(self, other): 实现小于运算符 <。
__le__(self, other): 实现小于等于运算符 <=。
__gt__(self, other): 实现大于运算符 >。
__ge__(self, other): 实现大于等于运算符 >=。

3.封装

封装是面向对象编程的一种思想，它指的是将数据（属性）和操作数据的方法（行为）结合在一起，将数据的实现细节隐藏起来，只暴露出必要的接口给外部使用。这样可以提高代码的安全性和可维护性。

封装的主要优点包括：

数据隐藏：通过将数据私有化，只允许通过公共方法访问，减少了数据被随意修改的风险。
提高代码的可维护性：如果需要修改内部实现，只需在类内部进行修改，而不影响使用该类的外部代码。
降低复杂性：外部代码只需要了解接口，而不需要关心内部实现，简化了使用过程。

私有成员

现实生活中的一些事物的部分属性和行为并不对所有人开放，类也是如此。类中提供了私有成员的形式来支持该特性。

定义私有成员只需要在私有成员名字前加“__”即可。

虽然私有成员无法被通过类访问，但是可以在类中被其他成员访问

class Phone:
    __current_voltage = None
    
    def __keep_single_core(self):
        print("5g通话已开启")
xiaomi = Phone()
print(xiaomi.__current_voltage)
print(xiaomi.__keep_single_core)
#报错
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通信，已设置单核模式省电")
xiaomi = Phone()
call_by_5g()
#5g通话已开启

4.继承

定义一个新的类，新的类的属性与方法继承自一个老的类，并且新的类有独属于自己的属性与方法。

语法：

class sub_class(super_class):
    class_stuct

单继承：

class phone:
    IMET = None
    producer = "Apple"
    
    def call_by_4g(self):
        print("4g")
        
class phone_new(phone):
    face_id = "10001"
    
    def call_by_5g(self):
        print("5g")

多继承：

class NFC:
    pass
    #pass,占位符，无实际意义，用于定义空类
class xiaomi(phone_new,NFC):
    class_struct

多个父类中,如果有同名的成员,那么默认以继承顺序(从左到右)为优先级。

即:先继承的保留,后继承的被覆盖

复写父类成员

class phone:
    IMET = None
    producer = "Apple"
    
    def call_by_4g(self):
        print("4g")
        
class phone_new(phone):
    face_id = "10001"
    producer = "microsoft" #复写父类成员变量
    def call_by_4g(self):
        print("5g")	#复写父类成员方法

调用父类同名成员

如果在子类中对父类进行复写，那么在子类中调尝试用父类同名成员时会调用复写后的成员，如果想真正能访问到父类中同名成员，需要用特殊的调用方式：

#mode1:
superclass_name.menber_variable
superclass_name.menber_method(self)
#mode2:
super().menber_variable
super().menber_method()

5.类型注解

为容器作注解

在注释中作注解

对函数参数进行注解

def func(param1:type,param2:type,……):
    pass

对函数返回值进行注解

def func(param1:type,param2:type,……) -> ret_type:
    pass

Union注解

#使用 Union 来表示值可以是多种类型之一。
from typing import Union

def parse_value(value: Union[int, str]) -> str:
    return str(value)

值得注意的是，注解并不会因为注解而改变变量，参数，或者返回值的类型，也就是说，注解仅仅是用于给编写者或者第三方IDE作提示信息。

6.多态

多态，指的是同一个行为，传入不同的对象，得到不同状态

抽象类(接口)

二.SQL入门与实战

1.数据库

数据可以分为储存和计算两部分，编程语言可以归纳为数据计算一类，数据库就是用于数据存储一类。

数据库如何组织数据

数据库管理系统(数据库软件)

MySQL,SQLSever等

数据库和SQL语言的关系

数据库用于储存数据，那么在这个过程中无法避免地涉及到数据地增删查改和数据库，数据表的管理。SQL语言就是对数据库进行操作，管理，查询的工具。

数据库软件可以获得库->表->数据，这种数据组织，储存的能力，并借助SQL语言完成对数据的操作，管理，查询。

2.SQL基础与DDL

SQL全称Structured Query Language,结构化查询语言，用于访问和处理数据库的标准的计算机语言。

SQL的基础语法特征：
- 大小写不敏感
- 单行或多行书写，以;结束
- 支持注释：
  1. 单行注释：— 注释内容
  2. 单行注释：# 注释内容
  3. 多行注释：/*注释内容*/

DDL是“数据定义语言”（Data Definition Language）的缩写。它用于定义和管理数据库中的结构和对象。

DDL-库管理

show databases;	-- 查看数据库
use database_name;	-- 使用数据库
create database database_name [charset utf8];	-- 创建数据库
drop database database_name;	-- 删除库
select database();	-- 查看当前数据库

DLL-表管理

show tables;	-- 查看表

drop table table_name;

drop table if exists table_name;	-- 删除表

create table table_name(
	column_name1 column_type1,
    column_name2 column_type2,
	column_name3 column_type3,
    ……
  );			-- 创建表

3.SQL-DML

DML是“数据操纵语言”（Data Manipulation Language）的缩写，它是数据库管理系统（DBMS）中用于管理数据的子语言。

数据插入insert

insert into table[(column1,column2,……,column n)] values(data1,data2,……,data n)[,(data1,data2,……,data n),……,(data1,data2,……,data n)]
#示例：
create table student(
	id int,
    name varchar(20),
    age int
);
#仅插入一列
insert into student(id) values(10001),(10002),(10003);
#插入全部列表
insert into student(id,name,age) values(10001,'xiaohua',18),(10002,'xiaohua',18);
#快速插入全部列表
insert into student values(10001,'xiaohua',18),(10002,'xiaohua',18);

数据删除delete

delete from table_name [while condition];
#注意删除数据是删除所匹配数据所在的一整个结构或对象

数据更新update

update table_name set column = value1 [where condition];

3.SQL-DQL

DQL（Data Query Language）是用于查询数据库中数据的语言，主要用于从数据库中检索数据。

查询数据select

select column1,column2,……,column n from table_name [where condition];
select * from table_name

分组聚合

select column1,column2,……,column n|聚合函数 from table_name [where condition] group by column x;
#聚合函数：
- sum(column)	求和
- avg(column)	求平均值
- min(column)	求最小值
- max(column)	求最大值
- count(column|*)	求数量

排序分页

select column|聚合函数|* from table_name [where condition] group by …… order by [asc(升序)|desc(降序)];	#排序
select column|聚合函数|* from table_name [where condition] group by …… order by [asc(升序)|desc(降序)] limit n[,m]; #分页

4.python操作MySQL

1.python执行SQL语句

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

import pymysql1
from pymysql1.cursors import Cursor

#构建MySQL数据库的链接
conn = pymysql1.Connection(
    password='xxxxxxxxxxxx',
    user='root',
    port=3306,
    host='localhost'
)
# print(conn.get_server_info())
#执行非查询性SQL语句
cursor = conn.cursor()      #获取到游标对象
conn.select_db("try")       #选择数据库
cursor.execute("create table test_pymysql(id int);")    #将SQL语句以字符串的形式作为参数传到execute方法即可
#执行查询性质的SQL语句
cursor = conn.cursor()      #获取到游标对象
conn.select_db("try")       #选择数据库
cursor.execute("select * from student;")
#查询结果
result: tuple = cursor.fetchall()      #获得查询结果并封装进元组
for r in result:
    print(r)
conn.close()

2.python数据插入MySQL

当我们在使用pymysql库执行数据插入或者其他可能产生数据更改的语句时，需要**“提交”**，通过链接对象.commit()即可确认此行为

Python2