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、写代码9 Z3 u. \" I' `! W% a: ~  [
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) :, b$ q! R4 N- G- ]0 Q" {
name = input('name:').strip()9 g6 ?% k/ {& n
pwd = input('pwd：').strip()
/ x) ]9 E; \1 ^! I+ O$ Y# {, k; y8 Q* c4 b/ n" L
if name=='seven' and pwd=='123' :: S5 Q& @9 P% l8 F! {5 ]
      print('ok')
8 A. w+ C: `( N% Q) b7 r$ i% v else:6 u! |$ T6 W( H4 }' q7 ^
      print('error')
* S1 o$ z& `- N2 ^       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)  :: D: e+ C# k# u: \) j3 g
name = input('name: ')4 ?0 J2 G9 t& y2 ^5 [" P
pwd = input('pwd: ')
' {+ m: m3 h1 k) H  G if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 [% Q. I3 d' W" h( F       print('ok')
* N1 Y0 Z) k: P( N/ a else :5 P" @6 H+ {7 y* Y0 o- |3 d
      print('error')
3 H$ A9 }6 K- C! U7 K5 e       count+=111、写代码# @" Y  w  i) k% {& h0 F; w
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) :9 s; A  b! T$ N" [
if i %2 != 0 :
  \# h# H1 D! Q- A       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :: i2 U2 O: T; B$ V0 F+ m  C
if i %2 == 0:
' L( M6 J' U! S6 q$ e: ^' D$ 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"6 ^8 y% b' e+ `, }* n
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)
# h$ {7 t" m2 b0 R3 Nfor i in name:, i" Q9 ^" i) y
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
; \/ e( R4 Z3 r- p7 E22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- `3 f" U" I1 F. r$ y# @
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    ( M) @; D3 r: z" v
print(li)! E2 C6 a3 ^& p
['alex', 'eric', 'rain', 'seven'], r% B& B# Z/ U1 r5 \7 t
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
1 _3 F8 s5 o- R* s# a. Hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')) r/ G2 ^- B: V) S
print(li)
1 Q0 x: k& J$ y, S+ Ue. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']; n7 b# }; B3 P1 M/ D6 q  I) n
li.pop(1)& J# g$ L7 E: U/ u& n- f$ {
print(li) ['alex', 'rain']
: i0 `* p1 j! E: U& U$ m指名道姓的删除li = ['alex', 'eric', 'rain']. z: K9 x: N8 X% ]4 x  r, q" x' L* Z
li.remove('alex')
* t: L/ p, x# d, X6 l- c! Cprint(li)! }- d% H; R) m9 V6 X* Q* X
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! S; {# q- V, mprint(li.pop(1)), ^* \) A, ~' S6 S, Q% W
print(li)
; A7 y' z0 H( M* H
- c: y1 H: S1 g9 _8 x! k# z1 Ieric4 V2 Y: }8 o3 ^9 S* {, J! `
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']1 H7 P8 \& q7 d& L
del li[1:]9 b  I. g2 I/ {1 g" y
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)$ K! b2 q" r* j. `
li = ['alex', 'eric', 'rain']
; }4 C( J0 t% T+ Lfor k,v in enumerate(li,1):3 \) i; A. N) T6 n% l. x
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 t( p+ f( ^, e/ x* S/ Xa. 请输出 “Kelly”
  Y. a$ J& w% k3 w# V$ f# Pli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]# }' T: d- y8 S/ F1 @
print(li[2][1][1])
" H; v3 ?" |4 l/ p/ f" F" Kb. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 |$ j1 {4 N5 G
li[2][2]='ALL'+ U& C+ n5 ~/ H
print(li)
" v. z) y+ G1 I24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
8 y# N' T4 y: D/ g  C& t3 M0 y4 Xa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')0 ~' D" W" n7 d  c( o
print(len(tu))
/ h1 v$ Q3 v8 c# mb. 获取元组的第 2 个元素，并输出
# L7 H  H: Q% w/ }print(tu[1])
/ d# Y; T1 `/ q- \; ke. 请使用 for、len、range 输出元组的索引
$ o, x; K) V  p9 Ufor i in range(len(tu)) :
: N; B* `; ]5 i8 N/ @ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
& i- w1 @0 u8 i* lfor k,v in enumerate(tu,10) :. Q: Q" a5 F7 o: y
print(k,v)5 t) ]9 {$ n! e
10 alex
" n% C, k; T+ H, c11 eric
* F" Y! v( r* \7 \; j" ^/ V12 rain0 e- U. c- H4 T) j; [3 U
8 ]3 u( ~) a0 d, x6 F7 B* y7 R
for k in enumerate(tu,10) :' v7 w8 O: Y/ W- `- T, {! k
print(k)
0 a5 }! p3 ]9 r! P. Y4 b" ^* ](10, 'alex')
9 O9 ?7 l4 z8 ]# p- K(11, 'eric')3 a1 I5 Z7 ~) \% Q# Y& N9 X( K# ~
(12, 'rain')
! W; X$ ~1 p" J( O
5 f# x) O8 m5 o! H4 L. t: n& Q+ {0 y- o
25、有如下变量，请实现要求的功能4 u- K' \, E4 }) V1 f- o  I
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
0 [+ a/ \8 J0 P2 r
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以- ?; o) h- ^# }+ k- O
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% S3 S" w/ y" [. H  ]res=tu[1][2]['k2'].append('seven'): r, F# s, c' I, v' z
9 ]2 E( J  \1 s
print(tu)
, i: t! j) B5 ?, h" [0 j" }26、字典
/ A3 S2 p) W! `& S; E7 n% ?dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
" c8 |; W1 t- d# h* H( w print(i)b. 请循环输出所有的 value
& G" [- {$ V/ y6 sfor i in dic:9 Y6 Z) {1 k% P( z5 X
print(dic)1 S( w1 C; X: A- R6 n! s+ E
c. 请循环输出所有的 key 和 valuefor i in dic:
9 m" [# \& n+ S" Pprint(i,dic)4 v5 a  k& M# r6 v
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典5 I. j4 V3 I: F
dic['k4']='v4'
9 E, i; H, w5 iprint(dic)6 l/ F- [, R# V2 ~* R
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典! w6 g: U! J2 s! T
dic['k1']='alex'
3 S' P7 k& R! A  k; _! nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典# f+ e) ~; ]* T: y2 V$ }% I
dic['k3'].append(44)
$ a" l0 I3 g0 hprint(dic)- ?6 l0 j7 A# W; u& ]6 P% v

0 K8 p) ~2 E$ S. s/ U* C$ mg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典1 B  N% L' R: U' S* K; p: {& R
dic['k3'].insert(0,44)  s$ \) y% l, }1 H' l( V/ g% m& C
print(dic); [% Y8 h* ]- f1 J; J  v7 {2 R
27、转换
1 o5 `5 o0 ?& H8 ja. 将字符串 s = "alex" 转换成列表  s = "alex"
$ h% C, ~) w, {* G3 s
! I; Y6 G' k- \, n" V9 I6 T, F! iprint(list(s))b. 将字符串 s = "alex" 转换成元祖# A% a2 Y% l& G2 O
s = "alex"
. e9 l' \' {" ]0 g7 \1 Hprint(tuple(s))
7 Z5 W! }; c9 I  \+ n$ A* a. r2 r0 d# S$ N: H
b. 将列表 li = ["alex", "seven"] 转换成元组
8 @- K/ N" S7 n" w. N2 nli = ["alex", "seven"]4 n/ M4 e3 A& b/ I
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
( p8 y9 m5 W% F- b) g# ttu = ('Alex', "seven"); \; S  }6 {" W5 }2 l
li=list(tu)3 o2 F: J/ K( E9 p4 q
print(li)$ w2 t( S" f0 \; P# k1 n

5 w7 k9 s1 {; _7 {" n+ U2 Q' X" U- z+ b" j" K. r% A! Y0 ~9 c: ^7 [
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) q7 J$ j; @( s! t7 \! s
. V. l' i9 K/ y4 D+ }5 c3 @dic={}
3 r5 p; i; v6 K" ~3 ifor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
$ _7 Q; V' [" W$ L dic[k]=v: l, X! s* P3 L1 {- V. R+ p) Y
print(dic)27、转码n = "老男孩"  l! _1 Z, z- p, J8 v3 \7 B
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, h: l% ]* p. t. fa=n.encode('utf-8')
' i9 y0 H! c9 P) gprint(a)
. i9 E4 t2 I+ ^0 zb=a.decode('utf-8')
# T* u/ @: r; b  _  Z6 Z- _* [( Mprint(b)7 z3 Z* v9 m/ m( K
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'): Y3 a9 c& x! V, h
print(a)" F1 g) S; H9 U/ Y
b=a.decode('gbk')8 f" o; B6 m- c  e# j/ P
print(b)28、求 1-100 内的所有数的和
4 B( T: z9 |3 E) D0 r& \0 q2 n9 H4 `count=1
5 c/ J0 ^7 r' q& K) E( S0 asum=0
7 m$ D+ q0 p. Y3 C2 wfor i in range(100) :
2 z7 a. r1 i3 B* T8 ^% a& R sum=sum+count
) R! T2 Z; u' N3 n! d) b& r count+=15 r6 b! M; r; K1 w8 p
print(sum)
" R5 W# Q% w( d/ H3 N# s# ~+ D: |7 v
count=1
9 Y; n- r1 W1 A) g9 Dsum=0
! Y0 j. ?( J+ lwhile count<=100 :
: H+ S# g5 A( r4 H  j7 C9 J sum+=count
4 k, p% S5 k0 n1 X# j! u count+=1
- t4 X1 k: P: ?1 r/ f5 _, |0 J9 E9 gprint(sum)29、元素分类
7 O; R' Y% y$ c有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
$ K! q/ {+ w( i5 y2 c8 Z* |将小于 66 的值保存至第二个 key 的值中。
1 v; [$ C) o: _& O* r. Q即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}( K+ x# ?& }0 A: _
li=[11,22,33,44,55,66,77,88,99,90]
! H3 k+ I, ]8 |. I. ]+ Fdic1={. h6 L3 t: F2 k3 J
'max':[],
9 N+ I" p4 y4 q4 h. p 'min':[]
. O. W2 _* w0 S! Q# z; _/ R& j}9 R7 D/ I& Q8 R) A8 {' _, w$ c8 @
for i in li :
  d- u3 X/ {3 s4 U if i <66 :' E) y. d2 f% C- J4 z* o9 D% K, }
      dic1['min'].append(i)% ^8 T; ^' J- ?/ K! E
else:  T+ s3 }0 W5 Z7 ~
      dic1['max'].append(i)
  u& l; V# K" |, Y: Pprint(dic1)
" x; I  e0 V4 [& q0 n# v
9 R; K, c$ j; i, w* x  R0 x& A7 G- u---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}4 ]0 N1 Y! J  A# K% L1 l

Python基础知识汇总

主题推荐

浏览过的版块