Python入门笔记(四)

文章目录

第九章集合set
- 9.1 创建集合：set()、集合生成式
- 9.2 集合性质
- 9.3 一些函数：issubset()、issuperset()、isdisjoint()
- 9.4 集合增加元素：add()、update()
- 9.5 集合删除元素：remove()、discard()、pop()、clear()
- 9.6 创建不能修改元素的集合：frozenset()
第十章函数
- 10.1 函数定义：def
- 10.2 闭包
- 10.3 函数变量的作用域：局部、全局（global、nonlocal）
- 10.4 实参和形参
- 10.5 return返回值
- 10.6 导入模块，函数的几种方法
- 10.7 导入包
- 10.8 if __name __ == '__main __'

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

本文电子版获取方式：
「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):    #闭包,引用了外层函数的参数xreturn x*yreturn FunYi = FunX(8)       #x=8
print(i)
print(type(i))
print(i(5))     #y=5print(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 = 5def Fun2():x *= x         #x未知return xreturn 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 * ratereturn 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=10print(count)MyFun()
print(count)

10
10

nonlocal：定义非局部变量

def Fun1():x = 5def Fun2():nonlocal x    #定义x为非局部变量x *= x        #5*5return x      #25return 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_namereturn 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将没空字符串解读为Truefull_name = first_name + " " + middle_name + " " + last_nameelse:full_name = first_name + " " + last_namereturn 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 = 0for n in numbers:sum = sum + n * nreturn sumprint(calc([1, 2, 3]))
print(calc((1, 2, 5, 7)))

14
79

例4

def calc(*numbers):sum = 0for n in numbers:sum = sum + n * nprint(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 = {}                      # 空字典profileprofile['姓'] = first     # 键first name；   值firstprofile['名'] = last       # 键last name：    值lastfor 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):passdef fun6(*args1, **args2):passdef 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_namereturn 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 personname = 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 personname = 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_namereturn full_name.title()active = True
while active:print("请告诉我你的名字:")f_name = input("First name:")     # 输入的First anme 赋值给f_namel_name = input("Last name:")      # 输入的Last name  赋值给l_namename = 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 = 0for n in args:ax = ax + nreturn ax

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

def lazy_sum(*args):def sum():ax = 0for n in args:ax = ax + nreturn axreturn 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:
- pepperoniMaking 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_pizzamake_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

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

from pizza import make_pizza as mpmp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')

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

import pizza as pp.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 +32return fahdef f2c(fah):cel = (fah - 32)/1.8return celdef test():             #多了这个print('测试：0摄氏度 = %.2f华氏度' % c2f(0))print('测试：0华氏度 = %.2f摄氏度' % f2c(0))if __name__ == '__main__':   #多了这个test()