Python学习笔记 === 快速了解python

示例代码：

def buildConnectionString(params):
"""Build a connection string from a dictionary of parameters.

Returns string."""
return ";".join(["%s=%s" % (k, params[k]) for k in params.keys()])

if __name__ == "__main__":
myParams = {"server":"mpilgrim", \
"database":"master", \
"uid":"sa", \
"pwd":"secret" \
}
print buildConnectionString(myParams)

声明函数：

Ptython 拥有函数，但是不像C++或者JAVA，没有独立的接口声明和声明实现，一旦需要使用一个函数，声明它然后开始编码；

Python并不区分有无函数返回值的函数，所有函数都是以def开头；

Python没有定义返回的数据类型，有return返回一个值，没有的话返回None；

Python函数中的参数不用指定类型，类型在内部有保存；

文档化函数：

文档化字符串，三重双引号文档化多行字符串；

文档化字符串应该在函数定义的冒号：之后填写；

Python提供机制：函数在运行的时候有文档串的属性；

什么都是对象：

导入一个模块，可以引用它任何的公共函数，类，或者属性；

使用定义在被倒入模块中的函数时候，必须加上模块的名字；

Python 中列表是对象，字典是对象，模块是对象，字符，函数是对象，全是对象；

函数的识别只有一个冒号和我们自己使用的缩排，不用大括号之类的东西，缩排表示开始，不缩排表示结束；

测试模块：

利用这一点来测试模块，Python中模块是对象，并且有几个有用的属性；

if __name__ == '__main__' 技巧，__name__是所有模块的内置属性，__name__名字通常为模块的文件名，但是可以像一个标准函数去运行__name__,默认为__main__,这是一个特殊的缺省值；

了解了这一点，可以在模块内部为模块设计一个测试套件，当模块直接运行的时候，__name__是__main___, 当导入模块的时候,__name__就变了，这个时候测试套件被忽略，所以说大程序加入模块之前就可以进行舒服的调试了；

字典：

定义一个字典

>>> d = {"server":"mpilgrim", "database":"master"}#拥有两个元素的字典，#赋值给d，整个元素用{}括起来，健值对；
>>> d
{'database': 'master', 'server': 'mpilgrim'}
>>> d['server']      #通过键得到值
'mpilgrim'
>>> d['database']
'master'
>>> d['mpilgrim']  #通过值不能得到键
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'mpilgrim'

修改一个字典

>>> d["server"]="test"   #添加已经存在的键赋值，抹掉原来的值
>>> d
{'database': 'master', 'server': 'test'}
>>> d["new"] = "start"  #增加了新的键值对
>>> d
{'new': 'start', 'database': 'master', 'server': 'test'}

字典没有顺序的概念。

字典中混用数据类型

>>> d
{'new': 'start', 'database': 'master', 'server': 'test'}
>>> d["sj"]=3
>>> d
{'new': 'start', 'sj': 3, 'database': 'master', 'server': 'test'}
>>> d[2]="sta"
>>> d
{'new': 'start', 'sj': 3, 'database': 'master', 2: 'sta', 'server': 'test'}

字典中删除元素

>>> d
{'new': 'start', 'sj': 3, 'database': 'master', 2: 'sta', 'server': 'test'}
>>> del d[2]  #根据键值删除元素
>>> d
{'new': 'start', 'sj': 3, 'database': 'master', 'server': 'test'}
>>> d.clear()  #删除所有元素，清空字典
>>> d
{}

列表：

定义列表：

>>> li = ["a", "b", "test", "shabi", "helmet"]  #5个元素的列表
>>> li
['a', 'b', 'test', 'shabi', 'helmet']
>>> li[0]  #如此访问元素
'a'
>>> li[4]
'helmet'

负的列表索引：

>>> li
['a', 'b', 'test', 'shabi', 'helmet']
>>> li[-5] #这样理解 li
=li[n-len(li)]
'a'
>>> li[-1] #非空列表的最后一项都是li[-1]
'helmet'

分割一个列表：

>>> li
['a', 'b', 'test', 'shabi', 'helmet']
>>> li[0:3]     #切片操作，li 0到2  不包括3
['a', 'b', 'test']
>>> li[1:-1]
['b', 'test', 'shabi']

分片缩写：

>>> li
['a', 'b', 'test', 'shabi', 'helmet']
>>> li[:3]
['a', 'b', 'test']
>>> li[0:]
['a', 'b', 'test', 'shabi', 'helmet']
>>> li[:]
['a', 'b', 'test', 'shabi', 'helmet']

列表增加元素：

>>> li
['a', 'b', 'test', 'shabi', 'helmet']
>>> li.append("elimination")  #append
>>> li
['a', 'b', 'test', 'shabi', 'helmet', 'elimination']
>>> li.insert(2, "elinination")   #insert
>>> li
['a', 'b', 'elinination', 'test', 'shabi', 'helmet', 'elimination']
>>> li.extend(["shi", "shang"])  #extend
>>> li
['a', 'b', 'elinination', 'test', 'shabi', 'helmet', 'elimination', 'shi', 'shang']

搜索列表：

>>> li
['b', 'elinination', 'test', 'shabi', 'helmet', 'elimination', 'shi', 'shang']
>>> li.index("b")
0
>>> li.index('c')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'c' is not in list
>>> "c" in li  #测试元素是否在列表中 不在返回false
False

列表除去元素：

>>> li
['b', 'elinination', 'test', 'shabi', 'helmet', 'elimination', 'shi', 'shang']
>>> li.remove('b') #从列表中出去第一次出现的值 仅仅而已
>>> li
['elinination', 'test', 'shabi', 'helmet', 'elimination', 'shi', 'shang']
>>> li.remove('c')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> li.pop()  #除掉列表最后一个元素 返回这个删除的值
'shang'
>>> li
['elinination', 'test', 'shabi', 'helmet', 'elimination', 'shi']

列表操作符：

>>> li = ["a", "b", "mpilgrim"]
>>> li = li + ["new", "test"]  #相当于 extend(otherlist),但是+返回,extend()不
>>> li
['a', 'b', 'mpilgrim', 'new', 'test']
>>> li += ["two"]    #可以在用户定义的类中被重载
>>> li
['a', 'b', 'mpilgrim', 'new', 'test', 'two']
>>> li = [1, 2] * 3
>>> li
[1, 2, 1, 2, 1, 2]

序列(元组：tuple)

序列是不可变列表，一旦定义了就没有办法改变；

定义序列

>>> t = ("a", "b", 4, "z", "example")
>>> t
('a', 'b', 4, 'z', 'example')
>>> t[0]
'a'
>>> t[-1]
'example'
>>> t[1:3]
('b', 4)

序列没有方法

>>> t.append("new")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>> t.insert("new")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'insert'
>>> t.indes("z")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'indes'
>>> "z" in t   #可以用in
True

序列的好处

序列的遍历速度比列表快，如果定义了一个值集合常量，并且唯一要用它做的是不断地遍历它

字典关键字可以是整数，字符串和“几种其他的类型”吗？序列就是那些类型之一。序列可以在字典中做关键字，但是列表不行。序列用在字符串格式化

序列可以转换成列表，反之亦然。内置的tuple函数接收一个列表，饭或一个有着相同元素的序列，list函数接收一个序列，返回一个列表。tuple冻结一个列表，list解冻一个序列

定义变量

Python有局部变量和全局变量，但是它没有明显的变量声明，变量通过赋值产生，当超出作用范围时自动消灭。

if语句是代码块，需要缩排，像函数一样；

if __name__ == "__main__":
myParams = {"server":"mpilgrim", \
"database":"master", \
"uid":"sa", \
"pwd":"secret" \
}

Python 不允许引用一个没有赋值的变量，这样做会引起异常；早晚有一天会为此感谢Python

>>> x
Traceback (innermost last):
File "<interactive input>", line 1, in ?
NameError: There is no variable named 'x'
>>> x = 1
>>> x
1

格式化字符串formating strings

集中中间部分，类似C语言字符串格式化

return ";".join(["%s=%s" % (k, params[k]) for k in params.keys()])

格式化介绍简单:字符串连接做到了连接，格式化，以及强制类型转换

格式化对比字符串连接

>>> pwd = "secret"
>>> print pwd + "is the first"     #连接字符串
secretis the first
>>> print "%s is the test" % (pwd,)    #格式化字符串
secret is the test
>>> userCount = 6
>>> print "%d" % (userCount,)
6
>>> print "Users connected: " + userCount   #将字符串和非字符串连接会#产生异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

映射列表Mapping lists

对列表的每个元素应用一个函数来转换数据

["%s=%s" % (k, params[k]) for k in params.keys()]
#字典应用了params的keys函数，返回字典中关键字的列表

列表映射介绍

>>> li=[2,4,6,8]
>>> [elem*2 for elem in li]   #python循环遍历列表中的每个元素，一次遍历一个元素，临时将每个元素的值赋给elem，然后elem*2, 将结果追加到返回的列表当中
[4, 8, 12, 16]
>>> li                         #列表映射不改变被映射的列表
[2, 4, 6, 8]

在buildConnectionString中的列表映射步骤

>>> params={"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> [k for k in params.keys()]    #映射表达式刚好是自身，所以这个列表映射返回列表的原封不动的拷贝，等于params,keys().
['pwd', 'database', 'uid', 'server']
>>> [params[k] for k in params.keys()]  #较难一点的拷贝，重复遍历params[k]，变量k按顺序赋予每个元素，映射表达式接受元素并且在字典汇总查到对应的值，等于params.values()。
['secret', 'master', 'sa', 'mpilgrim']
>>> ["%s=%s" % (k, params[k]) for k in params.keys()] #用字符串格式化，将键值对列表输出。
['pwd=secret', 'database=master', 'uid=sa', 'server=mpilgrim']

Keys函数

>>> params = {"shi":"shang", "zhu":"xing", "shi":"qiang"}
>>> params.keys()  #字典中的元素是无序的，所以列表没有特定的顺序其实，因为#是一个列表，所以可以映射它，对每个元素应用一个函数，然后返回一个包含为计算后#的值的新列表
['shi', 'zhu']

连接列表和分割字符串

连接列表，将一个Key=value的键值串，连接成单个的字符串，将任意的字符串列表连接成一个单个的字符串，需要用到字符串对象的方法join。

函数是对象，字符串本身也是对象，本例子中";"调用的join方法

return ";".join(["%s=%s" % (k, params[k]) for k in params.keys()])  #join 只用于字符串列表

分割字符串，将字符串分割成列表

>>> params={"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> s = ";".join(params)
>>> s
'pwd;database;uid;server'
>>> s.split(":")
['pwd;database;uid;server']
>>> s.split(";")
['pwd', 'database', 'uid', 'server']
>>> s.split(";", 1)           #第二个参数是可选参数 要分割的次数；想要搜索一个字串，然后处理字串前面的东西和后边的东西时候，用到
['pwd', 'database;uid;server']

小结

odbchelper.py的代码和输出

def buildConnectionString(params):
"""Build a connection string from a dictionary of parameters.

Returns string."""
return ";".join(["%s=%s" % (k, params[k]) for k in params.keys()])

if __name__ == "__main__":
myParams = {"server":"mpilgrim", \
"database":"master", \
"uid":"sa", \
"pwd":"secret" \
}
print buildConnectionString(myParams)

#输出：
server=mpilgrim;uid=sa;database=master;pwd=secret

自我完成作业

测试表达式通过shell

编写python模块

导入模块和调用他们的函数

声明函数以及使用文档字符串，局部变量，和适当的缩进

定义字典，列表，和序列

存取任意个对象的属性和方法，包括字符串，列表，字典，函数和模块？？？

字符串格式化连接值

映射列表成为其他列表

分割字符串，并切连接列表为字符串

本文总结笔记参考自：dive in to python