课堂笔记14-模块

课堂笔记

1. 模块

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

# print(__name__)

# 在模块中定义变量
a = 1
b = 2
_c = 3
# 在模块中定义函数
def test1():
    print('test1')


def test2():
    print('test2')

# 在模块中定义类
class Person:

    def __init__(self):


        self.name = '葫芦娃'

p = Person()

# print(p)
# 以下是测试代码 当你是主模块的时候在执行
if __name__ == '__main__':
    test2()
    test1()
    print(p.name)

2. 模块的创建

在Python当中⼀个py⽂件就是⼀个模块

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

可以引⼊同⼀个模块多次，但是模块的实例只会创建⼀次 import 模块名 as 模块别名

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

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

# 模块的创建

# 在python中一个py文件就是一个模块
# 在一个模块中引入外部模块
# 可以引入同一个模块多次，但是模块的实例只会执行一次
# 1. import 模块名 (模块名就是我们的Python文件名)

# import test_m
# import test_m
# import test_m



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

# print(__name__) # __main__

# print(test) # NameError: name 'test_m' is not defined

# 在每一个模块当中都有一个 __name__。通过它我们可以获得模块的名字

# 模块的使用
# import requests
#
# requests.get()
# import test_m
# 访问模块中的变量 语法 模块名.变量名

# def test2():
#
#     print('我是主模块中的test2....')

# print(test_m.a,test_m.b)

# 访问模块中的函数 语法 模块名.函数名
# test_m.test1()
# test_m.test2()

# 访问模块中的对象 语法 模块名.对象名
# p = test_m.Person()
# print(p.name)

# 3.我们也可以引入模块中的部分内容
# 语法 from 模块名 import 变量名,变量名，变量名.....
# from test_m import Person
#
# # print(test_m) # NameError: name 'test_m' is not defined
#
# from test_m import test1
#
# p1 = Person()
#
# # print(p1)
# test1()
# from test_m import Person,test1,test2

# from test_m import *
#


# 4. 语法 from 模块名 import 变量名 as 别名
#
# from test_m import test2 as new_test2
#
#
# test2()
# new_test2()

import test_m
# from test_m import *

# print(test_m._c)

# 1.import xxx
# 2.import xxx as yyy
# 3.from xxx import yyy,zzz,fff
# 4.from xxx import yyy as zzz
# from xxx import *

3. 模块的使⽤

访问模块中的变量 语法是 模块名.变量名
访问模块中的函数 语法是 模块名.函数名
访问模块中的对象 语法是 模块名.对象名
我们也可以引⼊模块中部分内容 语法 from 模块名 import 变量，变量…
还有⼀种引⼊⽅式 语法 from 模块名 import 变量 as 别名

# 定义一个类
class A(object):

    # 类属性 直接在类中定义的属性
    # 类属性可以通过类和类的实例访问到
    # 类属性只能通过类对象来修改,无法通过实例对象修改
    count = 0

    def __init__(self):
        # 实例属性 通过实例对象添加的属性
        # 实例属性只能通过实例对象访问和修改，类对象无法访问和修改
        self.name = '葫芦娃'
    #     # 实例方法
    # 在类中定义，以self第一个参数的方法都是实例方法
    # 实例方法在调用的时候 Python会将调用对象以self传入
    # 当通过类去调用时，不会自动传递self，此时需要手动传递self
    def test(self):

        print('这是test方法......',self)

    # 类方法
    # 类方法和实例方法的区别 实例方法第一个是参数self 而类方法第一个参数是cls
    # 而且类方法需要用@classmethod
    @classmethod
    def test_2(cls):

        print('这是test2方法 它是一个类方法...',cls)
        print(cls.count)
    #  @staticmethod  修饰的方法是静态方法
    # 静态方法不需要指定任何默认参数。静态方法可以通过类或者实例调用
    # 静态方法 基本上是一个和当前类无关的方法。它只是一个保存到当前类的函数
    # 静态方法一般都是一些工具方法。和当前类无关
    @staticmethod
    def test_3():
        print('test3方法是一个静态方法')

a = A()
a.name = 'xxxx'
# b = A()
# a.count = 10

# A.count = 100
# print('A',A.count)
# print('a',a.count)
# print('a,',a.name)
# print('A',A.name) # AttributeError: type object 'A' has no attribute 'name'

# a.test()
# A.test(a) # TypeError: test() missing 1 required positional argument: 'self'
# a.test() 等价于 A.test(a)

# A.test_2()
# a.test_2()
# A.test_2() 等价于 a.test_2()

A.test_3()
a.test_3()

print()

max()

input()