python入门练习题1

常见python入门练习题

 1.执行python脚本的两种方法

 第一种：给python脚本一个可执行的权限，进入到当前存放python程序的目录，给一个x可执行权限，如:有一个homework.py文件   然后运行./homework

 第二种：使用python命令执行，如：python homework.py

2.简述，位，字节的关系

位：bit是由八个二进制数组成
      1 bit = 0101 0101
字节：一个字节等于八个bit位
        1Byet = 8bit

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

#unicode:包含所有国家的字符编码，
#utf-8可变长的字符编码，英文表示一个字节，中文（繁文）表示3个字节
#ascii美国标志信息交换代码，是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言，一个字符占一个字节
#gbk全称《汉字内码扩展规范》,一个字符占用两个字节

4.请写出'李杰'分别用utf-8和gbk编码所在的为数

#在utf-8中，一个中文字符占用3个字节
#在gbk中一个汉字占用2个字节
#李杰 = utf-8(6字节)
#李杰 = gbk(4字节)

5.python单行注释和多行注释分别用什么

#单行注释：将要注释的行选重。ctrl+/即可

#多行注释：用三对当引号或者三对双引号，将要注释的内容从头到尾括起来

6.声明变量名的注意事项
#1.变量名不能以数字，特殊字符开头，在变量名中也不能包含特殊字符
#2.不能以python中的关键字命名，我们可以调用keyword模块查看这个变量名是否为关键字

8，如何查看变量在内存中的地址
#通过id这个命令可以查看
    如：a = 'alex'  内存地址为print(id(a))  #

12，分别书写数字5，10，32，7的二进制表示
#5 = 0000 0101
#10=0000 1010
#32=0010 0000

13，简述对象和类的关系
#在python中一切事物皆对象，对象是基于类创建的

14，现有如下两个变量，请简述n1和n2是什么关系
#n1 = 123,n1是变量名，123是变量值，其实在python内部执行的时候，就是在内存中开辟出了一块123的空间，通过n1
    就可以调用这块开辟的空间123
 #n2 = 123,在python内部执行的时候，其实是通过python的一个内部机制，去内存里查看有没有这个123这块空间，
    如果有就直接调用，没有就从新开辟一块空间，我们可以通过查看变量名的id号来判断这个两个变量是否指向同
    一块内存地址
 # n1 = 123    print(id(n1))   #1746669840
 # n2 = 123    print(id(n2))   #1746669840
    两个变量名是指向同一个内存地址

16，现有如下两个变量,请简述n1和n2是什么关系
    n1 = 123456     n2 = n1
#n1 = 123456 是在内存中开辟了一块内存空间，而n2 = n1则是n2的值直接指向n1所开辟的那块内存空间，它们
    之间是一个对应关系

18,布尔值分别有什么
#True和False

19,阅读代码，写出执行结果
#a = 'alex'      #alex
#b = a.capitalize()
#Alex,capitalize将首字母大写

19,阅读代码，写出执行结果
a = 'alex'      #alex
b = a.capitalize()  #Alex,capitalize将首字母大写

20，写代码，有如下变量，请按照要求实现每个功能
name = 'aleX'
a,移除name变量对应的值的两边的空格，并输入移除有的内容
print(a.strip())   #aleX

b.判断name变量对应的值是否以'al'开头，并输出结果
print(a.startswith('al'))   #True
c.判断name是否以'X'结尾，并输出结果
print(a.endswith('X'))    #False

d.将name变量对应的值中的'l'替换为'p'，并输出结果
print(a.replace('l','p'))   #apeX

e.将name变量对应的值根据'l'分割，并输出结果
print(a.split('l'))   #['a', 'eX']
f,上一题e分割之后得到的值是什么数据leix
print(type(a.split('l')))   #<class 'list'>

g.将name变量对应的值变为大写，并输出结果
print(a.upper())    #ALEX

h.将name变量对应的值变为小写，并输出结果
print(a.lower())    #alex

i.输出name变量对应的值的第2个字符
print(a[1:2])   #l

j.输出name变量对应的值的前3个字符
print(a[:3])    #ale

k.输出name变量对应值的后2个字符
print(a[-2:])   #eX

l.输出name变量中对应的值中'e‘所在索引位置
print(a.index('e')) #

21，字符串是否可迭代？如可以请使用for循环每一个元素
#字符串是可迭代的，举例如下：
a = ’alex'
for i in a:
    print(i)
#结果循环字符串中的字符，并以迭代的方式输出
#a
#l
#e
#x

22，请用代码实现，利用下划线将列表的每一个元素拼接成字符串，li = ['alex','rein','rain']

li = ['alex','jack','rain']
s = '_'.join(li)   #alex_jack_rain

23.写代码，有如下列表，按照要求实现每一个功能   li = ['alex','eric','rain']
a.计算列表长度并输出
print(len(li))  #3

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

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

d,请修改列表的第2个位置为'Kelly'，并输出修改后的列表
li[2] = 'Kelly'
print(li)   #['alex', 'eric', 'Kelly']

e，请删除列表中的元素'eric'，并输出修改后的列表
result = li.remove('eric')
print(li)   #['alex', 'rain']

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

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

h.请删除列表中的第2个至4个元素，并输出删除元素后的列表
li = ['alex','eric','rain','Tony']
del li[1:]
print(li)       #['alex']
i，请将列表所有的元素反转，并输出反转后的列表
li = ['alex','eric','rain','Tony']
result = li.reverse()
print(li)   #['Tony', 'rain', 'eric', 'alex']

j,请使用for,len,range输出列表的索引
li = ['alex','eric','rain','Tony']
for i in li:
    i = li.index(i)
    print(i)
0
1
2
3

k，请使用enumrate输出列表元素和序号（序号从100开始）
li = ['alex','eric','rain','Tony']
for i,y in enumerate(li,100):
    print(i,y)
100 alex
101 eric
102 rain
103 Tony

l.请使用for循环输出列表中的所有元素
for i in li:
    print(i)
alex
eric
rain
Tony

24.24.写代码，有如下元祖，按照要求实现每一个功能
tu = ('alex','eric','rain')

a,计算元组长度并输出
print(len(tu))  #

b,计算元组的第2个元素，并输出
result = tu[1]
print(result)   #eric

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

25,有如下变量，请按照要求实现每个功能
a,简述元组的特性

b，请问tu变量中的第一个元素'alex'是否可被修改
#以元组的形式是不能修改的，我们可以通过将tu的数据类型转换为列表来进行修改

c,tu变量中的'k2'对应的值是什么类型，是否可以被修改，如果可以，请在其中添加一个元素'Seven'
result = tu[1][2].get('k2')
print(result)   #['age', 'name']
print(type(result)) #<class 'list'>
result = tu[1][2].get('k2').append('seven')
print(tu)
#('alex', [11, 22, {'k3': (11, 22, 33), 'k1': 'v1', 'k2': ['age', 'name', 'seven']}, 44])

c,tu变量中的'k3'对应的值是什么类型，是否可以被修改，如果可以，请在其中添加一个元素'Seven'
result = tu[1][2].get('k3')   #k3不能修改，因为k3对应的value是元组类型
print(result)   #(11, 22, 33)
print(type(result)) #<class 'tuple'>

26.字典

dic = {'k1':'v1','k2':'v2','k3':[11,22,33]}
a.循环输出所有的k

for i in dic:
    print(i)
k2
k3
k1

b,循环输出所有的value
for k,v in dic.items():
    print(v)
v2
[11, 22, 33]
v1

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

 k2 v2
k3 [11, 22, 33]
k1 v1

d，在字典中添加键值对，'k4':'v4'，输出添加后的字典
result = dic.update({'k4':'v4'})
print(dic)
#{'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4', 'k1': 'v1'}

e,修改字典中'k1',对应的值为'alex'，输出修改后的字典
result = dic.update({'k1':'alex'})
print(dic)
#{'k2': 'v2', 'k1': 'alex', 'k3': [11, 22, 33]}

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

g,在k3对应的值的第一个位置插入一个元素18，请输出修改后的字典
dic['k3'].insert(1,18)
print(dic)  #{'k1': 'v1', 'k3': [11, 18, 22, 33], 'k2': 'v2'}

27,转换
a.将字符串s = 'alex'转换为列表
s = 'alex'
a = list(s)
print(a,type(a))#['a', 'l', 'e', 'x'] <class 'list'>

b.将字符串s = 'alex'转换为元组
a = tuple(s)
print(a,type(a))    #('a', 'l', 'e', 'x') <class 'tuple'>

c.将元组tu = ('Alex','seven')
lione = list(tu)转换为列表
tu = lione
print(tu,type(tu))

d。将列表li = ['alex','seven']转换为元组
tu = tuple(li)
li = tu
print(li,type(li))

e,将列表li = ['alex','seven']转换为字典且字典的key按照10开始向后递增
# li = ['alex','seven']
# dic = {}
# for key,value in enumerate(li,start=10):
#     dic[key]=value
# print(dic)

27,字符编码转换，n = '老男孩'
a,将字符串转换为utf-8编码的字节，并输出，然后在将该字节转换成utf-8编码字符
print(n.encode('utf-8'))    #b'\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9'
print(n.encode('utf-8').decode('utf-8'))    #老男孩

b,将字符串转换为gbk编码的字节，并输出，然后在将该字节转换成gbk编码字符
print(n.encode('gbk'))  #b'\xc0\xcf\xc4\xd0\xba\xa2'
print(n.encode('gbk').decode('gbk'))    #老男孩

28,求1-100的所有数的和
count = 0
b = 0
while count <100:
    count +=1
    b +=count
    print(b)
或者    print(sum(range(1,101)))

 29.元素分类
 有如下集合[11,22,33,44,55,66,77,88,99,90],将所有大于66的值保存到字典的第一个key中，
 将小于66的保存到第二个key中
 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)
    else:
        dic['k2'].append(i)
print(dic)