精华内容
下载资源
问答
  • 众所周知,Python 是动态类型语言,运行时不需要指定变量类型。这一点是不会改变的,但是2015年9月创始人 Guido van Rossum 在 Python 3.5 引入了一个类型系统,允许开发者指定变量类型类型提示(Type Hints)。它...

    众所周知,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 参数类型简介

    千次阅读 2019-07-25 11:17:34
    HTTP 参数类型简介请求头参数 (head)路径参数 (path)查询参数 (query)请求体参数 (body) http协议 传参类型 根据参数所在协议位置可分为 四大类 请求头参数 (head) 请求头参数顾名思义,是存放在请求头...

    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/jsonjson,服务器会将请求体进行json解析,获取参数{“userId”:1,“sex”:“男”}
    application/xmlxml,服务器会将请求体进行xml解析,获取参数参见 xml 标准格式
    text/htmlhtml,服务器会将请求体进行html解析,获取参数参见 html 标准格式

    ps:其中application/from类型如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。

    类似的还有很多这里不一一列举。有兴趣可以翻一下,Content-Type介绍

    展开全文
  • 模板参数类型

    千次阅读 2018-09-24 22:26:36
    文章目录模板参数类型整数模板参数函数指针模板参数指针及引用模板参数成员函数指针模板参数模板型模板参数 这是《深入实践C++模板编程》第三章“模板参数类型详解”的读书笔记。 模板参数类型 模板参数通常表示类型...


    这是《深入实践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函数的4种参数类型

    万次阅读 多人点赞 2019-06-29 16:18:16
    总结 python 函数中的不同参数类型的使用方法。 在调用函数时,通常会传递参数,函数内部的代码保持不变,针对 不同的参数 处理 不同的数据。 有位置传参、关键字传参、默认值参数、多值参数等。 1、参数传递 形参...

    总结 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 — 存放 字典 参数,(kwkeywordkwargs键值对参数
    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}
    
    展开全文
  • 在上一篇文章中介绍了在Jenkinsfile中通过parameters中的choice(下拉框)类型获取输入参数的方法,这篇文章将会继续介绍Jenkinsfile的parameters所支持的其他物种类型的使用方式。
  • java 方法中的参数类型是类类型的

    千次阅读 2019-08-02 22:03:09
    今天做作业遇到方法中的参数类型是类类型的;有点懵。所以上网查了一些资料,并且和参数类型是基本数据类型的比较了一下。 1方法参数类型是基本数据类型的: public void test(int a) { a=6; System.err.println...
  • python限制参数类型

    千次阅读 2019-12-09 17:34:15
    welcome to my blog ...python3.5支持限制参数类型了 下面的示例表示,name需要是str类型的, greeting()的返回值是str类型的 def greeting(name: str) -> str: return 'Hello ' + name 官方文档链接 ...
  • python 参数类型

    千次阅读 2019-05-28 22:20:12
    文章目录1、简介2、必须...python 常见类型 2、必须参数 也就是我们常见的参数 def fun (name ,age): print(name + " "+ str(age) ) fun ("lum",27) log: lum 27 3、默认值函数 def fun_1(name,country = "CN",s...
  • 假设要利用模板元编程获取位于index的参数的类型: template&... // FuntionType的返回值类型和参数类型? }; int f(int, short, float); static_assert(is_same_v&amp;lt;decltype(f), int(int...
  • c++11模板:获取函数的参数类型

    千次阅读 2019-02-23 12:55:18
    假设我们已经知道一个函数类型的定义double(unsigned char*, unsigned char*),如何获取这个函数定义中的输入和输出参数类型呢? c++11提供的模板函数std::function和std::tuple_element可以将一个函数定义的输入和...
  • jmeter 请求参数类型

    千次阅读 2019-08-15 16:34:07
    这篇我们要讲的是,如何填写参数,什么时候用,填写的过程中会遇到哪些坑,我们知道我们参数一般填写在(下图标红)这些地方,那我们如何避免踩坑? 1.先来说说参数参数是按键:值对来填的。学过代码都知道这是...
  • python-函数参数类型检查

    千次阅读 2019-04-24 15:08:56
    python在3.5后引入了参数类型注解,例: def add(x:int,y:int)->int:#对x,y和返回值都进行注释,为int类型 return x + y 注:注解是对函数参数和返回值的‘注释’,没有强制定义的作用(因为python是动态语言啊...
  • IntelliJ IDEA 提示参数类型

    千次阅读 2019-09-19 22:26:12
    在需要输入参数的地方按ctrl+P
  • Switch的参数类型

    千次阅读 2018-06-13 21:25:15
    昨天面试问了一个java的基础问题:switch中参数类型可以有哪些?平时虽然有用过,但真没怎么注意switch中参数的类型。然后就随便蒙了一个答案,答对了。今天就对switch分析一下。在jdk1.7版本以前,参数类型只能是...
  • MyBatis的parameterType传入参数类型

    万次阅读 2018-06-05 11:42:39
    在mybatis映射接口的配置中,有select,insert,update,delete等元素都提到了parameterType的用法,parameterType为输入参数,在配置的时候,配置相应的输入参数类型即可。parameterType有基本数据类型和复杂的数据类型...
  • interface ResolveData { (): void; } interface fn{ (arr: ResolveData): void } function filterFn (val: string, update: fn) { update(() =>... tempaltes.value.data = temps.value.data.filter...
  • switch的参数类型

    千次阅读 2018-09-29 21:09:58
    switch(expr1)中,expr1是一个整数表达式, 整数表达式可以是int基本类型或integer包装类型,由于byte,short,char都可以隐士转换成int类型,所以,这些类型,以及这些类型的包装类型也是可以的。因此传递给...
  • HTTP接口的请求参数类型有哪些

    千次阅读 2019-11-14 17:14:32
    get post put delete 二、类型: (1)查询字符串参数(Query String Parameters参数) 一般用于GET请求,会以url string的形式进行传递 ...一般用于POST请求,可以使用Content-Type来指定不同参数类型
  • TS基础之(二)函数声明及参数类型

    千次阅读 2020-08-31 18:01:35
    void类型 void即返回值;void表示没有返回值 function run():void{ console.log(123) }; function main():number{ return 123; } 参数传递方式 默认参数、可选参数 function run(str:string
  • 在我们使用Vue中 path + query 方式传参的时候,这里存在一些坑或者说是现象(参数类型因为刷新而变化),记录一下,供大家学习。 二、使用场景 我们在使用Vue中 path + query 方式传参的时候,可以使用参数中的某...
  • mysql存储过程 变量和参数类型

    万次阅读 2018-03-27 10:23:04
    4.如果既需要传入,同时需要传输,则可以使用INOUT参数类型 存储过程的可变参数 INOUT 需求:调用存储过程时 ,参数user_id和user_name既是传入,也是传出参数 delimiter $$ create procedure teste(INOUT user_id1 ...
  • 后端接受前端的参数类型

    千次阅读 2018-06-18 22:46:47
    一、普通的键值对参数:get请求实质也是键值对的形式二、list传值也可以把list对象放到对象里面三、Map类型或实体类类型传值,即json格式传值实体类接受的参数,可以其中的一个,也可以是全部的参数,,即有什么字段...
  • python函数传参时的参数类型判断

    千次阅读 2019-04-27 13:11:15
    # 实参中的K与形参中的K是一样的,K一样,只要进行value的类型判断即可 raise TypeError ( "you must input {}" . format ( params [ k ] . annotation ) ) cc = fn ( * args , ** kwargs ) return cc ...
  • 我们用实体类接收, 如: 也可以使用Map来接收 : 好了就到此,为什么要发这个文章,因为今天公司有伙伴在对数组参数的传递接收发问,我觉得有必要给一些伙伴普及一下这些普遍的处理协调参数为数组类型的接口方式。...
  • flask获取参数类型和请求响应

    千次阅读 2018-05-15 19:53:39
    flask重要的两种请求: ...(1)GET请求的的参数类型: str(默认) int float path uuid # 没规定,默认(str) @blue.route('/hello/&lt;name&gt;/') def hello_mian(name): return 'hello %s' % (na...
  • ^ HINT: 没有匹配指定名称和参数类型的函数. 您也许需要增加明确的类型转换. 解决办法:把下面一段代码放到数据库执行执行一下就行 CREATE OR REPLACE FUNCTION pgsql_type(a_type varchar) RETURNS varchar AS $...
  • Python函数参数类型

    万次阅读 2017-01-07 21:44:34
    普通参数,默认参数,可变参数(可变位置参数,可变关键字参数),keyword-only 参数 调用函数(传参): 位置参数,关键字参数参数结构(位置参数解构,关键字参数解构) 普通参数 x,y: def add(x,y)  ...
  • 2018年3月23日11:43:06 using System.Reflection //取得YourClassName中的名称为foo的方法 Type className = Type(YourClassName) .../*取得方法的参数个数、参数类型和名称、返回值类型*/ ...
  • 1,传递基本类型参数,请看下面例子 function addNum(num) { num + = 10; return num; } var count = 20; var result = addTen(count); alert(count); //20, not change alert(result); //30 在调用函数...
  • golang 传入函数作为参数类型

    千次阅读 2018-12-21 08:57:58
    package main import "fmt" #############################################################################################...可以这样定义函数格式的类型,即相同输入输出值的函数都为此类型   ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,054,568
精华内容 1,621,827
关键字:

参数类型