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

上一章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。
【python3快速入门学习总结 – Python3教程】我们不需要在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_floprint("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]) # 输出: pprint('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 = -1if 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 = 1while 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+valprint("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 sumresult = 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 mathresult = 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 sysrandomList = ['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 = idef getData(self): print("{0}+{1}j".format(self.real,self.imag))c1 = ComplexNumber(2,3) # 创建一个新的ComplexNumber对象 c1.getData() # 输出: 2+3jc2 = 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中称为闭包。