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、写代码
* G; S* z& P6 E, M% `* `# j: Ka.实现用户输入用户名和密码，当用户名为 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) :4 o; }2 P' P9 r2 S  m/ ~
name = input('name:').strip()- {  Y' s  L) J- I1 I- d
pwd = input('pwd：').strip()
$ z! J0 [. d; o. t' R) {; \* o) n& d8 G+ [$ G
if name=='seven' and pwd=='123' :
% @* c, R+ z% M# K0 E       print('ok')+ A" l  V) a: ^7 g; X8 e
else:
: t3 t, }: b6 U4 L7 U! I       print('error')
4 p/ b. _: u' U, c# a       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 b0 a' p& b& U2 a, J5 j! x% s( ] name = input('name: ')# j* ]: s) t  q" z7 k
pwd = input('pwd: ')' N/ j) L8 o& s  {1 ?! ^- K
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
% G- K  S* h) h- W7 s6 j4 b       print('ok')
+ l; z. q7 j# Y) n5 T! @8 K7 O! Z1 ` else :
7 Q3 p0 @, n9 R# x       print('error')/ Z9 Q$ E4 {5 k+ F. ], b
      count+=111、写代码% `& v0 |5 O% Q: m: H' S( a$ x
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) :
7 B  B) r" I) \; \ if i %2 != 0 :
, z# v) R. s6 N/ b3 C8 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) :! a# p, J+ l! H) }5 R
if i %2 == 0:# w  t1 d' h" D3 O
      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"
0 ~" i, {, x0 C8 n7 @, Ta. 移除 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)+ f8 x* M* o0 l
for i in name:( R" c& ?/ _0 M, `# N4 a1 c
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain/ a: `1 }+ x. h; r* @& t5 b
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']" |8 y. ]/ f. H$ f( n" l( q/ c
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
; ?) P. e# f: ?- H; iprint(li)
: m" I, g7 B3 c; J/ Z ['alex', 'eric', 'rain', 'seven']
0 x. W; S, M9 P; j; ]c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
$ `, H: ?5 m% @6 I3 P, T9 cprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
9 t1 F- o1 h6 i, o& ]$ Tprint(li)
. g6 u" T- _: z) z5 me. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
8 D3 }9 K$ o7 D2 A0 wli.pop(1)+ Q& d$ t/ u* S( J4 [
print(li) ['alex', 'rain']
/ N( k; F1 `1 q( W指名道姓的删除li = ['alex', 'eric', 'rain']
1 P4 Y- _9 F# x; Y) X. Qli.remove('alex')
$ K1 i6 F% g7 T$ }0 W( vprint(li)  _7 a& y" Q1 i9 R1 I
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' _4 A/ E, |# oprint(li.pop(1))- t2 S# z+ \; x+ Z7 h3 D6 R
print(li)
/ G, i3 d: _1 K$ ]) g& y2 j) U
# c, N( D0 W3 T0 N7 C3 Ueric
! Z8 X! H% ]( u5 ~0 ~9 B: `5 C['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
* |/ z0 @5 }6 `) J6 fdel li[1:]& L, S2 b. k# G
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)) Z1 I" S) ]4 L! `; o, V& J, }
li = ['alex', 'eric', 'rain']+ X: ~5 C+ _- b9 Q
for k,v in enumerate(li,1):
3 f4 W$ [, n! Y" _6 z# G1 ? print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ M  y( Z# T+ N- I  wa. 请输出 “Kelly”( A1 a9 M- P( e% z6 x- J
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]; @% v/ [  H" A; {7 U
print(li[2][1][1])4 j" z8 t$ c; g2 o/ p6 E
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”0 a% N4 A3 C8 @9 E3 t2 L7 [9 |0 q' _( f
li[2][2]='ALL'
6 }0 K% s/ Z( ?' c( xprint(li)
% P2 f" ?) }4 Q4 S% O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')7 X  H+ N) M0 C& T: I  o
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')+ J' ]# c1 g4 r) H2 W# g' ^
print(len(tu))
( B( l) \! X4 c2 x( ~) S; |2 }b. 获取元组的第 2 个元素，并输出8 L+ O) O. E0 ?
print(tu[1])
9 @  g% W: |! [9 k4 Se. 请使用 for、len、range 输出元组的索引$ a. f' l$ p  a  {9 s- l+ M
for i in range(len(tu)) :/ P$ P; g" o* m+ F
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
* w; J5 R) r/ W$ n+ j+ v  zfor k,v in enumerate(tu,10) :
5 h' L( x5 ~! [* }$ A7 G print(k,v)0 E4 t( V* i1 j( W* `+ ~( P% y
10 alex
& X1 z+ z9 d1 h! Y! }11 eric
" g9 z3 Z) N- ^( p  V; t0 }12 rain' C# p: l- W/ n  p! Z8 S8 |# H
% y1 D2 k9 f3 w6 K/ R
for k in enumerate(tu,10) :
( M$ m- k& G% n print(k)# [# f0 A' o9 |+ D9 B7 k/ `% n
(10, 'alex')
! M* t1 m; x1 P9 Z9 }1 [! C0 q(11, 'eric')
" B+ {: x& S8 p4 f& ?' C(12, 'rain')
* l! W; U( r! |2 Y+ Q$ M0 ]/ ^; |  [3 Y  I: g3 S1 X: E5 l
2 H5 V. L+ N4 ]; n& T* g8 y, o' G% w
25、有如下变量，请实现要求的功能
. }  s1 q- B7 N$ E4 M& utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
0 N. [8 e- S* d/ A5 v/ y
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ }' k% x/ H5 k
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
) ?( A0 S: p( H. \9 \" y. w, P/ g" y& ^# I
print(tu)
7 K( K  v$ O$ w0 l26、字典
' R( y2 j) |& `7 |. I) Mdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( Y$ ?7 O8 r# `& k  F" |9 u8 S print(i)b. 请循环输出所有的 value
. P$ Q1 O5 r- E& q0 F" Nfor i in dic:
. N, R- {" U8 { print(dic)3 M( H/ }" R( A5 N4 e5 V/ t2 h% B
c. 请循环输出所有的 key 和 valuefor i in dic:
# G0 T9 @0 |. o" j2 _. \print(i,dic)3 O4 T$ ~' C" m( @) g- ^& y/ @
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
4 `& h7 h, q( p5 S) d9 j* T4 b% Edic['k4']='v4'
0 z9 p* t! M5 q3 {# |* a# hprint(dic)& L6 ^. ^0 G$ `1 ^1 j
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
, _7 G" j. H. y" s2 mdic['k1']='alex'/ h) h* i- Q3 \8 @6 O
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典* o; C! t3 ?; S. o9 S+ g7 C
dic['k3'].append(44); g. R2 v3 ~! `
print(dic)
# k$ L- d& S6 ^) K8 A' r/ e7 I* b7 H- L6 Y
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ c8 |' n" C% j7 K# kdic['k3'].insert(0,44)- M# D5 l; a' m
print(dic), M* x( h# d; o; N3 v0 p# a8 X
27、转换
( u2 k" R% F* f- xa. 将字符串 s = "alex" 转换成列表  s = "alex"& b% v( V$ r/ k9 \* l3 `1 Y0 O

8 o) U- q7 _3 n  o% f* d7 Dprint(list(s))b. 将字符串 s = "alex" 转换成元祖$ m2 f2 r/ X( M  k. G/ A/ J& |
s = "alex"" y) j2 c3 T6 s' U0 o
print(tuple(s))" p0 G1 p6 ]) g
- U) l" ~0 \9 y: a, B
b. 将列表 li = ["alex", "seven"] 转换成元组
9 [) e, R( C/ kli = ["alex", "seven"]
! {- D" R3 B- `- L% b  V1 nprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
" k0 s/ X1 T3 b6 `: ~tu = ('Alex', "seven")
' R' ^9 @. t5 r. K/ j$ ali=list(tu)% X, c( n# |  S$ X5 \7 A" [& P
print(li)! K  e) E# M" n$ F1 F

( @: F* {- Z( g6 j! v" m$ b: u- [) P4 S- w  `% i
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
4 _/ E. ]7 Z8 N3 Z9 o3 |
, _" L/ c+ `5 n6 ~3 a" l/ W( _dic={}$ @% ]9 F" l: }* B' r* b
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: M/ l: G  m/ Y( a; L! P dic[k]=v
5 g' q2 Y  b3 G; Q+ M+ O% r0 | print(dic)27、转码n = "老男孩"# T" \; E( Y2 l( T! O
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
. r/ x) Z2 D3 R6 T/ Ia=n.encode('utf-8')
  n5 v0 G" x/ B; l" I! W; kprint(a)
* Y  i$ w' W1 \! fb=a.decode('utf-8')
: s& e" E7 `& ]# Q! R7 b2 t& g' p4 M. uprint(b)
: g- k9 |$ m  l( Q- lb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 g; a0 B# |3 w  T, eprint(a)4 \& X( K% U6 j' x) J* N& E  L. P
b=a.decode('gbk')1 Y! k9 G2 Q0 z: x- e
print(b)28、求 1-100 内的所有数的和8 l- B6 b0 ^0 P; t; a3 p
count=1
0 @$ u9 Q1 ~3 ?2 Q  Wsum=0% o! v" r8 F4 o  i1 R3 }+ A
for i in range(100) :. `0 k, v( Y7 ^- A. n: w& `" v
sum=sum+count5 R7 _4 N$ I8 Y/ n  K; |$ Q! n
count+=1
& ~; [8 n5 _6 E) g; B# w4 {print(sum)
; q# K/ A& ~9 t) R2 V1 g$ P0 t8 }
# S6 F9 Y% {4 m  u" I% x! U( lcount=1
0 \3 ?8 W- z5 Z0 L- }  Gsum=0
+ U. I, `" p% H; {/ K$ Nwhile count<=100 :
, h, r/ N2 y) Z1 Q) I sum+=count. l( V6 F5 M. G2 A% h2 j# L& G
count+=11 B! u+ u7 Q' R. U
print(sum)29、元素分类
1 D9 b. ~5 ~! y. J# |( U0 O5 A有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
: z7 s7 |+ |. C# U  f( A将小于 66 的值保存至第二个 key 的值中。) l" V! z2 d6 `) i* T7 c
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}! H1 z6 W( X5 S8 f( w4 M
li=[11,22,33,44,55,66,77,88,99,90]+ J) t, ?8 L" R( Z$ o( t9 J5 _3 W1 {- f
dic1={# I. J; s9 P; ]1 u
'max':[],
'min':[]
# V/ ^- q4 v) l+ R  U: {8 W5 ^}& b0 m: C* }0 o+ ]! _/ |* F4 H
for i in li :3 `# W- I2 F2 n$ ?2 H: O, p& g0 ~
if i <66 :1 g6 S2 T7 S7 H
      dic1['min'].append(i)
8 _% v+ S4 X! Z  t else:
% e9 L5 F! M# K$ L* m# P       dic1['max'].append(i)8 O; \' K# H  N9 i3 M: b
print(dic1)
; K2 j8 M: V+ v$ l8 ]9 i2 \! a
) e& L9 P7 t( P7 K---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
8 ~2 f$ c4 H9 }6 Y+ a( J; L

Python基础知识汇总

主题推荐