Python编程从入门到实践-书籍学习笔记

2017年9月6日14:32:58于广州科学城

print ('Hello python world!')

Albert Einstein once said,”A person who never made a mistake never tired anything new.”

The zen of Python,by Tim Peters

import this # Python 之蝉

Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren’t special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one– and preferably only one –obvious way to do it. Although that way may not be obvious at first unless you’re Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it’s a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea – let’s do more of those!

==建议使用四个空格来实现缩进而不是使用Tab缩进==

==建议每行行长不超过80个字符，注释的行长不超过72个字符==

目录

特别注意(各种小错误和各种坑)

1. 应该注意所定义的对象、函数不能与关键字、库函数重名了，否则虽然不会不能运行，但是会导致名字被覆盖的那个对象不能再正常调用；
2. range()返回的序列是左闭右开的
3. 遍历容器的时候可以使用for，但是====不要在使用for的时候修改容器的元素====，否则可能会出问题；====要修改容器的元素，应该使用while来遍历====，while list1 : tmp = list1.pop()
4. 每个print是自带换行的
5. ==注意class后面的类名称首字母大写，其他字母小写==
6. ==注意class Name()中类的名称后面必须带上小括号==
7. 在Python2和3中的类定义和继承有很大的不相同
8. 双三引号括起来的就是注释，不论它出现在哪个地方
9. 类名应该使用驼峰命名法：每个单词的首字母大写，且不要使用下划线；模块名和实例名应该采用小写，单词之间使用下划线
10. 先导入标准库模块，再导入第三方模块和自己的模块，之间要有空行分割
11. 注意：windows中对于文件路径使用的是反斜杠，必须使用反斜杠来分隔，在Linux和OS X才能使用普通斜杠
12. type(obj)查看对象的类型，id()查看对象的id(地址)，可用于区分是否是同一个对象
13. 注意，在命令行中直接调用某些方法希望打印它们的结果的时候，可以不用print就能打印，但是代码中一般需要print；例：命令行type(foo)可以直接得到结果，但是从代码运行的时候没有任何输出，必须加上print:print type(foo)
14. 使用while True:不要使用while 1
15. 注意==当需要对多个对象/多种情况调用一个函数的时候，可以将这些函数放进一个列表/元组，然后使用for in来循环调用一个函数==，这样比较简洁

Python2和3的不同

1. 2中的print有无()会有不同的结果
2. 2中不论使用/还是//都会自动抛弃小数，只得到整数；3中/可以得到小数，//抛弃整数，得到小数；因此做除法的时候必须显式地将除数的小数写上去
3. 创建对象、继承的格式不同

数值和字符串

1. 当希望使用’+’来将int型变量连接字符串的时候，必须显式地将该变量说明为string：
   
   1. 例：num=10 str='num='+num 此时需要使用str='num='+str(num)否则报错;
   2. 特别注意：上例有致命错误：定义的变量名与已有库函数重名了
      
      1. 佳：`print (’s=’+str(s))
2. string对象的title()方法：将每个单词的首字母改成大写，并且将确保首字母外的其它字母为小写(如果其它字母为大写，则会被改为小写)
   
   1. 注意title()并不修改实际对象，只是对对象的副本加工后输出

方法

1. title()
2. split()
   
   1. 将一个字符串按照空白字符分裂为几个单词字符串存储到一个列表后返回
   2. 应用例：使用split()分拆后使用len()来统计文本包含的单词个数

列表list:支持多种类元素的数组

基本

1. 使用[]来表示
2. 因为列表一般包含多个元素，故建议命名为单词的复数形式
3. 使用list对象的名称来打印list时，会将list的详细表示方法打印出来
   
   1. 例：list1=['foo','bar'] print (list1)会打印出来：['foo','bar']
4. 常用的方法：
   
   1. append()
   2. insert()
   3. del 删除元素的语句但并不获取这个元素的值
      
      1. del list1[0]
      2. del是一个删除语句，并不是list列表对象的方法
   4. pop() 获取指定元素的值后再list中删除
      
      1. 弹出列表中最后一个元素，并且取得它的值以使用它，pop()弹出之后该元素被删除
      2. pop()重载：pop(index)，删除指定位置的元素
   5. remove() 不使用索引而根据元素的值来删除
      
      1. 根据值来删除元素，不会返回该元素的值(因为调用这个方法的前提就是用户已知该值)
      2. 注意：remove()只匹配第一个元素进行删除，当对象中含有多个值相同的元素的时候，只删除第一个，可以考虑使用循环进行判断；
   6. sort() 永久性的排列；传入参数reverse=true时可以使之倒序排列
   7. sorted() 临时性的排列；对list对象的副本排序后返回，原有的实际的list对象的内容不变
   8. reverse() 反转list内的元素顺序
   9. len() 得到列表元素个数，不是内存占用大小 ==注意len()的使用是len(list)==
   10. ==[-1] 索引为-1的时候，得到最后一个元素==
   11. min()
   12. max()
   13. sum()
   14. ==注意：max/min/sum是参数型的方法，不是list.sum()这种形式的调用==
5. 使用range()来生成一个序列列表：
   
   1. list1=list(range()) 直接使用list=range()是不正确的
   2. range()的重载方法：range(0,10,2);2表示生成的元素之间相差2，即产生[0,9]之间的偶数
6. ==使用[]定义给一个新对象可以使该对象成为空的列表==
   
   1. tmp=[] #tmp是一个list tmp.append()

切片

1. ==注意切片也是左闭右开的==
2. 形式：list1[1:4]注意[4]其实是取不到的
   
   1. list1[:10]
   2. list1[10:]
   3. ==list[-3:] #得到最后三个元素==

使用全切片[:]来实现list拷贝

1. ==tmp=list1[:]==
   
   1. ==使用全切片进行拷贝，产生了副本，这两个对象之间是独立的==

使用’=’来完成假’拷贝’

1. ==tmp=list1==
   1.==等号仅仅只是将一个对象关联到另一个对象，实际并没有产生副本，这两个符号实际指向一个相同的对象==

for语句

1. 格式：
   for i in list1:
   …
2. ++==for语句结合list使用==++
   
   1. [val for val in range(1,11)]
      
      1. 结果： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   2. [foo for bar in range(1,11)]
      
      1. 结果： [10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
   3. [val**2 for val in range(0,10,2)]

元组() tuple

元组是只读的列表

==虽然不能修改元组的成员的值，但是可以对存储元组的对象进行修改：对元组对象赋一个新的元组即可实现修改元组==

元组虽然不能修改，但是可以修改元组对象的指向使之指向新的元组

tuple1=(1,10) #元组的元素不可以修改

tuple1=(10,10) #可以修改tuple1的指向以实现tuple的修改

if语句

1. 直接使用age > 10就是一种if，不需要显式写出if
2. ====多条件判断使用and和or====
3. ==判断一个元素是否存在于一个集合内，使用关键字in==
4. ==判断一个集合中不包含某个元素，not in==
5. ==注意if和else都要以冒号:结尾==
6. ==if foo : elif bar : else :==
7. ====特别注意：if list1 :可以判断列表是否为空：当列表或元组为空的时候，返回False
8. 不要忘记在使用for对列表、元组进行处理之前对list/tuple进行if判断是否为空
9. ==if foo in bar :==

字典 Dictionary

格式

1. dict1 = {'foo' : 10 , 'bar' : 'hello'} #注意：字典的元素可以是不同类型的对象
2. ==注意：键值对中的值可以是各种对象，包括list、tuple、dict==

Dictionary的for循环使用格式

1. ==for key , value in dict1 :==
   
   1. 使用第一个参数表示键，第二个参数表示对应的值

字典中常用的方法

1. ``` keys() ```  得到字典中所有键的list    1. 注意：keys()的返回的list中的元素的顺序是不确定的，一般不与代码中元素的位置相同2. ```values()```  得到字典中所有值的list    1. 注意：values()的返回值是会包含重复值的，即同一个值可能出现多次，而不会自动忽略重复值3. ```items()```   特别重要:对字典使用items()可以得到字典内存储的所有内容；    1. ```dict1.items() # 注意不要忘了items()方法中的S```

遍历字典的键：keys()能够顺序遍历

遍历字典的值：values()遍历的结果==不是顺序==的

对list、tuple、dict.values()使用set()来生成集合

集合：相当于不存在重复元素的list

格式：set1 = set(dict1.value())

嵌套：如：在list中使用dict或其他在一种容器中使用另一种容器

字符串输入input()

格式 tmp = input("Please input:")

数值输入int()

int()将输入解释为数值

函数

格式：

def func() :    """DocString文档字符串-注释"""    print ("hello") 

关键字实参 ：即使用foo = bar的方法来传递参数

注意：在函数定义的时候，有默认实参的参数中，使用等号时等号两侧不要加空格；在函数调用的时候，使用关键字传参的时候使用的等号两边也不要有空格

def func(first,second='foo'):       # 等号不要空格    ...func(first='foo',second='bar'):     # 关键字传参的时候等号两侧不要空格    ...

函数定义的时候，如果想要从第二行开始写参数，则换行后应该先使用<Tab>两次实现两次缩进对齐;一般当行长超过79个字符的时候要求换行

def fn(        arg1,arg2,        foo,bar):    ...         # Function Body 注意缩进只是一个```<Tab>```而不是两个

函数调用时，容器参数的传递方式是引用传递，在函数内修改了容器的内容，将会导致实参发生变化；如果想要避免实参被改变，则必须使用切片来传递副本

list1=[1,2,3,4,5]def func(list1):    for iter in range(0,len(list1)):        list1.pop()func(list1[:])      # 使用切片传递列表的副本，列表实参不会受到影响func(list1)         # 引用传递列表参数，函数内的操作将会使实参受到影响

直接传递容器是引用传递，使用[:]才是拷贝值传递

函数定义时在参数前使用*表示接受任意数量的参数，python函数参数中的*表示该函数创建一个空的元组来接受参数；这些参数不能修改

函数定义时在参数前使用**表示接收的任意数量的参数放置到一个字典中，该列表保存的参数可以被修改

==注意**函数参数的传递方法:==

def func(**args):    for key,value in args.items():        ...# Call func() examplefunc(a = 1,b = 2,c ='3',d = '4')func(a = (1,2,3,4), b = ['a','b','c','d'])  # 传递列表、元组的等容器

模块

从指定模块中导入特定的函数

from module_name import func_name

为导入的函数指定别名

from module_name import func_name as foo

为导入的模块指定别名

import module_name as bar

使用*导入一个模块中的所有函数

格式：

from module_name import *

1. 与导入整个模块的区别：导入整个模块需要使用module_name.fn()来完成函数调用，而导入模块中所有函数可以不需要使用模块名称加英文句点运算符即可调用函数，相当于将目标模块中的所有函数都拷贝到了自己这个模块内，成为模块内定义的函数；
2. 注意：该方法==将导致本模块内定义的函数名称大大增加，很可能导致命名冲突，一般不能够使用(特别是在大工程)==

类

格式

class Foo():            # 类的名称使用首字母大写，其他小写(类似title())    """文档字符串DocStr"""    def __init__(self,foo,bar):     # 注意别忘了self参数    """DocStr"""    self.foo = foo  # 定义类的属性并赋值    self.bar = bar  # 注意使用成员的名称引用的不是类内数据，使用self+英文句点才能引用类内成员    def func1(self)；               # self不可缺少        ...

self是类对应的实例，通过self实例+英文句点访问的变量就是类实例的属性,可以在init中创建/设置类的属性

python类的实例中的每个属性都必须有初始值

毕竟python中定义每一个属性都必须通过’=’，一个属性被定义了，那么它就是被赋值了，则一定会有初始值

注意函数和类的文档字符串DocStr中的双三引号不要求在一行内，可以跨多行，使DocStr可以写多行

class Foo():    """    DocStr    Move on and on    """    def __init__(self):        ...

继承

格式

class Son_class(Super_class):       # 在括号内指定父类的名称    """从超类(父类)继承的子类"""    # __init__函数必须要接收传递给父类/超类构造函数的参数    def __init__(self,super_arg_1,super_arg_2,arg_1,arg_2):        """初始化父类属性"""        super().__init__(super_arg_1,super_arg_2)foo = Son_class(super_1,super_2,arg_1,arg_2)

注意在子类的构造函数中调用父类的构造函数

super().__init__(args)

方法重写

直接在子类中def同名的方法即可，不需要virtual-override

可以用一个对象实例作为类的一个属性：当一个类的属性很多且它们可以封装为一个对象的时候，将它们封装到一个对象然后实例作为类的属性

--snapdef __init__():    self.foo=Bar()

标准库

例：collections(集合/收藏)模块的OrderedDict有序字典

有序列表

from collections import OrderedDict as ODictmy_orderedDict = ODict()        # OrderedDict创建...

==注意：有序是指该字典记录了用户的元素输入顺序(普通dicta是不记录元素输入顺序的)，并不是指OrderedDict会对用户的输入进行排序，有序就是指打印出来的时候、遍历的时候内容的顺序与用户的输入顺序完全相同==

文件

工作目录是.py文件所在的位置

关键字with的作用

1. with==在不再需要访问文件后自动将其关闭==
2. with的作用：文件的打开、关闭需要使用open()、close()，当程序故障导致close()未能执行，会使文件对象无法被释放；with==能够自动关闭文件==
3. 格式：
   python
with open(path) as file_object:
... # 接下来操作文件的代码必须缩进，表示这些代码操作文件，属于with语句块
... # 操作完成后，取消缩进，这些代码不能操作文件，这时文件已经被with自动关闭

   ==注意文件在with代码块结束后被自动释放==

open()绝对路径的填写

1. 在==windows中，使用的路径分隔符为\==;
2. 当使用绝对路径的时候，注意，==如果绝对路径较长，则应该使用一个变量来保存绝对路径，然后将这个变量传递给open(path),而不要直接传递字符串==
3. 填写绝对路径的时候，发现==当绝对路径中的最后一个反斜杠\使用了双反斜杠的时候才能正常打开文件==，否则提示open():Invalid argument

方法()

1. read()::str
   
   1. read()会读取文件的所有内容，它应该是有重载函数提供参数来实现其它读取形式；
   2. read()的特点：==read()读取到文件末尾的时候回返回一个空字符串==，使用print显示出来的时候即为显示为空行;要想删除末尾的空行，可以使用rstrip() # 剥除空行
2. rstrip()::str
   
   1. ’rstrip’ = ‘r’ + ‘strip’; //strip即剥除，’r’表示递归，递归删除遇到的所有空白字符(即空行)
   2. 剥除末尾的空行
   3. ==只删除末尾的空行，不删除开头的空行==
3. strip()::str
   
   1. ’strip’://剥除
   2. 对str对象剥除==开头和末尾==的空白字符(包括\n、\t、空格)
4. readline()::’str’
   
   1. 读取文件对象的一行
   2. 返回值是str对象
   3. 注意区分readlines()
5. readlines():: class ‘list’
   
   1. 一次性读取文件的所有内容，按照每一行的内容顺序存储为列表的每个元素
   2. 格式：lines = file_object.readlines()
   3. 得到的结果是列表，可以按元素访问，也可以使用for来访问
   4. readlines()==将读取的每一行加上结尾的'\n'存储为列表的元素，在最后文件末尾将’\n’存储为最后一个元素==
6. open()
   
   1. 不指定模式的时候，默认为’r’
   2. 指定’w’：写入文件，若文件exist则截断之
   3. 指定’a’：追加文件，不会截断文件，==’a’与’w’一样，可以自动创建文件==
   4. 指定’r+’：可读可写，’r+不会截断文件’，==仅仅只有’w’才会截断文件==
   5. 注意：==write()不会自动追加换行==
   6. ==python仅仅支持将字符串写入文件，即write()只接受str对象，要写入数值，必须使用int()来转换==
   7. ==注意：’a’也不会自动换行

使用for()循环来实现文件的逐行读取

格式

with open(path) as file_object:    for line in file_object:    # 将每行的换行符和print自己的换行打了出来，实际多了一个换行        print (line)    # 到最后一行的时候有三次换行：print+行尾+文本结束      file_object.seek(0)    for line in file_object:        print (line.rstrip()    # 剥除空行

使用列表储存with读取的内容，使之能够在with语句块结束后使用

即使用readlines()，注意区别readline()

读取文本文件时，所有内容都将会解释为字符串，如果想要解释为数值，需要使用int()或float()

判断一个str是否在另一个str内：使用if foo in bar:

异常

简介

异常是python的一种特殊对象，用于管理程序执行期间发生的错误。当程序发生无法处理/规避的错误(该错误导致程序不可能继续执行)的时候，将会创建一个异常对象实例，如果这个异常被捕获处理，则程序可以继续运行，否则将终止，并显示一个traceback(即解释时出现语法错误时解释器打印的信息)

格式

try-except语句块:

try:    foo()   # do something which may throw exceptexcept ZeroDivisionError:       # ExceptClassName    handle()    # adjust  and fix itelse:    do_something()  # execute while there no except exist

在except:语句块中使用pass可以跳过异常处理，实际上可以将异常出现时伴随的错误信息消除掉(因为你已经捕捉了异常)，相当于关闭了异常发生时的错误信息输出。

==注意else:代码区的作用：依赖于try:代码块正常运行的条件下才能执行的代码，即try成功了才能成功执行的代码必须放到else:里面==

部分异常种类

书中仅涉及了以下异常种类
1. ZeroDivisionError
2. FileNotFoundError
1. 当文件不存在时，解释器发出的traceback(‘No such file or dictory’)其实就是一个文件未找到异常

JSON处理模块

JavaScript Object Notation # JS对象标记

方法

import json
1. json.dump(data,file_object)
1. 存储数据到JSON文件中
2. ==注意json.dump()对json文件的写入模式(w/a)取决于with中open()的模式(r/w/a)==
2. json.load(file_object)
1. 读取json文件内容

测试

import unittest'''unittest提供测试工具'''

单元测试和测试用例

单元测试用于核实函数的某个方面没有问题、运行正常

测试用例是一组单元测试，测试用例包含的若干单元测试一起核实函数在各种情况下的运行行为

步骤

导入模块unittest,创建一个继承unittest.TestCase作为超类的子类，在该类中测试

格式

import unittestfrom BeTestFunc import be_test_func as test         # 待测试的函数class MyUnitTest(unittest.TestCase):    """.D.o.c.S.t.r"""    def test_unit(self):        """测试用例"""        return_value = test(args)        self.assertEqual(return_value,compare_value)            # compare_value是assertEqual()断言/判断相等的值# 启动测试unittest.main()

测试输出

每当有一个测试通过了，则会打印输出一个英文句点，每个英文句点都表示一个测试通过了。每当有一个测试无法通过，则会打印出一个大写’E’，并且显示其对应的traceback

断言方法

1. assertEqual()
2. assertNotEqual()
3. assertTrue()
4. assertFalse()
5. assertIn()
6. assertNotIn()