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、写代码' ^: O0 @; Q6 i3 ]9 J- o- D
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$ h5 |, x  a! R name = input('name:').strip()$ I$ y0 V" [- ^" O8 V
pwd = input('pwd：').strip()2 n8 N* F0 R6 H' }
) R8 x% z$ m6 ~, Q
if name=='seven' and pwd=='123' :
" J2 r" q! {% A! q3 N+ @% S$ |. T       print('ok')
7 p9 A) m$ C. V/ v% L else:& A" s- @( O- Z+ j. D
      print('error')
/ `! n  e9 v5 B) P; F       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 H0 r) ~! I* P4 B0 u: o7 a- v* h
name = input('name: ')3 W( `1 F* K6 a! Y+ q. S
pwd = input('pwd: ')
4 w2 o/ ~- s$ |5 |+ q if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
- p% @' k0 p& |4 R6 k       print('ok')3 i2 M( i( b# y& n+ [8 E
else :2 `, N- Y: Y$ ]% x9 M8 A% X0 b9 B
      print('error')
* H# ^& {% x) \" ?: F1 [       count+=111、写代码9 D. V/ c* S1 c
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) :
# J2 x3 k5 K0 F% Q. K  Y+ c, Q if i %2 != 0 :5 L6 ]) u0 u; r6 g
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :' J5 W! ?7 C/ o. F$ ]6 V
if i %2 == 0:" L: x" D( D6 ^) z
      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 F# g1 r! m" J. c% e6 a% g, z" S4 H
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)
' q  P3 R/ S+ Z, V# Z0 [/ efor i in name:3 X" }" N3 N. F9 i/ I1 @
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain+ ]- Y% D. w: Z9 o7 @# s% D3 Y# U
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
: R2 C7 D; F% T7 p. iprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
5 U3 p  C; \8 K8 eprint(li)  |2 p7 y/ h( ?3 a
['alex', 'eric', 'rain', 'seven']) a' S3 C' \% Z0 _
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')" p. w: t, [& L% q9 y; I9 r
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'): S5 S' o2 d+ x$ s% @" ~! |+ q
print(li)& R+ J; }9 ^8 v8 i
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
. y" e* Q2 [4 {0 P1 y& }li.pop(1)' I0 k8 d( ~# P9 D  N2 ]1 [. I% G
print(li) ['alex', 'rain']' [0 y& }+ m  E8 a3 W' ?
指名道姓的删除li = ['alex', 'eric', 'rain']
, x& k4 |$ X9 }9 ili.remove('alex')' ?! J3 u  q3 }+ }: |! w* }
print(li)% D% N: A# i) D# e2 f0 C
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']/ F' r) {, b8 ]0 z5 N! C
print(li.pop(1))
4 j: O$ @1 f0 o" s- U6 y0 e2 Gprint(li)# w8 j7 {" C  P3 V4 Q3 m  D
3 d* r. E" ^" f. W. o
eric4 K; G5 \. \9 R0 E* N& O
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain'], l! \2 u9 n8 l: |7 t
del li[1:]
- X8 O0 }& [1 }* K$ b2 h4 Eprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)3 [" Y. |/ x3 {& W, ]
li = ['alex', 'eric', 'rain']
' }. \9 d# _, Y; P" vfor k,v in enumerate(li,1):" Z* `- b1 C0 }9 S2 M) w0 l4 \
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 |0 C9 l% c# E  ]. C: ha. 请输出 “Kelly”1 I$ U$ g* ]" q7 e3 b, O* r
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ {- ]9 }2 I. g0 {4 K+ {print(li[2][1][1])6 c; S$ e7 P5 _' O
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”/ s& ]% _  {: f2 @
li[2][2]='ALL'
' g' A; d0 v- G2 l1 eprint(li)
. s) i+ }4 L1 V* }3 ~: c7 F1 O$ M/ m24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
1 g" \4 t1 h8 V* J4 J% N& `& N2 ma. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 i& k) T7 R. b: Z8 ?1 Bprint(len(tu))
9 l- U. j3 X+ x$ eb. 获取元组的第 2 个元素，并输出8 O7 W+ G$ M1 Q4 o- H. _' f( b
print(tu[1]); V" _4 e8 T# Q8 t7 F! S' z' ]
e. 请使用 for、len、range 输出元组的索引4 I8 z3 g" W2 G7 N9 i; O
for i in range(len(tu)) :7 E' ?3 z  R- V& t0 g+ N
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始); ~/ }9 V# W6 ~& v: s
for k,v in enumerate(tu,10) :
8 L4 z6 L0 o4 [5 r, R print(k,v)) ]/ i) t9 j9 u' N# q
10 alex/ A' V* U- m8 f: q7 }
11 eric- y6 L$ G8 ~, h2 B% `( j1 L, N
12 rain
4 N. X! `. |# q5 _
3 B; @7 R# z' d6 b/ Gfor k in enumerate(tu,10) :
9 G) E% X! ^4 R* C% H6 k. { print(k)
9 D) \1 l1 J, x6 K# x) ?# ~(10, 'alex')0 t- z  B. m" q7 g' d
(11, 'eric')5 j  i/ ?' A7 u
(12, 'rain')
$ s$ |1 w8 s: n1 R
/ o; i' d- `$ k: O% k% n+ x# ?) E5 P. o% o' U) x; T. t4 u; j5 q
25、有如下变量，请实现要求的功能6 |( s2 }3 y: `( B4 H
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ S; a/ [$ Y& V/ W* D; vd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以, l/ Y' y6 v1 ~0 k1 m1 W4 T
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]); r4 O+ C$ J2 I2 q5 }+ m# O
res=tu[1][2]['k2'].append('seven')$ ^- D, ?# ~7 L
& A* r7 G( ?  m& Q! G) e/ J% {
print(tu)/ ~% H, j( E+ [+ e$ b: l
26、字典
/ N+ a( c9 R: u6 i3 M2 P8 cdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:- n: a9 P* ~3 F4 Z  U
print(i)b. 请循环输出所有的 value1 B4 m  ~3 N) S$ _5 B% L8 q. R
for i in dic:7 F& I4 c7 Y, O; V, v) W
print(dic)" f+ y- `- }4 ~# `
c. 请循环输出所有的 key 和 valuefor i in dic:
/ ]0 l! F- v6 o) Fprint(i,dic)4 E: D! r; y8 ^
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典# f- J# c2 W) N  H# `" R
dic['k4']='v4'
4 E+ E  L2 s5 v& Y8 K% {print(dic)
, {7 L/ [; p  L$ d* ~& R  Re. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典# q1 T- K% E5 m% q
dic['k1']='alex'( J% h7 b0 o/ U. Z# u
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
/ a7 `9 L' s+ R  W2 N+ `dic['k3'].append(44)1 x6 c. B  j' T  J( L( n% h
print(dic)5 T! S; W: i6 \# e" Q
9 y, j! o8 d9 _' ^" W! s2 q; I1 X. d
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典2 O; @' v$ T3 k2 {% ^
dic['k3'].insert(0,44); G& w/ j6 l1 x  m$ P6 m% Q5 w
print(dic)
* P/ n7 P' U: [$ w& Q27、转换! R) o1 l* j+ m9 `
a. 将字符串 s = "alex" 转换成列表  s = "alex"
9 `& a) o/ K) R1 V) f9 z0 D
2 ^/ m' h2 y7 \. s, pprint(list(s))b. 将字符串 s = "alex" 转换成元祖
: z4 \) |! L4 }# E; ns = "alex"+ _( u4 a" j% V5 W# A6 O8 ]
print(tuple(s))
. \- V6 R4 c/ D1 x8 M0 R( X2 z# U. P$ K! S
b. 将列表 li = ["alex", "seven"] 转换成元组5 W5 u6 t( V3 P+ U; B$ Y7 G
li = ["alex", "seven"]0 a* d7 _+ d! u- \
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
* m7 `! k" P! B4 |1 `* d3 atu = ('Alex', "seven")
* X0 P+ a0 Z- N# y; X0 H' mli=list(tu)
% N& d! e' |* s* u. qprint(li)
/ A" |& a. J& c9 T& s5 _4 E' ~' e. H" v. i- {% |& \
8 V3 ]9 a9 @% A  o' S, J
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 z, i' K8 m- |  ^- a; m5 v0 C/ @6 ~  A8 G- A' t' f- L" I
dic={}8 t! U* R. H' x; F
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
' f. i- |6 V6 F# V: V: O dic[k]=v
6 o9 Z* f! K1 I print(dic)27、转码n = "老男孩"
$ Y% Y- u" [8 qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! l1 z7 B0 Q) ua=n.encode('utf-8')
# {) I/ n+ ]- tprint(a)- x; F0 D0 H; f  T8 P  r
b=a.decode('utf-8')
  m5 i$ `1 ~. S/ a* b' y2 ~4 Qprint(b)2 j8 K& @9 v9 D6 c& [
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
6 I$ B: V6 o- M' k7 Dprint(a)2 I9 n, G# l7 e
b=a.decode('gbk')
( ^1 x5 p9 C( U) D' Sprint(b)28、求 1-100 内的所有数的和
  W# x9 g2 D$ D) R, [1 O* lcount=1$ M; b3 P" R9 w$ k1 N
sum=0- w, d1 a0 W& r$ d
for i in range(100) :
1 K/ b3 d# K$ n4 V sum=sum+count8 Q& c6 k8 Q/ O' `( N
count+=1
  r" a% V- }# S- [print(sum)5 E! M5 t8 B  t9 N* g  B
, g* e( l3 B4 a/ r4 [+ N
count=1
% e' u9 [, O6 ~# O: }+ v  esum=0
2 o6 a0 H8 ~. l) o. |while count<=100 :
* N2 G; L2 ~8 ?1 i- p sum+=count% R6 B* f$ y' X1 z  g- y: v
count+=1" l$ }; f* A# g2 V* A6 r2 C
print(sum)29、元素分类# r: _7 N& S2 i0 G/ B
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& q4 v4 A5 }- \/ }& z1 E  g7 f将小于 66 的值保存至第二个 key 的值中。* Y& F: O! B: U  X7 J
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
6 @4 n. J" L2 M: O0 Dli=[11,22,33,44,55,66,77,88,99,90]6 J/ }; i$ Z: I1 l  v- U- o. w  ]
dic1={6 @, r) o. U2 q1 d6 s/ x
'max':[],
, ?1 z4 k9 [6 b  i, T7 ` 'min':[]
0 d! S+ I1 D7 g0 U}
; B3 J, ], c" H% x: L" Vfor i in li :
1 U, V) @; P0 Z  j5 | if i <66 :7 N0 X0 U/ r- l5 e
      dic1['min'].append(i)8 u' m+ ]) Q9 E! \# M! c( A
else:
9 ?4 }+ f) x, Z3 J* H- U8 l7 _       dic1['max'].append(i)
7 f2 b: [8 q3 h/ i9 G1 s* kprint(dic1)  L$ m1 F* m$ d% `7 v1 A

1 }+ S; t6 r. O+ ?---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
6 ^* s1 b7 h4 ?, F5 ^3 G

Python基础知识汇总

主题推荐