Hello World!

例：输出Hello World!。

1	print("Hello World!")

结果展示：

1	Hello World!

注释

注释是对代码的解释说明，计算机并不会执行。

单行注释

以#开头，#右边的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用。

例：输出Hello World!，后面需要有相应的注释。

1	print("Hello World!") #输出Hello World!

结果展示：

1	Hello World!

多行注释

多行注释需要用三个单引号，即三个'包裹起来。

例：书写一段多行注释，第一行为比格沃斯，第二行为Bigglesworth。

'''
    比格沃斯
    Bigglesworth
'''

字面量

在代码中，被写下来的固定值，被称为字面量。

常用的值的类型

类型	描述	说明
数字（Number）	支持整数（int）浮点数（float）复数（complex）布尔（bool）	整数（int），如：10、-10 浮点数（float），如：13.14、-13.14 复数（complex），如：4+3j，以j结尾表示复数布尔（float）表达现实生活中的逻辑，即真和假，`True`表示真，`False`表示假。`True`的本质是一个数字记作1，`False`记作0
字符串（String）	描述文本的一种数据类型	字符串（String）是由任意数量的字符组成
列表（List）	有序的可变序列	Python中使用最频繁的数据类型，可以有序记录一堆数据
元组（Tuple）	有序的不可变序列	可有序记录一堆不可变的Python数据集合
集合（Set）	无序不重复集合	可无序记录一堆不重复的Python数据集合
字典（Dictionary）	无序Key-Value集合	可无序记录一堆Key-Value型的Python数据集合

字符串

又称为文本，是由任意数量的字符，如中文、英文、各类符号、数字等组成。所以叫做字符的串。

如：

“Bigglesworth”
“XXX的编号是：114514”
“今天是星期二”

在Python中，字符串需要使用双引号""包裹起来。

被引号包裹起来的均为字符串。

输出字面量

使用print()函数将字面量打印在屏幕上。

例：分别输出13.14，666,Bigglesworth。

1
2
3

print(13.14)
print(666)
print("Bigglesworth")

结果展示：

1
2
3

13.14
666
Bigglesworth

变量

变量指的是在程序运行时，能储存计算结果或能表示值的抽象概念。

简单来说，变量就是在程序运行时，记录数据用的。

变量的定义格式

格式：变量名称 = 变量的值

每一个变量都有自己的名称，称之为：变量名也就是变量本身。

每一个变量都有自己存储的值（内容），称之为：变量值。

赋值，表示将等号右侧的值，赋值给左侧的变量。

例：定义一个变量score，其值为13，并将其输出。

1 2	score = 13 print("得分为：", score)

结果展示：

得分为： 13

变量运算

变量可以直接当作其存储的内容进行运算。

例：将score的值增加2并输出。

score = 13
print("得分为：", score)
score = score + 2
print("变化后的得分为：", score)

结果展示：

1 2	得分为： 13 变化后的得分为： 15

数据类型

直接输出类型信息

使用type()可以输出一个字面量或者变量的类型信息。

例：分别输出Bigglesworth，3.1415926，3+4j的类型信息。

1
2
3

print(type("Bigglesworth"))
print(type(3.1415926))
print(type(3+4j))

结果展示：

1
2
3

<class 'str'>
<class 'float'>
<class 'complex'>

存储类型信息结果

可以使用一个变量用来存储type()的返回结果，该结果被称作返回值。

例：利用type()获取114514的数据类型，将其存储在Type变量中并输出。

1 2	Type = type(114514) print(Type)

结果展示：

1	<class 'int'>

查看变量中存储的数据类型

例：定义一个变量name，其存储的内容为Bigglesworth，输出其数据类型。

1 2	name = "Bigglesworth" print(type(name)))

结果展示：

1	<class 'str'>

数据类型的转换

常见的转换语句

语句（函数）	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将对象x转换为字符串

注：这三条语句均有返回值。

例：将字符串类型的3.1415926转换为浮点数类型。

number = "3.1415926"
print(type(number), number)
number = float(number)
print(type(number), number)

结果展示：

1 2	<class 'str'> 3.1415926 <class 'float'> 3.1415926

注：

可以将任何东西转换为字符串，但是字符串转成别的数据类型的时候需要注意是否合法，比如如果要将一个字符串转换为整型，则需要注意字符串内是否全都是数字。
在整型转换为浮点型的时候，会默认加上一个.0，因为浮点类型默认带小数。
在浮点型转换为整型的时候，会将小数点后的数据直接舍去。

标识符

标识符的定义

在Python程序中，我们可以给很多东西起名字，例如变量、函数、类等等，这些名字被统称为标识符，用来做内容的标识。

标识符命名规则

命名规则主要有三点：

内容限定
大小写敏感
不可使用关键字

内容限定

标识符命名中，只允许出现：

英文
中文
数字
下划线

注意点：

虽然Python支持中文作为标识符，但是尽量不要去使用。
开头不可以是数字

大小写敏感

两个标识符字母都一样，唯一的区别是字母的大小写不一样，那么也是可以正确区分的。

不可使用关键字

Python中有一系列单词，称之为关键字，关键字在Python中都有特定的用途，我们不可以使用它们作为标识符。

运算符

算术运算符

设a=10，b=20

运算符	描述	实例
+	加	两个对象相加a + b输出结果30
-	减	两个对象相减a - b输出结果-10
*	乘	两个数相乘或是返回一个被重复若干次的字符串a * b输出结果200
/	除	b / a输出结果2
//	取整除	返回商的整数部分9//2输出结果4,9.0//2.0输出结果4.0
%	取余	返回除法的余数b % a输出结果0
**	指数	a**b为10的20次方

例：计算上表中的实例。

a=10
b=20
print("a + b =", a + b)
print("a - b =", a - b)
print("a * b =", a * b)
print("b / a =", b / a)
print("9 // 2 =", 9 // 2)
print("9.0 // 2.0 =", 9.0 // 2.0)
print("b % a =", b % a)
print("a ** b =", a ** b)

结果展示：

a + b = 30
a - b = -10
a * b = 200
b / a = 2.0
9 // 2 = 4
9.0 // 2.0 = 4.0
b % a = 0
a ** b = 100000000000000000000

赋值运算符

基础赋值运算符

运算符	描述	实例
=	赋值运算符	把 = 右边的结果赋值给左边的变量

复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

字符串扩展

字符串的三种定义方式

字符串在Python中有多种定义形式：

单引号定义法：name = 'Bigglesworth'
双引号定义法：name = "Bigglesworth"
三引号定义法：name = '''Bigglesworth'''

三引号定义法，和多行注释的写法一样，同样支持换行操作。

使用变量接收它，它就是字符串。

不使用变量去接收它，就可以作为多行注释使用。

Python中基本上不区分单引号和双引号。

字符串的引号嵌套

当字符串中有单引号或者双引号时，可以通过以下几种方法进行嵌套：

单引号定义法，可以内含双引号
双引号定义法，可以内含单引号
可以使用转义字符\来将引号解除效用，变成普通字符串

例：将"My name is 'Bigglesworth'"存储至变量sentence并输出。

1 2	sentence = "\"My name is \'Bigglesworth\'\"" print(sentence)

结果展示：

1	"My name is 'Bigglesworth'"

字符串拼接

如果我们有两个字符串字面量，可以将其拼接成一个字符串，通过+号即可完成。

例：将My name is 和Bigglesworth拼接在一起。

1	print("My name is " + "Bigglesworth")

结果展示：

1	My name is Bigglesworth

字面量和变量或变量和变量之间会使用拼接。

例：将九磅十五便士存入变量money中，利用字符串拼接输出衬衫的价格为九磅十五便士。

1 2	money = "九磅十五便士" print("衬衫的价格是" + money)

结果展示：

1	衬衫的价格是九磅十五便士

注：字符串不能与整数或者浮点数之类的进行拼接。

字符串格式化

普通格式化

通过格式符号来进行占位，然后将变量（该变量可以是任意类型的变量）编程字符串放入占位的地方。

常用的格式符号：

格式符号	转化
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点型，放入占位位置

例：输出我的年龄是19岁，班级号为2001，其中数字使用字符串格式化操作。

age = 19
class_num = 2001
message = "我的年龄是%d岁，班级号为%d" % (age, class_num)
print(message)

结果展示：

1	我的年龄是19岁，班级号为2001

注：对于多个变量占位的情况，变量要用括号括起来，并按照占位的顺序填入。

快速格式化

语法：f"内容{变量}"

例：将上述例子利用快速格式化进行输出。

age = 19
class_num = 2001
message = f"我的年龄是{age}岁，班级号为{class_num}"
print(message)

结果展示：

1	我的年龄是19岁，班级号为2001

格式化的精度控制

我们可以使用辅助符号m.n来控制数据的宽度和精度。

m用来控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效
.n用来控制小数点精度，要求是数字，会进行小数的四舍五入

示例：

%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度。
%5.2f：表示将宽度控制为5，将小数点精度设置为2；小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35
%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%2.f后，结果为11.35.

表达式格式化

表达式：一条具有明确执行结果的代码语句。

在无需使用变量进行数据存储的时候，可以直接格式化表达式，简化代码。

例：计算2 * 5的值。

1	print(f"2 * 5的结果是：{2 * 5}")

结果展示：

1	2 * 5的结果是：10

数据输出

字面量输出

直接输出要输出的内容。

例：

1 2	print(3.1415926) print("Biggleswotrh")

结果展示：

1 2	3.1415926 Biggleswotrh

变量输出

可以直接输出一个变量的值。

例：

1 2	a = 10086 print(a)

结果展示：

end输出

一般情况下，直接利用print函数输出会默认换行，因此可以在print()的括号中的最后加上, end = ''，可以防止其自动换行，当然也可以在end里面加上内容，作为输出的结尾。

例：

1
2
3

print("Bigglesworth", end = '')
print(3.14)
print(6.28, end = 'a')

结果展示：

1 2	Bigglesworth3.14 6.28a

加号拼接

该方法只针对于字符串，通过加号来对字符串进行拼接。

例：

str1 = "27.56"
float1 = 27.56
print("数据为：" + str1)
print("数据为：" + str(float1))

结果展示：

1 2	数据为：27.56 数据为：27.56

format格式

利用format来进行输出，在print中用花括号进行占位，花括号中的值代表后面占位的字面量或者变量的顺序。

例：

a = 27.56
b = 28.99
c = 29.66
print("数据为：{}".format(b))
print("abc的数据分别为：{0}，{1}，{2}".format(a, b, c))
print("abc的数据分别为：{1}，{0}，{2}".format(a, b, c))

结果展示：

1
2
3

数据为：28.99
abc的数据分别为：27.56，28.99，29.66
abc的数据分别为：28.99，27.56，29.66

print(f”{}”)用法

该用法在上述中提到过，与其使用方法一致。

例：

a = 27.56
b = 28.99
c = 29.66
print(f"数据为：{a}")
print(f"abc的数据分别为：{a}，{b}，{c}")

结果展示：

1 2	数据为：27.56 abc的数据分别为：27.56，28.99，29.66

格式化输出

字符	含有
%s	字符串
%d	有符号十进制整数，%06d表示输出的整数显示位数字，不足的地方使用0补全
%f	浮点数，%.2f表示小数点后只显示两位
%%	输出%

该用法在上述中提到过，与其使用方法一致。

age = 19
class_num = 2001
message = "我的年龄是%d岁，班级号为%d" % (age, class_num)
print(message)

结果展示：

1	我的年龄是19岁，班级号为2001

数据输入

input()函数

数据输入需要使用到input()函数，需要用一个变量来接收存储该语句获取的键盘输入数据。

例：输入名字并将其输出。

1
2
3

print("What's your name?")
name = input()
print(f"Oh, your name is {name}!")

结果展示：

What's your name?

Bigglesworth
Oh, your name is Bigglesworth!

也可以直接把提示信息写在input()函数的括号内。

例：将上面的例子中的print函数省略。

1 2	name = input("What's your name?") print(f"Oh, your name is {name}!")

结果展示：

1 2	What's your name?Bigglesworth Oh, your name is Bigglesworth!)

注：input函数获取的是字符串类型。

例：从键盘输入两个数字，输出它们相加的结果。

1
2
3

x = int(input("请输入x"))
y = int(input("请输入y"))
print(f"x + y = {x + y}")

结果展示：

请输入x10

请输入y20
x + y = 30

split()函数

在Python中，input()函数所接受的数据返回为一个string类型，如果一行中有多个数据的话，则需要使用split()函数进行切割，切割后返回一个列表（列表会在后续具体讲到）。

例：在一行输入若干个数字，将其输出。

1 2	data = input().split() print(data)

结果展示：

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

布尔类型和比较运算符

布尔类型的定义

布尔类型的字面量：

True表示真（是、肯定）
False表示假（否，否定）

定义变量存储布尔类型数据：

变量名称 = 布尔类型字面量

布尔类型不仅可以自行定义，同时也可以使用比较运算符进行比较运算得到布尔类型的结果。

比较运算符

运算符	描述	示例
==	判断内容是否相等，满足为True，不满足为False	如a=3,b=3，则(a == b)为True
!=	判断内容是否不相等，满足为True，不满足为False	如a=1，b=3，则(a != b)为True
>	判断运算符左侧内容是否大于右侧，满足为True，不满足为False	如a=7,b=3，则(a > b)为True
<	判断运算符左侧内容是否小于右侧，满足为True，不满足为False	如a=3,b=7，则(a < b)为True
>=	判断运算符左侧内容是否大于等于右侧，满足为True，不满足为False	如a=3,b=3，则(a >= b)为True
<=	判断运算符左侧内容是否小于等于右侧，满足为True，不满足为False	如a=3,b=3，则(a <= b)为True

注：首字母一定要大写。

判断语句

if语句的基本格式

基本格式：

1 2	if 要判断的条件: 条件成立时，要做的事情

注：

Python是通过缩进来识别语句的归属的，所以第二行前要有四个空格，以此来说明这句话属于第一行的if语句。
条件后面要有一个英文的冒号。
可以有不止一行要做的事情，只需要保证他们都有着相同的缩进即可。

例：输入一个整数，判断它是否是偶数，是的话输出Yes。

1
2
3

n = int(input())
if n % 2 == 0:  
    print("Yes")

结果展示：

1
2

10
Yes

判断语句的结果，必须是布尔类型True或False，True会执行if内的代码语句，False则不会执行。

if else语句

基本格式：

if 条件:
    满足条件时要做的事
else:
    不满足条件时要做的事

例：输入一个整数，判断它是否是偶数，是的话输出Yes，否则输出No。

n = int(input())
if n % 2 == 0:  
    print("Yes")
else:
    print("No")

结果展示：

1
2

10
Yes

1
2

5
No

if elif else语句

基本格式：

if 条件1::
    条件1满足时应做的事情
elif 条件2:
    条件2满足时应做的事情
elif 条件N:
    条件N满足时应做的事情
else:
    所有条件都不满足时应做的事情

例：输入一个成绩，根据表格输出对应评价。

成绩	评价
90~100	优秀
80~89	良好
70~79	中等
60~69	及格
0~59	不及格

score = int(input())
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("及格")
else:
    print("不及格")

结果展示：

1
2

73
中等

1
2

43
不及格

判断语句的嵌套

基本格式：

if 条件1:
    满足条件1 做的事情1
    满足条件1 做的事情2
    if 条件2:
        满足条件2 做的事情1
        满足条件2 做的事情2

第二个if，属于第一个if内，只有第一个if满足条件，才会执行第二个if。

嵌套的关键点在于空格缩进，通过空格缩进，来决定语句之间的层次关系。

例：输入三个数字，将它们按照从小到大的顺序输出。

a = int(input("请输入a"))
b = int(input("请输入b"))
c = int(input("请输入c"))
if a < b:
    if b < c:
        print(f"{a}<{b}<{c}")
    elif a < c:
        print(f"{a}<{c}<{b}")
    else:
        print(f"{c}<{a}<{b}")
else:
    if a < c:
        print(f"{b}<{a}<{c}")
    elif b < c:
        print(f"{b}<{c}<{a}")
    else:
        print(f"{c}<{b}<{a}")

结果展示：

请输入a10

请输入b5

请输入c8
5<8<10

请输入a9

请输入b8

请输入c7
7<8<9

逻辑运算符

逻辑运算符一般在遇到复合问题时使用，例如：如果明天不下雨并且休息，我就出去玩。对于这个命题，就用到了且这个逻辑运算符。常见的逻辑运算符一共有如下三种，他们常用于判断和循环的条件内。

名称	例子	结果
逻辑与	a and b	当a和b都为True时，为True
逻辑或	a or b	当a或b有一个为True时，为True
逻辑非	not a	当a为False时，为True

例：输入一个年份year，判断其是否为闰年，是闰年输出Yes，否则输出No。

能够整除4且不能整除100的年份为闰年，或者能整除400的为闰年

year = int(input())
if year % 4 == 0 and not year % 100 == 0 or year % 400 == 0:
    print("Yes")
else:
    print("No")

结果展示：

1
2

2008
Yes

1
2

2100
No

循环语句

while循环的基本格式

基本格式：

while 条件:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3

注：只要条件满足，就会无限循环执行。

例：输出0~9的所有数字。

i = 0
while i < 10:
    print(i)
    i += 1

结果展示：

注意点：

while的条件的结果需要是布尔类型，True表示继续循环，False表示结束循环
需要设置循环终止的条件，如i += 1配合i < 10，就能确保10次后停下，否则将无限循环
空格缩进和if判断一样，都需要设置

while循环的嵌套应用

基本格式：

while 条件1:
    条件1满足时，做的事情1
    条件1满足时，做的事情2
    条件1满足时，做的事情3
    while 条件2:
        条件2满足时，做的事情1
        条件2满足时，做的事情2
        条件2满足时，做的事情3

例：输入一个正整数n，打印仅由*构成的n行直角三角形。

n = int(input())
i = 0
while i < n:
    j = 0
    while j <= i:
        print('*', end = '')
        j += 1
    print()
    i += 1

结果展示：

5
*
**
***
****
*****

for循环的基础语法

除了while循环语句外，Python同样提供了for循环语句。

两者能完成的功能基本差不多，但仍有一些区别：

while循环的循环条件是自定义的，自行控制循环条件
fore循环是一种“轮询”机制，是对一批内容进行逐个处理

基本格式：

1 2	for 临时变量 in 待处理数据集: 循环满足条件时执行的代码

遍历字符串

例：遍历Bigglesworth，并将变量的结果打印出来。

1
2
3

name = "Bigglesworth"
for x in name:  
    print(x)

结果展示：

B
i
g
g
l
e
s
w
o
r
t
h

for循环就是将被处理的数据内容挨个取出，赋值给变量。

可以看出，for循环是将字符串的内容依次取出，所以，for循环也被称之为遍历循环。

同while循环不同，for循环是无法定义循环条件的，只能从被处理的数据集中，依次取出内容进行处理。

所以，理论上讲，Python的for循环无法构建无限循环（被处理的数据集不可能无限大）。

range语句

for循环语句，本质上是遍历：序列类型。

我们可以通过range语句，获得一个简单的数字序列。

语法1

range(num)

获取一个从0开始，到num结束的数字序列（不包含num本身）

如range(5)取得的数据是：[0, 1, 2, 3, 4]。

语法2

range(num1, num2)

获得一个从num1开始，到num2结束的数字序列（不含num2本身）

如range(5, 10)取得的数据是：[5, 6, 7, 8, 9]。

语法3

range(num1, num2, step)

获得一个从num1开始，到num2结束的数字序列（不包含num2本身）

数字之间的步长，以step为准（step默认是1）

如range(5, 10, 2)取得的数据是：[5, 7, 9]。

变量作用域

for循环赋值的是临时变量，在编程规范上，作用范围（作用域），只限定在for循环内部。

如果在for循环外部访问临时变量：

实际上是可以访问到的
在编程规范上，是不允许、不建议这么做的

解决临时变量的方法是在全局变量的位置对其定义。

for循环的嵌套

基本格式：

for 临时变量 in 待处理数据集（序列）:
    循环满足条件应做的事情1
    循环满足条件应做的事情2
    循环满足条件应做的事情N
        for 临时变量 in 待处理数据集（序列）:
            循环满足条件应做的事情1
            循环满足条件应做的事情2
            循环满足条件应做的事情N

例：输入一个数字n，求1~n中所有完数。

完数：一个数字的所有真因子相加等于其本身，则该数字被称为完数。

n = int(input())
for i in range(n + 1):
    count = 0
    for j in range(1, i):
        if i % j == 0:
            count += j
    if count == i:
        print(i)

结果展示：

循环中断

无论是while循环或者是for循环，都是重复性的执行特定操作。在这个重复过程中，会出现一切其它情况让我们不得不：

暂时跳过某次循环，直接进行下一次
提前退出循环，不再继续

对于这种场景，Python提供了continue和break关键字用来对循环进行临时跳过和直接结束。

continue

continue关键字用于中断本次循环，直接进入下一次循环。

continue可以用于for循环和while循环，效果一致。

for i in range(1, 100):
    语句1
    continue
    语句2

对于上面的这个例子中，在循环内，遇到continue就结束当次循环，进行下一次，所以语句2是不会执行的。

应用场景：在循环中，因为某些原因，临时结束本次循环。

例：输出0~30内的所有数字，跳过所有5的倍数。

for i in range(1, 31):
    if i % 5 == 0:
        continue
    print(i)

结果展示：

break

break关键字用于直接结束循环。

break可以用于for循环和while循环，效果一致。

for i in range(1, 100):
    语句1
    break

对于上面这个例子。在循环内，遇到break就结束循环了，所以，执行了语句1后，直接执行语句3了。

例：输出0~30内的所有数字，当遇到10的倍数时跳出循环，并输出程序已结束。

for i in range(1, 31):
    if i % 10 == 0:
        break
    print(i)
print("程序已结束")

结果展示：

1
2
3
4
5
6
7
8
9
程序已结束

函数

函数定义

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

例：

1
2
3

name = "Bigglesworth"
length = len(name)
print(length)

结果展示：

在上述例子中，len()实现了对字符串的长度进行统计，可以随时进行调用，这是因为len()是Python中的内置函数，因此函数应该满如下几点：

是提前写好的
可以重复使用
实现某一种特定功能的代码段

函数的定义

基本格式：

1
2
3

def 函数名(传入参数):
    函数体
    return 返回值

例：定义一个函数Hello，功能是输出Hello World!。

1 2	def Hello(): print("Hello World!")

函数的调用

函数名(参数)

例：调用上一个例子中的函数。

def Hello():
    print("Hello World!")

Hello()

结果展示：

1	Hello World!

函数注意事项

参数如不需要，可以省略
返回值如不需要，可以省略
函数必须先定义后使用

函数的参数

传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据。

例：定义一个加法函数，从键盘输入两个数字，将其传入加法函数，并输出结果。

def add(x, y):
    print(f"{x + y}")

x = int(input())
y = int(input())
add(x, y)

结果展示：

函数定义中，提供的x和y称之为：形式参数（形参），表示函数声明将要使用2个参数，参数之间使用逗号进行分隔
函数调用中，提供的x和y称之为：实际参数（实参），表示函数执行是时正使用的参数值，传入的时候，按照顺序传入数据，使用逗号分隔

传入参数的数量是不受限制的。

函数的返回值

返回值指的就是在程序中函数完成事情后，最后给调用者的结果。

基本格式：

def 函数(参数):
    函数体
    return 返回值

变量 = 函数(参数)

例：定义一个加法函数，传入两个参数，并将他们相加的结果作为返回值返回。

def add(x, y):
    answer = x + y
    return answer

a = int(input())
b = int(input())
result = add(a, b)
print(result)

结果展示：

None类型

如果函数中没有使用return语句返回数据，函数依然有返回值。

Python中有一个特殊的字面量：None，其类型是：<class 'NoneType'>。

无返回值的函数，实际上就是返回了None这个字面量。

在判断中，None意味着假值。

函数的嵌套调用

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数。

例：

def fun_b():
    print(2)

def fun_a():
    print(1)

    fun_b()

    print(3)

fun_a()

结果展示：

1
2
3

1
2
3

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置。

变量的作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）

主要分为两类：局部变量和全局变量

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

局部变量的作用：在函数体内部，临时保存数据，即当函数嗲用完成后，则销毁局部变量。

全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量。

global关键字

使用global关键字可以在函数内部声明变量为全局变量。

num = 100

def A():
    print(num)

def B():
    num = 500

def C():
    global num
    num = 500

A()
B()
A()
C()
A()

1
2
3

100
100
500

结果展示：

1
2
3

100
100
500

数据容器

list列表

列表的定义

基本格式：

#定义字面量
[元素1, 元素2, 元素3, 元素4, ...]

#定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]

#定义空列表
变量名称 = []
变量名称 = list()

列表中的每一个数据，称之为元素。

以[]作为标识
列表内每一个元素之间用,逗号隔开

注：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。

例：定义一个列表l，存储的数据为Bigglesworth，3.1415926，[1, 2, 3]，输出该列表和它的类型。

1
2
3

l = ['Bigglesworth', 3.1415926, [1, 2, 3]]
print(l)
print(type(l))

结果展示：

1 2	['Bigglesworth', 3.1415926, [1, 2, 3]] <class 'list'>

list列表的下标索引

基本格式：

列表[下标索引]

正向下标索引从0开始，反向下标索引从-1开始进行索引。

例：定义一个列表l，其内容是圆周率小数点后5位，输出第一个元素和最后一个元素。

1
2
3

l = [1, 4, 1, 5, 9]
print(l[0])
print(l[-1])

结果展示：

1
2

1
9

对于嵌套列表，同样地，下标索引也可以进行嵌套。

例：定义一个列表l，存储1~9的数字，每三个分为一组，输出5。

1 2	l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print(l[1][1])

结果展示：

注意事项：要注意下标索引的取值范围，超出范围无法取出元素，并且会报错。

列表的常用操作

列表的查询功能

查找指定元素在列表的下标，如果找不到，报错ValueError。

基本格式：

1	列表.index(元素)

例：定义一个列表l，其内容是圆周率小数点后5位，分别查询是否存在元素1和0。

1
2
3

l = [1, 4, 1, 5, 9]
print(l.index(1))
print(l.index(0))

结果展示：

1 2	0 ValueError: 0 is not in list

列表的修改功能

修改特定位置（索引）的元素值，直接对指定下标（正向、反向下标均可）的值进行重新赋值（修改）。

基本格式：

1	列表[下标] = 值

例：定义一个列表l，其内容是Bigglesworth，将其改为Areskey。

插入元素

在指定的下标位置，插入指定的元素。

基本格式：

1	列表.insert(下标, 元素)

例：定义一个列表l，其内容是圆周率小数点后5位，在第3（即下标为2）位插入999。

1
2
3

l = [1, 4, 1, 5, 9]
l.insert(2, 999)
print(l)

结果展示：

1	[1, 4, 999, 1, 5, 9]

追加元素

将指定元素，追加到列表的尾部。

基本格式：

1	列表.append(元素)

例：定义一个列表l，其内容是圆周率小数点后5位，在最后追加一个新的元素999。

1
2
3

l = [1, 4, 1, 5, 9]
l.append(999)
print(l)

结果展示：

1	[1, 4, 1, 5, 9, 999]

追加多个元素

将其他数据容器的内容取出，一次追加到列表尾部。

基本格式：

1	列表.extend(其它数据容器)

例：定义两个列表分别为a和b，a中的元素是1，2，3，b中的元素是4，5，6，将b列表合并到a列表中。

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)

结果展示：

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

删除元素

基本格式：

#语法1：
del 列表[下标]
#语法2：
列表.pop(下标)

例：定义一个列表l，其内容是圆周率小数点后5位，用两种方式分别删除第一个元素和最后一个元素。

l = [1, 4, 1, 5, 9]
del l[0]
print(l)
l.pop(3)
print(l)

结果展示：

1 2	[4, 1, 5, 9] [4, 1, 5]

注意点：使用pop可以返回删除的元素。

删除第一个匹配项

删除某元素在列表中的第一个匹配项。

基本格式：

1	列表.remove(元素)

例：定义一个列表l，其内容是圆周率小数点后5位，删除第一个出现的1。

1
2
3

l = [1, 4, 1, 5, 9]
l.remove(1)
print(l)

结果展示：

1	[4, 1, 5, 9]

清空列表

清空列表内容。

基本格式：

1	列表.clear()

例：定义一个列表l，其内容是圆周率小数点后5位，将其清空。

1
2
3

l = [1, 4, 1, 5, 9]
l.clear()
print(l)

结果展示：

[]

统计某个元素的数量

统计某元素在列表内的数量。

基本格式：

1	列表.count(元素)

例：定义一个列表l，其内容是圆周率小数点后5位，统计其中元素1的数量。

1 2	l = [1, 4, 1, 5, 9] print(l.count(1))

结果展示：

查找元素位置

查找列表中某个元素第一次出现的下标，如果没有查到则报错ValueError。

基本格式：

1	列表.index(元素)

例：定义一个列表l，其内容是圆周率小数点后5位，查找元素1的下标。

1 2	l = [1, 4, 1, 5, 9] print(l.index(1))

结果展示：

统计所有元素的数量

统计列表内有多少元素。

基本格式：

len(列表)

例：定义一个列表l，其内容是圆周率小数点后5位，统计其中一共有多少个元素。

1 2	l = [1, 4, 1, 5, 9] print(len(l))

结果展示：

总结

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表(下标)	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear(元素)	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表中的下标找不到报错`ValueError`
10	len(列表)	统计容器中有多少个元素

列表的特点

可以容纳的元素数量上限为（2⁶³-1，即9223372036854775807个）
可以容纳不同类型的元素（混装）
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加或删除元素等）

list列表的遍历

while循环

基本格式：

index = 0
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index += 1

例：定义一个列表l，其内容是圆周率小数点后5位，将这些元素依次输出，每两个元素之间用一个空格隔开。

l = [1, 4, 1, 5, 9]
index = 0
while index < len(l):
    print(l[index], end = ' ')
    index += 1

结果展示：

1 4 1 5 9

for循环

基本格式：

1 2	for 临时变量 in 数据容器: 对临时变量进行处理

例：定义一个列表l，其内容是圆周率小数点后5位，将这些元素依次输出，每两个元素之间用一个空格隔开。

1
2
3

l = [1, 4, 1, 5, 9]
for element in l:
    print(element, end = ' ')

结果展示：

1 4 1 5 9

tuple元组

元组的定义

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

基本格式：

#定义元组字面量
(元素, 元素, ......, 元素)

#定义元组变量
变量名称 = (元素, 元素, ......, 元素)

#定义空元组
变量名称 = ()    #方式1
变量名称 = tuple()    #方式2

例：定义一个元组t，存储的数据为Bigglesworth，3.1415926，[1, 2, 3]，输出该元组和它的类型。

1
2
3

t = ('Bigglesworth', 3.14, [1, 2, 3])
print(t)
print(type(t))

结果展示：

1 2	('Bigglesworth', 3.14, [1, 2, 3]) <class 'tuple'>

注意点：如果元组内只有一个数据，这个数据后面要添加逗号。

tuple元组的下标索引

基本格式：

元组[下标索引]

正向下标索引从0开始，反向下标索引从-1开始进行索引。

例：定义一个元组t，其内容是圆周率小数点后5位，输出第一个元素和最后一个元素。

1
2
3

t = (1, 4, 1, 5, 9)
print(t[0])
print(t[-1])

结果展示：

1
2

1
9

对于嵌套列表，同样地，下标索引也可以进行嵌套。

例：定义一个元组t，存储1~9的数字，每三个分为一组，输出5。

1 2	t = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) print(t[1][1])

结果展示：

注意事项：要注意下标索引的取值范围，超出范围无法取出元素，并且会报错。

元组的常用操作

查找元素位置

查找元组中某个元素第一次出现的下标，如果没有查到则报错ValueError。

基本格式：

1	元组.index(元素)

例：定义一个元组t，其内容是圆周率小数点后5位，查找元素1的下标。

1 2	t = (1, 4, 1, 5, 9) print(t.index(1))

结果展示：

统计某个元素的数量

统计某元素在元组内的数量。

基本格式：

1	元组.count(元素)

例：定义一个元组t，其内容是圆周率小数点后5位，统计其中元素1的数量。

1 2	t = (1, 4, 1, 5, 9) print(t.count(1))

结果展示：

统计所有元素的数量

统计元组内有多少元素。

基本格式：

len(元组)

例：定义一个元组t，其内容是圆周率小数点后5位，统计其中一共有多少个元素。

1 2	t = (1, 4, 1, 5, 9) print(len(t))

结果展示：

总结

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

元组的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素等，但是可以修改内部list的内部元素）
支持for循环

srt字符串

字符串的下标索引

基本格式：

字符串[下标索引]

正向下标索引从0开始，反向下标索引从-1开始进行索引。

例：定义一个字符串s，其内容是圆周率小数点后5位，输出第一个元素和最后一个元素。

1
2
3

s = "14159"
print(s[0])
print(s[-1])

结果展示：

1
2

1
9

字符串的常用操作

查找元素位置

查找字符串中某个字符串第一次出现的下标，如果没有查到则报错ValueError。

基本格式：

1	元组.index(元素)

例：定义一个字符串s，存储的内容为Hello World!，输出World第一次出现的下标。

1 2	s = "Hello World!" print(s.index("World"))

结果展示：

字符串的替换

将字符串内的全部：字符串1，替换为字符串2。

基本格式：

1	字符串.replace(字符串1, 字符串2)

注意点：不是修改字符串本身，而是得到了一个新的字符串。

例：定义一个字符串s1，存储的内容为Hello World!，将World替换为Bigglesworth并赋值给s2。

s1 = "Hello World!"
s2 = s1.replace("World", "Bigglesworth")
print(s1)
print(s2)

结果展示：

1 2	Hello World! Hello Bigglesworth!

字符串的分割

按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。

基本格式：

1	字符串.split(分隔符字符串)

注意点：字符串本身不变，而是得到了一个列表对象。

例：定义一个字符串s，存储的内容为I have a dream!，以空格为分隔符分割字符串，将得到的列表赋值给l。

1
2
3

s = "I have a dream!"
l = s.split(' ')
print(l)

结果展示：

1	['I', 'have', 'a', 'dream!']

字符串的规整操作

去掉字符串前面和后面的特定字符，如果没有指定，则去除空格。

基本格式：

1	字符串.strip("字符串")

注意点：不是修改字符串本身，而是得到了一个新的字符串，传入的字符是按照单个字符来计算的，而不是直接看字符串。

例：定义一个字符串s1，存储的内容为 I have a dream! ，去除前后空格，将结果存储至s2并输出。定义一个字符串str1，存储的内容为123456789132，去除123，将结果存储至str2并输出。

s1 = " I have a dream! "
s2 = s1.strip()
print(s2)
str1 = "123456789132"
str2 = str1.strip("123")
print(str2)

结果展示：

1 2	I have a dream! 456789

统计某个字符串出现的次数

统计某个字符串在整个字符串中出现的次数。

基本格式：

1	字符串.count(字符串)

例：定义一个字符串s，其内容是1231231234567，统计字符串123的数量。

1 2	s = '1231231234567' print(s.count("123"))

结果展示：

计算字符串长度

计算字符串中一共有多少个字符。

基本格式：

len(字符串)

例：定义一个字符串s，其内容是1231231234567，计算字符串长度。

1 2	s = '1231231234567' print(len(s))

结果展示：

总结

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串)	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分割不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

字符串的遍历

同列表、元组一样，字符串也支持while循环和for循环进行遍历。

while循环

基本格式：

index = 0
while index < len(字符串):
    字符 = 字符串[index]
    对字符进行处理
    index += 1

例：定义一个字符串s，内容存储为I have a dream.，将它们依次输出中间用一个空格隔开。

s = "I have a dream."
index = 0
while index < len(s):
    print(s[index], end = ' ')
    index += 1

结果展示：

1	I h a v e a d r e a m .

for循环

基本格式：

1 2	for 临时变量 in 数据容器: 对临时变量进行处理

例：定义一个字符串s，内容存储为I have a dream.，将它们依次输出中间用一个空格隔开。

1
2
3

s = "I have a dream."
for element in s:
    print(element, end = ' ')

结果展示：

1	I h a v e a d r e a m .

字符串的特点

只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持for循环

序列的切片

序列的定义

序列是指：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串，均可以视为序列。

序列的切片

序列支持切片，即从一个序列中，取出一个子序列。

基本格式：

1	序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

起始下标表示从何处开始，可以留空，留空视作从头开始
结束下表（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意点：此操作不会影响序列本身，而是会得到一个新的序列。

例：定义一个字符串s，其内容是Hello World!，分别输出前一半元素（向下取整），隔一个取一个，倒置。

s = "Hello World!"
print(s[:len(s) // 2])
print(s[::2])
print(s[::-1])

结果展示：

1
2
3

Hello 
HloWrd
!dlroW olleH

set集合

集合的定义

集合定义：定义集合使用花括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

基本格式：

#定义集合字面量
{元素, 元素, ......, 元素}

#定义集合变量
变量名称 = {元素, 元素, ......, 元素}

#定义空集合
变量名称 = set()

例：定义一个集合s，存储的数据为Bigglesworth，3.1415926，3.1415926，输出该集合和它的类型。

1
2
3

s = {"Bigglesworth", 3.1415926, 3.1415926}
print(s)
print(type(s))

结果展示：

1 2	{3.1415926, 'Bigglesworth'} <class 'set'>

注意点：数据类型是无序存储的，且不允许重复元素的存在。

集合的常用操作

首先，因为集合是无序的，所以集合不支持下标索引访问。

添加新元素

将指定元素添加到集合内，且集合本身被修改。

基本格式：

1	集合.add("元素")

例：定义一个集合s，存储的数据为Bigglesworth，3.1415926，3.1415926，将Hello World!添加至该集合。

1	元组.index(元素)

例：定义一个元组t，其内容是圆周率小数点后5位，查找元素1的下标。

1
2
3

s = {"Bigglesworth", 3.1415926, 3.1415926}
s.add("Hello World!")
print(s)

结果展示：

1	{'Hello World!', 3.1415926, 'Bigglesworth'}

移除元素

将指定元素从集合中移除。

基本格式：

1	集合.remove("元素")

例：定义一个集合s，存储的数据为Bigglesworth，3.1415926，3.1415926，将3.1415926移除。

1
2
3

s = {"Bigglesworth", 3.1415926, 3.1415926}
s.add(3.1415926)
print(s)

结果展示：

1	{3.1415926, 'Bigglesworth'}

从集合中随机取出元素

从集合中随机取出一个元素。

基本格式：

1	变量 = 集合.pop()

例：定义一个集合s，存储的数据为Bigglesworth，3.1415926，3.1415926，利用pop随机取出一个元素，并将取出的元素赋值给element。

s = {"Bigglesworth", 3.1415926, 3.1415926}
element = s.pop()
print(element)
print(s)

结果展示：

1 2	3.1415926 {'Bigglesworth'}

清空集合

清空集合内容。

基本格式：

1	集合.clear()

例：定义一个集合s，存储的数据为Bigglesworth，3.1415926，3.1415926，将其清空。

1
2
3

s = {"Bigglesworth", 3.1415926, 3.1415926}
s.clear()
print(s)

结果展示：

set()

求差集

取出两个集合的差集（前者有而后者没有的）。

基本格式：

1	集合 = 集合1.difference(集合2)

例：定义两个集合s1和s2，s1中存储内容为十以内的奇数,s2中存储内容为十以内的质数，求二者差集，并赋值给s3。

s1 = {1, 3, 5, 7, 9}
s2 = {2, 3, 5, 7}
s3 = s1.difference(s2)
print(s1)
print(s2)
print(s3)

结果展示：

1
2
3

{1, 3, 5, 7, 9}
{2, 3, 5, 7}
{1, 9}

消除差集

消除两个集合的差集，在第一个集合中删除与第二个集合相同的元素。

基本格式：

1	集合 = 集合1.difference(集合2)

例：定义两个集合s1和s2，s1中存储内容为十以内的奇数,s2中存储内容为十以内的质数，消除差集。

s1 = {1, 3, 5, 7, 9}
s2 = {2, 3, 5, 7}
s1.difference_update(s2)
print(s1)
print(s2)

结果展示：

1 2	{1, 9} {2, 3, 5, 7}

求并集

将两个集合组成一个新的集合。

基本格式：

1	集合 = 集合1.union(集合2)

例：定义两个集合s1和s2，s1中存储内容为十以内的奇数,s2中存储内容为十以内的质数，求二者并集，并赋值给s3。

s1 = {1, 3, 5, 7, 9}
s2 = {2, 3, 5, 7}
s3 = s1.difference(s2)
print(s1)
print(s2)
print(s3)

结果展示：

1
2
3

{1, 3, 5, 7, 9}
{2, 3, 5, 7}
{1, 2, 3, 5, 7, 9}

统计所有元素的数量

统计集合元素数量。

基本格式：

len(集合)

例：定义一个集合s，存储的数据为Bigglesworth，3.1415926，3.1415926，统计其中的元素数量。

1 2	s = {"Bigglesworth", 3.1415926, 3.1415926} print(len(s))

结果展示：

集合的遍历

由于集合不支持下标索引，因此不能使用while循环进行遍历，只能使用for循环进行遍历。

基本格式：

1 2	for 临时变量 in 数据容器: 对临时变量进行处理

例：定义一个集合s，存储的内容为二十以内的质数，利用for循环进行遍历。

1
2
3

s = {2, 3, 5, 7, 11, 13, 17, 19}
for element in s:
    print(element)

结果展示：

总结

编号	使用方式	作用
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的两个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素集合1被修改，集合2内容不变
7	集合1.union(集合2)	得到一个新集合，内含2个集合的全部元素原有的两个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

集合的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是无序存储的（不支持下标索引）
不允许重复数据存在
可以修改（增加或删除元素等）
支持for循环

dic字典、映射

字典的定义

字典定义：定义字典使用花括号，不过存储的元素是一个个的键值对。

基本格式：

#定义字典字面量
{key: value, key: value, ......, key: value}

#定义字典变量
{key: value, key: value, ......, key: value}

#定义空字典
变量名称 = {}	#方式1
变量名称 = dict()	#方式2

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0。

1
2
3

d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1}
print(d)
print(type(d))

结果展示：

1 2	{1: 0, 2: 1, 3: 1, 4: 0, 5: 1} <class 'dict'>

注意点：如果键相同，则只会保留一个。

字典数据的获取

字典统计和一样，不可以使用下标进行索引，但是字典可以通过Key值来取得对应的Value。

同时，字典的key和Value可以是任意数据类型（Key不可以为字典），那么就表明，字典是可以进行嵌套的。

字典[Key]

例：定义一个字典`dict，存储学生信息，并输出某条具体信息。

1
2
3

dic = {"Bigglesworth": {"Math": 100, "Chinese": 90}, 
       "Areskey": {"English": 95, "History": 99}}
print(dic["Bigglesworth"]["Chinese"])

结果展示：

字典的常用操作

添加新元素

字典被修改，增加了元素。

基本格式：

1	字典[Key] = Value

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，添加新的键值对为17的对应关系。

1
2
3

d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1}
d[17] = 1
print(d)

结果展示：

1	{1: 0, 2: 1, 3: 1, 4: 0, 5: 1, 17: 1}

更新元素

字典被修改，元素被更新。

基本格式：

1	字典[Key] = Value

注意点：字典Key不可以重复，所以对已经存在的Key执行上述操作，就是更新Value的值。

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，将1的值改为3。

1
2
3

d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1}
d[1] = 3
print(d)

结果展示：

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

删除元素

获得指定Key的Value，同时字典被修改，指定Key的数据被删除。

基本格式：

1	变量 = 字典.pop(Key)

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，将3的键值对删除并输出。

d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1}
value = d.pop(3)
print(value)
print(d)

结果展示：

1 2	1 {1: 0, 2: 1, 4: 0, 5: 1}

清空字典

清空字典中的所有元素。

基本格式：

1	字典.clear()

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，将该字典清空。

1
2
3

d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1}
d.clear()
print(d)

结果展示：

{}

获取全部Key

到字典中的全部Key。

基本格式：

字典.keys()

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，获取该字典的全部Key。

1 2	d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1} print(d.keys())

结果展示：

1	dict_keys([1, 2, 3, 4, 5])

统计字典的元素数量

共计字典中一共有多少个元素。

基本格式：

len(字典)

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，统计一共有多少个元素。

1 2	d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1} print(len(d))

结果展示：

字典的遍历

可以利用keys函数来遍历整个字典。

例：定义一个集合d，存储的数据为五以内的所有数字，其中如果是质数则标记为1，否则标记为0，遍历整个字典。

1
2
3

d = {1: 0, 2: 1, 3: 1, 4: 0, 5: 1}
for key in d.keys():
    print(f"{key}: {d[key]}")

结果展示：

1: 0
2: 1
3: 1
4: 0
5: 1

注意点：其实不用这个函数直接写字典名也可以直接获取到字典的Key的。

总结

编号	使用方式	作用
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

字典的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
每一份数据都是键值对
可以通过Key获取到Value，Key不可以重复（重复会直接覆盖）
不支持下标索引
可以修改（增加或删除更新元素等）
支持for循环，不支持while循环

数据容器总结

数据容器分类

是否支持下标索引
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
是否支持重复元素
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
是否可以修改
- 支持：列表、集合、字典
- 不支持：元组、字符串

容器通用排序功能

对容器进行指定方式的排序，一共两个参数，分别为要排序的容器和排序方式，默认reverse的值为False，表示从小到大排序，如果其值为True，则会变为从大到小排序。

基本格式：

1	sorted(容器, reverse = True)

例：定义一个列表l，存储的数据为圆周率小数点后前十位，并将他们降序排序。

l = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(l)
l = sorted(l, reverse = True)
print(l)

结果展示：

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

函数进阶

函数多返回值

可以返回多个值。按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return。

基本格式：

def fun():
    return result1, result2

x, y = fun()

例：定义一个函数，从键盘中输入两个数字，返回他们相加和相减的结果。

def fun(x, y):
    return x + y, x - y

a, b = input().split()
a = int(a)
b = int(b)
answer1, answer2 = fun(a, b)
print(f"{answer1} {answer2}")

结果展示：

1
2

5 8
13 -3

函数多种传参方式

位置参数

调用函数时根据函数定义的参数位置来传递参数。

注意点：传递的参数和定义的参数的顺序及个数必须一致。

例：定义一个函数，其功能是传递基本信息然后输出。

def information(name, age, gender):
    print(f"姓名：{name} 年龄：{age} 性别：{gender}")
    
information("Bigglesworth", 20, "男")

结果展示：

1	姓名：Bigglesworth 年龄：20 性别：男

关键字参数

函数调用时通过“键 = 值”形式传递参数。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

注意点：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

例：定义一个函数，其功能是传递基本信息然后输出。

def information(name, age, gender):
    print(f"姓名：{name} 年龄：{age} 性别：{gender}")
    
information("Bigglesworth", gender = "男", age = 20)

结果展示：

1	姓名：Bigglesworth 年龄：20 性别：男

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不穿该默认参数的值。

注意点：所有位置参数必须出现在默认参数前，包括函数定义和调用。函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值。

例：定义一个函数，其功能是传递基本信息然后输出，其中，性别默认为男。

def information(name, age, gender = "男"):
    print(f"姓名：{name} 年龄：{age} 性别：{gender}")
    
information("Bigglesworth", 20)
information("Areskey", 18, "女")

结果展示：

1 2	姓名：Bigglesworth 年龄：20 性别：男姓名：Areskey 年龄：18 性别：女

不定长参数

不定长参数也可叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。不定长参数业可分为两种，分别是位置传递和关键字传递。

位置传递

基本格式：

1 2	def fun(*args): print(args)

注意点：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组tuple，args是元组类型，这就是位置传递。

例：定义一个函数，传递多个参数，并将其输出。

def fun(*args):
    print(args)
    print(type(args))
    
fun("Bigglesworth", 20, "男")

结果展示：

1 2	('Bigglesworth', 20, '男') <class 'tuple'>

关键字传递

基本格式：

1 2	def fun(**kwargs): print(args)

注意点：参数是“键 = 值”形式的情况下，所有的“键 = 值”都会被kwargs接受，同时会根据“键 = 值”组成字典。

例：定义一个函数，传递多个参数，并将其输出。

def fun(**kwargs):
    print(kwargs)
    print(type(kwargs))
    
fun(name = "Bigglesworth", age = 20, gender = "男")

结果展示：

1 2	{'name': 'Bigglesworth', 'age': 20, 'gender': '男'} <class 'dict'>

lambda匿名函数

def关键字，可以定义带有名称的函数
lambda关键字，可以定义匿名函数（无名称）

有名称的函数，可以基于名称重复使用。

无名称的匿名函数，只可临时使用一次。

基本格式：

1	lambda 传入参数: 函数体（一行代码）

注意点：lambda是关键字，表示定义匿名函数。传入参数表示匿名函数的形式参数，如：x，y表示接收2个形式参数。函数体，就是函数的执行逻辑，要注意的是只能写一行代码，无法写多行代码。

例：定义一个函数，接受其它函数输入。

def fun(func):
    ans = func(5, 6)
    print(ans)
    
fun(lambda x, y: x * y)

结果展示：

文件

文件的读取

在Python中，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件。

基本格式：

1	open(name, mode, encoding)

name：是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode：设置打开文件的模式（访问模式）：只读、写入、追加等。
encoding：编码格式（推荐使用UTF-8）

例：使用UTF-8的编码格式，只读文件Test.txt

1
2
3

f = open("Test.txt", "r", encoding = "UTF-8")
print(f)
print(type(f))

结果展示：

1 2	<_io.TextIOWrapper name='Test.txt' mode='r' encoding='UTF-8'> <class '_io.TextIOWrapper'>

mode常用的三种基础访问模式

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件。

读操作相关方法

读取固定长度

基本格式：

1	文件对象.read(num)

其中，num表示要从文件中读取的数据的长度（单位是字节，这里认为一个汉字也是一个字节），如果没有传入num，那么就表示读取文件中所有的数据。

例：读取文件Test.txt，并输出其内容。

f = open("Test.txt", "r", encoding = "UTF-8")
value = f.read(5)
print(value)
value = f.read()
print(value)

结果展示：

1 2	Hello World!

读取整个文件

基本格式：

1	文件对象.readlines()

可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。

例：读取文件Test.txt，并输出其内容。

f = open("Test.txt", "r", encoding = "UTF-8")
value = f.readlines()
print(value)
f.close()

结果展示：

1	['Hello World!\n', 'My name is Bigglesworth!']

读取一行内容

基本格式：

1	文件对象.readline()

一次性读取一行内容。

例：利用for循环读取文件Test.txt，并输出其内容。

1
2
3

f = open("Test.txt", "r", encoding = "UTF-8")
for line in f:
    print(line)

结果展示：

1
2
3

Hello World!

My name is Bigglesworth!

关闭文件

基本格式：

1	文件对象.close()

关闭文件对象，如果不关闭且程序没有停止运行，将会持续占用该文件。

例：读取文件Test.txt,读取之后关闭该文件。

f = open("Test.txt", "r", encoding = "UTF-8")
for line in f:
    print(line)
f.close()

结果展示：

1
2
3

Hello World!

My name is Bigglesworth!

自动关闭文件

基本格式：

1 2	with open(name, mode, encoding)as f: 执行的操作

可以在操作完成后自动关闭文件，避免遗忘掉手动关闭。

例：读取文件Test.txt,读取之后关闭该文件。

1
2
3

with open("Test.txt", "r", encoding = "UTF-8") as f:
    for line in f:
        print(line)

结果展示：

1
2
3

Hello World!

My name is Bigglesworth!

写操作相关方法

基本格式：

#打开文件
f = open("Test.txt", "w",  encoding = "UTF-8")

#文件写入
f.write("Hello World!")

#内容刷新
f.flush()

注意点：

直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区。
当调用flush的时候，内容会真正写入文件。
这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写入磁盘）

结果展示（文件中的结果）：

1	Hello World!

注意点：close功能内置了flush功能。文件存在的话，会将其中的东西全部清空后写入；文件不存在的话，会创建相应文件后写入。

追加写入操作相关方法

基本格式：

#打开文件
f = open("Test.txt", "a",  encoding = "UTF-8")

#文件写入
f.write("\nMy name is Bigglesworth!")

#内容刷新
f.flush()

注意点：

a模式下，文件不存在会创建文件。
a模式下，文件存在会在最后追加写入文件。

结果展示（文件中原本有一句Hello World!）：

1 2	Hello World!My name is Bigglesworth! My name is Bigglesworth!

注意点：close功能内置了flush功能。文件存在的话，会将其中的东西全部清空后写入；文件不存在的话，会创建相应文件后写入。