python

最近在使用Python单元测试框架构思自动化测试，在不段的重构与修改中，发现了大量的if…else之类的语法，有没有什么好的方式使Python具有C/C#/JAVA等的switch功能呢？
在不断的查找和试验中，发现了这个：http://code.activestate.com/recipes/410692/，并在自己的代码中大量的应用，哈哈，下面来看下吧：
下面的类实现了我们想要的switch。

class switch(object):
    def __init__(self, value):
        self.value = value
        self.fall = False
    def __iter__(self):
        """Return the match method once, then stop"""
        yield self.match
        raise StopIteration
    def match(self, *args):
        """Indicate whether or not to enter a case suite"""
        if self.fall or not args:
            return True
        elif self.value in args: # changed for v1.5, see below
            self.fall = True
            return True
        else:
            return False
 

下面是它的使用方法：

v = 'ten'
for case in switch(v):
    if case('one'):
        print 1
        break
    if case('two'):
        print 2
        break
    if case('ten'):
        print 10
        break
    if case('eleven'):
        print 11
        break
    if case(): # 默认
        print "something else!"
 

来源：http://www.cnblogs.com/ListenWind/p/4267517.html

在Python语言里如何来使用join方法呢？下面举几个例子：

>>> name='lizhanguo wangyuwei lixuehan'
>>> a = name.split()
>>> a
['lizhanguo', 'wangyuwei', 'lixuehan']
 

>>> b = ','.join(a)   注：以逗号分隔
>>> b
'lizhanguo,wangyuwei,lixuehan'
 

>>> c = ' '.join(a)    注：以空格分隔
>>> c
'lizhanguo wangyuwei lixuehan'
 

列表：shoplist = [‘apple’, ‘mango’, ‘carrot’, ‘banana’] 字典：di = {‘a’:123,’b’:’something’}
集合：jihe = {‘apple’,’pear’,’apple’}
元组： t = 123,456,’hello’
1.列表
空列表：a=[] 函数方法：

          a.append(3)     　　>>>[3]
          a.extend([3,4,5])     　　>>>[3,3,4,5]    添加一个列表序列
          a.insert(1,'hello')    　　  >>>[3,'hello',3,4,5]
          a.remove(3)        　　　  >>>['hello',3,4,5] 删除第一个出现的3，没有3则报错
          a.pop()        　　　　　　>>>['hello',3,4]
          a.pop(0)        　　　　　　>>>[3,4]
          a.index(4)       　　 >>>1    返回出现的第一个4的下标
          a.count(3)        　　>>>1    列表中元素3的个数
          a.sort        >>>[3,4]    排序
          a.reverse()        >>>[4,3]    反序
 

删除元素的方法

 a.remove(3)    通过值删除元素，删除第一个为参数值得元素
        a.pop()       通过下标删除元素，默认删除列表最后一个值，带参数则删除下标为参数值的元素
        del a[0]       通过下标删除元素，
            del a[2:4] 删除a表下标为2,3的元素
        del a[:]   删除a列表所有元素
        del a       删除列表
 

列表推导式：

 vec = [2,4,6]
         [3*x for x in vec if x<6&#93;    >>>[6,12]    3*2,3*4
        vec2 = [1,2,3]
        [x*y for x in vec for y in vec2]    >>>[2,4,6,4,8,12,6,12,18]
 

嵌套列表推导式：

  mat = [
        [1,2,3],
        [4,5,6],
        [7,8,9]
        ]
        print ([[row[i] for row in mat] for i in [0,1,2]])
        >>>[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
 

思考：list (zip(mat)) 和 list (zip(*mat))结果会有什么不同
2.元组
空元组：t = ()
元组赋值：

           t = (123,345)
           t[0]         >>>123
 

3.字典

    d = {'Jack':'jack@mail.com','Tom':'Tom@main.com'}
    d['Jack']    　　　　　　　　>>>'jack@mail.com
    d['Jim'] = 'Jim@sin.com'    >>>{'Jim': 'Jim@sin.com', 'Jack': 'jack@mail.com', 'Tom': 'Tom@main.com'}
　  del d['Jim']    >>>{'Jack': 'jack@mail.com', 'Tom': 'Tom@main.com'}
    list(d.keys())    将返回一个字典中所有关键字组成的无序列表
    sorted(d.keys()) 将返回一个字典中所有关键字组成的排序列表
    dict()    构造函数可以直接从key-value对中创建字典
    dict([('Tim',123),('Tiny',234)])    >>>{'Tiny': 234, 'Tim': 123}
 

推导式创建字典：
{d2:d2+’@main.com’ for d2 in list(d.keys())}
>>>{‘Jack’: ‘Jack@main.com’, ‘Tom’: ‘Tom@main.com’}
练习：循环输出字典中的键值对：
for name,email in d.items():
print(name,email)
4.集合
空集合：A = set() ※想要创建空集合，必须使用set()
演示：

     basket = {'apple','orange','apple'}    >>>{'orange', 'apple'}    注意重复的元素只显示一个？
    'apple' in basket              >>>True
    'pear' in basket            >>>False
 

集合的数学运算：

        a = set('ababcdabca')        >>>{'c', 'b', 'a', 'd'}
        b = {'a','b','m'}            >>>{'b', 'a', 'm'}
        a - b        >>>{'c', 'd'}
        b - a        >>>{'m'}
        a | b        >>>{'c', 'd', 'b', 'a', 'm'}
        a & b        >>>{'a','b'}
        a ^ b        >>>{'c','d','m'}
 

集合推导式：

       {x for x in a if x not in 'ab'}    >>>{'c','d'}
 

在python 语言中，当你需要加载一个模块或者包的时候，我们需要将其导入到当前程序中，那么如何导入python 模块和包呢？

一、模块用import导入
cal.py：

  #!/usr/bin/pythondef add(x,y):
        return x+yif __name__ == '__main__':
            print add(1,2)
 

注：__name__为内置变量，如果直接在CLI中调用值为__mail__，否则为文件名。
在new.py中导入：

    import calprint
    cal.add(2,3);
 

二、包：按目录名组织的模块
1、建立一个名字为包名字的文件夹
2、在该文件夹下创建一个__init__.py文件
3、根据需要在该文件夹下存放脚本文件、已编译的扩展及子包
4、在文件中用 import pack.m1,pack.m2,pack.m3 进行导入
5、用 pack.m1.xxx来调用包中模块的方法
示例目录结构：

util/├── cal.py
├── cal.pyc
├── __init__.py
└── __init__.pyc
 

调用示例new.py：

import util.calprint util.cal.add(2,3);//5
 

或用as来使用别名：

import util.cal as cprint c.add(2,3);//5
 

或者用from来简写：

from util.cal import addprint add(2,3);
 

本文将会对Python 语言里的一些内置函数的用法做一些介绍。
一、数学相关
1、绝对值：abs(-4)
2、最大最小值：max([456,789 123])、min([1,2,3])
3、序列长度：len(‘abc’)、len([1,2,3])、len((1,2,3))
4、取模：divmod(5,2)//(2,1)
5、乘方：pow(2,3,4)//2**3/4
6、浮点数：round(1)//1.0
二、功能相关
1、函数是否可调用：callable(funcname)，注意，funcname变量要定义过
2、类型判断：isinstance(x,list/int)
3、比较：cmp(‘hello’,’hello’)
4、快速生成序列：(x)range([start,] stop[, step])
三、类型转换
1、int(x)
2、long(x)
3、float(x)
4、complex(x) //复数
5、str(x)
6、list(x)
7、tuple(x) //元组
8、hex(x)
9、oct(x)
10、chr(x)//返回x对应的字符，如chr(65)返回‘A’
11、ord(x)//返回字符对应的ASC码数字编号，如ord(‘A’)返回65
四、字符串处理
1、首字母大写：str.capitalize

>>> 'world'.capitalize()'World'
 

2、字符串替换：str.replace
>>> ‘hello’.replace(‘l’,’t’)’hetto’
可以传三个参数，第三个参数为替换次数
3、字符串切割：str.split

>>> 'hello'.split('l')
['he', '', 'o']
 

可以传二个参数，第二个参数为切割次数
以上三个方法都可以引入String模块，然后用string.xxx的方式进行调用。
五、序列处理函数
1、len：序列长度
2、max：序列中最大值
3、min：最小值
4、filter：过滤序列

>>> filter(lambda x:x%2==0, [1,2,3,4,5,6])
[2, 4, 6]
 

5、zip：并行遍历

>>> name=['jim','tom','lili']>>> age=[20,30,40]>>> tel=['133','156','189']>>> zip(name,age,tel)
[('jim', 20, '133'), ('tom', 30, '156'), ('lili', 40, '189')]
 

注意，如果序列长度不同时，会是下面这样的结果：

>>> name=['jim','tom','lili']>>> age=[20,30,40]>>> tel=['133','170']>>> zip(name,age,tel)
[('jim', 20, '133'), ('tom', 30, '170')]
 

6、map：并行遍历，可接受一个function类型的参数

>>> a=[1,3,5]>>> b=[2,4,6]>>> map(None,a,b)
[(1, 2), (3, 4), (5, 6)]>>> map(lambda x,y:x*y,a,b)
[2, 12, 30]
 

7、reduce：归并

>>> l=range(1,101)>>> l
[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, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]>>> reduce(lambda x,y:x+y,l)5050
 

现在的很多网络爬虫都会用python 语言来写，那么如何通过python语言来打开一个网页呢。

import urllib
i = urllib.urlopen('http://www.baidu.com')
i = i.read()
print i
 

用python写的猜数字游戏。

# -*- coding:utf-8 -*-
import easygui,random
status = easygui.buttonbox(“这是一个猜数字游戏，点击开始进行游戏，点击退出关闭游戏。”, choices = [“开始”,”退出”])
if status == “开始”:
s_number = random.randint(1,100)
count = 0
u_number = 0
#print s_number
while count < 6 and u_number != s_number: u_number = int(easygui.enterbox("请输入一个1-100的数字：")) if u_number == s_number: easygui.msgbox("恭喜你猜对了") break elif u_number < s_number: easygui.msgbox("小了") #print u_number else: easygui.msgbox("大了") #print u_number count = count + 1 else: easygui.msgbox("六次了你都没有猜中") #print s_number else: easygui.msgbox("退出游戏！") #print "exit" [/code]

Python 标准库中有很多实用的工具类，但是在具体使用时，标准库文档上对使用细节描述的并不清楚，比如 urllib2 这个 HTTP 客户端库。这里总结了一些 urllib2 库的使用细节。
1 Proxy 的设置
2 Timeout 设置
3 在 HTTP Request 中加入特定的 Header
4 Redirect
5 Cookie
6 使用 HTTP 的 PUT 和 DELETE 方法
7 得到 HTTP 的返回码
8 Debug Log
1 Proxy 的设置
urllib2 默认会使用环境变量 http_proxy 来设置 HTTP Proxy。如果想在程序中明确控制 Proxy，而不受环境变量的影响，可以使用下面的方式。

import urllib2
enable_proxy = True
proxy_handler = urllib2.ProxyHandler({"http" : 'http://some-proxy.com:8080'})
null_proxy_handler = urllib2.ProxyHandler({})
if enable_proxy:
    opener = urllib2.build_opener(proxy_handler)
else:
    opener = urllib2.build_opener(null_proxy_handler)
urllib2.install_opener(opener)
 

这里要注意的一个细节，使用 urllib2.install_opener() 会设置 urllib2 的全局 opener。这样后面的使用会很方便，但不能做更细粒度的控制，比如想在程序中使用两个不同的 Proxy 设置等。比较好的做法是不使用 install_opener 去更改全局的设置，而只是直接调用 opener 的 open 方法代替全局的 urlopen 方法。
2 Timeout 设置
在老版本中，urllib2 的 API 并没有暴露 Timeout 的设置，要设置 Timeout 值，只能更改 Socket 的全局 Timeout 值。

import urllib2
import socket
socket.setdefaulttimeout(10) # 10 秒钟后超时
urllib2.socket.setdefaulttimeout(10) # 另一种方式
 

3 在 HTTP Request 中加入特定的 Header
要加入 Header，需要使用 Request 对象：

import urllib2
request = urllib2.Request(uri)
request.add_header('User-Agent', 'fake-client')
response = urllib2.urlopen(request)
 

对有些 header 要特别留意，Server 端会针对这些 header 做检查
User-Agent 有些 Server 或 Proxy 会检查该值，用来判断是否是浏览器发起的 Request
Content-Type 在使用 REST 接口时，Server 会检查该值，用来确定 HTTP Body 中的内容该怎样解析。
常见的取值有：
在使用 RPC 调用 Server 提供的 RESTful 或 SOAP 服务时， Content-Type 设置错误会导致 Server 拒绝服务。
application/xml ：在 XML RPC，如 RESTful/SOAP 调用时使用
application/json ：在 JSON RPC 调用时使用
application/x-www-form-urlencoded ：浏览器提交 Web 表单时使用
……
4 Redirect
urllib2 默认情况下会针对 3xx HTTP 返回码自动进行 Redirect 动作，无需人工配置。要检测是否发生了 Redirect 动作，只要检查一下 Response 的 URL 和 Request 的 URL 是否一致就可以了。

import urllib2
response = urllib2.urlopen('http://www.google.cn')redirected = response.geturl() == 'http://www.google.cn'
 

如果不想自动 Redirect，除了使用更低层次的 httplib 库之外，还可以使用自定义的 HTTPRedirectHandler 类。

import urllib2
class RedirectHandler(urllib2.HTTPRedirectHandler):
    def http_error_301(self, req, fp, code, msg, headers):
        pass
    def http_error_302(self, req, fp, code, msg, headers):
        pass
opener = urllib2.build_opener(RedirectHandler)
opener.open('http://www.google.cn')
5 Cookie
 

urllib2 对 Cookie 的处理也是自动的。如果需要得到某个 Cookie 项的值，可以这么做：

import urllib2
import cookielib
cookie = cookielib.CookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookie))
response = opener.open('http://www.google.com')
for item in cookie:
    if item.name == 'some_cookie_item_name':
        print item.value
 

6 使用 HTTP 的 PUT 和 DELETE 方法

import urllib2
request = urllib2.Request(uri, data=data)
request.get_method = lambda: 'PUT' # or 'DELETE'
response = urllib2.urlopen(request)
 

7 得到 HTTP 的返回码
对于 200 OK 来说，只要使用 urlopen 返回的 response 对象的 getcode() 方法就可以得到 HTTP 的返回码。但对其它返回码来说，urlopen 会抛出异常。这时候，就要检查异常对象的 code 属性了：

import urllib2
try:
    response = urllib2.urlopen('http://restrict.web.com')
except urllib2.HTTPError, e:
    print e.code
8 Debug Log
 

使用 urllib2 时，可以通过下面的方法把 Debug Log 打开，这样收发包的内容就会在屏幕上打印出来，方便我们调试，在一定程度上可以省去抓包的工作。

import urllib2
httpHandler = urllib2.HTTPHandler(debuglevel=1)
httpsHandler = urllib2.HTTPSHandler(debuglevel=1)
opener = urllib2.build_opener(httpHandler, httpsHandler)
urllib2.install_opener(opener)
response = urllib2.urlopen('http://www.google.com')
 

来源：http://linuxadmin.blog.51cto.com/2683824/1610811

一、if语句

>>> x = int(raw_input(“Please enter an integer: “))Please enter an integer: 42>>> if x < 0:... x = 0... print 'Negative changed to zero'... elif x == 0:... print 'Zero'... elif x == 1:... print 'Single'... else:... print 'More' [/code] 二、for 语句 [code] In [5]: words = ['cat', 'window', 'defenestrate'] In [6]: for w in words: ...: print w, len(w) ...: [/code] cat 3 window 6 defenestrate 12 三、 range函数 [code] In [8]: range(5, 10) Out[8]: [5, 6, 7, 8, 9] In [9]: range(0, 10, 3) Out[9]: [0, 3, 6, 9] In [10]: range(-10, -100, -30) Out[10]: [-10, -40, -70] [/code] 四、循环语句中的break 、continue和else [code] In [14]: for n in range(2,10): for x in range(2,n): if n%x==0: print n,'equals',x,'*',n/x break else: print n,'is a prime number' ....: 2 is a prime number 3 is a prime number 4 equals 2 * 2 5 is a prime number 6 equals 2 * 3 7 is a prime number 8 equals 2 * 4 9 equals 3 * 3 [/code] [code] In [16]: for num in range(2, 10): ....: if num % 2 == 0: ....: print "Found an even number", num ....: continue ....: print "Found a number", num ....: Found an even number 2 Found a number 3 Found an even number 4 Found a number 5 Found an even number 6 Found a number 7 Found an even number 8 Found a number 9 [/code] 五、pass语句 [code] In [18]: def initlog(*args): ....: pass [/code] 来源：http://linjohn.blog.51cto.com/1026193/1609673

列表使用[ ]，列表包含的元素可以是多种不同的类型;

In [1]: squares = [1, 4, 9, 16, 25]
In [2]: squares
Out[2]: [1, 4, 9, 16, 25]
 

跟字符串一样，列表也可以使用索引和切片：

In [3]: squares[0]
Out[3]: 1
In [4]: squares[-1]
Out[4]: 25
In [5]: squares[-3:]
Out[5]: [9, 16, 25]
 

所有的切片操作都会返回一个新的包含切片内容的新列表，以下操作表示生成一个原列表的副本：

In [6]: squares[:]
Out[6]: [1, 4, 9, 16, 25]
 

列表也支持连接符：

In [7]: squares + [36, 49, 64, 81, 100]
Out[7]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 

列表是可变的，与字符串不同：

In [8]: cubes = [1, 8, 27, 65, 125]
In [9]:  4 ** 3
Out[9]: 64
In [10]: cubes[3] = 64
In [11]: cubes
Out[11]: [1, 8, 27, 64, 125]
 

使用append函数可以在列表的末尾添加新元素：

In [12]: cubes.append(216)
In [13]: cubes.append(7 ** 3)
In [14]: cubes
Out[14]: [1, 8, 27, 64, 125, 216, 343]
 

给切片分配新的内容也可以：

In [15]: letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
In [16]: letters
Out[16]: ['a', 'b', 'c', 'd', 'e', 'f', 'g']
In [17]: letters[2:5] = ['C', 'D', 'E']
In [18]: letters
Out[18]: ['a', 'b', 'C', 'D', 'E', 'f', 'g']
In [19]: letters[2:5] = []
In [20]:  letters
Out[20]: ['a', 'b', 'f', 'g']
In [21]: letters[:] = []
In [22]: letters
Out[22]: []
 

使用内置函数len也可以计算列表的长度：

In [23]: letters = ['a', 'b', 'c', 'd']
In [24]: len(letters)
Out[24]: 4
 

也可以在列表中放进列表：

In [25]: a = ['a', 'b', 'c']
In [26]: n = [1, 2, 3]
In [27]: x = [a, n]
In [28]: x
Out[28]: [['a', 'b', 'c'], [1, 2, 3]]
In [29]: x[0]
Out[29]: ['a', 'b', 'c']
In [30]: x[0][1]
Out[30]: 'b'
 

来源：http://linjohn.blog.51cto.com/1026193/1608870

1、number
数字可以直接在python运算，使用圆括号分组

In [1]: 2+2
Out[1]: 4
In [2]: 50-5*6
Out[2]: 20
In [3]: (50-5.0*6)/4
Out[3]: 5.0
In [4]: 8/5.0
Out[4]: 1.6
 

在进行除法/的时候，如果2个除数都是int型，则返回的值也为整型int：
如果有1个除数为浮点型float，则结果值为浮点型float；
使用运算符//做除法，则返回的值为除后取整
使用%做除法取余数；

In [5]: 17/3
Out[5]: 5
In [6]: 17/3.0
Out[6]: 5.666666666666667
In [7]: 17//3.0
Out[7]: 5.0
In [8]: 17%3
Out[8]: 2
 

使用**来计算乘方：

In [9]: 5**2
Out[9]: 25
In [10]: 2**7
Out[10]: 128
 

使用=号赋值：

In [11]: width=20
In [12]: height=5*9
In [13]: width * height
Out[13]: 900
 

如果一个变量没有定义，那么直接使用它会出错：

In [14]: n
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-14-fe13119fb084> in <module>()
----> 1 n
NameError: name 'n' is not defined
 

整型和浮点类型的转换：

In [15]: 3*3.75/1.5
Out[15]: 7.5
In [16]: 7.0/2
Out[16]: 3.5
 

可以将最后打印的计算结果直接给“_”符号

In [17]: tax=12.5/100
In [18]: price=100.50
In [19]: tax * price
Out[19]: 12.5625
In [20]: price+_
Out[20]: 113.0625
In [21]: round(_,2)
Out[21]: 113.06
 

2、String
可以使用单引号”和双引号来直接引用String,反斜杠可以转义引号：

In [22]: 'spam eggs'
Out[22]: 'spam eggs'
In [23]: 'doesn\'t'
Out[23]: "doesn't"
In [24]: "doesn't"
Out[24]: "doesn't"
In [25]: '"Yes," he said.'
Out[25]: '"Yes," he said.'
In [26]: "\"Yes,\" he said."
Out[26]: '"Yes," he said.'
In [27]: '"Isn\'t," she said.'
Out[27]: '"Isn\'t," she said.'
 

使用print命令可以忽略字符引号，并且可以打印特殊意义符号：

In [28]: '"Isn\'t," she said.'
Out[28]: '"Isn\'t," she said.'
In [29]: print '"Isn\'t," she said.'
"Isn't," she said.
In [30]:  s = 'First line.\nSecond line.'
In [31]: s
Out[31]: 'First line.\nSecond line.'
In [32]: print s
First line.
Second line.
 

如果不想打印特殊字符，可以在第一个引号前面加r：

In [33]: print 'C:\some\name'
C:\some
ame
In [34]: print r'C\some\name'
C\some\name
 

使用三元引号可以将多行放在一行里面，但在第一个引号后面加\符号则还是会使用多行模式：

In [38]: print """\
   ....: Usage: thingy [OPTIONS]
   ....:      -h                        Display this usage message
   ....:      -H hostname               Hostname to connect to
   ....: """
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
 

String可以使用+号连接或者*号运算

In [40]: 3 * 'un' + 'ium'
Out[40]: 'unununium'
 

连接多个字符串可以使用以下方式：

In [42]: 'Py' 'thon'
Out[42]: 'Python'
 

使用+符号可以将变量与字符串相连接：

In [43]: prefix = 'Py'
In [44]:  prefix + 'thon'
Out[44]: 'Python'
 

当需要将比较长的字符串连接在一起的时候，使用引号的方式比较有用：

In [45]: text = ('Put several strings within parentheses '
   ....:             'to have them joined together.')
In [46]: text
Out[46]: 'Put several strings within parentheses to have them joined together.'
 

字符串可以有索引：

In [47]: word = 'Python'
In [48]:  word[0]
Out[48]: 'P'
In [49]: word[5]
Out[49]: 'n'
In [50]: word[-1]
Out[50]: 'n'
In [51]: word[-2]
Out[51]: 'o'
In [52]: word[-6]
Out[52]: 'P'
 

字符串的切片：

In [53]: word[0:2]
Out[53]: 'Py'
In [54]: word[2:5]
Out[54]: 'tho'
In [55]: word[:2] + word[2:]
Out[55]: 'Python'
In [56]: word[:4] + word[4:]
Out[56]: 'Python'
 

字符串切片索引示意：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
 

超过索引顺序的切片可以比较友好的处理：

In [68]: word[4:42]
Out[68]: 'on'
In [69]: word[42:]
 

String不能被改变：

In [69]: word[0] = 'J'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-69-197b67ffdd83> in <module>()
----> 1 word[0] = 'J'
TypeError: 'str' object does not support item assignment
 

如果需要不同的字符串，可以生成新的字符串：

In [70]: 'J' + word[1:]
Out[70]: 'Jython'
In [71]: word[:2] + 'py'
Out[71]: 'Pypy'
 

使用内置的len函数可以计算字符串的长度：

In [72]: len(word)
Out[72]: 6
 

来源：http://linjohn.blog.51cto.com/1026193/1608530

使用关键字def定义函数

In [19]: def fib(n):
   ....:     a, b = 0, 1
   ....:     while a < n:
   ....:         print a,
   ....:         a, b = b, a+b
   ....:
In &#91;20&#93;: fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
 &#91;/code&#93;
    函数可以直接传递给变量，相当于重新命名函数名：
 &#91;code&#93;
In &#91;21&#93;: fib
Out&#91;21&#93;: <function __main__.fib>
In [22]: f = fib
In [23]: f(100)
0 1 1 2 3 5 8 13 21 34 55 89
 

函数一般都有返回值，如果没有返回值，那么默认返回值是none

In [24]: def fib2(n):
….: result = [] ….: a,b=0,1
….: while a