python基础学习

练习网站：猪八戒；程序员客栈；猿急送；码市；智城外包网；实现网；人人开发；开发邦；电鸭社区；快码；英选；外包大师；智筹；自由职客；解放号；

应用：python开发；爬虫开发；数据挖掘；人工智能；自动化测试；自动化运维；

开发工具：python解释器；pycharm编译器

（若对知识点不清晰，可将程序粘贴到编译器里查看结果）

01-输入函数和输出函数.py：

"""
    python输出函数与输入函数：
    　　输出函数：print()
    　　输入函数：input()
"""
print("你好！欢迎了解python的世界。")
your_id = input("请输入你的ID:")
print("工号" + your_id + "，欢迎您的到来！望您学有所获！")

02-python的转义符.py：

"""
　　python的转义符：
　　　　转义符，即\+特异功能的首字母
　　1、\n：换行
　　2、\t：制表符
　　3、\r：覆盖
　　4、\b：删除
　　5、\\：表示一个\
　　6、原字符：使转义字符不起作用，写在前面，用r或R
"""
print("今天天气不错!\n一起出去走走。")   # 换行操作
print("性别\t年龄\t住址") # 补齐4个空格（占位）
print("花\r草")   # ‘草’会覆盖‘花’
print("Your_\bName")    # b -> 键盘上的backspace
print(r"\\", "\\")

03-python的基础语法.py:

"""
　　python 关键字
　　缩进->键盘中的空格键->4个空格->tab键
　　多行语句
　　python 引号"..." '...' """"""
　　python 注释 #
　　python 空格和空行->美化作用，非必须
"""
import keyword
print(keyword.kwlist)
num_1 = 1
num_2 = 3
num_3 = 7
sum_ = num_1 + \
      num_2 + \
      num_3
data_1 = [1,
          3,
          7]
data_2 = (1,
          3,
          7)
data_3 = {
    "工号": "9816",
    "年龄": "20"
}
print(sum_, data_1, data_2, data_3)

04-python的变量.py:

"""
　　变量：
　　　　1.1 变量命名规则：
　　　　*变量名只能是字母，数字下划线的任意组合
　　　　*变量名第一个字符不能是数字
　　　　*变量名区分大小写，大小写字母被认为是两个不同的字符
　　　　*特殊关键字不能命名为变量名
　　　　1.2变量赋值
　　　　1.3多个变量赋值
　　　　1.4常量
"""
num_1, num_2, num_3 = 100, 200, 300
BI = 3.1415926  # 约定大写为常量（可改变）

05-python数据类型.py:

"""
　　python3中的六个标准数据类型中：
　　·不可变数据（3个）：Number（数字）、String（字符串）、Tuple（元组）；
　　·可变数据（3个）：List（列表）、Dictionary（字典）、Set（集合）。
　　数字：python3 支持 int、float、bool
　　　　1.1整型（Int）- 通常被称为整型或者整数，是正或负整数，不带小数点
　　　　1.2浮点型（float）-浮点型由整数部分与小数部分组成
　　　　1.3布尔型（bool）-True False
"""
I_num = 100
f_num = 99.9
b_num = True

06-python数值运算.py:

"""
/　　两个数相除，结果为浮点数（小数）
//　　两个数相除，结果为向下取整的整数
%　　取模，返回两个数相除的余数
**　　幂运算，返回乘方结果
"""
print("-----加法运算-----", 4+5)
print("-----减法运算-----", 6-3)
print("-----乘法运算-----", 3*5)
print("-----除法运算-----", 2/4)
print("-----加法运算，向下取整-----", 2//4)  # 0
print("-----取模，返回两个数相除的余数-----", 7 % 3)  # 1
print("-----幂运算，返回乘方结果-----", 2**3)  # 8

07-python支持常见的比较运算符.py:

"""
　　python支持常见的比较运算符：
　　　　>　　  大于
　　　　>=　　大于等于
　　　　<　　  小于
　　　　<=　　小于等于
　　　　!=　　不等于
　　　　==　　等于
　　返回bool值：
　　　　True = 1 False = 0
"""
print(1+(3 > 2))
print(1 + True)

08-python运算符与或非.py:

"""
　　布尔值也可用and、or和not运算
　　and -> 与
　　　　and运算是与运算，只有所有都为True, and运算结果才是True
　　or -> 或
　　　　or运算是或运算，只要其中有一个为True, or运算结果就是True
　　not -> 非（不是）
　　　　not运算是非运算，它是一个单目运算符，把True变成False，把False变成True，
      表示对后面的布尔表达式进行取反运算
"""
print(True and True)
print(True or False)
print(not False)

09-python的空值以及内置函数的返回值.py:

"""
　　1.python的空值 --- None 什么都没有 单独存在的数据类型
　　2.内置函数的返回值->None 函数运行后是可以有返回值（在于自己的设置）
"""
result = print("======result======")
print("======", result, "======")

 10-字符串切片.py：

"""
　　[:]->切片的是整个字符串
　　[::-1]->整个字符串反转
　 落  落 大  方 且  冰 雪  聪 明
　　0  1  2  3  4  5  6  7  8
　　-9 -8 -7 -6 -5 -4 -3 -2 -1 0
"""
name = "落落大方且冰雪聪明"
# 切片  [开始:结尾]  取左不取右
print(name[0:4])
print(name[-2:])
# 切片  [开始:结尾:步长]  取左不取右
print(name[0:5:2])

 11-字符串下表取值.py：

# 字符串索引  下标->正向由0开始，逆向由-1开始
str_ = "天气晴！"  # 空格也是字符
print(str_[0])
print(str_[-1])

 12-字符串拼接.py：

"""
　　字符串拼接 +
"""
str_ = '100' + '号'
print(str_)
wel_ = "欢迎光临"
val_ = "新客有优惠"
com_ = ','.join((wel_, val_))
print(com_)

 13-字符串格式化.py：

"""
　　字符串格式化 {}
　　format()
"""
intro = "大家好，我的名字叫{}，今年{}岁".format("杳", "18")
#                                           0 　  1
print(intro)
intro_ = "大家好，我的名字叫{1}，今年{0}岁".format("18", "杳")
print(intro_)
intro_1 = "大家好，我的名字叫{}，今年{}岁"
print(intro_1.format("杳", "18"))

 14-字符串查找元素位置.py：

"""
　　find:查找元素位置
　　查找字符串片段在字符串中的下标位置，从前往后找，返回的是第一个被找到字符串片段起始位置
　　第一个参数：查找的字符串片段
　　第二个参数：要查找的起始点
　　第三个参数：要找到终止位置-1
　　如果查找的字符串存在多个，查找结果是第一个出现的字符串下标
　　找不到就返回-1
count：统计字符串片段，在字符串中出现的次数
　　找不到返回0
"""
str_1 = "python studying"
print(str_1.find("u", 6, 15))
print(str_1.find("a", 6, 15))
print(str_1.count("y", 1, 15))

 15-字符串常用方法.py：

"""
    字符串常用方法：
        replace:替换指定的字符串片段
        参数1：要替换的字符串片段
        参数2：替换之后的字符串片段
        参数3：替换的次数，从前往后替换（默认替换所有）
        upper:将小写字母转为大写
        lower:将大写字母转成小写
        split:指定分割点对字符串进行分割
        参数1：分割点
        参数2：分割的次数（默认找到所有的分割点进行分割）
        strip:去除字符串首尾的空格
"""
str_1 = "Python Learning"
res = str_1.replace('n', 'm', 1)
print(res)
str_2 = str_1.upper()
print(str_2)
str_3 = str_1.lower()
print(str_3)
str_4 = "Learn&Study&K"
# 将字符串，用规定的字符”&“进行分割，得到一个列表
print(str_4.split('&', 1))
str_5 = "  Learn  "
print(str_5.strip())
str_6 = "###Study###"
print(str_6.strip('#'))
str_7 = " Learn Study K "
print(str_7.replace(' ', ''))

 16-字符串传统的格式化输出方法.py：

"""
    字符串传统的格式化输出方法:%
    %s:为字符占位，任意类型都可以
    %d:为数值类型占位
    %f:为浮点数占位
"""
str_1 = '%s茶' % '喝'
str_2 = '数字：%d' % 100
str_3 = '数字：%f' % 10.0
print(str_1, str_2, str_3)
name_ = "杳"
age_ = 18
intro_1 = F"大家好，我的名字叫{name_}，今年{age_}岁"  # F表达式（F、f都一样）
print(intro_1)

 17-字符串format的进阶用法.py：

"""
    len():字符串的长度
    format:格式化输出（进阶）
        1.格式化小数长度（四舍五入） :.2f
        2.将小数按百分比的形式显示  :.2%
"""
str_1 = "study python"
print(len(str_1))
str_2 = 93572.267
re_str = 1.837
i_num = 437
print("浮点数小数部分精度（2）：{1:.2f},{1:.2E},{1:.2e}".format(str_2, re_str))
print("占比：{:.2%}".format(0.397))  # {占位符:}
print("占比：{0:*<20}".format(str_1))  # 字符串显示宽度是20，左对齐，空白部分使用*填充
print("占比：{0:*>20}".format(str_1))  # 字符串显示宽度是20，右对齐，空白部分使用*填充
print("占比：{0:*^20}".format(str_1))  # 字符串显示宽度是20，居中对齐，空白部分使用*填充
print("千位分隔符（只是用与整数和浮点数）：{0:,}".format(str_2))
print("字符串类型的最大显示长度：{0:.5}".format(str_1))
print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(i_num))

   18-定义列表.py：

"""
    列表：
        1.定义列表
        2.列表的下标 从0开始
        3.列表取值
"""
list_1 = [12, 9, 21, "星", [10, 34, 7]]
print(list_1[4][0])

   19-列表的长度和更新列表.py：

"""
    1.列表的长度 len()
    2.更新列表中的值
"""
list_1 = [21, 39, 7, 97, 136]
print(len(list_1))
list_1[3] = 52
print(list_1)

  20-列表的加法和乘法操作.py：

"""
    列表的加法和乘法操作
"""
list_1 = [17, 5, 26]
list_2 = [8, 27, 95]
print(list_1 + list_2)  # 拼接成一个新列表
print(list_1*2)  # 重复写两次值形成一个新列表

  21-列表的切片取值.py：

"""
    列表的切片取值
"""
list_1 = [14, 6, 9, 32]
print(list_1[0:3])
print(list_1[-3:])
print(list_1[0:3:2])
print(list_1[-3::3])
print(list_1[:])
print(list_1[::-1])

  22-列表的操作方法.py：

"""
    列表的操作方法:
        1.del关键字    删除
        2.append函数
            append函数用于向列表末尾添加元素
        3.insert函数
            insert函数用于向列表中插入元素
            第一个参数：插入的位置
            第二个参数：要插入的对象
        4.clear函数用于将列表清空
        5.remove函数
            remove函数用于从列表中移除元素
            若列表中有重复元素，remove函数只会移除匹配到的第一个
        6.pop函数
            pop函数用于移除列表中指定位置的元素，并返回要移除的元素
            在默认的情况下，移除列表中最后一个元素
        7.index函数
            index函数用于返回所匹配元素的索引
            第一个参数：待查找的对象
            第二个参数：查找的起始范围
            第三个参数：查找的结束范围
        8.reverse函数
            reverse函数用于将列表反向排列
        9.extend函数
            extend函数用于在列表的末尾添加另一个列表
            与append函数相比，extend函数可以一次添加多个元素
            使用extend函数和列表加法的结果一样，但是extend函数会将另一个列表并入当前列表，
            而列表加法返回新的列表，为了节省内存空间，推荐使用extend函数来实现列表的连接操作
        10.copy函数
           copy函数用于创建列表的副本
        11.sort函数
            sort函数用于将列表进行排序（按照ASCII码科普排序）
            常见ASCII码的大小规则：0~9<A~Z<a~z
            需同类型数据比较
        12.count函数
            count函数用于统计某个元素在列表中出现的次数
"""
list_1 = [18, 21, 32, 18, 37]
list_2 = list_1.copy()  # 相比于赋值'='，不会影响原始列表
del list_1[2]  # 在计算机（内存）中变量(list_1)或指定值(list_1[2])被删除
print("del:", list_1)
print("删除list_1[2]，查看list_2是否变化:", list_2)
list_1.append(18)
print("append:", list_1)
list_1.insert(1, "莲")
print("insert:", list_1)
list_1.remove(18)
print("remove:", list_1)
pop_ = list_1.pop(0)
print("pop:", list_1, ",移除元素:", pop_)
loc_ = list_1.index(18, 0, 3)
print("index:", loc_, "列表:", list_1)
list_1.reverse()
print("reverse:", list_1)
list_1.extend([96, 35])
print("extend:", list_1)
list_2.sort()   # 升序排序
print("sort升序排序:", list_2)
list_2.sort(reverse=True)   # 降序排序
print("sort降序排序:", list_2)
cont_ = list_2.count(18)
print("count:", cont_)
list_1.clear()
print("clear:", list_1)

  23-元组的创建.py：

"""
    1.元组也是一种数据容器，使用小括号"()"表示，使用场景与列表相似。唯一区别是元组不可变
    2.元组的元素类型可以不统一
"""
tuple_1 = ("python", 36, 4.7, [10.2, 9.3])
print(tuple_1)

  24-元组的加法与数据更新.py：

"""
    元组的拼接
"""
tuple_1 = ("杳", "貅")
tuple_2 = ([10, 36], [95])
tuple_3 = tuple_1 + tuple_2
print(tuple_3)
tuple_3[2][1] = "奇"  # 元组内列表可修改
print(tuple_3)

 25-元组列表字符串的共同操作.py：

"""
    关于元组、列表、字符串的一些共同操作
    len()、max()、min() 同类型比较
"""
tuple_1 = (19, 42, 76, 8)
list_1 = [19, 42, 76, 8]
str_1 = "1942貅p"
print(len(tuple_1), ",", len(list_1), ",", len(str_1))
print(max(tuple_1), ",", max(list_1), ",", max(str_1))
print(min(tuple_1), ",", min(list_1), ",", min(str_1))

 26-元组的注意事项以及乘号的使用.py：

"""
     元组的注意事项以及乘号的使用
"""
tuple_1 = (20, 9)
tuple_2 = 20, 9  # 多个数据，可以不加"()"
tuple_3 = (12,)  # 写一个数据时，元组需要加“,”，否则，为单条数据
print(tuple_1, ",", tuple_2, ",", tuple_3)
print(tuple_3*3)

 27-集合的创建.py：

"""
    集合：
        集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合中默认去重
        创建集合：
            1.变量名 = set(元素) 字符串、列表、元组、字典
            2.变量名 = {元素,元素,...} 字符串、元组、数字
            3.元素是唯一的，用于列表的去重
"""
gather_1 = set("2693")
print(gather_1)
gather_2 = set([19, 26, 72])
print(gather_2)
gather_3 = set((1, 6, 7))
print(gather_3)
gather_4 = set({"年龄": 18, "姓名": "杳"})  # 针对键名
print(gather_4)
gather_5 = {"2693", (1, 6, 7), 18}  # 字典和列表用"{}"时，不可用
print(gather_5)
gather_6 = set([1, 6, 7, 1, 7, 9])
print(gather_6)

 28-集合的常见操作方法.py：

"""
     集合的常见操作方法:
        1.add()
            往集合中添加元素    数字、字符串、元组
        2.update()
            将集合合并
            集合随机排列
        3.remove()
            使用remove删除集合中的元素，如果存在，直接删除，否则，程序报错
        4.pop()
            使用pop删除是随机删除集合中的元素，如果集合中没有元素，程序报错
        5.discard
            使用discard删除，如果元素存在，直接删除，否则，不做任何操作
        6.交集
            使用"&"符号连接多个集合，得到相同的元素
        7.并集
            使用"|"符号连接多个集合，得到集合中的全部元素
"""
gather_1 = {12, 53, 79}
gather_1.add(17)
print(gather_1)
gather_1.add("杳")
print(gather_1)
gather_1.add((23, 59))
print(gather_1)
gather_2 = {"貅", "俏", "雅", 24}
gather_1.update(gather_2)
print(gather_1)
gather_1.remove("貅")
print(gather_1)
gather_2.pop()
print(gather_2)
gather_1.discard(53)
print(gather_1)
gather_3 = gather_1 & gather_2
print(gather_3)
gather_4 = gather_1 | gather_2
print(gather_4)

 29-创建字典.py：

"""
    字典是一种映射类型，它的元素是键值对，字典的键必须为不可变类型，且不能重复
    键可以是任意不可变类型（元组、字符串、数字）
    1.字典的创建方式
        1.1直接使用"{}"
        1.2使用dict()
    2.空字典
"""
dictionary_1 = {
    "姓名": "杳",
    16: 21,
    (68, 79): "19"
}
print(dictionary_1)
dictionary_2 = dict((["年龄", 18], ["兴趣", "画竹"]))
print(dictionary_2)
dictionary_3 = {}  # 直接写"{}"表示字典
gather_1 = set()  # 空集合
print(dictionary_3)
print(gather_1)

 30-修改和删除字典.py：

"""
    字典的增删改查操作
"""
dictionary_1 = {
    "姓名": "杳",
    "年龄": 21
}
dictionary_1["兴趣"] = "画竹"
print(dictionary_1)
del dictionary_1["兴趣"]
print(dictionary_1)
dictionary_1["姓名"] = "岐"
print(dictionary_1)
print(dictionary_1["年龄"])

 31-字典的操作方法.py：

"""
    字典的操作方法：
        1.get函数
            get函数用于从字典获取指定键的值，在get函数中可以设置默认值，
            当get函数没有获取到对应键时，get函数会将默认值返回
        2.keys函数
            keys函数将以列表的形式返回字典中的所有键
        3.items函数
            items函数将以列表的形式返回字典里的所有键值对
        4.values函数
            values函数将以列表的形式返回字典中的所有值
        5.clear函数
            clear函数用于将字典清空
        6.copy函数
            copy函数用于创建字典的副本，修改原字典对象，不会影响其副本
        7.fromkeys函数
            fromkeys函数用于创建一个新的字典
                第一个参数是一个序列（列表、元组、集合），用于作为字典的键
                第二个参数是可以是任意数据类型，作为每个键的值
        8.pop函数
            pop函数用于从字典中移除指定键，并返回改键所对应的值
        9.popitem函数
            popitem函数用于从字典中删除最后一项，并以元组形式返回该项所对应的键和值
        10.setdefault函数
            setdefault函数用于设置键的默认值
            若在字典中改键已经存在，则忽略设置，否则，添加改键和值
        11.update函数
            update函数用于将字典2的值更新到字典1
            若字典2的键在字典1已经存在，则对字典1进行修改，否则，对字典1进行添加
"""
dictionary_1 = {
    "姓名": "杳",
    "年龄": 18,
    "年龄": 21,   # 保留最后一个同名数据，会覆盖前一个同名数据
    "活动": {
        "活动1": "乒乓",
        "活动2": "排球"
    }
}
value_1 = dictionary_1.get("姓名")
value_2 = dictionary_1.get("兴趣")
value_3 = dictionary_1.get("兴趣", "画竹")
print(value_1, ",", value_2, ",", value_3)
print(dictionary_1)
print(dictionary_1.keys())
result_1 = dictionary_1.items()
print(result_1)
result_2 = dictionary_1.values()
print(result_2)
dictionary_2 = dictionary_1.copy()
print(dictionary_2)
dictionary_2.clear()
print(dictionary_2)
dictionary_3 = {}
dic_1 = dictionary_3.fromkeys(("名字", "年龄"), (12, 35))  # (12, 35)作为一个整体赋予键
print(dic_1)
result_3 = dictionary_1.pop("活动")
print(dictionary_1, ",", result_3)
result_4 = dictionary_1.popitem()
print(dictionary_1, ",", result_4)
dictionary_1.setdefault("兴趣", "画竹")
print(dictionary_1)
dictionary_4 = {
    "姓名": "卿",
    "活动": "排球"
}
dictionary_1.update(dictionary_4)
print(dictionary_1)

 32-成员与标识检测.py：

"""
    成员检测与标识检测
        使用"in"和"not in"运算符来判断某个对象是否为序列成员
        in:判断对象是否在序列（列表、字符串、元组、字典）中，如果是，返回True
        not in:判断对象是否不在序列中，如果是，返回True
"""
print("3" in "13529")  # 字符串3是否存在于字符串”13529“中
print(12 in (12, 26, 72))
print(14 in [12, 56])
print("姓名" in {"姓名": "杳"})  # 仅仅判断键
print(14 not in [12, 56])

 33-判断某两个对象是否相同.py：

"""
    判断某两个对象是否相同，使用is和not is运算符
    is（是） 判断对象是否相同
    is not（不是）判断对象是否不相同
    数字、字符串、元组（都是不可变的数据类型） 表面一样，则完全一样
    列表、字典、集合（都是可变的数据类型） 表面一样，其实不一样，已经不是同一个对象
"""
str_1 = "杳"
str_2 = "python"
print(str_1 is str_2)
print(str_1 is not str_2)

 34-python数据类型转换.py：

"""
    python的类型转换
        1.字符串类型 String
        2.数字类型 Number
            整型 int
            浮点型 float
            布尔类型 boot
        3.表类型 List
        4.元组类型 Tuple
        5.字典类型 Dictionary
        6.集合类型 Set
    由于不同的数据类型之间是不能进行运算的，所以我们需要数据类型转换。
    python中的数据类型转换有两种:
        一种是自动类型转换，即python在计算中会自动将不同类型的数据
        转换成同类数据来进行计算，另一种是强制类型转换，即需要我们基
        于不同的开发需求，强制将一个数据类型转换成另一个数据类型
        7.自动类型转换
            当两个不同类型的数据进行运算时，结果会向更高精度进行计算
            精度等级：布尔<整型<浮点型
        8.检测数据类型的方法
            type()
        9.强制类型转换
            str():可以把其他类型数据转化为字符串类型
                  所有类型都可以转化为字符串类型
            int():可以把其他数据类型转换成整型
            float():可以把其他数据类型转换成浮点型
                  数字类型之间可以相互转换
                  只有字符串可以转换为数字类型，并且字符串的元素必须为纯整型数字，否则无法转换
            bool():可以把其他类型转换为True或False
                  容器类型转换成布尔类型：
                    容器类型数据：字符串、列表、元组、字典、集合
                    非容器类型数据：数字类型、布尔类型
                    容器为空->False
                    容器中有元素->True
                  数字类型转换成布尔类型：
                    int类型中，0为False，其他为真
                    float类型中，0.0为False，其他为真
            list():数字类型是非容器类型，不能转换成列表
                   字符串转换成列表时，会把字符串中的每一个字符当作列表的元素
                   元组转换成列表时，会把字符串中的每一个字符当作列表的元素
                   字典转换成列表时，只保留字典中的键
                   集合转换成列表时，结果是无序的，因为集合本身就是无序的
            tuple():其他类型数据转换成元组类型与其他类型数据转换成列表类型的规则相同
            set():数字类型是非容器类型，不能转换成集合
                  字符串、列表、元组、字典转化成集合时，结果是无序的，字典只保留键
            dict():数字类型是非容器类型，不能转换成字典
                   字符串不能转换成字典类型，因为字符串不能生成二级容器
                   列表、元组类型转换成字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2
                   集合不能转换成字典类型
"""
num_ = 10
boot_ = True
print(num_ + boot_)
float_ = 3.14
print(num_ + float_)
str_ = "10"
print(type(str_), ",", type(num_))
result_ns = str(num_)
print(result_ns, ",", type(result_ns))
result_nf = float(num_)
print(result_nf, ",", type(result_nf))
result_fi = int(float_)  # 不会四舍五入
print(result_fi, ",", type(result_fi))
result_sf = float(str_)
print(result_sf, ",", type(result_sf))

str_1 = ""  # 空字符串
list_1 = []  # 空列表
tuple_1 = ()  # 空元组
dictionary_1 = {}  # 空字典
gather_1 = set()  # 空集合
print(bool(str_1), ",", bool(list_1), ",", bool(tuple_1), ",", 
      bool(dictionary_1), ",", bool(gather_1))
print(bool(num_))

print(list(str_))
dictionary_2 = {
    "姓名": "杳"
}
print(list(dictionary_2))
print(tuple(str_))
print(tuple(dictionary_2))
print(set(str_))
print(set(dictionary_2))
list_2 = [["num_", 12], ["姓名", "杳"], ["str", "python"]]
print(dict(list_2))
tuple_2 = (("姓名", "杳"), ("str", "python"))
print(dict(tuple_2))

 35-python判断对象是否为已知类型.py：

"""
    isinstance()用来判断一个对象是否是一个已知的类型
                函数的返回值是布尔型
                若对象的类型为已知的类型，则返回True，否则，返回False
                用法：isinstance(对象，对象类型)
"""
i_num = 127
print(isinstance(i_num, int))
print(isinstance(i_num, float))
print(isinstance(i_num, (int, float, dict)))

 36-python的流程控制.py：

"""
     python的流程控制：
        if语句：
            if...elif...else...分支语句
            if...else...
            if语句可单独存在
        for语句：
            for循环用来遍历序列，通过不使用下标的方式来实现对序列中每一个元素的访问
            （列表、元组、字符串、字典、集合）
            遍历数字
                range()函数的步长
            遍历字典的键与值 字典dictionary.items()
        while语句：
            可以配合else使用
        循环中的关键字：
            break 语句可以跳出for和while的循环体
            continue 语句被用来跳过当前循环快中的剩余语句，然后继续进行下一轮循环
        pass语句：
            pass是空语句，是为了保持程序结构的完整性
            用于那些语法上必须要有什么语句，但程序什么也不会做的场合
"""
if 3 > 1:
    print("兴趣")

if 3 < 1:
    print("欢迎")
elif 9 > 8:
    print("活动")
else:
    print("杳")

dictionary_1 = {"姓名": "杳", "年龄": 16}

for num_k in dictionary_1:
    print(num_k)
for num_a in dictionary_1.items():
    print(num_a)
for i_num_ in range(0, 5, 2):  # 0-5区间 0  2   4
    print(i_num_)
# 嵌套
list_1 = [12, 35, 98, [16, 47], [29, 77]]
for emu in list_1:
    print(emu)
    # 条件判断
    if isinstance(emu, list):
        for emn in emu:
            if emn == 47:
                print("跳出当前的for循环")
                break
            if emn == 29:
                print("不输出当前值")
                continue
            print(emn)

c_num = 3
while c_num <= 5:
    c_num += 1
    print(c_num)
else:
    print("c_num已经大于5，不满足循环条件")

c_num_1 = 1
while c_num_1 <= 5:
    if c_num_1 == 4:
        print("跳出当前的while循环")
        break
    c_num_1 += 1
    if c_num_1 == 3:
        print("不输出当前值")
        continue
    print(c_num_1)

for cunt in range(0, 10):
    pass  # 没有想好写什么，预留位置

 37-python的函数创建与参数.py：

"""
    函数的定义与调用
    创建函数的目的是封装业务逻辑，实现代码的重复使用
    创建函数的关键字：def
    函数的参数
    1.函数中的pass关键字
    2.位置参数：在对函数进行调用的时候，有几个位置参数就需要传递几个参数，否则会触发异常，
      传递的参数要与函数参数列表中一一对应
    3.默认参数：
      默认参数指的是带有默认值的参数（函数定义时），在对该函数进行调用的时候，
      可以不必显示传递给该函数。
      当不传递值的时候，函数将使用默认值，默认值只会执行一次，默认值为可变对象
      （列表、字典以及大多数的实例）
      官方建议默认参数尽量使用不可变对象，因为可变对象会将当前传递的参数存储到可变对象中，
      在后续调用中，作为新的传递参数
    4.关键字参数：
      关键字参数（函数调用）：函数调用时，指定参数名称，称为关键字参数，函数调用时，
      关键字参数必须在普通参数后面
      限定关键字形参（即关键字参数），必须使用关键字方式传递参数
      限定关键字形参，是为了限定后面几个参数只能按照关键字传递，应为后面的几个形参名
      具有十分明显的含义，
      显式写出有利于可读性，或者是后面的几个形参随着版本的更迭很可能发生变化，
      强制关键字形式有利于保证跨版本兼容性
    实际生产的过程中，使用最多的是自定义函数
    5.可变参数：
      *参数：最常见的变量名是args，看到该变量名，一眼就知道变量args指向一个tuple对象
      自动收集所有未匹配的位置参数到一个tuple对象中，变量名args指向了此tuple对象
      **参数：常见的变量名是kwargs，看到该变量名，一眼就知道变量kwargs指向一个dict对象
      自动收集所有未匹配的关键字参数（"参数=值"）到一个dict对象中，变量名kwargs指向了此dict对象
    6.参数的解包（拆包）：
      参数数据类型是：字符串、列表、元组、集合、字典的时候可以解包
      传递实参时，可以在序列类型的参数前添加星号，会自动将序列中的元素依次作为参数传递
    7.python的参数解包与可变参数一起使用，其中，"**参数"只收集未匹配的关键字参数
    8.函数中各种参数排列位置：
      可变参数，必须定义在普通参数以及默认值参数的后面
      函数定义时，二者同时存在，一定要将*args放在**kwargs前面
"""
def print_l(i_num_l):  # i_num为位置参数
    print("输出数据:", i_num_l)

def print_m(i_num_mf=27,i_num_mn=73):  # i_num为默认参数，函数定义时
    print("输出数据:", i_num_mf, ",", i_num_mn)

def will_change_():
    pass  # 以后补充,暂时不写

def not_sug(val_1, val_2=[]):  # 列表为可变对象
    val_2.append(val_1)
    print(val_2)

def not_sug_change(val_1, val_2=None):
    if val_2 is None:
        val_2 = []
    val_2.append(val_1)
    print(val_2)

def print_k(i_num_kf,i_num_kn=73,i_num_kl=52):
    # i_num_kf为普通参数 i_num_kn为默认参数，后面必须也是默认参数
    print("输出数据:", i_num_kf, ",", i_num_kn, ",", i_num_kl)

def print_limit(i_num_limitf,*,i_num_limitn,i_num_limitl):
    # *只是占位， ”*“后面全部变为关键字参数，不可以直接传参，必须加上关键字
    print("输出数据:", i_num_limitf, ",", i_num_limitn, ",", i_num_limitl)

def print_c(i_num_limicf,*i_num_limicn):  # *i_num_limicn 通常会写成 *args
    print("输出数据:", i_num_limicf, ",", i_num_limicn)

def print_c2(i_num_limic2f,**i_num_limic2n):
    # **i_num_limic2n 通常会写成 **kwargs
    print("输出数据:", i_num_limic2f, ",", i_num_limic2n)

def print_dismantle(i_num_disf,i_num_disn,i_num_disl):
    print("输出数据:", i_num_disf, ",", i_num_disn, ",", i_num_disl)

def print_locright(i_num_lrf,i_num_lrn="杳", *i_num_lrm, **i_num_lrl):
    print("输出数据:", i_num_lrf, ",", i_num_lrn, ",", i_num_lrm, ",", i_num_lrl)

print_l(18)  # 传入任意的数据类型作为参数
print_m(39)  # 默认给第一个参数传值，其余参数使用默认值
print_m(i_num_mn=69)  # 指定默认传参进行传值，i_num_mn为关键字参数
not_sug(35)
not_sug(79)  # 期待结果是[79]，实际结果是[35, 79]
not_sug_change(35)
not_sug_change(79)  # 期待结果是[79]，实际结果是[79]
print_k(29, 65, 77)
print_k(29, i_num_kl=65, i_num_kn=77)  # 关键字位置可互换
print_limit(10, i_num_limitn=39, i_num_limitl=51)
print_c(37)  # i_num_limicf=37, i_num_limicn=() 空元组
print_c(37, 55, 22)  # i_num_limicf=37, i_num_limicn=(55, 22)
print_c2(399)
print_c2(399, num_1=45, num_2=62)  # num_1=45, num_2=62 关键字参数

str_ = "169"
list_ = [54, 32, 7]
print_dismantle(*str_)  # 长度要对应
print_dismantle(*list_)
dictionary_1 = {
    "姓名": "杳",
    "年龄": 19,
    "兴趣": "画竹"
}
dictionary_2 = {
    "i_num_disf": "杳",
    "i_num_disn": 19,
    "i_num_disl": "画竹"
}
print_dismantle(*dictionary_1)  # "*"取出的是键，不用与参数名一样
print_dismantle(**dictionary_2)  # "**"取出的是值，dictionary_2中键与参数名要一致
print_c(12, (21, 19, 30))
print_c(12, *(21, 19, 30))  # 参数解包
print_c2(11, **dictionary_1)  # 参数解包
print_locright(20, "祜", 12, 38, 91, mun_1=29, nun_2=59)

 38-python的函数返回值.py

"""
    函数的返回值：
        python中的函数可以使用return返回数据，也可以不用return返回，默认返回"None"
        return关键字，用于函数执行的时，返回处理好的结果
"""
def print_():
    pass

def print_re(i_num_1, i_num_2):
    return i_num_1 + 3, i_num_2 + 7
result_ = print_()
print(result_)
result_1 = print_re(13, 82)
print(type(result_1), result_1)  # 返回值为一个元组数据类型
num1_, num2_ = result_1
print(num1_)
print(num2_)

 39-python的函数返回函数.py

"""
     python的函数返回函数
       函数里面嵌套函数
       函数返回函数
"""
def out_func():
    def in_func():
        return [13, 28, 9]
    return in_func

result_1 = out_func()  # result_1接收的是一个函数
print(result_1)
result_2 = result_1()
print(result_2)

 40-字符串的编码与解码.py

"""
    字符串的编码与解码:
        字符串编码：
            最早字符串编码是美国标准信息交换码，ASCII，最多可以表示256个符号，一个字符占一个字节
            中文编码：GBK：我国制定的编码标准，英语占一个字节，中文占两个字节
                    GB2312：我国制定的编码标准，英文占一个字节，中文占两个字节
                    UTF-8：国际通用的编码，英文占一个字节，中文占三个字节
        str类型：表示Unicode字符（ASCII和其他字符）
        bytes类型：表示二进制数据（包括编码的文本）
                                网络传输
            内存（hello）---> 010010100101001--->内存（hello）
            str-----转换---->bytes-------转换--->str
"""
str_ = "你好"
bytes_ = str_.encode(encoding='utf-8', errors='ignore')  # strict/ignore/replace
str_1 = bytes_.decode(encoding='utf-8', errors='ignore')
print(bytes_)
print(str_1)

scode_gbk = str.encode("gbk")
scode_utf8 = str.encode("utf-8")  # 默认为utf-8
print(scode_gbk)
print(scode_utf8)

 41-数据的验证与处理.py 

"""
    对用户输入夫人数据进行“合法“性验证
        str.isdigit()：所有字符都是数字（阿拉伯数字）
        str.isnumeric()：所有字符都是数字
        str.isalpha()：所有字符都是字母（包含中文字符）
        str.isalnum()：所有字符都是数字或字母（包含中文字符）
        str.islower()：所有字符都是小写
        str.isupper()：所有字符都是大写
        str.istitle()：所有字符都是首字母大写
        str.isspace()：所有字符都是空白字符（\n、\t等）
"""
str_ = "前不见古人，后不见来者，念天地之悠悠，独怆然而涕下。"
print(str_)
gather_ = set(str_)
list_ = list(gather_)
list_.sort(key=str_.index)
print(" ".join(list_))

 42-字符串的正则表达式.py 

"""
    正则表达式是一种特殊的字符序列，能够帮助用户便捷的检查一个字符串是否符合某种规则（模式）
    元字符：
        具有特殊意义的专用字符
        用来描述字符串边界的元字符
        开始”^“
        结尾”$“
    限定符：用于限定匹配的次数
    其他字符：
        区间字符[]:匹配[]中指定字符
        排除字符^:匹配不在[]中指定字符
        选择字符|:用于匹配|左右的任意字符
        转义字符
        [\u4e00-\u9fa5]:匹配任意一个汉字
        分组():改变限定符作用
    内置模块re:用于实现python中的正则表达式的操作，导入即可使用
    re.match()：用于从字符串的开始位置进行匹配，开始位置匹配成功，返回为Match对象，否则返回None
    re.search()：用于在整个字符串中搜索第一个匹配的值，匹配成功，返回为Match对象，否则返回None
    re.findall()：用于在整个字符串搜索所有符合正则表达式的值，返回列表
    re.sub()：用于实现字符串的替换
    re.split()：功能与字符串的split方法相同
"""
import re
pattern_ = r"\d\.\d+"  # r表示元字符，字符中转义字符不起作用，\d匹配0-9的整数，
# \.普通字符，（即为.）（.为任意字符），\d+（+限定次数）
str_1 = "I study lr3.37 every day"
match_1 = re.match(pattern_, str_1, flags=0)
print(match_1)
str_2 = "3.37lr I study every day"
match_2 = re.match(pattern_, str_2, re.I)
print(match_2)
print("匹配值的起始位置：", match_2.start())
print("匹配值的结束位置：", match_2.end())
print("匹配区间的位置元组：", match_2.span())
print("待匹配的字符串：", match_2.string)
print("匹配的数据：", match_2.group())
str_3 = "I study lh9.88 and lr3.37 every day"
str_4 = "I study every day"
search_1 = re.search(pattern_, str_2)
search_2 = re.search(pattern_, str_3)
search_3 = re.search(pattern_, str_4)
print(search_1, "，匹配的数据：", search_1.group())
print(search_2, "，匹配的数据：", search_2.group())
print(search_3)
list_1 = re.findall(pattern_, str_2)
list_2 = re.findall(pattern_, str_3)
list_3 = re.findall(pattern_, str_4)
print(list_1)
print(list_2)
print(list_3)
pattern_2 = "科技|解码|抓取"
str_5 = "连接科技，实现解码，抓取必要信息"
result_1 = re.sub(pattern_2, "**", str_5)
print(result_1)
str_6 = "https://www.baidu.com/s?wd=yz&ie=utf-8&tn=baidu"
pattern_3 = "[?|&]"
list_4 = re.split(pattern_3, str_6)
print(list_4)

 43-Bug的常见类型.py 

"""
    Bug的常见类型：
        粗心导致的语法错误SyntaxError：
            漏了末尾的冒号
            缩进错误
            把英文字符写成中文字符
            没有定义变量
            "=="比较运算符与"="赋值运算符混用
        知识不熟练导致的错误：（熟能生巧）
            索引越界问题IndexError
            append()方法掌握不熟练
        思路不清晰导致的问题解决方案：
            使用print()函数输出变量值，查看数据变化
            使用"#"暂时注释部分代码，找到出现问题的部分，一步步筛查
        被动掉坑：程序代码逻辑没有错，只是因为用户错误操作或者一些”例外情况“而导致的程序崩溃
        被动掉坑问题的解决方案：pyhton提供了异常处理机制，可以在异常出现时即时捕获，
                          然后内部“消化”，让程序继续运行
                try:
                    可能出现异常的代码
                except 异常类型:
                    异常处理代码
            多个except结构：
            捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，
            可以在最后增加BaseException
                try:
                    可能出现异常的代码
                except 异常类型:
                    异常处理代码
                except 异常类型:
                    异常处理代码
                except BaseException:
                    异常处理代码
"""
age = input("请输入年龄：")
# if age >= 18: # TypeError: '>=' not supported between instances of 'str' and 'int'
if int(age) >= 18:  # age由字符串转成整型数据
    print("成年人")
else:
#    print（"未成年"） # SyntaxError: invalid character '（' (U+FF08)
    print("未成年")  # 将中文字符"（）"改成英文字符"()"

list_1 = [12, 23, 45, 77]
# print(list_1[4])  # IndexError: list index out of range
print(list_1[3])
# list_1.append("A", "C")  # TypeError: list.append() takes exactly one argument (2 given)
list_1.append("A")
list_1.append("C")
print(list_1)
i_num_1 = int(input("请输入第一个整数："))
i_num_2 = int(input("请输入第二个整数："))
# 当输入"w"时，ValueError: invalid literal for int() with base 10: 'w'
result_1 = i_num_1 + i_num_2
print("结果为：", result_1)
try:
    i_num_3 = int(input("请输入第1个整数："))
    i_num_4 = int(input("请输入第2个整数："))
    result_2 = i_num_3 + i_num_4
    print("结果为：", result_2)
except ValueError:  # 当输入"w"时，出现ValueError，满足条件
    print("请输入整数数据")

try:
    i_num_5 = int(input("请输入第壹个整数："))
    i_num_6 = int(input("请输入第贰个整数："))
    result_3 = i_num_5 / i_num_6
    print("结果为：", result_3)
except ZeroDivisionError:
    print("除数不能为零")
except ValueError:  # 当输入"w"时，出现ValueError，满足条件
    print("请输入整数数据")
except BaseException as e:
    print(e)
print("程序结束")

 44-python的异常处理机制.py 

"""
    python的异常处理机制：
        try...except...else...
        如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块
        try...except...else...finally
        finally块无论是否发生异常都会被执行，经常用来释放try块中申请的资源
        使用traceback模块打印异常信息
"""
import traceback
try:
    print(1/0)
except:
    traceback.print_exc()
print("--------")
try:
    i_num_1 = int(input("请输入第一个整数："))
    i_num_2 = int(input("请输入第二个整数："))
    result_1 = i_num_1 / i_num_2
except BaseException as e:  # e为BaseException的别名
    print("错误原因：", e)
else:
    print("结果为：", result_1)

try:
    i_num_3 = int(input("请输入第1个整数："))
    i_num_4 = int(input("请输入第2个整数："))
    result_2 = i_num_3 / i_num_4
except BaseException as e:  # e为BaseException的别名
    print("错误原因：", e)
else:
    print("结果为：", result_2)
finally:
    print("感谢你的使用")

 45-python中常见的异常类型.py 

"""
    python中常见的异常类型：
        ZeroDivisionError：除（或取模）零（所有数据类型）
        IndexError：序列中没有此索引（index）
        KeyError：映射中没有这个键
        NameError：未声明（或未初始化）对象
        SyntaxError：python语法错误
        ValueError：传入无效的参数
"""

 46-pycharm开发环境调试.py

"""
    断点：程序运行到此处，暂时挂起，停止执行🛑，此时可以详细观察程序的运行情况，
        方便做出进一步的判断
    进入调试视图：三种方式
        单击工具栏上的按钮
        右键单击编辑区：点击debug‘模块名’
        快捷键：shift + F9
"""

 47-类和对象的创建、属性与方法.py

"""
    类的语法：
        class Student:
            pass
    类的组成：
        类属性：类中方法外的变量称为类属性，被该类的所有对象所共享
        实例方法：使用@classmethod修饰的方法，使用类名直接访问的方法
        静态方法：使用@staticmethod修饰的方法，使用类名直接访问的方法
        类方法
    对象的创建称为类的实例化：
        实例名 = 类名()
    动态绑定属性和方法：
        python是动态语言，在创建对象后，可以动态的绑定属性和方法
"""

class Student:  # Student为类名，由一个或多个单词组成，每个单词的首字母大写，其余小写
    pass

# python中一切皆对象
print(id(Student))  # Student是对象，开辟了内存空间，类对象的内存地址
print(type(Student))
print(Student)

class Student_1:
    native_place = "苏"  # 直接写在类里面的变量，称为类属性

    def __init__(self, name, age):
        self.name = name  # self.name称为实例属性，将局部变量name赋值给实例属性
        self.age = age

    def playing(self):  # 实例方法（在类之外定义的称为函数，在类内定义的称为方法）
        print("在跑步……")

    @staticmethod
    def method():
        print("因为使用了staticmethod修饰，所以是静态方法")

    @classmethod
    def clas_method(cls):
        print("因为使用了classmethod修饰，所以是类方法")
def show():
    print("定义在类之外的函数")

stu_1 = Student_1("杳", 17)
print(id(stu_1))  # 实例对象的内存地址
print(type(stu_1))
print(stu_1)
stu_1.playing()
print(stu_1.name)
print(Student_1.native_place)  # 类属性的使用
stu_2 = Student_1("卿", 28)
print(stu_1.native_place, ",", stu_2.native_place)  # 类指针指向同一个地点
Student_1.native_place = "沪"
print(stu_1.native_place, ",", stu_2.native_place)
Student_1.clas_method()  # 类方法使用
Student_1.method()  # 静态方法使用
stu_2.gender = "女"  # 给stu_2单独动态绑定性别属性
print(stu_1.name, stu_1.age)
print(stu_2.name, stu_2.age, stu_2.gender)
stu_1.show = show  # 动态绑定方法
stu_1.show()

 48-面向对象的封装.py

"""
    封装：提高程序的安全性
        python中没有专门的修饰符用于属性的私有，如果不希望在类对象的外部被访问，变量名前面加上"__"
"""
class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 年龄不希望在类的外部被使用，所以加上"__"

    def show(self):
        print(self.name, self.__age)

stu_1 = Student("杳", 19)
stu_1.show()
print(stu_1.name)
print(dir(stu_1))
print(stu_1._Student__age)  # 在类外面可以通过 _Student__age 进行访问（不建议访问）

49-面向对象的继承.py

"""
    继承：提高代码的复用性
        语法格式：
            class 子类类名(父类1, 父类2, ……)
        如果一个类没有继承任何类，则默认继承object
        python支持多个继承
        定义子类时，必须在其构造函数中调用父类的构造函数
"""
class Person(object):  # Person继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name, self.age)

class Student(Person):  # 子类
    def __init__(self, name, age, stu_nu):
        super().__init__(name, age)
        self.stu_nu = stu_nu

class Teacher(Person):
    def __init__(self, name, age, teach_of_year):
        super().__init__(name, age)
        self.teach_of_year = teach_of_year

stu_1 = Student("杳", 19, "2022191")
teacher_1 = Teacher("卿", 27, 3)

stu_1.info()
teacher_1.info()

class A(object):
    pass

class B(object):
    pass

class C(A,B):  # 多继承
    pass

50-面向对象的方法重写.py

"""
    方法重写：
        如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写
        子类重写后的方法中，可以通过super().xxx()调用父类中被重写的方法
"""
class Person(object):  # Person继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name, self.age)

class Student(Person):  # 子类
    def __init__(self, name, age, stu_nu):
        super().__init__(name, age)
        self.stu_nu = stu_nu
    def info(self):  # 方法重写
        super().info()  # 调用被重写的方法
        print(self.stu_nu)

class Teacher(Person):
    def __init__(self, name, age, teach_of_year):
        super().__init__(name, age)
        self.teach_of_year = teach_of_year

stu_1 = Student("杳", 19, "2022191")
teacher_1 = Teacher("卿", 27, 3)
stu_1.info()
teacher_1.info()

51-面向对象的object类.py

"""
    object类：
        object类时所有类的父类，因此所有类都有object类的属性和方法
        内置函数dir()可以查看指定对象所有属性
        object有一个__str__()方法，用于返回一个对于"对象的描述"，
        对应于内置函数str()经常用于print()方法，
        帮助我们查看对象信息，所以我们经常会对__str__()进行重写
"""
class Student:
    pass

class Student_1:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return "姓名：{0}，年龄：{1}".format(self.name, self.age)
stu_1 = Student()
stu_2 = Student_1("杳", 27)
print(dir(stu_1))
print(stu_1)
print(stu_2)  # 默认调用__str__()方法
print(type(stu_2))

52-面向对象的多态.py

"""
    多态：提高程序的可扩展性和可维护性
        多态就是"具有多种形态"，指的是：即使不知道一个变量所引用的对象到底是什么类型，
        仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，
        动态决定调用哪个对象中的方法
"""
class Animal(object):
    def eat(self):
        print("动物会吃什么")

class Dog(Animal):
    def eat(self):
        print("狗吃骨头...")
class Cat(Animal):
    def eat(self):
        print("猫吃鱼...")
class Person():
    def eat(self):
        print("各人都有喜好的食物")
def fun(obj):  # 定义一个函数，传递一个对象
    obj.eat()  # 调用该对象中的eat()方法(只要该对象存在此方法)
fun(Cat())  # 开始调用函数
fun(Dog())
fun(Animal())
fun(Person())

53-面向对象的特殊属性和特殊方法.py

"""
    面向对象的特殊属性和特殊方法：
        特殊属性：
            __dict__:获得类对象或者实例对象所绑定的所有属性和方法的字典
        特殊方法：
            __len__():通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
            __add__():通过重写__add__()方法，可使自定义对象具有"+"功能
            __new__():用于创建对象
            __init__():对创建的对象进行初始化
"""
class A:
    pass
class B:
    pass
class C(A, B):
    def __init__(self, name):
        self.name = name
per = C("杳")
print(per.__dict__)  # 实例对象的属性字典
print(C.__dict__)  # 类对象的属性和方法的字典
print(per.__class__)  # 实例对象所属的类
print(C.__bases__)  # C类的父类类型的元组
print(C.__base__)  # 离C类最近的父类（最前面的一个父类）
print(C.__mro__)  # 类的层次结构
print(A.__subclasses__())  # 查看A类的子类（列表）

class Student:
    def __init__(self, name):
        self.name = name
    def __add__(self, other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)
stu_1 = Student("杳")
stu_2 = Student("卿")
name_comb = stu_1 + stu_2  # 实现了两个对象的加法运算
# （因为在Student类中，编写__add__()特殊的方法）
name_cb = stu_1.__add__(stu_2)
print(name_comb)
print(name_cb)
list_1 = [12, 5, 78]
print(len(list_1))
print(list_1.__len__())
print(len(stu_1))

class Person(object):
    # 先创建new后初始化init并返回return
    def __new__(cls, *args, **kwargs):
        print("__new__被调用执行，cls的id值为{0}".format(id(cls)))
        obj = super().__new__(cls)
        print("创建的对象的id为：{0}".format(id(obj)))
        return obj

    def __init__(self, name, age):
        print("__init__被调用，self的id值为：{0}".format(id(self)))
        self.name = name
        self.age = age

print("object这个类对象的id为：{0}".format(id(object)))
print("Person这个类对象的id为：{0}".format(id(Person)))
per = Person("杳", 18)
print("per这个Person类的实例对象的id为：{0}".format(id(per)))

54-类的赋值与拷贝.py

"""
    类的赋值与拷贝：
        变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象
        浅拷贝：python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，
            因此，源对象与拷贝对象会引用同一个子对象
        深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，
            源对象与拷贝对象所有的子对象也不相同
"""

class CPU:
    pass

class Disk:
    pass

class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk
cpu_1 = CPU()
cpu_2 = cpu_1  # 两个变量指向同一个对象
print(cpu_1, id(cpu_1))
print(cpu_2, id(cpu_2))
disk = Disk()
computer = Computer(cpu_1, disk)

import copy
computer_1 = copy.copy(computer)  # 浅拷贝
computer_2 = copy.deepcopy(computer)  # 深拷贝
print(computer, computer.cpu, computer.disk)
print(computer_1, computer_1.cpu, computer_1.disk)
print(computer_2, computer_2.cpu, computer_2.disk)

55-模块化编程.py

"""
    模块：一个模块中可以包含多个函数
        在python中一个扩展名为.py的文件就是一个模块
    使用模块的好处：
        方便其他程序和脚本的导入并使用
        避免函数名和变量名冲突
        提高代码的可维持性
        提高代码的可重用性
"""
# 55-模块化编程.py 即为一个模块
# 模块：函数、类（类属性、实例属性、类方法、静态方法）、语句
def fun_1():
    pass
def fun_2():
    pass

class Student_1:
    native_place = "苏"
    def person(self, name, age):
        self.name = name
        self.age = age

    @staticmethod
    def method():
        pass

    @classmethod
    def clas_method(cls):
        pass

num_1 = 12
num_2 = 29
print(num_1 + num_2)

56-自定义模块.py

"""
    自定义模块：
        创建模块：
            新建一个.py文件，名称尽量不要与python自带的标准模块名相同（见名知义）
        导入模块；
            import 模块名称 [as 别名]     （导入模块中的所有）
            from 模块名称 import 函数/变量/类    （导入模块中的指定）
        导入自定义模块：
            import 自定义模块 （当自定义模块引入报错时，
            右键当前文件夹（Directory）->Mark Directory as->Source Root）
            from 自定义模块 import 函数/变量/类
"""
import math
print(id(math))
print(type(math))
print(math)

57-以主程序方式运行.py

"""
    以主程序方式运行：
        在每个模块的定义中都包含一个记录模块名称的变量__name__，程序可以检查该变量，
        以确定他们在哪个模块中执行。如果一个模块不是被导入到其他程序中执行，
        那么它可能在解释器额顶级模式中执行。
        顶级模块的__name__变量的值为__main__
        if __name__ = '__main__': （只有在当前模块为主程序时才会执行，下面语句，引入其他模块时，
                                    将不会执行下面语句）
            pass
"""

58-python中的包.py

"""
    python中的包：
        包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
        作用：代码规范，避免模块名称冲突
        包与目录的区别：包含__init__.py文件的目录称为包，目录中通常不包含__init__.py文件
        包的导入：import 包名.模块名
    新建包：右击当前文件夹->New->Python Package->自定义包名
    模块中导入包：import 自定义包名.自定义模块（当前包名下） as 别名
    模块中导入带有包的模块时注意事项：
        import 自定义包名
        import 自定义模块名（带有自定义包）
    使用from...import可以导入包、模块、函数、变量
"""

59-python中常用的内置模块.py

"""
    python中常用的内置模块：
        sys：与python解释器及其环境操作相关的标准库
        time：提供与时间相关的各种函数的标准库
        os：提供了访问操作系统服务功能的标准库
        calendar：提供与时间相关的各种函数的标准库
        urllib：用于读取来自网上（服务器）的标准库
        json：用于使用JSON序列化和反序列化对象
        re：用于在字符串中执行正则表达式匹配和替换
        math：提供标准算术运算函数的标准库
        decimal：用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
        logging：提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能
"""
import sys
import time
import urllib.request
import math

print(sys.getsizeof(24))
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen("http://www.bai.com").read())
print(math.pi)

60-第三方模块的安装与使用.py

"""
    第三方模块的安装与使用：
        第三方模块的安装：
            pip install 模块名
        第三方模块的使用：
            import 模块名
"""

61-文件中的编码格式.py

"""
    文件中的编码格式：
        python的解释器使用的是Unicode（内存）
        .py文件在磁盘上使用UTF-8存储（外存）
    #encoding=utf-8 （不写默认为utf-8）
"""

62-文件读写.py

"""
    文件读写：
        文件的读写俗称"IO操作"
        文件读写操作流程
        操作原理：.py文件->解释器->OS->操作硬盘（打开或新建文件->读、写文件->关闭资源）
        内置函数open()创建文件对象：
            程序（对象（映射磁盘上的真实文件））<--input/output-->文件
            通过IO流将磁盘文件中的内容与程序中的对象中的内容进行同步
        语法规则：
            file = open(filename[mode,encoding])
            被创建的文件对象 = 创建文件对象的函数(要创建或打开的文件名称[打开模式默认只读,
                            默认文本文件中字符的编码格式为gbk])
        常用的文件打开模式：
            文件类型：
                按文件中数据的组织形式，分为两大类：
                    文本文件：存储的是普通"字符"文本，默认为unicode字符集，可以使用记事本程序打开
                    二进制文件：把数据内容用"字节"进行存储，无法用记事本打开，
                             必须使用专门的软件打开，如mp3音频文件，jpg图片，doc文档等
                r:以只读模式打开文件，文件的指针将会放在文件的开头
                w:以只读模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，
                  文件指针在文件的开头
                a:以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，
                  则在文件末尾追加内容，文件指针在原文件末尾
                b:以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb或者wb
                +:以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+
        文件对象的常见方法：
            read([size]):从文件中读取size个字节或字符的内容返回，若省略[size]，
                         则读取到文件末尾，即一次读取文件所有内容
            readline():从文本文件中读取一行内容
            readlines():把文本文件中的每一行都作为独立的字符串对象，并将这些对象放入列表返回
            write(str):将字符串str内容写入文件
            writelines(s_list):将字符串列表s_list写入文本文件，不添加换行符
            seek(__offset,__whence):把文件指针移动到新的位置，offset表示相对whence的位置：
                                offset：为正往结束方向移动，为负往开始方向移动
                                whence不同的值代表不同含义：
                                    0：从文件头开始计算（默认值）
                                    1：从当前位置开始计算
                                    2：从文件尾开始计算
            tell():返回文件指针的当前位置
            flush():把缓冲区的内容写入文件，但不关闭文件
            close():把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源
"""
file_1 = open("file_demo.txt", "r", encoding="utf-8")  # 需要先建立文件
print(file_1.read(1))
print(file_1.readlines())
print(file_1.tell())
file_1.close()

file_2 = open("file_next.txt", "w")
file_2.write("雪耳")
file_2.close()

file_3 = open("file_next.txt", "a")
file_3.write("靓灿")
list_ = ["杳", "卿"]
file_3.writelines(list_)
file_3.close()

63-with语句.py

"""
    with语句(上下文管理器)：
        with语句可以自动管理上下文资源，不论什么原因跳出with块，都能保证文件正确的关闭，
        以此来达到释放资源的目的
        with open("log.png", "rb") as src_file:
             [-------上下文表达式---][--可选项---]
             自动调用_enter_()方法，并将返回值赋值给src_file
             离开运行时上下文，自动调用上下文管理器的特殊方法_exit_()，不需要再手写关闭过程
"""
with open("file_demo.txt", "r", encoding="utf-8") as file:
    print(file.read())
"""
    MyContentMgr实现了特殊方法__enter__(),__exit__()称为该类对象遵守了上下文管理器协议
    该类对象的实例对象，称为上下文管理器
    MyContentMgr()   
"""
class MyContentMgr(object):
    def __enter__(self):
        print("enter方法被调用执行")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit方法被调用执行")
    def show(self):
        print("show方法被调用执行")

with MyContentMgr() as file_s:
    file_s.show()

64-目录操作.py

"""
    目录操作：
        os模块是python内置的与操作系统功能和文件系统相关的模块，
        该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，
        得到的结果可能不一样
        os模块与so.path模块用于对目录或文件进行操作
        os模块操作目录相关函数：
            getcwd():返回当前的工作目录
            listdir(path):返回指定路径下的文件和目录
            mkdir(path,mode):创建目录
            makedirs(path1/path2...,mode):创建多级目录
            rmdir(path):删除目录
            removedirs(path1/path2...):删除多级目录
            chdir(path):将path设置为当前工作目录
        os.path模块操作目录相关函数：
            abspath(path):用于获取文件或目录的绝对路径
            exists(path):用于判断文件或目录是否存在，如果存在，返回True，否则，返回False
            join(path, name):将目录与目录或者文件名拼接起来
            splitext():分离文件名和扩展名
            basename(path):从一个目录中提取文件名
            dirname(path):从一个路径中提取文件路径，不包括文件名
            isdir(path):用于判断是否为路径
"""
import os
import os.path
print(os.getcwd())
print(os.path.abspath("64-目录操作.py"))
print(os.path.split(os.path.abspath("64-目录操作.py")))
print(os.path.splitext("64-目录操作.py"))
print(os.path.basename(os.path.abspath("64-目录操作.py")))
print(os.path.dirname(os.path.abspath("64-目录操作.py")))