众所周知，Python 是动态类型语言，运行时不需要指定变量类型。这一点是不会改变的，但是2015年9月创始人 Guido van Rossum 在 Python 3.5 引入了一个类型系统，允许开发者指定变量类型–类型提示（Type Hints）。它的主要作用是方便开发，供IDE 和各种开发工具使用，对代码运行不产生影响，运行时会过滤类型信息。
 
 
主要优点如下：
 
1、易于理解代码
 指定函数输入和输出，便于理解代码片段的过程。永远记住你阅读的代码，比你写的代码要多得多。
 有了类型提示（Type Hints），在调用函数时就可以告诉你需要传递哪些参数类型；以及需要扩展/修改函数时，也会告诉你输入和输出所需要的数据类型。 例如，想象一下以下这个发送请求的函数，
 
def send_request(request_data : Any,
                 headers: Optional[Dict[str, str]],
                 user_id: Optional[UserId] = None,
                 as_json: bool = True):
    ...
 
只看这个函数签名，我们就可以知道：
 
request_data可以是任何数据
header的内容是一个可选的字符串字典
UserId是可选的（默认为None），或者是符合编码UserId的任何数据
as_json需要始终是一个布尔值（本质上是一个flag，即使名称可能没有提供这种提示）
 
而类型提示系统可以将类型信息从文档中移动到更加接近函数的接口，然后以一个明确定义的方式来声明复杂的类型要求。同时，构建linters，并在每次更改代码后运行它们，可以检查这些类型提示约束，确保它们永远不会过时。
 
2、 易于重构
 类型提示可以在重构时，更好得帮助我们定位类的位置。
 
虽然许多IDE现在采用一些启发式方法提供了这项功能，但是类型提示可以使IDE具有100%的检测准确率，并定位到类的位置。这样可以更平滑，更准确地检测变量类型在代码中的运行方式。
 
请记住，虽然动态类型意味着任何变量都可以成为任何类型，但是所有变量在所有时间中都应只有一种类型。类型系统仍然是编程的核心组件，想想那些使用isinstance判断变量类型、应用逻辑所浪费的时间吧。
 3、 易于使用库
 使用类型提示意味着IDE可以拥有更准确、更智能的建议引擎。当调用自动完成时，IDE会完全放心地知道对象上有哪些方法/属性可用。此外，如果用户尝试调用不存在的内容或传递不正确类型的参数，IDE可以立即警告它。
 4、验证运行数据
 类型标注（Type annotations）是一种直接的方式，并且是类型文档中最常见到的那种方式。
 
使用：语句将信息附加到变量或函数参数中。，
 ->运算符用于将信息附加到函数/方法的返回值中。
 
好处：
 这是实现类型提示的规范方式，这意味着是类型提示中最干净的一种方式。
 因为类型信息附加在代码的右侧，这样我们可以立刻明晰类型。
 
缺点：
 它不向后兼容。至少需要Python 3.6才能使用它。
 强制你导入所有类型依赖项，即使它们根本不在运行时使用。
 在类型提示中，会使用到复合类型，例如List[int]。而为了构造这些复杂类型，解释器在首次加载此文件时需要执行一些操作。
 
 
类型标注的使用
 
类型标注（Type annotations）是一种直接的方式，并且是类型文档中最常见到的那种方式。
 声明一个函数参数的类型，只要在参数名称的后面加个":“号，带上类型名称就行了。声明函数的返回值类型，只要在函数声明结束之前，也就是”:“号之前加入一个”->"，带上类型名称。
 常见数据类型
 
int,long,float: 整型,长整形,浮点型
bool,str: 布尔型，字符串类型
List, Tuple, Dict, Set:列表，元组，字典, 集合
Iterable,Iterator:可迭代类型，迭代器类型
Generator：生成器类型
 
1) 基本数据类型
 
def test(a:int, b:str) -> str:
    print(a, b)
    return 1000

if __name__ == '__main__':
    test('test', 'abc')
 
函数test，a:int 指定了输入参数a为int类型，b:str b为str类型，-> str 返回值为srt类型。
 
可以看到，在方法中，我们最终返回了一个int，此时pycharm就会有警告；
 当我们在调用这个方法时，参数a我们输入的是字符串，此时也会有警告；
 
但非常重要的一点是，pycharm只是提出了警告，但实际上运行是不会报错，毕竟python的本质还是动态语言
 2）复杂的类型标注
 示例1
 
from typing import List
Vector = List[float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]

# typechecks; a list of floats qualifies as a Vector.
new_vector = scale(2.0, [1.0, -4.2, 5.4])
 
示例2
 
from typing import Dict, Tuple, Sequence

ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]

def broadcast_message(message: str, servers: Sequence[Server]) -> None:
    ...

# The static type checker will treat the previous type signature as
# being exactly equivalent to this one.
def broadcast_message(
    message: str,
    servers: Sequence[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:
    ...
):
    ...
 
这里需要注意，元组这个类型是比较特殊的，因为它是不可变的。
 所以，当我们指定Tuple[str, str]时，就只能传入长度为2，并且元组中的所有元素都是str类型
 
3) 泛型指定
 
from typing import Sequence, TypeVar, Union

T = TypeVar('T')      # Declare type variable

def first(l: Sequence[T]) -> T:   # Generic function
    return l[0]

T = TypeVar('T')  # Can be anything
A = TypeVar('A', str, bytes)  # Must be str or bytes
A = Union[str, None] # Must be str or None
 
创建变量时类型指定
 
from typing import NamedTuple

class Employee(NamedTuple):
    name: str
    id: int = 3

employee = Employee('Guido')
assert employee.id == 3
 
4) 参数注释
 
def send_mail(sender:      "fish@example.com",
              receiver:    "panda@example.com",
              subject:     "say hello to you.",
              message:     "hello.",
              attachments: list("type<io.BytesIO>")
              ) -> bool:
    pass
创建变量时类型指定
 
写在":“号后面的并一定是一个类型。Python把这种写法称为"annotations”(标注)，在运行的时候完全不使用它。它是专门设计出来给程序员和自动处理程序看的。任何可被计算出来的东西都可以写在那里。
 很明显，与直接写类型相比，直接把参数是什么样子写出来更容易让调用者看清楚函数的使用方法。更激进的话，标注还可以是被计算出来的。比如下面这个例子：
 
def add_matrix3x3(x: [(1, 1, 1), (1, 1, 1), (1, 1, 1)],
                  y: [(2, 2, 2), (2, 2, 2), (2, 2, 2)],
                 ) ->[(3, 3, 3), (3, 3, 3), (3, 3, 3)]:
    pass
 
*不足之处
 示例
 
from typing import List

def test(b: List[int]) -> str:
    print(b)
    return 'test'


if __name__ == '__main__':
    test([1, 'a'])
 
从这个例子可以看出来，虽然我们指定了List[int]即由int组成的列表，但是，实际中，只要这个列表中存在int（其他的可以为任何类型），就不会出现警告
 
 
 
参考文章
 1、https://sikasjc.github.io/2018/07/14/type-hint-in-python/
 2、https://docs.python.org/zh-cn/3/library/typing.html
 3、https://hgoldfish.com/blogs/article/83/
 

 
HTTP 参数类型简介
 
请求头参数 （head）
路径参数 （path）
查询参数 （query）
请求体参数 （body）

 
http协议 传参类型 根据参数所在协议位置可分为 四大类
 
请求头参数 （head）
 
请求头参数顾名思义，是存放在请求头中发送给服务器的参数，服务器通过解析请求头获取参数内容。通常会存放本次请求的基本设置，以帮助服务器理解并解析本次请求的body体。
 参数形式如：
 
Accept-Language : zh-CN,zh;q=0.8,zh-TW;q=0.5,en-US;q=0.3,en;q=0.2
 
其中 Accept-Language 为参数名称 :号后面紧跟请求的值。
 
 
 
ps:如上则表示本次请求的语言为中文和英文。 q用来标识语种权重 值在 0-1之间
 服务器根据会这个请求头选择返回的语言
 
 
其他http协议中规定的参数及含义请参考 http请求头规范
 
当然我们也可以自定义请求头内容，参数名称和参数意义必须事先和服务器约定好否则没服务器无法理解你传输请求头的意义会忽略自定义参数。
 其中 jQuery 添加请求头方式如下：
 
$.ajax({
          headers: {
              'Access-Token':$.cookie('access_token')
          }
      })
 
 
 
ps:cookies 是存放在每一条请求中的请求头上的特殊存储体 由于每次请求都会将全部cookies发送给服务器 所以不建议在cookies存储大量数据 ，也因此产生了session 技术，不过这是题外话了。
 
 
路径参数 （path）
 
路径参数顾名思义，本次请求的资源路径,紧跟请求域名的后面，服务器通过解析路径参数获取资源位置。路径参数是用/分隔的一系列字符串，其意义在于对服务器资源进行统一定位，如：
 
http://www.madmk.com/office/zhangsan
 
其中 /office/zhangsan 便是路径参数，其含义可解释为 找办公室里的张三，大多数情况下路径参数会代表服务器真实的文件路径。
 
 
 
REST API的兴起赋予了路径参数更为广阔的含义，有兴趣的朋友可以找一下有关 REST API 设计的文章。
 
 
 
 
ps:其中参数如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。
 
 
查询参数 （query）
 
查询参数，是房放在请求地址后面的参数同样以键值对进行标识形如：
 
userId=1
 
其中 userId 表示参数名称 1表示参数的值。参数名称为可重复的。
 请求地址与参数之间用?进行分隔 多个参数之间用 &进行分隔，完整请求如下：
 
http://www.madmk.com/a/b/c?userId=1&userId=1&age=18&sex=男
 
大多数情况下使用 查询参数 进行传值的是GET请求，所有用表单提交的GET请求都会使用 查询参数 进行传参。
 
 
 
ps:其中参数如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。
 
 
请求体参数 （body）
 
请求体参数顾名思义，是存放在请求体中发送给服务器的参数。请求体参数格式复杂多变，服务器会先根据请求头中的 Content-Type 获取其格式，然后再根据其格式进行解析，常见的格式如下：
 
Content-Type值
内容格式
消息示例
application/from
表单传值，也是默认的解析形式,服务器会对表单进行解析
userId=1&userId=1&age=18&sex=男
text/plain
文本值，服务器会将本次请求的请求体当作普通字符串看待
Hello world
application/json
json,服务器会将请求体进行json解析，获取参数
{“userId”:1,“sex”:“男”}
application/xml
xml,服务器会将请求体进行xml解析，获取参数
参见 xml 标准格式
text/html
html,服务器会将请求体进行html解析，获取参数
参见 html 标准格式
 
 
ps:其中application/from类型如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。
 
 
类似的还有很多这里不一一列举。有兴趣可以翻一下，Content-Type介绍

 
文章目录
 
模板参数类型
整数模板参数
函数指针模板参数
指针及引用模板参数
成员函数指针模板参数
模板型模板参数
 


 这是《深入实践C++模板编程》第三章“模板参数类型详解”的读书笔记。
 
模板参数类型
 
模板参数通常表示类型，表示类型的模板参数称为类型模板参数（type template parameter）;此外还有非类型模板参数（non-type template parameter），非类型模板参数包含以下四种类型：
 
整数及枚举类型
指针（对象指针或函数指针）
引用（对象引用或函数引用）
指向类对象成员函数的指针
 
模板的参数还可以是一个模板，叫做模板模板参数（template template parameter）。这些类型的模板参数都可以同时出现在模板参数列表中。
 
整数模板参数
 
非类型模板参数的作用，是为函数模板或类模板预定义一些常量。这些常量的值在编译期已知，所有模板实例中，都有相同的值。例如一个固定长度的数据类
 
#include <iostream>
#include <stdexcept>

template<typename T, unsigned size>
class array {
    T elems[size];
 public:
    T& operator[] (unsigned i) throw (std::out_of_range) {
        if (i >= size) {
            throw std::out_of_range("array access out of range.");
        }
        else return elems[i];
    }
};

int main(int argc, char* argv[]) {
    array<char, 20> array0;
    array<char, 10> array1;

    array0[10] = 'b';

    try {
        array1[10] = 'b';
    }
    catch (std::out_of_range& e) {
        std::cerr << "Access out of range." << std::endl;
    }
    return 0;
}
 
函数指针模板参数
 
函数指针通常用于实现回调。函数指针模板参数也可以用于实现回调，只不过普通函数指针的回调函数可以在运行期确定，函数指针作为模板参数时，要在编译期确定。
 
#include <iostream>

template<typename T, void (*f) (T &v)>
void foreach(T array[], unsigned size) {
    for (unsigned i = 0; i < size; ++i)
        f(array[i]);
}

template<typename T>
void inc(T &v) {
    ++v;
}

template<typename T>
void dec(T &v) {
    --v;
}

template<typename T>
void print(T& v) {
    std::cout<< ' ' << v;
}

int main(int argc, char* argv[]) {
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8};

    foreach<int, print<int>>(array, 8);
    std::cout << std::endl;

    foreach<int, inc<int>>(array, 8);
    foreach<int, print<int>>(array, 8);
    std::cout << std::endl;

    foreach<int, dec<int>>(array, 8);
    foreach<int, print<int>>(array, 8);
    std::cout << std::endl;
    return 0;
}
 
指针及引用模板参数
 
指针和引用作为模板参数时，相当于为函数或对象声明一个常量指针或引用。因为模板参数是在编译期确定的，所以只有全局变量/外部变量(extern修饰)/类的静态变量的指针或引用才可以作为模板参数。
 
#include <iostream>

template<int *p>
struct wrapper {
    int get() {
        return *p;
    }
    void set(int v) {
        *p = v;
    }
};

template<int &p>
struct wrapper2 {
    int get() {
        return p;
    }
    void set(int v) {
        p = v;
    }
};

int main(int argc, char* argv[]) {
	int global_variable = 0;
 	wrapper<&global_variable> gwrapper;
    gwrapper.set(1);
    std:: cout << gwrapper.get() << std::endl;

    wrapper2<global_variable> gwrapper2;
    gwrapper2.set(2);
    std::cout<< gwrapper2.get() << std::endl;

    return 0;
}
 
成员函数指针模板参数
 
成员函数指针作为函数模板参数时，和普通函数指针类型，只是声明方法看上去难理解。例如类some_class有多个函数，参数都为int，返回值也为int，那么指向这些成员函数的指针可以声明为
 
int (some_class:: *mfp)(int);
 
可以用typedef定义别名，精简一下
 
typedef int (some_class:* some_class_mfp)(int);
some_class_mfp mfp;
 
使用成员函数指针调用函数时，要用到操作符*.和->。这两个操作符优先级比较低，通常需要用括号括起来。例如：
 
some_class a;
std::cout << (a.*mfp)(0) << std::endl;

some_class *p(&a);
std::cout << (p->*mfp)(0) << std::endl;
 
下面示例为一个some_class类包含3个成员函数add_by,sub_by,mul_by，分别对成员变量value进行对应操作。
 
#include <iostream>
class some_value {
    int value;
 public:
    some_value(int _value): value(_value) {}
    int add_by(int op) { return value += op;}
    int sub_by(int op) { return value -= op;}
    int mul_by(int op) { return value *= op;}
};

int main(int argc, char* argv[]) {
    some_value v0(0);
    std::cout<< call<&some_value::add_by>(v0, 1) << std::endl;
    std::cout<< call<&some_value::sub_by>(v0, 2) << std::endl;
    std::cout<< call<&some_value::mul_by>(v0, 3) << std::endl;

    return 0;
}
 
需要注意的是，在取成员函数指针是，取地址符&不能省略。
 
模板型模板参数
 
模板型模板参数只是，模板的参数是另外一个模板。声明形式类似：
 
template<typename T, template<typename TT0, typename TT1> class A>
struct Foo {A<T, T> bar;};
 
上面声明中的第二个模板参数A是一个类模板。注意声明中要用到关键字class。只有类模板可以作为模板参数。
 
在函数指针模板参数的例子中，有
 
foreach<int, print<int>> (array, 8);
foreach<int, inc<int>> (array, 8);
foreach<int, dec<int>> (array, 8);
 
上面都将int重复两遍有点冗余。三个函数print,inc,dec都是函数模板。可以用带参数的模板传入，在foreach内进行实例化即可。只是需要将三个函数模板修改为类模板。
 
#include <iostream>

template<template<typename TT> class Func, typename T>
void foreach(T array[], unsigned size) {
    Func<T> func;
    for (unsigned i = 0; i < size; ++i)
        func(array[i]);
}

template<typename T>
struct inc {
    void operator() (T &v) const {++v;}
};

template<typename T>
struct dec {
    void operator() (T &v) const {--v;}
};

template<typename T>
struct print {
    void operator() (T &v) const { std::cout << " " << v;}
};

int main(int argc, char* argv[]) {
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8};
    foreach<print>(array, 8);
    std::cout << std::endl;

    foreach<inc>(array, 8);
    foreach<print>(array, 8);
    std::cout << std::endl;

    foreach<dec>(array, 8);
    foreach<print>(array, 8);
    std::cout << std::endl;

    return 0;
}

 
 
总结 python 函数中的不同参数类型的使用方法。
 
 
在调用函数时，通常会传递参数，函数内部的代码保持不变，针对 不同的参数 处理 不同的数据。
 
有位置传参、关键字传参、默认值参数、多值参数等。
 
1、参数传递
 
形参和实参：
 
形参：定义 函数时的 参数变量
实参：调用 函数时，使用的参数变量
 
参数传递的过程，就是 把实参的引用 传递给 形参  ，使用实参的值来执行函数体的过程。
 
在 Python 中，函数的 实参/返回值 都是是靠 引用 来传递来的
 
2、位置实参
 
按照参数位置，依次传递参数，这是最普通的方式。
 
def location(a, b)
    print(a + b)

location(3, 9)
"调用函数时，按顺序传递参数，3 传给 a，9 传给 b"
 
3、关键字实参
 
如果不想严格按照顺序传递参数，也可以按关键字传递。
 
def location(a, b)
    print(a + b)

location(b = 3, a = 9)
"调用函数时，按关键字传递参数，3 传给 b，9 传给 a"
 
4、缺省参数
 
定义函数时，可以给 某个参数 赋值一个默认值，具有默认值的参数就叫做 缺省参数
 
调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用 参数默认值
将常见的值设置为参数的缺省值，从而 简化函数的调用 
  
要使用 最常见的值 作为默认值
如果一个参数的值 不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！
 
 
例如：对列表排序的方法
 
gl_num_list = [6, 3, 9]

"默认就是升序排序，因为这种应用需求更多"
gl_num_list.sort()
print(gl_num_list)

"只有当需要降序排序时，才需要传递 'reverse' 参数"
gl_num_list.sort(reverse=True)
print(gl_num_list)
 
缺省参数的定义位置：
 
必须保证带有默认值的缺省参数在参数列表末尾！ 
 
调用带有多个缺省参数的函数：
 
在 调用函数时，如果有 多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！
 
def print_info(name, title="", gender=True):
    gender_text = "男生"

    if not gender:
        gender_text = "女生"

    print("%s%s 是 %s" % (title, name, gender_text))


# 提示：在指定缺省参数的默认值时，应该使用最常见的值作为默认值！
print_info("小明")
print_info("老王", title="班长")
print_info("小美", gender=False)
 
5、多值参数
 
当函数需要处理的参数个数不确定时，可使用 多值参数。
 
python 中有两种多值参数：
 
接收 元组：参数名前加 一个 *
接收 字典：参数名前加 两个 *
 
一般在给多值参数命名时，习惯使用以下两个名字
 
*args — 存放 元组 参数
**kwargs — 存放 字典 参数，（kw 即 keyword，kwargs 即 键值对参数）
 
def demo(num, *args, **kwargs):

    print(num)
    print(args)
    print(kwargs)

demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)

输出：
1
(2, 3, 4, 5)
{'name': '小明', 'age': 18, 'gender': True}
 
拆包
 
在上面多值参数传递时，实际上使用了拆包功能。
 
拆包主要用于元组和字典参数的传递。
 
在调用带有多值参数的函数时，使用拆包简化参数的传递：
 
直接将一个 元组变量 实参传递给元组形参 args 
  
在 元组变量前，加 *
 
直接将一个 字典变量 实参传递给字典形参 kwargs 
  
在 字典变量前，加 **
 
 
def demo(*args, **kwargs):

    print(args)
    print(kwargs)

gl_nums = (1, 2, 3)
gl_xiaoming = {"name": "小明", "age": 18}

"变量名前必须要加 * 号，否则不能无法正常拆包"

"错误演示（不加 * 号）："
demo(gl_nums, gl_xiaoming)
输出：
((1, 2, 3), {'name': '小明', 'age': 18})
{}

"正确演示（加 * 号）："
demo(*gl_nums, **gl_xiaoming)
输出：
(1, 2, 3)
{'name': '小明', 'age': 18}