[Python知识库]python

变量

\n换行符，\t制表符

列表

列表的创建和组织

python中，用方括号[ ]表示列表，并用逗号来分割其中的元素。例如：

bicucles = ['trek', 'redline', 'hhah']

列表是一个有序集合，因此列表的访问可以遵循索引，例如:

print(bicucles[0])

索引从0开始，索引-1表示最后一个列表元素，-2表示倒数第二个元素，以此类推。
列表的修改，添加，删除：

names = ['kangkang', 'john', 'alice']
names[0] = 'lens'  # 修改列表元素
names.append('xiaofu')  # 在列表末尾添加元素
names.insert(0, 'mary')  # 在0索引处添加元素，既有元素依次右移
del names[0]  # 删除元素
name = names.pop()  # 删除最后一个元素，并返回它
name = names.pop(0)  # 删除第一个元素，0指定删除的索引
names.remove('kangkang')  # 根据值删除元素

组织列表：

names.sort()  # 对列表排序，永久排序
names.sort(reverse = True)  # 反序
sorted(names)  # 临时排序
names.reverse()  # 反转列表
len(names)  # 列表长度

操作列表

遍历列表：

names = ['kangkang', 'john', 'alice']
for name in names:  # 注意冒号
    print(name)

数字列表：

print(range(1,5))  # range产生一系列数字
>>>range(1, 5)
print(list(range(1,5)))  # list将数字转化为列表
>>>[1, 2, 3, 4]
print(list(range(5)))
>>>[0, 1, 2, 3, 4]
print(list(range(2,12,3)))  # 指定步长
>>>[2, 5, 8, 11]

列表解析：

#####创建一个元素为1-10的平方的列表
list = []
for rang in range(1,11):
    list.append(rang**2)
# 解析列表
list = [rang**2 for rang in range(1,11)]

列表切片：

names = ['x', 'y', 'z', 'd', 'h']
names[0:3]
names[:3]  # 索引0到索引2
names[1:4]  # 索引1到索引3
name[2:]  # 索引2到最后一个
names[-3:]  # 最后三个

复制列表：

names = ['x', 'y', 'z', 'd', 'h']
names1 = names[:]  # 利用切片复制列表，此时name1和names为两个相同的列表
names2 = names  # 这种做法不能得到两个列表，而是names2和names都指向同一个列表

元组 tuple，列表是可以修改的，要创建一系列不可更改的元素，可以使用元组。元组使用圆括号而不是方括号来标识：

t = (200, 50)
t[0]  # 元组的访问

if 语句

if语句格式：

if expression1 and expression2:
   operate
elif expression3:
   operate
else:
   operate

dict 字典

字典的创建与访问

创建空字典，字典用放在花括号{ }中的一系列键值对表示。每个键key与每个值value相关联，可以使用键来访问与之关联的值。python不关心键值对的顺序，只关心键值对的对应关系。与键关联的值可以是数字、字符串、列表乃至字典。

target = {}  # 创建一个空字典
target["boxes"] = boxes  # 添加键值对
target["labels"] = labels
target["masks"] = masks
target["image_id"] = image_id
target["area"] = area
target["iscrowd"] = iscrowd

使用字典表示：

target={’boxes‘：boxes，’masks‘：masks}
target['boxes']  # 字典的访问，返回与键‘boxes’相关联的值
target['name'] = 25  # 增加键值对，或者修改键值对
del target['name']  # 删除键值对

遍历字典：

for key, value in target.items():  # 两个变量用于储存键值对
    print("\nkey:" + key)
    print("value:" + value)
for k in target.keys():  # 遍历字典中的所有键
    print("\nkey:" + k)
for v in target.values():  # 遍历字典中的所有值
    print("\nkey:" + v)
for k in set(target.values()):  # 遍历字典中的所有值，不重复(创建一个集合)
    print("\nkey:" + k)

嵌套

列表中嵌套字典，字典中嵌套列表，字典中嵌套字典。
字典列表，列表中每个元素都是一个字典：

person1 = {'color': 'y', 'name': 'x'}  # 字典
person1 = {'color': 't', 'name': 'f'}

people = [person1, person2]  # 字典列表

字典中存储列表：

pizza = {
     'crust': 'thick',
     'toppings': ['mushroon', 'cheese'],
     }

字典中存储字典：

pizza = {
     'crust': {'color': 'y', 
     'name': 'x',
     },
     'toppings': {'color': 't', 
     'name': 'f',
     },
  }

函数

函数定义与形参

传递任意数量的实参：
带*的形参，python将会创建一个名为toppings的空元组，将实参封装到其中，即使只收到一个值也是如此。

def make_pizza(size, *toppings):  
    """
    这里是文档字符串，描述函数是做什么的，用三引号括起
    python使用它们来生成有关程序中函数的文档
    """
    for topping in toppings:
        print(topping)

传递任意数量的关键字实参，预先不知道传递给函数的会是什么样的信息。**形参可以接受任意数量的键值对。
**user_info让python创建一个名为user_info的空字典，并将收到的所有名称-值对封装到这个字典中。

def build_profile(first, last, **user_info):
    """创建一个字典，包含用户信息"""
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for k, v in user_info.items():
        profile[k] = v
    return profile

函数模块

模块创建，创建module_name.py文件，在其中编写函数。接下来在该文件所在目录下创建另一个test.py文件，在test.py文件内导入模块，就能使用所有模块中定义的函数，导入与使用格式：

import module_name
module_name.function_name()

导入特定函数：

from module_name import function_0, function_1
function_0()  # 调用无需使用句点

class 类

从空白创建一个类

python中，首字母大写的名称指的是类。下面这个类的定义中括号是空的，表示从空白创建这个类。
方法__init__()
类中的函数称为方法，__init__()是一个特殊的方法，每当根据Dog类创建新实例时，python会自动运行它。__init__()方法包含三个形参，self、name和age，形参self必不可少，且必须位于第一个。在创建实例时，将自动传入实参self，它是一个指向实例本身的引用，让实例可以访问类中的属性和方法。__init__()中两个变量都有前缀self，以self为前缀的变量可以供类中所有方法使用，称为属性。

class Dog():
    """创建一个类"""

    def __init__(self, name, age):
        """初始化属性"""
        self.name = name
        self.age = age

    def sit(self):
        """模拟一种类的通用行为"""
        print(self.name.title() + "is now sitting.")

    def roll_over(self):
        print(self.name.title() + "rolled over.")

根据Dog类创建实例my_dog，并使用提供的值来设置属性name和age。访问属性使用据点表示法，调用方法同样。

my_dog = Dog('zhangq', 22)
print("my dog's name is " + my_dog.name +".")
print("my dog is " + str(my_dog.age) + " years old.")
my_dog.sit()
my_dog.roll_over()

使用类

类中的属性必须有初始值，在方法__init__()中指定初始值是可行的。如果对某个属性这样做了，就无需包含为它提供初始值的形参。

class Car():
    """从空白创建一个类"""

    def __init__(self, make, model, year):
        """属性"""
        self.year = year
        self.make = make
        self.model = model
        self.odometer_read = 0  # 默认属性初始值

    def get_name(self):
        """定义一个方法"""
        name = str(self.year) + ' ' + self.make + ' ' +self.model
        return name

my_car = Car('china', 'A4', 2021)
print(my_car.get_name())

直接修改属性的值：

my_car.odometer_read = 23

通过方法进行设置：

class Car():
    --snip--
    
    def update_odometer(self, m):
        self.odometer_read = m 

my_car.update_odometer(23)

类的继承

编写类时，并非总要从空白开始。如果要编写的类是另一个现成类的特殊版本，可以使用继承。继承会自动获得父类的所有属性和方法，同时子类还能定义自己的属性和方法。创建子类时，父类必须包含在当前文件中，并在子类前面，或者import导入父类。定义子类时，必须在括号内指定父类的名称。super()让python调用父类的__init__，使子类的实例包含父类的所有属性。父类也称为superclass。

class Electriccar(Car):
    """继承父类Car"""

    def __init__(self, make, model, year):
        """初始化父类属性"""
        super().__init__(make, model, year)

my_ecar = Electriccar('china', 'bmw', 2021)
print(my_ecar.get_name())

python2.7的继承

python2.7的语法有所不同，阅读代码时可能用的上，以下继承是python2.7的语法。定义父类时，必须在父类括号内指定object，函数super()需要两个实参，子类名和对象self。

class Car(object):
    """从空白创建一个类"""
    def __init__(self, make, model, year):
    --snip--

class Electriccar(Car):
    def __init__(self, make, model, year):
        super(Electriccar, self).__init__(make, model, year)
        --snip--

将实例用作属性

class Battery():
    def __init__(self, battery=70):
        self.batterysize = battery

    def showbattery(self):
        print(str(self.batterysize))

class Electriccar(Car):
    """继承父类Car"""

    def __init__(self, make, model, year):
        """初始化父类属性，并增加子类属性"""
        super().__init__(make, model, year)
        self.battery = Battery()  # 实例用作属性

my_ecar.battery.showbattery()

collections模块

模块collections中的OrderedDict类可以创建字典，并且记录其中键值对的添加顺序。

from collections import OrderedDict

shili = OrderedDict()
shili['name'] = 'zhangq'
shili['age'] = 22
shili['location'] = 'chongq'
for k, v in shili.items():
    print(k+': '+str(v))

类编码风格

• 类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写ElectricCar，而不使用下划线。实例名my_car和模块名car.py都采用小写格式，并在单词之间加上下划线。
• 对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行述。
• 可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import语句，再添加一个空行，然后编写导入你自己编写的模块的import语句。在包含多条import语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。

文件与异常

文件读取与写入

要使用文本文件中的信息，需要先将其读取到内存中。
with可以在不需要访问文件后将其关闭，只有在with代码块内可以对文件对象进行使用。
读取整个文件：

with open('digits') as file_object:
    content = file_object.read()
    print(content)

逐行读取：

filename = 'digits'
with open(filename) as file_object:
    for l in file_object:
        print(l.rstrip())

将文件内容存在列表中：

with open(filename) as file_object:
    l = file_object.readlines()  # 读取每一行，存放在列表中
print(l)
# 将读取内容存放到一个字符串中
ps = ''
for lt in l:
    ps += lt.strip()
print(ps)
print(len(ps))

python读取文本文件时，所有的文本都被解读为字符串，如果读取的数字需要作为数值使用，必须使用int()或float()将其转化格式。
写入文件，在open()时提供两个参数，分别是文件路径和操作方式，读取模式(‘r’)，写入模式(‘w’)，附加模式(‘a’)，读取写入模式(‘r+’)，默认只读。python只能将字符串写入文本文件，如果要把数值数据存到文本文件中，需要先str()转化格式

with open(filename, 'a') as file_object:
    file_object.write('\n\tthere also be something more important.')

异常与异常处理

异常使用try-except代码块处理。try-except代码块让python在遇到异常时执行指定操作，显示友好错误信息，而不是traceback。并且程序不会在异常处中断，这可以有效防止程序崩溃。只有可能发生异常的代码才需要放在try语句中。一些仅在try正常执行才需要运行的代码放在else中。

try:
    print(5/0)
except ZeroDivisionError:
    print("there is wrong about division")
else:
    print("")
print("程序不会被异常打断")

统计文件中包含多少个单词：

with open('digits') as file_object:
    content = file_object.read()
    print(len(content.split()))  # split可以将字符串以空格拆分为多部分

python中的pass语句可以使程序在发生指定异常时什么都不做：

except FileNotFoundError:
	pass

数据

json格式文件可以用来存储python程序中的数据，使程序之间可以分享数据。

import json
numbers = [2,3,4,5,6,7,8]
filename = 'number.json'
with open(filename, 'w') as object_file:
    json.dump(numbers, object_file)  # 存储

with open(filename) as object_file:
    t = json.load(object_file)  # 读取
print(t)

测试代码

测试函数

python标准库中的模块unittest提供了代码测试工具。创建测试程序：

在测试程序中import需要测试的函数：

import unittest
from function import get_name

class MyTestCase(unittest.TestCase):
    def test_first_last_name(self):
        result = get_name('zhang', 'q')
        self.assertEqual(result, 'Zhang Q')  # add assertion here

    def test_fml_name(self):
        result = get_name('xia', 'wen', 'h')
        self.assertEqual(result, 'Xia H Wen')


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

"""
function.py
"""
def get_name(first, last, mid=''):
    if mid:
        fullname = first + ' ' + mid + ' ' + last
    else:
        fullname = first + ' ' + last
    return fullname.title()

测试类

unittest提供很多断言方法，下面是六个常用的断言方法：

编写一个测试：

import unittest
from survey import AnonymousSurvey

class TestAnonymousSurvey(unittest.TestCase):
    """针对一个类的测试"""

    def setUp(self):
        """
        创建一个调查对象，供测试方法使用
        以免在每个测试方法中都要创建一个实例
        """
        question = "where is my future?"
        self.ms = AnonymousSurvey(question)
        self.anwser = ['ai', 'cv', 'nlp']

    def test_store_single_response(self):
        """测试单个答案可以妥善存储"""
        self.ms.store_response(self.anwser[0])
        self.assertIn(self.anwser[0], self.ms.response)  # add assertion here

    def test_store_three_response(self):
        for i in self.anwser:
            self.ms.store_response(i)
        for i in self.anwser:
            self.assertIn(i, self.ms.response)

class AnonymousSurvey():
    """创建一个要测试的类"""

    def __init__(self, question):
        self.question = question
        self.response = []

    def show_question(self):
        print(self.question)

    def store_response(self, new_response):
        self.response.append(new_response)

    def show_result(self):
        print("Result:")
        for i in self.response:
            print('- ' + i)