前言

由于一些原因，好久没更博客了，接下来会陆续总结出一些包含各方面的基础知识的文章（如数据库、Python、数据挖掘等），算是作为以后的“考前”（面试）回顾的资料吧。首先就写下关于Python基础的一些总结吧。

1、str

1.1、内置方法：

[‘capitalize’,‘casefold’,‘center’,‘count’,‘ncode’,‘endswith’,‘expandtabs’,‘find’,‘format’,‘format_map’,‘index’,‘isalnum’,‘isalpha’,‘isdecimal’,‘isdigit’‘isidentifier’,‘islower’,‘isnumeric’,‘isprintable’,‘isspace’,‘istitle’,‘isupper’,‘join’,‘ljust’,‘lower’,‘lstrip’,‘maketrans’,‘partition’,‘replace’,‘rfind’,‘rindex’,‘rjust’,‘rpartition’,‘rsplit’,‘rstrip’,‘split’,‘splitlines’,‘startswith’,‘strip’,‘swapcase’,‘title’,‘translate’,‘upper’,‘zfill’]

1.2、常用的内置方法

S.join(iterable)->str #将iterable拼接成(转化为)字符串

“”.join(list)#将list转化为字符串

S.replace(old,new[,count])->str #替换字符串中元素，返回一个新字符串。

S.split(sep,maxsplit)->list#将字符串分割为list

S.strip([chars])->str#剔除字符串中的特定字符

S.swapcase()->str#转化字符串的大小写字母

capitalize：Python capitalize()将字符串的第一个字母变成大写,其他字母变小写

S.islower()/isupper() #判断字符是否是全为大/小写
S.lower()/upper()#将字符串转化为大写或小写

maketrans()->:返回一张翻译表

#定义翻译表，然后对相应的字符串一个字一个字的去映射。与replace的区别：replace不能对每个字符进行一一映射，而translate可以

translate(table)->str#传入table进行映射处理

a="asdfsdafd123"
g = str.maketrans("abc","123")
print(a)
asdfsdafd123
print(a.translate(g))
1sdfsd1fd123

S.count(sub[,start[,end]])->int #返回某个字符（串）出现的次数`

S.find(sub[,star,end]) -> int #返回索引值
S.index()#同find方法一样，区别：若没有该值的索引则抛出异常。

a="hello world"
a.find("word")#找到返回初始的索引值
a.find("wordl")#未找到返回-1

S.format(*args,**kwargs)->str #格式化输出字符串

"my name is {0} and age is {1}".format("xiaoli",25)
"my name is {a}, i love {b}".format(a='pyer',b='apple')

S.isdigit()->bool #判断字符是否是数字

str.strip([chars])
参数
chars – 移除字符串头尾指定的字符序列。
返回值
返回移除字符串头尾指定的字符生成的新字符串。

1.3、String模块的一些方法

2、list

2.1、内置方法

2.2、常用内置方法

[‘append’,‘clear’,‘copy’,‘count’,‘extend’,‘index’,‘insert’,‘pop’,‘remove’,‘reverse’,‘sort’]

L.append()->None #添加元素到list末尾

L.insert(index,object)#在对应的index添加元素

L.clear()->None #清空list所有元素

L.pop([index])-|>item#剔除index的元素并返回

L.remove(value)->None#剔除list中的包含的第一项的value。

L.extend(iterable)->None #添加迭代器来扩展list

L.reverse()#反转list

L.count(value)->int #查找list中某value出现的次数

L.sort(key)->None #只需要传入对应的key即可,原理就是拿key中的每个元素执行sort方法

a.sort(key=lambda x :x[],reverse=True)

L.copy()->list #生成一个新的list，存储地址不同

3、tupple

3.1、内置方法

3.2、常用内置方法

count()
index()

4、dict

4.1、内置方法

4.2、常用内置方法

[‘clear’, ‘copy’, ‘fromkeys’
, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’]

fromkeys(iterable,value=None)#通过传入iterable生成新的dict。

D.get(k[,d])->D[k]#传入k得到对应的value

D.items()->set #返回dict的子项item

D.update()#传入dict进行更新

5、其他

5.1、几个sort的使用

sorted #传入对应的迭代器和key即可比较

字典如何去排序#sorted(dict.items(),key=lambdax:x[1])#dict.item()返回值为tuple,所以才能利用sored排序！

a.sort(key=lambda x :x[],reverse=True)#key最好用#声明按字典中key或者value进行排序

多级排序咋个办#使用sort方法中operator

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：
1、sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
2、list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法
sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])
参数说明：

iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值
返回重新排序的列表。

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>

5.2、enumerate（）：根据可迭代对象创建枚举对象

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法
以下是 enumerate() 方法的语法:

enumerate(sequence, [start=0])
参数
sequence – 一个序列、迭代器或其他支持迭代对象。
start – 下标起始位置。
返回值
返回 enumerate(枚举) 对象。

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three

5.3、filter

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法
以下是 filter() 方法的语法:

filter(function, iterable)
参数
function – 判断函数。
iterable – 可迭代对象。
返回值
返回列表。

实例
以下展示了使用 filter 函数的实例：
过滤出列表中的所有奇数：
#!/usr/bin/python
# -*- coding: UTF-8 -*-def is_odd(n):return n % 2 == 1newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
输出结果 ：[1, 3, 5, 7, 9]

5.4、map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map() 函数语法：
map(function, iterable, …)
参数
function – 函数
iterable – 一个或多个序列
返回值
Python 2.x 返回列表。
Python 3.x 返回迭代器

>>>def square(x) :            # 计算平方数
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

5.5、reduce()

函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

语法
reduce() 函数语法：

reduce(function, iterable[, initializer])
参数
function – 函数，有两个参数
iterable – 可迭代对象
initializer – 可选，初始参数
返回值
返回函数计算结果。

实例
以下实例展示了 reduce() 的使用方法：
>>>def add(x, y) :            # 两数相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
15

5.6、dir()

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
dir 语法：

dir([object])
参数说明：

object – 对象、变量、类型。
返回值
返回模块的属性列表。

>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

5.7、eval()

用来执行一个字符串表达式，并返回表达式的值。
语法
以下是 eval() 方法的语法:

eval(expression[, globals[, locals]])
参数
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

5.8、file()

用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。

语法
以下是 file() 方法的语法:

file(name[, mode[, buffering]])
参数
name – 文件名
mode – 打开模式
buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。
返回值
文件对象。

实例
测试文件 test.txt，内容如下：RUNOOB1
RUNOOB2
>>>f = file('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'

5.9、isinstance()

来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法
以下是 isinstance() 方法的语法:

isinstance(object, classinfo)
参数
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。。

实例
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

5.10、round()

方法返回浮点数x的四舍五入值。

语法
以下是 round() 方法的语法:

round( x [, n] )
参数
x – 数值表达式。
n – 数值表达式。
返回值
返回浮点数x的四舍五入值。

round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0

5.11、set()

函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法
set 语法：

class set([iterable])
参数说明：

iterable – 可迭代对象对象；
返回值
返回新的集合对象。

>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除

5.12、zip()

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。

语法
zip 语法：

zip([iterable, …])
参数说明：

iterabl – 一个或多个迭代器;
返回值
返回元组列表。

实例
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

5.13、Format()

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

数字格式化
下表展示了 str.format() 格式化数字的多种方法：