【Python基础入门学习】Python高级变量你了解多少？

1. 列表 list

1.1 列表的定义

1. list（列表）是python中使用最频繁的数据类型，在其他语言中被称为数组
2. 列表是用于存储一串数据，存储的数据称为元素
3. 列表用 []，元素之间使用，分隔
4. 列表的索引从 0 开始
   索引就是元素在列表中的位置编号，索引又可以被称为下表
   

name_list = ["zhangsan", "lisi", "wangwu"]
# 取出列表中元素的值
print(name_list[0])
print(name_list[1])
print(name_list[2])  
# 输出 lisi

当从列表中取值时，如果超出索引范围，程序会报错

1.2 列表常用操作

序号	分类	关键字/函数/方法	解释
1	增加	列表.append(数据)	在末尾追加数据
		列表.insert(索引, 数据)	在指定位置插入数据(位置前有空元素会补位)
		列表.extend(Iterable)	将可迭代对象中的元素追加到列表
2	删除	del 列表[索引]	删除指定索引的数据
		列表.remove(数据)	删除第一个出现的指定数据
		列表.pop()	删除末尾数据，返回被删除的元素
		列表.pop(索引)	删除指定索引数据
		列表.pop(索引)	清空列表
3	修改	列表[索引] = 数据	修改指定索引的数据，数据不存在会报错
4	查询	列表[索引]	根据索引取值，索引不存在会报错
		列表.index(数据)	根据值查询索引，返回首次出现时的索引，没有查到会报错
		列表.count(数据)	数据在列表中出现的次数
		len(列表)	列表长度
		if 数据 in 列表:	检查列表中是否包含某元素
5	排序	列表.sort()	升序排序
		列表.sort(reverse=True)	降序排序
		列表.reverse()	逆序、反转

1. list1.extend(list2)，把list2和list1拼到一个list里，一次性给list里加多个元素
2. del 是关键字，关键字后面没有括号，通用语法，还可以删除别的东西
3. len是函数，因为后面有括号，还可以求字符串的长度

num_list=[1,2,3,4,5]
num_list.append(6)
print(num_list)
# 下标为1的位置插入8
num_list.insert(1,8)
print(num_list)
list2=['tom','cat']
num_list.extend(list2)
print(num_list)

4. list.pop()有返回值，可以赋给一个变量

num_list=[1,2,3,4,5]
num=num_list.pop()
print(num)
print(num_list)

5. 一个list里元素类型可以不同，但是不同类型不能排序

#将列表中所有的3修改为8
num_list=[1,2,3,4,4,3,5]
n=0
c=num_list.count(3)
while n<c:#这里不能写成n<num_list.count(3)，因为每次循环改了个3，count次数就变少了i=num_list.index(3)num_list[i]=8n+=1
print(num_list)

关键字、函数和方法

1. 关键字是 Python 内置的、具有特殊意义的标识符

import keyword
print(keyword.kwlist)

2. 函数封装了独立功能，可以直接调用

函数名(参数)

3. 方法和函数类似，同样是封装了独立的功能
4. 方法需要通过对象来调用，表示针对这个对象要做的操作

对象.方法名(参数)

1.3 循环遍历

1. 遍历就是从头到尾依次从列表中取出每一个元素，并执行相同的操作
2. Python中实现遍历的方式很多，比如while循环、for循环、迭代器等

# while循环实现列表的遍历
i = 0
name_list = ["apple", "peach", "pear"]
list_count = len(name_list)
while i < list_count:name = name_list[i]print(name)i += 1

3. Python为了提高列表的遍历效率，专门提供for循环实现遍历
4. Python中for循环的本质是迭代器

# for 实现列表的遍历
name_list = ["apple", "peach", "pear"]
for name in name_list:# 循环内部针对列表元素进行操作print(name)

1.4 列表嵌套

1. 类似while循环的嵌套，列表也是支持嵌套的
2. 一个列表中的元素又是一个列表，那么这就是列表的嵌套

i=1
l1=[]
l2=[]
l3=[]
while i <= 100:if i % 3 == 1:l1.append(i)elif i % 3 == 2:l2.append(i)else:l3.append(i)i += 1
print(l1,'\n',l2,'\n',l3)
list=[]
list.append(l1)
list.append(l2)
list.append(l3)
print(list)

1.5 应用场景

1. 尽管Python的列表中可以存储不同类型的数据
2. 但是在开发中，更多的应用场景是
   a. 列表存储相同类型的数据
   b. 通过for循环，在循环体内部，针对列表中的每一项元素，执行相同的操作

2. 元组 tuple

2.1 元组的定义

1. 元组用（）定义
2. 用于存储一串数据、元素之间使用‘,’分割
3. 元组的索引从0开始

# 定义元组
info_tuple = ("lxd", 22, 183)
# 取出元素的值
print(info_tuple[0],info_tuple[1])  

4. 元组中只包含一个元素时，需要在元素后面添加逗号

info_tuple = (50,)
print(info_tuple)

2.2 元组常用操作

1. Tuple（元组）与列表类似，不同之处在于元组的元素不能修改----元祖是常量，列表是变量
2. 变化的数据不能存在元祖里

info_tuple = ("lxd", 18, 1.75)
# 程序报错
info_tuple[0] = "lisi"  

序号	分类	关键字	含义
1	查询	元组[索引]	根据索引取值，索引不存在会报错
		元组.index(数据)	根据值查询索引，返回首次出现时的索引，没有查到会报错
		元组.count(数据)	数据在元组中出现的次数
		len(列表)	元组长度
		if 数据 in 元组:	检查元组中是否包含某元素
2	遍历	for 数据 in 元组:	取出元组中的每个元素

2.3 应用场景

作为自动组包的默认类型

info = 10, 20
print(type(info))  # 输出类型为 tuple
# 交换变量的值
a = 10
b = 20
a, b = b, a  # 先自动组包，后自动解包

1. 格式字符串，格式化字符串后面的（）本质上就是一个元组

info = ("lxd", 22)
print("%s 的年龄是 %d" % info)

2. 让列表不可以被修改，以保护数据安全
   元组和列表之间的转换
   使用 tuple 函数 把列表转换成元组：list1 = [10, 11] tuple1 = tuple(list1)
   使用 list 函数 把元组转换成列表：list1 = list(tuple1)

3. 字典 dictionary

3.1 字典的含义

1. dictionary（字典）是除列表以外Python之中最灵活的数据类型
2. 字典同样可以用来存储多个数据
   ○ 通常用于存储描述一个物体的相关信息
3. 字典用{ }定义
4. 字典使用键值对存储数据，键值对之间使用,分隔
   ○ 键key是索引
   ○ 值value是数据
   ○ 键和值之间使用:分隔
   ○ 值可以取任何数据类型，但键只能使用字符串、数字或元组
   ○ 键必须是唯一的
   

# 定义字典
people = {"name": "小明","age": 18,"gender": True,"height": 1.75}
# 取出元素的值
print(people["name"])

3.2 字典常用操作

序号	分类	关键字/函数/方法	含义
1	增加	字典[键] = 数据	键不存在，会添加键值对；键存在，会修改键值对的值
2	删除	del 字典[键]	删除指定的键值对
		字典.pop(键)	删除指定键值对,返回被删除的值
		字典.clear	清空字典
3	修改	字典[键] = 数据	键不存在，会添加键值对；键存在，会修改键值对的值
		字典.setdefault(键，数据)	键值对不存在，添加键值对；存在则不做处理
		字典.update(字典2)	取出字典2的键值对，键值对不存在，添加键值对；存在则修改值
4	查询	字典[键]	根据键取值，键值对不存在会报错
		字典.get(键)	字典.get(键) 根据键取值，键值对不存在不会报错
		字典.keys()	可进行遍历，获取所有键
		字典.values()	可进行遍历，获取所有值
		字典.items()	可进行遍历，获取所有(键，值)
5	遍历	for key in 字典	取出字典中的每个元素的key

3.3 应用场景

在开发中，字典的应用场景是：
○ 使用多个键值对，存储描述一个物体的相关信息—— 描述更复杂的数据信息
○ 将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理

card_list = [{"name": "张三","qq": "12345","phone": "110"},{"name": "李四","qq": "54321","phone": "10086"}]
print(card_list)

4. 字符串 string

4.1 字符串的定义

1. 字符串就是一串字符，是编程语言中表示文本的数据类型
2. 在 Python 中可以使用一对双引号"或者一对单引号’定义一个字符串
   ○ 虽然可以使用"或者’做字符串的转义，但是在实际开发中：
   ■ 如果字符串内部需要使用 "，可以使用 ’ 定义字符串
   ■ 如果字符串内部需要使用 '，可以使用 " 定义字符串
3. 可以使用索引获取一个字符串中指定位置的字符，索引计数从0开始
4. 也可以使用for循环遍历字符串中每一个字符

string = "Hello Python"
for c in string:print(c)

字符串取对应索引的字符：可以用负的索引你，从右往左，-1，-2……

string='12345'
print(string[0],string[1],string[2],string[3],string[4])
print(string[-5],string[-4],string[-3],string[-2],string[-1])

4.2 字符串常用操作

4.2.1 判断

方法	含义
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True

4.2.2 查找和替换

方法	含义
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 次

sart和end可以省略：左闭右开，start那个位置查找，end那个索引值不查找

4.2.3 拆分和连接

方法	含义
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’)分隔
string1 + string2	拼接两个字符串
string.join(seq)	返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串，这里的seq不是字符串，可用是元祖、列表

左边或右边没有字符串，返回就是空串

str='hello world,hello python'
print(str.partition('hello'))str='hello \t world \t hello \t python'
print(str.split())
# 指定以 ，作为分隔符切一次
str='hello,world,hello,python'
print(str.split(',',1))

4.2.4 大小写转换

方法	含义
string.lower()	返回新字符串，转换 string 中的大写字母为小写
string.upper()	返回新字符串，转换 string 中的小写字母为大写

4.2.5 文本对齐

方法	含义
string.ljust(width)	返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width
string.rjust(width)	返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width
string.center(width)	返回新字符串，基于原字符串居中，并使用空格填充至长度 width

# 把list里每个字符串长度都变成6，左右用空格填充
str_list=['a','hello','abc']
for s in str_list:print(s.center(6))

4.2.6 去除空白字符

方法	含义
string.lstrip()	返回新字符串，截掉 string **左边（开始）**的空白字符
string.rstrip()	返回新字符串，截掉 string **右边（末尾）**的空白字符
string.strip()	返回新字符串，截掉 string 左右两边的空白字符

列表除了查询方法和pop方法都没有返回值，字符串所有方法都有返回值

4.3 字符串的切片

1. 切片译自英文单词slice，翻译成另一个解释更好理解:一部分
2. 切片使用索引值来限定范围，根据步长从原序列中取出一部分元素组成新序列
3. 切片方法适用于字符串、列表、元组

字符串[开始索引:结束索引:步长]

注意：

1. 指定的区间属于左闭右开型：[开始索引, 结束索引)对应开始索引 = 范围 < 结束索引
   ○ 从起始位开始，到结束位的前一位结束（不包含结束位本身)
2. 从头开始，开始索引数字可以省略，冒号不能省略
3. 到末尾结束，结束索引数字和冒号都可以省略
4. 步长默认为1，如果元素连续，数字和冒号都可以省略

str='hello,world,abc,python'
print(str[0:5:2])

4.3.1 索引的顺序和倒序

1. 在 Python 中不仅支持顺序索引，同时还支持倒序索引
2. 所谓倒序索引就是从右向左计算索引
   ○ 最右边的索引值是**-1**，依次递减
3. 注意：如果步长为负数
   ○ 并省略了开始索引，则开始索引表示最后一位
   ○ 并省略了结束索引，则结束索引表示第一位

反向（从右往左），步长是负数 ，-1，-2不能省略，开始的死闭区间（右边），结束的是开区间（左边）

str='hello'
print(str[-3:-5:-1])

4.3.2 练习需求

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])

5. 公共语法

5.1 python 内置函数

函数	描述
len(item)	计算容器中元素个数
del(item)	删除变量
max(item)	返回容器中元素最大值
min(item)	返回容器中元素最小值
cmp(item1, item2)	比较两个值，-1 小于/0 相等/1 大于

注意
● 字符串比较符合以下规则： “0” < “A” < “a”
● del list[1]，del(list[1])都可以

5.2 切片

描述	Python 表达式	结果	支持的数据类型
切片	“0123456789”[::-2]	“97531”	字符串、列表、元组

1. 切片使用索引值来限定范围，从一个大的字符串中切出小的字符串
2. 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
3. 字典是一个无序的集合，是使用键值对保存数据。字典无序不能切片

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被称为成员运算符

成员运算符

1. 成员运算符用于测试序列中是否包含指定的成员
2. 注意：在对字典操作时，判断的是字典的键

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False	3 in (1, 2, 3)返回True
not in	如果在指定的序列中没有找到值返回 True，否则返回 False	3 not in (1, 2, 3)返回False

5.4 for … else 语法

在Python中，循环语句支持else， 语法如下：

for 变量 in 集合:循环体代码break
else:没有通过 break 退出循环，循环结束后，会执行else这块代码

str='hello'
fs='o'
for char in str:if char==fs:print('找到了')break
else:print('未找到')

应用场景

1. 在迭代遍历嵌套的数据类型时，例如一个列表包含了多个字典
2. 需求：要判断 某一个字典中 是否存在 指定的 值
   ○ 如果存在，提示并且退出循环
   ○ 如果不存在，在循环整体结束后，希望得到一个统一的提示

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_nameif stu_dict["name"] == find_name:print("找到了")# 如果已经找到，直接退出循环，就不需要再对后续的数据进行比较break
else:print("没有找到")
print("循环结束")