Python基础学习文档（1）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

目录

一、Python入门

1、input语句

2、print语句

1、使用print()函数输出

2、使用print()函数格式化输出

3、快速写法

二、Python基础

1、字面量

2、注释

3、变量

4、数据类型

1、string（字符串类型）

2、int（整型（有符号））

3、float（浮点型（有符号））

4、bool(布尔值)

5、complex(复数类型)

5、数据类型的转换

6、标识符

7、运算符

三、程序设计结构

1、判断语句

2、for语句

3、while语句

4、break，continue，pass语句

四、组合数据

1、元组

1、性质

2、元组的定义方式

3、元组的计算

4、元组的索引、切片、遍历

5、元组支持方法count()，len()与index()

6、元组存在的意义 

2、列表

1、列表性质

2、列表的创建

3、列表添加元素

4、列表运算

5、列表的删除

6、列表的索引，切片与遍历

7、列表支持方法count()，len()与index()

8、列表排序

9、其他方法

3、字典

1、字典性质

2、字典的创建

3、字典中元素访问方法

4、元素的添加与删除

5、序列解包：运用于字典（类似于赋值）

6、字典键值对的个数：len()

4、集合

1、集合的性质

2、集合的创建

3、访问集合元素

4、元素的添加与删除

5、集合的运算

总结

---

一、Python入门

1、input语句

数据输入：input

使用input()语句可以从键盘获取输入
使用一个变量接受（储存）input语句获取的键盘输入数据即可

例如：
name = input("请告诉我你是谁？")
print(name)
输出：（从键盘输入的内容）

input输入的数据为字符串类型

一次输入多个数据：

#一次输入多个数据
姓名 = input('请输入姓名：')
性别,职业 = input('请输入性别和职业（用空格隔开）：').split() #一次输入多个字符
print(f"姓名是{姓名}，性别为{性别}，职业是{职业}。")

2、print语句

print语句是最常用的输出函数，可以直接输出数字、字符串、列表等常量、变量或表达式，也可以对它们进行格式化输出。

1、使用print()函数输出

print(23)
# 23
print("123")
# 123
print([1,2,3])
# [1, 2, 3]
print(123,'123',45,'book',sep='-')
# 123-123-45-book

2、使用print()函数格式化输出

%c 单字符（接收整数或单字符字符串）

%s 字符串

%d 十进制整数

%b 二进制整数

%o 八进制整数

%x 十六进制整数

%r 字符串

%f 格式化浮点数

%e 用科学计数法格式化浮点数

%g 是%f与%e的简写

%G 是%F和%E的简写

a = 123.456
print("a = %d"%a)
# a = 123
print("a = %f"%a)
# a = 123.456000
print("a = %8.4f"%a)
# a = 123.4560

3、快速写法

a = 100
b = "abc"
c = True
d = 1 + 2j
print(f"a = {a}\nb = {b}\nc = {c}\nd = {d}\n")
# a = 100
# b = abc
# c = True
# d = (1+2j)

二、Python基础

1、字面量

定义：在代码中，被写下来的固定的值，称之为字面量。
例如：
666
13.1415
"程序员"

2、注释

单行注释：#

多行注释："""  """

# 我是单行注释，我不能换行

"""
我是多行注释
我可以换行
"""

'''
我也是多行注释
我可以换行
'''

3、变量

定义：在程序运行时，能储存计算结果或能表示值的抽象概念。

定义变量格式：变量名 = 变量值

例如：

money = 50
print("钱包还有:",money)
# 钱包还有: 50

money = money - 10
print("买了冰淇淋花了10元，还剩余",money,"元")
# 买了冰淇淋花了10元，还剩余 40 元

变量的特征：变量的值是可以改变的。

变量是什么，有什么作用：变量就是在程序运行中，记录数据用的。

4、数据类型

1、string（字符串类型）

用双引号引起来的数据都是字符串

字符串三种定义方法

单引号定义法：name = '程序员'
双引号定义法：name = "程序员"
三引号定义法：name = """程序员"""

三引号定义法和多行注释写法一样，同样支持换行操作。
使用变量接收它，它就是字符串
不使用变量接收它，就可以作为多行注释使用

如果定义的字符串本身就是包含：单引号、双引号自身呢？如何写？
（1）单引号定义法，可以内含双引号
（2）双引号定义法，可以内含单引号
（3）可以使用转义字符（\）来将引号解除，变成普通字符串

更多操作在文档（3）中

2、int（整型（有符号））

数字类型，存放整数，例如 -1，10，0 等

（1）bin()函数：将其他进制的数转化为二进制数。

二进制数以"0B"或"0b"开头

（2）int()函数：将其他进制的数转化为十进制数。

（3）oct()函数：将其他进制的数转化为八进制数。

八进制数以"0O"或"0o"开头

（4）hex()函数：将其他进制的数转化为十六进制数。

十六进制数以"0X"或"0x"开头

3、float（浮点型（有符号））

数字类型，存放小数，例如 -3.14，6.66 等

由于精度和数制转换之间的问题，浮点数运算结果有时和预期结果存在误差

a = 0.1
b = 0.2
print(a + b)
# 0.30000000000000004
print(a + b == 0.3)
# False

（1）浮点数在计算机储存和表示时，有效位数是有限的，会对尾数进行一些处理。

（2）计算机再进行运算时，会将十进制转换为二进制再进行运算，可能导致十进制数转换为二进制数后成为循环小数。

解决方法：

（1）判断两个浮点数是否相等，可以将两个数相减取绝对值，若绝对值足够小，则可以认为两数相等

（2）使用round(f,n)函数限定小数位数为n位。

4、bool(布尔值)

布尔类型只有两个值，True与False

在python中，非0数字，非空字符串，非空元组，非空字典，非空集合等在条件判断时均被视为(True)，数字0或0.0、空字符串、空列表、空元组、空字典、空集合等在条件判断时均被判为（False）

布尔类型的常量如果出现在算数运算中True被当作1，False被当作0。

5、complex(复数类型)

有实部与虚部，例如：6 + 5j ，6 + 5J

对于复数x，可以使用x.real来获得复数的实部，使用x.imag获取复数的虚部

复数运算：

a = 1 + 2j
b = 3 + 4J
print(a + b)
# (4+6j)
print(a.imag)
# 2.0
print(a.real)
# 1.0

（组合数据类型见章节四）

注意：type()语句可以得到数据的类型

print(type("程序员"))
# <class 'str'>

print(type(666))
# <class 'int'>

print(type(3.14))
# <class 'float'>

print(type(6+5j))
# <class 'complex'>

print(type(True))
# <class 'bool'>

5、数据类型的转换

语句函数：
int(x)：将x转化为一个整数

float(x)：将x转化为一个浮点数

str(x)：将x转化为字符串

bool(x)：将x转化为布尔值

注意：想要将字符串转化为数字类型，必须要求字符串内容都为数字，否则就会报错。

6、标识符

（1）变量的名字
（2）方法的名字
（3）类的名字，等等
这些名字我们把它统一称为标识符，用来做内容的标识

标识符命名规则：
（1）标识符命名中只允许出现以下四类元素
  英文(不推荐)，中文，数字，下划线(_)
（2）数字不可以用在开头
（3）Python区分英文大小写
（4）关键字不可以用作标识符

7、运算符

//：取整除
返回商的整数部分，例如9 // 2输出 4，9.0 // 2.0输出 4.0。

**:指数
2**3 输出 8，为2的三次方。

赋值运算符
**= ： 幂赋值运算符
c **= a 等价于 c = c ** a

//= : 取整除赋值运算符
c //= a   等价于 c = c // a

三、程序设计结构

1、判断语句

1、单分支结构

单分支结构可以用 if 单分支语句实现

a = 100
if a == 100:
    print("a = 100") 
# a = 100

2、二分支结构

二分支结构可以使用if，else语句实现

a = 100
if a == 101:
    print("a = 101")
else:
    print("a != 101")
# a != 101

3、多分支结构

多分支结构使用if，elif，else实现

a = 100
if a == 101:
    print("a = 101")
elif a == 100:
    print("a = 100")
else:
    print("a != 101")
# a = 100

2、for语句

格式：

for 变量  in  序列或迭代对象:

        语句块

[else :

        else子句语句块]

a = [1,2,3,4,5,6,7]
for i in a:
    print(i)
    

3、while语句

while语句用于循环执行一段程序，直到不满足条件。

求1~100的和：

x = 1
ans = 0
while x <= 100:
    ans += x
    x += 1
print(ans)
# 5050

4、break，continue，pass语句

break语句用于退出循环

continue语句用于跳过该次循环

pass是空语句（不做任何处理）

a = [1,2,3,4]
for i in a:
    pass

四、组合数据

1、元组

1、性质

（1）元组不可修改；
（2）元组支持索引、切片、遍历、长度、运算；
（3）元组有序

（4）元组可以混装

2、元组的定义方式

多个元素，加括号
>>>a = (1,2,3)
(1,2,3)

元组嵌套
>>>a = ((1,2),3)
((1,2),3)

多个元素，不加括号
>>>a = 1,2,3
(1,2,3)

一个元素，不加括号
>>>a = 1,
(1)

空元组
>>>a = ()

注意：当元组内只有一个元素的时候，逗号(,)不可以省略

# 多个元素，加括号
a = (1,2,3)

# 元组嵌套
b = ((1,2),3)

# 多个元素，不加括号
c = 1,2,3

# 一个元素，不加括号
d = 1,

# 空元组
e = ()

3、元组的计算

加法

print((1,2,3) + ("a","b"))
# (1, 2, 3, 'a', 'b')

乘法

print((1,2,3) * 3)
# (1, 2, 3, 1, 2, 3, 1, 2, 3)

in运算符

判断元素是否在元组内

a = (1,2,3)
print(2 in a)
#True
print(4 in a)
#False

is运算符与==运算符

注意：is是比较的地址，==比较的是元组内部的值

a = (1,2)
c = (1,)
b = c + (2,)
print("a = ",a)
# a =  (1, 2)
print("b = ",b)
# b =  (1, 2)
print("a的地址为：",id(a))
# a的地址为： 2851199875456
print("b的地址为：",id(b))
# b的地址为： 2851200877248
print(a is a)
# True
print(a is b)
# False
print(a == b)
# True

<,>运算符
注意：<,>就是将元组对应元素进行比较

a = (1,2,3)
b = (2,3,4)
print(a > b)
# False
print(a < b)
# True

4、元组的索引、切片、遍历

索引

格式：k[x] , x为索取元素的位置，可以为负数

k = (1,2,3,4,5,6)
print(k[0])
# 1
print(k[5])
# 6
print(k[-1])
# 6
print(k[-5])
# 2

切片

格式：k[l,r] ，l为起始位置，r为终止位置（不包含r）

k = (1,2,3,4,5,6)
print(k[0:3])
# (1, 2, 3)
print(k[2:])
# (3, 4, 5, 6)
print(k[-3:-1])
# (4, 5)
print(k[-5:])
# (2, 3, 4, 5, 6)

遍历

元组可以被遍历

k = (1,2,3,4,5,6)
for x in k[2:5]:
       print(x)
# 3
# 4
# 5

5、元组支持方法count()，len()与index()

count(x)表示x在元组中出现的次数

len()：获取元组长度
index(x)表示x第一次在元组中出现的位置
index(x,l,r)表示x第一次在元组[l,r)区间出现的位置

k = (1,2,3,1,2,3)
print(k.count(2))
# 2

print(len(k))
# 6

print(k.index(2))
# 1

print(k.index(2,2,5))
# 4

6、元组存在的意义 

元组作为一个不可变序列，可以保证数据在程序运行过程中，不会意外由自己或
他人修改（例如在函数参数传递中），这样可以保证数据的完整性。

2、列表

1、列表性质

（1）列表与元组相似，不同的是：列表为可变序列

（2）列表为有序序列

（3）列表可以添加/删除元素

（4）列表可以混装

2、列表的创建

（1）使用[ ]创建

a = [1,2,3]
print(a)
# [1, 2, 3]

（2）使用list()创建字符列表

a = list('abc')
print(a)
# ['a', 'b', 'c']

（3）使用list()创建数字列表

a = list((1,2,3))
print(a)
# [1, 2, 3]

（4）使用range()创建整数列表

a = list(range(10))
print(a)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

b = list(range(3,-10,-3))
print(b)
# [3, 0, -3, -6, -9]

（5）使用列表推导式创建列表

a = list(i for i in range(3,10,2))
print(a)
# [3, 5, 7, 9]

（6）创建空列表

a = []
b = list()
print("a = ",a)
# a =  []
print("b = ",b)
# b =  []

3、列表添加元素

（1）append()方法：真正在尾部添加元素，速度最快，推荐使用

注：不改变存储地址，原地操作列表

a = [1,2,3,4]
print("a的地址：",id(a))
# a的地址： 1665568886272
a.append(5)
print("a的地址：",id(a))
# a的地址： 1665568886272
print(a)
# [1, 2, 3, 4, 5]

（2）extend()方法：将B列表元素添加到A列表，推荐使用，A.extend(B)

注：将一个列表添加到另一个列表元素尾部。添加元素前后，地址不变

a = [1,2,3]
b = ['abc']
print("a的地址：",id(a))
# a的地址： 2419901550080
a.extend(b)
print("a的地址：",id(a))
# a的地址： 2419901550080
print(a)
# [1, 2, 3, 'abc']

（3）insert()方法：在列表指定位置插入元素，原地址插入，地址不变

注：当涉及大量元素的时候，尽量避免使用，会让插入位置后面的元素进行大面积移动，影响处理速度

a = [1,2,3,4,5]
print("a的地址：",id(a))
# a的地址： 1952084020736
a.insert(3,0)
print("a的地址：",id(a))
# a的地址： 1952084020736
print(a)
# [1, 2, 3, 0, 4, 5]

4、列表运算

（1）“+”操作符扩展列表

注：操作后会更改储存地址，属于创建新列表，增加内存。不建议使用

a = [1,2,3]
b = [4,5,6]
c = a + b
print(c)
# [1, 2, 3, 4, 5, 6]

（2）“*”操作符扩展列表

注：操作后会更改储存地址，属于创建新列表，增加内存。不建议使用

a = [1,2,3]
b = a * 3
print(b)
# [1, 2, 3, 1, 2, 3, 1, 2, 3]

5、列表的删除

（1）del方法：删除指定位置的元素(或整个列表)

a = [1,2,3,4,5]
del a[2]
print(a)
# [1, 2, 4, 5]
del a
# 删除整个列表

（2）pop()方法：删除指定位置的元素

注：若不指定位置，默认删除列表末尾的元素
推荐使用：不指定索引的用法

a = [1,2,3,4,5]
print(a.pop(1))
# 2
print(a)
# [1, 3, 4, 5]
print(a.pop())
# 5

（3）remove()方法：删除列表中首次出现的元素

注：若删除元素不存在，则抛出异常
 

a = [1,2,3,4,3]
a.remove(3)
print(a)
# [1, 2, 4, 3]

（4）clear()方法：删除列表中所有元素

a = [1,2,3,4,3]
a.clear()
print(a)
# []

6、列表的索引，切片与遍历

列表支持索引，切片与遍历

参考元组

7、列表支持方法count()，len()与index()

参考元组

8、列表排序

sort()方法：原地修改列表

注：默认是升序，参数reverse=True,表示将列表降序，sort 不能用一个新的变量去接收，因为列表前后地址没变，是在原地修改列表。所以不可能用新的变量接收。append 也是类似用法，不能用新的变量去接收

a=[2,3,1]
a.sort()
print(a)
# [1,2,3]
a.sort(reverse=True)
print(a)
# [3,2,1]

sorted()方法：建立新列表的排序方法

9、其他方法

reverse()：列表反转，不排序
max():返回列表中的最大值 
min():返回列表中的最小值
sum():对数值型列表中，所有元素进行求和,有非数值型数据会报错

3、字典

1、字典性质

（1）字典是一种映射类型，用{ }标识。

（2）字典是无序的“key : value”对集合。（key必须是唯一的）

2、字典的创建

（1) 用{}创建字典

a = {'name':'陈丽','age':18,'job':'teacher'}
print(a)
# {'name': '陈丽', 'age': 18, 'job': 'teacher'}
# -----------------------------------------------------------
b = {'name':'陈丽','age':18,'job':['teacher','wife']}
print(b)
# {'name': '陈丽', 'age': 18, 'job': ['teacher', 'wife']}

（2）用 dict 创建字典

c = dict(name='张伟',age=19)
print(c)
# {'name': '张伟', 'age': 19}
# ----------------------------------------------
d = dict([('name','李丽'),('age',18)])
print(d)
# {'name': '李丽', 'age': 18}

（3）用 zip 函数创建字典

x = ['name','age','job']
y = ['陈丽','18','teacher']
e = dict(zip(x,y))
print(e)
# {'name': '陈丽', 'age': '18', 'job': 'teacher'}

（4）用{},dict 创建空字典

f = {}
print(f)
# {}
# -----------------------
g = dict()
print(g)
# {}

（5）用 fromkeys 创建'值为空'的字典

h = dict.fromkeys(['name','age','job'])
print(h)
# {'name': None, 'age': None, 'job': None}

3、字典中元素访问方法

（1） 通过“键”获取“值”。若“键”不存在，则抛出异常
 

a = {'name':'陈丽','age':18,'job':'teacher'}
print(a['name'])
# '陈丽'
print(a['age'])
# 18
print(a['job'])
# 'teacher'
#若键不存在，抛出异常。
print(a['names'])
# 不存在，抛出异常

（2） get()方法：强烈推荐的字典元素访问

b = {'name':'陈丽','age':18,'job':['teacher','wife','sister']}
print(b.get('name'))
# '陈丽'
#若'键'不存在，返回的是 None,而不是抛出异常。
print(b.get('sex'))
# None
print(b.get('sex') == None)
# True
if b.get('sex') == None:
    print('sex = None')
# sex = None
#当'键'不存在时，自己设定默认的返回对象。
print(b.get('sex','不存在'))
#

（3）用 items 获取‘所有的键值对

a = {'name':'陈丽','age':18,'job':'teacher'}
print(a.items())
# dict_items([('name', '陈丽'), ('age', 18), ('job', 'teacher')])
print(type(a.items()))
# <class 'dict_items'>
for i in a.items():
    print(i)
# ('name', '陈丽')
# ('age', 18)
# ('job', 'teacher')

（4） 列出所得有‘键’：keys , 列出所得有‘值’：values

a = {'name':'陈丽','age':18,'job':'teacher'}
print(a.keys())
# dict_keys(['name', 'age', 'job'])
print(a.values())
# dict_values(['陈丽', 18, 'teacher'])

4、元素的添加与删除

添加

（1）“键”存在，则覆盖原有“键值对”。“键”不存在，新增键值对
格式：字典['键']:‘值’。

a = {'name':'陈丽','age':18,'job':'teacher'}
a['job'] = 'sister' #覆盖原有“键值对”
print(a)
# {'name': '陈丽', 'age': 18, 'job': 'sister'}
a['height'] = 170 #新增“键值对”
print(a)
# {'name': '陈丽', 'age': 18, 'job': 'sister', 'height': 170}

（2）使用 update 把 b 字典的所有‘键值对’添加到 a 字典中
格式：a.undate(b)，若果‘键值对重复’，直接覆盖；否则，合并。

a = {'name':'陈丽','age':18,'job':'teacher'}
print(a)
# {'name': '陈丽', 'age': 18, 'job': 'teacher'}
b = dict([('job','Python'),('weight',75),('height',170)])
print(b)
# {'job': 'Python', 'weight': 75, 'height': 170}
a.update(b)
print(a)
# {'name': '陈丽', 'age': 18, 'job': 'Python', 'weight': 75, 'height': 170}

删除
（1） del 方法:删除指定的“键值对” 
注：一旦删除‘键’和‘值’就消失了。

a = {'name':'陈丽','age':18,'job':'teacher'}
del(a['job'])
print(a)
# {'name': '陈丽', 'age': 18}

（2） clear 方法:删除字典中所有的‘键值对’ 
注：删除所有的，有点狠

b = dict([('job','Python'),('weight',75),('height',170)])
print(b)
# {'job': 'Python', 'weight': 75, 'height': 170}
b.clear()
print(b)
# {}

（3） pop 方法：删除指定的‘键’ 
优点：“键”删除后，可以用一个“变量”接收返回的“值”。

c = {'name':'黄伟','age':18,'job':'teacher'}
cc = c.pop('name')
print(cc)
# '黄伟'
print(c)
# {'age': 18, 'job': 'teacher'}

（4） popitem 方法:随机删除和返回‘键值对’ 
注：字典是无序可变序列，没有第一个元素、最后一个元素的概念

b = {'name':'陈丽','age':18,'job':['teacher','wife']}
bb = b.popitem()
print(bb)
# ('job', ['teacher', 'wife'])

bbb = b.popitem()
print(bbb)
# ('age', 18)

bbbb = b.popitem()
print(bbbb)
# ('name', '陈丽')

bbbbb = b.popitem()
print(bbbbb)
# 字典b已经为空，无法继续删除，会报错

5、序列解包：运用于字典（类似于赋值）

（1）利用 items：把‘键值对’赋给 b,c,d,e,f…

a = {'name1':'陈丽','name2':'黄伟','name3':'阿亮','name4':'荣哥'}
b,c,d,e = a.items()
print(b,c)
# (('name1', '陈丽'), ('name2', '黄伟'))

（2）利用 keys：把‘键’赋给 g,h,i,j,k…

a = {'name1':'陈丽','name2':'黄伟','name3':'阿亮','name4':'荣哥'}
g,h,i,j = a.keys()
print(g,h)
# name1 name2

（3）利用 values：把‘键’赋给 l,m,n,o,p… 

a = {'name1':'陈丽','name2':'黄伟','name3':'阿亮','name4':'荣哥'}
l,m,n,o = a.values()
print(l,m)
# 陈丽 黄伟

6、字典键值对的个数：len()

a = {'name':'陈丽','age':18,'job':'teacher'}
print(len(a))
# 3

4、集合

1、集合的性质

（1）可以容纳多个数据
（2）可以容纳不同的数据类型
（3）数据储存是无序的（不支持下标索引）
（4）不允许重复数据存在
（5）可以修改（增加或删除元素等）
（6）支持for循环

2、集合的创建

1、使用{ }创建集合

集合名 = {元素1，元素2，元素3......}

2、使用set()创建集合

集合名 = set(sequence)

集合可以是字符串、列表、元组或range()函数返回结果等迭代对象

3、访问集合元素

集合的元素是无序的，不支持索引来访问集合中的指定元素，但是可以访问整个集合，还可以遍历所有元素。

a = {1,2,3,4,5}
print("访问集合元素：",a)
# 访问集合元素： {1, 2, 3, 4, 5}
print("遍历集合元素")
for i in a:
    print(i)

# 遍历集合元素
# 1
# 2
# 3
# 4
# 5

4、元素的添加与删除

添加新元素：add
语法：集合.add(添加的元素)

添加或修改元素：update
语法：集合.update(sequence)
在集合中添加或修改元素。sequence可以是列表、元组、集合等。

移除元素：remove
语法：集合.remove(元素)
将指定元素从集合中去除

移除元素：discard
语法：集合.discard(元素)
删除指定元素

随机取出元素：pop
语法：集合.pop()
从集合中随机取出一个元素
结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
 

清空所有元素：clear
语法：集合.clear()
 

5、集合的运算

取两个集合的差集：difference
set3 = set1.diffierence(set2)
结果：
得到了一个新集合，该集合属于set1,但是没有属于set2的元素

消除2个集合的差集：difference_update
集合1.difference_uodate(集合2)
功能：对比集合1和集合2，在集合1内，删除与集合2相同的元素
结果：集合1被修改，集合2不变。

两个集合合并为一个：union
set3 = set1.union(set2)
结果：得到一个集合3，该集合包含集合1，2的所有元素。

“ > , < ”运算符：子集运算
set1 < set2  若set1是set2的子集，返回True，否则返回False。

“ - ”运算符：差集运算
set1 - set2  返回在set1集合中但是不在set2集合中的元素。

“&”运算符：交集运算
set1 & set2  返回同时在集合set1与set2集合中的元素。

“|”运算符：并集运算
set1 | set2  返回结果为在集合set1与set2中所有的元素。

---

总结

函数与面向对象等部分将在后续部分......