python学习-Day8

目录

• 作业讲解
• 数据类型内置方法3
  • 字典 ( dict ，可变类型)
    • 类型转换 —— dict()
    • 需要掌握的方法
      • 按key取值（可存可取）
      • 统计字典中键值对的个数（len）
      • 成员运算
      • 删除键值对
      • 获取 所有的 键、值 、键值对
      • 循环
    • 需要了解的方法
      • update更新字典
      • fromkeys()快速生成字典
        • 贴一个题
      • setdefault()
  • 元组（tuple）
    • 注*：
    • 类型转换
    • 元组的特性
    • 内置方法
      • 索引取值
      • 切片操作
      • 长度
      • 成员运算(in 和 not in)
      • 统计某个元素出现的次数
      • 元组内元素不能"修改"
        • 贴个题
  • 集合（set）
    • • 集合的三个特点：
    • 注意点
    • 类型转换
    • 关系运算
      • 合集(|)
      • 交集(&)
      • 差集(-)
      • 对称差集(^)
      • 值是否相等(==)
      • 父集
      • 子集
    • 去重
      • 贴几个例子
    • 补充
• 垃圾回收机制
  • 引用计算
  • 标记-清除
  • 分代回收

作业讲解

'''
 利用列表编写一个用户注册、登录程序
	  提示:循环
      要求:成功一次即可 无需考虑用户冲突等情况
'''

# 1.先定义一个用于存储用户数据的列表
data_list = []
# 2.循环打印程序的功能 供用户选择执行
while True:
    # 3.打印程序中所有的功能编号
    print("""
    1.注册
    2.登录
    3.查看所有用户信息
    """)
    # 4.获取用户想要执行的功能编号
    choice = input('请输入功能编号>>>:').strip()
    # 5.判断用户想要执行的功能
    if choice == '1':
        # 6.获取用户的用户名和密码  针对一些小的判断逻辑 你们自己去考虑
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        # 6.1.判断用户名不能冲突
        for user in data_list:  # 'jason|123'   'tony|321'
            # 6.2.如果考虑密码是用户名 用户名是其他
            if username == user.split('|')[0]:
                print('用户名已存在')
                break
        else:
            # 7.将用户名和密码拼接到一起
            user_data = f'{username}|{password}'  # 'jason|123'
            # 8.添加到列表中
            data_list.append(user_data)
            # 9.提示用户注册成功
            print(f'{username}注册成功')
    elif choice == '2':
        # 10.获取用户名和密码
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        # 11.两种判断思路  思路1:先比对用户名 之后比对密码   思路2:直接拼接比对整体结构
        user_data1 = f'{username}|{password}'
        # 12.循环比对
        for data in data_list:
            if user_data1 == data:
                print('登录成功')
                break
        else:
            print('用户名或密码错误')
    elif choice == '3':
        print(data_list)
    else:
        print('你能不能好好的输 眼瞎是吧!!!')

''' 不使用count统计列表中指定元素出现的次数'''

l1 = [11, 22, 33, 44, 11, 22, 22, 11, 11, 22, 11, 22, 11, 22, 11, 22, 11]
# 获取用户想要统计的元素
target = input('请输入你想要统计的元素>>>:').strip()
if target.isdigit():
    target = int(target)
    # 定义一个计数器
    count = 0
    # 循环判断元素是否相等
    for i in l1:
        if target == i:
            # 计数器自增1
            count += 1
    # 打印元素出现的次数
    print(f'{target}出现了{count}次')

今天的新内容来啦！！！

数据类型内置方法3

字典 ( dict ，可变类型)

在{}内用逗号分隔开多元素，每一个元素是K:V键值对形式，K是不可变类型（整型、浮点型、字符串也是不可变类型），V是任意类型

类型转换 —— dict()

res = dict(name='qiao', pwd = 123, hobby = 'read')
print(res)
# {'name': 'qiao', 'pwd': 123, 'hobby': 'read'}

res1 = dict([['name', 'qiao'], ['age', 18], ['hobby', 'read']])
print(res1)
# {'name': 'qiao', 'age': 18, 'hobby': 'read'}

# fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
print({}.fromkeys(('name', 'age', 'sex'), None))
# {'name': None, 'age': None, 'sex': None}

需要掌握的方法

按key取值（可存可取）

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print(d1['name'])  # jason  键存在
print(d1['xxx'])  # 键不存在直接报错
"""上述方法不推荐使用"""

print(d1.get('name'))  # jason  键存在
print(d1.get('xxx'))  # None 键不存在，不报错，返回None
print(d1.get('xxx', '这个键不存在'))  # 键不存在，第二个参数不写时默认返回None，写了则返回写了的
print(d1.get('name', '这个键不存在'))  # 如果键存在 则不需要用到第二个参数（返回key所对应的value）

# (添加值) 对于赋值操作，如果key原先不存在于字典，则会新增key:value
d1['gender'] = 'male'
print(d1)
# {'name': 'jason', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

# (修改值) 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
d1['name'] = 'tony'
print(d1)
# {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

统计字典中键值对的个数（len）

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(len(d1))  # 3

成员运算

in和not in

# 只能判断某个值是否是字典的key而已
print('jason' in d1)  # False
print('name' in d1)  # True

删除键值对

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

# 通用的删除方式
del d1['name']
print(d1)  # {'age': 18, 'hobbies': ['play game', 'basketball']}

# 通过指定字典的key来删除字典的键值对 pop尾部弹出
print(d1.pop('age'))  # 18  弹出
print(d1)  # {'name': 'jason', 'hobbies': ['play game', 'basketball']}

# 随机弹出一个(使用频率很低 可以忽略)
d1.popitem()
print(d1)

获取 所有的 键、值 、键值对

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

print(d1.keys())
# dict_keys(['name', 'age', 'hobbies'])  可以看成是列表  （在python2中直接返回一个列表）

print(d1.values())
# dict_values(['jason', 18, ['play game', 'basketball']])  可以看成是列表  （在python2中直接返回一个列表）

print(d1.items())
# dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])  可以看成是列表套元组  （在python2中直接返回一个列表）
for v in d1.values():
    print(v)

循环

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

# 默认遍历的是字典的key
for key in d1:
    print(key)
'''
name
age
hobbies
'''

# 只遍历key
for key in d1.keys():
    print(key)
'''
name
age
hobbies
'''

# 遍历key与value
for key in dic.items():
    print(key)
'''
('name', 'jason')
('age', 18)
('hobbies', ['play game', 'basketball'])
'''

需要了解的方法

update更新字典

# 用新字典更新旧字典，有则修改，无则添加
dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1': 'JN', 'k4': 'xxx'})
print(dic)  # 键存在则修改 键不存在则新增
# {'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'}

fromkeys()快速生成字典

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)  # {'k1': [], 'k2': [], 'k3': []}

贴一个题

dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
dic['k1'].append(111)  # 三个键指向的是同一个列表
print(dic)  # {'k1': [111], 'k2': [111], 'k3': [111]}

setdefault()

dic = {'k1': 111, 'k2': 222}
# key不存在则新增键值对，并返回新增的value
print(dic.setdefault('k3', 333))  # 333
print(dic)  # {'k1': 111, 'k2': 222, 'k3': 333}

# key存在则不做任何修改，并返回其对应的value值
print(dic.setdefault('k1', '嘿嘿嘿'))  # 111
print(dic)  # {'k1': 111, 'k2': 222, 'k3': 333}

元组（tuple）

可以看成是不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

注*：

强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

类型转换

# 支持for循环的数据类型都可以转成元组
# int
print(tuple(11))  # 报错
# float
print(tuple(11.11))  # 报错
# str
print(tuple('jason'))
# list
print(tuple([11,22,33,44]))
#  dict
print(tuple({'name':'jason'}))
# set
print(tuple({11,22,33,44}))
# bool
print(tuple(True))  # 报错

元组的特性

t1 = (11, 22, 33, 44)
print(type(t1))  # <class 'tuple'>
t2 = (11)
print(type(t2))  # <class 'int'>
t2 = (11.11)
print(type(t2))  # <class 'float'>
t2 = ('jason')
print(type(t2))  # <class 'str'>
"""当元组内只有一个元素的时候 一定要在元素的后面加上逗号"""
t2 = (11,)
print(type(t2))  # tuple
t2 = (11.11,)
print(type(t2))  # tuple
t2 = ('jason',)
print(type(t2))  # tuple

内置方法

索引取值

t1 = (11, 22, 33, 44, 55, 66)
# (正向取+反向取)：只能取，不能改否则报错！
print(t1[0])  # 11
print(t1[-1])  # 66

切片操作

t1 = (11, 22, 33, 44, 55, 66)
# (顾头不顾尾，步长)
print(t1[1:4])  # (22, 33, 44)
print(t1[-1:-4:-1])  # (66, 55, 44)
print(t1[-4:-1])  # (66, 55, 44)
print(t1[1:4:2])  # (22, 44)

长度

t1 = (11, 22, 33, 44, 55, 66)
print(len(t1))  # 6

成员运算(in 和 not in)

t1 = (11, 22, 33, 44, 55, 66)
print(11 in t1)  # True

统计某个元素出现的次数

t1 = (11, 22, 33, 44, 55, 66)
print(t1.count(22)) # 1

元组内元素不能"修改"

# 元组内各个索引值指向的内存地址不能修改
t1 = (11, 22, 33, 44, 55, 66)
t1[0] = 111
# 报错：TypeError: 'tuple' object does not support item assignment

贴个题

'''
tt = (11, 22, 33, [11, 22])
tt[-1].append('heiheihei')
    问:执行之后的结果   正确答案选B
      A.报错    B.正常添加   C.不知道
'''
tt = (11, 22, 33, [11, 22])
print(id(tt[-1]))  # 3191328568904
tt[-1].append('heiheihei')
print(id(tt[-1]))  # 3191328568904
print(tt)  # (11, 22, 33, [11, 22, 'heiheihei'])

集合（set）

集合内部也可以存放多个值，但是集合主要用于：去重、关系运算

集合的三个特点：

1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

注意点

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式。

d = {} # 默认是空字典
s = set() # 这才是定义空集合

类型转换

'''集合内元素只能是不可变类型'''
# int
print(set(11))  # 报错
# float
print(set(11.11))  # 报错
# str
print(set('jason'))
# list
print(set([11,22,33,44]))
# dict
print(set({'name':'jason'}))
# tuple
print(set((11,22,33)))
# bool
print(set(True))  # 报错

关系运算

判断两个群体内的差异

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

合集(|)

print(friends1 | friends2)
# {'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

交集(&)

print(friends1 & friends2)
# {'jason', 'egon'}

差集(-)

# 求用户1独有的好友
print(friends1 - friends2)
# {'kevin', 'zero'}

# 求用户2独有的好友
print(friends2 - friends1)
# {'ricky', 'Jy'}

对称差集(^)

# 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
# {'kevin', 'zero', 'ricky', 'Jy'}

值是否相等(==)

print(friends1 == friends2)
# False

父集

# 一个集合是否包含另外一个集合
# 包含则返回True
print({1,2,3} > {1,2})  # True
print({1,2,3} >= {1,2})  # True

# 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

子集

# 一个集合是否被包含于另外一个集合
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

去重

集合去重复有局限性

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

贴几个例子

s1 = {1,1,1,2,2,2,2,2,1,2,3,2,2,1,2,3,2,3,4,3,2,3}
print(s1)  # {1, 2, 3, 4}

l = ['a', 'b', 1, 'a', 'a']
s1 = set(l)  # 将列表转成了集合
l = list(s1)  # 再将集合转回列表
print(l)  # [1, 'b', 'a']  # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，

补充

1.长度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
>>>    print(item)

c
a
b

垃圾回收机制

垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间

引用计算

# 引用计数就是：变量值被变量名关联的次数
# python会将引用计数为0的数据清除
name = 'jason'  # jason引用计数为1
a = name        # 此时name和a都关联了jason,所以jason引用计数为2

标记-清除

当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除。先挨个检查值的引用计数并给计数为0的数据打上标记，然后一次性清理掉。

分代回收

**根据值存在的时间长短 将值划分为三个等级(1,2,3) **

如：
等级1 检测机制每隔5s来一次
等级2 检测机制每隔1min来一次
等级3 检测机制每隔5min来一次

又一天结束啦！！！时间过得好快呀