Python基础5-18

Python基础5：Python中条件语句块

Python基础6：Python中循环语句块

Python基础7：Python中的函数

Python基础8：深入了解Python函数

Python基础9：了解Python中的数据容器

Python基础10：了解列表的增删改查操作

Python基础11：列表注意事项及切片的使用

Python基础12：元组

Python基础13：set集合

Python基础14：字典dict

Python基础15：数据容器特性总结与通用排序sorted的介绍

数据容器特点对比表

补充说明（对应表格核心差异）

Python基础16：JSON的使用

Python基础17：文件相关操作与with语句块

Python基础18：面向对象之构造与析构

Python基础5：Python中条件语句块

复制代码

# ===================== 1. 布尔逻辑 not / and / or 基础 =====================
# ok = True
# ok = False
# if语句块
ok = 5 < 3
# 在python中not关键字为取反
# 在python中or为C/C++中的||运算符，and 就是&&运算符。
if not ok:
    print("5<3是错误的！！！")

# ===================== 2. 多独立if 分数判断 =====================
score = int(input("请输入一个分数：\n"))
if score > 90:
    print("成绩优秀")
if 90 > score > 60:
    print("成绩一般")
if score < 60:
    print("成绩不合格")

# ===================== 3. if-elif-else 互斥多分支 =====================
# if ... else....  if ... elif... ... else...
like = input("校花喜欢你吗？\n")
if like == "是":
    print("去表白")
elif like == "一般":
    print("约她看场电影")
else:
    print("努力学习，赚大钱买大房")

# ===================== 4. match-case 匹配分支（Python3.10+新特性，等价C switch-case） =====================
number = int(input("请输入你的班级号：\n"))
match number:
    case 1:
        print("您好，一班的同学")
    case 2:
        print("您好，二班")
    case 3:
        print("你好，三班")
    case 4 | 5:
        print("您好，三班或四班的同学")
    # 以下的语句相当于switch case中的最后的一个条件即default:
    # 这个条件放在match case中的最后。
    case _:
        print("你好，其它班的同学")

# 导入随机数模块
import random
# 生成0~10之间的随机整数（包含0和10）
number = random.randint(0,10)
# 获取用户输入并转为整型
confirm = int(input("请输出一个数字来猜大小"))
# 判断猜数字结果
if confirm == number:
    print("你猜中了")
elif confirm < number:
    print("你猜小了")
else:
    print("你猜大了")

Python基础6：Python中循环语句块

复制代码

# while for
"""
while 条件表达式:
    条件满足时则执行的内容
"""

import time

# 基础有限while循环（注释示例）
# i = 0
# while i < 10:
#     i += 1
#     print(i)
#     time.sleep(1)

# 在循环语句块中常用两个关键字：break, continue
# break: 退出当下的循环体
# continue: 跳过当下循环体中的本次循环，继续执行下一次循环。

# 带break、continue的死循环控制示例
i = 0
while True:
    i += 1
    if i >= 10:
        break
    if i == 5:
        continue
    print(i)
    time.sleep(1)

# 与C/C++中一样，while循环也是可以嵌套使用的：
import time
i = 0
# 外层循环嵌套内层循环：
while i < 3:
    i += 1
    time.sleep(1)
    print("你好")
    j = 0
    while j < 3:
        print("gaowanxi ", end=" ")
        j += 1
    print()

Python基础7：Python中的函数

复制代码

"""
python中的函数：内置函数: print,len,range,int(),float(),str(),input...
python中也提供了自定义的函数的形式:
def + 函数名 + (形参列表) + < ->返回值类型进行说明>:
    函数体，如果这个函数体有返回值的话，那么就使用return进行返回。
    return + 返回值
"""

# 1. 无参无返回函数
def show():
    print("helloworld")
# 调用函数
show()

# 注释：两参数加法函数
# def add(a,b):
#     return a + b
# python中同名函数是没有重载概念
# 覆盖上面的add，仅三参数加法生效
def add(a, b, c):
    return a + b + c

# None 空值，等价C NULL / C++ nullptr
c = None
d = None

# 带文档注释的减法函数
# 添加函数注释:
def sub(a, b):
    """
    :param a: 第一个参数
    :param b: 第二个参数
    :return: 任意类型的返回值
    """
    return a - b

# 调用加法、减法函数
print(add(1, 2, 3))
sub(10, 20)

# 全局变量与global关键字
x = 100
def showInfo():
    # global 声明使用全局变量x
    global x
    x = 200
    print(x)

# 调用全局变量函数
showInfo()
# 打印修改后的全局x
print(x)

7.2

复制代码

# 1. 多返回值函数
def f_test(x, y):
    return x, y

# 2. 多分支return，不同类型返回值
def test1(x):
    if x == 1:
        return "gaowanxi"
    if x == 2:
        return 123

# 打印多返回值的类型
print(type(f_test(1, 2)))

# 3. 默认参数函数
def add(a=20, b=10):
    return a + b
# 在python中函数参数的默认值从右往左依次赋值不可以跳跃。
print(add(40))

# 4. 可变位置参数 *args
# python中的可变参数
# *args代表一个可变参数，类型，个数可变
def show(*args):
    print(args)
show(10, 3.14, "gaowanxi")

# 5. 可变关键字参数 **kwargs
def show1(**kwargs):
    # kwargs：k=key,w=word，整体是字典，key为传入参数名，value为实参值
    print(kwargs["name"], kwargs["age"], kwargs["score"])

# 关键字传参，顺序可随意调换
show1(name="gaowanxi", age=35, score=98)
# python中函数传参时，默认是一一对应
show1(age=35, score=98, name="gaowanxi")

# 6. lambda匿名函数
# python中的匿名函数 Lambda表达式
func = lambda x, y: x + y
print(func(1, 2))

Python基础8：深入了解Python函数

复制代码

# 1. 普通双参函数
def add(a,b):
    return a + b
print(add(1,2))

# 2. 带默认参数函数
def add1(a=1,b=2):
    return a + b
print(add1())

# 3. lambda匿名函数
func = lambda x,y:x + y
print(func(1,2))

# 4. *args可变位置参数，求和
def add2(*args):
    # *args 就是一个元组对象
    my_sum = 0
    for i in args:
        my_sum = my_sum + i
    return my_sum
print(add2(1,2,3,4,5,6,7,8,9,10))

# 5. **kwargs可变关键字参数
def showInfo(**kwargs):
    # 关键词的key与value的字典
    print(kwargs["name"], kwargs["age"], kwargs["score"])
showInfo(name="gaowanxi", age=35, score=98)
showInfo(score=98, name="gaowanxi", age=35)

# python一切皆对象，变量、函数、类型全是对象
print(type(add))

Python基础9：了解Python中的数据容器

复制代码

"""
在python中常用的数据容器：list列表，tuple元组，set集合，dict字典，string字符串
1. 以上这些数据容器都是可迭代的类型，内部有__iterator__方法，也就是可以类似于C++中迭代器，
可以使用枚举for循环，在python中就是可以使用python中的for循环进行遍历。

2. list列表，tuple元组，是一种顺序连续的序列，支持下标操作，所以也支持切片。
set集合，dict字典是一种非连续性的可迭代序列，所以是不支持切片。
"""

"""
list数据容器，是类似于C++vector容器的一种顺序表结构的容器，并非是C++中那种list双向循环链表。
"""

复制代码

"""
list数据容器，是类似于C++vector容器的一种顺序表结构的容器，并非是C++中那种list双向循环链表。
"""

# 创建空列表两种写法等价
list1 = list()
# list1 = []
# list1.append(1)
print(list1.__sizeof__())
list1.append(1)
print(list1.__sizeof__())

# 循环1~99依次添加到列表
for i in range(1, 100):
    list1.append(i)
    # 打印有效元素数量、底层数组容量
    print("list1中的有效元素的个数: %d, 容器大小: %d"%(len(list1), (list1.__sizeof__()-40)//8))

Python基础10：了解列表的增删改查操作

复制代码

print("--------------------------------------------------")
list2 = list(["gaowanxi", 35, 99.99, 3.14, 5.12])
for i in list2:
    print(i)

list3 = ["gaowanxi", 35, 99.99, 3.14, 5.12]
for i in list3:
    print(i)

print("------------------------CRUD------------------------")
# 列表增加元素的操作
# append尾部追加，时间复杂度是O(1)
list2.append("lisi")
for i in list2:
    print(i, end=" ")
print()

# 指定位置插入操作：insert(下标，要插入元素的值)，时间复杂度是O(n)
list2.insert(3, "Wangwu")
for i in list2:
    print(i, end=" ")
print()

# 删除列表中的元素的方式：remove(_value)  时间复杂度O(n)
list2.remove("Wangwu")
for i in list2:
    print(i, end=" ")
print()

list2.remove(list2[2])
for i in list2:
    print(i, end=" ")
print()

# 尾部删除：pop()方法
list2.pop()
for i in list2:
    print(i, end=" ")
print()

# 使用pop(index下标) 的方式指定删除
list2.pop(0)
for i in list2:
    print(i, end=" ")
print()

# 改操作：直接通过下标的方式去改：
list2[0] = 88
for i in list2:
    print(i, end=" ")
print()

# 查操作下标访问：可以直接使用下标来访问，
print(list2[0])
# index(_value)获取在列表中的下标位置
# 类似于C++的泛型算法中的find方法
print(list2.index(3.14))

# list列表中反转操作：
list2.reverse()
for i in list2:
    print(i, end=" ")
print()

# 统计列表中某个元素的值在列表所出现的次数：
list2.append(88)
count = list2.count(88)
print(count)

# list列表也提供了排序的方法：sort
def compair(a):
    return a -10

list3 = ["gaowanxi", "lisi", "Wangwu"]
list3.sort(key=len)
for i in list3:
    print(i, end=" ")
print()

list2.sort(key=compair)
for i in list2:
     print(i, end=" ")
print()

# 获取列表中的最大值的方法：
number_list = [5, 2, 3, 8]
Max = number_list[0]
for i in number_list:
    if Max < i:
        Max = i
print(Max)

Python基础11：列表注意事项及切片的使用

复制代码

# 获取列表中最大值的方法是一个内置方式：max
number_list = [5, 2, 3, 8]
Max = max(number_list)
print(Max)

# 在python如果我们想按条件删除列表的元素时，一个注意事项：当删除之后，会涉及到元素的移动的问题：
my_list = [5, 8, 9, 4, 11, 15, 30, 31]
# 【错误写法】正向for in遍历同时删除元素，会漏删
for i in my_list:
    if i > 10:
        my_list.remove(i)
print(my_list)

# 重新初始化，演示正确方案
my_list = [5, 8, 9, 4, 11, 15, 30, 31]
# 第一方式：使用while循环
i = 0
while i < len(my_list):
    if my_list[i] > 10:
        my_list.remove(my_list[i])
    else:
        i += 1
print(my_list)

# 重新初始化
my_list = [5, 8, 9, 4, 11, 15, 30, 31]
# 第二种方式，使用反向迭代for循环：
for i in range(len(my_list)-1, -1, -1):
    if my_list[i] > 10:
        my_list.pop(i)
print(my_list)

# ----------------列表切片----------------
# 列表中的切片的概念：
# 把列表中数据按照一个规则生成一个新的子列表，就是切片。
# 切片：只能用于支持下标操作的连续性的数据容器（list、tuple、str）。
# 切片语法形式 [起始下标:结束下标:步长]

my_list = [0,1,2,3,4,5]
sub_list = my_list[1:3:1]
print(sub_list)

myname = "gaowanxi"
sub_name = myname[3:None:1]
sub_name1 = myname[3::1]
sub_name2 = myname[::3]
sub_name3 = myname[::-1]
sub_name4 = myname[:2:-1]
sub_name5 = myname[3::-1]
sub_name6 = myname[3::]

print("原字符串：", myname)
print("sub_name  =", sub_name)
print("sub_name1 =", sub_name1)
print("sub_name2 =", sub_name2)
print("sub_name3 =", sub_name3)
print("sub_name4 =", sub_name4)
print("sub_name5 =", sub_name5)
print("sub_name6 =", sub_name6)

# myname[0] = 'l'
# 报错！字符串str是不可变序列，不支持下标修改
# 下节课讲元组

Python基础12：元组

复制代码

# 元组，不可修改的列表就是元组
t = tuple()
t1 = ()
print(type(t))
print(type(t1))

# 构建有元素的元组
t = tuple(["gaowanxi", "lisi", 35, 28])
print(t)

t1 = ("gaowanxi", "lisi", 35, 28)
print(t1)

# 可以省略括号直接逗号构成元组
t2 = "gaowanxi", "lisi", 35, 28
print(t2)

def getvalu(x, y):
    return x, y  # return多个值，自动打包成元组

t3 = getvalu("gaowanxi", "lisi")
print(t3)

# 元组是连续序列，元素不可修改
print("------------------------------------------------")
for i in t2:
    print(i, end=" ")
print()

Python基础13：set集合

复制代码

# set集合的构建方式：
s1 = set()
print(type(s1))

# 有元素的无序、元素不可重复集合
s2 = set(["gaowanxi", "lisi", "Wangwu"])
print(type(s2))

s3 = {"gaowanxi", "lisi", "wangwu", 88, 99, 33}
print(type(s3))

# 遍历集合s3
for i in s3:
    print(i, end=" ")
print()

s4 = set({"gaowanxi", "wangwu", "malu"})
print(type(s4))
for i in s4:
    print(i, end=" ")
print()

# 交集 &
s5 = s3 & s4
print("交集：", s5)

# 1. 增操作 add：重复元素添加无效
s4.add("tianqi")
print("add后：", s4)

# 2. 删除操作 remove(元素)，元素不存在会报错
s4.remove("malu")
print("remove后：", s4)

# pop() 随机删除一个元素
s4.pop()
print("pop随机删除后：", s4)

# 并集 |
s6 = s4 | s3
print("并集：", s6)

Python基础14：字典dict

复制代码

# 创建空字典的方式
d1 = dict()
d2 = {}
print(type(d1))
print(type(d2))

# 创建有元素字典方式1：嵌套可迭代对象
d3 = dict([("name", "gaowanxi"), ("age", 35), ("score", 98)])
print(type(d3))
print(d3)

# 创建方式2：关键字传参
d4 = dict(name="gaowanxi", age=35, score=98)
print(type(d4))
print(d4)

# 创建方式3：dict包裹字典
d5 = dict({1:"name", 2:"age", 3:"score"})
print(type(d5))
print(d5)

# 创建方式4：字面量{}（最常用）
d6 = {"name":"gaowanxi", "age":35, "score":98}
print(type(d6))
print(d6)

d7 = {1:"name", 2:"age", 3:"score"}
print(type(d7))
print(d7)

print("------------------------------------------------------")

# 通过key取值
print(d6["name"])

# 获取所有key转为列表
key_list = list(d6)
print(key_list)

# 获取键值对数量
print(len(d6))

# 修改value：key存在则修改，不存在则新增
d6["name"] = "lisi"
print(d6)

# 判断key是否存在（只检查key，不检查value）
print("name" in d6)

print("-----------------------")

# get取值：推荐，key不存在不会崩溃
print(d6.get("name"))
print(d6.keys())

# pop：根据key删除指定键值对
d6.pop("score")
print(d6)

# popitem()：Python3.7+删除最后插入的键值对
print(d6.popitem())
print(d6)

# update：用另一个字典合并更新，同名key会覆盖
d6.update(d7)
print(d6)

# values() 获取所有value视图
view_map = d6.values()
print(view_map)

Python基础15：数据容器特性总结与通用排序sorted的介绍

数据容器特点对比表

表格

对比维度	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key: ValueKey: 除字典外任意类型Value: 任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以 Key 检索 Value 的数据记录场景

补充说明（对应表格核心差异）

有序 / 无序：列表、元组、字符串是有序序列，支持下标和切片；集合、字典是无序哈希表，不支持下标访问。
可修改性：列表、集合、字典是可变容器，支持增删改；元组、字符串是不可变容器，创建后无法修改内部元素。
重复元素：列表、元组、字符串允许重复元素；集合、字典的键（Key）不允许重复。
元素类型：字符串仅能存放字符；字典是键值对结构，键必须可哈希，值无限制。

sorted通用排序：sorted(可迭代对象)

可迭代对象内置类型：string, list, tuple, set, dict

1. 字符串排序

str1 = "dfeacbjklnmoqpzrtyuivcx"

正向排序，返回排序后的字符列表

str_list = sorted(str1)
print("字符串正向排序结果：", str_list)

反向排序

reverse_str_list = sorted(str1, reverse=True)
print("字符串反向排序结果：", reverse_str_list)

print("------------------------------------------------------")

2. 列表排序

list_l = [9, 3, 4, 2, 1, 5, 7, 6, 8]
l1 = sorted(list_l)
print("列表正向排序结果：", l1)

print("------------------------------------------------------")

3. 元组排序

t1 = 9, 3, 4, 2, 1, 5, 7, 6, 8
list_t = sorted(t1)
print("元组排序结果：", list_t)

print("------------------------------------------------------")

4. 集合排序

set_list = {9, 3, 4, 2, 1, 5, 7, 6, 8}
list_set = sorted(set_list)
print("集合排序结果：", list_set)

print("------------------------------------------------------")

5. 字典排序

d1 = {1001: "gaowanxi", 1005: "lisi", 1003: "zhangsan", 1004: "malu"}

字典sorted默认按key排序，返回排序后的key列表

d_list = sorted(d1)
print("字典按键排序结果：", d_list)

按value排序的写法

d_list_value = sorted(d1.items(), key=lambda x: x[1])
print("字典按value排序结果：", d_list_value)

Python基础16：JSON的使用

复制代码

# ===================== JSON序列化基础概念 =====================
# 序列化：把数据容器对象转为字符串，用于文件保存/网络传输
# 反序列化：把JSON字符串/文件数据，还原成Python容器对象
# JSON支持序列化：列表list、元组tuple、字典dict；set集合不支持
# json包4个核心API：
# dumps()  对象 → JSON字符串      loads() JSON字符串 → 对象
# dump()   对象 → 文件流          load()  文件流 → 对象
# 口诀：带s的操作【字符串】，不带s的操作【文件】

# import 相当于C/C++ #include 头文件
import json

# -------------------- 1. list列表 序列化与反序列化 --------------------
list_1 = [5, 3, 4, 5, 2, 5, 23, 3]
str_list = json.dumps(list_1)
print(str_list)
print(type(str_list))

list_2 = json.loads(str_list)
print(list_2)
print(type(list_2))

print("------------------------------------------------------")

# -------------------- 2. tuple元组 序列化与反序列化 --------------------
tuple_1 = (5, 3, 4, 5, 2, 5, 23, 3)
str_tuple = json.dumps(tuple_1)
print(str_tuple)
print(type(str_tuple))

# ⚠️重点：元组序列化后，loads还原得到的是list，不再是tuple
tuple_2 = json.loads(str_tuple)
print(tuple_2)
print(type(tuple_2))

print("------------------------------------------------------")

# -------------------- 3. dict字典 序列化与反序列化 --------------------
# ensure_ascii=False 解决中文被转义问题
d1 = {"姓名": "gaowanxi", "年龄": 35}
str_d1 = json.dumps(d1, ensure_ascii=False)
print(str_d1)
print(type(str_d1))

d2 = json.loads(str_d1)
print(d2)
print(type(d2))

print("----------------以下为文件相关的json操作----------------")

# -------------------- 4. dump / load 文件读写JSON --------------------
# 1）序列化：将容器对象写入json文件
d3 = [{"姓名": "gaowanxi", "年龄": 35}, {"姓名": "lisi", "年龄": 28}, {"姓名": "Wangwu", "年龄": 22}]
f = open("./data.json", "w", encoding="utf-8")
json.dump(d3, f, ensure_ascii=False)
f.close()

# 2）反序列化：读取json文件，还原成容器对象
f1 = open("./data.json", "r", encoding="utf-8")
d4 = json.load(f1)
f1.close()

print(d4)
print(type(d4))

Python基础17：文件相关操作与with语句块

复制代码

# ===================== 文件打开模式说明 =====================
# r   只读模式；w   只写模式；r+ 读写模式
# 如果操作二进制文件，模式后面加上字母 b（rb / wb / ab）

# 打开文本文件，读写模式 r+，指定编码utf-8
f = open("./mytext.txt", "r+", encoding="utf-8")
print(type(f))

# write() 写入多行文本
f.write("姓名:高万喜，年龄：35\n"
        "姓名:李四，年龄：28\n"
        "姓名:王五，年龄：22\n")

# 文件光标操作 seek(offset, whence)
# whence标记位：0 文件开头，1 当前位置，2 文件末尾
# ⚠️文本模式下仅支持 whence=0
f.seek(0)

# ---------------------- 文件读取方式 ----------------------
# 方式1：read(-1) 一次性读取全部内容
# str_text = f.read(-1)
# print(str_text)

# 方式2：readline() 只读取一行
text_line = f.readline()
print(text_line)

print("--------------------------------------------------")
# 方式3：readlines() 读取所有行，返回字符串列表
text_lines = f.readlines()
print(text_lines)
print("--------------------------------------------------")

# 方式4：list()强制转换文件对象，得到所有行列表
f.seek(0)
text_lines = list(f)
print(text_lines)
print()

# 文件对象属于【可迭代对象】，支持for循环逐行读取
print("--------------------------------------------------")
f.seek(0)
# print(dir(f)) # 查看文件对象所有内置方法
for i in f:
    print(i, end="")

# 文件操作完毕，必须手动关闭释放资源
f.close()

# ===================== 二进制文件读写示例（图片/视频等） =====================
# rb+ 二进制读写模式
f2 = open("d:/Gril.png", "rb+")
str_binary = f2.read()
print(str_binary)
f2.close()

# wb 二进制只写模式，复制图片文件
f3 = open("./my_pixmap.png", "wb")
f3.write(str_binary)
f3.close()

# ===================== with 语句块（上下文管理器，推荐！） =====================
# with 原理：类必须实现 __enter__（进入）、__exit__（退出）两个魔法方法
class A:
    def __enter__(self):
        print("进入了")
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("出来了")

print("--------------------------------------------------")
with A() as f:
    print("abc")

# with 打开文件：代码块结束自动调用close()，防止忘记关闭
with open("./mytext.txt", "r", encoding="utf-8") as f5:
    for line in f5:
        print(line, end="")

"""
知识点总结：
1、open打开模式区分
文本模式：r / w / r+ / a
二进制模式：rb / wb / rb+ / ab （不能写encoding参数）
r：文件不存在 → 报错
w：文件不存在自动创建；存在直接清空原有内容
r+：可读可写，文件不存在报错；从光标位置覆盖写入

2、光标 seek(0) 回到文件头部；读写共用同一个光标，写完需要seek才能从头读取

3、读取方法区别
read()：读取全部，返回str
readline()：读取一行
readlines()：读取全部行，list[str]
for in f：逐行迭代，节省内存，大文件首选

4、二进制文件：图片、音频、视频、exe都必须用带b模式读写

5、with上下文管理器优势
自动关闭文件，即使代码发生异常也能安全释放句柄，工程开发优先使用

6、重要限制
文本模式下 seek 仅支持相对于文件开头偏移；
想要使用相对当前、文件末尾偏移，必须打开为二进制模式
"""

Python基础18：面向对象之构造与析构

复制代码

# 1.在python定义一个类的语法形式：
class Person:
    # 成员属性
    name = None
    age = None

    # 成员方法：self 类似于C++中this指针，只要是非静态成员方法第一个参数必须是self
    def hard_work(self):
        print("姓名：%s，年龄：%d正在努力的工作！！！！" % (self.name, self.age))

    # 类中的构造方法 __init__
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("Person类的构造")

    # 析构方法 __del__
    def __del__(self):
        print("Person的析构")

# 关于类对象的构建方式：
p = Person("gaowanxi", 35)
p.hard_work()
print(p.__dir__())
print(p.__dict__)

"""
核心知识点笔记：
1、class 关键字用来定义类；Python3 自定义类默认继承 object 基类
2、self：实例方法第一个形参，代表当前对象本身，类比C++ this指针
3、__init__(self,...) 构造方法
   创建对象时自动调用，用来初始化成员属性；
   如果有额外参数，实例化 Person(参数) 时传入
4、__del__(self) 析构方法
   对象被系统垃圾回收时自动调用，一般用来释放资源；
   无法确定执行时机，不要依赖它做关键清理
5、实例化：对象变量 = 类名(构造参数)
6、访问：对象.属性 / 对象.方法()
7、内置属性：
   __dict__ ：字典，存放该对象自身所有成员属性
   __dir__()：返回对象所有可用属性、方法列表
8、⚠注意：
   写 hard_work 打印必须带上 self.name / self.age，
   直接写name会优先找局部变量，会报错
"""

类型差异（载体不同）
print(type(obj.__dir__()))  # 输出：<class 'generator'>
print(type(dir(obj)))       # 输出：<class 'list'>

Python基础5：Python中条件语句块

Python基础6：Python中循环语句块

Python基础7：Python中的函数

Python基础8：深入了解Python函数

Python基础9：了解Python中的数据容器

Python基础10：了解列表的增删改查操作

Python基础11：列表注意事项及切片的使用

Python基础12：元组

Python基础13：set集合

Python基础14：字典dict

Python基础15：数据容器特性总结与通用排序sorted的介绍

数据容器特点对比表

补充说明（对应表格核心差异）

sorted通用排序：sorted(可迭代对象)

可迭代对象内置类型：string, list, tuple, set, dict

1. 字符串排序

正向排序，返回排序后的字符列表

反向排序

2. 列表排序

3. 元组排序

4. 集合排序

5. 字典排序

字典sorted默认按key排序，返回排序后的key列表

按value排序的写法

Python基础16：JSON的使用

Python基础17：文件相关操作与with语句块

Python基础18：面向对象之构造与析构