先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新软件测试全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注软件测试）
正文
li = (1,2,3,4) | |
class IndexTuple: | |
def __init__(self,*args): # args元组不定长参数拿到是一个元组 | |
self.values = args | |
self.index = tuple(enumerate(self.values)) # 通过枚举enumerate的方法将下标索引和自身的元素组成一个大大的元组 | |
print(self.index) | |
def __len__(self): | |
return len(self.values) | |
def __getitem__(self,key): # 通过下标索引key取值 | |
return self.index[key] | |
return self.values[key] | |
def __repr__(self): | |
return str(self.values) # 只能返回字符串 | |
my_t = IndexTuple(1,2,3,34) |
可迭代对象 --> 取值，像字符串，元组，列表，集合，字典能够被如循环取值一个一个拿取到元素的数据类型
li = [1,2,3,4,5] # 可迭代对象 | |
li1 = iter(li) # 将可迭代对象转成一个迭代器对象，迭代器对象就是能够被next一个一个将值取出 | |
next(li1) |
迭代器协议
class Number: | |
def __init__(self,end): | |
self.start = 0 | |
self.end = end | |
def __iter__(self): #构建一个迭代器对象 | |
return self | |
def __next__(self): #对迭代器对象取值 | |
self.start += 1 | |
if self.start <= self.end: #当self.start值小于self.end | |
return self.start #返回self.start | |
else: | |
raise StopIteration #抛出终止迭代异常 | |
nu = Number(6) | |
for i in nu: | |
print(i) | |
# 也可以用next(nu)函数去调用 |
上下文协议： 计时器，所谓的秒表，检测代码运行时长
import time #时间模块 | |
class RunTime: | |
def __enter__(self): #接收代码开始时间 | |
self.star_time = time.time() #获得当前开始时间 | |
return self.star_time | |
def __exit__(self,exc_type,exc_val,exc_tb): | |
self.end_time = time.time() #获取当前结束时间 | |
self.run_time = self.end_time - self.star_time #代码运行时间 | |
print('代码运行时间为：',self.run_time) | |
with RunTime(): #使用方法 | |
# 要执行的代码，运行时长 | |
pass |
生成器和装饰器
生成器等同于迭代器 yield 关键字返回值 next获取值
def func(): | |
print(1) | |
yield 2 # 和return一样有一个暂停函数的功能，并且遇到下一个next会继续向下执行 | |
print(3) | |
yield 4 | |
print(5) | |
yield 6 | |
a = func() | |
for i in a: | |
print(i) | |
# 或者使用next(a)，通过next获取值得到返回值 |
装饰器：闭包加回调函数
def fun(x): | |
def fun1(aa, bb): | |
print(aa, 'and:', bb) | |
return x(1, 2) | |
print('外层函数') | |
return fun1 | |
@fun | |
def func(cc, dd): | |
print('这是func的值：', cc, dd) | |
func(3, 4) |
内置装饰器
class Person: | |
def __init__(self,name,age): | |
self.name = name | |
self.age = age | |
@classmethod # 第一个参数自动传入类 | |
def learn(cls): # cls=Person | |
print(f'{zl.name}在学习') | |
print(cls) | |
@staticmethod #不在自动传入self | |
def sleep(): | |
print(zl.name) | |
print('在睡觉') | |
zl = Person('z',18) | |
Person.learn() | |
Person.sleep() |
五、常用操作
格式化操作
%方式
format方法
常用函数
print()：输出函数
input()：输入函数
type()：查看数据类型
id()：查看内存地址
eval()：去除双引号
异常信息
try:
pass
except Exception as e: # 保错后键异常信息存储在e中
pass
finally: # 无论报不报错都运行
pass
| 异常名称 | 描述 |
|---|---|
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| OverflowError | 数值运算超出最大限制 |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| AssertionError | 断言语句失败 |
| AttributeError | 对象没有这个属性 |
| EOFError | 没有内建输入,到达EOF 标记 |
| EnvironmentError | 操作系统错误的基类 |
| IOError | 输入/输出操作失败 |
| OSError | 操作系统错误 |
| WindowsError | 系统调用失败 |
| ImportError | 导入模块/对象失败 |
| LookupError | 无效数据查询的基类 |
| IndexError | 序列中没有此索引(index) |
| KeyError | 映射中没有这个键 |
| MemoryError | 内存溢出错误(对于Python 解释器不是致命的) |
| NameError | 未声明/初始化对象 (没有属性) |
| UnboundLocalError | 访问未初始化的本地变量 |
| ReferenceError | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| NotImplementedError | 尚未实现的方法 |
| SyntaxError | Python 语法错误 |
| IndentationError | 缩进错误 |
| TabError | Tab 和空格混用 |
| SystemError | 一般的解释器系统错误 |
| TypeError | 对类型无效的操作 |
| ValueError | 传入无效的参数 |
| UnicodeError | Unicode 相关的错误 |
| UnicodeDecodeError | Unicode 解码时的错误 |
| UnicodeEncodeError | Unicode 编码时错误 |
| UnicodeTranslateError | Unicode 转换时错误 |
| Warning | 警告的基类 |
| DeprecationWarning | 关于被弃用的特征的警告 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| SyntaxWarning | 可疑的语法的警告 |
| UserWarning | 用户代码生成的警告 |
六、文件管理
文件读写
文件打开
相对路径：在py脚本文件同级目录下的文件 .\同级目录 …\上级目录
绝对路径：完整的路径
文件读写mode
a追加模式下，如果文件不存在，也会自动帮我们创建一个文件，之后在写入内容
和w只写的区别就是一个是清空再写入，一个是继续向后写
文件操作
打开
file = open(“FilePath”, mode=“type”(, encoding=“”)) # 要记得关闭文件
pass
file.close()
with open(“FilePath”, mode=“type”(, encoding=“”)) # 上下文管理器打开，可以不用关闭
写入
file.writre(“content”) # write()方法：需要传入一个字符串做为参数,否则会报错
file.writelines() # writelines()方法：既可以传入字符串又可以传入一个字符序列,并将该字符序列写入文件
读取
file.read() # read()方法：一次性读如并返回文件的所有内容
file.readlines() # readlines()方法：每次读取一行；返回的是一个字符串对象，保持当前行的内存。一次性读取整个文件；自动将文件内容分析成一个行的列表
遍历读取
- 文件对象本身可以迭代，并且以行的形式读取
- | | |
| — | — |
| |for i in file:|
| |print(i)|指针
file.tell() # tell()方法：返回文件的当前位置，即文件指针当前位置。
file.seek() # seek()方法：用于移动文件读取指针到指定位置。
- seek第一个参数：移动的长度（字节）；如果该值为负数，表示从后往前移动n个字节
- seek第二个参数：0从开头（默认），1从当前，2从末尾
OS模块
| 方法 | 含义 |
|---|---|
| os.sep | 符合当前系统的路径分割符，Linux/windows\ |
| os.name | 返回操作系统类型windows“nt”Linux“posix” |
| os.rename | 更改文件名，传递两个参数（旧文件名，新文件名） |
| os.getcwd | 返回当前的工作目录 |
| os.listdir | 列出指定目录下的目录和文件 |
| os.chdir | 修改当前的工作路径 |
| os.mkdir | 创建目录 |
| os.makedirs | 递归创建目录 |
| os.remove | 删除文件 |
| os.rmdir | 删除文件夹（文件夹下内容为空） |
| os.removedirs | 递归删除文件夹 |
| os.system | 执行系统命令 |
| os.popen | 执行系统命令，会将结果以文件的形式返回 |
| os.walk | 通过在目录树中游走输出在目录中的文件名，向上或者向下 |
| os.path.join | 连接目录和文件名。os.path.join（path,name） |
| os.path. isfile | 判断指定对象是否为文件。是返回True,否则False |
| os.path.isdir | 判断指定对象是否为目录。是True,否则False |
| os.path. split | 返回路径的目录和文件名 |
| os.path. exists | 检验指定的对象是否存在。是True,否则False |
| os.path.getsize | 获取指定对象的文件大小 |
| os.path.abspath | 获得绝对路径 |
| os.path.basename | 返回文件名 |
| os.path.dirname | 返回文件所在目录 |
sys模块
| 方法 | 含义 |
|---|---|
| sys.argv | 获取命令行参数列表，第一个元素是程序本身 |
| sys.exit(n) | 退出Python程序，exit(0)表示正常退出。当参数非0时，会引发一个SystemExit异常，可以在程序中捕获该异常 |
| sys.version | 获取Python解释程器的版本信息 |
| sys.maxsize | 最大的Int值，64位平台是2**63 - 1 |
| sys.path | 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 |
| sys.platform | 返回操作系统平台名称 |
| sys.stdin | 输入相关 |
| sys.stdout | 输出相关 |
| sys.stderr | 错误相关 |
| sys.exc_info() | 返回异常信息三元元组 |
| sys.getdefaultencoding() | 获取系统当前编码，默认为utf-8 |
| sys.setdefaultencoding() | 设置系统的默认编码 |
| sys.getfilesystemencoding() | 获取文件系统使用编码方式，默认是utf-8 |
| sys.modules | 以字典的形式返回所有当前Python环境中已经导入的模块 |
| sys.builtin_module_names | 返回一个列表，包含所有已经编译到Python解释器里的模块的名字 |
| sys.copyright | 当前Python的版权信息 |
| sys.flags | 命令行标识状态信息列表。只读。 |
| sys.getrefcount(object) | 返回对象的引用数量 |
| sys.getrecursionlimit() | 返回Python最大递归深度，默认1000 |
| sys.getsizeof(object[, default]) | 返回对象的大小 |
| sys.getswitchinterval() | 返回线程切换时间间隔，默认0.005秒 |
| sys.setswitchinterval(interval) | 设置线程切换的时间间隔，单位秒 |
| sys.getwindowsversion() | 返回当前windwos系统的版本信息 |
| sys.hash_info | 返回Python默认的哈希方法的参数 |
| sys.implementation | 当前正在运行的Python解释器的具体实现，比如CPython |
| sys.thread_info | 当前线程信息 |
七、模块和包
模块
其是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
导包
import 包名 # 导入模块
import 模块名 as 别名
from 模块名 import 成员名 as 别名
from 模块名 import 成员名
from 模块名 import * # 从模块中导入所有方法
【第七小节：python（变量类型）】
序
其实大一上就简单学了下python，跟着书做了下飞机大战和爬豆瓣的爬虫，但现在好像连python基本语法都不记得了。刚好这个学期要有自学opencv和strcpy的需求，所以借此机会重温下py，用的资料就是《python编程从入门到实践》。我就慢慢从头开始过下基础知识，现在就当成云笔记了，希望也对和我一样的小白有些许帮助，同时若有大佬能对我指点一二我就感激不尽啦。
变量赋值
python是一种解释型语言，和我学的c完全不一样，同时注意的地方也有许多，缩进，继承，类，等等。
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = “John” # 字符串
print(name)
多个变量赋值
a, b, c = 1, 2, “john”
a = b = c = 1
标准数据类型
number
var1 = 1
var2 = 10
删除的话：
del var1
Python支持四种不同的数字类型：
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）（复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。）
string（字符串）
python的字串列表有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
eg：
a b c d e
0 1 2 3 4
-5 -4 -3 -2 -1
"切片“是python很强大的一个功能，用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。左闭右开
s = ‘abcdef’
print(s[1:5])
可以像C语言数组一样使用切片功能。
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
str = ‘Hello World!’
print (str) # 输出完整字符串
print (str[0]) # 输出字符串中的第一个字符
print (str[2:5]) # 输出字符串中第三个至第六个之间的字符串
print (str[2:]) # 输出从第三个字符开始的字符串
print (str * 2) # 输出字符串两次
print (str + “TEST”) # 输出连接的字符串
Python 列表截取可以接收第三个参数，参数作用是截取的步长，在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串
list（列表） （用【】）
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
操作和string类似
tuple（元组）（不能二次赋值）（用（））
元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
tuple = ( ‘runoob’, 786 , 2.23, ‘john’, 70.2 )
tinytuple = (123, ‘john’)
同切片操作
dictionary （字典）（用{}）
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
dict = {} # 创建空字典
dict[‘one’] = “This is one” # 为字典赋键值对
dict[2] = “This is two”
tinydict = {‘name’: ‘runoob’, ‘code’: 6734, ‘dept’: ‘sales’}
print(dict[‘one’]) # 输出键为’one’ 的值
print(dict[2]) # 输出键为 2 的值
print(dict)
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
注意编码格式为UTF-8
Python数据类型转换
int(x [,base])
将x转换为一个整数
long(x [,base] )
将x转换为一个长整数
float(x)
将x转换到一个浮点数
complex(real [,imag])
创建一个复数
str(x)
将对象 x 转换为字符串
repr(x)
将对象 x 转换为表达式字符串
eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)
将序列 s 转换为一个元组
list(s)
将序列 s 转换为一个列表
set(s)
转换为可变集合
dict(d)
创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)
转换为不可变集合
chr(x)
将一个整数转换为一个字符
unichr(x)
将一个整数转换为Unicode字符
ord(x)
将一个字符转换为它的整数值
hex(x)
将一个整数转换为一个十六进制字符串
oct(x)
将一个整数转换为一个八进制字符串
python内置函数好多啊
【第八小节：Python数据类型转换】
一 自动类型转换
(针对于Number类型) bool float int complex
当Number不同的数据类型进行运算的时候,默认向更高精度转化
精度从低到高顺序:bool -> int -> float ->complex
True 默认转化是1
False 默认转化是0
(1) bool + int
res = True + 89
print(res)
(2) bool + float
res = True + 55.78
print(res)
(3) bool + complex
res = False + 2-4j
print(res)
(4) int + float
res = 31 + 4.1
print(res)
(5) int + complex
res = 17 + 4-7j
print(res)
(6) float + complex
res = 8.12 + 3+5j
print(res)
[root@node10 python]# python3 test.p
90
56.78
(2-4j)
35.1
(21-7j)
(11.12+5j)
二 强制类型转换
Number => (int float bool complex)
2.1 把数据强制转换成整型 int
(整型 浮点型 布尔类型 纯数字字符串)
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = “123321”
var6 = “你好123”
res = int(var2)
True 强转整型是1 False 强转整型是0
res = int(var3)
print(res,type(res))
res = int(var3_1)
print(res)
res = int(var5)
print(res,type(res))
[root@node10 python]# python3 test.py
1 <class ‘int’>
0
123321 <class ‘int’>
字符型字符串不能转化
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = “123321”
var6 = “你好123”
res = int(var6)
print(res,type(res))
[root@node10 python]# python3 test.py
Traceback (most recent call last):
File “test.py”, line 9, in
res = int(var6)
ValueError: invalid literal for int() with base 10: ‘你好123’
2.2 float (整型 浮点型 布尔类型 纯数字字符串)
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = “123321”
var6 = “你好123”
res = float(var1)
print(res)
res = float(var3) # 加上.0 成为小数
print(res)
res = float(var3_1) # 0.0
print(res)
res = float(var5) #123321.0
print(res)
[root@node10 python]# python3 test.py
13.0
1.0
0.0
123321.0
[root@node10 python]# python3 test.py
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = “123321”
var6 = “你好123”
res = float(var4) #can’t convert complex to float
print(res)
[root@node10 python]# python3 test.py
Traceback (most recent call last):
File “test.py”, line 9, in
res = float(var4) #can’t convert complex to float
TypeError: can’t convert complex to float
complex (整型 浮点型 布尔类型 纯数字字符串 复数)
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = “123321”
var6 = “你好123”
res = complex(var1) # 13 + 0j
print(res)
res = complex(var2) #(99.99+0j)
print(res)
res = complex(var3) #(1+0j)
print(res)
res = complex(var3_1) #0j
print(res)
res = complex(var5) #(123321+0j)
print(res)
[root@node10 python]# python3 test.py
(13+0j)
(99.99+0j)
(1+0j)
0j
(123321+0j)
2.3 bool类型
( 容器类型数据 / Number类型数据 都可以,要么True要么False)
布尔类型为假的十种情况: 0,0.0,False,0j,“”,[],(),set(),{},None None 是系统的一个关键字 表示空的,什么也没有,一般做初始值
var1 = 13
var2 = 99.99
var3 = True
var3_1 = False
var4 = 4+1j
var5 = “123321”
var6 = “你好123”
res = bool(var6)
print(res,type(res))
res = bool(var4)
print(res,type(res))
res = bool([1,2,3])
print(“<!!!>”)
print(res)
res = None
print(res,type(res))
[root@node10 python]# python3 test.py
True <class ‘bool’>
True <class ‘bool’>
<!!!>
True
None <class ‘NoneType’>
三 容器类型数据的强制类型转换
(str list tuple set dict)
3.1 str 强转成字符串类型
( 容器类型数据 / Number类型数据 都可以 )
字符串强转规律: 就是单纯的在原数据的两侧加上引号
var1 = “快乐每一天”
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {“美丽”,“店铺名个人”}
var5 = {“a”:1,“b”:2,“c”:3}
var6 = 123
res = str(var2)
print(repr(res),type(res))
res = str(var3)
print(repr(res),type(res))
res = str(var5)
print(repr(res),type(res))
res = str(var6)
print(res,type(res))
repr 以字符串形式原型化输出数据 (想看到引号用repr转化)
print(repr(res),type(res))
[root@node10 python]# python3 test.py
‘[1, 2, 3]’ <class ‘str’>
‘(4, 5, 6)’ <class ‘str’>
“{‘a’: 1, ‘b’: 2, ‘c’: 3}” <class ‘str’>
‘123’ <class ‘str’>
3.2 list 列表
list 列表强转规律:
如果是字符串:把字符串中的每一个字符当成新的元素放到列表中，如果是其他数据:就是单纯的把原标识符换成[]
var1 = “快乐每一天”
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {“美丽”,“店铺名个人”}
var5 = {“a”:1,“b”:2,“c”:3}
var6 = 123
res = list(var1) #[‘快’, ‘乐’, ‘每’, ‘一’, ‘天’]
print(res)
res = list(var3)
print(res)
res = list(var4)
print(res)
res = list(var5) #[‘a’, ‘b’, ‘c’] 强转字典时,保留键,舍去值
res = list(var6) # error
print(res)
[root@node10 python]# python3 test.py
[‘快’, ‘乐’, ‘每’, ‘一’, ‘天’]
[4, 5, 6]
[‘店铺名个人’, ‘美丽’]
[‘a’, ‘b’, ‘c’]
3.3 tuple 元组
tuple 元组强转规律
如果是字符串:把字符串中的每一个字符当成新的元素放到元组中
如果是其他数据:就是单纯的把原标识符换成() 变成元组即可
var1 = “快乐每一天”
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {“美丽”,“店铺名个人”}
var5 = {“a”:1,“b”:2,“c”:3}
var6 = 123
res = tuple(var1) #(‘快’, ‘乐’, ‘每’, ‘一’, ‘天’)
print(res)
res = tuple(var2)
print(res)
res = tuple(var5) #(‘a’, ‘b’, ‘c’) #强转字典时,保留键,舍去值
print(res)
[root@node10 python]# python3 test.py
(‘快’, ‘乐’, ‘每’, ‘一’, ‘天’)
(1, 2, 3)
(‘a’, ‘b’, ‘c’)
3.4 set 集合
set 集合强转规律
- 如果是字符串:把字符串中的每一个字符当成新的元素放到集合中
- 如果是其他数据:就是单纯的把原标识符换成{} 变成集合即可
var1 = “快乐每一天”
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {“美丽”,“店铺名个人”}
var5 = {“a”:1,“b”:2,“c”:3}
var6 = 123
res = set(var1) #因为无序,字符串被打散
print(res)
res = set(var2) # {1,2,3}
print(res)
res = set(var5) #强转字典时,保留键,舍去值,键值顺序被打乱
print(res)
[root@node10 python]# python3 test.py
{‘快’, ‘每’, ‘一’, ‘乐’, ‘天’}
{1, 2, 3}
{‘c’, ‘a’, ‘b’}
过滤列表重复数据
listvar = [1,2,3,4,5,5,6,7,6]
container = set(listvar)
print(container)
container = list(container)
print(container,type(container))
[root@node10 python]# python3 test.py
{1, 2, 3, 4, 5, 6, 7}
[1, 2, 3, 4, 5, 6, 7] <class ‘list’>
3.5 二级容器
外面是一个容器类型的数据,里面的元素还是一个容器类型数据
listvar = [1,2,3,(4,5,6)] # 二级容器
print(listvar)
[root@node10 python]# python3 test.py
[1, 2, 3, (4, 5, 6)]
二级元祖
tup = (3,5,(7,8,9))
print(tup)
[root@node10 python]# python3 test.py
(3, 5, (7, 8, 9))
二级集合 (只能存放元组)
setvar = {1,2,3,(11,22,33)}
print(setvar)
[root@node10 python]# python3 test.py
{1, 2, 3, (11, 22, 33)}
二级字典
dictvar = {‘a’:{‘c’:333},‘b’:2}
取出333
print(dictvar[‘a’][‘c’])
[root@node10 python]# python3 test.py
333
四级容器
container = [1,2,3,(4,5,6,{“a”:1,“b”:[7,8,9]}),90]
取出9
res = container[-2][-1][“b”][-1]
print(res)
[root@node10 python]# python3 test.py
| 1 | 9 |
等长的二级容器
(1) 里面每个元素都是容器类型数据
(2) 每个容器类型数据的元素个数都相同
container = [(1,2,3),[4,5,6]]
3.6 字典的强制类型转换
外面是列表,里面是列表或元组或字符串
listvar = [[“a”,1],(“b”,2),“c123”] # 字符串慎用 如果值是多个,有局限性
listvar = [[“a”,1],(“b”,2)] # 推荐 ***
res = dict(listvar)
print(res)
[root@node10 python]# python3 test.py
{‘a’: 1, ‘b’: 2}
外面是元组,里面是列表元组或字符串
tuplevar = ([“c”,11],(“d”,23)) # 推荐 ***
res = dict(tuplevar)
print(res)
[root@node10 python]# python3 test.py
{‘c’: 11, ‘d’: 23}
例外:如果往列表或者元组容器放集合,语法上不报错,但情况出乎意料,达不到想要效果
container = dict([{“a”,1},{“b”,2}]) # 不推荐使用
print(container)
[root@node10 python]# python3 test.py
{‘a’: 1, ‘b’: 2}
外面是集合,里面是元组或字符串
setvar = {(‘a’,1),(‘b’,2),“c3”} # 必须放入不可变数据,即可哈希
res = dict(setvar)
print(res)
[root@node10 python]# python3 test.py
{‘b’: 2, ‘a’: 1, ‘c’: ‘3’}
int() float() bool() complex()
str() list() tuple() set() dict()
这些函数在进行强转时,都默认转化成当前的数据类型
用这样的方式也可以初始化一个变量
res = int()
res = list()
print(res)
[root@node10 python]# python3 test.py
【第九小节：Python 内置函数]
分类
按参数和返回值分类
无参数，无返回值
无参数，有返回值
有参数，无返回值
有参数，有返回值
按来源分类
内置函数
自定义函数
标准库函数
第三方库函数
内置函数
数学运算(7个)
类型转换(24个)
序列操作(8个)
对象操作(7个)
反射操作(8个)
变量操作(2个)
交互操作(2个)
文件操作(1个)
编译执行(4个)
装饰器(3个)
| 函数 | 分类 | 返回值 |
|---|---|---|
| abs() | 数学运算 | 返回数字的绝对值，如abs(-10) 返回 10 |
| all() | 序列操作 | 接受一个迭代器，如果迭代器的所有元素都为真，那么返回True，否则返回False |
| any() | 序列操作 | 接受一个迭代器，如果迭代器里有一个元素为真，那么返回True,否则返回False |
| ascii() | 对象操作 | 调用对象的__repr__()方法，获得该方法的返回值 |
| bin() | 类型转换 | 将十进制数分别转换为2进制 |
| bool() | 类型转换 | 测试一个对象是True还是False |
| bytearray() | 类型转换 | 将一个字符串转换成字节类型 |
| bytes() | 类型转换 | 将字符类型/数值类型等转换为字符串类型 |
| callable() | 反射操作 | 判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例 |
| chr() | 类型转换 | 查看十进制数对应的ASCII字符 |
| classmethod() | 装饰器 | 用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法 |
| compile() | 编译执行 | 将一个字符串编译为字节代码 |
| complex() | 类型转换 | 用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数 |
| delattr() | 反射操作 | 删除对象的属性 |
| dict() | 类型转换 | 创建数据字典 |
| dir() | 对象操作 | 不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表 |
| divmod() | 数学运算 | 分别取商和余数 |
| enumerate() | 类型转换 | 返回一个可以枚举的对象，该对象的next()方法将返回一个元组 |
| eval() | 编译执行 | 将字符串str当成有效的表达式来求值并返回计算结果 |
| exec() | 编译执行 | 执行字符串或complie方法编译过的字符串，没有返回值 |
| filter() | 序列操作 | 过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据 |
| float() | 类型转换 | 讲一个字符串或整数转换为浮点数 |
| format() | 对象操作 | 格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法 |
| frozenset() | 类型转换 | 创建一个不可修改的集合 |
| getattr() | 反射操作 | 获取对象的属性 |
| globals() | 变量操作 | 返回一个描述当前全局变量的字典 |
| hasattr() | 反射操作 | 用于判断对象是否包含对应的属性 |
| hash() | 对象操作 | 用于获取一个对象（字符串或者数值等）的哈希值 |
| help() | 对象操作 | 返回对象的帮助文档 |
| hex() | 类型转换 | 将十进制数分别转换为16进制 |
| id() | 对象操作 | 返回对象的内存地址 |
| input() | 交互操作 | 获取用户输入内容 |
| int() | 类型转换 | 将一个字符串或数值转换为一个普通整数 |
| isinstance() | 反射操作 | 检查对象是否是类的对象，返回True或False |
| issubclass() | 反射操作 | 检查一个类是否是另一个类的子类。返回True或False |
| iter() | 类型转换 | 用来生成迭代器 |
| len() | 对象操作 | 返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典） |
| list() | 类型转换 | 列表构造函数 |
| locals() | 变量操作 | 打印当前可用的局部变量的字典 |
| map() | 序列操作 | 根据提供的函数对指定序列做映射 |
| max() | 数学运算 | 返回给定元素里最大值 |
| memoryview() | 类型转换 | 返回给定参数的内存查看对象 |
| min() | 数学运算 | 返回给定元素里最小值 |
| next() | 序列操作 | 返回一个可迭代数据结构（如列表）中的下一项 |
| object() | 类型转换 | 不接受任何参数，返回一个无特征对象，该对象是所有类的基础 |
| oct() | 类型转换 | 将十进制数分别转换为8进制 |
| open() | 文件操作 | 打开文件 |
| ord() | 类型转换 | 查看某个ASCII对应的十进制数 |
| pow() | 数学运算 | 幂函数 |
| print() | 交互操作 | 输出函数 |
| property() | 装饰器 | 在新式类中返回属性值 |
| range() | 类型转换 | 根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数 |
| repr() | 编译执行 | 将任意值转换为字符串，供计时器读取的形式 |
| reversed() | 序列操作 | 反转，逆序对象 |
| round() | 数学运算 | 四舍五入 |
| set() | 类型转换 | 创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。 |
| setattr() | 反射操作 | 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。 |
| slice() | 类型转换 | 实现切片对象，主要用在切片操作函数里的参数传递 |
| sorted() | 序列操作 | 对所有可迭代的对象进行排序操作 |
| staticmethod() | 装饰器 | 返回函数的静态方法 |
| str() | 类型转换 | 返回一个对象的string格式 |
| sum() | 数学运算 | 求和 |
| super() | 类型转换 | 调用父类的方法 |
| tuple() | 类型转换 | 元组构造函数 |
| type() | 对象操作 | 显示对象所属的类型 |
| vars() | 对象操作 | 返回对象object的属性和属性值的字典对象 |
| zip() | 序列操作 | 将对象逐一配对 |
| __import__() | 反射操作 | 用于动态加载类和函数 |
【第十小节：python运算符】
什么是运算符
举个简单的例子:
4 + 5 = 9
例子中，4 和 5 被称为操作数，+ 称为运算符。
Python 语言支持以下类型的运算符:
1、算术运算符
以下假设变量a为10，变量b为21：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 31 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
| / | 除 - x 除以 y | b / a 输出结果 2.1 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 1 |
** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
| // | 取整除 - 向下取接近商的整数 | >>> 9//2 4 >>> -9//2 -5 |
以下实例演示了Python所有算术运算符的操作：
实例(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print (“1 - c 的值为：”, c)
c = a - b
print (“2 - c 的值为：”, c)
c = a * b
print (“3 - c 的值为：”, c)
c = a / b
print (“4 - c 的值为：”, c)
c = a % b
print (“5 - c 的值为：”, c)
修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print (“6 - c 的值为：”, c)
a = 10
b = 5
c = a//b
print (“7 - c 的值为：”, c)
以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2
结果总是隐式转换为复杂类型
正负
+x
521
-x
-521
加法,可结合赋值运算+=
x + 0
521
减法,可结合赋值运算-=
x - 21
500
乘法,可结合赋值运算*=
z * 100
521.0
除法,可结合赋值运算/=或//=
“”"
兼容特性: from future import division
“”"
Python2中对于包含小数使用真除法(保留小数部分,最终为小数)
x / 100.
5.21
Python3中对于包含小数使用真除法(保留小数部分,最终为小数)
x / 100.
5.21
Python2中对于全整数使用传统除法(保留整数部分,最终为整数)
x / 100
5
Python3中对于全整数使用真除法(保留小数部分,最终为小数)
x / 100
5.21
Python2中对于包含小数使用地板除(保留整数部分,最终为小数)
Python3中对于包含小数使用地板除(保留整数部分,最终为小数)
x // 100.
5.0
Python2中对于全整数使用地板除(保留整数部分,最终为整数)
Python3中对于全整数使用地板除(保留整数部分,最终为整数)
x // 100
5
取模,可结合赋值运算%=
x % 2
1
乘方,可结合赋值运算**=
z * 10 ** 2
521.0
5 + 4 # 加法
9
4.3 - 2 # 减法
2.3
3 * 7 # 乘法
21
2 / 4 # 除法，得到一个浮点数
0.5
2 // 4 # 除法，得到一个整数
0
17 % 3 # 取余
2
2 ** 5 # 乘方
32
2 & (2 - 1)
0
8 & (8 - 1)
0
16 & (16 - 1)
0
2、比较运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 True。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
以下实例演示了Python所有比较运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
print (“1 - a 等于 b”)
else:
print (“1 - a 不等于 b”)
if ( a != b ):
print (“2 - a 不等于 b”)
else:
print (“2 - a 等于 b”)
if ( a < b ):
print (“3 - a 小于 b”)
else:
print (“3 - a 大于等于 b”)
if ( a > b ):
print (“4 - a 大于 b”)
else:
print (“4 - a 小于等于 b”)
修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print (“5 - a 小于等于 b”)
else:
print (“5 - a 大于 b”)
if ( b >= a ):
print (“6 - b 大于等于 a”)
else:
print (“6 - b 小于 a”)
以上实例输出结果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a
值比较
小于
y < x
True
小于等于
x <= x
True
大于
x > y
True
大于等于
x >= y
True
等于
x == x
True
不等于
for Python2
x != y
True
x <> y
True
for Python3
x != y
True
地址比较
id(x), id(521)
(140428868352096, 140428868352072)
x is 521
False
3、赋值运算符
向内存申请一空闲内存单元存储数字然后将变量名指向此内存单元,至此可通过变量名操作此内存单元数据
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | 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 |
| := | 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。 | 在这个示例中，赋值表达式可以避免调用 len() 两次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") |
以下实例演示了Python所有赋值运算符的操作：
实例(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print (“1 - c 的值为：”, c)
c += a
print (“2 - c 的值为：”, c)
c *= a
print (“3 - c 的值为：”, c)
c /= a
print (“4 - c 的值为：”, c)
c = 2
c %= a
print (“5 - c 的值为：”, c)
c **= a
print (“6 - c 的值为：”, c)
c //= a
print (“7 - c 的值为：”, c)
以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864
:point_right：混合操作符优先级问题可通过括号()提升优先级解决
:point_right：混合类型的转换以复杂度为基准,会自动转换至复杂度最高的类型
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, “runoob”
以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 “runoob” 分配给变量 c。
4、位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13二进制格式如下：
a = 0011 1100
b = 0000 1101
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | ||
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
以下实例演示了Python所有位运算符的操作：
实例(Python 3.0+)
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13二进制格式如下：
#!/usr/bin/python3
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print (“1 - c 的值为：”, c)
c = a | b; # 61 = 0011 1101
print (“2 - c 的值为：”, c)
c = a ^ b; # 49 = 0011 0001
print (“3 - c 的值为：”, c)
c = ~a; # -61 = 1100 0011
print (“4 - c 的值为：”, c)
c = a << 2; # 240 = 1111 0000
print (“5 - c 的值为：”, c)
c = a >> 2; # 15 = 0000 1111
print (“6 - c 的值为：”, c)
bin(x)
‘0b1000001001’
左移,可结合赋值运算<<=
“”"
规则: 左
“”"
bin(x << 2)
‘0b100000100100’
右移,可结合赋值运算>>=
bin(x >> 2)
‘0b10000010’
位与,可结合赋值运算&=
“”"
规则: 都为1为1,否则为0
100000100100
000010000010
000000000000
“”"
0b100000100100 & 0b10000010
0
位或,可结合赋值运算|=
“”"
规则: 存在1为1,否则为0
100000100100
000010000010
100010100110
“”"
0b100000100100 | 0b10000010
2214
异或,可结合赋值运算^=
“”"
规则: 不同为1,相同为0
100000100100
000010000010
100010100110
“”"
0b100000100100 ^ 0b10000010
2214
取反,可结合赋值运算～=
“”"
规则: 1变为0,0变为1
0000001000001001
1111110111110110 取反,此时最高位为1表示负数,负数的存储需要将其转换为补码
1000001000001001 反码,保持符号位不变,其它位置取反
1000001000001010 补码,在反码的基础上最低位+1
-522
“”"
~0b1000001001
-522
👉 位或运算等同于十进制加法,基于此值之上与操作数位与等同于求操作数,反之与操作数取反位与等同于求被操作数,通常被用于权限模型
In [44]: x = 521
In [45]: bin(x)
Out[45]: ‘0b1000001001’
In [46]: x << 2
Out[46]: 2084
In [48]: bin(2084)
Out[48]: ‘0b100000100100’
In [52]: x << 5
Out[52]: 16672
In [53]: bin(16672)
Out[53]: ‘0b100000100100000’
//
In [49]: x >> 2
Out[49]: 130
In [50]: bin(130)
Out[50]: ‘0b10000010’
In [51]: 2084 & 130 # 与操作
Out[51]: 0
bin(x)
‘0b1000001001’
左移,可结合赋值运算<<=
“”"
规则: 左
“”"
bin(x << 2)
‘0b100000100100’
右移,可结合赋值运算>>=
bin(x >> 2)
‘0b10000010’
位与,可结合赋值运算&=
“”"
规则: 都为1为1,否则为0
100000100100
000010000010
000000000000
“”"
0b100000100100 & 0b10000010
0
位或,可结合赋值运算|=
“”"
规则: 存在1为1,否则为0
100000100100
000010000010
100010100110
“”"
0b100000100100 | 0b10000010
2214
异或,可结合赋值运算^=
“”"
规则: 不同为1,相同为0
100000100100
000010000010
100010100110
“”"
0b100000100100 ^ 0b10000010
2214
取反,可结合赋值运算～=
“”"
规则: 1变为0,0变为1
0000001000001001
1111110111110110 取反,此时最高位为1表示负数,负数的存储需要将其转换为补码
1000001000001001 反码,保持符号位不变,其它位置取反
1000001000001010 补码,在反码的基础上最低位+1
-522
“”"
~0b1000001001
-522
👉 位或运算等同于十进制加法,基于此值之上与操作数位与等同于求操作数,反之与操作数取反位与等同于求被操作数,通常被用于权限模型
5、逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
以上实例输出结果：
实例(Python 3.0+)
与, 都为真为真
x and y
52.1
或, 一个真即真
x or y
521
非,总是隐式转换为布尔对象
not x
False
以上实例输出结果：
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false
与, 都为真为真
In [38]: x
Out[38]: 521
In [39]: y
Out[39]: 6
In [40]: x and y
Out[40]: 6
或, 一个真即真
In [41]: x or y
Out[41]: 521
非,总是隐式转换为布尔对象
not x
False
In [42]: x = 0
In [43]: not x
Out[43]: True
6、成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
以下实例演示了Python所有成员运算符的操作：
实例(Python 3.0+)
以上实例输出结果：
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
7、身份运算符
常用于比较两个对象是否
指向同一个内存单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
注： id()") 函数用于获取对象内存地址。
为避免频繁分配释放内存,解释器预先将-5~256的小整数作为索引将值存入small_ints列表对应的内存单元
至此声明变量右侧值为小整数时会首先在small_ints列表中索引是否存在,如果存在则直接将变量名指向此地址
n1 = 1
n2 = 1
n1 is n2
True
n1 = 521
n2 = 521
n1 is n2
False
对于单行多个赋值的特殊情况,如果值相同会将变量名指向同一块儿内存单元
n1 = 521; n2 = 521; n3 = 521
n1 is n2 is n3
True
以下实例演示了Python所有身份运算符的操作：
实例(Python 3.0+)
以上实例输出结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True
运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，求余数和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘AND’ |
| ^ | |
| <= < > >= | 比较运算符 |
| == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
以下实例演示了Python所有运算符优先级的操作：
实例(Python 3.0+)
以上实例输出结果：
(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0
and 拥有更高优先级:
实例
以上实例输出结果：
yes
注意：
Pyhton3 已不支持 <> 运算符，可以使用 != 代替，如果你一定要使用这种比较运算符，可以使用以下的方式：
from future import barry_as_FLUFL
1 <> 2
True
【第十一小节：python流程控制】
1、概念
控制事物的执行流程就是流程控制
2、执行流程的三种情况
顺序结构：自上而下运行
分支结构：在运行过程中根据条件的不同可能会执行不同的流程
循环结构：在运行过程中会有些代码需要反复执行
3、必知必会
1、条件都会转成布尔值，从而决定子代码是否执行
2、在python中，使用缩进来代表代码的从属关系（四个空格）
3、并不是所有的代码都可以拥有子代码
4、同属于某个代码的多行子代码，必须保持相同的缩进量
**小技巧：**在上一行代码的结尾如果是冒号，那么下一行代码比缩进
if语法
1、单分支（单if）
#语法：
if 条件：
条件成立之后执行的代码块
#示例：
age = 18
if age < 20:
print(‘你很漂亮’)
2、双分支（if 和else一起使用）
#语法：
if 条件1：
条件1成立之后执行的代码块
else ：
条件不成立后执行的代码块
#示例：
age = 29
if age < 20:
print(‘你很漂亮’)
else:
print(‘认错人了’)
3、多分支（if、elif以及else共同使用）
#语法：
if 条件1：
条件1成立之后执行的代码块
elif 条件2：
条件1不成立条件，2成立之后执行的代码块
else 条件3:
条件1和2都不成立，条件3成立之后执行的代码块
#示例：
age = 19
if age < 20:
print(‘你很漂亮’)
elif age <29:
print(‘你好啊’)
else:
print(‘不好意思认错人了’)
4、if嵌套
age_of_girl = 20
height = 171
weight = 99
is_pretty = True
success = False
if age_of_girl >= 20 and age_of_girl < 22 and height > 170 and weight < 100 and is_pretty == True:
if success:
print(‘表白成功,在一起’)
else:
print(‘下次再见’)
else:
print(‘阿姨好’)
小练习
jason管理员 tony安保人员 kevin财务 jack销售 其他普通员工
1.获取用户名
username = input(‘你的名字:’)
2.判断用户名身份
if username == ‘jason’:
print(‘管理员’)
elif username == ‘tony’:
print(‘安保’)
elif username == ‘kevin’:
print(‘财务’)
elif username == ‘jack’:
print(‘销售’)
else:
print(‘普通员工’)
while循环
1、语法
while 条件:
条件成立之后执行的子代码块
2、基本用法示例
i = 1
while i <= 5:
print(i)
i += 1
3、while+break
break：结束本层循环
while True:
1.获取用户输入的用户名和密码
username = input(‘username>>>:’)
password = input(‘password>>>:’)
2.判断用户名和密码是否正确
if username == ‘小明’ and password == ‘123’:
print(‘输入正确’)
直接结束本层循环
break
else:
print(‘输入错误’)
4、全局标志位
tag = True
while tag:
1.获取用户输入的用户名和密码
username = input(‘username>>>:’)
password = input(‘password>>>:’)
2.判断用户名和密码是否正确
if username == ‘小明’ and password == ‘123’:
print(‘输入正确’)
直接结束本层循环
tag = False
else:
print(‘输入错误’)
5**、while嵌套**
while嵌套
while True:
1.获取用户输入的用户名和密码
username = input(‘username>>>:’)
password = input(‘password>>>:’)
2.判断用户名和密码是否正确
if username == ‘小明’ and password == ‘123’:
print(‘输入正确’)
while True:
cmd = input(‘请输入您的指令>>>:’)
判断用户是否想退出
if cmd == ‘q’:
break
print(‘正在执行您的指令:%s’ % cmd)
break
else:
print(‘输入错误’)
案例
猜年龄的游戏
普通要求
用户可以有三次猜错的机会 如果过程中猜对了直接退出
拔高要求
三次机会用完之后提示用户是否继续尝试 如果是则再给三次机会 如果否则直接结束
普通要求# 1.先编写猜年龄主体功能
定义一个真实的年龄
real_age = 18
3.定义一个计数器
count = 1
2.先加一个循环功能
while count < 4:
1.1 获取用户猜测的年龄
guess_age = input(‘请输入您猜测的年龄>>>:’)
1.2 简单粗略的将字符串转换成数字(可能会报错 暂时不要考虑)
guess_age = int(guess_age)
1.3 猜测年龄
if guess_age > real_age:
print(‘猜大了’)
4.1 每次猜错都加一
count += 1
elif guess_age < real_age:
print(‘猜小了’)
4.1 每次猜错都加一
count += 1
else:
print(‘哎呀 你真棒 猜对了!!!’)
4.猜对了直接结束本层循环
break
优化
count += 1
拔高要求# 1.先编写猜年龄主体功能
定义一个真实的年龄
real_age = 18
3.定义一个计数器
count = 1
2.先加一个循环功能
while True:
5.判断当前用户是第几次尝试
if count == 4:
choice = input(‘您已经尝试了三次 是否继续(y/n)>>>:’)
5.1 判断用户输入的是y还是n
if choice == ‘y’:
重置count的次数
count = 1
else:
print(‘再接再厉’)
break
1.1 获取用户猜测的年龄
guess_age = input(‘请输入您猜测的年龄>>>:’)
1.2 简单粗略的将字符串转换成数字(可能会报错 暂时不要考虑)
guess_age = int(guess_age)
1.3 猜测年龄
if guess_age > real_age:
print(‘猜大了’)
4.1 每次猜错都加一
count += 1
elif guess_age < real_age:
print(‘猜小了’)
4.1 每次猜错都加一
count += 1
else:
print(‘哎呀 你真棒 猜对了!!!’)
4.猜对了直接结束本层循环
break
优化
count += 1
6、while+continue
continue表示结束本次循环，直接进入下一次循环
使用while循环打印出0-10但是不打印4
1.定义一个起始变量
count = 0
2.循环
while count < 11:
5.判断 如果count为4则不打印
if count == 4:
count += 1
跳过本次循环 开始下一次循环
continue
3.打印变量的值
print(count)
4.变量值自增1
count += 1
continue会让循环体代码直接回到条件判断处重新判断
7、while+else
count = 0
while count < 5:
print(count)
count += 1
else:
print(‘呵呵’) # 会执行else子代码
count = 0
while count < 5:
if count == 3:
break
print(count)
count += 1
else:
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注软件测试）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
nt(‘销售’)
else:
print(‘普通员工’)
while循环
1、语法
while 条件:
条件成立之后执行的子代码块
2、基本用法示例
i = 1
while i <= 5:
print(i)
i += 1
3、while+break
break：结束本层循环
while True:
1.获取用户输入的用户名和密码
username = input(‘username>>>:’)
password = input(‘password>>>:’)
2.判断用户名和密码是否正确
if username == ‘小明’ and password == ‘123’:
print(‘输入正确’)
直接结束本层循环
break
else:
print(‘输入错误’)
4、全局标志位
tag = True
while tag:
1.获取用户输入的用户名和密码
username = input(‘username>>>:’)
password = input(‘password>>>:’)
2.判断用户名和密码是否正确
if username == ‘小明’ and password == ‘123’:
print(‘输入正确’)
直接结束本层循环
tag = False
else:
print(‘输入错误’)
5**、while嵌套**
while嵌套
while True:
1.获取用户输入的用户名和密码
username = input(‘username>>>:’)
password = input(‘password>>>:’)
2.判断用户名和密码是否正确
if username == ‘小明’ and password == ‘123’:
print(‘输入正确’)
while True:
cmd = input(‘请输入您的指令>>>:’)
判断用户是否想退出
if cmd == ‘q’:
break
print(‘正在执行您的指令:%s’ % cmd)
break
else:
print(‘输入错误’)
案例
猜年龄的游戏
普通要求
用户可以有三次猜错的机会 如果过程中猜对了直接退出
拔高要求
三次机会用完之后提示用户是否继续尝试 如果是则再给三次机会 如果否则直接结束
普通要求# 1.先编写猜年龄主体功能
定义一个真实的年龄
real_age = 18
3.定义一个计数器
count = 1
2.先加一个循环功能
while count < 4:
1.1 获取用户猜测的年龄
guess_age = input(‘请输入您猜测的年龄>>>:’)
1.2 简单粗略的将字符串转换成数字(可能会报错 暂时不要考虑)
guess_age = int(guess_age)
1.3 猜测年龄
if guess_age > real_age:
print(‘猜大了’)
4.1 每次猜错都加一
count += 1
elif guess_age < real_age:
print(‘猜小了’)
4.1 每次猜错都加一
count += 1
else:
print(‘哎呀 你真棒 猜对了!!!’)
4.猜对了直接结束本层循环
break
优化
count += 1
拔高要求# 1.先编写猜年龄主体功能
定义一个真实的年龄
real_age = 18
3.定义一个计数器
count = 1
2.先加一个循环功能
while True:
5.判断当前用户是第几次尝试
if count == 4:
choice = input(‘您已经尝试了三次 是否继续(y/n)>>>:’)
5.1 判断用户输入的是y还是n
if choice == ‘y’:
重置count的次数
count = 1
else:
print(‘再接再厉’)
break
1.1 获取用户猜测的年龄
guess_age = input(‘请输入您猜测的年龄>>>:’)
1.2 简单粗略的将字符串转换成数字(可能会报错 暂时不要考虑)
guess_age = int(guess_age)
1.3 猜测年龄
if guess_age > real_age:
print(‘猜大了’)
4.1 每次猜错都加一
count += 1
elif guess_age < real_age:
print(‘猜小了’)
4.1 每次猜错都加一
count += 1
else:
print(‘哎呀 你真棒 猜对了!!!’)
4.猜对了直接结束本层循环
break
优化
count += 1
6、while+continue
continue表示结束本次循环，直接进入下一次循环
使用while循环打印出0-10但是不打印4
1.定义一个起始变量
count = 0
2.循环
while count < 11:
5.判断 如果count为4则不打印
if count == 4:
count += 1
跳过本次循环 开始下一次循环
continue
3.打印变量的值
print(count)
4.变量值自增1
count += 1
continue会让循环体代码直接回到条件判断处重新判断
7、while+else
count = 0
while count < 5:
print(count)
count += 1
else:
print(‘呵呵’) # 会执行else子代码
count = 0
while count < 5:
if count == 3:
break
print(count)
count += 1
else:
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注软件测试）
[外链图片转存中…(img-NHVE2nqd-1713445986936)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
