Python学习

Python的注释

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

  # print 'hello, python.'

Python的变量

a = 123    # a是整数
print a
a = 'imooc'   # a变为字符串
print a

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

Python中定义字符串

----------
如果字符串本身包含'比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示：
print "I'm OK"
----------
类似的，如果字符串包含"，我们就可以用' '括起来表示
print 'Learn "Python" in imooc'
----------
如果字符串既包含'又包含"这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。要表示字符串 
Bob said "I'm OK".
由于 ' 和 " 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为
'Bob said \"I\'m OK\".'
----------
常用的转义字符还有：
\n 表示换行
\t 表示一个制表符
\\ 表示 \ 字符本身

----------

Python中raw字符串与多行字符串

 1. 在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：
r'\(~_~)/ \(~_~)/'
 2. 但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串
如果要表示多行字符串，可以用'''...'''表示
 3. '''Line 1
    Line 2
    Line 3''' 与 'Line 1\nLine 2\nLine 3'表示的含义是一样的


 4. # -*- coding: utf-8 -*-  //-*- coding:utf-8 -*- 此句的作用是支持utf-8编码
    print '''静夜思
    床前明月光，
    疑是地上霜。
    举头望明月，
    低头思故乡。'''
 5. Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True
 6. 构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。
    L = ['Michael', 100, True]，由于python是动态语言，所以列表L中可以放不同数据类型

Python之倒序访问list

 1. L = [95.5, 85, 59]
    print L[-1]
    print L[-2]
    print L[-3]
    运行结果：59
            85
            95.5
    L[-1] 表示倒数第一个数，L[-2]表示倒数第二个数,......
 2. 加新元素
    L.append(78),其中append方法总是添加在尾部
    L.insert(0,55),其中0表示插入位置，后一个表示插入新元素

 3. 从list删除元素
    L.pop()，其中pop函数总是删除最后一个函数，59被删除了，
    如果要删除85这个元素，L.pop(1),1表示85在L中的索引位置

 4. 创建tuple
    t=(95.5,85,59),tuple称为元组，其成员变量不可修改
    （其指针指向不变），其访问成员方法和list一样

 5. 创建单元素tuple
    t=(1)的结果是整数1，因为（1）会被编译器运算花括号里的1，
    要表示成一个tuple的话，改成t=(1,)、t=('sdfsd',)等加一个逗号

 6. t = ('a', 'b', ['A', 'B'])，包含'a','b',和一个list
    list[0]='X',list[1]='Y'是有效的
    tuple所谓的“不变”是说，tuple的每个元素，指向永远不变，
    即指向'a'，就不能改成指向'b'，指向一个list，
    就不能改成指向其他对象，但指向的这个list本身是可变的！

条件判断和循环

 1. if条件判断，python对缩进特别严格。
    age = 20
    if age >= 18:
        print 'your age is', age
        print 'adult'
    print 'END'
    具有相同缩进的代码被视为代码块，第三行和第四行具有相同缩进，如果if
    条件为真，则执行。
    缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，
    更不要混合Tab和空格。

 2. if else语句
    if age >= 18:
        print 'adult'
     else:
        print 'teenager'
     注意else后有一个冒号

 3. if-elif-else，多判断条件
    if age >= 18:
        print 'adult'
    elif age >= 6:
        print 'teenager'
    elif age >= 3:
        print 'kid'
    else:
        print 'baby'
 4. for循环
    L = ['Adam', 'Lisa', 'Bart']
    for name in L:
        print name
    注意，print name也要注意缩进，缩进4格

 5. while循环
    N = 10
    x = 0
    while x < N:
        print x
        x = x + 1
 6. break退出循环
    sum = 0
    x = 1
    while True:
        sum = sum + x
        x = x + 1
        if x > 100:
            break
    print sum
 7. continue
    for x in L:
    if x < 60:
        continue
    sum = sum + x
    当x小于60时，continue跳出本次循环，进行下一次循环

dict和set

 1. dict
    dicts = {
        'Adam': 95,
        'Lisa': 85,
        'Bart': 59
    }
    花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
    由于dict也是集合，len() 函数可以计算任意集合的大小
    可以简单地使用 d[key] 的形式来查找对应的 value，

    (1)if 'Paul' in d:
        print d['Paul']//判断Pual是否存在于d中，从而避免了报错
    (2)dict本身提供的一个get方法，在Key不存在的时候，返回None：
    >>> print d.get('Bart')
        59
    >>> print d.get('Paul')
        None     
    (3)dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样：因此不能用dict存储有序的集合
    （4）dict的第三个特点是作为 key 的元素必须不可变，因此一个list不能作为key,最常用的key是字符串
    （5）新添元素：d['Paul'] = 72,覆盖旧元素：d['Brat'] =88 

 2.循环遍历dict
   以  name:score  格式打印出来
  d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
  }
  for key in d:
      print key+':',d[key]

 2. set
     (1)set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
     创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：  s = set(['A', 'B', 'C'])
     必须使用list,s = set('A', 'B', 'C')报错
     (2)由于set存储的是无序集合，所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。
    'bart' in s 
     False
     (3)set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
        set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的,最后，set存储的元素也是没有顺序的。
     (4)for循环遍历set
     >>> s = set(['Adam', 'Lisa', 'Bart'])
     >>> for name in s:
     ...     print name
         s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
        for x in s:
             print x[0],':',x[1]
      (5)更新set    添加  ：s = set([1, 2, 3]  s.add(4)
                  删除  ：s.remove(3),如果3不在set中，报错

函数

 1.  >>> help(函数名) 
     某函数的帮助信息。
     >>> abs(-20)//调用函数信息
     20
    Python内置的常用函数还包括数据类型转换函数，比如   int()函数可以把其他数据类型转换为整数：  >>> int（'123'）123  >>> str(123) 123
    (1)sum()函数接受一个list作为参数，并返回list所有元素之和。请计算 1*1 + 2*2 + 3*3 + ... + 100*100。
    L = []
    x=1
    y=0
    while x<=100:
        y=x*x
        L.append(y)
        x=x+1;
    print sum(L)
 2. 编写函数
     定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
    def my_abs(x):
        if x >= 0:
            return x
        else:
            return -x

 3. Python函数之返回多值,其返回多值其实就是返回一个tuple
    (1)# math包提供了sin()和 cos()函数，我们先用import引用它
    import math
    def move(x, y, step, angle):
        nx = x + step * math.cos(angle)
        ny = y - step * math.sin(angle)
        return nx, ny

    (2)x, y = move(100, 100, 60, math.pi / 6)
    >>> print x, y
    151.961524227 70.0
    (3)>>> r = move(100, 100, 60, math.pi / 6)
      >>> print r
      (151.96152422706632, 70.0）//r 为一个tuple

 4. 递归函数
    我们对柱子编号为a, b, c，将所有圆盘从a移到c可以描述为：
    如果a只有一个圆盘，可以直接移动到c；
    如果a有N个圆盘，可以看成a有1个圆盘（底盘） + (N-1)个圆盘，首先需要把 (N-1) 个圆盘移动到 b，然后，将 a的最后一个圆盘移动到c，再将b的(N-1)个圆盘移动到c。
    请编写一个函数，给定输入 n, a, b, c，打印出移动的步骤：
    move(n, a, b, c)
    例如，输入 move(2, 'A', 'B', 'C')，打印出：
    A --> B
    A --> C
    B --> 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(3, 'A', 'B', 'C')
    ...
    A-->C
    A-->B
    C-->B
    A-->C
    B-->A
    B-->C
    A-->C


 5. 定义默认参数
    def greet(b='world'):
        print 'Hello,'+b+'.'

    greet()//当不输入参数是，默认使用b='world'
    greet('Bart')//输入参数时，使用b='Bart'
    ...
    Hello,world.
    Hello,Bart.


 6. 定义可变参数
    def average(*args):
    sum=0.0
    n=0.0
    for x in args:
        sum=sum+x
        n=n+1
    if n==0:
        return 0.0
    else:
        return sum/n

    print average()
    print average(1, 2)
    print average(1, 2, 2, 3, 4)
    0.0
    1.5
    2.4
    args相当于一个tuple

迭代

 1.  索引迭代：对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，方法是使用 enumerate() 函数：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
0 - Adam
1 - Lisa
2 - Bart
3 - Paul
迭代的每一个元素实际上是一个tuple：
for t in enumerate(L):
    index = t[0]
    name = t[1]
    print index, '-', name
zip()函数可以把两个 list 变成一个 list：
>>> zip([10, 20, 30], ['A', 'B', 'C'])
[(10, 'A'), (20, 'B'), (30, 'C')]
在迭代 ['Adam', 'Lisa', 'Bart', 'Paul'] 时，如果我们想打印出名次 - 名字（名次从1开始)，请考虑如何在迭代中打印出来。
提示：考虑使用zip()函数和range()函数
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in zip(range(1,5),L):
    print index, '-', name

 2. 迭代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
dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
    print v
# 85
# 95
# 59
差别：
（1） values() 方法实际上把一个 dict 转换成了包含 value 的list。
（2）但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
 3. 迭代dict的key和value
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() 不占用额外的内存。
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for k, v in d.iteritems()://注意是d.iteritems()不是d.itervalues()
    sum = sum + v
    print k,':',v
print 'average', ':', sum/len(d)

生成列表

 1.  如果要生成[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。

(2)请利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]
提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
print [(x+1)*x for x in range(1,101,2)]

 2. 复杂表达式
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格：
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'
注：字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。

在生成的表格中，对于没有及格的同学，请把分数标记为红色。
提示：红色可以用 <td style="color:red"> 实现:
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>'

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

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

 4. 多层表达式
for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。
对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

利用 3 层for循环的列表生成式，找出对称的 3 位数。例如，121 就是对称数，因为从右到左倒过来还是 121。

print [x*100+y*10+z for x in range(1,10) for y in range(0,10) for z in range(0,10) if x==z]