Python入门笔记(四)

zdb呀

于 2024-10-10 19:24:11 发布

阅读量285

点赞数 4

分类专栏： # Python基础文章标签： python 笔记开发语言

本文链接：https://blog.csdn.net/qq_39236499/article/details/142829931

版权

Python基础专栏收录该内容

14 篇文章 3 订阅

订阅专栏

文章目录

第九章集合set
第十章函数

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。
点击跳转：人工智能从入门到精通教程

本文电子版获取方式：
「Python入门笔记(四).pdf」，复制整段内容，打开最新版「夸克APP」即可获取。
链接：https://pan.quark.cn/s/4c5293739126

第九章集合set

9.1 创建集合：set()、集合生成式

一种是直接把一对元素用花括号括起来
一种是使用set()工厂函数
集合生成式

1.set()
例1

set1 = set([1,2,3,4,5,6])       #将list转换成set
print(set1)
print(type(set1))

{1, 2, 3, 4, 5, 6}
<class 'set'>

2.集合生成式

"""集合生成式，就是把列表的改成集合"""
# 列表生成式
list1 = [i*i for i in range(6)]
print(list1)

# 集合生成式
set1 = {i*i for i in range(6)}
print(set1)

[0, 1, 4, 9, 16, 25]
{0, 1, 4, 9, 16, 25}

9.2 集合性质

集合无映射关系，也是大括号
集合无序，不能索引
集合中每个元素只出现一次

num = {}               #字典
print(type(num))
num2 = {1,2,3,4,5}     #集合，无映射关系
print(type(num2))

<class 'dict'>
<class 'set'>

集合数据具有唯一性

num1 = {1,2,3,4,5,5,4,3,2,1}   #集合数据具有唯一性，集合是无序的，不能索引
print(num1)
#print(num1[2])    #错误，不可索引

{1, 2, 3, 4, 5}

例

num1 = [1,2,3,4,5,5,3,1,0]
num1 = set(num1)        #数据唯一，重复的自动删去
print(num1)

{0, 1, 2, 3, 4, 5}

集合中的数学操作：交集、并集、差集、对称差集
1、交集：intersection()、&

# 方法一：.intersection()
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))
# 方法二
print(s1 & s2)

{40, 20, 30}
{40, 20, 30}

2、并集：union()、|

s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
# 方法一
print(s1.union(s2))
# 方法二
print(s1 | s2)

{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}

3、差集：-

s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.difference(s2))  # s1中不同于s2的
print(s1 - s2)

{10}
{10}

4、对称差集：s1 + s2 - (s1 & d2) symmertric_difference()

s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.symmetric_difference(s2))  # 除去两者相同的
print(s1 ^ s2)

{50, 10, 60}
{50, 10, 60}

9.3 一些函数：issubset()、issuperset()、isdisjoint()

1、判断相等

s = {10, 20, 30, 40}
s2 = {40, 20, 10, 30}
print(s == s2)

True

2、.issubset()判断是否为子集

s = {10, 20, 30, 40}
s3 = {10, 20, 30}
s4 = {20, 30, 40}
print(s3.issubset(s))   # 判断子集，s3是s的子集
print(s4.issubset(s))

True
True

3、.issuperset()判断是否为超集

s = {10, 20, 30, 40}
s3 = {10, 20, 30}
print(s.issuperset(s3))  # 判断超集,s是s3的超集

True

4、isdisjoint()判断是否有交集，有交集为False

s = {10, 20, 30, 40}
s3 = {10, 20, 30}
print(s3.isdisjoint(s))  # 有交集为False，否则为True

False

in， not in判断集合元素

s = {10, 20, 30, 40}
print(10 in s)
print(50 not in s)

True
True

9.4 集合增加元素：add()、update()

.add()：集合添加元素

num1 = {1,2,3,4,5}
num1.add(6)            #添加6
print(num1)

{1, 2, 3, 4, 5, 6}

.update()：可以一次添加多个

s = {10, 20, 30, 40}
s.update([50])
print(s)
s.update({60})
print(s)

{40, 10, 50, 20, 30}
{40, 10, 50, 20, 60, 30}

9.5 集合删除元素：remove()、discard()、pop()、clear()

.remove()：集合删除指定元素，如果不存在就抛出异常

num1 = {1,2,3,4,5}
num1.remove(5)         #移除5
print(num1)

{1, 2, 3, 4}

.discard()：一次删除一个指定元素，删除没有的不会报异常

s = {10, 20, 30, 40}
s.discard(10) 
s.discard(50)   # 删除没有的不会报异常
print(s)

{40, 20, 30}

.pop()：一次只删除任意一个元素，删谁不知道
不能添加参数

s = {10, 20, 30, 40}
s.pop()
s.pop()  # 删除任意，删谁不知道
print(s)

{20, 30}

错误实例：

s.pop(10)   # 不能带参数，错误代码

.clear()：清空集合，清空后为空集合

9.6 创建不能修改元素的集合：frozenset()

frozen：冰冻的，冻结的

num1 = frozenset([1,2,3,4,5])
print(num1)
print(type(num1))

num1.add(0)   #错误,frozenset删不掉
print(num1)

frozenset({1, 2, 3, 4, 5})
<class 'frozenset'>

    num1.add(0)   #错误
AttributeError: 'frozenset' object has no attribute 'add'

第十章函数

什么是函数：函数就是执行特定任务和完成特定功能的一段代码

函数的作用：

1、复用代码
2、隐藏实现细节
3、提高可维护性
4、提高可读性便于调试

函数命名规则：

小写
下划线隔开单词
注释函数功能

10.1 函数定义：def

形参赋值默认值等号两边不要有空格

def greet_user():
    """显示简单的问候语"""
    print("Hello!")

greet_user()

Hello!

空函数

def nop():
    pass

问题：pass语句什么都不做，那有什么用？
答：实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

内嵌函数：即函数内嵌入函数

def fun1():
    print('fun1正在被调用...')
    def fun2():    #fun2为fun1的内嵌函数
        print('fun2正在被调用...')
    fun2()     #fun1内部的函数，不可以在外部调用
fun1()

fun1正在被调用...
fun2正在被调用...

10.2 闭包

def FunX(x):
    def FunY(y):    #闭包,引用了外层函数的参数x
        return x*y
    return FunY

i = FunX(8)       #x=8
print(i)
print(type(i))
print(i(5))     #y=5

print(FunX(8)(5))    #只能调用X，不能Y，Y为内部局部变量

<function FunX.<locals>.FunY at 0x000002C19FBCF168>
<class 'function'>
40
40

例2

def Fun1():
    x = [5]
    def Fun2():
        x[0] *= x[0]
        return x[0]
    return Fun2()

print(Fun1())

例3

def Fun1():
    x = 5
    def Fun2():
        x *= x         #x未知
        return x
    return Fun2()

print(Fun1())

错误

   x *= x
UnboundLocalError: local variable 'x' referenced before assignment

用函数封装代码

foods = ['苹果', '香蕉', '梨子']   # 所有的食物
my_foods = []                    # 我想要的食物，初始化为空
while foods:                    # 遍历食物
    food = foods.pop()          # 删除食物列表的最后一个，变成当前我点的食物
    print("我当前点的食物: " + food)
    my_foods.append(food)        # 把当前我点的食物加到我想要的食物列表中
print("\n我所有点的食物有以下:")
for my_food in my_foods:
    print(my_food)

我当前点的食物: 梨子
我当前点的食物: 香蕉
我当前点的食物: 苹果

我所有点的食物有以下:
梨子
香蕉
苹果

版本二： 用函数封装起来

def now_food(foods, my_foods):
    while foods:                    # 遍历食物
        food = foods.pop()          # 删除食物列表的最后一个，变成当前我点的食物
        print("我当前点的食物: " + food)
        my_foods.append(food)        # 把当前我点的食物加到我想要的食物列表中


def all_my_foods(my_foods):
    print("\n我所有点的食物有以下:")
    for my_food in my_foods:
        print(my_food)


foods = ['苹果', '香蕉', '梨子']   # 所有的食物
my_foods = []                    # 我想要的食物，初始化为空

now_food(foods, my_foods)
all_my_foods(my_foods)

商品打折小游戏

def discounts(price,rate):   #局部变量，只在定义里面
    final_price = price * rate
    return final_price    #局部变量，只在定义里面


old_price = float(input('请输入原价：'))  #old_price:全局变量，不在函数内
rate = float(input('请输入折扣率：'))
new_price = discounts(old_price,rate)
print('打折后价格是：',new_price)

#print('这是试图打印局部变量final_price的值：'final_price)  #错误，局部变量

请输入原价：100
请输入折扣率：0.5
打折后价格是： 50.0

10.3 函数变量的作用域：局部、全局（global、nonlocal）

局部变量(local variable)
全局变量(global variable )

局部变量：在函数内定义并使用的变量，只有函数内部有效，局部变量使用global声明，这个变量就会变成全局变量
全局变量：函数体外定义的变量，可作用于函数内外

global：定义全局变量

count=5
def MyFun():
    count=10     #局部变量
    print(count)

MyFun()
print(count)

10
5

例2

count=5
def MyFun():
    global count    #定义count为全局变量，定义了则可以修改
    count=10
    print(count)

MyFun()
print(count)

10
10

nonlocal：定义非局部变量

def Fun1():
    x = 5
    def Fun2():
        nonlocal x    #定义x为非局部变量
        x *= x        #5*5
        return x      #25
    return Fun2()

print(Fun1())

10.4 实参和形参

def greet_user(username):    # 形参
    """显示简单的问候语"""
    print("Hello, " + username.title() + "!")

greet_user("huzhuzhu")      # 实参

Hello, Huzhuzhu!

1. 位置实参：要求实参的顺序和形参的顺序相同

def describbe_pey(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describbe_pey('z', 'zdb')

I have a z.
My z's name is zdb.

例2： 调用函数多次

def describbe_pey(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describbe_pey('z', 'zdb')
describbe_pey('pet', 'zzz')

I have a z.
My z's name is zdb.

I have a pet.
My pet's name is zzz.

例3 ：位置实参的顺序很重要

def describbe_pey(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describbe_pey('zdb', 'z')

I have a zdb.
My zdb's name is z.

2. 关键字实参
接收的是dict，关键字实参是传递给函数的名称-值对

def describbe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describbe_pet(animal_type= 'z', pet_name= 'zdb')

I have a z.
My z's name is zdb.

命名关键字实参
从这个*之后的参数，只能采用关键字实参

def person(name, age, *, city, job):
    print(name, age, city, job)


person('Jack', 24, city='Beijing', job='Engineer')
person('Jack', 24, city='Beijing', job='Engineer')

Jack 24 Beijing Engineer
Jack 24 Beijing Engineer

3. 默认实参：指定默认值的形参要放在未指定默认值的形参后面
注：提供的实参多余或少于函数完成其工作所需的信息时，将出现实参不匹配错误。

def describbe_pey(pet_name, animal_type='dog'):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name + ".")

describbe_pey(pet_name= 'z')

I have a dog.
My dog's name is z.

例2

# end的默认值为换行，这里修改为制表符
print('hello', end='\t')
print('world')

hello	world

默认实参为空字符，实现实参可选
例1：有中间名的情况

def get_formatted_name(first_name, middle_name, last_name):
    """返回整洁的姓名"""
    full_name = first_name + " " + middle_name + " " + last_name
    return full_name.title()

musician = get_formatted_name('z', 'a', 'db')
print(musician)

Z A Db

例2： 中间名赋值为空字符

def get_formatted_name(first_name, last_name, middle_name=' '):
    """返回整洁的姓名"""
    if middle_name:            #python将没空字符串解读为True
        full_name = first_name + " " + middle_name + " " + last_name
    else:
        full_name = first_name + " " + last_name
    return full_name.title()

musician = get_formatted_name('z', 'db')
print(musician)

musician = get_formatted_name('z', 'db', 'a')
print(musician)

Z Db
Z A Db

4. 任意个数参数：*
个数可变的位置实参：*args

定义函数时，可能无法实现确定传递的位置实参的个数时，使用可变的位置参数；结果为一个元组

个数可变的位置参数只能定义一个

def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

例3

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum


print(calc([1, 2, 3]))
print(calc((1, 2, 5, 7)))

14
79

例4

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    print(sum)


calc(1, 2)
calc()

nums = [1, 2, 3]
calc(nums[0], nums[1], nums[2])
calc(*nums)

个数可变的关键字参数：**args

定义函数时，无法事先确定传递的关键字形参的个数，使用可变的关键字形参
结果为一个字典；个数可变的关键字参数也只能定义一个

# 个数可变的关键字形参
# 定义函数时，无法事先确定传递的关键字形参的个数，使用可变的关键字形参
# **arg
# 结果为一个字典
# 个数可变的关键字参数也只能定义一个
def fun(**args):
    print(args)
fun(a=10)
fun(a=10, b=20, c=30)

{'a': 10}
{'a': 10, 'b': 20, 'c': 30}

例2：形参**user_info中的两个星号让python创建一个名为profile的空字典，并将收到的所有名称键-值对都封装到这个字典中。

def build_profiles(first, last, **user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切"""
    profile = {}                      # 空字典profile
    profile['姓'] = first     # 键first name；   值first
    profile['名'] = last       # 键last name：    值last
    for key, value in user_info.items():    # 遍历键值对
        profile[key] = value                # 把value赋值给键对应的值
    return profile                          # 返回字典


# 调用函数
information = build_profiles('z', 'db',
                              性别='男',
                              家='南昌')
print(information)    #输出

{'姓': 'z', '名': 'db', '性别': '男', '家': '南昌'}

例3：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)


person('Bob', 35, city='Beijing')
person('Adam', 45, gender='M', job='Engineer')

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=extra['city'], job=extra['job'])
person('Jack', 24, **extra)

name: Bob age: 35 other: {'city': 'Beijing'}
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

注意：
在一个函数的定义过程中，既有个数可变的关键字形参，又有个数可变的位置形参
要求，个数可变的位置形参，放在个数可变的关键字形参之前

5. 参数小结
在这里插入图片描述
参数顺序问题

def fun5(a, b, *, c, d, **args):
    pass

def fun6(*args1, **args2):
    pass

def fun7(a, b=10, *args, **args2)

实参为列表

def greet_users(names):     #names形参，对应实参usernames
    """向列表中的每位用户都发出简单的问候"""
    for name in names:      #name临时参数
        msg = "Hello, " + name.title() + "!"
        print(msg)

usernames = ['hannnah', 'try', 'margot']    #实参为列表
greet_users(usernames)

Hello, Hannnah!
Hello, Try!
Hello, Margot!

结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中接纳任意数量实参的形参放在最后。python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

def make_pizza(size, *toppings):
    """概述要制作的披萨"""
    print("我想要个 " + str(size) + "块的手抓饼，" +
          "我要加:")
    for topping in toppings:
        print(topping)


make_pizza(16, '番茄酱')
make_pizza(12, '番茄酱', '热狗', '鸡蛋')

在这里插入图片描述
参数组合

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)


def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)


f1(1, 2)
f1(1, 2, c=3)

f1(1, 2, 3, 'a', 'b')
f1(1, 2, 3, 'a', 'b', x=99)
f2(1, 2, d=99, ext=None)

a = 1 b = 2 c = 0 args = () kw = {}
a = 1 b = 2 c = 3 args = () kw = {}

a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

例2

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)


def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)


args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw)

args = (1, 2, 3)
kw = {'d': 88, 'x': '#'}
f2(*args, **kw)

a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

10.5 return返回值

函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。
函数返回的值被称为返回值。
在函数中，可使用return语句将值返回到调用函数的代码行。
返回值让你能够将程序的大部分繁重工作移到函数中完成，从而简化主程序。

例1：返回简单值

def get_formatted_name(first_name, last_name):
    """返回整洁的姓名"""
    full_name = first_name + " " + last_name
    return full_name.title()

musician = get_formatted_name('z', 'db')
print(musician)

Z Db

(1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】，return可以省略不写
(2)函数的返回值，如果是1个，直接返回类型
(3)函数的返回值，如果是多个，返回的结果为元组
函数在定义时，是否需要返回值，视情况而定

def fun1():
    print('hello')
    # return
fun1()

def fun2():
    return 'hello'
res = fun2()
print(res)

def fun3():
    return 'hello', 'world'
print(fun3())

hello
hello
('hello', 'world')

例2：返回字典

def your_name(first_name, last_name):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'姓': first_name, '名': last_name}
    return person

name = your_name('z', 'db')
print(name)

{'姓': 'z', '名': 'db'}

例3：字典添加元素

def your_name(first_name, last_name, age=' '):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'姓': first_name, '名': last_name}
    if age:                   # 有age就赋值，没有不赋值
        person['年龄'] = age   # 将输入的age赋值给字典键age对应的值
    return person

name = your_name('z', 'db', age=22)
print(name)

{'姓': 'z', '名': 'db', '年龄': 22}

例4：结合使用函数和while循环
版本一：无线循环，不能停止

def your_name(first_name, last_name):
    """返回整洁的姓名"""
    full_name = first_name + " " + last_name
    return full_name.title()


active = True
while active:
    print("请告诉我你的名字:")
    f_name = input("First name:")     # 输入的First anme 赋值给f_name
    l_name = input("Last name:")      # 输入的Last name  赋值给l_name
    name = your_name(f_name, l_name)    # 调用定义的函数
    print("你好, " + name + "!")
    a = input("是否继续，输入quit可退出：")
    if a == 'quit':
        active = False

请告诉我你的名字:
First name:hu
Last name:zhuzhu
你好, Hu Zhuzhu!
是否继续，输入quit可退出：hu
请告诉我你的名字:
First name:hu
Last name:zhuzhu
你好, Hu Zhuzhu!
是否继续，输入quit可退出：quit

函数作为返回值
例1：实现一个可变参数的求和。
通常情况下，求和的函数是这样定义的：

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？
可以不返回求和的结果，而是返回求和的函数：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

调用函数f时，才真正计算求和的结果：

>>> f()
25

10.6 导入模块，函数的几种方法

首先，将函数存储在模块中

1、使用函数可以将代码块与主程序分离
2、通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。

1. import 模块名：导入整个模块
1.先创建模块，模块是扩展名为 .py的文件
pizza.py

def make_pizza(size, *toppings):
    """概述要制作的披萨"""
    print("\nMaking a " + str(size) +
          "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

2.调用

import pizza
pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

3.输出

Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

2. from 模块 import 函数：导入模块中特定的函数
正常调用模块使用函数

module_name.function_name()

你还可以导入模块中的特定函数

from module_name import function_name

通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数

form module_name import function_0, function_1, function_2

对于前面的making_pizza.py示例，如果只想要导入要使用的函数，代码将类似于下面这样：

from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

3. 用as给函数指定别名
格式：form 模块 import 函数名 as 别名
如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名

from pizza import make_pizza as mp

mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

4. 用as给模块指定别名
格式：import 模块 as 模块别名

import pizza as p

p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

5. (*)导入模块中所有函数
使用星号（*） 导入模块中所有函数

from pizza import *

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

import语句中的星号让python将模块pizza中的每个函数都复制到这个程序文件中

10.7 导入包

包是一个分层次的目录结构，它将一组功能相近的模块组织在一下

作用：
1、代码规范
2、避免模块名称冲突

包和目录的区别：

1、包含__init __.py文件的目录称为包
2、目录里通常不包含__init __.py文件

创建包：
1、创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字
2、在文件夹中创建一个__init__.py的模块文件，内容可以为空

导入包模块

import 包名.模块名

起别名：

import 包名 as 别名

from  包名 import 模块名
from 包名.模块名 import 函数名/变量名

例

>>> import sys   # 这里直接导入包
>>> sys.path.append('C:\\Users\\zdb\\Desktop')
>>> import M1.Temperature   # 导入包里面的模块
>>> M1.Temperature.c2f(32)  # 使用包.模块.函数
89.6

在这里插入图片描述

10.8 if name == ‘main ’

以主程序形式运行

def c2f(cel):
    fah = cel * 1.8 +32
    return fah

def f2c(fah):
    cel = (fah - 32)/1.8
    return cel

def test():             #多了这个
    print('测试：0摄氏度 = %.2f华氏度' % c2f(0))
    print('测试：0华氏度 = %.2f摄氏度' % f2c(0))

if __name__ == '__main__':   #多了这个
    test()