繁依Fanyi0

这个屌丝很懒，什么也没留下！

热门标签

Python从入门到自闭(基础篇)

作者：繁依Fanyi0 | 2024-05-26 16:01:02

踩

Python从入门到自闭(基础篇)

作者:日魔

Python的创始人吉多.范罗苏姆(Guido va Rossum)(外号:龟叔)

一. Python 的历史：

1. 1989年圣诞节的时候为了打发时间决定开发一款新的脚本解释程序。
1

199年第一个python编译器诞生，他是用C语言实现的并能调用C语言的库文件。
1994年Python_1.0诞生，添加了lambda,map,filter and reduce.
2000年Python_2.0诞生，添加了垃圾回收机制。
2004年python_2.4诞生，添加了著名的WEB框架Django.

二. Python 小知识

这里可能会让一些比较白的小白看的脑袋疼所以可以直接阅读下面的Python基础

1.首先我们来看看在不同角度编程语言的分类(这里只从三个角度进行分类):

按转换过程来分类
1. 编译型: 就是你得到了一本外星人的书，需要一个外星翻译给你把整本书翻译成你能看懂的语言在给你。
  
  代表语言:C，C++…
2. 解释型:就是你得到了一本外星人的书，需要一个外星翻译坐在你身边你想翻译那段就给你翻译那段。
  
  代表语言:Python，JavaScript，PHP…
3. 混合型:上面两种的结合。
  
  代表语言:Java，C#…
按运行时结构状态分类
1. 动态语言:运行时代码可根据特殊情况进行改变自身结构。
  1. 代表语言:Python，JavaScript，PHP…
2. 静态语言:运行时结构不可改变。
  1. 代表语言:C，Java，C++，C#…
按数据类型的监管分类
1. 动态类型语言:在运行期间才去做数据类型检查的语言。
  1. 代表语言:Python，JavaScript，PHP…
2. 静态类型语言:变异期间(或运行之前)确定的，编写代码时要明确变量的数据类型。
  1. 代表语言:C，C++，C#，Java…

2.看完编程语言的分类之后我们在来看看Python解释器的分类

CPython:从官网上下载的解释器也是使用最广的解释器。
IPython:基于CPython之上的交互式解释器。
PyPy:另一种Python解释器，执行速度块，利用JIT技术对Python代码进行动态编译所以可以显著提高Python代码的执行速度。
Jython:是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节执行。
IronPython:和Jython类似，不过他是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

3.接下来我们来看看Python的优缺点

Python的优点:
1. “优雅”，“明确”，“简单”，虽然入门比较容易简单但将来进行深入学习时还是非常困难的！
2. 开发效率非常高，拥有强大的第三方库。
3. 可移植性，他开源的属性让他注定有着优秀的可移植性。
4. 可扩展性，如果你需要代码运行的更快或希望某些算法不想被公开，你可以把你的部分大妈使用C或C++进行编写然后在Python程序中使用它们。
5. 可嵌入性，你可以将Python嵌入你C或C++程序，从而向你的程序用户提供脚本功能。
Python的缺点:
1. 速度慢，他的运行速度相比C语言要慢很多
2. 代码不能加密
3. 进程不能利用多CPU问题

4.最后来初步认识一下编码和单位转换

ASCII 1字节 不支持中文
Unicode 中文和英文4字节
utf-8 英文1字节 欧洲2字节 亚洲3字节

14.
# 单位转换:
# 1字节 == 8位
# 1B = 8b
# 1KB = 1024B
# 1MB = 1024KB
# 1GB = 1023MB
# 1TB = 1024GB
# 1PB = 1024TB
# 1EB = 1024PB
1
2
3
4
5
6
7
8
9
10
11
12
13
14

三.挑战第一关 _Python_之基础知识

1.变量

**变量:**一个存放东西的空间

1.声明变量

Name = "苍空井"
1

Name是你自己定的变量名，"苍空井"就是数据，=(赋值运算符)就是将等号右边的确定数据交给左边的变量

这是我们的第一段代码，他的意思简单点说就是给"苍空井"这条数据取名叫Name

要是复杂说的话就是在内存里声明一个名为Name的变量名，再将“苍空井”这条数据通过某种联系进行连接，达到存放东西的效果。

下面这个图片是这条代码在内存中的实现过程

[外链图片转存失败(img-wTnrpCiz-1565428895732)(D:\LNH_zuo_ye\Sketch002.jpg)]

2.变量声明规则

变量名只能由字母，数字，下划线进行组合
变量名不能以数字开头
变量名最好能见名知意
变量唯一每个变量只能连接一条条数据
这些内部关键字不能作为变量名

[‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

3.推荐的声明方法

#驼峰
CangJingKong = "你好"
#下划线
cang_jing_kong = "你好"
1
2
3
4

这样做会显得很专业这很重要！

2.常量

一般不变的数据称之为常量

其实在Python没有常量这一说

但是大家有个规定就是变量名全大写的变量为常量

NAME = 12054
1

类似于这样的写法

3.基础数据类型

int(整形):就是数字
```
a = 6
1
```
bool(布尔型):True = 1，False = 0,后期用于判断的必要参数

整形转布尔型只要不是0都是True(0为False)

字符串转布尔型只要字符串内部有元素就为True(否则为False)
```
a = True
b = False
1
2
```

ste(字符串):就是一个存储数据的区域，字符串是不能被修改且有序的(后面会重点讲述)

[外链图片转存失败(img-YKl53d5B-1565428895735)(C:\Users\Lenovo\Pictures\Screenshots\屏幕截图(40)].png)

a = "a" 
a = 'a'  #和双引号一样
a = "我想打个引号'所以只能这样打出来'" #要是想在字符串内打出字符串就需要用到双引号和单引号的组合运用
a = """ a """ #这种输出的数据是可以带格式的
1
2
3
4

list(列表):是由一系列特定元素顺序排列组成的，其元素也可以修改的(后面会详细讲解)
```
a = []
1
```
tuple(元祖)元祖和列表相似但不可修改(后面会详细讲解)
```
a = ()
1
```
dict(字典):是由一组组无序的键值对组成的(后面会详细讲解)
```
a = {
     }
1
2
```
set(集合):有些饶人前器理解会比较困难到后面会有详细讲解

在在这个阶段我们只需要了解这些类型就够了

4.用户交互

最常见的用户交互就是用户登陆

让我们先看看他在Python内部怎么表示

输入语句:

a = input("填写用户可视化信息")
1

a是变量名
=是赋值运算符
input()是输入语句，但这条语句只负责将用户输入的信息记录并且类型为"str"类型
""内部放的是用户可以看见的提示信息

输出语句:

print("作者真的帅")
1

print就是我们的输出语句
"作者真的帅"是一段字符串也就是咱们之前说的str
他的作用就是将"作者真的帅"输出到屏幕上

下面是一个小例子，他实现的功能是获取用户名和密码并输出到屏幕上

[外链图片转存失败(img-K7gfoGMt-1565428895736)(C:\Users\Lenovo\Pictures\Screenshots\屏幕截图(34)].png)

5.运算符

运算符分类:

算数运算符:+ (加)，- (减)，* (乘)，/ (除)，// (整除)，** (幂)，% (取模)
比较(关系)运算符:== (等于)，!= (不等于)，< (小于)，> (大于)，<= (小于等于)，>= (大于等于)，
赋值运算符:= (正常的赋值运算符)

逻辑运算符:and (与)，or (或)，not (非)

and
    1 and 10 如果两边都是真就输出右边的数
    False and 0 如两边都是假的话就输出左边的数
    10 and False 如果一真一假就输出假的那边数

or
    1 or 10 如果两边都是真就输出左边的数
    False or 0 如两边都是假的话就输出右边的数
    10 or False 如果一真一假就输出真的那边数

not
    取反真的变假的
    假的变真的
    not 1 就变成0
    not False 就变成True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

位运算符:& (按位与运算符)，| (按位或运算符),^ (按位异或运算符)，~ (按位取反运算符),<< (左移动运算符)，

>> (右移动运算符)(后面会详细讲解)
成员运算符:in (如果在制定序列内找到值就返回True，否的返回False)，not in (和in得到的相反)
身份运算符:is (判断两个表示符是否引用自同一对象，类似id(a)==id(b)，若是同一个对象返回True否则返

回False)

is not(和is得到的结果相反)(后期会详细讲解)

6.格式化输出

这里主要讲的就是占位符的使用，占位符的作用肯定是用来占位的啦！

#首先我们先来他们的样子
首先我们来输出一个名片(因为涉及到格式所以我们使用"""三引号的写法""")
    print("""
    -----名片------
    姓名：日魔
    电话：12345
    --------------
    """)
    这样是不是像点样子了，但是我们总不能来一个人重新写一个这样的名片吧，那样就显得太过麻烦了。
    这个时候就该使用我们的占位符啦


1.第一种占位方式：%s(str字符型占位符，只能补位字符串)%d或%i(int 整形占位符，只能补位整形)
在引号后面加%()进行补位记得一定要按顺序补位,如果你想在内部写%那就要打%%
    print("""
    -----名片------
    姓名：%s
    电话：%s
    --------------
    """%(input("姓名"),input("电话"))
    这样写就可以往这个字符串内部输入不同的数据了

      
2.用f和{
   }进行补位不过只有在3.5以后版本才能使用,
    print(f"""
    -----名片------
    姓名：{input(">>")}
    电话：{input(">>")}
    --------------
    """)
    f是用来声明占位用的，{
   }里面的内容是用来补位用的。
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

7.字符串(str)

这里我们来详细讲解一下字符串的一些特点和用法

首先前面我们已经介绍了字符串是一组有序不可不可变的元素

接下来再让我们看看他的一些特性

索引

字符串中的每一个字符都有一个编号，就像我们身份证号码一样，因为名字可能出现重复但身份证号码是唯一的。
    a = "abc"
         0,1,2
        -3,-2,-1
就像上面的字符串分别是a的下标从左到右排为0,从右向左排序为-3
1
2
3
4
5

切片

切片就是利用索引对字符串进行控制，切片有个特性就是顾头不顾尾
    a = "abc"
想输出b就像下面一样写
    i = a[1]
也可以
    i = a[-2]
想输出a后面的值可以像下面一样写
    i = a{0:}
1
2
3
4
5
6
7
8

步长

步长就是每次输出所跨越的长度或方向
    a = "absdfac"
想输出c前面的值可以像下面一样写
    i = a[-1::-1]
也可以
    i = a[::-1]
想输出a,b,c可以像下面一样写
    i = a[::3]
想输出c,b,a可以像下面一样写
    i = a[::-3]
1
2
3
4
5
6
7
8
9
10

之后我们来简答介绍一下字符串的常用方法

a = "abcdefg"
.upper() 								#将字符串内部所有小写变成大写
print(a.upper())
.lower() 								#将字符串内部所有大写变成小写
print(a.lower（）)
.startswith(“”，开始的索引，结束的索引) 	#判断开头是否为括号内的字符
print(a.startswith("a"))
.endswith(“”，开始的索引，结束的索引) 		#判断结尾是否为括号内的字符
print(a.endswith("g"))
.count("") 								#字符内有多少个方法括号内的字符
print(a.count("a"))
.strip() 					#删掉字符串的首尾空格，要是方法括号内部有字符就删掉首尾方法括号内的字符
print(a.strip())
split()                        #分割
.replace("被替换的字符","替换成的字符") 	#进行替换括号内第一个字符和第二个字符
print(a.replace("a","b"))
.find(要查找的元素)
print(a.find("a")) 			#查找元素人如果没找到返回-1
分隔符.join("被分割字符串")
print(".".join(a))	 		#用·左边的字符串去分割右边join内部的字符串或列表但必须都是字符串类型
.isdigit() 					#判断是不是阿拉伯数字
.isdecimal 					#判断是不是十进制
.isalnum 					#判断是不是字母数字汉字
.isalpha 					#判断是不是字母汉字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

最后我们在介绍一些虽然不会经常介绍但也需要了解的一些方法

1.扩展方法
    a = "abc_dem"
    print(a.capitalize()) 	#将首字母大写
    print(a.title()) 		# 将开头字母大写空格文字特殊符号等都能起到分割的作用
    print(a.swapcase()) 	# 大写变小写小写变大写
    print(a.center(20,"*")) # 居中,填充用逗号右边字符串进行填充一共算上要居中的字符串需要逗号左边的的								空间
    print(a.index("a")) 	#查找元素如果没找到就会报错

2.字符串做加法和乘法
    print(a + a) 			# 新开辟一个空间存放两个字符串的拼接
    # 结果 "abc_demabc_dem"
    print(a * 5) 			# 开辟一个新的空间存放这个字符串相乘五回的结果
    # 结果"abc_demabc_demabc_demabc_demabc_dem"
    # 字符串做加乘运算都是开辟的新空间
1
2
3
4
5
6
7
8
9
10
11
12
13
14

8.列表(list)

列表是一个可变有序的容器，他可以存储大部分的数据类型，他内部存储的元素分别是一个个的地址。

1.他也有和字符串很像的操作就是
    索引
        a = [1,"2",[3]]
             0,  1,  2   	#从左到右索引
            -3, -2, -1	 	#从右向左索引
    切片
        a[起始值:中止值]
        a[::] 				#从左到右输出整个列表
    步长
        a[起始值:中止值:步长]
        a[::-1] 			#从右向左输出整个列表



2.接下来我们来看看列表的方法
    a = [1,2,3]
    增
        a.append() 		#追加
        a.insert() 		#插入
        a.extend() 		#迭代添加
    删
        a.pop() 		#弹出式删除
        a.remove() 		#按元素删除
        a.clear()		#清空列表
        del a 			#删除整个列表
    改
    	(可用切片的形式进行修改)
        a[0] = 4
        a.sort() 				#排序（默认升序）
		a.sort(reverse=True) 	#降序
		a.reverse()          	#将数据反转
    查
        print(a[0])
		print(a.index(数据)) 	   # 查询数据的索引如果查不到会报错
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

在最后我们也来看看列表有那些需要了解的方法

小功能
1.人工降序
    a = [1,2,3,4]
    a.sort()  			#先降序
    a.reverse() 		#在反转
    print(a)
2.不改变数据源进行反转
    a = [1,2,3,4]
    b = a[::-1]
    print(b)
3.列表进行加减法
    # lst = [1,2,3,4]
    # lst = lst + [1,2,3]
    # print(lst)  
    #结果[1,2,3,4,1,2,3]

    # lst = [1,2,3] * 5
    # print(lst)
    # print(id(lst[0]),id(lst[3]))
    # 结果[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
          1412983840 1412983840

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

9.元祖(tuple)

元祖可以简单理解成不可变的列表

    元祖加法乘法
    
    # tu = (12,3,4) + (4,5,3,4)
    # print(tu)
    结果:(12, 3, 4, 4, 5, 3, 4)

    # tu = (1,[]) * 3
    # print(tu)
    # tu[-1].append(10)
    # print(tu)
    结果:(1, [], 1, [], 1, [])
		(1, [10], 1, [10], 1, [10])
1
2
3
4
5
6
7
8
9
10
11
12

10.字典(dict)

字典应该是我们以后最常用的一个数据类型

一.让我们先看下这个小东西长成什么样子
变量名 = {键:值}
    1.字典是一个无序可变可迭代的数据类型，他的存储方式为哈希列表存储一般在别的语言内这个东西叫键值对在		  Python叫做字典
    2.他的键只能为不可变可哈希的值  (key)
    3.他的值可以随便放 (valuse)


二.咱们先看下他的相关操作
增
    1.首先是暴力添加：字典名[键]=[值] #如果字典内部有这个键就将他的值进行更改，要是没有则进行添加
    2.然后是温柔添加：字典名.setdefault(键,值) #如果字典内部有这个键就返回他的值，要是没有则进行添加

删
    1.删除和列表一些类似
    2.弹出时删除：字典名.pop(键) #有返回值效果和列表的相似将键和他的值进行删除
    3.彻底删除：del 字典名 #全部删除
    4.彻底删除2：del 字典名[键] #将键和他的值进行删除
    5.清空整个字典：字典名.clear() #将列表删除

改
    1首先是暴力修改：字典名[键]=[值] #如果字典内部有这个键就将他的值进行更改，要是没有则进行添加
    2.合并字典修改：主字典名.update(辅字典名) #将主字典内没有的键值对添加到主字典内部

查
    1.没错还是setdefault()：字典名.setdefault(键)   #如果只是写一个键这个方法就会返回这个键的值，要													  是招不到键就返回None
    2.get()纯查找：字典名.get(键)   				#查找键要是找到了返回值要是没找到返回Noeo
    3.keys()查询所有键：字典名.keys() 				#返回这个字典的所有key(键)
    4.valuses()查询所有值：字典名.valuses() 			#返回这个字典所有valuse(值)
    5.items()查询所有键，值：变量1，变量2 = 字典名.items() #这个比较特殊需要两个变量接收第一个变量接受														键第二个变量接受值


三.他和for的结合
1.for i in 字典名            #将字典所有的键循环一遍
  for i in 字典名.keys()
  
2.for i in 字典名.valuses()  #将字典所有有值循环一遍

3.for i,j in 字典名.items()  #将字典的所有键和值都循环一边，前面需要两个变量接收



四.字典嵌套
    a = {"作者":{"长相":"太帅了","身材":"太棒了"}}
    print(a["作者"]["长相"])
    这样我们就能拿到"太帅了"
    
五.字典的其他方法
	# dic = {"key":1,"key1":2,"key2":4,"key3":1}
    # print(dic.popitem())   		# 随机删除  python3.6版删除最后一个键值对
    # popitem返回的是被删除的键值对
    # print(dic)
    
    
    #     dic = {}
    #     dic.fromkeys("abc",[]) 	# 批量创建键值对 "a":[],"b":[],"c":[]
    #     print(dic)
# fromkeys 第一个参数必须是可迭代对象,会将可迭代对象进行迭代,成为字典的键.第二个参数是值(这个值是共用的)
# fromkeys 共用的值是可变数据类型就会有坑,不可变数据类型就没事

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
58
59

11.集合(set)

是一个天生自带去重可变无序的数据类型，可以将他理解成字典里没有值的键

让我们来看看他的样子
    a = {1,2,"3",("4","5")}
    是不是和我们的字典长得特别的相似呀
    一.既然是可便的那一定就有我们的：
    
1.增
    集合名.add()

2.删
    集合名.remove(想删除的数据)
    集合名.pop()  #随机删除
    变量名.clear()

3.改
    先删后改

4.查
    for循环进行查找




二.特殊操作
# s = {1,23,9,4,5,7}
# s1 = {1,2,3,4,5}
#差集 "-"
    print(s - s1)           #将父级集合中和子级集合重复的元素进行删除然后返回剩下的数据
    (s是父级集合,s1是子级集合)

#交集 "&"
    print(s & s1)        	#将父级集合中和子级集合重复的数据返回
    (s是父级集合,s1是子级集合)

#并集 "|"
    print(s | s1)           #将父级集合和子集集合中的元素进行合并然后去重复
    (s是父级集合,s1是子级集合)

#反交集 "^"
    print(s ^ s1)           #将不重复的值合并在一起并返回
    (s是父级集合,s1是子级集合)
    
#父级子集
    #大于号右边是否为子集 返回一个布尔值
        print(父级 > 子集)  
    #小于号右边是否为父级 返回一个布尔值		  #父级要完全拥有子集的所有内容
        print(子集 < 父级)  
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

12.基础数据类型整理

# 可变,不可变,有序,无序
    # 1.可变:
    #     list
    #     dict
    #     set
    # 2.不可变:
    #     int
    #     str
    #     bool
    #     tuple
    # 3.有序:
    #     list
    #     tuple
    #     str
    # 4.无序:
    #     dict
    #     set

# 取值方式:

    # 1.索引
    #     list
    #     tuple
    #     str
    #
    # 2.键
    #     dict
    #
    # 3.直接
    #     int
    #     bool
    #     set

# 数据类型转换
    # str -- int
    # int -- str
    # str -- bool
    # bool -- str
    # int  -- bool
    # bool -- int
    # list -- tuple
    # lst = [1,23,5,4]
    # print(tuple(lst))

    # tuple -- list
    # tu = (1,23,5,4)
    # print(list(tu))

    # list -- set
    # lst = [1,23,12,31,23]
    # print(set(lst))

    # set -- list

    # tuple -- set
    # tu = (1,2,3,4,5)
    # print(set(tu))

    # set -- tuple


# 重要: *****
	将列表转为字符串
        # list -- str
        # lst = ["1","2","3"]
        # print("".join(lst))

    将字符串转换为字典
        # s = "alex wusir 日魔"
        # print(s.split())

#  目前字典转换,自己实现方法

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

13.Boss 程序控制语句分支结构if

学到现在总算是遇到了一个小怪物头目

让我们先来看看他的真面目

#第一种
if 1 < 2:
	print("1小于2")

#第二种
if 1 < 2:
    print("1小于2")
else:
    print("1不小于2")
    
#第三种
if 1 < 2:
    print("1小于2")
elif 1 > 2:
    print("1大于2")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我先来介绍一下他们

if你可以给他理解成”如果“，后面的双引号是固定格式。
else你可以给他理解成"否则"，后面的双引号是固定格式。
elif你可以理解成"否则如果"，后面的双引号是固定格式。
print是输出的意思，这是我们之前讲过的。

然后我们在来看看他们，是不是感觉舒服多了，但这个只能作为理解不能真正的运行出来

#第一种
如果 1 < 2:
	输出("1小于2")

#第二种
如果 1 < 2:
    输出("1小于2")
否则:
    输出("1不小于2")
    
#第三种
如果 1 < 2:
    输出("1小于2")
否则如果 1 > 2:
    输出("1大于2")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

下面是他们真正运行后的结果

[外链图片转存失败(img-h2zNgaaa-1565428895742)(C:\Users\Lenovo\Pictures\Screenshots\屏幕截图(36)].png)

14.Boss 程序控制语句循环结构while

如果你成功的通过了"if"考验那么证明你已经超过了百分之20的人，坚持住你已经很棒了！

老规矩首先让我们看一下这个while长成什么样子

#第一种正常的while
while "循环判断语句":
    print("循环体(如果判断语句一直成功且不遇到break(强制结束循环语句)就不会结束这个循环，并且会一直循环	 循环体内部的指令)")


#加else的while语句   
while "循环判断语句":
    print("循环体(如果判断语句一直成功且不遇到break(强制结束循环语句)就不会结束这个循环，并且会一直循环	 循环体内部的指令)")
else:
    print("如果循环判断语句失败了就执行这条语句(这条语句只会执行一回不会像循环体一样一直循环)"1
2
3
4
5
6
7
8
9

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/627343

Python从入门到自闭(基础篇)