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、写代码
- |, x8 ]8 C; r/ ]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) :
! X+ d+ x7 J" T) h' c8 }9 i name = input('name:').strip()# Q) f2 D8 L# m  g1 A" ?+ s
pwd = input('pwd：').strip()& m2 W5 P4 |# j7 ], ]5 A8 ^

- l3 r& z; g! ?3 j if name=='seven' and pwd=='123' :  W" O9 q* ]7 {# J; n8 A+ Y
      print('ok')0 ^! d9 z. e/ p+ H- B3 A2 l
else:' P6 P) o/ Y5 w% o& s& A
      print('error')  B$ m3 k; P( 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)  :
0 w4 ]( o8 g, [) Q& v name = input('name: ')5 j- Q0 D4 l  p! `! M/ b2 F1 B7 \
pwd = input('pwd: ')
, M! s  s* C/ f4 S7 ]3 S3 O if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
) ?. z$ R" x; {" g; P) v       print('ok')
& w7 G( [8 B; A8 @  Q1 v8 w  | else :$ @- d* E/ Z3 g1 ~
      print('error')5 Y8 {# V8 R+ W% z5 n' R
      count+=111、写代码* z9 X/ ?. w+ [) z* [
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) :0 Y6 J' l. m" N
if i %2 != 0 :
/ ~  v0 f% k  P) W" W6 t" k       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :2 |# y! K# o# p5 |8 D3 B4 y
if i %2 == 0:
: [9 z7 j  `9 I2 G* f, k2 g       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"
% ~+ s& Q1 e: `& d; Ka. 移除 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)- X# s# P+ U. _& s
for i in name:  K( D$ }  P+ ?$ ^+ @
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain. g& r2 l4 x* E! P: y* k* Y2 Y
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
: I9 D; p# L5 m  l# t% qprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
* I! z8 U3 V9 u! Q: H- iprint(li)
% I  T4 L, @& D6 y0 T, r& K2 } ['alex', 'eric', 'rain', 'seven']4 C1 U% A6 q& p' Z# j, Z. x# m
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 L, `- m8 Y0 C0 Y9 i- w/ c8 Jprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')& U7 O5 g0 O( F  n
print(li)
5 e/ M% @8 F% x) p# A- ?3 }+ }* de. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
. I0 p$ m8 ~' _3 u0 [! x; |/ \% Sli.pop(1)- L9 M" b. d& a
print(li) ['alex', 'rain']$ Z# b1 s5 s) L  C( O0 ^+ }4 j
指名道姓的删除li = ['alex', 'eric', 'rain']& P; {5 a! U& f7 g
li.remove('alex')) p! k% u# t5 p3 N* \3 W! i5 q
print(li)
6 a# o) l+ g9 ^  j( R, A. Ff. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
( g5 o3 @3 F) k$ G# Y2 s* V2 R! Tprint(li.pop(1))+ g' N3 A+ V9 w0 I
print(li)/ f! M1 m, Y0 T/ i9 _4 z8 y

7 d" H% L1 w+ P5 z/ D) |eric
- X7 S9 K' l- A  _0 l  o['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']. Z- p. U; t% p5 c0 ^
del li[1:]) b) p& S5 p0 [# c; P. {* _. u
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)5 {# B8 o$ A% f$ F! r9 i
li = ['alex', 'eric', 'rain']$ S& _0 j3 c& W7 x, U. z- o# e- w
for k,v in enumerate(li,1):% G9 v5 Q& Y3 }9 }: i
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 o. A7 W4 C7 Q$ j
a. 请输出 “Kelly”
( z' g4 K% @5 o7 `* f! L! Sli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
' t4 @7 H! \' K, |7 I8 y; {print(li[2][1][1])# w, I- p9 b9 k0 @2 @7 W
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- s- u$ v# L3 N" w2 j/ Mli[2][2]='ALL'& s/ h" V  _+ L& Z7 r7 @# Q: X
print(li)9 u8 ~) c& D' j: U
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! B6 I" @1 i/ w0 Qa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
* b  m7 v6 L) c4 l/ b, iprint(len(tu))
0 v9 q! q( w3 p8 m/ B8 sb. 获取元组的第 2 个元素，并输出. [8 N/ r6 g9 ~+ n
print(tu[1])
9 s+ P# b" F$ h$ b& g' y( ~3 z# _e. 请使用 for、len、range 输出元组的索引. ]9 G! S- u) C/ g2 ]5 }7 n  e" `
for i in range(len(tu)) :
9 _( L: m: U4 n2 ~* ] print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)" W0 Y8 x3 U+ W
for k,v in enumerate(tu,10) :
9 k8 O; x; i7 C- y3 _1 ?! z3 Y print(k,v)
0 C" G! T$ _! [10 alex
- Y5 l) O) m6 ^  k4 u11 eric/ R7 ^( _0 q4 Y% q3 q
12 rain
' _) `4 p. n+ _9 y8 W( l$ N
6 N: w5 c8 B0 n4 }/ Ifor k in enumerate(tu,10) :& x! g. Z6 \, }  Q& b
print(k): A% Z  T' i% Z# r
(10, 'alex')7 r* q- A( r8 v# D+ c4 o" N+ d! E( y
(11, 'eric')* U1 T6 G) N3 h. h- r1 ~4 C. m
(12, 'rain')  @- H8 k$ ^# X) u6 S! `9 B2 L

4 L( D) }* i' l3 y" o+ i6 V$ e, c  Z" a+ Q
25、有如下变量，请实现要求的功能
; g0 |% b1 ^# y& z. K2 \tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

8 U. q. Y9 d  r1 O' h- [d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 y4 |0 M; P$ q2 R5 ~% V: {tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 N; y* k. t% [% rres=tu[1][2]['k2'].append('seven')
4 V; m( S/ w+ S% ^
. U8 t' l' H! u4 bprint(tu)
) w1 K$ h( \7 i% t26、字典+ r  w- f0 l) l3 G
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:6 K+ {. s: A: e) T
print(i)b. 请循环输出所有的 value
+ u, c) |6 g' T# s, ?6 y, Yfor i in dic:, a- v) I* K7 t# {
print(dic)
8 [: F0 r: g& ^( Vc. 请循环输出所有的 key 和 valuefor i in dic:: j9 Q) H6 D; P8 n
print(i,dic)
0 i2 p) m$ e% u: \$ f2 S0 b- ]d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典' J: K' Q5 Z0 _1 M; O* ]
dic['k4']='v4'
4 l( k; E' |+ W6 Cprint(dic)3 p" v; E7 u% y" d- i4 m
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
' i3 D/ `$ e; f2 j8 O; r# edic['k1']='alex'
, L- O9 }  V8 dprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
! Z7 \; N$ J, k" }! B( i9 ydic['k3'].append(44)9 b1 W) Y: `/ l# n
print(dic)
+ B0 O. a* R9 x1 v7 d
+ G' L5 W" r  Z/ X# Ug. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% \. j, k* Q# Q0 Zdic['k3'].insert(0,44)
( o% |( M* W* @" b+ D/ Cprint(dic)
( Z" Q5 I; s; O; [0 G6 z8 O27、转换! {; Y# G5 X6 \! I: k+ g
a. 将字符串 s = "alex" 转换成列表  s = "alex"
# E2 g% S& n. V: i. p* W  [8 q3 T# T2 O" E9 r
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  m: J8 [/ P4 ~/ [5 Ds = "alex"
+ W& b2 K/ b- X8 J1 Yprint(tuple(s))& c1 ^7 o, D& M3 D

9 n0 L$ S  z7 ^1 b8 qb. 将列表 li = ["alex", "seven"] 转换成元组5 ^( ~5 `, K. Q2 w/ U+ a
li = ["alex", "seven"]
9 N0 ?9 r0 T; E+ nprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表( r! r* N6 n' ~' ~3 f2 O0 }. C- @
tu = ('Alex', "seven")! x9 p6 u/ u0 L1 Z2 _
li=list(tu)
0 X& q1 r7 }0 I7 Y/ k; A$ F- qprint(li)
& q9 J2 \" ~( z+ d9 y- S
8 y  k( E) K6 `) ?- U; w( _$ Q5 E
$ u7 J2 Z( s) J5 \. n/ A; Fd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增) S/ `2 w, i: _* }+ K. @! X+ j

# O$ q9 r7 T5 G" e8 b5 S% gdic={}
3 w( T6 Q9 g, L3 ]6 H) K2 W/ l& cfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面) T/ P" {8 [' Y0 X# @
dic[k]=v
& V% Q7 A& K2 j4 I, I( Z. Q print(dic)27、转码n = "老男孩"
* Y5 Y4 _. g( w+ ja. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 I8 ~" w6 b( O% _; i! [a=n.encode('utf-8') # c8 o& D" N' F
print(a)
8 ^; {( p, m# |2 Ob=a.decode('utf-8')  P6 o0 x) a* Y  E
print(b)
% j% z8 |" y! F" F" `+ D, N; ~b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')! V, X& k9 i% X& ^2 ?
print(a)9 i% H9 h$ J2 V
b=a.decode('gbk')
; }1 O) s. \0 o; }8 e. N* S- wprint(b)28、求 1-100 内的所有数的和
count=1; l% H0 d" M+ d  G- M  f9 y
sum=0# V. |9 f* ?" D& Q( o7 j# F
for i in range(100) :
/ w- O7 P& n# f- Q' ~5 X  H sum=sum+count9 S( q1 Q, X. t  U/ ?# |1 j
count+=10 {3 A6 q" y: _) @+ S
print(sum)- b! X' @3 z5 G9 M
) }. u. M, k3 l" t; H& Y
count=1
! r1 `/ Y2 ]# h0 N  e0 Osum=07 _# k: [! q8 w4 o1 [! b5 U
while count<=100 :; T8 Y9 J+ i, v" m5 C- k. O' }
sum+=count5 w2 @3 w0 e, D  E7 V) P' ]
count+=1+ O. x2 ~% }* w! Y, y  s0 M
print(sum)29、元素分类: u9 d" I7 V/ a. M3 g% Y
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
# X2 _' a- ~# |: a$ ~将小于 66 的值保存至第二个 key 的值中。
6 y: Y! L: a' R4 D9 g5 X即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}" F5 u- _3 }- l4 m: k) @& e0 D- n3 f) I
li=[11,22,33,44,55,66,77,88,99,90]
3 d  ]$ ^8 ]0 G4 {6 kdic1={
3 ]% q' F9 s" D1 A4 t 'max':[],
) c% Q- X  z+ d" `: ?& e 'min':[]
0 H: x' G' H, W6 `- D}: @% u+ i; Y. j) {) T
for i in li :5 Q0 O/ N# g/ [  ?* y0 D
if i <66 :
; d7 v. o! d' z: u; J( a       dic1['min'].append(i)$ G; e8 X7 X% W: k. [. n9 t
else:2 B8 s3 q& t( I: l+ X* I5 f8 N
      dic1['max'].append(i)# v  E" |. P; e0 U" b
print(dic1), X' z* q# C3 M2 `: ~# T

; J# W- J6 g+ ^---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}+ T% o; X- G3 {

Python基础知识汇总

主题推荐