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、写代码
8 z* g1 M0 a& e) A- 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) :
8 e7 I; H& Y: |1 q# Q) Z name = input('name:').strip()
1 O# g4 R7 S  l! u pwd = input('pwd：').strip(). M8 R" p; w2 w* n  ~) m  ?" L

% _: @& S6 a- P1 d, G' j. _* r) k' c if name=='seven' and pwd=='123' :
) w1 {& ~$ W/ K6 m8 q/ Z       print('ok'): d' V  D6 W0 O7 D; X6 D' {
else:4 @  W$ V0 w  K+ U2 R* `
      print('error')
% f$ j) D) U2 ?. }: A( O       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)  :
/ a9 A' p8 ~- f8 J/ A name = input('name: ')
. I$ v* ?3 Y5 k3 X. { pwd = input('pwd: ')
) e5 ^( p) o( K3 f/ P8 @ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 U8 k3 w- q9 @# }       print('ok')
$ s0 f# Z* x) a5 U( K* @ else :
/ l. s7 _% W( p7 f# H       print('error')' c' H  Q/ q& G9 i( f$ Z
      count+=111、写代码' X+ g- h% L; b) o
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) :
2 N7 F/ s  c5 F1 Z if i %2 != 0 :
2 U8 o. u6 `5 v4 z- u1 u) a. v       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" U  o% ]+ M) W% g! T- j if i %2 == 0:
3 J( }/ p2 u% C0 S1 E9 ]       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"
3 e2 b3 i* {! `1 p6 R+ ma. 移除 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)3 t: l2 y8 N- l  }1 X- g
for i in name:2 M- }) T# O# \3 q* v/ ?  m: _
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
( R3 c4 y/ A, y22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 H% ^9 @9 F) h/ ^+ |- qprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    $ b5 M4 k, O* p- F
print(li)1 R! Y$ y3 P1 A, |& |1 U
['alex', 'eric', 'rain', 'seven']' Y$ q9 y- E+ f, C# p0 l: M
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')+ M( {2 |! z/ s
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')2 p+ ]: U' h, ^- k& p5 d2 z( l
print(li)
% K7 I4 `! R! M, E, O+ w9 T3 D# x+ ]e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 k) B" P0 m0 H( ~% ili.pop(1)/ ^6 W! ~7 g3 H" v' K3 N0 K
print(li) ['alex', 'rain']
. Q  b6 B5 N" F- v+ J指名道姓的删除li = ['alex', 'eric', 'rain']6 v" ]: z& [8 v' M8 S; L
li.remove('alex')" r" ]/ T0 }* V! U% u
print(li)
- q7 A1 l7 ?$ _' of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
: C0 W* u0 a0 I% v! d& `print(li.pop(1))
. b7 Y- Y0 s$ k8 \print(li)
2 P) ]3 L8 ]. P1 B' m( o; {' f  j' ]/ t" M4 T' {
eric; S, p7 Q* m6 m* Z0 h' h, |
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
5 y# x1 ]' ]0 a* Ldel li[1:]
4 _" r- l6 M- z* \print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
( Z" M' n8 P" ]. Ili = ['alex', 'eric', 'rain']
' e" ~+ O( z% i9 @7 N( A. ~for k,v in enumerate(li,1):
" K/ N( R! |) L* c. o2 u+ X7 K print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 y3 _, u$ h1 L4 H  A9 M
a. 请输出 “Kelly”
& L% H! g# t5 \% X# b7 w5 A5 |li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]7 Z+ S9 d: \3 T0 P# Z+ L7 G
print(li[2][1][1])& o/ U# s& p& x0 p2 x+ a
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”) W* E& S( U4 s* L
li[2][2]='ALL'
, ^% j* h3 x- r; tprint(li)
5 Y, v$ [4 F# g24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')1 N. A3 v1 y) {3 H  Z2 J  g
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')7 N7 s. F3 W6 S1 n
print(len(tu))
0 H5 O! |, J- I# z7 Ob. 获取元组的第 2 个元素，并输出8 N- n- K: y6 C( }
print(tu[1])
1 i0 w% R# ^  i/ Ne. 请使用 for、len、range 输出元组的索引
' {/ p6 w, `- ~. q* sfor i in range(len(tu)) :) Z0 n4 p- k0 X) u
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
  B  \3 l8 d& h! F. pfor k,v in enumerate(tu,10) :7 f* F3 k  ]; d' ?2 J
print(k,v)/ `4 m3 y  a6 [
10 alex
8 M# E, F4 `8 z& H1 r11 eric5 X( b3 Z7 P4 [
12 rain
1 q) E+ n+ d/ u8 d
& O6 D3 I3 G+ z) P# h3 \for k in enumerate(tu,10) :
/ a; z% D- x; p/ n0 o" a print(k)
+ [* ~0 f* S0 {/ x(10, 'alex')
( N( a2 M& w3 Q% [(11, 'eric')2 J$ B/ C9 n* T
(12, 'rain')
3 T( M+ o2 J9 i0 a4 q. ?, @; q6 K$ l9 z

8 G8 x7 R2 }1 T8 R25、有如下变量，请实现要求的功能3 b! X0 J6 B# M) D) S/ V, y* `
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- j$ u: R( C7 E9 }- Md. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
- ?7 L& Y4 ], l! \8 @6 J# E" Ftu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
& K( v3 i/ f8 J/ \" y8 w1 P  a- nres=tu[1][2]['k2'].append('seven')' I8 d2 N. P4 |" v" P3 p, j

' |- _% D- ^$ Y3 ?print(tu)
+ o6 q8 m8 o7 N% l$ \' H0 `26、字典8 a' X, d0 E& y/ M  T! M
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* i8 S$ u& V9 J) W% P* C print(i)b. 请循环输出所有的 value
  A9 O) g% i2 H+ K$ `for i in dic:/ A' @/ H! o9 A" N8 `' [
print(dic)
5 l, t; c  _9 F. h4 P: m1 n8 Qc. 请循环输出所有的 key 和 valuefor i in dic:
$ ?% `# v3 o! r. c( gprint(i,dic)0 p- P0 G4 R, K; X8 r  f( c
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典6 j4 W0 I' g- S2 y: h+ i9 c( b
dic['k4']='v4'% y! W3 |$ S, P; E4 P  z5 d
print(dic)
4 g1 ?& `* b3 g- ]1 d9 Qe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 G4 |* Z2 C! t- v3 X; {
dic['k1']='alex'
8 F5 X9 N( [  l  ]+ [( @  {print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典8 f4 g" X5 H. g
dic['k3'].append(44)# l# w& [5 v4 k: F) B% F+ s" `8 w. [
print(dic)

+ ?- x9 a% T- r$ G+ @g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典" `! \0 w9 K4 h  \
dic['k3'].insert(0,44)
; C# n+ s4 ^0 T9 ~6 Yprint(dic)
- O; ]* t6 H- X: t27、转换4 \& P: r! p  x; @
a. 将字符串 s = "alex" 转换成列表  s = "alex"4 U7 q  b: f% J# t
0 Z4 j9 ]- Z' n0 e& r/ a
print(list(s))b. 将字符串 s = "alex" 转换成元祖
/ a; I% A" ^/ v! @5 |! b" ^- ks = "alex"
! {. }/ ]3 ~' Y7 N6 tprint(tuple(s))5 n7 E- @$ X; X2 Z
+ g1 f4 Z7 Y2 i; q; c: J" L
b. 将列表 li = ["alex", "seven"] 转换成元组
: v- V% j. M/ X# C0 e* g- Hli = ["alex", "seven"]  I; m0 \$ @3 c& [) }1 T( P6 Z& Z
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
4 w8 p3 u( k& c% M/ I/ xtu = ('Alex', "seven")
4 O% u+ h6 J' [4 w6 r& q7 Pli=list(tu)
- c2 B2 n$ D# K* Mprint(li), p6 z  L, v7 g4 M" I

# l2 D' w9 {9 ?9 Y' V! A: m/ j
$ Q9 h. g8 C2 Td. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增) Y1 Q8 m2 _8 t+ ~3 T

; V* p# ?1 x) M* l/ E, F/ Mdic={}
  h6 T7 `: z7 u) E! kfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面" I/ V4 X' p+ O! ~8 }" z* a
dic[k]=v/ ?* L& h% W* X. H# g" b* g
print(dic)27、转码n = "老男孩"
# \; q3 P, Z$ r7 B/ [; Oa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
0 F) O7 V, T0 m+ Qa=n.encode('utf-8') 3 s" a6 Y; m5 Z8 L
print(a)
+ I3 \; y8 j9 D& t3 }" {! }b=a.decode('utf-8')- C) ^2 z) h, f# G5 S, `  o
print(b)
3 ?7 Y7 c& z3 z3 U* E( Ib. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
0 S3 k* ]) L6 w4 R, p3 T$ c' O& U/ |print(a)! A. ~6 V& W( D, D5 {
b=a.decode('gbk')3 E/ o8 I3 u8 D; [
print(b)28、求 1-100 内的所有数的和
5 T/ K1 S2 \! |! Scount=1
; v; u# W' w2 |- C: X/ Q6 h* hsum=0
3 P0 H# Y$ ]& K1 T) L4 xfor i in range(100) :
3 q& u) Z, l" r" r+ K! n: ? sum=sum+count
6 \: O8 |! s/ ~7 X" ^5 d count+=1" o8 j3 y" \! ~* M+ ]2 F8 O
print(sum)
; ?* [  ~! Y6 U( V+ s. b1 I) e+ z4 z7 e# Z; E
count=1" [$ L) }7 D% T) k+ Z. c
sum=0
* B6 |! b' h+ I5 B3 Kwhile count<=100 :3 h7 p- P: H1 \- l# a9 {
sum+=count
9 a6 b. y. p  ]+ R2 d count+=1
" u$ j# X: z$ W6 u9 `print(sum)29、元素分类( l5 ?7 s% B+ Z1 t
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，$ \2 o; j$ h( L8 L1 Z% a$ d) |1 o
将小于 66 的值保存至第二个 key 的值中。
" {( |* a+ e$ i* D/ |5 W即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}. D( w% S+ x0 C# s0 a. @- Y' m4 a
li=[11,22,33,44,55,66,77,88,99,90]
- W5 E" A2 n2 P# A9 t3 e: t7 ^" Ydic1={+ s  d" g) Z. D4 u" Y( ^
'max':[],
5 O! R6 ]' ?# p 'min':[]& `0 e& w& |+ a) o/ x" }
}
* G5 K) b5 }# X1 n: i" |for i in li :, l# X. s  \7 P! ?
if i <66 :
3 x: l/ `5 N+ O& c) s* t6 `       dic1['min'].append(i)
  c' t5 x8 M7 A# t5 H( ?& q else:
5 G4 A/ Z+ ]2 v       dic1['max'].append(i)
8 V) u1 k6 v9 z. lprint(dic1)
7 l( Y! T4 ?+ ?# c
# @, s1 k& s; S, s8 T5 [8 T: }; w---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}; a3 x% [4 N+ D) E: ~2 d( P

Python基础知识汇总

主题推荐