⼀、认识 Python

Python 是开发的⼀种新的脚本解释程序，是⼀种解释型语⾔，也称之为脚本语⾔。可以实现复杂，并且⼯作量⽐较⼤的数据输⼊。能够为开发或者测试节省很多的时间。
特点：
1） 明确，简单；⼊⻔容易，但是深⼊⽐较难；通过⼀些简单的代码，可以实现相关的功能；其语法简洁，表达能⼒强；
2） 他的代码量很⼩，维护的成本低编程效率⾼；他的代码量是 Java 的五分之⼀；
3） 是⼀种“半编译，半解释”型的语⾔，⼀⽅⾯，他的解释器会按⾏，读取源代码的⽂件，然后将源代码转化为供其解释器直接执⾏的“字节码”，然后再执⾏字节码；
4） 跨平台使⽤。python 是基于解释器来进⾏执⾏，只要某个操作系统或者平台上能运⾏，其解释器就可以运⾏ Python 的源代码主流的 Windows，Linux， M A C 等操作系统上都能够很好地⽀持 Python。
1、Python 解释器安装与环境变量部署
下载 Python，点击安装；双击下载好的 python ⽂件（不建议改路径，可是我改了）

验证是否配置成功：win+r 打开 cmd 命令⾏，输⼊命令”python”，如果有提示 python 版本，则表示配置成功。

2、认识 Pycharm
Pycharm 他是⼀款集成开发⼯具，主要就是写代码的，需要将其与 python.exe 关联起来，到时候在 pycharm ⾥⾯写的脚本需要⽤ python 这种编译器解释，因为电脑不认识你写的内容，中间有编译器进⾏翻译，这样电脑能理解。
相关使⽤和操作设置：

安装⽬录要⾃⼰记清楚，后⾯会⽤到，可以改，就是 Python ⼀般不改

装完，点击要不要重启

创建项⽬

⼆、Python 命令

1、变量、赋值、对象

1、 变量名只能包含字⺟、数字、下划线；不能以数字开头；⼤⼩写敏感
2、 变量名不能包含空格，但可以⽤_来分割其中的单词；
3、 不要将 Python 关键字和函数名作为变量名，变量名应简洁，并且“⻅名知意”。
4、 谨慎使⽤⼩写字⺟ l 和⼤写字⺟ O 因为他容易被看成数字 1 和 0。

1.1动态类型 type（变量名）

Python 中的变量不需要申明类型，在写的时候会⾃动区分开来。可以使⽤ type（变量名）来理解变量的类型。值的类型变化，其动态类型就跟着变化

注释掉：#或者 ctrl +/ (快捷选中多个注释，使其不起作⽤)

1.2增量赋值增量赋值：

两种简写⽅式（n*=10）（n+=2）

1.3Python 的对象：三要素（ID，类型，值）

⼀个变量在⼀个时刻只能有⼀个对象；但是⼀个对象可以拥有多个变量

2、Python 的输⼊与输出

2.1Python 的输出 print

可以单独打印，也可同时打印多个值输出

print 有⾃动换⾏功能，在末尾使⽤ end（）函数，可以⾃定义换⾏⽅式

2.2Python 的输⼊ input

在输⼊后，才会执⾏下⼀步操作

3、数据类型

3.1数字类型、整数 int 与⼩数 float/相互转化

1、 float 转化为 int；直接去⼩数点后的内容

2、 int 转化为 float：若为值整数，在后⾯加.0 ; 若值为⼩数，不变化

3、 int 转化为 str，看上去没有变化，但本质是做字符串使⽤

4、 bool 转化为 int

3.2布尔类型 True ,False

布尔类型中 True 与 False，⾸字⺟记得⼤写在运算中 True 当做 1,False 当做 0

3.3字符串类型

在 Python 中，我们⽤单引号（‘’），双引号（“”）,三引号（“‘’”）来表示字符串

引号使⽤的时候内外要配对，否则容易出错

3.3.1对字符切⽚处理[ ] / [ : ]

单切只取其中⼀个，从 0 开始取;

双切：取两个，依旧从 0 开始取，其取值规则为左闭右开[ );

从后往前取值：从 后⼀个开始取， 后从-1 开始；

全部都取、只取前⾯的全部、只取后⾯的全部

隔 1/2/3/4…,取⼀个值，正向从 0 开始取

倒着隔 1/2/3/4…,取⼀个值，倒着从 后的-1 开始取

先把数据倒过来，再正取某些值

3.3.2格式化字符串 %s 、 %d 、%f 或 f‘{}’

对字符串格式化 %s,对int格式化 %d

[root@Labatt python]# cat str.py 
name=input('please input your name ')
age=int(input('please input your age '))
print(name,'hello,my name is Andy.my gae is',age,'old')
print('%s hello.my name is Andy.my age is %d old'%(name,age))
[root@Labatt python]# python3 str.py 
please input your name Labatt
please input your age 18
Labatt hello,my name is Andy.my gae is 18 old
Labatt hello.my name is Andy.my age is 18 old

float格式化%.nf

[root@Labatt python]# python3 str2.py 
please input price: 18
today The price of meat 18.000000 per jin
today The price of meat 18.0 per jin
today The price of meat 18.00 per jin
today The price of meat 18.000 per jin
[root@Labatt python]# cat str2.py 
price=float(input("please input price: "))
print('today The price of meat %f per jin'%(price))
print('today The price of meat %.1f per jin'%(price))
print('today The price of meat %.2f per jin'%(price))
print('today The price of meat %.3f per jin'%(price))

格式化的另一种表达f’{}’

[root@Labatt python]# python3 str3.py 
please input your name Labatt
please input your age 18
please input price: 15
Labatt hello,my name is Andy,my old is 18,tody gift is 15.00
Labatthello,my name is Andy,my old is 18,tody gift is 15.0
[root@Labatt python]# cat str3.py 
name=input('please input your name ')
age=int(input('please input your age '))
price=float(input('please input price: '))
print('%s hello,my name is Andy,my old is %d,tody gift is %.2f'%(name,age,price))
print(f'{name}hello,my name is Andy,my old is {age},tody gift is {price}')

3.3.3转义字符串\t 、\n 、\、 r

对⻬表格各列\t ;⼀个\t 占位两个字符
换行字符 \n
“” “\”
原始字符 r

[root@Labatt python]# cat str4.py 
print("Labatt\t\t18\t\t12324325\t\thunan")
print("Labatt的\t18\t\t12324325\t\thunan")
print("hello\nmy name is Labatt\nwelcome to hunan")
print("hellomy name is Labatt\\welcome to hunan")
print(r"hello\nmy name is Labatt\nwelcome to hunan")
[root@Labatt python]# python3 str4.py 
Labatt          18              12324325                hunan
Labatt的        18              12324325                hunan
hello
my name is Labatt
welcome to hunan
hellomy name is Labatt\welcome to hunan
hello\nmy name is Labatt\nwelcome to hunan

3.3.4串常⽤操作+、*、startswith 、endswith 、find、 replace、 isalpha、 isdidit、 count

字符串的拼接
字符串的重复*
字符串的开头和结尾startswitch/endswitch,结果返回true、false
去除开头和结尾 strip
查找 find,返回值为下⻆标的值，若没有找到返回值为-1 下⻆标从 0 开始
计算数量 count

[root@Labatt python]# cat str5.py 
#字符串的拼接
name='Labatt'
word='hello'
print(name+word)
#字符串的重复
name='8'
print(name*10)
##字符串的开头和结尾startswitch/endswitch
sentance='I love you'
print(sentance.startswith('I'))
print(sentance.endswith('I'))
##去除开头和结尾 strip
sentance=' I love you '
print(sentance)
print(sentance.strip())
##查找find，返回值为下标的值，若没找到返回值为-1.下标值从0开始
sentance='I love you,you love me,mixue icecream delicious'
print(sentance.find('you'[2]))
print(sentance.find('lo'))
#替换replace
sentance='I love you,you love me,mixue icecream delicious'
print(sentance.replace('I','liming'))
print(sentance.replace('you','mary'))
print(sentance.replace('you','mary',1))
#纯字母与纯数字：isalpha/isdigit,返回结果为true或者false
sentance='I love you,you love me,mixue icecream delicious'
print(sentance.isalpha())
num='25'
print(num.isdigit())
num=int(input('please input numbers: '))
print(f'你需要支付{num*10}')
#计算数量count
sentance='I love you,you love me,mixue icecream delicious'
print(sentance.count('you'))
[root@Labatt python]# python3 str5.py 
Labatthello
8888888888
True
False
 I love you 
I love you
9
2
liming love you,you love me,mixue icecream delicious
I love mary,mary love me,mixue icecream delicious
I love mary,you love me,mixue icecream delicious
False
True
please input numbers: 5
你需要支付50
2

3.4 列表与元组

3.4.1列表list[ ]

[root@Labatt python]# cat list.py 
list_1=[1,2,3,4,5]
list_2=[1]
list_3=[1,]
print(type(list_1))
print(type(list_2))
print(type(list_3))
##列表里套元组
list_4=[1,(2,3),4,5]
print(type(list_4))
##对列表可以切片，从子集0开始，左闭右开，可以计算列表的长度len
list_4=[1,(2,3),4,5]
print(list_4[1])
print(list_4[0:2])
print(len(list_4))
[root@Labatt python]# python3 list.py 
<class 'list'>
<class 'list'>
<class 'list'>
<class 'list'>
(2, 3)
[1, (2, 3)]
4

3.4.2元组tuple（）

在单个元素为元组时候，后⾯要跟⼀个‘，’逗号，列表不⽤；⾥⾯也可以嵌套列表

3.4.3列表的增、删、改、查；append、insert、remove、del

对列表增加元素，在 后增加 append；在某位置增加 insert（1，内容）

tuple_1=(1,'36','mary',[4,5])
tuple_2=(1)
tuple_3=(1,)
print(type(tuple_1))
print(type(tuple_2))
print(type(tuple_3))
[root@Labatt python]# python3 tuple.py 
<class 'tuple'>
<class 'int'>
<class 'tuple'>

对列表修改元素
对列表删除元素remove、del
Remove ⼀次只能从前到后，删除⼀个；删除的是指
del按照下标删除，一次可以删除多个

[root@Labatt python]# cat tuple.py 
tuple_1=(1,'36','mary',[4,5])
tuple_2=(1)
tuple_3=(1,)
print(type(tuple_1))
print(type(tuple_2))
print(type(tuple_3))
[root@Labatt python]# python3 tuple.py 
<class 'tuple'>
<class 'int'>
<class 'tuple'>
[root@Labatt python]# cat tuple.py 
tuple_1=(1,'36','mary',[4,5])
tuple_2=(1)
tuple_3=(1,)
print(type(tuple_1))
print(type(tuple_2))
print(type(tuple_3))
#对列表修改元素
list_1=[1,'36','mary',(4,5)]
list_1.append([99,'yun'])
print(list_1)
list_2=[1,'36','mary',(4,5)]
list_2.remove('mary')
print(list_2)
del(list_1[0:2])
print(list_1)
[root@Labatt python]# python3 tuple.py 
<class 'tuple'>
<class 'int'>
<class 'tuple'>
[1, '36', 'mary', (4, 5), [99, 'yun']]
[1, '36', (4, 5)]
['mary', (4, 5), [99, 'yun']]

3.4.4 列表字符串与字符串拼接join、split

Join 就是把⼏个分隔开的字符串连在⼀起

split 就是把⼀个整合的字符串，按照⼀个符号，或者字⺟数字分隔开，隔成⼏个，形成列表字符串。

3.4.5 split 和冒泡的合并⽤法，map 将list 列表内容从str 转化为int

与map功能一致，map将list列表内容从str转化为init

3.5深浅拷⻉

总结
浅copy

元素 ID，不跟着源列表 ID 变化；
内部可变⼦集元素变化，其⼦集 ID 会跟着源列表变。

深拷⻉

列表 ID，不跟着源列表 ID 变化；元素 ID，不跟着源列表 ID 变化；
内部可变⼦集元素变化，不跟着源列表 ID 变化；赋值： 列表 ID，跟着源列表 ID 变化；元素 ID，跟着源列表 ID 变化；

赋值

列表 ID，跟着源列表 ID 变化；元素 ID，跟着源列表 ID 变化；
内部可变⼦集元素变化，跟着源列表 ID 变化；

3.6字典

{ ：} 什么可以做 key：不可变类型（int、float、str、bool、元组）

3.6.1字典的定义，key 不可以重复，值可以重复

3.6.2 新增或者修改value

3.6.3 删除字典del、pop、clear

直接删除del

删除后引⽤删除的值 pop

3.6.4 拿到key的值

3.6.5 打印字典的所有key、value、items

3.7集合 set{}

集合自动去重

3.7.1 添加元素add、更新插入元素update、删除remove

3.7.2集合的交互，取集合的值（-）、（& ）、（| ）、（^）

s_a={1,3,5,7}
s_b={1,3,8,9}
s1=s_a-s_b
s2=s_a&s_b
s3=s_a|s_b
s4=s_a^s_b
print(s1,s2,s3,s4)
####output###
{5, 7} {1, 3} {1, 3, 5, 7, 8, 9} {5, 7, 8, 9}

4、操作符

4.1 操作符+、-、*、/

print(1+2,8-4,8*4,8/4)

3 4 32 2.0

4.2操作符的取余%，取余数

print(8%2,3%2)

0 1

4.3操作符的地板除//，向下（⼩）取整

print(5/2,5//2,-5//2)

2.5 2 -3

4.4操作符的乘⽅**

4.5操作符的累加+=、累乘*=

5、比较运算符

5.1⽐较运算符

、>=、 <、 <=、 ==等于、！=不等于、结果返回的是布尔值；

5.2 字符串的大小比较

0<9<A<Z<a<z

6、逻辑运算符 and、or、not

6.1and，两个都为 True 才为 True，其他都为 false

6.2or,两个都为 False 才为 False，其他都为 True

6.3not 否定

6.4 当 and，or，not 联合⽤时，运算优先级 not>and>or

7 if语句

如果表达式的值⾮（0，‘’，[ ],( ),{ },false）;则执⾏下⼀句

7.1If、elif、else 的联⽤

7.2多个 if 的嵌套使⽤（多条件情况），其中运算按缩进对⻬原则进⾏

8、while循环

如果表达式的值⾮（0，‘’，[ ]，( )，{ }，false）;则执⾏循环；循环内部必须是有限的，不能是死循环。

⼀般按照条件进⾏循环，把 while 改成可变的，循环只在内部进⾏，⼀般是⽤于错误输⼊，触发循环，引导正确输⼊；或多次使⽤循环。

9、for 循环

⾸先要给出可循环对象（变量），如字符串，列表，元组，集合，字典

9.1字典的循环（键、值、条款）

10、常用内置函数

10.1 长度len

10.2范围 range,左闭右开

10.3绝对值 abs

10.4取值商和余数 divmod

10.5 值的互换a,b=b,a

10.6四舍五⼊ round（偶尔会触发精度损失）

10.7 break

10.8跳过本次循环 continue

10.9通过 pass，占位函数(if 后⾯必须跟东⻄)

11、条件表达式

11.1把 x/y 中最⼩的赋值给 z

11.2 生成列表

12、自定义函数

⼀些可以被重复使⽤的代码，可以提取出啦放到函数中，Python 使⽤ def 来定义⼀个函数，使⽤ return 来返回结果（如果返回的结果你不⽤就不⽤写 return）。

12.1形参与实参数

若只想拿到其中一个值，不想输出5，采用如下方式

12.2重命名函数（函数名相同，最后调⽤，只保留后⼀个）

12.3默认参数（可以不用传实参数）

12.4解包，有多个返回结果取值

12.5不定⻓参数*，**

默认给了*，就不能给默认值，在形参前⾯加*，能打印出多个实参，输出结果为元组形式。

第二个值必须指定给参数

给**就意味着要⽤键值的形式输⼊实参数，注意在输⼊实参时，key 不能是数字，key 也不能给引号。

字典使用的for循环


注 在informs这个字典中，健为k的值

* 与** 的并⽤，但是第⼀个实参要写就要写完

13、类-作为函数的总和——class 定义⼀个类

在类⾥⾯写函数也是 def，但是函数⾥⾯必须加⼀个 self

class cd():
    def select_shop(self):
        shops=['hunan','guangzhou','guangxi']
        shop=input(f'this is my shop{shops}please select a shop: ')
        print(f'select {shop} shop')
Labatt=cd()
Labatt.select_shop()
###output###
this is my shop['hunan', 'guangzhou', 'guangxi']please select a shop: hunan
select hunan shop

调⽤函数时，要把类等于调⽤，然后再选择类⾥⾯的函数，进⾏调⽤

13.1类⾥⾯ Self 的⽤法

定义域问题：在⼀个函数⾥⾯的⼀个变量，出了函数内部，就不起作⽤了，必须调⽤才能⽤，在类⾥⾯也会出现这个情况，所以要⽤ self，就相当于⼤家共⽤的，其他函数也能⽤

class cd():
    def select_shop(self):
        shops=['hunan','guangzhou','guangxi']
        self.shop=input(f'this is my shop{shops}please select a shop: ')
        print(f'select {self.shop} shop')
    def select_foods(self):
        food_oder={'hunan':{'maodu':'12','chuanchuan':'13'},
                   'guangzhou':{'tang':'15','de':'16'},
                   'guangxi':{'zhu': '17', 'lan': '18'}}
        food=input(f'select {food_oder[self.shop]}')
        print(f'select {food_oder[self.shop]}')
Labatt=cd()#类就是一个模板
Labatt.select_shop()#实例化
Labatt.select_foods()
#####output#####
this is my shop['hunan', 'guangzhou', 'guangxi']please select a shop: hunan
select hunan shop
select {'maodu': '12', 'chuanchuan': '13'}
select {'maodu': '12', 'chuanchuan': '13'}

13.2类中init的用法

⽤来给类，在实例化过程中传递参数⽤的，给类传参数，在实例化类的时候可以直接调⽤

class cd():
   def __init__(self,people_num): #这个类型的函数，在实例化类的时候必须传参
       self.p_num=people_num #在第一步就要使用的时候就写上
   def select_shop(self):
       shops=['hunan','guangzhou','guangxi']
       self.shop=input(f'this is my shop{shops}please select a shop: ')
       print(f'select {self.shop} shop')
   def select_foods(self):
       food_oder={'hunan':{'maodu':'12','chuanchuan':'13'},
                  'guangzhou':{'tang':'15','de':'16'},
                  'guangxi':{'zhu': '17', 'lan': '18'}}
       food=input(f'select {food_oder[self.shop]}')
       # print(f'select {food_oder[self.shop]}')
       print(f'select {food}')
       print(self.p_num)
Labatt=cd(3)#类就是一个模板
Labatt.select_shop()#实例化
Labatt.select_foods()

再次调⽤

class cd():
    def __init__(self,people_num): #这个类型的函数，在实例化类的时候必须传参
        self.p_num=people_num #在第一步就要使用的时候就写上
    def select_shop(self):
        shops=['hunan','guangzhou','guangxi']
        self.shop=input(f'this is my shop{shops}please select a shop: ')
        print(f'select {self.shop} shop')
    def select_foods(self):
        self.food_order={'hunan':{'maodu':'12','chuanchuan':'13'},
                   'guangzhou':{'tang':'15','de':'16'},
                   'guangxi':{'zhu': '17', 'lan': '18'}}
        self.food=input(f'select {self.food_order[self.shop]}')
        # print(f'select {food_oder[self.shop]}')
        print(f'select {self.food}')
        print(self.p_num)
    def show_total_price(self):
        print('price is: ',self.food_order[self.shop][self.food])
Labatt=cd(3)#类就是一个模板
Labatt.select_shop()#实例化
Labatt.select_foods()
Labatt.show_total_price()
Labatt.show_total_price()
###output###
this is my shop['hunan', 'guangzhou', 'guangxi']please select a shop: hunan
select hunan shop
select {'maodu': '12', 'chuanchuan': '13'}maodu
select maodu
3
price is:  12
price is:  12

同等效果

只拿到菜名

class cd():
    def __init__(self,people_num): #这个类型的函数，在实例化类的时候必须传参
        self.p_num=people_num #在第一步就要使用的时候就写上
    def select_shop(self):
        shops=['hunan','guangzhou','guangxi']
        self.shop=input(f'this is my shop{shops}please select a shop: ')
        print(f'select {self.shop} shop')
    def select_foods(self):
        self.food_order={'hunan':{'maodu':'12','chuanchuan':'13'},
                   'guangzhou':{'tang':'15','de':'16'},
                   'guangxi':{'zhu': '17', 'lan': '18'}}
        self.food=input(f'menu: {list(self.food_order[self.shop].keys())}')
        # print(f'select {food_oder[self.shop]}')
        print(f'select {self.food}')
        print(self.p_num)
    def show_total_price(self):
        print('price is: ',self.food_order[self.shop][self.food])
Labatt=cd(3)#类就是一个模板
Labatt.select_shop()#实例化
Labatt.select_foods()
Labatt.show_total_price()
Labatt.show_total_price()
###output###
this is my shop['hunan', 'guangzhou', 'guangxi']please select a shop: guangzhou
select guangzhou shop
menu: ['tang', 'de']tang
select tang
3
price is:  15
price is:  15

选择多个菜计算

class cd():
    def __init__(self,people_num): #这个类型的函数，在实例化类的时候必须传参
        self.p_num=people_num #在第一步就要使用的时候就写上
    def select_shop(self):
        shops=['hunan','guangzhou','guangxi']
        self.shop=input(f'this is my shop{shops}please select a shop: ')
        print(f'select {self.shop} shop')
    def select_foods(self):
        self.food_order={'hunan':{'maodu':'12','chuanchuan':'13'},
                   'guangzhou':{'tang':'15','de':'16'},
                   'guangxi':{'zhu': '17', 'lan': '18'}}
        self.foods=input(f'menu: {list(self.food_order[self.shop].keys())},please select: ').split(',')
        # print(f'select {food_oder[self.shop]}')
        print(f'select {self.foods}')
        print(self.p_num)
    def show_total_price(self):
      for food in self.foods:
        print(f'{food}price is: ',self.food_order[self.shop][food])
Labatt=cd(3)#类就是一个模板
Labatt.select_shop()#实例化
Labatt.select_foods()
Labatt.show_total_price()
###output###
this is my shop['hunan', 'guangzhou', 'guangxi']please select a shop: hunan
select hunan shop
menu: ['maodu', 'chuanchuan'],please select: maodu,chuanchuan
select ['maodu', 'chuanchuan']
3
maoduprice is:  12
chuanchuanprice is:  13

显示总价格

13.2类的继承的⽤法

⼦类在继承⽗类时，⽗类的函数都能够使⽤，但是⽗类在 init 要传参数，你也必须传参数

14读写文件

先建⼀个普通⽂件

14.1 文件的读

14.1.1 打开文件

14.1.2read ⽂件的读-r

14.1.3 readline readlines

Readlines 读出来的是⼀个列表，每次读完关了，就能保证不断开

14.2⽂件的写—w

14.2.1覆盖写“w”

14.2 追加写"a"

追加写的with语句


覆盖写的with语句

14.3⽂件的读写运⽤

14.3.1在点餐系统⾥⾯造⼀些⼤量的数据通过 Python 实现，写⼀些 SQL 数据就⼀个⼀个改很慢，所通过以下⽅式

把复制好的语句放在下⾯的引号⾥⾯，注意改好格式

复制好的 SQL 语句中，要保证主键还有关联键是唯⼀的，在这⾥ leimu_type 和 food_id 需是唯⼀

打开数据库，右击选择运⾏ SQL ⽂件

复制好的语句放在下面的引号里面，主意好格式

复制好的 SQL 语句中，要保证主键还有关联键是唯⼀的，在这⾥ leimu_type 和 food_id 需是唯⼀


把类目id改成8888

把类目type改成9999

然后写SQL语句



复制路径

打开数据库，右击选择运⾏ SQL ⽂件




刷新数据库

删除脏数据 以上面实例为模板

14.3.2在点餐系统⾥⾯删除造的数据

生成的t6里面放的delete语句

运行

去这⾥⾯运⾏写好的 t6 删除语句，然后就没有

15、Python 的处理异常（⼀些报错）

15.1 语法错误

语法异常⼀旦出现，所有的 print 都不会打印，就不会继续执⾏

15.2普通异常

这种只在对应⾏报错，报了在这之前的其他⾏依旧⾏正常打印，在这之后的就不执⾏了（半编译编执⾏）

15.3偶现异常

时⽽好的，时⽽有问题，就⽐如等待时间这种，这会导致进程的停滞

15.4 try、except的跳过异常方法或者修复

这就跳过了

打印错误

报错时，另外的处理方法

16、模块——moudle

⽂件代码的集合，在 Python ⽂件中，.py ⽂件就是模块；模块就是类或 py ⽂件的集合会按照不同的模块建⽴多个不同的部分导⼊某个模块，这个模块就会被运⾏⼀遍（导⼊意味着被执⾏）

16.1导⼊模块 import 模块名，⽤模块的全部⽅法

16.2使⽤模块⾥⾯的函数，就⽤模块名.⽅法（参数）

16.3使⽤模块⾥⾯的类，以及⾥⾯的函数，先实例化类，再实例化类名.函数

16.4导⼊模块中某个⽅法 from 模块名 import ⽅法名，就只能使⽤这个⽅法

使用的时候，直接用函数名
导入方法

16.5给模块起⼀个别名 as 别名

16.6 导入全部的东西 import

16.7 私有的怎么导入

16.8 如何⽤别⼈的某函数，⼜不执⾏全部模块的内容_main__（脚本的执⾏⼊⼝）当导⼊意味着被执⾏时，test1 是我写的，我要⽤ test2 别⼈写的冒泡，怎么解决利⽤ Python ⾃带的变量

main__意味着是这个模块⾥⾯的主程序
在⾃⼰模块⾥⾯，打印__name_;输出结果就是__main__;是字符串
⽽引⽤的其他模块⾥⾯有__name__;在⾃⼰模块⾥⾯打印出来的就是模块的名字，以及对应模块打印出的函数值

在⾃⼰的模块⾥⾯，把要执⾏的统⼀写到后⾯，写⼀个 if 语句，这样别⼈调⽤就单纯使⽤⾥
⾯的⽅法，不会打印别⼈模块的值：
如果__name__打印出来的结果为__main__,那么就打印我⾃⼰需要打印的东⻄ 否则其他的模块⾥⾯__name__打印出来的结果为模块名，就不打印了

17、包，就是⼀个⽂件夹，⾃动⽣成⼀个__init__意义

⾥⾯会⾃动⽣成⼀个__init__,当要导⼊这个包时，Python 就会去找__init__,从⽽找到这个包，否则找不到，导入就要叠加

想要初始化一些操作，就可以在init里面写内容