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

1. 示例代码：

   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)

2. 声明函数：
   • Ptython 拥有函数，但是不像C++或者JAVA，没有独立的接口声明和声明实现，一旦需要使用一个函数，声明它然后开始编码；
   • Python并不区分有无函数返回值的函数，所有函数都是以def开头；
   • Python没有定义返回的数据类型，有return返回一个值，没有的话返回None；
   • Python函数中的参数不用指定类型，类型在内部有保存；
3. 文档化函数：
   • 文档化字符串，三重双引号文档化多行字符串；
   • 文档化字符串应该在函数定义的冒号：之后填写；
   • Python提供机制：函数在运行的时候有文档串的属性；
4. 什么都是对象：
   • 导入一个模块，可以引用它任何的公共函数，类，或者属性；
   • 使用定义在被倒入模块中的函数时候，必须加上模块的名字；
   • Python 中列表是对象，字典是对象，模块是对象，字符，函数是对象，全是对象；
5. 函数的识别只有一个冒号和我们自己使用的缩排，不用大括号之类的东西，缩排表示开始，不缩排表示结束；
6. 测试模块：
   • 利用这一点来测试模块，Python中模块是对象，并且有几个有用的属性；
   • if __name__ == '__main__' 技巧，__name__是所有模块的内置属性，__name__名字通常为模块的文件名，但是可以像一个标准函数去运行__name__,默认为__main__,这是一个特殊的缺省值；
   • 了解了这一点，可以在模块内部为模块设计一个测试套件，当模块直接运行的时候，__name__是__main___, 当导入模块的时候,__name__就变了，这个时候测试套件被忽略，所以说大程序加入模块之前就可以进行舒服的调试了；
7. 字典：
   • 定义一个字典

     >>> 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
     {}

8. 列表：
   • 定义列表：

     >>> 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[n]=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]

9. 序列(元组：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解冻一个序列
10. 定义变量
    • 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

11. 格式化字符串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

12. 映射列表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']

13. 连接列表和分割字符串
    • 连接列表，将一个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']

14. 小结
    • 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