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、写代码
- p+ L! ^1 Z0 A/ S2 i3 C. {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) :
+ @' [( \0 [1 h: u  w4 H name = input('name:').strip()9 N. ^! M4 r) L* \' d* a: J7 I
pwd = input('pwd：').strip()
: w! K* k* D& Y, o6 u/ t6 K! O. u3 K' J' I* P+ D9 R1 l6 }* W) ^
if name=='seven' and pwd=='123' :$ W& C6 Y6 s" L/ y* e
      print('ok')
1 x5 ?/ _$ a8 C; W: [ else:2 R1 m' ^& t0 b( J9 I$ d0 A
      print('error')
- ~6 f5 D% b9 P5 {       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)  :7 }; e& u# a: \6 m$ S! s) d; q
name = input('name: ')
+ y2 K3 S; Z7 v/ E6 P# e pwd = input('pwd: ')
2 k6 t* u1 O+ ~9 M+ ?/ Y* R if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 K: z1 H: @: H  G       print('ok')9 W; Y- M3 I: ^6 x4 q
else :# m9 k) r/ h5 H* v. e5 D
      print('error')6 m% _! p. E% V) r( M
      count+=111、写代码
: R" U  x! ^; _4 v' @' Ca. 使用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) :$ j; a9 Q. m% [! W) c$ y( I- @6 Y
if i %2 != 0 :
% Q  q# H1 \7 Z$ b, x  E" e, 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) :
* `7 {6 p  c( b if i %2 == 0:# o8 |& q; A" z9 J( c+ 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"& \# K% X5 e$ P8 s
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)' t# i/ ]* A" @$ x: n/ J: t
for i in name:
7 u5 {5 L1 q' m) m1 [/ y' d print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
$ d& g; ^6 F* [; O22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']! L# w) f! [( e( ^4 w
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
, G  Q/ W) p# s, a* x: Sprint(li)& Z3 z6 O' G2 D- v0 r" t# U
['alex', 'eric', 'rain', 'seven']
6 g+ Y* y9 I6 d* J" N" Zc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')* J! F+ D0 H6 \
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ K' o2 C; |/ t8 k' }* |5 Sprint(li)! }* r3 P# |+ g5 z# Y
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 j) q- Q* T" T) s2 F0 T/ Dli.pop(1)
  r: A" x0 F, u5 z) \) oprint(li) ['alex', 'rain']
# S% f+ {3 M6 }8 X- ?6 A" j& N# ?: R指名道姓的删除li = ['alex', 'eric', 'rain']  D7 W% P2 i1 s# o2 O' g5 G6 a3 k3 q' v
li.remove('alex'), e% B0 V, w9 B/ H
print(li)
7 s1 k- l# U5 d% A' |f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
( w& X/ ^) k8 E2 W* M( P, @; sprint(li.pop(1))
% ]7 Y% Z+ p9 v, qprint(li)( c. e/ p5 [) H& N1 ?! r

$ x- p( P) A" [3 W8 ^; C% N5 Deric
9 v* U7 F9 u0 M. T5 Z1 M['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']# B$ Y- {- d" K
del li[1:]
) L% g3 k# ~# v8 ~5 C; d7 rprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
  b( u3 i$ g* _/ u7 Pli = ['alex', 'eric', 'rain']: y) C& f" t' r9 A9 Z$ f
for k,v in enumerate(li,1):
6 a8 M# \) M+ U+ e2 P! Z! X6 D print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]& z7 x; y5 g! L5 r
a. 请输出 “Kelly”( s9 y# ~) t- U  r8 m3 u; I$ T" U
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* @% g* ?6 m: f2 [$ d1 ~+ Jprint(li[2][1][1])( J' j* b3 D% X5 {' I$ d
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”* J" r4 m9 j- w7 |
li[2][2]='ALL'+ Y# K" }# {* z+ j0 X1 h, g
print(li)
/ J5 W6 O9 {. Q* j24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
) D6 A7 {# X2 a0 p+ Ua. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ ?' D2 o" W- S% V6 `. P) U3 Vprint(len(tu))8 R& O  {7 F) k) r4 `
b. 获取元组的第 2 个元素，并输出
7 d3 t: S! K- Qprint(tu[1])) y3 w5 u; u/ R8 c( n1 i0 u( V
e. 请使用 for、len、range 输出元组的索引/ o# V) S5 ]6 ~2 W% p
for i in range(len(tu)) :
# I) C0 V4 R- g: f8 J0 k. W- A& h print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
) \6 S! V+ z6 c" {+ Xfor k,v in enumerate(tu,10) :9 m$ v& l- v9 L1 \/ T1 b
print(k,v)( `, ?" y+ N6 }) U
10 alex
: Z0 i/ ~0 v/ V$ [11 eric9 M0 E* y7 r4 o, M0 T
12 rain
1 k( K$ Z3 ~; p' V; Q' d$ f: w* E! S7 U" `/ E
for k in enumerate(tu,10) :' S2 \( X9 k5 f  {
print(k)9 m& c# J9 S- r! H) I
(10, 'alex')8 |  k: o/ F4 Z7 I
(11, 'eric')
! w" W1 s* A/ K- H(12, 'rain')$ D# [* e: i3 b6 D
+ c+ |3 H. }2 V; |* ]
/ i! `# f: S4 i
25、有如下变量，请实现要求的功能/ m3 g% f; F  q8 t' k; _. u! X
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

2 p# Q. n! L; {. Gd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以8 \  T; P  m8 ]+ o9 A5 V
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])& v) `7 z. d# E$ }  w8 |) W( u
res=tu[1][2]['k2'].append('seven')6 A9 x7 x' Q+ E$ `% V! u
/ `& `" B2 ?7 c0 Y  G- F& p1 R
print(tu)
- C/ S$ G3 Z6 R26、字典
5 s' R! s) q  a' g8 fdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
  t) ^& r6 P0 Y: t print(i)b. 请循环输出所有的 value; {) d1 p4 _% n+ V2 x6 l+ d0 p! a& }1 N$ V
for i in dic:7 C+ H7 ]  V+ Y7 H. v/ ^
print(dic)
; C8 }% g: [+ T) ?$ P1 F: _$ Xc. 请循环输出所有的 key 和 valuefor i in dic:
3 ?. [8 J+ F  s8 J8 j. ~print(i,dic): |$ w. Y3 i( s
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
% @- T# q! s0 i+ \! W$ Tdic['k4']='v4'
+ g7 D4 g2 s8 y3 G% I( u1 y: vprint(dic)
% m- @+ ?4 f& c* K. s, ~e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
8 W* u1 j% ]$ E9 \( q6 u3 c5 xdic['k1']='alex'* S; b+ G) f  O
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典1 R  W8 V2 }0 A4 v
dic['k3'].append(44)
2 v' Z& C+ ?( q9 x: `# v) Z3 wprint(dic)
; r3 L$ C' t9 e3 R% h2 C; e3 i# o5 |2 s! [3 a& ?7 L" D3 t
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典, b) }+ u" n! V; o
dic['k3'].insert(0,44)& h+ K! m  l0 M( y; W* l
print(dic)& a$ x& P  F) S
27、转换' y: K2 ^; N5 a
a. 将字符串 s = "alex" 转换成列表  s = "alex"  h. L$ o4 B" `9 b
* _& T! R# T! Z  t
print(list(s))b. 将字符串 s = "alex" 转换成元祖& I+ J& ?8 Q! {: @
s = "alex": P* l: L( c" k" ~5 E2 t; ]. q
print(tuple(s))2 G  C  F; J$ C9 i6 y$ h% z0 |

( {# ?- o  G; y2 @' p9 k; Nb. 将列表 li = ["alex", "seven"] 转换成元组
/ Z! f. P( u  T) S5 v0 |2 Yli = ["alex", "seven"]
7 A5 v! U( W1 A7 Cprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表# E  ^: f& u8 `9 G" k
tu = ('Alex', "seven")
- Q4 J& l: h$ J0 {5 Z1 pli=list(tu). q8 E. O; P" e' }) f
print(li)- u9 X% c- o5 B  s7 h
/ Z  x! i6 ]% _, @  o

5 C' u" @" S$ D5 _& P" o6 l" ]( md. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 q* E0 }7 y5 \. U% x: H1 }! w' O, t0 @# P2 p8 c1 s
dic={}
8 _7 c7 H" a( p% T- z. {1 i9 ]  Zfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# L7 p! z, p0 {$ q/ z' A( V dic[k]=v
5 @  @+ s% d) S$ u) ^* V1 D: w print(dic)27、转码n = "老男孩"' s  u* G/ r' _4 D
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! _$ z0 j# F  w+ B$ k# O. ga=n.encode('utf-8')
* @* z) k( t- [: V, Z3 O8 Wprint(a)
) Y6 A6 K5 e! H  @b=a.decode('utf-8')
! F/ ~8 i- o# rprint(b)
6 q3 k; L3 E$ Vb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
  [/ f2 C  e% S6 x5 D6 dprint(a)# o: z; X. L4 Q
b=a.decode('gbk')
) k5 ]# R/ s/ Z4 K: C7 F# G$ Uprint(b)28、求 1-100 内的所有数的和
# u7 E8 \/ ^0 M# ucount=1
: |3 K3 Z! }6 I3 [% l& Lsum=00 {. J" Q. j. t7 g2 C% N# m
for i in range(100) :9 e# b' r! S2 k9 s, n. d2 M- b. ?
sum=sum+count9 g# n; y; _% `: t6 s* K
count+=1; Z+ Z8 O7 B& y. W! n1 _. B
print(sum)8 H, |% v% b+ d

- K% @$ G# B! W$ \7 Zcount=1
" e8 @- H! z3 I- n5 ^$ T9 Nsum=0
# m* O6 @5 h* _; ^" E; G4 wwhile count<=100 :( k( {4 p8 t. i" V; B( Z) Q& X
sum+=count1 R2 O) J2 Z/ _" q# e
count+=1  d6 |& P: n) n# ~+ t
print(sum)29、元素分类' J& C9 D$ T( v
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，, C. x- |) V+ ]" D8 _, R; |1 r0 o
将小于 66 的值保存至第二个 key 的值中。, X) W4 }$ u, J+ e) W* K
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}8 n. Q0 N: h. `! x$ |
li=[11,22,33,44,55,66,77,88,99,90]/ c: Q8 D( K: N* D; N/ g% R/ ]: K
dic1={+ O. x0 c( g/ J$ j
'max':[],
; f) ]: n8 i  b$ b$ a& Z8 e% B 'min':[]
  [# \1 V! q$ b8 B5 f}7 u! m1 x( S4 P. [
for i in li :
. I* F* s- u, ~# C/ o" g) B) ]: B if i <66 :/ ]/ Q/ [" @8 W4 X. o5 V9 j% L
      dic1['min'].append(i)8 ^6 Q0 f; w3 V
else:- t$ q$ O, C, s; b- i# x
      dic1['max'].append(i)8 i1 h  }  [4 t& V4 q( ]
print(dic1)+ ?; h3 H! I4 q. |6 \9 x
$ K5 ?6 m- Q1 u, H
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}  q3 s8 d+ z1 p/ r2 b' L

Python基础知识汇总

主题推荐