方法是特定的对象相关联在一起的函数  附属于对象的属性 而这些属性不过是调用的函数

object.attribute读取ob的属性attribute值

字符串方法：

大小写相关：

  “string”.capitalize( ) 第一个字母大写，其余都变成小写

  “string”.title( ) 每一个词的头字母大写，其余都小写

  "string".upper( ) 全改为大写

  "string".lower( )全改成小写

  "string".swapcase( ) 大小写转换

排版相关：

  S.center.(width,['char']) 原来的字符扩到指定长度，再用char填充其余空处，默认空格。类似的有S.ljust( ) / S.rjust( )

  S.expandtabs( tabsize ) 更改tabs转换为空格的数量，默认为8

  S.strip( [chars] ) 删除两边的指定字符（默认为空格和换行符）类似的有S.lstrip( [chars] ) / S.rstrip( [chars] )

查找相关；

S.startswith( prefix[ , start[ ,end ] ] ) / S.endswith( suffix [ ,start[ ,end] ] )  是否 以特定字符串开头/结尾的，返回真假。例：'hello world'.startswith('hello')

S.count( sub [ , start[,end] ] ) 相应字符串在文本里的个数。例：‘hello world’.count('l')

S.find( sub [ ,start[,end] ] ) / S.rfind(sub [,end] ) 查询第一个与sub匹配的字符串位置，没找到就返回-1。例：‘helloworld'.find('l')

S.index 与find差不多，但没找到的话，返回错误

S.replace(old,new[,count]) 查找old，替换成new，count为替换相应的个数，默认全替换。例：'hello world'.replace('h','H')

格式判断：

返回的值都是真或假

S.isalpha( ）是否为字母

S.isdigit( ) 是否为数字

S.isalnum( ) 是否为数字和字母

S.islower( ) 是否有字母且全小写

S.isupper( )

S.isspace( ) 是否只有空格和换行符号

S.istitle( ) 是否每个单词的第一个字母为大写

下面的只有py3开始支持

S.isdecimal( ) 是不是数字

S.isnumeric 是不是数字 

S.isidentifier( ) 判断字符能否成为标识符

S.isprintable( ) 字符是否全部能打印

字符的分隔：

S.split( [sep [ ,maxsplit] ] ) /

S.rsplit( [ sep[,maxsplit] ] ) 从左或右以sep分隔，最多分隔max次，默认无限次。

例：'helloworldhello'.split(' ',1)

S.splitlines( [keepends]) 以\n 或者\r 或者 \r\n 分隔

例：'hello\nworld'.splitlines( )

S.partition(sep) / S.rpartition(sep) 从左或右找第一个sep分隔，sep左边的，sep  ，sep 右边的

'http;//baidu.com'.partition('://')

其他：

S.join( )--->'-'.join('abc')--->'a-b-c'

S.maketrans( x [,y[,z] ] ) / S.translate(map) 两者在py2和3中完全不同

例：map1={97:'A'}  

'a'.translate(map1)--->

S.format 字符串格式化方法

Python的类型与运算-字符串方法

• 字符串方法
• 字符串格式化表达式

    属性读取：
Object.attribute格式的表达式可以理解为“读取object对象的属性attribute值”

    函数调用表达式
具有函数（参数）格式的表达式意味着“调用函数代码，传递零或者更多用逗号隔开的参数对象，最后返回函数的返回值”。
    这两者合并可以让我们调用一个对象方法。

大小写相关

S.capitalize() － 第一个字母大写，其余都变成小写字母。
S.title() － 每一词的头字母大写，其余都变成小写字母。
S.upper() － 全改成大写
S.lower() － 全改成小写
S.swapcase() － 大小写转换
S.center(width[, fill])/ S.ljust(width[, fill])/S.rjust(width[, fill])－ 原来的字符扩到指定长度，再用fill来填充其余空处，默认空格。

S.expandtabs(tabsize)
－ 更改tabs（在字符串里”\t”）转换为空格的数量，默认为8。
S.zfill(width)
－ 原来的字符串扩到指定长度，前面使用0来填充。数字计算的时候会用到。
S.strip([chars])/S.lstrip([chars])/S.rstrip([chars])
－ 删除两遍／左边／右边的指定字符（默认为空格和换行符）。

字符串的格式化方法 

# ！/usr/bin/env python
# -*- coding:UTF-8 -*-
import getpass

text = input("请输入你的名字：")
print(text,"你好！")


name = input("请输入你的名字：")
age = int(input("请输入你的年龄："))
sex = input("请输入你的性别：")
words = input("请输入你的祝福的话语：")


information = """
-------------------来自%s的真实的信息-------------------
你的名字是%s
你的年龄是%d
你的性别是%s
你的祝福的话语是%s
"""%(name,name,age,sex,words)


new_information = """
-------------------来自{0}的真实的信息-------------------
你的名字是{1}
你的年龄是{2}
你的性别是{3}
你的祝福的话语是{4}
""".format(name,name,age,sex,words)

print(new_information.encode().decode())
'''
encode() 方法以 encoding 指定的编码格式编码字符串。字符串转换为二进制。
decode() 方法以 encoding 指定的编码格式解码字符串。二进制转换为字符串。
布尔值
    True 和 False
对应数字
    1    和     0
'''

属性读取：
Object.attribute格式的表达式可以理解为“读取object对象的属性attribute值”。

字符串操作方法

1. S.capitalize() － 第一个字母大写，其余都变成小写字母。
2. S.title() － 每一词的头字母大写，其余都变成小写字母。
3. S.upper() － 全改成大写。
4. S.lower() － 全改成小写。
5. S.swapcase() － 大小写转换。
6. S.center(width[, fill])/ S.ljust(width[, fill])/S.rjust(width[, fill])
   － 原来的字符扩到指定长度，再用fill来填充其余空处，默认空格。
7. S.expandtabs(tabsize)
   － 更改tabs（在字符串里”\t”）转换为空格的数量，默认为8。
8. S.zfill(width)
   － 原来的字符串扩到指定长度，前面使用0来填充。数字计算的时候会用到。
9. S.strip([chars])/S.lstrip([chars])/S.rstrip([chars])
   － 删除两遍／左边／右边的指定字符（默认为空格和换行符）。
10. 在这里所有的start和start, end看成是S[start:]和S[start:end]
    S.startswith(prefix[, start[, end]])/S.endswith(suffix[ ,start[ ,end]])
    － 以特定字符串开头／结尾的，返回真假。
11. S.count(sub[, start[, end]])
    － 相应字符串在文本里的个数
12. S.find(sub [, start[, end]])/S.rfind(sub[, start[, end]])
    － 查找第一个与sub匹配的字符串位置，没找到返回-1
13. S.index(sub[, start[, end]])/S.rindex(sub[, start[, end]])
    － 与find差不多，但没找到会返回错误
14. S.replace(old, new[, count])
    － 查找old，替换成new，count是只替换相应个数，默认全替换。

字符串的方法：方法调用

大小写的函数：S.capitalize()/S.title()/S.upper()/S.lower()/S.swapcase()

排版相关函数：S.centerr(width[,fill])/S.ljust(width[,fill])/S.rjust(width[,fill])/S.expandtabs(tabsize)//转换空格的数量

查找相关函数：S.startswith(prefix[,start[,end]])//以特定字符串开头，返回真假

s.find(sub[,start[,end]])//查找第一个与sub匹配的字符串位置，没找到返回-1

格式判断函数：S.isalpha()--判断是不是字母

S.isdigit()--判断是否数字

字符分隔函数：S.split([sep[,maxsplit]])/S.rsplit([sep[,maxsplit]])--从左/右

python3.x

a='aB\nC1234c5b6a.b'

a.capitalize() ==> 'Ab\nc1234c5b6a.b'     a.title() ==> 'Ab\nC1234C5B6A.B'         a.upper() ==> 'AB\nC1234C5b6A.B'         a.lower() ==> 'ab\nc1234c5b6a.b'         a.swapcase() ==> 'Ab\nc1234C5b6A.B'

b='123'(奇数个) c='1234'（偶数个）

b.center(6,'*') ==>'*123**'(居中函数)   c.center(7) ==> '  1234 '(前面有2个空格，后一)                                   a.ljust(5,' ')==>'123  '                 b.rjust(5,'-')==>'-1234'                 print('Hello\tworld')==>'Hello   world' print('Hello\tworld'.expandtabs(10))==> 'Hello     world'                                                                  '  Hello world   '.strip()==>      'Hello world'                           '  Hello world   '.lstrip()==>       'Hello world   '                         '  Hello world   '.strip()==>            '   Hello world'                                                           'abcaabbccHello worldaaccbb'.strip('[abc]')==>'Hello world'                                   'abcaabbccHello worldaaccbb'.lstrip('[abc]')==>'Hello worldaaccbb'                           'abcaabbccHello worldaaccbb'.rstrip('[abc]')==>'abcaabbccHello world'

'Hello world'.startswith('hello')【判断是否以hello开头】==>False            'Hello world'.startswith('ello',1)【从第一个元素开始判断是否以ello开头】==> True                                 'Hello world'.endswith('Rld')【判断是否以Rld结尾】==>False                 'Hello world'.endswith('Rld'，1)【去掉第一个元素，判断是否以Rld结尾】==>False  

'hello world'.count('l')==>3         'hello world'.count('ll')==>1         

'hello world'.find('l')==>2【找到第一个l，并输出其所在位置】                   'hello world'.rfind('l')==>9【从右边开始找】                                  'hello world'.find('a')==>-1（未找到则返回-1） // index()函数会返回错误

'hello'.replace('l','L',1)将第一个l换为L

python 2.x 3.x

S.isalpha()判断是否是纯字母           S.isdigit()判断是否是纯数字           S.isalnum()判断是否是数字加字母       S.islower()判断是否有字母且全是小写   S.isupper()判断是否有字母且全是大写   S.isspace()判断是否只有空格和换行符   S.title()判断每个单词的第一个字母是不是大写

python 3.x

S.isdecimal()判断是否是纯数字           S.isnumeric()判断是否是纯数字         S.isidentifier()判断字符能否成为标识符 S.isprintable()判断字符是否全部能打印出来

'Hello world'.split()==>['Hello','world']                     'Hello    world'.split(' ')==>['Hello',' ',' ','world']

'Hello\nworld\rhello'.splitlines()==>  ['Hello','world','hello']

'http://myweb.com'.partition('://')==>('http','://','myweb.com')

'http://myweb.com/1st/2nd/3rd/file.name'.rpartition('/')==>('http://myweb.com/1st/2nd/3rd','/','file.name')

'-'join('abc')==>'a-b-c'

python3.x

map={97:'A'}                         "a".translate(map)==>'A'

字符串方法

字符串格式化表达式

字符串操作

字符串输出方法

除了表达式之外，字符串还提供了一系列的方法去实现更复杂的文本处理任务。方法是与特定的对象关联在一起的函数。从技术角度讲，它们附属于对象的属性，而这些属性不过是写调用函数罢了。在py中，表达式和内置函数可能在不同范围的类型有效，但方法通常特定于对象类型，例如，字符串方法仅适用于字符串对象

属性读取：

     Object.attribute格式的表达式可以理解为"读取object对象的属性attribute值"

函数调用表达式

     具有函数（参数）格式的表达式意味着"调用函数代码，传递零或者更多用逗号隔开的参数对象，最后返回函数的返回值"

这两者合并可以让我们调用一个对象方法

S.expandtabs(tabsize)改变默认的(8)tab键值

S.strip()去掉两边的空格(默认或者是指定的字符)lstrip  rstrip

S.split()以指定的字符分割字符串（默认以空格分割）

S.splitlines([keepends])以\n或者\r或者\r\n分割

S.partition(sep)从左或者右找第一个sep分割保留sep分隔符 一般用在分割网址时

join连接字符串

attribute属性

方法

“hellob”.capitalize() Hello

.title() Hello Hello

.会分割为两个单词，有数字不是单词

swapcase（）大小写转换

'Hello'.center(7)

奇数个靠左

偶数个靠右

.center(7,'a')

ljust(7.'-')

.strip()默认删除两边空格和换行符

'helloworld'starstwith('hello',0,5)=='hello world'[0:5].startswith('hello')

'hello world'.startswith('hello',1)为false

有start才有end

.endswith('ld',4)只要结尾有那个字符串，如果只设单个数字的话大部分都是true因为结尾都为ld

\x00不可打印

‘http://myweb.com'.partition('://')

'-'.join(['dad','ad'] join多用于列表

map={97:'A'}

'a'.translate(map)可以将小写转换为大写