pyhton

约 7607 字大约 25 分钟

2026-04-04

环境搭建

https://www.python.org/

设计第一个小游戏

""" 用python设计第一个游戏 """

temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字：")
guess = int(temp)

if guess == 8:
    print("你是小甲鱼心里的蛔虫嘛？！")
    print("哼，猜中了也没奖励！")
else:
    print("猜错啦，小甲鱼现在心里想的是8！")

print("游戏结束，不玩啦^_^")

将字符串转换为整数

使用 int() 函数将指定的值转换成整数

比较运算符

变量

创建并访问变量

创建一个变量

Python 的变量无需声明，只需要一次赋值，该变量就能够被成功创建：

>>> x = 3

访问一个变量

简单，当一个变量被创建之后，使用变量名就可以直接访问该变量了：

>>> print(x)
3

变量名命名规则

变量名

变量名呢，通常是由字母、数字和下划线（_）构成，但千万不能以数字打头，比如 loveyou1314 是合法的变量名，而 520baby 却是非法的。

>>> loveyou1314 = 1314
>>> 520baby = 520
SyntaxError: invalid syntax

另外，变量名是区分大小写的，也就是 FishC、fishc 在 Python 看来，是两个完全不同的名字。

勇于尝试的同学可能会发现，Python3 还支持中文字符作为变量名，是的：

>>> 幸运数 = 588
>>> print(幸运数)
588

字符串

字符串

字符串（Single quotes）

Python 字符串的编写方式多种多样，主要有：Single quotes、Double quotes 还有 Triple quoted 三种形式。

其中，Single quotes 是使用一对单引号将文本包含起来：

>>> print('I love China')
I love China

字符串（Double quotes）

那么 Double quotes 就是使用一对双引号将文本包含起来：

>>> print("I love FishC")
I love FishC

混合使用 Single quotes 和 Double quotes 的技巧：

>>> print("Let's go!")
Let's go!
>>> print('"Life is short, you need Python."')
"Life is short, you need Python."

原始字符串

使用原始字符串，可以避免反斜杠（\）被当作转义字符解析：

>>> 未使用原始字符串
>>> print("D:\three\two\one\now")
D:    hree    wo\one
ow
>>> # 使用原始字符串
>>> print(r"D:\three\two\one\now")
D:\three\two\one\now

字符串（Triple quotes）

通常，使用三引号字符串来引用多行文本：

>>> poetry = """
面朝大海，春暖花开
 
从明天起，做一个幸福的人
喂马、劈柴，周游世界
从明天起，关心粮食和蔬菜
我有一所房子，面朝大海，春暖花开
 
从明天起，和每一个亲人通信
告诉他们我的幸福
那幸福的闪电告诉我的
我将告诉每一个人
 
给每一条河每一座山取一个温暖的名字
陌生人，我也为你祝福
愿你有一个灿烂的前程
愿你有情人终成眷属
愿你在尘世获得幸福
我只愿面朝大海，春暖花开
"""

字符串的加法乘法

字符串加法和乘法

字符串相加我们叫做拼接，就是将字符串组合成一个长的新的字符串：

>>> '520' + '1314'
'5201314'

还可以使用乘法符号（*）进行复制。

print("I Love hzz\n" * 520)

条件分支

if-else结构

if-else结构
if 条件：
条件为真（true）执行的操作
else：
条件为假（false）执行的操作
 
简写形式：
if 条件：
条件为真（true）执行的操作
elif 条件：
条件为真（true）执行的操作
else：
条件为假（false）执行的操作
 
悬挂else问题
缩进问题

while循环

while循环结构
while 条件：
        条件为真（true）执行的操作（循环体）

打印1+2+3+4+…+100的计算结果
i=1
sum=0

while i<=100:
    sum+=i
    i+=1
print(sum)

for循环

for循环语句的语法如下：

for 变量 in 可迭代对象：
       循环体

可迭代对象：指那些元素可以被单独提取出来的对象

range()

一个BIF函数，可为指定的整数生成一个数字序列

语法如下：

range(stop)
range(start,stop)
range(start,stop,step)

参数只能是整数

只有一个参数

list是将可迭代对象以列表的形式展示出来

指定起始数值和结束数值

增加步长

打印1+2+3+4+…+100的计算结果
sum=0
for i in range(101):
    sum+=i
print(sum)

断言（assert）

当这个关键字后的条件为假时，程序自动崩溃并抛出AssertionError异常

break语句

中止当前循环，跳出循环体

continue语句

跳出本轮循环并开始下一轮循环（开始前测试循环条件）

else语句

while和for循环语句后也可加上一个else语句，语法如下：
while 条件：
      循环体
else：
      条件不成立时执行的内容

for 变量 in 可迭代对象
      循环体
else：
      条件不成立时执行的内容

随机数

random模块
返回随机的整数
>>> import random
>>> random.randint(1,100)
52
>>> random.randint(1,34)
1
>>> random.randint(3,45)
43

数据类型

整型

长度只限于计算机的虚拟内存总数

>>> 7462874/3434
2173.2306348281886

浮点型

科学计数法表示大数

>>> a=0.000000000003
>>> a
3e-12

布尔类型

true/false两种类型，true相当于1，flase相当于0

>>> True + True

2

>>> True * False

0

>>> True/False

Traceback (most recent call last):

 File "<pyshell#15>", line 1, in <module>

  True/False

ZeroDivisionError: division by zero

类型转换

int()将一个字符串或浮点数转换为一个整数

>>> a='520'
>>> b=int(a)
>>> a,b
('520', 520)
>>> c=5.99
>>> d=int(c)
>>> c,d
(5.99, 5)

float()将一个字符串或整数转换成一个浮点数

>>> a='520'

>>> b=float(a)

>>> b

520.0

>>> c=520

>>> d=float(c)

>>> d

520.0

>>> c,d

(520, 520.0)

str()将一个数或任何其他类型转换成一个字符串

>>> a=5.99

>>> b=str(a)

>>> b

'5.99'

>>> c=str(5e15)

>>> c

'5000000000000000.0'

获取类型信息

type（）函数

>>> type('520')

<class 'str'>

>>> type(5.20)

<class 'float'>

>>> type(520)

<class 'int'>

>>> type(True)

<class 'bool'>

isinstance（）函数

两个参数
第一个	待确定类型的数据
第二个	指定一个数据类型

>>> a='胡梓卓'

>>> isinstance(a,str)

True

>>> isinstance(520,float)

False

>>> isinstance(520,int)

True

常用操作符

算数操作符

+

-

*

** 幂运算操作符，双星号左侧为底数，右侧为指数
>>> 3**4
81

/
>>> 3/2
1.5

// 计算结果取比商小的最大整数值（取整）
>>> 3//2
1

%取余
>>> 5%2
1
>>> 4%2
0

优先级

先乘除后加减

幂运算操作符比其左侧的一元操作符优先级高，比其右侧的一元操作符优先级低

>>> 5**-2

0.04

>>> 5**2

25

python操作符	优先级
幂运算	**
正负号	+ -
算数运算符	/ // + - *
比较运算符	< <= > >= == !=
逻辑运算符	not and or

比较操作符

根据表达式的值得真假返回布尔类型值

<

<=

>

>=

==

!=

>>> 3<4
True
>>> 's'>'b'
True

逻辑操作符

and 两边同时为假，结果才为假

or 左边或右边任意一边为真，结构都为真

not 一元操作符，得到一个和操作数相反的布尔类型值
>>> not True
False
>>> not 4
False

>>> 5>3<4
True
>>> 5>3 and 3<4
True

三元操作符

if x<y:
    small=x
else:
    small=y

三元操作符语法：
small=x if 条件 else y

列表、元组和字符串

列表

使用中括号将数据包裹起来（数据之间使用逗号分隔）

上面创建的是匿名的列表，无法使用

可使用变量名

列表支持各种不同的数据存放

可创建空列表

向列表添加元素

（1）使用append()方法：向列表末尾添加元素

append()属于列表对象的一个方法

append()方法只支持一个参数

（2）添加多个数据，可使用extend()方法向列表末尾添加多个元素：

extend()使用一个列表来扩充另一个列表，参数是另一个列表

（3）向列表任意位置插入元素，可使用insert()方法

两个参数：

【1】指定待插入的位置（索引值）；支持负数：表示与列表末尾的相对距离

【2】待插入的元素值

从列表获取元素

通过索引值可直接获取列表中的某一个元素

访问列表最后一个元素，使用len()函数获取该列表长度，减1，即为最后一个元素的索引值

当索引值为负数时，表示从列表的末尾反向索引

若要交换位置

若开发抽奖功能

random的choice()方法可从一个非空的序列中随机获取一个元素

列表可以包含另一个列表，若要获取内部子列表的某一个元素，可使用两次索引

从列表删除元素

remove()方法：指定一个待删除的元素

pop()方法:取出并删除元素，参数为索引值

del语句：可删除元素和整个变量

列表切片

使用一个冒号隔开两个索引值，左边是开始位置，右边是结束位置

结束位置上的元素不包含

若想获取列表最后几个元素

列表切片不会修改自身的组成结构和数据，只是为列表创建一个新的拷贝并返回

进阶

列表切片可接受第三个参数，代表步长，默认值为1

直接作用于原始列表的操作

（1）del语句作用于列表切片

（2）切片后为列表赋值

常用操作符

当列表包含多个元素，默认从第一个元素开始比较

连接操作符（+）：并不能实现列表添加新元素的操作

重复操作符（*）

成员关系操作符（in,not in）：只能判断一个层次的成员关系

去除列表中重复的数据

count()方法：统计某个元素在列表中出现的次数

index()方法：返回某个元素在列表中第一次出现的索引值

reverse()方法：将整个列表翻转

sort()方法：对列表进行排序

默认从小到大

语法：sort(func,key,reverse)

三个参数：

【1】设置排序的算法，默认使用归并排序

【2】关键字

【3】sort(reverse=False)默认

元组

元组和列表的最大区别：元组只可读，不可写

创建和访问一个元组

创建元组大部分时候使用小括号

访问元组也是通过索引值访问一个或多个元素

复制一个元组，可通过切片实现

元组的标识符

若要元组中只包含一个元素，可在该元素后添加一个逗号（，）实现

小括号可省略

更新和删除元组

利用切片和拼接实现更新元组的目的

id()函数用于返回指定对象的唯一ID值

使用del语句删除整个元组

很少使用del去删除整个元组，Pyhton的垃圾回收机制会对某个对象不再被使用的时候自动进行清理

字符串

切片也可应用于字符串

字符串一旦确定就不能修改，只能使用切片

旧的字符串还在，变量名指向拼接后的字符串；旧的字符串失去变量的引用，Python的垃圾回收机制将其释放

各种内置方法

方法	含义
casefold()	将字符串的所有字符修改为小写

修改字符串并不是修改原字符串，而是返回字符串修改后的一个拷贝

方法	含义
count(sub,[,start[,end]])	返回sub参数在字符串里面出现的次数 start和end参数可选，指定统计范围

方法	含义
find(sub[,start[,end]]) index(sub[,start[,end]])	检查sub参数是否包含在字符串中，如果有则返回第一个出现位置的索引值，否则返回-1；index方法找不到将抛出ValueError异常 start和end参数可选，指定统计范围

方法	含义
replace(old,new[,count])	将字符串中的old参数指定的字符串替换成new参数指定的字符串 count参数可选，表示最多替换次数不超过count

方法	含义
split(sep=None,maxsplit=-1)	以空白字符作为分隔符对字符串进行分割 sep参数指定分隔符，默认是空白字符 maxsplit参数设置最大分割次数，默认是不限制

方法	含义
join(iterable)	以字符串作为分隔符，插入到iterable参数迭代出来的所有字符串之间如果iterable中包含任何非字符串值，将抛出TypeError异常

格式化 format

format()方法接收位置参数和关键字参数，均传递到一个名为replacement的字段，在字符串内用大括号{}表示

若将位置参数和关键字参数综合使用，位置参数必须在关键字参数之前，否则会报错

要打印大括号

格式化操作符：%

Python	格式化符号及其含义
符号	含义
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x %X	格式化无符号十六进制数
%f	格式化浮点数字，可指定小数点后的精度
%e %E	用科学计数法格式化浮点数
%g %G	根据值得大小决定使用%f或%e

使用格式化方法拼接字符串

拼接字符串的三种方法

（1）简单字符串拼接，使用+

（2）复杂，有格式化需求，使用%

（3）大量字符串拼接，尤其发生在循环体内部，使用join()

Python	格式化操作符的辅助命令
符号	含义
m.n	m显示最小总宽度，n是小数点后的位数
-	结果左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示'0o'，在十六进制数前面显示'0x'或'0X'
0	显示的数字前面填充'0'代替空格

Python的转义字符以及含义

符号	说明
'	单引号
"	双引号
\a	发出系统响铃声
\b	退格符
\n	换行符
\t	横向制表符（TAB）
\v	纵向制表符
\r	回车符
\f	换页符
\o	八进制数代表的字符
\x	十六进制数代表的字符
\0	表示一个空字符
\	反斜杠

序列

list([iterable])用于把一个迭代对象转换为列表

tuple([iterable])用于把一个迭代对象转换为元组

str(obj)把obj对象转换为字符串

len(sub)返回sun参数的长度

max()-保证序列或参数的数据类型统一

用于返回序列或参数集合中的最大值

min()-保证序列或参数的数据类型统一

用于返回序列或参数集合中的最小值

sum(iterable[,start])

用于返回序列iterable的所有元素值的总和，可选参数start默认值为0

sorted(iterable,key=None,reverse=False)

用于返回一个排序的新列表；内建方法sort()是实现列表原地排序

reversed(sequence)

用于返回迭代序列的值；列表的内建方法是原地翻转，reversed（）是返回一个翻转的迭代器对象

enumerate(iterable)

生成由二元组（元素数量为2的元组）构成的一个迭代对象，每个二元组由可迭代参数的索引号及其对应的元素组成

zip(iter1[,iter2][…])用于返回由各个可迭代参数共同组成的元组

函数

创建和调用函数

使用def关键字

def myfirstfunction():
    print("helloworld")

调用函数

myfirstfunction()

函数的参数

函数的返回值

使用return返回，若无返回值默认返回none；若返回多个值默认以元组的形式进行打包；也可利用列表返回

形参和实参

形式参数-parameter 实际参数-argument

函数文档

文档字符串可通过特殊属性__doc__获取

获取函数文档

help()

关键字参数

固定的参数称为关键字参数

传入实参时，明确指定形参的关键字参数

默认参数

定义函数时，位置参数必须在默认参数前面

收集参数（可变参数）

在参数前面加上星号（*）

把标志为收集参数的参数们打包成一个元组

若定义的函数中带有收集参数，可将其他参数设置为默认参数

sep参数：指定多个参数之间的分隔符，默认是空格

end参数：指定以什么字符结束打印，默认是换行

file参数：指定输出的位置

flush参数：指定是否强制刷新缓存

星号（*）在形参中的作用是“打包”

在实参中的作用是“解包”

两个星号（**）的收集函数表示将参数们打包成字典的形式

收集参数2种打包形式：

元组
字典

当参数带两个星号（**）时，传递给函数的任意数量的key=value实参会被打包进一个字典中

变量的作用域

局部变量

局部变量-->定义在函数内部的变量

作用域：只能在函数内部有效，不能在函数外部被引用

全局变量

全局变量-->在函数外部定义

作用域-->整个模块

若在函数内部修改全局变量的值，Python会创建一个新的局部变量来替代，原本的全局变量不会被改变

global关键字

可修改全局变量的值

内嵌函数

Python函数定义是支持嵌套的

内部函数整个作用域都在外部函数之内

在嵌套函数中，内部函数可以引用外部函数局部变量

LEGB原则

L-Local --> 函数内的名字空间
E-Enclosing function locals --> 嵌套函数中外部函数的名字空间
G-Global --> 函数定义所在模块的名字空间
B-Builtin --> 内置模块的名字空间

变量的查找顺序是：L -> E -> G -> B

闭包

在一个内部函数里对在外部作用域的变量进行引用，这个内部函数就是一个闭包

使用nonlocal关键字可声明变量不是局部变量

装饰器

装饰器（decorator）功能：将被装饰的函数当作参数传递给与装饰器对应的函数，并返回包装后的被装饰的函数

log(eat)将eat函数作为参数传递给log()

使用用语法糖【Syntactic sugar】（在计算机语言中添加的某种语法，对语言的功能没有影响，方便程序员使用）

def log(func):
        def wrapper():
                print("开始调用eat()函数...")
                func()
                print("结束调用eat()函数...")
        return wrapper

"""def eat():
        print("开始吃了")
eat=log(eat) --代替--
eat()
"""
print("----------------")

@log
def eat():
        print("开始吃了")
eat()

多参数问题可使用收集参数解决，调用时使用（*）解包

def log(func):
        def wrapper(*params):
                print("开始调用")
                func(*params)
                print("end")
                return wrapper

可使用多层装饰器

@buffer
@performance
@log
def eat(name):
        print("%s吃了"%name)

函数式编程

lambda

允许使用lambda关键字创建匿名函数

def ds(x):
        return 2*x+1
ds(5)

lambda x:2*x+1

基本语法：

使用冒号（：）分隔函数的参数及返回值
冒号左边放置函数的参数，若存在多个参数，使用逗号（，）分隔
冒号右边是函数的返回值

执行语句后返回一个函数对象，要进行调用需要绑定一个变量

g=lambda x:2*x+1
g(5)

filter()

filter()函数是一个过滤器，可在大量数据里面提取有用的数据

这个内置函数由两个参数：

可以是函数或none；

(1)函数 --> 将第二个可迭代对象里的每一个元素作为函数的参数进行计算，把返回True的值筛选出来

(2)None --> 将第二个参数中为True的值筛选出来

temp =filter(None,[1,0,True,False])
list(temp)

def odd(x):
        return x%2
temp=filter(odd,range(10))
list(temp)

list(filter(lambda x:x%2,range(10)))

map()

“映射”

这个内置函数有两个参数：

可是函数或可迭代对象

(1)将可迭代对象的每一个元素作为函数的参数进行运算加工，直到全部加工完成

(2)第二个参数是收集参数，支持多个迭代对象；map()会从所有可迭代对象中依次取一个元素组成元组，将其传递给func

注意：若可迭代对象的长度不一致，则按较短的迭代结束

list(map(lambda x,y:x+y,[1,3,5],[10,30,50,66,88]))

递归

>>> import sys
>>> sys.set函数名limit(10000) #将递归深度限制设置为一万层

写一个求阶乘的函数

#非递归版本
def recursion(n):
    result=n
    for i in range(1,n):
        result*=i
    return result
number=int(input('请输入一个整数：'))
result=recursion(number)
print("%d的阶乘是：%d"%(number,result))

#递归版本
def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
number=int(input('请输入一个整数:'))
result=factorial(number)
print('%d的阶乘是：%d'%(number,result))

斐波那契数列

#迭代实现
def fab(n):
    a1=1
    a2=1
    a3=1
    if n<1:
        print("输入错误")
        return -1
    while(n-2)>0:
        a3=a1+a2
        a1=a2
        a2=a3
        n-=1
    return a3
result=fab(20)
if result!=-1:
    print("总共有%d对小兔子出生！"%result)

#递归实现
def fab(n):
    if n<1:
        print('输入错误')
        return -1
    if n==1 or n==2:
        return 1
    else:
        return fab(n-1)+fab(n-2)
result=fab(20)
if result!=-1:
    print("总共有%d对小兔子出生！"%result)

汉诺塔

#汉诺塔递归
def hanoi(n,x,y,z):
    if n==1:
        print(x,"-->",z)
    else:
        hanoi(n-1,x,z,y)
        print(x,"-->",z)
        hanoi(n-1,y,x,z)
n=int(input("输入层数:"))
hanoi(n,'x','y','z')

字典和集合

创建和访问字典

"键（key）"-->"值（value）"

字典是Python中唯一的映射类型，指两个元素集之间元素相互"对应"的关系

创建和访问字典

字典使用大括号{}定义；字典由"键"和"值"共同构成构成，每一对键值组合成为"项"

字典的键必须独一无二，但值不必，值可以取任何数据类型，但必须是不可变的

声明一个空字典

也可以使用dict()内置函数来创建字典

参数可以是一个序列（不能是多个），必须要打包成一个元组（或列表）

可通过提供具有映射关系的参数创建字典

键的位置不能加字符串的引号！

访问字典里的值，把相应的键放入方括号，若该键不在映射中，则抛出KeyError

还有一种创建方法，直接给字典的键赋值，若键值存在，则改写键对应的值；若不存在，则创建一个新的键并赋值

字典中不允许同一个键出现两次，最后一个值会覆盖前面的值

键必须不可变，可以用数值、字符串、元组；不能使用列表

创键字典的5种方法

字典不支持拼接和重复操作

各种内置方法

（1）fromkeys(seq[,value])

用于创建并返回一个新的字典

两个参数：

字典的键
（可选）传入键的对应值；默认none

（2）keys(),values(),items()

Keys()用于返回字典中的键

Values()返回字典中所有的值

Items()返回字典中所有的键值对

（3）get(key[,default])

当键值不存在时，返回none

希望找不到数据时返回指定的值

若不知道一个键是否在字典中，可以使用成员资格操作符（in或not in）

清空字典，使用clear()方法

（4）copy()

拷贝（浅拷贝）整个字典

（5）pop(key,[,default])和popitem()

Pop()给定键弹出对应的值

Popitem()弹出一个项

（6）setdefault(key[,default])

Setdefault()在字典中找不到相应的键时，会自动添加

（7）update([other])

更新字典

创建集合

用大括号括起来一堆数字但没有体现映射关系，即为集合

集合特点：唯一

集合时无序的，不能通过索引其中的某一个元素

创建集合

2种方法：

使用大括号{}括起来
使用set()内置函数

Set()能去除重复元素

将无序的集合转换成列表不能保证原来的列表顺序

访问集合

可使用迭代把集合中的数据依次读出来

也可以使用in和not in判断元素是否在集合中存在

使用add()方法可以为集合添加元素

使用remove()方法可以删除集合中已知的元素

不可变集合

使用frozenset()函数

永久存储

文件

打开文件

使用open()内置函数打开文件并返回文件对象

打开模式	执行操作
'r'	以只读方式打开文件（默认）
'w'	以写入的方式打开文件，会覆盖已存在的文件
'x'	若文件已经存在，使用此模式打开将引发异常
'a'	以写入模式打开，若文件存在，则在末尾追加写入
'b'	以二进制模式打开文件
't'	以文本模式打开（默认）
'+'	可读写模式（可添加到其他模式中使用）
'U'	通用换行符支持

文件对象的方法

文件对象的方法	执行操作
Close()	关闭文件
Read(size=-1)	从文件读取size个字符，当未给定size或给定负值时，读取剩余的所有字符
Readline()	从文件中读取一整行字符串
Write(str)	将字符串str写入文件
Writelines(seq)	向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象
Seek(offest,from)	在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）
Tell()	返回当前文件中的位置

文件关闭

Python的垃圾回收机制会在文件对象的引用计数降到0时，自动关闭文件

文件的读取和定位

Read()以字节为单位读取

文件的写入

使用'w'模式写入文件，此前的文件内容会全部删除，要追加内容一定要使用'a'模式打开文件

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

mode是一个可选的字符串参数，用来指定文件打开模式

buffering是一个整数可选项，用于设置缓冲策略，传入0关闭缓冲（仅允许在二进制模式下），1选择行缓冲（尽用于文本模式），大于1的整数用于指示某个固定大小的块缓冲区的字节大小

encoding是用于编码或解码文件的编码名称。该参数应仅用于文本模式

errors是一个字符串可选项，用于指定如何操作编、解码的错误（不能用于二进制模式）

newline控制通用换行模式如何运行（只支持文本模式），该值可以是None, ”, ‘\n’、’\r’和’\r\n’

如果closefd为False，且给定文件描述符（而不是文件名），那么当文件关闭时底层文件描述符将保持打开。如果给定文件名，closefd必须为True（默认）。否则将引发错误。

opener可以传递调用一个自定义打开器，然后通过调用opener获取文件对象的底层文件描述符。opener必须返回一个打开文件

描述符

贡献者

xiaofei

更新日志

2026/4/5 03:39

查看所有更新日志

fb8bc-更新为vuepress于 2026/4/5