文章目录
-
-
- [1. 环境安装](#1. 环境安装)
- [2. 第一个程序 hello word](#2. 第一个程序 hello word)
- [3. 注释](#3. 注释)
- [4. 变量](#4. 变量)
-
- [4.1 变量声明](#4.1 变量声明)
- [4.2 命名规则](#4.2 命名规则)
- [4.3 命名规范](#4.3 命名规范)
- [5. 运算符](#5. 运算符)
-
- [5.1 算术运算符](#5.1 算术运算符)
- [5.2 赋值运算符](#5.2 赋值运算符)
- [5.3 比较运算符](#5.3 比较运算符)
- [6. 数据类型](#6. 数据类型)
-
- [6.1 数据类型](#6.1 数据类型)
- [6.2 数据类型的转换](#6.2 数据类型的转换)
- [7. 字符串操作](#7. 字符串操作)
-
- [7.1 字符串定义的几种方式](#7.1 字符串定义的几种方式)
- [7.2 字符串拼接](#7.2 字符串拼接)
- [7.3 字符串格式化](#7.3 字符串格式化)
- [7.4 字符串精度控制](#7.4 字符串精度控制)
- [8. 数据输入](#8. 数据输入)
- [9. 语句](#9. 语句)
-
- [9.1 if 判断语句](#9.1 if 判断语句)
- [9.2 循环语句1](#9.2 循环语句1)
-
- [9.2.1 while 循环](#9.2.1 while 循环)
- [9.2.2 for 循环](#9.2.2 for 循环)
- [9.3 循环语句2](#9.3 循环语句2)
-
- [9.3.1 range 语句](#9.3.1 range 语句)
- [9.3.2 for 循环临时变量作用域](#9.3.2 for 循环临时变量作用域)
- [9.3.3 continue 与 break](#9.3.3 continue 与 break)
- [10. 函数](#10. 函数)
-
- [10.1 函数的作用](#10.1 函数的作用)
- [10.2 函数的定义](#10.2 函数的定义)
- [10.3 函数的描述](#10.3 函数的描述)
- [10.4 函数的嵌套](#10.4 函数的嵌套)
- [10.5 全局变量与局部变量](#10.5 全局变量与局部变量)
- [10.6 函数案例，ATM 机](#10.6 函数案例，ATM 机)
- [11. 数据容器](#11. 数据容器)
-
- [11.1 列表](#11.1 列表)
-
- [11.1.1 列表的定义](#11.1.1 列表的定义)
- [11.1.2 列表的基本操作](#11.1.2 列表的基本操作)
- [11.1.3 列表的方法](#11.1.3 列表的方法)
- [11.1.4 列表的遍历](#11.1.4 列表的遍历)
- [11.2 元组](#11.2 元组)
-
- [11.2.1 元组的定义](#11.2.1 元组的定义)
- [11.2.2 元组的基本操作](#11.2.2 元组的基本操作)
- [11.2.3 元组的方法](#11.2.3 元组的方法)
- [11.2.4 元组的遍历](#11.2.4 元组的遍历)
- [11.3 字符串](#11.3 字符串)
-
- [11.3.1 字符串的基本操作](#11.3.1 字符串的基本操作)
- [11.3.2 字符串的方法](#11.3.2 字符串的方法)
- [11.3.3 字符串的遍历](#11.3.3 字符串的遍历)
- [11.4 序列的切片](#11.4 序列的切片)
-
- [11.4.1 序列的定义](#11.4.1 序列的定义)
- [11.4.2 序列的操作](#11.4.2 序列的操作)
- [11.5 集合](#11.5 集合)
-
- [11.5.1 集合的定义](#11.5.1 集合的定义)
- [11.5.2 集合的方法](#11.5.2 集合的方法)
-
1. 环境安装
- 需要安装 python 解析器（解析器是吧 python 语言，解析成计算机可以认识的01代码）、代码编辑器（方法编写 python 代码）
- 解析器下载 exe 直接双击安装即可
- 编辑器需要去官网下载 PyCharm 面向专业开发者的 Python IDE
2. 第一个程序 hello word
py
# 以下代码会打印一个 hello word
print("hello word")3. 注释
py
# 我是单行注释
"""
我是多行注释
"""4. 变量
4.1 变量声明
py
# 此时 num 就是一个变量，变量可以被修改也可以做运算等
num = 1234.2 命名规则
- 内容限定，限定只能使用：中文、英文、数字、下划线，注意：不能以数字开头
- 区分大小写
- 不可使用关键字，True、False、None、and、as、if、import、yield... 等
4.3 命名规范
- 见名知意
- 下划线命名法
- 一个单词字母全小写
5. 运算符
5.1 算术运算符
| 运算符 | 描述 | 示例 |
|---|---|---|
| + | 加 | 10 + 10 = 20 |
| - | 减 | 10 - 5 = 5 |
| * | 乘 | 10 * 10 = 100 |
| / | 除 | 10 / 10 = 1 |
| // | 取整除 | 9 // 2 = 4 |
| % | 去余 | 9 % 2 = 1 |
| ** | 指数 | 2 ** 3 = 8 |
5.2 赋值运算符
| 运算符 | 描述 | 解释 |
|---|---|---|
| = | 赋值运算符 | 直接赋值 |
| +=、-=、*=、/=、%=、**=、//= | 复合赋值运算符 | 先本身和后面的数值进行计算，在赋值给自己 |
py
num += 3 # num = num + 35.3 比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 比较左右两边是否相等，返回布尔值 | 3 == 3 为 True |
| != | 比较左右两边是否不相等，返回布尔值 | 3 != 3 为 False |
| > | 比较左边是否大于右边，返回布尔值 | 5 > 3 为 True |
| < | 比较左边是否小于右边，返回布尔值 | 5 < 3 为 False |
| >= | 比较左边是否大于等于右边，返回布尔值 | 4 >= 4 为 True |
| <= | 比较左边是否小于等于右边，返回布尔值 | 5 <= 4 为 False |
6. 数据类型
6.1 数据类型
type(xxx)：可以用于查看数据类型
列：
type(123) ==> <class 'int'>type(123.123) ==> <class 'float'>type(True) ==> <class 'bool'>
| 类型 | 描述 | 说明 |
|---|---|---|
| 数字（Number） | 支持： 整数（int）、浮点数（float）、复数（complex）、布尔（bool） | 整数：10、-10，浮点数：13.14、-13.14，复数：4+3j，以 j 结尾表示复数，布尔：既真和假，True 表示为真记作1，False 表示假记作0 |
| 字符串（String） | 描述文本的一种数据类型 | 字符串由任意数量的字符组成 |
| 列表（List） | 有序的可变序列 | Python 中使用最频繁的数据类型，可有序记录一堆数据 |
| 元组（Tuple） | 有序的不可变序列 | 可有序的记录一堆不可变的 Python 数据集合 |
| 集合（Set） | 无序不重复集合 | 可无序的记录一堆不重复的 Python 数据集合 |
| 字典（Dictionary） | 无序的 Key-Value 集合 | 可无序记录一堆 Key-Value 型的 Python 数据集合 |
6.2 数据类型的转换
- int(x)：将 x 转换为 int 类型，x 有限制，当 x 为字符时，字符内容只能为纯数字，不然会报错
- float(x)：将 x 转换为 float 类型，x 有限制
- str(x)：将 x 转换为 str 类型，x 没有限制
7. 字符串操作
7.1 字符串定义的几种方式
-
单引号定义
py'hello word' -
双引号定义
py"hello word" -
三引号定义
py# 三引号的方式，如果不用变量接收那么就是多行注释，如果用变量接收就是多行字符串，*三引号定义建议使用双引号 s = """ hello word hello word """ -
引号之间的嵌套
py# \ 为转义字符，把特殊字符当做字符使用 "'hello word'" '"hello word"' "\"hello word\"" '\'hello word\''
7.2 字符串拼接
py
# 字符串拼接都是使用 + 号，可以字符串与字符串拼接，也可以和变量拼接
h = "hello"
w = "word"
h + w
h + "word"
"hello" + "word"7.3 字符串格式化
- %s 插入字符，"hello %s" % "word"
- %：表示占位
- s：表示插入的位置
py
# 如果为多个 %s，后面则需要一个小括号一一对应
print("大家好我叫%s，今年%s岁了" % ("张三", 18))| 格式符号 | 转化 |
|---|---|
| %s | 将内容转换成字符串，放入占位位置 |
| %d | 将内容转换成整数，放入占位位置 |
| %f | 将内容转换成浮点数，放入占位位置 |
- f"内容{变量}"：第二种插入方式，字符串前面加上一个 f 可以直接使用变量
7.4 字符串精度控制
-
以下代码将内容转换成浮点数会出现精度丢失的问题
pyprint("大家好我叫%s，今年%f岁了" % ("张三", 18)) # 大家好我叫张三，今年18.000000岁了 -
需要对数字做精度控制，我们可以使用辅助符号 "m.n" 来控制数据的宽度和精度
- m：控制数字整数部分的长度，设置的长度小于数字的长度，不生效，大于则空格补齐
- n：控制数字小数部分精度，设置的长度小于小数的长度，四舍五入，大于则零补齐`
- 例：
"%7.2f" % 15.146 ==> [空格][空格]15.15（一共有七个字符长度）
8. 数据输入
-
input("提示内容")
-
input() 会中断程序的执行，等到键盘按下回车，才会执行后续的代码
-
input() 输入的内容始终为字符串
pyname = input("请输入你的名字") print(f"你的名字是：{name}")
9. 语句
9.1 if 判断语句
-
if
py""" 语法（根据 tab 来判断是否属于当前 if 语句，规范为 4 个空格） if 判断条件: 满足条件执行结果 满足条件执行结果 不受 if 的约束 """ # 代码示例，只有最后一个 print 才会打印 age = 16 if age > 18: print("我已经成年了") print("我长大了") print("我不知道我多少岁") -
else
py""" 语法 if 判断条件: 满足条件执行结果 else: 不满足条件执行结果 """ -
if elif else
py""" 语法 注意一个语句中只会执行一个条件，如果多个条件同时满足，执行最先匹配的 if 判断条件: 满足条件执行结果 elif 判断条件: 满足条件执行结果 ...elif else: 不满足条件执行结果 """ -
if 嵌套
py# 嵌套也是根据 tab 来判断的 if True: print("第一层if开始") if True: print("第二层if") print("第一层if结束") print("最外层if")
9.2 循环语句1
9.2.1 while 循环
py
# 如果条件一直满足就会一直执行，嵌套和 if 用法一样，这里就不一一叙述了
while 条件:
满足条件执行结果9.2.2 for 循环
py
"""
# 嵌套和 while 用法一样
待处理的数据集(序列类型)，字符串、列表、元组...
for 临时变量 in 待处理的数据集:
"""
name = "abcd"
for k in name:
print(k)
# a
# b
# c
# d9.3 循环语句2
9.3.1 range 语句
- 作用：获得一个数字序列
- 语法：
- range(num)：获取一个从 0 ~ num - 1 的数字序列
- range(num1, num2)：获取一个从 num1 ~ num2 - 1 的数字序列
- range(num1, num2, step)：步长不在是 1 了，比如 (5, 10, 2) ==> 5、7、9
py
for i in range(5)
print(i)
# 0
# 1
# 2
# 3
# 49.3.2 for 循环临时变量作用域
py
# 这种情况外层的 print 语句是可以访问到变量 i 的，但是规范上不建议这么做
for i in range(3):
print(i)
print("我是外层的i", i)
# 0
# 1
# 2
# 我是外层的i 2
# 最好是在外层在定义一个 i
i = 0
for i in range(3):
print(i)
print("我是外层的i", i)9.3.3 continue 与 break
-
continue 与 break 都是对当前层的影响
-
continue 跳过当前循环
pyfor i in range(3): print("我是前面的", i) continue print("我是后面的", i) # 我是前面的 0 # 我是前面的 1 # 我是前面的 2 -
break 结束循环语句
pyfor i in range(3): print("我是前面的", i) break print("我是后面的", i) # 我是前面的 0
10. 函数
10.1 函数的作用
- 将功能封装在函数内，可供随时随地的重复利用
- 提高代码的复用性，减少重复代码，提高开发效率
10.2 函数的定义
- 函数调用时传入的实参与形参对应
- 函数 return 的值，调用时可以接收到，如果不写 return 默认返回 None
- 在当前作用域中如果 return 后面还有代码，则 return 后面的代码不会执行
- 函数要先定义才能使用
py
def 函数名称(形参1, 形参2):
# 函数体 code
# 函数返回
return ""
# 函数调用
函数名称(实参1, 实参2)10.3 函数的描述
py
# 键盘敲三个 "，然后回车，编辑器直接会出当前参数和返回值的架子，需要自行添加详细描述
def add(a, b):
"""
两数相加
:param a: 参数1
:param b: 参数2
:return: 返回两个数的和
"""
return a + b10.4 函数的嵌套
py
# 代码从上向下依次执行
def a():
print("我第二个执行")
def b():
print("我第一个执行")
a()
print("我第三个执行")
b()
# 我第一个执行
# 我第二个执行
# 我第三个执行10.5 全局变量与局部变量
py
# 函数中定义的变量外部无法访问
def a():
num = 100
a()
print(num) # name 'num' is not defined
# 函数中无法修改全局的变量（但是可以拿到），下面这段代码函数 a 中的 num 相当于又在局部声明了一个
num = 50
def a():
num = 100
a()
print(num) # 50
# global 关键字，设置内部的变量为全局变量
num = 50
def a():
global num
num = 100
a()
print(num) # 10010.6 函数案例，ATM 机
py
"""
初始账户有 5000
重复一下操作直到退出，1：查看余额，2：存款，3：取款，4：退出
"""
money = 5000
name = input("请输入您的名称")
flag = True
def view():
"""
查看余额
:return:
"""
print(f"{name}的余额为{money}")
def save():
"""
存款
:return:
"""
num = int(input("请输入存款金额"))
global money
money += num
def take():
"""
取款
:return:
"""
num = int(input("请输入取款金额"))
global money
if num > money:
print("取款失败，账号没有这么多余额")
else:
money -= num
def main():
"""
主程序
:return:
"""
i = int(input("请输入您的操作，1：查看余额，2：存款，3：取款，4：退出"))
if i == 1:
view()
elif i == 2:
save()
elif i == 3:
take()
else:
global flag
flag = False
while flag:
main()11. 数据容器
11.1 列表
11.1.1 列表的定义
py
# 字面量
[元素1, 元素2, 元素3, 元素4, ...]
# 定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]
# 定义空列表
变量名称 = []
变量名称 = list()11.1.2 列表的基本操作
py
# 定义一个普通列表
arr1 = ["元素1", "元素2", "元素3", "元素4"]
# 定义一个嵌套列表
arr2 = ["元素1", ["元素2_1", "元素2_2"], "元素3"]
# 通过列表下标获取列表中的数据
# 从左向右 0、1、2、... ，从右向左 -1、-2、-3、...
print(arr1[0]) # 元素1
print(arr1[-1]) # 元素4
# 或者嵌套列表中的数据
print(arr2[1][0]) # 元素2_1
# 获取超出范围的内容，会报错
print(arr[4]) # IndexError: list index out of range
# 修改列表中某个元素的值
arr1[0] = "我是修改的值"
# 删除列表中某个元素的值
del arr1[0]
# 获取列表的长度
len(arr)11.1.3 列表的方法
py
# 注，列表统一使用 arr
arr = [1, 2, 3]| 方法名称 | 作用 | 示例 | 返回值 | 原列表 |
|---|---|---|---|---|
| index | 查找指定元素的下标 | arr.index(1) | 列表索引，0 | [1, 2, 3] |
| count | 统计传入元素的数量 | arr.count(2) | 统计数量，1 | [1, 2, 3] |
| insert | 在指定位置插入元素 | arr.insert(1, 666) | None | [1, 666, 2, 3] |
| append | 在列表尾部添加单个元素 | arr.append(666) | None | [1, 2, 3, 666] |
| extend | 在列表尾部添加多个元素 | arr.extend([666, 777]) | None | [1, 2, 3, 666, 777] |
| pop | 删除指定位置的元素 | arr.pop(0) | 删除的元素 | [2, 3] |
| remove | 从左向右搜索并删除第一个指定元素 | arr.remove(1) | None | [2, 3] |
| clear | 清空列表 | arr.clear() | None | [] |
11.1.4 列表的遍历
py
arr = [21, 25, 21, 23]
# while 循环遍历
i = 0
while i < len(arr):
print(arr[i])
i += 1
# 21
# 25
# 21
# 23
# for 循环遍历
for i in arr:
print(i)
# 结果与 while 循环一致
"""
区别：
while 更灵活
for 更简单
"""11.2 元组
11.2.1 元组的定义
py
# 元组可以理解为是只读的列表
# 字面量
(元素1, 元素2, 元素3, 元素4, ...)
# 定义变量
变量名称 = (元素1, 元素2, 元素3, 元素4, ...)
# 定义空元组
变量名称 = ()
变量名称 = tuple()11.2.2 元组的基本操作
py
# 定义单个元素的元组，后面一定要加一个逗号
t1 = (元素1, )
# 元组的嵌套
t2 = ((元素1_1, 元素1_2, 元素1_3), (元素2_1, 元素2_2, 元素2_3))
# 通过下标获取元素
print(t2[0][0]) # 元素1_1
# 获取元组的长度
print(len(t2)) # 2
# 修改元组中的值会报错
t2[0][0] = "改变的值" # 'tuple' object does not support item assignment
# 但是元组中嵌套列表是可以修改的
t = (1, 2, [1, 2])
t[2][0] = 2
t[2][1] = 411.2.3 元组的方法
py
# 注，元组统一使用 t
t = (1, 2, 3)| 方法名称 | 作用 | 示例 | 返回值 |
|---|---|---|---|
| index | 查找指定元素的下标 | t.index(1) | 列表索引，0 |
| count | 统计传入元素的数量 | t.count(2) | 统计数量，1 |
11.2.4 元组的遍历
py
t = (2, 4, 6)
# while 循环
i = 0
while i < len(t):
print(t[i])
i += 1
# for 循环
for i in t:
print(i)11.3 字符串
11.3.1 字符串的基本操作
py
# 字符串也可以像列表一样通过下标去获取，字符串也是一个只读属性
s = "hello word"
print(s[0]) # h
print(s[-1]) # d
# 返回字符串的长度
print(len(s)) # 1011.3.2 字符串的方法
py
# 注，字符串统一使用 s
s = "hello word"| 方法名称 | 作用 | 示例 | 返回值 |
|---|---|---|---|
| index | 查找指定元素的下标 | s.index("ll") | 列表索引，2 |
| replace | 将字符串进行替换 | s.replace("ll", "hh") | 新的字符串，"hehho word" |
| split | 将字符串按指定形式进行分割 | s.split(" ") | 列表，["hello", "word"] |
| strip | 将字符串首尾的字符按指定形式清除 | "12121266666212121".strip("12")， 传入的参数是单个识别的，是存在1、2 都清除，而不是12， 如果不传参数默认清除的是首尾的空格 | 新的字符串，"66666" |
| count | 统计字符串出现的次数 | s.count("l") | 次数，2 |
11.3.3 字符串的遍历
py
# 字符串的遍历和列表、元组的遍历是一样的，这里就不演示了11.4 序列的切片
11.4.1 序列的定义
- 内容连续、有序、可使用下标索引的一类数据容器
- 列表、元组、字符串都可以视为序列
11.4.2 序列的操作
- 语法：序列[起始下标:结束下标:步长]
- 起始下标
- 表示从何处开始（包含开始位置），可以为空，为空表示从头开始
- 结束下标
- 表示从何处结束（不含结束位置），可以为空，为空表示一直到最后
- 步长
- 步长不写默认为 1，为 1 表示一个个的取元素
- 为 2 表示，每次跳过 1 个元素取
- ...
- 为负数表示反相取，起始下标和结束下标也要反向标记
py
arr = [1, 2, 3, 4, 5, 6, 7]
print(arr[0:3]) # 包含 0，不包含 3，[1, 2, 3]
print(arr[::]) # 全部使用默认值，[1, 2, 3, 4, 5, 6, 7]
print(arr[::-1]) # 相当于倒序，[7, 6, 5, 4, 3, 2, 1]
print(arr[::2]) # 隔一个取，[1, 3, 5, 7]
print(arr[4:2:-1]) # 倒着截取，[5, 4]11.5 集合
11.5.1 集合的定义
py
# 定义集合
s1 = {元素1, 元素2, 元素3, 元素4, ...}
# 定义空集合
s2 = {}
s3 = set()
# 获取集合的长度
len(s1)11.5.2 集合的方法
py
# 注，集合统一使用 s1、s2
s1 = {1, 2, 3}
s2 = {4, 5, 6}| 方法名称 | 作用 | 示例 | 返回值 | 原集合 |
|---|---|---|---|---|
| index | 查找指定元素的下标 | arr.index(1) | 列表索引，0 | [1, 2, 3] |
| count | 统计传入元素的数量 | arr.count(2) | 统计数量，1 | [1, 2, 3] |
| insert | 在指定位置插入元素 | arr.insert(1, 666) | None | [1, 666, 2, 3] |
| append | 在列表尾部添加单个元素 | arr.append(666) | None | [1, 2, 3, 666] |
| extend | 在列表尾部添加多个元素 | arr.extend([666, 777]) | None | [1, 2, 3, 666, 777] |
| pop | 删除指定位置的元素 | arr.pop(0) | 删除的元素 | [2, 3] |
| remove | 从左向右搜索并删除第一个指定元素 | arr.remove(1) | None | [2, 3] |
| clear | 清空 | arr.clear() | None | [] |
更新中...