Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

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、写代码7 I. f' w. A: U( q, Z! s
a.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :
% f& T: G7 _3 x4 h/ M name = input('name:').strip()$ U# b+ ?; |- C( r' c9 ]2 R8 S: }
pwd = input('pwd：').strip(): H  K! K- J1 I4 ?

! P4 a' L4 Y% r% q1 u! X if name=='seven' and pwd=='123' :
9 K; V4 i4 p4 ^3 r- ~. u' d" s       print('ok')7 C4 U- e. a3 d: h$ w" Z
else:
6 F* ~3 \% B- H1 ?( u& n       print('error')4 f1 ]$ R: g. S
      count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
name = input('name: ')
pwd = input('pwd: ')
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
      print('ok')
else :
      print('error')
      count+=1
for循环
for count in range(3)  :
' w2 h2 \* W- e6 R' f; C name = input('name: '). O6 g4 P* i& P+ o/ ?
pwd = input('pwd: ')  ^' t: |' j  c6 _1 X2 P, S" z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':& l/ C2 X4 Q9 a* B$ |
      print('ok')
! a2 `  ?5 y) F  H9 B. }8 D* B else :% ?# g: V, Q( {5 R
      print('error')
, n/ i3 `9 |( Y7 V* x+ [; l# |4 O7 F       count+=111、写代码, m: x) B! ^. Y1 W, C
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      num=num+count
print(num)

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

count=1
while count < 13 :
if count !=6 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
' j8 j& Y5 ?- r& R, U. o  K( G if i %2 != 0 :3 T% B5 c1 h) c3 l7 g  s
      print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* \% p8 K; i6 }' L' H# H if i %2 == 0:
  @, o( v7 `) P0 F1 ~0 {       print(i)

count=0
while count<100 :
if count%2 == 0 :
      print(count)
count+=1

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

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

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1)) 结果 3

18、布尔值分别有什么?

False .Ture ,或1 和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p')) apex
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(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 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
print(name)6 X% T3 L2 r, B% N/ z4 m
for i in name:
  c4 f* ^: d$ R1 r print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! O' E' O, H1 F% T# B2 D22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
! |  T3 Z' ]/ F& u0 E6 A% mprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    6 I) B+ G+ O1 o/ y, R7 g3 a
print(li)3 v4 V/ X# s3 W5 p
['alex', 'eric', 'rain', 'seven']2 i& |9 E$ [% h$ p' A  s) D# s
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
) O+ E8 a4 F' I: \3 z) Nprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')$ S8 U; y+ x7 b7 N0 m+ i, @
print(li)
" `, g* ?+ a+ L) _( v" K9 U; Re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
' R' I' M1 z3 J  @5 F9 ~li.pop(1)0 K! t( o: T/ I8 H# _
print(li) ['alex', 'rain']8 W5 o0 J) @+ p, r8 I" o8 d
指名道姓的删除li = ['alex', 'eric', 'rain']6 R# Z. ?. m% }! s( v4 F0 u4 W
li.remove('alex')
+ b* i, U# c2 L6 z% _print(li)
8 h" c* T: O/ [, u# J0 V7 j9 k' af. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
3 ]* M! q% b9 H1 B6 i; x  tprint(li.pop(1))
5 X  b/ P0 X1 I4 Z6 e. U) f0 Iprint(li)
7 {# T$ {' D, P5 {4 v1 f5 \5 f
1 X* ?4 J' J+ G/ \7 `) a4 j  xeric0 ~- M! i' I; m) |" k
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
  x8 }1 v2 [3 I) udel li[1:]: V$ G0 e& ?  [% o3 V: M6 [
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 l( r/ i( ?; b$ R6 c
li = ['alex', 'eric', 'rain']
3 }9 m, w0 ~' L3 B$ U* q* j( ~for k,v in enumerate(li,1):/ i" A) g4 o. M% Z$ O3 {6 N2 Q
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]+ Y# p8 K' d4 V$ {
a. 请输出 “Kelly”/ P8 h' O+ i9 \; k- |
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 ?& C; a3 B: r3 B  _
print(li[2][1][1])
& ?( d8 _0 J; G5 z7 e7 cb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
( ^, A' _" R/ y) q, F1 jli[2][2]='ALL'
. D- z8 J4 ^- ?) Q$ S- i8 {print(li)$ S8 c9 l$ `8 ?+ J& b! s
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')7 _# h# A3 i! t& k9 M" W8 \' J
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" ]7 S# Z0 T2 Z3 Jprint(len(tu))
8 w1 _0 I, p' z' j' q8 ^+ w5 ab. 获取元组的第 2 个元素，并输出
5 Y$ m" Z3 R9 V) A$ Bprint(tu[1])0 O0 j- L- R- s/ ^+ l
e. 请使用 for、len、range 输出元组的索引3 v* {# R& h* |4 w
for i in range(len(tu)) :% u! j* v9 _2 _8 O$ l  D
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
& U" I0 u% V2 s/ @for k,v in enumerate(tu,10) :) x3 M* N& J. F8 B
print(k,v)$ _) S) H# i- b, r" T- ?" B' M, Q
10 alex
/ I, A, `6 M$ E  \' u$ H, J11 eric
/ O, j6 l' c7 L" E! X4 s' X12 rain
* H" c" z* v7 Q+ }% M9 O% I7 Q0 i0 g1 D/ |+ m  Z4 b
for k in enumerate(tu,10) :0 }) t) S) E4 K& J# i
print(k)/ ]: n1 S0 E7 o0 r4 h9 f
(10, 'alex')
" O0 f3 W: ^; x0 f, Q' f% M; Y, D(11, 'eric')
: l2 ^2 t( Q4 H0 ](12, 'rain')
- @( F& ~& E. J- K7 ~4 v
* [$ i( {! P; C3 l
6 V1 p: m  L5 a$ a4 q( K25、有如下变量，请实现要求的功能
% |* {( B; B+ D' x+ Y. a! Utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
# a( t/ w. w& O% |
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以- z6 |7 p+ r; N% q* h6 X
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 B# @& {# X" [7 |" k+ [* Jres=tu[1][2]['k2'].append('seven')
' ^, f% z- c. w1 H  x% B' e
9 q' I/ Z+ ]( ], k( E) Gprint(tu)
% L1 Z9 A5 F# e, k- @. _/ X1 N26、字典
1 j. v& R  |; L" j3 u. Z4 Y6 S) pdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:+ m/ Q- b. S' @# g8 D! C8 g
print(i)b. 请循环输出所有的 value& W6 f- O, t: u; t, u$ W
for i in dic:8 A1 F& c! `3 }
print(dic)
2 {" n1 X8 W' ^9 Uc. 请循环输出所有的 key 和 valuefor i in dic:: ?. c; l: u' w  K, z+ U
print(i,dic)" N- S  m+ y/ _; u
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
0 w  q1 E/ B6 v: z3 M" Ydic['k4']='v4'* @) j' G+ j5 M) Z+ T! k
print(dic)
, o0 q5 y: N& Q' c( w7 G5 z3 N, Ie. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
! Z- r7 B8 o: x+ _. T5 [3 Q0 c2 ddic['k1']='alex'
% y( f7 C" }  b: F, E# ?print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典' [; `, {0 {7 O$ h
dic['k3'].append(44)
. ~: g3 b5 a$ U7 Q) fprint(dic)5 P: v- F, ]! m
+ A6 j& p) v% E' Z. a7 e- M/ N
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典9 P' l- {4 [9 W/ k# t
dic['k3'].insert(0,44)
/ b4 D5 X* o1 Cprint(dic)) \1 }8 o% }3 W* f- z4 _/ v: w
27、转换
2 _* t8 C5 A1 g1 Z8 F$ q; ^a. 将字符串 s = "alex" 转换成列表  s = "alex"
8 r: ]" A9 n1 C% j& B+ I0 `  X& q/ k# `3 p8 T
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  z4 r6 U- @7 q0 M( W$ l0 ]s = "alex"
7 G, N) B6 {4 @" ?print(tuple(s))
6 Y; j& B8 ~; D; q3 B* Y' v9 f6 p+ _6 t+ q
b. 将列表 li = ["alex", "seven"] 转换成元组3 |9 `, \# z) Z9 S; O; J/ y. Y8 h
li = ["alex", "seven"]9 _* E& W5 `" {' ~: G) A
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表5 y! L6 r7 D# q# I
tu = ('Alex', "seven")
, ]- W" N- }/ I$ J5 |  y- Oli=list(tu)
3 j$ x' h# f. p: i  S9 b2 bprint(li)
1 z9 u5 `, y" f, @# U, A% R8 M; e3 Q+ G# K
. C. ~' r; Y2 ?  P; ?, ^2 s3 Z7 \
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增0 E; o/ e  _: G" Y
0 ^' t9 O; q7 A6 Y' }# Z+ A/ L, L
dic={}
+ _( U1 d' H. Vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面4 s* Q, p. j( G4 k1 d1 V. W7 u
dic[k]=v
. L( T9 g3 |: m- E" _ print(dic)27、转码n = "老男孩"
# Y, S; }9 O+ ^a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"4 D" V3 b- l. J0 B9 ]& G
a=n.encode('utf-8') - P' R/ ~4 J- F' x
print(a)
6 k( }# D% J/ Q% ?8 P7 y( Ib=a.decode('utf-8')2 n. z8 K  X+ v6 S7 L
print(b)/ r# L/ h3 @9 Q# ~/ {1 A
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')+ O1 @' W! i! Y" C- n1 U  G
print(a)& u" p: M! p% k. `9 k. Z' C
b=a.decode('gbk')6 w9 q3 E& e$ v! N* r2 t4 k
print(b)28、求 1-100 内的所有数的和
! g' a1 j/ U" [6 u' Wcount=1
+ S1 S+ e- Y3 Q; p" B3 T, m$ v$ Tsum=0
& {5 j. R5 p' j8 S/ T# ^for i in range(100) :& T; s; v9 ~, w5 h
sum=sum+count
9 x# E- D& a5 ?4 f7 M% s& Y: m0 x" }5 u count+=1
; i' Z, m9 [; F! p$ `- {6 E9 }print(sum)3 g& A6 n% x3 n- L2 f0 c. z7 l( q
  Y; s, O" j" y; ^. Z; [7 O1 @; O
count=1) R9 t5 Q  @4 T9 n  G) s' y7 l
sum=0
0 s' Z& R0 {% V9 J2 c- {while count<=100 :7 r& e/ O% y+ u. v
sum+=count' i, B8 z  K% P7 k2 m
count+=1; J; C! j0 n# q
print(sum)29、元素分类
4 Y: J8 m! K) b有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
0 y: L& ?" k7 `) }/ e! d将小于 66 的值保存至第二个 key 的值中。1 G  A# E; Z6 U4 F4 ?8 s2 H, ~8 o
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
' M) ~+ H4 V2 W5 y5 Mli=[11,22,33,44,55,66,77,88,99,90]& @5 V) K6 A4 I, A1 \9 O
dic1={$ v7 a0 @+ q+ i, v2 f7 R3 m
'max':[],
) A$ H8 J0 [: f# E5 A0 P 'min':[]' P# R6 c" m: p. x$ G; o) A7 l4 W
}
! x! o* E" A! T4 @9 }for i in li :
0 [1 z( _) T; d( d1 }8 W9 o  v if i <66 :
: \/ _, ?! ?* o' @* e       dic1['min'].append(i)
+ ?! @5 U. Z4 c% \# @ else:0 i7 W5 H, M& m
      dic1['max'].append(i)0 q) ~1 ^* x. d1 u4 F# h
print(dic1)* k, `' |* X8 n$ j2 E
7 V% w* p, G9 C( L4 R- [% ?
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) U" w% |( H% z1 a

Python基础知识汇总

主题推荐