Python编程：从入门到实践

Appendix 1.代码规范

1.1函数编写规范

函数名使用小写字母和单词之间下划线。应给函数指定描述性名称。模块命名也是

每个函数应有简要的DocStrings注释

每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式。

DocStrings 文档字符串

给形参指定默认值时，等号两边不要有空格，对于函数调用中的关键字实参，也应遵循这种约定：

在左括号后换行，是函数形参过长的处理办法。

每行代码长度不要超过这根竖线

1.2 类编写规范

类的名称每个单词首字母大写且不使用下划线，实例名和模块名都采用小写格式，并在单词之间加上下划线。

每个类紧跟定义后包含一个文档字符串描述类的功能

可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。

需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句。

1.3 测试类、测试函数编写规范

单元测试 是测试函数某一方面是否有问题
测试用例 是一组单元测试
全覆盖式测试 是一整套单元测试

类名包含字样Test

方法名必须以test_打头，这样它才会在我们运行test_name_function.py时自动运行。

1.4 通过空行，划分程序

要将程序的不同部分分开，可使用空行。你应该使用空行来组织程序文件，但也不能滥用；例如，如果你有5行创建列表
的代码，还有3行处理该列表的代码，那么用一个空行将这两部分隔开是合适的。然而，你不应使用三四个空行将它们隔开。
空行不会影响代码的运行，但会影响代码的可读性。

1.5 输入输出

message=input("please input your name: ")冒号后要有个空格

打印的内容太长，如何拆分

Chapter 2 变量

注意 　就目前而言，应使用小写的Python变量名。在变量名中使用大写字母虽然不会导致错误，但避免使用大写字母是个不错的主意。

2.3字符串

‘…’,"…",#字符串，单引号，双引号都可以。

str(18) #把数字转化为字符串

int(‘18’) #把字符串转化为整数

float(18),float(‘3.14’) #把整形转化为浮点数，把字符串转换为浮点数

name.title() #每个单词首字母改为大写

name.upper() #全部大写

name.lower() #全部小写

删除空白，都是暂时性删除，若要永久删除字符串中的空白，需要将删除操作的结果存回变量中

favorite_language.strip() #暂时性剔除字符串两端的空白

favorite_language.lstrip() #剔除字符串开头的空白

favorite_language.rstrip() #剔除字符串末尾的空白

message=message.replace(‘dog’,‘cat’) #替换指定单词，一次性全部替换

message.split() #以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。

字符串拼接新方式 很常用，材料中的源码字符串拼接用的都是这个

f"{str1}中间想加什么都可以{str2} {str3}" #字符串拼接

Chapter 3 列表 [ …]

3.1列表的增、删、查、改

bicycles=[‘trek’,‘cannondale’,‘redline’,‘specialized’] #初始化列表

print(bicycles[0]) #访问列表

print(bicycles[-1]) #访问列表倒数第一个元素

motorcycles[0]=‘ducati’ #修改列表元素

motorcycles.append(‘ducati’) #在列表末尾添加元素

motorcycles.insert(0,‘ducati’) #在列表任意位置插入元素

del motorcycles[0] #del语句删除指定位置元素

x=motorcycles.pop() #列表元素出栈

x=motorcycles.pop(2) #弹出指定位置元素

motorcycles.remove(‘ducati’) #根据值删除元素

remove()只能删除第一个指定的值，多次出现用循环。

3.3列表排序，逆序，长度，某个元素出现的个数

cars=[‘bmw’,‘audi’,‘toyota’,‘subaru’]

list.count(obj) #统计某个元素在列表中出现的次数。

cars.sort() #永久排序，字母顺序排序

cars.sort(reverse=True) #永久排序，字母相反顺序排序

sorted(cars,reverse=True) #临时性排序

cars.reverse() #倒着打印列表

len(cars)

Chapter4 操作列表

4.1 遍历整个列表

magicians=[‘alice’,‘david’,‘carolina’]

for magician in magicians: #遍历magicians列表中的元素

常见错误：遗漏冒号，多余的缩进

4.3 创建数值列表

for value in range(1,5): #1,2,3,4

range(10) #[0,9)

4.3.2 使用range()创建数字列表

numbers=list(range(1,6)) #创建列表 numbers=[1,2,3,4,5]

x_values=list(range(1,1001))

y_values=[x**2 for x in x_valuse] #自动计算数据，快速生成列表

4.3.3 对数字列表执行简单的统计计算

digits=list(range(0,10))

min(digits),max(digits),sum(digits)#最小，最大，求和

squares=[value**2 for value in range(1,11)] #列表解析

4.4 切片，使用列表的一部分

players=[‘charles’,‘matina’,‘michael’,‘florence’,‘eli’]

print(players[0:3]) #打印切片(子列表) 0,1,2元素

players[:4],players[2:],players[-3:]

for player in players[:3]: #遍历切片

4.4.3 复制列表

my_foods=[‘pizza’,‘falafel’,‘carrot cake’]

friend_foods=my_foods[:] 正确, friend_foods=my_foods 错误；

4.5 元组(…) #不可变的列表被称为元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组 。

dimensions=(200,50)#一个矩阵的长和宽我们不希望它改变，所以将长和宽存放在一个元组当中

print(dimesions[0]) #访问元组

for dimension in dimensions: #遍历元组中的所有值:

虽然不能修改元组的元素，但可以给存储元组的变量重新赋值

Chapter 5 if语句

if x>3 and x<6 ；if x>3 or x<1

if ‘bmw’ in cars #检查特定值是否包含在列表中

if ‘bmw’ not in cars #检查特定值是否不包含在列表中

5.3.3 if-elif-else结构，注意不要遗漏了冒号

5.4.2 if cars: #确定列表不是空的

5.4.3 使用多个列表，通过for循环和if-elif-else的结合

Chapter 6 字典

alien_0={‘color’: ‘green’, ‘points’: 5} #{…}存放一系列的键-值对

在Python中，字典 是一系列键—值对 。每个键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

alien_0[‘x_position’]=0 #添加键-值对

alien_0[‘color’]=‘yellow’ #修改字典中的值

del alien_0[‘points’] #删除键-值对

由类似对象组成的字典

遍历字典

for key,value in user_0.items(): #遍历字典，不要遗漏了.items()

注意，即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。若要跟踪顺序可以使用python标准库中模块collections 中的OrderedDict

for name in favorite_languages.keys(): #遍历字典中的所有键

for language in favorite_languages.values(): #遍历字典中所有值

for language in set (favorite_languages.values()): #剔除重复项

for name in sorted(favorite_languages.keys()): #按顺序遍历字典中的所有键

6.4 嵌套 包含前面列表和字典以及二者的遍历

有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套 。

6.4.1 字典列表

通过循环生成字典并append到列表中

经常需要在列表中包含大量的字典，而其中每个字典都包含特定对象的众多信息。例如，你可能需要为网站的每个用户创建一个字典（就像6.3.1节的user.py中那样），并将这些字典存储在一个名为users 的列表中。在这个列表中，所有字典的结构都相同，因此你可以遍历这个列表，并以相同的方式处理其中的每个字典。

6.4.2 在字典中存储列表

每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表。

注意 　列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决问题的方案。

Chapter 7 用户输入和while循环

message=input(“Please enter your ID:”)

intput()读入的都是字符串，若想获取数值输入需要用int()

7.2 while i <=5: #i=1提前赋值 while循环

让用户选择何时退出

while active: #使用标志，active=True提前定义好。

使用break 退出循环

在循环中使用continue

7.3 使用while循环来处理列表和字典

for 循环中不应修改列表，要在遍历列表的同时对其进行修改，可使用while 循环。

while unconfirmed_users: #while列表非空，使用while处理列表。

while ‘cat’ in pets: #remove结合while删除包含特定值的所有列表元素

使用用户输入来填充字典

Chapter 8 函数

def greet_user(username): #定义一个函数，并能向函数传递信息

8.1 传递实参

def describe_pet(animal_type,pet_name):

describe_pet(‘dog’,‘xiaohei’) #位置实参，实参传入时必须按位置顺序传入

describe_pet(pet_name=‘xiaohei’,animal_type=‘dog’) #关键字实参，无需考虑实参顺序，但需要给出形参名。

def describe_pet(pet_name,animal_type=‘dog’): #默认值

在形参列表中必须先列出没有默认值的形参，再列出有默认值的形参。

8.3 返回值

return full_name.title() #返回简单值

返回一个字典，同理可以返回一个列表

def buld_person(first_name,last_name='qiqi',age=''):#默认参数age是str对象
    person={'first_name':first_name,'last_name':last_name}
    print(type(age))
    if age:#不能用if age>=18: 因为这里的age是str对象，不是int对象
        person['age']=age
    return person
person=buld_person('du','jianjun',23)#23可以打引号，也可以不打引号
print(person)

def buld_person(first_name,last_name='qiqi',age=None):#默认参数age是int对象
    person={'first_name':first_name,'last_name':last_name}
    print(type(age))
    if age>=18:
        person['age']=age
    return person
person=buld_person('du','jianjun',23)
print(person)

传递一个列表

print_models(unprinted_designs[:])#禁止函数修改列表，切片表示法[:]创建列表的副本

def make_pizza(*toppings): #传递任意数量的实参。toppings是一个元组，星号让python创建了一个名为topings的空元组。

def make_pizza(size,*toppings):#结合使用位置实参和任意数量实参

def build_profile(first,last,**user_info): #使用任意数量的关键字实参，user_info是一个空字典

8.6 将函数存储在模块中 #模块是.py文件

import pizza #导入整个模块，pizza.make_pizza(16,‘cheese’)，调用pizza.py文件中的make_pizza函数

pizza.make_pizza(16,‘cheese’) #导入整个模块后所使用的的句点表示法

from module_name import function_name #导入特定的函数

import numpy as np #使用as给模块指定别名

from pizza import make_pizza as mp #使用as给函数指定别名

from pizza import * #导入模块中的所有函数，不建议这样用，最好是导入整个模块并使用句点表示法，让代码更容易阅读。

Chapter 9 类

9.1 创建和使用类

9.1.1创建Dog类#类名首字母大写

class Dog():

def __init__(self,name,age)方法

my_dog=Dog(‘xiaohei’,6)#创建实例

my_dog.name, my_dog.sit() #访问属性，调用方法

self.age=18 #给属性指定默认值

修改属性的值

可以以三种不同的方式修改属性的值：直接通过实例进行修改；通过方法进行设置；通过方法进行递增（增加特定的值）。

xiaohei.age=10 #直接通过实例进行修改

通过方法修改属性的值

通过方法对属性的值进行递增

9.3 Class ElectrictCar(Car): #继承

一个类继承 另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类(超类)，而新类称为子类 。

super().__init__(make,model,year) #子类的init方法下面需要用super().init方法将父类和子类关联起来

给子类定义属性和方法

子类中的方法与父类中的方法同名可实现重写父类方法

将实例用作属性

例子很重要，看一看

class Person():
    def __init__(self,user_name,**info):
        self.user_name=user_name
        self.info={}
        for k,v in info.items():
            self.info[k]=v
    def print_name(self):
        print(self.user_name)
        return self.user_name
    def print_info(self):
        print(self.info)

class Lover(Person):
    def __init__(self,user_name,Person,**info):
        super().__init__(user_name,**info)
        self.lover=Person
    def print_info(self):
        print(self.user_name+"'s lover is "+self.lover.user_name,self.info)
    def print_lover_info(self):
        self.lover.print_info()

djj=Person('dujianjun',location="HIT",interest='coding')
caoqiqi=Lover('caomin',djj,location='xiangyun',interest='reading')
caoqiqi.print_info()
caoqiqi.print_lover_info()

9.4 导入类

from car import Car #导入单个类

from car import Car, ElectricCar #从一个模块中导入多个类

import car #导入整个模块，使用句点表示法访问需要的类

Python标准库

Python标准库链接 ：https://pymotw.com/3/index.html

Chapter 10 文件和异常

10.1 从文件中读取数据

with open(‘pi_digit.txt’) as file_object: #打开文件，关键字with在不再需要访问文件后将其关闭

10.1.1读取整个文件

contents=file_object.read() #读取整个文件

在with这个代码块下，打开的文件不会关闭，出了with代码块，文件就会关闭

contents.rstrip() #Chapter 2有更详细的内容

with open(’./test/pi_digits.txt’) as file_object: 使用相对路径查找打开文件，’.‘不能少，代表相对路径，没有’.’则是绝对路径

注意 Windows系统有时能够正确地解读文件路径中的斜杠(/)。如果你使用的是Windows系统，且结果不符合预期，请确保在文件路径中使用的是反斜杠()。
各个系统打开路径的方式不同

10.1.3 逐行读取

for line in file_object:

lines=file_object.readlines() #创建一个包含文件各行内容的列表

使用文件的内容举例：

== 对于你可处理的数据量，Python没有任何限制；只要系统的内存足够多，你想处理多少数据都可以。==

10.2 写入文件

with open(filename,‘w’) as file_object: #文件不存在则创建，存在则先清空内容

如果你要写入的文件不存在，函数open() 将自动创建它。然而，以写入（‘w’ ）模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。

写入空文件

file_object.write(“I love qiqi”)

注意 　Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str() 将其转换为字符串格式。
== 读取模式(‘r’)、写入模式(‘w’)、附加模式(‘a’)、读写模式(‘r+’)==

写入多行

函数write() 不会在你写入的文本末尾添加换行符，因此如果你写入多行时没有指定换行符，文件看起来可能不是你希望的那样：

附加到文件

with open(filename,‘a’) as file_object #文件不存在则创建，存在的话，写入到文件的行都将添加到文件末尾

10.3 异常

使用异常避免崩溃或被黑客攻击

try:-except 异常:异常处理-else 结构

处理FileNotFoundError 异常

失败时一声不吭

pass #可在代码块中使用它来让Python什么都不要做

10.4 存储数据

import json
with open(‘numbers.json’,‘w’) as file_object:

json.dump(numbers,file_object) #将数列numbers放入.json文件中

10.4.3 重构

你经常会遇到这样的情况：代码能够正确地运行，但可做进一步的改进——将代码划分为一系列完成具体工作的函数。这样的过程被称为重构 。重构让代码更清晰、更易于理解、更容易扩展。

Chapter 11 单元测试和测试用例

Python标准库中的模块unittest 提供了代码测试工具。
单元测试 用于核实函数的某个方面没有问题
测试用例 是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求。良好的测试用例考虑到了函数可能收到的各种输入，包含针对所有这些情形的测试。
全覆盖式测试 用例包含一整套单元测试，涵盖了各种可能的函数使用方式。对于大型项目，要实现全覆盖可能很难。通常，最初只要针对代码的重要行为编写测试即可，等项目被广泛使用时再考虑全覆盖。

11.1 测试函数：用于测试函数的

可通过的测试

mport unittest

from name_function import get_formatted_name

class NameTestCase(unittest.TestCase):
    def test_first_last_name(self): #类名之后，直接跟测试函数，都是test_开头
        name=get_formatted_name('du','jianjun')
        print(name)
        self.assertEqual('Du Jianjun',name) #第一参数放预期结果，第二参数放输出结果

if __name__ == '__main__': #下面截图少了这一句，会出错
    unittest.main()

不能通过的测试

测试未通过会报错成这样：

测试未通过怎么办？：应该修改被测试的函数，而不是修改测试

11.2 测试类：用于测试类的

和测试函数写法基本一致

方法setUp()

注意 　运行测试用例时，每完成一个单元测试，Python都打印一个字符：测试通过时打印一个句点；测试引发错误时打印一个E ；测试导致断言失败时打印一个F 。这就是你运行测试用例时，在输出的第一行中看到的句点和字符数量各不相同的原因。如果测试用例包含很多单元测试，需要运行很长时间，就可通过观察这些结果来获悉有多少个测试通过了。

import unittest
from survey import AnonymousSurvey
class AnonymousSurveyTestCase(unittest.TestCase):
    def setUp(self):
        question='What language did you first learn to speak?'
        self.my_survey=AnonymousSurvey(question)
        self.responses=['English','Chinese','Spanish']

    def test_single_response(self):
        self.my_survey.store_response(self.responses[0])
        self.assertIn(self.responses[0],self.my_survey.responses)

    def test_three_response(self):
        for response in self.responses:
            self.my_survey.store_response(response)
        for response in self.responses:
            self.assertIn(response,self.my_survey.responses)

if __name__ == '__main__':
    unittest.main()