Python基础

# coding=utf-8
# 设置编码

输出

# 输出多个变量(用, 隔开)：字符串, 表达式  =  '字符串+表达式的值'
print '100 + 200 =', 100 + 200

a = 'A'
b = 'B'
print a, '-->', b

判断分支

# if-elif-else 
score = 85
if score >= 90:
    print 'excellent'
elif score >= 80:
    print 'good'
elif score >= 60:
    print 'passed'
else:
    print 'failed'

list

# list 声明
L = ['Adam', 'Lisa', 'Bart']

# list 添加元素 方式1
L.append('Paul')

# list 添加元素 方式2
L.insert(0, 'Paul')

# list 删除元素
L.pop()  # 删除最后一个
L.pop(2)  # 删除第三个

# list 替换元素
L[2] = 'Paul'

# tuple 中含“可变元素”：list
t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0] = 'X'
L[1] = 'Y'
print t  # 可以看到list中的元素被改变了

tuple

tuple：tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

# tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
# tuple 声明
t = ('Adam', 'Lisa', 'Bart')
# tuple 创建单元素(需要添加一个,)
t = (1,)

dict

dict存储的是键值对形式的数据（无序）。

# dict 的声明
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
# 注意：一个 key-value 算一个长度。所以  len(d) 返回的是含有的键值对数
# 可以使用d[key] 的形式来查找对应的 value。
# 注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。
# 要避免 KeyError 发生，有两个办法：
# 一是先判断一下 key 是否存在，用 in 操作符：
if 'Paul' in d:
    print d['Paul']
# 二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：
print d.get('Paul')

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

# dict 更新值
d['Paul'] = 72

# dict 遍历
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
for key in d:
    print key

set

set存储的是一组不重复的无序元素。

# set 声明
s = set(['Adam', 'Lisa', 'Bart'])


# 判断元素是否存在 set 中
s = set(['Adam','Lisa','Bart'])
name = 'Lisa'
if name in s:
    print 'exists'
else:
    print 'not exists'


# set 遍历
s = set(['Adam','Lisa','Bart'])
for name in s:
    print name


# 含复杂元素的set
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for obj in s:
    print obj[0] + ':', obj[1]


# set 更新: s.add() 添加元素,  s.remove() 删除元素
# 注意：如果添加的元素已存在, 不会报错。如果要移除的元素不存在, 就会报错, 所以移除前需要做判断
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

函数

# 官方函数文档： http://docs.python.org/2/library/functions.html
# 命令行通过 help(abs) 可查看abs函数的帮助信息
# 在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。故return None可以简写为return。另外，可以有一个返回值，也可以有多个返回值（其实就是返回一个tuple）。

# 定义函数：函数接受一个list, 返回list中每个元素平方的和
def square_of_sum(L):
    sum = 0
    for x in L:
        sum += x * x
    return sum

print square_of_sum([1, 2, 3, 4, 5])


# 定义函数：求一元二次方程的两个解。求根公式：x = (-b±√(b²-4ac)) / 2a
import math
def quadratic_equation(a, b, c):
    t = math.sqrt(b * b - 4 * a * c)
    return (-b + t) / (2 * a), ( -b - t )/ (2 * a)

print quadratic_equation(2, 3, 0)


# 汉诺塔(递归函数的应用)
# 我们对柱子编号为a, b, c，将所有圆盘从a移到c可以描述为：如果a只有一个圆盘，可以直接移动到c；如果a有N个圆盘，可以看成a有1个圆盘（底盘） + (N-1)个圆盘，首先需要把 (N-1) 个圆盘移动到 b，然后，将 a的最后一个圆盘移动到c，再将b的(N-1)个圆盘移动到c。
def move(n, a, b, c):
    if n ==1:
        print a, '-->', c
        return
    move(n-1, a, c, b)
    print a, '-->', c
    move(n-1, b, a, c)

move(4, 'A', 'B', 'C')


# 函数定义默认参数。定义一个计算 x 的 n 次方的函数(默认为平方)：
# 注意：因为函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(5)
power(5,3)


# 函数定义可变参数：参数的名字前面加个 * 号。
# 定义一个求平均数的函数
def average(*args):
    sum = 0.0
    if len(args) == 0:
        return sum
    for x in args:
        sum += x
    return sum / len(args)

print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)

list切片

取list中指定范围符合条件的元素。

# L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。如果第一个索引是0，还可以省略：L[:3]
# 只用一个 : ，表示从头到尾：L[:]
# 切片操作还可以指定第三个参数：第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。
# 第一个参数省略：从0开始取。 第二个参数省略：到最后一个。

# 创建一个数列：[1, 2, 3, ..., 100]
L = range(1, 101)
# 1. 前10个数；2. 3的倍数；3. 不大于50的5的倍数。
print L[0:10]
print L[2::3]
print L[4:50:5]


# 字符串切片
# 字符串可以看作是一个list
# 将首字母转大写的函数
def firstCharUpper(s):
    return s[0].upper() + s[1:]

print firstCharUpper('hello')
print firstCharUpper('sunday')
print firstCharUpper('september')

集合迭代

集合是指包含一组元素的数据结构，已经介绍的包括：

1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict

# 遍历添加索引： enumerate(L)函数。索引从0开始
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
    print index, '-', name


# zip()函数可以把两个 list 变成一个 list
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in zip(range(1, len(L)+1), L):
    print index, '-', name


# dict 迭代
# 迭代值 values() 和 itervalues()。 values() 方法实际上把一个 dict 转换成了包含 value 的list。但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

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

# 迭代 key
for k in d:
    print k

# 迭代 value 方法1
for v in d.values():
    print v

# 迭代 value 方法2
for v in d.itervalues():
    print v

# 迭代dict的 key 和 value。d.items() 和  iteritems()。iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
# 给定 dict，打印出 name : score，最后再打印出平均分 average : score。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for k, v in d.iteritems():
    sum = sum + v
    print k, ':', v
print 'average', ':', sum / len(d)

生成列表

# 例1、生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
range(1, 11)

# 例2、生成[1x1, 2x2, 3x3, ..., 10x10]
# 方式1
L = []
for x in range(1, 11):
    L.append(x * x)
# 方式2(列表生成式)
print [x * x for x in range(1, 11)]

# 例3、生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]
print [x * (x + 1) for x in range(1, 100, 2)]

复杂表达式

# 用给定数据生成表格，对于没有及格的同学，请把分数标记为红色。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
# 1、首先，定义生成行元素的方法
def generate_tr(name, score):
    if score < 60:
        # 字符串可以通过 % 进行格式化，用指定的参数替代 %s。
        return '<tr><td>%s</td><td style="color:red">%s</td></tr>' % (name, score)
    return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)
# 2、用表达式生成表格(行数据)
tds = [generate_tr(name, score) for name, score in d.iteritems()]
print '<table border="1">'
print '<tr><th>Name</th><th>Score</th><tr>'
# 字符串的join()方法可以把一个 list 拼接成一个字符串。
print '\n'.join(tds)
print '</table>'



# 表达式追加添加条件：在for循环之后添加
# 例1、指定范围内偶数的平方
[x * x for x in range(1, 11) if x % 2 == 0]

# 例2、编写一个函数，它接受一个 list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略。isinstance(x, str) 可以判断变量 x 是否是字符串。字符串的 upper() 方法可以返回大写的字母。
def toUppers(L):
    return [x.upper() for x in L if isinstance(x, str)]
print toUppers(['Hello', 'world', 101])

# 列表生成式嵌套
# 例3、利用3层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为从右到左倒过来还是 121。
print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]