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、写代码: e# h1 S/ E3 g2 x, 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) :& A6 V5 r+ d! s: |! P. X
name = input('name:').strip()6 D$ z! V' e: V# r! M
pwd = input('pwd：').strip()6 X$ `/ a4 K+ d8 v2 v. Z- D% y" {: J
( @% L& A$ X8 N& a, }, m' S0 ]' j
if name=='seven' and pwd=='123' :
, d2 H- ^* ~" e7 a) L( e       print('ok')
: i6 a. y8 O" t- A9 F9 Q else:9 T! h5 B3 _- u- i9 m
      print('error')9 i% M" C( R/ Z+ X. G- g
      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)  :
" m2 N& Q+ I0 C" p* L. H2 S name = input('name: ')
' x2 e4 U! _( h4 W pwd = input('pwd: ')
" T. w+ w4 G8 F& Z if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 e# k4 \5 F0 L  ~& O$ y+ D+ X+ c       print('ok')4 s9 V" G: P; S7 C  g
else :1 x1 Q* O& E# s+ q- u  b6 s. ~1 [1 l3 }
      print('error')7 R& s3 p" K% r, N- F
      count+=111、写代码
7 X1 ?$ P8 `) na. 使用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) :. d5 B9 W& [8 D( m; ~4 S
if i %2 != 0 :7 {) t5 W5 N2 G7 e/ 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) :
$ Y4 R7 H- N' S5 H  \  f3 ` if i %2 == 0:' ^  t  J7 c* ]' `& m% ?7 G2 ?" d
      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"
7 W4 k- G- ?* a, f! P) b* Q7 Xa. 移除 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)3 Q3 {7 h! e3 H/ i3 g
for i in name:" l5 z6 A7 ~' d+ o
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
0 J( d2 ~3 L/ g: [" \22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']. t7 l3 K  v# X  i# }" X
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
6 j- \! q3 \- f0 n8 Xprint(li)) W1 p, a( v1 B$ o
['alex', 'eric', 'rain', 'seven']- n+ b" ^1 z5 @5 Q9 Z6 P: y
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. Y  I3 l! M+ i, ~& W0 r' v1 e, Vprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')3 G, e' z; V& x+ u* S0 `$ Z8 ]- e
print(li)
6 I1 o% D2 G3 N- q4 f  q3 ]! [e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; E7 D$ h, e+ s( cli.pop(1)' Z  Y8 {8 [! o6 `
print(li) ['alex', 'rain']
1 B; O6 f% @0 U$ N. Y指名道姓的删除li = ['alex', 'eric', 'rain']
$ A6 |9 |: d* U/ r8 qli.remove('alex')
3 ]$ A: b& V) @: G" D$ c6 nprint(li). \* b; l7 Y& c- \
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']$ [5 _) j% o6 I% P% z7 I
print(li.pop(1))# O) s2 _4 f& r
print(li)) Y; I# l# ?1 d! V) N
4 Y& ^- h& p; c( a7 \
eric2 _9 B7 [, {8 P8 r) p
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: i# G4 e+ Q' R: _0 ?del li[1:]- z) s8 o' p7 {0 f+ A8 E- ~& N
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
/ p' V. K  Z5 C4 _4 {9 Zli = ['alex', 'eric', 'rain']6 p: B9 B5 _( s6 o. A' ?
for k,v in enumerate(li,1):( g1 t( n/ h) u7 K
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ _8 s& ]* W: ?; D* Ma. 请输出 “Kelly”
" \- s! p( v: L) l: x5 Rli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]; I% w9 Q  J$ Z" c, x/ `
print(li[2][1][1]), r5 J9 j: o8 O- r# H
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”# N0 G, r" x9 K2 @2 k
li[2][2]='ALL': J' z, U5 [5 o& E7 }  c
print(li)
, @2 ?, E, ?: I% F9 \4 h24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
) `2 Z/ m7 |9 G3 za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" Q$ ~: ~% i; z# }) lprint(len(tu))
  o2 E+ K+ W5 w0 x9 u+ F& mb. 获取元组的第 2 个元素，并输出0 _  n& l& B' s$ \1 C
print(tu[1])
' U# ?3 N3 ?) ?+ f  b; H  D6 We. 请使用 for、len、range 输出元组的索引' a  F9 F! s* Q" c3 s; g
for i in range(len(tu)) :# I$ d! a- ]" k+ X7 `. U; L5 n
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
- q* `& O& N" o; ?& yfor k,v in enumerate(tu,10) :
0 A3 q5 I5 d7 h. s. n: I print(k,v)
+ X# d; [! N9 \- B, o$ x' B10 alex
( C" f) m6 c! E. A* W$ u11 eric
9 U/ W( C# N8 {( r12 rain
' Z' a  k% p$ V6 c0 B: |) l  D/ A
for k in enumerate(tu,10) :
1 z5 W8 `4 d$ e% C# ~ print(k)
7 N, `2 {9 e% Z) M7 ^% B1 t4 o) q* \(10, 'alex')% Y9 K1 \2 k& v
(11, 'eric')
! m8 S  v+ ?3 O1 s9 L1 ](12, 'rain')
+ F% D) [* d* i- Y9 @3 A! _# H  o/ g& @) T$ q
- W$ u( [8 m' a3 O2 J# U/ J" ~: }3 m/ p
25、有如下变量，请实现要求的功能5 [; M, T3 H" P# F- G+ S# s
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

7 c' e- m, W% _1 z  S* td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以  d/ j, m2 l/ y5 A( c5 M* O2 V0 c' L
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
; Y1 W' O8 G; Yres=tu[1][2]['k2'].append('seven')
8 Y7 g5 \3 H6 r
  J7 j' b+ X; K: ^1 pprint(tu)
, {* ?. D* E  G& k+ D26、字典1 e/ E. S. f) |& W- l3 }, d" L
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:: ^- C" ^( h* @, A5 i9 K# G  r
print(i)b. 请循环输出所有的 value" v. c' E7 i9 D* [1 W) ]
for i in dic:- W, z2 ?  U7 L0 m! K6 i
print(dic); `4 w! E  R" U3 `/ B% r: G2 m, y
c. 请循环输出所有的 key 和 valuefor i in dic:
- u! n8 n' K2 aprint(i,dic)* x, _9 Q' F( k+ v$ r. W( V# y2 Q
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
) P3 X. R/ o5 n9 Vdic['k4']='v4'
3 U+ c) ~8 K0 |) \0 nprint(dic)( p( R; e5 p: g; z8 a" |; X
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典" J  l0 M. x& L. c& L: p2 n, ~( o
dic['k1']='alex'
# v- w' T$ W1 p7 c1 tprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. r, ]& o' ]) u+ c
dic['k3'].append(44)0 C, C8 d9 n4 _. p$ e6 R( F8 g5 I
print(dic)' |& D, r8 }; J7 f/ `: z3 y

% ^, I2 C4 }, y/ {1 y/ Mg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
) K  D& `$ o0 J- Y" ~dic['k3'].insert(0,44)$ g. ^, O. T) w' l* G
print(dic)
- m! W" q! c0 N' p9 h+ x27、转换& K* G  }9 V/ S: z9 z
a. 将字符串 s = "alex" 转换成列表  s = "alex"
, l# M0 @9 N7 d4 ?& [7 a4 B* z" j7 ?
* J" K8 c1 {: r6 V$ @5 Y* O0 X1 |print(list(s))b. 将字符串 s = "alex" 转换成元祖+ X8 X/ A4 G. y, p) g" A; a/ k
s = "alex"
; |" A6 f& d6 b5 L) W3 d6 uprint(tuple(s))$ y# \& \+ H: a0 s" u; ?- |

/ v* `+ k+ G9 ^9 w3 _4 Zb. 将列表 li = ["alex", "seven"] 转换成元组4 n9 ]; [, n# d; R& i! x4 n# `
li = ["alex", "seven"]7 }! ~) ?% N; e5 Y# ]5 J
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表0 o, `  v6 Z* _' [/ o
tu = ('Alex', "seven")( j" U! f4 j: \) j) Z: w8 X
li=list(tu), K2 w0 L' L' w" ]4 q  u. S) z
print(li)
# L* u. |5 h  D* p- G/ ^
! N1 q$ U; z7 W; V; ]! L; B* t. O/ W% d; w+ w
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
. l5 V! t$ b% n
. a; x* ~! u  b) w+ N  S6 Qdic={}
8 O5 w, p6 H1 d( [2 s1 m3 ~& Ufor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: I+ J  X! U, `8 _# a dic[k]=v
4 Y8 ^4 o4 w" z; A/ X  `9 g print(dic)27、转码n = "老男孩"; L. v9 F0 l& ]3 I' J. E
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
% [( `; l( C1 M% w% F3 v; Na=n.encode('utf-8')
2 ^5 k$ C% L; N1 Fprint(a)) k( C/ b3 p: G& W, k- b2 r' ^
b=a.decode('utf-8')
7 B4 R1 p, j" vprint(b)
& i& K- {; ^3 K/ Sb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 }1 z! b5 m, D/ q& {3 G) ]
print(a)
) ^' o$ |) H6 |' ?' B: mb=a.decode('gbk')" y+ l8 M- @+ r# X6 M  E7 Z) D
print(b)28、求 1-100 内的所有数的和3 V" G, a( o% r1 z
count=1* H1 \- O8 w6 O3 B
sum=0
% k1 H1 [  \4 }+ Pfor i in range(100) :
5 g$ L# V7 h% c- @7 p9 J sum=sum+count4 v, d' k! l1 W
count+=11 {4 _3 A" G; ^# l6 [6 x
print(sum)
& }8 T) ~; p$ e
7 z: v. A2 h8 xcount=1  |4 S' t, O4 K. x+ S7 M) D0 ^
sum=0( E0 G# x; N$ t: z
while count<=100 :
+ p1 k& v7 Z5 K) D8 L sum+=count2 l; q. w9 o" b' Z9 x& T( e7 h
count+=14 X2 @( n& t8 I& O$ V' h
print(sum)29、元素分类! d2 p1 g+ F2 Y2 h) R9 X7 s0 h* q
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，8 n8 _9 C9 @# s! j3 \. n% L
将小于 66 的值保存至第二个 key 的值中。
$ h3 P, q- }* X) H即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) {0 `& h$ t! W  H
li=[11,22,33,44,55,66,77,88,99,90]
) X5 D+ `) V% p* ~% f. Zdic1={
# F  Y5 n0 n) ?2 U% A 'max':[],/ J1 C% s, d2 m& |8 J: K0 h
'min':[]6 ~  }; e' o* h1 }+ h. {% w( {
}
* ]7 w$ Y5 v- [9 L9 k# m1 xfor i in li :& C. q2 D4 V. }5 B) u8 g
if i <66 :
% ]: S6 i! w0 _( K       dic1['min'].append(i)0 O9 y4 C5 A& i9 A0 z
else:# p# x4 n0 y5 z3 @3 O; b
      dic1['max'].append(i)
  o" z! v  A1 i" l, |3 \print(dic1)
& L- y% g! K8 ]/ o7 M" |7 H) d' q
& Z9 p9 r) E4 h! |& ^. m---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}1 o  g2 [+ r& R+ s& B' {$ d

Python基础知识汇总

主题推荐