python if 判断相等的语句 python 判断数值相等

python语言中有3种基本的数值类型，int 类型表示整数；float类型表示浮点数。第三数据类型表示复数

1 整数

>>> x=42
>>> type(x)
<class 'int'>

>>> x=int("17") #将字符串转换为整数
>>> y=int(4.8) #截取把浮点数小数点右边的部分去掉
>>> print(x,y,x-y)
17 4 13
将一个字符串转换为一个整数时，python语言假定该数值使用十进制表示。可以为该数值指定另外一种进制。

>>> hex_number="a1"
>>> print(int(hex_number,16))
161

可以通过在数值前面加前缀0x指定一个十六进制数。0xa1

>>> print(10**100)
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>>> type(10**100)
<class 'int'>

使用 指数据运算符**来省去输入100个0的麻烦

int类型所能存储的整数大小不再限制

2 浮点数

python中的浮点数用float类型的对象表示。一个浮点数只是一个实数的近似值。

 

>>> x=1.111
>>> x
1.111
>>> print(x)
1.111

可以使用float构造函数将字符串转换为数值

>>> x=float("16.4")
>>> x
16.4
>>> type(x)
<class 'float'>

特别大和特别小的浮点数使用指数表示法来表示，指数表示法将10的指数单独表示。

>>> debt=11322188570453.51
>>> print(debt)
11322188570453.51
>>> e=1.1111e+13
>>> print(e)
11111000000000.0

浮点数的精度：浮点数是一个近似值，它只能保证有限数量的精确位数。

Python使用C语言中的double类型存储float类型的变量，因此如果知道C语言中的double类型在一个平台上的精度，就可以知道在相同平台上运行的python语言中的float类型的精度。大部分系统使用64位存储C语言中的double类型，并提供16位的精确的位数。

3 格式化数值

格式化运算符：%

在一个字符串后使用%，%为字符串格式化运算符，如果在两个数值中间使用%，%为取余运算符。

格式化整数用：%d 

格式化浮点数：%f

如果对一个浮点数使用%d或者对一个整数使用%f,python会将数值转换为转换符号表示的类型

>>> print("%d"%100)
100
>>> print("%d"%101.6)
101

用十六进制显示输出内容：使用%x转换符号。如果使用%#x会在输出内容之前加上0x.

%o 字母o可以产生八进制的输出，%#o可以产生前面带0的八进制输出

>>> print("%#x"%100)
0x64
>>> print("%x"%100)
64
>>> print("%o"%100)
144
>>> print("%#o"%100)
0o144

对于整数，可以通过在格式化字符串%后面增加一个数值来指定输出内容的宽度，如果数值以0开关，输出内容左边的空余位数会用0填满，否则的话会用空格真满。

>>> print("z is (%6d)"%175)
z is ( 175)
>>> print("z is (%06d)"%175)
z is (000175)

当格式化浮点数时，可以指定输出内容的总宽度，和 或者 小数点后的数字位数。如果输出内容的总宽度为w，并在小数点后显示p位数字，需要在格式化字符串中使用转换符号%w.pf,总宽度包括了小数点以及小数点后的数字。与将一个浮点转换为整数时处理不同，python对小数点后的最后一位数值采取四舍五入的处理方法。

>>> x=20.0/3
>>> print("(%6.2f)"%x)
( 6.67)

如果在格式化字符串中省略掉小数点前面的数字，python会使用输出内容需要的足够空间显示输出内容的整数部分，并且按照格式化字符串中的要求显示小数部分：

>>> print("(%.4f)"%x)
(6.6667)

float类型的精确位数是有限的，一般只包含16位数字左右的信息。

>>> tt=2.0/3
>>> print("%.40f"%tt)
0.6666666666666666296592325124947819858789

如果省略掉小数点后面的数字或者指定0位小数，python将不会显示小数部分，并且也不会显示小数点：

>>> print("(%4.f)"%x)
( 7)

def as_percent(num,den):
if den==0:
ratio=0
else:
ratio=float(num)/den
return "%5.1f%%"%(100*ratio)

>>> import num
>>> print("ratio="+as_percent(6839,13895))
ratio= 49.2%

 如果在输出内容中显示%，使用两%%

在转换符号中使用*替代一个数值，python语言从参数元组中一个额外的整形参数（位于被格式化的数值前面）得到*的值。

 

def format_dollars(dollars,places):
return "$%*.2f"%(places+3,dollars)

 

>>> print(format_dollars(499.98,5))
$  499.98

4 作为数值的字符

在Python中，一个字符只是一个长度为1的字符串，不能作为一个数值使用。

python提供了内置函数ord将一个字符转换为它的数值代码，还提供了内置函数asc来将一个数值代码转换为一个字符。数值代码的范围必须在0到255之间。

 

def rot13_character(character):
#look up codes for ends of the alphabet.
a=ord('a')
z=ord('z')
A=ord('A')
Z=ord('Z')

code=ord(character)
# rotate lower-case characters
if a<=code<=z:
code=a+(code-a+13)%26
#rotate upper-case characters.
elif A<=code<=Z:
code=A+(code-A+13)%26
#leave other characters alone.
else:
pass
return chr(code)

def rot13(plaintext):
#loop over letters in the text.
ciphertext=""
for character in plaintext:
ciphertext+=rot13_character(character)
return ciphertext

>>> import num
>>> mesage=num.rot13("this is a top-secret encoded message.")#加密
>>> print(mesage)
guvf vf n gbc-frperg rapbqrq zrffntr.

要解密一条使用rot13加密的消息，只需要对加密的消息再应用一次rot13加密即可：

>>> print(num.rot13(mesage))
this is a top-secret encoded message.

 5 算术运算

python语言为数值类型的对象提供了标准的算术运算符，可以混用不同的数值类型，python语言会为运算结果自动选择最具灵活性的类型：

total==6 即 total=total+6 

co/=2 即 co=co/2

当两个整数相除时，python一般使用int类型表示运算结果。但是当运算结果含有小数部分时，不同

>>> print(13/3)
4.333333333333333

下界除法，显示地将商四舍五入为一个整数，下界除法运算符使用//表示。也可以float类型的对象上应用它：

>>> print(6.6//3.0)
2.0
>>> print(10//3)
3
>>> print(11//3)
3

指数运算符** 计算复利

def compound(starting_balance,annual_rate,years):
return starting_balance * ((1+annual_rate)**years)

>> compound(130000,0.03,10)

174709.12931473588

取余运算符%，返回除尘的余数。
def format_months(months):
print("%d years,%d months" %(months//12,months%12))

 6 内置函数

>>> abs(-6.5)
6.5
>>> print(min(6,7,2,-8))
-8
>>> print(max([0,43.5,-6,7,]))
43.5

round函数可以将一个浮点数四舍五入为指定小数位数的数值。

>>> print(round(1234.56789,2))
1234.57

可以指定保留的小数位数为负数，这样将从小数点开始向左边四舍五入指定的位数

>>> print(round(1234.56789,-2))
1200.0

sum对一个序列中的数值求和。结合range函数可以计算出前100个正整数的和：

>>> print(sum(range(1,101)))
5050

 

def mean(numbers):
if numbers:
return float(sum(numbers))/len(numbers)
else:
raise ValueError("no numbers specified")

>>> print(mean([96,90,100,88]))
93.5

math模块中包括了标准的超越函数，所有这些函数都使用float类型的参数，并返回float类型的值：

floor函数和ceil函数是标准的下界函数和上界函数，它们返回的结果为整数，但却以float类型的数值表示。

 

from math import sin,cos,pi
def trajectory(velocity,angle):
""" compute time of flight and range of a projectile.
for a projectile with initial 'velocity' in meters/sec launched at 'angle' from
horizontal in degrees,returns time of flight in sec and range in meters ,
meglecting friction."""
#gravitational acceleration in meters/sec^2.
g=9.8
#convert 'angle' to radians.
angle=angle * pi /180
#compute horizontal and vertical components of velocity.
v_h=velocity * cos(angle)
v_v=velocity*sin(angle)
#compute the time of flight and range.
tof=2*v_v/g
range=tof*v_h
return tof,range

>>> tof,range=trajectory(40,45)
>>> print ("time of flight:%.1f sec,range:%.0f meters "%(tof,range))
time of flight:5.8 sec,range:163 meters

7 复数 实数与虚数的和。

虚数是虚数单位的倍数，虚数单位是指-1的平方根。数学家通常使用i表示虚数部分，而工程师通常使用j.

python中，虚数用一个数值以及数值后面的j来表示（数值和j之间不能有空格）：

>>> imaginary_number=16j

要创建一个复数，将一个实数和一个虚数相加 或者相减：

>>> complex_number=6+4j

python将复数作为单个对象来存储，使用的类型为complex类型：

>>> print(complex_number)
(6+4j)

>>> type(complex_number)
<class 'complex'>

可以使用complex构造函数来构造复数对象

>>> complex_number=complex(6,4)
>>> complex_number
(6+4j)

>>> print(1j**2)
(-1+0j)

不能直接用j来表示虚数单位，而必须使用1j,单独的j表示名称为j的变量。

复数对象的实数部分和虚数部分都被存储为浮点数

>>> print((1+0j)/3)
(0.3333333333333333+0j)

>>> print(2*(10+3j)*(6.5-4j)/(1-1j)+30)
(127.5+56.5j)

 数学运算Re和Im分别返回一个复数的实数部分和虚数部分。在python中可以使用每个complex类型的对象都具有的real属性和imag属性得到这两种运算的结果。每个结果都是float类型：

>>> x=5-6j
>>> print(x.real)
5.0
>>> print(x.imag)
-6.0

内置的abs函数返回 int 类型、long类型 或double类型的对象的绝对值，对于复数，abs函数返回量值 magnitude,即实数部分与虚数部分的平方和的平方根。

>>> print(abs(x))
7.810249675906654
>>> import math
>>> print(math.hypot(x.real,x.imag))
7.810249675906654

每个complex类型的对象都有一个名为conjugate的方法，这个方法返回复数的共轭值。共轭复数指拥有相同实数部分和相反虚数部分的两个复数。 

>>> print(x.conjugate())
(5+6j)

 python提供了一个称作cmath的模块，这包含了相同函数的复数版本，即它们应用在复数上并返回复数。这个模块中的平方根函数可以处理-1

>>> import cmath
>>> print(cmath.sqrt(-1))
1j

python语言将复数的实数部分和虚数部分都存储为相同精度的浮点值，在绝大多数系统上是16位的精度。

8 数组

列表可以被修改，元组不能被修改

from math import sqrt
def stddev(numbers):
n=len(numbers)
sum=0
sum_of_squares=0
for number in numbers:
sum+=number
sum_of_squares+=number*number
return sqrt(sum_of_squares/n-(sum/n)**2)

>>> print(stddev((5.6,3.2,-1.0,0.7)))
2.501374622082826

pythonu将列表中的每个元素都表示为一个对象。

array 模块 ，用来表示一维数值数组。这个模块中的array类型将数组中的所有数值作为一个对象存储在内存中，并且要求所有数值必须是同一数值类型。可以存储int/float类型值 ，还可以存储其他大小的整数以及其他精度的浮点数。但不能存储非常大的值，而且完全不能存储复数。

当创建一个数组时，需要指定存储在数组中的数值的数值类型。数值类型可用一个字符指定。如果要存储python中的int类型的对象，使用l;对于float类型的对象，使用d.如果不做其他任何指定，则将得到一个空数组。

>>> import array

>>> a=array.array("l")
>>> print(a)
array('l')

>>> a.append(15)
>>> print(a)
array('l', [15])

>>> a.extend([20,17,0])
>>> print(a)
array('l', [15, 20, 17, 0])

>>> a[1]=42
>>> print(a)
array('l', [15, 42, 17, 0])

>>> del a[2]
>>> print(a)
array('l', [15, 42, 0])

通过将一个列表或元组作为参数传递给数组类型的构造函数，可以把它们转换为一个数组对象：

>>> t=(5.6,3.2,-1.0,0.7)
>>> a=array.array("d",t)
>>> print(a)
array('d', [5.6, 3.2, -1.0, 0.7])

如果把一个数组类型的对象转换回一个普通的元组或列表，只需要将这个数组类型的对象传递给tuple或list类型的构造函数。

>>> back_again=tuple(a)
>>> print(back_again)
(5.6, 3.2, -1.0, 0.7)

数组对象的所有元素必须是相同类型；与列表相同，数组对象是一维的；

array模块是python标准库的一部分；数组对象不能自动被存储；

数组对象存储值的效率比数值列表高。

总结：

表示数值数组最简单的方法是使用数值列表或数值元组。为使存储更有效率，需要使用python语言中的array模块。

与python语言中的其他对象一样，每个数值都有类型。python有3种基本的数值类型。int类型表示整数，float类型表示浮点数。第三种数值类型是复数。

可以使用str构造函数将python中 任何数值转换为一个字符串，这产生了字符串类型的文本，可以被print语句打印出来。

要格式化一个整数，在格式化字符串中使用%d转换符号。对于浮点数，使用%f，如果对浮点数使用%d,或者对整数使用%f,python会将数值转换为转换符号表示的类型。

python为各种数值类型都提供了标准的算术运算符:+-*/

array模块中的array类型将数组中的数值在内存中存储为一个对象，这些数值必须有相同的类型。

math模块包含函数：sqrt平方根函数 exp指数函数，log log10自然对数函数和以10为底的对数函数，sin con tan三角函数，asin/acos/atan反三角函数，以及sinh/cosh/tanh双曲函数。

 

def format_bytes(number):
gbnum=number//(1024*1024*1024)
leave=number-(gbnum*1024*1024*1024)
mbnum=leave//(1024*1024)
leave2=leave-(mbnum*1024*1024)
kbnum=leave2//(1024)
bbnum=leave2-(kbnum*1024)
return ("%d GB+%d MB+%d KB+%d bytes"%(gbnum,mbnum,kbnum,bbnum))

>>> print(format_bytes(9876543210))
9 GB+203 MB+5 KB+746 bytes

def rgb_to_html(red,green,blue):
red=int(round(red*255))
green=int(round(green*255))
blue=int(round(blue*255))

return("#%02x%02x%02x"%(red,green,blue)) #02 两位 如果有一位则前面显示0

>>> print(rgb_to_html(0.0,0.0,0.0))
#000000

def normalize(arr):
sum_of_squares=0
for num in arr:
sum_of_squares+=num*num
result=list(arr)
scale=1/sqrt(sum_of_squares)
for i in range(len(result)):
result[i]*=scale
return result

>>> normalize([1.0,1,2])
[0.4082482904638631, 0.4082482904638631, 0.8164965809277261]