python把缓存区数据写入硬盘 python将数据存在内存

文章目录

• 一、补充知识点

• 1.1 进制
• 1.2 队列 和 堆栈 都是存值取值的
• 1.3 占位符

• 二、基本数据类型及内置方法

• 2.1 数字
• 2.2 字符串
• 2.3 列表 list
• 2.3 元组 tuple （就是“不可变的列表”)
• 2.4 字典 dict
• 2.5 集合

• 三、数据类型总结和分类

• 3.1 有序和无序
• 3.1 存一个值or多个值
• 3.1 可变or不可变

一、补充知识点

1.1 进制

• 名字（参数）：触发一个功能的运行，工厂，会有返回，也可以无返回
• 进制转换（十进制–》二进制）：bin(10) # 0b1010 十进制转化为二进制， 0b开头是二进制
• 进制转换（十进制–》八进制）：oct(10) # 0o13 十进制转化为八进制， 0o开头是八进制
• 进制转换（十进制–》十六进制）：hex(10) # 0x1010 十进制转化为十六进制， 0x开头是十六进制
• 其他进制转化为十进制：全部用int

1.2 队列 和 堆栈 都是存值取值的

• 队列 FIFO 先进先出
• 堆栈 LIFO 后进先出

1.3 占位符

• pass 占位符 什么都不做
• …： python3新功能和pass一样

二、基本数据类型及内置方法

2.1 数字

• int 类型
    定义： age = 10 # age = int(10)
    类型转换： 纯数字的字符串可以转换成int
• float类型
    定义： age = 10 # age = float(10)
    类型转换： 小数的字符串可以转换成float

使用： 没有需要掌握的内置方法

2.2 字符串

• 定义： msg = ‘hello’ # msg = str(‘hello’)
• 类型转换：可以把任意类型转化为字符串
• 按索引取值 只能取 不能赋值

msg = 'hello world'
# 正向取
print(msg[3])
# 反向取
print(msg[-1])
# 切片 ： 从一个大的字符串中拷贝出一个子字符串， 顾头不顾尾
print(msg[0:5:2]) # 开始， 结尾， 步长 0 2 4
# 反向步长
print(msg[5:0:-1]) # 5 4 3 2 1
# 完整拷贝一份
res=msg[:]#res=msg[0:len(msg)+1]
# 倒着拷贝一份
res=msg[::-1]

• 成员运算in 和 not in： 判断一个字符串是否存在于一个大字符串中

print("alex"in "alex is name")
print("alex"not in "alex is name")

• 移除空白strip

# 默认去掉的是空格
msg = '   egon   '
res = msg.strip()# 默认去掉的空格
print(res)# 是产生了新值
# 也可以去掉其他
msg = '****egon****'
res = msg.strip('*')
# 只会去掉两边不会去掉中间
# 也可以去掉多个
msg = '**/*=一**egon**-=（）**'
print(msg.strip('*/-=()'))

• 切分split 默认按照空格分割 将字符串切分成列表

info = 'name:zpp,age:18'
info.split(':', 1) # 分隔符、分割次数

• 循环

info = 'name:zpp,age:18'
for i in info:
	print(i)

• strip、lstrip、rstrip
    strip：去左右   lstrip：去左边   rstrip：去右边
• lower、upper
    .lower：小写  .upper：大写
• startswith、endwith
    .startswith：是否以什么开头  .endwith：是否以什么结尾
• split、rsplit
    rsplit：从右往左切
• join ： 将列表拼接成字符串，按照某个分隔符，将全为字符串的列表拼接成字符串":".join(msg)  
• replace

msg = "you can you up no can no bb'
print(msg.replace("you", "YoU" ,2))# 原值 替换值 替换次数

• isdigit ： 判断字符串是否由纯数字组成

print('123'.isdigit()) # 可以
print('12.3'.isdigit()) # 不可以

• find、rfind、index、rindex、count

msg = 'hello zpp hahaha'
# find 
msg.find('e') # 1 返回要查中的字符串在大字字符串中的起始索引
msg.find('zpp') # 6 
# index
msg.index('e') # 1 返回要查中的字符串在大字字符串中的起始索引
msg.index('zpp') # 6 
# 区别是find找不到返回-1， index找不到抛出异常 报错
# count 统计个数
msg.count('a') # 3

• center、ljust、rjust、zfill

# center 居中显示
print('zpp'.center(50,'*'))
# ljust 字符串左边显示
print('zpp'.ljust(50,'*'))
# rjust字符串右边显示
print('zpp'.rjust(50,'*'))
# zfill 左边填充   默认填充的是0
print('zpp'.zfill (10))

• expandtabs 指定制表符的宽度

msgs'heLlo\tworld'
print(msg.expandtabs(2))

• captalize、swapcase、title

# captalize 首字母大写
# swapcase 大小写互换
# title 每个单词的首字母大写

• is系列

islower() 是否为小写
isupper() 是否为大写
istitle() 是否为标题si
isalnum() 是否为字母或数字组成
isalpha() 是否为字母组成
isspace() 是否是空格
isidentifier() 名字是否合法 python内置的和自己设置的
isdigit() 不能识别汉字的四和罗马数字
isnumberic() 不能识别罗马数字

2.3 列表 list

• 作用
    按位置存放多个值
• 定义
    l = [1，2，’a‘] # l = list[1，2，’a‘]
• 类型转换:
    但凡能被for循环遍历的类型都可以当作参数传给list()转成列表如：字符串、字典
• 按照索引取值
    正想取： l[0]
    反向取： l[-1]
    可以取也可以改：l[0] = 3  索引不存在就会报错
• 切片 切片等同于拷贝行为 相当于浅拷贝

l = [0,1,2,3,'a','b']
l[0:4:2] # 开头 结束 步长

• 长度 ：len()
• 成员运算in 和 not in

print("alex" in ["alex", "is", "name"])
print("alex" in ["alex", "is", "name"])

• 追加、插入、删除

l = [1, 2, 'a'] 
# 追加1 append
l.append(333)
# 追加2 extend
l.extend([1,2,3])
# 插入
l.insert(1, 6)

• 删除

l = [1, 2, 'a'] 
# 删除一 del通用的删除方法 没有返回值
del l[0]
# 删除二 pop 根据索引删除  默认删除最后一个  有返回值,返回删除的值
res = l.pop(1)
# 删除三 l.remove() 根据元素删 返回None
l.remove(2)

• count、index、clear、reverse、sort

l.count('1') 计数
l.index('a') 第一个找到的索引 找不到报错
l.clear() 清空整个列表
l.reverse() 直接改原列表   将列表倒过来
l.sort()  默认升序  reverse = False降序  只能是列表内元素必须是同种类型 字母是按照ASCI码表的先后顺序字符的大小
# 字符串可以比大小，按照对应的位置的字符依次pk
# 字符串的大小是按照A5C码表的先后顺序加以区别，表中排在后面的字符大于前面的

2.3 元组 tuple （就是“不可变的列表”)

  元组不能改指的是元组的内存地址不能改

• 作用
    按位置存放多个值、只用于读不用于改
• 定义 （）内用逗号分隔开多个任意类型的元素
    t = (1，2，’a‘) # t = tuple(1，2，’a‘)
    如果元组中只有一个元素，必须加逗号 t = (10,)
    t=（1，1.3, ‘aaa’）# t=（0->值1的内存地址，1->值1.3的内存地址，1->值’aaa’的内存地址）
• 应用场景
    当我有多个值且日后只有读的需求
• 
  

2.4 字典 dict

• 作用
• 定义： {}内用逗号分隔开多个key：value， 其中value可以是任意类型， 但是key必须是不可变类型,且不能重复
    d = {‘k1’: 111, (1, 2): 222} 或者 d = dict(x=1, y = 2, z = 3) # d = dict(‘k1’: 111, (1, 2): 222)
• 生成字典的方式
    d = {‘k1’: 111, (1, 2): 222}
    d = dict(x=1, y = 2, z = 3)

# 生成字典
d = {'k1': 111,  (1, 2): 222} 
d = dict(x=1, y = 2, z = 3) 
# 已知key生成字典  快速初始化一个字典
keys = ['name', 'age', 'gender']
d = {}.fromkeys(keys, None)

• 按key存取值： 可存可取

d = {'k1':111}
# 针对赋值操作： key存在，则修改
d['k1'] = 222
# 针对赋值操作： key不存在，则创建新值 
d['k2'] = 333

• 长度len；
• 成员运算 in 和 not in ： 根据key
• 删除

# 删除def
del d['k1']
del d
# 删除 pop 根据key删除 会返回删除的对应的value
d.pop('k2')
# 删除 popitem 随机删除 返回一个元组（删除的key，删除的value）
d.popitem()

• 键keys()、值value()、键值对items() ==>在python3中全部变成老母鸡（可迭代对象）

d.keys()
d.value()
d.items() # [('k1':111), (k2:222)]
# 用for循环让鸡下蛋
for k,v in d.items()
	print(k, v)
# 全部变成蛋 list()
list(d.keys())

• clear、get、 setdefault、update

d = {'k1': 111}
d.get('k5') # 对于d['k5']这种取值方式 key不存在就会报错  key不存在不报错， 返回None, 也可固定返回某值 
d.setdefault('k1', 222) # 如果key不存在添加， 如果key存在不做任何操作 返回字典中key对应的值
d.clear() # 清空字典
老字典.update(新字典) # 老字典追加到新字典中

2.5 集合

• 定义

• 在{}内用逗号分隔开多个元素，多个元素满足以下三个条件：
      1.集合内元素必须为不可变类型
      2.集合内元素无序
      3.集合内元素没有重复
• s = {1, 2} # s = set({1, 2}) s = {} 默认是空字典， 空集合是s = set()

• 关系运算： 取交集、取并集（合集）、取差集、对称差集、父子集

student1 = {'ee', 'aa', 'pp', 'll'}
student2 = {'kk', 'uu', 'pp', 'll'}
# 取交集
res = student1 & student2 # {'pp', 'll'}
res = student1.intersection(student2) # {'pp', 'll'}
# 取并集
res = student1 | student2 # {'ee', 'aa', 'pp', 'll', 'kk', 'uu'}
res = student1.union(student2) # {'ee', 'aa', 'pp', 'll', 'kk', 'uu'}
# 差集 取student1 独有的
res = student1 - student2 # {'ee', 'aa'}
res = student1.difference(student2) # {'ee', 'aa'}
# 差集 取student2 独有的
res = student2 - student1 # {'kk', 'uu'}
# 取两者独有的元素（去掉相同的元素）
res = student2 ^ student1 # {'ee', 'aa', 'kk', 'uu'}
res = student1.symmetric_difference(student2) # {'ee', 'aa', 'kk', 'uu'}
# 包含的关系
s1 = {1, 2, 3, 4}
s2 = {3, 1}
# 大于
s1 > s2 # True
s1.issuperset(s2)
# 小于
s1 < s2 # True
s1.issubset(s2)

• 去重（有局限性）

  1、只能针对不可变类型去重
  2、无法保证原来的顺序

• discard、、、、

# 删除
discard(2) # 在原来的集合上删除，存在删除、不存在不报错
remove(4) # 删除元素不存在报错
# 更新
update({1，3}) # 先加  后去重
add(5) # 添加元素
# 是否独立
isdisjoint() # 如果两个集合是独立的返回True

三、数据类型总结和分类

3.1 有序和无序

  有序又称为序列类型

• 有序： 索引能代表顺序： 字符串、列表、元组
• 无序：索引不能代表顺序： 字典（映射类型）

3.1 存一个值or多个值

• 标量/原子类型：只能存一个值的： 数字、字符串
• 容器类型： 存多个值： 列表、元组、字典

3.1 可变or不可变

• 可变类型：字典、列表、集合
• 不可变类型： 数字、字符串、元组