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、写代码
: N2 L/ \0 c2 N5 R7 [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) :
: w( ~( G! C& @ name = input('name:').strip()# X. @) Y# Z  }3 S' T+ X0 z
pwd = input('pwd：').strip()" ], B1 R" S% L2 C& l. r

) ^# Z) a4 K0 B2 s- _! k) N if name=='seven' and pwd=='123' :
, _0 E4 Y( h2 p$ \% s* X; ^       print('ok')
% U; n, Y4 K7 l# f else:
" J# p, q# a5 o" ~       print('error')
7 ?  ~, a  ]: x       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)  :- S, n, i0 [3 G1 o3 Q
name = input('name: ')
& c1 d8 N# a/ q7 `& F pwd = input('pwd: ')( e  h) J5 _* m" d+ ]: J2 a5 e
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: W$ K% `, S/ o. ^! k; S4 U6 N. C       print('ok'), Q* `# x  c7 {6 c; D: F* u
else :" H! `, T" }, t* C- f" a
      print('error'), S3 [' k2 i) i7 ]& d
      count+=111、写代码
3 F1 {# K5 x' o9 V& Oa. 使用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) :$ O/ u! N- i; k# p# F( }
if i %2 != 0 :, ^9 {' g8 v8 G3 g4 T
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
1 m3 b) w. G2 n% S0 S if i %2 == 0:6 m  y7 x9 A6 f* i- P0 ^: k
      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"
0 w- s, ]1 |( 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)% n) ]( b6 |7 y) [* y
for i in name:
7 v$ T% A8 v( Q7 c8 H/ S2 X print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 d  n/ j* {* R/ M0 q9 ^
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- ~3 o  e  ?  [+ D% T# |print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    0 h' u  m3 W# ?, F: h4 P$ X
print(li)
1 Q5 F+ Z4 E0 t- }4 ?: R* X% f ['alex', 'eric', 'rain', 'seven']
# s: X4 V& C7 n0 L5 w6 Cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. Q' T7 B1 D8 D+ I$ Z6 a5 I! M  _% aprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ K5 a) x1 f* y; k9 _0 Qprint(li)
! t% E( U' B* d& Fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; v9 Q4 E0 o- F# a2 `7 ^2 Jli.pop(1)$ N# p; ^/ N2 D
print(li) ['alex', 'rain']
, F, r# ^# T0 I$ s7 T8 y: F' l2 G% p指名道姓的删除li = ['alex', 'eric', 'rain']/ P, f  }3 N6 X* L8 @4 U  X. N
li.remove('alex')
8 [+ J) p1 d5 E' oprint(li)
8 Y; N; V" m1 ?+ i! ]f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']9 O% r% U2 d# D) G
print(li.pop(1))! l5 o% {6 ]* P
print(li)2 {8 ]/ N4 h* i+ v. P( o

4 Q/ V5 a' R% t: R! ]eric8 q1 k1 N& R1 l+ r0 M8 ~
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
+ t7 O6 M- u) t1 {' \& \del li[1:]& g/ I4 C8 c& D9 T9 B- H& S- P
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
! l2 W$ N" R- A5 yli = ['alex', 'eric', 'rain']. V# `1 g9 p) W% Q3 k7 g* {$ ?
for k,v in enumerate(li,1):
5 A$ N8 v# a& z print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 G  }  |2 v6 M( h: Ia. 请输出 “Kelly”
- s, Q- t8 F: ~3 M8 n6 Sli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 U. j( g* ]0 @7 [' ~4 Z! X+ j2 a* cprint(li[2][1][1])
, u8 `4 H6 |$ V4 k4 kb. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 |( v; \' F' H; I- p5 c2 O. C- u
li[2][2]='ALL'" m$ j7 z) h- f
print(li)
$ k$ j$ k6 K; T+ c3 m7 ^! Q1 J  ^+ d24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'); e8 c% @# h, Q! U( V
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'): y) \4 R3 y0 M$ R* |
print(len(tu))6 j  g# M& D6 w# Q! z6 ^" U1 f
b. 获取元组的第 2 个元素，并输出3 u, a4 J/ ~, m" B: w4 X, ]1 g
print(tu[1])$ B- _( J" D# B# m( k7 r: ?6 K
e. 请使用 for、len、range 输出元组的索引  `/ E; X6 B! v/ ~: t
for i in range(len(tu)) :: \6 Z1 D# U7 ~7 |4 E; o( B
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)* k& w5 M: f" N  Z" s
for k,v in enumerate(tu,10) :
9 ^4 U, F; F  M3 ~7 T print(k,v)- A- v9 K1 u* e* ]2 j6 N( r2 k
10 alex
/ }3 A3 C1 c0 q; W# V: h+ y1 w8 t' R11 eric
5 R0 R/ |- p% X6 W9 }1 c( k/ \% a12 rain) a. ?9 o2 }, j6 T! K, e

# C( Q/ _$ Z7 l7 V: A: }) bfor k in enumerate(tu,10) :
6 u8 o# ]" D  U0 b: n3 |$ E) U print(k)
8 n& a9 g: f- u+ D5 Z+ d(10, 'alex'). O- s! x2 I$ c& F$ w  r
(11, 'eric')
6 |$ O3 k% }* G+ Z(12, 'rain')
- {8 @* m7 f; o! S, }
0 G% I5 D! e. o0 q2 i& w( n+ H$ J4 I" ]' \! x4 i
25、有如下变量，请实现要求的功能
4 W0 z3 L& G: Y4 d) @7 jtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

4 N# i5 J1 _: P- O$ `. Q" N, b9 Cd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ _0 p) m6 {7 _! d
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
8 C) k! y2 O- g- u3 ?$ U- S! l& C" Xres=tu[1][2]['k2'].append('seven'). G) u+ H1 `/ M
7 Q# L/ F. N, ?$ |# v; X
print(tu)% e3 Q- B4 X5 I  o7 x) z
26、字典  q8 p. {+ Y) Z  W$ B& \* {
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( n7 W% T: T. ]5 Z% c8 S4 p print(i)b. 请循环输出所有的 value" m( x. u5 I) ~0 ]9 s& Z' |
for i in dic:
5 E: G  N" [: k9 _" m print(dic)
% u* I; ?7 ~; |- y% q4 uc. 请循环输出所有的 key 和 valuefor i in dic:7 q4 @& a, k, o) ?, y9 Z
print(i,dic)* H; S- @( e0 N: J- x; ^
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
8 j& t# Z# F) z4 Hdic['k4']='v4'
, \, M# S. L$ b. O" Oprint(dic)5 a2 g) c: }& r+ Y+ Q
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 b# Z3 q1 O  C- _) x) s4 n- E) p2 qdic['k1']='alex'! l( x! l$ a* v$ M( D8 ?
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典4 P- r: r8 ^9 ]% F. s5 K
dic['k3'].append(44)* m; j, l% G) s
print(dic)
9 K* \& D3 O! T" t& q% D/ ]2 g6 C# `- @4 ^- n) S3 Q8 u
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
1 j: O; V! r) e/ e% |: Bdic['k3'].insert(0,44)+ C( W1 k! u6 [* b1 F
print(dic)
. @9 C1 j& _+ |2 X3 k8 c27、转换
; q! A6 O0 @& {; h: pa. 将字符串 s = "alex" 转换成列表  s = "alex"& c' U8 E) D; G3 E% k6 m3 d
9 f  O- f( N2 |  U, f
print(list(s))b. 将字符串 s = "alex" 转换成元祖6 V# K* s; p* ?' H$ G' [2 X  }
s = "alex"
' S: d5 b, r; x8 ^: I2 |print(tuple(s))$ k1 ~! i" _4 g+ _/ M, R0 z4 L# j
) q, q! d* W2 l6 G, L$ w
b. 将列表 li = ["alex", "seven"] 转换成元组
1 s# h( a# n5 R8 o3 K, @li = ["alex", "seven"]9 y. ?- V1 O0 v3 g7 ]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表# b9 t7 o0 j1 |: O7 ^( K. `
tu = ('Alex', "seven")
  q0 i4 R; w+ ^7 v4 x  Fli=list(tu)8 K% `+ K$ v* a2 x+ u+ [" D
print(li)
2 w6 W& R  H8 N! `- S3 [0 V
4 R3 d1 J0 I# U
5 K* u. R7 k& K  Dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# f1 {' s7 i" C3 i# U  @
% B5 z" ?' X9 J! Fdic={}- A9 l) l6 F1 K) ?% b
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面8 a7 O+ B* R5 Q2 a  H/ P* i$ f
dic[k]=v4 a' E  m8 h4 g% p$ K* f
print(dic)27、转码n = "老男孩"& w/ V% F! y; q) ^
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: \+ |: N4 n" z  [; c! h( ^0 Ya=n.encode('utf-8')
& f( R5 n3 s$ t. G+ kprint(a)
# s/ d. O8 `/ U1 ~( C" K% }/ t0 cb=a.decode('utf-8')/ N& M% ?. E$ U; R
print(b)
7 n* M1 m4 W% I1 R% M( I! |7 nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'): n5 Q3 z+ s" A! e6 L
print(a)
% h6 l6 R2 z6 cb=a.decode('gbk')) Q' d) `. ^# Z9 G9 u
print(b)28、求 1-100 内的所有数的和5 }( ^& M* E( |  Y5 }' h' {
count=13 h4 `% v) N3 R. f$ w
sum=0
* J4 k! i7 K8 N$ C4 _for i in range(100) :
& Z2 u# T: f+ J3 K% q sum=sum+count
1 U0 A5 q7 ^$ X4 k9 L& F, u- r count+=1
: C1 O; y! R' H- u9 qprint(sum)8 v) i" B' c% O3 j% K3 M9 q& m

( I6 I! y! u0 t$ Y: Q5 R: ccount=1* o4 t' p/ G% N/ r3 X1 [" v0 O" Q
sum=0
3 S! \) a: T* ?" m( b. F5 q8 pwhile count<=100 :
( y0 A$ I# l( b/ e& f; f sum+=count  Q. j! q) \/ @; B# w  b' s  L- C
count+=1+ s" N5 t; n3 b8 O1 c, }; b7 a/ X3 X
print(sum)29、元素分类% a, G' I3 u/ |0 C5 F" _" u
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，( T$ o' C% w; }  n' D2 w, h3 W+ S
将小于 66 的值保存至第二个 key 的值中。; _# j& [2 X& G" H8 U( h3 L7 L
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 W# L) G( t! F# y& tli=[11,22,33,44,55,66,77,88,99,90]" C. U; c; E, g1 P
dic1={6 O/ u7 f0 N5 t( P& h
'max':[],7 ]* Y9 T3 I, V2 f
'min':[]
3 _2 |. @2 o- g  W}* J. W+ r8 v# }- d" a8 l
for i in li :, q/ l/ l: @  C+ z6 [
if i <66 :
8 b$ @' |' O% d3 J! H       dic1['min'].append(i)4 y" X$ J* r, Z: ~0 ?
else:1 n0 D- V2 r, c$ i# i
      dic1['max'].append(i)) x$ Z# y9 H# R/ p
print(dic1)2 E5 R8 ~* _2 M4 u/ g" ~. b, O

% s6 [! ]. [& M8 L---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
+ z* \. h8 g. F( z' q0 R

Python基础知识汇总

主题推荐