Python基础知识点梳理_python知识体系

目录

一、变量和赋值

二、分支和循环

1.分支结构

2.循环结构

三、数据结构

四、函数

lambda函数(匿名函数)

五、面向对象

1、封装

2、继承

六、模块和包

# 简单赋值
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

# 分支结构 
 
# 输入一个成绩，判断它的优良中差等级
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)

##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("循环执行完毕！")

##集合数据结构示例
# 重复值的集合声明
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())  # 返回字典中全部值的视图
 
 

##函数定义
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)

##定义类
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

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()