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、写代码6 f6 y' }0 T$ P% v+ 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) :( y+ S( \+ c' q, I2 a
name = input('name:').strip()
8 ?0 m# c3 {2 ~. r8 f; F8 k pwd = input('pwd：').strip(). B' R( u( A, d- N4 o8 H/ V

& t* |& |+ Y+ N- |0 p! Q2 K if name=='seven' and pwd=='123' :
. n. V/ e. A5 \) s, a- e  T       print('ok')
3 f* ]' c* B+ N2 o& o. y; g else:
+ P; q$ \; B; b       print('error')
% {. y& c0 _- C4 k       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)  :. z6 s7 Z/ Z5 O; s* \, d
name = input('name: ')6 A4 e' r' R" Z+ W1 N
pwd = input('pwd: ')" u* u9 L8 g6 z3 X
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
& K9 V% L) e0 H0 s% T' g4 S4 W& W- z7 {       print('ok')
6 D5 K- E4 k. [ else :
( S- J+ k" ~9 U       print('error')
! W1 D* c& h: l2 E# B2 x2 d       count+=111、写代码
2 Z& P* ?( }, C/ za. 使用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) :
9 P8 o$ ?, Y( A+ U* O+ e+ n2 P9 @& [ if i %2 != 0 :
* |3 ?- _/ @' d5 R; J  Q; 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) :; n; |1 u  `4 s- x6 s
if i %2 == 0:: W! p/ V1 j" D( J" S/ H0 S3 A
      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"
) a/ O4 S7 V; v; j8 j- z) H: ua. 移除 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)9 ?2 I2 V; i6 _" {, N
for i in name:" M- g/ x3 H/ [) }
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain$ C- @" D  b- l+ T  E4 w
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']0 i% C  D) U4 c- X
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
7 z) ~: h- q+ ?  q+ tprint(li)
9 S: a& a( r5 @/ V' E ['alex', 'eric', 'rain', 'seven']2 Y4 Z" C& ?. u2 `* [7 E
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
1 A8 I7 P# I* s. _: gprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')  k7 e7 U% F) i* q+ n$ J9 h: k5 w! }
print(li)
+ K- E& Y1 C" \+ e% ae. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
0 h/ c& P* v2 {; jli.pop(1)) j! V2 C: X$ I9 N6 w/ `, N/ t8 b) o
print(li) ['alex', 'rain']8 t6 b! D+ t# S+ {+ J
指名道姓的删除li = ['alex', 'eric', 'rain']
. j! T0 r: ^: ~, `9 _$ wli.remove('alex')
% p0 o& e; g6 ]% }print(li)
6 P9 k, P$ b" of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
2 \: z2 E0 _, u% a' |; ?6 jprint(li.pop(1))! W1 @" b4 w  n
print(li)6 x1 j5 y, f) E
( a+ D& [  x2 l: b5 u" k
eric2 Y! H+ ^/ q& [+ r
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
  p  k( M$ b$ Q+ R0 mdel li[1:]$ i4 L" r! X% V/ U/ v7 p
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)) ^* ]* E$ G7 y) r8 {( X
li = ['alex', 'eric', 'rain']/ Y) {8 A# c- e% K9 l9 M& v
for k,v in enumerate(li,1):. g+ V9 @& z9 `" Y
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]( E, v( H. j6 r2 ^3 `# V. f5 f4 r; ?
a. 请输出 “Kelly”
+ d% v! c2 U$ n* Tli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
; d2 x9 C/ O2 qprint(li[2][1][1])# N8 K- h4 V/ f% Y, j$ _8 B3 A& ?
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 y  J' g  \" V8 \4 [
li[2][2]='ALL'
1 p- R5 Q* B5 A' c4 Xprint(li)
% o; |. F2 [* s24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
& ~+ w% @# M+ Y, ea. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
9 c& `( t& j* R1 Kprint(len(tu))
7 o, v5 o3 k  O, d9 db. 获取元组的第 2 个元素，并输出
7 j) r9 e9 D$ j  ~print(tu[1])
7 g6 H* X6 e7 x( \; Qe. 请使用 for、len、range 输出元组的索引
) P* I* f3 T* Q% _1 ?# Cfor i in range(len(tu)) :
. H# V1 S  g/ }7 v* K4 Y- N* y8 ] print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)$ E) U& B% P) Y% y( W
for k,v in enumerate(tu,10) :
" x+ v4 S" Q4 F& F% u print(k,v)
; z' p7 x. ?6 z; M' J! K+ {10 alex: P4 ~& h/ h2 I' Q3 k' j: n* T" f
11 eric$ r; j. n! z4 P4 U8 k
12 rain) t! c( ^2 O5 T" k% ?. Z

) a7 ]( e% k8 @; `( f. Dfor k in enumerate(tu,10) :
8 |8 k7 _0 p9 e; l- p- M print(k)
# E$ A' G1 ~- J1 J# `3 _2 [(10, 'alex')4 s8 F4 j2 x& N
(11, 'eric')) s/ ^* M  v3 A4 ]
(12, 'rain')
' p9 u. }5 D- N2 C; D( G0 P+ h& }1 ]% Z0 u  p( o

* P1 z- M( u; h& P25、有如下变量，请实现要求的功能
$ R" y/ D5 m( O4 N$ F: etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

/ m& I4 i; @( `/ O# sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以# I+ R5 z5 J& \( {" }' Q
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
9 @3 `/ W) \9 F0 A+ Ures=tu[1][2]['k2'].append('seven')
( l& I% V) M$ Y$ _" _: S8 d" J& d- m9 `$ n( X+ V
print(tu)
: n, Y, F3 ?, e/ \26、字典, W0 p/ k5 M. Y6 g
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:. k/ n% _% e& j7 Q" v
print(i)b. 请循环输出所有的 value9 I+ y7 R/ c$ i( c- q% c
for i in dic:& h! h+ z( E0 S. \/ J& J" m4 L
print(dic)
8 f4 {4 @8 l. y' pc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
! ^) C" D+ Z- H' {$ b% wd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
) t9 ]. ^6 }% `2 vdic['k4']='v4'
  v+ U' u6 M+ Y3 l2 tprint(dic)
6 D8 K9 n1 h; \e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典% ]7 @. W) O" f3 S. b
dic['k1']='alex'
0 u1 i' D$ L' W' nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
5 k: [+ H9 l. `print(dic)2 W8 e$ U/ O( |3 U/ a
+ @8 y2 T# r6 }) r# N& x
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- N8 ^6 T; V/ A+ w) f3 W, Xdic['k3'].insert(0,44)
% d3 Z6 E" K" M1 {* S5 C3 U! bprint(dic)
6 f' D- W+ J, z1 o27、转换/ L' `1 T. I6 D* u# t3 G) M
a. 将字符串 s = "alex" 转换成列表  s = "alex"" O; t! [4 _' m2 U) c& M

4 O% [" s) d6 e4 y4 C8 \8 pprint(list(s))b. 将字符串 s = "alex" 转换成元祖( x8 G" ~, `( B* y' t' o2 k
s = "alex"
- T/ d, j, X4 u) dprint(tuple(s))
( L2 c7 M, x1 T+ G2 k' e4 S1 Z+ Y
* C4 p; l) H, S* p0 W2 Fb. 将列表 li = ["alex", "seven"] 转换成元组0 X, q' q: |' ?$ }
li = ["alex", "seven"]
- ~) a, a8 \" F' G' \print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表9 M# ?1 _6 `" {7 m- z
tu = ('Alex', "seven")
; \6 R$ h" R0 ?9 xli=list(tu)7 ~5 P$ H: I3 |) e0 x4 h
print(li)
9 c4 ]+ q$ `$ v1 G3 l" Z: ~% E
$ b  j0 u! K) F
) A5 _0 O8 H: m, A% Ud. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增. n5 R+ c8 }. V
: F/ g8 ^1 \8 X' y3 ^" H
dic={}
8 R4 ~5 S/ G0 X) I% Gfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面  D3 u: n4 U% l8 B7 o& [" z+ X
dic[k]=v* T2 V4 ]$ `3 L& C- ~9 r
print(dic)27、转码n = "老男孩"2 R, Z3 n- z4 R: g2 T5 o
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 k7 X1 g9 }! wa=n.encode('utf-8') ; X3 C2 k+ M* c, w, H5 f' u- n
print(a)
4 w2 ?, }  j  I0 Lb=a.decode('utf-8')
; L) j# c1 j* C- L" lprint(b)
* O8 O. I; b& w! T- a+ Kb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
. U* L: M. i( h8 `. o' e/ q/ K1 gprint(a)6 f) \5 R5 ^- C3 n1 A, T
b=a.decode('gbk')8 O: L/ t+ W/ ^
print(b)28、求 1-100 内的所有数的和+ V+ P0 C4 b- {* u2 u# g
count=1: T2 p0 A0 L. `+ S; [% `
sum=08 ~7 {# T4 Z3 g7 [0 o6 T
for i in range(100) :. i& ?# a: _4 ?: T  }  J
sum=sum+count) `7 i  C6 Q5 K- W# b
count+=1; l0 `8 F* X4 g" T$ b( w; {& Y
print(sum)7 e* b3 }- T9 ]
% j- k9 g" p. u( ^3 ]$ i8 x
count=1
3 ^* Y, t. ?9 ]sum=09 d+ Q) Y- S8 H, r. y+ S- b3 h
while count<=100 :
9 ]6 @& K6 W" U/ `. [0 W sum+=count* @4 Q4 X5 Y! u2 Z1 f" h
count+=18 @% n3 [; c9 B3 u
print(sum)29、元素分类
9 m$ N) K0 s) y! I有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
4 d+ F; U' P! L/ d将小于 66 的值保存至第二个 key 的值中。/ _& v7 z; ]6 d, H! c0 s
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}. R, o1 G3 @7 w
li=[11,22,33,44,55,66,77,88,99,90]
: q" n8 A6 F6 g% @* udic1={" a+ B: d7 N/ x' w( @
'max':[],
; X) c8 V0 Q4 J1 _" K& P! L, ^& _( m 'min':[]- w# Y2 f$ D' y/ x) I/ }
}
: [. b+ Q7 ?; W0 ]5 K6 C$ Ofor i in li :" S4 z  ~4 ]9 l9 u3 a' R
if i <66 :" N0 `* J$ u+ F* N0 Z4 ~( W% q
      dic1['min'].append(i)7 B/ X/ U* m5 K0 ]; {
else:: ~0 X) R- ~3 H! U. B+ |1 c
      dic1['max'].append(i)+ f) ^7 F. z2 C  Q" t$ W$ u
print(dic1)+ [3 q( E, L2 E$ ~

; |' T, V  v1 m! K---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) V# B$ Z5 M' b1 V$ ^+ B+ O

Python基础知识汇总

主题推荐