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、写代码
% A7 E5 V3 {8 q) L! ma.实现用户输入用户名和密码，当用户名为 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) :
" W$ o5 X8 m& b$ i name = input('name:').strip()$ Q5 s8 L. k0 G+ y& k' F
pwd = input('pwd：').strip()* j" n) [8 e7 ]; b
$ i/ l2 w- m* Q5 [) N
if name=='seven' and pwd=='123' :
0 k+ g$ K5 T2 g! M" g! H       print('ok')
/ j4 `+ ?: ~# Z5 J& i* L else:
, s! A& k( a3 }  ^       print('error')
- |* m- W  H" _; m, C# M       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)  :1 Y+ c& w5 s* g: t3 i
name = input('name: ')
1 p, `9 q' U* J  l pwd = input('pwd: '): ]- c2 z# J& s1 n4 \# H
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
! s7 L# b( K/ |0 z$ [) q       print('ok')
# y0 D& b& P% P) P# B8 M else :- \$ u4 L/ X# w$ v  e
      print('error')
# f& E5 b$ i& p3 ?- `       count+=111、写代码
% H. c9 u" N$ I7 i" L6 A6 {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 z  Z8 k! @ if i %2 != 0 :) ~8 g) [$ P3 Q; j' T& W
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :8 l7 I1 _6 W6 D- K- I$ b, G
if i %2 == 0:
) p3 P* ~, 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"3 g" X" P7 P+ Z
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, a; R  L6 s  r( a; mfor i in name:
# M2 Z& H5 j6 [ print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
% J* q; S, X' G1 W* m. E22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']* u( ]; v2 ^6 K( a( J3 y- }) ?
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
( j  X! L9 J0 |0 b. eprint(li)
5 v, |! T6 _) ?- S4 x7 I5 R$ L$ ~  j ['alex', 'eric', 'rain', 'seven']* H- m1 o. C7 M
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')* K- p+ q$ S3 l7 Z
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')# n5 b1 c: w6 N0 I
print(li)
5 ^1 \8 [$ S3 L/ se. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
& N/ {5 I4 v8 eli.pop(1)
! |* w; Y, B/ L9 R9 o% n" J7 d  z- uprint(li) ['alex', 'rain']
3 B% o+ T( d4 x5 N% L' Z指名道姓的删除li = ['alex', 'eric', 'rain']+ G: W7 S- z1 B( _. \$ q
li.remove('alex')
+ B+ k1 q( Z, t7 tprint(li)
$ t8 L1 u- `; q* B8 D/ K* Ff. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']$ M+ M8 E& N/ R8 D6 Q
print(li.pop(1))
$ a$ [/ P, V7 t6 Z, G& hprint(li)
0 p1 k5 a. x4 F2 K5 E; H% |8 `" h& c8 N+ M. j- h; q
eric8 T# p; D) W. E% D/ I3 v
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']# F; W/ P$ s, M6 j5 f
del li[1:]
2 u7 h, y+ r# {+ G' Z  u% Pprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
0 ?- s( E" b4 R- U5 m# I: {/ \li = ['alex', 'eric', 'rain']
; M& G. ~1 I( b! t. r! b, ifor k,v in enumerate(li,1):: ]" {- b& w/ v& o6 I3 X/ e% ]; g' v0 u
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  R% b$ g; A! h4 B$ O- Ua. 请输出 “Kelly”
# T) m1 [  v: `4 g8 Z2 Ali = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  `# W8 e3 y" A2 n6 a  E+ }
print(li[2][1][1])
2 m5 E& ]% G6 w# pb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
3 y( p2 r: P% m4 lli[2][2]='ALL'' U  l) c- R* p. R
print(li)
( y; B8 R9 ?/ G24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
4 a4 [. {" p+ y. s7 D2 pa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
. N5 `5 L  p! R' S' k8 Qprint(len(tu))7 S, m0 z8 J' E% W/ C
b. 获取元组的第 2 个元素，并输出
; j' y7 F& ~, B% G2 Oprint(tu[1])5 W4 Q! U. ^" r2 N
e. 请使用 for、len、range 输出元组的索引
4 W" ?( r4 F0 b1 F/ q" Cfor i in range(len(tu)) :
) u/ p, A  K( s+ K: e# F print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
) Z; W8 a$ V' ]* _- ffor k,v in enumerate(tu,10) :
2 i. l4 R) i* Y# h& D/ | print(k,v)
' T  t0 j% o& X% y0 r10 alex! Y0 m8 m3 I  K- K4 ^# O
11 eric* J  e' Z! K# }- ?- q  S2 l
12 rain
% a5 C9 E% o. @, m3 {! t  u! F$ {" a4 Y- `- A& o( f0 Q* i; ^
for k in enumerate(tu,10) :% Y" S& ~; B0 m
print(k)
: N$ X2 c; w. H9 M2 K1 C. ^: [& d0 i; X(10, 'alex')
1 ^% a/ s2 O0 B- ?6 w4 b! e(11, 'eric')
+ X+ }, `4 C$ D(12, 'rain'): k, R! Q( J: k8 d
. K8 t7 s0 r  e& k8 I2 a
5 A" b4 Y/ C8 S8 v  U3 ^" K4 i
25、有如下变量，请实现要求的功能
2 l# L1 G5 Q* Itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

6 v" h5 j9 V0 q3 Jd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以$ h$ B4 a- K7 [+ K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 j5 n1 t- L4 |; ures=tu[1][2]['k2'].append('seven')+ L/ d; h& I" ^/ v( v: {

. p3 P4 {: u! [5 K5 p  lprint(tu)
9 }/ j6 [0 K/ j7 s/ }26、字典) |4 M$ Y7 ?! O2 T4 E1 u! D, e
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:1 ^" G' k6 d% J: c4 Q
print(i)b. 请循环输出所有的 value
) ]8 n+ y$ Z! A8 d' Lfor i in dic:+ o; w6 \! n- [) Y* f* a
print(dic)- Q3 H# @1 y0 [4 a: |$ c1 b
c. 请循环输出所有的 key 和 valuefor i in dic:
& H: d7 _9 O$ ~& gprint(i,dic)
* G! d: D" \; [0 {6 t7 [% K& O7 Jd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
) r* T# h/ c/ j/ V- t* E- }) gdic['k4']='v4'( B4 t7 N0 C! @# M" m6 V
print(dic)
! T( V; |6 L. \, n; S6 ]7 q) N: F/ Ze. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
5 R9 n) c: P. Gdic['k1']='alex'
' U" h& L% p# o: K: gprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典# j" M# d4 K% ^9 L. u2 d
dic['k3'].append(44)
0 f( z9 G1 J4 }8 }) hprint(dic)
1 Z+ W2 C7 _4 _- b& U0 X
) T! ^$ F6 H/ a* J; Qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
- [2 S7 O, {( o- Y9 Q* w3 D4 U( sdic['k3'].insert(0,44)( F5 `) X+ A" W! J  U% ~* Z8 M4 j5 C! f
print(dic)
! R, ~* N4 m/ ?# d27、转换; ~9 w/ _, ^, M+ @0 @7 S
a. 将字符串 s = "alex" 转换成列表  s = "alex". V* a' j4 l2 N: x

$ h% C3 K. r3 [# R" Y6 i. C2 R/ wprint(list(s))b. 将字符串 s = "alex" 转换成元祖' m$ I4 E) A! D# K
s = "alex"
$ z7 S  A2 N% e3 d8 x; \* jprint(tuple(s))- l* @) k+ r# Y$ Z- P+ r3 }/ a8 C0 c
7 z. o1 `" v6 P; Y! }! Q
b. 将列表 li = ["alex", "seven"] 转换成元组- r, G3 _$ \5 n+ k! K
li = ["alex", "seven"]& E0 i6 T$ K! r) H, [9 u
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表/ }' y' b! @/ O7 K$ d2 C$ h
tu = ('Alex', "seven")4 F2 t3 G" F( V. D9 s6 x
li=list(tu)
$ o2 n; h% B: \print(li)% o/ B0 W0 e6 r+ Z5 _

3 q8 z* J, Z2 K! S! [
8 R" x4 I. Z& ^8 f- |d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增/ q2 g8 M; v+ i% o  t

9 R+ r$ Y; `1 `9 O% t9 |dic={}) {+ O( K( h! f
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# T, w0 g5 k( K dic[k]=v( M0 s, Y7 J* w! R( ~
print(dic)27、转码n = "老男孩"" e" u- ~0 }0 }) f
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
. l! A  I! j2 ?a=n.encode('utf-8')
/ q! ^2 `2 ~. vprint(a)+ T: v; G# J/ P$ K( m$ w# }
b=a.decode('utf-8')
( ^9 P, S' ^) J5 T3 y# h% i" h. Gprint(b)
6 a* Z" S) d  ^2 ~! D8 h6 gb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')) U& K2 y4 L7 j6 ~1 }9 y- F
print(a)
2 F' {$ e4 T% j. ub=a.decode('gbk')3 l# T; K& A6 [4 i* [" H
print(b)28、求 1-100 内的所有数的和& n/ j- k1 e* m  [6 b0 N
count=1' P; s# h9 v5 a; X: `! w% _
sum=0% I& N8 b8 s3 \4 k3 I& V
for i in range(100) :
3 D0 z$ i& P. h sum=sum+count, V6 U2 {) r# g" x. Y+ @  Q
count+=1
1 G4 E0 |( ^; B. y3 Pprint(sum)+ A# _& ?- S) C% E$ ]. d

) O, k" R. b  w3 `count=1
- w0 f6 g/ Q' A0 b3 [" Psum=0
% M. O' A  w6 x: E  Ywhile count<=100 :
7 p4 u) |; g& v# W8 ` sum+=count
- Q$ n2 y  i1 x count+=1
. `& M" g5 b4 m6 i2 V0 Cprint(sum)29、元素分类" ^% C& F, r8 M9 H2 w6 g! J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
9 p! t3 v3 i7 |9 v" O将小于 66 的值保存至第二个 key 的值中。
. ^( y. ]' [7 _) A* w& X0 c) p即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) U" w5 A0 U4 `; g- u
li=[11,22,33,44,55,66,77,88,99,90]4 `; v/ a& l" |0 [5 G& s9 A- R
dic1={0 v  C* B5 ^  D: R& P' A( G
'max':[],% K% f& |1 t7 ^' P" A5 I: N
'min':[]
# L) g2 d/ g7 f% G1 o+ `}6 e7 v. p6 ]/ O  A
for i in li :3 r- ]6 _! W. Q9 ]# K, B0 T* |7 p
if i <66 :7 T  s7 Y; X/ |3 i1 d
      dic1['min'].append(i)" g1 \# Y5 a2 O
else:
; h9 l2 a, |6 F+ i- A) d       dic1['max'].append(i)+ b$ E' o0 }7 Z6 G8 Z% Y
print(dic1): o% i/ f, Q5 H- X

2 u0 f& J) O. O! T---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}  r1 g, K/ \, Z1 j/ j

Python基础知识汇总

主题推荐