【合集】Python基础知识【第二版】

更新部分

1. 为了避免冗长的代码影响大家观感，将部分案例拆开
2. 增加部分知识点，为了减少大家阅读的负担，尽可能使用短句子，但知识点不可能全覆盖，笔者不是写书，就算是写书也不可能全面，请同学们自行去补充
3. 增加部分案例，但是目前笔者能力有限，大部分都是书上的案例直接拉过来，并且为了不影响观感案例不会太多，大部分为抛砖引玉，请同学们灵活变通

编程基础

基本输入输出

print("Hello World");Name = input('请输入您的姓名：');print(Name);

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.pyHello World请输入您的姓名：AliceAlice进程已结束,退出代码0

变量

print("-------------输出语句-------------");message="Hello Python world";print(message);print("-------------首字母大写-------------");name="ada lovelace";print(name.title());print("-------------大小写-------------");print(name.upper());print(name.lower());print("-------------拼接字符串-------------");first_name = "ada"last_name = "lovelace"full_name = first_name + " " + last_nameprint(full_name);print("-------------添加空白-------------");print("\tPython");print("Languages:\nPython\nC\nJavaScript");print("-------------删除空白-------------");print("Hello ".rstrip());print("-------------运算-------------");print(2+3);print(3-2);print(2*3);print(3/2);print(3**2);print(3**3);print(10**6);print(0.1+0.1);print(0.2+0.2);print("------------注释-------------");# 测试注释

-------------输出语句-------------Hello Python world-------------首字母大写-------------Ada Lovelace-------------大小写-------------ADA LOVELACEada lovelace-------------拼接字符串-------------ada lovelace-------------添加空白-------------	PythonLanguages:PythonCJavaScript-------------删除空白-------------Hello-------------运算-------------5161.592710000000.20.4------------注释-------------Process finished with exit code 0

1. 运行文件hello_world.py时，末尾的.py指出这是一个Python程序，因此编辑器将使用Python解释器来运行它
2. 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
3. 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
4. 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，
5. 变量名应既简短又具有描述性。
6. 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0
7. 在Python中，注释用井号（ # ）标识。井号后面的内容都会被Python解释器忽略

基本运算符

print("-----------------算数运算符-----------------");#+ 加，两个对象相加#- 减，得到负数或是一个数减去另一个数#* 乘，两个数相乘或是返回一个被重复若干次的字符串#x/y 除，x 除以 y#% 取模，返回除法的余数#// 取整除，返回商的整数部分#x**y 幂print(12+13);print(12-13);print(12*13);print(12/13);print(12/13);print(12%13);print(12//13);print(12**13);print("-----------------比较运算符-----------------");#== 等于，比较对象是否相等 （a == b）返回 False#!= 不等于，比较两个对象是否不相等 （a != b）返回 True#<> 不等于，比较两个对象是否不相等 （a <> b）返回 True。这个运算符类似 !=#x > y 大于，返回 x 是否大于 y （a > b）返回 False#x < y小于，返回 x 是否小于 y。所有比较运算符返回 1表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意这些变量名的大小写（a < b）返回 True#x >= y 大于等于，返回 x 是否大于等于 y （a >= b）返回 False#x <= y 小于等于，返回 x 是否小于等于 y （a <= b）返回 Trueprint(12>13);print(12>=13);print(12<13);print(12<=13);print(12!=13);print(12==13);print("-----------------赋值运算符-----------------");#= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c#+= 加法赋值运算符 c += a 等效于 c = c + a#-= 减法赋值运算符 c-= a 等效于 c = c-a#*= 乘法赋值运算符 c *= a 等效于 c = c * a#/= 除法赋值运算符 c /= a 等效于 c = c / a#%= 取模赋值运算符 c %= a 等效于 c = c % a#**= 幂赋值运算符 c **= a 等效于 c = c ** a#//= 取整除赋值运算符 c //= a 等效于 c = c // aa=21;b=10;c=0;c+=a;print(c);c*=b;print(c);c/=a;print(c);c-=b;print(c);c=2;c%=a;print(c);c**=a;print(c);c//=a;print(c);print("-----------------位运算符-----------------");#& 按位与运算符 （a & b）输出结果 12，二进制解释：0000 1100#| 按位或运算符 （a | b）输出结果 61，二进制解释：0011 1101#^ 按位异或运算符 （a ^ b）输出结果 49，二进制解释：0011 0001#～ 按位取反运算符#（～a）输出结果?61，二进制解释：1100 0011，#在一个有符号二进制数的补码形式#<< 左移动运算符 a << 2 输出结果 240，二进制解释：1111 0000#>> 右移动运算符 a >> 2 输出结果 15，二进制解释：0000 1111a=60;b=13;c=0;c=a&b;print(c);c=a|b;print(c);c=a^b;print(c);c=~a;print(c);c=a<<2;print(c);c=a>>2;print(c);print("-----------------逻辑运算符-----------------");#x and y 布尔“与”，如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值#x or y 布尔“或”，如果 x 是 True，它返回 True，否则它返回 y 的计算值#x not y 布尔“非”，如果 x 为 True，返回 False。如果 x 为 False，它返回 Truea=10;b=20;print(a and b);a=0;print(a and b);

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-----------------算数运算符-----------------25-11560.92307692307692310.9230769230769231120106993205379072-----------------比较运算符-----------------FalseFalseTrueTrueTrueFalse-----------------赋值运算符-----------------2121010.00.02209715299864-----------------位运算符-----------------126149-6124015进程已结束,退出代码0

1. 截取除法（//）的结果是整数，并且整数和浮点数均可应用。
2. 除法（/）：在 Python 2.X 中，如果操作数是整数，除法结果取整数，但在 Python 3.X中，结果是浮点数。
3. 对浮点数来说，取余运算的结果是“a // b”的浮点数余数，即“a –（a//b）*b”。
4. 对于复数，取余和截取除法是无效的。
5. 对于比较运算符，可以有更复杂的写法，如：“a<b<c”，这相当于“a<b and b<c”，又如：“a<b>c”，相当于“a<b and b>c”，“a==b>c”相当于“a==b and b>c”。
6. 不允许对复数进行比较。
7. 只有当操作数是同一类型时，比较才有效。对于内置的数字对象，当两个操作数类型不一致时，Python 将进行类型的强制转换，例如，当操作数之一为浮点数时，则将另一个操作数也转换为浮点。
8. not a：如果 a 为 False，则返回 1，否则返回 0。
9. a and b：如果 a 为 False，则返回 a，否则返回 b。
10. a or b：如果 a 为 False，则返回 b，否则返回 a。
11. 身份运算符用 is、is not 表示，用于比较两个对象的存储单元。is not 是特殊的比较运算符，比较的是对象的存储单元，实际进行的是存储单元的比较。
12. 存储单元地址可以使用函数 id( )进行查看，存储单元取值也可以采用函数 id( )。

控制流程

选择结构

print("-------------检查是否相等-------------");car='bmw';print(car=='bmw');print(car=='audi');print(car=='BMW');print(car.upper()=='BMW');age=18;print(age==18);print(age>=18);print(age<=18);print(age>18);print(age<18);age_0 = 22;age_1 = 18;print(age_0 >= 21 and age_1 >= 21);print(age_0 >= 21 or age_1 >= 21);print("-------------if语句-------------");age = 19if age >= 18:    print("You are old enough to vote!");        age=17    if age>=18:        print("You are old enough to vote!");    else:        print("Sorry you are too young");                age = 12        if age < 4:            print("Your admission cost is $0.")        elif age < 18:            print("Your admission cost is $5.")        else:            print("Your admission cost is $10.")                        age = 12            if age < 4:                price = 0            elif age < 18:                price = 5            elif age < 65:                price = 10            elif age >= 65:                price = 5print("Your admission cost is $" + str(price) + ".")

-------------检查是否相等-------------TrueFalseFalseTrueTrueTrueTrueFalseFalseFalseTrue-------------if语句-------------You are old enough to vote!Sorry you are too youngYour admission cost is $5.Your admission cost is $5.Process finished with exit code 0

1. 在Python中检查是否相等时区分大小写
2. 要判断两个值是否不等，可结合使用惊叹号和等号（ != ）
3. 要检查是否两个条件都为 True ，可使用关键字 and 将两个条件测试合而为一
4. 关键字 or 也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。
5. 在 if 语句中，缩进的作用与 for 循环中相同。如果测试通过了，将执行 if 语句后面所有缩进的代码行，否则将忽略它们。
6. 经常需要检查超过两个的情形，为此可使用Python提供的 if-elif-else 结构

循环结构

print("-------------函数input()的工作原理-------------");message = input("Tell me something, and I will repeat it back to you: ")print(message)print("-------------编写清晰的程序-------------");name=input("Please enter your name:");print("Hello,"+name+"!");print("-------------求模运算符-------------");print(4%3);print("-------------while循环-------------");current_number = 1while current_number <= 5:    print(current_number)    current_number += 1print("-------------让用户选择何时退出-------------");prompt = "\nTell me something, and I will repeat it back to you:"prompt += "\nEnter 'quit' to end the program. "message = ""while message != 'quit':    message = input(prompt)    print(message)print("-------------break语句-------------");prompt = "\nPlease enter the name of a city you have visited:"prompt += "\n(Enter 'quit' when you are finished.) "while True:    city = input(prompt)    if city == 'quit':        break    else:        print("I'd love to go to " + city.title() + "!")

-------------函数input()的工作原理-------------Tell me something, and I will repeat it back to you: Hello WorldHello World-------------编写清晰的程序-------------Please enter your name:AliceHello,Alice!-------------求模运算符-------------1-------------while循环-------------12345-------------让用户选择何时退出-------------Tell me something, and I will repeat it back to you:Enter 'quit' to end the program. Hello WorldHello WorldTell me something, and I will repeat it back to you:Enter 'quit' to end the program. quitquit-------------break语句-------------Please enter the name of a city you have visited:(Enter 'quit' when you are finished.) ShangHaiI'd love to go to Shanghai!Please enter the name of a city you have visited:(Enter 'quit' when you are finished.) quitProcess finished with exit code 0

1. 函数 input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中，以方便你使用。
2. 函数 input() 接受一个参数：即要向用户显示的提示或说明，让用户知道该如何做。
3. 每当你使用函数 input() 时，都应指定清晰而易于明白的提示，准确地指出你希望用户提供什么样的信息——指出用户该输入任何信息的提示都行
4. 使用函数 input() 时，Python将用户输入解读为字符串
5. break 语句用来终止整个循环（当前循环），即循环条件没有为 False 或者序列还没被完全递归完，也会停止执行循环语句。
6. break 语句用在 while 和 for 循环中。
7. 如果使用嵌套循环，break 语句将停止执行当前的循环，并开始执行下一行代码。
8. continue 语句用来跳出本次循环，而 break 语句用于跳出整个循环。
9. continue 语句用来告诉 Python 跳过当前循环的剩余语句，然后继续进行下一轮循环。
10. Python 的 pass 语句是空语句，是为了保持程序结构的完整性。pass 语句不做任何事情，一般作占位语句。
11. 在 Python 中，while … else 表示这样的意思，while 中的语句和普通的没有区别，else中的语句会在循环正常执行完（即 while 语句不是通过 break 跳出而中断的）的情况下执。
12. 在 Python 中，for … else 表示这样的意思，for 中的语句和普通的语句没有区别，else 中的语句会在循环正常执行完（即 for 语句不是通过 break 跳出而中断的）的情况下执行。

数据类型

字符串

print("-------------字符串操作-------------");#coding=utf-8str = 'Hello World!'print(str) # 输出完整字符串print(str[0]) # 输出字符串中的第一个字符print(str[2:5]) # 输出字符串中第三个至第五个之间的字符串print(str[2:]) # 输出从第三个字符开始的字符串print(str * 2) # 输出字符串两次print(str + "TEST") # 输出连接的字符串print("-------------格式化输出-------------");x="欢迎您，%s，当前第%d 次访问! "y=x%("小明",1)#y=("欢迎您，%s，当前第%d 次访问! "%("小明",1))，以上两行可以合并为这一行。print(y)print("-------------三引号-------------");hi = '''hithere'''print(hi) # str()

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------字符串操作-------------Hello World!Hllollo World!Hello World!Hello World!Hello World!TEST-------------格式化输出-------------欢迎您，小明，当前第1 次访问! -------------三引号-------------hithere进程已结束,退出代码0

1. 字符串是 Python 中最常用的数据类型。我们可以使用引号来创建字符串。
2. 字符串在内存中存储，每个字符都对应一个编号，常见的编号以 0 开始，依次加 1Python 的字符串列表有两种取值顺序：
3. 从左到右索引默认是从 0 开始的，最大范围是字符串长度减去 1。
4. 从右到左索引默认是从-1 开始的，最大范围是字符串开头。
5. 如果要取得一段子串的话，用变量[头下标：尾下标]截取相应的字符串，其中下标是从 0开始算起的，可以是正数或负数，下标可以为空，表示取到头或尾。
6. + 字符串连接 a + b 输出结果：HelloPython
7. * 重复输出字符串 a*2 输出结果：HelloHello
8. [] 通过索引获取字符串中字符 a[1] 输出结果 e
9. [：] 截取字符串中的一部分 a[1:4] 输出结果 ell
10. in 成员运算符，如果字符串中包含给定的字符则返回 True H in a 输出结果 1
11. not in 成员运算符，如果字符串中不包含给定的字符则返回True M not in a 输出结果 1
12. r/R 原始字符串，所有的字符串都是直接按照字面的意思来使用的，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母“r”（可以大小写），与普通字符串有着几乎完全相同的语法
13. % 格式字符串
14. Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用的，单字符的取值方式和字符串相同，只有一个下标值[0]。
15. print( )函数可以采用格式化输出形式：print('格式串'%(对象 1，对象 2，...))
16. 使用 format 格式化输出时，之前同样需要占位，不过此时不采用%占位符，而是采用{}占位，需要在什么位置插入相关数据，则在相关位置插入{}号
17. Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符及其他特殊字符。

列表

print("-------------创建列表-------------");list1 = ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3]print(list1)list2 = list('Python')print(list2)list3 = []print(list3)print("-------------访问列表中的值-------------");print("list1[0]: ", list1[0])print("list2[1:5]: ", list2[1:5])print("-------------列表函数-------------");list1.append('XYZ') #向 list1 增加'XYZ'对象print(list1.count('Python')) #返回'Python'出现次数list1.extend(list2) #将 list2 加到 list1 后面print(list1)list1.remove('XYZ') #删除对象'XYZ'print(list1.pop()) # 删除列表的最后位置上的对象并返回print(list1)

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------创建列表-------------['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3]['P', 'y', 't', 'h', 'o', 'n'][]-------------访问列表中的值-------------list1[0]:  JAVAlist2[1:5]:  ['y', 't', 'h', 'o']-------------列表函数-------------1['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3, 'XYZ', 'P', 'y', 't', 'h', 'o', 'n']n['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3, 'P', 'y', 't', 'h', 'o']进程已结束,退出代码0

1. 用方括号（[]）将一组 Python 对象括起来，Python 对象之间用逗号分隔。
2. 列表操作符包括长度取值、连接、重复、成员检查和迭代检查。
3. 使用下标索引来访问列表中的值，同样可以使用方括号的形式截取字符

元祖

print("-------------创建访问元祖-------------");#coding=utf-8tuple = ( 'Java', 786 , 2.23, 'john', 70.2 )tinytuple = (123, 'john')print(tuple) # 输出完整元组print(tuple[0])# 输出元组的第一个元素print(tuple[1:3]) # 输出第二个至第三个的元素print(tuple[2:])# 输出从第三个开始至列表末尾的所有元素print(tinytuple * 2) # 输出元组两次print(tuple + tinytuple) # 打印组合的元组

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------创建访问元祖-------------('Java', 786, 2.23, 'john', 70.2)Java(786, 2.23)(2.23, 'john', 70.2)(123, 'john', 123, 'john')('Java', 786, 2.23, 'john', 70.2, 123, 'john')进程已结束,退出代码0

1. 创建元组与创建列表一样，只是其用圆括号而已。
2. 访问元组的元素也是通过切片操作实施的，操作与列表一样。
3. 元组中的元素值是不允许修改的
4. 元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组
5. 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着它们可以组合和复制，运算后会生成一个新的元组
6. 因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素
7. 任意无符号的对象，以逗号隔开，默认为元组
8. 元组的不可变性带来的好处。元组的元素不可变，编写程序时，可以利用这个不可性保存数据，不被修改。因为元组不可变，所以元组可以作为字典的关键字使用。
9. 和列表一样，元组也可以嵌套列表或元组。嵌套的子对象的可变性不受元组不可变的限制

字典

print("-------------创建字典-------------");d1 = {} # 空字典d2={"id":10,"tel":123456,"name":"小明"}print(d1)print(d2)print("-------------访问字典-------------");dict2 = {'name': '小明','id':1, 'dept': '计算机'}print(dict2['dept'])print(dict2['name'])print("-------------修改添加字典-------------");dict1 = {'Name':'小明', 'Age':19, 'major':'计算机'};dict1['Age'] = 18; # 字典中有"Age"键，更新现有元素dict1['college'] = "Tech"; # 字典中无"college"键，执行添加操作print("dict1['Age']: ",dict1['Age'])print("dict1['college']: ",dict1['college'])print("-------------删除字典-------------");dict1={"stu_name":"小明","stu_id":1,"stu_age":24}del dict1["stu_id"] # 删除键为"stu_id"的键值对print(dict1)dict1.clear() # 删除所有键值对print(dict1)

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------创建字典-------------{}{'id': 10, 'tel': 123456, 'name': '小明'}-------------访问字典-------------计算机小明-------------修改添加字典-------------dict1['Age']:  18dict1['college']:  Tech-------------删除字典-------------{'stu_name': '小明', 'stu_age': 24}{}进程已结束,退出代码0

1. 列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过顺序偏移存取。
2. 字典用“{ }”标识。字典由索引（键 key）和它对应的值（value）组成。字典由键和对应值成对组成。字典也被称为关联数组或哈希表。
3. 字典是键值对的无序集合。所谓键值对（又称条目、或元素）是指字典中的每个元素由键和值（又称数据项）两个部分组成，键是关键字，值是与关键字有关的数据。通过键可以找到与其有关的值，反过来则不行，不能通过值找键。
4. 字典的定义是：在一对花括号（{、}）之间添加 0 个或多个元素，元素之间用逗号分隔；元素是键值对，键与值之间用冒号分隔；键必须是不可变对象，键在字典中必须是唯一的，值可以是不可变对象或可变对象。
5. 键必须是不可变对象。这是说键必须是可哈希的，也就是说键可以通过哈希函数计算出对应值的存储位置。在字典中，通常将数字对象和字符串对象作为键，并将整数对象和浮点数对象作为同一个键，如整数 1 和浮点数 1.0 是同一个键。元组是不可变对象，原则上是可以作键使用的，但要求元组的元素是数字或字符串。
6. 键在字典中必须是唯一的。如果有同名键存在，系统将用最后一个键值对取代前一个，以保证键的唯一性。
7. 创建字典直接使用{}键入，用 dict( )函数创建字典，用 fromkeys( )方法创建字典。
8. 访问字典里的值，格式简单，采用直接的访问方法，格式如下：<字典>[<键>]也就是“字典对象[key]”，key 如果是字符串，需要加引号；如果是数字，不能加引号。
9. 字典中的元素都是以“键值对（key：value）”的方式存在的。在字典中，要想修改一个元素的值，可根据字典中的键名找到所对应的值，然后直接赋值即可。修改格式如下：字典["键名"]=值
10. 可以删除单一的元素也可以清空字典。单一元素的删除操作：在字典中，元素是以一个键值对方式存在的，删除元素时，取键（key）即可，格式为：del 字典元素
11. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，余下的将被抛弃
12. 键必须不可变，可以用数、字符串或元组充当，但不能用列表或字典

集合

print("-------------创建集合-------------");s = set() # 空集print(s)print(type(s))s = {1,2,3} # 直接写入集合元素print(type(s))s=set(["ABC",'XYZ','xyz','123','1',1,1.0])print(s)s=set(i for i in range(10))print(s)s=frozenset("Python 3.3.3")print(s)s= dict((i,0) for i in {1, 'ABC', 'XYZ', 'xyz', '1', '123'})print(s)s= dict((i,0) for i in frozenset({'n', 'o', 'h', ' ', '.', 'y', 't', 'P', '3'}))print(s)print("-------------访问集合-------------");s = set(['A', 'B', 'C', 'D'])# s = {'A', 'B', 'C', 'D'}print('A' in s)print('a' not in s)for i in s:    print(i,end='\t')print("-------------更新集合-------------");s = set(['A', 'B', 'C', 'D'])s = s|set('Python') # 使用操作符"|"print(s)s.add('ABC') # add()方法print(s)s.remove('ABC') # remove()方法s.update('JAVAEF') # update()方法print(s)

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------创建集合-------------set()<class 'set'><class 'set'>{1, '1', 'xyz', 'XYZ', '123', 'ABC'}{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}frozenset({'t', 'o', 'y', 'n', '3', '.', 'h', ' ', 'P'}){1: 0, '1': 0, 'xyz': 0, 'XYZ': 0, '123': 0, 'ABC': 0}{'t': 0, 'o': 0, 'n': 0, '.': 0, 'y': 0, '3': 0, 'h': 0, ' ': 0, 'P': 0}-------------访问集合-------------TrueTrueB	D	C	A	-------------更新集合-------------{'B', 't', 'o', 'y', 'n', 'D', 'C', 'h', 'P', 'A'}{'B', 't', 'o', 'ABC', 'y', 'n', 'D', 'C', 'h', 'P', 'A'}{'B', 'E', 't', 'o', 'y', 'n', 'J', 'D', 'C', 'h', 'F', 'P', 'V', 'A'}进程已结束,退出代码0D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------创建字典-------------{}{'id': 10, 'tel': 123456, 'name': '小明'}-------------访问字典-------------计算机小明-------------修改添加字典-------------dict1['Age']:  18dict1['college']:  Tech-------------删除字典-------------{'stu_name': '小明', 'stu_age': 24}{}进程已结束,退出代码0

1. 创建集合可使用 set( )和 frozenset( )函数，这两个函数分别用于创建可变集合和不可变集合
2. 访问集合中的元素是指检查元素是否是集合中的成员，或通过遍历方法显示集合内的成员。
3. 集合的更新包括增加、修改、删除集合的元素等。
4. 集合所使用的标准类型操作符，包括成员关系（in 和 not in）、集合相等与不相等（==和!=）两种，判断集合是否同一集合可以通过比较集合是否相等来判断
5. 集合类型专用操作符包括 4 个操作符：并操作符（|）、交操作符（&）、差补操作符（-）、对称差分操作符（^）
6. 复合操作符，有 4 个。4 个复合操作符是集合类型专用符的 4 个操作符（|、&、-和^）分别与赋值符相结合构成增量赋值操作符，它们是：|=、&=、-= 和 ^=

函数

print("-------------定义函数-------------");def print_info():#打印提示信息，返回输入信息    print("欢迎访问学生信息管理系统，请按提示输入操作！")    print("1.添加学生信息")    print("2.删除学生信息")    print("3.修改学生信息")    print("4.查询学生信息")    print("5.浏览学生信息")    print("6.退出系统")print("-------------调用函数-------------");print_info()

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------定义函数--------------------------调用函数-------------欢迎访问学生信息管理系统，请按提示输入操作！1.添加学生信息2.删除学生信息3.修改学生信息4.查询学生信息5.浏览学生信息6.退出系统进程已结束,退出代码0

1. 建立函数的一段程序（这段程序表达函数的功能）就是函数定义。在程序中使用这个函

数称调用这个函数。在程序中可以多次、反复地调用一个定义了的函数。函数必须先定义后

2. 使用（调用）。定义一个由自己想要功能的函数，以下是简单的规则：
3. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号（）。
4. 函数的命名规则和对象变量相同，不能以数字开头，不得与关键字同名。
5. 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
6. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
7. 函数内容以冒号起始，并且缩进。
8. return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
9. 函数的定义格式为：

def <函数名>（<参数表>）：

<函数体>

return 表达式

10. 定义一个函数时只给了函数一个名称，指定了函数里包含的参数和代码块结构。
11. 函数只是一个代码块，本身是不会自动加载执行的，必须要有相关的调用。在面向对象的程序操作中，除了类默认主函数和构造函数，其他函数必须通过编写代码调用后方可执行。一般是程序函数的结构完成以后，通过另一个函数调用执行的。当然，也可以直接从 Python提示符执行。函数的调用方式很简单，通过“函数名（）”就可以完成调用。
12. 函数调用有以下几种方式：【1】函数语句。函数调用单独出现，一般此时不需要函数的返回值，只是要把函数执行一遍完成函数的操作。【2】函数表达式。在表达式中调用函数，此时一般需要函数的返回值。这时函数的返回值被当作一个参与表达式运算的数据对象。【3】函数作参数。可以将函数调用得到的值作为其他函数调用的实际参数。
13. 必备参数须以正确的顺序传入函数。调用时的参数个数必须和声明时的一样。
14. 命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。Python 会跳过不传的参数或者乱序传参，因为 Python 解释器能够用参数名匹配参数值。
15. 定义函数时，可以给函数的参数设置为默认值。也就是说，Python 中，对于形参，还可以使用默认值。如果函数定义中存在带有默认值的参数，该参数及其所有后续参数都是可选的。如果没有给函数定义中的所有可选参数赋值，就会引发 SyntaxError 异常。
16. 如果需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，和上述2 种参数不同，声明时前面需要添加*号

模块

1. 导入模块使用 import 语句和 from…import 语句。导入方法有以下三种。

方法 1：import <库名>

方法 2：import <库名> as <新名字>

方法 3：from <库名> import <函数名>|

2. 想使用 Python 源文件，只需在另一个源文件中执行 import 语句
3. 使用 import math 导入数学模块，此时调用函数时，函数前面需要添加模块名，如 math.sqrt( )。如果模块名字比较长或名称可能重复，或不想直接使用模块名进行调用，这时可以使用 import… as…语句
4. 有时候，需要在默认空间下直接使用某模块的相关函数，此时可以使用 from… import语句。
5. from…import*语句可以导入模块的某些属性，也可以使用“from module import *”导入所有属性。

类和对象

类的创建

print("-------------创建类-------------");class Stu:    name = "张三"print(Stu.name)

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------创建类-------------张三进程已结束,退出代码0

1. 在 Python 中，使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾。类名使用驼峰（CamelCase）命名风格，首字母大写，私有类可用一个下画线开头
2. 在 Python 中，有一些特殊的属性定义，主要是内置类属性。内置类属性包括以下几种。

__dict__：类的属性（包含一个字典，由类的数据属性组成）。

__doc__：类的文档字符串。

__name__：类名。

__module__：类定义所在的模块（类的全名是“__main__.className”，如果类位于一

个导入模块 mymod 中，那么 className.__module__ 等于 mymod）。

__bases__：类的所有父类构成元素（包含了由所有父类组成的元组）。

实例对象

print("-------------实例对象-------------");class Stu:    # '定义一个属性    name = "张三"    age = 19# 创建 Stu 类的对象stu = Stu()print("学生姓名:%s,年龄:%d" % (stu.name, stu.age))

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------实例对象-------------学生姓名:张三,年龄:19进程已结束,退出代码0

1. 程序想要完成具体的功能，仅有类是不够的，需要根据类创建实例对象，通过实例对象完成具体的功能。
2. 实例对象，就是为类创建一个具体的实例化的对象，以使用类的相关属性和方法。
3. Python 中，创建类的实例化对象不需使用 new，可以直接赋值，语法如下：对象名=类名（）

类的方法

print("-------------构造方法------------");class Stu:    # 构造方法    def __init__(self):        self.name = "张三"        self.stuid = 1    def displayCount(self):        print("学生姓名：%s，学号%d" % (self.name, self.stuid))stu = Stu()stu.displayCount()print("-------------析构方法------------");class Stu:    # 构造方法    def __init__(self, name, stuid):        self.name = name        self.stuid = stuid    # 析构方法    def __del__(self):        print("已释放资源")stu = Stu("张三", 1)del stu  # 删除对象 触发析构方法# del stu.name #这是属性的删除 不会触发,整个实例删除是才会触发print("进行垃圾回收")print("-------------封装------------");# coding=utf-8class JustCounter:    __secretCount = 0  # 私有变量    publicCount = 0  # 公开变量    def count(self):        self.__secretCount += 1        self.publicCount += 1        print(self.__secretCount)counter = JustCounter()counter.count()counter.count()print(counter.publicCount)print(counter._JustCounter__secretCount)

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------构造方法------------学生姓名：张三，学号1-------------析构方法------------已释放资源进行垃圾回收-------------封装------------1222进程已结束,退出代码0

1. 构造方法__init__( )是一种特殊的方法，被称为类的构造函数或初始化方法，用来进行一些初始化的操作，在对象创建时就设置好属性。如果用户没有重新定义构造函数，则系统自动执行默认的构造方法。这个方法不需要显式调用，当创建了这个类的实例时就会调用该方法。在构造方法__init__( )中，init 前后用两个下画线开头和结尾，是 Python 内置的方法，用于在对象实例化时对实例进行的初始化工作。
2. _init__( )方法是析构方法，当创建对象后，Python 解释器会调用__init__( )方法。当删除一个对象来释放类所占用的资源时，Python 解释器会调用另外一个方法，也就是析构方法。析构方法__del__( )，使用 del 命令，前后同样用两个下画线开头和结尾。该方法同样不需要显式调用，在释放对象时进行调用，可以进行释放资源的操作
3. 面向对象编程的特性是封装、继承与多态。封装是隐藏属性、方法与方法实现细节的过程。封装是在变量或方法名前加两个下画线，封装后，私有的变量或方法只能在定义它们的类内部调用，在类外和子类中不能直接调用。

类的继承

print("-------------类的继承------------");# coding=utf-8class Parent:  # 定义父类    parentAttr = 100    def __init__(self):        print("调用父类构造函数")    def parentMethod(self):        print("调用父类方法")    def setAttr(self, attr):        Parent.parentAttr = attr    def getAttr(self):        print("父类属性 :", Parent.parentAttr)class Child(Parent):  # 定义子类    def __init__(self):        print("调用子类构造方法")    def childMethod(self):        print("调用子类方法 child method")c = Child()  # 实例化子类c.childMethod()  # 调用子类的方法c.parentMethod()  # 调用父类方法c.setAttr(200)  # 再次调用父类的方法c.getAttr()  # 再次调用父类的方法

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------类的继承------------调用子类构造方法调用子类方法 child method调用父类方法父类属性 : 200进程已结束,退出代码0

1. 继承语法“class 子类名(父类名):”也可写成“class 派生类名(基类名)：”，其中，父类名写在括号中，父类是在类定义时，在元组之中指明的。
2. 在 Python 中继承具有如下一些特点：

【1】在继承中父类的构造（__init__( )方法）不会被自动调用，它需要在其子类的构造中亲自专门调用。

【2】在调用父类的方法时，需要加上父类的类名前缀，且需要带上 self 参数变量，以区别于在类中调用普通函数时并不需要带上 self 参数。

【3】Python 总是首先查找对应类型的方法，如果它不能在子类中找到对应的方法，它才到父类中逐个查找（先在本类中查找调用的方法，找不到才到父类中找）。

3. 如果在继承元组中列了一个以上的类，那么它就被称为“多重继承”。子类的声明，与它们的父类类似，继承的父类列表跟在类名之后

方法重写

print("-------------方法重写------------");# coding=utf-8class Parent:  # 定义父类    def myMethod(self):        print('调用父类方法')class Child(Parent):  # 定义子类    def myMethod(self):        print('调用子类方法')c = Child()  # 子类实例c.myMethod()  # 子类调用重写方法

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------方法重写------------调用子类方法进程已结束,退出代码0

运算符重载

print("-------------运算符重载------------");class Computation():    def __init__(self, value):        self.value = value    def __add__(self, other):        return self.value + other    def __sub__(self, other):        return self.value - otherc = Computation(5)x = c + 5print("重构后加法运算结果是：", x)y = c - 3print("重构后减法运算结果是：", y)

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py-------------运算符重载------------重构后加法运算结果是： 10重构后减法运算结果是： 2进程已结束,退出代码0

1. 类可以重载加减运算、打印、函数调用、索引等内置运算，运算符重载使我们的对象的行为与内置对象的一样。

文件处理

打开关闭文件

#在同一目录下新建文本文件 test.txtf=open("test.txt","r")print(type(f))g=open("test.txt","rb")print(type(g))

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py<class '_io.TextIOWrapper'><class '_io.BufferedReader'>进程已结束,退出代码0

文件读写

#coding=utf-8# 打开一个文件f = open("f.txt", "w")f.write( "人生苦短.\n 我用 Python!\n");# 关闭打开的文件f.close()

1. 必须先用 Python 内置的 open( )函数打开一个文件，创建一个 file 对象，相关的辅助方法才可以调用它进行读写
2. 一个文件被打开后，有一个 file 对象，可以得到有关该文件的各种信息。
3. file.closed如果文件已被关闭返回True，否则返回False
4. file.mode返回被打开文件的访问模式
5. file.name返回文件的名称
6. file.softspace如果用print输出后，必须跟-一个空格符，返回False，否则返回True
7. file 对象的 close( )方法用于刷新缓冲区中任何还没写入的信息，并关闭该文件，这之后便不能再进行写入操作。
8. 当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close( )方法关闭文件是一个很好的习惯
9. 使用 with 语句，执行文件打开操作，实现预定义清理操作，文件在使用后将自动关闭，不再需要书写关闭文件代码。
10. write( )方法可将任何字符串写入一个打开的文件中。需要重点注意的是，Python 字符串可以是二进制数据，而不仅仅是文字。write( )方法不在字符串的结尾添加换行符（'\n'）
11. read( )方法从一个打开的文件中读取一个字符串
12. tell( )方法用于告诉文件内的当前位置；换句话说，下一次的读写会发生在文件开头多字节之后。
13. seek(offset [,from])方法用于改变当前文件的位置，其中，offset 变量表示要移动的字节数，from 变量指定开始移动字节的参考位置。

异常处理

异常

try:    f = open("test.txt", "w")    f.write("异常处理测试!")except IOError:    print("错误: 没找到文件或文件不可用")else:    print("读写成功")    f.close()

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.py读写成功进程已结束,退出代码0

1. BaseException 和 ExceptionBaseException 是顶层的异常，Exception 是 BaseException 的下层异常。
2. NameError这是企图访问一个未申明的变量而引发的 NameError。错误类型是：NameError：name '……' is not defined。
3. ZeroDivisionError当除数为零时，会引发 ZeroDivisionError 异常。错误类型是：ZeroDivisionError：division by zero。
4. SyntaxError程序代码中有语法错误，这种异常是非程序运行时的错误，只能在程序运行前纠错，也就是说，不可能用异常处理该错误。当解释器发现有语法错误时，会引发 SyntaxError 异常。错误类型是：SyntaxError：invalid syntax。
5. IndexError请求的索引超出了序列范围，即当使用序列中不存在的索引时，会引发 IndexError 异常。错误类型是：IndexError：list index out of range。
6. KeyError请求一个不存在的字典关键字。当使用映射中不存在的键时，会引发 KeyError 异常。错误类型是：KeyError：'server'。
7. FileNotFoundError企图打开一个不存在的文件，会引发 FileNotFoundError。错误类型是：FileNotFoundError：[Errno 2] No such file or directory。
8. AttributeError企图访问某对象的不存在的属性，即当尝试访问未知对象属性时，会引发 AttributeError异常。错误类型是：AttributeError："object has no attribute"。所有异常都是基类 Exception 的成员，它们都定义在 exceptions 模块中。

抛出异常

try:    raise IndexErrorexcept:    print("出错了")    raise

D:\工作空间\Python\venv\Scripts\python.exe D:/工作空间/Python/main.pyTraceback (most recent call last):  File "D:/工作空间/Python/main.py", line 2, in <module>    raise IndexErrorIndexError出错了进程已结束,退出代码1

raise 语句

Python 执行 raise 语句时，会引发异常并传递异常类的实例对象。使用 raise 语句能显式

地触发异常，分为三种情况进行处理。

（1）用类名引发异常，创建异常类的实例对象，并引发异常，基本格式如下：

raise 异常类名

raise 语句中，指定异常类名时，创建该类的实例对象，然后引发异常。使用时直接写出类名。例如：

raise IndexError

IndexError 是一个异常类，编码时不实例化，执行时会进行创建。

（2）用异常类实例对象引发异常，引发异常类实例对象对应的异常，基本格式如下：

raise 异常类对象

raise 语句中，使用异常类实例对象引发异常时，通过显式地创建异常类的实例，直接使用该实例来引发异常。例如：

index=IndexError()

raise index

（3）重新引发刚刚发生的异常，基本格式如下：

raise

此时，不带参数的 raise 语句，可以再次引发刚刚发生过的异常，作用就是向外传递异常。