本文介绍了Python的基础知识，包括Python的定义、执行方式、Linux常用命令以及解释器类型。详细讲解了数据类型如整型、浮点型、字符串、布尔型，并介绍了运算符、变量、函数、逻辑控制结构（如if-elif-else）、循环（while和for）等核心概念。此外，还涵盖了字符串、列表、元组、字典和集合等容器类型的操作，以及函数的定义与调用、作用域等高级话题。
Python 简介
-
程序员：
程序设计人员。
- 程序：
一组计算机能识别和执行的指令，是实现某种需求的软件。
- 程序员：
程序设计人员。
程序：
一组计算机能识别和执行的指令，是实现某种需求的软件。
操作系统：
管理和控制计算机软件与硬件资源的程序；
隔离不同硬件的差异，使开发程序简单化。
- 操作系统：
管理和控制计算机软件与硬件资源的程序；
隔离不同硬件的差异，使开发程序简单化。
例如，Windows，Linux，Unix。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JefIYOgn-1573646222722)(/home/tarena/1909/笔记/图/day01/计算机基本结构.jpg)]
- 硬件：
主板–计算机的主要电路系统。
CPU --主要负责执行程序指令，处理数据。
硬盘–持久化存储数据的记忆设备，容量大，速度慢。
内存–临时存储数据的记忆设备，容量小，速度快。
IO设备–键盘、鼠标、显示器。
Python 定义
是一个免费、开源、跨平台、动态、面向对象的编程语言。
Python程序的执行方式
交互式
在命令行输入指令，回车即可得到结果。
-
打开终端
-
进入交互式：python3
-
编写代码：print(“hello world”)
-
离开交互式：exit()
文件式
将指令编写到.py文件，可以重复运行程序。
-
编写文件。
-
打开终端
-
进入程序所在目录：cd 目录
-
执行程序： python3 文件名
Linux常用命令
-
pwd：查看当前工作目录的路径
-
ls：查看指定目录的内容或文件信息
-
cd：改变工作目录（进入到某个目录）
练习：
- 在指定目录创建python文件.
–目录：/home/tarena/1908/month01
–文件名：exercise01.py
2. 在文件中写入：print(“你好，世界!”)
\3. 运行python程序
执行过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LCVhbSbX-1573646222724)(/home/tarena/.config/Typora/typora-user-images/1570753670995.png)]
计算机只能识别机器码(1010)，不能识别源代码(python)。
-
由源代码转变成机器码的过程分成两类：编译和解释。
-
编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言。
– 优点：运行速度快
– 缺点：开发效率低，不能跨平台。
3.解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行。例如Javascript
– 优点：开发效率高，可以跨平台；
– 缺点：运行速度慢。
4.python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）。
源代码 – 编译 --> 字节码 – 解释 --> 机器码
|————1次———|
解释器类型
-
CPython（C语言开发)
-
Jython (java开发)
-
IronPython (.net开发)
数据基本运算
代码：
"""
### 汇率转换器
"""
``#获取数据
usd = input("请输入美元：")
#逻辑计算
result = float(usd) * 7.1243
#显示结果
print("人民币是：" + str(result))
pycharm常用快捷键
-
移动到本行开头：home键
-
移动到本行末尾：end键盘
-
注释代码：ctrl + /
-
复制行：ctrl +d
-
选择列：鼠标左键 + alt
-
移动行：shift + alt + 上下箭头
-
智能提示：ctrl + space
-
代码格式化：ctrl+alt+l
注释
给人看的，通常是对代码的描述信息。
-
单行注释：以#号开头。
-
多行注释：三引号开头，三引号结尾。
函数
函数代码：
"""
函数
结果 = 函数名(输入的信息)
"""
# 1. print
# 字面意思:打印/输出/显示
# 参数:需要呈现的内容
# 备注:如果是文字需要放在双引号中
# 适用性:需要显示结果
print("需要呈现的内容")
# 2. input
# 字面意思:输入 从终端到程序
# 参数:需要提示的信息
# 结果:用户实际录入的内容
# 适用性:从终端获取数据
result = input("需要提示的信息")
表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。
例如：
-
print(数据) 作用：将括号中的内容显示在控制台中
-
变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量
变量
变量内存图：
变量交换思想：
-
定义：关联一个对象的标识符。
-
命名：必须是字母或下划线开头，后跟字母、数字、下划线。
不能使用关键字(蓝色)，否则发生语法错误：SyntaxError: invalid syntax。
3.建议命名：字母小写，多个单词以下划线隔开。程序员：
程序设计人员。
程序：
一组计算机能识别和执行的指令，是实现某种需求的软件。
操作系统：
管理和控制计算机软件与硬件资源的程序；
隔离不同硬件的差异，使开发程序简单化。
class_name
4.创建一个变量或改变一个变量关联的数据。
5.变量名 = 数据
变量名1 = 变量名2 = 数据
变量名1, 变量名2, = 数据1, 数据2
变量代码：
"""
变量
程序运行在哪? --- 内存
程序处理什么? --- 数据
变量:存储数据的
语法:
变量名称 = 数据
= 赋值号: 右边 给 左边
练习:exercise01.py
练习:exercise02.py
练习:exercise03.py
"""
创建变量age关联数据18
age = 18
修改变量age存储的数据地址
age = 100
访问变量存储的数据地址
print(age)
将变量age存储的数据地址 复制一份 给新变量number
number = age
删除变量age
del age
同时创建多个变量
count, id = 10, 901
同时为多个变量赋值
num01 = num02 = num03 = 888
del 语句
- 语法:
del 变量名1, 变量名2
2.作用：
用于删除变量,同时解除与对象的关联.如果可能则释放对象。
3.自动化内存管理的引用计数：
每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
核心数据类型
数据类型代码知识点：
"""
数据类型
变量没有类型
变量关联的对象有类型
"""
# 1. 空值类型
# --表示不存在的特殊对象。
number = None
# -- 占位和解除与对象的关联。
id = 101
id = None
# 2. 整形(整数)int
# 十进制(逢十进一)
# 0123456789 10 11 12 ... 2? 3? ... 99 100
number = 10
# 二进制(逢二进一)0 1 10
number = 0b10
print(number)# 以十进制显示2
# 八进制(逢八进一)0 1 2 3 4 5 6 7 10
number = 0o10
print(number)# 以十进制显示8
# 十六进制(逢十六进一)0 1 2 .. 9 a(10) f(15) 10
number = 0x10
print(number)# 以十进制显示16
# 3. 浮点型 float
number = 1.5
number = 0.00005
print(number)# 5e-05
# 4. 字符串str
name = "张无忌"
str01 = "1" + "2" # 字
print(str01)# 12
str01 = 1 + 2# 数 支持数学运算
print(str01)# 3
# 5. 复数 complex
# 实部 虚部 j
number = 1 + 1j
number = 1j
print(type(number))
-
在python中变量没有类型，但关联的对象有类型。
-
通过type函数可查看。
空值对象 None
-
表示不存在的特殊对象。
-
作用：占位和解除与对象的关联。
整形int
- 表示整数，包含正数、负数、0。
如： -5, 100, 0
2.字面值：
十进制：5
二进制：0b开头，后跟1或者1
八进制：0o开头，后跟0~7
十六进制：0x开头，后跟09,AF,a~f
浮点型float
-
表示小数，包含正数、负数，0.0)。
-
字面值：
小数：1.0 2.5
科学计数法：e/E (正负号) 指数
1.23e-2 (等同于0.0123)
1.23456e5(等同于123456.0)
字符串str
是用来记录文本信息(文字信息)。
字面值：双引号
复数complex
由实部和虚部组成的数字。
虚部是以j或J结尾。
字面值： 1j 1+1j 1-1j
布尔bool
运算符代码：
"""
bool
比较运算符 > < == != >= <=
逻辑运算符
练习:exercise09.py
"""
# 1. 命题:带有判断性质的陈述句.
# 你是个美女.
# 如果成立 True 不成立 False
# 2. 比较运算符
# 比较数值大小 , 结果是bool类型.
number01 = 8
number02 = "8"
print(number01 == number02) # 8 == "8" --> Flase
# 3. 逻辑运算符
# 判断2个bool值关系的
# 与 and 一假俱假 表达"并且"关系(所有条件必须都满足)
print(True and True) # True
print(False and True) # False
print(True and False) # False
print(False and False) # False
# 或 or 一真俱真 表达"或者"关系(有一个就行)
print(True or True) # True
print(False or True) # True
print(True or False) # True
print(False or False) # False
# 非 取反
print(not True) # False
用来表示真和假的类型
True 表示真(条件满足或成立)，本质是1
False 表示假(条件不满足或不成立)，本质是0
数据类型转换
数据类型转换代码知识点：
"""
数据类型转换
input 结果是字符串
"""
usd = "8.5+"
# str --> float
# 注意:字符串必须长得"像"需要转换的类型
usd = float(usd)
# float --> str
print("结果是:"+str(usd))
-
转换为整形: int(数据)
-
转换为浮点型:float(数据)
-
转换为字符串:str(数据)
-
转换为布尔:bool(数据)
结果为False：bool(0) bool(0.0) bool(None)
5.混合类型自动升级：
1 + 2.14 返回的结果是 3.14
1 + 3.0 返回结果是: 4.0
运算符
除法图：
算术运算符
运算符代码：
"""
运算符
算数运算符+ - * 数学的除法/ 地板除// 取余数% 幂运算**
增强运算符+= -= *= /= //= %= **=
练习:exercise04.py
练习:exercise05.py
练习:exercise06.py
练习:exercise07.py
练习:exercise08.py
"""
# 1. 算数运算符
number01 = 5
number02 = 2
print(number01 + number02)
# 5 的 2次方
print(number01 ** number02)
# 2. 增强运算符
number03 = 10
print(number03 + 5)
# 没有改变number03
print(number03) # 10
# number03运算后又赋值给了自身
number03 += 5 # number03 = number03 + 5
+ 加法
- 减法
× 乘法
/ 除法：结果为浮点数 
// 地板除：除的结果去掉小数部分 
% 求余
** 幂运算
优先级从高到低： ()
**
* / % //
+ -
增强运算符
y += x 等同于 y = y + x
y -= x 等同于 y = y - x
y *= x 等同于 y = y * x
y /= x 等同于 y = y / x
y //= x 等同于 y = y // x
y %= x 等同于 y = y % x
y **= x 等同于 y = y * * x
比较运算符
< 小于
<= 小于等于
> 大于
>= 大于等于
== 等于
!= 不等于
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
逻辑运算符
逻辑运算符图：
与and
表示并且的关系，一假俱假。
示例:
True and True # True
True and False # False
False and True # False
False and False # False
或or
表示或者的关系，一真俱真
示例:
True or True # True
True or False # True
False or True # True
False or False # False
非 not
表示取反
例如：
not True # 返回False
not False # 返回True
短路运算
一但结果确定，后面的语句将不再执行。
# (面试题)
# 短路逻辑:
# 现象:后面的条件不会影响结果时,不再执行.
# 价值:耗时(复杂)的条件应该尽量放在前还是后
# 代码: 条件1 and 条件2 or 条件3 .....
# false and ?
# 如果and前面是false,后面的条件不会影响结果,所以不执行.
# re = 1 > 2 and print("你看见我了吗?")
# true or ?
# 如果or前面是true,后面的条件不会影响结果,所以不执行.
re = 1 < 2 or print("你看见我了吗?")
身份运算符
语法:
x is y
x is not y
作用：
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
is not 的作用与is相反
优先级
高到低：
算数运算符
比较运算符
快捷运算符
身份运算符
逻辑运算符
语句
行
-
物理行：程序员编写代码的行。
-
逻辑行：python解释器需要执行的指令。
-
建议一个逻辑行在一个物理行上。
-
如果一个物理行中使用多个逻辑行，需要使用分号；隔开。
-
如果逻辑行过长，可以使用隐式换行或显式换行。
隐式换行：所有括号的内容换行,称为隐式换行
括号包括: () [] {} 三种
显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。
代码：
"""
行
"""
# (建议) 3个物理行 对应3个逻辑行
a = 10
b = 20
c = a + b
# (不建议)1个物理行 对应3个逻辑行
a = 10;b = 20;c = a + b
# (代码过长)3个物理行 对应1个逻辑行
a = 1 + 2 + \
3 + 4 + 5 \
+ 6 + 6
a = 1 + (2 +
3 + 4 + 5
+ 6) + 6
pass 语句
通常用来填充语法空白。
选择语句
If elif else 语句
- 作用:
让程序根据条件选择性的执行语句。
2.语法:
"""
选择语句
练习:exercise01.py ~ exercise06.py
"""
sex = input("请输入性别:")
# 如果 变量sex 存储的数据等于"男"
if sex == "男":
# 缩进:4个空格,不是Tab键盘(但是开发都用Tab键)
print("您好,先生!")
elif sex == "女": # 否则 互斥
print("您好,女士!")
else:
print("性别未知")
# 调试:让程序中断,逐语句执行.
# 目的:审查程序执行过程 --- F7
# 查看变量取值 --- Debugger 面板
# 解决:程序中的错误
# 步骤:
# 1. (在可能出错的代码)加断点
# 2. 调试运行Debug
# 3. F7 逐语句执行
# 4. 停止调试Ctrl + F2
if 条件1:
语句块1
elif 条件2:
语句块2
else:
语句块3
- 说明:
elif 子句可以有0个或多个。
else 子句可以有0个或1个，且只能放在if语句的最后。
if 语句的真值表达式
代码：
"""
if 真值表达式
if 变量:
如果变量指向的数据有值,则满足条件.
if 变量 != 0:
if 变量 != 0.0:
if 变量 != "":
if 条件表达式
变量 = 满足条件的值 if 条件 else 不满足条件的值
练习:exercise07.py
"""
print(bool(1))
print(bool(62626))
print(bool(-34324))
print(bool(0)) # false
print(bool("a"))
print(bool("你好"))
print(bool(" "))
print(bool("")) # false
print(bool(0.1))
print(bool(0.0)) # false
# 1. if 真值表达式
str_input = input("请输入:")
# 如果字符串有数据则处理
# if str_input != "":
if str_input:
print("处理")
# 2. if 条件表达式
sex = input("请输入:")
# 根据条件,给变量赋值
# if sex == "男":
# value = 1
# else:
# value = -1
value = 1 if sex == "男" else -1
print(value)
if 100:
print(“真值”)
等同于
if bool(100):
print(“真值”)
条件表达式
语法：变量 = 结果1 if 条件 else 结果2
作用：根据条件(True/False) 来决定返回结果1还是结果2。
循环语句
while: 根据条件重复执行
for:遍历可迭代对象中的元素
预订次数
while语句
代码：
"""
while 循环 计数
15:50
"""
count = 0 # 从哪里开始
while count < 5: # 5 < 5 到哪里结束
print(count) # 0 1 2 3 4
count += 1 # 跨度
- 作用:
可以让一段代码满足条件，重复执行。
2.语法:
while 条件:
满足条件执行的语句
else:
不满足条件执行的语句
random_number = random.randint(1,100)
count = 0
while count < 3:
count += 1
input_number = int(input("请输入:"))
if input_number > random_number:
print("大了")
elif input_number < random_number:
print("小了")
else:
print("猜对了,总共猜了"+str(count)+"次.")
break
else:# 如果循环条件不满足,才执行else语句
print("你失败了")
3.说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
for 语句
"""
for for
"""
# 外层循环控制行
for r in range(3):# 0 1 2
# 内层循环控制列
for c in range(4):#0123 0123 0123
print("$",end = " ")
print()
- 作用:
用来遍历可迭代对象的数据元素。
可迭代对象是指能依次获取数据元素的对象，例如：容器类型。
2.语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
3.说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
range 函数
# range 整数生成器
# range(结束)
# range(开始,结束)
# range(开始,结束,间隔)
# 不包含结束值
for item in range(5,10,2):# 0 1 2
print(item)
１．作用:
用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。
- 语法:
range(开始点，结束点，间隔)
3.说明:
函数返回的可迭代对象可以用for取出其中的元素
返回的数字不包含结束点
开始点默认为0
间隔默认值为1
跳转语句
break 语句
-
跳出循环体，后面的代码不再执行。
-
可以让while语句的else部分不执行。
continue 语句
# 需求:累加1--100之间能被5整除的数字
# 1 + 2+ 3+ ... 100
# sum_value = 0
# for item in range(1, 101):
# # 满足条件则累加
# if item % 5 == 0:
# sum_value += item
# print(sum_value)
sum_value = 0
for item in range(1, 101):
# 不满足条件则跳过
if item % 5 != 0:
continue
sum_value += item
print(sum_value)
跳过本次，继续下次循环。
容器类型
通用操作
"""
字符串常用操作
练习:exercise09.py
"""
# 1. 数学运算
# -- 拼接
name = "悟空"
name += "大圣"
print(name) # 悟空大圣
# -- 重复
name = "八戒"
name *= 3
print(name)
# 比较
str01 = "axy"
str02 = "acd"
# 依次比较两个容器中元素,一但不同则返回比较结果。
print(str01 > str02)
# 成员运算
str03 = "我在花果山."
print("在花" in str03)
# 索引 -- 单个
print(str03[1]) # 在
print(str03[-1]) # .
print(str03[2]) # 花
print(str03[-4]) # 花
# 特别注意:索引不能越界
# print(str03[10])# IndexError: string index out of range
# print(str03[-8])# IndexError: string index out of range
# 切片 -- 多个
print(str03[2:5:1]) # 花果山
# 开始索引/结束索引可以不写
print(str03[:2]) # 我在
print(str03[-2:]) # 山.
print(str03[:]) # 我在花果山.
print(str03[::-1]) # .山果花在我
print(str03[-4::-1]) # 花在我
print(str03[::2]) # 我花山
print(str03[1:-1]) # 在花果山
print(str03[-2:2]) # 空
print(str03[1:1]) # 空
print(len(str03)) # 总数
数学运算符
-
+：用于拼接两个容器
-
+=：用原容器与右侧容器拼接,并重新绑定变量
-
*：重复生成容器元素
-
*=：用原容器生成重复元素, 并重新绑定变量
-
< <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。
成员运算符
-
语法：
数据 in 序列
数据 not in 序列
2 .作用：
如果在指定的序列中找到值，返回bool类型。
索引index
-
作用：定位单个容器元素
-
语法：容器[整数]
-
说明：
正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。
切片slice
- 作用：
定位多个容器元素。
2. 语法：
容器[(开始索引):(结束索引)(:(步长))]
3. 说明：
小括号()括起的部分代表可省略
结束索引不包含该位置元素
步长是切片每次获取完当前元素后移动的偏移量
内建函数
-
len(x) 返回序列的长度
-
max(x) 返回序列的最大值元素
-
min(x) 返回序列的最小值元素
-
sum(x) 返回序列中所有元素的和(元素必须是数值类型)
字符串 str
"""
str
"""
# 1. 不可变
# 如果改变,很可能破坏其他对象的内存空间.
name = "悟空"
name = "孙悟空"
name = name + "大圣"
# 创建新字符串对象,替换变量存储的地址.
print(name) # 孙悟空
定义
由一系列字符组成的不可变序列容器，存储的是字符的编码值。
编码
# 编码
# 字 --> 数
print(ord("a"))
# 数 --> 字py
print(chr(100))
-
字节byte：计算机最小存储单位，等于8 位bit.
-
字符：单个的数字，文字与符号。
-
字符集(码表)：存储字符与二进制序列的对应关系。
-
编码：将字符转换为对应的二进制序列的过程。
-
解码：将二进制序列转换为对应的字符的过程。
-
编码方式：
–ASCII编码：包含英文、数字等字符，每个字符1个字节。
–GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
–Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
–UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。
相关函数
-
ord(字符串):返回该字符串的Unicode码。
-
chr(整数):返回该整数对应的字符串。
字面值
"""
字符串字面值
练习:exercise08.py
"""
# 单引号
str01 = 'a'
# 双引号
str01 = "a"
# 三引号 -- 可见即所得
str01 = """
a
lasdnflasdf
afasdf
adf
"""
str01 = '''a'''
# 1. 单引号内的双引号不算结束符
# 2. 双引号内的单引号不算结束符
str02 = '我叫"qtx".'
str02 = "我叫'qtx'."
str02 = '''我叫'q't"x".'''
# 转义符: 改变原始字符串含义的特殊字符
# \" \' \t 水平制表格 \n 换行 \\ r"原始字符串"
str03 = "我叫\"qtx\"."
str04 = "我\t叫苏大强."
str04 = "我\n叫苏大强."
url = "C:\\arogram Files\\bommon Files\cervices"
url = r"C:\arogram Files\bommon Files\cervices"
print(url)
# 在字符串中插入变量
name = "悟空"
age = 28
score = 95.59
# 字符串拼接
print("我叫" + name + ",年龄是" + str(age) + ",成绩是" + str(score) + ".")
# 占位符/格式化字符串
print("我叫%s,年龄是%d,成绩是%.1f." % (name, age, score))
单引和双引号的区别
-
单引号内的双引号不算结束符
-
双引号内的单引号不算结束符
三引号作用
-
换行会自动转换为换行符\n
-
三引号内可以包含单引号和双引号
-
作为文档字符串
转义字符
- 改变字符的原始含义。
\’ \” \””” \n \ \t \0 空字符
-
原始字符串：取消转义。
a = r”C:\newfile\test.py”
字符串格式化
- 定义：
生成一定格式的字符串。
- 语法：
字符串%(变量)
“我的名字是%s,年龄是%s” % (name, age)
- 类型码：
%s 字符串 %d整数 %f 浮点数
列表 list
"""
列表内存图
15:25
"""
# list01 列表类型的引用(地址)
list01 = ["张无忌", "张翠山"]
# 将列表引用赋值给变量list02
list02 = list01
# 修改的是列表第一个元素
list01[0] = "无忌哥哥"
print(list02[0]) # "无忌哥哥"
list01 = ["张无忌", "张翠山"]
# 通过切片获取数据时,会创建新容器.
list02 = list01[:]
list01[0] = "无忌哥哥"
print(list02[0]) # 张无忌
list01 = ["张无忌", "张翠山"]
list02 = list01
# 遍历列表["张三丰","赵敏"]中元素,赋值给list01指向的列表中(第二个位置)
list01[1:] = ["张三丰", "赵敏"]
print(list02) # ['张无忌', '张三丰', '赵敏']
list01 = ["张无忌", "张翠山"]
list02 = list01
# 修改的是变量list01存储的地址
list01 = "张三丰"
print(list02)
# 将列表作为列表的元素
list01 = [["张无忌", "赵敏"], "张翠山"]
list02 = list01
# 修改列表第一个元素的第一个元素
list01[1][0] = "周芷若"
print(list02)
"""
is 身份运算符
"""
list01 = [100, 200]
list02 = [100, 200]
# 判断内容
print(list01 == list02) # True
# id(list01) == id(list02)
print(list01 is list02) # False
list01 = [100, [200, 300]]
list02 = [100, [200, 300]]
print(list01 == list02) # True
定义
由一系列变量组成的可变序列容器。
基础操作
"""
列表基础操作 list
练习:exercise01.py
"""
# 1. 创建
list01 = []
list01 = [3,"a",45,False,676]
lis02 = list()
# list(可迭代对象)
# str 不可变 --> list 可变
list02 = list("abcde")
# 整数生成器 --> list
list02 = list(range(5))#
# 2. 增加
# -- 追加
list02.append("A")
# -- 插入(位置,元素)
list02.insert(1,"孙悟空")
# 3. 获取
# -- 索引
# 最后一个
print(list02[-1])
# print(list02[500])# 小心越界
# -- 切片
print(list02)
# 后三个
print(list02[-3:])
# 前三个
print(list02[:3])
# -- 循环
# 正向
# for item in list02:
# print(item)
# 反向
# for i in range(len(list02)-1,-1,-1):
# print(list02[i])
# 4. 修改
# [0, '孙悟空', 1, 2, 3, 4, 'A']
# -- 索引
list02[1] = "齐天大圣"
list02[-1] = "a"
# -- 切片
# 原理: 遍历右侧的可迭代对象,将每个元素依次赋值给左边定位的元素
# 温馨提示:右侧必须是可迭代对象
list02[:3] = "abc"
list02[:0] = "asdfhs"
#" 1asdfhs"
print(list02)
# -- 循环
# for i in range(len(list02)):
# list02[i] = 0
# 5. 删除
# -- 根据元素删除
list02.remove("a")
# 删除最后一个元素
# del list02[-1]
print(list02)
del list02[::2]
print(list02)
- 创建列表：
列表名 = []
列表名 = list(可迭代对象)
- 添加元素：
列表名.append(元素)
列表.insert(索引，元素)
- 定位元素：
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
- 删除元素：
列表名.remove(元素)
del 列表名[索引或切片]
深拷贝和浅拷贝
浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。
"""
浅拷贝:复制一层
深拷贝:复制整个依赖的变量
好处:深拷贝后的数据与之前的数据互补影响.
缺点:占用内存过大
"""
list01 = [500, [600, 700]]
# list02 = list01[:]
list02 = list01.copy() # 浅拷贝
list01[1][0] = "六百"
print(list02)
# 创建一个深拷贝的工具
import copy
list01 = [500, [600, 700]]
# 深拷贝
list02 = copy.deepcopy(list01)
list01[1][0] = "六百"
print(list02)
列表VS字符串
-
列表和字符串都是序列,元素之间有先后顺序关系。
-
字符串是不可变的序列,列表是可变的序列。
-
字符串中每个元素只能存储字符,而列表可以存储任意类型。
-
列表和字符串都是可迭代对象。
-
函数：
将多个字符串拼接为一个。
result = “连接符”.join(列表)
将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)
"""
list --> str
练习:exercise01.py
"""
list01 = ["a", "b", "c"]
# 结果 = 连接符.joint(列表)
result = "+".join(list01)
print(result)
# 需求:根据某些逻辑,拼接字符串.
# 0 1 2 3 4 5...9
"""
str_result = ""
for item in range(10):
# "0" + "1" --> "01"
# 每次循环,都会产生一个垃圾
# (变量str_result不断指向新对象)
str_result += str(item)
print(str_result)
"""
# 重点:让可变对象,负责拼接元素.
list_temp = []
for item in range(10):
list_temp.append(str(item))
str_result = "".join(list_temp)
print(str_result)
列表推导式
"""
列表推导式嵌套
17:00
"""
list01 = ["香蕉", "苹果", "哈密瓜"]
list02 = ["雪碧", "可乐", "咖啡", "牛奶"]
# 全排列
# list_result = []
# for r in list01:
# for c in list02:
# list_result.append(r + c)
list_result = [r + c for r in list01 for c in list02]
print(list_result)
- 定义：
使用简易方法，将可迭代对象转换为列表。
- 语法：
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]
- 说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
"""
str --> list
"""
# 一个字符串表达多个信息
str_names = "张无忌_翠山_张三丰"
list_result = str_names.split("_")
print(list_result)
"""
列表推导式
练习:exercise03.py
10:18
"""
list01 = [4,5,6,7,9,8]
# list02 = []
# for item in list01:
# if item % 2:
# list02.append(item)
list02 = [item for item in list01 if item % 2]
# list02 = []
# for item in list01:
# list02.append(item ** 2)
list02 = [item ** 2 for item in list01]
列表推导式嵌套
- 语法：
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
- 传统写法：
result = []
for r in ["a", "b", "c"]:
for c in ["A", "B", "C"]:
result.append(r + c)
- 推导式写法：
result = [r + c for r in list01 for c in list02]
元组 tuple
定义
-
由一系列变量组成的不可变序列容器。
-
不可变是指一但创建，不可以再添加/删除/修改元素。
基础操作
- 创建空元组：
元组名 = ()
元组名 = tuple()
- 创建非空元组：
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)
- 获取元素：
变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表
-
遍历元组：
正向：
for 变量名 in 列表名:
变量名就是元素 反向：for 索引名 in range(len(列表名)-1,-1,-1):
元组名[索引名]就是元素
"""
元组 tuple
按需分配
练习:exercise04.py
练习:exercise05.py
"""
# 1. 创建
# -- (元素)
tuple01 = (34, "45", True)
# 创建空元组
tuple01 = ()
# 创建具有一个元素的元组(必须在元素后增加逗号)
tuple01 = ("a",)
print(tuple01)
# -- tuple(可迭代对象)
tuple02 = tuple(range(10, 20))
print(tuple02)
# 2. 获取
# -- 索引
print(tuple02[0])
print(tuple02[-1])
# print(tuple02[20]) # 索引不能越界
# -- 切片
print(tuple02[:5]) # 切片会创建新元组
print(tuple02[:25]) # 越界不会报错
# -- 循环
# 获取每一个元素
# for item in tuple02:
# print(item)# 元素
# 倒序获取每一个元素
for i in range(len(tuple02) - 1, -1, -1):
# print(i)# 索引
print(tuple02[i])
# 通用操作
tuple03 = ("a", "b")
tuple03 += ("c",)
print(tuple03) # 累加后的元素是新元组('a', 'b', 'c')
v01,v02,v03 = ("a","b","c")
print(v01)
print(v02)
print(v03)
作用
-
元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
-
元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
-
应用：
变量交换的本质就是创建元组：x, y = （y, x ）
格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)
字典 dict
定义
-
由一系列键值对组成的可变散列容器。
-
散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
-
键必须惟一且不可变(字符串/数字/元组)，值没有限制。
基础操作
- 创建字典：
字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象)
- 添加/修改元素：
语法:
字典名[键] = 数据
说明:
键不存在，创建记录。
键存在，修改值。
- 获取元素：
变量 = 字典名[键] # 没有键则错误
-
遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
- 删除元素：
del 字典名[键]
"""
字典
练习:exercise06.py
练习:exercise07.py
练习:exercise08.py
"""
# 1. 创建
dict01 = {}
dict01 = {"101": "qtx", "102": "lzmly", "103": "wk"}
dict02 = dict([("a", "b"), ("c", "d")])
# ('101', '102', '103')
tuple01 = tuple(dict01)
# 2. 添加元素
# 如果添加的键已经存在,则修改值.
dict01["104"] = "zwj"
# 判断字典中是否存在某个键
print("104" in dict01)
# 3. 修改元素
dict01["104"] = "zsf"
# 4. 获取元素
# -- 通过键key 获取值value
print(dict01["104"])
if "105" in dict01:
print(dict01["105"])
# -- 循环
# 遍历字典,获取key.
for key in dict01:
print(key)
# print(dict01[key])
# 遍历字典,获取value.
for value in dict01.values():
print(value)
# 遍历字典,获取key同时获取value.
for k, v in dict01.items():
print(k) # key
print(v) # value
# 5. 删除元素
del dict01["101"]
# 根据条件,删除字典中的记录.
# 不能遍历字典同时删除字典
# 解决:遍历元组(所有的键)删除字典
tuple_key = tuple(dict01)
for item in tuple_key:
# if item dict01[item]
del dict01[item]
# 删除全部元素
dict01.clear()
print(dict01)
字典推导式
- 定义：
使用简易方法，将可迭代对象转换为字典。
- 语法:
{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}
"""
字典推导式
练习:exercise01.py
练习:exercise02.py
11:05
"""
# key : 0 1 2 3 .. 9 --> value: 键的平方
# dict01 = {}
# for item in range(10):
# dict01[item] = item ** 2
dict01 = {item: item ** 2 for item in range(10)}
# dict01 = {}
# for item in range(10):
# if item % 2 !=0:
# dict01[item] = item ** 2
dict01 = {item: item ** 2 for item in range(10) if item % 2 != 0}
字典 VS 列表
"""
字典:
优点:根据key定位value速度最快
# 为值提供了键,代码可读性略高."name":张三 "score":100
缺点:占用内存/无序(不能使用索引和切片)
列表:
优点:有序(能使用索引和切片)
# 相对节省内存
缺点:查找速度相对慢一些
# 通过索引获取数据,如果信息过多,代码可读略差
适用性:如果侧重于读写速度,使用字典
方式,使用列表
例如:
字典内嵌列表
{
"悟空":[24,100,"男"],
"八戒":[26,0,"男"],
}
字典内嵌字典
{
"悟空":{age":24,"score":100,"sex":"男"},
"八戒":{"age":28,"score":0,"sex":"男"},
}
列表内嵌字典
[
{"name":"悟空",age":24,"score":100,"sex":"男"},
{"name":"八戒","age":28,"score":0,"sex":"男"},
]
"""
-
都是可变容器。
-
获取元素方式不同,列表用索引,字典用键。
-
字典的插入,删除,修改的速度快于列表。
-
列表的存储是有序的,字典的存储是无序的。
集合 set
定义
-
由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
-
相当于只有键没有值的字典(键则是集合的数据)。
基础操作
"""
集合
特点:去重复/数学运算
练习:exercise04.py
"""
# 1. 创建
set01 = {34, 4, 5, 456, 7, 456}
# 空集合
# set01 = {}# 这是字典
set02 = set()
# 需求:对列表去重(顺序会捣乱)
list01 = [3, 2, 2, 2, 22, 2, 2, 5]
set02 = set(list01)
list01 = list(set02)
# 2. 添加
set02.add("a")
set02.add("b")
# 3. 获取
# -- 不能定位元素
# -- 循环获取全部
for item in set02:
print(item)
# 4. 删除
set02.remove("a")
print(set02)
# 5. 数学运算
s01 = {1,2,3}
s02 = {2,3,4}
# 交集 & 2 3
print(s01 & s02)
# 并集 {1, 2, 3, 4}
print(s01 | s02)
# 补集
# 对称补集
print(s01 ^ s02)# {1, 4}
#
print(s01 - s02)# {1}
print(s02 - s01)# {4}
# 子集 超集
s03 = {2,3}
print(s03 < s01)
- 创建空集合：
集合名 = set()
集合名 = set(可迭代对象)
- 创建具有默认值集合：
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
- 添加元素：
集合名.add(元素)
- 删除元素：
集合名.discard(元素)
运算
- 交集&：返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
- 并集：返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
- 补集-：返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
补集^：返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
-
子集<：判断一个集合的所有元素是否完全在另一个集合中
-
超集>：判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True
-
相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 != s2 # False
子集或相同,超集或相同 <= >=
集合推导式
- 定义：
使用简易方法，将可迭代对象转换为集合。
- 语法:
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}
固定集合 frozenset
定义
不可变的集合。
作用
固定集合可以作为字典的键,还可以作为集合的值。
基础操作
创建固定集合：frozenset(可迭代对象)
运算
等同于set
函数 function
"""
函数
定义函数
参数
"""
# 代码的重复，是万恶之源．
"""
print("直拳")
print("临门一脚")
print("摆拳")
# ....
print("直拳")
print("临门一脚")
print("摆拳")
# ....
print("直拳")
print("临门一脚")
print("摆拳")
"""
def attack():
"""
单次攻击
"""
print("直拳")
print("勾拳")
print("临门一脚")
print("摆拳")
# 形参： count 数量
def attack_repeat(count):
"""
重复攻击
:param count:ｉｎｔ类型,数量
"""
for i in range(count):
print("直拳")
print("勾拳")
print("临门一脚")
print("摆拳")
attack()
# 实参：真实
attack_repeat(2)
pycharm相关设置
- “代码自动完成”时间延时设置
File -> Settings -> Editor -> General -> Code Completion -> Autopopup in (ms):0
- 快捷键：
Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档
Ctrl + Alt + M 提取方法
定义
-
用于封装一个特定的功能，表示一个功能或者行为。
-
函数是可以重复执行的语句块, 可以重复调用。
作用
提高代码的可重用性和可维护性（代码层次结构更清晰）。
定义函数
- 语法：
def 函数名(形式参数):
函数体
- 说明：
def 关键字：全称是define，意为”定义”。
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：方法定义者要求调用者提供的信息。
函数体：完成该功能的语句。
- 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
调用函数
-
语法：函数名(实际参数)
-
说明：根据形参传递内容。
"""
参数:调用者 给 定义者 的信息
返回值: 定义者 给 调用者 的结果
"""
# 需求:定义函数,两个数值相加.
# 要小而精,不要大而全
"""
def add():
# 获取数据
number_one = float(input("请输入第一个数:"))
number_two = float(input("请输入第二个数:"))
# 逻辑计算
result = number_one + number_two
# 显示结果
print("结果是:" + str(result))
add()
"""
def add(number_one, number_two):
# 逻辑计算
result = number_one + number_two
return result # 返回 数据
number_one = float(input("请输入第一个数:"))
number_two = float(input("请输入第二个数:"))
# 变量 = 调用函数(...)
re = add(number_one, number_two)
print("结果是:" + str(re))
返回值
"""
函数内存分配
15:35
"""
def fun01():
a = 100
# 调用函数,开辟内存空间(栈帧:存储在函数中定义的变量)
fun01()
# 函数执行过后,栈帧清空.
def fun02(p1):
# 修改p1变量存储的对象地址
p1 = 100
data01 = "悟空"
# 传递的值变量data01存储的"悟空"地址
fun02(data01)
print(data01) # ?
- 定义：
方法定义者告诉调用者的结果。
- 语法：
return 数据
"""
返回值语法
10:30
"""
def fun01():
print("fun01执行喽")
# 1. 返回 数据100, 2. 退出函数
return 100
print("fun01又执行喽")
# 即使有返回值,调用者也可以不定义变量接受.
fun01()
def fun02():
print("fun02执行喽")
# 定义函数时,没有return相当于return None
# return None
# return 后面没有数据,相当于return None
return
re = fun02()
print(re)
- 说明：
return后没有语句，相当于返回 None。
函数体没有return，相当于返回None。
可变／不可变类型在传参时的区别
- 不可变类型参数有:
数值型(整数，浮点数,复数)
布尔值bool
None 空值
字符串str
元组tuple
固定集合frozenset
- 可变类型参数有:
列表 list
字典 dict
集合 set
- 传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。
函数参数
"""
函数参数
实际参数
位置实参 函数名(数据1,数据2,数据3)
序列实参 函数名(*序列)
关键字实参 函数名(形参名2 =数据2,形参名1 =数据1)
字典实参 函数名(**字典)
形式参数
默认参数
位置形参
星号元组形参 函数名(*args)
命名关键字形参
字典形参 函数名(**kwargs)
练习:exercise01.py
练习:exercise02.py
11:25
"""
# 1. 默认参数: 实参可以不提供数据(从右到左的存在)
def fun01(p1=0.0, p2="", p3=0):
print(p1)
print(p2)
print(p3)
# 位置实参 + 默认形参
fun01(1)
# 关键字实参(按名字)+ 默认形参(可以传) --> 按名字随意传
fun01(p2="p2的参数")
# 2. 位置形参:实参必须提供
def fun02(p1, p2, p3):
print(p1)
print(p2)
print(p3)
实参传递方式argument
位置传参
定义：实参与形参的位置依次对应。
序列传参
定义：实参用*将序列拆解后与形参的位置依次对应。
关键字传参
定义：实参根据形参的名字进行对应。
字典关键字传参
-
定义：实参用**将字典拆解后与形参的名字进行对应。
-
作用：配合形参的缺省参数，可以使调用者随意传参。
形参定义方式parameter
缺省参数
- 语法：
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
函数体
- 说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。
缺省参数可以有0个或多个，甚至全部都有缺省参数。
位置形参
语法：
def 函数名(形参名1, 形参名2, …):
函数体
星号元组形参
- 语法：
def 函数名(*元组形参名):
函数体
- 作用：
收集多余的位置传参。
- 说明：
一般命名为’args’
形参列表中最多只能有一个
命名关键字形参
- 语法：
def 函数名(*, 命名关键字形参1, 命名关键字形参2, …):
函数体
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, …):
函数体
- 作用：
强制实参使用关键字传参
双星号字典形参
- 语法：
def 函数名(**字典形参名):
函数体
- 作用：
收集多余的关键字传参
- 说明:
一般命名为’kwargs’
形参列表中最多只能有一个
参数自左至右的顺序
位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
作用域LEGB
-
作用域：变量起作用的范围。
-
Local局部作用域：函数内部。
-
Enclosing 外部嵌套作用域 ：函数嵌套。
-
Global全局作用域：模块(.py文件)内部。
-
Builtin内置模块作用域：builtins.py文件。
变量名的查找规则
-
由内到外：L -> E -> G -> B
-
在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。
局部变量
-
定义在函数内部的变量(形参也是局部变量)
-
只能在函数内部使用
-
调用函数时才被创建，函数结束后自动销毁
全局变量
-
定义在函数外部,模块内部的变量。
-
在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
global 语句
- 作用：
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。
- 语法：
global 变量1, 变量2, …
- 说明
在函数内直接为全局变量赋值，视为创建新的局部变量。
不能先声明局部的变量，再用global声明为全局变量。
nonlocal 语句
- 作用：
在内层函数修改外层嵌套函数内的变量
- 语法
nonlocal 变量名1,变量名2, …
- 说明
在被嵌套的内函数中进行使用
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
