Python基础学习

基础篇

1. 基本概念

1.1 字面量

在代码中，被写下来的固定的值。

1.2 数据类型

Python有6种数据类型：

类型 描述 说明
数字（Number） 支持 整数（int） 浮点数（float） 复数（complex） 布尔（bool） 整数（int），如：10、-10 浮点数（float），如：13.14、-13.14 复数（complex），如：4+3j，以 j 结尾表示复数 布尔（bool）表达现实生活中的逻辑，即真和假，True 表示真，False 表示假。True 本质上是一个数字记作 1，False 记作 0
字符串（String） 描述文本的一种数据类型 字符串（string）由任意数量的字符组成
列表（List） 有序的可变序列 Python 中使用最频繁的数据类型，可有序记录一堆数据
元组（Tuple） 有序的不可变序列 可有序记录一堆不可变的 Python 数据集合
集合（Set） 无序不重复集合 可无序记录一堆不重复的 Python 数据集合
字典（Dictionary） 无序 Key - Value 集合 可无序记录一堆 Key - Value 型的 Python 数据集合

1.3 注释

  • 单行注释：前面加 #
  • 多行注释：前后加 “””

1.4 变量

在程序运行时储存值，值可以变。

2. 基本操作

2.1 输出

  • print() 拼接直接用逗号
1
2
a = 1
print("a =", a)
  • 输出不换行添加 end=""
1
2
3
print("Hello", end="")
print("World", end="")
# 输出：HelloWorld
  • \t 水平制表符
1
2
3
4
5
print("Hello\tWorld")
print("Name\tAge")
# 输出：
# Hello	World
# Name	Age

2.2 数据类型查看

type() 函数：输出数据类型信息

1
2
3
a = 1
print(type(a))
# 输出：<class 'int'>

2.3 数据类型转换

函数 说明
int(x) 将x转换为整数，小数会丢失精度
float(x) 将x转换为浮点数
str(x) 将x转换为字符串

2.4 字符串格式化

格式符号 转化
%s 将内容转换成字符串，放入占位符位置
%d 将内容转换成整数，放入占位符位置
%f 将内容转换成浮点型，放入占位符位置

示例：

1
2
3
4
5
wo = "我"
jn = "今年"
age = 18
print("你好%s%s%s" % (wo, jn, age))
# 输出：你好我今年18

%5d：表示将整数的宽度控制在5位，如数字11，输出为[空格空格空格11]，用三个空格补足宽度。宽度比自己本身小就不生效

%7.2f：表示将宽度控制在7，将小数点精度设置为2，且会四舍五入，如小数11.345，输出为[空格空格11.35]

%.2f：表示不限制宽度，只设置精度

快速字符串格式：
语法：f"内容{变量:宽度.精度}"
示例：

1
2
3
4
5
wo = "我"
jn = "今年"
age = 11.99
print(f"你好{wo}{jn}{age:3.0f}")
# 输出：你好我今年 12

2.5 输入

input(提示内容) 函数：用来获取键盘输入。获取到的数据都是字符串类型

2.6 运算符

运算符 描述 示例
== 判断内容是否相等，满足为 True，不满足为 False 如 a=3, b=3，则 (a == b) 为 True
!= 判断内容是否不相等，满足为 True，不满足为 False 如 a=1, b=3，则 (a != b) 为 True
> 判断运算符左侧内容是否大于右侧，满足为 True，不满足为 False 如 a=7, b=3，则 (a> b) 为 True
< 判断运算符左侧内容是否小于右侧，满足为 True，不满足为 False 如 a=3, b=7，则 (a < b) 为 True
>= 判断运算符左侧内容是否大于等于右侧，满足为 True，不满足为 False 如 a=3, b=3，则 (a>= b) 为 True
<= 判断运算符左侧内容是否小于等于右侧，满足为 True，不满足为 False 如 a=3, b=3，则 (a <= b) 为 True

2.7 随机数

随机数函数 random.randint(最小值, 最大值)

1
2
3
# 生成一个1到100之间的数
import random
sum = random.randint(1, 100)

3. 流程控制

3.1 while 循环

语法格式：

1
2
3
4
5
6
7
8
9
10
11
12
while 条件1:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    条件满足时，做的事情4
    ......
    while 条件2:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        条件满足时，做的事情4
        ......

3.2 for 循环

语法：

1
2
3
4
5
6
7
8
9
10
11
for 临时变量 in 序列类型:
    循环满足条件时执行的代码
name = "Hello"
for i in name:
    print(i)
# 输出：
# H
# e
# l
# l
# o

序列类型：字符串、列表、元组等

3.3 range() 函数

  • 语法1：range(num)：获取一个从0开始，到num结束的数字序列(不含num本身)
  • 语法2：range(num1, num2)：获取一个从num1开始，到num2结束的数字序列(不含num2本身)
  • 语法3：range(num1, num2, step)：获取一个从num1开始，到num2结束的数字序列(不含num2本身)数字之间的步长，以step为准(step默认为1)
    • 如 range(1, 10, 2) 获取的数据为 [1, 3, 5, 7, 9]

3.4 循环控制

  • continue：中断所在的循环一次循环，直接进入下一次循环
  • break：所在的循环直接结束循环

4. 函数

4.1 函数定义

1
2
3
def 函数名(传入的参数):
    函数体
    return 返回值

当函数没有返回值时会返回 None

4.2 函数说明文档

1
2
3
4
5
6
7
8
def add(x, y):
    """
    计算两数之和
    :param x: 相加的第一个数
    :param y: 相加的第二个数
    :return: 返回两个数之和
    """
    return x + y

4.3 变量作用域

  • 局部变量：定义在函数体内部的变量，即只在函数体内部生效
  • 全局变量：在函数体内外都能生效的变量
    • 当存在同名变量时，局部变量会覆盖全局变量，但仅在局部作用域内有效
    • 若要在函数内部修改全局变量的值，必须使用 global 关键字声明
1
2
3
4
5
6
7
8
9
x = 10  # 全局变量

def test():
    global x  # 声明要修改全局变量 x
    x = 20    # 修改全局变量的值
    print("函数内的 x:", x)  # 输出：20

test()
print("函数外的 x:", x)  # 输出：20（全局变量已被修改）

在嵌套函数中，若要修改外层（非全局）函数的变量，需使用 nonlocal 关键字

1
2
3
4
5
6
7
8
9
10
11
def outer():
    x = 10  # 外层函数的局部变量
    
    def inner():
        nonlocal x  # 声明要修改外层函数的变量 x
        x = 20      # 修改外层变量的值
    
    inner()
    print("外层函数的 x:", x)  # 输出：20

outer()

4.4 函数传参方式

  • 位置参数：调用函数时根据函数定义的参数位置来传递参数
1
2
3
4
def user_info(name, age, gender):
    print(f'您的名字是{name}，年龄是{age}，性别是{gender}')

user_info('TOM', 20, '男')
  • 关键字参数：函数调用时通过”键=值”形式传递参数
1
2
3
4
5
6
7
8
9
def user_info(name, age, gender):
    print(f"您的名字是：{name}，年龄是：{age}，性别是：{gender}")

# 关键字传参
user_info(name="小明", age=20, gender="男")
# 可以不按照固定顺序
user_info(age=20, gender="男", name="小明")
# 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明", age=20, gender="男")
  • 缺省参数：也叫默认参数，用于定义函数为参数提供默认值
1
2
3
4
5
def user_info(name, age, gender='男'):
    print(f'您的名字是{name}，年龄是{age}，性别是{gender}')

user_info('TOM', 20)
user_info('Rose', 18, '女')
  • 不定长参数：用于不确定调用的时候会传递多少个参数的场景
    • 位置传递：传进的所有参数都会根据传进参数的位置合并成为一个元组(tuple)
1
2
3
4
5
6
7
def user_info(*args):
    print(args)

user_info('TOM')
# 结果: ('TOM',)
user_info('TOM', 18)
# 结果: ('TOM', 18)
  • 关键字传递：参数是”键=值”的形式，所有的参数都会接收且会根据”键=值”组成字典
1
2
3
4
5
6
7
8
def user_info(**kwargs):
    print(kwargs)

# 输出: {'name': 'TOM', 'age': 20}
user_info(name='TOM', age=20)

# 输出: {'name': 'Rose', 'age': 18, 'gender': '女'}
user_info(name='Rose', age=18, gender='女')
  • 函数作为参数传递：传递的是计算逻辑，而不是数据的传递
1
2
3
4
5
6
7
8
def test_func(compute):
    result = compute(1, 2)
    print(result)

def test(x, y):
    return x + y

test_func(test) # 结果：3

4.5 lambda 匿名函数

语法：

1
lambda 传入参数: 函数体(一行代码)

示例：

1
2
3
4
5
6
def test(com, x, y):
    x = com(x)
    return x + y

a = test(lambda a: a + 10, 10, 20)
print(a)    # 结果：40

5. 数据容器

5.1 通用特点

一种可容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据。
特点：

  • 是否支持重复元素
  • 是否可修改
  • 是否有序

5.2 序列的常用操作

序列：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串都是序列。
序列的切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]

  • 起始下标表示从何处开始，可以留空，留空视作从头开始
  • 结束下标 (不含) 表示何处结束，可以留空，留空视作截取到结尾
  • 步长表示，依次取元素的间隔
  • 步长 1 表示，一个个取元素
  • 步长 2 表示，每次跳过 1 个元素取
  • 步长 N 表示，每次跳过 N - 1 个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

5.3 数据容器类别

数据类型 定义表示 元素数量 元素类型 下标索引 重复元素 可修改性 数据有序性 应用场景
列表 方括号 [] 支持多个 任意 支持 支持 支持 是 可修改、可重复的一批数据记录场景，如学生成绩记录、购物清单
元组 圆括号 () 支持多个 任意 支持 支持 不支持 是 不可修改、可重复的一批数据记录场景，如函数固定返回值、坐标点
字符串 单引号 ''、双引号 ""、三引号 ''' 或 """ 支持多个 仅字符 支持 支持 不支持 是 一串字符的记录场景，如文本处理、姓名地址存储
集合 花括号 {}（空集合用set()） 支持多个 任意 不支持 不支持 支持 否 用于去重，判断成员关系，集合的交、并、差运算等场景
字典 花括号 {}，以键值对key: value形式 支持多个 Key：除字典外任意不可变类型 Value：任意类型 不支持 Key 不支持，Value 支持 支持 否 以 Key 检索 Value 的数据记录场景，如存储用户信息（键为用户名，值为用户详情 ）
5.3.1 列表（list）
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
# 字面量
[元素 1，元素 2，元素 3，元素 4，...]
# 定义变量
变量名称 = [元素 1，元素 2，元素 3，元素 4，...]
# 定义空列表
变量名称 = []
变量名称 = list ()
# 取元素
print(变量名[下标索引])
# 查找元素的第一次出现的下标
变量名.index(元素)
# 在指定的下标位置插入元素
变量名.insert(下标, 元素)
# 在列表追加元素
变量名.append(元素)
# 在列表追加其他数据容器
变量名.extend(其他数据容器)
# 删除元素
del 变量名[下标]
变量名.pop[下标]
# 删除元素在列表中的第一个匹配项
变量名.remove(元素)
# 清空列表内容
变量名.clear()
# 统计元素在列表中出现的次数
变量名.count(元素)
# 统计列表长度
len(变量名)
5.3.2 元组（tuple）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 定义元组字面量
(元素, 元素, ..., 元素)
元素, 元素, ..., 元素
# 定义元组变量
变量名 = (元素, 元素, ..., 元素)
变量名 = 元素, 元素, ..., 元素
# 定义空元组
变量名 = ()
变量名 = tuple()
# 取元素
变量名[下标索引]
# 查找元素的第一次出现的下标
变量名.index(元素)
# 统计元素在元组中出现的次数
变量名.count(元素)
# 统计元组长度
len(变量名)
5.3.3 字符串（str）
1
2
3
4
5
6
7
8
9
10
11
12
# 查找特定字符串的起始下标索引值
字符串.index(字符串)
# 替换字符串里的内容
字符串 = 字符串.replace(字符串1, 字符串2) # 不是修改字符串本身，而是得到了一个新字符串
# 字符串的分割
字符串.split(分割字符串) # 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。返回的是列表
# 去前后指定字符串
字符串.strip(字符串) # 没有参数代表去空格，按单个字符去除
# 统计字符串中某字符串出现的次数
字符串.count(字符串)
# 统计字符串长度
len(字符串)
5.3.4 集合（set）
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
# 定义集合字面量
{元素, 元素, ..., 元素}
# 定义变量
变量名称 = {元素 1，元素 2，元素 3，元素 4，...}
# 定义空集合
变量名称 = set()
# 添加元素
变量名.add(元素)
# 移除元素
变量名.remove(元素)
# 随机取出元素
变量名.pop
# 清空集合
变量名.clear()
# 取出两个集合中的差集(集合1有而集合2没有的)
set1 = {1, 2, 3}
set2 = {1, 5, 6}
print(set1.difference(set2)) # 结果：{2, 3}
# 消除两个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
print(set1.difference_update(set2))
print(set1) # 结果：{2, 3}
print(set2) # 结果：{1, 5, 6}
# 合并两个集合
集合1.union(集合2)
5.3.5 字典（dict）
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
# 定义字典字面量
{key: value, key: value, ..., key: value}
# 定义字典变量
变量名 = {key: value, key: value, ..., key: value}
# 定义空字典
变量名 = {}
变量名 = dict{}
# 取出字典中的Value
变量名[key]
# 新增元素
stu_dict = {
    "张三": 77,
    "李四": 88
}
stu_dict['王五'] = 66
print(stu_dict) # 结果：{"张三": 77,"李四": 88, "王五": 66}
# 更新元素
stu_dict = {
    "张三": 77,
    "李四": 88
}
stu_dict['张三'] = 66
print(stu_dict) # 结果：{"张三": 66,"李四": 88}
# 删除元素
stu_dict = {
    "张三": 77,
    "李四": 88
}
print(stu_dict.pop('李四')) # 结果：{"张三": 77}
# 清空字典
变量名.clear()
# 获取全部的key
变量名.keys()

5.4 数据容器的通用函数

1
2
3
4
5
6
7
8
9
10
len(容器) # 统计容器的长度
max(容器) # 容器最大的元素
min(容器) # 容器最小的元素

list(容器) # 将容器转换成列表
str(容器) # 将容器转换成字符串
tuple(容器) # 将容器转换成元组
set(容器) # 将容器转换成集合

sorted(容器, [reverse=True]) # 给容器排序，默认从小到大reverse为False，改为True就会从大到小。结果为列表

6. 文件操作

6.1 文件的编码

编码技术：翻译的规则，记录了如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容。不同的编码翻译成二进制也不同。
常见编码：

  1. UTF - 8：目前全球通用的编码格式
  2. GBK
  3. Big5

6.2 文件的读取

open() 函数：打开一个已经存在的文件或创建一个新文件

1
2
3
4
open(name, mode, encoding)
# name：是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
# mode：设置打开文件的模式（访问模式）：只读、写入、追加等
# encoding：编码格式（推荐使用UTF - 8）

mode 常用的三种基础访问模式：

  1. ‘r’：以只读方式打开文件，文件的指针将会放在文件的开头。默认模式
  2. ‘w’：打开一个文件只用于写于。如果改文件已存在则打开文件，从头开始编辑且原有的内容都会被删除。如果不存在，创建新文件
  3. ‘a’：打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有的内容之后。如果不存在，创建新文件进行写入

读取方法：

1
2
文件对象.read(num)
# num表示要从文件中读取的数据的长度（单位是字符），如果没有传入num，表示读取文件中所有的数据。返回的时str类型

readlines() 方法：可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，其中每一行的数据为一个元素
readline() 方法：一次读取一行返回的时字符串类型
close() 方法：关闭文件对象关闭占用，不调用这个方法会导致文件一直被python程序占用

with open as 语法：操作完后自动 close 文件
示例：

1
2
with open('1.txt', 'r', encoding='UTF - 8') as f:
    print(f.readlines())

6.3 文件的写入

1
2
3
4
5
6
# 1.打开文件
f = open('python.txt', 'w')
# 2.文件写入
f.write('hello world')
# 3.内容刷新
f.flush()

调用 write 时内容没有写入文件，而是在内存的缓冲区，当调用 flush 的时候内容才会写入到文件中，也可以用 close 方法

6.4 文件的追加

1
2
3
4
5
6
# 1.用a模式打开
f = open('python.txt', 'a')
# 2.文件写入
f.write('hello world')
# 3.内容更新
f.flush()

7. 异常处理

7.1 异常的捕获方法

异常就是程序运行中抛出了错误。
捕获异常作用：提前假设某处会出现异常，做好提前准备，出现异常时有后续手段。

异常捕获语法：

1
2
3
4
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码

捕获指定异常语法：

1
2
3
4
try:
    print(name)
except NameError as e:
    print('name变量名称未定义错误')

多个异常捕获：

1
2
3
4
try:
    print(1/0)
except (NameError, ZeroDivisionError):    # 多个异常用元组类型
    print('ZeroDivision错误')

异常的 else：

1
2
3
4
5
6
try:
    print(1)
except Exception as e:    # Excception表示所有异常
    print(e)
else:    # 没有异常执行的代码
    print('没有异常')

异常的 finally：

1
2
3
4
5
6
7
8
try:
    f = open('test.txt', 'r')
except Exception as e:
    f = open('test.txt', 'w')
else:
    print('没有异常')
finally:        # finally表示无论有没有异常都执行的代码
    f.close()

7.2 异常的传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def func01():
    print("这是func01开始")
    num = 1 / 0
    print("这是func01结束")
def func02():
    print("这是func02开始")
    func01()
    print("这是func02结束")
def main():
    try:
        func02()
    except Exception as e:
        print(e)
main() # 结果：这是func02开始
        #      这是func01开始
        #      division by zero

8. 模块与包

8.1 模块

模块：是一个python文件，以 .py 结尾。模块能定义函数，类和变量，模块里也能包含可执行的代码。
模块作用：快速的实现一些功能。
模块导入语法：

1
[from 模块名] import [模块|类|变量|函数|*] [as 别名]

自定义模块：在python代码文件中正常写代码即可，通过 import、from 关键字和导入python内置模块一样导入即可使用。
__name__ 变量的功能：只有当程序是直接执行的值才为 __main__，如果是导入则是模块名。
__all__ 变量的功能：可以控制 import * 的时候哪些功能可以被导入。

8.2 包

包：就是一个文件夹，里面可以存放许多python的模块（代码文件），通过包，在逻辑上将一批模块归为一类，方便管理。
包中的 __init__.py 文件：创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是python的包，而非普通的文件夹。
__all__ 变量的作用：通模块中学习到的是一个作用，控制 import * 能够导入的内容。

8.3 安装第三方python包

第三方包：非官方内置的包。
安装第三方包：python中内置pip程序。
安装语法：

  1. pip install 包名称
  2. pip install -i 镜像网址 包名称

9. JSON数据

JSON：是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据，本质上一个带有特定格式的字符串。
Python数据和JSON数据转换示例：

1
2
3
4
import json        # 导入json模块
data = [{"name": "老王", "age": 16}, {"name":"张三", "age": 20}]    # 准备python数据
data = json.dumps(data, ensure_ascii=False)    # 通过json.dumps(data)方法把python数据转换成json数据，有中文代上ensure_ascii=False
data = json.loads(data)    # 通过json.loads(data)方法把json数据转换成python数据