python基础

python浮点数的精确计算:decimal模块中，可以通过整数，字符串或原则构建decimal.Decimal对象。如果是浮点数，特别注意因为浮点数本身存在误差，需要先将浮点数转化为字符串。

>>> from decimal import Decimal
>>> from decimal import getcontext
>>> Decimal('4.20') + Decimal('2.10')
Decimal('6.30')

复数型（Complex）用字母j表示虚数部分，a.real和a.ima可以分别查看实数和虚数部分，复数型存储的是浮点数类型

查看复共轭：a.conjugate()

四舍五入取整 round(21.6)->22.0

python里的二进制用0b开头，八进制用0或0o开头，十六进制用0x开头

字符串的常用方法：

(1).split()方法：默认情况下，按照空白字符分割，返回一个字符串列表

>>> line='1 2 34'
>>> line.split()
['1', '2', '34']

也可以自定义分隔符，在括号内加入分隔符

>>> line='1,2,34,5'
>>> line.split(',')
['1', '2', '34', '5']

还可以指定分割的最大次数：

>>> line='1,2,3,4,5,6'
>>> line.split(',',3)
['1', '2', '3', '4,5,6']

此外还可以通过.rsplit()方法，从字符串的结尾开始进行分割，主要在最大次数限制的时候看出不同

>>> line='1,2,3,4,5,6'
>>> line.rsplit(',',3)
['1,2,3', '4', '5', '6']

(2).join()方法：以当前字符串作为连接符，将字符串序列中的元素连成一个完整的字符串

>>> numbers='1,2,3,4,5'
>>> numbers
'1,2,3,4,5'
>>> s=':'
>>> s.join(numbers)
'1:,:2:,:3:,:4:,:5'

(3).replace()方式：将字符串中的指定部分替换成新的内容，得到新的字符串，但并不会改变原始字符串

>>> s.join(numbers)
'1:2:3:4'
>>> s='hello world'
>>> s.replace('world','python')
'hello python'
>>> s
'hello world'

可以在.replace()方法里使用一个额外参数指定替换次数

>>> s='1 2 3 4 5'
>>> s.replace(' ',':',2)
'1:2:3 4 5'

(4).upper()和.lower()方法，返回一个字母全部大写或者全部小写的新字符串

>>> 'hello'.upper()
'HELLO'

(5).strip()方法返回一个将两端多余空格去掉的新字符串

>>> '    123     '.strip()
'123'

.lstrip()只去掉左边的空格，同理，.rstrip()只去掉右边的空格

.strip()也可以传入参数，去除字符串首尾两端指定的字符

>>> '---==-123---'.strip('-=')
'123'

多行字符串的生成用一对三引号'''，在存储形式上python使用的是‘\n’

代码的换行可以用()或者\

数字和字符串的相互转化：str()和repr()函数，区别在于repr()返回的是适合python解释器阅读的表示，而str()返回的是适合人阅读的形式

整数到其他进制字符串的转化函数：

str()(十进制)   hex()(十六进制)   oct(八进制)   bin(二进制)

ord()可以查看单个字符的ASCII码值

chr(97)->a 可以讲数值转化为相应的ASCII字符

除了使用%进行格式化输出，python还提供了更为强大的格式化输出方法.format()，使用format方法时，{}会被传入的参数依次代替

此外还可以自己设置编号及顺序

>>> '{1}是{0}'.format('傻逼','瑞豪')
'瑞豪是傻逼'

可以只传入少量参数进行多次替换

>>> x=5
>>> '{0}*{0}*{0}={1}'.format(x,x**3)
'5*5*5=125'

还可以在花括号中使用名称对参数进行格式化，并在.format()方法中指定这些参数的值

>>> '{nm} is {ag} years old'.format(ag=10,nm='John')
'John is 10 years old'

花括号内还可以控制输出的类型和格式：{<field name>:<format>}，格式可以是类似s、d、f这样的输出类型

>>> '{:10s} is good'.format('python')
'python     is good'

长度不够时补0的情况：

>>> '{:010d} is good'.format(100)
'0000000100 is good'

Unicode字符串：

国际标准的ASCII码是0~127，后面的128~255经过组合可以生产一些比较不规则的文字的编码，如汉字等

.decode()方法可以讲字符串解码为Unicode字符串，对于 Unicode字符串，可以使用.encode()方法将其编码为字符串

列表：

对于间隔为1的连续分片，python采用整段替换的方法，直接用一个新的列表替换原来的分片，两者的元素个数并不需要相同

>>> a=[11,12,13,14,15]
>>> a[1:3]=[4,4,4,4]
>>> a
[11, 4, 4, 4, 4, 14, 15]
>>> a[1:3]=[]
>>> a
[11, 4, 4, 14, 15]

对于间隔不为1的不连续分片，赋值时，两者的元素数目必须一致，否则会抛出异常，其实可以理解，假设元素数目将不一致，代入后后面的索引发生变化，毕竟此时用的不是整段替代法

>>> a[::2]=[]
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    a[::2]=[]
ValueError: attempt to assign sequence of size 0 to extended slice of size 3

.count()方法：返回列表中某个特定元素出现的次数

.index()方法：返回某个元素第一次出现的索引的位置，元素不存在是抛出异常

.append()方法：向列表最后添加单个元素 如果这个元素是序列，那么列表最后就是这个序列，并不会将其展开

>>> a
[11, 4, 4, 14, 15]
>>> a.append([1,2,3])
>>> a
[11, 4, 4, 14, 15, [1, 2, 3]]

.extend()方法:将另一个序列中的元素一次添加到列表的最后，且必须是可迭代对象，单个元素会报错

>>> a=[1,2]
>>> a.extend([1,2])
>>> a
[1, 2, 1, 2]

.insert()方法：在指定索引位置处插入一个元素 a.insert(2,'a')

.remove()方法：将列表中第一个出现的指定元素删除，若该元素不存在会抛出异常

.pop()方法：将列表中指定索引位置处的元素删除，并返回这个元素值，该方法同样支持负数索引的弹出

>>> a=[1,2,3,4,5]
>>> a.pop(2)
3
>>> a.pop(-2)
4

.sort()方法：从小到大排序，可以在调用的时候加入一个reverse参数，如果它等于True，列表会反过来按照从大到小的方式排序，但这样会直接改变原列表里的顺序，如果不想改变原列表里的顺序，可以使用sorted()函数（非方法，不是.开头），得到一个排序后的新列表

.reverse()方法：将列表中的元素逆序排序

元组：可以理解成不可变列表，元组的生成速度要比列表快得多

单个元素的元组：a=(10)并不会被认为是元组，而是普通的int类型，正确的做法应该是，在元素后加上一个额外的逗号a=(10,)或者a=10, 即括号可以省略，使用list()函数和tuple()函数可以实现列表和元组的相互转换

元组的不可变性是相对的，如元组中包含列表，对该列表直接赋值仍然是不被允许的，但可以调用列表的方法来改变元组里的值

>>> a=([1,2],3,4,5)
>>> a[0].append(5)
>>> a
([1, 2, 5], 3, 4, 5)

多变量赋值的本质是将两个元组中的元素一一对应，这种情况下，python要求等号两边的元素数目必须相等，使用多变量赋值，可以轻易地实现交换

>>> a,b=1,2
>>> a,b=b,a
>>> a
2
>>> b
1

字符串是一种不可变类型，不能通过索引来改变它的值，调用字符串的方法也不会改变原来的值，而是返回一个新的字符串

字典：键不可变 由于精度问题，一般不适用浮点数作为键的类型

>>> a={}
>>> a[1.1+2.2]=6.6
>>> a
{3.3000000000000003: 6.6}

元组也是常用的键类型

>>> a={}
>>> a[('a','b')]=20
>>> a[('b','a')]=15
>>> a[('a','b')]
20
>>> a[('b','a')]
15

可用关键字in来判断某个键是否在字典中

.get()方法：用索引查询字典中不存在的键时，python会抛出异常，为避免这种异常，可使用.get()方法，该方法接受两个参数key和default，default可以省略，如果键不存在时，返回default指定的值，default的默认值是None

.pop()方法：与列表不同的是，对于非法的索引，字典不会抛出异常，该方法同样接受两个参数key和default

.update()方法：可以一次性更新多个键值对，该方法接受的参数也可以是键值对元组构成的列表，详情见下面dict()初始化方法

>>> a={'one':1,'two':2}
>>> b={'three':3,'four':4}
>>> a.update(b)
>>> a
{'one': 1, 'two': 2, 'three': 3, 'four': 4}

.keys()方法：返回一个由所有键组成的列表

.values()方法：返回一个由所有值组成的列表，.keys()和.values()返回的值并不一定一一对应

dict()方法:初始化字典，括号内的参数可以是另一个字典，也可以是一个键值对元组构成的列表

>>> dict([('one',1),('two',2)])
{'one': 1, 'two': 2}

集合和不可变集合：

集合是一种无序的序列，元素具有唯一性 

空集合可以用set()函数来生成，也可以在set()函数中传入一个列表来初始化这个集合，我们也可以用大括号{}来创建一个集合，但是空集合只能用set()函数来生成，因为空的大括号创建的是一个空的字典

并集| 交集& 差集-或.difference()方法 对称差集^或.symmetric_difference()

>>> a={1,2,3,4}
>>> b={3,4,5,6}
>>> a|b
{1, 2, 3, 4, 5, 6}
>>> a&b
{3, 4}
>>> a-b
{1, 2}
>>> a.difference(b)
{1, 2}
>>> a^b
{1, 2, 5, 6}
>>> a.symmetric_difference(b)
{1, 2, 5, 6}

.add()方法：和列表的.append()方法类似，集合用.add()方法添加单个元素

.update()方法：和列表的.extend()方法类似，.update()方法用来向集合添加多个元素

.remove()方法：移除单个元素

.pop()方法：由于集合是一种没有顺序的结构，该方法随机地从集合中删除并返回一个元素

.discard()方法：和.remove()方法类似，区别在于删除不存在的元素时保护会抛出异常

in判断从属关系 

不可变集合：不可变集合的一个主要用途是作为字典的键，如果用元组作为键，(a,b)和(b,a)是两个不同的键，这时可以用不可变集合让它们代表同一个键

>>> s=frozenset([1,2,3,'a'])

python的赋值机制：

>>> x=500
>>> y=x
>>> y='foo'
>>> x
500
>>> y
'foo'

id()函数可用来查看变量的内存地址 关键字is可以用来判断两个变量是不是同一个对象

一般来说，对于每个出现的对象，python都会单独赋值，即使值是一样的，但为了提高内存的利用效率，对于一些比较简单的对象，比如一些数值较小的整数对象，python采用了共用内存的方法

>>> x is y
False

遍历.items()方法：

>>> values={1:'one',2:'two',3:'three'}
>>> for k,v in values.items():
	print(k,v)

1 one
2 two
3 three

列表推导式：

>>> values=[10,21,7,5,3]
>>> [x**2 for x in values if x<=10]
[100, 49, 25, 9]
>>> {x:x**2 for x in values if x<=10}
{10: 100, 7: 49, 5: 25, 3: 9}

enumerate()函数：

>>> x=[2,4,6]
>>> for i,n in enumerate(x):
	print('pos {} is {}'.format(i,n))

	
pos 0 is 2
pos 1 is 4
pos 2 is 6

zip()函数：

如果参数是字典，zip()函数会保留它的键

>>> x=['a','b','c','d']
>>> y=[1,2,3]
>>> z={'one':1,'two':2}
>>> zip(x,y,z)
<zip object at 0x0000020DAC535988>
>>> for i,j,k in zip(x,y,z):
	print(i,j,k)

a 1 one
b 2 two

函数：定义时可设定默认参数，但带默认值的参数必须放在不带默认值的参数后面

接受不定数目参数：在定义函数时用*来实现，使用任意键值作为参数用**

>>> def add(x,**ys):
	total=x
	for k,v in ys.items():
		print("adding",k)
		total+=v
	return total

>>> add(1,y=2,z=3,w=4)
adding y
adding z
adding w
10

也可以在元组或者字典前加星号，将其作为参数传递给函数

函数可以返回多个值，返回的是一个元组，只不过括号被省略了，可利用python的多变量赋值机制赋值

模块：

__name__变量：我们导入模块时，有时不希望执行脚本中的某些语句，这时可以借由__name__来实现，该变量在python中作为脚本执行或模块导入时的值有一定的差异

导入模块时，python会优先在当前程序的工作目录中寻找模块，如果找不到，则会在python系统的工作目录中寻找，路径的查找顺序可以用sys模块的变量sys.path查看，默认情况下，模块会导入脚本中所有已定义的内容，为此，我们可以通过设置__all__变量来限制导入的内容 例如在ex1中，假设我们只需要导入PI、my_sum，不需要w，可以在ex1.py中，令__all__=[PI,my_sum]

dir()函数：查看一个模块中包含的所有对象，如果不给定参数，dir()函数返回当前已定义的所有变量

包(Package):一个由多个模块组成的集合，用来管理多个模块

__init__.py文件必不可少，它可以是一个空文件

.代表当前文件夹 ..代表当前文件夹的父文件夹

异常和警告：

python3中已经去掉了raw_input()

try里面放可能抛出异常的代码，except处理异常

Exception是所有异常的总称，可以直接捕获所有的异常

包含多个异常except(ValueError,ZeroDivisionError)

得到异常的具体信息：

except SomeError as e:
    print (e.message)

raise抛出异常,括号内时具体的说明信息

if month>12 or month<1:
    raise ValueError("month must be between 1 and 12")

finally关键字：无论是否抛出异常都会执行的内容

警告：使用警告需要余弦导入相关的模块 import warnings,然后调用warnings模块里的warn函数来抛出警告

warn(msg,WarningType=UserWarning)msg是警告的提示信息，WarningType参数用来指定警告的类型，如果不指定，默认用户警告

常用的警告类型：所有警告的父类，所有的警告都能看成一个Warning类

UserWarning：用户警告，默认类型

DeprecationWarning：表示用户使用了未来会被废弃的功能

FutureWarning：表示用户使用了未来可能会改变的功能

RuntimeWarning：运行时警告

有时候不希望运行时看到某种类型的警告，可以用warnings模块中的filterwarnings来进行筛选

warnings.filterwarnings(action='ignore',category=RuntimeWarning)

这样所有RuntimeWarning类型的警告都不会被显示

文件读写：

在python中，我们用open()和file()函数来读取文件，二者基本没有区别

.read()可以一次读取文件所有内容 .readlines()对文件内容按行读取，返回一个列表，每个元素为文件中每一行的内容，每一行行末的回车符\n会被保留 .readline()只读一行

for循环支持文件对象的迭代

for line in f:
    print(line)

.close()关闭文件

写文件：open()函数默认只读，写文件时，将模式转化为写 f=open('myfile.txt','w') 

.write()方法：写入内容

a是追加模式，不会覆盖原有内容 w+表示的读写模式实现同时读取和写入文件

中文文件的读写：

python提供了codecs模块来读写不同格式的字符串，我们可以使用codecs.open()函数实现Unicode字符串的写入

f=codecs.open("tmp.txt","w",encoding="utf-8")

处理中文文件时，通常使用codecs.open()函数代替open()函数

内置函数：divmod(a,b)返回一个元组，如果参数是整数，返回(a//b,a%b)，如果参数是浮点数，返回(q,a%b).q通常是a/b向下取整得到的结果

pow(x,y,[,z])：给定参数z时，返回x的y次方模z的结果

round(num[,ndigits]):参数ndigits参数用来指定近似到小数点后几位，默认为0，即返回近似到整数的浮点数值，四舍五入

>>> round(2.676,2)
2.68
>>> round(0.5)
0
>>> round(0.5,0)
0.0

序列相关的内置函数：

序列的真假判断：all()、any()

all()接受一个序列，当序列所有元素都为真时返回True，any()则在序列中任意一个元素都为真时返回True

连续序列的生成：range()和xrange(),两个函数的使用方法一致，只不过xrange()产生的不是列表而是xrange()对象

序列的迭代：enumerate()和zip()

enumerate()函数可以在迭代序列时输出序号和值

>>> for i,c in enumerate('abc'):
	print(i,c)

0 a
1 b
2 c

enumerate(x,1)表示计数从1开始

序列的切片：slice(begin,end,step)

>>> for i in range(20)[slice(5,15,2)]:
	print(i)

5
7
9
11
13

isinstance()函数：

>>> a=[1,2,3]
>>> isinstance(a,list)
True