先前版本

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

更新部分

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

编程基础

基本输入输出

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

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

截取除法（//）的结果是整数，并且整数和浮点数均可应用。
除法（/）：在 Python 2.X 中，如果操作数是整数，除法结果取整数，但在 Python 3.X中，结果是浮点数。
对浮点数来说，取余运算的结果是“a // b”的浮点数余数，即“a –（a//b）*b”。
对于复数，取余和截取除法是无效的。
对于比较运算符，可以有更复杂的写法，如：“a<b<c”，这相当于“a<b and b<c”，又如：“a<b>c”，相当于“a<b and b>c”，“a==b>c”相当于“a==b and b>c”。
不允许对复数进行比较。
只有当操作数是同一类型时，比较才有效。对于内置的数字对象，当两个操作数类型不一致时，Python 将进行类型的强制转换，例如，当操作数之一为浮点数时，则将另一个操作数也转换为浮点。
not a：如果 a 为 False，则返回 1，否则返回 0。
a and b：如果 a 为 False，则返回 a，否则返回 b。
a or b：如果 a 为 False，则返回 b，否则返回 a。
身份运算符用 is、is not 表示，用于比较两个对象的存储单元。is not 是特殊的比较运算符，比较的是对象的存储单元，实际进行的是存储单元的比较。
存储单元地址可以使用函数 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=17if age>=18:print(\"You are old enough to vote!\");else:print(\"Sorry you are too young\");age = 12if 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 = 12if age < 4:price = 0elif age < 18:price = 5elif age < 65:price = 10elif 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

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

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

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

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

元祖

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

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

字典

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

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

集合

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

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

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

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

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

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

<函数体>

return 表达式

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

模块

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

方法 1：import <库名>

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

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

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

类和对象

类的创建

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

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

在 Python 中，使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾。类名使用驼峰（CamelCase）命名风格，首字母大写，私有类可用一个下画线开头
在 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

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

类的方法

print(\"-------------构造方法------------\");class Stu:# 构造方法def __init__(self):self.name = \"张三\"self.stuid = 1def displayCount(self):print(\"学生姓名：%s，学号%d\" % (self.name, self.stuid))stu = Stu()stu.displayCount()print(\"-------------析构方法------------\");class Stu:# 构造方法def __init__(self, name, stuid):self.name = nameself.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 += 1self.publicCount += 1print(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

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

类的继承

print(\"-------------类的继承------------\");# coding=utf-8class Parent:  # 定义父类parentAttr = 100def __init__(self):print(\"调用父类构造函数\")def parentMethod(self):print(\"调用父类方法\")def setAttr(self, attr):Parent.parentAttr = attrdef 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

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

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

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

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

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

方法重写

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 = valuedef __add__(self, other):return self.value + otherdef __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

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

文件处理

打开关闭文件

#在同一目录下新建文本文件 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()

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

BaseException 和 ExceptionBaseException 是顶层的异常，Exception 是 BaseException 的下层异常。
NameError这是企图访问一个未申明的变量而引发的 NameError。错误类型是：NameError：name \’……\’ is not defined。
ZeroDivisionError当除数为零时，会引发 ZeroDivisionError 异常。错误类型是：ZeroDivisionError：division by zero。
SyntaxError程序代码中有语法错误，这种异常是非程序运行时的错误，只能在程序运行前纠错，也就是说，不可能用异常处理该错误。当解释器发现有语法错误时，会引发 SyntaxError 异常。错误类型是：SyntaxError：invalid syntax。
IndexError请求的索引超出了序列范围，即当使用序列中不存在的索引时，会引发 IndexError 异常。错误类型是：IndexError：list index out of range。
KeyError请求一个不存在的字典关键字。当使用映射中不存在的键时，会引发 KeyError 异常。错误类型是：KeyError：\’server\’。
FileNotFoundError企图打开一个不存在的文件，会引发 FileNotFoundError。错误类型是：FileNotFoundError：[Errno 2] No such file or directory。
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 语句，可以再次引发刚刚发生过的异常，作用就是向外传递异常。

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