我的Python学习之路-数据类型/运算符

　　(1)Cpython(官方推荐)
　　　　把python转化成c语言能识别的二进制码
　　(2)Jpython
　　　　把python转化成java语言能识别的二进制码
　　(3)其他语言解释器
　　　　把python转化成其他语言能识别的二进制码
　　(4)PyPy
　　　将所有代码一次性编译成二进制码,加快执行效率(模仿编译型语言的一款python解释器)

二、注释的用法

　　注释的含义：就是对代码的解释，方便阅读代码；

1.注释的分类

1 #print("hello world")

单行注释

 1 '''
 2 print("这个小伙看起来相貌堂堂,一表人才")
 3 print("这个小伙看起来文质彬彬,谈吐非凡")
 4 '''
 5 
 6 """
 7 print("这个小伙看起来相貌堂堂,一表人才")
 8 print("这个小伙看起来文质彬彬,谈吐非凡")
 9 
10 """

多行注释

2.注释的注意点

　　如果外面使用三个单引号，里面使用三个双引号，反之亦然。

 1 '''
 2 print("耿泽世这个小伙看起来相貌堂堂,一表人才")
 3 print("贾这个小伙看起来文质彬彬,谈吐非凡")
 4 
 5 """
 6 print("这个帅哥看起来浓眉大眼,樱桃小嘴")
 7 """
 8 print("何这个帅哥气质美如兰,才华腹如仙")
 9 print("李这个家伙衣冠禽兽,斯文败类")
10 '''

View Code

3.注释的排错性

　　运行程序时代码发生错误，可以根据报错提示行数，先注释一部分代码，然后执行另外一部分，看看是否报错，逐层缩小报错范围，找到最终错误点；

三、变量

1、变量概念

　　定义：可以改变的的量，实际上是指内存上的一块存储空间；

2、变量声明

1 # 方法一
2 a = 1
3 b = 2
4 # 方法二
5 a,b = 5,6
6 # 方法三
7 a = b = 90

View Code

3.变量的命名　

　　#字母数字下划线，首字符不能为数字
　　#严格区分大小写，且不能使用关键字
　　#变量命名有意义，且不能使用中文哦

4、变量的交换　　

 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)

View Code

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 、科学计数法　　　

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))

View Code

　　（3）bool 布尔型

　　　　True（1）真；False（0），假；

　　（4）复数型

　　　　形如a+bj的数字就叫做复数，其中a叫做实数，b叫做虚数；

　　　　表示方法有两种：

 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));

View Code

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)

转义字符： + 符号

、	换行
	缩进（水平制表符）
	把后面的字符串拉到本行行首

元字符串不产生转义,原型化输出字符串

pathvar = r"D:python33视频课件
otepad++"
#输出：D:python33视频课件
otepad++

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

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)

View Code

五、变量的缓存机制

1、在同一文件(模块)里,变量存储的缓存机制 (仅对python3.6版本负责)

　　1、Number 部分

　　1、对于整型而言，-5~正无穷范围内的相同值 id一致

　　2、对于浮点数而言，非负数范围内的相同值 id一致

　　3、3.布尔值而言,值相同情况下，id一致

　　4、复数在实数+虚数这样的结构中id永不相同(只有纯正虚数的情况例外)

　　2、容器类型部分

　　1、.字符串和空元组相同的情况下，地址相同

　　2、列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]

2、不同文件(模块)里,部分数据驻留小数据池中 (仅对python3.6版本负责了解)

　　用cmd运行python就是不同文件的条件下，验证不同文件下的变量缓存；

　　python在内存中创建了-5 ~ 256 范围的整数,提前驻留在了内存的一块区域.如果是不同文件(模块)的两个变量,声明同一个值，在-5~256这个范围里，那么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

　　自动转化的原则是从低精度数据的向高精度的转化　

 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)

View Code

　　知识扩展：精度损耗 (写程序时,不要用小数做比较的条件,会导致结果不准确,一般系统会把小数位截取15~18位而产生数据的误差)　

res = 0.1+0.2 == 0.3
print(res)#输出 False

3、容器类型的强制转化

　　str 强制转换成字符串：在原数据的两边套上引号,表达字符串的类型;可以强转一切数据；

　　list 强制转换成列表：　如果是字符串,把里面的字符一个个拿出来,作为列表的新元素

　　　　　　　　　　　　如果是字典,只保留字典的键,不要值
　　　　　　　　　　　　　如果是其他容器,就是单纯的把两边的符号换成[];

　　tuple 强制转换成元组：

　　　　　　　　　　　　如果是字符串,把里面的字符一个个拿出来,作为元组的新元素

　　　　　　　　　　　　如果是字典,只保留字典的键,不要值
　　　　　　　　　　　　如果是其他容器,就是单纯的把两边的符号换成();

　set 强制转换成集合:

　　　　　　　　　　如果是字符串,把里面的字符一个个拿出来,作为集合的新元素(无序,去重)
　　　　　　　　　　如果是字典,只保留字典的键,不要值(无序,去重)
　　　　　　　　　　如果是其他容器,就是单纯的把两边的符号换成{};

# ### 容器类型的强制转换 (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))

View Code

　　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=ac
/=	除法赋值运算符	c/=a 等效于c=c/a
%=	取模赋值运算符	c%=a 等效于c=c%a
**=	幂法赋值运算符	c=a 等效于c=ca
//=	取整除数法赋值运算符	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、位运算符 (针对于二进制操作)

  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 """

View Code

总结：

个别运算符:

优先级最高的: **

优先级最低的: =

整体运算符:

一元运算符 : 同一时间操作一个数值 (- , ~)

二元运算符 : 同一时间操作二个数值 (+,-,* , / ....)

一元运算符 > 二元运算符:

同一种类运算符:

算术运算符: 先算乘除,再算加减

逻辑运算符: () > not > and > or

位运算符 : ( << >> ) > & > ^ > |

所有大类运算符:

算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

赋值运算符做收尾;