Python语言系列-02-基础数据类型

---

---

---

格式化输出

#!/usr/bin/env python3
# author:Alnk(李成果)

# 百分号% 格式化输出
name = input('姓名:')
age = input('年龄:')
sex = input('性别:')
hobby = input('爱好:')
job = input('工作:')

msg = '''------------ info of %s -----------
Name  : %s
Age   : %s
job   : %s
hobby: %s
------------- end -----------------''' % (name, name, age, job, hobby)
print(msg)

# 补充：注意其中的一个坑
# 当用格式化输出的时候，里面有百分号，表示百分之几，需要两个百分号转义
msg1 = '我叫%s，今年%s岁，学习进度3%%' % ("alnk", 18)
print(msg1)

# format 格式化输出
# 第一种
msg = '我叫{} 今年{} 性别{}'.format('tom', '18', '男')
print(msg)

# 第二种
msg = '我叫{0} 今年{1} 性别{2}，我依然叫{0}'.format('tom', '18', '男')
print(msg)

# # 第三种
msg = '我叫{name} 今年{age} 性别{sex}'.format(name='tom', sex='男', age='18',)
print(msg)

运算符

#!/usr/bin/env python3
# author:Alnk(李成果)

"""
运算符：
    算数运算，逻辑运算，赋值运算，比较运算，位运算，成员运算，身份运算...
    算数运算：+ - * /  **  //  %
    比较运算: == < > >= <=  !=
    赋值运算: = += -= *= /= ....
    逻辑运算: and or not
"""

# 一、逻辑运算: and or not
# 优先级：() > not > and > or ,同一优先级从左至右依次计算
# 1,运算符两边全部是比较运算
print(1 > 2 and 3 < 4 and 2 > 7 or 4 < 5)  # True
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)  # False

# 2,运算符两边全部是数值
# x or y: if x is True return x else y
print("-" * 20)
print(1 or 3)  # 1
print(2 or 3)  # 2
print(-1 or 3)  # -1
print(0 or 3)  # 3
print(1 or 3 or 0 or -1)  # 1

# x and y: 和上面相反 if x is True return y else x
print("-" * 20)
print(1 and 3)  # 3
print(2 and 3)  # 3
print(-1 and 3)  # 3
print(0 and 3)  # 0

# int ---> bool: 非0即True，0即False
# int ---> bool: True  1，False  0
print("-" * 20)
i = 0
print(bool(i))  # False
print(int(True))  # 1
print(int(False))  # 0

# 3,运算符两边即是比较又是数值
print("-" * 20)
print(1 > 2 or 3 and 4)  # 4

# 二、成员运算：in、not in
print("-" * 20)
s1 = "abcde"
s2 = 'ac'
print(s2 in s1)  # False

if s2 in s1:
    print(333)
else:
    print(111)  # 111

编码

#!/usr/bin/env python3
# author:Alnk(李成果)

"""
谍战剧： 场景 发电报 滴滴滴滴滴滴滴
    计算机：文件的存储或者网络传输 高低电平01010101
    密码本：记录的就是010101 与文字的对应关系。
        今       0000001
        晚       0000101
        吃       0000110
        鸡       0010001

        # 0010101011010001
        0000001000010100001100010001

    ASCII：最初版本的密码本：英文字母，数字，特殊字符

        最开始：
            0000 0001   256种可能。
            0000 0001  8位 = 1个字节（bytes）。
            s1 = 'hello1' 6个字节
            一个字节表示一个字符。
            h: 01101000
            e: 01101001
            l: 01101100
            o: 01101110
            1:
            01101000 01101001 01101100 01101100 01101110 01101111

    unicode：万国码。把全世界所有的文字都记录起来。
        起初：一个字符两个字节
            h: 01101000 01101000
            中：01101000 01101000
            不够用
        升级：一个字符四个字节
            h: 01101000 01101000 01101000 01101000
            中: 01111000 01101000 01101000 01101000
        浪费空间，浪费流量

    utf-8: 最少用8位一个字节表示一个字符。
        英文: 01101000 ASCII 英文字符：1个字节表示
        欧洲文: 01101000 01101000 一个字符两个字节表示
        中文: 01101000 01101100 01101000 一个字符用3个字节表示。
        'old男孩' utf-8的编码方式： 9个字节

    gbk:国标。
        只包含：英文和本国语言。
         h: 01101000 ASCII 英文字符：1个字节表示
         中: 01101000 01101100 一个字符用2个字节表示
         'old男孩' gbk的编码方式： 7个字节

    单位转化：
        8bit  ==   1Bytes
        1024Bytes ==  1KB
        1024KB    ==  1MB
        1024MB    ==  1GB
        1024GB    ==  1TB
"""

# 1， 不同密码本之间不能互相识别。报错，乱码。
# 2， 数据的存储或者网络传输不能用unicode的密码本进行编码。
#
# python3x 环境：
#         str类型内部编码方式为Unicode。
#         所以：str类数据不能直接存储硬盘，或者网络传输。
#
#       str: 操作方法
#       bytes: 拥有和str相同的操作方式，并且编码为非Unicode
#
# 英文：
#     str:
#         表现形式：'alex'
#         内部编码：unicode
#
#     bytes:
#         表现形式：b'alex'
#         内部编码：非unicode
#
# 中：
#     str:
#         表现形式：'alex'
#         内部编码：unicode
#
#     bytes:
#         表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'
#         内部编码：非unicode

#
# 英文
print("---------------英文------------------")
str1 = 'barry'  # 字符串
print(type(str1))  # <class 'str'>
print(str1.upper())
# bytes
b1 = b'barry'  # bytes字节
print(type(b1))  # <class 'bytes'>
print(b1.upper())

# 中文
print("---------------中文------------------")
s1 = '中国'
print(type(s1))  # <class 'str'>
b1 = s1.encode('utf-8')  # 编码
print(type(b1))  # <class 'bytes'>
print(b1)  # bytes

# 转换；
# str  ---> bytes
print("------------- str ---> bytes -----------")
ss1 = "abc"
print(type(ss1))  # <class 'str'>
ss2 = ss1.encode("utf-8")
print(type(ss2))  # <class 'bytes'>

# unicode ---> utf-8
print("------------- unicode ---> utf-8 -----------")
s1 = '中国'
b1 = s1.encode('utf-8')  # 编码
print(b1)
print(type(b1))  # <class 'bytes'>

# utf-8 ---> unicode
print("------------- utf-8 ---> unicode -----------")
s2 = b1.decode('utf-8')  # 解码
print(s2)
print(type(s2))  # <class 'str'>

# gbk
print("------------- gbk  -----------")
s1 = '中央'
b1 = s1.encode('gbk')  # 编码
print(b1)

# utf-8 ----> unicode
s2 = b1.decode('gbk')  # 解码
print(s2)

# gbk ---> utf-8
print("-------------- gbk ---> utf-8 ----------")
b1 = b'\xd6\xd0\xb9\xfa'  # 中国 这个字符串的的gbk编码
s1 = b1.decode('gbk')  # gbk ---> Unicode
print(s1)  # 中国
print(type(s1))  # <class 'str'>
b2 = s1.encode('utf-8')  # Unicode ---> bytes
print(b2)
print(type(b2))  # <class 'bytes'>

基础数据类型转化

#!/usr/bin/env python3
# author:Alnk(李成果)

"""
bool <---> int
str  <--->  int
    s1 = '100'  全部由数字组成的str ---> int
    int(s1)
    str(100)
str  <--->  bool  非空即True   '' 空即False

"""

print("-------- bool <---> int ------------ ")
print(int(True))  # 1
print(int(False))  # 0
print(bool(1))  # True 非零为True
print(bool(-1))  # True
print(bool(0))  # False

print("-------- str  <--->  int ------------ ")
print(int("100"))  # 100
# print(int("a"))  # 会报错
print(str(100))  # 100

print("-------- str  <--->  bool ------------ ")
print(bool("a"))  # True 非空为true
print(bool(""))  # False

字符串str

#!/usr/bin/env python3
# author:Alnk(李成果)
# 字符串常用操作方法
# 对字符串进行的任何操作都会形成一个新字符串，与原字符串无关

# 索引
print("-------------- 字符串索引 --------------")
s1 = 'python中国'
s2 = s1[0]
print(s2, type(s2))
s3 = s1[2]
print(s3)
print(s1[-1])

# 切片：顾首不顾尾
print("-------------- 字符串切片 --------------")
s4 = s1[0:6]
print(s4)
s8 = s1[:6]
print(s8)
s5 = s1[2:6]
print(s5)
s6 = s1[:]
print(s6)

# 切片+步长 [起始索引: 结尾索引: 步长]
s7 = s1[:5:2]
print(s7)

# 反着取值（反向步长）
print(s1[-1:-4:-1])
print(s1[-3::1])
print(s1[-3::-1])

# upper lower
# upper 全大写
# lower 全小写
print("----------------- upper 和 lower ------------------")
s1 = 'aLNk'
s2 = s1.lower()
print(s2)
print(s1)
s3 = s1.upper()
print(s3)

# 例子
# username = input('请输入用户名>>>:')
# password = input('请输入密码>>>:')
# code = 'afREd'.upper()
# your_code = input('请输入验证码>>>:').upper()
# if code == your_code:
#     if username == 'tom' and password == '123':
#         print('登录成功')
# else:
#     print('验证码错误')

# strip
# 默认(指定)去除字符串两边的换行符，制表符，空格。
# lstrip  rstrip
print("----------------- strip ------------------")
s1 = ' \talnk\n'
print(s1)
print(s1.strip())

s2 = 'reaeareelexqw'
print(s2.strip('qwer'))  # aeareelex

s3 = '   alnk   '
print(s3.lstrip())
print(s3.rstrip())

# 例子
# username = input('请输入用户名').strip()
# password = input('请输入密码').strip()
# if username == 'tom' and password == '123':
#     print('登录成功')

# find index
# find  通过元素找索引，找到第一个则返回，找不到返回-1
# index 通过元素找索引，找到第一个则返回，找不到则报错
print("---------------- find 和 index -----------------")
s1 = '深圳南山pythonon中国'
i = s1.find('w')
print(i)  # -1
i = s1.find('中')
print(i)  # 12
# i = s1.index('w')  # 会报错
# print(i)
i = s1.index('p')
print(i)  # 4

# startswith endswith
# startswith 判断以...为开始
# endswith 判断以...为结尾
print("---------------- startswith 和 endswith -----------------")
s1 = '中国ChinaChina'
print(s1.startswith("中"))  # True
print(s1.startswith("C", 2, 7))  # True
print(s1.startswith("bb", 2, 5))  # False
print(s1.endswith("ba", 2, 5))  # False
print(s1.endswith('na'))  # True

# split
# split 默认(可指定分隔符)以空格为分割，返回一个列表。
# str ----> list
print("---------------- split -----------------")
s1 = 'alnk tom 深圳 广东'
s11 = ':alnk:tom:深圳:广东'
s12 = 'alnk:tom:深圳:广东'
l1 = s1.split()
print(l1)  # ['alnk', 'tom', '深圳', '广东']

l2 = s11.split(':')
print(l2)  # ['', 'alnk', 'tom', '深圳', '广东']

# 指定分隔次数
l3 = s12.split(':', 1)
print(l3)  # ['alnk', 'tom:深圳:广东']

# join
# join 可以操作任何数据类型（由多个对象组成即可），并不止字符串
print("---------------- join -----------------")
s1 = 'alnk'
s2 = '_'.join(s1)
print(s2)
s2 = '*'.join(s1)
print(s2)

# 列表拼接
# 前提条件：此列表必须全部是有字符串元素组成
l1 = ['alnk', 'tom', '深圳', '广东']
s2 = ' '.join(l1)
print(s2)
s3 = '*'.join(l1)
print(s3)

# replace
# replace  默认全部替换 也可以设置替换次数
print("---------------- replace -----------------")
s1 = 'python深圳 深圳是一个很美丽的城市，我爱深圳'
s2 = s1.replace('深圳', '北京')
print(s2)
s2 = s1.replace('深圳', '北京', 1)
print(s2)

# count
# count  计算某个元素出现的次数
print("---------------- count -----------------")
s1 = 'barryafdfdafdaaa'
i = s1.count('a')
print(i)

# is 系列
print("---------------- is 系列 -----------------")
name = 'alnk123'
print(name.isalnum())  # 字符串由字母或数字组成 True
print(name.isalpha())  # 字符串只由字母组成 False
print(name.isdigit())  # 字符串只由数字组成 False

# len 内置函数,统计字符串长度
print("---------------- len -----------------")
s1 = 'fjdsklfsjafldsfjskladfjsladfjldksa'
print(len(s1))

for循环

#!/usr/bin/env python3
# author:Alnk(李成果)
# for 循环

s1 = 'python中国'
count = 0
while count < len(s1):
    print(s1[count])
    count += 1
print("-------------- 分隔符 -------------------")

# for 变量 in iterable:
#     pass
for i in s1:
    print(i, type(i))

print("-------------- 分隔符 -------------------")

for i in s1:
    print(i + 'nb')

列表

#!/usr/bin/env python3
# author:Alnk(李成果)
# 列表 list
# 容器类的数据类型：基础数据类型之一 list
# 列表可以存储大量的数据，列表是有序的
# 列表有索引，切片，切片（步长）

# 索引，切片
print("------------- 列表的索引和切片 --------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
print(l1[0], type(l1[0]))  # 100 <class 'int'>
print(l1[-2])  # True
# 顾首不顾尾
print(l1[:3])  # [100, 'tom', True]

# 增删改查其他操作
print("------------- 列表增删改查 --------------------")

# 增
print("------------- 增 --------------------")
l1 = ['tom', 'jerry', '深圳', '广东', '南山']
# append 追加
l1.append("666")
print(l1)  # ['tom', 'jerry', '深圳', '广东', '南山', '666']

# insert插入
l1.insert(1,'lilei')
print(l1)  # ['tom', 'lilei', 'jerry', '深圳', '广东', '南山', '666']
# extend 迭代着追加，增加多个（拆解成最小的元素追加到列表最后）
l1.extend('abc')
print(l1)  # ['tom', 'lilei', 'jerry', '深圳', '广东', '南山', '666', 'a', 'b', 'c']
l1.extend([1,2,3])
print(l1)  # ['tom', 'lilei', 'jerry', '深圳', '广东', '南山', '666', 'a', 'b', 'c', 1, 2, 3]

# 删
print("------------- 删 --------------------")
l1 = [100, 'tom', True, [1, 2, 3]]

# pop 按照索引删除 有返回值，如果不加索引，默认删除最后一个元素
ret = l1.pop(-1)
print(ret)  # [1, 2, 3]

# remove  按照元素删除
l1.remove('tom')
print(l1)  # [100, True]

# clear清空列表
l1.clear()
print(l1)  # []

# del从内存中删除整个列表，或者按照索引删除单个元素，多个元素
l1 = [100, 'tom', True, [1, 2, 3]]
del l1[0]  # 按照索引删除
del l1[:2] # 按照切片删除
del l1
# print(l1)  # 会报错

# 改
print("------------- 改 --------------------")
# 按照索引改值
l1 = [100, 'tom', True, [1, 2, 3]]
l1[1] = 'sb'
print(l1)  # [100, 'sb', True, [1, 2, 3]]
# 按照切片改值
l1[:3] = 'abcd'
print(l1)  # ['a', 'b', 'c', 'd', [1, 2, 3]]

# 查：可以索引切片 for循环
print("------------- 查 ------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
for i in l1:
    print(i)

# 其他操作方法
print("------------- 其他操作方法 ------------------")
l1 = [100, 'tom', True, [1, 2, 3]]
print(len(l1))  # 元素个数 4
# count 次数
ret = l1.count('tom')
print(ret)  # 1

# index 通过元素找索引，找不到报错
print("------------- index ------------------")
l1 = [100, 'tom', 'a', True, [1, 2, 3]]
ret = l1.index('a')
print(ret)  # 2

# sort 排序
print("------------- sort ------------------")
l2 = [5, 6, 4, 0, 9, 1, 7, 8]
l2.sort()  # 从小到大
print(l2)  # [0, 1, 4, 5, 6, 7, 8, 9]
l2.sort(reverse=True)  # 从大到小
print(l2)  # [9, 8, 7, 6, 5, 4, 1, 0]
l2.reverse()  # 翻转
print(l2)

# 列表的嵌套
print("---------------- 列表的嵌套 ----------------")
l1 = [1, 2, 'jerry', [1, 'tom', 3, ]]
# 1, 将l1中的'jerry'变成大写并放回原处
# 2，给小列表[1,'tom',3,]追加一个元素,'中国'
# 3，将列表中的'tom'通过字符串拼接的方式在列表中变成'tomsb'
# 1
l1[2] = l1[2].upper()
print(l1)  # [1, 2, 'TAIBAI', [1, 'alex', 3]]
# 2
l1[3].append("中国")
print(l1)  # [1, 2, 'JERRY', [1, 'tom', 3, '中国']]
# 3
# l1[3][1] = l1[3][1] + "sb"
# print(l1)  # [1, 2, 'JERRY', [1, 'tomsb', 3, '中国']]
# 3
l1[3][1] = "tomsb"
print(l1)

# range 可以视为一个可控的数字范围的列表，多与for循环结合
print("------------------ range ----------------")
for i in range(1,10):  # [1,2,3,4,...9]
    print(i)

for i in range(20):  # [0,1,2,3,4,...19]
    print(i)

for i in range(1,10,2):  # [1,2,3,4,...9]
    print(i)

print(range(10))

# 倒着取值 顾首不顾尾
print("--------------------------------")
for i in range(10, 1, -1):
    print(i)

# range 打印列表的索引
print("--------------------------------")
l1 = ['tom', 'jerry', '中国','广东', '深圳']
for index in range(len(l1)):
    print(index)

print("--------------------------------")
for i in l1:
    print(i)

元组

#!/usr/bin/env python3
# author:Alnk(李成果)

# 元组 tuple 基础数据类型之一
# 存储数据，重要的数据。

tu1 = (100, True, [1, 2, 3])
# 元组没有增删改，可以查询
for i in tu1:
    print(i)

# 元组也有索引切片
print(tu1[0])

# 元组里面的列表是可以更改的
tu1 = (100, True, [1, 2, 3])
tu1[-1].append(666)
print(tu1)

# 补充
# tuple
# 元组中如果只有一个元素且没有逗号（那他不是元组），则与该元素数据类型相同。
tu1 = (1)
tu2 = ('tome')
print(tu1, type(tu1))  # 1 <class 'int'>
print(tu2, type(tu2))  # tome <class 'str'>

字典

#!/usr/bin/env python3
# author:Alnk(李成果)

"""
列表的不足
    1 列表的数据量越大，查询速度越慢
    2 列表存储的数据没有什么关联性

基础数据类型 字典dict
    dic = {'name': 'tom'}
    字典是以键值对的形式存储的

数据类型的划分：
    可变的（不可哈希）数据类型：list dict set
    不可变（可哈希）的数据类型：tuple str int bool

字典的键key：必须是不可变得数据类型：int str
字典的值：任意数据类型 变量，对象
字典可以存储大量的数据，而且字典的查询速度非常快
字典的key 唯一的不重复的

字典 3.5之前是无序的
字典在3.5之后是有序的 初始化时的顺序

构建数据类型：大量的关系型数据时，要想到字典
"""

# 增：
# 有则修改，无则增加
print("------------------- 增 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
dic['high'] = 175
print(dic)  # {'name': 'tom', 'age': 18, 'sex': 'boy', 'high': 175}
dic['name'] = '日天'
print(dic)  # {'name': '日天', 'age': 18, 'sex': 'boy', 'high': 175}

# 有则不变，无则增加
dic.setdefault('weight',200)
print(dic)  # {'name': '日天', 'age': 18, 'sex': 'boy', 'high': 175, 'weight': 200}
dic.setdefault('age',73)
print(dic)  # {'name': '日天', 'age': 18, 'sex': 'boy', 'high': 175, 'weight': 200}

# 删除
# pop 按照key删除键值对,有返回值
print("------------------- 删 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
ret = dic.pop('name')
print(ret)  # tom
print(dic)  # {'age': 18, 'sex': 'boy'}

# clear 清空字典
dic.clear()
print(dic)  # {}

# del 删除整个字典或者某个键值对
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
del dic
# print(dic)

dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
del dic['name']

# 改
print("------------------- 改 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
dic['name'] = '日天'
print(dic)  # {'name': '日天', 'age': 18, 'sex': 'boy'}

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"tom","weight":75}
dic2.update(dic)   # 将dic的键值对覆盖添加到dic2中，dic不变。
print(dic2)  # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
print(dic)  # {'name': 'jin', 'age': 18, 'sex': 'male'}

# 查
print("------------------- 查 --------------------------")
dic = {'name': 'tom', 'age': 18, 'sex': 'boy'}
print(dic['name'])  # tom
# print(dic['name1'])  # 报错
ret = dic.get('name')
print(ret)  # tom
ret = dic.get('name1')
print(ret)  # None
ret = dic.get('name1', '没有此键')
print(ret)  # 没有此键

for i in dic:
    print(i,dic[i])

# 其他方法：
# dic.keys() dic.values() dic.items()
print(dic.keys(),type(dic.keys()))  # dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>

for key in dic.keys():
    print(key,type(key))

print("------------------------- 1 -------------------")

for v in dic.values():
    print(v)

print("------------------------ 2 --------------------")
print(list(dic.items()))  # [('name', 'tom'), ('age', 18), ('sex', 'boy')]

# 分别赋值
print("-------------------- 分别赋值 -------------------------")
a, b = 1, 4
print(a,b)  # 1 4

a, b = (1,4)
print(a, b, type(a))  # 1 4 <class 'int'>

a, b = [[1,2,3],'tom']
print(a,b)  # [1, 2, 3] tom

# 嵌套
print("-------------------- 嵌套 -------------------------")
dic = {
    'name_list': ['张三', '李四', 'TOM'],
    1:{'name':'TOM', 'age': 18},
    'TOM': {}
}
# 1，给列表追加一个值：'王五'
# dic['name_list'].append('王五')
# print(dic)  # {'name_list': ['张三', '李四', 'TOM', '王五'], 1: {'name': 'TOM', 'age': 18}, 'TOM': {}}

# 2，将 列表中的TOM 变成小写
# print(dic['name_list'][-1].lower())  # tom
# dic['name_list'][-1] = dic['name_list'][-1].lower()
# print(dic)  # {'name_list': ['张三', '李四', 'tom'], 1: {'name': 'TOM', 'age': 18}, 'TOM': {}}

# 3，给{'name':'TOM', 'age': 18} 增加一个键值对 sex: 男。
print(dic[1])
dic[1]['sex'] = '男'
print(dic)  # {'name_list': ['张三', '李四', 'TOM'], 1: {'name': 'TOM', 'age': 18, 'sex': '男'}, 'TOM': {}}

基础数据类型练习

#!/usr/bin/env python3
# author:Alnk(李成果)

# int str bool list tuple dict
# 数据类型的转换。
# str ————> list split
# list ————> str join

# list tuple
# tuple ---> list
print(list((1, 2, 3, 'alex')))

# list ---> tuple
print(tuple([1, 2, 3, 'alex']))

# dict ---> list
dic = {"name": "jin", "age": 18, "sex": "male"}
print(list(dic))

# list
l1 = [11, 22, 33, 44, 55]
# 将列表中索引为奇数位的元素删除
# 正常思路（错误示范）元素会左移
# 对于列表来说，你在循环一个列表时，不要改变列表的大小，会影响你的最终结果
# for index in range(len(l1)):
#     if index % 2 == 1:
#         del l1[index]
# print(l1)

# 方法一：
del l1[1::2]
print(l1)

# 字典
# 将字典的键中含有k元素的所有键值对删除
dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'name': 'tom'}

# 错误示范
# for key in dic:
#     if 'k' in key:
#         dic.pop(key)
# print(dic)

# 满足条件的key添加到一个新列表中，循环列表删除相应的键值对。
l1 = []
for key in dic:
    if 'k' in key:
        l1.append(key)
print(l1)
for i in l1:
    dic.pop(i)
print(dic)

练习题1

#!/usr/bin/env python3
# author:Alnk(李成果)

# 1、有变量name = "aleX leNb " 完成如下操作
name = "aleX leNb"

# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())

# 2) 移除name变量左边的"al"并输出处理结果
print(name.lstrip('al'))

# 3) 移除name变量右面的"Nb",并输出处理结果
print(name.rstrip('Nb'))

# 4) 移除name变量开头的a"与最后的"b",并输出处理结果
print(name.strip('ab'))

# 5) 判断 name 变量是否以 "al" 开头,并输出结果
print(name.startswith('al'))

# 6) 判断name变量是否以"Nb"结尾,并输出结果
print(name.endswith('Nb'))

# 7) 将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果
print(name.replace('l', 'p'))

# 8) 将name变量对应的值中的第一个"l"替换成"p",并输出结果
print(name.replace('l', 'p', 1))

# 9) 将 name 变量对应的值根据 所有的"l" 分割,并输出结果。
print(name.split('l'))

# 10) 将name变量对应的值根据第一个"l"分割,并输出结果。
print(name.split('l', 1))

# 11) 将 name 变量对应的值变大写,并输出结果
print(name.upper())

# 12) 将 name 变量对应的值变小写,并输出结果
print(name.lower())

# 13) 将name变量对应的值首字母"a"大写,并输出结果
print(name.capitalize())

# 14) 判断name变量对应的值字母"l"出现几次，并输出结果
print(name.count('l'))

# 15) 如果判断name变量对应的值前四位"l"出现几次,并输出结果
print(name.count('l', 0, 5))

# 16) 从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
print(name.index('N'))

# 17) 从name变量对应的值中找到"N"对应的索引(如果找不到则返回‐1)输出结果
print(name.find('N'))

# 18) 从name变量对应的值中找到"X le"对应的索引,并输出结果
print(name.find("X le"))

# 19) 请输出 name 变量对应的值的第 2 个字符?
print(name[1])

# 20) 请输出 name 变量对应的值的前 3 个字符?
print(name[:3])

# 21) 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])

# 22) 请输出 name 变量对应的值中所有 "e" 所在索引位置?
l1 = []
for i in range(len(name)):
    if name[i] == 'e':
        l1.append(i)
print(l1)
print("-" * 20)

# 2、有字符串s = "123a4b5c"
s = "123a4b5c"
# 1)通过对s切片形成新的字符串s1,s1 = "123"
s1 = s[:3]
print(s1)

# 2)通过对s切片形成新的字符串s2,s2 = "a4b"
s2 = s[3:6]
print(s2)

# 3)通过对s切片形成新的字符串s3,s3 = "1345"
s3 = s[::2]
print(s3)

# 4)通过对s切片形成字符串s4,s4 = "2ab"
s4 = s[1:-2:2]
print(s4)

# 5)通过对s切片形成字符串s5,s5 = "c"
s5 = s[-1]
print(s5)

# 6)通过对s切片形成字符串s6,s6 = "ba2"
s6 = s[-3::-2]
print(s6)
print("-" * 20)

# 3、使用while或for循环分别打印字符串s="asdfer"中每个元素。
s = "asdfer"
for i in s:
    print(i)
print("-" * 20)

count = 0
while count < len(s):
    print(s[count])
    count += 1
print("-" * 20)

# 4、使用for循环对s="asdfer"进行循环，但是每次打印的内容都是"asdfer"
s = "asdfer"
for i in s:
    print(s)
print("-" * 20)

# 5、使用for循环对s="abcdefg"进行循环，每次打印的内容是每个字符加上sb， 例如：asb, bsb，csb,...gsb
s = "abcdefg"
for i in s:
    print(i + 'sb')
print("-" * 20)

# 6、使用for循环对s="321"进行循环，打印的内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"，"出发！"
s= "321"
for i in s:
    print("倒计时%s秒" % (i))
print("出发！")
print("-" * 20)

# 7、实现一个整数加法计算器(两个数相加)：
# 如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9，然后进行分割再进行计算。
content = input("请输入内容：")
content = content.replace(' ','')
content_list = content.split('+')
sum = int(content_list[0]) + int(content_list[1])
print(sum)
print("-" * 20)

# 8、升级题：实现一个整数加法计算器（多个数相加）：
# 如：content = input("请输入内容:") 用户输入：5+9+6 +12+ 13，然后进行分割再进行计算
content = input("请输入内容：")
content = content.replace(' ', '')
content_list = content.split('+')
sum = 0
for i in content_list:
    sum = sum + int(i)
print(sum)
print("-" * 20)

# 9、计算用户输入的内容中有几个整数（以个位数为单位）
# 如：content = input("请输入内容：") # 如fhdal234slfh98769fjdla
content = input("请输入内容：")
sum = 0
for i in content:
    if i.isdigit():
       sum += 1
print(sum)

# 10、写代码，完成下列需
# 用户可持续输入（用while循环），用户使用的情况：
    # 输入A，则显示走大路回家，然后在让用户进一步选择：
        # 是选择公交车，还是步行？
            # 选择公交车，显示10分钟到家，并退出整个程序。
            # 选择步行，显示20分钟到家，并退出整个程序。
    # 输入B，则显示走小路回家，并退出整个程序。
    # 输入C，则显示绕道回家，然后在让用户进一步选择：
        # 是选择游戏厅玩会，还是网吧？
            # 选择游戏厅，则显示 ‘一个半小时到家，爸爸在家，拿棍等你。’并让其重新输入A，B,C选项。
            # 选择网吧，则显示‘两个小时到家，妈妈已做好了战斗准备。’并让其重新输入A，B,C选项。
flag = True
while flag:
    user_choice1 = input("请输入A or B or C:")
    if user_choice1.upper() == "A":
        print("走大路回家")
        while flag:
            user_choice2 = input("\t公交车回家输入1，步行回家输入2:")
            if user_choice2 == "1":
                print("10分钟到家")
                flag = False
            elif user_choice2 == "2":
                print("20分钟到家")
                flag = False
            else:
                print("输入有误哦，请重新输入")
                continue

    elif user_choice1.upper() == "B":
        print("走小路回家")
        flag = False

    elif user_choice1.upper() == "C":
        print("绕道回家")
        while flag:
            user_choice3 = input("\t游戏厅输入1，网吧输入2:")
            if user_choice3 == "1":
                print("一个半小时到家，爸爸在家，拿棍等你\n")
                break
            elif user_choice3 == "2":
                print("两个小时到家，妈妈已做好了战斗准备\n")
                break
            else:
                print("输入有误哦，请重新输入")
                continue

    else:
        print("只能输入A或B或C哦")
print("-" * 20)

# 11、写代码：计算 1 - 2 + 3 ... + 99 中除了88以外所有数的总和？
# 方法1
odd_sum = 0
even_sum = 0
count = 1
while count < 100:
    if count % 2 == 1:
        odd_sum = odd_sum + count
    elif count % 2 == 0:
        if count == 88:
            pass
        else:
            even_sum = even_sum + count
    count = count + 1
print("总和为:",odd_sum - even_sum)

# 方法2
sum = 0
count = 0
while count < 99:
    count += 1

    if count == 88:
        count +=1

    if count % 2 == 0:
        sum = sum - count
    else:
        sum = sum + count
print(sum)
print("-" * 20)

# 16、制作趣味模板程序需求：等待用户输入名字、地点、爱好、根据用户的名字和爱好进行任意实现
# 如：敬爱可亲的xxx，最喜欢在xxx地进行xxx
name = input("姓名:")
addr = input("地点:")
hobby = input("爱好:")
msg = '敬爱可亲的[%s]，最喜欢在[%s]地进行[%s]' % (name,addr,hobby)
print(msg)
print("-" * 20)

# 17、等待用户输入内容，检测用户输入内容中是否包含敏感字符？如果存在敏感字符提示"存在敏感字符请重新输入"
# 并允许用户重新输入并打印。敏感字符："粉嫩"、"铁锤"
flag = True
while flag:
    user_str = input("请输入内容:")
    if "粉嫩" in user_str.replace(' ','') or "铁锤" in user_str.replace(' ',''):
        print("存在敏感字符请重新输入")
        continue
    else:
        print(user_str)
        flag = False
print("-" * 20)

# 18、写代码，有如下列表，按照要求实现每一个功能
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
# 1)计算列表的长度并输出
print(len(li))

# 2)列表中追加元素"seven",并输出添加后的列表
li.append('seven')
print(li)

# 3)请在列表的第1个位置插入元素"Tony",并输出添加后的列表
li.insert(1,'Tony')
print(li)

# 4)请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
li[1] = 'Kelly'
print(li)

# 5)请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
l2 = [1,"a",3,4,"heart"]
li.extend(l2)
print(li)

# 6)请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
s = "qwert"
li.extend(s)
print(li)

# 7)请删除列表中的元素"barry",并输出添加后的列表
li.remove('barry')
print(li)

# 8)请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
li.pop(1)
print(li)

# 9)请删除列表中的第2至4个元素，并输出删除元素后的列表
del li[1:4]
print(li)

# 10)请将列表所有得元素反转，并输出反转后的列表
li.reverse()
print(li)

# 11)请计算出"alex"元素在列表li中出现的次数，并输出该次数。
print(li.count('alex'))
print("-" * 30)

# 19、写代码，有如下列表，利用切片实现每一个功能
li = [1, 3, 2, "a", 4, "b", 5,"c"]
# 1)通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
l1 = li[:3]
print(l1)

# 2)通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
l2 = li[3:6]
print(l2)

# 3)通过对li列表的切片形成新的列表l3,l3 = [1,2,4,5]
l3 = li[::2]
print(l3)

# 4)通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
l4 = li[1:-1:2]
print(l4)

# 5)通过对li列表的切片形成新的列表l5,l5 = ["c"]
l5 = li[-1]
print(l5)

# 6)通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
l6 = li[-3::-2]
print(l6)
print("-" * 30)

# 20、写代码，有如下列表，按照要求实现每一个功能。
# lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 1)将列表lis中的"tt"变成大写（用两种方式）
# 方法1
lis[3][2][1][0] = lis[3][2][1][0].upper()
print(lis)
# 方法2
lis[3][2][1][0] = 'TT'
print(lis)

# 2)将列表中的数字3变成字符串"100"（用两种方式）
# 方法1
lis[1] = '100'
lis[3][2][1][1] = '100'
print(lis)
# 方法2 脑洞开大一点就行了
lis[1] = str(lis[1] + 97)
print(lis)

# 3)将列表中的字符串"1"变成数字101（用两种方式）
# 方法1
lis[3][2][1][2] = '101'
print(lis)
print("-" * 30)

# 21、请用代码实现
# 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
li = ["alex", "eric", "rain"]
s1 = '_'.join(li)
print(s1)
print("-" * 30)

# 22、利用for循环和range打印出下面列表的索引。
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
for index in range(len(li)):
    print(index)
print("-" * 30)

# 23、利用for循环和range找出100以内所有的偶数并将这些偶数插入到一个新列表中。
l1 = []
for i in range(101):
    if i % 2 == 0:
        l1.append(i)
print(l1)
print("-" * 30)

# 24、利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中。
l1 = []
for i in range(51):
    if i % 3 ==0:
        l1.append(i)
print(l1)
print("-" * 30)

# 25、利用for循环和range从100~1，倒序打印。
for i in range(100,0,-1):
    print(i)
print("-" * 30)

# 26、利用for循环和range从100~10，倒序将所有的偶数添加到一个新列表中，
# 然后对列表的元素进行筛选，将能被4整除的数留下来
l1 = []
for i in range(100,9,-1):
    if i % 2 == 0:
        l1.append(i)

l2 = []
for i in l1:
    if i % 4 ==0:
        l2.append(i)
print(l2)
print("-" * 30)

# 26、利用for循环和range，将1-30的数字依次添加到一个列表中，并循环这个列表，将能被3整除的数改成*。
l1 = []
for i in range(1,31):
    l1.append(i)
print(l1)

l2 = []
for i in l1:
    if i % 3 == 0:
        l2.append('*')
    else:
        l2.append(i)
print(l2)
print("-" * 30)

# 27、查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头，并以"c"结尾的所有元素，
# 并添加到一个新列表中,最后循环打印这个新列表。
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
new_li = []
for i in li:
    if i.strip().lower().startswith('a') and i.strip().endswith('c'):
        new_li.append(i.strip())

print('新列表:',new_li)
print("-" * 30)

# 28、开发敏感词语过滤程序，提示用户输入评论内容，如果用户输入的内容中包含特殊的字符：
# 敏感词列表 li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
# 则将用户输入的内容中的敏感词汇替换成等长度的*（苍老师就替换***），并添加到一个列表中；
# 如果用户输入的内容没有敏感词汇，则直接添加到上述的列表中
li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
new_li = []

user_comm = input("请输入评论内容:")
for i in li:
    while i in user_comm:
        user_comm = user_comm.replace(i,(len(i) * "*"))

new_li.append(user_comm)
print(new_li)
print("-" * 30)

# 29、有如下变量（tu是个元祖），请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# a. 讲述元祖的特性
# 元组是基础的数据类型之一，它不可以增，删，改，但是可以查询，也可以索引切片

# b. 请问tu变量中的第一个元素 "alex" 是否可被修改？
# 不能被修改

# c. 请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素"Seven"
# k2 对应的值是一个列表，可以被修改。
tu[1][2]['k2'].append('Seven')
print(tu)

# d. 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素"Seven"
# k3 对应的值是一个元组，不能修改
print("-" * 30)

# 30、字典dic
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
# a. 请循环输出所有的key
for k in dic:
    print(k)

# b. 请循环输出所有的value
for v in dic.values():
    print(v)

# c. 请循环输出所有的key和value
for k,v in dic.items():
    print(k,v)

# d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4'] = 'v4'
print(dic)

# e. 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
dic['k1'] = 'alex'
print(dic)

# f. 请在k3对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)

# g. 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,18)
print(dic)
print("-" * 30)

# 31、如下
av_catalog = {
    "欧美":{
            "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
            "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
            "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
            "x‐art.com":["质量很高,真的很高","全部收费,屌丝请绕过"]
    },
    "日韩":{
            "tokyo‐hot":["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]
    },
    "大陆":{
            "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    },
}

# a,给此 ["很多免费的,世界最大的","质量一般"]列表第二个位置插入一个 元素：'量很大'。
av_catalog['欧美']["www.youporn.com"].insert(1,'量很大')
print(av_catalog)

# b,将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。
av_catalog['欧美']["x‐art.com"].remove("全部收费,屌丝请绕过")
print(av_catalog)

# c,将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。
av_catalog['欧美']["x‐art.com"].remove("全部收费,屌丝请绕过")
print(av_catalog)

# d,将此["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]列表的 "verygood"全部变成大写。
av_catalog["日韩"]["tokyo‐hot"][1] = av_catalog["日韩"]["tokyo‐hot"][1].upper()
print(av_catalog)

# e,给 '大陆' 对应的字典添加一个键值对 '1048' :['一天就封了']
av_catalog["大陆"]['1048'] = ['一天就封了']
print(av_catalog)

# f,删除此"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"]键值对。
del av_catalog["欧美"]["letmedothistoyou.com"]
print(av_catalog)

# g,给此["全部免费,真好,好人一生平安","服务器在国外,慢"]列表的第一个元素，加上一句话：'可以爬下来'
av_catalog["大陆"]["1024"].insert(0,'可以爬下来')
print(av_catalog)
print("-" * 30)

# 32、有字符串"k:1|k1:2|k2:3|k3:4" 处理成字典 {'k':1,'k1':2....}
s = "k:1|k1:2|k2:3|k3:4"
l1 = s.split('|')
dic = {}
for i in l1:
    k,v = i.split(':')
    dic[k] = v
print(dic)
print("-" * 30)

# 33、元素分类
# 有如下值li= [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于66 的值保存至第二个key的值中。
# 即： {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表}
li= [11,22,33,44,55,66,77,88,99,90]
dic = {'k1':[],'k2':[]}
for i in li:
    if i > 66:
        dic['k1'].append(i)
    elif i < 66:
        dic['k2'].append(i)
print(dic)

练习题2

#!/usr/bin/env python3
# author:Alnk(李成果)

"""
需求:
1. 用户先给自己的账户充钱：比如先充3000元
2. 页面显示 序号 + 商品名称 + 商品价格，如：
    1 电脑 1999
    2 鼠标 10
    …
    n 购物车结算
3. 用户输入选择的商品序号，然后打印商品名称及商品价格,并将此商品，添加到购物车，用户还可继续添加商品
4. 如果用户输入的商品序号有误，则提示输入有误，并重新输入
5. 用户输入n为购物车结算，依次显示用户购物车里面的商品，数量及单价，若充值的钱数不足，则让用户删除某商品，直至可以购买，
    若充值的钱数充足，则可以直接购买
6. 用户输入Q或者q退出程序
7. 退出程序之后，依次显示用户购买的商品，数量，单价，以及此次共消费多少钱，账户余额多少
"""

# 商品列表
goods_dic = {
    "1":{"name":"电脑","price":1999,},
    "2":{"name":"鼠标","price":10,},
    "3":{"name":"键盘","price":60,},
    "4":{"name":"手机","price":4000,},
    "5":{"name":"ipad","price":2999,},
    "n":{"name":"购物车结算","price":'',},
}

# 用户购物车
user_shopping_cart = {}

# 标志位
flag = True

# 充值
while flag:
    print('------------ 您好，欢迎来到购物商城 ----------------')
    user_balance = input("请先给账号充值(退出Q/q):")
    if user_balance.lower() == "q":
        print("退出，欢迎下次光临！")
        flag = False
    elif user_balance.isdigit():
        user_balance = int(user_balance)
        print("账号充值成功！余额为[%s]元\n" % (user_balance))
        break
    else:
        print("输入有误，请重新输入。")

# 主程序
while flag:
    print("下列是您可以选购的商品(退出Q/q):")
    for key in goods_dic:
        print('\t',key,goods_dic[key]['name'],goods_dic[key]['price'])

    user_choice = input("请输入你想购买的商品序号:")
    if user_choice.lower() == "q":
        print("退出购物商城")
        flag = False

    # 结算
    elif user_choice == "n":
        while flag:
            # 显示购车里的商品
            print("\n您的购车里商品如下:")
            for k in user_shopping_cart:
                print("\t商品[%s] 数量[%s] 价格[%s]" % (k, user_shopping_cart[k]['number'] ,user_shopping_cart[k]['price']) )

            # 购物车所有商品总价
            shopp_cart_total = 0

            print("\n正在结算，请稍候...")
            # 计算商品总价格
            for k in user_shopping_cart:
                shopp_cart_total = shopp_cart_total + user_shopping_cart[k]['number'] * user_shopping_cart[k]['price']

            # 判断余额是否能够支付
            if user_balance >= shopp_cart_total:
                print("您本次总共需要支付[%s]元，余额为[%s]元" % (shopp_cart_total,user_balance))
                print("\n您本次购买的商品详单如下：")
                for k in user_shopping_cart:
                    print('\t商品[%s] 数量[%s] 价格[%s]' % (k, user_shopping_cart[k]['number'], user_shopping_cart[k]['price']) )
                print("\n本次总共消费[%s]元，账户余额为[%s]元" % (shopp_cart_total,user_balance-shopp_cart_total) )
                print("\n购买成功!")
                flag = False
            else:
                print("本次总共需要支付[%s]元 你的余额为[%s]元" % (shopp_cart_total,user_balance))
                print("余额不足，请先删除购物车里的一些商品再去结算哟\n")

                while flag:
                    print("\n购物车的商品列表如下:")
                    for k in user_shopping_cart:
                        print('\t商品[%s] 数量[%s] 价格[%s]' % (k,user_shopping_cart[k]['number'],user_shopping_cart[k]['price']) )

                    user_choice2 = input("请输入你想删除的商品名称:")
                    if user_shopping_cart.get(user_choice2):
                        if user_shopping_cart[user_choice2]['number'] == 1:
                            del user_shopping_cart[user_choice2]
                            print('商品[%s]已从购物车删除' % (user_choice2))
                        elif user_shopping_cart[user_choice2]['number'] > 1:
                            user_shopping_cart[user_choice2]['number'] -= 1
                            print("商品[%s]数量减少1件" % (user_choice2))
                        break
                    else:
                        print("\n输入的商品名称有误，请重新输入")

    # 添加商品到用户购物车
    elif goods_dic.get(user_choice):
        if user_shopping_cart.get(goods_dic[user_choice]['name']):
            user_shopping_cart[goods_dic[user_choice]['name']]['number'] += 1
        else:
            user_shopping_cart[goods_dic[user_choice]['name']] = {"number":1,"price":goods_dic[user_choice]['price']}
        print("\n商品[%s] 价格[%s] " % (goods_dic[user_choice]['name'], goods_dic[user_choice]['price']))
        print('添加到购物车成功！\n')

    else:
        print("输入有误，请重新输入哦\n")