一、Python 基本数据类型及操作

1.1 整数（int）类型

在计算机系统总，常用的整数类型一般有4种进制表示：十进制、二进制、八进制 和 十六进制，默认情况，整数采用十进制，其它进制需要增加前置引导符号(大小写字母均可使用)。

示例：

1
2
3
4
5
6
7
8

# -*- coding: utf-8 -*-

if __name__ == '__main__':
    Int = 45
    Int0B = 0B101101
    Int0O = 0O55
    Int0X = 0X2D
    print("integerL:", Int, Int0B, Int0O, Int0X)

在Python中，整数的范围并不是固定的，而是由计算机的内存和架构决定的。Python的整数类型（int）可以动态地调整大小以适应需要的值，这意味着它可以是任意大的正数或任意小的负数，受限于可用内存。

然而，对于 32位 和 64位 操作系统（OS），Python的整数实现通常有一个实际的上限和下限，这些限制取决于系统的架构和Python解释器的实现。

对于32位系统：

• 最大整数通常是 $2^{31}$ - 1（因为需要一位来表示正负号）
• 最小整数通常是 -$2^{31}$

对于64位系统：

• 最大整数通常是 $2^{63}$ - 1
• 最小整数通常是 -$2^{63}$

这些值可以通过sys模块来检查：

1
2
3
4
5
6
7
8
9

import sys

# 最大整数
print(sys.maxsize)

# 最小整数
#（在Python中，最小整数通常是负数，但由于整数的动态大小调整，没有固定的最小值）
# 可以通过取最大整数的负数来得到一个非常接近最小值的整数
print(-sys.maxsize - 1)

注意，由于Python整数的动态性质，这些限制更多地是理论上的限制，而不是实际编程中会遇到的限制。在实际应用中，通常不需要担心整数的范围限制，除非是在处理极端大的数据集或进行特殊的数值计算。

Tips: 此外，如果需要处理超出普通整数范围的数值，Python还提供了 decimal 模块来进行高精度的十进制运算，以及 fractions 模块来进行有理数运算。这些模块提供了对数值范围和精度的更多控制。

1.2 浮点数（float）类型

Python语言要求所有浮点数必须带有小数部分，小数部分可以是0，这种设计是为了区分浮点数和整数类型。

浮点数有两种表示方法：十进制表示法 和 科学技术表示法，科学计数法使用字母e或E作为幂的符号，以10位基数，例如：2.5e-3的值为 1.5 * $10 ^{-3}$ = 0.0025； 8.5E5的值为 8.5 * $10^5$ = 850000.0

浮点数类型整数类型由计算机的不同硬件单元执行，处理方法不同，需要注意的是，尽管浮点数0.0和整数0大小相等，但它们在计算机内部表示不同。

Python浮点数的数值范围和小数精度受不同计算机系统的限制，sys.float_info详细列出了Python解释器所运行系统的浮点数各项参数，例如

1
2
3

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

上述输出给出：

• 浮点数类型所能表示的最大值(max)、最小值(min)；
• 科学计数法表示下最大值的幂(max_10_exp)、 最小值的幂(min_10_exp)；
• 基数(radix) 为2时最大值的幂(max_exp)、 最小值的幂(min_exp)；
• 科学计数法表示中系数a的最大精度(mant_dig)；
• 计算机所能分辨的两个相邻浮点数的最小差值(epsilon)；
• 能准确计算的浮点数最大个数(dig)。

浮点数类型直接表示或科学计数法表示中的系数最长可输出16个数字，浮点数运算结果中最长可输出17个数字，然而，根据sys.float_info 结果，计算机只能够提供15个数字(dig) 的准确性，最后一位 由计算机根据二进制计算结果确定，存在误差，例如:

1
2
3
4

>>> 3.1415926535897924
3.1415926535897922
>>> 12345678987654.321
12345678987654.32

简单地说，浮点数类型的取值范围在[2-1023, 21023], 即[-2.225x10308, 1.797*10308]之间，运算精度为 2.220x10-16,即浮点数运算误差仅为 0.000 000 000 000 0002。对于高精度科学计算外的绝大部分运算来说，浮点数类型足够“可靠”，一般认为浮点数类型没有范围限制，运算结果准确。

Tips: 复数类型

• 复数可以看做是二元有序实数对（a,b）,表示为a+bj,其中a是实数部分，b是虚数部分。Python语言中，复数的虚部通过后缀“J”或“j”来表示，例如：3+4j
• 复数类型中实部和虚部的数值都是浮点数类型。对于复数z，可以用z.real和z.imag分别获取它的实数部分和虚数部分，例如：

1 2 3 4 5

# 实数 >>> (3 + 4j).real 3.0 >>> (3 + 4j).imag 4.0

1.3 字符串（string）类型

字符串类型 用来存储和处理文本信息；字符串是用单引号、双引号或三引号括起来的一个、多个或多行字符；其中，单引号和双引号都可以表示单行字符串，两者作用相同。使用单引号时，双引号可以作为字符串的一部分;使用双引号时，单引号可以作为字符串的部分。三引号可以表示单行或者多行字符串。

字符串是字符的序列，可以按照单个字符或字符片段进行索引。字符串包括两种序号体系：正向递增序号和反向递减序号；

Python字符串提供区间访问方式，采用 [N:M:T] 格式，表示从 N 到 M（不包含M）的子字符串，正向递增序列和反向递减序列可混合使用；T表示步长。举例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

192:Python mac$ cat strings.py 
# -*- coding: utf-8 -*-
import sys

if __name__ == '__main__':
    string = "Hello world!"     # 共有12个字符
    print(string[0:4])          # 打印前四个字符
    print(string[2:4])          # 打印第三四个字符
    print(string[0:-1])         # 打印除去最后一个字符的字符串
    print(string[:-1])          # 打印除去最后一个字符的字符串
    print(string[-1])           # 打印最后一个字符
    print(string[:])            # 打印全部字符
    print(string[::2])          # 切片打印，步长为2
192:Python mac$ python3 strings.py 
Hell
ll
Hello world
Hello world
!
Hello world!
Hlowrd
192:Python mac$ 

• 转义字符 和 特殊的格式化控制字符

Python 中的字符串以 Unicode编码 存储，因此，字符串的英文字符和中文字符都算作一个字符。反斜杠字符（\）是一个特殊字符，在字符含义中表示转义，即该字符与后面相邻的一个字符共同组成了新的含义。例如：' 表示单引号，" 表示双引号

1.4 数据类型的操作

• 内置的数值运算操作符

Python提供了9个基本的数值运算操作符，不需要引用第三方库。

操作符运算结果可能改变数字类型，基本规则如下：

1. 整数之间运算，如果数学意义上的结果是小数，结果是浮点数。
2. 整数之间运算，如果数学意义上的结果是整数，结果是整数。
3. 整数和浮点数混合运算，输出结果是浮点数。
4. 整数或浮点数与复数运算，输出结果是复数。

所有二元数学操作符(+，-，x，/，//，%，** )都有与之对应的增强赋值操作符(+=、 -=、*=、/=、//=、%=. **=)。如果用op表示这些二元数学操作符，则下面两个赋值操作等价，注意，op和二元操作符之间没有空格:

1

x op = y 等价于 x = x op y

增强赋值操作符获得的结果写入变量x中，简化了代码表达，例如:

1

x += 3 相当于 x = x +3

内置的数值运算函数:

Tips：abs()可以计算复数的绝对值，例如： abs(-3+4j)的值为5.0

内置的数字类型转换函数

数值运算操作符可以隐式地转换输出结果的数字类型，例如，两个整数采用运算符“/”的除法将可能输出浮点数结果。此外，通过内置的数字类型转换函数可以显式地在数字类型之间进行转换;

浮点数类型转换为整数类型时，小数部分会被舍弃(不使用四舍五入),复数不能直接转换为其他数字类型，可以通过real和.imag将复数的实部或虚部分别转换，例如:

• 基本字符串操作符

  操作符	描述
  x+y	连接两个字符串x和y
  strn 或 nstr	复制n次字符串str, 如： 3*‘abc’、“eF”*5
  x in s	如果 x 是 s的子串，返回Ture,否则返回False
  str[i]	索引，返回第i个字符
  str[N:M]	切片，返回索引第N到第M的子串，其中不包括M

内置的字符串处理函数

format()函数的功能和用法

Python中的format()函数是一个非常强大的字符串格式化工具，它允许你以灵活的方式插入和格式化数据到字符串中。

1. 基本语法：

使用大括号 {} 在字符串中标记出需要插入数据的位置。然后，通过调用字符串的 format() 方法来替换这些占位符。format()可以传入多个参数，它们会按照顺序填充到字符串中的占位符 {} 的位置。

2. 使用方法：

通过在字符串中放置大括号 {} 来定义占位符，然后在 format() 方法中传入相应的参数。例如: "Hello, {}!".format("World") 会输出 “Hello, World!"。

可以通过在 占位符 {} 添加索引或键名来引用参数，例如: "Name: {name}, Age: {age}".format(age=25, name="Alice")。

3. 格式化选项：

在占位符内部，可以使用格式说明符来控制数据的显示方式。例如，可以通过 : 后跟格式说明符来指定对齐方式、填充字符、宽度、精度等。

常用的格式说明符包括对齐方式（<左对齐，>右对齐，^居中对齐），填充字符，宽度，精度等。例如，”{:<10}".format(“Hello”)会输出一个左对齐的字符串，总宽度为10个字符。 还可以使用类型转换来确保数据以特定的类型显示，如浮点数使用f表示，整数使用d表示等。

二、Python内置组合数据类型

2.1 Python内置组合数据类型简介

Python 中内置的组合类型分三大类，分别为：

• 序列类型 包括 字符串（str）、元组（tuple）和 列表（list）
• 集合类型 集合（set）
• 映射类型 字典（map）

2.2 序列类型及操作

序列类型包括 字符串（str）、元组（tuple） 和 列表（list），是一维元素向量，元素类型可以相同、也可以不同；类似数学元素序列： s0, s1, … , s（n-1）；元素间由序号引导，通过下标访问序列的特定元素。

序列类型的通用操作符和函数：

元组类型及操作：

• 元组是一种序列类型，一旦创建就不能被修改；
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔；
• 可以使用或不使用小括号；
• 元组中各元素类型可以不同，无长度限制；
• 元组继承了序列类型的全部通用操作。

列表类型及操作：

• 列表是一种序列类型，创建后可以随意被修改；
• 使用方括号 [] 或 list() 创建，元素间用逗号 , 分隔；
• 列表中各元素类型可以不同，无长度限制；
• 元组继承了序列类型的全部通用操作；
• 列表类型特有操作函数及方法：

  函数或方法	功能描述
  ls[i] = x	替换列表ls中第 i个 元素值为 x
  ls[i:j] = lt	用列表 lt 替换 列表 ls 中第 i 到 j（不包含j）个元素
  ls[i:j:k] = lt	用列表 lt 替换 列表 ls 中第 i 到 j（不包含j）个一 k 为步长的元素
  del ls[i:j:k]	删除列表ls 中第 i 到 j（不包含j）个一 k 为步长的元素
  ls += lt 或 ls.extend(lt)	将列表lt中的元素添加到列表ls 中
  ls *= n	更新列表ls，其元素重复n次
  ls.append(x)	在列表ls 最后的位置追加一个元素x
  ls.clear()	删除列表ls中的所有元素
  ls.copy()	复制ls 列表，操作将生成一个新的列表，新列表 与 ls 相同（元素个数相同，相同位置的值相同）
  ls.insert(i, x)	在列表ls 的第 i 个位置添加元素x
  ls.pop(i)	将列表ls中第i个元素取出 并从列表中删除
  ls.remove(x)	删除列表中第一个出现的x元素
  ls.reverse()	将列表中的元素反转

2.3 集合（set）类型及操作

集合（set）类型与数学中的集合概念一致，集合中的元素之间无序，每个元素唯一，不存在相同元素，集合中的元素值不可更改，不能是可变数据类;

集合用大括号 {} 表示，元素间用逗号分隔；建立集合类型用 {} 或 set()；建立空集合类型，必须使用 set()；

示例：

1
2
3
4
5
6
7

setA = {"Climb",5201314,("python",123)}
SetB = set("Climb,520,Climb")
NulC = set()
print(setA)
print(setB)
print(NulC)
type(NulC)

集合类型操作符

2.4 字典(map)类型及操作

映射是一种键(索引)和值(数据)的对应，键是数据索引的扩展；

1
2

  内部颜色：蓝色
  外部颜色：红色

字典类型是“映射”的体现，字典是键值对的集合，键值对之间无序，字典采用大括号{} 或 dict() 创建，键值对用冒号 : 表示 {<键1>:<值1>, <键2>:<值2>,··· , <键n>:<值n>}

创建 空 字典 可以使用 {} 或 dict()。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

p1 = {"name":"Macs", "age": 19, "city":"昆明"}
print(p1)
name = p1["name"]
p1["age"] = 18

p2 = dict(name='Alice', age=25, city='New York')

# 使用列表/元组创建字典
# dict()函数还可以使用列表/元组来创建字典对象。传入一个列表/元组，其中每个元素都是包含键和值的列表/元组。
items = [('apple', 1), ('banana', 2)]
fruits = dict(items)

# 使用zip创建字典
# 另一种常见的用法是使用 zip函数 和 dict()函数一起创建字典。zip函数可以将两个序列组合在一起，然后通过dict()函数将其转换为字典。
keys = ['name', 'age']
values = ['Alice', 25]
person = dict(zip(keys, values))

字典类型的函数及方法:

三、程序的控制结构

3.1 程序基本结构

程序三种基本结构：顺序结构、分支结构 和 循环结构。

• 顺序结构：是程序按照线性顺序依次执行的一种运行方式；

• 分支结构：是程序根据条件判断结果而选择不同的执行路径的一种运行方式；分支结构又分为 单分支结构、二分支结构 和 多分支结构。

  • 单分支结构（if 语句） 语法格式如下：

  1 2 3 4 5 6 7 8

  if <条件>: <语句块1> <其它语句> # 语句块是if条件满足后执行的一个或多个语句序列，语句块中语句通过与if所在行形成缩进表达包含关系。 # if 语句首先评估条件的结果值，如果结果为True，则执行语句块中的语句序列，然后控制转向程序的下一条语句。 # 如果结果为False,语句块中的语句会被跳过。

  • 二分支结构（if—else 语句） 语法格式如下：

  1 2 3 4 5 6 7 8

  if <条件>: <语句块1> else: <语句块2> # 语句块1是在if条件满足后执行的一个或多个语句序列， # 语句块2是if条件不满足后执行的语句序列。 # 二分支语句用于区分条件的两种可能，即True或者False,分别形成执行路径；

  • 多分支结构(if—elif—else) 语法格式如下：

  1 2 3 4 5 6 7 8 9 10

  if <条件1>: <语句块1> elif <条件2>: <语句块2> ··· else: <语句块N> # 多分支结构是二分支结构的扩展，这种形式通常用于设置同一个判断条件的多条执行路径。 # Python依次评估寻找第一个结果为 True的条件,执行该条件下的语句块，结束后跳过整个if-elif-else 结构，执行后面的语句。 # 如果没有任何条件成立，else 下面的语句块将被执行。else 子句是可选的。

• 循环结构：是根据条件判断结果向后反复执行的一种运行方式。

  • 遍历循环（即有限循环）：for语句

  之所以称为“遍历循环”，是因为for语句的循环执行次数是根据遍历结构中元素个数确定的。遍历循环可以理解为从遍历结构中逐一提取元素， 放在循环变量中，对于所提取的每个元素执行一次语句块。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  # 遍历结构可以是字符串、文件、组合数据类型或range( )函数等，例如 for <循环变量> in <遍历结构>: <语句块2> # 循环N次 for i in range(N): <语句块> # 遍历文件 fi 的每一行 for line in fi: <语句块> # 遍历字符s for c in s: <语句块> # 遍历列表ls for item in ls: <语句块>

  • 无限循环（即条件循环）: while语句

  无限循环一直保持循环操作直到循环条件不满足才结束，不需要提前确定循环次数

  1 2	while <条件>: <语句块>

  • 循环保留字：break和continue

    break用来跳出最内层for或while循环，脱离该循环后程序从循环代码后继续执行；

    continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

3.2 程序的异常处理

• 异常处理：try—except

Python异常信息中最重要的部分是异常类型，它表明了异常的原因，也是程序处理异常的依据。Python使用try—except语句实现异常处理，其基本语法格式如下：

1
2
3
4

try:
  <语句块1>
except <异常类型>:
  <语句块2>

异常处理实例程序:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

try:
    intV = 10
    print(intV ** 2)

    strV = "abc"
    print(strV ** 2)
except TypeError:
    print("参数错误")

# 输出：
# 100
# 参数错误

• 异常的高级用法，try—except语句可以支持多个except语句，语法格式如下：

1
2
3
4
5
6
7
8
9

try:
  <语句块1>
except <异常类型1>:
  <语句块2>
···
except <异常类型N>:
  <语句块N+1>
except:
  <语句块N+2>

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

try:
    intV = 10
    print(intV ** 2)

    strV = "abc"
    print(strV ** 2)
except NameError:
    print("Name错误")
except ValueError:
    print("值错误")
except :
    print("未知/其它错误")

# 输出：
# 100
# 未知/其它错误

Python能识别多种异常类型，但不能编写程序时过度依赖try-except这种异常处理机制。try-except 异常一般只用来检测极少发生的情况，例如，用户输入的合规性或文件打开是否成功等。对于上面实例中索引字符串超过范围的情况应该尽量在程序中采用if语句直接判断，而避免通过异常处理来应对这种可能发生的错误”。

对于面向商业应用的软件产品，稳定性和可靠性是最重要的衡量指标之–。即使这类软件产品也不会滥用try-except类型语句。因为采用try-except语句会影响代码的可读性，增加代码维护难度，因此，- 般只在关键地方采用try- except类型语句处理可能发生的异常。

四、函数和代码复用

4.1 函数的定义

函数（function） 是一段具有特定功能的、可重用的程序语句组（块），用 函数名 来表示并通过函数名进行功能调用。函数也可以看作是一段具有名字的子程序代码块，可以在需要的地方调用执行，不需要在每个执行的地方重复编写这些语句。每次使用函数可以提供不同的参数作为输入，以实现对不同数据的处理；函数执行后，还可以反馈相应的处理结果。

函数能够完成特定功能，对函数的使用不需要了解函数内部实现原理，只要了解函数的输入输出方式即可。严格地说，函数是一种功能抽象。

有些函数是用户自己编写的，称为自定义函数；Python 安装包也自带了一些函数和方法，包括Python内置的函数，如abs()、eval()等；Python标准库中的函数，如math库中的 sqrt()等。

使用函数主要有两个目的: 降低编程难度和代码重用。函数是一种功能抽象，利用它可以将-一个复杂的大问题分解成一系列简单的小问题，然后将小问题继续划分成更小的问题，当问题细化到足够简单时，就可以分而治之，为每个小问题编写程序，并通过函数封装，当各个小问题都解决了，大问题也就迎刃而解。这是一种自顶向下的程序设计思想。函数可以在一个程序中的多个位置使用，也可以用于多个程序，当需要修改代码时，只需要在函数中修改一次，所有调用位置的功能都更新了，这种代码重用降低了代码行数和代码维护难度。

Python 中使用 def 保留字定义一个函数，语法格式如下：

1
2
3

def <函数名>（<参数列表>）：
    <函数体>
    return <返回值列表>

• 函数名可以是任何有效的Python标识符；
• 参数列表是调用该函数时传递给它的值，可以有零个、一个或多个，当传递多个参数时各参数由逗号分隔，当没有参数时也要保留圆括号。函数定义中参数列表里面的参数是形式参数，简称为“形参”。
• 函数体是函数每次被调用时执行的代码，由一行或多行语句组成。
• 当需要返回值时，使用保留字return 和返回值列表，否则函数可以没有return 语句，在函数体结束位置将控制权返回给调用者。

函数调用和执行的一般形式： <函数名>(<参数列表>)

函数定义及调用举例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#. 
def happy():
	print("Happy birthday to you!")

def happyN(name):
	happy()
	happy()
	print("Happy birthday, dear {}!".format(name))
	happy()

happyN("Linda")
print()     #换行作用
happyN("Liming")

程序调用一个函数需要执行以下4个步骤:

• 调用程序在调用处暂停执行。
• 在调用时将实参复制给函数的形参。
• 执行函数体语句。
• 函数调用结束给出返回值，程序回到调用前的暂停处继续执行。

Tips:

• Python内置函数: https://docs.python.org/zh-cn/3.11/library/functions.html
• Python 标准库: https://docs.python.org/zh-cn/3.11/library/index.html

4.2 函数库调用方式

• 第一种引用函数库方法

1
2
3

import <库名>
# 程序课调用库中所有函数，使用库中函数格式如下：
<库名>.<函数名>（<函数参数>）

• 第二种引用函数库方法

1
2
3
4

from <库名> import <函数名1，函数名2，函数名3···>
from <库名> import * “此处*为通配符，表示所有函数”
# 调用该库的函数时不再需要使用库名，直接使用如下格式
<函数名>(函数参数)