Python基础知识汇总

1.执行脚本的两种方式

Python a.py     直接调用Python解释器执行文件

chomd +x a.py   ./a.py    #修改a.py文件的属性，为可执行，在用  ./  执行a.py 文件

2、简述位、字节的关系

1bytes=8bit  ,2**8=256,可以代表256中变化，

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

ascii 是最早美国用的标准信息交换码，把所有的字母的大小写，各种符号用 二进制来表示，共有256中，加入些拉丁文等字符，1bytes代表一个字符，

Unicode是为了统一世界各国语言的不用，统一用2个bytes代表一个字符，可以表达2**16=65556个，称为万国语言，特点：速度快，但浪费空间，

可以用在内存处理中，兼容了utf-8，gbk，ASCII，

utf-8 为了改变Unicode的这种缺点，规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的，

gbk  是中文的字符编码，用2个字节代表一个字符，

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

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

多行注释  """  """三个双引号或是三个单 引号把要解释的内容放中间， ‘’‘  ’’’

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

万能避错规则，以小写字母开头命名，可以加上下划线，或者数字，

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

.pyc 是编译py文件后的二进制文件，用于加速运行

10、写代码
" F: z% W/ e4 D7 L' pa.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
0 r5 ~# c! x# [; i2 ~pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
) X% Z. f- h: R) H    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
4 J& p  @  o! }- e) l' {8 U3 v    pwd = input('pwd：').strip()
! K8 d2 |% t/ B( w3 D
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
$ ?0 m" k* z0 Y7 d% T$ p$ _, }% Y( Q        count += 1
for循环：
1 r! X( L2 K, ]& E6 N# {8 H, d+ [for count in range(3) :
- P, ^4 j; L' R6 A$ Q$ i8 ]) p    name = input('name:').strip()
5 |( t8 m% A5 k    pwd = input('pwd：').strip()
% m) ]1 _* T0 M# X6 K
    if name=='seven' and pwd=='123' :
2 i- U0 \& G; D7 B        print('ok')
2 T5 f, F5 r6 o    else:
: }- U& r/ C: P: h        print('error')
6 z+ |  H$ ?; Z8 n: e! Y0 L1 I        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
& N- ]  j% g7 ^' Y) c8 ]9 O7 Bwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
( ~' w, j6 K( D3 x$ G1 ?8 u* ^    else :
$ }! L$ C' w( Z        print('error')
( F2 N% v7 W$ ~        count+=1
6 @/ N6 w) z0 m: D5 J: J) Kfor循环
7 H5 v2 `0 K5 Y  L1 r5 Kfor count in range(3)  :
- H% s' |( N* A4 s( j4 F    name = input('name: ')
" H5 y" z% t$ s( I) d6 K    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
. i. Q/ ^5 }3 T8 t    else :
        print('error')
        count+=111、写代码
/ @" b! S. A1 Y- x. v7 n* sa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
  K- P8 g5 t9 `6 Z' E& Qwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
7 c- s5 j+ Z9 J, i        count+=1
7 ]! M$ e) A4 G2 R. j, O8 J0 \    else:
        num=num-count
: x+ C7 o/ g+ h; ^        count+=1
print(num)
* ^5 O. Q" W' B' n- O5 C$ G4 ]
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
# D2 D+ u. |2 n( J9 E* bcount=1
5 {+ e7 @: V( M) |' v! gfor count in range(100) :
% j2 {& @7 v; W/ f    if count % 2 == 0 :
, G  r7 V  p7 x        num=num - count
1 |1 o' o3 S$ y2 _$ W    else :
        num=num+count
5 x; v4 V  m7 E0 Kprint(num)

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

count=1
+ i- M. T- q( l  R& C! gwhile count < 13 :
' J1 P" v6 W+ z+ L  P/ y- ^% j$ g( G    if count !=6 :
8 q5 l5 u( N  P6 J        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)
+ c5 t! |4 t, k, `& Q4 x
count=0
while count<100 :
    if count %2 != 0 :
        print(count)
- V+ x, H  L  N7 H2 f+ I    count += 1
5 ?8 G0 f% G1 u" f+ }. D2 U
7 h3 s2 i, G4 D) z* Ye. 使用 while 循环实现输出 1-100 内的所有偶数
. }/ Q9 |4 Z3 p; b2 n. @$ Xfor i in range(100) :
& \5 B2 V) \0 d: t    if i %2 == 0:
        print(i)
3 i; b. S; p+ s/ t" [
, f5 m7 n2 n! C7 U2 Pcount=0
6 u3 _. d3 k9 E' c) X& N4 ]while count<100 :
$ f; C: \& x% c" B) i- u! U    if count%2 == 0 :
6 I( o7 z7 L: G- S+ P7 C3 M3 y" t        print(count)
/ |' g, v. j2 n5 b    count+=1

+ A  i0 W, ^6 z) j* x6 ]12、分别书写数字 5，10，32，7 的二进制表示
, Z& a$ ]% f2 t4 A
print(bin(5))二进制   0b101
) G6 x* c6 t: c$ T4 F! u0 m) W' z8 c1 Hprint(hex(10))十六进制  0x5
1 {: k2 K, e# ?  p0 oprint(oct(5))  八进制  0o5
- O' m* G! [  x+ W" s. }14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

n1,n2是连个不同的变量名，但值都一样，都指向了同一个内存地址，

1 C6 H# G  i0 U. w+ Z, f/ o! B16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
' \5 R- ^$ V& f+ _2 z9 P. xprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
9 f# B  Q, F# c! R. `" {* x; |a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
$ G* N/ Q2 l, U* W% X9 f" {+ Y) i
+ y+ T, `5 l0 y4 L' x4 ^  `$ s# Zb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
/ \6 ]. L. P8 f+ W3 j2 q# gc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
( G! p  c8 |0 f) id. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
% f9 f( [3 _0 ]8 x) o+ j9 J& Tprint(name.replace('l','p'))   apex  
! M8 `, U# w' i  O; r; me. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

1 }# `7 z; L) m7 R' ?g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
# T2 K0 H9 I0 L0 Y
' C! m) g9 P" N; P; ~" cj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
5 \% ^, _$ \" [! W% r8 i' w" ifor i in range(len(name)) :
    print(name)
2 b$ X' U4 |* `9 ^! [for i in name:
4 ?, X5 U. \, t6 [2 q/ K) b# p' d3 `/ l    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
( T6 \$ a5 X+ V9 O  \. tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
. `' l1 n8 b/ zprint(li)
* H4 b8 A2 N7 w. S ['alex', 'eric', 'rain', 'seven']
# `1 u' K) p  Y/ Dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 G  G0 O& \* J( U  ]print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
4 x9 a) `, E$ O0 oe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
. l  q  T" ~3 O2 u2 e! G; [' o& v指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
# `5 G$ ]* ^* E" P& ?4 V* k9 r3 T/ Af. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)

eric
0 ]/ [$ t! I) m' k( ^3 `9 D['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, W: N8 z- i8 gdel li[1:]
5 e3 B5 f/ ~- C' f! _4 M3 t5 H0 C1 a3 ]print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
' a6 r3 {+ c$ L5 @  ?: dfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! G( `6 \9 R: B$ @& u, `a. 请输出 “Kelly”
: Y% K1 `& @  K& `li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
8 J6 M; O( \! }  z2 D9 M1 y4 v. mb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: a) a6 U' z# d; tli[2][2]='ALL'
* P+ @' @0 c: |# E4 g4 y$ Aprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
5 H7 F  a3 T( f3 `9 C0 Wb. 获取元组的第 2 个元素，并输出
% ]  ~/ n3 i$ c2 j) dprint(tu[1])
! I2 y0 J& z& G7 e8 \7 Le. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
& F5 x$ r# x+ f$ F& l    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
$ C4 n+ a" ^& @/ m/ G6 z- t    print(k,v)
9 x$ \; P- W0 ~) G( T7 L( O  `10 alex
11 eric
12 rain

! d% N( K. h% @1 z* vfor k in enumerate(tu,10) :
% D7 R" ^7 U0 i* W2 K2 r    print(k)
(10, 'alex')
(11, 'eric')
4 O6 ?" L  e8 S2 f  A(12, 'rain')

( B6 U; ?. `6 F
25、有如下变量，请实现要求的功能
; j; _1 V+ }" A3 O0 _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

4 J! ^% T! F8 T* Kd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
; T9 f  |9 X2 Nres=tu[1][2]['k2'].append('seven')

# Q' g0 h) l/ ]/ r. ^6 p2 B: Aprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
% R! g3 f* W1 d/ L# Qprint(i,dic)
) \8 w5 K" x) x# P9 _: {$ Zd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
6 m9 K9 b# M$ n6 b" b3 r) s4 i0 ?( Bdic['k4']='v4'
print(dic)
* d3 w# \  `$ {3 W! C+ {e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
  P2 V: \7 @' J, N/ [
. d; E8 G7 I8 Rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ u3 ~' a" W+ [# \! D9 i  ydic['k3'].insert(0,44)
print(dic)
27、转换
9 M1 [/ w8 m* ^. Z* o6 T1 Qa. 将字符串 s = "alex" 转换成列表  s = "alex"
4 {% V4 C4 \" A7 {! b% V) H- k; g
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
6 \! j# c+ G3 E2 t/ Pprint(tuple(s))
$ g- g1 M% R/ ~% B/ S* `3 E" E
b. 将列表 li = ["alex", "seven"] 转换成元组
  K( D8 l+ a' c1 vli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
, I& u8 o6 r! y' Uprint(li)
4 |1 j) i# @2 X5 |, d0 F
1 c* B9 B. Y. @9 H1 Z: l1 }. E
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
0 o0 b- L& a% v# j! ~. Y0 t
dic={}
* T+ B$ r# z4 X- q8 X" j" E- Gfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
; E- C$ j% B6 [; P5 O' w" z7 ]    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
9 ?$ ], y2 ^3 Aprint(a)
* [) N0 O: @8 p2 nb=a.decode('gbk')
$ B: ]( j: S, N+ Fprint(b)28、求 1-100 内的所有数的和
) N9 R' Q$ h' Ocount=1
( ~2 H8 y- v) O2 T& p( c- a) s, ?sum=0
for i in range(100) :
9 e- t+ b; P5 k2 s2 \    sum=sum+count
' V. O7 {0 Y8 Q! `3 J    count+=1
! L4 F% R4 T6 P1 _- T! \3 H, dprint(sum)

count=1
. E" h3 ]# `( |sum=0
while count<=100 :
    sum+=count
    count+=1
/ E( D" @, _; |* iprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
( S9 c) o! j  ?5 Dli=[11,22,33,44,55,66,77,88,99,90]
. Y, I2 R+ Y( k0 J. idic1={
8 Z+ U+ c7 B8 U    'max':[],
    'min':[]
}
$ @1 o; d: @, y1 B2 b( }for i in li :
    if i <66 :
        dic1['min'].append(i)
* `" w$ i) B4 H" {; w4 D" M, c    else:
+ O# Y! o; l3 [/ h, j. T* o        dic1['max'].append(i)
4 t! f4 i. A2 Z; L4 B, I+ O+ cprint(dic1)
5 Q  T0 F% o' H
4 h5 w$ ^% _6 C' C  n$ G4 O' w1 R5 E3 Q---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}