python—变量

fo安方

已于 2022-05-04 08:01:00 修改

阅读量1k

点赞数

文章标签：链表数据结构

于 2022-03-17 06:57:24 首次发布

本文链接：https://blog.csdn.net/stqer/article/details/123541002

版权

文章目录

变量

变量

前言：

是什么：
（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 中，如果 变量名 需要由二个或 多个单词 组成时，可以按照以下方式命名
1. 每个单词都使用小写字母
2. 单词与单词之间使用 _下划线 连接
- 例如：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	有符号十进制整数，`%06d` 表示输出的整数显示位数，不足的地方使用 `0` 补全
%f	浮点数，`%.2f` 表示小数点后只显示两位
%%	输出 `%`

语法格式如下：

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，`全角数字`、`⑴`、`\u00b2`
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 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 `-1`
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	`3 in (1, 2, 3)` 返回 `True`
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	`3 not in (1, 2, 3)` 返回 `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("循环结束")

fo安方

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
python—变量

列表[]（使用最频繁的数据类型）一、列表基本知识定义列表（list），是用方括号[]括起来的一种数据结构，元素和元素之间用逗号分隔，列表中的元素是可以进行增删查改等一系列操作的，列表通常这样表示：列表名 = [元素1,元素2,元素3]●命令：列表用[]定义，数据之间使用，分隔●特点：list(列表)是Python中使用最频繁的数据类型，在其他语言中通常叫做数组，专门用于存储一串信息（存放多个数据，数据可以是任意类型）●索引：索引就是数据在列表中的位置编号，索引又可以被称为下标，列表的索引
复制链接

扫一扫