Python入门到高手进阶|这一篇就够了（3万字|超详细）

🙈作者简介：练习时长两年半的Java up主
🙉个人主页：程序员老茶
🙊 ps:点赞👍是免费的，却可以让写博客的作者开兴好久好久😎
📚系列专栏：Java全栈，计算机系列（火速更新中）
💭 格言：种一棵树最好的时间是十年前，其次是现在
🏡动动小手，点个关注不迷路，感谢宝子们一键三连

课程名：Python

内容/作用：知识点/设计/实验/作业/练习

学习：Python入门知识

课程：python

一、python介绍

1、基本介绍

​ 吉多范罗苏姆----荷兰科学家
ABC语言：
​ 优点：
​ 语言简洁、代码量少（C语言的1/4）、专为程序员设计等
​ 缺点：
​ 不开放
​
1989年 圣诞节 python（由来）
Python语言：
​ 优点：
​ 语言简洁、代码量少（C语言的1/4），开放等

2、python的执行方式

（1）非交互式解释器（python2.x python3.x）
在python的终端运行Python文件
$ python python文件
$ python3 python文件
（2）交互式解释器—ipython
用户编写一行代码，机器识别一行代码
（3）集成开发环境—IDE
继承了用户所需要的环境与软件

二、环境的安装

1、解释器

​ 将用户编写的代码解释成二进制语言，便于机器识别（机器能读懂的语言）
流程：
​ 用户编写python代码-------解释器解释Python代码-------操作系统------cpu执行

2、环境的安装

​ 集成开发环境—Pycharm

三、版本的介绍

1、python2.x版本：

08年以前是python2.x版本，08年以后python3.x版本，python2.7和python2.8版本（向上兼容）
python2.x版本：

（1）保留了cmp函数

​ 用于两个对象进行比较
cmp（a,b） #如果a>b，返回为1，a<b，返回-1，a=b，返回为0

（2）True、False是全局变量

True=10
False=“hello”

（3）python2版本默认是ASCII编码

a=50
b=“hello”
中国=“hello” #不支持

（4）print是作为一条语句，进行输出（打印）

print “hello” #控制台输出字符串hello
print（“hello”） #不支持
（5）保留了不等于符号：!=、<>
2!=3
3<>3
…

2、python3.x版本：

（1）增加了operator模块

lt（a,b）函数： less than，小于，如果a<b，返回为真，否则返回假
le（a,b）函数： less equal ，小于等于，如果a<=b，返回为真，否则返回为假
eq（a,b）函数：equal，等于，如果a=b，返回为真，否则返回为假
gt（a,b）函数：greater than ，大于，如果a>b，返回为真，否则返回为假
ge（a,b）函数：greater equal ，大于等于，如果a>=b，返回真，否则返回为假

（2）True、False是关键字

True=“world” #报错
False=50 #报错

（3）python3解释器是UTF-8编码

a=“hello”
中国=“hello”

（4）print作为一个函数，进行输出（打印）

print（“hello world”） #输出hello world
print “hello " #不支持

（5）保留了不等于符号：!=，舍弃了<>

2!=3
2<>3 #不支持
…
#win+r------cmd-----python（进入到Python的解释器）

四、python的优缺点

优点：

1、python作为一种面向对象的一门语言
2、python社区集成了很多模块，数据库、tcp/ip、UDP、图像处理、文本处理等等
3、语言简洁优美
4、易扩展性
5、易学习

缺点（特点）：

1、单行语句（没有分号“；”）
2、执行速度慢
3、强制缩进（没有大括号“{}”）

五、第一个python程序

​ print（“hello world”） #this is first python code

1、print（）

​ 将print函数里的带的实参输出到控制台，输出

2、print函数带的参数

​ 参数是Python支持的数据类型（int、str、list、tuple、float等等）
例如：
​ print（50）#输出50
​ print（“hello world”）
​ print（12.356）
​ print（num） #报错

3、注释

（1）行注释

​ 意思就是注释单行代码，其他行代码没有注释（将#后面的内容全部注释，其他行没有注释）
符号：#
例如：

	#  hello world

（2）块注释

​ 块注释是注释多行代码
符号：三个双引号"""或者是三个单引号
例如：

"""
print("hello world") #this is first python code
print("你好世界")
"""
'''
print("hello world") #this is first python code
print("你好世界")
'''

六、标识符

​ 标识符一般是作为变量来使用
1、标识符由字母、数字、下划线组成
2、标识符不能是关键字（避免使用关键字）
3、标识符不能是以数字开头
例如：
​ _hello、5hjl（错误）、@hj5（错误）、shfiosfho、dgd5awe、￥sfsg（错误）、ssg#949（错误）

七、关键字

​ 关键字是python内部保留的一些字符，特定场景使用的字符
关键字如下：
​ 查询关键字的方式：win+r----cmd----python—help（）----keywords
​ 查询关键字详细介绍的方式：win+r----cmd----python—help（）----keywords------break
离开帮助：
​ help>quit

八、变量

​ 变量的实质就是标识符，变量的内容是可变的
例如：
​ num、sum、shifhi、ncsfweg等等
注意：
​ 变量不能独立存在

1、整型：int

例如：
50、15、45、-15、-40等等
整型数据的存储：

格式：
	标识符 =  整型值
例如：
	num=50
	num=40

2、字符串类型：str

​ 用双引号或者是单引号括起来的字符，称之为字符串，严格来说称之为字符序列
例如：
​ “hello” ‘hello’ “1245” ‘你好，世界’ ‘a’ 等等
字符串的存储：

格式：
​	标识符=字符串值
例如：
​	num="hello"
​	num='a'

后面会讲：字符串的复制、拼接、截取或切片等等

3、浮点型：float

​ 浮点型在数学中就是小数
例如：
​ 1.2 1.355 1.4646 5.15
浮点型的存储：

格式：
​	标识符=浮点型值
例如：
​	num=1.56
​	num=4.564

4、bool类型

关键字：True（真）、False（假）
一般用于条件判断或者是循环条件判断

5、列表、元组、词典（字典）

6、全局变量与局部变量

（1）全局变量

​ 存在于函数体外部的变量，称之为全局变量，那么对于整个py文件都是可见的，没有任何的作用域的限制；注意，在函数体内部更新全局变量的值需要有关键字global来声明
global：针对局部去修改全局变量的值

（2）局部变量

​ 存在于函数体内部的变量，称之为局部变量，局部变量只对函数体内有效（它的生命周期只存在于函数体内）；注意，在函数体内部的函数体内部更新第一个函数体变量的值需要有关键字nonlocal来声明
nonlocal：针对局部的局部去修改局部变量的值

7、工厂函数

​ 工厂函数实质就是：类型转换（相当于c语言中强制类型转换）类似于与工厂生产产品一样

（1）int(对象，基数)

​ 参数：一定要是数字类型或者数字字符串类型，如20，“20”，
​ 基数：可有可无，如果没有该基数，默认是十进制，如
​ 例如：
​

	int("20") #将字符串“20”转换为整型的20
	int("20",8)#20是八进制形式的，通过int转换整形（十进制）

（2）type（对象）

​ 该函数时查看参数的数据类型
​ 例如：​

	num=int("20")
	print(type(num))

（3）str（对象）

​ 该函数就是将对象转换为字符类型进行输出
​ 例如：​

	num=20
	str(num) #将整形的num转换为字符类型进行输出
	num=15.6
	str(num) #将浮点型的num转换为字符类型进行输出

（4）float（对象）

​ 该函数就是将对象转换为浮点型进输出
​ 例如：
​

	num=50
	print(float(num))

（5）list(对象)

​ 该函数就是将对象转换为列表类型进行输出，注意，对象是序列

（6）tuple(对象)

​ 该函数将对象转换为元组类型进行输出，注意，对象是序列

（7）dict（对象）

​ 该函数将对象转换为字典类型进行输出

（8）set（对象）

​ 该函数将对象转换为无序不重复的元素集，注意，对象是序列
​ 例如：
​

	num="hello"
	counter="world"
	x=set(num) #将"hello"生存无序不重复的集合存入到x中
	y=set(counter) #将"world"生存无序不重复的集合存入到y中

符号：&
该符号是求两个集合的交集
格式：

集合1 & 集合2

​ 例如：
​

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x & y
	print(z)

符号：|
该符号是求两个集合的并集
格式：

集合1 | 集合2

​ 例如：
​

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x | y
	print(z)

符号：-（减号）
该符号是求两个集合的差集
包含集合x中的元素，但不包含集合y中的元素
格式：

集合1 - 集合2

​ 例如：

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x - y
	print(z)

符号：^
该符号是求两个集合的补集
包含集合x和集合y中的非共同元素
格式：

集合1 ^ 集合2

例如：

	num="hello"
	counter="world"
	x=set(num) 
	y=set(counter)
	z=x ^ y
	print(z)

九、print函数与input函数

1、print函数

​ 该函数的作用将print所带的参数输出到控制台
​ print带的参数;
​ 参数是python所支持的数据类型（int,str,float,list,tuple,ste,dict等）

（1）使用print函数直接进行输出

​ 例如：

    num=50
    print（num）
    print（50）
    num=“hello”
    print（num） #直接进行输出
    print（"hello"）

​ 注意：
​ 使用直接进行输出的方式可以连续输出多个数据
​ 格式：

print（数据1，数据2，...........）  #数据可以是具体的数据，也可以是变量（注：变量一定要提前赋初始值）

​ 例如：

	print（50，“hello”）
    num=45
    counter="hello world"
    print（num , counter）

（2）使用%格式化进行输出

​ 格式：

	print（“%格式控制符”%标识符） #注：标识符就是变量
	print（“%格式控制符1   ，%格式控制符2 ，........ ” %(标识符1 ， 标识符2 ，............)）

​ 格式控制符：
​ d（整形）、o（八进制）、x（十六进制）、f（浮点型）、s（字符串型）等等
​ 注意：
​ a、print函数里一个格式控制符前必须要有一个%
​ b、%格式控制符与后面的标识符是一一对应
​ c、print函数里的双引号后面没有逗号
​ d、格式控制符要与%结合使用
​ e、标识符与标识符之间使用逗号隔开，并且逗号是英文格式
​ 例如：

	num=52
    num2=20
    counter="hello world"
    print（“%d ， %d”%(num,num2)）
    print（“num=%d，counter=%s”%(num,counter)）
	>>d（整形，十进制）

​ 例如：

	num=34
	print（“num=%d”%num） #输出num=34

格式：

print（“{0}  ,  {1}  ，...........”.format（标识符1，标识符2，............））

例如：

	num=10
	counter=20
	print（“num={0} , counter={1} ”.format（num,counter））

（6）format高级用法

左对齐输出x位
格式：

{ ： <  x}   #如果没有x，那么输出就直接是左对齐，如果有x，控制输出左对齐为x位，不足的补空格
print（“{：< x}”.format（标识符））

例如：

num="hello"
print（“{：< 10}”.format（num）） #输出左对齐为10位，不足的补空格

右对齐输出x位
格式：

{：>  x}   #如果没有x，那么输出就直接是右对齐，如果有x，控制输出右对齐为x位，不足的补空格
print（“{：> x}”.format（标识符））

例如：

num="hello"
print（“{：> 10}”.format（num）） #输出右对齐为10位，不足的补空格	

中央对齐输出x位
格式：

{：^ x}   #中央对齐输出x位
print（“{：^ x}”.format（标识符））

例如：

num="hello"
print（“{：^ 10}”.format（num）） #输出中央对齐为10位，不足的补空格

输出十进制
格式：

{：d}   
print（“{：d}”.format（标识符））  #将标识符以10进制形式输出

例如：

num=50
print（“{：d}”.format（num））

输出八进制
格式：

{：o}   
print（“{：o}”.format（标识符））  #将标识符以八进制形式输出

例如：

num=50
print（“{：o}”.format（num））

输出十六进制
格式：

{：x}   
print（“{：x}”.format（标识符））  #将标识符以十六进制形式输出

例如：

num=50
print（“{：x}”.format（num））
输出浮点型数据

格式1：

{：. x f}  #控制数据输出小数点后x位	
print（“{：.x f}”.format（标识符））

例如：

num=3.1415926
print（“{：.2 f}”.format（num））

格式2：

{：x.yf}  #控制数据输出x位，并且保留小数点后y位 ，不足的补空格，默认右对齐
	print（“{：x.y f}”.format（标识符））

例如：

	num=3.1415926
	print（“{：10.2 f}”.format（num））
	print（“{：<10.2 f}”.format（num））

（7）带关键字format格式进行输出

格式：

print（“{a} ,  {b} ，...........”.format（a=初始值 ， b=初始值，............）） #a和b就是关键字

例如：

print（“num={num}  , counter={counter}”.format（num=50 , counter="hello world"））

2、input函数

​ 该函数用于从控制台获取用户输入的内容，并存入到内存中
格式：
​

input（字符串） 
或
input（）

注意：
a、input函数带的参数字符串可有可无，该字符串的作用仅仅只是提示，并且会在控制台输出该字符串
b、使用input函数获取的用户的输入的内容，就自动转换为字符串类型

十、运算符

1、基本运算符

（1）赋值运算符：=

格式：

标识符（变量）=初始值

使用：
将初始值存入到标识符（变量）里
例如：

	num=50
	counter="hello"
	.............

（2）乘法运算符：*

格式：
对象1 * 对象2
使用：
如果对象1和对象2都是数字，那么符号“”就表示对象1乘以对象2；如果对象1是字符串序列，对象2是整形的数字，那么符号“”就表示将对象1复制对象2次（参考字符串）
例如：

	num=50
	counter=15
	num * counter  #计算num和counter的乘积

（3）除法运算符：/

格式：

对象1 / 对象2

使用：
如果对象1和对象2都是数字，那么符号“/”就表示对象1除以对象2，注，与C语言的符号“/”要区分开
例如：

	num=50
	counter=15
	num / counter  #计算num和counter的除法

（4）取整符号：//

格式：
对象1 // 对象2
使用：
如果对象1和对象2都是数字，那么符号“//”就表示取对象1除以对象2的整数部分
例如：

	num=50
	counter=15
	num // counter  #计算num和counter相除的整数部分

（5）取余符号：%

格式：

对象1  %  对象2

使用：
如果对象1和对象2都是数字，那么符号“%”就表示取对象1除以对象2的余数部分
例如：

	num=50
	counter=15
	num % counter  #计算num和counter相除的余数部分

（6）加法运算符：+

格式：
对象1 + 对象2

使用：
如果对象1和对象2都是数字，那么符号“+”就表示计算对象1和对象2的和；如果对象1和对象2都是序列，那么符号“+”就表示对象1和对象2的拼接
例如：

	num=50
	counter=15
	num + counter  #计算num和counter的和

（7）减法运算符：-

格式：

对象1 -  对象2

使用：
如果对象1和对象2都是数字，那么符号“-”就表示计算对象1和对象2的差；如果对象1和对象2都是集合，那么符号“-”就表示求对象1和对象2的差集
例如：

	num=50
	counter=15
	num - counter  #计算num和counter的差

（8）幂运算符：**

格式：

对象1  **  对象2

使用：
如果对象1和对象2都是数字，那么符号“**”就表示求对象1的对象2次方
例如：

	num=50
	counter=15
	num ** counter  #计算num的counter次方

2、增强型运算符

​ 增强型运算符就是结合了赋值运算符和基本运算符，称之为增强型运算符

（1）+=

格式：

对象1 +=对象2    #  对象1=对象1+对象2

使用：
将对象1加上对象2之后的结果再存入到对象1里
例如：

	num=50
	counter=40
	num+=counter  #num=num+counter

（2）-=

格式：

对象1 -=对象2   #对象1 = 对象1-对象2

使用：
将对象1减去对象2之后的结果再存入到对象1里
例如：

	num=50
	counter=40
	num-=counter  #num=num-counter	

（3）*=

（4）/=

（5）//=

（6）%=

（7）**=

参考加等于“+=”

（8）同步赋值运算符

格式：

标识符1  ，  标识符2  =   初始值1  ，  初始值2

例如：

num ,  counter  =  10  ,  20   #将10赋值给num的同时将20赋值给counter

3、比较运算符

（1）>：大于运算符

格式：

对象1 > 对象2

使用：
如果对象1大于对象2，那么该表达式返回为真，否则，返回为假
例如：

10>20   #假----False

（2）<:小于运算符

格式：

对象1 < 对象2

使用：
如果对象1小于对象2，那么该表达式返回为真，否则，返回为假
例如：

10<20   #真---True

（3）>=:大于等于运算符

格式：

对象1  >= 对象2

使用：
如果对象1大于等于对象2，那么该表达式返回为真，否则，返回为假

（4）<=：小于等于运算符

格式：

对象1  <= 对象2

使用：
如果对象1小于等于对象2，那么该表达式返回为真，否则，返回为假
例如：

10<=20   #True

（5）==：等于运算符

格式：

对象1  == 对象2

使用：
如果对象1等于对象2，那么该表达式返回为真，否则，返回为假
例如：

10==20  #False

（6）注意的点

​ python里的比较运算符可以相互的结合使用，跟C语言区分开
例如：​

2>4>5   #python
2>4  && 4>5   #C 

4、同一性运算符

​ 是指两个对象是否是指向同一块内存空间，如果是，那么就是同一性，否则就不是同一性

（1）is运算符

格式：

标识符1   is  标识符2 

使用：
如果标识符1和标识符2都是指向同一块内存空间，那么该表达式就输出为真（True），否则，输出为假（False）
例如：

num=50
counter=50
num is counter   #True
num=500
counter=500
num is counter  #False

注：
解释器里预留了-5-256数据

（2）is not

格式：

标识符1  is not  标识符2

使用：
如果标识符1和标识符2不是指向同一块内存空间，那么该表达式就输出为真（True），否则，输出为假（False）

例如：

	num=50
	counter=50
	num is not counter   #False
	num=50
	counter=60
	num is not counter   #True

5、逻辑运算符

（1）and：逻辑与运算符

格式：

对象1  and 对象2  #对象1和对象2可以是表达式

使用：
如果对象1和对象2同时成立（同时为真），那么该表达式才成立（返回为真）；只要对象1和对象2任意一个不成立（为假），那么整个表达式不成立（为假）
例如：

3>2  and  5>4   #一般该表达式存在于if或则while中

注意：
如果对象1 and 对象2独立存在，该表达式从左往右执行，如果遇到对象不成立，那么就输出对象不成立的结果；只要对象1和对象2同时成立，那么就输出对象2的结果（一般认为0就表示假，大于0就表示真）

（2）or：逻辑或运算符

格式：

对象1  or  对象2   #对象1和对象2可以是表达式

使用：
如果对象1和对象2任意一个成立（为真），那么该表达式就成立（返回为真）；只要对象1和对象2同时不成立（为假），那么整个表达式不成立（为假）
例如：

5>4  or  4<3  #True

注意：
如果对象1 and 对象2独立存在，该表达式从左往右执行，如果遇到对象成立，那么就输出对象成立的结果；只要对象2和对象2同时不成立，那么就输出对象2的结果（一般认为0就表示假，大于0就表示真）

（3）not：逻辑非运算符

格式：

not 对象

使用：
如果对象成立，那么整个表达式不成立（为假），反之，整个表达式成立（为真）
例如：

not 3>4  #True

（4）逻辑运算符的优先级

not>and>or

6、位运算

​ 位运算是针对二进制的每一位对应进行运算

（1）按位与运算：&

​ 格式：

对象1   &  对象2

​ 使用：
​ 将对象1和对象2转换为二进制，然后让对象1和对象2的二进制的每一位对应进行相与
例如：
​

50二进制：   0  1  1  0  0  1  0
85二进制：   1  0  1  0  1  0  1  
50 & 85=   0  0  1  0  0  0  0  = 16

（2）按位或运算：|

格式：

对象1  |   对象2

使用：
将对象1和对象2转换为二进制，然后让对象1和对象2的二进制的每一位对应进行相或

例如：

50二进制：   0  1  1  0  0  1  0
85二进制：   1  0  1  0  1  0  1 
50 | 85=    1  1  1   0  1  1  1  = 119

（3）按位异或运算：^

格式：

对象1  ^  对象2

使用：
将对象1和对象2转换为二进制，然后让对象1和对象2的二进制的每一位对应进行异或
异或：
相同为0，不同为1
例如：

50二进制：   0  1  1  0  0  1  0
85二进制：   1  0  1  0  1  0  1 
50 ^ 85 = 1  1  0  0  1  1  1  = 103
50 ^ 85 = 1  1  0  0  1  1  1  ^ 50  
		=1  1  0  0  1  1  1  ^
		 0  1  1  0  0  1  0
		 0  1  1  0  0  1  0

练习：实现两个数的交换

（4）按位取反：~

格式：

~ 对象

使用：
将对象转为二进制，然后让对象的二进制的每一位进行取反（0-1，1-0）

例如：

50二进制：1  1  0  0  1  0
	~50       ：0   0  1  1  0  1

（5）左移位运算：<<

格式：

对象  << n

使用：
将对象转为二进制，然后让对象的二进制的每一位左移n位，右补n个0
例如：

10的二进制：1010
	10  << 2   #将10的二进制左移2位，右补2个0

（6）右移位运算：>>

格式：

对象  >>  n

使用：
将对象转为二进制，然后让对象的二进制的每一位右移n位，左补n个0，同时去掉n个位置的数据
例如：

10的二进制：1010
	10  >> 2   ：0010    =2

十一、常用基础语句

1、if条件语句

​ 该语句是用于判断条件是否成立，如果条件成立，则执行相应的语句块，否则就不执行
关键字：if
格式：

if  判断条件  ：
        语句1
        语句2
        .............

注意：
（1）if语句中的关键字if不能省略
（2）判断条件的结果是真（条件成立）假（条件不成立）类型（比较运算等），判断条件可以用括号括起来，但一般省略
（3）判断条件后的冒号“：”不能省略
（4）if条件语句里的内容一定要缩进
（5）关键字if后面的判断条件如果没有用括号括起来那么if和判断条件之间需要加上空格，反之不用加上空格
例如：

if 2>1:   #2>1条件成立
    print("2大于1")   #执行
    print("hello world")  #执行
print("你好，世界")

(1)if语句的嵌套

格式：

if   条件1  ：
	      语句1
	      语句2
          ......
         if   条件2   ：
                语句3
                语句4
                ......
                if       条件3  ：
                         语句5
                          .............

使用：
当条件1满足的前提下，执行语句1、2，再判断条件2，当条件2满足的条件下，执行语句3、4，再判断条件3，当条件3满足的情况下，执行语句5…；如果当条件1不满足的情况下，之后的内容都不执行

例如：

num=int(input("请输入一个数字："))
if num>10:
    print("%d数字是大于10的"%num)
    if num>40:
        print("%d数字是大于40的" % num)
        if num>80:
            print("%d数字是大于80的" % num)

2、if…else语句

​ 判断if后面的条件是否成立，如果成立，则执行if语句块里的内容，不执行else语句块里的内容；如果不成立，则执行else语句块里的内容
关键字：if、else
格式：

if   条件  ：
	      语句1
	      语句2
	      ...........
else  :
       语句3
                  语句4
                  ............

例如：

num=int(input("请输入一个年龄："))
if num>50:
    print("你太老了，快去享受退休生活")
else:
    print("你还太年轻，抓紧学习")

注意事项：
（1）else是和if语句成对出现（只要有else，必定会有if）
（2）if判断条件后面的冒号“：”不能省略
（3）else语句后面没有判断条件
（4）else语句后面的冒号“：”不能省略

(1)if…else语句的嵌套

格式：

if    条件1  ：
		语句1
		if  条件2   ：
			语句5
		else :
			语句6
else：
    语句2
    if   条件3  ：
           语句3
    else：
           语句4

例如：

num=int(input("请输入一个年龄："))
if num>50:
    print("你太老了，快去享受退休生活")
    if num>60:
        print("年龄也老")
        if num>75:
            print("你75岁")
    else:
        print("你还好")
else:
    print("你还太年轻，抓紧学习")
    if num>20:
        print("你才20岁")
    else:
        print("你太小了")

​

3、if …elif…elif…

格式：

if  条件1  ：
		语句1
	elif  条件2：
		语句2
	elif 条件3 ：
		语句3
	.......

解释：
如果条件1满足，那么就执行语句1，如果条件2满足，则执行语句2，如果条件3满足，则执行语句3，…；在任意时刻只满足一个条件或则是所有条件都不满足
例如：

num=9
if 0<num<10:
    print("num是属于0-10之间的数")
elif 10<num<20:
    print("num是属于10-20之间的数")
elif 20<=num<30:
    print("num是属于20-30之间的数")

4、if …elif…elif…else

格式：

if  条件1  ：
		语句1
	elif  条件2：
		语句2
	elif 条件3 ：
		语句3
	.......
	else：
		语句n

解释：
如果条件1满足，那么就执行语句1，如果条件2满足，则执行语句2，如果条件3满足，则执行语句3，…；在任意时刻只满足一个条件

注意：（1）if和elif的条件避免交叉

5、for循环

该循环一直去判断用户给定的条件，如果条件一直成立，那么就一直执行for循环里的内容，否则跳出该循环
关键字：for、in
格式：

	for  标识符（变量）   in   序列  ：
		语句1
		语句2
		...............

解释：
该循环每循环一次就从序列里面取一个值出来存入到标识符里，如果序列是无限的，那么该for循环就是死循环
注意：
（1）关键字for和in不能省略
（2）序列可以是字符串、列表、元组、集合等等
（3）for语句块里的语句注意缩进

例如：

num="hello world"
for i in num:
    print("取的值：",i,"类型：",type(i))

(1) range函数

》》range函数
该函数的作用是生成一个有序不重复的整型数据序列
原型：

range（start，end，step）

参数：
（1）start：生成从start开始的整型数据序列，如果start参数不写，那么默认是从0开始生成整型数据序列
（2）end：生成一个整型的数据序列直到end-1结束
（3）step：生成的整型数据序列的步进值（步长），如果step参数不写，默认step的值为1

例如：

for i in range(2,8,1):
    print("取得值：",i,"类型：",type(i)) #生成2-7的序列
for i in range(8):
    print("取得值：",i,"类型：",type(i))  #生成0-7的序列

练习：#计算任意两个数之间的数字和，100 250 ：100+101+…+250
#1、计算500-1000的和
#2、计算1-100的偶数和（奇数和）

(2)for循环的嵌套

格式：

for  标识符1  in   序列1 ：  #序列1里面有4个数
		for 标识符2  in 序列2 ： #序列2里面有5个数
			for 标识符3  in  序列3：  #序列3里面有6个数
				语句3
				................. 

解释：
第一个for循环循环1次，第二个for循环就循环5次，第三个for循环循环56次；对于上面的格式来说，总共循环45*6=120次
例如：

for i in "he":  #2次
    for j in "hel":   #3次
        for k in "hell":  #4次
            print("hello") #hello打印多少次？答案：24次	

6、while循环

​ 该循环是指只要循环条件一直成立，那么就一直执行while循环体里的内容，称之为死循环，只要循环条件不成立，那么就跳出该while循环
格式：

	while  条件  ：  #条件一般是由比较运算符组成（具体根据实际情况而定）
		语句1
		......

例如：

	while  2>1  :
		print("hello world")

注意：
如果需要控制while循环的次数，就通过修改while循环后的条件（仅限此处）

7、break语句

​ 该语句用于打破循环（跳出循环），只要程序一旦执行到break语句，那么整个循环就结束，break后面的代码也不会执行（break语句放在循环内）
格式：

	break   #终止循环

例如：

while  True：
		print("hello world")
		break
		print（“你好，世界！”）
	print（“世界，你好”）

8、continue语句

​ 该语句用于循环中，作用是终止本次循环，只要程序一旦执行到continue语句，那么当次循环就结束，continue语句后面的代码也不会执行（continue放在循环内）
格式：
​

continue  #终止本次循环

例如：

i=0
while i<10:
    i+=1
    if i==5:
        continue
    print("i=",i)

9、pass语句

​ 该语句是一个空语句，为了增加程序的可读性
格式：

pass   #放在程序的任意位置

十二、字符串

​ Python里的字符串是基本的数据类型，是由单引号或者是双引号括起来的数据，称之为字符串，或者是字符序列
例如：
​ “hello ” “中国” ‘world’ “hello ‘world’” "hello “hello"world”
注意：
（1）字符串里可以是中文、英文、数字等等
（2）字符串里可以包含子字符串，外层字符串的符号和内层字符串的符号不能相同（如果外层用双引号，那么内层不能用双引号，或则外层用单引号，内层不能用单引号）

1、字符串的赋值

​ 相当于是给变量赋值一个字符串
格式：

标识符  =  字符串

例如：

	num ="hello "
	numm="world"

注意：
（1）如果想要创建多行字符串并且将字符串赋值给标识符，那么就将多行字符串用三个单引号或者是三个双引号括起来
例如：

	num="""
	hello
	world
	hello world
	......
	"""

（2）python里的字符串支持空字符串或者空格字符串
例如：

	str=''
	str=" "

2、与字符串相关的函数

（1）len函数

​ 该函数求字符串的长度
格式：

len（“字符串”） #求字符串的长度

例如：

len（“hello”）  #5

（2）replace函数

​ 该函数是替换字符串中的数据
格式：

字符串 . replace（旧的字符串，新的字符串）

例如：

	str="hello"   #将“hello”中的"h"替换为“w”
	str.replace（“h”，“w”）

3、字符串的复制

​ 是指将字符串复制n份
符号：*
格式：
​ 字符串 * n
解释：
​ 将字符串复制n份
例如：
​ str=“hello”
​ str*3 #将“hello”复制3份

4、字符串的访问

​ 是指用户一般需要去访问或者是获取字符串里的字符
字符串的编码：系统会自动给字符串编一个下标码（类似于数组）

（1）正向编码

​ 字符串的下标是从左往右依次开始从0递增进行编码
​ “ h e l l o w o r l d”
----> 0 1 2 3 4 5 6 7 8 9

（2）反向编码

​ 字符串的下标是从右往左依次开始从-1递减进行编码
​ “ h e l l o w o r l d”
​ -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 <-------

字符串的访问：
（1）正向访问
正向访问是指通过字符串的正向下标对字符串里的内容进行访问
符号：[]
格式：
字符串 [ 正向下标 ] #访问字符串中正向下标对应的字符
例如：
str=“hello world”
str [5] #访问str中下标为5对应的元素
str [3] #访问str中下标为3对应的元素
…
（2）反向访问
反向访问是指通过字符串的反向下标对字符串里的内容进行访问
符号：[]
格式：
字符串 [ 反向下标 ] #访问字符串中反向下标对应的字符
例如：
str=“hello world”
str [-6] #访问str中下标为-6对应的元素：’ ’
str [-3] #访问str中下标为-3对应的元素：“r”
…

5、字符串的截取或切片

​ 是指从字符串里截取一段子字符串出来

（1）正向截取

（包头（start）不包尾（end））
前提是字符串的下标编码是正向编码
符号：[]
格式：
[start : end : step]
参数：
a、start：字符串的截取从start位置开始从左往右截取，如果start参数不写，那么默认是从下表为0开始进行截取
b、end：字符串的截取直到end-1结束，如果end不写，默认是截取到最后一个数据（包含最后一个数据）
c、step：字符串截取的步长，注意，step的绝对值表示截取的步长，step的正负值表示截取的方向，如果step不写，默认截取的步长为1，截取的方向从左往右
例如：
str=“hello world”
str[2:4] #ll
str[0:5] #hello
str[:5] #hello
str[1:8:3] #eoo
str[2:0:-1] #截取le #多去练一练
str[::-1] #特殊情况，字符串的反转
str[::1]
str[::]
…

（2）反向截取

（包头（start）不包尾（end））
前提是字符串的下标编码是反向编码
符号：[]
格式：
[start : end : step]
参数：
a、start：字符串的截取从start位置开始从左往右截取，如果start参数不写，那么默认是从左边第一个数据开始进行截取
b、end：字符串的截取直到end-1结束，如果end不写，默认是截取到最后一个数据（包含最后一个数据）
c、step：字符串截取的步长，注意，step的绝对值表示截取的步长，step的正负值表示截取的方向，如果step不写，默认截取的步长为1，截取的方向从左往右
例如：
str=“hello world”
str[-11:-9] #he
str[:-9] #he
str[-9:] #“llo world”
str[::] #“hello world”
str[-3:-8:-1] # “row o” 特殊情况

6、字符串的拼接

（1）使用加号“+”来实现两个字符串的拼接
格式：
字符串1 + 字符串2
例如：
str1=“hello”
str2=“world”
str=str1+str2 #“helloworld”
（2）两个字符串直接进行拼接
格式：
字符串1字符串2
例如：
str1=“hello”
str2=“world”
str=str1str2 #报错，str1str2标识符没有被定义
str=“hello”“world” #“helloworld”

十三、列表：list

​ 列表也是Python里内置的一种基本数据类型（列表也是一种序列），它是用于存储数据（与数组类似），并且数据的类型可以不相同（与数组的区别）
符号：[]
格式：
​ [数据1，数据2，[数据3，数据4,…]]
例如：
​ [1，2，3，4] [1,1.2,1.2344] [1,1,566,“hello”] [3,“hello”,“你好”,[1,2,4]]

总结：
（1）列表中的数据元素的类型可以是相同的，也可以是不同的
（2）列表中的元素之间是用逗号隔开“,”，注意逗号是英文格式的
（3）列表支持空列表：list=[]

1、列表的初始化

格式：
标识符 = 列表
例如：
list=[1，2，3，4]

2、列表与数组的区别

相同点：
（1）数组和列表都是用于存储数据
（2）数组和列表中的元素都是以逗号隔开
（3）数组和列表都有下标，并且下标是正向编码

不同点：
（1）数组要求存的数据的类型必须一致
（2）数组只能正向编码，而列表可以反向编码
（3）数组一旦声明大小就固定，而列表声明了之后，大小不固定

3、列表的访问

​ 与字符串一样，可以访问（获取）列表中的元素
正向编码：
​ 列表中的元素从左往右从0依次开始递增编码
反向编码：
​ 列表中的元素从右往左从-1依次开始递减编码
列表的访问：
（1）正向访问
符号：[]
格式：
​ 列表 [ 下标 ]
例如：
​ list=[ 1 , 2 , 3 , 4 , 5 , 6]
----> 0 1 2 3 4 5
​ list[3] #4
​ …
（2）反向访问
符号：[]
格式：
​ 列表 [ 下标 ]
例如：
​ list=[“hello” , “world” , “hello world”]
​ -3 -2 -1 <--------------
​ list[-1] #“hello world”

4、列表的截取或切片

（1）正向截取（包头不包尾）
注意：正向截取的下标编码是正向编码
格式：
[start : end : step]
参数：
a、start：列表的截取从start开始进行截取，如果start不写，默认是从下标为0的元素开始进行截取
b、end：列表的截取一直到end-1结束，如果end不写，默认是截取到最后一个元素
c、step：截取的步长，绝对值表示步长，正负值代表方向，如果step不写，默认截取的步长是1，并且截取的方向是从左往右
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list[0:3:1] #[“hello” , “world” , “你好”]
list[:3:1] #[“hello” , “world” , “你好”]
list[0::1] #[“hello” , “world” , “你好” , “世界” ， “1234”]
list[0:3] #[“hello” , “world” , “你好”]
list[::] #[“hello” , “world” , “你好” , “世界” ， “1234”]
…

（2）反向截取（包头不包尾）
注意：反向截取的下标编码是反向编码
格式：
[start : end : step]
参数：
a、start：列表的截取从start开始进行截取，如果start不写，默认是从左边的的第一个元素开始进行截取
b、end：列表的截取一直到end-1结束，如果end不写，默认是截取到最后一个元素
c、step：截取的步长，绝对值表示步长，正负值代表方向，如果step不写，默认截取的步长是1，并且截取的方向是从左往右
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list[-4👎1] #[“world” , “你好” , “世界”]
list[👎1] #[“hello” , “world” , “你好” , “世界” ]
list[-4::1] #[ “world” , “你好” , “世界” ， “1234”]
…

5、列表的增、删、改、查

（1）列表的增加

a、append函数
向指定列表中添加指定的数据元素，并且数据元素是单个进行添加，并且是以追加的形式添加
格式：
列表 . append（数据元素） #将数据元素添加到列表的尾部
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.append（“今天是星期一”）#将今天是星期一”添加到list的尾部
list.append（15） #将15添加到list的尾部
…
b、extend函数
向指定列表中添加指定的数据元素，数据元素是多个进行添加，并且是以追加的形式添加
格式：
列表 . extend（列表类型） #将列表类型的数据添加到列表的尾部
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.extend（[“123456”,“654321”]）
c、insert函数
向指定列表中指定的位置插入指定的数据元素，原来该位置的元素自动往后挪一位
格式：
列表 . insert（下标 ， 数据） #向列表中的下标位置插入数据
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.insert(0,“boss”) #将boss插入到list的第0个位置

（2）列表的删除

a、pop函数
pop函数删除列表中顶部的元素
格式：
列表 . pop（） #删除列表中的顶部元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.pop() #删除“1234”
b、pop（下标）函数
pop（下标）函数删除列表中指定下标对应的数据元素
格式：
列表 . pop（下标） #删除列表中下标对应的数据元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.pop(1) #删除下标为1对应的数据元素
c、remove函数
该函数删除列表中指定的数据元素
格式：
列表 . remove（列表中的数据元素） #删除列表中指定的数据元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.remove（“world”） #将“world”从list中移除掉
d、del关键字
该关键字删除列表及列表中的所有元素
格式：
del 列表 #删除列表及列表中的数据元素
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
del list

e、clear函数

清空列表中的数据元素

（3）列表的修改

​ 可以修改列表中指定下标对应的数据元素
符号：[]
格式：
​ 列表 [ 下标 ] = 新的数据
例如：
​ list=[“hello” , “world” , “你好” , “世界” ， “1234”]
​ list [1]=“boss” #将list中下标为1的数据元素更改为“boss”

（4）列表的查询

​ 可以查询列表中数据元素的个数、相同数据元素出现的个数、查询下标对应的数据元素、查询数据元素对应的下标等等
a、len函数
​ len函数可以查询列表中元素的个数
格式：
​ len（列表）
例如：
​ list=[“hello” , “world” , “你好” , “世界” ， “1234”]
​ len(list) #5
b、count（）函数
​ 该函数可以查询列表中相同元素出现的个数
格式：
​ 列表 . count（数据）
例如：
​ list=[“hello” , “world” , “你好” , “世界” ， “1234”]
​ list.count（“hello”） #查询“hello”在list中出现的次数
c、查询下表对应的数据元素
格式：
​ 列表 [下标] #查询到下标对应的数据元素
例如：
​ list=[“hello” , “world” , “你好” , “世界” ， “1234”]
​ print（list[0]） #查询到下标为0对应的数据元素：“hello”

d、index函数
该函数可以查询列表中数据元素对应的下标
格式：
列表 . index（数据）
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list.index（“world”） #查询list中“world对应的下标”

6、列表的拼接

符号：+
格式：
列表1 + 列表2
例如：
list1=[10,20]
list2=[30,40]
list=list1+list2

7、列表的赋值

符号：*
格式：
列表 * n
解释：
将列表复制n份
例如：
list=[10]
list * 3 #将list复制3份

十四、元组：tuple

​ 元组也是Python里提供的一种基本数据类型，类似于列表，可以存储数据，数据的类型也可以不一致

1、元组的初始化

符号： ( )
格式：
标识符 = （数据1 ， 数据2 ，…，）
例如：
tuple = (10 ， 20 ， “hello”，“world”，)

注意：
（1）元组的声明是用括号“()”进行声明
（2）元组中的数据元素之间是用逗号“,”
（3）元组中的数据元素的类型可以不一致
（4）元组一旦声明，那么就不能随意更改元组中的内容，可以看成是一个常量
（5）元组里的数据后面以逗号结尾（注，如果是单个数据必须加逗号才表示是元组，如果是多个数据，逗号可以省略）

2、元组的访问

（1）正向编码：元组的下标从左往右依次从0开始递增进行编码
例如：
(10 ， 20 ， “hello”，“world”)
0 1 2 3
（2）反向编码：元组的下标从右往左依次从-1开始递减进行编码
例如：
(10 ， 20 ， “hello”，“world”)

 -4       -3            -2                -1

元组的访问：
（3）正向访问
符号：[]
格式：
元组 [ 下标 ] #访问到下标对应的数据元素
例如：
tuple= (10 ， 20 ， “hello”，“world”)
tuple [ 2 ]

（4）反向访问
符号：[]
格式：
元组 [ 下标 ] #访问到下标对应的数据元素
例如：
tuple= (10 ， 20 ， “hello”，“world”)
tuple [ -2 ]

3、元组的截取或切片

（参考列表或字符串）
（1）正向截取（包头不包尾）
注意：正向截取的下标编码是正向编码
格式：
[start : end : step]
参数：
a、start：列表的截取从start开始进行截取，如果start不写，默认是从下标为0的元素开始进行截取
b、end：列表的截取一直到end-1结束，如果end不写，默认是截取到最后一个元素
c、step：截取的步长，绝对值表示步长，正负值代表方向，如果step不写，默认截取的步长是1，并且截取的方向是从左往右
例如：
list=（“hello” , “world” , “你好” , “世界” ， “1234”）
list[0:3:1] #[“hello” , “world” , “你好”]
list[:3:1] #[“hello” , “world” , “你好”]
list[0::1] #[“hello” , “world” , “你好” , “世界” ， “1234”]
list[0:3] #[“hello” , “world” , “你好”]
list[::] #[“hello” , “world” , “你好” , “世界” ， “1234”]
…

（2）反向截取（包头不包尾）
注意：反向截取的下标编码是反向编码
格式：
[start : end : step]
参数：
a、start：列表的截取从start开始进行截取，如果start不写，默认是从左边的的第一个元素开始进行截取
b、end：列表的截取一直到end-1结束，如果end不写，默认是截取到最后一个元素
c、step：截取的步长，绝对值表示步长，正负值代表方向，如果step不写，默认截取的步长是1，并且截取的方向是从左往右
例如：
list=[“hello” , “world” , “你好” , “世界” ， “1234”]
list[-4👎1] #[“world” , “你好” , “世界”]
list[👎1] #[“hello” , “world” , “你好” , “世界” ]
list[-4::1] #[ “world” , “你好” , “世界” ， “1234”]
…

4、元组涉及的函数

（1）len函数

​ 该函数求元组的长度
格式：
​ len（元组）
例如：
​ tuple=(10,20)
​ len(tuple)

（2）max函数

​ 该函数求元组中的数据元素的最大值
格式：
​ max（元组）
例如：
​ tuple=(10,20)
​ max（tuple） #20

（3）min函数

​ 该函数求元组中的数据元素的最小值
格式：
​ min（元组）
例如：
​ tuple=(10,20)
​ min（tuple） #10

5、元组的删除

关键字：del
格式：
del 元组
例如：
tuple=(10,20)
del tuple

6、元组的拼接

符号：+
格式：
元组1 + 元组2
例如：
tuple1=(10)
tuple2=(20)
tuple1+tupl2
注：
元组里的数据如果是单个数字，使用“+”，表示将元组里的内容进行相加，如果是多个数据，那么就实现两个元组的拼接

十五、字典or词典：dict

​ 字典也是Python里的一种基本数据结构，它也是用于存储数据，类似于元组或者是列表，但是存储的方式有不同，数据在字典里的存储方式是以键值对的形式存储

1、字典的初始化

符号：{}
格式：
标识符 = { 键1 ：值1 ，键2：值2 ，键3：值3 ,… }
例如：
dict={“key1” : 1 , “key2” : 2 , “key3” : 3 } #可以
dict={(10,20) : 1 , (20,“10”) : 2 , (4 , 8) : 3} #可以
dict={[10,20] : 1 , [20 ,“10”] : 3 , [4 ,8] :3} #不可以
dict={0 : 1 , 1 : 2 , 2 :3} #可以

注意：
（1）键值对中的键必须是不可变的数据，如常量、元组等等
（2）键值对中的键是唯一标识用户所存储的数据，意思就是键值对中的键不能与其它键相同（每个键都是独立的并且不相同的）
（3）用户存储的数据在字典中必须以键值对的形式存在（键值对成对出现）
（4）键值对之间用逗号“,”隔开
（5）字典中的键值对中的键与值之间使用冒号“：”隔开
（6）字典中存储的值可以是任意类型的数据

2、字典访问

​ 访问字典里存储的数据
符号：[]
格式：
​ 字典 [ 键 ] #访问字典里键对应的值
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict[“key2”] #2

3、字典的增加、删除、修改、查询

（1）增加

​ 向字典里增加新的内容
符号：[]
格式：
​ 字典 [新的键] = 新的值
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict[“key4”] = 4

（2）删除

​ 删除字典中的数据或者是删除整个字典
a、关键字：del
格式：
​ del 字典 #删除整个字典
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ del dict
b、关键字：del
格式：
​ del 字典[键] #删除字典中键对应的值
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ del dict[“key1”]

（3）修改

​ 可以修改键值对中键对应的值
格式：
​ 字典 [已经存在的键] = 更新的值 #将字典中之前键对应的值更新为新的值
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict[“key2”] = “hello world” #将字典中2更新为“hello world”
（4）查询
​ 可以查询字典中键对应的值
格式：
​ 字典 [已经存在的键]
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict[“key2”]

4、字典常用的函数

（1）values函数

​ 该函数用于获取字典中所有的键对应的值
格式：
​ 字典 . values（）
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict . values（）

（2）keys函数

​ 该函数用于获取字典中所有的键
格式：
​ 字典 . keys（）
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict.keys（）

（3）items函数

​ 该函数用于获取字典中所有的键值对
格式：
​ 字典 . items（）
例如：
​ dict={“key1” : 1 , “key2” : 2 , “key3” : 3 }
​ dict.items（）

十六、函数

​ 函数是对实际的一些功能进行封装，封装的目的是保护数据的安全和为了使用简便，它只向用户暴露接口，不暴露具体的实现细节

1、函数的声明

关键字：def
格式：

def   函数名（参数1 ，参数2 ，......）： #注：参数可有可无
		字符串  #该字符串也是可有可无
		代码
		....
		return   #return也是可有可无

例如：

def    function   （）：
		“该函数用于实现字符串的拼接”
		print（“hello world”）
		return 0    #该函数返回0

注意：
（1）关键字def不能省略，它用于声明函数
（2）函数名就是标识符，满足python的标识符规定
（3）函数名后面的括号里参数可有可无，根据自身实际情况而定
（4）函数参数括号后面的冒号“：”
（5）函数体内部的内容需要进行缩进
（6）函数体内部第一行代码是字符串，它可有可无，目的是为了提示
（7）函数体内部的关键字return的作用是返回，使用格式：return 内容

2、函数的参数

（1）函数传参的顺序不变，根据函数内部参数的实现而定—必备参数

def   function（x , y ）：
	num=x+10
	str=y+"hello"

（2）函数传参是以关键字形式，函数传参的顺序可以变化

def   function（x , y ）:
	num=x+10
	str=y+"hello"

（3）函数传参时默认值传参

def   function（x, y=“world” ）:
	num=x+10
	str=y+"hello"

3、函数的调用

格式：
函数名 （传递实参） #如果函数带了参数就需要传递实参，如没有带，那就不需要传递
例如：
（1）

def   function（x , y ）：  #按顺序传参
    num=x+10
    str=y+"hello"
function（10，“world”）	

（2）

def   function（x , y ）：  #按关键字传参
    num=x+10
    str=y+"hello"
function（y=“world”，x=10）

（3）

def   function（x , y=“world” ）:  #注：带默认值的参数必须放在不带默认值参数的后面
    num=x+10   
    str=y+"hello"
function（y="world"）

4、函数嵌套

格式：
def function1（参数）：
代码
…
def function2（参数）
代码
…
function2（实参）
调用：
function1（实参）

十七、模块和包

1、模块

​ 模块在python里是指一个python文件（python文件=模块） ，模块里可以放置函数、全局变量、类等等

（1）模块的导入

​ 是指一个模块使用另外一个模块里的内容
关键字：import
格式：
​ import 模块名
例如：
​ hello.py #模块名：hello
​ import hello
注：导入模块时，同时取别名
关键字：import、as
格式：
​ import 模块 as 别名
例如：
​ hello.py
​ import hello as he

（2）使用其他模块里的内容

a、是在import导入其他模块的前提下，再使用其他模块里的内容
格式：
import 模块名
模块名 . 功能或别名 . 功能
例如：
hello.py #模块名：hello
import hello
hello . num #使用其他模块里的内容

b、导入其他模块里指定的内容
关键字：from、import
格式：
from 模块 import 功能
例如：
hello.py #模块名：hello
from hello import num #从hello模块里导入变量num到当前文件
print（“num=”,num）
c、一次性导入其他模块里的所有内容
关键字：from、import
符号：*
格式：
from 模块 import *
例如：
hello.py #模块名：hello
from hello import *
print（“num=”,num）
function（）

2、包

​ 包在python里是一个目录，包是包含多个模块，每一个包里包含一个特殊文件，该文件是__init__.py

（1）包的导入

关键字：import
格式：
import 包名 #包名是文件名

注：导入包时，同时取别名
关键字：import、as
格式：
import 包 as 别名
例如：
hello #包
import hello as he

（2）使用包里的模块里的内容

格式：

import  包名
包名  .   模块名  .   功能

例如：

zhang   #包zhang
hello.py   #包zhang里的模块
import zhang
zhang . hello .num   #使用包zhang里的模块hello里的变量num（前提条件是注里的内容）

注：
需要在__init__.py文件里导入该包里用户需要使用的模块
格式：

from  .   import  模块名

十八、文件操作（I/O技术）

对于一个完整的程序一般都包括数据的存储和读取。从外部存储介质(硬盘、光盘、软盘、U盘)读取数据，或将程序中(结果）的数据存储到介质(文件)。
文件:按照数据的组织形式：

1.文本文件

文本文件存储的普通”字符"

2.二进制文件

二进制文件把数据内容用"字节"进行存储，无法使用记事本打开，必须使用专用的软件解码。常见的有:|MP4、MP3、JPG图片、exe

3、文件操作相关模块

Python标准库中，提供如下模块进行文件操作：

名称		 说明
io模块 ：文件的输入和输出操作 input、output
os模块 ：基本的操作系统功能，包括文件操作
glob模块 ：查找符合特定规则的文件路径名
filecmp模块： 用于文件的比较

名称 		说明
cvs模块： 用于cvs文件处理
xml包 ：用于xml数据处理
bz2、gzip、zipfile、zlib、tarlib：用于处理压缩和解压文件(分别对应不同的算法)

（1）创建文件对象

open()函数用于创建文件对象，表示—个在程序中要操作的文件
基本语法格式:

open(文件名[打开方式])

文件名可以是全路径:表示操作指定目录下的文件。如:C:\Usersly\Desktop\test.txt。为了减少\的输入，可以使用原始字符串来示:r"C:\Usersly Desktop\test.txt"
打开方式:

模式：描述
b：二进制binary模型，二进制文件
r：读read模式
w：写write模式。如果文件不存在则创建，如果文件存在，则重新写内容(清空内容)
a：写append模式。文件不存在则创建，如果存在，则在文件末尾追加内容
+：在已有的选择中添加额外的读、写。

open()函数存在返回值，返回值就是打开的文件对象文件对象变量名= open(文件路径，打开方式)

（2）文本文件的写入

基本的文件写入操作，文件的写入一般有三个步骤:①创建文件对象(打开文件)，②写入数据，③关闭文件对象(关闭文件)。
write(写入的内容)
用法：

文件对象.write（内容）

writelines(要写入列表)
用法：

文件对象.writelines(要写入列表)

（3）文本文件的读取

read()函数，从文本文件中读取数据
read([size])从文件中读取size个字符，如果没有size参数，则表示读取整个文件，返回值就是读取的字符串。当已经读取到文件结束，再次进行读取时，返回值为空字符串（读取到文件末尾，会返回空字符串）

==readline()==从文件中读取一行内容，返回值就是读取的数据。当已经读取到文件结束，再次进行读取时，返回值为空字符串（读取到文件末尾，会返回空字符串）==readlines()==从文件中读取每一行，每一行作为一个字符串存储列表中，返回该列表。

（4）关闭文件对象

关闭打开的文件close)函数关闭文件用法:

文件对象.close()

对于文本文件，由于有不同的编码格式，所以经常操作时会碰到
乱码问题。 编码： ASCII：用7位表示，表示128个字符
ISO8859-1：又叫做Latin-1，8位字符集，兼容ASCII编码

GB2312：汉字编码字符集，兼容ISO8859-1编码 GBK：汉字内码
扩展规范，扩展GB2312，在它的基础上又增加了更多的汉字
GB18030：它采用单字节、双字节、四字节 UTF-8：不定长编
码，每一个字符长度1-4字节不等

（5）文件对象的常用属性和方法

属性 ：说明
name ：返回文件的名字
mode ：返回文件的打开模式
closed ：若文件被关闭则返回True

常用方法

方法 ：说明
tell()： 返回文件当前操作位置
seek()： 把文件当前操作位置移动到新的位置
truncate()： 不论当前位置在哪，只留下当前位置指定大小的内容，其余全部删除

seek(偏移大小，基准位置) 偏移大小： 移动多少字节字符，负数向前，正数向后 基准位置： 0：从文件开始位置计算 1：从当前位置开始计算 2：从文件末尾位置开始计算os和os.path模块 os模块可以帮助我们直接对操作系统进行操作，执行程序、命令、直接操作文件、目录等。

函数： 作用
remove(文件路径)： 删除指定的文件
rename(原文件名,目标文件名) ：重命名文件或目录
stat(文件路径) ：返回文件的所有属性
listdir(目录) ：返回目录下的文件和目录的列表
rmdir(目录) ：删除目录
mkdir(目录) ：创建目录

os.path模块
os.path模块提供了目录相关的操作

方法：			描述:
isdir(路径)：判断路径是否是目录
isfile(路径)：判断路径是否是文件
exists(文件路径)：判断路径的文件是否存在
getsize():返回文件大小
getatime():文件访问时间
getctime():文件创建时间
getmtime():文件修改时间
例如：(os.path.getatime)
isabs(路径):判断路径是否是绝对路径

4、CSV文件操作

csv是逗号分隔符文本格式，常用于数据交换、Excel文件和数据库数据的导入和导出。

csv文件：
值没有类型，所有值都是字符串
没有多个工作表
在python的标准库模块csv提供了读取和写入csv格式的对象

csv.read对象
#读取csv文件内容
import csv

#打开文件
a = open("C:/Users/y/Desktop/1.csv")
#创建csv对象读取文件
csv_a = csv.reader(a)#csv读取对象要操作 a 文件，返回值就是csv对象，是包含了所有数据的列表，每一行就是一个元素

for row in csv_a :
    print(row)

csv.writer对象
#往csv文件添加（写入）数据
import csv

f = open("C:/Users/y/Desktop/1.csv","w")

csv_a = csv.writer(f)#创建csv对象，操作 f 文件
csv_a.writerow(["姓名","地址","联系方式"])

csv_a.writerows([["张三","xxxx","无"],["李四","无","xxxxxx"]])

5、压缩与解压

shutil模块是python中提供的，主要用来文件和文件夹的拷贝、移动、删除等，也可以用于文件和文件夹的压缩、解压操作文件拷贝 copyfile(源文件,目标文件)

文件拷贝 目录拷贝copytree(源目录,目标目录–不存在)

压缩： make_archive(压缩的目标文件名，压缩方式，压缩源文件目录)

import shutil
import zipfile

#shutil.copyfile("C:/Users/y/Desktop/1.txt","3.txt")

#shutil.copytree("C:/Users/y/Desktop/one","one")

#shutil.make_archive("C:/Users/y/Desktop/ok","zip","one")

#使用zipfile压缩
z = zipfile.ZipFile("C:/Users/y/Desktop/a.zip","w")#打开压缩文件，如果压缩文件不存在就创建

z.write("1.txt")
z.write("2.txt")
z.write("3.txt")

z.close()

解压：

import zipfile

z = zipfile.ZipFile("C:/Users/y/Desktop/a.zip","r")

z.extractall("C:/Users/y/Desktop")#设置解压文件
z.close()

总结

好好学习，天天向上。文章来源地址https://www.toymoban.com/news/detail-428945.html

到了这里，关于Python入门到高手进阶|这一篇就够了（3万字|超详细）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！