python学习笔记

今日内容概要

• 作业讲解
• 列表内置方法
• 字典内置方法
• 元组内置方法
• 集合内置方法
• 可变类型与不可变类型

今日内容详细

作业讲解

1.基于字符串充当数据库完成用户登录
data_source = 'jason|123' # 一个用户数据
获取用户用户名和密码，将上述数据拆分校验用户信息是否正确

data_source = 'jason|123' # 模拟数据库
username = input('username:').strip()
password = input('password:').strip() # 获取用户名和密码之后立刻移除首尾空格，再赋值给变量名username，password
real_name, real_pwd = data_source.split('|') # a，b = 【'jason', '123'】,切割之后再解压赋值
if username == real_name and password == real_pwd:
    print('登录成功')
else:
    print('用户名或密码错误')

2.基于列表充当数据库完成用户登录
多个数据库
data_source = ['jason|123', 'kevin|321', 'oscar|333']

data_source = ['jason|123', 'kevin|321', 'oscar|333']  # 模拟数据库
username = input('username:').strip()
password = input('password:').strip()
 # 获取用户名和密码
for data in data_source: # 比对（循环一一比对，有一个正确就可以）
    real_name, real_pwd = data.split('|') # 切割之后再解压赋值（jason，123...）
    if username == real_name and password == real_pwd:
        print('登录成功')
        break # 只要匹配正确，就应该立刻结束循环，避免资源浪费
else:
    print('用户名或密码错误')

列表内置方法

1.关键字

list

2.使用

按照位置记录多个值，索引对应值

3.定义方式

在[]内用逗号分隔开多个任意类型的值
数据类型转换：但凡能够被for循环的数据类型都可以转成列表

4.内置方法

列表在调用内置方法之后不会产生新的值，而是修改的自身
增删改查：占据了程序的90%以上的核心操作

1.len（统计列表中数据值的个数）

l1 = [11, 22, 33, 44, 55]
print(len(l1)) # 5

2.append（尾部追加数据值）和insert（任意位置插入数据值）和extend（扩展列表）

1.append（尾部追加数据值），括号内无论写什么数据类型，都当成一个数据值追加

l1 = ['jason','kevin']
l1.append('tony')
print(l1)  # ['jason', 'kevin', 'tony']
l1.append([1, 2, 3])
print(l1)  # ['jason', 'kevin', 'tony', [1, 2, 3]]

2.insert(任意位置插入数据值)，括号内无论写什么数据类型，都当成一个数据值插入

l1 = ['jason', 'kevin']
l1.insert(0, '插队')
print(l1)  # ['插队', 'jason', 'kevin']
l1.insert(0, [1, 2, 3])
print(l1)  # [[1, 2, 3], '插队', 'jason', 'kevin']

3.扩展列表

l1 = [1, 2, 3]
l2 = [4, 5, 6]
方式1（利用for循环+append（））：
for i in l1:
    l2.append(i)
print(l2)  # [4, 5, 6, 1, 2, 3]
方式2（利用运算符'+'）：
print(l1 + l2) # [1, 2, 3, 4, 5, 6]
方式3(利用内置方法extend（）推荐使用)：
l1.extend(l2)
print(l1) # [1, 2, 3, 4, 5, 6]
# 括号里面必须是支持for循环的数据类型相当于for循环+append（）

3.查询数据与修改数据

按索引取值，即可存也可取

l1 = [1, 2, 3]
print(l1)
print(l1[0])
print(l1[1:3])
l1[0] = 'jasonNB'
print(l1)
输出结果：
[1, 2, 3]
1
[2, 3]  # 索引取值
['jasonNB', 2, 3]

4.del（通用删除策略），remove（指名道姓删除），pop（先取出数据值，然后再删）

1.del（通用删除策略）

l1 = [1, 2, 3]
del l1[0] # 通过索引即可
print(l1) # [2, 3]

2.remove(指名道姓删除)

l1 = [1, 2, 3]
res = l1.remove(1) # 括号内必须填写明确的数据值，就地正法
print（l1, res） # [2, 3] None

3.pop(先取出数据值，然后再删)

l1 = [1, 2, 3]
res = l1.pop()  # 默认取出列表尾部数据值然后再删，先蹂躏一下再删
print(l1, res) # [1, 2] 3

5.index(查看数据值对于的索引值)

l1 = [1, 2, 3]
print(l1.index(1)) # 0

6.count(统计某个数据值出现的次数)

l1 = [1, 1, 1, 2, 2, 3, 4, 5, 6]
print(l1.count(1)) # 3

7.sort(排序)

l1 = [1, 3, 5, 2, 7, 4, 6]
l1.sort() # 升序
l1.sort(reverse=True) # 降序
print(l1)
输出结果：
[1, 2, 3, 4, 5, 6, 7]
[7, 6, 5, 4, 3, 2, 1]

8.reverse（翻转）

l1 = [1, 2, 3, 4, 5, 6, 7]
l1.reverse() # 前后颠倒
print(l1) # [7, 6, 5, 4, 3, 2, 1]

9.比较运算

l1 = [99, 11]
l2 = [11, 22, 33]
print(l1 > l2) # True 是按照位置顺序一一比较


l1 = ['a', 11]
l2 = [11, 22, 33]
print(l1 >l2) # 报错   不同数据类型之间默认无法直接做操作

可变与不可变类型

1.可变类型

值改变，但是id不变，证明就是在改变原值，是可变类型（eg：list）

l1 = [1, 2, 3]
print(id(l1)) # 1826315556416
l1.append(4) # [1, 2, 3, 4]
print(id(l1)) # 1826315556416

2.不可变类型

值改变，但是id也跟着变，证明是产生了新值，是不可变类型（eg：str，int，float）

s1 = '$hello$'
print(id(s1)) # 1732448092848
s1 = s1.strip('$') # hello
print(id(s1)) # 1732446780912

元组内置方法

1.关键字

tuple

2.定义

在()内用逗号隔开多个任意类型的值
类型转换：支持for循环的数据类型都可以转元组

3.补充知识

当元组内只有一个数据值的时候，逗号不能省略，如果省略了，那么括号里面是什么数据类型就是什么数据类型
建议：编写元组，哪怕只有一个数据也要把逗号加上
ps：以后遇到可以存储多个数据值得数据类型，如果里面只有一个数据，逗号也趁机加上

4.内置方法

1.索引相关操作

t1 = (1, 2, 3)
print(t1[0])  # 1

2.len（统计元组内数据值的个数）

t1 = (1, 2, 3)
print(len(t1)) # 3

3.查与改

t1 = (1, 2, 3)
print(t1[0]) # 1   可以查
t1[0] = 111 # 报错  不可以改

元组的索引不能改变绑定的地址

t1 = (11, 22, 33, [11, 22])
t1[-1].append(33)
print(t1)  # (11, 22, 33, [11, 22, 33])

字典内置方法

1.关键字

dictionary

2.定义

在{}内用逗号隔开的一系列键值对
字典很少涉及到类型转换，都是直接定义使用
k是对v的描述性性质的信息一般是字符串，k其实只要是不可变类型都可以

3.内置方法

1.字典内k：v键值对是无序的，所以无法索引取值

2.get（取值操作）

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
print(info['username'])  # jason
print(info['xxx']) # 不推荐使用，键不存在会直接报错


print(info.get('username')) # jason
print(info.get('xxx')) # None   键不存在返回的值，默认返回None


print(info.get('xxx', 123)) # 123
print(info.get('xxx')) # None

3.len(统计字典中键值对的个数)

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
print(len(info))  # 3

4.修改数据

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
info['username'] = 'jasonNB'
print(info)  # {'username': 'jasonNB', 'pwd': 123, 'hobby': ['read', 'run']}

键存在则是修改

5.新增数据

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
info['salary'] = 6
print(info)  # {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 6}

键不存在则是新增

6.删除数据

方式1：

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
del info['username']
print(info)  # {'pwd': 123, 'hobby': ['read', 'run']}

方式2：

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
res = info.pop('username')
print(info, res)  # {'pwd': 123, 'hobby': ['read', 'run']} jason

方式3：

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
info.popitem()  # 随机删除
print(info) # {'username': 'jason', 'pwd': 123}

7.快速获取键，值，键值对数据

print(info.keys())  # 获取字典所有的k值 结果当成是列表即可dict_keys(['username', 'pwd', 'hobby'])
print(info.values())  # 获取字典所有的v值 结果当成是列表即可dict_values(['jason', 123, ['read', 'run']])
print(info.items())  # 获取字典kv键值对数据 组织成列表套元组dict_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])

8.修改字典数据，键存在则是修改，键不存在则是新增

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
info.update({'username':'jason123'})
print(info) # {'username': 'jason123', 'pwd': 123, 'hobby': ['read', 'run']}
info.update({'xxx':'jason123'})
print(info)) # {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'xxx': 'jason123'}

9.快速构造字典，给的值默认情况下所有的键都用一个

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
res = dict.fromkeys([1, 2, 3], None)
print(res) # {1: None, 2: None, 3: None}

10.键存在则获取键对应的值，键不存在则设置并返回设置的新值

info = {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
res = info.setdefault('username', 'jasonNB')
print(res, info) # jason {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
res1 = info.setdefault('xxx', 'jasonNB')
print(res1, info) # jasonNB {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'xxx': 'jasonNB'}

集合内置方法

1.关键字

set

2.定义

集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
类型转换：支持for循环的并且数据必须是不可变类型
定义空集合需要使用关键字才可以
集合内数据必须是不可变类型（整型，浮点型，字符串，元组，布尔值）

3.去重

s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
print(s1)  # {1, 2, 3, 4, 5, 12}
l1 = ['jason', 'jason', 'tony', 'oscar', 'tony', 'oscar', 'jason']
s2 = set(l1)
l1 = list(s2)
print(l1) # ['oscar', 'jason', 'tony']

4.关系运算

模拟两个人的好友集合
f1 = {'jason', 'tony', 'oscar', 'jerry'}
f2 = {'kevin', 'jerry', 'jason', 'lili'}
1.求f1和f2的共同好友
print(f1 & f2)  # {'jason', 'jerry'}
2.求f1/f2独有好友
print(f1 - f2)  # {'oscar', 'tony'}
print(f2 - f1)  # {'lili', 'kevin'}
3.求f1和f2所有的好友
print(f1 | f2)  # {'jason', 'kevin', 'lili', 'oscar', 'jerry', 'tony'}
4.求f1和f2各自独有的好友(排除共同好友)
print(f1 ^ f2)  # {'kevin', 'lili', 'tony', 'oscar'}
5.父集 子集
s1 = {1, 2, 3, 4, 5, 6, 7}
s2 = {3, 2, 1}
print(s1 > s2)  # s1是否是s2的父集  s2是不是s1的子集
print(s1 < s2)

作业

1.利用列表编写一个员工姓名管理系统
输入1执行添加用户名功能
输入2执行查看所有用户名功能
输入3执行删除指定用户名功能
ps:思考如何让程序循环起来并且可以根据不同指令执行不同操作
提示: 循环结构 + 分支结构
拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写 不会没有关系)

2.去重下列列表并保留数据值原来的顺序
eg: [1,2,3,2,1] 去重之后 [1,2,3]
l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]

l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
l2 = []
for i in l1:
    if not i in l2:
        l2.append(i)
print(l2)

3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合

pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
print(pythons & linuxs)
print(pythons | linuxs )
print(pythons - linuxs)
print(pythons ^ linuxs )