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、写代码0 U& U; F# ?- b8 _* t" b8 \
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) :  S5 c  g! Y( s7 Q
name = input('name:').strip()
8 u3 U2 g. O$ h! D pwd = input('pwd：').strip()
. c3 s: Y4 K8 S/ t
, J, l! ^% s. n5 G0 e if name=='seven' and pwd=='123' :
# W$ r! z- T; P' }1 `       print('ok')
) s0 g+ h1 Y" w+ K& o. V( D else:
; \' n1 u2 z8 q1 t2 |       print('error')) r" l8 k( P4 Q: c3 L% `
      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)  :
8 x4 P3 N5 E: ?% R- q name = input('name: ')
/ |0 R- q$ P5 t# n0 g4 k% h5 w3 n0 P pwd = input('pwd: '). L( ?& _% Y$ n
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':! \3 x; h4 U: m9 r9 I
      print('ok')
) B0 N5 l3 M$ V, U! Y* J9 l else :
/ ~& j; X5 p: C0 ]6 U* O" V       print('error')0 k: r: J% B/ G5 X$ p3 ^' I8 U/ Q
      count+=111、写代码
6 \' e7 z8 L! Y1 D. La. 使用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) :
5 c( K/ O9 n9 W6 \" a5 V- ] if i %2 != 0 :2 g2 r$ B' b) r0 ~; ^
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :: Z" T6 ^0 K, u# h- \2 p$ ~9 z
if i %2 == 0:  M" P5 S; l9 W# ]( v6 R/ 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"
) s2 n8 m4 F% q! Ma. 移除 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 T% Z, }% t# F* M/ X
for i in name:
5 w0 n! J1 p2 T  F1 m print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
% n8 W7 F! ?; l. P22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
0 l  \$ P( v5 h8 Qprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 y" k1 v# f: F# }# ^* D8 Vprint(li)5 P8 C6 `. r( B1 U
['alex', 'eric', 'rain', 'seven']) W1 N- L- `) u+ P& R' W7 R& W" b
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( v/ O8 m1 A/ O+ a6 x
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% C2 j0 \; b1 h0 |3 }: Pprint(li)7 ^- p; m9 H3 k9 t! B3 @& H
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']6 X1 J( y) E8 \1 r" X# X  I
li.pop(1); |' u! L$ o- [6 M3 {
print(li) ['alex', 'rain']1 [2 o' e8 P" |+ g! a
指名道姓的删除li = ['alex', 'eric', 'rain']
; K# T3 `; P% L6 y& Q$ K! x- Ili.remove('alex')
2 ]  Z# R: R! `, ?8 E' `0 vprint(li)$ Q( v( d% o& M5 h( _
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
; W6 P7 Z9 I9 m% v- Rprint(li.pop(1))  K# Y9 y# q# Z+ Y7 p4 D, l
print(li)& U; E9 s6 {" f: `6 ], p

. ]7 T% `* z3 _1 i" A/ Oeric
6 Y1 i4 f# h1 A' S1 [' {" n" L, y4 Z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']: y$ [; V# y) K) I- [* e4 X" {
del li[1:]
  \2 I, G: K/ D' iprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
  N$ c$ i0 n. J' i8 d* oli = ['alex', 'eric', 'rain']
% A1 {6 p8 y  Z3 nfor k,v in enumerate(li,1):4 Q: y! ]; X( R& y! n& \4 R/ {; E
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  ~0 z% Z; i: _' H6 d& r0 o' O
a. 请输出 “Kelly”" x; F  V: D4 R! ?* ~
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 T& c* [6 }2 `3 Pprint(li[2][1][1])0 B0 f4 X9 \! u: s. R8 S4 J0 A! r' P
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”' H9 D. C* s* ?3 O5 U& g3 _
li[2][2]='ALL'
8 d# q% D0 e- J* [/ ?6 oprint(li)
2 ?' p, e& @* E7 ^7 N7 A7 K24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 a" G. L3 m; w- w/ j: d) T6 ya. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: G7 H& e- W* r4 ^4 C/ N* Qprint(len(tu))
2 o& ^* L' a! ]b. 获取元组的第 2 个元素，并输出
. }: m" n- q1 s( P/ N$ Zprint(tu[1])" C  s' ]2 W1 A, @
e. 请使用 for、len、range 输出元组的索引
% f  w# G5 z6 w- bfor i in range(len(tu)) :
; W8 H: H2 P; u- J" n9 _' l% U print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)' e' @* Q( V! d  Z  p& W
for k,v in enumerate(tu,10) :$ Q* @: k6 @% [2 u) T6 N
print(k,v)) Y; m, U7 |9 Z' y5 v
10 alex
  ?; q' s# ?& v2 k/ w6 q11 eric5 H* k: q/ g8 x9 k' Y
12 rain! `3 R; V$ N% c1 ?4 c$ m3 w
- V1 F% s( U" o# \9 \
for k in enumerate(tu,10) :
7 Z# f5 p# c3 R/ |! E1 q print(k)
: a& S# m2 Q/ e$ R6 V(10, 'alex'); s( [* m$ [0 r# W( q1 ^
(11, 'eric'); a3 F, Q. ]( Z. e2 C" D6 `2 N
(12, 'rain')3 g8 Q" S% A8 a5 _

/ q8 w( z. G+ e. V/ p3 t
! K: d9 V' H( B; v+ U5 _25、有如下变量，请实现要求的功能
2 G, [' Z1 `! l+ ~9 Ctu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

3 ?( g8 f1 |7 K) Od. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
" J$ _( I; F5 p/ Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! n4 c5 y. `+ t6 p8 ~- nres=tu[1][2]['k2'].append('seven')8 @  U/ {$ T* n( _. i

, {( y5 r) _* \/ G/ w6 C4 Q( uprint(tu)) I& G" f! x6 _
26、字典
3 K$ F* I, V8 J. D, a4 [0 Vdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:8 B  \  _( D+ X2 p" d5 m, a
print(i)b. 请循环输出所有的 value
9 s: k( B/ {6 ~2 I! [/ f% Dfor i in dic:4 g, x3 ?  Q  [2 s
print(dic)
- e- W/ n- ]( m8 I* p: E" `; v4 X) }0 lc. 请循环输出所有的 key 和 valuefor i in dic:& O- V( E! o8 U* \% T
print(i,dic)
$ t" P9 x. V. Q* y5 ?+ u) Kd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典8 u- F& a* t. V8 Q
dic['k4']='v4'
1 F& c8 o+ _" s& jprint(dic)* n, V* [/ Q# @0 |: H! [
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 K  J( H! q6 f6 t
dic['k1']='alex'
+ p" e+ v+ B8 s2 t  l! Hprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
9 |% {2 I/ A' t8 F8 Ydic['k3'].append(44)1 l1 Z  ^' E; @
print(dic): l; y: B# ~: k0 Z. v6 x
, m( x. u" S2 v# m+ [! a
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
, `4 W5 i0 c, _$ Z& o% adic['k3'].insert(0,44): Q5 ^( ~, B  B; r" ~- v
print(dic); F" K7 h! ~. r) S  K
27、转换
2 }3 c/ c# B* {" O3 b- Pa. 将字符串 s = "alex" 转换成列表  s = "alex"
! l3 ^2 L% o2 E% l! r4 q. m* a  R; r5 \% r/ f2 c1 \% m7 f
print(list(s))b. 将字符串 s = "alex" 转换成元祖9 d. H4 _/ u4 [- N
s = "alex"; g: C# X2 K& Y6 T$ A, L, j6 _
print(tuple(s))2 {' o7 b5 c# l+ m

  s! j6 X. c5 fb. 将列表 li = ["alex", "seven"] 转换成元组
6 {- N5 ^) v8 [7 Eli = ["alex", "seven"]4 a& E2 J8 E8 F: V" q
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
: N' c. N( l' L# i4 }tu = ('Alex', "seven"); `* ^$ K1 h# j) k( G$ N/ J5 M% X
li=list(tu)* R, k/ Y, Z# t( _0 ^
print(li)
8 u8 h/ r, d: x- k/ O, b8 k+ w4 X7 v( P5 p

  A8 }3 e0 C0 O# r" pd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
1 u- D9 D) T) a4 }* Y3 |" d9 V# a- A1 _4 i" p) z* D7 _, Q
dic={}3 G9 u* n+ [0 Z3 X; h: Q
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面& f! E' l# d" P* Y  G% D
dic[k]=v
+ ?( E8 F- p0 C print(dic)27、转码n = "老男孩") ^+ T, a" V7 z
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"% V$ \/ k1 D5 q' a  B$ _
a=n.encode('utf-8') 0 U3 E; s+ i& H: k: |, c: s
print(a)( Z# x: O. W- T2 P3 E2 f/ {
b=a.decode('utf-8')
7 \0 I# @# w+ Wprint(b)8 H8 G& N# \; M2 l9 p3 u4 t8 y
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
. @3 }) w* C- g) W+ j# w5 s$ [print(a). A* O5 t; w; F
b=a.decode('gbk')
/ s. g" V/ F$ E# Q+ O4 N" ?) E4 w: vprint(b)28、求 1-100 内的所有数的和
0 v4 E! }  _  R, m! r* T( pcount=1
- r' G4 G" u. ]! }0 g- F  _" N' {9 Osum=06 o3 F7 C4 e2 p+ }) Y; T0 i
for i in range(100) :
! h  R  h2 ?, j8 h sum=sum+count5 M2 ]8 O: m4 X
count+=1
  u3 }* X6 [4 e7 y" Jprint(sum)
3 f' \% d, h" e2 D4 ^  C
( X' Y! a3 S6 qcount=1
! ]( @. J7 P4 }1 |sum=08 U9 k) s) U6 b: L
while count<=100 :$ m2 p- C$ e8 Y; d
sum+=count
6 {4 C6 G2 B: l8 c count+=1
  H2 O# _9 Z$ s4 U8 z" yprint(sum)29、元素分类" [$ R, T( D3 `8 X" i* {" J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
( @- ]1 m; q& L将小于 66 的值保存至第二个 key 的值中。# P2 E% I$ t$ \2 @6 P+ _
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
( E2 Y  [7 j8 c6 `, G  H" Dli=[11,22,33,44,55,66,77,88,99,90]# ^' q/ a9 L$ J3 G& H; i) h6 {, [
dic1={
  ^# y9 x2 U% l- O3 {$ U 'max':[],
1 I* H9 j3 Y% k9 r0 l" {9 n6 } 'min':[]
, Z  c. _' I7 x. c% J1 j! c/ A}
& ~1 s* e& Q0 x& ~' F" ffor i in li :6 \) e9 a8 c2 v( a7 q7 c9 J$ `
if i <66 :1 j6 N/ S, H; c* O
      dic1['min'].append(i)' J$ |0 c4 U) l% [9 Z% u8 D
else:
- E. _) F, V3 l+ ?0 C4 t3 H       dic1['max'].append(i)" T' q7 c  U' A: k7 D
print(dic1)
2 T* n) z) r. i5 N( z' B3 t3 ~
3 w7 ~9 Y3 N- _# S# w- y% h, q---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}$ w' g- u+ C$ u) T# I

Python基础知识汇总

主题推荐