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、写代码
7 `' V1 @9 \# G' k7 ?+ `3 oa.实现用户输入用户名和密码，当用户名为 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) :+ d9 l8 T; \8 ~/ j' ~$ Z$ ]* B! [+ }/ W
name = input('name:').strip()
. z1 T2 ^: x) T4 s pwd = input('pwd：').strip()
+ t' b7 m7 h) A4 c2 T! l, W( q  ?& k9 |( m, O- {1 W+ h
if name=='seven' and pwd=='123' :0 C! `7 T$ x9 C7 Z# ]
      print('ok')8 Z0 P. M! {9 G! k  F9 k
else:
9 i* ^, O5 ]+ k2 ?' }0 M       print('error')& R: H5 G2 Y, x' U
      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)  :
2 Y* ~4 ]6 G" h$ A name = input('name: ')
9 c: \1 w& s0 N! n2 c2 O  f& f pwd = input('pwd: ')) n- p9 N; `% d
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 X) p: |/ V) s  W) L       print('ok')$ v9 y- ?7 L& i6 N* n+ Y
else :
- T( z, t: G: B5 r: ]       print('error')5 ~8 S% `! `6 }+ f! q5 V) }, ~0 M3 j
      count+=111、写代码
& {6 r- d% o9 R" W3 \6 Y- G, }- ta. 使用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) :
  g+ s& v* Z" n8 d if i %2 != 0 :
: T& E, Y7 d' o       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :0 B% Y+ ~7 E" y; L. m& F$ n* `
if i %2 == 0:
& i! a0 K  k, [" q4 V       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") E9 u0 Y5 F' v) L% e
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)
9 s+ n' ?7 q& D8 q/ ^( Bfor i in name:" k4 W1 _+ O  X" f) ]/ X
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
. \! w' X# B( l, G% U; z  c( r5 K22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
5 h) Y  r, ~' F9 F: g# Cprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
; O2 f9 z4 ^! z( o8 G3 G0 Yprint(li)
9 E2 R2 b. ]( d ['alex', 'eric', 'rain', 'seven']
$ d2 z% F9 m; p8 H- p4 K3 ^7 Qc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')9 n) _7 B5 a: A0 C! s, _0 G6 y
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
5 |7 \" i6 {/ i4 Qprint(li)
9 u3 L1 s2 X. e6 `e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
) ~7 M( e& U' x+ o2 D' y& U9 F: @li.pop(1)
# Z# V9 x% @& G8 Sprint(li) ['alex', 'rain']
* H' d& n- P& q指名道姓的删除li = ['alex', 'eric', 'rain']: f( e8 v4 S6 @; O
li.remove('alex')
print(li)4 w9 Z7 v0 a4 ], W7 n) I2 X" j3 c
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']: C: U: |( T! l6 o% v
print(li.pop(1))
; |& y: |$ K4 j! d, x( t; uprint(li)3 U* Q7 J( h$ M% r3 M/ v

0 a9 Y7 b* i/ U* Seric; [* I: x. `6 ~0 ^6 R! b$ _
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']9 ?& u! \9 i- ^
del li[1:]: U( N% Z2 V" D4 `
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)  q; X" g! i2 |: h) \. G
li = ['alex', 'eric', 'rain']4 J* K% M; D+ s+ T
for k,v in enumerate(li,1):+ E) J+ ~  @3 t% R5 f! C
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ X8 C, r7 t8 w7 x# A6 sa. 请输出 “Kelly”
' W: [; `+ D: i5 s5 D5 p) Q2 W* N! @li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]7 i" s. e# k: x% i9 g# l+ n6 e% Z
print(li[2][1][1]), @# ]& `- J' W8 F" t: C% i' k' y
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
1 i9 a7 h* ^4 ]. n2 r; pli[2][2]='ALL'
* c7 r) r7 S; N. G8 i& `print(li)
3 a& x7 o% ]3 j' C; J24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
  R" Z1 Z) O" v! v9 \% ~a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')7 t. M. f$ H) b* |/ l) Q
print(len(tu))" |/ D6 q) h  g/ p
b. 获取元组的第 2 个元素，并输出
4 T( l- `/ |: S0 Eprint(tu[1])
5 v! B$ e' ]  K5 o. m5 ]1 fe. 请使用 for、len、range 输出元组的索引
5 Z' A( u6 H4 q' Nfor i in range(len(tu)) :
" b6 D: \/ z& I( b& X print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)/ t. t7 `8 g" K3 s+ b: X
for k,v in enumerate(tu,10) :
* H9 G" [# g) D1 v* _. c; w6 J* H print(k,v)5 _8 s6 m& Q% J7 B* R7 ?* ^8 L2 Y- W
10 alex
. b3 A+ N6 m+ F" P: }  L2 |7 W11 eric
/ s6 z& Z8 e" ~- k7 \3 u; t12 rain2 G) A% T  W1 H) P

8 R, `1 ]/ a9 Hfor k in enumerate(tu,10) :' N  L( V1 e3 w/ T& p  C/ A6 ]: B' J
print(k)" Y4 ^1 h9 [6 z: o' u
(10, 'alex'): p! E9 M0 w1 |. Y4 C& ?% T
(11, 'eric')% W$ |( c/ X7 V! W- P- i" F# @
(12, 'rain')
! G! H( S% o, P/ m4 |9 c( L$ Y6 W
* E0 X  Z1 I0 G$ G+ h* Z8 @
6 ]8 M' Y5 o; D  `  G2 K3 ^25、有如下变量，请实现要求的功能
" S& M" X# U& k" f. _! }$ Ntu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

5 f( t7 F+ x- c9 _8 j* Wd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ t4 g9 {  w+ P! `
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  ?4 z" I$ r; R/ c" d7 h. o( `+ @res=tu[1][2]['k2'].append('seven')
" n& a/ _4 j8 T& ~' h
9 Y5 u- E* w! B. C/ ]; K) [print(tu)& f. K& O& @( `0 o4 W, F
26、字典
* |; D* u7 |( r. `, Qdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
" U8 W3 N$ B" `+ a( F3 i0 b print(i)b. 请循环输出所有的 value
" e, A/ |) a5 t7 }8 Z0 W  ofor i in dic:
/ s! Z2 l+ a2 L1 y; t print(dic)
( l3 p( b$ _0 {" K$ `( _, a! vc. 请循环输出所有的 key 和 valuefor i in dic:* x' W! r, V9 W
print(i,dic)2 `8 P1 q$ E8 s% S
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  q  b  H8 L; ?% fdic['k4']='v4'9 _' |& {$ @" b/ z0 Z4 |
print(dic)& V% x9 Y9 o$ C+ Y
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典) \) }3 s0 K( {5 @0 C* D
dic['k1']='alex'/ q" ^- ?1 _* D7 W
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典! w* R7 U/ v) b0 F$ [
dic['k3'].append(44)
' ]/ O( z0 q6 V" w) C7 H$ tprint(dic)
$ \; n3 C3 {$ e, Y" ?, U% I% q
$ {0 S: C! `7 ~* h) a% Fg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典9 Z7 w  E6 D4 k" P' R' ?
dic['k3'].insert(0,44)
# ?) r8 T7 G' m: u2 n2 c7 J" Vprint(dic)/ t/ v8 V$ t. `  @
27、转换
' ~; K; @: h# y' V8 ma. 将字符串 s = "alex" 转换成列表  s = "alex"" }9 p: a( T+ Q0 ^# m5 X  N# l* p
3 f6 n4 w/ u- E! t. z
print(list(s))b. 将字符串 s = "alex" 转换成元祖9 K5 B) T7 _1 x' e6 P- q5 c
s = "alex"
! x  u. w4 ^* ?# I1 C) Nprint(tuple(s))
: G8 P, Z9 u8 P& Y" N( \/ z, J
6 `- J3 Z! b+ h/ l  U- ~b. 将列表 li = ["alex", "seven"] 转换成元组/ {# p1 l- w9 ?% r. O+ J
li = ["alex", "seven"]
/ E/ `% |5 M- g7 j* s6 E0 K$ mprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
* q, U8 x# f2 D" Ttu = ('Alex', "seven")/ V0 l  c5 L9 [! b2 @! k
li=list(tu)
$ T, W5 R: I. ]* g% s$ Eprint(li)( `9 j% j$ ?/ Y2 ]* \, Z+ ^! y$ P
- B- f2 m; d. S6 o, i, _2 M! h

9 ]1 p5 o- H" Sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
9 Y' r3 @+ S5 I; }- B6 o% `2 i' U) m2 l- S; s" C& u, y& }" Q) o' j
dic={}
5 `# k% y  w/ }1 i2 M6 k5 bfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" r. I. k; _" n# ~3 Z$ s dic[k]=v- S2 T( r, g# Y% k5 Q( ~6 {& E6 K" _  h
print(dic)27、转码n = "老男孩"
9 t; B' N. @& @  x  ja. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"* f8 O+ c5 l2 v$ F: Y
a=n.encode('utf-8')
+ N8 Q4 |; h  f* Q7 P/ Uprint(a)
; Z& x7 w- `- }- ^: jb=a.decode('utf-8')8 a( `2 q+ T6 L2 M! \4 F" g
print(b)5 x1 M7 q4 S$ `6 S7 e! l, q3 i( k
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')5 f' ?/ J  S' o' n
print(a)6 ^! N* q( y' [) q7 l  ~
b=a.decode('gbk')6 I; ^) A1 u' d0 B9 [" m# `; w& T
print(b)28、求 1-100 内的所有数的和
6 g# J. c$ X9 Z' s" Qcount=1' Y. `# F# B. }/ b5 Y* c
sum=08 [9 ~& X+ f( W! x- A% _
for i in range(100) :
% U* F! M9 T' v' L sum=sum+count$ F2 Y9 g) H3 ?2 K" p
count+=1
print(sum)8 ~9 i) C6 H- F& H

* d9 @3 H1 |9 s; l9 u* u2 V8 T, ^count=1
& j+ D+ i4 }% h9 Zsum=00 \' e, H5 D" i0 @( e
while count<=100 :
! e  G9 j6 ~% G( ]8 ~* c sum+=count3 w' J2 S4 t: M' v) O# z4 V' {* _* |
count+=1
" ^; @- E3 B; oprint(sum)29、元素分类+ J/ j0 c) n  P: Y1 j$ J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，# O, N- C0 c* e; E% \! c; o. I
将小于 66 的值保存至第二个 key 的值中。
) u/ i7 `( y3 i/ {7 \. n$ H即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) `' W% _0 X! n1 O3 ?( c
li=[11,22,33,44,55,66,77,88,99,90]
7 k- Q" }  j/ Z. Y  G% bdic1={
; H+ E7 k1 W8 S' I! ?7 E 'max':[],
  ?* ~1 K  p$ t* @( i 'min':[]: d( ^, f2 g- V$ P3 g* W
}) N/ B, W$ W% Y3 \
for i in li :( q3 K% Y7 k8 ]8 a/ _" t+ c
if i <66 :
6 L- S. P3 `. S$ g       dic1['min'].append(i)
  |3 e1 W4 R6 W6 j5 d else:( V! Z: p8 m  ~# t& ^
      dic1['max'].append(i)6 w  P( W8 p0 e; A
print(dic1)
; |/ K, n8 w" k2 V7 ~* }% r0 [- I
8 J+ }2 I* @/ ?% R/ z! g7 ^---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}! N7 }3 I) k5 w  K/ B) b# E

Python基础知识汇总

主题推荐