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、写代码! F# K  p! a/ D, W. {$ q4 O0 H
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) :
4 ]0 P- p6 k3 D& U7 j1 ^ name = input('name:').strip()  a8 D- j8 d% z
pwd = input('pwd：').strip()
/ W  ~: q% P. o0 W
5 S) {. n; N# y$ r4 M0 q8 r4 @ if name=='seven' and pwd=='123' :) R) [% K" f4 @+ p! k4 t: V
      print('ok')
' c1 }' @9 |$ {, j- | else:/ J# `# Z1 k" W: F) ]( T; z
      print('error')$ Y( ]0 S- _) y7 C% ^
      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)  :& u* c) D+ E9 q6 K; f% }
name = input('name: ')
5 V6 T  Y# F8 I; s$ i6 ` pwd = input('pwd: ')
( i- I7 i: b! U5 r5 a) u6 Y% t' v if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':$ i* r/ _+ n7 o! Q2 F  j3 I$ G. z7 k
      print('ok')6 Q6 M! r" g5 A% c
else :
4 ~+ E- g: @3 l0 ^       print('error')
% @0 i  x( W7 m) C# e       count+=111、写代码, X5 V+ l3 t* p$ z# R- ~1 `
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) :
" e' R# O3 ]( d% v6 r if i %2 != 0 :
* A8 m4 U3 m6 c7 J% w       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
8 {; y2 g% I7 P- F6 l if i %2 == 0:0 x$ S5 K: Y$ h( l: `0 r
      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"/ ]8 c8 Z5 i1 F* h) u" \/ T
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)
2 \. t6 D* }4 j- h+ ~for i in name:
8 Q  o2 x' G' ~7 P print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
( H; f( B9 W3 l' U7 G; q22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
1 V- i( r- k; X$ n5 S, e1 Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    2 r) `% S: o, u. g8 G6 V; c/ M
print(li)
  f0 f% x- G/ B3 W# b8 D& x* J7 V ['alex', 'eric', 'rain', 'seven']& T7 F# O3 W0 v
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')2 R# K% ^: Y% P! Y9 a
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ F5 x/ I% q8 {% T' t, Q/ M6 iprint(li)% k9 w5 Y* e, [4 S* w( ~
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
0 G$ E* |3 F+ z+ M9 m1 C& u" Cli.pop(1)
* \6 U# w: J; F) }* Fprint(li) ['alex', 'rain']
& k( u/ ]( O+ U9 _指名道姓的删除li = ['alex', 'eric', 'rain']" y" m9 Z' J8 g$ \  w
li.remove('alex')
, r/ l5 ~1 Y: J& S* ]print(li)5 z* H# M: J; w, P3 M( k' J! Y) S
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! @' z* ~! t" W7 s# k+ Uprint(li.pop(1))
/ ~* `. z% W! `5 Zprint(li): A9 `, |: X+ j8 e4 H) i

# S6 i4 Q8 M+ ^+ w+ \eric
9 t5 |+ b$ w- f5 [6 t) H['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']  {5 Z2 Y" x$ p7 c
del li[1:]
. G) z1 T( c/ B9 t: ]( Yprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)! W7 f, v! G8 ]) \& e( f: o) y
li = ['alex', 'eric', 'rain']
: L$ ]% R* G  m- m+ F1 r( I1 c; D/ Kfor k,v in enumerate(li,1):' E7 s) ~" Z/ H3 e* c- M) B" \7 q
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]# I& f- r% [4 u# C4 V
a. 请输出 “Kelly”  T2 T. b  N$ v/ V1 p0 `3 Y# @
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& Z+ A( @3 n4 }
print(li[2][1][1])  V/ S& o, x$ t$ |/ X' _
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
1 K3 \1 z+ a. Z6 {6 R" M3 xli[2][2]='ALL'
; s! }7 j  D. ~/ {7 Hprint(li)- I: W' @7 n% m, ?7 h! \
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 I! a( E' v! Fa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')# L; ?3 A0 o' b1 x) n  D
print(len(tu))
3 R7 v* R: p1 E6 Z  W" Ub. 获取元组的第 2 个元素，并输出7 ]7 y' m3 \/ S) `3 H" v
print(tu[1])
! T+ L) {3 t/ h; t+ ce. 请使用 for、len、range 输出元组的索引: |' V/ \7 V+ g: e3 I/ E& q
for i in range(len(tu)) :
8 A! |* Y% W, W) B& X print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :) q" H8 I5 d+ N) Q# v$ I9 b$ z+ \7 ]7 ]
print(k,v)
; A9 y3 v# W7 W* N( m10 alex
$ G! N2 }" C% C) P11 eric
6 R5 Q' t& v$ }3 p. o5 q12 rain6 m* N$ c: D2 x& `

! _& s$ v9 d8 z& e% H7 |  rfor k in enumerate(tu,10) :
2 s0 v" }0 q7 i  S( M) O print(k)2 y+ r: ~3 F* ~% G9 c
(10, 'alex')
" U, n! K0 X/ d$ \  j( D; G' ?(11, 'eric')
$ U9 U8 i5 d, }, T, Q(12, 'rain')
' D+ a4 S& I- @' }+ _
2 y4 F- w' x+ K, l, A% j- Y6 G
) X' @! Q& g7 C% K  `6 \* H2 v25、有如下变量，请实现要求的功能
. H* }  D2 A: s' e1 Ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
4 ?$ h) h: a4 @% C; k  O
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以# u+ E. h  c/ g: F
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 I  ?" Q1 r9 q4 Zres=tu[1][2]['k2'].append('seven')
4 e$ C5 ^/ {1 G" ^3 K+ @, c: I
# ~1 o3 `: K% wprint(tu)8 Z! g2 m) p& O) r
26、字典
3 G* {* E( k1 Z# Tdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
: I2 x3 p) n8 F5 G print(i)b. 请循环输出所有的 value
& ~3 O& b5 I8 D( nfor i in dic:
! }" U+ r6 w# P4 N5 ]& L/ _6 w print(dic)3 K" C  C4 }3 A* C
c. 请循环输出所有的 key 和 valuefor i in dic:7 [+ d( g2 j6 }& [9 P$ m
print(i,dic)
, ~8 R" H- U2 jd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
% M: f0 q( m: H/ H1 y+ v4 kdic['k4']='v4'7 H5 Z+ k+ e" H: G1 Q4 I
print(dic)7 e& J/ x- ^! G3 T4 l* ~, e
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典/ X/ G  b! |2 J
dic['k1']='alex'
& B1 _; o- b5 i4 x* \5 \% l) _print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典! r4 m3 y* ]$ f1 R6 y! d: n
dic['k3'].append(44)  W, C9 Y  Y0 Q% @/ m
print(dic)4 h& N' `) u! u, m" G" r! _+ R9 }
* L! I/ U/ S2 Y
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典. y" K) ~4 ~! h* W" e: d4 l6 W
dic['k3'].insert(0,44)1 T# S  g# b- {2 `
print(dic)
) q! J; f* Z5 E" M& H' N& L5 ?27、转换3 o" |/ s8 M0 w* C/ @$ o3 P
a. 将字符串 s = "alex" 转换成列表  s = "alex"
: _9 a8 `8 W, Q- }4 g
1 d9 h0 Y9 f: r& ]0 tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
, _' O6 r# T! _  a& E" Ns = "alex"
- T. G: J( U8 C$ z0 d# \) ?print(tuple(s))
4 n7 Z5 H% o8 x; p4 e. m5 M/ u
. w8 l; e8 j% Z* c; ub. 将列表 li = ["alex", "seven"] 转换成元组' i, N- V; r, w! [2 M: s4 J6 T/ d
li = ["alex", "seven"]' Y' M, i5 l! z1 }% Q! V
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表1 m  w9 H( e, w# `6 Q1 G% B" ^
tu = ('Alex', "seven")" E. D9 r7 A/ ^; D+ `( [+ n! \; v
li=list(tu)- E8 I, H4 `; X) O, h! X$ u
print(li)
5 j/ [( U( D* |$ ^$ `; i6 A; }3 ?( X1 ~" i1 R1 r& Z

/ U# y' v. Y& q& b& M# v% pd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
4 w, h* [% k  p1 [3 W
1 Q7 U1 h7 Q" I. v, h; q# \+ I4 Adic={}  e% |' W4 H0 E, J* a- M
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
  v! [% @8 y0 Q& o5 h% g dic[k]=v+ A! Z9 }' N" H/ C% N
print(dic)27、转码n = "老男孩"% F/ D/ {9 P$ e: ]' I* ^" N% m
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"$ D2 u( c* z6 f
a=n.encode('utf-8')
2 r9 N" w7 s# |1 j5 n: A& Q, bprint(a)+ _7 [- g, ]" Q3 p2 K; k& z" u* w
b=a.decode('utf-8')
0 ~. T6 _$ [1 t2 b. c  Cprint(b): o8 `* m$ c7 ~: g8 S) _6 n
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
9 o" _, L$ R& }: z4 ?print(a)
5 u  x2 o  A$ }5 s. V0 xb=a.decode('gbk')
) e! M- c) m' v& W; i' Zprint(b)28、求 1-100 内的所有数的和  n- y, W& j' U2 p: R& k! ^
count=1
! N3 A6 j- o. E8 C. O6 v3 e: W# {sum=0/ a7 m7 Q% s7 E$ ?1 d& ^
for i in range(100) :8 D$ C% U$ ?- @  v. I/ e
sum=sum+count
; M1 L+ W& p+ f$ s  U count+=1
# [, Z% I" U( M5 e# c: pprint(sum)8 j; G3 D" u# G6 m4 `

, G1 c" [5 w7 b$ n2 Fcount=1
1 g4 L; P. B, s; X! osum=0
5 v6 d9 v8 x1 iwhile count<=100 :
1 g+ B/ H# f' o2 x1 U sum+=count7 r7 j- H0 s: U, k5 T6 ~7 _
count+=1
; ^& e  o+ |5 {/ F5 rprint(sum)29、元素分类
3 \* S7 D+ y2 x有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，3 }) h$ i/ V' ~4 ?3 ~8 R0 Q
将小于 66 的值保存至第二个 key 的值中。8 R' w4 L$ h5 T7 k
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
7 h' i( p+ b, J0 V, Ali=[11,22,33,44,55,66,77,88,99,90]
" k* G0 n4 l0 Q. J; r# n1 l: Bdic1={* k1 f6 y9 c% ?" y" Y
'max':[],( `5 n- s  V2 C. L
'min':[]; K) M2 a) R  y  {' m0 c
}
& q5 C- G( S( F0 E/ p$ I  Dfor i in li :
1 i/ {, W9 B% { if i <66 :
      dic1['min'].append(i)
. ]* D  R) v8 E else:& X! }( W3 @8 d: V
      dic1['max'].append(i)
6 i6 @; \8 w- o* W& f4 d; D. Pprint(dic1)
7 @( Y1 L$ p; S% r
2 m) h1 e0 A# l! p& Q---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
% `; C9 f1 x" T

Python基础知识汇总

主题推荐