Python是动态语言

1、list中的元素可以随时增加或者删除

2、list中包含的元素并不要求必须是同一种类型，可以是很多类型，比如说字符串，数值等等

3、list的表示形式是【】

L = [75, 92, 59, 68]
sum = 0.0
for score in L:
   sum+=score
print sum / 4

这里跳了一下

多层表达式

for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。

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

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

条件过滤

列表生成式的 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 的时候，才把循环的当前元素添加到列表中。

任务

请编写一个函数，它接受一个 list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略。

提示：

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

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

列表生成

循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的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创建出来，十分有用，多写几次，很快就可以熟悉这种语法。

任务

请利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]

提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]

<br /><strong>迭代dict的key ,value</strong><br /><p>Python中，<strong>迭代永远是取出元素本身，而非元素的索引。</strong></p><p>对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？</p><p>方法是使用 <span><strong>enumerate() 函数</strong></span>：</p><pre class="code">&gt;&gt;&gt; L = ['Adam', 'Lisa', 'Bart', 'Paul'] &gt;&gt;&gt; for index, name in enumerate(L):...     print index, '-', name ...  0 - Adam 1 - Lisa 2 - Bart 3 - Paul</pre><p>使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是，这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把：</p><pre class="code">['Adam', 'Lisa', 'Bart', 'Paul']</pre><p>变成了类似：</p><pre class="code">[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]</pre><p>因此，迭代的每一个元素实际上是一个tuple：</p><pre class="code">for t in enumerate(L):     index = t[0]     name = t[1]     print index, '-', name</pre><p>如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：</p><pre class="code">for index, name in enumerate(L):     print index, '-', name</pre><p>这样不但代码更简单，而且还少了两条赋值语句。</p><p>可见，索引迭代也不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。</p><h3 class="code-tips-title">任务</h3><p>zip()函数可以把两个 list 变成一个 list：</p><pre class="code">&gt;&gt;&gt; zip([10, 20, 30], ['A', 'B', 'C']) [(10, 'A'), (20, 'B'), (30, 'C')]</pre><p>在迭代 ['Adam', 'Lisa', 'Bart', 'Paul'] 时，如果我们想打印出名次 - 名字（名次从1开始)，请考虑如何在迭代中打印出来。</p><p><strong>提示：</strong>考虑使用zip()函数和range()函数</p><ul class="list-paddingleft-2"><li><p><strong>?</strong>不会了怎么办</p></li><li><p>range(1, ?) 可以创建出起始为 1 的数列。</p><p><strong>参考代码:</strong></p><pre class="code">L = ['Adam', 'Lisa', 'Bart', 'Paul'] for index, name in zip(range(1, len(L)+1), L):     print index, '-', name</pre></li></ul><p><br /></p>

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')]

在迭代 ['Adam', 'Lisa', 'Bart', 'Paul'] 时，如果我们想打印出名次 - 名字（名次从1开始)，请考虑如何在迭代中打印出来。

提示：考虑使用zip()函数和range()函数

• ?不会了怎么办

• range(1, ?) 可以创建出起始为 1 的数列。

  参考代码:

  L = ['Adam', 'Lisa', 'Bart', 'Paul']
  for index, name in zip(range(1, len(L)+1), L):
      print index, '-', name

Tuple  操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 。
如果对不需要修改的数据进行 “写保护”，可以使代码更安全。说明这一数据是常量。

t = (range(10))

print t #此时range生成的是list

r=tuple(range(10))

print r #此时转换成了tuple

value单个d[]表示，循环也是一样

key是用于查找的

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

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

在很多编程语言中，针对字符串提供了很多各种截取函数，其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。

任务

字符串有个方法 upper() 可以把字符变成大写字母：

>>> 'abc'.upper() 'ABC'

但它会把所有字母都变成大写。请设计一个函数，它接受一个字符串，然后返回一个仅首字母变成大写的字符串。

提示：利用切片操作简化字符串操作。

• ?不会了怎么办

• 取除首字母外的字符串用[1:]

  参考代码:

  def firstCharUpper(s):     return s[0].upper() + s[1:] print firstCharUpper('hello') print firstCharUpper('sunday') print firstCharUpper('september')

                       

• index.py

提交                  重置代码                            

God，你离成神已经不远了！下一节吧。

                         

• 评论

• 问

<strong>倒序切片</strong><p>对于list，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片，试试：</p><pre class="code">&gt;&gt;&gt; L = ['Adam', 'Lisa', 'Bart', 'Paul'] &gt;&gt;&gt; L[-2:] ['Bart', 'Paul'] &gt;&gt;&gt; L[:-2] ['Adam', 'Lisa'] &gt;&gt;&gt; L[-3:-1] ['Lisa', 'Bart'] &gt;&gt;&gt; L[-4:-1:2] ['Adam', 'Bart']</pre><p>记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。</p><h3 class="code-tips-title">任务</h3><p>利用倒序切片对 1 - 100 的数列取出：</p><p>* 最后10个数；</p><p>* 最后10个5的倍数。</p><ul class="list-paddingleft-2"><li><p><strong>?</strong>不会了怎么办</p></li><li class="hide"><p>5的倍数可以用 ::5 取出，要确</p></li></ul><p><br /></p>

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

如果第一个索引是0，还可以省略：

>>> L[:3]
['Adam', 'Lisa', 'Bart']

也可以从索引1开始，取出2个元素出来：

>>> L[1:3]
['Lisa', 'Bart']

只用一个 : ，表示从头到尾：

>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']

因此，L[:]实际上复制出了一个新list。

切片操作还可以指定第三个参数：

>>> L[::2]
['Adam', 'Bart']

第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。

把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。