moudel,generator,iterable

1. 模块

• 模块化指将⼀个完整的程序分解成⼀个个的小模块，通过将模块组合，来搭建出⼀个完整的程序
• 模块化的优点：方便开发、方便维护、模块可以复⽤

2.模块的创建

• 在Python当中⼀个py⽂件就是⼀个模块
• 在⼀个模块中引⼊外部模块 import 模块名(模块名就是py⽂件)

在一个模块中引入其他模块
1.import 模块名(Python的文件名)

• 可以引⼊同⼀个模块多次，但是模块的实例只会调用一次

import requests
import requests

#只会调用一次，生成实例只有一次

2.import 模块名 as 模块别名
import test_m as test

• 在⼀个模块内部都有⼀个__name__。通过它我们可以获取模块的名字

print(__name__)# __main__,表示当前的文件为主文件
#输出当前引入模块的名字

• 如果py⽂件直接运⾏时，那么__name__默认等于字符串’main’。 __name__属性值为__main__的模块是主模块。⼀个程序中只有⼀个主模块

3.模块的使用

• 访问模块中的变量 语法是 模块名.变量名

print(test_m.name)

• 访问模块中的函数 语法是 模块名.函数名

r= test_m.test()
print(r)

• 访问模块中的对象 语法是 模块名.对象名

a=test_m.hero()
print(a.name)

• 引⼊模块中部分内容

from 模块名 import 变量，变量…
from 模块名 import 变量 as 别名

4.生成器(generator)

• 在Python中有一边循环一边计算的机制，称之为生成器
• 创建生成器
  1. 通过列表推导式

new_list=[x * 3 for x in range(20)if x%5==0]
print(new_list)
#[0, 15, 30, 45]

new=(x * 3 for x in range(20)if x%5==0)
print(new)
#<generator object <genexpr> at 0x0000019725DE36D0>  （）表示生成器对象


#获得元素
print(new.__next__())#0
print(new.__next__())#15
print(new.__next__())#30
print(new.__next__())#45

print(next(new))#0
print(next(new))#15
print(next(new))#30
print(next(new))#45
print(next(new))#StopIteration停止迭代

2. 通过函数生成

• 只要在函数中添加了yield关键字，就变成了一个生成器函数
  1. 定义一个函数，函数中使用yield关键字
  2. 调用函数，接收调用结果
  3. 得到的结果就是个生成器
  4. 通过next()函数 _ _ next _ _()

def fn():

    n = 0
    while True:
        n += 1
        yield n  #使得程序变为生成器，相当于return n +暂停
        
n = fn()
print(n)
print(next(n))#1
print(next(n))#2

5.列表推导式

• 旧的列表 --> 新的列表

1. [表达式 for 变量 in 旧列表]
2. [表达式 for 变量 in 旧列表 if 条件]

#找到名字长度大于3的语言
lst = ['python','java','ruby','php','mysql']

def fn(lst):

    new_lst = []

    for language in lst:

        if len(language) > 3:
            new_lst.append(language)

    return new_lst
print(fn(lst))

r = [language for language in lst if len(language)>3]
print(r)
#['python', 'java', 'ruby', 'mysql']
		 

6.迭代器(iterable)

• 迭代：在一些元素中获取元素的过程或者方式
• 可迭代对象
  1. 生成器
  2. 列表，元组，字符串，字典
• 迭代器定义：是一个可以记住遍历位置的对象，迭代器对象从序列中的第一个元素开始访问，直到所有的元素被访问结束，而且只能前进不能后退。
• 可以被next()函数调用 并不断返回下一个值的对象称之为迭代器

isinstance()可以检测某个实例是否是该类的实例

from collections import Iterable #Iterable就是迭代器对象

lst=[1,2,3,4]

print(isinstance(lst,Iterable))#false 可迭代对象不一定是迭代器
s =(x*3 for x in range(10))

print(isinstance(s,Iterable))#true  生成器是迭代器

print(next(lst))#error list并不是迭代器

llst=iter(lst)#可以将可迭代对象变成迭代器
print(next(llst))#1

生成器和迭代器

• 生成器的出现是为了优化程序节省内存，迭代器是一个大的范围，而生成器只是迭代器的一种。

7.单例模式

• 单例模式:设计模式的一种，相当于一种模板。单例模式保证系统中的一个类只有一个实例

1. 创建对象
   pereon的父类是object，该类中有一个_ _ new_ _ 方法来创建对象。创建对象之后，才能继续执行_ _ init _ _(self)，进行初始化

class person()
	def __new__(cls,*args,**kwargs):
		print('创建类的方法')
	def __init__(self):
		print('初始化')
p=person()

2. 对象的执行顺序

class person()
   def __new__(cls,*args,**kwargs)：
   
      print('创建类的方法')
      obj=object.__new__(cls)#创建对象
      return obj
   def __init__(self):
      print('创建完对象之后进行初始化')
p=person()

class person()
	#私有变量
	_instance =None
	def __new__(cls,*args,**kwargs)
		print('创建类的方法')
		if person._instance is None:
			obj = object.__new(cls)
			person._instance=obj
		return person._instance#将这个对象赋值给类的私有变量_instance
		
	def __init__(self):
		print('初始化')
p1=person()
p2=person()

print(id(p1),id(p2))#id值一模一样，在同一个内存空间