为了账号安全,请及时绑定邮箱和手机立即绑定

初识Python

廖雪峰 移动开发工程师
难度入门
时长 5小时 0分
学习人数
综合评分94.7
3641人评价 查看评价
9.7 内容实用
9.5 简洁易懂
9.2 逻辑清晰
  • for循环可以嵌套,因此,在列表生成式中,也可以用多层 for 循环来生成列表。

    对于字符串 'ABC' 和 '123',可以使用两层循环,生成全排列:

    >>> [m + n for m in 'ABC' for n in '123']
    ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

    翻译成循环代码就像下面这样:

    L = []
    for m in 'ABC':
        for n in '123':
            L.append(m + n)


  • 列表生成式的 for 循环后面还可以加上 if 判断。例如:

    >>> [x * x for x in range(1, 11)]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

    如果我们只想要偶数的平方,不改动 range()的情况下,可以加上 if 来筛选:

    >>> [x * x for x in range(1, 11) if x % 2 == 0]
    [4, 16, 36, 64, 100]

    有了 if 条件,只有 if 判断为 True 的时候,才把循环的当前元素添加到列表中。

    1. isinstance(x, str) 可以判断变量 x 是否是字符串;

    2. 字符串的 upper() 方法可以返回大写的字母。


  • 使用for循环的迭代不仅可以迭代普通的list,还可以迭代dict。

    假设有如下的dict:

    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

    完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格:

    tds = ['<tr><td>%s</td><td>%s</td></tr>' % 
    (name, score) for name, score in 
    d.iteritems()]
    print '<table>'
    print '<tr><th>Name</th><th>Score</th><tr>'
    print '\n'.join(tds)
    print '</table>'

    注:字符串可以通过 % 进行格式化,用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。

    把打印出来的结果保存为一个html文件,就可以在浏览器中看到效果了:

    <table border="1">
    <tr><th>Name</th><th>Score</th><tr>
    <tr><td>Lisa</td><td>85</td></tr>
    <tr><td>Adam</td><td>95</td></tr>
    <tr><td>Bart</td><td>59</td></tr>
    </table>

    <!--此处有图片-->

    任务

    在生成的表格中,对于没有及格的同学,请把分数标记为红色。

    提示:红色可以用 <td > 实现。

    如果我们用一个函数来替换字符串的格式化代码,可以得到更清晰的代码,这样,只需要修改 generate_tr() 函数,必要的时候把score标红。

    参考代码:

    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    def generate_tr(name, score):
        if score < 60:
            return '<tr><td>%s</td><td >%s</td></tr>' % (name, score)
        return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)
    tds = [generate_tr(name, score) for name, 
    score in d.iteritems()]
    print '<table border="1">'
    print '<tr><th>Name</th><th>Score</th><tr>'
    print '\n'.join(tds)
    print '</table>'


  • 要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],我们可以用range(1, 11),但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做?方法一是循环。

    但是循环太繁琐,而列表生成式则可以用一行语句代替循环生成上面的list:

    >>> [x * x for x in range(1, 11)]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

    这种写法就是Python特有的列表生成式。利用列表生成式,可以以非常简洁的代码生成 list。

    写列表生成式时,把要生成的元素 x * x 放到前面,后面跟 for 循环,就可以把list创建出来,十分有用,多写几次,很快就可以熟悉这种语法。

  • Python把0空字符串''None看成 False,其他数值和非空字符串都看成 True

  • 要解释上述结果,又涉及到 and 和 or 运算的一条重要法则:短路计算。

    1. 在计算 a and b 时,如果 a 是 False,则根据与运算法则,整个结果必定为 False,因此返回 a;如果 a 是 True,则整个计算结果必定取决与 b,因此返回 b。

    2. 在计算 a or b 时,如果 a 是 True,则根据或运算法则,整个计算结果必定为 True,因此返回 a;如果 a 是 False,则整个计算结果必定取决于 b,因此返回 b。

    所以Python解释器在做布尔运算时,只要能提前确定计算结果,它就不会往后算了,直接返回结果。


  • 我们了解了如何迭代 dict 的key和value,那么,在一个 for 循环中,能否同时迭代 key和value?答案是肯定的。

    首先,我们看看 dict 对象的 items() 方法返回的值:

    >>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    >>> print d.items()
    [('Lisa', 85), ('Adam', 95), ('Bart', 59)]

    可以看到,items() 方法把dict对象转换成了包含tuple的list,我们对这个list进行迭代,可以同时获得key和value:

    >>> for key, value in d.items():
    ...     print key, ':', value
    ... 
    Lisa : 85
    Adam : 95
    Bart : 59

    和 values() 有一个 itervalues() 类似, items() 也有一个对应的 iteritems(),iteritems() 不把dict转换成list,而是在迭代过程中不断给出 tuple,所以, iteritems() 不占用额外的内存。

  • 我们已经了解了dict对象本身就是可迭代对象,用 for 循环直接迭代 dict,可以每次拿到dict的一个key。

    如果我们希望迭代 dict 对象的value,应该怎么做?

    dict 对象有一个 values() 方法,这个方法把dict转换成一个包含所有value的list,这样,我们迭代的就是 dict的每一个 value:

    d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    print d.values()
    # [85, 95, 59]
    for v in d.values():    
        print v
    # 85
    # 95
    # 59

    dict除了values()方法外,还有一个 itervalues() 方法,用 itervalues() 方法替代 values() 方法,迭代效果完全一样。

    那这两个方法有何不同之处呢?

    1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

    2. 但是 itervalues() 方法不会转换,它会在迭代过程中依次从 dict 中取出 value,所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

    3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象,这说明在Python中,for 循环可作用的迭代对象远不止 list,tuple,str,unicode,dict等,任何可迭代对象都可以作用于for循环,而内部如何迭代我们通常并不用关心。

    如果一个对象说自己可迭代,那我们就直接用 for 循环去迭代它,可见,迭代是一种抽象的数据操作,它不对迭代对象内部的数据有任何要求。


  • and:只有两个布尔值都为 True 时,计算结果才为 True。

    or:只要有一个布尔值为 True,计算结果就是 True。

    Python把0空字符串''None看成 False,其他数值和非空字符串都看成 True,

  • 整数与浮点数的混合运算结果为浮点数

  • 由于set存储的是一组不重复的无序元素,因此,更新set主要做两件事:

    一是把新的元素添加到set中,二是把已有元素从set中删除。

    添加元素时,用set的add()方法:

    删除set中的元素时,用set的remove()方法:

  • set的内部结构和dict很像,唯一区别是不存储value,因此,判断一个元素是否在set中速度很快。

    set存储的元素和dict的key类似,必须是不变对象,因此,任何可变对象是不能放入set中的

    set存储的元素也是没有顺序的。

  • Python中,迭代永远是取出元素本身,而非元素的索引。

    对于有序集合,元素确实是有索引的。有的时候,我们确实想在 for 循环中拿到索引,怎么办?

    方法是使用 enumerate() 函数:

    >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
    >>> for index, name in enumerate(L):
    ...     print index, '-', name
    ... 
    0 - Adam
    1 - Lisa
    2 - Bart
    3 - Paul

    使用 enumerate() 函数,我们可以在for循环中同时绑定索引index和元素name。但是,这不是 enumerate() 的特殊语法。实际上,enumerate() 函数把:

    ['Adam', 'Lisa', 'Bart', 'Paul']

    变成了类似:

    [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

    因此,迭代的每一个元素实际上是一个tuple:

    for t in enumerate(L):
        index = t[0]
        name = t[1]
        print index, '-', name

    如果我们知道每个tuple元素都包含两个元素,for循环又可以进一步简写为:

    for index, name in enumerate(L):
        print index, '-', name

    这样不但代码更简单,而且还少了两条赋值语句。

    可见,索引迭代也不是真的按索引访问,而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple,再迭代,就同时获得了索引和元素本身。

    zip()函数可以把两个 list 变成一个 list:

    >>> zip([10, 20, 30], ['A', 'B', 'C'])
    [(10, 'A'), (20, 'B'), (30, 'C')]


  • dict的缺点是占用内存大,还会浪费很多内容,

    由于dict是按 key 查找,所以,在一个dict中,key不能重复。

    dict的第二个特点就是存储的key-value序对是没有顺序的!这和list不一样

    dict内部是无序的,不能用dict存储有序的集合。

    dict的第三个特点是作为 key 的元素必须不可变,Python的基本类型如字符串、整数、浮点数都是不可变的,都可以作为 key。但是list是可变的,就不能作为 key。

  • 在Python中,如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们成为迭代(Iteration)。

    在Python中,迭代是通过 for ... in 来完成的,而很多语言比如C或者Java,迭代list是通过下标完成的,比如Java代码。

    可以看出,Python的for循环抽象程度要高于Java的for循环。

    因为 Python 的 for循环不仅可以用在list或tuple上,还可以作用在其他任何可迭代对象上。

    因此,迭代操作就是对于一个集合,无论该集合是有序还是无序,我们用 for 循环总是可以依次取出集合的每一个元素。

    注意: 集合是指包含一组元素的数据结构,我们
    已经介绍的包括:
    1. 有序集合:list,tuple,str和unicode;
    2. 无序集合:set
    3. 无序集合并且具有 key-value 对:dict

    而迭代是一个动词,它指的是一种操作,在Python中,就是 for 循环。

    迭代与按下标访问数组最大的不同是,后者是一种具体的迭代实现方式,而前者只关心迭代结果,根本不关心迭代内部是如何实现的。


举报

0/150
提交
取消
课程须知
如果您了解程序设计的基本概念,会简单使用命令行,了解中学数学函数的概念,那么对课程学习会有很大的帮助,让您学起来得心应手,快速进入Python世界。
老师告诉你能学到什么?
通过本课程的学习,您将学会搭建基本的Python开发环境,以函数为基础编写完整的Python代码,熟练掌握Python的基本数据类型以及list和dict的操作。
意见反馈 邀请有奖 帮助中心 APP下载
官方微信