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、写代码5 J. I% i% Q& C3 p" T
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) :
6 ]% |( O2 {. H7 o0 K: J name = input('name:').strip()' k' B, e1 t) `7 ?6 ^3 k# `
pwd = input('pwd：').strip()  G+ z8 l5 r( T+ K; a/ Q" P

7 K! C/ h5 J7 G5 U. ^2 F if name=='seven' and pwd=='123' :
4 y. u& |4 y! h# V8 Z6 H       print('ok')- X3 Y4 ^- j4 \! j
else:
# w8 B& J- e5 U2 O& s; e       print('error'), z2 l6 G5 ~. y( l3 [
      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 b( r$ o4 A, M9 C& h1 S
name = input('name: ')# n) Y2 ]$ \& P1 Q
pwd = input('pwd: ')3 ^  j8 ?. d4 \9 g4 D
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':# o! Y3 _! c% I' o" J  h, z
      print('ok')
! j' e% a1 |% L else :" g! Q# x4 p; Q2 }
      print('error')7 @  n0 c, A$ J  Q' p% B4 U- |
      count+=111、写代码! j  t# ~% K& v* S
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) :
& ^* ]/ d9 w( q7 H& V# B# [ if i %2 != 0 :
; |, J$ B4 J9 Y: @! I' y9 U       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
' P2 o, H8 Y/ X if i %2 == 0:
, L4 S6 V9 S3 J8 m( 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"6 v% X& `! p4 ~  ?/ N1 E$ J
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* J7 p& S1 G' T2 ~for i in name:, P; h7 \8 W* K3 l  \( m; g; c
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain( f# R+ {. ^! U& d7 t/ }- e
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']7 ]3 O8 ?! d9 o* x$ U) h
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    5 D* k+ B! `4 x/ D. R+ @( i& h
print(li)
3 q! z* s6 r8 v4 O ['alex', 'eric', 'rain', 'seven']
6 K$ g1 \: y6 r# g9 Cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 k# X* u( v2 p" Xprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
1 \; G8 p/ z1 I0 W$ F4 [print(li)5 x: O) Z  {  X% X6 {9 h$ }
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain'], ]5 W9 O. \1 s) ?# S* E
li.pop(1)
* H/ y( `* |/ X2 Cprint(li) ['alex', 'rain']4 f% T6 o5 x6 G, ^
指名道姓的删除li = ['alex', 'eric', 'rain']
& @$ s: C" m' V' Y% Bli.remove('alex')
- s; z0 d% L7 N1 A6 m: H1 qprint(li)
4 [/ y# q3 v5 v9 j' Q$ |f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
3 k' p0 H7 ^. i! V2 P' B2 Nprint(li.pop(1))
7 F3 t3 l' p6 R2 `print(li)8 [  x& p5 x- z

1 E; t' R' {, y9 Z4 deric
) p8 Z  h! S6 r$ z: o5 ]['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
' O# c/ |6 |' Q- m, |del li[1:]
9 G9 {! O& q0 kprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
; t9 w; D0 ?3 Qli = ['alex', 'eric', 'rain']6 I4 B% ^& F  p2 C# e8 r
for k,v in enumerate(li,1):+ X+ l( t6 X/ r9 l/ c/ ]
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 `* |1 H0 @& L. F/ Za. 请输出 “Kelly”  I$ |. H' c5 ?# S
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 i8 C! Y; o4 E/ Y' [+ @% U/ Nprint(li[2][1][1])
! {0 Q! l' J+ u8 m$ J/ hb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
( [& {3 h, K' k( p" M) Nli[2][2]='ALL'; ?0 K/ O( Y+ v$ u/ N
print(li)
" S* `& s" M. {! t24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'), `0 r$ o' Q2 p4 q% c: L1 S
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')6 y. z; b: y" p' k
print(len(tu))4 B" k7 z+ ^* E  `% o
b. 获取元组的第 2 个元素，并输出" s6 a" n7 _! q' F, W; n9 ^
print(tu[1])2 X. k9 ~8 e% B
e. 请使用 for、len、range 输出元组的索引; S7 y$ E# d5 v0 L
for i in range(len(tu)) :" R" m+ A' S- l! |, ^0 I
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)2 G9 o: ^  o; h) d) D" Z4 K/ P
for k,v in enumerate(tu,10) :
/ a1 [: f1 a' H( Q" z: z! R4 } print(k,v)5 j2 S+ n# f$ U0 L
10 alex
1 @& p# B# F! T1 T8 A11 eric
: F9 C+ ~2 a  n' n0 [12 rain& j; P  @" N1 u# W- [0 B- T

; M3 X" Y7 G* Q4 w8 afor k in enumerate(tu,10) :3 ?. n! U. v( y; D
print(k)
- j3 l! _# Y: v& T$ }0 H1 G(10, 'alex')% q& {1 Q0 T% d
(11, 'eric')
1 X  ^- l( @5 c  [- k(12, 'rain')' b2 e  C& S* k

( @% h1 B# \5 _* @
# F9 U; G' y4 h25、有如下变量，请实现要求的功能4 O# |  `8 E1 H* O* k
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
: e& J- x9 y. ]" ]6 _: Z
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以$ c* Y; N7 p1 X) r  [
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
8 w* D2 r, Y) F3 Z7 {9 G( G7 gres=tu[1][2]['k2'].append('seven')
  v/ P. b; @% C- O  i+ L) V- ^- Z. V! r& Z
print(tu)
. a0 t5 z' \: u5 F* q' C+ `) k26、字典
% `: \& d* H6 i# odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:9 _. u3 h  u, [# x7 x9 v
print(i)b. 请循环输出所有的 value' f: O: ]+ ~6 N* @; K
for i in dic:# f2 K- {3 |7 o, s- ~# n) O$ p
print(dic)& D  B) d3 {8 C  n4 v! Q
c. 请循环输出所有的 key 和 valuefor i in dic:
4 {4 f  `  v" C9 H0 b% ^" v- f$ oprint(i,dic)9 O1 l/ J; s) j7 Y$ q4 `4 r
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典* Z) h7 e% y5 ?, E: E1 m- w
dic['k4']='v4'! y- X' Z# ^: o) k! d* r' ]
print(dic)
! a9 B& [; U+ je. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典* v8 o0 J& y8 `3 l
dic['k1']='alex'
5 r8 ^& E1 f8 F( [+ hprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
1 H# I& l6 x. f% Udic['k3'].append(44): d( D  J( h/ T# D! o
print(dic)
% D$ x$ \+ c7 Y8 E+ G
  y* c1 y- `( g( }0 a4 t( A5 Gg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( x% f* `6 B( n- }5 g, P) jdic['k3'].insert(0,44)' J% j  p/ l. K' k! ^& W4 Q8 H
print(dic)
6 L0 n0 f+ V: a. M27、转换2 w) z9 _- E- R3 P& f: S3 U2 }
a. 将字符串 s = "alex" 转换成列表  s = "alex"
7 z& D) f/ m: ^" A6 T/ h% H0 N0 z' H2 a# b9 B- I
print(list(s))b. 将字符串 s = "alex" 转换成元祖$ N0 M6 @( V* X+ ?; U& T
s = "alex"
- C% k7 q7 R' U8 v* a' [print(tuple(s)), D" t9 m3 S6 [* V: f

. k. x9 `' K7 z2 X: n1 ?b. 将列表 li = ["alex", "seven"] 转换成元组
0 B) W) c2 m6 E; mli = ["alex", "seven"]
5 ^* Y# O5 a, Y6 \9 A8 Vprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表% ], T# v; n6 K1 I$ p. e7 o" k6 J
tu = ('Alex', "seven")7 W0 s5 s+ ^$ Q; L4 ^; c& N3 A
li=list(tu)( J3 g: ?0 g: n$ C% Z/ f
print(li)5 G- s3 C9 S9 |/ K! U2 f. s
6 C, u3 s; P8 ?

. |. b& |2 ^$ j6 qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增3 H9 ]2 ]+ S3 a6 ^
/ T& E8 k1 b: z  k( V
dic={}' y& l* `, G$ k3 Z' f7 x4 a, t5 G: U" Y
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面- \9 }6 d3 [  t) s" t
dic[k]=v
: h0 ?4 [: U. q- e. A4 o print(dic)27、转码n = "老男孩"
% n/ o, z# B. s# va. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"# s% z  t: w" t; r* p7 X8 L
a=n.encode('utf-8') 2 w. Z+ y* m; j
print(a)* R* Q' O! P; f* A
b=a.decode('utf-8'). f' ?# ~! B6 m$ K3 w' X' }
print(b)
) M8 j5 |* j0 `  V$ Vb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')! t5 j4 M3 N4 n9 G. b* z! W
print(a)& W4 P( N; t% l
b=a.decode('gbk')
( r# I0 h0 q* _' R' ?% Z- {print(b)28、求 1-100 内的所有数的和. J3 s$ Q, u( ^2 w- o' z
count=1+ ?, \( i% w* |' @' D& ?
sum=04 A$ G7 D$ t- s4 K9 {( Y6 B! j
for i in range(100) :  o- }7 U1 I! q  X; w3 i0 E
sum=sum+count( [6 K  Z/ S2 R8 L; I
count+=1
6 }. S; D! A/ G4 l4 i6 aprint(sum)
( K" {0 T+ e% @. g# b$ `, q3 G& ?2 s4 c, |6 I. n
count=1+ W# V, E7 N( C0 ?+ c8 O
sum=0
- n, q. U1 X$ X1 ^# pwhile count<=100 :1 K) k6 T5 R& K7 m8 Q; Y
sum+=count
( S9 n8 Q! I' D" K6 U8 P6 w) q count+=1
* d+ W! y+ Z& j) L/ sprint(sum)29、元素分类  @& n. q9 W) M+ V2 V
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，+ H. z3 w, a6 ]" i& `8 D$ z' p
将小于 66 的值保存至第二个 key 的值中。
: ]2 z$ i" C" c* A8 e即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}# J. X' E' F2 d0 Y8 i( R8 ~
li=[11,22,33,44,55,66,77,88,99,90]" h: v, i3 Y2 m  E
dic1={1 @" W. s2 x" c5 H
'max':[],' L* A4 e- I6 y; [$ E( Z' z& S  y
'min':[]& k# `3 Q5 Y0 q+ t- J# s1 U
}5 X: R2 d4 d( P2 g; Y
for i in li :9 H0 s0 |3 B$ Q0 F
if i <66 :
0 m9 e6 l7 ?, E5 g" s, i       dic1['min'].append(i)4 Q) g0 o' r6 K0 N
else:
- r& k0 C4 D/ d2 [       dic1['max'].append(i)* G; t* `  T7 j( \1 [) v
print(dic1)  ~/ w6 X! T; x( m
% [3 j2 e- j$ c8 ]' K
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
- p: F5 O5 K5 _

Python基础知识汇总

主题推荐