python-基于python程序设计基础第二版

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

文章目录


一、基本规则

1. 基本词法单位

  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. 需要将输入的字符串转为其他类型,需要调用对应的转换函数。

二、数值类型

  1. 内置函数 type(object) 可以返回 object 的数据类型。
  2. 内置函数 isinstance(obj,class) 可以判断测试对象obj是否为指定的class类型。
  3. 内置函数 id(object) 可以确切的知道变量引用的内存地址。
  4. 数值类型是不可变对象。所谓不可变,是指不能在原地修改对象的内容。
>>> 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)

  1. 定义 :不带小数部分的数值
  2. python中整数的特性 : 没有长度限制,可以书写和计算几百位的大整数(9位就是亿单位的计算了
  3. 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)

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

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

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

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

2. 3 布尔值(bool)

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

2. 3 复数(complex)

  1. 复数是python中内置的数据类型,使用 1j 表述 -1 的平方根。
  2. 复数对象有两个属性,用于查看实部(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 字符串规则

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

3. 2 字符串界定符

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

  • 单引号 ’
  • 双引号 ” (是一个字符,不是两个单引号)
  • 三引号’’’/ ”””(是三个字符,可以是3个单引号或者3个双引号)
  1. 单引号中可以使用双引号,双引号中也可以使用单引号,这样就可以不使用转义字符。
  2. 单引号中使用单引号,双引号中使用双引号,这样必须使用转义字符。
s='ddd"ss"fdfsd'
print(s)  # 输出:  ddd"ss"fdfsd

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

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

  1. 转义符是一些特殊的字符。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
  1. 原始字符串:使用原字符 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. 字符串大小写转换

序号函数名功能用法
1str.upper()将字符串中的所有字符转换为大写
2str.lower()将字符串中的所有字符转换为小写
3str.swapcase()字符串中的大写字符转换为小写,小写字符转换为大写
4str.capitalize()字符串的第一个字符转换为大写,其余字符转换为小写
5str.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. 字符串查找和替换

序号函数名功能用法
1str.find(sub[, start[, end]])返回子字符串sub在字符串中的起始索引值,如果未找到则返回 -1区间为左闭右开[start,end),end省略时则到末尾
2str.rfind(sub)返回子字符串sub在字符串中的最后索引值,如果未找到则返回 -1
3str.index(sub[, start[, end]])与 find() 相同,仅未找到子字符串时会报错抛出 ValueError建议使用find(),不会报错
4str.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. 字符串分割、转为字符串

序号函数名功能用法
1str.split(sep=None, maxsplit=-1)根据分隔符 sep 将字符串分割为多个子字符串,返回一个列表maxsplit 指定最大分割次数(可选)s.split() 默认按空白字符分割
2str.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. 字符串格式化

序号函数名功能用法
1str.format(nane1, nane2…)使用占位符 {} 和 .format() 方法进行字符串格式化.format(name1, name2) 与前面字符串有无空格均可以
2f-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. 字符串检查

序号函数名功能用法
1str.isdigit()检查字符串是否只包含数字
2str.isalpha()检查字符串是否只包含字母
3str.isalnum()检查字符串是否只包含字母和数字
4str.isspace()检查字符串是否只包含空白字符
5str.startswith(prefix[, start[, end]])检查字符串是否以指定的前缀开头
6str.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. 字符串对齐和填充

序号函数名功能用法
1str.center(width[, fillchar])将字符串居中对齐,并用指定字符(默认为空格)填充到指定宽度
2str.ljust(width[, fillchar])将字符串左对齐,并用指定字符填充到指定宽度
3str.rjust(width[, fillchar])将字符串右对齐,并用指定字符填充到指定宽度
4str.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. 字符串去除空白
空白字符:如空格、制表符、换行符等

序号函数名功能用法
1str.strip([chars])移除字符串两端的空白字符或指定字符对两边都处理
2str.lstrip([chars])移除字符串左侧的空白字符或指定字符仅对左侧处理
3str.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. 字符串的子串出现次数

序号函数名功能用法
1str.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 说明

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

在科学计数法中,为了使公式简便,可以用带“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() 函数-将浮点型数据 圆整 为整型

  1. python 采用的是 “银行家圆整” :将小数部分采用 “ 四舍六入五留双 ” 。即个位为偶数,则舍弃;个位为基数,则进位;使整数为偶数。
print(round(36.5555))
print(round(37.55555))
>>>
36
38

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

  1. 数值0和空字符串转换的布尔型的值为Flase。
  2. 除了上述的类型值,其他转换的布尔型值均为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() 函数-整数 与 字符 之间的转换

  1. chr() 将一个整数按照 ‘ ASCII ’ 码转换成对于的字符。
  2. 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() 函数-返回传入字符串的表达式的结果。

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

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

五、基本运算和表达式

5.1 运算符

  1. Python 支持算术运算符、赋值运算符、关系运算符、逻辑运算符等。
  2. 运算符分类(按操作数数目):
    单目运算符:只要一个操作数,负(-)、逻辑非(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.54-最低
-5-2=3 或 5.5-2=3.54-最低
*5*2=10 或 5.5*2=11.03-低
/浮点除法5/2=2.5 或 5.5/2=2.753-低
//整除,返回商5//2=2 或 5.5//2=2.03-低
%整除,返回余数,也称取模5%2=1 或 5.5%2.0=1.53-低
+单目+x=-7 则 +x为-72-高
-单目-x=-7 则 -x为72-高
**幂运算5**2=25 或 5.5**2.0=30.251-最高

余数的正负号和除数的符号保持一致
-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 返回 False3-低
and逻辑与运算符,只有两个都为真,结果才为真True or True 返回 True2-中
not逻辑非运算符,单目运算符,反转操作数的逻辑状态not True 返回 False1-高

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 中的一个内置函数,用于生成一个整数序列,常用于循环控制中。
特点

  1. 惰性生成: range() 生成的是一个惰性序列,不会一次性生成所有值,而是根据需要逐个生成。这使得它在处理大范围的整数时非常高效。
  2. 不可变性: range() 生成的序列是不可变的,不能修改其中的值。
  3. 内存友好:由于是惰性生成, range() 不会占用大量内存,即使生成的序列范围很大。
# 如果需要将range()生成的序列转换为列表,可以使用list()函数:
numbers = list(range(5))
print(numbers)  # 输出:[0, 1, 2, 3, 4]
  1. 单参数形式:range(stop) :从 0 开始到 stop (不包括 stop )的整数序列,即[0,stop)
    例如: range(5) 生成 [0, 1, 2, 3, 4]
  2. 双参数形式:range(start, stop) :从 start 开始到 stop (不包括 stop )的整数序列,即[start,stop)
    例如: range(2, 7) 生成 [2, 3, 4, 5, 6] 。
  3. 三参数形式: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

  1. break :用于提前退出当前循环。
  2. continue :用于跳过当前循环的剩余代码,直接进入下一次迭代。
  3. 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])
支持列表方法:增、删、改、查

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

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

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

元组的常用操作

序号名称简介
1len(t)返回元组的长度
2for i in t: print(i)使用 for 循环遍历元组中的元素
3t3=t1+t2使用 + 操作符连接两个元组,返回一个新元组
4t1 = 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{}创建字典
2dict() 函数创建使用 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、字典中的值的处理:增、查、改

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

序号名称简介
1del dict1[“name1”]删除指定键值对,如果键不存在,会报错抛出 KeyError
2vari1 = dict1.pop(“name1”)删除键对应的键值对,并返回键对应的值
3dict1.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、返回字典中的视图:键、值、键值对

序号名称简介
1key1= dict1.keys()返回字典的键视图
2valu1= dict1.values()返回字典的值视图
3item1 = 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、字典的遍历:键、值、键值对

序号名称简介
1for i in person.keys():print(i)遍历字典的键
2for i in person.values(): print(i)遍历字典的值
3for 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{}使用花括号创建集合,但不能用{}创建空集合,因为{}表示空字典
2set()函数使用 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、集合的基本操作:增、删、无改、无查

序号名称简介
1my_set.add(value)添加一个元素到集合中
2my_set.remove(3)删除指定元素。如果元素不存在,会抛出 KeyError
3my_set.discard(5))删除指定元素。如果元素不存在,不会抛出异常
4element = my_set.pop()随机删除一个元素,并返回该元素
5my_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、集合运算:并、交、差和对称差集

序号名称简介说明
1set1 | set2 或 set1.union(set2)并集:| 运算符或 union() 方法2个集合相加,且重复显示1个
2set1 & set2 或 set1.intersection(set2)交集:& 运算符或 intersection() 方法2个集合相交,且仅仅显示重复的1个
3set1 - set2 或 set1.difference(set2)差集: - 运算符或 difference() 方法集合1 减去 集合2
4set1 ^ 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、集合的判断:子集、超集、没有交集和更新集合

序号名称简介
1set1.issubset(set2)判断set1是否为set2的子集,set1 ⊆ set2,正确为True,错误为False
2set1.issuperset(set2)判断set1是否为set2的超集(与子集是互为逆关系),set1 ⊇ set2,正确为True,错误为False
3set1.isdisjoint(set3)判断两个集合是否没有交集,他们不存在相同的为True,存在相同为False
4set1.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循环

序号名称简介
1for 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、 函数的调用(参数的传递)

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

返回值 = 函数名(参数列表)
  1. 调用无参数函数:如果函数没有参数,调用时只需写函数名并加上括号即可。
def greet():
    print("Hello, world!")

greet()  # 调用函数  输出:Hello, world!
  1. 调用有参数函数(位置参数):如果函数有参数,调用时需要传递相应的参数值。
def add(a, b):
    return a + b

result = add(3, 5)  # 3和5是位置参数
print(result)  # 输出8
  1. 关键字参数调用:使用关键字参数调用函数时,可以通过参数名指定参数值,调用时参数的顺序可以与定义时不同。
def person(name, age):
    print(f"Name: {name}, Age: {age}")

person(age=25, name="Alice")  # 使用关键字参数调用 输出:Name: Alice, Age: 25
  1. 默认参数调用:如果函数有默认参数,调用时可以不传递该参数,此时将使用默认值。
def power(base, exponent=2):
    return base ** exponent

print(power(3))  # 输出9,使用默认值exponent=2
print(power(3, 3))  # 输出27,传递了exponent=3
  1. 可变参数调用
# 可变位置参数:使用 *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会按照以下顺序查找变量:

  1. 局部作用域(Local)
  2. 嵌套作用域(Enclosing)
  3. 全局作用域(Global)
  4. 内置作用域(Built - in)
    如果需要在函数内部修改全局变量,需要使用 global 关键字
x = 10
def modify_global():
    global x	# 使用 global 关键字,在函数内部修改为全局变量
    x = 20
modify_global()
print(x)  # 输出20

9.3 匿名函数

  1. 匿名函数(lambda函数):
    Python中可以使用 lambda 关键字定义匿名函数,其语法如下:
lambda 参数列表: 表达式

# 例如:
add = lambda x, y: x + y
print(add(2, 3))  #5 输出
  1. 匿名函数通常用于简单的操作,例如作为高阶函数的参数。
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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值