python-基于python程序设计基础第二版_ython 程序设计基础第二版 csdn-优快云博客

本文链接：https://blog.youkuaiyun.com/combeginner/article/details/116903685

持续不定期更新，以下内容主要供学习使用

文章目录

*持续不定期更新，以下内容主要供学习使用*
一、基本规则
二、数值类型
三、字符串（str）类型
四、变量类型转换（内置函数）
五、基本运算和表达式
六、基本流程控制
七、组合数据类型
八、文件处理
- 8.1 文件的打开：open() 函数
- 8.2 基于文件的数据分析
九、函数

一、基本规则

1. 基本词法单位

基本词法单位为：常量、变量、关键字、运算符、表达式、函数、语句、类等。

2. 基本规则

2.1 python区分大小写;
2.2 python通过缩进来区分代码块;

python没有采用话括号或begin-end等分隔代码块。错误的缩进可能导致代码含义完全不同。
建议使用4个空格表示代码缩进，不推荐其他数量空格及制表符的方式表示缩进。

2.3 python每条语句单独一行，允许行尾加分号，但非常不建议;

3 . 标识符的规则

· 由任意多个的字母、数字、下划线、汉字组成
· 开头不能是数字
· 不能与关键字重名

4 . print（）输出函数

# 1. 一般格式为： 
print(<输出值1>,<输出值2>,***，<输出值n>,sep=' ',end='\n')
# 1. 可将多个输出值转化为字符串并且输出。
# 2. 这些值以sep分割，默认为空格符
# 3. 所有输出值得最后以end结束，默认为换行符‘\n’。

5 . input（）输入函数

# 1. 一般格式为： 
x = input(<提示字符串>)
# 1. 将用户输入的内容（不含最后回车符）以字符串的形式保存在变量x中。
# 2. 需要将输入的字符串转为其他类型，需要调用对应的转换函数。

二、数值类型

内置函数 type(object) 可以返回 object 的数据类型。
内置函数 isinstance(obj,class) 可以判断测试对象obj是否为指定的class类型。
内置函数 id(object) 可以确切的知道变量引用的内存地址。
数值类型是不可变对象。所谓不可变，是指不能在原地修改对象的内容。

>>> type(1), type(1.0),type('1')
(<class 'int'>, <class 'float'>, <class 'str'>)
>>> isinstance(1,float),isinstance(1.0,str)
(False, False)
>>> id(1),id(1.0),id(1.00000)
(140725575288496, 2335651847280, 2335651847280)
>>> id(0),id(0.0),id(0.00000)	# 仅供了解，0与0.00类型不一致，id也不一致。
								# 0.00与0.00000类型一致，值大小也一致，id也一致
(140725575288464, 2335651847280, 2335651847280)
>>> id(-0),id(-0.0),id(-0.00000)# 仅供了解，0与-0类型一致，值大小也一致，id也一致
>								# 【仅供了解，0.0与-0.0类型一致，值大小也一致，id不一致】
(140725575288464, 2335621716560, 2335621716560)

2. 1 整数（int）

定义：不带小数部分的数值
python中整数的特性：没有长度限制，可以书写和计算几百位的大整数（9位就是亿单位的计算了）
python中整数书写有四种数制：十进制(无前置)、二进制、八进制、十六进制。
0b / 0B 二进制，前一位为数值0，后一位为字母B,大小写都可以。
0o / 0O 八进制，前一位为数值0，后一位为字母O,大小写都可以。
0x / 0X 十六进制，前一位为数值0，后一位为字母X,大小写都可以。


>>> X=0B1010100
>>> X
84
>>> X=0o7654123
>>> X
2054227
>>> X=0xFAB321
>>> X
16429857
>>> X=0xbbc25
>>> X
769061

2. 2 浮点数（float）

定义：带小数部分的数值（2.00 也是小数）
python中浮点数的特性：存在上限和下限，超过上限或下限范围会导致溢出错误
python中浮点数的要求：只能以十进制方式表达。
科学计数法的值为浮点型。 e/E 前面表示指数，e/E 表示以10为底，e/E 后面表示10的幂数。

>>> r=1e10
>>> type(r)
<class 'float'>

计算机不一定能精确地表示程序中书写或计算的实数，有两个原因：

存储空间有限不能精确存储无限小数，会产生误差
>>> 2/3
>>>0.6666666666666666
>>> 1-2/3
>>>0.33333333333333337
计算机内部为二进制表示，但不是所有的十进制实数都可以用二进制精确表示，导致计算结果的二进制被截断，产生的精度误差称为截断误差
>>> s=2.3+5.6
>>> s
>>> 7.8999999999999995

2. 3 布尔值（bool）

布尔值就是逻辑值，只有 True 和 False 两种。
python 3.x中将 True 和 False 定义为关键字。
他们的值实质上仍然是 1（True）和 0 （False）。并且可以与数值类型的值进行算数运算。
数值0和空字符串转换的布尔型的值为Flase，相反其他场景就为True。

2. 3 复数（complex）

复数是python中内置的数据类型，使用 1j 表述 -1 的平方根。
复数对象有两个属性，用于查看实部（real）和虚部（imag）。

>>> (3+4j)*(3-4j)
(25+0j)
>>> (3-4j).real
3.0
>>> (3-4j).imag
-4.0
>>> 
>>> type((3-4j).real)
<class 'float'>
>>> type((3-4j).imag)
<class 'float'>

三、字符串（str）类型

3. 1 字符串规则

字符串是由字符组成的序列。
字符串是不可变对象。所谓不可变，是指不能在原地修改对象的内容。

3. 2 字符串界定符

字符串界定符用来区分字符串和其他词法单位，有以下三种形式

单引号 ’
双引号 ” (是一个字符，不是两个单引号)
三引号’’’/ ”””(是三个字符，可以是3个单引号或者3个双引号)

单引号中可以使用双引号，双引号中也可以使用单引号，这样就可以不使用转义字符。
单引号中使用单引号，双引号中使用双引号，这样必须使用转义字符。

s='ddd"ss"fdfsd'
print(s)  # 输出:  ddd"ss"fdfsd

s="ddd'ss'fdfsd"
print(s)  # 输出:  ddd"ss"fdfsd

3. 3 转义符和原始字符串

转义符是一些特殊的字符。python 用反斜杆（\）来转义字符，以便表示那些特殊字符。

转义字符	说明
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。
\\	反斜线
\’	单引号
\"	双引号
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\f	换页
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\v	纵向制表符

s=';klklkk\
fsdfsfsfds'
print(s)  # 输出:  ;klklkkfsdfsfsfds

s='aassa\\dfsd\'fs\'e"we"wwr'  
print(s)  # 输出:  aassa\dfsd'fs'e"we"wwr

print('a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr')
    # 输出：672345  890ssa\dfsd'fs'e"we"w
# wr

原始字符串：使用原字符 r/R 使字符串的转义字符不起作用。

注意1：最后的字符不能是基数个的反斜杆（\），否则报错
注意2：若最后是0个或以上偶数个的反斜杆（\），是可以的

>>> print(r'a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr\\\\')
>>> a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr\\\\

>>> print(r'a12345\r67\t890a\bssa\\dfsd\'fs\'e"we"w\nwr\\\')
SyntaxError: EOL while scanning string literal

3. 4 内置的对字符串中字符的函数操作

1. 字符串大小写转换

序号	函数名	功能
1	str.upper()	将字符串中的所有字符转换为大写
2	str.lower()	将字符串中的所有字符转换为小写
3	str.swapcase()	字符串中的大写字符转换为小写，小写字符转换为大写
4	str.capitalize()	字符串的第一个字符转换为大写，其余字符转换为小写
5	str.title()	字符串中每个单词的首字母转换为大写，其余字符转换为小写

s = "Hello, World!"
print(s.upper())  # 输出：HELLO, WORLD!  全部大写
print(s.lower())  # 输出：hello, world!  全部小写
print(s.swapcase())  # 输出：hELLO, wORLD!  将字符串中大写转为小写，小写转为大写

s = "hello, woRld!"
print(s.capitalize())  # 输出：Hello, world!  将字符串的第一个字符转换为大写，其余字符转换为小写
print(s.title())  # 输出：Hello, World!  将字符串中每个单词的首字母转换为大写，其余字符转换为小写

2. 字符串查找和替换

序号	函数名	功能	用法
1	str.find(sub[, start[, end]])	返回子字符串sub在字符串中的起始索引值，如果未找到则返回 -1	区间为左闭右开[start，end)，end省略时则到末尾
2	str.rfind(sub)	返回子字符串sub在字符串中的最后索引值，如果未找到则返回 -1
3	str.index(sub[, start[, end]])	与 find() 相同，仅未找到子字符串时会报错抛出 ValueError	建议使用find()，不会报错
4	str.replace(old, new[, count])	将字符串中的 old 子字符串替换为 new 子字符串， count 指定替换的次数（可选）

s = "Hello, World!"
print(s.find("World"))  # 输出：7    是索引值，从0开始到末尾
print(s.find("Python"))  # 输出：-1  表示没有找到
print(s.find("o",4,9))  # 输出：4    左闭，从4开始且返回第一个符合索引
print(s.find("o",5,9))  # 输出：8    从5开始，区间[5,9)
print(s.find("o",5,8))  # 输出：-1   不包括8
print(s.find("o",8))  # 输出：8      从8开始
print(s.find("o",9))  # 输出：-1     
print(s.rfind("o"))  # 输出：8     找到最后一个“o”在索引值8  

print(s.index("World"))  # 输出：7    是索引值，从0开始
print(s.index("o",4,9))  # 输出：4    左闭，从4开始且返回第一个符合索引
print(s.index("o",5,9))  # 输出：8    从5开始，到8结束
print(s.index("o",8))  	 # 输出：8    从8开始
print(s.index("Python"))  # 会报错，并抛出 ValueError: substring not found

print(s.replace("World", "Python"))  # 输出：Hello, Python!
print(s.replace("WorlD", "Python"))  # 输出：Hello, World!  大小写敏感，不匹配，保持不变
print(s.replace("l", "v"))  # 输出：Hevvo, Worvd!   全部改变
print(s.replace("l", "v", 1))  # 输出：Hevlo, World!    仅改变第一个
print(s.replace("l", "v", 2))  # 输出：Hevvo, World!    仅改变第一、二个
print(s.replace("l", "v", -1))  # 输出：Hevvo, Worvd!    全部改变

3. 字符串分割、转为字符串

序号	函数名	功能	用法
1	str.split(sep=None, maxsplit=-1)	根据分隔符 sep 将字符串分割为多个子字符串，返回一个列表。 maxsplit 指定最大分割次数（可选）	s.split() 默认按空白字符分割
2	str.rsplit(sep=None, maxsplit=-1)	与 split() 类似，但分割方向是从右向左
3	“分隔符”.join(iterable)	将可迭代对象（如列表、元组）中的元素连接成一个字符串，元素之间用指定的分隔符连接

s = "Hello,World! Welcome to Python."
print(s.split())  # 输出：['Hello,World!', 'Welcome', 'to', 'Python.']  默认按空白字符分割  
print(s.split(","))  # 输出： ['Hello', 'World! Welcome to Python.']  按指定分隔符分割
print(s.split("e",2))  # 按指定分隔符"e"分割2次   ['H', 'llo,World! W', 'lcome to Python.']
print(s.rsplit("e",2))  # 按指定分隔符"e"分割2次  ['Hello,World! W', 'lcom', ' to Python.']

lst = ["Hello", "World", "Python"]
s="， ".join(lst)
print(s)  # 输出：Hello， World， Python  一个字符串

4. 字符串格式化

序号	函数名	功能	用法
1	str.format(nane1, nane2…)	使用占位符 {} 和 .format() 方法进行字符串格式化	.format(name1, name2) 与前面字符串有无空格均可以
2	f-string（Python 3.6+）	使用 f 前缀和大括号 {} 进行字符串格式化	f与后面字符串不允许有空格

name = "Bob"
age = 25
print("My name is {} and I am {} years old." .format(name, age))  
# 输出：My name is Bob and I am 25 years old.

print(f"My name is {name} and I am {age} years old.")  
# 输出：My name is Bob and I am 25 years old.

5. 字符串检查

序号	函数名	功能
1	str.isdigit()	检查字符串是否只包含数字
2	str.isalpha()	检查字符串是否只包含字母
3	str.isalnum()	检查字符串是否只包含字母和数字
4	str.isspace()	检查字符串是否只包含空白字符
5	str.startswith(prefix[, start[, end]])	检查字符串是否以指定的前缀开头
6	str.endswith(suffix[, start[, end]])	检查字符串是否以指定的后缀结尾

s1 = "12345"
s2 = "123.45"
print(s1.isdigit())  # 输出：True  检查是否只含有数字
print(s2.isdigit())  # 输出：False  因为存在小数点

s = "Hello"
print(s.isalpha())  # 输出：True  检查是否只含有字母
s = "Hello10023"
print(s.isalnum())  # 输出：True  检查是否只含有字母和数字
s = "       "
print(s.isspace())  # 输出：True    检查是否只含有空白字符
s = "Hello, World!"
print(s.startswith("Hel"))  # 输出：True    检查字符串是否以"Hello"开始
print(s.endswith("rld!"))  # 输出：True  检查字符串是否以"World!"结尾

6. 字符串对齐和填充

序号	函数名	功能
1	str.center(width[, fillchar])	将字符串居中对齐，并用指定字符（默认为空格）填充到指定宽度
2	str.ljust(width[, fillchar])	将字符串左对齐，并用指定字符填充到指定宽度
3	str.rjust(width[, fillchar])	将字符串右对齐，并用指定字符填充到指定宽度
4	str.zfill(width)	将字符串左端用零填充到指定宽度

s = "Python"
print(s.center(9, '*'))  # 输出：**Python*   将居中对齐
print(s.center(10, '*'))  # 输出：**Python** 
print(s.center(2, '*'))  # 输出：Python      小于长度保留Python

print(s.ljust(10, '-'))  # 输出：Python----  将左对齐，并用指定字符填充到指定宽度
print(s.ljust(2, '-'))  # 输出：Python       小于长度保留Python

print(s.rjust(10, '?'))  # 输出：????Python  将右对齐，并用指定字符填充到指定宽度
print(s.rjust(3, '?'))  # 输出：Python       小于长度保留Python

print(s.zfill(10))  # 输出：0000Python   将左端用零填充到指定宽度

7. 字符串去除空白
空白字符：如空格、制表符、换行符等

序号	函数名	功能	用法
1	str.strip([chars])	移除字符串两端的空白字符或指定字符	对两边都处理
2	str.lstrip([chars])	移除字符串左侧的空白字符或指定字符	仅对左侧处理
3	str.rstrip([chars])	移除字符串右侧的空白字符或指定字符	仅对右侧处理

s = "   Hello, World!   "
print(s.strip())  # 输出："Hello, World!"    若不指定则默认仅去除两端的空白

s = "   d!Hello, World!   "
print(s.strip("d! "))  # 输出："Hello, Worl"
print(s.strip(" !d"))  # 输出："Hello, Worl"
print(s.strip("H!d l"))  # 输出："ello, Wor"
# 将指定字符串按照字符，一一进行比对去除，与顺序无关
print(s.strip("d!"))  # 输出："   d!Hello, World!   "  保持不变，因两端与指定不匹配

print(s.lstrip())  # 与print(s.strip())相比，仅去除左侧
print(s.rstrip())  # 与print(s.strip())相比，仅去除右侧

8. 字符串的子串出现次数

序号	函数名	功能	用法
1	str.count(sub[, start[, end]])	返回子字符串 sub 在字符串中出现的次数

s = "Hello, World! woo "
print(s.count("o"))  # 输出：4   默认从头到尾
print(s.count("o",4))  # 输出：4   从索引4开始匹配
print(s.count("o",5))  # 输出：3   从索引5开始匹配，索引4就不在范围；
print(s.count("o",5,17))  # 输出：3   从索引5开始匹配，左闭右开区间[5,17)；

四、变量类型转换（内置函数）

4.1 说明

python 是一种强类型语言。当运算需要时，必须使用显式的变量类型转换。
变量的类型转换，并不是对变量原地进行修改，而是产生一个新的预期类型的对象。

在科学计数法中，为了使公式简便，可以用带“E”/“e”的格式表示。当用该格式表示时，E/e前面的数字和“E/e+”后面要精确到十分位，（位数不够末尾补0）,例如7.8乘10的7次方，正常写法为：7.8x10^7,简写为“7.8E+07”的形式

4.2 float（）函数-将其他类型数据转换为浮点数

s = 1
t = float(s)
print(float(t))
print(id(s))
print(id(t))
>>> # id值不一致，说明不是在原有的id值上进行修改
1.0
140733647750832
2169706998704

print(float('1.246e-4'))
print(float('1e-5'))
print(float('1.2e-5'))
print(float('1.365211e+15'))
print(float('1.365211e+16'))
>>> # python会尽可能的转换成字符长度较短的形式进行保存，以节省空间。
>>> # 实例可知，在科学计数法为-5 或 +16 时，用科学计数法。
0.0001246
1e-05
1.2e-05
1365211000000000.0
1.365211e+16

4.3 str（）函数-将其他类型数据转换为字符串

print(type(str(1)),str(1))
print(type(str(1.000)),str(1.000)) # 因为1.000为浮点数，故不能为1，因为要满足最短要求，展示为1.0
print(type(str(1.365e-4)),str(1.365e-4))
print(type(str(1.365e-5)),str(1.365e-5))
print(type(str(1.365211e+15)),str(1.365211e+15))
print(type(str(1.365211e+16)),str(1.365211e+16))
>>> # python会尽可能的转换成字符长度较短的形式进行保存，以节省空间。
>>> # 实例可知，在科学计数法为-5 或 +16 时，用科学计数法。
<class 'str'> 1
<class 'str'> 1.0
<class 'str'> 0.0001365
<class 'str'> 1.365e-05
<class 'str'> 1365211000000000.0
<class 'str'> 1.365211e+16

4.4 int（）函数-将其他类型数据转换为整型

print(type(int(1.999)),int(1.999)) 	# int() 不是四舍五入，而是会直接剔除小数部分，
print(type(int(-1.999)),int(-1.999)) 
print(type(int(True)),int(True))	# 布尔值 True 相当于 1
print(type(int(False)),int(False))	# 布尔值 False相当于 0
print(type(int('3')),int('3'))
print(type(int(float('5.5'))),int(float('5.5')))
print(type(int('3.5')),int('3.5'))	# 有的字符串不能直接转换成整型
>>> # 1. 字符串是整数时，可以直接转换为整型
>>> # 2. 字符串是浮点数时，必须先转换为浮点型后，再转换成整型
<class 'int'> 1
<class 'int'> -1
<class 'int'> 1
<class 'int'> 0
<class 'int'> 3
<class 'int'> 5
ValueError: invalid literal for int() with base 10: '3.5'

4.5 round() 函数-将浮点型数据圆整为整型

python 采用的是 “银行家圆整” ：将小数部分采用 “ 四舍六入五留双 ” 。即个位为偶数，则舍弃；个位为基数，则进位；使整数为偶数。

print(round(36.5555))
print(round(37.55555))
>>>
36
38

4.6 bool() 函数-将其他类型数据转换为布尔型

数值0和空字符串转换的布尔型的值为Flase。
除了上述的类型值，其他转换的布尔型值均为True

print(type(bool()),bool())		#【没有数据】，布尔型的值为Flase
print(type(bool(0)),bool(0))	#数值是【0、0.000】，布尔型的值为Flase
print(type(bool(-0)),bool(-0))	#数值是【-0、-0.000】，布尔型的值为Flase
print(type(bool('0')),bool('0'))	#字符串类型的0，布尔型值为True
print(type(bool('')),bool(''))		#字符串类型的【空字符】，布尔型的值为Flase
print(type(bool(' ')),bool(' '))    #字符串类型的空格，布尔型的值为True
print(type(bool(654)),bool(654))    #数值是654，布尔型的值为True
>>>
<class 'bool'> False
<class 'bool'> False
<class 'bool'> False
<class 'bool'> True
<class 'bool'> False
<class 'bool'> True
<class 'bool'> True

4.7 chr() 与 ord() 函数-整数与字符之间的转换

chr() 将一个整数按照 ‘ ASCII ’ 码转换成对于的字符。
ord() 将一个字符按照 ‘ ASCII ’ 码转换成对于的整数。


>>> ord('0') , ord('9') , ord('A'), ord('Z'),ord('a'),ord('z')
(48, 57, 65, 90, 97, 122)
>>> chr(47) , chr(58) , chr(64) , chr(91), chr(96), chr(123)
('/', ':', '@', '[', '`', '{')

4.8 eval() 函数-返回传入字符串的表达式的结果。

将字符串当成有效的表达式来求值并返回计算结果。
eval() 函数就是实现list、dict、tuple与str之间的转化，
str() 函数把list，dict，tuple转为为字符串

eval() 函数说明:
eval(expression[, globals[, locals]])
expression ：表达式。
globals ：（可选参数)变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals ： (可选参数)变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

五、基本运算和表达式

5.1 运算符

Python 支持算术运算符、赋值运算符、关系运算符、逻辑运算符等。
运算符分类（按操作数数目）：
单目运算符：只要一个操作数，负（-）、逻辑非（not）
双目运算符：需要两个操作数，大部分都是，比如：赋值运算符（=）、算术乘法（*）
三目运算符：需要三个操作数，value_if_true if condition else value_if_false，
例如：max_value = a if a > b else b

5.2 算术运算符

python的算术运算符

运算符	描述	实例	优先级
+	加	5+2=7 或 5.5+2.0=7.5	4-最低
-	减	5-2=3 或 5.5-2=3.5	4-最低
*	乘	52=10 或 5.52=11.0	3-低
/	浮点除法	5/2=2.5 或 5.5/2=2.75	3-低
//	整除，返回商	5//2=2 或 5.5//2=2.0	3-低
%	整除，返回余数，也称取模	5%2=1 或 5.5%2.0=1.5	3-低
+	单目+	x=-7 则 +x为-7	2-高
-	单目-	x=-7 则 -x为7	2-高
**	幂运算	52=25 或 5.52.0=30.25	1-最高

余数的正负号和除数的符号保持一致
-5%3 ==》1
5%-3 ==》 -1
-5%-3 ==》 -2

5.3 赋值运算符 =

变量 = 表达式

左边只能是变量，不可为常量。如：5=x 或 5=2+3 都是错误的；

1 单变量赋值

name = "张三"
age = 18+2

2 序列赋值

>>>x,y = 1,1.5
>>>print(x,y)
1  1.5

>>>a,b,c,d,e = "hello" 
>>>print(a,b,c,d,e)
h e l l o

>>>q,w,e,r = "hello",12,43.76,8+5j
>>>print(q,w,e,r)
hello  12  43.76  (8+5j)

>>>i,j = 30,50  # 实现两个变量的值直接进行交换
>>>i,j=j,i
>>>print(i,j)
50  30

2 多目标赋值：将相同的值赋给多个变量

>>>a = b = c = d = "hello" 
>>>print(a,b,c,d)
hello hello hello hello

只用于赋予数值或字符串等不可变类型，若赋值为可变类型，可能存在问题

5.4 算术复合赋值运算符

python的算术运算符

运算符	描述	实例
+=	加等	a+=b 等价于 a=a+b
-=	减等	a-=b 等价于 a=a-b
*=	乘等	a=b 等价于 a=ab
/=	浮点除法等	a/=b 等价于 a=a/b
//=	整除等	a//=b 等价于 a=a//b
%=	取模等	a%=b 等价于 a%a+b
**=	幂等	a=b 等价于 a=ab

5.5 关系运算符

运算符	描述	实例
>	大于	5>2为True ，“5”>"12"为True 字符串从左往右单个比较
>=	大于等于	“a”>="A"为True ，“ab”>=“ac” 为False
<	小于
<=	小于等于
==	等于	5==2为False， “5”==5为False
!=	不等于	5!=2为True ， “5”!=5为True
is	等于	5 is 2为False， “5” is 5为False
is not	不等于	5 is not 2为True ， “5” is not 5为True

复数不能比较大小，只能比较是否想等
允许x<y<z 等价于 x<y且y<z
允许x<y>z 等价于 x<y且y>z

5.6 逻辑运算符

运算符	描述	实例	优先级
or	逻辑或运算符，只要有一个都为真，结果才为真	False or False 返回 False	3-低
and	逻辑与运算符，只有两个都为真，结果才为真	True or True 返回 True	2-中
not	逻辑非运算符，单目运算符，反转操作数的逻辑状态	not True 返回 False	1-高

or 是一个短路运算符，如果左边为True，则跳过右边，直接得出结果为True
and是一个短路运算符，如果左边为False ，则跳过右边，直接得出结果为False

>>>a,b,c = 1,2,3 
>>>a==1 or b==10 and c==12
True  
python会按照“最贪婪”方式短路，因为and优先级高，所以b和c为整体。
又因为or的左边为True，则不判断其右边的and的结果，b和c全部被短路。
直接得到 True

5.7 常用的python数学运算类的内置函数

函数名	描述	实例
abs	绝对值	abs(-5)返回5，abs(-5.0)返回5.0
divmod	取模，返回商和余数	divmod(5,2)返回(2,1)
pow	幂次	pow(5,2)返回25，pow(5.0,2.0)返回25.0
round	四舍六入五留双	round(1.5)返回2，round(2.5)返回2
sum	可迭代对象求和	sum([1,3,4,5,2])返回15
max	求最大值	max([1,3,4,5,2])返回5
min	求最小值	min([1,3,4,5,2])返回1

六、基本流程控制

6.1 顺序结构

在 Python 中，顺序结构是最基本的程序流程控制方式。

顺序结构的特点
1~ 按顺序执行：程序从上到下依次执行代码，每条语句执行完成后才执行下一条语句。
2~无条件判断：顺序结构中没有条件判断或分支逻辑。
3~无循环：顺序结构中没有循环逻辑，代码不会重复执行。

6.2 分支结构（也称为选择结构）

在 Python 中，分支结构（也称为选择结构）是非常重要的程序流程控制方式。允许程序根据条件判断选择不同的执行路径。
分支结构的核心是条件判断，通过条件表达式的布尔值（ True 或 False ）来决定程序的执行流程。

6.2.1 单分支结构（if语句）

if 语句用于根据条件判断是否执行某段代码。
如果条件为 True ，则执行代码块；
如果条件为 False ，则跳过代码块。

6.2.2 双分支结构（if-else语句）

if-else 语句用于根据条件判断选择两个不同的执行路径。
如果条件为 True ，则执行 if 块中的代码；
如果条件为 False ，则执行 else 块中的代码。

age = 16
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")
# 输出：You are a minor.   ~~你还是未成年人

6.2.3 多分支结构（if-elif-else语句）

if-elif-else 语句用于处理多个条件判断。
程序会依次检查每个条件，直到找到一个为 True 的条件并执行对应的代码块。
如果没有条件为 True ，则执行 else 块中的代码。

score = 85
if score >= 90:	print("Grade: A")
elif score >= 80: print("Grade: B")
elif score >= 70: print("Grade: C")
elif score >= 60: print("Grade: D")
else: print("Grade: F")
# 输出：Grade: B

6.2.4 分支语句嵌套

分支结构可以嵌套使用，即在一个分支结构内部再包含另一个分支结构。
嵌套分支结构可以处理更复杂的逻辑关系。

age = 25
has_license = True

if age >= 18:
    if has_license:
        print("You can drive.")
    else:
        print("You need to get a license first.")
else:
    print("You are too young to drive.")
# 输出：You can drive.    ~~~你太年轻了，不能开车。

6.3 循环结构

在 Python 中，循环结构允许程序重复执行某段代码，直到满足特定条件为止。循环结构是程序设计中非常重要的部分，它可以帮助我们处理重复的任务，例如遍历列表、处理文件中的每一行数据等。

6.3.1 while语句

while 循环会一直执行代码块，直到条件变为 False 。
通常用于在不知道循环次数的情况下，根据条件重复执行代码。while 循环适用于根据条件重复执行代码。

6.3.2 for语句与range()内置函数

for 循环用于遍历可迭代对象（如列表、元组、字符串、字典等），并对每个元素执行相同的代码块。
for 循环适用于遍历可迭代对象。

range() 是 Python 中的一个内置函数，用于生成一个整数序列，常用于循环控制中。
特点

惰性生成： range() 生成的是一个惰性序列，不会一次性生成所有值，而是根据需要逐个生成。这使得它在处理大范围的整数时非常高效。
不可变性： range() 生成的序列是不可变的，不能修改其中的值。
内存友好：由于是惰性生成， range() 不会占用大量内存，即使生成的序列范围很大。

# 如果需要将range()生成的序列转换为列表，可以使用list()函数：
numbers = list(range(5))
print(numbers)  # 输出：[0, 1, 2, 3, 4]

单参数形式：range(stop) ：从 0 开始到 stop （不包括 stop ）的整数序列，即[0,stop)
例如： range(5) 生成 [0, 1, 2, 3, 4]
双参数形式：range(start, stop) ：从 start 开始到 stop （不包括 stop ）的整数序列，即[start,stop)
例如： range(2, 7) 生成 [2, 3, 4, 5, 6] 。
三参数形式：range(start, stop, step) ：生成从 start 开始到 stop （不包括 stop ）的整数序列，每次增加 step 。
例如： range(3, 10, 2) 生成 [3, 5, 7, 9]
例如： range(10, 2, -3) 生成 [10, 7, 4]

6.3.3 循环语句嵌套

循环结构可以嵌套使用，即在一个循环内部再包含另一个循环。嵌套循环常用于处理二维数据结构（如矩阵）。

# 嵌套循环
for i in range(3):
    for j in range(3):
        print(f"({i}, {j})", end=" ")
    print()
# 输出：
# (0, 0) (0, 1) (0, 2)
# (1, 0) (1, 1) (1, 2)
# (2, 0) (2, 1) (2, 2)

6.3.3 break、continue、else

break ：用于提前退出当前循环。
continue ：用于跳过当前循环的剩余代码，直接进入下一次迭代。
else ：在循环正常结束时执行（即没有被 break 中断）。

# 使用 else
for i in range(5):
    print(i)
else:
    print("Loop finished normally")
# 输出：
# 0
# 1
# 2
# 3
# 4
# Loop finished normally

6.4 try-except异常处理

在 Python 中， try-except 是一种异常处理机制，用于捕获和处理程序运行时可能出现的错误（异常）。通过使用 try-except 块，可以避免程序因未处理的异常而崩溃，从而提高程序的健壮性和用户体验。

6.4.1 try-except结构

try:
  	 # 尝试执行的代码块
	 # 这里可能会引发异常
except ExceptionType as e: # 捕获异常，并将异常对象赋值给变量e
    # 处理异常的代码块
    # 当try块中的代码引发指定类型的异常时，执行这里的代码
组成部分
1. try块：这是程序中可能会引发异常的代码部分。Python会尝试执行try块中的代码。
2. except块：如果try块中的代码引发了指定类型的异常（ExceptionType），Python 会将异常对象赋值给变量e，并执行except块中的代码。
3. ExceptionType：这是你希望捕获的异常类型。可以是Python内置的异常类型（如ValueError、ZeroDivisionError、NameError等），也可以是自定义的异常类型。
4. as e：将捕获的异常对象赋值给变量e，方便在except块中访问异常对象的属性和方法。

Exception：所有异常场景，它是所有内置异常的基类
ZeroDivisionError：除数为零，仅匹配此场景
NameError：变量名未定义，仅匹配此场景
ValueError：

1、单except~捕获除零错误

try:
    result = 10 / 0	 # try块中代码尝试执行除零操作，会引发ZeroDivisionError异常
except ZeroDivisionError as e: #  except块捕获了ZeroDivisionError异常，并将异常对象赋值给变量e
    print(f"Error: {e}")	# 使用f"Error: {e}" 打印出异常信息
# 输出：Error: division by zero   除数为零

2：多except~捕获多种异常

try:
    # 可能会引发多种异常的代码
    result = 10 / 0
    print(name1)
except ZeroDivisionError as e:
    print(f"ZeroDivisionError: {e}")
except NameError as e:
    print(f"NameError: {e}")
except Exception as e:  # 捕获其他所有异常
    print(f"Unknown Exception: {e}")
# 输出：ZeroDivisionError: division by zero
# 若result 的除数不是0，则输出为：NameError: name 'name1' is not defined
# 若出现非上述的两个异常时，会触发 "except Exception as e:",兜底其他异常；

3：获取异常的类型和消息

try:
    result = 10 / 0
except Exception as e:
    print(f"Exception type: {type(e).__name__}")
    print(f"Exception message: {e}")
# 输出：
# Exception type: ZeroDivisionError
# Exception message: division by zero
• 使用  type(e).__name__  获取异常的类型。
• 使用  e  获取异常的消息。

6.4.2 try-except-else结构

如果try块中的代码没有引发异常，则会执行else子句中的代码；
如果try块中的代码引发异常，不会执行else子句。

try:
    result2 = 10 / 2
except ZeroDivisionError as e:
    print(f"Error: {e}")
else:
    print(f"result2的值为: {result2}")
# 输出：result2的值为： 5.0

6.4.3 try-except-else-finally结构

finally子句中的代码无论是否发生异常都会执行，通常用于清理资源，如关闭文件、释放网络连接等。

try:
    result = 10 / 2
except ZeroDivisionError as e:
    print(f"Error: {e}")
else:
    print("没有异常产生.")
finally:
    print("这里将一致执行.")
# 输出：
# 没有异常产生.
# 这里将一致执行.

6.4.4 自定义异常

除了内置的异常类型，Python 还允许用户定义自己的异常类。自定义异常类通常继承自 Exception 或其子类。（略）

七、组合数据类型

7.1 序列型组合数据类型：字符串、列表、元组

它们都是有序的数据结构，元素按照特定的顺序排列，并且可以通过索引访问。

序列的通用操作：由于字符串、列表和元组都是序列类型，它们支持一些通用的操作。

函数名	描述	实例
seq[index]	索引访问	从左往右索引从 0 开始；从右往左索引从 -1 开始；
seq[start：end：step]	切片操作	范围为左闭右开的区间 [start，end），step是步长，默认为 1且省略
len(seq)	长度计算	获取序列中元素的数量
element in seq 或 element not in seq	成员检查	可以检查某个元素是否存在于序列中
for循环遍历序列中的每个元素	迭代	使用 for 循环遍历序列中的每个元素
s1+s2	连接	使用 + 操作符可以将两个序列连接在一起
s1 * n 或 n * s1	重复	使用 * 操作符可以将序列重复指定次数
min() 和 max()	获取可比较元素的序列中的最小值和最大值	若是字符串则返回ASCII值中最小/最大的字符；数值则按照最小/最大的值
count()	计数	可以统计序列中某个元素出现的次数
index()	查找	可以找到某个元素在序列中的第一个索引位置
enumerate()	枚举	可以同时获取序列的索引和元素

s1 = "hello"
s2 = "world"
lst1 = [1, 2, 3, 4, 5]
lst2 = [4, 5, 6, 6]
t1 = (7, 8, 9, 10)
t2 = (9, 10, 11, 12)

print(s1[1])  # 输出：e
print(lst1[2])  # 输出：3
print(t1[-1])  # 输出：10

print(s1[1:4])  # 输出：ell
print(lst1[1:4])  # 输出：[2, 3, 4]
print(t1[1:4:2])  # 输出：(8, 10)
print(s1[::-1])  # 输出：olleh（反转字符串、列表、元组均可）
print(lst1 [::2])  # 输出：[1, 3, 5]（每隔一个元素取一个）

print(len(s1))  # 输出：5
print(len(lst1))  # 输出：5
print(len(t1))  # 输出：4

print("e" in s1)  # 输出：True
print(3 in lst1)  # 输出：True
print(19 not in t1)  # 输出：True

for char in s1:
    print(char)  # 逐个打印字符 h e l l o
for num in lst1:
    print(num)  # 逐个打印列表元素 1 2 3 4 5
for item in t1:
    print(item)  # 逐个打印元组元素 7 8 9 10

print(s1 + " " + s2)  # 输出：hello world
print(lst1 + lst2)  # 输出：[1, 2, 3, 4, 5, 4, 5, 6, 6]
print(t1 + t2)  # 输出：(7, 8, 9, 10, 9, 10, 11, 12)

print(s1 * 3)  # 输出：hellohellohello
print(lst1 * 2)  # 输出：[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
print(t1 * 3)  # 输出：(7, 8, 9, 10, 7, 8, 9, 10, 7, 8, 9, 10)

print(min(s1))  # 输出：e（按字母顺序返回ASCII值中最小的字符）
print(max(lst1))  # 输出：5
print(min(t1))  # 输出：7

s3 = "hello"
lst3 = [1, 2, 3, 2, 4]
t3 = (5, 6, 7, 6, 8)
print(s3.count("l"))  # 输出：2
print(lst3.count(2))  # 输出：2
print(t3.count(6))  # 输出：2

print(s3.index("l"))  # 输出：2
print(lst3.index(2))  # 输出：1
print(t3.index(6))  # 输出：1

for index, char in enumerate(s1):
    print(f"Index: {index}, Char: {char}")
    
	#	Index: 0, Char: h
	#	Index: 1, Char: e
	#	Index: 2, Char: l
	#	Index: 3, Char: l
	#	Index: 4, Char: o
	
for index, num in enumerate(lst1):
    print(f"Index: {index}, Num: {num}")
    
	#	Index: 0, Num: 1
	#	Index: 1, Num: 2
	#	Index: 2, Num: 3
	#	Index: 3, Num: 4
	#	Index: 4, Num: 5

7.1.1 字符串（str）

定义：字符串是由字符组成的不可变序列。一旦创建，字符串的内容不能被修改。

特点：
• 不可变：不能直接修改字符串中的某个字符，例如 s[0] = ‘h’ 会报错，可以使用支持的方法进行变换。
• 支持索引和切片：可以通过索引访问单个字符，通过切片获取子字符串。例如：print(s[1]) 、print(s[1:4])
• 支持字符串方法：如 upper() 、 lower() 、 replace() 等

7.1.2 列表（list）

定义：列表是一个可变的有序序列，可以包含不同类型的数据。
特点
• 可变：可以修改列表中的元素。例如 lst[2] = ‘h’ 修改列表的元素成功。
• 支持索引和切片：可以通过索引访问单个元素，通过切片获取子列表。例如：print(lst[1])、print(lst[1:3])
支持列表方法：增、删、改、查

序号	函数名	描述	实例
1	lst.append()	列表末尾添加一个元素
2	lst.extend([5, 6])	在列表末尾添加多个元素
3	lst.insert(2, “new”)	在指定位置插入一个元素
4	lst.remove(4)	删除第一个值为 4 的元素	（）内为列表中的元素
5	lst.pop()	移除并返回最后一个元素	一般 value=lst.pop() 获取删除的值
6	lst[2] = ‘h’	可以将对应索引值直接修改
7	lst[1:3]	切片操作

lst = [1, 2, 3]
lst.append(4)  # 在列表末尾添加一个元素
print(lst)  # 输出：[1, 2, 3, 4]

lst.extend([5, 6])  # 在列表末尾添加多个元素
print(lst)  # 输出：[1, 2, 3, 4, 5, 6]

lst.insert(2, "new")  # 在指定位置插入一个元素
print(lst)  # 输出：[1, 2, 'new', 3, 4, 5, 6]

del lst[2]  # 删除索引为 2 的元素
print(lst)  # 输出：[1, 2, 3, 4, 5, 6]


lst = [1, "sd", 3, 0, 5]
lst2 = lst[1:4] 
print(lst2) # 输出：['sd', 3, 0]

支持列表方法~排序/清空列表

序号	函数名	描述	实例
1	lst.sort()	对自身从小到大排序，没有返回值
2	sorted(list)	返回排序后的列表，但原列表不变	从小到大排序
3	lst.reverse()	对自身排序反转，没有返回值	lst[::-1]，原列表不变，返回列表排序反转
4	lst.clear()	对自身清空，没有返回值

lst1=[1,3,5,2,8,6,1]
x1=lst1.sort()  # 仅将list1进行重新排序，不会赋值给x1
print(lst1)  # 输出：[1, 1, 2, 3, 5, 6, 8]
print(x1)    # 输出：None

lst2=[1,3,5,2,8,6,1]
x2=sorted(lst2)	# 将重新排序赋给x2,自身不变
print(lst2)     # 输出：[1, 3, 5, 2, 8, 6, 1]
print(x2)       # 输出：[1, 1, 2, 3, 5, 6, 8]
lst2.clear()  # 清空列表
print(lst)  # 输出：[]

列表推导式
列表推导式是一种简洁的方式来创建列表.

# 创建一个包含 0 到 9 的平方的列表
squares = [x**2 for x in range(10)]
			# 将x的每一次值，都经过x**2
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 创建一个包含偶数平方的列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]
			# 将x的每一次值，在if判断为true时，再经过x**2
print(even_squares)  # 输出：[0, 4, 16, 36, 64]

7.1.3 元组（tuple）

定义：元组是一个不可变的有序序列，可以包含不同类型的数据。
特点
• 不可变性：不能修改元组中的元素。例如 t[0] = ‘h’ 会报错（且不能添加、删除或修改元素）。这使得元组在某些场景下比列表更安全，例如作为字典的键。
• 有序性：支持索引和切片，可以通过索引访问单个元素，通过切片获取子元组。例如：print(t[1])、print(t[1:3])左闭右开、print(t[3:])、print(t[:3])；
• 可嵌套：元组可以嵌套，即元组的元素可以是另一个元组（或其他数据类型）。

# 元组可以通过圆括号 () 创建，也可以不使用圆括号，但建议使用圆括号以提高可读性
t1 = (1, 2, 3)
t2 = ("hello", 3.14, True)

# 不使用圆括号创建元组（单个元素的元组需要加逗号）
t3 = 1, 2, 3
t4 = "hello",  # 单个元素的元组需要加逗号

print(t1[0])  # 输出：1
print(t3[::-1])  # 输出：(3, 2, 1)
print(t4[0])  # 输出：hello

元组的常用操作

序号	名称	简介
1	len(t)	返回元组的长度
2	for i in t: print(i)	使用 for 循环遍历元组中的元素
3	t3=t1+t2	使用 + 操作符连接两个元组,返回一个新元组
4	t1 = t1 * 3 或 t2 = 3* t1	使用 * 操作符重复元组,返回一个新元组，可以再次赋值给自己

t1 = (1, 2, 3, 4, 5)
print(len(t1))  # 输出：5

for i in t1 : print(i,end='、')  # 1、2、3、4、5、
t2=t1*2
t3=2*t1

7.2 映射型组合数据类型：字典

在Python中，字典是一种非常重要的映射型组合数据类型，它通过键值对（ key-value ）的方式存储数据。

定义:字典是一种可变的容器模型，且可存储任意类型对象。字典的每个键值 key:value 对用冒号 : 分割，每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中。

特点:

键（ key ）必须是不可变类型（如字符串、数字或元组），且具有唯一性。【如果尝试添加一个已经存在的键，会覆盖原来的值；如果使用可变类型（如列表）作为键，会抛出 TypeError 】
值（ value ）可以是任意类型，包括数字、字符串、列表、字典等。
字典是无序的，即字典中的键值对没有固定的顺序。

7.2.1、字典的创建**

序号	名称	简介
1	{}	创建字典
2	dict() 函数创建	使用 dict() 函数创建字典

# 创建一个空字典
empty_dict = {}
# 创建一个包含键值对的字典
person = {"name": "Alice","age": 25}

# 使用键值对列表创建字典
person1 = dict([("name", "Alice"), ("age", 25), ("city", "New York")])
# 使用关键字参数创建字典
person2 = dict(name="Alice", age=25, city="New York")
print(person1) # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}
print(person2) # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

7.2.2、字典中的值的处理：增、查、改

序号	名称	简介
1	dict1[“name1”]	通过键来访问字典dict1中的值。如果键不存在，会报错抛出 KeyError
2	dict1.get(“name”[,“define”])	使用get方法访问键值，如果键不存在返回定义值，缺省则为默认为 None
3	dict1[“name1”] = value2	可以通过键来修改对应的值；若键是未重复的，则添加一个键值对
4	+ 或 *	~~两个字典不可用+ 或 *连接，会报错抛出 TypeError~~
5	dict1.update(dict2)	将dict2的键值对新增到dict1中

person1 = dict([("name", "Alice"), ("age", 25), ("city", "New York")])
person2 = {"sks": 235}
print(person1["name"])  # 输出：Alice
# 使用get方法访问键值，如果键不存在，返回默认值
print(person1.get("name"))  # 输出：Alice
print(person1.get("name2"))  # 输出：None
print(person1.get("gender", "Unknown"))  # 输出：Unknown

person1["name"] = "Alice2"	  # 修改name键的值为Alice2
person1["gender"] = "Female"  # 添加新的键值对

person1.update(person2)
print(person1) # 输出： {'name': 'Alice2', 'age': 25, 'city': 'New York', 'gender': 'Female', 'sks': 235}

7.2.3、字典中的删除键值对

序号	名称	简介
1	del dict1[“name1”]	删除指定键值对，如果键不存在，会报错抛出 KeyError
2	vari1 = dict1.pop(“name1”)	删除键对应的键值对，并返回键对应的值
3	dict1.clear()	清空字典

person1 = dict([("name", "Alice"), ("age", 25), ("city", "New York")])
person1["name"] = "Bob"
person1["gender"] = "Female"  # 添加新的键值对
print(person1)     # 输出： {'name': 'Bob', 'age': 25, 'city': 'New York', 'gender': 'Female'}

del person1["gender"]
print(person1)     # 输出：{'name': 'Bob', 'age': 25, 'city': 'New York'}

age = person1.pop("age")  # 删除键为"age"的键值对，并返回对应的值
print(age)         # 输出：25

person1.clear()
print(person1)     # 输出：{}

7.2.4、返回字典中的视图：键、值、键值对

序号	名称	简介
1	key1= dict1.keys()	返回字典的键视图
2	valu1= dict1.values()	返回字典的值视图
3	item1 = person.items()	返回字典的键值对视图

person1 = {"name": "Alice", "age": 25, "city": "New York"}
key11 = person1.keys()
print(key11)  # 输出：dict_keys(['name', 'age', 'city'])

valu11 = person1.values()
print(valu11)  # 输出：dict_values(['Alice', 25, 'New York'])

item11 = person1.items()
print(item11)  # 输出：dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

7.2.5、字典的遍历：键、值、键值对

序号	名称	简介
1	for i in person.keys():print(i)	遍历字典的键
2	for i in person.values(): print(i)	遍历字典的值
3	for i,j in person.items(): print(f"{i}: {j}")	遍历字典的键值对

7.2.6、字典的高级用法：嵌套字典、字典推导式

family = {
    "Alice": {
        "age": 25,
        "city": "New York"
    },
    "Bob": {
        "age": 30,
        "city": "Los Angeles"
    }
}		# 创建嵌套字典（字典的值可以是另一个字典，形成嵌套结构）**

print(family["Alice"]["city"])  # 输出：New York  输出family字典中Alice键的值中city子键对应的子值的信息；


squares = {x: x*x for x in range(6)}  # 字典推导式（类似于列表推导式，可以快速生成字典）
# x: x*x 为创建字典的格式
print(squares)  # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

7.3 集合型组合数据类型：集合

在Python中，集合（set）是一种集合型组合数据类型，它是一个无序且不重复的元素集合。集合非常适合用于处理唯一性问题，例如去除重复数据、进行数学集合运算（如并集、交集、差集等）。
定义：集合是一个无序的、不重复的元素集合。集合中的元素必须是不可变类型（如数字、字符串、元组等），但集合本身是可变的。

特点:

无序性：集合中的元素没有固定的顺序
唯一性：集合中的元素不允许重复。。
可变性：集合可以动态地添加或删除元素。

7.3.1、集合的创建

序号	名称	简介
1	{}	使用花括号创建集合，但不能用{}创建空集合，因为{}表示空字典
2	set()函数	使用 set() 函数可以创建空集合，且函数中仅可放入一个可迭代对象中，然后传递给set函数

# 创建一个包含多个元素的集合（注意：不能用{}创建空集合，因为{}表示空字典）
my_set1 = {1, 2, 3, 4, 5}
print(my_set1)  # 输出：{1, 2, 3, 4, 5}

# set创建一个空集合
empty_set2 = set()
print(empty_set2)  # 输出：set()

# set创建一个非空集合
empty_set3 = set("123")
print(empty_set3)  # 输出：{'2', '1', '3'}  集合是无序的；
empty_set4 = set(123)
print(empty_set4)  # 报错：TypeError: 'int' object is not iterable，数值不可迭代；

my_list = [1, 2, 2, 3, 4, 4, 5]     # 列表
my_set = set(my_list)
print(my_set)  # 输出：{1, 2, 3, 4, 5}  去重

my_tuple = (1, 2, 2, 3, 4, 4, 5)    # 元组
my_set = set(my_tuple)
print(my_set)  # 输出：{1, 2, 3, 4, 5}  去重

7.3.2、集合的基本操作：增、删、无改、无查

序号	名称	简介
1	my_set.add(value)	添加一个元素到集合中
2	my_set.remove(3)	删除指定元素。如果元素不存在，会抛出 KeyError
3	my_set.discard(5))	删除指定元素。如果元素不存在，不会抛出异常
4	element = my_set.pop()	随机删除一个元素，并返回该元素
5	my_set.clear()	清空集合

my_set = {1, 2, 3, 4}

my_set.remove(3)  # 删除元素3
print(my_set)  # 输出：{1, 2, 4}
my_set.discard(5)  # 尝试删除不存在的元素5，不会报错
print(my_set)  # 输出：{1, 2, 4}
element = my_set.pop()  # 随机删除一个元素
print(element)  # 输出：1（随机）
print(my_set)  # 输出：{2, 4}
my_set.clear()  # 清空集合
print(my_set)  # 输出：set()

7.3.3、集合运算：并、交、差和对称差集

序号	名称	简介	说明
1	set1 \| set2 或 set1.union(set2)	并集：\| 运算符或 union() 方法	2个集合相加，且重复显示1个
2	set1 & set2 或 set1.intersection(set2)	交集：& 运算符或 intersection() 方法	2个集合相交，且仅仅显示重复的1个
3	set1 - set2 或 set1.difference(set2)	差集: - 运算符或 difference() 方法	集合1 减去集合2
4	set1 ^ set2 或 set1.symmetric_difference(set2)	对称差集 : ^ 运算符或 symmetric_difference() 方法	2个集合相加，且重复的不显示

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2)  # 输出：{1, 2, 3, 4, 5}   2个集合相加，因集合不重复，重复的只保留1个
print(set1.union(set2))  # 输出：{1, 2, 3, 4, 5}  同上

print(set1 & set2)  # 输出：{3}   只展示2个集合都存在的元素，因集合不重复，重复的只保留1个
print(set1.intersection(set2))  # 输出：{3}    同上

print(set1 - set2)  # 输出：{1, 2}   2个集合相减，且只减去都存在的；
print(set1.difference(set2))  # 输出：{1, 2}    同上

print(set1 ^ set2)  # 输出：{1, 2, 4, 5}  2个集合相加，且只减去都存在的；
print(set1.symmetric_difference(set2))  # 输出：{1, 2, 4, 5}  同上

7.3.4、集合的判断：子集、超集、没有交集和更新集合

序号	名称	简介
1	set1.issubset(set2)	判断set1是否为set2的子集，set1 ⊆ set2，正确为True，错误为False
2	set1.issuperset(set2)	判断set1是否为set2的超集（与子集是互为逆关系），set1 ⊇ set2，正确为True，错误为False
3	set1.isdisjoint(set3)	判断两个集合是否没有交集，他们不存在相同的为True，存在相同为False
4	set1.update(set2)	更新集合，将集合2的元素复制到集合1中

set1 = {1, 2}
set2 = {1, 2, 3, 4}
set3 = {1, 2, 5}
print(set1.issubset(set2))  # 输出：True  集合set1是集合set2的子集
print(set3.issubset(set2))  # 输出： False  集合set3不是集合set2的子集
print(set2.issuperset(set1))  # 输出：True   集合set2是集合set1的超级
print(set2.isdisjoint(set3))   # 输出：False  集合set2与集合set3存在相同的元素
set4 = {1, 9, 7}
set2.update(set4)   # 将集合set4的元素添加到集合set2中
print(set2)  # 输出：{1, 2, 3, 4, 7, 9}

7.3.5、集合的遍历：for循环

序号	名称	简介
1	for element in my_set: print(element)	但由于集合是无序的，遍历顺序可能与添加顺序不同

my_set = {1, 2, 3, 4, 5}
for element in my_set:
    print(element)

7.3.6、集合的应用场景

# 1 去除重复元素
# 集合的唯一性特性使其非常适合去除重复数据。
my_list = [1, 2, 2, 3, 4, 4, 5]
unique_list = list(set(my_list))  # 使用set（）方法将原列表删除重复项，
								  # 且再次list（）返回赋值一个新列表
print(unique_list)  # 输出：[1, 2, 3, 4, 5]

# 2 成员资格测试
# 集合的成员资格测试（  in  或  not in  ）比列表更快，因为集合是基于哈希表实现的。
my_set = {1, 2, 3, 4, 5}
print(3 in my_set)  # 输出：True
print(6 not in my_set)  # 输出：True

八、文件处理

8.1 文件的打开：open() 函数

Python的 open() 函数是一个内置函数，用于打开文件并返回一个文件对象，通过该对象可以对文件进行读取、写入、追加等操作。
open() 函数的语法：
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明

file ：必需参数，表示要打开的文件的路径（字符串或路径对象）。可以是相对路径或绝对路径。
mode ：可选参数，指定文件的打开模式。默认值为 ‘r’ （只读模式）。常见模式包括：
》 ‘r’ ：只读模式，文件必须存在。
》 ‘w’ ：写入模式，如果文件已存在则覆盖，不存在则创建。
》 ‘x’ ：独占创建模式，如果文件已存在则抛出 FileExistsError。
》 ‘a’ ：追加模式，在文件末尾添加内容，如果文件不存在则创建。
》 ‘b’ ：二进制模式（配合其他模式一起使用，如 ‘rb’ 或 ‘wb’ ）。
》 ‘t’ ：文本模式（默认模式，如 ‘rt’ 或 ‘wt’ ）。
》 ‘+’ ：更新模式，可读写。（读写模式，如 ‘r+’ 或 ‘w+’ ）。
buffering ：可选参数，指定缓冲区大小。默认值为 -1 ，表示使用系统默认的缓冲区大小。支持以下常用值：
》 -1 ：使用系统默认缓冲区大小。
》 0 ：无缓冲。
》 >0 ：指定缓冲区大小。
encoding ：可选参数，指定文件的编码格式。在文本模式下使用，例如 ‘utf-8’ 、 ‘ascii’ 、 ‘gbk’ 等。缺省则默认为’gbk’且无法对汉字等字符获取。
errors ：可选参数，指定如何处理编码错误。常见值包括：
》 ‘strict’ （默认）：在遇到编码错误时抛出异常。
》 ‘ignore’ ：忽略编码错误。
》 ‘replace’ ：用替代字符替换错误字符。
newline ：可选参数，指定如何处理换行符。在文本模式下使用，常见值包括：
》 None （默认）：自动识别换行符。
》 ‘’ ：空字符串，不处理换行符。
》 ‘\n’ ：将换行符统一为Unix风格。
》 ‘\r’ ：将换行符统一为Mac风格。
》 ‘\r\n’ ：将换行符统一为Windows风格。
closefd ：可选参数，指定是否关闭文件描述符。默认值为 True 。
opener ：可选参数，指定一个自定义的文件打开器。默认值为 None 。

open() 函数返回一个文件对象（ file object ），支持以下常用方法：

read() ：读取文件的全部内容为一个字符串。打开文件格式mode为读才行；
readline() ：读取文件的一行。打开文件格式mode为读才行；
readlines() ：读取文件的所有行并返回一个列表。打开文件格式mode为读才行；
write() ：写入字符串到文件。打开文件格式mode为写才行；
writelines() ：写入一个字符串列表内容到文件。打开文件格式mode为写才行；
seek() ：移动文件指针到指定位置。
tell() ：获取文件指针的当前位置。
close() ：关闭文件。

在这里插入图片描述

file1 = open("C:\\Users\\admin\\Desktop\\demo123.txt",encoding='utf-8', mode="r")  
# "r" 表示以只读模式打开文件
content1 = file1.readline()  # 读取文件首行
# readline(n),若 0≤n<首行字符数，按照n字符显示，其他则完整显示首行
file1.close()    # 关闭文件
print(content1)  # 展示文件内容   输出：12345

file1 = open("C:\\Users\\admin\\Desktop\\demo123.txt",encoding='utf-8', mode="r")  
# "r" 表示以只读模式打开文件
content1 = file1.readlines()  # 读取文件的所有行并返回一个列表,换行符也算在列表中；
file1.close()
print(content1)  # 展示文件内容  
# 输出：['12345\n', '567890\n', '‘’‘’一二三四五六\n', 'asdasasd']

文件的
文件定位 f.seek()
文件的读取、写入、追加

8.2 基于文件的数据分析

对数据文件的读取和遍历
词频分析
第三方库jieba和中文词频分析
第三方库wordcloud和词语可视化

九、函数

在Python中，函数是一种封装了特定功能的代码块，可以被重复调用。函数的使用极大地提高了代码的可读性、可维护性和复用性。

9.1 函数的定义与调用

函数的定义和调用是Python编程中非常重要的概念。

9.1.1、函数的定义

函数的定义使用 def 关键字，其基本语法如下：

def 函数名(参数列表):
	"""函数文档字符串（可选）"""
    函数体
    return 返回值（可选）

# 示例：
def greet(name):	
    """打印问候语"""
    print(f"Hello, {name}!")

Python函数定义基本语法解析：

函数名：必须遵循Python变量的命名规则（只能包含字母、数字和下划线，且不能以数字开头）。
函数名应具有描述性，能够清晰地表明函数的功能。
参数列表：是函数接收的输入值，可以是任意类型，包括数字、字符串、列表等。
参数类型可以是位置参数、关键字参数、默认参数、可变参数等。
》• 位置参数：按顺序传递参数，函数调用时参数的顺序必须与定义时一致。
》• 关键字参数：通过参数名指定参数值，调用时可以不按顺序传递参数。
》• 默认参数：在函数定义时为参数指定默认值，调用时如果未传递该参数，则使用默认值。
》 • 可变参数：允许函数接收任意数量的参数，分为可变位置参数（ *args ）和可变关键字参数（ **kwargs ）。
函数体：函数体是函数的具体实现代码，可以包含任意数量的语句。
函数体必须缩进，通常使用4个空格作为缩进
返回值：return 语句用于返回函数的结果，可以返回任意类型的值，也可以不返回任何值（即返回 None ）
如果函数没有 return 语句，则默认返回 None

9.1.2、函数的调用（参数的传递）

函数的调用：函数定义后，可以通过函数名和参数列表来调用它。
调用函数的基本语法如下：

返回值 = 函数名(参数列表)

调用无参数函数：如果函数没有参数，调用时只需写函数名并加上括号即可。

def greet():
    print("Hello, world!")

greet()  # 调用函数  输出：Hello, world!

调用有参数函数（位置参数）：如果函数有参数，调用时需要传递相应的参数值。

def add(a, b):
    return a + b

result = add(3, 5)  # 3和5是位置参数
print(result)  # 输出8

关键字参数调用：使用关键字参数调用函数时，可以通过参数名指定参数值，调用时参数的顺序可以与定义时不同。

def person(name, age):
    print(f"Name: {name}, Age: {age}")

person(age=25, name="Alice")  # 使用关键字参数调用 输出：Name: Alice, Age: 25

默认参数调用：如果函数有默认参数，调用时可以不传递该参数，此时将使用默认值。

def power(base, exponent=2):
    return base ** exponent

print(power(3))  # 输出9，使用默认值exponent=2
print(power(3, 3))  # 输出27，传递了exponent=3

可变参数调用

# 可变位置参数：使用 *args 接收任意数量的位置参数，args 是一个元组。
# 可变关键字参数：使用 **kwargs 接收任意数量的关键字参数，kwargs 是一个字典。
def print_args(*args):
    for arg in args:
        print(arg,end='*')
print_args(1, 2, 3, "hello")  # 调用可变位置参数函数
# 输出：1*2*3*hello*

def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_kwargs(name="Bob", age=30)  # 调用可变关键字参数函数
# name和age为key,"Bob",30为value;
# name: Bob
# age: 30

9.2 函数的作用域

1、函数的作用域：是指变量可以被访问的范围。
Python中主要有以下几种作用域：
• 局部作用域：在函数内部定义的变量，只能在该函数内部访问。
• 全局作用域：在函数外部定义的变量，可以在整个程序中访问。
• 嵌套作用域：如果函数内部定义了另一个函数，内部函数可以访问外部函数的变量。
• 内置作用域：Python内置的变量和函数，如 len() 、 str() 等。

2. 在函数内部访问变量时，Python会按照以下顺序查找变量：

局部作用域（Local）
嵌套作用域（Enclosing）
全局作用域（Global）
内置作用域（Built - in）
如果需要在函数内部修改全局变量，需要使用 global 关键字

x = 10
def modify_global():
    global x	# 使用 global 关键字，在函数内部修改为全局变量
    x = 20
modify_global()
print(x)  # 输出20

9.3 匿名函数

匿名函数（lambda函数）：
Python中可以使用 lambda 关键字定义匿名函数，其语法如下：

lambda 参数列表: 表达式

# 例如：
add = lambda x, y: x + y
print(add(2, 3))  #5 输出

匿名函数通常用于简单的操作，例如作为高阶函数的参数。

def apply_function(func, a, b):  # 三个参数，函数作为参数1
    return func(a, b)  # 返回值为：参数2、参数3作为参数1函数的参数值得到结果；

result = apply_function(lambda x, y: x * y, 2, 3) # 匿名函数作为参数1，
print(result)  # 输出：6

9.4 函数的文档字符串

在函数定义时，可以使用三引号（ “”" ）添加文档字符串，用于描述函数的功能、参数和返回值等信息。文档字符串可以通过 help() 函数或 .doc 属性查看。

def add(a, b):
    """
    This function adds two numbers.
    
    Parameters:
    a (int): The first number.
    b (int): The second number.
    
    Returns:
    int: The sum of a and b.
    """
    return a + b

print(add.__doc__)  # 查看文档字符串
help(add)  # 查看函数的帮助信息

9.5 函数的递归

递归是Python中一种强大的编程技术，它允许函数调用自身来解决问题。

递归通常用于解决可以分解为更小子问题的问题，例如计算阶乘、斐波那契数列、树的遍历等。

递归函数通常包含两个主要部分：基准情况（Base Case）和递归步骤（Recursive Step）。

9.5.1 基准情况（Base Case）

基准情况是递归函数的终止条件，它是一个简单的、可以直接求解的情况。如果没有基准情况，递归函数可能会无限调用自身，导致栈溢出错误（ RecursionError ）。

9.5.2 递归步骤（Recursive Step）

递归步骤是函数调用自身的过程，每次调用都会将问题分解为更小的子问题，直到达到基准情况。

9.5.3 递归函数的结构

递归函数的基本结构如下：

def recursive_function(parameters):
    if 基准情况:
        return 基准结果
    else:
        return 递归调用(更小的子问题)

9.5.4 示例：计算阶乘

阶乘是一个经典的递归问题。 n! （n的阶乘）定义为 n * (n-1) * (n-2) * … * 1 ，其中 0! = 1 。

def factorial(n):
    if n == 0:  # 基准情况,输入0，则阶乘为1
        return 1
    else:    # 其他情况，输入非0时，执行阶乘
        return n * factorial(n - 1)  # 递归调用
print(factorial(5))  # 输出：120

# 尾递归优化阶乘计算
# 尾递归是指递归调用是函数的最后一个操作。Python本身不支持尾递归优化，但可以通过手动转换为迭代来实现。
def factorial(n, acc=1):  # 尾递归实现
    if n == 0:
        return acc
    else:
        return factorial(n - 1, n * acc)
print(factorial(5))  # 输出：120

9.5.5 示例：斐波那契数列

斐波那契数列是一个数列，其中每个数字是前两个数字的和： 0, 1, 1, 2, 3, 5, 8, 13, … 。
斐波那契数列的定义为：
• F(0) = 0
• F(1) = 1
• F(n) = F(n-1) + F(n-2) ，对于 n > 1

def fibonacci(n):
    if n == 0:  # 基准情况1
        return 0
    elif n == 1:  # 基准情况2
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)  # 递归调用
print(fibonacci(6))  # 输出：8

9.5.6. 递归的优缺点

优点
• 简洁性：递归代码通常更简洁，逻辑更清晰，易于理解。
• 适用性：递归非常适合解决可以分解为更小子问题的问题，如树的遍历、分治算法等。
缺点
• 性能问题：递归可能会导致大量的重复计算，效率较低。例如，斐波那契数列的递归实现时间复杂度为 O(2^n) 。
• 栈溢出：递归调用过深可能会导致栈溢出错误（ RecursionError ）。Python的默认递归深度限制为1000左右，可以通过 sys.setrecursionlimit() 调整。

9.6 函数的高级应用

9.6.1 函数作为参数

函数可以作为参数传递给另一个函数，例如：

def apply_function(func, value):
    return func(value)

def square(x):
    return x * x

result = apply_function(square, 4)
print(result)  # 输出16

9.6.2 函数作为返回值

函数也可以作为返回值，例如：

def get_function():
    def add(x, y):
        return x + y
    return add

my_function = get_function()
print(my_function(2, 3))  # 输出5