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、写代码
( A) z7 x: a* q5 fa.实现用户输入用户名和密码，当用户名为 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) :# x% j/ ?- x7 h8 C! e
name = input('name:').strip()
8 f  ~: g0 A5 k$ ?; I# ]5 W pwd = input('pwd：').strip()) `; R9 a9 O5 F( g* M; J

6 N* k1 r" T+ g5 Z2 c% j, K% o+ { if name=='seven' and pwd=='123' :
; S1 R7 m3 _* p5 Z$ }       print('ok')
* f) i$ F  A+ e% ]) K8 S% H else:
6 I! P5 ~/ ^. V( C       print('error')( n& n% I; F7 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)  :
3 _2 P/ J$ Z6 a name = input('name: ')
5 W% E# K0 |1 j, c# s pwd = input('pwd: ')2 Q" Z) R# J5 E  U  v* v& a
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. k+ V9 U9 u" I       print('ok')
' H2 J( f; w' h3 D  y else :6 J, B" H/ j# d+ r1 Q
      print('error')1 ]* D1 t, t2 q/ S8 p) @
      count+=111、写代码
1 n* Z0 ~# e' H0 p& Ta. 使用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) :
) Q6 Q2 A. O* c5 I if i %2 != 0 :
, l' f: Q4 g5 e2 f& e       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :$ y/ X: c/ O5 a
if i %2 == 0:
1 I5 k7 T: Z: m* C       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"  y3 G7 T4 M, j
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)
3 m  ]$ E& _( r) ffor i in name:8 S5 h/ O% s% l: s3 l& c
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain" q8 ~+ q# I, R% b; G
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain'], M8 W% [4 S9 k2 k
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    $ E* P% }% ^$ X/ X1 Y" B% B
print(li)
- {3 j; t/ j9 {# w( x! c  x; q ['alex', 'eric', 'rain', 'seven']& R' P. i' c7 n3 S. k
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
! j( }  b: H) g% Y# P  {3 Zprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
: i/ R7 n, N6 s) x+ [8 R/ ]1 sprint(li)& f$ E: [! [) O+ Z% a
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
% ~: b4 i! A- b1 n. i) Y+ f, nli.pop(1)! c; N0 M# L3 U3 i0 N% O+ Y
print(li) ['alex', 'rain']+ t4 R$ Y, S4 Q: X
指名道姓的删除li = ['alex', 'eric', 'rain']+ j: ]5 y/ F& D. G! _* y, b" c
li.remove('alex')  j' ?4 Q# e4 V' q
print(li)0 t6 {% V" o- n
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
0 {! g( a8 R8 I1 y  r# `print(li.pop(1))
+ f6 |" `5 C- G6 d. F; ?print(li)
# a: X  C8 g0 T# r
" @; w. E& [! H8 c" X6 G' o. ~eric- p, F1 k( A8 K/ ~2 `
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
4 S8 C# V3 I! idel li[1:]
1 T9 |( u$ B# G$ b# Jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
8 \& X/ g) y4 p- F" I% P( T# p; |li = ['alex', 'eric', 'rain']' k) ], W  ?- A: m* i
for k,v in enumerate(li,1):
1 O  B3 n0 t* t+ E5 A5 a/ y/ r: F7 ` print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& P# M* h: u) A. Q# @a. 请输出 “Kelly”4 ^# n. C7 g7 [0 |, f; _
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 _2 j- n/ C1 o6 E  J% Sprint(li[2][1][1])- u3 S/ b( ^4 |
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: U5 _1 K2 M: i$ |, A% Zli[2][2]='ALL'
8 a1 [  p! U5 [0 Tprint(li)
$ ^7 G8 l* E/ w& D6 {! A24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')$ }$ [3 x& s0 T& M1 s* {
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'), E# F" r6 i, |! i9 z$ U3 g
print(len(tu))
6 w& l, J" i3 E0 E- F: ^) ~( gb. 获取元组的第 2 个元素，并输出
# c! r) S6 o5 c8 G0 \print(tu[1])
9 C0 \3 [* K0 o4 s0 D# Le. 请使用 for、len、range 输出元组的索引8 p8 R1 F, S- e4 Q; d1 o& n" ?* I
for i in range(len(tu)) :; _0 r8 u" D  R; t* Y# Z- G8 k
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
& c0 }$ N5 Y. T% v9 O" r$ Xfor k,v in enumerate(tu,10) :: S; O5 e0 D: o/ o! _
print(k,v)
+ H2 {- i) s  }# J* z10 alex3 R  q6 Z6 P: k* h0 n: {# L; G9 ~
11 eric
3 M" V/ }/ L+ `* ?8 H12 rain0 @5 ~% K  b) `- z9 V

$ u6 m( l& H  R9 h" `for k in enumerate(tu,10) :
% n* |: h; T; h8 \  Q7 n print(k)7 r& I3 K  t: x0 _& i# U
(10, 'alex')
( e) T) t6 \) O/ i(11, 'eric')- |/ X% |9 S- B# C( b3 v
(12, 'rain')( q9 Q8 G6 N2 b  p0 j$ m  `  {
' j1 J/ N/ G. b2 }: L# j* V3 C
3 J9 [/ e/ `( R7 }( D7 n
25、有如下变量，请实现要求的功能
# }1 j7 U& C- I( e, L5 ktu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 k  N3 R; W6 y3 [  k6 Vd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以% }& X7 Y. e  E3 l0 \, c
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# |/ O4 u8 P' A8 U" Y& qres=tu[1][2]['k2'].append('seven')# f+ m8 {7 z! z4 {0 y# R* ~

4 F* U: Y# X( D4 B. aprint(tu)+ ]- m5 W9 T$ l4 @/ {2 \
26、字典* G" k9 q1 M. T" |1 R/ O
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:& O, |2 ?# d) _/ ^3 p8 T; ~
print(i)b. 请循环输出所有的 value
% N3 C, e2 X8 V+ `/ ]% D' Jfor i in dic:& e, {5 V% d* [6 p) h/ s
print(dic); U- _( P. s9 o; f; v. n, `
c. 请循环输出所有的 key 和 valuefor i in dic:2 n6 w, Y+ j8 A% Z/ g
print(i,dic)
# [8 A! C7 P5 _% b; x7 u$ D+ ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
* B2 \- ]8 C* g) E) xdic['k4']='v4'& z8 V% h5 l8 G
print(dic)
7 W; V8 P+ l, Q# t& z" m5 |3 M# Ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# s% J# |" v9 V7 \; [8 \3 Idic['k1']='alex'
, Z- l  ]- m+ J* f& ^% H( ?print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 k% S1 |- [/ y4 k- g8 z% @, @dic['k3'].append(44)
- o( r# V  S2 `5 z4 ]  f0 [! Iprint(dic)$ K8 y4 |% L0 A( l8 W
& h9 o8 v3 d2 l8 K2 H
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典- v% {: p7 p7 B: t  s, u( }
dic['k3'].insert(0,44)1 c4 l* w; L# N8 \) D
print(dic)
1 E- ^6 e( X+ o& k+ M0 J27、转换) S) U4 X- d& v, S! Q7 j
a. 将字符串 s = "alex" 转换成列表  s = "alex"* U8 g  y# K0 M4 Y; {8 f
: L: }. q( f1 |. L
print(list(s))b. 将字符串 s = "alex" 转换成元祖
% d1 d/ r% o. Ss = "alex"
6 `! A9 s; s3 Q4 n. b, _print(tuple(s))
8 l# g$ |2 [) i$ Q$ h( |! ~. B% b
' ~2 Z$ [9 a! r& e6 P6 Xb. 将列表 li = ["alex", "seven"] 转换成元组
0 @7 h! i# z; Y# {% Z. _( c$ ~li = ["alex", "seven"]2 C8 \6 X: z. N4 N6 N3 n
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表* D9 O& i( {8 P4 b7 b% }
tu = ('Alex', "seven")7 r/ T$ \7 R8 G9 F
li=list(tu)& D6 X( \% q* k( ~; v% ~1 v
print(li)
" y7 w9 n' m! q( |/ \0 \! I+ Z% }+ d$ a4 s7 K
, o$ I: a& t) M
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& V+ W6 n3 y- g3 Z/ e7 |
8 W! t* A: [& D. Y: o7 E# A  a: D5 Ldic={}
0 O, Q0 F/ n4 h" Kfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面- S$ t' k" Z! F1 P1 x5 w
dic[k]=v
" Q- N4 o- e; L% D5 G' d5 \ print(dic)27、转码n = "老男孩"
4 @. V: t: S- b7 f0 h) p8 ha. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, Y4 e' {  m4 k! l+ ~a=n.encode('utf-8') # ^. Z1 X1 d! q% ?1 y
print(a)
4 U7 w+ N( S, ~- e& Mb=a.decode('utf-8')
+ B! ]6 n) C; y9 Vprint(b)
, U$ R% V. M5 x1 D( p4 B- lb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
" I1 U7 k/ L0 c' n/ g! c9 Eprint(a). J3 w1 X; W' Q% v$ H: |
b=a.decode('gbk'). r, x' u8 c2 q- d. P. V% L
print(b)28、求 1-100 内的所有数的和$ l7 u" k1 Y* R7 H
count=1& I; S* d$ Y: U  ^% T- N0 T  c
sum=0
7 e+ d: v3 l# g1 J. t' @% {' pfor i in range(100) :( J: g9 \& `6 F) O& S  A
sum=sum+count' {! O, I  c3 M+ b7 |1 @( j
count+=1& y3 J, q9 f% M/ N
print(sum)2 O4 n) g; g! p0 Z' k
& p3 y9 O5 s9 M5 V7 `. Q
count=13 R2 C4 I4 B1 D& `' @9 M4 Z
sum=0
7 U' f- x4 ~7 i6 }$ h4 N  bwhile count<=100 :
1 a/ v# }0 P4 p' y sum+=count
  J* b3 _2 b# Z" g& J count+=14 W. E% }: `# d( A/ m
print(sum)29、元素分类
. ~) u: D1 E  k有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
, \; z  p0 h; `将小于 66 的值保存至第二个 key 的值中。
' p6 q* K6 x6 Q! {$ x即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
- G. m4 b/ S1 [3 {li=[11,22,33,44,55,66,77,88,99,90]
4 F- e; x) X* W5 ~, U6 ddic1={/ N$ y4 U  ^- W( A' a
'max':[],
- V, W( i. h. i/ V1 T) d 'min':[]4 b6 [7 n! C! k# n- H, g5 T  n
}! l# b6 I0 \1 U/ I9 \; {; U
for i in li :' L3 S# W8 {9 x/ T) k( S7 t% a
if i <66 :0 ?3 |* D4 I+ w+ l0 T
      dic1['min'].append(i)
' s+ V& ]1 g: a: X3 [9 s, W& w0 A else:4 f9 t4 B3 @" p& ~
      dic1['max'].append(i): j/ |) B  h& E) m1 A1 D
print(dic1)
- |8 u3 K" c+ a) M8 Y- |& {5 a9 O. R; @" s
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) j2 X4 A- R$ K% {

Python基础知识汇总

主题推荐