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、写代码1 q0 f9 k/ N1 S, K5 t, b8 H7 Q0 ?
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) :
( B2 s8 K; f8 x4 a3 c; Z/ ] name = input('name:').strip(): [; v" r; d2 p& A7 y8 c+ |* N* X
pwd = input('pwd：').strip()( j8 `7 l7 r, k+ N5 b0 {" S

3 i0 r# n+ G0 Y- @" t6 D- V9 h if name=='seven' and pwd=='123' :/ i3 j2 |+ a; R) h" R+ A( [; C/ `4 j
      print('ok')) o3 q) I) T* a& `: U
else:
/ `+ x) ]# t1 D; E       print('error')
- S* k: g3 Y% G( X3 M3 ^! w2 O       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)  :2 q4 i) ?- H7 J( z
name = input('name: ')- e# r8 s0 T# D4 u$ t! l: z
pwd = input('pwd: ')7 ?! Y9 g& B* `- H3 y) J! Y0 G
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  \1 s/ U! m& P' n5 @; d
      print('ok')8 Q; c" e) t$ a/ H5 j
else :
* X4 _; ^) n! l# W* p       print('error')9 }9 H, p9 M" Y3 V8 s
      count+=111、写代码
& C6 ]! g6 b6 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 Z0 r/ K! {$ P3 b6 J+ k  ]; j if i %2 != 0 :
6 {& R, d( v, i7 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) :
; P* L2 t: T9 V if i %2 == 0:, U1 _2 U- i: 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"
) P: C7 r/ t6 E) F% da. 移除 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)1 C& [7 |4 k" l4 M# _
for i in name:
, J  [' c5 V7 k+ X: Q print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain- _) b' k! n# A4 o* U' N" y
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
3 d6 Z/ I& {9 hprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 E  f4 k* N! |+ @# [' bprint(li)
+ h7 Q1 `/ u7 _& B) {9 Z& } ['alex', 'eric', 'rain', 'seven']
6 Z8 }5 P* v. l$ e3 X0 o9 ~c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
0 B7 p2 N! D4 W2 c8 V  G' Q1 Eprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ t) l5 m4 ]% I, ]print(li), q/ [  G; Z: J) ^2 g" N/ a
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
2 u& g: f+ Q% E3 F; X/ Vli.pop(1)
: O' y& D/ H  F/ `: {2 y" A2 vprint(li) ['alex', 'rain']
+ `  S# m8 Y6 D- K8 A指名道姓的删除li = ['alex', 'eric', 'rain']/ a- @' P! p7 ^" P0 F
li.remove('alex')
+ o1 M/ n4 U$ @" {. Y" aprint(li)2 s; {$ }* W+ i- @1 {7 r  H2 F" F
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']7 ~. f$ V, m* }# o5 t0 Y0 X
print(li.pop(1))
7 l  x, F2 y) v$ f8 \% K+ lprint(li)
/ w" W5 h& ]4 `+ r. A4 X' S: r
& e3 Z' @6 w/ C$ l5 y* }eric
. W: y/ Y$ }. d['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
; ^' _( n, }2 Q5 n7 xdel li[1:]6 ^5 @$ y9 L- ?* Q, y) M
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
* q! s. H% d9 |& I4 mli = ['alex', 'eric', 'rain']
  C. z9 X( {& F2 Ifor k,v in enumerate(li,1):
: x6 W6 k% K) M1 }% M print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, G$ F5 j$ p, j8 ma. 请输出 “Kelly”# ]: q3 F2 F9 z0 l$ v& g
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! z: g; r5 T' d2 f5 e
print(li[2][1][1])
- ?# O! J# Z" _( N7 u6 e. Bb. 请使用索引找到 'all' 元素并将其修改为 “ALL”; I3 P9 t8 ^* d" G
li[2][2]='ALL'
. u& |4 \8 z3 ]) D9 xprint(li)
# c0 E& |' X& _+ W) r1 q- b24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
0 w* k" e# ^% H: wa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
( r5 s& ^, |/ U5 |6 ~; F6 F/ Lprint(len(tu))
4 Q& q# D6 h2 e* g* o  L! Lb. 获取元组的第 2 个元素，并输出, K( O% g' c9 \( N. C
print(tu[1])
; l/ y; p5 k* e2 \4 Q1 ~7 {e. 请使用 for、len、range 输出元组的索引
! D4 d3 \5 R$ P1 ^8 r6 ffor i in range(len(tu)) :, d* @$ z% v3 N
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)$ M! r# G  h  |  K5 Z6 ]
for k,v in enumerate(tu,10) :
. [, G. E0 _9 s/ t$ ]  } print(k,v)
' V9 d& u. K: I; H2 c/ p7 m10 alex: c2 R& g8 r  X8 T6 ^0 J5 a
11 eric: `8 V! K( u1 J$ y* ?
12 rain3 S( x1 N0 S" M' B( q5 P" W
  J1 {& Y1 c# m
for k in enumerate(tu,10) :
: [% l$ s( t2 o/ F* j print(k)
* F) @, C8 c8 P$ ~(10, 'alex')
1 U) T2 C8 K* g* }) q(11, 'eric')
! w9 c( A6 Z9 r4 S$ ](12, 'rain')4 z8 j3 ], h' U6 L3 S( W' R6 w
, S5 v& `: ~5 e, S5 {! k

2 X" e* D0 U& B+ U25、有如下变量，请实现要求的功能
5 v8 O, b+ H( Stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

% M2 e" _" s3 ]3 \d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 c9 g& v1 ^4 |* P6 `tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ _% J0 U; k8 g( u1 l4 Q3 Vres=tu[1][2]['k2'].append('seven')3 f# S# C0 [" l% u' d3 P# k

: G" @+ `0 f1 v# P% A4 C$ ?; ]print(tu)
; J) r' }# H7 A+ s26、字典2 [' r/ E- [; n1 U3 O
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
. T0 [! s+ H( ]+ @5 \' j9 _. F+ W print(i)b. 请循环输出所有的 value
8 Z  f3 J2 g/ efor i in dic:6 v; D$ r1 _4 E' t" U$ I
print(dic)% ?% E5 J+ y# w- D7 H, e
c. 请循环输出所有的 key 和 valuefor i in dic:
* v1 a: F8 L3 R+ g7 `print(i,dic)) H0 f; B( e4 J! _
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
8 I( P/ J5 N) K: |, v/ u4 Odic['k4']='v4'
  g# w8 _% k7 v4 ~print(dic)' |2 C2 M1 F5 C& }! ?
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
% Z& V( s" f0 S7 a$ w* w2 k+ Idic['k1']='alex'
; K0 z1 f: o/ A6 R0 j4 W+ zprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典8 m7 X# g: P* H! g5 x
dic['k3'].append(44)2 Q. a4 ~0 V+ x7 p0 e
print(dic)( n2 O0 \  d( w) N7 P# S3 W' j

3 H& f7 [+ C+ E  y6 p! P0 Z5 E( og. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
* o* ~7 x( d2 ~; }/ ?dic['k3'].insert(0,44)/ a% f' s, i3 v; s5 F
print(dic)6 T6 \  |6 y1 Y! x: O3 I9 }
27、转换5 x* Y. L4 J9 A6 c8 [; ?
a. 将字符串 s = "alex" 转换成列表  s = "alex"' e" `9 N2 u5 a! ?/ s# o2 j" P
9 l( y0 b/ c1 k) J: d
print(list(s))b. 将字符串 s = "alex" 转换成元祖9 C! h- h$ {- E$ \
s = "alex"6 M/ P5 a0 ?, D  A( E9 w, Q0 v, ?
print(tuple(s))& e3 _, j1 T! j3 b, B

* [7 B- H& t& |3 z( y- Db. 将列表 li = ["alex", "seven"] 转换成元组& E0 N3 `" F6 W2 l
li = ["alex", "seven"]2 B. e! m  O9 m4 g
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
+ {4 U0 w/ j" O) y9 J, Jtu = ('Alex', "seven")
9 x$ E: ?) Y3 j4 j; c: Ali=list(tu)
! k7 `2 n$ H7 x+ T) J2 Yprint(li)9 i  f$ @& }9 y& a# Y4 f

; L. x9 P7 J+ m' \8 z# h; C3 E! M5 Z
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增+ i. b, F7 |) Q2 x/ k# {

# }1 `4 l2 S3 u) [5 Ddic={}4 t# S; Q1 S1 P& j/ L5 |" n/ L
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
) O, t* Q4 W$ o dic[k]=v
% s$ ~5 r+ ?6 V: b print(dic)27、转码n = "老男孩"
( h& h+ d7 S' A2 g0 Na. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 |- m+ Q9 @. ^9 a; sa=n.encode('utf-8')
' H+ U8 z. G. p; |* P2 h6 J% D; Dprint(a)9 K- B( p4 o* [1 D
b=a.decode('utf-8')
6 j/ Y2 b( E( B, p1 m. H* Cprint(b)+ L1 j% t! B5 m5 I' m
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
1 S9 y# ]1 k: \+ I& [( Sprint(a)7 a4 ~, u( F: M9 D4 M: B
b=a.decode('gbk')
0 }, @+ |1 b) f9 U' uprint(b)28、求 1-100 内的所有数的和
- S* D2 t( i5 p5 P  J4 y# ~count=1
3 B4 b4 U1 F% t" G2 l) isum=0% r# d; j3 e' h
for i in range(100) :
6 G0 _, \  t  B. p! o. B- S5 J sum=sum+count
4 |/ X, h3 Z, S count+=1
0 |! Y8 p% G4 u- u) |( N0 a! fprint(sum)" R# b, B+ y) @/ \" S, j

# M/ A- e# P2 n4 p2 Acount=1
2 [  E; N5 v2 g. T  r; zsum=0
# h* P- _# z2 O- r' @( owhile count<=100 :
$ s) z0 V8 {# i( z% k& G- k0 K sum+=count
) d6 Q7 S6 {# J/ U& u; O count+=1  `' L8 H7 {/ I' R
print(sum)29、元素分类9 b) T4 n8 ]- z
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
$ H/ [1 y4 [# z- m$ U# T2 N, X9 ?将小于 66 的值保存至第二个 key 的值中。
8 }, l; V6 ]- }, g% T8 |即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
9 A+ d# h9 U  R# q3 }/ g- sli=[11,22,33,44,55,66,77,88,99,90]4 k) K7 B- v6 @, ~$ X9 F
dic1={4 R$ m3 F; X; l0 }
'max':[],
: a% h6 s$ s  ?& ~; Q 'min':[]
" c  ?* a% I7 T7 y- s}
; K# p! m7 g9 c8 O3 ifor i in li :, s- j2 j6 u3 k5 D4 s2 e. L$ _
if i <66 :
9 a. F) H1 ~; K6 Z; C( Q, G       dic1['min'].append(i)
/ e" q& D& w, z, B6 M6 h" S else:2 U- f3 v0 `) o( N8 n; F0 ~
      dic1['max'].append(i)
" G* w1 J# ?7 |% N$ Dprint(dic1)
2 |8 A7 W4 F6 d( V
" W& g0 l" X6 s8 E---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}# f( z. H7 s+ y3 r) [3 p

Python基础知识汇总

主题推荐