python编程基础-5

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

总结
数值、布尔、字符串、列表、元组、字典、集合、时间日历
访问集合方式-迭代器