目录
很多小伙伴可能都没有看过凡哥的视频，所以大家可能对凡哥不是很了解这里先和大家来个自我介绍
凡哥我已经有着十二年互联网自动化测试和测试开发工程师，拥有丰富的自动化测试平台及测试开发经验，擅长接口测试、Python自动化全栈，测试开发平台等，参与过亿级用户金融系统测试开发平台架构以及开发，曾主导过多家一线互联网公司自动化测试平台或自动化测试框架的搭建，参与项目涵盖金融、电商、教育等多个行业。好就介绍这么多，接下来就开始正题废话少说让我们开始把
【本系列文章是从入门到精通全套文章教程，当然也有视频教程，需要的看文章末尾】
2. 在System Properties窗口中找到Environment Variables并点击此按钮。
3. 编辑System variables中的Path（可双击打开编辑窗口，也可选中Path后点击Edit按钮打开编辑窗口）。
1. 安装浏览器，并根据浏览器版本下载对应的浏览器驱动，将驱动文件放到python根目录。
在代码编辑区中，编写多行代码。例如，输出由宋词《江城子》改编而成的《程序员之歌》，代码如下：
运行程序后，将打开 Python Shell 窗口显示运行结果，
【第五小节：Python集成开发环境Pycharm+Git+Gitee】
匿名函数：用在那些只使用一次的场景中，程序中只需要调用一次某个简单逻辑。
2.2 float (整型 浮点型 布尔类型 纯数字字符串)
【第一小节：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 输出了简单的语句，但在实际开发中，通常不能只包含一行代码，当需要编写多行代码时，可以单独创建一个文件保存这些代码，在全部编写完成后一起执行。具体方法如下：
-
- 在 IDLE 主窗口的菜单栏上，选择“File -> New File”菜单项，将打开一个新窗口，在该窗口中，可以直接编写 Python 代码。
在输入一行代码后再按下 <Enter> 键，将自动换到下一行，等待继续输入，如图 2 所示。
图 2 新创建的 Python 文件窗口 -
在代码编辑区中，编写多行代码。例如，输出由宋词《江城子》改编而成的《程序员之歌》，代码如下：
- print(” “*5+“程序员之歌”)
- print(” “*15+“——《江城子》改编\n”)
- print(“十年生死两茫茫，写程序，到天亮，”)
- print(“千行代码，Bug何处藏。”)
- print(“纵使上线又怎样，朝令改，夕断肠。”)
- print(“领导每天新想法，天天改，日日忙。”)
- print(“相顾无言，惟有泪千行”)
- print(“每晚灯火阑珊处，程序员，加班狂。”)
编写代码后的 Python 文件窗口如图 3 所示。
图 3 编写代码后的 Python 文件窗口 -
按下快捷键
- <Ctrl+S> 保存文件，这里将文件名称设置为 demo.py。其中，.py 是 Python 文件的扩展名。在菜单栏中选择“Run -> Run Module”菜单项（也可以直接按下快捷键 <F5>），运行程序，如图 4 所示。
图 4 运行程序 -
运行程序后，将打开 Python Shell 窗口显示运行结果，
- 如图 5 所示。
图 5 运行结果
- 在 IDLE 主窗口的菜单栏上，选择“File -> New File”菜单项，将打开一个新窗口，在该窗口中，可以直接编写 Python 代码。
【第五小节：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 | 尚未实现的方法 |
| 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 集合强转规律
- 如果是字符串:把字符串中的每一个字符当成新的元素放到集合中
- 如果是其他数据:就是单纯的把原标识符换成{} 变成集合即可
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 |
|
等长的二级容器
(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。 | (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二进制格式如下：
#!/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:
print('呵呵') # 不会执行else子代码
"""
当while循环没有被人为中断(break)的情况下才会走else
"""
8、死循环
while True:
print(1)
for循环
for循环可以做的事情while都可以做，之所以使用for循环是在循环取值时，for循环比while循环的使用更为简洁
1、语法
for 变量名 in 可迭代对象：#（此时只需要知道可迭代对象是字符串、列表、字典，后面会专门讲解）
代码一
代码二
ps:变量名如果没有合适的名称 那么可以使用i,j,k,v,item等
演示
# 列表
for i in ['a','b','c']:
print(i)
# 字符串
for i in 'hello world':
print(i)
# 字典
d = {'name': '小明', 'age': 18, }
for k in d:
print(k, d[k])
2、range关键字
# 第一种:一个参数 从0开始 顾头不顾尾
for i in range(10): # 0,1,2,3,4,5,6,7,8,9
print(i)
# 第二种:两个参数 自定义起始位置 顾头不顾尾
for i in range(4, 10): #4,5,6,7,8,9
print(i)
# 第三种:三个参数 第三个数字用来控制等差值
for i in range(2, 100, 10): # 2,12,22,32,42,52,62,72,82,92
print(i)
range在不同版本的解释器中 本质不同
在python2.X中range会直接生成一个列表
在python2.X中有一个xrange也是迭代器
在python3.X中range是一个迭代器 节省内存空间
'''python2.X中xrange就是python3.x里面的range'''
具体如下
python2
python3
3、for+break
# break功能也是用于结束本层循环h和while循环一样的作用
for i in range(10):
if i == 4:
break
print(i)
4、for+continue
# continue功能也是用于结束本层循环h和while循环一样的作用
for i in range(10):
if i == 4:
continue
print(i)
5、for+else
# else也是在for循环正常结束的情况下才会执行和while循环一样的作用
for i in range(10):
if i == 4:
break
print(i)
else:
print('123')
6、for循环嵌套
# *****
# *****
# *****
for i in range(3):
for j in range(5):
print("*", end='')
print() # print()表示换行
# 1*1=1
# 2*1=2 2*2=4
# 3*1=3 3*2=6 3*3=9
# 4*1=4 4*2=8 4*3=12 4*4=16
# 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
# 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
# 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
# 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
# 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
for i in range(1, 10):
for j in range(1, i + 1):
print('%s*%s=%s' % (i, j, i * j), end=' ')
print()
# *
# ***
# *****
# *******
# *********
max_level = 5
for current_level in range(1, max_level + 1):
for i in range(max_level - current_level):
print(' ', end='') # 在一行中连续打印多个空格
for j in range(2 * current_level - 1):
print('*', end='') # 在一行中连续打印多个空格
prin
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
