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、写代码) C  ~" z" W! t5 W
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) :: Q0 Q8 K8 G2 R3 e) }3 ~
name = input('name:').strip()- {" }. M0 A0 K) e/ i* |1 |
pwd = input('pwd：').strip()
( x* V% I# o8 f
+ @) u8 f: A* q if name=='seven' and pwd=='123' :
6 A$ S: p) @' |  O+ T9 Z       print('ok')
  C- V3 e) b9 I; t, F else:- x# h: ~: s; W( ]+ Q1 U9 U* \
      print('error')  U. u: N% s$ [  l3 L5 G& R
      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)  :( T8 r5 v6 c2 l; E" S' V7 x& i* r4 S
name = input('name: '): ]0 y( p3 c. ]; Y  x
pwd = input('pwd: ')9 N1 D# D7 A! t8 s& z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  p# x/ F" t" B# Y
      print('ok'), P9 [8 E% O' x* ~( `( B' [4 r  _4 m$ O
else :
; Q1 \( j% R7 e4 @; C9 \       print('error')/ g( v5 g+ D1 d4 N$ s
      count+=111、写代码; H5 S/ V) W2 N  }2 [3 V. }
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 g8 e& T' {/ D) S if i %2 != 0 :
+ |3 }% n3 ]3 h" q( M* 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) :
+ |7 q: A) D9 F" S  a5 a+ H) d* J. Q if i %2 == 0:
( }; [8 V8 R+ F       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"- k8 e  f+ T8 f- n
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)+ y& o6 W: ~4 T7 Z9 b
for i in name:
% }6 O% }' z, w" K1 X+ B print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain6 S& m/ c! p( M
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
9 K1 {% q0 c! T' X5 Mprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    , _! T9 G9 x! n6 |8 N; L
print(li)
% X. N1 R; x4 H2 C' e: x& b4 q ['alex', 'eric', 'rain', 'seven']
% j3 Y! \  |% m' Ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')9 J/ G: d+ d! ~1 I, Z2 X
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# ?  S- i4 ?: Z, z$ r4 E; O# jprint(li)
) E& o2 l% e/ D% i6 ye. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: u+ N' ]& T* R: K1 m$ @9 R$ ]li.pop(1)8 J! V: h. l, K% Y
print(li) ['alex', 'rain']9 L: B& i0 m$ i% l2 x2 T
指名道姓的删除li = ['alex', 'eric', 'rain']# [* R5 q6 ]0 \9 f. E
li.remove('alex')
* b" g1 G& f9 i( Nprint(li)
6 e; s0 j4 y4 Y: f; a7 i9 y  f3 If. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# t% k' B+ D) G5 P/ |print(li.pop(1))
5 W7 B- K( m: Z( g4 _print(li)% o9 j5 ]5 s3 z

5 j2 w! c/ _+ A. k* h4 G7 Jeric5 x& I6 j( c9 L) s! ~0 b) y
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']1 X5 I' u' \! F6 C3 G* d6 Y
del li[1:]
# T/ E; V6 z6 k4 I1 s0 M1 lprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ L: V' s7 H. I: R3 A8 _' U
li = ['alex', 'eric', 'rain']) ~/ |% L: p+ V8 Y
for k,v in enumerate(li,1):1 v" X& F+ H2 v& w
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ ~( o: @; ^7 _$ Q4 D3 ^
a. 请输出 “Kelly”
. O; s: Y6 K% t+ gli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 ^( B) D1 `& U  ?' s$ bprint(li[2][1][1]), @1 J7 H- Z* x1 l/ o" i; C
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- h  d: l- m. c0 l: Xli[2][2]='ALL'
$ [8 O* c2 \7 O0 nprint(li)
! D# J8 ^" n7 k1 N* b# s24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')2 d; A% a( S$ d& I% P1 X! a& ?
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')7 r3 E  \! m) g, N
print(len(tu))
" I5 n& l0 j* D7 y  Cb. 获取元组的第 2 个元素，并输出& x9 K3 ~8 q5 a' E' Q0 [
print(tu[1])" ?8 d  c: z% p; c& b, l4 M. x$ A
e. 请使用 for、len、range 输出元组的索引
5 m; x! ^" |8 ~6 h1 Z$ Sfor i in range(len(tu)) :( l4 n, g: e$ \- f' R5 M
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
. N; ]. ~0 h+ V$ K% `; ]7 |for k,v in enumerate(tu,10) :& A* z# a7 C* r/ S, g1 ^6 D5 e
print(k,v)
1 m' L( S9 i' r10 alex8 @* H$ H6 J. g% J* K6 @
11 eric2 T8 E: x7 W7 |+ P
12 rain
$ F% s. Q, E/ @/ C- x& j
1 @+ Y' Y" m7 s  {% d) k( D' nfor k in enumerate(tu,10) :0 Y9 }/ D3 I8 H+ d0 l8 h$ m
print(k)
, U0 p3 O+ O* J  P* A(10, 'alex')7 j0 n" [7 N5 _, K/ e) N; Y
(11, 'eric')
* R2 X# V+ g- q4 }) D$ P3 {(12, 'rain')
+ n  A' ]* ?( j) \
6 S& X  p$ @4 u
' d" j3 d7 f1 ~% w$ s0 Y25、有如下变量，请实现要求的功能4 z. Z7 [( y( o) b
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
/ W% G, e8 V2 F( ~
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
/ A( B" L* e& f2 l1 r  p# \" j9 rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
. k: s0 K8 m1 j$ P! H! ?* v9 nres=tu[1][2]['k2'].append('seven')7 j% t$ S1 h" ]: s5 E- @$ X- V# r
$ K7 E9 X3 q5 K0 _
print(tu). G0 [# Q' p; B
26、字典( t! o" o( }/ e: w# D" x
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:$ J+ `$ _0 @6 ?+ A
print(i)b. 请循环输出所有的 value
7 s5 J( e2 _! K1 Y) pfor i in dic:
+ q& c7 K2 Y$ n7 c! E( J/ a print(dic)
/ x, x/ s- g0 i7 g6 Dc. 请循环输出所有的 key 和 valuefor i in dic:
) B: c* \" Q3 s! A! K+ Q% Cprint(i,dic)
) M& R/ w: w) u! y; [9 vd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典; ?' Y5 l9 |, n$ T% n9 j
dic['k4']='v4'
1 h3 D" O# W6 j# z5 A: y8 Tprint(dic)% |  U7 K, U$ j' R' T' C
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典) u! B; F- p9 I( \3 h1 o: ~) |( e/ Z
dic['k1']='alex'
- _9 p" d" A( \# c! _print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典# d, A( h2 o: p! P% Z
dic['k3'].append(44), ]& T1 j# R) T1 ?$ T
print(dic)$ m* q, E0 ^7 k

, ]+ S. i1 ?* B$ }g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典: G- X' Y4 q) D/ b" b; @
dic['k3'].insert(0,44)2 e/ z/ W% g! t9 T. ]% E
print(dic)+ k' b5 N' L* q/ W+ C" r0 v
27、转换
  E% P" r6 ?1 I6 L& B* oa. 将字符串 s = "alex" 转换成列表  s = "alex"
  D! a- m8 b- j' j5 `/ M; c2 ^
& S% \, W9 }1 r2 k' eprint(list(s))b. 将字符串 s = "alex" 转换成元祖5 I, J% D% X& `( \
s = "alex"
: Z" K8 }6 ]* A9 cprint(tuple(s))
' ?8 K) ~5 y  F' {& M1 ?
5 J2 _. _4 L. V. `1 `3 ]" P/ Tb. 将列表 li = ["alex", "seven"] 转换成元组
; z: H0 A4 I2 {* uli = ["alex", "seven"]
' i$ M& K; G+ k; J0 D! E8 Aprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
9 h8 Q0 r# _1 p2 ~& |" K1 utu = ('Alex', "seven")
* P9 [5 z! Z4 N6 Rli=list(tu): O: J2 u- G1 S- {
print(li)
4 Z0 l; h8 Y7 u/ H2 X1 H! `# [& N# }& ?+ U: _) |
( V) W0 t# ~6 x- w7 h9 t
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# l3 i' P& z+ H) I, d& }) b- k8 [0 o$ j; L
dic={}3 Z: j' f% f" S; ]
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
( _: }4 H4 U* ?3 A( L0 \& h) k! E dic[k]=v
, X" P' y( p& R print(dic)27、转码n = "老男孩"/ g3 a* J. G: u0 K
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩", e0 f' E2 e8 q  w( ?& ?6 U
a=n.encode('utf-8')
! O. P. e: O: _print(a)9 F( w& U& ?2 t+ M
b=a.decode('utf-8')( s- T. q$ M1 }2 V5 _* _' T
print(b)
# B2 x9 N& u3 ^! Y) Qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')4 D1 [8 g8 |( T6 q
print(a)
; C3 ~) c" M9 @7 C/ F1 Xb=a.decode('gbk')1 B* v0 N4 B5 q" m* h  T+ Z7 a
print(b)28、求 1-100 内的所有数的和( Z! T. X+ N$ Z2 Y
count=1
9 d2 m) P" e6 f6 |sum=0
( t/ J2 U( r- _for i in range(100) :
; I$ J0 U7 f0 h5 c" F0 U  J: {/ y sum=sum+count
" ~1 N5 t6 Z3 h count+=1
: ]! N0 j3 q& oprint(sum)
0 @- s% b) |. r5 w$ N# u$ ]. M8 y" _3 b6 @1 j- T$ E$ X7 }- s
count=18 ^: O% l& z, l3 j
sum=0
1 ~5 }1 |$ q$ I0 H4 c3 Fwhile count<=100 :4 g. U  {6 P* x; Y( l7 O5 f# m
sum+=count7 U* U* u: s  [# U" o! Q
count+=1
9 ~: N4 x5 s5 y1 Q6 x# @print(sum)29、元素分类
( H! ?8 ~' V  ]( d1 y有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，0 l) w3 L) Q) E
将小于 66 的值保存至第二个 key 的值中。
. [* W  V; Q" y( v即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
+ e  X( ^7 n8 X2 m9 x2 |li=[11,22,33,44,55,66,77,88,99,90]
* h' F6 z0 {" X7 D4 X& Adic1={
* ]4 {# g3 z7 `/ @6 r7 n) B 'max':[],9 g: Z8 z$ C. ^+ Y# V: Z
'min':[]
. B/ ~1 |% h+ b6 A$ y' @}
4 N) _5 c: L/ t, efor i in li :
! i% B. [( E' j2 F/ k; ]$ I% D if i <66 :3 C  b' [& a: x5 Y( ?
      dic1['min'].append(i)
/ Z. ]/ z7 c1 x2 R else:
7 f" J; E* e; O! N% \% X       dic1['max'].append(i)6 `4 D* g5 u+ z
print(dic1)
# Z1 K9 m6 |4 b6 H, {1 [- X1 A5 ?
4 l7 w& n$ X; Z1 n3 a---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}: w4 r; g4 `2 L6 z8 n

Python基础知识汇总

主题推荐