devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【阿里内部教程】python初阶：基础语法 python全栈自动化测试系类_python代码规范阿里巴巴

作者：我家自动化 | 2024-04-03 00:21:35

赞

踩

python代码规范阿里巴巴

目录

很多小伙伴可能都没有看过凡哥的视频，所以大家可能对凡哥不是很了解这里先和大家来个自我介绍

凡哥我已经有着十二年互联网自动化测试和测试开发工程师，拥有丰富的自动化测试平台及测试开发经验，擅长接口测试、Python自动化全栈，测试开发平台等，参与过亿级用户金融系统测试开发平台架构以及开发，曾主导过多家一线互联网公司自动化测试平台或自动化测试框架的搭建，参与项目涵盖金融、电商、教育等多个行业。好就介绍这么多，接下来就开始正题废话少说让我们开始把

【本系列文章是从入门到精通全套文章教程，当然也有视频教程，需要的看文章末尾】

【第一小节：python  pycharm 安装】

一.python安装 

二.配置环境变量

三，验证一下

四，安装pycharm

五，更换下载源

六，更新pip

七，PyCharm配置

【第二小节：selenium +python环境搭建】

一、selenium简介

二、python安装

三、配置环境变量

1.  搜索环境变量

2. 在System Properties窗口中找到Environment Variables并点击此按钮。

 3. 编辑System variables中的Path（可双击打开编辑窗口，也可选中Path后点击Edit按钮打开编辑窗口）。

四、安装selenium

五、浏览器

1. 安装浏览器，并根据浏览器版本下载对应的浏览器驱动，将驱动文件放到python根目录。

六、最终验证自动化环境是否配置成功

【第三小节：python环境变量】

1.变量是什么？

2.声明变量

3.变量定义的规则

4.常量

5.注释

6.Python的基础数据类型

7.判断变量是什么数据类型

【第四小节：python IDLE使用方法详解】

1.简介

在代码编辑区中，编写多行代码。例如，输出由宋词《江城子》改编而成的《程序员之歌》，代码如下：

按下快捷键

运行程序后，将打开 Python Shell 窗口显示运行结果，

【第五小节：Python集成开发环境Pycharm+Git+Gitee】

一、环境介绍

二、环境搭建

1）注册码云账户，创建代码远端仓库

2）安装Git，可以自己去官网下载 https://git-scm.com/  或者百度云盘提取，直接下一步安装至结束，鼠标右击桌面出现Git GUI Here和Git Bash Here则说明安装成功！

3）Pycharm 配置Git

4）代码托管到远端仓库码云

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

一，语法

二、编译器

三、基础知识

1、数据类型

2、条件判断

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

3、循环语句

for循环

while循环

4、运算符

逻辑运算符

比较运算符

算术运算符

布尔运算符

四、类和函数

函数

函数参数

特殊函数

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

类

初始化变量

类的继承

多继承

高级面向对象

魔法方法

迭代器协议

生成器和装饰器

内置装饰器

五、常用操作

格式化操作

format方法

常用函数

异常信息

六、文件管理

文件读写

OS模块

sys模块

七、模块和包

模块

导包

【第七小节：python（变量类型）】

序

变量赋值

多个变量赋值

标准数据类型

number

string（字符串）

list（列表） （用【】）

tuple（元组）（不能二次赋值）（用（））

dictionary （字典）（用{}）

Python数据类型转换

【第八小节：Python数据类型转换】

一 自动类型转换

二 强制类型转换

2.1 把数据强制转换成整型 int 

2.2  float   (整型   浮点型 布尔类型  纯数字字符串)

2.3 bool类型

三 容器类型数据的强制类型转换

3.1  str 强转成字符串类型

3.2 list 列表

3.3 tuple 元组

3.4 set 集合

3.5 二级容器

3.6 字典的强制类型转换

【第九小节：Python 内置函数]

分类

按参数和返回值分类

按来源分类

内置函数

【第十小节：python运算符】

什么是运算符

1、算术运算符

2、比较运算符

3、赋值运算符

4、位运算符

5、逻辑运算符

6、成员运算符

7、身份运算符

运算符优先级

【第十一小节：python流程控制】

 　1、概念

 　2、执行流程的三种情况

 　3、必知必会

if语法

 　1、单分支（单if）

 　2、双分支（if 和else一起使用）

 　3、多分支（if、elif以及else共同使用）

 　4、if嵌套

 　小练习

while循环

 　1、语法

 　2、基本用法示例

 　3、while+break

 　4、全局标志位

 　5、while嵌套

 　　案例

 　6、while+continue

 　7、while+else

 　8、死循环

for循环

 　1、语法

 　　演示

 　2、range关键字

 　　3、for+break

 　4、for+continue

 　5、for+else

 　6、for循环嵌套

【第一小节：python  pycharm 安装】

凡哥有话bb：如果想要安装包，学习资料，教学视频，有关于不懂的技术类问题的小伙伴也可以找到我们的蓓蓓小姐姐微信：【mashang-qq】备注【csdn000】【必须备注不然不会通过哦】我们还有大佬在线答疑群

群号：【913569736】（备注“csdn000”）群里的免费资料都可以找蓓蓓小姐姐领取。还有同行大神一起交流技术哦。

一.python安装 

小伙子踏入python门，从此python人，加油打工人

​

​


​

​

二.配置环境变量

​

​

三，验证一下

​

​

四，安装pycharm

​

五，更换下载源

​


试一下安装numpy

​

六，更新pip

说明pip可以更新

​


进行更新操作命令

​

七，PyCharm配置

​

​


 

​

​


更换一下字体大小

​

 

感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走：

①　2000多本Python电子书（主流和经典的书籍应该都有了）

②　Python标准库资料（最全中文版）

③　项目源码（四五十个有趣且经典的练手项目及源码）

④　Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）


 ⑤ Python学习路线图（告别不入流的学习）

在我的QQ技术交流群里（技术交流和资源共享，广告进来腿给你打断）

可以自助拿走，群号913569736（备注“csdn000”）群里的免费资料都是笔者十多年测试生涯的精华。还有同行大神一起交流技术哦。

作者有话bb：

这篇文章写的是关于python的安装，下一咱们正式开始说selenium+python的环境搭建以及环境变量的原理，从最基础python环境搭建以及环境变量的原理来学习，慢慢的积累，从0开始，凡哥相信各位一定会有所收获。

人生格言：学习不是记录表象，而是掌握本质

【第二小节：selenium +python环境搭建】

一、selenium简介

Selenium 是用于测试 Web 应用程序用户界面 (UI) 的常用框架。它是一款用于运行端到端功能测试的超强工具。支持的浏览器包括IE（7, 8, 9, 10, 11），Mozilla Firefox，Safari，Google Chrome，Opera，Edge等。

Selenium的发展经历了三个阶段，第一个阶段，也就是selenium1的时代，在运行selenium1.0程序之前，我们得先启动selenium server端(selenium remote control)，我们简称RC。RC主要包括三个部分：launcher，http proxy，selenium core。其中selenium core是被selenium server嵌入到浏览器页面中的，selenium core内部是一堆javascript函数构成，通过调用这些函数来实现对浏览器的各种操作。

很显然比较繁琐，这并不是最佳自动化解决方案，于是后来有了webdriver。

selenium2 的时代合并了webdriver，也就是我们通常说的selenium，selenium2是默认支持Firefox浏览器的，这点非常方便。当然也支持其他更多浏览器，Ie和chrome浏览器需要下载驱动包，并添加到环境变量下

selenium3 是2016年十月份左右出来的，并且现在默认安装都是selenium3了，selenium3在selenium2的基础上做了一些调整，最明显的区别就是 selenium2对Firefox的支持最高只支持46及以下版本。selenium3可以支持47以上版本，但是需要下载geckodriver.exe驱动，并添加到环境变量path下。

二、python安装

下载最开始说到了，详情请看文章开头

1. 下载完成后，直接安装即可，安装过程中可选择自己的安装路径（注意安装路径要记得，后续配置环境变量用到）。

三、配置环境变量

中文的环境变量配置路径：搜索到环境变量 -> 双击环境变量中的Path -> 点击新建按钮，把python的安装路径复制上，点击确定按钮即可完成环境变量编辑。

1.  搜索环境变量

​

2. 在System Properties窗口中找到Environment Variables并点击此按钮。

​

 3. 编辑System variables中的Path（可双击打开编辑窗口，也可选中Path后点击Edit按钮打开编辑窗口）。

​

 4. 点击Edit environment variable的New按钮添加ptyhon的安装路径（python的安装路径即python.exe所在路径，对应python安装中第3步骤的路径），点击OK保存环境变量配置。

 5. 检查环境python环境变量是否配置成功：

　　A、win + R 或在windows的搜索框搜索cmd，打开DOS窗口。

　　B、输入python，回车，假如出现python版本等信息即说明python安装成功且环境变量配置成功。

​

四、安装selenium

1.WIN+R打开DOS窗口输入：pip(如果有内容显示，说明正常)

2.cmd输入指令安装selenium：pip install selenium

注释：如果想安装指定版本的selenium 则可吧输入的命令改为pip install selenium==3.141.0，其中“==”后面是对应的版本号。

3.验证selenium是否正常工作

　　1）在DOS窗口输入命令：python

　　2）在进入命令行后输入命令：from selenium import webdirver

　　假如没有出现报错信息，则证明selenium可正常工作。

​

五、浏览器

1. 安装浏览器，并根据浏览器版本下载对应的浏览器驱动，将驱动文件放到python根目录。

　如下图，有Chrome和Edge的对应浏览器驱动。

​

六、最终验证自动化环境是否配置成功

1.创建python文件，运行如下代码，确认是否能成功打开浏览器。

1 # coding: utf-8
2 from selenium import webdriver
3 driver = webdriver.Chrome()
4 driver.get("https://www.baidu.com")

【第三小节：python环境变量】

1.变量是什么？

变量是把程序运行的结果临时存在内存里，一遍后续的代码调用。

2.声明变量

name = '小明'

上述代码声明了一个变脸，变量名为：name，变量name的值为："小明"

变量的作用：昵称，其代指内存里某个地址中保存的内容

3.变量定义的规则

  • 变量名只能是字母、数字或下划线的任意组合

  • 变量名的第一个字符不能是数字

  • 变量名不能为以下关键字：['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

  • 变量名要具有描述性

  • 变量名不能使用中文，不能过长

4.常量

  • 生活中一直不变的：身份证号码，历史发生的时间

  • 常量一直不变的量，Python中没有真正的常量，为了应和其他语言，全部大写的变量称之为常量。

  • 将变量全部大写，放在文件最上边

  • 设置一些不变的量如：身份证号，性别和名字

5.注释

  • 便于理解对方的代码和自己的代码

  • 单行注释#，多行注释 '''被注释的内容'''

  • 难以理解的代码后面加注释（函数，类，文件都需要注释来解释说明）

6.Python的基础数据类型

  • int（整型）：1，2，3，123，123123

在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807

  • str（字符串）：在Python中,加了引号的字符都被认为是字符串。

#单双引号配合使用
countent = "i'm zfs ,18 years old"
#三引号使用，换行的字符串
msg = '''
今天天气真好，
我想写首小诗。
'''
print(msg)
#字符串拼接
s1 = 'zfs' 
s2 = 'shuai'
s3 = s1 + s2 
print(s3)
#str * int
s1 = '帅'
print(s1 * 8

  • bool（布尔值）：True或False，用于逻辑判断

print(2<1)
print(2>1)

7.判断变量是什么数据类型

 s1 = '100'
 s2 = 100
print(s1,type(s1))
print(s2,type(s2))

【第四小节：python IDLE使用方法详解】

1.简介

在安装 Python(Windows安装Python（图解） 后，会自动安装一个 IDLE，它是一个 Python Shell (可以在打开的 IDLE 窗口的标题栏上看到），程序开发人员可以利用 Python Shell 与 Python 交互。

本节将以 Windows7 系统中的 IDLE 为例，详细介绍如何使用 IDLE 开发 Python 程序。

单击系统的开始菜单，然后依次选择“所有程序 -> Python 3.6 -> IDLE (Python 3.6 64-bit)”菜单项，即可打开 IDLE 窗口，如图 1 所示。

​


图 1 IDLE主窗口

前面我们己经应用 IDLE 输出了简单的语句，但在实际开发中，通常不能只包含一行代码，当需要编写多行代码时，可以单独创建一个文件保存这些代码，在全部编写完成后一起执行。具体方法如下：

    1. 在 IDLE 主窗口的菜单栏上，选择“File -> New File”菜单项，将打开一个新窗口，在该窗口中，可以直接编写 Python 代码。
      在输入一行代码后再按下 <Enter> 键，将自动换到下一行，等待继续输入，如图 2 所示。

      ​


      图 2 新创建的 Python 文件窗口

    2. 在代码编辑区中，编写多行代码。例如，输出由宋词《江城子》改编而成的《程序员之歌》，代码如下：

      1. print(” “*5+“程序员之歌”)
      2. print(” “*15+“——《江城子》改编\n”)
      3. print(“十年生死两茫茫，写程序，到天亮，”)
      4. print(“千行代码，Bug何处藏。”)
      5. print(“纵使上线又怎样，朝令改，夕断肠。”)
      6. print(“领导每天新想法，天天改，日日忙。”)
      7. print(“相顾无言，惟有泪千行”)
      8. print(“每晚灯火阑珊处，程序员，加班狂。”)

      编写代码后的 Python 文件窗口如图 3 所示。

      ​


      图 3 编写代码后的 Python 文件窗口

    3. 按下快捷键

    4. <Ctrl+S> 保存文件，这里将文件名称设置为 demo.py。其中，.py 是 Python 文件的扩展名。在菜单栏中选择“Run -> Run Module”菜单项（也可以直接按下快捷键 <F5>），运行程序，如图 4 所示。

      ​


      图 4 运行程序

    5. 运行程序后，将打开 Python Shell 窗口显示运行结果，

    6. 如图 5 所示。

      ​


      图 5 运行结果

【第五小节：Python集成开发环境Pycharm+Git+Gitee】

一、环境介绍

   PyCharm是一种Python IDE，带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。

   Git(读音为/gɪt/。)是一个开源的分布式版本控制系统，可以有效、高速地处理从很小到非常大的项目版本管理。   Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。

   码云(gitee.com)是 OSCHINA.NET 推出的代码托管平台,支持 Git 和 SVN,提供免费的私有仓库托管。目前已有超过 350 万的开发者选择码云。（国产）

二、环境搭建

1）注册码云账户，创建代码远端仓库

  •      码云地址： https://gitee.com/     建议使用邮箱注册，笔者没有使用所以又进行了邮箱绑定

　

​

  • 创建远端代码仓库

​

  • 红框地址就是远端库地址，提交或者更新代码都是这个地址

​

2）安装Git，可以自己去官网下载 https://git-scm.com/  或者百度云盘提取，直接下一步安装至结束，鼠标右击桌面出现Git GUI Here和Git Bash Here则说明安装成功！

　　链接：https://pan.baidu.com/s/1AMJgPTCANWrysQCqWCFU8w
　　提取码：8o54


　　注意：在Git Bash Here 设置一下Git 用户名和邮箱，提交代码会用到

　　$ git config --global user.name “wirelessqa”
　　$ git config --global user.email wirelessqa.me@gmail.com

3）Pycharm 配置Git

  •  　安装Pycharm见笔者另一篇博客：https://www.cnblogs.com/xjx767361314/p/10195661.html
  • 　 设置git管理代码

​

  • 将开发的代码托管到本地仓库Git   
  • 初始化仓库：git init

​

  • 添加代码到本地仓库：git add .
  • 查看本地仓库代码状态：git status 

​

4）代码托管到远端仓库码云

  •   配置远端仓库地址

​

  • 将码云仓库地址粘贴到这里，需要进行码云账户验证，注册的账户信息

​

  • 点击提交图标或快捷键ctrl+k提交代码到远端码云,可以commit或者commit&push

​

  • 笔者是没有commit&push 而是terminal窗口命令push的，但效果是一样的！

​

  • 登录远端仓库码云，查看代码情况，至此环境搭建完成，代码提交成功！ 

​

  •  多人协同开发，配置仓库成员，建议链接分享，直接利用Pycharm导入即可

​

​

  • Pycharm 导入远端库码云代码,利用git命令或者Pycharm工具自带方式创建分支，分支开发，最后合并到master

​

最后 Git常用命令列举：

添加文件到Git仓库，分两步：

使用命令git add .  

使用命令git commit -m   描述提交内容

分支使用：

查看分支：git branch

创建分支：git branch

切换分支：git checkout

推送自己的修改到远程分支 git push origin

创建+切换分支：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尚未实现的方法
SyntaxErrorPython 语法错误
IndentationError缩进错误
TabErrorTab 和空格混用
SystemError一般的解释器系统错误
TypeError对类型无效的操作
ValueError传入无效的参数
UnicodeErrorUnicode 相关的错误
UnicodeDecodeErrorUnicode 解码时的错误
UnicodeEncodeErrorUnicode 编码时错误
UnicodeTranslateErrorUnicode 转换时错误
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完全不一样，同时注意的地方也有许多，缩进，继承，类，等等。
 

 
 
 
  
  1. counter = 100 # 赋值整型变量
  2. miles = 1000.0 # 浮点型
  3. name = "John" # 字符串
  4.  
  5. print(name)
 
 
 

 

在这里插入图片描述​
 

多个变量赋值
 

 
 
 
  
  1. a, b, c = 1, 2, "john"
  2. a = b = c = 1
 
 
 

 

标准数据类型
 

number
 

 
 
 
  
  1. var1 = 1
  2. 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 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。左闭右开
 

 
 
 
  
  1. s = 'abcdef'
  2. print(s[1:5])
 
 
 

 

在这里插入图片描述​
 

可以像C语言数组一样使用切片功能。
 加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
 

 
 
 
  
  1. str = 'Hello World!'
  2.  
  3. print (str)           # 输出完整字符串
  4. print (str[0])        # 输出字符串中的第一个字符
  5. print (str[2:5])      # 输出字符串中第三个至第六个之间的字符串
  6. print (str[2:])       # 输出从第三个字符开始的字符串
  7. print (str * 2)       # 输出字符串两次
  8. print (str + "TEST")  # 输出连接的字符串
 
 
 

 

在这里插入图片描述​
 Python 列表截取可以接收第三个参数，参数作用是截取的步长，在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串
 

list（列表） （用【】）
 

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
 列表用 [ ] 标识，是 python 最通用的复合数据类型。
 列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
 

操作和string类似
 

tuple（元组）（不能二次赋值）（用（））
 

元组是另一个数据类型，类似于 List（列表）。
 

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
 

 
 
 
  
  1. tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
  2. tinytuple = (123, 'john')
 
 
 

 

同切片操作
 

dictionary （字典）（用{}）
 

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
 

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
 

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
 

 
 
 
  
  1. dict = {}  # 创建空字典
  2. dict['one'] = "This is one"  # 为字典赋键值对
  3. dict[2] = "This is two"
  4.  
  5. tinydict = {'name': 'runoob', 'code': 6734, 'dept': 'sales'}
  6. print(dict['one'])  # 输出键为'one' 的值
  7. print(dict[2])  # 输出键为 2 的值
  8. print(dict)
  9. print(tinydict)  # 输出完整的字典
  10. print(tinydict.keys())  # 输出所有键
  11. 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 除以 yb / a 输出结果 2.1
%取模 - 返回除法的余数b % a 输出结果 1
**幂 - 返回x的y次幂a**b 为10的21次方
//取整除 - 向下取接近商的整数>>> 9//2 4 >>> -9//2 -5
 

以下实例演示了Python所有算术运算符的操作：
 

实例(Python 3.0+)
 

 
 
 
  
  1. #!/usr/bin/python3
  2.  
  3. a = 21
  4. b = 10
  5. c = 0
  6.  
  7. c = a + b
  8. print ("1 - c 的值为：", c)
  9.  
  10. c = a - b
  11. print ("2 - c 的值为：", c)
  12.  
  13. c = a * b
  14. print ("3 - c 的值为：", c)
  15.  
  16. c = a / b
  17. print ("4 - c 的值为：", c)
  18.  
  19. c = a % b
  20. print ("5 - c 的值为：", c)
  21.  
  22. # 修改变量 a 、b 、c
  23. a = 2
  24. b = 3
  25. c = a**b 
  26. print ("6 - c 的值为：", c)
  27.  
  28. a = 10
  29. b = 5
  30. c = a//b 
  31. print ("7 - c 的值为：", c)
 
 
 

 

以上实例输出结果：
 

 
 
 
  
  1. 1 - c 的值为： 31
  2. 2 - c 的值为： 11
  3. 3 - c 的值为： 210
  4. 4 - c 的值为： 2.1
  5. 5 - c 的值为： 1
  6. 6 - c 的值为： 8
  7. 7 - c 的值为： 2
 
 
 

 

 

结果总是隐式转换为复杂类型
 

 
 
 
  
  1. # 正负
  2. >>> +x
  3. 521
  4. >>> -x
  5. -521
  6.  
  7. # 加法,可结合赋值运算+=
  8. >>> x + 0
  9. 521
  10.  
  11. # 减法,可结合赋值运算-=
  12. >>> x - 21
  13. 500
  14.  
  15. # 乘法,可结合赋值运算*=
  16. >>> z * 100
  17. 521.0
  18.  
  19. # 除法,可结合赋值运算/=或//=
  20. """
  21. 兼容特性: from __future__ import division
  22. """
  23. # Python2中对于包含小数使用真除法(保留小数部分,最终为小数)
  24. >>> x / 100.
  25. 5.21
  26. # Python3中对于包含小数使用真除法(保留小数部分,最终为小数)
  27. >>> x / 100.
  28. 5.21
  29. # Python2中对于全整数使用传统除法(保留整数部分,最终为整数)
  30. >>> x / 100
  31. 5
  32. # Python3中对于全整数使用真除法(保留小数部分,最终为小数)
  33. >>> x / 100
  34. 5.21
  35. # Python2中对于包含小数使用地板除(保留整数部分,最终为小数)
  36. # Python3中对于包含小数使用地板除(保留整数部分,最终为小数)
  37. >>> x // 100.
  38. 5.0
  39. # Python2中对于全整数使用地板除(保留整数部分,最终为整数)
  40. # Python3中对于全整数使用地板除(保留整数部分,最终为整数)
  41. >>> x // 100
  42. 5
  43.  
  44. # 取模,可结合赋值运算%=
  45. >>> x % 2
  46. 1
  47.  
  48. # 乘方,可结合赋值运算**=
  49. >>> z * 10 ** 2
  50. 521.0
  51.  
  52. >>> 5 + 4  # 加法
  53. 9
  54. >>> 4.3 - 2 # 减法
  55. 2.3
  56. >>> 3 * 7  # 乘法
  57. 21
  58. >>> 2 / 4  # 除法，得到一个浮点数
  59. 0.5
  60. >>> 2 // 4 # 除法，得到一个整数
  61. 0
  62. >>> 17 % 3 # 取余 
  63. 2
  64. >>> 2 ** 5 # 乘方
  65. 32
 
 
 

 

 
 
 
  
  1. >>> 2 & (2 - 1)
  2. 0
  3.  
  4. >>> 8 & (8 - 1)
  5. 0
  6.  
  7. >>> 16 & (16 - 1)
  8. 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所有比较运算符的操作：
 

 

 
 
 
  
  1. #!/usr/bin/python3
  2.  
  3. a = 21
  4. b = 10
  5. c = 0
  6.  
  7. if ( a == b ):
  8.    print ("1 - a 等于 b")
  9. else:
  10.    print ("1 - a 不等于 b")
  11.  
  12. if ( a != b ):
  13.    print ("2 - a 不等于 b")
  14. else:
  15.    print ("2 - a 等于 b")
  16.  
  17. if ( a < b ):
  18.    print ("3 - a 小于 b")
  19. else:
  20.    print ("3 - a 大于等于 b")
  21.  
  22. if ( a > b ):
  23.    print ("4 - a 大于 b")
  24. else:
  25.    print ("4 - a 小于等于 b")
  26.  
  27. # 修改变量 a 和 b 的值
  28. a = 5;
  29. b = 20;
  30. if ( a <= b ):
  31.    print ("5 - a 小于等于 b")
  32. else:
  33.    print ("5 - a 大于  b")
  34.  
  35. if ( b >= a ):
  36.    print ("6 - b 大于等于 a")
  37. else:
  38.    print ("6 - b 小于 a")
 
 
 

 

以上实例输出结果：
 

 
 
 
  
  1. 1 - a 不等于 b
  2. 2 - a 不等于 b
  3. 3 - a 大于等于 b
  4. 4 - a 大于 b
  5. 5 - a 小于等于 b
  6. 6 - b 大于等于 a
 
 
 

 

 

 
 
 
  
  1. # 值比较
  2. # 小于
  3. >>> y < x
  4. True
  5.  
  6. # 小于等于
  7. >>> x <= x
  8. True
  9.  
  10. # 大于
  11. >>> x > y
  12. True
  13.  
  14. # 大于等于
  15. >>> x >= y
  16. True
  17.  
  18. # 等于
  19. >>> x == x
  20. True
  21.  
  22. # 不等于
  23. # for Python2
  24. >>> x != y
  25. True
  26. >>> x <> y
  27. True
  28. # for Python3
  29. >>> x != y
  30. True
  31.  
  32. # 地址比较
  33. >>> id(x), id(521)
  34. (140428868352096, 140428868352072)
  35. >>> x is 521
  36. 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+)
 

 
 
 
  
  1. #!/usr/bin/python3
  2.  
  3. a = 21
  4. b = 10
  5. c = 0
  6.  
  7. c = a + b
  8. print ("1 - c 的值为：", c)
  9.  
  10. c += a
  11. print ("2 - c 的值为：", c)
  12.  
  13. c *= a
  14. print ("3 - c 的值为：", c)
  15.  
  16. c /= a 
  17. print ("4 - c 的值为：", c)
  18.  
  19. c = 2
  20. c %= a
  21. print ("5 - c 的值为：", c)
  22.  
  23. c **= a
  24. print ("6 - c 的值为：", c)
  25.  
  26. c //= a
  27. print ("7 - c 的值为：", c)
 
 
 

 

以上实例输出结果：
 

 
 
 
  
  1. 1 - c 的值为： 31
  2. 2 - c 的值为： 52
  3. 3 - c 的值为： 1092
  4. 4 - c 的值为： 52.0
  5. 5 - c 的值为： 2
  6. 6 - c 的值为： 2097152
  7. 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二进制格式如下：
 

 
 
 
  
  1. a = 0011 1100
  2. b = 0000 1101
  3.  
  4. -----------------
  5.  
  6. a&b = 0000 1100
  7. a|b = 0011 1101
  8. a^b = 0011 0001
  9. ~a  = 1100 0011
 
 
 

 

运算符描述实例
&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ，二进制解释： 0000 1100
|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。(a | b) 输出结果 61 ，二进制解释： 0011 1101
^按位异或运算符：当两对应的二进位相异时，结果为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二进制格式如下：
 

 
 
 
  
  1. #!/usr/bin/python3
  2.  
  3. a = 60            # 60 = 0011 1100 
  4. b = 13            # 13 = 0000 1101 
  5. c = 0
  6.  
  7. c = a & b;        # 12 = 0000 1100
  8. print ("1 - c 的值为：", c)
  9.  
  10. c = a | b;        # 61 = 0011 1101 
  11. print ("2 - c 的值为：", c)
  12.  
  13. c = a ^ b;        # 49 = 0011 0001
  14. print ("3 - c 的值为：", c)
  15.  
  16. c = ~a;           # -61 = 1100 0011
  17. print ("4 - c 的值为：", c)
  18.  
  19. c = a << 2;       # 240 = 1111 0000
  20. print ("5 - c 的值为：", c)
  21.  
  22. c = a >> 2;       # 15 = 0000 1111
  23. print ("6 - c 的值为：", c)
 
 
 

 

 
 
 
  
  1. >>> bin(x)
  2. '0b1000001001'
  3.  
  4. # 左移,可结合赋值运算<<=
  5. """
  6. 规则: 左
  7. """
  8. >>> bin(x << 2)
  9. '0b100000100100'
  10.  
  11. # 右移,可结合赋值运算>>=
  12. >>> bin(x >> 2)
  13. '0b10000010'
  14.  
  15. # 位与,可结合赋值运算&=
  16. """
  17. 规则: 都为1为1,否则为0
  18. 100000100100
  19. 000010000010
  20. ------------
  21. 000000000000
  22. """
  23. >>> 0b100000100100 & 0b10000010
  24. 0
  25.  
  26. # 位或,可结合赋值运算|=
  27. """
  28. 规则: 存在1为1,否则为0
  29. 100000100100
  30. 000010000010
  31. ------------
  32. 100010100110
  33. """
  34. >>> 0b100000100100 | 0b10000010
  35. 2214
  36.  
  37. # 异或,可结合赋值运算^=
  38. """
  39. 规则: 不同为1,相同为0
  40. 100000100100
  41. 000010000010
  42. ----------
  43. 100010100110
  44. """
  45. >>> 0b100000100100 ^ 0b10000010
  46. 2214
  47.  
  48. # 取反,可结合赋值运算～=
  49. """
  50. 规则: 1变为0,0变为1
  51. 0000001000001001
  52. ----------------
  53. 1111110111110110  取反,此时最高位为1表示负数,负数的存储需要将其转换为补码
  54. ----------------
  55. 1000001000001001  反码,保持符号位不变,其它位置取反
  56. ----------------
  57. 1000001000001010  补码,在反码的基础上最低位+1
  58. ----------------
  59. -522
  60. """
  61. >>> ~0b1000001001
  62. -522
 
 
 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/354139
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。