文章目录
- 变量
- 变量的定义
- 变量的命名
- 变量的赋值
- 变量的引用
- 变量的输入
- 1. 关于函数
- 2. input 函数实现键盘输入
- 3. 类型转换函数
- 4. 变量输入演练 —— 超市买苹果增强版
- 演练方式 1
- 演练方式 2 —— 买苹果改进版
- 变量的输出
- 格式化输出演练 —— 基本练习
- 课后练习 —— 个人名片
- 变量的切片
- 切片的作用
- 变量的运算
- 不同类型变量之间的计算
- 1. **数字型变量** 之间可以直接计算
- 2. **字符串变量** 之间使用 `+` 拼接字符串
- 3. **字符串变量** 可以和 **整数** 使用 `*` 重复拼接相同的字符串
- 4. **数字型变量** 和 **字符串** 之间 **不能进行其他计算**
- 运算符
- 算数运算符
- 应用
- 比较运算符
- 逻辑运算符
- 示例
- 赋值运算符
- 运算符优先级
- 变量的类型
- 数字型
- 变量的非数字型/高级数据类型
- 字符串
- 字符串的定义
- 字符串的输入
- 字符串的输出
- 字符串的下标
- 字符串的切片
- 索引的顺序和倒序
- **字符串的转义字符**
- 字符串的常用操作
- 1. 判断类型 - 9
- 2. 查找和替换 - 7
- 3. 大小写转换 - 5
- 4. 文本对齐 - 3
- 5. 去除空白字符 - 3
- 6. 拆分和连接 - 5
- 7. 修改
- **列表**[](使用最频繁的数据类型)
- 一、是什么
- 列表的切片
- 索引的顺序和倒序
- 列表的同步性
- 二、怎么用
- 2.1.建
- 2.2.增
- 2.3.删
- 2.4.查
- 2.5.改
- 2.6.排序
- 2.7. 复制
- 2.8.求列表长度
- 2.9.计数
- 2.10.循环遍历
- 2.11.列表推导式[for]
- 2.12.嵌套
- 三、题目
- 题目1 [加强训练]
- 题干
- 训练目标
- 训练提示
- 参考方案
- 操作步骤
- 参考答案
- 题目2 [加强训练]
- 题干
- 训练目标
- 训练提示
- 参考方案
- 操作步骤
- 参考答案
- 题目3 [加强训练]
- 题干
- 训练目标
- 训练提示
- 参考方案
- 操作步骤
- 参考答案
- 元组()
- 是什么
- 元组常用操作
- 增
- 删
- 查
- 改
- 循环遍历
- 应用场景
- 元组和列表之间的转换
- 字典
- 字典的定义
- 字典常用操作
- 增
- 删
- 查
- 改
- 循环遍历
- 遍历之key
- 遍历之value
- 遍历之键值对
- 遍历之键值对(拆包)
- **应用场景**
- 05. 公共方法
- 5.1 Python 内置函数
- 5.2 切片
- 5.3 运算符
- 成员运算符
- 5.4 完整的 for 循环语法
- 应用场景
变量
前言:
- 是什么:
(1)定义:程序就是用来处理数据的,而变量就是用来存储数据的;
(2)赋值:每个变量 在使用前都必须赋值,变量 赋值以后 该变量 才会被创建,用 等号(=)用来给变量赋值。
(3)引用:变量中记录数据的地址。(变量&数据&地址/引用的关系: 变量和数据是分开存储的数据保存在内存中的一个位置,变量中保存着数据在内存中的地址;变量存储数据的类型); - 有什么:在
Python
中定义变量是 不需要指定数据类型(在其他很多高级语言中都需要),数据类型有两类,数字型和非数字型;数字型:str、bool、int、float、complex;非数字型/高级数据类型:列表[]、元组()、字典{}、字符串"“)
① 列表[]:
新建列表:[1,2,3,4]、[“a”,“b”,“c”,“d”];
增加元素:append(末尾) / insert(指定位置);
增加列表:extend;
删除元素:remove(按值) / pop(按位置);
查找元素:in 索引+切片;
修改元素:查找后赋值;
排序:sort;
复制:copy;
长度:len;
计数:count
④ 字符串”": - 做什么:
① 变量的运算
执行结果如下:
变量的定义
- 在 Python 中,每个变量 在使用前都必须赋值,变量 赋值以后 该变量 才会被创建
- 等号(=)用来给变量赋值
-
=
左边是一个变量名 -
=
右边是存储在变量中的值
变量名 = 值
变量定义之后,后续就可以直接使用了
- 在内存中创建一个变量,会包括:
- 变量的名称
- 变量保存的数据
- 变量存储数据的类型
- 变量的地址
变量的命名
命名规则 可以被视为一种 惯例,并无绝对与强制
目的是为了 增加代码的识别和可读性
- 命名的规范性
- 变量名可以包括字母、数字、下划线,但是数字不能做为开头。例如:name1是合法变量名,而1name就不可以。
- 系统关键字不能做变量名使用
- 除了下划线之外,其它符号不能做为变量名使用
- Python的变量名是区分大小写的
- 在
Python
中,如果 变量名 需要由 二个 或 多个单词 组成时,可以按照以下方式命名
- 每个单词都使用小写字母
- 单词与单词之间使用
_
下划线 连接
- 驼峰命名法(* 当 变量名 是由二个或多个单词组成时,还可以利用驼峰命名法来命名)
大驼峰:每一个单词的首字母都大写,eg:FirstName LastName
小驼峰:第一个单词以小写字母开始,后续单词的首字母大写,eg:firstName lastName
注意: Python
中的 标识符 是 区分大小写的
- 在定义变量时,为了保证代码格式,
=
的左右应该各保留一个空格 - 在
Python
中,如果 变量名 需要由 二个 或 多个单词 组成时,可以按照以下方式命名
- 每个单词都使用小写字母
- 单词与单词之间使用
_
下划线 连接
- 例如:
first_name
、last_name
、qq_number
、qq_password
变量的赋值
- 在 Python 中,使用
=
可以给变量赋值 - 在算术运算时,为了简化代码的编写,
Python
还提供了一系列的 与 算术运算符 对应的 赋值运算符 - 注意:赋值运算符中间不能使用空格
运算符 | 描述 | 实例 |
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
%= | 取 模 (余数)赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
变量的引用
定义:变量中记录数据的地址,就叫做引用。
- 变量和数据是分开存储的
- 数据保存在内存中的一个位置
- 变量中保存着数据在内存中的地址
分类:python中数据值的传递、函数传参传递
查看方式:使用id()函数可以查看变量中保存数据所在的内存地址,可以将id 值认为是内存地址的别名
注意:
- 如果变量已经被定义,当给一个变量赋值的时候,本质上是修改了数据的引用(赋值运算符可以改变变量的引用)
- 变量不再对之前的数据引用
- 变量改为对新赋值的数据引用
- 变量和数据都是保存在内存中的
- 在Python中函数的参数传递以及返回值都是靠引用传递的
# 可以使用 id() 查看变量的引用, 可以将id 值认为是内存地址的别名
# python中数据值的传递的是引用
# 赋值运算符可以改变变量的引用
# 将数据10存储到变量a中, 本质是将数据10所在内存的引用地址保存到变量a中
a = 10
# 将变量a中保存的引用地址给给到b
b = a
print(a, b) # 使用print函数打印变量a和b引用中存储的值
print(id(a), id(b))
a = 20
print(a, b)
print(id(a), id(b))
执行结果如下:
10 10
140718781487040 140718781487040
20 10
140718781487360 140718781487040
my_list = [1, 2, 3] # 将列表的引用地址保存到变量my_list 中
my_list1 = my_list # 将my_list 变量中存储的引用地址给到 my_list1
print(my_list, id(my_list))
print(my_list1, id(my_list1))
my_list.append(4) # 向列表中添加数据4, 将数据4的引用保存到列表中
print(my_list, id(my_list))
print(my_list1, id(my_list1))
my_list[2] = 5
print(my_list, id(my_list))
print(my_list1, id(my_list1))
执行结果如下:
[1, 2, 3] 2184769236096
[1, 2, 3] 2184769236096
[1, 2, 3, 4] 2184769236096
[1, 2, 3, 4] 2184769236096
[1, 2, 5, 4] 2184769236096
[1, 2, 5, 4] 2184769236096
# 函数传参传递的也是引用
my_list = [1, 2, 3] # 全局变量
def func1(a):
a.append(4)
def func2():
# 为啥不加global, 因为没有修改 my_list 中存的引用值
my_list.append(5)
def func3():
global my_list
my_list = [1, 2, 3] # 修改全局变量的值
def func4(a):
# += 对于列表来说,类似列表的extend方法,不会改变变量的引用地址
a += a # a = a + a, 修改了a变量a的引用
# print(a)
func1(my_list) # [1, 2, 3, 4]
func2() # [1, 2, 3, 4, 5]
func3() # [1, 2, 3]
print(my_list)
b = 10 # 不可变类型
func4(b)
print(b) #
func4(my_list)
print(my_list) # [1, 2, 3, 1, 2, 3]
执行结果如下:
[1, 2, 3]
10
[1, 2, 3, 1, 2, 3]
bb = aa
print(bb)
print(id(aa))
print(id(bb))
aa.append(30)
print(aa)
print(bb) # 列表是可变类型
print(id(aa))
print(id(bb))
执行结果如下:
[10, 20]
2357098503488
2357098503488
[10, 20, 30]
[10, 20, 30]
2357098503488
2357098503488
变量的输入
- 所谓 输入,就是 用代码 获取 用户通过 键盘 输入的信息
- 例如:去银行取钱,在 ATM 上输入密码
- 在 Python 中,如果要获取用户在 键盘 上的输入信息,需要使用到
input
函数
1. 关于函数
- 一个 提前准备好的功能(别人或者自己写的代码),可以直接使用,而 不用关心内部的细节
- 目前已经学习过的函数
函数 | 说明 |
print(x) | 将 x 输出到控制台 |
type(x) | 查看 x 的变量类型 |
2. input 函数实现键盘输入
- 在 Python 中可以使用
input
函数从键盘等待用户的输入 - 用户输入的 任何内容 Python 都认为是一个 字符串
- 语法如下:
字符串变量 = input("提示信息:")
3. 类型转换函数
函数 | 说明 |
int(x) | 将 x 转换为一个整数 |
float(x) | 将 x 转换到一个浮点数 |
4. 变量输入演练 —— 超市买苹果增强版
需求
- 收银员输入 苹果的价格,单位:元/斤
- 收银员输入 用户购买苹果的重量,单位:斤
- 计算并且 输出 付款金额
演练方式 1
# 1. 输入苹果单价
price_str = input("请输入苹果价格:")
# 2. 要求苹果重量
weight_str = input("请输入苹果重量:")
# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)
# 2> 将苹果重量转换成小数
weight = float(weight_str)
# 3> 计算付款金额
money = price * weight
print(money)
提问
- 演练中,针对 价格 定义了几个变量?
- 两个
-
price_str
记录用户输入的价格字符串 -
price
记录转换后的价格数值
- 思考 —— 如果开发中,需要用户通过控制台 输入 很多个 数字,针对每一个数字都要定义两个变量,方便吗?
演练方式 2 —— 买苹果改进版
- 定义 一个 浮点变量 接收用户输入的同时,就使用
float
函数进行转换
price = float(input("请输入价格:"))
- 改进后的好处:
- 节约空间,只需要为一个变量分配空间
- 起名字方便,不需要为中间变量起名字
- 改进后的“缺点”:
- 初学者需要知道,两个函数能够嵌套使用,稍微有一些难度
提示
- 如果输入的不是一个数字,程序执行时会出错,有关数据转换的高级话题,后续会讲!
变量的输出
苹果单价
9.00
元/斤,购买了5.00
斤,需要支付45.00
元
- 在 Python 中可以使用
print
函数将信息输出到控制台 - 如果希望输出文字信息的同时,一起输出 数据,就需要使用到 格式化操作符
%
被称为 格式化操作符,专门用于处理字符串中的格式
- 包含
%
的字符串,被称为 格式化字符串 -
%
和不同的 字符 连用,不同类型的数据 需要使用 不同的格式化字符
格式化字符 | 含义 |
%s | 字符串 |
%d | 有符号十进制整数, |
%f | 浮点数, |
%% | 输出 |
- 语法格式如下:
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))
格式化输出演练 —— 基本练习
需求
- 定义字符串变量
name
,输出 我的名字叫 小明,请多多关照! - 定义整数变量
student_no
,输出 我的学号是 000001 - 定义小数
price
、weight
、money
,输出 苹果单价 9.00 元/斤,购买了 5.00 斤,需要支付 45.00 元 - 定义一个小数
scale
,输出 数据比例是 10.00%
print("我的名字叫 %s,请多多关照!" % name)
print("我的学号是 %06d" % student_no)
print("苹果单价 %.02f 元/斤,购买 %.02f 斤,需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))
课后练习 —— 个人名片
需求
- 在控制台依次提示用户输入:姓名、公司、职位、电话、邮箱
- 按照以下格式输出:
**************************************************
公司名称
姓名 (职位)
电话:电话
邮箱:邮箱
**************************************************
实现代码如下:
"""
在控制台依次提示用户输入:姓名、公司、职位、电话、电子邮箱
"""
name = input("请输入姓名:")
company = input("请输入公司:")
title = input("请输入职位:")
phone = input("请输入电话:")
email = input("请输入邮箱:")
print("*" * 50)
print(company)
print()
print("%s (%s)" % (name, title))
print()
print("电话:%s" % phone)
print("邮箱:%s" % email)
print("*" * 50)
变量的切片
- 切片 方法适用于 字符串、列表、元组
。切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
1.对切片赋值,相当于替代原list中的切片部分,赋值的list不必与切片长度一致,也可以将切片赋值给新的变量,用以取原list中的一部分;
2.list中的元素在切片中可以用正数索引或负数索引表示,正向索引为0,1,2……,第一个元素索引为0;负向索引-1,-2,-3,……最后一个元素索引-1;
3.可以指定间隔进行切片。
切片的作用
要一个序列的子串的时候,可以使用切片操作。例如:
a = [‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’]
在a这个序列中,如果你想截取里面[‘c’,‘d’,‘e’]这个子序列,那么你就可以使用切片a[2:5]
它的语法形式是a[start:end],这里有一个区间边沿取值的问题。首先你要明确序列的索引是从0开始的,a[2:5]取值的范围是[2,5),前面是闭区间,后面是开区间,也就是2<=索引值<5这段区间里的元素。所以如果这样来切的话:a[1:1],得到的就是[],空序列。
索引也可以为负,从后往前依次是-1,-2,-3,……
变量的运算
不同类型变量之间的计算
1. 数字型变量 之间可以直接计算
- 在 Python 中,两个数字型变量是可以直接进行 算数运算的
- 如果变量是
bool
型,在计算时
-
True
对应的数字是1
-
False
对应的数字是0
演练步骤
- 定义整数
i = 10
- 定义浮点数
f = 10.5
- 定义布尔型
b = True
- 在 iPython 中,使用上述三个变量相互进行算术运算
2. 字符串变量 之间使用 +
拼接字符串
- 在 Python 中,字符串之间可以使用
+
拼接生成新的字符串
In [1]: first_name = "三"
In [2]: last_name = "张"
In [3]: first_name + last_name
Out[3]: '三张'
3. 字符串变量 可以和 整数 使用 *
重复拼接相同的字符串
In [1]: "-" * 50
Out[1]: '--------------------------------------------------'
4. 数字型变量 和 字符串 之间 不能进行其他计算
In [1]: first_name = "zhang"
In [2]: x = 10
In [3]: x + first_name
---------------------------------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
类型错误:`+` 不支持的操作类型:`int` 和 `str`
运算符
算数运算符
运算符 | 逻辑表达式 | 作用 |
+ | 加 | 10 + 20 = 30 |
- | 减 | 10 - 20 = - 10 |
* | 乘 | 10 * 20 = 200 |
/ | 除 | 10 / 20 = 0.5 |
// | 取整除 | 返回除法的整数部分(商) |
% | 取余数 | 返回除法的余数,9%2=1 |
** | 幂 | 又称次方、乘方,2 ** 3 = 8 |
应用
- 在Python中*运算符还可以用于字符串,计算结果就是字符串重复指定次数的结果
- 求出数字的个、十、百位数
num=10000000
个位数: num % 10
⼗位数: num // 10
比较运算符
运算符 | 逻辑表达式 | 作用 |
== | x == y | 检查两个操作数的值是否相等,如果是,则条件成立,返回True |
!= | x != y | 检查两个操作数的值是否不相等,如果是,则条件成立,返回True |
> | x > y | 检查左操作数的值是否大于右操作数的值,如果是,则条件成立,返回True |
< | x < y | 检查左操作数的值是否小于右操作数的值,如果是,则条件成立,返回True |
>= | x >= y | 检查左操作数的值是否大于或等于右操作数的值,如果是,则条件成立,返回True |
<= | x < = y | 检查左操作数的值是否小于或等于右操作数的值,如果是,则条件成立,返回True |
逻辑运算符
运算符 | 逻辑表达式 | 作用 |
and | x and y | 只有x和y的值都为True,才会返回True,否则只要x或者y有一个值为False,就返回False(如果第一个条件为False,就不会再判断第二个条件–“一假则假”) |
or | x or y | 只要x或者y有一个值为True,就返回True(如果第一个条件为True,第二个条件就不会再判断了–“一真为真”)只有x和y的值都为False,才会返回False |
not | not x | 如果x为True,返回False,如果x为False,返回True |
优先级:() > not > and > or
1.or
逻辑运算符or,表达式为:x or y, 如果x为True则返回x,如果x为False返回y值。因为如果x为True那么or运算就不需要在运算了,因为一个为真则为真,所以返回x的值。如果x的值为假,那么or运算的结果取决于y,所以返回y的值。
2.and
逻辑运算符and,表达式为:x and y,如果x为True则返回y值。如果x为False则返回y值。如果x的值为True,and的运算不会结束,会继续看y的值,所以此时真与假取决于y的值,所以x如果为真,则返回y的值。如果x为假,那么and运算就会结束运算过程了,因为有一个为假则and为假,所以返回x的值。
示例
print(1 > 2 and 3 or 4 and 3 < 2 or not 4 > 5)
解析:按照从左向右,优先级高的先执行优先级高的规则,首先因为比较运算符优先级高于逻辑运算符,很简单,如果运算符低于了逻辑运算符优先级那还如何运算呢。and 优先级大于 or,not优先级大于and和or。
解:
not 4 > 5 为True
1 > 2 为 False
3 < 2 为 False
Flase and 3,因为False为假所以and不在运算直接返回False
4 and False,因为4为真所以and运算符会继续运算后面的,以False为主,所以返回False。
False or False,为False
False or True,为True
False or False,因为False为假,所以or运算符会继续运算后面的,以False为主,所以返回后面的False值
赋值运算符
运算符 | 描述 | 作用 |
= | 简单的赋值运算符 | c = a + b 将 a+b的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a等效于 c = c * a |
/= | 除法赋值运算符 | c /= a等效于c = c / a |
//= | 取整除赋值运算符 | c //= a等效于c = c // a |
%= | 取模(余数)赋值运算符 | c %= a等效于c = c % a |
**= | 幂赋值运算符 | c = a等效于 c = c a |
●在Python中,使用=可以给变量赋值
●在算术运算时,为了简化代码的编写, Python 还提供了一系列的与算术运算符对应的赋值运算符
●注意:赋值运算符中间不能使用空格
运算符优先级
以下表格的算数优先级由高到最低顺序排列
优先级高到低 | 类型 | 运算符 | 描述 | 内部优先级 |
1 | 算数运算符 | ** | 幂(最高优先级) | 运算从左到右(幂>乘除取余数整数>加减) |
2 | 算数运算符 | *、/、%、// | 乘、除、取余数、取整数 | 运算从左到右(幂>乘除取余数整数>加减) |
3 | 算数运算符 | +、- | 加法、减法 | 运算从左到右(幂>乘除取余数整数>加减) |
4 | 比较运算符 | <=、<、>、>= | 比较 | 运算从左到右 |
5 | 等于运算符 | ==、!= | 等于不等于 | 运算从左到右 |
6 | 赋值运算符 | =、%=、/=、//=、-=、+=、*= | 赋值 | 运算从左到右 |
7 | 逻辑运算符 | not、and 、or | 不、或、和 | () > not > and > or |
变量的类型
- 在
Python
中定义变量是 不需要指定类型(在其他很多高级语言中都需要) - 数据类型可以分为 数字型 和 非数字型
- 数字型
(1)整型 (int
)
(2)浮点型(float
)
(3)布尔型(bool
): ① 真True
非 0 数
—— 非零即真;② 假False
0
(4)复数型 (complex
):主要用于科学计算,例如:平面场问题、波动问题、电感电容等问题 - 非数字型
(1)字符串
(2)列表
(3)元组
(4)字典
提示:在 Python 2.x 中,整数 根据保存数值的长度还分为:
int
(整数)long
(长整数)
- 使用
type
函数可以查看一个变量的类型
In [1]: type(name)
数字型
- 数字型
- 整型 (
int
) - 浮点型(
float
) - 布尔型(
bool
)
- 真
True
非 0 数
—— 非零即真 - 假
False
0
- 复数型 (
complex
)
变量的非数字型/高级数据类型
- 字符串
- 列表
- 元组
- 字典
字符串
字符串的定义
- 字符串 就是 一串字符,是编程语言中表示文本的数据类型
- 在 Python 中可以使用 一对双引号
"
或者 一对单引号'
定义一个字符串
- 虽然可以使用
\"
或者\'
做字符串的转义,但是在实际开发中:
- 如果字符串内部需要使用
"
,可以使用'
定义字符串 - 如果字符串内部需要使用
'
,可以使用"
定义字符串
- 可以使用 索引 获取一个字符串中 指定位置的字符,索引计数从 0 开始
- 也可以使用
for
循环遍历 字符串中每一个字符
大多数编程语言都是用
"
来定义字符串
string = "Hello Python"
for c in string:
print(c)
a = 'hello ' \
'world'
print(a)
print(type(a))
b = "TOM"
print(type(b))
# 三引号
e = '''i am TOM'''
print(type(e))
f = """I
am TOM"""
print(type(f))
print(f)
# I'm TOM
c = "I'm TOM"
print(c)
print(type(c))
# d = 'I'm TOM'
d = 'I\'m TOM'
print(d)
print(type(d))
执行结果如下:
hello world
<class 'str'>
<class 'str'>
<class 'str'>
<class 'str'>
I
am TOM
I'm TOM
<class 'str'>
I'm TOM
<class 'str'>
字符串的输入
# 输入密码
password = input('请输入您的密码:')
print(f'您输入的密码是{password}')
print(type(password))
执行结果如下:
请输入您的密码:123
您输入的密码是123
<class 'str'>
字符串的输出
print("hello world")
name = 'ROSE'
# 我的名字是TOM
print('我的名字是%s' % name)
print(f'我的名字是{name}')
执行结果如下:
hello world
我的名字是ROSE
我的名字是ROSE
字符串的下标
str1 = 'abcdefg'
print(str1)
# 数据在程序运行过程中存储在内存
# ? 得到数据a字符,得到数据b字符 -- 使用字符串中某个特定的数据
# 这些字符数据从0开始顺序分配一个编号 -- 使用这个编号精确找到某个字符数据 -- 下标或索引或索引值
# str1[下标]
print(str1[0])
print(str1[1])
执行结果如下:
abcdefg
a
b
字符串的切片
- 切片 方法适用于 字符串、列表、元组
。切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
。列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
。字典 是一个 无序 的集合,是使用 键值对 保存数据
字符串 [开始索引:结束索引:步长]
序列名 [开始位置的下标:结束位置的下标:步长]
# 序列名[开始位置的下标:结束位置的下标:步长]
str1 = '012345678'
# print(str1[2:5:1]) # 234
# print(str1[2:5:2]) # 24
# print(str1[2:5]) # 234
# print(str1[:5]) # 01234 -- 如果不写开始,默认从0开始选取
# print(str1[2:]) # 2345678 -- 如果不写结束,表示选取到最后
# print(str1[:]) # 012345678 -- 如果不写开始和结束,表示选取所有
# 负数测试
# print(str1[::-1]) # 876543210 -- 如果步长为负数,表示倒叙选取
# print(str1[-4:-1]) # 567 -- 下标-1表示最后一个数据,依次向前类推
# 终极测试
# print(str1[-4:-1:1]) # 567
print(str1[-4:-1:-1]) # 不能选取出数据:从-4开始到-1结束,选取方向为从左到右,但是-1步长:从右向左选取
# **** 如果选取方向(下标开始到结束的方向) 和 步长的方向冲突,则无法选取数据
print(str1[-1:-4:-1]) # 876
执行结果如下:
876
注意:
- 指定的区间属于 左闭右开 型
[开始索引, 结束索引)
=>开始索引 >= 范围 < 结束索引
- 从
起始
位开始,到结束
位的前一位 结束(不包含结束位本身)
- 从头开始,开始索引 数字可以省略,冒号不能省略
- 到末尾结束,结束索引 数字可以省略,冒号不能省略
- 步长默认为
1
,如果连续切片,数字和冒号都可以省略
str1 = 'abcdefg'
# 得到整个字符串数据
print(str1)
# 下标得到的是下标为某个数字的数据
print(str1[2])
# 得到abc 这3个数据该怎么办
执行结果如下:
abcdefg
c
索引的顺序和倒序
- 在 Python 中不仅支持 顺序索引,同时还支持 倒序索引
- 所谓倒序索引就是 从右向左 计算索引
- 最右边的索引值是 -1,依次递减
演练需求
- 截取从 2 ~ 5 位置 的字符串
- 截取从 2 ~
末尾
的字符串 - 截取从
开始
~ 5 位置 的字符串 - 截取完整的字符串
- 从开始位置,每隔一个字符截取字符串
- 从索引 1 开始,每隔一个取一个
- 截取从 2 ~
末尾 - 1
的字符串 - 截取字符串末尾两个字符
- 字符串的逆序(面试题)
答案
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置,每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始,每隔一个取一个
print(num_str[1::2])
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序(面试题)
print(num_str[::-1])
字符串的转义字符
-
\t
在控制台输出一个 制表符,协助在输出文本时 垂直方向 保持对齐 -
\n
在控制台输出一个 换行符
制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本
转义字符 | 描述 |
\\ | 反斜杠符号 |
\’ | 单引号 |
\" | 双引号 |
\n | 换行 |
\t | 横向制表符 |
\r | 回车 |
字符串的常用操作
- 在
ipython3
中定义一个 字符串,例如:hello_str = ""
- 输入
hello_str.
按下TAB
键,ipython
会提示 字符串 能够使用的 方法 如下:
In [1]: hello_str.
hello_str.capitalize hello_str.isidentifier hello_str.rindex
hello_str.casefold hello_str.islower hello_str.rjust
hello_str.center hello_str.isnumeric hello_str.rpartition
hello_str.count hello_str.isprintable hello_str.rsplit
hello_str.encode hello_str.isspace hello_str.rstrip
hello_str.endswith hello_str.istitle hello_str.split
hello_str.expandtabs hello_str.isupper hello_str.splitlines
hello_str.find hello_str.join hello_str.startswith
hello_str.format hello_str.ljust hello_str.strip
hello_str.format_map hello_str.lower hello_str.swapcase
hello_str.index hello_str.lstrip hello_str.title
hello_str.isalnum hello_str.maketrans hello_str.translate
hello_str.isalpha hello_str.partition hello_str.upper
hello_str.isdecimal hello_str.replace hello_str.zfill
hello_str.isdigit hello_str.rfind
提示:正是因为 python 内置提供的方法足够多,才使得在开发时,能够针对字符串进行更加灵活的操作!应对更多的开发需求!
1. 判断类型 - 9
方法 | 说明 |
string.isspace() | 如果 string 中只包含空格,则返回 True |
string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True |
string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True |
string.isdecimal() | 如果 string 只包含数字则返回 True, |
string.isdigit() | 如果 string 只包含数字则返回 True, |
string.isnumeric() | 如果 string 只包含数字则返回 True, |
string.istitle() | 如果 string 是标题化的(每个单词的首字母大写)则返回 True |
string.islower() | 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True |
string.isupper() | 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True |
2. 查找和替换 - 7
方法 | 说明 |
string.startswith(str) | 检查字符串是否是以 str 开头,是则返回 True |
string.endswith(str) | 检查字符串是否是以 str 结束,是则返回 True |
string.find(str, start=0, end=len(string)) | 检测 str 是否包含在 string 中,如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回 |
string.rfind(str, start=0, end=len(string)) | 类似于 find(),不过是从右边开始查找 |
string.index(str, start=0, end=len(string)) | 跟 find() 方法类似,不过如果 str 不在 string 会报错 |
string.rindex(str, start=0, end=len(string)) | 类似于 index(),不过是从右边开始 |
string.replace(old_str, new_str, num=string.count(old)) | 把 string 中的 old_str 替换成 new_str,如果 num 指定,则替换不超过 num 次 |
mystr = "hello world and itcast and itheima and Python"
# 1. find()
# print(mystr.find('and')) # 12
# print(mystr.find('and', 15, 30)) # 23
# print(mystr.find('ands')) # -1 , ands子串不存在
# 2.index()
# print(mystr.index('and')) # 12
# print(mystr.index('and', 15, 30)) # 23
# print(mystr.index('ands')) # 如果index查找子串不存在,报错
# 3.count()
# print(mystr.count('and', 15, 30))
# print(mystr.count('and')) # 3
# print(mystr.count('ands')) # 0
# 4.rfind()
# print(mystr.rfind('and'))
# print(mystr.rfind('ands'))
# 5.rindex()
# print(mystr.rindex('and'))
# print(mystr.rindex('ands'))
3. 大小写转换 - 5
方法 | 说明 |
string.capitalize() | 把字符串的第一个字符大写 |
string.title() | 把字符串的每个单词首字母大写 |
string.lower() | 转换 string 中所有大写字符为小写 |
string.upper() | 转换 string 中的小写字母为大写 |
string.swapcase() | 翻转 string 中的大小写 |
4. 文本对齐 - 3
方法 | 说明 |
string.ljust(width) | 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
string.rjust(width) | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
string.center(width) | 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
5. 去除空白字符 - 3
方法 | 说明 |
string.lstrip() | 截掉 string 左边(开始)的空白字符 |
string.rstrip() | 截掉 string 右边(末尾)的空白字符 |
string.strip() | 截掉 string 左右两边的空白字符 |
6. 拆分和连接 - 5
方法 | 说明 |
string.partition(str) | 把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面) |
string.rpartition(str) | 类似于 partition() 方法,不过是从右边开始查找 |
string.split(str=“”, num) | 以 str 为分隔符拆分 string,如果 num 有指定值,则仅分隔 num + 1 个子字符串,str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格 |
string.splitlines() | 按照行(‘\r’, ‘\n’, ‘\r\n’)分隔,返回一个包含各行作为元素的列表 |
string.join(seq) | 以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
7. 修改
mystr = "hello world and itcast and itheima and Python"
# 1. replace() 把and换成he #** 说明replace函数有返回值,返回值是修改后的字符串
# new_str = mystr.replace('and', 'he')
# new_str = mystr.replace('and', 'he', 1)
# 替换次数如果超出子串出现的次数,表示替换所有这个子串
# new_str = mystr.replace('and', 'he', 10)
# # print(mystr)
# print(new_str)
# ***** 调用了replace函数后,发现原有字符串的数据并没有做到修改,修改后的数据是replace函数的返回值
# --- 说明 字符串是不可变数据类型
# 数据是否可以改变划分为 可变类型 和 不可变类型
# 2. split() -- 分割,返回一个列表, 丢失分割字符
# list1 = mystr.split('and')
# list1 = mystr.split('and', 2)
# print(list1)
# 3. join() -- 合并列表里面的字符串数据为一个大字符串
# mylist = ['aa', 'bb', 'cc']
#
# # aa...bb...cc
# new_str = '...'.join(mylist)
# print(new_str)
# mystr = "hello world and itcast and itheima and Python"
# 1. capitalize() 字符串首字母大写
# new_str = mystr.capitalize()
# 2.title(): 字符串中每个单词首字母大写
# new_str = mystr.title()
# 3. upper():小写转大写
# new_str = mystr.upper()
# 4. lower(): 大写转小写
# new_str = mystr.lower()
# print(new_str)
mystr = " hello world and itcast and itheima and Python "
print(mystr)
# 1. lstrip(): 删除左侧空白字符
# new_str = mystr.lstrip()
# 2. rstrip(): 删除右侧空白字符
# new_str = mystr.rstrip()
# 3.strip():删除两侧空白字符
new_str = mystr.strip()
print(new_str)
执行结果如下:
hello world and itcast and itheima and Python
hello world and itcast and itheima and Python
列表[](使用最频繁的数据类型)
一、是什么
- 定义
列表(list),是用方括号[]括起来的一种数据结构,元素和元素之间用逗号分隔,列表中的元素是可以进行增删查改等一系列操作的,列表通常这样表示:
列表名 = [元素1,元素2,元素3]
●命令:列表用[]定义,数据之间使用,分隔
●特点:list(列表)是Python中使用最频繁的数据类型,在其他语言中通常叫做数组,专门用于存储一串信息(存放多个数据,数据可以是任意类型)
●索引:索引就是数据在列表中的位置编号,索引又可以被称为下标,列表的索引从θ开始。注意:从列表中取值时,如果超出索引范围,程序会报错。
name_list = ['TOM', 'Lily', 'ROSE']
print(name_list)
print(name_list[1])
print(name_list[0])
print(name_list[2])
执行结果如下:
['TOM', 'Lily', 'ROSE']
Lily
TOM
ROSE
常考点:
- 下标-1表示最后一个数据,依次向前类推;
- 指定的区间属于 左闭右开 型
[开始索引, 结束索引)
=>开始索引 >= 范围 < 结束索引
;从起始
位开始,到结束
位的前一位 结束(不包含结束位本身)
列表的切片
- 切片 方法适用于 字符串、列表、元组
。切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
。列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
。字典 是一个 无序 的集合,是使用 键值对 保存数据
字符串 [开始索引:结束索引:步长]
序列名 [开始位置的下标:结束位置的下标:步长]
# 序列名[开始位置的下标:结束位置的下标:步长]
str1 = '012345678'
# print(str1[2:5:1]) # 234
# print(str1[2:5:2]) # 24
# print(str1[2:5]) # 234
# print(str1[:5]) # 01234 -- 如果不写开始,默认从0开始选取
# print(str1[2:]) # 2345678 -- 如果不写结束,表示选取到最后
# print(str1[:]) # 012345678 -- 如果不写开始和结束,表示选取所有
# 负数测试
# print(str1[::-1]) # 876543210 -- 如果步长为负数,表示倒叙选取
# print(str1[-4:-1]) # 567 -- 下标-1表示最后一个数据,依次向前类推
# 终极测试
# print(str1[-4:-1:1]) # 567
print(str1[-4:-1:-1]) # 不能选取出数据:从-4开始到-1结束,选取方向为从左到右,但是-1步长:从右向左选取
# **** 如果选取方向(下标开始到结束的方向) 和 步长的方向冲突,则无法选取数据
print(str1[-1:-4:-1]) # 876
执行结果如下:
876
注意:
- 指定的区间属于 左闭右开 型
[开始索引, 结束索引)
=>开始索引 >= 范围 < 结束索引
- 从
起始
位开始,到结束
位的前一位 结束(不包含结束位本身)
- 从头开始,开始索引 数字可以省略,冒号不能省略
- 到末尾结束,结束索引 数字可以省略,冒号不能省略
- 步长默认为
1
,如果连续切片,数字和冒号都可以省略
str1 = 'abcdefg'
# 得到整个字符串数据
print(str1)
# 下标得到的是下标为某个数字的数据
print(str1[2])
# 得到abc 这3个数据该怎么办
执行结果如下:
abcdefg
c
索引的顺序和倒序
- 在 Python 中不仅支持 顺序索引,同时还支持 倒序索引
- 所谓倒序索引就是 从右向左 计算索引
- 最右边的索引值是 -1,依次递减
演练需求
- 截取从 2 ~ 5 位置 的字符串
- 截取从 2 ~
末尾
的字符串 - 截取从
开始
~ 5 位置 的字符串 - 截取完整的字符串
- 从开始位置,每隔一个字符截取字符串
- 从索引 1 开始,每隔一个取一个
- 截取从 2 ~
末尾 - 1
的字符串 - 截取字符串末尾两个字符
- 字符串的逆序(面试题)
答案
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置,每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始,每隔一个取一个
print(num_str[1::2])
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序(面试题)
print(num_str[::-1])
●作用:列表可以⼀次性存储多个数据,且可以为不同数据类型。程序员可以对这些数据进⾏的操作有:增、删、改、查。
列表的同步性
以list为例
lst和lst1的内存地址不一样,说明是两个不同的对象 :id() 或者is两种方法 id不同 内存不同 is返回false
但是 lst == lst1返回true ==判断是否相等
is id判断是否是同一个对象(内存)
但是lst[0]和lst1[0]、lst[3]和lst1[3](最外层列表)是同一个
相当于列表lst 筐换了,但是筐里面的元素没换
修改最外层元素 互不影响
修改内层元素元素 相互同步
lst[3][0]和lst1[3][0]也是同一个
要实现深拷贝需要import.copy模块 调用copy.deepcopy()
内层、外层修改都互不影响 筐和元素都不是同一个
二、怎么用
前言:从建、增、删、查、改5个维度来学习列表。
说明:In[]:表明为输入的代码,编写代码时不需要书写,Out[]同理为输出结果;
- 在
ipython3
中定义一个 列表,例如:name_list = []
- 输入
name_list.
按下TAB
键,ipython
会提示 列表 能够使用的 方法 如下:
In [1]: name_list.
name_list.append name_list.count name_list.insert name_list.reverse
name_list.clear name_list.extend name_list.pop name_list.sort
name_list.copy name_list.index name_list.remove
序号 | 分类 | 关键字 / 函数 / 方法 | 说明 |
1 | 增加 | 列表.insert(索引, 数据) | 在指定位置插入数据 |
列表.append(数据) | 在末尾追加数据 | ||
列表.extend(列表2) | 将列表2 的数据追加到列表 | ||
2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
列表.remove[数据] | 删除第一个出现的指定数据 | ||
列表.pop | 删除末尾数据 | ||
列表.pop(索引) | 删除指定索引数据 | ||
列表.clear | 清空列表 | ||
4 | 统计 | len(列表) | 列表长度 |
列表.count(数据) | 数据在列表中出现的次数 | ||
5 | 排序 | 列表.sort() | 升序排序 |
列表.sort(reverse=True) | 降序排序 | ||
列表.reverse() | 逆序、反转 |
2.1.建
建:创建和访问列表。
- 列表中的数据没有类型的限制,可以是数值型也可以是字符型,还可以混搭。新建一个列表i_list,列表中的数据是数值型。
In [1]:#新建一个列表
i_list = [2,5,8]
i_list
Out[1]:[2,5,8]
- 可以用type函数查看一个列表的数据类型,可以看到i_list列表的类型为list
In [2]:type(i_list)
Out[2]:list
- 新建一个字符型的列表s_list,里面存储字符
In [3]:s_list = ["a","b","c"]
s_list
Out[3]:["a","b","c"]
- 新建一个混搭型的列表,h_list,既有数值又有字符
In [4]:h_list = [1,"a",2,"b"]
h_list
Out[4]:[1,"a",2,"b"]
2.2.增
增的意思是在列表中增加元素,或在列表中增加列表。
2.2.1. 列表中增加元素
2.2.1.1. 末尾插入
- append方法用来在末尾插入新元素,如对i_list列表后边追加一个值10。
In [5]:# 末尾追加
i_list.append(10)
i_list
Out[5]:[2,5,8,10]
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.append('xiaoming')
name_list.append([11, 22])
print(name_list)
# 1. 列表数据可改的 -- 列表可变类型
# 2. append函数追加数据的时候如果数据是一个序列,追加整个序列到列表的结尾
执行结果如下:
['TOM', 'Lily', 'ROSE', [11, 22]]
2.2.1.2. 指定位置插入
- insert方法则可以在指定位置插入新元素,如在s_list列表中第2个位置插入“s”字符,需要注意的是,insert(位置,值),意思是在哪一个位置插入什么值,第一个位置是0,第二个位置是1,因此这里是(1,“s”)
- 注意:位置被插入的元素,顺延下标加1
my_list = [1,2]
my_list.insert(-1,1)
print(my_list)
执行结果如下:
[1, 1, 2]
In [6]:# 指定插入
s_list.insert(1,"s")
s_list
Out[6]:["a","s","b","c"]
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.insert(下标, 数据)
name_list.insert(1, 'aaa')
print(name_list)
执行结果如下:
['TOM', 'aaa', 'Lily', 'ROSE']
my_list = [1,2]
for v in range(2):
my_list.insert(-1,my_list[v])
print(my_list)
执行结果如下:
[1, 1, 1, 2]
2.2.2. 列表中增加列表
- 俗称列表合并,可以用”+”号操作符,如将i_list与s_list两个列表合并在一起,就是纯粹地连接在了一起。
In [7]:i_s = i_list + s_list
i_s
Out[7]:[2,5,8,10,"a","s","b","c"]
- 也可以使用extend方法,a.extend(b),意思是把b列表合并到a列表中,效果是一样的,只不过现在i_list列表就变了,不是单纯的数值型列表了。
In [8]:i_list.extend(s_list)
i_list
Out[8]:[2,5,8,10,"a","s","b","c"]
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.extend('xiaoming')
name_list.extend(['xiaoming', 'xiaohong'])
print(name_list)
# extend() 追加数据是一个序列,把数据序列里面的数据拆开然后逐一追加到列表的结尾
执行结果如下:
['TOM', 'Lily', 'ROSE', 'xiaoming', 'xiaohong']
2.3.删
列表中元素的删除,可以根据元素值删除,也可按索引删除。
- remove方法是根据元素删除,指定要删除的元素的值,一次只能删除一个值,如现在删除s_list列表中的“s”字符。
In [9]:s_list.remove("s")
s_list
Out[9]:["a","b","c","d"]
- pop方法是按照索引删除,即指定要删除字符所在的位置,如删除i_list列表中10这个值,已知10是该列表中的最后一位
In [10]:i_list.pop(-1)
i_list
Out[10]:[2,5,8]
- 以及del函数,永久删除,效果一样,不同的是一个是python中的函数,一个是面向对象的方法。
In [11]:del i_list[-1]
i_list
Out[11]:[2,5,8]
name_list = ['TOM', 'Lily', 'ROSE']
# 1. del
# del name_list
# del(name_list)
# del 可以删除指定下标的数据
# del name_list[0]
# print(name_list)
# 2. pop() -- 删除指定下标的数据,如果不指定下标,默认删除最后一个数据,
# 无论是按照下标还是删除最后一个,pop函数都会返回这个被删除的数据
# del_name = name_list.pop()
# del_name = name_list.pop(1)
# print(del_name)
# print(name_list)
# 3. remove(数据)
# name_list.remove('ROSE')
# print(name_list)
# 4. clear() -- 清空
name_list.clear()
print(name_list)
执行结果如下:
[]
2.4.查
查的意思是查找某个元素是否在列表中,以及通过索引访问该元素。
2.4.1 查找某个值是否在列表中
可以使用in操作符来查找一个值是否在列表中,返回的结果是逻辑值True/False,这个在之前数据类型中写到过的字符串查找用in的方法是一样的,如查找5是否在i_list列表中。
In [12]:5 in i_list
Out[12]:True
2.4.2 查找列表中指定位置的值
查找列表中指定位置的值,也就是通过索引来访问该元素。列表是有序的,每一个元素都有其特定的索引,可以使用索引和切片来查找列表中某位置的值。如获取s_list列表中第3个位置的值,得到字符“c”,再来复习一下索引,从0开始递增,那么a的位置是0,b是1,c就是2.
In [13]:s_list
Out[13]:["a","b","c","d"]
In [14]:s_list[2] #获取第3位的值
Out[14]:'c'
取第3位及以后位置的值,就要切片了,:是指所有的值,2:是指从第3位开始,包括第三位以后所有的值。
In [15]:s_list[2:] #获取第3位及以后的值
Out[15]:['c','d']
2.5.改
对列表中元素的值进行修改,直接查找到位置后赋值即可,就是这么简单粗暴。如对s_list列表中的第一个值,改成大写的A。
In [16]:s_list[0] = "A"
s_list
Out[16]:["A","b","c","d"]
可选地,对列表的操作还有排序、复制、计数等,可以看一下。
name_list = ['TOM', 'Lily', 'ROSE']
# 1. 修改指定下标的数据
# name_list[0] = 'aaa'
# print(name_list)
# 2. 逆序 reverse()
list1 = [1, 3, 2, 5, 4, 6]
# list1.reverse()
# print(list1)
# 3. sort() 排序:升序(默认) 和 降序
# list1.sort()
# list1.sort(reverse=False)
list1.sort(reverse=True)
print(list1)
执行结果如下:
[6, 5, 4, 3, 2, 1]
2.6.排序
sort方法,默认升序,降序需添加reverse = True参数。
In [17]:#升序
s_list.sort()
s_list
Out[17]:["A","b","c","d"]
In [18]:#降序
s_list.sort(reverse = True)
s_list
Out[18]:["d","c","b","A"]
2.7. 复制
copy方法复制列表,如将s_list列表复制一份,则得到它的副本,可以在它的副本基础上做修改。
In [19]:s_list.copy()
Out[19]:["d","c","b","A"]
name_list = ['TOM', 'Lily', 'ROSE']
list1 = name_list.copy()
print(list1)
print(name_list)
执行结果如下:
['TOM', 'Lily', 'ROSE']
['TOM', 'Lily', 'ROSE']
2.8.求列表长度
用len函数求列表长度,如求s_list列表的长度,得到4,里面有4个元素。
In [20]:len(s_list)
Out[20]:4
2.9.计数
计数用来统计列表中元素出现的次数,用count方法,如统计t_list列表中元素c出现的次数,结果为1,表示出现了1次。
In [21]:s_lisr.count("c")
Out[21]:1
2.10.循环遍历
循环遍历:从头到为 依次从列表中获取数据,在循环体内部对每个元素执行相同的操作。为了提高列表的遍历效率,专门提供了迭代interation遍历,For能够实现迭代遍历。
for
name_list=["zhangsan","lisi","wangwu","wangxiaoer"]
for my_name in name_list:
print("我的名字叫:%s"%my_name)
顺序的从列表中依次获取数据,每一次循环过程中,数据都会保存在my_name
通过my_name这个变量中,每次在循环体内部都可以访问当前这一次获取到的数据
for my_name in name_list(要遍历的列表变量):
优点:不需要设计计数器,也不需要对计数器进行操作
name_list = ['TOM', 'Lily', 'ROSE']
for i in name_list:
# 遍历序列中的数据
print(i)
执行结果如下:
TOM
Lily
ROSE
list = [x*x for x in range(10)]
print(list)
执行结果如下:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print([x*x for x in range(1,11)])
print([x*x for x in range(1,11) if x%2==0])
print([m+n for m in 'ABC' for n in'abc'])
执行结果如下:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[4, 16, 36, 64, 100]
['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']
第一条代码意思是对(1,11)的元素每一个进行平方操作
第二条代码意思是在(1,11)的元素中先判断是否为偶数,如果是,则进行平方操作
第三条代码意思是将’ABC’中的元素作为结果中的第一个元素,将’abc’中的元素作为第二个元素,通过双重for循环来实现m+n的操作
while
name_list = ['TOM', 'Lily', 'ROSE']
'''
1. 准备表示下标数据
2. 循环while
条件 i < 3 len()
遍历:依次按顺序访问到序列的每一个数据
i += 1
'''
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
执行结果如下:
TOM
Lily
ROSE
2.11.列表推导式[for]
列表推导式,为了快速的生成一个列表
列表推导式的语法格式如下:
[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]
- 变量=[生成数据的规则 for 临时变量 in xxx]。
每循环一次,就会创建一个数据
my_list = [i for i in range(5)]
print(my_list)
执行结果如下:
[0, 1, 2, 3, 4]
my_list1 = ['hello' for i in range(5)]
print(my_list1)
执行结果如下:
['hello', 'hello', 'hello', 'hello', 'hello']
my_list2 = [i+i for i in range(5)]
print(my_list2)
执行结果如下:
[0, 2, 4, 6, 8]
- 变量=[生成数据的规则 for 临时变量 in xxx if xxx]。
每循环一次,并且if条件为True,生成一个数据
my_list = [i for i in range(5) if i%2 == 0]
print(my_list)
执行结果如下:
[0, 2, 4]
- 变量=[生成数据的规则 for 临时变量 in xxx for j in xxx]。
第二个for循环循环一次,生成一个数据
my_list = [(i,j) for i in range(3) for j in range(3)]
print(my_list)
执行结果如下:
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
lst = [[x for x in range(3)] for y in range(3)]
for r in range(3):
for c in range(3):
if lst[r][c] % 2 != 0:
print("#")
执行结果如下:
#
#
#
2.12.嵌套
name_list = [['TOM', 'Lily', 'Rose'], ['张三', '李四', '王五'], ['xiaohong', 'xiaoming', 'xiaolv']]
# print(name_list)
# 列表嵌套的时候的数据查询
# print(name_list[0])
print(name_list[0][1])
执行结果如下:
Lily
# 需求:8位老师,3个办公室, 将8位老师随机分配到3个办公室
"""
步骤:
1. 准备数据
1.1 8位老师 -- 列表
1.2 3个办公室 - 列表嵌套
2. 分配老师到办公室
*** 随机分配
就是把老师的名字写入到办公室列表 -- 办公室列表追加老师名字数据
3. 验证是否分配成功
打印办公室详细信息:每个办公室的人数和对应的老师名字
"""
import random
# 1. 准备数据
teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
offices = [[], [], []]
# 2. 分配老师到办公室 -- 取到每个老师放到办公室列表 -- 遍历老师列表数据
for name in teachers:
# 列表追加数据 -- append(选中) extend insert
# xx[0] -- 不能指定是具体某个下标 -- 随机
num = random.randint(0, 2)
offices[num].append(name)
# print(num)
# print(offices)
# 为了更贴合生活,把各个办公室子列表加一个办公室编号 1, 2, 3
i = 1
# 3. 验证是否分配成功
for office in offices:
# 打印办公室人数 -- 子列表数据的个数 len()
print(f'办公室{i}的人数是{len(office)},老师分别是:')
# 打印老师的名字
# print() -- 每个子列表里面的名字个数不一定 -- 遍历 -- 子列表
for name in office:
print(name)
i += 1
执行结果如下:
办公室1的人数是2,老师分别是:
F
G
办公室2的人数是1,老师分别是:
E
办公室3的人数是5,老师分别是:
A
B
C
D
H
三、题目
题目1 [加强训练]
题干
有一个列表,判断列表中的每一个元素是否以s或e结尾,如果是,则将其放入一个新的列表中,最后输出这个新的列表
list = ["red", "apples", "orange", "pink", "bananas", "blue", "black", "white"]
训练目标
让学员知道列表的循环和值的获取,以及列表的操作方法
训练提示
- 如何找到列表中的每一个元素?
- 如何判断列表中的元素以什么字符结尾?
参考方案
- 使用循环遍历的方式获取列表中的每一个元素?
- 列表中的元素为字符串,所以可以使用下标[-1] 来获取最后一个字符的值,然后判断.
操作步骤
- 遍历列表中的每一个元素
- if 判断 最后一个字符是否是
s
或者e
- 如果是,使用 append() 方法,将数据追加到新的列表中.
参考答案
my_list = ["red", "apples", "orange", "pink", "bananas", "blue", "black", "white"]
# 用来存放以e或者s结尾的字符串
new_list = []
for i in my_list:
# 判断列表中每一个元素是否以s或e结尾
if i[-1] == 's' or i[-1] == 'e':
new_list.append(i)
# 打印出这个新的列表
print(new_list)
方法二:
使用字符串中的方法来判断.
my_list = ["red", "apples", "orange", "pink", "bananas", "blue", "black", "white"]
# 用来存放以e或者s结尾的字符串
new_list = []
for i in my_list:
# 判断列表中每一个元素是否以s或e结尾
if i.endswith('s') or i.endswith('e'):
new_list.append(i)
# 打印出这个新的列表
print(new_list)
题目2 [加强训练]
题干
给定一个列表,首先删除以s开头的元素,删除后,修改第一个元素为"joke",并且把最后一个元素复制一份,放在joke的后边
my_list = ["spring", "look", "strange", "curious", "black", "hope"]
训练目标
列表的相关操作
训练提示
- 通过for循环遍历列表,获取到每一个元素
- 通过列表的操作方法对列表进行修改
参考方案
- 通过for循环获取每一个元素
- 通过remove删除列表中的元素
- 通过insert函数在指定位置插入元素
操作步骤
- 通过for循环获取每一个元素,判断是否以
s
开头 - 如果条件成立,则通过remove删除选中的元素
- 获取到最后一个元素,通过replace将元素放在指定的位置上
参考答案
my_list = ["spring", "look", "strange" "curious", "black", "hope"]
for i in my_list[:]:
# 删除以s开头的元素,
if i[0] == 's':
my_list.remove(i)
# 修改第一个元素为"joke"
my_list[0] = "joker"
# 获取最后一个元素
last_one = my_list[-1]
# 将最后一个元素放在joke的后面
my_list.insert(1, last_one)
print(my_list)
题目3 [加强训练]
题干
将下列两个列表合并,将合并后的列表去重,之后降序并输出
list1 = [11, 4, 45, 34, 51, 90]
list2 = [4, 16, 23, 51, 0]
训练目标
列表操作方法的使用
训练提示
- 如何合并两个列表?
- 如何进行列表去重?
- 如何排序并降序输出?
参考方案
- 合并列表可以使用 extend()方法或者两个列表相加。
- 列表去重有两种方案
- 自己实现方法实现,借助一个新的列表,循环遍历原列表,判断元素是否在新的列表中,如果在,遍历下一个元素,如果不在,添加到新的列表中。
- 使用 set() 集合去重
- sort 函数可以实现排序,参数reverse=True对列表进行倒序排序
操作步骤
1,使用 + 对列表进行拼接(或者使用 extend)
2,列表去重
3,使用sort函数,参数reverse=True对列表进行倒序排序
参考答案
方案 1
list1 = [11, 4, 45, 34, 51, 90]
list2 = [4, 16, 23, 51, 0]
# 1. 使用 + 合并两个列表
my_list = list1 + list2
# 2. 列表去重
# 2.1 定义新的空列表保存去重后的数据
my_list1 = []
# 2.2 遍历合并后的列表
for i in my_list:
# 2.3 判断i 是否在my_list1 中
if i in my_list1:
# 2.3.1 如果存在,直接下一次循环
continue
else:
# 2.3.2 将i添加到my_list1 中.
my_list1.append(i)
# 3. 循环结束,得到去重后的列表 my_list1,进行排序
my_list1.sort(reverse=True)
# 4. 输出最后的结果
print(my_list1)
方案 2 暂时不用管后边会学习
使用集合(set), 去重,
set 也是一个容器,具有自动去重的功能(后续会学习)
目前只需要了解即可.
list1 = [11, 4, 45, 34, 51, 90]
list2 = [4, 16, 23, 51, 0]
# 列表拼接
list3 = list1 + list2
# 列表去重
list4 = set(list3)
list5 = list(list4)
# 列表降序输出
list5.sort(reverse=True)
print(list5)
元组()
是什么
- 定义
Tuple
(元组)与列表类似,不同之处在于元组的 元素不能修改
- 元组 表示多个元素组成的序列
- 元组 在
Python
开发中,有特定的应用场景
- 用于存储 一串 信息,数据 之间使用
,
分隔 - 元组用
()
定义 - 元组的 索引 从
0
开始
- 索引 就是数据在 元组 中的位置编号
info_tuple = ("zhangsan", 18, 1.75)
- 命令写法
(1)创建空元组
info_tuple = ()
(2)元组中 只包含一个元素 时,需要 在元素后面添加逗号
info_tuple = (50, )
- tuple 不可变的好处
相对于 list 而言,tuple 是不可变的,这使得它可以作为 dict 的 key,或者扔进 set 里,而 list 则不行。
tuple 放弃了对元素的增删(内存结构设计上变的更精简),换取的是性能上的提升:创建 tuple 比 list 要快,存储空间比 list 占用更小。所以就出现了“能用 tuple 的地方就不用 list”的说法。
多线程并发的时候,tuple 是不需要加锁的,不用担心安全问题,编写也简单多了。
元组常用操作
增
直接在同一个元组上更新是不可行的,但是可以通过拷贝现有的元组片段构造一个新的元组的方式解决。
通过分片的方法让元组拆分成两部分,然后再使用连接操作符(+)合并成一个新元组,最后将原来的变量名(temp)指向连接好的新元组。在这里就要注意了,逗号是必须的,小括号也是必须的!
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
temp = ("龙猫","泰迪","叮当猫")
temp = temp[:2] + ("小猪佩奇",)+temp[2:]
print(temp)
"""
('龙猫', '泰迪', '小猪佩奇', '叮当猫')
Process finished with exit code 0
"""
删
删除元组中的元素:对于元组是不可变的原则来说,单独删除一个元素是不可能的,当然你可以利用切片的方式更新元组,间接的删除一个元素。
__author__ = 'Administrator'
# -*- coding:utf-8 -*-
temp = ('龙猫', '泰迪', '小猪佩奇', '叮当猫')
temp = temp[:2] + temp[3:]
print(temp)
"""
('龙猫', '泰迪', '叮当猫')
Process finished with exit code 0
"""
在日常中很少用del去删除整个元组,因为Python的回收机制会在这个元组不再被使用的时候自动删除。
查
改
- 在
ipython3
中定义一个 元组,例如:info = ()
- 输入
info.
按下TAB
键,ipython
会提示 元组 能够使用的函数如下:
info.count info.index
有关 元组 的 常用操作 可以参照上图练习
t1 = ('aa', 'bb', 'cc', 'bb')
# 1. 下标
# print(t1[0])
# 2. index()
# print(t1.index('bb'))
# print(t1.index('bbb'))
# 3. count()
# print(t1.count('aa'))
# print(t1.count('aaa'))
# 4. len()
print(len(t1))
执行结果如下:
4
循环遍历
- 取值 就是从 元组 中获取存储在指定位置的数据
- 遍历 就是 从头到尾 依次 从 元组 中获取数据
# for 循环内部使用的变量 in 元组
for item in info:
循环内部针对元组元素进行操作
print(item)
- 在
Python
中,可以使用for
循环遍历所有非数字型类型的变量:列表、元组、字典 以及 字符串- 提示:在实际开发中,除非 能够确认元组中的数据类型,否则针对元组的循环遍历需求并不是很多
应用场景
- 尽管可以使用
for in
遍历 元组 - 但是在开发中,更多的应用场景是:
- 函数的 参数 和 返回值,一个函数可以接收 任意多个参数,或者 一次返回多个数据
- 有关 函数的参数 和 返回值,在后续 函数高级 给大家介绍
- 格式字符串,格式化字符串后面的
()
本质上就是一个元组 - 让列表不可以被修改,以保护数据安全
info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)
元组和列表之间的转换
- 使用
list
函数可以把元组转换成列表
list(元组)
- 使用
tuple
函数可以把列表转换成元组
tuple(列表)
字典
字典的定义
-
dictionary
(字典) 是 除列表以外Python
之中 最灵活 的数据类型 - 字典同样可以用来 存储多个数据
- 通常用于存储 描述一个
物体
的相关信息
- 和列表的区别
- 列表 是 有序 的对象集合
- 字典 是 无序 的对象集合
- 字典用
{}
定义 - 字典使用 键值对 存储数据,键值对之间使用
,
分隔
- 键
key
是索引 - 值
value
是数据 - 键 和 值 之间使用
:
分隔 - 键必须是唯一的
- 值 可以取任何数据类型,但 键 只能使用 字符串、数字或 元组
# {} 键值对 各个键值对用逗号隔开
# 1. 有数据的字典: name的值TOM, age的值是20, gender的值是男
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# print(dict1)
# print(type(dict1))
# 2. 创建空字典
dict2 = {}
# print(type(dict2))
dict3 = dict()
print(type(dict3))
执行结果如下:
<class 'dict'>
字典常用操作
- 在
ipython3
中定义一个 字典,例如:xiaoming = {}
- 输入
xiaoming.
按下TAB
键,ipython
会提示 字典 能够使用的函数如下:
In [1]: xiaoming.
xiaoming.clear xiaoming.items xiaoming.setdefault
xiaoming.copy xiaoming.keys xiaoming.update
xiaoming.fromkeys xiaoming.pop xiaoming.values
xiaoming.get xiaoming.popitem
字典类 dict中的三种方法:items()、keys、values()
1、items()方法将字典里对应的一对键和值以元组的形式(键, 值),存储为所生成序列里的单个元素
2、keys()方法将字典里的每个键以字符串的形式,存储为所生成序列里的单个元素
3、values()方法将字典里的每个值以字符串的形式,存储为所生成序列里的单个元素
增
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# 字典序列[key] = 值
# id的值是110
dict1['id'] = 110
print(dict1)
dict1['name'] = 'ROSE'
print(dict1)
执行结果如下:
{'name': 'TOM', 'age': 20, 'gender': '男', 'id': 110}
{'name': 'ROSE', 'age': 20, 'gender': '男', 'id': 110}
删
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# del 删除字典或指定的键值对
# del(dict1)
# print(dict1)
# del dict1['name']
# del dict1['names'] # 报错
# print(dict1)
# clear()
dict1.clear()
print(dict1)
执行结果如下:
{}
查
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# 1. [key]
# print(dict1['name']) # 返回对应的值(key存在)
# print(dict1['names'])
# 2. 函数
# 2.1 get()
# print(dict1.get('name'))
# print(dict1.get('names')) # 如果key不存在,返回None
# print(dict1.get('names', 'Lily'))
# 2.2 keys() 查找字典中所有的key,返回可迭代对象
# print(dict1.keys())
# 2.3 values() 查找字典中的所有的value,返回可迭代对象
# print(dict1.values())
# 2.4 items() 查找字典中所有的键值对,返回可迭代对象,里面的数据是元组,元组数据1是字典的key,元组数据2是字典key对应的值
print(dict1.items())
执行结果如下:
dict_items([('name', 'TOM'), ('age', 20), ('gender', '男')])
改
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# dict1['name'] = 'Lily'
# print(dict1)
dict1['id'] = 110
print(dict1)
执行结果如下:
{'name': 'TOM', 'age': 20, 'gender': '男', 'id': 110}
循环遍历
- 遍历 就是 依次 从 字典 中获取所有键值对
# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:
print("%s: %s" % (k, xiaoming[k]))
提示:在实际开发中,由于字典中每一个键值对保存数据的类型是不同的,所以针对字典的循环遍历需求并不是很多
遍历之key
for循环遍历字典, 默认获取的是key
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
执行结果如下:
name
age
gender
my_dict = {'bookName': 'python', 'price': 100}
for key in my_dict:
print(key)
执行结果如下:
>> bookName
>> price
遍历之value
遍历字典中的每一个value
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
执行结果如下:
TOM
20
男
my_dict = {'bookName': 'python', 'price': 100}
for key in my_dict.values():
print(key)
执行结果如下:
python
100
遍历之键值对
根据key获取value值
my_dict = {'bookName': 'python', 'price': 100}
for key in my_dict:
value = my_dict[key]
print(key, value)
执行结果如下:
bookName python
price 100
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
执行结果如下:
('name', 'TOM')
('age', 20)
('gender', '男')
遍历字典中的每项数据,并且把键值对封装到元祖里面
my_dict = {'bookName': 'python', 'price': 100}
for key in my_dict.items():
print(key)
执行结果如下:
('bookName', 'python')
('price', 100)
遍历之键值对(拆包)
dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# xx.items(): 返回可迭代对象,内部是元组,元组有2个数据
# 元组数据1是字典的key,元组数据2是字典的value
for key, value in dict1.items():
# print(key)
# print(value)
# 目标: key=value
print(f'{key}={value}')
执行结果如下:
name=TOM
age=20
gender=男
利用拆包,使不同的变量保存在容器类型中
my_dict = {'bookName': 'python', 'price': 100}
for key, value in my_dict.items():
print(key, value)
执行结果如下:
bookName python
price 100
应用场景
- 尽管可以使用
for in
遍历 字典 - 但是在开发中,更多的应用场景是:
- 使用 多个键值对,存储 描述一个
物体
的相关信息 —— 描述更复杂的数据信息 - 将 多个字典 放在 一个列表 中,再进行遍历,在循环体内部针对每一个字典进行 相同的处理
card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}
]
05. 公共方法
5.1 Python 内置函数
Python 包含了以下内置函数:
函数 | 描述 | 备注 |
len(item) | 计算容器中元素个数 | |
del(item) | 删除变量 | del 有两种方式 |
max(item) | 返回容器中元素最大值 | 如果是字典,只针对 key 比较 |
min(item) | 返回容器中元素最小值 | 如果是字典,只针对 key 比较 |
cmp(item1, item2) | 比较两个值,-1 小于/0 相等/1 大于 | Python 3.x 取消了 cmp 函数 |
注意
- 字符串 比较符合以下规则: “0” < “A” < “a”
5.2 切片
| 描述 | Python 表达式 | 结果 | 支持的数据类型 |
| :—: | — | — | — | — |
| 切片 | “0123456789”[::-2] | “97531” | 字符串、列表、元组 |
- 切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
- 列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
- 字典 是一个 无序 的集合,是使用 键值对 保存数据
5.3 运算符
运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
+ | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
* | [“Hi!”] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 | 字符串、列表、元组 |
in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
> >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |
注意
-
in
在对 字典 操作时,判断的是 字典的键 -
in
和not in
被称为 成员运算符
成员运算符
成员运算符用于 测试 序列中是否包含指定的 成员
运算符 | 描述 | 实例 |
in | 如果在指定的序列中找到值返回 True,否则返回 False |
|
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False |
|
注意:在对 字典 操作时,判断的是 字典的键
5.4 完整的 for 循环语法
- 在
Python
中完整的for 循环
的语法如下:
for 变量 in 集合:
循环体代码
else:
没有通过 break 退出循环,循环结束后,会执行的代码
应用场景
- 在 迭代遍历 嵌套的数据类型时,例如 一个列表包含了多个字典
- 需求:要判断 某一个字典中 是否存在 指定的 值
- 如果 存在,提示并且退出循环
- 如果 不存在,在 循环整体结束 后,希望 得到一个统一的提示
students = [
{"name": "阿土",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
find_name = "阿土"
for stu_dict in students:
print(stu_dict)
# 判断当前遍历的字典中姓名是否为find_name
if stu_dict["name"] == find_name:
print("找到了")
# 如果已经找到,直接退出循环,就不需要再对后续的数据进行比较
break
else:
print("没有找到")
print("循环结束")