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、写代码
* S! [2 b* c% A# P/ K7 ja.实现用户输入用户名和密码，当用户名为 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) :
$ f2 u( t  N8 ^ name = input('name:').strip()
( r7 E, }- ~5 {  c pwd = input('pwd：').strip()0 r  Y8 Z1 y4 a8 w# _+ P9 H

+ \) f( \  E1 ] if name=='seven' and pwd=='123' :8 n* k+ x6 ^+ _  y% l) q3 [
      print('ok')  [, Y* o  X6 r( U6 M# G/ t
else:
7 }0 v7 n/ e- t. Y5 B  f       print('error'); Q7 E0 I% C2 n. |: I
      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)  :' B% ]+ L, y; B3 j' w
name = input('name: ')4 o( e( {& U; b5 B7 J
pwd = input('pwd: ')0 G; \# L% ~1 n7 h$ H) L8 S5 z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':* x$ o+ [8 b9 P5 Y+ U8 B
      print('ok')- d# }# D  j7 e; ^$ Z; R3 C
else :
% |: s9 c8 z% e9 o# Y       print('error')
4 G+ B* d: ?- i& F/ Z4 w  C, u& S6 H       count+=111、写代码6 Y* R. R) ~: y- N) l' U7 |
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) :
! M( k1 V' b, Q" l7 D; W- Q if i %2 != 0 :* t; M" e5 b3 G  D' q& }. Z
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
/ o: P8 U& a; ~+ e0 \" x+ [ if i %2 == 0:
4 C( ]; K. @* u$ Y       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"
- h7 s. }; c5 Q2 L8 n8 Q5 sa. 移除 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)
( Q4 V5 e2 t2 T. e6 b) Jfor i in name:1 {: e: s0 l5 ^! }4 V
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
! r# X: [2 g5 P  _: X& i) o22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
% p) J( k( k* g% K9 Z! |print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
# V. v3 V, x9 m+ V! u) \; rprint(li), n0 U' B; B2 z' @
['alex', 'eric', 'rain', 'seven']- h: Q* v2 C' e4 L3 A  Q
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'); _( W) X3 |' j
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')* J3 o: v+ n0 H9 r5 i
print(li)% _7 ]0 i, c2 w
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
  E( i! m$ e. d& Qli.pop(1)
- A1 w6 Z3 O, y4 n0 O2 _print(li) ['alex', 'rain']
2 k, n  x, R& M指名道姓的删除li = ['alex', 'eric', 'rain']
2 V9 K# e: I" I! Uli.remove('alex')0 Z: W" C. Q* p  T+ o: O
print(li)
( v7 j  H+ a& Z" rf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
+ M3 n5 K6 I9 r/ fprint(li.pop(1)), J. Y* o/ h3 s) J+ E0 f! P/ z
print(li)- H% O+ q. o) X  K" R4 i" s8 t$ n
( x7 ?4 b( j% X
eric% Z$ s1 n4 Y8 C8 ?
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
0 b' [  T* |* f2 ?$ Q" j0 sdel li[1:]
4 G# [; G& W( ^% e1 U/ b+ p7 [print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
- n/ ?2 m5 l) a" t7 ali = ['alex', 'eric', 'rain']# r* j/ b3 p, x5 M+ a& d9 Q* s
for k,v in enumerate(li,1):' u; i4 H9 U6 ~. q
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& o0 U$ N- d. ~; C. Ga. 请输出 “Kelly”
4 D9 P* q5 |7 V# eli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 L( e' R9 C3 w2 f" ]
print(li[2][1][1])
1 `8 E! _+ b) J0 }0 x  w$ yb. 请使用索引找到 'all' 元素并将其修改为 “ALL”0 m5 a/ r9 f/ {) k0 U: l' t
li[2][2]='ALL'
4 I8 L  `7 b% ~. Q. k* hprint(li)
9 S& V* Z3 V' b7 M4 ~+ N( W  ~- P24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')1 e& g- X+ r# W# a
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')! y, M: ]; n" b8 X0 f# h& ~
print(len(tu))" ?: }6 z' Z$ K( E" Q6 O' {! G
b. 获取元组的第 2 个元素，并输出8 c1 O3 \/ v3 E
print(tu[1])6 V& x# {6 |) N: m, ^: E# @
e. 请使用 for、len、range 输出元组的索引# m% z" `/ M, }+ Q; s5 N  r
for i in range(len(tu)) :% L1 C' D: C4 m% Q! U7 Y) R
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
- S# u' r- u4 p! K0 rfor k,v in enumerate(tu,10) :$ F# G2 O- Q% L# V
print(k,v)9 t7 ~$ O2 m# _( z
10 alex) W. K+ i# n2 y" c
11 eric" y  U$ w9 E' a$ v6 t- E8 v
12 rain+ A3 a7 x- J* `$ ?7 M) {, w
! ~# d8 t& k. a! Z7 ^, c/ a
for k in enumerate(tu,10) :
8 Z$ w0 ~1 s7 J print(k)
. o5 O' j8 F9 S* M(10, 'alex')
8 B$ t$ j+ y# ]; ~" R4 _(11, 'eric'); [( U1 r4 D7 A2 I; q! B- c- h
(12, 'rain')
& |" h! |! V2 ]
0 b: j- s3 [- q3 v  M5 {% k, P+ _$ b$ J* _% ^, z
25、有如下变量，请实现要求的功能
! ]9 t+ E5 W+ D1 T5 [tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

0 q1 Z( _4 Y% O* n. B; k! Rd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
' c+ n% R5 R$ Utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])# a' N6 ?- j: J. _! z* ^0 F
res=tu[1][2]['k2'].append('seven')
. f/ A/ p6 @2 m, W3 I% |0 j- `% ~/ ~' T9 s3 E6 E5 N& W# g6 e
print(tu)  K% V. j! L8 T, S3 L% Z5 Z5 U
26、字典
$ H8 P9 C, d: edic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# c; T3 Z: r5 A& K( A( J print(i)b. 请循环输出所有的 value3 n2 C: K3 y0 v# z- K
for i in dic:
5 O4 a& m9 E; c  m. i! J, l print(dic), Y, n4 K$ |+ Y: _2 c" n, d
c. 请循环输出所有的 key 和 valuefor i in dic:
" b! Z9 V3 Y2 |2 Zprint(i,dic)' C( y/ B/ a/ r9 N0 s
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
1 S7 A; n! e# r0 p% |dic['k4']='v4'
- o; o8 c) u9 |9 T" `" ~print(dic)" ]- m8 l$ P8 R0 a
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
3 h/ f2 T- ~0 C) bdic['k1']='alex'# G7 D. m+ C+ P" D
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& q& n& E( n6 k1 a# p7 |( g2 W; B+ tdic['k3'].append(44)
) m$ X$ A$ ?7 X7 d0 tprint(dic)9 D* q0 \+ E$ X' i; _, f& R0 N
% n$ T) t; [9 J  Z4 L
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% O% T( t: b8 R& H6 @# Adic['k3'].insert(0,44)% d7 O/ R4 z, T: y# ]% F0 [0 g
print(dic)
" L- l# `6 k0 p: p27、转换& O  Z9 }: W' w( l2 q* o; D" I8 `
a. 将字符串 s = "alex" 转换成列表  s = "alex") M. k$ X- h- Q3 @. S: R! H5 k- l

, Q# k' q7 V8 m  L2 Eprint(list(s))b. 将字符串 s = "alex" 转换成元祖
" I0 @  r1 x3 Xs = "alex"
/ i! A' d' ~, `+ F/ q, o, I& d& ?print(tuple(s))/ h" F: {6 M+ o3 d6 P8 f

, ^) b' m3 {. J' Bb. 将列表 li = ["alex", "seven"] 转换成元组, l9 ~% n6 K1 w7 J6 [+ o
li = ["alex", "seven"]
- {4 S$ M% y% b2 I, _  [: sprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表' T+ Y9 f- a4 m9 R% S* q
tu = ('Alex', "seven")1 W  V2 u( |6 l
li=list(tu)
8 J! n& W( n$ e' ]9 Z6 e3 n2 [: G5 jprint(li)* ?, B# F  U7 I4 q' j* K

2 G8 a4 G3 H* e, h/ j/ ]$ M# ?* a
) B' @+ d' N$ [& P& Y' }8 k' {d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增. C- ^3 X, q' C% V# g* b0 U

: h$ O" i5 a' f& w6 Odic={}' ]6 `1 w6 p4 p+ S
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面3 i9 l" b' `0 H: L
dic[k]=v
6 h7 W4 ]- G3 }2 E$ } print(dic)27、转码n = "老男孩"
  Q0 K* {9 ]7 V+ p3 E$ Oa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
. D1 H' J2 U! r; c# ?) H; ca=n.encode('utf-8') & Y9 W! B2 t. A1 `: j/ I3 Z
print(a)) L* F* t+ i" b1 v! n
b=a.decode('utf-8')  T9 o( W8 _0 j# K% u7 t
print(b)
$ ^4 O) ~8 l  y% `/ ~b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 s. l( Q" o! m- T! m- Q
print(a)
8 C3 E* a2 A! |9 z2 pb=a.decode('gbk')
: |) K. z! R' Xprint(b)28、求 1-100 内的所有数的和" J" r6 I$ j, r! V( E
count=18 @; B! a  ?  _
sum=06 w! T6 b4 l0 ~# K4 T4 u
for i in range(100) :( \1 h% \4 e+ D7 n. M
sum=sum+count  ?  M) t9 r/ T" Q
count+=1
5 Q) h$ M9 @* H; ~9 d: r( ^- kprint(sum); i8 x6 [2 b6 [# }6 w; H" D, ]. w
4 I& }* A* q0 B# B
count=1# ^' s& q9 S7 d; p
sum=08 s1 G7 X$ X( N# e
while count<=100 :  B3 k- i9 `. T6 c
sum+=count2 i! g2 V' ?- D. Y! K* {; S
count+=1
1 E3 Z5 E) c8 Y7 a8 X/ u0 J% Bprint(sum)29、元素分类, x) L( a% r9 z8 Q! z' p* e* e" b: d2 ^* _
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，2 K9 C5 N5 W" u0 K' Z
将小于 66 的值保存至第二个 key 的值中。/ q* X$ X8 d* U; \* W
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; ]: u8 j+ e/ I" ^- {li=[11,22,33,44,55,66,77,88,99,90]6 n3 r# H* E  @
dic1={0 f+ p0 p! u7 s4 p. J
'max':[],
7 A3 l$ B! H3 H- M) @- I 'min':[]
7 m$ H/ p2 O: |" }}, b4 r* ~/ ~; e* W5 I  J
for i in li :
# c. U& f5 R. b) {* R if i <66 :
+ F$ B$ e/ s+ ^/ Z4 ~       dic1['min'].append(i), ]- O: F$ I, R, X9 J
else:
: G2 l8 ^5 e$ T7 R" G7 u       dic1['max'].append(i)
1 t5 J- D! R9 T$ ?. j- oprint(dic1)1 i( T" P) Q# M( m* J
0 p) f8 m3 B0 ^' V3 s5 x7 [4 N
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}( W9 n0 n) K) G8 c

Python基础知识汇总

主题推荐