Python学习小笔记1

1.函数raw_input()和input()的区别:raw_input是默认为字符串输入，那么在输入时字符串不用加引号，而input()在输入字符串的时候需加引号
2.如果一个自定义的函数function()有返回值，那么直接执行function()和print function()得到的结果有什么不同？比如:
  >>> from math import *
  >>> def area(radius):
     atemp=pi*radius*2
      return atemp

  >>> area(2)
  12.566370614359172
  >>> print area(2)
  12.5663706144
3.python有一个主函数：_main_。其他的函数都是在这个函数内执行，或者说_main_调用你的程序以及程序内的函数。你在任何函数外创造的变量都属于_main_。
4.在有返回值的函数中，一定要保证每个可能的流程都有对应着return语句。如果某一条件分支缺少return语句，则函数返回值为None（注意N要大写），None是不属于任何类型的类型。
5.Python有一个math模块，提供了大部分与数学计算相似的函数。模块是一个文件，它是功能类似的函数的集合。（利用关键字import）
 如果你自定义的函数和math模块中的函数同名，则math模块中的函数将被覆盖，即使用点操作符也不能调用。但在字符串模块中，即使自定义了和模块中相同函数名的函数，也可以通过点操作符来调用模块中函数，解释器能够区分。
6.python 允许你定义一种单行的小函数。（lambda 参数:表达式），lambda函数默认返回表达式的值，lambda函数可以接受任意个参数，包括可选参数，但是表达式只有一个
  >>> g=lambda x,y:x*y
  >>> g(3,4)
  12
  >>>
  >>> g=lambda x,y=0,z=0:x+y+z
  >>> g(1)
  1
  >>>
  也能够直接使用lambda函数，不把它赋值给变量：
  >>> (lambda x,y=0,z=0:x+y+z)(3,5,6)
  14
  >>>
7.在python中，空字符串为假，非空字符串为真，非零的数为真。
  and 操作符：只要左边的表达式为真，整个表达式返回的值是右边表达式的值。否则，返回左边表达式的值。
  or 操作符：只要两边的表达式为真，整个表达式的结果是左边表达式的值；如果是一真一假，返回真值表达式的值。特别注意的是空值和0的情况，这时候返回的是右边的0或空值。
8.return 在函数中返回函数值。它的另一个作用是当函数内有错误发生时，终止函数的运行，提前退出。
  >>> import math
  >>> def printc(a,b):
    if(a-b)<0:
        print "a小于b"
        return
    print math.sqrt(a-b)

   
  >>> printc(1,2)
  a小于b
  >>> printc(4,2)
  1.41421356237
  >>>
  当a小于b时，return终止函数的执行，下一条语句也不执行了。
9.用while语句和for语句遍历字符串，例子：
  （1）
>>> def travel(string):
    index=0
    while index<len(string):
        letter=string[index]
        print letter
        index=index+1

       
>>> travel("dsidjso")
d
s
i
d
j
s
o
 
（2）
>>> def travel(address):
    for char in address: #注意for语句的简练用法
        print char
       
>>> travel("www.google.cn")
w
w
w
.
g
o
o
g
l
e
.
c
n

10.列表时一组任意类型的值，按照一定顺序组合而成的。组成列表的值叫做元素，每个元素被标识一个索引，第一个索引也是0.列表中的元素可以是任意类型，甚至是列表类型，也就是说列表可以嵌套。
11.列表的元素还可以是变量。但是修改变量的值，并不影响列表中元素的值。例如：
   >>> a=1
   >>> b=2
   >>> num=[a,b,3]
   >>> print num
   [1, 2, 3]
   >>> a=b=9
   >>> print num
   [1, 2, 3]
   >>>
12.函数range返回一个整数列表，列表从函数的第一个参数开始，到最后一个参数结束，不包含最后一个参数，相邻两数之间的差值是1.
13.列表的索引也可以是负数，那么列表的最后一个元素的索引是-1，倒数第二个的索引是-2，依此类推。
14.列表的一些方法：
   append在列表的尾部追加元素，参数是插入元素的值。
   >>> numbers.append(5)
   >>> numbers
   [1, 2, 3, 4, 5]
   insert在列表中插入元素，它有两个参数，一个是索引位置，一个是插入元素的值。
   >>> numbers
   [1, 2, 3, 4, 5]
   >>> numbers.insert(3,6)
   >>> numbers
   [1, 2, 3, 6, 4, 5]
   extend合并两个列表为一个：
>>> nation1=["French","German"]
>>> nation2=["Chinese","Korean"]
>>> nation1.extend(nation2)
>>> nation1
['French', 'German', 'Chinese', 'Korean']
  方法index是取得元素的索引值。
  方法remove是从列表中删除第一次出现的值。
>>> color=["red","green","yellow","green","black","green"]
>>> color.remove("green")
>>> color
['red', 'yellow', 'green', 'black', 'green']
>>>
  方法pop是删除最后一个值，然后返回这个值：
>>> letter=['a','b','c','d']
>>> letter.pop()
'd'
>>> letter
['a', 'b', 'c']
>>>
  函数len返回列表的长度，即元素的个数。可以用这个值作为遍历列表的变量，这意味着，即使改变列表的长度，我们也不用对程序的循环次数作出更改。
>>> os=["Linux","Unix","FreeBSD","Mac"]
>>> i=0
>>> while i<len(os):
    print os[i]
    i=i+1
   
Linux
Unix
FreeBSD
Mac
  虽然列表之中还可以包含列表，但嵌套的列表被当作一个元素。
  in是一个布尔操作符，它测试左边的操作数是否包含于列表中。
>>> os=["Linux","Unix","Mac","Windows"]
>>> "Windows" in os
True
>>>
 我们还可以用not和in的组合来测试一个元素不包含于列表。
 
 11.注意列表的方法append和列表操作符+的区别。
>>> a=[1,2,3,4]
>>> b=[6,7,8,9]
>>> a+b
[1, 2, 3, 4, 6, 7, 8, 9]

>>> a=[1,2,3,4]
>>> b=[6,7,8,9]
>>> print a.append(b)   #由输出可知列表的append方法是没有返回值的
None                      
>>> a
[1, 2, 3, 4, [6, 7, 8, 9]]  #可和上面的进行对比
12.乘号操作符
>>> [0]*4
[0, 0, 0, 0]
>>> [1,2,3]*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> "love"*2
'lovelove'
>>> print "love "*3
love love love

13.列表的元素是可变的，这一点和字符串不一样
14.python提供了关键字del删除列表中的元素。
>>> a=['one','two','three']
>>> del a[1]
>>> a
['one', 'three']
>>>
15.对两个不同的变量赋予相同的内容（字符串，整数，浮点数，列表），那么这两个变量指向的是同一个字符串。
>>> a="qswtp"
>>> b="qswtp"
>>> type(a)
<type 'str'>
>>> id(a)
13422016
>>> id(b)
13422016
>>> a=3
>>> b=3
>>> id(a)
10245808
>>> id(b)
10245808
>>> a=1.2
>>> b=1.2
>>> id(a)
11646520
>>> id(b)
13941984
>>> a=[1,2,3]
>>> b=[1,2,3]
>>> id(a)
13442384
>>> id(b)
13441704
16.在python中，如果我们将一个变量赋值给另一个变量，那么这两个变量指向同一个对象（这两个变量的值存储于同一个内存地址）。   
17.克隆列表：（列表的自我复制），克隆的结果是产生两个值一样，但却有不同标识符的列表。克隆是利用列表的片段操作符。
>>> x=[1,3,5,7]
>>> y=x[:]
>>> print y
[1, 3, 5, 7]
>>> id(x),id(y)
(13480544, 10967120)
18.列表参数：传递列表参数实际上是传递列表的别名，而不是列表的拷贝。如果在函数中修改了列表，也就是更改了原有的列表变量。
>>> def deleteHead(list):
    del list[0]
   
>>> number=[1,2,3,4,5]
>>> deleteHead(number)
>>> print number
[2, 3, 4, 5]
如果防止列表变量在函数中被更改，我们可以利用克隆列表。
>>> def deletements(list):
    temp=list[:]
    del temp[0]
   
>>> numbers=[1,2,3]
>>> deletements(numbers)
>>> print numbers
[1, 2, 3]
19.矩阵：
>>> matrix=[[1,2,3],[4,5,6],[7,8,9]]
>>> matrix[1]
[4, 5, 6]
>>> matrix[1][2]
6
20.列表映射：
>>> fruit=['apple','orange','pear','banana']
>>> i=0
>>> for var in fruit:
    fruit[i]=var+'s'
    i=i+1
   
>>> print fruit
['apples', 'oranges', 'pears', 'bananas']
>>> fruit=['apple','orange','pear','banana']
>>> [fruit+'s' for fruit in fruit]                 #列表映射对所有元素执行了相同的操作
['apples', 'oranges', 'pears', 'bananas']
>>> fruit=['apple','orange','pear','banana']
>>> [var+'s' for var in fruit if len(var)!=6]     #列表映射对满足长度不等于6的元素执行操作
['apples', 'pears']

21.序列：和列表比较相近，只是它的元素的值是固定的（不能根据索引直接修改）。序列中的元素以逗号分隔开。如果要创建一个包含一个元素的序列，那需要在序列的最后加上逗号。
>>> t1=('a',)
>>> type(t1)
<type 'tuple'>
>>> t2=('a')
>>> type(t2)
<type 'str'>
和列表相似，也可以用索引从序列中读取一个元素。用片段操作符取得序列的一部分。
可以用另一种方法修改序列中的元素：
>>> tuple1=('a','b','c','d')
>>> tuple1=('A',)+tuple1[1:]
>>> tuple1
('A', 'b', 'c', 'd')
这种方法也适用于字符串：
>>> string="xiayongfeng"
>>> string='X'+string[1:]
>>> print string
Xiayongfeng
>>> string=string[0:3]+'Y'+string[4:]
>>> print string
XiaYongfeng
22.序列赋值： 用序列赋值实现交换变量的值
>>> a=1
>>> b=2
>>> c=3
>>> a,b,c=c,b,a
>>> print a,b,c
3 2 1
右边序列元素的值按照从左到右的顺序赋值给左边的序列元素。如果右边的序列包含表达式，则先进行计算，然后再赋值。
函数的返回值可以是序列
23.在python中，如果变量具有相同的值，就可以认为这些变量是同一个值的别名。也就是这些变量指向同一个值。这样做的好处也许是为了节省内存空间。但是如果某一个变量改变了它自己的值，那么解释器就开辟出新内存空间存储这个变量的值，这个变量就指向新的值。
24.python提供了内建的函数来产生伪随机数，之所以叫伪随机数，是因为它不是数学意义上的随机数。random模块中的random函数能够产生一个值的范围在0.0到1.0之间的浮点数。
import random
for i in range(10):
    x=random.random()
    print i,")",x
>>>
0 ) 0.676109359448
1 ) 0.693073409019
2 ) 0.00218003825242
3 ) 0.389647975804
4 ) 0.196840558524
5 ) 0.420898950921
6 ) 0.981725587146
7 ) 0.564476300672
8 ) 0.504931431334
9 ) 0.390636920746

25.字典的索引可以是字符串，除了这一点，它与其他组合类型非常相似。当然，字典的索引亦可以是整数。
   字典的元素以逗号为分隔符，每个元素包含键和键值，他俩用冒号分割。
>>> dict={'one':1,'two':2}
>>> dict
{'two': 2, 'one': 1}
>>> print dict['two']
2
>>> len(dict)
2
>>> del dict['two']
>>> dict
{'one': 1}
>>> dict['two']=0
>>> dict
{'two': 0, 'one': 1}
>>> dict.clear()
>>> dict
{}
>>>