【python基本数据类型的内置方法（2）】

python基本数据类型的内置方法

上一次我们学了整型，浮点型的内置方法，今天我们继续学习剩下的基本类型的内置方法。

字符串（str）

1. 移除字符中首尾的指定的字符（strip，lstrip,rstrip）

s = '   bana    '
print(s.strip())  # 去除首尾的空格
s1 = '$$$bana$$$'
print(s1.strip('$'))  # 去除首尾的'$'
print(s1.lstrip('$'))  # 去除左边的的符号'$'
print(s1.rstrip('$'))  # 去除右边的的符号'$'

2. 大小写相关的操作(lower，upper，islower，isupper)

s = 'abDEc123'
print(s.lower())  # 把字母全部转换成小写
print(s.upper())  # 吧字母全部转换成大写
print(s.islower())  # 判断是否都为小写  返回值是布尔值
print(s.isupper())  # 判断是否都为大写  返回值是布尔值

3. 判断字符串中的开头或者结尾是否是指定的字符。（startswith）

s = 'abDEc123'
print(s.startswith('a'))  # 判断字符串的开头是否为'a' 返回值是布尔值 为true
print(s.endswith('z'))  #判断字符串的结尾是否为'z' 返回值是布尔值 为false

4. 格式化输出（format）

print('my name is %s my age is %d' % ('bana', 22))  # 站位符 %s % d
print('my name is {} my age is {}'.format('bana', 12))  # 和占位符一样 用{}来占位
print('{1} my name is {0} my age is {1}'.format('bana', 12))  # 利用索引取值 可以有重复多个
print('{name} my name is {name} my age is {age}'.format(name='bana', age=12))  # 根据具体的变量名来取值 也是可以有多个
name = 'bana'
age = 12
print(f'{name} my name is {name} my age is {age}')  # 直接使用已经出现过的变量 也是可以有多个

5. 拼接字符串（join）

s1 = '三月不努力 四月变垃圾'
s2 = '年少不努力 妄为少年人'
print(s1 + s2)  # 如果字符串很大 加号效率较低
print(s1 * 10)  # 重复次数
print('|'.join(s1))  # 三|月|不|努|力| |四|月|变|垃|圾
print('$'.join(['jason', 'kevin', 'justin', 'tony']))  # jason$kevin$justin$tony

6. 替换字符中指定的字符（replace）

s = '哈哈哈哈嘿哈嘿哈嘿哈嘿'
print(s.replace('哈', '嘿'))  # 默认一次性替换所有指定替换的个数
print(s.replace('哈', '嘿', 2))  # 还可以通过数字控制替换的个数 从左往右

7. 判断字符串中是否尾纯数字（isdigit）

s = '1235mkj'
print(s.isdigit())  # 返回的是布尔值 false
print('120.3'.isdigit())  # 返回的是布尔值 false
print('[1,2,3]'.isdigit())  # 返回的是布尔值 false
print('123'.isdigit())  # 返回的是布尔值  true

8. 其他

# 1.查找指定字符对应的索引值
# s1 = 'jason justin kevin tony'
# print(s1.find('s'))  # 从左往右查找 查找一个就结束
# print(s1.find('k', 1, 9))  # -1 意思是没有 找不到
# print(s1.index('s'))
# print(s1.index('k', 1, 9))  # 找不到直接报错 不推荐使用

# 2.文本位置改变
 name = 'tony'
print(name.center(30, '-'))  # -------------tony-------------
print(name.ljust(30, '*'))  # tony**************************
print(name.rjust(30, '$'))  # $$$$$$$$$$$$$$$$$$$$$$$$$$tony
print(name.zfill(50))  # zero 零  0000000000000000000000000000000000000000000000tony

# 3.特殊符号:斜杠与一些英文字母的组合会产生特殊的含义
print('ja\tson\nke\avin')
'''如果想取消它们的特殊含义 可以在字符串的前面加一个字母r'''
print(r'ja\tson\nke\avin')

# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
message = 'hello everyone nice to meet you!'
message.capitalize()
# Hello everyone nice to meet you!
# 4.2 swapcase：大小写翻转
message1 = 'Hi girl, I want make friends with you!'
message1.swapcase()
# hI GIRL, i WANT MAKE FRIENDS WITH YOU!
#4.3 title：每个单词的首字母大写
msg = 'dear my friend i miss you very much'
msg.title()
# Dear My Friend I Miss You Very Much

列表（list）

1. 类型转换
   除了整型和浮点型，其他基本的数据类型都可以进行类型转换

    print(list(11))  # z整型不行
    print(list(11.11))  # 浮点型不行
    print(list('jason'))  # ['j', 'a', 's', 'o', 'n']
    print(list({'name': 'jason', 'pwd': 123}))  # ['name', 'pwd']
    print(list((11,22,33,44,55)))  # [11, 22, 33, 44, 55]
    print(list({1, 2, 3, 4, 5}))  # [1, 2, 3, 4, 5]
    print(list(True))

2. 索引取值

name_list = ['jason', 'kevin', 'tony', 'tom', 'jerry']
print(name_list[0])
print(name_list[2])

3. 切片操作

# 2.切片操作
print(name_list[1:4])  # ['kevin', 'tony', 'tom']
print(name_list[-4:-1])  # ['kevin', 'tony', 'tom']
print(name_list[-1:-4:-1])  # ['jerry', 'tom', 'tony']

4. 间隔操作

# 间隔
print(name_list[0:4:1])  # ['jason', 'kevin', 'tony', 'tom']
print(name_list[0:4:2])  # ['jason', 'tony']
print(name_list[-1:-4:-1])  # ['jerry', 'tom', 'tony']

5. 统计列表中元素的个数（len）

# 统计列表中元素的个数
print(len(name_list))  # 5

6. 成员运算

# 5.成员运算 最小判断单位是元素不是元素里面的单个字符
print('j' in name_list)  # False
print('jason' in name_list)  # True

1. 添加元素

# 列表添加元素的方式
# 尾部追加'单个'元素
name_list.append('小李')
print(name_list)
name_list.append([11, 22, 33, 44])
print(name_list)
# 6.2.指定位置插入'单个'元素
name_list.insert(0, 123)
name_list.insert(2, '可不可以插个队')
name_list.insert(1, [11, 22, 33])
print(name_list)
# 合并列表
name_list.extend([11, 22, 33, 44, 55])
print(name_list)
'''extend其实可以看成是for循环+append'''
for i in [11, 22, 33, 44, 55]:
    name_list.append(i)
print(name_list)
name_list += [11, 22, 33, 44, 55]
print(name_list)  # 加号的效率不高

2. 删除元素（del，remove，pop，）

# 7.1 通用的删除方式
del name_list[0]
print(name_list)
# 7.2 就地删除  # 指名道姓的直接删除某个元素
print(name_list.remove('jerry'))  # None
print(name_list)
# 7.3 延迟删除
print(name_list.pop())  # 默认是尾部弹出    jerry
print(name_list)
print(name_list.pop(2))  # 还可以指定索引值   tony
print(name_list)

3. List item
4. 修改列表元素（）

print(id(name_list[0]))  # 2614038082368
name_list[0] = 'jasonDSB'
print(id(name_list[0]))  # 2614038926320
print(name_list)

5. 排序（sort）

ss = [44, 77, 99, 11, 22, 33, 88, 66]
ss.sort()  # 默认是升序
print(ss)  # [11, 22, 33, 44, 66, 77, 88, 99]
ss.sort(reverse=True)  # 可以修改尾降序
print(ss)  # [99, 88, 77, 66, 44, 33, 22, 11]

6. 翻转（reverse）

ss = [44, 77, 99, 11, 22, 33, 88, 66]
ss.reverse()  # 前后颠倒
print(ss)

7. 比较运算

s1 = [11, 22, 33]
s2 = [1, 2, 3, 4, 5, 6, 7, 8]
print(s1 > s2)  # True
"""列表在做比较的时候 其实比的是对应索引位置上的元素"""
s1 = ['A', 'B', 'C']  # A>>>65
s2 = ['a']  # a>>>97
print(s1 > s2)  # False
ss = [44, 77, 99, 11, 22, 33, 88, 66]
print(ss.index(99))

8. 统计列表中某个元素出现的次数（count）

l1 = [11, 22, 33, 44, 33, 22, 11, 22, 11, 22, 33, 22, 33, 44, 55, 44, 33]
print(l1.count(11))  # 统计元素11出现的次数
l1.clear()  # 清空列表
print(l1)

可变类型与不可变类型

可变类型 列表
值改变 内存地址不变 修改的是本身
不可变类型 字符串
值改变 内存地址肯定遍 修改过程产生了新的值
如何查看变量的’内存地址’ 用id 查看
总结：可变数据类型更改值后，内存地址不发生改变。
不可变数据类型更改值后，内存地址发生改变

数据类型	可变/不可变
整型	不可变
字符串	不可变
列表	可变
字典	可变
元祖	可变
集合	可变

队列与堆栈

队列：遵循先进先出

堆栈：遵循先进后出