2.基础数据类型
目录
一、字符串
# 按索引取值
s[0]
# 切片
# 格式：s[开始位置: 结束位置: 步长]
# 包括开始位置，但是不包括结束位置，步长为取值间隔，如：str[2:9:2],则从第3个字符取到第8个字符，间隔为2，取得是索引是2，4，6，8上得数
# 全取
# s[:]
# 倒序,不加反向步长不报错
s[:-6:-1]
s[-1:-2:-1]
# 按索引 s[index]
# 按切片 s[start_index:end_index+1]
# 按步长 s[start_index:end_index+1:步长]
# 反向按照切片步长 s[start_index:edn_index后延一位:2]
常用方法
upper() 全大写
lower() 全小写
s.isalpha() 字符串是否只由字母组成
s.isalnum() 字符串是否只由字母或者数字组成
s.isdecimal 字符串是否只由十进制组成
s.startswith('s') 字符串是否以字母s开头
s.endswith('s') 字符串是否以字母s结尾
s.replace('is', 'this', 3) # 格式：s9.replace(old, new, max) max可选，替换不超过的次数
字符分割
split() 字符串分割，str-->list ，默认去除两边得空格，换行，制表符
# 字符串得分割，返回一个列表
s.slipt('+') # 按照+分割
s.slipt(':', 2) # 以:分割，并分割两次，
字符串拼接
# 字符串拼接，返回一个字符串
s1 = 'abc'
s2 = '+'.join(s1) # 以+号拼接，传入的s1中的元素必须是str
# s2='a+b+c'
格式化输出
# format格式化输出
# msg = '我叫{}今年{}性别{}'.format('an',25,'男')
msg = '我叫{0}今年{1}性别{2}'.format('an',25,'男') # 常用，0，1，2为索引
# msg = '我叫{name}今年{age}性别{sex}'.format(name='an',age=25,sex='男')
# 其他
# name = 'an'
# age = 3
# sex = '男'
# msg = f'我叫{name}今年{age}性别{sex}'
二、列表
索引查看
-
li[1]
-
li[-1]
常用方法
与字符串常用方法类似
- upper lower
- startswith endswith
- split 分割：str---->list
- 默认按照空格。
- 可以指定分隔符。
- strip：默认去除字符串两边的空格，换行符，制表符。
- isdecimal isalpha isalnum
- format 格式化输出
- count某个元素出现的次数
- join 连接
- replace
- len() 获取数据的元素个数。
列表的索引切片
- li[:3]
- li[:5:2]
- li[-1: -4:-1]
列表的增删改查
##### 列表的创建
# 方式一
li = [1, 2, 'an']
# 方式二
li = list()
li = list('asdfghjkl')
# 方式三：列表推导式
##### 增
li.append() # 在列表的最后追加元素，这是个操作，不能print
# insert 插入
li.insert(2, 'str') # 在索引为2处插入字符串str
# extend 迭代着追加
s = 'asdfghjkl'
# 直接在最后面插入s
li.extend([s])
li.extend(s) # 依次append a,s,d,f...
li.extends([1, 2, 3]) # 依次append 1,2,3
##### 删 常用pop，remove，del
# 按索引删除，返回删除的值
li.pop(-2)
# 删除指定元素，从左至右第一个
li.remove('q')
# 清空
li.clear()
# 按索引删除
del li[-1]
# 按照切片删除
del li[::2]
##### 改，迭代形式，加步长的话要一一对应
# 按照索引改值
li[1] = ''
# 按照切片改值，迭代
li[1:] = 'asdfg'
# 按照切片(步长改值),迭代
li[::2] = 'abc'
列表嵌套
li = [1, 2,'12', [4,'87',76]]
三、元组
tuple只能读，没有增删改,但是元组中嵌套的可变数据类型的元素可以增删改
tu = (1,2,3,'an',[5,6,7,8],True)
# 读
print(tu(1))
# tuple中可变数据类型的元素可以改
tu[-1].append('sb')
元组应用：拆包
a , b , c = (1, 2, 3) 必须一一对应，不能多也不能少
四、字典
字典初始
- 键必须是不可变的数据类型int str（bool和tuple几本不用），键是唯一的，
- 值可以任意的数据类型、对象
- 字典在3.6会按照初始的顺序排列，3.7以后都是有序的
- 字典的查询速度非常快，但是比列表占用的空间大
字典创建
# 方式一
dic = dict((('an', 11), ('bn', 22), ('cn', 33)))
# 方式二
dic = dict(an=11) # dic={'an':1}
# 方式三
dic = dict('an':11, 'bn':22, 'cn':33)
字典的增删改查
dic = {'name':'an', 'age':11, 'hobby_lsit':['玩','看视频']}
##### 增，有则改之，无则增加
dic['sex'] = '男'
# setdefault 有则不变，无则增加
dic.setdafault('bobby')
dic.setdafault('bobby', '打球')
##### 删
# pop按照键删除键值对，返回被删除的键对应的值
# dic.pop('name')
# pop传入第二个参数，若没有此键，则返回第二个参数对应的值
# dic.pop('hobby', '没有此键')
# clear 清空
dic.clear()
# del
del dic['name']
##### 改
dic['name'] = 'cn'
##### 查
print(dic['name'])
# get
dic.get('name')
# 设置返回值
dic.get('name','没有此键')
三个特殊的
# 三个特殊方法,返回值都是特殊的类型
# items（）方法返回字典的键值对
# keys（）方法返回字典的键
# values（）方法返回字典的值
# 可以转化成列表
# print(list(dic.keys()))
# for key in dic.keys():
# print(key)
# for key in dic:
# print(key)
# values()
# print(dic.values())
# print(list(dic.values()))
# for value in dic.values():
# print(value)
# items()
# print(dic.items())
# 拆包，key和value都是str类型
# for key,value in dic.items():
# print(key,value)
# a,b = ('name', 'an')
# print(a,b)
字典嵌套
字典可以设置为字典的值
五、集合
集合特点
集合中的元素不能重复，自动去重，集合的输出结果是无序排列的
集合的增删改
# 增
set1.add('xx')
# 迭代增加
set1.update('asdg')
# 删
# remove() 按照元素删除
# pop 随机删除
# 交集 &
# 并集 |
# 差集 -
# 应用：列表的去重
# 先使用set(li)转化为集合，在转化为列表，但是这么做会打乱列表中元素的顺序
六、基础数据类型的补充
str补充：
# capitalize() 首字母大写,其余变小写
# swapcase() 大小写反转
# title() 每个单词的首字母大写
# center() 居中
# s1.center(20, '*') # 长度20，*号填充
# find()
# index()
tuple:
# tuple
# t1 = (1) # te类型为int型，加逗号才是元组
# count 计数， 打印元素出现次数
list:循环列表时最好不要改变列表的大小
# ###########list
# 打印
# index() 打印元素的索引
# count() 计数，元素出现次数
# sort() 排序，字符串按照首字母的asccl码排序,默认从小到大
# sort(revers=True) # 默认从大到小
# reverse() 反转
# l1 + l2 相加, 元素直接合并
# 列表和数字相乘
# l1 = ['abc', '123', '好']
# print(l1.count('123'))
######### 列表的特性
l1 = [11, 22, 33, 44, 55]
# 删除奇数索引的值，删除一个元素，后面元素会往前移一位
# 按照切片删除
# del l1[1::2]
# 倒叙法删除
# for index in range(len(l1)-1, -1, -1):
# print(index)
# if index % 2 == 1:
# l1.pop(index)
# print(l1)
# 思维置换
# l1 = [11, 22, 33, 44, 55]
# new_l1 = []
# for index in range(len(l1)):
# if index % 2 ==0:
# new_l1.append(l1[index])
# # print(new_l1)
# l1 = new_l1
# print(l1)
dict补充：
# update()方法
dic = {'name': 'an', 'age':11}
# 无则添加
dic.update(hobby='运动',hight=180)
# 有则修改
dic.update(name = 'bn')
# 元组拆包
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
# 传入字典，有则覆盖,无则添加
dic1 = {'name':'cn','sex':'男'}
dic.update(dic1)
# fromkeys,创建的字典对象公用一个值
# 第一个参数为可迭代对象(字典的键)，第二个参数为值
dic = dict.fromkeys('abc', 1)
# 若第二个参数为可迭代对象，则和第一个参数的可迭代对象一一匹配，多余的则舍弃，如下的fgh则会舍弃
dic = dict.fromkeys([1, 2, 3], 'asdfgh')
# 坑：值共有一个，注意是共有
dic = dict.fromkeys([1,2,3],[])
dic[1].append(666)
print(dic) # dic = {1: [666], 2: [666], 3: [666]}
dic[1][0] = 111
print(dic) # dic = {1: [111], 2: [111], 3: [111]}
七、深浅copy
浅copy：copy.copy()
深copy：copy.deepcopy()
浅copy：可变数据类型和不可变数据类型都沿用之前的
深copy：将一份可变的数据类型copy一份（id不同，如下面的小列表），不可变数据类型沿用之前的
import copy
l1 = [1,2,3,[33,44]]
l2 = copy.deepcopy(l1)
print(l2)
# l1和l2中小列表是可变的数据类型，直接复制了一份，因此id不同
print(id(l1[-1]))
print(id(l2[-1]))
# l1和l2中1，2，3都是不可变的数据类型，所以没有复制，沿用之前的，因此id相同
print(id(l1[1]))
print(id(l2[1]))
八、代码块与缓存机制
代码块
- 代码块：我们所有的代码都需要依赖代码块执行。
- 一个文件就是一个代码块。
- 交互式命令下一行就是一个代码块。
同一代码块下的缓存机制
- 前提条件：同一个代码块内。
- 机制内容：pass
- 适用的对象： int bool str
- 具体细则：所有的数字，bool，几乎所有的字符串。
- 优点：提升性能，节省内存。
不同代码块下的缓存机制（小数据池）
- 前提条件：不同代码块内。
- 机制内容：pass
- 适用的对象： int bool str
- 具体细则：数字的范围-5~256，bool，满足规则的字符串。
- 优点：提升性能，节省内存。
