Python 入门基础知识总结（文本化示例版）

一、简介

Python 是一种解释型、面向对象的语言，其语法和动态类型，以及解释性语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言。

二、Python 基础语法

2.1 字面量

字面量指在代码中被写下来的固定的值，Python 中有 6 种常用的数据类型，type()语句可查看变量存储的数据类型。

• 示例：定义整数类型变量 num1 = 10、浮点数类型变量 num2 = 3.14、字符串类型变量 str1 = "Python"、布尔类型变量 bool1 = True、列表类型变量 list1 = [1, 2, 3]、元组类型变量 tuple1 = (4, 5, 6)；使用 type () 语句查看类型，type (num1) 会输出 < class 'int'>，type (str1) 会输出 < class'str'>。

2.2 注释

• 单行注释：以#开头，#右边的所有文字为说明，非执行程序，#号和注释内容建议以一个空格隔开。
• 示例：# 这是单行注释，用于说明单行代码的功能；在 print ("Hello World") 语句后加# 行尾注释，说明该打印语句的作用。
• 多行注释：以一对三个双引号引起来。
• 示例："""这是多行注释，可以换行写多个说明语句，用于解释一段代码的功能"""；在该注释下方定义 a = 5、b = 3，执行 print (a + b) 会输出 8。

2.3 数据类型转换

• 综合示例：定义 x = "456"，执行 int (x) + 10 的结果是 466（将字符串转为整数后运算）；定义 y = 789，执行 str (y) + "abc" 的结果是 "789abc"（将整数转为字符串后拼接）；定义 z = 9，执行 float (z) 的结果是 9.0（将整数转为浮点数）。

2.4 标识符

标识符是用户编程时使用的一系列名字，用于给变量、类、方法等命名。命名仅允许出现英文、中文、数字、下划线（_）四类元素，不推荐使用中文，数字不可开头，且不可使用关键字。

• 合法示例：name = "张三"、age18 = 18、user_name = "李四"、_score = 90。
• 非法示例：1name = "王五"（数字开头）、user-name = "赵六"（含非法字符 “-”）、if = 10（使用关键字 “if”），这些写法都会报错。

2.5 运算符

算术（数学）运算符

复合赋值运算符

• 综合示例：定义 a = 10、b = 3，执行 a + b 结果是 13，a * 2 结果是 20，"hi" * 3 结果是 "hihihi"，10 / 3 结果是 3.3333333333333335，10 // 3 结果是 3，10 % 3 结果是 1；定义 c = 5，执行 c += a 后 c=15，再执行 c *= 2 后 c=30。

2.6 字符串

2.6.1 字符串的三种定义方式

单引号定义法、双引号定义法、三引号定义法。其中，单引号定义法可内含双引号，双引号定义法可内含单引号，也可使用转义字符（\）将引号解除效用，变成普通字符串。

• 定义示例：str1 = ' 单引号定义的字符串 '、str2 = "双引号定义的字符串"、str3 = """三引号定义的多行字符串"""。
• 引号嵌套与转义示例：str4 = 'He said: "I love Python"'（单引号内含双引号）、str5 = "She said: 'Python is easy'"（双引号内含单引号）、str6 = "He said:"I love Python""（转义字符 \ 解除双引号效用）、str7 = 'C:\Users\Desktop'（转义字符 \ 表示普通反斜杠）、str8 =" 第一行 \n 第二行 "（转义字符 \n 表示换行）；执行 print (str4) 输出 He said:"I love Python"，执行 print (str8) 输出第一行（换行）第二行。

2.6.2 字符串拼接

字符串无法和非字符串变量进行拼接。默认 print 语句输出内容会自动换行，在 print 语句中加上end=''即可实现输出不换行。

• 示例：定义 name = "张三"、age = 20，执行 "姓名：" + name + "，年龄：" + age 会报错（字符串不能与整数拼接）；执行 "姓名：" + name + "，年龄：" + str (age) 结果是 "姓名：张三，年龄：20"；执行 print ("Hello", end='') 后再执行 print ("World")，输出 Hello World（无换行）。

2.6.3 字符串格式化

通过特定语法可完成字符串和变量的快速拼接，格式符号及转化如下：

• 综合示例：定义 name = "王五"、age = 25、height = 1.80，执行 print ("姓名：% s，年龄：% d，身高：% f" % (name, age, height)) 输出姓名：王五，年龄：25，身高：1.800000；直接格式化表达式，执行 print ("10 + 20 = % d" % (10 + 20)) 输出 10 + 20 = 30，执行 print ("半径为 3 的圆面积：% f" % (3.14 * 3 ** 2)) 输出半径为 3 的圆面积：28.260000。

2.6.4 格式化的精度控制

使用辅助符号 “m.n” 控制数据的宽度和精度：m 控制宽度，要求是数字，若设置宽度小于数字自身则不生效；.n 控制小数点精度，要求是数字，会进行小数的四舍五入。

• 示例：定义 num1 = 11、num2 = 11.345；执行 print ("宽度控制为 5 位：%5d" % num1) 输出   11（三个空格补足宽度）；执行 print ("宽度 5 位 + 精度 2 位：%5.2f" % num2) 输出 11.35（宽度 5 位，小数保留 2 位并四舍五入）；执行 print ("仅精度 2 位：%.2f" % num2) 输出 11.35（不限制宽度，小数保留 2 位）；执行 print ("宽度 7 位 + 精度 2 位：%7.2f" % num2) 输出  11.35（两个空格补足宽度）。

2.6.5 字符串快速格式化

通过语法f"内容{变量}"快速格式化，该写法不做精度控制，不理会类型。

• 示例：定义 name = "赵六"、age = 28、height = 1.78，执行 print (f"姓名：{name}，年龄：{age}，身高：{height}") 输出姓名：赵六，年龄：28，身高：1.78；执行 print (f"20 + 30 = {20 + 30}") 输出 20 + 30 = 50。

2.7 数据输入

使用input()语句可从键盘获取输入，无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型。

• 示例：执行 name = input ("请输入你的姓名：")，输入 “张三” 后 name 的值为 "张三"；执行 age = input ("请输入你的年龄：")，输入 “20” 后 age 的值为 "20"（类型是字符串）；执行 print (f"姓名：{name}，年龄数据类型：{type (age)}") 输出姓名：xxx，年龄数据类型：<class'str'>；将 age 转为整数，执行 age_int = int (age) 后，执行 print (f"明年年龄：{age_int + 1}") 输出明年年龄：21。

三、Python 判断语句

3.1 if 语句的基本格式

归属于 if 判断的代码语句块，需在前方填充 4 个空格缩进，Python 通过缩进判断代码块的归属关系。

• 示例：定义 score = 85，执行 if score >= 60: 后，缩进 4 个空格执行 print ("成绩合格") 和 print ("可以参加后续活动")，再无缩进执行 print ("判断结束")；最终输出成绩合格 → 可以参加后续活动 → 判断结束。

3.2 if elif else 语句

用于多条件判断，依次判断条件，满足则执行对应代码块，均不满足则执行 else 代码块。

• 示例：定义 score = 75，执行 if score >= 90: print ("优秀")，elif score >= 70: print ("良好")，elif score >= 60: print ("及格")，else: print ("不及格")；最终输出良好。

四、Python 循环语句

4.1 while 循环

满足循环条件时，重复执行循环体代码，直到条件不满足退出循环。

• 示例：计算 1 到 10 的和，定义 sum_result = 0、i = 1，执行 while i <= 10: sum_result += i、i += 1；循环结束后执行 print ("1 到 10 的和：", sum_result)，输出 1 到 10 的和：55。

4.2 for 循环

可遍历可迭代对象（如序列、集合、字典等），依次取出元素执行循环体代码。

• 示例 1（遍历字符串）：定义 str1 = "Python"，执行 for char in str1: print (char, end=' ')，输出 P y t h o n。
• 示例 2（遍历列表）：定义 list1 = [1, 2, 3, 4, 5]、sum_list = 0，执行 for num in list1: sum_list += num；循环结束后执行 print ("\n 列表元素和：", sum_list)，输出列表元素和：15。

4.3 range 语句

用于获得一个数字序列，语法如下：

• 语法 1：range (num)，从 0 开始，到 num 结束（不含 num 本身）；示例：执行 for i in range (5): print (i, end=' ')，输出 0 1 2 3 4。
• 语法 2：range (num1, num2)，从 num1 开始，到 num2 结束（不含 num2 本身）；示例：执行 for i in range (2, 6): print (i, end=' ')，输出 2 3 4 5。
• 语法 3：range (num1, num2, step)，从 num1 开始，到 num2 结束（不含 num2 本身），step 为步长（依次取元素的间隔）；示例：执行 for i in range (1, 10, 2): print (i, end=' ')，输出 1 3 5 7 9。

五、Python 函数

函数是组织好的、可重复使用的、用于实现特定功能的代码段。

函数的定义

使用def关键字定义函数，若函数没有使用 return 语句返回数据，会返回 None 字面量；在 if 判断中，None 等同于 False；定义变量但暂时不需要具体值时，可用 None 代替。使用global关键字可在函数内部声明变量为全局变量。

• 示例 1（无参数无返回值函数）：定义 def say_hello (): print ("Hello Python!")，调用 say_hello () 输出 Hello Python!。
• 示例 2（有参数有返回值函数）：定义 def add (a, b): return a + b，调用 result = add (10, 20) 后，执行 print ("10 + 20 =", result) 输出 10 + 20 = 30。
• 示例 3（无 return 语句的函数）：定义 def func (): print ("无返回值函数")，调用 res = func () 后，执行 print ("函数返回值：", res) 输出函数返回值：None。
• 示例 4（global 关键字）：定义 num = 10，再定义 def modify_global (): global num; num = 20，调用 modify_global () 后，执行 print ("修改后的全局变量：", num) 输出修改后的全局变量：20。

六、Python 数据容器

数据容器是可容纳多份数据的数据类型，容纳的每一份数据称为 1 个元素，每个元素可以是任意类型的数据。

6.1 list（列表）

基本语法

使用方括号[]定义，元素之间用逗号分隔。

• 示例：list1 = [1, "Python", 3.14, True]（元素类型任意）、list2 = []（空列表）、list3 = [1, 2, [3, 4]]（嵌套列表）；执行 print (list1) 输出 [1, 'Python', 3.14, True]。

列表的方法

• 综合示例：定义 list1 = [10, 20, 30, 20]，执行 list1.append (40) 后 list1 为 [10,20,30,20,40]；执行 list1.extend ([50,60]) 后 list1 为 [10,20,30,20,40,50,60]；执行 list1.insert (2,25) 后 list1 为 [10,20,25,30,20,40,50,60]；执行 del list1 [3] 后 list1 为 [10,20,25,20,40,50,60]；执行 res = list1.pop (4) 后 list1 为 [10,20,25,20,50,60]，res=40；执行 list1.remove (20) 后 list1 为 [10,25,20,50,60]；执行 list1.count (20) 结果是 1；执行 list1.index (25) 结果是 1；执行 len (list1) 结果是 5；执行 list1.clear () 后 list1 为 []。

列表特点

支持多个元素，元素类型任意，支持下标索引，允许重复元素，可修改，数据有序。

6.2 tuple（元组）

基本语法

使用圆括号()定义，元素之间用逗号分隔。注意：元组只有一个数据时，该数据后面要添加逗号。

• 示例：tuple1 = (1, "Python", 3.14)（多元素元组）、tuple2 = (5,)（单个元素元组，必须加逗号）、tuple3 = ()（空元组）、tuple4 = 1,2,3（可省略括号）；执行 print (tuple1) 输出 (1, 'Python', 3.14)，执行 print (tuple2) 输出 (5,)。

元组的方法

• 示例：定义 tuple1 = (10,20,30,20,40)，执行 tuple1.index (20) 结果是 1；执行 tuple1.count (20) 结果是 2；执行 len (tuple1) 结果是 5；尝试执行 tuple1 [0] = 100 会报错（'tuple' object does not support item assignment）。

元组特点

支持多个元素，元素类型任意，支持下标索引，允许重复元素，不可修改，数据有序。

6.3 str（字符串）

字符串的方法

• 综合示例：定义 str1 = "Python is easy! Python is fun!"，执行 str1 [3] 结果是 "t"；执行 str1.index ("is") 结果是 9；执行 new_str1 = str1.replace ("Python", "Java") 后，new_str1 为 "Java is easy! Java is fun!"，原 str1 仍为 "Python is easy! Python is fun!"；定义 str2 = "apple,banana,orange"，执行 list1 = str2.split (",") 后 list1 为 ['apple', 'banana', 'orange']；定义 str3 = "hello\n"，执行 new_str3 = str3.strip () 后 new_str3 为 "hello"；定义 str4 = "xxxyyyzzz"，执行 new_str4 = str4.strip ("xyz") 后 new_str4 为空字符串；执行 str1.count ("Python") 结果是 2；执行 len (str1) 结果是 33。

字符串特点

容器内元素类型单一，仅为字符串类型；不可修改，修改需生成新字符串，旧字符串保持不变。

6.4 序列的切片

序列指内容连续、有序、可使用下标索引的一类数据容器，列表、元组、字符串均视为序列。语法：序列 [起始下标：结束下标：步长]，表示从序列指定位置开始，依次取出元素到指定位置结束，得到新序列。

• 示例 1（列表切片）：定义 list1 = [1,2,3,4,5,6]，执行 list1 [1:4] 结果是 [2,3,4]；执行 list1 [:3] 结果是 [1,2,3]；执行 list1 [2:] 结果是 [3,4,5,6]；执行 list1 [::2] 结果是 [1,3,5]；执行 list1 [::-1] 结果是 [6,5,4,3,2,1]；执行 list1 [4:1:-1] 结果是 [5,4,3]。
• 示例 2（字符串切片）：定义 str1 = "Python"，执行 str1 [1:4] 结果是 "yth"；执行 str1 [::-1] 结果是 "nohtyP"。
• 示例 3（元组切片）：定义 tuple1 = (10,20,30,40)，执行 tuple1 [1:3] 结果是 (20,30)。

6.5 set（集合）

基本语法

使用大括号{}定义，元素之间用逗号分隔。

• 示例：set1 = {1,2,3,4}（普通集合）、set2 = {1,2,2,3}（重复元素自动去重，结果为 {1,2,3}）、set3 = set ([1,2,3])（由列表转换为集合）、set4 = {}（空字典，不是空集合）、set5 = set ()（空集合）；执行 print (set1) 输出 {1,2,3,4}，执行 print (set2) 输出 {1,2,3}。

集合的方法

• 综合示例：定义 set1 = {10,20,30,40}、set2 = {30,40,50,60}；执行 set1.add (50) 后 set1 为 {10,20,30,40,50}；执行 set1.remove (20) 后 set1 为 {10,30,40,50}；执行 res = set1.pop () 后 set1 为 {30,40,50}，res=10（随机）；执行 diff = set1.difference (set2) 后 diff 为 set ()；执行 set1.difference_update (set2) 后 set1 为 set ()；执行 union_set = {1,2}.union ({3,4}) 后 union_set 为 {1,2,3,4}；执行 len (set2) 结果是 4；执行 set2.clear () 后 set2 为 set ()。

集合特点

不支持元素重复（自带去重功能），内容无序，支持多个元素，元素类型任意，不支持下标索引，可修改。

6.6 dict（字典）

字典定义

使用大括号{}定义，以键值对（Key: Value）形式存储数据，键值对之间用逗号分隔。

• 示例：dict1 = {"name": "张三", "age": 20, "height": 1.75}（普通字典）、dict2 = {}（空字典）、dict3 = {"name": "李四", "scores": {"math": 90, "english": 85}}（嵌套字典）；执行 print (dict1) 输出 {'name': ' 张三 ', 'age': 20, 'height': 1.75}。

字典的常用操作

• 综合示例：定义 dict1 = {"name": "张三", "age": 20, "height": 1.75}，执行 dict1 ["name"] 结果是 "张三"；执行 dict1 ["gender"] = "男" 后 dict1 为 {'name': ' 张三 ', 'age': 20, 'height': 1.75, 'gender': ' 男 '}；执行 dict1 ["age"] = 21 后 dict1 为 {'name': ' 张三 ', 'age': 21, 'height': 1.75, 'gender': ' 男 '}；执行 res = dict1.pop ("height") 后 dict1 为 {'name': ' 张三 ', 'age': 21, 'gender': ' 男 '}，res=1.75；执行 keys = dict1.keys () 后，list (keys) 为 ['name', 'age', 'gender']；执行 len (dict1) 结果是 3；执行 dict1.clear () 后 dict1 为 {}。

字典特点

键值对的 Key 和 Value 可任意类型（Key 不可为字典）；Key 不允许重复，重复添加等同于覆盖原有数据；不可用下标索引，通过 Key 检索 Value；支持多个元素，可修改，数据无序。

6.7 数据容器的通用操作

容器通用功能

• 综合示例：遍历 list1 = [1,2,3]，输出 1 2 3；遍历 dict1 = {"name": "张三", "age": 20}，输出 name : 张三 age : 20；执行 max (list1) 结果是 3，min (list1) 结果是 1；执行 max ("Python") 结果是 "y"，min ("Python") 结果是 "P"；执行 list ((4,5,6)) 结果是 [4,5,6]，执行 set ([1,2,3]) 结果是 {1,2,3}；执行 sorted ([5,2,8,1]) 结果是 [1,2,5,8]，执行 sorted ([5,2,8,1], reverse=True) 结果是 [8,5,2,1]。

七、Python 函数进阶

7.1 函数多返回值

按照返回值的顺序，用对应顺序的多个变量接收，变量之间用逗号隔开。

• 示例：定义 def calculate (a, b): sum_ab = a + b; diff_ab = a - b; return sum_ab, diff_ab；调用 sum_res, diff_res = calculate (10, 3) 后，sum_res=13，diff_res=7；调用 res = calculate (20,5) 后，res=(25,15)（返回元组）。

7.2 函数多种传参方式

7.2.1 位置参数

调用函数时根据函数定义的参数位置传递参数，传递的参数和定义的参数的顺序及个数必须一致。

• 示例：定义 def add (a, b, c): return a + b + c；调用 result = add (1,2,3)（a=1、b=2、c=3），result=6；调用 add (1,2) 会报错（missing 1 required positional argument: 'c'）。

7.2.2 关键字参数

函数调用时通过 “键 = 值” 形式传递参数。

• 示例：定义 def add (a, b, c): return a + b + c；调用 result1 = add (a=1, b=2, c=3)，result1=6；调用 result2 = add (b=2, a=1, c=3)（可打乱顺序），result2=6；调用 result3 = add (1, b=2, c=3)（位置参数在前），result3=6。

7.2.3 缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（所有位置参数必须出现在默认参数前）。

• 示例：定义 def print_info (name, age=18): print ("姓名：", name, "，年龄：", age)；调用 print_info ("张三")（未传 age），输出姓名：张三 ，年龄：18；调用 print_info ("李四", 20)（传 age），输出姓名：李四 ，年龄：20；调用 print_info ("王五", age=22)（关键字传值），输出姓名：王五 ，年龄：22。

7.2.4 不定长参数

不定长参数也叫可变参数，用于不确定调用时传递多少个参数（不传参也可）的场景，分为位置传递和关键字传递。

• 位置传递（*args）：定义 def sum_args (*args): sum_result=0; for num in args: sum_result += num; return sum_result；调用 sum_args (1,2,3) 结果是 6，调用 sum_args (4,5) 结果是 9，调用 sum_args () 结果是 0。
• 关键字传递（**kwargs）：定义 def print_kwargs (**kwargs): for k, v in kwargs.items (): print (k, ":", v, end=' ')；调用 print_kwargs (name="张三", age=20, gender="男")，输出 name : 张三 age : 20 gender : 男。

7.2.5 函数作为参数传递

可将函数作为参数传入另一个函数，在另一个函数中调用该函数。

• 示例：定义 def add (a,b): return a+b；def multiply (a,b): return a*b；def calculate (func, x, y): return func (x,y)；调用 result1 = calculate (add,10,3)，result1=13；调用 result2 = calculate (multiply,10,3)，result2=30。

7.3 匿名函数

使用lambda关键字定义匿名函数（无名称），仅可临时使用一次，语法：lambda 传入参数：函数体（函数体只能写一行）。

• 示例 1：add = lambda x,y: x+y，调用 add (10,20) 结果是 30。
• 示例 2：list1 = [(1,3),(4,1),(2,5)]，执行 sorted (list1, key=lambda x: x [1]) 结果是 [(4,1),(1,3),(2,5)]（按元组第二个元素排序）。
• 示例 3：定义 def calculate (func, x, y): return func (x,y)，调用 calculate (lambda a,b: a*b,5,6) 结果是 30。