Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

' h. h) X4 I; Y3、简述 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

$ R' g2 v0 O. h5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

, E- h9 s( \# D$ l' c+ }# i- w8、如何查看变量在内存中的地址?
z=1
print(id(z))
* D. Y7 ^: ~) \' V5 {+ n9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

% w) D3 v3 Z% _# U# B* w! X# L10、写代码
; Y. h1 |2 W% ~a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
* w* t1 w6 W: g$ d2 R1 I- bpwd=input('pwd：').strip()
+ b% h  Q! j$ b, ^3 l+ o" lif name=='seven' and pwd=='123' :
: A, b- J3 P& p+ q9 P* I9 D    print('ok')
# U, s" k) Y, S( C7 b; }else:
    print('error')

( f' o, a" `! p3 P* U' j! l+ |b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
2 v  L, y/ x/ S9 I' M" A; Icount=1
while count<=3 :
* B$ Q2 J2 y( a    name = input('name:').strip()
- V. f, f( T* ]3 F( ~    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
# |. |/ G* i, @) L, }8 D2 {        print('ok')
. A( S3 N% }% A) {4 n# w$ @    else:
; n7 K8 b% |7 E/ v0 y3 s% p        print('error')
' P( h" v0 N: U% u+ ?' W        count += 1
for循环：
0 X2 O: h: O) M8 L4 Y1 T5 pfor count in range(3) :
# a/ O. @5 L1 @    name = input('name:').strip()
    pwd = input('pwd：').strip()
2 X( J9 M! X* d
    if name=='seven' and pwd=='123' :
, x1 j1 j8 X4 k        print('ok')
  U! h+ c4 Q/ b# O1 G    else:
& r1 D. C# a$ r( ~        print('error')
4 m2 |. ]4 Y% Z/ ]- }* m        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
7 j6 W& B# J% Y# r: Icount =1
while count<=3 :
- q0 V, E2 c' d* q7 X& d' B9 X4 ^    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
, S2 I& \0 _. E5 r+ Z    else :
        print('error')
        count+=1
6 W; F( E! D) a) T" g5 Yfor循环
' m& t2 ~* Z6 M  D. p+ o* ~4 |for count in range(3)  :
2 u+ U* f) u8 V: A7 b5 @    name = input('name: ')
    pwd = input('pwd: ')
7 ?- p+ H4 p* r3 ?8 y, V    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
! K- i5 C6 o; Y4 _6 t: j& q        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
- E4 [# ]6 {( e5 b6 Enum=0
& f( }2 T" q) v& awhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
1 e0 Y5 I2 }$ B0 i* u3 J        num=num-count
        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
. D1 t5 s  n" z. Tcount=1
8 ^' C9 `" q7 `$ x7 gfor count in range(100) :
    if count % 2 == 0 :
& R6 h3 U- Y& \& q" e8 ~        num=num - count
    else :
        num=num+count
0 T. S* Z! n* z  Cprint(num)

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

! u7 H% B$ r+ @( c: T$ D1 dcount=1
" |; o6 f; z, a+ gwhile count < 13 :
  c$ e! A# T9 B    if count !=6 :
4 |* K) V* o5 C, f7 p/ `1 e+ X4 R# J" B        if count !=10 :
            print(count)
9 A- e0 E+ f1 H% r& p
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
, H9 f3 ^/ W1 f4 S+ A1 n7 I  C    if i %2 != 0 :
/ I5 J3 m. W* g/ F( g        print(i)
; ~4 p3 q; [) y9 l( r* z
/ G- {% q0 J2 ~count=0
while count<100 :
    if count %2 != 0 :
; W% ~3 x9 \- a8 U3 k4 R        print(count)
9 M& e% e$ A) g) s% a) \$ @  p    count += 1
1 J+ \5 |, t, }" O% n' h) p$ N8 J. ~% D
% T! I) J+ O8 S" K0 \& ke. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
: q5 X' n" p- r2 u    if i %2 == 0:
& E  M2 H0 K% U3 |; j        print(i)
# I5 ]5 G6 R* \0 g  x0 l# F
2 l1 X3 G* M: j" Qcount=0
# N* i. @$ e! o! H* ~2 B7 ~while count<100 :
    if count%2 == 0 :
        print(count)
    count+=1
; _6 `7 I) g( C( X/ U) q
12、分别书写数字 5，10，32，7 的二进制表示

  p4 l- q7 }! yprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

7 E- G4 @9 `( n+ N" w, @3 d4 h16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
0 ?. Y9 ~; G& w! J2 wprint(int.bit_length(n1))  结果  3

3 k0 g' \# I8 O8 u0 y, @& A( L: U
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

) L$ j; F5 j( j  e: Xb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
& [) h  A/ ?/ c# u9 V* ]) b% a; A  Lprint(name.startswith('al'))
  \- F- n# K* ~4 w) ^c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
- H' g( u. A* oe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
) Q; B7 P, w5 w1 ^, eprint(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
7 R  j3 D: @& v7 {4 ^0 |依赖索引
" s% Y; i6 `" u; W' A4 E, Gname = "Alex  "
* N& V; m; Y: m6 K1 `  }for i in range(len(name)) :
    print(name)
% I8 V# g( F, W# Q* vfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
9 ]* g# S0 @7 g* {5 v3 A' k# G  Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
; g" W% }5 x3 m5 D6 l% x4 }, X4 I7 rprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
1 r1 {4 `7 I8 D8 N4 H% Hprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
  S6 H* m+ O& f: vli.pop(1)
6 l+ q; M( T! M5 o% A, @+ f) `print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
. V2 n8 ], ]- }+ w5 D" H( Hprint(li)
9 D& S+ @: ~% U; lf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
8 o! w7 H1 B7 `  z1 bprint(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
. A3 V! q" @- B- c( gdel li[1:]
3 Y3 Y- O" n$ Yprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 _- U1 p8 l7 l9 u3 x* _' ^li = ['alex', 'eric', 'rain']
  r( G! j4 G. x: Ofor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
6 F+ c+ k$ w" e; sli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" K+ B& R& w8 {- D& Aprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
0 ]6 f/ p& l( l; r4 ^print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
2 I4 X. j. w5 n) V6 ?7 i. Ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
1 l1 a" H# Z8 X) \# {$ ?b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
6 B1 J; _/ r: _; xfor i in range(len(tu)) :
: U) V& x  b3 }+ `    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
( M" k, a- v0 d8 s: x& p    print(k,v)
) Z0 n( H" @% `) g4 |10 alex
' u& y7 M' ?4 d4 x' N3 H11 eric
$ G0 ~: }/ n1 X+ }0 G7 s12 rain

$ f3 X2 k& o6 Ffor k in enumerate(tu,10) :
    print(k)
(10, 'alex')
! N* ]* ?4 B$ G$ |0 v4 Z0 @# |(11, 'eric')
(12, 'rain')
/ }! d' Z) i& F* ]+ J7 H
7 I$ Q9 F6 E2 _
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

) t/ Z, o9 p' l  u! a3 |5 _- t9 fd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 n" C) T& |. s/ U6 b- itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
) d  o8 R& z. O8 U! ]  O$ Y7 n
4 v' n5 P8 F) H" k- s- uprint(tu)
) K9 P0 J+ W* D26、字典
( |. n+ z* y8 d) ?% @/ T: S+ wdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
. o7 S, X" ~$ l  U' nfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
6 x0 b; v" b& v- ^& J0 K3 l4 Dprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
. F4 }& h& ^& N- B% b; Yprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
, O; O5 S9 X0 |) f+ O  o- bdic['k3'].append(44)
print(dic)
' V) q( G* P) S! ?  S' N* ?
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
1 y9 N* {7 v" ?& M: v" d& Sprint(dic)
. f: e7 E0 X* c) i; r7 _27、转换
6 {) v. m" ^' _a. 将字符串 s = "alex" 转换成列表  s = "alex"
5 b" W) H- A1 S7 R& r8 X
print(list(s))b. 将字符串 s = "alex" 转换成元祖
( i! F7 r' Q8 `4 Gs = "alex"
print(tuple(s))

5 t+ R7 X& y4 h9 @' sb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
9 u) V% ?0 {' I- Eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
7 O2 J. i& X/ N, H( v- rli=list(tu)
- T* d9 X; u  C0 d' O9 Nprint(li)


$ \+ z1 g4 c) f/ r# x6 w; z9 u5 e) f. kd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

2 j: h/ C' y  O; k/ @6 gdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
& U2 F  G9 T9 C$ j7 W* Va. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
; Y: y+ e! b: Sa=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
. r  d# l- d) M5 ~- E* e8 O& tcount=1
, I4 q5 {* H+ ysum=0
for i in range(100) :
1 a+ [- z5 f6 I& U" I& f- Y3 ?* B    sum=sum+count
    count+=1
# V: R/ }1 G" Y" e+ M+ Sprint(sum)
8 M; B+ p& ?4 h3 Q0 G4 `3 X
. A. n6 M7 Q! Q4 m, w, V! icount=1
/ e3 j$ J/ p! h! z1 Esum=0
while count<=100 :
* B1 s+ K; F- }    sum+=count
    count+=1
print(sum)29、元素分类
( G* L/ P3 v: K' u# D" ]( u* ~有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' W0 ]3 ]  H/ u. _1 F* q6 p: n将小于 66 的值保存至第二个 key 的值中。
: R  m4 X7 J0 O( d8 w( \+ E即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
1 B5 N5 u  ?6 I6 o! M6 m4 n6 ]dic1={
    'max':[],
6 f  S9 }1 q# K* P* [- o2 z3 `# V1 L6 {    'min':[]
/ \; q0 ^! p3 [9 k}
. O+ L, K( d/ q+ @3 _5 n$ ^for i in li :
% g, B  N. h0 [    if i <66 :
" l5 u4 ?, `: h8 \        dic1['min'].append(i)
  l* m+ @8 q# e* K8 L    else:
        dic1['max'].append(i)
print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}