Elements-of-Python_02_DataType

（内容包括数据类型，运算符）

1.数据类型Data Types

1.1 简介Brief Introduction

Python3中的数据类型，类型关键字，赋值，见下表：

1.1数字Number

Python3中的数字由整形int，浮点型float，复数complex构成。

1.1.1整形int

整形即整数，用来装整数的变量叫整形变量。a=int(x)可以把不同类型的变量转化为整形。

取整数部分的int和四舍五入的round

print(f"int(12.99)= {int(12.99)}\t\t,int(-0.9)={int(-0.9)}\t\t,所以int是取整数部分.")
print(f"round(12.99) = {round(12.99)}\t,round(-0.9)={round(-0.9)}\t\t,所以round是四舍五入.")

字符串变成整数

如果字符串string中只有数字0~9，没有符号、小数点、字母等，用int(string)可以变为相应数字，不然会报错。

如果只想按顺序取出数字，可以采用以下代码：num = int("".join(list(filter(str.isdigit,"YOURSTRING"))))

a = '$3.4%2c5@k1k0sa74pi3^8^(2y+6)qlk'
num = int("".join(list(filter(str.isdigit,a))))
print(num)   #打印结果为342510743826

如果string中含有若干元素，且用固定分隔符分隔，用以下代码：

a = a.split("/") #每个分隔符切分一下
numArr = [int(i) for i in a] #转为数字列表

进制转换Binary Conversion

对于进制转换(从X进制转成R进制)最简单的理解就是由“逢X进一”变为“逢R进一”。举例而言，我将把6进制的12345，转换到十进制，再从十进制转成16进制。



python中内置了一些函数，可以实现常用进制之间的转换：

bin(100)   #十转二
oct(100)   #十转八
hex(100)  #十转十六
int("100101",2) #二转十
int("30A",16)#二转十六

此外，n进制转10进制，只需要 int("数字字符串",n)即可。

另外，十进制转n进制的代码如下：

#输入10进制，转为R进制
decNum = int(input("Input the decimal number:"))
R = int(input("Input the Conversion Radix:"))
ListR = []
temp = decNum
i = 0
while(temp>=1):
    ListR.append(temp%R)
    temp = int(temp/R)
ListR.reverse()
dict = {0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,10:"A",11:"B",12:"C",13:"D",14:"E",15:"F",16:"G",17:"H",18:"I",19:"J",20:"K",21:"L",22:"M",23:"N",24:"O",25:"P",26:"Q",27:"R",28:"S",29:"T",30:"U",31:"V",32:"W",33:"X",34:"Y",35:"Z"}
print(f'The number converses from {decNum}D to Radix"{R}" is ',end ="" )
for k in range(len(ListR)):
    print(dict.get(ListR[k]),end = "")

判断整数

判断一个数是不是整数，用 (0==int(a)-a)即可。也就是说，如果去掉整数部分等于原数，则原数为整数。

1.1.2浮点型float

Python3中默认17位精度，不论是否利用科学计数法就是17个数。要记得在python中，整数与整数的运算是精确的，如果涉及到使用浮点数做计算就会产生四舍五入的误差

浮点型变量用科学计数法表示

a = 123.456789123
print(format(a,"e")) #不设定位数，默认7个有效数字，最后一位四舍五入
print("{0:.4e}".format(a)) #用:.Ae表示需要A+1个有效数字

1.1.3 复型complex

可以用形如 3+4j （j为虚数单位）的方式，来对一个虚数赋值，也可以用complex(a,b)，用变量给虚部实部赋值。

下面是复数的一些常用操作。

a,b = 3,4
c = 1+2j  #这是第一种赋值，虚部不能加乘号，也不能把虚数单位加在
d = complex(a,b) #这是第二种赋值，相当于d=a+bj
e = complex(a,c) #参数本身可以是复数、整数或浮点数（不能是字符串），会自动运算，注意j*j=-1
f = e * d  #复数间可以加减乘除
g = abs(d) #取复数的模用绝对值函数
h = d.conjugate() #取共轭
i = d.real #取实部
k = d.imag #取虚部

运行结果如下：



自己做运算验证时，记得乘按照多项式运算，除需要先分母实数化（凑完全平方）。

1.2布尔型bool

共有True和False两个布尔值，分别对应1和0，可以参加运算。

布尔值可以参加逻辑运算，逻辑运算符共有3个，按照运算优先级排列分别是not、and、or。 not是单目运算符，进1出0；and是逻辑与运算符，双目运算符，两边有一个是0就得0；or是逻辑或运算符，双目运算符，两边有1就得1。

用bool()做强制类型转换的时候，只有0、0.0、""、None或者空列表、空元组等，会出现False，其他时候都是True。

逻辑短路Logic short circuiting

逻辑短路是指计算机在处理你的代码时，如果确定了你的逻辑运算值后，就不会继续做判断了。因为and和or是从左往右进行运算的，因此，只要and左边的逻辑表达式是False，或or左边的表达式是True，导致and等于0或or等于1已经确定，计算机就不会执行右边的算式。

if (True or exit() ): #or右边被短路，不然会exit
    print("True or anything,anything can't be read.")
else :
    print(abc) #此分支被短路，不然会说没有定义abc变量

if (False and exit() ): #and右边被短路，不然会exit
    print(math.pi) #此分支被短路，不然会说没有import math
else:
    print("False and anything,anything can't be read.")

运行结果如下：

1.3字符串型str

字符串str就是一系列字符组成的列表list，在赋值时可以用一对单引号或一对双引号进行赋值。但值得注意的是，如果在双引号内的字符串中，如果还想使用双引号，就要用转义字符\"，不然就会出现三个或更多双引号，导致二义性。（单引号同理）

转义字符Escape Sequence

转义字符有两个作用：

• ①把原字符转换成别的意思，如'n'是一个字母，'\n'就代表了换行符（重启一行）;
• ②把含有别的意思的字符转换成本来的意思，如果我就需要写'\n'而不是换行符，将反斜杠转换成原来的意思，即'\\n'。
  
  可以用转义字符完成一些功能，可见下表：
  
  

字符串运算

字符串有加法和数乘运算。字符串相加就是字符串拼接，把两个字符串拼接起来成为一个新字符串；字符串与数字相乘就是把这个字符串重复n遍形成一个新字符串。

三个引号

如果需要用到多行输出，可以用''' ''' 来表示，三引号同样可以进行格式化输出（''' '''.format() 或f''' '''）

字符串操作

字符串可以进行很多操作，如索引、切片、改变格式、统计、判断等。



值得注意的是：在索引时，start表示的并不是指的是字符串索引的左侧，而是字符串索引的起始（如从右往左索引，start是右边的，end是左边的）

1.4序列List&Tuple

1.4.1 列表list

列表是一个序列，特点是有序、可以修改；用一对中括号[ ]囊括序列的元素，用逗号进行元素间的分隔，各元素类型可以相同，也可以不相同。下面列举一些常用的操作：

列表的创建

#创建
a = ['a','b',3]*3+[("tuple",3),3.13159]
#列表可以进行加法和数乘，加法是后一个列表拼接在前一个后，乘法是把一个列表顺次扩展成多个
b = list(range(1,20,3))
#如果是等差数列，可以用range直接生成
c = [x*x  for x in range(10)]
#在中括号里写生成器表达式可以直接生成一个列表
print(a,b,c,sep="\n")

一些注意：

1.构建列表直接在中括号里写元素即可。不同类元素可以存在于同一列表中。列表可以进行加法和数乘，加法就是把后一个列表中的元素顺次加在前一个列表中；数乘就是把原列表扩展成多个。

2.利用list(range(start,end,step))就可以直接构造想要的数字列表。range()函数有三个整型的参数，第二个参数必填，是中止值，默认从0开始，步长为1。如果想倒着取值，就中止值小于起始值且步长为负。

1. 列表生成器也是一种生成列表的方式，格式：[通项公式 for 变量 in 迭代器 ]
2. 附几个列表生成器的进阶用法：
   
   
3. 在对列表进行赋值或者初始化的时候，一定要注意：你究竟是取了id，还是附了真值。

a = [1,2,3]
b = a #这句话是b会一直等于a
a[0] = 11
print(f"a = {a}\tb = {b}")
print("b = a 这种赋值，b取了a的id，a中改变，b也会跟着改变。\n")

c = [1,2,3]
d = c[:] #d中存入了c的所有元素
c[0] = 11
print(f"c = {c}\td = {d}")
print("d = c[:]是把此时c中的元素都读进了d,成为了d的元素,c变化d不再变化。\n")

再比如，a = [[0]*10]*10,如果a[0][0]发生了变化，整个a[x][0]都会跟着变化，所以构建列表推荐使用列表生成式[[0]*10 for _ in range(10)]或[[0 for i in range(10)] for j in range(10)],这样就会使其各个元素无关。否则会导致改动一个元素，整个列表中其他元素也右变化的可能性。

列表的操作

列表的常见操作主要是索引、切片、计数、查找、是否在内；增加减少修改元素；排序等。



关于sort(),>,<用哪个值比较的问题：

排序比较机制：数字间通过比较大小来比较排序；字符串通过首个差异字符元素的ASCII码比较排序；以列表、元组为元素的列表通过更内层的第一个非序列元素进行比较，且此元素必须在同一层的同类型变量才能比较；只能同种元素进行比较。

1.4.2 元组Tuple

元组是只读变量，效率比List高，如果可以，尽量用元组。

元组用小括号将元素整合，其中元素是有序的不可改变的。

元组和序列一样，同样可以进行索引切片等操作，只是不能进行对元组本身产生改变的序列操作。

a = 1,2,3,4,5
#tuple赋值可以不加小括号，但必须有逗号
print(a+(6,),type(a))
#tuple可以进行【+拼接】和【*复制】操作
print((a*3).count(2))
#tuple可以tuple.count(x)
#tuple还有len(a)、min()、max()、x in tuple、del tuple、tuple(list)的操作

输出结果：

1.5 哈希型Hash

1.5.1 字典Dict

字典就是若干个键值对Key-Value的集合，是无序可改变的，用大括号将元素整合。

#字典的创建
d = {"key":"value",1:"Tom",2:"Lily",3:"Jerry"}
#可以直接用大括号中加键值对构成字典
e = dict(key="value",one="Tom",two2="Lily",three=3)
#用dict关键字，内用key=value要注意，键必须符合变量命名规则且键不用加引号
f = dict([("2","Lily"),[1,"Tom"],"ab"])
#用dict关键字,也可以用双元素元组、双元素列表、双字符字符串进行赋值
k = (x for x in range(1,5))
v = ["Tom","Lily","Jerry","Joe"]
g = dict(zip(k,v))
#可以键值分开，键和值是等长序列，用zip(a,b)建立连接
#另外，和列表生成一样，字典也有字典推导式{key_exp:value_exp for key,value in dict.items() if condition}
for i in [d,e,f,g]:print(i,type(i),sep = '\t')

输出结果如图：

#字典的访问
d = {"key":"value",1:"Tom",2:"Lily",3:"Jerry"}
e = dict(key="value",one="Tom",two2="Lily",three=3)
print(d[1],e["one"],e.get(2333,"没这键"))
#可以直接用d[key]访问值，没有key会报错;也可以d.get(key,"No this key"),找到返回值，未找到返回第二个参数
print(d.items())#遍历字典所有键值对
print(e.keys())#遍历字典所有键
print(e.values())#遍历字典所有值

输出结果如图：

#字典的修改
d = {"key":"value",1:"Tom",2:"Lily",3:"Jerry"}
e = dict(key="value1",one="Tom",two2="Lily",three=3)
d.update(e)
print(d) #将一个字典加进另一个字典
#注意：值相同无所谓，键相同会覆盖原来的键值对（d中键值对会被e中的覆盖）
e["four"] = "Joe" #用这个格式可以加键值对进字典e，注意键必须是字符串
del(e["three"]) #用这个格式可以删除键值对
#另外，del d可以删除整个字典； d.clear()可以删除d中所有的键值对，保留d并使d为空字典
print(e)
print(e.pop("four"))#用pop(键对象)可以弹出值对象且删除此键值对
print(e)
print(d.popitem())#不需要参数，会从尾部一个一个将键值对弹出并删除

1.5.2 集合Set

集合是只有键对象的字典，和字典一样，集合的键不能重复。

a = {"GG",23333}
a.add("MDZZ")
b = set(["Amber","Cokin","Dylan"])
print(a|b) # 或a.union(b) 并集
print(a&b) # 或a.intersection(b) 交集
print(a-b) # 或a.difference(b) 差集
print(a^b) # 这个也是并集
a.update(b) #和字典相同，把集合b中的键以覆盖同名方式加入a
a.discard("MDZZZ") #删除键对象，没有键对象不报错
a.remove("MDZZ") #删除键对象，没有此对象报错
print(a)
a.clear() del b
#删除a中的所有键对象，a成为空集合 ；将b集合删除，b不再存在

1.6 三种表达式

上面说了列表推导式，也提到了字典推导式，其实一共有三种形式类似的推导式，分别是：



【小括号是生成器推导式，中括号是列表推导式，大括号(键值对)是字典推导式，大括号(键)是集合推导式】

举例而言：

import math
import itertools

a = (pow(2,i)*math.pi for i in range(2,16,2) if i%3 == 0)
print(f"Type of (Comprehension) is {type(a)}, and (Comprehension)={a}")
print(list(a))
print("-"*65)

b = [i*i if i%2 == 0 else -i*i for i in range(12)]
print(f"Type of [Comprehension] is {type(b)}, and [Comprehension]={b}")
print("-"*65)

c = {chr(k) for k in itertools.chain(range(65,91),range(97,122))} #itertools.chain(a,b)合并iterable的方法
print(f"Type of c is {type(c)}, and c={c}")
print("-"*65)

name = ["Tom","Lily","Jerry","Dylan","Amber","Bold","Kluge","Gina","Vera","Cokin"]
num = range(1,11)
d = {k:v for k,v in zip(name,num)}
print(f"Type of d is {type(d)}, and d={d}")

运行结果如下：



可以看出：

① 推导式中的分支结构，用 【A if BOOL else B for i in ITERABLE】

② 推导式中筛选输入数据，用【A for i in ITERABLE if CONDITION】

③ 合并range()，用【itertools.chain(a,b) 】先import itertools

④ 一行式是Python中特有的简单的书写方式，很好用

1.7 其他Others

除了基本数据类型外，python还有别的数据类型和自建数据类型，如指针、枚举、数组等。

2 运算符 Operators

Python中一共有这么几类运算符：

①算术运算符：

• +加法，-减法，乘法，*乘方，/除法，//整除取整(向下取整)， %整除取余。

②赋值运算符：(例:a+=1相当于a=a+1；另外,Python没有自增++ 自减--)

• 共有=， +=， -=，=，*=， /=， //=，%=。

③关系运算符：(运算后返回布尔值True/False)

• ==等于， !=不等于，<小于， >大于， <=小于等于，>=大于等于。

④逻辑运算符：（优先级按not，and，or递减）

• not非，and与，or或。

⑤成员、身份运算符：

• in，not in (后面的是否包含前面的)
• is，is not (元素引用地址是否相同)

⑥位运算符：

• &按位与，|按位或，^按位异或，~按位取反，<<二进制左移，>>二进制右移。

⑦符号运算符：

• +正号，-负号。

⑧其他：

• .attribute属性访问运算符；[]索引运算符。

⑨用作数学运算的运算公式：

abs(a)取模， all(a)是否都是False或None， any(a)是否含有False或None，divmod(a,b)指ab=c……d返回元组(c,d)， min(a) max(a) a中的最大最小值，sum(a)求和。

⑩函数修饰符@：

@a
@b
@c
def d(arg1,arg2,···):
    pass

等价于a(b(c(d(arg1,arg2,···))))

优先级如下：

①大体上，运算符优先级可以被记作：

属性类>位运算符>算术运算符>比较运算符>赋值运算符>逻辑运算符

②具体的，运算符的优先级如下：

• 【[]索引运算符】>【.attribute访问成员】>【**乘方】>【~按位取反】>【±正负号】>【*乘法 /除法 //向下取整 %整除取余】>【+加法 -减法】>【>>按位右移 <<按位左移】>【&按位与】>【^按位异或】>【|按位或】>【==等于 !=不等于 >大于 <小于 >=大于等于 <=小于等于】>【身份运算符is is not】>【成员运算符in not in】>【not逻辑非】>【and逻辑与】>【or逻辑或】

对位运算符的解释：将数字化成二进制后，按照位做运算，

①& 按位与 有0得0、全1得1，

②| 按位或 有1得1、全0得0，

③~ 按位取反 非0数是十进制加1后的相反数，0是-1（布尔型用not取反）

④^ 按位异或 相异为1，相同为0，

⑤>> << 左右移 左移一位乘2，右移一位除2。

按位取反过程：

如果您觉得Tc写得不错或者不好，欢迎批评或点赞。