精华内容
下载资源
问答
  • 01-去掉列表或者元组中重复的元素 一 在python中如何定义集合集合与列表有何区别 二 如何去掉列表(元组)中重复的元素 答 一 a = [1,2,3] #列表 ...把列表(元组转换成集合,再转换回去 例如...

    01-去掉列表或者元组中重复的元素

    一 在python中如何定义集合,集合与列表有何区别
    二 如何去掉列表(元组)中重复的元素
    
    答
    一
    a = [1,2,3] #列表
    b = (1,2,3) #元组
    c = {1,2,3} #集合
    
    集合和列表区别:
    1.列表可以有重复元素,集合没有重复元素
    2.集合中的元素和顺序无关,列表中的元素和顺序有关
    
    二
    把列表(元组)转换成集合,再转换回去
    例如:
    a = [1,3,3,3,4]
    b = list(set(a))

    02-集合的并集与交集

    一 如何向集合中添加或者删除元素,需要注意什么
    二 如何求集合之间的并、交,集合之间还有什么操作
    
    答:
    一
    1.添加是add()函数,删除是remove()函数
    例如:x={1,3,4,5}
    x.add(2)
    x.remove(1)
    2.进行删除操作时要先判断在集合里存不存在这个元素
    例如:
    if x.__contains__(1):
        x.remove(1)
    else:
        pass
    
    二
    1.并集:x1 | x2 或者 x1.union(x2)
      交集:x1 & x2 或者 x1.intersection(x2)
    2.x1.difference(x2) #x1中有,而x2中没有的
      x1 ^ x2   #刨除x1和x2共有的元素

    03-两个列表首尾相接

    一 连接两个列表的方式有哪些
    二 这些连接方式有什么区别
    
    答:
    一
    1.直接相加或者使用extend()函数,例如a.extend(b)
        元组首尾相接可以直接相加,但不能用extend
    
    2.加号不会改变原来列表的值,但extend会改变原来列表的值
      加号两边要同样的类型,extend可以连接列表和元组,但是只能元组在后面作为参数

    04-乱序列表

    一 编写一个函数打乱列表元素
    二 如何对列表元素进行随机排列
    
    答:
    一
    1.
    import random
    
    '''
    循环一百次,每次都随机互换两个数
    '''
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
    
    
    def random_list1(a):
        for i in range(0, 100):
            index1 = random.randint(0, len(a) - 1)
            index2 = random.randint(0, len(a) - 1)
            a[index1], a[index2] = a[index2], a[index1]
        return a
    
    
    b = random_list1(a)
    print(b)
    
    '''
    创建一个新的空列表,每次随机选一个出来加进去
    '''
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
    
    
    def random_list2(a):
        a_copy = a.copy()
        result = []
        for i in range(0, len(a)):
            index = random.randint(0, len(a_copy) - 1)
            result.append(a_copy[index])
            del a_copy[index]
        return result
    
    
    b = random_list2(a)
    print(b)
    
    二
    使用random.shuffle()函数
    例如
    def random_list2(a):
        random.shuffle(a)
        return a

    05-单星和双星运算符

    一 单星(*)和双星(**)运算符的作用,并举例说明
    二 请描述合并列表和合并字典的方法有哪些
    
    答:
    一
    单星(*):
        1.以元组方式导入
        2.可变参数(参数数量可变)
        3.如果可变参数不是最后一个参数,那么可变参数后面的形参指定参数值,一定要用命名参数
        例如:
        def fun1(param1, *param2,x):
            pass
        fun1(1,2,3,4,6,7,x=8)
    双星(**):
        以字典方式导入
        例如:
        def fun2(param1,**param2):
            pass
        dun2(1,a=1,b=2,c=3)
    
    二
    星号(*)和双星号(**)也能解引用
    例如:
    合并a和b
    a=[1,2,3]
    b=[4,5,6]
    c=[*a,*b]
    
    合并A和B
    A={'A':1,'B':2}
    B={'C':3,'D':4}
    C={**A,**B}

    06-快速调换字典中的key和value

    一 如何快速调换字典中的key和value
    二 如何循环快速生成一个从0到100的列表
    
    答:
    一
    D={'A':1,'B':2}
    E={v:k for k,v in D}
    
    二
    A=[i for i in range(0,101)]

    07-将两个列表(元组)合并成一个字典

    一 如何将下面两个列表合并成一个字典
        a = ["a","b"]
        b = [1,2]
        合并后:{"a":1,"b":2}
    
    答:
    一
    用zip和dict函数(先用zip压缩,接着用dict转换成字典)
    例如 dict(zip(a,b))
    
    假如:
        c = [[1,2],[3,4]]
        可以用循环先把每一维的列表合并成字典,然后append进一个列表里
        例如:
    c = [[1, 2], [3, 4]]
    a = ["a", "b"]
    r = []
    for li in c:
        d = dict(zip(a, li))
        r.append(d)
    print(r)

    08-列表和元组区别

    一 请详细描述列表和元组的区别
    
    答:
    一
    1.语法差异
        a = (1,2,3,4)   #元组
        b = [1,2,3,4]   #列表
    
    2.元组是只读的,列表是可读写的
    
    3.拷贝出来副本的性质不一样(使用tuple函数后,元组仍然为自身;使用list函数后,会复制一个新列表)
    copy_a = tuple(a)
    copy_b = list(b)
    print(copy_a is a)  #True
    print(copy_b is b)  #False
    4.大小不一样,元组比较小,因为元组使用比较大的内存块,当元素比较多时,元组速度更快
    print(a.__sizeof__())
    print(b.__sizeof__())
    

    09-如何排序一个列表

    一 对列表排序有几种方法
    二 列表的sort方法和sorted函数都可以对列表进行排序,他们有什么区别
    三 如何倒序排列一个列表
    
    答:
    一
    可以用列表自带的sort方法,也可以用sorted函数
    
    二
    sort方法是改变列表自身,sorted函数并不会改变列表本身,返回一个列表副本
    
    
    三
    降序排列(把sort方法和sorted函数的reverse属性改为true就可以了)
    例如:
        a.sort(reverse=true)
        sorted(a, reverse=true)

    10-列表元素是对象,该怎么进行排序

    一 如果列表元素是对象,对这样的列表排序有什么方法
    二 如果列表元素是对象,对这样的列表进行倒序排列的方法有哪些
    
    答:
    1.类的magic方法
    2.operator模块
    3.sort方法和sorted函数
    
    一
    1.相关magic方法有__lt__,__gt___,前期太乱就只记__lt__用法吧
    class myClass:
        def __init__(self, value):
            self.value = value
    
        def __lt__(self, other):
            return other.value > self.value
    #当满足__lt__函数的条件,使用sort方法,或者sorted函数排序时,当前类在左边,不满足magic函数时当前类在右边
    #当满足__gt__函数的条件,使用sort方法,或者sorted函数排序时,当前类在右边,不满足magic函数时当前类在左边
    2.使用operator函数
    例如:
        import operator
        a.sort(key=operator.attrgetter("value")    #参数要加双引号
        或者sorted(a,key=operator.attrgetter("value")
    
    二
    1.magic方法
    def __lt__(self, other):
        return self.value > other.value
    
    2.operater方法
    import operater
    a.sort(key=operater.attrgetter("value"),reverse=True)

    11-del和pop的区别

    一 del和pop都可以用来删除列表元素,他们有什么区别
    
    答:
    del 根据索引删除元素,并且没有返回值
        del a[2]
    pop 根据索引弹出列表元素,返回并删除该元素,
        a.pop(2)
        a.pop()  #没有指定参数时弹出列表最后一个

    12-用lambda函数对列表进行排序

    一 如果列表元素是字典,如何使用lambda表达式对列表进行升序降序排列
    
    答:
    一
    a = [
        {"name": "Mike", "age": 112},
        {"name": "Jack", "age": 23}
    ]
    print(sorted(a, key=lambda x: x["age"])) #降序后面加reverse

    13-字典键值支持的数据类型

    一 有哪些键值不能作为字典键值的数据类型
    二 为什么列表和字典类型的值不能作为字典的键值
    
    答:
    一 列表和字典不能作为字典键值
    
    二 因为字典的键值key是不能变的

    14-对产生器类型的对象使用切片

    一 如何使用切片获取产生器类型对象中的部分元素
    
    答:
    一
    其实不是很懂什么叫生成器,反正就是理解成存放大量数据时列表很耗空间,用生成器可以节省空间
    
    回到题目,itertools模块中的islice函数可以使用分片获取产生器类型对象中的部分元素
    islice函数的第一个参数是产生器,第二个参数是开始索引,第三个参数是结束索引下一个元素的索引
        from itertools import islice
        gen = iter(range(10))
        print type(gen)
        for i in islice(gen,2,6):
        print(i)

    15-将循环参数的列表变成产生器

    一 如何将【i for i in range(10)]变成产生器
    
    答:
    把方括号改为括号就好了,(i for i in range(10))
    注意里面要有for,不然就变成元组了

    16-python字典和json字符串怎么互换

    一 python字典和json字符串如何互转
    
    答:
    字典转json:
        import json
        json_str=json,dumps(d)
    json转字典:
        import json
        d = json.loads(json_str)

     

    展开全文
  • “修改”方法:如果要修改,先用list把元组转成列表,再用tuple转换成list。 或者,先生成一个tuple的拷贝(如何生成?),再按上面的方法改。 那为什么有列表还要有元组呢?元组不可变的好处。保证数据的安全,...

    元组特点

    1.有序的集合
    2.通过偏移来取数据,支持切片。(查看支持方法,只需要 dir(变量))
    3.属于不可变的对象,不能在原地修改内容,没有排序,修改等操作。

    “修改”方法:如果要修改,先用list把元组转成列表,再用tuple转换成list。
    或者,先生成一个tuple的拷贝(如何生成?),再按上面的方法改。

    那为什么有列表还要有元组呢?

    元组不可变的好处。保证数据的安全,比如我们传给一个不熟悉的方法或者数据接口,
    确保方法或者接口不会改变我们的数据从而导致程序问题。

    集合特点

    没有顺序的概念,所以不能切片or索引。

    创建集合

    分为set():可变的

    frozenset():不可变的

    如何确定一个对象是否可以迭代?dir()此对象。如果看到其中有___iter___,就说明可以迭代。

    a = set('abc')//括号里必须为可迭代对象。
    >>> b
    set(['a','c','b'])

    添加与删除操作

    添加:
    分add方法,update方法。
    前者把整体插入,后者把其迭代分块插入。(不明白自己试试!)

    删除:
    remove(要删除的元素)方法。

    成员关系

    in , not in
    判断在不在集合里
    返回一个bool值

    交集,并集,差集

    集合a,b;
    交集 : a & b
    并集:a | b
    差集 : a - b(只在a中出现的元素)

    set对list去重

    a = [1,2,3,2,3];
    b = set(a)
    a = list(b)
    展开全文
  • 提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 python基础语法 数据类型一、列表类型列表1...# 能被for循环遍历的都可以当成参数传给list()转换成列表,字典遍历的是key(for循环也是如此) res

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档



    提示:以下是本篇文章正文内容,下面案例可供参考

    一、列表类型

    列表1

    # 列表
    # 作用:按位置存放多个值
    # 定义
    l = ['a', 1]
    # 能被for循环遍历的都可以当成参数传给list()转换成列表,字典遍历的是key(for循环也是如此)
    res = list('why')
    print(res)
    
    for x in {1: 'a', 2: 'b'}:
        print(x)
    
    # 末尾追加  (修改原列表)
    li = ['a', 'b', 'cc']
    li.append('d')
    print(li)
    
    # 插入
    li.insert(1, 'nb')  # 第一个参数x,(则插在列表中索引位置为x的元素的前面),使插入的元素索引位置为x
    print(li)
    
    # extend 把列表的元素一个一个追加到另一个列表
    new_list = [1, 2, 3]
    li.extend(new_list)
    print(li)
    
    li[0] = 0
    print(li)
    
    # 删除
    #  方式1 del l[0]
    #  方式2
    l.pop()  # 根据索引删除,不给参数默认最后一个 返回所删除的值
    #  方式3
    print(l)
    l.remove('a')  # 按元素名删除 返回None
    
    # l[::-1] 整个倒过 来??????/?/?
    # 浅copy列表 列表内存地址不变
    
    # 队列:先进先出   堆栈:后进先出
    

    列表2

    # 需要掌握的操作
    
    #  ps:忌讳在for循环中改for要遍历的元素
    
    # l.clear() 清空所有元素
    
    # l.reverse() 将列表倒过来
    
    #  l.sort() 排序,且使用l.sort,列表内元素必须是同种类型才可以排序
    #  默认从小到大 ; 要从小到大 l.sort(reverse=True)
    #  (无用)字符串按ASCI码表的先后顺序(越后越大)区别大小,按对应的位置的字符依次pk 列表也可以比较,but对应位置元素类型必须相同
    

    列表模拟堆栈

    # 后进先出
    l = []
    n = int(input('几个:'))  #注意input接受后会默认转成字符串类型,不换成整型下一行会报错
    for i in range(0,n):
        la = input("输入:")
        l.append(la)
    
    #l.reverse() 加这个变成队列  之前把这个加到循环里,错了,反转了n次
    for i in range(0,n):
        x = l.pop()
        print(x, end='  ')
    
    #reverse后,三个元素的索引从012变成了210
    

    列表在内存中的存储

    x = 11
    l = ['n', 'b', x]  # l=['a'的内存地址,‘b’的内存地址,11的内存地址]
    x = 55  # 不影响列表了l
    print(l[2])
    
    d = {'a': x}  #  字典也是如此
    x = 22
    print(d['a']) #输出结果为55
    

    二、字典类型

    字典1

    # 字典
    # key:value,value可以是任意值,key必须是不可变类型(整型,浮点型,字符串),且不能重复
    
    # 数据类型转换  dict():嵌套的两层列表(元组),内层列表只有两元素转换成字典,for循环,每一项前一个当key..
    info = [
        ['name', '马牛逼'],
        ['do', '吃屎']
    ]
    info1 = dict(info)
    print(info1)
    
    # 造字典 第一种两层列表,第二种直接在dict里放x=1,x(字符型不加‘’)这里x将变成字符串类型的key
    x = 8
    d = dict(x=1, y=2, z=3)  #
    print(d)
    print(x)
    print(d['x'])
    
    # fromkeys for遍历列表作为keys,填充value
    #d = {}.fromkeys(info[0], '不错不错')
    d = {}.fromkeys(info[1], 'nbnb')
    print(d)
    
    

    字典2

    # 字典的操作
    d = dict(k1=233, k5=555,k6=666,k7=777)
    print(d)
    # 赋值操作,key存在则修改,不存在则添加
    d['k1'] = 222
    print(d)
    d['k2'] = 333
    print(d)
    
    # 删除元素
    d.pop('k1')  # 按key删除元素,返回元组 (存被删的元素)
    print(d)
    res=d.popitem()  # 随机删除,返回元组(存被删的元素)
    print(res)
    
    print('=====')
    # 取出key value items(个体) 得到列表
    print(list(d.keys()))
    print(list(d.items()))
    
    # d.clear 清空字典
    
    # d.update(key) 更新字典
    # 对于新字典的key,老字典有相同key的元素,更新为新字典的value
    # 若老字典没有此key,则此key对应元素添加到老字典
    
    # d.get()  key在字典里不存在不报错,返回None  作用也是按key取value
    print(d.get('k5'))
    res0=d.get('k10')
    print(res0)
    
    # dict.setdefault('k1',233) 若k1存在,则啥也不干,若无,则添加进字典
    d.setdefault('k1', 233)
    
    

    三、字符串类型

    字符串操作1

    # 字典的操作
    d = dict(k1=233, k5=555,k6=666,k7=777)
    print(d)
    # 赋值操作,key存在则修改,不存在则添加
    d['k1'] = 222
    print(d)
    d['k2'] = 333
    print(d)
    
    # 删除元素
    d.pop('k1')  # 按key删除元素,返回元组 (存被删的元素)
    print(d)
    res=d.popitem()  # 随机删除,返回元组(存被删的元素)
    print(res)
    
    print('=====')
    # 取出key value items(个体) 得到列表
    print(list(d.keys()))
    print(list(d.items()))
    
    # d.clear 清空字典
    
    # d.update(key) 更新字典
    # 对于新字典的key,老字典有相同key的元素,更新为新字典的value
    # 若老字典没有此key,则此key对应元素添加到老字典
    
    # d.get()  key在字典里不存在不报错,返回None  作用也是按key取value
    print(d.get('k5'))
    res0=d.get('k10')
    print(res0)
    
    # dict.setdefault('k1',233) 若k1存在,则啥也不干,若无,则添加进字典
    d.setdefault('k1', 233)
    
    

    字符串操作2

    print(res)
    res = '*'.join(l)
    print(res)
    
    #replace
    l0 = '吉你太美,吉吉'
    print(l0.replace('吉', '鸡', 2))
    
    #isdigit 判断是否由纯数字组成
    print('2333'.isdigit())
    
    #######下面不需要掌握,了解即可
    
    #find index 均是返回要查找的字符串在大字符串的起始索引值 找不到返回-1 index报错
    ms = 'nsnsnsns'
    res = ms.index('n')
    print(res)
    
    #count统计某个字符的个数
    msg=('abbb')
    print(msg.count('b'))
    
    # center ljust rjust zfill居中 左对齐 右对齐 零填充默认右对齐
    print('nb'.center(8,'*')) # 填充,第1个参数为长度
    
    # expandtabs(x)  设置制表符代表的空格数为2
    
    
    

    四、集合类型

    # 集合
    # 特点 :所有元素必须是不可变类型 无序 不重复
    # 表示 :{'a','b','c'}
    # 了解 :s={} 默认是字典
    # 类型转换
    set({1, 2, 3})  # 直接造集合
    print(set([1, 1, 1, 2, 3]))  # set 用列表造集合 自动去重
    # print(set([1, 1, 1, 2, 3, [1, 2]]))  # 报错,因为取出的元素是可变类型
    
    # 集合操作
    # 取交集 res = f1 & f2  或f1.intersection(f2)
    # 取并集 res = f1 | f2       union
    # 取差集 res = f1 - f2       difference
    # 对称差集(正反差集的并) ^  或 symmetric_difference
    # 有包含关系 则有f1 > f2(或者<) 无包含关系返回False
    #        f1>f2 还可以:f1.issuperset(f2) 或 f2.issubset(f1)
    
    f1 = {1,2,3}
    f1.discard(1)  # 删除一个元素
    print(f1)
    
    # 需要掌握的集合操作
    # f.discard(4) 元素不存在do nothing
    # f.remove(4)  不存在,报错
    # f.update(f2)  添加进去再去重
    # f.add() 单独添加某元素
    # s.isdisjoin(s1) 无交集返回True
    # f.pop() 因为没有索引序号,只能随机删
    

    五、元组类型

    #  元组 ,即不可变的列表,只能读 不能改
    #  定义,用
    t = ('a', 'b', 'c')
    
    # t=(10) 这里括号表示包含
    # t=(10,) 元组中只有一个元素时候,必须加,
    # 不可变 指元组内索引与对应的元素的内存地址的对应关系不可变  但是子的可变类型可以改值
    
    # 类型转换
    t = ['a', 'b', 'c']
    t0 = tuple(t)
    print(t0)
    
    # 操作
    # 修改的都没有
    
    

    总结

    終わりました

    展开全文
  • 嵌入式SQL(仔细研究)

    2019-09-26 15:48:33
    如何将嵌有SQL的宿主语言程序编译可执行码宿主语言和DBMS之间如何传递数据和信息数据库的查询结果一般是元组集合,这些元组须逐个赋给宿主语言程序中的变量,供其处理,其间存在转换问题两者的数据类型有时不...
    嵌入式SQL
    嵌入式SQL必须解决的问题:
    如何将嵌有SQL的宿主语言程序编译成可执行码
    宿主语言和DBMS之间如何传递数据和信息
    数据库的查询结果一般是元组的集合,这些元组须逐个赋给宿主语言程序中的变量,供其处理,其间存在转换问题
    两者的数据类型有时不完全对应或等价,需解决必要的数据类型转换问题
    嵌入式SQL的一般形式
    对宿主型数据库语言SQL,DBMS处理方法:
    预编译
    修改和扩充主语言使之能处理SQL语句
    为区分SQL语言和主语言:
    所有SQL语句都必须加前缀 EXEC  SQL;
    SQL的结束标志随主语言不同而不同。PL/1和C以分号(;)结束,COBOL中以END-EXEC结束
    例:    EXEC  SQL  DROP  TABLE  student;
    嵌入式SQL与主语言之间的通信
    数据库工作单元与源程序工作单元之间的通信主要包括:
    向主语言传递SQL语句的执行状态信息,使主语言能够据此控制程序流程,主要用SQL通信区(SQLCA)实现
    主语言向SQL语句提供参数,主要用主变量实现
    将SQL语句查询数据库的结果交主语言进一步处理,主要用主变量和游标实现
    SQL通信区
    SQLCA是系统定义的一个全局变量,在应用程序中定义,其格式为:
            EXEC  SQL  INCLUDE  SQLCA;
    SQLCA中有一个变量SQLCODE:存放每次执行SQL语句后返回的代码,主要用于向应用程序报告SQL的执行情况。
    主变量(1)
    主变量:SQL语句中使用的主语言程序变量,可分为:输入主变量和输出主变量。
    输入主变量由应用程序赋值,SQL语句引用
    输出主变量由SQL语句赋值,返回应用程序
    主变量不能直接接受空值NULL,可在主变量后跟一指示变量(整型变量),用来指示主变量是否为NULL
    主变量(2)
    所有主变量除系统定义者外,均要说明,说明的开头行和结束行分别为:
      EXEC  SQL  BEGIN  DECLARE  SECTION;
      EXEC  SQL  END  DECLARE  SECTION;
    说明后,为和数据库对象名区别,SQL语句中的主变量名和指示变量前要加冒号(:)作标志。SQL语句之外可直接引用。

    转载于:https://www.cnblogs.com/aoyihuashao/archive/2009/12/14/1623728.html

    展开全文
  • 问题:例如在自己制作了对的输入(input256×256 target 200×256)后,如何让输入图像和输出图像分辨率不一致,例如对图像中:input的分辨率是256×256, output 和target都是200×256,需要修改哪里的参数。...
  • 软件设计师5:数据库

    2019-05-26 13:24:45
    数据库 考点: 1.数据库模型(概念模式、外模式、内模式) 2.数据模型,ER图,第一范式,第二范式,第三范式 3.数据操作(集合运算和关系运算...2.ER模型转换成关系模式的规则 ER图的基本概念 实体Entity:客观存...
  • Unicode字符集合的全部功能。 第2章,语句和语法,将介绍创建脚本文件的一些基础知识。 然后 我们将继续看一些复杂的陈述,包括,如果,尝试, 和提高。 第3章,函数定义,将研究许多函数定义技术。 我们还会看一下...
  • 13讲:元组,戴上了枷锁的列表 30 14讲:字符串:各种奇葩的内置方法 32 14结:字符串内置方法小结 37 15讲:字符串的格式语句与操作符 39 16讲:序列相关内置函数介绍 43 1-16讲:阶段总结 48 17讲:函数:Python的...
  • 6.6.6 全称量词与存在量词的转换 137 6.6.7 使用全称量词 137 6.6.8 安全表达式 138 6.7 域关系演算 139 6.8 小结 140 复习题 141 练习题 141 实验题 144 选读文献 146 第7章 使用ER到...
  • 数据的逻辑结构是对数据元素之间的逻辑关系的描述,它可以用一个数据元素的集合和定义在此集合中的若干关系来表示。数据的逻辑结构有两个要素:一是数据元素的集合,通常记为D;二是D上的关系,它反映了数据元素之间...
  • 应用案例 - 华氏温度转换成摄氏温度 / 输入圆的半径计算周长和面积 / 输入年份判断是否是闰年 Day03 - 分支结构 分支结构的应用场景 - 条件 / 缩进 / 代码块 / 流程图 if语句 - 简单的if / if-else结构 / if-...
  • 尹成Python27天入门到项目实战

    千人学习 2020-12-05 17:04:22
    常量与变量区别标识符关键字输入输出id求地址type求类型python变量是地址赋值可以改变...一行规范用的常量算术运算符科学计数法与数字越界优先级结合性赋值运算符数据类型转换四舍五入数据提取时间处理作业day2 ...
  • 角色是一组权限的集合,将角色赋给一个用户,这个用户就拥有了这个角色中的所有权限。  系统预定义角色 预定义角色是在数据库安装后,系统自动创建的一些常用的角色。下面我们就简单介绍些系统角色:  CONNECT...
  • 因文件较大,全书压缩打包4部分,这是第1部分。 内容简介  是C# 2012和.NET 4.5高级技术的终极资源,旨在帮助读者更新、提高用C# 2012和.NET 4.5编写Windows应用程序、Web应用程序、Windows 8样式应用程序的技巧...
  • 我们就可以把我们的代码从 AST 转换成 CommenJS 的代码,这样子兼容性更高更好,并且将 ID 自增。 <pre><code>javascript const customCode = loader(filename, code) function loader(filename...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

集合如何转换成元组