【阿里内部教程】python初阶：基础语法 python全栈自动化测试系类_run shell和run module(1)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化的资料的朋友，可以戳这里获取

创建+切换分支：git checkout -b

合并某分支到当前分支：git merge

提交到远程仓库 git push

删除分支：git branch -d

Git使用工作流 ： https://blog.csdn.net/phunxm/article/details/48575797

Git常用命令：https://blog.csdn.net/lxw198902165221/article/details/89228458

强烈推荐码云这个平台，国产开源、好用，Git相关知识收集的很全面，赞！

码云提供的Git命令：Learn Git Branching

码云提供的Git大全：Git 大全 - Gitee.com

【第六小节：Python基础语法】

一，语法

​

二、编译器

支持python的编译器有很多，

我个人使用pycharm，其功能齐全，唯一的缺点的收费。

或者Visual Studio Code也是一个不错的选择.

三、基础知识

1、数据类型

数据类型包括：字符串（string）、整数类型（int）、浮点数（float）、布尔类型（boolean）[其中float(‘inf’)代表正无穷，float(‘-inf’)代表负无穷]。其关系如图：

​

2、条件判断

if语句可以通过判断条件是否成立来决定是否执行某个语句

if···else···

if···elif······else···

	"""用法如下"""
	weather = '天晴'
	if weather == '下雨':
	print('在家学习')
	elif weather == '阴天':
	print('去钓鱼')
	elif weather == '暴风雨':
	print('保命')
	else:
	print('去逛街')
	# 特殊的三目运算
	a = 3
	print(True) if a>5 else print(False)

3、循环语句

for循环

for 变量名 in 可遍历对象:
声明操作
else: # 循环结束才会去执行，可以省略！
声明操作

	for i in range(10):
	print(i)
	else:
	print("finished")

while循环

while 循环条件:

​ 声明操作

else: # 循环结束才会去执行，可以省略！

​ 声明操作

	while i<= 5:
	print(i)
	i += 1
	else:
	print('finished')
	# 死循环
	while True:
	pass
	# 99乘法表的制作
	num1 = 1
	while num1 <= 9:
	num2 = 1
	while num2 <= num1:
	print(f'{num1}*{num2}={num1 * num2:<2} ', end='')
	num2 += 1
	print('')
	num1 += 1

结束循环

continue：跳出当前循环

break：终止全部循环

4、运算符

逻辑运算符

名称	用法
or	有一个为真，则为真
and	有一个为假，则为假
not	否定作用

比较运算符

符号	用法
<	小于
>	大于
=	等于
<=	小于等于
>=	大于等于
!=	不等于

算术运算符

符号	用法
*	乘法
+	加法
-	减法
/	除法
//	整除运算
%	取余运算
**	幂运算

布尔运算符

类型	作用	范围
True	真	除False外都为真
False	假	空列表、空元组、空字典，空集合，0，空字符串等

四、类和函数

函数

def 函数名(): # 函数的命名用驼峰命名法

​ 函数体

函数名() #函数的调用：直接函数名加括号就是在调用函数，函数在调用时会执行函数里面的函数体

	def fun(): # 定义一个函数
	print("This a function")
	fun() # 调用函数

函数参数

形参：在函数体内用到的参数

必备参数：函数在调用是必须要传入的参数,给了几个参数就必须传几个参数值

关键字参数：指定参数名来传参数值

不定长参数（默认参数，可以不写）：接受的参数值不定，传多少，这个不定长参数就接受多少
一个号是元组不定长参数*args，两个**是字典不定长参数**kwargs

函数的注释 -> 提示：在help函数查看时可以看到

	def func(*args, **kwargs) -> "define function":
	print(args, 'and ', kwargs)
	func(1, 2, 3, a=1, d=2, c=3) # 其中，a=1是关键字参数，

函数的作用域

函数内部的变量不能被函数外面使用，除非通过return返回

	num1 = 20 # 这是全局变量
	def func2():
	global num1 # global 关键字声明全局变量
	num1 = num1+1
	print(num1)
	print(num1)

闭包里面的局部变量

	def func():
	num2 = 30 # 这是局部变量
	def func1():
	nonlocal num2 # nonlocal 关键字声明局部变量
	num2 = num2+1
	print(num2)
	def func2():
	print(num2)
	return func1,func2 # 外层函数返回内层函数的函数体
	a,b = func() #a = func1 a() func1()

特殊函数

递归函数：函数自身调用自己

	def recursion(n):
	if n <= 1: # 递归结束的条件
	return 1 # 结束返回1
	else:
	return n * recursion(n-1) # 一直调用自己 5*4*3*2*1
	print(recursion(5))

匿名函数：用在那些只使用一次的场景中，程序中只需要调用一次某个简单逻辑。

	def g(x):
	x = str(x)
	return x
	print(g(2))
	# 转换成匿名函数
	g = lambda x:x+1 # x就是函数g要传入的参数值，冒号后面就是对传入的参数做的操作
	g(4) # 匿名函数调用和函数一样

匿名函数也可以用在列表中

	list1 = [2,'3',1,'4',7,'9',5]
	list1.sort()
	list1.sort(key=lambda x:int(x),reverse=False)
	print(list1)

类

初级面向对象

面向对象的基本概念：类、属性、方法

类：黑白黄三种人，人类
属性：自身存在的，名字、性别、身高、体重、肤色，静态属性
方法：人会走路、吃饭、玩，动态属性

	name1 = '小' # 变量
	class Person: # class 帕斯卡命名法 PersonList
	name = '子' # 定义在类里面的变量称之为属性
	age = 18
	def play(self,name): # 定义在类里面的函数称之为方法,self指实例化对象本身 self=zilin
	print(f'{name}正在玩游戏')
	def search(self,name):
	print(f'{name}正在查资料')
	zilin = Person() # 实例化类，创建一个对象，实例化成一个具体的人
	bd = Person() # 创建第二个实例化对象bd
	bd.name = '北斗' # 重新给bd这个人给予一个名字

初始化变量

初始化函数__init__ 对属性重新赋值，让每个人拥有自己独有的属性

	class Student:
	def __init__ (self, name, age): # self指实例化对象本身 ，实例化对象是自动调用一次
	self.name = name # 等号后面的是实例化的属性
	self.age=age
	def play(self): # 定义在类里面的函数称之为方法,self指实例化对象本身 self=zilin
	print(f'{self.name}正在玩游戏') #bd.name
	def search(self):
	print(f'{self.name}正在查资料') # bd.name
	def __del__(self): # 析构函数__del__：让对象在删除时输出一句话,删除对象自动调用
	print(f'{self.name}被删除了')
	stu = Student(bd, 18) # 实例化对象时吗，就应该相对应的给初始化函数传参
	stu.play()
	stu.search()
	del stu # 删除stu这个实例化对象

类的继承

	class Student:
	def __init__ (self, name, age): # self指实例化对象本身 ，实例化对象是自动调用一次
	self.name = name # 等号后面的是实例化的属性
	self.age=age
	def play(self): # 定义在类里面的函数称之为方法,self指实例化对象本身 self=zilin
	print(f'{self.name}正在玩游戏') #bd.name
	def eat(self):
	print(f'{self.name}正在吃饭') # bd.name
	def __del__(self): # 析构函数__del__：让对象在删除时输出一句话,删除对象自动调用
	print(f'{self.name}被删除了')
	class StuYear(Student): # 继承Student中的所有方法
	def __init__(self, name, age, year):
	super().__init__(name, age) # 继承Student类的实例化对象
	self.year = year
	def study(self):
	print("name:", self.name, "age:", self.age, "year:", self.year)
	def eat(self):
	Student.eat(self) # 指定类去使用里面的方法
	super().eat() # 让重写发的子类拥有父类的方法
	print(f'{self.name}爱吃辣')
	stu = StuYear('li', 20, 20)
	stu.study()
	stu.play()
	StuYear.eat(self=stu)

多继承

使用’'类名.mro()"方法查看继承顺序

	class A:
	pass
	class B:
	pass
	class C:
	pass
	class D(A, B, C): # 调用顺序为A, B, C
	pass
	print(D.mro()) # 查看继承顺序

高级面向对象

魔法方法

	class Person:
	def __init__(self,name):
	self.name = name
	def eat(self):
	print(f'{self.name}在吃饭')
	kun = Person('kun')
	hasattr(kun,'name') # 判断属性是否存在
	getattr(kun,'name') # 得到属性值，没有则报错
	setattr(kun,'name','一') # 设置属性值，有则改，无则加
	delattr(kun,'name') # 删除属性
	issubclass(Person,object) # issubclass 判断第一个类是不是后面类的子类
	isinstance(zilin,Person) # isinstance 判断实例是否是后面类的实例对象
	isinstance(1,(str,int,float)) # 还可以用来判断数据类型
	type(zilin) == Person # 只能判断单个类实例化衍生

__new__方法：new魔法方法创建实例化对象，以及如何让init初始化方法拥有参数去使用

	class Person:
	def __new__(obj,*args,**kwargs): #object祖宗类，new方法才是帮我们创建实例化对象的一个方法
	print('new实例方法')
	return object.__new__(obj) # Person.eat(self)
	def __init__(self,name):
	print('init自动调用')
	self.name = name
	zilin = Person('kun')

单例模式 ： 创建的所有的实例化对象都是同一个对象

	class Person:
	def __new__(obj,*args,**kwargs): #object祖宗类，new方法才是帮我们创建实例化对象的一个方法
	if not hasattr(obj,'_instance'): #not取反返回True，判断祖宗类object里面有没有这个_instance
	#通过属性限制他去创建多个新的实例对象
	obj._instance = object.__new__(obj) #object.__new__(obj) 生成一个新的实例化对象
	return obj._instance #返回实例化对象
	def __init__(self,name):
	print('init自动调用')
	self.name = name
	z = Person('z') # 立第一个实例化对象会在object类去创建一个_instance属性
	b = Person('b') # 建第二个实例化对象判断属性存在返回第一个实例化对象
	y = Person('y') # 第三个实例化对象判断属性存在还是返回第一个实例化对象
	z==b==y # 上创建的都是同一个实例对象

输出魔法方法 __str__ __repr__

	class Person:
	def __init__(self,name,age):
	self.name = name
	self.age = age
	def __str__(self): # 针对print输出魔法方法
	return f'这个是{self.name}的str魔法方法'
	def __repr__(self): # 直接输出实例对象时会调用
	return f'这个是{self.name}的repr魔法方法'
	z = Person('z',18)
	z # repr方法调用
	print(z) # str方法调用

__call__方法：让实例对象像函数一样去调用

	class Person:
	def __init__(self,name,age):
	self.name = name
	self.age = age
	def __call__(self,x,y):
	return x+y
	z = Person('z',18)
	z(1, 2)

协议

序列协议

	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 <module>
    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 <module>
    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 集合强转规律

1. 如果是字符串:把字符串中的每一个字符当成新的元素放到集合中
2. 如果是其他数据:就是单纯的把原标识符换成{} 变成集合即可​​

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


![img](https://img-blog.csdnimg.cn/img_convert/2e9ea0d51e00b09f93eeff76be0ced83.png)
![img](https://img-blog.csdnimg.cn/img_convert/bbab212f599282e42177106be59e71c9.png)
![img](https://img-blog.csdnimg.cn/img_convert/41e8ca8bc173081d2305428ac8c4ab05.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618608311)**

# 位与,可结合赋值运算&=
"""
规则: 都为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


[外链图片转存中...(img-bXlT6hvE-1715071754814)]
[外链图片转存中...(img-SZ7bLape-1715071754815)]
[外链图片转存中...(img-aKMsA1l8-1715071754815)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上软件测试知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618608311)**