## 简介

TypeScript有助于提高代码质量，保证代码安全，更适合用在大型的企业级项目。不一定适合那些小型的、短期的个人项目。

TypeScript官网在线编译页面TypeScript Playground：[http://www.typescriptlang.org/play/](http://www.typescriptlang.org/play/)

TypeScript官方提供的编译器叫做tsc，可以将TypeScript脚本编译成JavaScript脚本。本机想要编译 TypeScript代码，必须安装tsc。

根据约定，TypeScript脚本文件使用.ts后缀名，JavaScript脚本文件使用.js后缀名。tsc的作用就是把.ts脚本转变成.js脚本。

### 静态类型检查

在代码运行前进行检查，发现代码的错误或不合理之处，减小运行时异常的出现几率，此种检查叫「静态类型检查」，TypeScript的核心就是「静态类型检查」，简言之就是把运行时的错误前置。

同样的功能，TypeScript代码量要大于JavaScript，但由于TypeScript代码结构更加清晰，在后期代码维护中TypeScript却远胜于JavaScript。

## 编译TypeScript

### 命令行编译

要把.ts文件编译为.js文件，需配置Typescript编译环境，步骤如下：

第一步：创建一个 index.ts 文件，例如：

    const person = {
      name: '张三',
      age: 18,
    }
    console.log(我叫${person.name}，今年${person.age}岁)

第二步：全局安装TypeScript：`npm i typescript -g`。

第三步：使用tsc命令编译.ts文件：`tsc index`，可省略后缀.ts。

### 自动化编译

第一步：创建TypeScript编译控制文件：`tsc --init`，工程中会生成一个tsconfig.json配置文件，其中包含着很多编译时的配置。默认编译的JS版本是ES7，可以手动调整为其他版本，例如`"target": "ES6",`。

第二步：监视目录中.ts文件变化：`tsc--watch`，实现自动编译。

第三步：小优化，当编译出错时不生成.js文件：`tsc --noEmitOnError --watch`。当然，最好是修改 tsconfig.json中的noEmitOnError配置项。

## 常用类型

TypeScript有两个“顶层类型”（any和unknown），但是“底层类型”只有never唯一一个。

### any类型

any类型表示没有任何限制，该类型的变量可以赋予任意类型的值。对于没有指定的类型，TypeScript如果无法推断出类型，就会认为类型是any。变量类型一旦设为any，TypeScript实际上会关闭这个变量的类型检查。

any类型的变量，可以赋值给任意类型的变量。

### unknown类型

unknown含义是未知，表示类型不确定，可能是任意类型，但是它的使用有一些限制，不像any那样自由，可以视为严格版的any，适用于不确定数据的具体类型。

    let a: unknown
    a = 10
    a = 'hello'
    let x: string
    // 第一种方式（加类型判断）
    if (typeof a === 'string') {
    x = a
    }
    // 第二种方式（加断言）
    x = a as string
    // 第三种方式（加断言）
    x = <string>a

unknown类型跟any类型的不同之处在于，它不能直接使用。主要有以下几个限制：

- unknown类型的变量，不能直接赋值给其他类型的变量（除了any类型和unknown类型）
- 不能直接调用unknown类型变量的方法和属性
- unknown类型变量能够进行的运算有限，只能进行比较运算（==、===、!=、!==、||、&&、?）、取反运算（!）、typeof运算符和instanceof运算符这几种，其他运算都会报错

只有经过“类型缩小”，unknown类型变量才可以使用。所谓“类型缩小”，就是缩小unknown变量的类型范围，确保不会出错。

### never类型

该类型为空，不包含任何值。由于不存在任何属于“空类型”的值，所以该类型被称为never，即不可能有这样的值。

never类型的一个重要特点是，可以赋值给任意其他类型。

### void

void用来表达“空”，通常用于函数返回值。函数返回值为空，调用者也不应依赖其返回值进行任何操作。

函数没有显示返回值的，会有一个隐式返回值，即undefined（undefined是void可以接受的一种空）。

## TS配置
target设置JavaScript的标准版本strict严格模式rootDirTS源文件所在目录，可设置为 ./srcoutDirTS编译后生成的JS文件输出目录，可设置为 ./dist
## 参考

- TypeScript 教程：[https://wangdoc.com/typescript/](https://wangdoc.com/typescript/)


TypeScript 基础编程笔记

Python中，一切皆对象。每个对象由：标识（identity）、类型（type）、值（value）组成。

id(obj)返回对象obj的标识；type(obj)返回对象obj的类型；print(obj)直接打印出对象obj的值。

同一运算符：`is`用来比较id，`==`用来比较值（本质是调用__eq__()）。is运算符比==效率高，在变量和None进行比较时，应使用is。

## 特殊成员

在Python类中存在一些特殊方法（一般称之为魔术方法），这些方法都是 `__方法__` 格式，这种方法（内置方法）在内部均有特殊含义。

### __init__初始化方法

专门用来定义一个类具有哪些属性的方法。

### __del__方法

对象被从内存中销毁前，会被自动调用。

### __new__构造方法

很少用，但比较重要。使用类名()创建对象时，Python解释器首先调用__new__方法为对象分配空间。

__new__是由object基类提供的内置静态方法，主要作用有2个：

- 在内存中为对象分配空间
- 返回对象的引用

class Foo(object): def __init__(self, name): print("第二步：初始化对象，在空对象中创建数据") self.name = name

    def __new__(cls, *args, **kwargs):
        print("第一步：先创建空对象并返回")
        return object.__new__(cls)
    

obj = Foo("李小龙")

### __call__方法

class Foo(object): def __call__(self, *args, **kwargs): print("执行call方法")

obj = Foo()
obj() # 对象+()执行call方法

### __str__方法

当使用print输出对象的时候，如果定义了__str__方法，那么就会打印从这个方法中return的数据。该方法需要返回一个字符串。 class Foo(object): def __init__(self, name): self.name = name

    def __str__(self):
        return "我是{}".format(self.name)
    

obj = Foo('李小龙')
print(obj) # 结果为：我是李小龙

__repr__这个特殊方法会在对当前对象使用repr()函数时调用，它的作用是指定对象在'交互模式'中直接输出的效果。

### __dict__方法

class Foo(object): def __init__(self, name, age): self.name = name self.age = age

obj = Foo('李小龙', 18)
print(obj.**dict**)

用类名调用__dict__，会输出该类中所有类属性组成的字典；而使用类的实例对象调用__dict__，会输出所有实例属性组成的字典。

### __getitem__方法、__setitem__方法、__delitem__方法

class Foo(object): def __getitem__(self, item): print(item)

    def __setitem__(self, key, value):
        print(key, value)
    
    def __delitem__(self, key):
        print('删除')
    

obj = Foo()
obj["x1"] # 自动触发类中__getitem__
obj['x2'] = 123 # 自动触发类中__setitem__
del obj['x3'] # 自动触发类中__delitem__

### __enter__和__exit__方法

class Foo(object): def __enter__(self): print("进来了") return 666

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("出去了")
    

obj = Foo()

# with 对象 as f：在内部会执行__enter__方法，这时f是666

# 当with缩进中的代码执行完毕，会自动执行__exit__方法

with obj as f:
print(123)
print(f)

输出结果如下：进来了 123 666 出去了

### __add__等

对象+值，内部会去执行`对象.__add__`方法，并将+后面的值当做参数传递过去。 class Foo(object): def __init__(self, age): self.age = age

    def __add__(self, other):
        return self.age + other.age
    

obj1 = Foo(18)
obj2 = Foo(20)
obj = obj1 + obj2
print(obj) # 结果为：38

### __iter__方法

#### 迭代器

迭代器类型的定义：

1. 类中定义 **iter** 和 **next** 这两个方法
2. iter 方法需要返回对象本身，即：self
3. next 方法返回下一个数据，如果没有数据了，则需要抛出一个StopIteration的异常

class IT(object): # 创建迭代器类型 def __init__(self): self.counter = 0

    def __iter__(self):
        return self
    
    def __next__(self):
        self.counter += 1
        if self.counter == 3:
            raise StopIteration()
        return self.counter
    

# 根据类实例化一个迭代器对象：

obj1 = IT()
v1 = next(obj1) # obj1.**next**()
print(v1) # 结果为：1

v2 = next(obj1)
print(v2) # 结果为：2

# v3 = next(obj1) # 抛出异常

# print(v3)

obj2 = IT()
for item in obj2:
print(item)

for循环内部在循环时，先执行__iter__方法，获取一个迭代器对象，然后不断执行的__next__取值（有异常StopIteration则终止循环）。

#### 生成器

# 创建生成器函数 def func(): yield 1 yield 2

# 创建生成器对象（内部是根据生成器类generator创建的对象），生成器类的内部也声明了__iter__、__next__方法

obj = func()

v1 = next(obj)
print(v1) # 结果为：1

v2 = next(obj)
print(v2) # 结果为：2

## v3 = next(obj) # StopIteration

## print(v3)

for item in obj:
print(item)

如果按照迭代器的规定来看，其实生成器类也是一种特殊的迭代器类（生成器也是一种特殊的迭代器）。

#### 可迭代对象

如果一个类中有__iter__方法且返回一个迭代器对象，则称这个类创建的对象为可迭代对象。 class IT(object): # 创建迭代器类型 def __init__(self): self.counter = 0

    def __iter__(self):
        return self
    
    def __next__(self):
        self.counter += 1
        if self.counter == 3:
            raise StopIteration()
        return self.counter
    

class Foo(object):
def **iter**(self):
return IT()

obj = Foo() # obj 是可迭代对象
for item in obj:
print(item)

## 继承

### mro和c3算法

如果类中存在继承关系，可以通过`mro()`获取当前类的继承关系。 class A(object): pass

class B(object):
pass

class C(A, B):
pass

print(C.mro())
print(C.**mro**)

输出结果如下：[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>] (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

如果用正经的C3算法规则去分析一个类继承关系有点繁琐，尤其是遇到一个复杂的类要分析很久。总结：**从左到右，深度优先，大小钻石，留住顶端**，基于这句话可以更快的找到继承关系。

## 类方法

类属性是针对类对象定义的属性，类方法是针对类对象定义的方法。语法如下： class Tool(): count = 0  # 类属性 @classmethod  # 类方法，用修饰器@classmethod来标识 def show_count(cls): print(f'工具对象的数量为 {cls.count}')

    def __init__(self, name):
        self.name = name
        Tool.count += 1
    

## 创建工具对象

tool = Tool('斧头')
tool2 = Tool('锯子')

# 调用类方法

Tool.show_count()

## 静态方法

如果类中封装的一个方法：

- 既不需要访问实例属性或者调用实例方法
- 也不需要访问类属性或者调用类方法

这个时候，就可以把这个方法封装成一个静态方法。静态方法既不需要传递类对象也不需要传递实例对象，有利于减少不必要的内存占用和性能消耗。

静态方法用修饰器@staticmethod来标识：

class Tool(): @staticmethod def show(): print('工具对象') def __init__(self, name): self.name = name # 创建工具对象 tool = Tool('斧头') # 调用类方法 Tool.show()

## 单例

让类创建的对象，在系统中只有唯一的一个实例，即单例。实现步骤为：

1. 定义一个类属性，初始值为None，用于记录单例对象的引用
2. 重写__new__方法
3. 如果类属性is None，调用父类方法分配空间，并在类属性中记录结果
4. 返回类属性中记录的对象引用

class Tool(): instance = None def __new__(cls, *args, **kwargs): if cls.instance is None: cls.instance = super().__new__(cls) return cls.instance

tool = Tool()
tool2 = Tool()
print(tool)
print(tool2)

### 只执行一次初始化

每次使用类名()创建对象时，Python解释器会自动调用两个方法：__new__、__init__。要让初始化动作只被执行一次，实现步骤为：

1. 定义一个类属性init_flag，标记是否执行过初始化动作，初始值为False
2. 在__init__方法中，判断init_flag，如果为False就执行初始化动作
3. 然后将init_flag设置为True

class Tool(): instance = None init_flag = False

    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance
    
    def __init__(self):
        if Tool.init_flag:
            return
        print('初始化')
        Tool.init_flag = True
    

tool = Tool()
tool2 = Tool()
print(tool)
print(tool2)

## 装饰器

Python内置的@property装饰器负责把一个方法变成属性调用。 class Square: def __init__(self, w, h): self.__height = h self.__width = w

    def set_side(self, new_side):
        self.__height = new_side
        self.__width = new_side
    
    @property
    def height(self):
        return self.__height
    
    @height.setter
    def height(self, new_value):
        if new_value &gt;= 0:
            self.__height = new_value
        else:
            raise Exception("Value must be larger than 0")
    

s = Square(2, 2)
print(s.height)  # 2
s.height = 5
print(s.height)  # 5

把一个getter方法变成属性，只需要加上@property就可以了。此时，@property本身又创建了另一个装饰器@height.setter，负责把一个setter方法变成属性赋值。

只定义getter方法，不定义setter方法就是一个只读属性。

### 类属性方式

class A: def __init__(self): self.__age = 0

    def get_age(self):
        return self.__age
    
    def set_age(self, age):
        if age &lt; 0 or age &gt; 120:
            raise ValueError("Invalid age")
        self.__age = age
    
    # 类属性方式的property属性
    age = property(get_age, set_age)
    

a = A()
print(a.age)  # 0
a.age = 25
print(a.age)  # 25

## 多态

多态是指同一个方法调用由于对象不同可能会产生不同的行为。关于多态要注意以下2点：

- 多态是方法的多态，属性没有多态
- 多态的存在有2个必要条件：继承、方法重写

## 抽象类

默认情况下，Python不提供抽象类，但abc模块为定义抽象基类提供了基础。抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类的抽象方法。

当需要抽象基类时，让类继承ABC(abc模块的ABC类)，使用@abstractmethod声明抽象方法，那么这个类就是抽象类。

from abc import ABC, abstractmethod class Animal(ABC): def __init__(self, name): self.name = name @abstractmethod def speak(self): pass # 抽象类不能实例化，只能被继承，不能创建对象 # a = Animal("dog") class Dog(Animal): def speak(self): print(f"{self.name} 汪汪叫") dog = Dog("狗") dog.speak() 


Python面向对象

PyMySQL是一个纯Python实现的MySQL客户端库，支持兼容Python 3，用于代替MySQLdb。

## select查询数据

    import pymysql
    第一步：建立连接
    conn = pymysql.connect(
    host="192.168.2.0",
    port=3306,
    user="test",
    passwd="",
    database="test",
    charset="utf8mb4",
    )
    try:
    # 第二步：获取游标（字典型游标）
    with conn.cursor() as cursor:
    # 第三步：执行SQL，返回受影响行数
    sql = "select * from aaa"
    rows = cursor.execute(sql)
    print("受影响行数:", rows)
        # 第四步：通过游标抓取数据
        for row in iter(cursor.fetchall()):
            print(row)
    
    except pymysql.MySQLError as err:
    print(err)
    finally:
    # 第五步：关闭连接
    conn.close()

## insert插入数据

    import pymysql
    第一步：建立连接
    conn = pymysql.connect(host='', port=3306,
    user='', passwd='',
    database='', charset='utf8mb4')
    try:
    # 第二步：获取游标
    with conn.cursor() as cursor:
    # 第三步：执行SQL
    affected_rows = cursor.execute(
    'insert into tb values (%s, %s)',
    (10, '姓名')
    )
    if affected_rows == 1:
    print('插入成功！')
    # 第四步：提交
    conn.commit()
    
    except pymysql.MySQLError as err:
    print(err)
    # 第四步：回滚
    conn.rollback()
    finally:
    # 第五步：关闭连接
    conn.close()

## update修改数据

    import pymysql
    conn = pymysql.connect(
    host="", port=3306, user="", passwd="", database="", charset="utf8mb4"
    )
    sql = "update table set name=%s where id=%s"
    data = ("张三", 3)
    cursor = conn.cursor()
    cursor.execute(sql, data)
    conn.commit()
    cursor.close()
    conn.close()

## delete删除数据

    import pymysql
    conn = pymysql.connect(
    host="", port=3306, user="", passwd="", database="", charset="utf8mb4"
    )
    sql = "delete from table where id=%s"
    data = (3,)
    cursor = conn.cursor()
    cursor.execute(sql, data)
    conn.commit()
    cursor.close()
    conn.close()

## 类写法

    import pymysql
    定义数据库相关配置项
    DB_CONFIG = {
    "host": "192.168.2.60",
    "port": 3306,
    "user": "test",
    "password": "xxbcw2019X",
    "database": "test",
    "charset": "utf8",
    }
    class SQLManager(object):
    def init(self):
    self.conn = None
    self.cursor = None
    self.connect()
    def connect(self):
        self.conn = pymysql.connect(
            host=DB_CONFIG[&quot;host&quot;],
            port=DB_CONFIG[&quot;port&quot;],
            user=DB_CONFIG[&quot;user&quot;],
            password=DB_CONFIG[&quot;password&quot;],
            db=DB_CONFIG[&quot;database&quot;],
            charset=DB_CONFIG[&quot;charset&quot;],
        )
        self.cursor = self.conn.cursor()
    
    def get_all(self, sql, *args):
        &quot;&quot;&quot;查询数据&quot;&quot;&quot;
        self.cursor.execute(sql, *args)
        return self.cursor.fetchall()
    
    def update_tb(self, sql, *args):
        self.cursor.execute(sql, *args)
        self.conn.commit()
    
    def insert_into(self, sql, *args):
        self.cursor.execute(sql, *args)
        self.conn.commit()
    
    def __del__(self):
        &quot;&quot;&quot;关闭游标和数据库连接&quot;&quot;&quot;
        self.cursor.close()
        self.conn.close()
    
    if name == "main":
    db = SQLManager()
    sql = "select drug,name from test where drug=%s and name=%s order by name"
    results = db.get_all(sql, ("drug", "name"))
    print(results)


Python连接MySQL数据库

    import requests
    from bs4 import BeautifulSoup
    import json
    import os
    
    url = "https://book.douban.com/top250"
    header = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36"}
    
    def getHTML(num):
        r = requests.get(url, headers=header, params={"start": num})
        return r.text
    
    ## 定义方法存储一个网页页面数据
    def getListData(html):
        booklist = []
        soup = BeautifulSoup(html, "lxml")
        books = soup.select("tr")
        for book in books:
            bookdic = {}
            tds = book.select("td")
            bookdic["书名"] = tds[1].div.a.text.strip().split("n")[0]
            bookdic["书籍详情"] = tds[0].a.get("href")
            bookdic["封面"] = tds[0].img.get("src")
            bookdic["出版信息"] = tds[1].p.text
            spans = tds[1].select("span[class]")
            bookdic["评分"] = spans[1].text
            bookdic["评论人数"] = spans[2].text.replace("(", "").replace(")", "").strip()
            if len(spans) == 4:
                bookdic["备注"] = spans[3].text
            booklist.append(bookdic)
        return booklist
    
    ## 存储所有网页页面数据
    allbooks = []
    for i in range(10):
        html = getHTML(i * 25)
        page = getListData(html)
        allbooks.extend(page)
    
    ## 定义方法将数据保存为json文件
    def saveJson(dic, path, filename):
        jData = json.dumps(dic, indent=2, ensure_ascii=False)
        if not os.path.exists(path):
            os.makedirs(path)
        with open(path + filename, "w", encoding="utf-8") as f:
            f.write(jData)
    
    ## 调用方法将数据保存在mdata目录下douban250.json文件中
    saveJson(allbooks, "mdata/", "douban250.json")


Python爬取豆瓣读书TOP250

## Excel导入数据到MySQL

    import pymysql
    import openpyxl
    wb = openpyxl.load_workbook('员工表.xlsx')
    ws = wb.active
    params = []
    for row_idx in range(2, ws.max_row + 1):
    values = []
    for col_idx in range(1, ws.max_column):
    values.append(ws.cell(row_idx, col_idx).value)
    params.append(values)
    conn = pymysql.connect(host='', port=3306,
    user='', passwd='',
    database='', charset='utf8mb4')
    try:
    with conn.cursor() as cursor:
    # 批量插入操作
    cursor.executemany(
    'inser into tb (no, name) values (%s, %s)',
    params
    )
    conn.commit()
    except pymysql.MySQLError as err:
    print(err)
    conn.rollback()
    finally:
    conn.close()

## MySQL导出数据到Excel

    import pymysql
    import openpyxl
    conn = pymysql.connect(host='', port=3306,
    user='', passwd='',
    database='', charset='utf8mb4')
    try:
    with conn.cursor() as cursor:
    cursor.execute(
    'select no from tb'
    )
    wb = openpyxl.Workbook()
    ws = wb.active
    title = ('工号', '姓名')
    for col_idx, col_name in enumerate(title):
    ws.cell(1, col_idx + 1, col_name)
    for row_idx, row in enumerate(cursor.fetchall()):
    for col_idx, col_value in enumerate(row):
    ws.cell(row_idx + 2, col_idx + 1, col_value)
    wb.save('员工表.xlsx')
    except pymysql.MySQLError as err:
    print(err)
    finally:
    conn.close()


Python实现Excel与MySQL数据库导入导出数据

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。