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、写代码
; P1 F) X2 C6 ^/ Za.实现用户输入用户名和密码，当用户名为 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) :
+ m- }" w, n8 S4 }: W1 Y4 A* l name = input('name:').strip()5 F, [/ a' A# d
pwd = input('pwd：').strip()
+ d% m2 @7 o! a  C8 F# X
, v! x& J2 f5 `& ] if name=='seven' and pwd=='123' :
( |4 E  H; H2 s; @       print('ok')
' ]# h( @3 n/ V else:
" i0 \, g5 G$ t# R: u       print('error')- Z+ ]* h6 J& Z1 P' Q: f
      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)  :9 Y! H" S4 g2 w/ D, H  P
name = input('name: ')
: P! W! X+ d9 X: M$ L* Z! G pwd = input('pwd: ')
3 ?0 V4 \+ k/ g! l9 A if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':1 A6 w" {* o: A2 d7 `
      print('ok')- m: m9 O4 Z9 u* r4 v
else :; n; [* u- E( D" h7 A8 o+ h
      print('error')
) |- x$ n3 ?. V0 s& h       count+=111、写代码' j; c! h: u% B. d2 ~4 {- y
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) :$ a2 j4 N4 d; j- R$ F- g' }6 S' s  b
if i %2 != 0 :( w0 c1 E7 m0 J& v/ p1 s( p
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :: o4 |$ @, W& Y* Q4 y
if i %2 == 0:- t" k, c6 |) Z  F" o
      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"4 P1 U& @0 j, C  ]" C; g
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)
: W" V/ T, t0 gfor i in name:
3 H  h( k4 L4 I print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! K9 m) i7 f* |) Z( H5 h7 J22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']0 W' ^7 [; j  b- U+ o7 f
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
( [$ H, A, o3 c3 D% f1 M0 {" Xprint(li)
+ F0 @) A6 c+ Q ['alex', 'eric', 'rain', 'seven']# K6 n# M. N( E+ J2 V7 c0 W; W* I
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, T: G( D; B2 r% V* X* M- J0 Kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')  h' v0 {* D  V+ L' r# y/ T" K
print(li)/ R( Q6 E$ B9 w. @, k( Q
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
( c3 z1 l" H5 t( ~li.pop(1)/ r/ c- |+ u, B, h8 x7 C1 k
print(li) ['alex', 'rain']* o3 D2 F% p1 H' |) o2 M7 A
指名道姓的删除li = ['alex', 'eric', 'rain']
' Y- N  o# |- r4 |$ ali.remove('alex'). b/ L6 I: M) o! @! J* {
print(li)
, p. k) F& w9 q$ Qf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))7 G. {2 U  w/ g1 P" {
print(li)9 z7 }9 S1 T+ q/ {8 f; V  y4 ^. ^
! W& E  X' O  z
eric
2 j- s+ I4 w+ X; j['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']( R2 A+ K1 O: y( f0 S$ J
del li[1:]2 N7 I3 Z3 m+ F* W6 s( e
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始); Q( K/ H, @& ^. V! u
li = ['alex', 'eric', 'rain']
4 j$ `' n0 ~4 `: n- }for k,v in enumerate(li,1):
  d2 h' S' @; W# [' Y' h print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 l; d0 L4 ]8 J; q! ]9 ~2 xa. 请输出 “Kelly”
3 P: a* l0 C8 t: u) Z1 F; Xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]5 G5 r) g9 {0 I) X3 ]# y8 D0 a& i
print(li[2][1][1])- y! g+ \, t/ w" s9 j8 B
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 v' ?6 Z2 {5 Q' h, Gli[2][2]='ALL'7 E* P: V; E3 z& a# j1 @
print(li)
  d  m2 R* q5 f% Y24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
7 Y0 X) D( L$ R% W8 ?& ea. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
9 G! y0 `2 P- Q% [print(len(tu))
0 H7 K5 F' B! Zb. 获取元组的第 2 个元素，并输出
* B3 A7 j; r: wprint(tu[1])
. H! N9 D! R5 ~8 U+ W1 ye. 请使用 for、len、range 输出元组的索引
( r2 f/ ?- J: r8 @! n9 K$ Cfor i in range(len(tu)) :
5 B0 B$ t) M/ a$ ^# l( k4 @0 G print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)1 a) V/ y. o; `# S4 Z# o
for k,v in enumerate(tu,10) :$ Y8 q- k$ G% y' V; ?/ z
print(k,v)
. h2 }4 ~  i" w( f* B! b) _7 b10 alex& I2 |* D3 a+ G: d; v2 p
11 eric
4 g6 v9 X( s4 I6 _. R/ m12 rain) Y7 Y9 l4 \& q+ F& V$ \

% [+ c! s* ]; s: zfor k in enumerate(tu,10) :5 s" A1 u6 g4 V: Z- e
print(k)
/ \+ T3 B6 Q' J5 {(10, 'alex')
4 R, o- \) x5 B0 ~8 v% c2 @3 J(11, 'eric')1 Y6 Z) Q# S5 ^# W9 g+ {7 v
(12, 'rain')0 ]" S0 e8 d4 ?
* m. }+ C" y! E$ z

9 r- t/ u( k2 Z" T0 b6 H25、有如下变量，请实现要求的功能2 l% W' S4 G1 j8 C" l# T
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

$ O) L# g# ]1 `& D' Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
; c$ q. h  w' h2 R. Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
( _4 T0 _  v3 g8 l2 ]6 wres=tu[1][2]['k2'].append('seven')
" R' E& N6 g; Y% `; e/ O1 Q: j1 B2 N, [
print(tu)
; ]8 I6 w- e9 e" f' v3 L26、字典
" Q: C' Y5 K5 O* s1 J3 jdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
  p+ M* x! q% ]/ `! p1 o5 y print(i)b. 请循环输出所有的 value. e0 p. F" s6 S/ b3 t, ~
for i in dic:+ U$ L) z6 ~2 ^$ v
print(dic)0 H+ h5 w" F0 o/ T" ]3 N
c. 请循环输出所有的 key 和 valuefor i in dic:" Z/ a0 t* r; E0 X8 N+ w$ Z/ V
print(i,dic)' o8 D6 }* R" r* ?. Y
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
5 \" m/ q6 p$ P& p7 ]! J# Ldic['k4']='v4'
3 O' f9 U/ `- |( z* `# ?( E/ H4 d+ H7 eprint(dic)* _" u0 X! S& Y  ]
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
& Z; k% \; b5 d1 P$ y9 Jdic['k1']='alex'' b) D$ u3 r) n5 {8 u9 z
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
+ V2 G7 j$ n' t+ ^5 j! R  o( ^dic['k3'].append(44)1 H9 u  w) T2 u- L# J; ^4 k  V5 Z
print(dic)
' T, V: B1 L9 v% M8 z8 a6 Q( ^0 {  V* n1 a9 U
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典4 A6 G7 ~7 k! G2 ^& C2 w
dic['k3'].insert(0,44)
% X0 H3 C& l+ e$ k1 Bprint(dic)) N4 `0 U. l& X  h1 C
27、转换
- H3 S5 `. `+ Q& z* j( ya. 将字符串 s = "alex" 转换成列表  s = "alex"/ B6 f% ~2 d6 [
1 `3 Z) R3 ?- O4 q0 s* d
print(list(s))b. 将字符串 s = "alex" 转换成元祖
! u( S- {8 W% m, js = "alex"# p4 L; B3 @: U; W+ S5 j* S
print(tuple(s))
2 G0 a! l) P/ t) ~
! ~! P* I1 D5 cb. 将列表 li = ["alex", "seven"] 转换成元组( h: m6 V9 X' f* p
li = ["alex", "seven"]
, ?/ |) r) ?2 s' ^0 g7 {print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表! j0 u1 L' c% I* t  x
tu = ('Alex', "seven")4 K( ~, Z2 u9 k3 ], |! L0 `5 C
li=list(tu)
8 l4 _; N6 T* ^* ?print(li)9 k& Q' D' Q" u- @4 Z

! |# n' X' h% k9 d/ Z5 Q" Z8 A1 O) J/ K) O6 t
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& I$ Y- k3 f; Y  p0 h; O! a0 L+ o1 Y4 y, n( A# B
dic={}7 _. _8 s3 a/ C1 A! z& @! ]: O
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
0 j  \- [" D2 S6 ]+ N. \) B dic[k]=v  C4 v4 S  x0 |: q' s* L+ ?4 r
print(dic)27、转码n = "老男孩"4 J/ y( a* t2 ^( S
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ [) R, h4 f$ @a=n.encode('utf-8')
2 `0 z% [4 X7 a: t* rprint(a)
+ i5 v$ i2 n% |1 r9 W/ v# d, N1 Sb=a.decode('utf-8')
# T) Y/ [% Z& ?! R- `2 @9 Bprint(b)5 E- G7 ?# B0 ^6 m
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')) l1 C% O& ]/ @
print(a)
5 n7 [0 p% j2 v) S* y) k& A5 nb=a.decode('gbk')
1 z: F3 i$ b0 R( F" a# v  vprint(b)28、求 1-100 内的所有数的和
$ |5 c0 |8 B  b' J, x& ycount=1
9 K- x9 g* q- ~4 J3 x0 Ksum=0
( W1 }: w% ~7 j2 Jfor i in range(100) :1 H. W9 T& c, C+ H# R: j% B
sum=sum+count
3 X. e' U7 I5 K' v' B count+=1
; g$ A/ N' K, w7 Iprint(sum)! U2 V. v) d" g- H! G7 ]' k9 \

2 y) t* W8 R4 x  R$ Bcount=1
1 `/ v. i$ d! q- hsum=0
5 a' M6 _- I# p( R; uwhile count<=100 :  h0 q# W3 W; S/ H
sum+=count% A2 C" C2 ^6 k6 v; u+ ^. U
count+=1+ Z/ u6 U! I" u% s5 @2 r! J
print(sum)29、元素分类1 D2 E5 C! L$ B# L( l
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，  R6 m0 a- W  }* [! i! R
将小于 66 的值保存至第二个 key 的值中。" J' p# B% P. P4 u+ D, O- x
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  c  G  \" Q3 S& R0 C
li=[11,22,33,44,55,66,77,88,99,90]
6 x! y. K8 U0 ], wdic1={
7 d' {, h' b! f# j% b; _! Z 'max':[]," p, a2 w8 ~! n# P- \2 G& d
'min':[]+ h; N% A- y8 e  H: r
}4 W4 V5 M4 L! Z  U! [& c
for i in li :
; g% q/ x8 C# H' g if i <66 :2 T1 G/ c! e4 i' U
      dic1['min'].append(i): F3 V( h- w. Y7 j, K2 [
else:
% M9 y  ]! d7 g       dic1['max'].append(i)
* E. r% ]6 T9 T# }$ R; }  t  g+ mprint(dic1)
9 s/ A! t# \# i  Y
2 ?7 N! d/ E0 R' }---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
; O( s$ }* d9 P7 Y' |5 t% T( T

Python基础知识汇总

主题推荐