持续不定期更新,以下内容主要供学习使用
文章目录
一、基本规则
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-最低 |
* | 乘 | 5*2=10 或 5.5*2=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-高 |
** | 幂运算 | 5**2=25 或 5.5**2.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=a*b |
/= | 浮点除法等 | a/=b 等价于 a=a/b |
//= | 整除等 | a//=b 等价于 a=a//b |
%= | 取模等 | a%=b 等价于 a%a+b |
**= | 幂等 | a**=b 等价于 a=a**b |
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 | 可以通过键来修改对应的值;若键是未重复的,则添加一个键值对 |
+ 或 * | ||
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