3.1字符串方法

查找

  • str.find()
    • 参数
      • str — 指定检索的字符串
      • beg — 开始索引，默认为0。
      • end — 结束索引，默认为字符串的长度。
  • index()
    • 不同与find(), 查找不到会抛出异常
  1. # 查找，find()、index()、rfind()、rindex()
  2. s =  '学习Python'
  3. s.find('P')            # 2, 返回第一次出现的子串的下标
  4. s.find('h', 2)            # 5, 设定下标2开始查找
  5. s.find('23333')            # -1, 查找不到返回-1
  7. s.index('y')            # 3, 返回第一次出现的子串的下标
  8. s.index('P')        # 不同与find(), 查找不到会抛出异常

转换大小写

  • str.upper()
  • str.lower()
  • str.swapcase() 大小写互换
  • str.capitalize()将字符串的第一个字母变成大写,其他字母变小写。
  • istitle()方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
  1. # 转大小写, upper()、lower()、swapcase()、capitalize()、istitle()、isupper()、islower()
  2. s =  '学习Python'
  3. s.upper()            # '学习PYTHON'
  4. s.swapcase()            # '学习pYTHON', 大小写互换
  5. s.istitle()            # True
  6. s.islower()            # False

替换

replace()

  • old — 将被替换的子字符串。
  • new — 新字符串，用于替换old子字符串。

  • max — 可选字符串, 替换不超过 max 次

    1. # 替换，还可以使用正则表达式替换
    2. s.replace('Python', 'Java')    # '学习Java'

    去空格

  • strip()

    • 默认为空格
    • 参数可设为指定字符，即可删除指定字符
  • lstrip()
  • rstrip()
  1. s = ' baidu'
  2. print(s.strip('bai'))

3.2切片

  1. s = '学习Python'
  2. # 切片
  3. s[0], s[-1], s[3:], s[::-1]    # '学', 'n', 'Python', 'nohtyP的习学'

3.3格式化

  1. # 格式化
  2. s1 = '%s %s' % ('Windrivder', 21)    # 'Windrivder 21' 
  3. s2 = '{},{}'.format('HELLO','python')
  4. s3 = '{1},{0},{1}'.format('HELLO','python')
  5. s4 = '{name}: {age}'.format(age=21, name='Windrivder')

3.4连接和分割

# 连接与分割，使用 + 连接字符串，每次操作会重新计算、开辟、释放内存，效率很低，所以推荐使用join
l = ['2017', '03', '29', '22:00']
s5 = '-'.join(l)            # '2017-03-29-22:00'
s6 = s5.split('-')            # ['2017', '03', '29', '22:00']

3.5遍历字符串

  1. for 语句遍历
fruit = 'banana'
for letter in fruit:
    print(letter)


fruit = 'banana
for index < len(fruit):
    letter = fruit[index]
    print(letter)
    index = index +1

frist = 'JKLMNOPQ'
second = 'ack'

for letter in frist:
    print(letter + second)

3.6搜索、循环和计数

def find(word , letter):
    index = 0
    while index < len(word):
        if word[index]==letter:
            return index
        index += 1
    return -1

find('banana','n')

计数：

count =0
word = 'banana'
for letter in word:
    if letter == 'a':
        count = count + 1
print(count)

练习题

两个字符串中都有的字母：

def both_have(word1,word2):
    list_both_have=[]
    for letter in word1:
        if letter in word2:
            list_both_have.append(letter)
    return list_both_have

print(both_have('apples','oranges'))

是否两个字符串时颠倒的：

def is_reverse(word1,word2):
    if len(word1) != len(word2):
        return False

    i = 0
    j = len(word2)-1  #必须减一，要不然会出现word2的index超出范围的错误

    while j >= 0 :
        print（i,j)
        if word1[i] != word2[j]:
            return False
        i = i + 1
        j = j - 1
    return True

is_reverse('hello','olleh')

判断一个字符是否为可颠倒的 ： 例如 noon ，倒过来还是noon

def is_p(word):
    if word [:] == word[::-1]:
        return True
print(is_p('noon'))

密码管理， 传递特殊密码时，早期都是通过错位的方式进行传递到，需要两个参数（原始字符串，错位的位数）

def rotate_word (strings, num):
    string_rotated = ''
    for letter in strings:
        n = ord(letter)
        string_rotated = string_rotated + chr(n+num)
    return string_rotated

new_str = rotate_word('abc',1)
print(new_str)



## List 方式拼接字符更节省内存，更高效。
def rotate_word (strings, num):
    string_rotated = ''
    list_str = []
    for letter in strings:
        n = ord(letter)
        n_new =  ((n + num)-97)%26+97   # 这个很关键，可以判断两个数字相加之后超过z的值后的计算
        list_str.append(chrn_new)
        #string_rotated = string_rotated + chr(n_new)
    string_rotated = ''.join(list_str)
    return string_rotated

new_str = rotate_word('chd',1)
print(new_str)