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、写代码
* _1 l6 w9 k7 d+ m! ?. h& \* l/ Wa.实现用户输入用户名和密码，当用户名为 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) :+ ]$ C9 O% Q9 d+ H
name = input('name:').strip()
7 T. i8 E& W: i; a1 s8 d9 U pwd = input('pwd：').strip()
$ y$ l. p* A/ Y
0 s# E. {9 l. R( y9 H7 ] if name=='seven' and pwd=='123' :( C+ X3 z6 J# X. _5 `: f3 r
      print('ok')# n% }5 Q- o7 k
else:
  m4 x+ }2 s6 J       print('error')- _/ t/ c% g+ G3 o; _0 w
      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)  :
. R/ K. a4 Y& p3 o: h5 { name = input('name: ')
0 T4 S* C4 }! ?# @1 R2 n# F pwd = input('pwd: '), \" C. s8 h+ w4 V7 [
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
* I& ^; J: z# H: Q; d6 d       print('ok')
9 V) p. R4 E0 S/ k& `/ P' y else :7 w  y5 P$ _0 I' X  u6 _
      print('error')
) F0 {  a) U( {# o$ U       count+=111、写代码; B1 t* Z  H/ N% Q+ [
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) :) ^+ P- W! H7 @) A( F8 j: |5 J
if i %2 != 0 :0 }* R+ D" ^( G( {* p6 L9 q$ L
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :: B' P8 M$ l3 ?8 ?" {1 k# L
if i %2 == 0:, ~. B; N/ M4 g) w- E6 q
      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"
6 t' k( B1 Z' X8 [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)5 p* M# m- f! u+ ]
for i in name:
  L7 s% [+ J( q print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
7 d- Y' o/ Y+ ^0 p! b5 m7 }22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
+ l+ q, k- w. K# ^: b$ M# u+ zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    3 u2 S. C" x0 d: @% @
print(li)
/ z6 b4 g4 f, _" {2 N+ b ['alex', 'eric', 'rain', 'seven']
: ]# P. O8 d6 W, [* j! Yc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')9 D7 w3 E4 q7 S# b: G
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
1 S  @- z# {) vprint(li)# `, |' x: B8 o5 x1 f& |1 a
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']* ~& e  I/ l5 `9 G
li.pop(1)1 w" a( o$ Z3 g( G
print(li) ['alex', 'rain']
  a2 Y. n* f$ j2 o) m指名道姓的删除li = ['alex', 'eric', 'rain']' [- q. k& A8 u# X7 Q
li.remove('alex')$ [# u" g/ b% j' j2 r6 D
print(li)) ^5 `# U1 v, h# s: P& J, y2 B7 x; g
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
" c4 J: X, m. a" j8 u7 \2 hprint(li.pop(1))
& k4 `& P- l) d: B& Q2 B1 Y# @print(li)9 A6 d7 z0 C- @$ u+ X
' k1 f* o5 ^6 h% B8 w: B% |$ x
eric. Q( v6 U3 D  k
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']: @$ Q+ U% n) f: S6 `. F
del li[1:]
0 N0 f) a, j& u+ T3 s% lprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
" e2 W& w0 c6 d# Bli = ['alex', 'eric', 'rain']" x0 S1 w3 z; M$ c$ f2 Z
for k,v in enumerate(li,1):
% [$ s" f# |; h print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# w+ |- M  |! r, {a. 请输出 “Kelly”
8 X1 _, S. B: h4 k0 f# m/ n# Xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]6 y4 j! K' d& z( V* x! f) S
print(li[2][1][1])( T! _) }1 V5 A4 Y8 p& e
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”1 Q# o. V: u+ ?2 p3 J
li[2][2]='ALL'
1 R# t5 ~# I, F6 iprint(li)8 Y+ {7 l: s; }2 k
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')- q  D% ^! @' Z
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* R* A1 Y6 o* Q' }  \print(len(tu))
* x( \7 y9 X7 |+ T" h# Zb. 获取元组的第 2 个元素，并输出
3 e! i/ _/ D" z1 X3 _print(tu[1])$ }/ q1 M2 P+ b# o* k7 U
e. 请使用 for、len、range 输出元组的索引3 n0 v! S# [0 D3 T; [
for i in range(len(tu)) :
) P+ J  v' t) H5 Y! Q; K0 K print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)3 t9 Q) p3 t" S' ~& _
for k,v in enumerate(tu,10) :& V+ d' Q- x, J
print(k,v)
  t1 T4 k: d/ v0 r, t, h' S10 alex9 J: @1 ~3 S5 t2 n; {, h2 {
11 eric
: Q- ~& |' e, ~) U) {. \, S12 rain; v, {% b/ A. y' t  R% \/ f& |
: U* G, A" C( {' p5 _+ ^6 I" s/ P' p
for k in enumerate(tu,10) :! `# p& I& @/ y3 Y0 Z
print(k)
* d5 O! s1 i7 J$ J4 X. ^+ E; ?2 O9 R(10, 'alex')
: x' u. j+ N5 w1 I# q(11, 'eric')) C0 _) l5 J2 a# i7 F
(12, 'rain')' T% R$ F' I) i  g5 _
5 y3 ]0 `& d! X4 |* ?4 m

! r' e7 W) f- n# r! |) a5 ~25、有如下变量，请实现要求的功能
5 r4 V, \, J0 V" m0 \" @: Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

2 m& W7 R, y  f5 Td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以0 @8 J3 _4 a0 D' [7 j5 S/ R! Z0 i  ^
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]); T7 \7 Y1 I& @' s( ?; ~( N
res=tu[1][2]['k2'].append('seven')+ e: Y; e% q) w1 Y* E! w, `; j7 |

0 m& z8 T! }, |8 R* F% }" U9 R3 wprint(tu)
+ D  J) X6 o! [: |26、字典
  S  N, e" |- i; Zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:, X! L7 T* ^. ]- ^' R$ j! k( z
print(i)b. 请循环输出所有的 value; R3 r) e' k! s, B9 R7 V
for i in dic:- N+ K1 R, j  I0 P
print(dic)
: A1 y4 K4 ^6 T& r6 Pc. 请循环输出所有的 key 和 valuefor i in dic:
- Z, D8 N0 \8 Q& t* g7 u2 uprint(i,dic)* ?2 e7 Z+ S. B: _
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典2 \" F8 c+ A. m6 j) X8 [: `# ~
dic['k4']='v4'1 ~" I2 d2 K% N$ ?! s( E
print(dic)
2 M. G9 u7 J  l6 Ge. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典: n, z0 Y2 u/ y$ V! l3 Z
dic['k1']='alex'6 ?* V% F1 ?# u" T- r6 P. U
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典7 ?4 M, e: z4 l5 v0 Z5 }
dic['k3'].append(44)) I8 t6 C: Z# H% \! H) I
print(dic)5 w) \* c" R& N5 u# G1 a$ ?

; @& j3 j- ^& G: V. d3 Gg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典" k2 @& F/ |" {
dic['k3'].insert(0,44)% [- \* y' v5 Q8 M( F# G
print(dic)
0 O. f  Z0 n4 g( O( ~4 R4 n27、转换' \" n  J" m0 }5 z. p
a. 将字符串 s = "alex" 转换成列表  s = "alex"0 o2 w* d  n% V
8 c1 L+ i+ R, {0 ^  u7 l
print(list(s))b. 将字符串 s = "alex" 转换成元祖1 u; w( f9 W( l; z
s = "alex"1 L: P' e+ }: [7 X
print(tuple(s))9 L1 a( p( [4 d& b

" N; k0 A4 `- r" b* H$ Ub. 将列表 li = ["alex", "seven"] 转换成元组
3 O7 u" P8 v. C6 bli = ["alex", "seven"]5 O% x: V+ \$ G' j8 O" \
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
5 e4 s2 b/ ~+ F$ q3 G0 n' @5 W6 J$ Jtu = ('Alex', "seven")6 ~+ Y7 K' D# n8 M4 U# Q: a, S1 k
li=list(tu)
" H% W; U" \7 x2 ^( f) nprint(li)
; G# Z1 w( S+ ^' h$ Z3 s) P# [2 Z0 g0 M+ h; w- m

! v/ {4 G" N' Rd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增, H* T. _" v1 u) $ ]; G0 K

8 y3 }  A  Q% z# D% Bdic={}
: x/ N5 M, j4 X* p* U$ vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
5 A, H; w: z! d8 y dic[k]=v
' W8 W2 X- r1 I. ^( s print(dic)27、转码n = "老男孩"
% ~1 O: F; n% U( H$ n. x: ia. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"0 \1 `/ O: B% Y6 m
a=n.encode('utf-8') + x  ^6 N* c0 Z! U5 c
print(a): I( k* O: b+ S, G8 k
b=a.decode('utf-8')1 u3 i6 z6 d+ ~9 I
print(b)/ k' A8 D, r: j9 E
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
; v- q8 n2 q- r' H6 C. _print(a)
* |" ]6 z3 c  I2 k  }" Y' O& Ob=a.decode('gbk')& ^& Z* $ e" B2 Z7 a; d
print(b)28、求 1-100 内的所有数的和2 B/ Y  t2 _$ s, I' {- h
count=1
0 i+ N5 d. }' G, g- P( Fsum=0
1 T& T% p7 b4 B* s: ffor i in range(100) :
, b, ~5 \; R' ~ sum=sum+count& n. }" H9 L1 g! x1 R
count+=1
$ n( K( N, z: `print(sum). U8 L1 ]& G' r/ I0 B0 ^9 x6 g3 m
: \3 F: U1 B) t% G+ W7 H# o) l
count=1/ e) w* W' |! @
sum=0
: s4 A, J, _9 u4 d7 o/ U1 qwhile count<=100 :) d4 l/ Y! g( r; _  J1 n4 I' J4 b
sum+=count+ r% K4 }9 k$ t: E  R8 j5 c
count+=1
1 ~" x! |& Q9 q$ h. N) c( H$ qprint(sum)29、元素分类$ ^. A9 Q3 s* D7 _# t
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
/ X; ^1 `5 V7 B! _& A/ \' f$ u9 x! D将小于 66 的值保存至第二个 key 的值中。0 `6 o4 p! J8 Y3 Z
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
  X3 p( k" R& P7 W: gli=[11,22,33,44,55,66,77,88,99,90]3 i. e2 z8 J8 {' }- X0 C
dic1={
6 r2 E" \- n6 K- s5 C 'max':[],
. o& q0 i' a' T& b, v! w 'min':[]
8 g$ o" W* e2 K2 C* K}
! b& Y; P7 N0 Y$ V5 h4 y( qfor i in li :6 O; H+ r; H3 M/ L% W: v. q9 p$ u' z9 h% G
if i <66 :
( c: P: Q- E$ U. r4 i) u0 p       dic1['min'].append(i)
( I( n6 w- P, o7 C: F1 s! m1 { else:
2 e* j) h: o9 D3 U       dic1['max'].append(i)
) p4 a( @; P" O1 ]$ N  I& ^print(dic1)4 I  r+ x& ]. Q/ u( O. N" X# q+ O

& A: V6 x! x. J  R0 W/ d---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}, Q  N% t7 Y( E2 Y- G

Python基础知识汇总

主题推荐