DevOps系列文章之 Python基础

字符串

定义字符串

1.python中字符串被定义为引号之间的字符集合

2.python支持使用成对的单引号或双引号
3.无论单引号，还是双引号，表示的意义相同
4.python还支持三引号（三个连续的单引号或者双引号），可以用来包含特殊字符
5.python不区分字符和字符串

字符串是不可变对象，字符串是可迭代对象Python3中，字符串是Unicode编码

特别提醒：字符串如果修改的话，字符串所在的内存地址也跟着变化，所以不可被修改，但是对于列表来说，可以修改是因为列表的内存是不变的，可以直接在上面修改

字符串切片

1.使用索引运算符[ ]和切片运算符[ : ]可得到子字符串
2.第一个字符的索引是0，最后一个字符的索引是-1
3.子字符串包含切片中的起始下标，但不包含结束下标

4.切片的语法：[起始:结束:步长]
5.注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)

字符串连接操作

1.使用+号可以将多个字符串拼接在一起
2.使用*号可以将一个字符串重复多次

>> name = "hello"
>>> name[0]
'h'

>>> name[-2]
'l'

>>> name[2:5]
'llo'
>>> name[2:4]
'll'
>>> name[:4]
'hell'
>>>

字符串操作符

1.比较操作符：字符串大小按ASCII码值大小进行比较
2.切片操作符：[ ]、[ : ]、[ : : ]

3.成员关系操作符：in、not in

字符串模板

string模块提供了一个Template对象，利用该对象可以实现字符串模板的功能

>>> import string
>>> origTxt = "Hi ${name}, I will see you ${day}"
>>> t = string.Template(origTxt)
>>> t.substitute(name = 'bob', day = 'tomorrow')
'Hi bob, I will see you tomorrow'
>>> t.substitute(name = 'tom', day = 'the day after tomorrow')
'Hi tom, I will see you the day after tomorrow'

原始字符串操作符

原始字符串操作符是为了对付那些在字符串中出现的特殊字符
在原始字符串里，所有的字符都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符

>>> winPath = "c:\windows\temp"
>>> winPath
'c:\\windows\temp'
>>> print winPath
c:\windows emp
>>> newPath = r"c:\windows\temp"
>>> newPath
'c:\\windows\\temp'
>>> print newPath
c:\windows\temp

Python实际三类字符串：

　1.通常意义字符串(str)

　　2.原始字符串，以大写R 或 小写r开始，r''，不对特殊字符进行转义

　　3.Unicode字符串，u'' basestring子类

python的字符串内建函数

具体如下：

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 'ignore' 或者'replace'
string.encode(encoding='UTF-8', errors='strict')	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，默认的空格数 tabsize 是 8.
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	Merges (concatenates)以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab])	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串 string 分成一个 3 元素的元组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是从右边开始.
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找.
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
string.splitlines(num=string.count('\n'))	按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.isdecimal()	isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

总结上面的用法，对其分个类，我们可以把字符串操作分为字符串的替换、删除、截取、复制、连接、比较、查找、分割等

　　但是，首先得判断这个对象是不是字符串，方法如下：

如何判断一个对象是不是字符串

python中字符串有两重，一种是str，一种是unicode。那如何判断一个对象是不是字符串呢？应该使用isinstance(s,basestring),而不是isinstance(s,str)。

看下面例子

>>>a = 'hi'
>>>isinstance(a,str)
True
>>>b = u'Hi'
>>>isinstance(b,str)
False
>>>isinstance(b,basestring)
True
>>>isinstance(b,unicode)
True
>>>isinstance(a,unicode)
False

要正确判读一个对象是不是字符串，要有basestring，因为basestring是str和unicode的基类，包含了普通字符串和unicode类型。

如何去掉字符串的双引号

a = '"string"'
print(a,type(a))
b = eval(a)
print(b,type(b))
 
结果：
"string" <class 'str'>
string <class 'str'>

下面讲str对象的基本用法

字符串的基本用法可以分以下五类，即性质判定、查找替换、分切与连接、变形、填空与删减。

(a)性质判定

性质判定有以下几个方法。

isalnum()：是否全是字母和数字，并至少有一个字符
isalpha()：是否全是字母，并至少有一个字符 
isdigit()：是否全是数字，并至少有一个字符
islower()：字符串中字母是否全是小写
isupper()：字符串中字母是否全是小写
isspace()：是否全是空白字符，并至少有一个字符
istitle()：判断字符串是否每个单词都有且只有第一个字母是大写
startswith(prefix[,start[,end]])：用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返 回 False。如果参数 start 和 end 指定值，则在指定范围内检查。
endswith(suffix[,start[,end]])：用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
 
is*()这些都比较简单，从字母的字面上就可以理解，*with()函数可以接受start和end参数，如果善加利用可以优化性能。另外，从python 2.5版本起，*with()函数族的第一个参数可接受tuple类型实参，当实参中某个元素匹配时，即返回True

(b)查找与替换

count(sub[,start[,end]])：统计字符串里某个字符sub出现的次数。可选参数为在字符串搜索的开始与结束位置。这个数值在调用replace方法时用得着。
find(sub[,start[,end]])：检测字符串中是否包含子字符串sub，如果指定start（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1
index(sub[,start[,end]])：跟find()方法一样，只不过如果sub不在 string中会抛出ValueError异常。
rfind(sub[,start[,end]])：类似于 find()函数，不过是从右边开始查找。
rindex(sub[,start[,end]])：类似于 index()，不过是从右边开始。
replace(old,new[,count])：用来替换字符串的某些子串，用new替换old。如果指定count参数话，就最多替换count次，如果不指定，就全部替换

前面五个方法都可以接受start、end参数，善加利用可以优化性能。对于查找某个字符串中是否有子串，不推荐使用index族和find族方法，推荐使用in和not in操作

(c)分切与连接

partition(sep)：用来根据指定的分隔符将字符串进行分割,如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。如果sep没有出现在字符串中，则返回值为(sep,",")。partition() 方法是在2.5版中新增的。
rpartition(sep)：类似于 partition()函数,不过是从右边开始查找.
splitness([keepends])：按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数        keepends 为 False，不包含换行符，如果为 True，则保留换行符。
split(sep[,maxsplit]])：通过指定分隔符对字符串进行切片，如果参数maxsplit 有指定值，则仅分隔 maxsplit 个子字符串，返回分割后的字符串列表。
rsplit(sep[,maxsplit]])：同split(),不过是从右边开始。

字符串的切割

# 使用 split(sep=None, maxsplit=-1) -> list of strings , 从左向右切割，sep指定分隔符，maxsplit指定切割的次数， -1表示有多少分隔符切多少刀
    string1 = '1,2,3,4,5'
    new_obj1 = string1.split(',')
    new_obj2 = string1.split(',', maxsplit=1)
    print(new_obj1)
    print(new_obj2)
    # 使用rsplit方法, rsplit(sep=None, maxsplit=-1) -> list of strings, 从右向左切割，sep指定分隔符，maxsplit指定切割的次数， -1表示有多少分隔符切多少刀
    string1 = '1,2,3,4,5'
    new_obj1 = string1.rsplit(',')
    new_obj2 = string1.rsplit(',', maxsplit=1)
    print(new_obj1)
    print(new_obj2)
    # 使用splitlines方法, splitlines([keepends]) -> list of strings， 按照行切割, keepends指是否保留分隔符
    string1 = 'I love xkd \nI love xkd'
    new_obj1 = string1.splitlines()
    new_obj2 = string1.splitlines(True)
    print(new_obj1)
    print(new_obj2)
    # 使用partition方法, partition(sep) -> (head, sep, tail)， 从左到右切割三段，分隔符为中间那段
    string1 = '1,2,3,4,5'
    new_obj1, seq, new_obj2 = string1.partition(',')
    print(new_obj1)
    print(seq)
    print(new_obj2)
    new_obj1, _, _ = string1.partition(',')
    print(new_obj1)

看下面例子

str1 = 'ab c\n\nde fg\rkl\r\n'
print str1.splitlines();
  
str2 = 'ab c\n\nde fg\rkl\r\n'
print str2.splitlines(True)

输出如下：

['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

split()函数有个小陷阱，比如对于字符串s，s.split()和s.split(" ")的返回值不同。看下面代码

s = "  hello world"#前面有两个空格
print s.split()
print s.split(' ')

输出结果如下

['hello', 'world']
['', '', 'hello', 'world']

这是为什么呢？原因在于：当忽略sep参数或者sep参数为None时与明确给sep赋予字符串值时，split()采用了两种不同的算法。对于前者，split()先除去两端的空白符，然后以任意长度的空白符串作为界定符分切字符串（即连续空白符串会被单一空白符看待）；对于后者则认为两个两个连续空白符之间存在一个空字符串，因此对空字符串，它们的返回值也不同。

>>>".split()
[]
>>>''.split(' ')
['']

(d)变形

lower()：转换字符串中所有大写字符为小写。
upper()：将字符串中的小写字母转为大写字母。
capitalize()：将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。
swapcase()：用于对字符串的大小写字母进行转换，大写转小写，小写转大写。
title()：返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写。

这些都是大小写切换，title()并不能除去字符串两端的空白符也不会把连续空白符替换成一个空格，如果有这样的需求，可以用string模块的capwords(s)函数，它能除去两端空白符，并且能将连续的空白符用一个空格符代替。看下面例子：

#coding=utf-8
import string
s = "   hello   world"
print s.title()
print string.capwords(s)

输出结果如下：

   Hello   World
Hello World

(e)删减与填充

strip([chars])：用于移除字符串头尾指定的字符（默认为空格），如果有多个就会删除多个。
ltrip([chars])：用于截掉字符串左边的空格或指定字符。
rtrip([chars])：用于截掉字符串右边的空格或指定字符。
center(width[,fillchar])：返回一个原字符串居中,并使用fillchar填充至长度 width 的新字符串。默认填充字符为空格
ljust(width[,fillchar])：返回一个原字符串左对齐,并使用fillchar填充至指定长度的新字符串，默认为空格。如果指定的长度小于原字符串的长度则返回原字符串。
rjust(width[,fillchar])：返回一个原字符串右对齐,并使用fillchar填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
zfill(width)：返回指定长度的字符串，原字符串右对齐，前面填充0
expandtabs([tabsize])：把字符串中的 tab 符号('\t')转为适当数量的空格，默认情况下是转换为8个。

（f）字符串切片

切片操作（slice）可以从一个字符串中获取子字符串（字符串的一部分）。我们使用一对方括号、起始偏移量start、终止偏移量end 以及可选的步长step 来定义一个分片。

格式： [start:end:step]

    • [:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
    • [start:] 从start 提取到结尾
    • [:end] 从开头提取到end - 1
    • [start:end] 从start 提取到end - 1
    • [start:end:step] 从start 提取到end - 1，每step 个字符提取一个
    • 左侧第一个字符的位置/偏移量为0，右侧最后一个字符的位置/偏移量为-1

例子：

str = '0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取，截取倒数第五位数与倒数第三位数之间<br>print str[::2] #按照步长为二，返回所有值

（g） maketrans和translate的用法

开发敏感词语过滤程序，提示用户输入内容，如果用户输入的内容中包含特殊的字符：
如："苍老师"“东京热”，则将内容替换为***

sentence_input  = input("请输入：")
sensitive_varcabulary1 = str.maketrans("苍老师",'***')
sensitive_varcabulary2 = str.maketrans("东京热",'***')
new_sentence = sentence_input.translate(sensitive_varcabulary1).translate(sensitive_varcabulary2)
print(new_sentence)
# 请输入：dads大大的苍老师
# dads大大的***

字符串操作实例：

#首字母大写(capitalize())
>>> name = "hello world"
>>> name.capitalize()   #首字母大写
'Hello world'
>>> 

#center(width,fillchar)
如果width（字符宽度）小于等于(<=)字符串的长度，则返回原字符串，如果大于(>)字符串的，则用fillchar（填满字符）填满，处理结果等于width，字符串位于fillchar的中间
>>> name.center(5)  #字符串居中，如果字符串不够5个字符串的话，用空格填充
'hello world'


>>> name.center(20) #字符串居中，如果字符串不够20个字符串的话，用空格填充
'    hello world     '

#统计(count(sub,start=None,end=None))
#sub:统计的字符，start:开始位，end：结束位，start和end默认为空时,则表示全部字符中去统计
>>> name.count('he')   #统计字母he出现的次数
1
>>> name.count('o') #统计字母o出现的次数
2
>>> name.count("o",0,5)   #从索引1-5中统计字母o出现的次数
1

>>> name.endswith("world") #检查字符串是否以world结尾，是则返回True，否则返回False

True


#find(sub,start=None,end=None)

#全文查找sub中第一个字符所在整个字符串中的索引值,没有找到则返回-1

#sub：字符或者字符串，start：开始位，end：结束位，start和end默认为空时，则在整个字符串中查找

>>> name.find("he")  #查找"he"，找到则返回其索引，否则返回-1
0
>>> name.find("e")
1
>>> name.index('w')  #跟find()方法一样，只不过如果str不在 string中会报一个异常
6
>>> 
>>> name.isalnum()  #字符串中只能包含字母或数字，否则返回False
False
>>> name = 'hello'
>>> name.isalnum()
True
>>> name.isalpha()  #字符串中所有的字符都是字母则返回True，否则返回False
True

>>> name = "abc123"  
>>> name.isdigit() #判断字符串中是否只包含数字，是则返回True，否则返回False
False
>>> name.islower() #判断字符串中是否全是小写，是则返回True，否则返回False
True
>>> 
>>> name.isspace() #判断字符串是否只包含空格，是则返回True，否则返回False
False

>>> name = "hello world"  
>>> name.isspace()  
False
>>> name = " "
>>> name.isspace()
True
>>> 
>>> name.istitle()    #判断字符串中是否以标题化的形式显示，是则返回True，否则返回False
False
>>> name = "hello world"
>>> name.istitle()   
False
>>> name = "Hello world"
>>> name.istitle()
False
>>> name = "Hello World"
>>> name.istitle()
True
>>> 


>>> name.isupper()   #判断字符串中所有的字符是否为大写，是则返回True，否则返回False
False

>>> ".".join(name)   #用.作为分隔符把字符串分割开合并成一个新的字符串
'H.e.l.l.o. .W.o.r.l.d'
>>> 

#ljust(width,fillchar)
如果字符串的长度大于width（字符宽度），则返回原字符串，如果小于width，则用fillchar（填满字符）填满，处理结果等于width，fillchar位于字符串的最右边
 #特别提醒：ljust中的l表示left的意思，表示从右向左
>>> name.ljust(50)  #原字符串左对齐，不够的位置用空格填充
'Hello World                                       '

>>> name.lower()   #判断字符串中所有的字符是否为小写，是则返回True，否则返回False
'hello world'

>>> name = "        hello world         "
>>> name.lstrip()  #去除左边的空格

'hello world         '
>>> name.rstrip()   #去除右边的空格
'        hello world'



#rjust(width,fillchar)

如果字符串的长度大于width（字符宽度），则返回原字符串，如果小于width，则用fillchar（填满字符）填满，处理结果等于width，fillchar位于字符串的最左边

#特别提醒：ljust中的l表示left的意思，表示从左向右

>>> name.rjust(50)  #原字符串右对齐，不够的位置用空格填充
'                              hello world         '
>>> 

 
>>> max(name)  #返回字符串中最大的字母
'w'
>>> min(name)  #返回字符串中最小的字符
' '

>>> name.startswith("h")  #检查字符串是否以h开头，是则返回True，否则返回False
True

>>> name = "     hello world  "
>>> name.strip()  #去除两边的空格
'hello world'


>>> name.swapcase()   #翻转字符串中的大小写
'     HELLO WORLD  '

>>> name.title()      #返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写
'     Hello World  '
>>> name.upper()     #把字符串的小写改成大写
'     HELLO WORLD  '

>>> name.zfill(50)   #原字符串右对齐，长度不够的话用0来填充
'00000000000000000000000000000000     hello world  '
>>> 


split()函数


语法：str.split(str="",num=string.count(str))[n]

参数说明：
str：表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]：表示选取第n个分片

注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略

>>> u = "www.doiido.com.cn"
>>> u.split() #使用默认分隔符
['www.doiido.com.cn']

#

>>> u.split(".") #以.作为分隔符
['www', 'doiido', 'com', 'cn']
>>>

>>> u.split(".",0) #分割0次
['www.doiido.com.cn']
>>>

>>> u.split(".",1) #分割1次
['www', 'doiido.com.cn']
>>>

>>> u.split(".",2) #分割2次
['www', 'doiido', 'com.cn']
>>>

>>> u.split(".",2)[1] #分割两次，并取序列为1的项
'doiido'
>>>

>>> u.split(".",-1)#分割最多次（实际与不加num参数相同）
['www', 'doiido', 'com', 'cn']
>>>

>>> u1,u2,u3 = u.split(".",2) #分割两次，并把分割后的三个部分保存到三个文件
>>> u1
'www'
>>> u2
'doiido'
>>> u3
'com.cn'
>>>

format_map()
数据格式，以字典形式传入
>>> name="name:{name},age:{age}"
>>> name.format_map({"name":"luoahong",'age':23})
#输出结果
'name:luoahong,age:23'

字符串格式化

Python的字符串格式化有两种方式: 百分号方式、format方式

百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。[PEP-3101]

This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing '%' string formatting operator.

如下：

# C语言风格
    print("I am %04d" % (100,)) # 前端补0
    print('I am %s' % 'xkd')    # 字符串
    print('%.3f' % (99.56789))  # 保留3位小数
    print("I am %-5d" % (20,))  # 左对齐
    print("I am %5d" % (20,))   # 右对齐
    # python format风格
    S.format(*args, **kwargs) -> str, 其中args为元组，kwargs为字典，花括号为占位符
    1: 占位
    print('我是{}老师， 我在{}'.format('Robby', 'xkd'))
    print('我是{0}老师， 我在{1}'.format('Robby', 'xkd'))
    print('我是{1}老师， 我在{0}'.format('xkd','Robby',))
    print('我是{1}老师， 我在{0}'.format(*('xkd','Robby')))
    print('我是{name}老师， 我在{addr}'.format(name='Robby', addr='xkd'))
    print('我是{name}老师， 我在{addr}'.format(**{'name':'Robby', 'addr':'xkd'}))
    2：对齐
    print('{0} + {1} = {2:<100}'.format(1,2,3))        # 指定100个位置，且左对齐
    print('{0} + {1} = {2:>100}'.format(1,2,3))        # 指定100个位置，且右对齐
    print('{0} + {1} = {2:0<100}'.format(1,2,3))       # 指定100个位置，且左对齐，其他地方补0
    print('{0} + {1} = {2:0>100}'.format(1,2,3))       # 指定100个位置，且右对齐，其他地方补0
    print('{0} + {1} = {2:^100}'.format(1,2,3))        # 指定100个位置，居中对齐
    print('{0} + {1} = {2:0^100}'.format(1,2,'不知道')) # 指定100个位置，居中对齐, 其他地方补0
    # 进制
    print("int: {0:d} bin: {0:b} hex: {0:x} oct: {0:o} ".format(100))
    print("int: {0:d} bin: {0:#b} hex: {0:#x} oct: {0:#o} ".format(100))

第一种：百分号方式

%[(name)][flags][width].[precision]typecode

    (name)      可选，用于选择指定的key
    flags          可选，可供选择的值有:

　+       右对齐；正数前加正号，负数前加负号；
        -        左对齐；正数前无符号，负数前加负号；
        空格    右对齐；正数前加空格，负数前加负号；
        0        右对齐；正数前无符号，负数前加负号；用0填充空白处

    width         可选，占有宽度
    .precision   可选，小数点后保留的位数
    typecode    必选

  s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
        r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
        c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
        o，将整数转换成 八  进制表示，并将其格式化到指定位置
        x，将整数转换成十六进制表示，并将其格式化到指定位置
        d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
        e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
        E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
        f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
        F，同上
        g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
        G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
        %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

常用格式化：

tp1 = "i am %s" % "alex"
 
tp2 = "i am %s age %d" % ("alex", 18)
 
tp3 = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
 
tp4 = "percent %.2f" % 99.97623
 
tp5 = "i am %(pp).2f" % {"pp": 123.425556, }

输出结果：

i am alex
i am alex age 18
i am alex age 18
percent 99.98
i am 123.43

第二种：Format方式

[[fill]align][sign][#][0][width][,][.precision][type]

        fill           【可选】空白处填充的字符
        align        【可选】对齐方式（需配合width使用）
            <，内容左对齐
            >，内容右对齐(默认)
            ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
            ^，内容居中
        sign         【可选】有无符号数字
            +，正号加正，负号加负；
             -，正号不变，负号加负；
            空格 ，正号空格，负号加负；
        #            【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
        ，            【可选】为数字添加分隔符，如：1,000,000
        width       【可选】格式化位所占宽度
        .precision 【可选】小数位保留精度
        type         【可选】格式化类型
            传入” 字符串类型 “的参数
                s，格式化字符串类型数据
                空白，未指定类型，则默认是None，同s
            传入“ 整数类型 ”的参数
                b，将10进制整数自动转换成2进制表示然后格式化
                c，将10进制整数自动转换为其对应的unicode字符
                d，十进制整数
                o，将10进制整数自动转换成8进制表示然后格式化；
                x，将10进制整数自动转换成16进制表示然后格式化（小写x）
                X，将10进制整数自动转换成16进制表示然后格式化（大写X）
            传入“ 浮点型或小数类型 ”的参数
                e， 转换为科学计数法（小写e）表示，然后格式化；
                E， 转换为科学计数法（大写E）表示，然后格式化;
                f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
                F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
                g， 自动在e和f中切换
                G， 自动在E和F中切换
                %，显示百分比（默认显示小数点后6位）

常用格式化：

#!/usr/bin/env python
#-*- coding:utf-8 -*-

tp1 = "i am {}, age {}, {}".format("seven", 18, 'alex')

tp2 = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])

tp3 = "i am {0}, age {1}, really {0}".format("seven", 18)

tp4 = "i am {0}, age {1}, really {0}".format(*["seven", 18])

tp5 = "i am {name}, age {age}, really {name}".format(name="seven", age=18)

tp6 = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})

tp7 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])

tp8 = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)

tp9 = "i am {:s}, age {:d}".format(*["seven", 18])

tp10 = "i am {name:s}, age {age:d}".format(name="seven", age=18)

tp11 = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})

tp12 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

tp13 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

tp14 = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)

tp15 = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

print tp1
print tp2
print tp3
print tp4
print tp5
print tp6
print tp7
print tp8
print tp9
print tp10
print tp11
print tp12
print tp13
print tp14
print tp15

执行结果：

i am seven, age 18, alex
i am seven, age 18, alex
i am seven, age 18, really seven
i am seven, age 18, really seven
i am seven, age 18, really seven
i am seven, age 18, really seven
i am 1, age 2, really 3
i am seven, age 18, money 88888.100000
i am seven, age 18
i am seven, age 18
i am seven, age 18
numbers: 1111,17,15,f,F, 1587.623000%
numbers: 1111,17,15,f,F, 1587.623000%
numbers: 1111,17,15,f,F, 1500.000000%
numbers: 1111,17,15,f,F, 1500.000000%

（h）字符串格式化（format）

用法：它通过 {} 和：代替传统的 % 方法

1，使用关键字参数

要点：关键字参数值要对得上，可用字典当关键字参数传入值，字典前加**即可

>>> hash = {'name':'hoho','age':18}
>>> 'my name is {name},age is {age}'.format(name='hoho',age=19)
'my name is hoho,age is 19'
>>> 'my name is {name},age is {age}'.format(**hash)
'my name is hoho,age is 18'

2，填充与格式化

:[填充字符][对齐方式 <^>][宽度]

'{:<20}'.format(10)           #左对齐
'10                  '
'{:>20}'.format(10)           #右对齐
'                  10'
'{:^20}'.format(10)           #居中对齐
'         10         '

3，使用位置参数

要点：从以下例子可以看出位置参数不受顺序约束，且可以为{},只要format里有相对应的参数值即可,参数索引从0开，传入位置参数列表可用*列表

>>> li = ['hoho',18]
>>> 'my name is {} ,age {}'.format('hoho',18)
'my name is hoho ,age 18'
>>> 'my name is {1} ,age {0}'.format(10,'hoho')
'my name is hoho ,age 10'
>>> 'my name is {1} ,age {0} {1}'.format(10,'hoho')
'my name is hoho ,age 10 hoho'
>>> 'my name is {} ,age {}'.format(*li)
'my name is hoho ,age 18'

4，精度与进制

>>> '{0:.2f}'.format(1/3)
'0.33'
>>> '{0:b}'.format(10)    #二进制
'1010'
>>> '{0:o}'.format(10)     #八进制
'12'
>>> '{0:x}'.format(10)     #16进制
'a'
>>> '{:,}'.format(12369132698)  #千分位格式化
'12,369,132,698'

5，使用索引

>>> li
['hoho', 18]
>>> 'name is {0[0]} age is {0[1]}'.format(li)
'name is hoho age is 18

（i）常用字符串技巧

1，反转字符串

>>> s = '1234567890'
>>> print s[::-1]
0987654321

2，关于字符串的拼接

尽量使用join()链接字符串，因为’+’号连接n个字符串需要申请n-1次内存,使用join()需要申请1次内存。

3，固定长度分割字符串

>>> import re
>>> s = '1234567890'
>>> re.findall(r'.{1,3}', s)  # 已三个长度分割字符串
['123', '456', '789', '0']

4，使用（）括号生成字符串

sql = ('SELECT count() FROM table '
       'WHERE id = "10" '
       'GROUP BY sex')
  
print sql
  
SELECT count() FROM table WHERE id = "10" GROUP BY sex

5，将print的字符串写到文件

>>> print >> open("somefile.txt", "w+"), "Hello World"  
# Hello World将写入文件somefile.txt

string模块

例子：

ascii_letters
获取所有ascii码中字母字符的字符串（包含大写和小写）
 
ascii_uppercase
获取所有ascii码中的大写英文字母
 
ascii_lowercase
获取所有ascii码中的小写英文字母
 
digits
获取所有的10进制数字字符
 
octdigits
获取所有的8进制数字字符
 
hexdigits
获取所有16进制的数字字符
 
printable
获取所有可以打印的字符
 
whitespace
获取所有空白字符
 
punctuation
获取所有的标点符号

python 如何从指定文件夹中读取csv文件格式

遍历文件夹，找到csv格式的文件

import os
Path_list = os.listdir(PathName0)
for name in Path_list:
    if name.endswith('.csv'):
        print(name)