【入门到精通】Python编程进阶,一篇文章全吃透!

'''    函数的参数传递：        1. 参数可以是任何类型的内容，不同数据类型的数据，或者对象，都可以是入参。        2. 在传递参数时，可以指定参数名传递，也可不指定。若不指定则根据参数的顺序对入参进行匹配。        3. 在参数定义时，可以设置参数的默认值。'''# 带参数的函数定义def function_demo(a, b, c):  # 此处的a,b,c就是函数的参数，也叫做形参。    print(a)    print(b)    print(c)# 带默认值参数的函数定义def function_arguments(a, b='默认'):  # 此处b参数设置有默认值，在不给b参数传入入参时，使用默认值，传入参数则修改默认值为传入后的值    print(a)    print(b)# 调用函数，并进行参数的传递function_demo(1, 2, 3)  # 此处的1，2，3表示实参，也是入参。# 指定参数顺序进行传参：通过指定参数进行传参，可以不遵循形参的顺序。function_demo(b=1, a=3, c=2)# 调用带默认值的函数function_arguments(1)  # 不传入b参数值function_arguments(1, 2)  # 传入b参数值，需与默认值保持同一数据类型，否则会提示警告。

# 复杂一些的return关键字调用# 在整个函数中，根据num的值来进行不同的判断，return对应的结果内容。def return_function(num):    if num == 1:        return '这是int'    elif num == 'str':        return '这是str'    elif num == 'dict':        return '这是dict'    else:        return '这啥也不是'# 更为复杂的return关键字调用：在一个死循环中定义return，当运行return时，函数结束，死循环也会同步结束。def return_function_plus():    i = 0    while True:        print('现在是更为复杂的应用')        if i == 4:            return 'bingo!'        i += 1

'''    函数的调用：    1. 调用方式是通过输入函数名加上括弧号进行调用。    2. 函数在调用时，若需要传入参数，默认情况下，参数值与参数名称是按照函数声明中所定义的顺序匹配起来的。所以传入参数的个数必须与函数保持一致。'''# 无参数版def hello():    print('hello world!')# 有参数版def hello_plus(addr):    print('hello {}!'.format(addr))# 函数的调用hello()  # 无参数hello_plus('China')  # 有参数

# 函数调用函数的调用方式与一般调用没有区别。def hello(addr):    print('hello {}!'.format(addr))def hello_plus(city):    hello(city)  # 函数调用函数# 函数的调用hello_plus('CSC')

'''    函数的参数传递：        1. 参数可以是任何类型的内容，不同数据类型的数据，或者对象，都可以是入参。        2. 在传递参数时，可以指定参数名传递，也可不指定。若不指定则根据参数的顺序对入参进行匹配。'''# 带参数的函数定义def function_demo(a, b, c):  # 此处的a,b,c就是函数的参数，也叫做形参。    print(a)    print(b)    print(c)# 调用函数，并进行参数的传递function_demo(1, 2, 3)  # 此处的1，2，3表示实参，也是入参。# 指定参数顺序进行传参：通过指定参数进行传参，可以不遵循形参的顺序。function_demo(b=1, a=3, c=2)

'''    *args与**kwargs的参数传递机制：        正常的函数参数，一般会有不定数量。也就是一个到多个参数不等。在python中，可以通过*args和**kwargs来实现参数的传递。        1. *args表示任意多个无名参数，通过元组的形态进行传递，根据函数参数的顺序依次匹配元组中的每一个元素，一般情况下元组长度必须与参数数量保持一致。            此类传递参数的方式，可以在调用函数时非常灵活将所有参数一次性传入，不用再一个个指定。便于函数调用的拓展使用。也就是所谓的不定值不定长传参模式。        2. **kwargs表示关键字参数。通过字典的kv格式进行传入参数，所有传入的参数都会遵循key=value的格式，根据函数的形参名逐一匹配字典的key，将对应value进行传参，一般情况下字典的key必须与形参相同            此类传递参数的方式，可以在调用函数时快速基于形参名将所有的参数一次性赋值。也就是所谓的定值不定长传参。'''# 带参数的函数定义def function_demo(a, b, c):  # 此处的a,b,c就是函数的参数，也叫做形参。    print(a)    print(b)    print(c)# 调用函数的两种传参方式function_demo(*(1, 2, 3))  # *表示调用*args传参，python会自行将元组解包，每一个元素都会一一匹配变成参数。function_demo(**{    'a': 3,    'b': 2,    'c': 1})  # **表示调用**kwargs传参，python会基于字典的kv对自行匹配函数的每一个参数。

'''    递归函数：        函数调用函数本身的一种形态。函数的定义就是用来调用的，可以被其他函数调用，自然也可以被自己调用。        只是因为函数本身的逻辑会更加复杂，所以递归函数在使用时会造成更多的资源占用。一般只是用于处理特定的算法'''# 非递归函数def multiplication(n):    num = n    for i in range(1, n):        num = num * i    return num# 递归函数def multiplication_plus(n):    if n == 1:  # 正确的结束条件定义        return 1    else:        num = n * multiplication_plus(n - 1)  # 调用自身函数的行为        print(num)  # 如果你算晕了可以加上print()，实时查看num值在每次被调用时的变化        return num# 普通函数的调用print(multiplication(5))# 递归函数的调用print(multiplication_plus(5))

'''    1. lambda匿名函数不需要通过def来进行定义，本身只是一个表达式，比常规函数要简单很多    2. lambda的主体基本只有一行代码，而不是一个代码块，所以能实现的逻辑非常有限，只用于简单的代码逻辑    3. lambda函数虽然看起来简单许多，但是除了调用与一般函数有区别外，其他基本一致。比如说函数内与函数外相互独立，数据不互通等。'''# 匿名函数示例x = lambda a: a + 10  # 定义一个匿名函数，要求传入参数a，函数体为计算a+10，将此函数赋值到xprint(x(10))  # 调用匿名函数y = lambda a, b: a + b  # 定义一个多参数的匿名函数，将此函数赋值到yprint(y(2, 3))

'''    函数外的变量不会因为函数运行对其进行的操作而修改变量本身的值。如果想要实现修改的效果，则需将变量声明为全局变量才可。'''a = 8def plus():    global a  # 定义a为全局变量之后，若对a进行了值的修改，则会影响到函数以外的a变量本身的值。    a = 10    return a + 5print(a)  # 函数调用前，a = 8print(plus())  # 调用含有global的函数print(a)  # 函数调用后，a = 10

'''    类的定义：        所有类都是通过class关键字进行创建。类是由类方法、类属性等组成的集合        对象是类的实例。类无法被直接调用，如果要操作类，则需通过实例化对象后，基于对象来进行操作。'''# 创建一个demo类class Demo:    # 类属性    a = '类属性'    # 类方法    def function_demo(self):        print('类方法')# 实例化Demo类，生成实例化类对象demo = Demo()# 通过实例化的类对象调用类方法和类属性。实现类的使用demo.function_demo()print(demo.a)

'''    类属性：        定义在类中且在方法外的变量，叫做类属性。        类属性的访问分为类内部访问与类外部访问两种方式：            1. 类内部，如果在类方法中需要调用类属性，需通过self关键字访问            2. 类外部，如果需要访问类属性则通过类名.类属性和对象名.对象属性'''# 创建一个demo类class Demo:    # 类属性    a = '类属性'    # 类方法    def function_demo(self):        print(self.a)  # 内部调用类属性，需通过self关键字# 类外部调用类属性print(Demo.a)  # 通过类名直接调用# 通过实例化类对象调用dd = Demo()print(dd.a)

'''    实例化后调用的是实例属性，该属性的修改与删除只会影响对应的实例化对象，对原本的类不会产生任何影响。    类属性在修改后，也不会影响实例化对象的属性赋值。所以类属性与实例属性是相互独立的存在。'''# 创建一个demo类class Demo:    # 类属性    a = '类属性'dd = Demo()print(dd.a)# 修改类属性Demo.a = 'before create'print(Demo.a)print(dd.a)# 通过实例化类对象对实例属性进行修改与删除dd.a = 'new attribute'  # 修改实例化对象的属性print(dd.a)del dd.a  # 删除实例化对象的属性print(dd.a)

'''    类方法的定义：        1. 类方法：通过self进行调用        2. 静态方法：通过类名调用            因为静态方法中不需要传入self参数，所以静态方法的调用是直接通过类名调用，也因为缺少self，所以静态方法无法获取类其他属性与方法。        3. 实例方法：实例化后调用'''class demo:    a = 'sd'    # 类方法    def function_in_class(self):        print('这是类方法')    # 静态方法：需声明@staticmethod装饰器    @staticmethod    def function_static():        print('这是类静态方法')# 类静态方法的调用，不需要实例化类，直接通过类名调用即可，静态方法无法直接获取类中其他的方法和变量。是相对独立的存在。demo.function_static()# 类方法的调用，需要通过实例化的形式调用，否则会提示缺少self参数demo().function_in_class()

'''    构造函数，默认不执行任何操作，也不需要专门定义。在实例化时python会自行帮我们调用一个不执行任何操作的默认构造函数。    如果对于实例化对象有初始化需求，需要在实例化时进行一部分的默认设置，则可以自己重新定义构造函数的相关内容。    构造函数在类中有固定的命名：__init__()。    如果设置有构造函数，实例化类对象时必须遵循构造函数的参数要求。'''class person:    # 构造函数：进行默认设定    def __init__(self, name, age):        self.name = name        self.age = age    # 调用构造函数中赋值的内容进行函数逻辑处理    def info(self):        print('Person的基本信息如下：姓名：{0}，年龄：{1}'.format(self.name, self.age))# 实例化person类对象：因为更改了构造函数，所以在实例化时需要传入name和age两个参数hcc = person('hcc', '28')hcc.info()# 因为构造函数的存在，不同的实例对象具备有不同的实例成员xzl = person('xzl', '18')xzl.info()

'''    self的用法定义：        在Python类中规定，普通类方法的第一个参数是实例对象本身，并且定义为关键字self。表示当前类        的对象。可以通过self来调用当前类中的属性和方法。        self只用于实例化对象调用普通方法。对于静态方法这种不需要实例化即可调用的函数。不需要传递self。        在类中，想要调用类本身存有的属性或者方法，也可直接通过self来进行调用。'''class demo:    a = 'sd'    # 类方法    def function_demo(self):        print('这是类方法')    # 静态方法    @staticmethod    def function_static():        print('这是类静态方法')    # 通过self调用类本身的属性和方法    def function_self(self):        print(self.a)  # 在类方法中调用类属性，通过self调用        self.function_demo()  # 在类方法中通过self调用普通类方法        self.function_static()  # 在类方法中通过self调用静态类方法# 实例化类对象，其实就是创建了一个self对象。所以实例化后调用函数不用再额外传入selfd = demo()d.function_self()

'''    封装的私有属性与方法：        在python语言中，没有像是java那样的public和private装饰符来定义属性与方法的权限。        如果想要在类中定义到专属于类内部的私有属性和方法，则可以通过在属性或方法的名字前添加__来表示        这是python对于私有化的标准命名写法。        私有属性无法在类外被调用，也无法被实例化对象调用    私有属性与方法的使用，只限于在类本身之中，这是封装上，对于类内部不愿被对外的内容的一种写法。    如果想要获取这些私有内容，则需要通过公有方法来调用，或者通过return将私有属性返回。'''class demo:    a = '公有属性'    __b = '私有属性'    def public_function(self):        print('这是公有方法')    def __private_function(self):        print('这是私有方法')    # 定义公有方法，调用私有属性与方法。达到外部使用的目的。    def function_demo(self):        self.__private_function()        return self.__bd = demo()print(d.a)# print(d.__b)  # 报错提示demo类没有这个属性d.public_function()# d.__private_function()    # 报错提示demo类没有这个方法print(d.function_demo())    # 通过公有方法调用私有方法，return私有属性

'''    继承：        继承语法：            class Student(Person): 创建一个Student类，继承于Person类        继承允许我们定义继承另一个类的所有方法和属性的类。在python中，所有的类（包括自定义类）都        默认继承于object类。        任何类都可以是父类，任何类都可以被其他类继承。但是我们在进行继承操作时，一般会选择彼此具备相关特性的类。'''# 创建父类class Person:    # 定义构造函数    def __init__(self, name, sexual):        self.name = name        self.sexual = sexual    # 定义父类方法    def speak(self):        print('这是一个名字叫做{}的{}人在说话'.format(self.name, self.sexual))# 创建子类，继承于Person类class Student(Person):    # 不定义子类任何的内容    pass# 实例化子类Student对象，可以直接调用Student类所继承的所有内容，包括构造函数与speak函数stu = Student('名字', '男')stu.speak()  # 正常执行父类的speak函数

'''    方法重写与重载：        1. 方法重写，子类对父类中继承而来的方法进行代码块的重新编写，虽然            方法名称相同且参数相同，但方法本身在子类和父类中已经截然不同        2. 方法重载，子类因为逻辑需要，可能在类中包含有非常多个同名函数，但            这些函数的参数以及返回类型都不同，在实例化后通过传入不同的参数实            现不同的方法调用，python默认不支持方法重载的语法结构，所以这里只            讲解概念'''# 创建父类class Person:    # 定义构造函数    def __init__(self, name, sexual):        self.name = name        self.sexual = sexual    # 定义父类方法    def speak(self):        print('这是一个名字叫做{}的{}人在说话'.format(self.name, self.sexual))# 创建子类，继承于Person类class Student(Person):    # 方法的重写：虽然还是speak方法，但是方法中的代码块与父类已经不同，调用时父类与子类的方法运行结果截然不同    def speak(self):        print('这是一个学生，名字叫做{}，性别为{}，这个孩子正在念书'.format(self.name, self.sexual))person = Person('父类', '男')person.speak()  # 执行父类原有的speak方法stu = Student('学生', '女')stu.speak()  # 执行子类重写的speak方法

'''    多继承，允许一个子类继承于多个父类，继承多个父类中的所有方法和属性。    需要额外注意的是，如果继承多个父类，调用父类中的同名方法和属性时，会基于继承顺序进行就近匹配    例如：        class A(B,C)，在同时继承B和C类后，若调用同名方法或属性时，会先在B类中查找，如果找到则直接调用，若没找到则继续在C类中查找        class A(C,B)，同样是继承B和C类，但C类在前，所以会现在C类中查找，如果没找到再在B类中查找'''# 创建父类1class Person:    # 定义构造函数    def __init__(self, name, sexual):        self.name = name        self.sexual = sexual    # 定义父类方法    def speak(self):        print('这是一个名字叫做{}的{}人在说话'.format(self.name, self.sexual))# 创建父类2class Child:    # 定义构造函数    def __init__(self):        print('这是Child构造函数')    # 定义父类方法    def speak(self):        print('我是child，我会咿咿呀呀~')# 创建子类1，继承于Person类和Child类class Student(Person, Child):    pass# 创建子类2，继承于Child类和Person类class Player(Child, Person):    passstu = Student('stu', 'female')  # 继承于Person类和Child类，所以优先调用Person类中的构造方法与类方法stu.speak()pla = Player()  # 继承于Child类和Person类，所以优先调用Child类中的构造方法和类方法pla.speak()

'''    Python模块在实际使用时，是通过import语句来引入的。    例如：        import time    要引入time模块所有内容    有时候我们并不需要引入一个完整的模块，可能只需要引入模块中的某一个函数，则可以指定内容引入    若要引入多个函数，则在引入时通过,进行分割        from time import sleep, struct_time'''# 只有引入对应的模块后，才可以调用该模块实现需要执行的逻辑。import time# 调用time库的sleep函数。time.sleep(5)# 从time模块只引入sleep函数和struct_timefrom time import sleep, struct_time# 调用sleep函数sleep(4)

# 自定义Python模块的demo.py文件内容class ModuleName:    def module_function(self):        print('this is module_function')# 导入自定义模块的main.py文件内容'''    Python自定义模块的调用：        Python也支持自定义模块的导入和使用。通过一个py文件将自定义模块的内容编写完成，可以是        类，也可以是函数的形态。在其他py文件中如果需要调用该自定义模块，则通过导入的形态来实现。'''# 导入自定义的ModuleName模块。demo是py文件的名称，ModuleName是类名from demo import ModuleName# 生成实例化对象mn，通过mn调用ModuleName的方法mn = ModuleName()mn.module_function()

'''    try/Except语句块基本语法：        try:            容易出现报错的代码        except:            出现错误后的处理    其实try/except语句块的处理逻辑和if控制流很像，都是根据实际情况进行判断，如果try中出现了报错，则进入except进行处理，如果try中    没有出现报错，则except不会被执行。'''# try/except示例try:    a = 1 / 0  # 因为除数不能为0，所以此处会产生报错except:    print('代码报错啦。')  # 因为try/except语句块提前做了错误处理，所以当出现错误时进入到except部分。程序继续运行。不会终止print('这是报错之后的执行')

'''    在except中，可以指定捕获的异常类型，通过调用Exception类及其子类来实现。    在指定异常类型进行捕获时要注意，如果是指定的特定的异常，若代码报错不是次异常，    则依旧会报错。如果想捕获所有的异常类型，建议使用基本类Exception'''# Exception捕获try:    a = 1 / 0  # 此处报异常ZeroDivisionErrorexcept ZeroDivisionError as e:  # as关键字，将ZeroDivisionError重新命名为e，可以简化复杂的名称    print(e)  # 通过except可以直接捕获该异常# try:#     a = [0, 1]#     print(a[5])  # 此处会报异常下标越界# except ZeroDivisionError as e:  # 定义除数为零异常进行捕获，因为实际报错与捕获异常不同，所以依旧会报错。#     print(e)try:    a = [0, 1]    print(a[5])  # 此处会报异常下标越界except Exception as e:  # 定义异常基础类进行捕获，因为所有的Exception和Error都属于Exception子类，所以能捕获成功所有的异常类型。    print(e)

'''    try...except...else语法结构，其实和if...else类似。    执行try语句块，如果没有出现异常，则进入到else中，如果出现异常并被捕获，则进入到except中。'''# else语法应用try:    a = 1/0    print('这是try')except IndexError as e:    print(e)else:    print('这是else')

'''    finally语句，不会考虑异常是否捕获成功，都一定会执行。    一般用于在最后进行资源释放之类的相关操作，确保对应资源即便在代码出现异常后也能正常关闭。'''# else语法应用try:    a = 1 / 0    print('这是try')except IndexError as e:  # 异常与实际产生的异常不同，所以异常捕获失败。    print(e)else:    print('这是else')finally:  # finally语句只能写在try...except...else的最后。    print('这是finally，无论前面怎么样，我都会执行的。')

'''    raise的三种用法：        1. 直接定义raise关键字，不带任何参数。虽然在pycharm中显示有红色，但实际可以运行。            raise默认抛出"No active exception to reraise"的RuntimeError        2. 在raise关键字后加上Exception相关对象，可以指定抛出的异常类型。也可在Exception            相关对象中，对异常的信息进行自定义描述        3. 可以自行定义一个自定义异常类，继承于Exception基础类。再通过raise来抛出自定义异常，整体            实现与前面两者应用相同'''# raise关键字应用1：单独调用raise，不带任何参数try:    i = int(input('请输入小于10的正整数：'))    a = 100 / i    if i >= 10:        raise  # 虽然提示报错信息，但程序可以正常运行，默认抛出RuntimeErrorexcept RuntimeError as e:    print(e)# raise关键字应用2：raise Exception对象，添加异常相关信息try:    i = int(input('请输入小于10的正整数：'))    a = 100 / i    if i >= 10:        raise ValueError('这是valueError')  # 自主抛出ValueError，并在括号中定义异常的具体说明信息except Exception as e:    print('这是异常：{}'.format(e))  # 当输入10及以上的正整数时，会触发try中的raise，抛出ValueError。在此处会将异常信息打印    # raise  # 因为在try中已经使用raise关键字抛出异常，在except中也可以通过raise将异常继续抛出，若抛出，则异常依旧存在，不会被处理。# raise关键字应用3：通过自定义异常类，然后raise抛出# 自定义异常类继承于Exception类class DemoException(Exception):    passtry:    i = int(input('请输入小于10的正整数：'))    a = 100 / i    if i >= 10:        raise DemoException('自定义异常的抛出')  # 通过自定义异常来让程序抛出。except Exception as e:    print(e)  # 显示为DemoException异常相关信息

'''    traceback模块：        将异常信息完整输出，便于我们问题的定位与处理'''import traceback# 调用traceback模块实现异常的输出try:    i = int(input('请输入小于10的正整数：'))    a = 100 / i    if i >= 10:        raise  # 虽然提示报错信息，但程序可以正常运行，默认抛出RuntimeErrorexcept RuntimeError as e:    traceback.print_exc()  # print_exc()函数可以将异常的相关信息显示在控制台

'''    open函数，用来操作文件的常用函数，可以将指定文件打开。创建一个file对象    open()函数有三个参数，分别是文件名称（包含路径），打开模式（读或者写），编码模式（便于文件解析）        文件名称：填写时需要包含路径在内，读取路径起始是基于当前执行的py文件开始的。        打开模式：            1. r 只读模式            2. w 写入模式，如果文件存在，则会删除文件原有的内容重新写入，若不存在则会新建一个文件            3. b 二进制模式，一般关联读或写，rb/wb，用于对非文本文件如图片等的操作            4. a 追加模式，如果文件存在，新内容会被写入已有内容有之后，若不存在则会新建一个文件        编码模式：用于确保打开文件后读取的内容，能够正常被读取及显示。    文件操作行为：    读：        1. read()：读取整个文件所有内容        2. readline()：每次读取一行        3. readlines()：按行读取文件，保存为list    写：        write()：写入文件内容        writelines()：将一个字符串list写入文件    在文件操作后，要记得调用file.close()来关闭该文件。确保资源被正常关闭。'''# 读取文件内容file = open('./file_dir/demo.txt', 'r', encoding='utf8')print(file.read())  # 读取整个文件的所有内容# print(file.readline())    # 读取一行文件内容# content = file.readlines() # 按照行为单位将文件内容全部读取并保存为list# print(content)    # 因为读取出来后是list，所以通过循环把每一行的内容全部输出# for line in content:#     print(line)file.close()# 对文件进行写入操作：文件写入，会将源文件的内容清空，再写入file1 = open('./file_dir/demo1.txt', 'w', encoding='utf8')file1.write('我是写入的内容')file1.close()# 对文件进行追加内容操作：对已有内容的文本文件进行新内容的追加，追加内容在文件末尾# file2 = open('./file_dir/demo.txt', 'a', encoding='utf8')# file2.write('\n我是追加的内容')# file2.close()# 新建一个图片文件，将已有的图片写入到新建的图片文件中image = open(r'D:\desktop_pic.jpg', 'rb')    # 已有的图片内容file_3 = open('./file_dir/image.jpg', 'wb')    # 新建一个文件对象，等待图片内容写入file_3.write(image.read())file_3.close()image.close()

'''    with open语法结构：        with open() as file:            代码块    因为文件操作到最后一定需要有关闭，不然容易造成文件锁或者损坏文件等问题的出现。    为了避免忘记关闭操作，所以在python中提供有with open语法，会在最后自动关闭    文件，不用再调用close函数手动关闭了。'''# with open语法：打开指定文件，并通过as为打开的文件对象命名with open('./file_dir/demo.txt', 'r', encoding='utf8') as f:    print(f.read())  # 操作文件print('这是with open外的代码')  # 运行到with open外时，打开的文件自动close# 使用with语法打开多个文件。每个open都用,进行分割。with open(r'D:\desktop_pic.jpg', 'rb') as image, \        open('./file_dir/image.jpg', 'wb') as f:    f.write(image.read())

'''    Python反射机制常用方法包括四个：        1. getattr()获取模块、类、对象中的属性或方法，便于直接调用或取值        2. setattr()对对象的属性设置新值        3. hasattr()判断模块、类、对象中是否含有该属性或方法，返回True或False        4. delattr()删除对象中的属性，通过类名来进行删除'''# 反射示例# 定义一个基本类class Demo:    a = '这是属性'    def function_demo(self):        print('这是方法')d = Demo()# getattr()示例：获取方法时需要在末尾添加一组括弧号print(getattr(d, 'a'))  # 获取d对象中的a属性getattr(d, 'function_demo')()  # 获取d对象中的function_demo方法。# setattr()示例：可以对对象进行新属性的设置以及对已有属性值的修改setattr(d, 'b', '这是setattr')  # 在d对象中新增b属性print(getattr(d, 'b'))  # 输出d对象中的b属性setattr(d, 'b', '这是修改后的setattr')  # 对d对象中已有的b属性进行值的修改print(d.b)  # 输出d对象中的b属性（修改后）# hasattr()示例：可以判断对象中是否有某个属性，返回结果为True或者Falseprint(hasattr(d, 'a'))  # 判断d对象是否有a属性，此处返回Trueprint(hasattr(d, 'function_demo'))  # 判断d对象是否有function_demo属性，虽然function_demo是函数，但依旧返回Trueprint(hasattr(d, 'c'))  # 判断d对象是会否有c属性，此处返回False# delattr()示例：可以删除目标对象中的指定属性delattr(d, 'b')  # 删除d对象中的b属性delattr(d, 'c')  # 删除d对象中不存在的c属性则会报错delattr(d, 'function_demo')  # 删除d对象中的function_demo函数，报错

'''    迭代器：取值时程序会每次取一个值，取值之后会停留在第一次结束，等到第二次        调用迭代器时，会从第二次重新运行，所以迭代器与普通程序运行不同，不会        在一次调用时就结束。'''# 创建迭代器对象li = ['1', 2, '3', 4]print(type(li))  # 输出listit = iter(li)  # 将list转为迭代器对象print(type(it))  # 输出list_iterator# 迭代器取值的两种方式：通过next()函数和循环的方式取值print(next(it))  # 取第一个值print('*' * 20)  # 分隔符for i in it:  # 从第二个值开始循环    print(i)