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、写代码2 ~% W3 x& ~' k# n) m
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) :
% _, g) N0 A8 t% U! D* `# j+ E name = input('name:').strip()
* j9 b2 |6 @5 Z pwd = input('pwd：').strip()
: o( m1 \+ p* [$ ?
7 B* C% K8 X) v9 \3 Y9 ^ if name=='seven' and pwd=='123' :
0 y/ y% z: k8 h7 J$ i$ z$ s       print('ok')' b) Z4 G0 T$ _8 b5 _
else:
# {, ^9 H/ I* y, N       print('error')5 F" ?; U1 C0 a# G% Z) M! L* y
      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)  :7 b' v+ b' @& R1 }- X  A5 e
name = input('name: ')
/ j) e8 P( S. p# C; i, n  R( G7 y pwd = input('pwd: ')
: m& z7 Z7 P5 o1 L( K0 f" b if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':" }: j( o- o- }
      print('ok')6 e2 n: n+ o; ~
else :
- G# l/ p8 a! D9 c: {6 f       print('error')' `, N7 u+ v% Y
      count+=111、写代码1 k* h9 _" A$ ?* ?
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) :* t/ K( S: C. K
if i %2 != 0 :
6 t- R" t7 V$ w" W  U       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
- s3 |" D7 [4 T9 }) S if i %2 == 0:
* I$ f2 Z! ]' Y5 ~/ Z  p. e       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"
! T( g0 ^3 H" S  A# Q0 ia. 移除 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)7 f  m1 M8 T- u+ v; h2 g1 o
for i in name:
  Z5 X$ s/ k* c! U! }4 w+ \, h1 p print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
7 R" f7 R& Q- p5 d5 ?22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 Q& F4 l1 r# R4 B+ M% }1 G, Iprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    * j- U! Z! Z( V' z/ O  ~
print(li)
3 J. i6 e  I  b! {8 ~  i  D ['alex', 'eric', 'rain', 'seven']
+ I# l8 ]$ w4 s9 @! L( fc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
9 I; U/ a4 M3 @- wprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')- `% A2 D4 u% K" w! m5 W+ c
print(li)
+ _: _; K: k- K5 Be. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
7 B% x: I: D; ^9 W! [+ ili.pop(1)
& c+ i; {' T* ]5 z8 n, {0 b7 K5 O+ Gprint(li) ['alex', 'rain']
, p$ }: P2 U0 n% K. W2 ?3 ?. h* g指名道姓的删除li = ['alex', 'eric', 'rain']
1 r; C- }& W: v0 f7 Hli.remove('alex')6 j/ p! f& B4 s5 ]+ B3 I  f
print(li)
- }. a' e) c/ R1 }f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
: T- O5 V, ]1 kprint(li.pop(1))
- @) W' m$ t, {0 c9 w: N0 ~9 ~/ b. Bprint(li)$ }" w4 q7 u2 h

3 _8 G/ R( D9 T% N1 b1 Feric9 T6 |8 F( W) D: m, J
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
* _  d0 q/ I, y* n$ @* T( Y8 O6 ndel li[1:]) M/ N& M! s1 T# L! Z% C
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
  G' y- l' S5 ^2 T4 {2 N4 ?li = ['alex', 'eric', 'rain']
# [3 n( t) R) r& r; t6 Wfor k,v in enumerate(li,1):
) Z, d: d/ E# y0 ` print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% }. _$ D$ ]2 E9 C) b) S: g; za. 请输出 “Kelly”
" H- |  _) _  E, Pli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 _, Z$ }# W; P. G5 x# J  w/ Hprint(li[2][1][1])5 u* }% @7 F6 @  q" F: \
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
/ W. ~' x' `* r/ g' u6 M0 zli[2][2]='ALL'
2 d. {" g) c: Iprint(li)
/ _$ V0 F" j7 A! S# P24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')- ?) H; N+ J3 V4 Y) a( y
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')$ Q* I6 n; d% o  K, s
print(len(tu))
+ k* X4 A& j) [) F6 wb. 获取元组的第 2 个元素，并输出
# A9 w3 |" g! `  n) M! ?3 Zprint(tu[1])
* w6 X1 q2 |; z. W/ E! a- ke. 请使用 for、len、range 输出元组的索引
5 o% T5 N. b9 Q+ w8 x3 z2 Z1 sfor i in range(len(tu)) :
$ Z9 v3 U/ `/ g" ?: F+ ]8 W7 i print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 {8 H3 E$ z' x. V' z5 j* ^
for k,v in enumerate(tu,10) :
0 D2 S4 i3 U; p* {# J  ^ print(k,v)& s, B* Z" J! o1 [7 ]6 l
10 alex
8 g5 _# k, v; N: _: _11 eric4 }! R/ h$ D( D* s
12 rain
+ p8 c3 O# c( F( R
4 |1 ^) n% A8 T7 Q+ }for k in enumerate(tu,10) :( {' K. w' \# H0 n8 c3 ~3 j" J, W) Q# P3 ]
print(k)7 H. g4 M- ]5 Y& x9 z. e0 _
(10, 'alex')/ ]! c  I# s, W
(11, 'eric'). |3 G- d1 N  j- Z
(12, 'rain')- r) Q. C2 ]# I# A% o

$ {- z+ f, }1 `+ I4 B% u$ \! x7 A) s+ B" N
25、有如下变量，请实现要求的功能2 W# [: {2 ]5 D1 V% W9 z6 K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
( R' D5 J8 @3 U4 v
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 l2 ~7 Y" v9 M  Z  ~( utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  R' N9 x. o2 rres=tu[1][2]['k2'].append('seven')) P9 D# L1 z' f; A* `
& o1 i9 R/ A6 l/ @( a6 T$ D
print(tu)% y8 c3 {( Q+ W, D. X% M
26、字典# W0 z; E1 ?4 l6 {! z
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:& C8 \# n. c# C0 ?
print(i)b. 请循环输出所有的 value
; \; Q. c. x9 Zfor i in dic:3 M, Y6 }! _' w/ l8 W' K  Z5 q
print(dic)
8 {9 U& ^4 e0 a/ wc. 请循环输出所有的 key 和 valuefor i in dic:/ n8 x9 X( i0 |5 a. K, I
print(i,dic)
2 A9 y; K9 o$ B2 ~0 N9 l4 ~d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 Q6 ?9 [6 {2 S' _( c7 s0 [7 O: Ldic['k4']='v4'% O4 y% \1 v+ U; g, c! u
print(dic)
9 o- |+ c) m- R" q" o8 Ue. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典9 T: M  k. m8 e/ R( w1 l* q2 h
dic['k1']='alex'
2 v7 H, J$ o% [7 i+ z* K( V! mprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典  \* L- ~' b3 o# e# `3 Y
dic['k3'].append(44)/ Q6 u' X- }& Z* L5 m' V. }
print(dic)
) J- W$ H1 ?6 n/ V0 D
/ {; \% ~  `- K8 Q# rg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ m% `8 Y9 S: f& U* Fdic['k3'].insert(0,44)  W2 e% N/ W; h# d# z% ~. B1 e: K! r
print(dic)
: d; D$ z: v0 S6 ^6 U4 b27、转换
' J9 A/ P5 {) p. K9 p+ R- Z- Ya. 将字符串 s = "alex" 转换成列表  s = "alex": `9 j0 Z2 I* t3 N( V  o
, ~0 p! M+ Y- u. g' v
print(list(s))b. 将字符串 s = "alex" 转换成元祖# y0 T4 w1 h! Z3 e) h) G
s = "alex"9 z* Y( u# v9 c. \$ o! M$ I
print(tuple(s))
+ ~% j1 R- F7 W7 R) y
" L# K8 H0 b3 Kb. 将列表 li = ["alex", "seven"] 转换成元组% o8 p" [8 z/ B) Z6 m" ^
li = ["alex", "seven"]
( S+ i# R) k4 J+ h& eprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表9 u; a% R) b" ]! J/ ?1 i
tu = ('Alex', "seven")0 p4 j  ~  k/ N, f8 @& _/ ]: v9 K
li=list(tu)+ S7 E: g0 A' n8 P
print(li); ?; P$ }9 w5 c, R! r
1 }% c# n5 {( K- X1 J' k
3 N4 P/ \3 X. X
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增2 k* }" i5 o: k( V6 Z) A+ x

& N* s1 L3 x6 B4 L- `0 Bdic={}9 g& F# f+ U) u( @; _2 u) X- h
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
4 D% {$ C  I7 U3 _$ ]% l6 _ dic[k]=v
: X: q$ W4 B0 G- W( t: E print(dic)27、转码n = "老男孩"$ x9 z  ^0 T8 B! T7 h
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ b; {8 n$ W3 j! |a=n.encode('utf-8') : T. |  o; M0 P# F1 z! b
print(a); X1 e) I; E* S; C" A! o: ?
b=a.decode('utf-8')5 f6 F8 x5 [; A2 m" R- p: e
print(b)
' T; N/ ?8 l# s3 |3 ib. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
; C/ Q; k" m( jprint(a)
; t9 v) _* v0 j+ F- N+ E1 i. L. Yb=a.decode('gbk')
4 f' m+ G$ i/ }8 J7 Q) Nprint(b)28、求 1-100 内的所有数的和0 l# l  ]( s& {, ?" P/ s& |. U, B
count=1
2 T& k/ R* P( {' Y+ @5 ?5 jsum=0
' ^% I* i0 u- k5 {8 @for i in range(100) :7 V4 |& O* L! E2 c( Q
sum=sum+count6 g& B4 n7 w5 S# Y) O
count+=1) \* x% ~* S0 e* K% f
print(sum)8 H2 e' a1 z! `5 J
2 f$ c& Q8 L1 D8 C6 P
count=1* p9 Z8 m4 w  \) f0 p9 ?6 u
sum=05 c& ]+ e3 M, K" E  }& t2 L
while count<=100 :
- \3 a. o+ \4 M: s( I3 N( r1 r sum+=count) F7 [/ ^2 t6 \
count+=1  x3 G) q& g+ j3 p' j
print(sum)29、元素分类
: k: E) k, e& Y8 g有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，9 c' e8 `5 f! I) {& P
将小于 66 的值保存至第二个 key 的值中。
* @% Y7 D0 s9 K" R" @) t: l% X) V5 s即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
6 l' h7 d) C$ kli=[11,22,33,44,55,66,77,88,99,90]3 X/ @: _# k; N9 f' |
dic1={
% W2 l! z4 z4 I2 N6 X  Q 'max':[],( m# F7 ?" J8 h4 k$ |+ O: J/ f
'min':[]
. j" s, H# b) k" j# \# V}/ V3 ]# M, K' j5 [6 Q( z" Q
for i in li :
$ H; m; y8 q8 g0 W( Y& L. Q) K if i <66 :
" Y6 u- \; f8 F* ]  T; B       dic1['min'].append(i)
* G+ ^4 l% V  }7 u( t" D else:! c+ W8 `; n7 g
      dic1['max'].append(i)
# }1 Y% L( Y2 f) T. b' v: {4 Dprint(dic1)2 o% [8 K1 _8 F. w* H# ?# |% N1 }0 ?

% K1 m! `% ?$ c2 _( w& x" \---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}- y' g8 K/ k2 I

Python基础知识汇总

主题推荐