精华内容
下载资源
问答
  • 今天我们的题目是《由个简单的Python合并字典问题引发的思考,如何优化我们的代码?》,为什么会有这个话题呢?起因是今天和位刚刚面试完Python开发岗位的朋友交流,这个问题也是他在面试中遇到的问题: 怎么用...

    关注公众号《云爬虫技术研究笔记》,获取更多干货~

    号主介绍
    多年反爬虫破解经验,AKA“逆向小学生”,沉迷数据分析和黑客增长不能自拔,虚名有CSDN博客专家和华为云享专家。

    今天我们的题目是《由一个简单的Python合并字典问题引发的思考,如何优化我们的代码?》,为什么会有这个话题呢?起因是今天和一位刚刚面试完Python开发岗位的朋友交流,这个问题也是他在面试中遇到的问题:

    怎么用一个简单的表达式合并Python中的两个Dict

    这个问题虽然是一道很简单的问题,并且解题的思路也有很多种。不过问题虽小,但是我们也借此分析一下更深层次的东西,关于代码如何优化优化思路等等。

    首先我们简单的思考一下,Python中合并两个Dict有哪些方法?我们分别举Python3Python2的例子。

    案例

    假设我们现在有DictXX和DictYY,我们想要合并它们得到新的DictZZ,我们会这么做:

    • 在Python 3.5或更高版本中:
    z = {**x, **y}
    
    • 在Python 2(或3.4或更低版本)中,编写一个函数:
    def merge_two_dicts(x, y):
        z = x.copy()   # start with x's keys and values
        z.update(y)    # modifies z with y's keys and values & returns None
        return z
    z = merge_two_dicts(x, y)
    

    Python3.5版本以上方法分析

    假设我们有两个字典,并且想要将它们合并为新字典而不更改原始字典:

    x = {'a': 1, 'b': 2}
    y = {'b': 3, 'c': 4}
    

    理想的结果是获得一个z是合并后的新字典,第二个Dict的值覆盖第一个字典Dict的值。

    >>> z
    {'a': 1, 'b': 3, 'c': 4}
    

    PEP 448中提出并从Python 3.5开始可用的新语法是:

    z = {**x, **y}
    

    它只需要一个非常简洁的表达式就可以完成,另外,我们也可以使用解包来进行操作:

    z = {**x, 'foo': 1, 'bar': 2, **y}
    

    结果如下:

    >>> z
    {'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}
    

    它现在正式的在3.5发布时间表中实现,PEP 478,并且已进入Python 3.5的新功能文档。

    我们大致看一下这个新功能的使用方式

    这个功能允许我们在同一个表达式中使用多个解包表达式,能够很方便的合并迭代器和普通的列表,而不需要将迭代器先转化成列表再进行合并。

    但是,由于许多组织仍在使用Python 2,因此我们可能希望以向后兼容的方式进行操作。在Python 2Python 3.0-3.4中可用的经典Pythonic方法是分两个步骤完成的:

    z = x.copy()
    z.update(y) # which returns None since it mutates z
    

    这种方法中,我们拷贝x生成新的对象z,再使用dictupdate的方法合并两个dict

    Python3.5版本以下方法分析

    如果我们尚未使用Python 3.5,或者需要编写向后兼容的代码,并且希望在单个表达式中使用它,则最有效的方法是将其放入函数中:

    def merge_two_dicts(x, y):
        """Given two dicts, merge them into a new dict as a shallow copy."""
        z = x.copy()
        z.update(y)
        return z
    

    然后我们需要这样使用函数:

    z = merge_two_dicts(x, y)
    

    您还可以创建一个合并多个dict的函数,并且我们可以指定任意数量的dict

    def merge_dicts(*dict_args):
        """
        Given any number of dicts, shallow copy and merge into a new dict,
        precedence goes to key value pairs in latter dicts.
        """
        result = {}
        for dictionary in dict_args:
            result.update(dictionary)
        return result
    

    此函数将在Python 23中适用于所有字典。我们可以这样使用:

    z = merge_dicts(a, b, c, d, e, f, g) 
    

    不过注意的是:越往后的dict的键值优先度越高,会覆盖前面的键值。

    发散脑洞,我们想象其他回答

    Python 2中,我们还可以这么操作:

    z = dict(x.items() + y.items())
    

    Python 2中,我们使用.items()会得到list,也就是我们将会在内存中创建两个列表,然后在内存中创建第三个列表,其长度等于前两个字典的长度,最后丢弃所有三个列表以创建字典,就是我们需要的Dict
    但是注意,我们决不能在Python 3中这么使用,在Python 3中,这会失败失败是因为我们是将两个dict_items对象而不是两个列表加在一起。

    >>> c = dict(a.items() + b.items())
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'
    

    当然,我们真的想要实现的话,我们也可以强制转换,将它们明确创建为列表,例如z = dict(list(x.items()) + list(y.items())),但是这反而浪费了资源和计算能力。

    类似地,当值是不可散列的对象(例如列表)时,items()在Python 3(viewitems()在Python 2.7中)进行联合也将失败。即使您的值是可哈希的,由于集合在语义上是无序的,因此关于优先级的行为是不确定的。所以不要这样做:

    >>> c = dict(a.items() | b.items())
    

    我们演示一下值不可散列时会发生的情况:

    >>> x = {'a': []}
    >>> y = {'b': []}
    >>> dict(x.items() | y.items())
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    

    这是一个示例,其中y应该优先,但是由于集合的任意顺序,保留了x的值:

    >>> x = {'a': 2}
    >>> y = {'a': 1}
    >>> x.items() | y.items()
    {('a', 1), ('a', 2)}
    >>> dict(x.items() | y.items())
    {'a': 2}
    

    另外一种我们不应该使用的另一种技巧:

    z = dict(x, **y)
    

    这使用了dict构造函数,并且非常快速且具有内存效率(甚至比我们的两步过程略高),但是除非我们确切地知道里面正在发生什么(也就是说,第二个dict作为关键字参数传递给dict,构造函数)我们才能使用,要不然这个表达式很难阅读,有时我们并不能很快的理解这算什么用法,因此不算Pythonic

    由于这种情况的存在,我们看看在django修复的用法示例。

    字典旨在获取可散列的键(例如,frozensettuple),但是当键不是字符串时,此方法在Python 3中失败。

    >>> c = dict(a, **b)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: keyword arguments must be strings
    

    邮件列表中,大佬Guido van Rossum写道:

    我宣布dict({},** {1:3})是非法的使用方式,因为这是对**机制的滥用。
    显然dict(x,** y)和直接调用x.update(y)并返回x这种“酷”的操作很类似。
    但是我个人觉得它比“酷”的操作更低俗。
    

    不过根据我的理解(以及对大佬的话的理解),dict(**y)命令的预期用途是为了创建可读性强的字典,例如:

    dict(a=1, b=10, c=11)
    

    用来代替

    {'a': 1, 'b': 10, 'c': 11}
    

    在这个地方使用**运算符也不会滥用该机制,我们使用**正是为了将dict作为关键字传递而设计的。

    最后看看那些性能较差的实现方案

    这些方法的性能较差,但是它们将提供正确的行为。它们的性能将不及copyupdate新的解包方式,因为它们在更高的抽象级别上遍历每个键值对,但它们确实遵循优先级的顺序(后者决定了优先级)

    • 我们可以在使用生成式来做:
    {k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7
    

    或在python 2.6中(也许在引入生成器表达式时早在2.4中):

    dict((k, v) for d in dicts for k, v in d.items())
    

    itertools.chain 迭代器的骚操作

    import itertools
    z = dict(itertools.chain(x.iteritems(), y.iteritems()))
    

    ChainMap骚操作

    >>> from collections import ChainMap
    >>> x = {'a':1, 'b': 2}
    >>> y = {'b':10, 'c': 11}
    >>> z = ChainMap({}, y, x)
    >>> for k, v in z.items():
            print(k, '-->', v)
    
    a --> 1
    b --> 10
    c --> 11
    

    ####我们做做时间分析
    我将仅对已知行为正确的用法进行性能分析。

    import timeit
    

    Ubuntu 18上完成以下操作
    Python 2.7(系统Python)中:

    >>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
    0.5726828575134277
    >>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
    1.163769006729126
    >>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
    1.1614501476287842
    >>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
    2.2345519065856934
    

    Python 3.5中:

    >>> min(timeit.repeat(lambda: {**x, **y}))
    0.4094954460160807
    >>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
    0.7881555100320838
    >>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
    1.4525277839857154
    >>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
    2.3143140770262107
    >>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
    3.2069112799945287
    

    结论

    经过我们之前的一系列分析和实验,我们可以得到这个问题的结论

    • Python 2中我们就采用copy加上update的方案
    • Python 3中我们就采用多重解包的方案

    不过对比以上两种,显然多重解包更快而且更简洁,针对大家不熟悉Python 3可以参考我之前的一篇文章Python2寿命只剩一个月啦!还不快赶紧学起Python3酷炫到爆的新特性!,可以帮助大家快速的切换成Python 3开发,不过注意的是Python 3高版本和Python 2.7差别也是比较大,因此大家要是涉及线上业务的切换,请谨慎注意

    最后我们来谈谈优化代码的问题,从这个问题入手,我们可以总结出优化代码的思路:

    1. 我们分析出有哪些解决方案?
    2. 哪些解决方案是有效的?
    3. 这些有效的方案怎么做对比?
    4. 最佳的方案需要我们做出哪些牺牲?
    展开全文
  • k倍多重正整数集

    2019-07-24 08:12:44
    k倍多重正整数集合的定义是:在多重集合(元素可以重复)中,不存在个正整数是另个正整数的k倍。 现在小M有n个正整数,你可以选择其中一些数构成k倍多重正整数集合。请求出最多能选出多少数来构成它。 输入...

    k倍多重正整数集
    牛客网:k倍多重正整数集

    题目描述

    k倍多重正整数集合的定义是:在一个多重集合(元素可以重复)中,不存在一个正整数是另一个正整数的k倍。 现在小M有n个正整数,你可以选择其中一些数构成k倍多重正整数集合。请求出最多能选出多少数来构成它。

    输入描述:
    第一行有两个整数n, k(1 <= n <= 10^5, 1 <= k <= 10^9)。

    接下来一行有n个正整数a1, a2, …, an (1 <= ai <= 10^9)。

    输出描述:
    最多能选出多少数构成k倍多重正整数集合。

    示例1

    输入
    6 2
    2 3 6 5 4 10

    输出
    3

    思路:
    首先声明,这个思路用python超时了,但是一定是正确的思路。
    我们将连续的符合k倍多重正整数归为同类,比如k=2时,【2,4,8,16】就是一类,但是如果没有32,那么64和上面的数组元素不属于同一类。因此,即便有k倍的关系,必须要连续才可以。

    因此我们先用哈希表存储数据和对应的次数,然后将哈希表的键值排序(排序的目的是为了保证后面不会出现比前面小的元素。比如【4,8,16】已经整理好,但是后面又出现了2,那么2是可以和他们归为一类,但是出现的顺序不对,那么就会出现自己单独归为一类,出现错误),用一个while循环将同一类的元素归为一类,record记录出现过的元素,并用temp记录相应键值的次数。

    temp这个数组很有用,它记录的是同一类连续元素出现的次数。那么对于这个数组,我用了动态规划计算其最大的次数。比如dp=【3,1,3,4】,我们取max(dp【-1】,dp【-2】)。dp的舒适化很重要,当dp的长度小于3时,取其中的最大值即可。dp长度大于等于3时,dp【0】= num【0】,dp【1】=max(num【0】,num【1】),dp【2】=num【0】+num【2】,之后的dp【i】= max(dp【i-2】,dp【i-3】)+num【i】。

    对每一类的temp,我们用select_num 计算最大的出现次数即可。简而言之,select_num实现了如下功能:计算出不连续子数组最大和。用res累加所有类的次数就是答案。python通过了95%的例子,最后那个例子一定是一万多以上的数字,不然的话不会如此耗时。而且,牛客网中python2版本运行速度往往优于python3。

    def select_num(num):
        tem = [num[i] for i in range(len(num))]
        if len(tem)<=2:
            return max(tem)
        else:
            dp = [0 for _ in range(len(tem))]
            dp[0] = tem[0]
            dp[1] = max(tem[0],tem[1])
            dp[2] = dp[0]+tem[2]
            for j in range(3,len(tem)):
                dp[j] = max(dp[j-2],dp[j-3])+tem[j]
        return max(dp[-1],dp[-2])
    #数据的读取
    n, k = list(map(int,input().split()))
    num = list(map(int,input().split()))
    if n==1:
        print(1) # 只有一个数时,直接输出1
    elif k==1:
        print(len(set(num))) #k=1时,输出集合元素个数就行
    else:
        dirc = {}
        for i in num: # 用哈希表存储元素及其相应出现的次数
            dirc[i] = dirc.get(i,0)+1
        record = [] #记录出现过的元素
        ans = 0
        new = sorted(dirc) #对哈希表的键值排序,保证循环时大的数只在后面出现
        for i in new:
            if i not in record: # 若已经在记录中出现过,那么就属于已经在temp中统计过的,不再重复统计。
                temp = [dirc[i]] #不在记录中,那就用temp记录相应的次数。
                number = i*k
                record.append(i)
                while number in dirc and number not in record: # 若i及其同类在字典中出现但不在temp中
                    temp.append( dirc[number])
                    record.append(number)
                    number = number * k
                ans += select_num(temp)
        print(ans)
    
    展开全文
  • python 之字典学习

    2021-03-16 22:23:51
    文章目录字典数据类型字典与列表keys, values 和 item() 方法检查字典中是否存在键或值get() 方法setdefault() 方法使用数据结构对真实世界建模井字棋盘嵌套的字典和列表 字典数据类型 像列表一样,“字典”是许多...

    字典数据类型

    像列表一样,“字典”是许多值的集合。但不像列表的下标,字典的索引可以使用许多不同数据类型,不只是整数。字典的索引被称为“键”,键及其关联的值称为“键-值”对。
    在代码中,字典输入时带花括号{}。在交互式环境中输入以下代码:

    >>> myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
    >>>> type(myCat)
    <class 'dict'>
    

    这将一个字典赋给 myCat 变量。这个字典的键是 ‘size’、‘color’ 和 ‘disposition’。这些键对应的值是 ‘fat’、‘gray’ 和 ‘loud’。可以通过它们的键访问这些值:

    >>> myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
    >>> myCat['size']
    'fat'
    >>> 'My cat has ' + myCat['color'] + ' fur.'
    'My cat has gray fur.'
    

    字典仍然可以用整数值作为键,就像列表使用整数值作为下标一样,但它们不必从 0 开始,可以是任何数字。

    >>> spam = {12345: 'Luggage Combination', 42: 'The Answer'}
    >>> spam[42]
    'The Answer'
    

    字典与列表

    不像列表,字典中的表项是不排序的。名为 spam 的列表中,第一个表项是 spam[0]。但字典中没有“第一个”表项。虽然确定两个列表是否相同时,表项的顺序很重要,但在字典中,键-值对输入的顺序并不重要。

    >>> spam = ['cats', 'dogs', 'moose']
    >>> bacon = ['dogs', 'moose', 'cats']
    >>> spam == bacon
    False
    >>> eggs = {'name': 'Zophie', 'species': 'cat', 'age': '8'}
    >>> ham = {'species': 'cat', 'age': '8', 'name': 'Zophie'}
    >>> eggs == ham
    True
    

    因为字典是不排序的,所以不能像列表那样切片。
    尝试访问字典中不存在的键,将导致 KeyError 出错信息。这很像列表的“越界” IndexError 出错信息。

    >>> spam = {'name': 'Zophie', 'age': 7}
    >>> spam['color']
    Traceback (most recent call last):
      File "<pyshell#114>", line 1, in <module>
        spam['color']
    KeyError: 'color'
    

    尽管字典是不排序的,但可以用任意值作为键,这一点可以让我们用强大的方式来组织数据。
    假定你希望程序保存朋友生日的数据,就可以使用一个字典,用名字作为键,用生日作为值。
    打开一个新的文件编辑窗口,输入以下代码,并保存为 birthdays.py。

    birthdays = {'Alice': 'Apr 1', 'Bob': 'Dec 12', 'Carol': 'Mar 4'}
    
    while True:
        print('Enter a name: (blank to quit)')
        name = input()
        if name == '':
            break
    
        if name in birthdays:
            print(birthdays[name] + ' is the birthday of ' + name)
        else:
            print('I do not have birthday information for ' + name)
            print('What is their birthday?')
            bday = input()
            birthdays[name] = bday
            print('Birthday database updated.')
    print('Quit the program')
    

    在上面的代码中,创建了一个初始的字典,将它保存在 birthdays 中。用 in 关键字,可以看看输入的名字是否作为键存在于字典中,就像查看列表一样。如果该名字在字典中,可以用方括号访问关联的值。如果不在,可以用同样的方括号语法和赋值操作符添加它。

    Enter a name: (blank to quit)
    Alice
    Apr 1 is the birthday of Alice
    Enter a name: (blank to quit)
    Eve
    I do not have birthday information for Eve
    What is their birthday?
    Dec 5
    Birthday database updated.
    Enter a name: (blank to quit)
    Eve
    Dec 5 is the birthday of Eve
    Enter a name: (blank to quit)
    

    keys, values 和 item() 方法

    有 3 个字典方法,它们将返回类似列表的值,分别对应于字典的键、值和键-值对:keys(), values()items()。这些方法返回的值不是真正的列表,它们不能被修改,没有 append() 方法。但这些数据类型(分别是 dict_keys, dict_valuesdict_items) 可以用于 for 循环。

    >>> spam = {'color': 'red', 'age':42}
    >>> for v in spam.values():
    	print(v)
    
    	
    red
    42
    >>> type(spam.values())
    <class 'dict_values'>
    

    这里,for 循环迭代了 spam 字典中的每个值。for 循环也可以迭代每个键或者键-值对:

    >>> for k in spam.keys():
    	print(k)
    
    	
    color
    age
    >>> type(spam.keys())
    <class 'dict_keys'>
    >>> for i in spam.items():
    	print(i)
    
    	
    ('color', 'red')
    ('age', 42)
    >>> type(spam.items())
    <class 'dict_items'>
    

    请注意,items() 方法返回的 dict_items 值中,包含的是键和值的元组。
    如果希望通过这些方法得到一个真正的列表,就把类似列表的返回值传递给 list 函数。

    >>> spam = {'color': 'red', 'age': 42}
    >>> spam.keys()
    dict_keys(['color', 'age'])
    >>> list(spam.keys())
    ['color', 'age']
    

    也可以利用多重赋值的技巧,在 for 循环中将键和值赋给不同的变量。

    >>> spam = {'color': 'red', 'age': 42}
    >>> for k, v in spam.items():
    	print('Key: ' + k + ' Value: ' + str(v))
    
    	
    Key: color Value: red
    Key: age Value: 42
    

    检查字典中是否存在键或值

    可以使用 innot in 操作符检查某个键或值是否存在于字典中。

    >>> spam.items()
    dict_items([('name', 'Zophie'), ('age', 7)])
    >>> spam.keys()
    dict_keys(['name', 'age'])
    >>> spam.values()
    dict_values(['Zophie', 7])
    >>> spam = {'name': 'Zophie', 'age': 7}
    >>> 'name' in spam.keys()
    True
    >>> 'Zophie' in spam.values()
    True
    >>> 'color' in spam.keys()
    False
    >>> 'color' not in spam.keys()
    True
    >>> 'color' in spam
    False
    >>> 'name' in spam
    True
    >>> ('age', 7) in spam.items()
    True
    

    请注意,在上面的例子中,'color' in spam 本质上是一个简写版本。相当于 'color' in spam.keys()
    如果想要检查一个值是否为字典中的键,就可以用关键字 innot in,作用于该字典本身。

    get() 方法

    在访问一个键的值之前,检查该键是否存在于字典中,这很麻烦。字典有一个 gets() 方法,它有两个参数:要取得其值的键,以及如果该键不存在时,返回的备用值。

    >>> picnicItems = {'apples': 5, 'cups': 2}
    >>> 'I am bringing ' + str(picnicItems.get('cups', 0)) + ' cups.'
    'I am bringing 2 cups.'
    >>> 'I am bringing ' + str(picnicItems.get('eggs', 0)) + ' eggs.'
    'I am bringing 0 eggs.'
    

    因为 picnicItems 字典中没有 egg 键,gets() 方法返回的默认值是 0.不使用 gets(),代码就会产生一个错误信息。

    >>> picnicItems = {'apples': 5, 'cups': 2}
    >>> 'I am bringing ' + str(picnicItems['eggs']) + ' eggs.'
    Traceback (most recent call last):
      File "<pyshell#159>", line 1, in <module>
        'I am bringing ' + str(picnicItems['eggs']) + ' eggs.'
    KeyError: 'eggs'
    

    setdefault() 方法

    我们常常需要为字典中某个键设置一个默认值,当该键没有任何值时使用它。代码看起来像这样:

    spam = {'name': 'Pooka', 'age': 5}
    if 'color' not in spam:
        spam['color'] = 'black'
    

    setdefault() 方法提供了一种方式,在一行中完成这件事。传递给该方法的第一个参数,是要检查的键,第二个参数,是如果该键不存在时要设置的值。如果该键确实存在,方法就会返回键的值。

    >>> spam = {'name': 'Pooka', 'age': 5}
    >>> spam.setdefault('color', 'black')
    'black'
    >>> spam
    {'name': 'Pooka', 'age': 5, 'color': 'black'}
    >>> spam.setdefault('color', 'white')
    'black'
    >>> spam
    {'name': 'Pooka', 'age': 5, 'color': 'black'}
    

    第一次调用 setdefault 时,spam 变量中的字典变为 {'name': 'Pooka', 'age': 5, 'color': 'black'}。该方法返回值为 'black',因为现在该值被赋给键 'color'。当 spam.setdefault('color', 'white') 接下来被调用时,该键的值没有被改变为 'white',因为 spam 变量已经有名为 'color' 的键。

    下面是一个小程序,计算一个字符串中每个字符出现的次数。

    message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
    count = {}
    for character in message:
        count.setdefault(character, 0)
        count[character] += 1
    
    print(count)
    

    程序循环迭代 message 字符串中的每个字符,计算每个字符出现的次数。setdefault() 方法调用确保了键存在于 count 中(默认值是 0),这样在执行 count[character] += 1 时,就不会抛出 KeyError 错误。
    程序运行是输出如下:

    {'I': 1, 't': 6, ' ': 13, 'w': 2, 'a': 4, 's': 3, 'b': 1, 'r': 5, 'i': 6, 'g': 2, 'h': 3, 'c': 3, 'o': 2, 'l': 3, 'd': 3, 'y': 1, 'n': 4, 'A': 1, 'p': 1, ',': 1, 'e': 5, 'k': 2, '.': 1}
    

    使用数据结构对真实世界建模

    井字棋盘

    嵌套的字典和列表

    展开全文
  • JavaScript字典

    千次阅读 2009-11-20 11:12:00
    1.document.write(""); 输出语句 2.JS中的注释为// 3....个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document) 5.得到表单中元素的名称和值:document.getElementById("表单中元素的I

    1.document.write(""); 输出语句
    2.JS中的注释为//
    3.传统的HTML文档顺序是:document->html->(head,body)
    4.一个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document)
    5.得到表单中元素的名称和值:document.getElementById("表单中元素的ID号").name(或value)
    6.一个小写转大写的JS: document.getElementById("output").value = document.getElementById("input").value.toUpperCase();
    7.JS中的值类型:String,Number,Boolean,Null,Object,Function
    8.JS中的字符型转换成数值型:parseInt(),parseFloat()
    9.JS中的数字转换成字符型:(""+变量)
    10.JS中的取字符串长度是:(length)
    11.JS中的字符与字符相连接使用+号.
    12.JS中的比较操作符有:==等于,!=不等于,>,>=, <. <=
    13.JS中声明变量使用:var来进行声明
    14.JS中的判断语句结构:if(condition){}else{}
    15.JS中的循环结构:for([initial e xpression];[condition];[upadte e xpression]) {inside loop}
    16.循环中止的命令是:break
    17.JS中的函数定义:function functionName([parameter],...){statement[s]}
    18.当文件中出现多个form表单时.可以用document.forms[0],document.forms[1]来代替.
    19.窗口:打开窗口window.open(), 关闭一个窗口:window.close(), 窗口本身:self
    20.状态栏的设置:window.status="字符";
    21.弹出提示信息:window.alert("字符");
    22.弹出确认框:window.confirm();
    23.弹出输入提示框:window.prompt();
    24.指定当前显示链接的位置:window.location.href="/blog/URL"
    25.取出窗体中的所有表单的数量:document.forms.length
    26.关闭文档的输出流:document.close();
    27.字符串追加连接符:+=
    28.创建一个文档元素:document.createElement(),document.createTextNode()
    29.得到元素的方法:document.getElementById()
    30.设置表单中所有文本型的成员的值为空:
    var form = window.document.forms[0]
    for (var i = 0; i <form.elements.length;i++){
        if (form.elements.type == "text"){
            form.elements.value = "";
        }
    }
    31.复选按钮在JS中判断是否选中:document.forms[0].checkThis.checked (checked属性代表为是否选中返回TRUE或FALSE)
    32.单选按钮组(单选按钮的名称必须相同):取单选按钮组的长度document.forms[0].groupName.length
    33.单选按钮组判断是否被选中也是用checked.
    34.下拉列表框的值:document.forms[0].selectName.options[n].value (n有时用下拉列表框名称加上.selectedIndex来确定被选中的值)
    35.字符串的定义:var myString = new String("This is lightsword");
    36.字符串转成大写:string.toUpperCase(); 字符串转成小写:string.toLowerCase();
    37.返回字符串2在字符串1中出现的位置:String1.indexOf("String2")!=-1则说明没找到.
    38.取字符串中指定位置的一个字符:StringA.charAt(9);
    39.取出字符串中指定起点和终点的子字符串:stringA.substring(2,6);
    40.数学函数:Math.PI(返回圆周率),Math.SQRT2(返回开方),Math.max(value1,value2)返回两个数中的最在值,Math.pow(value1,10)返回value1的十次方,Math.round(value1)四舍五入函数,Math.floor(Math.random()*(n+1))返回随机数
    41.定义日期型变量:var today = new Date();
    42.日期函数列表:dateObj.getTime()得到时间,dateObj.getYear()得到年份,dateObj.getFullYear()得到四位的年份,dateObj.getMonth()得到月份,dateObj.getDate()得到日,dateObj.getDay()得到日期几,dateObj.getHours()得到小时,dateObj.getMinutes()得到分,dateObj.getSeconds()得到秒,dateObj.setTime(value)设置时间,dateObj.setYear(val)设置年,dateObj.setMonth(val)设置月,dateObj.setDate(val)设置日,dateObj.setDay(val)设置星期几,dateObj.setHours设置小时,dateObj.setMinutes(val)设置分,dateObj.setSeconds(val)设置秒  [注意:此日期时间从0开始计]
    43.FRAME的表示方式: [window.]frames[n].ObjFuncVarName,frames["frameName"].ObjFuncVarName,frameName.ObjFuncVarName
    44.parent代表父亲对象,top代表最顶端对象
    45.打开子窗口的父窗口为:opener
    46.表示当前所属的位置:this
    47.当在超链接中调用JS函数时用:(javascript :)来开头后面加函数名
    48.在老的浏览器中不执行此JS: <!--      //-->
    49.引用一个文件式的JS: <script type="text/javascript" src="/blog/aaa.js"> </script>
    50.指定在不支持脚本的浏览器显示的HTML: <noscript> </noscript>
    51.当超链和onCLICK事件都有时,则老版本的浏览器转向a.html,否则转向b.html.例: <a href="/blog/a.html" οnclick="location.href="/blog/b.html";return false">dfsadf </a>
    52.JS的内建对象有:Array,Boolean,Date,Error,EvalError,Function,Math,Number,Object,RangeError,ReferenceError,RegExp,
    String,SyntaxError,TypeError,URIError
    53.JS中的换行:/n
    54.窗口全屏大小: <script>function fullScreen(){ this.moveTo(0,0);this.outerWidth=screen.availWidth;this.outerHeight=screen.availHeight;}window.maximize=fullScreen; </script>
    55.JS中的all代表其下层的全部元素
    56.JS中的焦点顺序:document.getElementByid("表单元素").tabIndex = 1
    57.innerHTML的值是表单元素的值:如 <p id="para">"how are <em>you </em>" </p>,则innerHTML的值就是:how are <em>you </em>
    58.innerTEXT的值和上面的一样,只不过不会把 <em>这种标记显示出来.
    59.contentEditable可设置元素是否可被修改,isContentEditable返回是否可修改的状态.
    60.isDisabled判断是否为禁止状态.disabled设置禁止状态
    61.length取得长度,返回整型数值
    62.addBehavior()是一种JS调用的外部函数文件其扩展名为.htc
    63.window.focus()使当前的窗口在所有窗口之前.
    64.blur()指失去焦点.与FOCUS()相反.
    65.select()指元素为选中状态.
    66.防止用户对文本框中输入文本:οnfοcus="this.blur()"
    67.取出该元素在页面中出现的数量:document.all.tags("div(或其它HTML标记符)").length
    68.JS中分为两种窗体输出:模态和非模态.window.showModaldialog(),window.showModeless()
    69.状态栏文字的设置:window.status='文字',默认的状态栏文字设置:window.defaultStatus = '文字.';
    70.添加到收藏夹:external.AddFavorite("http://www.cnblogs.com/css/";,"jaskdlf");
    71.JS中遇到脚本错误时不做任何操作:window.onerror = doNothing; 指定错误句柄的语法为:window.onerror = handleError;
    72.JS中指定当前打开窗口的父窗口:window.opener,支持opener.opener...的多重继续.
    73.JS中的self指的是当前的窗口
    74.JS中状态栏显示内容:window.status="内容"
    75.JS中的top指的是框架集中最顶层的框架
    76.JS中关闭当前的窗口:window.close();
    77.JS中提出是否确认的框:if(confirm("Are you sure?")){alert("ok");}else{alert("Not Ok");}
    78.JS中的窗口重定向:window.navigate("http://www.cnblogs.com/css/";);
    79.JS中的打印:window.print()
    80.JS中的提示输入框:window.prompt("message","defaultReply");
    81.JS中的窗口滚动条:window.scroll(x,y)
    82.JS中的窗口滚动到位置:window.scrollby
    83.JS中设置时间间隔:setInterval("expr",msecDelay)或setInterval(funcRef,msecDelay)或setTimeout
    84.JS中的模态显示在IE4+行,在NN中不行:showModalDialog("URL"[,arguments][,features]);
    85.JS中的退出之前使用的句柄:function verifyClose(){event.returnValue="we really like you and hope you will stay longer.";}}  window.οnbefοreunlοad=verifyClose;
    86.当窗体第一次调用时使用的文件句柄:onload()
    87.当窗体关闭时调用的文件句柄:onunload()
    88.window.location的属性: protocol(http:),hostname(www.example.com),port(80),host(www.example.com:80),pathname("/a/a.html"),hash("#giantGizmo",指跳转到相应的锚记),href(全部的信息)
    89.window.location.reload()刷新当前页面.
    90.window.history.back()返回上一页,window.history.forward()返回下一页,window.history.go(返回第几页,也可以使用访问过的URL)
    91.document.write()不换行的输出,document.writeln()换行输出
    92.document.body.noWrap=true;防止链接文字折行.
    93.变量名.charAt(第几位),取该变量的第几位的字符.
    94."abc".charCodeAt(第几个),返回第几个字符的ASCii码值.
    95.字符串连接:string.concat(string2),或用+=进行连接
    96.变量.indexOf("字符",起始位置),返回第一个出现的位置(从0开始计算)
    97.string.lastIndexOf(searchString[,startIndex])最后一次出现的位置.
    98.string.match(regExpression),判断字符是否匹配.
    99.string.replace(regExpression,replaceString)替换现有字符串.
    100.string.split(分隔符)返回一个数组存储值.
    101.string.substr(start[,length])取从第几位到指定长度的字符串.
    102.string.toLowerCase()使字符串全部变为小.
    103.string.toUpperCase()使全部字符变为大写.
    104.parseInt(string[,radix(代表进制)])强制转换成整型.
    105.parseFloat(string[,radix])强制转换成浮点型.
    106.isNaN(变量):测试是否为数值型.
    107.定义常量的关键字:const,定义变量的关键字:var

    展开全文
  • 在上篇有关并行化的《有关对耗时很循环进行并行化优化的探讨 之:并发搜索的处理》博文中,我们看到,不使用并行语言,而使用基本的编程语言配合多线程可以进行并行化处理,本文进一步将并行化操作进行个...
  • 数据字典汇总

    2015-05-26 18:39:47
    select * from dictionary;   --数据字典 ...数据字典是Oracle存放有关...数据库数据字典组表和视图结构。它们存放在SYSTEM表空间中   当用户在对数据库中的数据进行操作时遇到困难就可以访问数据字典
  • DC 字典

    2004-10-24 10:27:00
    1.ae锁 ae是automatic exposure自动曝光控制装置的缩写,ae锁就是锁定于某ae设置,用于自动曝光时人为控制曝光量,保证主体曝光正常。 使用ae锁有几点需要注意:1、手动方式或自拍时不能使用自动曝光(ae)锁。 2...
  • boost源码剖析之:多重回调机制signal(上)   刘未鹏 C++的罗浮宫(http://blog.csdn.net/pongba)   boost库固然是技术的宝库,却更是思想的宝库。大多数程序员都知道如何应用command,observer等模式,却不知...
  • 如何阅读一本

    千次阅读 2009-08-11 01:36:00
    《如何阅读一本书》 作者简介 莫提默·J.艾德勒(1902-2001) 以学者、教育家、编辑等多重面貌享有盛名。除了写作《如何阅读一本书》外,以主编《西方世界德经典》,并担任1974年第十五版《大英百科全书》的编辑...
  • oracle数据字典

    2012-12-13 22:44:51
    select * from dictionary;   --数据字典 ...数据字典是Oracle存放有关...数据库数据字典组表和视图结构。它们存放在SYSTEM表空间中   当用户在对数据库中的数据进行操作时遇到困难就可以访问数据字典
  • oracle 数据字典

    千次阅读 2012-01-09 10:17:27
    select * from dictionary;   --数据字典 ...数据字典是Oracle存放有关...数据库数据字典组表和视图结构。它们存放在SYSTEM表空间中   当用户在对数据库中的数据进行操作时遇到困难就可以访问数据字典
  • 多重网格、自适应网格和无网格

    万次阅读 2013-01-19 10:58:43
    多重网格法简介(Multi Grid)...从专业角度讲多重网格法实际上是种多分辨率的算法,由于直接在高分辨率(用于求解的间隔小)上进行求解时对于低频部分收敛较慢,与间隔的平方成反比。就想到先在低分辨率(间隔较
  • Oracle 数据字典

    2010-09-14 20:20:00
    数据库数据字典组表和视图结构。它们存放在SYSTEM表空间中   当用户在对数据库中的数据进行操作时遇到困难就可以访问数据字典来查看详细的信息。  用户可以用SQL语句访问数据
  • 《如何阅读一本书》

    千次阅读 2006-09-10 13:15:00
    《如何阅读一本书》 作者简介 莫提默·J.艾德勒(1902-2001) 以学者、教育家、编辑等多重面貌享有盛名。除了写作《如何阅读一本书》外,以主编《西方世界德经典》,并担任1974年第十五版《大英百科全书》的编辑...
  • 本人很喜欢这种风格 可以直接拿来用 很容易上手 不干独吞 大家分享 1.document.write(""); 输出语句 2.JS中的注释为/...个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document) 5.得到表
  • 《如何阅读一本书》读书笔记

    千次阅读 2018-08-23 13:50:23
    转自:... ...amp;wfr=spider&amp;for=pc  前言  书中有一章是介绍“辅助阅读”的,其中有段话是:“除非你看完了一本书,否则不要看某个人的导读”。原因是:一,“一本书的导读并不...
  • js语法字典

    2012-12-21 13:50:30
    1.document.write("");输出语句 2.JS中的注释为// ...4.个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document) 5.得到表单中元素的名称和值:document.getElementById("表单中元
  • JS语法字典

    2010-07-14 09:36:00
    个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document) 5.得到表单中元素的名称和值:document.getElementById("表单中元素的ID号").name(或value) 6.个小写转
  • 学习笔记——编程小白的第一本 Python 入门书:
  • python 字典详解 二(字典拓展使用 )

    千次阅读 2016-03-11 12:00:28
    前言本文将涵盖在一些特殊用途的字典,如OrderedDict, defaultdict, ChainMap, Counter,它们都在 collections 类库下面OrderedDict它主要的作用是字典排序, 标准的字典插入到字典中的键值对是没有顺序的,但是在...
  • Python 有四种数据结构,分别是:列表、字典、元组,集合。 6.2 列表 a. 特征: 列表中的每个元素都是可变的; 列表中的元素是有序的,也就是说每个元素都有个位置; 列表可以容纳 Python 中的任何...
  •  这是一本为阅读的人,或是想要成为阅读的人而写的书。尤其是想要阅读的人。所谓“阅读的人”(readers),是指那些今天仍然习惯于从书写文字中汲取大量资讯,以增进对世界了解的人,就和过去历史上每一个深有教养...
  • 第四章 数据字典详解

    2019-11-27 17:02:43
    gp 是基于 PostgreSQL开发的,部分数据字典是一样的;gp 也有自动的一些数据字典,一般是以 gp_ 开头 4.1 oid 无处不在 oid 是种特殊的数据类型,在 PG/GP 中,oid 都是递增的,每个表空间、表、索引、数据...
  •  这是一本为阅读的人,或是想要成为阅读的人而写的书。尤其是想要阅读的人。所谓“阅读的人”(readers),是指那些今天仍然习惯于从书写文字中汲取大量资讯,以增进对世界了解的人,就和过去历史上每一个深有教养...
  • 在电视剧和电影中,常常看到程序员在闪光的屏幕上迅速地输入密码般的串1和0,但现代编程没有这么神秘。编程只是输入指令让计算机来执行。这些指令可能运算一些数字,修改文本,在文件中查找信息,或通过因特网与...
  • 【高德地图API】句话搞定webmap()——轻地图组件 原文:[高德地图API]句话搞定webmap()——轻地图组件 摘要: 遥想当年,在APP中加入LBS元素相当困难:要刻苦学习java,要刻苦学习iOS开发,要刻苦学习...
  • 我们可以看到,在上图这样一本日常使用的字典中,每一个字都对应着一个或者多个解释,当你查阅字典时,你会先通过检索(可以是部首检索,可以是拼音检索)找到你所要查的字,然后再看解释。可能你会觉得有点莫名奇妙...
  • 在上篇文章中,我们回顾了Python列表的常用操作,列表作为种常用的数据类型在日常工作中扮演了非常重要的作用,这篇文章我们继续聊聊Python里另种常用的数据类型 - 字典(Dict)。 定义字典可以使用dict()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,096
精华内容 4,438
关键字:

一本大字典多重