python成长记（二）

python成长记（二）

最后一个要介绍的对象是元组。

• 元组tuple是个不能改变的对象。也就是不能原位改变。
• 元组是一个有序的对象集合，可以嵌入到别的对象中。
• 元组是有序的，也能通过偏移量访问，注意通过键的访问只有字典。
• 元组和字符串类似，是不可变的。
• 元组也是一个序列。
• 人生本不易，何添烦恼丝。

元组也存在分片和索引。

文件

在python中文件也是一个对象。
内置函数open创建了一个python文件对象，可作为计算机中一个文件的链接。
在调用open后，通过调用文件对象的方法，可以读写相关的外部文件。

为了打开一个文件，首先调用open函数，首先是外部名，跟着是处理模式。
r是输入模式，w代号输出生成和打开文件，a是在尾部追加文件。

output=open("temp/spam","w")  生成输出文件  但是为啥是用前面的区分？这个很有意思吼
input=open("data","r")        生成输入文件
不过这个也算简单的了。
要是对比java的话就是获得了一个输入或者输出的对象input或者是output。
s=input.read()
s=input.read(N)
output.write(s)               把字符串S写入文件。
output.close()                手动关闭，也就是结束和外部的连接。
这里居然涉及到文件但是一直没提到流的概念。是隐藏了？

下面举个栗子：

myfile=open("myfile","w")
myfile.write("hello text file\n")连转义字符也写进去了
mtfile.close()

总结一下，字符串，表，元组都享有序列操作。

原位可以改变列表list和字典dict，但是你无法原位改变string和元组。

列表和字典是可变的，所以他们的大小不是固定的。

在python这种弱类型语言里，那些c++的初学者该抓狂了

x=0
x=”hello”
这完全是没有问题的。在c++中x一般是有类型的，类型不匹配不能赋值。

但是python的名字没有类型限制，他和他绑定的对象没有必然的联系。

语句的话，注意if语句是 if….elif…else的格式。

而且python中没有switch语句

其实少了很多，python中也只有两个循环，一个while循环，一个for循环。

而for循环的格式变成了这样：
for<目标>in<对象>：
<语句>

常用的函数

>>>range(5)
[0,1,2,3,4]
range(2,5)
[2,3,4]
range(0,10,2)
[0,2,4,6,8]

其实range是生成序列的。也就是你很快生成了一个list。

不是所有的函数都有返回值
比如：list=list.append(X)
那list之后基本上是空的了，因为append()表面上看没有返回值，其实是返回了null而已。

函数

定义函数
def <名字>(arg1,arg2):
<语句>
return<值>
不过要是你不想要返回值其实也没事儿。因为系统自动但会一个NONE对象。

python的弱类型其实很尴尬啊：

>>>def times(x,y):
    return x*y

这好好的定义了一个函数是吧，但是看下面的调用
>>>time(2,4)
最后的输出是8
>>>time("ha",4)
最后输出是hahahaha

因为弱类型，这是python的一个弹性，导致变成了一个很强大的函数。
但是同样也带来了问题。

还有下面这个函数，我怎么隐隐觉得的有问题？
def intersect(seq1,seq2):
    res=[]
    for x in seq1:
        if x in seq2:
            res.append(x)
return res

将一个内部的东西return回去了，理论上是没问题，但是上次复习c++的时候有种类似的做法会引起异常，是什么呢？

在默认情况下，在函数中的赋值都是局部作用于的。如果要用到全局的话，用global修饰。这下就是全局的了。

LGB规则

命名空间找名字的时候是这样的顺序：
先局部，次之全局，最后内置。

换言之也就是局部会掩盖全局，就是局部变量原则。

这个全局的global啊。
在函数之外定义是全局的。如果不赋值只是引用，那没关系不用global。
但是如果赋值，那这个变量就要用global修饰了。

x,y,z=x,y,z
def haha():
    global x
    x=y+z

这里只是引用了y和z，那y，z正好也是全局变量，不用global修饰，
但是x被赋值了，如果不加global的话会被认为是局部的，会完全忽略外边那个全局的x而在模块中再生成一个x

在python中也存在形参实参的那种问题。
a=3,b=[1,2,3]
haha（a，b）
a=2
b[0]=2

a不会变，但是b变了，因为b用的是引用，会在原来的改变。
总结起来就是：
- 不可变参数传递是c中的“传值”模式
- 可变的参数是“传指针”模式。这种情况基本上都是传了一个list给自己找不自在的后果。

利用return

return可以返回各种类型的对象。
也就是说你完全可以拿过来一个string，return一个list回去。

你开心就好。

参数传递

python的参数传递还挺有讲究，不过这里只讲解一个任意参数的集合函数

def intersect(*args):
    res=[]
    for x in args[0]:
        for other in args[1:]:
            if x not in other:break
        else:
            res.append(x)
    return res
为什么会这样呢？因为传递过来，不论是多少参数，在到达*args的那一刻，都被封装成了一个元组，名字是args。

lambda表达式

lambda是一个表达式，而不是一个语句。所以lambda可以出现在def不能出现的地方，如在一个列表敞亮的内部。作为一个表达式，lambda返回一个值（这个值是一个新的函数）。其实你可以将lambda看作是一个只有一句return的语句，返回的是一个函数。

>>> f=lambda x,y z:x+y+z
>>>f(2,3,4)

赋值完成后，这个f就是一个函数对象（没错，在python中函数也是对象）

介绍一下内置的map函数

场景是：对于列表中的每一个成员进行一个操作并收集结果。

>>>counters=[1，2，3，4]
>>>def inc(x):return x+10
>>>map(inc,counters)

就是对counters中的每个成员进行性inc函数对应的操作。

有时候也出现lambda表达式
>>>map((lambda x:x+3),counters)
很好理解啊，lambda表达式返回了一个函数。

在python中，存在无返回值的函数。（比如append()）
无返回值的函数其实就是被看做是一个过程，也就是当做一个语句来使用。