Python基础知识

时间:2020-04-01
本文章向大家介绍Python基础知识,主要包括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("\nKey: " + 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("\nThe 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("\nMaking 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("\nFirst 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中的全部三个答案都被妥善地存储。

$flag 上一页 下一页