第一章/第二章课后习题

Posted 2722127842qq-123

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第一章/第二章课后习题相关的知识,希望对你有一定的参考价值。

 

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

1
2
3
4
5
交互方式:命令行
 
Windows操作系统下,快捷键cmd,输入“python”启动交互式python解释器。
 
文件方式:python文件

  

 

2、  简述位、字节的关系

1
2
3
4
5
一个二进制位是计算机里最小表示单元。
 
一个字节是计算机里最小存储单元。
 
二进制位=8bits=1Byte=1字节

  

 

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

1
2
3
4
5
6
7
8
9
10
美国制定了一套字符编码,对英语字符与二进制位之间的关系,做了统一规定。这被称为ASCII码。
 
Unicode是国际组织制定的可以容纳世界上所有文字和符号的字符编码方案。将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码,
那么乱码问题就会消失。这就是Unicode,就像它的名字都表示的,这是一种所有符号的编码。
 
互联网的普及,强烈要求出现一种统一的编码方式。UTF-8就是在互联网上使用最广的一种Unicode的实现方式。
UTF-8最大的一个特点,就是它是一种变长的编码方式。它可以使用1~4个字节表示一个符号,根据不同的符号而变化字节长度。UTF-8中,英文占一个字节,中文占3个字节。
 
GBK: 汉字国标扩展码,基本上采用了原来GB2312-80所有的汉字及码位,并涵盖了原Unicode中所有的汉字20902,总共收录了883个符号,
21003个汉字及提供了1894个造字码位。由于GBK同时也涵盖了Unicode所有CJK汉字,所以也可以和Unicode做一一对应。windows默认编码GBK,中文占2个字节。

  

 

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

1
2
3
utf-8中,一个英文占一个字节,一个中文占3个字节,此处“李连杰”占8个字节。
 
GBK中一个中文占2个自己,此处“李连杰”占6个字符。

  

 

5、  Pyhton 单行注释和多行注释分别用什么?

1
python单行注释用#,多行注释用三引号“‘    ’”。

  

 

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

1
声明变量需先赋值。变量名可以包含字母、数字和下划线_。变量不能以数字开头。

  

 

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

1
id(变量名)  #查看内存地址。

  

 

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

1
2
Python这样保存字节码是作为一种启动速度的优化。下一次运行程序时,如果你在上次保存字节码之后没有修改过源代码的话,Python将会加载.pyc文件并跳过编译这个步骤。
当Python必须重编译时,它会自动检查源文件和字节码文件的时间戳:如果你又保存了源代码,下次程序运行时,字节码将自动重新创建。

  

 
9、写代码

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

1
2
3
4
5
6
username=input("username:")
passwd=input("passwd:")
if username=="seven" and passwd=="123":
    print("登录成功!")
else:
    print("登录失败!")

  


b.实现用户输入用户名和密码,当用户名为  seven  且  密码为  123  时,显示登陆成功,否则登陆失败,失败时允许重复输入三次

1
2
3
4
5
6
7
8
9
10
11
count=0
while True:
    username = input("username:")
    passwd = input("passwd:")
    if username=="seven" and passwd=="123":
        print("登录成功!")
        break
    count += 1
    if count==3:
        print("登录失败!")
        break

  



10、写代码

a.  使用 while 循环实现输出 2  ­‐  3  +  4  ‐  5  +  6  ...  +  100  的和 

1
2
3
4
5
6
7
8
9
10
11
i=2
total_1=0
total_2=0
while i<=100:
    if i%2==0:
        total_1+=i
    else:
        total_2+=-i
    i+=1
total=total_1+total_2
print(total)

  

 

b.  使用 for 循环和 range 实现输出  1 - 2  +  3  -­ 4  +  5  -­ 6  ...  +  99  的和

1
2
3
4
5
6
7
8
9
total_1=0
total_2=0
for in range(100):
    if i%2==1:
      total_1+=i
    else:
        total_2+=-i
total=total_1+total_2
print(total)

  

 

c.  使用 while 循环实现输出  1,2,3,4,5,   7,8,9,    11,12

1
2
3
4
5
6
7
8
9
i=1
while True:
    if i>=1 and i<=5:
        print(i)
    if i>=7 and i<=9:
        print(i)
    if i==11 or i==12:
        print(i)
    i+=1

  

d.  使用 while 循环实现输出  1‐100  内的所有奇数

1
2
3
4
5
i=1
while i<=100:
    if i%2==1:
        print(i)
    i+=1

  



e.  使用 while 循环实现输出  1‐100  内的所有偶数

1
2
3
4
5
i=1
while i<=100:
    if i%2==0:
        print(i)
    i+=1

  



11、分别书写数字  5,10,32,7 的二进制表示

1
2
3
4
5
6
7
数字5:   00000101
 
数字10:  00001010
 
数字32: 00100000
 
数字7:  00000111

  

 

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

类是具有相同数据结构(属性)和相同操作功能(行为)对象的集合。对象就是符合某种类所产生的一个实例。

 

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

1
2
3
4
5
6
7
# n1 = 123
#
# n2 = 123
#
# n1和n2使用同一内存地址
#
# python内部的优化: -5
# 到157之间的赋值变量都是相同的地址

  

 

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

1
2
3
4
5
6
7
n1  =  123456
 
n2  =  123456
 
n1和n2使用不同的内存地址
 
python内部的优化: -5157之间的赋值变量都是相同的地址

  

 

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

1
2
3
4
5
n1  =  123456
 
n2  =  n1
 
使用同一内存地址,只是变量名不同

  

 

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

1
3个二进制位表示,00000101

  

 

17、布尔值分别有什么?

1
2
3
TrueFalse
 
在二进制中的01。很多情况下,0被认为是False,所有的非0均被认为是True

  

 

18、阅读代码,请写出执行结果

1
2
3
4
5
6
7
8
9
a  =  "Tom"
 
b  =  a.capitalize()
 
print(a)
 
print(b)
 
请写出输出结果:Tom   Tom   #capitalize() 首字母大写其他字母小写

  

 

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

1
name  =  "  aleX"

  

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

1
2
name="  aleX"
print(name.strip())

  

b.判断 name 变量对应的值是否以  "al"  开头,并输出结果

1
2
3
4
5
6
7
8
name="  aleX"
if name[0:2]=="al":
    print("True")
else:
    print("False")
 
输出False
方法二:print(name.startswith("al")) False

  

 

c.判断 name 变量对应的值是否以  "X"  结尾,并输出结果

1
2
3
4
5
6
7
8
name="  aleX"
if name[-1]=="X":
    print("True")
else:
    print("False")
输出True
 
方法二:print(name.endswith("X"))     True

  


d.将 name 变量对应的值中的  “l”  替换为  “p”,并输出结果
1
2
3
name="  aleX"
print(name.replace("l","p"))
输出:apeX

  



e.将 name 变量对应的值根据  “l”  分割,并输出结果。

1
2
3
name="  aleX"
print(name.split("l"))
输出:[‘  a‘‘eX‘]

  


f.请问,上一题  e  分割之后得到值是什么类型?

1
name.split("l")  #把字符用“l”分割成列表list

  

 

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

1
2
3
name="  aleX"
print(name.upper())
输出:  ALEX

  

 

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

1
2
3
name="  aleX"
print(name.lower())
输出:  alex

  

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

1
2
3
name=" aleX"
print(name[1])
输出:a

  

j.请输出 name 变量对应的值的前 3 个字符?

1
2
3
name=" aleX"
print(name[0:3])
输出: al

  



k.请输出 name 变量对应的值的后 2 个字符?

1
2
3
name=" aleX"
print(name[-2:])
输出:eX

  

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

1
2
3
name=" aleX"
print(name.index("e"))
输出:3

  



 

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

1
2
3
name="aleX"
for in range(len(name)):
    print(name[i])

  

 

21、请用代码实现:利用下划线将列表的每一个元素拼接成字符串,li  =  [‘alex‘,  ‘eric‘,  ‘rain‘]  

1
2
3
li=[‘alex‘,‘eric‘,‘rain‘]
print(‘_‘.join(li))
输出:alex_eric_rain

  

22、写代码,有如下列表,按照要求实现每一个功能

1
li = [‘alex‘‘eric‘‘rain‘]

  

a. 计算列表长度并输出

1
2
3
li=[‘alex‘,‘eric‘,‘rain‘]
print(len(li))
输出:3

  

b. 列表中追加元素 “seven”,并输出添加后的列表

1
2
3
4
li=[‘alex‘,‘eric‘,‘rain‘]
li.append(‘seven‘)
print(li)
输出:[‘alex‘‘eric‘‘rain‘‘seven‘]

  

c. 请在列表的第 1 个位置插入元素 “Tony”,并输出添加后的列表

1
2
3
4
li=[‘alex‘,‘eric‘,‘rain‘]
li.insert(0,‘tony‘)
print(li)
输出:[‘tony‘‘alex‘‘eric‘‘rain‘]

  

d. 请修改列表第 2 个位置的元素为 “Kelly”,并输出修改后的列表

1
2
3
4
li=[‘alex‘,‘eric‘,‘rain‘]
li[1]="kelly"
print(li)
输出:[‘alex‘‘kelly‘‘rain‘]

  

e. 请删除列表中的元素 “eric”,并输出修改后的列表

1
2
3
4
5
6
7
8
9
li=[‘alex‘,‘eric‘,‘rain‘]
li.pop(1)
print(li)
输出:[‘alex‘‘rain‘]
 
li=[‘alex‘,‘eric‘,‘rain‘]
li.remove("eric")
print(li)
输出:[‘alex‘‘rain‘]

  

f. 请删除列表中的第 2 个元素,并输出删除的元素的值和删除元素后的列表

1
2
3
4
5
6
li=[‘alex‘,‘eric‘,‘rain‘]
print(li[1])
li.pop(1)
print(li)
输出:eric
[‘alex‘‘rain‘]

  

g. 请删除列表中的第 3 个元素,并输出删除元素后的列表

1
2
3
4
li=[‘alex‘,‘eric‘,‘rain‘]
li.pop(2)
print(li)
输出:[‘alex‘‘eric‘]

  

h. 请删除列表中的第 2至4个元素,并输出删除元素后的列表

1
2
3
4
li=[‘tony‘,‘alex‘,‘eric‘,‘rain‘,‘seven‘]
del li[1:4]
print(li)
输出:[‘tony‘‘seven‘]

  

i. 请将列表所有的元素反转,并输出反转后的列表

1
2
3
4
li=[‘tony‘,‘alex‘,‘eric‘,‘rain‘,‘seven‘]
li.reverse()
print(li)
输出:[‘seven‘‘rain‘‘eric‘‘alex‘‘tony‘]

  

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

1
2
3
4
5
6
7
8
li=[‘tony‘,‘alex‘,‘eric‘,‘rain‘,‘seven‘]
for in range(len(li)):
    print(li.index(li[i]),li[i])
输出:0 tony
     1 alex
     2 eric
     3 rain
     4 seven

  

k. 请使用enumerate输出列表元素和序号(序号从100开始) 

1
2
3
4
5
6
li=[‘alex‘,‘eric‘,‘rain‘]
for i,j in enumerate(li):
    print(i+100,j)
输出:100 alex
     101 eric
     102 rain

  

 

l. 请使用for循环输出列表的所有元素

1
2
3
4
5
6
7
8
li=[‘tony‘,‘alex‘,‘eric‘,‘rain‘,‘seven‘]
for in range(len(li)):
    print(li[i])
输出:tony
     alex
     eric
        rain
        seven

  

23、写代码,有如下列表,请按照功能要求实现每一个功能
li = ["hello", ‘seven‘, ["mon", ["h", "kelly"], ‘all‘], 123, 446]


a. 请输出 “Kelly”

1
2
li = ["hello"‘seven‘, ["mon", ["h""kelly"], ‘all‘], 123446]
print(li[2][1][1])

  

b. 请使用索引找到 ‘all‘ 元素并将其修改为 “ALL”

1
2
li = ["hello"‘seven‘, ["mon", ["h""kelly"], ‘all‘], 123446]
print(li[2][2].upper())

  

24、写代码,有如下元组,按照要求实现每一个功能

tu = (‘alex‘, ‘eric‘, ‘rain‘)

a. 计算元组长度并输出

1
2
3
tu = (‘alex‘‘eric‘‘rain‘)
print(len(tu))
输出:3

  

b. 获取元组的第 2 个元素,并输出

1
2
3
tu = (‘alex‘‘eric‘‘rain‘)
print(tu[1])
输出:eric

  

c. 获取元组的第 1-2 个元素,并输出

1
2
3
tu = (‘alex‘‘eric‘‘rain‘)
print(tu[0:2])
输出:(‘alex‘‘eric‘)

  

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

1
2
3
4
5
6
tu = (‘alex‘‘eric‘‘rain‘)
for in range(len(tu)):
    print(tu[i])
输出:alex
     eric
     rain

  

e. 请使用for、len、range输出元组的索引

1
2
3
4
5
6
tu = (‘alex‘‘eric‘‘rain‘)
for in range(len(tu)):
    print(i,tu[i])
输出:0 alex
     1 eric
     2 rain

  

f. 请使用enumerate输出元祖元素和序号(序号从10开始)

1
2
3
4
5
6
tu = (‘alex‘‘eric‘‘rain‘)
for i,j in enumerate(tu):
    print(i+10,j)
输出:10 alex
     11 eric
     12 rain

  

25、有如下变量,请实现要求的功能
tu = ("alex", [11, 22, {"k1": ‘v1‘, "k2": ["age", "name"], "k3": (11,22,33)}, 44])
a. 讲述元祖的特性

1
和列表一样,但元组是只可读的,不可修改。

  

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

1
不可被修改,元组明确规定存储的数据不应该被修改,强制变更list后可以进行修改。

  

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

1
2
3
4
5
6
k2为列表,可以被修改。
 
tu = ("alex", [1122, {"k1"‘v1‘"k2": ["age""name"], "k3": (11,22,33)}, 44])
tu[1][2]["k2"].append("seven")
print(tu)
输出:(‘alex‘, [1122, {‘k1‘‘v1‘‘k2‘: [‘age‘‘name‘‘seven‘], ‘k3‘: (112233)}, 44])

  

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

1
2
3
4
5
6
7
8
k3为元组,不可以被修改。以下为强制修改:
 
tu = ("alex", [1122, {"k1"‘v1‘"k2": ["age""name"], "k3": (11,22,33)}, 44])
k3为元组部分里的字典中的key
tu[1][3]["k3"]=list(tu[1][3]["k3"])
tu[1][3]["k3"].append("seven")
tu[1][3]["k3"]=tuple(tu[1][3]["k3"])
print(tu)

  

 

26、字典
dic = {‘k1‘: "v1", "k2": "v2", "k3": [11,22,33]}
a. 请循环输出所有的key

1
2
3
4
5
6
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
for key in dic.keys():
    print(key)
输出:k1
     k2
     k3

  

b. 请循环输出所有的value 

1
2
3
4
5
6
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
for value in dic.values():
    print(value)
输出:v1
     v2
     [112233]

  

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

1
2
3
4
5
6
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
for i ,j in dic.items():
    print(i,j)
输出:k1 v1
     k2 v2
     k3 [112233]

  

d. 请在字典中添加一个键值对,"k4": "v4",输出添加后的字典 

1
2
3
4
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
dic["k4"]="v4"
print(dic)
输出:{‘k1‘‘v1‘‘k2‘‘v2‘‘k3‘: [112233], ‘k4‘‘v4‘}

  

e. 请在修改字典中 “k1” 对应的值为 “alex”,输出修改后的字典

1
2
3
4
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
dic["k1"]="alex"
print(dic)
输出:{‘k1‘‘alex‘‘k2‘‘v2‘‘k3‘: [112233]}

  

f. 请在k3对应的值中追加一个元素 44,输出修改后的字典

1
2
3
4
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
dic["k3"].append(44)
print(dic)
输出:{‘k1‘‘v1‘‘k2‘‘v2‘‘k3‘: [11223344]}

  

g. 请在k3对应的值的第 1 个位置插入个元素 18,输出修改后的字典

1
2
3
4
dic = {‘k1‘"v1""k2""v2""k3": [11,22,33]}
dic["k3"].insert(0,18)
print(dic)
输出:{‘k1‘‘v1‘‘k2‘‘v2‘‘k3‘: [18112233]}

  

27、转换
a. 将字符串 s = "alex" 转换成列表

1
2
3
4
s="alex"
s=list(s)
print(type(s))
输出:<class ‘list‘>

  

b. 将字符串 s = "alex" 转换成元祖

1
2
3
4
s="alex"
s=tuple(s)
print(type(s))
输出:<class ‘tuple‘>

  

b. 将列表 li = ["alex", "seven"] 转换成元组

1
2
3
4
5
li=["alex","seven"]
li=tuple(li)
print(type(li))
 
输出:<class ‘tuple‘>

  

c. 将元祖 tu = (‘Alex‘, "seven") 转换成列表

1
2
3
4
tu = (‘Alex‘"seven")
tu=list(tu)
print(type(tu))
输出:<class ‘tuple‘>

  


d. 将列表 li = ["alex", "seven"] 转换成字典且字典的key按照 10 开始向后递增
1
2
3
4
5
6
7
8
li = ["alex""seven"]
dir={}
a=10
for in li:
    dir[a]=i
    a+=1
print (dir)
输出:{10‘alex‘11‘seven‘}

  

28、转码
n = "老男孩"
a. 将字符串转换成utf-8编码的字节,并输出,然后将该字节再转换成utf-8编码字符串,再输出

1
2
3
4
5
6
7
n="老男孩"
n1=n.encode("utf-8")
print(n1)
n2=n1.decode("utf-8")
print(n2)
输出:b‘xe8x80x81xe7x94xb7xe5xadxa9‘
    老男孩

  

a. 将字符串转换成gbk编码的字节,并输出,然后将该字节再转换成gbk编码字符串,再输出

1
2
3
4
5
6
7
8
n="老男孩"
n1=n.encode("gbk")
print(n1)
n2=n1.decode("gbk")
print(n2)
输出:b‘xc0xcfxc4xd0xbaxa2‘
    老男孩
更多编码问题链接:http://www.cnblogs.com/yuanchenqi/articles/5956943.html

  

29、求1-100内的所有数的和

1
2
3
4
5
sum=0
for in range(101):
    sum+=i
print(sum)
输出:5050

  

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

1
2
3
4
5
6
7
8
9
10
11
12
13
tu=[11,22,33,44,55,66,77,88,99,90]
n1=[]
n2=[]
dir={}
for in tu:
    if i >66:
        n1.append(i)
    else:
        n2.append(i)
dir["k1"]=n1
dir["k2"]=n2
print(dir)
输出:{‘k1‘: [77889990], ‘k2‘: [112233445566]}

 

以上是关于第一章/第二章课后习题的主要内容,如果未能解决你的问题,请参考以下文章

软件设计师教程第5版课后习题答案

高等数学 本科少学时类型 第4版 上册 课后习题 答案 同济大学数学系

第一章课后习题

课后习题答案

[数电] 第一章数制和码制——课后习题

课程作业|图论第一章课后习题