Python基础知识

摘录自Python编程：从入门到实践

1. 变量和简单数据类型

变量规范:

1. 变量只能包含字母、数字和下划线，但不能以数字开头；
2. 变量名不能包含空格；
3. 不要使用python关键字和函数名作为变量名。

#字符串
name = "ada LoveLace"
print(name.title())#title()用于大写首字母(未改变原字符串)
print(name.upper())#upper()用于大写全部字母
print(name.lower())#lower()用于小写全部字母

Python使用加号（+）来合并字符串。

Python能够找出字符串开头和末尾多余的空白。要确保字符串末尾没有空白，可使用方法rstrip()。你还可以剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法lstrip()和strip()。

Python使用两个乘号表示乘方运算。

str()函数：

#强转字符型
age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

2. 列表

2.1 基本操作

列表由一系列按特定顺序排列的元素组成，其中的元素之间可以没有任何关系。

colors = ['blue', 'yellow', 'green', 'red']
colors.append('black')#向列表末尾加入新元素(改变了原列表)
colors.insert(0,'white')#向列表中插入新元素
del colors[0]#通过索引删除元素
popped_colors = colors.pop()#pop弹出列表中的元素，无参数则弹出列表最后一个元素
colors.remove('blue')#删除指定元素

实际上，你可以使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。

2.2 列表排序

使用方法sort()对列表进行永久性排序，只需向sort()方法传递参数reverse=True，就可以按与字母顺序相反的顺序排列列表元素。

使用函数sorted()对列表进行临时排序，也可向函数sorted()传递参数reverse=True。

要（永久性地）反转列表元素的排列顺序，可使用方法reverse()。

使用函数len()可快速获悉列表的长度。

2.3 遍历列表

magicians = ['alice', 'david', 'carolina'] 
for magician in magicians: 
    print(magician)

alice
david
carolina

2.4 数值列表

numbers = list(range(1,6)) 
print(numbers)

[1, 2, 3, 4, 5]

squares = [] 
for value in range(1,6): 
    square = value**2 
    squares.append(square) 
print(squares)

[1, 4, 9, 16, 25]

列表解析：（只需一行代码）

squares = [value**2 for value in range(1,6)]

2.5 切片

1. [0:2]：前两个；
2. [:4]：没有指定起始索引，从列表开头开始；
3. [-3:]：最后3个元素。

• [:]：复制列表
• 直接复制实际上是让Python将新变量关联到原的列表，因此两个变量都指向同一个列表。

2.6 元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

dimensions = (200, 50) 
print(dimensions[0])

试图修改元组的操作是被禁止的，因此Python不能给元组的元素赋值。给元组变量整体赋值是合法的。

3. if语句

Python使用and和or表示与或关系。

要判断特定的值是否已包含在列表中，可使用关键字in。

elif是Python中的else if。

在if语句中将列表名用在条件表达式中时，Python将在列表至少包含一个元素时返回True，并在列表为空时返回False。

4. 字典

4.1 基本操作

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

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0['color'])

新增键值对：

alien_0['x_position'] = 0 
alien_0['y_position'] = 25 
print(alien_0)

使用del删除键值对。

4.2 遍历

user_0 = { 
 'username': 'efermi', 
 'first': 'enrico', 
 'last': 'fermi', 
 } 
for key, value in user_0.items(): 
    print("
Key: " + key) 
    print("Value: " + value)

Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

在不需要使用字典中的值时，方法keys()用于获取所有的键。使用方法values()可以返回一个值列表。

为剔除重复项，可使用集合（set）。集合类似于列表，但每个元素都必须是独一无二的。

5. 用户输入

函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中，以方便后续使用。

message = input("Tell me something, and I will repeat it back to you: ") 
print(message)

为解决这个问题，可使用函数int()，它让Python将输入视为数值。

6. while循环

current_number = 1 
while current_number <= 5: 
    print(current_number) 
    current_number += 1

要立即退出while循环，不再运行循环中余下的代码，也不管条件测试的结果如何，可使用break语句。

以while True打头的循环将不断运行，直到遇到break语句。

要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句。

7. 函数

7.1 操作列表

将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都可以是永久性的，这让你能够高效地处理大量的数据。

# 首先创建一个列表，其中包含一些要打印的设计
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron'] 
completed_models = [] 
# 模拟打印每个设计，直到没有未打印的设计为止
# 打印每个设计后，都将其移到列表completed_models中
while unprinted_designs: 
    current_design = unprinted_designs.pop() 
    #模拟根据设计制作3D打印模型的过程
    print("Printing model: " + current_design) 
    completed_models.append(current_design) 
 
# 显示打印好的所有模型
print("
The following models have been printed:") 
for completed_model in completed_models: 
    print(completed_model)

有时候，需要禁止函数修改列表。此时可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

要将列表的副本传递给函数，可以像下面这样做：

function_name(list_name[:])

7.2 任意实参

有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。

def make_pizza(size, *toppings): 
    """概述要制作的比萨""" 
    print("
Making a " + str(size) + 
          "-inch pizza with the following toppings:") 
    for topping in toppings: 
        print("- " + topping) 
 
make_pizza(16, 'pepperoni') 
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。

def build_profile(first, last, **user_info): 
    """创建一个字典，其中包含我们知道的有关用户的一切""" 
    profile = {} 
    profile['first_name'] = first 
    profile['last_name'] = last 
    for key, value in user_info.items(): 
        profile[key] = value 
    return profile 
user_profile = build_profile('albert', 'einstein', 
                             location='princeton', 
                             field='physics') 
print(user_profile)

{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

7.3 存储在模块中

要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。

import module_name

import module_name as mn

from module_name import function_name

from module_name import function_name as fn

from module_name import *

所有的import语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序。

9. 类

9.1 创建和使用类

class Dog(): 
    """一次模拟小狗的简单尝试""" 
    def __init__(self, name, age): 
        """初始化属性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!")

方法__init__()

类中的函数称为方法。__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。方法__init__()定义包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。

以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。

my_dog = Dog('willie', 6) 
print("My dog's name is " + my_dog.name.title() + ".") 
print("My dog is " + str(my_dog.age) + " years old.")

My dog's name is Willie.
My dog is 6 years old.

要访问实例的属性，可使用句点表示法。

根据Dog类创建实例后，就可以使用句点表示法来调用Dog类中定义的任何方法。

my_dog.sit() 
my_dog.roll_over()

Willie is now sitting.
Willie rolled over!

9.2 继承

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方法__init__()需要父类施以援手。

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    
    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
    
    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")
    
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")
    
    def increment_odometer(self, miles):
        self.odometer_reading += miles

class ElectricCar(Car): 
    """Represent aspects of a car, 
    specific to electric vehicles.""" 
    def __init__(self, make, model, year): 
        """ 
        电动汽车的独特之处
        初始化父类的属性，再初始化电动汽车特有的属性
        """ 
        super().__init__(make, model, year) 
        self.battery_size = 70 
 
    def describe_battery(self): 
        """打印一条描述电瓶容量的消息""" 
        print("This car has a " + str(self.battery_size) + "-kWh battery.") 
my_tesla = ElectricCar('tesla', 'model s', 2016) 
print(my_tesla.get_descriptive_name()) 
my_tesla.describe_battery()

2016 Tesla Model S
This car has a 70-kWh battery.

super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。父类也称为超类（superclass），名称super因此而得名。

让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。你可以将大型类拆分成多个协同工作的小类。

class Battery(): 
    """一次模拟电动汽车电瓶的简单尝试""" 
    def __init__(self, battery_size=70): 
        """初始化电瓶的属性""" 
        self.battery_size = battery_size 
    def describe_battery(self): 
        """打印一条描述电瓶容量的消息""" 
        print("This car has a " + str(self.battery_size) + "-kWh battery.") 

class ElectricCar(Car): 
    """电动汽车的独特之处""" 
    def __init__(self, make, model, year): 
        """ 
        初始化父类的属性，再初始化电动汽车特有的属性
        """ 
        super().__init__(make, model, year) 
        self.battery = Battery()

my_tesla = ElectricCar('tesla', 'model s', 2016) 
my_tesla.battery.describe_battery()

This car has a 70-kWh battery.

类可以从文件导入。

类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。

10. 文件和异常

10.1 从文件读取数据

with open('pi_digits.txt') as file_object: 
    contents = file_object.read() 
    print(contents)

关键字with在不再需要访问文件后将其关闭。也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存在bug，导致close()语句未执行，文件将不会关闭。未妥善地关闭文件可能会导致数据丢失或受损。如果在程序中过早地调用close()，会导致更多的错误。通过使用前面所示的结构，可让Python去确定：你只管打开文件，并在需要时使用它，Python自会在合适的时候自动将其关闭。

逐行读取：

with open('pi_digits.txt') as file_object: 
    for line in file_object: 
        print(line.rstrip())

10.2 写入文件

保存数据的最简单的方式之一是将其写入到文件中。通过将输出写入文件，即便关闭包含程序输出的终端窗口，这些输出也依然存在：你可以在程序结束运行后查看这些输出，可与别人分享输出文件，还可编写程序来将这些输出再次读取到内存中并进行处理。

filename = 'programming.txt' 
with open(filename, 'w') as file_object: 
    file_object.write("I love programming.")

Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。

如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式'a'打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。

10.3 异常

Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行；如果你未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。

1. ZeroDivisionError 异常

当你认为可能发生了错误时，可编写一个try-except代码块来处理可能引发的异常。你让Python尝试运行一些代码，并告诉它如果这些代码引发了指定的异常，该怎么办。

try: 
    print(5/0) 
except ZeroDivisionError: 
    print("You can't divide by zero!")

print("Give me two numbers, and I'll divide them.") 
print("Enter 'q' to quit.") 
while True: 
    first_number = input("
First number: ") 
    if first_number == 'q': 
        break 
    second_number = input("Second number: ") 
    try: 
        answer = int(first_number) / int(second_number) 
    except ZeroDivisionError: 
        print("You can't divide by 0!") 
    else: 
        print(answer)

2. FileNotFoundError 异常

使用文件时，一种常见的问题是找不到文件：你要查找的文件可能在其他地方、文件名可能不正确或者这个文件根本就不存在。对于所有这些情形，都可使用try-except代码块以直观的方式进行处理。

filename = 'alice.txt' 
try: 
    with open(filename) as f_obj: 
        contents = f_obj.read() 
except FileNotFoundError: 
    msg = "Sorry, the file " + filename + " does not exist." 
    print(msg)

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

有时候你希望程序在发生异常时一声不吭，就像什么都没有发生一样继续运行。要让程序在失败时一声不吭，可在except代码块中使用pass语句，让Python什么都不要做。

10.4 存储数据

很多程序都要求用户输入某种信息，如让用户存储游戏首选项或提供要可视化的数据。不管专注的是什么，程序都把用户提供的信息存储在列表和字典等数据结构中。用户关闭程序时，你几乎总是要保存他们提供的信息；一种简单的方式是使用模块json来存储数据。

JSON（JavaScript Object Notation）格式最初是为JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用。

使用json.dump()来存储数据，使用json.load()读取数据。

import json 
numbers = [2, 3, 5, 7, 11, 13] 
filename = 'numbers.json' 
with open(filename, 'w') as f_obj: 
    json.dump(numbers, f_obj)

filename = 'numbers.json' 
with open(filename) as f_obj: 
    numbers = json.load(f_obj) 
print(numbers)

11. 测试代码

11.1 测试函数

Python标准库中的模块unittest提供了代码测试工具。单元测试用于核实函数的某个方面没有问题；测试用例是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求。

import unittest 

def get_formatted_name(first, last): 
    """Generate a neatly formatted full name.""" 
    full_name = first + ' ' + last 
    return full_name.title()


class NamesTestCase(unittest.TestCase): 
    """测试name_function.py""" 
    
    def test_first_last_name(self): 
        """能够正确地处理像Janis Joplin这样的姓名吗？""" 
        formatted_name = get_formatted_name('janis', 'joplin') 
        self.assertEqual(formatted_name, 'Janis Joplin') 
unittest.main()

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

创建一个类并继承unittest.TestCase类，这样Python才知道如何运行你编写的测试。

11.2 测试类

断言方法	用途
assertEqual(a, b)	核实a == b
assertNotEqual(a, b)	核实a != b
assertTrue(x)	核实x为True
assertFalse(x)	核实x为False
assertIn(item, list)	核实item在list中
assertNotIn(item, list)	核实item不在list中

import unittest 

class AnonymousSurvey(): 
    """收集匿名调查问卷的答案""" 
     
    def __init__(self, question): 
        """存储一个问题，并为存储答案做准备""" 
        self.question = question 
        self.responses = [] 
     
    def show_question(self): 
        """显示调查问卷""" 
        print(self.question) 
     
    def store_response(self, new_response): 
        """存储单份调查答卷""" 
        self.responses.append(new_response) 
     
    def show_results(self): 
        """显示收集到的所有答卷""" 
        print("Survey results:") 
        for response in self.responses: 
            print('- ' + self.response)

class TestAnonmyousSurvey(unittest.TestCase): 
    """针对AnonymousSurvey类的测试""" 
    def test_store_single_response(self): 
        """测试单个答案会被妥善地存储""" 
        question = "What language did you first learn to speak?" 
        my_survey = AnonymousSurvey(question) 
        my_survey.store_response('English') 
        self.assertIn('English', my_survey.responses) 
unittest.main()

11.3 setUp()

import unittest 

class AnonymousSurvey(): 
    """收集匿名调查问卷的答案""" 
     ...

class TestAnonymousSurvey(unittest.TestCase): 
    """针对AnonymousSurvey类的测试""" 
     
    def setUp(self): 
        """ 
        创建一个调查对象和一组答案，供使用的测试方法使用
        """ 
        question = "What language did you first learn to speak?" 
        self.my_survey = AnonymousSurvey(question) 
        self.responses = ['English', 'Spanish', 'Mandarin'] 
    def test_store_single_response(self): 
        """测试单个答案会被妥善地存储""" 
        self.my_survey.store_response(self.responses[0]) 
        self.assertIn(self.responses[0], self.my_survey.responses) 
        
    def test_store_three_responses(self): 
        """测试三个答案会被妥善地存储""" 
        for response in self.responses: 
            self.my_survey.store_response(response) 
        for response in self.responses: 
            self.assertIn(response, self.my_survey.responses) 
unittest.main()

unittest.TestCase类包含方法setUp()，让我们只需创建这些对象一次，并在每个测试方法中使用它们。

方法setUp()做了两件事情：创建一个调查对象；创建一个答案列表。存储这两样东西的变量名包含前缀self（即存储在属性中），因此可在这个类的任何地方使用。这让两个测试方法都更简单，因为它们都不用创建调查对象和答案。方法test_store_three_response()核实 self.responses 中的第一个答案——self.responses[0]—— 被妥善地存储，而方法test_store_three_response()核实self.responses中的全部三个答案都被妥善地存储。