Python基础练习

Posted on

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

在Windows中执行，通过cmd 进入相应的Python文件(如hello.py)的路径，在cmd中输入python hello.py就可以执行。
通过IDE软件，如pycharm，ctrl+shift+F10执行脚本
在Linux系统中：
在Python文件的开头需要添加python的路径,不清楚路径通过whichis python3 查看
执行：Python3 hello.py

2、 简述位、字节的关系

位(bit)是计算机中最小的单位，8位代表1字节(byte)

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

ASCII中每个字符占1个字节，unitcode通常是2个字节，但是如果写的都是英文就会占用过多的空间。UTF-8是可变长字符编码，根据不同数字的大小编码成1-6个字节，通常英文占1个字节，汉字通常占3个字节。GBK编码是中国自己的标准，占2个字节，Windows系统默认中文的就是GBK编码。

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

UTF-8：48位(utf-8每个中文占用3个字节，总共6个字节)
GBK:32位(每个中文是2个字节，李杰是4个字节)
验证：（在Python中使用encode可以转换成相应的编码格式）

1
2
3
4
>>> '李'.encode('gbk')
b'\xc0\xee'
>>> '李'.encode('utf-8')
b'\xe6\x9d\x8e'

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

Python单行注释用 #
Python多行注释用三对单引号或者三对双引号

1
2
3
4
5
6
‘’’
这是注释
‘’’
“””
这是注释
“””

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

首先变量是以字母下划线开头的，在Python中声明变量最好通过下划线分隔，变量名还需要见名知意，不要使用a b c 等简单的变量来代替。

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

例如定义了变量name=1
查看name内存地址：

1
id(naem)

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

.pyc文件是由.py文件经过编译后生成的字节码文件，其加载速度相对于之前的.py文件有所提高，而且还可以实现源码隐藏，以及一定程度上的反编译。

19、写代码

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

1
2
3
4
5
6
7
8
9
10
11
import getpass
username=input("username:")
passwd=getpass.getpass("passwd:\n")  # 输入密码的时候不是明文
print(username,passwd)
if username=="seven" and passwd=="123":
    print("登录成功")
else:
    print("登录失败")

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import getpass
count = 0    #定义了一个计数器
while True :
	username=input("username:")
	passwd=getpass.getpass("passwd:\n") # 输入密码的时候不是明文
	print(username,passwd)
	if username=="seven" and passwd=="123":
		print("登录成功")
	else:
		print("登录失败")
		count += 1
		if  count >= 3:   #计数器判断登录失败的次数
			break

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import getpass
count = 0
while True :
	username=input("username:")
	passwd=getpass.getpass("passwd:\n") #输入密码的时候不是明文
	print(username,passwd)
	if username=="seven"or username =='alex' and passwd=="123":   # 修改得位置
		print("登录成功")
	else:
		print("登录失败")
		count += 1
		if  count >= 3:
			break

10、

a.使用while循环输出2-3+4-5+6…+100的和：

1
2
3
4
5
6
7
8
9
10
11
12
13
n = 0
sum = 0
sum_odd = 0  # 奇数
sum_evn = 0  # 偶数
while n < 100:
    n += 1
    if n%2 == 0:  # 这是偶数
        # continue
        sum_evn += n  # 偶数求和
    if n%2 != 0 :
        sum_odd += n  # 奇数求和
sum = sum_evn - sum_odd + 1  # 将多减的1减去
print(sum)

结果：51

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

1
2
3
4
5
6
7
8
9
10
sum = 0
sum_odd = 0  # 奇数
sum_evn = 0  # 偶数
for num in range(100):  # range生成0-99
    if num%2 == 0:  # 这是偶数
        sum_evn += num  # 偶数求和后需要取反
    if num%2 != 0 :
        sum_odd += num  # 奇数求和
sum = sum_odd - sum_evn
print(sum)

结果是：50

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n = 0    # 定义了一个计数器
while True :
	n += 1
	if n < 6 :
		print(n)  
	elif n == 6 :
		continue
	elif n > 6 and n < 10:
		print(n)
	elif n == 10:
		continue
	elif n < 13:
		print(n)
	if n ==13 :   # 在这里对n进行清零操作
		n = 0

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

1
2
3
4
5
6
7
8
n = 0    #定义一个计数器n
while n < 100:   
	n += 1
	if n%2 == 0:   # 判断是偶数的时，跳过这次循环
		continue
	print(n)
	if n >= 99:  #打印完最后一个奇数后清零  重新进入循环
		n = 0

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

1
2
3
4
5
6
7
8
n = 0    #定义一个计数器n
while n < 100:   
	n += 1
	if n%2 ！= 0:   # 判断是奇数时，跳过这次循环
		continue
	print(n)
	if n >= 99:  #打印完最后一个奇数后清零  重新进入循环
		n = 0

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

1
2
3
4
5
十进制      二进制
5			0101
10			1010
32		 	100000
7			0111

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

  • 可以把对象比作一个人，让人做某件事情，不需要考虑中间的过程，只需要给一个指令，然后这个人就把事情做完了。

  • 类可以认为是一个模板

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

n1    =    123    
n2    =    123

变量通常是保存在内存中的，变量不是直接指向的内容，而是先指向存内容123的地址，这个地址就相当于门牌号。

使用id()查看变量的地址，发现地址是相同的，即便是将n1重新复制给n3，内容也是一样的，说明n1 n2存储的内容指向同一个地址。

1
2
3
4
5
6
7
8
>>> id(n1)
**1584640928**
>>> id(n2)
**1584640928**
>>> n3 = n2
>>> id(n3)
**1584640928**

通过查找资料，发现这不是绝对的，在数字很小的时候，id是一样的，是Python对此进行了缓存。但是在pycharm中都是一样的，应该是pycharm本身处理的。

下面是做的实验测试确定范围（在Python终端中测试）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
>>> n1 = 256
>>> n2 = 256
>>> id(n1)
**1403044928**
>>> id(n2)
**1403044928**
>>> n1 = 257
>>> n2 = 257
>>> id(n1)
**34317424**
>>> id(n2)
**34320112**   # 此时就不一样了
>>> n1 = -5
>>> n2 = -5
>>> id(n1)
**1403495328**
>>> id(n2)
**1403495328**
>>> ^Z
>>> n1 = -6
>>> n2 = -6
>>> id(n1)
**37378992**
>>> id(n2)
**37378960**
>>>

测试的结果是：缓存的范围是[-5~256]

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

n1    =    123456    
n2=    123456    

1
2
3
4
5
6
7
>>> n1 = 123456
>>> n2 = 123456
>>> id(n1)
**1945328**
>>> id(n2)
**37378992**
>>>

现在n1 n2的地址是不一样的，说明n1 n2 是完全不同的

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

1
2
3
4
5
6
7
>>> n1 = 123456
>>> n2 = n1
>>> id(n1)
5874800
>>> id(n2)
5874800
>>>

通过测试发现n1 n2的地址是一样的，说明n1把自己的地址赋值给了n2,这个地址指向的是同一个内容123456

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

1
0b101

二进制最少是3位

17、布尔值分别有什么？

  • True
  • False

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

a    =    "alex"    
b    =    a.capitalize()      # 首字母大写
print(a)    
print(b)    

请写出输出结果：    

1
2
"alex"
"Alex"

capitalize()将变量a转换成大写并赋值给b

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

name = “ aleX”

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

1
2
name = " aleX"
print(name.strip())  # 通过strip()去除空格

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

如果直接用startwith判断的时候，返回得是False，name的开头是空格，通过上一步去除空格后

1
2
3
name = " aleX"
name1 = name.strip()
print(name1.startswith('al'))

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

1
2
name = " aleX"
print(name.endswith('X'))    # endswith()查看结尾

d. 将 name 变量对应的值中的 “l” 替换为 “p”， 并 输 出 结 果

1
2
3
name = " aleX"
print(name.replace('l','p'))  # 字符串的替换

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

1
2
name = " aleX"
print(name.split('l'))

输出结果是：
[‘ a’, ‘eX’]

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

列表list

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

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

ALEX

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

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

alex

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

1
2
3
name = " aleX"
# print(name.find(2))
print(name[2])

Python字符串可以看做list的对象

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

1
2
3
4
5
6
7
8
name = " aleX"
name = list(name)  # 将字符串转换成一个有序的列表
print(name)
conut = 0  # 定义count计数器
for i in name:
    conut +=1
    if conut < 4 :
        print(i)

输出的前三个是： 空格 a l

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

1
2
3
4
name = " aleX"
name = list(name)
print(name[-2])
print(name[-1])

还是把字符串转换成列表，直接根据列表的索引值求出

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

1
2
name = " aleX"
print(name.index('e'))  # 直接查找字符串的索引值

得出的索引值是3

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

  1. 可以迭代
    1
    2
    for iteration in 'abdefg':
        print iteration

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

使用join直接把列表拼接成字符串，前面的分号可以添加分隔符号

1
2
3
li = ['alex','eric','rain']
# print("".join(['alex','eric','rain']))  
print("".join(li))  #

结果：alexericrain

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

li＝[‘alex’,’eric’,’rain’]

a. 计算列表长度并输出 

1
2
li = ['alex','eric','rain']
print(len(li))

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

1
2
3
li = ['alex','eric','rain']
li.append('seven')   # 在末尾添加
print(li)

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

1
2
3
li = ['alex','eric','rain']
li.insert(1,'Tony')  # def insert(self, index, p_object):
print(li)

忘记怎么用查看下函数的定义，index在前面

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

1
2
3
li = ['alex','eric','rain']
li[2] = 'Kelly'
print(li)

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

1
2
3
li = ['alex','eric','rain']
del li[li.index('eric')]  #  li.index('eric')   # 获取eric的索引值
print(li)

首先获取eric的索引值，然后通过索引来删除

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

1
2
3
4
li = ['alex','eric','rain']
print(li[1])
del li[1]
print(li)

列表的顺序是从0 开始的

输出结果：
eric
[‘alex’, ‘rain’]

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

1
2
3
li = ['alex','eric','rain']
del li[2]
print(li)

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

1
2
3
li = ['alex','eric','rain']
del li[1:3]  # 切片删除
print(li)

切片删除，[start : end : step] start end 是索引 的起始位置，step是步长

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

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

输出结果：
[‘rain’, ‘eric’, ‘alex’]

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

1
2
3
li = ['alex','eric','rain']
for num in range(len(li)):     
    print(num,li[num])

输出结果：
(0, ‘alex’)
(1, ‘eric’)
(2, ‘rain’)

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

1
2
3
li = ['alex','eric','rain']
for index,item in enumerate(li,100) :  # 这个参数可以指定索引开始的值
    print(index,item)

输出结果：
(100, ‘alex’)
(101, ‘eric’)
(102, ‘rain’)

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

1
2
3
li = ['alex','eric','rain']
for index in li:
    print(index)

输出结果：
alex
eric
rain

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

li=[“hello”, ‘seven’, [“mon”, [“h”,”kelly”],’all’],123,446]

a. 请输出 “Kelly”

1
2
3
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
name = str(li[2][1][1])
print(name.capitalize())

Kelly

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

1
2
3
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
li= str(li[2][2])
print(li.upper())

结果：
ALL

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

tu ＝ (‘alex’, ‘eric’, ‘rain’)

a.计算元组长度并输出 

1
2
tu = ('alex','eric','rain')
print(len(tu))

结果：3

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

1
2
tu = ('alex','eric','rain')
print(tu[1])   # 和列表一样 都是从0 开始

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

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

结果：
(‘alex’, ‘eric’)

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

1
2
3
tu = ('alex','eric','rain')
for menu in tu:
    print(menu)

结果:
alex
eric
rain

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

1
2
3
tu = ('alex','eric','rain')
for num in range(len(tu)):
    print(num,tu[num])

结果：
(0, ‘alex’)
(1, ‘eric’)
(2, ‘rain’)

f. 请使用 enumrate 输出元祖元素和序号（序号从 10 开始） 

1
2
3
tu = ('alex','eric','rain')
for index,item in enumerate(tu,10) :
    print(index,item)

结果：
(10, ‘alex’)
(11, ‘eric’)
(12, ‘rain’)

24、有如下变量，请实现要求的功能

tu=(“alex”,[11, 22, {“k1”:’v1’,”k2”:[“age”,”name”],”k3”:(11,22,33)}, 44])

a. 讲述元祖的特性

元组tuple拥有列表的特性，唯一不同的是不能修改

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

不能修改

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

k2是字典dict，可以修改

1
2
3
tu=("alex",[11,	22,{"k1":'v1',"k2":["age","name"],"k3":(11,22,33)},44])
tu[1][2].setdefault('k4','Seven')
print(tu)

j结果：
(‘alex’, [11, 22, {‘k3’: (11, 22, 33), ‘k2’: [‘age’, ‘name’], ‘k1’: ‘v1’, ‘k4’: ‘Seven’}, 44])

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

k3对应的是元组类型tuple，不能修改

25、字典

dic ={‘k1’:”v1”, “k2”:”v2”,”k3”: [11,22,33]}

a. 请循环输出所有的 key 

1
2
3
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for menu in dic:
    print(menu)

因为字典是无序的，所以输出的也是无序的

结果：
k3
k2
k1

b. 请循环输出所有的 value

1
2
3
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for menu in dic:
    print(dic[menu])  # 先找到key  然后循环把key的值输出

结果：
[11, 22, 33]
v2
v1

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

1
2
3
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic.setdefault('k4','v4')
print(dic)

结果：

{‘k3’: [11, 22, 33], ‘k2’: ‘v2’, ‘k1’: ‘v1’, ‘k4’: ‘v4’}

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

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

结果：

{‘k3’: [11, 22, 33], ‘k2’: ‘v2’, ‘k1’: ‘alex’}

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

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

结果:

{‘k3’: [11, 22, 33, 44], ‘k2’: ‘v2’, ‘k1’: ‘v1’}

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

1
2
3
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k3'].insert(1,18)
print(dic)

{‘k3’: [11, 18, 22, 33], ‘k2’: ‘v2’, ‘k1’: ‘v1’}

26、转换

a. 将字符串 s =”alex” 转换成列表 

1
2
3
s='alex'
temp = list(s)
print(type(temp))

结果：

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

1
2
3
s='alex'
temp = tuple(s)
print(type(temp))

结果：

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

1
2
3
li=["alex","seven"]
temp = tuple(li)
print(type(temp))

结果：

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

1
2
3
tu = ('Alex', "seven")
temp = list(tu)
print(type(temp))

结果：

d.将列表 li=[“alex”,”seven”] 转换成字典且字典的 key 按照10步长开始向后递增 

1
2
3
4
5
li = ["alex","seven"]
temp = {}
for k,v in enumerate(li,10):  # 用枚举的方式
    temp[k] = v
    print(temp)

结果：

{10: ‘alex’}
{10: ‘alex’, 11: ‘seven’}

27、转码

n=”老男孩”

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

1
2
3
n = "老男孩"
print(n.encode(encoding="utf-8"))
print(n.encode(encoding="utf-8").decode(encoding="utf-8"))

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

1
2
3
n = "老男孩"
print(n.encode(encoding="gbk"))
print(n.encode(encoding="gbk").decode(encoding="gbk"))

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

1
2
3
4
sum = 0
for num in range(101):
    sum += num
print(sum)

29、元素分类

有如下值集合 [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
data = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
data_end = {'k1':[],'k2':[]}
for num in data :
    if num < 66 :
        data_end['k2'].append(num)
    if num > 66 :
        data_end['k1'].append(num)
print(data_end)

结果：
{‘k2’: [11, 22, 33, 44, 55], ‘k1’: [77, 88, 99, 90]}

30、购物车

功能要求：要求用户输入总资产，例如：2000 显示商品列表，让用户根据序号选择商品，加入购物车 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功
goods =[
{“name”: “电脑”, “price”: 1999},
{“name”: “鼠标”, “price”: 10},
{“name”: “游艇”, “price”: 20},
{“name”: “美女”, “price”: 998},

]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
© 2018 Peter's Blog Center All Rights Reserved.
Theme by hiero