a = 'ABC'时，Python解释器干了两件事情： 1. 在内存中创建了一个'ABC'的字符串； 2. 在内存中创建了一个名为a的变量，并把它指向'ABC'。 也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码： a = 'ABC' b = a a = 'XYZ' print b

>>> [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() 方法可以返回大写的字母。

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

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

可变参数 args 是一个tuple，当0个参数传入时，args是一个空tuple。

参考代码:

def average(*args):
    sum = 0.0
    if len(args) == 0:
        return sum
    for x in args:
        sum = sum + x
    return sum / len(args)
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)

Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

定义可变参数的目的也是为了简化调用。假设我们要计算任意个数的平均值，就可以定义一个可变参数：

def average(*args):
    ...

这样，在调用的时候，可以这样写：

>>> average()
0
>>> average(1, 2)
1.5
>>> average(1, 2, 2, 3, 4)
2.4

list[]数列 list[0]，list[1]……表示数列的索引，从0开始

L是一个数列，L,append（）在数列末尾追加

L.insert（索引,添加参数），如L.insert（2,'param1'）

L.pop( )删除数列中指定索引的值 L.pop（2）,不加索引值，默认删除末尾

---重赋值

L(2)='param1'  赋值符号直接将数列中索引为2的值进行重新赋值即可

tuple是另一种有序的列表，中文翻译为“ 元组 ”。

tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了,创建tuple和创建list唯一不同之处是用( )替代了[ ],索引概念一样的使用

数列 L=[1,2,3]   元组 L1=（1,2,3）

t = (1,)

print t

打印出结果为（1，） 

t = (1)

print t

打印出结果为1

结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。所以 Python 规定，单元素 tuple 要多加一个逗号“,”

dict 表示的是一个元组(集合)（类似json的含义，有key值和value）

花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

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

由于dict也是集合，len() 函数可以计算任意集合的大小：

注意: 一个 key-value 算一个，因此，dict大小为3。

>>> len(d)
3

dict的特点:按照key查找快，但是占用内存;存储的key-value序对是没有顺序的; key 的元素必须不可变

给disc新赋值，直接用d[key]=value  写入到d元组中，是无序的，任意排序，不会放在最后

针对于 dict的for循环 ，遍历的是dict 的 key值：

d = {

    'Adam': 95,

    'Lisa': 85,

    'Bart': 59

}

for key in d:

     print (key+':',d[key])

set 持有一系列元素，和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像

例如

>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])

经常用来判断某元素是否在set的集合中 例如

print 'D' in s  返回false   注意区分大小写 

set 的遍历也是用for循环，增加用s.add(),

删除用s.remove()如果不存在，则会报错，一般会用if进行判断，再操作

例如:

s = set(['Adam', 'Lisa', 'Paul'])

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

for name in L:

    if name in s:

        s.remove(name)

    else:

        s.add(name)

print s

===================

1、if----else----

2、if----elif----else

3、几类循环

     3.1 for   

     例子：
        L = ['Adam', 'Lisa', 'Bart']
        for name in  L:
        
  3.2 while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束
      N = 10
      x = 0
      while x < N:
          print x
          x = x + 1
  3.3 break 退出循环
       sum = 0
       x = 1
       while True:
           sum = sum + x
           x = x + 1
           if x > 100:        
               break
       print sum   
  3.4 continue继续循环 
  老师只想统计及格分数的平均分，就要把 x < 60 的分数剔除掉
  利用 continue，可以做到当 x < 60的时候，不继续执行循环体的后续代码，直接进入下一次循环
   L = [75, 98, 59, 81, 66, 43, 69, 85]
   sum = 0.0
   n = 0
   for x in L:
       if x < 60:
           continue
       sum = sum + x
       n = n + 1
   print sum / n
   
  例子： 计算100内，所有奇数的和
   sum = 0
   x = 0
   while True:    
       x = x + 1    
       if x > 100:        
           break    
       if x%2==0:
           continue
       sum = sum + x
    print sum

print  10/4  结果是2

print 10.0/4 结果是2.0  

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

短路计算。

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解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

range()这个函数是有三个参数的，括号里可以输入三个值，用‘逗号，’隔开：

假使你只在里面写了一个参数，如range(10)，表示从0开始到9，[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

假使你只在里面写了两个参数，如range(1,10),表示从1开始到9，[1, 2, 3, 4, 5, 6, 7, 8, 9]

假使你只在里面写了三个参数，如range(1,10, 2),表示从1开始，每加2取一个数，直到这个数大于10，但是不取这个数，[1, 3, 5, 7, 9]

<table>是<tr>的上层标签 <tr>必须在一个<table></table>里面,它不能单独使用,相当于<table>的属性标签.   <table>表示一个表格,<tr>标示这个表格中间的一个行   <td>表示行中的一个列,需要嵌套在<tr></tr>中间 <th >是标题的列，<tr >是行，<td >是正常的列

条件过滤

列表生成式的 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() 方法可以返回大写的字母。

使用 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

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

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义

很多时候跟版本还有编译器有关，你试着在print u'哈哈'这里加上半角括号试一下，就可以了,这里只是说打印

1. '....' 和“.....”都可用来表示字符串
   

2.要表示的字符串中包含字符串表示符的一种时，可用另一种来表示整个字符串的始末

3.既包含‘,又包含“”的字符串，在表示时需要对某些特殊字符串进行转义，理论上，转完其中一种，就可用另一种来表示字符串的始末了

4.区分好'' 与“  ”不能用两个单引号表示一个双引号