初识Python笔记

初识Python

基本数据类型

基本数据类型：

• 整数 十六进制用0x前缀和0-9，a-f表示
• 浮点数 整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差
• 字符串 以’‘或""括起来的任意文本，转义字符 \ ，多行字符串，可以用’’’…’’'表示，字符串前面加个前缀 r 表示这是一个 raw 字符串，里面的字符就不需要转义了
• 布尔值 只有True、False两种值，布尔值可以用and、or和not运算
  空值 用None表示

print 语句可以向屏幕上输出指定的文字，逗号“,”会输出一个空格

注释以 # 开头，后面的文字直到行尾都算注释

变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头

等差数列求和：

# -*- coding: utf-8 -*-
x1 = 1
d = 3  # 公差
n = 100
x100 = x1 + (n - 1) * d
s = (x1 + x100) * n / 2
print s

a = 'python'
print 'hello,', a or 'world'  # hello, python
b = ''
print 'hello,', b or 'world'  # hello, world

列表

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素

L = ['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
print L

L = [95.5,85,59]
print L[0]
print L[1]
print L[2]
print L[3]  # 报错
print L[-1]
print L[-2]
print L[-3]

L = ['Adam', 'Lisa', 'Bart']
L.append('Paul')
print L  # ['Adam', 'Lisa', 'Bart', 'Paul']

L = ['Adam', 'Lisa', 'Bart']
L.insert(0, 'Paul')
print L  # ['Paul', 'Adam', 'Lisa', 'Bart']

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L.pop()  # 'Paul'
print L  # ['Adam', 'Lisa', 'Bart']

L = ['Adam', 'Lisa', 'Paul', 'Bart']
L.pop(2)  # 'Paul'
print L  # ['Adam', 'Lisa', 'Bart']

切片：

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L[0:3]  # ['Adam', 'Lisa', 'Bart']
L[:3]  # ['Adam', 'Lisa', 'Bart']
L[1:3]  # ['Lisa', 'Bart']
L[:]  # ['Adam', 'Lisa', 'Bart', 'Paul']
L[::2]  # ['Adam', 'Bart']，第三个参数表示每N个取一个

L = range(1, 101)

print L[:10]  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print L[2::3]
print L[4:50:5]  # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L[-2:]  # ['Bart', 'Paul']
L[:-2]  # ['Adam', 'Lisa']
L[-3:-1]  # ['Lisa', 'Bart']
L[-4:-1:2]  # ['Adam', 'Bart']

L = range(1, 101)
print L[-10:]
print L[-46::5]

def firstCharUpper(s):
    return s[0:1].upper() + s[1:]

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

元组

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

tuple没有 append()方法，也没有insert()和pop()方法

t = ('Adam', 'Lisa', 'Bart')

t = (0,1,2,3,4,5,6,7,8,9)
print t

t = (1)
print t  # 1

t = (1,)
print t  # (1,)

t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0] = 'X'
L[1] = 'Y'
print t  # ('a', 'b', ['X', 'Y'])

t = ('a', 'b', ('A', 'B'))
print t  # ('a', 'b', ('a', 'b'))

流程控制

Python代码的缩进规则，缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

if 语句后接表达式，然后用:表示代码块开始

age = 20
if age >= 18:
    print 'your age is', age  # your age is 20
    print 'adult'  # adult

score = 55
if score >= 60:
    print 'passed'
else:
    print 'failed'

score = 85

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

for 循环可以依次把list或tuple的每个元素迭代出来

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

和 for 循环不同的另一种循环是 while 循环，while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束

break退出循环
continue继续循环

sum = 0
x = 1
while x < 100:
    sum += x
    x += 2
print sum

sum = 0
x = 1
n = 1
while True:
    sum += x
    x = 2 * x
    n += 1
    if n > 20:
        break
print sum

sum = 0
x = 0
while True:
    x = x + 1
    if x > 100:
        break
    if x % 2 == 0:
        continue
    sum += x
print sum

for x in [1,2,3,4,5,6,7,8,9]:
    for y in [1,2,3,4,5,6,7,8,9]:
        if x < y:
            print x * 10 +  y

dict

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

通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：
一是先判断一下 key 是否存在，用 in 操作符
二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None

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

dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样

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

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

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

d = {
    95: 'Adam',
    85: 'Lisa',
    59: 'Bart'
}
d[72] = 'Paul'

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
for key in d:
    print key,':',d[key]

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

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

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

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

s = set(['A', 'B', 'C', 'C'])
print s  # set(['A', 'C', 'B'])
len(s)  # 3

s = set(['adam', 'lisa', 'bart', 'paul'])
print 'adam' in s
print 'bart' in s

months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])
x1 = 'Feb'
x2 = 'Sun'

if x1 in months:
    print 'x1: ok'
else:
    print 'x1: error'
    
if x2 in months:
    print 'x2: ok'
else:
    print 'x2: error'

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
    print x[0],':',x[1]

set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。

s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for x in L:
    if x in s:
        s.remove(x)
    else:
        s.add(x)
print s

函数

在交互式命令行通过 help(abs) 查看abs函数的帮助信息

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误
如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误

abs(-20)  # 20

cmp(1, 2)  # -1
cmp(2, 1)  # 1
cmp(3, 3)  # 0

int('123')  # 123
int(12.34)  # 12

str(123)  # '123'
str(1.23)  # '1.23'

L = []
for i in range(1, 101):
    L.append(i * i)
print sum(L)

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。return None可以简写为return。

def square_of_sum(L):
    sum = 0
    for i in L:
        sum += i * i
    return sum

print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])

math包提供了sin()和 cos()函数，我们先用import引用它

Python的函数返回多值其实就是返回一个tuple

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)
print quadratic_equation(1, -6, 5)

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

def greet(x='world'):  # 默认参数
    print 'Hello,',x,'.'

greet()
greet('Bart')

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中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）。

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

迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

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

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

Python中，迭代永远是取出元素本身，而非元素的索引。使用 enumerate() 函数

实际上，enumerate() 函数把：[‘Adam’, ‘Lisa’, ‘Bart’, ‘Paul’]
变成了类似：[(0, ‘Adam’), (1, ‘Lisa’), (2, ‘Bart’), (3, ‘Paul’)]

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list
dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样

items() 方法把dict对象转换成了包含tuple的list

for i in range(1,101):
    if i % 7 == 0:
        print i

L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in enumerate(L):
    print index, '-', name

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

sum = 0.0
for v in d.itervalues():
    sum += v
print sum / len(d)

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

sum = 0.0
for k, v in d.items():
    sum = sum + v
    print k,':',v
print 'average', ':', sum / len(d)

列表生成式

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

要生成[1x1, 2x2, 3x3, …, 10x10]，方法一是循环
但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：[x * x for x in range(1, 11)]

range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,…]

列表生成式的 for 循环后面还可以加上 if 判断：[x * x for x in range(1, 11) if x % 2 == 0]

print [n * (n+1) for n in range(1, 100, 2)] # [1x2, 3x4, 5x6, 7x8, ..., 99x100]

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def generate_tr(name, score):
    if score < 60:
        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)

tds = [generate_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>'

def toUppers(L):
    return [x.upper() for x in L if isinstance(x, str)]
print toUppers(['Hello', 'world', 101])

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]