Python全栈考试（一）

标签：组类型   [1]   eve   style   位置   获取   lower   程序   功能   

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

1) 使用命令行执行Python脚本: python C:\tesst.py

2) 使用各种IDE软件.pycharm wing

2、简述位、字节的关系         

位 (bit) 数据存储是以“字节”位单位的，数据传输大多是以“位”为单位的，以为就代表一个0或1，每8位组成一个字节，是最小一级的信息单位。 

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

　　Ascii码有256位为最原始的版本

　　Unicode位万国码

　　Utf-8为Unicode压缩版 以尽量少字节表达

　　Gbk为汉字编码        

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

　　Utf-8需要用3个字节表示一个汉字 李杰需要使用48位

　　Gbk需要使用两个字节表示一个汉字  李杰需要用32位 

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

            单行注释：# hello

　　　  多行注释：‘‘‘

          　　　　　　hello world

           　　　　　‘‘‘

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

　　1）  变量名由字符、数字、下划线组成

　　2）  变量名不能以数字开头

　　3）  变量名不能是关键字

　　4）  常量定义字符全为大写字符

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

　　使用id函数查看：Id(变量名)

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

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

10、             写代码        

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

name = input(‘please input name>>:‘).strip()
password = input(‘please input password>>:‘).strip()
if name.__eq__(‘seven‘) and password.__eq__(‘123‘):
    print(‘login ok‘)
    break
else:
    print(‘login failed‘)

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

 1 counter = 3
 2 while counter > 0:
 3     counter-=1
 4     name = input(‘please input name>>:‘).strip()
 5     password = input(‘please input password>>:‘).strip()
 6     if name.__eq__(‘seven‘) and password.__eq__(‘123‘):
 7         print(‘login ok‘)
 8     break
 9     else:
10         print(‘login failed‘)

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

counter = 3

while counter > 0:

    counter-=1

    name = input(‘please input name>>:‘).strip()

    pwd = input(‘please input password>>:‘).strip()

    if (name.__eq__(‘seven‘) or name.__eq__(‘alex‘))and pwd.__eq__(‘123‘):

        print(‘login ok‘)

    else:

        print(‘login failed‘)        

   11、写代码           

1. 使用 while 循环实现输出 2 -   3    +    4    -  5    +    6  -.......   +    100         的和         

2.         result = 0
   
   while counter > 1:
   
       if counter % 2 == 0:
   
           result += counter
   
       else:
   
           result -= counter
   
       counter -= 1
   
       
   
   print(result)

    

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

result = 0

for x in range(1,100):

    if x%2==0:

        result-=x

    else:

        result+=x

print(result)

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

counter = 0

while counter <12:

    counter+=1

    if counter==6 or counter ==10:

        print(‘          ‘,end=‘‘)

    else:

        print(counter,end=‘,‘)

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

counter = 1

while counter < 100:

    print(counter)

    counter+=2

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

counter = 2

while counter < 100:

    print(counter)

    counter+=2

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

             5  ： 0b0000 0101
　　　　　　　10  : 0b0000 1010
　　　　　　　32  : 0b0010 0000
　　　　　　　 7  : 0b0000 0111

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

　　　　　　类是对象的集合,如同蛋类中包含鸡蛋,鸭蛋,鹅蛋,egon

　　　　　　蛋{鸡蛋,鸭蛋,鹅蛋,egon};

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

                  　　n1        =    123       

                  　　n2        =    123    

　　　　　　n1和n2两个变量的 在内存中指向的是一个地址，他们的id是一样的

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

                  n1        =    123456         

                  n2        =    123456         

  　　　　 n1和n2数值相等，但是他们的内存id不同

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

                  n1        =    123456         

                  n2        =    n1         

　　　　n1 和 n2 数值相等,内存地址相等,此时变更n1不会影响n2,n1变更数值,其内存地址变更,而n2的内存地址不变

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

          　　 int.bit_length(n1)

18、              布尔值分别有什么？          

　　　　True和False

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

a     =       "alex"   

b     =       a.capitalize()         

                  print(a)       

                  print(b)      

                  请写出输出结果：alex

　　　　　　　　　　　　　 Alex     

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

name =  "           aleX"     

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

　　name.strip()

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

　　name.startwith(“al”)  

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

        name.endwith(“X”)

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

         name.replace(‘l’, ’p’)

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

         name.strp(‘l’)                          

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

        得到的是列表类型的

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

        print(name.strip().supper())   #ALEX

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

　　print(name.strip().lower())       #alex

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

        print(name.strip()[1])      #l

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

        print(name.strip()[:3])     #ale

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

          print(name[-2:])   #eX

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

　　print(name.index(‘e’))           #6

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

            字符串可以迭代 

            str = ‘hello world’

            for item in str:

                   print(item)

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

　　　　str = li[0]+’_’+ li[1]+’_+ li[2]                                       

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

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

1. 计算列表长度并输出       

　　　　　print(len(li))

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

                   print(li.append(‘seven’))

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

                print(li.insert(0,’Tony’))

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

                 li[1]=’Kelly’

                 print(li)

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

               li.remoer(‘eric’)

               print(li)

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

               print(li.pop(2))

               print(li)

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

　　　　print(li.pop(3))

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

　　　　del li[1:3]

　　　　print(li)

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

　　　　print(li.reverse())

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

　　　　for index in range(len(li)):

      　　　　print(index)  

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

              for x,y in enumerate(li,100):

                   print(x,y)

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

               for item in li:

                     print(item)

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

         li          =    ["hello",         ‘seven‘,           ["mon",          ["h",       "kelly"],         ‘all‘],      123,       446]   

1. 请输出       “Kelly”

　　　　print(li[2][1][1])  

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

         　 print(li[2][2].upper())

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

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

1. 计算元组长度并输出       

               print(len(tu))

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

　　　　print(tu[1])

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

　　　　print(tu[:2])

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

　　　　for item in tu:

     　　　　 print(item)                   

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

               for index in range(len(tu)):

                     print(index)

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

　　　　for index value in enumerate(tu):

      　　　　print(index,value)

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

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

1. 讲述元祖的特性      

                        元组是不可变类型，主要体现在元组的每个元素id唯一

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

                        不可以被修改

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

                     K2对应的是列表类型，可以被修改，

                     tu[1][2].get(‘k2’).append(“Seven”)  

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

                        K3对应的是元组类型  不可被修改

26、              字典   

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

1. 请循环输出所有的 key           

　　　　for key in dic.keys:

      　　　　print(key)

　　 2.请循环输出所有的 value

　　　　for value in dic.values:

     　　　　 print(value)        

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

　　　　for key,value in dic.items:

      　　　　print(key:‘%s  value:%s’   % (key,value))

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

　　　　　dic[‘k4’]) = ‘k4’)  print((dic)

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

　　　　dic[‘k1’] = ‘alec’  print(dic)

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

              dic[‘k3’].append(44)  print(dic)

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

              dic[‘k3’].insert(0,18)  print(dic)

27、转换                           

1. 将字符串            s           =    "alex"     转换成列表         

            l = []

　　　for char in s:

                l.append(char)

                print(l)

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

              l = []

　　　　for char in s:

                   l.append(char)

                   print(tuple(l)l)

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

                   tuple(li)

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

                    list(tu)

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

                   dic = dict(enumerate(li,10))

                   print(dic)

28、  转码   

         n          =    "老男孩"       

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

　　　　　　sstr=n.encode("UTF-8")
　　　　　　print(sstr)
　　　　　　sstr.decode("UTF-8")
　　　　　　print(sstr)

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

　　　　　　sstr=n.encode("GBK")
　　　　　　print(sstr)
　　　　　　sstr.decode("GBK")
　　　　　　print(sstr)

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

                        result = 0

                        for i in range(100):

                                     result +=i

                            print(result)

29、元素分类   

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

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

            l = [11,22,33,44,55,66,77,88,99,90]

dic = {’k1’:[],’’k2:[]}

            for item in l:

                   if  item > 66

                            dic[‘k1’].append(item)

                   else:

                            dic[‘k2’].append(item)

         print(dic)

30、              购物车        

                  功能要求：         

                                      要求用户输入总资产，例如：2000           

                                      显示商品列表，让用户根据序号选择商品，加入购物车         

                                      购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。           

goods           =    [   
 {"name":      "电脑",           "price":           1999},           
{"name":      "鼠标",           "price":           10},       
 {"name":      "游艇",           "price":           20},       
{"name":      "美女",           "price":           998},    

 ]          
assets = 2000

cart_l = []

while True:

    cmd = input(‘1.Shopping\n2.Settlement\nPlease input 
index>>:‘)

    if not cmd.isdigit():continue

    if int(cmd) <= 0  or int(cmd) >2:

        print(‘commend not exist‘)

        continue

    if cmd == ‘1‘:

        for index, goods_d in enumerate(goods_l, 1):

            name, price = goods_d.items()

            print(‘%d.goods name:%s goods price:%s‘ % (index, name[1], price[1]))

        cmd = input(‘please select your goods by index>>:‘)

        if not cmd.isdigit():continue

        index_s = int(cmd)

        if index_s <= 0 or index_s > len(goods_l):continue

        while True:

            num = input(‘please select number of goods>>:‘)

            if num.isdigit(): break

        cart_l.append((goods_l[index_s-1], int(num)))

        print(cart_l)

    else:

        totals = 0

        for goods_msg in cart_l:

            totals += goods_msg[0][‘price‘] * (goods_msg[1])

        if totals <= assets:

            print(type(totals))

            print(‘you settlement ok!!,and balance is %d $‘ % (assets - totals))

        else:

            print(‘balance is not enough!!!1‘)

        break

Python全栈考试（一）

标签：组类型   [1]   eve   style   位置   获取   lower   程序   功能   

原文地址：http://www.cnblogs.com/richiewlq/p/7220844.html