python数字的表示

科学计数法

四舍五入

round() 方法返回浮点数x的四舍五入值。第二个参数就是保留几个小数，默认为0。如果不填第二个参数返回的是整数，否则类型与一样
int则是剪去小数部分，只保留前面的整数，即向零取整
int（）不可以用于非整数的字符串
eval()可以运算，不能用于先导0的数字

类型转换

int(x [,base]) ⇒ 将x转换为一个十进制的整数 
long(x [,base]) ⇒ 将x转换为一个十进制的长整数 
float(x) ⇒ 将x转换为一个浮点数 
str(object) ⇒ 转换为字符串 
repr(object) ⇒ 转换为表达式字符串 
eval(str) ⇒ 用来计算在字符串中的有效Python表达式,并返回一个对象 
tuple(seq) ⇒ 将序列seq转换为一个元组 
list(seq) ⇒ 将序列seq转换为一个列表 
chr(x ) ⇒ 将一个整数转换为一个字符 
unichr(x ) ⇒ 将一个整数转换为Unicode字符 
ord(x ) ⇒ 将一个字符转换为它的整数值 
hex(x ) ⇒ 将一个整数转换为一个十六进制字符串 
oct(x ) ⇒ 将一个整数转换为一个八进制字符串

更多

# 16->2,8,10
a=int(input("16->2,8,10:"),base=16)
print("2:{:b}\n8:{:o}\n10:{:d}".format(a,a,a))

# 10->2,8,16
a = int(input("请输入一个十进制整数："))
print("其对应二进制为{:b}\n八进制为{:o}\n十六进制为{:x}".format(a,a,a))


# 8->2,8,10
a = int(input("请输入一个八进制整数："),base=8)
print("其对应二进制为{:b}\n八进制为{:o}\n十进制为{:d}".format(a,a,a))


# 2->8,10,16
a = int(input("请输入一个二进制整数："),base=2)
print("八进制为{:o}\n十进制为{:d}\n其对应十六进制为{:x}".format(a,a,a))

基本运算

divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数

整数除运算符号 和 求余运算符 的分析

• 整数除运算符号

>>> 9 // 4
2
>>> 9 // -4
-3
>>> -9 // 4
-3
>>> -9 // -4
2

原则：运算式 a // b，被除数 a ,除数 b ， 余数c (a/b = k + c )需要在a到0范围内

9 = 4 * 2 + 1 =》 2    
9 = -4 * -3 - 3 =》 -3
-9 = 4 * -3 + 3  =》 -3
-9 = -4 * 2 - 1  =》 2

• 求余运算符(需要结合上面的整数除运算)

>>> 9 % -4
-3
>>> -9 % 4
3
>>> (-9) % (-4)
-1
>>> -9 - ( -4 * 2)
-1

原则：
a%b=a-b倍数=a-b (a//b)= 余数c
也就是说，a对b取余就是计算a最多可以容纳多少个b,多出来的那部分就是余数。

# 9 % -4
9 = -4 * -3 - 3 =》 k=-3
9 - (-4) * -3 = -3 => c = -3

# -9 % 4
-9 = 4 * -3 + 3  => k = -3
-9 - 4 * -3  = 3  => c = 3

数学函数

需要

import math

还有(x) 弧度-》角度
(x) 角度-》弧度
,
对比 :
int()函数是“向0取整”，取整方向总是让结果比小数的绝对值更小
“整除”符号运算将结果忠实地向下取整，与()处理结果一样

如果我们坚持将值域限定为实数，并使用其近似的浮点数实现，就无法计算负数的平方根。
负数的平方根为虚数，而由实部和虚部组成的数为复数。Python标准库提供了一个专门用于处理
复数的模块。
>>> import cmath 
>>> cmath.sqrt(-1) 
1j
注意到这里没有使用from ... import ...。如果使用了这种import命令，将无法使用常规函
数sqrt。类似这样的名称冲突很隐蔽，因此除非必须使用from版的import命令，否则应坚持使用
常规版import命令。

常用函数

abs()
max() min()
pow(a,b)
round(x)
round(x,n)保留小数点后n位
常用更多函数

随机函数

函数范围

字符串的转换

Python 使用了
ord() 函数返回单个字符的编码，
chr() 函数把编码转成相应字符。

转移符号

运算符

字符串的用法特例

>>> eval(str(19)+'1')
191
>>> eval((str(19))+'+1')
20

格式化

格式：format(,item,format-specifier)

>>> print(format(1.2300,'1.3f'))
1.230
>>> print(round(1.23,2))
1.23
>>> print(round(1.2301,3))
1.23

<左对齐
字符串默认左对齐
数字默认右对齐

格式化%s %d %f

%s

# %s
print("%s")
string="HelloWorld"
# 1: %2s意思是字符串长度为2，当原字符串的长度超过2时，按原长度打印，所以%2s的打印结果还是helloWorld
print("string=%2s"%string)
print("string=%12s"%string)
print("string=%-12s\n"%string)

print("string="+format(string,"12s"))
print("string="+format(string,"<12s"))
print("string="+format(string,">12s"))
print()

# 2: %.2s意思是截取字符串的前2个字符，所以%.2s的打印结果是he
print("string=%.2s\n" % string)     # output: string=He

# 3: %a.bs这种格式是上面两种格式的综合，首先根据小数点后面的数b截取字符串，
#当截取的字符串长度小于a时，还需要在其左侧补空格
print("string=%7.2s\n" % string)           # output: string=     He

# 4: 还可以用%*.*s来表示精度，两个*的值分别在后面小括号的前两位数值指定
print ("string=%*.*s\n" % (7,2,string)  )    # output: string=     He

%d

# %d
print("%d")
num=110
# 1:    %1d意思是打印结果为1位整数，当整数的位数超过1位时，按整数原值打印，所以%1d的打印结果还是110
print("num=%1d"%num)
# 2:    %4d意思是打印结果为4位整数，当整数的位数不够4位时，在整数左侧补空格，所以%3d的打印结果是 110
print("num=%4d"%num)
# 3:     %-4d意思是打印结果为4位整数，当整数的位数不够4位时，在整数右侧补空格，所以%3d的打印结果是110
print("num=%-4d"%num)
# 4       %05d意思是打印结果为5位整数，当整数的位数不够5位时，在整数左侧补0，所以%05d的打印结果是00110
print ("num=%05d" % num )
# 5:      %.4d小数点后面的4意思是打印结果为4位整数,当整数的位数不够4位时，在整数左侧补0，所以%.4d的打印结果是0110
print ("num=%.4d" % num )
# 6:     %.004d小数点后面的004和4一样，都表示4，意思是打印结果为4位整数，
print( "num=%.004d" % num)       # output: num=0110
# 7:    %5.4d是两种补齐方式的综合，当整数的位数不够4时，先在左侧补0，还是不够5位时，再在左侧补空格，
#规则就是补0优先，最终的长度选数值较大的那个，所以%5.4d的打印结果还是num= 0110
print ("num=%5.4d" % num)
# 8:    %05.4d是两种补齐方式的综合，当整数的位数不够4时，先在左侧补0，还是不够5位时，    
#由于是05，再在左侧补0，最终的长度选数值较大的那个，所以%05.4d的打印结果还是num=00110    
print("num=%05.4d" % num) # output:num= 0110
# 9:    还可以用%*.*d来表示精度，两个*的值分别在后面小括号的前两位数值指定
#如下，不过这种方式04就失去补0的功能，只能补空格，只有小数点后面的3才能补0
print( "num=%*.*d" % (0o5, 4, num)) # output: num= 0110
print( "num=%*.*d" % (5, 4, num)) # output: num= 0110

%f

print("%f")
import math
#%，a表示浮点数的打印长度，b表示浮点数小数点后面的精度    
# 1:    只是%f时表示原值，默认是小数点后5位数    
print("PI=%f"% )# output: PI=3.141593    
# 2:    #只是%9f时，表示打印长度9位数，小数点也占一位，不够左侧补空格 
print("PI=%9f"%)                # output: PI= 3.141593 
# 3:    只有.没有后面的数字时，表示去掉小数输出整数，03表示不够3位数左侧补0
print("PI=%"%)              # output: PI=003
# 4:    %6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够左侧补空格    
print("PI=%6.3f"%)               # output: PI=_3.142    
# 5:    %-6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够右侧补空格 
print("PI=%-6.3f"%)               # output: PI=3.142
# 6:    还可以用%*.*f来表示精度，两个*的值分别在后面小括号的前两位数值指定  
#如下，不过这种方式06就失去补0的功能，只能补空格  
print("PI=%*.*f" % (0o6, 3, ))               # output:PI= 3.142
print("PI=%*.*f" % (6, 3, ))               # output: PI= 3.142

Python3.6同时输入多个值

1. 同时输入多个字符串,字符串间以逗号间隔

a,b,c=input(‘三个字符串:’).split(‘,’) #得到字符串

a,b,c=eval(input(‘三个数字:’))# 得到整数

2. 同时输入多个数值,字符串间以空格间隔

a,b,c=map(eval,input(‘三个数字:’).split()) # 得到整数
a,b,c=input(‘三个字符串:’).split() #得到字符串

由于input( )输出的是用空格分开的字符串，split( )会分割开各个值并放到列表中，此时在列表中的值是字符串，如果要用于运算必须在map( )中利用int( )或者float( )等处理，再赋值。如果需要赋值的值都是字符串的话就没必要用map函数了。

处理浮点数存储的不精确性

计算机采用二进制存储浮点数时是不精确的，可能会存在误差
解决方案：导入模块decimal或fractions
其中，模块Decimal用于处理十进制的浮点数，模块Fractions用于处理分数

print(1.1 + 2.2 - 3.3)
print(1.1 + 2.2)

from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2') - Decimal('3.3'))

from fractions import Fraction
print(Fraction(11, 10) + Fraction(22, 10) - Fraction(33, 10))