Python入门（一）

**

Python入门

**
一、Python简介

1. Python的来源

2.Python是一种怎样的语言

• 解释型语言，伪编译 ：优缺点
• 胶水语言
• 开源
• 跨平台
• 免费、自由软件
• 强类型、动态类型
• 自动内存管理
• 面向对象
• 有大量可用的库
• 增加其他语言编写并编译的模块即可扩展功能

3.Python的特点

1）简单、易学
Python是一种代表简单主义思想的语言，有简单的语法，容易上手。 Python的这种伪代码本质是它最大的优点之一。Python使你能够专注于解决问题而不是去搞明白语言本身。

2）面向对象的高层语言
无需关注底层细节，而C/C++中需要操作指针。与其他语言相比， Python以强大而又简单的方式实现面向对象编程。

3）解释性
Python程序不需要编译成二进制代码，可以直接在源代码上运行。对于编译性语言（C/C++），源文件->编译/链接器->可执行文件。

4）免费开源，可移植性
Unix衍生系统， Win32系统家族，掌上电脑/手机，游戏控制台（PSP）等等。

5）可扩展性，可嵌入性
如果一段关键代码希望运行得更快或者希望算法不公开，你可以把这部分程序用C或C++编写，然后在Python程序中使用它们。你可以把Python嵌入到C/C++程序，从而向程序用户提供脚本功能。

6）丰富的库
Python标准库确实很庞大，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、等等。此外，还有其他高质量的库，如wxPython、 Twisted和图像库等等。

4.Python和其它语言的对比

二、Python数据类型

1.数字Number

1）整数
Python可以处理任意大小的整数，包括负整数。
isinstance(1, int)
True

2）浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x10^9和12.3x10^8是相等的。
但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

注意：整数运算的结果永远是精确的，而浮点数运算的结果不一定精确，因为计算机内存再大，也无法精确表示出无限循环小数

3）分数fractions

4）复数complex numbers

2.字符串
字符串是以”或”“括起来的任意文本。

1）如果字符串本身包含’怎么办？
比如我们要表示字符串 I’m OK ，这时，可以用” “括起来表示：”I’m OK”

2）类似的，如果字符串包含”，我们就可以用’ ‘括起来表示：
‘Learn “Python” in imooc’

3）如果字符串既包含’又包含”怎么办？
要表示字符串 Bob said “I’m OK”.
由于 ’ 和 ” 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为：
‘Bob said \”I\’m OK\”.’

注意：转义字符 \ 不计入字符串的内容中。

4）raw字符串与多行字符串

• 如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：
  r’(~_~)/ (~_~)/’

• 但是r’…’表示法不能表示多行字符串，也不能表示包含’和 “的字符串（为什么？）
  如果要表示多行字符串，可以用”’…”’表示：
  ”’Line 1
  Line 2
  Line 3”’
  上面这个字符串的表示方法和下面的是完全一样的：
  ‘Line 1\nLine 2\nLine 3’

• 还可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串：
  r”’Python is created by “Guido”.
  It is free and easy to learn.
  Let’s start learn Python in imooc!”’

5）对字符串切片

字符串 ‘xxx’和 Unicode字符串 u’xxx’也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：

‘ABCDEFG’[:3]
‘ABC’

‘ABCDEFG’[-3:]
‘EFG’

‘ABCDEFG’[::2]
‘ACEG’

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

6）字符串运算

7）常用字符串方法

3.布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。

注：布尔值可以用and、or和not运算。

and运算是与运算，只有所有都为 True，and运算结果才是 True。
or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。
not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。

4.空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

5.List

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
比如，列出班里所有同学的名字，就可以用一个list表示：
[‘Michael’, ‘Bob’, ‘Tracy’]
[‘Michael’, ‘Bob’, ‘Tracy’]

list是数学意义上的有序集合，也就是说，list中的元素是按照顺序排列的。

构造list非常简单，按照上面的代码，直接用 [ ]把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list：

classmates = [‘Michael’, ‘Bob’, ‘Tracy’]
classmates # 打印classmates变量的内容
[‘Michael’, ‘Bob’, ‘Tracy’]

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：

L = [‘Michael’, 100, True]

一个元素也没有的list，就是空list：
empty_list = []

注意:
1）索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。

2）倒数第一用-1表示，倒数第二用 -2 表示，倒数第三用 -3 表示，…
Print L[-1] #倒数第一

3）列表常用方法

替换元素：
对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。

6）对list进行切片<正序>

• 取一个list的部分元素是非常常见的操作。比如，一个list如下：
  L = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
  取前3个元素，应该怎么做？
  笨办法：
  [L[0], L[1], L[2]]
  [‘Adam’, ‘Lisa’, ‘Bart’]
  之所以是笨办法是因为扩展一下，取前N个元素就没辙了。

取前N个元素，也就是索引为0-(N-1)的元素，可以用循环：

r = []
n = 3
for i in range(n):
… r.append(L[i])
…
r
[‘Adam’, ‘Lisa’, ‘Bart’]
对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

对应上面的问题，取前3个元素，用一行代码就可以完成切片：
L[0:3]
[‘Adam’, ‘Lisa’, ‘Bart’]
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。
L = range(1, 101)
print L[0:10] #0到9
print L[2::3] #每隔3个取一个
print L[4:50:5] #不大于50，每隔5个取一个

7）对list倒序切片
对于list，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒序切片，试试：
L = [‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
L[-2:]
[‘Bart’, ‘Paul’]

L[:-2]
[‘Adam’, ‘Lisa’]

L[-3:-1]
[‘Lisa’, ‘Bart’]

L[-4:-1:2]
[‘Adam’, ‘Bart’]

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

8）生成列表：列表生成式

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：
range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, …, 10x10]怎么做？方法一是循环：
L = []
for x in range(1, 11):
… L.append(x * x)
…
L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

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

6.Tuple
tuple是另一种有序的列表，称为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

同样是表示班里同学的名称，用tuple表示如下：
t = (‘Adam’, ‘Lisa’, ‘Bart’)

创建tuple和创建list唯一不同之处是用( )替代了[ ]。

现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。
获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。

1）创建单元素tuple：
tuple和list一样，可以包含 0 个、1个和任意多个元素。
包含多个元素的 tuple，前面我们已经创建过了。
包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：
t = ()
print t
()

创建包含1个元素的 tuple 呢？来试试：
t = (1)
print t
1
好像哪里不对！t 不是 tuple ，而是整数1。为什么呢？
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：
t = (1,)
print t
(1,)

Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

2）多元素 tuple 加不加这个额外的“,”效果是一样的：
t = (1, 2, 3,)
print t
(1, 2, 3)

3）“可变”的tuple
t = (‘a’, ‘b’, [‘A’, ‘B’])
L = t[2]
L[0] = ‘X’
L[1] = ‘Y’
print t
(‘a’, ‘b’, [‘X’, ‘Y’])

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

7.dict
d = {
‘Adam’: 95,
‘Lisa’: 85,
‘Bart’: 59
}

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

1）dict特点：

第一个特点：查找速度快。无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

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

第二个特点：*存储的key-value序对是没有顺序的*！这和list不一样：
d = {
‘Adam’: 95,
‘Lisa’: 85,
‘Bart’: 59
}

当我们试图打印这个dict时：
print d
{‘Lisa’: 85, ‘Adam’: 95, ‘Bart’: 59}

打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。

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

可以试试用list作为key时会报什么样的错误。
不可变这个限制仅作用于key，value是否可变无所谓：
{
‘123’: [1, 2, 3], # key 是 str，value是list
123: ‘123’, # key 是 int，value 是 str
(‘a’, ‘b’): True # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
}
最常用的key还是字符串，因为用起来最方便。

2）访问dict：

可以简单地使用 d[key] 的形式来查找对应的 value；

• 先判断一下 key 是否存在，用 in 操作符：
  if ‘Paul’ in d:
  print d[‘Paul’]

• 使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

  print d.get(‘Bart’)
  59

  print d.get(‘Paul’)
  None

3）更新dict
dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：
d = {
‘Adam’: 95,
‘Lisa’: 85,
‘Bart’: 59
}

要把新同学’Paul’的成绩 72 加进去，用赋值语句：
d[‘Paul’] = 72
再看看dict的内容：
print d
{‘Lisa’: 85, ‘Paul’: 72, ‘Adam’: 95, ‘Bart’: 59}

如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value：
d[‘Bart’] = 60
print d
{‘Lisa’: 85, ‘Paul’: 72, ‘Adam’: 95, ‘Bart’: 60}

4）遍历dict
由于dict也是一个集合，所以，遍历dict和遍历list类似，都可以通过 for 循环实现。

直接使用for循环可以遍历 dict 的 key：

d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 }
for key in d:
print key

Lisa
Adam
Bart
由于通过 key 可以获取对应的 value，因此，在循环体内，可以获取到value的值。

5）迭代dict的value

我们已经了解了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

如果仔细阅读Python文档，还可以发现，dict除了values()方法外，还有一个 itervalues() 方法，用itervalues()方法替代values()方法，迭代效果完全一样：

d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 }
print d.itervalues()

for v in d.itervalues():
print v
85
95
59

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

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

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

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

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

6）迭代dict的key和value

我们了解了如何迭代 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() 不占用额外的内存。

7）字典常用方法



8.Set

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

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

创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
s = set([‘A’, ‘B’, ‘C’])

可以查看 set 的内容：
print s
set([‘A’, ‘C’, ‘B’])

请注意，上述打印的形式类似 list， 但它不是 list，仔细看还可以发现，打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。

因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？

s = set([‘A’, ‘B’, ‘C’, ‘C’])
print s
set([‘A’, ‘C’, ‘B’])
len(s)
3

结果显示，set会自动去掉重复的元素，原来的list有4个元素，但set只有3个元素。

1）set特点

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

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

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

  -无重复元素

2）set的这些特点，可以应用在哪些地方呢？

星期一到星期日可以用字符串’MON’, ‘TUE’, … ‘SUN’表示。
假设我们让用户输入星期一至星期日的某天，如何判断用户的输入是否是一个有效的星期呢？
可以用 if 语句判断，但这样做非常繁琐：
x = ‘???’ # 用户输入的字符串if x!= ‘MON’ and x!= ‘TUE’ and x!= ‘WED’ … and x!= ‘SUN’:
print ‘input error’else:
print ‘input ok’
注意：if 语句中的…表示没有列出的其它星期名称，测试时，请输入完整。

如果事先创建好一个set，包含’MON’ ~ ‘SUN’：

weekdays = set([‘MON’, ‘TUE’, ‘WED’, ‘THU’, ‘FRI’, ‘SAT’, ‘SUN’])
再判断输入是否有效，只需要判断该字符串是否在set中：

x = ‘???’ # 用户输入的字符串
if x in weekdays:
print ‘input ok’else:
print ‘input error’

3）访问set
由于set存储的是无序集合，所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。

例如，存储了班里同学名字的set：
s = set([‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’])

我们可以用 in 操作符判断：
Bart是该班的同学吗？
‘Bart’ in s
True

Bill是该班的同学吗？
‘Bill’ in s
False

bart是该班的同学吗？
‘bart’ in s
False
看来大小写很重要，’Bart’ 和 ‘bart’被认为是两个不同的元素。

4）遍历set
s = set([‘Adam’, ‘Lisa’, ‘Bart’])
for name in s:
… print name

Lisa
Adam
Bart

注意: 观察 for 循环在遍历set时，元素的顺序和list的顺序很可能是不同的，而且不同的机器上运行的结果也可能不同。

5）set常用方法

9.Python中Unicode字符串

字符串还有一个编码问题：

1）ASCII码：因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母 A 的编码是65，小写字母 z 的编码是122。

2）GB2312：如果要表示中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

3）Unicode：类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。

注意：因为Python的诞生比Unicode标准发布的时间还要早，所以最早的Python只支持ASCII编码，普通的字符串’ABC’在Python内部都是ASCII编码的。

Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u’…’表示，比如：

print u’中文’
中文
注意: 不加 u ，中文就不能正常显示。

Unicode字符串除了多了一个 u 之外，与普通字符串没啥区别，转义字符和多行表示法仍然有效：

转义：
u’中文\n日文\n韩文’

多行：
u”’第一行
第二行”’

raw+多行：
ur”’Python的Unicode字符串支持”中文”,
“日文”,
“韩文”等多种语言”’

如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释

目的是告诉Python解释器，用UTF-8编码读取源代码。

10.空值None

11.常见数据类型的区别

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

三、Python基础语法
1.注释
1）单行注释：以#开头
2）多行注释：用三个单引号或三个双引号将注释括起来

2.行与缩进
Python中默认每行为一条语句，但是当一行需要输入多条语句时，可以使用分号（;）表示。

Python最具特色的是使用缩进表示代码块。缩进的空格数是可变的（默认是4个），但同一代码块的语句必须包含相同的缩进空格数。

3.输入和输出
1）输入
raw_input() 用来获取控制台的输入。
raw_input() 将所有输入作为字符串看待，返回字符串类型。
python3 里 input() 默认接收到的是 str 类型。

注意：Python2中，input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

注：如果变换数据类型，可进行强制转换

2）输出print语句
Python2：
print ‘The quick brown fox’, ‘jumps over’, ‘the lazy dog’

Python3：

4.变量

• 在Python中变量不需要申明。每个变量在使用前都必须赋值，变量赋值后才会被创建。

• 在Pyhton中，变量就是变量，没有类型，我们所说的类型是变量所指内存中对象的类型。

• 等号（=）用来给变量赋值。

  -等号（=）运算符左边是一个变量名，右边是变量指向的值。

在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头。

1）单变量赋值
a = 123 # a是整数
print a
a = ‘ilove’ # a变为字符串
print a

2）多个变量赋值
a = b = c = 1
e, f, g = 1, 2, ‘run’

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。

四、迭代

1.迭代
在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）。

在Python中，迭代是通过 for … in 来完成的，而很多语言比如C或者Java，迭代list是通过下标完成的。Python的for循环抽象程度要高于Java的for循环。

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

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

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

2.迭代索引

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，再迭代，就同时获得了索引和元素本身。

五、复杂表达式

使用for循环的迭代不仅可以迭代普通的list，还可以迭代dict。
假设有如下的dict：
d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 }

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

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

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

六、多层表达式

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)