追光学院
Yang Liangxi
2023-04-01

Python基础

# 注释

单行注释：# 简单注释内容

多行注释："""注释内容""" '''注释内容'''

# 变量

  • 由数字、字母、下划线组成
  • 不能数字开头
  • 不能使用内置关键字
  • 严格区分大小写
# 大驼峰命名法
MyTest = "tom"
# 小驼峰命名法
myTest = "zhang san"
# 下划线分割命名法
my_name = "yang rui"
1
2
3
4
5
6

# Bug

程序中的错误。

# 数据类型

  • float
  • int
  • str
  • bool
  • list
  • tuple
  • set
  • dict
num1 = 2.2
num2 = 2
name = 'hello'
isMan = True
l = [10, 20, 30]
t = (10, 20, 30)
s = {10, 20, 30}
d = {'name': 'yang liang', 'age': 22}

print(type(num1))
print(type(num2))
print(type(name))
print(type(isMan))
print(type(l))
print(type(t))
print(type(s))
print(type(d))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<class 'float'>
<class 'int'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
1
2
3
4
5
6
7
8

# 格式化输出

在 Python 中，格式符号是用于格式化输出字符串的特殊标记。以下是常见的格式符号及其用途：

  • %s：字符串类型。
  • %d：整数类型。
  • %f：浮点数类型。
  • %e：科学计数法类型。
  • %g：使用 %f 或 %e 格式中较短的表示方法。
  • %o：八进制整数。
  • %x：十六进制整数（小写字母）。
  • %X：十六进制整数（大写字母）。
  • %c：单个字符。
  • %r：将变量转换为字符串（使用 repr() 函数）。
  • %i：同 %d。
  • %u：无符号整数。

还可以使用其他格式选项来指定宽度、精度、对齐方式等。例如：

  • %10s：宽度为10个字符的字符串类型。
  • %6.2f：宽度为6个字符、小数点后保留2位的浮点数类型。
  • %-10s：左对齐、宽度为10个字符的字符串类型。

使用格式符号可以更方便地控制输出字符串的格式，特别是在需要输出大量数据时。

f_id = 1
f_name = '李白'
f_age = 22
f_add = '山西省太原市'
f_weight = 78.5

print('我的年龄是%d' % f_age)
print('我的姓名是%s' % f_name)
print('我的学号是%03d' % f_id)
print('我的地址是%s' % f_add)
print('我的体重是%.2f公斤' % f_weight)
print('我的姓名是%s，学号是%03d，年龄是%d，体重是%.2f公斤' % (f_name, f_id, f_age, f_weight))
print(f'我的姓名是{f_name}，学号是{f_id}，年龄是{f_age}，体重是{f_weight}公斤')  # 比%格式化更加高效，python3.6版本新增功能
1
2
3
4
5
6
7
8
9
10
11
12
13
我的年龄是22
我的姓名是李白
我的学号是001
我的地址是山西省太原市
我的体重是78.50公斤
我的姓名是李白，学号是001，年龄是22，体重是78.50公斤
我的姓名是李白，学号是1，年龄是22，体重是78.5公斤
1
2
3
4
5
6
7

# 转义符

在 Python 中，转义字符用反斜杠（\）来表示，它可以使特殊字符在字符串中得到正确的解释。以下是一些常用的 Python 转义字符：

  • \n：换行符
  • \t：制表符
  • \r：回车符
  • ': 单引号
  • ": 双引号
# 默认的是\n，用户可以自定义成任意的转义字符
print('hello\npython')
print('\thello python')
print('你好', end='\t')
print('世界', end='\n')
1
2
3
4
5
hello
python
	hello python
你好	世界
1
2
3
4

# 输入

result = input('请输入...')
print(f'您输入的是{result}')
print(f'收到的数据类型是{type(result)}')
1
2
3

# 数据类型转化函数

在Python中，可以使用以下函数来转换不同类型的数据：

  • int(x) - 将x转换为整数。例如：int('123')将返回整数123。
  • float(x) - 将x转换为浮点数。例如：float('3.14')将返回浮点数3.14。
  • str(x) - 将x转换为字符串。例如：str(123)将返回字符串'123'。
  • bool(x) - 将x转换为布尔值。例如：bool('')将返回False，bool('hello')将返回True。
  • list(x) - 将x转换为列表。例如：list('hello')将返回['h', 'e', 'l', 'l', 'o']。
  • tuple(x) - 将x转换为元组。例如：tuple([1, 2, 3])将返回(1, 2, 3)。
  • set(x) - 将x转换为集合。例如：set([1, 2, 3])将返回{1, 2, 3}。
  • dict(x) - 将x转换为字典。例如：dict([(1, 'one'), (2, 'two')])将返回{1: 'one', 2: 'two'}。

除了这些内置函数之外，还可以使用类构造函数，例如int()、float()、str()、bool()、list()、tuple()、set()和dict()，来将其他类型的对象转换为相应的类型。

z_num = 2
z_str = '10'
z_list = [10, 20, 30]
z_tuple = (10, 20, 30)

print(float(z_num))
print(float(z_str))
print(list(z_tuple))
print(tuple(z_list))
print(type(eval(z_str)))
1
2
3
4
5
6
7
8
9
10
2.0
10.0
[10, 20, 30]
(10, 20, 30)
<class 'int'>
1
2
3
4
5

# 算术运算符

Python中的算术运算符包括：

  • 加法运算符（+）
  • 减法运算符（-）
  • 乘法运算符（*）
  • 除法运算符（/）
  • 取余运算符（%）
  • 取整除运算符（//）
  • 幂运算符（**）
  • 小括号运算符()
ss_num1 = 10
ss_num2 = 20

print(ss_num1 - ss_num2)
print(ss_num1 + ss_num2)
print(ss_num1 * ss_num2)
print(ss_num1 / ss_num2)
print(ss_num1 // ss_num2)
print(ss_num1 % ss_num2)
print(ss_num1 ** ss_num2)
1
2
3
4
5
6
7
8
9
10
-10
30
200
0.5
0
10
100000000000000000000
1
2
3
4
5
6
7

# 赋值运算符

Python 赋值运算符用于将值分配给变量。常见的赋值运算符包括：

=：将右侧的值赋给左侧的变量。

fz_num1, fz_num2, fz_str1 = 1, 20, '火山'
fz_num3 = fz_num4 = 10

print(f'{fz_num1},{fz_num2},{fz_str1},{fz_num1},{fz_num3},{fz_num4}')
1
2
3
4
1,20,火山,1,10,10
1

# 复合赋值运算符

Python 中的复合赋值运算符是用于同时进行赋值和运算的操作符，它们可以使代码更简洁高效。常见的复合赋值运算符包括：

  • += ：加等于运算符，将右侧操作数加到左侧操作数，并将结果赋值给左侧操作数。
  • -= ：减等于运算符，将右侧操作数从左侧操作数中减去，并将结果赋值给左侧操作数。
  • *= ：乘等于运算符，将右侧操作数乘到左侧操作数中，并将结果赋值给左侧操作数。
  • /= ：除等于运算符，将左侧操作数除以右侧操作数，并将结果赋值给左侧操作数。
  • %= ：取模等于运算符，将左侧操作数对右侧操作数取模，并将结果赋值给左侧操作数。
  • //= ：取整除等于运算符，将左侧操作数除以右侧操作数并向下取整，并将结果赋值给左侧操作数。
  • **= ：幂等于运算符，将左侧操作数的值提高到右侧操作数次幂，并将结果赋值给左侧操作数。
ss_num1 = 10
ss_num2 = 20

ss_num1 -= ss_num2
print(ss_num1)
ss_num1 += ss_num2
print(ss_num1)
ss_num1 *= ss_num2
print(ss_num1)
ss_num1 /= ss_num2
print(ss_num1)
ss_num1 //= ss_num2
print(ss_num1)
ss_num1 %= ss_num2
print(ss_num1)
ss_num1 **= ss_num2
print(ss_num1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
-10
10
200
10.0
0.0
0.0
0.0
1
2
3
4
5
6
7

# 比较运算符

Python 中的比较运算符用于比较两个值之间的关系，结果为 True 或 False。以下是 Python 中常用的比较运算符：

  • ==：等于，用于比较两个值是否相等，例如：a == b。
  • !=：不等于，用于比较两个值是否不相等，例如：a != b。
  • >大于，用于比较左侧的值是否大于右侧的值，例如：a > b。
  • <：小于，用于比较左侧的值是否小于右侧的值，例如：a < b。
  • >=：大于等于，用于比较左侧的值是否大于等于右侧的值，例如：a >= b。
  • <=：小于等于，用于比较左侧的值是否小于等于右侧的值，例如：a <= b。 这些比较运算符可以用于任何数据类型，包括数字、字符串、列表、元组等。在进行比较时，Python 会根据数据类型和值自动进行类型转换和比较运算。
ss_num1 = 10
ss_num2 = 20

print(ss_num1 > ss_num2)
print(ss_num1 < ss_num2)
print(ss_num1 <= ss_num2)
print(ss_num1 >= ss_num2)
print(ss_num1 != ss_num2)
print(ss_num1 == ss_num2)
1
2
3
4
5
6
7
8
9
False
True
True
False
True
False
1
2
3
4
5
6

# 逻辑运算符

Python中有三种逻辑运算符：and（与）、or（或）、not（非）。

  • and：当两个操作数都为True时，结果为True；否则结果为False。
  • or：当两个操作数中至少有一个为True时，结果为True；否则结果为False。
  • not：如果操作数为True，结果为False；如果操作数为False，结果为True。
ss_num1 = 10
ss_num2 = 20

print(ss_num1 > ss_num2 and fz_num3 == fz_num4)
print(ss_num1 > ss_num2 or fz_num3 == fz_num4)
print(not fz_num3 == fz_num4)
print(ss_num1 and fz_num3)
print(ss_num2 and fz_num4)
print(ss_num2 or fz_num4)
print(ss_num1 or fz_num3)
1
2
3
4
5
6
7
8
9
10
False
True
False
0.0
10
20
10
1
2
3
4
5
6
7

# 条件语句

Python 中的条件语句使用 if、elif 和 else 关键字，语法格式如下：

if condition1:
    # if 条件为真执行的代码
elif condition2:
    # elif 条件为真执行的代码
else:
    # 以上条件都不为真执行的代码
1
2
3
4
5
6

其中，if 后面的 condition1 是一个表达式，如果它的值为 True，就会执行后面的代码块；否则会继续执行 elif 或者 else 语句。elif 和 else 都是可选的，你可以只使用 if 语句或者同时使用多个 elif 语句。

以下是一个简单的 Python 程序，演示了条件语句的用法：

if_age = 22
zhengJian = False
if (if_age > 0) and (if_age < 18):
    print(f'您输入的年龄是{if_age},童工')
elif (if_age >= 18) and (if_age < 60):
    print(f'您输入的年龄是{if_age},合法')
    if zhengJian:
        print("有工作证，可以进入园区!!")
    else:
        print("无证件，不能进入园区!!")
else:
    print(f'您输入的年龄是{if_age},退休')
1
2
3
4
5
6
7
8
9
10
11
12
您输入的年龄是22,合法
有工作证，可以进入园区
1
2

# 模块导入

import random

randNum = random.randint(0, 5)
print(randNum)
1
2
3
4

# 三目运算法

Python 的三目运算符也称为条件表达式，它是一种简化的 if-else 语句。

三目运算符的语法格式如下：

value_if_true if condition else value_if_false
1
numA = 1
numB = 10
numC = numA if numA > numB else numB
print(numC)
1
2
3
4
10
1

# while循环

i = 0
while i <= 2:
    print('媳妇我错了!')
    i += 1
1
2
3
4
媳妇我错了!
媳妇我错了!
媳妇我错了!
1
2
3
j = 0
r = 0
while j <= 100:
    if j % 2 == 0:
        r += j
    j += 1
else:
    print(f'1-100偶数和的运算的结果是{r}')
1
2
3
4
5
6
7
8
1-100偶数和的运算的结果是2550
1
m = 0
n = 0
while m < 100:
    if m % 2 == 0:
       m += 1
       continue
    m += 1
    n += m
else:
    print(f'结果是：{n}')
    print("这句话不知道能否执行到continue else")
1
2
3
4
5
6
7
8
9
10
11
结果是：2550
这句话不知道能否执行到continue else
1
2
m = 0
n = 0
while m < 100:
    m += 1
    n += m
    if n > 1000:
        print(f'{n}')
        print(f'吃到第{m}个结束不吃了。')
        break
    print(f'吃第{m}个')
else:
    print("这句话不知道能否执行到break else")
1
2
3
4
5
6
7
8
9
10
11
12
吃第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个
1035
吃到第45个结束不吃了。
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
j1 = 0
while j1 < 3:
    n1 = 0
    while n1 < 5:
        print('媳妇我错了！今晚我洗碗！')
        n1 += 1
    print('一套惩罚结束------------------------------------')
    j1 += 1
print('结束所有惩罚!')
1
2
3
4
5
6
7
8
9
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
一套惩罚结束------------------------------------
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
一套惩罚结束------------------------------------
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
媳妇我错了！今晚我洗碗！
一套惩罚结束------------------------------------
结束所有惩罚!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# for循环

str1 = 'hello yang liang xi'
for s in str1:
    if s == 'x':
        print(f'遇到了退出字符{s}')
        break
    print(s)
else:
    print("=====================")
1
2
3
4
5
6
7
8
h
e
l
l
o
 
y
a
n
g
 
l
i
a
n
g
 
遇到了退出字符x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
for s in str1:
    if s == 'x':
        print(f'遇到了字符{s}不打印')
        continue
    print(s)
else:
    print("=====================")
1
2
3
4
5
6
7
h
e
l
l
o
 
y
a
n
g
 
l
i
a
n
g
 
遇到了字符x不打印
i
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 字符串

Python字符串是不可变序列，具有丰富的内置方法，可以对其进行各种操作和转换。以下是一些常见的Python字符串方法：

  • str.capitalize(): 将字符串第一个字符转换为大写。
  • str.lower(): 将字符串转换为小写。
  • str.upper(): 将字符串转换为大写。
  • str.title(): 将每个单词的首字母转换为大写。
  • str.strip(): 去掉字符串开头和结尾的空白字符。
  • str.startswith(prefix): 判断字符串是否以指定的前缀开头。
  • str.endswith(suffix): 判断字符串是否以指定的后缀结尾。
  • str.replace(old, new[, count]): 将字符串中的旧子串替换为新子串，可以指定替换次数。
  • str.split([sep[, maxsplit]]): 将字符串按照指定的分隔符（默认是空格）分割成列表，可以指定分割次数。
  • str.join(iterable): 将可迭代对象中的元素按照指定的分隔符连接成一个字符串。
  • str.format(*args, **kwargs): 将字符串格式化，用参数替换占位符，可以使用位置参数或关键字参数。
  • str.isalnum(): 判断字符串是否只包含字母和数字。
  • str.isalpha(): 判断字符串是否只包含字母。
  • str.isdigit(): 判断字符串是否只包含数字。
  • str.islower(): 判断字符串是否只包含小写字母。
  • str.isupper(): 判断字符串是否只包含大写字母。
  • str.isnumeric(): 判断字符串是否只包含数字字符。
  • str.count(sub[, start[, end]]): 统计字符串中子串出现的次数。

这些方法只是Python字符串方法的一小部分。要了解更多，请查看官方文档

s_name = 'i am ' \
         'yang rui'
print(s_name)
1
2
3
i am yang rui
1
s_name = """i am 
yang rui"""
print(s_name)
1
2
3
i am 
yang rui
1
2
s_name = "i am " \
         "yang rui"
print(s_name)
1
2
3
i am yang rui
1
s_name = ' i\'m yang rui '
print(s_name)
print(s_name[1:5:1])
print(s_name[:5]) # 从位置0到位置5之前的数
print(s_name[1:])
print(s_name[:])
print(s_name[:: -1])
print(s_name[-4:-1])
print(s_name.find('yang', 0, 20))
print(s_name.find('yang'))
print(s_name.find('yangs'))
print(s_name.index('yang'))
print(s_name.count('yang'))
print(s_name.count('yangs'))
print(s_name.rfind('yangs'))
print(s_name.rindex('yang'))
print(s_name.replace('yang', 'zhang'))
print(s_name.split('yang'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 i'm yang rui 
i'm 
 i'm 
i'm yang rui 
 i'm yang rui 
 iur gnay m'i 
rui
5
5
-1
5
1
0
-1
5
 i'm zhang rui 
[" i'm ", ' rui ']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
str_list = ['aa', 'bb', 'cc']
print('...'.join(str_list))
print(s_name.capitalize())
print(s_name.title())
print(s_name.lower())
print(s_name.upper())
print(s_name.lstrip())
print(s_name.rstrip())
print(s_name.strip())
print(s_name.ljust(20, '.'))
print(s_name.rjust(20, '.'))
print(s_name.center(20, '.'))
print(s_name.startswith(' i'))
print(s_name.endswith('rui '))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
aa...bb...cc
 i'm yang rui 
 I'M Yang Rui 
 i'm yang rui 
 I'M YANG RUI 
i'm yang rui 
 i'm yang rui
i'm yang rui
 i'm yang rui ......
...... i'm yang rui 
... i'm yang rui ...
True
True
1
2
3
4
5
6
7
8
9
10
11
12
13
test = 'ssdsfsdfsfsfs'
test1 = '1213213131'
test2 = '    '
test3 = 'sd1123233'
print('==============')
print(test.isalpha())
print(test1.isalpha())
print(test2.isalpha())
print(test3.isalpha())
print('==============')
print(test.isdigit())
print(test1.isdigit())
print(test2.isdigit())
print(test3.isdigit())
print('==============')
print(test.isalnum())
print(test1.isalnum())
print(test2.isalnum())
print(test3.isalnum())
print('==============')
print(test.isspace())
print(test1.isspace())
print(test2.isspace())
print(test3.isspace())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
==============
True
False
False
False
==============
False
True
False
False
==============
True
True
False
True
==============
False
False
True
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 列表list

Python中的列表（list）是一种有序的集合数据类型，用于存储一组元素。列表中的元素可以是任何数据类型，包括数字、字符串、布尔值等等。以下是Python列表的一些常用用法：

  • 创建列表
my_list = [1, 2, 3, 4, 5]
1
  • 访问列表中的元素：可以使用索引来访问列表中的元素。Python中的索引从0开始，因此第一个元素的索引为0。
my_list = [1, 2, 3, 4, 5]
print(my_list[0])   # 输出1
1
2
  • 修改列表中的元素：可以通过索引来修改列表中的元素。
my_list = [1, 2, 3, 4, 5]
my_list[0] = 6
print(my_list)   # 输出[6, 2, 3, 4, 5]
1
2
3
  • 列表切片：可以使用切片来获取列表的子集。
my_list = [1, 2, 3, 4, 5]
print(my_list[1:3])   # 输出[2, 3]
1
2
  • 添加元素：可以使用append()方法向列表末尾添加一个元素。
my_list = [1, 2, 3, 4, 5]
my_list.append(6)
print(my_list)   # 输出[1, 2, 3, 4, 5, 6]
1
2
3
  • 删除元素：可以使用del关键字或者remove()方法删除列表中的元素。
my_list = [1, 2, 3, 4, 5]
del my_list[0]
print(my_list)   # 输出[2, 3, 4, 5]

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)   # 输出[1, 2, 4, 5]
1
2
3
4
5
6
7
  • 列表长度：可以使用len()函数获取列表的长度。
my_list = [1, 2, 3, 4, 5]
print(len(my_list))   # 输出5
1
2
lb_list = [10, '20', 30, 'yang liang xi', 10]
print(lb_list[0]) # 10
print(lb_list[1]) # 20
print(lb_list.index(10, 0, 5)) # 0
print(lb_list.count(10)) # 2
print(len(lb_list)) # 5
print(10 in lb_list) # True
print(100 in lb_list) # False
print(200 not in lb_list) # True
1
2
3
4
5
6
7
8
9
lb_list.append('张三')
lb_list.append(10)
lb_list.extend('10')
lb_list.extend(['10', 2000])
lb_list.insert(2, '1k0')
print(lb_list) # [10, '20', '1k0', 30, 'yang liang xi', 10, '张三', 10, '1', '0', '10', 2000]
1
2
3
4
5
6
ele = lb_list.pop()
print(ele) # 2000
1
2
del (lb_list[0])
print(lb_list) # ['20', '1k0', 30, 'yang liang xi', 10, '张三', 10, '1', '0', '10']
1
2
ele = lb_list.pop(7)
print(ele) # 1
1
2
lb_list.clear()
print(lb_list) # []
1
2
lb_list = [10, '2x0', 300, 'yang liang xi', '10s']
lb_list.reverse()
print(lb_list) # ['10s', 'yang liang xi', 300, '2x0', 10]
1
2
3
lb_list = [10, 20, 300, 1, 5]
lb_list.sort()
print(lb_list) # [1, 5, 10, 20, 300]
1
2
3
lb_list2 = lb_list.copy()
print(lb_list2) # [1, 5, 10, 20, 300]
1
2
i = 0
while i < len(lb_list2):
    print(lb_list2[i], end="\t")
    i += 1
else:
    print("循环结束")

# 1	5	10	20	300
# 循环结束
1
2
3
4
5
6
7
8
9
for item in lb_list2:
    print(item, end="\t")

# 1	5	10	20	300
1
2
3
4
lb_list = [['李四', '张三', '王五'], ['李四1', '张三1', '王五1'], ['李四2', '张三2', '王五2']]
print() 
index = 0
while index < len(lb_list):
    index1 = 0
    while index1 < len(lb_list[index]):
        print(lb_list[index][index1], end="\t")
        index1 += 1
    else:
        # print(f'第{index1}... ...')
        print()
    index += 1
else:
    # print(f'第{index}... ...')
    print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 八位老师
teachers = ['zhang san', 'lisi', 'wang wu', 'zhao liu', 'hu ma cha', 'gou sheng', 'lv dan']
offices = [[], [], []]
for name in teachers:
    num = random.randint(0, 2)
    offices[num].append(name)
else:
    print(offices)
1
2
3
4
5
6
7
8

# 元组Tuple

在 Python 中，元组（tuple）是一种序列数据类型，类似于列表（list），但是元组是不可变的（immutable），即一旦创建，元组中的元素不能被修改、添加或删除。元组使用圆括号来表示，其中的元素用逗号分隔。例如：

t0 = (10, 20, 30, 10)
t1 = (10,)  # 只存放一个元素的写法
print(t0.index(10)) # 0
print(t0.count(10)) # 2
print(len(t0)) # 4
1
2
3
4
5

元组中嵌套的列表是支持修改的。

# 字典Dic

Python 字典是一种用于存储键-值对的数据结构，也被称为哈希表或关联数组。以下是一些 Python 字典的基本用法：

  • 创建字典:可以使用花括号 {} 或 dict() 函数来创建一个空字典，也可以在花括号中使用键值对初始化字典。
# 创建一个空字典
my_dict = {}

# 使用键值对初始化字典
my_dict = {"apple": 1, "banana": 2, "orange": 3}

# 使用 dict() 函数初始化字典
my_dict = dict(apple=1, banana=2, orange=3)
1
2
3
4
5
6
7
8
  • 访问字典中的值:可以使用方括号 [] 来访问字典中的值，其中方括号内是键。
# 访问字典中的值
print(my_dict["apple"]) # 输出：1
1
2

如果访问的键不存在，会抛出 KeyError 异常。可以使用 get() 方法来避免这种情况。

# 使用 get() 方法访问字典中的值
print(my_dict.get("pear")) # 输出：None
print(my_dict.get("pear", "not found")) # 输出：not found
1
2
3
  • 添加或修改键值对:可以使用方括号 [] 来添加或修改字典中的键值对，其中方括号内是要添加或修改的键。如果键不存在，则添加键值对；如果键已经存在，则修改对应的值。
# 添加或修改字典中的键值对
my_dict["pear"] = 4
my_dict["apple"] = 5
print(my_dict) # 输出：{"apple": 5, "banana": 2, "orange": 3, "pear": 4}
1
2
3
4
  • 删除键值对:可以使用 del 关键字来删除字典中的键值对，其中关键字后面是要删除的键。
# 删除字典中的键值对
del my_dict["orange"]
print(my_dict) # 输出：{"apple": 5, "banana": 2, "pear": 4}
1
2
3
  • 遍历字典:可以使用 for 循环遍历字典中的所有键或值，或同时遍历键和值。
# 遍历字典中的所有键
for key in my_dict:
    print(key)

# 遍历字典中的所有值
for value in my_dict.values():
    print(value)

# 遍历字典中的所有键值对
for key, value in my_dict.items():
    print(key, value)
1
2
3
4
5
6
7
8
9
10
11
  • 其他常用方法:除了上述基本用法外，Python 字典还提供了许多常用方法，如 keys() 返回字典中所有的键，values() 返回字典中所有的值，items() 返回字典中所有的键值对，pop() 删除指定键的值并返回该值，clear() 清空字典等。
dic = {'name': "zhang san", 'age': 22, 'gender': '男'}
print(dic) # {'name': 'zhang san', 'age': 22, 'gender': '男'}
print(dic['name']) # zhang san
dic['id'] = 100
print(dic) # {'name': 'zhang san', 'age': 22, 'gender': '男', 'id': 100}
dic['id'] = 110
print(dic) # {'name': 'zhang san', 'age': 22, 'gender': '男', 'id': 110}
del dic['name']
print(dic) # {'age': 22, 'gender': '男', 'id': 110}
# del dic['name']
# print(dic)
# dic.clear()
# print(dic)
dic['name'] = 'zhang li juan'
print(dic.get('name', 'yang liang xi')) # zhang li juan
print(dic.get('names', 'yang liang xi')) # yang liang xi
print(dic.keys()) # dict_keys(['age', 'gender', 'id', 'name'])
print(dic.values()) # dict_values([22, '男', 110, 'zhang li juan'])
print(dic.items()) # dict_items([('age', 22), ('gender', '男'), ('id', 110), ('name', 'zhang li juan')])

for key in dic.keys():
    print(key)

# age
# gender
# id
# name

for value in dic.values():
    print(value)

# 22
# 男
# 110
# zhang li juan

for item in dic.items():
    print(item)

# ('age', 22)
# ('gender', '男')
# ('id', 110)
# ('name', 'zhang li juan')

for key, value in dic.items():
    print(f'{key}={value}')

# age=22
# gender=男
# id=110
# name=zhang li juan
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

# 集合Set

在 Python 中，set 是一种集合数据类型，它包含一组无序且不重复的元素。以下是一些 set 的常见用法：

  • 创建一个空的 set：
my_set = set()
1
  • 创建一个带有元素的 set：
my_set = {1, 2, 3}
1
  • 添加元素到 set：
my_set.add(4)
1
  • 从 set 中删除元素
my_set.remove(2)
1
  • 判断元素是否存在于 set 中：
if 2 in my_set:
    print("2 is in the set")
1
2
  • 获取 set 的长度：
print(len(my_set))
1
  • 对两个 set 进行交集运算：
set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection = set1.intersection(set2)
1
2
3
  • 对两个 set 进行并集运算：
set1 = {1, 2, 3}
set2 = {2, 3, 4}
union = set1.union(set2)
1
2
3
  • 对两个 set 进行差集运算：
set1 = {1, 2, 3}
set2 = {2, 3, 4}
difference = set1.difference(set2)
1
2
3
  • 对两个 set 进行对称差集运算：
set1 = {1, 2, 3}
set2 = {2, 3, 4}
symmetric_difference = set1.symmetric_difference(set2)
1
2
3
jh = {10, 20, 30, 40, 10}  # 去重
jh1 = set()
print(jh) # {40, 10, 20, 30}
print(jh1) # set()
jh.add(200)
print(jh) # {40, 200, 10, 20, 30}
jh.update([89, 98])
print(jh) # {98, 40, 200, 10, 20, 89, 30}
1
2
3
4
5
6
7
8
jh.update('2324234sdfsfdsf')
print(jh) # {98, '3', 's', 40, 200, 10, '4', 'd', 20, 89, '2', 30, 'f'}
jh.remove(10)
print(jh) # {98, '3', 's', 40, 200, '4', 'd', 20, 89, '2', 30, 'f'}
jh.discard(10)  # 不报错
print(jh) # {98, '3', 's', 40, 200, '4', 'd', 20, 89, '2', 30, 'f'}
jh.pop()
print(jh) # {'3', 's', 40, 200, '4', 'd', 20, 89, '2', 30, 'f'}
jh.pop()
print(jh) # {'s', 40, 200, '4', 'd', 20, 89, '2', 30, 'f'}
print(10 in jh) # False
print(100 not in jh) # True
1
2
3
4
5
6
7
8
9
10
11
12

提示

集合内部的数据不可以重复

# 函数

Python 函数是一段可重复使用的代码块，用于执行特定的任务或计算，接受输入并返回输出。函数的主要作用是将复杂的程序分解成小的、可重用的代码块，从而使程序更加可读、可维护和可测试。在Python中，函数可以完成以下任务：

  1. 提高代码的可重用性：将重复使用的代码封装成函数，可以在程序的任何地方调用这个函数，从而节省时间和代码量。
  2. 实现模块化设计：通过函数将一个大的程序分解为小的模块，有助于更好地组织和管理代码。
  3. 提高代码的可读性和可维护性：将复杂的逻辑和算法封装在函数中，使程序更加易于理解和修改。
  4. 实现抽象和封装：函数可以屏蔽底层实现细节，只暴露必要的接口，从而增强代码的抽象性和安全性。
  5. 支持递归调用：Python函数支持递归调用，使得处理递归问题更加简单和直观。

定义函数：

def 函数名(参数):
    代码1
    代码2
1
2
3

函数说明文档：保存函数解释说明的信息

def 函数名():
    """
    函数说明文档
    """
1
2
3
4

调用函数：函数名(参数)

函数嵌套调用：一个函数内部嵌套调用另一个函数

提示

  • 函数必须是先定义后调用
  • 函数没调用，里面的代码不会执行
  • 定义函数的时候里面的代码并没有执行
def function_name(parameter1, parameter2, ...):
    # 函数体
    return value
1
2
3

其中，function_name 是函数名，参数parameter1，parameter2等是传递给函数的输入。函数体包含在缩进块中，它执行特定的任务。return关键字用于返回函数执行的结果。函数可以返回一个值或一组值。要调用函数，可以通过函数名和所需参数列表来调用它。例如，要调用上面的函数，可以使用以下代码：

sum = add_numbers(10, 20)
print(sum)
1
2
m = 100
def add_num(a, b):
    """
    求和函数：
    :param a:
    :param b:
    :return:
    """
    global m
    m = 100
    result = a + b + y
    print(result) # 13
    print(m) # 100
1
2
3
4
5
6
7
8
9
10
11
12
13
add_num(1, 2)

help(add_num)  
# add_num(a, b)
#     求和函数：
#     :param a:
#     :param b:
#     :return:

print(f'm是100吗：{m}') # m是100吗：100
1
2
3
4
5
6
7
8
9
10
def add_num1(a, b, c=41):
    global m
    m = 200
    print(m)
    print(a + b + c)
1
2
3
4
5
add_num1(100, 200)  

# 200
# 341

print(m) # 200
print(f'm是200吗{m}') # m是200吗200
1
2
3
4
5
6
7
def fun1(name, age=20, gender='男'):
    return name, age, gender
1
2

# 函数高级用法

变量作用域：变量作用域指的是变量生效的范围，主要分两类局部变量和全局变量。

局部变量是定义在函数体内部的变量，即只在函数体内部生效。局部变量的作用，在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

全局变量指的是在函数体内部、外部都生效的变量。如果在函数内部修改了全局变量的值，那么在函数体内输出的就是修改后的数据。要想在函数体外也输出修改后的全局变量，那么函数体内需要用global修饰该全局变量。

global修改全局变量的值

m=0
def add_num():
    global m
    m = 200
    print(m)

print(m) # 0
add_num() # 200
print(m) # 200
1
2
3
4
5
6
7
8
9

函数的参数：

  1. 位置参数：调用函数的时候根据函数定义的参数位置来传递参数。传递的参数类型和位置需要与定义时的参数类型个数必须一致。
  2. 关键字参数：通过键=值形式指定参数。可以让函数更加清晰，容易使用，同时也清除了参数顺序的问题。函数调用时，如果有位置参数，位置参数必须位于键值参数之前，但关键字参数不存在先后顺序关系。
# 关键字参数
def user_info(name, age, gender):
    print(f'姓名是{name},年龄是{age},性别是{gender}')

user_info('张三', gender='男', age=20) # 姓名是张三,年龄是20,性别是男
user_info('李四', age=22, gender='女') # 姓名是李四,年龄是22,性别是女
1
2
3
4
5
6
  1. 缺省参数：也叫默认参数，定义函数时为函数提供默认值，调用函数时不用为该参数传输数值。注意所有位置参数必须位于键值参数和默认参数之前。调用函数时如果为默认参数传递数值那么会修改这个参数的值。
# 缺省参数
def user_info(name, age, gender='男'):
    print(f'姓名是{name},年龄是{age},性别是{gender}')


user_info('张三', age=20)  # 姓名是张三,年龄是20,性别是男
user_info('李四', age=22, gender='女') # 姓名是李四,年龄是22,性别是女
1
2
3
4
5
6
7
  1. 不定长参数：用于不确定调用的时候会传递多少个参数(不传参数也可以的)场景。此时，可用包裹位置参数，或者包裹关键字参数，来进行参数传递，会显得更加方便。
# 包裹位置不定长参数
def user_info(*args):
    print(args)


user_info('张三', 20)  # ('张三', 20)
user_info('李四', 22, '女')  # ('李四', 22, '女')
1
2
3
4
5
6
7
# 包裹关键字不定长参数
def user_info(**kwargs):
    print(kwargs)


user_info(name='张三', age=20)  # {'name': '张三', 'age': 20}
user_info(name='李四', age=22, gender='女')  # {'name': '李四', 'age': 22, 'gender': '女'}
1
2
3
4
5
6
7

元组拆包

# 元组拆包
def return_num():
    return 100, 200


num1, num2 = return_num()
print(num1) # 100
print(num2) # 200
1
2
3
4
5
6
7
8

字典拆包

# 字典拆包
def return_dic():
    return {'name': 'zhangsan', 'age': 20}


dic = return_dic()
a, b = return_dic()
print(dic)  # {'name': 'zhangsan', 'age': 20}
print(a)  # name
print(b)  # age
print(dic[a])  # zhangsan
print(dic[b])  # 20
1
2
3
4
5
6
7
8
9
10
11
12

交换变量

# 交换变量
a, b = 1, 2
a, b = b, a
print(a) # 2
print(b) # 1
1
2
3
4
5

# 引用

在python中值是靠引用来传递的。

id(value) # 查看变量value在内存中地址
1
# 引用
a = 1
b = a
print(a) # 1
print(b) # 1

print(id(a)) # 1591859376
print(id(b)) # 1591859376
1
2
3
4
5
6
7
8

# 可变类型和不可变类型

  • 可变类型：列表-字典-集合
  • 不可变类型：整型-浮点型-字符型-元组

# 递归

递归是一种编程思想，应用场景：

  1. 遍历文件夹下的所有文件
  2. 在算法中离不开递归

递归的特点

  1. 函数自己调用自己
  2. 有函数出口
def sum_num(num):
    if num == 1:
        return 1
    return num + sum_num(num - 1)

print(sum_num(4)) # 10
1
2
3
4
5
6

# lambda表达式

lambda 参数列表：表达式

无参数: fn1=lambda:200 
print(fn1()) # 200
1
2
一个参数：fn1=lambda a:a
print(fn1('hello world')) # hello world
1
2
两个参数：fn1=lambda a,b:a+b
print(fn1(1,2)) # 3
1
2
默认参数：fn1=lambda a,b,c=100:a+b+c
print(fn1(1,2)) # 103
1
2
不定长位置参数：fn1=lambda *args:args
print(fn1(1,2)) # (1,2)
1
2
不定长键值参数：fn1=lambda **kwargs:kwargs
print(fn1(name='zhangsan',age=20)) # {'name':'zhangsan', 'age':20}
1
2
fn = lambda a, b: a if a > b else b
print(fn(1000, 3000)) # 3000
1
2
students = [{'name': 'tom', 'age': 24}, {'name': 'jack', 'age': 22}, {'name': 'lili', 'age': 23}]
students.sort(key=lambda x: x['name'])
print(students) # [{'name': 'jack', 'age': 22}, {'name': 'lili', 'age': 23}, {'name': 'tom', 'age': 24}]
1
2
3
students.sort(key=lambda x: x['name'], reverse=True)
print(students) # [{'name': 'tom', 'age': 24}, {'name': 'lili', 'age': 23}, {'name': 'jack', 'age': 22}]
1
2

# 高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

def add(num1, num2, f):
    return f(num1) + f(num2)

print(add(2, -10, abs)) # 12
1
2
3
4

内置高阶函数:

r = map(lambda x: x ** 2, [1, 2, 3, 4, 5, 6])

for ele in r:
    print(ele, end="\t")
else:
    print()
1
2
3
4
5
6

# 公共运算符之高级用法

  • + 合并 (字符串-元组-列表)
  • * 复制 (字符串-元组-列表)
  • in 元素是否存在 (字符串-元组-列表-字典)
  • not in 元素是否不存在 (字符串-元组-列表-字典)
  • len() 计算容器中元素的个数 (字符串-元组-列表-集合-字典)
  • del或del() 删除
  • max() 返回容器中元素最大值
  • min() 返回容器中元素最小值
  • range(start, end, step) 生成从start到end的数字，步长为step，供for循环使用，print(range(start, end, step)返回一个range可迭代对象
  • enumerate(可遍历对象，start=0) 函数用于将一个可以遍历的数据对象(如列表、元组或字符串)组合成一个索引序列，同时列出数据和数据下标，一般用在for循环当中
s1 = 'sss'
s2 = 'dfdfdfd'
print(s1 + s2) # 'ssdfdfdfd'
print('s' in s1) # True
print('s' not in s1) # Flase
1
2
3
4
5
s1 = [10, 23]
s2 = [10, 34, 88]
print(s1 + s2) # [10, 23, 10, 34, 88]
1
2
3
s1 = (10, 23)
s2 = (10, 34, 88)
print(s1 + s2) # (10, 23, 10, 34, 88)
1
2
3
s1 = 'sss'
print(s1 * 5) # sssssssssssssss
1
2
s1 = [10, 23]
print(s1 * 5) # [10, 23, 10, 23, 10, 23, 10, 23, 10, 23]
1
2
s1 = (10, 23, 222, 254, 74, 78)
print(s1 * 5) # (10, 23, 222, 254, 74, 78, 10, 23, 222, 254, 74, 78, 10, 23, 222, 254, 74, 78, 10, 23, 222, 254, 74, 78, 10, 23, 222, 254, 74, 78)
print(max(s1)) # 254
print(min(s1)) # 10
print(len(s1)) # 6
1
2
3
4
5
s1 = (10, 23, 222, 254, 74, 78)
print(range(0, 100, 1)) # range(0, 100)
for i in range(0, 10, 3):
    print(i) # 0 3 6 9
for i in enumerate(s1):
    print(i) # (0, 10)(1, 23)(2, 222)(3, 254)(4, 74)(5, 78)
for i in enumerate(s1, start=2):
    print(i) # (2, 10)(3, 23)(4, 222)(5, 254)(6, 74)(7, 78)
s1 = {1, 2, 3, 4, 5, 6, 7}
l1 = {11, 22, 33, 44, 55, 66, 77}
print(tuple(s1)) # (1, 2, 3, 4, 5, 6, 7)
print(tuple(l1)) # (33, 66, 11, 44, 77, 22, 55)

del s1
print(s1) # 报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 推导式用法

用一个表达式创建一个有规律的列表或者控制一个有规律的列表。列表推导式又叫列表生成式。

# 使用while循环实现列表创建
ls = []
i = 0
while i < 10:
    ls.append(i)
    i += 1
else:
    print(ls)
ls.clear()
1
2
3
4
5
6
7
8
9
# 使用for循环实现列表创建
for i in range(0, 10, 1):
    ls.append(i)
    i += 1
else:
    print(ls)
ls.clear()

#列表推导式实现
ls = [i for i in range(0, 10, 1)]
print(ls)
ls.clear()
1
2
3
4
5
6
7
8
9
10
11
12
# 带if条件的列表推导式
ls = [i for i in range(0, 10, 1) if i % 2 == 0]
print(ls) # [0, 2, 4, 6, 8]
ls.clear()
1
2
3
4
ls = [(i, j) for i in range(1, 3, 1) for j in range(0, 3, 1)]
print(ls) # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
1
2
ls1 = ['name', 'age', 'gender', 'addr']
ls2 = ['zhang san', 22, '男', '清华同方科技广场']
dic = {ls1[i]: ls2[i] for i in range(len(ls1))}
print(dic) # {'name': 'zhang san', 'age': 22, 'gender': '男', 'addr': '清华同方科技广场'}
1
2
3
4
dic = {'华硕': 220, '弘基': 209, '联想': 220, '戴尔': 333}
dic = {key: value for key, value in dic.items() if value >= 220}
print(dic) # {'华硕': 220, '联想': 220, '戴尔': 333}
1
2
3

# 文件操作

  1. 文件操作的作用：读取-写入-复制
  2. 文件的基本操作：打开-读写-关闭
  3. 文件备份
  4. 文件夹操作
打开文件模式

打开文件模式是指打开文件时使用的读写模式。Python 3.7 提供了以下几种打开文件模式:

'r':读取模式，打开文件后只能读取文件的内容，不能写入文件。例如：open('file.txt', 'r')。

'w':写入模式，打开文件后只能向文件中写入内容，不能读取文件。例如：open('file.txt', 'w')。

'a':追加模式，打开文件后只能向文件中追加内容，不能修改文件。例如：open('file.txt', 'a')。

'x':独占写入模式，打开文件后只能向文件中写入内容，其他用户无法访问该文件。例如：open('file.txt', 'x')。

'b':二进制模式，打开文件时，以二进制模式处理文件内容，适用于非文本文件，如图片、视频等。例如：open('file.txt', 'b')。

't':文本模式，打开文件时，以文本模式处理文件内容，适用于文本文件。例如：open('file.txt', 't')。

以上模式常用于 Python 脚本中打开文件，根据实际需求选择合适的打开模式。同时，Python 3.7 还提供了 with 语句，可以在运行期间动态打开和关闭文件，避免了代码重复和文件操作错误

  • 打开文件操作步骤：打开文件-读写文件操作-关闭文件
# 打开文件
with open('file.txt', 'w') as f:  
    f.write('Hello, World!')  

这个例子打开了一个名为 "file.txt" 的文件，以写入模式打开。上面的代码将写入 "Hello, World!" 到文件中。
1
2
3
4
5
# 打开文件
with open('file.txt', 'r') as f:  
    content = f.read()  

这个例子打开了一个名为 "file.txt" 的文件，以读取模式打开。上面的代码将读取文件中的所有内容并存储在 "content" 变量中。
1
2
3
4
5
# 关闭文件
with open('file.txt', 'w') as f:  
    f.write('Hello, World!')  
    f.close() 

这个例子打开了一个名为 "file.txt" 的文件，以写入模式打开。在上面的代码中，我们写入了 "Hello, World!" 到文件中，然后关闭了文件。
1
2
3
4
5
6
# 关闭文件
with open('file.txt', 'r') as f:  
    content = f.read()  
    f.close()  

这个例子打开了一个名为 "file.txt" 的文件，以读取模式打开。在上面的代码中，我们读取了文件中的所有内容并存储在 "content" 变量中，然后关闭了文件。
1
2
3
4
5
6
# 读取文件
with open('file.txt', 'r') as f:  
    content = f.read()  
    print(content)  

这个例子打开了一个名为 "file.txt" 的文件，以读取模式打开。在上面的代码中，我们读取了文件中的所有内容并存储在 "content" 变量中，然后打印了内容。
1
2
3
4
5
6
# 写入文件
with open('file.txt', 'w') as f:  
    f.write('Hello, World!')

这个例子打开了一个名为 "file.txt" 的文件，以写入模式打开。在上面的代码中，我们将 "Hello, World!" 写入了文件中。
1
2
3
4
5
  • 读文件是 Python 3.7 中文件操作中的基本操作之一，可以使用 open() 函数打开文件，然后使用 read() 方法读取文件的内容。下面是一个简单的例子:
with open('file.txt', 'r') as f:  
    content = f.read()  
    print(content)
1
2
3

上述代码使用了 with 语句打开文件，然后在 with 语句块中读取文件的内容。with 语句会自动关闭文件，避免了代码重复和文件操作错误。如果要读取多个文件，可以使用列表或字典存储文件名和文件内容，然后遍历列表或字典读取文件内容。例如:

files = {'file1.txt': 'Hello, World!', 'file2.txt': 'Goodbye, World!'}  
for file, content in files.items():  
    print(file, content)
1
2
3

上述代码使用字典存储了文件名和文件内容，然后遍历字典读取文件内容。需要注意的是，读取文件时需要使用双引号或单引号包裹文件内容，以防止文件内容包含特殊字符或空格导致的语法错误。除了使用 open() 函数和 read() 方法读取文件外，还可以使用 readlines() 方法读取文件的内容，该方法可以读取文件中的所有行并返回一个列表。例如:

with open('file.txt', 'r') as f:  
    lines = f.readlines()  
    print(lines)
1
2
3

上述代码使用了 readlines() 方法读取文件的内容，返回了一个包含所有行列表。需要注意的是，readlines() 方法会读取文件中的所有行，如果文件内容很长，可能会导致内存溢出。因此，如果需要读取较长的文件，建议使用分块读取的方式，将文件分成较小的块进行读取。

在 Python 3.7 中，写文件可以使用 open() 函数打开文件，并使用 write() 方法向文件中写入内容。下面是一个简单的例子:

with open('file.txt', 'w') as f:    
    f.write('Hello, World!')
1
2

上述代码使用 with 语句打开文件，然后在 with 语句块中向文件中写入内容。with 语句会自动关闭文件，避免了代码重复和文件操作错误。如果要写入多个文件，可以使用列表或字典存储文件名和文件内容，然后遍历列表或字典向文件中写入内容。例如:

files = {'file1.txt': 'Hello, World!', 'file2.txt': 'Goodbye, World!'}    
for file, content in files.items():    
    with open(file, 'w') as f:    
        f.write(content)
1
2
3
4

上述代码使用字典存储了文件名和文件内容，然后遍历字典向文件中写入内容。需要注意的是，写文件时需要使用单引号或双引号包裹文件内容，以防止文件内容包含特殊字符或空格导致的语法错误。除了使用 open() 函数和 write() 方法向文件中写入内容外，还可以使用 writelines() 方法向文件中写入多个内容，该方法可以将多个内容写入文件中。例如:

with open('file.txt', 'w') as f:    
    f.writelines(['Hello, World!', 'Goodbye, World!'])
1
2

上述代码使用了 writelines() 方法向文件中写入多个内容，返回了一个包含所有内容的新列表。需要注意的是，writelines() 方法会将所有内容写入文件中，如果文件内容很长，可能会导致内存溢出。因此，如果需要写入较长的文件，建议使用分块写入的方式，将文件分成较小的块进行写入。

  • seek()移动文件指针
文件对象.seek(偏移量，起始位置)

起始位置取值 0,1,2。0 开头  1 当前位置 2 结尾
1
2
3
  • 要在 Python 3.7 中备份文件，可以使用第三方库pydub,该库支持 Python 3.x 版本。以下是一个简单的示例，演示如何使用pydub库备份文件:
import pydub  
import os

# 备份文件路径  
备份文件路径 = "path/to/backup/file"

# 读取备份文件  
with open(备份文件路径，"r") as f:  
    备份内容 = f.read()

# 创建备份文件夹  
if not os.path.exists(备份文件路径):  
    os.makedirs(备份文件路径)

# 打印备份文件路径  
print(f"Backup file path: {备份文件路径}")

# 备份文件内容到新文件  
with open(备份文件路径，"w") as new_file:  
    new_file.write(备份内容)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这个示例首先使用pydub库读取备份文件的内容，然后创建备份文件夹，如果不存在则自动创建。最后，将备份文件的内容写入新文件中。请注意，pydub库需要安装才能使用。可以使用以下命令在终端或命令提示符中安装:

pip install pydub
1

如果你使用的是 Python 3.x 版本，可以使用pip3命令安装pydub库:

pip3 install pydub
1
编辑 (opens new window)
#Python
上次更新: 2025/02/10, 20:20:37

← 面向对象→

最近更新
01
Git问题集合
01-29
02
安装 Nginx 服务器
01-25
03
安装 Docker 容器
01-25
更多文章>
冀ICP备2025101965号
vdoing 支持|copyright©2021-2025 Yang Liangxi
×
×