Python基础知识点梳理

本文简要梳理了Python基础知识的大体框架。

目录

一、变量和赋值

二、分支和循环

1.分支结构

2.循环结构

三、数据结构

四、函数

lambda函数(匿名函数)

五、面向对象

1、封装

2、继承

六、模块和包

---

一、变量和赋值

变量是编程语言中能存储数据的抽象概念，它可以存储各种数据。变量名只能由字母、数字、下划线组成，需要注意的是：

• 不能以数字开头；
• 不能包含空格；
• 区分大小写，变量A和变量a是不同的。

赋值语句用于将数据赋值给变量。Python支持多种格式的赋值语句：

• 简单赋值用于为一个变量赋值。
• 序列赋值可以一次性为多个变量赋值。
• 多目标赋值指用连续的多个等号将同一个数据赋值给多个变量。
• 增强赋值指将运算符与赋值相结合的赋值语句。

代码如下（示例）：

# 简单赋值
num = 100 

# 序列赋值
x, y = 1, 2                     # 1, 2
(x2, y2) = 10, 20               # 10, 20
[x3, y3] = 'ab'                 # a, b
((x4, y4), z4) = 'ab', 'cd'     # a, b, cd
x5, *y5 = 'abcd'                # a, ['b', 'c', 'd']
*x6, y6 = [1, 2, 3, 'abc']      # [1, 2, 3], abc

# 多目标赋值
a = b = c = 10      # 将10 分别赋值给变量 a、b、c

# 增强赋值 
i = 10
i += 10  # 20

二、分支和循环

1.分支结构

Python中用 if 语句实现分支结构。

代码如下（示例）：

# 分支结构 

# 输入一个成绩，判断它的优良中差等级
score = int(input('请输入一个成绩：'))
if score < 60:
    print('差')
elif score < 70:
    print('中')
elif score < 80:
    print('良')
else:
    print('优')

    
# 输入两个数，输出最大的值
num1 = int(input('请输入第1个数值：'))
num2 = int(input('请输入第2个数值：'))
maxNum = num1 if num1 > num2 else num2
print(maxNum)

2.循环结构

Python中循环语句有两种格式：

• while语句
• for语句

循环中的break和contiune

• break：结束当前循环。

• continue：结束当前循环进入下一个循环。

代码如下（示例）：

##while语句
# 使用 while 计算1+2+...+100的结果
result = 0
i = 1
while i <= 100:
    result += i
    i += 1
    print(f'结果为：{result}')
else:  # 不管while条件是否满足，都会执行，可以省略
    print('执行完毕')


##for语句
# 循环输出1..10之间的所有偶数，如果数值等于6就跳过
for i in range(2, 11, 2):
    if i == 6:
        # break
        continue
    print(i, end='\t')
else:
    print("循环执行完毕！")

三、数据结构

Python中有两类数据类型：

• 简单数据类型：数字和字符串。
• 组合数据类型：
  • 集合(set) 是Python 2.4引入的一种类型，集合常量用大括号表示，例如，{1,2,3}。集合中的元素具有唯一、无序和不可改变等特点，集合支持数学理论中的各种集合运算。
  • 列表和元组都属于序列，序列支持索引、分片和合并等操作。字符串属于特殊的不可变序列。
  • 元组可以看作是不可变的列表，它的使用与字符串类似。元组常量用圆括号表示，例如：(1,2)、('a','b','c')，也可以使用tuple()方法来创建元组对象。
  • 字典是一种无序的映射集合，包含一系列的键:值对。字典常量用大括号表示，例如，{'name':'John','age':25,'sex':'male'}，也可以使用dict()函数来创建。

##集合数据结构示例
# 重复值的集合声明
set1 = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}
print(len(set1))  # 求长度：计算集合中元素的个数  4 
print('a' in set1)  # 判断包含：判断集合是否包括数据  True

# Python3.0引入的集合解析构造方法
set2 = {item for item in [1, 2, 3, 4]}
# 集合对象支持求长度、判断包含、求差集、并集、交集、对称差和比较等运算
print(set1 - set2)  # 求差集：用属于set1但不属于set2的元素创建新集合  {2, 'bc'}
print(set1 | set2)  # 求并集：用set1、set2两个集合中的所有元素创建新集合  {1, 2, 5, 'a', 'bc'}
print(set1 & set2)  # 求交集：用同时属于set1和set2的元素创建新集合  {1, 'a'}


##列表数据结构示例
# 列表切片操作
list1 = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1[2:5])      # [2, 3, 4]
print(list1[2:])       # [2, 3, 4, 5, 6, 7, 8, 9]
print(list1[:5])       # [0, 1, 2, 3, 4]
print(list1[3:10:2])   # [3, 5, 7, 9]
print(list1[10:3:-2])  # [9, 7, 5]

# 列表常用方法
list2 = [1, 3, 3, 7, 5]
list2.append(5)  # 追加
list2.remove(7)  # 移除指定元素
list2.pop(0)  # 按索引位置删除
list2.sort()  # 升序排序
list2.reverse()  # 反转

# 列表解析(推导式)： 列表解析与循环的概念紧密相关，使用列表解析来for代替循环操作。列表解析的基本结构：表达式 for 变量 in 可迭代对象 if 表达式
print([x + 10 for x in range(10) if x % 2 == 0])  # 带条件的列表解析， 用if筛选偶数  [10, 12, 14, 16, 18] 
print([x + y for x in (10, 20) if x > 10 for y in (1, 2, 3) if y % 2 == 1])  # 重解析嵌套, 分别使用if执行筛选 [21, 23]



##元组数据结构示例
# 创建元组
print((2,))  # 包含一个对象的元组，不能缺少逗号  (2,)
print(tuple('abcde'))  # 参数为可迭代对象  ('a', 'b', 'c', 'd', 'e')
print(tuple(item * 2 for item in range(5)))  # 使用解析结构创建元组  (0, 2, 4, 6, 8)

# 元组常用方法
print(len((1, 2, 3, 4, 5)))  # 求长度
print((1, 2) * 3)   # 重复
print(t3.count(1))  # 统计指定值出现的次数，如果不包含指定值时，返回0
print(t3.index(2))  # 查找指定范围内元素所在的索引

# 索引和分片
t2 = tuple(range(10))  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(t2[1])           # 1
print(t2[-1])          # 9
print(t2[2:5])         # (2, 3, 4)
print(t2[1:7:2])       # (1, 3, 5)



##字典数据结构示例
# 创建字典
dict1 = {'name': 'John', 'age': 25, 'sex': 'male'}  # 字典常量
dict2 = {'book': {'Python编程': 100, 'C++入门': 99}}  # 嵌套字典
dict3 = dict(name='Tom', age=25)  # 使用赋值格式的“键:值”对创建字典 {'name': 'Tom', 'age': 25}

# 字典常用方法
dict1['name'] = 'tom'  # 通过索引修改映射值
dict1.update(name='jim')  # update()方法用于为字典添加键值对,若字典已存在同名的键，则该键的映射值被覆盖
print(dict1['name'])  # 根据key获取value
print(dict1.get('name', 'default'))  # 返回键 key映射的值, 如果键key不存在，返回默认值
print(dict1.pop('name', 'default'))  # 从字典中删除键值对，并返回被删除的映射值。若键不存在，则返回default
print(dict1.items())  # 返回键值对视图，视图对象支持迭代操作
print(dict1.keys())   # 返回字典中所有键的视图
print(dict1.values())  # 返回字典中全部值的视图

四、函数

函数是完成特定任务的语句集合，调用函数会执行其它包含的语句。函数的返回值通常是函数的计算结果，调用函数是使用的参数不同，可获得不同的返回值。Python利用函数实现代码复用。

在函数定义的参数表里面的参数称为形式参数，简称形参。调用函数时，参数表中提供的参数称为实际参数，简称实参。Python的函数参数非常灵活，可以根据需求去选择参数个数，但是需要注意的是即使没有参数，括号也不可省略。

• 参数赋值传递：调用函数时会按参数的先后顺序，依次将实参传递给形参。Python允许以形参赋值的方式，将实参传递给指定形参。
• 有默认值的可选参数：在定义函数时，可以为参数设置默认值。调用函数时，如果未提供实参，则形参取默认值使用。注意，带默认值的参数为可选参数，在定义函数时，应放在参数表的末尾。
• 接受任意个数的参数： 在定义函数时，可接受任意个数的参数，如果在参数名前面使用一个星号*，表示形参是一个元组，如果是两个星号**，表示形参是一个字典。

代码如下（示例）：

##函数定义
def function(num1, num2, other=-1, *args, **kwargs):
    print(num1, num2, other, args, kwargs)  # 1 2 3 (4, 5) {'name': 'Tom', 'age': 18}

#函数调用
function(1, 2, 3, 4, 5, name='Tom', age=18)

lambda函数(匿名函数)

lambda函数也称表达式函数，用于定义匿名函数，可将lambda函数赋值给变量，通过变量调用函数。lambda表达式基于数学中的 λ演算 得名，它主要的作用就是简化函数代码，与def不同，lambda只能用一行表示。

lambda函数定义的基本语法为：lambda 参数表:表达式

五、面向对象

面向对象(Object Oriented)是软件开发方法，是一种程序设计规范，是一种对现实世界理解和抽象的方法。在面向对象编程思想中，一切事物皆对象，通过面向对象的方式，将现实世界的事物抽象成对象。

类用来描述具有相同属性和方法的对象的集合。Python的类使用class语句来定义，类通常包含一系列的赋值语句和函数定义，用来描述某一类事物。赋值语句定义类的属性，函数定义类的方法。

代码如下（示例）：

##定义类
class ClassName:
    """定义类的语法"""
    class_property = 0  # 没有使用self，并且写在方法外，这是类属性，它是共享的

    def __init__(self, prop_val):  # 初始化方法，即构造方法
        temporary_val = -1  # 写在方法里，但是没有self，这是一个局部变量
        self.instance_property = prop_val  # 有self，这里创建了一个实例属性，只需要赋值就可以创建
        ClassName.class_property += 1  # 操作类属性需要写类名

    def instance_method(self, prop_val):
        """
        实例方法，与前面的学习过的函数几乎一样，区别在于第一个参数必须是 self，隐式传入，实例自己
        :param prop_val:
        :return:
        """
        print(prop_val)
        pass

    @staticmethod  # 静态方法,类名调用
    def static_method():
        pass

    @classmethod  # 类方法，类名调用
    def class_method(cls):
        pass

1、封装

封装（Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点：

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

2、继承

继承可实现新类获取现有类的属性和方法。新类称作子类或派生类，被继承的类称作父类、基类或超类。在子类中可以定义新的属性和方法，从而完成对父类的扩展。

class Person:

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def show_info(self):
        print(f"name: {self.name}, age:{self.age}, sex:{self.sex}")


class Student(Person):  # 这里加了一个括号表明父类是 Person
    def __init__(self, name, age, sex, stu_id):
        super().__init__(name, age, sex)  # super 就是父类，调用父类的 初始化方法初始化参数
        self.stu_id = stu_id  # 子类特性

    def show_info(self):  # 重写父类方法
        print(f"name: {self.name}, age:{self.age}, sex:{self.sex}, stu_id:{self.stu_id}")


stu = Student("Tom", 18, "male", 10010)
stu.show_info()

六、模块和包

模块是一个包含变量、函数或类的程序文件，模块中也可包含其他的各种Python语句。大型系统往往将系统功能划分为模块来实现，或者将常用功能集中在一个或多个模块文件中，然后在顶层的主模块文件或其他文件中导入并使用模块。Python也提供了大量内置模块，并可集成各种扩展模块。

以模块方式组织代码能够方便地管理和维护，但是随着项目复杂度进一步升级，需要将项目不同功能代码放入把不同的文件夹中，这些文件夹可以相互引用，这就是包的概念。

Python模块的导入方式：

• 采用import 模块名的方式，导入模块中的所有函数，调用的时候需要通过模块名.函数的形式调用。也可以在模块名后面使用as关键字给模块重命名，这种方式主要用来避免模块之间函数名冲突。
• 采用from 模块名 import 函数名的方式，导入模块中指定的函数，调用的时候，函数名前不需要加上模块名。也可以把函数名换成*号，导入所有函数。
• 采用from 模块名 import *的方式，导入模块所有函数。

Python包从本质上来说就是一个文件夹，与一般的文件夹不同之处在于包中必须包含一个名为__init__.py的文件。__init__.py文件可以是一个空文件，仅用于表示该文件夹是一个包。

---