在 Python 中定义变量是 不需要指定类型
数据类型可以分位 数字型 和 非数字型
-
数字型
- 整型（int）
- 浮点型（float）
- 布尔型（bool）
- 真 true 非 0 数 —— 非零即真
- 假 False 0
- 复数型（complex）
- 主要用于科学计算
-
非数字型
- 字符串
- 列表
- 元组
- 字典
注：使用 type函数可以查看一个变量的类型
- 在Python 中，所有 非数字型变量 都支持以下特点：
- 都是一个序列sequence,
- 取值 []
- 遍历 for in
- 计算长度、最大/最小值、比较、删除
- 链接 + 和重复 *
- 切片
变量的引用
- 变量和数据都是保存在内存中的
- 在Python 中函数的参数传递 以及 返回值都是靠引用传递的
在Python中
- 变量和数据 是分开存储的
- 数据保存在内存中的一个位置
- 变量中保存着数据在内存中的地址
- 变量中记录数据的地址，就叫做引用
- 使用
id() 函数可以查看变量中保存数据所在的 内存地址
注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用
- 变量 不再对之前的数据引用
- 变量 改为 对新赋值的数据引用
示例：
def test(num):
print("在函数内部 %d 对应的内存地址是 %d" % (num, id(num)))
# 1> 定义一个字符串变量
result = "vvcat"
print("函数要返回数据的内存地址是 %d" % id(result))
# 2> 将字符串变量返回,返回的是数据的引用，而不是数据本身
return result
# 1. 定义一个数字的变量
a = 5
# 数据的地址本质上就是一个数字
print("a 变量保存数据的内存地址是 %d" % id(a))
# 2. 调用 test 函数，本质上传递的是实参保存数据的引用，而不是实参保存的数据
r = test(a)
print("%s 的内存地址是 %d" % (r, id(r)))
可变和不可变类型
- 不可变类型，内存中的数据不允许被修改：
- 数字类型 int, bool, float, complex
- 字符串 str
- 元组 tuple
- 可变类型，内存中的数据可以被修改：
- 列表 list
- 字典 dict
注：字典的 key 只能使用不可变类型的数据
1.可变类型的数据变化，是通过方法来实现的
2. 如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
- 变量不再对之前的数据引用
- 变量改为对新赋值的数据引用
示例：
# 列表
a = [1, 2, 3]
print(id(a))
a.append(567)
print(a)
print(id(a)) # 引用不发生改变
a.remove(3)
print(a)
print(id(a)) # 引用不发生改变
a.clear()
print(a)
print(id(a)) # 引用不发生改变
# 字典
d = {"name": "vvcat"}
print(d)
d["age"] = 15
print(d)
print(id(d)) # 引用不发生改变
d.pop("age")
print(d)
print(id(d)) # 引用不发生改变
d.clear()
print(d)
print(id(d)) # 引用不发生改变
d = {} # 赋值了一个新的数据，引用会修改
print(id(d))
哈希（hash）
- Python 中内置头一个名字叫做 hash(o)的函数
- 接收一个 不可变类型的数据作为参数
- 返回 结果是一个整数
- 哈希是一种算法，其作用就是提取数据的特征码（指纹）
- 相同的内容得到相同的结果
- 不同的内容得到不同的结果
- 在Python中，设置字典的键值对时，会首先对 key 进行 hash 已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增、删、改、查
- 键值对的 key 必须是不可变类型数据
- 键值对的 value 可以是任意类型的数据
示例：
d = {}
d["name"] = "vvcat"
print(d)
d[1] = "整数"
print(d)
d[(1,)] = "元组"
print(d)
# TypeError: unhashable type: 'list'
# d[[1, 2, 3]] = "列表"
print(d)
# TypeError: unhashable type: 'dict'
# d[{"n": "xxx"}] = "字典"
# print(d)
print(hash(1))
print(hash("vvcat"))
print(hash("vvcat1"))
print(hash((1,)))
# TypeError: unhashable type: 'list'
# print(hash([]))
# TypeError: unhashable type: 'dict'
# print(hash({}))
不同类型变量之间的计算
1）数字型变量之间可以直接计算
- 在Python中，两个数字型变量是可以直接进行 算数运算的
- 如果变量是 bool 型，在计算时
- True 对应的数字是 1
- False 对应的数字是 0
整型 + 整型 = 整型
整型 + 布尔型 = 整型
整型 + 浮点型 = 浮点型
浮点型 + 浮点型 = 浮点型
浮点型 + 布尔型 = 浮点型
布尔型 + 布尔型 = 整型
2）字符串变量之间使用 + 拼接字符串
- 在Python中，字符串之间可以使用 + 拼接生成新的字符串
例如：
str1 = "Hello"
str2 = "World"
str1 + str2
'Hello World'
3）字符串变量 可以和 整数 使用 * 重复拼接相同的字符串
"-" * 10
'----------'
4）数字型变量 和 字符串 之间 不能进行其他计算
name = "vvcat"
x = 5
x + name
类型错误：“+” 不支持的操作类型：‘int’ 和 ‘str’
变量的输入
- 在Python 中，如果要获取用户在键盘上的输入信息，需要输入信息，需要使用到 input 函数
注：用户输入的 任何内容 Pyhton 都认为是一个字符串
5）类型转换函数
| 函数 | 说明 |
|---|---|
| int(x) | 将 x 转换为一个整数 |
| float(x) | 将 x 转换到一个浮点数 |
6）变量的格式化输出
- %被称为
格式化操作符，专门用于处理字符串中的格式- 包含 % 的字符串，被称为 格式化字符串
- % 和不同 字符连用，不同类型的数据需要使用不同的格式化字符
| 格式化字符 | 含义 |
|---|---|
| %s | 字符串 |
| %d | 有符号十进制整数，%06d表示输出的整数显示位数，不足的地方使用0补全, 足够6位的显示原有的数字 |
| %f | 浮点数，%.02f 表示小数点后只显示两位 |
| %% | 输出% |
- 语法格式如下：
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))
例如：
name = "vvcat"
print("我的名字叫 %s, 请多多关照！" % name)
# 不足6位的前面 补0，足够6位的显示原有的数字
student_no = 30
print("我的学号是 %06d" % student_no)
price = 11.2
weight = 5
money = price * weight
print("苹果单价 %.2f 元 / 斤, 购买 %.02f斤， 需要支付 %.02f 元" % (price, weight, money))
scale = 0.25
print("数据比例是 %.02f%%" % (scale * 100))
Python 关键字查看
通过以下代码可以查看 Python 中的关键字
import keyword
print(keyword.kwlist)
字符串中的转义字符
- \t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐
- \n 在控制台输出一个换行符
制表符的功能是在不使用表格的情况下在垂直方向 按列对齐文本
| 转义字符 | 描述 |
|---|---|
| \\ | 反斜杠符号 |
| \’ | 单引号 |
| \" | 双引号 |
| \n | 换行 |
| \t | 横向字符表 |
| \r | 回车 |
列表
1.1 列表的定义
- List （列表）是 Python 中使用最频繁的数据类型，在其他语言中通常叫做 数组
- 专门用于存储一串信息
- 列表用 [] 定义，数据之间使用，分隔
- 列表的索引从0开始
- 索引就是数据在列表中的位置编号，索引又可以被称为下标
注意：从列表中取值时，如果超出索引范围，程序会报错
1.2列表常用操作：
-
在 python3中定义一个列表
例如：
str_list = [] -
列表能够使用的方法如下：
| 序号 | 分类 | 关键字/函数/方法 | 说明 |
|---|---|---|---|
| 1 | 增加 | 列表.insert(索引，数据) | 在指定位置插入数据 |
| 列表.append(数据) | 在末尾追加数据 | ||
| 列表.extend(列表2) | 将列表2 的数据追加到列表 | ||
| 2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
| 3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
| 列表.remove[数据] | 删除第一个出现的指定数据 | ||
| 列表.pop | 删除末尾数据 | ||
| 列表.pop(索引) | 删除指定索引数据 | ||
| 列表.clear | 清空列表 | ||
| 4 | 统计 | len(列表) | 列表长度 |
| 列表.count(数据) | 数据在列表中出现的次数 | ||
| 5 | 排序 | 列表.sort() | 升序排序 |
| 列表.sort(reverse=True) | 降序排序 | ||
| 列表.reverse() | 逆序、反转 |
注：Python 的列表中可以 存储不同类型的数据
循环遍历
- 遍历 就是 从头到尾依次 从 列表 中获取数据
- 在循环体内部 针对 每一个元素，执行相同的操作
- 在 Python 中为了提高列表的遍历效率，专门提供的 迭代遍历
- 使用 for 就能够实现迭代遍历
# for 循环内部使用的变量 in 列表
for name in name_list:
循环内部针对列表元素进行操作
print(name)
for 变量 in 集合:
循环体代码
else:
没有通过break 退出循环，循环结束后，会执行的代码
例如：
for num in [1, 2, 3, 4, 5]:
print(num)
if num == 3:
break
else:
# 如果循环体内部使用 break 退出了循环
# else 下方的代码就不会被执行
print("else 下方的代码被执行了")
print("循环结束")
元组
2.1 元组的定义
- Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改
- 元组表示多个元素组成的序列
- 用于存储 一串 信息，数据之间使用 ，分隔
- 元组用（）定义
- 元组的索引从 0 开始
- 索引就是数据在 元组 中的位置编号
创建空元组
tuple_info = ()
元组中只包含一个元素时，需要在元素后面添加逗号
tuple_info = (6, )
如果在定义元组变量时，元组只包含一个元素，没有添加逗号，会根据这个元素的类型，进行转换
例如：
single_tuple = (6)
print(type(single_tuple)) # 输出结果为 <class 'int'>
2.2 元组常用操作
-
在 python3中定义一个元组
例如：
tuple_info = [] -
列表能够使用的方法如下：
| 序号 | 分类 | 关键字/函数/方法 | 说明 |
|---|---|---|---|
| 1 | 查找 | 元组.index(数据) | 根据已知元组的数据，查找该数据在元组中的索引 |
| 2 | 统计 | len(元组) | 元组长度 |
| 元组.count(数据) | 数据在元组中出现的次数 |
2.3 循环遍历
# for 循环内部使用的变量 in 列表
for item in tuple_info:
循环内部针对元组元素进行操作
print(item )
- 在Python中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典、以及字符串。
2.4 元组在格式化字符串中的应用
- 格式字符串，格式化字符串后面的（）本质上就是一个元组
例如：
info_tuple = ("vvcat", 12, 1.45)
# 格式化字符串后面的 '()' 本质上就是元组
print("%s 年龄是 %d 身高是 %.2f" % info_tuple)
info_str = "%s 年龄是 %d 身高是 %.2f" % info_tuple
print(info_str)
2.5 元组和列表之间的转换
- 使用 list 函数可以把元组转换成列表
list(元组)
- 使用 tuple 函数可以把列表转换成元组
tuple(列表)
字典
3.1 字典的定义
- 字典是 除列表意外 Python之中最灵活的数据类型
- 字典同样可以用来存储多个数据类型
- 通常用于存储 描述一个 物体 的相关信息
- 和列表的区别
- 列表是有序的 对象集合
- 字典是无序的对象集合
- 字典用 {} 定义
- 字典使用 键值对存储数据，键值对之间使用 ，分隔
- 键 key 是索引
- 值 value 是数据
- 键 和 值 之间使用 ：分隔
- 键必须是唯一的
- 值 可以取任何数据类型，但 键 只能使用 字符串、数字或元组
3.2 字典的增删改查
vvcat_dict = {"name": "vv"}
# 1. 取值
print(vvcat_dict["name"])
# 在取值的时候，如果指定的key不存在，程序会报错！
# print(vvcat_dict["name123"])
# 2. 增加/修改
# 如果Key不存在，会新增键值对
vvcat_dict["age"] = 18
# 如果Key存在，会修改已经存在的键值对
vvcat_dict["name"] = "vvcat"
print(vvcat_dict)
# 3.删除
vvcat_dict.pop("name")
# 在删除指定键值对的时候，如果指定的key不存在，程序会报错！
# vvcat_dict.pop("name123")
print(vvcat_dict)
3.3 字典常用操作
-
在 python3中定义一个字典
例如：
dict_info = {} -
字典能够使用的方法如下：
| 序号 | 分类 | 关键字/函数/方法 | 说明 |
|---|---|---|---|
| 1 | 取值 | 字典[key] | 可以从字典中取值， key 不存在会报错 |
| 字典.get(key) | 可以从字典中取值， key 不存在不会报错 | ||
| 2 | 修改 | 字典[key] = value | 如果 key 存在，修改数据; 如果 key 不存在，新建键值对 |
| 字典.setdefault(key, value) | 如果 Key 存在，不会修改数据; 如果 key 不存在，新建键值对 | ||
| 字典.update(字典2) | 将字典 2 的数据合并到字典1，如果字典2和字典1有重复的键值对，字典2的重复的键值对将会覆盖字典1的键值对 | ||
| 3 | 删除 | del 字典[key] | 删除指定键值对， key 不存在会报错 |
| 字典.popitem() | 随机删除一个键值对 | ||
| 字典.pop(key) | 删除指定键值对，key 不存在会报错 | ||
| 字典.clear | 清空列表 | ||
| 4 | 统计 | len(字典) | 获取字典的键值对数量 |
| 5 | 查看 | 字典.keys() | 所有 key 列表 |
| 字典.values() | 所有 value 列表 | ||
| 字典.items() | 所有 (key, value) 元组列表 |
3.4 循环遍历
- 遍历就是依次从字典中获取所有键值对
vvcat_dict = {"name": "vvcat",
"age": "18",
"gender": "男"}
# 迭代遍历字典
# 变量k是每一次循环中，获取到的键值对的key
for k in vvcat_dict:
print("%s- %s" % (k, vvcat_dict[k]))
将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理
# 使用 多个键值对，存储 描述一个 物体的相关信息——描述更复杂的数据信息
# 将 多个字典 放在 一个列表 中，再进行遍历
card_list = [
{"name": "vvcat",
"age": 15,
"gender": True,
"height": 1.55,
"weight": 55.5},
{"name": "vvcat",
"age": 18,
"gender": True,
"height": 1.75,
"weight": 75.5}
]
# 遍历列表
for card_info in card_list:
print(card_info)
# 遍历列表中的字典
for card_info in card_list:
print()
for k in card_info:
print("%s- %s" % (k, card_info[k]))
- 在 Python 中完整的for循环的语法如下：
for 变量 in 集合:
循环体代码
else:
没有通过break 退出循环，循环结束后，会执行的代码
示例：
students = [
{"name": "张三"},
{"name": "李四"}
]
# 在列表中搜索指定的姓名
find_name = "vvcat"
for stu_dict in students:
print(stu_dict)
if stu_dict["name"] == find_name:
print("找到了 %s" % find_name)
# 如果已经找到，应该直接退出循环，而不再变量后续的元素
break
else:
# 如果希望在搜索列表时，所有的字典检查之后，都没有发现需要搜索的目标
# 还希望得到一个统一的提示！
print("抱歉没有找到 %s" % find_name)
print("循环结束")
字符串
4.1 字符串的定义
- 字符串就是一串字符，是编程语言中表示文本的数据类型
- 在Python中可以使用 一对双引号 " 或者 一对单引号 ’ 定义一个字符串
- 虽然可以使用 " 或者 ’ 做字符串的转义，但是在实际开发中：
- 如果字符串内部㤇使用 " , 可以使用 ’ 定义字符串
- 如果字符串内部㤇使用 ’ , 可以使用 " 定义字符串
- 虽然可以使用 " 或者 ’ 做字符串的转义，但是在实际开发中：
- 可以使用 索引获取一个字符串中 指定位置的字符，索引计数从 0 开始
- 也可以使用 for 循环遍历字符串中每一个字符
string = "Hello World"
for s in string:
print(s)
4.2 字符串的常用操作
-
在 python3中定义一个字符串，
例如：
string = “” -
字符串能够使用的方法如下：
1）判断类型
| 方法 | 说明 |
|---|---|
| string.isspace() | 如果 string 中只包含空格，则返回 True |
| string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True |
| string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回True |
| string.isdecimal() | 如果 string 只包含数字则返回 True, 全角数字 |
| string.isdigit() | 如果 string 只包含数字怎返回 True, 全角数字、(1)、\u00b2 |
| string.isnumeric() | 如果 string 只包含数字则返回 True, 全角数字，汉字数字 |
| string.istitle() | 如果 string 是标题化的（每个单词的首字母大写）则返回 True |
| string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写,则返回 True，否则返回 False |
| string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些（区分大写小的）字符都是大写,则返回 True，否则返回 False |
2）查找和替换
| 方法 | 说明 |
|---|---|
| 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, 如果 num 指定，则替换不超过 num 次 |
3）大小写转换
| 方法 | 说明 |
|---|---|
| string.capitalize() | 把字符串的第一个字符大写 |
| string.title() | 把字符串的每个单词首字母大写 |
| string.lower() | 转换 string 中所有大写字符为小写 |
| string.upper() | 转换 string 中的小写字母为大写 |
| string.swapcase() | 翻转 string 中的大小写 |
4）文本对齐
| 方法 | 说明 |
|---|---|
| string.ljust(width) | 返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串 |
| string.rjust(width) | 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串 |
| string.center(width) | 返回一个原字符串居中，并使用空格填充至长度 width 的新字符串 |
例如：
poem = ["落花",
"李商隐",
"高阁客竟去",
"小园花乱飞",
"参差连曲陌",
"迢递送斜晖",
"肠断未忍扫",
"眼穿仍欲归",
"芳心向春尽",
"所得是沾衣"]
for poem_str in poem:
print("|%s|" % poem_str.ljust(10, " "))
print("------------------------------")
for poem_str in poem:
print("|%s|" % poem_str.rjust(10, " "))
print("------------------------------")
for poem_str in poem:
print("|%s|" % poem_str.center(10, " "))
5）去除空白字符
| 方法 | 说明 |
|---|---|
| string.lstrip() | 截掉 string 左边（开始）的空白字符 |
| string.rstrip() | 截掉 string 右边（末尾）的空白字符 |
| string.strip() | 截掉 string 左右两边的空白字符 |
6）拆分和连接
| 方法 | 说明 |
|---|---|
| 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 中所有的元素（的字符串表示）合并为一个新的字符串 |
例如：
poem_str = "落花 \t 李商隐\t 高阁客竟去\t\n 小园花乱飞\t\t 参差连曲陌\t 迢递送斜晖\t\n 肠断未忍扫\t\t 眼穿仍欲归\t\t 芳心向春尽\t\t 所得是沾衣\t\n"
print(poem_str)
# 1. 拆分字符串
poem_list = poem_str.split()
print(poem_list)
# 2. 合并字符串
result = " ".join(poem_list)
print(result)
4.3 字符串的切片
-
切片方法适用于字符串、列表、元组
- 切片使用索引值 来限定范围，从一个大的字符串中切出小的字符串
- 列表和元组都是有序的集合，都能够通过索引值获取到对应的数据
- 字典是一个无序的集合，是使用键值对保存数据
字符串[开始索引:结束索引:步长]
注意：
1.指定的区间属于 左闭右开 型 [开始索引，结束索引] → 开始索引 >= 范围 < 结束索引
- 从 起始 位开始，到结束 位的前一位结束（不包含结束位本身）
2.从头开始，开始哟因 数字可以省略，冒号不能省略
3.到末尾结束，结束索引数字可以省略，冒号不能省略
4.步长默认为1，如果连续切片，数字和冒号都可以省略
例如：
num_str = "0123456789"
# 1.截取从 2 ~ 5位置的字符串
print(num_str[2:6])
# 2.截取从 2 ~ 末尾的字符串
print(num_str[2:])
# 3.截取从 开始 ~ 5 位置的字符串
print(num_str[0:6])
print(num_str[:6])
# 4.截取完整的字符串
print(num_str[:])
# 5.从开始位置，每隔一个字符截取字符串
print(num_str[::2])
# 6.从索引 1 开始，每隔一个字符截取字符串
print(num_str[1::2])
# 7.截取从 2 ~ 末尾 -1 的字符串
# print(num_str[-1])
print(num_str[2:-1])
# 8.截取字符串末尾两个字符
print(num_str[-2:])
# 9.字符串的逆序
# print(num_str[0::-1])
print(num_str[-1::-1])
print(num_str[::-1])
# 字符串逆序从索引 1 开始，每隔一个字符截取字符串
print(num_str[::-2])
5. 公共方法
5.1 Python 内置函数
Python 包含了以下内置函数：
| 函数 | 描述 | 备注 |
|---|---|---|
| len(item) | 计算容器中元素个数 | |
| del(item) | 删除变量 | del有两种方式 |
| max(item) | 返回容器中元素最大值 | 如果是字典，只针对 key 比较 |
| min(item) | 返回容器中元素最小值 | 如果是字典，只针对 key 比较 |
注意
- 字符串比较符合以下规则：“0” < “A” < “a”
例如：
# 删除变量
a = [1, 2, 3]
del a[1]
print(a)
del(a[1])
print(a)
del(a)
# print(a)
# 返回容器中元素最大值 最小值
t_str = "qwertyuiopasdfghjklzxcvbnm"
print(max(t_str))
print(min(t_str))
t_list = [5, 2, 4, 8, 1]
print(max(t_list))
print(min(t_list))
# 如果是字典，只针对 key 比较
t_dict = {"a": "z", "b" : "y", "c": "x"}
print(max(t_dict))
print(min(t_dict))
# 字符串比较符合以下规则：“0” < “A” < “a”
print("1" < "2")
print("1" > "2")
print("aaaa" < "bbbb")
print([1, 1, 1] < [2, 2, 2])
print((1, 1, 1) < (2, 2, 2))
#TypeError: '<' not supported between instances of 'dict' and 'dict'
print({"a": "z"} < {"b": "y"})
5.2 运算符
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| * | [“Python”] * 5 | [“Python”, “Python”, “Python”, “Python”, “Python”] | 重复 | 字符串、列表元组 |
| in | 2 in (1, 2, 3, 4, 5) | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 6 not in (1, 2, 3, 4, 5) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
| > >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |
注意：
- in 在对字典 操作时，判断的是 字典的键
- in 和 not in 被称为 成员运算符
例如：
print([1, 2] * 5) # 输出结果：[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
print((1, 2) * 5) # 输出结果：(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)
# TypeError: unsupported operand type(s) for *: 'dict' and 'int'
# {"a" : "z"} * 3
print((1, 2) + (3, 4, 5)) # 输出结果： (1, 2, 3, 4, 5)
print([1, 2] + [3, 4] + [5,]) # 输出结果：[1, 2, 3, 4, 5]
t_list = [1, 2]
# 与 + 的区别，+ 会产生一个新的列表，而extend()方法会修改原有的列表
t_list.extend([3, 4])
print(t_list) # 输出结果：[1, 2, 3, 4]
t_list.append(0)
print(t_list) # 输出结果：[1, 2, 3, 4, 0]
# append()方法把追加的列表元素看作是一个单独的元素，追加到原列表中
t_list.append([7, 8])
print(t_list) # 输出结果： [1, 2, 3, 4, 0, [7, 8]]
成员运算符
成员运算符用于测试序列中是否包含指定的成员
| 运算符 | 描述 |
|---|---|
| in | 如果在指定的序列中找到值返回 True, 否则返回False |
| not in | 如果在指定的序列中没有找到值返回 True, 否则返回 False |
注意：在对字典操作时，判断的是 字典的键
例如：
print("b" in "abcdefg") # 结果返回 True
print("a" not in "abcde") # 结果返回 False
print(2 in [0, 1, 2]) # 结果返回 True
print(1 not in [0, 1, 2]) # 结果返回 False
print("a" in {"a": "vvcat"}) # 结果返回 True
print("vvcat" in {"a": "vvcat"}) # 结果返回 False
6. 局部变量和全局变量
- 局部变量是在函数内部定义的变量，只能在函数内部使用
- 全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量
6.1局部变量
- 局部变量 是在 函数内部 定义的变量，只能在函数内部使用
- 函数执行结束后，函数内部的局部变量，会被系统回收
- 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
局部变量的作用、
- 在函数内部使用，临时 保存函数内部需要使用的数据
局部变量的声明周期
- 所谓声明周期就是变量从 被创建 到被系统回收的过程
- 局部变量在 函数执行时 次啊会被创建
- 函数执行结束后 局部变量 被系统回收
- 局部变量在生命周期内，可以用来存储 函数内部临时使用到的数据
6.2全局变量
- 全局变量 是在函数外部定义 的变量，所有函数内部都可以使用这个变量
注：函数执行时，需要处理变量时 会：
- 首先查找函数内部是否存在 指定名称的局部变量，如果有，直接使用
- 如果没有，查找函数外部是否存在 指定名称 的全局变量，如果有，直接使用
- 如果还没有，程序报错！
1）函数不能直接修改 全局变量的引用
- 全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所以函数内部 都可以使用这个变量
- 在函数内部，可以通过全局变量的引用获取对应的数据
- 但是，不允许直接修改全局变量的引用——— 使用赋值语句修改全局变量的值
2）在函数内部修改全局变量的值
- 如果在函数中需要修改全局变量，需要使用 global 进行声明
例如：
# 全局变量
num = 50
def demo1():
# 希望修改全局变量的值 - 使用 global 声明一下变量即可
# global 关键字会告诉解释器后面的变量是一个全局变量
# 在使用赋值语句时，就不会创建局部变量
global num
num = 100
print("demo1 ==> %d" % num)
def demo2():
print("demo2 ==> %d" % num)
demo1()
demo2()
3）全局变量定义的位置
- 为了保证所有的函数都能够正确使用到全局变量，应该将全局变量定义在其他函数的上方
注意：如果全局变量定义在 调用函数之后 ，在执行函数时，变量还没有定义，所以程序会报错！
为了区分全局变量和局部变量，在定义全局变量名前建议增加g_或者 gl_的前缀
扫一扫
1224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
