当前位置：首页>python>笔记:Python基础语法

笔记:Python基础语法

2026-02-07 13:23:36

笔记:Python基础语法

print("welcome to shanxi university children free aduct need")

age=input("please enter your age\n")

ifage>=18:

print("you are aduct please give me ten yuan")

print("happy you go")

Python

错误原因是：在比较操作中，一个字符串（str）类型与一个整数（int）类型使用了>=比较运算符，而这是Python不支持的。

根据文档中关于input语句的说明，input()默认获取的是字符串类型。因此，当代码中从输入获取age时，它实际上是字符串类型，但后续代码却直接用它和整数18进行比较，导致了类型错误。

解决方案：如文档中“五类型转化”部分所述，你需要使用int(x)进行类型转换，将输入的字符串转换为整数，然后进行比较。

正确示范：

print("welcome to shanxi university children free aduct need")

age=int(input("please enter your age\n"))

ifage>=18:

print("you are aduct please give me ten yuan")

print("happy you go")

Python

3.if else语句

if 条件：

else：（依旧必须加冒号）

else先不要判断条件，if不满则执行else

else所执行的语句之前同样需要有缩进

4.if elif else语句进行多条件判断

2判断是互斥并且有顺序 1满足则不会理会23

3else可以不写，同等于三个if语句

5判断语句的嵌套使用（多条件多层次的判断）

if 条件1：

if条件2：

通过缩进完成语句之间的层次关系

二 python循环语句

1.while循环

1.基础语法

i=0

whilei<100:

print("I love you")

i+=1

Python

注意：空格缩进

eg.1猜数字游戏（不使用break的方法）

import random

num=random.randint(1,100)

print(f"你一共猜了{count}次")

Python

2while的嵌套使用

2for循环

1基础语法

for 临时变量 in 待处理数据集（序列类型）

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

只能从被待理的数据集中遍历取出，无法定义循环条件

2range语句

语法1 range（num)

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

#语法1

for x inrange(10):

print(x)

Python

语法2 rang（num1,num2)

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

#语法2

for x inrange(5,10):

print(x)

Python

语法3 rang（num1，num2,step)

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

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

#语法3

for x inrange(5,10,2):

print(x)

Python

3for循环的变量作用域

4for循环的嵌套使用

控制好空格缩进

x=0

for x inrange(1,101):

print(f"今天是第{x}天")

for j inrange(1,11):

print(f"这是第{j}朵玫瑰")

print("我喜欢你")

print(f"第{x}天，表白成功")

Python

5break和continue关键字

5.1continue

结束当次循环，进入下一次

for i inrange(1, 10):

print("语句一")

continue

print("语句二")

Python

并且只跳出当前循环，不影响外层循环

for i inrange(1, 5):

print("语句一")

for j inrange(1, 5 ):

print("语句二")

continue

print("语句三")

Python

5.2break

直接结束循环

for i inrange(1, 101):

print("语句一")

break

print("语句二")

print("语句三")

Python

三函数

是组织好，可重复使用的代码块

3.1函数的定义语法

（传入参数）和return 返回值均可以省略

##函数定义

defsay_hi():

print("Hi")

#函数调用，让定义的函数开始工作

say_hi()

Python

先定义函数，后调用函数

3.2函数的传入参数

defadd(x,y):#形式参数

result=x+y

print(f"{x}+{y}的结果是{result}")

add(1,2)#实际参数

Python

1.定义中提供形参，函数声明时提供实参

2.传入参数的数量不限，使用逗号分隔开

3.传入参数时，要和形参一一对应，逗号分隔开

3.3函数返回值

3.3.1基础定义

defadd(a,b):

result =a+b

return result

end=add(1,2)

print(end)

Python

注意 return后面的语句不会执行

defadd(a,b):

result =a+b

return result

print("end")

end=add(1,2)

print(end)

Python

3.3.2None类型

无返回值的函数，相当于返回了None，类型

defsay_hi():

print("Hi")

result=say_hi()

print(f"无返回值函数，返回的内容是：{result}")

print(f"玩返回值函数，返回的类型是：{type(result)}")

Python

1.在if判断中，None等同于False 用于函数中主动返回None 配合if判断做出相关的处理

defcheck_age(age):

if age>18:

return"success"

result=check_age(16)

ifnot result:

print("Sorry, you are not old enough")

Python

2.None用于声明无初始内容的变量

3.4函数的说明文档

辅助理解函数的作用

defadd(x,y):

"""

add可以接受俩个参数，进行相加的功能

:param x：其中一个加数

:param y: 其中另外一个加数

:return: 返回两数相加的结果

"""

result=x+y

print(f"两束数的和为{result}")

return result

add(1,2)

Python

param解释参数，return解释返回值

鼠标放在实参上时可以显示注释

3.5函数的嵌套调用

在一个函数内调用另外一个函数

deffun_b():

print("---2---")

deffun_a():

print("---1---")

fun_b()

print("---3---")

fun_a()

Python

先把函数B中的任务执行完才会回到上次函数A执行的位置

3.6函数的变量作用域

3.6.1局部变量

只在函数体内部生效，函数运行时临时保存数据

deftest_a():

num=100

print(num)

test_a()

print(num)

Python

3.6.2全局变量

将变量定义在函数外

num=200

deftest_a():

print(f"test_a",num)

deftest_b():

print(f"test_b",num)

test_a()

test_b()

print(num

Python

3.6.3global关键字

num=200

deftest_a():

print(f"test_a",num)

deftest_b():

global num

num=500

print(f"test_b",num)

test_a()

test_b()

print(num)

Python

global +变量使函数内定义的变量成为全局变量

3.7函数的多返回值

类型不受限制

但要注意对位，第一个变量对应第一个值

defrerurn_num():

return1,"hello"

a,b = rerurn_num()

print(a)

print(b)

Python

3.8函数多种参数传递方式

1位置参数

2 关键字参数

调用时:键=值，形式传递参数

defuser_into(name,age,gender):

print(f"你的名字是{name}，年龄是{age}，性别是{gender}")

user_into(name="小明",age=20,gender="男")

Python

可以不按照固定的顺序

defuser_into(name,age,gender):

print(f"你的名字是{name}，年龄是{age}，性别是{gender}")

user_into(age=20,name="小明",gender="男")

Python

可以和位置参数混用，位置参数必须在前，且匹配参数顺序

defuser_into(name,age,gender):

print(f"你的名字是{name}，年龄是{age}，性别是{gender}")

user_into("小明",age=20,gender="男")

Python

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

3缺省参数

defuser_into(name,age,gender='男'):

print(f"你的名字是{name}，年龄是{age}，性别是{gender}")

user_into("小明",age=20)

Python

设置默认值，不传参时使用默认值，默认值必须写道最后面

4.不定长参数

4.1通过位置的不定长

defuser_input(*args):

print(args)

user_input("TOM,19")

Python

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

4.2通过关键字的不定长

defuser_input(**kwargs):

print(f"内容是{kwargs}")

user_input(name="小王",age=18,sex="男")

Python

3.9函数作为参数传递

调用函数cumpute作为参数，传入test_func函数中使用

deftest_func(computer):

result=computer(1,2)

print(result)

defcumputer(a,b):

return a+b

test_func(cumputer)

Python

计算逻辑的传递，而发数据的传递

3.10lambda匿名函数

只能使用一次

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

函数体只能写一行无法写多行代码

deftest_func(computer):

result=computer(1,2)

print(result)

test_func(lambda x,y:x+y)

Python

四.数据容器

4.1列表 List

4.1.1列表的定义与性质

4.1.1.1定义

性质

1.列表一次可以存储多个数据，且可以为不同数据类型

my_list=['python',666,True]

Python

2.可以进行嵌套

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

Python

3，数据有序存储（有下标序号）

4.允许重复数据的存在

5.可修改（增加或删除元素）

4.1.2列表的下标索引

4.1.2.1单层索引

name_list=["张三","李四","王五"]

print(name_list[0])#正向取

print(name_list[-3])#逆向取

Python

两者的输出结果相同但注意列表索引不要超出范围

4.1.2.2多层索引

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

print(my_list2[0][2])

Python

4.1.3列表的常用功能

4.1.3.1列表的查询功能（方法）

语法：列表.index（元素）

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

my_list=['it','is', 'a', 'test']

index=my_list.index('is')

print(f"下标索引是{index}")

Python

错误示范：

my_list=['it','is', 'a', 'test']

index=my_list.index('hello')

print(f"下标索引是{index}")

Python

4.1.3.2列表修改的功能（方法）

更改

语法：列表[下标]=值

my_list=['it','is', 'a', 'test']

my_list[0]='This'

print(f"修改后是{my_list}")

Python

插入 insert

语法:列表.insert（下标，元素）指定位置插入

my_list=['it','is', 'a', 'test']

my_list.insert(3,'best')

print(f"插入元素后是{my_list}")

Python

追加 append

语法：列表.append（元素）最后追加

my_list=['it','is', 'a', 'test']

my_list.append('list')

print(f"追加元素后是{my_list}")

Python

追加一批元素 extend

语法：列表.extend（其它数据容器）将其它数据容器的内容取出，依次追加到尾部

my_list=['it','is', 'a', 'test']

my_list2=[1,2,3]

my_list.extend(my_list2)

print(f"追加批量元素后是{my_list}")

Python

删除 del/pop/remove

语法1 del列表[下标]

my_list=['it','is', 'a', 'test']

del my_list[2]

print(f"删除元素后是{my_list}")

Python

语法2 列表.pop（下标）

与del区别：pop可以取出此元素并返回

my_list=['it','is', 'a', 'test']

element=my_list.pop(2)

print(f"删除元素后是{my_list},取出的元素是{element}")

Python

语法3 列表.remove（元素）

my_list=['it','is', 'a', 'test','a']

my_list.remove('a')

print(f"删除元素后是{my_list}")

Python

从前到后搜索，第一个元素被删除

清空列表 clear

语法：列表.clear（）

my_list=['it','is', 'a', 'test','a']

my_list.clear()

print(f"清空后是{my_list}")

Python

统计数量.出现了几次 count

语法：列表.count（元素）

my_list=['it','is', 'a', 'test','a']

count=my_list.count('a')

print(f"'a'有{count}个")

Python

统计数量.一共有多少元素 len

语法：len（列表）

my_list=['it','is', 'a', 'test','a']

count=len(my_list)

print(f"列表的元素个数一共有{count}个")

Python

列表修改方法的总结

4.1.3.3列表的遍历

while循环的遍历

my_list=[21,25,21,23,22,20]

index=0

while index

print(my_list[index])

index+=1

Python

for循环的遍历

语法：for 临时遍历 in 数据容器：

对临时变量进行处理

my_list=[21,25,21,23,22,20]

for element in my_list:

print(f"列表的元素是{element}")

Python

其二的区别

4.2元组 tuple

4.2.1元组的特点：

可以存储多个，不同类型的元素，但是不可以修改防止被篡改

4.2.2元组的定义：

区别：列表是[] 元组是（）

t1=(1,'hello',True)

t2=()

t3=tuple()

print(f"t1的类型是{type(t1)}，内容是{t1}")

print(f"t2的类型是{type(t2)}，内容是{t2}")

print(f"t3的类型是{type(t3)}，内容是{t3}")

Python

定义单个元组类型时，必须在后面加逗号

t4=("hello")

print(f"t4的类型是{type(t4)}")

t5=("hello",)

print(f"t5的类型是{type(t5)}")

Python

4.2.3元组的嵌套

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

print(f"t5的类型是：{type(t5)},内容是:{t5}")

Python

4.2.4元组的操作

下标索引

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

print(f"t5的类型是：{type(t5)},内容是:{t5}")

num=t5[1][2]

print(f"从嵌套列表中获取的元素是：{num}")

Python

与list一模一样

查找 index

t6=('zhangsan','lisi','wangwu')

index=t6.index('lisi')

print(f"lisi在t6中的索引是：{index}")

Python

统计 count

t6=('zhangsan','lisi','wangwu','lisi')

count=t6.count('lisi')

print(f"t6中lisi出现的次数是：{count}")

Python

统计总长度

t6=('zhangsan','lisi','wangwu','lisi')

num=len(t6)

print(num)

Python

4.2.5元组的遍历

while的遍历

t6=('zhangsan','lisi','wangwu','lisi')

index=0

while index

print(f"元组内的元素有{t6[index]}")

index+=1

Python

for的遍历

t6=('zhangsan','lisi','wangwu','lisi')

index=0

for i in t6:

print(f"元组中的元素有{i}")

Python

4.2.6元组不可修改

t6=('zhangsan','lisi','wangwu','lisi')

t6[2]='shanxi'

Python

特例：元组内包含列表可修改列表中的元素

t6=('zhangsan','lisi','wangwu','lisi',['zhangsan','lisi'])

t6[4][0]='lisi'

print(f"修改后的t6为：{t6}")

Python

4.3字符串 str

4.3.1特点

1字符串同元组一样，是一个无法修改的数据容器，修改，移除，追加等操作均无法完成，如果必须做，只能得到一共全新的字符串,

2.只能存储字符串

4.3.2操作功能

下标索引

my_str="shanxi university is in shanxi"

value=my_str[2]

value2=my_str[-16]

print(f"从字符串{my_str}中取出的字符是{value}和{value2}")

Python

查找 index

字符串.index（元素）

my_str="shanxi university is in shanxi"

value=my_str.index("in")

print(f"查找的字符串在字符串中的索引为：{value}")

Python

字符串的替换 replace

语法：字符串.repla（字符串1，字符串2）

功能：将字符串的全部内容字符串1换成字符串2

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

my_str="shanxi university is in shanxi"

new_my_str=my_str.replace("shanxi","beijing")

print(f"修改后的字符串为：{new_my_str}")

Python

字符串的分割 split

语法：字符串.spilt（分隔符字符串）

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

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

my_str="shanxi university is in shanxi"

my_str_list=my_str.split(" ")

print(f"将字符串{my_str}切分后得到列表为：{my_str_list}")

print(f"类型是：{type(my_str_list)}")

Python

字符串的规整操作 strip

去掉前后空格语法：字符串.strip（）

my_str=" shanxi university is in shanxi "

new_my_str=my_str.strip()

print(f"{my_str}去除首尾空格后的字符串为：{new_my_str}")

Python

去除前后指定字符串语法：字符串.strip（元素）

my_str="12shanxi university is in shanxi21"

new_my_str=my_str.strip("12")

print(f"{my_str}去除首尾12后的字符串为：{new_my_str}")

Python

统计出现的次数 .count

my_str="12shanxi university is in shanxi21"

count=my_str.count("shanxi")

print(f"字符串中出现shanxi的次数为：{count}")

Python

统计长度 len（）

my_str="12shanxi university is in shanxi21"

count=len(my_str)

print(f"字符串的长度是：{count}")

Python

字符串操作功能的总结

4.3.3字符串的遍历

while的遍历

my_str="shanxi university is in shanxi"

index=0

while index

print(my_str[index])

index+=1

Python

for的遍历

my_str="shanxi university is in shanxi"

for i in my_str:

print(i)

Python

4.4序列与序列的切片

4.4.1概念

内容连续，有序，可使用下标索引的一类数据容器

列表，元组，字符串均可以视为序列

4.4.2切片

从大的序列取出子序列

语法：序列[起始下边：结束下标：步长]

1.起始下标表示从何处开始，可以留空，留空视作从头开始

2.结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

3.步长表示依次取元素的间隔

步长1：一个一个取

步长2：每次跳过一个取

步长N，每次跳过N-1个元素取

步长为负数：反向取（起始下标和结束下标也要反向标记）

序列切片不会影响序列本身，会得到一个新的序列（因为元组和字符串不可更改）

#对list进行切片，从1开始，4结束，步长1

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

result=my_list[1:4]

print(f"结果一；{result}")

#对tuple进行切片，从头开始，到最后结束，步长1

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

result2=my_tuple[:]

print(f"结果二：{result2}")

#对str进行切片，从头开始，到最后结束，步长2

my_str="01234567"

result3=my_str[::2]

print(f"结果三：{result3}")

#对str进行切片，从头开始，到最后结束，步长-1

my_str1="01234567"

result4=my_str1[::-1]#等同于反转

print(f"结果四：{result4}")

#对列表进行切片，从3开始，到1结束，步长-1

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

result5=my_list2[3:1:-1]

print(f"结果五：{result5}")

#对元组进行切片，从头开始，到尾结束，步长-2

my_tuple2=(0,1,2,3,4,5,6)

result6=my_tuple2[::-2]

print(f"结果六：{result6}")

Python

4.5集合 set

4.5.1定义

改为{}

my_set={'山西大学','计算机与信息技术学院','人工智能专业','山西大学','计算机与信息技术学院',

'人工智能专业','山西大学','计算机与信息技术学院','人工智能专业'}

my_set_empty=set()

print(f"myset的类型为：{type(my_set)}内容是：{my_set}")

print(f"myset_empty的类型为：{type(my_set_empty)}内容是：{my_set_empty}")

Python

4.5.2特征

1不支持元素的重复（自带去重）

2内部无序性

3不支持下标索引

4.5.3常用操作

1添加新元素 add

语法集合.add（元素）

my_set={'山西大学','计算机与信息技术学院','人工智能专业','山西大学','计算机与信息技术学院',

'人工智能专业','山西大学','计算机与信息技术学院','人工智能专业'}

my_set.add(2501)

my_set.add('山西大学')

print(f"myset的内容是：{my_set}")

Python

“山西大学”没有被成功添加进去，因为集合的去重性

2移除元素 remove

语法：集合.remove(元素)

my_set={'山西大学','计算机与信息技术学院','人工智能专业','山西大学','计算机与信息技术学院',

'人工智能专业','山西大学','计算机与信息技术学院','人工智能专业'}

my_set.remove('山西大学')

print(f"myset的内容是：{my_set}")

Python

3随机取元素 pop

语法：集合.pop（）

my_set={'山西大学','计算机与信息技术学院','人工智能专业'}

extend=my_set.pop()

print(f"取出来的元素是：{extend}")

print(f"myset的内容是：{my_set}")

Python

4清空集合 clear

my_set={'山西大学','计算机与信息技术学院','人工智能专业'}

my_set.clear()

print(f"myset的内容是：{my_set}")

Python

5取俩个集合差集 difference

得到一个新集合，集合1和集合2不变，取差集

set1={1,2,3}

set2={1,5,6}

set3=set1.difference(set2)

print(set3)

Python

6消除差集difference.uodate

对比集合1和2中，在集合1中删除和集合2相同的元素

结果：集合1被修改，集合2不变

set1={1,2,3}

set2={1,5,6}

set1.difference_update(set2)

print(set1)

Python

7两个集合合并为一个 union

功能：将集合1和集合2组合成新集合

结果：得到新集合，1和2不变

set1={1,2,3}

set2={1,5,6}

set3=set1.union(set2)

print(set3)

Python

8统计集合元素数量 len

set1={1,2,3}

num=len(set1)

print(num)

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

num2=len(set2)

print(num2)

Python

注意：结果都是3，因为集合具有去重性

4.5.4集合的遍历

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

for的遍历

set1={1,2,3}

for i in set1:

print(i)

Python

4.5.5集合操作总结

4.6字典 dict

4.6.1字典的定义

基础定义

也是使用{}但是全部为键值对

my_dict={"张三":88,"王五":90,"赵六":100}

my_dict2={}

my_dict3=dict()

print(f"字典一的内容是{my_dict}")

print(f"字典二的内容是{my_dict2}")

print(f"字典三的内容是{my_dict3}")

Python

重复定义key

my_dict={"张三":88,"王五":90,"赵六":100,"张三":120,}

print(f"字典一的内容是{my_dict}")

Python

后面的key定义会覆盖前面的

从key中获取数据

不可以使用下标索引

my_dict={"张三":88,"王五":90,"赵六":100}

score=my_dict["张三"]

print(f"张三的分数是{score}")

Python

写法与下标索引类似

字典的嵌套

规定：key不能为字典，value不受限

my_dict={"张三":{"语文":80,"数学":90,"英语":100},

"李四":{"语文":80,"数学":90,"英语":100},

"王五":{"语文":80,"数学":90,"英语":100}}

print(f"学生的考试信息是：{my_dict}")

score=my_dict["张三"]["语文"]

score2=my_dict["李四"]["英语"]

print(f"张三的语文成绩是：{score}")

print(f"李四的英语成绩是：{score2}")

Python

4.6.2字典的常用操作

修改/更新

语法：语法[key]=value

my_dict={1:"one",2:"two",3:"three"}

my_dict[4]="four"

print(f"字典经过修改后为：{my_dict}")

my_dict[1]="first"

print(f"字典经过修改后为：{my_dict}")

Python

key不存在为增加，存在为更改

删除 pop

my_dict={1:"one",2:"two",3:"three"}

score=my_dict.pop(1)

print(f"字典经过修改后为：{my_dict}")

print(f"被删除的元素为：{score}")

Python

清空 clear

my_dict={1:"one",2:"two",3:"three"}

my_dict.clear()

print(f"字典经过清空后为：{my_dict}")

Python

获取全部key keys

my_dict={1:"one",2:"two",3:"three"}

keys=my_dict.keys()

print(f"字典的全部键为：{keys}")

Python

可以帮助我们做字典的遍历

统计元素的元素数量len

my_dict={1:"one",2:"two",3:"three"}

num=len(my_dict)

print(num)

Python

字典操作总结

4.6.3字典的遍历

方式一：通过获取全部的key完成遍历

my_dict={1:"one",2:"two",3:"three"}

keys=my_dict.keys()

print(f"字典的全部键为：{keys}")

for key in keys:

print(f"字典的key是{key}，value是{my_dict[key]}")

Python

方式二：直接对字典进行for循环，每次都是直接得到key

本文来自网友投稿或网络内容，如有侵犯您的权益请联系我们删除，联系邮箱：wyl860211@qq.com 。

笔记:Python基础语法

3.if else语句

4.if elif else语句进行多条件判断

5判断语句的嵌套使用（多条件多层次的判断）

二 python循环语句

1.while循环

1.基础语法

2while的嵌套使用

2for循环

1基础语法

2range语句

3for循环的变量作用域

4for循环的嵌套使用

5break和continue关键字

5.1continue

5.2break

三 函数

3.1函数的定义语法

3.2函数的传入参数

3.3函数返回值

3.3.1基础定义

3.3.2None类型

3.4函数的说明文档

3.5函数的嵌套调用

3.6函数的变量作用域

3.6.1局部变量

3.6.2全局变量

3.6.3global关键字

3.7函数的多返回值

3.8函数多种参数传递方式

3缺省参数

4.不定长参数

4.1通过位置的不定长

4.2通过关键字的不定长

3.9函数作为参数传递

3.10lambda匿名函数

四.数据容器

4.1列表 List

4.1.1列表的定义与性质

4.1.1.1定义

4.1.2列表的下标索引

4.1.2.1单层索引

4.1.2.2多层索引

4.1.3列表的常用功能

4.1.3.1列表的查询功能（方法）

4.1.3.2列表修改的功能（方法）

4.1.3.3列表的遍历

4.2元组 tuple

4.2.1元组的特点：

4.2.2元组的定义：

4.2.3元组的嵌套

4.2.4元组的操作

4.2.5元组的遍历

4.2.6元组不可修改

4.3字符串 str

4.3.1特点

4.3.2操作功能

4.3.3字符串的遍历

4.4序列与序列的切片

4.4.1概念

4.4.2切片

4.5集合 set

4.5.1定义

4.5.2特征

4.5.3常用操作

4.5.4集合的遍历

4.5.5集合操作总结

4.6字典 dict

4.6.1字典的定义

4.6.2字典的常用操作

4.6.3字典的遍历

Python入门(番外篇):命名空间和作用域

Python实战项目集:70+个脚本助你从零开始构建你的编程作品

最新文章

热门文章

随机文章

三函数