python3快速入门学习总结 – Python3教程

上一章Python教程请查看：python C语言扩展编程

Python是一种强大的编程语言，非常适合脚本和快速应用程序开发，它用于web开发(如Django和Bottle)、科学和数学计算(Orange、y、NumPy)以及桌面图形用户界面(Pygame、Panda3D)。

本系列教程向你介绍Python
3的基本概念和特性，在阅读完本教程之后，你将能够阅读和编写基本的Python程序，并可以自己深入探索Python。

本教程的目标读者是具有其他编程语言知识并希望快速开始使用Python的人。

本章涉及哪些内容？

• 在计算机上运行Python
• 介绍(变量，操作符，I/O，…)
• 数据结构(列表、字典、集合、…)
• 控制流(if, loop, break，…)
• 文件(文件处理，目录，…)
• 异常(处理、用户定义异常……)
• OOP(对象和类，继承，重载，…)
• 标准库(内置函数，列表方法，…)
• 杂项(生成器，装饰器，…)

在计算机上运行Python

学习本教程不需要在计算机上安装Python，但是我们建议你在自己的计算机上运行本教程中包含的Python程序。

Python的介绍

让我们编写我们的第一个Python程序，“Hello, World!”这是一个简单的程序，在标准输出设备(屏幕)上打印一个字符串。

print("Hello, World!");

在这个程序中，我们使用了内置的print()函数来打印Hello, world!字符串。

变量和常量

变量是用于在内存中的指定位置存储数据，这里有一个例子：

a = 5  

这里a是一个变量，我们给变量a赋值5。

我们不需要在Python中定义变量类型，你可以这样做：

a = 5
print("a =", 5)
a = "Music"
print("a =", a)

这里将整数值5分配给变量a，然后将字符串Music分配给相同的变量。

顺便说一下，5是数字字面量，“Music”是字符串字面量。

操作符

操作符是对操作数(变量和值)进行操作的特殊符号。

让我们在这一部分讨论算术和赋值运算符。

算术运算符被用来执行数学运算，如加法、减法、乘法等。

x = 14
y = 4

# 将两个操作数相加
print('x + y =', x+y) # 18

# 减法
print('x - y =', x-y) # 10

# 乘法
print('x * y =', x*y) # 56

# 除法 
print('x / y =', x/y)

# 向下除法
print('x // y =', x//y) 

# 左操作数除以右操作数的余数
print('x % y =', x%y)  
# 左操作数的右次方(x^y)
print('x ** y =', x**y) 

赋值运算符用于为变量赋值，你已经看到了=运算符的用法，让我们尝试更多的赋值运算符。

x = 5

# x += 5 ----> x = x + 5
x +=5
print(x)

# x /= 5 ----> x = x / 5
x /= 5
print(x)

其他常用的赋值操作符:-=、*=、%=、//=和**=。

获取用户输入

在Python中，可以使用input()函数获取用户的输入。例如：

inputString = input('输入一个句子:')
print('输入字符串为:', inputString)

Python的注释

在Python中有3种创建注释的方法。

# 这是一个注释

  """这是一个 
    多行
注释"""

  '''这也是一个
     多行
     注释'''

类型转换

将一种数据类型(整数、字符串、浮点数等)的值转换为另一种数据类型的过程称为类型转换，Python有两种类型的类型转换。

隐式类型转换

隐式转换不需要任何用户参与。例如：

num_int = 123  # 整数类型
num_flo = 1.23 # 浮点类型

num_new = num_int + num_flo

print("num_new:",num_new)
print("num_new的类型:",type(num_new))

这里num_new具有浮点数据类型，因为Python总是将较小的数据类型转换为较大的数据类型，以避免数据丢失。

下面是一个Python解释器不能隐式转换类型的例子。

num_int = 123     # int类型
num_str = "456"   # str类型

print(num_int+num_str)

当你运行程序时，你会得到类型错误：TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’。

但是，Python有一个解决这种情况的解决方案，称为显式转换。

显式转换

对于显式转换，将对象的数据类型转换为所需的数据类型。我们使用预定义的函数，如int()、float()、str()等来执行显式类型转换。例如：

num_int = 123  # int
num_str = "456" # str

# 显式转换为int类型
num_str = int(num_str) 

print(num_int+num_str)

Python数值类型

Python支持整数、浮点数和复数，在Python中，它们被定义为int、float和complex类。此外，布尔值：True和False是整数的子类型。

# 输出: <class int>
print(type(5))

# 输出: <class float>
print(type(5.0))

# <class complex>
c = 5 + 3j
print(type(c))

Python数据结构

Python提供了一系列复合数据类型，通常称为序列。在本节中，你将了解这些内置类型。

列表

通过将所有项(元素)放在由逗号分隔的方括号[]中来创建列表。

它可以有任意数量的项目，它们可能是不同的类型(整数、浮点数、字符串等)。

# 空列表
my_list = []
# 整数列表
my_list = [1, 2, 3]
# 混合数据类型的列表
my_list = [1, "Hello", 3.4]

还可以使用list()函数创建列表。

下面是访问列表元素的方法。

language = ["Espanol", "German", "English", "Chinese"]

# 访问第一个元素
print(language[0])

# 访问第四个元素
print(language[3])

使用索引操作符[]访问列表中的项，Index从0开始，一个有10个元素的列表的索引是从0到9。

Python还允许对其序列进行负索引，下标-1表示最后一项，下标-2表示倒数第二项，依此类推。

元组

Tuple类似于列表，只是在定义了Tuple之后不能更改它的元素，而在列表中，可以修改项。

基本上，list是可变的，而tuple是不可变的。

language = ("Espanol", "German", "English", "Chinese")
print(language)

你还可以使用tuple()函数来创建元组。

你可以以类似于列表的方式访问元组的元素。

language = ("Espanol", "German", "English", "Chinese")

print(language[1]) #输出: German
print(language[3]) #输出: Chinese
print(language[-1]) # 输出: Chinese

你不能删除元组的元素，但是，你可以使用del操作符完全删除元组本身。

language = ("Espanol", "German", "English", "Chinese")
del language

# NameError: name 'language' is not defined
print(language)

字符串

字符串是字符序列，下面是创建字符串的不同方法。

# 下面这些都是等价的
my_string = 'Hello'
print(my_string)

my_string = "Hello"
print(my_string)

my_string = '''Hello'''
print(my_string)

# 三重引号字符串可以扩展多行
my_string = """Hello, welcome to
           the world of Python"""
print(my_string)

可以使用索引(类似于列表和元组)访问字符串的各个字符。

str = 'srcmini'
print('str = ', str)

print('str[0] = ', str[0]) # 输出: p

print('str[-1] = ', str[-1]) # 输出: z

# 切割2到5个字符
print('str[1:5] = ', str[1:5]) # 输出: rogr

# 最后一个字符从6位切到2位
print('str[5:-2] = ', str[5:-2]) # 输出: am

字符串是不可变的，一旦指定了字符串，就不能更改它的元素。但是，可以将一个字符串分配给另一个字符串。另外，可以使用del操作符删除字符串。

连接可能是最常见的字符串操作，要连接字符串，可以使用+运算符，类似地，可以使用*操作符重复给定次数的字符串。

str1 = 'Hello '
str2 ='World!'

# 输出: Hello World!
print(str1 + str2)

# Hello Hello Hello
print(str1 * 3)

集合

集合是项目的无序集合，其中每个元素都是唯一的(没有重复)。

下面是如何在Python中创建集合。

# 整数集合
my_set = {1, 2, 3}
print(my_set)

# 混合类型集合
my_set = {1.0, "Hello", (1, 2, 3)}
print(my_set)

还可以使用set()函数来创建集合。

集是可变的，你可以添加、删除和删除一个集合中的元素，但是，你不能用另一个集合中的一个元素替换另一个集合中的一个元素，因为它们是无序的，并且索引没有任何意义。

让我们尝试常用的set方法：add()、update()和remove()。

my_set = {1, 2, 3}

my_set.add(4)
print(my_set) # 输出: {1, 2, 3, 4}

my_set.add(2)
print(my_set) # 输出: {1, 2, 3, 4}

my_set.update([3, 4, 5])
print(my_set) # 输出: {1, 2, 3, 4, 5}

my_set.remove(4)
print(my_set) # 输出: {1, 2, 3, 5}

让我们尝试一些常用的集合操作

A = {1, 2, 3}
B = {2, 3, 4, 5}

# 相当于A.union(B)
# 也相当于B.union(A)
print(A | B) # 输出: {1, 2, 3, 4, 5}

# 相当于A.intersection(B)
# 也相当于B.intersection(A)
print (A & B) # 输出: {2, 3}

# 差集
print (A - B) # 输出: {1}

# 对称差分
print(A ^ B)  # 输出: {1, 4, 5}

字典

Dictionary是一个无序的项集合，其他复合数据类型只有值作为元素，而字典有一个键:值对。例如：

# 空字典
my_dict = {}

# 整数键值
my_dict = {1: 'apple', 2: 'ball'}

# 混合类型的键值
my_dict = {'name': 'John', 1: [2, 4, 3]}

还可以使用dict()函数创建字典。

要从字典中访问值，可以使用key。例如：

下面介绍如何更改、添加或删除dictionary元素。

person = {'name':'Jack', 'age': 26}

# 更改为36
person['age'] = 36 
print(person) # 输出: {'name': 'Jack', 'age': 36}

# 添加键值对
person['salary'] = 4342.4
print(person) # 输出: {'name': 'Jack', 'age': 36, 'salary': 4342.4}

# 删除
del person['age']
print(person) # 输出: {'name': 'Jack', 'salary': 4342.4}

# 删除整个字典
del person

Python range()

range()返回给定的开始整数到停止整数之间的不可变的数字序列。

print(range(1, 10)) # 输出: range(1, 10)

输出是一个可迭代的，你可以将其转换为list、tuple、set等。例如

numbers = range(1, 6)

print(list(numbers)) # 输出: [1, 2, 3, 4, 5]
print(tuple(numbers)) # 输出: (1, 2, 3, 4, 5)
print(set(numbers)) # 输出: {1, 2, 3, 4, 5}

# 输出: {1: 99, 2: 99, 3: 99, 4: 99, 5: 99} 
print(dict.fromkeys(numbers, 99))

在上面的例子中，我们省略了range()的可选步骤参数，省略时，步骤默认为1，让我们尝试一些带有step参数的示例。

# 等价于: numbers = range(1, 6)
numbers1 = range(1, 6 , 1)
print(list(numbers1)) # 输出: [1, 2, 3, 4, 5]

numbers2 = range(1, 6, 2)
print(list(numbers2)) # 输出: [1, 3, 5]

numbers3 = range(5, 0, -1)
print(list(numbers3)) # 输出: [5, 4, 3, 2, 1]

Python控制流

if……else语句

if……else语句用于在不同的条件下执行不同的操作(运行不同的代码)。例如：

num = -1

if num > 0:
    print("正数")
elif num == 0:
    print("0")
else:
    print("负数")
    
# 输出: 负数

可以有零个或多个elif部分，而else部分是可选的。

大多数编程语言使用{}来指定代码块，而Python使用缩进。

代码块以缩进开始，以第一个未缩进的行结束。缩进的数量由你决定，但必须在整个块中保持一致。

通常四个空白用于缩进，并且优先于制表符。

我们再举一个例子:

if False:
  print("inside the body")
  print("also inside the body")
print("outside")

# 输出: outside

在进入下一节之前，我们建议你检查比较运算符和逻辑运算符。

while循环

与大多数编程语言一样，while循环用于在测试表达式(条件)为真时遍历代码块，下面是一个求自然数和的例子:

n = 100

# 初始化sum和计数器
sum = 0
i = 1

while i <= n:
    sum = sum + i
    i = i+1    # 更新计数器

print("sum: ", sum)

# 输出: sum: 5050

在Python中，while循环可以有可选的else块，如果while循环中的条件计算结果为False，则执行else块。但是，如果循环使用break语句终止，Python解释器将忽略else块。

for循环

在Python中，for循环用于遍历序列(列表、元组、字符串)或其他可迭代对象，遍历一个序列称为遍历。

下面是一个用于查找存储在列表中的所有数字的和的示例。

numbers = [6, 5, 3, 8, 4, 2]

sum = 0

# 遍历列表
for val in numbers:
  sum = sum+val

print("sum: ", sum) 

注意上面示例中in操作符的使用，如果在序列中找到值/变量，in操作符将返回True。

在Python中，for循环可以有可选的else块，如果for循环中使用的序列中的项耗尽，则执行else部分。但是如果循环使用break语句终止，Python解释器将忽略else块。

break语句

break语句终止包含它的循环，程序的控制立即在循环体之后流向语句，例如：

for val in "string":
    if val == "r":
        break
    print(val)

print("The end")

continue语句

continue语句用于仅针对当前迭代跳过循环内的其余代码，循环不会终止，而是继续下一个迭代，例如：

for val in "string":
    if val == "r":
        continue
    print(val)

print("The end")

pass语句

假设你有一个尚未实现的循环或函数，但希望在将来实现它，他们不可能有一个空的body主体，因此，可以使用pass语句构造一个不执行任何操作的主体。

sequence = {'p', 'a', 's', 's'}
for val in sequence:
    pass

Python函数

函数是一组执行特定任务的相关语句，使用def关键字在Python中创建函数。

def print_lines():
  print("line1.")
  print("line2.")

你必须调用函数来运行它里面的代码，方法如下:

def print_lines():
  print("line1.")
  print("line2.")

# 函数调用
print_lines()

函数可以接受参数。

def add_numbers(a, b):
  sum = a + b
  print(sum)

add_numbers(4, 5)

# 输出: 9

还可以使用return语句从函数返回值。

def add_numbers(a, b):
  sum = a + b
  return sum

result = add_numbers(4, 5)
print(result)

# 输出: 9

递归(递归函数)

调用自身的函数称为递归函数，这个过程称为递归。

每个递归函数必须有一个基本条件来停止递归，否则函数将无限地调用自己。

# 求一个数的阶乘的递归函数

def calc_factorial(x):

    if x == 1:
        return 1
    else:
        return (x * calc_factorial(x-1))

num = 6
print(num, "的阶乘： ", calc_factorial(num)) 

Lambda函数

在Python中，可以定义没有名称的函数，这些函数称为lambda或匿名函数，要创建lambda函数，使用lambda关键字。

square = lambda x: x ** 2
print(square(5))

# 输出: 25

当我们短时间内需要一个匿名函数时，我们使用lambda函数，Lambda函数与内置函数一起使用，如filter()、map()等。

模块

模块引用包含Python语句和定义的文件。

包含Python代码的文件，例如：example。称为模块，其模块名为example。

让我们创建它并将其保存为example.py。

# 模块例子
def add(a, b):
   return a + b

要使用此模块，我们使用import关键字。

# import导入模块
import example 
# 访问模块内的函数使用点.操作符
example.add(4, 5.5) 

Python有大量的标准模块可供使用，例如

import math

result = math.log2(5) # 返回以2为底的对数
print(result) # 输出: 2.321928094887362

你可以从模块中导入特定的名称，而不需要整体导入模块。这里有一个例子。

from math import pi
print("PI: ", pi)

Python文件I/O

文件操作按以下顺序进行。

• 打开一个文件
• 读或写(执行操作)
• 关闭文件

如何打开文件？

可以使用open()函数打开文件。

f = open("test.txt")    # 在当前目录打开文件
f = open("C:/Python33/README.txt")  # 指定网站路径

我们可以在打开文件时指定模式。

模式	说明
‘r’	打开一个文件进行读取（默认）
‘w’	打开一个文件进行写作。如果文件不存在，则创建新文件;如果文件存在，则截断该文件。
‘x’	打开文件进行独占创建。如果文件已经存在，则操作失败。
‘a’	打开文件末尾的附加部分，但不截断它。创建一个不存在的新文件。
‘t’	以文本模式打开(默认)
‘b’	二进制模式
‘+’	打开文件进行更新(读和写)

f = open("test.txt")      # 相当于'r' 或 'rt'
f = open("test.txt",'w')  # 写模式
f = open("img.bmp",'r+b') # 二进制读写模式

如何关闭文件？

要关闭文件，可以使用close()方法。

f = open("test.txt",encoding = 'utf-8')
# 执行文件操作
f.close()

如何写入文件？

为了在Python中写入文件，我们需要在写’w’、附加’a’或独占创建’x’模式中打开它。

with open("test.txt",'w',encoding = 'utf-8') as f:
   f.write("AAA\n")
   f.write("BBB\n\n")
   f.write("EEEE\n")

这里，我们使用with语句来打开一个文件，这可以确保在退出其中的块时关闭文件。

如何读取文件？

要读取Python中的文件，必须以读取模式打开文件。

有各种各样的方法可以达到这个目的，我们可以使用read(size)方法来读取数据的大小。

f = open("test.txt",'r',encoding = 'utf-8')
f.read(4)    # 读取前4个数据

Python目录

目录或文件夹是文件和子目录的集合，Python有os模块，它提供了许多有用的方法来处理目录和文件。

import os
os.getcwd()  // 当前工作目录
os.chdir('D:\\Hello') // 将当前目录更改为D:\Hello
os.listdir()  // 列出该路径中的所有子目录和文件
os.mkdir('test') // 创建一个新的目录测试
os.rename('test','tasty') // 将目录测试重命名为tasty
os.remove('old.txt')  // 删除old.txt文件

Python的异常处理

运行时发生的错误称为异常，例如，当我们试图打开的文件不存在FileNotFoundError时，就会出现这种情况，用一个数字除以零就会出现零分错误等等。

如果不处理异常，就会吐出一条错误消息，我们的程序就会意外地突然停止。

在Python中，可以使用try语句处理异常，当异常被捕获时，由你决定执行什么操作符。

# 导入模块sys获取异常类型
import sys

randomList = ['a', 0, 2]

for entry in randomList:
    try:
        print("entry: ", entry)
        r = 1/int(entry)
        break
    except:
        print(sys.exc_info()[0])
        print("Next entry.")
        print()
print(entry,"的倒数：",r)

要了解如何使用try语句捕获特定的异常和finally子句，请访问Python异常处理。

此外，你还可以在Python中创建用户定义的异常，为此，请访问Python自定义异常

Python的面向对象

Python中的一切都是对象，包括整数、浮点数、函数、类和None，我们不要关注为什么Python中的所有东西都是对象，为此，请访问此页面。相反，本节主要讨论如何创建自己的类和对象。

类和对象

对象只是作用于数据的数据(变量)和方法(函数)的集合，类是对象的蓝图。

如何定义一个类？

class MyClass:
   a = 10
   def func(self):
      print('Hello')  

一旦定义了一个类，就会创建一个具有相同名称的新类对象，这个类对象允许我们访问不同的属性以及实例化该类的新对象。

class MyClass:
  "This is my class"
  a = 10
  def func(self):
    print('Hello')

# 输出: 10
print(MyClass.a)

# 输出: <function 0x0000000003079bf8="" at="" myclass.func="">
print(MyClass.func)

# 输出: 'This is my class'
print(MyClass.__doc__)
</function>

你可能已经注意到了类内部函数定义中的self参数，但是，我们只是简单地将该方法称为ob.func()，没有任何参数，它仍然工作。

这是因为，每当一个对象调用它的方法时，对象本身都会作为第一个参数传递。因此ob.func()转换成MyClass.func(ob)。

创建对象

你还可以自己创建类的对象。

class MyClass:
  "This is my class"
  a = 10
  def func(self):
    print('Hello')

obj1 = MyClass()
print(obj1.a)        # 输出: 10
 
obj2 = MyClass()
print(obj1.a + 5)    # 输出: 15

Python的构造函数

在Python中，名称为_init()__的方法是一个构造函数，在对象实例化时自动调用此方法。

class ComplexNumber:
    def __init__(self,r = 0,i = 0):  # 构造函数
        self.real = r
        self.imag = i

    def getData(self):
        print("{0}+{1}j".format(self.real,self.imag))

c1 = ComplexNumber(2,3) # 创建一个新的ComplexNumber对象
c1.getData() # 输出: 2+3j

c2 = ComplexNumber() # 创建一个新的ComplexNumber对象
c2.getData() # 输出: 0+0j

Python继承

继承指的是定义一个新类，只需要对现有类进行少量或不进行修改。举个例子:

class Mammal:
  def displayMammalFeatures(self):
    print('哺乳动物是温血动物.')

让我们从这个哺乳动物类派生一个新的类Dog。

class Mammal:
  def displayMammalFeatures(self):
    print('哺乳动物是温血动物.')

class Dog(Mammal):
  def displayDogFeatures(self):
    print('狗有四条腿.')

d = Dog()
d.displayDogFeatures()
d.displayMammalFeatures()

注意，我们能够从派生类d的对象中调用基类displayMammalFeatures()的方法。

如果你感兴趣，我们还建议你查看之后的教程中的多重继承和操作符重载。

杂项和前沿主题

迭代器

Python中的Iterator只是一个可以迭代的对象。一个对象，它一次返回一个元素。

从技术上讲，Python迭代器对象必须实现两种特殊的方法，即iter__()和next__()，它们统称为迭代器协议。

如果我们可以从一个对象中获得一个迭代器，那么这个对象就称为iterable。Python中的大多数内置容器，如:列表、元组、字符串等，都是可迭代的。

iter()函数(它反过来调用了_iter__()方法)从它们返回一个迭代器。

my_list = [4, 7, 0, 3]

# 使用iter()获得迭代器
my_iter = iter(my_list)

print(next(my_iter)) # 输出: 4
print(next(my_iter)) # 输出: 7

生成器

在Python中构建迭代器有很多开销，我们必须使用_iter__()和_next__()方法来实现一个类，跟踪内部状态，在没有要返回的值时触发StopIteration等等。

这既冗长又违反直觉，生成器在这种情况下可以派上用场。

Python生成器是创建迭代器的一种简单方法。

闭包

这种将一些数据附加到代码中的技术在Python中称为闭包。

def print_msg(msg): # 外函数
    def printer():  # 内部函数
        print(msg)
    return printer  # 这有改变

another = print_msg("Hello") # 输出: Hello
another()

这里，print_msg()函数以字符串“Hello”作为参数被调用，返回的函数被绑定到另一个名称。在调用另一个()时，尽管我们已经完成了print_msg()函数的执行，但是仍然记住了该消息。

要在Python中创建闭包，必须满足以下几点。

• 我们必须有一个嵌套的函数(函数内的函数)。
• 嵌套函数必须引用封闭函数中定义的值。
• 封闭函数必须返回嵌套函数。

装饰器

Python有一个有趣的特性，称为装饰器，用于向现有代码添加功能。

这也称为元编程，因为程序的一部分试图在编译时修改程序的另一部分。

要详细了解decorator，请访问Python decorator。

来源：

https://www.srcmini02.com/2486.html