Python学习第十一课-面向对象一

最新推荐文章于 2023-05-10 20:12:16 发布

MIANHUA_007

最新推荐文章于 2023-05-10 20:12:16 发布

阅读量710

点赞数 1

分类专栏： Python学习课程文章标签： python 生成器列表

本文链接：https://blog.csdn.net/MIANHUA_007/article/details/116541003

版权

Python学习课程专栏收录该内容

15 篇文章 2 订阅

订阅专栏

本文详细介绍了Python中的面向对象编程，包括可迭代对象、列表推导式、生成器及其创建方式，以及迭代器的概念和使用。通过实例展示了如何通过列表推导式简洁地创建列表，以及如何利用生成器优化内存使用。同时，解释了面向过程与面向对象的区别，并给出了类的创建及使用示例。文章最后讨论了isinstance()函数的作用和用法。

摘要由CSDN通过智能技术生成

一、可迭代对象

我们已经知道可以对list、tuple、dict、set、str等类型的数据使用for … in…的循环语法从其中一次拿到数据进行使用，我们把这项的过程称为遍历，也叫做迭代。
把可以通过for …in…这类语句迭代读取一条数据供我们使用的对象，成为可迭代对象

二、列表推导式

2.1 概念

推导式分为列表推导式、字典推导式、集合推导式等。
列表推导式是Python构建列表的一种快捷方式，可以使用简介的代码就创建出一个列表，简单理解就是有一个旧的列表来构建一个新的列表。
列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。

2.2 语法

列表推导式的语法格式如下：

[表达式 for 变量 in 旧列表（可迭代对象）]
[表达式 for 变量 in 旧列表（可迭代对象）[if 条件表达式] ]

通过列表推导式的语法格式，明显会感觉到它和 for 循环存在某些关联。其实，除去 [if 条件表达式] 部分，其余各部分的含义以及执行顺序和
for 循环是完全一样的（表达式其实就是 for 循环中的循环体），也可以这样理解，它只是对 for 循环语句的格式做了一下简单的变形，并用
[] 括起来而已，只不过最大的不同之处在于，列表推导式最终会将循环过程中，计算表达式得到的一系列值组成一个列表。

2.3 推导

list1 = ['zzk', '海滨居士', '活在人心', '炫']
def fun(lst):
    new_list = []
    for i in lst:
        if len(i) > 3:
            new_list.append(i)
    return new_list

print(fun(list1))
'''
['海滨居士', '活在人心']
'''

list1 = ['zzk', '海滨居士', '活在人心', '炫']
list2 = [i for i in list1 if len(i) > 3]
print(list2)
'''
['海滨居士', '活在人心']
'''

# 求1到100之间所有能被3整除的数
list3 = [i for i in range(1,100) if i % 3 == 0]
print(list3)
# 求1到100之间所有能被3整除的数之和
num = sum(list3)
print(num)

'''
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
1683
'''

# 求1到100之间所有能被3整除且能被5整除的数
list4 = [i for i in range(1, 100) if i % 3 == 0 and i % 5 ==0]
print(list4)
# 求1到100之间所有能被3整除且能被5整除的数之和
num = sum(list4)
print(num)

'''
[15, 30, 45, 60, 75, 90]
315
'''

2.4 练习

# 求1234能组合出来的不重复数字的三位数
list1 = ['{}{}{}'.format(x, y, z) for x in range(1, 5) for y in range(1, 5) for z in range(1, 5) if x != y and x != z and y != z]

print(list1)
'''
['123', '124', '132', '134', '142', '143', '213', '214', '231', '234', '241', '243', '312', '314', '321', '324', '341', '342', '412', '413', '421', '423', '431', '432']
''''

# 求两个列表整除关系的组合
list1 = [30, 12, 66, 34, 39, 78, 36, 57, 121]
list2 = [3, 5, 7]
res = [(x, y) for x in list2 for y in list1 if y % x == 0]
print(res)
'''
[(3, 30), (3, 12), (3, 66), (3, 39), (3, 78), (3, 36), (3, 57), (5, 30)]
'''

三、生成器

3.1 背景

通过列表推导式我们可以直接创建出一个列表,但是受到内存的限制，我们不可
能创造出一个无限大的列表。而且创建一个有200万个元素的列表，会占用很大的内存空间，而这个时候我们仅仅需要访问列表中几个元素，那么后面的元素就占用着空间就是一种浪费的行为。那么我们可不可以用几个元素就创建出几个元素。这样在一定程度上就优化了内存。那么在Python中有一种一边循环一边计算的机制就是生成器

3.2 创建生成器的方式

3.2.1 列表推导式

gen = (i for i in range(1,10) if i % 3 == 0)
print(gen)
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
'''
<generator object <genexpr> at 0x7fddb067f350>
3
6
9
Traceback (most recent call last):
  File "/Users/mianhua/PycharmProjects/python/Python基础/day11/生成器.py", line 17, in <module>
    print(gen.__next__())
StopIteration  #超过迭代次数，就会停止并报错
'''

gen = (i for i in range(1,10) if i % 3 == 0)
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
'''
StopIteration
3
6
9
'''

3.2.2 通过函数来完成

def fun():  # 一旦使用了yield fun()就变成一个生成器了
    i = 0
    while True:
        i += 1
        # return i
        yield i


r = fun()
print(fun())
print(r)
print(next(r))
print(next(r))
'''
<generator object fun at 0x7f8327872eb0>
<generator object fun at 0x7f832467f350>
1
2
'''

3.3 扩展理解

def fun():
    for i in range(1,10):
        yield i
r = fun()
print(next(r))
print(next(r))
print(next(r))
res = [i for i in r]
print(res)
'''
1
2
3
[4, 5, 6, 7, 8, 9]
'''
# 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

3.4 练习

def Fibonacci_sequence(n):
    a, b, counter = 0, 1, 0
    while True:
        if counter > n:
            return
        yield a
        a, b = b, a + b
        counter += 1

print(Fibonacci_sequence(20))
res = Fibonacci_sequence(20)
print(next(res))
print(next(res))
print(next(res))
print(next(res))

四、迭代器

4.1 概念

在这里插入图片描述

迭代器是访问集合元素的一种方式。
迭代器是一个可以记住遍历位置的对象
迭代器对象从集合的第一个元素位置开始访问，知道所有元素访问完结束
可以被next()函数调用并且不断返回下一个值的对象成为迭代器iterator
生成器是可迭代的，也是迭代器
列表是可迭代的，但不是迭代器
通过iter()函数可以将可迭代对象变成一个迭代器

4.2 iter() 函数

Python 内置函数 Python 内置函数
描述
iter() 函数用来生成迭代器。
语法
以下是 iter() 方法的语法:

iter(object[, sentinel])

参数
– object – 支持迭代的集合对象。
– sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
返回值
迭代器对象。

4.3 示例

list1 = [1, 2, 3, 4, 5]
itr = iter(list1)
print(itr)
print(next(itr))
print(next(itr))
res = [i for i in itr]
print(res)
'''
<list_iterator object at 0x7fe825a63280>
1
2
[3, 4, 5]
'''

五、对象的简介

Python是一门面向对象的编程语言
所谓面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的

5.1 面向过程

面向过程指将我们的程序分解为一个个步骤,通过对每个步骤的抽象来完成程序
这种编写方式往往只适用于一个功能,如果要实现别的功能，往往复用性比较低
这种编程方式符号人类的思维，编写起来比较容易
- 1.妈妈穿衣服穿鞋出门]
- 2妈妈骑上电动车
- 3.妈妈到超市门口放好电动车
- 4.妈妈买西瓜
- 5.妈妈结账.
- 6.妈妈骑电动车回家
- 7.到家孩子吃西瓜

5.2 面向对象

面向对象的编程语言，关注的是对象，而不注重过程，对于面向对象一切皆对
象
以上方式可以用孩子妈妈给孩子买瓜来解决
面向对象的编程思想，将所有功能统一保存到对应的对象中，要使用某个功
能，直接找到对应的对象即可
这种编码方式比较容易阅读,并且易于维护，容易复用。但是编写的过程中不
太符合常规的思维，编写相对麻烦
- 妈妈的基本技能
- 1、穿衣服
- 2、穿鞋
- 3、骑车
- 4、买西瓜
- 5、结账

六、类的

6.1 简介

我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以我们在开发中经常要自定义一些对象

类简单理解它就是相当于一个图纸，在程序汇总我们需要根据类来创建对象。类就是对象的图纸
我们也称对象是类的实例(instance)
如果多个对象是通过一个类创建的，我们称这些对象是一类对象

6.2 类的创建

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体

6.3 示例

class MyClass: # 自定义类
    # 功能
    # 属性
    def fun(self):
        # 方法是具体怎么去实现
        print('111')
        # pass
    pass

mc = MyClass() # 创建实例
mc.fun()
'''
111
'''

class MyClass: # 自定义类 (也是一个对象)
    # 功能
    # 属性
    def fun(self):
        # 方法是具体怎么去实现
        print('111')
        # pass
    pass

mc = MyClass() # 创建实例
# mc.fun()
mc2 = MyClass()
mc3 = MyClass()
mc4 = MyClass()
print(mc2)
print(id(mc2))
print(id(mc3))
print(id(mc4))
print(id(MyClass))
print(MyClass)

print(type(mc2))
print(isinstance(mc2, MyClass))
'''
<__main__.MyClass object at 0x7fdddca39880>
140590866208896
140590866207360
140590866379392
140590834618288
<class '__main__.MyClass'>
<class '__main__.MyClass'>
True
'''