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、写代码# S1 L/ s8 m* {3 L, [
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) :' E: y, I/ j; Z- ?. u. v! ]) v
name = input('name:').strip()1 {. m% y7 [  i( Q3 B+ E# q% M5 w
pwd = input('pwd：').strip()- f. i( U6 ]" ~" S& n

! N( z" b% X% _* Z8 t2 f if name=='seven' and pwd=='123' :$ ?  s8 y$ [  s1 u: j
      print('ok')
. g7 n) G% m- o3 B+ l else:
/ _- Q# L" ]( L; w( s       print('error')
' B8 T* A6 G% y' D" ]9 ~4 j( u       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)  :
0 L) \0 T. F2 Y4 n- E# z name = input('name: ')
+ Q* B  h& z4 w1 O, C+ ~4 t pwd = input('pwd: ')
" j/ B0 Q% c, \' a if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':4 `, J, S) ~% ]. I: v
      print('ok')
! U4 G5 y! e- M7 t$ a else :
: P3 p5 s! A- D6 c% w. W1 {       print('error')' }" N. x2 z. X& V
      count+=111、写代码
; K# G+ L  C/ K8 |( c) W% fa. 使用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) :
, y5 C- a, V/ W) a1 A if i %2 != 0 :
/ c/ P4 v# l- B! t; L& m1 g       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :' x+ b- G, D0 b& k, h" y; R: a
if i %2 == 0:6 p( m+ H! E8 z0 E. d
      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"9 T3 P7 }, w& F! U. o, g1 K3 s' ]+ d0 n
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)
: a/ `' y/ p) T( g) {! kfor i in name:
& A( y) F; P$ [5 G. F! I/ G4 l print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! g) P- z& F# e$ o% Q8 N8 W7 w: ^22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
& z* i0 R- m2 I! q/ Z- O" C; L  tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
$ _; N; F" V& @. u5 xprint(li)
" r1 H; f4 A' T" E  a ['alex', 'eric', 'rain', 'seven']+ i8 d- h5 K' |* m8 S$ V' X
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
4 R! ]$ g3 W7 g6 w3 I5 Hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')7 N& A4 q- }( f  m' Q
print(li)
, q# y0 ^4 C  s( @e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
8 B  H9 Y4 o4 {li.pop(1)
/ H% k3 l, S7 ~1 D, iprint(li) ['alex', 'rain']
. g3 q" W- N: N指名道姓的删除li = ['alex', 'eric', 'rain']
/ B- i6 f! A! ?' _5 I7 Xli.remove('alex')3 j" h8 A4 E$ x7 ], j
print(li)0 U3 f1 ^" h4 i* ]
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
) c6 u* Q/ ?3 ?) |% Sprint(li.pop(1))% |. G" W7 A5 Y5 E( y% U* J
print(li)
9 c8 n  C2 ~; W6 Y% |9 w4 Z& u: S# f" N/ E$ t/ O$ g4 A
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']( U# f4 I3 s$ p* g) e7 ]. [1 T, P3 U
del li[1:]
# s% _' n8 v' r' G$ D2 tprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
7 l& e2 y/ y  G( r1 S1 \li = ['alex', 'eric', 'rain']
  T' E+ F2 @) S. F1 tfor k,v in enumerate(li,1):8 a! g+ N+ C1 t, I% ^
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 `# H2 [: Q! d3 x& v% g  v% ca. 请输出 “Kelly”
& U! x4 d3 N7 }: L% T! U8 ~8 tli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: V* q2 |) o# t6 ]. N. F; tprint(li[2][1][1])) l5 ]; h) F5 I, t8 Z$ H, Q$ X
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
4 I3 q! V! X, h& w* vli[2][2]='ALL'
( j8 k0 g. r+ D! G$ z0 pprint(li)
3 Y7 L- a0 X2 |4 v8 K24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')' A: C2 w2 m. ^+ N" }  V
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
1 ~" R! I3 y7 oprint(len(tu))9 S5 [: h, \7 x$ a
b. 获取元组的第 2 个元素，并输出
4 W% a" d1 n$ K. R1 Bprint(tu[1])8 [8 d' z5 ^9 s% u0 P4 A" |
e. 请使用 for、len、range 输出元组的索引
3 q% W. m3 w% U- |! F" L' Xfor i in range(len(tu)) :* C% g2 N8 D5 b+ y4 ^: L
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
3 I2 D$ l" a0 A3 @1 [for k,v in enumerate(tu,10) :
5 r, b+ X# H3 B' ~5 u, x print(k,v)
( ^% [2 [4 `$ X, R10 alex/ [. m1 }9 W# q0 }0 N1 u
11 eric
6 V* P$ i( D: G9 t. ?12 rain
9 n- d) s# q; o4 K2 G& U* \8 R: |) Q1 T: [! V
for k in enumerate(tu,10) :
% t; w% ^3 `$ @% U; L: V print(k)
- f8 T8 L5 N$ m(10, 'alex')( j0 t4 r2 h& h' E2 c5 H
(11, 'eric')
/ H" s: ^: f5 m(12, 'rain')
( r7 C! h- g; G/ ^$ K3 w0 r7 z$ M1 J8 l1 U/ R: N  `6 o, R

5 t. p9 r% i/ V3 w25、有如下变量，请实现要求的功能
# J% T+ V% T$ p) btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

& s# v# w% s& r/ p4 b0 ]d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 [5 `& k/ l/ {: c8 [8 ~  g! Etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
( W0 x; H. k" [  u9 `" h# D: Eres=tu[1][2]['k2'].append('seven'): a/ O- F$ c% k# Z2 Z

' ]. C0 E9 d/ N% p. |print(tu)
- z8 }+ I( M% ~( s% s1 u* {26、字典$ O' r! S7 G; X( U
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:: F1 `7 c/ O! I) s
print(i)b. 请循环输出所有的 value$ E) C$ [3 R1 M
for i in dic:
( y9 M2 h6 |6 Y1 e print(dic)
2 @! k+ d8 L  [. Oc. 请循环输出所有的 key 和 valuefor i in dic:
, H! _3 F, u1 C# @( E& ]4 h4 xprint(i,dic)
# U* W9 q: z. ]- q/ _( ^9 D2 ?d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典- C! t" k; T* s  G" p; k! z( `
dic['k4']='v4'% H) y; O! Y7 @! Y3 }/ D- A( p( r
print(dic)  g: Y* g5 N- {: r% W: S$ O9 b/ ^+ W
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ i& F) y1 P' ]! |4 Ydic['k1']='alex'# M# p9 k; d  {4 u1 z. B
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 u  V3 Y( B* Y8 n) Y# }+ }7 F# Jdic['k3'].append(44)
' v& i; Q% f& X" N5 u! |" Eprint(dic)1 m5 @3 T! E9 e  \# Y" F1 p

& e( v6 F3 ]* ~* B- J- \7 Rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典+ G& n/ f# O# A3 l- B
dic['k3'].insert(0,44)
4 d- l2 V3 y$ d  x' M6 \0 gprint(dic)" w! y7 u1 J5 ~. u: Z3 ^
27、转换1 N; ]- Q9 l1 S6 _9 L! f8 B
a. 将字符串 s = "alex" 转换成列表  s = "alex"4 l3 U7 z3 s7 H, q
0 X* L' e6 p; o* a/ X) s
print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 t  R3 P, b4 S2 Ns = "alex"
" q  F; U  l, Q# L8 {# l0 T( _print(tuple(s)): \6 G& X/ ^! w" c  k

7 t, L. n+ j# Z7 Ib. 将列表 li = ["alex", "seven"] 转换成元组/ s1 Z: \5 z) N3 O' h
li = ["alex", "seven"]) p/ s; W8 Z# Z8 P" \8 m5 [
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表/ p8 Q- e1 W6 \' T% n6 k' @
tu = ('Alex', "seven")
0 n4 f/ r' Y. @* s: k" \li=list(tu)" u8 [+ |* K/ @. v' d2 x
print(li)- ?; G/ T! L1 C2 S" e: t1 w, B1 u
$ Y4 E5 d0 j' |! M/ o
+ ?- {" P2 a- g
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增0 a! _% ?$ g3 n( T1 Q- \& c

- u# l5 ^2 E/ V" y7 {5 w4 C1 ddic={}4 u! q3 T) }5 P+ b* C$ L2 _
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
4 V" k" H' `: I0 j3 W6 M0 ] dic[k]=v# n$ Y/ K& b) F( @9 v
print(dic)27、转码n = "老男孩"
5 D# j3 K- k3 K% e, U) y: C' da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"; P' E& Q+ w4 g2 z) X
a=n.encode('utf-8')
) A; h; p) s' Q& H* vprint(a)
. G( G. v9 z# {2 J) Hb=a.decode('utf-8')
7 A# @2 ^8 F2 o! Mprint(b)
, t6 u9 j, H. t5 U5 }# Bb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
% ?& h! U2 [7 ?8 mprint(a)7 r3 X; ?0 V; I6 o1 K: V3 o, ^
b=a.decode('gbk')
7 w& z3 E. d  Q5 R! \print(b)28、求 1-100 内的所有数的和8 m6 q8 E, M  ?- @0 B( G: r
count=1
  L  ?) i3 O, R& A+ b; \1 lsum=0' i7 b( `: V2 E$ `' w" r2 U( s
for i in range(100) :' D: f- C7 h6 T3 ^, }9 s
sum=sum+count
# y0 q" [+ z+ p! j0 G* [ count+=1% x$ F7 G+ b# L1 v2 Q$ d
print(sum)- b* ?7 e6 K% X! m( z
7 b9 q  F2 [+ ?) S8 Q
count=1
7 t$ B6 q8 n- dsum=0
6 y  _3 r0 B3 x. g/ J7 ~6 p' Kwhile count<=100 :
, r8 J% h0 a" J2 d1 R4 G sum+=count7 x+ `) j' ^0 A$ S9 q) ]2 Z
count+=1
8 _% ?% b2 W" d- G5 m) Z) G- yprint(sum)29、元素分类6 D& m$ a6 r& w- o3 e$ }" X
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，! I' U* S2 |' T, S0 x
将小于 66 的值保存至第二个 key 的值中。" e1 ?+ B) M/ B3 I; O
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}7 F( A/ }5 D2 G6 R, Z) U8 x
li=[11,22,33,44,55,66,77,88,99,90]% s3 o9 d9 z) I" [9 \  s8 r
dic1={' F' K8 Q. K/ y: v/ j
'max':[],
7 o. n# b$ @* a# T1 b$ e% R 'min':[]
' R9 X: l2 S" u% w9 p4 _: {}4 E) e! H, ?' m- J! L
for i in li :+ l' J8 L: J7 _; g& F" Z* H1 U5 j
if i <66 :; v2 i9 r* \$ n! K7 P
      dic1['min'].append(i)+ w; s# s2 P* k7 i
else:# R6 k- ^# w1 {) A% H3 w# N7 ]
      dic1['max'].append(i)
0 t/ \9 y1 b$ d: h. Aprint(dic1)
1 w1 w4 U/ P# P5 }$ H; W) W: `' l; A$ B$ h
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}& x$ G  T. V* W  R6 s* D$ T3 i" B* D

Python基础知识汇总

主题推荐