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; e; Q- }! l8 [  Y
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) :, y7 O4 w) r& \4 H( }9 Q: d
name = input('name:').strip()
4 }, N- O+ J1 w3 M2 }, x4 _! ]7 M pwd = input('pwd：').strip()
! S( b7 n: U7 \# Y  _) u6 W5 a" ^: {: ^+ q% M
if name=='seven' and pwd=='123' :* c3 z6 t6 ^. D" w% ]$ L& _
      print('ok')
0 G0 {9 {! \9 } else:) T7 I3 y4 v) s2 K* D) _* o
      print('error')
& r$ f% C- Q  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)  :
; S5 ]! b: W6 p name = input('name: ')5 ?3 j) B( D6 b
pwd = input('pwd: ')9 `- e2 ^1 e$ t0 Q) L
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  D3 f0 k; H0 F# S7 F       print('ok')
, h+ \3 v& [) e9 f/ a( U& C else :
! x  r5 [4 q; W  L: {% }1 _% t" O       print('error')- F; E  ]& d" t6 ]: A
      count+=111、写代码
3 N! d% B/ `' z6 Aa. 使用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) :
0 ?1 B7 |4 o2 f3 {+ r, k if i %2 != 0 :
1 b8 r- B0 t2 x2 d8 d. _( 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) :
. M( e: b7 j9 k0 `, n; Z5 ~' S if i %2 == 0:
1 n4 O3 @6 \+ k% Q  s3 j       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"
7 Y3 P- {3 Y# @! u: R& v8 m& ka. 移除 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)
! b; c8 ^' u1 j1 `4 ffor i in name:
3 `+ n; Z- V( I( o7 s/ U print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
+ b+ U( K9 L( v! v; ~22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
0 y; d0 ~6 w4 o( N6 Aprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    + j( \3 [, |- a4 N1 c: v* P
print(li)! H5 R4 ]4 V& Z/ h5 P4 R
['alex', 'eric', 'rain', 'seven']% q; J4 N% l, F* W0 S
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. b3 y# A' Z6 z& kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
5 J* n9 m3 T- K% Mprint(li)
% Q: @& k+ d3 q( |' m1 I8 V, ee. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" X6 I# {# |1 J( I0 a5 [' kli.pop(1)
( `, E4 F, Y5 M2 }" cprint(li) ['alex', 'rain']: s" M9 B6 J; T, @6 N* m# z! c
指名道姓的删除li = ['alex', 'eric', 'rain']
/ H  x& E! F& e4 V3 Qli.remove('alex')) J9 L0 R$ |' p- j, x
print(li)+ J% r- m1 @$ L
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']/ p( [* w6 `( G; a' D+ `. Q$ X8 m
print(li.pop(1))9 o8 F( E# B( p/ P
print(li)6 W; k9 m: J7 c2 `9 P
* i1 W3 w: E" s& X# l( W! w8 f
eric# A( o. T: O7 r
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']9 m( I# n( e, c; {8 j3 |
del li[1:]/ i/ n: f( W# g5 a; L( D3 J  x
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)  O( [$ ]$ V3 K2 `# O2 c6 r
li = ['alex', 'eric', 'rain']
" h; ?) W2 S. T  o3 T/ i; Gfor k,v in enumerate(li,1):: q! v7 y3 [# i6 `
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* N6 r; e( M* }+ h8 f7 \a. 请输出 “Kelly”* l9 m7 g$ `# h4 t
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]0 F$ [3 y/ q. ~7 Z5 @2 P1 e- ]
print(li[2][1][1])
. Y1 U9 x. b1 {6 r3 Y( q6 b! l+ Kb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
3 U% h% o9 p$ ?# r& yli[2][2]='ALL'
1 N( g) i" Q+ N- @: ^print(li)8 P5 W# N, Q% l
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')* V) t2 q! @5 z! I0 m, v/ r+ f
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
$ t8 ~8 r+ j6 Cprint(len(tu)); M* r8 t9 ~  T! D% r7 _
b. 获取元组的第 2 个元素，并输出- x6 K, h7 |8 y/ g% `5 o
print(tu[1])+ s! v* [# A. t/ Y
e. 请使用 for、len、range 输出元组的索引+ E6 t# J3 h) s
for i in range(len(tu)) :& B& e4 b& J: q
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)% I% }6 S7 [2 [1 U# P
for k,v in enumerate(tu,10) :
1 i. {; s$ I5 Z% \# S8 R3 B print(k,v)
6 _* B0 O, B+ Y% y9 ?( v10 alex
: M5 o( g% M" Q- O6 q0 A3 `11 eric4 d6 {2 x$ }! e; W6 N, v/ L$ \
12 rain! I: O. k, [# s

5 V  O) F7 R+ z% afor k in enumerate(tu,10) :
1 q# ~) T- P) M3 j2 c$ x3 N print(k)
9 [6 c% v; ^- P; P(10, 'alex')
/ ~, A; _  k2 v# H3 R2 f(11, 'eric')+ E- j1 I- m/ j) ]8 F3 u
(12, 'rain')
3 }# |* k( s$ t; d" r9 B* y
/ k- ]" G8 K  x7 \/ \
6 L3 M; T6 W% ]1 x25、有如下变量，请实现要求的功能
2 b9 g; x( M* D, h8 i6 |  Gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
/ D9 R8 \4 s  A" y: j" b2 u$ H3 S/ J
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以3 ]+ M' c& L  X9 v
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
9 _9 C  p2 U+ e1 V' Y8 Hres=tu[1][2]['k2'].append('seven')
3 V4 ]1 y$ a- p! \
$ \- k  K  z  ]print(tu)0 J2 K) E- x5 o+ y" k3 j
26、字典  u6 A3 a  y! z  l5 _
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* A/ K* \1 H2 A( t2 g6 @* R print(i)b. 请循环输出所有的 value2 q* g- c7 J3 |6 u- B
for i in dic:
" e( Q" y" D& A: A7 m' {- U print(dic)' R  V" U. |# b; q
c. 请循环输出所有的 key 和 valuefor i in dic:
, @0 D& W7 z: Q* @- Zprint(i,dic)
; ^( ?4 T+ C3 H; E) Ed. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' k3 L# ~4 Y  t5 X1 n! ~4 ldic['k4']='v4'  ~5 ~3 P$ r& G, g. I! w8 @
print(dic)
9 K& h1 U' j$ g: s. a2 H8 U% A- Ue. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典1 o4 \, q. w  w+ `: @* O. }
dic['k1']='alex'  }' Y$ D. K$ Z/ S' k) ^. a- B
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典) U1 _/ T; T3 d8 j9 y7 c7 }9 h
dic['k3'].append(44)+ N4 r0 O' C3 y1 m7 ?( v1 z; x4 u
print(dic)
" w4 S; ]0 |3 C; u
+ N  d6 x" X! W9 E2 {g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& Z6 Z% d0 q- n6 w% r& b/ {dic['k3'].insert(0,44)$ ^8 C  u+ G- @5 G3 W- D1 I7 ^
print(dic)
% C- g  u* w1 `# J4 s27、转换/ y3 A! D0 j% K
a. 将字符串 s = "alex" 转换成列表  s = "alex"
- V2 G, {+ A' {* U4 @
3 i: @/ o/ C# M+ Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖3 n' n: w6 R' b: o" o; \9 t3 O
s = "alex"
8 c9 q) d3 c' F" u! jprint(tuple(s))8 U! d/ ]6 v( C3 ~" |
8 |% _* K: z1 q
b. 将列表 li = ["alex", "seven"] 转换成元组
! B8 A' a3 _8 |7 P" k0 c/ |& m" ?9 tli = ["alex", "seven"]
2 M% q7 c& S4 ]( mprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表7 f( w& C' N! M
tu = ('Alex', "seven")
; t/ `; f* b2 F1 r8 w9 Oli=list(tu)/ W6 n: z* p, L& ?3 @1 m7 ^$ H
print(li)
0 f0 r8 {4 f3 Z
/ J4 N* f7 T# Q. z# A
; q2 |, l- j  f- J' Xd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& S5 F/ l9 R- u: D9 a
3 h# @: n4 Y3 rdic={}6 S. d6 v" _% ^
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面% b% V0 d$ k* P
dic[k]=v5 o0 M' D2 r- j5 a8 z+ G
print(dic)27、转码n = "老男孩"% n4 N6 K" m2 r" M' ]' [. a; S
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"1 `$ ^# [0 G4 D' ^$ ~! i9 P
a=n.encode('utf-8') : K, f5 I0 B- Q" g; U' {# \
print(a)' E5 [. P. z) t: n  c* \+ O1 E
b=a.decode('utf-8')
2 m( {' q- D* M$ K9 Q# B: zprint(b)% o. [& h% D) s) U$ z7 w, Y$ k
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
" ?" \$ r* }$ j5 E! N0 m1 e* @3 Tprint(a)& Q& L/ w9 Q$ N& ?6 W. [
b=a.decode('gbk')
* Y7 L# }3 v5 h5 I# b/ Tprint(b)28、求 1-100 内的所有数的和5 `7 [3 v& j: w4 f& Y0 U' L
count=1  w* s6 c  e9 K8 w0 z2 U
sum=02 `& r) z: A4 F8 J$ Q1 }! W
for i in range(100) :
. I1 z- t* }: k0 w) T. S5 g sum=sum+count
- e0 e; r* p2 `4 \0 i count+=1
% d/ I1 K: H" eprint(sum)
1 Y, M, P1 e* \' Y7 t" M1 \" o; L+ M! _8 ]( R
count=1
6 j& F0 {# z9 a7 `0 _! {sum=0% q+ d3 B/ s& L4 L; Q$ q
while count<=100 :
& L7 ~3 l, @& b6 T- |9 a' g) { sum+=count( q0 K0 @, B* O; v
count+=16 E7 f; ]2 o' i% S- G
print(sum)29、元素分类
, q- E) e, h3 I# T有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
$ m- X+ E7 r* s; @将小于 66 的值保存至第二个 key 的值中。
! p" f/ x5 q$ R. V3 R即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
/ b- ?0 I5 X! t% H+ Jli=[11,22,33,44,55,66,77,88,99,90]; S6 ~7 ]- W5 O. r
dic1={3 J( {6 [0 V/ T# Q) W- \
'max':[],. H! P9 U+ ~! S! p5 }
'min':[]- Q) O" T: k3 ^# Q/ ^9 S
}
/ U, B( P3 i. u' p3 Xfor i in li :
) g3 g4 X! T& D1 K! `9 y( L if i <66 :
- X/ ]/ p/ [. `5 K+ Y% c; C       dic1['min'].append(i)
2 F1 N. Z! g; I& L" M2 h7 D0 G else:: ~% S8 I( |! ~" a' W" W6 G  i$ C, O
      dic1['max'].append(i)
/ M1 M' w% k1 M9 A: _  {$ zprint(dic1)- e# h0 z$ g* @4 u' k* ~; }

0 a/ p4 Y* F# y6 C/ \3 l; |" p: t---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}% t. Y) k# {1 m/ T$ h9 m+ I

Python基础知识汇总

主题推荐