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 t6 x; X" C* p/ R7 G" va.实现用户输入用户名和密码，当用户名为 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) :
5 A6 L/ |6 D. r6 n* ^' X+ q name = input('name:').strip()
' O' m/ |( \: ~0 F pwd = input('pwd：').strip()3 Q/ P# n, t: s& M1 Z8 X

$ J; S$ x# _( O if name=='seven' and pwd=='123' :
& x1 b+ ~: t+ Y4 v' u* U4 B; b4 p       print('ok')
9 b- g4 d( m( r else:& @% X, d! ?0 v) P
      print('error')) h" g- n6 q1 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)  :
* K6 P' g* x- X0 Y0 Q name = input('name: '). {. V3 M$ y6 ^4 x: E% w1 X
pwd = input('pwd: ')
/ S; y8 D# }! s if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
% o" `8 i2 z9 P" I1 a1 z) ]6 J       print('ok')* L% X$ E; c! w  W0 D1 ]
else :! D) [3 i1 g' R# Y) b: S. m/ J+ J
      print('error'); ~) |& @) M+ h
      count+=111、写代码
; b3 i  P7 p! j$ Ca. 使用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) :
4 p5 h. p. A! \/ I if i %2 != 0 :; U, H1 r# H; s% C- D9 g! R
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
! F" G) c' B$ n* r& k$ a if i %2 == 0:- ]; p  v% p3 \9 ]: N5 k+ f
      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"
! D8 }! b# l3 ~- n' j/ g; \% o* Ja. 移除 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)
, _2 C& n! x# O9 u1 n3 Pfor i in name:# _% O- p8 `4 `. z$ U$ B
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain# s+ C" K5 v3 O% ^8 e9 P0 g# w
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']2 Y% J4 ^2 Q5 s5 Z1 }; k( b
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 `# }6 v8 H5 Q. w+ S3 |' b9 ?
print(li)0 ^: A: t6 e2 W9 L& H( k+ ]
['alex', 'eric', 'rain', 'seven']5 y' X/ ?( w% Z6 f% y
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
& A. T6 w) X/ d0 a1 }print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ Y5 c5 Z- d4 y  E( a1 pprint(li)
$ [) c# S! h4 K# `" Fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: u( F+ N$ `9 c; Xli.pop(1)
: F9 z# @3 b/ |5 Kprint(li) ['alex', 'rain']' M3 d* {2 {  n$ R5 S, z9 |
指名道姓的删除li = ['alex', 'eric', 'rain']
* h# R( J8 D7 y/ s" r' Eli.remove('alex')
% ?3 N) @" @1 cprint(li)
% E. \2 n, R6 ]) g8 tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
  I$ i. \+ Y3 e; y/ A$ W/ Mprint(li.pop(1))
' Q4 ?' W, F: J0 F: ?: W* {" |print(li)
8 p7 _! }  ^. Z% w! J9 y. i
1 V& h9 x1 {: t6 P  I) C/ `eric
( u& o8 p, P- F2 A4 G) O6 F7 u['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
5 }5 R- e/ _: [$ K4 S3 l1 I, Mdel li[1:]" E# D: C2 p3 `2 z4 t
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
7 g7 v$ Z# M& R  r! Zli = ['alex', 'eric', 'rain']/ ~/ q7 b1 Q, F) R. C
for k,v in enumerate(li,1):5 x# O5 c3 y* y4 v9 V0 B" n
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 J3 x7 `: s4 O' {6 K0 T3 ha. 请输出 “Kelly”
2 `, d! M2 t7 f6 P5 R9 Kli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ n  b& C+ {! |' F! @7 dprint(li[2][1][1])
7 w! ?3 t0 `$ d9 zb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
$ a) @* l5 D  D& K+ v, K& Qli[2][2]='ALL'- }# W  f6 Q" @* ^) ^
print(li)
) B) K3 b6 v. B1 F24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')" |6 a/ {) o8 O% c. ^3 J
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')0 C$ K4 ?4 Y! `7 M
print(len(tu))
, f. m1 k" p7 w' }1 A# {b. 获取元组的第 2 个元素，并输出' T3 t* @/ }, n9 I
print(tu[1])
/ A7 |* d" ~% Y/ v6 D2 me. 请使用 for、len、range 输出元组的索引+ c3 j  O! s; Q2 H# i& V
for i in range(len(tu)) :
; }5 x: \8 {+ U6 H) f1 t print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
( T+ g( m4 \( z7 {) Jfor k,v in enumerate(tu,10) :
# X9 P8 j$ k  s4 }  c% J, |% J7 d print(k,v)
& J' C( B+ p* J  K9 [" d5 g10 alex/ x* b* X+ \7 z, g& w
11 eric
, g  ^: ^6 P& c& a% j12 rain
7 Z+ h& y, b7 C) V8 C" M+ K! m" n9 \- z# ~6 B% I0 Z: Y
for k in enumerate(tu,10) :' G; Y- N1 Q2 m3 Y
print(k)5 x, {# W+ E# `7 O8 k5 q
(10, 'alex')% o9 V0 _- `4 J+ c( n: [
(11, 'eric')
* u, C7 N: P: P( u; W. _2 i(12, 'rain')+ s1 f9 S$ i% J: R* s' S
6 A) \8 \0 I- w% [( w
/ g- w+ q: B3 o* F" n
25、有如下变量，请实现要求的功能% `2 s1 ?- z* J" l' h1 y
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

: l, B7 ~, O& Q3 Wd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 j! ?5 F1 t8 u* Itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 b' W8 k: n+ Bres=tu[1][2]['k2'].append('seven')" P5 ~4 |4 c$ `2 s. K
& o; @; O# G6 B" C  H
print(tu)
; L' M# e4 x, l  y% z; k26、字典' r0 |+ @# u# u5 ^: y8 {
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:2 }2 B/ `$ i5 C, B
print(i)b. 请循环输出所有的 value
6 a' Q% n; ]& @6 Z4 Kfor i in dic:; C. V! M7 I8 u! ^9 H
print(dic)
' E. X& W" _. v0 i0 pc. 请循环输出所有的 key 和 valuefor i in dic:0 h& T- i# l8 m, a" C( Y
print(i,dic)3 V7 S7 W! T6 s& ^) L9 G4 M1 @
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 P2 @( B* L/ q5 pdic['k4']='v4'
, J7 H% i, o  A2 Mprint(dic)
" b! m' ~$ p9 i1 {1 \3 ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典6 J- P5 ~' w- r2 H0 i# E$ W2 i8 J3 ~4 y
dic['k1']='alex', U: f2 U' d9 y! W7 J6 j7 E
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
7 W$ K4 K2 a6 a' [" rdic['k3'].append(44)
4 C2 K+ t% ?3 Hprint(dic)
3 K: l6 J: a: j* U. `+ k' x2 n$ t. x$ R) ?; w3 \
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典( W6 n# L# z% S2 D9 l" x
dic['k3'].insert(0,44)
  K2 _; q& c+ e* Dprint(dic)% D6 H7 G" ~5 B9 T- [' f
27、转换7 X% J! Z( `+ k2 r* O/ L& `
a. 将字符串 s = "alex" 转换成列表  s = "alex"
2 u4 J! S) G% L  x) i- i
( }& O; O- ~8 U6 u9 R( b" Dprint(list(s))b. 将字符串 s = "alex" 转换成元祖& b/ v9 W( g& e4 T
s = "alex"& ]1 J" l' L6 p: I. o: u
print(tuple(s))  K) n# k' K7 v* Z7 |# L$ B- c

" Z+ E: U6 S% y( t' A5 X! Eb. 将列表 li = ["alex", "seven"] 转换成元组
  c2 \& x$ a8 yli = ["alex", "seven"]
7 C+ g8 i4 r6 g: E! W7 ~print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
8 F+ u( {: K) i% Ztu = ('Alex', "seven")4 L2 G6 c% ?1 F8 t! C
li=list(tu)
! `7 ]1 L# s) t+ F. ]$ [print(li)% H& p+ D2 o$ t& ?3 \7 D# W
0 P5 l, S1 Q( j$ f# o% A
0 `' n! D) m+ f; \5 E
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: q9 ?7 q% }0 k. P: R( w0 q$ v  r& N8 M0 Z
dic={}
# A5 O' {; w5 R2 R5 n( `2 O' M, ?for k,v in enumerate(li,10) :----li要放在前面，序号放在后面0 [! J* _, U5 O  r
dic[k]=v
1 h$ s0 w, \& o2 \" _. O" s1 R print(dic)27、转码n = "老男孩"4 l' B2 `3 f/ A+ j% ]1 s2 ?, k
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"2 M0 B3 Z0 W3 o
a=n.encode('utf-8')
5 @' p2 w* _5 A6 xprint(a)$ b, \1 R' M8 ~1 }
b=a.decode('utf-8')- P  c, E: |% x- e" X
print(b)3 ~$ I( _( B7 d1 {0 z8 m
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
2 H) P# @( N6 H' |print(a)
8 e! n0 _& j. i+ e8 Cb=a.decode('gbk')
" M% Q2 c, {* o/ M& p/ R, lprint(b)28、求 1-100 内的所有数的和
; k. Y1 _' v: Rcount=1
3 Z9 Z7 ~" Q# ?sum=0
/ R3 v# K3 j* N* H6 j( t  v3 A% j9 kfor i in range(100) :
- l  }  T" ~2 }, o3 _$ P6 R( V7 { sum=sum+count
' [7 w, a$ U. X& ` count+=1
1 C; X* |  `- a7 _( j! W0 oprint(sum); R; H4 \7 f! }/ X

9 E4 t0 d7 S4 }7 G; i- jcount=12 m) k2 W( o$ F) e* A" @1 ^
sum=0; k* v( O, I% f" m: E( V
while count<=100 :1 |4 b6 j8 \, w1 @
sum+=count
9 n9 s4 j" g* Z, U! w8 H count+=16 x5 m% S$ ]3 O3 t
print(sum)29、元素分类: [6 F& C, U' E% Y: J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
5 q" [  E( g6 b6 _1 H* q将小于 66 的值保存至第二个 key 的值中。
8 `  o" v2 S* f, q0 B/ J: P即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}9 w7 v7 Y; c- w* r+ U8 ]- Q
li=[11,22,33,44,55,66,77,88,99,90]% H  t1 o7 `3 n7 O
dic1={8 v9 ]% P. m6 p* w3 m# s
'max':[],% x' I, X: {; e0 x; ^
'min':[]$ X# P& ?* v0 u% K  r3 X- a# _
}+ o: f2 m, f2 K/ Y
for i in li :
! W; H( `1 t( U if i <66 :! h1 q9 z" ]3 t
      dic1['min'].append(i)
( R% e, S+ r, \; J# S/ W else:
+ }$ }5 q9 P, ?" {2 a7 D% [       dic1['max'].append(i)' U0 z: {1 T  K
print(dic1)
% }6 g' ?& b8 l1 }3 F
. X* P1 S. I( y3 O8 J# l---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
8 Q# b8 [; g  ~" a( z, b9 r, c

Python基础知识汇总

主题推荐