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、写代码
' g$ Y/ [+ A9 c! N6 \3 j+ ^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) :( `' x0 z# M, f% @/ u$ i1 T  A: \
name = input('name:').strip()
, e' @; j1 F. c) Z' s. @ pwd = input('pwd：').strip()
2 U. [9 ~. J9 o8 `7 t5 q1 B
; C4 m+ i& I6 e if name=='seven' and pwd=='123' :* b* f3 R* H4 c' o9 L
      print('ok')6 ?  |1 ?. `. p* V; Y2 O
else:  f: ^9 g% C) N- k$ P$ z1 q
      print('error')) S7 Y( q1 A( q
      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)  :
; i! f. d2 I% a. s9 H/ M+ F$ u/ ` name = input('name: '), S  G' S! @$ |: ]8 @  s% q
pwd = input('pwd: ')
( V/ B7 _" I6 O, \7 z5 ? if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':' O5 k+ A! ?* E: H# k) v
      print('ok')& g& v1 |9 d; B+ v
else :
" t! Q, A8 e% ]2 r" p4 K) x       print('error')0 \2 _: ]6 n* M: n6 O
      count+=111、写代码
: Z* K. k& `( q8 N$ M  ma. 使用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) :
# [; d4 }' U/ ?% @ if i %2 != 0 :
0 c% w; U" k+ K+ g       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :4 F8 h: t. a7 x# q( H" S
if i %2 == 0:( U2 s  S& v, ?; s' Y5 p
      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"  E/ b+ ~' Q% x6 `& x8 L
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)8 J' W1 I% T& P
for i in name:5 C( @7 E" h& }! u/ Y
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
( ^0 d# E9 H& @, ]5 e# a22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
  y3 |1 j9 V7 R* y$ Iprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ; D1 i" ?- K; E+ X- C- X
print(li)
: o9 P, X& N0 S: o3 d$ d ['alex', 'eric', 'rain', 'seven']
% Z/ B* [. R4 r2 J9 f' Cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 _" s3 b; W; N) r" \; ^4 h( Cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
$ c. q1 ?! ~( b3 R0 d8 aprint(li)9 @. L4 L2 o6 |5 F7 }- X& j  j
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']) {1 c# T' r5 {7 C% I
li.pop(1)' Y. M' X6 J" @8 O. `2 p
print(li) ['alex', 'rain']
% ^; X6 C- G& \4 b/ z4 `指名道姓的删除li = ['alex', 'eric', 'rain']
; X$ Y& a. A& [2 u! b; \( m, G# xli.remove('alex')
" r% Q8 i; x1 fprint(li)
7 D. P- X: t% c$ q% d/ b) bf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
( t; t3 z8 o, _+ i! S) _print(li.pop(1))5 y9 Z/ ^, f( _( c+ r4 u3 h* o
print(li)8 y2 n7 R( Z9 J6 @1 c/ @4 E
4 @3 C- @1 T' f' }
eric4 q, q- c; f) s0 E1 {3 v: N$ p" H
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain'], o4 X' N! D4 M( r) k5 E
del li[1:]
0 w: _: o3 i4 p, `. W1 vprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
. O/ ^  u* R2 f8 F6 hli = ['alex', 'eric', 'rain']
# c) T( l) e/ x) F/ O& Wfor k,v in enumerate(li,1):
, ?4 y4 u& T, p; p6 ?. M3 R6 s! l- F8 A print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 Y" x  D7 c( g- i- _; ea. 请输出 “Kelly”
4 E6 }8 E* o, Q  ~/ c% l4 Rli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 ^* C, q7 u0 z: ]print(li[2][1][1])
  b' Y& C6 P- nb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
- E# A( F2 v* w" g3 J7 R7 q  ]3 pli[2][2]='ALL'
$ B) z7 r# n8 L! cprint(li)
0 X9 W5 @( K4 k2 c24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'), V4 H7 }2 P' M8 i+ C7 N  M
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'); ^7 ]8 k5 ]6 K5 j( `3 K
print(len(tu))$ V  j5 J+ S5 U# \* x
b. 获取元组的第 2 个元素，并输出+ j: n  b% K" P) f" V
print(tu[1])
) E! ?# Z7 v& b, }- we. 请使用 for、len、range 输出元组的索引' U6 L1 Y5 }2 s
for i in range(len(tu)) :- w% K: P$ k( z6 n* o6 |2 P
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)- u$ L  r0 Z; g; a5 x# E$ ^! v
for k,v in enumerate(tu,10) :9 L. F! f+ }1 K6 C& \4 i
print(k,v)$ ?% O% g6 K) c; j
10 alex
  {& c+ N/ R# `9 d: N  ~/ E# u11 eric/ g" h; J, O3 Y0 i+ N5 P7 Q
12 rain9 X- Q1 f8 q4 Z; A, H8 E
0 V& s4 E1 U1 E: ?* a8 c3 h' C
for k in enumerate(tu,10) :* Z( D/ W( ]4 X5 C) \8 P9 }. g! {
print(k)7 H+ ^) x2 _; p% i- T/ `$ V
(10, 'alex')# w7 }* v! T1 f) p7 A5 P9 M7 i
(11, 'eric')# H9 F/ x' M; }  ]
(12, 'rain')
* e0 T& n5 F1 j' Y) H% O# P
; z$ |% u- g) g, [6 s* V, ]5 e+ F
25、有如下变量，请实现要求的功能
2 O, u6 U6 N0 K& j' k' k- Xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 \% u2 A! H/ M1 K+ a# bd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以3 M# x9 ]8 r4 f4 B8 v2 j" z0 R
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])5 e& F& c+ q, O" y
res=tu[1][2]['k2'].append('seven')
; A( Y) M' W# \' S; a7 o, h
6 T- C9 h7 N1 {4 E$ `- ?print(tu)- m( s3 i+ ?5 c% X
26、字典, G: U5 c2 ]' E/ i3 u7 }: }9 ^% o& a
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:9 N+ C4 z- t0 `
print(i)b. 请循环输出所有的 value8 x7 M" p8 [  l1 f0 }0 w
for i in dic:3 w5 n3 L5 ]. l+ K  D
print(dic)
' |; s8 [  T- H' z$ Sc. 请循环输出所有的 key 和 valuefor i in dic:0 p5 P4 F: L+ U! y% e& c
print(i,dic)! b9 O1 R# E* Z! ^; f7 ?3 a
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
. s  }' T4 o. t; v" v) W+ E* I0 Adic['k4']='v4') p2 k2 c) m4 g* U8 o
print(dic)
, V! T3 k; ?( M$ K" M" p4 m- a1 ke. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典( ]8 s- ~7 o9 i
dic['k1']='alex'
6 C3 G- I+ Q2 Z5 S) i/ Tprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
; T& L, o# {. }$ q( pdic['k3'].append(44); \* @% N/ V# `1 `
print(dic)
. i& S5 v7 F. ~2 P3 C  a& O4 e* O4 U- j6 v, i
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典4 h9 d+ N& |9 y1 ], `: g3 _
dic['k3'].insert(0,44)5 V' d, |! Q3 |! m3 V' l+ Q! }
print(dic)
: U; q) @$ b! V' j6 J$ p" `9 e27、转换
5 Q4 ~' @/ z& Z( S. D7 D9 z4 G& }a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 q" \- {  ]: J9 y( M1 h; [+ I# d- F: z9 f! ?
print(list(s))b. 将字符串 s = "alex" 转换成元祖
. B& p) C6 c$ U- B; G8 v- f; `s = "alex"% p. Q3 d: M8 W* b' C6 [1 d
print(tuple(s))6 w+ a; r5 m. i0 g
; W0 |- R: ~' ]; Z3 k: \3 l2 A
b. 将列表 li = ["alex", "seven"] 转换成元组
- l3 A  \2 m2 H/ i4 ?, @* ^: sli = ["alex", "seven"]
0 e- h/ M. k! [print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
2 C" m. i$ Y$ ?- Q6 u$ etu = ('Alex', "seven")$ z4 B% i) m- j/ v) `0 G
li=list(tu)
( u( ?* M1 I; q2 H4 M0 L9 A! kprint(li)
" O$ E. ^! ?$ K% Q6 q0 Z; [: F
  n5 e6 J' ^( x1 r
* {% V+ i" J- V6 ], y! sd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增% l! C, _! {: V/ f. v" U

- E  S* S1 D' l7 i2 gdic={}6 [* ~; G% o4 [  U3 q
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
' H# |& ?4 q4 ^  v1 n4 s dic[k]=v
: @/ z/ ~! X) Z' m$ ]9 o, _  c( } print(dic)27、转码n = "老男孩"
0 r+ W7 v/ Y2 w2 ^, pa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"  g9 k! u9 y1 _& K
a=n.encode('utf-8') - K$ w0 p* n* u5 o: _
print(a)
/ p5 R. z# \$ P" ^, a& O  Sb=a.decode('utf-8')4 U. q" w8 M1 f
print(b)
0 J/ s+ ?; p" j% z  p/ X" sb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')0 u: n3 @; y1 [2 [- R9 q
print(a)5 j7 l0 w- Y4 I
b=a.decode('gbk')& E- \3 N+ e" t/ c3 p+ @, T! [. [
print(b)28、求 1-100 内的所有数的和$ R) z% s( n7 C: Q% C' g2 S) c
count=1! p, f$ a( l8 C% H4 @6 A
sum=0
. O4 F/ P0 M% R, m, X! E5 Tfor i in range(100) :
+ Q6 l# H1 R: P" ]7 N, ` sum=sum+count
0 W- h" U/ v7 i: A! ?- D count+=1  S% A! e  S/ ^" z: S+ Q" I
print(sum)
/ y9 ]/ h6 v3 p$ V# q/ K2 z% P1 }) o/ p4 a; J6 R! E
count=1
8 J2 \  \& y6 T; Ssum=0
3 ~9 d" H. E+ ?# |. k/ V( t; Hwhile count<=100 :$ T  `0 S* z) A3 B
sum+=count
4 I$ |* t/ @6 T! x' W0 Z8 i) K$ W, @8 Y count+=1
8 Y* K7 Z: ]  a+ x. y. N+ h. xprint(sum)29、元素分类: j. D3 i' T2 L" a
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，+ Y- Q, z4 I( s  N3 c' ~7 v: F
将小于 66 的值保存至第二个 key 的值中。
, k+ y. J* K! q即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}1 O3 n& Q8 [& e2 m) a. @
li=[11,22,33,44,55,66,77,88,99,90]6 v+ m  D2 h+ h
dic1={
2 V3 C% L% B# C+ W( }& k! k& i* G/ g 'max':[],
/ j; @! H% |" g: f0 c8 F! ?0 Y) ? 'min':[]+ j, p$ p/ h$ L, o
}
( N3 [: F3 z) u# k2 K! ]. u" Yfor i in li :
  b$ h, u8 V( j3 X if i <66 :
9 D7 f0 v! F) L& J5 y( N8 P/ c       dic1['min'].append(i)
" ]# _1 o7 h) b else:' p/ z9 c- s+ ^
      dic1['max'].append(i)3 ^. l( F. i- V1 L' g( r
print(dic1)- s7 C9 f" Q/ w- i; D# I

4 c- s0 z3 x. n5 u7 w+ n---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) {0 i2 Y. ~- w' ?+ q

Python基础知识汇总

主题推荐