我的Python学习之路-数据类型/运算符
本文内容:
三、变量
四、python的六大数据类型初识
字符串格式化输出
集合和字典之间的注意事项
六、数据的类型转换
七、数据运算
一、python认知
1、python 简介
89年开发的语言,创始人范罗苏姆(Guido van Rossum),别称:龟叔(Guido). python具有非常多并且强大的第三方库,使得程序开发起来得心应手.
Python程序员的信仰:人生苦短,我用python!
开发方向: 机器学习人工智能 ,自动化运维&测试 ,数据分析&爬虫 ,python全栈开发;
2、python 版本
python2.x:将于2020年停止更新,不建议学习此版本
python3.x:功能更将强大,原码较为简单,bug较少;
3、编译性语言和解释性语言的区别
编译性语言:一次性把代码编译成计算机能识别的二进制码,然后在运行;例如:c、c++
优点:执行速度快;
缺点:开发速度慢,调试周期长;
解释性语言:代码从上到下一行一行解释并运行;例如:python ,php
优点:开发速度快,调试周期短
缺点:运行速度慢
4、python解释器
(1)Cpython(官方推荐)
把python转化成c语言能识别的二进制码
(2)Jpython
把python转化成java语言能识别的二进制码
(3)其他语言解释器
把python转化成其他语言能识别的二进制码
(4)PyPy
将所有代码一次性编译成二进制码,加快执行效率(模仿编译型语言的一款python解释器)
二、注释的用法
注释的含义:就是对代码的解释,方便阅读代码;
1.注释的分类
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 #print("hello world")
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 ''' 2 print("这个小伙看起来相貌堂堂,一表人才") 3 print("这个小伙看起来文质彬彬,谈吐非凡") 4 ''' 5 6 """ 7 print("这个小伙看起来相貌堂堂,一表人才") 8 print("这个小伙看起来文质彬彬,谈吐非凡") 9 10 """
2.注释的注意点
如果外面使用三个单引号,里面使用三个双引号,反之亦然。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 ''' 2 print("耿泽世这个小伙看起来相貌堂堂,一表人才") 3 print("贾这个小伙看起来文质彬彬,谈吐非凡") 4 5 """ 6 print("这个帅哥看起来浓眉大眼,樱桃小嘴") 7 """ 8 print("何这个帅哥气质美如兰,才华腹如仙") 9 print("李这个家伙衣冠禽兽,斯文败类") 10 '''
3.注释的排错性
运行程序时代码发生错误,可以根据报错提示行数,先注释一部分代码,然后执行另外一部分,看看是否报错,逐层缩小报错范围,找到最终错误点;
三、变量
1、变量概念
定义:可以改变的的量,实际上是指内存上的一块存储空间;
2、变量声明
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 # 方法一 2 a = 1 3 b = 2 4 # 方法二 5 a,b = 5,6 6 # 方法三 7 a = b = 90
3.变量的命名
#字母数字下划线 ,首字符不能为数字
#严格区分大小写 ,且不能使用关键字
#变量命名有意义 ,且不能使用中文哦
4、变量的交换
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 # 方法一 2 a = 100 3 b = 200 4 a,b = b,a 5 print(a,b) 6 7 # 方法二 8 a = 100 9 b = 200 10 tmp = a 11 a = b 12 b = tmp 13 print(a,b)
5、常量
常量就是不可改变的量,由于pyton没有常量的关键字,约定俗称的把变量名大写就当做常量使用;
四、python的六大数据类型初识
python中有六大数据类型:
(1)Number 数字类型 (int float bool complex)
(2)str 字符串类型
(3)list 列表类型
(4)tuple 元组类型
(5)set 集合类型
(6)dict 字典类型
1、数字 Number
(1)整型
十进制整型:intvar=13;
二进制整型:0b10;
八进制整型:0o17;
十六进制整型:0xff;
(2)浮点型 float(小数)
表示方法分为两类:1、小数 2 、科学计数法
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 # 方法一 2 floatvar = 3.13 3 print( floatvar , type(floatvar) ) 4 5 # 方法二 科学计数法 6 floatvar = 3.66e3 7 floatvar = 4.32e-4 8 print(floatvar , type(floatvar))
(3)bool 布尔型
True(1) 真 ;False(0),假;
(4)复数型
形如a+bj的数字就叫做复数,其中a叫做实数,b叫做虚数;
表示方法有两种:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 # 方法一 2 complexvar = 3 + 4j 3 print(complexvar , type(complexvar)) 4 5 # 方法二 6 # 用法: complex(实数,虚数) 7 res = complex(3,4) 8 res = complex(3,-4) 9 res = complex(0,5) 10 print(res , type(res));
2、字符串类型 str
特征:可获取,不可修改,有序
#1.单引号 strvar1='今天是周四,学习python第二课' #2.双引号 strvar2="今天是周四,学习python第二课" #3.三引号(支持跨行) strvar3 = """ 当学习不好的时候,就"照镜"子激励自己. 不然别人会说,这个人除了'好看'之后一无所有 """
字符串格式化输出
# %d 整型占位符 strvar = "张三买了%d个苹果" % (5) # %2d 整型占位符 (占两位) """占两位 , 不够两位拿空格来补位,原字符串局右""" strvar = "张三买了%2d个苹果" % (5) print(strvar) # %-2d 整型占位符 (占两位),原字符串局左 strvar = "张三买了%-2d个苹果" % (5) print(strvar) # %f 浮点型占位符 (默认小数位保留6位) strvar = "每个月开%f元工资" % (3.8887) # %.2f 浮点型占位符 (默认小数位保留2位) 存在四舍五入 strvar = "每个月开%.2f元工资" % (3.8887) print(strvar) # %s 字符串占位符 strvar = "%s" % ("方金顺真帅") print(strvar)
转义字符:\ + 符号
\n 、\r\n | 换行 |
\t | 缩进(水平制表符) |
\r | 把\r后面的字符串拉到本行行首 |
元字符串 不产生转义,原型化输出字符串
pathvar = r"D:\python33视频课件\notepad++" #输出:D:\python33视频课件\notepad++
3、列表 list
特征:可获取、可修改、有序
1、列表的定义
# 1.定义空列表 listvar = [] # 2.定义普通列表 listvar = [19,6.89,"你好",5-90j]
2、获取列表中的元素
# 正向索引 0 1 2 3 listvar = [19, 6.89,"你好",5-90j] # 逆向索引 -4 -3 -2 -1 res = listvar[2] print(res) #输出:你好
3.获取列表中最后一个元素
#1. 通过逆向索引下标 res = listvar[-1] #2.获获取列表的长度-1 res = listvar[ len(listvar) - 1 ]
4.修改列表中的元素
listvar = [19,6.89,"你好",5-90j] listvar[1] = "刘灵镇" print(listvar) #输出[19,6.89,"刘灵镇",5-90j]
4、元组类型 tuple
特点:可获取、不可修改、有序
1、元组的定义
# 1.定义一个空元组 tuplevar = () print(tuplevar , type(tuplevar)) # 2 定义一个普通元组 # 正向索引 0 1 2 3 4 tuplevar = ("李琦","朱培峰","方金顺","黄昌建","刘文博") # 逆向索引 -5 -4 -3 -2 -1
2.获取元组当中数据
res = tuplevar[3] print(res)#输出:"黄昌建"
3.注意点
区分是否是元组,由逗号这个标识符来决定;
tuplevar = ("你好",) tuplevar = (345,) tuplevar = 1,2 tuplevar = 5,
#以上都是表示一个元组
5、集合 set
特征:无序、自动去重
1、定义一个集合
#1.定义一个空集合 setvar1 = set() # 2.定义一个普通集合 setvar2 = {"周杰伦","易烊千玺","王源","王俊凯"}
2.集合特征: 无序
# 是否可获取集合中的元素? 不行 # print(setvar[0]) error # 是否可修改集合中的元素? 不行 # setvar[0] = "周润发"
3.集合特征: 自动去重
setvar = {"周杰伦","易烊千玺","王源","王俊凯","王文","王文","王文"} print(setvar) #输出:{'王俊凯', '王文', '周杰伦', '易烊千玺', '王源'}
6、字典 dict
字典里的数据以键值对的方式进行存储,表面上有序,实际上无序; 在python3.6版本之后,底层做了优化,存储时,记录了字典的定义顺序,在获取字典时,把无序存储的数据拿出来,按照定义字典的字面顺序重新排序;语法: {键1:值1,键2:值2 , .... }
1、字典的定义
#1、定义一个空字典 dictvar1={} #2、定义一个普通的字典 dictvar = {"haq":"胡安庆","llz":"刘灵镇","wsf":"王生福","xhr":"熊海瑞"}
2.获取字典中的元素
res = dictvar["llz"] print(res) #输出:刘灵镇
3.修改字典中的元素
dictvar["xhr"] = "小黄人" print(dictvar) #{'haq': '胡安庆', 'llz': '刘灵镇', 'wsf': '王生福', 'xhr': '小黄人'}
集合和字典之间的注意事项
集合的值和字典的键有数据类型上的要求:
允许的数据类型 (可哈希的数据类型,不可变的数据类型): Number(int , float , bool ,complex) , str , tuple
不允许的数据类型(不可哈希的数据类型,可变的数据类型): list , set , dict
(了解)
字典的键和集合的值在底层内存存储时,使用了哈希算法,哈希算法的要求是该数据类型为不可变得数据类型才能够存储
哈希算法特点: 无序的散列;
为什么要提出哈希算法?
为了把数据均匀的存储在内存之后,减少哈希碰撞,让数据更快的存储在内存中.
知识扩展
isinstance:判断类型
语法一
isinstance( 要判断的数据,要判断的类型 ) ,如果该数据是这个类型,返回True,反之返回False
语法二
isinstance( 要判断的数据,(类型1,类型2,类型3 .... ) ), 如果该数据在后面的类型元组中,返回True,反之返回False
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 # 语法一 2 res = isinstance(111,int) 3 res = isinstance([] , tuple ) 4 print(res) 5 6 # 语法二 7 res = isinstance("你好",(int ,float,list,tuple ,str) ) 8 res = isinstance({'a','b','c'},(int ,float,list,tuple ,str) ) 9 print(res)
五、变量的缓存机制
2、容器类型部分
1、.字符串 和 空元组 相同的情况下,地址相同
2、列表,元组,字典,集合无论什么情况 id标识都不同 [空元组例外]
3、总结
无论是同一文件的缓存机制,还是不同文件的小数据池,都是为了提升执行的效率,减小空间损耗;
六、数据的类型转换
1、Number的强制类型转化
1、int的强制转换:
init() 可以转换的类型为:整型 、浮点数、布尔值、纯数字字符串
2、float的强制转换
float() 可以转换的类型为:整型 、浮点数、布尔值、纯数字字符串
3、complex的强制转换
complex() 可以转换的类型为:整型 、浮点数、布尔值、纯数字字符串、复数
4、bool 的强制转换
bool() 没有数据类型的限制,可以转换一切数据类型
布尔型为假的十种情况:0、0.0、0j、False、""、()、{}、set()、[]、None
ps:None用于变量的初始化
2、Number 的自动类型转换
精度从高到底是:bool->int->float->complex
自动转化的原则是从低精度数据的向高精度的转化
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 # bool + int 2 res = True + 100 # 1 + 100 => 101 3 print(res , type(res)) 4 5 # bool + float 6 res = True + 4.5 # 1.0 + 4.5 => 5.5 7 print(res , type(res)) 8 9 # bool + complex 10 res = True + 6+3j # 1+0j + 6+3j => 7 + 3j 11 print(res , type(res)) 12 13 # int + float 14 res = 120 + 3.14 # 120.0 + 3.14 15 print(res , type(res)) 16 17 # int + complex 18 res =100 + 4-3j # 100 + 0j +4-3j 19 print(res , type(res)) 20 21 # float + complex 22 res = 5.67 + 3+3j # 5.67 + 0j + 3 + 3j 23 print(res , type(res)
知识扩展: 精度损耗 (写程序时,不要用小数做比较的条件,会导致结果不准确,一般系统会把小数位截取15~18位而产生数据的误差)
res = 0.1+0.2 == 0.3 print(res)#输出 False
3、容器类型的强制转化
str 强制转换成字符串:在原数据的两边套上引号,表达字符串的类型;可以强转一切数据;
list 强制转换成列表: 如果是字符串,把里面的字符一个个拿出来,作为列表的新元素
如果是字典,只保留字典的键,不要值
如果是其他容器,就是单纯的把两边的符号换成[];
tuple 强制转换成元组:
如果是字符串,把里面的字符一个个拿出来,作为元组的新元素
如果是字典,只保留字典的键,不要值
如果是其他容器,就是单纯的把两边的符号换成();
set 强制转换成集合:
如果是字符串,把里面的字符一个个拿出来,作为集合的新元素(无序,去重)
如果是字典,只保留字典的键,不要值(无序,去重)
如果是其他容器,就是单纯的把两边的符号换成{};
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# ### 容器类型的强制转换 (str list tuple set dict) var1 = "我爱你,就像老鼠爱大米" var2 = [1,2,3] var3 = ("景旭阳","孙翔宇","家营和","耿择世") var4 = {"郝建康","白金鸽","杨特"} var5 = {"hjk":"英明神武,瞳孔有力","bjg":"白面小生","yt":"兰陵王特质"} # str 强制转换成字符串 """特点: 在原数据的两边套上引号,表达字符串的类型;可以强转一切数据""" res = str(var2) res = str(var3) res = str(var4) print(res ,type(res)) # 原型化输出字符串 等价于r"" 元字符传 print(repr(res)) # list 强制转换成列表 """ 特点:如果是字符串,把里面的字符一个个拿出来,作为列表的新元素 如果是字典,只保留字典的键,不要值 如果是其他容器,就是单纯的把两边的符号换成[]; """ res = list(var1) res = list(var3) res = list(var5) print(res , type(res)) # tuple 强制转换成元组 """ 特点:如果是字符串,把里面的字符一个个拿出来,作为元组的新元素 如果是字典,只保留字典的键,不要值 如果是其他容器,就是单纯的把两边的符号换成(); """ res = tuple(var1) res = tuple(var4) res = tuple(var5) print(res , type(res)) # set 强制转换成集合 """ 特点:如果是字符串,把里面的字符一个个拿出来,作为集合的新元素(无序,去重) 如果是字典,只保留字典的键,不要值(无序,去重) 如果是其他容器,就是单纯的把两边的符号换成{}; """ res = set(var1) res = set(var3) res = set(var5) print(res , type(res))
dict()字典的强制转换:必须是等长的二级容器(里面的元素都是容器,且每个元素包含的元素个数相等),且元素个数是2个
二级容器:
# 二级列表 listvar = [1,2,3,4,[5,6,7]] # 二级元组 tuplevar = (1,2,3,(4,5,6)) # 二级集合 setvar = {"a","b","c",(1,2,3)} print(setvar) # 二级字典 dictvar = { "a":1, "b" : {"c":3,"d":4} }
字典强制转换的例子:
# 1.外面是列表,里面是列表或者元组 container = [ ["a",1],("b",2) ] res = dict(container) print(res , type(res)) # {'a': 1, 'b': 2} <class 'dict'> # 2.外面是元组,里面是列表或者元组 container = ( ["a",1],("b",2) ) res = dict(container) print(res , type(res)) # {'a': 1, 'b': 2} <class 'dict'> # 3.外面是集合,里面是元组 container = { ("a",1) , ("b",2) } res = dict(container) print(res , type(res)) # {'a': 1, 'b': 2} <class 'dict'>
扩展:
# 情况一:额外扩展 """语法ok , 但是由于集合是无需,导致键值不明确不符合本意,不推荐""" container = [ ["a",1],("b",2),{"c",3} ] res = dict(container) print(res) # 情况二:额外扩展 """语法有很大局限性,字符串的个数必须是2个,不推荐""" container = [["a",1],("b",2),"c3"] res = dict(container) print(res)
七、 数据运算
1、算数运算符
运算符 | 描述 a=10 b=20 | 实例 |
+ | 加-两个对象相加 | a+b=30 |
- | 减-两个对象相减 | a-b=-10 |
* | 乘-两个对象相乘 | a*b=200 |
/ | 除-两个对象相除(结果一定是小数) | b/a=2.0 |
% | 返回余数 | b%a=0 |
// | 取整数-返回商的的整数部分(如果被除数或者除数身上有小数,在得到正常结果之后,加上.0) | 9//2=4 9.0//4.0=2.0 |
** | 幂运算 | 2**3=8 |
取余的具体使用方法:
先正常算出余数,如果被除数身上有负号,那么该余数身上补负号和除数相加,如果被除数或者除数身上都有符号,直接算出余数,然后前面套上负号即可
res = 7 % 4 res = -7 % 4 # -3 + 4 = 1 res = 7 % -4 # 3 + (-4) = -1 res = -7 % -4 # -3 res = -91 % 8 # -3 + 8 = 5 res = 91 % -8 # 3 + (-8) = -5 res = -91 % -8# -3
2.比较运算符
比较运算符只能得到2个结果,要么是True 真的 ,要么是False 假的(> < >= <= == !=)
res = 5 > 3 # True res = 6 <= 6 # True res = 6 == 7 # False res = 6 != 7 # True
3、赋值运算
运算符 | 描述 | 实例 |
= | 简单赋值运算符 | c=a+b |
+= | 加法赋值运算符 | c+=a 等效于c=a+c |
-= | 减法赋值运算符 | c-=a 等效于c=c-a |
*= | 乘法赋值运算符 | c*=a 等效于c=a*c |
/= | 除法赋值运算符 | c/=a 等效于c=c/a |
%= | 取模赋值运算符 | c%=a 等效于c=c%a |
**= | 幂法赋值运算符 | c**=a 等效于c=c**a |
//= | 取整除数法赋值运算符 | c//=a 等效于c=c//a |
4、成员运算符
in 和 not in 针对于容器型数据,数据在容器内返回 True ,否则返False;在字典中只能判断“键”是否存在,不能判断“值”;
5、身份运算符
is 和 is not 检测两个数据在内存当中是否是同一地址
6、逻辑运算符
and:与 全真则真,一假则假
or :或 一真则真,全假则假
not :非 真变假,假变真
逻辑短路:后面的代码不执行了
短路两种形式:
(1) True or 表达式
(2) False and 表达式
无论后面的表达式是什么,都无法改变最后的结果,会出现逻辑短路
# 逻辑运算符的优先级: () > not > and > or res = 5 or 6 and 7 # 5 res = 5 and 6 or 7 # 6 res = (5 or 6) and 7 #7 res = not (5 or 6) and 7 # not 5 and 7 => False and 7 => 短路返回前者
7、位运算符 (针对于二进制操作)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 var1 = 19 2 var2 = 15 3 4 # & 按位与 5 res = var1 & var2 6 print(res) 7 """ 8 19: 00010011 9 15: 00001111 10 11 00010011 12 00001111 13 00000011 => 3 14 """ 15 16 # | 按位或 17 res = var1 | var2 18 print(res) 19 """ 20 19: 00010011 21 15: 00001111 22 23 00010011 24 00001111 25 00011111 => 31 26 """ 27 28 # ^ 按位异或 29 """两个值不一样时为真,反之为假""" 30 res = var1 ^ var2 31 print(res) # 28 32 """ 33 19: 00010011 34 15: 00001111 35 36 00010011 37 00001111 38 00011100 => 28 39 """ 40 41 # << 左移 42 """公式: 5 乘以 2的n次幂 """ 43 res = 5 << 1 # 10 44 res = 5 << 2 # 20 45 res = 5 << 3 # 40 46 res = 5 << 4 # 80 47 print(res) 48 """ 49 5 : 00000101 => 5 50 向左移动一位 51 : 00001010 => 10 52 向左移动二位 53 : 00010100 => 20 54 向左移动三位 55 : 00101000 => 40 56 """ 57 58 # >> 右移 59 """公式: 5 地板除 2的n次幂""" 60 res = 5 >> 1 # 2 61 res = 5 >> 2 # 1 62 res = 5 >> 3 # 0 63 print(res) 64 """ 65 5 : 00000101 => 5 66 向右移动一位 67 : 00000010 => 2 68 向右移动二位 69 : 00000001 => 1 70 向右移动三位 71 : 00000000 => 0 72 """ 73 74 # ~ 按位非 75 """公式: -(n+1)""" 76 # (按位非是让二进制的每一位都取反,包含符号位) 77 res = ~19 78 print(res) 79 """ 80 19 81 原码: 0 000 ... 10011 82 反码: 0 000 ... 10011 83 补码: 0 000 ... 10011 84 85 0 000 ... 10011 86 按位非: 87 1 111 ... 01100 88 89 给你补码 -> 求原码 90 补码: 1 111 ... 01100 91 反码: 1 000 ... 10011 92 原码: 1 000 ... 10100 => -20 93 """ 94 95 res = ~(-19) 96 print(res) 97 """ 98 -19 99 原码: 1 000 ... 10011 100 反码: 1 111 ... 01100 101 补码: 1 111 ... 01101 102 103 按位非: 104 1 111 ... 01101 105 0 000 ... 10010 106 107 给你补码 -> 求原码 108 0 000 ... 10010 (正值 : 原码 = 反码 = 补码) => `18 109 """
总结:
个别运算符:
优先级最高的: **
优先级最低的: =
整体运算符:
一元运算符 : 同一时间操作一个数值 (- , ~)
二元运算符 : 同一时间操作二个数值 (+,-,* , / ....)
一元运算符 > 二元运算符:
同一种类运算符:
算术运算符: 先算乘除,再算加减
逻辑运算符: () > not > and > or
位运算符 : ( << >> ) > & > ^ > |
所有大类运算符:
算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符做收尾;