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=0while 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=2total_1=0total_2=0while i<=100: if i%2==0: total_1+=i else: total_2+=-i i+=1total=total_1+total_2print(total) |
b. 使用 for 循环和 range 实现输出 1 - 2 + 3 - 4 + 5 - 6 ... + 99 的和
|
1
2
3
4
5
6
7
8
9
|
total_1=0total_2=0for i in range(100): if i%2==1: total_1+=i else: total_2+=-itotal=total_1+total_2print(total) |
c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12
|
1
2
3
4
5
6
7
8
9
|
i=1while 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=1while i<=100: if i%2==1: print(i) i+=1 |
e. 使用 while 循环实现输出 1‐100 内的所有偶数
|
1
2
3
4
5
|
i=1while 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 |
14、现有如下两个变量，请简述 n1 和 n2 是什么关系？
|
1
2
3
4
5
6
7
|
n1 = 123456n2 = 123456n1和n2使用不同的内存地址python内部的优化： -5到157之间的赋值变量都是相同的地址 |
15、现有如下两个变量，请简述 n1 和 n2 是什么关系？
|
1
2
3
4
5
|
n1 = 123456n2 = n1使用同一内存地址，只是变量名不同 |
16、如有以下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示？
|
1
|
3个二进制位表示，00000101 |
17、布尔值分别有什么？
|
1
2
3
|
True和False在二进制中的0、1。很多情况下，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 i 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 i 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 i 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‘], 123, 446]print(li[2][1][1]) |
b. 请使用索引找到 ‘all‘ 元素并将其修改为 “ALL”
|
1
2
|
li = ["hello", ‘seven‘, ["mon", ["h", "kelly"], ‘all‘], 123, 446]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 i 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 i 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", [11, 22, {"k1": ‘v1‘, "k2": ["age", "name"], "k3": (11,22,33)}, 44])tu[1][2]["k2"].append("seven")print(tu)输出：(‘alex‘, [11, 22, {‘k1‘: ‘v1‘, ‘k2‘: [‘age‘, ‘name‘, ‘seven‘], ‘k3‘: (11, 22, 33)}, 44]) |
d. 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 “Seven”
|
1
2
3
4
5
6
7
8
|
k3为元组，不可以被修改。以下为强制修改：tu = ("alex", [11, 22, {"k1": ‘v1‘, "k2": ["age", "name"], "k3": (11,22,33)}, 44])k3为元组部分里的字典中的keytu[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 [11, 22, 33] |
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 [11, 22, 33] |
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‘: [11, 22, 33], ‘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‘: [11, 22, 33]} |
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‘: [11, 22, 33, 44]} |
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‘: [18, 11, 22, 33]} |
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=10for i in li: dir[a]=i a+=1print (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‘\xe8\x80\x81\xe7\x94\xb7\xe5\xad\xa9‘ 老男孩 |
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‘\xc0\xcf\xc4\xd0\xba\xa2‘ 老男孩更多编码问题链接：http://www.cnblogs.com/yuanchenqi/articles/5956943.html |
29、求1-100内的所有数的和
|
1
2
3
4
5
|
sum=0for i in range(101): sum+=iprint(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 i in tu: if i >66: n1.append(i) else: n2.append(i)dir["k1"]=n1dir["k2"]=n2print(dir)输出：{‘k1‘: [77, 88, 99, 90], ‘k2‘: [11, 22, 33, 44, 55, 66]} |
