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、写代码
& G' O+ Z8 P- m4 Va.实现用户输入用户名和密码，当用户名为 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) :( H) T+ X+ P1 W' P  p
name = input('name:').strip()
4 S) H# J2 V( Q0 |, A pwd = input('pwd：').strip()
$ j& U# E. K+ b" k2 k1 `4 _
) G' s; r) N! j) l' O$ o$ C8 | if name=='seven' and pwd=='123' :
$ c4 m! w& G1 y9 z4 i  s" ]- ?2 F4 [       print('ok')0 `  f' n* u# m0 G4 \
else:5 G# _3 w( z+ @7 i9 f
      print('error')  ^( r0 \2 p7 O6 w# M/ P
      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)  :/ `% K( q' }" c# E$ s. W. o
name = input('name: '): s+ X- V% M! @4 C- ?* @8 _0 U
pwd = input('pwd: '). N" m4 q* I0 N; W  R( ^
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':7 e5 Y: w* m7 H. N  x2 T6 }$ D
      print('ok')/ G$ w  b- R% O8 s/ O
else :  i: q8 L  ]+ y9 e- D; X
      print('error')
1 t; m- c. h' w( c' A       count+=111、写代码
' N: y" D4 P9 g8 j1 va. 使用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) :1 a$ M. [. J( Q2 O/ {0 ~9 c: ?2 b: _
if i %2 != 0 :8 E# M3 U0 O- u# D" `1 u0 k! D
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :7 ~9 h7 r  W8 _- h6 y
if i %2 == 0:
' Z, A3 |( \" c5 u       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"
( ]$ S: f  i# A5 la. 移除 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)" k0 f) W0 w* ?2 c
for i in name:: N: D: z7 C4 f! |9 N
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
9 A  @! }, r% j: W+ v" h22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']6 j/ b, q" k/ g
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
) |/ a) X" L. m& m( N7 u% o  U# _2 lprint(li)6 Q. L2 c8 _3 D* W: T/ I" v! B
['alex', 'eric', 'rain', 'seven']
7 ^3 l; [8 j2 C/ J7 k9 Dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- b# O" G3 Z8 ~6 Fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'). Q2 y4 k" H4 X! |; k
print(li)3 A' K4 s3 j0 m4 t
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']; c2 H6 I& Z- [9 B0 x! W$ Y/ |% x$ a
li.pop(1)2 V" b. ^. b" s2 L- |7 i( P
print(li) ['alex', 'rain']
! P9 u/ b3 G0 W. V指名道姓的删除li = ['alex', 'eric', 'rain']
1 C5 z6 h! ]; j* d/ R! Oli.remove('alex')+ m+ P& T0 c- O5 n
print(li)# N, X  L2 F$ ~) k
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']0 |' C" ?" V# [' |! F! f: R
print(li.pop(1))/ |* V; x/ U$ E, z" P7 {+ a
print(li)
4 V% Z! y) R! P0 r+ c- v* P$ B- v5 y% @
eric
" a0 I3 _' G" j) B' v: Y/ g9 ]6 |['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']6 t1 u3 V6 D# q2 v& |/ B
del li[1:]" I- I% O3 `6 k" b# `1 K+ c
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始). S" P, L2 s$ ~$ w
li = ['alex', 'eric', 'rain']
; r0 O7 P, T- Xfor k,v in enumerate(li,1):+ q( q2 b2 L! k( Q  }$ r6 J  k4 B/ X
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
' t6 b1 D+ ~3 d# H- Ra. 请输出 “Kelly”& H2 s6 \2 P/ ^& d% d4 W5 {% E0 @
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 `' k. w8 n, f* @( Vprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
* O* m+ H+ d4 `: i* e& bli[2][2]='ALL'/ |: ^3 z# {  Z& y
print(li)( i5 j1 p4 ^+ y% @7 I$ {
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')2 n5 w% ?$ U0 n  J) y
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
8 A2 u' s7 }" K( M, v: yprint(len(tu))
7 `- ?: w) S# F. O5 [; z+ zb. 获取元组的第 2 个元素，并输出  `0 Q% l- s' F
print(tu[1])
: H9 b' g+ s* j( R! G$ R. `( ^* re. 请使用 for、len、range 输出元组的索引
" a3 g- e3 }0 zfor i in range(len(tu)) :" s: |! p, w7 q$ ?2 k2 t9 l4 ?
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始). u: i  v: Z/ [  k) |
for k,v in enumerate(tu,10) :
! f, j/ q; R, c, a& f! g print(k,v)+ Z4 R( b, M7 \1 P6 U
10 alex5 ?5 @0 @' P  V& t% Q' {
11 eric
# ?5 L7 x) j1 l( i12 rain
: {# t& |: z& {5 h, q' t4 }' F8 t) g9 ]3 o" d, i
for k in enumerate(tu,10) :  p+ c# R! G+ F" j1 K
print(k)( s' ~' n- j. ^$ d
(10, 'alex')
- _) ^/ I# Q7 _0 l6 L(11, 'eric')) a) i- S( C2 f- v% o
(12, 'rain')
6 Y" e* |3 J/ j# O7 H) j$ o- P1 p2 F, z6 Y) q6 X

6 A( m- E0 H$ U( K3 Z# R. b25、有如下变量，请实现要求的功能
7 p: |- ]- |& Q& k9 Xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
  U! l2 G* r  @
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以- R$ |6 v. A( J2 ^! l5 S& B
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])& q0 r0 d0 l  j( _+ k4 E. {' `- B
res=tu[1][2]['k2'].append('seven')7 x  ~- U1 S: Y- C0 W8 g' S
1 ~& t/ E! T* n% l7 c# p7 S' W
print(tu): s- z, _' w$ W4 n1 D4 x/ S1 M
26、字典
* [+ K6 c) l+ mdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# v, t7 d8 N4 M print(i)b. 请循环输出所有的 value
. u7 U6 N2 ~  ~% s( q6 f% M  U1 tfor i in dic:2 S/ ?9 A  g  D) R9 O8 V
print(dic)9 z4 q+ L' I  S6 R' X
c. 请循环输出所有的 key 和 valuefor i in dic:
4 E1 n2 y- L, g8 n5 i9 @6 d3 ?3 jprint(i,dic)8 i; W5 _; J/ w$ ]; c
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
: m0 L/ f7 d4 F( P* Fdic['k4']='v4'
4 `, ]0 \! K* f: g) x& B6 ]$ dprint(dic)
, F4 O! `! T0 |% y, G7 ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
; P* U; p" Y* @( D: }6 Idic['k1']='alex'
2 n( u3 k( ]! r% a- r. nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
; G6 G; j  ^' z# Tdic['k3'].append(44)7 _% K' E& G# ~6 ]+ O
print(dic)
! O: o. S9 u) Y9 N
, B5 a7 B4 v# }: ?" dg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典3 q9 j' t1 c; @. j2 ?3 a& y; ^* I
dic['k3'].insert(0,44)) P5 M3 ~  U# c6 B; S: r' h
print(dic)) ~- d: X) h0 o
27、转换) |  z# s1 Q9 a% l) Z
a. 将字符串 s = "alex" 转换成列表  s = "alex"
  o8 _5 g+ f" h& Q% U, p5 z& K. F+ L- I3 `
print(list(s))b. 将字符串 s = "alex" 转换成元祖$ r) r/ q7 ]' X- v% N
s = "alex"
% a2 u2 q( x; \- d4 {* _3 gprint(tuple(s)). R# A2 g* }# s5 S, n( x8 q

  N. E# {$ `) z/ M1 P$ J, s/ bb. 将列表 li = ["alex", "seven"] 转换成元组/ w+ t; [1 K2 v: P, |' k' k1 Q1 g
li = ["alex", "seven"]
( r6 a! b- ]8 Z6 T/ a" jprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
+ n8 N  I# [8 K" u6 Q  [. }" r/ Utu = ('Alex', "seven")& t  M1 i+ C, l: J
li=list(tu)
% ?2 W2 j7 E) d7 h1 tprint(li)
0 C5 i* y# b! d
' I! n# x/ W$ L2 \* H' O* I
+ q: T1 p4 y9 V. Z. l$ od. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
% N) `0 c: {( y$ `6 d: k; D1 l; r  ?% x' J7 D2 K
dic={}
  L, H# E" d& f6 m! `3 G8 ~for k,v in enumerate(li,10) :----li要放在前面，序号放在后面+ w/ @; D2 d6 T& j  C( \5 @
dic[k]=v" D! E0 N" L- B7 p5 F
print(dic)27、转码n = "老男孩"
  j2 u% p: L' |$ P6 N' da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"4 t( p# q/ g% i& t- s
a=n.encode('utf-8') , D5 \1 W" L8 f* e. Z5 n
print(a)
$ l+ d+ y$ D6 k& R! `" ]b=a.decode('utf-8')
* v; t- {- B3 c& l0 E% Fprint(b)
% w4 K( F$ E: b( ^b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 y4 j. W% s+ N
print(a)* B: x4 O! J0 h6 V; m  m+ B
b=a.decode('gbk')
- m: L" w: u5 k) pprint(b)28、求 1-100 内的所有数的和
3 l$ @. O8 G3 l# R2 L8 Ncount=1
$ K, P9 S  i- |* b- ?. I* G# qsum=0
3 Z) j1 _: q- x/ Bfor i in range(100) :; r& u( x: E( y, I
sum=sum+count; u6 h0 C6 G% r3 z, y  Q% F
count+=1+ }  _4 b2 _4 [
print(sum)7 n+ H+ c: x, o9 J' j) Z

5 {$ w0 z" K9 o7 k( dcount=1: j3 r1 ]1 P: \, v
sum=0% {) e4 b7 z' |& H, a: n6 O5 }
while count<=100 :
; m2 Y6 p% x/ X; w sum+=count
+ O  J! L8 x5 E* W9 t0 M: G6 J count+=1
8 w( T& Q2 @  |9 n3 b7 z  kprint(sum)29、元素分类
( C5 f0 [) _# W有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，3 n( }2 {+ I* H# c2 B$ C( ^& ~9 T( m
将小于 66 的值保存至第二个 key 的值中。5 f/ o4 S- Z( ~4 N; A& ?8 L
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}4 u5 T, O# z, q
li=[11,22,33,44,55,66,77,88,99,90]+ G" P' L! d: k
dic1={9 I' I( V3 p& a$ n* a
'max':[],- d$ x5 x: ^& V) h8 l, z4 _
'min':[]3 D5 B; Y$ v% j( S5 z0 Y- R0 F
}
8 ?! _; a  i) Kfor i in li :3 g1 U2 @7 K* Y+ E1 R4 c8 R/ |
if i <66 :
& m7 R& a, r# ~! c% n: Y2 u       dic1['min'].append(i)$ |$ f& N6 g* a+ h" S' d; v; h5 e
else:
) @% }5 I# s+ h" [       dic1['max'].append(i)
8 j- N% _: Z: R- g0 P+ |& I6 Kprint(dic1)0 _& W5 m2 N& i$ T5 \" k

0 i, _- _8 k7 t: B---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
. m6 c6 W) J1 @% K+ T6 B+ J* ~

Python基础知识汇总

主题推荐