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、写代码
: o7 |+ J$ m: E& ~4 s* X' Ea.实现用户输入用户名和密码，当用户名为 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) :) d- i2 D* ?+ u6 Z6 X, V
name = input('name:').strip()( o6 `  ]( p* M4 v+ T3 p9 _
pwd = input('pwd：').strip()
% G5 z5 h% N" i6 S7 s5 H' M/ }
) m! I0 I( |- o if name=='seven' and pwd=='123' :
8 u# C4 X$ H1 M       print('ok')7 W, r& i+ Z& @8 H* ^4 C% R3 H
else:' D4 Q3 Q8 s$ X; O
      print('error'); M* \4 }3 Y5 Q3 d; v7 ^8 D& v. \
      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)  :
6 k7 A/ v/ O2 l+ F name = input('name: '), Z4 S6 u0 }2 ^0 l' j+ V0 `
pwd = input('pwd: ')& m/ R' `- r# }
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':" O/ s) R# `' n0 E6 ^' l. f
      print('ok')4 D0 {& ^) w$ k- m$ c
else :  s( V) t( P5 B0 q& i1 m3 }2 c' H
      print('error')
: n" P+ v, v$ C0 b8 n, w2 d       count+=111、写代码9 l0 k5 e' n# n/ p) x$ I8 j+ T
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) :) R8 o( Q& R& l. G
if i %2 != 0 :& C" B# Z3 h% s4 T' F" V0 x7 `
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
; U9 ~7 ^. G; d# _; h% E if i %2 == 0:, F, d( d6 X+ |# n! p' M
      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"% X1 L2 [0 B: Y7 f" a
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)
; W7 J( N) h. W* t# hfor i in name:& a+ [2 H; e, O4 E) U( F) i
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain* g* N% m: F' r9 [
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 x: ?# r% u" Q  [print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
& W8 @! V- x& _  _, o6 F* N5 W2 U# ~print(li)
' ^8 K1 [: [. J7 \: D. |  Q ['alex', 'eric', 'rain', 'seven']% y: S8 N, B( r! H" I6 K7 E
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')8 z9 ?; R8 j1 X
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'); h+ m4 n% V+ T8 T" b& @
print(li)+ o' w8 h" ]' C9 j0 n
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']& g, Z# y' j- U
li.pop(1)  A( N# H. J! v
print(li) ['alex', 'rain']
; i, l/ n# v, X; }; h指名道姓的删除li = ['alex', 'eric', 'rain']8 {( L$ p! }- E& h
li.remove('alex')
# k, c! ?3 D, f( I; P0 ]) k5 V' iprint(li)1 y1 p8 \+ M" V7 E( A/ l( @
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
$ ^% `6 G# g& o: i" T* n7 K( g" Rprint(li.pop(1))& t& w% }3 K  b. G  t# v% u+ x
print(li)% j" |) t4 H+ i# o* c# W: H
/ P3 ^$ R& C- Z' Z4 @
eric5 T& w$ W) h0 Y) m$ ^2 Y8 h5 F
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']8 G- ]' I4 J( t2 [' T  j" n5 g( U
del li[1:]
. A1 G$ G; ]) H2 @' p1 L  [1 Kprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
4 v. y! I; k, i3 b) X' ili = ['alex', 'eric', 'rain']
1 i0 ?9 [6 }  c! {, ^0 e5 }for k,v in enumerate(li,1):, u' q- Y* r. C+ F6 {/ N
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]+ S1 q0 ^4 x2 |+ k" O; o/ i; N3 l$ ]
a. 请输出 “Kelly”
% Z# L4 j- I( Nli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]: @- j9 G/ C: N6 t& C+ F
print(li[2][1][1])
! |+ s# T4 a" Kb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: [  a. I( P, P4 u3 T) hli[2][2]='ALL'* Y7 B( `$ \7 [' W! q
print(li)
8 e% D% N$ j8 F, L) d8 C, M24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ ~4 t& b; X, P: m9 M7 Ta. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
  u; s1 q! I+ [9 M9 m4 G" ^9 ?print(len(tu))
  d) v8 m- W5 t9 z" N6 R/ y0 ?b. 获取元组的第 2 个元素，并输出$ }; N7 O2 a6 f; L+ U0 I+ M" T
print(tu[1])0 J% y# ?2 A9 [- Z
e. 请使用 for、len、range 输出元组的索引
4 ~7 N/ E' d7 P" `for i in range(len(tu)) :" g, M, a  G! X; W0 r% x* H* ~* B
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)& J0 y: M  h3 s5 r
for k,v in enumerate(tu,10) :0 h- M( i! _  C- d" q; Q
print(k,v). ]9 f' m: m+ x. F( [
10 alex1 ^: S; _' ^2 a) d/ o- m& {
11 eric
/ S3 @7 ]; j2 C, d7 z4 ?& D* s1 W12 rain
6 h' S# s8 u# n+ x* i: M# h$ ]& X8 N" P& h. L
for k in enumerate(tu,10) :& w8 r: x, X) H" O+ P0 l& O
print(k)
0 }, ~( e% f! `/ K(10, 'alex')0 j$ m6 Y9 m6 o( O
(11, 'eric'), V/ P6 S7 C" d$ N1 _
(12, 'rain')
7 ^4 i) k* N. N, A4 {- k
& y; k2 d( A2 H& p0 m1 m3 q
+ E- f' n& p: Y' H25、有如下变量，请实现要求的功能
) w" p; |( Q3 [) w4 q1 qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

$ V! w8 a% P, O) a8 l8 Qd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
. _) |) K0 b5 f, z# K6 ]tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
2 {+ H% e1 y  I& H7 ]9 pres=tu[1][2]['k2'].append('seven')
- m% [2 o8 q! p- [
- r  a% o' N& _  R, {print(tu)( {) G! B9 K  P! f- ]& l
26、字典
9 }# M0 x" b  J4 n8 Kdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:5 k" L- M6 M* {% h! u' R/ A( T5 P
print(i)b. 请循环输出所有的 value
  v+ N% B3 M2 P- h( jfor i in dic:+ j( J  D( C" a; _) E
print(dic)3 N9 C- x- @* d
c. 请循环输出所有的 key 和 valuefor i in dic:7 ]" u8 M/ i5 f% J" A- {
print(i,dic)( H: M1 R0 q- j
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典4 E; a% x5 l  m0 e5 h( \
dic['k4']='v4'
# v4 A# W" N* u" [, \8 Jprint(dic)
/ N, I7 W' ~+ q( K5 se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典8 k: r/ O7 _' Z% J; I2 L) R
dic['k1']='alex'
& T5 O/ d% N' d5 o' o) o, jprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典3 g' w8 H  x2 H  g( {+ G6 P
dic['k3'].append(44)* C, R: g% n+ y
print(dic)! R* R8 `! F- |  Y

* X5 j" K1 W* B, x5 C6 m7 wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
: Q. j% o7 p$ I6 Sdic['k3'].insert(0,44)6 j" r4 ]! B5 R% B# D# u% Q, A
print(dic)
  u" d$ T' X% P$ ?27、转换9 c$ s* H/ F7 K/ \8 Z$ W
a. 将字符串 s = "alex" 转换成列表  s = "alex"
6 F% ?( M* C' b# P! D
5 Q5 H: [/ @( k& r+ C. ]& Yprint(list(s))b. 将字符串 s = "alex" 转换成元祖
' T9 p4 ?5 M) j1 zs = "alex"
* B5 Q7 L% H; o9 d) F7 w6 Bprint(tuple(s)). L& I) z6 e7 W9 l$ I( P2 O
* ?) ^8 T; H2 L
b. 将列表 li = ["alex", "seven"] 转换成元组* |  E# c3 N6 O) B* T
li = ["alex", "seven"]( {: Y" f+ W6 s1 f; ^  j% Z8 j, N
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表3 J; F: `8 `7 n' A# K
tu = ('Alex', "seven")1 e' C4 V; k; j  [% W/ X- G/ _! O# X
li=list(tu)) p' D0 V! z; o; M- u6 F+ r* O# g
print(li)
# O6 R& D1 S1 w8 {6 f* ~# `& i: z5 l% {! ^

0 k. @& H2 ^; R/ C+ _- M8 O( {' {d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增4 m5 \$ p8 Y& b5 ?( H

8 r9 o5 E0 ~+ U# ydic={}- n* e/ r5 b& O2 Y- C6 v
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面" p3 c8 S1 H  L5 R6 ~9 A
dic[k]=v
. Y' J; J3 W2 a  A7 e0 {2 n print(dic)27、转码n = "老男孩"
- }% a9 V/ O) Qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩". F. o3 B$ ~2 W( j+ t' @/ a& `
a=n.encode('utf-8') : I9 _/ h- Q) D. ]* y
print(a)1 B" W+ t% L4 C/ F
b=a.decode('utf-8')' d& h4 M0 W  E/ G$ z$ K& S1 ~+ X7 `
print(b), s' R3 h, G0 P) n/ o# i  y) \9 b0 T
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')& [' z2 h4 c7 P' Y
print(a)* ~0 ]# @0 e: Y2 _0 F7 U) [
b=a.decode('gbk'). Z2 H0 z4 t5 G0 @1 r, b
print(b)28、求 1-100 内的所有数的和! p3 b6 O& D9 ?/ B
count=11 l4 L: S) k+ O5 L. O8 z
sum=0
/ k/ Z: S1 I) N9 H* F" Ifor i in range(100) :
. j& C4 B' l8 ^  `9 U sum=sum+count
. a% t8 q0 e$ R3 c- A7 D8 w count+=1: |/ U0 Z% ?1 n6 v
print(sum)( c' X/ {7 J8 t# F, W. w

* F6 S  r% s6 w; Pcount=1
8 q( d- s( k, y4 v, `7 Z# c/ a$ @sum=09 ~8 ?: \  n- V+ n$ H' n
while count<=100 :
9 k' T6 L, u$ `3 x0 Z sum+=count
/ V1 _% i6 t+ O# H6 n9 k7 b3 a count+=1% R6 ^5 `1 }, `) P
print(sum)29、元素分类
5 C( J4 w- n0 \! y1 t+ I7 r/ A有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，" o. ^3 m" s+ m/ y4 ^: r: M
将小于 66 的值保存至第二个 key 的值中。
9 N. x$ H& L" A! K* A' ~$ @7 G3 L即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}- a9 \) w# c' K- t
li=[11,22,33,44,55,66,77,88,99,90]
: A, p$ Z+ p5 p' s* qdic1={
3 z9 j' |$ W- _6 z! R 'max':[],6 A" e% r  m. z) i+ r4 P
'min':[]7 Y4 a) w0 C8 a( ?4 A
}
' G1 K+ u3 d& Z. G, vfor i in li :
- N4 _- F, \7 \  T$ }9 e8 ^/ G& E if i <66 :1 p4 ^) K  z6 \3 N
      dic1['min'].append(i)4 Y- ?0 u, @$ k2 p% e- b' }% L
else:% {2 _* F6 E/ n8 X
      dic1['max'].append(i): |* y8 l. o  C2 v1 x: |$ z
print(dic1)' u$ c2 w7 N8 w
" c6 d" K, {8 P  d1 X$ U: A
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}/ B- m' `- O$ |% x4 ]: {' K& \

Python基础知识汇总

主题推荐