入门Python笔记(基础)

入门Python笔记(基础)

在此感谢关东升老师《看漫画学Python》，大家如有需要请购买正版书籍。
以下是学习Python所记录的笔记，以便自己学习回顾。

1. Python的特点

Python.之所以受到大家的欢迎，是因为它有很多优秀“品质”。

1. 简单、易学、免费、开源：Pythor简单、易学。我们可以自由发布其复制版本，阅读、修改其源代码，将其（部分）用于新软件中。
2. 解释型：Python是边解释边执行的，Python解释器会将源代码转换为中间字节码形式，然后将其解释为机器语言并执行。
3. 可移植：Python解释器已被移植在许多平台上，Python程序无须经过修改就可以在多个平台上运行。
4. 代码规范：Pythor所采用的强制缩进的方式，使得其代码具有极佳的可读性。
5. 面向对象：与C++和ava等相比，Python以强大而简单的方式实现了面向对象编程。
6. 胶水语言：标准版本的Python调用c语言，并可以借助c语言的接口驱动调用所有编程语言。
7. 丰富的库：Python的标准库种类繁多，可以帮助处理各种工作，我们不需要安装就可以直接使用这些库。
8. 动态类型：Python:不会检查数据类型，在声明变量时不需要指定数据类型。

2. Python安装

Python详细安装教程
Python 3.11.4

3. Python中的数据类型

Python中有6种主要的内置数据类型：数字、字符串、列表、元组、集合和字典

列表、元组、集合、字典将在 6.容器类型数据 介绍

3.1 数字类型

Python中有4种数字类型：整数类型、浮点类型、复数类型和布尔类型。

3.1.1 整数类型

Python中的整数类型为int类。

3.1.2 浮点类型

Python的浮点类型为float类。

3.1.3 复数类型

复数在数学中被表示为：a+bi,其中a被称为实部，b被称为虚部，被称为虚数单位。

3.1.4 布尔类型

Python中的布尔类型为bool类：它只有两个值：
True和False。

3.2 数字类型的相互转换

1.隐式类型的转换
2.显式类型的转换

4. 运算符

4.1 算术运算符

4.2 比较运算符

4.3 逻辑运算符

4.4 位运算符

4.5 赋值运算符

4.6 运算符优先级

5. 程序流程控制

5.1 条件结构

5.1.1 if结构

5.1.2 if-else结构

5.1.3 if-elif-else结构

5.2 循环语句

Python支持两种循环语句：while和for。

5.2.1 while语句

while 语句，在Python语言中只有while语句，没有do-while语句。

5.2.2 for语句

在Python中只有一种for语句，即for-in语句。

5.3跳转语句

跳转语句能够改变程序的执行顺序
包括break、continue和return。

5.3.1 break语句

5.3.2 continue语句

6.容器类型数据

6.1序列

6.1.1序列

序列(sequence)是一种可迭代的、元素有序的容器类型的数据。

序列的索引操作，序列中的元素是有序的，每一个元素都带有序号，这个序号叫作索引，索引有“正值索引”和“负值索引”之分

6.1.2加和乘操作

加和乘操作，加（+）和乘（x）运算符也可以用于序列中的元素操作。加（+）运算符可以将两个序列连接起来，乘（x）运算符可以将两个序列重复多次。

6.1.3 切片操作

序列的切片（Slicing）就是从序列中切分出小的子序列
切片运算符的语法形式为[start:end:step]。
其中，start是开始索引，end是结束索引，step是步长（切片时获取的元素的间隔，可以为正整数，也可以为负整

6.1.4 成员测试

成员测试运算符有两个：in和not in,
in用于测试是否包含某一个元素，not
in用于测试是否不包含某一个元素。

6.2 列表

6.2.1 列表

6.2.2 追加元素

追加元素，列表是可变的序列对象，列表可以追加元素。
1.在列表中追加单个元素时，可以使用列表的append()方法。
2.在列表中追加多个元素时，可以使用加（+)运算符或列表的extend(t)方法

6.2.3 插入元素

想向列表中插入元素时，可以使用列表的list.insert(i, x)方法，其中，i指定索引位置，x是要插入的元素。

6.2.4 替换元素

想替换列表中的元素时，将列表下标索引元素放在赋值符号（=)的左边，进行赋值即可。

6.2.5 删除元素

想在列表中删除元素时，可使用列表的list.remove(x)方法。

6.3 元组

元组(tuple)是一种不可变序列类型。

6.3.1 创建元组

创建元组时有两种方法
1.tuple(iterable)函数
2.(元素1，元素2，元素3，…)

6.3.2 元组拆包，

创建元组，并将多个数据放到元组中，这个过程被称为元组打包。

6.4 集合

集合（set)是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。

6.4.1 创建集合

可以通过以下两种方式创建列表：set(iterable)函数和{元素1, 元素2, 元素3, …}

6.4.2 修改集合

修改集合类似于修改列表，可以向其中插入和删除元素。修改可变集合有以下常用方法。

●add(elem):添加元素，如果元素已经存在，则不能添加，不会抛出错误。
●remove(elem):删除元素，如果元素不存在，则抛出错误。
●clear():清除集合。

6.5 字典

字典(dict)是可迭代的、通过键(key)来访问元素的可变的容器类型的数据。
键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。

6.5.1 创建字典

可以通过以下两种方法创建字典：dict()函数和{key1:value1, key2:value2,..., key_n:value_n}

6.5.2 修改字典

字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除。

6.5.3 访问字典视图

可以通过字典中的以下方法访问字典视图：items()；keys()；values()。

7. 字符串

7.1 字符串

7.1.1 普通字符串

普通字符串指采用单引号（’ '）或双引号（" "）括起来的字符串
常用转义符

7.1.2 原始字符串

使用原始字符串（raw string）表示，原始字符串中的特殊字符不需要被转义，按照字符串的本来样子呈现。在普通字符串前加r就是原始字符串了

7.1.3 长字符串

对于长字符串，使用三个单引号（‘’'）或三个双引号（“”"）括起来

7.2 字符串与数字的相互转换

7.2.1 将字符串转换为数字

将字符串转换为数字，将字符串转换为数字，可以使用int()和float()实现，如果成功则返回数字，否则引发异常

7.2.2 将数字转换为字符串

将数字转换字符串，可以使用str()函数，str()函数可以将很多类型数据都转换为字符串

7.3 格式化字符串

格式化字符串的函数 str.format()

7.3.1 使用占位符

要想将表达式计算结果插入字符串中，则需要用到占位符。对于占位符，使用一对大括号（{}）表示

7.4 操作字符串

7.4.1 字符串查找

字符串的find()方法用于查找子字符串…
str.find(sub[,start[,end])查找子字符串，在索引start到end之间查找子字符串sub,如果找到，则返回最左端位置的索引；了如果没有找到，则返回-1。

7.4.2 字符串替换

若想进行字符串替换，则可以使用replace()方法替换匹配的子字符串，返回值是替换之后的字符串

str.replace(old,new[,count])字符串替换 new子字符串替换old子字符串。
count参数指定了替换old子字符串的个数，counti被省略，则替换所有old子字符串。

7.4.3 字符串分割

若想进行字符串分割，则可以使用split()方法，按照子字符串来分割字符串，返回字符串列表对象。

str.split(sep=None,maxsplita=-1),使用sep子字符串分割字符串str。
maxsplit是最大分割次数，如果maxsplit被省略，则表示不限制分割次数。

8. 函数

函数具有函数名、参数和返回值。
Pyth0n中的函数很灵话：可以在模块中但是类之外定义，作用域是当前模块，我们称之为函数；也可以在别的函数中定义，我们称之为嵌套函数；还可以在类中定义，我们称之为方法。

8.1 定义函数

由于定义函数时的参数不是实际数据，会在调用函数时传递给它们实际数据…

8.2 形参与实参

由于定义函数时的参数不是实际数据，会在调用函数时传递给它们实际数据，所以我们称定义函数时的参数为形式参数，简称形参；称调用函数时传递的实际数据为实际参数，简称实参。你可以将形参理解为在函数中定义的变量。

8.2.1使用位置参数调用函数

使用位置参数调用函数，调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式。

8.2.2使用关键字参数调用函数

使用关键字参数调用函数，调用函数时可以采用“关键字=实参”的形式，其中，关键字的名称就是定义函数时形参的名称。

8.3 参数的默认值

函数重载会增加代码量，所以在Python中没有函数重载的概念，而是为函数的参数提供默认值实现的。

8.4 可变参数

Python中的函数可以定义接收不确定数量的参数，这种参数被称为可变参数。可变参数有两种，即在参数前加 * 或 **。

8.4.1 基于元组的可变参数（* 可变参数）

*可变参数在函数中被组装成一个元组。

8.4.2 基于字典的可变参数（** 可变参数）

**可变参数在函数中被组装成一个字典。

8.5 函数中变量的作用域

变量可以在模块中创建，作用域（变量的有效范围）是整个模块，被称为全局变量。变量也可以在函数中创建，在默认情况下作用域是整个函数，被称为局部变量。

8.6 函数类型

Python中的任意一个函数都有数据类型，这种数据类型是 function,被称为函数类型。

8.6.1 理解函数类型

1.一个函数可以作为另一个函数返回值使用。
2.一个函数可以作为另一个函数参数使用。
函数类型数据与其他类型数据是一样的，类型数据可以作为函数返回值使用，还可以作为函数参数使用。

8.6.2 过滤函数filter(）

过滤函数filter，在Python中定义了一些用于数据处理的函数，如filter()和map()等

8.6.3 映射函数map()

map()函数用于对容器中的元素进行映射（或变换）。

8.7 lambda函数

在Python中使用lambda关键字定义匿名函数。
lambda关键字定义的函数也被称为lambda函数。

9. 类与对象

类和对象都是面向对象中的重要概念。

9.1 面向对象

面向对象是一种编程思想，即按照真实世界的思维方式构建软件系统。

9.2 定义类

Python中的数据类型都是类，我们可以自定义类，即创建一种新的数据类型

9.3 创建对象

类相当于一个模板，依据这样的模板来创建对象，就是类的实例化，所以对象也被称为“实例”

9.4 类的成员

在类体中可以包含类的成员…

9.4.1 实例变量

实例变量就是对象个体特有的“数据”，例如狗狗的名字和年龄等

9.4.2 构造方法

类中的__init__()方法是一个非常特殊的方法，用来创建和初始化实例变量，这种方法就是“构造方法”

9.4.3 实例方法

实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。

9.4.4 类变量

类变量是属于类的变量，不属于单个对象。

9.4.5 类方法

类方法与类变量类似，属于类，不属于个体实例。在定义类方法时，它的第一个参数不是self，而是类本身。

9.5 封装性

封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。

9.5.1 私有变量

为了防止外部调用者随意存取类的内部数据（成员变量），内部数据（成员变量）会被封装为“私有变量”
私有变量，则在变量前加上双下画线(__)。

9.5.2 私有方法

私有方法与私有变量的封装是类似的，在方法前上双下画线（__）就是私有方法了。

9.5.3 使用属性

为了实现对象的封装，一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set（赋值）和get（取值）方法访问。

9.6 继承性

1.继承性也是面向对象重要的基本特性之一。在现实世界中继承关系无处不在。
2.例如猫与动物之间的关系：猫是一种特殊动物，具有动物的全部特征和行为，即数据和操作。在面向对象中动物是一般类，被称为”父类”；猫是特殊类，被称为“子类”。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。

9.6.1 Python 中的继承

在Python中声明子类继承父类，语法很简单，在定义类时在类的后面使用一对小括号指定它的父类就可以了。

9.6.2 多继承

在Python中，当子类继承多个父类时，如果在多个父类中有相同的成员方法或成员变量，则子类优先继承左边父类中的成员方法或成员变量，

9.6.3 方法重写

子类的方法会重写（Override）父类的同名方法

9.7 多态性

多态性也是面向对象重要的基本特性之一。“多态”指对象可以表现出多种形态。

1.“多态”指对象可以表现出多种形态。
2.例如，猫、狗、鸭子都属于动物，它们有“叫”和“动”等行为，但是”叫的方式不同，“动”的方式也不同。

9.7.1 继承与多态

在多个子类继承父类，并重写父类方法后，这些子类所创建的对象之间就是多态的。这些对象采用不同的方式实现父类方法。

9.7.2 鸭子类型测试与多态

Python的多态性更加灵活，支持鸭子类型测试
1.鸭子类型测试指：若看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。
2.Python支持鸭子类型测试，Python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为（方法)，它们之间就是多态的。

10. 异常处理

10.1 第一个异常 —— 除零异常

在数学中，任何整数都不能除以0，如果在计算机程序中将整数除以0，则会引发异常。

10.2 捕获异常

我们不能防止用户输入0，但在出现异常后我们能捕获并处理异常，不至于让程序发生终止并退出。亡羊补牢，为时未晚。

10.2.1 try-except 语句

异常捕获是通过try-except语句实现的

10.2.2 多个except代码块

多条语句可能会引发多种不同的异常，对每一种异常都会采用不同的处理方式。针对这种情况，我们可以在一个try后面跟多个except代码块。

10.2.3 多重异常捕获

如果多个except代码块的异常处理过程类似，则可以合并处理，就是多重异常捕获。

0.2.4 try-except语句嵌套
try-except语句可以嵌套。

10.3 使用finally代码块释放资源

有时在try-excepti语句中会占用一些资源，可以使用finally代码块。

10.4 自定义异常类

为了提高代码的可重用性，自己编写了一些Python类库，其中自己编写了一些异常类。

(Exception)继承Exception父类
def __init__()构造方法，有 message 异常错误消息。

10.5 手动引发异常

到目前为止，接触到的异常都是由于解释器引发的，也可以通过raise语句手动引发异常。

##1

11. 常用内置模块

11.1 数学计算模块 —— math

在math模块中包含数学运算相关的函数等。

11.2 日期时间模块一datetime

● datetime:包含时间和日期。
● date:只包含日期。
● time:只包含时间。
● timedelta:计算时间跨度。
● tzinfo:时区信息。

11.2.1 datetime 类

datetime类表示日期和时间等信息

datetime类的常用方法如下：
●datetime.today():返回当前的本地日期和时间。
●datetime.now(tz=None):返回指定时区的当前日期和时间，参数tz用于设置时区，如果参数tz为None或省略，则等同于today()。
●datetime.fromtimestamp(timestamp,tz=None):返回与UNlX时间戳对应的本地日期和时间。UNIX时间戳是从1970年1月1日00:00:00开始到现在为止的总秒数。

11.2.2 date类

date类的常用方法如下：
●date.today():返回当前的本地日期。
●date.fromtimestamp(timestamp):返▣与UNlX时间戳对应的本地日期。

11.2.3 time 类

表示一天中的时间信息

11.2.4 计算时间跨度类 —— timedelta

可以使用timedelta类。timedelta类用于计算datetime、date和time对象的时间间隔。

11.2.5 将日期时间与字符串相互转换

1.将日期时间对象转换为字符串时，称之为日期时间格式化。
在 Python中使用strftime()方法进行日期时间的格式化，在datetime、 date和time三个类中都有一个实例方法strftime(format)。

2.将字符串转换为日期时间对象的过程，叫作日期时间解析。
在 Python中使用datetime.strptime(date string,format)类方法进行日期时间解析。

日期和时间格式控制符

11.3 正则表达式模块—— re

正则表达式指预先定义好一个“字符串模板”，通过这个“字符串模板”可以匹配、查找和替换那些匹配“字符串模板”的字符串

11.3.1 字符串匹配

字符串匹配指验证一个字符串是否符合指定的“字符串模板”，经常被用于用户输入验证。

我们使用match(p,tet)函数进行字符串匹配，其中的参数p是正则表达式，即字符串模板，text是要验证的字符串。如果匹配成功，则返回一个Match对象(匹配对象)，否则返回None。

11.3.2 字符串查找

字符串查找指从一个字符串中查找匹配正则表达式的子字符串。

1.search(p,tet): 在tet字符串中查找匹配的内容，如果找到，则返回第1个匹配的Match对象，否则返回None。p是正则表达式。
2.findall(p,text): 在text字符串中查找所有匹配的内容，如果找到，则返回所有匹配的字符串列表；如果一个都没有匹配，则返回None。p是正则表达式。

11.3.3 字符串替换

使用正则表达式的字符串替换函数是sub()，该函数替换匹配的子字符串。

参数pattern是正则表达式：
参数repl是用于替换的新字符串；
参数string是即将被替换的旧字符串；
参数count是要替换的最大数量，默认值为零，表示不限制替换数量。

11.3.4 字符串分割

在Python中使用re模块中的split()函数进行字符串分割，该函数按照匹配的子字符串进行字符串分割，

参数pattern:是正则表达式；
参数string.是要分割的字符串；
参数maxsplit是最大分割次数；maxsplit的默认值为零，表示分割次数没有限制。

12.2 关闭文件

在打开文件后，如果不再使用该文件，则应该将其关闭，会用到close()方法。

12.2.1在with as代码块中关闭文件

with as提供了一个代码块，在as后面声明一个资源变量在with as代码块结束之后自动释放资源。

12.3 读写文本文件

● read(size=-1):从文件中读取字符串，size限制读取的字符数，size=-1指对读取字符数没有限制。
● readline(size=-1):在读取到换行符或文件尾时返回单行字符串。如果已经到文件尾则返回一个空字符串。size是限制读取的字符数，size=-1表示没有限制。
● readline():读取文件数据到一个字符串列表中，每一行数据都是列表的一个素。
● write(s):将字符串s写入文件中，并返回写入的字符数。
● writelines(lines):向文件中写入一个字符串列表。不添加行分隔符，因此通常为每行末尾都提供行分隔符。
● flus():刷新写缓冲区，在文件没有关闭的情况下将数据写入文件中。

12.4 复制文本文件

下面给出一个文本文件复制示例

12.5 读写二进制文件

● read(size=-1):从文件中读取字节，size限制读取的字节数，如果size=-1,侧读取全部字节。
● readline(size=-1):从文件中读取并返回一行。size是限制读取的字节数，如果size=-1,则没有限制。
● readlines():读取文件数据到一个字节列表中，每一行数据都是列表的一个元素。
● write(b):写入b字节，并返回写入的字节数。
● writelines(lines):向文件中写入一个字节列表。不添加行分隔符，因此通常为每一行末尾都提供行分隔符。
● flush():刷新写缓冲区，在文件没有关闭的情况下将数据写入文件中。

12.6 复制二进制文件

13. 图形用户界面

● 安装wxPython
● wxPython的程序结构
● 自定义窗口类
● 在窗口中添加控件
● 事件处理
● 布局管理
● 控件

13.1 Python中的图形用户界面开发库

Python中的图形用户界面开发库，Python中的图形用户界面开发库有很多，较为突出的有：Tkinter、PyQt和wxPython。推荐使用wxPython开发图形用户界面。

Tkinter是Python官方提供的图形用户界面开发库，用于封装TkGU工具包，跨平台。
PyQt是非Python官方提供的图形用户界面开发库，用于封装Qt工具包，跨平台。
wXPython是非Python官方提供的图形用户界面开发库，也跨平台。

13.2 安装wxPython

可以使用Python的pip指令进行安装

pip install wxPython -i https://pypi.tuna.tsinghua.edu.cn/simple

解决方法

13.3 第一个wxPython程序

图形用户界面主要是由窗口及窗口中的控件构成的。

import wx
        
#创建应用程序对象
app = wx.App()

#创建窗口对象
frm = wx.Frame(None,title="第一个wxPython程序！",size=(400,300),pos=(100,100))
#显示窗口
frm.Show ()

#进入主事件循环
app.MainLoop ()

13.4 自定义窗口类

可以自定义窗口（wx.Frame）类

模板

import wx
#自定义窗口类MyFrame
class MyFrame (wx.Frame):
    def __init__(self):
        super().__init__(None,title="第-个wxPython程序！",size=(400,300),pos=(100,100))
        #你的代码
        
#创建应用程序对象
app = wx.App()

#创建窗口对象
frm = MyFrame ()
#显示窗口
frm.Show ()

#进入主事件循环
app.MainLoop ()

13.5 在窗口中添加控件

import wx
#自定义窗口类MyFrame
class MyFrame (wx.Frame):
    def __init__(self):
        super().__init__(None,title="第-个wxPython程序！",size=(400,300),pos=(100,100))
        panel = wx.Panel(parent=self)
        statictext = wx.StaticText(parent=panel,label='Hello World', pos=(10,10))
        
#创建应用程序对象
app = wx.App()

#创建窗口对象
frm = MyFrame ()
#显示窗口
frm.Show ()

#进入主事件循环
app.MainLoop ()

13.6 事件处理

图形界面的控件要响应用户的操作，就必须添加事件处理机制。

● 事件源：事件发生的场所，就是各个控件，例如按钮事件的事件源是按钮。
● 事件：wXPython中的事件被封装为事件类wx.Event及其子类，例如按钮事件类是wx.CommandEvent，鼠标事件类是wx.MoveEvent。
● 事件处理程序：一个响应用户事件的方法。

import wx
#自定义窗口类MyFrame
class MyFrame (wx.Frame):
    def __init__(self):
        super().__init__(None,title="事件处理",size=(400,300))
        panel = wx.Panel(parent=self)
        self.statictext = wx.StaticText(parent=panel,label='请点击OK按钮', pos=(150,50))
        b = wx.Button(parent=panel,label='OK',pos=(150,90))
        self.Bind(wx.EVT_BUTTON,self.on_click,b)

    def on_click(self,event):
        self.statictext.SetLabelText('Hello,World.')
        
        
#创建应用程序对象
app = wx.App()

#创建窗口对象
frm = MyFrame ()
#显示窗口
frm.Show ()

#进入主事件循环
app.MainLoop ()

13.7 布局管理

13.7.1 盒子布局管理器

盒子布局管理器类是wx.BoxSizer，Box布局管理器是最常用的布局管理器，它可以让其中的子窗口（或控件）沿垂直或水平方向布局。

创建盒子布局管理对象

添加子窗口（或控件）到父窗口

flag对齐标志

flag边框标志

flag调整尺寸标志

13.7.2 重构事件处理示例

采用盒子布局重构该示例

import wx
#自定义窗口类MyFrame
class MyFrame (wx.Frame):
    def __init__(self):
        super().__init__(None,title="事件处理",size=(300,180))
        panel = wx.Panel(parent=self)
        self.statictext = wx.StaticText(parent=panel,label='请点击OK按钮')
        b = wx.Button(parent=panel,label='OK')
        self.Bind(wx.EVT_BUTTON,self.on_click,b)

        #创建垂直方向的盒子布局昝理器对象vbox

        vbox = wx.BoxSizer(wx.VERTICAL)
        #添加静态文本到vbox布局管理器
        vbox.Add(self.statictext,proportion=1,
            flag=wx.ALIGN_CENTER_HORIZONTAL|wx.FIXED_MINSIZE| wx.TOP,border=30)
        #添加按钮b到vbox布局管理器
        vbox.Add(b,proportion=1,flag=wx.EXPAND|wx.BOTTOM,border=10)
        #设置面板(pane1)采用vbox布局管理器个
        panel.SetSizer(vbox)


    def on_click(self,event):
        self.statictext.SetLabelText('Hello,World.')
        
        
#创建应用程序对象
app = wx.App()

#创建窗口对象
frm = MyFrame ()
#显示窗口
frm.Show ()

#进入主事件循环
app.MainLoop ()

13.7.3 盒子布局管理器嵌套示例

布局管理器还可以进行嵌套。

13.8 控件

参考此博主的博文
图形界面wxPython 库的使用

13.8.1 文本输入控件

文本输入控件（wx.TextCtrl）是可以输入文本的控件。

13.8.2 复选框和单选按钮

多选控件是复选框（wx.CheckBox），复选框（wx.CheckBox）有时也能单独使用，能提供两种状态的开和关。

13.8.3 列表

在列表控件可以进行单选或多选，列表控件类是wx.ListBox。

13.8.4 静态图片控件

静态图片控件用来显示一张图片，图片可以是wx.Python所支持的任何图片格式，静态图片控件类是wx.StaticBitmap