Python入门教程（超详细）

士别三日wyx

于 2024-08-20 09:16:28 发布

阅读量7.6k

点赞数 74

分类专栏：《网络安全快速入门》文章标签： python 开发语言安全 web安全人工智能

本文链接：https://blog.csdn.net/wangyuxiang946/article/details/141226295

版权

《网络安全快速入门》专栏收录该内容

54 篇文章 641 订阅

订阅专栏

《网络安全自学教程》

在这里插入图片描述

Python是一种「基于C语言」实现的，「开源」的，「面向对象的」的，「动态数据类型」的「解释型」语言。

Python的语法「简单」且「优雅」，相对于其他语言学习「难度较低」，入门非常快。

Python的上升趋势非常明显，20年来首次超过C语言和Java，成为「最受欢迎」的程序语言。

在这里插入图片描述

0. Hello Python

许多PC和Mac默认已经安装了python，在 cmd 运行以下命令检查是否安装了python

C:\Users\zhangsan>python --version

已安装python则会显示出python的「版本」

Python 3.8.6

如果你的电脑没装Python，就先安装Python的开发工具。

PyCharm工具安装教程

每学习一门新语言，第一件事当然是输出"Hello, World!"

第一步：「新建」一个文本文件，「输入」以下内容，「修改」文件名为 hello.py

print('Hello, Python!')

在这里插入图片描述

第二步： 在文件所在目录的地址栏中输入 cmd （当前目录打开 cmd ）

在这里插入图片描述

第三步：「执行」python文件

在这里插入图片描述

恭喜，你已经编写并执行了第一个python程序，点击 ↓↓↓ 安装集成开发工具。

PyCharm工具安装教程

1、语法

1.1、缩进

Python中使用缩进（而不是{}）来控制代码块，即代码行开头的「空格」

同一代码块中必须使用「相同数量」的空格（默认使用两个空格）

if 2 > 1:
    print('Hello, Python!')

输出：

Hello, Python!

如果「没有缩进」，则会报错

if 2 > 1:
print('Hello, Python!')

输出：

  File "E:/data/PrCharm/test/test.py", line 2
    print('Hello, Python!')
    ^
IndentationError: expected an indented block
# 缩进错误：此处需要缩进

1.2、注释

注释是给人看的，用来「解释」代码的作用，注释的内容「不会被执行」

Python的注释以 # 开头

# 注释不会被执行
print('Hello, Python!')

输出：

Hello, Python!

「未分配」给变量的字符串不会被执行，可当做注释使用

'字符串注释'
print('Hello, Python!')

输出：

Hello, Python!

一对引号只能包含一行内容，三引号可包含「多行内容」，起到多行注释的作用

'''
多行注释
多行注释
'''
print('Hello, Python!')

输出：

Hello, Python!

1.3、变量

变量用来「存放数据」

Python的变量在被赋值时「创建」，不需要声明变量

text = 5
print(text)

输出：

Python会根据变量内容自动确定「变量类型」，不需要「声明」变量类型，可随意「修改」数据类型

text = 5
text = '张三'
print(text)

输出：

张三

变量命名规则：

变量名只能包含字母、数字和下划线（A-z、0-9 和 _）
变量名必须以字母或下划线开头，不能以数字开头
变量名区分大小写（如text 和 Text 是不同的变量）

Python可以同时为「多个变量赋值」，变量与值的「位置」一一对应

x, y, z = '张三', '李四', '王五'
print(x, y, z)

输出：

张三 李四 王五

或者同时为「多个变量赋同一个值」

x = y = z = '张三'
print(x, y, z)

输出：

张三 张三 张三

函数「外部」创建的变量称为全局变量，函数内部和外部都能使用

name = '张三' # 全局变量
def hello():
    print(name)
hello()

输出：

张三

函数「内部」创建的变量成为局部变量，只能在函数内部使用

def hello():
    name = '张三' # 局部变量
    print(name)
    
hello()

输出：

张三

局部变量不能在函数「外部」调用，否则会报错

def hello():
    name = '张三' # 局部变量
    
hello()
print(name)

输出：

Traceback (most recent call last):
  File "E:/data/PrCharm/test/test.py", line 4, in <module>
    print(name)
NameError: name 'name' is not defined
# 名称错误，变量‘name’没有被定义

global 可以将局部变量更改为全局变量

def hello():
    global name # 定义全局变量
    name = '张三'  # 赋值

hello()
print(name)

输出：

张三

必须在变量赋值前使用 global 关键字，否则会报错

def hello():
    name = '张三'  # 赋值
    global name  # 定义全局变量

hello()
print(name)

输出：

  File "E:/data/PrCharm/test/test.py", line 3
    global name  # 定义全局变量
    ^
SyntaxError: name 'name' is assigned to before global declaration
# 语法错误：变量‘name’在全局声明之前被赋值

2、数据类型

Python变量的数据类型有8种：

Numbers：数字类型
String：字符串类型
bool：布尔类型
List：列表类型
Tuple：元组类型
Set：集合类型
Dictionary：字典类型
bytes：二进制序列

其中数字、字符串、元祖是不可变类型；列表、字典、集合是可变类型。

2.1、数字

数字类型（Numbers）用来存储数值，比如整数、小数等。

「创建」数字类型变量

num1 = 1
num2 = 1.1

del可以「删除」对象的引用

del num1

删除后的对象，再引用会报错

num1 = 1

print('删除前：', num1)
del num1
print('删除后：', num1)

输出：

Traceback (most recent call last):
  File "C:\Users\dell\PycharmProjects\pythonProject1\test1.py", line 7, in <module>
    print('删除后：', num1)
NameError: name 'num1' is not defined
删除前： 1

数字类型是不可变的，值「修改」以后，会分配一个新的对象。

num1 = 1
print('改变前：', id(num1))
num1 = 2
print('改变后：', id(num1))

输出：

改变前： 140729117181600
改变后： 140729117181632

2.2、字符串

字符串是由数字、字母、下划线组成的一串字符，用单/双引号包裹。

「创建」字符串变量

str1 = '123_abc'
str2 = "123_abc"

del可以「删除」字符串，删除后，再引用会报错 NameError: name ‘str1’ is not defined

str1 = 'abc'

print('删除前：', str1)
del str1
print('删除后：', str1)

输出：

在这里插入图片描述
字符串是不可变类型，当值被「修改」，就会分配一个新的对象，内存地址发生改变。

str1 = 'abc'
print('修改前：', id(str1))
str1 = 'def'
print('修改后：', id(str1))

输出：

修改前： 2035775820080
修改后： 2035778983344

字符串相当于一种特殊的数组，可以通过索引来「读取」字符串中的字符，索引从0开始

比如，读取单个字符（读取第4个字符）

str1 = '123_abc'
print(str1[4])

输出：

「读取多个」字符（读取第4~6个字符），含头不含尾

str1 = '123_abc'
print(str1[4:6])

输出：

ab

字符串之间可以通过一些「运算符」来简化操作。

运算符	描述
+	拼接字符串
*	重复字符串
in	成员运算符，字符串中包含指定字符串时返回True
not in	成员运算符，字符串中不包含指定字符串时返回True
r/R	输出原始字符串（转义符不生效）

print('hello' + 'world')
print('hello' * 3)
print('a' in 'abcd')
print('a' not in 'abcd')
print(r'a\'')

输出：

helloworld
hellohellohello
True
False
a\'

字符串中，使用反斜杠\来转译特殊字符。

转义字符	描述
`\\`	反斜杠
`\'`	单引号
`\"`	双引号
`\n`	换行
`\v`	纵向制表符
`\t`	横向制表符
`\f`	换页

print('hello world')
print('hello \\ world')
print('hello \' world')
print('hello \" world')
print('hello \n world')
print('hello \v world')
print('hello \t world')
print('hello \t world')

输出：

hello world
hello \ world
hello ' world
hello " world
hello 
 world
hello  world
hello 	 world
hello 	 world

想让转义符不生效，可以在字符串前面加上 r

str1 = r'abc\ndef'
print(str1)

输出：

abc\ndef

2.3、布尔

布尔类型只有两个值：True 和 False。

「创建」布尔类型变量

a = True
b = False

首字母必须大写，否则会报错 NameError: name ‘true’ is not defined

a = true
print(a)

输出：

在这里插入图片描述

True会被当做 1，False 会被当做 0。

print(int(True))
print(int(False))

输出：

1
0

bool() 可以把其他类型「转换」成布尔类型

0、空字符串、空列表、空元祖会被转成 False
其他变量都会转成 True

print(bool(1))
print(bool(0))
print(bool(''))
print(bool([]))
print(bool({}))

输出：

True
False
False
False
False

2.4、列表

列表用中括号[]包裹，元素之间使用逗号,分隔。

创建列表类型的变量

list1 = [1, 2, 3]

读取整个列表

list1 = [1, 2, 3]

print(list1)

输出：

[1, 2, 3]

通过索引，读取列表中的某个元素，索引从 0 开始。

list1 = [1, 2, 3]

print(list1[1])

输出：

读取第1~3个元素，含头不含尾[1~3)

list1 = [1, 2, 3, 4, 5]

print(list1[1:3])

输出：

[2, 3]

列表中的元素可以修改。

比如，修改一个元素

list1 = [1, 2, 3, 4, 5]

list1[1] = '张三'
print(list1)

输出：

[1, '张三', 3, 4, 5]

修改多个元素

list1 = [1, 2, 3, 4, 5]

list1[1:3] = '张三', '李四'
print(list1)

输出：

[1, '张三', '李四', 4, 5]

列表可以配合一些「运算符」，简化列表的操作

运算符	描述
list[] + list[]	拼接列表
list[] * n	重复列表
k in list[]	判断元素是否在列表中
for k in list[]：print( k )	迭代

加号 + 可以拼接两个列表，返回一个新的列表

list1 = [1, 2, 3]
list2 = [4, 5, 6]

new_list = list1 + list2
print(new_list)

输出：

[1, 2, 3, 4, 5, 6]

乘号 * 可以将列表重复拼接多次，返回一个新的列表

list1 = [1, 2, 3]

new_list = list1 * 3
print(new_list)

输出：

[1, 2, 3, 1, 2, 3, 1, 2, 3]

in 可以判断列表中是否存在某个元素，存在返回True，不存在返回False

list1 = [1, 2, 3]

print(1 in list1)

输出：

True

使用「迭代」的方式，可以更简洁的遍历列表的每一个元素

list1 = [1, 2, 3]

for k in list1:
    print(k)

输出：

1
2
3

2.5、元组

元组用小括号()包裹，元素之间用逗号,分隔。

创建元组类型的变量

tuple1 = (1, 2, 3, 4)

和列表、字符串一样，也能通过索引读取。

tuple1 = (1, 2, 3, 4)

print(tuple1)
print(tuple1[1])
print(tuple1[1:3])

输出：

(1, 2, 3, 4)
2
(2, 3)

元组是不可变类型，元素不可以修改，否则会报错 TypeError: ‘tuple’ object does not support item assignment

tuple1 = (1, 2, 3, 4)

tuple1[1] = 3

输出：

在这里插入图片描述

虽然元组不可变，但可以配合一些「运算符」，改成新的元组。

操作符	描述
tuple() + tuple()	拼接元组
tuple() * n	重复元组
k in tuple()	元组中是否包含某个值
for k in tuple() : print( k )	迭代遍历

加号 + 可以将两个元组「拼接」成一个新的元组

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

new_tuple = tuple1 + tuple2
print(new_tuple)

输出：

(1, 2, 3, 4, 5, 6)

乘号 * 可以将元组的内容「复制」多次，并生成一个新的元组

tuple1 = (1, 2, 3)
new_tuple = tuple1 * 3
print(new_tuple)

输出：

(1, 2, 3, 1, 2, 3, 1, 2, 3)

关键字 in 可以判断指定值是否在元组中存在，存在返回True，不存在返回False

tuple1 = (1, 2, 3)
print(1 in tuple1)
print(10 in tuple1)

输出：

True
False

使用「迭代」的方式，快速「遍历」列表中的元素

tuple1 = (1, 2, 3)
for k in tuple1:
    print(k)

输出：

1
2
3

2.6、集合

集合用大括号{}包裹，元素之间用逗号,分隔。

创建集合类型的变量

set1 = {1, 2, 3, 4}

集合没有下标，不能通过索引的方式读取，只能全部读取

set1 = {1, 2, 3, 4}

print(set1)

输出：

{1, 2, 3, 4}

集合的元素不允许重复，这个特点常被用来去重。

set() 函数可以将其他类型转成集合类型。

比如，给列表中的元素去重

list1 = [1, 1, 2, 2]

set1 = set(list1)
print(set1)

输出：

{1, 2}

集合有一些「操作符」，可以简化操作

操作符	描述
k in set()	判断集合中是否存在指定内容
for k in set() : prin( k )	迭代遍历

关键字 in 可以判断某个值是否在集合中存在，存在返回True，不存在返回False。

set1 = {1, 2, 3}
print(1 in set1)
print(10 in set1)

输出：

True
False

使用「迭代」的方式快速「遍历」集合中的元素

set1 = {1, 2, 3}
for k in set1:
    print(k)

输出：

1
2
3

2.7、字典

字典用大括号{}包裹，元素由键值对key:value组成，元素之间用逗号,分隔，键和值之间用冒号:分隔

创建字典类型的变量

dict1 = {1: 1, 'key1': 'value1'}

字典可以根据键来读取值，和索引有些类似。

dict1 = {1: 1, 'key1': 'value1'}

print(dict1)
print(dict1['key1'])

输出：

{1: 1, 'key1': 'value1'}
value1

字典可以修改值，但不能修改键。并且键唯一，不可重复。

dict1 = {1: 1, 'key1': 'value1'}

dict1['key1'] = 1
print(dict1)

输出：

{1: 1, 'key1': 1}

2.8、二进制序列

bytes类型使用单双引号包裹，并在前面加上 b

bytes类型常用来处理二进制数据，比如视频、图片等。

创建bytes类型的变量

bytes1 = b'12345'

bytes类型也可以通过索引读取

bytes1 = b'12345'

print(bytes1)
print(bytes1[1])
print(bytes1[1:3])

输出：

b'12345'
50
b'23'

这里需要注意：bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

3、数据类型转换

type() 函数可以查看数据的「类型」，比如下面这个就是字符串类型（str）

str1 = 'abc'
print(type(str1))

输出：

<class 'str'>

数据之间可以进行类型转换，转换的方式有两种：「隐式类型转换」、「显式类型转换」。

3.1、隐式类型转换

在运算等场景时，Python会「自动」将一种数据类型转换成另一种数据类型，这种自动发生的类型转换，就是「隐式类型转换」。

比如整数和浮点数进行运算时，会先将整数转换成浮点数，再进行运算

int1 = 2
float1 = 2.01
result = int1 + float1

print('整数：', type(int1))
print('浮点数：', type(float1))
print('运算结果是浮点数：', type(result))

输出：

整数： <class 'int'>
浮点数： <class 'float'>
运算结果是浮点数： <class 'float'>

隐式类型转换只能转换「一小部分」，比如数字和字符串进行运算时，字符串就不能自动转换成数字

int1 = 2
str1 = '3'

print('整数：', type(int1))
print('字符串：', type(str1))

int1 + str1

输出：

整数： <class 'int'>
字符串： <class 'str'>
Traceback (most recent call last):
  File "E:/data/PrCharm/pythonProject1/test.py", line 8, in <module>
    int1 + str1
TypeError: unsupported operand type(s) for +: 'int' and 'str'

这种情况下，我们可以使用「显式类型转换」。

3.2、显式类型转换

「显式类型转换」需要使用「函数」来转换数据类型，Python「内置」了一些类型转换的函数：

提示：点击列表中蓝色「函数名」可直达函数解析区域

函数名	作用	使用
int	转换为整型	int( value )
float	转换为浮点型	float( value )
str	转换为字符串	str( value )
bool	转换为布尔类型	bool( value )
list	转换为列表	list( value )
tuple	转换为元祖	tuple( value )
set	转换为集合	set( value )

int() 可以将一个「字符串」或「数字」转成「整型」

语法

int( value )

参数

value：需要转换的数据
返回值：转换后的数据（int类型）

浮点型（ float）转换为整型，「只取整数」，不关心小数位（不存在四舍五入）

float1 = 1.1
float2 = 1.9
print('小数位小于5时：', int(float1))
print('小数位大于5时：', int(float2))

输出：

小数位小于5时： 1
小数位大于5时： 1

内容为「纯整数」的字符串可以转换为整型

例：’111‘可以转，’111a’或‘3.14’不可以转

str1 = '111'
print('内容为纯整数的字符串：', int(str1))

输出：

内容为纯整数的字符串： 111

其他数据类型可以使用 float() 函数转换为「浮点型」（ float类型）

语法

float( value )

参数

value：需要转换类型的数据
返回值：转换后的数据（float类型）

「整型」（ int 类型）转换为浮点型

int1 = 111
print('整型（int类型）：', float(int1))

输出：

整型（int类型）： 111.0

内容为「纯数字」（整数或小数）的字符串可以转换为浮点型

str1 = '111'
str2 = '111.11'
print('内容为纯整型的字符串：', float(str1))
print('内容为纯浮点型的字符串：', float(str2))

输出：

内容为纯整型的字符串： 111.0
内容为纯浮点型的字符串： 111.11

str() 可以将「任意类型」转成「字符串」。

语法

str( value )

参数

value：需要转换类型的数据
返回值：转换后的数据（str类型）

int1 = 111
float1 = 11.1
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
dict = {'name': 'value'}
print('整型：', str(int1))
print('浮点型：', str(float1))
print('列表：', str(list1))
print('元祖：', str(tuple1))
print('集合：', str(set1))
print('字典：', str(dict))

输出：

整型： 111
浮点型： 11.1
列表： [1, 2, 3]
元祖： (1, 2, 3)
集合： {1, 2, 3}
字典： {'name': 'value'}

其他数据类型可以使用 bool() 函数转换为「布尔」类型
语法

bool( value )

参数

value：需要转换类型的数据
返回值：转换后的数据（bool类型）

空值（ None , 0 , " " , () , [] , {} ）转换为 False，其他值转为 True

None1 = None
int1 = 0
str1 = ""
list1 = []
tuple1 = ()
set1 = {}
print('None：', bool(None1))
print('数字 0：', bool(int1))
print('空字符串：', bool(str1))
print('空列表：', bool(list1))
print('空字典：', bool(tuple1))
print('空集合：', bool(set1))

输出：

None： False
数字 0： False
空字符串： False
空列表： False
空字典： False
空集合： False

list() 可以将「元组」或「字符串」转成「列表」

语法

list( value )

参数

value：需要转换为列表类型的数据
返回值：转换后的数据（list类型）

「可迭代对象」（ str, tuple, set, dict ）可以转换为列表

str1 = '111'
tuple1 = (1, 2, 3)
set1 = {1, 2, 3}
print('字符串：', list(str1))
print('元祖：', list(tuple1))
print('集合：', list(set1))

输出：

字符串： ['1', '1', '1']
元祖： [1, 2, 3]
集合： [1, 2, 3]

tuple() 可以将「可迭代序列」转换成「元组」

语法

tuple( value )

参数

value：需要转换的数据
返回值：转换后的数据（tuple类型）

「可迭代对象」（str, list, set, dict ）可以转化为元祖

str1 = '111'
list1 = [1, 2, 3]
set1 = {1, 2, 3}
dict1 = {'name': 'value'}
print('字符串：', tuple(str1))
print('列表：', tuple(list1))
print('元祖：', tuple(set1))
print('字典：', tuple(dict1))

输出：

字符串： ('1', '1', '1')
列表： (1, 2, 3)
元祖： (1, 2, 3)
字典： ('name',)

其他数据类型可以使用 set() 函数转换为「集合」（set类型）

语法

set( value )

参数

value：需要转换类型的数据
返回值：转换后的数据（set类型）

「可迭代对象」可以转换为集合

str1 = '111'
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
dict1 = {'name': 'value'}
print('字符串：', set(str1))
print('列表：', set(list1))
print('元祖：', set(tuple1))
print('字典：', set(dict1))

输出：

字符串： {'1'}
列表： {1, 2, 3}
元祖： {1, 2, 3}
字典： {'name'}

4、运算符

运算符用来对变量和值「执行操作」

4.1、算术运算符

运算符	作用	使用
+	加	1 + 2
-	减	2 - 1
*	乘	1 * 2
/	除	1 / 2
%	取余	1 % 2
**	幂	1 ** 2
//	取整除	1 // 2

算术运算符常用于「数字」之间的运算

a = 2
b = 3
print('a加b的结果是：', a + b)
print('a减b的结果是：', a - b)
print('a乘b的结果是：', a * b)  
print('a除b的结果是：', a / b)  
print('a除b的余数是：', a % b)  
print('a的b次方是：', a ** b)  
print('a除b取整是：', a // b)

输出：

a加b的结果是： 5
a减b的结果是： -1
a乘b的结果是： 6
a除b的结果是： 0.6666666666666666
a除b的余数是： 2
a的b次方是： 8
a除b取整是： 0

4.2、比较运算符

运算符	作用	使用
==	等于	a == b
!=	不等于	a != b
>	大于	a > b
<	小于	a < b
>=	大于或等于	a >= b
<=	小于或等于	a <= b

比较运算符常用于「比较」两个值，返回结果为 True 或 False

a = 2
b = 3
print('a是否等于b：', a == b)
print('a是否不等于b：', a != b)
print('a是否大于b：', a > b)
print('a是否小于b：', a < b)
print('a是否大于或等于b：', a >= b)
print('a是否小于等于b：', a <= b)

输出：

a是否等于b： False
a是否不等于b： True
a是否大于b： False
a是否小于b： True
a是否大于或等于b： False
a是否小于等于b： True

4.3、逻辑运算符

运算符	作用	使用
and	逻辑与，两个条件都为真，则返回 True	a > 1 and a < 3
or	逻辑或，只要有一个条件为真，就返回 True	a > 1 or a < 3
not	逻辑非，反转结果	not( a > 1)

逻辑运算符可以同时判断「多个条件」

a = 2
b = 3
print('两个条件都成立：', a > 1 and a > b)
print('只有一个成立：', a > 1 or a > b)
print('结果取反：', not( True ))

输出：

两个条件都成立： False
只有一个成立： True
结果取反： False

4.4、身份运算符

运算符	作用	使用
is	同一个对象，则返回 True	a is b
is not	不是同一个对象，则返回 True	a is not b

身份运算符常用来比较「对象」（同一个对象的内存地址相同）

a = 2
b = 3
print('a和a是否是同一个对象：',  a is a)
print('a和b是否是同一个对象：',  a is b)
print('a和a是否不是同一个对象：',  a is not a)
print('a和b是否不是同一个对象：', a is not b)

输出：

a和a是否是同一个对象： True
a和b是否是同一个对象： False
a和a是否不是同一个对象： False
a和b是否不是同一个对象： True

4.5、成员运算符

运算符	作用	使用
in	对象中存在指定内容，则返回 True	a in b
not in	对象中不存在指定内容，则返回 False	a not in b

成员运算符常用来判断对象中是否「包含」指定内容

a = 'a'
b = 'abc'
print('b中是否包含a：', a in b)  
print('b中是否不包含a：', a not in b) 
``
输出：

```powershell
b中是否包含a： True
b中是否不包含a： False

4.6、位运算符

运算符	作用	使用
&	位与，	如果两个位均为 1，则将每个位设为 1
\|	位或，	如果两位中的一位为 1，则将每个位设为 1
^	位异或，	如果两个位中只有一位为 1，则将每个位设为 1
~	位求反，	反转所有位
<<	左移位	通过从右侧推入零来向左移动，推掉最左边的位
>>	又移位	通过从左侧推入最左边的位的副本向右移动，推掉最右边的位

4.7、赋值运算符

运算符	作用	使用
=	赋值	name = ‘张三’

赋值运算符常用于给变量「赋值」，可配合算术运算符「叠加」运算

a = 3
print('给a赋值3后，a的值：', a)
a += 3
print('a += 3 等价于 a = a+3，a的值：',a)
a *= 3
print('a *= 3 等价于 a = a*3，a的值：', a)

输出：

给a赋值3后，a的值： 3
a += 3 等价于 a = a+3，a的值： 6
a *= 3 等价于 a = a*3，a的值： 18

5、函数

函数就是把具有「独立功能」的代码块封装成一个小模块,可以直接调用,从而提高代码的编写「效率」以及重用性

语法

def 函数名（ 参数1, 参数2, ……）:
	代码块（函数调用时执行）

使用 def 关键字创建函数，根据「函数名」调用函数
注意：Python中的函数调用必须在函数定义之后

def fun():
    print('函数内容')
    
fun()  # 调用函数

输出：

函数内容

函数被「调用」才会执行，「不调用」则不执行

def fun1():
    print('函数1被执行了')

def fun2():
    print('函数2被执行了')

fun1()

输出：

函数1被执行了

5.1、参数

函数可以接收参数，并在函数内使用，参数「数量不限」，多个参数之间使用「逗号」分隔

text1 = '参数1'
text2 = '参数2'

def fun(text1, text2):
    print(text1)
    print(text1)

fun(text1, text2)

输出：

参数1
参数1

参数可以是「任意类型」

list1 = [1, 2, 3]

def fun(list1):
    print('列表类型的参数：', list1)

fun(list1)

输出：

列表类型的参数： [1, 2, 3]

Python中的变量遵守「就近原则」，比如函数里面和外面有两个名字相同的变量，函数就会使用「里面」的变量，而不是外面的变量。

# 函数外面的变量
money = 18

def function1():
    # 函数里面的变量
    money = 20
    print(money)

function1()

开发时，如果搞混了这些「名字相同」的变量，可能会出现意料之外的情况。为了避免出现这类问题，函数采用了参数传递的方式。

给函数传两个参数，并在函数内调用

name = 'ZhangSan'
money = 18

def function1( name, money):
    print('我的名字是', name, '我有', money, '块钱！')

function1( name, money)

输出：

我的名字是 ZhangSan 我有 18 块钱！

函数创建时，括号里的参数叫「形参」（形式参数），用来接收参数。

函数调用时，括号里的参数叫「实参」（实际参数），用来实际使用。

形参和实参的「名字」可以「不同」。

比如，我把参数名字随便改成其他的名字，仍然可以正常调用。当然，实际开发时，建议根据作用来命名参数。

name = 'ZhangSan'
money = 18

# 1、函数定义时，接收形参
def function1( a, b):
    print('我的名字是', a, '我有', b, '块钱！')

# 2、函数调用时，传入实参
function1( name, money)

输出：

我的名字是 ZhangSan 我有 18 块钱！

函数调用时，参数的「数量」和「位置」必须和函数创建时一样。

name = 'ZhangSan'
money = 18

def function1( a, b):
    print('第一个参数：', a)
    print('第二个参数：', b)

function1( name, money)

输出：

第一个参数： ZhangSan
第二个参数： 18

如果参数的「数量不对」，会报错 TypeError。

在这里插入图片描述

如果参数的「位置不对」，会不符合预期。

name = 'ZhangSan'
money = 18

def function1( a, b):
    print('我的名字是：', a, '我有', b, '快钱！')

function1( money, name)

输出：

我的名字是： 18 我有 ZhangSan 快钱！

缺省参数也叫「默认参数」，在函数定义时，给参数指定「默认值」。

拥有默认值的参数，在函数调用时可以「不传值」：

如果传值，参数就会使用传入的新值
如果不传值，参数就会使用默认值

name = 'ZhangSan'
money = 18

# 1、参数设置默认值
def function1( a, b = 28):
    print('我的名字是：', a, '我有', b, '块钱！')

# 2、传值
function1( name, money)
# 3、不传值
function1( name)

输出：

我的名字是： ZhangSan 我有 18 块钱！
我的名字是： ZhangSan 我有 28 块钱！

Python变量的类型中，整型、字符串、元组属于「不可变类型」，列表、字典等属于「可变类型」。

函数接收「不可变类型」的参数，采用「值传递」，只是修改另一个复制的变量，不会改变原变量的值。
函数接收「可变类型」的参数，采用「引用传递」，会改变原变量的值。

str1 = 'ZhangSan'
list1 = [1, 2, 3]

# 修改传入的参数
def function1( str, list):
    str * 2
    list.append(4)

function1( str1, list1)

print(str1)
print(list1)

输出：

ZhangSan
[1, 2, 3, 4]

函数调用时，可以按照「参数关键字」给参数「赋值」。使用这种方式，可以不受参数顺序的限制。

name = 'ZhangSan'
money = 18

def function1( a, b):
    print('我的名字是', a, '我有', b, '块钱！')

# 关键字参数传参
function1( b=money, a=name)

输出：

我的名字是 ZhangSan 我有 18 块钱！

5.2、匿名函数

匿名函数不需要 def 来声明函数，而是用 lambda 表达式来创建函数。常用于处理简单的场景。

语法

函数名 = lambda [参数] : 代码块

lambda 表达式的格式是固定的，因此只能封装有限的代码进去。

实例：创建一个匿名函数，返回两个数相加之和。

function1 = lambda num1, num2: num1 + num2

result = function1(1, 2)
print(result)

输出：

5.3、函数的返回值

关键字 return 可以让函数返回一个值，比如将函数的执行结果返回，或者返回一个自定义的值。

返回多个值需要用逗号间隔；如果不指定值，就返回None。

def function1(a, b):
    return a + b

def function2(a, b):
    return '自定义的值'

def function3(a, b):
    return '第一个值', '第二个值'

def function4(a, b):
    return

print(function1(1, 2))
print(function2(1, 2))
print(function3(1, 2))
print(function4(1, 2))

输出：

3
自定义的值
('第一个值', '第二个值')
None

return 还有退出函数的作用， return 后面的代码不会被执行；如果一个函数内有多个 return ，则只返回第一个 return 的返回值。

def function1(a, b):
    return a + b
    print('return后面的代码')
    return '第二个返回值'

print(function1(1, 2))

输出：

5.4、递归

函数可以「自己调用自己」，即递归调用

注意：「单程递归」将耗尽计算机的算力，慎用

i = 1

def fun(i):
    print(i, '函数被调用了')
    i += 1
    fun(i)  # 递归调用

fun(i)

输出：

996 函数被调用了
……
RecursionError: maximum recursion depth exceeded while calling a Python object
# 递归异常： 达到最大递归深度（一种保护机制，防止算力耗尽）

5.5、数学函数

函数	描述
max()	返回序列中的最大值
min()	返回序列中的最小值
abs()	返回数字的绝对值
round()	四舍五入

max() 可以返回「最大值」。可接收多个参数，参数可以是「任意类型」。

「一个参数」时，参数必须是「可迭代对象」，会返回对象中最大的一个「元素」。

print(max('1234'))
print(max([1, 2, 3, 4]))
print(max((1, 2, 3, 4)))

# 字典返回最大的键，值不参与计算
print(max({1: 10, 2: 20}))

输出：

「多个参数」时，参数的类型必须「相同」，会返回最大的一个「参数」

print(max(10, 20, 30))
print(max([1, 2], [3, 4]))
print(max((1, 2), (3, 4)))

输出：

30
[3, 4]
(3, 4)

min() 可以返回「最小值」，用法跟 max() 一样。

abs() 可以返回数字的「绝对值」。对于小数，只保留小数点后一位。

print(abs(-10))
print(abs(-10.100000))

输出：

10
10.1

rount() 可以返回数字四舍五入后的结果。

print(round(1.6))
print(round(1.5))
print(round(1.4))

输出：

2
2
1

5.6、字符串函数

字符串是不可变类型，所以函数都会返回一个「新值」，原来的字符串则不会被「改变」。

函数名	描述	使用详解
capitalize()	首字母大写	文章链接：capitalize() 函数使用详解
center()	字符串居中	文章链接： center() 函数使用详解
count()	统计字符出现次数	文章链接： count() 函数使用详解
encode()	字符串编码/解码	文章链接： encode() 函数使用详解
endwith()	是否以指定字符结尾	文章链接：endswith()函数使用详解
startwith()	是否以指定字符开头	点我直达：startwith() 函数使用详解
fiind()	查找字符串	文章链接：find() 函数使用详解
isalnum()	是否只包含字母或数字	文章链接：isalnum() 函数使用详解
isalpha()	是否只包含字母和中文	文章链接：isalpha() 函数使用详解
isdigit()	是否只包含数字	文章链接：isdigit() 函数使用详解
islower()	是否只包含小写字母	文章链接：islower() 函数使用详解
isupper()	是否只包含大写字母	点我直达：isupper() 函数使用详解
join()	拼接字符串	文章链接： join() 函数使用详解
len()	字符串长度	点我直达： len() 函数使用详解
lower()	转为小写	点我直达：lower() 函数使用详解
upper()	转为大写	点我直达：upper() 函数使用详解
max()	返回最大的字符	点我直达：max() 函数使用详解
min()	返回最小的字符	点我直达： min() 函数使用详解
replace()	替换字符串	文章链接：replace() 函数使用详解
split()	分割字符串	文章链接： split() 函数使用详解
strip()	去除首尾的空格	点我直达：strip() 函数使用详解
swapcase()	大小写反转	点我直达：swapcase() 函数使用详解

startwith() 可以检查字符串否以指定字符「开头」

语法

str.startwith( str, start, end)

参数

str ：（必选）指定字符
start ：（可选）开始的索引
end：（可选）结束的索引

返回值

以指定字符开头就返回True
否则就返回False

实例

str1 = 'hello world'

print('是否以h开头：', str1.startswith('h'))
print('是否以he开头：', str1.startswith('he'))
print('第[1~结尾]个字符中，是否以e开头：', str1.startswith('e', 1))
print('第[1~3]个字符中，是否以e开头：', str1.startswith('e', 1, 3))

输出：

是否以h开头： True
是否以he开头： True
第[1~结尾]个字符中，是否以e开头： True
第[1~3]个字符中，是否以e开头： True

isupper() 可以检查字符串的「字母」是否全部都是「大写」

语法

str.isupper()

返回值

所有区分大小写的字符都是大写，就返回True
没有区分大小写的字符，或者区分大小写的字符并不全是大写，就返回False

实例

# 有区分大小写的字符，并全部大写
print('ABC'.isupper())
print('A 12 !@ 汉字'.isupper())

# 有区分大小写的字符，但不全是大写
print('aA'.isupper())
print('Aa 12 !@ 汉字'.isupper())

# 没有区分大小写的字符(数字、汉字、空格、特殊符号等)
print('123456 !@#$%^&* 汉字'.isupper())

输出：

True
True
False
False
False

len() 可以返回字符串的「长度」，如果是可迭代对象，就返回「元素个数」。

语法

len( element )

返回值

返回对象的长度（元素个数）

实例

# 汉字也算一个字符
print(len('abc'))
print(len('汉字'))

# 列表、元组等返回元素个数
print(len([1, 2, 3]))
print(len((1, 2, 3)))

# 字典返回键的个数
print(len({'key1': 1, 'key2': 2}))

输出：

lower() 可以将字符串中的字母转成「小写」，不区分大小写的字符不会改变。

语法

str.lower()

返回值

返回转成小写的新的字符串

实例

print('ABC'.lower())
print('ABc'.lower())
print('123 !@# ABc'.lower())

输出：

abc
abc
123 !@# abc

upper() 可以将字符串中的字母转成「大写」，不区分大小写的字符不会改变。

语法

str.upper()

返回值

返回转成大写后的新的字符串

print('abc'.upper())
print('abC'.upper())
print('123 !@# ABc'.upper())

输出：

ABC
ABC
123 !@# ABC

max() 可以返回给定参数的「最大值」。参数的「类型」必须相同。

语法

max( iterables )

参数

iterables ：（必选，可迭代对象）一个或多个参数

返回值

一个参数时，返回参数中最大的一个元素
多个参数时，返回最大的一个参数。

实例

# 一个参数，返回最大的元素
print(max('abc'))
print(max([1, 2, 3]))
print(max((1, 2, 3)))

# 多个元素，返回最大的参数
print(max('123', '456'))
print(max([1, 2], [3, 4]))
print(max((1, 2), (3, 4)))

输出：

c
3
3
456
[3, 4]
(3, 4)

min() 可以返回给定参数的「最小值」。参数「类型」必须相同。

语法

min( iterables )

参数

iterables ：（必选，可迭代对象）一个或多个参数

返回值

一个参数时，返回参数中最小的一个元素
多个参数时，返回最小的一个参数。

实例

# 一个参数，返回最小的元素
print(min('abc'))
print(min([1, 2, 3]))
print(min((1, 2, 3)))

# 多个元素，返回最小的参数
print(min('123', '456'))
print(min([1, 2], [3, 4]))
print(min((1, 2), (3, 4)))

输出：

a
1
1
123
[1, 2]
(1, 2)

strip() 可以「删除」字符串「两边」的指定字符，常用来去除两边的「空格」。

语法

str.strip( str )

参数

str ：指定删除的字符

返回值

实例

print('  hello world   '.strip())
print('aahello worldaaa'.strip('a'))

输出：

hello world
hello world

swapcase() 可以「反转」字符串的「大小写」。不区分大小写的字符不会改变。

语法

str.swapcase()

返回值

返回反转大小写后的新字符串

实例

print('aaa'.swapcase())
print('AAA'.swapcase())
print('a 123 !@# '.swapcase())

输出：

AAA
aaa
A 123 !@#

5.7、列表函数

函数	描述	使用详解
append()	末尾添加元素	文章链接：append()函数使用详解
count()	统计元素出现次数	文章链接： count() 函数使用详解
extend()	末尾添加序列	文章链接：extend()函数使用详解
index()	查找元素的索引	点击直达： index() 函数使用详解
insert()	指定位置插入元素	文章链接：insert() 函数使用详解
pop()	按照索引移除元素	文章链接： pop() 函数使用详解
remove()	按照内容移除元素	文章链接：remove() 函数使用详解
sort()	列表元素排序	文章链接： sort() 函数使用详解
reverse()	反转列表中元素的顺序	点我直达：reverse() 函数使用详解
clear()	清空列表	点我直达：clear() 函数使用详解
copy()	复制列表	点我直达：copy() 函数使用详解
len()	返回列表中元素的个数	点我直达：len() 函数使用详解
max()	返回列表中最大的元素	点我直达：max() 函数使用详解
min()	返回列表中最小的元素	点我直达：min() 函数使用详解
list()	将元组转换成列表

index() 可以返回「元素」第一次出现的「索引」位置。

语法

list.index( element, start, end)

参数

element ：（必选）需要查找的元素
start ：（可选）开始的索引
end ：（可选）结束的索引

实例

list1 = ['a', 'b', 'c']

print(list1.index('b'))

输出：

reverse() 可以「反转」列表中的「元素」顺序。

语法

list.reverse()

返回值

None，没有返回值，只是反转原列表中的元素顺序。

实例

list1 = [1, 2, 3]

list1.reverse()
print(list1)

输出：

[3, 2, 1]

clear() 可以「清空」列表。清空后变成「空列表」，且内存地址不变，并不是删除列表。

语法

list.clear()

实例

list1 = [1, 2, 3]

print('清空前的内存地址：', id(list1))
list1.clear()
print('清空后变成空列表：', list1)
print('清空后的内存地址：', id(list1))

输出：

清空前的内存地址： 1709999787200
清空后变成空列表： []
清空后的内存地址： 1709999787200

copy() 可以「复制」列表，属于「浅拷贝」，元素引用的序列发生改变时，列表中的元素会同步改变。

语法

list.copy()

返回值

返回一个浅拷贝的新列表。

实例

list1 = [1, 2, 3]
list2 = [1, list1, 3]

print('复制前的内存地址：', id(list2))
new_list = list2.copy()
print('复制后的内存地址：', id(new_list))
print('复制后的列表：', new_list)

list1[1] = 'abc'
print('元素引用的列表改变时，列表的元素同步改变：', new_list)

输出：

复制前的内存地址： 2291942231232
复制后的内存地址： 2291942607424
复制后的列表： [1, [1, 2, 3], 3]
元素引用的列表改变时，列表的元素同步改变： [1, [1, 'abc', 3], 3]

len() 可以返回列表的「长度」。与元素类型无关，只计算「元素」的个数。

语法

list.len()

返回值

返回元素的个数

实例

list1 = [1, 2, 3]
list2 = [1, list1, 3]

print(len(list1))
print(len(list2))

输出：

3
3

max() 可以返回列表中「最大」的元素。列表中所有的元素，必须是「相同」的类型。

实例

list1 = [1, 2, 3]

print(max(list1))

输出：

min() 可以返回列表中「最小」的元素。列表中所有元素的「类型」，必须「相同」。

实例

list1 = [1, 2, 3]

print(min(list1))

输出：

list() 可以将「元组」或「字符串」转成列表。

语法

list list( iterable )

参数

iterable ：（必选）需要转换的可迭代对象

返回值

返回转换后的列表

实例

print(list('abc'))
print(list((1, 2, 3)))

输出：

['a', 'b', 'c']
[1, 2, 3]

5.8、集合函数

函数	描述	使用详解
add()	添加元素	文章链接：add() 函数使用详解
clear()	清空集合	点我直达： clear() 函数使用详解
copy()	拷贝集合	点我直达：copy() 函数使用详解
difference()	返回多个集合的差集	点我直达：difference() 函数使用详解
difference_update()	删除多个集合的交集	点我直达：difference_update() 函数使用详解
discard()	删除元素	点我直达： discard() 函数使用详解
intersection()	返回多个集合的交集	点我直达： intersection() 函数使用详解
intersection_update()	删除多个集合的差集	点我直达： intersection_update()
isdisjoint()	判断两个集合是否包含相同的元素	点我直达： isdisjoint() 函数使用详解
issubset()	判断集合是否是另一个集合的子集	点我直达： issubset() 函数使用详解
issuperset()	判断集合是否是另一个集合的父集	点我直达： issuperset() 函数使用详解
pop()	随机删除元素	文章链接：pop() 函数使用详解
remove()	删除指定元素	文章链接：remove() 函数使用详解
symmetric_difference()	返回两个集合中不同的元素	点我直达： symmetric_difference() 函数使用详解
symmetric_difference_update()	删除与另一个集合重复的元素	点我直达： symmetric_difference_update() 函数使用详解
union()	随机删除元素	文章链接：union() 函数使用详解
update()	修改集合	点我直达： update() 函数使用详解

clear() 可以清空集合中的元素

set1 = {1, 2, 3}

set1.clear()
print(set1)

输出：

set()

copy() 可以拷贝集合

语法

set.copy()

返回值

返回一个内容相同的新集合

set1 = {1, 2, 3}

set2 = set1.copy()
print(set2)

输出：

{1, 2, 3}

这里的拷贝是浅拷贝，拷贝前后的两个集合内存地址不同，并且其中一个集合发生变化时，另一个集合不受影响。

set1 = {1, 2, 3}

set2 = set1.copy()
print('拷贝前的内存地址：', id(set1))
print('拷贝后的内存地址：', id(set2))

print('修改原列表前：', set2)
set1.add(4)
print('修改原列表后：', set2)

输出：

拷贝前的内存地址： 2150779800704
拷贝后的内存地址： 2150779798016
修改原列表前： {1, 2, 3}
修改原列表后： {1, 2, 3}

difference() 可以返回两个集合的差集作为一个新集合。

语法

set.difference( set )

参数

set：（必选）需要比较的集合

返回值

返回一个新集合，内容是两个集合的差集

差集指的是：第一个集合里有，但第二个集合里没有的元素。

set1 = {1, 2, 3}
set2 = {1, 4, 5}
print(set1.difference(set2))
print(set2.difference(set1))

输出：

{2, 3}
{4, 5}

difference_update() 可以删除两个集合中都存在的元素

语法

set.difference_update( set )

参数

set：（必选）需要比较的集合

set1 = {1, 2, 3}
set2 = {1, 4, 5}
set1.difference_update(set2)
print(set1)

输出：

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

discard() 可以删除集合中的元素，即使元素不存在也不会报错

语法

set.discard( value)

参数

value：（必选）需要删除的元素

set1 = {1, 2, 3}

set1.discard(2)
set1.discard(10)
print(set1)

输出：

{1, 3}

intersection() 可以返回两个或多个集合的交集

语法

set.intersection( set )

参数

set：（必选）需要比较的集合，可以传入多个集合

返回值

返回一个新的集合，内容是这些集合的交集。

set1 = {1, 2, 3}
set2 = {1, 3, 5}
print(set1.intersection(set2))
print(set2.intersection(set1))

输出：

{1, 3}
{1, 3}

intersection_update() 可以删除多个集合的差集

语法

set.intersection_update( set )

参数

set ：（必选）需要比较的集合

删除第一个集合里有，但第二个集合里没有的元素

set1 = {1, 2, 3}
set2 = {1, 3, 5}
set1.intersection_update(set2)
print(set1)
print(set2)

输出：

{1, 3}
{1, 3, 5}

isdisjoint() 可以判断两个集合是否包含相同的元素

语法

set.isdisjoint( set )

参数

set：（必选）需要比较的集合

返回值

包含相同的元素，返回False
不包含相同的元素，返回True

注意判断逻辑，不要搞混了。

set1 = {1, 2, 3}
set2 = {1, 3, 5}
set3 = [10, 20, 30]

print(set1.isdisjoint(set2))
print(set1.isdisjoint(set3))

输出：

False
True

issubset() 可以判断一个集合是否是另一个集合的子集

语法

set.issubset( set )

参数

set：（必选）需要比较的集合

返回值

第二个集合包含第一个集合的所有元素，返回True
否则，返回False

set1 = {1, 2, 3, 4}
set2 = {1, 2, 3}

print(set2.issubset(set1))

输出：

True

issuperset() 可判断一个集合是否是另一个集合的父集

语法

set.issuperset( set )

参数

set：需要比较的集合

返回值

第一个集合包含第二个集合的所有元素，返回True
否则，返回False

set1 = {1, 2, 3, 4}
set2 = {1, 2, 3}

print(set1.issuperset(set2))

symmetric_difference() 可以返回两个集合中不重复的元素集合。

语法

set.symmetric_difference( set )

参数

set：需要比较的集合

返回值

返回一个新集合，内容是两个集合中不重复的元素。

set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 2, 3}

new_set = set1.symmetric_difference(set2)
print(new_set)

输出：

{4, 5, 6}

symmetric_difference_update() 可以删除与另一个集合重复的元素。

语法

set.symmetric_difference_update( set )

参数

set：需要比较的集合

返回值

None，无返回值，只修改原集合

set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 2, 3}

set1.symmetric_difference_update(set2)

print(set1)
print(set2)

输出：

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

update() 可以给集合添加元素。添加的元素必须是可迭代类型。

语法

set.update( iterable )

参数

iterable：（必选）需要添加的元素

返回值

None，不返回值，只修改原集合

往集合中添加另一个集合的元素

set1 = {1, 2, 3}
set2 = {4, 5, 6}

set1.update(set2)
print(set1)

输出：

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

5.9、元祖函数

函数	描述
len()	返回元组长度
max()	返回最大的元素
min()	返回最小的元素
tuple()	将可迭代序列转成元组

len() 可以返回元组的「长度」，实际上是返回元组中元素的个数

tuple1 = (1, 2, 3)
print(len(tuple1))

输出：

max() 可以返回元组中「最大」的一个元素，可以同时传入多个参数，但参数的元素的类型必须全部相同。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# 一个参数返回最大的元素
print(max(tuple1))
# 多个参数返回最大的参数
print(max(tuple1, tuple2))

输出：

3
(4, 5, 6)

min() 可以返回元组中「最小」的元素，用法和 max() 一样。

tuple() 可以将可迭代序列「转成」元组类型

print(tuple('abc'))
print(tuple([1, 2, 3]))
print(tuple({'key1': 1, 'key2': 2}))

输出：

('a', 'b', 'c')
(1, 2, 3)
('key1', 'key2')

5.10、文件函数

Python中提供了一些函数以方便我们「操作文件」

open() 函数用来打开文件

语法

open( name, mode )

参数

name：文件路径
mode：可选，模式
返回值：文件对象

在 E 盘创建文件 a.txt ，使用 open() 函数打开该文件

file = open('E://a.txt')
print(file)

输出：

<_io.TextIOWrapper name='E://a.txt' mode='r' encoding='cp936'>

文件路径分为两种：

相对路径
绝对路径

相对路径是指「相对于当前文件」的路径
打开当前目录下的 a.txt 文件

file = open('a.txt')
print(file)

输出：

<_io.TextIOWrapper name='a.txt' mode='r' encoding='cp936'>

绝对路径是指文章在「电脑」中的位置

打开 E 盘 Python 目录下的 a.txt 文件

file = open('E://python/a.txt')
print(file)

输出：

<_io.TextIOWrapper name='E://python/a.txt' mode='r' encoding='cp936'>

修改参数 mode 的值，可以指定文件的「打开方式」

r：默认，读取，打开文件并读取，文件不存在则报错
a：修改，打开文件准备修改，文件不存在则创建
w：写入，打开文件准备写入，文件不存在则创建
x：创建文件，文件存在则报错

「打开模式」

t：默认，文本模式
b：二进制模式（图像）

以文本模式「读取」文件 a.txt

file = open('a.txt', 'rt')
print(file)

输出：

<_io.TextIOWrapper name='a.txt' mode='rt' encoding='cp936'>

在当前目录创建文件 b.txt

open('b.txt', 'x')

检查左侧目录，会多出一个文件 b.txt

read() 函数用来读取文件内容

语法

read( n )

参数

n：可选，读取几个字符
返回值：读取的内容

读取文件 a.txt 的全部内容

file = open('a.txt', encoding='utf-8')
text = file.read()
print(text)

输出：

第一行
第二行
第三行
第四行
……

读取文件 a.txt 的前 6个字符

file = open('a.txt', encoding='utf-8')
text = file.read(6)
print(text)

输出：

第一行
第二

readline() 函数可以读取一行内容
读取文件 a.txt 第一行内容

file = open('a.txt', encoding='utf-8')
text = file.readline()
print(text)

输出：

第一行

配合 for 循环读取多行内容，如读取 3 行

file = open('a.txt', encoding='utf-8')
i = 0
while i < 3:
    text = file.readline()
    print(text)
    i += 1

输出：

第一行

第二行

第三行

使用 for 循环遍历文件，「逐行读取」文件内容

file = open('a.txt', encoding='utf-8')
for text in file:
    print(text)

输出：

第一行
第二行
第三行
第四行
……

close() 函数可以关闭文件，如果文件未关闭，对文件的「修改」可能会「不生效」

file = open('a.txt', encoding='utf-8')
print(file.read(3))
file.close()

输出：

第一行

write() 函数可以向文件中写入内容
修改文件内容时，需要指定 open() 函数的参数

a：「追加」内容至文件末尾
w：「写入」内容至文件中（覆盖原文件内容）

向文件 a.txt 中追加内容

file = open('a.txt', 'a', encoding='utf-8')
file.write('新添加的内容')
file.close()

# 修改模式的文件不可读，需重新打开文件
file = open('a.txt', 'r', encoding='utf-8')
print(file.read())

输出：

第一行新添加的内容

向文件 a.txt 中写入内容（「覆盖」原内容）

file = open('a.txt', 'w', encoding='utf-8')
file.write('新添加的内容')
file.close()

# 修改模式的文件不可读，需重新打开文件
file = open('a.txt', 'r', encoding='utf-8')
print(file.read())

输出：

新添加的内容

exists() 函数可以判断「文件是否存在」
remove() 函数可以根据文件名「删除文件」

import os

if os.path.exists('a.txt'):
    print('文件存在，删除文件')
    os.remove('a.txt')
else:
    print('文件不存在，无法删除')

输出：

文件存在，删除文件

rmdir() 函数可以删除目录（文件夹）

import os

os.rmdir('mulu')

观察左侧目录，文件夹 mulu 已被删除

6、流程控制语句

一个程序往往包含多条代码，流程控制就是控制这些代码的「执行顺序」和「是否能够执行」的规则

在程序开发中,一共有三种「执行流程」

顺序执行：按照从上往下的顺序依次执行代码
分支执行：根据条件判断，决定执行代码的分支
循环执行：重复执行某一段代码

6.1、 if条件判断

if 是分支执行的一种语句，「满足条件」时才会执行代码，「不满足条件」则不执行

语法

if 条件:
	代码块(条件成立时执行)

如果条件（a大于b）「成立」，就执行对应的「代码块」（输出a>b）

a = 2
b = 1
if a > b:
    print('条件成立：a>b')

if a < b:
    print('条件不成立，不会执行')

输出：

条件成立：a>b

if 语句可配合逻辑运算符同时判断「多个条件」

a = 1
b = 2
c = 3
if a<b and b<c:
    print('条件成立，a<b<c')

输出：

条件成立，a<b<c

if 语句的代码块中可以「嵌套」 if 语句，无限套娃

a = 1
b = 2
if a<b:
    print('第一层if的条件成立了，进入下一层if')
    if b>a:
        print('第二层if的条件成立了')

输出：

第一层if的条件成立了，进入下一层if
第二层if的条件成立了

if else

语法

if 条件：
	代码块（条件成立时执行）
else:
	代码块（条件不成立时执行）

if 只能指定「条件成立」时的代码块， else 关键字可以指定「条件不成立」时执行的代码块

a = 2
b = 1
if a < b:
    print('条件成立：a>b')
else:
    print('条件不成立：a<b')

输出：

条件不成立：a<b

if else 可以简写为一行，前提是「每个条件」只对应「一行代码」

a = 2
b = 1
print('条件成立：a>b') if a<b else print('条件不成立：a<b')

输出：

条件不成立：a<b

el if
elif 关键字可以进行「多次条件判断」

a = 1
b = 2
if a>b:
    print('第一个条件成立：a>b')
elif a==b:
    print('第二个条件成立：a=b')
elif a<b:
    print('第三个条件成立：b<a')
else:
    print('以上条件都不成立')
    print('以上条件都不成立')

输出：

第三个条件成立：b<a

6.2、 while循环

while 是循环执行的一种语句，条件成立时「多次执行」代码，不成立则不执行，常用来「重复」处理相同的任务。

语法

while 条件：
	代码块（条件成立时执行）

执行 3 次打印☆的操作

注意：用于判断的条件最好有一个「不满足」的可能性，否则循环会一直进行

i = 1
while i <7:
    print('☆')
    i += 1

输出：

☆
☆
☆

6.3、 for循环

for 是循环执行的一种语句，常用于「迭代序列」，类似其他语言中的迭代器

for 循环可以遍历字符串、列表、元祖、集合、字典等序列

list1 = [1, 2, 3]
for l in list1:
    print(l)

输出：

1
2
3

6.4、 break

break 关键字可以结束整个循环，不执行剩余代码块

循环执行 i+1 的操作，当 i>3 时，结束循环

i = 1
while True:
    print('i的值是：', i)
    i += 1
    if i >3:
        print('结束整个循环')
        break

输出：

i的值是： 1
i的值是： 2
i的值是： 3
结束整个循环

6.5、 continue

continue 关键字可以结束本次循环，不执行剩余代码块

循环执行 i+1 的操作，打印 1~4，但不打印 3

i = 0
while i < 4:
    i += 1
    if i == 3:
        print('i的值为3，跳过本次循环')
        continue
    print(i)

输出：

1
2
i的值为3，跳过本次循环
4

士别三日wyx

关注

74
点赞
踩
97

收藏

觉得还不错? 一键收藏
打赏
61
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

Python入门教程（超详细）

Python

0. Hello Python

1、语法

1.1、缩进

1.2、注释

1.3、变量

2、数据类型

2.1、数字

2.2、字符串

2.3、布尔

2.4、列表

2.5、元组

2.6、集合

2.7、字典

2.8、二进制序列

3、数据类型转换

3.1、隐式类型转换

3.2、显式类型转换

4、运算符

4.1、算术运算符

4.2、比较运算符

4.3、逻辑运算符

4.4、身份运算符

4.5、成员运算符

4.6、 位运算符

4.7、赋值运算符

5、函数

5.1、 参数

5.2、匿名函数

5.3、函数的返回值

5.4、 递归

5.5、数学函数

5.6、字符串函数

5.7、列表函数

5.8、集合函数

5.9、元祖函数

5.10、 文件函数

6、流程控制语句

6.1、 if条件判断

6.2、 while循环

6.3、 for循环

6.4、 break

6.5、 continue

4.6、位运算符

5.1、参数

5.4、递归

5.10、文件函数