Python基础-Week2

1.    包、模块、类

       包可以理解为一个文件夹

       每个包内可以有多个模块

2.    Python包与模块的命名

        包是某一个模块所依赖的空间。不同的包下，可以有子包，模块可以和包以平行模式存在。

3.    __*__ 该格式为系统内定

        包（package）里一定存在 __init__.py 文件，没有则是普通文件。

        __init__.py文件本身就是一个模块

4.     import导入模块

        在项目开发中，多个包之间不可避免要互相调用，可以使用import关键字在某个包中来调用其他包中的资源。

        eg：在new1中使用new2中定义的变量 a

                import new2

                print(new2.a)

        4.1   new1.under_new1.demo2 为包new1下的under_new1文件下的demo2模块，将该路径定义（as）为 a

                eg：import new1.under_new1.demo2 as a

        4.2    同级之下可以直接调用（import  模块名）

        4.3    调用子包内的模块

                 import要加上子包的包名

        4.4    不可以直接引用变量

        4.5    from XXX import XXX

                 如果路径过长，要在代码中多次使用某个模块的变量，如下编写就显得啰嗦：

                 import directory_name.module_name

                 print(directory_name.module_name.a)

                 此时就可以利用以下方法来简化：

                 from directory_name.module_name import a

                 print (a)

        4.6    调用模块下的变量 from *(模块) import *(变量/函数)

        4.7    * 的使用

                 如果要引用某个模块中的多个变量，就要重复操作form XXX import XXX 

                 from XXX import a

                 from XXX import b

                 from XXX import c

                 使用 * 则可以一次性导入所有变量：  from XXX import *

                 或者使用逗号分隔 ：  from XXX import a,b,c   如果一行无法书写完成，则可如下书写：

                 from XXX import (a,b,

                 c)

        4.8    __init__.py  的使用 

                一个文件中是否拥有__init__.py ，决定这个文件是否是包。（有则是，无则否）

                一个子包下拥有__init__.py模块，此时调用该子包下的任意模块包括这个包时，都会率先执行 __init__.py模块

        4.9   __all__   的使用 

                限制导入变量

                批量导入时可以限制模块内某些变量不被导入，但是单个导入时，仍然可以导入。（在该模块中用__all__声明）

                在某个模块中存在三个变量a,b,c，在利用 * 导入时 只想导入a和b ，操作如下：

                

                批量导入模块时，需要在__init__.py模块中利用__all__声明批量调用的模块有哪些。

                 使用  __all__  时，没有在列表中的变量可以利用 from XXX import XXX 来单独引入

        4.10  两个模块之间不能互相调用，否则这两个模块之间会产生依赖，进行无限调用

5.     函数

        round()

                a = 1.2345

                result = round(a,3)

        (1)功能性

        (2)隐藏细节

        (3)避免编写重复的代码

        5.1   定义

                def funcname():

                        pass

                 (1) 可以没有参数列表

                 (2) return value 若没有返回值，Python默认返回None

                 eg：实现两个数字相加 ：

                         def add(x,y):

                                result = x+ y

                                return result

                          打印参数：

                            def print(x):

                                    print(x)

    

                            a = add(x,y)

                            b = pritn(x)

                            print(a,b)

                                 import sys

                                 sys.setrecursionlimit(1000000)

                             print()函数可以灵活防止参数个数，但并不是所有的函数都可以放任意个参数

         5.2 return 

               在程序中一旦出现return语句，程序立即终止

               在Python中，若要返回多个变量，只需用逗号将变量分隔即可，如：return x,y,z

         5.3 序列解包

                x,y = funcname()

                a = 1

                b = 2

                c = 3

                a, b, c =1, 2, 3

                d = 1, 2, 3 or

                print(type(d))

                a, b, c = d

                a, b, c =[1,2,3] 

        5.4   可变参数

                在 Python 函数中，可以定义可变参数。可变参数就是传入的参数个数是可变的，可以是1个，2个 ··· 任意个，还可以是0个。

         5.5  必须参数

                在函数参数列表中所定义的参数

                def add(x,y)括号中的x,y为形式参数

                add(1,2)实际参数，实参

        5.6   关键字参数

                add(y=3, x=2) 使用关键字参数，也就是在参数列表中具体声明给每个参数传递的值

                如果只传一个参数，如 add(x=2) 会报错，定义多少个形参，就要传递多少实参

                与必须参数相比，两者的不同在于函数的调用上

        5.7   calc 可变参数

                def calc (*numbers):

                        sum = 0

                        for n in numbers:

                                sum = sum + n * n

                         return sum

                print(clac(2,3,4,5))

                

                l = [1,2,3,4]

                t = (1,2,3,4)

                print(clac(*l))

                print(clac(*t))