Python学习笔记03

chapter_3

强制类型转换

>>> int(3.1415) #转换为int型
3
>>> float(3) #转换为浮点型
3.0

• 比较大小

>>> X = 2
>>> Y = 4
>>> Z = 6
>>> X < Y < Z #这种方式运算可能会快一点
True
>>> X < Y and Y < Z
True

---

tip:

可以在Python 2.x中使用一个__future__import 来兼容Python3.x中的代码

---

Floor除法和传统除法

• floor除法:把结果向下截断到它的下层,即真正结果之下的最近的整数.

>>> 10/4 #传统除法,保留小数
2.5
>>> 10//4 #floor除法,向下取整
2
>>> 10/-4
-2.5
>>> 10//-4
-3

用math模块中的方法来处理运算的结果:

>>> import math
>>> math.floor(2.5)
2
>>> math.floor(-2.5)
-3
>>> math.trunc(2.5) #截断除法,直接去掉小数位
2
>>> math.trunc(-2.5)
-2

---

复数

>>> 1j*1j
(-1+0j)
>>> 2+1j*3
(2+3j)
>>> (2+1j)*3
(6+3j)

---

十六进制,八进制和二进制

>>> (0o1,0o20,0o377) #八进制
(1, 16, 255) 
>>> 0x01,0x10,0xFF #十六进制
(1, 16, 255)
>>> 0b1,0b10000,0b11111111 #二进制
(1, 16, 255)

十进制转八进制,十六进制,二进制

>>> oct(64),hex(64),bin(64)
('0o100', '0x40', '0b1000000')

• 字符串形式:

>>> '{0:o},{1:x},{2:b}'.format(64,64,64)
'100,40,1000000'
>>> '%o,%x,%X' % (64,255,255)
'100,ff,FF'

八进制,十六进制,二进制转十进制

• 方式一:

#第二个参数是用来指明第一个参数所属的进制,默认为十进制
>>> int('64'),int('100',8),int('40',16),int('1000000',2)
(64, 64, 64, 64)

• 方式二(不推荐):

#eval函数会将字符串当作Python代码来执行
>>> 64
64
>>> 0o100
64
>>> 0x40
64
>>> 0b1000000
64
>>> eval('64'),eval('0o100'),eval('0x40'),eval('0b1000000')
(64, 64, 64, 64)

注意:

>>> 0o1,0o20,0o377 #python2.6之后的八进制的格式:以0o开头
(1, 16, 255)
>>> 01,020,0377 #在2.6之前使用的格式,在python3.0中会报错
(1, 16, 255)

---

位操作

>>> x = 1
>>> x << 2 #左移两位
4
>>> x | 2 #位或
3
>>> x & 1 #位与
1
>>> x ^ 1 #位异或
0

计算位数

>>> X = 99
>>> bin(X),X.bit_length() #bit_length方法可以计算表示一个数字的值需要的位数
('0b1100011', 7)
>>> bin(256),(256).bit_length()
('0b100000000', 9)
>>> len(bin(256)) - 2 #用len来计算需要减2,即减去'0b'占用的位数
9

---

其他数学工具

>>> import math
>>> math.pi,math.e
(3.141592653589793, 2.718281828459045)
>>> math.sin(2 * math.pi / 180)
0.03489949670250097
>>> math.sqrt(144),math.sqrt(2) #开方
(12.0, 1.4142135623730951)
>>> pow(2,4),2**4 #求2^4
(16, 16)
>>> abs(-42.0),sum((1,2,3,4)) #绝对值,求和
(42.0, 10)
>>> min(3,1,2,4),max(3,1,2,4) 
(1, 4)

• random模块

>>> import random
>>> random.random() #产生0和1之间的任意浮点数
0.7688402171560043
>>> random.randint(1,10) #产生1和10之间的任意整数(包括1和10)
10
>>> random.choice(['Life of Brian','Holy Grail','Meaning of Life']) #随机选择提供的列表中的元素
'Meaning of Life'
>>> random.choice(['Life of Brian','Holy Grail','Meaning of Life'])
'Holy Grail'

小数注意点

• 浮点数缺乏精确性,因为用来存储数值的空间有限
• 下面的计算应该得到0,但结果并没有,接近0,但没有足够的位数去实现这样的精度.

>>> 0.1 + 0.1 +0.1 - 0.3
5.551115123125783e-17

• 使用小数对象可以修正结果

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal('0.0')

注意:在Python3.1中,能够从一个浮点对象创建一个小数对象,调用方式:

>>> from decimal import Decimal
>>> Decimal.from_float(1.25)
Decimal('1.25')

设置全局精度

• decimal模块中的其他工具可以用来设置所有小数数值的精度,设置错误处理等.

• decimal模块中的上下文对象允许指定精度(小数位数) 和 舍入模式(舍去,进位)

>>> import decimal
>>> decimal.Decimal(1)/decimal.Decimal(7) #没有设置上下文对象
Decimal('0.1428571428571428571428571429')

>>> decimal.getcontext().prec = 4 #设置上下文对象,设置精度为4(小数位数为4)
>>> decimal.Decimal(1)/decimal.Decimal(7)
Decimal('0.1429')

• 应用:

>>> 1999 + 1.33 #现在的编译器已经能够保留两位小数
2000.32999999999999

>>> decimal.getcontext().prec = 2
>>> pay = decimal.Decimal(str(1999 + 1.33))
>>> pay
Decimal('2000.33')

• 正常情况下,设置了一次上下文,之后的计算都会蹲守这个上下文的设置

>>> decimal.getcontext().prec = 4
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.3333')
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.3333')

• 可以使用上下文管理器语句来重新设置临时精度,在语句退出后,精度又重新设置为初始值.

>>> import decimal
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.3333333333333333333333333333')
>>> 
>>> with decimal.localcontext() as ctx:
...     ctx.prec = 2
...     decimal.Decimal('1.00') / decimal.Decimal('3.00')
... 
Decimal('0.33')
>>> 
>>> decimal.Decimal('1.00') / decimal.Decimal('3.00')
Decimal('0.3333333333333333333333333333')

---

分数类型

>>> from fractions import Fraction
>>> x = Fraction(1,3) #1/3
>>> y = Fraction(4,6) #4/6,即2/3
>>> x
Fraction(1, 3)
>>> y
Fraction(2, 3)
>>> print(y)
2/3

• 分数可以像平常一样用于数学表达式中:

>>> x + y
Fraction(1, 1)
>>> x - y
Fraction(-1, 3)
>>> x * y
Fraction(2, 9)

• 浮点数转为分数

>>> Fraction('.25')
Fraction(1, 4)
>>> Fraction('1.25')
Fraction(5, 4)
>>> 
>>> Fraction('.25') + Fraction('1.25')
Fraction(3, 2)

>>> (2.5).as_integer_ratio() #产生小数对应分数的分子和分母比
(5, 2)
>>> f = 2.5
>>> z = Fraction(*f.as_integer_ratio()) #*是一种特殊的语法,它把一个元组扩展到单个的参数中
>>> z
Fraction(5, 2)

• 分数提供精确的结果

>>> 0.1 + 0.1 + 0.1 - 0.3
5.551115123125783e-17
>>> from fractions import Fraction
>>> Fraction(1,10) + Fraction(1,10) + Fraction(1,10) - Fraction(3,10)
Fraction(0, 1) #计算的结果精确

• 注意:

尽管可以把浮点数转换为分数,但在某些情况下,也还是不可避免的会有精度损失,因为需要转换的数字在其最初的浮点形式下是不精确的.当需要的时候,可以通过限制最大分母值来简化结果.

>>> 4.0 / 3
1.3333333333333333
>>> (4.0 / 3).as_integer_ratio() #在运算4.0/3的时候就已经损失了精度
(6004799503160661, 4503599627370496)
>>> 
>>> x
Fraction(1, 3)
>>> a = x + Fraction(*(4.0 / 3).as_integer_ratio())
>>> a
Fraction(22517998136852479, 13510798882111488)
>>> 22517998136852479 / 13510798882111488
1.6666666666666665
>>> a.limit_denominator(10) #限制最大的分母数值为10
Fraction(5, 3)

---

集合

• Python2.4引入了一种新的类型–集合(set),这是一些唯一的,不可变的对象的一个无序集合(collection),这些对象支持与数学集合理论相对应的操作.
• 根据定义,一个项在集合中只能出现一次,不管将它添加了多少次.
• 集合是无序的

>>> x = set('abcde') #set()方法的参数必须是可迭代的对象
>>> y = set('bdxyz')
>>> x
{'c', 'd', 'a', 'b', 'e'}
>>> y
{'y', 'z', 'd', 'b', 'x'}

>>> S = set(1.23) #浮点类型不可迭代,因此报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object is not iterable
>>> S = set([1.23])
>>> S
{1.23}
>>> B = {1.23}
>>> B
{1.23}

集合运算

>>> x
{'c', 'd', 'a', 'b', 'e'}
>>> y
{'y', 'z', 'd', 'b', 'x'}
>>> 'e' in x
True
>>> x - y
{'c', 'a', 'e'}
>>> x | y #并运算
{'d', 'e', 'z', 'c', 'y', 'a', 'x', 'b'}
>>> x & y #与运算
{'d', 'b'}
>>> x ^ y 
{'z', 'e', 'c', 'y', 'a', 'x'}
>>> x > y,x < y #测试是否为父子集关系
(False, False)

集合的操作方法

>>> x = set('abcde')
>>> y = set('bdxyz')
>>> x
{'c', 'b', 'a', 'e', 'd'}
>>> y
{'x', 'b', 'y', 'z', 'd'}
>>> z = x.intersection(y) #相当于x & y
>>> z
{'b', 'd'}
>>> z.add('SPAM') #给集合添加元素
>>> z
{'b', 'SPAM', 'd'}
>>> z.update(set(['X','Y'])) #给集合添加一个集合
>>> z
{'X', 'b', 'Y', 'SPAM', 'd'} 
>>> z.remove('b') #从集合中移除指定的元素
>>> z
{'X', 'Y', 'SPAM', 'd'}

>>> S = set([1,2,3])
>>> S
{1, 2, 3}
>>> S.union([3,4]) #往集合中添加元素
{1, 2, 3, 4}
>>> S.intersection((1,3,5))
{1, 3}
>>> list(range(-5,5))
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> S.issubset(range(-5,5)) #测试父子集关系
True

• 集合是可迭代的容器

>>> for item in set('abc'):print(item * 3)
... 
ccc
bbb
aaa

注意

• 空的集合必须通过内置函数set来创建,{ }表示一个空的字典,不是空集合.

>>> S = set()
>>> S
set()
>>> type(S)
<class 'set'>
>>> type({}) #{}表示空字典,不是空集合
<class 'dict'>

• 集合的元素只能是不可变的对象类型,因此,列表和字典都不可以作为集合的元素,元组可以.

>>> S = {1.23}
>>> S
{1.23}
>>> S.add([1,2,3]) #不可添加列表
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> S.add({'a':1}) #不可添加字典
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> S.add((1,2,3))  #可以添加元组
>>> S
{1.23, (1, 2, 3)}
>>> (1,2,3) in S
True