python---第三方模块和面向对象

<一.>python—第三方模块

1.python系统内置第三方模块

import os
import random
import string
random.random()
random.randint(1,4)
random.choice('hello')
random.sample(string.ascii_letters + string.digits,4)
random.shuffle(list(range(1,10)))
import functools
functools.reduce(lambda  x,y:x+y,range(10))

2.第三方模块—itchat

import itchat
# hotReload=True,会保留登陆状态，在短时间内重新登陆不用
# 再次扫描二维码
itchat.auto_login()
# 1.给手机助手发送消息
# while True:
#     #itchat.send('hello',toUserName='filehelper')
#     itchat.send_file('/etc/passwd',toUserName='filehelper')

# 2.统计你的好友的男女比例
friends = itchat.get_friends()
#print(friends)

info={}
for friend in friends[1:]:
    if friend['Sex'] == 1:
       info['male'] = info.get('male',0) + 1
    elif friend['Sex'] == 2:
        info['female'] = info.get('female',0) + 1
    else:
        info['other'] = info.get('other',0) + 1
print(info)

import itchat
import requests

def get_tuling_reponse(_info):
    #print(_info)
    api_url = 'http://www.tuling123.com/openapi/api'
    data ={
        'key':'d6cdfe1757a044d7b6370927acebc297',
        'info':_info,
        'userid':'haha'
    }

    # 发送数据到指定网址，获取网址返回的数据
    res = requests.post(api_url,data).json()
    #print(res,type(res))
    # 给用户返回的内容
    print(res['text'])
    return res['text']

# get_tuling_reponse('给我讲个笑话～')
# get_tuling_reponse('给我讲个故事')
# get_tuling_reponse('cat')


# 时刻监控好友发送的文本消息，并且给予一个回复
# isGroupChat=True 接收群聊消息
# 注册响应事件，消息类型为itchat.content.TEXT，即文本消息
@itchat.msg_register(itchat.content.TEXT,isFriendChat=True)
def text_reply(msg):
    # 获取好友发送的文本消息
    # 返回同样的文本消息
    content = msg['Content']
    # 将好友的消息发送给机器人去处理，处理的结果就是返回给好友的消息
    returnContent = get_tuling_reponse(content)
    return returnContent

itchat.auto_login()
itchat.run()

@itchat.msg_register(itchat.content.TEXT,isFriendChat=True)
def text_reply(msg):
    """
    需求:当我们的文件助手发送消息的时候，执发送的内容
        1.如果执行成功，显示执行结果
        2.如果执行失败，显示执行失败
    :param msg:
    :return:
    """
    if msg['ToUserName'] == 'filehelper':
        # 获取要执行的命令的内容
        command = msg['Content']
        # 让电脑执行命令代码
        # 如果执行成功，返回值是0
        if os.system(command) == 0:
            res = os.popen(command).read()
            result = '[返回值]-命令执行成功，执行结果:\n' + res
            itchat.send(result,'filehelper')
        # 如果命令执行失败
        else:
            result = '[返回值]-命令%s执行失败，请重试' %(command)
            itchat.send(result,'filehelper')

itchat.auto_login()
itchat.run()

import itchat
# 给指定好友发送消息

itchat.auto_login(hotReload=True)
# 根据好友昵称查找好友的信息,返回值是一个列表，有多个元素
res = itchat.search_friends('刘玉')
#print(res)
# 通过索引获取该好友的详细信息
ly = res[0]['UserName']
while True:
    itchat.send('python',toUserName=ly)

import itchat
# 给指定好友发送消息

itchat.auto_login(hotReload=True)
# 根据好友昵称查找好友的信息,返回值是一个列表，有多个元素
res = itchat.search_friends('yy')
#print(res)
# 通过索引获取该好友的详细信息
ly = res[0]['UserName']
while True:
    itchat.send('python',toUserName=ly)

<二.>python—面向对象

面向对象（oop）基本概念

面向对象： 相对于函数来说是一个更大的封装，根据职责将对象所能实现的功能封装到一起
1.确定对象要做的事情(方法---->多个)
2.让对象调用方法

类： 是一群具有相同特征和行为事物的一个统称(抽象的---->不能直接使用)
特征：被称为属性
行为：被称为方法

对象： 由类创建出来的一个具体的存在，由哪一个类创建出来的对象，就拥有哪一个类中定义的方法和属性

类和对象的关系：

    类是模板，对象是根据这个模板创建出来的，先有类再有对象
    类只需要有一个，对象可以有很多个
    由同一类创建出来的不同对象之间的属性可以不相同
    类中定义了什么属性和方法，使用这个类创建出来的对象就有什么属性和方法，不可能多也不可能少

类的设计：

    类名：这类事物的名字(大驼峰命名法)
    大驼峰命名法
    1. 每一个单词的首字母大写
    2. 单词与单词之间没有下划线
    属性:这个类创建出来的对象有什么样的特征
    方法：这个类创建出来的对象有什么样的行为

类名的确定：
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类

<一.>python—第三方模块
1.python系统内置第三方模块

import os
import random
import string
random.random()
random.randint(1,4)
random.choice(‘hello’)
random.sample(string.ascii_letters + string.digits,4)
random.shuffle(list(range(1,10)))
import functools
functools.reduce(lambda x,y:x+y,range(10))

2.第三方模块—itchat

import itchat

hotReload=True,会保留登陆状态，在短时间内重新登陆不用

再次扫描二维码

itchat.auto_login()

1.给手机助手发送消息

while True:

#itchat.send(‘hello’,toUserName=‘filehelper’)

itchat.send_file(’/etc/passwd’,toUserName=‘filehelper’)

2.统计你的好友的男女比例

friends = itchat.get_friends()
#print(friends)

info={}
for friend in friends[1:]:
if friend[‘Sex’] == 1:
info[‘male’] = info.get(‘male’,0) + 1
elif friend[‘Sex’] == 2:
info[‘female’] = info.get(‘female’,0) + 1
else:
info[‘other’] = info.get(‘other’,0) + 1
print(info)

import itchat
import requests

def get_tuling_reponse(_info):
#print(_info)
api_url = ‘http://www.tuling123.com/openapi/api’
data ={
‘key’:‘d6cdfe1757a044d7b6370927acebc297’,
‘info’:_info,
‘userid’:‘haha’
}

# 发送数据到指定网址，获取网址返回的数据
res = requests.post(api_url,data).json()
#print(res,type(res))
# 给用户返回的内容
print(res['text'])
return res['text']

get_tuling_reponse(‘给我讲个笑话～’)

get_tuling_reponse(‘给我讲个故事’)

get_tuling_reponse(‘cat’)

时刻监控好友发送的文本消息，并且给予一个回复

isGroupChat=True 接收群聊消息

注册响应事件，消息类型为itchat.content.TEXT，即文本消息

@itchat.msg_register(itchat.content.TEXT,isFriendChat=True)
def text_reply(msg):
# 获取好友发送的文本消息
# 返回同样的文本消息
content = msg[‘Content’]
# 将好友的消息发送给机器人去处理，处理的结果就是返回给好友的消息
returnContent = get_tuling_reponse(content)
return returnContent

itchat.auto_login()
itchat.run()

@itchat.msg_register(itchat.content.TEXT,isFriendChat=True)
def text_reply(msg):
“”"
需求:当我们的文件助手发送消息的时候，执发送的内容
1.如果执行成功，显示执行结果
2.如果执行失败，显示执行失败
:param msg:
:return:
“”"
if msg[‘ToUserName’] == ‘filehelper’:
# 获取要执行的命令的内容
command = msg[‘Content’]
# 让电脑执行命令代码
# 如果执行成功，返回值是0
if os.system(command) == 0:
res = os.popen(command).read()
result = ‘[返回值]-命令执行成功，执行结果:\n’ + res
itchat.send(result,‘filehelper’)
# 如果命令执行失败
else:
result = ‘[返回值]-命令%s执行失败，请重试’ %(command)
itchat.send(result,‘filehelper’)

itchat.auto_login()
itchat.run()

import itchat

给指定好友发送消息

itchat.auto_login(hotReload=True)

根据好友昵称查找好友的信息,返回值是一个列表，有多个元素

res = itchat.search_friends(‘刘玉’)
#print(res)

通过索引获取该好友的详细信息

ly = res[0][‘UserName’]
while True:
itchat.send(‘python’,toUserName=ly)

import itchat

给指定好友发送消息

itchat.auto_login(hotReload=True)

根据好友昵称查找好友的信息,返回值是一个列表，有多个元素

res = itchat.search_friends(‘yy’)
#print(res)

通过索引获取该好友的详细信息

ly = res[0][‘UserName’]
while True:
itchat.send(‘python’,toUserName=ly)

<二.>python—面向对象
面向对象（oop）基本概念

面向对象： 相对于函数来说是一个更大的封装，根据职责将对象所能实现的功能封装到一起
1.确定对象要做的事情(方法---->多个)
2.让对象调用方法

类： 是一群具有相同特征和行为事物的一个统称(抽象的---->不能直接使用)
特征：被称为属性
行为：被称为方法

对象： 由类创建出来的一个具体的存在，由哪一个类创建出来的对象，就拥有哪一个类中定义的方法和属性

类和对象的关系：

类是模板，对象是根据这个模板创建出来的，先有类再有对象
类只需要有一个，对象可以有很多个
由同一类创建出来的不同对象之间的属性可以不相同
类中定义了什么属性和方法，使用这个类创建出来的对象就有什么属性和方法，不可能多也不可能少

类的设计：

类名：这类事物的名字(大驼峰命名法)
大驼峰命名法
1. 每一个单词的首字母大写
2. 单词与单词之间没有下划线
属性:这个类创建出来的对象有什么样的特征
方法：这个类创建出来的对象有什么样的行为

类名的确定：

名词提炼法分析整个业务流程，出现的名词，通常就是找到的类

属性和方法的确定：
对对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑

举例： 猫爱吃鱼，猫要喝

# 创建猫类   
class Cat:
# 哪一个对象调用的方法,self就是哪一个对象的引用
# 在类封装方法的内部,self就表示当前调用方法的对象自己
# 在类的方法内部,可以通过 self.属性 来访问对象的属性
    def eat(self):
        print('%s 爱吃鱼' %(self.name))

    def drink(self):
        print('猫要喝水')

# 创建猫对象
tom = Cat()
# 在类的外部 对象.属性 可以给对象添加属性(不推荐使用)
# 对象包含哪些方法,应该封装再类中
tom.name = 'Tom'
print(tom)
addr = id(tom)
print(addr)
# %x:打印格式为十六进制
print('%x' %(addr))
# %d:打印格式为十进制
print('%d' %(addr))
tom.eat()
tom.drink()


# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = 'miaomiao'
print(lazy_cat)
lazy_cat.eat()
lazy_cat.drink()

lazy_cat2 =lazy_cat
print(lazy_cat2)

__init__初始化方法

初始化方法
我们现在已经知道了使用 类名( ) 就可以创建一个对象
当使用 类名( ) 创建对象时，python的解释器会自动执行以下操作：
1.为对象在内存中分配空间----创建对象
2.调用初始化方法为对象的属性设置初始值----初始化方法__init__

这个初始化方法就是__init__方法，__init__是对象的内置方法，__init__方法是专门用来定义一个类具有哪些属性的方法

改造初始化方法----初始化的同时设置初始值：
在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用 self.属性名 = 形参 接收外部传递的参数
3.在创建对象时，使用类名(属性1，属性2，…)调用

改造初始化方法，可以让创建对象更加灵活

class Cat:
    def __init__(self,new_name):
        print('这是一个初始化方法')
        # self.属性名 = 属性的初始值
        # self.name = 'Tom'
        self.name = new_name
    # 在类中，任何方法都可以使用self.name
    def eat(self):
        print('%s 爱吃鱼' %(self.name))

# 使用类名()创建对象的时候，会自动调用初始化方法__init__
tom = Cat('tom')
# 定义属性之后，再用Cat创建对象的时候，都会拥有该属性
print(tom.name)
tom.eat()

lazy_cat = Cat('miaomiao')
print(lazy_cat.name)
lazy_cat.eat()

__del__方法

如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

当使用类名( )创建对象时，为对象分配完空间后，会自动调用__init__方法
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法

应用场景：
__init__改造初始化方法，可以让创建对象更加灵活
__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

生命周期(出生到死亡)：
一个对象从调用类名( )创建，生命周期开始
一个对象的__del__方法一但被调用，生命周期结束
在对象的生命周期内，可以访问对象属性，或者让对象调用方法

class Cat:
    def __init__(self,new_name):
        self.name = new_name
        print('%s 来了' %(self.name))
    def __del__(self):
        print('%s 走了' %(self.name))

cat = Cat('tom')
print(cat.name)
# del关键字可以删除一个对象，del关键字自己调用__del__方法
del cat
print('*' * 50)

__str__方法

返回对象的描述信息(print函数输出使用)

在python中，使用python输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址(十六进制表示)

如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了

class Cat:
    def __init__(self,new_name):
        self.name = new_name
    def __str__(self):
        # 必须返回一个字符串
        return '我是 %s' %(self.name)

cat = Cat('tom')
print(cat)

面向对象实现栈

 class Stack:
    def __init__(self):
        self.stack = []
    def push(self,value):
        self.stack.append(value)
        return True
    def pop(self):
        if self.stack:
            item = self.stack.pop()
            return item
        else:
            return False
    def top(self):
        if self.stack:
            return self.stack[-1]
        else:
            return False
    def len(self):
        return len(self.stack)
    def isempty(self):
        return self.stack == []
    def view(self):
        return ','.join(self.stack)

s = Stack()
s.push('1')
s.push('2')
s.push('3')
print(s.view())

print(s.top())

print(s.len())

item = s.pop()
print(item)
print(s.view())

print(s.isempty())

1.面向对象—封装

封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中(为什么说是抽象的，因为类不能直接使用)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

需求1:
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤

class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def __str__(self):
        return ('我的名字叫 %s 体重是 %.2f' %(self.name,self.weight))
# 在对象方法内部，可以直接访问对象的属性
    def run(self):
        print('%s 爱跑步' %(self.name))
        self.weight -= 0.5
    def eat(self):
        print('%s 吃东西' %(self.name))
        self.weight += 1
xiaoming = Person('小明',75.0)
xiaoming.run()
xiaoming.eat()
#print(xiaoming.weight)
print(xiaoming)


# 同一个类创建出多个对象之间，属性互补干扰的
xiaomei = Person('小美',45.0)
xiaomei.run()
xiaomei.eat()
print(xiaomei)
print(xiaoming)

需求2：摆放家具
需求：
1.房子有户型，总面积和家具名称列表
	新房子没有任何的家具
2.家具有名字和战地面积，其中
	床：占4平米
	衣柜：占2平面
	餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

class HouseItem:
    # 初始化方法
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s] 占地 %.2f' % (self.name, self.area)


class House:
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具名称列表
        self.item_list = []

    def __str__(self):
        return ('户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：'
                '%s' %(self.house_type,self.area,self.free_area,self.item_list))

    def add_item(self,item):
        #print('要添加 %s' %(item))
        #1.判断家具的面积
        if item.area > self.free_area:
            print('%s的面积太大了，无法添加' %(item.name))
            return
        #2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        #3.计算剩余面积
        self.free_area -= item.area

# 1.创建家具
bed = HouseItem('bed', 400)
print(bed)
chest = HouseItem('chest', 200)
print(chest)
table = HouseItem('table', 1.5)
print(table)


# 2.创建房子对象
my_home = House('两室一厅',100)
#print(my_home)
# 将家具添加到房子里
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

演练重点：一个对象的属性可以是另外一个类创建的对象
示例:士兵射击
需求：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量

class Gun:
    def __init__(self,model):
        # 枪的型号
        self.model = model
        # 子弹的数量(调用增加子弹的方法来增加子弹数量)
        self.bullet_count = 0

    def add_bullet(self,count):
        self.bullet_count += count

    def shoot(self):
        # 判断子弹数量
        if self.bullet_count <= 0:
            print('[%s] 没有子弹了...' %(self.model))
            return
        # 发射子弹 子弹数量变化
        self.bullet_count -= 1
        print('[%s] tututu~ [%d]' %(self.model,self.bullet_count))

class Soldier:
    def __init__(self,name):
        self.name = name
        # 枪（新兵没有枪）
        self.gun = None

    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun == None:
            print('[%s] 还没有枪..' %(self.name))
            return
        print('go!!![%s]' %(self.name))
        self.gun.add_bullet(50)
        self.gun.shoot()


# 创建枪对象
ak = Gun('ak47')
# ak.add_bullet(50)
# ak.shoot()
# ak.shoot()

# 创建士兵对象
ryan = Soldier('Ryan')
# 通过主程序的赋值语句，士兵有枪了
ryan.gun = ak
ryan.fire()
#print(ryan.gun)

2.面向对象—类属性和类方法

类是一个特殊的对象
Python中一切皆对象
	class AAA: 定义的类属性属于类对象
	obj1 =AAA: 属于实例对象
在运行程序时，类 同样会被加载到内存
在python中，类 是一个特殊的对象--类对象
在程序运行时，类对象(模板) 在内存中之有一份，使用一个类(模板)可以创建出很多个对象实例
除了封装 实例 的属性和方法外，类对象还可以有自己的属性和方法
1.类属性
2.类方法
通过 类名. 的方式可以直接访问类的属性或者调用类的方法

类方法需要用修饰器@classmethod来标示，告诉解释器这是一个类方法
类方法的第一个参数应该是cls
	由哪一个类调用的方法，方法内的cls就是哪一个类的引用
	这个参数和实例方法的第一个参数是self类似(哪一个对象调用的方法，self就是哪一个对象的引用)

通过类名调用类方法，调用方法时，不需要传递cls参数

在方法内部
	也可以通过cls.访问类的属性
	也可以通过cls.调用其他的类方法

静态方法.py
class Cat(object):
    @staticmethod
    def call():
        print('喵～')
# 不需要创建对象，直接就可以使用
Cat.call()

3.面向对象—继承

继承：实现代码的重用，相同的代码不需要重复的写

单继承：
子类拥有父类的所有方法和属性(子类只需封装自己特有的方法)

多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法

class Animal:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵喵～')

class Hellokitty(Cat):
    def speak(self):
        print('我可以说日语～')

# 创建猫对象
# fentiao = Cat()
# fentiao.eat()
# fentiao.drink()
# fentiao.run()
# fentiao.sleep()
# fentiao.call()

hk = Hellokitty()
hk.speak()
# 子类可以继承父类的所有属性和方法
hk.call()

# 继承的传递性，子类拥有父类的父类的属性和方法
hk.eat()
hk.drink()
hk.run()
hk.sleep()

 class A:
     def test(self):
         print('test 方法')
 class B:
     def demo(self):
         print('demo 方法')
 class D:
     def haha(self):
          print('!!!!!!!!!!!!')
 class C(A,B,D):
     """多继承可以让子类对象，同时具有多个父类的属性和方法"""
     pass
 c = C()
 c.test()
 c.demo()
 c.haha()

多继承的注意事项：
问题的提出：
如果不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪一个父类中的方法呢？
提示：开发时，应尽量避免这种容易产生混淆的情况
如果父类之间存在同名的属性或方法，因该尽量避免使用多继承
class A:
    def test(self):
        print('A----test 方法')
    def demo(self):
        print('A----demo 方法')

class B:
    def test(self):
        print('B----test 方法')
    def demo(self):
        print('B----demo 方法')

class C(B,A):
    pass
c = C()
c.test()
c.demo()

新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类

4.面向对象—多态

 覆盖：在子类中重写父类的方法，在运行中，只会调用子类中重写的父类方法；
 	而不会调用父类中的这个方法；

5.面向对象—私有属性和私有方法

应用场景
	在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到
	私有属性 就是 对象 不希望公开的 属性
	私有方法 就是 方法 不希望公开的 方法
定义方法
	在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法

class Women(object):
    def __init__(self,name):
        self.name = name
        self.__age = 18

    def __secret(self):
        print('%s 的年龄是 %d' %(self.name,self.__age))

lily = Women('lily')
#print(lily.age)
lily.__secret()

class Date(object):
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
    # 实例方法(默认情况下会传递对象给echo方法)
    def echo(self):
        print('%s %s %s' %(self.year,self.month,self.day))

    # 默认传递类本身给这个方法
    @classmethod
    def as_string(cls,s):
        #print(cls)
        month,day,year = s.split('/')
        d = cls(year,month,day) # d = Date(2018,10,10)
        return d

    @staticmethod
    def is_vaild(s):
        # 批量将年月日转换成整型
        # month,day,year = s.split('/')
        # month,day,year = [int(i) for i in s.split('/')]
        month,day,year = map(int,s.split('/'))
        return 0<month<=12 and 0<day<=31 and 1<year< 9999

# d = Date(2018,10,10)
# print(d)
# d.echo()

s = '10/10/2018'
print(Date.as_string(s))
# print(Date.is_vaild(s))

# d = Date(2018,10,10)
# print(d.is_vaild('13/10/2019'))

模块

模块(python–核心概念)

    每一个以 扩展名.py 结尾的python源代码都是一个模块
    模块就好比是工具包，要想使用这个工具包中的工具，就先导入这个模块
    在模块中定义的 全局变量、函数、类 都是提供给外界直接使用的工具
    变量名/函数名/类名/方法名(标示符) 需要符合标示符号的命名规格

模块包括：

内置模块，自定义模块，第三方模块

好处：

    大大提高了代码的可维护性，编写代码不必从零开始。
    当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。

    使用模块还可以避免函数名和变量名冲突。
    相同名字的函数和变量完全可以分别存在不同的模块中，
    因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。
    但是也要注意，尽量不要与内置函数名字冲突。

模块导入的两种方式：

1.推荐使用

import day10.test1
import day10.test2

2.不规范
import day10.test1,day10.test2

模块导入

如果模块的名字太长(或者你不喜欢)，可以使用as指定模块的别名

import day10.test1 as test1_10

如果希望从某一个模块中，导入部分工具，可以用from xx import xx

from test3 import say_hello1

from xx import xx：不需要通过模块名，可以直接使用模块提供的工具
import：一次性把模块中的所有工具都全部导入(通过 模块名/别名.工具名)

from test3 import say_hello1
say_hello1()

import day10.test1
day10.test1.say_hello()
print(day10.test1.test1)

模块导入原则：

每一个 xx.py 文件都应该是可以被导入的
----一个独立的python文件就是一个模块
----在我们导入文件的时候，文件中所有缩进的代码都会执行一遍
解决问题

问题：导入模块时， 模块里面执行代码结果也会显示
解决方法：

__name__, 所在文件没有当作模块导入时，结果为__main__;
__name__, 所在文件被当作模块导入时，结果为模块的名称;

判断模块是否被导入， 如果没有被导入， 则执行下面的代码.

if __name__ == '__main__':
    print('这是写好的模块里面的显示.......')
    print(timeit(hello))
    print(__name__)

面向对象（oop）
基本概念

面向对象： 相对于函数来说是一个更大的封装，根据职责将对象所能实现的功能封装到一起
1.确定对象要做的事情(方法---->多个)
2.让对象调用方法

类： 是一群具有相同特征和行为事物的一个统称(抽象的---->不能直接使用)
特征：被称为属性
行为：被称为方法

对象： 由类创建出来的一个具体的存在，由哪一个类创建出来的对象，就拥有哪一个类中定义的方法和属性

类和对象的关系：

    类是模板，对象是根据这个模板创建出来的，先有类再有对象
    类只需要有一个，对象可以有很多个
    由同一类创建出来的不同对象之间的属性可以不相同
    类中定义了什么属性和方法，使用这个类创建出来的对象就有什么属性和方法，不可能多也不可能少

类的设计：

    类名：这类事物的名字(大驼峰命名法)
    大驼峰命名法
    1. 每一个单词的首字母大写
    2. 单词与单词之间没有下划线
    属性:这个类创建出来的对象有什么样的特征
    方法：这个类创建出来的对象有什么样的行为

类名的确定：
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类