python----题库（一）

1、执行 Python 脚本的两种方式

答：1.>>python ../pyhton.py    

        2. >>python.py   #必须在首行有 #!/usr/bin/env python3 指定执行语言

2、简述位、字节的关系

答：一个字节(byte)=8位(bit)  位为最小的单位

3、简述 ascii、unicode、utf-8、gbk 的关系

ascii:只能表示256个符号 

unicode:万国码，各国都有 需要有2位来表示 

utf-8:UTF-8，是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类

gbk:中文字符集，是对

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

Python
n = "李杰"
5、Pyhton 单行注释和多行注释分别用什么?

答：单行注释 #代码

        多行注释 ''' 代码 '''    Pycharm 快捷键ctrl+/ 

6、声明变量注意事项有那些?

答：1.变量名只能用字母、数字或下划线的任意组合

        2.变量名不能以数字为第一个字符

        3.内置函数名不能用

['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

8、如何查看变量在内存中的地址?

答：id(变量名)

9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

答：运行Python程序，PyCodeObject编译保存文件，.pyc文件是PyCodeObject永久性保存文件

10、写代码 a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!

Python
username = input("username:")#输入账号
password = input("password:")#输入密码
if username == "alex" and password == "123":#判断用户名密码是否相等
    print("登录成功")
    break#循环结束
else:#不同返回信息
    print("用户名或密码不正确，请重新输入！")
    continue
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次

Python
for i in range(3):#程序循环3次
    username = input("username:")#输入账号
    password = input("password:")#输入密码
    if username == "alex" and password == "123":#判断用户名密码是否相等
        print("登录成功")
        break#循环结束
    else:#不同返回信息
        print("用户名或密码不正确，请重新输入！")
        continue
c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次

Python
for i in range(3):#程序循环3次
    username = input("username:")#输入账号
    password = input("password:")#输入密码
    if username == "alex" or username == "seven":#判断用户名是否相等
        if password == "123":#密码是否相同
            print("登录成功")
            break#循环结束
        else:#不同返回信息
            print("用户名或密码不正确，请重新输入！")
            continue
    else:#不相等返回提示并重新输入
        print("用户名或密码不正确，请重新输入！")
        continue

11、写代码 a. 使用while循环实现输出2-3+4-5+6...+100 的和

Python
i,b = 2,0
while i <= 100:#i取2-100
    if i%2 == 0:#判断是偶数
        b = b + i #结果加当前的i
    else:#基数
        b = b - i #结果减当前i
    i += 1 #判断完自增一
print(b)
#结果：51
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和

Python
b = 0 #结果
for i in range(1,100):
    if i%2 == 0:#判断是偶数
        b = b - i #结果加当前的i
    else:#基数
        b = b + i #结果减当前i
    i += 1 #判断完自增一
print(b)
#结果：50
c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12 

Python
i = 1#初始值
while i < 13: #判断小余13
    if i == 6 or i == 10:#只有6和10不输出，or是或
        pass #啥也不做跳过
    else:
        print(i)
    i += 1
d. 使用 while 循环实现输出 1-100 内的所有奇数

Python
i = 1
while i < 101:
    if i%2 == 0:#取2得余数为0为偶数
        pass#啥也不做
    else:
        print(i)
    i += 1
e. 使用 while 循环实现输出 1-100 内的所有偶数

Python
i = 1
while i < 101:
    if i%2 == 0:#取2得余数为0为偶数
        print(i)
    else:
        pass#啥也不做
    i += 1
12、分别书写数字 5，10，32，7 的二进制表示

5：0000 0101   10：0000 1010   32：0010 0000  7：0000 0111

13、简述 对象和 类的关系(可用比喻的手法)

答：类就是文件夹，对象就是文件夹的文件  类有列表，元组，字典等 里面的元素就是对象

14、现有如下两个变量，请简述 n1 和 n2 是什么关系?

n1 = 123

n2 = 123

答：n1和n2都在内存中并列存在

15、现有如下两个变量，请简述 n1 和 n2 是什么关系?

n1 = 123456

n2 = 123456

答：n1和n2都在内存中并列存在

16、现有如下两个变量，请简述 n1 和 n2 是什么关系?

n1 = 123456

n2 = n1

答：n1的值在内存存在，n2的值是指向n1的值，如下图：

17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

Python
n1 = 5
print(n1.bit_length())  #3
18、布尔值分别有什么?

答：True和False   1和0

19、阅读代码，请写出执行结果

a = "alex" b = a.capitalize()

print(a) print(b)

请写出输出结果:alex Alex

20、写代码，有如下变量，请按照要求实现每个功能

name = " aleX"

a. 移除 name 变量对应的值两边的空格，并输入移除有的内容

Python
name = " aleX"
print(name.strip())
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果

Python
name = " aleX"
print(name.startswith("al"))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果

Python
name = " aleX"
print(name.endswith("X"))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果

Python
#第一种
name = " aleX"
name = name[:2]+"p"+name[-2:]
print(name)
#第二种
name = " aleX"
name1 = ""
for i in name:
    i = "p" if i == "l" else i #三元运算
    name1 += i
print(name1)
#第三种
name = " aleX"
name1 = ""
for i in name:
    if i == "l":
        i = "p"
    name1 += i
print(name1)
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。

Python
#第一种人工分割
name = " aleX"
name1 = name[:2]
name2 = name[-2:]
print(name1,name2)
#第二种循环分割
name = " aleX"
for i,v in enumerate(name):
    if v == "l":
        print(name[:i],name[i+1:])
f. 请问，上一题 e 分割之后得到值是什么类型?

答：字符串

g. 将 name 变量对应的值变大写，并输出结果

Python
name = " aleX"
print(name.upper())
h. 将 name 变量对应的值变小写，并输出结果

Python
name = " aleX"
print(name.lower())
i. 请输出 name 变量对应的值的第 2 个字符?

Python
name = " aleX"
print(name[1:2])
j. 请输出 name 变量对应的值的前 3 个字符?

Python
name = " aleX"
print(name[:3])
k. 请输出 name 变量对应的值的后 2 个字符?

Python
name = " aleX"
print(name[-2:])
l. 请输出 name 变量对应的值中 “e” 所在索引位置?

Python

name = " aleX"
for i,v in enumerate(name):
    if v == "e":
        print("e的索引是：%s"%i)

21、字符串是否可迭代?如可以请使用 for 循环每一个元素?

Python
name = "hairui"
for i in name:
    print(i)
22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain'] 

Python
#方法一
li = ['alex', 'eric', 'rain']
b = li[0]+"_"+li[1]+"_"+li[2]
print(b)
#方法二
li = ['alex', 'eric', 'rain']
c = ""
for i,name in enumerate(li,1):
    if i == len(li):#判断是否是最后一位
        c = c + name
    else:
        c = c + name + "_"
print(c)
22、写代码，有如下列表，按照要求实现每一个功能

li = ['alex', 'eric', 'rain'] a. 计算列表长度并输出

Python
li = ['alex', 'eric', 'rain']
print(len(li))
b. 列表中追加元素 “seven”，并输出添加后的列表

Python
li = ['alex', 'eric', 'rain']
li.append("seven")
print(li)
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表

Python
li = ['alex', 'eric', 'rain']
li.insert(0,"seven")
print(li)
d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表

Python
li = ['alex', 'eric', 'rain']
li[1] = "Tony"
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表

Python
li = ['alex', 'eric', 'rain']
li.remove('eric')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表

Python
li = ['alex', 'eric', 'rain']
print(li.pop(1))
g. 请删除列表中的第 3 个元素，并输出删除元素后的列表

Python
li = ['alex', 'eric', 'rain']
li.pop(2)
print(li)
h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表

Python
li = ['alex', 'eric', 'rain','Tony']
for i in range(3):循环3次
    li.pop(1)
print(li)
i. 请将列表所有的元素反转，并输出反转后的列表

Python

li = ['alex', 'eric', 'rain']
print(li.reverse())

j. 请使用 for、len、range 输出列表的索引

Python
li = ['alex', 'eric', 'rain','Tony']
for i in range(len(li)):
    print(i)
k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)l. 请使用 for 循环输出列表的所有元素

Python
li = ['alex', 'eric', 'rain','Tony']
for i,name in enumerate(li,100):
    print(i,name)
23、写代码，有如下列表，请按照功能要求实现每一个功能li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446] 

a. 请输出 “Kelly”

Python
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
name = str(li[2][1][1])
print(name.capitalize())
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”

Python
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
name = str(li[2][2])
print(name.upper())
24、写代码，有如下元组，按照要求实现每一个功能tu = ('alex', 'eric', 'rain')

a. 计算元组长度并输出

Python
tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出

Python
tu = ('alex', 'eric', 'rain')
print(tu[1])
c. 获取元组的第 1-2 个元素，并输出

Python

tu = ('alex', 'eric', 'rain')
print(tu[:2])

d. 请使用 for 输出元组的元素

Python
tu = ('alex', 'eric', 'rain')
for i in tu:
    print(i)
e. 请使用 for、len、range 输出元组的索引

Python
tu = ('alex', 'eric', 'rain')
for i in range(len(tu)):
    print(i)
f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)

Python
tu = ('alex', 'eric', 'rain')
for i,name in enumerate(tu,10):
    print(i,name)
25、有如下变量，请实现要求的功能 tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])

a. 讲述元祖的特性

1.不可修改    b. 请问 tu 变量中的第一个元素 “alex” 是否可被修改?

答：不可以修改 c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

答：可以修改，是列表

Python
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
b = tu[1][2]["k2"] = [].append("Seven")
print(tu)
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

答：元组，可以，重新给k3赋值

Python
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
b = list(tu[1][2]["k3"])#k3的value转换list
b.append("seven")#添加值
tu[1][2]["k3"] = tuple(b)#给k3赋值
print(tu)
26、字典 dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}

a. 请循环输出所有的 key 

Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
for i in dic.keys():
    print(i)
b. 请循环输出所有的 value

Python

dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
for i in dic.values():
    print(i)

c. 请循环输出所有的 key 和 value

Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
for i in dic.keys():
    print(i,dic[i])
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典

Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
dic.setdefault("k4","v4")
print(dic)
#结果：{'k2': 'v2', 'k3': [11, 22, 33], 'k1': 'v1', 'k4': 'v4'}
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典

Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
dic["k1"] = "alex"
print(dic)
f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典

Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
b = list(dic["k3"])#读取k3的value,转换成list赋值给B
b.append(44)#将元素添加至列表B中
dic["k3"] = b#将列表赋值给k3的value
print(dic)
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典

Python
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
b = list(dic["k3"])
b.insert(0,18)
dic["k3"] = b
print(dic)
27、转换 a. 将字符串 s = "alex" 转换成列表

Python
s = "alex"
print(list(s))
b. 将字符串 s = "alex" 转换成元祖

Python
s = "alex"
print(tuple(s))
b. 将列表 li = ["alex", "seven"] 转换成元组

Python
li = ["alex", "seven"]
print(tuple(li))
c. 将元祖 tu = ('Alex', "seven") 转换成列表

Python
tu = ('Alex', "seven")
print(list(tu))
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

Python
li = ["alex", "seven"]
dict = {}
for i,name in enumerate(li,10):
    dict[i] = name
print(dict)
28、转码

n = "老男孩"

a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出

Python
n = "老男孩"
print(n.encode(encoding="utf-8"))
print(n.encode(encoding="utf-8").decode(encoding="utf-8"))
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出

Python
n = "老男孩"
print(n.encode(encoding="gbk"))
print(n.encode(encoding="gbk").decode(encoding="gbk"))
29、求 1-100 内的所有数的和

Python
b = 0
for i in range(0,101):
    b = b + i
print(b)
结果：5050

30、元素分类 有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，将小于 66 的值保存至第二个 key 的值中。

即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}

Python
li = [11,22,33,44,55,66,77,88,99]
l1 = []
l2 = []
for i in li:
    if i >66:
        l1.append(i)
    else:
        l2.append(i)
dict = {"k1":l1,"k2":l2}
print(dict)
结果：{'k1': [77, 88, 99], 'k2': [11, 22, 33, 44, 55]}

31、购物车 功能要求:

要求用户输入总资产，例如:2000显示商品列表，让用户根据序号选择商品，加入购物车 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。

goods = [ {"name": "电脑", "price": 1999},

{"name": "鼠标", "price": 10},

 {"name": "游艇", "price": 20}, 

{"name": "美女", "price": 998},

] 

Python

goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998},
]
my_money = int(input("请输入金额："))
while True:#用于循环购买
    for i,good in enumerate(goods,1):#循环商品信息
        print(i,goods[i-1]["name"],goods[i-1]["price"])#打印列表
    user_c = int(input("请选择商品："))#输入商品序号
    if user_c >0 and user_c <=len(goods):#判断输入是否在列表中
        if int(goods[user_c-1]["price"]) <= my_money:#余额大于商品金额
            my_money = my_money - int(goods\
                                    [user_c-1]["price"])#减商品金额
            print("购买 %s 成功,余额为 %s"%(goods[user_c-1]["name"]\
                                            ,my_money))#打印成功信息
        else:
            print("余额不足!再见！")
            break
    else:
        print("无此商品！")
        continue
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

基本数据类型经典题型：
一，基础题。
1：name= " aleX leNb" (每小题一分，共计 23 分)
1) 移除 name 变量对应的值两边的空格,并输出处理结果

2) 移除 name 变量左边的’al’并输出处理结果

3) 移除 name 变量右面的’Nb’,并输出处理结果

4) 移除 name 变量开头的 a’与最后的’b’,并输出处理结果

5) 判断 name 变量是否以 "al" 开头,并输出结果

6) 判断 name 变量是否以”Nb”结尾,并输出结果

7) 将 name 变量对应的值中的 所有的“l” 替换为 “p”,并输出结果

8) 将 name 变量对应的值中的第一个’l’替换成’p’,并输出结果

9) 将 name 变量对应的值根据 所有的“l” 分割,并输出结果。

10) 将 name 变量对应的值根据第一个’l’分割,并输出结果。

11) 将 name 变量对应的值变大写,并输出结果

12) 将 name 变量对应的值变小写,并输出结果

13) 将 name 变量对应的值首字母’a’大写,并输出结果

14) 判断 name 变量对应的值字母’l’出现几次，并输出结果

15) 如果判断 name 变量对应的值前四位’l’出现几次,并输出结果

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

17) 从 name 变量对应的值中找到’N’对应的索引(如果找不到则返回-1)输出结果

18) 从 name 变量对应的值中找到’X le’对应的索引,并输出结果

19) 请输出 name 变量对应的值的第 2 个字符?

20) 请输出 name 变量对应的值的前 3 个字符?
21) 请输出 name 变量对应的值的后 2 个字符?

22) 请输出 name 变量对应的值中 “e” 所在索引位置?

23) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
2，写代码，有如下列表，按照要求实现每一个功能（每题一分，共计 12 分）

li=[‘alex’,’wusir’,’eric’,’rain’,‘alex’] 1)计算列表的长度并输出

2)列表中追加元素’seven’,并输出添加后的列表

3)请在列表的第 1 个位置插入元素’Tony’,并输出添加后的列表

4)请修改列表第 2 个位置的元素为’Kelly’,并输出修改后的列表

5)请将列表 l2=[1,’a’,3,4,’heart’]的每一个元素添加到列表 li 中，一行代码实现，不允许循
环添加。
6)请将字符串 s=‘qwert’的每一个元素添加到列表 li 中，一行代码实现，不允许循环添
加。
7)请删除列表中的元素’eric’,并输出添加后的列表

8)请删除列表中的第 2 个元素，并输出删除的元素和删除元素后的列表

9)请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表

10)请将列表所有得元素反转，并输出反转后的列表

11)请使用 enumrate 输出列表元素和序号（序号从 100 开始）

12)请计算出‘alex’元素在列表 li 中出现的次数，并输出该次数。
3，写代码，有如下列表，利用切片实现每一个功能（每题一分，共计 6 分） li=[1,3,2,’a’,4,’b’,5,’c’]

1)通过对 li 列表的切片形成新的列表 l1,l1=[1,3,2]

2)通过对 li 列表的切片形成新的列表 l2,l2=[’a’,4,’b’]
3)通过对 li 列表的切片形成新的列表 l3,l3=[’1,2,4,5]

4)通过对 li 列表的切片形成新的列表 l4,l4=[3,’a’,’b’]

5)通过对 li 列表的切片形成新的列表 l5,l5=[‘c’]

6)通过对 li 列表的切片形成新的列表 l6,l6=[‘b’,’a’,3]
4,写代码，有如下字典，按照要求实现每一个功能（每题一分，共计 9 分） dic={‘k1’:’v1’,’k2’:’v2’,’k3’:’v3’}

1)请循环遍历出所有的 key

2)请循环遍历出所有的 value

3)请循环遍历出所有的 key 和 value

4)请在字典中添加一个键值对，’k4’:’v4’,输出添加后的字典

5)请删除字典中键值对’k1’,’v1’,并输出删除后的字典

6)请删除字典中的键’k5’对应的键值对，如果字典中不存在键’k5’，则不报错，并且让其 返回 None。

7)请获取字典中’k2’对应的值。

8)请获取字典中’k6’对应的值，如果键’k6’不存在，则不报错，并且让其返回 None。

9)现有 dic2={‘k1’:’v111’,’a’:’b’}通过一行操作使 dic2={‘k1’:’v1’,’k2’:’v2’,’k3’:’v3’,a’:’b’}
二，组合嵌套题。
1,写代码，有如下列表，按照要求实现每一个功能（每题 3 分，写出一种方法得 1 分， 写出两种方法的 3 分。此题共 9 分） lis=[[‘k’,[‘qwe’,20,{‘k1’:[‘tt’,3,’1’]},89],’ab’]] 1)将列表 lis 中的’tt’变成大写（用两种方式）。

2)将列表中的数字 3 变成字符串’100’（用两种方式）。
3)将列表中的字符串’1’变成数字 101（用两种方式）。

2，写代码，有如下字典，按照要求实现每一个功能(每道题两分，共计 10 分) dic={‘k1’:’v1’,’k2’:[‘alex’,’sb’],(1,2,3,4,5):{‘k3’:[‘2’,100,’wer’]}}

1)将’k2’对应的值的最后面添加一个元素’23’。

2)将’k2’对应的值的第一个位置插入一个元素’a’。

3)将(1,2,3,4,5)对应的值添加一个键值对’k4’,’v4’。

4)将(1,2,3,4,5)对应的值添加一个键值对(1,2,3),’ok’。

5)将’k3’对应的值的’wer’更改为’qq’。
三，循环遍历题（每题两分，共计 8 分）。

1)输出 1-100 内所有的奇数

2)使用 while 循环输出 123568910

3)求 1-2+3-4+5...99 的所有数的和

4)编写 for 循环，利用索引遍历出每一个字符 msg='helloegon666'

四，综合题（1-5 题每题 1 分，6,7,8 题每题 6 分，共计 23 分）。

1)有列表 li=[‘alex’,’wusir’,’rain’]通过操作该列表构造一个字符串 s=’alexwusirrain’

2)有列表 li=[‘alex’,’wusir’,’rain’]通过操作该列表构造一个字符串 s=’alex*wusir*rain’

3)有字符串 s=‘alexwusirlex’,通过操作该字符串构造一个列表 li=[‘a’,’exwusirlex’]

4)有字符串 s=‘alexwusir’,通过操作该字符串构造一个列表 li=[‘alex’,’wusir’]

5)有字符串 s=‘alex’通过操作该字符串构造一个字符串 s1=‘a_l_e_x’

6)列表 li=[1,’2’,’ab’,3,’as21’,4,’5b’,’6’,’568’,’10q’]将所有数字类型的元素，保存在字典第一 个 key中，将所有全部由数字组成的字符串类型的元素保存在字典的第二个 key中，剩 下的所有保存在字典的第三个 key中。 如 dic={key1:数字类型的值;key2:全部由数字组成的字符串元素;key3:剩下的其他元素}
7)列表 li=[1,2,’3’,4,’5’,6,’7’,8,9]将索引为偶数位对应的值相加(遇到字符串转化为数字相 加)最后得到的结果插入到列表 li 第二个位置。 8)按照要求实现以下功能： 现有一个列表 li=[1,2,3,’a’,’b’,4,’c’],有一个空字典 dic={}；现在需要完成这样的操作： 如果该字典没有’k1’这个键，那就创建这个’k1’键和对应的值(并且该键对应的值是列表 类型)，并将列表 li 中的索引为奇数位的元素，添加到’k1’这个键对应的值中。 如果该字典中有’k1’这个键，那就将列表 li 中的索引为奇数位的元素，添加到’k1’这个键
对应的值中。

答案：

name = "aleX leNb"
#1
print(name[2:])
#2
print(name[:-2])
#3
print(name[1:-1])
#4
print(name.replace('l','p'))
#5
print(name.replace('l','p',1))
#6
print(name.split('l'))
#7
print(name.split('l',1))
#8
print(name.capitalize())
#9
print(name.count('l'))
#10
print(name.count('l',4))
#11
print(name.index('X le'))
#12
print(name.index('e'))
#13
name1=name[:-1]
print(name1)
li = ['alex','wusir','eric','rain','alex']
#1
li.insert(1,'Tony')
print(li)
#2
li[1]='Kelly'
print(li)
#3
l2 = [1,'a', 3, 4,'heart']
li+=l2
print(li)
#4
s = 'qwert'
li+=list(s)
print(li)
#5
li.remove('eric')
print(li)
#6
li.pop(1)
print(li)
#7
del li[1:4]
print(li)
#8
li.reverse()
print(li)
#9
for i in enumerate(li,100):
    print(i)
#10
print(li.count('alex'))

li = [1,3,2,'a',4,'b',5,'c']
#1
print(li[3:-2])
#2
print(li[::2])
#3
print(li[1:6:2])
#4
l5=li[-1:]
print(l5)
#5
l6=li[-3::-2]
print(l6)

dic = {'k1':'v1','k2':'v2','k3':'v3'}
#1
for i in dic.keys():
    print(i)
    #2
for i in dic.values():
    print(i)
#3
for i in dic.items():
    print(i)

#4
dic['k4']='v4'
print(dic)
#5
dic.pop('k1')
print(dic)
#6
print(dic.pop('k5',None))
#7
print(dic.get('k6'))
#8
dic2 ={'k1':'v111','a':'b'}
dic2.update(dic)
print(dic)
#1
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
# lis[0][1][2]['k1'][0]='TT'
# print(lis)
lis[0][1][2]['k1'][0]=lis[0][1][2]['k1'][0].upper()
print(lis)

#2
# lis[0][1][2]['k1'][1]='100'
# print(lis)
lis[0][1][2]['k1'][1]=str(lis[0][1][2]['k1'][1]+97)
print(lis)
#3
# lis[0][1][2]['k1'][2]=101
# print(lis)
lis[0][1][2]['k1'][2]=int(lis[0][1][2]['k1'][2])+100
print(lis)
#1
dic = {'k1':'v1','k2':['alex','sb'],(1,2,3,4,5):{'k3':['2',100,'wer']}}
dic['k2'].append('23')
print(dic)
#2
dic['k2'].insert(0,'a')
print(dic)
#3
dic[(1,2,3,4,5)]['k4']='v4'
print(dic)

#4
dic[(1,2,3,4,5)][(1,2,3)]='ok'
print(dic)
#5
dic[(1,2,3,4,5)]['k3'][2]='qq'
print(dic)

#1
for i in range(101):
    if i%2 ==1:
        print(i)

#2
cont=1
while cont <11:
    if cont!=4 and cont!=7:
        print(cont)
    cont+=1

#3
sum_qq=0
for i in range(101):
    if i%2==0:
        sum_qq+=i
    else:
        sum_qq-=i
print(sum_qq)

#1
li = ['alex','wusir','rain']
s=''.join(li)
print(s)
#2
s='*'.join(li)
print(s)
#3
s='alexwusirrain'
li=s.split('l',1)
print(li)
#4
s = 'alex wusir'
li_1=s.split(' ')
print(li_1)
#5
s='alex'
s1='_'.join(s)
print(s1)
#7
li_int = [1,2,'3',4,'5',6,'7',8,9]

re=sum([int(li_int[i]) for i in range(len(li_int)) if i%2==0])
li_int.insert(1,re)
print(li_int)
#8
dic_bb = {'234':[1,2,3],'12b':'alex','2':['a','b','1']}

li_s=[i for i in dic_bb.keys()]

for i in li_s:
    if i.isdigit():
        print(i,dic_bb[i])
    else:
        print(dic_bb[i])

#9
li = [1,2,3,'a','b',4,'c']
li_sb=[li[i] for i in range(len(li)) if i%2==1]
print(li_sb)
dic_sb={}
if 'k1'  in dic_sb:
    dic_sb['k1']+=li_sb
else:
    dic_sb['k1']=li_sb
print(dic_sb)

数据类型经典题型

#! usr/bin/env python
# -*- coding: utf-8 -*-
#基本数据类型
#---------------------字符串-----------------
# l = 'wangshanglonG'
# '    wangshanglong    '
# print(l.strip())    #1:strip-----------------去除前后空格lstrip(左)，strip(右)1
# print(l.startswith('W'))#2:startswith---------------判断是否以'....',开头
# print(l.endswith('g'))#3endswit h-------------------判断是否以'....',结尾
# print(l.upper())#4:upper-----------------------------变大写
# print(l.lower())#5:lower-------------------------------变小写
# print(l.swapcase())#6:swapcase---------------------------大小写转换
# print(l.split('s'))#7:split--------------------------------以'....',切分。
# print(l.index('s'))#8:index-----------------求'....'的索引，若找不到就报错。
# print(l.find('p'))#9:find---------------------求'....'的索引，找不到返回负。
# print(l.count('a'))#10:count--------------------统计'....'次数。
# print(l.replace('shang','S'))#11------------------替换
# print(len(l))#12:len()-------------------------------求长度
# print('+'.join(l))#13:join--------------------------用'....'连接。
# '    wangshanglong    '
# print(l.center(20,'*'))#14:center---------------------填充空白
# print(l.format())#15:format-----------------------------取出字符串的字符
#----------------------------列表-------------------------------------------
# l = ['1',2,3,'wang','shang','long']
# l.append(123)#1:append------------追加
# print(l)
# l.insert(4,'hwuhuhuhuhwuhuuw')#1：insert--------------增加（按索引）
# print(l)
# l.extend('王,尚,long')#:extend-------------------------增加（追加多个，字符）
# print(l)
# l.remove('1')#2:remove-----------------------------------删除（按元素删）
# print(l)
# l.pop(4)#opo-----------------------------------------------删除（按索引）
# print(l)
# del l[0]#---------------------------------------------------删除（按索引）
# print(l)
# a = ["q","w","e","r","t","y"]--------------------------------切片查找
# print(a[0:3])
# print(a[0::2])   #面试
# print(a[0:5])
# print(a[0:3:2])
# print(a[-1])  #面试
# print(a[-1:])#结果是列表
# print(a[3:1:-1])   #面试(倒叙)
#---------------------------------------------------------字典--------------------------------------------------------
#例题：
# lis = ['a','gfg',['qwe',20,['tre','1',3],89]]
# 根据索引找到tre元素，并改成TRE
# lis[2][2][0] = 'TRE'
# lis[2][2][0] = lis[2][2][0].upper()
# print(lis)
#1:找到数字3通过相加的方式让其加上97，变成100。
# lis[2][2][2] += 97
# print(lis)
#2:找到字符串'1',通过相加方式变成字符串'101'。
# lis[2][2][1]+='01'
# print(lis)
#3:找到数字20，通过数字相加和字符转换方式使其变成'120'.
# lis = ['a','gfg',['qwe',20,['tre','1',3],89]]
# lis[2][1]=str(lis[2][1]+100)
# print(lis)
# tu = ('alex',[11,22,{'k1':'v1','k2':['name','age'],'k3':(1,2,3)},32])
# 1,tu变量第一个元素能否被修改？
#不能
# 2,k2对应的值是什么类型？能否被修改，如果可以添加一个'jx'
# tu[1][2]['k2'].append('jx')
# print(tu)
# 3,k3对应的值是什么类型？能否被修改，如果可以添加一个'jx'
# 元祖不能修改
# 字典的操作
# 字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。
# python对key进行哈希函数运算，根据计算的结果决定value的存储地址，
# 所以字典是无序存储的，且key必须是可哈希的。
# 可哈希表示key必须是不可变类型，如：数字、字符串、元组。
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# for key in dic:
#     print(key)
# for item in dic.items():
#     print(item)
# for key,value in dic.items():
#     print(key,value)
# 增
# dic[[1,2,3]] = ["a","b","c"]
# print(dic)
# setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
# dic.setdefault('k','v')
# print(dic)  # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic.setdefault('k','v1')  # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# print(dic)
# 删
# dic_pop = dic.pop("a",'无key默认返回值') # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
# print(dic_pop)
# del dic["name"]  # 没有返回值。
# print(dic)
# dic_pop1 = dic.popitem()  # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
# print(dic_pop1)  # ('name','jin')
# dic_clear = dic.clear()  # 清空字典
# print(dic,dic_clear)  # {} None

# 改
# dic2.update(dic)  # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
# print(dic2)

# 查
# value1 = dic["name"]  # 没有会报错
# print(value1)
# value2 = dic.get("djffdsafg","默认返回值")  # 没有可以返回设定的返回值
# print(value2)
#例题：
dic = {'k1':'v1','k2':['name','age'],'k3':{'a':'b',"c":'d'}}
#,1找出字典中所有的key值，values值，key，values值
# print(dic.keys())
# print(dic.values())
# print(dic.items())m
#2,添加一个键值对，'k4':'v4"
# dic.setdefault('k4','v4')
# print(dic)
# dic.update({'k4':'v4'})
# print(dic)
#3,在k3对应的值里面增加一个键值对，'aa':'bb',并输出k3对应的值的键值对
# dic['k3'].update({'aa':'bb'})
# print(dic['k3'])
#4,请在'k2'对应的值第一个位置加入一个'sex',并输出该值
# dic['k2'].insert(1,'sex')
# print(dic)
#5,将k2对应的值增加多个值，这些值是这个列表[1,2,3,4,5]的每一个元素
# dic['k2'].extend([1,2,3,4,5])
# print(dic)
av_catalog = {
    "欧美":{
        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
        "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
    },
    "日韩":{
        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
    },
    "大陆":{
        "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    }
}
#三级菜单
# def find(av_catalog):
#     for key in av_catalog:
#         print(key)
#     k = input("请输入:")
#     if k in av_catalog:
#             find(av_catalog[k])
# find(av_catalog)
#1:将"资源不多,更新慢" 变成 "还是自拍好呀"
# av_catalog["欧美"]["letmedothistoyou.com"][1]="还是自拍好呀"
# print(av_catalog)
#2:将"服务器在国外,慢"追加一句：'好多找不到了'
# av_catalog["大陆"]["1024"].append("好多找不到了")
# print(av_catalog)
#3:列表 lis = ['a','b','c'] 创建一个字典(用上lis列表)，让其变成dic = {'a':1,'b':1,'c':1}
# w = {}
# lis = ['a','b','c']
# for i in lis:
#     w.setdefault(i,1)
# print(w)
#4:列表 li = [1,2,3,4,5,6,7,8,9],将所有大于6的值保存在字典第一个key中，将所有小于6的值保存在字典第二个key中
# 如：{'k1':所有大于6的值;'k2':所有小于6的值}
# li = [1,2,3,4,5,6,7,8,9]
# # w = []
# s = []
# l = {'k1':w,'k2':s}
# for i in li:
#     if i > 6:
#         w.append(i)
#     else:
#         s.append(i)
# print(l)
# a = {'k1':[],'k2':[]}
# for i in li:
#     if i >6:
#         a['k1'].append(i)
#     else:
#         a['k2'].append(i)
# print(a)
# li = [1,2,3,4,5,6,7,8,9]将索引为偶数位对应的值相加并添加到li列表的最后面。
# li = [1,2,3,4,5,6,7,8,9]
# cont = 0
# for i in li:
#     if i % 2 ==0:
#        cont+=i
# li.append(cont)
# print(li)