python常用数据类型操作
字典
字典数据类型,无序的可变的键值对的集合
- 定义
key不能被重复,必须是任意不可变类型,一个key对应一个索引值
可变包括:列表、字典、可变集合
不可变包括:数值、布尔、字符串、元组
# 表述一个人的信息
# 字符串
str1 = "sz,18,180"
infos = str1.split(",")
print(infos)
# 列表
l = ["sz", "18", "180"]
print(l[0])
print(l[1])
print(l[2])
# 元组
t = ("sz", "18", "180")
print(t[0])
print(t[1])
print(t[2])
# 定义方式一
person = {"name": "yl", "age": 18, "height": 180}
print(person, type(person)) # {'age': 18, 'name': 'yl', 'height': 180} <class 'dict'>
print(person["name"])
# 定义方式二
# 静态方法 类和对象都可以调用
d = dict.fromkeys("abc", 666)
print(d) # {'b': 666, 'a': 666, 'c': 666}
# 定义注意:key不能被重复,必须是任意不可变类型,一个key对应一个索引值
# 可变包括:列表、字典、可变集合
# 不可变包括:数值、布尔、字符串、元组
d = {"a": 1, "b": 2, "a": 3} # 如果重复,后值会把前面的值覆盖
print(d) # {'b': 2, 'a': 3}
num = 10
print(id(num))
num = 20
print(id(num)) # id不一样代表两块不同的内存,num不可变
num = [1, 2, 4]
print(num, id(num))
num.append(67)
print(num, id(num)) # 可变的值,内存不变,值对应可以改变
# python字典采用hash方式实现
# 字典存在意义,使得访问具备意义、查询效率有很大提升
简单的存储过程:初始化一个表格(hash表),用来存放所有的值 在存储一个键值对的时候,根据给定的key,通过某些操作得到一个索引位置,根据索引位置存储给定的值
简单查找过程:使用hash函数将key转换为对应列表的索引,定位到列表的位置value
- 存在意义
可以通过key,访问对应的值,使得访问更具意义
查询效率得到很大提升 - 常用操作
# 常用操作
# 增加 dic[key] = value
d = {"a": 1, "b": 2, "a": 3}
print(d, id(d))
d["age"] = 18
print(d, id(d)) # id一样
# 删除操作
# 方式一
d = {"a": 1, "b": 2, "a": 3}
del d["a"]
print(d)
# 方式二
# dic.pop(key,default)
# 删除指定的键值对,返回对应的值
# 如果key不存在,就返回给定的default值
d = {"name": "yl", "age": 18, "height": 180}
v = d.pop("age")
print(v, d) # v返回对应age值 18 {'name': 'yl', 'height': 180}
v = d.pop("age1", 55555)
print(v, d) # v返回对应age值 55555 {'name': 'yl', 'height': 180}
# dic.popitem()
# 删除按照升序的第一个键值对,以元组的形式返回该键值对
# 如果字典为空,会报错
d = {"name": "yl", "age": 18, "height": 180}
v = d.popitem() # ('age', 18)
print(v, d) # ('age', 18) {'name': 'yl', 'height': 180}
# dic.clear()
# 删除字典所有键值对
# 字典对象本身还存在,内容被清空了
d = {"name": "yl", "age": 18, "height": 180}
v = d.clear()
print(v) # del删除所有东西 none
# 字典修改,只能修改值,不能改key
# 修改单个
d = {"name": "yl", "age": 18, "height": 180}
d["age"] = 30
d["sex"] = "女"
print(d)
# 批量修改键值对
# oldDic.update(newDic)
# 根据新的字典批量更新旧字典键值对
# 如果旧字典没有对应的key,则增加
d = {"name": "yl", "age": 18, "height": 180}
d.update({"age": 99, "address": "shanghai"})
print(d) # {'age': 30, 'sex': '女', 'name': 'yl', 'height': 180}
# 查询操作
# 方式一
d = {"name": "yl", "age": 18, "height": 180}
print(d["age"])
# 方式二
# dic.get(key[,default])
# 如果不存给定的key,取default
# 没有默认值,不会报错,也不会增加
d = {"name": "yl", "age": 18, "height": 180}
v = d.get("name")
print(v)
v = d.get("name1")
print(v)
# 方式三
# dic.setdefault(key[,default])
# 如果key不存d在,则设定默认d值,增加键值对,value为None
d = {"name": "yl", "age": 18, "height": 180}
v = d.setdefault("name")
print(v)
v = d.setdefault("name1")
print(d)
# 获取所有的值 dic.values()
# 获取所有的键 dic.keys()
# 获取字典的键值对 dic.items()
print(d.values()) # dict_values([18, None, 'yl', 180])
print(d.keys()) # dict_keys(['age', 'name1', 'name', 'height'])
print(d.items()) # dict_items([('age', 18), ('name1', None), ('name', 'yl'), ('height', 180)])
# 遍历操作
# 先遍历所有的key
d = {"name": "yl", "age": 18, "height": 180, "address": "hefei"}
keys = d.keys()
for key in keys:
print(key)
print(d[key])
# 直接遍历所有键值对
kvs = d.items() # dict_items([('age', 18), ('address', 'hefei'), ('name', 'yl'), ('height', 180)])
print(kvs) # 列表里面是元组
for k, v in kvs:
print(k, v) # 元组解包
# 元组计算 len(info)
# 键值对个数
print(len(d))
# 判定操作
# 判定key,是否存在在字典
print("name" in d)
print(18 in d) # false
集合
无序的不可随机访问的不可重复的
# 无序的不可随机访问的不可重复的
s = {1, 5, 89}
# 交、并、差、补
# 分为可变集合和非可变集合
# set 可变 增删改
# frozenset 不可变集合
print(s, type(s)) # {89, 1, 5} <class 'set'>
# 方法二
s1 = set("dbah")
print(s1, type(s1)) # {'h', 'd', 'b', 'a'} <class 'set'>
# 集合推导式
s = set(x for x in range(0, 10))
print(s, type(s)) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
# 不可变集合
# fs = frozenset(iterable) 字符串、列表、元组、字典
# 为dic时,只会获取key作为set的值
fs = frozenset("asd")
print(fs, type(fs)) # frozenset({'s', 'd', 'a'}) <class 'frozenset'>
fs = frozenset([1, 4, 3])
print(fs, type(fs))
fs = frozenset((1, 4, 3))
print(fs, type(fs))
fs = frozenset({"name": 1, "age": 4})
print(fs, type(fs)) # frozenset({'name', 'age'}) <class 'frozenset'>
# 集合推导式
s = frozenset(x for x in range(0, 10))
print(s, type(s)) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) <class 'frozenset'>
# 注意,创建空集合{},使用set、frozenset vs 字典
ss = {} # 字典
ss = set() # 空的集合s
ss = frozenset() # 空的集合
# 集合中的元素必须是可哈希的值(如果一个对象在自己生命周期中有一哈希值是不可改变的,那么它就是可哈希的 展示理解为不可变类型)
# 如果集合中的元素重复,则被合并为一个
s = {1, 5, 89} # s = {1, 5, 89,[1,3]} error
print(s)
# 可以给列表去重
l = [1, 2, 1, 1]
s = set(l)
print(s) # {1,2}
result = list(s) # 转为列表类型
print(result, type(result))
# 常用操作
# 增加
s = {1, 5, 89}
s.add(4) # 新增的元素不可变,可哈希的值
print(s, type(s)) # {89, 1, 4, 5} <class 'set'>
# 删除
# 集合没有该元素,返回一个错误
s = {1, 5, 89}
result1 = s.remove(1)
print(result1, s) # None {89, 5}
# s.discard()
# 集合没有该元素,do nothing,不返回错误
s = {1, 5, 89}
result1 = s.discard(23)
print(result1, s) # None {89, 1, 5}
# s.pop()随机删除
# 集合没有该元素,返回一个错误
s = {1, 5, 89}
result1 = s.pop()
print(result1, s) # 89 {1, 5}
# s.clear() 清空集合所有元素
s = {1, 5, 89}
result1 = s.clear()
print(result1, s) # None set()
# 删除整个集合
# del
# 不可变集合不可增加、删除、修改 可变集合也不可以修改,可以增加、删除、查询
# 可变集合与不可变集合查询方式一样
# 查询
# 无法通过索引或者key进行查询
# 可以遍历
s = {1, 5, 89}
for v in s:
print(v)
# 使用迭代器
# 生成一个迭代器
# 访问,next()、for in
its = iter(s)
print(next(its))
print(next(its))
print(next(its))
# 迭代器不可以重复使用
its = iter(s)
for v in its:
print(v)
# 交、并、差、判定
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1.intersection(s2)
print(result, type(result)) # 可变集合 {1, 3} <class 'set'>
s1 = frozenset({1, 3, 5, 3, 19, 3})
s2 = {1, 4, 6, 3}
result = s1.intersection(s2) # s1在前,总体不可变集合
print(result, type(result)) # 不可变集合 frozenset({1, 3}) <class 'frozenset'>
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1 & s2 # 可变与不可变混合,运算符左侧为准
print(result, type(result)) # 可变集合 {1, 3} <class 'set'>
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1.intersection_update(s2) # 会更改原对象值,只适用于可变集合
print(result, type(result)) # 可变集合
print(s1) # s1又保存了运算的结果
print(s1.intersection([1, 2, 3])) # {1, 3}
s1 = {"1", "2", "3"}
print(s1.intersection({"1": "asd", "2": "sdfsd"})) # {'2', '1'}
# 并
# union 逻辑或| update()更新并集
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1.union(s2)
print(result, type(result))
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1 | s2
print(result, type(result))
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1.update(s2)
print(result, type(result))
print(s1) # 更新了s1本身
# 差集
# difference -号
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1.difference(s2)
print(result, type(result))
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1 - s2
print(result, type(result))
s1 = {1, 3, 5, 3, 19, 3}
s2 = {1, 4, 6, 3}
result = s1.difference_update(s2)
print(result, type(result))
print(s1) # 更新了s1本身
# 判定
s1 = {1, 3, 5, 3, 19, 3, 4, 6}
s2 = {1, 4, 6, 3}
print(s1.isdisjoint(s2)) # 是否不相交 false
print(s1.issuperset(s2)) # s1是否包含 true
print(s1.issubset(s2)) # s2是否s1子集和 false
print(s2.issubset(s1)) # 是否子集和 true
时间日历
# python程序很多方式处理日期和时间,转换日期格式是一个常见功能
# time模块:提供处理时间和表示之间的转换功能
# calendar模块:提供与日历相关的功能
# datetime模块:可以计算操作
# 获取当前的时间戳
# 从0时区的1970年1月1号0时0分0秒,到所给定的日期时间的秒数
import time
result = time.time()
print(result) # 秒数
years = result / (24 * 60 * 60 * 365) + 1970
print(years) # 2020.2910467696342
# 获取时间元组
result = time.localtime()
print(result) # time.struct_time(tm_year=2020, tm_mon=4, tm_mday=4, tm_hour=13, tm_min=34, tm_sec=10, tm_wday=5, tm_yday=95, tm_isdst=0)
result = time.localtime(1471820230.594102) # 根据时间戳转换成对应的时间元组进行查看
print(result)
# 获取格式化时间
# 秒->可读时间
t = time.time()
result = time.ctime(t)
print(result) # Sat Apr 4 13:34:10 2020
# 时间元组->可读时间
time_tuple = time.localtime()
result = time.asctime(time_tuple)
print(result) # Sat Apr 4 13:34:10 2020
# 自定义格式化时间
# 字符串->格式化时间 time.strftime(格式字符串,时间元组)
result = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(result) # 2020-04-04 13:34:10
result = time.strftime("%y-%m-%d %H:%M:%S", time.localtime())
print(result) # 20-04-04 13:34:10
# 格式化日期->时间元组
pt = time.strptime("19-10-23 16:52:33", "%y-%m-%d %H:%M:%S")
print(pt) # time.struct_time(tm_year=2019, tm_mon=10, tm_mday=23, tm_hour=16, tm_min=52, tm_sec=33, tm_wday=2, tm_yday=296, tm_isdst=-1)
# 时间元组->时间戳
t = time.mktime(pt)
print(t) # 1571820753.0
# 获取当前cpu时间
# 一段程序的执行耗费时间
start = time.clock()
for i in range(0, 3):
print(i)
# time.sleep(1) # 休眠一秒,打印没有那么频繁
end = time.clock()
print(end - start)
# time.sleep()
# 休眠n秒
# 推迟线程执行,可理解为让程序暂停
# 获取某月日历
import calendar
print(calendar.month(2017, 6)) # 2017年六月的文本日历
# 处理时间和日期的标准库
# datetime模块里面有datetime类此外还有date类以及time类
# 获取当天日期
import datetime
print(datetime.datetime.now()) # 2020-04-04 13:34:10.949149
print(datetime.datetime.today()) # 2020-04-04 13:34:10.949149
t = datetime.datetime.today()
print(type(t)) # <class 'datetime.datetime'>
print(t.year)
print(t.month)
print(t.day)
print(t.hour)
print(t.minute)
print(t.second)
t = datetime.datetime.today()
# 计算n天之后的日期
result = t + datetime.timedelta(days=7) # 加上七天新的日期
print(t) # 2020-04-04 13:34:10.949149
print(result) # 2020-04-11 13:34:10.949149
# 获取两个时间的日期差
first = datetime.datetime(2017, 9, 2, 12, 00, 00)
second = datetime.datetime(2017, 9, 3, 12, 00, 00)
delta = second - first
print(delta,type(delta)) # 1 day, 0:00:00 <class 'datetime.timedelta'>
print(delta.total_seconds()) # 86400.0
总结
数值、布尔、字符串、列表、元组、字典、集合、时间日历
访问集合方式-迭代器