python

发表于2025-07-30更新于2025-12-27

python学习笔记

​ 雄关漫道真如铁，而今迈步从头越

​ ——毛泽东

基础语法

缩进

缩进就是每一行开头都要有一定的格式，python需要严格的缩进去控制代码

1
2
3
4
5
if True:
    print ("True")
else:
    print ("False")
# 这段代码中第一层判断语句顶格写，而执行的代码需要写在判断语句的内部，这里是四个空格

多行语句

如果语句太长会导致代码十分的不整齐并且混乱，我们可以通过 \ 来将同一行语句，变成多行

1
2
3
print(1312371237+ \
      123342132+ \
      1342433532)

注释

1
2
3
4
5
# 我是单行注释
'''
我是
多行注释
'''

引号

单引号表示一个词，双引号表示一个句子，六个双引号表示多个句子组成的段落

1
2
3
4
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

同行多语句

用分号隔开即可

1
age = 1;height = 200

字面量

定义：通俗来讲就是写在程序里面的值

值类型

类型 描述 说明/举例
数字（Number） 包括：
整数（int）浮点数（float/double）
复数（complex） 布尔（bool）		 int: 10,-8,19
float/double: 1.109,-838.1
complex: 4+3j 以j结尾
bool: 只有true和false，两个值，方便表示真假判断
字符串（String） 相当于一段文本 string:由任意字符组成
列表（List） 有序的可变序列 最常用的类型，可有序记录一堆数据
元组（Tuple） 有序的不可变序列 可有序记录一堆不可变的数据集合
集合（Set） 无序不重复组合 可无序记录一堆不重复的数据集合
字典（Dictionary） 无序的Key-Value集合 可无序记录一堆Key-Value的数据集合

输入语句

通用格式为：变量名 = input(“提示字符串”)

注意：python输入默认解析为字符串，需要进行类型转换，后面会讲

1
2
input("按下 enter 键退出，其他任意键显示...\n")
age = input("请输入年龄：")

输出语句

1
print("wind")

输出括号内的内容

print格式化输出：

与C语言的占位符规则相似

占位符 含义
%d 输出整数
%s 输出字符串
%c 输出单个字符
%f 输出小数

当然了这种输出方式可以更方便控制输出格式，至于更详细的用法可以上网查一下，这里不展开了

1
2
3
animal = 'monkey'
num = 4
print('A %s has %d legs' % (animal, num))
1
2
输出：
A monkey has 4 legs

我们还可以在字符串前声明一个 f 这样也可以格式化输出

1
2
3
age = 18
name = "lqf"
print(f"我是{name},我今年{age}岁")

这种方式是最优雅的，但是不如占位符好控制，两者可以根据需求进行选择

变量

通俗来讲，就是程序运行中用来存储某种数据的值

比如我想存一个人的身高，可以定义 height = 185 或者 h = 185 ，命名只能有字母、数字、下划线

至于是具体命名更好，还是简单命名更好，我个人建议，如果你是在参加个人竞赛，那么保证命名自己理解就好。如果你是需要与别人合作，比如团队竞赛，或者开发，那么越具体越好

1
2
3
4
5
6
# 定义变量存储身高
height = 50
print("小名的身高为：",height)
# 小名长高了10cm
height = height + 10
print("小名的最新身高为：",height)
1
2
3
输出：
小名的身高为： 50
小名的最新身高为： 60

数据类型

可以使用type() 语句来查看数据类型

1
2
3
4
print(type(185))
print(type(75.12))
print(type(True))
print(type("liuqf"))
1
2
3
4
5
输出：
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'str'>

或者也可以将变量填入

1
2
3
4
5
6
7
8
9
height = 188
name = "liuqf"
sex = True
weight = 75.19

print(type(height))
print(type(weigh.t))
print(type(sex))
print(type(name))
1
2
3
4
5
输出：
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'str'>

当然了也可以把type() 存入变量输出，这里不演示了

数据类型转换

目标类型(变量)

直接按照这个格式就可以进行类型转换了

1
2
3
4
5
6
7
8
a = "123"
b = 123
c ="11.32"
a = int(a)
b = str(b)
c = float(c)
print(type(a),"\n",type(b),"\n",type(c))
print(a,"\n",b,"\n",c)
1
2
3
4
5
6
7
输出：
<class 'int'> 
 <class 'str'> 
 <class 'float'>
123 
 123 
 11.32

运算符

设 a = 10,b = 20

运算符 描述 实例
+ 将数据相加 a + b = 30
- 将数据相减 a - b = -10
* 将数据相乘 a * b = 200
/ 将数据相除，由于python有高精度所以会自动保留小数 b / a = 2
% 取模 - 返回除法的余数 b % a = 0
** 返回x的y次幂 a ** b = 10的20次幂
// 取整除 - 返回商的整数部分（向下取整） 10 // 3 = 3

条件语句

条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false

Python 编程中 if 语句用于控制程序的执行，基本形式为：

1
2
3
4
if 判断条件：
    执行语句……
else：
    执行语句……

条件为真时执行if语句下的代码，否则执行else下的代码

1
2
3
4
5
6
# 小名需不需要买票，买票条件为年龄大于等于18
age = 输入年龄
if age >= 18:
    print("年龄大于等于18，需买票")
else:
    print("年龄小于18，免费")

当然了，这种只能判断一种条件显然是不够用，所以我们需要完整版的条件语句

1
2
3
4
5
6
7
8
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……
1
2
3
4
5
6
7
age = int(input("Enter your age: "))
if age < 18:
    print("You are young")
elif age == 18:
    print("You are strong")
else:
    print("You are older")
1
2
输入：18
输出：You are strong

注意：判断条件时由上到下判断，只要满足条件直接执行，剩余的条件不会进行判断

判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系

如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；

使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功

1
2
3
4
5
6
7
age = int(input("Enter your age: "))
if age >= 18 and age < 32 :
    print("You are young")
elif age >= 32 and age < 65:
    print("You are strong")
else:
    print("You are older")
1
2
输入：44
输出：You are strong

循环语句

循环语句主要用于，我需要满足一个条件，当这个条件不满足时，我需要一直重复一段代码直到满足条件

while循环

1
2
while 判断条件:
    执行语句……

与条件语句基本一直，只不过在不满足条件时会一直循环执行代码

1
2
3
4
5
6
7
# 小名年龄满足18才能进游乐园
age = int(input("请输入小名的年龄："))
while age < 18 :
    print("小名",age,"岁 不能进游乐园，明年再来吧！")
    age = age + 1

print("小名",age,"岁 可以进游乐园啦！！！")
1
2
3
4
5
6
输入：15
输出：
小名 15 岁 不能进游乐园，明年再来吧！
小名 16 岁 不能进游乐园，明年再来吧！
小名 17 岁 不能进游乐园，明年再来吧！
小名 18 岁 可以进游乐园啦！！！

循环语句还可以嵌套条件语句使用

1
2
3
4
5
6
7
8
9
10
# 小名要参加比赛，当小名的分数在18~30之间时，他的成绩是优秀的
score = int(input("请输入小名的成绩："))
while score < 18 or score > 30:
    if(score < 18):
        print("成绩为",score,"再提升一点吧！")
        score = score + 2
    elif(score > 30):
        print("成绩为",score,"再降低一点吧！")
        score = score - 2
print("小名的成绩为",score,"是优秀的！")
1
2
3
4
5
输入：15
输出：
成绩为 15 再提升一点吧！
成绩为 17 再提升一点吧！
小名的成绩为 19 是优秀的！
1
2
3
4
5
6
7
输入：37
输出：
成绩为 37 再降低一点吧！
成绩为 35 再降低一点吧！
成绩为 33 再降低一点吧！
成绩为 31 再降低一点吧！
小名的成绩为 29 是优秀的！

当然了循环是可以无限的，只要让条件一直为真，用户可以手动用 CTRL+C 来中止循环，这个就不演示了，可以自己实验一下

for循环

循环语句逻辑相同，只是语法不同，用于不同的使用场景逻辑，for循环的逻辑更有针对性，他更适用于对数据进行遍历处理

1
2
for 临时变量 in 数据集
	执行代码....

for循环会逐个将数据集中的数据赋值给临时变量

1
2
3
4
5
6
7
# 只保留字符串中的奇数
nums = "123456789"
nums2 = ""
for num in nums:
    if int(num) % 2 != 0:
        nums2 += num
print(nums2)
1
2
输出：
13579

注意：for循环无法自定义条件，也无法无限循环

上面所称的数据集实际上是序列，例如字符串、元组、列表等等

range语句

range可以构建一个简单序列

1
2
3
4
5
6
range(num)
# 获得一个从0开始到num-1的序列
range(num1,num2)
# 获得一个从num1开始到num2-1的序列
range(num1,num2,step)
# 获得一个从num1走step步到num2-1的序列
1
2
3
4
5
6
7
8
9
10
11
for i in range(10):
    print(i," ", end=" ")
print("\n")

for i in range(5,10):
    print(i," ", end=" ")
print("\n")

for i in range(5,10,2):
    print(i," ", end=" ")
print("\n")
1
2
3
4
5
6
 输出：
0   1   2   3   4   5   6   7   8   9   

5   6   7   8   9   

5   7   9

嵌套循环

while嵌套

我们可以通过两层循环来写一个九九乘法表，外层控制行数，第二层控制列数

1
2
3
4
5
6
7
8
9
a = 1
b = 1
while a<=9:
    b=1
    while b<=a:
        print(f"{a}x{b}={a*b} ",end="")
        b+=1
    a+=1
    print("\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
输出：
1x1=1 

2x1=2 2x2=4 

3x1=3 3x2=6 3x3=9 

4x1=4 4x2=8 4x3=12 4x4=16 

5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 

6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 

7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 

8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 

9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81

for嵌套

依旧是外层控制行数，分成上下三角打印，内层分别控制空格和星号

1
2
3
4
5
6
7
8
9
10
11
12
13
# 打印菱形
for i in range(4):
    for j in range(3-i):
        print(" ",end="")
    for k in range(2*i+1):
        print("*",end="")
    print("\n")
for i in range(3):
    for j in range(i+1):
        print(" ",end="")
    for k in range(2*(2-i)+1):
        print("*",end="")
    print("\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
   *

  ***

 *****

*******

 *****

  ***

   *

循环控制语句

break

若在循环中执行该语句，那么不论如何都会直接跳出整个循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 小名参加跳绳比赛，跳够一百个就能晋级，但是小名的体力值不一定能跳够100个
# 每跳一次消耗两点体力
sum = input("请输入小名当前跳绳个数：")
height = input("请输入小名当前体力值：")
sum = int(sum)
height = int(height)
while sum < 100:
    if height <= 0:
        print("体力值不足，跳不出来了")
        break
    sum = sum + 1
    height = height - 2
    print("跳了一次，当前跳绳个数为：",sum)
    print("跳了一次，当前体力值为：",height)

if sum >= 100:
    print("跳够100个，晋级成功")
else:
    print("跳不够100个，晋级失败")

1
2
3
4
5
6
7
8
9
10
请输入小名当前跳绳个数：95
请输入小名当前体力值：6
跳了一次，当前跳绳个数为： 96
跳了一次，当前体力值为： 4
跳了一次，当前跳绳个数为： 97
跳了一次，当前体力值为： 2
跳了一次，当前跳绳个数为： 98
跳了一次，当前体力值为： 0
体力值不足，跳不出来了
跳不够100个，晋级失败

continue

若在循环中执行该语句，则直接跳过该语句下面所有代码，执行下一次循环

1
2
3
4
5
6
# 输出序列所有偶数
for i in range(1,10):
    if i%2 == 1:
        continue
    print(i)

1
2
3
4
5
输出：
2
4
6
8

[!IMPORTANT]

恭喜你已经学完了python的基础语法，掌握以上这些语法，可以让你完成大部分普通的程序需求，接下来我们基于语法基础进行详细展开，以及更多的编程技巧

进阶编程

函数

编写一种功能模块，可以在程序中重复调用，方便代码逻辑管理

1
2
3
4
5
def 函数名称(参数) :
	功能代码....
	return 返回值
# 调用
函数名称(传入参数)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 模拟len()函数
def my_len(str):
    count = 0
    for i in str:
        count += 1
    print(f"字符串{str}的长度为{count}")
    return count

str1 = 'hello'
str2 = 'world'
str3 = str1 + str2

my_len(str1)
my_len(str2)
my_len(str3)
1
2
3
4
输出：
字符串hello的长度为5
字符串world的长度为5
字符串helloworld的长度为10

**注意：函数返回值可以为None(空) **

函数说明文档

1
2
3
4
5
6
7
8
9
10
11
12
# 模拟len()函数
def my_len(str):
    '''
    模拟len()函数，返回字符串的长度
    :param str: 字符串
    :return: 字符串的长度 
    '''
    count = 0
    for i in str:
        count += 1
    print(f"字符串{str}的长度为{count}")
    return count

param 函数形参

return 函数返回值

函数嵌套

1
2
3
4
5
6
7
8
9
10
11
# 两数比较大小后相减
def compe(a,b):
    return a>=b
def sub(a,b):
    if compe(a,b):
        return a-b
    else:
        return b-a
a = int(input("请输入第一个数："))
b = int(input("请输入第二个数："))
print(f"{a}和{b}差的绝对值为：{sub(a,b)}")

函数多返回值

1
2
3
4
5
6
def test() :
    return 1,2

x,y = test()
print(x)
print(y)xxxxxxxxxx def test() :    return 1,2x,y = test()print(x)print(y)def
1
2
3
输出：
1
2

函数多种传参方式

位置参数
1
2
3
4
def user_info(name,age,sex) :
    print(f"姓名：{name}，年龄：{age}，性别：{sex}")

user_info("张三",18,"男")
1
2
输出：
姓名：张三，年龄：18，性别：男
关键字参数
1
2
3
4
5
6
def user_info(name,age,sex) :
    print(f"姓名：{name}，年龄：{age}，性别：{sex}")

user_info(name = "张三",age = 18,sex ="男")

user_info(age = 18,name = "张三",sex ="男")
1
2
3
输出：
姓名：张三，年龄：18，性别：男
姓名：张三，年龄：18，性别：男
缺省参数

可以设定默认值

1
2
3
4
5
6
7
def user_info(name,age,sex = "男") :
    print(f"姓名：{name}，年龄：{age}，性别：{sex}")

user_info("张三",18)

user_info("李四",19,"女")

1
2
3
输出：
姓名：张三，年龄：18，性别：男
姓名：李四，年龄：19，性别：女
不定长参数

可以不限制传入数量，默认存为元组

1
2
3
4
5
6
def user_info(*user) :
    print(user)

user_info("张三",18)

user_info("李四",19,"女")
1
2
3
输出：
('张三', 18)
('李四', 19, '女')
1
2
3
4
5
6
def user_info(**user) :
    print(user)

user_info(name="张三",age=18)

user_info(name="李四",age=19,sex="女")
1
2
3
输出：
{'name': '张三', 'age': 18}
{'name': '李四', 'age': 19, 'sex': '女'}

匿名函数

函数作为参数

传入计算逻辑而不是数据

1
2
3
4
5
6
def add(a,b) :
    return a+b
def test(add) :
    print(add(1,2))

test(add)
1
3
1
2
3
4
5
6
7
8
9
def add(a,b) :
    return a+b
def test(add) :
    print(add(1,2))
    
def sub(a,b) :
    return a-b

test(sub)
1
-1
lambda匿名函数

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

只能临时使用一次，主要是为了丰富代码逻辑

1
2
3
4
def test(com) :
    print(com(1,2))

test(lambda a,b : a+b)
1
3

数据容器

列表

定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 定义列表
list1 = [1,2,3,4,5]
print(list1)

list2 = list() # 定义空列表
# 从键盘输入5个数字，将其存储到list2中
i = 0
while i < 5:
    p = input("请输入一个数据：")
    list2.append(p)
    i+=1

print(list2)

list3 = ["liuqf","2006/02/05",188,"男"]

print(list3)

1
2
3
4
5
6
7
8
9
10
11
12
输出：
[1, 2, 3, 4, 5]

请输入一个数据：li
请输入一个数据：2e
请输入一个数据：234
请输入一个数据：mmm
请输入一个数据：88

['li', '2e', '234', 'mmm', '88']

['liuqf', '2006/02/05', 188, '男']
访问元素
1
2
3
4
5
6
7
# 列表的元素
print(list1[0])
print(list1[3])

# 列表的切片
print(list1[0:3])
print(list1[2:5])
1
2
3
4
5
输出：
1
4
[1, 2, 3]
[3, 4, 5]
列表的相关语法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 列表的方法

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

print(len(list1)) # 列表的长度

index = list1.index(3) # 查找元素下标
print(index)

list1.append(6) # 在列表末尾添加元素
print(list1)

list1.extend([9,8,7]) # 在列表末尾批量添加元素
print(list1)

list1.insert(0,0) # 在列表指定位置添加元素
print(list1)

list1.remove(6) # 删除列表指定元素
print(list1)

p = list1.pop(2) # 删除索引为2的元素，返回删除数据
print(list1,p)

list1.pop() # 删除列表末尾元素
print(list1)

list1.clear() # 清空列表
print(list1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
输出：
5

2

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

[1, 2, 3, 4, 5, 9, 8, 7]

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

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

[1, 2, 4, 5] 

[0, 1, 2, 3, 4]

[]
列表排序
1
2
3
4
5
6
7
8
# 列表的排序
list1 = [1,3,2,4,5]
print(list1)
list1.sort() # 升序排序
print(list1)

list1.sort(reverse=True) # 降序排序
print(list1)
1
2
3
4
输出：
[1, 3, 2, 4, 5]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
列表的拼接
1
2
3
4
5
6
7
8
9
10
11
# 列表的重复
list1 = [1,2,3]
print(list1)
list1 = list1 * 3
print(list1)
# 列表的拼接
list1 = [1,2,3]
list2 = [4,5,6]
list3 = list1 + list2
print(list3)

1
2
3
输出：
[1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3, 4, 5, 6]

元组

定义
1
2
3
4
5
6
7
# 定义元组
t = (1, 2, 3, 4, 5)
print(t)
p = ()
# 输入元组
p = tuple(input("请输入元组："))
print(p)
1
2
3
4
输出：
(1, 2, 3, 4, 5)
请输入元组：123123
('1', '2', '3', '1', '2', '3')
操作
1
2
3
4
5
6
7
8
9
10
# 元组的索引
print(t[0])
# 元组的切片
print(t[1:3])
# 元组的长度
print(len(t))
# 元组的元素个数
print(t.count(1))
# 元组的索引
print(t.index(2))
1
2
3
4
5
6
输出：
1
(2, 3)
5
1
1
注意
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 元组的元素不能修改
# t[0] = 100
# 元组的元素不能删除
# del t[0]
# 元组的元素不能添加
# t.append(6)
# 元组的元素不能排序
# t.sort()
# 元组的元素不能反转
# t.reverse()
# 元组的元素不能清空
# t.clear()
# 元组的元素不能删除
# del t

字符串

定义

1
2
3
# 定义字符串
name = "hsy"
print(name)
1
2
输出：
hsy

方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 字符串的长度
print(len(name))

# 字符串的索引
print(name[2])

# 字符串的切片
print(name[0:3])

# 字符串的方法
print(name.index("h")) # 查找子字符串的索引
print(name.count("y")) # 统计子字符串的个数

print(name.replace("hsy","hsy123")) # 替换子字符串
print(name) # 原字符串不会改变

name = name.replace("hsy","hsy 123") # 替换子字符串后赋值
print(name) # 原字符串会改变

name_list=name.split('y') #根据'y'分割字符串
print(name_list)

name_list2=name.split()
print(name_list2)

1
2
3
4
5
6
7
8
9
10
11
输出：
3
y
hsy
0
1
hsy123
hsy
hsy 123
['hs', ' 123']
['hsy', '123']

集合

定义

1
2
3
# 定义集合
set1 = {1,2,3,1,2,3,1,2,3}
print(set1)
1
2
输出：
{1, 2, 3}

操作

1
2
3
4
5
6
# 集合的操作
set2 = {2,3,4,5,6}
print(set1 & set2) # 交集
print(set1 | set2) # 并集
print(set1 - set2) # 差集
print(set1 ^ set2) # 对称差集，即集合1和集合2中不重复的元素
1
2
3
4
5
输出：
{2, 3}
{1, 2, 3, 4, 5, 6}
{1}
{1, 4, 5, 6}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
set1.add(4) # 添加元素
print(set1)

set1.remove(4) # 删除元素
print(set1)

set1.pop() # 随机删除一个元素
print(set1)

set1.clear() # 清空集合
print(set1)

# 集合的长度
print(len(set1))

# 集合的成员判断
print(1 in set1)
print(1 not in set1)

1
2
3
4
5
6
7
8
输出：
{1, 2, 3, 4}
{1, 2, 3}
{2, 3}
set()
0
False
True

字典

定义

1
2
3
4
5
6
7
# 定义字典
dict1 = {"name":"张三","age":18,"sex":"男"}
print(dict1)

# 定义嵌套字典
dict2={"张三":{"age":18,"sex":"男"},"李四":{"age":19,"sex":"女"}}
print(dict2)
1
2
3
输出：
{'name': '张三', 'age': 18, 'sex': '男'}
{'张三': {'age': 18, 'sex': '男'}, '李四': {'age': 19, 'sex': '女'}}

操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 字典的操作
print(dict1["name"]) # 访问字典中的元素
print(dict1.get("name")) # 访问字典中的元素

dict1["name"] = "李四" # 修改字典中的元素
print(dict1)

dict1["height"] = 170 # 添加元素
print(dict1)

del dict1["age"] # 删除元素
print(dict1)

# 字典的长度
print(len(dict1))

# 字典的成员判断
print("name" in dict1)
print("name" not in dict1)

# 获取全部键
print(dict1.keys())

# 获取全部值
print(dict1.values())

# 获取全部键值对
print(dict1.items())

1
2
3
4
5
6
7
8
9
10
11
12
输出：
张三
张三
{'name': '李四', 'age': 18, 'sex': '男'}
{'name': '李四', 'age': 18, 'sex': '男', 'height': 170}
{'name': '李四', 'sex': '男', 'height': 170}
3
True
False
dict_keys(['name', 'sex', 'height'])
dict_values(['李四', '男', 170])
dict_items([('name', '李四'), ('sex', '男'), ('height', 170)])

序列切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
list1 = [1,2,3,4,5,6]
# 列表的切片
print(list1[1:4]) 
# 从索引1开始，到索引4结束，不包含索引4
print(list1[1:4:2]) 
# 从索引1开始，到索引4结束，不包含索引4，步长为2
print(list1[:2]) 
# 从索引0开始，到索引2结束，不包含索引2
print(list1[2:])
# 从索引2开始，到索引结束，包含索引结束
print(list1[::3]) 
# 从索引0开始，到索引结束，步长为3
print(list1[::-1]) 
# 从索引结束开始，到索引0结束，步长为-1，即反转列表
1
2
3
4
5
6
7
输出：
[2, 3, 4]
[2, 4]
[1, 2]
[3, 4, 5, 6]
[1, 4]
[6, 5, 4, 3, 2, 1]

通用操作

1
2
3
4
5
6
7
8
9
10
len() # 统计元素个数
max() # 查找最大元素
min() # 查找最小元素
# 类型转换
list()
srr()
tuple()
set()
# 排序
sorted(,reverse='True/False')

文件

读取

三步走：

  1. 打开文件
  2. 读取文件
  3. 关闭文件

打开文件

1
2
3
4
f=open(name,mode,encoding)
# name：文件路径
# mode：打开模式 r只读 w只写 a追加
# encoding：编码格式

读取文件

1
2
3
f.read(num) # 读取文件内容 num表示读取的字节数 不填表示读取全部
f.readline() # 读取一行内容
f.readlines() # # 按照行读取所有内容，返回一个列表

关闭文件

1
2
3
4
5
f.close()

#或者
with open() as f:
	操作文件...

示例

1
2
3
4
5
6
f=open("C:\\Users\\35211\\Desktop\\qita\\testr.txt","r",encoding="utf-8")

t = f.read(4) # 读取文件内容 num表示读取的字节数 不填表示读取全部
print(t)
t = f.read()
print(t)
1
2
3
4
5
6
7
输出：
这么早就
订回去的票了
先预约
怕抢不到
我看了刚出的票
直接买不了了
1
2
3
4
f=open("C:\\Users\\35211\\Desktop\\qita\\testr.txt","r",encoding="utf-8")
t = f.readlines()
print(t)

1
2
输出：
['这么早就订回去的票了\n', '先预约\n', '怕抢不到\n', '我看了刚出的票\n', '直接买不了了']

写入

四步走：

  1. 打开文件
  2. 写入文件
  3. 内容刷新
  4. 关闭文件

打开文件与关闭文件操作相同

写入文件

1
f.wirte("内容")

内容刷新

1
f.flush()

示例：

1
2
3
4
5
6
7
8
f=open("C:\\Users\\35211\\Desktop\\qita\\testr.txt","w+",encoding="utf-8")

f.write("hello world\n")
f.flush()
f.seek(0)
t = f.read()
print(t)
f.close()
1
2
输出：
hello world

追加

1
2
3
4
5
6
7
8
f=open("C:\\Users\\35211\\Desktop\\qita\\testr.txt","a+",encoding="utf-8")

f.write("hsy\n")
f.flush()
f.seek(0)
t = f.read()
print(t)
f.close()
1
2
3
输出：
hello world
hsy

异常

异常也就是bug,这个词来源于上个世纪一台计算机突然无法正常运行了，在检查后发现是一只小飞虫进去卡住了计算机，飞虫的英文名就是”不过“，于是后面就用”bug“这个词来表示程序异常

捕获异常

基本语法
1
2
3
4
try:
	可能发生错误的代码
except:
	如果异常那么要运行的代码

示例

1
2
3
4
5
6
7
try:
    f=open("C:\\Users\\35211\\Desktop\\qita\\tes.txt","r",encoding="utf-8")
    t = f.read()
    print(t)
    f.close()
except:
    print(f"打开文件失败，请检查")
1
2
输出：
打开文件失败，请检查
捕获指定异常
1
2
3
4
5
6
# 捕获指定异常
try:
    print(height)

except NameError as e:
    print(f"变量未定义")
1
2
输出：
变量未定义
捕获多个异常

通过元组的形式，写入多个异常名称

1
2
3
4
5
try:
    print(height)
    1/0
except (NameError,ZeroDivisionError) as e:
    print(f"变量未定义 或 除数为0")
1
2
输出：
变量未定义 或 除数为0
捕获所有异常
1
2
3
4
5
try:
    print(height)
    1/0
except Exception as e:
    print(f"出现错误")
1
2
输出：
出现错误
异常else
1
2
3
4
5
6
7
8
9
# 表示如果没有异常的话执行代码
try:
    height = 50
    print(height)

except Exception as e:
    print(f"出现错误")
else:
    print("没有错误")
1
2
3
输出：
50
没有错误
异常finally
1
2
3
4
5
6
7
8
9
10
# 无论如何都会执行
try:
    print(height)

except Exception as e:
    print(f"出现错误")
else:
    print("没有错误")
finally:
    print("程序结束")
1
2
3
输出：
出现错误
程序结束

模块

导入其他的python功能包

基础语法

1
2
import 模块名
import 模块名1,模块名2
1
2
3
import time

time.sleep(1) # 暂停1秒
1
2
3
from time import sleep # 导入sleep函数

time.sleep(1)
1
2
3
from time import * # 导入time模块,不用写time.

sleep(1)
1
2
3
import time as t # 导入time模块并将其重命名为t

t.sleep(1)

自定义模块

1
2
3
4
5
# 自定义模块，命名为model
def adds(x, y):
    return x + y
def subs(x, y):
    return x - y
1
2
3
4
5
import model

print(model.adds(1,2))

print(model.subs(1,2))
1
2
3
输出：
3
-1
_ _ main _ _用法

我们还可以在模块文件内部测试函数，但是调用时会执行测试函数的程序，所以我们可以通过_ _ main _ _用法防止调用

1
2
3
4
5
6
7
8
# 自定义模块，命名为model
def adds(x, y):
    return x + y
def subs(x, y):
    return x - y
# 测试模块
if __name__ == '__main__':
    print(adds(1,2))
1
2
输出；
3
_ _all _ _用法

限定使用 from …import *方法调用模块时，可以使用的函数

1
2
3
4
5
6
7
8
9
# 使用all函数，限制调用
__all__ = ['adds']
def adds(x, y):
    return x + y
def subs(x, y):
    return x - y
# 测试模块
if __name__ == '__main__':
    print(adds(1,2))
1
2
3
4
5
6
7
8
from model import *

print(adds(1,2))

try:
    print(subs(1,2))
except:
    print('subs函数不存在')
1
2
3
输出：
3
subs函数不存在

包

包其实就是将许多模块汇总到一块进行管理

基础用法

文件夹：test

​ _ _ init _ _.py

​ model1.py

​ model2.py

1
2
3
# model1
def func1():
    print('func1')
1
2
3
# model2
def model2():
    print('model2')
1
2
3
4
5
6
# 导入模块
import test.mode1
import test.model2

test.mode1.func1()
test.model2.model2()
1
2
3
输出：
func1
model2

第三方包导入

在终端使用 pip install 包名 命令

1
2
3
4
5
6
7
C:\Users\35211>pip install numpy
Collecting numpy
  Downloading numpy-2.3.2-cp313-cp313-win_amd64.whl.metadata (60 kB)
Downloading numpy-2.3.2-cp313-cp313-win_amd64.whl (12.8 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 12.8/12.8 MB 3.6 MB/s  0:00:03
Installing collected packages: numpy
Successfully installed numpy-2.3.2

注意网络链接，如果连不上可以使用国内镜像链接，具体方法就不演示了

具体案例

[!IMPORTANT]

到这里python的基本内容已经基本上全部结束，后面开始具体内容演示，以及数据分析、面对对象编程、数据库等，高级编程方法

可视化

JSON

一种轻量级的数据交互格式，跨语言通用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 基础格式，类似于字典
{name:"admin","age:18}
 
# 嵌套格式，列表嵌套字典
[
  {
    "name": "admin",
    "age": 18
  },
  {
  	"name": "admin2",
  	"age": 19
  },
  {
  	"name": "admin3",
  	"age": 20
  }
]
python 数据转换 json
1
2
3
4
5
6
7
8
9
10
11
12
13
# 导入json模块
import json

data = [{"name": "张三","age": 18},{"name": "李四","age": 20},{"name": "王五","age": 32}]

# 转换为json字符串
json_str = json.dumps(data,ensure_ascii=False)
print(json_str)

# 转换为python对象
python_obj = json.loads(json_str)
print(python_obj)

1
2
3
输出：
[{"name": "张三", "age": 18}, {"name": "李四", "age": 20}, {"name": "王五", "age": 32}]
[{'name': '张三', 'age': 18}, {'name': '李四', 'age': 20}, {'name': '王五', 'age': 32}]

pyecharts模块

echarts是专门为数据可视化开发的模块，pyecharts是专门用于python的可视化模块

官方提供的画廊网站可以供我们搜索自己感兴趣的图表

网站链接：gallery.pyecharts.org

入门用法
创建折线图
1
2
3
4
5
6
7
8
9
from pyecharts.charts import Line
# 获取Line对象
line = Line()
# 设置x,y轴数据
line.add_xaxis(['张三','李四','王五'])
line.add_yaxis("height",[180,172,188])
# 渲染图表
line.render()

全局配置

通过 set-global_opts 方法配置，可以配置图例，工具箱等等的显示

1
2
3
4
5
6
7
line.set_global_opts(
    title_opts=opts.TitleOpts(title="美国、日本、印度确诊人数",pos_left="center",pos_bottom="1%"),# 标题
    xaxis_opts=opts.AxisOpts(name="日期"),# x轴
    yaxis_opts=opts.AxisOpts(name="确诊人数"),# y轴
    toolbox_opts=opts.ToolboxOpts(is_show=True),# 工具框   

)
实例：疫情数据对比
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import json

from pyecharts.charts import Line
from pyecharts import options as opts
from pyecharts.options import LabelOpts

line = Line()

us = open("D:\\BaiduNetdiskDownload\\美国.txt","r",encoding="utf-8")
jp = open("D:\\BaiduNetdiskDownload\\日本.txt","r",encoding="utf-8")
ind = open("D:\\BaiduNetdiskDownload\\印度.txt","r",encoding="utf-8")

us_data = us.read()
jp_data = jp.read()
ind_data = ind.read()

us_data = us_data.replace("jsonp_1629344292311_69436(","")
jp_data = jp_data.replace("jsonp_1629350871167_29498(","")
ind_data = ind_data.replace("jsonp_1629350745930_63180(","")

us_data = us_data[:-2]
jp_data = jp_data[:-2]
ind_data = ind_data[:-2]


us_data = json.loads(us_data)
jp_data = json.loads(jp_data)
ind_data = json.loads(ind_data)

x_in = us_data["data"][0]["trend"]["updateDate"]
y_in_us = us_data["data"][0]["trend"]["list"][0]["data"]
y_in_jp = jp_data["data"][0]["trend"]["list"][0]["data"]
y_in_ind = ind_data["data"][0]["trend"]["list"][0]["data"]

x_in = x_in[69:192]
y_in_us = y_in_us[69:192]
y_in_jp = y_in_jp[70:193]
y_in_ind = y_in_ind[24:147]

line.add_xaxis(x_in)
line.add_yaxis("美国",y_in_us,label_opts=LabelOpts(is_show=False))
line.add_yaxis("日本",y_in_jp,label_opts=LabelOpts(is_show=False),is_smooth=True)
line.add_yaxis("印度",y_in_ind,label_opts=LabelOpts(is_show=False),is_smooth=True)
line.set_global_opts(
    title_opts=opts.TitleOpts(title="美国、日本、印度确诊人数",pos_left="center"),# 标题
    legend_opts=opts.LegendOpts(pos_left="center",pos_bottom="1%"),# 图例
    xaxis_opts=opts.AxisOpts(name="日期"),# x轴
    yaxis_opts=opts.AxisOpts(name="确诊人数"),# y轴
    toolbox_opts=opts.ToolboxOpts(is_show=True),# 工具框

)
line.render("疫情.html")

us.close()
jp.close()
ind.close()
实例：中国疫情统计地图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
from contextlib import closing

from pyecharts.charts import Map
from pyecharts import options as opts
import json
maps=Map()

f = open("D:\\BaiduNetdiskDownload\\疫情.txt","r",encoding="utf-8")

china = f.read()

china = json.loads(china)
china_data = china["areaTree"][0]["children"]
i = 0
dic_china = {}
while i <= 33:
    if (china_data[i]["name"] == "北京" or china_data[i]["name"] == "上海"
            or china_data[i]["name"] == "重庆" or china_data[i]["name"] == "天津"):
        dic_china[china_data[i]["name"]+"市"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "内蒙古" or china_data[i]["name"] == "西藏":
        dic_china[china_data[i]["name"]+"自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "宁夏":
        dic_china[china_data[i]["name"]+"回族自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "新疆":
        dic_china[china_data[i]["name"]+"维吾尔自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "广西":
        dic_china[china_data[i]["name"]+"壮族自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "香港" or china_data[i]["name"] == "澳门":
        dic_china[china_data[i]["name"]+"特别行政区"] = china_data[i]["total"]["confirm"]
    else :
        dic_china[china_data[i]["name"]+"省"] = china_data[i]["total"]["confirm"]
    i += 1

list_china = list(dic_china.items()) # 把字典转换为列表
print(list_china)
maps.add("中国",list_china, "china")

maps.set_global_opts(
    title_opts=opts.TitleOpts(title="中国疫情地图",pos_left="center"),# 标题
    legend_opts=opts.LegendOpts(pos_left="center",pos_bottom="1%"),# 图例
    visualmap_opts=opts.VisualMapOpts(is_show=True,
                                      is_piecewise=True,
                                      pieces=[
                                          {"min":1,"max":9,"label":"1-9人","color":"#45d654"},
                                          {"min":10,"max":99,"label":"10-99人","color":"#4360e5"},
                                          {"min":100,"max":999,"label":"100-999人","color":"#0421a7"},
                                          {"min":1000,"max":9999,"label":"1000-9999人","color":"#ff980b"},
                                          {"min":10000,"max":99999,"label":"10000-99999人","color":"#cf4b34"},
                                          {"min":100000,"max":999999,"label":"100000-999999人","color":"#ff2700"},
                                          {"min":1000000,"label":"1000000人以上","color":"#4f0303",},
                                      ]# 视觉映射
                                      )
)

maps.render("中国地图.html")

f.close()
实例：河南省疫情地图
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
from contextlib import closing

from pyecharts.charts import Map
from pyecharts import options as opts
import json
maps=Map()

f = open("D:\\BaiduNetdiskDownload\\疫情.txt","r",encoding="utf-8")

china = f.read()

china = json.loads(china)
china_data = china["areaTree"][0]["children"]
i = 0
dic_china = {}
while i <= 33:
    if (china_data[i]["name"] == "北京" or china_data[i]["name"] == "上海"
            or china_data[i]["name"] == "重庆" or china_data[i]["name"] == "天津"):
        dic_china[china_data[i]["name"]+"市"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "内蒙古" or china_data[i]["name"] == "西藏":
        dic_china[china_data[i]["name"]+"自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "宁夏":
        dic_china[china_data[i]["name"]+"回族自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "新疆":
        dic_china[china_data[i]["name"]+"维吾尔自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "广西":
        dic_china[china_data[i]["name"]+"壮族自治区"] = china_data[i]["total"]["confirm"]
    elif china_data[i]["name"] == "香港" or china_data[i]["name"] == "澳门":
        dic_china[china_data[i]["name"]+"特别行政区"] = china_data[i]["total"]["confirm"]
    else :
        dic_china[china_data[i]["name"]+"省"] = china_data[i]["total"]["confirm"]
    i += 1

list_china = list(dic_china.items()) # 把字典转换为列表
print(list_china)
maps.add("中国",list_china, "china")

maps.set_global_opts(
    title_opts=opts.TitleOpts(title="中国疫情地图",pos_left="center"),# 标题
    legend_opts=opts.LegendOpts(pos_left="center",pos_bottom="1%"),# 图例
    visualmap_opts=opts.VisualMapOpts(is_show=True,
                                      is_piecewise=True,
                                      pieces=[
                                          {"min":1,"max":9,"label":"1-9人","color":"#45d654"},
                                          {"min":10,"max":99,"label":"10-99人","color":"#4360e5"},
                                          {"min":100,"max":999,"label":"100-999人","color":"#0421a7"},
                                          {"min":1000,"max":9999,"label":"1000-9999人","color":"#ff980b"},
                                          {"min":10000,"max":99999,"label":"10000-99999人","color":"#cf4b34"},
                                          {"min":100000,"max":999999,"label":"100000-999999人","color":"#ff2700"},
                                          {"min":1000000,"label":"1000000人以上","color":"#4f0303",},
                                      ]# 视觉映射
                                      )
)

maps.render("中国地图.html")

f.close()