• 作业讲解
• 数据类型的转换及其内置方法
  • 字符串(str)
  • 列表(list)
    • 类型转换
    • 内置方法
      • 索引取值
      • 切片操作
      • 步长
      • 统计列表中元素的个数
      • 成员运算 (in和not in)
      • 列表添加元素的方式*
      • 删除元素
      • 修改列表元素(id)
      • 排序(sort)
      • 翻转
      • 比较运算
      • 统计列表中某个元素出现的次数
  • 可变类型与不可变类型
    • 数字类型( int \ float ):
    • 字符串：
    • 列表：
    • 元组：
    • 字典：
  • 队列与堆栈
    • 队列(先进先出)
    • 堆栈(先进后出)

作业讲解

'''
习题题目：
编写一个用户登录程序
	要求最多尝试失误三次 过期自动提示并可重置尝试次数
    用户登录成功之后进入内部循环 用户输入什么就打印什么 并给用户提供一个结束程序的特殊指令
    获取用户输入的用户名和密码,可以处理首尾空格
    用户的用户名和密码使用变量存储 通过程序获取用户名和密码比对
    	data = 'jason|123'
'''

# 用户登录功能   获取用户输入 比对用户数据
# 1.定义类似于数据库的数据  (单用户模式)
source_data = 'jason|123'
# 1.1 多用户模式登录
# source_data = ['jason|123', 'tony|123', 'kevin|321', 'jerry|222']
# 8.添加一个计数器
count = 1
# 5.添加循环
while True:
    # 9.判断当前尝试的次数
    if count == 4:
        choice = input('您已经尝试三次了 是否继续(y/n)>>>:').strip()
        if choice == 'y':
            count = 1
        else:
            print('欢迎下次使用')
            break
    # 2.获取用户输入的用户名和密码
    username = input('username>>>:').strip()
    # TODO:自己可以结合自己的需求添加更多的校验
    if len(username) == 0:
        print('用户名不能为空')
        continue
    password = input('password>>>:').strip()
    if len(password) == 0:
        print('密码不能为空')
        continue
    # 3.切割原始数据得到用户名和密码再比对
    real_name, real_pwd = source_data.split('|')  # real_name, real_pwd=['jason','123']  解压赋值
    # 4.校验用户名和密码
    if username == real_name and password == real_pwd:
        print("登录成功")
        # 6.添加内层循环
        while True:
            cmd = input('请输入您的指令>>>:').strip()
            # 7.添加一个结束条件
            if cmd == 'q':
                break
            print('正在执行您的命令:%s' % cmd)
    else:
        print('用户名或密码')
        # 10.没错一次 计数器加一
        count += 1

数据类型的转换及其内置方法

字符串(str)

这里我整理了比较完整的字符串的数据类型转换及内置方法，详情去我的番外篇博客看吧~

列表(list)

类型转换

​ 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

# int
print(list(11))  # 不行
# float
print(list(11.11))  # 不行
#str
print(list('wdad')) # 结果：['w', 'd', 'a', 'd'] 
# dict
print(list({"name":"jason","age":18})) #结果：['name', 'age']
# tuple
print(list((1,2,3))) # 结果：[1, 2, 3] 
# set
print(list({1,2,3,4})) # 结果：[1, 2, 3, 4]
# bool
print(list(True))  # 不行

内置方法

name_list = ['jason', 'kevin', 'tony', 'tom', 'jerry']

索引取值

# 正向取(从左往右)
print(name_list[0])

# 反向取(负号表示从右往左)
print(name_list[-1])

# 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
name_list[1] = 'martthow'
print(name_list)
# ['jason', 'martthow', 'tony', 'tom', 'jerry']

切片操作

# 顾头不顾尾：取出索引为1到3的元素
print(name_list[1:4])  # ['kevin', 'tony', 'tom']

print(name_list[-4:-1])  # ['kevin', 'tony', 'tom']

print(name_list[-1:-4:-1])  # ['jerry', 'tom', 'tony']

步长

# 第三个参数1代表步长，会从0开始，每次累加一个1即可，所以会取出索引0、1、2、3的元素
print(name_list[0:4:1])  # ['jason', 'kevin', 'tony', 'tom']

# 第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
print(name_list[0:4:2])  # ['jason', 'tony']

print(name_list[-1:-4:-1])  # ['jerry', 'tom', 'tony']

统计列表中元素的个数

print(len(name_list))  # 5

成员运算 (in和not in)

# 最小判断单位是元素不是元素里面的单个字符
print('j' in name_list)  # False
print('jason' in name_list)  # True

列表添加元素的方式*

# append()列表尾部追加'单个'元素
name_list.append('小李')
print(name_list)
name_list.append([11, 22, 33, 44])
print(name_list)

# insert()指定位置插入'单个'元素
name_list.insert(0, 123)
name_list.insert(2, '可不可以插个队')
name_list.insert(1, [11, 22, 33])
print(name_list)

# extend()合并列表
name_list.extend([11, 22, 33, 44, 55])
print(name_list)
'''extend其实可以看成是for循环+append'''
for i in [11, 22, 33, 44, 55]:
    name_list.append(i)
print(name_list)
name_list += [11, 22, 33, 44, 55]
print(name_list)  # 加号的效率不高

删除元素

# 通用的删除方式(del)
del name_list[0]
print(name_list)

# 就地删除(remove)
# remove()括号内指名道姓的直接删除某个元素，没有返回值
print(name_list.remove('jerry'))  # None
print(name_list)  # ['jason', 'kevin', 'tony', 'tom']
# 从左往右查找第一个 括号内需要删除的元素

# 延迟删除(pop)
print(name_list.pop())  # 默认是尾部弹出    jerry
print(name_list)
print(name_list.pop(2))  # 还可以指定索引值   tony
print(name_list)

修改列表元素(id)

print(id(name_list[0]))  # 2614038082368
name_list[0] = 'jasonDSB'
print(id(name_list[0]))  # 2614038926320
print(name_list)

排序(sort)

# sort()给列表内所有元素排序
# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
ss = [44, 77, 99, 11, 22, 33, 88, 66]
ss.sort()  # 默认是升序
print(ss)  # [11, 22, 33, 44, 66, 77, 88, 99]
ss.sort(reverse=True)  # 可以修改尾降序
# reverse用来指定是否跌倒排序，默认为False
print(ss)  # [99, 88, 77, 66, 44, 33, 22, 11]

翻转

ss = [44, 77, 99, 11, 22, 33, 88, 66]
ss.reverse()  # 前后颠倒
print(ss)

比较运算

s1 = [11, 22, 33]
s2 = [1, 2, 3, 4, 5, 6, 7, 8]
print(s1 > s2)  # True
"""列表在做比较的时候 其实比的是对应索引位置上的元素,如果分出大小，则无需比较下一个元素"""
s1 = ['A', 'B', 'C']  # A>>>65
s2 = ['a']  # a>>>97
print(s1 > s2)  # False
ss = [44, 77, 99, 11, 22, 33, 88, 66]
print(ss.index(99))

统计列表中某个元素出现的次数

l1 = [11, 22, 33, 44, 33, 22, 11, 22, 11, 22, 33, 22, 33, 44, 55, 44, 33]
print(l1.count(11))  # 统计元素11出现的次数
l1.clear()  # 清空列表
print(l1)  # []

可变类型与不可变类型

可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值

不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值

'''
可变类型与不可变类型
    可变类型     如：列表
        值改变 内存地址不变 修改的是本身
    不可变类型   如：字符串
        值改变 内存地址肯定遍 修改过程产生了新的值
如何查看变量的'内存地址'
'''

数字类型( int \ float ):

>>> x = 10
>>> id(x)
1953464720
>>>
>>> x = 20
>>> id(x)
1953465040
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

字符串：

>>> x = "qiao"
>>> id(x)
1853141915384
>>> x = "qiaoyu"
>>> id(x)
1853141915496
# 内存地址改变了，说明字符串是不可变数据类型

列表：

>>> list1 = ['tom','jack','egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

元组：

>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 报错：TypeError
>>> t1.append('lili') # 报错：TypeError
# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)

字典：

>>> dic = {'name':'egon','sex':'male','age':18}
>>> 
>>> id(dic)
4327423112
>>> dic['age']=19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

队列与堆栈

这里我们先使用列表模拟出队列与堆栈的特征

队列(先进先出)

new_list = []
# 先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 先出
for i in new_list:
    print(i)
print(new_list.pop(0))
print(new_list.pop(0))
print(new_list.pop(0))

堆栈(先进后出)

new_list = []
# 先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 后出
print(new_list.pop())
print(new_list.pop())
print(new_list.pop())

今天的学习内容结束啦！！！