字符串

  • 1.去除空格 strip()

    1. s1 = '   测试程序     '
    2. print(s1.strip())
    3. # 去除两端的空格， 可以用于用户输入时去掉输入
    4. # 内容两端的多余空格，括号内的是被去除的内容，不写默认为空格
    5. print(s1.lstrip())
    6. # 去除左边的空格
    7. print(s1.rstrip())
    8. # 去除右边的空格

  • 居中设置 center(‘占几个字符’, ‘代替多余空格的内容’)

    1. s = "测试"
    2. print(s.center(10, '-'))
    3. # 让字符串居中
    4. # 结果： ----测试----

  • 字符串中字母大小写

    1. str1 = str.upper()
    2. print(str1)
    3. # 把字符串中的每一个单词全部转换成大写
    4. str2 = str.lower()
    5. print(str2)
    6. str3 = str2.capitalize()
    7. print(str3)
    8. print(str.title())
    9. # 每个单词的首字母大写
    10. print(str.capitalize())

  • 索引操作，可以设置步伐

    1. str = 'This is a string'
    2. print(str[-7:-2:2])
    3. print(str[-1:-7:-2])

  • 替换字符串中的内容 ```python s = “Alex is a programmer” s1 = s.replace(‘ ‘, ‘’) print(s1)

    strip只能去除掉两边的内容，无法去除中间的内容

    但replace可以对中间的内容进行替换，‘’表示替换去除掉内容

    s2 = s.replace(‘Alex’, ‘Jack’) print(s2)

s3 = ‘AlexAlexAlexAlexAlexAlex’ s4 = s3.replace(‘Alex’, ‘Jack’, 3) print(s4)

最后的数字表示替换的个数

  2. - 切片操作split(‘分界的内容，被切掉的内容’)，切片后结果是有多个字符串组成的列表
  3. > **Note**
  4. > 需要注意的是如果切片操作切到了字符串的两端，那么会形成空的字符
  6. ```python
  7. s5 = 'Jack_is_a_hacker_and_very_like_program'
  8. s6 = s5.split('_')
  9. print(s6)
  10. s7 = s5.split('_program')
  11. print(s7)
  12. # 结果是:
  13. ['Jack', 'is', 'a', 'hacker', 'and', 'very', 'like', 'program']
  14. ['Jack_is_a_hacker_and_very_like', '']
  15. # 空字符串

  • 字符串的格式化操作

    1. print('%s的性别是%s,年龄是%d' % (name, gender, age))
    2. # %进行格式化，位置是固定的
    3. 李明的性别是男,年龄是19
    4. print('{}的年龄是{}，性别是{}'.format(name, age, gender))
    5. 李明的年龄是19，性别是男
    6. print('{2}的年龄是{0}，性别是{1}'.format(age, gender, name))
    7. 李明的年龄是19，性别是男
    8. # 可以指定位置，format中的顺序可以随意写，但需要注意的是下标索引必须从0开始
    9. print('%s的价格是%.2f' % (food, price))
    10. 大米的价格是123456.21
    11. # 保留小数点后的两位

  • 查找操作，注意start和end后都需要加上s

    1. s.startswith('测试')
    2. True
    3. # 查找字符串以固定内容开头
    4. s.endswith('内容')
    5. True
    6. # 查找字符串以固定内容结尾
    7. s = 'aaaaaaaabbbbbbbb'
    8. print(s.count('a'))
    9. 8
    10. # 计算字符串中固定字符出现的次数
    11. s = '12345sfljaso'
    12. print(s.find('f'))
    13. 6
    14. # 查找字符在字符串中的具体位置
    15. print(s.find('ccc'))
    16. -1
    17. 注意： 如果字符串中没有查找的字符，那么返回值是-1
    18. s = '123456dafsdfgfbbbbbbbb1234'
    19. print(s.find('fgf', 4, 23))
    20. 11
    21. # 查找固定位置内是否存在字符， 4为起始位置，23为结束位置
    22. print(s.index('bbbb'))
    23. 14
    24. # 查找字符在字符串中的下标索引值
    25. print(s.isalpha())
    26. False
    27. # 判断字符串是否由字母组成
    28. print(s.isalnum())
    29. True
    30. # 判断字符串是否由字母和数字组成
    31. print(s.isdigit())
    32. True
    33. # 判断字符串是否由数字组成
    34. if s.startswith('12') and s.endswith('qew'):
    35. ...if s.isalnum() and s.find('fg', 3, 15):
    36. ...     print('fg在字符串内')
    37. ...else:
    38. ...     print('fg不在字符串内')
    39. ...else:
    40. ...     print('字符串格式不正确')
    41. # 结果是：
    42. fg在字符串内
    43. # 综合使用

  • 字符串的长度

    1. s.__len__()
    2. 23
    3. len(s)
    4. 23
    5. # __len__()方法等同于len(), len调用的就是__len__()方法

  • 遍历字符串中的所有内容，需要先求出中长度，根据下标索引来打印出来

    1. '''方法一：根据索引来打印'''
    2. s = '21324354wqeretr'
    3. l = len(s)
    4. for i in range(0, l - 1):
    5. ...     print(s[i])
    6. ... 
    7. # 结果是：
    8. 2、1、3、2、4、3、5、4、w、q、e、r、e、t
    9. '''直接遍历打印'''
    10. for i in s:
    11. print(s, end='#')
    12. # 结果是：
    13. 1#2#3#2#4#5#w#q#e#r#w#g#f#d#v#c#
    14. # 这里需要注意end的用法，这个用法在python3版本中才可以直接使用，python2版本不支持

列表

  • 列表中的切片操作

    1. list = [1, 2, 3, 4, '21345wfe', 'safewgfvsc', 12324]
    2. print(list[4][3])
    3. # 结果是：
    4. 4
    5. # 字符串也是可以继续索引的
    6. print(list[2:4])
    7. ['sfaelm', 2]
    8. list.append({'name': 'Alex'})
    9. # 在列表末尾添加元素
    10. list
    11. ['213sd', '1324frvgf', 'sfaelm', 2, 1, {'name': 'Alex'}]
    12. # 列表中可以包含字典元素
    13. print(list[5]['name'])
    14. Alex
    15. # 打印字典的value
    16. print(list[::2])
    17. ['213sd', 'sfaelm', 1]
  • 列表的增删改查 ```python ‘’’添加元素’’’ list = [‘黄渤’, ‘史泰龙’, ‘黄宏’] list.pop()

    删除列表末尾元素

    print(list) list.append(‘张艺’)

    列表末尾添加元素

    list.insert(3, ‘姚明’)

    在固定位置添加元素

    print(list) ‘’’迭代添加’’’ list.extend(‘马化腾’) print(list) list.extend([‘马云’, ‘俞敏洪’]) print(list)

    结果是：

    [‘黄渤’, ‘史泰龙’, ‘张艺’, ‘马’, ‘化’, ‘腾’] [‘黄渤’, ‘史泰龙’, ‘张艺’, ‘马’, ‘化’, ‘腾’, ‘马云’, ‘俞敏洪’]

    注意：extend中添加也是在末尾，如果只是添加一个字符串，那么字符串中的每一个字符都会被当作单个元素一次添加进去，如果以列表的形式来添加，那么列表会被当作整体添加。

‘’’删除元素’’’

方式一

data = list.pop(2) print(data) print(list) 张艺 [‘黄渤’, ‘史泰龙’, ‘马’, ‘化’, ‘腾’, ‘马云’, ‘俞敏洪’]

pop如果不加参数，默认剔除掉末尾的元素，如果添加下标索引值，则删除指定的元素，pop具有返回值，删除的元素可以赋值给变量做判断

方式二

list.remove(‘马云’) print(list) [‘黄渤’, ‘史泰龙’, ‘马’, ‘化’, ‘腾’, ‘俞敏洪’]

四种删除方式中只有remove是通过写出删除的元素来删除的

方式三

del list[3] print(list) [‘黄渤’, ‘史泰龙’, ‘马’, ‘腾’, ‘俞敏洪’] del list[2:4] print(list) [‘黄渤’, ‘史泰龙’, ‘俞敏洪’]

通过下标索引来删除, 并且可以进行切片删除

方式四

list.clear() [ ]

把列表元素全部删除

‘’’修改列表元素：过程是先删除后新增’’’ list = [‘1234’, ‘王者荣耀’, ‘sdg’, 123243, ‘麦田的守望者’, ‘平凡的世界’, 123, {‘age’: 13}] list[2:4] = [‘政治’, ‘军事’] print(list) [‘1234’, ‘王者荣耀’, ‘政治’, ‘军事’, ‘麦田的守望者’, ‘平凡的世界’, 123, {‘age’: 13}]

通过切片来进行修改

list[1:4:2] = [‘QQ’, ‘Wechat’] [‘1234’, ‘QQ’, ‘政治’, ‘Wechat’, ‘麦田的守望者’, ‘平凡的世界’, 123, {‘age’: 13}]

通过列表中的步伐来隔元素进行修改，注意：需要修改几个元素，列表中需要给定几个元素，否则会报错

  2. - 列表的遍历
  3. ```python
  4. for i in list:
  5.     print(i, end=' ')
  6. 1234 QQ 政治 Wechat 麦田的守望者 平凡的世界 123 {'age': 13}

  • 列表的嵌套（将为操作）

    1. list = [[1, 2], ['测试', '程序'], [[1, 2, 3], [3, 4, 5], [6, 7, 8]], {'name': 'Alex'}]
    2. list[2][1][0] = 1111
    3. # 或者list[2][1][0] = list[2][1][0] + 1098
    4. print(list)
    5. [[1, 2], ['测试', '程序'], [[1, 2, 3], [1111, 4, 5], [6, 7, 8]], {'name': 'Alex'}]
    6. # 多层嵌套使用

  • 其他的操作

    1. '''查询元素出现的次数，和字符串用法一致'''
    2. count = list[1].count('测试')
    3. print(count)
    4. '''列表排序'''
    5. list = [0, 20, 33, 1, 44, -1]
    6. list.sort()
    7. print(list)
    8. [-1, 0, 1, 20, 33, 44]
    9. # sort排序方式默认是升序排序
    10. list.reverse()
    11. print(list)
    12. [44, 33, 20, 1, 0, -1]
    13. # reverse()默认为降序排序
    14. list.sort(reverse=True)
    15. print(list)
    16. [44, 33, 20, 1, 0, -1]
    17. # 或者还继续红sort,但是添加元素reverse=True来进行降序排列

元组(不可变的列表)

  • 基本用法：小括号包裹，如果只有一个元素，后边必须加上逗号

    1. tuple = (3,)
    2. print(tuple)
    3. (3,)
    4. tu = ()
    5. type(tu)
    6. <type 'tuple'>
    7. # 空元组

  • 元组不支持任何修改，只能读取元素

    1. tuple[0]
    2. 3
    3. for i in tu:
    4.   print(i) 
    5. 1、2、3、4、55
    6. # 索引和列表中的使用方法完全一样
    7. tuple[0] = 34
    8. Traceback (most recent call last):
    9. File "<stdin>", line 1, in <module>
    10. TypeError: 'tuple' object does not support item assignment
    11. tuple.append(2333)
    12. Traceback (most recent call last):
    13. File "<stdin>", line 1, in <module>
    14. AttributeError: 'tuple' object has no attribute 'append'
    15. del tuple[0]
    16. Traceback (most recent call last):
    17. File "<stdin>", line 1, in <module>
    18. TypeError: 'tuple' object doesn't support item deletion

  • 虽然元组是不可变的，但是如果元素中有可变元素如列表，那么可变元素中的元素是可以修改的，但可变元素本身不能变

    1. tuple = (1, '23', '这是字符串', [])
    2. print(tuple)
    3. tuple[3].append(1)
    4. print(tuple)
    5. tuple[3].insert(2, 3)
    6. print(tuple)
    7. # 结果是：
    8. (1, '23', '这是字符串', [])
    9. (1, '23', '这是字符串', [1])
    10. (1, '23', '这是字符串', [1, 3])

range()用法

  • range()是一个可迭代的对象
  • range(m, n), 遍历的结果下标是从m到n-1
  • range(m, n, y) y表示的是步伐 ```python for i in range(0, len(tu), 2): print(tu[i], end=’、’) 1、3、4、5、6

tu = [1,2,3,3,4,5,5,6,6] for i in range(len(tu)-1, 0, -2): print(tu[i]) 6 5 4 3

注意反向遍历的时候，左侧索引值必须-1， 步伐必须是负数

```

Note 切片操作的到的对象类型和原对象类型一致， 切片不会改变对象类型