文章目录
- 第九章 集合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): #闭包,引用了外层函数的参数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())
25
例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())
25
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)
5
0
14
14
个数可变的关键字参数：**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()
