编码格式

1
2
3
4
# encoding:utf-8
# 有了第一段代码，就可以写中文了。
# Python官方文档https://docs.python.org/2/library/
print 'Hello Python'

数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
# Python中的数据类型
print(45678+0x12fd2)
print('Learn Python in imooc')
print(100 < 99)
print(0xff == 255)
# Python 的变量
x1 = 1
d = 3
n = 100
x100 = 298
s = 50*(x100+1)
print s

Print

1
2
3
4
5
6
7
8
9
10
11
# Python的print
# print会依次打印每个字符串，遇到逗号“,”会输出一个空格
print 'The quick brown fox','jumps over','the lazy dog'
print (100 + 200)
print "HELLO,".lower()+"python.".upper() 
# Python 转义字符
print 'Bob said \"I\'m OK\".'
# 多行raw字符串 r'''...'''
print r'''"To be, or not to be": that is the question.
Whether it's nobler in the mind to suffer.'''

逻辑运算

1
2
3
4
5
6
7
# 逻辑 and 和 or 运算的一条重要法则：短路计算。
print r'''1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；
如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；
如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
'''

List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Python List
# list是一种有序的集合，可以随时添加和删除其中的元素。
L = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
print L
print L[2] 
print L[-2] # 倒序访问
L.append('Paul')# 追加
L.insert(0, 'PaP')# 插入
print L
L.pop()# pop最后一个
L.pop(0)
print L
L[0] = 'Beyond'# 更改
print L
# List切片
#L[0:3] 取0，1，2
#L[:3] 取从零开始到 3，不包括3
#L[1:3] 取1，2
#L[:] 取全部
#L[1:10:2] 取从1开始，每隔2取出，直到10，不包括10
#L[-4:-1:2] 取从倒数第4开始，每隔2取出，直到倒数第1个

Tuple

1
2
3
4
5
6
7
8
9
10
11
12
13
# tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
t = ('Adam', 'Lisa', 'Bart')
print t
# tuple没有 append()方法，也没有insert()和pop()方法。
# 单元素 tuple 要多加一个逗号“,”
k = ('king',)
print k
# 改变元素中的元素
t = ('a', 'b', ['A', 'B']) # 其实更改的是tuple中的list中的元素，tuple中的元素没有改变
L = t[2]
L[0] = 'X'
L[1] = 'Y'
print t

判断语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Python的条件判断语句
# if
age = 20
if age >= 18:
    print 'your age is', age
    print 'adult'
print 'END'
# if else
if not age >= 18:
    print 'teenager'
else:
    print 'adult'
# if elif else
if age >= 18:
    print 'adult'
elif age >= 6:
    print 'teenager'
elif age >= 3:
    print 'kid'
else:
    print 'baby'

循环语句

1
2
3
4
5
6
7
8
9
10
11
12
13
# Python的循环
# for
L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print name
# while
N = 10
x = 0
while x < N:
    print x
    x = x + 1
    if x == 6:
    	break

Dict

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# dict 类似c++中的map，swift中的字典
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
print 'd的长度为',len(d)
# 机智的写法，不担心找不到值
if 'Paul' in d:
    print d['Paul']
print 'Bart:', d['Bart']
d['Paul'] = 72
print d
# 遍历
for x in d:
    print x+':',d[x]
#dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
#不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
#由于dict是按 key 查找，所以，在一个dict中，key不能重复。
#dict的第二个特点就是存储的key-value序对是没有顺序的！
#dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

Set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Pyhton的Set
# set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
s = set(['A', 'B', 'C', 'C'])
print s
set(['A', 'C', 'B'])
len(s)
print 'C' in s
# set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
# set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
s = set(['Adam', 'Lisa', 'Bart'])
s.remove('Lisa')
s.add('Beyond')
for name in s:
    print name

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# Python的函数
print abs(-11)
print cmp(3,9)
print int(12.31)
print str(101)
# return None可以简写为return。
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
# 多个返回值的函数
import math
# 由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
def move(x, y, step=0, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print x, y
r = move(100, 100, 60, math.pi / 6)
print r # 返回了一个tuple
# 可变参数
def fn(*args):
    print args
# Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 迭代
for i in range(1,100):
    if i%7==0:
        print i
# 索引和值
# enumerate() 函数把：
#['Adam', 'Lisa', 'Bart', 'Paul']
#变成了类似：
#[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for a, b in enumerate(L):
    print a, '-', b
# dict迭代
#dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
for v in d.values():
    print v
# 用 itervalues() 方法替代 values() 方法，迭代效果完全一样：
for v in d.itervalues():
    print v
# 区别
#1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
#2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
#3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

列表生成式

# Python列表生成式
print [x * x for x in range(1, 11) if x % 2 == 0]
print [m + n for m in 'ABC' for n in '123']
# 复杂的列表生成式
tds = ['<tr><td>%s</td><td>%s</td></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>'